source/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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /* the last IP received from */
  25 struct in_addr lastip;
  26
  27 /* the last port received from */
  28 int lastport=0;
  29
  30 int smb_read_error = 0;
  31
  32 static char *get_socket_addr(int fd)
  33 {
  34         struct sockaddr sa;
  35         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
  36         socklen_t length = sizeof(sa);
  37         static fstring addr_buf;
  38
  39         fstrcpy(addr_buf,"0.0.0.0");
  40
  41         if (fd == -1) {
  42                 return addr_buf;
  43         }
  44
  45         if (getsockname(fd, &sa, &length) < 0) {
  46                 DEBUG(0,("getsockname failed. Error was %s\n", strerror(errno) ));
  47                 return addr_buf;
  48         }
  49
  50         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
  51
  52         return addr_buf;
  53 }
  54
  55 static int get_socket_port(int fd)
  56 {
  57         struct sockaddr sa;
  58         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
  59         socklen_t length = sizeof(sa);
  60
  61         if (fd == -1)
  62                 return -1;
  63
  64         if (getsockname(fd, &sa, &length) < 0) {
  65                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
  66                 return -1;
  67         }
  68
  69         return ntohs(sockin->sin_port);
  70 }
  71
  72 /****************************************************************************
  73  Determine if a file descriptor is in fact a socket.
  74 ****************************************************************************/
  75
  76 BOOL is_a_socket(int fd)
  77 {
  78         int v;
  79         socklen_t l;
  80         l = sizeof(int);
  81         return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
  82 }
  83
  84 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
  85
  86 typedef struct smb_socket_option {
  87         const char *name;
  88         int level;
  89         int option;
  90         int value;
  91         int opttype;
  92 } smb_socket_option;
  93
  94 static const smb_socket_option socket_options[] = {
  95   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
  96   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
  97   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
  98 #ifdef TCP_NODELAY
  99   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
 100 #endif
 101 #ifdef TCP_KEEPCNT
 102   {"TCP_KEEPCNT",       IPPROTO_TCP,   TCP_KEEPCNT,     0,                 OPT_INT},
 103 #endif
 104 #ifdef TCP_KEEPIDLE
 105   {"TCP_KEEPIDLE",      IPPROTO_TCP,   TCP_KEEPIDLE,    0,                 OPT_INT},
 106 #endif
 107 #ifdef TCP_KEEPINTVL
 108   {"TCP_KEEPINTVL",     IPPROTO_TCP,   TCP_KEEPINTVL,   0,                 OPT_INT},
 109 #endif
 110 #ifdef IPTOS_LOWDELAY
 111   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
 112 #endif
 113 #ifdef IPTOS_THROUGHPUT
 114   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
 115 #endif
 116 #ifdef SO_REUSEPORT
 117   {"SO_REUSEPORT",      SOL_SOCKET,    SO_REUSEPORT,    0,                 OPT_BOOL},
 118 #endif
 119 #ifdef SO_SNDBUF
 120   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
 121 #endif
 122 #ifdef SO_RCVBUF
 123   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
 124 #endif
 125 #ifdef SO_SNDLOWAT
 126   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
 127 #endif
 128 #ifdef SO_RCVLOWAT
 129   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
 130 #endif
 131 #ifdef SO_SNDTIMEO
 132   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
 133 #endif
 134 #ifdef SO_RCVTIMEO
 135   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
 136 #endif
 137   {NULL,0,0,0,0}};
 138
 139 /****************************************************************************
 140  Print socket options.
 141 ****************************************************************************/
 142
 143 static void print_socket_options(int s)
 144 {
 145         int value;
 146         socklen_t vlen = 4;
 147         const smb_socket_option *p = &socket_options[0];
 148
 149         /* wrapped in if statement to prevent streams leak in SCO Openserver 5.0 */
 150         /* reported on samba-technical  --jerry */
 151         if ( DEBUGLEVEL >= 5 ) {
 152         for (; p->name != NULL; p++) {
 153                 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
 154                         DEBUG(5,("Could not test socket option %s.\n", p->name));
 155                 } else {
 156                         DEBUG(5,("socket option %s = %d\n",p->name,value));
 157                         }
 158                 }
 159         }
 160  }
 161
 162 /****************************************************************************
 163  Set user socket options.
 164 ****************************************************************************/
 165
 166 void set_socket_options(int fd, const char *options)
 167 {
 168         fstring tok;
 169
 170         while (next_token(&options,tok," \t,", sizeof(tok))) {
 171                 int ret=0,i;
 172                 int value = 1;
 173                 char *p;
 174                 BOOL got_value = False;
 175
 176                 if ((p = strchr_m(tok,'='))) {
 177                         *p = 0;
 178                         value = atoi(p+1);
 179                         got_value = True;
 180                 }
 181
 182                 for (i=0;socket_options[i].name;i++)
 183                         if (strequal(socket_options[i].name,tok))
 184                                 break;
 185
 186                 if (!socket_options[i].name) {
 187                         DEBUG(0,("Unknown socket option %s\n",tok));
 188                         continue;
 189                 }
 190
 191                 switch (socket_options[i].opttype) {
 192                 case OPT_BOOL:
 193                 case OPT_INT:
 194                         ret = setsockopt(fd,socket_options[i].level,
 195                                                 socket_options[i].option,(char *)&value,sizeof(int));
 196                         break;
 197
 198                 case OPT_ON:
 199                         if (got_value)
 200                                 DEBUG(0,("syntax error - %s does not take a value\n",tok));
 201
 202                         {
 203                                 int on = socket_options[i].value;
 204                                 ret = setsockopt(fd,socket_options[i].level,
 205                                                         socket_options[i].option,(char *)&on,sizeof(int));
 206                         }
 207                         break;
 208                 }
 209
 210                 if (ret != 0)
 211                         DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
 212         }
 213
 214         print_socket_options(fd);
 215 }
 216
 217 /****************************************************************************
 218  Read from a socket.
 219 ****************************************************************************/
 220
 221 ssize_t read_udp_socket(int fd,char *buf,size_t len)
 222 {
 223         ssize_t ret;
 224         struct sockaddr_in sock;
 225         socklen_t socklen = sizeof(sock);
 226
 227         memset((char *)&sock,'\0',socklen);
 228         memset((char *)&lastip,'\0',sizeof(lastip));
 229         ret = (ssize_t)sys_recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
 230         if (ret <= 0) {
 231                 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
 232                 return(0);
 233         }
 234
 235         lastip = sock.sin_addr;
 236         lastport = ntohs(sock.sin_port);
 237
 238         DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %lu\n",
 239                         inet_ntoa(lastip), lastport, (unsigned long)ret));
 240
 241         return(ret);
 242 }
 243
 244 /****************************************************************************
 245  Read data from a socket with a timout in msec.
 246  mincount = if timeout, minimum to read before returning
 247  maxcount = number to be read.
 248  time_out = timeout in milliseconds
 249 ****************************************************************************/
 250
 251 ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
 252 {
 253         fd_set fds;
 254         int selrtn;
 255         ssize_t readret;
 256         size_t nread = 0;
 257         struct timeval timeout;
 258
 259         /* just checking .... */
 260         if (maxcnt <= 0)
 261                 return(0);
 262
 263         smb_read_error = 0;
 264
 265         /* Blocking read */
 266         if (time_out <= 0) {
 267                 if (mincnt == 0) mincnt = maxcnt;
 268
 269                 while (nread < mincnt) {
 270                         readret = sys_read(fd, buf + nread, maxcnt - nread);
 271
 272                         if (readret == 0) {
 273                                 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
 274                                 smb_read_error = READ_EOF;
 275                                 return -1;
 276                         }
 277
 278                         if (readret == -1) {
 279                                 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
 280                                 smb_read_error = READ_ERROR;
 281                                 return -1;
 282                         }
 283                         nread += readret;
 284                 }
 285                 return((ssize_t)nread);
 286         }
 287
 288         /* Most difficult - timeout read */
 289         /* If this is ever called on a disk file and
 290            mincnt is greater then the filesize then
 291            system performance will suffer severely as
 292            select always returns true on disk files */
 293
 294         /* Set initial timeout */
 295         timeout.tv_sec = (time_t)(time_out / 1000);
 296         timeout.tv_usec = (long)(1000 * (time_out % 1000));
 297
 298         for (nread=0; nread < mincnt; ) {
 299                 FD_ZERO(&fds);
 300                 FD_SET(fd,&fds);
 301
 302                 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
 303
 304                 /* Check if error */
 305                 if (selrtn == -1) {
 306                         /* something is wrong. Maybe the socket is dead? */
 307                         DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
 308                         smb_read_error = READ_ERROR;
 309                         return -1;
 310                 }
 311
 312                 /* Did we timeout ? */
 313                 if (selrtn == 0) {
 314                         DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
 315                         smb_read_error = READ_TIMEOUT;
 316                         return -1;
 317                 }
 318
 319                 readret = sys_read(fd, buf+nread, maxcnt-nread);
 320
 321                 if (readret == 0) {
 322                         /* we got EOF on the file descriptor */
 323                         DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
 324                         smb_read_error = READ_EOF;
 325                         return -1;
 326                 }
 327
 328                 if (readret == -1) {
 329                         /* the descriptor is probably dead */
 330                         DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
 331                         smb_read_error = READ_ERROR;
 332                         return -1;
 333                 }
 334
 335                 nread += readret;
 336         }
 337
 338         /* Return the number we got */
 339         return (ssize_t)nread;
 340 }
 341
 342 /****************************************************************************
 343  Read data from the client, reading exactly N bytes.
 344 ****************************************************************************/
 345
 346 ssize_t read_data(int fd,char *buffer,size_t N)
 347 {
 348         ssize_t ret;
 349         size_t total=0;
 350
 351         smb_read_error = 0;
 352
 353         while (total < N) {
 354                 ret = sys_read(fd,buffer + total,N - total);
 355
 356                 if (ret == 0) {
 357                         DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
 358                         smb_read_error = READ_EOF;
 359                         return 0;
 360                 }
 361
 362                 if (ret == -1) {
 363                         DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
 364                         smb_read_error = READ_ERROR;
 365                         return -1;
 366                 }
 367                 total += ret;
 368         }
 369         return (ssize_t)total;
 370 }
 371
 372 /****************************************************************************
 373  Read data from a socket, reading exactly N bytes.
 374 ****************************************************************************/
 375
 376 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
 377 {
 378         ssize_t ret;
 379         size_t total=0;
 380
 381         smb_read_error = 0;
 382
 383         while (total < N) {
 384                 ret = sys_read(fd,buffer + total,N - total);
 385
 386                 if (ret == 0) {
 387                         DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
 388                         smb_read_error = READ_EOF;
 389                         return 0;
 390                 }
 391
 392                 if (ret == -1) {
 393                         DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
 394                         smb_read_error = READ_ERROR;
 395                         return -1;
 396                 }
 397                 total += ret;
 398         }
 399         return (ssize_t)total;
 400 }
 401
 402 /****************************************************************************
 403  Write data to a fd.
 404 ****************************************************************************/
 405
 406 ssize_t write_data(int fd, const char *buffer, size_t N)
 407 {
 408         size_t total=0;
 409         ssize_t ret;
 410
 411         while (total < N) {
 412                 ret = sys_write(fd,buffer + total,N - total);
 413
 414                 if (ret == -1) {
 415                         DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
 416                         return -1;
 417                 }
 418                 if (ret == 0)
 419                         return total;
 420
 421                 total += ret;
 422         }
 423         return (ssize_t)total;
 424 }
 425
 426 /****************************************************************************
 427  Write data to a socket - use send rather than write.
 428 ****************************************************************************/
 429
 430 static ssize_t write_socket_data(int fd, const char *buffer, size_t N)
 431 {
 432         size_t total=0;
 433         ssize_t ret;
 434
 435         while (total < N) {
 436                 ret = sys_send(fd,buffer + total,N - total,0);
 437
 438                 if (ret == -1) {
 439                         DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
 440                         return -1;
 441                 }
 442                 if (ret == 0)
 443                         return total;
 444
 445                 total += ret;
 446         }
 447         return (ssize_t)total;
 448 }
 449
 450 /****************************************************************************
 451  Write to a socket.
 452 ****************************************************************************/
 453
 454 ssize_t write_socket(int fd, const char *buf, size_t len)
 455 {
 456         ssize_t ret=0;
 457
 458         DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
 459         ret = write_socket_data(fd,buf,len);
 460
 461         DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
 462         if(ret <= 0)
 463                 DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
 464                         (int)len, fd, strerror(errno) ));
 465
 466         return(ret);
 467 }
 468
 469 /****************************************************************************
 470  Send a keepalive packet (rfc1002).
 471 ****************************************************************************/
 472
 473 BOOL send_keepalive(int client)
 474 {
 475         unsigned char buf[4];
 476
 477         buf[0] = SMBkeepalive;
 478         buf[1] = buf[2] = buf[3] = 0;
 479
 480         return(write_socket_data(client,(char *)buf,4) == 4);
 481 }
 482
 483
 484 /****************************************************************************
 485  Read 4 bytes of a smb packet and return the smb length of the packet.
 486  Store the result in the buffer.
 487  This version of the function will return a length of zero on receiving
 488  a keepalive packet.
 489  Timeout is in milliseconds.
 490 ****************************************************************************/
 491
 492 static ssize_t read_smb_length_return_keepalive(int fd, char *inbuf, unsigned int timeout)
 493 {
 494         ssize_t len=0;
 495         int msg_type;
 496         BOOL ok = False;
 497
 498         while (!ok) {
 499                 if (timeout > 0)
 500                         ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
 501                 else
 502                         ok = (read_socket_data(fd,inbuf,4) == 4);
 503
 504                 if (!ok)
 505                         return(-1);
 506
 507                 len = smb_len(inbuf);
 508                 msg_type = CVAL(inbuf,0);
 509
 510                 if (msg_type == SMBkeepalive)
 511                         DEBUG(5,("Got keepalive packet\n"));
 512         }
 513
 514         DEBUG(10,("got smb length of %lu\n",(unsigned long)len));
 515
 516         return(len);
 517 }
 518
 519 /****************************************************************************
 520  Read 4 bytes of a smb packet and return the smb length of the packet.
 521  Store the result in the buffer. This version of the function will
 522  never return a session keepalive (length of zero).
 523  Timeout is in milliseconds.
 524 ****************************************************************************/
 525
 526 ssize_t read_smb_length(int fd, char *inbuf, unsigned int timeout)
 527 {
 528         ssize_t len;
 529
 530         for(;;) {
 531                 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
 532
 533                 if(len < 0)
 534                         return len;
 535
 536                 /* Ignore session keepalives. */
 537                 if(CVAL(inbuf,0) != SMBkeepalive)
 538                         break;
 539         }
 540
 541         DEBUG(10,("read_smb_length: got smb length of %lu\n",
 542                   (unsigned long)len));
 543
 544         return len;
 545 }
 546
 547 /****************************************************************************
 548  Read an smb from a fd. Note that the buffer *MUST* be of size
 549  BUFFER_SIZE+SAFETY_MARGIN.
 550  The timeout is in milliseconds.
 551  This function will return on receipt of a session keepalive packet.
 552  Doesn't check the MAC on signed packets.
 553 ****************************************************************************/
 554
 555 BOOL receive_smb_raw(int fd, char *buffer, unsigned int timeout)
 556 {
 557         ssize_t len,ret;
 558
 559         smb_read_error = 0;
 560
 561         memset(buffer,'\0',smb_size + 100);
 562
 563         len = read_smb_length_return_keepalive(fd,buffer,timeout);
 564         if (len < 0) {
 565                 DEBUG(10,("receive_smb_raw: length < 0!\n"));
 566
 567                 /*
 568                  * Correct fix. smb_read_error may have already been
 569                  * set. Only set it here if not already set. Global
 570                  * variables still suck :-). JRA.
 571                  */
 572
 573                 if (smb_read_error == 0)
 574                         smb_read_error = READ_ERROR;
 575                 return False;
 576         }
 577
 578         /*
 579          * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
 580          * of header. Don't print the error if this fits.... JRA.
 581          */
 582
 583         if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
 584                 DEBUG(0,("Invalid packet length! (%lu bytes).\n",(unsigned long)len));
 585                 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
 586
 587                         /*
 588                          * Correct fix. smb_read_error may have already been
 589                          * set. Only set it here if not already set. Global
 590                          * variables still suck :-). JRA.
 591                          */
 592
 593                         if (smb_read_error == 0)
 594                                 smb_read_error = READ_ERROR;
 595                         return False;
 596                 }
 597         }
 598
 599         if(len > 0) {
 600                 if (timeout > 0) {
 601                         ret = read_socket_with_timeout(fd,buffer+4,len,len,timeout);
 602                 } else {
 603                         ret = read_socket_data(fd,buffer+4,len);
 604                 }
 605
 606                 if (ret != len) {
 607                         if (smb_read_error == 0)
 608                                 smb_read_error = READ_ERROR;
 609                         return False;
 610                 }
 611
 612                 /* not all of samba3 properly checks for packet-termination of strings. This
 613                    ensures that we don't run off into empty space. */
 614                 SSVAL(buffer+4,len, 0);
 615         }
 616
 617         return True;
 618 }
 619
 620 /****************************************************************************
 621  Wrapper for receive_smb_raw().
 622  Checks the MAC on signed packets.
 623 ****************************************************************************/
 624
 625 BOOL receive_smb(int fd, char *buffer, unsigned int timeout)
 626 {
 627         if (!receive_smb_raw(fd, buffer, timeout)) {
 628                 return False;
 629         }
 630
 631         /* Check the incoming SMB signature. */
 632         if (!srv_check_sign_mac(buffer, True)) {
 633                 DEBUG(0, ("receive_smb: SMB Signature verification failed on incoming packet!\n"));
 634                 if (smb_read_error == 0)
 635                         smb_read_error = READ_BAD_SIG;
 636                 return False;
 637         };
 638
 639         return(True);
 640 }
 641
 642 /****************************************************************************
 643  Send an smb to a fd.
 644 ****************************************************************************/
 645
 646 BOOL send_smb(int fd, char *buffer)
 647 {
 648         size_t len;
 649         size_t nwritten=0;
 650         ssize_t ret;
 651
 652         /* Sign the outgoing packet if required. */
 653         srv_calculate_sign_mac(buffer);
 654
 655         len = smb_len(buffer) + 4;
 656
 657         while (nwritten < len) {
 658                 ret = write_socket(fd,buffer+nwritten,len - nwritten);
 659                 if (ret <= 0) {
 660                         DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
 661                                 (int)len,(int)ret, strerror(errno) ));
 662                         return False;
 663                 }
 664                 nwritten += ret;
 665         }
 666
 667         return True;
 668 }
 669
 670 /****************************************************************************
 671  Open a socket of the specified type, port, and address for incoming data.
 672 ****************************************************************************/
 673
 674 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
 675 {
 676         struct sockaddr_in sock;
 677         int res;
 678
 679         memset( (char *)&sock, '\0', sizeof(sock) );
 680
 681 #ifdef HAVE_SOCK_SIN_LEN
 682         sock.sin_len         = sizeof(sock);
 683 #endif
 684         sock.sin_port        = htons( port );
 685         sock.sin_family      = AF_INET;
 686         sock.sin_addr.s_addr = socket_addr;
 687
 688         res = socket( AF_INET, type, 0 );
 689         if( res == -1 ) {
 690                 if( DEBUGLVL(0) ) {
 691                         dbgtext( "open_socket_in(): socket() call failed: " );
 692                         dbgtext( "%s\n", strerror( errno ) );
 693                 }
 694                 return -1;
 695         }
 696
 697         /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
 698         {
 699                 int val = rebind ? 1 : 0;
 700                 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
 701                         if( DEBUGLVL( dlevel ) ) {
 702                                 dbgtext( "open_socket_in(): setsockopt: " );
 703                                 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
 704                                 dbgtext( "on port %d failed ", port );
 705                                 dbgtext( "with error = %s\n", strerror(errno) );
 706                         }
 707                 }
 708 #ifdef SO_REUSEPORT
 709                 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
 710                         if( DEBUGLVL( dlevel ) ) {
 711                                 dbgtext( "open_socket_in(): setsockopt: ");
 712                                 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
 713                                 dbgtext( "on port %d failed ", port );
 714                                 dbgtext( "with error = %s\n", strerror(errno) );
 715                         }
 716                 }
 717 #endif /* SO_REUSEPORT */
 718         }
 719
 720         /* now we've got a socket - we need to bind it */
 721         if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
 722                 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 || port == SMB_PORT2 || port == NMB_PORT) ) {
 723                         dbgtext( "bind failed on port %d ", port );
 724                         dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
 725                         dbgtext( "Error = %s\n", strerror(errno) );
 726                 }
 727                 close( res );
 728                 return( -1 );
 729         }
 730
 731         DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
 732
 733         return( res );
 734  }
 735
 736 /****************************************************************************
 737  Create an outgoing socket. timeout is in milliseconds.
 738 **************************************************************************/
 739
 740 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
 741 {
 742         struct sockaddr_in sock_out;
 743         int res,ret;
 744         int connect_loop = 10;
 745         int increment = 10;
 746
 747         /* create a socket to write to */
 748         res = socket(PF_INET, type, 0);
 749         if (res == -1) {
 750                 DEBUG(0,("socket error (%s)\n", strerror(errno)));
 751                 return -1;
 752         }
 753
 754         if (type != SOCK_STREAM)
 755                 return(res);
 756
 757         memset((char *)&sock_out,'\0',sizeof(sock_out));
 758         putip((char *)&sock_out.sin_addr,(char *)addr);
 759
 760         sock_out.sin_port = htons( port );
 761         sock_out.sin_family = PF_INET;
 762
 763         /* set it non-blocking */
 764         set_blocking(res,False);
 765
 766         DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
 767
 768         /* and connect it to the destination */
 769   connect_again:
 770
 771         ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
 772
 773         /* Some systems return EAGAIN when they mean EINPROGRESS */
 774         if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 775                         errno == EAGAIN) && (connect_loop < timeout) ) {
 776                 smb_msleep(connect_loop);
 777                 timeout -= connect_loop;
 778                 connect_loop += increment;
 779                 if (increment < 250) {
 780                         /* After 8 rounds we end up at a max of 255 msec */
 781                         increment *= 1.5;
 782                 }
 783                 goto connect_again;
 784         }
 785
 786         if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 787                         errno == EAGAIN)) {
 788                 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
 789                 close(res);
 790                 return -1;
 791         }
 792
 793 #ifdef EISCONN
 794
 795         if (ret < 0 && errno == EISCONN) {
 796                 errno = 0;
 797                 ret = 0;
 798         }
 799 #endif
 800
 801         if (ret < 0) {
 802                 DEBUG(2,("error connecting to %s:%d (%s)\n",
 803                                 inet_ntoa(*addr),port,strerror(errno)));
 804                 close(res);
 805                 return -1;
 806         }
 807
 808         /* set it blocking again */
 809         set_blocking(res,True);
 810
 811         return res;
 812 }
 813
 814 /****************************************************************************
 815  Create an outgoing TCP socket to any of the addrs. This is for
 816  simultaneous connects to port 445 and 139 of a host or even a variety
 817  of DC's all of which are equivalent for our purposes.
 818 **************************************************************************/
 819
 820 BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs,
 821                          int timeout, int *fd_index, int *fd)
 822 {
 823         int i, resulting_index, res;
 824         int *sockets;
 825         BOOL good_connect;
 826
 827         fd_set r_fds, wr_fds;
 828         struct timeval tv;
 829         int maxfd;
 830
 831         int connect_loop = 10000; /* 10 milliseconds */
 832
 833         timeout *= 1000;        /* convert to microseconds */
 834
 835         sockets = SMB_MALLOC_ARRAY(int, num_addrs);
 836
 837         if (sockets == NULL)
 838                 return False;
 839
 840         resulting_index = -1;
 841
 842         for (i=0; i<num_addrs; i++)
 843                 sockets[i] = -1;
 844
 845         for (i=0; i<num_addrs; i++) {
 846                 sockets[i] = socket(PF_INET, SOCK_STREAM, 0);
 847                 if (sockets[i] < 0)
 848                         goto done;
 849                 set_blocking(sockets[i], False);
 850         }
 851
 852  connect_again:
 853         good_connect = False;
 854
 855         for (i=0; i<num_addrs; i++) {
 856
 857                 if (sockets[i] == -1)
 858                         continue;
 859
 860                 if (connect(sockets[i], (struct sockaddr *)&(addrs[i]),
 861                             sizeof(*addrs)) == 0) {
 862                         /* Rather unlikely as we are non-blocking, but it
 863                          * might actually happen. */
 864                         resulting_index = i;
 865                         goto done;
 866                 }
 867
 868                 if (errno == EINPROGRESS || errno == EALREADY ||
 869                     errno == EAGAIN) {
 870                         /* These are the error messages that something is
 871                            progressing. */
 872                         good_connect = True;
 873                 } else if (errno != 0) {
 874                         /* There was a direct error */
 875                         close(sockets[i]);
 876                         sockets[i] = -1;
 877                 }
 878         }
 879
 880         if (!good_connect) {
 881                 /* All of the connect's resulted in real error conditions */
 882                 goto done;
 883         }
 884
 885         /* Lets see if any of the connect attempts succeeded */
 886
 887         maxfd = 0;
 888         FD_ZERO(&wr_fds);
 889         FD_ZERO(&r_fds);
 890
 891         for (i=0; i<num_addrs; i++) {
 892                 if (sockets[i] == -1)
 893                         continue;
 894                 FD_SET(sockets[i], &wr_fds);
 895                 FD_SET(sockets[i], &r_fds);
 896                 if (sockets[i]>maxfd)
 897                         maxfd = sockets[i];
 898         }
 899
 900         tv.tv_sec = 0;
 901         tv.tv_usec = connect_loop;
 902
 903         res = sys_select(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
 904
 905         if (res < 0)
 906                 goto done;
 907
 908         if (res == 0)
 909                 goto next_round;
 910
 911         for (i=0; i<num_addrs; i++) {
 912
 913                 if (sockets[i] == -1)
 914                         continue;
 915
 916                 /* Stevens, Network Programming says that if there's a
 917                  * successful connect, the socket is only writable. Upon an
 918                  * error, it's both readable and writable. */
 919
 920                 if (FD_ISSET(sockets[i], &r_fds) &&
 921                     FD_ISSET(sockets[i], &wr_fds)) {
 922                         /* readable and writable, so it's an error */
 923                         close(sockets[i]);
 924                         sockets[i] = -1;
 925                         continue;
 926                 }
 927
 928                 if (!FD_ISSET(sockets[i], &r_fds) &&
 929                     FD_ISSET(sockets[i], &wr_fds)) {
 930                         /* Only writable, so it's connected */
 931                         resulting_index = i;
 932                         goto done;
 933                 }
 934         }
 935
 936  next_round:
 937
 938         timeout -= connect_loop;
 939         if (timeout <= 0)
 940                 goto done;
 941         connect_loop *= 1.5;
 942         if (connect_loop > timeout)
 943                 connect_loop = timeout;
 944         goto connect_again;
 945
 946  done:
 947         for (i=0; i<num_addrs; i++) {
 948                 if (i == resulting_index)
 949                         continue;
 950                 if (sockets[i] >= 0)
 951                         close(sockets[i]);
 952         }
 953
 954         if (resulting_index >= 0) {
 955                 *fd_index = resulting_index;
 956                 *fd = sockets[*fd_index];
 957                 set_blocking(*fd, True);
 958         }
 959
 960         free(sockets);
 961
 962         return (resulting_index >= 0);
 963 }
 964 /****************************************************************************
 965  Open a connected UDP socket to host on port
 966 **************************************************************************/
 967
 968 int open_udp_socket(const char *host, int port)
 969 {
 970         int type = SOCK_DGRAM;
 971         struct sockaddr_in sock_out;
 972         int res;
 973         struct in_addr *addr;
 974
 975         addr = interpret_addr2(host);
 976
 977         res = socket(PF_INET, type, 0);
 978         if (res == -1) {
 979                 return -1;
 980         }
 981
 982         memset((char *)&sock_out,'\0',sizeof(sock_out));
 983         putip((char *)&sock_out.sin_addr,(char *)addr);
 984         sock_out.sin_port = htons(port);
 985         sock_out.sin_family = PF_INET;
 986
 987         if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
 988                 close(res);
 989                 return -1;
 990         }
 991
 992         return res;
 993 }
 994
 995
 996 /* the following 3 client_*() functions are nasty ways of allowing
 997    some generic functions to get info that really should be hidden in
 998    particular modules */
 999 static int client_fd = -1;
1000
1001 void client_setfd(int fd)
1002 {
1003         client_fd = fd;
1004 }
1005
1006 char *client_name(void)
1007 {
1008         return get_peer_name(client_fd,False);
1009 }
1010
1011 char *client_addr(void)
1012 {
1013         return get_peer_addr(client_fd);
1014 }
1015
1016 char *client_socket_addr(void)
1017 {
1018         return get_socket_addr(client_fd);
1019 }
1020
1021 int client_socket_port(void)
1022 {
1023         return get_socket_port(client_fd);
1024 }
1025
1026 struct in_addr *client_inaddr(struct sockaddr *sa)
1027 {
1028         struct sockaddr_in *sockin = (struct sockaddr_in *) (sa);
1029         socklen_t  length = sizeof(*sa);
1030
1031         if (getpeername(client_fd, sa, &length) < 0) {
1032                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1033                 return NULL;
1034         }
1035
1036         return &sockin->sin_addr;
1037 }
1038
1039 /*******************************************************************
1040  Matchname - determine if host name matches IP address. Used to
1041  confirm a hostname lookup to prevent spoof attacks.
1042 ******************************************************************/
1043
1044 static BOOL matchname(char *remotehost,struct in_addr  addr)
1045 {
1046         struct hostent *hp;
1047         int     i;
1048
1049         if ((hp = sys_gethostbyname(remotehost)) == 0) {
1050                 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
1051                 return False;
1052         }
1053
1054         /*
1055          * Make sure that gethostbyname() returns the "correct" host name.
1056          * Unfortunately, gethostbyname("localhost") sometimes yields
1057          * "localhost.domain". Since the latter host name comes from the
1058          * local DNS, we just have to trust it (all bets are off if the local
1059          * DNS is perverted). We always check the address list, though.
1060          */
1061
1062         if (!strequal(remotehost, hp->h_name)
1063             && !strequal(remotehost, "localhost")) {
1064                 DEBUG(0,("host name/name mismatch: %s != %s\n",
1065                          remotehost, hp->h_name));
1066                 return False;
1067         }
1068
1069         /* Look up the host address in the address list we just got. */
1070         for (i = 0; hp->h_addr_list[i]; i++) {
1071                 if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
1072                         return True;
1073         }
1074
1075         /*
1076          * The host name does not map to the original host address. Perhaps
1077          * someone has compromised a name server. More likely someone botched
1078          * it, but that could be dangerous, too.
1079          */
1080
1081         DEBUG(0,("host name/address mismatch: %s != %s\n",
1082                  inet_ntoa(addr), hp->h_name));
1083         return False;
1084 }
1085
1086 /*******************************************************************
1087  Return the DNS name of the remote end of a socket.
1088 ******************************************************************/
1089
1090 char *get_peer_name(int fd, BOOL force_lookup)
1091 {
1092         static pstring name_buf;
1093         pstring tmp_name;
1094         static fstring addr_buf;
1095         struct hostent *hp;
1096         struct in_addr addr;
1097         char *p;
1098
1099         /* reverse lookups can be *very* expensive, and in many
1100            situations won't work because many networks don't link dhcp
1101            with dns. To avoid the delay we avoid the lookup if
1102            possible */
1103         if (!lp_hostname_lookups() && (force_lookup == False)) {
1104                 return get_peer_addr(fd);
1105         }
1106
1107         p = get_peer_addr(fd);
1108
1109         /* it might be the same as the last one - save some DNS work */
1110         if (strcmp(p, addr_buf) == 0)
1111                 return name_buf;
1112
1113         pstrcpy(name_buf,"UNKNOWN");
1114         if (fd == -1)
1115                 return name_buf;
1116
1117         fstrcpy(addr_buf, p);
1118
1119         addr = *interpret_addr2(p);
1120
1121         /* Look up the remote host name. */
1122         if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1123                 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1124                 pstrcpy(name_buf, p);
1125         } else {
1126                 pstrcpy(name_buf,(char *)hp->h_name);
1127                 if (!matchname(name_buf, addr)) {
1128                         DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1129                         pstrcpy(name_buf,"UNKNOWN");
1130                 }
1131         }
1132
1133         /* can't pass the same source and dest strings in when you
1134            use --enable-developer or the clobber_region() call will
1135            get you */
1136
1137         pstrcpy( tmp_name, name_buf );
1138         alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1139         if (strstr(name_buf,"..")) {
1140                 pstrcpy(name_buf, "UNKNOWN");
1141         }
1142
1143         return name_buf;
1144 }
1145
1146 /*******************************************************************
1147  Return the IP addr of the remote end of a socket as a string.
1148  ******************************************************************/
1149
1150 char *get_peer_addr(int fd)
1151 {
1152         struct sockaddr sa;
1153         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1154         socklen_t length = sizeof(sa);
1155         static fstring addr_buf;
1156
1157         fstrcpy(addr_buf,"0.0.0.0");
1158
1159         if (fd == -1) {
1160                 return addr_buf;
1161         }
1162
1163         if (getpeername(fd, &sa, &length) < 0) {
1164                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1165                 return addr_buf;
1166         }
1167
1168         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1169
1170         return addr_buf;
1171 }
1172
1173 /*******************************************************************
1174  Create protected unix domain socket.
1175
1176  Some unixes cannot set permissions on a ux-dom-sock, so we
1177  have to make sure that the directory contains the protection
1178  permissions instead.
1179  ******************************************************************/
1180
1181 int create_pipe_sock(const char *socket_dir,
1182                      const char *socket_name,
1183                      mode_t dir_perms)
1184 {
1185 #ifdef HAVE_UNIXSOCKET
1186         struct sockaddr_un sunaddr;
1187         struct stat st;
1188         int sock;
1189         mode_t old_umask;
1190         pstring path;
1191
1192         old_umask = umask(0);
1193
1194         /* Create the socket directory or reuse the existing one */
1195
1196         if (lstat(socket_dir, &st) == -1) {
1197                 if (errno == ENOENT) {
1198                         /* Create directory */
1199                         if (mkdir(socket_dir, dir_perms) == -1) {
1200                                 DEBUG(0, ("error creating socket directory "
1201                                         "%s: %s\n", socket_dir,
1202                                         strerror(errno)));
1203                                 goto out_umask;
1204                         }
1205                 } else {
1206                         DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1207                                 socket_dir, strerror(errno)));
1208                         goto out_umask;
1209                 }
1210         } else {
1211                 /* Check ownership and permission on existing directory */
1212                 if (!S_ISDIR(st.st_mode)) {
1213                         DEBUG(0, ("socket directory %s isn't a directory\n",
1214                                 socket_dir));
1215                         goto out_umask;
1216                 }
1217                 if ((st.st_uid != sec_initial_uid()) ||
1218                                 ((st.st_mode & 0777) != dir_perms)) {
1219                         DEBUG(0, ("invalid permissions on socket directory "
1220                                 "%s\n", socket_dir));
1221                         goto out_umask;
1222                 }
1223         }
1224
1225         /* Create the socket file */
1226
1227         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1228
1229         if (sock == -1) {
1230                 perror("socket");
1231                 goto out_umask;
1232         }
1233
1234         pstr_sprintf(path, "%s/%s", socket_dir, socket_name);
1235
1236         unlink(path);
1237         memset(&sunaddr, 0, sizeof(sunaddr));
1238         sunaddr.sun_family = AF_UNIX;
1239         safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1240
1241         if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1242                 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1243                         strerror(errno)));
1244                 goto out_close;
1245         }
1246
1247         if (listen(sock, 5) == -1) {
1248                 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1249                         strerror(errno)));
1250                 goto out_close;
1251         }
1252
1253         umask(old_umask);
1254         return sock;
1255
1256 out_close:
1257         close(sock);
1258
1259 out_umask:
1260         umask(old_umask);
1261         return -1;
1262
1263 #else
1264         DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1265         return -1;
1266 #endif /* HAVE_UNIXSOCKET */
1267 }