challange -> challenge
[samba.git] / 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 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   {
1144     unsigned char trust_passwd_hash[16];
1145     time_t lct;
1146     pstring remote_machine_list;
1147
1148     /*
1149      * We're in domain level security, and the code that
1150      * read the machine password flagged that the machine
1151      * password needs changing.
1152      */
1153
1154     /*
1155      * First, open the machine password file with an exclusive lock.
1156      */
1157
1158     if(!secrets_fetch_trust_account_password(global_myworkgroup, trust_passwd_hash, &lct)) {
1159       DEBUG(0,("process: unable to read the machine account password for \
1160 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
1161       return True;
1162     }
1163
1164     /*
1165      * Make sure someone else hasn't already done this.
1166      */
1167
1168     if(t < lct + lp_machine_password_timeout()) {
1169       global_machine_password_needs_changing = False;
1170       return True;
1171     }
1172
1173     pstrcpy(remote_machine_list, lp_passwordserver());
1174
1175     change_trust_account_password( global_myworkgroup, remote_machine_list);
1176     global_machine_password_needs_changing = False;
1177   }
1178
1179   /*
1180    * Check to see if we have any blocking locks
1181    * outstanding on the queue.
1182    */
1183   process_blocking_lock_queue(t);
1184
1185   /*
1186    * Check to see if we have any change notifies 
1187    * outstanding on the queue.
1188    */
1189   process_pending_change_notify_queue(t);
1190
1191   /*
1192    * Now we are root, check if the log files need pruning.
1193    * Force a log file check.
1194    */
1195   force_check_log_size();
1196   check_log_size();
1197
1198   /*
1199    * Modify the select timeout depending upon
1200    * what we have remaining in our queues.
1201    */
1202
1203   *select_timeout = setup_select_timeout();
1204
1205   return True;
1206 }
1207
1208 /****************************************************************************
1209   process commands from the client
1210 ****************************************************************************/
1211
1212 void smbd_process(void)
1213 {
1214         extern int smb_echo_count;
1215         time_t last_timeout_processing_time = time(NULL);
1216         unsigned int num_smbs = 0;
1217
1218         InBuffer = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN);
1219         OutBuffer = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN);
1220         if ((InBuffer == NULL) || (OutBuffer == NULL)) 
1221                 return;
1222
1223         max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
1224
1225         /* re-initialise the timezone */
1226         TimeInit();
1227
1228         /* register our message handlers */
1229         message_register(MSG_SMB_FORCE_TDIS, msg_force_tdis);
1230
1231         while (True) {
1232                 int deadtime = lp_deadtime()*60;
1233                 int select_timeout = setup_select_timeout();
1234                 int num_echos;
1235
1236                 if (deadtime <= 0)
1237                         deadtime = DEFAULT_SMBD_TIMEOUT;
1238
1239                 errno = 0;      
1240                 
1241                 /* free up temporary memory */
1242                 lp_talloc_free();
1243                 main_loop_talloc_free();
1244
1245                 while (!receive_message_or_smb(InBuffer,BUFFER_SIZE+LARGE_WRITEX_HDR_SIZE,select_timeout)) {
1246                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1247                                 return;
1248                         num_smbs = 0; /* Reset smb counter. */
1249                 }
1250
1251                 /*
1252                  * Ensure we do timeout processing if the SMB we just got was
1253                  * only an echo request. This allows us to set the select
1254                  * timeout in 'receive_message_or_smb()' to any value we like
1255                  * without worrying that the client will send echo requests
1256                  * faster than the select timeout, thus starving out the
1257                  * essential processing (change notify, blocking locks) that
1258                  * the timeout code does. JRA.
1259                  */ 
1260                 num_echos = smb_echo_count;
1261
1262                 process_smb(InBuffer, OutBuffer);
1263
1264                 if (smb_echo_count != num_echos) {
1265                         if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1266                                 return;
1267                         num_smbs = 0; /* Reset smb counter. */
1268                 }
1269
1270                 num_smbs++;
1271
1272                 /*
1273                  * If we are getting smb requests in a constant stream
1274                  * with no echos, make sure we attempt timeout processing
1275                  * every select_timeout milliseconds - but only check for this
1276                  * every 200 smb requests.
1277                  */
1278                 
1279                 if ((num_smbs % 200) == 0) {
1280                         time_t new_check_time = time(NULL);
1281                         if(new_check_time - last_timeout_processing_time >= (select_timeout/1000)) {
1282                                 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1283                                         return;
1284                                 num_smbs = 0; /* Reset smb counter. */
1285                                 last_timeout_processing_time = new_check_time; /* Reset time. */
1286                         }
1287                 }
1288         }
1289 }