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