2 Unix SMB/Netbios implementation.
4 process incoming packets - main loop
5 Copyright (C) Andrew Tridgell 1992-1998
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.
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.
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.
24 extern int DEBUGLEVEL;
26 struct timeval smb_last_time;
28 static char *InBuffer = NULL;
29 char *OutBuffer = NULL;
30 char *last_inbuf = NULL;
33 * Size of data we can send to client. Set
34 * by the client for all protocols above CORE.
35 * Set by us for CORE protocol.
37 int max_send = BUFFER_SIZE;
39 * Size of the data we can receive. Set by us.
40 * Can be modified by the max xmit parameter.
42 int max_recv = BUFFER_SIZE;
44 extern int last_message;
45 extern int global_oplock_break;
46 extern pstring sesssetup_user;
47 extern char *last_inbuf;
48 extern char *InBuffer;
49 extern char *OutBuffer;
50 extern int smb_read_error;
51 extern VOLATILE SIG_ATOMIC_T reload_after_sighup;
52 extern BOOL global_machine_password_needs_changing;
53 extern fstring global_myworkgroup;
54 extern pstring global_myname;
57 /****************************************************************************
58 structure to hold a linked list of queued messages.
60 ****************************************************************************/
66 } pending_message_list;
68 static ubi_slList smb_oplock_queue = { NULL, (ubi_slNodePtr)&smb_oplock_queue, 0};
70 /****************************************************************************
71 Function to push a message onto the tail of a linked list of smb messages ready
73 ****************************************************************************/
75 static BOOL push_message(ubi_slList *list_head, char *buf, int msg_len)
77 pending_message_list *msg = (pending_message_list *)
78 malloc(sizeof(pending_message_list));
82 DEBUG(0,("push_message: malloc fail (1)\n"));
86 msg->msg_buf = (char *)malloc(msg_len);
87 if(msg->msg_buf == NULL)
89 DEBUG(0,("push_message: malloc fail (2)\n"));
94 memcpy(msg->msg_buf, buf, msg_len);
95 msg->msg_len = msg_len;
97 ubi_slAddTail( list_head, msg);
102 /****************************************************************************
103 Function to push a smb message onto a linked list of local smb messages ready
105 ****************************************************************************/
107 BOOL push_oplock_pending_smb_message(char *buf, int msg_len)
109 return push_message(&smb_oplock_queue, buf, msg_len);
112 /****************************************************************************
113 Do a select on an two fd's - with timeout.
115 If a local udp message has been pushed onto the
116 queue (this can only happen during oplock break
117 processing) return this first.
119 If a pending smb message has been pushed onto the
120 queue (this can only happen during oplock break
121 processing) return this next.
123 If the first smbfd is ready then read an smb from it.
124 if the second (loopback UDP) fd is ready then read a message
125 from it and setup the buffer header to identify the length
127 Returns False on timeout or error.
130 The timeout is in milli seconds
131 ****************************************************************************/
133 static BOOL receive_message_or_smb(char *buffer, int buffer_len,
134 int timeout, BOOL *got_smb)
147 * Check to see if we already have a message on the smb queue.
148 * If so - copy and return it.
151 if(ubi_slCount(&smb_oplock_queue) != 0)
153 pending_message_list *msg = (pending_message_list *)ubi_slRemHead(&smb_oplock_queue);
154 memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
156 /* Free the message we just copied. */
157 free((char *)msg->msg_buf);
161 DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
166 * Setup the select read fd set.
171 maxfd = setup_oplock_select_set(&fds);
173 to.tv_sec = timeout / 1000;
174 to.tv_usec = (timeout % 1000) * 1000;
176 selrtn = sys_select(MAX(maxfd,Client)+1,&fds,timeout>0?&to:NULL);
180 /* something is wrong. Maybe the socket is dead? */
181 smb_read_error = READ_ERROR;
185 /* Did we timeout ? */
187 smb_read_error = READ_TIMEOUT;
191 if (FD_ISSET(Client,&fds))
194 return receive_smb(Client, buffer, 0);
198 return receive_local_message(&fds, buffer, buffer_len, 0);
202 /****************************************************************************
203 Get the next SMB packet, doing the local message processing automatically.
204 ****************************************************************************/
206 BOOL receive_next_smb(char *inbuf, int bufsize, int timeout)
208 BOOL got_smb = False;
213 ret = receive_message_or_smb(inbuf,bufsize,timeout,&got_smb);
217 /* Deal with oplock break requests from other smbd's. */
218 process_local_message(inbuf, bufsize);
222 if(ret && (CVAL(inbuf,0) == 0x85))
224 /* Keepalive packet. */
229 while(ret && !got_smb);
234 /****************************************************************************
235 We're terminating and have closed all our files/connections etc.
236 If there are any pending local messages we need to respond to them
237 before termination so that other smbds don't think we just died whilst
239 ****************************************************************************/
241 void respond_to_all_remaining_local_messages(void)
247 * Assert we have no exclusive open oplocks.
250 if(get_number_of_exclusive_open_oplocks()) {
251 DEBUG(0,("respond_to_all_remaining_local_messages: PANIC : we have %d exclusive oplocks.\n",
252 get_number_of_exclusive_open_oplocks() ));
257 * Setup the select read fd set.
261 if(!setup_oplock_select_set(&fds))
265 * Keep doing receive_local_message with a 1 ms timeout until
266 * we have no more messages.
269 while(receive_local_message(&fds, buffer, sizeof(buffer), 1)) {
270 /* Deal with oplock break requests from other smbd's. */
271 process_local_message(buffer, sizeof(buffer));
274 (void)setup_oplock_select_set(&fds);
282 These flags determine some of the permissions required to do an operation
284 Note that I don't set NEED_WRITE on some write operations because they
285 are used by some brain-dead clients when printing, and I don't want to
286 force write permissions on print services.
288 #define AS_USER (1<<0)
289 #define NEED_WRITE (1<<1)
290 #define TIME_INIT (1<<2)
291 #define CAN_IPC (1<<3)
292 #define AS_GUEST (1<<5)
293 #define QUEUE_IN_OPLOCK (1<<6)
296 define a list of possible SMB messages and their corresponding
297 functions. Any message that has a NULL function is unimplemented -
298 please feel free to contribute implementations!
300 struct smb_message_struct
304 int (*fn)(connection_struct *conn, char *, char *, int, int);
311 {SMBnegprot,"SMBnegprot",reply_negprot,0},
312 {SMBtcon,"SMBtcon",reply_tcon,0},
313 {SMBtdis,"SMBtdis",reply_tdis,0},
314 {SMBexit,"SMBexit",reply_exit,0},
315 {SMBioctl,"SMBioctl",reply_ioctl,0},
316 {SMBecho,"SMBecho",reply_echo,0},
317 {SMBsesssetupX,"SMBsesssetupX",reply_sesssetup_and_X,0},
318 {SMBtconX,"SMBtconX",reply_tcon_and_X,0},
319 {SMBulogoffX, "SMBulogoffX", reply_ulogoffX, 0}, /* ulogoff doesn't give a valid TID */
320 {SMBgetatr,"SMBgetatr",reply_getatr,AS_USER},
321 {SMBsetatr,"SMBsetatr",reply_setatr,AS_USER | NEED_WRITE},
322 {SMBchkpth,"SMBchkpth",reply_chkpth,AS_USER},
323 {SMBsearch,"SMBsearch",reply_search,AS_USER},
324 {SMBopen,"SMBopen",reply_open,AS_USER | QUEUE_IN_OPLOCK },
326 /* note that SMBmknew and SMBcreate are deliberately overloaded */
327 {SMBcreate,"SMBcreate",reply_mknew,AS_USER},
328 {SMBmknew,"SMBmknew",reply_mknew,AS_USER},
330 {SMBunlink,"SMBunlink",reply_unlink,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
331 {SMBread,"SMBread",reply_read,AS_USER},
332 {SMBwrite,"SMBwrite",reply_write,AS_USER | CAN_IPC },
333 {SMBclose,"SMBclose",reply_close,AS_USER | CAN_IPC },
334 {SMBmkdir,"SMBmkdir",reply_mkdir,AS_USER | NEED_WRITE},
335 {SMBrmdir,"SMBrmdir",reply_rmdir,AS_USER | NEED_WRITE},
336 {SMBdskattr,"SMBdskattr",reply_dskattr,AS_USER},
337 {SMBmv,"SMBmv",reply_mv,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
339 /* this is a Pathworks specific call, allowing the
340 changing of the root path */
341 {pSETDIR,"pSETDIR",reply_setdir,AS_USER},
343 {SMBlseek,"SMBlseek",reply_lseek,AS_USER},
344 {SMBflush,"SMBflush",reply_flush,AS_USER},
345 {SMBctemp,"SMBctemp",reply_ctemp,AS_USER | QUEUE_IN_OPLOCK },
346 {SMBsplopen,"SMBsplopen",reply_printopen,AS_USER | QUEUE_IN_OPLOCK },
347 {SMBsplclose,"SMBsplclose",reply_printclose,AS_USER},
348 {SMBsplretq,"SMBsplretq",reply_printqueue,AS_USER},
349 {SMBsplwr,"SMBsplwr",reply_printwrite,AS_USER},
350 {SMBlock,"SMBlock",reply_lock,AS_USER},
351 {SMBunlock,"SMBunlock",reply_unlock,AS_USER},
353 /* CORE+ PROTOCOL FOLLOWS */
355 {SMBreadbraw,"SMBreadbraw",reply_readbraw,AS_USER},
356 {SMBwritebraw,"SMBwritebraw",reply_writebraw,AS_USER},
357 {SMBwriteclose,"SMBwriteclose",reply_writeclose,AS_USER},
358 {SMBlockread,"SMBlockread",reply_lockread,AS_USER},
359 {SMBwriteunlock,"SMBwriteunlock",reply_writeunlock,AS_USER},
361 /* LANMAN1.0 PROTOCOL FOLLOWS */
363 {SMBreadBmpx,"SMBreadBmpx",reply_readbmpx,AS_USER},
364 {SMBreadBs,"SMBreadBs",NULL,AS_USER},
365 {SMBwriteBmpx,"SMBwriteBmpx",reply_writebmpx,AS_USER},
366 {SMBwriteBs,"SMBwriteBs",reply_writebs,AS_USER},
367 {SMBwritec,"SMBwritec",NULL,AS_USER},
368 {SMBsetattrE,"SMBsetattrE",reply_setattrE,AS_USER | NEED_WRITE },
369 {SMBgetattrE,"SMBgetattrE",reply_getattrE,AS_USER },
370 {SMBtrans,"SMBtrans",reply_trans,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
371 {SMBtranss,"SMBtranss",NULL,AS_USER | CAN_IPC},
372 {SMBioctls,"SMBioctls",NULL,AS_USER},
373 {SMBcopy,"SMBcopy",reply_copy,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
374 {SMBmove,"SMBmove",NULL,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
376 {SMBopenX,"SMBopenX",reply_open_and_X,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
377 {SMBreadX,"SMBreadX",reply_read_and_X,AS_USER | CAN_IPC },
378 {SMBwriteX,"SMBwriteX",reply_write_and_X,AS_USER | CAN_IPC },
379 {SMBlockingX,"SMBlockingX",reply_lockingX,AS_USER },
381 {SMBffirst,"SMBffirst",reply_search,AS_USER},
382 {SMBfunique,"SMBfunique",reply_search,AS_USER},
383 {SMBfclose,"SMBfclose",reply_fclose,AS_USER},
385 /* LANMAN2.0 PROTOCOL FOLLOWS */
386 {SMBfindnclose, "SMBfindnclose", reply_findnclose, AS_USER},
387 {SMBfindclose, "SMBfindclose", reply_findclose,AS_USER},
388 {SMBtrans2, "SMBtrans2", reply_trans2, AS_USER | QUEUE_IN_OPLOCK },
389 {SMBtranss2, "SMBtranss2", reply_transs2, AS_USER},
391 /* NT PROTOCOL FOLLOWS */
392 {SMBntcreateX, "SMBntcreateX", reply_ntcreate_and_X, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
393 {SMBnttrans, "SMBnttrans", reply_nttrans, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
394 {SMBnttranss, "SMBnttranss", reply_nttranss, AS_USER | CAN_IPC },
395 {SMBntcancel, "SMBntcancel", reply_ntcancel, 0 },
397 /* messaging routines */
398 {SMBsends,"SMBsends",reply_sends,AS_GUEST},
399 {SMBsendstrt,"SMBsendstrt",reply_sendstrt,AS_GUEST},
400 {SMBsendend,"SMBsendend",reply_sendend,AS_GUEST},
401 {SMBsendtxt,"SMBsendtxt",reply_sendtxt,AS_GUEST},
403 /* NON-IMPLEMENTED PARTS OF THE CORE PROTOCOL */
405 {SMBsendb,"SMBsendb",NULL,AS_GUEST},
406 {SMBfwdname,"SMBfwdname",NULL,AS_GUEST},
407 {SMBcancelf,"SMBcancelf",NULL,AS_GUEST},
408 {SMBgetmac,"SMBgetmac",NULL,AS_GUEST}
412 /****************************************************************************
413 do a switch on the message type, and return the response size
414 ****************************************************************************/
415 static int switch_message(int type,char *inbuf,char *outbuf,int size,int bufsize)
417 static pid_t pid= (pid_t)-1;
419 static int num_smb_messages =
420 sizeof(smb_messages) / sizeof(struct smb_message_struct);
423 extern int global_smbpid;
425 if (pid == (pid_t)-1)
431 /* make sure this is an SMB packet */
432 if (strncmp(smb_base(inbuf),"\377SMB",4) != 0)
434 DEBUG(2,("Non-SMB packet of length %d\n",smb_len(inbuf)));
438 for (match=0;match<num_smb_messages;match++)
439 if (smb_messages[match].code == type)
442 /* yuck! this is an interim measure before we get rid of our
443 current inbuf/outbuf system */
444 global_smbpid = SVAL(inbuf,smb_pid);
446 if (match == num_smb_messages)
448 DEBUG(0,("Unknown message type %d!\n",type));
449 outsize = reply_unknown(inbuf,outbuf);
453 DEBUG(3,("switch message %s (pid %d)\n",smb_messages[match].name,(int)pid));
455 if(global_oplock_break)
457 int flags = smb_messages[match].flags;
459 if(flags & QUEUE_IN_OPLOCK)
462 * Queue this message as we are the process of an oplock break.
465 DEBUG( 2, ( "switch_message: queueing message due to being in " ) );
466 DEBUGADD( 2, ( "oplock break state.\n" ) );
468 push_oplock_pending_smb_message( inbuf, size );
472 if (smb_messages[match].fn)
474 int flags = smb_messages[match].flags;
475 static uint16 last_session_tag = UID_FIELD_INVALID;
476 /* In share mode security we must ignore the vuid. */
477 uint16 session_tag = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(inbuf,smb_uid);
478 connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
481 /* Ensure this value is replaced in the incoming packet. */
482 SSVAL(inbuf,smb_uid,session_tag);
485 * Ensure the correct username is in sesssetup_user.
486 * This is a really ugly bugfix for problems with
487 * multiple session_setup_and_X's being done and
488 * allowing %U and %G substitutions to work correctly.
489 * There is a reason this code is done here, don't
490 * move it unless you know what you're doing... :-).
493 if (session_tag != last_session_tag) {
494 user_struct *vuser = NULL;
496 last_session_tag = session_tag;
497 if(session_tag != UID_FIELD_INVALID)
498 vuser = get_valid_user_struct(session_tag);
500 pstrcpy( sesssetup_user, vuser->requested_name);
503 /* does this protocol need to be run as root? */
504 if (!(flags & AS_USER))
507 /* does this protocol need to be run as the connected user? */
508 if ((flags & AS_USER) && !become_user(conn,session_tag)) {
509 if (flags & AS_GUEST)
512 return(ERROR(ERRSRV,ERRaccess));
514 /* this code is to work around a bug is MS client 3 without
515 introducing a security hole - it needs to be able to do
516 print queue checks as guest if it isn't logged in properly */
520 /* does it need write permission? */
521 if ((flags & NEED_WRITE) && !CAN_WRITE(conn))
522 return(ERROR(ERRSRV,ERRaccess));
524 /* ipc services are limited */
525 if (IS_IPC(conn) && (flags & AS_USER) && !(flags & CAN_IPC)) {
526 return(ERROR(ERRSRV,ERRaccess));
529 /* load service specific parameters */
531 !become_service(conn,(flags & AS_USER)?True:False)) {
532 return(ERROR(ERRSRV,ERRaccess));
535 /* does this protocol need to be run as guest? */
536 if ((flags & AS_GUEST) &&
538 !check_access(Client, lp_hostsallow(-1), lp_hostsdeny(-1)))) {
539 return(ERROR(ERRSRV,ERRaccess));
544 outsize = smb_messages[match].fn(conn, inbuf,outbuf,size,bufsize);
548 outsize = reply_unknown(inbuf,outbuf);
556 /****************************************************************************
557 construct a reply to the incoming packet
558 ****************************************************************************/
559 static int construct_reply(char *inbuf,char *outbuf,int size,int bufsize)
561 int type = CVAL(inbuf,smb_com);
563 int msg_type = CVAL(inbuf,0);
565 GetTimeOfDay(&smb_last_time);
572 return(reply_special(inbuf,outbuf));
574 construct_reply_common(inbuf, outbuf);
576 outsize = switch_message(type,inbuf,outbuf,size,bufsize);
578 outsize += chain_size;
581 smb_setlen(outbuf,outsize - 4);
586 /****************************************************************************
587 process an smb from the client - split out from the process() code so
588 it can be used by the oplock break code.
589 ****************************************************************************/
590 void process_smb(char *inbuf, char *outbuf)
594 extern BOOL sslEnabled; /* don't use function for performance reasons */
595 static int sslConnected = 0;
596 #endif /* WITH_SSL */
597 static int trans_num;
598 int msg_type = CVAL(inbuf,0);
599 int32 len = smb_len(inbuf);
603 profile_p->smb_count++;
606 if (trans_num == 0) {
607 /* on the first packet, check the global hosts allow/ hosts
608 deny parameters before doing any parsing of the packet
609 passed to us by the client. This prevents attacks on our
610 parsing code from hosts not in the hosts allow list */
611 if (!check_access(Client, lp_hostsallow(-1), lp_hostsdeny(-1))) {
612 /* send a negative session response "not listining on calling
614 static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
615 DEBUG( 1, ( "Connection denied from %s\n",
616 client_addr(Client) ) );
617 send_smb(Client,(char *)buf);
618 exit_server("connection denied");
622 DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type, len ) );
623 DEBUG( 3, ( "Transaction %d of length %d\n", trans_num, nread ) );
626 if(sslEnabled && !sslConnected){
627 sslConnected = sslutil_negotiate_ssl(Client, msg_type);
628 if(sslConnected < 0){ /* an error occured */
629 exit_server("SSL negotiation failed");
630 }else if(sslConnected){
635 #endif /* WITH_SSL */
638 if(trans_num == 1 && VT_Check(inbuf))
647 else if(msg_type == 0x85)
648 return; /* Keepalive packet. */
650 nread = construct_reply(inbuf,outbuf,nread,max_send);
654 if (CVAL(outbuf,0) == 0)
657 if (nread != smb_len(outbuf) + 4)
659 DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
660 nread, smb_len(outbuf)));
663 send_smb(Client,outbuf);
670 /****************************************************************************
671 return a string containing the function name of a SMB command
672 ****************************************************************************/
673 char *smb_fn_name(int type)
675 static char *unknown_name = "SMBunknown";
676 static int num_smb_messages =
677 sizeof(smb_messages) / sizeof(struct smb_message_struct);
680 for (match=0;match<num_smb_messages;match++)
681 if (smb_messages[match].code == type)
684 if (match == num_smb_messages)
685 return(unknown_name);
687 return(smb_messages[match].name);
691 /****************************************************************************
692 Helper function for contruct_reply.
693 ****************************************************************************/
695 void construct_reply_common(char *inbuf,char *outbuf)
697 memset(outbuf,'\0',smb_size);
699 set_message(outbuf,0,0,True);
700 CVAL(outbuf,smb_com) = CVAL(inbuf,smb_com);
702 memcpy(outbuf+4,inbuf+4,4);
703 CVAL(outbuf,smb_rcls) = SMB_SUCCESS;
704 CVAL(outbuf,smb_reh) = 0;
705 SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES)); /* bit 7 set
707 SSVAL(outbuf,smb_flg2,FLAGS2_LONG_PATH_COMPONENTS); /* say we support long filenames */
708 SSVAL(outbuf,smb_err,SMB_SUCCESS);
709 SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
710 SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
711 SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
712 SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
715 /****************************************************************************
716 construct a chained reply and add it to the already made reply
717 **************************************************************************/
718 int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
720 static char *orig_inbuf;
721 static char *orig_outbuf;
722 int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
723 unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
724 char *inbuf2, *outbuf2;
726 char inbuf_saved[smb_wct];
727 char outbuf_saved[smb_wct];
728 int wct = CVAL(outbuf,smb_wct);
729 int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
731 /* maybe its not chained */
732 if (smb_com2 == 0xFF) {
733 CVAL(outbuf,smb_vwv0) = 0xFF;
737 if (chain_size == 0) {
738 /* this is the first part of the chain */
740 orig_outbuf = outbuf;
744 * The original Win95 redirector dies on a reply to
745 * a lockingX and read chain unless the chain reply is
746 * 4 byte aligned. JRA.
749 outsize = (outsize + 3) & ~3;
751 /* we need to tell the client where the next part of the reply will be */
752 SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
753 CVAL(outbuf,smb_vwv0) = smb_com2;
755 /* remember how much the caller added to the chain, only counting stuff
756 after the parameter words */
757 chain_size += outsize - smb_wct;
759 /* work out pointers into the original packets. The
760 headers on these need to be filled in */
761 inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
762 outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
764 /* remember the original command type */
765 smb_com1 = CVAL(orig_inbuf,smb_com);
767 /* save the data which will be overwritten by the new headers */
768 memcpy(inbuf_saved,inbuf2,smb_wct);
769 memcpy(outbuf_saved,outbuf2,smb_wct);
771 /* give the new packet the same header as the last part of the SMB */
772 memmove(inbuf2,inbuf,smb_wct);
774 /* create the in buffer */
775 CVAL(inbuf2,smb_com) = smb_com2;
777 /* create the out buffer */
778 construct_reply_common(inbuf2, outbuf2);
780 DEBUG(3,("Chained message\n"));
783 /* process the request */
784 outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
787 /* copy the new reply and request headers over the old ones, but
788 preserve the smb_com field */
789 memmove(orig_outbuf,outbuf2,smb_wct);
790 CVAL(orig_outbuf,smb_com) = smb_com1;
792 /* restore the saved data, being careful not to overwrite any
793 data from the reply header */
794 memcpy(inbuf2,inbuf_saved,smb_wct);
796 int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
797 if (ofs < 0) ofs = 0;
798 memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
804 /****************************************************************************
805 Setup the needed select timeout.
806 ****************************************************************************/
808 static int setup_select_timeout(void)
810 int change_notify_timeout = lp_change_notify_timeout() * 1000;
814 * Increase the select timeout back to SMBD_SELECT_TIMEOUT if we
815 * have removed any blocking locks. JRA.
818 select_timeout = blocking_locks_pending() ? SMBD_SELECT_TIMEOUT_WITH_PENDING_LOCKS*1000 :
819 SMBD_SELECT_TIMEOUT*1000;
821 if (change_notifies_pending())
822 select_timeout = MIN(select_timeout, change_notify_timeout);
824 return select_timeout;
827 /****************************************************************************
828 Check if services need reloading.
829 ****************************************************************************/
831 void check_reload(int t)
833 static time_t last_smb_conf_reload_time = 0;
835 if(last_smb_conf_reload_time == 0)
836 last_smb_conf_reload_time = t;
838 if (reload_after_sighup || (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK))
840 reload_services(True);
841 reload_after_sighup = False;
842 last_smb_conf_reload_time = t;
846 /****************************************************************************
847 Process any timeout housekeeping. Return False if the caller should exit.
848 ****************************************************************************/
850 static BOOL timeout_processing(int deadtime, int *select_timeout, time_t *last_timeout_processing_time)
853 static time_t last_keepalive_sent_time = 0;
854 static time_t last_idle_closed_check = 0;
857 extern int keepalive;
859 if (smb_read_error == READ_EOF)
861 DEBUG(3,("end of file from client\n"));
865 if (smb_read_error == READ_ERROR)
867 DEBUG(3,("receive_smb error (%s) exiting\n",
872 *last_timeout_processing_time = t = time(NULL);
874 if(last_keepalive_sent_time == 0)
875 last_keepalive_sent_time = t;
877 if(last_idle_closed_check == 0)
878 last_idle_closed_check = t;
880 /* become root again if waiting */
883 /* check if we need to reload services */
886 /* automatic timeout if all connections are closed */
887 if (conn_num_open()==0 && (t - last_idle_closed_check) >= IDLE_CLOSED_TIMEOUT)
889 DEBUG( 2, ( "Closing idle connection\n" ) );
893 last_idle_closed_check = t;
895 if (keepalive && (t - last_keepalive_sent_time)>keepalive)
897 struct cli_state *cli = server_client();
898 if (!send_keepalive(Client)) {
899 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
902 /* also send a keepalive to the password server if its still
904 if (cli && cli->initialised)
905 send_keepalive(cli->fd);
906 last_keepalive_sent_time = t;
909 /* check for connection timeouts */
910 allidle = conn_idle_all(t, deadtime);
912 if (allidle && conn_num_open()>0) {
913 DEBUG(2,("Closing idle connection 2.\n"));
917 if(global_machine_password_needs_changing)
919 unsigned char trust_passwd_hash[16];
921 pstring remote_machine_list;
924 * We're in domain level security, and the code that
925 * read the machine password flagged that the machine
926 * password needs changing.
930 * First, open the machine password file with an exclusive lock.
933 if(!trust_password_lock( global_myworkgroup, global_myname, True)) {
934 DEBUG(0,("process: unable to open the machine account password file for \
935 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
939 if(!get_trust_account_password( trust_passwd_hash, &lct)) {
940 DEBUG(0,("process: unable to read the machine account password for \
941 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
942 trust_password_unlock();
947 * Make sure someone else hasn't already done this.
950 if(t < lct + lp_machine_password_timeout()) {
951 trust_password_unlock();
952 global_machine_password_needs_changing = False;
956 pstrcpy(remote_machine_list, lp_passwordserver());
958 change_trust_account_password( global_myworkgroup, remote_machine_list);
959 trust_password_unlock();
960 global_machine_password_needs_changing = False;
964 * Check to see if we have any blocking locks
965 * outstanding on the queue.
967 process_blocking_lock_queue(t);
970 * Check to see if we have any change notifies
971 * outstanding on the queue.
973 process_pending_change_notify_queue(t);
976 * Modify the select timeout depending upon
977 * what we have remaining in our queues.
980 *select_timeout = setup_select_timeout();
985 /****************************************************************************
986 process commands from the client
987 ****************************************************************************/
989 void smbd_process(void)
991 extern int smb_echo_count;
992 time_t last_timeout_processing_time = time(NULL);
993 unsigned int num_smbs = 0;
995 InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
996 OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
997 if ((InBuffer == NULL) || (OutBuffer == NULL))
1000 InBuffer += SMB_ALIGNMENT;
1001 OutBuffer += SMB_ALIGNMENT;
1003 max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
1005 /* re-initialise the timezone */
1010 int deadtime = lp_deadtime()*60;
1011 BOOL got_smb = False;
1012 int select_timeout = setup_select_timeout();
1015 deadtime = DEFAULT_SMBD_TIMEOUT;
1017 #if USE_READ_PREDICTION
1018 if (lp_readprediction())
1019 do_read_prediction();
1024 /* free up temporary memory */
1027 while(!receive_message_or_smb(InBuffer,BUFFER_SIZE,select_timeout,&got_smb))
1029 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1031 num_smbs = 0; /* Reset smb counter. */
1036 * Ensure we do timeout processing if the SMB we just got was
1037 * only an echo request. This allows us to set the select
1038 * timeout in 'receive_message_or_smb()' to any value we like
1039 * without worrying that the client will send echo requests
1040 * faster than the select timeout, thus starving out the
1041 * essential processing (change notify, blocking locks) that
1042 * the timeout code does. JRA.
1044 int num_echos = smb_echo_count;
1046 process_smb(InBuffer, OutBuffer);
1048 if(smb_echo_count != num_echos) {
1049 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1051 num_smbs = 0; /* Reset smb counter. */
1057 * If we are getting smb requests in a constant stream
1058 * with no echos, make sure we attempt timeout processing
1059 * every select_timeout milliseconds - but only check for this
1060 * every 200 smb requests.
1063 if((num_smbs % 200) == 0) {
1064 time_t new_check_time = time(NULL);
1065 if(last_timeout_processing_time - new_check_time >= (select_timeout/1000)) {
1066 if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
1068 num_smbs = 0; /* Reset smb counter. */
1069 last_timeout_processing_time = new_check_time; /* Reset time. */
1074 process_local_message(InBuffer, BUFFER_SIZE);