source3/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_m(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   {
 498 #ifdef WITH_SSL
 499     if(fd == sslFd){
 500       ret = SSL_write(ssl,buffer + total,N - total);
 501     }else{
 502       ret = write(fd,buffer + total,N - total);
 503     }
 504 #else /* WITH_SSL */
 505     ret = write(fd,buffer + total,N - total);
 506 #endif /* WITH_SSL */
 507
 508     if (ret == -1) {
 509       DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
 510       return -1;
 511     }
 512     if (ret == 0) return total;
 513
 514     total += ret;
 515   }
 516   return (ssize_t)total;
 517 }
 518
 519 /****************************************************************************
 520  Write data to a socket - use send rather than write.
 521 ****************************************************************************/
 522
 523 ssize_t write_socket_data(int fd,char *buffer,size_t N)
 524 {
 525   size_t total=0;
 526   ssize_t ret;
 527
 528   while (total < N)
 529   {
 530 #ifdef WITH_SSL
 531     if(fd == sslFd){
 532       ret = SSL_write(ssl,buffer + total,N - total);
 533     }else{
 534       ret = send(fd,buffer + total,N - total, 0);
 535     }
 536 #else /* WITH_SSL */
 537     ret = send(fd,buffer + total,N - total,0);
 538 #endif /* WITH_SSL */
 539
 540     if (ret == -1) {
 541       DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
 542       return -1;
 543     }
 544     if (ret == 0) return total;
 545
 546     total += ret;
 547   }
 548   return (ssize_t)total;
 549 }
 550
 551 /****************************************************************************
 552 write to a socket
 553 ****************************************************************************/
 554
 555 ssize_t write_socket(int fd,char *buf,size_t len)
 556 {
 557   ssize_t ret=0;
 558
 559   DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
 560   ret = write_socket_data(fd,buf,len);
 561
 562   DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
 563   if(ret <= 0)
 564     DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
 565        (int)len, fd, strerror(errno) ));
 566
 567   return(ret);
 568 }
 569
 570 /****************************************************************************
 571 read 4 bytes of a smb packet and return the smb length of the packet
 572 store the result in the buffer
 573 This version of the function will return a length of zero on receiving
 574 a keepalive packet.
 575 timeout is in milliseconds.
 576 ****************************************************************************/
 577
 578 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
 579 {
 580   ssize_t len=0;
 581   int msg_type;
 582   BOOL ok = False;
 583
 584   while (!ok)
 585   {
 586     if (timeout > 0)
 587       ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
 588     else
 589       ok = (read_socket_data(fd,inbuf,4) == 4);
 590
 591     if (!ok)
 592       return(-1);
 593
 594     len = smb_len(inbuf);
 595     msg_type = CVAL(inbuf,0);
 596
 597     if (msg_type == 0x85)
 598       DEBUG(5,("Got keepalive packet\n"));
 599   }
 600
 601   DEBUG(10,("got smb length of %d\n",len));
 602
 603   return(len);
 604 }
 605
 606 /****************************************************************************
 607 read 4 bytes of a smb packet and return the smb length of the packet
 608 store the result in the buffer. This version of the function will
 609 never return a session keepalive (length of zero).
 610 timeout is in milliseconds.
 611 ****************************************************************************/
 612
 613 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
 614 {
 615   ssize_t len;
 616
 617   for(;;)
 618   {
 619     len = read_smb_length_return_keepalive(fd, inbuf, timeout);
 620
 621     if(len < 0)
 622       return len;
 623
 624     /* Ignore session keepalives. */
 625     if(CVAL(inbuf,0) != 0x85)
 626       break;
 627   }
 628
 629   DEBUG(10,("read_smb_length: got smb length of %d\n",len));
 630
 631   return len;
 632 }
 633
 634 /****************************************************************************
 635   read an smb from a fd. Note that the buffer *MUST* be of size
 636   BUFFER_SIZE+SAFETY_MARGIN.
 637   The timeout is in milliseconds.
 638   This function will return on a
 639   receipt of a session keepalive packet.
 640 ****************************************************************************/
 641
 642 BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
 643 {
 644         ssize_t len,ret;
 645
 646         smb_read_error = 0;
 647
 648         memset(buffer,'\0',smb_size + 100);
 649
 650         len = read_smb_length_return_keepalive(fd,buffer,timeout);
 651         if (len < 0) {
 652                 DEBUG(10,("receive_smb: length < 0!\n"));
 653                 return(False);
 654         }
 655
 656         /*
 657          * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
 658      * of header. Don't print the error if this fits.... JRA.
 659          */
 660
 661         if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
 662                 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
 663                 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
 664                         smb_read_error = READ_ERROR;
 665                         return False;
 666                 }
 667         }
 668
 669         if(len > 0) {
 670                 ret = read_socket_data(fd,buffer+4,len);
 671                 if (ret != len) {
 672                         smb_read_error = READ_ERROR;
 673                         return False;
 674                 }
 675         }
 676
 677         return(True);
 678 }
 679
 680 /****************************************************************************
 681   read an smb from a fd ignoring all keepalive packets. Note that the buffer
 682   *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
 683   The timeout is in milliseconds
 684
 685   This is exactly the same as receive_smb except that it never returns
 686   a session keepalive packet (just as receive_smb used to do).
 687   receive_smb was changed to return keepalives as the oplock processing means this call
 688   should never go into a blocking read.
 689 ****************************************************************************/
 690
 691 BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
 692 {
 693   BOOL ret;
 694
 695   for(;;)
 696   {
 697     ret = receive_smb(fd, buffer, timeout);
 698
 699     if (!ret)
 700     {
 701       DEBUG(10,("client_receive_smb failed\n"));
 702       show_msg(buffer);
 703       return ret;
 704     }
 705
 706     /* Ignore session keepalive packets. */
 707     if(CVAL(buffer,0) != 0x85)
 708       break;
 709   }
 710   show_msg(buffer);
 711   return ret;
 712 }
 713
 714 /****************************************************************************
 715   send an smb to a fd
 716 ****************************************************************************/
 717
 718 BOOL send_smb(int fd,char *buffer)
 719 {
 720         size_t len;
 721         size_t nwritten=0;
 722         ssize_t ret;
 723         len = smb_len(buffer) + 4;
 724
 725         while (nwritten < len) {
 726                 ret = write_socket(fd,buffer+nwritten,len - nwritten);
 727                 if (ret <= 0) {
 728                         DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
 729                                 (int)len,(int)ret, strerror(errno) ));
 730                         return False;
 731                 }
 732                 nwritten += ret;
 733         }
 734
 735         return True;
 736 }
 737
 738 /****************************************************************************
 739 send a single packet to a port on another machine
 740 ****************************************************************************/
 741
 742 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
 743 {
 744   BOOL ret;
 745   int out_fd;
 746   struct sockaddr_in sock_out;
 747
 748   /* create a socket to write to */
 749   out_fd = socket(AF_INET, type, 0);
 750   if (out_fd == -1)
 751     {
 752       DEBUG(0,("socket failed"));
 753       return False;
 754     }
 755
 756   /* set the address and port */
 757   memset((char *)&sock_out,'\0',sizeof(sock_out));
 758   putip((char *)&sock_out.sin_addr,(char *)&ip);
 759   sock_out.sin_port = htons( port );
 760   sock_out.sin_family = AF_INET;
 761
 762   if (DEBUGLEVEL > 0)
 763     DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
 764              len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
 765
 766   /* send it */
 767   ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
 768
 769   if (!ret)
 770     DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
 771              inet_ntoa(ip),port,strerror(errno)));
 772
 773   close(out_fd);
 774   return(ret);
 775 }
 776
 777 /****************************************************************************
 778  Open a socket of the specified type, port, and address for incoming data.
 779 ****************************************************************************/
 780
 781 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
 782 {
 783         struct sockaddr_in sock;
 784         int res;
 785
 786         memset( (char *)&sock, '\0', sizeof(sock) );
 787
 788 #ifdef HAVE_SOCK_SIN_LEN
 789         sock.sin_len         = sizeof(sock);
 790 #endif
 791         sock.sin_port        = htons( port );
 792         sock.sin_family      = AF_INET;
 793         sock.sin_addr.s_addr = socket_addr;
 794
 795         res = socket( AF_INET, type, 0 );
 796         if( res == -1 ) {
 797                 if( DEBUGLVL(0) ) {
 798                         dbgtext( "open_socket_in(): socket() call failed: " );
 799                         dbgtext( "%s\n", strerror( errno ) );
 800                 }
 801                 return -1;
 802         }
 803
 804         /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
 805         {
 806                 int val = rebind ? 1 : 0;
 807                 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
 808                         if( DEBUGLVL( dlevel ) ) {
 809                                 dbgtext( "open_socket_in(): setsockopt: " );
 810                                 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
 811                                 dbgtext( "on port %d failed ", port );
 812                                 dbgtext( "with error = %s\n", strerror(errno) );
 813                         }
 814                 }
 815 #ifdef SO_REUSEPORT
 816                 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
 817                         if( DEBUGLVL( dlevel ) ) {
 818                                 dbgtext( "open_socket_in(): setsockopt: ");
 819                                 dbgtext( "SO_REUSEPORT = %d ", val?"True":"False" );
 820                                 dbgtext( "on port %d failed ", port );
 821                                 dbgtext( "with error = %s\n", strerror(errno) );
 822                         }
 823                 }
 824 #endif /* SO_REUSEPORT */
 825         }
 826
 827         /* now we've got a socket - we need to bind it */
 828         if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
 829                 if( DEBUGLVL(dlevel) && (port == SMB_PORT || port == NMB_PORT) ) {
 830                         dbgtext( "bind failed on port %d ", port );
 831                         dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
 832                         dbgtext( "Error = %s\n", strerror(errno) );
 833                 }
 834                 close( res );
 835                 return( -1 );
 836         }
 837
 838         DEBUG( 3, ( "bind succeeded on port %d\n", port ) );
 839
 840         return( res );
 841  }
 842
 843 /****************************************************************************
 844   create an outgoing socket. timeout is in milliseconds.
 845   **************************************************************************/
 846
 847 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
 848 {
 849   struct sockaddr_in sock_out;
 850   int res,ret;
 851   int connect_loop = 250; /* 250 milliseconds */
 852   int loops = (timeout) / connect_loop;
 853
 854   /* create a socket to write to */
 855   res = socket(PF_INET, type, 0);
 856   if (res == -1)
 857     { DEBUG(0,("socket error\n")); return -1; }
 858
 859   if (type != SOCK_STREAM) return(res);
 860
 861   memset((char *)&sock_out,'\0',sizeof(sock_out));
 862   putip((char *)&sock_out.sin_addr,(char *)addr);
 863
 864   sock_out.sin_port = htons( port );
 865   sock_out.sin_family = PF_INET;
 866
 867   /* set it non-blocking */
 868   set_blocking(res,False);
 869
 870   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
 871
 872   /* and connect it to the destination */
 873 connect_again:
 874   ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
 875
 876   /* Some systems return EAGAIN when they mean EINPROGRESS */
 877   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 878         errno == EAGAIN) && loops--) {
 879     msleep(connect_loop);
 880     goto connect_again;
 881   }
 882
 883   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 884          errno == EAGAIN)) {
 885       DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
 886       close(res);
 887       return -1;
 888   }
 889
 890 #ifdef EISCONN
 891   if (ret < 0 && errno == EISCONN) {
 892     errno = 0;
 893     ret = 0;
 894   }
 895 #endif
 896
 897   if (ret < 0) {
 898     DEBUG(2,("error connecting to %s:%d (%s)\n",
 899              inet_ntoa(*addr),port,strerror(errno)));
 900     close(res);
 901     return -1;
 902   }
 903
 904   /* set it blocking again */
 905   set_blocking(res,True);
 906
 907   return res;
 908 }
 909
 910 /* the following 3 client_*() functions are nasty ways of allowing
 911    some generic functions to get info that really should be hidden in
 912    particular modules */
 913 static int client_fd = -1;
 914
 915 void client_setfd(int fd)
 916 {
 917         client_fd = fd;
 918 }
 919
 920 char *client_name(void)
 921 {
 922         return get_socket_name(client_fd);
 923 }
 924
 925 char *client_addr(void)
 926 {
 927         return get_socket_addr(client_fd);
 928 }
 929
 930 /*******************************************************************
 931  matchname - determine if host name matches IP address. Used to
 932  confirm a hostname lookup to prevent spoof attacks
 933  ******************************************************************/
 934 static BOOL matchname(char *remotehost,struct in_addr  addr)
 935 {
 936         struct hostent *hp;
 937         int     i;
 938
 939         if ((hp = sys_gethostbyname(remotehost)) == 0) {
 940                 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
 941                 return False;
 942         }
 943
 944         /*
 945          * Make sure that gethostbyname() returns the "correct" host name.
 946          * Unfortunately, gethostbyname("localhost") sometimes yields
 947          * "localhost.domain". Since the latter host name comes from the
 948          * local DNS, we just have to trust it (all bets are off if the local
 949          * DNS is perverted). We always check the address list, though.
 950          */
 951
 952         if (strcasecmp(remotehost, hp->h_name)
 953             && strcasecmp(remotehost, "localhost")) {
 954                 DEBUG(0,("host name/name mismatch: %s != %s\n",
 955                          remotehost, hp->h_name));
 956                 return False;
 957         }
 958
 959         /* Look up the host address in the address list we just got. */
 960         for (i = 0; hp->h_addr_list[i]; i++) {
 961                 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
 962                         return True;
 963         }
 964
 965         /*
 966          * The host name does not map to the original host address. Perhaps
 967          * someone has compromised a name server. More likely someone botched
 968          * it, but that could be dangerous, too.
 969          */
 970
 971         DEBUG(0,("host name/address mismatch: %s != %s\n",
 972                  inet_ntoa(addr), hp->h_name));
 973         return False;
 974 }
 975
 976
 977 /*******************************************************************
 978  return the DNS name of the remote end of a socket
 979  ******************************************************************/
 980 char *get_socket_name(int fd)
 981 {
 982         static pstring name_buf;
 983         static fstring addr_buf;
 984         struct hostent *hp;
 985         struct in_addr addr;
 986         char *p;
 987
 988         /* reverse lookups can be *very* expensive, and in many
 989            situations won't work because many networks don't link dhcp
 990            with dns. To avoid the delay we avoid the lookup if
 991            possible */
 992         if (!lp_hostname_lookups()) {
 993                 return get_socket_addr(fd);
 994         }
 995
 996         p = get_socket_addr(fd);
 997
 998         /* it might be the same as the last one - save some DNS work */
 999         if (strcmp(p, addr_buf) == 0) return name_buf;
1000
1001         pstrcpy(name_buf,"UNKNOWN");
1002         if (fd == -1) return name_buf;
1003
1004         fstrcpy(addr_buf, p);
1005
1006         addr = *interpret_addr2(p);
1007
1008         /* Look up the remote host name. */
1009         if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1010                 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1011                 pstrcpy(name_buf, p);
1012         } else {
1013                 pstrcpy(name_buf,(char *)hp->h_name);
1014                 if (!matchname(name_buf, addr)) {
1015                         DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1016                         pstrcpy(name_buf,"UNKNOWN");
1017                 }
1018         }
1019
1020         alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
1021         if (strstr(name_buf,"..")) {
1022                 pstrcpy(name_buf, "UNKNOWN");
1023         }
1024
1025         return name_buf;
1026 }
1027
1028 /*******************************************************************
1029  return the IP addr of the remote end of a socket as a string
1030  ******************************************************************/
1031 char *get_socket_addr(int fd)
1032 {
1033         struct sockaddr sa;
1034         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1035         int     length = sizeof(sa);
1036         static fstring addr_buf;
1037
1038         fstrcpy(addr_buf,"0.0.0.0");
1039
1040         if (fd == -1) {
1041                 return addr_buf;
1042         }
1043
1044         if (getpeername(fd, &sa, &length) < 0) {
1045                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1046                 return addr_buf;
1047         }
1048
1049         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1050
1051         return addr_buf;
1052 }
1053
1054 /*******************************************************************
1055  opens and connects to a unix pipe socket
1056  ******************************************************************/
1057 int open_pipe_sock(char *path)
1058 {
1059         int sock;
1060         struct sockaddr_un sa;
1061
1062         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1063
1064         if (sock < 0)
1065         {
1066                 DEBUG(0, ("unix socket open failed\n"));
1067                 return sock;
1068         }
1069
1070         ZERO_STRUCT(sa);
1071         sa.sun_family = AF_UNIX;
1072         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1073
1074         DEBUG(10, ("socket open succeeded.  file name: %s\n", sa.sun_path));
1075
1076         if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1077         {
1078                 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1079                 close(sock);
1080                 return -1;
1081         }
1082
1083         return sock;
1084 }
1085
1086 int create_pipe_socket(char *dir, int dir_perms,
1087                                 char *path, int path_perms)
1088 {
1089         int s;
1090         struct sockaddr_un sa;
1091
1092         DEBUG(0,("create_pipe_socket: %s %d %s %d\n",
1093                    dir, dir_perms, path, path_perms));
1094
1095         DEBUG(0,("*** RACE CONDITION.  PLEASE SOMEONE EXAMINE create_pipe_Socket AND FIX IT ***\n"));
1096
1097         mkdir(dir, dir_perms);
1098
1099         if (chmod(dir, dir_perms) < 0)
1100         {
1101                 DEBUG(0, ("chmod on %s failed\n", dir));
1102                 return -1;
1103         }
1104
1105         if (!remove(path))
1106         {
1107                 DEBUG(0, ("remove on %s failed\n", path));
1108         }
1109
1110         /* start listening on unix socket */
1111         s = socket(AF_UNIX, SOCK_STREAM, 0);
1112
1113         if (s < 0)
1114         {
1115                 DEBUG(0, ("socket open failed\n"));
1116                 return -1;
1117         }
1118
1119         ZERO_STRUCT(sa);
1120         sa.sun_family = AF_UNIX;
1121         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1122
1123         if (bind(s, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1124         {
1125                 DEBUG(0, ("socket bind to %s failed\n", sa.sun_path));
1126                 close(s);
1127                 remove(path);
1128                 return -1;
1129         }
1130
1131         if (s == -1)
1132         {
1133                 DEBUG(0,("bind failed\n"));
1134                 remove(path);
1135                 return -1;
1136         }
1137
1138         if (path_perms != 0)
1139         {
1140                 chmod(path, path_perms);
1141         }
1142
1143         if (listen(s, 5) == -1)
1144         {
1145                 DEBUG(0,("listen failed\n"));
1146                 return -1;
1147         }
1148
1149         DEBUG(5,("unix socket opened: %s\n", path));
1150
1151         return s;
1152 }
1153
1154 /*******************************************************************
1155 this is like socketpair but uses tcp. It is used by the Samba
1156 regression test code
1157 The function guarantees that nobody else can attach to the socket,
1158 or if they do that this function fails and the socket gets closed
1159 returns 0 on success, -1 on failure
1160 the resulting file descriptors are symmetrical
1161  ******************************************************************/
1162 static int socketpair_tcp(int fd[2])
1163 {
1164         int listener;
1165         struct sockaddr_in sock;
1166         struct sockaddr_in sock2;
1167         socklen_t socklen = sizeof(sock);
1168         int connect_done = 0;
1169
1170         fd[0] = fd[1] = listener = -1;
1171
1172         memset(&sock, 0, sizeof(sock));
1173
1174         if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1175
1176         memset(&sock2, 0, sizeof(sock2));
1177 #ifdef HAVE_SOCK_SIN_LEN
1178         sock2.sin_len = sizeof(sock2);
1179 #endif
1180         sock2.sin_family = PF_INET;
1181
1182         bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1183
1184         if (listen(listener, 1) != 0) goto failed;
1185
1186         if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1187
1188         if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1189
1190         set_blocking(fd[1], 0);
1191
1192         sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1193
1194         if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1195                 if (errno != EINPROGRESS) goto failed;
1196         } else {
1197                 connect_done = 1;
1198         }
1199
1200         if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1201
1202         close(listener);
1203         if (connect_done == 0) {
1204                 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1205                     && errno != EISCONN) goto failed;
1206         }
1207
1208         set_blocking(fd[1], 1);
1209
1210         /* all OK! */
1211         return 0;
1212
1213  failed:
1214         if (fd[0] != -1) close(fd[0]);
1215         if (fd[1] != -1) close(fd[1]);
1216         if (listener != -1) close(listener);
1217         return -1;
1218 }
1219
1220
1221 /*******************************************************************
1222 run a program on a local tcp socket, this is used to launch smbd
1223 when regression testing
1224 the return value is a socket which is attached to a subprocess
1225 running "prog". stdin and stdout are attached. stderr is left
1226 attached to the original stderr
1227  ******************************************************************/
1228 int sock_exec(const char *prog)
1229 {
1230         int fd[2];
1231         if (socketpair_tcp(fd) != 0) {
1232                 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));
1233                 return -1;
1234         }
1235         if (fork() == 0) {
1236                 close(fd[0]);
1237                 close(0);
1238                 close(1);
1239                 dup(fd[1]);
1240                 dup(fd[1]);
1241                 exit(system(prog));
1242         }
1243         close(fd[1]);
1244         return fd[0];
1245 }
1246