sockwrap.c 11.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
/* sockwrap.c */

/* Berkley/WinSock socket API wrappers */

/* $Id$ */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
11
 * Copyright 2011 Rob Swindell - http://www.synchro.net/copyright.html		*
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 *																			*
 * This library is free software; you can redistribute it and/or			*
 * modify it under the terms of the GNU Lesser General Public License		*
 * as published by the Free Software Foundation; either version 2			*
 * of the License, or (at your option) any later version.					*
 * See the GNU Lesser General Public License for more details: lgpl.txt or	*
 * http://www.fsf.org/copyleft/lesser.html									*
 *																			*
 * Anonymous FTP access to the most recent released source is available at	*
 * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net	*
 *																			*
 * Anonymous CVS access to the development source and modification history	*
 * is available at cvs.synchro.net:/cvsroot/sbbs, example:					*
 * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login			*
 *     (just hit return, no password is necessary)							*
 * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src		*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * You are encouraged to submit any modifications (preferably in Unix diff	*
 * format) via e-mail to mods@synchro.net									*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

deuce's avatar
deuce committed
38
#include <ctype.h>		/* isdigit */
39
#include <stdlib.h>		/* alloca/free on FreeBSD */
40
#include <string.h>		/* bzero (for FD_ZERO) on FreeBSD */
41
#include <errno.h>		/* ENOMEM */
42
#include <stdio.h>		/* SEEK_SET */
43
#include <string.h>
44
45
46
#if defined(_WIN32)
 #include <malloc.h>	/* alloca() on Win32 */
#endif
47

48
#include "genwrap.h"	/* SLEEP */
deuce's avatar
deuce committed
49
#include "gen_defs.h"	/* BOOL/LOG_WARNING */
50
51
52
#include "sockwrap.h"	/* sendsocket */
#include "filewrap.h"	/* filelength */

53
static socket_option_t socket_options[] = {
54
	{ "TYPE",				0,				SOL_SOCKET,		SO_TYPE				},
55
	{ "ERROR",				0,				SOL_SOCKET,		SO_ERROR			},
56
57
58
59
	{ "DEBUG",				0,				SOL_SOCKET,		SO_DEBUG			},
	{ "LINGER",				SOCK_STREAM,	SOL_SOCKET,		SO_LINGER			},
	{ "SNDBUF",				0,				SOL_SOCKET,		SO_SNDBUF			},
	{ "RCVBUF",				0,				SOL_SOCKET,		SO_RCVBUF			},
60
61

#ifndef _WINSOCKAPI_	/* Defined, but not supported, by WinSock */
62
63
64
65
	{ "SNDLOWAT",			0,				SOL_SOCKET,		SO_SNDLOWAT			},
	{ "RCVLOWAT",			0,				SOL_SOCKET,		SO_RCVLOWAT			},
	{ "SNDTIMEO",			0,				SOL_SOCKET,		SO_SNDTIMEO			},
	{ "RCVTIMEO",			0,				SOL_SOCKET,		SO_RCVTIMEO			},
66
67
68
#ifdef SO_USELOOPBACK	/* SunOS */
	{ "USELOOPBACK",		0,				SOL_SOCKET,		SO_USELOOPBACK		},
#endif
69
#endif
70

71
	{ "REUSEADDR",			0,				SOL_SOCKET,		SO_REUSEADDR		},	
deuce's avatar
deuce committed
72
73
74
#ifdef SO_REUSEPORT	/* BSD */
	{ "REUSEPORT",			0,				SOL_SOCKET,		SO_REUSEPORT		},	
#endif
75
76
77
78
	{ "KEEPALIVE",			SOCK_STREAM,	SOL_SOCKET,		SO_KEEPALIVE		},
	{ "DONTROUTE",			0,				SOL_SOCKET,		SO_DONTROUTE		},
	{ "BROADCAST",			SOCK_DGRAM,		SOL_SOCKET,		SO_BROADCAST		},
	{ "OOBINLINE",			SOCK_STREAM,	SOL_SOCKET,		SO_OOBINLINE		},
79

80
#ifdef SO_ACCEPTCONN											
81
	{ "ACCEPTCONN",			SOCK_STREAM,	SOL_SOCKET,		SO_ACCEPTCONN		},
82
#endif
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#ifdef SO_PRIORITY		/* Linux */
	{ "PRIORITY",			0,				SOL_SOCKET,		SO_PRIORITY			},
#endif
#ifdef SO_NO_CHECK		/* Linux */
	{ "NO_CHECK",			0,				SOL_SOCKET,		SO_NO_CHECK			},
#endif
#ifdef SO_PROTOTYPE		/* SunOS */
	{ "PROTOTYPE",			0,				SOL_SOCKET,		SO_PROTOTYPE		},
#endif
#ifdef SO_MAX_MSG_SIZE	/* WinSock2 */
	{ "MAX_MSG_SIZE",		SOCK_DGRAM,		SOL_SOCKET,		SO_MAX_MSG_SIZE		},
#endif
#ifdef SO_CONNECT_TIME	/* WinSock2 */
	{ "CONNECT_TIME",		SOCK_STREAM,	SOL_SOCKET,		SO_CONNECT_TIME		},
#endif
98
99

	/* IPPROTO-level socket options */
100
	{ "TCP_NODELAY",		SOCK_STREAM,	IPPROTO_TCP,	TCP_NODELAY			},
101
102
	/* The following are platform-specific */					
#ifdef TCP_MAXSEG											
103
	{ "TCP_MAXSEG",			SOCK_STREAM,	IPPROTO_TCP,	TCP_MAXSEG			},
104
105
#endif															
#ifdef TCP_CORK													
106
	{ "TCP_CORK",			SOCK_STREAM,	IPPROTO_TCP,	TCP_CORK			},
107
108
#endif															
#ifdef TCP_KEEPIDLE												
109
	{ "TCP_KEEPIDLE",		SOCK_STREAM,	IPPROTO_TCP,	TCP_KEEPIDLE		},
110
111
#endif															
#ifdef TCP_KEEPINTVL											
112
	{ "TCP_KEEPINTVL",		SOCK_STREAM,	IPPROTO_TCP,	TCP_KEEPINTVL		},
113
114
#endif															
#ifdef TCP_KEEPCNT												
115
	{ "TCP_KEEPCNT",		SOCK_STREAM,	IPPROTO_TCP,	TCP_KEEPCNT			},
116
#endif															
117
118
119
#ifdef TCP_KEEPALIVE	/* SunOS */
	{ "TCP_KEEPALIVE",		SOCK_STREAM,	IPPROTO_TCP,	TCP_KEEPALIVE		},
#endif															
120
#ifdef TCP_SYNCNT												
121
	{ "TCP_SYNCNT",			SOCK_STREAM,	IPPROTO_TCP,	TCP_SYNCNT			},
122
123
#endif															
#ifdef TCP_LINGER2												
124
	{ "TCP_LINGER2",		SOCK_STREAM,	IPPROTO_TCP,	TCP_LINGER2			},
125
126
#endif														
#ifdef TCP_DEFER_ACCEPT										
127
	{ "TCP_DEFER_ACCEPT",	SOCK_STREAM,	IPPROTO_TCP,	TCP_DEFER_ACCEPT	},
128
129
#endif															
#ifdef TCP_WINDOW_CLAMP											
130
	{ "TCP_WINDOW_CLAMP",	SOCK_STREAM,	IPPROTO_TCP,	TCP_WINDOW_CLAMP	},
131
132
#endif														
#ifdef TCP_QUICKACK											
133
	{ "TCP_QUICKACK",		SOCK_STREAM,	IPPROTO_TCP,	TCP_QUICKACK		},
134
135
#endif						
#ifdef TCP_NOPUSH			
136
	{ "TCP_NOPUSH",			SOCK_STREAM,	IPPROTO_TCP,	TCP_NOPUSH			},
137
138
#endif						
#ifdef TCP_NOOPT			
139
	{ "TCP_NOOPT",			SOCK_STREAM,	IPPROTO_TCP,	TCP_NOOPT			},
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#endif
	{ NULL }
};

int getSocketOptionByName(const char* name, int* level)
{
	int i;

	if(level!=NULL)
		*level=SOL_SOCKET;	/* default option level */
	for(i=0;socket_options[i].name;i++) {
		if(stricmp(name,socket_options[i].name)==0) {
			if(level!=NULL)
				*level = socket_options[i].level;
			return(socket_options[i].value);
		}
	}
	if(!isdigit(*name))	/* unknown option name */
		return(-1);
	return(strtol(name,NULL,0));
}

socket_option_t* getSocketOptionList(void)
{
	return(socket_options);
}

167
int sendfilesocket(int sock, int file, off_t *offset, off_t count)
168
{
169
	char		buf[1024*16];
170
	off_t		len;
171
172
173
174
	int			rd;
	int			wr=0;
	int			total=0;
	int			i;
175

176
177
178
/* sendfile() on Linux may or may not work with non-blocking sockets ToDo */
	len=filelength(file);

179
180
181
182
	if(offset!=NULL)
		if(lseek(file,*offset,SEEK_SET)<0)
			return(-1);

183
	if(count<1 || count>len) {
184
		count=len;
185
186
		count-=tell(file);		/* don't try to read beyond EOF */
	}
187
188
189
190
191
192
193
194
#if USE_SENDFILE
	while((i=sendfile(file,sock,(offset==NULL?0:*offset)+total,count-total,NULL,&wr,0))==-1 && errno==EAGAIN)  {
		total+=wr;
		SLEEP(1);
	}
	if(i==0)
		return((int)count);
#endif
195

196
197
198
199
200
201
	if(count<0) {
		errno=EINVAL;
		return(-1);
	}

	while(total<count) {
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
		rd=read(file,buf,sizeof(buf));
		if(rd==-1)
			return(-1);
		if(rd==0)
			break;
		for(i=wr=0;i<rd;i+=wr) {
			wr=sendsocket(sock,buf+i,rd-i);
			if(wr>0)
				continue;
			if(wr==SOCKET_ERROR && ERROR_VALUE==EWOULDBLOCK) {
				wr=0;
				SLEEP(1);
				continue;
			}
			return(wr);
217
		}
218
219
220
		if(i!=rd)
			return(-1);
		total+=rd;
221
222
	}

223
	if(offset!=NULL)
224
225
226
		(*offset)+=total;

	return(total);
227
228
}

229
int recvfilesocket(int sock, int file, off_t *offset, off_t count)
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
{
	/* Writes a file from a socket -
	 *
	 * sock		- Socket to read from
	 * file		- File descriptior to write to
	 *				MUST be open and writeable
	 * offset	- pointer to file offset to start writing at
	 *				is set to offset writing STOPPED
	 *				on return
	 * count	- number of bytes to read/write
	 *
	 * returns -1 if an error occurse, otherwise
	 * returns number ob bytes written and sets offset
	 * to the new offset
	 */
	 
	char*	buf;
	int		rd;
	int		wr;

	if(count<1) {
		errno=ERANGE;
		return(-1);
	}
		
255
	if((buf=(char*)malloc((size_t)count))==NULL) {
256
257
258
259
260
261
262
263
		errno=ENOMEM;
		return(-1);
	}

	if(offset!=NULL)
		if(lseek(file,*offset,SEEK_SET)<0)
			return(-1);

264
	rd=read(sock,buf,(size_t)count);
265
266
	if(rd!=count) {
		free(buf);
267
		return(-1);
268
	}
269
270
271
272
273
274

	wr=write(file,buf,rd);

	if(offset!=NULL)
		(*offset)+=wr;

275
	free(buf);
276
277
278
279
	return(wr);
}


280
/* Return true if connected, optionally sets *rd_p to true if read data available */
281
BOOL socket_check(SOCKET sock, BOOL* rd_p, BOOL* wr_p, DWORD timeout)
282
283
284
{
	char	ch;
	int		i,rd;
285
	fd_set	rd_set;
286
	fd_set*	rd_set_p=&rd_set;
287
288
	fd_set	wr_set;
	fd_set*	wr_set_p=NULL;
289
290
291
292
293
	struct	timeval tv;

	if(rd_p!=NULL)
		*rd_p=FALSE;

294
295
296
	if(wr_p!=NULL)
		*wr_p=FALSE;

297
298
299
	if(sock==INVALID_SOCKET)
		return(FALSE);

300
301
302
303
304
305
	FD_ZERO(&rd_set);
	FD_SET(sock,&rd_set);
	if(wr_p!=NULL) {
		wr_set_p=&wr_set;
		FD_ZERO(wr_set_p);
		FD_SET(sock,wr_set_p);
306
		if(rd_p==NULL)
307
			rd_set_p=NULL;
308
	}
309

310
311
312
	/* Convert timeout from ms to sec/usec */
	tv.tv_sec=timeout/1000;
	tv.tv_usec=(timeout%1000)*1000;
313

314
	i=select(sock+1,rd_set_p,wr_set_p,NULL,&tv);
315
316
317
318
319
320
	if(i==SOCKET_ERROR)
		return(FALSE);

	if(i==0) 
		return(TRUE);

321
322
323
324
325
326
	if(wr_p!=NULL && FD_ISSET(sock,wr_set_p)) {
		*wr_p=TRUE;
		if(i==1)
			return(TRUE);
	}

327
	if(rd_p !=NULL || wr_p==NULL)  {
328
329
330
331
332
333
334
		rd=recv(sock,&ch,1,MSG_PEEK);
		if(rd==1 
			|| (rd==SOCKET_ERROR && ERROR_VALUE==EMSGSIZE)) {
			if(rd_p!=NULL)
				*rd_p=TRUE;
			return(TRUE);
		}
335
336
337
338
	}

	return(FALSE);
}
deuce's avatar
deuce committed
339

340
341
342
int retry_bind(SOCKET s, const struct sockaddr *addr, socklen_t addrlen
			   ,uint retries, uint wait_secs
			   ,const char* prot
343
			   ,int (*lprintf)(int level, const char *fmt, ...))
deuce's avatar
deuce committed
344
{
345
	char	port_str[128];
deuce's avatar
deuce committed
346
	int		result=-1;
347
	uint	i;
deuce's avatar
deuce committed
348

349
	if(addr->sa_family==AF_INET)
deuce's avatar
deuce committed
350
		SAFEPRINTF(port_str," to port %u",ntohs(((SOCKADDR_IN *)(addr))->sin_port));
351
352
	else
		port_str[0]=0;
deuce's avatar
deuce committed
353
	for(i=0;i<=retries;i++) {
354
		if((result=bind(s,addr,addrlen))==0)
deuce's avatar
deuce committed
355
			break;
356
		if(lprintf!=NULL)
357
			lprintf(i<retries ? LOG_WARNING:LOG_CRIT
358
359
360
				,"%04d !ERROR %d binding %s socket%s", s, ERROR_VALUE, prot, port_str);
		if(i<retries) {
			if(lprintf!=NULL)
361
362
				lprintf(LOG_WARNING,"%04d Will retry in %u seconds (%u of %u)"
					,s, wait_secs, i+1, retries);
363
364
			SLEEP(wait_secs*1000);
		}
deuce's avatar
deuce committed
365
366
367
	}
	return(result);
}
368
369
370
371
372
373
374
375
376
377
378

int nonblocking_connect(SOCKET sock, struct sockaddr* addr, size_t size, unsigned timeout)
{
	int result;

	result=connect(sock, addr, size);

	if(result==SOCKET_ERROR
		&& (ERROR_VALUE==EWOULDBLOCK || ERROR_VALUE==EINPROGRESS)) {
		fd_set		socket_set;
		struct		timeval tv;
rswindell's avatar
rswindell committed
379
		socklen_t	optlen=sizeof(result);
380
381
382
383
		tv.tv_sec = timeout;
		tv.tv_usec = 0;
		FD_ZERO(&socket_set);
		FD_SET(sock,&socket_set);
384
		if(select(sock+1,NULL,&socket_set,NULL,&tv)==1)
rswindell's avatar
rswindell committed
385
			getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&result, &optlen);
386
387
388
	}
	return result;
}
389
390
391

const char *inet_addrtop(SOCKADDR *in, char *dest, size_t size)
{
392
#ifdef _WIN32
393
394
	static INT (WSAAPI *a2s)(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO, LPTSTR, LPDWORD)=NULL;
	static BOOL searched=FALSE;
395

396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
	if(!searched) {
		HMODULE hMod = LoadLibrary("ws2_32.dll");

		searched = TRUE;
		if(hMod)
			a2s=(INT (WSAAPI *)(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO, LPTSTR, LPDWORD))GetProcAddress(hMod, "WSAAddressToString");
	}

	if(a2s) {
		DWORD	dsize=size;

		if(a2s(in, SOCK_MAXADDRLEN, NULL, dest, &dsize)==SOCKET_ERROR)
			return NULL;
		return dest;
	}
	if(in->sa_family != AF_INET)
		strncpy(dest, "<Address Family Not Supported>", size);
	else
		strncpy(dest, inet_ntoa(((struct sockaddr_in *)in)->sin_addr), size);
	dest[size-1]=0;
416
417
	return dest;
#else
418
419
420
421
422
423
	switch(in->sa_family) {
		case AF_INET:
			return inet_ntop(in->sa_family, &((struct sockaddr_in *)in)->sin_addr, dest, size);
		case AF_INET6:
			return inet_ntop(in->sa_family, &((struct sockaddr_in6 *)in)->sin6_addr, dest, size);
		default:
424
			safe_snprintf(dest, size, "<unknown address>");
425
426
			return NULL;
	}
427
#endif
428
429
430
431
432
433
434
435
436
437
438
439
440
}

uint16_t inet_addrport(SOCKADDR *in)
{
	switch(in->sa_family) {
		case AF_INET:
			return ntohs(((struct sockaddr_in *)in)->sin_port);
		case AF_INET6:
			return ntohs(((struct sockaddr_in6 *)in)->sin6_port);
		default:
			return 0;
	}
}