int main(int argc, char *argv[]) {
if(argc != 3) {
printf("usage: c10k <parallel-connections> <roundtrip-count>\n");
return 1;
}
long conns = atol(argv[1]);
long roundtrips = atol(argv[2]);
assert(conns >= 1);
tcpsock ls = tcplisten(iplocal("127.0.0.1", 5555, 0), 10);
assert(ls);
int i;
for(i = 0; i != conns - 1; ++i) {
go(connector());
tcpsock as = tcpaccept(ls, -1);
assert(as);
}
go(sender(roundtrips));
tcpsock as = tcpaccept(ls, -1);
assert(as);
int64_t start = now();
char buf[1];
size_t nbytes;
for(i = 0; i != roundtrips; ++i) {
nbytes = tcpsend(as, "A", 1, -1);
assert(errno == 0);
assert(nbytes == 1);
tcpflush(as, -1);
assert(errno == 0);
nbytes = tcprecv(as, buf, 1, -1);
assert(errno == 0);
assert(nbytes == 1);
assert(buf[0] == 'A');
}
int64_t stop = now();
long duration = (long)(stop - start);
long us = (duration * 1000) / roundtrips;
printf("done %ld roundtrips in %f seconds\n",
roundtrips, ((float)duration) / 1000);
printf("duration of a single roundtrip: %ld us\n", us);
printf("roundtrips per second: %ld\n",
(long)(roundtrips * 1000 / duration));
return 0;
}
int main(int argc, char *argv[]) {
int port = 5555;
if(argc > 1)
port = atoi(argv[1]);
tcpsock ls = tcplisten(iplocal(NULL, port, 0));
if(!ls) {
perror("Can't open listening socket");
return 1;
}
while(1) {
tcpsock as = tcpaccept(ls, -1);
tcpsend(as, "What's your name?\r\n", 19, -1);
tcpflush(as, -1);
char inbuf[256];
size_t sz = tcprecvuntil(as, inbuf, sizeof(inbuf), "\r", 1, -1);
inbuf[sz - 1] = 0;
char outbuf[256];
int rc = snprintf(outbuf, sizeof(outbuf), "Hello, %s!\n", inbuf);
sz = tcpsend(as, outbuf, rc, -1);
tcpflush(as, -1);
tcpclose(as);
}
}
int main() {
tcpsock ls = tcplisten("*:5555");
assert(ls);
go(client());
tcpsock as = tcpaccept(ls);
tcpsend(as, "ABC", 3);
int rc = tcpflush(as);
assert(rc == 0);
char buf[16];
ssize_t sz = tcprecvuntil(as, buf, sizeof(buf), '\n');
assert(sz == 4);
assert(buf[0] == '1' && buf[1] == '2' && buf[2] == '3' && buf[3] == '\n');
sz = tcprecvuntil(as, buf, sizeof(buf), '\n');
assert(sz == 3);
assert(buf[0] == '4' && buf[1] == '5' && buf[2] == '\n');
sz = tcprecvuntil(as, buf, 3, '\n');
assert(sz == 0);
assert(buf[0] == '6' && buf[1] == '7' && buf[2] == '8');
tcpclose(as);
tcpclose(ls);
return 0;
}
int main(int argc, char *argv[])
{
int port = 5555;
if(argc > 1)
port = atoi(argv[1]);
ipaddr addr = iplocal(NULL, port, 0);
tcpsock ls = tcplisten(addr, 10);
if(!ls)
{
perror("Can't open listening socket");
return 1;
}
while(1)
{
tcpsock as = tcpaccept(ls, -1);
printf("New connection!\n");
tcpsend(as, "What's your name?\r\n", 19, -1);
tcpflush(as, -1);
tcpclose(as);
}
return 0;
}
int main(int argc, char *argv[]) {
int port = 5555;
if (argc > 1) {
port = atoi(argv[1]);
}
// create a communication channel
chan channel = chmake(int, 0);
go(channel_handler(channel));
// create server that listens and routes traffic to handler function
ipaddr addr = iplocal(NULL, port, 0);
tcpsock ls = tcplisten(addr);
if (!ls) {
perror("Can't open listening socket");
return 1;
}
while(1) {
tcpsock accepted_socket = tcpaccept(ls, -1);
if (!accepted_socket) {
continue;
} else {
go(handler(accepted_socket, channel));
}
// temporary stop gap :)
if (test == 3) {
break;
}
}
return 0;
}
int
fdproc_accept(int fd)
{
int newfd = tcpaccept(fd);
//if (newfd >= 0) {};
if (newfd > maxfd) {
maxfd = newfd;
}
return newfd;
}
void matoslaserv_serve(int epoll_fd,int count,struct epoll_event *pdesc) {
//uint32_t now=main_time();
serventry *eptr,*weptr;
int ns;
weptr = (serventry *)pdesc[count].data.ptr;
if ((weptr->listen_sock == 1) && (pdesc[count].events & EPOLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
MFSLOG(LOG_INFO,"Master<->sla socket: accept error: %m");
} else {
struct epoll_event ev;
tcpnonblock(ns);
tcpnodelay(ns);
eptr = (serventry *)malloc(sizeof(serventry));
eptr->next = matoslaservhead;
matoslaservhead = eptr;
eptr->sock = ns;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 120;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->listen_sock = 0;
eptr->connection = 4;
ev.data.ptr = eptr;
ev.events = EPOLLIN | EPOLLOUT;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD,ns,&ev);
}
}
if(weptr->listen_sock == 0) {
if (pdesc[count].events & (EPOLLERR|EPOLLHUP)) {
weptr->mode = KILL;
}
if ((pdesc[count].events & EPOLLIN) && weptr->mode!=KILL) {
matoslaserv_read(weptr);
weptr->lastread = get_current_time();
}
if ((pdesc[count].events & EPOLLOUT) && weptr->mode!=KILL && weptr->outputhead!=NULL) {
matoslaserv_write(weptr);
weptr->lastwrite = get_current_time();
}
}
}
/*
* add by ning
* */
int tcptoaccept(int sock, uint32_t msecto) {
struct pollfd pfd;
pfd.fd = sock;
pfd.events = POLLIN;
if (poll(&pfd,1,msecto)<0) {
return -1;
}
if (pfd.revents & POLLIN) {
return tcpaccept(sock);
} else {
errno = ETIMEDOUT;
return -1;
}
}
int main() {
char buf[16];
tcpsock ls = tcplisten(iplocal(NULL, 5555, 0), 10);
assert(ls);
int fd = tcpdetach(ls);
assert(fd != -1);
ls = tcpattach(fd, 1);
assert(ls);
assert(tcpport(ls) == 5555);
go(client(5555));
tcpsock as = tcpaccept(ls, -1);
/* Test deadline. */
int64_t deadline = now() + 30;
size_t sz = tcprecv(as, buf, sizeof(buf), deadline);
assert(sz == 0 && errno == ETIMEDOUT);
int64_t diff = now() - deadline;
assert(diff > -20 && diff < 20);
sz = tcpsend(as, "ABC", 3, -1);
assert(sz == 3 && errno == 0);
tcpflush(as, -1);
assert(errno == 0);
sz = tcprecvuntil(as, buf, sizeof(buf), "\n", 1, -1);
assert(sz == 4);
assert(buf[0] == '1' && buf[1] == '2' && buf[2] == '3' && buf[3] == '\n');
sz = tcprecvuntil(as, buf, sizeof(buf), "\n", 1, -1);
assert(sz == 3);
assert(buf[0] == '4' && buf[1] == '5' && buf[2] == '\n');
sz = tcprecvuntil(as, buf, 3, "\n", 1, -1);
assert(sz == 3);
assert(buf[0] == '6' && buf[1] == '7' && buf[2] == '8');
tcpclose(as);
tcpclose(ls);
return 0;
}
int main(int argc, char *argv[]) {
int port = 5555;
if(argc > 1)
port = atoi(argv[1]);
ipaddr addr = iplocal(NULL, port, 0);
tcpsock ls = tcplisten(addr, 10);
if(!ls) {
perror("Can't open listening socket");
return 1;
}
while(1) {
tcpsock as = tcpaccept(ls, -1);
if(!as)
continue;
go(dialogue(as));
}
}
int main(int argc, char *argv[]) {
int port = 5555;
int nproc = 1;
if(argc > 1)
port = atoi(argv[1]);
if(argc > 2)
nproc = atoi(argv[2]);
ipaddr addr = iplocal(NULL, port, 0);
tcpsock ls = tcplisten(addr, 10);
if(!ls) {
perror("Can't open listening socket");
return 1;
}
int i;
for (i = 0; i < nproc - 1; ++i) {
pid_t pid = fork();
if(pid < 0) {
perror("Can't create new process");
return 1;
}
if(pid > 0)
break;
}
chan ch = chmake(int, 0);
go(statistics(ch));
while(1) {
tcpsock as = tcpaccept(ls, -1);
if(!as)
continue;
go(dialogue(as, ch));
}
}
void matomlserv_serve(struct pollfd *pdesc) {
uint32_t now=main_time();
matomlserventry *eptr,**kptr;
packetstruct *pptr,*paptr;
int ns;
static uint64_t lastaction = 0;
uint64_t unow;
uint32_t timeoutadd;
if (lastaction==0) {
lastaction = main_precise_utime();
}
if (lsockpdescpos>=0 && (pdesc[lsockpdescpos].revents & POLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
mfs_errlog_silent(LOG_NOTICE,"Master<->ML socket: accept error");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
eptr = malloc(sizeof(matomlserventry));
passert(eptr);
eptr->next = matomlservhead;
matomlservhead = eptr;
eptr->sock = ns;
eptr->pdescpos = -1;
eptr->mode = HEADER;
eptr->lastread = now;
eptr->lastwrite = now;
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 10;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matomlserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->chain1fd=-1;
eptr->chain2fd=-1;
eptr->logindex=-1;
eptr->logf=NULL;
eptr->currentversion=0;
}
}
// read
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if (eptr->pdescpos>=0) {
if (pdesc[eptr->pdescpos].revents & (POLLERR|POLLHUP)) {
eptr->mode = KILL;
}
if ((pdesc[eptr->pdescpos].revents & POLLIN) && eptr->mode!=KILL) {
eptr->lastread = now;
matomlserv_read(eptr);
}
}
}
// timeout fix
unow = main_precise_utime();
timeoutadd = (unow-lastaction)/1000000;
if (timeoutadd) {
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
eptr->lastread += timeoutadd;
}
}
lastaction = unow;
// write
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if ((uint32_t)(eptr->lastwrite+(eptr->timeout/3))<(uint32_t)now && eptr->outputhead==NULL) {
matomlserv_createpacket(eptr,ANTOAN_NOP,0);
}
if (eptr->pdescpos>=0) {
if ((((pdesc[eptr->pdescpos].events & POLLOUT)==0 && (eptr->outputhead)) || (pdesc[eptr->pdescpos].revents & POLLOUT)) && eptr->mode!=KILL) {
eptr->lastwrite = now;
matomlserv_write(eptr);
}
if (eptr->mode!=KILL && eptr->logf && eptr->outputhead==NULL) {
matomlserv_send_old_changes(eptr, eptr->currentversion);
}
}
if ((uint32_t)(eptr->lastread+eptr->timeout)<(uint32_t)now) {
eptr->mode = KILL;
}
}
// close
kptr = &matomlservhead;
while ((eptr=*kptr)) {
if (eptr->mode == KILL) {
matomlserv_beforeclose(eptr);
tcpclose(eptr->sock);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
if (eptr->servstrip) {
free(eptr->servstrip);
}
*kptr = eptr->next;
free(eptr);
} else {
kptr = &(eptr->next);
}
}
}
void masterconn_serve(int epoll_fd,int count,struct epoll_event *pdesc) {
//uint32_t now=main_time();
serventry *weptr = NULL,*eptr = NULL;
int ns;
int ret;
struct epoll_event ev;
if(ismaster()) {
return;
}
weptr = (serventry *)pdesc[count].data.ptr;
if ((weptr->listen_sock == 1) && (pdesc[count].events & EPOLLIN) && (weptr->mode != KILL)) {
ns = tcpaccept(lsock);
if (ns<0) {
MFSLOG(LOG_INFO,"master sync thread<->shadow master socket: accept error: %m");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
master_serve = (serventry *)malloc(sizeof(serventry));
eptr = master_serve;
eptr->sock = ns;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->downloading = 0;
eptr->metafd=-1;
eptr->logfd=NULL;
eptr->listen_sock = 0;
eptr->connection = 3;
ev.data.ptr = eptr;
ev.events = EPOLLIN;
ret = epoll_ctl(epoll_fd,EPOLL_CTL_ADD,ns,&ev);
if (ret < 0) {
MFSLOG(LOG_NOTICE,"add epoll fail");
}
}
}
if (weptr->listen_sock == 0) {
if (weptr->mode == CONNECTING) {
if (pdesc[count].events & (EPOLLHUP | EPOLLERR)) {
masterconn_connecttest(weptr);
}
if (pdesc[count].events & EPOLLOUT) {
masterconn_connecttest(weptr);
}
} else {
if ((pdesc[count].events & (EPOLLHUP | EPOLLERR)) && (weptr->mode != KILL)) {
MFSLOG(LOG_NOTICE, "set to NULL");
weptr->mode = KILL;
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && (pdesc[count].events & EPOLLIN)) { // FD_ISSET(eptr->sock,rset)) {
masterconn_read(weptr);
weptr->lastread = get_current_time();
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && (pdesc[count].events & EPOLLOUT)) { // FD_ISSET(eptr->sock,wset)) {
masterconn_write(weptr);
weptr->lastwrite = get_current_time();
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && weptr->lastread+Timeout<get_current_time()) {
MFSLOG(LOG_NOTICE, "set to NULL");
weptr->mode = KILL;
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && weptr->lastwrite+5<get_current_time()
&& weptr->outputhead==NULL) {
masterconn_createpacket(weptr,ANTOAN_NOP,0);
}
}
}
}
wsock wsockaccept(wsock s, int64_t deadline) {
int err = 0;
if(!(s->flags & WSOCK_LISTENING)) {err = EOPNOTSUPP; goto err0;}
struct wsock *as = (struct wsock*)malloc(sizeof(struct wsock));
if(!as) {err = ENOMEM; goto err0;}
as->flags = 0;
as->u = tcpaccept(s->u, deadline);
if(errno != 0) {err = errno; goto err1;}
wsock_str_init(&as->url, NULL, 0);
wsock_str_init(&as->subprotocol, NULL, 0);
/* Parse request. */
char buf[256];
size_t sz = wsock_getline(as, buf, sizeof(buf), deadline);
if(sz < 0) {err = errno; goto err2;}
char *lend = buf + sz;
char *wstart = buf;
char *wend = (char*)memchr(buf, ' ', lend - wstart);
if(!wend || wend - wstart != 3 || memcmp(wstart, "GET", 3) != 0) {
err = EPROTO; goto err2;}
wstart = wend + 1;
wend = (char*)memchr(wstart, ' ', lend - wstart);
if(!wend) {err = EPROTO; goto err2;}
wsock_str_init(&as->url, wstart, wend - wstart);
wstart = wend + 1;
wend = (char*)memchr(wstart, ' ', lend - wstart);
if(wend || lend - wstart != 8 || memcmp(wstart, "HTTP/1.1", 8) != 0) {
err = EPROTO; goto err2;}
int hasupgrade = 0;
int hasconnection = 0;
int haskey = 0;
int hassubprotocol = 0;
const char *subprotocol = NULL;
size_t subprotocolsz = 0;
struct wsock_sha1 sha1;
while(1) {
sz = wsock_getline(as, buf, sizeof(buf), deadline);
if(sz < 0) {err = errno; goto err2;}
if(sz == 0)
break;
lend = buf + sz;
char *nstart = buf;
char *nend = (char*)memchr(buf, ' ', lend - nstart);
if(!nend || nend - nstart < 1 || nend[-1] != ':') {
err = EPROTO; goto err2;}
size_t nsz = nend - nstart - 1;
char *vstart = nend + 1;
char *vend = (char*)memchr(vstart, ' ', lend - vstart);
if(vend) {err = EPROTO; goto err2;}
size_t vsz = lend - vstart;
if(nsz == 7 && memcmp(nstart, "Upgrade", 7) == 0) {
if(hasupgrade || vsz != 9 || memcmp(vstart, "websocket", 9) != 0) {
err = EPROTO; goto err2;}
hasupgrade = 1;
continue;
}
if(nsz == 10 && memcmp(nstart, "Connection", 10) == 0) {
if(hasconnection || vsz != 7 || memcmp(vstart, "Upgrade", 7) != 0) {
err = EPROTO; goto err2;}
hasconnection = 1;
continue;
}
if(nsz == 17 && memcmp(nstart, "Sec-WebSocket-Key", 17) == 0) {
if(haskey) {err = EPROTO; goto err2;}
wsock_sha1_init(&sha1);
int i;
for(i = 0; i != vsz; ++i)
wsock_sha1_hashbyte(&sha1, vstart[i]);
const char *uuid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
for(i = 0; i != 36; ++i)
wsock_sha1_hashbyte(&sha1, uuid[i]);
haskey = 1;
continue;
}
if(nsz == 22 && memcmp(nstart, "Sec-WebSocket-Protocol", 22) == 0) {
/* TODO: RFC6455, section 11.3.4 allows for multiple instances of
this field. */
if(hassubprotocol) {err = EPROTO; goto err2;}
const char *available = wsock_str_get(&s->subprotocol);
if(available) {
subprotocol = wsock_hassubprotocol(available, vstart, vsz,
&subprotocolsz);
if(!subprotocol) {err = EPROTO; goto err2;}
}
else {
subprotocol = vstart;
subprotocolsz = vsz;
}
hassubprotocol = 1;
wsock_str_init(&as->subprotocol, subprotocol, subprotocolsz);
continue;
}
}
if(!hasupgrade || !hasconnection || !haskey) {err = EPROTO; goto err2;}
/* If the subprotocol was not specified by the client, we still want to
use one of the suerver-supported protocols locally. */
if(!subprotocol) {
const char *available = wsock_str_get(&s->subprotocol);
if(available) {
size_t asz = 0;
while(available[asz] != 0 && available[asz] != ',')
++asz;
wsock_str_init(&as->subprotocol, available, asz);
}
}
/* Send reply. */
const char *lit1 =
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: ";
tcpsend(as->u, lit1, strlen(lit1), deadline);
if(errno != 0) {err = errno; goto err2;}
char key[32];
wsock_sha1_result(&sha1);
sz = wsock_base64_encode(wsock_sha1_result(&sha1), 20, key, sizeof(key));
assert(sz > 0);
tcpsend(as->u, key, sz, deadline);
if(errno != 0) {err = errno; goto err2;}
if(hassubprotocol) {
tcpsend(as->u, "\r\nSec-WebSocket-Protocol: ", 26, deadline);
if(errno != 0) {err = errno; goto err2;}
tcpsend(as->u, subprotocol, subprotocolsz, deadline);
if(errno != 0) {err = errno; goto err2;}
}
tcpsend(as->u, "\r\n\r\n", 4, deadline);
if(errno != 0) {err = errno; goto err2;}
tcpflush(as->u, deadline);
if(errno != 0) {err = errno; goto err2;}
return as;
err2:
tcpclose(as->u);
err1:
free(as);
err0:
errno = err;
return NULL;
}
BCPLWORD callc(BCPLWORD *args, BCPLWORD *g) {
int rc = 0;
BCPLWORD fno = args[0];
//printf("\nCallc: fno = %d\n", fno);
switch(fno) {
default:
return -1;
case c_name2ipaddr: // name => ipaddr (host format)
b2c_str(args[1], namebuf);
//printf("Callc c_name2ipaddr: args[1]=%d %s\n",
// args[1], namebuf);
return name2ipaddr(namebuf);
case c_name2port: // name => port (host format)
b2c_str(args[1], namebuf);
//printf("callc c_name2port: %s\n", namebuf);
return name2port(namebuf);
case c_newsocket: // Allocate a new socket
return newsocket();
case c_reuseaddr: // Reuse address
return reuseaddr((int)args[1], (int)args[2]);
case c_setsndbufsz: // Set the send buffer size
return setsndbufsz((int)args[1], (int)args[2]);
case c_setrcvbufsz: // Set the recv buffer size
return setrcvbufsz((int)args[1], (int)args[2]);
case c_tcpbind: // Bind a socket to a given ipaddr/port
//printf("c_tcpbind: %d %08x %d\n", args[1], args[2], args[3]);
return tcpbind((int)args[1], (int)args[2], (int)args[3]);
case c_tcpconnect: // Connect a socket to a given ipaddr/port
//printf("tcpconnect %d %08x %d\n", args[1], args[2], args[3]);
return tcpconnect((int)args[1], (int)args[2], (int)args[3]);
case c_tcplisten: // Cause a socket to listen
return tcplisten((int)args[1], (int)args[2]);
case c_tcpaccept: // Cause a socket to accept a connection
return tcpaccept((int)args[1]);
case c_tcpclose: // Close a connection
//printf("tcpclose %d\n", args[1]);
return close((int)args[1]);
case c_fd_zero: // Clear all bits in an fd_set
{ //fd_set *bits = (fd_set*)&W[args[2]];
FD_ZERO((fd_set*)&W[args[1]]);
return 0;
}
case c_fd_set: // Set a bit in an fd_set
//printf("c_fd_set: args[1]=%d args[2]=%d\n", args[1], args[2]);
FD_SET((int)args[1], (fd_set*)&W[args[2]]);
return 0;
case c_fd_isset: // Test a bit in an fd_set
return FD_ISSET((int)args[1], (fd_set*)&W[args[2]]);
case c_select: // Call the select function
{ int i, rc;
int s = (int) args[1];
fd_set *rd_set = (fd_set *) &W[args[2]];
fd_set *wr_set = (fd_set *) &W[args[3]];
fd_set *er_set = (fd_set *) &W[args[4]];
struct timeval *timeval = (struct timeval *)
((args[5]==0) ? NULL : &W[args[5]]);
/*
//for(i=0; i<10;i++)
// printf("callc: rdset bit %d = %d\n",
i, FD_ISSET(i, (fd_set*)&W[args[2]]));
*/
//printf("callc: calling select(%d,%d,%d,%d,%d)\n",
// args[1],args[2],args[3],args[4],args[5]);
//if(timeval) {
//printf("c_select: tv_sec = %d\n", timeval->tv_sec);
//printf("c_select: tv_usec = %d\n", timeval->tv_usec);
//}
rc = select(s, rd_set, wr_set, er_set, timeval);
if(rc==-1) perror("select returned error");
//printf("\ncallc: select => rc = %d\n", rc);
//for(i=0; i<10;i++)
// printf("callc: rdset bit %d = %d\n",
// i, FD_ISSET(i, rd_set));
return rc;
}
case c_recv: // Call the recv(s, buf, len, flags)
{ int s = (int)args[1];
char *buf = (char*)&W[args[2]];
int len = (int)args[3];
int flags = (int)args[4];
int rc = 0;
//printf("cfuncs: Calling recv(%d, %d, %d, %d)\n",
// args[1], args[2], args[3], args[4]);
rc = recv(s, buf, len, flags);
if(rc==-1)perror("recv returned error");
//printf("cfuncs: recv returned rc=%d\n", rc);
return rc;
}
case c_send: // Call the send(s, buf, len, flags)
{ int s = (int)args[1];
char *buf = (char*)&W[args[2]];
int len = (int)args[3];
int flags = (int)args[4];
int rc = 0;
//printf("cfuncs: Calling send(%d, %d, %d, %d)\n",
// args[1], args[2], args[3], args[4]);
rc = send(s, buf, len, flags);
if(rc==-1)perror("send returned error");
//printf("cfuncs: send returned rc=%d\n", rc);
return rc;
}
case c_read: // Call the read(s, buf, len)
{ int s = (int)args[1];
char *buf = (char*)&W[args[2]];
int len = (int)args[3];
int rc = 0;
//printf("cfuncs: Calling read(%d, %d, %d)\n", args[1], args[2], args[3]);
rc = read(s, buf, len);
//if(rc==-1)perror("read returned error");
//printf("cfuncs: read returned rc=%d\n", rc);
return rc;
}
case c_write: // Call the write(s, buf, len)
{ int s = (int) args[1];
char *buf = (char*) &W[args[2]];
int len = (int) args[3];
int rc = 0;
//printf("cfuncs: Calling write(%d, %d, %d)\n", args[1], args[2], args[3]);
rc = write(s, buf, len);
if(rc==-1)perror("read returned error");
//printf("cfuncs: read returned rc=%d\n", rc);
return rc;
}
}
}
void csserv_serve(struct pollfd *pdesc) {
double now;
csserventry *eptr,**kptr;
packetstruct *pptr,*paptr;
int ns;
now = monotonic_seconds();
if (lsockpdescpos>=0 && (pdesc[lsockpdescpos].revents & POLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
mfs_errlog_silent(LOG_NOTICE,"accept error");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
eptr = malloc(sizeof(csserventry));
passert(eptr);
eptr->next = csservhead;
csservhead = eptr;
eptr->state = IDLE;
eptr->mode = HEADER;
eptr->sock = ns;
eptr->pdescpos = -1;
eptr->lastread = now;
eptr->lastwrite = now;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->jobid = 0;
eptr->idlejobs = NULL;
}
}
for (eptr=csservhead ; eptr ; eptr=eptr->next) {
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & (POLLERR|POLLHUP))) {
eptr->state = CLOSE;
}
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & POLLIN) && eptr->state==IDLE) {
eptr->lastread = now;
csserv_read(eptr);
}
if (eptr->state==IDLE && eptr->lastwrite+(CSSERV_TIMEOUT/3.0)<now && eptr->outputhead==NULL) {
csserv_create_packet(eptr,ANTOAN_NOP,0);
}
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & POLLOUT) && eptr->state==IDLE) {
eptr->lastwrite = now;
csserv_write(eptr);
}
if (eptr->state==IDLE && eptr->lastread+CSSERV_TIMEOUT<now) {
// syslog(LOG_NOTICE,"csserv: connection timed out");
eptr->state = CLOSE;
}
}
kptr = &csservhead;
while ((eptr=*kptr)) {
if (eptr->state == CLOSE) {
tcpclose(eptr->sock);
csserv_close(eptr);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
// wptr = eptr->todolist;
// while (wptr) {
// waptr = wptr;
// wptr = wptr->next;
// free(waptr);
// }
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
*kptr = eptr->next;
free(eptr);
} else {
kptr = &(eptr->next);
}
}
}
