source: trunk/samba/source/smbd/nttrans.c @ 26

Last change on this file since 26 was 26, checked in by Paul Smedley, 14 years ago

Updated source to 3.0.25rc1

File size: 91.6 KB
Line 
1/*
2   Unix SMB/CIFS implementation.
3   SMB NT transaction handling
4   Copyright (C) Jeremy Allison                 1994-1998
5   Copyright (C) Stefan (metze) Metzmacher      2003
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20*/
21
22#include "includes.h"
23
24extern int max_send;
25extern enum protocol_types Protocol;
26extern int smb_read_error;
27extern struct current_user current_user;
28
29static const char *known_nt_pipes[] = {
30        "\\LANMAN",
31        "\\srvsvc",
32        "\\samr",
33        "\\wkssvc",
34        "\\NETLOGON",
35        "\\ntlsa",
36        "\\ntsvcs",
37        "\\lsass",
38        "\\lsarpc",
39        "\\winreg",
40        "\\initshutdown",
41        "\\spoolss",
42        "\\netdfs",
43        "\\rpcecho",
44        "\\svcctl",
45        "\\eventlog",
46        "\\unixinfo",
47        NULL
48};
49
50static char *nttrans_realloc(char **ptr, size_t size)
51{
52        if (ptr==NULL) {
53                smb_panic("nttrans_realloc() called with NULL ptr\n");
54        }
55               
56        *ptr = (char *)SMB_REALLOC(*ptr, size);
57        if(*ptr == NULL) {
58                return NULL;
59        }
60        memset(*ptr,'\0',size);
61        return *ptr;
62}
63
64/****************************************************************************
65 Send the required number of replies back.
66 We assume all fields other than the data fields are
67 set correctly for the type of call.
68 HACK ! Always assumes smb_setup field is zero.
69****************************************************************************/
70
71int send_nt_replies(char *outbuf, int bufsize, NTSTATUS nt_error,
72                    char *params, int paramsize, char *pdata, int datasize)
73{
74        int data_to_send = datasize;
75        int params_to_send = paramsize;
76        int useable_space;
77        char *pp = params;
78        char *pd = pdata;
79        int params_sent_thistime, data_sent_thistime, total_sent_thistime;
80        int alignment_offset = 3;
81        int data_alignment_offset = 0;
82
83        /*
84         * Initially set the wcnt area to be 18 - this is true for all
85         * transNT replies.
86         */
87
88        set_message(outbuf,18,0,True);
89
90        if (NT_STATUS_V(nt_error)) {
91                ERROR_NT(nt_error);
92        }
93
94        /*
95         * If there genuinely are no parameters or data to send just send
96         * the empty packet.
97         */
98
99        if(params_to_send == 0 && data_to_send == 0) {
100                show_msg(outbuf);
101                if (!send_smb(smbd_server_fd(),outbuf)) {
102                        exit_server_cleanly("send_nt_replies: send_smb failed.");
103                }
104                return 0;
105        }
106
107        /*
108         * When sending params and data ensure that both are nicely aligned.
109         * Only do this alignment when there is also data to send - else
110         * can cause NT redirector problems.
111         */
112
113        if (((params_to_send % 4) != 0) && (data_to_send != 0)) {
114                data_alignment_offset = 4 - (params_to_send % 4);
115        }
116
117        /*
118         * Space is bufsize minus Netbios over TCP header minus SMB header.
119         * The alignment_offset is to align the param bytes on a four byte
120         * boundary (2 bytes for data len, one byte pad).
121         * NT needs this to work correctly.
122         */
123
124        useable_space = bufsize - ((smb_buf(outbuf)+
125                                alignment_offset+data_alignment_offset) -
126                                outbuf);
127
128        /*
129         * useable_space can never be more than max_send minus the
130         * alignment offset.
131         */
132
133        useable_space = MIN(useable_space,
134                                max_send - (alignment_offset+data_alignment_offset));
135
136
137        while (params_to_send || data_to_send) {
138
139                /*
140                 * Calculate whether we will totally or partially fill this packet.
141                 */
142
143                total_sent_thistime = params_to_send + data_to_send +
144                                        alignment_offset + data_alignment_offset;
145
146                /*
147                 * We can never send more than useable_space.
148                 */
149
150                total_sent_thistime = MIN(total_sent_thistime, useable_space);
151
152                set_message(outbuf, 18, total_sent_thistime, True);
153
154                /*
155                 * Set total params and data to be sent.
156                 */
157
158                SIVAL(outbuf,smb_ntr_TotalParameterCount,paramsize);
159                SIVAL(outbuf,smb_ntr_TotalDataCount,datasize);
160
161                /*
162                 * Calculate how many parameters and data we can fit into
163                 * this packet. Parameters get precedence.
164                 */
165
166                params_sent_thistime = MIN(params_to_send,useable_space);
167                data_sent_thistime = useable_space - params_sent_thistime;
168                data_sent_thistime = MIN(data_sent_thistime,data_to_send);
169
170                SIVAL(outbuf,smb_ntr_ParameterCount,params_sent_thistime);
171
172                if(params_sent_thistime == 0) {
173                        SIVAL(outbuf,smb_ntr_ParameterOffset,0);
174                        SIVAL(outbuf,smb_ntr_ParameterDisplacement,0);
175                } else {
176                        /*
177                         * smb_ntr_ParameterOffset is the offset from the start of the SMB header to the
178                         * parameter bytes, however the first 4 bytes of outbuf are
179                         * the Netbios over TCP header. Thus use smb_base() to subtract
180                         * them from the calculation.
181                         */
182
183                        SIVAL(outbuf,smb_ntr_ParameterOffset,
184                                ((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
185                        /*
186                         * Absolute displacement of param bytes sent in this packet.
187                         */
188
189                        SIVAL(outbuf,smb_ntr_ParameterDisplacement,pp - params);
190                }
191
192                /*
193                 * Deal with the data portion.
194                 */
195
196                SIVAL(outbuf,smb_ntr_DataCount, data_sent_thistime);
197
198                if(data_sent_thistime == 0) {
199                        SIVAL(outbuf,smb_ntr_DataOffset,0);
200                        SIVAL(outbuf,smb_ntr_DataDisplacement, 0);
201                } else {
202                        /*
203                         * The offset of the data bytes is the offset of the
204                         * parameter bytes plus the number of parameters being sent this time.
205                         */
206
207                        SIVAL(outbuf,smb_ntr_DataOffset,((smb_buf(outbuf)+alignment_offset) -
208                                smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
209                                SIVAL(outbuf,smb_ntr_DataDisplacement, pd - pdata);
210                }
211
212                /*
213                 * Copy the param bytes into the packet.
214                 */
215
216                if(params_sent_thistime) {
217                        memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
218                }
219
220                /*
221                 * Copy in the data bytes
222                 */
223
224                if(data_sent_thistime) {
225                        memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
226                                data_alignment_offset,pd,data_sent_thistime);
227                }
228   
229                DEBUG(9,("nt_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
230                        params_sent_thistime, data_sent_thistime, useable_space));
231                DEBUG(9,("nt_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
232                        params_to_send, data_to_send, paramsize, datasize));
233   
234                /* Send the packet */
235                show_msg(outbuf);
236                if (!send_smb(smbd_server_fd(),outbuf)) {
237                        exit_server_cleanly("send_nt_replies: send_smb failed.");
238                }
239   
240                pp += params_sent_thistime;
241                pd += data_sent_thistime;
242   
243                params_to_send -= params_sent_thistime;
244                data_to_send -= data_sent_thistime;
245
246                /*
247                 * Sanity check
248                 */
249
250                if(params_to_send < 0 || data_to_send < 0) {
251                        DEBUG(0,("send_nt_replies failed sanity check pts = %d, dts = %d\n!!!",
252                                params_to_send, data_to_send));
253                        return -1;
254                }
255        } 
256
257        return 0;
258}
259
260/****************************************************************************
261 Is it an NTFS stream name ?
262****************************************************************************/
263
264BOOL is_ntfs_stream_name(const char *fname)
265{
266        if (lp_posix_pathnames()) {
267                return False;
268        }
269        return (strchr_m(fname, ':') != NULL) ? True : False;
270}
271
272/****************************************************************************
273 Save case statics.
274****************************************************************************/
275
276static BOOL saved_case_sensitive;
277static BOOL saved_case_preserve;
278static BOOL saved_short_case_preserve;
279
280/****************************************************************************
281 Save case semantics.
282****************************************************************************/
283
284static uint32 set_posix_case_semantics(connection_struct *conn, uint32 file_attributes)
285{
286        if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
287                return file_attributes;
288        }
289
290        saved_case_sensitive = conn->case_sensitive;
291        saved_case_preserve = conn->case_preserve;
292        saved_short_case_preserve = conn->short_case_preserve;
293
294        /* Set to POSIX. */
295        conn->case_sensitive = True;
296        conn->case_preserve = True;
297        conn->short_case_preserve = True;
298
299        return (file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
300}
301
302/****************************************************************************
303 Restore case semantics.
304****************************************************************************/
305
306static void restore_case_semantics(connection_struct *conn, uint32 file_attributes)
307{
308        if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
309                return;
310        }
311
312        conn->case_sensitive = saved_case_sensitive;
313        conn->case_preserve = saved_case_preserve;
314        conn->short_case_preserve = saved_short_case_preserve;
315}
316
317/****************************************************************************
318 Reply to an NT create and X call on a pipe.
319****************************************************************************/
320
321static int nt_open_pipe(char *fname, connection_struct *conn,
322                        char *inbuf, char *outbuf, int *ppnum)
323{
324        smb_np_struct *p = NULL;
325        uint16 vuid = SVAL(inbuf, smb_uid);
326        int i;
327 
328        DEBUG(4,("nt_open_pipe: Opening pipe %s.\n", fname));
329   
330        /* See if it is one we want to handle. */
331
332        if (lp_disable_spoolss() && strequal(fname, "\\spoolss")) {
333                return(ERROR_BOTH(NT_STATUS_OBJECT_NAME_NOT_FOUND,ERRDOS,ERRbadpipe));
334        }
335
336        for( i = 0; known_nt_pipes[i]; i++ ) {
337                if( strequal(fname,known_nt_pipes[i])) {
338                        break;
339                }
340        }
341   
342        if ( known_nt_pipes[i] == NULL ) {
343                return(ERROR_BOTH(NT_STATUS_OBJECT_NAME_NOT_FOUND,ERRDOS,ERRbadpipe));
344        }
345   
346        /* Strip \\ off the name. */
347        fname++;
348   
349        DEBUG(3,("nt_open_pipe: Known pipe %s opening.\n", fname));
350
351        p = open_rpc_pipe_p(fname, conn, vuid);
352        if (!p) {
353                return(ERROR_DOS(ERRSRV,ERRnofids));
354        }
355
356        /* Add pipe to db */
357       
358        if ( !store_pipe_opendb( p ) ) {
359                DEBUG(3,("nt_open_pipe: failed to store %s pipe open.\n", fname));
360        }
361       
362        *ppnum = p->pnum;
363        return 0;
364}
365
366/****************************************************************************
367 Reply to an NT create and X call for pipes.
368****************************************************************************/
369
370static int do_ntcreate_pipe_open(connection_struct *conn,
371                         char *inbuf,char *outbuf,int length,int bufsize)
372{
373        pstring fname;
374        int ret;
375        int pnum = -1;
376        char *p = NULL;
377        uint32 flags = IVAL(inbuf,smb_ntcreate_Flags);
378
379        srvstr_pull_buf(inbuf, fname, smb_buf(inbuf), sizeof(fname), STR_TERMINATE);
380
381        if ((ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum)) != 0) {
382                return ret;
383        }
384
385        /*
386         * Deal with pipe return.
387         */ 
388
389        if (flags & EXTENDED_RESPONSE_REQUIRED) {
390                /* This is very strange. We
391                 * return 50 words, but only set
392                 * the wcnt to 42 ? It's definately
393                 * what happens on the wire....
394                 */
395                set_message(outbuf,50,0,True);
396                SCVAL(outbuf,smb_wct,42);
397        } else {
398                set_message(outbuf,34,0,True);
399        }
400
401        p = outbuf + smb_vwv2;
402        p++;
403        SSVAL(p,0,pnum);
404        p += 2;
405        SIVAL(p,0,FILE_WAS_OPENED);
406        p += 4;
407        p += 32;
408        SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
409        p += 20;
410        /* File type. */
411        SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
412        /* Device state. */
413        SSVAL(p,2, 0x5FF); /* ? */
414        p += 4;
415
416        if (flags & EXTENDED_RESPONSE_REQUIRED) {
417                p += 26;
418                SIVAL(p,0,FILE_GENERIC_ALL);
419                /*
420                 * For pipes W2K3 seems to return
421                 * 0x12019B next.
422                 * This is ((FILE_GENERIC_READ|FILE_GENERIC_WRITE) & ~FILE_APPEND_DATA)
423                 */
424                SIVAL(p,4,(FILE_GENERIC_READ|FILE_GENERIC_WRITE)&~FILE_APPEND_DATA);
425        }
426
427        DEBUG(5,("do_ntcreate_pipe_open: open pipe = %s\n", fname));
428
429        return chain_reply(inbuf,outbuf,length,bufsize);
430}
431
432/****************************************************************************
433 Reply to an NT create and X call for a quota file.
434****************************************************************************/
435
436int reply_ntcreate_and_X_quota(connection_struct *conn,
437                                char *inbuf,
438                                char *outbuf,
439                                int length,
440                                int bufsize,
441                                enum FAKE_FILE_TYPE fake_file_type,
442                                const char *fname)
443{
444        int result;
445        char *p;
446        uint32 desired_access = IVAL(inbuf,smb_ntcreate_DesiredAccess);
447        files_struct *fsp;
448        NTSTATUS status;
449
450        status = open_fake_file(conn, fake_file_type, fname, desired_access,
451                                &fsp);
452
453        if (!NT_STATUS_IS_OK(status)) {
454                return ERROR_NT(status);
455        }
456
457        set_message(outbuf,34,0,True);
458       
459        p = outbuf + smb_vwv2;
460       
461        /* SCVAL(p,0,NO_OPLOCK_RETURN); */
462        p++;
463        SSVAL(p,0,fsp->fnum);
464
465        DEBUG(5,("reply_ntcreate_and_X_quota: fnum = %d, open name = %s\n", fsp->fnum, fsp->fsp_name));
466
467        result = chain_reply(inbuf,outbuf,length,bufsize);
468        return result;
469}
470
471/****************************************************************************
472 Reply to an NT create and X call.
473****************************************************************************/
474
475int reply_ntcreate_and_X(connection_struct *conn,
476                         char *inbuf,char *outbuf,int length,int bufsize)
477{ 
478        int result;
479        pstring fname;
480        uint32 flags = IVAL(inbuf,smb_ntcreate_Flags);
481        uint32 access_mask = IVAL(inbuf,smb_ntcreate_DesiredAccess);
482        uint32 file_attributes = IVAL(inbuf,smb_ntcreate_FileAttributes);
483        uint32 new_file_attributes;
484        uint32 share_access = IVAL(inbuf,smb_ntcreate_ShareAccess);
485        uint32 create_disposition = IVAL(inbuf,smb_ntcreate_CreateDisposition);
486        uint32 create_options = IVAL(inbuf,smb_ntcreate_CreateOptions);
487        uint16 root_dir_fid = (uint16)IVAL(inbuf,smb_ntcreate_RootDirectoryFid);
488        /* Breakout the oplock request bits so we can set the
489           reply bits separately. */
490        int oplock_request = 0;
491        uint32 fattr=0;
492        SMB_OFF_T file_len = 0;
493        SMB_STRUCT_STAT sbuf;
494        int info = 0;
495        files_struct *fsp = NULL;
496        char *p = NULL;
497        struct timespec c_timespec;
498        struct timespec a_timespec;
499        struct timespec m_timespec;
500        BOOL extended_oplock_granted = False;
501        NTSTATUS status;
502
503        START_PROFILE(SMBntcreateX);
504
505        DEBUG(10,("reply_ntcreate_and_X: flags = 0x%x, access_mask = 0x%x "
506                  "file_attributes = 0x%x, share_access = 0x%x, "
507                  "create_disposition = 0x%x create_options = 0x%x "
508                  "root_dir_fid = 0x%x\n",
509                        (unsigned int)flags,
510                        (unsigned int)access_mask,
511                        (unsigned int)file_attributes,
512                        (unsigned int)share_access,
513                        (unsigned int)create_disposition,
514                        (unsigned int)create_options,
515                        (unsigned int)root_dir_fid ));
516
517        /*
518         * If it's an IPC, use the pipe handler.
519         */
520
521        if (IS_IPC(conn)) {
522                if (lp_nt_pipe_support()) {
523                        END_PROFILE(SMBntcreateX);
524                        return do_ntcreate_pipe_open(conn,inbuf,outbuf,length,bufsize);
525                } else {
526                        END_PROFILE(SMBntcreateX);
527                        return(ERROR_DOS(ERRDOS,ERRnoaccess));
528                }
529        }
530
531        if (create_options & FILE_OPEN_BY_FILE_ID) {
532                END_PROFILE(SMBntcreateX);
533                return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
534        }
535
536        /*
537         * Get the file name.
538         */
539
540        if(root_dir_fid != 0) {
541                /*
542                 * This filename is relative to a directory fid.
543                 */
544                pstring rel_fname;
545                files_struct *dir_fsp = file_fsp(inbuf,smb_ntcreate_RootDirectoryFid);
546                size_t dir_name_len;
547
548                if(!dir_fsp) {
549                        END_PROFILE(SMBntcreateX);
550                        return ERROR_DOS(ERRDOS,ERRbadfid);
551                }
552
553                if(!dir_fsp->is_directory) {
554
555                        srvstr_get_path(inbuf, fname, smb_buf(inbuf), sizeof(fname), 0, STR_TERMINATE, &status);
556                        if (!NT_STATUS_IS_OK(status)) {
557                                END_PROFILE(SMBntcreateX);
558                                return ERROR_NT(status);
559                        }
560
561                        /*
562                         * Check to see if this is a mac fork of some kind.
563                         */
564
565                        if( is_ntfs_stream_name(fname)) {
566                                END_PROFILE(SMBntcreateX);
567                                return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
568                        }
569
570                        /*
571                          we need to handle the case when we get a
572                          relative open relative to a file and the
573                          pathname is blank - this is a reopen!
574                          (hint from demyn plantenberg)
575                        */
576
577                        END_PROFILE(SMBntcreateX);
578                        return(ERROR_DOS(ERRDOS,ERRbadfid));
579                }
580
581                /*
582                 * Copy in the base directory name.
583                 */
584
585                pstrcpy( fname, dir_fsp->fsp_name );
586                dir_name_len = strlen(fname);
587
588                /*
589                 * Ensure it ends in a '\'.
590                 */
591
592                if((fname[dir_name_len-1] != '\\') && (fname[dir_name_len-1] != '/')) {
593                        pstrcat(fname, "/");
594                        dir_name_len++;
595                }
596
597                srvstr_get_path(inbuf, rel_fname, smb_buf(inbuf), sizeof(rel_fname), 0, STR_TERMINATE, &status);
598                if (!NT_STATUS_IS_OK(status)) {
599                        END_PROFILE(SMBntcreateX);
600                        return ERROR_NT(status);
601                }
602                pstrcat(fname, rel_fname);
603        } else {
604                srvstr_get_path(inbuf, fname, smb_buf(inbuf), sizeof(fname), 0, STR_TERMINATE, &status);
605                if (!NT_STATUS_IS_OK(status)) {
606                        END_PROFILE(SMBntcreateX);
607                        return ERROR_NT(status);
608                }
609
610                /*
611                 * Check to see if this is a mac fork of some kind.
612                 */
613
614                if( is_ntfs_stream_name(fname)) {
615                        enum FAKE_FILE_TYPE fake_file_type = is_fake_file(fname);
616                        if (fake_file_type!=FAKE_FILE_TYPE_NONE) {
617                                /*
618                                 * Here we go! support for changing the disk quotas --metze
619                                 *
620                                 * We need to fake up to open this MAGIC QUOTA file
621                                 * and return a valid FID.
622                                 *
623                                 * w2k close this file directly after openening
624                                 * xp also tries a QUERY_FILE_INFO on the file and then close it
625                                 */
626                                result = reply_ntcreate_and_X_quota(conn, inbuf, outbuf, length, bufsize,
627                                                                fake_file_type, fname);
628                                END_PROFILE(SMBntcreateX);
629                                return result;
630                        } else {
631                                END_PROFILE(SMBntcreateX);
632                                return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
633                        }
634                }
635        }
636       
637        /*
638         * Now contruct the smb_open_mode value from the filename,
639         * desired access and the share access.
640         */
641        status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
642        if (!NT_STATUS_IS_OK(status)) {
643                END_PROFILE(SMBntcreateX);
644                if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
645                        return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
646                }
647                return ERROR_NT(status);
648        }
649
650        oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
651        if (oplock_request) {
652                oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
653        }
654
655        /*
656         * Ordinary file or directory.
657         */
658               
659        /*
660         * Check if POSIX semantics are wanted.
661         */
662               
663        new_file_attributes = set_posix_case_semantics(conn, file_attributes);
664               
665        status = unix_convert(conn, fname, False, NULL, &sbuf);
666        if (!NT_STATUS_IS_OK(status)) {
667                restore_case_semantics(conn, file_attributes);
668                END_PROFILE(SMBntcreateX);
669                return ERROR_NT(status);
670        }
671        /* All file access must go through check_name() */
672        status = check_name(conn, fname);
673        if (!NT_STATUS_IS_OK(status)) {
674                restore_case_semantics(conn, file_attributes);
675                END_PROFILE(SMBntcreateX);
676                return ERROR_NT(status);
677        }
678
679        /* This is the correct thing to do (check every time) but can_delete is
680           expensive (it may have to read the parent directory permissions). So
681           for now we're not doing it unless we have a strong hint the client
682           is really going to delete this file. If the client is forcing FILE_CREATE
683           let the filesystem take care of the permissions. */
684
685        /* Setting FILE_SHARE_DELETE is the hint. */
686
687        if (lp_acl_check_permissions(SNUM(conn))
688            && (create_disposition != FILE_CREATE)
689            && (share_access & FILE_SHARE_DELETE)
690            && (access_mask & DELETE_ACCESS)) {
691                if ((dos_mode(conn, fname, &sbuf) & FILE_ATTRIBUTE_READONLY) ||
692                                !can_delete_file_in_directory(conn, fname)) {
693                        restore_case_semantics(conn, file_attributes);
694                        END_PROFILE(SMBntcreateX);
695                        return ERROR_NT(NT_STATUS_ACCESS_DENIED);
696                }
697        }
698
699        /*
700         * If it's a request for a directory open, deal with it separately.
701         */
702
703        if(create_options & FILE_DIRECTORY_FILE) {
704
705                /* Can't open a temp directory. IFS kit test. */
706                if (file_attributes & FILE_ATTRIBUTE_TEMPORARY) {
707                        END_PROFILE(SMBntcreateX);
708                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
709                }
710
711                oplock_request = 0;
712                status = open_directory(conn, fname, &sbuf,
713                                        access_mask,
714                                        share_access,
715                                        create_disposition,
716                                        create_options,
717                                        new_file_attributes,
718                                        &info, &fsp);
719
720                restore_case_semantics(conn, file_attributes);
721
722                if(!NT_STATUS_IS_OK(status)) {
723                        if (!use_nt_status() && NT_STATUS_EQUAL(
724                                    status, NT_STATUS_OBJECT_NAME_COLLISION)) {
725                                status = NT_STATUS_DOS(ERRDOS, ERRfilexists);
726                        }
727                        END_PROFILE(SMBntcreateX);
728                        return ERROR_NT(status);
729                }
730
731        } else {
732
733                /*
734                 * Ordinary file case.
735                 */
736
737                /* NB. We have a potential bug here. If we
738                 * cause an oplock break to ourselves, then we
739                 * could end up processing filename related
740                 * SMB requests whilst we await the oplock
741                 * break response. As we may have changed the
742                 * filename case semantics to be POSIX-like,
743                 * this could mean a filename request could
744                 * fail when it should succeed. This is a rare
745                 * condition, but eventually we must arrange
746                 * to restore the correct case semantics
747                 * before issuing an oplock break request to
748                 * our client. JRA.  */
749
750                status = open_file_ntcreate(conn,fname,&sbuf,
751                                        access_mask,
752                                        share_access,
753                                        create_disposition,
754                                        create_options,
755                                        new_file_attributes,
756                                        oplock_request,
757                                        &info, &fsp);
758
759                if (!NT_STATUS_IS_OK(status)) { 
760                        /* We cheat here. There are two cases we
761                         * care about. One is a directory rename,
762                         * where the NT client will attempt to
763                         * open the source directory for
764                         * DELETE access. Note that when the
765                         * NT client does this it does *not*
766                         * set the directory bit in the
767                         * request packet. This is translated
768                         * into a read/write open
769                         * request. POSIX states that any open
770                         * for write request on a directory
771                         * will generate an EISDIR error, so
772                         * we can catch this here and open a
773                         * pseudo handle that is flagged as a
774                         * directory. The second is an open
775                         * for a permissions read only, which
776                         * we handle in the open_file_stat case. JRA.
777                         */
778
779                        if (NT_STATUS_EQUAL(status,
780                                            NT_STATUS_FILE_IS_A_DIRECTORY)) {
781
782                                /*
783                                 * Fail the open if it was explicitly a non-directory file.
784                                 */
785
786                                if (create_options & FILE_NON_DIRECTORY_FILE) {
787                                        restore_case_semantics(conn, file_attributes);
788                                        END_PROFILE(SMBntcreateX);
789                                        return ERROR_FORCE_NT(NT_STATUS_FILE_IS_A_DIRECTORY);
790                                }
791       
792                                oplock_request = 0;
793                                status = open_directory(conn, fname, &sbuf,
794                                                        access_mask,
795                                                        share_access,
796                                                        create_disposition,
797                                                        create_options,
798                                                        new_file_attributes,
799                                                        &info, &fsp);
800
801                                if(!NT_STATUS_IS_OK(status)) {
802                                        restore_case_semantics(conn, file_attributes);
803                                        if (!use_nt_status() && NT_STATUS_EQUAL(
804                                                    status, NT_STATUS_OBJECT_NAME_COLLISION)) {
805                                                status = NT_STATUS_DOS(ERRDOS, ERRfilexists);
806                                        }
807                                        END_PROFILE(SMBntcreateX);
808                                        return ERROR_NT(status);
809                                }
810                        } else {
811                                restore_case_semantics(conn, file_attributes);
812                                END_PROFILE(SMBntcreateX);
813                                if (open_was_deferred(SVAL(inbuf,smb_mid))) {
814                                        /* We have re-scheduled this call. */
815                                        return -1;
816                                }
817                                return ERROR_NT(status);
818                        }
819                } 
820        }
821               
822        restore_case_semantics(conn, file_attributes);
823
824        file_len = sbuf.st_size;
825        fattr = dos_mode(conn,fname,&sbuf);
826        if(fattr == 0) {
827                fattr = FILE_ATTRIBUTE_NORMAL;
828        }
829        if (!fsp->is_directory && (fattr & aDIR)) {
830                close_file(fsp,ERROR_CLOSE);
831                END_PROFILE(SMBntcreateX);
832                return ERROR_DOS(ERRDOS,ERRnoaccess);
833        } 
834       
835        /* Save the requested allocation size. */
836        if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
837                SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)IVAL(inbuf,smb_ntcreate_AllocationSize);
838#ifdef LARGE_SMB_OFF_T
839                allocation_size |= (((SMB_BIG_UINT)IVAL(inbuf,smb_ntcreate_AllocationSize + 4)) << 32);
840#endif
841                if (allocation_size && (allocation_size > (SMB_BIG_UINT)file_len)) {
842                        fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
843                        if (fsp->is_directory) {
844                                close_file(fsp,ERROR_CLOSE);
845                                END_PROFILE(SMBntcreateX);
846                                /* Can't set allocation size on a directory. */
847                                return ERROR_NT(NT_STATUS_ACCESS_DENIED);
848                        }
849                        if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
850                                close_file(fsp,ERROR_CLOSE);
851                                END_PROFILE(SMBntcreateX);
852                                return ERROR_NT(NT_STATUS_DISK_FULL);
853                        }
854                } else {
855                        fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)file_len);
856                }
857        }
858
859        /*
860         * If the caller set the extended oplock request bit
861         * and we granted one (by whatever means) - set the
862         * correct bit for extended oplock reply.
863         */
864
865        if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
866                extended_oplock_granted = True;
867        }
868
869        if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
870                extended_oplock_granted = True;
871        }
872
873        if (flags & EXTENDED_RESPONSE_REQUIRED) {
874                /* This is very strange. We
875                 * return 50 words, but only set
876                 * the wcnt to 42 ? It's definately
877                 * what happens on the wire....
878                 */
879                set_message(outbuf,50,0,True);
880                SCVAL(outbuf,smb_wct,42);
881        } else {
882                set_message(outbuf,34,0,True);
883        }
884
885        p = outbuf + smb_vwv2;
886       
887        /*
888         * Currently as we don't support level II oplocks we just report
889         * exclusive & batch here.
890         */
891
892        if (extended_oplock_granted) {
893                if (flags & REQUEST_BATCH_OPLOCK) {
894                        SCVAL(p,0, BATCH_OPLOCK_RETURN);
895                } else {
896                        SCVAL(p,0, EXCLUSIVE_OPLOCK_RETURN);
897                }
898        } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
899                SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
900        } else {
901                SCVAL(p,0,NO_OPLOCK_RETURN);
902        }
903       
904        p++;
905        SSVAL(p,0,fsp->fnum);
906        p += 2;
907        if ((create_disposition == FILE_SUPERSEDE) && (info == FILE_WAS_OVERWRITTEN)) {
908                SIVAL(p,0,FILE_WAS_SUPERSEDED);
909        } else {
910                SIVAL(p,0,info);
911        }
912        p += 4;
913
914        /* Create time. */
915        c_timespec = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
916        a_timespec = get_atimespec(&sbuf);
917        m_timespec = get_mtimespec(&sbuf);
918
919        if (lp_dos_filetime_resolution(SNUM(conn))) {
920                dos_filetime_timespec(&c_timespec);
921                dos_filetime_timespec(&a_timespec);
922                dos_filetime_timespec(&m_timespec);
923        }
924
925        put_long_date_timespec(p, c_timespec); /* create time. */
926        p += 8;
927        put_long_date_timespec(p, a_timespec); /* access time */
928        p += 8;
929        put_long_date_timespec(p, m_timespec); /* write time */
930        p += 8;
931        put_long_date_timespec(p, m_timespec); /* change time */
932        p += 8;
933        SIVAL(p,0,fattr); /* File Attributes. */
934        p += 4;
935        SOFF_T(p, 0, get_allocation_size(conn,fsp,&sbuf));
936        p += 8;
937        SOFF_T(p,0,file_len);
938        p += 8;
939        if (flags & EXTENDED_RESPONSE_REQUIRED) {
940                SSVAL(p,2,0x7);
941        }
942        p += 4;
943        SCVAL(p,0,fsp->is_directory ? 1 : 0);
944
945        if (flags & EXTENDED_RESPONSE_REQUIRED) {
946                uint32 perms = 0;
947                p += 26;
948                if (fsp->is_directory || can_write_to_file(conn, fname, &sbuf)) {
949                        perms = FILE_GENERIC_ALL;
950                } else {
951                        perms = FILE_GENERIC_READ|FILE_EXECUTE;
952                }
953                SIVAL(p,0,perms);
954        }
955
956        DEBUG(5,("reply_ntcreate_and_X: fnum = %d, open name = %s\n", fsp->fnum, fsp->fsp_name));
957
958        result = chain_reply(inbuf,outbuf,length,bufsize);
959        END_PROFILE(SMBntcreateX);
960        return result;
961}
962
963/****************************************************************************
964 Reply to a NT_TRANSACT_CREATE call to open a pipe.
965****************************************************************************/
966
967static int do_nt_transact_create_pipe( connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
968                                  uint16 **ppsetup, uint32 setup_count,
969                                  char **ppparams, uint32 parameter_count,
970                                  char **ppdata, uint32 data_count)
971{
972        pstring fname;
973        char *params = *ppparams;
974        int ret;
975        int pnum = -1;
976        char *p = NULL;
977        NTSTATUS status;
978        size_t param_len;
979        uint32 flags;
980
981        /*
982         * Ensure minimum number of parameters sent.
983         */
984
985        if(parameter_count < 54) {
986                DEBUG(0,("do_nt_transact_create_pipe - insufficient parameters (%u)\n", (unsigned int)parameter_count));
987                return ERROR_DOS(ERRDOS,ERRnoaccess);
988        }
989
990        flags = IVAL(params,0);
991
992        srvstr_get_path(inbuf, fname, params+53, sizeof(fname), parameter_count-53, STR_TERMINATE, &status);
993        if (!NT_STATUS_IS_OK(status)) {
994                return ERROR_NT(status);
995        }
996
997        if ((ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum)) != 0) {
998                return ret;
999        }
1000       
1001        /* Realloc the size of parameters and data we will return */
1002        if (flags & EXTENDED_RESPONSE_REQUIRED) {
1003                /* Extended response is 32 more byyes. */
1004                param_len = 101;
1005        } else {
1006                param_len = 69;
1007        }
1008        params = nttrans_realloc(ppparams, param_len);
1009        if(params == NULL) {
1010                return ERROR_DOS(ERRDOS,ERRnomem);
1011        }
1012       
1013        p = params;
1014        SCVAL(p,0,NO_OPLOCK_RETURN);
1015       
1016        p += 2;
1017        SSVAL(p,0,pnum);
1018        p += 2;
1019        SIVAL(p,0,FILE_WAS_OPENED);
1020        p += 8;
1021       
1022        p += 32;
1023        SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
1024        p += 20;
1025        /* File type. */
1026        SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
1027        /* Device state. */
1028        SSVAL(p,2, 0x5FF); /* ? */
1029        p += 4;
1030       
1031        if (flags & EXTENDED_RESPONSE_REQUIRED) {
1032                p += 26;
1033                SIVAL(p,0,FILE_GENERIC_ALL);
1034                /*
1035                 * For pipes W2K3 seems to return
1036                 * 0x12019B next.
1037                 * This is ((FILE_GENERIC_READ|FILE_GENERIC_WRITE) & ~FILE_APPEND_DATA)
1038                 */
1039                SIVAL(p,4,(FILE_GENERIC_READ|FILE_GENERIC_WRITE)&~FILE_APPEND_DATA);
1040        }
1041
1042        DEBUG(5,("do_nt_transact_create_pipe: open name = %s\n", fname));
1043       
1044        /* Send the required number of replies */
1045        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, params, param_len, *ppdata, 0);
1046       
1047        return -1;
1048}
1049
1050/****************************************************************************
1051 Internal fn to set security descriptors.
1052****************************************************************************/
1053
1054static NTSTATUS set_sd(files_struct *fsp, char *data, uint32 sd_len, uint32 security_info_sent)
1055{
1056        prs_struct pd;
1057        SEC_DESC *psd = NULL;
1058        TALLOC_CTX *mem_ctx;
1059        BOOL ret;
1060       
1061        if (sd_len == 0 || !lp_nt_acl_support(SNUM(fsp->conn))) {
1062                return NT_STATUS_OK;
1063        }
1064
1065        /*
1066         * Init the parse struct we will unmarshall from.
1067         */
1068
1069        if ((mem_ctx = talloc_init("set_sd")) == NULL) {
1070                DEBUG(0,("set_sd: talloc_init failed.\n"));
1071                return NT_STATUS_NO_MEMORY;
1072        }
1073
1074        prs_init(&pd, 0, mem_ctx, UNMARSHALL);
1075
1076        /*
1077         * Setup the prs_struct to point at the memory we just
1078         * allocated.
1079         */
1080       
1081        prs_give_memory( &pd, data, sd_len, False);
1082
1083        /*
1084         * Finally, unmarshall from the data buffer.
1085         */
1086
1087        if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
1088                DEBUG(0,("set_sd: Error in unmarshalling security descriptor.\n"));
1089                /*
1090                 * Return access denied for want of a better error message..
1091                 */ 
1092                talloc_destroy(mem_ctx);
1093                return NT_STATUS_NO_MEMORY;
1094        }
1095       
1096        if (psd->owner_sid==0) {
1097                security_info_sent &= ~OWNER_SECURITY_INFORMATION;
1098        }
1099        if (psd->group_sid==0) {
1100                security_info_sent &= ~GROUP_SECURITY_INFORMATION;
1101        }
1102        if (psd->sacl==0) {
1103                security_info_sent &= ~SACL_SECURITY_INFORMATION;
1104        }
1105        if (psd->dacl==0) {
1106                security_info_sent &= ~DACL_SECURITY_INFORMATION;
1107        }
1108       
1109        ret = SMB_VFS_FSET_NT_ACL( fsp, fsp->fh->fd, security_info_sent, psd);
1110       
1111        if (!ret) {
1112                talloc_destroy(mem_ctx);
1113                return NT_STATUS_ACCESS_DENIED;
1114        }
1115       
1116        talloc_destroy(mem_ctx);
1117       
1118        return NT_STATUS_OK;
1119}
1120
1121/****************************************************************************
1122 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
1123****************************************************************************/
1124                                                                                                                             
1125static struct ea_list *read_nttrans_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
1126{
1127        struct ea_list *ea_list_head = NULL;
1128        size_t offset = 0;
1129
1130        if (data_size < 4) {
1131                return NULL;
1132        }
1133
1134        while (offset + 4 <= data_size) {
1135                size_t next_offset = IVAL(pdata,offset);
1136                struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset + 4, data_size - offset - 4, NULL);
1137
1138                if (!eal) {
1139                        return NULL;
1140                }
1141
1142                DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
1143                if (next_offset == 0) {
1144                        break;
1145                }
1146                offset += next_offset;
1147        }
1148                                                                                                                             
1149        return ea_list_head;
1150}
1151
1152/****************************************************************************
1153 Reply to a NT_TRANSACT_CREATE call (needs to process SD's).
1154****************************************************************************/
1155
1156static int call_nt_transact_create(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1157                                  uint16 **ppsetup, uint32 setup_count,
1158                                  char **ppparams, uint32 parameter_count,
1159                                  char **ppdata, uint32 data_count, uint32 max_data_count)
1160{
1161        pstring fname;
1162        char *params = *ppparams;
1163        char *data = *ppdata;
1164        /* Breakout the oplock request bits so we can set the reply bits separately. */
1165        int oplock_request = 0;
1166        uint32 fattr=0;
1167        SMB_OFF_T file_len = 0;
1168        SMB_STRUCT_STAT sbuf;
1169        int info = 0;
1170        files_struct *fsp = NULL;
1171        char *p = NULL;
1172        BOOL extended_oplock_granted = False;
1173        uint32 flags;
1174        uint32 access_mask;
1175        uint32 file_attributes;
1176        uint32 new_file_attributes;
1177        uint32 share_access;
1178        uint32 create_disposition;
1179        uint32 create_options;
1180        uint32 sd_len;
1181        uint32 ea_len;
1182        uint16 root_dir_fid;
1183        struct timespec c_timespec;
1184        struct timespec a_timespec;
1185        struct timespec m_timespec;
1186        struct ea_list *ea_list = NULL;
1187        TALLOC_CTX *ctx = NULL;
1188        char *pdata = NULL;
1189        NTSTATUS status;
1190        size_t param_len;
1191
1192        DEBUG(5,("call_nt_transact_create\n"));
1193
1194        /*
1195         * If it's an IPC, use the pipe handler.
1196         */
1197
1198        if (IS_IPC(conn)) {
1199                if (lp_nt_pipe_support()) {
1200                        return do_nt_transact_create_pipe(conn, inbuf, outbuf, length, 
1201                                        bufsize,
1202                                        ppsetup, setup_count,
1203                                        ppparams, parameter_count,
1204                                        ppdata, data_count);
1205                } else {
1206                        return ERROR_DOS(ERRDOS,ERRnoaccess);
1207                }
1208        }
1209
1210        /*
1211         * Ensure minimum number of parameters sent.
1212         */
1213
1214        if(parameter_count < 54) {
1215                DEBUG(0,("call_nt_transact_create - insufficient parameters (%u)\n", (unsigned int)parameter_count));
1216                return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1217        }
1218
1219        flags = IVAL(params,0);
1220        access_mask = IVAL(params,8);
1221        file_attributes = IVAL(params,20);
1222        share_access = IVAL(params,24);
1223        create_disposition = IVAL(params,28);
1224        create_options = IVAL(params,32);
1225        sd_len = IVAL(params,36);
1226        ea_len = IVAL(params,40);
1227        root_dir_fid = (uint16)IVAL(params,4);
1228
1229        /* Ensure the data_len is correct for the sd and ea values given. */
1230        if ((ea_len + sd_len > data_count) ||
1231                        (ea_len > data_count) || (sd_len > data_count) ||
1232                        (ea_len + sd_len < ea_len) || (ea_len + sd_len < sd_len)) {
1233                DEBUG(10,("call_nt_transact_create - ea_len = %u, sd_len = %u, data_count = %u\n",
1234                        (unsigned int)ea_len, (unsigned int)sd_len, (unsigned int)data_count ));
1235                return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1236        }
1237
1238        if (ea_len) {
1239                if (!lp_ea_support(SNUM(conn))) {
1240                        DEBUG(10,("call_nt_transact_create - ea_len = %u but EA's not supported.\n",
1241                                (unsigned int)ea_len ));
1242                        return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
1243                }
1244
1245                if (ea_len < 10) {
1246                        DEBUG(10,("call_nt_transact_create - ea_len = %u - too small (should be more than 10)\n",
1247                                (unsigned int)ea_len ));
1248                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1249                }
1250        }
1251
1252        if (create_options & FILE_OPEN_BY_FILE_ID) {
1253                return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
1254        }
1255
1256        /*
1257         * Get the file name.
1258         */
1259
1260        if(root_dir_fid != 0) {
1261                /*
1262                 * This filename is relative to a directory fid.
1263                 */
1264                files_struct *dir_fsp = file_fsp(params,4);
1265                size_t dir_name_len;
1266
1267                if(!dir_fsp) {
1268                        return ERROR_DOS(ERRDOS,ERRbadfid);
1269                }
1270
1271                if(!dir_fsp->is_directory) {
1272                        srvstr_get_path(inbuf, fname, params+53, sizeof(fname), parameter_count-53, STR_TERMINATE, &status);
1273                        if (!NT_STATUS_IS_OK(status)) {
1274                                return ERROR_NT(status);
1275                        }
1276
1277                        /*
1278                         * Check to see if this is a mac fork of some kind.
1279                         */
1280
1281                        if( is_ntfs_stream_name(fname)) {
1282                                return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
1283                        }
1284
1285                        return ERROR_DOS(ERRDOS,ERRbadfid);
1286                }
1287
1288                /*
1289                 * Copy in the base directory name.
1290                 */
1291
1292                pstrcpy( fname, dir_fsp->fsp_name );
1293                dir_name_len = strlen(fname);
1294
1295                /*
1296                 * Ensure it ends in a '\'.
1297                 */
1298
1299                if((fname[dir_name_len-1] != '\\') && (fname[dir_name_len-1] != '/')) {
1300                        pstrcat(fname, "/");
1301                        dir_name_len++;
1302                }
1303
1304                {
1305                        pstring tmpname;
1306                        srvstr_get_path(inbuf, tmpname, params+53, sizeof(tmpname), parameter_count-53, STR_TERMINATE, &status);
1307                        if (!NT_STATUS_IS_OK(status)) {
1308                                return ERROR_NT(status);
1309                        }
1310                        pstrcat(fname, tmpname);
1311                }
1312        } else {
1313                srvstr_get_path(inbuf, fname, params+53, sizeof(fname), parameter_count-53, STR_TERMINATE, &status);
1314                if (!NT_STATUS_IS_OK(status)) {
1315                        return ERROR_NT(status);
1316                }
1317
1318                /*
1319                 * Check to see if this is a mac fork of some kind.
1320                 */
1321
1322                if( is_ntfs_stream_name(fname)) {
1323                        return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
1324                }
1325        }
1326
1327        oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1328        if (oplock_request) {
1329                oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1330        }
1331
1332        /*
1333         * Ordinary file or directory.
1334         */
1335               
1336        /*
1337         * Check if POSIX semantics are wanted.
1338         */
1339               
1340        new_file_attributes = set_posix_case_semantics(conn, file_attributes);
1341   
1342        status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
1343        if (!NT_STATUS_IS_OK(status)) {
1344                if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1345                        return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
1346                }
1347                return ERROR_NT(status);
1348        }
1349
1350        status = unix_convert(conn, fname, False, NULL, &sbuf);
1351        if (!NT_STATUS_IS_OK(status)) {
1352                restore_case_semantics(conn, file_attributes);
1353                return ERROR_NT(status);
1354        }
1355        /* All file access must go through check_name() */
1356        status = check_name(conn, fname);
1357        if (!NT_STATUS_IS_OK(status)) {
1358                restore_case_semantics(conn, file_attributes);
1359                return ERROR_NT(status);
1360        }
1361
1362        /* This is the correct thing to do (check every time) but can_delete is
1363           expensive (it may have to read the parent directory permissions). So
1364           for now we're not doing it unless we have a strong hint the client
1365           is really going to delete this file. If the client is forcing FILE_CREATE
1366           let the filesystem take care of the permissions. */
1367
1368        /* Setting FILE_SHARE_DELETE is the hint. */
1369
1370        if (lp_acl_check_permissions(SNUM(conn))
1371            && (create_disposition != FILE_CREATE)
1372            && (share_access & FILE_SHARE_DELETE)
1373            && (access_mask & DELETE_ACCESS)) {
1374                if ((dos_mode(conn, fname, &sbuf) & FILE_ATTRIBUTE_READONLY) ||
1375                                !can_delete_file_in_directory(conn, fname)) {
1376                        restore_case_semantics(conn, file_attributes);
1377                        return ERROR_NT(NT_STATUS_ACCESS_DENIED);
1378                }
1379        }
1380
1381        if (ea_len) {
1382                pdata = data + sd_len;
1383
1384                /* We have already checked that ea_len <= data_count here. */
1385                ea_list = read_nttrans_ea_list(tmp_talloc_ctx(), pdata,
1386                                               ea_len);
1387                if (!ea_list ) {
1388                        restore_case_semantics(conn, file_attributes);
1389                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1390                }
1391        }
1392
1393        /*
1394         * If it's a request for a directory open, deal with it separately.
1395         */
1396
1397        if(create_options & FILE_DIRECTORY_FILE) {
1398
1399                /* Can't open a temp directory. IFS kit test. */
1400                if (file_attributes & FILE_ATTRIBUTE_TEMPORARY) {
1401                        restore_case_semantics(conn, file_attributes);
1402                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1403                }
1404
1405                /*
1406                 * We will get a create directory here if the Win32
1407                 * app specified a security descriptor in the
1408                 * CreateDirectory() call.
1409                 */
1410
1411                oplock_request = 0;
1412                status = open_directory(conn, fname, &sbuf,
1413                                        access_mask,
1414                                        share_access,
1415                                        create_disposition,
1416                                        create_options,
1417                                        new_file_attributes,
1418                                        &info, &fsp);
1419                if(!NT_STATUS_IS_OK(status)) {
1420                        restore_case_semantics(conn, file_attributes);
1421                        return ERROR_NT(status);
1422                }
1423
1424        } else {
1425
1426                /*
1427                 * Ordinary file case.
1428                 */
1429
1430                status = open_file_ntcreate(conn,fname,&sbuf,
1431                                        access_mask,
1432                                        share_access,
1433                                        create_disposition,
1434                                        create_options,
1435                                        new_file_attributes,
1436                                        oplock_request,
1437                                        &info, &fsp);
1438
1439                if (!NT_STATUS_IS_OK(status)) { 
1440                        if (NT_STATUS_EQUAL(status,
1441                                            NT_STATUS_FILE_IS_A_DIRECTORY)) {
1442
1443                                /*
1444                                 * Fail the open if it was explicitly a non-directory file.
1445                                 */
1446
1447                                if (create_options & FILE_NON_DIRECTORY_FILE) {
1448                                        restore_case_semantics(conn, file_attributes);
1449                                        return ERROR_FORCE_NT(NT_STATUS_FILE_IS_A_DIRECTORY);
1450                                }
1451       
1452                                oplock_request = 0;
1453                                status = open_directory(conn, fname, &sbuf,
1454                                                        access_mask,
1455                                                        share_access,
1456                                                        create_disposition,
1457                                                        create_options,
1458                                                        new_file_attributes,
1459                                                        &info, &fsp);
1460                                if(!NT_STATUS_IS_OK(status)) {
1461                                        restore_case_semantics(conn, file_attributes);
1462                                        return ERROR_NT(status);
1463                                }
1464                        } else {
1465                                restore_case_semantics(conn, file_attributes);
1466                                if (open_was_deferred(SVAL(inbuf,smb_mid))) {
1467                                        /* We have re-scheduled this call. */
1468                                        return -1;
1469                                }
1470                                return ERROR_NT(status);
1471                        }
1472                } 
1473        }
1474
1475        /*
1476         * According to the MS documentation, the only time the security
1477         * descriptor is applied to the opened file is iff we *created* the
1478         * file; an existing file stays the same.
1479         *
1480         * Also, it seems (from observation) that you can open the file with
1481         * any access mask but you can still write the sd. We need to override
1482         * the granted access before we call set_sd
1483         * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
1484         */
1485
1486        if (lp_nt_acl_support(SNUM(conn)) && sd_len && info == FILE_WAS_CREATED) {
1487                uint32 saved_access_mask = fsp->access_mask;
1488
1489                /* We have already checked that sd_len <= data_count here. */
1490
1491                fsp->access_mask = FILE_GENERIC_ALL;
1492
1493                status = set_sd( fsp, data, sd_len, ALL_SECURITY_INFORMATION);
1494                if (!NT_STATUS_IS_OK(status)) {
1495                        talloc_destroy(ctx);
1496                        close_file(fsp,ERROR_CLOSE);
1497                        restore_case_semantics(conn, file_attributes);
1498                        return ERROR_NT(status);
1499                }
1500                fsp->access_mask = saved_access_mask;
1501        }
1502       
1503        if (ea_len && (info == FILE_WAS_CREATED)) {
1504                status = set_ea(conn, fsp, fname, ea_list);
1505                if (!NT_STATUS_IS_OK(status)) {
1506                        close_file(fsp,ERROR_CLOSE);
1507                        restore_case_semantics(conn, file_attributes);
1508                        return ERROR_NT(status);
1509                }
1510        }
1511
1512        restore_case_semantics(conn, file_attributes);
1513
1514        file_len = sbuf.st_size;
1515        fattr = dos_mode(conn,fname,&sbuf);
1516        if(fattr == 0) {
1517                fattr = FILE_ATTRIBUTE_NORMAL;
1518        }
1519        if (!fsp->is_directory && (fattr & aDIR)) {
1520                close_file(fsp,ERROR_CLOSE);
1521                return ERROR_DOS(ERRDOS,ERRnoaccess);
1522        } 
1523       
1524        /* Save the requested allocation size. */
1525        if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
1526                SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)IVAL(params,12);
1527#ifdef LARGE_SMB_OFF_T
1528                allocation_size |= (((SMB_BIG_UINT)IVAL(params,16)) << 32);
1529#endif
1530                if (allocation_size && (allocation_size > file_len)) {
1531                        fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
1532                        if (fsp->is_directory) {
1533                                close_file(fsp,ERROR_CLOSE);
1534                                /* Can't set allocation size on a directory. */
1535                                return ERROR_NT(NT_STATUS_ACCESS_DENIED);
1536                        }
1537                        if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
1538                                close_file(fsp,ERROR_CLOSE);
1539                                return ERROR_NT(NT_STATUS_DISK_FULL);
1540                        }
1541                } else {
1542                        fsp->initial_allocation_size = smb_roundup(fsp->conn, (SMB_BIG_UINT)file_len);
1543                }
1544        }
1545
1546        /*
1547         * If the caller set the extended oplock request bit
1548         * and we granted one (by whatever means) - set the
1549         * correct bit for extended oplock reply.
1550         */
1551
1552        if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1553                extended_oplock_granted = True;
1554        }
1555
1556        if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1557                extended_oplock_granted = True;
1558        }
1559
1560        /* Realloc the size of parameters and data we will return */
1561        if (flags & EXTENDED_RESPONSE_REQUIRED) {
1562                /* Extended response is 32 more byyes. */
1563                param_len = 101;
1564        } else {
1565                param_len = 69;
1566        }
1567        params = nttrans_realloc(ppparams, param_len);
1568        if(params == NULL) {
1569                return ERROR_DOS(ERRDOS,ERRnomem);
1570        }
1571
1572        p = params;
1573        if (extended_oplock_granted) {
1574                if (flags & REQUEST_BATCH_OPLOCK) {
1575                        SCVAL(p,0, BATCH_OPLOCK_RETURN);
1576                } else {
1577                        SCVAL(p,0, EXCLUSIVE_OPLOCK_RETURN);
1578                }
1579        } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
1580                SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
1581        } else {
1582                SCVAL(p,0,NO_OPLOCK_RETURN);
1583        }
1584       
1585        p += 2;
1586        SSVAL(p,0,fsp->fnum);
1587        p += 2;
1588        if ((create_disposition == FILE_SUPERSEDE) && (info == FILE_WAS_OVERWRITTEN)) {
1589                SIVAL(p,0,FILE_WAS_SUPERSEDED);
1590        } else {
1591                SIVAL(p,0,info);
1592        }
1593        p += 8;
1594
1595        /* Create time. */
1596        c_timespec = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1597        a_timespec = get_atimespec(&sbuf);
1598        m_timespec = get_mtimespec(&sbuf);
1599
1600        if (lp_dos_filetime_resolution(SNUM(conn))) {
1601                dos_filetime_timespec(&c_timespec);
1602                dos_filetime_timespec(&a_timespec);
1603                dos_filetime_timespec(&m_timespec);
1604        }
1605
1606        put_long_date_timespec(p, c_timespec); /* create time. */
1607        p += 8;
1608        put_long_date_timespec(p, a_timespec); /* access time */
1609        p += 8;
1610        put_long_date_timespec(p, m_timespec); /* write time */
1611        p += 8;
1612        put_long_date_timespec(p, m_timespec); /* change time */
1613        p += 8;
1614        SIVAL(p,0,fattr); /* File Attributes. */
1615        p += 4;
1616        SOFF_T(p, 0, get_allocation_size(conn,fsp,&sbuf));
1617        p += 8;
1618        SOFF_T(p,0,file_len);
1619        p += 8;
1620        if (flags & EXTENDED_RESPONSE_REQUIRED) {
1621                SSVAL(p,2,0x7);
1622        }
1623        p += 4;
1624        SCVAL(p,0,fsp->is_directory ? 1 : 0);
1625
1626        if (flags & EXTENDED_RESPONSE_REQUIRED) {
1627                uint32 perms = 0;
1628                p += 26;
1629                if (fsp->is_directory || can_write_to_file(conn, fname, &sbuf)) {
1630                        perms = FILE_GENERIC_ALL;
1631                } else {
1632                        perms = FILE_GENERIC_READ|FILE_EXECUTE;
1633                }
1634                SIVAL(p,0,perms);
1635        }
1636
1637        DEBUG(5,("call_nt_transact_create: open name = %s\n", fname));
1638
1639        /* Send the required number of replies */
1640        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, params, param_len, *ppdata, 0);
1641
1642        return -1;
1643}
1644
1645/****************************************************************************
1646 Reply to a NT CANCEL request.
1647 conn POINTER CAN BE NULL HERE !
1648****************************************************************************/
1649
1650int reply_ntcancel(connection_struct *conn,
1651                   char *inbuf,char *outbuf,int length,int bufsize)
1652{
1653        /*
1654         * Go through and cancel any pending change notifies.
1655         */
1656       
1657        int mid = SVAL(inbuf,smb_mid);
1658        START_PROFILE(SMBntcancel);
1659        remove_pending_change_notify_requests_by_mid(mid);
1660        remove_pending_lock_requests_by_mid(mid);
1661        srv_cancel_sign_response(mid);
1662       
1663        DEBUG(3,("reply_ntcancel: cancel called on mid = %d.\n", mid));
1664
1665        END_PROFILE(SMBntcancel);
1666        return(-1);
1667}
1668
1669/****************************************************************************
1670 Copy a file.
1671****************************************************************************/
1672
1673static NTSTATUS copy_internals(connection_struct *conn, char *oldname, char *newname, uint32 attrs)
1674{
1675        SMB_STRUCT_STAT sbuf1, sbuf2;
1676        pstring last_component_oldname;
1677        pstring last_component_newname;
1678        files_struct *fsp1,*fsp2;
1679        uint32 fattr;
1680        int info;
1681        SMB_OFF_T ret=-1;
1682        NTSTATUS status = NT_STATUS_OK;
1683
1684        ZERO_STRUCT(sbuf1);
1685        ZERO_STRUCT(sbuf2);
1686
1687        if (!CAN_WRITE(conn)) {
1688                return NT_STATUS_MEDIA_WRITE_PROTECTED;
1689        }
1690
1691        status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
1692        if (!NT_STATUS_IS_OK(status)) {
1693                return status;
1694        }
1695
1696        status = check_name(conn, oldname);
1697        if (!NT_STATUS_IS_OK(status)) {
1698                return status;
1699        }
1700
1701        /* Source must already exist. */
1702        if (!VALID_STAT(sbuf1)) {
1703                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1704        }
1705        /* Ensure attributes match. */
1706        fattr = dos_mode(conn,oldname,&sbuf1);
1707        if ((fattr & ~attrs) & (aHIDDEN | aSYSTEM)) {
1708                return NT_STATUS_NO_SUCH_FILE;
1709        }
1710
1711        status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
1712        if (!NT_STATUS_IS_OK(status)) {
1713                return status;
1714        }
1715
1716        status = check_name(conn, newname);
1717        if (!NT_STATUS_IS_OK(status)) {
1718                return status;
1719        }
1720
1721        /* Disallow if newname already exists. */
1722        if (VALID_STAT(sbuf2)) {
1723                return NT_STATUS_OBJECT_NAME_COLLISION;
1724        }
1725
1726        /* No links from a directory. */
1727        if (S_ISDIR(sbuf1.st_mode)) {
1728                return NT_STATUS_FILE_IS_A_DIRECTORY;
1729        }
1730
1731        /* Ensure this is within the share. */
1732        status = reduce_name(conn, oldname);
1733        if (!NT_STATUS_IS_OK(status)) {
1734                return status;
1735        }
1736
1737        DEBUG(10,("copy_internals: doing file copy %s to %s\n", oldname, newname));
1738
1739        status = open_file_ntcreate(conn,oldname,&sbuf1,
1740                        FILE_READ_DATA, /* Read-only. */
1741                        FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
1742                        FILE_OPEN,
1743                        0, /* No create options. */
1744                        FILE_ATTRIBUTE_NORMAL,
1745                        NO_OPLOCK,
1746                        &info, &fsp1);
1747
1748        if (!NT_STATUS_IS_OK(status)) {
1749                return status;
1750        }
1751
1752        status = open_file_ntcreate(conn,newname,&sbuf2,
1753                        FILE_WRITE_DATA, /* Read-only. */
1754                        FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
1755                        FILE_CREATE,
1756                        0, /* No create options. */
1757                        fattr,
1758                        NO_OPLOCK,
1759                        &info, &fsp2);
1760
1761        if (!NT_STATUS_IS_OK(status)) {
1762                close_file(fsp1,ERROR_CLOSE);
1763                return status;
1764        }
1765
1766        if (sbuf1.st_size) {
1767                ret = vfs_transfer_file(fsp1, fsp2, sbuf1.st_size);
1768        }
1769
1770        /*
1771         * As we are opening fsp1 read-only we only expect
1772         * an error on close on fsp2 if we are out of space.
1773         * Thus we don't look at the error return from the
1774         * close of fsp1.
1775         */
1776        close_file(fsp1,NORMAL_CLOSE);
1777
1778        /* Ensure the modtime is set correctly on the destination file. */
1779        fsp_set_pending_modtime(fsp2, get_mtimespec(&sbuf1));
1780
1781        status = close_file(fsp2,NORMAL_CLOSE);
1782
1783        /* Grrr. We have to do this as open_file_ntcreate adds aARCH when it
1784           creates the file. This isn't the correct thing to do in the copy
1785           case. JRA */
1786        file_set_dosmode(conn, newname, fattr, &sbuf2,
1787                         parent_dirname(newname));
1788
1789        if (ret < (SMB_OFF_T)sbuf1.st_size) {
1790                return NT_STATUS_DISK_FULL;
1791        }
1792
1793        if (!NT_STATUS_IS_OK(status)) {
1794                DEBUG(3,("copy_internals: Error %s copy file %s to %s\n",
1795                        nt_errstr(status), oldname, newname));
1796        }
1797        return status;
1798}
1799
1800/****************************************************************************
1801 Reply to a NT rename request.
1802****************************************************************************/
1803
1804int reply_ntrename(connection_struct *conn,
1805                   char *inbuf,char *outbuf,int length,int bufsize)
1806{
1807        int outsize = 0;
1808        pstring oldname;
1809        pstring newname;
1810        char *p;
1811        NTSTATUS status;
1812        BOOL src_has_wcard = False;
1813        BOOL dest_has_wcard = False;
1814        uint32 attrs = SVAL(inbuf,smb_vwv0);
1815        uint16 rename_type = SVAL(inbuf,smb_vwv1);
1816
1817        START_PROFILE(SMBntrename);
1818
1819        p = smb_buf(inbuf) + 1;
1820        p += srvstr_get_path_wcard(inbuf, oldname, p, sizeof(oldname), 0, STR_TERMINATE, &status, &src_has_wcard);
1821        if (!NT_STATUS_IS_OK(status)) {
1822                END_PROFILE(SMBntrename);
1823                return ERROR_NT(status);
1824        }
1825
1826        if( is_ntfs_stream_name(oldname)) {
1827                /* Can't rename a stream. */
1828                END_PROFILE(SMBntrename);
1829                return ERROR_NT(NT_STATUS_ACCESS_DENIED);
1830        }
1831
1832        if (ms_has_wild(oldname)) {
1833                END_PROFILE(SMBntrename);
1834                return ERROR_NT(NT_STATUS_OBJECT_PATH_SYNTAX_BAD);
1835        }
1836
1837        p++;
1838        p += srvstr_get_path_wcard(inbuf, newname, p, sizeof(newname), 0, STR_TERMINATE, &status, &dest_has_wcard);
1839        if (!NT_STATUS_IS_OK(status)) {
1840                END_PROFILE(SMBntrename);
1841                return ERROR_NT(status);
1842        }
1843       
1844        status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, oldname);
1845        if (!NT_STATUS_IS_OK(status)) {
1846                END_PROFILE(SMBntrename);
1847                if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1848                        return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
1849                }
1850                return ERROR_NT(status);
1851        }
1852
1853        status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, newname);
1854        if (!NT_STATUS_IS_OK(status)) {
1855                END_PROFILE(SMBntrename);
1856                if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1857                        return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
1858                }
1859                return ERROR_NT(status);
1860        }
1861
1862        DEBUG(3,("reply_ntrename : %s -> %s\n",oldname,newname));
1863       
1864        switch(rename_type) {
1865                case RENAME_FLAG_RENAME:
1866                        status = rename_internals(conn, oldname, newname, attrs, False, src_has_wcard, dest_has_wcard);
1867                        break;
1868                case RENAME_FLAG_HARD_LINK:
1869                        if (src_has_wcard || dest_has_wcard) {
1870                                /* No wildcards. */
1871                                status = NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
1872                        } else {
1873                                status = hardlink_internals(conn, oldname, newname);
1874                        }
1875                        break;
1876                case RENAME_FLAG_COPY:
1877                        if (src_has_wcard || dest_has_wcard) {
1878                                /* No wildcards. */
1879                                status = NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
1880                        } else {
1881                                status = copy_internals(conn, oldname, newname, attrs);
1882                        }
1883                        break;
1884                case RENAME_FLAG_MOVE_CLUSTER_INFORMATION:
1885                        status = NT_STATUS_INVALID_PARAMETER;
1886                        break;
1887                default:
1888                        status = NT_STATUS_ACCESS_DENIED; /* Default error. */
1889                        break;
1890        }
1891
1892        if (!NT_STATUS_IS_OK(status)) {
1893                END_PROFILE(SMBntrename);
1894                if (open_was_deferred(SVAL(inbuf,smb_mid))) {
1895                        /* We have re-scheduled this call. */
1896                        return -1;
1897                }
1898                return ERROR_NT(status);
1899        }
1900
1901        outsize = set_message(outbuf,0,0,False);
1902 
1903        END_PROFILE(SMBntrename);
1904        return(outsize);
1905}
1906
1907/****************************************************************************
1908 Reply to a notify change - queue the request and
1909 don't allow a directory to be opened.
1910****************************************************************************/
1911
1912static int call_nt_transact_notify_change(connection_struct *conn, char *inbuf,
1913                                          char *outbuf, int length,
1914                                          int bufsize, 
1915                                          uint16 **ppsetup, uint32 setup_count,
1916                                          char **ppparams,
1917                                          uint32 parameter_count,
1918                                          char **ppdata, uint32 data_count,
1919                                          uint32 max_data_count,
1920                                          uint32 max_param_count)
1921{
1922        uint16 *setup = *ppsetup;
1923        files_struct *fsp;
1924        uint32 filter;
1925        NTSTATUS status;
1926        BOOL recursive;
1927
1928        if(setup_count < 6) {
1929                return ERROR_DOS(ERRDOS,ERRbadfunc);
1930        }
1931
1932        fsp = file_fsp((char *)setup,4);
1933        filter = IVAL(setup, 0);
1934        recursive = (SVAL(setup, 6) != 0) ? True : False;
1935
1936        DEBUG(3,("call_nt_transact_notify_change\n"));
1937
1938        if(!fsp) {
1939                return ERROR_DOS(ERRDOS,ERRbadfid);
1940        }
1941
1942        {
1943                char *filter_string;
1944
1945                if (!(filter_string = notify_filter_string(NULL, filter))) {
1946                        return ERROR_NT(NT_STATUS_NO_MEMORY);
1947                }
1948
1949                DEBUG(3,("call_nt_transact_notify_change: notify change "
1950                         "called on %s, filter = %s, recursive = %d\n",
1951                         fsp->fsp_name, filter_string, recursive));
1952
1953                TALLOC_FREE(filter_string);
1954        }
1955
1956        if((!fsp->is_directory) || (conn != fsp->conn)) {
1957                return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1958        }
1959
1960        if (fsp->notify == NULL) {
1961
1962                status = change_notify_create(fsp, filter, recursive);
1963
1964                if (!NT_STATUS_IS_OK(status)) {
1965                        DEBUG(10, ("change_notify_create returned %s\n",
1966                                   nt_errstr(status)));
1967                        return ERROR_NT(status);
1968                }
1969        }
1970
1971        if (fsp->notify->num_changes != 0) {
1972
1973                /*
1974                 * We've got changes pending, respond immediately
1975                 */
1976
1977                /*
1978                 * TODO: write a torture test to check the filtering behaviour
1979                 * here.
1980                 */
1981
1982                change_notify_reply(inbuf, max_param_count,
1983                                    fsp->notify);
1984
1985                /*
1986                 * change_notify_reply() above has independently sent its
1987                 * results
1988                 */
1989                return -1;
1990        }
1991
1992        /*
1993         * No changes pending, queue the request
1994         */
1995
1996        status = change_notify_add_request(inbuf, max_param_count, filter,
1997                                           recursive, fsp);
1998        if (!NT_STATUS_IS_OK(status)) {
1999                return ERROR_NT(status);
2000        }
2001
2002        return -1;
2003}
2004
2005/****************************************************************************
2006 Reply to an NT transact rename command.
2007****************************************************************************/
2008
2009static int call_nt_transact_rename(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2010                                  uint16 **ppsetup, uint32 setup_count,
2011                                  char **ppparams, uint32 parameter_count,
2012                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2013{
2014        char *params = *ppparams;
2015        pstring new_name;
2016        files_struct *fsp = NULL;
2017        BOOL replace_if_exists = False;
2018        BOOL dest_has_wcard = False;
2019        NTSTATUS status;
2020
2021        if(parameter_count < 5) {
2022                return ERROR_DOS(ERRDOS,ERRbadfunc);
2023        }
2024
2025        fsp = file_fsp(params, 0);
2026        replace_if_exists = (SVAL(params,2) & RENAME_REPLACE_IF_EXISTS) ? True : False;
2027        CHECK_FSP(fsp, conn);
2028        srvstr_get_path_wcard(inbuf, new_name, params+4, sizeof(new_name), parameter_count - 4,
2029                        STR_TERMINATE, &status, &dest_has_wcard);
2030        if (!NT_STATUS_IS_OK(status)) {
2031                return ERROR_NT(status);
2032        }
2033
2034        status = rename_internals(conn, fsp->fsp_name,
2035                                  new_name, 0, replace_if_exists, False, dest_has_wcard);
2036
2037        if (!NT_STATUS_IS_OK(status)) {
2038                if (open_was_deferred(SVAL(inbuf,smb_mid))) {
2039                        /* We have re-scheduled this call. */
2040                        return -1;
2041                }
2042                return ERROR_NT(status);
2043        }
2044
2045        /*
2046         * Rename was successful.
2047         */
2048        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0, NULL, 0);
2049       
2050        DEBUG(3,("nt transact rename from = %s, to = %s succeeded.\n", 
2051                 fsp->fsp_name, new_name));
2052       
2053        return -1;
2054}
2055
2056/******************************************************************************
2057 Fake up a completely empty SD.
2058*******************************************************************************/
2059
2060static size_t get_null_nt_acl(TALLOC_CTX *mem_ctx, SEC_DESC **ppsd)
2061{
2062        size_t sd_size;
2063
2064        *ppsd = make_standard_sec_desc( mem_ctx, &global_sid_World, &global_sid_World, NULL, &sd_size);
2065        if(!*ppsd) {
2066                DEBUG(0,("get_null_nt_acl: Unable to malloc space for security descriptor.\n"));
2067                sd_size = 0;
2068        }
2069
2070        return sd_size;
2071}
2072
2073/****************************************************************************
2074 Reply to query a security descriptor.
2075****************************************************************************/
2076
2077static int call_nt_transact_query_security_desc(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize, 
2078                                  uint16 **ppsetup, uint32 setup_count,
2079                                  char **ppparams, uint32 parameter_count,
2080                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2081{
2082        char *params = *ppparams;
2083        char *data = *ppdata;
2084        prs_struct pd;
2085        SEC_DESC *psd = NULL;
2086        size_t sd_size;
2087        uint32 security_info_wanted;
2088        TALLOC_CTX *mem_ctx;
2089        files_struct *fsp = NULL;
2090
2091        if(parameter_count < 8) {
2092                return ERROR_DOS(ERRDOS,ERRbadfunc);
2093        }
2094
2095        fsp = file_fsp(params,0);
2096        if(!fsp) {
2097                return ERROR_DOS(ERRDOS,ERRbadfid);
2098        }
2099
2100        security_info_wanted = IVAL(params,4);
2101
2102        DEBUG(3,("call_nt_transact_query_security_desc: file = %s, info_wanted = 0x%x\n", fsp->fsp_name,
2103                        (unsigned int)security_info_wanted ));
2104
2105        params = nttrans_realloc(ppparams, 4);
2106        if(params == NULL) {
2107                return ERROR_DOS(ERRDOS,ERRnomem);
2108        }
2109
2110        if ((mem_ctx = talloc_init("call_nt_transact_query_security_desc")) == NULL) {
2111                DEBUG(0,("call_nt_transact_query_security_desc: talloc_init failed.\n"));
2112                return ERROR_DOS(ERRDOS,ERRnomem);
2113        }
2114
2115        /*
2116         * Get the permissions to return.
2117         */
2118
2119        if (!lp_nt_acl_support(SNUM(conn))) {
2120                sd_size = get_null_nt_acl(mem_ctx, &psd);
2121        } else {
2122                sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd, security_info_wanted, &psd);
2123        }
2124
2125        if (sd_size == 0) {
2126                talloc_destroy(mem_ctx);
2127                return(UNIXERROR(ERRDOS,ERRnoaccess));
2128        }
2129
2130        DEBUG(3,("call_nt_transact_query_security_desc: sd_size = %lu.\n",(unsigned long)sd_size));
2131
2132        SIVAL(params,0,(uint32)sd_size);
2133
2134        if(max_data_count < sd_size) {
2135
2136                send_nt_replies(outbuf, bufsize, NT_STATUS_BUFFER_TOO_SMALL,
2137                                params, 4, *ppdata, 0);
2138                talloc_destroy(mem_ctx);
2139                return -1;
2140        }
2141
2142        /*
2143         * Allocate the data we will point this at.
2144         */
2145
2146        data = nttrans_realloc(ppdata, sd_size);
2147        if(data == NULL) {
2148                talloc_destroy(mem_ctx);
2149                return ERROR_DOS(ERRDOS,ERRnomem);
2150        }
2151
2152        /*
2153         * Init the parse struct we will marshall into.
2154         */
2155
2156        prs_init(&pd, 0, mem_ctx, MARSHALL);
2157
2158        /*
2159         * Setup the prs_struct to point at the memory we just
2160         * allocated.
2161         */
2162
2163        prs_give_memory( &pd, data, (uint32)sd_size, False);
2164
2165        /*
2166         * Finally, linearize into the outgoing buffer.
2167         */
2168
2169        if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
2170                DEBUG(0,("call_nt_transact_query_security_desc: Error in marshalling \
2171security descriptor.\n"));
2172                /*
2173                 * Return access denied for want of a better error message..
2174                 */ 
2175                talloc_destroy(mem_ctx);
2176                return(UNIXERROR(ERRDOS,ERRnoaccess));
2177        }
2178
2179        /*
2180         * Now we can delete the security descriptor.
2181         */
2182
2183        talloc_destroy(mem_ctx);
2184
2185        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, params, 4, data,
2186                        (int)sd_size);
2187        return -1;
2188}
2189
2190/****************************************************************************
2191 Reply to set a security descriptor. Map to UNIX perms or POSIX ACLs.
2192****************************************************************************/
2193
2194static int call_nt_transact_set_security_desc(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2195                                  uint16 **ppsetup, uint32 setup_count,
2196                                  char **ppparams, uint32 parameter_count,
2197                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2198{
2199        char *params= *ppparams;
2200        char *data = *ppdata;
2201        files_struct *fsp = NULL;
2202        uint32 security_info_sent = 0;
2203        NTSTATUS nt_status;
2204
2205        if(parameter_count < 8) {
2206                return ERROR_DOS(ERRDOS,ERRbadfunc);
2207        }
2208
2209        if((fsp = file_fsp(params,0)) == NULL) {
2210                return ERROR_DOS(ERRDOS,ERRbadfid);
2211        }
2212
2213        if(!lp_nt_acl_support(SNUM(conn))) {
2214                goto done;
2215        }
2216
2217        security_info_sent = IVAL(params,4);
2218
2219        DEBUG(3,("call_nt_transact_set_security_desc: file = %s, sent 0x%x\n", fsp->fsp_name,
2220                (unsigned int)security_info_sent ));
2221
2222        if (data_count == 0) {
2223                return ERROR_DOS(ERRDOS, ERRnoaccess);
2224        }
2225
2226        if (!NT_STATUS_IS_OK(nt_status = set_sd( fsp, data, data_count, security_info_sent))) {
2227                return ERROR_NT(nt_status);
2228        }
2229
2230  done:
2231
2232        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0, NULL, 0);
2233        return -1;
2234}
2235   
2236/****************************************************************************
2237 Reply to NT IOCTL
2238****************************************************************************/
2239
2240static int call_nt_transact_ioctl(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize, 
2241                                  uint16 **ppsetup, uint32 setup_count,
2242                                  char **ppparams, uint32 parameter_count,
2243                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2244{
2245        uint32 function;
2246        uint16 fidnum;
2247        files_struct *fsp;
2248        uint8 isFSctl;
2249        uint8 compfilter;
2250        static BOOL logged_message;
2251        char *pdata = *ppdata;
2252
2253        if (setup_count != 8) {
2254                DEBUG(3,("call_nt_transact_ioctl: invalid setup count %d\n", setup_count));
2255                return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
2256        }
2257
2258        function = IVAL(*ppsetup, 0);
2259        fidnum = SVAL(*ppsetup, 4);
2260        isFSctl = CVAL(*ppsetup, 6);
2261        compfilter = CVAL(*ppsetup, 7);
2262
2263        DEBUG(10,("call_nt_transact_ioctl: function[0x%08X] FID[0x%04X] isFSctl[0x%02X] compfilter[0x%02X]\n", 
2264                 function, fidnum, isFSctl, compfilter));
2265
2266        fsp=file_fsp((char *)*ppsetup, 4);
2267        /* this check is done in each implemented function case for now
2268           because I don't want to break anything... --metze
2269        FSP_BELONGS_CONN(fsp,conn);*/
2270
2271        switch (function) {
2272        case FSCTL_SET_SPARSE:
2273                /* pretend this succeeded - tho strictly we should
2274                   mark the file sparse (if the local fs supports it)
2275                   so we can know if we need to pre-allocate or not */
2276
2277                DEBUG(10,("FSCTL_SET_SPARSE: called on FID[0x%04X](but not implemented)\n", fidnum));
2278                send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0, NULL,
2279                                0);
2280                return -1;
2281       
2282        case FSCTL_0x000900C0:
2283                /* pretend this succeeded - don't know what this really is
2284                   but works ok like this --metze
2285                 */
2286
2287                DEBUG(10,("FSCTL_0x000900C0: called on FID[0x%04X](but not implemented)\n",fidnum));
2288                send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0, NULL,
2289                                0);
2290                return -1;
2291
2292        case FSCTL_GET_REPARSE_POINT:
2293                /* pretend this fail - my winXP does it like this
2294                 * --metze
2295                 */
2296
2297                DEBUG(10,("FSCTL_GET_REPARSE_POINT: called on FID[0x%04X](but not implemented)\n",fidnum));
2298                send_nt_replies(outbuf, bufsize, NT_STATUS_NOT_A_REPARSE_POINT,
2299                                NULL, 0, NULL, 0);
2300                return -1;
2301
2302        case FSCTL_SET_REPARSE_POINT:
2303                /* pretend this fail - I'm assuming this because of the FSCTL_GET_REPARSE_POINT case.
2304                 * --metze
2305                 */
2306
2307                DEBUG(10,("FSCTL_SET_REPARSE_POINT: called on FID[0x%04X](but not implemented)\n",fidnum));
2308                send_nt_replies(outbuf, bufsize, NT_STATUS_NOT_A_REPARSE_POINT,
2309                                NULL, 0, NULL, 0);
2310                return -1;
2311                       
2312        case FSCTL_GET_SHADOW_COPY_DATA: /* don't know if this name is right...*/
2313        {
2314                /*
2315                 * This is called to retrieve the number of Shadow Copies (a.k.a. snapshots)
2316                 * and return their volume names.  If max_data_count is 16, then it is just
2317                 * asking for the number of volumes and length of the combined names.
2318                 *
2319                 * pdata is the data allocated by our caller, but that uses
2320                 * total_data_count (which is 0 in our case) rather than max_data_count.
2321                 * Allocate the correct amount and return the pointer to let
2322                 * it be deallocated when we return.
2323                 */
2324                SHADOW_COPY_DATA *shadow_data = NULL;
2325                TALLOC_CTX *shadow_mem_ctx = NULL;
2326                BOOL labels = False;
2327                uint32 labels_data_count = 0;
2328                uint32 i;
2329                char *cur_pdata;
2330
2331                FSP_BELONGS_CONN(fsp,conn);
2332
2333                if (max_data_count < 16) {
2334                        DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) < 16 is invalid!\n",
2335                                max_data_count));
2336                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2337                }
2338
2339                if (max_data_count > 16) {
2340                        labels = True;
2341                }
2342
2343                shadow_mem_ctx = talloc_init("SHADOW_COPY_DATA");
2344                if (shadow_mem_ctx == NULL) {
2345                        DEBUG(0,("talloc_init(SHADOW_COPY_DATA) failed!\n"));
2346                        return ERROR_NT(NT_STATUS_NO_MEMORY);
2347                }
2348
2349                shadow_data = TALLOC_ZERO_P(shadow_mem_ctx,SHADOW_COPY_DATA);
2350                if (shadow_data == NULL) {
2351                        DEBUG(0,("talloc_zero() failed!\n"));
2352                        talloc_destroy(shadow_mem_ctx);
2353                        return ERROR_NT(NT_STATUS_NO_MEMORY);
2354                }
2355               
2356                shadow_data->mem_ctx = shadow_mem_ctx;
2357               
2358                /*
2359                 * Call the VFS routine to actually do the work.
2360                 */
2361                if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
2362                        talloc_destroy(shadow_data->mem_ctx);
2363                        if (errno == ENOSYS) {
2364                                DEBUG(5,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, not supported.\n", 
2365                                        conn->connectpath));
2366                                return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
2367                        } else {
2368                                DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, failed.\n", 
2369                                        conn->connectpath));
2370                                return ERROR_NT(NT_STATUS_UNSUCCESSFUL);                       
2371                        }
2372                }
2373
2374                labels_data_count = (shadow_data->num_volumes*2*sizeof(SHADOW_COPY_LABEL))+2;
2375
2376                if (!labels) {
2377                        data_count = 16;
2378                } else {
2379                        data_count = 12+labels_data_count+4;
2380                }
2381
2382                if (max_data_count<data_count) {
2383                        DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) too small (%u) bytes needed!\n",
2384                                max_data_count,data_count));
2385                        talloc_destroy(shadow_data->mem_ctx);
2386                        return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
2387                }
2388
2389                pdata = nttrans_realloc(ppdata, data_count);
2390                if (pdata == NULL) {
2391                        talloc_destroy(shadow_data->mem_ctx);
2392                        return ERROR_NT(NT_STATUS_NO_MEMORY);
2393                }               
2394
2395                cur_pdata = pdata;
2396
2397                /* num_volumes 4 bytes */
2398                SIVAL(pdata,0,shadow_data->num_volumes);
2399
2400                if (labels) {
2401                        /* num_labels 4 bytes */
2402                        SIVAL(pdata,4,shadow_data->num_volumes);
2403                }
2404
2405                /* needed_data_count 4 bytes */
2406                SIVAL(pdata,8,labels_data_count);
2407
2408                cur_pdata+=12;
2409
2410                DEBUG(10,("FSCTL_GET_SHADOW_COPY_DATA: %u volumes for path[%s].\n",
2411                        shadow_data->num_volumes,fsp->fsp_name));
2412                if (labels && shadow_data->labels) {
2413                        for (i=0;i<shadow_data->num_volumes;i++) {
2414                                srvstr_push(outbuf, cur_pdata, shadow_data->labels[i], 2*sizeof(SHADOW_COPY_LABEL), STR_UNICODE|STR_TERMINATE);
2415                                cur_pdata+=2*sizeof(SHADOW_COPY_LABEL);
2416                                DEBUGADD(10,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
2417                        }
2418                }
2419
2420                talloc_destroy(shadow_data->mem_ctx);
2421
2422                send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0,
2423                                pdata, data_count);
2424
2425                return -1;
2426        }
2427       
2428        case FSCTL_FIND_FILES_BY_SID: /* I hope this name is right */
2429        {
2430                /* pretend this succeeded -
2431                 *
2432                 * we have to send back a list with all files owned by this SID
2433                 *
2434                 * but I have to check that --metze
2435                 */
2436                DOM_SID sid;
2437                uid_t uid;
2438                size_t sid_len = MIN(data_count-4,SID_MAX_SIZE);
2439               
2440                DEBUG(10,("FSCTL_FIND_FILES_BY_SID: called on FID[0x%04X]\n",fidnum));
2441
2442                FSP_BELONGS_CONN(fsp,conn);
2443
2444                /* unknown 4 bytes: this is not the length of the sid :-(  */
2445                /*unknown = IVAL(pdata,0);*/
2446               
2447                sid_parse(pdata+4,sid_len,&sid);
2448                DEBUGADD(10,("for SID: %s\n",sid_string_static(&sid)));
2449
2450                if (!sid_to_uid(&sid, &uid)) {
2451                        DEBUG(0,("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
2452                                sid_string_static(&sid),(unsigned long)sid_len));
2453                        uid = (-1);
2454                }
2455               
2456                /* we can take a look at the find source :-)
2457                 *
2458                 * find ./ -uid $uid  -name '*'   is what we need here
2459                 *
2460                 *
2461                 * and send 4bytes len and then NULL terminated unicode strings
2462                 * for each file
2463                 *
2464                 * but I don't know how to deal with the paged results
2465                 * (maybe we can hang the result anywhere in the fsp struct)
2466                 *
2467                 * we don't send all files at once
2468                 * and at the next we should *not* start from the beginning,
2469                 * so we have to cache the result
2470                 *
2471                 * --metze
2472                 */
2473               
2474                /* this works for now... */
2475                send_nt_replies(outbuf, bufsize, NT_STATUS_OK, NULL, 0,
2476                                NULL, 0);
2477                return -1;     
2478        }       
2479        default:
2480                if (!logged_message) {
2481                        logged_message = True; /* Only print this once... */
2482                        DEBUG(0,("call_nt_transact_ioctl(0x%x): Currently not implemented.\n",
2483                                 function));
2484                }
2485        }
2486
2487        return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
2488}
2489
2490
2491#ifdef HAVE_SYS_QUOTAS
2492/****************************************************************************
2493 Reply to get user quota
2494****************************************************************************/
2495
2496static int call_nt_transact_get_user_quota(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize, 
2497                                  uint16 **ppsetup, uint32 setup_count,
2498                                  char **ppparams, uint32 parameter_count,
2499                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2500{
2501        NTSTATUS nt_status = NT_STATUS_OK;
2502        char *params = *ppparams;
2503        char *pdata = *ppdata;
2504        char *entry;
2505        int data_len=0,param_len=0;
2506        int qt_len=0;
2507        int entry_len = 0;
2508        files_struct *fsp = NULL;
2509        uint16 level = 0;
2510        size_t sid_len;
2511        DOM_SID sid;
2512        BOOL start_enum = True;
2513        SMB_NTQUOTA_STRUCT qt;
2514        SMB_NTQUOTA_LIST *tmp_list;
2515        SMB_NTQUOTA_HANDLE *qt_handle = NULL;
2516
2517        ZERO_STRUCT(qt);
2518
2519        /* access check */
2520        if (current_user.ut.uid != 0) {
2521                DEBUG(1,("get_user_quota: access_denied service [%s] user [%s]\n",
2522                        lp_servicename(SNUM(conn)),conn->user));
2523                return ERROR_DOS(ERRDOS,ERRnoaccess);
2524        }
2525
2526        /*
2527         * Ensure minimum number of parameters sent.
2528         */
2529
2530        if (parameter_count < 4) {
2531                DEBUG(0,("TRANSACT_GET_USER_QUOTA: requires %d >= 4 bytes parameters\n",parameter_count));
2532                return ERROR_DOS(ERRDOS,ERRinvalidparam);
2533        }
2534       
2535        /* maybe we can check the quota_fnum */
2536        fsp = file_fsp(params,0);
2537        if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2538                DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2539                return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2540        }
2541
2542        /* the NULL pointer checking for fsp->fake_file_handle->pd
2543         * is done by CHECK_NTQUOTA_HANDLE_OK()
2544         */
2545        qt_handle = (SMB_NTQUOTA_HANDLE *)fsp->fake_file_handle->pd;
2546
2547        level = SVAL(params,2);
2548       
2549        /* unknown 12 bytes leading in params */ 
2550       
2551        switch (level) {
2552                case TRANSACT_GET_USER_QUOTA_LIST_CONTINUE:
2553                        /* seems that we should continue with the enum here --metze */
2554
2555                        if (qt_handle->quota_list!=NULL && 
2556                            qt_handle->tmp_list==NULL) {
2557               
2558                                /* free the list */
2559                                free_ntquota_list(&(qt_handle->quota_list));
2560
2561                                /* Realloc the size of parameters and data we will return */
2562                                param_len = 4;
2563                                params = nttrans_realloc(ppparams, param_len);
2564                                if(params == NULL) {
2565                                        return ERROR_DOS(ERRDOS,ERRnomem);
2566                                }
2567
2568                                data_len = 0;
2569                                SIVAL(params,0,data_len);
2570
2571                                break;
2572                        }
2573
2574                        start_enum = False;
2575
2576                case TRANSACT_GET_USER_QUOTA_LIST_START:
2577
2578                        if (qt_handle->quota_list==NULL &&
2579                                qt_handle->tmp_list==NULL) {
2580                                start_enum = True;
2581                        }
2582
2583                        if (start_enum && vfs_get_user_ntquota_list(fsp,&(qt_handle->quota_list))!=0)
2584                                return ERROR_DOS(ERRSRV,ERRerror);
2585
2586                        /* Realloc the size of parameters and data we will return */
2587                        param_len = 4;
2588                        params = nttrans_realloc(ppparams, param_len);
2589                        if(params == NULL) {
2590                                return ERROR_DOS(ERRDOS,ERRnomem);
2591                        }
2592
2593                        /* we should not trust the value in max_data_count*/
2594                        max_data_count = MIN(max_data_count,2048);
2595                       
2596                        pdata = nttrans_realloc(ppdata, max_data_count);/* should be max data count from client*/
2597                        if(pdata == NULL) {
2598                                return ERROR_DOS(ERRDOS,ERRnomem);
2599                        }
2600
2601                        entry = pdata;
2602
2603                        /* set params Size of returned Quota Data 4 bytes*/
2604                        /* but set it later when we know it */
2605               
2606                        /* for each entry push the data */
2607
2608                        if (start_enum) {
2609                                qt_handle->tmp_list = qt_handle->quota_list;
2610                        }
2611
2612                        tmp_list = qt_handle->tmp_list;
2613
2614                        for (;((tmp_list!=NULL)&&((qt_len +40+SID_MAX_SIZE)<max_data_count));
2615                                tmp_list=tmp_list->next,entry+=entry_len,qt_len+=entry_len) {
2616
2617                                sid_len = sid_size(&tmp_list->quotas->sid);
2618                                entry_len = 40 + sid_len;
2619
2620                                /* nextoffset entry 4 bytes */
2621                                SIVAL(entry,0,entry_len);
2622               
2623                                /* then the len of the SID 4 bytes */
2624                                SIVAL(entry,4,sid_len);
2625                               
2626                                /* unknown data 8 bytes SMB_BIG_UINT */
2627                                SBIG_UINT(entry,8,(SMB_BIG_UINT)0); /* this is not 0 in windows...-metze*/
2628                               
2629                                /* the used disk space 8 bytes SMB_BIG_UINT */
2630                                SBIG_UINT(entry,16,tmp_list->quotas->usedspace);
2631                               
2632                                /* the soft quotas 8 bytes SMB_BIG_UINT */
2633                                SBIG_UINT(entry,24,tmp_list->quotas->softlim);
2634                               
2635                                /* the hard quotas 8 bytes SMB_BIG_UINT */
2636                                SBIG_UINT(entry,32,tmp_list->quotas->hardlim);
2637                               
2638                                /* and now the SID */
2639                                sid_linearize(entry+40, sid_len, &tmp_list->quotas->sid);
2640                        }
2641                       
2642                        qt_handle->tmp_list = tmp_list;
2643                       
2644                        /* overwrite the offset of the last entry */
2645                        SIVAL(entry-entry_len,0,0);
2646
2647                        data_len = 4+qt_len;
2648                        /* overwrite the params quota_data_len */
2649                        SIVAL(params,0,data_len);
2650
2651                        break;
2652
2653                case TRANSACT_GET_USER_QUOTA_FOR_SID:
2654                       
2655                        /* unknown 4 bytes IVAL(pdata,0) */     
2656                       
2657                        if (data_count < 8) {
2658                                DEBUG(0,("TRANSACT_GET_USER_QUOTA_FOR_SID: requires %d >= %d bytes data\n",data_count,8));
2659                                return ERROR_DOS(ERRDOS,ERRunknownlevel);                               
2660                        }
2661
2662                        sid_len = IVAL(pdata,4);
2663                        /* Ensure this is less than 1mb. */
2664                        if (sid_len > (1024*1024)) {
2665                                return ERROR_DOS(ERRDOS,ERRnomem);
2666                        }
2667
2668                        if (data_count < 8+sid_len) {
2669                                DEBUG(0,("TRANSACT_GET_USER_QUOTA_FOR_SID: requires %d >= %lu bytes data\n",data_count,(unsigned long)(8+sid_len)));
2670                                return ERROR_DOS(ERRDOS,ERRunknownlevel);                               
2671                        }
2672
2673                        data_len = 4+40+sid_len;
2674
2675                        if (max_data_count < data_len) {
2676                                DEBUG(0,("TRANSACT_GET_USER_QUOTA_FOR_SID: max_data_count(%d) < data_len(%d)\n",
2677                                        max_data_count, data_len));
2678                                param_len = 4;
2679                                SIVAL(params,0,data_len);
2680                                data_len = 0;
2681                                nt_status = NT_STATUS_BUFFER_TOO_SMALL;
2682                                break;
2683                        }
2684
2685                        sid_parse(pdata+8,sid_len,&sid);
2686               
2687                        if (vfs_get_ntquota(fsp, SMB_USER_QUOTA_TYPE, &sid, &qt)!=0) {
2688                                ZERO_STRUCT(qt);
2689                                /*
2690                                 * we have to return zero's in all fields
2691                                 * instead of returning an error here
2692                                 * --metze
2693                                 */
2694                        }
2695
2696                        /* Realloc the size of parameters and data we will return */
2697                        param_len = 4;
2698                        params = nttrans_realloc(ppparams, param_len);
2699                        if(params == NULL) {
2700                                return ERROR_DOS(ERRDOS,ERRnomem);
2701                        }
2702
2703                        pdata = nttrans_realloc(ppdata, data_len);
2704                        if(pdata == NULL) {
2705                                return ERROR_DOS(ERRDOS,ERRnomem);
2706                        }
2707
2708                        entry = pdata;
2709
2710                        /* set params Size of returned Quota Data 4 bytes*/
2711                        SIVAL(params,0,data_len);
2712       
2713                        /* nextoffset entry 4 bytes */
2714                        SIVAL(entry,0,0);
2715       
2716                        /* then the len of the SID 4 bytes */
2717                        SIVAL(entry,4,sid_len);
2718                       
2719                        /* unknown data 8 bytes SMB_BIG_UINT */
2720                        SBIG_UINT(entry,8,(SMB_BIG_UINT)0); /* this is not 0 in windows...-mezte*/
2721                       
2722                        /* the used disk space 8 bytes SMB_BIG_UINT */
2723                        SBIG_UINT(entry,16,qt.usedspace);
2724                       
2725                        /* the soft quotas 8 bytes SMB_BIG_UINT */
2726                        SBIG_UINT(entry,24,qt.softlim);
2727                       
2728                        /* the hard quotas 8 bytes SMB_BIG_UINT */
2729                        SBIG_UINT(entry,32,qt.hardlim);
2730                       
2731                        /* and now the SID */
2732                        sid_linearize(entry+40, sid_len, &sid);
2733
2734                        break;
2735
2736                default:
2737                        DEBUG(0,("do_nt_transact_get_user_quota: fnum %d unknown level 0x%04hX\n",fsp->fnum,level));
2738                        return ERROR_DOS(ERRSRV,ERRerror);
2739                        break;
2740        }
2741
2742        send_nt_replies(outbuf, bufsize, nt_status, params, param_len,
2743                        pdata, data_len);
2744
2745        return -1;
2746}
2747
2748/****************************************************************************
2749 Reply to set user quota
2750****************************************************************************/
2751
2752static int call_nt_transact_set_user_quota(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize, 
2753                                  uint16 **ppsetup, uint32 setup_count,
2754                                  char **ppparams, uint32 parameter_count,
2755                                  char **ppdata, uint32 data_count, uint32 max_data_count)
2756{
2757        char *params = *ppparams;
2758        char *pdata = *ppdata;
2759        int data_len=0,param_len=0;
2760        SMB_NTQUOTA_STRUCT qt;
2761        size_t sid_len;
2762        DOM_SID sid;
2763        files_struct *fsp = NULL;
2764
2765        ZERO_STRUCT(qt);
2766
2767        /* access check */
2768        if (current_user.ut.uid != 0) {
2769                DEBUG(1,("set_user_quota: access_denied service [%s] user [%s]\n",
2770                        lp_servicename(SNUM(conn)),conn->user));
2771                return ERROR_DOS(ERRDOS,ERRnoaccess);
2772        }
2773
2774        /*
2775         * Ensure minimum number of parameters sent.
2776         */
2777
2778        if (parameter_count < 2) {
2779                DEBUG(0,("TRANSACT_SET_USER_QUOTA: requires %d >= 2 bytes parameters\n",parameter_count));
2780                return ERROR_DOS(ERRDOS,ERRinvalidparam);
2781        }
2782       
2783        /* maybe we can check the quota_fnum */
2784        fsp = file_fsp(params,0);
2785        if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2786                DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2787                return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2788        }
2789
2790        if (data_count < 40) {
2791                DEBUG(0,("TRANSACT_SET_USER_QUOTA: requires %d >= %d bytes data\n",data_count,40));
2792                return ERROR_DOS(ERRDOS,ERRunknownlevel);               
2793        }
2794
2795        /* offset to next quota record.
2796         * 4 bytes IVAL(pdata,0)
2797         * unused here...
2798         */
2799
2800        /* sid len */
2801        sid_len = IVAL(pdata,4);
2802
2803        if (data_count < 40+sid_len) {
2804                DEBUG(0,("TRANSACT_SET_USER_QUOTA: requires %d >= %lu bytes data\n",data_count,(unsigned long)40+sid_len));
2805                return ERROR_DOS(ERRDOS,ERRunknownlevel);               
2806        }
2807
2808        /* unknown 8 bytes in pdata
2809         * maybe its the change time in NTTIME
2810         */
2811
2812        /* the used space 8 bytes (SMB_BIG_UINT)*/
2813        qt.usedspace = (SMB_BIG_UINT)IVAL(pdata,16);
2814#ifdef LARGE_SMB_OFF_T
2815        qt.usedspace |= (((SMB_BIG_UINT)IVAL(pdata,20)) << 32);
2816#else /* LARGE_SMB_OFF_T */
2817        if ((IVAL(pdata,20) != 0)&&
2818                ((qt.usedspace != 0xFFFFFFFF)||
2819                (IVAL(pdata,20)!=0xFFFFFFFF))) {
2820                /* more than 32 bits? */
2821                return ERROR_DOS(ERRDOS,ERRunknownlevel);
2822        }
2823#endif /* LARGE_SMB_OFF_T */
2824
2825        /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2826        qt.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2827#ifdef LARGE_SMB_OFF_T
2828        qt.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2829#else /* LARGE_SMB_OFF_T */
2830        if ((IVAL(pdata,28) != 0)&&
2831                ((qt.softlim != 0xFFFFFFFF)||
2832                (IVAL(pdata,28)!=0xFFFFFFFF))) {
2833                /* more than 32 bits? */
2834                return ERROR_DOS(ERRDOS,ERRunknownlevel);
2835        }
2836#endif /* LARGE_SMB_OFF_T */
2837
2838        /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2839        qt.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2840#ifdef LARGE_SMB_OFF_T
2841        qt.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2842#else /* LARGE_SMB_OFF_T */
2843        if ((IVAL(pdata,36) != 0)&&
2844                ((qt.hardlim != 0xFFFFFFFF)||
2845                (IVAL(pdata,36)!=0xFFFFFFFF))) {
2846                /* more than 32 bits? */
2847                return ERROR_DOS(ERRDOS,ERRunknownlevel);
2848        }
2849#endif /* LARGE_SMB_OFF_T */
2850       
2851        sid_parse(pdata+40,sid_len,&sid);
2852        DEBUGADD(8,("SID: %s\n",sid_string_static(&sid)));
2853
2854        /* 44 unknown bytes left... */
2855
2856        if (vfs_set_ntquota(fsp, SMB_USER_QUOTA_TYPE, &sid, &qt)!=0) {
2857                return ERROR_DOS(ERRSRV,ERRerror);     
2858        }
2859
2860        send_nt_replies(outbuf, bufsize, NT_STATUS_OK, params, param_len,
2861                        pdata, data_len);
2862
2863        return -1;
2864}
2865#endif /* HAVE_SYS_QUOTAS */
2866
2867static int handle_nttrans(connection_struct *conn,
2868                          struct trans_state *state,
2869                          char *inbuf, char *outbuf, int size, int bufsize)
2870{
2871        int outsize;
2872
2873        if (Protocol >= PROTOCOL_NT1) {
2874                SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
2875        }
2876
2877        /* Now we must call the relevant NT_TRANS function */
2878        switch(state->call) {
2879                case NT_TRANSACT_CREATE:
2880                {
2881                        START_PROFILE(NT_transact_create);
2882                        outsize = call_nt_transact_create(conn, inbuf, outbuf,
2883                                                          size, bufsize, 
2884                                                        &state->setup, state->setup_count,
2885                                                        &state->param, state->total_param, 
2886                                                        &state->data, state->total_data,
2887                                                          state->max_data_return);
2888                        END_PROFILE(NT_transact_create);
2889                        break;
2890                }
2891
2892                case NT_TRANSACT_IOCTL:
2893                {
2894                        START_PROFILE(NT_transact_ioctl);
2895                        outsize = call_nt_transact_ioctl(conn, inbuf, outbuf,
2896                                                         size, bufsize, 
2897                                                         &state->setup, state->setup_count,
2898                                                         &state->param, state->total_param, 
2899                                                         &state->data, state->total_data, state->max_data_return);
2900                        END_PROFILE(NT_transact_ioctl);
2901                        break;
2902                }
2903
2904                case NT_TRANSACT_SET_SECURITY_DESC:
2905                {
2906                        START_PROFILE(NT_transact_set_security_desc);
2907                        outsize = call_nt_transact_set_security_desc(conn, inbuf, outbuf, 
2908                                                         size, bufsize, 
2909                                                         &state->setup, state->setup_count,
2910                                                         &state->param, state->total_param, 
2911                                                         &state->data, state->total_data, state->max_data_return);
2912                        END_PROFILE(NT_transact_set_security_desc);
2913                        break;
2914                }
2915
2916                case NT_TRANSACT_NOTIFY_CHANGE:
2917                {
2918                        START_PROFILE(NT_transact_notify_change);
2919                        outsize = call_nt_transact_notify_change(
2920                                conn, inbuf, outbuf, size, bufsize, 
2921                                &state->setup, state->setup_count,
2922                                &state->param, state->total_param, 
2923                                &state->data, state->total_data,
2924                                state->max_data_return,
2925                                state->max_param_return);
2926                        END_PROFILE(NT_transact_notify_change);
2927                        break;
2928                }
2929
2930                case NT_TRANSACT_RENAME:
2931                {
2932                        START_PROFILE(NT_transact_rename);
2933                        outsize = call_nt_transact_rename(conn, inbuf, outbuf,
2934                                                         size, bufsize, 
2935                                                         &state->setup, state->setup_count,
2936                                                         &state->param, state->total_param, 
2937                                                         &state->data, state->total_data, state->max_data_return);
2938                        END_PROFILE(NT_transact_rename);
2939                        break;
2940                }
2941
2942                case NT_TRANSACT_QUERY_SECURITY_DESC:
2943                {
2944                        START_PROFILE(NT_transact_query_security_desc);
2945                        outsize = call_nt_transact_query_security_desc(conn, inbuf, outbuf, 
2946                                                         size, bufsize, 
2947                                                         &state->setup, state->setup_count,
2948                                                         &state->param, state->total_param, 
2949                                                         &state->data, state->total_data, state->max_data_return);
2950                        END_PROFILE(NT_transact_query_security_desc);
2951                        break;
2952                }
2953
2954#ifdef HAVE_SYS_QUOTAS
2955                case NT_TRANSACT_GET_USER_QUOTA:
2956                {
2957                        START_PROFILE(NT_transact_get_user_quota);
2958                        outsize = call_nt_transact_get_user_quota(conn, inbuf, outbuf, 
2959                                                         size, bufsize, 
2960                                                         &state->setup, state->setup_count,
2961                                                         &state->param, state->total_param, 
2962                                                         &state->data, state->total_data, state->max_data_return);
2963                        END_PROFILE(NT_transact_get_user_quota);
2964                        break;
2965                }
2966
2967                case NT_TRANSACT_SET_USER_QUOTA:
2968                {
2969                        START_PROFILE(NT_transact_set_user_quota);
2970                        outsize = call_nt_transact_set_user_quota(conn, inbuf, outbuf, 
2971                                                         size, bufsize, 
2972                                                         &state->setup, state->setup_count,
2973                                                         &state->param, state->total_param, 
2974                                                         &state->data, state->total_data, state->max_data_return);
2975                        END_PROFILE(NT_transact_set_user_quota);
2976                        break;                                 
2977                }
2978#endif /* HAVE_SYS_QUOTAS */
2979
2980                default:
2981                        /* Error in request */
2982                        DEBUG(0,("reply_nttrans: Unknown request %d in nttrans call\n",
2983                                 state->call));
2984                        return ERROR_DOS(ERRSRV,ERRerror);
2985        }
2986        return outsize;
2987}
2988
2989/****************************************************************************
2990 Reply to a SMBNTtrans.
2991****************************************************************************/
2992
2993int reply_nttrans(connection_struct *conn,
2994                        char *inbuf,char *outbuf,int size,int bufsize)
2995{
2996        int  outsize = 0;
2997        uint32 pscnt = IVAL(inbuf,smb_nt_ParameterCount);
2998        uint32 psoff = IVAL(inbuf,smb_nt_ParameterOffset);
2999        uint32 dscnt = IVAL(inbuf,smb_nt_DataCount);
3000        uint32 dsoff = IVAL(inbuf,smb_nt_DataOffset);
3001       
3002        uint16 function_code = SVAL( inbuf, smb_nt_Function);
3003        NTSTATUS result;
3004        struct trans_state *state;
3005
3006        START_PROFILE(SMBnttrans);
3007
3008        if (IS_IPC(conn) && (function_code != NT_TRANSACT_CREATE)) {
3009                END_PROFILE(SMBnttrans);
3010                return ERROR_DOS(ERRSRV,ERRaccess);
3011        }
3012
3013        result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
3014        if (!NT_STATUS_IS_OK(result)) {
3015                DEBUG(2, ("Got invalid nttrans request: %s\n", nt_errstr(result)));
3016                END_PROFILE(SMBnttrans);
3017                return ERROR_NT(result);
3018        }
3019
3020        if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
3021                END_PROFILE(SMBnttrans);
3022                return ERROR_DOS(ERRSRV,ERRaccess);
3023        }
3024
3025        state->cmd = SMBnttrans;
3026
3027        state->mid = SVAL(inbuf,smb_mid);
3028        state->vuid = SVAL(inbuf,smb_uid);
3029        state->total_data = IVAL(inbuf, smb_nt_TotalDataCount);
3030        state->data = NULL;
3031        state->total_param = IVAL(inbuf, smb_nt_TotalParameterCount);
3032        state->param = NULL;
3033        state->max_data_return = IVAL(inbuf,smb_nt_MaxDataCount);       
3034        state->max_param_return = IVAL(inbuf,smb_nt_MaxParameterCount);
3035
3036        /* setup count is in *words* */
3037        state->setup_count = 2*CVAL(inbuf,smb_nt_SetupCount); 
3038        state->setup = NULL;
3039        state->call = function_code;
3040
3041        /*
3042         * All nttrans messages we handle have smb_wct == 19 +
3043         * state->setup_count.  Ensure this is so as a sanity check.
3044         */
3045
3046        if(CVAL(inbuf, smb_wct) != 19 + (state->setup_count/2)) {
3047                DEBUG(2,("Invalid smb_wct %d in nttrans call (should be %d)\n",
3048                        CVAL(inbuf, smb_wct), 19 + (state->setup_count/2)));
3049                goto bad_param;
3050        }
3051
3052        /* Don't allow more than 128mb for each value. */
3053        if ((state->total_data > (1024*1024*128)) ||
3054            (state->total_param > (1024*1024*128))) {
3055                END_PROFILE(SMBnttrans);
3056                return ERROR_DOS(ERRDOS,ERRnomem);
3057        }
3058
3059        if ((dscnt > state->total_data) || (pscnt > state->total_param))
3060                goto bad_param;
3061
3062        if (state->total_data)  {
3063                /* Can't use talloc here, the core routines do realloc on the
3064                 * params and data. */
3065                if ((state->data = (char *)SMB_MALLOC(state->total_data)) == NULL) {
3066                        DEBUG(0,("reply_nttrans: data malloc fail for %u "
3067                                 "bytes !\n", (unsigned int)state->total_data));
3068                        TALLOC_FREE(state);
3069                        END_PROFILE(SMBnttrans);
3070                        return(ERROR_DOS(ERRDOS,ERRnomem));
3071                } 
3072                if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
3073                        goto bad_param;
3074                if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
3075                    (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
3076                        goto bad_param;
3077
3078                memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
3079        }
3080
3081        if (state->total_param) {
3082                /* Can't use talloc here, the core routines do realloc on the
3083                 * params and data. */
3084                if ((state->param = (char *)SMB_MALLOC(state->total_param)) == NULL) {
3085                        DEBUG(0,("reply_nttrans: param malloc fail for %u "
3086                                 "bytes !\n", (unsigned int)state->total_param));
3087                        SAFE_FREE(state->data);
3088                        TALLOC_FREE(state);
3089                        END_PROFILE(SMBnttrans);
3090                        return(ERROR_DOS(ERRDOS,ERRnomem));
3091                } 
3092                if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
3093                        goto bad_param;
3094                if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
3095                    (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
3096                        goto bad_param;
3097
3098                memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
3099        }
3100
3101        state->received_data  = dscnt;
3102        state->received_param = pscnt;
3103
3104        if(state->setup_count > 0) {
3105                DEBUG(10,("reply_nttrans: state->setup_count = %d\n",
3106                          state->setup_count));
3107                state->setup = (uint16 *)TALLOC(state, state->setup_count);
3108                if (state->setup == NULL) {
3109                        DEBUG(0,("reply_nttrans : Out of memory\n"));
3110                        SAFE_FREE(state->data);
3111                        SAFE_FREE(state->param);
3112                        TALLOC_FREE(state);
3113                        END_PROFILE(SMBnttrans);
3114                        return ERROR_DOS(ERRDOS,ERRnomem);
3115                }
3116
3117                if ((smb_nt_SetupStart + state->setup_count < smb_nt_SetupStart) ||
3118                    (smb_nt_SetupStart + state->setup_count < state->setup_count)) {
3119                        goto bad_param;
3120                }
3121                if (smb_nt_SetupStart + state->setup_count > size) {
3122                        goto bad_param;
3123                }
3124
3125                memcpy( state->setup, &inbuf[smb_nt_SetupStart], state->setup_count);
3126                dump_data(10, (char *)state->setup, state->setup_count);
3127        }
3128
3129        if ((state->received_data == state->total_data) &&
3130            (state->received_param == state->total_param)) {
3131                outsize = handle_nttrans(conn, state, inbuf, outbuf,
3132                                         size, bufsize);
3133                SAFE_FREE(state->param);
3134                SAFE_FREE(state->data);
3135                TALLOC_FREE(state);
3136                END_PROFILE(SMBnttrans);
3137                return outsize;
3138        }
3139
3140        DLIST_ADD(conn->pending_trans, state);
3141
3142        /* We need to send an interim response then receive the rest
3143           of the parameter/data bytes */
3144        outsize = set_message(outbuf,0,0,False);
3145        show_msg(outbuf);
3146        END_PROFILE(SMBnttrans);
3147        return outsize;
3148
3149  bad_param:
3150
3151        DEBUG(0,("reply_nttrans: invalid trans parameters\n"));
3152        SAFE_FREE(state->data);
3153        SAFE_FREE(state->param);
3154        TALLOC_FREE(state);
3155        END_PROFILE(SMBnttrans);
3156        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3157}
3158       
3159/****************************************************************************
3160 Reply to a SMBnttranss
3161 ****************************************************************************/
3162
3163int reply_nttranss(connection_struct *conn,  char *inbuf,char *outbuf,
3164                   int size,int bufsize)
3165{
3166        int outsize = 0;
3167        unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
3168        struct trans_state *state;
3169
3170        START_PROFILE(SMBnttranss);
3171
3172        show_msg(inbuf);
3173
3174        for (state = conn->pending_trans; state != NULL;
3175             state = state->next) {
3176                if (state->mid == SVAL(inbuf,smb_mid)) {
3177                        break;
3178                }
3179        }
3180
3181        if ((state == NULL) || (state->cmd != SMBnttrans)) {
3182                END_PROFILE(SMBnttranss);
3183                return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3184        }
3185
3186        /* Revise state->total_param and state->total_data in case they have
3187           changed downwards */
3188        if (IVAL(inbuf, smb_nts_TotalParameterCount) < state->total_param) {
3189                state->total_param = IVAL(inbuf, smb_nts_TotalParameterCount);
3190        }
3191        if (IVAL(inbuf, smb_nts_TotalDataCount) < state->total_data) {
3192                state->total_data = IVAL(inbuf, smb_nts_TotalDataCount);
3193        }
3194
3195        pcnt = IVAL(inbuf,smb_nts_ParameterCount);
3196        poff = IVAL(inbuf, smb_nts_ParameterOffset);
3197        pdisp = IVAL(inbuf, smb_nts_ParameterDisplacement);
3198
3199        dcnt = IVAL(inbuf, smb_nts_DataCount);
3200        ddisp = IVAL(inbuf, smb_nts_DataDisplacement);
3201        doff = IVAL(inbuf, smb_nts_DataOffset);
3202
3203        state->received_param += pcnt;
3204        state->received_data += dcnt;
3205               
3206        if ((state->received_data > state->total_data) ||
3207            (state->received_param > state->total_param))
3208                goto bad_param;
3209
3210        if (pcnt) {
3211                if (pdisp+pcnt > state->total_param)
3212                        goto bad_param;
3213                if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
3214                        goto bad_param;
3215                if (pdisp > state->total_param)
3216                        goto bad_param;
3217                if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
3218                    (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
3219                        goto bad_param;
3220                if (state->param + pdisp < state->param)
3221                        goto bad_param;
3222
3223                memcpy(state->param+pdisp,smb_base(inbuf)+poff,
3224                       pcnt);
3225        }
3226
3227        if (dcnt) {
3228                if (ddisp+dcnt > state->total_data)
3229                        goto bad_param;
3230                if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
3231                        goto bad_param;
3232                if (ddisp > state->total_data)
3233                        goto bad_param;
3234                if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
3235                    (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
3236                        goto bad_param;
3237                if (state->data + ddisp < state->data)
3238                        goto bad_param;
3239
3240                memcpy(state->data+ddisp, smb_base(inbuf)+doff,
3241                       dcnt);     
3242        }
3243
3244        if ((state->received_param < state->total_param) ||
3245            (state->received_data < state->total_data)) {
3246                END_PROFILE(SMBnttranss);
3247                return -1;
3248        }
3249
3250        /* construct_reply_common has done us the favor to pre-fill the
3251         * command field with SMBnttranss which is wrong :-)
3252         */
3253        SCVAL(outbuf,smb_com,SMBnttrans);
3254
3255        outsize = handle_nttrans(conn, state, inbuf, outbuf,
3256                                 size, bufsize);
3257
3258        DLIST_REMOVE(conn->pending_trans, state);
3259        SAFE_FREE(state->data);
3260        SAFE_FREE(state->param);
3261        TALLOC_FREE(state);
3262
3263        if (outsize == 0) {
3264                END_PROFILE(SMBnttranss);
3265                return(ERROR_DOS(ERRSRV,ERRnosupport));
3266        }
3267       
3268        END_PROFILE(SMBnttranss);
3269        return(outsize);
3270
3271  bad_param:
3272
3273        DEBUG(0,("reply_nttranss: invalid trans parameters\n"));
3274        DLIST_REMOVE(conn->pending_trans, state);
3275        SAFE_FREE(state->data);
3276        SAFE_FREE(state->param);
3277        TALLOC_FREE(state);
3278        END_PROFILE(SMBnttranss);
3279        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3280}
Note: See TracBrowser for help on using the repository browser.