source3/smbd/process.c

   1 #define OLD_NTDOMAIN 1
   2 /*
   3    Unix SMB/Netbios implementation.
   4    Version 1.9.
   5    process incoming packets - main loop
   6    Copyright (C) Andrew Tridgell 1992-1998
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 extern int DEBUGLEVEL;
  26
  27 struct timeval smb_last_time;
  28
  29 static char *InBuffer = NULL;
  30 char *OutBuffer = NULL;
  31 char *last_inbuf = NULL;
  32
  33 /*
  34  * Size of data we can send to client. Set
  35  *  by the client for all protocols above CORE.
  36  *  Set by us for CORE protocol.
  37  */
  38 int max_send = BUFFER_SIZE;
  39 /*
  40  * Size of the data we can receive. Set by us.
  41  * Can be modified by the max xmit parameter.
  42  */
  43 int max_recv = BUFFER_SIZE;
  44
  45 extern int last_message;
  46 extern int global_oplock_break;
  47 extern pstring sesssetup_user;
  48 extern char *last_inbuf;
  49 extern char *InBuffer;
  50 extern char *OutBuffer;
  51 extern int smb_read_error;
  52 extern VOLATILE SIG_ATOMIC_T reload_after_sighup;
  53 extern BOOL global_machine_password_needs_changing;
  54 extern fstring global_myworkgroup;
  55 extern pstring global_myname;
  56 extern int max_send;
  57
  58 /****************************************************************************
  59  structure to hold a linked list of queued messages.
  60  for processing.
  61 ****************************************************************************/
  62
  63 typedef struct {
  64    ubi_slNode msg_next;
  65    char *msg_buf;
  66    int msg_len;
  67 } pending_message_list;
  68
  69 static ubi_slList smb_oplock_queue = { NULL, (ubi_slNodePtr)&smb_oplock_queue, 0};
  70
  71 /****************************************************************************
  72  Function to push a message onto the tail of a linked list of smb messages ready
  73  for processing.
  74 ****************************************************************************/
  75
  76 static BOOL push_message(ubi_slList *list_head, char *buf, int msg_len)
  77 {
  78   pending_message_list *msg = (pending_message_list *)
  79                                malloc(sizeof(pending_message_list));
  80
  81   if(msg == NULL)
  82   {
  83     DEBUG(0,("push_message: malloc fail (1)\n"));
  84     return False;
  85   }
  86
  87   msg->msg_buf = (char *)malloc(msg_len);
  88   if(msg->msg_buf == NULL)
  89   {
  90     DEBUG(0,("push_message: malloc fail (2)\n"));
  91     free((char *)msg);
  92     return False;
  93   }
  94
  95   memcpy(msg->msg_buf, buf, msg_len);
  96   msg->msg_len = msg_len;
  97
  98   ubi_slAddTail( list_head, msg);
  99
 100   return True;
 101 }
 102
 103 /****************************************************************************
 104  Function to push a smb message onto a linked list of local smb messages ready
 105  for processing.
 106 ****************************************************************************/
 107
 108 BOOL push_oplock_pending_smb_message(char *buf, int msg_len)
 109 {
 110         return push_message(&smb_oplock_queue, buf, msg_len);
 111 }
 112
 113 /****************************************************************************
 114 do all async processing in here. This includes UDB oplock messages, kernel
 115 oplock messages, change notify events etc.
 116 ****************************************************************************/
 117 static void async_processing(fd_set *fds, char *buffer, int buffer_len)
 118 {
 119         /* check for oplock messages (both UDP and kernel) */
 120         if (receive_local_message(fds, buffer, buffer_len, 0)) {
 121                 process_local_message(buffer, buffer_len);
 122         }
 123
 124         /* check for async change notify events */
 125         process_pending_change_notify_queue(0);
 126
 127         /* check for sighup processing */
 128         if (reload_after_sighup) {
 129                 unbecome_user();
 130                 DEBUG(1,("Reloading services after SIGHUP\n"));
 131                 reload_services(False);
 132                 reload_after_sighup = False;
 133         }
 134
 135         /* check for any pending internal messages */
 136         message_dispatch();
 137 }
 138
 139 /****************************************************************************
 140   Do a select on an two fd's - with timeout.
 141
 142   If a local udp message has been pushed onto the
 143   queue (this can only happen during oplock break
 144   processing) call async_processing()
 145
 146   If a pending smb message has been pushed onto the
 147   queue (this can only happen during oplock break
 148   processing) return this next.
 149
 150   If the first smbfd is ready then read an smb from it.
 151   if the second (loopback UDP) fd is ready then read a message
 152   from it and setup the buffer header to identify the length
 153   and from address.
 154   Returns False on timeout or error.
 155   Else returns True.
 156
 157 The timeout is in milli seconds
 158 ****************************************************************************/
 159
 160 static BOOL receive_message_or_smb(char *buffer, int buffer_len, int timeout)
 161 {
 162         fd_set fds;
 163         int selrtn;
 164         struct timeval to;
 165         int maxfd;
 166
 167         smb_read_error = 0;
 168
 169         /*
 170          * Check to see if we already have a message on the smb queue.
 171          * If so - copy and return it.
 172          */
 173         if(ubi_slCount(&smb_oplock_queue) != 0) {
 174                 pending_message_list *msg = (pending_message_list *)ubi_slRemHead(&smb_oplock_queue);
 175                 memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
 176
 177                 /* Free the message we just copied. */
 178                 free((char *)msg->msg_buf);
 179                 free((char *)msg);
 180
 181                 DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
 182                 return True;
 183         }
 184
 185
 186         /*
 187          * Setup the select read fd set.
 188          */
 189
 190  again:
 191         FD_ZERO(&fds);
 192         FD_SET(smbd_server_fd(),&fds);
 193         maxfd = setup_oplock_select_set(&fds);
 194
 195         to.tv_sec = timeout / 1000;
 196         to.tv_usec = (timeout % 1000) * 1000;
 197
 198         selrtn = sys_select(MAX(maxfd,smbd_server_fd())+1,&fds,timeout>0?&to:NULL);
 199
 200         /* if we get EINTR then maybe we have received an oplock
 201            signal - treat this as select returning 1. This is ugly, but
 202            is the best we can do until the oplock code knows more about
 203            signals */
 204         if (selrtn == -1 && errno == EINTR) {
 205                 async_processing(&fds, buffer, buffer_len);
 206                 goto again;
 207         }
 208
 209         /* Check if error */
 210         if (selrtn == -1) {
 211                 /* something is wrong. Maybe the socket is dead? */
 212                 smb_read_error = READ_ERROR;
 213                 return False;
 214         }
 215
 216         /* Did we timeout ? */
 217         if (selrtn == 0) {
 218                 smb_read_error = READ_TIMEOUT;
 219                 return False;
 220         }
 221
 222         if (!FD_ISSET(smbd_server_fd(),&fds) || selrtn > 1) {
 223                 async_processing(&fds, buffer, buffer_len);
 224                 if (!FD_ISSET(smbd_server_fd(),&fds)) goto again;
 225         }
 226
 227         return receive_smb(smbd_server_fd(), buffer, 0);
 228 }
 229
 230 /****************************************************************************
 231 Get the next SMB packet, doing the local message processing automatically.
 232 ****************************************************************************/
 233
 234 BOOL receive_next_smb(char *inbuf, int bufsize, int timeout)
 235 {
 236         BOOL got_keepalive;
 237         BOOL ret;
 238
 239         do {
 240                 ret = receive_message_or_smb(inbuf,bufsize,timeout);
 241
 242                 got_keepalive = (ret && (CVAL(inbuf,0) == 0x85));
 243         } while (ret && got_keepalive);
 244
 245         return ret;
 246 }
 247
 248 /****************************************************************************
 249  We're terminating and have closed all our files/connections etc.
 250  If there are any pending local messages we need to respond to them
 251  before termination so that other smbds don't think we just died whilst
 252  holding oplocks.
 253 ****************************************************************************/
 254
 255 void respond_to_all_remaining_local_messages(void)
 256 {
 257   char buffer[1024];
 258   fd_set fds;
 259
 260   /*
 261    * Assert we have no exclusive open oplocks.
 262    */
 263
 264   if(get_number_of_exclusive_open_oplocks()) {
 265     DEBUG(0,("respond_to_all_remaining_local_messages: PANIC : we have %d exclusive oplocks.\n",
 266           get_number_of_exclusive_open_oplocks() ));
 267     return;
 268   }
 269
 270   /*
 271    * Setup the select read fd set.
 272    */
 273
 274   FD_ZERO(&fds);
 275   if(!setup_oplock_select_set(&fds))
 276     return;
 277
 278   /*
 279    * Keep doing receive_local_message with a 1 ms timeout until
 280    * we have no more messages.
 281    */
 282   while(receive_local_message(&fds, buffer, sizeof(buffer), 1)) {
 283           /* Deal with oplock break requests from other smbd's. */
 284           process_local_message(buffer, sizeof(buffer));
 285
 286           FD_ZERO(&fds);
 287           (void)setup_oplock_select_set(&fds);
 288   }
 289
 290   return;
 291 }
 292
 293
 294 /*
 295 These flags determine some of the permissions required to do an operation
 296
 297 Note that I don't set NEED_WRITE on some write operations because they
 298 are used by some brain-dead clients when printing, and I don't want to
 299 force write permissions on print services.
 300 */
 301 #define AS_USER (1<<0)
 302 #define NEED_WRITE (1<<1)
 303 #define TIME_INIT (1<<2)
 304 #define CAN_IPC (1<<3)
 305 #define AS_GUEST (1<<5)
 306 #define QUEUE_IN_OPLOCK (1<<6)
 307
 308 /*
 309    define a list of possible SMB messages and their corresponding
 310    functions. Any message that has a NULL function is unimplemented -
 311    please feel free to contribute implementations!
 312 */
 313 struct smb_message_struct
 314 {
 315   int code;
 316   char *name;
 317   int (*fn)(connection_struct *conn, char *, char *, int, int);
 318   int flags;
 319 }
 320  smb_messages[] = {
 321
 322     /* CORE PROTOCOL */
 323
 324    {SMBnegprot,"SMBnegprot",reply_negprot,0},
 325    {SMBtcon,"SMBtcon",reply_tcon,0},
 326    {SMBtdis,"SMBtdis",reply_tdis,0},
 327    {SMBexit,"SMBexit",reply_exit,0},
 328    {SMBioctl,"SMBioctl",reply_ioctl,0},
 329    {SMBecho,"SMBecho",reply_echo,0},
 330    {SMBsesssetupX,"SMBsesssetupX",reply_sesssetup_and_X,0},
 331    {SMBtconX,"SMBtconX",reply_tcon_and_X,0},
 332    {SMBulogoffX, "SMBulogoffX", reply_ulogoffX, 0}, /* ulogoff doesn't give a valid TID */
 333    {SMBgetatr,"SMBgetatr",reply_getatr,AS_USER},
 334    {SMBsetatr,"SMBsetatr",reply_setatr,AS_USER | NEED_WRITE},
 335    {SMBchkpth,"SMBchkpth",reply_chkpth,AS_USER},
 336    {SMBsearch,"SMBsearch",reply_search,AS_USER},
 337    {SMBopen,"SMBopen",reply_open,AS_USER | QUEUE_IN_OPLOCK },
 338
 339    /* note that SMBmknew and SMBcreate are deliberately overloaded */
 340    {SMBcreate,"SMBcreate",reply_mknew,AS_USER},
 341    {SMBmknew,"SMBmknew",reply_mknew,AS_USER},
 342
 343    {SMBunlink,"SMBunlink",reply_unlink,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
 344    {SMBread,"SMBread",reply_read,AS_USER},
 345    {SMBwrite,"SMBwrite",reply_write,AS_USER | CAN_IPC },
 346    {SMBclose,"SMBclose",reply_close,AS_USER | CAN_IPC },
 347    {SMBmkdir,"SMBmkdir",reply_mkdir,AS_USER | NEED_WRITE},
 348    {SMBrmdir,"SMBrmdir",reply_rmdir,AS_USER | NEED_WRITE},
 349    {SMBdskattr,"SMBdskattr",reply_dskattr,AS_USER},
 350    {SMBmv,"SMBmv",reply_mv,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
 351
 352    /* this is a Pathworks specific call, allowing the
 353       changing of the root path */
 354    {pSETDIR,"pSETDIR",reply_setdir,AS_USER},
 355
 356    {SMBlseek,"SMBlseek",reply_lseek,AS_USER},
 357    {SMBflush,"SMBflush",reply_flush,AS_USER},
 358    {SMBctemp,"SMBctemp",reply_ctemp,AS_USER | QUEUE_IN_OPLOCK },
 359    {SMBsplopen,"SMBsplopen",reply_printopen,AS_USER | QUEUE_IN_OPLOCK },
 360    {SMBsplclose,"SMBsplclose",reply_printclose,AS_USER},
 361    {SMBsplretq,"SMBsplretq",reply_printqueue,AS_USER},
 362    {SMBsplwr,"SMBsplwr",reply_printwrite,AS_USER},
 363    {SMBlock,"SMBlock",reply_lock,AS_USER},
 364    {SMBunlock,"SMBunlock",reply_unlock,AS_USER},
 365
 366    /* CORE+ PROTOCOL FOLLOWS */
 367
 368    {SMBreadbraw,"SMBreadbraw",reply_readbraw,AS_USER},
 369    {SMBwritebraw,"SMBwritebraw",reply_writebraw,AS_USER},
 370    {SMBwriteclose,"SMBwriteclose",reply_writeclose,AS_USER},
 371    {SMBlockread,"SMBlockread",reply_lockread,AS_USER},
 372    {SMBwriteunlock,"SMBwriteunlock",reply_writeunlock,AS_USER},
 373
 374    /* LANMAN1.0 PROTOCOL FOLLOWS */
 375
 376    {SMBreadBmpx,"SMBreadBmpx",reply_readbmpx,AS_USER},
 377    {SMBreadBs,"SMBreadBs",NULL,AS_USER},
 378    {SMBwriteBmpx,"SMBwriteBmpx",reply_writebmpx,AS_USER},
 379    {SMBwriteBs,"SMBwriteBs",reply_writebs,AS_USER},
 380    {SMBwritec,"SMBwritec",NULL,AS_USER},
 381    {SMBsetattrE,"SMBsetattrE",reply_setattrE,AS_USER | NEED_WRITE },
 382    {SMBgetattrE,"SMBgetattrE",reply_getattrE,AS_USER },
 383    {SMBtrans,"SMBtrans",reply_trans,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
 384    {SMBtranss,"SMBtranss",NULL,AS_USER | CAN_IPC},
 385    {SMBioctls,"SMBioctls",NULL,AS_USER},
 386    {SMBcopy,"SMBcopy",reply_copy,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
 387    {SMBmove,"SMBmove",NULL,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
 388
 389    {SMBopenX,"SMBopenX",reply_open_and_X,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
 390    {SMBreadX,"SMBreadX",reply_read_and_X,AS_USER | CAN_IPC },
 391    {SMBwriteX,"SMBwriteX",reply_write_and_X,AS_USER | CAN_IPC },
 392    {SMBlockingX,"SMBlockingX",reply_lockingX,AS_USER },
 393
 394    {SMBffirst,"SMBffirst",reply_search,AS_USER},
 395    {SMBfunique,"SMBfunique",reply_search,AS_USER},
 396    {SMBfclose,"SMBfclose",reply_fclose,AS_USER},
 397
 398    /* LANMAN2.0 PROTOCOL FOLLOWS */
 399    {SMBfindnclose, "SMBfindnclose", reply_findnclose, AS_USER},
 400    {SMBfindclose, "SMBfindclose", reply_findclose,AS_USER},
 401    {SMBtrans2, "SMBtrans2", reply_trans2, AS_USER | QUEUE_IN_OPLOCK | CAN_IPC },
 402    {SMBtranss2, "SMBtranss2", reply_transs2, AS_USER},
 403
 404    /* NT PROTOCOL FOLLOWS */
 405    {SMBntcreateX, "SMBntcreateX", reply_ntcreate_and_X, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
 406    {SMBnttrans, "SMBnttrans", reply_nttrans, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
 407    {SMBnttranss, "SMBnttranss", reply_nttranss, AS_USER | CAN_IPC },
 408    {SMBntcancel, "SMBntcancel", reply_ntcancel, 0 },
 409
 410    /* messaging routines */
 411    {SMBsends,"SMBsends",reply_sends,AS_GUEST},
 412    {SMBsendstrt,"SMBsendstrt",reply_sendstrt,AS_GUEST},
 413    {SMBsendend,"SMBsendend",reply_sendend,AS_GUEST},
 414    {SMBsendtxt,"SMBsendtxt",reply_sendtxt,AS_GUEST},
 415
 416    /* NON-IMPLEMENTED PARTS OF THE CORE PROTOCOL */
 417
 418    {SMBsendb,"SMBsendb",NULL,AS_GUEST},
 419    {SMBfwdname,"SMBfwdname",NULL,AS_GUEST},
 420    {SMBcancelf,"SMBcancelf",NULL,AS_GUEST},
 421    {SMBgetmac,"SMBgetmac",NULL,AS_GUEST}
 422  };
 423
 424 /*******************************************************************
 425 dump a prs to a file
 426  ********************************************************************/
 427 static void smb_dump(char *name, int type, char *data, ssize_t len)
 428 {
 429         int fd, i;
 430         pstring fname;
 431         if (DEBUGLEVEL < 50) return;
 432
 433         if (len < 4) len = smb_len(data)+4;
 434         for (i=1;i<100;i++) {
 435                 slprintf(fname,sizeof(fname), "/tmp/%s.%d.%s", name, i,
 436                                 type ? "req" : "resp");
 437                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
 438                 if (fd != -1 || errno != EEXIST) break;
 439         }
 440         if (fd != -1) {
 441                 write(fd, data, len);
 442                 close(fd);
 443                 DEBUG(0,("created %s len %d\n", fname, len));
 444         }
 445 }
 446
 447
 448 /****************************************************************************
 449 do a switch on the message type, and return the response size
 450 ****************************************************************************/
 451 static int switch_message(int type,char *inbuf,char *outbuf,int size,int bufsize)
 452 {
 453   static pid_t pid= (pid_t)-1;
 454   int outsize = 0;
 455   static int num_smb_messages =
 456     sizeof(smb_messages) / sizeof(struct smb_message_struct);
 457   int match;
 458   extern int global_smbpid;
 459
 460   if (pid == (pid_t)-1)
 461     pid = sys_getpid();
 462
 463   errno = 0;
 464   last_message = type;
 465
 466   /* make sure this is an SMB packet */
 467   if (strncmp(smb_base(inbuf),"\377SMB",4) != 0)
 468   {
 469     DEBUG(2,("Non-SMB packet of length %d\n",smb_len(inbuf)));
 470     return(-1);
 471   }
 472
 473   for (match=0;match<num_smb_messages;match++)
 474     if (smb_messages[match].code == type)
 475       break;
 476
 477   /* yuck! this is an interim measure before we get rid of our
 478      current inbuf/outbuf system */
 479   global_smbpid = SVAL(inbuf,smb_pid);
 480
 481   if (match == num_smb_messages)
 482   {
 483     DEBUG(0,("Unknown message type %d!\n",type));
 484     smb_dump("Unknown", 1, inbuf, size);
 485     outsize = reply_unknown(inbuf,outbuf);
 486   }
 487   else
 488   {
 489     DEBUG(3,("switch message %s (pid %d)\n",smb_messages[match].name,(int)pid));
 490
 491     smb_dump(smb_messages[match].name, 1, inbuf, size);
 492     if(global_oplock_break)
 493     {
 494       int flags = smb_messages[match].flags;
 495
 496       if(flags & QUEUE_IN_OPLOCK)
 497       {
 498         /*
 499          * Queue this message as we are the process of an oplock break.
 500          */
 501
 502         DEBUG( 2, ( "switch_message: queueing message due to being in " ) );
 503         DEBUGADD( 2, ( "oplock break state.\n" ) );
 504
 505         push_oplock_pending_smb_message( inbuf, size );
 506         return -1;
 507       }
 508     }
 509     if (smb_messages[match].fn)
 510     {
 511       int flags = smb_messages[match].flags;
 512       static uint16 last_session_tag = UID_FIELD_INVALID;
 513       /* In share mode security we must ignore the vuid. */
 514       uint16 session_tag = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(inbuf,smb_uid);
 515       connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 516
 517
 518       /* Ensure this value is replaced in the incoming packet. */
 519       SSVAL(inbuf,smb_uid,session_tag);
 520
 521       /*
 522        * Ensure the correct username is in sesssetup_user.
 523        * This is a really ugly bugfix for problems with
 524        * multiple session_setup_and_X's being done and
 525        * allowing %U and %G substitutions to work correctly.
 526        * There is a reason this code is done here, don't
 527        * move it unless you know what you're doing... :-).
 528        * JRA.
 529        */
 530       if (session_tag != last_session_tag) {
 531         user_struct *vuser = NULL;
 532
 533         last_session_tag = session_tag;
 534         if(session_tag != UID_FIELD_INVALID)
 535           vuser = get_valid_user_struct(session_tag);
 536         if(vuser != NULL)
 537           pstrcpy( sesssetup_user, vuser->user.smb_name);
 538       }
 539
 540       /* does this protocol need to be run as root? */
 541       if (!(flags & AS_USER))
 542         unbecome_user();
 543
 544       /* does this protocol need to be run as the connected user? */
 545       if ((flags & AS_USER) && !become_user(conn,session_tag)) {
 546         if (flags & AS_GUEST)
 547           flags &= ~AS_USER;
 548         else
 549           return(ERROR(ERRSRV,ERRaccess));
 550       }
 551       /* this code is to work around a bug is MS client 3 without
 552          introducing a security hole - it needs to be able to do
 553          print queue checks as guest if it isn't logged in properly */
 554       if (flags & AS_USER)
 555         flags &= ~AS_GUEST;
 556
 557       /* does it need write permission? */
 558       if ((flags & NEED_WRITE) && !CAN_WRITE(conn))
 559         return(ERROR(ERRSRV,ERRaccess));
 560
 561       /* ipc services are limited */
 562       if (IS_IPC(conn) && (flags & AS_USER) && !(flags & CAN_IPC)) {
 563         return(ERROR(ERRSRV,ERRaccess));
 564       }
 565
 566       /* load service specific parameters */
 567       if (conn && !become_service(conn,(flags & AS_USER)?True:False)) {
 568         return(ERROR(ERRSRV,ERRaccess));
 569       }
 570
 571       /* does this protocol need to be run as guest? */
 572       if ((flags & AS_GUEST) &&
 573           (!become_guest() ||
 574            !check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1)))) {
 575         return(ERROR(ERRSRV,ERRaccess));
 576       }
 577
 578       last_inbuf = inbuf;
 579
 580       outsize = smb_messages[match].fn(conn, inbuf,outbuf,size,bufsize);
 581     }
 582     else
 583     {
 584       outsize = reply_unknown(inbuf,outbuf);
 585     }
 586   }
 587
 588   smb_dump(smb_messages[match].name, 0, outbuf, outsize);
 589
 590   return(outsize);
 591 }
 592
 593
 594 /****************************************************************************
 595   construct a reply to the incoming packet
 596 ****************************************************************************/
 597 static int construct_reply(char *inbuf,char *outbuf,int size,int bufsize)
 598 {
 599   int type = CVAL(inbuf,smb_com);
 600   int outsize = 0;
 601   int msg_type = CVAL(inbuf,0);
 602
 603   GetTimeOfDay(&smb_last_time);
 604
 605   chain_size = 0;
 606   file_chain_reset();
 607   reset_chain_p();
 608
 609   if (msg_type != 0)
 610     return(reply_special(inbuf,outbuf));
 611
 612   construct_reply_common(inbuf, outbuf);
 613
 614   outsize = switch_message(type,inbuf,outbuf,size,bufsize);
 615
 616   outsize += chain_size;
 617
 618   if(outsize > 4)
 619     smb_setlen(outbuf,outsize - 4);
 620   return(outsize);
 621 }
 622
 623
 624 /****************************************************************************
 625   process an smb from the client - split out from the process() code so
 626   it can be used by the oplock break code.
 627 ****************************************************************************/
 628 void process_smb(char *inbuf, char *outbuf)
 629 {
 630 #ifdef WITH_SSL
 631   extern BOOL sslEnabled;     /* don't use function for performance reasons */
 632   static int sslConnected = 0;
 633 #endif /* WITH_SSL */
 634   static int trans_num;
 635   int msg_type = CVAL(inbuf,0);
 636   int32 len = smb_len(inbuf);
 637   int nread = len + 4;
 638
 639   DO_PROFILE_INC(smb_count);
 640
 641   if (trans_num == 0) {
 642           /* on the first packet, check the global hosts allow/ hosts
 643              deny parameters before doing any parsing of the packet
 644              passed to us by the client.  This prevents attacks on our
 645              parsing code from hosts not in the hosts allow list */
 646           if (!check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1))) {
 647                   /* send a negative session response "not listining on calling
 648                    name" */
 649                   static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
 650                   DEBUG( 1, ( "Connection denied from %s\n",
 651                               client_addr() ) );
 652                   send_smb(smbd_server_fd(),(char *)buf);
 653                   exit_server("connection denied");
 654           }
 655   }
 656
 657   DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type, len ) );
 658   DEBUG( 3, ( "Transaction %d of length %d\n", trans_num, nread ) );
 659
 660 #ifdef WITH_SSL
 661     if(sslEnabled && !sslConnected){
 662         sslConnected = sslutil_negotiate_ssl(smbd_server_fd(), msg_type);
 663         if(sslConnected < 0){   /* an error occured */
 664             exit_server("SSL negotiation failed");
 665         }else if(sslConnected){
 666             trans_num++;
 667             return;
 668         }
 669     }
 670 #endif  /* WITH_SSL */
 671
 672   if (msg_type == 0)
 673     show_msg(inbuf);
 674   else if(msg_type == 0x85)
 675     return; /* Keepalive packet. */
 676
 677   nread = construct_reply(inbuf,outbuf,nread,max_send);
 678
 679   if(nread > 0)
 680   {
 681     if (CVAL(outbuf,0) == 0)
 682       show_msg(outbuf);
 683
 684     if (nread != smb_len(outbuf) + 4)
 685     {
 686       DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
 687                  nread, smb_len(outbuf)));
 688     }
 689     else
 690       send_smb(smbd_server_fd(),outbuf);
 691   }
 692   trans_num++;
 693 }
 694
 695
 696
 697 /****************************************************************************
 698 return a string containing the function name of a SMB command
 699 ****************************************************************************/
 700 char *smb_fn_name(int type)
 701 {
 702         static char *unknown_name = "SMBunknown";
 703         static int num_smb_messages =
 704                 sizeof(smb_messages) / sizeof(struct smb_message_struct);
 705         int match;
 706
 707         for (match=0;match<num_smb_messages;match++)
 708                 if (smb_messages[match].code == type)
 709                         break;
 710
 711         if (match == num_smb_messages)
 712                 return(unknown_name);
 713
 714         return(smb_messages[match].name);
 715 }
 716
 717
 718 /****************************************************************************
 719  Helper function for contruct_reply.
 720 ****************************************************************************/
 721
 722 void construct_reply_common(char *inbuf,char *outbuf)
 723 {
 724   memset(outbuf,'\0',smb_size);
 725
 726   set_message(outbuf,0,0,True);
 727   CVAL(outbuf,smb_com) = CVAL(inbuf,smb_com);
 728
 729   memcpy(outbuf+4,inbuf+4,4);
 730   CVAL(outbuf,smb_rcls) = SMB_SUCCESS;
 731   CVAL(outbuf,smb_reh) = 0;
 732   SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES)); /* bit 7 set
 733                                  means a reply */
 734   SSVAL(outbuf,smb_flg2,FLAGS2_LONG_PATH_COMPONENTS);
 735         /* say we support long filenames */
 736
 737   SSVAL(outbuf,smb_err,SMB_SUCCESS);
 738   SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
 739   SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
 740   SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
 741   SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
 742 }
 743
 744 /****************************************************************************
 745   construct a chained reply and add it to the already made reply
 746   **************************************************************************/
 747 int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
 748 {
 749   static char *orig_inbuf;
 750   static char *orig_outbuf;
 751   int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
 752   unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
 753   char *inbuf2, *outbuf2;
 754   int outsize2;
 755   char inbuf_saved[smb_wct];
 756   char outbuf_saved[smb_wct];
 757   int wct = CVAL(outbuf,smb_wct);
 758   int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
 759
 760   /* maybe its not chained */
 761   if (smb_com2 == 0xFF) {
 762     CVAL(outbuf,smb_vwv0) = 0xFF;
 763     return outsize;
 764   }
 765
 766   if (chain_size == 0) {
 767     /* this is the first part of the chain */
 768     orig_inbuf = inbuf;
 769     orig_outbuf = outbuf;
 770   }
 771
 772   /*
 773    * The original Win95 redirector dies on a reply to
 774    * a lockingX and read chain unless the chain reply is
 775    * 4 byte aligned. JRA.
 776    */
 777
 778   outsize = (outsize + 3) & ~3;
 779
 780   /* we need to tell the client where the next part of the reply will be */
 781   SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
 782   CVAL(outbuf,smb_vwv0) = smb_com2;
 783
 784   /* remember how much the caller added to the chain, only counting stuff
 785      after the parameter words */
 786   chain_size += outsize - smb_wct;
 787
 788   /* work out pointers into the original packets. The
 789      headers on these need to be filled in */
 790   inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
 791   outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
 792
 793   /* remember the original command type */
 794   smb_com1 = CVAL(orig_inbuf,smb_com);
 795
 796   /* save the data which will be overwritten by the new headers */
 797   memcpy(inbuf_saved,inbuf2,smb_wct);
 798   memcpy(outbuf_saved,outbuf2,smb_wct);
 799
 800   /* give the new packet the same header as the last part of the SMB */
 801   memmove(inbuf2,inbuf,smb_wct);
 802
 803   /* create the in buffer */
 804   CVAL(inbuf2,smb_com) = smb_com2;
 805
 806   /* create the out buffer */
 807   construct_reply_common(inbuf2, outbuf2);
 808
 809   DEBUG(3,("Chained message\n"));
 810   show_msg(inbuf2);
 811
 812   /* process the request */
 813   outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
 814                             bufsize-chain_size);
 815
 816   /* copy the new reply and request headers over the old ones, but
 817      preserve the smb_com field */
 818   memmove(orig_outbuf,outbuf2,smb_wct);
 819   CVAL(orig_outbuf,smb_com) = smb_com1;
 820
 821   /* restore the saved data, being careful not to overwrite any
 822    data from the reply header */
 823   memcpy(inbuf2,inbuf_saved,smb_wct);
 824   {
 825     int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
 826     if (ofs < 0) ofs = 0;
 827     memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
 828   }
 829
 830   return outsize2;
 831 }
 832
 833 /****************************************************************************
 834  Setup the needed select timeout.
 835 ****************************************************************************/
 836
 837 static int setup_select_timeout(void)
 838 {
 839         int select_timeout;
 840         int t;
 841
 842         /*
 843          * Increase the select timeout back to SMBD_SELECT_TIMEOUT if we
 844          * have removed any blocking locks. JRA.
 845          */
 846
 847         select_timeout = blocking_locks_pending() ? SMBD_SELECT_TIMEOUT_WITH_PENDING_LOCKS*1000 :
 848                 SMBD_SELECT_TIMEOUT*1000;
 849
 850         t = change_notify_timeout();
 851         if (t != -1) select_timeout = MIN(select_timeout, t*1000);
 852
 853         return select_timeout;
 854 }
 855
 856 /****************************************************************************
 857  Check if services need reloading.
 858 ****************************************************************************/
 859
 860 void check_reload(int t)
 861 {
 862   static time_t last_smb_conf_reload_time = 0;
 863
 864   if(last_smb_conf_reload_time == 0)
 865     last_smb_conf_reload_time = t;
 866
 867   if (reload_after_sighup || (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK))
 868   {
 869     reload_services(True);
 870     reload_after_sighup = False;
 871     last_smb_conf_reload_time = t;
 872   }
 873 }
 874
 875 /****************************************************************************
 876  Process any timeout housekeeping. Return False if the caller should exit.
 877 ****************************************************************************/
 878
 879 static BOOL timeout_processing(int deadtime, int *select_timeout, time_t *last_timeout_processing_time)
 880 {
 881   static time_t last_keepalive_sent_time = 0;
 882   static time_t last_idle_closed_check = 0;
 883   time_t t;
 884   BOOL allidle = True;
 885   extern int keepalive;
 886
 887   if (smb_read_error == READ_EOF)
 888   {
 889     DEBUG(3,("end of file from client\n"));
 890     return False;
 891   }
 892
 893   if (smb_read_error == READ_ERROR)
 894   {
 895     DEBUG(3,("receive_smb error (%s) exiting\n",
 896               strerror(errno)));
 897     return False;
 898   }
 899
 900   *last_timeout_processing_time = t = time(NULL);
 901
 902   if(last_keepalive_sent_time == 0)
 903     last_keepalive_sent_time = t;
 904
 905   if(last_idle_closed_check == 0)
 906     last_idle_closed_check = t;
 907
 908   /* become root again if waiting */
 909   unbecome_user();
 910
 911   /* check if we need to reload services */
 912   check_reload(t);
 913
 914   /* automatic timeout if all connections are closed */
 915   if (conn_num_open()==0 && (t - last_idle_closed_check) >= IDLE_CLOSED_TIMEOUT)
 916   {
 917     DEBUG( 2, ( "Closing idle connection\n" ) );
 918     return False;
 919   }
 920   else
 921     last_idle_closed_check = t;
 922
 923   if (keepalive && (t - last_keepalive_sent_time)>keepalive)
 924   {
 925     struct cli_state *cli = server_client();
 926     if (!send_keepalive(smbd_server_fd())) {
 927       DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
 928       return False;
 929     }
 930     /* also send a keepalive to the password server if its still
 931        connected */
 932     if (cli && cli->initialised)
 933       send_keepalive(cli->fd);
 934     last_keepalive_sent_time = t;
 935   }
 936
 937   /* check for connection timeouts */
 938   allidle = conn_idle_all(t, deadtime);
 939
 940   if (allidle && conn_num_open()>0) {
 941     DEBUG(2,("Closing idle connection 2.\n"));
 942     return False;
 943   }
 944
 945   if(global_machine_password_needs_changing)
 946   {
 947     unsigned char trust_passwd_hash[16];
 948     time_t lct;
 949     pstring remote_machine_list;
 950
 951     /*
 952      * We're in domain level security, and the code that
 953      * read the machine password flagged that the machine
 954      * password needs changing.
 955      */
 956
 957     /*
 958      * First, open the machine password file with an exclusive lock.
 959      */
 960
 961     if(!secrets_fetch_trust_account_password(global_myworkgroup, trust_passwd_hash, &lct)) {
 962       DEBUG(0,("process: unable to read the machine account password for \
 963 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
 964       return True;
 965     }
 966
 967     /*
 968      * Make sure someone else hasn't already done this.
 969      */
 970
 971     if(t < lct + lp_machine_password_timeout()) {
 972       global_machine_password_needs_changing = False;
 973       return True;
 974     }
 975
 976     pstrcpy(remote_machine_list, lp_passwordserver());
 977
 978     change_trust_account_password( global_myworkgroup, remote_machine_list);
 979     global_machine_password_needs_changing = False;
 980   }
 981
 982   /*
 983    * Check to see if we have any blocking locks
 984    * outstanding on the queue.
 985    */
 986   process_blocking_lock_queue(t);
 987
 988   /*
 989    * Check to see if we have any change notifies
 990    * outstanding on the queue.
 991    */
 992   process_pending_change_notify_queue(t);
 993
 994   /*
 995    * Now we are root, check if the log files need pruning.
 996    */
 997   if(need_to_check_log_size())
 998       check_log_size();
 999
1000   /*
1001    * Modify the select timeout depending upon
1002    * what we have remaining in our queues.
1003    */
1004
1005   *select_timeout = setup_select_timeout();
1006
1007   return True;
1008 }
1009
1010 /****************************************************************************
1011   process commands from the client
1012 ****************************************************************************/
1013
1014 void smbd_process(void)
1015 {
1016         extern int smb_echo_count;
1017         time_t last_timeout_processing_time = time(NULL);
1018         unsigned int num_smbs = 0;
1019
1020         InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1021         OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1022         if ((InBuffer == NULL) || (OutBuffer == NULL))
1023                 return;
1024
1025         InBuffer += SMB_ALIGNMENT;
1026         OutBuffer += SMB_ALIGNMENT;
1027
1028         max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
1029
1030         /* re-initialise the timezone */
1031         TimeInit();
1032
1033         while (True) {
1034                 int deadtime = lp_deadtime()*60;
1035                 int select_timeout = setup_select_timeout();
1036                 int num_echos;
1037
1038                 if (deadtime <= 0)
1039                         deadtime = DEFAULT_SMBD_TIMEOUT;
1040
1041                 errno = 0;
1042
1043                 /* free up temporary memory */
1044                 lp_talloc_free();
1045                 parse_talloc_free();
1046
1047                 while (!receive_message_or_smb(InBuffer,BUFFER_SIZE,select_timeout)) {
1048                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1049                                 return;
1050                         num_smbs = 0; /* Reset smb counter. */
1051                 }
1052
1053                 /*
1054                  * Ensure we do timeout processing if the SMB we just got was
1055                  * only an echo request. This allows us to set the select
1056                  * timeout in 'receive_message_or_smb()' to any value we like
1057                  * without worrying that the client will send echo requests
1058                  * faster than the select timeout, thus starving out the
1059                  * essential processing (change notify, blocking locks) that
1060                  * the timeout code does. JRA.
1061                  */
1062                 num_echos = smb_echo_count;
1063
1064                 process_smb(InBuffer, OutBuffer);
1065
1066                 if (smb_echo_count != num_echos) {
1067                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1068                                 return;
1069                         num_smbs = 0; /* Reset smb counter. */
1070                 }
1071
1072                 num_smbs++;
1073
1074                 /*
1075                  * If we are getting smb requests in a constant stream
1076                  * with no echos, make sure we attempt timeout processing
1077                  * every select_timeout milliseconds - but only check for this
1078                  * every 200 smb requests.
1079                  */
1080
1081                 if ((num_smbs % 200) == 0) {
1082                         time_t new_check_time = time(NULL);
1083                         if(last_timeout_processing_time - new_check_time >= (select_timeout/1000)) {
1084                                 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1085                                         return;
1086                                 num_smbs = 0; /* Reset smb counter. */
1087                                 last_timeout_processing_time = new_check_time; /* Reset time. */
1088                         }
1089                 }
1090         }
1091 }
1092
1093 #undef OLD_NTDOMAIN