Esempio n. 1
0
/* discard extraneous data after timeout */
int news_discard( int cn )
{
	int16 bytes_available,x;
	int sbuf=sizeof(buffer);

/*	fprintf( log, "in news_discard(%d)\n", cn );  fflush(log); */
	while ((bytes_available=CNbyte_count(cn))>0) {

		if (handle_escape_events()==27) break;
/*
		if (Bconstat(2)==-1 && (Bconin(2) & 0xFF)==27) {
			break;
		}
*/
		if (bytes_available>sbuf) { bytes_available=sbuf; }
		CNget_block(cn, buffer, bytes_available);
	}
	if (bytes_available<0) {
		x=bytes_available;
		fprintf( log, "CNbyte_count(%d) returns (%d) %s \n", cn, x, get_err_text(x));
		fflush( log );
	}
/*	fprintf( log, "completed news_discard(%d)\n", cn );  fflush(log); */
	return(bytes_available);
}
Esempio n. 2
0
int checkdccchat()
{
short lcount=0,offset=0,sln;
short mcto=0;
char *dp;
char temps[2048];
	int16 stat;
while(mcto<30){
	if(chan[mcto].stat>2){
	stat = CNbyte_count(chan[mcto].cn);
	if (chan[mcto].stat == SAWAIT && stat >= E_NODATA)
		{chan[mcto].stat = SACTIVE;
		sendout("--DCC chat opened",cwin,col[CDCCINFO]);
		wn[chan[mcto].win].chan=mcto;
		dowindinfo(chan[mcto].win);}


	if (stat < E_NODATA && chan[mcto].stat !=SAWAIT) {
	sendout("--DCC chat terminated by remote",cwin,col[CDCCINFO]);
	closchan(mcto);
	}
	else{
	if (stat > 0){
	strcpy(dccp,"\0");

	CNget_block(chan[mcto].cn,(char *)dccp,stat);
*(dccp+stat)=0;
sln=(int16)strlen(dccp)+1;
dp=dccp;
while(offset<sln){
if(*(dp+lcount)==9){*(dp+lcount)=' ';}
if(*(dp+lcount)==10){
*(dp+lcount)=0;
sprintf(temps,"[DCC:%s] %s",chan[mcto].name,dp);
sendout(temps,chan[mcto].win,col[CDCCINFO]);dp=dp+lcount+1;
lcount=-1;
}
offset++;
lcount++;
}
if(offset!=sln){
if(!conf.boldnicks)
sprintf(temps,"[DCC:%s] ",chan[mcto].name);
else
sprintf(temps,"[DCC:%s] ",chan[mcto].name);
strncat(temps,dp,strlen(dp)-1);
sendout(temps,chan[mcto].win,col[CDCCINFO]);
}
}
}
}
mcto++;
}
return 0;
}
Esempio n. 3
0
int dcc_send(void)
{
short count=0;
int16 tstat;
long stat;
char temps[2048],temps2[2048];

while(count<10){
if(dcc[count].dir==DCOUT && dcc[count].stat){
tstat=CNbyte_count(dcc[count].cn);

if(tstat<E_NODATA && dcc[count].stat==SACTIVE){
sprintf(temps2,"**DCC: Error in send to %s",dcc[count].avec);
sendout(temps2,cwin,col[CERRORS]);
resetadcc(count);
if(is_dw_open(dcc[count].dcw))wd_close(dcc[count].dcw);
return 0;
}
if(dcc[count].stat==SAWAIT && tstat>=E_NODATA){
sprintf(temps,"--DCC send to %s connected",dcc[count].avec);
sendout(temps,cwin,col[CDCCINFO]);
dcc[count].stat=SACTIVE;
dcc[count].lack=dcc[count].cnt;
}

if(tstat>=4 && dcc[count].stat==SACTIVE){
CNget_block(dcc[count].cn,(char *)&dcc[count].lack,4);
}
if(dcc[count].lack==dcc[count].cnt && dcc[count].dcfh<0){
sprintf(temps,"--DCC send to %s completed",dcc[count].avec);
sendout(temps,cwin,col[CDCCINFO]);
resetadcc(count);
if(is_dw_open(dcc[count].dcw))wd_close(dcc[count].dcw);
return 0;
} 

if(dcc[count].stat==SACTIVE && dcc[count].lack==dcc[count].cnt){
stat=Fread(dcc[count].dcfh,(long)dctbufsize,(char *)&dcctempbuffer);
if(stat>0)TCP_send(dcc[count].cn,(char *)&dcctempbuffer,(int16)stat);
dobar(dcc[count].dcw,(long)dcc[count].cnt,dcc[count].len,count);
if(stat<dctbufsize){
Fclose(dcc[count].dcfh);
dcc[count].dcfh=-1;
}
dcc[count].cnt=dcc[count].cnt+stat;
}

}
count++;
}
return 0;
}
Esempio n. 4
0
int dcc_recv(void)
{
short count=0;
int16 tstat;
char temps[2048];
while(count<10){
if(dcc[count].dir==DCIN && dcc[count].stat==RAWAIT){
tstat=CNbyte_count(dcc[count].cn);

if(tstat>0){
CNget_block(dcc[count].cn,(char *)&dcctempbuffer,tstat);
Fwrite(dcc[count].dcfh,(long)tstat,(char *)&dcctempbuffer);
dcc[count].cnt=dcc[count].cnt+tstat;
dobar(dcc[count].dcw,(long)dcc[count].cnt,dcc[count].len,count);
TCP_send(dcc[count].cn,(char *)&dcc[count].cnt,4);
}

if(tstat<E_NODATA){
printf("%d",tstat);
if(dcc[count].cnt<dcc[count].len){
sprintf(temps,"**DCC: %s from %s incompleted",dcc[count].fname,dcc[count].avec);
sendout(temps,cwin,col[CERRORS]);
if(is_dw_open(dcc[count].dcw))wd_close(dcc[count].dcw);
resetadcc(count);
return 0;
}
sprintf(temps,"++DCC:%s received from %s",dcc[count].fname,dcc[count].avec);
sendout(temps,cwin,col[CDCCINFO]);
sprintf(temps,"++Bytes: %lu",dcc[count].cnt);
sendout(temps,cwin,col[CDCCINFO]);
if(is_dw_open(dcc[count].dcw))wd_close(dcc[count].dcw);
resetadcc(count);
return 0;
}

}
count++;
}
return 0;
}
Esempio n. 5
0
static int16 getResponse(int16 cnId)
{
	char response[RESPONSESIZE];
	int16 nInQueue;
	int16 rc;
	clock_t to = clock() + TIMEOUT * CLK_TCK;	/* time to quit at */

	/* poll for input */
	while ( (nInQueue = CNbyte_count(cnId)) <= 0 ) {
		if (clock() > to) {
			uiPrintf(uiH, uiPrERR, "get timed out");
			return -1;
		}
		uiYield(uiH, YIELDMS);
	} 

	rc = CNget_block(cnId, response, min(nInQueue, RESPONSESIZE) );
	if (rc != min(nInQueue, RESPONSESIZE)) {
		uiPrintf(uiH, uiPrERR, "get failed");
		return -1;
	}

	return response[0];
}	/* getResponse */
Esempio n. 6
0
void test0130(void)
{
    int handle, res, ok;
    int a,b,c;
    
    out_test_header(0x0130, "UDP - CNbyte_count() on 3 datagrams");
    handle = UDP_open(SERVER_ADDR, SERVER_PORT_START + 4);
    if(handle >= 0) {
        // send 3 x 100 bytes
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        
        sleep(1);
        
        res = CNbyte_count(handle);         // see how many bytes we got for reading on this socket
        ok = (res == 300) ? 1 : 0;      
        
        out_result_error(ok, res);
        //-----------------------------------
        out_test_header(0x0131, "UDP - CNget_block() on 3 datagrams");
        
                                            // receive it using 3x CNget_block()
        a = CNget_block (handle, rBuf, 100);
        b = CNget_block (handle, rBuf, 100);
        c = CNget_block (handle, rBuf, 100);
        
        ok = (a == 100 && b == 100 && c == 100) ? 1 : 0;
        out_result_error(ok, res);
        //-----------------------------------
        
        UDP_close(handle);
    } else {
        out_result_string(0, "UDP_open failed");
    }
    
    //////////////////////////////////////////////////////////////////////////////
    
    out_test_header(0x0132, "UDP - CNbyte_count() after partial read");
    handle = UDP_open(SERVER_ADDR, SERVER_PORT_START + 4);
    if(handle >= 0) {
        // send 300 bytes
        (void) UDP_send(handle, wBuf, 300);
        
        sleep(1);
        
        res = CNbyte_count(handle);         // see how many bytes we got for reading on this socket
        ok = (res == 300) ? 1 : 0;      

        if(!ok) {                           // if not enough data, fail
            out_result_error_string(ok, res, "not enough data");
        } else {
            a = CNget_block (handle, rBuf, 100);
            b = CNbyte_count(handle);
            
            ok = (a == 100 && b == 200) ? 1 : 0;
            out_result_error(ok, b);
         }
        
        UDP_close(handle);
    } else {
        out_result_string(0, "UDP_open failed");
    }    
    
    //////////////////////////////////////////////////////////////////////////////
    
    out_test_header(0x0133, "UDP - get 3 DGRAMs with 1 CNget_block");
    handle = UDP_open(SERVER_ADDR, SERVER_PORT_START + 4);
    if(handle >= 0) {
        // send 300 bytes
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        
        sleep(1);
        
        res = CNbyte_count(handle);         // see how many bytes we got for reading on this socket
        ok = (res == 300) ? 1 : 0;      

        if(!ok) {                           // if not enough data, fail
            out_result_error_string(ok, res, "not enough data");
        } else {
            a = CNget_block (handle, rBuf, 300);
            b = CNbyte_count(handle);
            
            ok = (a == 300 && b == 0) ? 1 : 0;
            out_result_error(ok, b);
         }
        
        UDP_close(handle);
    } else {
        out_result_string(0, "UDP_open failed");
    }        
    
    //////////////////////////////////////////////////////////////////////////////
    
    out_test_header(0x0134, "UDP - get 3 DGRAMs with 3x CNget_NDB");
    handle = UDP_open(SERVER_ADDR, SERVER_PORT_START + 4);
    if(handle >= 0) {
        // send 300 bytes
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        
        sleep(1);
        
        res = CNbyte_count(handle);         // see how many bytes we got for reading on this socket
        ok = (res == 300) ? 1 : 0;      

        if(!ok) {                           // if not enough data, fail
            out_result_error_string(ok, res, "not enough data");
        } else {
            NDB *m,*n,*o;
            
            m = CNget_NDB(handle);
            n = CNget_NDB(handle);
            o = CNget_NDB(handle);
            
            ok = (m != NULL && n != NULL && o != NULL) ? 1 : 0;
            
            if(!ok) {
                out_result_string(ok, "some CNget_NDB failed");
            } else {
                ok = (m->len == 100 && n->len == 100 && o->len == 100) ? 1 : 0;
                
                if(!ok) {
                    out_result_string(ok, "length of NDB block wrong");
                } else {
                    out_result(1);
                }
            }
         }
        
        UDP_close(handle);
    } else {
        out_result_string(0, "UDP_open failed");
    }        

    //////////////////////////////////////////////////////////////////////////////
    
    out_test_header(0x0135, "UDP - get 3 DGRAMs with CNget_char");
    handle = UDP_open(SERVER_ADDR, SERVER_PORT_START + 4);
    if(handle >= 0) {
        // send 300 bytes
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        (void) UDP_send(handle, wBuf, 100);
        
        sleep(1);
        
        res = CNbyte_count(handle);         // see how many bytes we got for reading on this socket
        ok = (res == 300) ? 1 : 0;      

        b = 1;                              // good for now
        if(!ok) {                           // if not enough data, fail
            out_result_error_string(ok, res, "not enough data");
        } else {
            int i;
            for(i=0; i<300; i++) {
                a = CNget_char(handle);
                
                if(a >= 0) {
                    rBuf[i] = a;
                } else {
                    out_result_error_string(0, a, "error on CNget_char");
                    b = 0;                  // failed
                    break;
                }
            }
        
            if(b) {                         // if good, check data
                a = memcmp(rBuf,       wBuf, 100);
                b = memcmp(rBuf + 100, wBuf, 100);
                c = memcmp(rBuf + 200, wBuf, 100);
                
                ok = (a == 0 && b == 0 && c == 0) ? 1 : 0;
                out_result(ok);
            }
         }
        
        UDP_close(handle);
    } else {
        out_result_string(0, "UDP_open failed");
    }
}
Esempio n. 7
0
int sendAndReceive(BYTE tcpNotUdp, DWORD blockSize, int handle, BYTE getBlockNotNdb)
{
    //----------
    // send
    int res;
    DWORD now, endTime;
    DWORD kbs = 1 + (blockSize / 1024);
    
    endTime = getTicks() + (kbs * 200);         // for each kB of data give 1 second to transfer
    
    while(1) {              // try to send
        if(tcpNotUdp) {
            res = TCP_send(handle, wBuf, blockSize);
        } else {
            res = UDP_send(handle, wBuf, blockSize);
        }

        if(res != E_OBUFFULL) {
            break;
        }
        
        now = getTicks();
        if(now >= endTime) {        // timeout? 
            out_result_error_string(0, blockSize, "send() timeout");
            return 0;
        }
    }
    
    if(res != E_NORMAL) { 
        out_result_error_string(0, res, "send() failed");
        return 0;
    }
    
    //----------
    // wait
    endTime = getTicks() + (kbs * 200);         // for each kB of data give 1 second to transfer
    
    memset(rBuf, 0, blockSize);
    BYTE *pBuf  = rBuf;
    DWORD toGet = blockSize;
    
    while(toGet > 0) {
        now = getTicks();
        if(now >= endTime) {                    // timeout?
            out_result_error_string(0, blockSize, "CNbyte_count() timeout");
            return 0;
        }

        res = CNbyte_count(handle);                     // find out how many bytes are waiting

        if(res > 0) {                                   // something waiting? read it
            if(getBlockNotNdb) {                        // retrieve using CNget_block?
                res = CNget_block(handle, pBuf, res);
                
                if(res > 0) {
                    pBuf  += res;
                    toGet -= res;
                } else if(res != E_NODATA && res < 0) {        // if it's some error, and that error is not E_NODATA, fail
                    out_result_error_string(0, blockSize, "CNget_block() failed");
                    return 0;
                }
            } else {                                    // retrieve using CNget_NDB
                NDB *ndb = CNget_NDB(handle);

                if(ndb) {                               // if something retrieved
                    memcpy(pBuf, ndb->ndata, ndb->len); // copy in the data

                    pBuf += ndb->len;                     // it was this many bytes
                    toGet -= ndb->len;

                    KRfree (ndb->ptr);                  // free the ram
                    KRfree (ndb);
                }
            }
        }
    }
    
    //----------
    // data are valid? 
    res = memcmp(rBuf, wBuf, blockSize);
    
    if(res != 0) {
        out_result_string(0, "Received data mismatch");
        return 0;
    }

    //-------
    // if came here, everything is OK
    return 1;
}
Esempio n. 8
0
/* wait for the response from the newsserver */
int news_receive(int cn, char *file, int file_reqd)
{
	/* copied from http_get in CABCOVL.C  */
	int16 x, bytes_available, eof=0;
	long bytes_read=0,rc;
	int return_code=0;
	int file_handle, status=0, header_pos=0;
	time_t timeout,kicker,total;
	int bug=0;
	int sbuf=sizeof(buffer);

	if (file_reqd) {
		file_handle=(int) Fcreate(file, 0);
		if (bug) {
			fprintf( log, "news_receive - opening file = %d\n", file_handle );
			fflush( log );
		}
		if (file_handle<0) {
			#ifdef ERR_MSGS
				printf("Couldn't create %s!\n", file);
			#endif
			return(1);
		}
	}
	total=clock();					/* total time in routine */
	timeout=clock()+max_to*CLK_TCK;	/* timeout */
	kicker=clock()+kick*CLK_TCK;		/* conversation kicker */
	if (file_reqd) {
		browser->msg_status(2,0); /* Getting data... */
	}
	if (file_reqd==2) { status=2; }

	while (eof==0) {
		bytes_available=CNbyte_count(cn);
		/* printf("received %d bytes \n", (long)bytes_available ); */

		if (handle_escape_events()==27) { eof=4; }
		/*
		if (Bconstat(2)==-1 && (Bconin(2) & 0xFF)==27) { eof=4;	}
		*/
		if (clock()>timeout) {
			#ifdef MDEBUG
				printf("Timeout!\n");
			#endif
			eof=2;
		} else if (clock()>kicker) {
			#ifdef MDEBUG
				printf("Kick Connection!\n");
			#endif
			CNkick(cn);
			kicker=clock()+kick*CLK_TCK;	/* conversation kicker */
		} else if (bytes_available==E_EOF) {
			#ifdef MDEBUG
				printf("EOF!\n");
			#endif
			eof=1;
		} else if (bytes_available<E_NODATA) {
			#ifdef ERR_MSGS
				printf("CNbyte_count() returns: %s\n", get_err_text(bytes_available));
			#endif
			eof=3;
		} else if (bytes_available>0) {
			timeout=clock()+char_to*CLK_TCK;	/* timeout after last char */
			kicker=clock()+kick*CLK_TCK;		/* conversation kicker */
			if (status==2) {
				if (bytes_available>sbuf) { bytes_available=sbuf; }
				if (CNget_block(cn, buffer, bytes_available)>=E_NODATA) {
					rc = Fwrite(file_handle, bytes_available, &buffer);
					if (rc!=bytes_available) { 	/* didn't write everything */
						file_write_error(rc);
						Fclose(file_handle);
						return(1);
					}
					bytes_read+=bytes_available;
					if (bug) {
						fprintf( log, "received %d bytes, total %ld\n",
							bytes_available , bytes_read);
						fflush( log );
					} else { browser->msg_status(2, bytes_read); }

				/* look for period (.) on a line by itself */
					if (strncmp(&buffer[bytes_available-5], "\r\n.\r\n", 5)==0 ||
					    strncmp(&buffer[bytes_available-5], "\n\r.\n\r", 5)==0 ||
					    strncmp(&buffer[bytes_available-3], "\r.\r", 3)==0 ||
					    strncmp(&buffer[bytes_available-3], "\n.\n", 3)==0)
					eof=1;
					if (bytes_read==3 &&
					    strncmp(&buffer[bytes_available-3], ".\r\n", 3)==0)
					eof=1;
				} else {
					#ifdef ERR_MSGS
						printf("Error in CNget_block()!\n");
					#endif
					eof=3;
				}
			} else {
				x = CNget_char(cn);
				if (x<E_NODATA) {
					#ifdef ERR_MSGS
						printf("CNget_char() returns: %s\n", get_err_text(x));
					#endif
					eof=3;
				} else
					header[header_pos++]=(char) x;
			}
			/* only an empty line and response line in NNTP responses */
			/* when status = 0, drop until valid non-control, when = 1, store in header */
			if (status==0) {
				if (strncmp(&header[header_pos-1], " ", 1)<0) {
					header_pos = 0;
				} else { status++;}
			}
			if (status==1) {
				if (strncmp(&header[header_pos-2], "\r\n", 2)==0 ||
				    strncmp(&header[header_pos-2], "\n\r", 2)==0) {
				/*	strncmp(&header[header_pos-1], "\r", 1)==0 ||
				    strncmp(&header[header_pos-1], "\n", 1)==0) { */
					header[header_pos-2]=0;
					if (log_resp=='Y') { fprintf( log, "%s\n", header ); fflush(log); }
					#ifdef MDEBUG
						printf("Header: %s\n", header );
						printf("End of header.\n");
					#endif
					if (!file_reqd) { eof=1; } else { status++; }
					if (memcmp(header,"423",3)==0) { eof=1; }
				} else if (header_pos>2000) {
					rc = Fwrite(file_handle, header_pos, header);
					if (rc!=header_pos) { 	/* didn't write everything */
						file_write_error(rc);
						Fclose(file_handle);
						return(1);
					}
					status++;
				}
			}
		}
	}
	#ifdef MDEBUG
	printf("EOF= %d \n", (long)eof );
	#endif

	if (eof>1) {	/* timeout or worse*/
	/*	x = (int16)TCP_close(cn, 2);
		if (x < 0) {
			#ifdef MDEBUG
				printf("TCP_close() returns: %s\n", get_err_text(x));
			#endif
		} 
	*/
		if (bug) {
			fprintf( log, "news_receive - error - eof = %d\n", eof );
			fflush( log );
		}	
		if (file_reqd) {
		#ifdef MDEBUG
			printf("Fclose returns %i\n", Fclose(file_handle));
		#else
			/**** I might get a bug here! ****/
			if((x=(int16)Fclose(file_handle))<0) {
				#ifdef ERR_MSGS
					printf("Error with Fclose! (%i)\n", x);
				#endif
			}
		#endif
			if (bug) {
				fprintf( log, "news_receive - error - closing file = %d\n", x );
				fflush( log );
			}
		}
		if (eof==3) { eof=bytes_available; }  /* return negative value */
		return(eof);
	}	

	if (file_reqd) {
		if (log_data=='Y') {
			total=clock()-total;	/* total time in clock ticks */
			if (total) {
				fprintf( log, "Transfer Rate = %ld cps\n", (bytes_read*CLK_TCK)/total ); fflush(log);
			}
		}
		#ifdef MDEBUG
			printf("Fclose returns %d\n", Fclose(file_handle));
		#else
			if((x=(int16)Fclose(file_handle))<0)	browser->msg_error(x);
		#endif
		if (bug) {
			fprintf( log, "news_receive - good - closing file = %d\n", x );
			fflush( log );
		}
	}
	#ifdef MDEBUG
		printf("Hit a key.\n");
		Bconin(2);
	#endif
	return(return_code);	/* return(0)     if getting data was successful,	 */
        					/* return(errno) if it fails, return an error number */
}