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

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 49.2 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 FD_ZERO(&fds);
499 FD_SET(fd,&fds);
500
501 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
502
503 /* Check if error */
504 if (selrtn == -1) {
505 save_errno = errno;
506 /* something is wrong. Maybe the socket is dead? */
507 if (fd == get_client_fd()) {
508 /* Try and give an error message saying
509 * what client failed. */
510 DEBUG(0,("read_fd_with_timeout: timeout "
511 "read for client %s. select error = %s.\n",
512 get_peer_addr(fd,addr,sizeof(addr)),
513 strerror(save_errno) ));
514 } else {
515 DEBUG(0,("read_fd_with_timeout: timeout "
516 "read. select error = %s.\n",
517 strerror(save_errno) ));
518 }
519 return map_nt_error_from_unix(save_errno);
520 }
521
522 /* Did we timeout ? */
523 if (selrtn == 0) {
524 DEBUG(10,("read_fd_with_timeout: timeout read. "
525 "select timed out.\n"));
526 return NT_STATUS_IO_TIMEOUT;
527 }
528
529 readret = sys_read(fd, buf+nread, maxcnt-nread);
530
531 if (readret == 0) {
532 /* we got EOF on the file descriptor */
533 DEBUG(5,("read_fd_with_timeout: timeout read. "
534 "EOF from client.\n"));
535 return NT_STATUS_END_OF_FILE;
536 }
537
538 if (readret == -1) {
539 save_errno = errno;
540 /* the descriptor is probably dead */
541 if (fd == get_client_fd()) {
542 /* Try and give an error message
543 * saying what client failed. */
544 DEBUG(0,("read_fd_with_timeout: timeout "
545 "read to client %s. read error = %s.\n",
546 get_peer_addr(fd,addr,sizeof(addr)),
547 strerror(save_errno) ));
548 } else {
549 DEBUG(0,("read_fd_with_timeout: timeout "
550 "read. read error = %s.\n",
551 strerror(save_errno) ));
552 }
553 return map_nt_error_from_unix(errno);
554 }
555
556 nread += readret;
557 }
558
559 done:
560 /* Return the number we got */
561 if (size_ret) {
562 *size_ret = nread;
563 }
564 return NT_STATUS_OK;
565}
566
567/****************************************************************************
568 Read data from an fd, reading exactly N bytes.
569 NB. This can be called with a non-socket fd, don't add dependencies
570 on socket calls.
571****************************************************************************/
572
573NTSTATUS read_data(int fd, char *buffer, size_t N)
574{
575 return read_fd_with_timeout(fd, buffer, N, N, 0, NULL);
576}
577
578/****************************************************************************
579 Write all data from an iov array
580 NB. This can be called with a non-socket fd, don't add dependencies
581 on socket calls.
582****************************************************************************/
583
584ssize_t write_data_iov(int fd, const struct iovec *orig_iov, int iovcnt)
585{
586 int i;
587 size_t to_send;
588 ssize_t thistime;
589 size_t sent;
590 struct iovec *iov_copy, *iov;
591
592 to_send = 0;
593 for (i=0; i<iovcnt; i++) {
594 to_send += orig_iov[i].iov_len;
595 }
596
597 thistime = sys_writev(fd, orig_iov, iovcnt);
598 if ((thistime <= 0) || (thistime == to_send)) {
599 return thistime;
600 }
601 sent = thistime;
602
603 /*
604 * We could not send everything in one call. Make a copy of iov that
605 * we can mess with. We keep a copy of the array start in iov_copy for
606 * the TALLOC_FREE, because we're going to modify iov later on,
607 * discarding elements.
608 */
609
610 iov_copy = (struct iovec *)TALLOC_MEMDUP(
611 talloc_tos(), orig_iov, sizeof(struct iovec) * iovcnt);
612
613 if (iov_copy == NULL) {
614 errno = ENOMEM;
615 return -1;
616 }
617 iov = iov_copy;
618
619 while (sent < to_send) {
620 /*
621 * We have to discard "thistime" bytes from the beginning
622 * iov array, "thistime" contains the number of bytes sent
623 * via writev last.
624 */
625 while (thistime > 0) {
626 if (thistime < iov[0].iov_len) {
627 char *new_base =
628 (char *)iov[0].iov_base + thistime;
629 iov[0].iov_base = (void *)new_base;
630 iov[0].iov_len -= thistime;
631 break;
632 }
633 thistime -= iov[0].iov_len;
634 iov += 1;
635 iovcnt -= 1;
636 }
637
638 thistime = sys_writev(fd, iov, iovcnt);
639 if (thistime <= 0) {
640 break;
641 }
642 sent += thistime;
643 }
644
645 TALLOC_FREE(iov_copy);
646 return sent;
647}
648
649/****************************************************************************
650 Write data to a fd.
651 NB. This can be called with a non-socket fd, don't add dependencies
652 on socket calls.
653****************************************************************************/
654
655ssize_t write_data(int fd, const char *buffer, size_t N)
656{
657 ssize_t ret;
658 struct iovec iov;
659
660 iov.iov_base = CONST_DISCARD(void *, buffer);
661 iov.iov_len = N;
662
663 ret = write_data_iov(fd, &iov, 1);
664 if (ret >= 0) {
665 return ret;
666 }
667
668 if (fd == get_client_fd()) {
669 char addr[INET6_ADDRSTRLEN];
670 /*
671 * Try and give an error message saying what client failed.
672 */
673 DEBUG(0, ("write_data: write failure in writing to client %s. "
674 "Error %s\n", get_peer_addr(fd,addr,sizeof(addr)),
675 strerror(errno)));
676 } else {
677 DEBUG(0,("write_data: write failure. Error = %s\n",
678 strerror(errno) ));
679 }
680
681 return -1;
682}
683
684/****************************************************************************
685 Send a keepalive packet (rfc1002).
686****************************************************************************/
687
688bool send_keepalive(int client)
689{
690 unsigned char buf[4];
691
692 buf[0] = SMBkeepalive;
693 buf[1] = buf[2] = buf[3] = 0;
694
695 return(write_data(client,(char *)buf,4) == 4);
696}
697
698/****************************************************************************
699 Read 4 bytes of a smb packet and return the smb length of the packet.
700 Store the result in the buffer.
701 This version of the function will return a length of zero on receiving
702 a keepalive packet.
703 Timeout is in milliseconds.
704****************************************************************************/
705
706NTSTATUS read_smb_length_return_keepalive(int fd, char *inbuf,
707 unsigned int timeout,
708 size_t *len)
709{
710 int msg_type;
711 NTSTATUS status;
712
713 status = read_fd_with_timeout(fd, inbuf, 4, 4, timeout, NULL);
714
715 if (!NT_STATUS_IS_OK(status)) {
716 return status;
717 }
718
719 *len = smb_len(inbuf);
720 msg_type = CVAL(inbuf,0);
721
722 if (msg_type == SMBkeepalive) {
723 DEBUG(5,("Got keepalive packet\n"));
724 }
725
726 DEBUG(10,("got smb length of %lu\n",(unsigned long)(*len)));
727
728 return NT_STATUS_OK;
729}
730
731/****************************************************************************
732 Read 4 bytes of a smb packet and return the smb length of the packet.
733 Store the result in the buffer. This version of the function will
734 never return a session keepalive (length of zero).
735 Timeout is in milliseconds.
736****************************************************************************/
737
738NTSTATUS read_smb_length(int fd, char *inbuf, unsigned int timeout,
739 size_t *len)
740{
741 uint8_t msgtype = SMBkeepalive;
742
743 while (msgtype == SMBkeepalive) {
744 NTSTATUS status;
745
746 status = read_smb_length_return_keepalive(fd, inbuf, timeout,
747 len);
748 if (!NT_STATUS_IS_OK(status)) {
749 return status;
750 }
751
752 msgtype = CVAL(inbuf, 0);
753 }
754
755 DEBUG(10,("read_smb_length: got smb length of %lu\n",
756 (unsigned long)len));
757
758 return NT_STATUS_OK;
759}
760
761/****************************************************************************
762 Read an smb from a fd.
763 The timeout is in milliseconds.
764 This function will return on receipt of a session keepalive packet.
765 maxlen is the max number of bytes to return, not including the 4 byte
766 length. If zero it means buflen limit.
767 Doesn't check the MAC on signed packets.
768****************************************************************************/
769
770NTSTATUS receive_smb_raw(int fd, char *buffer, size_t buflen, unsigned int timeout,
771 size_t maxlen, size_t *p_len)
772{
773 size_t len;
774 NTSTATUS status;
775
776 status = read_smb_length_return_keepalive(fd,buffer,timeout,&len);
777
778 if (!NT_STATUS_IS_OK(status)) {
779 DEBUG(10, ("receive_smb_raw: %s!\n", nt_errstr(status)));
780 return status;
781 }
782
783 if (len > buflen) {
784 DEBUG(0,("Invalid packet length! (%lu bytes).\n",
785 (unsigned long)len));
786 return NT_STATUS_INVALID_PARAMETER;
787 }
788
789 if(len > 0) {
790 if (maxlen) {
791 len = MIN(len,maxlen);
792 }
793
794 status = read_fd_with_timeout(
795 fd, buffer+4, len, len, timeout, &len);
796
797 if (!NT_STATUS_IS_OK(status)) {
798 return status;
799 }
800
801 /* not all of samba3 properly checks for packet-termination
802 * of strings. This ensures that we don't run off into
803 * empty space. */
804 SSVAL(buffer+4,len, 0);
805 }
806
807 *p_len = len;
808 return NT_STATUS_OK;
809}
810
811/****************************************************************************
812 Open a socket of the specified type, port, and address for incoming data.
813****************************************************************************/
814
815int open_socket_in(int type,
816 uint16_t port,
817 int dlevel,
818 const struct sockaddr_storage *psock,
819 bool rebind)
820{
821 struct sockaddr_storage sock;
822 int res;
823 socklen_t slen = sizeof(struct sockaddr_in);
824
825 sock = *psock;
826
827#if defined(HAVE_IPV6)
828 if (sock.ss_family == AF_INET6) {
829 ((struct sockaddr_in6 *)&sock)->sin6_port = htons(port);
830 slen = sizeof(struct sockaddr_in6);
831 }
832#endif
833 if (sock.ss_family == AF_INET) {
834 ((struct sockaddr_in *)&sock)->sin_port = htons(port);
835 }
836
837 res = socket(sock.ss_family, type, 0 );
838 if( res == -1 ) {
839 if( DEBUGLVL(0) ) {
840 dbgtext( "open_socket_in(): socket() call failed: " );
841 dbgtext( "%s\n", strerror( errno ) );
842 }
843 return -1;
844 }
845
846 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
847 {
848 int val = rebind ? 1 : 0;
849 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,
850 (char *)&val,sizeof(val)) == -1 ) {
851 if( DEBUGLVL( dlevel ) ) {
852 dbgtext( "open_socket_in(): setsockopt: " );
853 dbgtext( "SO_REUSEADDR = %s ",
854 val?"true":"false" );
855 dbgtext( "on port %d failed ", port );
856 dbgtext( "with error = %s\n", strerror(errno) );
857 }
858 }
859#ifdef SO_REUSEPORT
860 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,
861 (char *)&val,sizeof(val)) == -1 ) {
862 if( DEBUGLVL( dlevel ) ) {
863 dbgtext( "open_socket_in(): setsockopt: ");
864 dbgtext( "SO_REUSEPORT = %s ",
865 val?"true":"false");
866 dbgtext( "on port %d failed ", port);
867 dbgtext( "with error = %s\n", strerror(errno));
868 }
869 }
870#endif /* SO_REUSEPORT */
871 }
872
873 /* now we've got a socket - we need to bind it */
874 if (bind(res, (struct sockaddr *)&sock, slen) == -1 ) {
875 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 ||
876 port == SMB_PORT2 || port == NMB_PORT) ) {
877 char addr[INET6_ADDRSTRLEN];
878 print_sockaddr(addr, sizeof(addr),
879 &sock);
880 dbgtext( "bind failed on port %d ", port);
881 dbgtext( "socket_addr = %s.\n", addr);
882 dbgtext( "Error = %s\n", strerror(errno));
883 }
884 close(res);
885 return -1;
886 }
887
888 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
889 return( res );
890 }
891
892struct open_socket_out_state {
893 int fd;
894 struct event_context *ev;
895 struct sockaddr_storage ss;
896 socklen_t salen;
897 uint16_t port;
898 int wait_nsec;
899};
900
901static void open_socket_out_connected(struct tevent_req *subreq);
902
903static int open_socket_out_state_destructor(struct open_socket_out_state *s)
904{
905 if (s->fd != -1) {
906 close(s->fd);
907 }
908 return 0;
909}
910
911/****************************************************************************
912 Create an outgoing socket. timeout is in milliseconds.
913**************************************************************************/
914
915struct tevent_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
916 struct event_context *ev,
917 const struct sockaddr_storage *pss,
918 uint16_t port,
919 int timeout)
920{
921 char addr[INET6_ADDRSTRLEN];
922 struct tevent_req *result, *subreq;
923 struct open_socket_out_state *state;
924 NTSTATUS status;
925
926 result = tevent_req_create(mem_ctx, &state,
927 struct open_socket_out_state);
928 if (result == NULL) {
929 return NULL;
930 }
931 state->ev = ev;
932 state->ss = *pss;
933 state->port = port;
934 state->wait_nsec = 10000;
935 state->salen = -1;
936
937 state->fd = socket(state->ss.ss_family, SOCK_STREAM, 0);
938 if (state->fd == -1) {
939 status = map_nt_error_from_unix(errno);
940 goto post_status;
941 }
942 talloc_set_destructor(state, open_socket_out_state_destructor);
943
944 if (!tevent_req_set_endtime(
945 result, ev, timeval_current_ofs(0, timeout*1000))) {
946 goto fail;
947 }
948
949#if defined(HAVE_IPV6)
950 if (pss->ss_family == AF_INET6) {
951 struct sockaddr_in6 *psa6;
952 psa6 = (struct sockaddr_in6 *)&state->ss;
953 psa6->sin6_port = htons(port);
954 if (psa6->sin6_scope_id == 0
955 && IN6_IS_ADDR_LINKLOCAL(&psa6->sin6_addr)) {
956 setup_linklocal_scope_id(
957 (struct sockaddr *)&(state->ss));
958 }
959 state->salen = sizeof(struct sockaddr_in6);
960 }
961#endif
962 if (pss->ss_family == AF_INET) {
963 struct sockaddr_in *psa;
964 psa = (struct sockaddr_in *)&state->ss;
965 psa->sin_port = htons(port);
966 state->salen = sizeof(struct sockaddr_in);
967 }
968
969 if (pss->ss_family == AF_UNIX) {
970 state->salen = sizeof(struct sockaddr_un);
971 }
972
973 print_sockaddr(addr, sizeof(addr), &state->ss);
974 DEBUG(3,("Connecting to %s at port %u\n", addr, (unsigned int)port));
975
976 subreq = async_connect_send(state, state->ev, state->fd,
977 (struct sockaddr *)&state->ss,
978 state->salen);
979 if ((subreq == NULL)
980 || !tevent_req_set_endtime(
981 subreq, state->ev,
982 timeval_current_ofs(0, state->wait_nsec))) {
983 goto fail;
984 }
985 tevent_req_set_callback(subreq, open_socket_out_connected, result);
986 return result;
987
988 post_status:
989 tevent_req_nterror(result, status);
990 return tevent_req_post(result, ev);
991 fail:
992 TALLOC_FREE(result);
993 return NULL;
994}
995
996static void open_socket_out_connected(struct tevent_req *subreq)
997{
998 struct tevent_req *req =
999 tevent_req_callback_data(subreq, struct tevent_req);
1000 struct open_socket_out_state *state =
1001 tevent_req_data(req, struct open_socket_out_state);
1002 int ret;
1003 int sys_errno;
1004
1005 ret = async_connect_recv(subreq, &sys_errno);
1006 TALLOC_FREE(subreq);
1007 if (ret == 0) {
1008 tevent_req_done(req);
1009 return;
1010 }
1011
1012 if (
1013#ifdef ETIMEDOUT
1014 (sys_errno == ETIMEDOUT) ||
1015#endif
1016 (sys_errno == EINPROGRESS) ||
1017 (sys_errno == EALREADY) ||
1018 (sys_errno == EAGAIN)) {
1019
1020 /*
1021 * retry
1022 */
1023
1024 if (state->wait_nsec < 250000) {
1025 state->wait_nsec *= 1.5;
1026 }
1027
1028 subreq = async_connect_send(state, state->ev, state->fd,
1029 (struct sockaddr *)&state->ss,
1030 state->salen);
1031 if (tevent_req_nomem(subreq, req)) {
1032 return;
1033 }
1034 if (!tevent_req_set_endtime(
1035 subreq, state->ev,
1036 timeval_current_ofs(0, state->wait_nsec))) {
1037 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
1038 return;
1039 }
1040 tevent_req_set_callback(subreq, open_socket_out_connected, req);
1041 return;
1042 }
1043
1044#ifdef EISCONN
1045 if (sys_errno == EISCONN) {
1046 tevent_req_done(req);
1047 return;
1048 }
1049#endif
1050
1051 /* real error */
1052 tevent_req_nterror(req, map_nt_error_from_unix(sys_errno));
1053}
1054
1055NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd)
1056{
1057 struct open_socket_out_state *state =
1058 tevent_req_data(req, struct open_socket_out_state);
1059 NTSTATUS status;
1060
1061 if (tevent_req_is_nterror(req, &status)) {
1062 return status;
1063 }
1064 *pfd = state->fd;
1065 state->fd = -1;
1066 return NT_STATUS_OK;
1067}
1068
1069NTSTATUS open_socket_out(const struct sockaddr_storage *pss, uint16_t port,
1070 int timeout, int *pfd)
1071{
1072 TALLOC_CTX *frame = talloc_stackframe();
1073 struct event_context *ev;
1074 struct tevent_req *req;
1075 NTSTATUS status = NT_STATUS_NO_MEMORY;
1076
1077 ev = event_context_init(frame);
1078 if (ev == NULL) {
1079 goto fail;
1080 }
1081
1082 req = open_socket_out_send(frame, ev, pss, port, timeout);
1083 if (req == NULL) {
1084 goto fail;
1085 }
1086 if (!tevent_req_poll(req, ev)) {
1087 status = NT_STATUS_INTERNAL_ERROR;
1088 goto fail;
1089 }
1090 status = open_socket_out_recv(req, pfd);
1091 fail:
1092 TALLOC_FREE(frame);
1093 return status;
1094}
1095
1096struct open_socket_out_defer_state {
1097 struct event_context *ev;
1098 struct sockaddr_storage ss;
1099 uint16_t port;
1100 int timeout;
1101 int fd;
1102};
1103
1104static void open_socket_out_defer_waited(struct tevent_req *subreq);
1105static void open_socket_out_defer_connected(struct tevent_req *subreq);
1106
1107struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
1108 struct event_context *ev,
1109 struct timeval wait_time,
1110 const struct sockaddr_storage *pss,
1111 uint16_t port,
1112 int timeout)
1113{
1114 struct tevent_req *req, *subreq;
1115 struct open_socket_out_defer_state *state;
1116
1117 req = tevent_req_create(mem_ctx, &state,
1118 struct open_socket_out_defer_state);
1119 if (req == NULL) {
1120 return NULL;
1121 }
1122 state->ev = ev;
1123 state->ss = *pss;
1124 state->port = port;
1125 state->timeout = timeout;
1126
1127 subreq = tevent_wakeup_send(
1128 state, ev,
1129 timeval_current_ofs(wait_time.tv_sec, wait_time.tv_usec));
1130 if (subreq == NULL) {
1131 goto fail;
1132 }
1133 tevent_req_set_callback(subreq, open_socket_out_defer_waited, req);
1134 return req;
1135 fail:
1136 TALLOC_FREE(req);
1137 return NULL;
1138}
1139
1140static void open_socket_out_defer_waited(struct tevent_req *subreq)
1141{
1142 struct tevent_req *req = tevent_req_callback_data(
1143 subreq, struct tevent_req);
1144 struct open_socket_out_defer_state *state = tevent_req_data(
1145 req, struct open_socket_out_defer_state);
1146 bool ret;
1147
1148 ret = tevent_wakeup_recv(subreq);
1149 TALLOC_FREE(subreq);
1150 if (!ret) {
1151 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1152 return;
1153 }
1154
1155 subreq = open_socket_out_send(state, state->ev, &state->ss,
1156 state->port, state->timeout);
1157 if (tevent_req_nomem(subreq, req)) {
1158 return;
1159 }
1160 tevent_req_set_callback(subreq, open_socket_out_defer_connected, req);
1161}
1162
1163static void open_socket_out_defer_connected(struct tevent_req *subreq)
1164{
1165 struct tevent_req *req = tevent_req_callback_data(
1166 subreq, struct tevent_req);
1167 struct open_socket_out_defer_state *state = tevent_req_data(
1168 req, struct open_socket_out_defer_state);
1169 NTSTATUS status;
1170
1171 status = open_socket_out_recv(subreq, &state->fd);
1172 TALLOC_FREE(subreq);
1173 if (!NT_STATUS_IS_OK(status)) {
1174 tevent_req_nterror(req, status);
1175 return;
1176 }
1177 tevent_req_done(req);
1178}
1179
1180NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd)
1181{
1182 struct open_socket_out_defer_state *state = tevent_req_data(
1183 req, struct open_socket_out_defer_state);
1184 NTSTATUS status;
1185
1186 if (tevent_req_is_nterror(req, &status)) {
1187 return status;
1188 }
1189 *pfd = state->fd;
1190 state->fd = -1;
1191 return NT_STATUS_OK;
1192}
1193
1194/*******************************************************************
1195 Create an outgoing TCP socket to the first addr that connects.
1196
1197 This is for simultaneous connection attempts to port 445 and 139 of a host
1198 or for simultatneous connection attempts to multiple DCs at once. We return
1199 a socket fd of the first successful connection.
1200
1201 @param[in] addrs list of Internet addresses and ports to connect to
1202 @param[in] num_addrs number of address/port pairs in the addrs list
1203 @param[in] timeout time after which we stop waiting for a socket connection
1204 to succeed, given in milliseconds
1205 @param[out] fd_index the entry in addrs which we successfully connected to
1206 @param[out] fd fd of the open and connected socket
1207 @return true on a successful connection, false if all connection attempts
1208 failed or we timed out
1209*******************************************************************/
1210
1211bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
1212 int timeout, int *fd_index, int *fd)
1213{
1214 int i, resulting_index, res;
1215 int *sockets;
1216 bool good_connect;
1217
1218 fd_set r_fds, wr_fds;
1219 struct timeval tv;
1220 int maxfd;
1221
1222 int connect_loop = 10000; /* 10 milliseconds */
1223
1224 timeout *= 1000; /* convert to microseconds */
1225
1226 sockets = SMB_MALLOC_ARRAY(int, num_addrs);
1227
1228 if (sockets == NULL)
1229 return false;
1230
1231 resulting_index = -1;
1232
1233 for (i=0; i<num_addrs; i++)
1234 sockets[i] = -1;
1235
1236 for (i=0; i<num_addrs; i++) {
1237 sockets[i] = socket(addrs[i].ss_family, SOCK_STREAM, 0);
1238 if (sockets[i] < 0)
1239 goto done;
1240 set_blocking(sockets[i], false);
1241 }
1242
1243 connect_again:
1244 good_connect = false;
1245
1246 for (i=0; i<num_addrs; i++) {
1247 const struct sockaddr * a =
1248 (const struct sockaddr *)&(addrs[i]);
1249
1250 if (sockets[i] == -1)
1251 continue;
1252
1253 if (sys_connect(sockets[i], a) == 0) {
1254 /* Rather unlikely as we are non-blocking, but it
1255 * might actually happen. */
1256 resulting_index = i;
1257 goto done;
1258 }
1259
1260 if (errno == EINPROGRESS || errno == EALREADY ||
1261#ifdef EISCONN
1262 errno == EISCONN ||
1263#endif
1264 errno == EAGAIN || errno == EINTR) {
1265 /* These are the error messages that something is
1266 progressing. */
1267 good_connect = true;
1268 } else if (errno != 0) {
1269 /* There was a direct error */
1270 close(sockets[i]);
1271 sockets[i] = -1;
1272 }
1273 }
1274
1275 if (!good_connect) {
1276 /* All of the connect's resulted in real error conditions */
1277 goto done;
1278 }
1279
1280 /* Lets see if any of the connect attempts succeeded */
1281
1282 maxfd = 0;
1283 FD_ZERO(&wr_fds);
1284 FD_ZERO(&r_fds);
1285
1286 for (i=0; i<num_addrs; i++) {
1287 if (sockets[i] == -1)
1288 continue;
1289 FD_SET(sockets[i], &wr_fds);
1290 FD_SET(sockets[i], &r_fds);
1291 if (sockets[i]>maxfd)
1292 maxfd = sockets[i];
1293 }
1294
1295 tv.tv_sec = 0;
1296 tv.tv_usec = connect_loop;
1297
1298 res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
1299
1300 if (res < 0)
1301 goto done;
1302
1303 if (res == 0)
1304 goto next_round;
1305
1306 for (i=0; i<num_addrs; i++) {
1307
1308 if (sockets[i] == -1)
1309 continue;
1310
1311 /* Stevens, Network Programming says that if there's a
1312 * successful connect, the socket is only writable. Upon an
1313 * error, it's both readable and writable. */
1314
1315 if (FD_ISSET(sockets[i], &r_fds) &&
1316 FD_ISSET(sockets[i], &wr_fds)) {
1317 /* readable and writable, so it's an error */
1318 close(sockets[i]);
1319 sockets[i] = -1;
1320 continue;
1321 }
1322
1323 if (!FD_ISSET(sockets[i], &r_fds) &&
1324 FD_ISSET(sockets[i], &wr_fds)) {
1325 /* Only writable, so it's connected */
1326 resulting_index = i;
1327 goto done;
1328 }
1329 }
1330
1331 next_round:
1332
1333 timeout -= connect_loop;
1334 if (timeout <= 0)
1335 goto done;
1336 connect_loop *= 1.5;
1337 if (connect_loop > timeout)
1338 connect_loop = timeout;
1339 goto connect_again;
1340
1341 done:
1342 for (i=0; i<num_addrs; i++) {
1343 if (i == resulting_index)
1344 continue;
1345 if (sockets[i] >= 0)
1346 close(sockets[i]);
1347 }
1348
1349 if (resulting_index >= 0) {
1350 *fd_index = resulting_index;
1351 *fd = sockets[*fd_index];
1352 set_blocking(*fd, true);
1353 }
1354
1355 free(sockets);
1356
1357 return (resulting_index >= 0);
1358}
1359/****************************************************************************
1360 Open a connected UDP socket to host on port
1361**************************************************************************/
1362
1363int open_udp_socket(const char *host, int port)
1364{
1365 struct sockaddr_storage ss;
1366 int res;
1367
1368 if (!interpret_string_addr(&ss, host, 0)) {
1369 DEBUG(10,("open_udp_socket: can't resolve name %s\n",
1370 host));
1371 return -1;
1372 }
1373
1374 res = socket(ss.ss_family, SOCK_DGRAM, 0);
1375 if (res == -1) {
1376 return -1;
1377 }
1378
1379#if defined(HAVE_IPV6)
1380 if (ss.ss_family == AF_INET6) {
1381 struct sockaddr_in6 *psa6;
1382 psa6 = (struct sockaddr_in6 *)&ss;
1383 psa6->sin6_port = htons(port);
1384 if (psa6->sin6_scope_id == 0
1385 && IN6_IS_ADDR_LINKLOCAL(&psa6->sin6_addr)) {
1386 setup_linklocal_scope_id(
1387 (struct sockaddr *)&ss);
1388 }
1389 }
1390#endif
1391 if (ss.ss_family == AF_INET) {
1392 struct sockaddr_in *psa;
1393 psa = (struct sockaddr_in *)&ss;
1394 psa->sin_port = htons(port);
1395 }
1396
1397 if (sys_connect(res,(struct sockaddr *)&ss)) {
1398 close(res);
1399 return -1;
1400 }
1401
1402 return res;
1403}
1404
1405/*******************************************************************
1406 Return the IP addr of the remote end of a socket as a string.
1407 Optionally return the struct sockaddr_storage.
1408 ******************************************************************/
1409
1410static const char *get_peer_addr_internal(int fd,
1411 char *addr_buf,
1412 size_t addr_buf_len,
1413 struct sockaddr *pss,
1414 socklen_t *plength)
1415{
1416 struct sockaddr_storage ss;
1417 socklen_t length = sizeof(ss);
1418
1419 strlcpy(addr_buf,"0.0.0.0",addr_buf_len);
1420
1421 if (fd == -1) {
1422 return addr_buf;
1423 }
1424
1425 if (pss == NULL) {
1426 pss = (struct sockaddr *)&ss;
1427 plength = &length;
1428 }
1429
1430 if (getpeername(fd, (struct sockaddr *)pss, plength) < 0) {
1431 DEBUG(0,("getpeername failed. Error was %s\n",
1432 strerror(errno) ));
1433 return addr_buf;
1434 }
1435
1436 print_sockaddr_len(addr_buf,
1437 addr_buf_len,
1438 pss,
1439 *plength);
1440 return addr_buf;
1441}
1442
1443/*******************************************************************
1444 Matchname - determine if host name matches IP address. Used to
1445 confirm a hostname lookup to prevent spoof attacks.
1446******************************************************************/
1447
1448static bool matchname(const char *remotehost,
1449 const struct sockaddr *pss,
1450 socklen_t len)
1451{
1452 struct addrinfo *res = NULL;
1453 struct addrinfo *ailist = NULL;
1454 char addr_buf[INET6_ADDRSTRLEN];
1455 bool ret = interpret_string_addr_internal(&ailist,
1456 remotehost,
1457 AI_ADDRCONFIG|AI_CANONNAME);
1458
1459 if (!ret || ailist == NULL) {
1460 DEBUG(3,("matchname: getaddrinfo failed for "
1461 "name %s [%s]\n",
1462 remotehost,
1463 gai_strerror(ret) ));
1464 return false;
1465 }
1466
1467 /*
1468 * Make sure that getaddrinfo() returns the "correct" host name.
1469 */
1470
1471 if (ailist->ai_canonname == NULL ||
1472 (!strequal(remotehost, ailist->ai_canonname) &&
1473 !strequal(remotehost, "localhost"))) {
1474 DEBUG(0,("matchname: host name/name mismatch: %s != %s\n",
1475 remotehost,
1476 ailist->ai_canonname ?
1477 ailist->ai_canonname : "(NULL)"));
1478 freeaddrinfo(ailist);
1479 return false;
1480 }
1481
1482 /* Look up the host address in the address list we just got. */
1483 for (res = ailist; res; res = res->ai_next) {
1484 if (!res->ai_addr) {
1485 continue;
1486 }
1487 if (sockaddr_equal((const struct sockaddr *)res->ai_addr,
1488 (struct sockaddr *)pss)) {
1489 freeaddrinfo(ailist);
1490 return true;
1491 }
1492 }
1493
1494 /*
1495 * The host name does not map to the original host address. Perhaps
1496 * someone has compromised a name server. More likely someone botched
1497 * it, but that could be dangerous, too.
1498 */
1499
1500 DEBUG(0,("matchname: host name/address mismatch: %s != %s\n",
1501 print_sockaddr_len(addr_buf,
1502 sizeof(addr_buf),
1503 pss,
1504 len),
1505 ailist->ai_canonname ? ailist->ai_canonname : "(NULL)"));
1506
1507 if (ailist) {
1508 freeaddrinfo(ailist);
1509 }
1510 return false;
1511}
1512
1513/*******************************************************************
1514 Deal with the singleton cache.
1515******************************************************************/
1516
1517struct name_addr_pair {
1518 struct sockaddr_storage ss;
1519 const char *name;
1520};
1521
1522/*******************************************************************
1523 Lookup a name/addr pair. Returns memory allocated from memcache.
1524******************************************************************/
1525
1526static bool lookup_nc(struct name_addr_pair *nc)
1527{
1528 DATA_BLOB tmp;
1529
1530 ZERO_STRUCTP(nc);
1531
1532 if (!memcache_lookup(
1533 NULL, SINGLETON_CACHE,
1534 data_blob_string_const_null("get_peer_name"),
1535 &tmp)) {
1536 return false;
1537 }
1538
1539 memcpy(&nc->ss, tmp.data, sizeof(nc->ss));
1540 nc->name = (const char *)tmp.data + sizeof(nc->ss);
1541 return true;
1542}
1543
1544/*******************************************************************
1545 Save a name/addr pair.
1546******************************************************************/
1547
1548static void store_nc(const struct name_addr_pair *nc)
1549{
1550 DATA_BLOB tmp;
1551 size_t namelen = strlen(nc->name);
1552
1553 tmp = data_blob(NULL, sizeof(nc->ss) + namelen + 1);
1554 if (!tmp.data) {
1555 return;
1556 }
1557 memcpy(tmp.data, &nc->ss, sizeof(nc->ss));
1558 memcpy(tmp.data+sizeof(nc->ss), nc->name, namelen+1);
1559
1560 memcache_add(NULL, SINGLETON_CACHE,
1561 data_blob_string_const_null("get_peer_name"),
1562 tmp);
1563 data_blob_free(&tmp);
1564}
1565
1566/*******************************************************************
1567 Return the DNS name of the remote end of a socket.
1568******************************************************************/
1569
1570const char *get_peer_name(int fd, bool force_lookup)
1571{
1572 struct name_addr_pair nc;
1573 char addr_buf[INET6_ADDRSTRLEN];
1574 struct sockaddr_storage ss;
1575 socklen_t length = sizeof(ss);
1576 const char *p;
1577 int ret;
1578 char name_buf[MAX_DNS_NAME_LENGTH];
1579 char tmp_name[MAX_DNS_NAME_LENGTH];
1580
1581 /* reverse lookups can be *very* expensive, and in many
1582 situations won't work because many networks don't link dhcp
1583 with dns. To avoid the delay we avoid the lookup if
1584 possible */
1585 if (!lp_hostname_lookups() && (force_lookup == false)) {
1586 length = sizeof(nc.ss);
1587 nc.name = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf),
1588 (struct sockaddr *)&nc.ss, &length);
1589 store_nc(&nc);
1590 lookup_nc(&nc);
1591 return nc.name ? nc.name : "UNKNOWN";
1592 }
1593
1594 lookup_nc(&nc);
1595
1596 memset(&ss, '\0', sizeof(ss));
1597 p = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf), (struct sockaddr *)&ss, &length);
1598
1599 /* it might be the same as the last one - save some DNS work */
1600 if (sockaddr_equal((struct sockaddr *)&ss, (struct sockaddr *)&nc.ss)) {
1601 return nc.name ? nc.name : "UNKNOWN";
1602 }
1603
1604 /* Not the same. We need to lookup. */
1605 if (fd == -1) {
1606 return "UNKNOWN";
1607 }
1608
1609 /* Look up the remote host name. */
1610 ret = sys_getnameinfo((struct sockaddr *)&ss,
1611 length,
1612 name_buf,
1613 sizeof(name_buf),
1614 NULL,
1615 0,
1616 0);
1617
1618 if (ret) {
1619 DEBUG(1,("get_peer_name: getnameinfo failed "
1620 "for %s with error %s\n",
1621 p,
1622 gai_strerror(ret)));
1623 strlcpy(name_buf, p, sizeof(name_buf));
1624 } else {
1625 if (!matchname(name_buf, (struct sockaddr *)&ss, length)) {
1626 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1627 strlcpy(name_buf,"UNKNOWN",sizeof(name_buf));
1628 }
1629 }
1630
1631 /* can't pass the same source and dest strings in when you
1632 use --enable-developer or the clobber_region() call will
1633 get you */
1634
1635 strlcpy(tmp_name, name_buf, sizeof(tmp_name));
1636 alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1637 if (strstr(name_buf,"..")) {
1638 strlcpy(name_buf, "UNKNOWN", sizeof(name_buf));
1639 }
1640
1641 nc.name = name_buf;
1642 nc.ss = ss;
1643
1644 store_nc(&nc);
1645 lookup_nc(&nc);
1646 return nc.name ? nc.name : "UNKNOWN";
1647}
1648
1649/*******************************************************************
1650 Return the IP addr of the remote end of a socket as a string.
1651 ******************************************************************/
1652
1653const char *get_peer_addr(int fd, char *addr, size_t addr_len)
1654{
1655 return get_peer_addr_internal(fd, addr, addr_len, NULL, NULL);
1656}
1657
1658/*******************************************************************
1659 Create protected unix domain socket.
1660
1661 Some unixes cannot set permissions on a ux-dom-sock, so we
1662 have to make sure that the directory contains the protection
1663 permissions instead.
1664 ******************************************************************/
1665
1666int create_pipe_sock(const char *socket_dir,
1667 const char *socket_name,
1668 mode_t dir_perms)
1669{
1670#ifdef HAVE_UNIXSOCKET
1671 struct sockaddr_un sunaddr;
1672 struct stat st;
1673 int sock;
1674 mode_t old_umask;
1675 char *path = NULL;
1676
1677 old_umask = umask(0);
1678
1679 /* Create the socket directory or reuse the existing one */
1680
1681 if (lstat(socket_dir, &st) == -1) {
1682 if (errno == ENOENT) {
1683 /* Create directory */
1684 if (mkdir(socket_dir, dir_perms) == -1) {
1685 DEBUG(0, ("error creating socket directory "
1686 "%s: %s\n", socket_dir,
1687 strerror(errno)));
1688 goto out_umask;
1689 }
1690 } else {
1691 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1692 socket_dir, strerror(errno)));
1693 goto out_umask;
1694 }
1695 } else {
1696 /* Check ownership and permission on existing directory */
1697 if (!S_ISDIR(st.st_mode)) {
1698 DEBUG(0, ("socket directory %s isn't a directory\n",
1699 socket_dir));
1700 goto out_umask;
1701 }
1702 if ((st.st_uid != sec_initial_uid()) ||
1703 ((st.st_mode & 0777) != dir_perms)) {
1704 DEBUG(0, ("invalid permissions on socket directory "
1705 "%s\n", socket_dir));
1706 goto out_umask;
1707 }
1708 }
1709
1710 /* Create the socket file */
1711
1712 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1713
1714 if (sock == -1) {
1715 DEBUG(0, ("create_pipe_sock: socket error %s\n",
1716 strerror(errno) ));
1717 goto out_close;
1718 }
1719
1720 if (asprintf(&path, "%s/%s", socket_dir, socket_name) == -1) {
1721 goto out_close;
1722 }
1723
1724 unlink(path);
1725 memset(&sunaddr, 0, sizeof(sunaddr));
1726 sunaddr.sun_family = AF_UNIX;
1727 strlcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path));
1728
1729 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1730 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1731 strerror(errno)));
1732 goto out_close;
1733 }
1734
1735 if (listen(sock, 5) == -1) {
1736 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1737 strerror(errno)));
1738 goto out_close;
1739 }
1740
1741 SAFE_FREE(path);
1742
1743 umask(old_umask);
1744 return sock;
1745
1746out_close:
1747 SAFE_FREE(path);
1748 if (sock != -1)
1749 close(sock);
1750
1751out_umask:
1752 umask(old_umask);
1753 return -1;
1754
1755#else
1756 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1757 return -1;
1758#endif /* HAVE_UNIXSOCKET */
1759}
1760
1761/****************************************************************************
1762 Get my own canonical name, including domain.
1763****************************************************************************/
1764
1765const char *get_mydnsfullname(void)
1766{
1767 struct addrinfo *res = NULL;
1768 char my_hostname[HOST_NAME_MAX];
1769 bool ret;
1770 DATA_BLOB tmp;
1771
1772 if (memcache_lookup(NULL, SINGLETON_CACHE,
1773 data_blob_string_const_null("get_mydnsfullname"),
1774 &tmp)) {
1775 SMB_ASSERT(tmp.length > 0);
1776 return (const char *)tmp.data;
1777 }
1778
1779 /* get my host name */
1780 if (gethostname(my_hostname, sizeof(my_hostname)) == -1) {
1781 DEBUG(0,("get_mydnsfullname: gethostname failed\n"));
1782 return NULL;
1783 }
1784
1785 /* Ensure null termination. */
1786 my_hostname[sizeof(my_hostname)-1] = '\0';
1787
1788 ret = interpret_string_addr_internal(&res,
1789 my_hostname,
1790 AI_ADDRCONFIG|AI_CANONNAME);
1791
1792 if (!ret || res == NULL) {
1793 DEBUG(3,("get_mydnsfullname: getaddrinfo failed for "
1794 "name %s [%s]\n",
1795 my_hostname,
1796 gai_strerror(ret) ));
1797 return NULL;
1798 }
1799
1800 /*
1801 * Make sure that getaddrinfo() returns the "correct" host name.
1802 */
1803
1804 if (res->ai_canonname == NULL) {
1805 DEBUG(3,("get_mydnsfullname: failed to get "
1806 "canonical name for %s\n",
1807 my_hostname));
1808 freeaddrinfo(res);
1809 return NULL;
1810 }
1811
1812 /* This copies the data, so we must do a lookup
1813 * afterwards to find the value to return.
1814 */
1815
1816 memcache_add(NULL, SINGLETON_CACHE,
1817 data_blob_string_const_null("get_mydnsfullname"),
1818 data_blob_string_const_null(res->ai_canonname));
1819
1820 if (!memcache_lookup(NULL, SINGLETON_CACHE,
1821 data_blob_string_const_null("get_mydnsfullname"),
1822 &tmp)) {
1823 tmp = data_blob_talloc(talloc_tos(), res->ai_canonname,
1824 strlen(res->ai_canonname) + 1);
1825 }
1826
1827 freeaddrinfo(res);
1828
1829 return (const char *)tmp.data;
1830}
1831
1832/************************************************************
1833 Is this my name ?
1834************************************************************/
1835
1836bool is_myname_or_ipaddr(const char *s)
1837{
1838 TALLOC_CTX *ctx = talloc_tos();
1839 char addr[INET6_ADDRSTRLEN];
1840 char *name = NULL;
1841 const char *dnsname;
1842 char *servername = NULL;
1843
1844 if (!s) {
1845 return false;
1846 }
1847
1848 /* Santize the string from '\\name' */
1849 name = talloc_strdup(ctx, s);
1850 if (!name) {
1851 return false;
1852 }
1853
1854 servername = strrchr_m(name, '\\' );
1855 if (!servername) {
1856 servername = name;
1857 } else {
1858 servername++;
1859 }
1860
1861 /* Optimize for the common case */
1862 if (strequal(servername, global_myname())) {
1863 return true;
1864 }
1865
1866 /* Check for an alias */
1867 if (is_myname(servername)) {
1868 return true;
1869 }
1870
1871 /* Check for loopback */
1872 if (strequal(servername, "127.0.0.1") ||
1873 strequal(servername, "::1")) {
1874 return true;
1875 }
1876
1877 if (strequal(servername, "localhost")) {
1878 return true;
1879 }
1880
1881 /* Maybe it's my dns name */
1882 dnsname = get_mydnsfullname();
1883 if (dnsname && strequal(servername, dnsname)) {
1884 return true;
1885 }
1886
1887 /* Handle possible CNAME records - convert to an IP addr. */
1888 if (!is_ipaddress(servername)) {
1889 /* Use DNS to resolve the name, but only the first address */
1890 struct sockaddr_storage ss;
1891 if (interpret_string_addr(&ss, servername, 0)) {
1892 print_sockaddr(addr,
1893 sizeof(addr),
1894 &ss);
1895 servername = addr;
1896 }
1897 }
1898
1899 /* Maybe its an IP address? */
1900 if (is_ipaddress(servername)) {
1901 struct sockaddr_storage ss;
1902 struct iface_struct *nics;
1903 int i, n;
1904
1905 if (!interpret_string_addr(&ss, servername, AI_NUMERICHOST)) {
1906 return false;
1907 }
1908
1909 if (ismyaddr((struct sockaddr *)&ss)) {
1910 return true;
1911 }
1912
1913 if (is_zero_addr((struct sockaddr *)&ss) ||
1914 is_loopback_addr((struct sockaddr *)&ss)) {
1915 return false;
1916 }
1917
1918 n = get_interfaces(talloc_tos(), &nics);
1919 for (i=0; i<n; i++) {
1920 if (sockaddr_equal((struct sockaddr *)&nics[i].ip, (struct sockaddr *)&ss)) {
1921 TALLOC_FREE(nics);
1922 return true;
1923 }
1924 }
1925 TALLOC_FREE(nics);
1926 }
1927
1928 /* No match */
1929 return false;
1930}
1931
1932struct getaddrinfo_state {
1933 const char *node;
1934 const char *service;
1935 const struct addrinfo *hints;
1936 struct addrinfo *res;
1937 int ret;
1938};
1939
1940static void getaddrinfo_do(void *private_data);
1941static void getaddrinfo_done(struct tevent_req *subreq);
1942
1943struct tevent_req *getaddrinfo_send(TALLOC_CTX *mem_ctx,
1944 struct tevent_context *ev,
1945 struct fncall_context *ctx,
1946 const char *node,
1947 const char *service,
1948 const struct addrinfo *hints)
1949{
1950 struct tevent_req *req, *subreq;
1951 struct getaddrinfo_state *state;
1952
1953 req = tevent_req_create(mem_ctx, &state, struct getaddrinfo_state);
1954 if (req == NULL) {
1955 return NULL;
1956 }
1957
1958 state->node = node;
1959 state->service = service;
1960 state->hints = hints;
1961
1962 subreq = fncall_send(state, ev, ctx, getaddrinfo_do, state);
1963 if (tevent_req_nomem(subreq, req)) {
1964 return tevent_req_post(req, ev);
1965 }
1966 tevent_req_set_callback(subreq, getaddrinfo_done, req);
1967 return req;
1968}
1969
1970static void getaddrinfo_do(void *private_data)
1971{
1972 struct getaddrinfo_state *state =
1973 (struct getaddrinfo_state *)private_data;
1974
1975 state->ret = getaddrinfo(state->node, state->service, state->hints,
1976 &state->res);
1977}
1978
1979static void getaddrinfo_done(struct tevent_req *subreq)
1980{
1981 struct tevent_req *req = tevent_req_callback_data(
1982 subreq, struct tevent_req);
1983 int ret, err;
1984
1985 ret = fncall_recv(subreq, &err);
1986 TALLOC_FREE(subreq);
1987 if (ret == -1) {
1988 tevent_req_error(req, err);
1989 return;
1990 }
1991 tevent_req_done(req);
1992}
1993
1994int getaddrinfo_recv(struct tevent_req *req, struct addrinfo **res)
1995{
1996 struct getaddrinfo_state *state = tevent_req_data(
1997 req, struct getaddrinfo_state);
1998 int err;
1999
2000 if (tevent_req_is_unix_error(req, &err)) {
2001 switch(err) {
2002 case ENOMEM:
2003 return EAI_MEMORY;
2004 default:
2005 return EAI_FAIL;
2006 }
2007 }
2008 if (state->ret == 0) {
2009 *res = state->res;
2010 }
2011 return state->ret;
2012}
Note: See TracBrowser for help on using the repository browser.