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