source: vendor/3.5.11/source3/lib/util_sock.c

Last change on this file was 597, checked in by Herwig Bauernfeind, 14 years ago

Samba 3.5: Update vendor to version 3.5.9
File size: 51.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Tim Potter 2000-2001
6 Copyright (C) Jeremy Allison 1992-2007
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 3 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, see <http://www.gnu.org/licenses/>.
20*/
21
22#include "includes.h"
23
24/****************************************************************************
25 Get a port number in host byte order from a sockaddr_storage.
26****************************************************************************/
27
28uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
29{
30 uint16_t port = 0;
31
32 if (pss->ss_family != AF_INET) {
33#if defined(HAVE_IPV6)
34 /* IPv6 */
35 const struct sockaddr_in6 *sa6 =
36 (const struct sockaddr_in6 *)pss;
37 port = ntohs(sa6->sin6_port);
38#endif
39 } else {
40 const struct sockaddr_in *sa =
41 (const struct sockaddr_in *)pss;
42 port = ntohs(sa->sin_port);
43 }
44 return port;
45}
46
47/****************************************************************************
48 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
49****************************************************************************/
50
51static char *print_sockaddr_len(char *dest,
52 size_t destlen,
53 const struct sockaddr *psa,
54 socklen_t psalen)
55{
56 if (destlen > 0) {
57 dest[0] = '\0';
58 }
59 (void)sys_getnameinfo(psa,
60 psalen,
61 dest, destlen,
62 NULL, 0,
63 NI_NUMERICHOST);
64 return dest;
65}
66
67/****************************************************************************
68 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
69****************************************************************************/
70
71char *print_sockaddr(char *dest,
72 size_t destlen,
73 const struct sockaddr_storage *psa)
74{
75 return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
76 sizeof(struct sockaddr_storage));
77}
78
79/****************************************************************************
80 Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
81****************************************************************************/
82
83char *print_canonical_sockaddr(TALLOC_CTX *ctx,
84 const struct sockaddr_storage *pss)
85{
86 char addr[INET6_ADDRSTRLEN];
87 char *dest = NULL;
88 int ret;
89
90 /* Linux getnameinfo() man pages says port is unitialized if
91 service name is NULL. */
92
93 ret = sys_getnameinfo((const struct sockaddr *)pss,
94 sizeof(struct sockaddr_storage),
95 addr, sizeof(addr),
96 NULL, 0,
97 NI_NUMERICHOST);
98 if (ret != 0) {
99 return NULL;
100 }
101
102 if (pss->ss_family != AF_INET) {
103#if defined(HAVE_IPV6)
104 dest = talloc_asprintf(ctx, "[%s]", addr);
105#else
106 return NULL;
107#endif
108 } else {
109 dest = talloc_asprintf(ctx, "%s", addr);
110 }
111
112 return dest;
113}
114
115/****************************************************************************
116 Return the string of an IP address (IPv4 or IPv6).
117****************************************************************************/
118
119static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
120{
121 struct sockaddr_storage sa;
122 socklen_t length = sizeof(sa);
123
124 /* Ok, returning a hard coded IPv4 address
125 * is bogus, but it's just as bogus as a
126 * zero IPv6 address. No good choice here.
127 */
128
129 strlcpy(addr_buf, "0.0.0.0", addr_len);
130
131 if (fd == -1) {
132 return addr_buf;
133 }
134
135 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
136 DEBUG(0,("getsockname failed. Error was %s\n",
137 strerror(errno) ));
138 return addr_buf;
139 }
140
141 return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
142}
143
144/****************************************************************************
145 Return the port number we've bound to on a socket.
146****************************************************************************/
147
148int get_socket_port(int fd)
149{
150 struct sockaddr_storage sa;
151 socklen_t length = sizeof(sa);
152
153 if (fd == -1) {
154 return -1;
155 }
156
157 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
158 DEBUG(0,("getpeername failed. Error was %s\n",
159 strerror(errno) ));
160 return -1;
161 }
162
163#if defined(HAVE_IPV6)
164 if (sa.ss_family == AF_INET6) {
165 return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
166 }
167#endif
168 if (sa.ss_family == AF_INET) {
169 return ntohs(((struct sockaddr_in *)&sa)->sin_port);
170 }
171 return -1;
172}
173
174const char *client_name(int fd)
175{
176 return get_peer_name(fd,false);
177}
178
179const char *client_addr(int fd, char *addr, size_t addrlen)
180{
181 return get_peer_addr(fd,addr,addrlen);
182}
183
184const char *client_socket_addr(int fd, char *addr, size_t addr_len)
185{
186 return get_socket_addr(fd, addr, addr_len);
187}
188
189#if 0
190/* Not currently used. JRA. */
191int client_socket_port(int fd)
192{
193 return get_socket_port(fd);
194}
195#endif
196
197/****************************************************************************
198 Accessor functions to make thread-safe code easier later...
199****************************************************************************/
200
201void set_smb_read_error(enum smb_read_errors *pre,
202 enum smb_read_errors newerr)
203{
204 if (pre) {
205 *pre = newerr;
206 }
207}
208
209void cond_set_smb_read_error(enum smb_read_errors *pre,
210 enum smb_read_errors newerr)
211{
212 if (pre && *pre == SMB_READ_OK) {
213 *pre = newerr;
214 }
215}
216
217/****************************************************************************
218 Determine if a file descriptor is in fact a socket.
219****************************************************************************/
220
221bool is_a_socket(int fd)
222{
223 int v;
224 socklen_t l;
225 l = sizeof(int);
226 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
227}
228
229enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
230
231typedef struct smb_socket_option {
232 const char *name;
233 int level;
234 int option;
235 int value;
236 int opttype;
237} smb_socket_option;
238
239static const smb_socket_option socket_options[] = {
240 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
241 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
242 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
243#ifdef TCP_NODELAY
244 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
245#endif
246#ifdef TCP_KEEPCNT
247 {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
248#endif
249#ifdef TCP_KEEPIDLE
250 {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
251#endif
252#ifdef TCP_KEEPINTVL
253 {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
254#endif
255#ifdef IPTOS_LOWDELAY
256 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
257#endif
258#ifdef IPTOS_THROUGHPUT
259 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
260#endif
261#ifdef SO_REUSEPORT
262 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
263#endif
264#ifdef SO_SNDBUF
265 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
266#endif
267#ifdef SO_RCVBUF
268 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
269#endif
270#ifdef SO_SNDLOWAT
271 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
272#endif
273#ifdef SO_RCVLOWAT
274 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
275#endif
276#ifdef SO_SNDTIMEO
277 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
278#endif
279#ifdef SO_RCVTIMEO
280 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
281#endif
282#ifdef TCP_FASTACK
283 {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
284#endif
285#ifdef TCP_QUICKACK
286 {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
287#endif
288 {NULL,0,0,0,0}};
289
290/****************************************************************************
291 Print socket options.
292****************************************************************************/
293
294static void print_socket_options(int s)
295{
296 int value;
297 socklen_t vlen = 4;
298 const smb_socket_option *p = &socket_options[0];
299
300 /* wrapped in if statement to prevent streams
301 * leak in SCO Openserver 5.0 */
302 /* reported on samba-technical --jerry */
303 if ( DEBUGLEVEL >= 5 ) {
304 DEBUG(5,("Socket options:\n"));
305 for (; p->name != NULL; p++) {
306 if (getsockopt(s, p->level, p->option,
307 (void *)&value, &vlen) == -1) {
308 DEBUGADD(5,("\tCould not test socket option %s.\n",
309 p->name));
310 } else {
311 DEBUGADD(5,("\t%s = %d\n",
312 p->name,value));
313 }
314 }
315 }
316 }
317
318/****************************************************************************
319 Set user socket options.
320****************************************************************************/
321
322void set_socket_options(int fd, const char *options)
323{
324 TALLOC_CTX *ctx = talloc_stackframe();
325 char *tok;
326
327 while (next_token_talloc(ctx, &options, &tok," \t,")) {
328 int ret=0,i;
329 int value = 1;
330 char *p;
331 bool got_value = false;
332
333 if ((p = strchr_m(tok,'='))) {
334 *p = 0;
335 value = atoi(p+1);
336 got_value = true;
337 }
338
339 for (i=0;socket_options[i].name;i++)
340 if (strequal(socket_options[i].name,tok))
341 break;
342
343 if (!socket_options[i].name) {
344 DEBUG(0,("Unknown socket option %s\n",tok));
345 continue;
346 }
347
348 switch (socket_options[i].opttype) {
349 case OPT_BOOL:
350 case OPT_INT:
351 ret = setsockopt(fd,socket_options[i].level,
352 socket_options[i].option,
353 (char *)&value,sizeof(int));
354 break;
355
356 case OPT_ON:
357 if (got_value)
358 DEBUG(0,("syntax error - %s "
359 "does not take a value\n",tok));
360
361 {
362 int on = socket_options[i].value;
363 ret = setsockopt(fd,socket_options[i].level,
364 socket_options[i].option,
365 (char *)&on,sizeof(int));
366 }
367 break;
368 }
369
370 if (ret != 0) {
371 /* be aware that some systems like Solaris return
372 * EINVAL to a setsockopt() call when the client
373 * sent a RST previously - no need to worry */
374 DEBUG(2,("Failed to set socket option %s (Error %s)\n",
375 tok, strerror(errno) ));
376 }
377 }
378
379 TALLOC_FREE(ctx);
380 print_socket_options(fd);
381}
382
383/****************************************************************************
384 Read from a socket.
385****************************************************************************/
386
387ssize_t read_udp_v4_socket(int fd,
388 char *buf,
389 size_t len,
390 struct sockaddr_storage *psa)
391{
392 ssize_t ret;
393 socklen_t socklen = sizeof(*psa);
394 struct sockaddr_in *si = (struct sockaddr_in *)psa;
395
396 memset((char *)psa,'\0',socklen);
397
398 ret = (ssize_t)sys_recvfrom(fd,buf,len,0,
399 (struct sockaddr *)psa,&socklen);
400 if (ret <= 0) {
401 /* Don't print a low debug error for a non-blocking socket. */
402 if (errno == EAGAIN) {
403 DEBUG(10,("read_udp_v4_socket: returned EAGAIN\n"));
404 } else {
405 DEBUG(2,("read_udp_v4_socket: failed. errno=%s\n",
406 strerror(errno)));
407 }
408 return 0;
409 }
410
411 if (psa->ss_family != AF_INET) {
412 DEBUG(2,("read_udp_v4_socket: invalid address family %d "
413 "(not IPv4)\n", (int)psa->ss_family));
414 return 0;
415 }
416
417 DEBUG(10,("read_udp_v4_socket: ip %s port %d read: %lu\n",
418 inet_ntoa(si->sin_addr),
419 si->sin_port,
420 (unsigned long)ret));
421
422 return ret;
423}
424
425/****************************************************************************
426 Read data from a file descriptor with a timout in msec.
427 mincount = if timeout, minimum to read before returning
428 maxcount = number to be read.
429 time_out = timeout in milliseconds
430 NB. This can be called with a non-socket fd, don't change
431 sys_read() to sys_recv() or other socket call.
432****************************************************************************/
433
434NTSTATUS read_fd_with_timeout(int fd, char *buf,
435 size_t mincnt, size_t maxcnt,
436 unsigned int time_out,
437 size_t *size_ret)
438{
439 fd_set fds;
440 int selrtn;
441 ssize_t readret;
442 size_t nread = 0;
443 struct timeval timeout;
444 char addr[INET6_ADDRSTRLEN];
445 int save_errno;
446
447 /* just checking .... */
448 if (maxcnt <= 0)
449 return NT_STATUS_OK;
450
451 /* Blocking read */
452 if (time_out == 0) {
453 if (mincnt == 0) {
454 mincnt = maxcnt;
455 }
456
457 while (nread < mincnt) {
458 readret = sys_read(fd, buf + nread, maxcnt - nread);
459
460 if (readret == 0) {
461 DEBUG(5,("read_fd_with_timeout: "
462 "blocking read. EOF from client.\n"));
463 return NT_STATUS_END_OF_FILE;
464 }
465
466 if (readret == -1) {
467 save_errno = errno;
468 if (fd == get_client_fd()) {
469 /* Try and give an error message
470 * saying what client failed. */
471 DEBUG(0,("read_fd_with_timeout: "
472 "client %s read error = %s.\n",
473 get_peer_addr(fd,addr,sizeof(addr)),
474 strerror(save_errno) ));
475 } else {
476 DEBUG(0,("read_fd_with_timeout: "
477 "read error = %s.\n",
478 strerror(save_errno) ));
479 }
480 return map_nt_error_from_unix(save_errno);
481 }
482 nread += readret;
483 }
484 goto done;
485 }
486
487 /* Most difficult - timeout read */
488 /* If this is ever called on a disk file and
489 mincnt is greater then the filesize then
490 system performance will suffer severely as
491 select always returns true on disk files */
492
493 /* Set initial timeout */
494 timeout.tv_sec = (time_t)(time_out / 1000);
495 timeout.tv_usec = (long)(1000 * (time_out % 1000));
496
497 for (nread=0; nread < mincnt; ) {
498 if (fd < 0 || fd >= FD_SETSIZE) {
499 errno = EBADF;
500 return map_nt_error_from_unix(EBADF);
501 }
502
503 FD_ZERO(&fds);
504 FD_SET(fd,&fds);
505
506 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
507
508 /* Check if error */
509 if (selrtn == -1) {
510 save_errno = errno;
511 /* something is wrong. Maybe the socket is dead? */
512 if (fd == get_client_fd()) {
513 /* Try and give an error message saying
514 * what client failed. */
515 DEBUG(0,("read_fd_with_timeout: timeout "
516 "read for client %s. select error = %s.\n",
517 get_peer_addr(fd,addr,sizeof(addr)),
518 strerror(save_errno) ));
519 } else {
520 DEBUG(0,("read_fd_with_timeout: timeout "
521 "read. select error = %s.\n",
522 strerror(save_errno) ));
523 }
524 return map_nt_error_from_unix(save_errno);
525 }
526
527 /* Did we timeout ? */
528 if (selrtn == 0) {
529 DEBUG(10,("read_fd_with_timeout: timeout read. "
530 "select timed out.\n"));
531 return NT_STATUS_IO_TIMEOUT;
532 }
533
534 readret = sys_read(fd, buf+nread, maxcnt-nread);
535
536 if (readret == 0) {
537 /* we got EOF on the file descriptor */
538 DEBUG(5,("read_fd_with_timeout: timeout read. "
539 "EOF from client.\n"));
540 return NT_STATUS_END_OF_FILE;
541 }
542
543 if (readret == -1) {
544 save_errno = errno;
545 /* the descriptor is probably dead */
546 if (fd == get_client_fd()) {
547 /* Try and give an error message
548 * saying what client failed. */
549 DEBUG(0,("read_fd_with_timeout: timeout "
550 "read to client %s. read error = %s.\n",
551 get_peer_addr(fd,addr,sizeof(addr)),
552 strerror(save_errno) ));
553 } else {
554 DEBUG(0,("read_fd_with_timeout: timeout "
555 "read. read error = %s.\n",
556 strerror(save_errno) ));
557 }
558 return map_nt_error_from_unix(errno);
559 }
560
561 nread += readret;
562 }
563
564 done:
565 /* Return the number we got */
566 if (size_ret) {
567 *size_ret = nread;
568 }
569 return NT_STATUS_OK;
570}
571
572/****************************************************************************
573 Read data from an fd, reading exactly N bytes.
574 NB. This can be called with a non-socket fd, don't add dependencies
575 on socket calls.
576****************************************************************************/
577
578NTSTATUS read_data(int fd, char *buffer, size_t N)
579{
580 return read_fd_with_timeout(fd, buffer, N, N, 0, NULL);
581}
582
583/****************************************************************************
584 Write all data from an iov array
585 NB. This can be called with a non-socket fd, don't add dependencies
586 on socket calls.
587****************************************************************************/
588
589ssize_t write_data_iov(int fd, const struct iovec *orig_iov, int iovcnt)
590{
591 int i;
592 size_t to_send;
593 ssize_t thistime;
594 size_t sent;
595 struct iovec *iov_copy, *iov;
596
597 to_send = 0;
598 for (i=0; i<iovcnt; i++) {
599 to_send += orig_iov[i].iov_len;
600 }
601
602 thistime = sys_writev(fd, orig_iov, iovcnt);
603 if ((thistime <= 0) || (thistime == to_send)) {
604 return thistime;
605 }
606 sent = thistime;
607
608 /*
609 * We could not send everything in one call. Make a copy of iov that
610 * we can mess with. We keep a copy of the array start in iov_copy for
611 * the TALLOC_FREE, because we're going to modify iov later on,
612 * discarding elements.
613 */
614
615 iov_copy = (struct iovec *)TALLOC_MEMDUP(
616 talloc_tos(), orig_iov, sizeof(struct iovec) * iovcnt);
617
618 if (iov_copy == NULL) {
619 errno = ENOMEM;
620 return -1;
621 }
622 iov = iov_copy;
623
624 while (sent < to_send) {
625 /*
626 * We have to discard "thistime" bytes from the beginning
627 * iov array, "thistime" contains the number of bytes sent
628 * via writev last.
629 */
630 while (thistime > 0) {
631 if (thistime < iov[0].iov_len) {
632 char *new_base =
633 (char *)iov[0].iov_base + thistime;
634 iov[0].iov_base = (void *)new_base;
635 iov[0].iov_len -= thistime;
636 break;
637 }
638 thistime -= iov[0].iov_len;
639 iov += 1;
640 iovcnt -= 1;
641 }
642
643 thistime = sys_writev(fd, iov, iovcnt);
644 if (thistime <= 0) {
645 break;
646 }
647 sent += thistime;
648 }
649
650 TALLOC_FREE(iov_copy);
651 return sent;
652}
653
654/****************************************************************************
655 Write data to a fd.
656 NB. This can be called with a non-socket fd, don't add dependencies
657 on socket calls.
658****************************************************************************/
659
660ssize_t write_data(int fd, const char *buffer, size_t N)
661{
662 ssize_t ret;
663 struct iovec iov;
664
665 iov.iov_base = CONST_DISCARD(void *, buffer);
666 iov.iov_len = N;
667
668 ret = write_data_iov(fd, &iov, 1);
669 if (ret >= 0) {
670 return ret;
671 }
672
673 if (fd == get_client_fd()) {
674 char addr[INET6_ADDRSTRLEN];
675 /*
676 * Try and give an error message saying what client failed.
677 */
678 DEBUG(0, ("write_data: write failure in writing to client %s. "
679 "Error %s\n", get_peer_addr(fd,addr,sizeof(addr)),
680 strerror(errno)));
681 } else {
682 DEBUG(0,("write_data: write failure. Error = %s\n",
683 strerror(errno) ));
684 }
685
686 return -1;
687}
688
689/****************************************************************************
690 Send a keepalive packet (rfc1002).
691****************************************************************************/
692
693bool send_keepalive(int client)
694{
695 unsigned char buf[4];
696
697 buf[0] = SMBkeepalive;
698 buf[1] = buf[2] = buf[3] = 0;
699
700 return(write_data(client,(char *)buf,4) == 4);
701}
702
703/****************************************************************************
704 Read 4 bytes of a smb packet and return the smb length of the packet.
705 Store the result in the buffer.
706 This version of the function will return a length of zero on receiving
707 a keepalive packet.
708 Timeout is in milliseconds.
709****************************************************************************/
710
711NTSTATUS read_smb_length_return_keepalive(int fd, char *inbuf,
712 unsigned int timeout,
713 size_t *len)
714{
715 int msg_type;
716 NTSTATUS status;
717
718 status = read_fd_with_timeout(fd, inbuf, 4, 4, timeout, NULL);
719
720 if (!NT_STATUS_IS_OK(status)) {
721 return status;
722 }
723
724 *len = smb_len(inbuf);
725 msg_type = CVAL(inbuf,0);
726
727 if (msg_type == SMBkeepalive) {
728 DEBUG(5,("Got keepalive packet\n"));
729 }
730
731 DEBUG(10,("got smb length of %lu\n",(unsigned long)(*len)));
732
733 return NT_STATUS_OK;
734}
735
736/****************************************************************************
737 Read 4 bytes of a smb packet and return the smb length of the packet.
738 Store the result in the buffer. This version of the function will
739 never return a session keepalive (length of zero).
740 Timeout is in milliseconds.
741****************************************************************************/
742
743NTSTATUS read_smb_length(int fd, char *inbuf, unsigned int timeout,
744 size_t *len)
745{
746 uint8_t msgtype = SMBkeepalive;
747
748 while (msgtype == SMBkeepalive) {
749 NTSTATUS status;
750
751 status = read_smb_length_return_keepalive(fd, inbuf, timeout,
752 len);
753 if (!NT_STATUS_IS_OK(status)) {
754 return status;
755 }
756
757 msgtype = CVAL(inbuf, 0);
758 }
759
760 DEBUG(10,("read_smb_length: got smb length of %lu\n",
761 (unsigned long)len));
762
763 return NT_STATUS_OK;
764}
765
766/****************************************************************************
767 Read an smb from a fd.
768 The timeout is in milliseconds.
769 This function will return on receipt of a session keepalive packet.
770 maxlen is the max number of bytes to return, not including the 4 byte
771 length. If zero it means buflen limit.
772 Doesn't check the MAC on signed packets.
773****************************************************************************/
774
775NTSTATUS receive_smb_raw(int fd, char *buffer, size_t buflen, unsigned int timeout,
776 size_t maxlen, size_t *p_len)
777{
778 size_t len;
779 NTSTATUS status;
780
781 status = read_smb_length_return_keepalive(fd,buffer,timeout,&len);
782
783 if (!NT_STATUS_IS_OK(status)) {
784 DEBUG(10, ("receive_smb_raw: %s!\n", nt_errstr(status)));
785 return status;
786 }
787
788 if (len > buflen) {
789 DEBUG(0,("Invalid packet length! (%lu bytes).\n",
790 (unsigned long)len));
791 return NT_STATUS_INVALID_PARAMETER;
792 }
793
794 if(len > 0) {
795 if (maxlen) {
796 len = MIN(len,maxlen);
797 }
798
799 status = read_fd_with_timeout(
800 fd, buffer+4, len, len, timeout, &len);
801
802 if (!NT_STATUS_IS_OK(status)) {
803 return status;
804 }
805
806 /* not all of samba3 properly checks for packet-termination
807 * of strings. This ensures that we don't run off into
808 * empty space. */
809 SSVAL(buffer+4,len, 0);
810 }
811
812 *p_len = len;
813 return NT_STATUS_OK;
814}
815
816/****************************************************************************
817 Open a socket of the specified type, port, and address for incoming data.
818****************************************************************************/
819
820int open_socket_in(int type,
821 uint16_t port,
822 int dlevel,
823 const struct sockaddr_storage *psock,
824 bool rebind)
825{
826 struct sockaddr_storage sock;
827 int res;
828 socklen_t slen = sizeof(struct sockaddr_in);
829
830 sock = *psock;
831
832#if defined(HAVE_IPV6)
833 if (sock.ss_family == AF_INET6) {
834 ((struct sockaddr_in6 *)&sock)->sin6_port = htons(port);
835 slen = sizeof(struct sockaddr_in6);
836 }
837#endif
838 if (sock.ss_family == AF_INET) {
839 ((struct sockaddr_in *)&sock)->sin_port = htons(port);
840 }
841
842 res = socket(sock.ss_family, type, 0 );
843 if( res == -1 ) {
844 if( DEBUGLVL(0) ) {
845 dbgtext( "open_socket_in(): socket() call failed: " );
846 dbgtext( "%s\n", strerror( errno ) );
847 }
848 return -1;
849 }
850
851 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
852 {
853 int val = rebind ? 1 : 0;
854 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,
855 (char *)&val,sizeof(val)) == -1 ) {
856 if( DEBUGLVL( dlevel ) ) {
857 dbgtext( "open_socket_in(): setsockopt: " );
858 dbgtext( "SO_REUSEADDR = %s ",
859 val?"true":"false" );
860 dbgtext( "on port %d failed ", port );
861 dbgtext( "with error = %s\n", strerror(errno) );
862 }
863 }
864#ifdef SO_REUSEPORT
865 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,
866 (char *)&val,sizeof(val)) == -1 ) {
867 if( DEBUGLVL( dlevel ) ) {
868 dbgtext( "open_socket_in(): setsockopt: ");
869 dbgtext( "SO_REUSEPORT = %s ",
870 val?"true":"false");
871 dbgtext( "on port %d failed ", port);
872 dbgtext( "with error = %s\n", strerror(errno));
873 }
874 }
875#endif /* SO_REUSEPORT */
876 }
877
878 /* now we've got a socket - we need to bind it */
879 if (bind(res, (struct sockaddr *)&sock, slen) == -1 ) {
880 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 ||
881 port == SMB_PORT2 || port == NMB_PORT) ) {
882 char addr[INET6_ADDRSTRLEN];
883 print_sockaddr(addr, sizeof(addr),
884 &sock);
885 dbgtext( "bind failed on port %d ", port);
886 dbgtext( "socket_addr = %s.\n", addr);
887 dbgtext( "Error = %s\n", strerror(errno));
888 }
889 close(res);
890 return -1;
891 }
892
893 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
894 return( res );
895 }
896
897struct open_socket_out_state {
898 int fd;
899 struct event_context *ev;
900 struct sockaddr_storage ss;
901 socklen_t salen;
902 uint16_t port;
903 int wait_nsec;
904};
905
906static void open_socket_out_connected(struct tevent_req *subreq);
907
908static int open_socket_out_state_destructor(struct open_socket_out_state *s)
909{
910 if (s->fd != -1) {
911 close(s->fd);
912 }
913 return 0;
914}
915
916/****************************************************************************
917 Create an outgoing socket. timeout is in milliseconds.
918**************************************************************************/
919
920struct tevent_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
921 struct event_context *ev,
922 const struct sockaddr_storage *pss,
923 uint16_t port,
924 int timeout)
925{
926 char addr[INET6_ADDRSTRLEN];
927 struct tevent_req *result, *subreq;
928 struct open_socket_out_state *state;
929 NTSTATUS status;
930
931 result = tevent_req_create(mem_ctx, &state,
932 struct open_socket_out_state);
933 if (result == NULL) {
934 return NULL;
935 }
936 state->ev = ev;
937 state->ss = *pss;
938 state->port = port;
939 state->wait_nsec = 10000;
940 state->salen = -1;
941
942 state->fd = socket(state->ss.ss_family, SOCK_STREAM, 0);
943 if (state->fd == -1) {
944 status = map_nt_error_from_unix(errno);
945 goto post_status;
946 }
947 talloc_set_destructor(state, open_socket_out_state_destructor);
948
949 if (!tevent_req_set_endtime(
950 result, ev, timeval_current_ofs(0, timeout*1000))) {
951 goto fail;
952 }
953
954#if defined(HAVE_IPV6)
955 if (pss->ss_family == AF_INET6) {
956 struct sockaddr_in6 *psa6;
957 psa6 = (struct sockaddr_in6 *)&state->ss;
958 psa6->sin6_port = htons(port);
959 if (psa6->sin6_scope_id == 0
960 && IN6_IS_ADDR_LINKLOCAL(&psa6->sin6_addr)) {
961 setup_linklocal_scope_id(
962 (struct sockaddr *)&(state->ss));
963 }
964 state->salen = sizeof(struct sockaddr_in6);
965 }
966#endif
967 if (pss->ss_family == AF_INET) {
968 struct sockaddr_in *psa;
969 psa = (struct sockaddr_in *)&state->ss;
970 psa->sin_port = htons(port);
971 state->salen = sizeof(struct sockaddr_in);
972 }
973
974 if (pss->ss_family == AF_UNIX) {
975 state->salen = sizeof(struct sockaddr_un);
976 }
977
978 print_sockaddr(addr, sizeof(addr), &state->ss);
979 DEBUG(3,("Connecting to %s at port %u\n", addr, (unsigned int)port));
980
981 subreq = async_connect_send(state, state->ev, state->fd,
982 (struct sockaddr *)&state->ss,
983 state->salen);
984 if ((subreq == NULL)
985 || !tevent_req_set_endtime(
986 subreq, state->ev,
987 timeval_current_ofs(0, state->wait_nsec))) {
988 goto fail;
989 }
990 tevent_req_set_callback(subreq, open_socket_out_connected, result);
991 return result;
992
993 post_status:
994 tevent_req_nterror(result, status);
995 return tevent_req_post(result, ev);
996 fail:
997 TALLOC_FREE(result);
998 return NULL;
999}
1000
1001static void open_socket_out_connected(struct tevent_req *subreq)
1002{
1003 struct tevent_req *req =
1004 tevent_req_callback_data(subreq, struct tevent_req);
1005 struct open_socket_out_state *state =
1006 tevent_req_data(req, struct open_socket_out_state);
1007 int ret;
1008 int sys_errno;
1009
1010 ret = async_connect_recv(subreq, &sys_errno);
1011 TALLOC_FREE(subreq);
1012 if (ret == 0) {
1013 tevent_req_done(req);
1014 return;
1015 }
1016
1017 if (
1018#ifdef ETIMEDOUT
1019 (sys_errno == ETIMEDOUT) ||
1020#endif
1021 (sys_errno == EINPROGRESS) ||
1022 (sys_errno == EALREADY) ||
1023 (sys_errno == EAGAIN)) {
1024
1025 /*
1026 * retry
1027 */
1028
1029 if (state->wait_nsec < 250000) {
1030 state->wait_nsec *= 1.5;
1031 }
1032
1033 subreq = async_connect_send(state, state->ev, state->fd,
1034 (struct sockaddr *)&state->ss,
1035 state->salen);
1036 if (tevent_req_nomem(subreq, req)) {
1037 return;
1038 }
1039 if (!tevent_req_set_endtime(
1040 subreq, state->ev,
1041 timeval_current_ofs(0, state->wait_nsec))) {
1042 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
1043 return;
1044 }
1045 tevent_req_set_callback(subreq, open_socket_out_connected, req);
1046 return;
1047 }
1048
1049#ifdef EISCONN
1050 if (sys_errno == EISCONN) {
1051 tevent_req_done(req);
1052 return;
1053 }
1054#endif
1055
1056 /* real error */
1057 tevent_req_nterror(req, map_nt_error_from_unix(sys_errno));
1058}
1059
1060NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd)
1061{
1062 struct open_socket_out_state *state =
1063 tevent_req_data(req, struct open_socket_out_state);
1064 NTSTATUS status;
1065
1066 if (tevent_req_is_nterror(req, &status)) {
1067 return status;
1068 }
1069 *pfd = state->fd;
1070 state->fd = -1;
1071 return NT_STATUS_OK;
1072}
1073
1074NTSTATUS open_socket_out(const struct sockaddr_storage *pss, uint16_t port,
1075 int timeout, int *pfd)
1076{
1077 TALLOC_CTX *frame = talloc_stackframe();
1078 struct event_context *ev;
1079 struct tevent_req *req;
1080 NTSTATUS status = NT_STATUS_NO_MEMORY;
1081
1082 ev = event_context_init(frame);
1083 if (ev == NULL) {
1084 goto fail;
1085 }
1086
1087 req = open_socket_out_send(frame, ev, pss, port, timeout);
1088 if (req == NULL) {
1089 goto fail;
1090 }
1091 if (!tevent_req_poll(req, ev)) {
1092 status = NT_STATUS_INTERNAL_ERROR;
1093 goto fail;
1094 }
1095 status = open_socket_out_recv(req, pfd);
1096 fail:
1097 TALLOC_FREE(frame);
1098 return status;
1099}
1100
1101struct open_socket_out_defer_state {
1102 struct event_context *ev;
1103 struct sockaddr_storage ss;
1104 uint16_t port;
1105 int timeout;
1106 int fd;
1107};
1108
1109static void open_socket_out_defer_waited(struct tevent_req *subreq);
1110static void open_socket_out_defer_connected(struct tevent_req *subreq);
1111
1112struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
1113 struct event_context *ev,
1114 struct timeval wait_time,
1115 const struct sockaddr_storage *pss,
1116 uint16_t port,
1117 int timeout)
1118{
1119 struct tevent_req *req, *subreq;
1120 struct open_socket_out_defer_state *state;
1121
1122 req = tevent_req_create(mem_ctx, &state,
1123 struct open_socket_out_defer_state);
1124 if (req == NULL) {
1125 return NULL;
1126 }
1127 state->ev = ev;
1128 state->ss = *pss;
1129 state->port = port;
1130 state->timeout = timeout;
1131
1132 subreq = tevent_wakeup_send(
1133 state, ev,
1134 timeval_current_ofs(wait_time.tv_sec, wait_time.tv_usec));
1135 if (subreq == NULL) {
1136 goto fail;
1137 }
1138 tevent_req_set_callback(subreq, open_socket_out_defer_waited, req);
1139 return req;
1140 fail:
1141 TALLOC_FREE(req);
1142 return NULL;
1143}
1144
1145static void open_socket_out_defer_waited(struct tevent_req *subreq)
1146{
1147 struct tevent_req *req = tevent_req_callback_data(
1148 subreq, struct tevent_req);
1149 struct open_socket_out_defer_state *state = tevent_req_data(
1150 req, struct open_socket_out_defer_state);
1151 bool ret;
1152
1153 ret = tevent_wakeup_recv(subreq);
1154 TALLOC_FREE(subreq);
1155 if (!ret) {
1156 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1157 return;
1158 }
1159
1160 subreq = open_socket_out_send(state, state->ev, &state->ss,
1161 state->port, state->timeout);
1162 if (tevent_req_nomem(subreq, req)) {
1163 return;
1164 }
1165 tevent_req_set_callback(subreq, open_socket_out_defer_connected, req);
1166}
1167
1168static void open_socket_out_defer_connected(struct tevent_req *subreq)
1169{
1170 struct tevent_req *req = tevent_req_callback_data(
1171 subreq, struct tevent_req);
1172 struct open_socket_out_defer_state *state = tevent_req_data(
1173 req, struct open_socket_out_defer_state);
1174 NTSTATUS status;
1175
1176 status = open_socket_out_recv(subreq, &state->fd);
1177 TALLOC_FREE(subreq);
1178 if (!NT_STATUS_IS_OK(status)) {
1179 tevent_req_nterror(req, status);
1180 return;
1181 }
1182 tevent_req_done(req);
1183}
1184
1185NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd)
1186{
1187 struct open_socket_out_defer_state *state = tevent_req_data(
1188 req, struct open_socket_out_defer_state);
1189 NTSTATUS status;
1190
1191 if (tevent_req_is_nterror(req, &status)) {
1192 return status;
1193 }
1194 *pfd = state->fd;
1195 state->fd = -1;
1196 return NT_STATUS_OK;
1197}
1198
1199/*******************************************************************
1200 Create an outgoing TCP socket to the first addr that connects.
1201
1202 This is for simultaneous connection attempts to port 445 and 139 of a host
1203 or for simultatneous connection attempts to multiple DCs at once. We return
1204 a socket fd of the first successful connection.
1205
1206 @param[in] addrs list of Internet addresses and ports to connect to
1207 @param[in] num_addrs number of address/port pairs in the addrs list
1208 @param[in] timeout time after which we stop waiting for a socket connection
1209 to succeed, given in milliseconds
1210 @param[out] fd_index the entry in addrs which we successfully connected to
1211 @param[out] fd fd of the open and connected socket
1212 @return true on a successful connection, false if all connection attempts
1213 failed or we timed out
1214*******************************************************************/
1215
1216bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
1217 int timeout, int *fd_index, int *fd)
1218{
1219 int i, resulting_index, res;
1220 int *sockets;
1221 bool good_connect;
1222
1223 fd_set r_fds, wr_fds;
1224 struct timeval tv;
1225 int maxfd;
1226
1227 int connect_loop = 10000; /* 10 milliseconds */
1228
1229 timeout *= 1000; /* convert to microseconds */
1230
1231 sockets = SMB_MALLOC_ARRAY(int, num_addrs);
1232
1233 if (sockets == NULL)
1234 return false;
1235
1236 resulting_index = -1;
1237
1238 for (i=0; i<num_addrs; i++)
1239 sockets[i] = -1;
1240
1241 for (i=0; i<num_addrs; i++) {
1242 sockets[i] = socket(addrs[i].ss_family, SOCK_STREAM, 0);
1243 if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE)
1244 goto done;
1245 set_blocking(sockets[i], false);
1246 }
1247
1248 connect_again:
1249 good_connect = false;
1250
1251 for (i=0; i<num_addrs; i++) {
1252 const struct sockaddr * a =
1253 (const struct sockaddr *)&(addrs[i]);
1254
1255 if (sockets[i] == -1)
1256 continue;
1257
1258 if (sys_connect(sockets[i], a) == 0) {
1259 /* Rather unlikely as we are non-blocking, but it
1260 * might actually happen. */
1261 resulting_index = i;
1262 goto done;
1263 }
1264
1265 if (errno == EINPROGRESS || errno == EALREADY ||
1266#ifdef EISCONN
1267 errno == EISCONN ||
1268#endif
1269 errno == EAGAIN || errno == EINTR) {
1270 /* These are the error messages that something is
1271 progressing. */
1272 good_connect = true;
1273 } else if (errno != 0) {
1274 /* There was a direct error */
1275 close(sockets[i]);
1276 sockets[i] = -1;
1277 }
1278 }
1279
1280 if (!good_connect) {
1281 /* All of the connect's resulted in real error conditions */
1282 goto done;
1283 }
1284
1285 /* Lets see if any of the connect attempts succeeded */
1286
1287 maxfd = 0;
1288 FD_ZERO(&wr_fds);
1289 FD_ZERO(&r_fds);
1290
1291 for (i=0; i<num_addrs; i++) {
1292 if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE) {
1293 /* This cannot happen - ignore if so. */
1294 continue;
1295 }
1296 FD_SET(sockets[i], &wr_fds);
1297 FD_SET(sockets[i], &r_fds);
1298 if (sockets[i]>maxfd)
1299 maxfd = sockets[i];
1300 }
1301
1302 tv.tv_sec = 0;
1303 tv.tv_usec = connect_loop;
1304
1305 res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
1306
1307 if (res < 0)
1308 goto done;
1309
1310 if (res == 0)
1311 goto next_round;
1312
1313 for (i=0; i<num_addrs; i++) {
1314
1315 if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE) {
1316 /* This cannot happen - ignore if so. */
1317 continue;
1318 }
1319
1320 /* Stevens, Network Programming says that if there's a
1321 * successful connect, the socket is only writable. Upon an
1322 * error, it's both readable and writable. */
1323
1324 if (FD_ISSET(sockets[i], &r_fds) &&
1325 FD_ISSET(sockets[i], &wr_fds)) {
1326 /* readable and writable, so it's an error */
1327 close(sockets[i]);
1328 sockets[i] = -1;
1329 continue;
1330 }
1331
1332 if (!FD_ISSET(sockets[i], &r_fds) &&
1333 FD_ISSET(sockets[i], &wr_fds)) {
1334 /* Only writable, so it's connected */
1335 resulting_index = i;
1336 goto done;
1337 }
1338 }
1339
1340 next_round:
1341
1342 timeout -= connect_loop;
1343 if (timeout <= 0)
1344 goto done;
1345 connect_loop *= 1.5;
1346 if (connect_loop > timeout)
1347 connect_loop = timeout;
1348 goto connect_again;
1349
1350 done:
1351 for (i=0; i<num_addrs; i++) {
1352 if (i == resulting_index)
1353 continue;
1354 if (sockets[i] >= 0)
1355 close(sockets[i]);
1356 }
1357
1358 if (resulting_index >= 0) {
1359 *fd_index = resulting_index;
1360 *fd = sockets[*fd_index];
1361 set_blocking(*fd, true);
1362 }
1363
1364 free(sockets);
1365
1366 return (resulting_index >= 0);
1367}
1368/****************************************************************************
1369 Open a connected UDP socket to host on port
1370**************************************************************************/
1371
1372int open_udp_socket(const char *host, int port)
1373{
1374 struct sockaddr_storage ss;
1375 int res;
1376
1377 if (!interpret_string_addr(&ss, host, 0)) {
1378 DEBUG(10,("open_udp_socket: can't resolve name %s\n",
1379 host));
1380 return -1;
1381 }
1382
1383 res = socket(ss.ss_family, SOCK_DGRAM, 0);
1384 if (res == -1) {
1385 return -1;
1386 }
1387
1388#if defined(HAVE_IPV6)
1389 if (ss.ss_family == AF_INET6) {
1390 struct sockaddr_in6 *psa6;
1391 psa6 = (struct sockaddr_in6 *)&ss;
1392 psa6->sin6_port = htons(port);
1393 if (psa6->sin6_scope_id == 0
1394 && IN6_IS_ADDR_LINKLOCAL(&psa6->sin6_addr)) {
1395 setup_linklocal_scope_id(
1396 (struct sockaddr *)&ss);
1397 }
1398 }
1399#endif
1400 if (ss.ss_family == AF_INET) {
1401 struct sockaddr_in *psa;
1402 psa = (struct sockaddr_in *)&ss;
1403 psa->sin_port = htons(port);
1404 }
1405
1406 if (sys_connect(res,(struct sockaddr *)&ss)) {
1407 close(res);
1408 return -1;
1409 }
1410
1411 return res;
1412}
1413
1414/*******************************************************************
1415 Return the IP addr of the remote end of a socket as a string.
1416 Optionally return the struct sockaddr_storage.
1417 ******************************************************************/
1418
1419static const char *get_peer_addr_internal(int fd,
1420 char *addr_buf,
1421 size_t addr_buf_len,
1422 struct sockaddr *pss,
1423 socklen_t *plength)
1424{
1425 struct sockaddr_storage ss;
1426 socklen_t length = sizeof(ss);
1427
1428 strlcpy(addr_buf,"0.0.0.0",addr_buf_len);
1429
1430 if (fd == -1) {
1431 return addr_buf;
1432 }
1433
1434 if (pss == NULL) {
1435 pss = (struct sockaddr *)&ss;
1436 plength = &length;
1437 }
1438
1439 if (getpeername(fd, (struct sockaddr *)pss, plength) < 0) {
1440 DEBUG(0,("getpeername failed. Error was %s\n",
1441 strerror(errno) ));
1442 return addr_buf;
1443 }
1444
1445 print_sockaddr_len(addr_buf,
1446 addr_buf_len,
1447 pss,
1448 *plength);
1449 return addr_buf;
1450}
1451
1452/*******************************************************************
1453 Matchname - determine if host name matches IP address. Used to
1454 confirm a hostname lookup to prevent spoof attacks.
1455******************************************************************/
1456
1457static bool matchname(const char *remotehost,
1458 const struct sockaddr *pss,
1459 socklen_t len)
1460{
1461 struct addrinfo *res = NULL;
1462 struct addrinfo *ailist = NULL;
1463 char addr_buf[INET6_ADDRSTRLEN];
1464 bool ret = interpret_string_addr_internal(&ailist,
1465 remotehost,
1466 AI_ADDRCONFIG|AI_CANONNAME);
1467
1468 if (!ret || ailist == NULL) {
1469 DEBUG(3,("matchname: getaddrinfo failed for "
1470 "name %s [%s]\n",
1471 remotehost,
1472 gai_strerror(ret) ));
1473 return false;
1474 }
1475
1476 /*
1477 * Make sure that getaddrinfo() returns the "correct" host name.
1478 */
1479
1480 if (ailist->ai_canonname == NULL ||
1481 (!strequal(remotehost, ailist->ai_canonname) &&
1482 !strequal(remotehost, "localhost"))) {
1483 DEBUG(0,("matchname: host name/name mismatch: %s != %s\n",
1484 remotehost,
1485 ailist->ai_canonname ?
1486 ailist->ai_canonname : "(NULL)"));
1487 freeaddrinfo(ailist);
1488 return false;
1489 }
1490
1491 /* Look up the host address in the address list we just got. */
1492 for (res = ailist; res; res = res->ai_next) {
1493 if (!res->ai_addr) {
1494 continue;
1495 }
1496 if (sockaddr_equal((const struct sockaddr *)res->ai_addr,
1497 (struct sockaddr *)pss)) {
1498 freeaddrinfo(ailist);
1499 return true;
1500 }
1501 }
1502
1503 /*
1504 * The host name does not map to the original host address. Perhaps
1505 * someone has compromised a name server. More likely someone botched
1506 * it, but that could be dangerous, too.
1507 */
1508
1509 DEBUG(0,("matchname: host name/address mismatch: %s != %s\n",
1510 print_sockaddr_len(addr_buf,
1511 sizeof(addr_buf),
1512 pss,
1513 len),
1514 ailist->ai_canonname ? ailist->ai_canonname : "(NULL)"));
1515
1516 if (ailist) {
1517 freeaddrinfo(ailist);
1518 }
1519 return false;
1520}
1521
1522/*******************************************************************
1523 Deal with the singleton cache.
1524******************************************************************/
1525
1526struct name_addr_pair {
1527 struct sockaddr_storage ss;
1528 const char *name;
1529};
1530
1531/*******************************************************************
1532 Lookup a name/addr pair. Returns memory allocated from memcache.
1533******************************************************************/
1534
1535static bool lookup_nc(struct name_addr_pair *nc)
1536{
1537 DATA_BLOB tmp;
1538
1539 ZERO_STRUCTP(nc);
1540
1541 if (!memcache_lookup(
1542 NULL, SINGLETON_CACHE,
1543 data_blob_string_const_null("get_peer_name"),
1544 &tmp)) {
1545 return false;
1546 }
1547
1548 memcpy(&nc->ss, tmp.data, sizeof(nc->ss));
1549 nc->name = (const char *)tmp.data + sizeof(nc->ss);
1550 return true;
1551}
1552
1553/*******************************************************************
1554 Save a name/addr pair.
1555******************************************************************/
1556
1557static void store_nc(const struct name_addr_pair *nc)
1558{
1559 DATA_BLOB tmp;
1560 size_t namelen = strlen(nc->name);
1561
1562 tmp = data_blob(NULL, sizeof(nc->ss) + namelen + 1);
1563 if (!tmp.data) {
1564 return;
1565 }
1566 memcpy(tmp.data, &nc->ss, sizeof(nc->ss));
1567 memcpy(tmp.data+sizeof(nc->ss), nc->name, namelen+1);
1568
1569 memcache_add(NULL, SINGLETON_CACHE,
1570 data_blob_string_const_null("get_peer_name"),
1571 tmp);
1572 data_blob_free(&tmp);
1573}
1574
1575/*******************************************************************
1576 Return the DNS name of the remote end of a socket.
1577******************************************************************/
1578
1579const char *get_peer_name(int fd, bool force_lookup)
1580{
1581 struct name_addr_pair nc;
1582 char addr_buf[INET6_ADDRSTRLEN];
1583 struct sockaddr_storage ss;
1584 socklen_t length = sizeof(ss);
1585 const char *p;
1586 int ret;
1587 char name_buf[MAX_DNS_NAME_LENGTH];
1588 char tmp_name[MAX_DNS_NAME_LENGTH];
1589
1590 /* reverse lookups can be *very* expensive, and in many
1591 situations won't work because many networks don't link dhcp
1592 with dns. To avoid the delay we avoid the lookup if
1593 possible */
1594 if (!lp_hostname_lookups() && (force_lookup == false)) {
1595 length = sizeof(nc.ss);
1596 nc.name = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf),
1597 (struct sockaddr *)&nc.ss, &length);
1598 store_nc(&nc);
1599 lookup_nc(&nc);
1600 return nc.name ? nc.name : "UNKNOWN";
1601 }
1602
1603 lookup_nc(&nc);
1604
1605 memset(&ss, '\0', sizeof(ss));
1606 p = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf), (struct sockaddr *)&ss, &length);
1607
1608 /* it might be the same as the last one - save some DNS work */
1609 if (sockaddr_equal((struct sockaddr *)&ss, (struct sockaddr *)&nc.ss)) {
1610 return nc.name ? nc.name : "UNKNOWN";
1611 }
1612
1613 /* Not the same. We need to lookup. */
1614 if (fd == -1) {
1615 return "UNKNOWN";
1616 }
1617
1618 /* Look up the remote host name. */
1619 ret = sys_getnameinfo((struct sockaddr *)&ss,
1620 length,
1621 name_buf,
1622 sizeof(name_buf),
1623 NULL,
1624 0,
1625 0);
1626
1627 if (ret) {
1628 DEBUG(1,("get_peer_name: getnameinfo failed "
1629 "for %s with error %s\n",
1630 p,
1631 gai_strerror(ret)));
1632 strlcpy(name_buf, p, sizeof(name_buf));
1633 } else {
1634 if (!matchname(name_buf, (struct sockaddr *)&ss, length)) {
1635 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1636 strlcpy(name_buf,"UNKNOWN",sizeof(name_buf));
1637 }
1638 }
1639
1640 /* can't pass the same source and dest strings in when you
1641 use --enable-developer or the clobber_region() call will
1642 get you */
1643
1644 strlcpy(tmp_name, name_buf, sizeof(tmp_name));
1645 alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1646 if (strstr(name_buf,"..")) {
1647 strlcpy(name_buf, "UNKNOWN", sizeof(name_buf));
1648 }
1649
1650 nc.name = name_buf;
1651 nc.ss = ss;
1652
1653 store_nc(&nc);
1654 lookup_nc(&nc);
1655 return nc.name ? nc.name : "UNKNOWN";
1656}
1657
1658/*******************************************************************
1659 Return the IP addr of the remote end of a socket as a string.
1660 ******************************************************************/
1661
1662const char *get_peer_addr(int fd, char *addr, size_t addr_len)
1663{
1664 return get_peer_addr_internal(fd, addr, addr_len, NULL, NULL);
1665}
1666
1667/*******************************************************************
1668 Create protected unix domain socket.
1669
1670 Some unixes cannot set permissions on a ux-dom-sock, so we
1671 have to make sure that the directory contains the protection
1672 permissions instead.
1673 ******************************************************************/
1674
1675int create_pipe_sock(const char *socket_dir,
1676 const char *socket_name,
1677 mode_t dir_perms)
1678{
1679#ifdef HAVE_UNIXSOCKET
1680 struct sockaddr_un sunaddr;
1681 struct stat st;
1682 int sock;
1683 mode_t old_umask;
1684 char *path = NULL;
1685
1686 old_umask = umask(0);
1687
1688 /* Create the socket directory or reuse the existing one */
1689
1690 if (lstat(socket_dir, &st) == -1) {
1691 if (errno == ENOENT) {
1692 /* Create directory */
1693 if (mkdir(socket_dir, dir_perms) == -1) {
1694 DEBUG(0, ("error creating socket directory "
1695 "%s: %s\n", socket_dir,
1696 strerror(errno)));
1697 goto out_umask;
1698 }
1699 } else {
1700 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1701 socket_dir, strerror(errno)));
1702 goto out_umask;
1703 }
1704 } else {
1705 /* Check ownership and permission on existing directory */
1706 if (!S_ISDIR(st.st_mode)) {
1707 DEBUG(0, ("socket directory %s isn't a directory\n",
1708 socket_dir));
1709 goto out_umask;
1710 }
1711 if ((st.st_uid != sec_initial_uid()) ||
1712 ((st.st_mode & 0777) != dir_perms)) {
1713 DEBUG(0, ("invalid permissions on socket directory "
1714 "%s\n", socket_dir));
1715 goto out_umask;
1716 }
1717 }
1718
1719 /* Create the socket file */
1720
1721 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1722
1723 if (sock == -1) {
1724 DEBUG(0, ("create_pipe_sock: socket error %s\n",
1725 strerror(errno) ));
1726 goto out_close;
1727 }
1728
1729 if (asprintf(&path, "%s/%s", socket_dir, socket_name) == -1) {
1730 goto out_close;
1731 }
1732
1733 unlink(path);
1734 memset(&sunaddr, 0, sizeof(sunaddr));
1735 sunaddr.sun_family = AF_UNIX;
1736 strlcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path));
1737
1738 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1739 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1740 strerror(errno)));
1741 goto out_close;
1742 }
1743
1744 if (listen(sock, 5) == -1) {
1745 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1746 strerror(errno)));
1747 goto out_close;
1748 }
1749
1750 SAFE_FREE(path);
1751
1752 umask(old_umask);
1753 return sock;
1754
1755out_close:
1756 SAFE_FREE(path);
1757 if (sock != -1)
1758 close(sock);
1759
1760out_umask:
1761 umask(old_umask);
1762 return -1;
1763
1764#else
1765 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1766 return -1;
1767#endif /* HAVE_UNIXSOCKET */
1768}
1769
1770/****************************************************************************
1771 Get my own canonical name, including domain.
1772****************************************************************************/
1773
1774const char *get_mydnsfullname(void)
1775{
1776 struct addrinfo *res = NULL;
1777 char my_hostname[HOST_NAME_MAX];
1778 bool ret;
1779 DATA_BLOB tmp;
1780
1781 if (memcache_lookup(NULL, SINGLETON_CACHE,
1782 data_blob_string_const_null("get_mydnsfullname"),
1783 &tmp)) {
1784 SMB_ASSERT(tmp.length > 0);
1785 return (const char *)tmp.data;
1786 }
1787
1788 /* get my host name */
1789 if (gethostname(my_hostname, sizeof(my_hostname)) == -1) {
1790 DEBUG(0,("get_mydnsfullname: gethostname failed\n"));
1791 return NULL;
1792 }
1793
1794 /* Ensure null termination. */
1795 my_hostname[sizeof(my_hostname)-1] = '\0';
1796
1797 ret = interpret_string_addr_internal(&res,
1798 my_hostname,
1799 AI_ADDRCONFIG|AI_CANONNAME);
1800
1801 if (!ret || res == NULL) {
1802 DEBUG(3,("get_mydnsfullname: getaddrinfo failed for "
1803 "name %s [%s]\n",
1804 my_hostname,
1805 gai_strerror(ret) ));
1806 return NULL;
1807 }
1808
1809 /*
1810 * Make sure that getaddrinfo() returns the "correct" host name.
1811 */
1812
1813 if (res->ai_canonname == NULL) {
1814 DEBUG(3,("get_mydnsfullname: failed to get "
1815 "canonical name for %s\n",
1816 my_hostname));
1817 freeaddrinfo(res);
1818 return NULL;
1819 }
1820
1821 /* This copies the data, so we must do a lookup
1822 * afterwards to find the value to return.
1823 */
1824
1825 memcache_add(NULL, SINGLETON_CACHE,
1826 data_blob_string_const_null("get_mydnsfullname"),
1827 data_blob_string_const_null(res->ai_canonname));
1828
1829 if (!memcache_lookup(NULL, SINGLETON_CACHE,
1830 data_blob_string_const_null("get_mydnsfullname"),
1831 &tmp)) {
1832 tmp = data_blob_talloc(talloc_tos(), res->ai_canonname,
1833 strlen(res->ai_canonname) + 1);
1834 }
1835
1836 freeaddrinfo(res);
1837
1838 return (const char *)tmp.data;
1839}
1840
1841/************************************************************
1842 Is this my ip address ?
1843************************************************************/
1844
1845static bool is_my_ipaddr(const char *ipaddr_str)
1846{
1847 struct sockaddr_storage ss;
1848 struct iface_struct *nics;
1849 int i, n;
1850
1851 if (!interpret_string_addr(&ss, ipaddr_str, AI_NUMERICHOST)) {
1852 return false;
1853 }
1854
1855 if (ismyaddr((struct sockaddr *)&ss)) {
1856 return true;
1857 }
1858
1859 if (is_zero_addr((struct sockaddr *)&ss) ||
1860 is_loopback_addr((struct sockaddr *)&ss)) {
1861 return false;
1862 }
1863
1864 n = get_interfaces(talloc_tos(), &nics);
1865 for (i=0; i<n; i++) {
1866 if (sockaddr_equal((struct sockaddr *)&nics[i].ip, (struct sockaddr *)&ss)) {
1867 TALLOC_FREE(nics);
1868 return true;
1869 }
1870 }
1871 TALLOC_FREE(nics);
1872 return false;
1873}
1874
1875/************************************************************
1876 Is this my name ?
1877************************************************************/
1878
1879bool is_myname_or_ipaddr(const char *s)
1880{
1881 TALLOC_CTX *ctx = talloc_tos();
1882 char *name = NULL;
1883 const char *dnsname;
1884 char *servername = NULL;
1885
1886 if (!s) {
1887 return false;
1888 }
1889
1890 /* Santize the string from '\\name' */
1891 name = talloc_strdup(ctx, s);
1892 if (!name) {
1893 return false;
1894 }
1895
1896 servername = strrchr_m(name, '\\' );
1897 if (!servername) {
1898 servername = name;
1899 } else {
1900 servername++;
1901 }
1902
1903 /* Optimize for the common case */
1904 if (strequal(servername, global_myname())) {
1905 return true;
1906 }
1907
1908 /* Check for an alias */
1909 if (is_myname(servername)) {
1910 return true;
1911 }
1912
1913 /* Check for loopback */
1914 if (strequal(servername, "127.0.0.1") ||
1915 strequal(servername, "::1")) {
1916 return true;
1917 }
1918
1919 if (strequal(servername, "localhost")) {
1920 return true;
1921 }
1922
1923 /* Maybe it's my dns name */
1924 dnsname = get_mydnsfullname();
1925 if (dnsname && strequal(servername, dnsname)) {
1926 return true;
1927 }
1928
1929 /* Handle possible CNAME records - convert to an IP addr. list. */
1930 if (!is_ipaddress(servername)) {
1931 /* Use DNS to resolve the name, check all addresses. */
1932 struct addrinfo *p = NULL;
1933 struct addrinfo *res = NULL;
1934
1935 if (!interpret_string_addr_internal(&res,
1936 servername,
1937 AI_ADDRCONFIG)) {
1938 return false;
1939 }
1940
1941 for (p = res; p; p = p->ai_next) {
1942 char addr[INET6_ADDRSTRLEN];
1943 struct sockaddr_storage ss;
1944
1945 ZERO_STRUCT(ss);
1946 memcpy(&ss, p->ai_addr, p->ai_addrlen);
1947 print_sockaddr(addr,
1948 sizeof(addr),
1949 &ss);
1950 if (is_my_ipaddr(addr)) {
1951 freeaddrinfo(res);
1952 return true;
1953 }
1954 }
1955 freeaddrinfo(res);
1956 }
1957
1958 /* Maybe its an IP address? */
1959 if (is_ipaddress(servername)) {
1960 return is_my_ipaddr(servername);
1961 }
1962
1963 /* No match */
1964 return false;
1965}
1966
1967struct getaddrinfo_state {
1968 const char *node;
1969 const char *service;
1970 const struct addrinfo *hints;
1971 struct addrinfo *res;
1972 int ret;
1973};
1974
1975static void getaddrinfo_do(void *private_data);
1976static void getaddrinfo_done(struct tevent_req *subreq);
1977
1978struct tevent_req *getaddrinfo_send(TALLOC_CTX *mem_ctx,
1979 struct tevent_context *ev,
1980 struct fncall_context *ctx,
1981 const char *node,
1982 const char *service,
1983 const struct addrinfo *hints)
1984{
1985 struct tevent_req *req, *subreq;
1986 struct getaddrinfo_state *state;
1987
1988 req = tevent_req_create(mem_ctx, &state, struct getaddrinfo_state);
1989 if (req == NULL) {
1990 return NULL;
1991 }
1992
1993 state->node = node;
1994 state->service = service;
1995 state->hints = hints;
1996
1997 subreq = fncall_send(state, ev, ctx, getaddrinfo_do, state);
1998 if (tevent_req_nomem(subreq, req)) {
1999 return tevent_req_post(req, ev);
2000 }
2001 tevent_req_set_callback(subreq, getaddrinfo_done, req);
2002 return req;
2003}
2004
2005static void getaddrinfo_do(void *private_data)
2006{
2007 struct getaddrinfo_state *state =
2008 (struct getaddrinfo_state *)private_data;
2009
2010 state->ret = getaddrinfo(state->node, state->service, state->hints,
2011 &state->res);
2012}
2013
2014static void getaddrinfo_done(struct tevent_req *subreq)
2015{
2016 struct tevent_req *req = tevent_req_callback_data(
2017 subreq, struct tevent_req);
2018 int ret, err;
2019
2020 ret = fncall_recv(subreq, &err);
2021 TALLOC_FREE(subreq);
2022 if (ret == -1) {
2023 tevent_req_error(req, err);
2024 return;
2025 }
2026 tevent_req_done(req);
2027}
2028
2029int getaddrinfo_recv(struct tevent_req *req, struct addrinfo **res)
2030{
2031 struct getaddrinfo_state *state = tevent_req_data(
2032 req, struct getaddrinfo_state);
2033 int err;
2034
2035 if (tevent_req_is_unix_error(req, &err)) {
2036 switch(err) {
2037 case ENOMEM:
2038 return EAI_MEMORY;
2039 default:
2040 return EAI_FAIL;
2041 }
2042 }
2043 if (state->ret == 0) {
2044 *res = state->res;
2045 }
2046 return state->ret;
2047}
Note: See TracBrowser for help on using the repository browser.