source/smbd/process.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    process incoming packets - main loop
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /* To be removed.... JRA */
  25 #define SMB_ALIGNMENT 1
  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 userdom_struct current_user_info;
  48 extern int smb_read_error;
  49 SIG_ATOMIC_T reload_after_sighup;
  50 SIG_ATOMIC_T got_sig_term;
  51 extern BOOL global_machine_password_needs_changing;
  52 extern fstring global_myworkgroup;
  53 extern pstring global_myname;
  54 extern int max_send;
  55
  56 /****************************************************************************
  57  structure to hold a linked list of queued messages.
  58  for processing.
  59 ****************************************************************************/
  60
  61 typedef struct {
  62    ubi_slNode msg_next;
  63    char *msg_buf;
  64    int msg_len;
  65 } pending_message_list;
  66
  67 static ubi_slList smb_oplock_queue = { NULL, (ubi_slNodePtr)&smb_oplock_queue, 0};
  68
  69 /****************************************************************************
  70  Function to push a message onto the tail of a linked list of smb messages ready
  71  for processing.
  72 ****************************************************************************/
  73
  74 static BOOL push_message(ubi_slList *list_head, char *buf, int msg_len)
  75 {
  76   pending_message_list *msg = (pending_message_list *)
  77                                malloc(sizeof(pending_message_list));
  78
  79   if(msg == NULL)
  80   {
  81     DEBUG(0,("push_message: malloc fail (1)\n"));
  82     return False;
  83   }
  84
  85   msg->msg_buf = (char *)malloc(msg_len);
  86   if(msg->msg_buf == NULL)
  87   {
  88     DEBUG(0,("push_message: malloc fail (2)\n"));
  89     SAFE_FREE(msg);
  90     return False;
  91   }
  92
  93   memcpy(msg->msg_buf, buf, msg_len);
  94   msg->msg_len = msg_len;
  95
  96   ubi_slAddTail( list_head, msg);
  97
  98   return True;
  99 }
 100
 101 /****************************************************************************
 102  Function to push a smb message onto a linked list of local smb messages ready
 103  for processing.
 104 ****************************************************************************/
 105
 106 BOOL push_oplock_pending_smb_message(char *buf, int msg_len)
 107 {
 108         return push_message(&smb_oplock_queue, buf, msg_len);
 109 }
 110
 111 /****************************************************************************
 112  Do all async processing in here. This includes UDB oplock messages, kernel
 113  oplock messages, change notify events etc.
 114 ****************************************************************************/
 115
 116 static void async_processing(char *buffer, int buffer_len)
 117 {
 118         DEBUG(10,("async_processing: Doing async processing.\n"));
 119
 120         /* check for oplock messages (both UDP and kernel) */
 121         if (receive_local_message(buffer, buffer_len, 1)) {
 122                 process_local_message(buffer, buffer_len);
 123         }
 124
 125         if (got_sig_term) {
 126                 exit_server("Caught TERM signal");
 127         }
 128
 129         /* check for async change notify events */
 130         process_pending_change_notify_queue(0);
 131
 132         /* check for sighup processing */
 133         if (reload_after_sighup) {
 134                 change_to_root_user();
 135                 DEBUG(1,("Reloading services after SIGHUP\n"));
 136                 reload_services(False);
 137                 reload_after_sighup = 0;
 138         }
 139 }
 140
 141 /****************************************************************************
 142   Do a select on an two fd's - with timeout.
 143
 144   If a local udp message has been pushed onto the
 145   queue (this can only happen during oplock break
 146   processing) call async_processing()
 147
 148   If a pending smb message has been pushed onto the
 149   queue (this can only happen during oplock break
 150   processing) return this next.
 151
 152   If the first smbfd is ready then read an smb from it.
 153   if the second (loopback UDP) fd is ready then read a message
 154   from it and setup the buffer header to identify the length
 155   and from address.
 156   Returns False on timeout or error.
 157   Else returns True.
 158
 159 The timeout is in milli seconds
 160 ****************************************************************************/
 161
 162 static BOOL receive_message_or_smb(char *buffer, int buffer_len, int timeout)
 163 {
 164         fd_set fds;
 165         int selrtn;
 166         struct timeval to;
 167         int maxfd;
 168
 169         smb_read_error = 0;
 170
 171  again:
 172
 173         /*
 174          * Note that this call must be before processing any SMB
 175          * messages as we need to synchronously process any messages
 176          * we may have sent to ourselves from the previous SMB.
 177          */
 178         message_dispatch();
 179
 180         /*
 181          * Check to see if we already have a message on the smb queue.
 182          * If so - copy and return it.
 183          */
 184         if(ubi_slCount(&smb_oplock_queue) != 0) {
 185                 pending_message_list *msg = (pending_message_list *)ubi_slRemHead(&smb_oplock_queue);
 186                 memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
 187
 188                 /* Free the message we just copied. */
 189                 SAFE_FREE(msg->msg_buf);
 190                 SAFE_FREE(msg);
 191
 192                 DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
 193                 return True;
 194         }
 195
 196
 197         /*
 198          * Setup the select read fd set.
 199          */
 200
 201         FD_ZERO(&fds);
 202
 203         /*
 204          * Ensure we process oplock break messages by preference.
 205          * We have to do this before the select, after the select
 206          * and if the select returns EINTR. This is due to the fact
 207          * that the selects called from async_processing can eat an EINTR
 208          * caused by a signal (we can't take the break message there).
 209          * This is hideously complex - *MUST* be simplified for 3.0 ! JRA.
 210          */
 211
 212         if (oplock_message_waiting(&fds)) {
 213                 DEBUG(10,("receive_message_or_smb: oplock_message is waiting.\n"));
 214                 async_processing(buffer, buffer_len);
 215                 /*
 216                  * After async processing we must go and do the select again, as
 217                  * the state of the flag in fds for the server file descriptor is
 218                  * indeterminate - we may have done I/O on it in the oplock processing. JRA.
 219                  */
 220                 goto again;
 221         }
 222
 223         FD_SET(smbd_server_fd(),&fds);
 224         maxfd = setup_oplock_select_set(&fds);
 225
 226         to.tv_sec = timeout / 1000;
 227         to.tv_usec = (timeout % 1000) * 1000;
 228
 229         selrtn = sys_select(MAX(maxfd,smbd_server_fd())+1,&fds,NULL,NULL,timeout>0?&to:NULL);
 230
 231         /* if we get EINTR then maybe we have received an oplock
 232            signal - treat this as select returning 1. This is ugly, but
 233            is the best we can do until the oplock code knows more about
 234            signals */
 235         if (selrtn == -1 && errno == EINTR) {
 236                 async_processing(buffer, buffer_len);
 237                 /*
 238                  * After async processing we must go and do the select again, as
 239                  * the state of the flag in fds for the server file descriptor is
 240                  * indeterminate - we may have done I/O on it in the oplock processing. JRA.
 241                  */
 242                 goto again;
 243         }
 244
 245         /* Check if error */
 246         if (selrtn == -1) {
 247                 /* something is wrong. Maybe the socket is dead? */
 248                 smb_read_error = READ_ERROR;
 249                 return False;
 250         }
 251
 252         /* Did we timeout ? */
 253         if (selrtn == 0) {
 254                 smb_read_error = READ_TIMEOUT;
 255                 return False;
 256         }
 257
 258         /*
 259          * Ensure we process oplock break messages by preference.
 260          * This is IMPORTANT ! Otherwise we can starve other processes
 261          * sending us an oplock break message. JRA.
 262          */
 263
 264         if (oplock_message_waiting(&fds)) {
 265                 DEBUG(10,("receive_message_or_smb: oplock_message is waiting.\n"));
 266                 async_processing(buffer, buffer_len);
 267                 /*
 268                  * After async processing we must go and do the select again, as
 269                  * the state of the flag in fds for the server file descriptor is
 270                  * indeterminate - we may have done I/O on it in the oplock processing. JRA.
 271                  */
 272                 goto again;
 273         }
 274
 275         return receive_smb(smbd_server_fd(), buffer, 0);
 276 }
 277
 278 /****************************************************************************
 279 Get the next SMB packet, doing the local message processing automatically.
 280 ****************************************************************************/
 281
 282 BOOL receive_next_smb(char *inbuf, int bufsize, int timeout)
 283 {
 284         BOOL got_keepalive;
 285         BOOL ret;
 286
 287         do {
 288                 ret = receive_message_or_smb(inbuf,bufsize,timeout);
 289
 290                 got_keepalive = (ret && (CVAL(inbuf,0) == 0x85));
 291         } while (ret && got_keepalive);
 292
 293         return ret;
 294 }
 295
 296 /****************************************************************************
 297  We're terminating and have closed all our files/connections etc.
 298  If there are any pending local messages we need to respond to them
 299  before termination so that other smbds don't think we just died whilst
 300  holding oplocks.
 301 ****************************************************************************/
 302
 303 void respond_to_all_remaining_local_messages(void)
 304 {
 305   char buffer[1024];
 306
 307   /*
 308    * Assert we have no exclusive open oplocks.
 309    */
 310
 311   if(get_number_of_exclusive_open_oplocks()) {
 312     DEBUG(0,("respond_to_all_remaining_local_messages: PANIC : we have %d exclusive oplocks.\n",
 313           get_number_of_exclusive_open_oplocks() ));
 314     return;
 315   }
 316
 317   /*
 318    * Keep doing receive_local_message with a 1 ms timeout until
 319    * we have no more messages.
 320    */
 321   while(receive_local_message(buffer, sizeof(buffer), 1)) {
 322           /* Deal with oplock break requests from other smbd's. */
 323           process_local_message(buffer, sizeof(buffer));
 324   }
 325
 326   return;
 327 }
 328
 329
 330 /*
 331 These flags determine some of the permissions required to do an operation
 332
 333 Note that I don't set NEED_WRITE on some write operations because they
 334 are used by some brain-dead clients when printing, and I don't want to
 335 force write permissions on print services.
 336 */
 337 #define AS_USER (1<<0)
 338 #define NEED_WRITE (1<<1)
 339 #define TIME_INIT (1<<2)
 340 #define CAN_IPC (1<<3)
 341 #define AS_GUEST (1<<5)
 342 #define QUEUE_IN_OPLOCK (1<<6)
 343
 344 /*
 345    define a list of possible SMB messages and their corresponding
 346    functions. Any message that has a NULL function is unimplemented -
 347    please feel free to contribute implementations!
 348 */
 349 struct smb_message_struct
 350 {
 351   char *name;
 352   int (*fn)(connection_struct *conn, char *, char *, int, int);
 353   int flags;
 354 }
 355  smb_messages[256] = {
 356
 357 /* 0x00 */ { "SMBmkdir",reply_mkdir,AS_USER | NEED_WRITE},
 358 /* 0x01 */ { "SMBrmdir",reply_rmdir,AS_USER | NEED_WRITE},
 359 /* 0x02 */ { "SMBopen",reply_open,AS_USER | QUEUE_IN_OPLOCK },
 360 /* 0x03 */ { "SMBcreate",reply_mknew,AS_USER},
 361 /* 0x04 */ { "SMBclose",reply_close,AS_USER | CAN_IPC },
 362 /* 0x05 */ { "SMBflush",reply_flush,AS_USER},
 363 /* 0x06 */ { "SMBunlink",reply_unlink,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
 364 /* 0x07 */ { "SMBmv",reply_mv,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
 365 /* 0x08 */ { "SMBgetatr",reply_getatr,AS_USER},
 366 /* 0x09 */ { "SMBsetatr",reply_setatr,AS_USER | NEED_WRITE},
 367 /* 0x0a */ { "SMBread",reply_read,AS_USER},
 368 /* 0x0b */ { "SMBwrite",reply_write,AS_USER | CAN_IPC },
 369 /* 0x0c */ { "SMBlock",reply_lock,AS_USER},
 370 /* 0x0d */ { "SMBunlock",reply_unlock,AS_USER},
 371 /* 0x0e */ { "SMBctemp",reply_ctemp,AS_USER | QUEUE_IN_OPLOCK },
 372 /* 0x0f */ { "SMBmknew",reply_mknew,AS_USER},
 373 /* 0x10 */ { "SMBchkpth",reply_chkpth,AS_USER},
 374 /* 0x11 */ { "SMBexit",reply_exit,0},
 375 /* 0x12 */ { "SMBlseek",reply_lseek,AS_USER},
 376 /* 0x13 */ { "SMBlockread",reply_lockread,AS_USER},
 377 /* 0x14 */ { "SMBwriteunlock",reply_writeunlock,AS_USER},
 378 /* 0x15 */ { NULL, NULL, 0 },
 379 /* 0x16 */ { NULL, NULL, 0 },
 380 /* 0x17 */ { NULL, NULL, 0 },
 381 /* 0x18 */ { NULL, NULL, 0 },
 382 /* 0x19 */ { NULL, NULL, 0 },
 383 /* 0x1a */ { "SMBreadbraw",reply_readbraw,AS_USER},
 384 /* 0x1b */ { "SMBreadBmpx",reply_readbmpx,AS_USER},
 385 /* 0x1c */ { "SMBreadBs",NULL,0},
 386 /* 0x1d */ { "SMBwritebraw",reply_writebraw,AS_USER},
 387 /* 0x1e */ { "SMBwriteBmpx",reply_writebmpx,AS_USER},
 388 /* 0x1f */ { "SMBwriteBs",reply_writebs,AS_USER},
 389 /* 0x20 */ { "SMBwritec",NULL,0},
 390 /* 0x21 */ { NULL, NULL, 0 },
 391 /* 0x22 */ { "SMBsetattrE",reply_setattrE,AS_USER | NEED_WRITE },
 392 /* 0x23 */ { "SMBgetattrE",reply_getattrE,AS_USER },
 393 /* 0x24 */ { "SMBlockingX",reply_lockingX,AS_USER },
 394 /* 0x25 */ { "SMBtrans",reply_trans,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
 395 /* 0x26 */ { "SMBtranss",NULL,AS_USER | CAN_IPC},
 396 /* 0x27 */ { "SMBioctl",reply_ioctl,0},
 397 /* 0x28 */ { "SMBioctls",NULL,AS_USER},
 398 /* 0x29 */ { "SMBcopy",reply_copy,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
 399 /* 0x2a */ { "SMBmove",NULL,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
 400 /* 0x2b */ { "SMBecho",reply_echo,0},
 401 /* 0x2c */ { "SMBwriteclose",reply_writeclose,AS_USER},
 402 /* 0x2d */ { "SMBopenX",reply_open_and_X,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
 403 /* 0x2e */ { "SMBreadX",reply_read_and_X,AS_USER | CAN_IPC },
 404 /* 0x2f */ { "SMBwriteX",reply_write_and_X,AS_USER | CAN_IPC },
 405 /* 0x30 */ { NULL, NULL, 0 },
 406 /* 0x31 */ { NULL, NULL, 0 },
 407 /* 0x32 */ { "SMBtrans2", reply_trans2, AS_USER | QUEUE_IN_OPLOCK | CAN_IPC },
 408 /* 0x33 */ { "SMBtranss2", reply_transs2, AS_USER},
 409 /* 0x34 */ { "SMBfindclose", reply_findclose,AS_USER},
 410 /* 0x35 */ { "SMBfindnclose", reply_findnclose, AS_USER},
 411 /* 0x36 */ { NULL, NULL, 0 },
 412 /* 0x37 */ { NULL, NULL, 0 },
 413 /* 0x38 */ { NULL, NULL, 0 },
 414 /* 0x39 */ { NULL, NULL, 0 },
 415 /* 0x3a */ { NULL, NULL, 0 },
 416 /* 0x3b */ { NULL, NULL, 0 },
 417 /* 0x3c */ { NULL, NULL, 0 },
 418 /* 0x3d */ { NULL, NULL, 0 },
 419 /* 0x3e */ { NULL, NULL, 0 },
 420 /* 0x3f */ { NULL, NULL, 0 },
 421 /* 0x40 */ { NULL, NULL, 0 },
 422 /* 0x41 */ { NULL, NULL, 0 },
 423 /* 0x42 */ { NULL, NULL, 0 },
 424 /* 0x43 */ { NULL, NULL, 0 },
 425 /* 0x44 */ { NULL, NULL, 0 },
 426 /* 0x45 */ { NULL, NULL, 0 },
 427 /* 0x46 */ { NULL, NULL, 0 },
 428 /* 0x47 */ { NULL, NULL, 0 },
 429 /* 0x48 */ { NULL, NULL, 0 },
 430 /* 0x49 */ { NULL, NULL, 0 },
 431 /* 0x4a */ { NULL, NULL, 0 },
 432 /* 0x4b */ { NULL, NULL, 0 },
 433 /* 0x4c */ { NULL, NULL, 0 },
 434 /* 0x4d */ { NULL, NULL, 0 },
 435 /* 0x4e */ { NULL, NULL, 0 },
 436 /* 0x4f */ { NULL, NULL, 0 },
 437 /* 0x50 */ { NULL, NULL, 0 },
 438 /* 0x51 */ { NULL, NULL, 0 },
 439 /* 0x52 */ { NULL, NULL, 0 },
 440 /* 0x53 */ { NULL, NULL, 0 },
 441 /* 0x54 */ { NULL, NULL, 0 },
 442 /* 0x55 */ { NULL, NULL, 0 },
 443 /* 0x56 */ { NULL, NULL, 0 },
 444 /* 0x57 */ { NULL, NULL, 0 },
 445 /* 0x58 */ { NULL, NULL, 0 },
 446 /* 0x59 */ { NULL, NULL, 0 },
 447 /* 0x5a */ { NULL, NULL, 0 },
 448 /* 0x5b */ { NULL, NULL, 0 },
 449 /* 0x5c */ { NULL, NULL, 0 },
 450 /* 0x5d */ { NULL, NULL, 0 },
 451 /* 0x5e */ { NULL, NULL, 0 },
 452 /* 0x5f */ { NULL, NULL, 0 },
 453 /* 0x60 */ { NULL, NULL, 0 },
 454 /* 0x61 */ { NULL, NULL, 0 },
 455 /* 0x62 */ { NULL, NULL, 0 },
 456 /* 0x63 */ { NULL, NULL, 0 },
 457 /* 0x64 */ { NULL, NULL, 0 },
 458 /* 0x65 */ { NULL, NULL, 0 },
 459 /* 0x66 */ { NULL, NULL, 0 },
 460 /* 0x67 */ { NULL, NULL, 0 },
 461 /* 0x68 */ { NULL, NULL, 0 },
 462 /* 0x69 */ { NULL, NULL, 0 },
 463 /* 0x6a */ { NULL, NULL, 0 },
 464 /* 0x6b */ { NULL, NULL, 0 },
 465 /* 0x6c */ { NULL, NULL, 0 },
 466 /* 0x6d */ { NULL, NULL, 0 },
 467 /* 0x6e */ { NULL, NULL, 0 },
 468 /* 0x6f */ { NULL, NULL, 0 },
 469 /* 0x70 */ { "SMBtcon",reply_tcon,0},
 470 /* 0x71 */ { "SMBtdis",reply_tdis,0},
 471 /* 0x72 */ { "SMBnegprot",reply_negprot,0},
 472 /* 0x73 */ { "SMBsesssetupX",reply_sesssetup_and_X,0},
 473 /* 0x74 */ { "SMBulogoffX", reply_ulogoffX, 0}, /* ulogoff doesn't give a valid TID */
 474 /* 0x75 */ { "SMBtconX",reply_tcon_and_X,0},
 475 /* 0x76 */ { NULL, NULL, 0 },
 476 /* 0x77 */ { NULL, NULL, 0 },
 477 /* 0x78 */ { NULL, NULL, 0 },
 478 /* 0x79 */ { NULL, NULL, 0 },
 479 /* 0x7a */ { NULL, NULL, 0 },
 480 /* 0x7b */ { NULL, NULL, 0 },
 481 /* 0x7c */ { NULL, NULL, 0 },
 482 /* 0x7d */ { NULL, NULL, 0 },
 483 /* 0x7e */ { NULL, NULL, 0 },
 484 /* 0x7f */ { NULL, NULL, 0 },
 485 /* 0x80 */ { "SMBdskattr",reply_dskattr,AS_USER},
 486 /* 0x81 */ { "SMBsearch",reply_search,AS_USER},
 487 /* 0x82 */ { "SMBffirst",reply_search,AS_USER},
 488 /* 0x83 */ { "SMBfunique",reply_search,AS_USER},
 489 /* 0x84 */ { "SMBfclose",reply_fclose,AS_USER},
 490 /* 0x85 */ { NULL, NULL, 0 },
 491 /* 0x86 */ { NULL, NULL, 0 },
 492 /* 0x87 */ { NULL, NULL, 0 },
 493 /* 0x88 */ { NULL, NULL, 0 },
 494 /* 0x89 */ { NULL, NULL, 0 },
 495 /* 0x8a */ { NULL, NULL, 0 },
 496 /* 0x8b */ { NULL, NULL, 0 },
 497 /* 0x8c */ { NULL, NULL, 0 },
 498 /* 0x8d */ { NULL, NULL, 0 },
 499 /* 0x8e */ { NULL, NULL, 0 },
 500 /* 0x8f */ { NULL, NULL, 0 },
 501 /* 0x90 */ { NULL, NULL, 0 },
 502 /* 0x91 */ { NULL, NULL, 0 },
 503 /* 0x92 */ { NULL, NULL, 0 },
 504 /* 0x93 */ { NULL, NULL, 0 },
 505 /* 0x94 */ { NULL, NULL, 0 },
 506 /* 0x95 */ { NULL, NULL, 0 },
 507 /* 0x96 */ { NULL, NULL, 0 },
 508 /* 0x97 */ { NULL, NULL, 0 },
 509 /* 0x98 */ { NULL, NULL, 0 },
 510 /* 0x99 */ { NULL, NULL, 0 },
 511 /* 0x9a */ { NULL, NULL, 0 },
 512 /* 0x9b */ { NULL, NULL, 0 },
 513 /* 0x9c */ { NULL, NULL, 0 },
 514 /* 0x9d */ { NULL, NULL, 0 },
 515 /* 0x9e */ { NULL, NULL, 0 },
 516 /* 0x9f */ { NULL, NULL, 0 },
 517 /* 0xa0 */ { "SMBnttrans", reply_nttrans, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
 518 /* 0xa1 */ { "SMBnttranss", reply_nttranss, AS_USER | CAN_IPC },
 519 /* 0xa2 */ { "SMBntcreateX", reply_ntcreate_and_X, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
 520 /* 0xa3 */ { NULL, NULL, 0 },
 521 /* 0xa4 */ { "SMBntcancel", reply_ntcancel, 0 },
 522 /* 0xa5 */ { NULL, NULL, 0 },
 523 /* 0xa6 */ { NULL, NULL, 0 },
 524 /* 0xa7 */ { NULL, NULL, 0 },
 525 /* 0xa8 */ { NULL, NULL, 0 },
 526 /* 0xa9 */ { NULL, NULL, 0 },
 527 /* 0xaa */ { NULL, NULL, 0 },
 528 /* 0xab */ { NULL, NULL, 0 },
 529 /* 0xac */ { NULL, NULL, 0 },
 530 /* 0xad */ { NULL, NULL, 0 },
 531 /* 0xae */ { NULL, NULL, 0 },
 532 /* 0xaf */ { NULL, NULL, 0 },
 533 /* 0xb0 */ { NULL, NULL, 0 },
 534 /* 0xb1 */ { NULL, NULL, 0 },
 535 /* 0xb2 */ { NULL, NULL, 0 },
 536 /* 0xb3 */ { NULL, NULL, 0 },
 537 /* 0xb4 */ { NULL, NULL, 0 },
 538 /* 0xb5 */ { NULL, NULL, 0 },
 539 /* 0xb6 */ { NULL, NULL, 0 },
 540 /* 0xb7 */ { NULL, NULL, 0 },
 541 /* 0xb8 */ { NULL, NULL, 0 },
 542 /* 0xb9 */ { NULL, NULL, 0 },
 543 /* 0xba */ { NULL, NULL, 0 },
 544 /* 0xbb */ { NULL, NULL, 0 },
 545 /* 0xbc */ { NULL, NULL, 0 },
 546 /* 0xbd */ { NULL, NULL, 0 },
 547 /* 0xbe */ { NULL, NULL, 0 },
 548 /* 0xbf */ { NULL, NULL, 0 },
 549 /* 0xc0 */ { "SMBsplopen",reply_printopen,AS_USER | QUEUE_IN_OPLOCK },
 550 /* 0xc1 */ { "SMBsplwr",reply_printwrite,AS_USER},
 551 /* 0xc2 */ { "SMBsplclose",reply_printclose,AS_USER},
 552 /* 0xc3 */ { "SMBsplretq",reply_printqueue,AS_USER},
 553 /* 0xc4 */ { NULL, NULL, 0 },
 554 /* 0xc5 */ { NULL, NULL, 0 },
 555 /* 0xc6 */ { NULL, NULL, 0 },
 556 /* 0xc7 */ { NULL, NULL, 0 },
 557 /* 0xc8 */ { NULL, NULL, 0 },
 558 /* 0xc9 */ { NULL, NULL, 0 },
 559 /* 0xca */ { NULL, NULL, 0 },
 560 /* 0xcb */ { NULL, NULL, 0 },
 561 /* 0xcc */ { NULL, NULL, 0 },
 562 /* 0xcd */ { NULL, NULL, 0 },
 563 /* 0xce */ { NULL, NULL, 0 },
 564 /* 0xcf */ { NULL, NULL, 0 },
 565 /* 0xd0 */ { "SMBsends",reply_sends,AS_GUEST},
 566 /* 0xd1 */ { "SMBsendb",NULL,AS_GUEST},
 567 /* 0xd2 */ { "SMBfwdname",NULL,AS_GUEST},
 568 /* 0xd3 */ { "SMBcancelf",NULL,AS_GUEST},
 569 /* 0xd4 */ { "SMBgetmac",NULL,AS_GUEST},
 570 /* 0xd5 */ { "SMBsendstrt",reply_sendstrt,AS_GUEST},
 571 /* 0xd6 */ { "SMBsendend",reply_sendend,AS_GUEST},
 572 /* 0xd7 */ { "SMBsendtxt",reply_sendtxt,AS_GUEST},
 573 /* 0xd8 */ { NULL, NULL, 0 },
 574 /* 0xd9 */ { NULL, NULL, 0 },
 575 /* 0xda */ { NULL, NULL, 0 },
 576 /* 0xdb */ { NULL, NULL, 0 },
 577 /* 0xdc */ { NULL, NULL, 0 },
 578 /* 0xdd */ { NULL, NULL, 0 },
 579 /* 0xde */ { NULL, NULL, 0 },
 580 /* 0xdf */ { NULL, NULL, 0 },
 581 /* 0xe0 */ { NULL, NULL, 0 },
 582 /* 0xe1 */ { NULL, NULL, 0 },
 583 /* 0xe2 */ { NULL, NULL, 0 },
 584 /* 0xe3 */ { NULL, NULL, 0 },
 585 /* 0xe4 */ { NULL, NULL, 0 },
 586 /* 0xe5 */ { NULL, NULL, 0 },
 587 /* 0xe6 */ { NULL, NULL, 0 },
 588 /* 0xe7 */ { NULL, NULL, 0 },
 589 /* 0xe8 */ { NULL, NULL, 0 },
 590 /* 0xe9 */ { NULL, NULL, 0 },
 591 /* 0xea */ { NULL, NULL, 0 },
 592 /* 0xeb */ { NULL, NULL, 0 },
 593 /* 0xec */ { NULL, NULL, 0 },
 594 /* 0xed */ { NULL, NULL, 0 },
 595 /* 0xee */ { NULL, NULL, 0 },
 596 /* 0xef */ { NULL, NULL, 0 },
 597 /* 0xf0 */ { NULL, NULL, 0 },
 598 /* 0xf1 */ { NULL, NULL, 0 },
 599 /* 0xf2 */ { NULL, NULL, 0 },
 600 /* 0xf3 */ { NULL, NULL, 0 },
 601 /* 0xf4 */ { NULL, NULL, 0 },
 602 /* 0xf5 */ { NULL, NULL, 0 },
 603 /* 0xf6 */ { NULL, NULL, 0 },
 604 /* 0xf7 */ { NULL, NULL, 0 },
 605 /* 0xf8 */ { NULL, NULL, 0 },
 606 /* 0xf9 */ { NULL, NULL, 0 },
 607 /* 0xfa */ { NULL, NULL, 0 },
 608 /* 0xfb */ { NULL, NULL, 0 },
 609 /* 0xfc */ { NULL, NULL, 0 },
 610 /* 0xfd */ { NULL, NULL, 0 },
 611 /* 0xfe */ { NULL, NULL, 0 },
 612 /* 0xff */ { NULL, NULL, 0 }
 613
 614 };
 615
 616 /*******************************************************************
 617 dump a prs to a file
 618  ********************************************************************/
 619 static void smb_dump(char *name, int type, char *data, ssize_t len)
 620 {
 621         int fd, i;
 622         pstring fname;
 623         if (DEBUGLEVEL < 50) return;
 624
 625         if (len < 4) len = smb_len(data)+4;
 626         for (i=1;i<100;i++) {
 627                 slprintf(fname,sizeof(fname)-1, "/tmp/%s.%d.%s", name, i,
 628                                 type ? "req" : "resp");
 629                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
 630                 if (fd != -1 || errno != EEXIST) break;
 631         }
 632         if (fd != -1) {
 633                 ssize_t ret = write(fd, data, len);
 634                 if (ret != len)
 635                         DEBUG(0,("smb_dump: problem: write returned %d\n", (int)ret ));
 636                 close(fd);
 637                 DEBUG(0,("created %s len %d\n", fname, len));
 638         }
 639 }
 640
 641
 642 /****************************************************************************
 643 do a switch on the message type, and return the response size
 644 ****************************************************************************/
 645 static int switch_message(int type,char *inbuf,char *outbuf,int size,int bufsize)
 646 {
 647   static pid_t pid= (pid_t)-1;
 648   int outsize = 0;
 649   extern uint16 global_smbpid;
 650
 651   type &= 0xff;
 652
 653   if (pid == (pid_t)-1)
 654     pid = sys_getpid();
 655
 656   errno = 0;
 657   last_message = type;
 658
 659   /* make sure this is an SMB packet */
 660   if (strncmp(smb_base(inbuf),"\377SMB",4) != 0)
 661   {
 662     DEBUG(2,("Non-SMB packet of length %d\n",smb_len(inbuf)));
 663     return(-1);
 664   }
 665
 666   /* yuck! this is an interim measure before we get rid of our
 667      current inbuf/outbuf system */
 668   global_smbpid = SVAL(inbuf,smb_pid);
 669
 670   if (smb_messages[type].fn == NULL)
 671   {
 672     DEBUG(0,("Unknown message type %d!\n",type));
 673     smb_dump("Unknown", 1, inbuf, size);
 674     outsize = reply_unknown(inbuf,outbuf);
 675   }
 676   else
 677   {
 678     int flags = smb_messages[type].flags;
 679     static uint16 last_session_tag = UID_FIELD_INVALID;
 680     /* In share mode security we must ignore the vuid. */
 681     uint16 session_tag = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(inbuf,smb_uid);
 682     connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 683
 684     DEBUG(3,("switch message %s (pid %d)\n",smb_fn_name(type),(int)pid));
 685
 686     smb_dump(smb_fn_name(type), 1, inbuf, size);
 687     if(global_oplock_break)
 688     {
 689       if(flags & QUEUE_IN_OPLOCK)
 690       {
 691         /*
 692          * Queue this message as we are the process of an oplock break.
 693          */
 694
 695         DEBUG( 2, ( "switch_message: queueing message due to being in " ) );
 696         DEBUGADD( 2, ( "oplock break state.\n" ) );
 697
 698         push_oplock_pending_smb_message( inbuf, size );
 699         return -1;
 700       }
 701     }
 702
 703     /* Ensure this value is replaced in the incoming packet. */
 704     SSVAL(inbuf,smb_uid,session_tag);
 705
 706     /*
 707      * Ensure the correct username is in current_user_info.
 708      * This is a really ugly bugfix for problems with
 709      * multiple session_setup_and_X's being done and
 710      * allowing %U and %G substitutions to work correctly.
 711      * There is a reason this code is done here, don't
 712      * move it unless you know what you're doing... :-).
 713      * JRA.
 714      */
 715
 716     if (session_tag != last_session_tag) {
 717       user_struct *vuser = NULL;
 718
 719       last_session_tag = session_tag;
 720       if(session_tag != UID_FIELD_INVALID)
 721         vuser = get_valid_user_struct(session_tag);
 722       if(vuser != NULL)
 723         current_user_info = vuser->user;
 724     }
 725
 726     /* does this protocol need to be run as root? */
 727     if (!(flags & AS_USER))
 728       change_to_root_user();
 729
 730     /* does this protocol need a valid tree connection? */
 731     if ((flags & AS_USER) && !conn) {
 732             return ERROR_DOS(ERRSRV, ERRinvnid);
 733     }
 734
 735
 736     /* does this protocol need to be run as the connected user? */
 737     if ((flags & AS_USER) && !change_to_user(conn,session_tag)) {
 738       if (flags & AS_GUEST)
 739         flags &= ~AS_USER;
 740       else
 741         return(ERROR_DOS(ERRSRV,ERRaccess));
 742     }
 743
 744     /* this code is to work around a bug is MS client 3 without
 745        introducing a security hole - it needs to be able to do
 746        print queue checks as guest if it isn't logged in properly */
 747     if (flags & AS_USER)
 748       flags &= ~AS_GUEST;
 749
 750     /* does it need write permission? */
 751     if ((flags & NEED_WRITE) && !CAN_WRITE(conn))
 752       return(ERROR_DOS(ERRSRV,ERRaccess));
 753
 754     /* ipc services are limited */
 755     if (IS_IPC(conn) && (flags & AS_USER) && !(flags & CAN_IPC)) {
 756       return(ERROR_DOS(ERRSRV,ERRaccess));
 757     }
 758
 759     /* load service specific parameters */
 760     if (conn && !set_current_service(conn,(flags & AS_USER)?True:False)) {
 761       return(ERROR_DOS(ERRSRV,ERRaccess));
 762     }
 763
 764     /* does this protocol need to be run as guest? */
 765     if ((flags & AS_GUEST) &&
 766                  (!change_to_guest() ||
 767                 !check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1)))) {
 768       return(ERROR_DOS(ERRSRV,ERRaccess));
 769     }
 770
 771     last_inbuf = inbuf;
 772
 773     outsize = smb_messages[type].fn(conn, inbuf,outbuf,size,bufsize);
 774   }
 775
 776   smb_dump(smb_fn_name(type), 0, outbuf, outsize);
 777
 778   return(outsize);
 779 }
 780
 781
 782 /****************************************************************************
 783   construct a reply to the incoming packet
 784 ****************************************************************************/
 785 static int construct_reply(char *inbuf,char *outbuf,int size,int bufsize)
 786 {
 787   int type = CVAL(inbuf,smb_com);
 788   int outsize = 0;
 789   int msg_type = CVAL(inbuf,0);
 790
 791   GetTimeOfDay(&smb_last_time);
 792
 793   chain_size = 0;
 794   file_chain_reset();
 795   reset_chain_p();
 796
 797   if (msg_type != 0)
 798     return(reply_special(inbuf,outbuf));
 799
 800   construct_reply_common(inbuf, outbuf);
 801
 802   outsize = switch_message(type,inbuf,outbuf,size,bufsize);
 803
 804   outsize += chain_size;
 805
 806   if(outsize > 4)
 807     smb_setlen(outbuf,outsize - 4);
 808   return(outsize);
 809 }
 810
 811 /****************************************************************************
 812   Keep track of the number of running smbd's. This functionality is used to
 813   'hard' limit Samba overhead on resource constrained systems.
 814 ****************************************************************************/
 815 static BOOL smbd_process_limit(void)
 816 {
 817         int32  total_smbds;
 818
 819         if (lp_max_smbd_processes()) {
 820
 821                 /* Always add one to the smbd process count, as exit_server() always
 822                  * subtracts one.
 823                  */
 824
 825                 total_smbds = 1; /* In case we need to create the entry. */
 826
 827                 if (!conn_tdb_ctx()) {
 828                         DEBUG(0,("smbd_process_limit: max smbd processes parameter set with status parameter not \
 829 set. Ignoring max smbd restriction.\n"));
 830                         return False;
 831                 }
 832
 833                 if (tdb_change_int32_atomic(conn_tdb_ctx(), "INFO/total_smbds", &total_smbds, 1) == -1)
 834                         return True;
 835
 836                 return total_smbds > lp_max_smbd_processes();
 837         }
 838         else
 839                 return False;
 840 }
 841
 842 /****************************************************************************
 843   process an smb from the client - split out from the process() code so
 844   it can be used by the oplock break code.
 845 ****************************************************************************/
 846 void process_smb(char *inbuf, char *outbuf)
 847 {
 848 #ifdef WITH_SSL
 849   extern BOOL sslEnabled;     /* don't use function for performance reasons */
 850   static int sslConnected = 0;
 851 #endif /* WITH_SSL */
 852   static int trans_num;
 853   int msg_type = CVAL(inbuf,0);
 854   int32 len = smb_len(inbuf);
 855   int nread = len + 4;
 856
 857   DO_PROFILE_INC(smb_count);
 858
 859   if (trans_num == 0) {
 860           /* on the first packet, check the global hosts allow/ hosts
 861              deny parameters before doing any parsing of the packet
 862              passed to us by the client.  This prevents attacks on our
 863              parsing code from hosts not in the hosts allow list */
 864           if (smbd_process_limit() ||
 865                   !check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1))) {
 866                   /* send a negative session response "not listening on calling
 867                    name" */
 868                   static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
 869                   DEBUG( 1, ( "Connection denied from %s\n",
 870                               client_addr() ) );
 871                   (void)send_smb(smbd_server_fd(),(char *)buf);
 872                   exit_server("connection denied");
 873           }
 874   }
 875
 876   DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type, len ) );
 877   DEBUG( 3, ( "Transaction %d of length %d\n", trans_num, nread ) );
 878
 879 #ifdef WITH_SSL
 880     if(sslEnabled && !sslConnected){
 881         sslConnected = sslutil_negotiate_ssl(smbd_server_fd(), msg_type);
 882         if(sslConnected < 0){   /* an error occured */
 883             exit_server("SSL negotiation failed");
 884         }else if(sslConnected){
 885             trans_num++;
 886             return;
 887         }
 888     }
 889 #endif  /* WITH_SSL */
 890
 891   if (msg_type == 0)
 892     show_msg(inbuf);
 893   else if(msg_type == 0x85)
 894     return; /* Keepalive packet. */
 895
 896   nread = construct_reply(inbuf,outbuf,nread,max_send);
 897
 898   if(nread > 0)
 899   {
 900     if (CVAL(outbuf,0) == 0)
 901       show_msg(outbuf);
 902
 903     if (nread != smb_len(outbuf) + 4)
 904     {
 905       DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
 906                  nread, smb_len(outbuf)));
 907     }
 908     else
 909       if (!send_smb(smbd_server_fd(),outbuf))
 910         exit_server("process_smb: send_smb failed.\n");
 911   }
 912   trans_num++;
 913 }
 914
 915
 916
 917 /****************************************************************************
 918 return a string containing the function name of a SMB command
 919 ****************************************************************************/
 920 char *smb_fn_name(int type)
 921 {
 922         static char *unknown_name = "SMBunknown";
 923
 924         if (smb_messages[type].name == NULL)
 925                 return(unknown_name);
 926
 927         return(smb_messages[type].name);
 928 }
 929
 930
 931 /****************************************************************************
 932  Helper function for contruct_reply.
 933 ****************************************************************************/
 934
 935 void construct_reply_common(char *inbuf,char *outbuf)
 936 {
 937   memset(outbuf,'\0',smb_size);
 938
 939   set_message(outbuf,0,0,True);
 940   SCVAL(outbuf,smb_com,CVAL(inbuf,smb_com));
 941
 942   memcpy(outbuf+4,inbuf+4,4);
 943   SCVAL(outbuf,smb_rcls,SMB_SUCCESS);
 944   SCVAL(outbuf,smb_reh,0);
 945   SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES)); /* bit 7 set
 946                                  means a reply */
 947   SSVAL(outbuf,smb_flg2,FLAGS2_LONG_PATH_COMPONENTS);
 948         /* say we support long filenames */
 949
 950   SSVAL(outbuf,smb_err,SMB_SUCCESS);
 951   SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
 952   SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
 953   SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
 954   SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
 955 }
 956
 957 /****************************************************************************
 958   construct a chained reply and add it to the already made reply
 959   **************************************************************************/
 960 int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
 961 {
 962   static char *orig_inbuf;
 963   static char *orig_outbuf;
 964   int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
 965   unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
 966   char *inbuf2, *outbuf2;
 967   int outsize2;
 968   char inbuf_saved[smb_wct];
 969   char outbuf_saved[smb_wct];
 970   int wct = CVAL(outbuf,smb_wct);
 971   int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
 972
 973   /* maybe its not chained */
 974   if (smb_com2 == 0xFF) {
 975     SCVAL(outbuf,smb_vwv0,0xFF);
 976     return outsize;
 977   }
 978
 979   if (chain_size == 0) {
 980     /* this is the first part of the chain */
 981     orig_inbuf = inbuf;
 982     orig_outbuf = outbuf;
 983   }
 984
 985   /*
 986    * The original Win95 redirector dies on a reply to
 987    * a lockingX and read chain unless the chain reply is
 988    * 4 byte aligned. JRA.
 989    */
 990
 991   outsize = (outsize + 3) & ~3;
 992
 993   /* we need to tell the client where the next part of the reply will be */
 994   SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
 995   SCVAL(outbuf,smb_vwv0,smb_com2);
 996
 997   /* remember how much the caller added to the chain, only counting stuff
 998      after the parameter words */
 999   chain_size += outsize - smb_wct;
1000
1001   /* work out pointers into the original packets. The
1002      headers on these need to be filled in */
1003   inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
1004   outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
1005
1006   /* remember the original command type */
1007   smb_com1 = CVAL(orig_inbuf,smb_com);
1008
1009   /* save the data which will be overwritten by the new headers */
1010   memcpy(inbuf_saved,inbuf2,smb_wct);
1011   memcpy(outbuf_saved,outbuf2,smb_wct);
1012
1013   /* give the new packet the same header as the last part of the SMB */
1014   memmove(inbuf2,inbuf,smb_wct);
1015
1016   /* create the in buffer */
1017   SCVAL(inbuf2,smb_com,smb_com2);
1018
1019   /* create the out buffer */
1020   construct_reply_common(inbuf2, outbuf2);
1021
1022   DEBUG(3,("Chained message\n"));
1023   show_msg(inbuf2);
1024
1025   /* process the request */
1026   outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
1027                             bufsize-chain_size);
1028
1029   /* copy the new reply and request headers over the old ones, but
1030      preserve the smb_com field */
1031   memmove(orig_outbuf,outbuf2,smb_wct);
1032   SCVAL(orig_outbuf,smb_com,smb_com1);
1033
1034   /* restore the saved data, being careful not to overwrite any
1035    data from the reply header */
1036   memcpy(inbuf2,inbuf_saved,smb_wct);
1037   {
1038     int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
1039     if (ofs < 0) ofs = 0;
1040     memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
1041   }
1042
1043   return outsize2;
1044 }
1045
1046 /****************************************************************************
1047  Setup the needed select timeout.
1048 ****************************************************************************/
1049
1050 static int setup_select_timeout(void)
1051 {
1052         int select_timeout;
1053         int t;
1054
1055         /*
1056          * Increase the select timeout back to SMBD_SELECT_TIMEOUT if we
1057          * have removed any blocking locks. JRA.
1058          */
1059
1060         select_timeout = blocking_locks_pending() ? SMBD_SELECT_TIMEOUT_WITH_PENDING_LOCKS*1000 :
1061                 SMBD_SELECT_TIMEOUT*1000;
1062
1063         t = change_notify_timeout();
1064         if (t != -1) select_timeout = MIN(select_timeout, t*1000);
1065
1066         return select_timeout;
1067 }
1068
1069 /****************************************************************************
1070  Check if services need reloading.
1071 ****************************************************************************/
1072
1073 void check_reload(int t)
1074 {
1075   static time_t last_smb_conf_reload_time = 0;
1076
1077   if(last_smb_conf_reload_time == 0)
1078     last_smb_conf_reload_time = t;
1079
1080   if (reload_after_sighup || (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK))
1081   {
1082     reload_services(True);
1083     reload_after_sighup = 0;
1084     last_smb_conf_reload_time = t;
1085   }
1086 }
1087
1088 /****************************************************************************
1089  Process any timeout housekeeping. Return False if the caller should exit.
1090 ****************************************************************************/
1091
1092 static BOOL timeout_processing(int deadtime, int *select_timeout, time_t *last_timeout_processing_time)
1093 {
1094   static time_t last_keepalive_sent_time = 0;
1095   static time_t last_idle_closed_check = 0;
1096   time_t t;
1097   BOOL allidle = True;
1098   extern int keepalive;
1099
1100   if (smb_read_error == READ_EOF)
1101   {
1102     DEBUG(3,("end of file from client\n"));
1103     return False;
1104   }
1105
1106   if (smb_read_error == READ_ERROR)
1107   {
1108     DEBUG(3,("receive_smb error (%s) exiting\n",
1109               strerror(errno)));
1110     return False;
1111   }
1112
1113   *last_timeout_processing_time = t = time(NULL);
1114
1115   if(last_keepalive_sent_time == 0)
1116     last_keepalive_sent_time = t;
1117
1118   if(last_idle_closed_check == 0)
1119     last_idle_closed_check = t;
1120
1121   /* become root again if waiting */
1122   change_to_root_user();
1123
1124   /* check if we need to reload services */
1125   check_reload(t);
1126
1127   /* automatic timeout if all connections are closed */
1128   if (conn_num_open()==0 && (t - last_idle_closed_check) >= IDLE_CLOSED_TIMEOUT)
1129   {
1130     DEBUG( 2, ( "Closing idle connection\n" ) );
1131     return False;
1132   }
1133   else
1134     last_idle_closed_check = t;
1135
1136   if (keepalive && (t - last_keepalive_sent_time)>keepalive)
1137   {
1138     struct cli_state *cli = server_client();
1139     if (!send_keepalive(smbd_server_fd())) {
1140       DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1141       return False;
1142     }
1143     /* also send a keepalive to the password server if its still
1144        connected */
1145     if (cli && cli->initialised)
1146       if (!send_keepalive(cli->fd)) {
1147         DEBUG( 2, ( "password server keepalive failed.\n"));
1148         cli_shutdown(cli);
1149       }
1150     last_keepalive_sent_time = t;
1151   }
1152
1153   /* check for connection timeouts */
1154   allidle = conn_idle_all(t, deadtime);
1155
1156   if (allidle && conn_num_open()>0) {
1157     DEBUG(2,("Closing idle connection 2.\n"));
1158     return False;
1159   }
1160
1161   if(global_machine_password_needs_changing && lp_security() == SEC_DOMAIN)
1162   {
1163     unsigned char trust_passwd_hash[16];
1164     time_t lct;
1165     pstring remote_machine_list;
1166
1167     /*
1168      * We're in domain level security, and the code that
1169      * read the machine password flagged that the machine
1170      * password needs changing.
1171      */
1172
1173     /*
1174      * First, open the machine password file with an exclusive lock.
1175      */
1176
1177     if(!secrets_fetch_trust_account_password(global_myworkgroup, trust_passwd_hash, &lct)) {
1178       DEBUG(0,("process: unable to read the machine account password for \
1179 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
1180       return True;
1181     }
1182
1183     /*
1184      * Make sure someone else hasn't already done this.
1185      */
1186
1187     if(t < lct + lp_machine_password_timeout()) {
1188       global_machine_password_needs_changing = False;
1189       return True;
1190     }
1191
1192     pstrcpy(remote_machine_list, lp_passwordserver());
1193
1194     change_trust_account_password( global_myworkgroup, remote_machine_list);
1195     global_machine_password_needs_changing = False;
1196   }
1197
1198   /*
1199    * Check to see if we have any blocking locks
1200    * outstanding on the queue.
1201    */
1202   process_blocking_lock_queue(t);
1203
1204   /*
1205    * Check to see if we have any change notifies
1206    * outstanding on the queue.
1207    */
1208   process_pending_change_notify_queue(t);
1209
1210   /*
1211    * Now we are root, check if the log files need pruning.
1212    * Force a log file check.
1213    */
1214   force_check_log_size();
1215   check_log_size();
1216
1217   /*
1218    * Modify the select timeout depending upon
1219    * what we have remaining in our queues.
1220    */
1221
1222   *select_timeout = setup_select_timeout();
1223
1224   return True;
1225 }
1226
1227 /****************************************************************************
1228   process commands from the client
1229 ****************************************************************************/
1230
1231 void smbd_process(void)
1232 {
1233         extern int smb_echo_count;
1234         time_t last_timeout_processing_time = time(NULL);
1235         unsigned int num_smbs = 0;
1236
1237         InBuffer = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN);
1238         OutBuffer = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN);
1239         if ((InBuffer == NULL) || (OutBuffer == NULL))
1240                 return;
1241
1242         InBuffer += SMB_ALIGNMENT;
1243         OutBuffer += SMB_ALIGNMENT;
1244
1245         max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
1246
1247         /* re-initialise the timezone */
1248         TimeInit();
1249
1250         /* register our message handlers */
1251         message_register(MSG_SMB_FORCE_TDIS, msg_force_tdis);
1252
1253         while (True) {
1254                 int deadtime = lp_deadtime()*60;
1255                 int select_timeout = setup_select_timeout();
1256                 int num_echos;
1257
1258                 if (deadtime <= 0)
1259                         deadtime = DEFAULT_SMBD_TIMEOUT;
1260
1261                 errno = 0;
1262
1263                 /* free up temporary memory */
1264                 lp_talloc_free();
1265                 main_loop_talloc_free();
1266
1267                 while (!receive_message_or_smb(InBuffer,BUFFER_SIZE+LARGE_WRITEX_HDR_SIZE,select_timeout)) {
1268                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1269                                 return;
1270                         num_smbs = 0; /* Reset smb counter. */
1271                 }
1272
1273                 /*
1274                  * Ensure we do timeout processing if the SMB we just got was
1275                  * only an echo request. This allows us to set the select
1276                  * timeout in 'receive_message_or_smb()' to any value we like
1277                  * without worrying that the client will send echo requests
1278                  * faster than the select timeout, thus starving out the
1279                  * essential processing (change notify, blocking locks) that
1280                  * the timeout code does. JRA.
1281                  */
1282                 num_echos = smb_echo_count;
1283
1284                 process_smb(InBuffer, OutBuffer);
1285
1286                 if (smb_echo_count != num_echos) {
1287                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1288                                 return;
1289                         num_smbs = 0; /* Reset smb counter. */
1290                 }
1291
1292                 num_smbs++;
1293
1294                 /*
1295                  * If we are getting smb requests in a constant stream
1296                  * with no echos, make sure we attempt timeout processing
1297                  * every select_timeout milliseconds - but only check for this
1298                  * every 200 smb requests.
1299                  */
1300
1301                 if ((num_smbs % 200) == 0) {
1302                         time_t new_check_time = time(NULL);
1303                         if(new_check_time - last_timeout_processing_time >= (select_timeout/1000)) {
1304                                 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1305                                         return;
1306                                 num_smbs = 0; /* Reset smb counter. */
1307                                 last_timeout_processing_time = new_check_time; /* Reset time. */
1308                         }
1309                 }
1310         }
1311 }