source3/lib/util_sock.c

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