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