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 <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   res = socket(AF_INET, type, 0);
 795   if (res == -1)
 796     { DEBUG(0,("socket failed\n")); return -1; }
 797
 798   {
 799     int val=1;
 800         if(rebind)
 801                 val=1;
 802         else
 803                 val=0;
 804     if(setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1)
 805                 DEBUG(dlevel,("setsockopt: SO_REUSEADDR=%d on port %d failed with error = %s\n",
 806                         val, port, strerror(errno) ));
 807 #ifdef SO_REUSEPORT
 808     if(setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1)
 809                 DEBUG(dlevel,("setsockopt: SO_REUSEPORT=%d on port %d failed with error = %s\n",
 810                         val, port, strerror(errno) ));
 811 #endif /* SO_REUSEPORT */
 812   }
 813
 814   /* now we've got a socket - we need to bind it */
 815   if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)
 816     {
 817       if (port) {
 818         if (port == SMB_PORT || port == NMB_PORT)
 819           DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",
 820                         port,inet_ntoa(sock.sin_addr),strerror(errno)));
 821         close(res);
 822
 823         if (dlevel > 0 && port < 1000)
 824           port = 7999;
 825
 826         if (port >= 1000 && port < 9000)
 827           return(open_socket_in(type,port+1,dlevel,socket_addr,rebind));
 828       }
 829
 830       return(-1);
 831     }
 832   DEBUG(3,("bind succeeded on port %d\n",port));
 833
 834   return res;
 835 }
 836
 837 /****************************************************************************
 838   create an outgoing socket. timeout is in milliseconds.
 839   **************************************************************************/
 840
 841 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
 842 {
 843   struct sockaddr_in sock_out;
 844   int res,ret;
 845   int connect_loop = 250; /* 250 milliseconds */
 846   int loops = (timeout) / connect_loop;
 847
 848   /* create a socket to write to */
 849   res = socket(PF_INET, type, 0);
 850   if (res == -1)
 851     { DEBUG(0,("socket error\n")); return -1; }
 852
 853   if (type != SOCK_STREAM) return(res);
 854
 855   memset((char *)&sock_out,'\0',sizeof(sock_out));
 856   putip((char *)&sock_out.sin_addr,(char *)addr);
 857
 858   sock_out.sin_port = htons( port );
 859   sock_out.sin_family = PF_INET;
 860
 861   /* set it non-blocking */
 862   set_blocking(res,False);
 863
 864   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
 865
 866   /* and connect it to the destination */
 867 connect_again:
 868   ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
 869
 870   /* Some systems return EAGAIN when they mean EINPROGRESS */
 871   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 872         errno == EAGAIN) && loops--) {
 873     msleep(connect_loop);
 874     goto connect_again;
 875   }
 876
 877   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
 878          errno == EAGAIN)) {
 879       DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
 880       close(res);
 881       return -1;
 882   }
 883
 884 #ifdef EISCONN
 885   if (ret < 0 && errno == EISCONN) {
 886     errno = 0;
 887     ret = 0;
 888   }
 889 #endif
 890
 891   if (ret < 0) {
 892     DEBUG(2,("error connecting to %s:%d (%s)\n",
 893              inet_ntoa(*addr),port,strerror(errno)));
 894     close(res);
 895     return -1;
 896   }
 897
 898   /* set it blocking again */
 899   set_blocking(res,True);
 900
 901   return res;
 902 }
 903
 904 /* the following 3 client_*() functions are nasty ways of allowing
 905    some generic functions to get info that really should be hidden in
 906    particular modules */
 907 static int client_fd = -1;
 908
 909 void client_setfd(int fd)
 910 {
 911         client_fd = fd;
 912 }
 913
 914 char *client_name(void)
 915 {
 916         return get_socket_name(client_fd);
 917 }
 918
 919 char *client_addr(void)
 920 {
 921         return get_socket_addr(client_fd);
 922 }
 923
 924 /*******************************************************************
 925  matchname - determine if host name matches IP address. Used to
 926  confirm a hostname lookup to prevent spoof attacks
 927  ******************************************************************/
 928 static BOOL matchname(char *remotehost,struct in_addr  addr)
 929 {
 930         struct hostent *hp;
 931         int     i;
 932
 933         if ((hp = sys_gethostbyname(remotehost)) == 0) {
 934                 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
 935                 return False;
 936         }
 937
 938         /*
 939          * Make sure that gethostbyname() returns the "correct" host name.
 940          * Unfortunately, gethostbyname("localhost") sometimes yields
 941          * "localhost.domain". Since the latter host name comes from the
 942          * local DNS, we just have to trust it (all bets are off if the local
 943          * DNS is perverted). We always check the address list, though.
 944          */
 945
 946         if (strcasecmp(remotehost, hp->h_name)
 947             && strcasecmp(remotehost, "localhost")) {
 948                 DEBUG(0,("host name/name mismatch: %s != %s\n",
 949                          remotehost, hp->h_name));
 950                 return False;
 951         }
 952
 953         /* Look up the host address in the address list we just got. */
 954         for (i = 0; hp->h_addr_list[i]; i++) {
 955                 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
 956                         return True;
 957         }
 958
 959         /*
 960          * The host name does not map to the original host address. Perhaps
 961          * someone has compromised a name server. More likely someone botched
 962          * it, but that could be dangerous, too.
 963          */
 964
 965         DEBUG(0,("host name/address mismatch: %s != %s\n",
 966                  inet_ntoa(addr), hp->h_name));
 967         return False;
 968 }
 969
 970
 971 /*******************************************************************
 972  return the DNS name of the remote end of a socket
 973  ******************************************************************/
 974 char *get_socket_name(int fd)
 975 {
 976         static pstring name_buf;
 977         static fstring addr_buf;
 978         struct hostent *hp;
 979         struct in_addr addr;
 980         char *p;
 981
 982         p = get_socket_addr(fd);
 983
 984         /* it might be the same as the last one - save some DNS work */
 985         if (strcmp(p, addr_buf) == 0) return name_buf;
 986
 987         pstrcpy(name_buf,"UNKNOWN");
 988         if (fd == -1) return name_buf;
 989
 990         fstrcpy(addr_buf, p);
 991
 992         addr = *interpret_addr2(p);
 993
 994         /* Look up the remote host name. */
 995         if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
 996                 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
 997                 pstrcpy(name_buf, p);
 998         } else {
 999                 pstrcpy(name_buf,(char *)hp->h_name);
1000                 if (!matchname(name_buf, addr)) {
1001                         DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1002                         pstrcpy(name_buf,"UNKNOWN");
1003                 }
1004         }
1005
1006         alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
1007         if (strstr(name_buf,"..")) {
1008                 pstrcpy(name_buf, "UNKNOWN");
1009         }
1010
1011         return name_buf;
1012 }
1013
1014 /*******************************************************************
1015  return the IP addr of the remote end of a socket as a string
1016  ******************************************************************/
1017 char *get_socket_addr(int fd)
1018 {
1019         struct sockaddr sa;
1020         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1021         int     length = sizeof(sa);
1022         static fstring addr_buf;
1023
1024         fstrcpy(addr_buf,"0.0.0.0");
1025
1026         if (fd == -1) {
1027                 return addr_buf;
1028         }
1029
1030         if (getpeername(fd, &sa, &length) < 0) {
1031                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1032                 return addr_buf;
1033         }
1034
1035         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1036
1037         return addr_buf;
1038 }
1039
1040 /*******************************************************************
1041  opens and connects to a unix pipe socket
1042  ******************************************************************/
1043 int open_pipe_sock(char *path)
1044 {
1045         int sock;
1046         struct sockaddr_un sa;
1047
1048         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1049
1050         if (sock < 0)
1051         {
1052                 DEBUG(0, ("unix socket open failed\n"));
1053                 return sock;
1054         }
1055
1056         ZERO_STRUCT(sa);
1057         sa.sun_family = AF_UNIX;
1058         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1059
1060         DEBUG(10, ("socket open succeeded.  file name: %s\n", sa.sun_path));
1061
1062         if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1063         {
1064                 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1065                 close(sock);
1066                 return -1;
1067         }
1068
1069         return sock;
1070 }
1071
1072 int create_pipe_socket(char *dir, int dir_perms,
1073                                 char *path, int path_perms)
1074 {
1075         int s;
1076         struct sockaddr_un sa;
1077
1078         DEBUG(0,("create_pipe_socket: %s %d %s %d\n",
1079                    dir, dir_perms, path, path_perms));
1080
1081         DEBUG(0,("*** RACE CONDITION.  PLEASE SOMEONE EXAMINE create_pipe_Socket AND FIX IT ***\n"));
1082
1083         mkdir(dir, dir_perms);
1084
1085         if (chmod(dir, dir_perms) < 0)
1086         {
1087                 DEBUG(0, ("chmod on %s failed\n", dir));
1088                 return -1;
1089         }
1090
1091         if (!remove(path))
1092         {
1093                 DEBUG(0, ("remove on %s failed\n", path));
1094         }
1095
1096         /* start listening on unix socket */
1097         s = socket(AF_UNIX, SOCK_STREAM, 0);
1098
1099         if (s < 0)
1100         {
1101                 DEBUG(0, ("socket open failed\n"));
1102                 return -1;
1103         }
1104
1105         ZERO_STRUCT(sa);
1106         sa.sun_family = AF_UNIX;
1107         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1108
1109         if (bind(s, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1110         {
1111                 DEBUG(0, ("socket bind to %s failed\n", sa.sun_path));
1112                 close(s);
1113                 remove(path);
1114                 return -1;
1115         }
1116
1117         if (s == -1)
1118         {
1119                 DEBUG(0,("bind failed\n"));
1120                 remove(path);
1121                 return -1;
1122         }
1123
1124         if (path_perms != 0)
1125         {
1126                 chmod(path, path_perms);
1127         }
1128
1129         if (listen(s, 5) == -1)
1130         {
1131                 DEBUG(0,("listen failed\n"));
1132                 return -1;
1133         }
1134
1135         DEBUG(5,("unix socket opened: %s\n", path));
1136
1137         return s;
1138 }
1139
1140 /*******************************************************************
1141 this is like socketpair but uses tcp. It is used by the Samba
1142 regression test code
1143 The function guarantees that nobody else can attach to the socket,
1144 or if they do that this function fails and the socket gets closed
1145 returns 0 on success, -1 on failure
1146 the resulting file descriptors are symmetrical
1147  ******************************************************************/
1148 static int socketpair_tcp(int fd[2])
1149 {
1150         int listener;
1151         struct sockaddr_in sock;
1152         struct sockaddr_in sock2;
1153         socklen_t socklen = sizeof(sock);
1154         int connect_done = 0;
1155
1156         fd[0] = fd[1] = listener = -1;
1157
1158         memset(&sock, 0, sizeof(sock));
1159
1160         if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1161
1162         memset(&sock2, 0, sizeof(sock2));
1163 #ifdef HAVE_SOCK_SIN_LEN
1164         sock2.sin_len = sizeof(sock2);
1165 #endif
1166         sock2.sin_family = PF_INET;
1167
1168         bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1169
1170         if (listen(listener, 1) != 0) goto failed;
1171
1172         if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1173
1174         if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1175
1176         set_blocking(fd[1], 0);
1177
1178         sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1179
1180         if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1181                 if (errno != EINPROGRESS) goto failed;
1182         } else {
1183                 connect_done = 1;
1184         }
1185
1186         if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1187
1188         close(listener);
1189         if (connect_done == 0) {
1190                 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1191                     && errno != EISCONN) goto failed;
1192         }
1193
1194         set_blocking(fd[1], 1);
1195
1196         /* all OK! */
1197         return 0;
1198
1199  failed:
1200         if (fd[0] != -1) close(fd[0]);
1201         if (fd[1] != -1) close(fd[1]);
1202         if (listener != -1) close(listener);
1203         return -1;
1204 }
1205
1206
1207 /*******************************************************************
1208 run a program on a local tcp socket, this is used to launch smbd
1209 when regression testing
1210 the return value is a socket which is attached to a subprocess
1211 running "prog". stdin and stdout are attached. stderr is left
1212 attached to the original stderr
1213  ******************************************************************/
1214 int sock_exec(const char *prog)
1215 {
1216         int fd[2];
1217         if (socketpair_tcp(fd) != 0) {
1218                 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));
1219                 return -1;
1220         }
1221         if (fork() == 0) {
1222                 close(fd[0]);
1223                 close(0);
1224                 close(1);
1225                 dup(fd[1]);
1226                 dup(fd[1]);
1227                 exit(system(prog));
1228         }
1229         close(fd[1]);
1230         return fd[0];
1231 }
1232