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