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