int ParseToken(HttpState* state, int *bytesRead) { int i; int retval; int len; for (i = 0; i < (sizeof(FORMSpec)/sizeof(FORMType)); i++) { if (!strcmp(FORMSpec[i].name, state->buffer)) { parsePtr = FORMSpec[i].value; len = 0; retval = sock_fastread(&state->s, parsePtr, 1); while ((*bytesRead < (state->content_length - 2)) && (tcp_tick(&state->s) != 0) && (*parsePtr != '&')) { if (retval != 0) { (*bytesRead)++; if (len < (FORMSpec[i].len - 1)) { parsePtr++; len++; } } retval = sock_fastread(&state->s, parsePtr, 1); } *parsePtr = '\0'; } if (i < (sizeof(FORMSpec)/sizeof(FORMType) - 1) && (tcp_tick(&state->s) == 0)) { return -1; } } return 1; }
/* * Receive a message. The socket is re-opened and message read. The need * for a response is indicated. tcp_tick() fails if peer closed socket. */ void RecvMessage(tcp_Socket* tcpSock, int* respond) { auto char buffer[500]; auto int numBytes; tcp_listen(tcpSock, PORT, 0, 0, NULL, 0); dispClear(); /* Wait for connection. */ while( ! tcp_established( tcpSock ) ) { if( ! tcp_tick( (sock_type *) tcpSock ) ) { dispPrintf( "ERROR: listening: %s\n", tcpSock->err_msg ); exit( 99 ); } } /* Wait for some data to appear, or an error... */ while( 0 == (numBytes = sock_fastread(tcpSock, buffer, sizeof(buffer))) ) { if( ! tcp_tick( tcpSock ) ) { bad_read: dispPrintf( "ERROR: read: %s\n", tcpSock->err_msg ); exit( 99 ); } } if (numBytes == -1) { goto bad_read; } buffer[numBytes] = '\0'; dispPrintf("%s", buffer); *respond = 1; // Indicate the need for a response } /* end RecvMessage() */
static int udpdom( byte dtype, unpacker_funct unpacker, void *data ) { int i,uret; uret = sock_fastread((sock_type*)dom_sock, (byte*)question, sizeof(struct useek )); /* this does not happen */ if (uret < 0) { /* netputevent(USERCLASS,DOMFAIL,-1); */ return(0); /* ?? why'd I change this? -md */ // return(-1); } /* num = intel16(question->h.ident); */ /* get machine number */ /* * check to see if the necessary information was in the UDP response */ i = (int) ddextract(question, dtype, unpacker, data); switch (i) { case 0: return(1); /* we got a response */ case 3: return(0); /* name does not exist */ case -1:return( 0 ); /* strange return code from ddextract */ default:return( 0 ); /* dunno */ } }
/* * Parse the url-encoded POST data into the FORMSpec struct * (ie: parse 'foo=bar&baz=qux' into the struct). Return -1 * on error. */ int ParsePost(HttpState* state) { int retval; int bytesRead; bytesRead = 0; while ((bytesRead < (state->content_length - 2)) && (tcp_tick(&state->s) != 0)) { retval = sock_fastread(&state->s, state->p, 1); if (retval != 0) { bytesRead++; if (*state->p == '=') { *state->p = '\0'; state->p = state->buffer; if (ParseToken(state, &bytesRead) == -1) { return -1; } } else { state->p++; } } } if (bytesRead == (state->content_length - 2)) { return 1; } else { return -1; } }
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"); } }
static int udp_read (_udp_Socket *sock, u_char *buf, int len, ERROR_TYPE *error, DWORD timeout) { int status = _ip_delay1 ((sock_type*)sock, (int)timeout, NULL, NULL); if (status == -1) { *error = ETIMEDOUT; return (0); } *error = 0; return sock_fastread ((sock_type*)sock, (BYTE*)buf, len); }
/********************************************************************************* This function reads the xml socket, if there is no data it returns 2 so the My_Handler function calls state 2 again (state 2 is the receive state). ********************************************************************************/ int My_Rcv_Pkt(My_Socket_Type *my_sock) { /* receive the packet */ my_sock->rxbytes = sock_fastread(&my_sock->sock,my_sock->buff,BUFF_SIZE); switch(my_sock->rxbytes) { case -1: return 4; // there was an error go to state 4 (NO_WAIT_CLOSE) case 0: return 2; // connection is okay, but no data received default: (my_sock->statetime) = MS_TIMER+TCP_TIMEOUT; // reset time to be in the SEND state return 3; //now go to state 3 (SEND) } }
int receive_packet(void) { /* receive the packet */ bytes = sock_fastread(&sock,buff,BUFF_SIZE); switch(bytes) { case -1: return 4; // there was an error go to state 4 (NO_WAIT_CLOSE) case 0: return 2; // connection is okay, but no data received default: statetime = MS_TIMER+TIME_OUT; // reset time to be in the SEND state return 3; //now go to state 3 (SEND) } }
/* * getresult() - read answer and extract host name * return 0 on error, 1 on success */ static __inline int getresult (udp_Socket *s, char *name) { answer_t a; struct rrpart *rr; char *c; int len = sock_fastread ((sock_type*)s, (BYTE*)&a, sizeof(a)); if (len < sizeof(struct dhead) || a.h.qdcount != intel16(1) || a.h.ancount == 0) return (0); /* Skip question */ c = a.x; while (*c) ++c; c += 5; /* Skip name */ while (*c) { if ((*c & 0xC0) == 0xC0) { c += 2; break; } else ++c; } rr = (struct rrpart *) c; if (rr->rtype != intel16(DTYPEPTR)) return (0); c = (char*) &rr->rdata; while (*c) { if ((*c & 0xC0) == 0xC0) c = a.x + (*(int*)c & 0x3FFF); strncpy (name,c+1,*c); name += *c; c += *c + 1; if (*c) *name++ = '.'; } *name = 0; return (1); }
void do_reception(void) { unsigned int maxtransfer; #ifdef OLD unsigned int newtransfer; int status; unsigned int chars_avail, i; #endif sock_tick( s, &status ); #ifdef OLD if ( sock_dataready( s )) { if (rec_out > rec_in ) { /* we can fill intermediate portion of buffer */ maxtransfer = rec_out - rec_in; } else { /* we fill end of buffer and leave start for next attempt */ maxtransfer = RECEIVE_BUF_SIZE - rec_in; } if (maxtransfer) { rec_in += sock_fastread( s, &receive_buffer[ rec_in ], maxtransfer ); if ( rec_in >= RECEIVE_BUF_SIZE ) rec_in -= RECEIVE_BUF_SIZE; } } #else maxtransfer = RECEIVE_BUF_SIZE - rec_in; if (rec_out > rec_in) maxtransfer = rec_out - rec_in; maxtransfer = sock_recv( s, &receive_buffer[ rec_in ], maxtransfer ); if (maxtransfer) rec_in = (rec_in + maxtransfer) % RECEIVE_BUF_SIZE ; #endif OLD /* return( 0 ); */ return; sock_err: switch (status) { case 1 : outs("\n\r\7[??Host closed connection??]\n\r"); break; case-1 : outs("\n\r\7[??Host reset connection??]\n\r"); break; } s = NULL; sock_status = 0; }
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()); }
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); } }
/* * Receive a message. The connected socket and is sent back, and the need * for a response is indicated. */ void RecvMessage(tcp_Socket* tcpSock) { auto char buffer[500]; auto int numBytes; tcp_listen(tcpSock, PORT, 0, 0, NULL, 0); /* Wait for connection. */ while( ! tcp_established( tcpSock ) ) { if( ! tcp_tick( (sock_type *) tcpSock ) ) { TextGotoXY(&wholewindow, 0, 0 ); TextPrintf(&wholewindow, "Error: listen"); return; } } /* Wait for some data to appear, or an error... */ while((numBytes = sock_fastread(tcpSock, buffer, sizeof(buffer))) == 0 ) { if( ! tcp_tick( tcpSock ) || numBytes == -1 ) { TextGotoXY(&wholewindow, 0, 0 ); TextPrintf(&wholewindow, "Error: read"); return; } } // Display received from other controller glBlankScreen(); TextGotoXY(&wholewindow, 0, 0 ); TextPrintf(&wholewindow, "Message received:"); buffer[numBytes] = '\0'; TextGotoXY(&wholewindow, 0, 1 ); TextPrintf(&wholewindow, "%s", buffer); } /* end RecvMessage() */
int cookie( longword host ) { static udp_Socket sock; udp_Socket *s; char buffer[ 2049 ]; int status; int i; int fortunelen; s = &sock; status = 0; if ( host != 0 ) { status=udp_open( s, 0, host, COOKIE_PORT, NULL ); } else { if (_last_cookie == 0) { puts("Sorry, I can't seem to remember where my cookie jars are. "); puts("Could you tell me where one is? (Hint: host on the comand line)"); exit(3); } for (i=0; i < _last_cookie; i++) { if ( (status=udp_open( s, 0, _cookie[i], COOKIE_PORT, NULL )) != 0 ) { break; } } } if ( status == 0 ) { puts("None of the cookie jars are open!"); return( 1 ); } sock_write( s, "\n", 1 ); while ( 1 ) { sock_tick( s, &status ); if (sock_dataready( s ) ) { fortunelen=sock_fastread( s, buffer, sizeof( buffer )); buffer[fortunelen]='\0'; printf("%s\n", buffer); sock_close(s); return(0); } } sock_err: switch (status) { case 1 : /* foreign host closed */ return(0); case -1: /* timeout */ printf("\nConnection timed out!"); printf("ERROR: %s\n\r", sockerr( s )); return(1); } return (0); }
int ftpsession(struct Url *url,struct HTTPrecord *cache,char *uploadfile) { longword host; char str[256]; char buffer[BUFLEN+2]; tcp_Socket datasocket; word dataport=0; int rv=0,len; char *ptr,*datahostptr,datahost[80]; char isdir=0,retry=0;//,ascii=0; long total=0; //!!glennmcc: Nov 11, 2007 -- for 'dblp code' below int dblp=0; //!!glennmcc: end //!!glennmcc: Nov 13, 2007 -- for EZNOS2 fix below int eznos2=0; //!!glennmcc: end int log; if(!tcpip)return 0; free_socket(); if((!url->file[0] || url->file[strlen(url->file)-1]=='/') && !uploadfile) isdir=1; sprintf(str,msg_askdns,url->host); outs(str); GlobalLogoStyle=0; //SDL set resolve animation host=resolve_fn( url->host, (sockfunct_t) TcpIdleFunc ); //SDL // host=resolve( url->host ); if(!host) { DNSerr(url->host); return 0; } // if(!uploadfile) //!glennmcc: Oct 20, 2012 - commented-out to make upload log more verbose log=a_open("FTP.LOG",O_BINARY|O_WRONLY|O_CREAT|O_TRUNC,S_IREAD|S_IWRITE); GlobalLogoStyle=2; //SDL set connect animation if (!tcp_open( socket, locport(), host, url->port, NULL )) { sprintf(str,msg_errcon,url->host); outs(str); return 0; } sprintf(str,msg_con,url->host,url->port); outs(str); write(log,str,strlen(str)); write(log,"\r\n",2); sock_wait_established(socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status); //SDL GlobalLogoStyle=1; //SDL set data animation sock_mode( socket, TCP_MODE_ASCII ); outs(MSG_LOGIN); do { sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); if ( *buffer != '2' && buffer[0]!=' ') goto quit; } while(buffer[3]=='-' || buffer[0]==' '); //continued message! if(!url->user[0]) ptr="anonymous"; else ptr=url->user; sprintf( str, "USER %s", ptr); write(log,str,strlen(str)); write(log,"\r\n",2); sock_puts(socket,(unsigned char *)str); sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); //!!glennmcc: May 11, 2005 //removed due to the fact that not all sites use '3' //see additional info below with respect to anonymous password // if ( *buffer != '3' ) goto quit; //!!glennmcc: end //open cache filename: //!glennmcc: Oct 20, 2012 - commented-out to make upload log more verbose // if(uploadfile) // strcpy(cache->locname,"FTP.LOG"); // else //!glennmcc end: Oct 20, 2012 { //!!glennmcc: Oct 22, 2008 -- strchr() was preventing the use of 'CachePath .\cache\' // ptr=strchr(cache->locname,'.'); ptr=strrchr(cache->locname,'.'); //!!glennmcc: end if(ptr) { strcpy(&ptr[1],"FTP"); strcpy(cache->rawname,cache->locname); } } cache->handle=a_open(cache->locname,O_BINARY|O_WRONLY|O_CREAT|O_TRUNC,S_IREAD|S_IWRITE); if(cache->handle<0) goto quit; strcpy(cache->mime,"text/plain"); if(url->password[0]) ptr=url->password; else { if(url->user[0] && !strcmp(url->host,AUTHENTICATION->host) && !strcmp(AUTHENTICATION->realm,"$ftp")) ptr=AUTHENTICATION->password; else { ptr=configvariable(&ARACHNEcfg,"FakeFTPeMail",NULL); if(!ptr || !strchr(ptr,'@')) { ptr=configvariable(&ARACHNEcfg,"eMail",NULL); if(!ptr) ptr="@"; } } } //!!glennmcc: May 11, 2005 //some sites do not require a password after 'anonymous' //therefer, this entire block is now within this 'if()' so that //the password (email address), will only be sent if asked for //!!glennmcc: Nov 13, 2007 -- EZNOS2 says "Enter PASS command" if (strstr(buffer,"sword") || strstr(buffer,"Enter PASS command")) //if (strstr(buffer,"sword"))//original line { sprintf( str, "PASS %s", ptr); sock_puts(socket,(unsigned char *)str); write(log,str,strlen(str)); write(log,"\r\n",2); }//!!glennmcc: inserted Mar 02, 2008 //Some servers need the following 'do/while' section, //therefore, only the section above for sending the password needs to be //'blocked' when no password was requested. do { sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); if (strstr(buffer,"Enter PASS command")) eznos2=1; if (*buffer != '2' && buffer[0]!=' ' && !eznos2) { write(cache->handle,buffer,strlen(buffer)); rv=1; goto quit; } else if ((buffer[3]=='-' || buffer[0]==' ') && (isdir || uploadfile)) { strcat(buffer,"\r\n"); rv=1; write(cache->handle,buffer,strlen(buffer)); } } while(buffer[3]=='-' || buffer[0]==' ' || buffer[0]=='3'); //continued message! //}//!!glennmcc: end May 11, 2005 -- removed on Mar 02, 2008 //ask server where we have to connect: sock_puts(socket,(unsigned char *)"PASV"); sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); //2xx Entering passive mode (a,b,c,d,x,y) if ( *buffer != '2' ) goto quit; datahostptr=strchr(buffer,'('); //!!glennmcc: Nov 13, 2007 -- EZNOS2 doesn't enclose the info in () //therefore, if '(' is not found... look for the last 'space'. if(!datahostptr) {datahostptr=strrchr(buffer,' '); eznos2=1;} //if that still fails... 'quit' //!!glennmcc: end if(!datahostptr) goto quit;//original line ptr=++datahostptr; { int carka=0; char *portptr=NULL; while(*ptr) { if(*ptr==',') { carka++; if(carka<4) *ptr='.'; else if(carka==4) { *ptr='\0'; portptr=ptr+1; } else if (carka==5) { *ptr='\0'; dataport=256*(word)atoi(portptr); // ,x,y -> 256*x+y portptr=ptr+1; //!!glennmcc: Nov 13, 2007 -- part of above fix for EZNO2 info not in () if(eznos2) dataport+=atoi(portptr); // ,x,y -> 256*x+y //!!glennmcc: end } } else if(*ptr==')' && portptr) { //!!glennmcc: Nov 11, 2007 -- some servers have double ')' // at the end of the port address info... // this 'dblp code' will prevent that from adding the final set twice //eg: (99,167,219,186,234,255)) instead of.... (99,167,219,186,234,255) //without this fix ... 255 gets added a 2nd time and //we end-up-with... port 60414 instead of the correct port of 60159 *ptr='\0'; if(!dblp)//!!glennmcc: Nov 11, 2007 dataport+=atoi(portptr); // ,x,y -> 256*x+y dblp=1;//!!glennmcc: Nov 11, 2007 } ptr++; } } if(!dataport) goto quit; //!!glennmcc: Aug 31, 2009 //EZNOS2 sends the IP of the machine on a router as datahost //therefore we need to go back to the original host if(eznos2) { makestr(datahost,url->host,79); outs(datahost); Piip(); } else //!!glennmcc:end makestr(datahost,datahostptr,79);//original line retry: if(isdir) { if(url->file[0]) { //!!glennmcc: Oct 15, 2007 -- fix problems with CWD on FTP servers //which interpret the leading '/' as an attempted CD to 'root' if(url->file[0]=='/') sprintf( str, "CWD %s", url->file+1); else //!!glennmcc: end Oct 15, 2007 sprintf( str, "CWD %s", url->file); sock_puts(socket,(unsigned char *)str); do { sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); //!!glennmcc: Apr 08, 2005 -- commented-out this block // to fix the problem of 'broken dir listing' when the // 'FTP welcome message' contains linefeeds // such as at ftp://ftp.cdrom.com/.2/simtelnet/ /* if ( *buffer != '2' && buffer[0]!=' ') { write(cache->handle,buffer,strlen(buffer)); rv=1; goto quit; } else if (buffer[3]=='-' || buffer[0]==' ') */ //!!glennmcc: end { strcat(buffer,"\r\n"); rv=1; write(cache->handle,buffer,strlen(buffer)); } } //!!glennmcc: Apr 08, 2005 -- added a test for !=' ' which is also // needed for the same fix at ftp://ftp.cdrom.com/.2/simtelnet/ while(buffer[3]=='-' || buffer[3]!=' ' || buffer[0]==' '); //continued message! // while(buffer[3]=='-' || buffer[0]==' '); //continued message! //!!glennmcc: end } strcpy(cache->mime,"ftp/list"); sprintf( str, "LIST"); } else { char *fnameptr; char mimestr[80]="ftp/binary"; fnameptr=strrchr(url->file,'/'); if(!fnameptr) { fnameptr=strrchr(url->file,'\\'); if(!fnameptr) fnameptr=url->file; else fnameptr++; } else fnameptr++; sprintf( str, "TYPE I"); if(fnameptr) { char ext[5]; strcpy(mimestr,"file/"); strncat(mimestr,fnameptr,70); mimestr[79]='\0'; get_extension(mimestr,ext); if(!strncmpi(ext,"TXT",3) || !strncmpi(ext,"HTM",3)) { //!!glennmcc: begin June 09, 2002 //optionally upload TXT and HTM in binary mode ptr=configvariable(&ARACHNEcfg,"UseBinaryFTP",NULL); if(!ptr || toupper(*ptr)=='N') //!!glennmcc: end sprintf( str, "TYPE A"); // ascii=1; } } strcpy(cache->mime,mimestr); sock_puts(socket,(unsigned char *)str); write(log,str,strlen(str)); write(log,"\r\n",2); sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); if ( *buffer != '2' || uploadfile) { strcat(buffer,"\n"); write(cache->handle,buffer,strlen(buffer)); } if ( *buffer != '2' ) { rv=1; goto quit; } if(!uploadfile) //!!glennmcc: Oct 17, 2007 -- fix problems with FTP servers //which interpret the leading '/' as an attempted CD to 'root' if(url->file[0]=='/') sprintf( str, "RETR %s", url->file+1); else sprintf( str, "RETR %s", url->file); //original single line above this comment //!!glennmcc: end else sprintf( str, "STOR %s", url->file); } sock_puts(socket,(unsigned char *)str); write(log,str,strlen(str)); write(log,"\r\n",2); //!!glennmcc: Oct 19, 2008 -- back to original fix //!!glennmcc: Nov 15, 2007 -- always 'close' the connection when done //with both dir listings and file downloads //Apr 10, 2007 fix did it only for dir listings if(isdir || strstr(str,"RETR")) //if(isdir) sock_puts(socket,(unsigned char *)"QUIT");//!!glennmcc: Apr 10, 2007 //!!glennmcc: end if(!retry) { //get file using datahost & dataport GlobalLogoStyle=0; //SDL set resolve animation host=resolve_fn( datahost, (sockfunct_t) TcpIdleFunc ); //SDL // host=resolve( datahost ); if(!host) goto quit; GlobalLogoStyle=2; //SDL set connect animation if (!tcp_open( &datasocket, locport(), host, dataport, NULL )) { sprintf(str,msg_errcon,datahost); outs(str); goto quit; } sprintf(str,msg_con,datahost,dataport); outs(str); write(log,str,strlen(str)); write(log,"\r\n",2); //wait for datasocket to open: sock_wait_established(&datasocket, sock_delay, (sockfunct_t) TcpIdleFunc, &status); //SDL //!!glennmcc: Sep 27, 2008 -- increase D/L speed on cable & DSL //many thanks to 'mik' for pointing me in the right direction. :) { #ifdef DEBUG char sp[80]; sprintf(sp,"Available stack = %u bytes",_SP); outs(sp); Piip(); Piip(); #endif if(_SP>(1024*SETBUFSIZE)) { char setbuf[1024*SETBUFSIZE]; sock_setbuf(&datasocket, (unsigned char *)setbuf, 1024*SETBUFSIZE); } } //!!glennmcc: end GlobalLogoStyle=1; //SDL set data animation } //wait for "110 openning connection" (or "550 ....error....") sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); write(log,buffer,strlen(buffer)); write(log,"\r\n",2); // printf("FTP daemon said>"); // puts(buffer); if ( *buffer != '1' || uploadfile) { strcat(buffer,"\n"); write(cache->handle,buffer,strlen(buffer)); } if ( *buffer != '1' ) { if(!strncmp(buffer,"550",3) && !retry) { retry=1; isdir=1-isdir; if(isdir) strcat(url->file,"/"); else { int i=strlen(url->file); if(i>0 && url->file[i-1]=='/') url->file[i-1]='\0'; } goto retry; } strcpy(cache->mime,"text/plain"); rv=1; goto dataquit; } if(!uploadfile) //-------------------------------------- download --------------- { while ( 1 ) { xChLogoTICK(1); if(GUITICK()) if(GLOBAL.gotolocation || GLOBAL.abort) goto dataquit; if (sock_dataready( &datasocket )) { len = sock_fastread( &datasocket, (unsigned char*)buffer, BUFLEN ); write(cache->handle,buffer,len); total+=len; sprintf(str,MSG_BYTESR,MSG_DOWNLD,total); outs(str); } else sock_tick( &datasocket, &status ); //shift TCP/IP } } else //-------------------------------------- upload ------------------ { int f,lenread,done; long length; char pom[256]; /* if(ascii) f=a_sopen(uploadfile,O_RDONLY|O_TEXT, SH_DENYNO, S_IREAD); else*/ f=a_sopen(uploadfile,O_RDONLY|O_BINARY, SH_DENYNO, S_IREAD); if(f<0) goto dataquit; lenread=done=0; length=0l; { long filel=a_filelength(f); while(1) { sprintf(pom,MSG_UPLOAD,length,filel); outs(pom); //!!glennmcc:Oct 23, 2008 -- 'reversed the logic' // to keep from overflowing at 21megs if(filel>100) percentbar((int)(length/(filel/100))); // percentbar((int)(100*length/filel)); lenread=a_read(f,buffer,BUFLEN); length+=lenread; if(lenread<=0) done=1; //wait until we can write to socket: while(sock_tbleft(&datasocket)<lenread) //SDL // while( datasocket.datalen > 1024) { sock_tick(&datasocket,&status); xChLogoTICK(1); // animation of logo if(GUITICK()) goto dataquit; } if(done) { sock_close( &datasocket ); a_close(f); goto dataclose; } sock_fastwrite(&datasocket,(unsigned char *)buffer,lenread); sock_tick(&datasocket,&status); }//loop } } dataquit: //!!glennmcc: Nov 15, 2007 -- removed sock_abort because it was // sometimes preventing the connection from being closed, // therefore preventing access to several files within a short time // due to too many connections open from the same IP // sock_abort( &datasocket );//original line //!!glennmcc: end dataclose: outs(MSG_CLOSE); sock_puts(socket,(unsigned char *)"QUIT");//!!glennmcc: Dec 04, 2006 sock_wait_closed( &datasocket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL if(uploadfile) { sock_wait_input( socket, sock_delay, (sockfunct_t) TcpIdleFunc, &status ); //SDL sock_gets( socket, (unsigned char *)buffer, sizeof( buffer )); outs(buffer); } quit: sock_puts(socket,(unsigned char *)"QUIT"); sock_close( socket ); closing[socknum]=1; sock_keepalive[socknum][0]='\0'; // sock_wait_closed( socket, sock_delay, NULL, &status ); //we will better wait because we are about to deallocate datasocket sock_err: switch (status) { case 1 : /* foreign host closed */ write(log,MSG_CLOSE,strlen(MSG_CLOSE)); write(log,"\r\n",2); close(log); break; case -1: /* timeout */ sprintf(str,MSG_TCPERR, sockerr(socket)); outs(str); write(log,str,strlen(str)); write(log,"\r\n",2); close(log); break; } if(total) { cache->knowsize=1; cache->size=total; rv=1; } if(cache->handle>=0) { a_close(cache->handle); rv=1; } return rv; }
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; }
/* * Receive a TFTP data packet */ static int recv_packet (DWORD block) { int len, status = 0; /* Use a callback since first block sent might cause a "ICMP * port unreachable" to be sent back. Note that the normal mechanism * of detecting ICMP errors (through _udp_cancel) doesn't work since * we did set 'sock->udp.hisaddr = 0'. * * Note: 'block' is 32-bit, but 16-bit in tftp-header. * We allow the header block-counter to wrap (allowing > 32MB files). */ if (block == 1UL) sock->udp.icmp_callb = (icmp_upcall) udp_callback; else sock->udp.icmp_callb = NULL; /* Read packet with timeout */ sock_wait_input (sock, tftp_timeout, NULL, &status); len = sock_fastread (sock, (BYTE*)inbuf, TFTP_HEADSIZE+SEGSIZE); /* Check that the packet has a correct length */ len -= TFTP_HEADSIZE; if (len < 0 || len > SEGSIZE) { TRACE (("tftp: Invalid packet, len = %d\n", len)); tftp_errno = ERR_INV; return (-1); } /* Check if we got an error packet */ if (intel16(inbuf->th_opcode) == ERROR) { #if defined(USE_DEBUG) int code = intel16 (inbuf->th_code); const char *str = tftp_strerror (code); TRACE (("tftp: Error: %s (%d): %.*s\n", str, code, SEGSIZE, inbuf->th_data)); #endif tftp_errno = ERR_ERR; return (-1); } /* Check if we got a valid data packet at all */ if (intel16(inbuf->th_opcode) != DATA) { TRACE (("tftp: Invalid opcode %d\n", intel16(inbuf->th_opcode))); tftp_errno = ERR_OP; return (-1); } /* Check if the block number of the data packet is correct */ if (intel16(inbuf->th_block) != (WORD)block) { TRACE (("tftp: Block %u != %u\n", intel16(inbuf->th_block), (WORD)block)); tftp_errno = ERR_BLOCK; return (-1); } tftp_errno = 0; if (debug_on) (*_outch) ('#'); /* Write 1 hash-mark per block */ return (len); sock_err: if (status == -1) { if (debug_on) (*_outch) ('T'); tftp_errno = ERR_TIMEOUT; return (-1); } /* most likely "Port unreachable" */ TRACE (("tftp: %s\n", sockerr(sock))); tftp_errno = ERR_UNKNOWN; return (-1); }
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; } } }
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 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; } } }