// ----------------------------------------------------- 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; }