![[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 / src / xpdev|
Return to sockwrap.c CVS log | Up to [Synchronet] / sbbs / src / xpdev |
1.1 ! root 1: /* sockwrap.c */ ! 2: ! 3: /* Berkley/WinSock socket API wrappers */ ! 4: ! 5: /* $Id: sockwrap.c,v 1.32 2006/05/09 21:02:55 deuce 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 2005 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> /* alloca/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: #if defined(_WIN32) ! 44: #include <malloc.h> /* alloca() on Win32 */ ! 45: #endif ! 46: ! 47: #include "genwrap.h" /* SLEEP */ ! 48: #include "gen_defs.h" /* BOOL/LOG_WARNING */ ! 49: #include "sockwrap.h" /* sendsocket */ ! 50: #include "filewrap.h" /* filelength */ ! 51: ! 52: static socket_option_t socket_options[] = { ! 53: { "TYPE", 0, SOL_SOCKET, SO_TYPE }, ! 54: { "ERROR", 0, SOL_SOCKET, SO_ERROR }, ! 55: { "DEBUG", 0, SOL_SOCKET, SO_DEBUG }, ! 56: { "LINGER", SOCK_STREAM, SOL_SOCKET, SO_LINGER }, ! 57: { "SNDBUF", 0, SOL_SOCKET, SO_SNDBUF }, ! 58: { "RCVBUF", 0, SOL_SOCKET, SO_RCVBUF }, ! 59: ! 60: #ifndef _WINSOCKAPI_ /* Defined, but not supported, by WinSock */ ! 61: { "SNDLOWAT", 0, SOL_SOCKET, SO_SNDLOWAT }, ! 62: { "RCVLOWAT", 0, SOL_SOCKET, SO_RCVLOWAT }, ! 63: { "SNDTIMEO", 0, SOL_SOCKET, SO_SNDTIMEO }, ! 64: { "RCVTIMEO", 0, SOL_SOCKET, SO_RCVTIMEO }, ! 65: #ifdef SO_USELOOPBACK /* SunOS */ ! 66: { "USELOOPBACK", 0, SOL_SOCKET, SO_USELOOPBACK }, ! 67: #endif ! 68: #endif ! 69: ! 70: { "REUSEADDR", 0, SOL_SOCKET, SO_REUSEADDR }, ! 71: { "KEEPALIVE", SOCK_STREAM, SOL_SOCKET, SO_KEEPALIVE }, ! 72: { "DONTROUTE", 0, SOL_SOCKET, SO_DONTROUTE }, ! 73: { "BROADCAST", SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST }, ! 74: { "OOBINLINE", SOCK_STREAM, SOL_SOCKET, SO_OOBINLINE }, ! 75: ! 76: #ifdef SO_ACCEPTCONN ! 77: { "ACCEPTCONN", SOCK_STREAM, SOL_SOCKET, SO_ACCEPTCONN }, ! 78: #endif ! 79: #ifdef SO_PRIORITY /* Linux */ ! 80: { "PRIORITY", 0, SOL_SOCKET, SO_PRIORITY }, ! 81: #endif ! 82: #ifdef SO_NO_CHECK /* Linux */ ! 83: { "NO_CHECK", 0, SOL_SOCKET, SO_NO_CHECK }, ! 84: #endif ! 85: #ifdef SO_PROTOTYPE /* SunOS */ ! 86: { "PROTOTYPE", 0, SOL_SOCKET, SO_PROTOTYPE }, ! 87: #endif ! 88: #ifdef SO_MAX_MSG_SIZE /* WinSock2 */ ! 89: { "MAX_MSG_SIZE", SOCK_DGRAM, SOL_SOCKET, SO_MAX_MSG_SIZE }, ! 90: #endif ! 91: #ifdef SO_CONNECT_TIME /* WinSock2 */ ! 92: { "CONNECT_TIME", SOCK_STREAM, SOL_SOCKET, SO_CONNECT_TIME }, ! 93: #endif ! 94: ! 95: /* IPPROTO-level socket options */ ! 96: { "TCP_NODELAY", SOCK_STREAM, IPPROTO_TCP, TCP_NODELAY }, ! 97: /* The following are platform-specific */ ! 98: #ifdef TCP_MAXSEG ! 99: { "TCP_MAXSEG", SOCK_STREAM, IPPROTO_TCP, TCP_MAXSEG }, ! 100: #endif ! 101: #ifdef TCP_CORK ! 102: { "TCP_CORK", SOCK_STREAM, IPPROTO_TCP, TCP_CORK }, ! 103: #endif ! 104: #ifdef TCP_KEEPIDLE ! 105: { "TCP_KEEPIDLE", SOCK_STREAM, IPPROTO_TCP, TCP_KEEPIDLE }, ! 106: #endif ! 107: #ifdef TCP_KEEPINTVL ! 108: { "TCP_KEEPINTVL", SOCK_STREAM, IPPROTO_TCP, TCP_KEEPINTVL }, ! 109: #endif ! 110: #ifdef TCP_KEEPCNT ! 111: { "TCP_KEEPCNT", SOCK_STREAM, IPPROTO_TCP, TCP_KEEPCNT }, ! 112: #endif ! 113: #ifdef TCP_KEEPALIVE /* SunOS */ ! 114: { "TCP_KEEPALIVE", SOCK_STREAM, IPPROTO_TCP, TCP_KEEPALIVE }, ! 115: #endif ! 116: #ifdef TCP_SYNCNT ! 117: { "TCP_SYNCNT", SOCK_STREAM, IPPROTO_TCP, TCP_SYNCNT }, ! 118: #endif ! 119: #ifdef TCP_LINGER2 ! 120: { "TCP_LINGER2", SOCK_STREAM, IPPROTO_TCP, TCP_LINGER2 }, ! 121: #endif ! 122: #ifdef TCP_DEFER_ACCEPT ! 123: { "TCP_DEFER_ACCEPT", SOCK_STREAM, IPPROTO_TCP, TCP_DEFER_ACCEPT }, ! 124: #endif ! 125: #ifdef TCP_WINDOW_CLAMP ! 126: { "TCP_WINDOW_CLAMP", SOCK_STREAM, IPPROTO_TCP, TCP_WINDOW_CLAMP }, ! 127: #endif ! 128: #ifdef TCP_QUICKACK ! 129: { "TCP_QUICKACK", SOCK_STREAM, IPPROTO_TCP, TCP_QUICKACK }, ! 130: #endif ! 131: #ifdef TCP_NOPUSH ! 132: { "TCP_NOPUSH", SOCK_STREAM, IPPROTO_TCP, TCP_NOPUSH }, ! 133: #endif ! 134: #ifdef TCP_NOOPT ! 135: { "TCP_NOOPT", SOCK_STREAM, IPPROTO_TCP, TCP_NOOPT }, ! 136: #endif ! 137: { NULL } ! 138: }; ! 139: ! 140: int getSocketOptionByName(const char* name, int* level) ! 141: { ! 142: int i; ! 143: ! 144: if(level!=NULL) ! 145: *level=SOL_SOCKET; /* default option level */ ! 146: for(i=0;socket_options[i].name;i++) { ! 147: if(stricmp(name,socket_options[i].name)==0) { ! 148: if(level!=NULL) ! 149: *level = socket_options[i].level; ! 150: return(socket_options[i].value); ! 151: } ! 152: } ! 153: if(!isdigit(*name)) /* unknown option name */ ! 154: return(-1); ! 155: return(strtol(name,NULL,0)); ! 156: } ! 157: ! 158: socket_option_t* getSocketOptionList(void) ! 159: { ! 160: return(socket_options); ! 161: } ! 162: ! 163: int sendfilesocket(int sock, int file, long *offset, long count) ! 164: { ! 165: char buf[1024*16]; ! 166: long len; ! 167: int rd; ! 168: int wr=0; ! 169: int total=0; ! 170: int i; ! 171: ! 172: /* sendfile() on Linux may or may not work with non-blocking sockets ToDo */ ! 173: len=filelength(file); ! 174: ! 175: if(offset!=NULL) ! 176: if(lseek(file,*offset,SEEK_SET)<0) ! 177: return(-1); ! 178: ! 179: if(count<1 || count>len) { ! 180: count=len; ! 181: count-=tell(file); /* don't try to read beyond EOF */ ! 182: } ! 183: #if USE_SENDFILE ! 184: while((i=sendfile(file,sock,(offset==NULL?0:*offset)+total,count-total,NULL,&wr,0))==-1 && errno==EAGAIN) { ! 185: total+=wr; ! 186: SLEEP(1); ! 187: } ! 188: if(i==0) ! 189: return((int)count); ! 190: #endif ! 191: ! 192: if(count<0) { ! 193: errno=EINVAL; ! 194: return(-1); ! 195: } ! 196: ! 197: while(total<count) { ! 198: rd=read(file,buf,sizeof(buf)); ! 199: if(rd==-1) ! 200: return(-1); ! 201: if(rd==0) ! 202: break; ! 203: for(i=wr=0;i<rd;i+=wr) { ! 204: wr=sendsocket(sock,buf+i,rd-i); ! 205: if(wr>0) ! 206: continue; ! 207: if(wr==SOCKET_ERROR && ERROR_VALUE==EWOULDBLOCK) { ! 208: wr=0; ! 209: SLEEP(1); ! 210: continue; ! 211: } ! 212: return(wr); ! 213: } ! 214: if(i!=rd) ! 215: return(-1); ! 216: total+=rd; ! 217: } ! 218: ! 219: if(offset!=NULL) ! 220: (*offset)+=total; ! 221: ! 222: return(total); ! 223: } ! 224: ! 225: int recvfilesocket(int sock, int file, long *offset, long count) ! 226: { ! 227: /* Writes a file from a socket - ! 228: * ! 229: * sock - Socket to read from ! 230: * file - File descriptior to write to ! 231: * MUST be open and writeable ! 232: * offset - pointer to file offset to start writing at ! 233: * is set to offset writing STOPPED ! 234: * on return ! 235: * count - number of bytes to read/write ! 236: * ! 237: * returns -1 if an error occurse, otherwise ! 238: * returns number ob bytes written and sets offset ! 239: * to the new offset ! 240: */ ! 241: ! 242: char* buf; ! 243: int rd; ! 244: int wr; ! 245: ! 246: if(count<1) { ! 247: errno=ERANGE; ! 248: return(-1); ! 249: } ! 250: ! 251: if((buf=(char*)alloca(count))==NULL) { ! 252: errno=ENOMEM; ! 253: return(-1); ! 254: } ! 255: ! 256: if(offset!=NULL) ! 257: if(lseek(file,*offset,SEEK_SET)<0) ! 258: return(-1); ! 259: ! 260: rd=read(sock,buf,count); ! 261: if(rd!=count) ! 262: return(-1); ! 263: ! 264: wr=write(file,buf,rd); ! 265: ! 266: if(offset!=NULL) ! 267: (*offset)+=wr; ! 268: ! 269: return(wr); ! 270: } ! 271: ! 272: ! 273: /* Return true if connected, optionally sets *rd_p to true if read data available */ ! 274: BOOL socket_check(SOCKET sock, BOOL* rd_p, BOOL* wr_p, DWORD timeout) ! 275: { ! 276: char ch; ! 277: int i,rd; ! 278: fd_set rd_set; ! 279: fd_set* rd_set_p=&rd_set; ! 280: fd_set wr_set; ! 281: fd_set* wr_set_p=NULL; ! 282: struct timeval tv; ! 283: ! 284: if(rd_p!=NULL) ! 285: *rd_p=FALSE; ! 286: ! 287: if(wr_p!=NULL) ! 288: *wr_p=FALSE; ! 289: ! 290: if(sock==INVALID_SOCKET) ! 291: return(FALSE); ! 292: ! 293: FD_ZERO(&rd_set); ! 294: FD_SET(sock,&rd_set); ! 295: if(wr_p!=NULL) { ! 296: wr_set_p=&wr_set; ! 297: FD_ZERO(wr_set_p); ! 298: FD_SET(sock,wr_set_p); ! 299: if(rd_p==NULL) ! 300: rd_set_p=NULL; ! 301: } ! 302: ! 303: /* Convert timeout from ms to sec/usec */ ! 304: tv.tv_sec=timeout/1000; ! 305: tv.tv_usec=(timeout%1000)*1000; ! 306: ! 307: i=select(sock+1,rd_set_p,wr_set_p,NULL,&tv); ! 308: if(i==SOCKET_ERROR) ! 309: return(FALSE); ! 310: ! 311: if(i==0) ! 312: return(TRUE); ! 313: ! 314: if(wr_p!=NULL && FD_ISSET(sock,wr_set_p)) { ! 315: *wr_p=TRUE; ! 316: if(i==1) ! 317: return(TRUE); ! 318: } ! 319: ! 320: if(rd_p !=NULL || wr_p==NULL) { ! 321: rd=recv(sock,&ch,1,MSG_PEEK); ! 322: if(rd==1 ! 323: || (rd==SOCKET_ERROR && ERROR_VALUE==EMSGSIZE)) { ! 324: if(rd_p!=NULL) ! 325: *rd_p=TRUE; ! 326: return(TRUE); ! 327: } ! 328: } ! 329: ! 330: return(FALSE); ! 331: } ! 332: ! 333: int retry_bind(SOCKET s, const struct sockaddr *addr, socklen_t addrlen ! 334: ,uint retries, uint wait_secs ! 335: ,const char* prot ! 336: ,int (*lprintf)(int level, char *fmt, ...)) ! 337: { ! 338: char port_str[128]; ! 339: int result=-1; ! 340: uint i; ! 341: ! 342: if(addr->sa_family==AF_INET) ! 343: SAFEPRINTF(port_str," to port %u",ntohs(((SOCKADDR_IN *)(addr))->sin_port)); ! 344: else ! 345: port_str[0]=0; ! 346: for(i=0;i<=retries;i++) { ! 347: if((result=bind(s,addr,addrlen))==0) ! 348: break; ! 349: if(lprintf!=NULL) ! 350: lprintf(i<retries ? LOG_WARNING:LOG_ERR ! 351: ,"%04d !ERROR %d binding %s socket%s", s, ERROR_VALUE, prot, port_str); ! 352: if(i<retries) { ! 353: if(lprintf!=NULL) ! 354: lprintf(LOG_WARNING,"%04d Will retry in %u seconds (%u of %u)" ! 355: ,s, wait_secs, i+1, retries); ! 356: SLEEP(wait_secs*1000); ! 357: } ! 358: } ! 359: return(result); ! 360: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.