void main() { int bytes_read; char buffer[100]; /* Currently (DC 7.30), printf() has max 127 bytes it can output. */ tcp_Socket socket; sock_init(); while(1) { tcp_listen(&socket,PORT,0,0,NULL,0); printf("Waiting for connection...\n"); while(!sock_established(&socket) && sock_bytesready(&socket)==-1) tcp_tick(NULL); printf("Connection received...\n"); do { bytes_read=sock_fastread(&socket,buffer,sizeof(buffer)-1); if(bytes_read>0) { buffer[bytes_read]=0; printf("%s",buffer); sock_write(&socket,buffer,bytes_read); } } while(tcp_tick(&socket)); printf("Connection closed...\n"); } }
/********************************************************************************* This function handles and controls the xml socket. ********************************************************************************/ void My_Handler(My_Socket_Type *my_sock) { static char ipaddr[25],DispStrOut[100]; switch(my_sock->nextstate) { case 0:/*INITIALIZATION*/ // listen for incoming connection inet_ntoa( ipaddr, my_ip_addr ); sprintf(DispStrOut,"OFFLINE\nCONNECT TO\nIP: %s\nPORT: %d", ipaddr, MY_PORT); while(!btnMsgBox(40,0,240,90,&fi14x16,DispStrOut,1,1)); if(tcp_listen(&my_sock->sock,MY_PORT,INCOMING_IP,INCOMING_PORT,NULL,0)) { my_sock->rxbytes = my_sock->txbytes = 0; my_sock->statetime = 0L; (my_sock->nextstate)++; // init complete move onto next state my_sock->statetime = MS_TIMER+TCP_TIMEOUT; // reset the statetime } else exit(0); break; case 1://LISTEN// if(sock_established(&my_sock->sock)) // check for a connection { inet_ntoa(ipaddr,my_sock->sock.hisaddr); sprintf(DispStrOut,"CONNECTED\nIP: %s",ipaddr); while(!btnMsgBox(40,0,240,90,&fi14x16,DispStrOut,1,0)); //printf("%s\nConnection Established.\n",BLACK); (my_sock->statetime) = MS_TIMER+TCP_TIMEOUT; // reset statetime for RECEIVE state (my_sock->nextstate)++; // we have connection so move on } else if ((long)(MS_TIMER-(my_sock->statetime)) > 0) // if X sec and no sock my_sock->nextstate = 4; // abort and re-init break; case 2://RECEIVE// my_sock->nextstate = My_Rcv_Pkt(my_sock); // see function for details if ((long)(MS_TIMER-(my_sock->statetime)) > 0) // if X sec and still waiting my_sock->nextstate = 4; // abort and re-init break; case 3://SEND// my_sock->nextstate = My_Snd_Pkt(my_sock); // see function for details if ((long)(MS_TIMER-(my_sock->statetime)) > 0) // if X sec and still waiting my_sock->nextstate = 4; // abort and re-init break; case 4://NO WAIT_CLOSE// sock_abort(&my_sock->sock); // close the socket my_sock->nextstate = 0; // go back to the INIT state } if(!tcp_tick(&my_sock->sock)) my_sock->nextstate = 0; }
void recv_tick(void) { auto int retval; tcp_tick(state->s); switch(state->state) { case STATE_INIT: if(sock_established(state->s)) { printf("Connection Established.\n"); state->state = STATE_STEADY; } break; case STATE_STEADY: if(!sock_established(state->s)) { /* connection died; reset */ printf("Connection lost.\n\n"); init_recv(state->lport); break; } retval = sock_fastread(state->s, state->buf, MAX_BUFLEN); if(retval) { /* we got data */ #ifdef INPUT_COOKED retval = cook_input(retval); #endif receive_data(state->buf, retval); /* give it to the user */ } break; default: /* shouldn't ever get here */ /* reset the conroller */ exit(-1); } }
void main() { int state,status; state = 0; sock_init(); while(1) { switch(state) { case 0:/*INITIALIZATION*/ // listen for incoming connection if(!tcp_listen(&sock,MY_PORT,INCOMING_IP,INCOMING_PORT,NULL,0)) printf("%sERROR OPENNING SOCKET!\n",RED); else { printf("%swaiting for incomming session\n",GREEN); statetime = MS_TIMER+TIME_OUT; // setup the time to be in LISTEN state state++; // init complete move onto next state } break; case 1:/*LISTEN*/ if(sock_established(&sock)) // check for a connection { printf("%ssocket established\n",BLUE); statetime = MS_TIMER+TIME_OUT; // reset time to be in the RECEIVE state state++; // we have connection so move on } else if ((long)(MS_TIMER-statetime) > 0) // if X millisecs and still waiting state = 4; // abort and re-init break; case 2:/*RECEIVE*/ state = receive_packet(); // see function for details if ((long)(MS_TIMER-statetime) > 0) // if X millisecs and still waiting state = 4; // abort and re-init break; case 3:/*SEND*/ state = send_packet(); // see function for details if ((long)(MS_TIMER-statetime) > 0) // if X millisecs and still waiting state = 4; // abort and re-init break; case 4:/*NO WAIT_CLOSE*/ printf("%sABORT SOCKET\n",RED); sock_abort(&sock); // close the socket state = 0; // go back to the INIT state } status = tcp_tick(&sock); } }
void set_nist_time(){ int dst, health; struct tm t; unsigned long longsec; char response[100]; int bytes_read,total_bytes; tcp_Socket sock; longword nist_server; printf("Trying to set time from NIST server...\n"); //get the time if (!(nist_server = resolve(NIST_SERVER))) { printf(" ! Could not resolve time host\n"); exit( 3 ); } if( !tcp_open(&sock,0,nist_server,NIST_PORT,NULL)){ printf(" ! Unable to connect to time server\n"); exit( 3 ); } while (!sock_established(&sock) && sock_bytesready(&sock)==-1){ tcp_tick(NULL); } sock_mode(&sock, TCP_MODE_ASCII); total_bytes=0; do{ bytes_read=sock_fastread(&sock,response+total_bytes,sizeof(response)-1-total_bytes); total_bytes+=bytes_read; } while(tcp_tick(&sock) && (total_bytes < sizeof(response)-2)); //parse it t.tm_year = 100 + 10*(response[7]-'0') + (response[8]-'0'); t.tm_mon = 10*(response[10]-'0') + (response[11]-'0'); t.tm_mday = 10*(response[13]-'0') + (response[14]-'0'); t.tm_hour = 10*(response[16]-'0') + (response[17]-'0'); t.tm_min = 10*(response[19]-'0') + (response[20]-'0'); t.tm_sec = 10*(response[22]-'0') + (response[23]-'0'); dst = 10*(response[25]-'0') + (response[26]-'0'); health = response[28]-'0'; longsec = mktime(&t); longsec += 3600ul * NIST_TIMEZONE; // adjust for timezone if (dst != 0) longsec += 3600ul; // DST is in effect if (health < 2) write_rtc(longsec); printf(" Time set to : "); print_time(read_rtc()); }
static int get_headlines(char *rss_site,char *rss_page){ longword rss_server; //holds resolve(RSS_SERVER) int bytes_read,total_bytes; //for sock_fastread int count; tcp_Socket socket; //for comm char rssCode[6500]; //7kb max downloaded file limit unsigned int pos; char temp[500]; char* newStr; char otherStr[500]; printf("Fetching headlines...\n"); if (!tcp_tick(NULL)) { printf(" ! No network"); return 0; } //connect to the server if (!(rss_server = resolve(rss_site))) { printf(" ! Could not resolve host"); return 0; } if( !tcp_open(&socket,0,rss_server,HTTP_PORT,NULL)){ printf(" ! Unable to connect to remote server"); return 0; } //wait for the connection to be established while (!sock_established(&socket) && sock_bytesready(&socket)==-1){ tcp_tick(NULL); } printf(" connected! sending request\n"); //get the RSS code memset(rssCode,0,sizeof(rssCode)); //empty it first! sock_puts(&socket,"GET "); sock_puts(&socket,rss_page); sock_puts(&socket," HTTP/1.0\n"); sock_puts(&socket,"Accept: text/xml\nAccept: text/plain\nAccept: application/rss+xml\n\n"); sock_puts(&socket,"User-Agent: Mozilla/5.0 (Windows; U; Win98; en-US; m18) Gecko/20001108 Netscape6/6.0 \r\n\r\n"); total_bytes=0; do{ //this should be changed to parse as we receive each set of //bytes, so we don't need to waste 10k of memory with the big //rssCode array... bytes_read=sock_fastread(&socket,rssCode+total_bytes,sizeof(rssCode)-1-total_bytes); total_bytes+=bytes_read; } while(tcp_tick(&socket) && (total_bytes < sizeof(rssCode)-2)); printf(" Connection closed (received %d bytes)...\n",total_bytes); if(total_bytes<600) printf(rssCode); //parse out the headlines memset(headlines,0,sizeof(headlines)); strcat(headlines,"** "); newStr = strstr(rssCode,"<title>"); newStr = strstr(newStr,">"); count=0; while((newStr!= NULL)){ pos = strcspn(newStr,"<"); temp[0] = 0; strncat(temp,newStr,pos); substr(otherStr,temp,1,strlen(temp)); printf(" - \"%s\"\n",otherStr); //debug - print out the headline strcat(headlines,otherStr); strcat(headlines,"... "); newStr = strstr(newStr,"</title>"); newStr = strstr(newStr,"<title>"); newStr = strstr(newStr,">"); count++; } printf("Parsed out %d headlines.\n\n",count); return 1; }
void main() { int state; long timeout; int bytes_read; static char buffer[64]; static tcp_Socket socket; // Initialize I/O to use PowerCoreFLEX prototyping board brdInit(); serXopen(BAUD_RATE); // set up serial port serMode(0); sock_init(); // initialize DCRTCP tcp_reserveport(PORT); // set up PORT for SYN Queueing // which will hold a pending connection // until we are ready to process it. state=CONNECTION_INIT; while(1) { if(state==CONNECTION_OPEN) { if(debounce_key()) { sock_close(&socket); state=CONNECTION_CLOSED; } } /* * Make sure that the connection hasn't closed on us. * */ if(tcp_tick(&socket)==0 && state!=CONNECTION_INIT) { sock_close(&socket); state=CONNECTION_CLOSED; } switch(state) { case CONNECTION_INIT: tcp_listen(&socket,PORT,0,0,NULL,0); state=CONNECTION_LISTEN; break; case CONNECTION_LISTEN: if(sock_established(&socket)) { state=CONNECTION_OPEN; timeout=SEC_TIMER+TIMEOUT; serXrdFlush(); serXwrFlush(); led(RESET_LED); } break; case CONNECTION_OPEN: /* * close the socket on a timeout * */ if((long) (SEC_TIMER-timeout) >= 0) { sock_close(&socket); state=CONNECTION_CLOSED; break; } /* * read as many bytes from the socket as we have * room in the serial buffer. Also strip out the * telnet commands. */ bytes_read = 0; if(sock_bytesready(&socket) != -1) { bytes_read=sock_fastread(&socket, buffer, min(sizeof(buffer), serXwrFree())); bytes_read=strip_telnet_cmds(buffer, bytes_read); } /* * close the socket on an error * */ if(bytes_read<0) { sock_close(&socket); state=CONNECTION_CLOSED; break; } /* * copy any bytes that we read * */ if(bytes_read > 0) { timeout=SEC_TIMER+TIMEOUT; serXwrite(buffer, bytes_read); } /* * read as many bytes from the serial port as we * have room in the socket buffer. * */ bytes_read=serXread(buffer,min(sizeof(buffer),sock_tbleft(&socket)),100); if(bytes_read>0) { timeout=SEC_TIMER+TIMEOUT; if(sock_fastwrite(&socket,buffer,bytes_read)<0) { sock_close(&socket); state=CONNECTION_CLOSED; } } led(TOGGLE_LED); break; case CONNECTION_CLOSED: serXrdFlush(); serXwrFlush(); sprintf(buffer, "\n\rConnection closed\n\r"); serXwrite(buffer, strlen(buffer)); led(RESET_LED); state=CONNECTION_INIT; break; } } }
void main(void) { // index is used to loop through the interfaces int index; // Initialize the TCP/IP stack sock_init(); // Initialize the state machine structure for (index = 0; index <= VIRTUAL_ETH; index++) { socks[index].state = LSTN_STATE; socks[index].iface = 0; memset(socks[index].buff, 0, sizeof(socks[index].buff)); socks[index].bytes = 0; } // Perform network configuration on the main (physical) Ethernet ineterface printf("Bringing up Main Interface %2d:\n", socks[0].iface); ifconfig(IF_ETH0, IFS_IPADDR, aton(LOCAL_IP), IFS_NETMASK, aton(LOCAL_NETMASK), IFS_ROUTER_SET,aton(LOCAL_GATEWAY), IFS_UP, IFS_END); // Wait for the interface to come up while (ifpending(IF_ETH0) == IF_COMING_UP) { tcp_tick(NULL); } printf("Main Interface %2d: is up!!\n", socks[0].iface); // Configure each of the virtual Ethernet interfaces for (index = 1; index <= VIRTUAL_ETH; index++) { // virtual_eth() creates a new virtual Ethernet interface and returns // the new interface number socks[index].iface = virtual_eth(IF_ETH0, aton(LOCAL_IP) + index, aton(LOCAL_NETMASK), NULL); if (socks[index].iface != -1) { printf("Created Virtual Interface %2d:\n", socks[index].iface); } else { exit(0); } // Wait for the virtual Ethernet interface to come up while (ifpending(socks[index].iface) == IF_COMING_UP) { tcp_tick(NULL); } printf("Virtual Interface %2d: is up!!\n", socks[index].iface); } // Print out information on the interfaces ip_print_ifs(); // Begin the main program loop while (1) { // Iterate over the Ethernet interfaces for (index = 0; index <= VIRTUAL_ETH; index++) { switch (socks[index].state) { // Listen on the socket case LSTN_STATE: // Note that the iface number is passed to tcp_extlisten() if (tcp_extlisten(&socks[index].s, socks[index].iface, LOCAL_PORT, 0, 0, NULL, 0, 0, 0)) { socks[index].state = ESTB_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer printf("Interface %2d: listening on port: %5d\n", socks[index].iface, LOCAL_PORT); } else { // tcp_extlisten() failed--let the user know printf("Interface %2d: tcp_extlisten failed\n", socks[index].iface); socks[index].state = CLSE_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } break; // Check if a connection has been established case ESTB_STATE: if (sock_established(&socks[index].s) || sock_bytesready(&socks[index].s) >= 0) { socks[index].state = RECV_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer printf("Interface %2d: socket established.\n", socks[index].iface); } break; // Check if data has been received. If so, read it out. case RECV_STATE: // Read any incoming data socks[index].bytes = sock_fastread(&socks[index].s, socks[index].buff, sizeof(socks[index].buff)); if (socks[index].bytes == -1) { // sock_fastread() returned an error--means that the socket is // likely closed printf("Interface %2d: sock_fastread failed\n", socks[index].iface); socks[index].state = CLSE_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } // Check if we received any data if (socks[index].bytes > 0) { printf("Interface %2d: revd: %2d bytes\n", socks[index].iface, socks[index].bytes); socks[index].state = SEND_STATE; // send the data back socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } break; // Echo back any received data case SEND_STATE: socks[index].bytes = sock_fastwrite(&socks[index].s, socks[index].buff, socks[index].bytes); if (socks[index].bytes == -1) { // sock_fastwrite() returned an error--means that the socket // is likely closed printf("Interface %2d: sock_fastwrite failed\n", socks[index].iface); socks[index].state = CLSE_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } // Check how much data was written. Note that in this program, // if not all the data was written, the remaining data will be // dropped. A more realistic program would try sending the rest // of the data later, or using sock_awrite() until the data can // be sent. if (socks[index].bytes > 0) { printf("Interface %2d: sent: %2d bytes\n", socks[index].iface, socks[index].bytes); socks[index].state = RECV_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } break; // Close the socket case CLSE_STATE: sock_close(&socks[index].s); socks[index].state = CLWT_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer break; // Wait for the socket to completely close case CLWT_STATE: if (!sock_alive(&socks[index].s)) { printf("Interface %2d: socket closed.\n", socks[index].iface); socks[index].state = LSTN_STATE; socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer } break; // Abort the socket--used only if a socket has timed out in one of // the closing states case ABRT_STATE: sock_abort(&socks[index].s); // abort the socket socks[index].state = LSTN_STATE; // try to listen again socks[index].timer = SEC_TIMER + TIME2WAIT; // reset the timer break; } // Drive the TCP/IP stack tcp_tick(NULL); // Check the timeout on this socket, and close or abort the socket // if necessary timed_out(index); } } }
void vs_handler(VsState* state) { auto tcp_Socket* socket; auto int ch, bytes_written; auto int bytes_to_write; if(vs_info.mode==VS_MODEOFF) return; socket=&state->socket; /* * was the connection reset? */ if(state->state!=VS_INIT && tcp_tick(socket)==0) { #ifdef VERBOSE printf("Connection closed\n"); #endif state->state=VS_INIT; state->open_timeout=vs_info.open_timeout; } switch(state->state) { case VS_INIT: /* * passive open on the socket port */ if(state->open_timeout && vs_info.mode == VS_MODEACTIVE) { costate { waitfor(DelayMs(state->open_timeout)); state->open_timeout=0; } if(state->open_timeout) break; } serYopen(vs_info.baud); if(vs_info.mode == VS_MODEPASSIVE) { if (tcp_listen(socket,vs_info.port,0,0,NULL,0) != 0) { state->state=VS_LISTEN; #ifdef VERBOSE printf("\nListening on socket\n"); #endif } else { printf("\nError listening on socket!\n"); } } else if(vs_info.mode == VS_MODEACTIVE) { if (tcp_open(socket,0,vs_info.dest_ip,vs_info.dest_port,NULL) != 0) { state->state=VS_OPENING; #ifdef VERBOSE printf("\nOpening socket\n"); #endif } else { printf("\nError opening socket!\n"); } } break; case VS_LISTEN: case VS_OPENING: /* * wait for a connection */ if(sock_established(socket) || sock_bytesready(socket) >= 0) { state->state=VS_OPEN; sock_mode(socket,vs_info.binary); #ifdef VERBOSE printf("New Connection\n"); #endif } break; case VS_OPEN: if(vs_info.timeout!=0 && state->offset && (long) ((state->last_character+vs_info.timeout) - MS_TIMER) < 0) { bytes_written=sock_fastwrite(socket,state->buffer,state->offset); if (bytes_written < 0) { state->state = VS_WAITCLOSE; sock_close(socket); #ifdef VERBOSE printf("Connection closed\n"); #endif break; } /* * Hmmm... We weren't able to write all the bytes out. * Since we don't want to loose any characters, we will * shift everything over and hopefully write it soon. * */ if(bytes_written!=state->offset) { memcpy(state->buffer,state->buffer+bytes_written,state->offset-bytes_written); state->offset = bytes_written; break; } else state->offset = 0; } /* * process any characters. */ bytes_to_write=sock_bytesready(socket); if(bytes_to_write>serYwrFree()) bytes_to_write=serYwrFree(); if(bytes_to_write>(int)sizeof(state->buffer)) bytes_to_write=sizeof(state->buffer); if(bytes_to_write>0) { sock_read(socket,state->buffer,bytes_to_write); serYwrite(state->buffer,bytes_to_write); } /* * If we aren't worried about interpacket delay * just send the characters if there is room in * the buffer. * */ if(vs_info.timeout==0) { bytes_to_write=serYrdUsed(); if(bytes_to_write>sock_tbleft(socket)) bytes_to_write=sock_tbleft(socket); if(bytes_to_write>(int)sizeof(state->buffer)) bytes_to_write=sizeof(state->buffer); if(bytes_to_write>0) { serYread(state->buffer,bytes_to_write,0); sock_write(socket,state->buffer,bytes_to_write); } } else { while(state->offset<VS_MAXOFFSET && (ch=serYgetc())!=-1) { #ifdef USE_STDIO printf("%c",ch); #endif state->buffer[state->offset++]=ch; state->last_character=MS_TIMER; } } /* * We should immediately flush characters if the buffer * is full. * */ if(state->offset==VS_MAXOFFSET) { bytes_written=sock_fastwrite(socket,state->buffer,state->offset); if (bytes_written < 0) { state->state = VS_WAITCLOSE; sock_close(socket); #ifdef VERBOSE printf("Connection closed\n"); #endif break; } /* * Hmmm... We weren't able to write all the bytes out. * Since we don't want to loose any characters, we will * shift everything over and hopefully write it soon. * */ if(bytes_written!=state->offset) { memcpy(state->buffer,state->buffer+bytes_written,state->offset-bytes_written); state->offset = bytes_written; } else state->offset = 0; } break; case VS_WAITCLOSE: break; default: /* * how did we get here? programming error? */ state->state=VS_INIT; break; }
int main() { auto int if_status; printf("Multiple Interface Echo Test\n"); usage(); printf("\nPress any key to proceed.\n"); while (!kbhit()); getchar(); printf("Initializing TCP/IP stack...\n"); for (i = 0; i < IF_MAX; i++) ifconfig(i, IFG_IPADDR, oldip+i, #ifdef USE_IF_CALLBACK IFS_IF_CALLBACK, updowncb, #endif IFS_END); sock_init(); // Wait for the interface to come up while (IF_COMING_UP == (if_status = ifpending(IF_DEFAULT)) || IF_COMING_DOWN == if_status) { tcp_tick(NULL); } printf("...done.\n"); memset(state, 0, sizeof(state)); socknum = -1; seq = 1; ping_ip = 0; act_ip = 0; asock = s + (NUM_SOCKS - 1); astate = state + (NUM_SOCKS - 1); *astate = STATE_DONT_USE; if(!udp_extopen(&usock, IF_ANY, ECHO_PORT, -1L, 0, echo_handler, 0, 0)) { printf("udp_extopen failed!\n"); exit(0); } for (;;) { socknum++; if (socknum == NUM_SOCKS) socknum = 0; tcp_tick(NULL); if (state[socknum] > STATE_CLOSED && !sock_alive(s+socknum)) { if (socknum == NUM_LISTEN_SOCKS) { printf("Active socket closed\n"); state[socknum] = STATE_DONT_USE; } else { printf("Socket %d closed\n", socknum); state[socknum] = STATE_CLOSED; } sock_perror(s+socknum, NULL); } for (i = 0; i < IF_MAX; i++) { ifconfig(i, IFG_IPADDR, &ip, IFS_END); if (oldip[i] != ip) { printf("IPaddr on i/f %d changed from %08lx to %08lx\n", i, oldip[i], ip); oldip[i] = ip; ifconfig(i, IFS_ICMP_CONFIG_RESET, IFS_END); } } if (kbhit()) { kb = getchar(); if (kb == '?') usage(); else if (kb == 'i') ip_print_ifs(); else if (kb == 'r') router_printall(); else if (kb == 'c') arpcache_printall(); else if (kb == 'p') { printf("Press an interface number [TCP/IP now blocked]\n"); while (!kbhit()); kb = getchar(); if (isdigit(kb)) { ifconfig(kb - '0', IFG_ROUTER_DEFAULT, &ping_ip, IFS_END); if (ping_ip) { printf("Pinging router %08lX...\n", ping_ip); _send_ping(ping_ip, seq++, 1, IPTOS_DEFAULT, &ping_id); } else printf("No router for interface %d\n", kb - '0'); } else printf("No interface selected.\n"); } else if (kb == 'a') { if (act_ip && *astate != STATE_DONT_USE) { printf("Closing active connection to %s...\n", inet_ntoa(buf, act_ip)); sock_close(asock); while (tcp_tick(asock)); } *astate = STATE_DONT_USE; printf("Enter a host name or IP address [TCP/IP now blocked]\n"); gets(buf); printf("Resolving...\n"); act_ip = resolve(buf); if (act_ip) { printf("Enter a port number to connect to (0-65535)\n"); gets(buf); aport = (word)atol(buf); printf("Opening to %s:%u...\n", inet_ntoa(buf, act_ip), aport); *astate = STATE_ACTOPEN; } else printf("Could not resolve %s to IP address.\n", buf); } else if (isdigit(kb)) { // Toggle interface status kb -= '0'; if (!(1u<<kb & IF_SET)) { printf("Not a valid interface\n"); continue; } if (ifstatus(kb)) { printf("Bringing interface %d down...\n", kb); ifconfig(kb, IFS_DOWN, IFS_END); } else { printf("Bringing interface %d up...\n", kb); ifconfig(kb, IFS_UP, IFS_END); } } } if (ping_ip) { if (_chk_ping(ping_ip , &ping_id) != 0xffffffffL) { printf("Got ping response from %08lX\n", ping_ip); ping_ip = 0; } } switch (state[socknum]) { case STATE_CLOSED: if (!tcp_extlisten(s + socknum, IF_ANY, ECHO_PORT, 0, 0, t_handler, 0, 0, 0)) { printf("Listen failed - socket %d\n", socknum); state[socknum] = STATE_DONT_USE; break; } printf("Listening on socket %d...\n", socknum); state[socknum] = STATE_LISTEN; break; case STATE_ACTOPEN: if (!tcp_extopen(s + socknum, IF_ANY, 0, act_ip, aport, t_handler, 0, 0)) { printf("Active open failed\n"); state[socknum] = STATE_DONT_USE; break; } state[socknum] = STATE_LISTEN; break; case STATE_LISTEN: if (sock_established(s + socknum)) { printf("Connection %d estab.\n", socknum); state[socknum] = STATE_ESTAB; } break; case STATE_ESTAB: if ((rb = sock_fastread(s + socknum, buf, sizeof(buf))) > 0) { sock_fastwrite(s + socknum, buf, rb); if (!strncmp(buf, "quit", 4)) { printf("Peer on socket %d requests close\n", socknum); sock_close(s + socknum); state[socknum] = STATE_CLOSING; } } else if (rb < 0) { printf("Connection %d closed by peer.\n", socknum); sock_close(s + socknum); state[socknum] = STATE_CLOSING; } break; default: break; } } }