![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sockwrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / xpdev|
Return to sockwrap.c CVS log | Up to [Synchronet] / sbbs / xpdev |
1.1 ! root 1: /* sockwrap.c */ ! 2: ! 3: /* Berkley/WinSock socket API wrappers */ ! 4: ! 5: /* $Id: sockwrap.c,v 1.24 2005/01/01 00:52:43 rswindell Exp $ */ ! 6: ! 7: /**************************************************************************** ! 8: * @format.tab-size 4 (Plain Text/Source Code File Header) * ! 9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) * ! 10: * * ! 11: * Copyright 2004 Rob Swindell - http://www.synchro.net/copyright.html * ! 12: * * ! 13: * This library is free software; you can redistribute it and/or * ! 14: * modify it under the terms of the GNU Lesser General Public License * ! 15: * as published by the Free Software Foundation; either version 2 * ! 16: * of the License, or (at your option) any later version. * ! 17: * See the GNU Lesser General Public License for more details: lgpl.txt or * ! 18: * http://www.fsf.org/copyleft/lesser.html * ! 19: * * ! 20: * Anonymous FTP access to the most recent released source is available at * ! 21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net * ! 22: * * ! 23: * Anonymous CVS access to the development source and modification history * ! 24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: * ! 25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login * ! 26: * (just hit return, no password is necessary) * ! 27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src * ! 28: * * ! 29: * For Synchronet coding style and modification guidelines, see * ! 30: * http://www.synchro.net/source.html * ! 31: * * ! 32: * You are encouraged to submit any modifications (preferably in Unix diff * ! 33: * format) via e-mail to [email protected] * ! 34: * * ! 35: * Note: If this box doesn't appear square, then you need to fix your tabs. * ! 36: ****************************************************************************/ ! 37: ! 38: #include <stdlib.h> /* malloc/free on FreeBSD */ ! 39: #include <string.h> /* bzero (for FD_ZERO) on FreeBSD */ ! 40: #include <errno.h> /* ENOMEM */ ! 41: #include <stdio.h> /* SEEK_SET */ ! 42: #include <string.h> ! 43: ! 44: #include "genwrap.h" /* SLEEP */ ! 45: #include "gen_defs.h" /* BOOL/LOG_WARNING */ ! 46: #include "sockwrap.h" /* sendsocket */ ! 47: #include "filewrap.h" /* filelength */ ! 48: ! 49: int sendfilesocket(int sock, int file, long *offset, long count) ! 50: { ! 51: /* sendfile() on Linux may or may not work with non-blocking sockets ToDo */ ! 52: #if defined(__FreeBSD__) && 0 ! 53: #warning FreeBSD sendfile may cause problems! ! 54: off_t total=0; ! 55: off_t wr=0; ! 56: int i; ! 57: long len; ! 58: ! 59: len=filelength(file); ! 60: if(count<1 || count>len) { ! 61: count=len; ! 62: count-=offset==NULL?0:*offset; ! 63: } ! 64: while((i=sendfile(file,sock,(offset==NULL?0:*offset)+total,count-total,NULL,&wr,0))==-1 && errno==EAGAIN) { ! 65: total+=wr; ! 66: SLEEP(1); ! 67: } ! 68: if(i==0) ! 69: return((int)count); ! 70: return(i); ! 71: #else ! 72: char* buf; ! 73: long len; ! 74: int rd; ! 75: int wr; ! 76: int total; ! 77: ! 78: if(offset!=NULL) ! 79: if(lseek(file,*offset,SEEK_SET)<0) ! 80: return(-1); ! 81: ! 82: len=filelength(file); ! 83: ! 84: if(count<1 || count>len) { ! 85: count=len; ! 86: count-=tell(file); /* don't try to read beyond EOF */ ! 87: } ! 88: ! 89: if((buf=(char*)malloc(count))==NULL) { ! 90: errno=ENOMEM; ! 91: return(-1); ! 92: } ! 93: ! 94: rd=read(file,buf,count); ! 95: if(rd!=count) { ! 96: free(buf); ! 97: return(-1); ! 98: } ! 99: ! 100: for(total=wr=0;total<count;total+=wr) { ! 101: wr=sendsocket(sock,buf+total,count-total); ! 102: if(wr>0) ! 103: continue; ! 104: if(wr==SOCKET_ERROR && ERROR_VALUE==EWOULDBLOCK) { ! 105: wr=0; ! 106: SLEEP(1); ! 107: continue; ! 108: } ! 109: break; ! 110: } ! 111: ! 112: free(buf); ! 113: ! 114: if(offset!=NULL) ! 115: (*offset)+=total; ! 116: ! 117: if(wr<1) ! 118: return(wr); ! 119: ! 120: return(total); ! 121: #endif ! 122: } ! 123: ! 124: int recvfilesocket(int sock, int file, long *offset, long count) ! 125: { ! 126: /* Writes a file from a socket - ! 127: * ! 128: * sock - Socket to read from ! 129: * file - File descriptior to write to ! 130: * MUST be open and writeable ! 131: * offset - pointer to file offset to start writing at ! 132: * is set to offset writing STOPPED ! 133: * on return ! 134: * count - number of bytes to read/write ! 135: * ! 136: * returns -1 if an error occurse, otherwise ! 137: * returns number ob bytes written and sets offset ! 138: * to the new offset ! 139: */ ! 140: ! 141: char* buf; ! 142: int rd; ! 143: int wr; ! 144: ! 145: if(count<1) { ! 146: errno=ERANGE; ! 147: return(-1); ! 148: } ! 149: ! 150: if((buf=(char*)malloc(count))==NULL) { ! 151: errno=ENOMEM; ! 152: return(-1); ! 153: } ! 154: ! 155: if(offset!=NULL) ! 156: if(lseek(file,*offset,SEEK_SET)<0) ! 157: return(-1); ! 158: ! 159: rd=read(sock,buf,count); ! 160: if(rd!=count) { ! 161: free(buf); ! 162: return(-1); ! 163: } ! 164: ! 165: wr=write(file,buf,rd); ! 166: free(buf); ! 167: ! 168: if(offset!=NULL) ! 169: (*offset)+=wr; ! 170: ! 171: return(wr); ! 172: } ! 173: ! 174: ! 175: /* Return true if connected, optionally sets *rd_p to true if read data available */ ! 176: BOOL socket_check(SOCKET sock, BOOL* rd_p, BOOL* wr_p, DWORD timeout) ! 177: { ! 178: char ch; ! 179: int i,rd; ! 180: fd_set rd_set; ! 181: fd_set* rd_set_p=&rd_set; ! 182: fd_set wr_set; ! 183: fd_set* wr_set_p=NULL; ! 184: struct timeval tv; ! 185: ! 186: if(rd_p!=NULL) ! 187: *rd_p=FALSE; ! 188: ! 189: if(wr_p!=NULL) ! 190: *wr_p=FALSE; ! 191: ! 192: if(sock==INVALID_SOCKET) ! 193: return(FALSE); ! 194: ! 195: FD_ZERO(&rd_set); ! 196: FD_SET(sock,&rd_set); ! 197: if(wr_p!=NULL) { ! 198: wr_set_p=&wr_set; ! 199: FD_ZERO(wr_set_p); ! 200: FD_SET(sock,wr_set_p); ! 201: if(rd_p==NULL) ! 202: rd_set_p=NULL; ! 203: } ! 204: ! 205: /* Convert timeout from ms to sec/usec */ ! 206: tv.tv_sec=timeout/1000; ! 207: tv.tv_usec=(timeout%1000)*1000; ! 208: ! 209: i=select(sock+1,rd_set_p,wr_set_p,NULL,&tv); ! 210: if(i==SOCKET_ERROR) ! 211: return(FALSE); ! 212: ! 213: if(i==0) ! 214: return(TRUE); ! 215: ! 216: if(wr_p!=NULL && FD_ISSET(sock,wr_set_p)) { ! 217: *wr_p=TRUE; ! 218: if(i==1) ! 219: return(TRUE); ! 220: } ! 221: ! 222: if(rd_p !=NULL || wr_p==NULL) { ! 223: rd=recv(sock,&ch,1,MSG_PEEK); ! 224: if(rd==1 ! 225: || (rd==SOCKET_ERROR && ERROR_VALUE==EMSGSIZE)) { ! 226: if(rd_p!=NULL) ! 227: *rd_p=TRUE; ! 228: return(TRUE); ! 229: } ! 230: } ! 231: ! 232: return(FALSE); ! 233: } ! 234: ! 235: int retry_bind(SOCKET s, const struct sockaddr *addr, socklen_t addrlen ! 236: ,uint retries, uint wait_secs ! 237: ,const char* prot ! 238: ,int (*lprintf)(int level, char *fmt, ...)) ! 239: { ! 240: char port_str[128]; ! 241: int result=-1; ! 242: uint i; ! 243: ! 244: if(addr->sa_family==AF_INET) ! 245: SAFEPRINTF(port_str," to port %u",ntohs(((SOCKADDR_IN *)(addr))->sin_port)); ! 246: else ! 247: port_str[0]=0; ! 248: for(i=0;i<=retries;i++) { ! 249: if((result=bind(s,addr,addrlen))==0) ! 250: break; ! 251: if(lprintf!=NULL) ! 252: lprintf(i<retries ? LOG_WARNING:LOG_ERR ! 253: ,"%04d !ERROR %d binding %s socket%s", s, ERROR_VALUE, prot, port_str); ! 254: if(i<retries) { ! 255: if(lprintf!=NULL) ! 256: lprintf(LOG_WARNING,"%04d Will retry in %u seconds (%u of %u)" ! 257: ,s, wait_secs, i+1, retries); ! 258: SLEEP(wait_secs*1000); ! 259: } ! 260: } ! 261: return(result); ! 262: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.