/*------------------------------------------------------------------------
* tcpout - handle events affecting TCP output processing
*------------------------------------------------------------------------
*/
PROCESS
tcpout(void)
{
struct tcb *ptcb;
int i;
tcps_oport = pcreate(TCPQLEN);
signal(Net.sema); /* synchronize on startup */
while (TRUE) {
i = preceive(tcps_oport);
ptcb = &tcbtab[TCB(i)];
if (ptcb->tcb_state <= TCPS_CLOSED)
continue; /* a rogue; ignore it */
wait(ptcb->tcb_mutex);
if (ptcb->tcb_state <= TCPS_CLOSED)
continue; /* TCB deallocated */
if (EVENT(i) == DELETE) /* same for all states */
tcbdealloc(ptcb);
else
tcposwitch[ptcb->tcb_ostate](TCB(i), EVENT(i));
if (ptcb->tcb_state != TCPS_FREE)
signal(ptcb->tcb_mutex);
}
}
int main(int argc, char *argv[])
{
printf("*****************************\nTest shm\n"
"*****************************\n");
(void)argc;
(void)argv;
const char *c="page_test_shm";
int fid=pcreate(1);
int ret;
int pid=start("test_shm1",10000,getprio(getpid()),(void *)fid);
void *pagep = shm_create(c);
assert(pagep!=NULL);
*((int*)pagep+4)=23;
psend(fid, 1);
preceive(fid,&ret);
printf("[process %i] : %i\n",getpid(),*((int*)pagep+4));
pdelete(fid);
shm_release(c);
waitpid(pid,&ret);
assert(shm_acquire(c)==NULL);
printf("\n*****************************\nTest fini\n"
"*****************************\n");
return 0;
}
/*------------------------------------------------------------------------
* igmp_update - send (delayed) IGMP host group updates
*------------------------------------------------------------------------
*/
PROCESS
igmp_update(void)
{
struct hg *phg;
HostGroup.hi_uport = pcreate(HG_TSIZE);
while (1) {
phg = (struct hg *)preceive(HostGroup.hi_uport);
wait(HostGroup.hi_mutex);
if (phg->hg_state == HGS_DELAYING) {
phg->hg_state = HGS_IDLE;
igmp(IGT_HREPORT, phg->hg_ifnum, phg->hg_ipa);
}
signal(HostGroup.hi_mutex);
}
}
/*------------------------------------------------------------------------
* tcpinp - handle TCP segment coming in from IP
*------------------------------------------------------------------------
*/
PROCESS
tcpinp(void)
{
struct ep *pep;
struct ip *pip;
struct tcp *ptcp;
struct tcb *ptcb;
tcps_iport = pcreate(TCPQLEN);
signal(Net.sema);
while (TRUE) {
pep = (struct ep *)preceive(tcps_iport);
if ((int)pep == SYSERR)
break;
pip = (struct ip *)pep->ep_data;
if (tcpcksum(pep, pip->ip_len - IP_HLEN(pip))) {
++TcpInErrs;
freebuf(pep);
continue;
}
ptcp = (struct tcp *)pip->ip_data;
tcpnet2h(ptcp); /* convert all fields to host order */
pep->ep_order |= EPO_TCP;
ptcb = tcpdemux(pep);
if (ptcb == 0) {
++TcpInErrs;
tcpreset(pep);
freebuf(pep);
continue;
}
if (!tcpok(ptcb, pep))
tcpackit(ptcb, pep);
else {
tcpopts(ptcb, pep);
tcpswitch[ptcb->tcb_state](ptcb, pep);
}
if (ptcb->tcb_state != TCPS_FREE)
signal(ptcb->tcb_mutex);
freebuf(pep);
}
}
/*------------------------------------------------------------------------
* tcpcntl - control function for TCP pseudo-devices
*------------------------------------------------------------------------
*/
int
tcpcntl(struct devsw *pdev, int func, void *arg, void *arg2)
{
struct tcb *ptcb = (struct tcb *)pdev->dvioblk;
int rv;
if (ptcb == NULL || ptcb->tcb_state == TCPS_FREE)
return SYSERR;
wait(ptcb->tcb_mutex);
if (ptcb->tcb_state == TCPS_FREE) /* verify no state change */
return SYSERR;
switch (func) {
case TCPC_ACCEPT: if (ptcb->tcb_type != TCPT_SERVER) {
rv = SYSERR;
break;
}
signal(ptcb->tcb_mutex);
return preceive(ptcb->tcb_listenq);
case TCPC_LISTENQ: rv = tcplq(ptcb, (int)arg);
break;
case TCPC_STATUS: rv = tcpstat(ptcb, (struct tcpstat *)arg);
break;
case TCPC_SOPT:
case TCPC_COPT: rv = tcpuopt(ptcb, func, (u_int)arg);
break;
case TCPC_SENDURG: /*
* tcpwr acquires and releases tcb_mutex
* itself.
*/
signal(ptcb->tcb_mutex);
return tcpwr(pdev, (u_char *)arg,
(unsigned)arg2, TWF_URGENT);
default:
rv = SYSERR;
}
signal(ptcb->tcb_mutex);
return rv;
}
int main(int argc, char *argv[])
{
(void)argv;
int fid=(int)argc;
unsigned long quartz, ticks, freq;
clock_settings(&quartz,&ticks);
freq=quartz/ticks;
while (1){
int jeton;
printf("%i essaye de prendre le jeton\n",getpid());
preceive(fid,&jeton);
printf("%i a pris le jeton %i, "
"l'incremente et le garde un peu\n",
getpid(),
jeton++);
wait_clock(3*freq+current_clock());
printf("%i remet le jeton\n",getpid());
psend(fid,jeton);
wait_clock(1*freq+current_clock());
}
return 0;
}
//------------------------------------------------------------------------
// netout - start network by finding address and forward IP packets
//------------------------------------------------------------------------
PROCESS
netout(int userpid, int icmpp)
{
struct epacket *packet;
struct ip *ipptr;
long tim;
int len;
char name[MNAMELEN];
IPaddr addr;
getaddr(addr);
gettime(&tim);
getname(name, MNAMELEN);
resume(userpid);
while (TRUE) {
packet = (struct epacket *)preceive(icmpp);
ipptr = (struct ip *)packet->ep_data;
memmove(addr, ipptr->i_dest, IPLEN);
len = net2hs(ipptr->i_paclen) - IPHLEN;
ipsend(addr, packet, len);
}
}
unsigned long cons_read(char *string, unsigned long length)
{
if (!(ADDR_VALIDE(string)))
return -1;
wait(sem);
for(icour=0; icour<length; icour++){
int msg;
preceive(fid_keyboard,&msg,1);
if (msg==13) {
signal(sem);
return icour;
} else if (msg==127 && icour>0) {
string[--icour]=0;
icour--;
} else if (msg!=127){
string[icour]=msg;
} else {
icour--;
}
}
signal(sem);
return length;
}
/** Implémentation de verrous en se basant sur les files de message. */
void xwait(struct sem *s)
{
assert(preceive(s->fid, 0) == 0);
}
