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 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), "/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                 tdb_lock_bystring(conn_tdb_ctx(), "INFO/total_smbds");
 785                 total_smbds = tdb_fetch_int(conn_tdb_ctx(), "INFO/total_smbds");
 786                 total_smbds = total_smbds < 0 ? 1 : total_smbds + 1;
 787                 tdb_store_int(conn_tdb_ctx(), "INFO/total_smbds", total_smbds);
 788                 tdb_unlock_bystring(conn_tdb_ctx(), "INFO/total_smbds");
 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                   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       send_smb(smbd_server_fd(),outbuf);
 864   }
 865   trans_num++;
 866 }
 867
 868
 869
 870 /****************************************************************************
 871 return a string containing the function name of a SMB command
 872 ****************************************************************************/
 873 char *smb_fn_name(int type)
 874 {
 875         static char *unknown_name = "SMBunknown";
 876
 877         if (smb_messages[type].name == NULL)
 878                 return(unknown_name);
 879
 880         return(smb_messages[type].name);
 881 }
 882
 883
 884 /****************************************************************************
 885  Helper function for contruct_reply.
 886 ****************************************************************************/
 887
 888 void construct_reply_common(char *inbuf,char *outbuf)
 889 {
 890   memset(outbuf,'\0',smb_size);
 891
 892   set_message(outbuf,0,0,True);
 893   CVAL(outbuf,smb_com) = CVAL(inbuf,smb_com);
 894
 895   memcpy(outbuf+4,inbuf+4,4);
 896   CVAL(outbuf,smb_rcls) = SMB_SUCCESS;
 897   CVAL(outbuf,smb_reh) = 0;
 898   SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES)); /* bit 7 set
 899                                  means a reply */
 900   SSVAL(outbuf,smb_flg2,
 901         (SVAL(inbuf,smb_flg2)&FLAGS2_UNICODE_STRINGS) | FLAGS2_LONG_PATH_COMPONENTS);
 902         /* say we support long filenames */
 903
 904   SSVAL(outbuf,smb_err,SMB_SUCCESS);
 905   SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
 906   SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
 907   SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
 908   SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
 909 }
 910
 911 /****************************************************************************
 912   construct a chained reply and add it to the already made reply
 913   **************************************************************************/
 914 int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
 915 {
 916   static char *orig_inbuf;
 917   static char *orig_outbuf;
 918   int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
 919   unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
 920   char *inbuf2, *outbuf2;
 921   int outsize2;
 922   char inbuf_saved[smb_wct];
 923   char outbuf_saved[smb_wct];
 924   int wct = CVAL(outbuf,smb_wct);
 925   int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
 926
 927   /* maybe its not chained */
 928   if (smb_com2 == 0xFF) {
 929     CVAL(outbuf,smb_vwv0) = 0xFF;
 930     return outsize;
 931   }
 932
 933   if (chain_size == 0) {
 934     /* this is the first part of the chain */
 935     orig_inbuf = inbuf;
 936     orig_outbuf = outbuf;
 937   }
 938
 939   /*
 940    * The original Win95 redirector dies on a reply to
 941    * a lockingX and read chain unless the chain reply is
 942    * 4 byte aligned. JRA.
 943    */
 944
 945   outsize = (outsize + 3) & ~3;
 946
 947   /* we need to tell the client where the next part of the reply will be */
 948   SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
 949   CVAL(outbuf,smb_vwv0) = smb_com2;
 950
 951   /* remember how much the caller added to the chain, only counting stuff
 952      after the parameter words */
 953   chain_size += outsize - smb_wct;
 954
 955   /* work out pointers into the original packets. The
 956      headers on these need to be filled in */
 957   inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
 958   outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
 959
 960   /* remember the original command type */
 961   smb_com1 = CVAL(orig_inbuf,smb_com);
 962
 963   /* save the data which will be overwritten by the new headers */
 964   memcpy(inbuf_saved,inbuf2,smb_wct);
 965   memcpy(outbuf_saved,outbuf2,smb_wct);
 966
 967   /* give the new packet the same header as the last part of the SMB */
 968   memmove(inbuf2,inbuf,smb_wct);
 969
 970   /* create the in buffer */
 971   CVAL(inbuf2,smb_com) = smb_com2;
 972
 973   /* create the out buffer */
 974   construct_reply_common(inbuf2, outbuf2);
 975
 976   DEBUG(3,("Chained message\n"));
 977   show_msg(inbuf2);
 978
 979   /* process the request */
 980   outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
 981                             bufsize-chain_size);
 982
 983   /* copy the new reply and request headers over the old ones, but
 984      preserve the smb_com field */
 985   memmove(orig_outbuf,outbuf2,smb_wct);
 986   CVAL(orig_outbuf,smb_com) = smb_com1;
 987
 988   /* restore the saved data, being careful not to overwrite any
 989    data from the reply header */
 990   memcpy(inbuf2,inbuf_saved,smb_wct);
 991   {
 992     int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
 993     if (ofs < 0) ofs = 0;
 994     memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
 995   }
 996
 997   return outsize2;
 998 }
 999
1000 /****************************************************************************
1001  Setup the needed select timeout.
1002 ****************************************************************************/
1003
1004 static int setup_select_timeout(void)
1005 {
1006         int select_timeout;
1007         int t;
1008
1009         /*
1010          * Increase the select timeout back to SMBD_SELECT_TIMEOUT if we
1011          * have removed any blocking locks. JRA.
1012          */
1013
1014         select_timeout = blocking_locks_pending() ? SMBD_SELECT_TIMEOUT_WITH_PENDING_LOCKS*1000 :
1015                 SMBD_SELECT_TIMEOUT*1000;
1016
1017         t = change_notify_timeout();
1018         if (t != -1) select_timeout = MIN(select_timeout, t*1000);
1019
1020         return select_timeout;
1021 }
1022
1023 /****************************************************************************
1024  Check if services need reloading.
1025 ****************************************************************************/
1026
1027 void check_reload(int t)
1028 {
1029   static time_t last_smb_conf_reload_time = 0;
1030
1031   if(last_smb_conf_reload_time == 0)
1032     last_smb_conf_reload_time = t;
1033
1034   if (reload_after_sighup || (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK))
1035   {
1036     reload_services(True);
1037     reload_after_sighup = False;
1038     last_smb_conf_reload_time = t;
1039   }
1040 }
1041
1042 /****************************************************************************
1043  Process any timeout housekeeping. Return False if the caller should exit.
1044 ****************************************************************************/
1045
1046 static BOOL timeout_processing(int deadtime, int *select_timeout, time_t *last_timeout_processing_time)
1047 {
1048   static time_t last_keepalive_sent_time = 0;
1049   static time_t last_idle_closed_check = 0;
1050   time_t t;
1051   BOOL allidle = True;
1052   extern int keepalive;
1053
1054   if (smb_read_error == READ_EOF)
1055   {
1056     DEBUG(3,("end of file from client\n"));
1057     return False;
1058   }
1059
1060   if (smb_read_error == READ_ERROR)
1061   {
1062     DEBUG(3,("receive_smb error (%s) exiting\n",
1063               strerror(errno)));
1064     return False;
1065   }
1066
1067   *last_timeout_processing_time = t = time(NULL);
1068
1069   if(last_keepalive_sent_time == 0)
1070     last_keepalive_sent_time = t;
1071
1072   if(last_idle_closed_check == 0)
1073     last_idle_closed_check = t;
1074
1075   /* become root again if waiting */
1076   unbecome_user();
1077
1078   /* check if we need to reload services */
1079   check_reload(t);
1080
1081   /* automatic timeout if all connections are closed */
1082   if (conn_num_open()==0 && (t - last_idle_closed_check) >= IDLE_CLOSED_TIMEOUT)
1083   {
1084     DEBUG( 2, ( "Closing idle connection\n" ) );
1085     return False;
1086   }
1087   else
1088     last_idle_closed_check = t;
1089
1090   if (keepalive && (t - last_keepalive_sent_time)>keepalive)
1091   {
1092     struct cli_state *cli = server_client();
1093     if (!send_keepalive(smbd_server_fd())) {
1094       DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1095       return False;
1096     }
1097     /* also send a keepalive to the password server if its still
1098        connected */
1099     if (cli && cli->initialised)
1100       send_keepalive(cli->fd);
1101     last_keepalive_sent_time = t;
1102   }
1103
1104   /* check for connection timeouts */
1105   allidle = conn_idle_all(t, deadtime);
1106
1107   if (allidle && conn_num_open()>0) {
1108     DEBUG(2,("Closing idle connection 2.\n"));
1109     return False;
1110   }
1111
1112   if(global_machine_password_needs_changing)
1113   {
1114     unsigned char trust_passwd_hash[16];
1115     time_t lct;
1116     pstring remote_machine_list;
1117
1118     /*
1119      * We're in domain level security, and the code that
1120      * read the machine password flagged that the machine
1121      * password needs changing.
1122      */
1123
1124     /*
1125      * First, open the machine password file with an exclusive lock.
1126      */
1127
1128     if(!secrets_fetch_trust_account_password(global_myworkgroup, trust_passwd_hash, &lct)) {
1129       DEBUG(0,("process: unable to read the machine account password for \
1130 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
1131       return True;
1132     }
1133
1134     /*
1135      * Make sure someone else hasn't already done this.
1136      */
1137
1138     if(t < lct + lp_machine_password_timeout()) {
1139       global_machine_password_needs_changing = False;
1140       return True;
1141     }
1142
1143     pstrcpy(remote_machine_list, lp_passwordserver());
1144
1145     change_trust_account_password( global_myworkgroup, remote_machine_list);
1146     global_machine_password_needs_changing = False;
1147   }
1148
1149   /*
1150    * Check to see if we have any blocking locks
1151    * outstanding on the queue.
1152    */
1153   process_blocking_lock_queue(t);
1154
1155   /*
1156    * Check to see if we have any change notifies
1157    * outstanding on the queue.
1158    */
1159   process_pending_change_notify_queue(t);
1160
1161   /*
1162    * Now we are root, check if the log files need pruning.
1163    */
1164   if(need_to_check_log_size())
1165       check_log_size();
1166
1167   /*
1168    * Modify the select timeout depending upon
1169    * what we have remaining in our queues.
1170    */
1171
1172   *select_timeout = setup_select_timeout();
1173
1174   return True;
1175 }
1176
1177 /****************************************************************************
1178   process commands from the client
1179 ****************************************************************************/
1180
1181 void smbd_process(void)
1182 {
1183         extern int smb_echo_count;
1184         time_t last_timeout_processing_time = time(NULL);
1185         unsigned int num_smbs = 0;
1186
1187         InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1188         OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1189         if ((InBuffer == NULL) || (OutBuffer == NULL))
1190                 return;
1191
1192         max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
1193
1194         /* re-initialise the timezone */
1195         TimeInit();
1196
1197         while (True) {
1198                 int deadtime = lp_deadtime()*60;
1199                 int select_timeout = setup_select_timeout();
1200                 int num_echos;
1201
1202                 if (deadtime <= 0)
1203                         deadtime = DEFAULT_SMBD_TIMEOUT;
1204
1205                 errno = 0;
1206
1207                 /* free up temporary memory */
1208                 lp_talloc_free();
1209                 main_loop_talloc_free();
1210
1211                 while (!receive_message_or_smb(InBuffer,BUFFER_SIZE,select_timeout)) {
1212                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1213                                 return;
1214                         num_smbs = 0; /* Reset smb counter. */
1215                 }
1216
1217                 /*
1218                  * Ensure we do timeout processing if the SMB we just got was
1219                  * only an echo request. This allows us to set the select
1220                  * timeout in 'receive_message_or_smb()' to any value we like
1221                  * without worrying that the client will send echo requests
1222                  * faster than the select timeout, thus starving out the
1223                  * essential processing (change notify, blocking locks) that
1224                  * the timeout code does. JRA.
1225                  */
1226                 num_echos = smb_echo_count;
1227
1228                 process_smb(InBuffer, OutBuffer);
1229
1230                 if (smb_echo_count != num_echos) {
1231                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1232                                 return;
1233                         num_smbs = 0; /* Reset smb counter. */
1234                 }
1235
1236                 num_smbs++;
1237
1238                 /*
1239                  * If we are getting smb requests in a constant stream
1240                  * with no echos, make sure we attempt timeout processing
1241                  * every select_timeout milliseconds - but only check for this
1242                  * every 200 smb requests.
1243                  */
1244
1245                 if ((num_smbs % 200) == 0) {
1246                         time_t new_check_time = time(NULL);
1247                         if(last_timeout_processing_time - new_check_time >= (select_timeout/1000)) {
1248                                 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1249                                         return;
1250                                 num_smbs = 0; /* Reset smb counter. */
1251                                 last_timeout_processing_time = new_check_time; /* Reset time. */
1252                         }
1253                 }
1254         }
1255 }