Fixing get/set of security descriptors.
[samba.git] / source3 / smbd / nttrans.c
1 #define OLD_NTDOMAIN 1
2 /*
3    Unix SMB/Netbios implementation.
4    Version 1.9.
5    SMB NT transaction handling
6    Copyright (C) Jeremy Allison 1994-1998
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25 extern int DEBUGLEVEL;
26 extern int Protocol;
27 extern int smb_read_error;
28 extern int global_oplock_break;
29 extern BOOL case_sensitive;
30 extern BOOL case_preserve;
31 extern BOOL short_case_preserve;
32
33 static void remove_pending_change_notify_requests_by_mid(int mid);
34
35 static char *known_nt_pipes[] = {
36   "\\LANMAN",
37   "\\srvsvc",
38   "\\samr",
39   "\\wkssvc",
40   "\\NETLOGON",
41   "\\ntlsa",
42   "\\ntsvcs",
43   "\\lsass",
44   "\\lsarpc",
45   "\\winreg",
46   "\\spoolss",
47 #ifdef WITH_MSDFS
48   "\\netdfs",
49 #endif
50   NULL
51 };
52
53 /****************************************************************************
54  Send the required number of replies back.
55  We assume all fields other than the data fields are
56  set correctly for the type of call.
57  HACK ! Always assumes smb_setup field is zero.
58 ****************************************************************************/
59
60 static int send_nt_replies(char *inbuf, char *outbuf, int bufsize, uint32 nt_error, char *params,
61                            int paramsize, char *pdata, int datasize)
62 {
63   extern int max_send;
64   int data_to_send = datasize;
65   int params_to_send = paramsize;
66   int useable_space;
67   char *pp = params;
68   char *pd = pdata;
69   int params_sent_thistime, data_sent_thistime, total_sent_thistime;
70   int alignment_offset = 3;
71   int data_alignment_offset = 0;
72
73   /*
74    * Initially set the wcnt area to be 18 - this is true for all
75    * transNT replies.
76    */
77
78   set_message(outbuf,18,0,True);
79
80   if(nt_error != 0) {
81     /* NT Error. */
82     SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_32_BIT_ERROR_CODES);
83
84     ERROR(0,nt_error);
85   }
86
87   /* 
88    * If there genuinely are no parameters or data to send just send
89    * the empty packet.
90    */
91
92   if(params_to_send == 0 && data_to_send == 0) {
93     send_smb(smbd_server_fd(),outbuf);
94     return 0;
95   }
96
97   /*
98    * When sending params and data ensure that both are nicely aligned.
99    * Only do this alignment when there is also data to send - else
100    * can cause NT redirector problems.
101    */
102
103   if (((params_to_send % 4) != 0) && (data_to_send != 0))
104     data_alignment_offset = 4 - (params_to_send % 4);
105
106   /* 
107    * Space is bufsize minus Netbios over TCP header minus SMB header.
108    * The alignment_offset is to align the param bytes on a four byte
109    * boundary (2 bytes for data len, one byte pad). 
110    * NT needs this to work correctly.
111    */
112
113   useable_space = bufsize - ((smb_buf(outbuf)+
114                     alignment_offset+data_alignment_offset) -
115                     outbuf);
116
117   /*
118    * useable_space can never be more than max_send minus the
119    * alignment offset.
120    */
121
122   useable_space = MIN(useable_space,
123                       max_send - (alignment_offset+data_alignment_offset));
124
125
126   while (params_to_send || data_to_send) {
127
128     /*
129      * Calculate whether we will totally or partially fill this packet.
130      */
131
132     total_sent_thistime = params_to_send + data_to_send +
133                             alignment_offset + data_alignment_offset;
134
135     /* 
136      * We can never send more than useable_space.
137      */
138
139     total_sent_thistime = MIN(total_sent_thistime, useable_space);
140
141     set_message(outbuf, 18, total_sent_thistime, True);
142
143     /*
144      * Set total params and data to be sent.
145      */
146
147     SIVAL(outbuf,smb_ntr_TotalParameterCount,paramsize);
148     SIVAL(outbuf,smb_ntr_TotalDataCount,datasize);
149
150     /* 
151      * Calculate how many parameters and data we can fit into
152      * this packet. Parameters get precedence.
153      */
154
155     params_sent_thistime = MIN(params_to_send,useable_space);
156     data_sent_thistime = useable_space - params_sent_thistime;
157     data_sent_thistime = MIN(data_sent_thistime,data_to_send);
158
159     SIVAL(outbuf,smb_ntr_ParameterCount,params_sent_thistime);
160
161     if(params_sent_thistime == 0) {
162       SIVAL(outbuf,smb_ntr_ParameterOffset,0);
163       SIVAL(outbuf,smb_ntr_ParameterDisplacement,0);
164     } else {
165       /*
166        * smb_ntr_ParameterOffset is the offset from the start of the SMB header to the
167        * parameter bytes, however the first 4 bytes of outbuf are
168        * the Netbios over TCP header. Thus use smb_base() to subtract
169        * them from the calculation.
170        */
171
172       SIVAL(outbuf,smb_ntr_ParameterOffset,
173             ((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
174       /* 
175        * Absolute displacement of param bytes sent in this packet.
176        */
177
178       SIVAL(outbuf,smb_ntr_ParameterDisplacement,pp - params);
179     }
180
181     /*
182      * Deal with the data portion.
183      */
184
185     SIVAL(outbuf,smb_ntr_DataCount, data_sent_thistime);
186
187     if(data_sent_thistime == 0) {
188       SIVAL(outbuf,smb_ntr_DataOffset,0);
189       SIVAL(outbuf,smb_ntr_DataDisplacement, 0);
190     } else {
191       /*
192        * The offset of the data bytes is the offset of the
193        * parameter bytes plus the number of parameters being sent this time.
194        */
195
196       SIVAL(outbuf,smb_ntr_DataOffset,((smb_buf(outbuf)+alignment_offset) -
197             smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
198       SIVAL(outbuf,smb_ntr_DataDisplacement, pd - pdata);
199     }
200
201     /* 
202      * Copy the param bytes into the packet.
203      */
204
205     if(params_sent_thistime)
206       memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
207
208     /*
209      * Copy in the data bytes
210      */
211
212     if(data_sent_thistime)
213       memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
214              data_alignment_offset,pd,data_sent_thistime);
215     
216     DEBUG(9,("nt_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
217           params_sent_thistime, data_sent_thistime, useable_space));
218     DEBUG(9,("nt_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
219           params_to_send, data_to_send, paramsize, datasize));
220     
221     /* Send the packet */
222     send_smb(smbd_server_fd(),outbuf);
223     
224     pp += params_sent_thistime;
225     pd += data_sent_thistime;
226     
227     params_to_send -= params_sent_thistime;
228     data_to_send -= data_sent_thistime;
229
230     /*
231      * Sanity check
232      */
233
234     if(params_to_send < 0 || data_to_send < 0) {
235       DEBUG(0,("send_nt_replies failed sanity check pts = %d, dts = %d\n!!!",
236             params_to_send, data_to_send));
237       return -1;
238     }
239   } 
240
241   return 0;
242 }
243
244 /****************************************************************************
245  (Hopefully) temporary call to fix bugs in NT5.0beta2. This OS sends unicode
246  strings in NT calls AND DOESN'T SET THE UNICODE BIT !!!!!!!
247 ****************************************************************************/
248
249 static void get_filename( char *fname, char *inbuf, int data_offset, int data_len, int fname_len)
250 {
251   /*
252    * We need various heuristics here to detect a unicode string... JRA.
253    */
254
255   DEBUG(10,("get_filename: data_offset = %d, data_len = %d, fname_len = %d\n",
256            data_offset, data_len, fname_len ));
257
258   if(data_len - fname_len > 1) {
259     /*
260      * NT 5.0 Beta 2 has kindly sent us a UNICODE string
261      * without bothering to set the unicode bit. How kind.
262      *
263      * Firstly - ensure that the data offset is aligned
264      * on a 2 byte boundary - add one if not.
265      */
266     fname_len = fname_len/2;
267     if(data_offset & 1)
268       data_offset++;
269     pstrcpy(fname, dos_unistrn2((uint16 *)(inbuf+data_offset), fname_len));
270   } else {
271     StrnCpy(fname,inbuf+data_offset,fname_len);
272     fname[fname_len] = '\0';
273   }
274 }
275
276 /****************************************************************************
277  Fix bugs in Win2000 final release. In trans calls this OS sends unicode
278  strings AND DOESN'T SET THE UNICODE BIT !!!!!!!
279 ****************************************************************************/
280
281 static void get_filename_transact( char *fname, char *inbuf, int data_offset, int data_len, int fname_len)
282 {
283   /*
284    * We need various heuristics here to detect a unicode string... JRA.
285    */
286
287   DEBUG(10,("get_filename_transact: data_offset = %d, data_len = %d, fname_len = %d\n",
288            data_offset, data_len, fname_len ));
289
290   /*
291    * Win2K sends a unicode filename plus one extra alingment byte.
292    * WinNT4.x send an ascii string with multiple garbage bytes on
293    * the end here.
294    */
295
296   if((data_len - fname_len == 1) || (inbuf[data_offset] == '\0')) {
297     /*
298      * Ensure that the data offset is aligned
299      * on a 2 byte boundary - add one if not.
300      */
301     fname_len = fname_len/2;
302     if(data_offset & 1)
303       data_offset++;
304     pstrcpy(fname, dos_unistrn2((uint16 *)(inbuf+data_offset), fname_len));
305   } else {
306     StrnCpy(fname,inbuf+data_offset,fname_len);
307     fname[fname_len] = '\0';
308   }
309 }
310
311 /****************************************************************************
312  Save case statics.
313 ****************************************************************************/
314
315 static BOOL saved_case_sensitive;
316 static BOOL saved_case_preserve;
317 static BOOL saved_short_case_preserve;
318
319 /****************************************************************************
320  Save case semantics.
321 ****************************************************************************/
322
323 static void set_posix_case_semantics(uint32 file_attributes)
324 {
325   if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS))
326     return;
327
328   saved_case_sensitive = case_sensitive;
329   saved_case_preserve = case_preserve;
330   saved_short_case_preserve = short_case_preserve;
331
332   /* Set to POSIX. */
333   case_sensitive = True;
334   case_preserve = True;
335   short_case_preserve = True;
336 }
337
338 /****************************************************************************
339  Restore case semantics.
340 ****************************************************************************/
341
342 static void restore_case_semantics(uint32 file_attributes)
343 {
344   if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS))
345     return;
346
347   case_sensitive = saved_case_sensitive;
348   case_preserve = saved_case_preserve;
349   short_case_preserve = saved_short_case_preserve;
350 }
351
352 /****************************************************************************
353  Utility function to map create disposition.
354 ****************************************************************************/
355
356 static int map_create_disposition( uint32 create_disposition)
357 {
358   int ret;
359
360   switch( create_disposition ) {
361   case FILE_CREATE:
362     /* create if not exist, fail if exist */
363     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_FAIL);
364     break;
365   case FILE_SUPERSEDE:
366   case FILE_OVERWRITE_IF:
367     /* create if not exist, trunc if exist */
368     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE);
369     break;
370   case FILE_OPEN:
371     /* fail if not exist, open if exists */
372     ret = (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN);
373     break;
374   case FILE_OPEN_IF:
375     /* create if not exist, open if exists */
376     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_OPEN);
377     break;
378   case FILE_OVERWRITE:
379     /* fail if not exist, truncate if exists */
380     ret = (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE);
381     break;
382   default:
383     DEBUG(0,("map_create_disposition: Incorrect value for create_disposition = %d\n",
384              create_disposition ));
385     return -1;
386   }
387
388   DEBUG(10,("map_create_disposition: Mapped create_disposition %lx to %x\n",
389         (unsigned long)create_disposition, ret ));
390
391   return ret;
392 }
393
394 /****************************************************************************
395  Utility function to map share modes.
396 ****************************************************************************/
397
398 static int map_share_mode( BOOL *pstat_open_only, char *fname,
399                                                         uint32 desired_access, uint32 share_access, uint32 file_attributes)
400 {
401   int smb_open_mode = -1;
402
403   *pstat_open_only = False;
404
405   switch( desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA) ) {
406   case FILE_READ_DATA:
407     smb_open_mode = DOS_OPEN_RDONLY;
408     break;
409   case FILE_WRITE_DATA:
410   case FILE_APPEND_DATA:
411   case FILE_WRITE_DATA|FILE_APPEND_DATA:
412     smb_open_mode = DOS_OPEN_WRONLY;
413     break;
414   case FILE_READ_DATA|FILE_WRITE_DATA:
415   case FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA:
416   case FILE_READ_DATA|FILE_APPEND_DATA:
417     smb_open_mode = DOS_OPEN_RDWR;
418     break;
419   }
420
421   /*
422    * NB. For DELETE_ACCESS we should really check the
423    * directory permissions, as that is what controls
424    * delete, and for WRITE_DAC_ACCESS we should really
425    * check the ownership, as that is what controls the
426    * chmod. Note that this is *NOT* a security hole (this
427    * note is for you, Andrew) as we are not *allowing*
428    * the access at this point, the actual unlink or
429    * chown or chmod call would do this. We are just helping
430    * clients out by telling them if they have a hope
431    * of any of this succeeding. POSIX acls may still
432    * deny the real call. JRA.
433    */
434
435   if (smb_open_mode == -1) {
436         if(desired_access == WRITE_DAC_ACCESS || desired_access == READ_CONTROL_ACCESS)
437                 *pstat_open_only = True;
438
439     if(desired_access & (DELETE_ACCESS|WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS|
440                               FILE_EXECUTE|FILE_READ_ATTRIBUTES|
441                               FILE_READ_EA|FILE_WRITE_EA|SYSTEM_SECURITY_ACCESS|
442                               FILE_WRITE_ATTRIBUTES|READ_CONTROL_ACCESS))
443       smb_open_mode = DOS_OPEN_RDONLY;
444     else {
445       DEBUG(0,("map_share_mode: Incorrect value %lx for desired_access to file %s\n",
446              (unsigned long)desired_access, fname));
447       return -1;
448     }
449   }
450
451   /*
452    * Set the special bit that means allow share delete.
453    * This is held outside the normal share mode bits at 1<<15.
454    * JRA.
455    */
456
457   if(share_access & FILE_SHARE_DELETE)
458     smb_open_mode |= ALLOW_SHARE_DELETE;
459
460   /* Add in the requested share mode. */
461   switch( share_access & (FILE_SHARE_READ|FILE_SHARE_WRITE)) {
462   case FILE_SHARE_READ:
463     smb_open_mode |= SET_DENY_MODE(DENY_WRITE);
464     break;
465   case FILE_SHARE_WRITE:
466     smb_open_mode |= SET_DENY_MODE(DENY_READ);
467     break;
468   case (FILE_SHARE_READ|FILE_SHARE_WRITE):
469     smb_open_mode |= SET_DENY_MODE(DENY_NONE);
470     break;
471   case FILE_SHARE_NONE:
472     smb_open_mode |= SET_DENY_MODE(DENY_ALL);
473     break;
474   }
475
476   /*
477    * Handle an O_SYNC request.
478    */
479
480   if(file_attributes & FILE_FLAG_WRITE_THROUGH)
481     smb_open_mode |= FILE_SYNC_OPENMODE;
482
483   DEBUG(10,("map_share_mode: Mapped desired access %lx, share access %lx, file attributes %lx \
484 to open_mode %x\n", (unsigned long)desired_access, (unsigned long)share_access,
485                     (unsigned long)file_attributes, smb_open_mode ));
486  
487   return smb_open_mode;
488 }
489
490 #if 0
491 /*
492  * This is a *disgusting* hack.
493  * This is *so* bad that even I'm embarrassed (and I
494  * have no shame). Here's the deal :
495  * Until we get the correct SPOOLSS code into smbd
496  * then when we're running with NT SMB support then
497  * NT makes this call with a level of zero, and then
498  * immediately follows it with an open request to
499  * the \\SRVSVC pipe. If we allow that open to
500  * succeed then NT barfs when it cannot open the
501  * \\SPOOLSS pipe immediately after and continually
502  * whines saying "Printer name is invalid" forever
503  * after. If we cause *JUST THIS NEXT OPEN* of \\SRVSVC
504  * to fail, then NT downgrades to using the downlevel code
505  * and everything works as well as before. I hate
506  * myself for adding this code.... JRA.
507  *
508  * The HACK_FAIL_TIME define allows only a 2
509  * second window for this to occur, just in
510  * case...
511  */
512
513 static BOOL fail_next_srvsvc = False;
514 static time_t fail_time;
515 #define HACK_FAIL_TIME 2 /* In seconds. */
516
517 void fail_next_srvsvc_open(void)
518 {
519   /* Check client is WinNT proper; Win2K doesn't like Jeremy's hack - matty */
520   if (get_remote_arch() != RA_WINNT)
521     return;
522
523   fail_next_srvsvc = True;
524   fail_time = time(NULL);
525   DEBUG(10,("fail_next_srvsvc_open: setting up timeout close of \\srvsvc pipe for print fix.\n"));
526 }
527
528 /*
529  * HACK alert.... see above - JRA.
530  */
531
532 BOOL should_fail_next_srvsvc_open(const char *pipename)
533 {
534
535   DEBUG(10,("should_fail_next_srvsvc_open: fail = %d, pipe = %s\n",
536     (int)fail_next_srvsvc, pipename));
537
538   if(fail_next_srvsvc && (time(NULL) > fail_time + HACK_FAIL_TIME)) {
539     fail_next_srvsvc = False;
540     fail_time = (time_t)0;
541     DEBUG(10,("should_fail_next_srvsvc_open: End of timeout close of \\srvsvc pipe for print fix.\n"));
542   }
543
544   if(fail_next_srvsvc && strequal(pipename, "srvsvc")) {
545     fail_next_srvsvc = False;
546     DEBUG(10,("should_fail_next_srvsvc_open: Deliberately failing open of \\srvsvc pipe for print fix.\n"));
547     return True;
548   }
549   return False;
550 }
551 #endif
552
553 /****************************************************************************
554  Reply to an NT create and X call on a pipe.
555 ****************************************************************************/
556 static int nt_open_pipe(char *fname, connection_struct *conn,
557                         char *inbuf, char *outbuf, int *ppnum)
558 {
559         pipes_struct *p = NULL;
560
561         uint16 vuid = SVAL(inbuf, smb_uid);
562         int i;
563
564         DEBUG(4,("nt_open_pipe: Opening pipe %s.\n", fname));
565     
566         /* See if it is one we want to handle. */
567         for( i = 0; known_nt_pipes[i]; i++ )
568                 if( strequal(fname,known_nt_pipes[i]))
569                         break;
570     
571         if ( known_nt_pipes[i] == NULL )
572                 return(ERROR(ERRSRV,ERRaccess));
573     
574         /* Strip \\ off the name. */
575         fname++;
576     
577 #if 0
578         if(should_fail_next_srvsvc_open(fname))
579                 return (ERROR(ERRSRV,ERRaccess));
580 #endif
581
582         DEBUG(3,("nt_open_pipe: Known pipe %s opening.\n", fname));
583
584         p = open_rpc_pipe_p(fname, conn, vuid);
585         if (!p)
586                 return(ERROR(ERRSRV,ERRnofids));
587
588         *ppnum = p->pnum;
589
590         return 0;
591 }
592
593 /****************************************************************************
594  Reply to an NT create and X call for pipes.
595 ****************************************************************************/
596
597 static int do_ntcreate_pipe_open(connection_struct *conn,
598                          char *inbuf,char *outbuf,int length,int bufsize)
599 {
600         pstring fname;
601         int ret;
602         int pnum = -1;
603         char *p = NULL;
604         uint32 fname_len = MIN(((uint32)SVAL(inbuf,smb_ntcreate_NameLength)),
605                                ((uint32)sizeof(fname)-1));
606
607         get_filename(fname, inbuf, smb_buf(inbuf)-inbuf, 
608                   smb_buflen(inbuf),fname_len);
609         if ((ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum)) != 0)
610                 return ret;
611
612         /*
613          * Deal with pipe return.
614          */  
615
616         set_message(outbuf,34,0,True);
617
618         p = outbuf + smb_vwv2;
619         p++;
620         SSVAL(p,0,pnum);
621         p += 2;
622         SIVAL(p,0,FILE_WAS_OPENED);
623         p += 4;
624         p += 32;
625         SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
626         p += 20;
627         /* File type. */
628         SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
629         /* Device state. */
630         SSVAL(p,2, 0x5FF); /* ? */
631
632         DEBUG(5,("do_ntcreate_pipe_open: open pipe = %s\n", fname));
633
634         return chain_reply(inbuf,outbuf,length,bufsize);
635 }
636
637 /****************************************************************************
638  Reply to an NT create and X call.
639 ****************************************************************************/
640
641 int reply_ntcreate_and_X(connection_struct *conn,
642                          char *inbuf,char *outbuf,int length,int bufsize)
643 {  
644         pstring fname;
645         uint32 flags = IVAL(inbuf,smb_ntcreate_Flags);
646         uint32 desired_access = IVAL(inbuf,smb_ntcreate_DesiredAccess);
647         uint32 file_attributes = IVAL(inbuf,smb_ntcreate_FileAttributes);
648         uint32 share_access = IVAL(inbuf,smb_ntcreate_ShareAccess);
649         uint32 create_disposition = IVAL(inbuf,smb_ntcreate_CreateDisposition);
650         uint32 create_options = IVAL(inbuf,smb_ntcreate_CreateOptions);
651         uint32 fname_len = MIN(((uint32)SVAL(inbuf,smb_ntcreate_NameLength)),
652                                ((uint32)sizeof(fname)-1));
653         uint16 root_dir_fid = (uint16)IVAL(inbuf,smb_ntcreate_RootDirectoryFid);
654         int smb_ofun;
655         int smb_open_mode;
656         int smb_attr = (file_attributes & SAMBA_ATTRIBUTES_MASK);
657         /* Breakout the oplock request bits so we can set the
658            reply bits separately. */
659         int oplock_request = 0;
660         mode_t unixmode;
661         int fmode=0,rmode=0;
662         SMB_OFF_T file_len = 0;
663         SMB_STRUCT_STAT sbuf;
664         int smb_action = 0;
665         BOOL bad_path = False;
666         files_struct *fsp=NULL;
667         char *p = NULL;
668         BOOL stat_open_only = False;
669
670         /* If it's an IPC, use the pipe handler. */
671
672         if (IS_IPC(conn)) {
673                 if (lp_nt_pipe_support())
674                         return do_ntcreate_pipe_open(conn,inbuf,outbuf,length,bufsize);
675                 else
676                         return(ERROR(ERRDOS,ERRbadaccess));
677         }
678                         
679
680         /* 
681          * We need to construct the open_and_X ofun value from the
682          * NT values, as that's what our code is structured to accept.
683          */    
684         
685         if((smb_ofun = map_create_disposition( create_disposition )) == -1)
686                 return(ERROR(ERRDOS,ERRbadaccess));
687
688         /*
689          * Get the file name.
690          */
691
692     if(root_dir_fid != 0) {
693       /*
694        * This filename is relative to a directory fid.
695        */
696       files_struct *dir_fsp = file_fsp(inbuf,smb_ntcreate_RootDirectoryFid);
697       size_t dir_name_len;
698
699       if(!dir_fsp)
700         return(ERROR(ERRDOS,ERRbadfid));
701
702       if(!dir_fsp->is_directory) {
703         /* 
704          * Check to see if this is a mac fork of some kind.
705          */
706
707         get_filename(&fname[0], inbuf, smb_buf(inbuf)-inbuf, 
708                    smb_buflen(inbuf),fname_len);
709
710         if( fname[0] == ':') {
711           SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
712           return(ERROR(0, 0xc0000000|NT_STATUS_OBJECT_PATH_NOT_FOUND));
713         }
714         return(ERROR(ERRDOS,ERRbadfid));
715       }
716
717       /*
718        * Copy in the base directory name.
719        */
720
721       pstrcpy( fname, dir_fsp->fsp_name );
722       dir_name_len = strlen(fname);
723
724       /*
725        * Ensure it ends in a '\'.
726        */
727
728       if(fname[dir_name_len-1] != '\\' && fname[dir_name_len-1] != '/') {
729         pstrcat(fname, "\\");
730         dir_name_len++;
731       }
732
733       /*
734        * This next calculation can refuse a correct filename if we're dealing
735        * with the Win2k unicode bug, but that would be rare. JRA.
736        */
737
738       if(fname_len + dir_name_len >= sizeof(pstring))
739         return(ERROR(ERRSRV,ERRfilespecs));
740
741       get_filename(&fname[dir_name_len], inbuf, smb_buf(inbuf)-inbuf, 
742                    smb_buflen(inbuf),fname_len);
743
744     } else {
745       
746       get_filename(fname, inbuf, smb_buf(inbuf)-inbuf, 
747                    smb_buflen(inbuf),fname_len);
748     }
749         
750         /*
751          * Now contruct the smb_open_mode value from the filename, 
752      * desired access and the share access.
753          */
754         RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
755
756         if((smb_open_mode = map_share_mode(&stat_open_only, fname, desired_access, 
757                                            share_access, 
758                                            file_attributes)) == -1)
759                 return(ERROR(ERRDOS,ERRbadaccess));
760
761         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
762         oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
763
764         /*
765          * Ordinary file or directory.
766          */
767                 
768         /*
769          * Check if POSIX semantics are wanted.
770          */
771                 
772         set_posix_case_semantics(file_attributes);
773                 
774         unix_convert(fname,conn,0,&bad_path,NULL);
775                 
776         unixmode = unix_mode(conn,smb_attr | aARCH, fname);
777     
778         /* 
779          * If it's a request for a directory open, deal with it separately.
780          */
781
782         if(create_options & FILE_DIRECTORY_FILE) {
783                 oplock_request = 0;
784                 
785                 fsp = open_directory(conn, fname, smb_ofun, unixmode, &smb_action);
786                         
787                 restore_case_semantics(file_attributes);
788
789                 if(!fsp) {
790                         return(UNIXERROR(ERRDOS,ERRnoaccess));
791                 }
792         } else {
793                 /*
794                  * Ordinary file case.
795                  */
796
797                 /* NB. We have a potential bug here. If we
798                  * cause an oplock break to ourselves, then we
799                  * could end up processing filename related
800                  * SMB requests whilst we await the oplock
801                  * break response. As we may have changed the
802                  * filename case semantics to be POSIX-like,
803                  * this could mean a filename request could
804                  * fail when it should succeed. This is a rare
805                  * condition, but eventually we must arrange
806                  * to restore the correct case semantics
807                  * before issuing an oplock break request to
808                  * our client. JRA.  */
809
810                 fsp = open_file_shared(conn,fname,smb_open_mode,
811                                  smb_ofun,unixmode, oplock_request,&rmode,&smb_action);
812
813                 if (!fsp) { 
814                         /* We cheat here. There are two cases we
815                          * care about. One is a directory rename,
816                          * where the NT client will attempt to
817                          * open the source directory for
818                          * DELETE access. Note that when the
819                          * NT client does this it does *not*
820                          * set the directory bit in the
821                          * request packet. This is translated
822                          * into a read/write open
823                          * request. POSIX states that any open
824                          * for write request on a directory
825                          * will generate an EISDIR error, so
826                          * we can catch this here and open a
827                          * pseudo handle that is flagged as a
828                          * directory. The second is an open
829                          * for a permissions read only, which
830                          * we handle in the open_file_stat case. JRA.
831                          */
832
833                         if(errno == EISDIR) {
834
835                                 /*
836                                  * Fail the open if it was explicitly a non-directory file.
837                                  */
838
839                                 if (create_options & FILE_NON_DIRECTORY_FILE) {
840                                         restore_case_semantics(file_attributes);
841                                         SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
842                                         return(ERROR(0, 0xc0000000|NT_STATUS_FILE_IS_A_DIRECTORY));
843                                 }
844         
845                                 oplock_request = 0;
846                                 fsp = open_directory(conn, fname, smb_ofun, unixmode, &smb_action);
847                                 
848                                 if(!fsp) {
849                                         restore_case_semantics(file_attributes);
850                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
851                                 }
852 #ifdef EROFS
853                         } else if (((errno == EACCES) || (errno == EROFS)) && stat_open_only) {
854 #else /* !EROFS */
855                         } else if (errno == EACCES && stat_open_only) {
856 #endif
857                                 /*
858                                  * We couldn't open normally and all we want
859                                  * are the permissions. Try and do a stat open.
860                                  */
861
862                                 oplock_request = 0;
863
864                                 fsp = open_file_stat(conn,fname,smb_open_mode,&sbuf,&smb_action);
865
866                                 if(!fsp) {
867                                         restore_case_semantics(file_attributes);
868                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
869                                 }
870
871                         } else {
872
873                                 if((errno == ENOENT) && bad_path) {
874                                         unix_ERR_class = ERRDOS;
875                                         unix_ERR_code = ERRbadpath;
876                                 }
877                                 
878                                 restore_case_semantics(file_attributes);
879                                 
880                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
881                         }
882                 } 
883         }
884                 
885         if(fsp->is_directory) {
886                 if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name, False), &sbuf) != 0) {
887                         close_file(fsp,True);
888                         restore_case_semantics(file_attributes);
889                         return(ERROR(ERRDOS,ERRnoaccess));
890                 }
891         } else {
892                 if (conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
893                         close_file(fsp,False);
894                         restore_case_semantics(file_attributes);
895                         return(ERROR(ERRDOS,ERRnoaccess));
896                 } 
897         }
898                 
899         restore_case_semantics(file_attributes);
900                 
901         file_len = sbuf.st_size;
902         fmode = dos_mode(conn,fname,&sbuf);
903         if(fmode == 0)
904                 fmode = FILE_ATTRIBUTE_NORMAL;
905         if (!fsp->is_directory && (fmode & aDIR)) {
906                 close_file(fsp,False);
907                 return(ERROR(ERRDOS,ERRnoaccess));
908         } 
909         
910         /* 
911          * If the caller set the extended oplock request bit
912          * and we granted one (by whatever means) - set the
913          * correct bit for extended oplock reply.
914          */
915         
916         if (oplock_request && lp_fake_oplocks(SNUM(conn)))
917                 smb_action |= EXTENDED_OPLOCK_GRANTED;
918         
919         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
920                 smb_action |= EXTENDED_OPLOCK_GRANTED;
921
922         set_message(outbuf,34,0,True);
923         
924         p = outbuf + smb_vwv2;
925         
926         /*
927          * Currently as we don't support level II oplocks we just report
928          * exclusive & batch here.
929          */
930
931     if (smb_action & EXTENDED_OPLOCK_GRANTED)   
932                 SCVAL(p,0, BATCH_OPLOCK_RETURN);
933         else if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
934         SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
935         else
936                 SCVAL(p,0,NO_OPLOCK_RETURN);
937         
938         p++;
939         SSVAL(p,0,fsp->fnum);
940         p += 2;
941         SIVAL(p,0,smb_action);
942         p += 4;
943         
944         /* Create time. */  
945         put_long_date(p,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
946         p += 8;
947         put_long_date(p,sbuf.st_atime); /* access time */
948         p += 8;
949         put_long_date(p,sbuf.st_mtime); /* write time */
950         p += 8;
951         put_long_date(p,sbuf.st_mtime); /* change time */
952         p += 8;
953         SIVAL(p,0,fmode); /* File Attributes. */
954         p += 4;
955         SOFF_T(p, 0, file_len);
956         p += 8;
957         SOFF_T(p,0,file_len);
958         p += 12;
959         SCVAL(p,0,fsp->is_directory ? 1 : 0);
960         
961         DEBUG(5,("reply_ntcreate_and_X: fnum = %d, open name = %s\n", fsp->fnum, fsp->fsp_name));
962
963         return chain_reply(inbuf,outbuf,length,bufsize);
964 }
965
966 /****************************************************************************
967  Reply to a NT_TRANSACT_CREATE call to open a pipe.
968 ****************************************************************************/
969
970 static int do_nt_transact_create_pipe( connection_struct *conn,
971                                         char *inbuf, char *outbuf, int length, 
972                                         int bufsize, char **ppsetup, char **ppparams, 
973                                         char **ppdata)
974 {
975         pstring fname;
976         uint32 fname_len;
977         int total_parameter_count = (int)IVAL(inbuf, smb_nt_TotalParameterCount);
978         char *params = *ppparams;
979         int ret;
980         int pnum = -1;
981         char *p = NULL;
982
983         /*
984          * Ensure minimum number of parameters sent.
985          */
986
987         if(total_parameter_count < 54) {
988                 DEBUG(0,("do_nt_transact_create_pipe - insufficient parameters (%u)\n", (unsigned int)total_parameter_count));
989                 return(ERROR(ERRDOS,ERRbadaccess));
990         }
991
992         fname_len = MIN(((uint32)IVAL(params,44)),((uint32)sizeof(fname)-1));
993
994         get_filename_transact(&fname[0], params, 53,
995                         total_parameter_count - 53 - fname_len, fname_len);
996
997     if ((ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum)) != 0)
998       return ret;
999
1000         /* Realloc the size of parameters and data we will return */
1001         params = *ppparams = Realloc(*ppparams, 69);
1002         if(params == NULL)
1003                 return(ERROR(ERRDOS,ERRnomem));
1004
1005         memset((char *)params,'\0',69);
1006
1007         p = params;
1008         SCVAL(p,0,NO_OPLOCK_RETURN);
1009
1010         p += 2;
1011         SSVAL(p,0,pnum);
1012         p += 2;
1013         SIVAL(p,0,FILE_WAS_OPENED);
1014         p += 8;
1015
1016         p += 32;
1017         SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
1018         p += 20;
1019         /* File type. */
1020         SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
1021         /* Device state. */
1022         SSVAL(p,2, 0x5FF); /* ? */
1023
1024         DEBUG(5,("do_nt_transact_create_pipe: open name = %s\n", fname));
1025
1026         /* Send the required number of replies */
1027         send_nt_replies(inbuf, outbuf, bufsize, 0, params, 69, *ppdata, 0);
1028
1029         return -1;
1030 }
1031
1032 /****************************************************************************
1033  Reply to a NT_TRANSACT_CREATE call (needs to process SD's).
1034 ****************************************************************************/
1035
1036 static int call_nt_transact_create(connection_struct *conn,
1037                                         char *inbuf, char *outbuf, int length, 
1038                                         int bufsize, char **ppsetup, char **ppparams, 
1039                                         char **ppdata)
1040 {
1041   pstring fname;
1042   char *params = *ppparams;
1043   int total_parameter_count = (int)IVAL(inbuf, smb_nt_TotalParameterCount);
1044   /* Breakout the oplock request bits so we can set the
1045      reply bits separately. */
1046   int oplock_request = 0;
1047   mode_t unixmode;
1048   int fmode=0,rmode=0;
1049   SMB_OFF_T file_len = 0;
1050   SMB_STRUCT_STAT sbuf;
1051   int smb_action = 0;
1052   BOOL bad_path = False;
1053   files_struct *fsp = NULL;
1054   char *p = NULL;
1055   BOOL stat_open_only = False;
1056   uint32 flags;
1057   uint32 desired_access;
1058   uint32 file_attributes;
1059   uint32 share_access;
1060   uint32 create_disposition;
1061   uint32 create_options;
1062   uint32 fname_len;
1063   uint16 root_dir_fid;
1064   int smb_ofun;
1065   int smb_open_mode;
1066   int smb_attr;
1067
1068   DEBUG(5,("call_nt_transact_create\n"));
1069
1070   /*
1071    * If it's an IPC, use the pipe handler.
1072    */
1073
1074   if (IS_IPC(conn)) {
1075                 if (lp_nt_pipe_support())
1076                         return do_nt_transact_create_pipe(conn, inbuf, outbuf, length, 
1077                                         bufsize, ppsetup, ppparams, ppdata);
1078                 else
1079                         return(ERROR(ERRDOS,ERRbadaccess));
1080   }
1081
1082   /*
1083    * Ensure minimum number of parameters sent.
1084    */
1085
1086   if(total_parameter_count < 54) {
1087     DEBUG(0,("call_nt_transact_create - insufficient parameters (%u)\n", (unsigned int)total_parameter_count));
1088     return(ERROR(ERRDOS,ERRbadaccess));
1089   }
1090
1091   flags = IVAL(params,0);
1092   desired_access = IVAL(params,8);
1093   file_attributes = IVAL(params,20);
1094   share_access = IVAL(params,24);
1095   create_disposition = IVAL(params,28);
1096   create_options = IVAL(params,32);
1097   fname_len = MIN(((uint32)IVAL(params,44)),((uint32)sizeof(fname)-1));
1098   root_dir_fid = (uint16)IVAL(params,4);
1099   smb_attr = (file_attributes & SAMBA_ATTRIBUTES_MASK);
1100
1101   /* 
1102    * We need to construct the open_and_X ofun value from the
1103    * NT values, as that's what our code is structured to accept.
1104    */    
1105
1106   if((smb_ofun = map_create_disposition( create_disposition )) == -1)
1107     return(ERROR(ERRDOS,ERRbadmem));
1108
1109   /*
1110    * Get the file name.
1111    */
1112
1113   if(root_dir_fid != 0) {
1114     /*
1115      * This filename is relative to a directory fid.
1116      */
1117
1118     files_struct *dir_fsp = file_fsp(params,4);
1119     size_t dir_name_len;
1120
1121     if(!dir_fsp)
1122         return(ERROR(ERRDOS,ERRbadfid));
1123
1124     if(!dir_fsp->is_directory) {
1125       /*
1126        * Check to see if this is a mac fork of some kind.
1127        */
1128
1129       get_filename_transact(&fname[0], params, 53,
1130                             total_parameter_count - 53 - fname_len, fname_len);
1131
1132       if( fname[0] == ':') {
1133           SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
1134           return(ERROR(0, 0xc0000000|NT_STATUS_OBJECT_PATH_NOT_FOUND));
1135       }
1136
1137       return(ERROR(ERRDOS,ERRbadfid));
1138     }
1139
1140     /*
1141      * Copy in the base directory name.
1142      */
1143
1144     pstrcpy( fname, dir_fsp->fsp_name );
1145     dir_name_len = strlen(fname);
1146
1147     /*
1148      * Ensure it ends in a '\'.
1149      */
1150
1151     if((fname[dir_name_len-1] != '\\') && (fname[dir_name_len-1] != '/')) {
1152       pstrcat(fname, "\\");
1153       dir_name_len++;
1154     }
1155
1156     /*
1157      * This next calculation can refuse a correct filename if we're dealing
1158      * with the Win2k unicode bug, but that would be rare. JRA.
1159      */
1160
1161     if(fname_len + dir_name_len >= sizeof(pstring))
1162       return(ERROR(ERRSRV,ERRfilespecs));
1163
1164     get_filename_transact(&fname[dir_name_len], params, 53,
1165                  total_parameter_count - 53 - fname_len, fname_len);
1166
1167   } else {
1168     get_filename_transact(&fname[0], params, 53,
1169                  total_parameter_count - 53 - fname_len, fname_len);
1170   }
1171
1172   /*
1173    * Now contruct the smb_open_mode value from the desired access
1174    * and the share access.
1175    */
1176
1177   if((smb_open_mode = map_share_mode( &stat_open_only, fname, desired_access,
1178                                       share_access, file_attributes)) == -1)
1179     return(ERROR(ERRDOS,ERRbadaccess));
1180
1181   oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1182   oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1183
1184   /*
1185    * Check if POSIX semantics are wanted.
1186    */
1187
1188   set_posix_case_semantics(file_attributes);
1189     
1190   RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1191
1192   unix_convert(fname,conn,0,&bad_path,NULL);
1193     
1194   unixmode = unix_mode(conn,smb_attr | aARCH, fname);
1195    
1196   /*
1197    * If it's a request for a directory open, deal with it separately.
1198    */
1199
1200   if(create_options & FILE_DIRECTORY_FILE) {
1201
1202     oplock_request = 0;
1203
1204     /*
1205      * We will get a create directory here if the Win32
1206      * app specified a security descriptor in the 
1207      * CreateDirectory() call.
1208      */
1209
1210     fsp = open_directory(conn, fname, smb_ofun, unixmode, &smb_action);
1211
1212     if(!fsp) {
1213       restore_case_semantics(file_attributes);
1214       return(UNIXERROR(ERRDOS,ERRnoaccess));
1215     }
1216
1217     if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name, False),
1218              &sbuf) != 0) {
1219       close_file(fsp,True);
1220       restore_case_semantics(file_attributes);
1221       return(ERROR(ERRDOS,ERRnoaccess));
1222     }
1223
1224   } else {
1225
1226     /*
1227      * Ordinary file case.
1228      */
1229
1230     fsp = open_file_shared(conn,fname,smb_open_mode,smb_ofun,unixmode,
1231                      oplock_request,&rmode,&smb_action);
1232
1233     if (!fsp) { 
1234
1235                 if(errno == EISDIR) {
1236
1237                         /*
1238                          * Fail the open if it was explicitly a non-directory file.
1239                          */
1240
1241                         if (create_options & FILE_NON_DIRECTORY_FILE) {
1242                                 restore_case_semantics(file_attributes);
1243                                 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
1244                                 return(ERROR(0, 0xc0000000|NT_STATUS_FILE_IS_A_DIRECTORY));
1245                         }
1246         
1247                         oplock_request = 0;
1248                         fsp = open_directory(conn, fname, smb_ofun, unixmode, &smb_action);
1249                                 
1250                         if(!fsp) {
1251                                 restore_case_semantics(file_attributes);
1252                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
1253                         }
1254 #ifdef EROFS
1255                 } else if (((errno == EACCES) || (errno == EROFS)) && stat_open_only) {
1256 #else /* !EROFS */
1257                 } else if (errno == EACCES && stat_open_only) {
1258 #endif
1259
1260                         /*
1261                          * We couldn't open normally and all we want
1262                          * are the permissions. Try and do a stat open.
1263                          */
1264
1265                         oplock_request = 0;
1266
1267                         fsp = open_file_stat(conn,fname,smb_open_mode,&sbuf,&smb_action);
1268
1269                         if(!fsp) {
1270                                 restore_case_semantics(file_attributes);
1271                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
1272                         }
1273                 } else {
1274
1275                         if((errno == ENOENT) && bad_path) {
1276                                 unix_ERR_class = ERRDOS;
1277                                 unix_ERR_code = ERRbadpath;
1278                         }
1279
1280                         restore_case_semantics(file_attributes);
1281
1282                         return(UNIXERROR(ERRDOS,ERRnoaccess));
1283                 }
1284       } 
1285   
1286       if(fsp->is_directory) {
1287           if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name,False), &sbuf) != 0) {
1288               close_file(fsp,True);
1289               restore_case_semantics(file_attributes);
1290               return(ERROR(ERRDOS,ERRnoaccess));
1291           }
1292       } else {
1293           if (!fsp->stat_open && conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
1294               close_file(fsp,False);
1295               restore_case_semantics(file_attributes);
1296               return(ERROR(ERRDOS,ERRnoaccess));
1297           } 
1298       }
1299  
1300       file_len = sbuf.st_size;
1301       fmode = dos_mode(conn,fname,&sbuf);
1302       if(fmode == 0)
1303         fmode = FILE_ATTRIBUTE_NORMAL;
1304
1305       if (fmode & aDIR) {
1306         close_file(fsp,False);
1307         restore_case_semantics(file_attributes);
1308         return(ERROR(ERRDOS,ERRnoaccess));
1309       } 
1310
1311       /* 
1312        * If the caller set the extended oplock request bit
1313        * and we granted one (by whatever means) - set the
1314        * correct bit for extended oplock reply.
1315        */
1316     
1317       if (oplock_request && lp_fake_oplocks(SNUM(conn)))
1318         smb_action |= EXTENDED_OPLOCK_GRANTED;
1319   
1320       if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1321         smb_action |= EXTENDED_OPLOCK_GRANTED;
1322   }
1323
1324   restore_case_semantics(file_attributes);
1325
1326   /* Realloc the size of parameters and data we will return */
1327   params = *ppparams = Realloc(*ppparams, 69);
1328   if(params == NULL)
1329     return(ERROR(ERRDOS,ERRnomem));
1330
1331   memset((char *)params,'\0',69);
1332
1333   p = params;
1334   if (smb_action & EXTENDED_OPLOCK_GRANTED)     
1335         SCVAL(p,0, BATCH_OPLOCK_RETURN);
1336   else if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
1337     SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
1338   else
1339         SCVAL(p,0,NO_OPLOCK_RETURN);
1340         
1341   p += 2;
1342   SSVAL(p,0,fsp->fnum);
1343   p += 2;
1344   SIVAL(p,0,smb_action);
1345   p += 8;
1346
1347   /* Create time. */
1348   put_long_date(p,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
1349   p += 8;
1350   put_long_date(p,sbuf.st_atime); /* access time */
1351   p += 8;
1352   put_long_date(p,sbuf.st_mtime); /* write time */
1353   p += 8;
1354   put_long_date(p,sbuf.st_mtime); /* change time */
1355   p += 8;
1356   SIVAL(p,0,fmode); /* File Attributes. */
1357   p += 4;
1358   SOFF_T(p,0,file_len);
1359   p += 8;
1360   SOFF_T(p,0,file_len);
1361
1362   DEBUG(5,("call_nt_transact_create: open name = %s\n", fname));
1363
1364   /* Send the required number of replies */
1365   send_nt_replies(inbuf, outbuf, bufsize, 0, params, 69, *ppdata, 0);
1366
1367   return -1;
1368 }
1369
1370 /****************************************************************************
1371  Reply to a NT CANCEL request.
1372 ****************************************************************************/
1373 int reply_ntcancel(connection_struct *conn,
1374                    char *inbuf,char *outbuf,int length,int bufsize)
1375 {
1376         /*
1377          * Go through and cancel any pending change notifies.
1378          */
1379         
1380         int mid = SVAL(inbuf,smb_mid);
1381         remove_pending_change_notify_requests_by_mid(mid);
1382         remove_pending_lock_requests_by_mid(mid);
1383         
1384         DEBUG(3,("reply_ntcancel: cancel called on mid = %d.\n", mid));
1385
1386         return(-1);
1387 }
1388
1389 /****************************************************************************
1390  Reply to an unsolicited SMBNTtranss - just ignore it!
1391 ****************************************************************************/
1392 int reply_nttranss(connection_struct *conn,
1393                    char *inbuf,char *outbuf,int length,int bufsize)
1394 {
1395         DEBUG(4,("Ignoring nttranss of length %d\n",length));
1396         return(-1);
1397 }
1398
1399 /****************************************************************************
1400  Reply to an NT transact rename command.
1401 ****************************************************************************/
1402
1403 static int call_nt_transact_rename(connection_struct *conn,
1404                                    char *inbuf, char *outbuf, int length, 
1405                                    int bufsize,
1406                                    char **ppsetup, char **ppparams, char **ppdata)
1407 {
1408   char *params = *ppparams;
1409   pstring new_name;
1410   files_struct *fsp = file_fsp(params, 0);
1411   BOOL replace_if_exists = (SVAL(params,2) & RENAME_REPLACE_IF_EXISTS) ? True : False;
1412   uint32 fname_len = MIN((((uint32)IVAL(inbuf,smb_nt_TotalParameterCount)-4)),
1413                          ((uint32)sizeof(new_name)-1));
1414   int outsize = 0;
1415
1416   CHECK_FSP(fsp, conn);
1417   StrnCpy(new_name,params+4,fname_len);
1418   new_name[fname_len] = '\0';
1419
1420   outsize = rename_internals(conn, inbuf, outbuf, fsp->fsp_name,
1421                              new_name, replace_if_exists);
1422   if(outsize == 0) {
1423     /*
1424      * Rename was successful.
1425      */
1426     send_nt_replies(inbuf, outbuf, bufsize, 0, NULL, 0, NULL, 0);
1427
1428     DEBUG(3,("nt transact rename from = %s, to = %s succeeded.\n", 
1429           fsp->fsp_name, new_name));
1430
1431     outsize = -1;
1432   }
1433
1434   return(outsize);
1435 }
1436    
1437 /****************************************************************************
1438  This is the structure to keep the information needed to
1439  determine if a directory has changed.
1440 *****************************************************************************/
1441
1442 typedef struct {
1443   time_t modify_time; /* Info from the directory we're monitoring. */ 
1444   time_t status_time; /* Info from the directory we're monitoring. */
1445   time_t total_time; /* Total time of all directory entries - don't care if it wraps. */
1446   unsigned int num_entries; /* Zero or the number of files in the directory. */
1447 } change_hash_data;
1448
1449 /****************************************************************************
1450  This is the structure to queue to implement NT change
1451  notify. It consists of smb_size bytes stored from the
1452  transact command (to keep the mid, tid etc around).
1453  Plus the fid to examine and the time to check next.
1454 *****************************************************************************/
1455
1456 typedef struct {
1457   ubi_slNode msg_next;
1458   files_struct *fsp;
1459   connection_struct *conn;
1460   uint32 flags;
1461   time_t next_check_time;
1462   change_hash_data change_data;
1463   char request_buf[smb_size];
1464 } change_notify_buf;
1465
1466 static ubi_slList change_notify_queue = { NULL, (ubi_slNodePtr)&change_notify_queue, 0};
1467
1468 /****************************************************************************
1469  Setup the common parts of the return packet and send it.
1470 *****************************************************************************/
1471
1472 static void change_notify_reply_packet(char *inbuf, int error_class, uint32 error_code)
1473 {
1474   char outbuf[smb_size+38];
1475
1476   memset(outbuf, '\0', sizeof(outbuf));
1477   construct_reply_common(inbuf, outbuf);
1478
1479   /*
1480    * If we're returning a 'too much in the directory changed' we need to
1481    * set this is an NT error status flags. If we don't then the (probably
1482    * untested) code in the NT redirector has a bug in that it doesn't re-issue
1483    * the change notify.... Ah - I *love* it when I get so deeply into this I
1484    * can even determine how MS failed to test stuff and why.... :-). JRA.
1485    */
1486
1487   if(error_class == 0) /* NT Error. */
1488     SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_32_BIT_ERROR_CODES);
1489
1490   ERROR(error_class,error_code);
1491
1492   /*
1493    * Seems NT needs a transact command with an error code
1494    * in it. This is a longer packet than a simple error.
1495    */
1496   set_message(outbuf,18,0,False);
1497
1498   send_smb(smbd_server_fd(),outbuf);
1499 }
1500
1501 /****************************************************************************
1502  Create the hash we will use to determine if the contents changed.
1503 *****************************************************************************/
1504
1505 static BOOL create_directory_notify_hash( change_notify_buf *cnbp, change_hash_data *change_data)
1506 {
1507   SMB_STRUCT_STAT st;
1508   files_struct *fsp = cnbp->fsp;
1509
1510   memset((char *)change_data, '\0', sizeof(change_data));
1511
1512   /* 
1513    * Store the current timestamp on the directory we are monitoring.
1514    */
1515
1516   if(dos_stat(fsp->fsp_name, &st) < 0) {
1517     DEBUG(0,("create_directory_notify_hash: Unable to stat name = %s. \
1518 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1519     return False;
1520   }
1521  
1522   change_data->modify_time = st.st_mtime;
1523   change_data->status_time = st.st_ctime;
1524
1525   /*
1526    * If we are to watch for changes that are only stored
1527    * in inodes of files, not in the directory inode, we must
1528    * scan the directory and produce a unique identifier with
1529    * which we can determine if anything changed. We use the
1530    * modify and change times from all the files in the
1531    * directory, added together (ignoring wrapping if it's
1532    * larger than the max time_t value).
1533    */
1534
1535   if(cnbp->flags & (FILE_NOTIFY_CHANGE_SIZE|FILE_NOTIFY_CHANGE_LAST_WRITE)) {
1536     pstring full_name;
1537     char *p;
1538     char *fname;
1539     size_t remaining_len;
1540     size_t fullname_len;
1541     void *dp = OpenDir(cnbp->conn, fsp->fsp_name, True);
1542
1543     if(dp == NULL) {
1544       DEBUG(0,("create_directory_notify_hash: Unable to open directory = %s. \
1545 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1546       return False;
1547     }
1548
1549     change_data->num_entries = 0;
1550
1551     pstrcpy(full_name, fsp->fsp_name);
1552     pstrcat(full_name, "/");
1553
1554     fullname_len = strlen(full_name);
1555     remaining_len = sizeof(full_name) - fullname_len - 1;
1556     p = &full_name[fullname_len];
1557
1558     while ((fname = ReadDirName(dp))) {
1559       if(strequal(fname, ".") || strequal(fname, ".."))
1560         continue;
1561
1562       change_data->num_entries++;
1563       safe_strcpy( p, fname, remaining_len);
1564
1565       memset(&st, '\0', sizeof(st));
1566
1567       /*
1568        * Do the stat - but ignore errors.
1569        */
1570
1571       if(dos_stat(full_name, &st) < 0) {
1572         DEBUG(5,("create_directory_notify_hash: Unable to stat content file = %s. \
1573 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1574       }
1575       change_data->total_time += (st.st_mtime + st.st_ctime);
1576     }
1577
1578     CloseDir(dp);
1579   }
1580
1581   return True;
1582 }
1583
1584 /****************************************************************************
1585  Delete entries by fnum from the change notify pending queue.
1586 *****************************************************************************/
1587
1588 void remove_pending_change_notify_requests_by_fid(files_struct *fsp)
1589 {
1590   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1591   change_notify_buf *prev = NULL;
1592
1593   while(cnbp != NULL) {
1594     if(cnbp->fsp->fnum == fsp->fnum) {
1595       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1596       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1597       continue;
1598     }
1599
1600     prev = cnbp;
1601     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1602   }
1603 }
1604
1605 /****************************************************************************
1606  Delete entries by mid from the change notify pending queue. Always send reply.
1607 *****************************************************************************/
1608
1609 static void remove_pending_change_notify_requests_by_mid(int mid)
1610 {
1611   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1612   change_notify_buf *prev = NULL;
1613
1614   while(cnbp != NULL) {
1615     if(SVAL(cnbp->request_buf,smb_mid) == mid) {
1616       change_notify_reply_packet(cnbp->request_buf,0,0xC0000000 |NT_STATUS_CANCELLED);
1617       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1618       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1619       continue;
1620     }
1621
1622     prev = cnbp;
1623     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1624   }
1625 }
1626
1627 /****************************************************************************
1628  Delete entries by filename and cnum from the change notify pending queue.
1629  Always send reply.
1630 *****************************************************************************/
1631
1632 void remove_pending_change_notify_requests_by_filename(files_struct *fsp)
1633 {
1634   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1635   change_notify_buf *prev = NULL;
1636
1637   while(cnbp != NULL) {
1638     /*
1639      * We know it refers to the same directory if the connection number and
1640      * the filename are identical.
1641      */
1642     if((cnbp->fsp->conn == fsp->conn) && strequal(cnbp->fsp->fsp_name,fsp->fsp_name)) {
1643       change_notify_reply_packet(cnbp->request_buf,0,0xC0000000 |NT_STATUS_CANCELLED);
1644       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1645       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1646       continue;
1647     }
1648
1649     prev = cnbp;
1650     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1651   }
1652 }
1653
1654 /****************************************************************************
1655  Process the change notify queue. Note that this is only called as root.
1656  Returns True if there are still outstanding change notify requests on the
1657  queue.
1658 *****************************************************************************/
1659
1660 BOOL process_pending_change_notify_queue(time_t t)
1661 {
1662   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1663   change_notify_buf *prev = NULL;
1664
1665   if(cnbp == NULL)
1666     return False;
1667
1668   if(cnbp->next_check_time >= t)
1669     return True;
1670
1671   /*
1672    * It's time to check. Go through the queue and see if
1673    * the timestamps changed.
1674    */
1675
1676   while((cnbp != NULL) && (cnbp->next_check_time <= t)) {
1677     change_hash_data change_data;
1678     connection_struct *conn = cnbp->conn;
1679     uint16 vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : 
1680                   SVAL(cnbp->request_buf,smb_uid);
1681
1682     ZERO_STRUCT(change_data);
1683
1684     /*
1685      * Ensure we don't have any old chain_fsp values
1686      * sitting around....
1687      */
1688     chain_size = 0;
1689     file_chain_reset();
1690
1691     if(!become_user(conn,vuid)) {
1692       DEBUG(0,("process_pending_change_notify_queue: Unable to become user vuid=%d.\n",
1693             vuid ));
1694       /*
1695        * Remove the entry and return an error to the client.
1696        */
1697       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1698       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1699       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1700       continue;
1701     }
1702
1703     if(!become_service(conn,True)) {
1704             DEBUG(0,("process_pending_change_notify_queue: Unable to become service Error was %s.\n", strerror(errno) ));
1705       /*
1706        * Remove the entry and return an error to the client.
1707        */
1708       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1709       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1710       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1711       unbecome_user();
1712       continue;
1713     }
1714
1715     if(!create_directory_notify_hash( cnbp, &change_data)) {
1716       DEBUG(0,("process_pending_change_notify_queue: Unable to create change data for \
1717 directory %s\n", cnbp->fsp->fsp_name ));
1718       /*
1719        * Remove the entry and return an error to the client.
1720        */
1721       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1722       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1723       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1724       unbecome_user();
1725       continue;
1726     }
1727
1728     if(memcmp( (char *)&cnbp->change_data, (char *)&change_data, sizeof(change_data))) {
1729       /*
1730        * Remove the entry and return a change notify to the client.
1731        */
1732       DEBUG(5,("process_pending_change_notify_queue: directory name = %s changed.\n",
1733             cnbp->fsp->fsp_name ));
1734       change_notify_reply_packet(cnbp->request_buf,0,NT_STATUS_NOTIFY_ENUM_DIR);
1735       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1736       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1737       unbecome_user();
1738       continue;
1739     }
1740
1741     unbecome_user();
1742
1743     /*
1744      * Move to the next in the list.
1745      */
1746     prev = cnbp;
1747     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1748   }
1749
1750   return (cnbp != NULL);
1751 }
1752
1753 /****************************************************************************
1754  Return true if there are pending change notifies.
1755 ****************************************************************************/
1756
1757 BOOL change_notifies_pending(void)
1758 {
1759   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1760   return (cnbp != NULL);
1761 }
1762
1763 /****************************************************************************
1764  Reply to a notify change - queue the request and 
1765  don't allow a directory to be opened.
1766 ****************************************************************************/
1767
1768 static int call_nt_transact_notify_change(connection_struct *conn,
1769                                           char *inbuf, char *outbuf, int length,
1770                                           int bufsize, 
1771                                           char **ppsetup, 
1772                                           char **ppparams, char **ppdata)
1773 {
1774   char *setup = *ppsetup;
1775   files_struct *fsp;
1776   change_notify_buf *cnbp;
1777
1778   fsp = file_fsp(setup,4);
1779
1780   DEBUG(3,("call_nt_transact_notify_change\n"));
1781
1782   if(!fsp)
1783     return(ERROR(ERRDOS,ERRbadfid));
1784
1785   if((!fsp->is_directory) || (conn != fsp->conn))
1786     return(ERROR(ERRDOS,ERRbadfid));
1787
1788   /*
1789    * Now queue an entry on the notify change stack. We timestamp
1790    * the entry we are adding so that we know when to scan next.
1791    * We only need to save smb_size bytes from this incoming packet
1792    * as we will always by returning a 'read the directory yourself'
1793    * error.
1794    */
1795
1796   if((cnbp = (change_notify_buf *)malloc(sizeof(change_notify_buf))) == NULL) {
1797     DEBUG(0,("call_nt_transact_notify_change: malloc fail !\n" ));
1798     return -1;
1799   }
1800
1801   memset((char *)cnbp, '\0', sizeof(change_notify_buf));
1802
1803   memcpy(cnbp->request_buf, inbuf, smb_size);
1804   cnbp->fsp = fsp;
1805   cnbp->conn = conn;
1806   cnbp->next_check_time = time(NULL) + lp_change_notify_timeout();
1807   cnbp->flags = IVAL(setup, 0);
1808
1809   if(!create_directory_notify_hash( cnbp, &cnbp->change_data )) {
1810     free((char *)cnbp);
1811     return(UNIXERROR(ERRDOS,ERRbadfid));
1812   }
1813
1814   /*
1815    * Adding to the tail enables us to check only
1816    * the head when scanning for change, as this entry
1817    * is forced to have the first timeout expiration.
1818    */
1819
1820   ubi_slAddTail(&change_notify_queue, cnbp);
1821
1822   DEBUG(3,("call_nt_transact_notify_change: notify change called on directory \
1823 name = %s\n", fsp->fsp_name ));
1824
1825   return -1;
1826 }
1827
1828 /****************************************************************************
1829  Reply to query a security descriptor - currently this is not implemented (it
1830  is planned to be though). Right now it just returns the same thing NT would
1831  when queried on a FAT filesystem. JRA.
1832 ****************************************************************************/
1833
1834 static int call_nt_transact_query_security_desc(connection_struct *conn,
1835                                                 char *inbuf, char *outbuf, 
1836                                                 int length, int bufsize, 
1837                                                 char **ppsetup, char **ppparams, char **ppdata)
1838 {
1839   uint32 max_data_count = IVAL(inbuf,smb_nt_MaxDataCount);
1840   char *params = *ppparams;
1841   char *data = *ppdata;
1842   prs_struct pd;
1843   SEC_DESC *psd = NULL;
1844   size_t sd_size;
1845
1846   files_struct *fsp = file_fsp(params,0);
1847
1848   if(!fsp)
1849     return(ERROR(ERRDOS,ERRbadfid));
1850
1851   DEBUG(3,("call_nt_transact_query_security_desc: file = %s\n", fsp->fsp_name ));
1852
1853   params = *ppparams = Realloc(*ppparams, 4);
1854   if(params == NULL)
1855     return(ERROR(ERRDOS,ERRnomem));
1856
1857   /*
1858    * Get the permissions to return.
1859    */
1860
1861   if((sd_size = get_nt_acl(fsp, &psd)) == 0)
1862     return(UNIXERROR(ERRDOS,ERRnoaccess));
1863
1864   DEBUG(3,("call_nt_transact_query_security_desc: sd_size = %d.\n",(int)sd_size));
1865
1866   SIVAL(params,0,(uint32)sd_size);
1867
1868   if(max_data_count < sd_size) {
1869
1870     free_sec_desc(&psd);
1871
1872     send_nt_replies(inbuf, outbuf, bufsize, 0xC0000000|NT_STATUS_BUFFER_TOO_SMALL,
1873                     params, 4, *ppdata, 0);
1874     return -1;
1875   }
1876
1877   /*
1878    * Allocate the data we will point this at.
1879    */
1880
1881   data = *ppdata = Realloc(*ppdata, sd_size);
1882   if(data == NULL) {
1883     free_sec_desc(&psd);
1884     return(ERROR(ERRDOS,ERRnomem));
1885   }
1886
1887   memset(data, '\0', sd_size);
1888
1889   /*
1890    * Init the parse struct we will marshall into.
1891    */
1892
1893   prs_init(&pd, 0, 4, MARSHALL);
1894
1895   /*
1896    * Setup the prs_struct to point at the memory we just
1897    * allocated.
1898    */
1899
1900   prs_give_memory( &pd, data, (uint32)sd_size, False);
1901
1902   /*
1903    * Finally, linearize into the outgoing buffer.
1904    */
1905
1906   if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
1907     free_sec_desc(&psd);
1908     DEBUG(0,("call_nt_transact_query_security_desc: Error in marshalling \
1909 security descriptor.\n"));
1910     /*
1911      * Return access denied for want of a better error message..
1912      */ 
1913     return(UNIXERROR(ERRDOS,ERRnoaccess));
1914   }
1915
1916   /*
1917    * Now we can delete the security descriptor.
1918    */
1919
1920   free_sec_desc(&psd);
1921
1922   send_nt_replies(inbuf, outbuf, bufsize, 0, params, 4, data, (int)sd_size);
1923   return -1;
1924 }
1925
1926 /****************************************************************************
1927  Reply to set a security descriptor. Map to UNIX perms.
1928 ****************************************************************************/
1929
1930 static int call_nt_transact_set_security_desc(connection_struct *conn,
1931                                                                         char *inbuf, char *outbuf, int length,
1932                                                                         int bufsize, char **ppsetup, 
1933                                                                         char **ppparams, char **ppdata)
1934 {
1935   uint32 total_parameter_count = IVAL(inbuf, smb_nts_TotalParameterCount);
1936   char *params= *ppparams;
1937   char *data = *ppdata;
1938   prs_struct pd;
1939   SEC_DESC *psd = NULL;
1940   uint32 total_data_count = (uint32)IVAL(inbuf, smb_nts_TotalDataCount);
1941   files_struct *fsp = NULL;
1942   uint32 security_info_sent = 0;
1943
1944   if(!lp_nt_acl_support())
1945     return(UNIXERROR(ERRDOS,ERRnoaccess));
1946
1947   if(total_parameter_count < 8)
1948     return(ERROR(ERRDOS,ERRbadfunc));
1949
1950   if((fsp = file_fsp(params,0)) == NULL)
1951     return(ERROR(ERRDOS,ERRbadfid));
1952
1953   security_info_sent = IVAL(params,4);
1954
1955   DEBUG(3,("call_nt_transact_set_security_desc: file = %s, sent 0x%x\n", fsp->fsp_name,
1956        (unsigned int)security_info_sent ));
1957
1958   /*
1959    * Init the parse struct we will unmarshall from.
1960    */
1961
1962   prs_init(&pd, 0, 4, UNMARSHALL);
1963
1964   /*
1965    * Setup the prs_struct to point at the memory we just
1966    * allocated.
1967    */
1968         
1969   prs_give_memory( &pd, data, total_data_count, False);
1970
1971   /*
1972    * Finally, unmarshall from the data buffer.
1973    */
1974
1975   if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
1976     free_sec_desc(&psd);
1977     DEBUG(0,("call_nt_transact_set_security_desc: Error in unmarshalling \
1978 security descriptor.\n"));
1979     /*
1980      * Return access denied for want of a better error message..
1981      */ 
1982     return(UNIXERROR(ERRDOS,ERRnoaccess));
1983   }
1984
1985   if (!set_nt_acl(fsp, security_info_sent, psd)) {
1986         free_sec_desc(&psd);
1987         return(UNIXERROR(ERRDOS,ERRnoaccess));
1988   }
1989
1990   free_sec_desc(&psd);
1991   send_nt_replies(inbuf, outbuf, bufsize, 0, NULL, 0, NULL, 0);
1992   return -1;
1993 }
1994    
1995 /****************************************************************************
1996  Reply to IOCTL - not implemented - no plans.
1997 ****************************************************************************/
1998 static int call_nt_transact_ioctl(connection_struct *conn,
1999                                   char *inbuf, char *outbuf, int length,
2000                                   int bufsize, 
2001                                   char **ppsetup, char **ppparams, char **ppdata)
2002 {
2003   static BOOL logged_message = False;
2004
2005   if(!logged_message) {
2006     DEBUG(0,("call_nt_transact_ioctl: Currently not implemented.\n"));
2007     logged_message = True; /* Only print this once... */
2008   }
2009   return(ERROR(ERRSRV,ERRnosupport));
2010 }
2011    
2012 /****************************************************************************
2013  Reply to a SMBNTtrans.
2014 ****************************************************************************/
2015 int reply_nttrans(connection_struct *conn,
2016                   char *inbuf,char *outbuf,int length,int bufsize)
2017 {
2018   int  outsize = 0;
2019 #if 0 /* Not used. */
2020   uint16 max_setup_count = CVAL(inbuf, smb_nt_MaxSetupCount);
2021   uint32 max_parameter_count = IVAL(inbuf, smb_nt_MaxParameterCount);
2022   uint32 max_data_count = IVAL(inbuf,smb_nt_MaxDataCount);
2023 #endif /* Not used. */
2024   uint32 total_parameter_count = IVAL(inbuf, smb_nt_TotalParameterCount);
2025   uint32 total_data_count = IVAL(inbuf, smb_nt_TotalDataCount);
2026   uint32 parameter_count = IVAL(inbuf,smb_nt_ParameterCount);
2027   uint32 parameter_offset = IVAL(inbuf,smb_nt_ParameterOffset);
2028   uint32 data_count = IVAL(inbuf,smb_nt_DataCount);
2029   uint32 data_offset = IVAL(inbuf,smb_nt_DataOffset);
2030   uint16 setup_count = 2*CVAL(inbuf,smb_nt_SetupCount); /* setup count is in *words* */
2031   uint16 function_code = SVAL( inbuf, smb_nt_Function);
2032   char *params = NULL, *data = NULL, *setup = NULL;
2033   uint32 num_params_sofar, num_data_sofar;
2034
2035   if(global_oplock_break && (function_code == NT_TRANSACT_CREATE)) {
2036     /*
2037      * Queue this open message as we are the process of an oplock break.
2038      */
2039
2040     DEBUG(2,("reply_nttrans: queueing message NT_TRANSACT_CREATE \
2041 due to being in oplock break state.\n" ));
2042
2043     push_oplock_pending_smb_message( inbuf, length);
2044     return -1;
2045   }
2046
2047   if (IS_IPC(conn) && (function_code != NT_TRANSACT_CREATE))
2048     return (ERROR(ERRSRV,ERRaccess));
2049
2050   outsize = set_message(outbuf,0,0,True);
2051
2052   /* 
2053    * All nttrans messages we handle have smb_wct == 19 + setup_count.
2054    * Ensure this is so as a sanity check.
2055    */
2056
2057   if(CVAL(inbuf, smb_wct) != 19 + (setup_count/2)) {
2058     DEBUG(2,("Invalid smb_wct %d in nttrans call (should be %d)\n",
2059           CVAL(inbuf, smb_wct), 19 + (setup_count/2)));
2060     return(ERROR(ERRSRV,ERRerror));
2061   }
2062     
2063   /* Allocate the space for the setup, the maximum needed parameters and data */
2064
2065   if(setup_count > 0)
2066     setup = (char *)malloc(setup_count);
2067   if (total_parameter_count > 0)
2068     params = (char *)malloc(total_parameter_count);
2069   if (total_data_count > 0)
2070     data = (char *)malloc(total_data_count);
2071  
2072   if ((total_parameter_count && !params)  || (total_data_count && !data) ||
2073       (setup_count && !setup)) {
2074     DEBUG(0,("reply_nttrans : Out of memory\n"));
2075     return(ERROR(ERRDOS,ERRnomem));
2076   }
2077
2078   /* Copy the param and data bytes sent with this request into
2079      the params buffer */
2080   num_params_sofar = parameter_count;
2081   num_data_sofar = data_count;
2082
2083   if (parameter_count > total_parameter_count || data_count > total_data_count)
2084     exit_server("reply_nttrans: invalid sizes in packet.\n");
2085
2086   if(setup) {
2087     memcpy( setup, &inbuf[smb_nt_SetupStart], setup_count);
2088     DEBUG(10,("reply_nttrans: setup_count = %d\n", setup_count));
2089     dump_data(10, setup, setup_count);
2090   }
2091   if(params) {
2092     memcpy( params, smb_base(inbuf) + parameter_offset, parameter_count);
2093     DEBUG(10,("reply_nttrans: parameter_count = %d\n", parameter_count));
2094     dump_data(10, params, parameter_count);
2095   }
2096   if(data) {
2097     memcpy( data, smb_base(inbuf) + data_offset, data_count);
2098     DEBUG(10,("reply_nttrans: data_count = %d\n",data_count));
2099     dump_data(10, data, data_count);
2100   }
2101
2102   if(num_data_sofar < total_data_count || num_params_sofar < total_parameter_count) {
2103     /* We need to send an interim response then receive the rest
2104        of the parameter/data bytes */
2105     outsize = set_message(outbuf,0,0,True);
2106     send_smb(smbd_server_fd(),outbuf);
2107
2108     while( num_data_sofar < total_data_count || num_params_sofar < total_parameter_count) {
2109       BOOL ret;
2110
2111       ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
2112
2113       if((ret && (CVAL(inbuf, smb_com) != SMBnttranss)) || !ret) {
2114         outsize = set_message(outbuf,0,0,True);
2115         if(ret) {
2116                 DEBUG(0,("reply_nttrans: Invalid secondary nttrans packet\n"));
2117         } else {
2118                 DEBUG(0,("reply_nttrans: %s in getting secondary nttrans response.\n",
2119                          (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
2120         }
2121         if(params)
2122           free(params);
2123         if(data)
2124           free(data);
2125         if(setup)
2126           free(setup);
2127         return(ERROR(ERRSRV,ERRerror));
2128       }
2129       
2130       /* Revise total_params and total_data in case they have changed downwards */
2131       total_parameter_count = IVAL(inbuf, smb_nts_TotalParameterCount);
2132       total_data_count = IVAL(inbuf, smb_nts_TotalDataCount);
2133       num_params_sofar += (parameter_count = IVAL(inbuf,smb_nts_ParameterCount));
2134       num_data_sofar += ( data_count = IVAL(inbuf, smb_nts_DataCount));
2135       if (num_params_sofar > total_parameter_count || num_data_sofar > total_data_count)
2136         exit_server("reply_nttrans2: data overflow in secondary nttrans packet\n");
2137
2138       memcpy( &params[ IVAL(inbuf, smb_nts_ParameterDisplacement)], 
2139               smb_base(inbuf) + IVAL(inbuf, smb_nts_ParameterOffset), parameter_count);
2140       memcpy( &data[IVAL(inbuf, smb_nts_DataDisplacement)],
2141               smb_base(inbuf)+ IVAL(inbuf, smb_nts_DataOffset), data_count);
2142     }
2143   }
2144
2145   if (Protocol >= PROTOCOL_NT1) {
2146     uint16 flg2 = SVAL(outbuf,smb_flg2);
2147     SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
2148   }
2149
2150   /* Now we must call the relevant NT_TRANS function */
2151   switch(function_code) {
2152     case NT_TRANSACT_CREATE:
2153       outsize = call_nt_transact_create(conn, inbuf, outbuf, length, bufsize, 
2154                                         &setup, &params, &data);
2155       break;
2156     case NT_TRANSACT_IOCTL:
2157       outsize = call_nt_transact_ioctl(conn, 
2158                                        inbuf, outbuf, length, bufsize, 
2159                                        &setup, &params, &data);
2160       break;
2161     case NT_TRANSACT_SET_SECURITY_DESC:
2162       outsize = call_nt_transact_set_security_desc(conn, inbuf, outbuf, 
2163                                                    length, bufsize, 
2164                                                    &setup, &params, &data);
2165       break;
2166     case NT_TRANSACT_NOTIFY_CHANGE:
2167       outsize = call_nt_transact_notify_change(conn, inbuf, outbuf, 
2168                                                length, bufsize, 
2169                                                &setup, &params, &data);
2170       break;
2171     case NT_TRANSACT_RENAME:
2172       outsize = call_nt_transact_rename(conn, inbuf, outbuf, length, 
2173                                         bufsize, 
2174                                         &setup, &params, &data);
2175       break;
2176
2177     case NT_TRANSACT_QUERY_SECURITY_DESC:
2178       outsize = call_nt_transact_query_security_desc(conn, inbuf, outbuf, 
2179                                                      length, bufsize, 
2180                                                      &setup, &params, &data);
2181       break;
2182   default:
2183           /* Error in request */
2184           DEBUG(0,("reply_nttrans: Unknown request %d in nttrans call\n", function_code));
2185           if(setup)
2186                   free(setup);
2187           if(params)
2188                   free(params);
2189           if(data)
2190                   free(data);
2191           return (ERROR(ERRSRV,ERRerror));
2192   }
2193
2194   /* As we do not know how many data packets will need to be
2195      returned here the various call_nt_transact_xxxx calls
2196      must send their own. Thus a call_nt_transact_xxxx routine only
2197      returns a value other than -1 when it wants to send
2198      an error packet. 
2199   */
2200
2201   if(setup)
2202     free(setup);
2203   if(params)
2204     free(params);
2205   if(data)
2206     free(data);
2207   return outsize; /* If a correct response was needed the call_nt_transact_xxxx 
2208                      calls have already sent it. If outsize != -1 then it is
2209                      returning an error packet. */
2210 }
2211 #undef OLD_NTDOMAIN