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