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