source/lib/util_sock.c

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