/* iperf_tcp_accept * * accept a new TCP stream connection */ int iperf_tcp_accept(struct iperf_test * test) { int s; signed char rbuf = ACCESS_DENIED; char cookie[COOKIE_SIZE]; socklen_t len; struct sockaddr_storage addr; len = sizeof(addr); if ((s = accept(test->listener, (struct sockaddr *) &addr, &len)) < 0) { i_errno = IESTREAMCONNECT; return -1; } if (Nread(s, cookie, COOKIE_SIZE, Ptcp) < 0) { i_errno = IERECVCOOKIE; close(s); return -1; } if (strcmp(test->cookie, cookie) != 0) { if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Ptcp) < 0) { i_errno = IESENDMESSAGE; } else { i_errno = IEBADCOOKIE; } close(s); return -1; } return s; }
/* iperf_udp_send * * sends the data for UDP */ int iperf_udp_send(struct iperf_stream *sp) { int r; uint32_t sec, usec, pcount; int size = sp->settings->blksize; struct timeval before; gettimeofday(&before, 0); ++sp->packet_count; sec = htonl(before.tv_sec); usec = htonl(before.tv_usec); pcount = htonl(sp->packet_count); memcpy(sp->buffer, &sec, sizeof(sec)); memcpy(sp->buffer+4, &usec, sizeof(usec)); memcpy(sp->buffer+8, &pcount, sizeof(pcount)); r = Nwrite(sp->socket, sp->buffer, size, Pudp); if (r < 0) return r; sp->result->bytes_sent += r; sp->result->bytes_sent_this_interval += r; return r; }
void Write5(DWORD d, DWORD n) { BYTE p[5]; Nunpack(p,n,5); Nwrite(p,d,5); return; }
void main(int argc, char *argv[]) { int skt; int err, quit=0; int DataBytes; InitLib(); err=NetStart(); if(err<0) { Print("Init Ethernet error.\n\r"); return; } GetIp(MyIp); Print("IP=%d.%d.%d.%d\r\n", MyIp[0], MyIp[1], MyIp[2], MyIp[3]); skt=Nopen("*", "UDP/IP", 10000, 0, S_NOCON | S_NOWA); if(skt<0) { Print("Cannot open a connection for UDP/IP!"); Nterm(); return; } Print("Socket=%d\r\n", skt); SOCKET_NOBLOCK(skt); while(!quit) { YIELD(); // must add this line in the while loop DataBytes=Nread(skt, InBuf, 1500); if(DataBytes>0) { Print("%s\n\r",InBuf); memcpy(OutBuf, InBuf, DataBytes); Nwrite(skt, OutBuf, DataBytes); } if(Kbhit()) { switch(Getch()) { case 'q': case 'Q': quit=1; break; } } } Nclose(skt); Nterm(); }
/* iperf_tcp_send * * sends the data for TCP */ int iperf_tcp_send(struct iperf_stream *sp) { int r; if (sp->test->zerocopy) r = Nsendfile(sp->buffer_fd, sp->socket, sp->buffer, sp->settings->blksize); else r = Nwrite(sp->socket, sp->buffer, sp->settings->blksize, Ptcp); if (r < 0) return r; sp->result->bytes_sent += r; sp->result->bytes_sent_this_interval += r; return r; }
DWORD RPL_CreateTemp(DWORD l) { DWORD a, b, c; BYTE *p; l += 6; // memory for link field (5) + marker (1) and end a = Read5(TEMPTOP); // tail address of top object b = Read5(RSKTOP); // tail address of rtn stack c = Read5(DSKTOP); // top of data stack if ((b+l)>c) return 0; // check if there's enough memory to move DSKTOP Write5(TEMPTOP, a+l); // adjust new end of top object Write5(RSKTOP, b+l); // adjust new end of rtn stack Write5(AVMEM, (c-b-l)/5); // calculate free memory (*5 nibbles) p = (BYTE *)malloc(b-a); memset(p,0,b-a); Npeek(p,a,b-a); Nwrite(p,a+l,b-a); free(p); Write5(a+l-5,l); // set object length field return (a+1); // return base address of new object }
int main(int argc, char **argv) { struct iperf_test *test; // XXX: Setting the process affinity requires root on most systems. // Is this a feature we really need? #ifdef TEST_PROC_AFFINITY /* didnt seem to work.... */ /* * increasing the priority of the process to minimise packet generation * delay */ int rc = setpriority(PRIO_PROCESS, 0, -15); if (rc < 0) { perror("setpriority:"); printf("setting priority to valid level\n"); rc = setpriority(PRIO_PROCESS, 0, 0); } /* setting the affinity of the process */ cpu_set_t cpu_set; int affinity = -1; int ncores = 1; sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set); if (errno) perror("couldn't get affinity:"); if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0) err("sysconf: couldn't get _SC_NPROCESSORS_CONF"); CPU_ZERO(&cpu_set); CPU_SET(affinity, &cpu_set); if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) err("couldn't change CPU affinity"); #endif test = iperf_new_test(); if (!test) { iperf_error("create new test error"); exit(1); } iperf_defaults(test); /* sets defaults */ // XXX: Check signal for errors? signal(SIGINT, sig_handler); if (setjmp(env)) { if (test->ctrl_sck >= 0) { test->state = (test->role == 'c') ? CLIENT_TERMINATE : SERVER_TERMINATE; if (Nwrite(test->ctrl_sck, &test->state, sizeof(char), Ptcp) < 0) { i_errno = IESENDMESSAGE; return (-1); } } exit(1); } if (iperf_parse_arguments(test, argc, argv) < 0) { iperf_error("parameter error"); fprintf(stderr, "\n"); usage_long(); exit(1); } if (iperf_run(test) < 0) { iperf_error("error"); exit(1); } iperf_free_test(test); printf("\niperf Done.\n"); return (0); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { ACE_SOCK_Stream connection_stream; int c; printf("HZ = %d\n", HZ); if (argc < 2) goto usage; while ((c = getopt (argc, argv, "drstU:uvBDTb:f:l:n:p:A:O:L:xh:")) != -1) { switch (c) { case 'h': host = optarg; break; case 'x': new_line = 1; break; case 'L': title = optarg; break; case 'B': b_flag = 1; break; case 't': trans = 1; break; case 'r': trans = 0; break; case 'd': options |= SO_DEBUG; break; case 'D': #ifdef TCP_NODELAY nodelay = 1; #else fprintf (stderr, "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n"); #endif break; case 'n': nbuf = atoi (optarg); break; case 'l': data_buf_len = atoi (optarg); break; case 's': sinkmode = !sinkmode; break; case 'p': port = atoi (optarg); break; case 'U': domain = PF_UNIX; domainname = optarg; break; case 'u': udp = 1; break; case 'v': verbose = 1; break; case 'A': bufalign = atoi (optarg); break; case 'O': bufoffset = atoi (optarg); break; case 'b': #if defined(SO_SNDBUF) || defined(SO_RCVBUF) sockbufsize = atoi (optarg); #else fprintf (stderr, "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n"); #endif break; case 'f': fmt = *optarg; break; case 'T': touchdata = 1; break; default: goto usage; } } /* if transmitter, create remote address to transmit to. */ if (trans) { if (address.set (port, host) == -1) perror ("address.set"), exit (1); } /* else, receiver create address to listen on */ else { address.set (port); } total_msg_len = sizeof (long) + data_buf_len; // allocate the buffer message_buf = (Data_Control_Message *) malloc (total_msg_len); if (message_buf == 0) err ("malloc"); // if (bufalign != 0) // message_buf += (bufalign - ((int) message_buf % bufalign) + bufoffset) % bufalign; // let's go ahead and set the control message for every send right now message_buf->size_ = data_buf_len; session_control_buf.nbuf_ = nbuf; session_control_buf.size_ = data_buf_len; // // print out option values for trans and receiver // if (trans) { fprintf (stdout, "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf (stdout, ", sockbufsize=%d", sockbufsize); fprintf (stdout, " %s -> %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix", host == 0 ? domainname : host); } else // receiver { fprintf (stdout, "ttcp-r: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf (stdout, ", sockbufsize=%d", sockbufsize); fprintf (stdout, " %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix"); } mes ("socket"); // // connect and accept // if (!udp) { signal (SIGPIPE, (SIG_TYP) sigpipe); /* the transmitter will set options and connect to receiver */ if (trans) { // turn off weird ack things if (nodelay) { struct protoent *p = getprotobyname ("tcp"); if (p && connection_stream.set_option (p->p_proto, TCP_NODELAY, (char *)& one, sizeof (one))) err ("setsockopt: nodelay"); mes ("nodelay"); } if (connector_factory.connect (connection_stream, address) == -1) perror ("connection failed"), exit (1); fprintf (stdout, "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) { if (connection_stream.set_option (SOL_SOCKET, SO_SNDBUF, (char *) &sockbufsize, sizeof sockbufsize) == -1) err ("acceptor_factory.set_option"); mes ("sndbuf"); } } /* receiver will listen for connections from the transmitter */ else { if (acceptor_factory.open (address, 1) == -1) perror ("acceptor open"), exit (1); if (sockbufsize) { if (connection_stream.set_option (SOL_SOCKET, SO_RCVBUF, (char *) &sockbufsize, sizeof sockbufsize) == -1) err ("acceptor_factory.set_option"); mes ("rcvbuf"); } ACE_INET_Addr remote_address; if (acceptor_factory.accept (connection_stream, (ACE_Addr *) &remote_address) == -1) perror ("acceptor accept"), exit (1); // set the window size fprintf (stderr, "ttcp-r: accept from %s\n", remote_address.get_host_name()); } } // // start timer // errno = 0; if (trans) { pattern (& (message_buf->data_), data_buf_len); prep_timer (); ACE_DEBUG ((LM_DEBUG, "Sending session control message" " nbuf %d, size %d\n", session_control_buf.nbuf_, session_control_buf.size_)); if (connection_stream.send_n ((char *) &session_control_buf, sizeof (Session_Control_Message)) != sizeof (Session_Control_Message)) ACE_ERROR_RETURN ((LM_ERROR, "%p send session control failed\n", "ttcp"), -1); long ack; int send_result; while (nbuf--) { send_result = connection_stream.send_n ((char *) message_buf, total_msg_len); if (send_result != total_msg_len) ACE_ERROR_RETURN ((LM_ERROR, "%p only sent %d of %d bytes on call %d\n", "ttcp", send_result, total_msg_len, numCalls + 1), -1); numCalls++; nbytes += data_buf_len; if (connection_stream.recv_n ((char *) &ack, sizeof ack) != sizeof ack) ACE_ERROR_RETURN ((LM_ERROR, "%p recv of ack failed\n", "ttcp"), -1); if (ack != data_buf_len) ACE_DEBUG ((LM_DEBUG, "received ack for only %d bytes\n", ack)); } printf("Client finished.\n"); } else { prep_timer (); if (connection_stream.recv_n ((char *) &session_control_buf, sizeof (Session_Control_Message)) != sizeof (Session_Control_Message)) ACE_ERROR_RETURN ((LM_ERROR, "%p recv session control failed\n", "ttcp"), -1); ACE_DEBUG ((LM_DEBUG, "received session control message" " nbuf %d, size %d\n", session_control_buf.nbuf_, session_control_buf.size_)); nbuf = session_control_buf.nbuf_; // ignore session_control_buf.size_ for now long cnt; while (nbuf--) { if (connection_stream.recv_n ((char *) message_buf, sizeof (long)) != sizeof (long)) ACE_ERROR_RETURN ((LM_ERROR, "%p recv data control failed\n", "ttcp"), -1); cnt = connection_stream.recv_n (& (message_buf->data_), message_buf->size_); if (cnt != message_buf->size_) ACE_ERROR_RETURN ((LM_ERROR, "recv data failed\n"), -1); numCalls++; nbytes += cnt; if (connection_stream.send_n ((char *) &cnt, sizeof cnt) != sizeof cnt) ACE_ERROR_RETURN ((LM_ERROR, "%p send ack failed\n", "ttcp"), -1); } printf("Server finished.\n"); } /* if (errno) err ("IO"); */ // // stop the timer // (void) read_timer (stats, sizeof (stats)); if (udp && trans) { (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ } if (cput <= 0.0) cput = 0.001; if (realt <= 0.0) realt = 0.001; #if defined (LM_RESULTS) if (trans && (title != 0)) { double tmp; FILE *fd; char filename[BUFSIZ]; ACE_OS::sprintf (filename, "%s.results", title); fd = fopen(filename,"a+"); if (new_line) fprintf(fd,"\n -l %ldk \t", data_buf_len/1024); tmp = ((double) nbytes) / realt; fprintf(fd,"%.2f ", tmp * 8.0 / 1024.0 / 1024.0); fclose(fd); } #endif fprintf (stdout, "ttcp%s: %ld bytes in %.2f real seconds = %s/sec +++\n", trans ? "-t" : "-r", nbytes, realt, outfmt (((double) nbytes) / realt)); if (verbose) { fprintf (stdout, "ttcp%s: %ld bytes in %.2f CPU seconds = %s/cpu sec\n", trans ? "-t" : "-r", nbytes, cput, outfmt (((double) nbytes) / cput)); } fprintf (stdout, "ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n", trans ? "-t" : "-r", numCalls, 1024.0 * realt / ((double) numCalls), ((double) numCalls) / realt); fprintf (stdout, "ttcp%s: %s\n", trans ? "-t" : "-r", stats); if (verbose) { fprintf (stdout, "ttcp%s: buffer address %#x\n", trans ? "-t" : "-r", message_buf); } exit (0); usage: fprintf (stderr, Usage); return 1; }
/* iperf_tcp_connect * * connect to a TCP stream listener */ int iperf_tcp_connect(struct iperf_test *test) { struct addrinfo hints, *local_res, *server_res; char portstr[6]; int s, opt; int saved_errno; if (test->bind_address) { memset(&hints, 0, sizeof(hints)); hints.ai_family = test->settings->domain; hints.ai_socktype = SOCK_STREAM; if (getaddrinfo(test->bind_address, NULL, &hints, &local_res) != 0) { i_errno = IESTREAMCONNECT; return -1; } } memset(&hints, 0, sizeof(hints)); hints.ai_family = test->settings->domain; hints.ai_socktype = SOCK_STREAM; snprintf(portstr, sizeof(portstr), "%d", test->server_port); if (getaddrinfo(test->server_hostname, portstr, &hints, &server_res) != 0) { if (test->bind_address) freeaddrinfo(local_res); i_errno = IESTREAMCONNECT; return -1; } if ((s = socket(server_res->ai_family, SOCK_STREAM, 0)) < 0) { if (test->bind_address) freeaddrinfo(local_res); freeaddrinfo(server_res); i_errno = IESTREAMCONNECT; return -1; } if (test->bind_address) { struct sockaddr_in *lcladdr; lcladdr = (struct sockaddr_in *)local_res->ai_addr; lcladdr->sin_port = htons(test->bind_port); local_res->ai_addr = (struct sockaddr *)lcladdr; if (bind(s, (struct sockaddr *) local_res->ai_addr, local_res->ai_addrlen) < 0) { saved_errno = errno; close(s); freeaddrinfo(local_res); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESTREAMCONNECT; return -1; } freeaddrinfo(local_res); } /* Set socket options */ if (test->no_delay) { opt = 1; if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETNODELAY; return -1; } } if ((opt = test->settings->mss)) { if (setsockopt(s, IPPROTO_TCP, TCP_MAXSEG, &opt, sizeof(opt)) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETMSS; return -1; } } if ((opt = test->settings->socket_bufsize)) { if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETBUF; return -1; } if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETBUF; return -1; } } if (test->debug) { socklen_t optlen = sizeof(opt); if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, &optlen) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETBUF; return -1; } printf("SO_SNDBUF is %u\n", opt); } #if defined(HAVE_FLOWLABEL) if (test->settings->flowlabel) { if (server_res->ai_addr->sa_family != AF_INET6) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETFLOW; return -1; } else { struct sockaddr_in6* sa6P = (struct sockaddr_in6*) server_res->ai_addr; char freq_buf[sizeof(struct in6_flowlabel_req)]; struct in6_flowlabel_req *freq = (struct in6_flowlabel_req *)freq_buf; int freq_len = sizeof(*freq); memset(freq, 0, sizeof(*freq)); freq->flr_label = htonl(test->settings->flowlabel & IPV6_FLOWINFO_FLOWLABEL); freq->flr_action = IPV6_FL_A_GET; freq->flr_flags = IPV6_FL_F_CREATE; freq->flr_share = IPV6_FL_F_CREATE | IPV6_FL_S_EXCL; memcpy(&freq->flr_dst, &sa6P->sin6_addr, 16); if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR, freq, freq_len) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETFLOW; return -1; } sa6P->sin6_flowinfo = freq->flr_label; opt = 1; if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWINFO_SEND, &opt, sizeof(opt)) < 0) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESETFLOW; return -1; } } } #endif /* HAVE_FLOWLABEL */ #if defined(HAVE_TCP_CONGESTION) if (test->congestion) { if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, test->congestion, strlen(test->congestion)) < 0) { close(s); freeaddrinfo(server_res); i_errno = IESETCONGESTION; return -1; } } #endif /* HAVE_TCP_CONGESTION */ #if defined(HAVE_SO_MAX_PACING_RATE) /* If socket pacing is available and not disabled, try it. */ if (! test->no_fq_socket_pacing) { /* Convert bits per second to bytes per second */ unsigned int rate = test->settings->rate / 8; if (rate > 0) { if (test->debug) { printf("Socket pacing set to %u\n", rate); } if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) { warning("Unable to set socket pacing, using application pacing instead"); test->no_fq_socket_pacing = 1; } } } #endif /* HAVE_SO_MAX_PACING_RATE */ if (connect(s, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen) < 0 && errno != EINPROGRESS) { saved_errno = errno; close(s); freeaddrinfo(server_res); errno = saved_errno; i_errno = IESTREAMCONNECT; return -1; } freeaddrinfo(server_res); /* Send cookie for verification */ if (Nwrite(s, test->cookie, COOKIE_SIZE, Ptcp) < 0) { saved_errno = errno; close(s); errno = saved_errno; i_errno = IESENDCOOKIE; return -1; } return s; }
int read_bin_file(char *filename) { struct stat st; FILE *fp; DWORD bin_size = 0; BYTE *bin_buffer = (BYTE *)0; int bBinary; long dwAddress; long i; LOGI("Loading filename: %s", filename); if (NULL == (fp = fopen(filename, "r"))) { return 0; } if (stat(filename, &st) < 0) { fclose(fp); return 0; } bin_size = st.st_size; bin_buffer = (BYTE *)malloc(bin_size * 2); if (fread(bin_buffer + bin_size, 1, (size_t)bin_size, fp) != bin_size) { free(bin_buffer); fclose(fp); return 0; } fclose(fp); bBinary = ((bin_buffer[bin_size+0]=='H') && (bin_buffer[bin_size+1]=='P') && (bin_buffer[bin_size+2]=='H') && (bin_buffer[bin_size+3]=='P') && (bin_buffer[bin_size+4]=='4') && (bin_buffer[bin_size+5]=='8') && (bin_buffer[bin_size+6]=='-')); for (i = 0; i < bin_size; i++) { BYTE byTwoNibs = bin_buffer[i+bin_size]; bin_buffer[i*2 ] = (BYTE)(byTwoNibs&0xF); bin_buffer[i*2+1] = (BYTE)(byTwoNibs>>4); } if (bBinary) { // load as binary bin_size = RPL_ObjectSize(bin_buffer+16); dwAddress = RPL_CreateTemp(bin_size); if (dwAddress == 0) return 0; Nwrite(bin_buffer+16,dwAddress,bin_size); } else { // load as string bin_size *= 2; dwAddress = RPL_CreateTemp(bin_size+10); if (dwAddress == 0) return 0; Write5(dwAddress,0x02A2C); // String Write5(dwAddress+5,bin_size+5); // length of String Nwrite(bin_buffer,dwAddress+10,bin_size); // data } RPL_Push(dwAddress); LOGI("Done loading filename: %s", filename); return 1; }