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