r15356: Remove unused 'flags' argument from socket_send() and friends.
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket / socket.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Socket functions
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Tim Potter      2000-2001
6    Copyright (C) Stefan Metzmacher 2004
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "lib/socket/socket.h"
25 #include "system/filesys.h"
26 #include "system/network.h"
27
28 /*
29   auto-close sockets on free
30 */
31 static int socket_destructor(void *ptr)
32 {
33         struct socket_context *sock = ptr;
34         if (sock->ops->fn_close) {
35                 sock->ops->fn_close(sock);
36         }
37         return 0;
38 }
39
40 static NTSTATUS socket_create_with_ops(TALLOC_CTX *mem_ctx, const struct socket_ops *ops,
41                                        struct socket_context **new_sock, 
42                                        enum socket_type type, uint32_t flags)
43 {
44         NTSTATUS status;
45
46         (*new_sock) = talloc(mem_ctx, struct socket_context);
47         if (!(*new_sock)) {
48                 return NT_STATUS_NO_MEMORY;
49         }
50
51         (*new_sock)->type = type;
52         (*new_sock)->state = SOCKET_STATE_UNDEFINED;
53         (*new_sock)->flags = flags;
54
55         (*new_sock)->fd = -1;
56
57         (*new_sock)->private_data = NULL;
58         (*new_sock)->ops = ops;
59         (*new_sock)->backend_name = NULL;
60
61         status = (*new_sock)->ops->fn_init((*new_sock));
62         if (!NT_STATUS_IS_OK(status)) {
63                 talloc_free(*new_sock);
64                 return status;
65         }
66
67         /* by enabling "testnonblock" mode, all socket receive and
68            send calls on non-blocking sockets will randomly recv/send
69            less data than requested */
70         if (!(flags & SOCKET_FLAG_BLOCK) &&
71             type == SOCKET_TYPE_STREAM &&
72             lp_parm_bool(-1, "socket", "testnonblock", False)) {
73                 (*new_sock)->flags |= SOCKET_FLAG_TESTNONBLOCK;
74         }
75
76         /* we don't do a connect() on dgram sockets, so need to set
77            non-blocking at socket create time */
78         if (!(flags & SOCKET_FLAG_BLOCK) && type == SOCKET_TYPE_DGRAM) {
79                 set_blocking(socket_get_fd(*new_sock), False);
80         }
81
82         talloc_set_destructor(*new_sock, socket_destructor);
83
84         return NT_STATUS_OK;
85 }
86
87 _PUBLIC_ NTSTATUS socket_create(const char *name, enum socket_type type, 
88                                 struct socket_context **new_sock, uint32_t flags)
89 {
90         const struct socket_ops *ops;
91
92         ops = socket_getops_byname(name, type);
93         if (!ops) {
94                 return NT_STATUS_INVALID_PARAMETER;
95         }
96
97         return socket_create_with_ops(NULL, ops, new_sock, type, flags);
98 }
99
100 _PUBLIC_ NTSTATUS socket_connect(struct socket_context *sock,
101                                  const struct socket_address *my_address, 
102                                  const struct socket_address *server_address,
103                                  uint32_t flags)
104 {
105         if (sock == NULL) {
106                 return NT_STATUS_CONNECTION_DISCONNECTED;
107         }
108         if (sock->state != SOCKET_STATE_UNDEFINED) {
109                 return NT_STATUS_INVALID_PARAMETER;
110         }
111
112         if (!sock->ops->fn_connect) {
113                 return NT_STATUS_NOT_IMPLEMENTED;
114         }
115
116         return sock->ops->fn_connect(sock, my_address, server_address, flags);
117 }
118
119 _PUBLIC_ NTSTATUS socket_connect_complete(struct socket_context *sock, uint32_t flags)
120 {
121         if (!sock->ops->fn_connect_complete) {
122                 return NT_STATUS_NOT_IMPLEMENTED;
123         }
124         return sock->ops->fn_connect_complete(sock, flags);
125 }
126
127 _PUBLIC_ NTSTATUS socket_listen(struct socket_context *sock, 
128                                 const struct socket_address *my_address, 
129                                 int queue_size, uint32_t flags)
130 {
131         if (sock == NULL) {
132                 return NT_STATUS_CONNECTION_DISCONNECTED;
133         }
134         if (sock->state != SOCKET_STATE_UNDEFINED) {
135                 return NT_STATUS_INVALID_PARAMETER;
136         }
137
138         if (!sock->ops->fn_listen) {
139                 return NT_STATUS_NOT_IMPLEMENTED;
140         }
141
142         return sock->ops->fn_listen(sock, my_address, queue_size, flags);
143 }
144
145 _PUBLIC_ NTSTATUS socket_accept(struct socket_context *sock, struct socket_context **new_sock)
146 {
147         NTSTATUS status;
148
149         if (sock == NULL) {
150                 return NT_STATUS_CONNECTION_DISCONNECTED;
151         }
152         if (sock->type != SOCKET_TYPE_STREAM) {
153                 return NT_STATUS_INVALID_PARAMETER;
154         }
155
156         if (sock->state != SOCKET_STATE_SERVER_LISTEN) {
157                 return NT_STATUS_INVALID_PARAMETER;
158         }
159
160         if (!sock->ops->fn_accept) {
161                 return NT_STATUS_NOT_IMPLEMENTED;
162         }
163
164         status = sock->ops->fn_accept(sock, new_sock);
165
166         if (NT_STATUS_IS_OK(status)) {
167                 talloc_set_destructor(*new_sock, socket_destructor);
168         }
169
170         return status;
171 }
172
173 _PUBLIC_ NTSTATUS socket_recv(struct socket_context *sock, void *buf, 
174                               size_t wantlen, size_t *nread)
175 {
176         if (sock == NULL) {
177                 return NT_STATUS_CONNECTION_DISCONNECTED;
178         }
179         if (sock->state != SOCKET_STATE_CLIENT_CONNECTED &&
180             sock->state != SOCKET_STATE_SERVER_CONNECTED &&
181             sock->type  != SOCKET_TYPE_DGRAM) {
182                 return NT_STATUS_INVALID_PARAMETER;
183         }
184
185         if (!sock->ops->fn_recv) {
186                 return NT_STATUS_NOT_IMPLEMENTED;
187         }
188
189         if ((sock->flags & SOCKET_FLAG_TESTNONBLOCK) && wantlen > 1) {
190                 if (random() % 10 == 0) {
191                         *nread = 0;
192                         return STATUS_MORE_ENTRIES;
193                 }
194                 return sock->ops->fn_recv(sock, buf, 1+(random() % wantlen), nread);
195         }
196
197         return sock->ops->fn_recv(sock, buf, wantlen, nread);
198 }
199
200 _PUBLIC_ NTSTATUS socket_recvfrom(struct socket_context *sock, void *buf, 
201                                   size_t wantlen, size_t *nread, 
202                                   TALLOC_CTX *mem_ctx, struct socket_address **src_addr)
203 {
204         if (sock == NULL) {
205                 return NT_STATUS_CONNECTION_DISCONNECTED;
206         }
207         if (sock->type != SOCKET_TYPE_DGRAM) {
208                 return NT_STATUS_INVALID_PARAMETER;
209         }
210
211         if (!sock->ops->fn_recvfrom) {
212                 return NT_STATUS_NOT_IMPLEMENTED;
213         }
214
215         return sock->ops->fn_recvfrom(sock, buf, wantlen, nread, 
216                                       mem_ctx, src_addr);
217 }
218
219 _PUBLIC_ NTSTATUS socket_send(struct socket_context *sock, 
220                               const DATA_BLOB *blob, size_t *sendlen)
221 {
222         if (sock == NULL) {
223                 return NT_STATUS_CONNECTION_DISCONNECTED;
224         }
225         if (sock->state != SOCKET_STATE_CLIENT_CONNECTED &&
226             sock->state != SOCKET_STATE_SERVER_CONNECTED) {
227                 return NT_STATUS_INVALID_PARAMETER;
228         }
229
230         if (!sock->ops->fn_send) {
231                 return NT_STATUS_NOT_IMPLEMENTED;
232         }
233
234         if ((sock->flags & SOCKET_FLAG_TESTNONBLOCK) && blob->length > 1) {
235                 DATA_BLOB blob2 = *blob;
236                 if (random() % 10 == 0) {
237                         *sendlen = 0;
238                         return STATUS_MORE_ENTRIES;
239                 }
240                 blob2.length = 1+(random() % blob2.length);
241                 return sock->ops->fn_send(sock, &blob2, sendlen);
242         }
243
244         return sock->ops->fn_send(sock, blob, sendlen);
245 }
246
247
248 _PUBLIC_ NTSTATUS socket_sendto(struct socket_context *sock, 
249                                 const DATA_BLOB *blob, size_t *sendlen, 
250                                 const struct socket_address *dest_addr)
251 {
252         if (sock == NULL) {
253                 return NT_STATUS_CONNECTION_DISCONNECTED;
254         }
255         if (sock->type != SOCKET_TYPE_DGRAM) {
256                 return NT_STATUS_INVALID_PARAMETER;
257         }
258
259         if (sock->state == SOCKET_STATE_CLIENT_CONNECTED ||
260             sock->state == SOCKET_STATE_SERVER_CONNECTED) {
261                 return NT_STATUS_INVALID_PARAMETER;
262         }
263
264         if (!sock->ops->fn_sendto) {
265                 return NT_STATUS_NOT_IMPLEMENTED;
266         }
267
268         return sock->ops->fn_sendto(sock, blob, sendlen, dest_addr);
269 }
270
271
272 /*
273   ask for the number of bytes in a pending incoming packet
274 */
275 _PUBLIC_ NTSTATUS socket_pending(struct socket_context *sock, size_t *npending)
276 {
277         if (sock == NULL) {
278                 return NT_STATUS_CONNECTION_DISCONNECTED;
279         }
280         if (!sock->ops->fn_pending) {
281                 return NT_STATUS_NOT_IMPLEMENTED;
282         }
283         return sock->ops->fn_pending(sock, npending);
284 }
285
286
287 _PUBLIC_ NTSTATUS socket_set_option(struct socket_context *sock, const char *option, const char *val)
288 {
289         if (sock == NULL) {
290                 return NT_STATUS_CONNECTION_DISCONNECTED;
291         }
292         if (!sock->ops->fn_set_option) {
293                 return NT_STATUS_NOT_IMPLEMENTED;
294         }
295
296         return sock->ops->fn_set_option(sock, option, val);
297 }
298
299 _PUBLIC_ char *socket_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
300 {
301         if (!sock->ops->fn_get_peer_name) {
302                 return NULL;
303         }
304
305         return sock->ops->fn_get_peer_name(sock, mem_ctx);
306 }
307
308 _PUBLIC_ struct socket_address *socket_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
309 {
310         if (!sock->ops->fn_get_peer_addr) {
311                 return NULL;
312         }
313
314         return sock->ops->fn_get_peer_addr(sock, mem_ctx);
315 }
316
317 _PUBLIC_ struct socket_address *socket_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
318 {
319         if (!sock->ops->fn_get_my_addr) {
320                 return NULL;
321         }
322
323         return sock->ops->fn_get_my_addr(sock, mem_ctx);
324 }
325
326 _PUBLIC_ int socket_get_fd(struct socket_context *sock)
327 {
328         if (!sock->ops->fn_get_fd) {
329                 return -1;
330         }
331
332         return sock->ops->fn_get_fd(sock);
333 }
334
335 /*
336   call dup() on a socket, and close the old fd. This is used to change
337   the fd to the lowest available number, to make select() more
338   efficient (select speed depends on the maxiumum fd number passed to
339   it)
340 */
341 _PUBLIC_ NTSTATUS socket_dup(struct socket_context *sock)
342 {
343         int fd;
344         if (sock->fd == -1) {
345                 return NT_STATUS_INVALID_HANDLE;
346         }
347         fd = dup(sock->fd);
348         if (fd == -1) {
349                 return map_nt_error_from_unix(errno);
350         }
351         close(sock->fd);
352         sock->fd = fd;
353         return NT_STATUS_OK;
354         
355 }
356
357 /* Create a new socket_address.  The type must match the socket type.
358  * The host parameter may be an IP or a hostname 
359  */
360
361 _PUBLIC_ struct socket_address *socket_address_from_strings(TALLOC_CTX *mem_ctx,
362                                                             const char *family,
363                                                             const char *host,
364                                                             int port)
365 {
366         struct socket_address *addr = talloc(mem_ctx, struct socket_address);
367         if (!addr) {
368                 return NULL;
369         }
370
371         addr->family = family;
372         addr->addr = talloc_strdup(addr, host);
373         if (!addr->addr) {
374                 talloc_free(addr);
375                 return NULL;
376         }
377         addr->port = port;
378         addr->sockaddr = NULL;
379         addr->sockaddrlen = 0;
380
381         return addr;
382 }
383
384 /* Create a new socket_address.  Copy the struct sockaddr into the new
385  * structure.  Used for hooks in the kerberos libraries, where they
386  * supply only a struct sockaddr */
387
388 _PUBLIC_ struct socket_address *socket_address_from_sockaddr(TALLOC_CTX *mem_ctx, 
389                                                              struct sockaddr *sockaddr, 
390                                                              size_t sockaddrlen)
391 {
392         struct socket_address *addr = talloc(mem_ctx, struct socket_address);
393         if (!addr) {
394                 return NULL;
395         }
396         addr->family = NULL; 
397         addr->addr = NULL;
398         addr->port = 0;
399         addr->sockaddr = talloc_memdup(addr, sockaddr, sockaddrlen);
400         if (!addr->sockaddr) {
401                 talloc_free(addr);
402                 return NULL;
403         }
404         addr->sockaddrlen = sockaddrlen;
405         return addr;
406 }
407
408 _PUBLIC_ const struct socket_ops *socket_getops_byname(const char *family, enum socket_type type)
409 {
410         extern const struct socket_ops *socket_ipv4_ops(enum socket_type);
411         extern const struct socket_ops *socket_ipv6_ops(enum socket_type);
412         extern const struct socket_ops *socket_unixdom_ops(enum socket_type);
413
414         if (strcmp("ip", family) == 0 || 
415             strcmp("ipv4", family) == 0) {
416                 return socket_ipv4_ops(type);
417         }
418
419 #if HAVE_SOCKET_IPV6
420         if (strcmp("ipv6", family) == 0) {
421                 if (lp_parm_bool(-1, "socket", "noipv6", False)) {
422                         DEBUG(3, ("IPv6 support was disabled in smb.conf"));
423                         return NULL;
424                 }
425                 return socket_ipv6_ops(type);
426         }
427 #endif
428
429         if (strcmp("unix", family) == 0) {
430                 return socket_unixdom_ops(type);
431         }
432
433         return NULL;
434 }
435
436 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
437
438 static const struct {
439         const char *name;
440         int level;
441         int option;
442         int value;
443         int opttype;
444 } socket_options[] = {
445   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
446   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
447   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
448 #ifdef TCP_NODELAY
449   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
450 #endif
451 #ifdef IPTOS_LOWDELAY
452   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
453 #endif
454 #ifdef IPTOS_THROUGHPUT
455   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
456 #endif
457 #ifdef SO_REUSEPORT
458   {"SO_REUSEPORT",      SOL_SOCKET,    SO_REUSEPORT,    0,                 OPT_BOOL},
459 #endif
460 #ifdef SO_SNDBUF
461   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
462 #endif
463 #ifdef SO_RCVBUF
464   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
465 #endif
466 #ifdef SO_SNDLOWAT
467   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
468 #endif
469 #ifdef SO_RCVLOWAT
470   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
471 #endif
472 #ifdef SO_SNDTIMEO
473   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
474 #endif
475 #ifdef SO_RCVTIMEO
476   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
477 #endif
478   {NULL,0,0,0,0}};
479
480
481 /**
482  Set user socket options.
483 **/
484 _PUBLIC_ void set_socket_options(int fd, const char *options)
485 {
486         const char **options_list = str_list_make(NULL, options, " \t,");
487         int j;
488
489         if (!options_list)
490                 return;
491
492         for (j = 0; options_list[j]; j++) {
493                 const char *tok = options_list[j];
494                 int ret=0,i;
495                 int value = 1;
496                 char *p;
497                 BOOL got_value = False;
498
499                 if ((p = strchr(tok,'='))) {
500                         *p = 0;
501                         value = atoi(p+1);
502                         got_value = True;
503                 }
504
505                 for (i=0;socket_options[i].name;i++)
506                         if (strequal(socket_options[i].name,tok))
507                                 break;
508
509                 if (!socket_options[i].name) {
510                         DEBUG(0,("Unknown socket option %s\n",tok));
511                         continue;
512                 }
513
514                 switch (socket_options[i].opttype) {
515                 case OPT_BOOL:
516                 case OPT_INT:
517                         ret = setsockopt(fd,socket_options[i].level,
518                                                 socket_options[i].option,(char *)&value,sizeof(int));
519                         break;
520
521                 case OPT_ON:
522                         if (got_value)
523                                 DEBUG(0,("syntax error - %s does not take a value\n",tok));
524
525                         {
526                                 int on = socket_options[i].value;
527                                 ret = setsockopt(fd,socket_options[i].level,
528                                                         socket_options[i].option,(char *)&on,sizeof(int));
529                         }
530                         break;    
531                 }
532       
533                 if (ret != 0)
534                         DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
535         }
536
537         talloc_free(options_list);
538 }
539