source3/lib/util_sock.c

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