// -----------------------------------------------------
long
tcp_manager::doRPC (ptr<location> from, ptr<location> l,
const rpc_program &prog, int procno,
ptr<void> in, void *out, aclnt_cb cb,
cbtmo_t cb_tmo)
{
// hack to avoid limit on wrap()'s number of arguments
RPC_delay_args *args = New RPC_delay_args (from, l, prog, procno,
in, out, cb, NULL);
if (chord_rpc_style == CHORD_RPC_SFSBT) {
tcpconnect (l->saddr ().sin_addr, ntohs (l->saddr ().sin_port),
wrap (this, &tcp_manager::doRPC_tcp_connect_cb, args));
} else {
hostinfo *hi = lookup_host (l->address ());
if (hi->fd == -2) { //no connect initiated
// weird: tcpconnect wants the address in NBO, and port in HBO
hi->fd = -1; // signal pending connect
tcpconnect (l->saddr ().sin_addr, ntohs (l->saddr ().sin_port),
wrap (this, &tcp_manager::doRPC_tcp_connect_cb, args));
} else if (hi->fd == -1) { //connect pending, add to waiters
hi->connect_waiters.push_back (args);
} else if (hi->fd > 0) { //already connected
send_RPC (args);
}
}
return 0;
}
static coroutine void connector(void) {
tcpsock s = tcpconnect(iplocal("127.0.0.1", 5555, 0), -1);
assert(s);
char buf[1];
tcprecv(s, buf, 1, -1);
assert(0);
}
coroutine void client(int port) {
ipaddr addr = ipremote("127.0.0.1", port, 0, -1);
tcpsock cs = tcpconnect(addr, -1);
assert(cs);
char ipstr[16] = {0};
ipaddrstr(addr, ipstr);
assert(errno == 0);
assert(strcmp(ipstr, "127.0.0.1") == 0);
int fd = tcpdetach(cs);
assert(fd != -1);
cs = tcpattach(fd, 0);
assert(cs);
msleep(now() + 100);
char buf[16];
size_t sz = tcprecv(cs, buf, 3, -1);
assert(sz == 3 && buf[0] == 'A' && buf[1] == 'B' && buf[2] == 'C');
sz = tcpsend(cs, "123\n45\n6789", 11, -1);
assert(sz == 11 && errno == 0);
tcpflush(cs, -1);
assert(errno == 0);
tcpclose(cs);
}
static int tcpip_connect(link_item_t *link, char *argv[], char **errmsg)
{
char *host = argv[0];
char *s_port = strchr(host, ':');
int port;
int sock;
/* Get port number */
if ( s_port == NULL ) {
*errmsg = "Illegal TCP/IP address specification";
return -1;
}
*(s_port++) = '\0';
port = atoi(s_port);
sock = tcpconnect(host, port, 0);
if ( sock == -1 ) {
*errmsg = strerror(errno);
return -1;
}
fcntl(sock, F_SETFL, O_NONBLOCK);
fcntl(sock, F_SETFD, FD_CLOEXEC);
link->fd_in = sock;
link->fd_out = sock;
link->ptr = NULL;
return 0;
}
QBBSd()
{
int udp_sock,
tcp_sock;
fd_set fdmask;
if((udp_sock = udp_open(1)) < 0)
logsyserr("<getconnect> could not get UDP socket");
if((tcp_sock = tcp_open(1)) < 0)
logsyserr("<getconnect> could not get TCP socket");
loginfo("<quakebbs> QuakeBBS v%s Now Running!", QBBS_VERSION);
for(;;)
{
loginfo("<quakebbs> Waiting for TCP connect on %d or UDP connect on %d", config.serv[0].port[0], config.serv[0].port[1]);
FD_ZERO(&fdmask);
FD_SET(udp_sock, &fdmask);
FD_SET(tcp_sock, &fdmask);
if(select(1+((tcp_sock > udp_sock) ? tcp_sock : udp_sock), &fdmask, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0)
logerr("<getconnect> select failed");
if(FD_ISSET(udp_sock, &fdmask))
udpconnect(udp_sock);
if(FD_ISSET(tcp_sock, &fdmask))
tcpconnect(tcp_sock);
}
}
void
sfssrv_proxy::clone (ref<axprt_clone> xc, svccb *sbp)
{
int cfd;
str data;
xc->extract (&cfd, &data);
tcpconnect (host, port, wrap (this, &sfssrv_proxy::mkproxy,
destroyed, cfd, data, sbp));
}
bool checkFailure(const char *checkip) {
int sfd = tcpconnect(checkip, HEARTBEAT_PORT);
if(sfd < 0)
return true;
else {
close(sfd);
return false;
}
}
void client(void) {
tcpsock cs = tcpconnect("127.0.0.1:5555");
assert(cs);
char buf[16];
ssize_t sz = tcprecv(cs, buf, 3);
assert(buf[0] == 'A' && buf[1] == 'B' && buf[2] == 'C');
tcpsend(cs, "123\n45\n6789", 11);
int rc = tcpflush(cs);
assert(rc == 0);
tcpclose(cs);
}
void
hclient_t::run ()
{
struct timespec tsnow = sfs_get_tsnow ();
if (noisy) warn << "run: " << id << "\n";
if (nrunning >= nconcur) {
if (noisy) warn << "queuing: " << id << "\n";
q.push_back (this);
return;
}
nrunning++;
if (noisy) warn << "running: " << id << " (nrunning: " << nrunning << ")\n";
if (noisy) warn << "connecting to: " << host << "\n";
cli_start = tsnow;
tcb = delaycb (timeout, 0, wrap (this, &hclient_t::timed_out, destroyed));
tcpconnect (host, port, wrap (this, &hclient_t::connected, destroyed));
}
static coroutine void sender(long roundtrips) {
tcpsock s = tcpconnect(iplocal("127.0.0.1", 5555, 0), -1);
assert(s);
char buf[1];
int i;
size_t nbytes;
for(i = 0; i != roundtrips; ++i) {
nbytes = tcprecv(s, buf, 1, -1);
assert(errno == 0);
assert(nbytes == 1);
assert(buf[0] == 'A');
nbytes = tcpsend(s, "A", 1, -1);
assert(errno == 0);
assert(nbytes == 1);
tcpflush(s, -1);
assert(errno == 0);
}
}
void mqtt_tcp_connect(char *addr, int port)
{
uip_ip4addr_t remote_ip_addr;
if(uiplib_ipaddrconv(addr, &remote_ip_addr) == 0)
{
resolv_query(addr);
return;
}
else
{
g_mqtt_socket_para.connect_status = SOCKET_CREATE;
g_mqtt_socket_para.fd = tcpconnect(&remote_ip_addr, port, &mqtt_socket_process);
printf("Tcp socket(%d) connectting to [%d.%d.%d.%d:%d]\n", g_mqtt_socket_para.fd,
remote_ip_addr.u8[0], remote_ip_addr.u8[1], remote_ip_addr.u8[2], remote_ip_addr.u8[3], port);
}
}
void client(ipaddr addr, int messages, chan results)
{
int sent = 0;
tcpsock s = tcpconnect(addr, -1);
if (s == NULL) {
perror("tcpconnect");
goto out;
}
while (messages--) {
tcpsend(s, "hello\n", 6, -1);
if (errno != 0) {
perror("tcpsend");
goto out;
}
tcpflush(s, -1);
if (errno != 0) {
perror("tcpflush");
goto out;
}
char buf[100];
size_t sz = tcprecvuntil(s, buf, sizeof(buf), "\n", 1, -1);
if (errno != 0) {
perror("tcprecvuntil");
goto out;
}
buf[sz - 1] = 0;
if (sz != 6) {
fprintf(stderr, "unexpedted return: %s\n", buf);
goto out;
}
sent++;
}
out:
tcpclose(s);
chs(results, int, sent);
}
int client(const char *host, char *buf){
int sock;
sock = tcpconnect(host, CPORT);
if(sock < 0){
close(sock);
return -1;
}
char conbuf[] = "pull\n";
write(sock, conbuf, strlen(conbuf));
int read_size;
char rebuf[BUFLEN];
read_size = read_line(sock, rebuf);
if(read_size != 0){
printf("mes: %s\n", rebuf);
}
subchar(buf, rebuf);
printf("discon - NAT.\n");
close(sock);
return 0;
}
int LinkDstListener::listenAddressChange(const ReplyProposer &rp,
const char *sip, unsigned sport,
const char *oip, unsigned oport){
struct AddressChange ac;
strcpy(ac.name, rp.name);
ac.count = rp.length;
ac.livingcount = 0;
struct ReplyAddress ra;
const int rasize = sizeof(struct ReplyAddress);
strcpy(ra.name, rp.name);
STDCOUT("proposers:");
for(unsigned i = 0; i != ac.count; i++){
strcpy(ac.proposers[i], rp.ip[i]);
STDCOUT(" " << ac.proposers[i]);
ac.sfd[i] = tcpconnect(ac.proposers[i], QUERY_BACKUP_PORT);
if(ac.sfd[i] >= 0){
if(write(ac.sfd[i], &ra, rasize) != rasize){
STDCOUT("(write error)");
}
this->fs->registerFD(ac.sfd[i]);
ac.livingcount++;
}
else{
ac.sfd[i] = -1;
STDCOUT("(connect error)");
}
}
STDCOUT("\n");
strcpy(ac.oldip, oip);
ac.oldport = oport;
strcpy(ac.srcip, sip);
ac.srcport = sport;
if(ac.livingcount == 0)
return -1;
this->listening.push_back(ac);
STDCOUT("listen: living count=" << ac.livingcount << "\n");
return 0;
}
int ircdboost(char *host, int port, char *nick)
{
int sock;
char buf[2048];
char *pt;
printf("Step 2: Connecting to the IRC Server.\n");
sock=tcpconnect(lookup(host),port,10);
if (sock==-1) {
printf("Error: cant connect\n");
exit(0x0);
}
printf("Step 3: Connected.. sending user / join\n");
/* the star is very very important */
writesock(sock,"USER o a a :a\r\n");
snprintf(buf,sizeof(buf),"NICK %s\r\n",nick);
writesock(sock,buf);
snprintf(buf,sizeof(buf),"WHOIS kbnn%d\r\n",lookup(host));
writesock(sock,buf);
/* this joins are needed to broadcast the user to the connected servers */
writesock(sock,"JOIN #sex\r\n"); /* yeah, right */
writesock(sock,"JOIN #showdown\r\n"); /* yeah, right */
writesock(sock,"JOIN #funfactory\r\n"); /* yeah, right */
writesock(sock,"JOIN #usa\r\n"); /* yeah, right */
writesock(sock,"JOIN #flirt.de\r\n"); /* yeah, right */
writesock(sock,"JOIN 0\r\n"); /* yeah, right */
printf("Step 4: Please press control+break to release the split.\n");
while (readsock(sock,buf,sizeof(buf)) >=0)
{
pt=strstr(buf,"PING");
if (pt==buf)
{
writesock(sock,"PONG :PPP\r\n");
}
pt=strstr(buf,"ERROR");
if (pt==buf) break;
printf(buf);
}
close(sock);
}
static int
conalloc(char *iname, char *oname, int keytype)
{
char *namebase, *name, *namelist;
int s;
namebase = namelist = xstrdup(iname);
do {
name = xstrsep(&namelist, ",");
if (!name) {
free(namebase);
return (-1);
}
} while ((s = tcpconnect(name)) < 0);
if (s >= maxfd)
fatal("conalloc: fdno %d too high", s);
if (fdcon[s].c_status)
fatal("conalloc: attempt to reuse fdno %d", s);
debug3("%s: oname %s kt %d", __func__, oname, keytype);
fdcon[s].c_fd = s;
fdcon[s].c_status = CS_CON;
fdcon[s].c_namebase = namebase;
fdcon[s].c_name = name;
fdcon[s].c_namelist = namelist;
fdcon[s].c_output_name = xstrdup(oname);
fdcon[s].c_data = (char *) &fdcon[s].c_plen;
fdcon[s].c_len = 4;
fdcon[s].c_off = 0;
fdcon[s].c_keytype = keytype;
gettimeofday(&fdcon[s].c_tv, NULL);
fdcon[s].c_tv.tv_sec += timeout;
TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
FD_SET(s, read_wait);
ncon++;
return (s);
}
int wait_for_tcpconnect(const char *host, int port, long timeoutsec, long timeoutnano) {
int connect_ret, timeout;
struct timespec begin_time;
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(host);
if (addr.sin_addr.s_addr == INADDR_NONE) {
fprintf(stderr, "Error converting host to inet address: %s\n", host);
return -1;
}
clock_gettime(CLOCK_REALTIME, &begin_time);
do {
connect_ret = tcpconnect(&addr, TCPCONNECT_TO_SEC, TCPCONNECT_TO_USEC);
timeout = _tcpconnect_timeout(&begin_time, timeoutsec, timeoutnano);
} while (connect_ret != 0 && !timeout);
return connect_ret;
}
SEXP
setOK(SEXP PORT, SEXP HOST, SEXP KEY)
{
#ifdef Win32
WSADATA wsaData;
DWORD dw_thread_id;
#endif
char *host = (char *)CHAR(STRING_ELT(HOST, 0));
int port = *(INTEGER(PORT));
const char *key = CHAR(STRING_ELT(KEY, 0));
if(go>0) return(R_NilValue);
#ifdef Win32
WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
tcpconnect(host, port);
go = 1;
#ifdef Win32
t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ok, (LPVOID)key, 0,
&dw_thread_id);
#else
pthread_create(&t, NULL, ok, (void *)key);
#endif
return(R_NilValue);
}
SEXP
setOK(SEXP PORT, SEXP HOST, SEXP KEY, SEXP AUTH)
{
#ifdef Win32
WSADATA wsaData;
DWORD dw_thread_id;
#endif
char authorize[BS];
char buf[BS];
char *host = (char *)CHAR(STRING_ELT(HOST, 0));
int port = *(INTEGER(PORT));
const char *key = CHAR(STRING_ELT(KEY, 0));
const char *auth = CHAR(STRING_ELT(AUTH, 0));
int j,k = strlen(auth);
if(go>0) return(R_NilValue);
#ifdef Win32
WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
tcpconnect(host, port);
go = 1;
/* check for AUTH and authorize if needed */
if(k>0)
{
memset(authorize,0,BS);
snprintf(authorize,BS,"*2\r\n$4\r\nAUTH\r\n$%d\r\n%s\r\n", k, auth);
j = msg(s, authorize, buf);
}
#ifdef Win32
t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ok, (LPVOID)key, 0,
&dw_thread_id);
#else
pthread_create(&t, NULL, ok, (void *)key);
#endif
return(R_NilValue);
}
void
dostuff( str __tame_h, int __tame_port, cbb __tame_cb, ptr<closure_t> __cls_g)
{
ptr<dostuff__closure_t> __cls_r;
dostuff__closure_t *__cls; // speed up to not use smart pointer ?
if (!__cls_g) {
__cls_r = New refcounted<dostuff__closure_t > (__tame_h, __tame_port, __tame_cb);
__cls = __cls_r;
} else {
__cls = reinterpret_cast<dostuff__closure_t *>
(static_cast<closure_t *> (__cls_g));
__cls_r = mkref (__cls);
}
int &fd = __cls->_stack.fd;
ptr< axprt_stream > &x = __cls->_stack.x;
ptr< aclnt > &cli = __cls->_stack.cli;
vec< int > &res = __cls->_stack.res;
vec< clnt_stat > &errs = __cls->_stack.errs;
int &n_tot = __cls->_stack.n_tot;
int &window_sz = __cls->_stack.window_sz;
int &n_out = __cls->_stack.n_out;
int &i = __cls->_stack.i;
int &cid = __cls->_stack.cid;
bool &err = __cls->_stack.err;
join_group_t<int> &RPC = __cls->_stack.RPC;
str &h = __cls->_args.h;
int &port = __cls->_args.port;
cbb &cb = __cls->_args.cb;
switch (__cls->jumpto ()) {
case 1:
goto dostuff__label1;
break;
case 2:
goto dostuff__label2;
break;
default:
break;
}
{
__cls->set_jumpto (1);
// in the case that all calls finish immediately, we still want to
// hold one reference, so that the reference count doesn't go down
// to 0 prematurely.
__cls->_block1 = 1;
tcpconnect (h, port,
(++__cls->_block1,
wrap (__cls_r,
&dostuff__closure_t::cb1<typeof (fd)>,
refset_t<typeof (fd)> (fd))));
// if the reference count is 0 here, that means that all calls returned
// immediately, and there is no need to block; therefore, only block
// (by returning) if there is at least one call outstanding.
if (-- __cls->_block1 )
return;
}
dostuff__label1:
if (fd < 0) {
warn ("%s:%d: connection failed: %m\n", h.cstr(), port);
err = true;
} else {
res.setsize (n_tot);
errs.setsize (n_tot);
x = axprt_stream::alloc (fd);
cli = aclnt::alloc (x, ex_prog_1);
while (n_out < window_sz && i < n_tot) {
n_out ++ ;
cid = i++;
cli->call (EX_RANDOM, NULL, &res[cid],
(RPC.launch_one (),
wrap (__nonblock_cb_1_1<typeof(errs[cid]), typeof (cid)>,
__cls_g,
RPC.make_joiner ("<function location XXX>"),
refset_t<typeof(errs[cid])> (errs[cid]),
value_set_t<typeof(cid)> (cid)
)));
}
while (RPC.need_join ()) {
// JOIN (&RPC, cid) { ...
dostuff__label2:
typeof (RPC.to_vs ()) v;
if (RPC.pending (&v)) {
typeof (v.v1) &cid = v.v1;
--n_out;
if (errs[cid]) {
warn << "RPC error: " << errs[cid] << "\n";
} else {
warn << "Success " << cid << ": " << res[cid] << "\n";
if (i != n_tot) {
n_out ++;
cid = i++;
cli->call (EX_RANDOM, NULL, &res[cid],
(RPC.launch_one (),
wrap (__nonblock_cb_1_1< typeof(errs[cid]),
typeof (cid)>,
__cls_g,
RPC.make_joiner ("<function location YYY>"),
refset_t<typeof(errs[cid])> (errs[cid]),
value_set_t<typeof(cid)> (cid)
)));
}
}
} else {
__cls->_args.h = h;
__cls->_args.port = port;
__cls->_args.cb = cb;
__cls->set_jumpto (2);
RPC.set_join_cb (wrap (__cls_r, &dostuff__closure_t::reenter));
return;
}
}
warn << "All done...\n";
}
(*cb) (!err);
}
/*---------------------------------------------------------------------------*/
int httprequest_send(U8 *httpcmd, U16 cmdlen, void (*fn)(void *))
{
int tmpint;
U8 *ptr1, *ptr2, *end = httpcmd + cmdlen;
if(httpreqdata.httpstatus != HTTP_IDLE)
{
printf("httpstatus:%d\n", httpreqdata.httpstatus);
return HTTPREQ_STILL_RUN;
}
ptr1 = httpcmd;
httpreqdata.rsplen = 0;
httpreqdata.httprsp[0] = 0;
if(memcmp(ptr1, "http://", 7) != 0)
{
printf("1:%s\n", ptr1);
return HTTPREQ_CMD_ERROR;
}
//Go to get remote ip information
ptr1 += 7;
ptr2 = ptr1;
while(ptr2 < end)
{
if((*ptr2 == ':') || (*ptr2 == '/'))
{
if(ptr2 - ptr1 > 16)
return HTTPREQ_STILL_RUN;
else
{
memcpy(httpreqdata.ipstr, ptr1, ptr2 - ptr1);
httpreqdata.ipstr[ptr2 - ptr1] = 0;
ptr1 = ptr2;
if(uiplib_ipaddrconv(httpreqdata.ipstr, &httpreqdata.ip_addr) == 0)
return HTTPREQ_STILL_RUN;
}
break;
}
ptr2++;
}
//Go to check there's port information in command
if(ptr1[0] == ':')
{
ptr1++;
tmpint = 0;
while(ptr1 < end)
{
if('0' <= ptr1[0] && ptr1[0] <= '9')
{
tmpint = tmpint * 10 + ptr1[0] - '0';
ptr1++;
}
else
break;
}
if((ptr1 >= end) || (ptr1[0] != '/') || (tmpint <= 0) || (tmpint >= 65536))
{
printf("2:%s, port:%d\n", ptr1 < end, tmpint);
return HTTPREQ_CMD_ERROR;
}
else
httpreqdata.port = tmpint;
}
else if(ptr1[0] == '/')
{
httpreqdata.port = 80;
}
else
{
printf("3:%s\n", ptr1);
return HTTPREQ_CMD_ERROR;
}
httpreqdata.callbackfn = fn;
//generate http get command
ptr2 = httpreqdata.httpcmd;
memcpy(ptr2 , "GET ", 4); ptr2 += 4;
memcpy(ptr2, ptr1, (end - ptr1)); ptr2 += (end - ptr1);
tmpint = strlen(" HTTP/1.1\r\nHOST: ");
memcpy(ptr2 , " HTTP/1.1\r\nHOST: ", tmpint); ptr2 += tmpint;
memcpy(ptr2 , httpreqdata.ipstr, strlen(httpreqdata.ipstr)); ptr2 += strlen(httpreqdata.ipstr);
tmpint = strlen("\r\nAuthorization: Basic YWRtaW46YWRtaW4=");
memcpy(ptr2 , "\r\nAuthorization: Basic YWRtaW46YWRtaW4=", tmpint); ptr2 += tmpint;
tmpint = strlen("\r\nUser-Agent: ICOMMHTTP/1.0\r\n\r\n");
memcpy(ptr2 , "\r\nUser-Agent: ICOMMHTTP/1.0\r\n\r\n", tmpint); ptr2 += tmpint;
httpreqdata.cmdlen = ptr2 - httpreqdata.httpcmd;
ptr2 = 0;
printf("ip:%s, port:%d, cmd:%s\n", httpreqdata.ipstr, httpreqdata.port, ptr1);
printf("len:%d, cmd:%s\n", httpreqdata.cmdlen, httpreqdata.httpcmd);
httpreqdata.httpsock = tcpconnect( &httpreqdata.ip_addr, httpreqdata.port, &http_req_process);
return HTTPREQ_SUCC;
}
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;
}
}
}
int main(void)
{
struct pollfd sfd[3];
const long timeout=500; //connection timeout in seconds
struct timespec ts_timeout;
int size;
field *pmessage;
fldformat *frm;
isomessage smessage;
GOOGLE_PROTOBUF_VERIFY_VERSION;
frm=loadNetFormat();
if(!frm)
{
printf("Error: Can't load format\n");
return 1;
}
printf("Message format loaded\n");
sfd[2].fd=tcpinit();
if(sfd[2].fd==-1)
{
printf("Error: Unable to start TCP connection\n");
freeFormat(frm);
return 1;
}
sfd[0].fd=ipcopen((char *)"visa");
if(sfd[0].fd==-1)
{
printf("Error: Unable to connect to switch\n");
close(sfd[2].fd);
freeFormat(frm);
return 1;
}
if (signal(SIGINT, catch_sigint) == SIG_ERR)
printf("Warning: unable to set the signal handler\n");
sfd[0].events=POLLIN;
sfd[1].events=POLLIN;
while (1)
{
printf("Waiting for a connection...\n");
errno=0;
sfd[1].fd=tcpconnect(sfd[2].fd);
if(sfd[1].fd==-1)
{
if(sigint_caught)
{
printf("onnection aborted^\n");
break;
}
printf("Connection error: %s\n", strerror(errno));
sleep(1);
continue;
}
printf("Connected.\n");
while (1)
{
printf("Waiting for a message...\n");
ts_timeout.tv_sec=timeout;
ts_timeout.tv_nsec=0;
errno=0;
size=ppoll(sfd, 2, &ts_timeout, NULL);
//printf("poll: %d: %hd, %hd: %s\n", size, sfd[0].revents, sfd[1].revents, strerror(errno));
if(size==-1)
{
if(sigint_caught)
{
printf("losing connection^\n");
break;
}
printf("Error: poll (%hd, %hd): %s\n", sfd[0].revents, sfd[1].revents, strerror(errno));
if(sfd[1].revents)
break;
else
{
usleep(100000);
continue;
}
}
else if(size==0)
{
printf("Error: Connection is inactive, closing it %ld, %ld\n", ts_timeout.tv_sec, ts_timeout. tv_nsec);
break;
}
if(sfd[1].revents & POLLIN)
{
printf("Receiving message from net\n");
size=tcprecvmsg(sfd[1].fd, &pmessage, frm);
if(size==-1)
{
printf("Closing connection\n");
break;
}
else if(size==0)
continue;
print_message(pmessage);
if(isNetMgmt(pmessage))
{
if(isNetRequest(pmessage))
{
if(!processNetMgmt(pmessage))
{
printf("Error: Unable to process Network Management request. Message dropped.\n");
freeField(pmessage);
continue;
}
print_message(pmessage);
size=tcpsendmsg(sfd[1].fd, pmessage);
if(size==-1)
{
printf("Closing connection\n");
freeField(pmessage);
break;
}
else if(size==0)
{
freeField(pmessage);
continue;
}
printf("Network Management Message sent (%d bytes)\n", size);
}
freeField(pmessage);
continue;
}
if(translateNetToSwitch(&smessage, pmessage)!=0)
{
printf("Error: Unable to translate the message to format-independent representation.\n");
if(isNetRequest(pmessage))
{
if(!declineNetMsg(pmessage))
{
printf("Error: Unable to decline the request. Message dropped.\n");
freeField(pmessage);
continue;
}
print_message(pmessage);
size=tcpsendmsg(sfd[1].fd, pmessage);
if(size==-1)
{
printf("Closing connection\n");
freeField(pmessage);
break;
}
else if(size==0)
{
freeField(pmessage);
continue;
}
printf("Decline message sent (%d bytes)\n", size);
}
freeField(pmessage);
continue;
}
printf("Converted message:\n");
smessage.PrintDebugString();
size=ipcsendmsg(sfd[0].fd, &smessage, (char *)"switch");
if(size<=0)
{
printf("Error: Unable to send the message to switch\n");
if(isNetRequest(pmessage))
{
if(!declineNetMsg(pmessage))
{
printf("Error: Unable to decline the request. Message dropped.\n");
freeField(pmessage);
continue;
}
print_message(pmessage);
size=tcpsendmsg(sfd[1].fd, pmessage);
if(size==-1)
{
printf("Closing connection\n");
freeField(pmessage);
break;
}
else if(size==0)
{
freeField(pmessage);
continue;
}
printf("Decline message sent (%d bytes)\n", size);
}
freeField(pmessage);
continue;
}
freeField(pmessage);
printf("Message sent, size is %d bytes.\n", size);
}
if(sfd[0].revents & POLLIN)
{
printf("Receiving message from switch\n");
if(ipcrecvmsg(sfd[0].fd, &smessage)<0)
continue;
printf("\nOutgoingMessage:\n");
smessage.PrintDebugString();
pmessage=translateSwitchToNet(&smessage, frm);
if(!pmessage)
{
printf("Error: Unable to translate the message from format-independent representation.\n");
if(isRequest(&smessage))
{
if(!declineMsg(&smessage))
{
printf("Error: Unable to decline the request. Message dropped.\n");
continue;
}
smessage.PrintDebugString();
size=ipcsendmsg(sfd[0].fd, &smessage, (char *)"switch");
if(size<=0)
{
printf("Error: Unable to return the declined message to switch. Message dropped.\n");
continue;
}
printf("Decline message sent (%d bytes)\n", size);
}
continue;
}
print_message(pmessage);
size=tcpsendmsg(sfd[1].fd, pmessage);
freeField(pmessage);
if(size==-1)
{
printf("Closing connection\n");
if(isRequest(&smessage))
{
if(!declineMsg(&smessage))
{
printf("Error: Unable to decline the request. Message dropped.\n");
continue;
}
smessage.PrintDebugString();
size=ipcsendmsg(sfd[0].fd, &smessage, (char *)"switch");
if(size<=0)
{
printf("Error: Unable to return the declined message to switch. Message dropped.\n");
continue;
}
printf("Decline message sent (%d bytes)\n", size);
}
break;
}
else if(size==0)
{
if(isRequest(&smessage))
{
if(!declineMsg(&smessage))
{
printf("Error: Unable to decline the request. Message dropped.\n");
continue;
}
smessage.PrintDebugString();
size=ipcsendmsg(sfd[0].fd, &smessage, (char *)"switch");
if(size<=0)
{
printf("Error: Unable to return the declined message to switch. Message dropped.\n");
continue;
}
printf("Decline message sent (%d bytes)\n", size);
}
continue;
}
printf("Message sent (%d bytes)\n", size);
}
}
tcpclose(sfd[1].fd);
printf("Disconnected.\n");
if(sigint_caught)
break;
}
tcpclose(sfd[2].fd);
ipcclose(sfd[0].fd);
freeFormat(frm);
google::protobuf::ShutdownProtobufLibrary();
return 0;
}
SEXP SOCK_CONNECT(SEXP HOST, SEXP PORT)
{
char *host = (char *)CHAR(STRING_ELT(HOST, 0));
int port = INTEGER(PORT)[0];
return ScalarInteger(tcpconnect(host, port));
}
int
nsldapi_connect_to_host( LDAP *ld, Sockbuf *sb, char *host, unsigned long address,
int port, int async, int secure )
/*
* if host == NULL, connect using address
* "address" and "port" must be in network byte order
* zero is returned upon success, -1 if fatal error, -2 EINPROGRESS
* if -1 is returned, ld_errno is set
* async is only used ifndef NO_REFERRALS (non-0 means don't wait for connect)
* XXX async is not used yet!
*/
{
void *tcps;
short i;
int err;
InetHostInfo hi;
LDAPDebug( LDAP_DEBUG_TRACE, "connect_to_host: %s:%d\n",
( host == NULL ) ? "(by address)" : host, ntohs( port ), 0 );
/* Initialize OpenTransport, or find out from the host app whether it is installed */
(void)tcp_init();
if ( host != NULL && gethostinfobyname( host, &hi ) != noErr ) {
LDAP_SET_LDERRNO( ld, LDAP_CONNECT_ERROR, NULL, NULL );
return( -1 );
}
if ( ld->ld_socket_fn == NULL ) {
tcps = tcpopen( NULL, TCP_BUFSIZ );
} else {
tcps = ld->ld_socket_fn( AF_INET, SOCK_STREAM, 0 );
}
if ( tcps == NULL ) {
LDAP_SET_LDERRNO( ld, LDAP_LOCAL_ERROR, NULL, NULL );
return( -1 );
}
if ( secure && ld->ld_ssl_enable_fn( tcps ) < 0 ) {
if ( ld->ld_close_fn == NULL ) {
tcpclose( (tcpstream *)tcps );
} else {
ld->ld_close_fn( tcps );
}
LDAP_SET_LDERRNO( ld, LDAP_LOCAL_ERROR, NULL, NULL );
return( -1 );
}
for ( i = 0; host == NULL || hi.addrs[ i ] != 0; ++i ) {
if ( host != NULL ) {
SAFEMEMCPY( (char *)&address, (char *)&hi.addrs[ i ], sizeof( long ));
}
if ( ld->ld_connect_fn == NULL ) {
if ( tcpconnect( tcps, address, port ) == 0 ) {
err = -1;
} else {
err = 0;
}
} else {
struct sockaddr_in sin;
(void)memset( (char *)&sin, 0, sizeof( struct sockaddr_in ));
sin.sin_family = AF_INET;
sin.sin_port = port;
sin.sin_addr.s_addr = address;
err = ld->ld_connect_fn( tcps, (struct sockaddr *)&sin,
sizeof( struct sockaddr_in ));
}
if ( err == 0 ) {
sb->sb_sd = (void *)tcps;
return( 0 );
}
if ( host == NULL ) { /* using single address -- not hi.addrs array */
break;
}
}
LDAPDebug( LDAP_DEBUG_TRACE, "tcpconnect failed\n", 0, 0, 0 );
LDAP_SET_LDERRNO( ld, LDAP_CONNECT_ERROR, NULL, NULL );
LDAP_SET_ERRNO( ld, EHOSTUNREACH ); /* close enough */
if ( ld->ld_close_fn == NULL ) {
tcpclose( (tcpstream *)tcps );
} else {
ld->ld_close_fn( tcps );
}
return( -1 );
}
wsock wsockconnect(ipaddr addr, const char *subprotocol, const char *url,
int64_t deadline) {
/* Check the arguments. */
if(!wsock_checkstring(url))
return NULL;
if(subprotocol) {
if(!wsock_checkstring(subprotocol))
return NULL;
}
/* Open TCP connection. */
int err = 0;
struct wsock *s = (struct wsock*)malloc(sizeof(struct wsock));
if(!s) {err = ENOMEM; goto err0;}
s->flags = WSOCK_CLIENT;
s->u = tcpconnect(addr, deadline);
if(errno != 0) {err = errno; goto err1;}
wsock_str_init(&s->url, url, strlen(url));
wsock_str_init(&s->subprotocol, NULL, 0);
/* Send request. */
tcpsend(s->u, "GET ", 4, deadline);
if(errno != 0) {err = errno; goto err2;}
tcpsend(s->u, url, strlen(url), deadline);
if(errno != 0) {err = errno; goto err2;}
const char *lit1 =
" HTTP/1.1\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Key: ";
tcpsend(s->u, lit1, strlen(lit1), deadline);
if(errno != 0) {err = errno; goto err2;}
uint8_t nonce[16];
int i;
for(i = 0; i != 8; ++i)
((uint16_t*) nonce)[i] = wsock_random() & 0xffff;
char swsk[32];
int swsk_len = wsock_base64_encode(nonce, 16, swsk, sizeof(swsk));
assert(swsk_len > 0);
tcpsend(s->u, swsk, swsk_len, deadline);
if(errno != 0) {err = errno; goto err2;}
if(subprotocol) {
tcpsend(s->u, "\r\nSec-WebSocket-Protocol: ", 26, deadline);
if(errno != 0) {err = errno; goto err2;}
tcpsend(s->u, subprotocol, strlen(subprotocol), deadline);
if(errno != 0) {err = errno; goto err2;}
}
tcpsend(s->u, "\r\n\r\n", 4, deadline);
if(errno != 0) {err = errno; goto err2;}
tcpflush(s->u, deadline);
if(errno != 0) {err = errno; goto err2;}
/* Parse reply. */
char buf[256];
size_t sz = wsock_getline(s, 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 != 8 || memcmp(wstart, "HTTP/1.1", 8) != 0) {
err = EPROTO; goto err2;}
wstart = wend + 1;
wend = (char*)memchr(wstart, ' ', lend - wstart);
if(!wend || wend - wstart != 3 || memcmp(wstart, "101", 3) != 0) {
err = EPROTO; goto err2;}
int hasupgrade = 0;
int hasconnection = 0;
int haskey = 0;
int hassubprotocol = 0;
while(1) {
sz = wsock_getline(s, 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 == 20 && memcmp(nstart, "Sec-WebSocket-Accept", 20) == 0) {
if(haskey) {err = EPROTO; goto err2;}
/* TODO */
haskey = 1;
continue;
}
if(nsz == 22 && memcmp(nstart, "Sec-WebSocket-Protocol", 22) == 0) {
if(hassubprotocol) {err = EPROTO; goto err2;}
for(i = 0; i != vsz; ++i)
if(vstart[i] == ',') {err = EPROTO; goto err2;}
if(!wsock_hassubprotocol(subprotocol, vstart, vsz, NULL)) {
err = EPROTO; goto err2;}
wsock_str_init(&s->subprotocol, vstart, vsz);
hassubprotocol = 1;
continue;
}
}
if(!hasupgrade || !hasconnection || !haskey) {err = EPROTO; goto err2;}
return s;
err2:
tcpclose(s->u);
err1:
free(s);
err0:
errno = err;
return NULL;
}
int main(int argc, char **argv)
{
puts("Mark v5 - C");
switch(argc) {
case 7: maxfiles=atoi(argv[6]);
case 6: moff= atoi(argv[5]);
case 5: nMessages = atoi(argv[4]);
case 4: nClients= atoi(argv[3]);
case 3: port= atoi(argv[2]);
case 2: hostname= argv[1];
break;
case 1:
printf("mark hostname port #clients #connections offset maxfiles");
break;
default: perror("too many arguments"); exit(1);
}
inbuffer= malloc(1000);
outbuffer= malloc(200);
s=tcpconnect(synchost, 4001);
rLen=0;
while (rLen<=0)
rLen= read(s, inbuffer, 5);
// sprintf(outbuffer, "%s\n", message);
puts("Opening connections...");
time0= getMillis();
sock= malloc(nClients * sizeof(int));
for (i=0; i<nClients; i++) {
if (i%100 == 0) printf("%d connections\n",i+1);
if ( (sock[i] = tcpconnect(hostname, port)) == -1)
fatal("Unable to open connection #%d\n", i+1);
if (sock[i]>fd_max) fd_max= sock[i];
}
fd_max++; // safety
msgs= nClients * nMessages;
time1= getMillis();
puts("Sending messages...");
FD_ZERO(&rperm);
count= malloc(fd_max*sizeof(int));
for (k=0; k<nClients; k++) {
filename=((counter+moff)*31)%maxfiles;
counter++;
bLength=sprintf(outbuffer,"ping567890");
//if ( (tmp= write(sock[k], outbuffer, bLength)) != bLength)
//fatal("write: trouble writing data: %d/%d written\n", tmp, bLength);
FD_SET(sock[k],&rperm);
count[sock[k]]= 0;
}
ack= 0;
while (ack < msgs) {
memcpy(&rtemp, &rperm, sizeof(fd_set));
memcpy(&rtemp2, &rperm, sizeof(fd_set));
if (select(fd_max, &rtemp, NULL, &rtemp2, NULL)==-1)
printf("errno: %d",errno);
for (k=3; k<fd_max; k++)
if ((FD_ISSET(k, &rtemp))
||FD_ISSET(k, &rtemp2))
{
if (FD_ISSET(k, &rtemp2))
printf("errorX");
// read
// printf("prepping to read k=%d\n",k);
rLen= read(k, inbuffer, 1000);
if (0) {
// if (rLen!=10) {
if (rLen==-1)
printf("error %d\n",errno);
printf("%d\n",rLen);
printf("%s\n",inbuffer);
printf("\n");
}
// write
ack++;
if (ack%1000 == 0)
printf("Received %d / %d\n", ack, msgs);
close(k);
count[k]=0;
FD_CLR(k,&rperm);
if (counter<(nMessages*nClients)) {
if ( (temp = tcpconnect(hostname, port)) == -1)
fatal("Unable to open connection #%d\n", i+1);
if (temp>=fd_max) fd_max= temp+1;
counter++;
filename=((counter+moff)*31)%maxfiles;
bLength=sprintf(outbuffer,"ping567890");
//if ( (tmp= write(temp, outbuffer, bLength)) != bLength)
//fatal("write: trouble writing data: %d/%d written\n", tmp, bLength);
//printf("Adding %d\n",temp);
FD_SET(temp,&rperm);
}
}
}
time2= getMillis();
printf("\nTest complete:\n\n");
printf("#Clients: %d\n",nClients);
printf("#Messages/ client: %d\n",nMessages);
printf("#Acknowledged: %d\n",ack);
printf("Opening rate: %ld connections/s\n", nClients*1000/(time1-time0) );
printf("Elapsed time: %ld ms",time2-time0);
printf("Throughput: %ld messages/s\n", msgs*1000/(time2-time1) );
printf("Overall: %ld messages/s\n", msgs*1000/(time2-time0) );
for (k=0; k<nClients; k++) close(sock[k]);
return 0;
}
