?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added the COMPRESSION_INFO trans2 QFILEINFO level and fixed the
[Samba.git] / source / smbd / trans2.c
blob8364c4b5095949a79ad5c72799266f368a370ac9
1 /*
2 Unix SMB/CIFS implementation.
3 SMB transaction2 handling
4 Copyright (C) Jeremy Allison 1994-2001
5 Copyright (C) Stefan (metze) Metzmacher 2003
6
7 Extensively modified by Andrew Tridgell, 1995
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25
26 extern int Protocol;
27 extern BOOL case_sensitive;
28 extern int smb_read_error;
29 extern fstring local_machine;
30 extern int global_oplock_break;
31 extern uint32 global_client_caps;
32 extern struct current_user current_user;
33
34 #define get_file_size(sbuf) ((sbuf).st_size)
35
36 /* given a stat buffer return the allocated size on disk, taking into
37 account sparse files */
38 SMB_BIG_UINT get_allocation_size(files_struct *fsp, SMB_STRUCT_STAT *sbuf)
39 {
40 SMB_BIG_UINT ret;
41 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
42 ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
43 #else
44 ret = (SMB_BIG_UINT)get_file_size(*sbuf);
45 #endif
46 if (!ret && fsp && fsp->initial_allocation_size)
47 ret = fsp->initial_allocation_size;
48 ret = SMB_ROUNDUP(ret,SMB_ROUNDUP_ALLOCATION_SIZE);
49 return ret;
50 }
51
52 /****************************************************************************
53 Send the required number of replies back.
54 We assume all fields other than the data fields are
55 set correctly for the type of call.
56 HACK ! Always assumes smb_setup field is zero.
57 ****************************************************************************/
58
59 static int send_trans2_replies(char *outbuf,
60 int bufsize,
61 char *params,
62 int paramsize,
63 char *pdata,
64 int datasize)
65 {
66 /* As we are using a protocol > LANMAN1 then the max_send
67 variable must have been set in the sessetupX call.
68 This takes precedence over the max_xmit field in the
69 global struct. These different max_xmit variables should
70 be merged as this is now too confusing */
71
72 extern int max_send;
73 int data_to_send = datasize;
74 int params_to_send = paramsize;
75 int useable_space;
76 char *pp = params;
77 char *pd = pdata;
78 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
79 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
80 int data_alignment_offset = 0;
81
82 /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
83
84 set_message(outbuf,10,0,True);
85
86 /* If there genuinely are no parameters or data to send just send the empty packet */
87
88 if(params_to_send == 0 && data_to_send == 0) {
89 if (!send_smb(smbd_server_fd(),outbuf))
90 exit_server("send_trans2_replies: send_smb failed.");
91 return 0;
92 }
93
94 /* When sending params and data ensure that both are nicely aligned */
95 /* Only do this alignment when there is also data to send - else
96 can cause NT redirector problems. */
97
98 if (((params_to_send % 4) != 0) && (data_to_send != 0))
99 data_alignment_offset = 4 - (params_to_send % 4);
100
101 /* Space is bufsize minus Netbios over TCP header minus SMB header */
102 /* The alignment_offset is to align the param bytes on an even byte
103 boundary. NT 4.0 Beta needs this to work correctly. */
104
105 useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
106
107 /* useable_space can never be more than max_send minus the alignment offset. */
108
109 useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
110
111 while (params_to_send || data_to_send) {
112 /* Calculate whether we will totally or partially fill this packet */
113
114 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
115
116 /* We can never send more than useable_space */
117 /*
118 * Note that 'useable_space' does not include the alignment offsets,
119 * but we must include the alignment offsets in the calculation of
120 * the length of the data we send over the wire, as the alignment offsets
121 * are sent here. Fix from Marc_Jacobsen@hp.com.
122 */
123
124 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
125
126 set_message(outbuf, 10, total_sent_thistime, True);
127
128 /* Set total params and data to be sent */
129 SSVAL(outbuf,smb_tprcnt,paramsize);
130 SSVAL(outbuf,smb_tdrcnt,datasize);
131
132 /* Calculate how many parameters and data we can fit into
133 * this packet. Parameters get precedence
134 */
135
136 params_sent_thistime = MIN(params_to_send,useable_space);
137 data_sent_thistime = useable_space - params_sent_thistime;
138 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
139
140 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
141
142 /* smb_proff is the offset from the start of the SMB header to the
143 parameter bytes, however the first 4 bytes of outbuf are
144 the Netbios over TCP header. Thus use smb_base() to subtract
145 them from the calculation */
146
147 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
148
149 if(params_sent_thistime == 0)
150 SSVAL(outbuf,smb_prdisp,0);
151 else
152 /* Absolute displacement of param bytes sent in this packet */
153 SSVAL(outbuf,smb_prdisp,pp - params);
154
155 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
156 if(data_sent_thistime == 0) {
157 SSVAL(outbuf,smb_droff,0);
158 SSVAL(outbuf,smb_drdisp, 0);
159 } else {
160 /* The offset of the data bytes is the offset of the
161 parameter bytes plus the number of parameters being sent this time */
162 SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
163 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
164 SSVAL(outbuf,smb_drdisp, pd - pdata);
165 }
166
167 /* Copy the param bytes into the packet */
168
169 if(params_sent_thistime)
170 memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
171
172 /* Copy in the data bytes */
173 if(data_sent_thistime)
174 memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
175 data_alignment_offset,pd,data_sent_thistime);
176
177 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
178 params_sent_thistime, data_sent_thistime, useable_space));
179 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
180 params_to_send, data_to_send, paramsize, datasize));
181
182 /* Send the packet */
183 if (!send_smb(smbd_server_fd(),outbuf))
184 exit_server("send_trans2_replies: send_smb failed.");
185
186 pp += params_sent_thistime;
187 pd += data_sent_thistime;
188
189 params_to_send -= params_sent_thistime;
190 data_to_send -= data_sent_thistime;
191
192 /* Sanity check */
193 if(params_to_send < 0 || data_to_send < 0) {
194 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
195 params_to_send, data_to_send));
196 return -1;
197 }
198 }
199
200 return 0;
201 }
202
203 /****************************************************************************
204 Reply to a TRANSACT2_OPEN.
205 ****************************************************************************/
206
207 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
208 char **pparams, int total_params, char **ppdata, int total_data)
209 {
210 char *params = *pparams;
211 int16 open_mode;
212 int16 open_attr;
213 BOOL oplock_request;
214 #if 0
215 BOOL return_additional_info;
216 int16 open_sattr;
217 time_t open_time;
218 #endif
219 int16 open_ofun;
220 int32 open_size;
221 char *pname;
222 pstring fname;
223 mode_t unixmode;
224 SMB_OFF_T size=0;
225 int fmode=0,mtime=0,rmode;
226 SMB_INO_T inode = 0;
227 SMB_STRUCT_STAT sbuf;
228 int smb_action = 0;
229 BOOL bad_path = False;
230 files_struct *fsp;
231
232 /*
233 * Ensure we have enough parameters to perform the operation.
234 */
235
236 if (total_params < 29)
237 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
238
239 open_mode = SVAL(params, 2);
240 open_attr = SVAL(params,6);
241 oplock_request = (((SVAL(params,0)|(1<<1))>>1) | ((SVAL(params,0)|(1<<2))>>1));
242 #if 0
243 return_additional_info = BITSETW(params,0);
244 open_sattr = SVAL(params, 4);
245 open_time = make_unix_date3(params+8);
246 #endif
247 open_ofun = SVAL(params,12);
248 open_size = IVAL(params,14);
249 pname = &params[28];
250
251 srvstr_pull(inbuf, fname, pname, sizeof(fname), -1, STR_TERMINATE);
252
253 DEBUG(3,("trans2open %s mode=%d attr=%d ofun=%d size=%d\n",
254 fname,open_mode, open_attr, open_ofun, open_size));
255
256 if (IS_IPC(conn))
257 return(ERROR_DOS(ERRSRV,ERRaccess));
258
259 /* XXXX we need to handle passed times, sattr and flags */
260
261 unix_convert(fname,conn,0,&bad_path,&sbuf);
262
263 if (!check_name(fname,conn)) {
264 set_bad_path_error(errno, bad_path);
265 return(UNIXERROR(ERRDOS,ERRnoaccess));
266 }
267
268 unixmode = unix_mode(conn,open_attr | aARCH, fname);
269
270 fsp = open_file_shared(conn,fname,&sbuf,open_mode,open_ofun,unixmode,
271 oplock_request, &rmode,&smb_action);
272
273 if (!fsp) {
274 set_bad_path_error(errno, bad_path);
275 return(UNIXERROR(ERRDOS,ERRnoaccess));
276 }
277
278 size = get_file_size(sbuf);
279 fmode = dos_mode(conn,fname,&sbuf);
280 mtime = sbuf.st_mtime;
281 inode = sbuf.st_ino;
282 if (fmode & aDIR) {
283 close_file(fsp,False);
284 return(ERROR_DOS(ERRDOS,ERRnoaccess));
285 }
286
287 /* Realloc the size of parameters and data we will return */
288 params = Realloc(*pparams, 28);
289 if( params == NULL )
290 return(ERROR_DOS(ERRDOS,ERRnomem));
291 *pparams = params;
292
293 memset((char *)params,'\0',28);
294 SSVAL(params,0,fsp->fnum);
295 SSVAL(params,2,fmode);
296 put_dos_date2(params,4, mtime);
297 SIVAL(params,8, (uint32)size);
298 SSVAL(params,12,rmode);
299
300 if (oplock_request && lp_fake_oplocks(SNUM(conn)))
301 smb_action |= EXTENDED_OPLOCK_GRANTED;
302
303 SSVAL(params,18,smb_action);
304
305 /*
306 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
307 */
308 SIVAL(params,20,inode);
309
310 /* Send the required number of replies */
311 send_trans2_replies(outbuf, bufsize, params, 28, *ppdata, 0);
312
313 return -1;
314 }
315
316 /*********************************************************
317 Routine to check if a given string matches exactly.
318 as a special case a mask of "." does NOT match. That
319 is required for correct wildcard semantics
320 Case can be significant or not.
321 **********************************************************/
322
323 static BOOL exact_match(char *str,char *mask, BOOL case_sig)
324 {
325 if (mask[0] == '.' && mask[1] == 0)
326 return False;
327 if (case_sig)
328 return strcmp(str,mask)==0;
329 return strcasecmp(str,mask) == 0;
330 }
331
332 /****************************************************************************
333 Return the filetype for UNIX extensions.
334 ****************************************************************************/
335
336 static uint32 unix_filetype(mode_t mode)
337 {
338 if(S_ISREG(mode))
339 return UNIX_TYPE_FILE;
340 else if(S_ISDIR(mode))
341 return UNIX_TYPE_DIR;
342 #ifdef S_ISLNK
343 else if(S_ISLNK(mode))
344 return UNIX_TYPE_SYMLINK;
345 #endif
346 #ifdef S_ISCHR
347 else if(S_ISCHR(mode))
348 return UNIX_TYPE_CHARDEV;
349 #endif
350 #ifdef S_ISBLK
351 else if(S_ISBLK(mode))
352 return UNIX_TYPE_BLKDEV;
353 #endif
354 #ifdef S_ISFIFO
355 else if(S_ISFIFO(mode))
356 return UNIX_TYPE_FIFO;
357 #endif
358 #ifdef S_ISSOCK
359 else if(S_ISSOCK(mode))
360 return UNIX_TYPE_SOCKET;
361 #endif
362
363 DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
364 return UNIX_TYPE_UNKNOWN;
365 }
366
367 /****************************************************************************
368 Return the major devicenumber for UNIX extensions.
369 ****************************************************************************/
370
371 static uint32 unix_dev_major(SMB_DEV_T dev)
372 {
373 #if defined(HAVE_DEVICE_MAJOR_FN)
374 return (uint32)major(dev);
375 #else
376 return (uint32)(dev >> 8);
377 #endif
378 }
379
380 /****************************************************************************
381 Return the minor devicenumber for UNIX extensions.
382 ****************************************************************************/
383
384 static uint32 unix_dev_minor(SMB_DEV_T dev)
385 {
386 #if defined(HAVE_DEVICE_MINOR_FN)
387 return (uint32)minor(dev);
388 #else
389 return (uint32)(dev & 0xff);
390 #endif
391 }
392
393 /****************************************************************************
394 Map wire perms onto standard UNIX permissions. Obey share restrictions.
395 ****************************************************************************/
396
397 static mode_t unix_perms_from_wire( connection_struct *conn, SMB_STRUCT_STAT *pst, uint32 perms)
398 {
399 mode_t ret = 0;
400
401 if (perms == SMB_MODE_NO_CHANGE)
402 return pst->st_mode;
403
404 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
405 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
406 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
407 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
408 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
409 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
410 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
411 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
412 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
413 #ifdef S_ISVTX
414 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
415 #endif
416 #ifdef S_ISGID
417 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
418 #endif
419 #ifdef S_ISUID
420 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
421 #endif
422
423 if (VALID_STAT(*pst) && S_ISDIR(pst->st_mode)) {
424 ret &= lp_dir_mask(SNUM(conn));
425 /* Add in force bits */
426 ret |= lp_force_dir_mode(SNUM(conn));
427 } else {
428 /* Apply mode mask */
429 ret &= lp_create_mask(SNUM(conn));
430 /* Add in force bits */
431 ret |= lp_force_create_mode(SNUM(conn));
432 }
433
434 return ret;
435 }
436
437 /****************************************************************************
438 checks for SMB_TIME_NO_CHANGE and if not found
439 calls interpret_long_date
440 ****************************************************************************/
441 time_t interpret_long_unix_date(char *p)
442 {
443 DEBUG(1,("interpret_long_unix_date\n"));
444 if(IVAL(p,0) == SMB_TIME_NO_CHANGE_LO &&
445 IVAL(p,4) == SMB_TIME_NO_CHANGE_HI) {
446 return -1;
447 } else {
448 return interpret_long_date(p);
449 }
450 }
451
452 /****************************************************************************
453 Get a level dependent lanman2 dir entry.
454 ****************************************************************************/
455
456 static BOOL get_lanman2_dir_entry(connection_struct *conn,
457 void *inbuf, void *outbuf,
458 char *path_mask,int dirtype,int info_level,
459 int requires_resume_key,
460 BOOL dont_descend,char **ppdata,
461 char *base_data, int space_remaining,
462 BOOL *out_of_space, BOOL *got_exact_match,
463 int *last_name_off)
464 {
465 const char *dname;
466 BOOL found = False;
467 SMB_STRUCT_STAT sbuf;
468 pstring mask;
469 pstring pathreal;
470 pstring fname;
471 char *p, *q, *pdata = *ppdata;
472 uint32 reskey=0;
473 int prev_dirpos=0;
474 int mode=0;
475 SMB_OFF_T file_size = 0;
476 SMB_BIG_UINT allocation_size = 0;
477 uint32 len;
478 time_t mdate=0, adate=0, cdate=0;
479 char *nameptr;
480 BOOL was_8_3;
481 int nt_extmode; /* Used for NT connections instead of mode */
482 BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
483
484 *fname = 0;
485 *out_of_space = False;
486 *got_exact_match = False;
487
488 if (!conn->dirptr)
489 return(False);
490
491 p = strrchr_m(path_mask,'/');
492 if(p != NULL) {
493 if(p[1] == '\0')
494 pstrcpy(mask,"*.*");
495 else
496 pstrcpy(mask, p+1);
497 } else
498 pstrcpy(mask, path_mask);
499
500 while (!found) {
501 BOOL got_match;
502
503 /* Needed if we run out of space */
504 prev_dirpos = TellDir(conn->dirptr);
505 dname = ReadDirName(conn->dirptr);
506
507 /*
508 * Due to bugs in NT client redirectors we are not using
509 * resume keys any more - set them to zero.
510 * Check out the related comments in findfirst/findnext.
511 * JRA.
512 */
513
514 reskey = 0;
515
516 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %d\n",
517 (long)conn->dirptr,TellDir(conn->dirptr)));
518
519 if (!dname)
520 return(False);
521
522 pstrcpy(fname,dname);
523
524 if(!(got_match = *got_exact_match = exact_match(fname, mask, case_sensitive)))
525 got_match = mask_match(fname, mask, case_sensitive);
526
527 if(!got_match && !mangle_is_8_3(fname, False)) {
528
529 /*
530 * It turns out that NT matches wildcards against
531 * both long *and* short names. This may explain some
532 * of the wildcard wierdness from old DOS clients
533 * that some people have been seeing.... JRA.
534 */
535
536 pstring newname;
537 pstrcpy( newname, fname);
538 mangle_map( newname, True, False, SNUM(conn));
539 if(!(got_match = *got_exact_match = exact_match(newname, mask, case_sensitive)))
540 got_match = mask_match(newname, mask, case_sensitive);
541 }
542
543 if(got_match) {
544 BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
545 if (dont_descend && !isdots)
546 continue;
547
548 pstrcpy(pathreal,conn->dirpath);
549 if(needslash)
550 pstrcat(pathreal,"/");
551 pstrcat(pathreal,dname);
552
553 if (INFO_LEVEL_IS_UNIX(info_level)) {
554 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
555 DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
556 pathreal,strerror(errno)));
557 continue;
558 }
559 } else if (SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
560
561 /* Needed to show the msdfs symlinks as
562 * directories */
563
564 if(lp_host_msdfs() &&
565 lp_msdfs_root(SNUM(conn)) &&
566 is_msdfs_link(conn, pathreal, NULL, NULL,
567 &sbuf)) {
568
569 DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s as a directory\n", pathreal));
570 sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
571
572 } else {
573
574 DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
575 pathreal,strerror(errno)));
576 continue;
577 }
578 }
579
580 mode = dos_mode(conn,pathreal,&sbuf);
581
582 if (!dir_check_ftype(conn,mode,&sbuf,dirtype)) {
583 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
584 continue;
585 }
586
587 file_size = get_file_size(sbuf);
588 allocation_size = get_allocation_size(NULL,&sbuf);
589 mdate = sbuf.st_mtime;
590 adate = sbuf.st_atime;
591 cdate = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
592
593 if (lp_dos_filetime_resolution(SNUM(conn))) {
594 cdate &= ~1;
595 mdate &= ~1;
596 adate &= ~1;
597 }
598
599 if(mode & aDIR)
600 file_size = 0;
601
602 DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
603
604 found = True;
605 }
606 }
607
608 mangle_map(fname,False,True,SNUM(conn));
609
610 p = pdata;
611 nameptr = p;
612
613 nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
614
615 switch (info_level) {
616 case SMB_INFO_STANDARD:
617 if(requires_resume_key) {
618 SIVAL(p,0,reskey);
619 p += 4;
620 }
621 put_dos_date2(p,l1_fdateCreation,cdate);
622 put_dos_date2(p,l1_fdateLastAccess,adate);
623 put_dos_date2(p,l1_fdateLastWrite,mdate);
624 SIVAL(p,l1_cbFile,(uint32)file_size);
625 SIVAL(p,l1_cbFileAlloc,(uint32)allocation_size);
626 SSVAL(p,l1_attrFile,mode);
627 p += l1_achName;
628 nameptr = p;
629 p += align_string(outbuf, p, 0);
630 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
631 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS)
632 SCVAL(nameptr, -1, len-2);
633 else
634 SCVAL(nameptr, -1, len-1);
635 p += len;
636 break;
637
638 case SMB_INFO_QUERY_EA_SIZE:
639 if(requires_resume_key) {
640 SIVAL(p,0,reskey);
641 p += 4;
642 }
643 put_dos_date2(p,l2_fdateCreation,cdate);
644 put_dos_date2(p,l2_fdateLastAccess,adate);
645 put_dos_date2(p,l2_fdateLastWrite,mdate);
646 SIVAL(p,l2_cbFile,(uint32)file_size);
647 SIVAL(p,l2_cbFileAlloc,(uint32)allocation_size);
648 SSVAL(p,l2_attrFile,mode);
649 SIVAL(p,l2_cbList,0); /* No extended attributes */
650 p += l2_achName;
651 nameptr = p;
652 p += align_string(outbuf, p, 0);
653 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
654 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS)
655 SCVAL(nameptr, -1, len-2);
656 else
657 SCVAL(nameptr, -1, len-1);
658 p += len;
659 break;
660
661 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
662 was_8_3 = mangle_is_8_3(fname, True);
663 p += 4;
664 SIVAL(p,0,reskey); p += 4;
665 put_long_date(p,cdate); p += 8;
666 put_long_date(p,adate); p += 8;
667 put_long_date(p,mdate); p += 8;
668 put_long_date(p,mdate); p += 8;
669 SOFF_T(p,0,file_size);
670 SOFF_T(p,8,allocation_size);
671 p += 16;
672 SIVAL(p,0,nt_extmode); p += 4;
673 q = p; p += 4;
674 SIVAL(p,0,0); p += 4;
675 /* Clear the short name buffer. This is
676 * IMPORTANT as not doing so will trigger
677 * a Win2k client bug. JRA.
678 */
679 memset(p,'\0',26);
680 if (!was_8_3) {
681 pstring mangled_name;
682 pstrcpy(mangled_name, fname);
683 mangle_map(mangled_name,True,True,SNUM(conn));
684 mangled_name[12] = 0;
685 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER);
686 #ifdef DEVELOPER
687 /* valgrind fixer... */
688 {
689 size_t sl = strlen(p+2);
690 if (24-sl)
691 memset(&p[sl+2], '\0', 24-sl);
692 }
693 #endif
694 SSVAL(p, 0, len);
695 } else {
696 SSVAL(p,0,0);
697 *(p+2) = 0;
698 }
699 p += 2 + 24;
700 len = srvstr_push(outbuf, p, fname, -1, 0);
701 SIVAL(q,0,len);
702 p += len;
703 len = PTR_DIFF(p, pdata);
704 len = (len + 3) & ~3;
705 SIVAL(pdata,0,len);
706 p = pdata + len;
707 break;
708
709 case SMB_FIND_FILE_DIRECTORY_INFO:
710 p += 4;
711 SIVAL(p,0,reskey); p += 4;
712 put_long_date(p,cdate); p += 8;
713 put_long_date(p,adate); p += 8;
714 put_long_date(p,mdate); p += 8;
715 put_long_date(p,mdate); p += 8;
716 SOFF_T(p,0,file_size);
717 SOFF_T(p,8,allocation_size);
718 p += 16;
719 SIVAL(p,0,nt_extmode); p += 4;
720 p += 4;
721 len = srvstr_push(outbuf, p, fname, -1, 0);
722 SIVAL(p, -4, len);
723 p += len;
724 len = PTR_DIFF(p, pdata);
725 len = (len + 3) & ~3;
726 SIVAL(pdata,0,len);
727 p = pdata + len;
728 break;
729
730 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
731 p += 4;
732 SIVAL(p,0,reskey); p += 4;
733 put_long_date(p,cdate); p += 8;
734 put_long_date(p,adate); p += 8;
735 put_long_date(p,mdate); p += 8;
736 put_long_date(p,mdate); p += 8;
737 SOFF_T(p,0,file_size);
738 SOFF_T(p,8,allocation_size);
739 p += 16;
740 SIVAL(p,0,nt_extmode); p += 4;
741 p += 4;
742 SIVAL(p,0,0); p += 4;
743
744 len = srvstr_push(outbuf, p, fname, -1, 0);
745 SIVAL(p, -4, len);
746 p += len;
747
748 len = PTR_DIFF(p, pdata);
749 len = (len + 3) & ~3;
750 SIVAL(pdata,0,len);
751 p = pdata + len;
752 break;
753
754 case SMB_FIND_FILE_NAMES_INFO:
755 p += 4;
756 SIVAL(p,0,reskey); p += 4;
757 p += 4;
758 /* this must *not* be null terminated or w2k gets in a loop trying to set an
759 acl on a dir (tridge) */
760 len = srvstr_push(outbuf, p, fname, -1, 0);
761 SIVAL(p, -4, len);
762 p += len;
763 len = PTR_DIFF(p, pdata);
764 len = (len + 3) & ~3;
765 SIVAL(pdata,0,len);
766 p = pdata + len;
767 break;
768
769 /* CIFS UNIX Extension. */
770
771 case SMB_FIND_FILE_UNIX:
772 p+= 4;
773 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
774
775 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
776 SOFF_T(p,0,get_file_size(sbuf)); /* File size 64 Bit */
777 p+= 8;
778
779 SOFF_T(p,0,get_allocation_size(NULL,&sbuf)); /* Number of bytes used on disk - 64 Bit */
780 p+= 8;
781
782 put_long_date(p,sbuf.st_ctime); /* Creation Time 64 Bit */
783 put_long_date(p+8,sbuf.st_atime); /* Last access time 64 Bit */
784 put_long_date(p+16,sbuf.st_mtime); /* Last modification time 64 Bit */
785 p+= 24;
786
787 SIVAL(p,0,sbuf.st_uid); /* user id for the owner */
788 SIVAL(p,4,0);
789 p+= 8;
790
791 SIVAL(p,0,sbuf.st_gid); /* group id of owner */
792 SIVAL(p,4,0);
793 p+= 8;
794
795 SIVAL(p,0,unix_filetype(sbuf.st_mode));
796 p+= 4;
797
798 SIVAL(p,0,unix_dev_major(sbuf.st_rdev)); /* Major device number if type is device */
799 SIVAL(p,4,0);
800 p+= 8;
801
802 SIVAL(p,0,unix_dev_minor(sbuf.st_rdev)); /* Minor device number if type is device */
803 SIVAL(p,4,0);
804 p+= 8;
805
806 SINO_T(p,0,(SMB_INO_T)sbuf.st_ino); /* inode number */
807 p+= 8;
808
809 SIVAL(p,0, unix_perms_to_wire(sbuf.st_mode)); /* Standard UNIX file permissions */
810 SIVAL(p,4,0);
811 p+= 8;
812
813 SIVAL(p,0,sbuf.st_nlink); /* number of hard links */
814 SIVAL(p,4,0);
815 p+= 8;
816
817 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
818 p += len;
819
820 len = PTR_DIFF(p, pdata);
821 len = (len + 3) & ~3;
822 SIVAL(pdata,0,len); /* Offset from this structure to the beginning of the next one */
823 p = pdata + len;
824 /* End of SMB_QUERY_FILE_UNIX_BASIC */
825
826 break;
827
828 default:
829 return(False);
830 }
831
832
833 if (PTR_DIFF(p,pdata) > space_remaining) {
834 /* Move the dirptr back to prev_dirpos */
835 SeekDir(conn->dirptr, prev_dirpos);
836 *out_of_space = True;
837 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
838 return False; /* Not finished - just out of space */
839 }
840
841 /* Setup the last_filename pointer, as an offset from base_data */
842 *last_name_off = PTR_DIFF(nameptr,base_data);
843 /* Advance the data pointer to the next slot */
844 *ppdata = p;
845
846 return(found);
847 }
848
849 /****************************************************************************
850 Reply to a TRANS2_FINDFIRST.
851 ****************************************************************************/
852
853 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
854 char **pparams, int total_params, char **ppdata, int total_data)
855 {
856 /* We must be careful here that we don't return more than the
857 allowed number of data bytes. If this means returning fewer than
858 maxentries then so be it. We assume that the redirector has
859 enough room for the fixed number of parameter bytes it has
860 requested. */
861 uint32 max_data_bytes = SVAL(inbuf, smb_mdrcnt);
862 char *params = *pparams;
863 char *pdata = *ppdata;
864 int dirtype = SVAL(params,0);
865 int maxentries = SVAL(params,2);
866 BOOL close_after_first = BITSETW(params+4,0);
867 BOOL close_if_end = BITSETW(params+4,1);
868 BOOL requires_resume_key = BITSETW(params+4,2);
869 int info_level = SVAL(params,6);
870 pstring directory;
871 pstring mask;
872 char *p, *wcard;
873 int last_name_off=0;
874 int dptr_num = -1;
875 int numentries = 0;
876 int i;
877 BOOL finished = False;
878 BOOL dont_descend = False;
879 BOOL out_of_space = False;
880 int space_remaining;
881 BOOL bad_path = False;
882 SMB_STRUCT_STAT sbuf;
883
884 if (total_params < 12)
885 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
886
887 *directory = *mask = 0;
888
889 DEBUG(3,("call_trans2findfirst: dirtype = %d, maxentries = %d, close_after_first=%d, \
890 close_if_end = %d requires_resume_key = %d level = %d, max_data_bytes = %d\n",
891 dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
892 info_level, max_data_bytes));
893
894 switch (info_level) {
895 case SMB_INFO_STANDARD:
896 case SMB_INFO_QUERY_EA_SIZE:
897 case SMB_FIND_FILE_DIRECTORY_INFO:
898 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
899 case SMB_FIND_FILE_NAMES_INFO:
900 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
901 break;
902 case SMB_FIND_FILE_UNIX:
903 if (!lp_unix_extensions())
904 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
905 break;
906 default:
907 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
908 }
909
910 srvstr_pull(inbuf, directory, params+12, sizeof(directory), -1, STR_TERMINATE);
911
912 RESOLVE_FINDFIRST_DFSPATH(directory, conn, inbuf, outbuf);
913
914 unix_convert(directory,conn,0,&bad_path,&sbuf);
915 if(!check_name(directory,conn)) {
916 set_bad_path_error(errno, bad_path);
917 return(UNIXERROR(ERRDOS,ERRbadpath));
918 }
919
920 p = strrchr_m(directory,'/');
921 if(p == NULL) {
922 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
923 if((directory[0] == '.') && (directory[1] == '\0'))
924 pstrcpy(mask,"*");
925 else
926 pstrcpy(mask,directory);
927 pstrcpy(directory,"./");
928 } else {
929 pstrcpy(mask,p+1);
930 *p = 0;
931 }
932
933 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
934
935 pdata = Realloc(*ppdata, max_data_bytes + 1024);
936 if( pdata == NULL )
937 return(ERROR_DOS(ERRDOS,ERRnomem));
938
939 *ppdata = pdata;
940 memset((char *)pdata,'\0',max_data_bytes + 1024);
941
942 /* Realloc the params space */
943 params = Realloc(*pparams, 10);
944 if (params == NULL)
945 return ERROR_DOS(ERRDOS,ERRnomem);
946 *pparams = params;
947
948 dptr_num = dptr_create(conn,directory, False, True ,SVAL(inbuf,smb_pid));
949 if (dptr_num < 0)
950 return(UNIXERROR(ERRDOS,ERRbadfile));
951
952 /* Save the wildcard match and attribs we are using on this directory -
953 needed as lanman2 assumes these are being saved between calls */
954
955 if(!(wcard = strdup(mask))) {
956 dptr_close(&dptr_num);
957 return ERROR_DOS(ERRDOS,ERRnomem);
958 }
959
960 dptr_set_wcard(dptr_num, wcard);
961 dptr_set_attr(dptr_num, dirtype);
962
963 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n",dptr_num, wcard, dirtype));
964
965 /* We don't need to check for VOL here as this is returned by
966 a different TRANS2 call. */
967
968 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
969 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),case_sensitive))
970 dont_descend = True;
971
972 p = pdata;
973 space_remaining = max_data_bytes;
974 out_of_space = False;
975
976 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
977 BOOL got_exact_match = False;
978
979 /* this is a heuristic to avoid seeking the dirptr except when
980 absolutely necessary. It allows for a filename of about 40 chars */
981 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
982 out_of_space = True;
983 finished = False;
984 } else {
985 finished = !get_lanman2_dir_entry(conn,
986 inbuf, outbuf,
987 mask,dirtype,info_level,
988 requires_resume_key,dont_descend,
989 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
990 &last_name_off);
991 }
992
993 if (finished && out_of_space)
994 finished = False;
995
996 if (!finished && !out_of_space)
997 numentries++;
998
999 /*
1000 * As an optimisation if we know we aren't looking
1001 * for a wildcard name (ie. the name matches the wildcard exactly)
1002 * then we can finish on any (first) match.
1003 * This speeds up large directory searches. JRA.
1004 */
1005
1006 if(got_exact_match)
1007 finished = True;
1008
1009 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1010 }
1011
1012 /* Check if we can close the dirptr */
1013 if(close_after_first || (finished && close_if_end)) {
1014 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1015 dptr_close(&dptr_num);
1016 }
1017
1018 /*
1019 * If there are no matching entries we must return ERRDOS/ERRbadfile -
1020 * from observation of NT.
1021 */
1022
1023 if(numentries == 0) {
1024 dptr_close(&dptr_num);
1025 return ERROR_DOS(ERRDOS,ERRbadfile);
1026 }
1027
1028 /* At this point pdata points to numentries directory entries. */
1029
1030 /* Set up the return parameter block */
1031 SSVAL(params,0,dptr_num);
1032 SSVAL(params,2,numentries);
1033 SSVAL(params,4,finished);
1034 SSVAL(params,6,0); /* Never an EA error */
1035 SSVAL(params,8,last_name_off);
1036
1037 send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata));
1038
1039 if ((! *directory) && dptr_path(dptr_num))
1040 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1041
1042 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1043 smb_fn_name(CVAL(inbuf,smb_com)),
1044 mask, directory, dirtype, numentries ) );
1045
1046 /*
1047 * Force a name mangle here to ensure that the
1048 * mask as an 8.3 name is top of the mangled cache.
1049 * The reasons for this are subtle. Don't remove
1050 * this code unless you know what you are doing
1051 * (see PR#13758). JRA.
1052 */
1053
1054 if(!mangle_is_8_3_wildcards( mask, False))
1055 mangle_map(mask, True, True, SNUM(conn));
1056
1057 return(-1);
1058 }
1059
1060 /****************************************************************************
1061 Reply to a TRANS2_FINDNEXT.
1062 ****************************************************************************/
1063
1064 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1065 char **pparams, int total_params, char **ppdata, int total_data)
1066 {
1067 /* We must be careful here that we don't return more than the
1068 allowed number of data bytes. If this means returning fewer than
1069 maxentries then so be it. We assume that the redirector has
1070 enough room for the fixed number of parameter bytes it has
1071 requested. */
1072 int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1073 char *params = *pparams;
1074 char *pdata = *ppdata;
1075 int dptr_num = SVAL(params,0);
1076 int maxentries = SVAL(params,2);
1077 uint16 info_level = SVAL(params,4);
1078 uint32 resume_key = IVAL(params,6);
1079 BOOL close_after_request = BITSETW(params+10,0);
1080 BOOL close_if_end = BITSETW(params+10,1);
1081 BOOL requires_resume_key = BITSETW(params+10,2);
1082 BOOL continue_bit = BITSETW(params+10,3);
1083 pstring resume_name;
1084 pstring mask;
1085 pstring directory;
1086 char *p;
1087 uint16 dirtype;
1088 int numentries = 0;
1089 int i, last_name_off=0;
1090 BOOL finished = False;
1091 BOOL dont_descend = False;
1092 BOOL out_of_space = False;
1093 int space_remaining;
1094
1095 if (total_params < 12)
1096 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1097
1098 *mask = *directory = *resume_name = 0;
1099
1100 srvstr_pull(inbuf, resume_name, params+12, sizeof(resume_name), -1, STR_TERMINATE);
1101
1102 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
1103 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
1104 resume_key = %d resume name = %s continue=%d level = %d\n",
1105 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
1106 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
1107
1108 switch (info_level) {
1109 case SMB_INFO_STANDARD:
1110 case SMB_INFO_QUERY_EA_SIZE:
1111 case SMB_FIND_FILE_DIRECTORY_INFO:
1112 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1113 case SMB_FIND_FILE_NAMES_INFO:
1114 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1115 break;
1116 case SMB_FIND_FILE_UNIX:
1117 if (!lp_unix_extensions())
1118 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
1119 break;
1120 default:
1121 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1122 }
1123
1124 pdata = Realloc( *ppdata, max_data_bytes + 1024);
1125 if(pdata == NULL)
1126 return ERROR_DOS(ERRDOS,ERRnomem);
1127
1128 *ppdata = pdata;
1129 memset((char *)pdata,'\0',max_data_bytes + 1024);
1130
1131 /* Realloc the params space */
1132 params = Realloc(*pparams, 6*SIZEOFWORD);
1133 if( params == NULL )
1134 return ERROR_DOS(ERRDOS,ERRnomem);
1135
1136 *pparams = params;
1137
1138 /* Check that the dptr is valid */
1139 if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num)))
1140 return ERROR_DOS(ERRDOS,ERRnofiles);
1141
1142 string_set(&conn->dirpath,dptr_path(dptr_num));
1143
1144 /* Get the wildcard mask from the dptr */
1145 if((p = dptr_wcard(dptr_num))== NULL) {
1146 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
1147 return ERROR_DOS(ERRDOS,ERRnofiles);
1148 }
1149
1150 pstrcpy(mask, p);
1151 pstrcpy(directory,conn->dirpath);
1152
1153 /* Get the attr mask from the dptr */
1154 dirtype = dptr_attr(dptr_num);
1155
1156 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%d)\n",
1157 dptr_num, mask, dirtype,
1158 (long)conn->dirptr,
1159 TellDir(conn->dirptr)));
1160
1161 /* We don't need to check for VOL here as this is returned by
1162 a different TRANS2 call. */
1163
1164 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
1165 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),case_sensitive))
1166 dont_descend = True;
1167
1168 p = pdata;
1169 space_remaining = max_data_bytes;
1170 out_of_space = False;
1171
1172 /*
1173 * Seek to the correct position. We no longer use the resume key but
1174 * depend on the last file name instead.
1175 */
1176
1177 if(requires_resume_key && *resume_name && !continue_bit) {
1178
1179 /*
1180 * Fix for NT redirector problem triggered by resume key indexes
1181 * changing between directory scans. We now return a resume key of 0
1182 * and instead look for the filename to continue from (also given
1183 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
1184 * findfirst/findnext (as is usual) then the directory pointer
1185 * should already be at the correct place. Check this by scanning
1186 * backwards looking for an exact (ie. case sensitive) filename match.
1187 * If we get to the beginning of the directory and haven't found it then scan
1188 * forwards again looking for a match. JRA.
1189 */
1190
1191 int current_pos, start_pos;
1192 const char *dname = NULL;
1193 pstring dname_pstring;
1194 void *dirptr = conn->dirptr;
1195 start_pos = TellDir(dirptr);
1196 for(current_pos = start_pos; current_pos >= 0; current_pos--) {
1197 DEBUG(7,("call_trans2findnext: seeking to pos %d\n", current_pos));
1198
1199 SeekDir(dirptr, current_pos);
1200 dname = ReadDirName(dirptr);
1201 if (dname) {
1202 /*
1203 * Remember, mangle_map is called by
1204 * get_lanman2_dir_entry(), so the resume name
1205 * could be mangled. Ensure we do the same
1206 * here.
1207 */
1208
1209 /* make sure we get a copy that mangle_map can modify */
1210
1211 pstrcpy(dname_pstring, dname);
1212 mangle_map( dname_pstring, False, True, SNUM(conn));
1213
1214 if(strcsequal( resume_name, dname_pstring)) {
1215 SeekDir(dirptr, current_pos+1);
1216 DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1217 break;
1218 }
1219 }
1220 }
1221
1222 /*
1223 * Scan forward from start if not found going backwards.
1224 */
1225
1226 if(current_pos < 0) {
1227 DEBUG(7,("call_trans2findnext: notfound: seeking to pos %d\n", start_pos));
1228 SeekDir(dirptr, start_pos);
1229 for(current_pos = start_pos; (dname = ReadDirName(dirptr)) != NULL; SeekDir(dirptr,++current_pos)) {
1230
1231 /*
1232 * Remember, mangle_map is called by
1233 * get_lanman2_dir_entry(), so the resume name
1234 * could be mangled. Ensure we do the same
1235 * here.
1236 */
1237
1238 if(dname) {
1239 /* make sure we get a copy that mangle_map can modify */
1240
1241 pstrcpy(dname_pstring, dname);
1242 mangle_map(dname_pstring, False, True, SNUM(conn));
1243
1244 if(strcsequal( resume_name, dname_pstring)) {
1245 SeekDir(dirptr, current_pos+1);
1246 DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1247 break;
1248 }
1249 }
1250 } /* end for */
1251 } /* end if current_pos */
1252 } /* end if requires_resume_key && !continue_bit */
1253
1254 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
1255 BOOL got_exact_match = False;
1256
1257 /* this is a heuristic to avoid seeking the dirptr except when
1258 absolutely necessary. It allows for a filename of about 40 chars */
1259 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1260 out_of_space = True;
1261 finished = False;
1262 } else {
1263 finished = !get_lanman2_dir_entry(conn,
1264 inbuf, outbuf,
1265 mask,dirtype,info_level,
1266 requires_resume_key,dont_descend,
1267 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1268 &last_name_off);
1269 }
1270
1271 if (finished && out_of_space)
1272 finished = False;
1273
1274 if (!finished && !out_of_space)
1275 numentries++;
1276
1277 /*
1278 * As an optimisation if we know we aren't looking
1279 * for a wildcard name (ie. the name matches the wildcard exactly)
1280 * then we can finish on any (first) match.
1281 * This speeds up large directory searches. JRA.
1282 */
1283
1284 if(got_exact_match)
1285 finished = True;
1286
1287 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1288 }
1289
1290 /* Check if we can close the dirptr */
1291 if(close_after_request || (finished && close_if_end)) {
1292 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
1293 dptr_close(&dptr_num); /* This frees up the saved mask */
1294 }
1295
1296 /* Set up the return parameter block */
1297 SSVAL(params,0,numentries);
1298 SSVAL(params,2,finished);
1299 SSVAL(params,4,0); /* Never an EA error */
1300 SSVAL(params,6,last_name_off);
1301
1302 send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata));
1303
1304 if ((! *directory) && dptr_path(dptr_num))
1305 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1306
1307 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1308 smb_fn_name(CVAL(inbuf,smb_com)),
1309 mask, directory, dirtype, numentries ) );
1310
1311 return(-1);
1312 }
1313
1314 /****************************************************************************
1315 Reply to a TRANS2_QFSINFO (query filesystem info).
1316 ****************************************************************************/
1317
1318 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf,
1319 int length, int bufsize,
1320 char **pparams, int total_params, char **ppdata, int total_data)
1321 {
1322 int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1323 char *pdata = *ppdata;
1324 char *params = *pparams;
1325 uint16 info_level = SVAL(params,0);
1326 int data_len, len;
1327 SMB_STRUCT_STAT st;
1328 char *vname = volume_label(SNUM(conn));
1329 int snum = SNUM(conn);
1330 char *fstype = lp_fstype(SNUM(conn));
1331 int quota_flag = 0;
1332
1333 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
1334
1335 if(SMB_VFS_STAT(conn,".",&st)!=0) {
1336 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
1337 return ERROR_DOS(ERRSRV,ERRinvdevice);
1338 }
1339
1340 pdata = Realloc(*ppdata, max_data_bytes + 1024);
1341 if ( pdata == NULL )
1342 return ERROR_DOS(ERRDOS,ERRnomem);
1343
1344 *ppdata = pdata;
1345 memset((char *)pdata,'\0',max_data_bytes + 1024);
1346
1347 switch (info_level) {
1348 case SMB_INFO_ALLOCATION:
1349 {
1350 SMB_BIG_UINT dfree,dsize,bsize;
1351 data_len = 18;
1352 SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1353 SIVAL(pdata,l1_idFileSystem,st.st_dev);
1354 SIVAL(pdata,l1_cSectorUnit,bsize/512);
1355 SIVAL(pdata,l1_cUnit,dsize);
1356 SIVAL(pdata,l1_cUnitAvail,dfree);
1357 SSVAL(pdata,l1_cbSector,512);
1358 DEBUG(5,("call_trans2qfsinfo : bsize=%u, id=%x, cSectorUnit=%u, cUnit=%u, cUnitAvail=%u, cbSector=%d\n",
1359 (unsigned int)bsize, (unsigned int)st.st_dev, ((unsigned int)bsize)/512, (unsigned int)dsize,
1360 (unsigned int)dfree, 512));
1361 break;
1362 }
1363
1364 case SMB_INFO_VOLUME:
1365 /* Return volume name */
1366 /*
1367 * Add volume serial number - hash of a combination of
1368 * the called hostname and the service name.
1369 */
1370 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(local_machine)<<16) );
1371 len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_TERMINATE);
1372 SCVAL(pdata,l2_vol_cch,len);
1373 data_len = l2_vol_szVolLabel + len;
1374 DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
1375 (unsigned)st.st_ctime, len, vname));
1376 break;
1377
1378 case SMB_QUERY_FS_ATTRIBUTE_INFO:
1379 case SMB_FS_ATTRIBUTE_INFORMATION:
1380
1381
1382 #if defined(HAVE_SYS_QUOTAS)
1383 quota_flag = FILE_VOLUME_QUOTAS;
1384 #endif
1385
1386 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
1387 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
1388 quota_flag); /* FS ATTRIBUTES */
1389
1390 SIVAL(pdata,4,255); /* Max filename component length */
1391 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
1392 and will think we can't do long filenames */
1393 len = srvstr_push(outbuf, pdata+12, fstype, -1, 0);
1394 SIVAL(pdata,8,len);
1395 data_len = 12 + len;
1396 break;
1397
1398 case SMB_QUERY_FS_LABEL_INFO:
1399 case SMB_FS_LABEL_INFORMATION:
1400 len = srvstr_push(outbuf, pdata+4, vname, -1, STR_TERMINATE);
1401 data_len = 4 + len;
1402 SIVAL(pdata,0,len);
1403 break;
1404
1405 case SMB_QUERY_FS_VOLUME_INFO:
1406 case SMB_FS_VOLUME_INFORMATION:
1407
1408 /*
1409 * Add volume serial number - hash of a combination of
1410 * the called hostname and the service name.
1411 */
1412 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
1413 (str_checksum(local_machine)<<16));
1414
1415 len = srvstr_push(outbuf, pdata+18, vname, -1, STR_TERMINATE);
1416 SIVAL(pdata,12,len);
1417 data_len = 18+len;
1418 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
1419 (int)strlen(vname),vname, lp_servicename(snum)));
1420 break;
1421
1422 case SMB_QUERY_FS_SIZE_INFO:
1423 case SMB_FS_SIZE_INFORMATION:
1424 {
1425 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1426 data_len = 24;
1427 SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1428 block_size = lp_block_size(snum);
1429 if (bsize < block_size) {
1430 SMB_BIG_UINT factor = block_size/bsize;
1431 bsize = block_size;
1432 dsize /= factor;
1433 dfree /= factor;
1434 }
1435 if (bsize > block_size) {
1436 SMB_BIG_UINT factor = bsize/block_size;
1437 bsize = block_size;
1438 dsize *= factor;
1439 dfree *= factor;
1440 }
1441 bytes_per_sector = 512;
1442 sectors_per_unit = bsize/bytes_per_sector;
1443 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1444 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1445 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1446 SBIG_UINT(pdata,0,dsize);
1447 SBIG_UINT(pdata,8,dfree);
1448 SIVAL(pdata,16,sectors_per_unit);
1449 SIVAL(pdata,20,bytes_per_sector);
1450 break;
1451 }
1452
1453 case SMB_FS_FULL_SIZE_INFORMATION:
1454 {
1455 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1456 data_len = 32;
1457 SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1458 block_size = lp_block_size(snum);
1459 if (bsize < block_size) {
1460 SMB_BIG_UINT factor = block_size/bsize;
1461 bsize = block_size;
1462 dsize /= factor;
1463 dfree /= factor;
1464 }
1465 if (bsize > block_size) {
1466 SMB_BIG_UINT factor = bsize/block_size;
1467 bsize = block_size;
1468 dsize *= factor;
1469 dfree *= factor;
1470 }
1471 bytes_per_sector = 512;
1472 sectors_per_unit = bsize/bytes_per_sector;
1473 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1474 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1475 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1476 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
1477 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
1478 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
1479 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
1480 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
1481 break;
1482 }
1483
1484 case SMB_QUERY_FS_DEVICE_INFO:
1485 case SMB_FS_DEVICE_INFORMATION:
1486 data_len = 8;
1487 SIVAL(pdata,0,0); /* dev type */
1488 SIVAL(pdata,4,0); /* characteristics */
1489 break;
1490
1491 #ifdef HAVE_SYS_QUOTAS
1492 case SMB_FS_QUOTA_INFORMATION:
1493 /*
1494 * what we have to send --metze:
1495 *
1496 * Unknown1: 24 NULL bytes
1497 * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
1498 * Hard Quota Limit: 8 bytes seems like SMB_BIG_UINT or so
1499 * Quota Flags: 2 byte :
1500 * Unknown3: 6 NULL bytes
1501 *
1502 * 48 bytes total
1503 *
1504 * details for Quota Flags:
1505 *
1506 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
1507 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
1508 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
1509 * 0x0001 Enable Quotas: enable quota for this fs
1510 *
1511 */
1512 {
1513 /* we need to fake up a fsp here,
1514 * because its not send in this call
1515 */
1516 files_struct fsp;
1517 SMB_NTQUOTA_STRUCT quotas;
1518
1519 ZERO_STRUCT(fsp);
1520 ZERO_STRUCT(quotas);
1521
1522 fsp.conn = conn;
1523 fsp.fnum = -1;
1524 fsp.fd = -1;
1525
1526 /* access check */
1527 if (conn->admin_user != True) {
1528 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
1529 lp_servicename(SNUM(conn)),conn->user));
1530 return ERROR_DOS(ERRDOS,ERRnoaccess);
1531 }
1532
1533 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
1534 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
1535 return ERROR_DOS(ERRSRV,ERRerror);
1536 }
1537
1538 data_len = 48;
1539
1540 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
1541
1542 /* Unknown1 24 NULL bytes*/
1543 SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
1544 SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
1545 SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
1546
1547 /* Default Soft Quota 8 bytes */
1548 SBIG_UINT(pdata,24,quotas.softlim);
1549
1550 /* Default Hard Quota 8 bytes */
1551 SBIG_UINT(pdata,32,quotas.hardlim);
1552
1553 /* Quota flag 2 bytes */
1554 SSVAL(pdata,40,quotas.qflags);
1555
1556 /* Unknown3 6 NULL bytes */
1557 SSVAL(pdata,42,0);
1558 SIVAL(pdata,44,0);
1559
1560 break;
1561 }
1562 #endif /* HAVE_SYS_QUOTAS */
1563 case SMB_FS_OBJECTID_INFORMATION:
1564 data_len = 64;
1565 break;
1566
1567 /*
1568 * Query the version and capabilities of the CIFS UNIX extensions
1569 * in use.
1570 */
1571
1572 case SMB_QUERY_CIFS_UNIX_INFO:
1573 if (!lp_unix_extensions())
1574 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1575 data_len = 12;
1576 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
1577 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
1578 SBIG_UINT(pdata,4,((SMB_BIG_UINT)0)); /* No capabilities for now... */
1579 break;
1580
1581 case SMB_MAC_QUERY_FS_INFO:
1582 /*
1583 * Thursby MAC extension... ONLY on NTFS filesystems
1584 * once we do streams then we don't need this
1585 */
1586 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
1587 data_len = 88;
1588 SIVAL(pdata,84,0x100); /* Don't support mac... */
1589 break;
1590 }
1591 /* drop through */
1592 default:
1593 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1594 }
1595
1596
1597 send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len);
1598
1599 DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
1600
1601 return -1;
1602 }
1603
1604 #ifdef HAVE_SYS_QUOTAS
1605 /****************************************************************************
1606 Reply to a TRANS2_SETFSINFO (set filesystem info).
1607 ****************************************************************************/
1608
1609 static int call_trans2setfsinfo(connection_struct *conn,
1610 char *inbuf, char *outbuf, int length, int bufsize,
1611 char **pparams, int total_params, char **ppdata, int total_data)
1612 {
1613 char *pdata = *ppdata;
1614 char *params = *pparams;
1615 files_struct *fsp = NULL;
1616 uint16 info_level;
1617 int outsize;
1618 SMB_NTQUOTA_STRUCT quotas;
1619
1620 ZERO_STRUCT(quotas);
1621
1622 DEBUG(10,("call_trans2setfsinfo: SET_FS_QUOTA: for service [%s]\n",lp_servicename(SNUM(conn))));
1623
1624 /* access check */
1625 if ((conn->admin_user != True)||!CAN_WRITE(conn)) {
1626 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
1627 lp_servicename(SNUM(conn)),conn->user));
1628 return ERROR_DOS(ERRSRV,ERRaccess);
1629 }
1630
1631 /* */
1632 if (total_params < 4) {
1633 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
1634 total_params));
1635 return ERROR_DOS(ERRDOS,ERRinvalidparam);
1636 }
1637
1638 fsp = file_fsp(params,0);
1639
1640 if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
1641 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
1642 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
1643 }
1644
1645 info_level = SVAL(params,2);
1646
1647 switch(info_level) {
1648 case SMB_FS_QUOTA_INFORMATION:
1649 /* note: normaly there're 48 bytes,
1650 * but we didn't use the last 6 bytes for now
1651 * --metze
1652 */
1653 if (total_data < 42) {
1654 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
1655 total_data));
1656 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1657 }
1658
1659 /* unknown_1 24 NULL bytes in pdata*/
1660
1661 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
1662 quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
1663 #ifdef LARGE_SMB_OFF_T
1664 quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
1665 #else /* LARGE_SMB_OFF_T */
1666 if ((IVAL(pdata,28) != 0)&&
1667 ((quotas.softlim != 0xFFFFFFFF)||
1668 (IVAL(pdata,28)!=0xFFFFFFFF))) {
1669 /* more than 32 bits? */
1670 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1671 }
1672 #endif /* LARGE_SMB_OFF_T */
1673
1674 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
1675 quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
1676 #ifdef LARGE_SMB_OFF_T
1677 quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
1678 #else /* LARGE_SMB_OFF_T */
1679 if ((IVAL(pdata,36) != 0)&&
1680 ((quotas.hardlim != 0xFFFFFFFF)||
1681 (IVAL(pdata,36)!=0xFFFFFFFF))) {
1682 /* more than 32 bits? */
1683 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1684 }
1685 #endif /* LARGE_SMB_OFF_T */
1686
1687 /* quota_flags 2 bytes **/
1688 quotas.qflags = SVAL(pdata,40);
1689
1690 /* unknown_2 6 NULL bytes follow*/
1691
1692 /* now set the quotas */
1693 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
1694 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
1695 return ERROR_DOS(ERRSRV,ERRerror);
1696 }
1697
1698 break;
1699 default:
1700 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
1701 info_level));
1702 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1703 break;
1704 }
1705
1706 /*
1707 * sending this reply works fine,
1708 * but I'm not sure it's the same
1709 * like windows do...
1710 * --metze
1711 */
1712 outsize = set_message(outbuf,10,0,True);
1713
1714 return outsize;
1715 }
1716 #endif /* HAVE_SYS_QUOTAS */
1717
1718 /****************************************************************************
1719 * Utility function to set bad path error.
1720 ****************************************************************************/
1721
1722 NTSTATUS set_bad_path_error(int err, BOOL bad_path)
1723 {
1724 if((err == ENOENT) && bad_path) {
1725 unix_ERR_class = ERRDOS;
1726 unix_ERR_code = ERRbadpath;
1727 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1728 }
1729 return NT_STATUS_OK;
1730 }
1731
1732 /****************************************************************************
1733 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
1734 file name or file id).
1735 ****************************************************************************/
1736
1737 static int call_trans2qfilepathinfo(connection_struct *conn,
1738 char *inbuf, char *outbuf, int length,
1739 int bufsize,
1740 char **pparams, int total_params, char **ppdata, int total_data)
1741 {
1742 int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1743 char *params = *pparams;
1744 char *pdata = *ppdata;
1745 uint16 tran_call = SVAL(inbuf, smb_setup0);
1746 uint16 info_level;
1747 int mode=0;
1748 SMB_OFF_T file_size=0;
1749 SMB_BIG_UINT allocation_size=0;
1750 unsigned int data_size;
1751 SMB_STRUCT_STAT sbuf;
1752 pstring fname, dos_fname;
1753 char *fullpathname;
1754 char *base_name;
1755 char *p;
1756 SMB_OFF_T pos = 0;
1757 BOOL bad_path = False;
1758 BOOL delete_pending = False;
1759 int len;
1760 time_t c_time;
1761 files_struct *fsp = NULL;
1762
1763 if (!params)
1764 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1765
1766 if (tran_call == TRANSACT2_QFILEINFO) {
1767 if (total_params < 4)
1768 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1769
1770 fsp = file_fsp(params,0);
1771 info_level = SVAL(params,2);
1772
1773 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
1774
1775 if(fsp && (fsp->fake_file_handle)) {
1776 /*
1777 * This is actually for the QUOTA_FAKE_FILE --metze
1778 */
1779
1780 pstrcpy(fname, fsp->fsp_name);
1781 unix_convert(fname,conn,0,&bad_path,&sbuf);
1782 if (!check_name(fname,conn)) {
1783 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed for fake_file(%s)\n",fname,strerror(errno)));
1784 set_bad_path_error(errno, bad_path);
1785 return(UNIXERROR(ERRDOS,ERRbadpath));
1786 }
1787
1788 } else if(fsp && (fsp->is_directory || fsp->fd == -1)) {
1789 /*
1790 * This is actually a QFILEINFO on a directory
1791 * handle (returned from an NT SMB). NT5.0 seems
1792 * to do this call. JRA.
1793 */
1794 pstrcpy(fname, fsp->fsp_name);
1795 unix_convert(fname,conn,0,&bad_path,&sbuf);
1796 if (!check_name(fname,conn)) {
1797 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
1798 set_bad_path_error(errno, bad_path);
1799 return(UNIXERROR(ERRDOS,ERRbadpath));
1800 }
1801
1802 if (INFO_LEVEL_IS_UNIX(info_level)) {
1803 /* Always do lstat for UNIX calls. */
1804 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
1805 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
1806 set_bad_path_error(errno, bad_path);
1807 return(UNIXERROR(ERRDOS,ERRbadpath));
1808 }
1809 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
1810 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
1811 set_bad_path_error(errno, bad_path);
1812 return(UNIXERROR(ERRDOS,ERRbadpath));
1813 }
1814
1815 delete_pending = fsp->directory_delete_on_close;
1816 } else {
1817 /*
1818 * Original code - this is an open file.
1819 */
1820 CHECK_FSP(fsp,conn);
1821
1822 pstrcpy(fname, fsp->fsp_name);
1823 if (SMB_VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
1824 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
1825 return(UNIXERROR(ERRDOS,ERRbadfid));
1826 }
1827 if((pos = SMB_VFS_LSEEK(fsp,fsp->fd,0,SEEK_CUR)) == -1)
1828 return(UNIXERROR(ERRDOS,ERRnoaccess));
1829
1830 delete_pending = fsp->delete_on_close;
1831 }
1832 } else {
1833 /* qpathinfo */
1834 if (total_params < 6)
1835 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1836
1837 info_level = SVAL(params,0);
1838
1839 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
1840
1841 srvstr_pull(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE);
1842
1843 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1844
1845 unix_convert(fname,conn,0,&bad_path,&sbuf);
1846 if (!check_name(fname,conn)) {
1847 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
1848 set_bad_path_error(errno, bad_path);
1849 return(UNIXERROR(ERRDOS,ERRbadpath));
1850 }
1851
1852 if (INFO_LEVEL_IS_UNIX(info_level)) {
1853 /* Always do lstat for UNIX calls. */
1854 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
1855 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
1856 set_bad_path_error(errno, bad_path);
1857 return(UNIXERROR(ERRDOS,ERRbadpath));
1858 }
1859 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
1860 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
1861 set_bad_path_error(errno, bad_path);
1862 return(UNIXERROR(ERRDOS,ERRbadpath));
1863 }
1864 }
1865
1866 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
1867 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1868
1869 DEBUG(3,("call_trans2qfilepathinfo %s level=%d call=%d total_data=%d\n",
1870 fname,info_level,tran_call,total_data));
1871
1872 p = strrchr_m(fname,'/');
1873 if (!p)
1874 base_name = fname;
1875 else
1876 base_name = p+1;
1877
1878 mode = dos_mode(conn,fname,&sbuf);
1879 fullpathname = fname;
1880 file_size = get_file_size(sbuf);
1881 allocation_size = get_allocation_size(fsp,&sbuf);
1882 if (mode & aDIR)
1883 file_size = 0;
1884
1885 params = Realloc(*pparams,2);
1886 if (params == NULL)
1887 return ERROR_DOS(ERRDOS,ERRnomem);
1888 *pparams = params;
1889 memset((char *)params,'\0',2);
1890 data_size = max_data_bytes + 1024;
1891 pdata = Realloc(*ppdata, data_size);
1892 if ( pdata == NULL )
1893 return ERROR_DOS(ERRDOS,ERRnomem);
1894 *ppdata = pdata;
1895
1896 if (total_data > 0 && IVAL(pdata,0) == total_data) {
1897 /* uggh, EAs for OS2 */
1898 DEBUG(4,("Rejecting EA request with total_data=%d\n",total_data));
1899 return ERROR_DOS(ERRDOS,ERReasnotsupported);
1900 }
1901
1902 memset((char *)pdata,'\0',data_size);
1903
1904 c_time = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1905
1906 if (lp_dos_filetime_resolution(SNUM(conn))) {
1907 c_time &= ~1;
1908 sbuf.st_atime &= ~1;
1909 sbuf.st_mtime &= ~1;
1910 sbuf.st_mtime &= ~1;
1911 }
1912
1913 /* NT expects the name to be in an exact form of the *full*
1914 filename. See the trans2 torture test */
1915 if (strequal(base_name,".")) {
1916 pstrcpy(dos_fname, "\\");
1917 } else {
1918 snprintf(dos_fname, sizeof(dos_fname), "\\%s", fname);
1919 string_replace(dos_fname, '/', '\\');
1920 }
1921
1922 switch (info_level) {
1923 case SMB_INFO_STANDARD:
1924 case SMB_INFO_QUERY_EA_SIZE:
1925 data_size = (info_level==1?22:26);
1926 put_dos_date2(pdata,l1_fdateCreation,c_time);
1927 put_dos_date2(pdata,l1_fdateLastAccess,sbuf.st_atime);
1928 put_dos_date2(pdata,l1_fdateLastWrite,sbuf.st_mtime); /* write time */
1929 SIVAL(pdata,l1_cbFile,(uint32)file_size);
1930 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
1931 SSVAL(pdata,l1_attrFile,mode);
1932 SIVAL(pdata,l1_attrFile+2,4); /* this is what OS2 does */
1933 break;
1934
1935 case SMB_INFO_IS_NAME_VALID:
1936 if (tran_call == TRANSACT2_QFILEINFO) {
1937 /* os/2 needs this ? really ?*/
1938 return ERROR_DOS(ERRDOS,ERRbadfunc);
1939 }
1940 data_size = 0;
1941 break;
1942
1943 case SMB_INFO_QUERY_EAS_FROM_LIST:
1944 data_size = 24;
1945 put_dos_date2(pdata,0,c_time);
1946 put_dos_date2(pdata,4,sbuf.st_atime);
1947 put_dos_date2(pdata,8,sbuf.st_mtime);
1948 SIVAL(pdata,12,(uint32)file_size);
1949 SIVAL(pdata,16,(uint32)allocation_size);
1950 SIVAL(pdata,20,mode);
1951 break;
1952
1953 case SMB_INFO_QUERY_ALL_EAS:
1954 data_size = 4;
1955 SIVAL(pdata,0,data_size);
1956 break;
1957
1958 case SMB_FILE_BASIC_INFORMATION:
1959 case SMB_QUERY_FILE_BASIC_INFO:
1960
1961 if (info_level == SMB_QUERY_FILE_BASIC_INFO)
1962 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
1963 else {
1964 data_size = 40;
1965 SIVAL(pdata,36,0);
1966 }
1967 put_long_date(pdata,c_time);
1968 put_long_date(pdata+8,sbuf.st_atime);
1969 put_long_date(pdata+16,sbuf.st_mtime); /* write time */
1970 put_long_date(pdata+24,sbuf.st_mtime); /* change time */
1971 SIVAL(pdata,32,mode);
1972
1973 DEBUG(5,("SMB_QFBI - "));
1974 {
1975 time_t create_time = c_time;
1976 DEBUG(5,("create: %s ", ctime(&create_time)));
1977 }
1978 DEBUG(5,("access: %s ", ctime(&sbuf.st_atime)));
1979 DEBUG(5,("write: %s ", ctime(&sbuf.st_mtime)));
1980 DEBUG(5,("change: %s ", ctime(&sbuf.st_mtime)));
1981 DEBUG(5,("mode: %x\n", mode));
1982
1983 break;
1984
1985 case SMB_FILE_STANDARD_INFORMATION:
1986 case SMB_QUERY_FILE_STANDARD_INFO:
1987
1988 data_size = 24;
1989 SOFF_T(pdata,0,allocation_size);
1990 SOFF_T(pdata,8,file_size);
1991 SIVAL(pdata,16,sbuf.st_nlink);
1992 SCVAL(pdata,20,0);
1993 SCVAL(pdata,21,(mode&aDIR)?1:0);
1994 break;
1995
1996 case SMB_FILE_EA_INFORMATION:
1997 case SMB_QUERY_FILE_EA_INFO:
1998 data_size = 4;
1999 break;
2000
2001 /* Get the 8.3 name - used if NT SMB was negotiated. */
2002 case SMB_QUERY_FILE_ALT_NAME_INFO:
2003 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
2004 {
2005 pstring short_name;
2006
2007 pstrcpy(short_name,base_name);
2008 /* Mangle if not already 8.3 */
2009 if(!mangle_is_8_3(short_name, True)) {
2010 mangle_map(short_name,True,True,SNUM(conn));
2011 }
2012 len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
2013 data_size = 4 + len;
2014 SIVAL(pdata,0,len);
2015 break;
2016 }
2017
2018 case SMB_QUERY_FILE_NAME_INFO:
2019 /*
2020 this must be *exactly* right for ACLs on mapped drives to work
2021 */
2022 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
2023 data_size = 4 + len;
2024 SIVAL(pdata,0,len);
2025 break;
2026
2027 case SMB_FILE_ALLOCATION_INFORMATION:
2028 case SMB_QUERY_FILE_ALLOCATION_INFO:
2029 data_size = 8;
2030 SOFF_T(pdata,0,allocation_size);
2031 break;
2032
2033 case SMB_FILE_END_OF_FILE_INFORMATION:
2034 case SMB_QUERY_FILE_END_OF_FILEINFO:
2035 data_size = 8;
2036 SOFF_T(pdata,0,file_size);
2037 break;
2038
2039 case SMB_QUERY_FILE_ALL_INFO:
2040 case SMB_FILE_ALL_INFORMATION:
2041 put_long_date(pdata,c_time);
2042 put_long_date(pdata+8,sbuf.st_atime);
2043 put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2044 put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2045 SIVAL(pdata,32,mode);
2046 pdata += 40;
2047 SOFF_T(pdata,0,allocation_size);
2048 SOFF_T(pdata,8,file_size);
2049 SIVAL(pdata,16,sbuf.st_nlink);
2050 SCVAL(pdata,20,delete_pending);
2051 SCVAL(pdata,21,(mode&aDIR)?1:0);
2052 pdata += 24;
2053 pdata += 4; /* EA info */
2054 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_TERMINATE);
2055 SIVAL(pdata,0,len);
2056 pdata += 4 + len;
2057 data_size = PTR_DIFF(pdata,(*ppdata));
2058 break;
2059
2060 case SMB_FILE_INTERNAL_INFORMATION:
2061 /* This should be an index number - looks like
2062 dev/ino to me :-)
2063
2064 I think this causes us to fail the IFSKIT
2065 BasicFileInformationTest. -tpot */
2066
2067 SIVAL(pdata,0,sbuf.st_dev);
2068 SIVAL(pdata,4,sbuf.st_ino);
2069 data_size = 8;
2070 break;
2071
2072 case SMB_FILE_ACCESS_INFORMATION:
2073 SIVAL(pdata,0,0x12019F); /* ??? */
2074 data_size = 4;
2075 break;
2076
2077 case SMB_FILE_NAME_INFORMATION:
2078 /* Pathname with leading '\'. */
2079 {
2080 size_t byte_len;
2081 byte_len = dos_PutUniCode(pdata+4,dos_fname,max_data_bytes,False);
2082 SIVAL(pdata,0,byte_len);
2083 data_size = 4 + byte_len;
2084 break;
2085 }
2086
2087 case SMB_FILE_DISPOSITION_INFORMATION:
2088 data_size = 1;
2089 SCVAL(pdata,0,delete_pending);
2090 break;
2091
2092 case SMB_FILE_POSITION_INFORMATION:
2093 data_size = 8;
2094 SOFF_T(pdata,0,pos);
2095 break;
2096
2097 case SMB_FILE_MODE_INFORMATION:
2098 SIVAL(pdata,0,mode);
2099 data_size = 4;
2100 break;
2101
2102 case SMB_FILE_ALIGNMENT_INFORMATION:
2103 SIVAL(pdata,0,0); /* No alignment needed. */
2104 data_size = 4;
2105 break;
2106
2107 #if 0
2108 /*
2109 * NT4 server just returns "invalid query" to this - if we try to answer
2110 * it then NTws gets a BSOD! (tridge).
2111 * W2K seems to want this. JRA.
2112 */
2113 case SMB_QUERY_FILE_STREAM_INFO:
2114 #endif
2115 case SMB_FILE_STREAM_INFORMATION:
2116 if (mode & aDIR) {
2117 data_size = 0;
2118 } else {
2119 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", 0xE, False);
2120 SIVAL(pdata,0,0); /* ??? */
2121 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
2122 SOFF_T(pdata,8,file_size);
2123 SIVAL(pdata,16,allocation_size);
2124 SIVAL(pdata,20,0); /* ??? */
2125 data_size = 24 + byte_len;
2126 }
2127 break;
2128
2129 case SMB_QUERY_COMPRESSION_INFO:
2130 case SMB_FILE_COMPRESSION_INFORMATION:
2131 SOFF_T(pdata,0,file_size);
2132 SIVAL(pdata,8,0); /* ??? */
2133 SIVAL(pdata,12,0); /* ??? */
2134 data_size = 16;
2135 break;
2136
2137 case SMB_FILE_NETWORK_OPEN_INFORMATION:
2138 put_long_date(pdata,c_time);
2139 put_long_date(pdata+8,sbuf.st_atime);
2140 put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2141 put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2142 SIVAL(pdata,32,allocation_size);
2143 SOFF_T(pdata,40,file_size);
2144 SIVAL(pdata,48,mode);
2145 SIVAL(pdata,52,0); /* ??? */
2146 data_size = 56;
2147 break;
2148
2149 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
2150 SIVAL(pdata,0,mode);
2151 SIVAL(pdata,4,0);
2152 data_size = 8;
2153 break;
2154
2155 /*
2156 * CIFS UNIX Extensions.
2157 */
2158
2159 case SMB_QUERY_FILE_UNIX_BASIC:
2160
2161 DEBUG(4,("call_trans2qfilepathinfo: st_mode=%o\n",(int)sbuf.st_mode));
2162
2163 SOFF_T(pdata,0,get_file_size(sbuf)); /* File size 64 Bit */
2164 pdata += 8;
2165
2166 SOFF_T(pdata,0,get_allocation_size(fsp,&sbuf)); /* Number of bytes used on disk - 64 Bit */
2167 pdata += 8;
2168
2169 put_long_date(pdata,sbuf.st_ctime); /* Creation Time 64 Bit */
2170 put_long_date(pdata+8,sbuf.st_atime); /* Last access time 64 Bit */
2171 put_long_date(pdata+16,sbuf.st_mtime); /* Last modification time 64 Bit */
2172 pdata += 24;
2173
2174 SIVAL(pdata,0,sbuf.st_uid); /* user id for the owner */
2175 SIVAL(pdata,4,0);
2176 pdata += 8;
2177
2178 SIVAL(pdata,0,sbuf.st_gid); /* group id of owner */
2179 SIVAL(pdata,4,0);
2180 pdata += 8;
2181
2182 SIVAL(pdata,0,unix_filetype(sbuf.st_mode));
2183 pdata += 4;
2184
2185 SIVAL(pdata,0,unix_dev_major(sbuf.st_rdev)); /* Major device number if type is device */
2186 SIVAL(pdata,4,0);
2187 pdata += 8;
2188
2189 SIVAL(pdata,0,unix_dev_minor(sbuf.st_rdev)); /* Minor device number if type is device */
2190 SIVAL(pdata,4,0);
2191 pdata += 8;
2192
2193 SINO_T(pdata,0,(SMB_INO_T)sbuf.st_ino); /* inode number */
2194 pdata += 8;
2195
2196 SIVAL(pdata,0, unix_perms_to_wire(sbuf.st_mode)); /* Standard UNIX file permissions */
2197 SIVAL(pdata,4,0);
2198 pdata += 8;
2199
2200 SIVAL(pdata,0,sbuf.st_nlink); /* number of hard links */
2201 SIVAL(pdata,4,0);
2202 pdata += 8+1;
2203 data_size = PTR_DIFF(pdata,(*ppdata));
2204
2205 {
2206 int i;
2207 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC"));
2208
2209 for (i=0; i<100; i++)
2210 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
2211 DEBUG(4,("\n"));
2212 }
2213
2214 break;
2215
2216 case SMB_QUERY_FILE_UNIX_LINK:
2217 {
2218 pstring buffer;
2219
2220 #ifdef S_ISLNK
2221 if(!S_ISLNK(sbuf.st_mode))
2222 return(UNIXERROR(ERRSRV,ERRbadlink));
2223 #else
2224 return(UNIXERROR(ERRDOS,ERRbadlink));
2225 #endif
2226 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1); /* read link */
2227 if (len == -1)
2228 return(UNIXERROR(ERRDOS,ERRnoaccess));
2229 buffer[len] = 0;
2230 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
2231 pdata += len;
2232 data_size = PTR_DIFF(pdata,(*ppdata));
2233
2234 break;
2235 }
2236
2237 default:
2238 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2239 }
2240
2241 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, data_size);
2242
2243 return(-1);
2244 }
2245
2246 /****************************************************************************
2247 Deal with the internal needs of setting the delete on close flag. Note that
2248 as the tdb locking is recursive, it is safe to call this from within
2249 open_file_shared. JRA.
2250 ****************************************************************************/
2251
2252 NTSTATUS set_delete_on_close_internal(files_struct *fsp, BOOL delete_on_close)
2253 {
2254 /*
2255 * Only allow delete on close for writable shares.
2256 */
2257
2258 if (delete_on_close && !CAN_WRITE(fsp->conn)) {
2259 DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but write access denied on share.\n",
2260 fsp->fsp_name ));
2261 return NT_STATUS_ACCESS_DENIED;
2262 }
2263 /*
2264 * Only allow delete on close for files/directories opened with delete intent.
2265 */
2266
2267 if (delete_on_close && !(fsp->desired_access & DELETE_ACCESS)) {
2268 DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but delete access denied.\n",
2269 fsp->fsp_name ));
2270 return NT_STATUS_ACCESS_DENIED;
2271 }
2272
2273 if(fsp->is_directory) {
2274 fsp->directory_delete_on_close = delete_on_close;
2275 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, directory %s\n",
2276 delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
2277 } else {
2278 fsp->delete_on_close = delete_on_close;
2279 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, file %s\n",
2280 delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
2281 }
2282
2283 return NT_STATUS_OK;
2284 }
2285
2286 /****************************************************************************
2287 Sets the delete on close flag over all share modes on this file.
2288 Modify the share mode entry for all files open
2289 on this device and inode to tell other smbds we have
2290 changed the delete on close flag. This will be noticed
2291 in the close code, the last closer will delete the file
2292 if flag is set.
2293 ****************************************************************************/
2294
2295 NTSTATUS set_delete_on_close_over_all(files_struct *fsp, BOOL delete_on_close)
2296 {
2297 DEBUG(10,("set_delete_on_close_over_all: %s delete on close flag for fnum = %d, file %s\n",
2298 delete_on_close ? "Adding" : "Removing", fsp->fnum, fsp->fsp_name ));
2299
2300 if (fsp->is_directory || fsp->is_stat)
2301 return NT_STATUS_OK;
2302
2303 if (lock_share_entry_fsp(fsp) == False)
2304 return NT_STATUS_ACCESS_DENIED;
2305
2306 if (!modify_delete_flag(fsp->dev, fsp->inode, delete_on_close)) {
2307 DEBUG(0,("set_delete_on_close_internal: failed to change delete on close flag for file %s\n",
2308 fsp->fsp_name ));
2309 unlock_share_entry_fsp(fsp);
2310 return NT_STATUS_ACCESS_DENIED;
2311 }
2312
2313 unlock_share_entry_fsp(fsp);
2314 return NT_STATUS_OK;
2315 }
2316
2317 /****************************************************************************
2318 Returns true if this pathname is within the share, and thus safe.
2319 ****************************************************************************/
2320
2321 static int ensure_link_is_safe(connection_struct *conn, const char *link_dest_in, char *link_dest_out)
2322 {
2323 #ifdef PATH_MAX
2324 char resolved_name[PATH_MAX+1];
2325 #else
2326 pstring resolved_name;
2327 #endif
2328 fstring last_component;
2329 pstring link_dest;
2330 pstring link_test;
2331 char *p;
2332 BOOL bad_path = False;
2333 SMB_STRUCT_STAT sbuf;
2334
2335 pstrcpy(link_dest, link_dest_in);
2336 unix_convert(link_dest,conn,0,&bad_path,&sbuf);
2337
2338 /* Store the UNIX converted path. */
2339 pstrcpy(link_dest_out, link_dest);
2340
2341 p = strrchr(link_dest, '/');
2342 if (p) {
2343 fstrcpy(last_component, p+1);
2344 *p = '\0';
2345 } else {
2346 fstrcpy(last_component, link_dest);
2347 pstrcpy(link_dest, "./");
2348 }
2349
2350 if (SMB_VFS_REALPATH(conn,link_dest,resolved_name) == NULL)
2351 return -1;
2352
2353 pstrcpy(link_dest, resolved_name);
2354 pstrcat(link_dest, "/");
2355 pstrcat(link_dest, last_component);
2356
2357 if (*link_dest != '/') {
2358 /* Relative path. */
2359 pstrcpy(link_test, conn->connectpath);
2360 pstrcat(link_test, "/");
2361 pstrcat(link_test, link_dest);
2362 } else {
2363 pstrcpy(link_test, link_dest);
2364 }
2365
2366 /*
2367 * Check if the link is within the share.
2368 */
2369
2370 if (strncmp(conn->connectpath, link_test, strlen(conn->connectpath))) {
2371 errno = EACCES;
2372 return -1;
2373 }
2374 return 0;
2375 }
2376
2377 /****************************************************************************
2378 Reply to a TRANS2_SETFILEINFO (set file info by fileid).
2379 ****************************************************************************/
2380
2381 static int call_trans2setfilepathinfo(connection_struct *conn,
2382 char *inbuf, char *outbuf, int length, int bufsize,
2383 char **pparams, int total_params, char **ppdata, int total_data)
2384 {
2385 char *params = *pparams;
2386 char *pdata = *ppdata;
2387 uint16 tran_call = SVAL(inbuf, smb_setup0);
2388 uint16 info_level;
2389 int dosmode=0;
2390 SMB_OFF_T size=0;
2391 struct utimbuf tvs;
2392 SMB_STRUCT_STAT sbuf;
2393 pstring fname;
2394 int fd = -1;
2395 BOOL bad_path = False;
2396 files_struct *fsp = NULL;
2397 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
2398 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
2399 mode_t unixmode = 0;
2400
2401 if (!params)
2402 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2403
2404 if (tran_call == TRANSACT2_SETFILEINFO) {
2405 if (total_params < 4)
2406 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2407
2408 fsp = file_fsp(params,0);
2409 info_level = SVAL(params,2);
2410
2411 if(fsp && (fsp->is_directory || fsp->fd == -1)) {
2412 /*
2413 * This is actually a SETFILEINFO on a directory
2414 * handle (returned from an NT SMB). NT5.0 seems
2415 * to do this call. JRA.
2416 */
2417 pstrcpy(fname, fsp->fsp_name);
2418 unix_convert(fname,conn,0,&bad_path,&sbuf);
2419 if (!check_name(fname,conn) || (!VALID_STAT(sbuf))) {
2420 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
2421 set_bad_path_error(errno, bad_path);
2422 return(UNIXERROR(ERRDOS,ERRbadpath));
2423 }
2424 } else if (fsp && fsp->print_file) {
2425 /*
2426 * Doing a DELETE_ON_CLOSE should cancel a print job.
2427 */
2428 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
2429 fsp->share_mode = FILE_DELETE_ON_CLOSE;
2430
2431 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
2432
2433 SSVAL(params,0,0);
2434 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2435 return(-1);
2436 } else
2437 return (UNIXERROR(ERRDOS,ERRbadpath));
2438 } else {
2439 /*
2440 * Original code - this is an open file.
2441 */
2442 CHECK_FSP(fsp,conn);
2443
2444 pstrcpy(fname, fsp->fsp_name);
2445 fd = fsp->fd;
2446
2447 if (SMB_VFS_FSTAT(fsp,fd,&sbuf) != 0) {
2448 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
2449 return(UNIXERROR(ERRDOS,ERRbadfid));
2450 }
2451 }
2452 } else {
2453 /* set path info */
2454 if (total_params < 6)
2455 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2456
2457 info_level = SVAL(params,0);
2458 srvstr_pull(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE);
2459 unix_convert(fname,conn,0,&bad_path,&sbuf);
2460 if(!check_name(fname, conn)) {
2461 set_bad_path_error(errno, bad_path);
2462 return(UNIXERROR(ERRDOS,ERRbadpath));
2463 }
2464
2465 /*
2466 * For CIFS UNIX extensions the target name may not exist.
2467 */
2468
2469 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
2470 DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
2471 set_bad_path_error(errno, bad_path);
2472 return(UNIXERROR(ERRDOS,ERRbadpath));
2473 }
2474 }
2475
2476 if (!CAN_WRITE(conn))
2477 return ERROR_DOS(ERRSRV,ERRaccess);
2478
2479 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
2480 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2481
2482 if (VALID_STAT(sbuf))
2483 unixmode = sbuf.st_mode;
2484
2485 DEBUG(3,("call_trans2setfilepathinfo(%d) %s info_level=%d totdata=%d\n",
2486 tran_call,fname,info_level,total_data));
2487
2488 /* Realloc the parameter and data sizes */
2489 params = Realloc(*pparams,2);
2490 if(params == NULL)
2491 return ERROR_DOS(ERRDOS,ERRnomem);
2492 *pparams = params;
2493
2494 SSVAL(params,0,0);
2495
2496 if (fsp) {
2497 /* the pending modtime overrides the current modtime */
2498 sbuf.st_mtime = fsp->pending_modtime;
2499 }
2500
2501 size = get_file_size(sbuf);
2502 tvs.modtime = sbuf.st_mtime;
2503 tvs.actime = sbuf.st_atime;
2504 dosmode = dos_mode(conn,fname,&sbuf);
2505 unixmode = sbuf.st_mode;
2506
2507 set_owner = VALID_STAT(sbuf) ? sbuf.st_uid : (uid_t)SMB_UID_NO_CHANGE;
2508 set_grp = VALID_STAT(sbuf) ? sbuf.st_gid : (gid_t)SMB_GID_NO_CHANGE;
2509
2510 switch (info_level) {
2511 case SMB_INFO_STANDARD:
2512 {
2513 if (total_data < l1_cbFile+4)
2514 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2515
2516 /* access time */
2517 tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
2518
2519 /* write time */
2520 tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
2521
2522 dosmode = SVAL(pdata,l1_attrFile);
2523 size = IVAL(pdata,l1_cbFile);
2524
2525 break;
2526 }
2527
2528 case SMB_INFO_SET_EA:
2529 return(ERROR_DOS(ERRDOS,ERReasnotsupported));
2530
2531 /* XXXX um, i don't think this is right.
2532 it's also not in the cifs6.txt spec.
2533 */
2534 case SMB_INFO_QUERY_EAS_FROM_LIST:
2535 if (total_data < 28)
2536 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2537
2538 tvs.actime = make_unix_date2(pdata+8);
2539 tvs.modtime = make_unix_date2(pdata+12);
2540 size = IVAL(pdata,16);
2541 dosmode = IVAL(pdata,24);
2542 break;
2543
2544 /* XXXX nor this. not in cifs6.txt, either. */
2545 case SMB_INFO_QUERY_ALL_EAS:
2546 if (total_data < 28)
2547 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2548
2549 tvs.actime = make_unix_date2(pdata+8);
2550 tvs.modtime = make_unix_date2(pdata+12);
2551 size = IVAL(pdata,16);
2552 dosmode = IVAL(pdata,24);
2553 break;
2554
2555 case SMB_SET_FILE_BASIC_INFO:
2556 case SMB_FILE_BASIC_INFORMATION:
2557 {
2558 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
2559 time_t write_time;
2560 time_t changed_time;
2561
2562 if (total_data < 36)
2563 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2564
2565 /* Ignore create time at offset pdata. */
2566
2567 /* access time */
2568 tvs.actime = interpret_long_date(pdata+8);
2569
2570 write_time = interpret_long_date(pdata+16);
2571 changed_time = interpret_long_date(pdata+24);
2572
2573 tvs.modtime = MIN(write_time, changed_time);
2574
2575 if (write_time > tvs.modtime && write_time != 0xffffffff) {
2576 tvs.modtime = write_time;
2577 }
2578 /* Prefer a defined time to an undefined one. */
2579 if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
2580 tvs.modtime = (write_time == (time_t)0 || write_time == (time_t)-1
2581 ? changed_time : write_time);
2582
2583 /* attributes */
2584 dosmode = IVAL(pdata,32);
2585 break;
2586 }
2587
2588 case SMB_FILE_ALLOCATION_INFORMATION:
2589 case SMB_SET_FILE_ALLOCATION_INFO:
2590 {
2591 int ret = -1;
2592 SMB_BIG_UINT allocation_size;
2593
2594 if (total_data < 8)
2595 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2596
2597 allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
2598 #ifdef LARGE_SMB_OFF_T
2599 allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
2600 #else /* LARGE_SMB_OFF_T */
2601 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2602 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2603 #endif /* LARGE_SMB_OFF_T */
2604 DEBUG(10,("call_trans2setfilepathinfo: Set file allocation info for file %s to %.0f\n",
2605 fname, (double)allocation_size ));
2606
2607 if (allocation_size)
2608 allocation_size = SMB_ROUNDUP(allocation_size,SMB_ROUNDUP_ALLOCATION_SIZE);
2609
2610 if(allocation_size != get_file_size(sbuf)) {
2611 SMB_STRUCT_STAT new_sbuf;
2612
2613 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new allocation size to %.0f\n",
2614 fname, (double)allocation_size ));
2615
2616 if (fd == -1) {
2617 files_struct *new_fsp = NULL;
2618 int access_mode = 0;
2619 int action = 0;
2620
2621 if(global_oplock_break) {
2622 /* Queue this file modify as we are the process of an oplock break. */
2623
2624 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
2625 DEBUGADD(2,( "in oplock break state.\n"));
2626
2627 push_oplock_pending_smb_message(inbuf, length);
2628 return -1;
2629 }
2630
2631 new_fsp = open_file_shared1(conn, fname, &sbuf,FILE_WRITE_DATA,
2632 SET_OPEN_MODE(DOS_OPEN_RDWR),
2633 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
2634 0, 0, &access_mode, &action);
2635
2636 if (new_fsp == NULL)
2637 return(UNIXERROR(ERRDOS,ERRbadpath));
2638 ret = vfs_allocate_file_space(new_fsp, allocation_size);
2639 if (SMB_VFS_FSTAT(new_fsp,new_fsp->fd,&new_sbuf) != 0) {
2640 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
2641 new_fsp->fnum, strerror(errno)));
2642 ret = -1;
2643 }
2644 close_file(new_fsp,True);
2645 } else {
2646 ret = vfs_allocate_file_space(fsp, allocation_size);
2647 if (SMB_VFS_FSTAT(fsp,fd,&new_sbuf) != 0) {
2648 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
2649 fsp->fnum, strerror(errno)));
2650 ret = -1;
2651 }
2652 }
2653 if (ret == -1)
2654 return ERROR_NT(NT_STATUS_DISK_FULL);
2655
2656 /* Allocate can truncate size... */
2657 size = get_file_size(new_sbuf);
2658 }
2659
2660 break;
2661 }
2662
2663 case SMB_FILE_END_OF_FILE_INFORMATION:
2664 case SMB_SET_FILE_END_OF_FILE_INFO:
2665 {
2666 if (total_data < 8)
2667 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2668
2669 size = IVAL(pdata,0);
2670 #ifdef LARGE_SMB_OFF_T
2671 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
2672 #else /* LARGE_SMB_OFF_T */
2673 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2674 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2675 #endif /* LARGE_SMB_OFF_T */
2676 DEBUG(10,("call_trans2setfilepathinfo: Set end of file info for file %s to %.0f\n", fname, (double)size ));
2677 break;
2678 }
2679
2680 case SMB_FILE_DISPOSITION_INFORMATION:
2681 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
2682 {
2683 BOOL delete_on_close = (CVAL(pdata,0) ? True : False);
2684 NTSTATUS status;
2685
2686 if (total_data < 1)
2687 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2688
2689 if (tran_call != TRANSACT2_SETFILEINFO)
2690 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2691
2692 if (fsp == NULL)
2693 return(UNIXERROR(ERRDOS,ERRbadfid));
2694
2695 status = set_delete_on_close_internal(fsp, delete_on_close);
2696
2697 if (NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_OK))
2698 return ERROR_NT(status);
2699
2700 /* The set is across all open files on this dev/inode pair. */
2701 status =set_delete_on_close_over_all(fsp, delete_on_close);
2702 if (NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_OK))
2703 return ERROR_NT(status);
2704
2705 break;
2706 }
2707
2708 /*
2709 * CIFS UNIX extensions.
2710 */
2711
2712 case SMB_SET_FILE_UNIX_BASIC:
2713 {
2714 uint32 raw_unixmode;
2715
2716 if (total_data < 100)
2717 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2718
2719 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
2720 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
2721 size=IVAL(pdata,0); /* first 8 Bytes are size */
2722 #ifdef LARGE_SMB_OFF_T
2723 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
2724 #else /* LARGE_SMB_OFF_T */
2725 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2726 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2727 #endif /* LARGE_SMB_OFF_T */
2728 }
2729 pdata+=24; /* ctime & st_blocks are not changed */
2730 tvs.actime = interpret_long_unix_date(pdata); /* access_time */
2731 tvs.modtime = interpret_long_unix_date(pdata+8); /* modification_time */
2732 pdata+=16;
2733 set_owner = (uid_t)IVAL(pdata,0);
2734 pdata += 8;
2735 set_grp = (gid_t)IVAL(pdata,0);
2736 pdata += 8;
2737 raw_unixmode = IVAL(pdata,28);
2738 unixmode = unix_perms_from_wire(conn, &sbuf, raw_unixmode);
2739 dosmode = 0; /* Ensure dos mode change doesn't override this. */
2740
2741 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC: name = %s \
2742 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
2743 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
2744
2745 if (!VALID_STAT(sbuf)) {
2746
2747 /*
2748 * The only valid use of this is to create character and block
2749 * devices, and named pipes. This is deprecated (IMHO) and
2750 * a new info level should be used for mknod. JRA.
2751 */
2752
2753 #if !defined(HAVE_MAKEDEV_FN)
2754 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2755 #else /* HAVE_MAKEDEV_FN */
2756 uint32 file_type = IVAL(pdata,0);
2757 uint32 dev_major = IVAL(pdata,4);
2758 uint32 dev_minor = IVAL(pdata,12);
2759
2760 uid_t myuid = geteuid();
2761 gid_t mygid = getegid();
2762 SMB_DEV_T dev;
2763
2764 if (tran_call == TRANSACT2_SETFILEINFO)
2765 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2766
2767 if (raw_unixmode == SMB_MODE_NO_CHANGE)
2768 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2769
2770 dev = makedev(dev_major, dev_minor);
2771
2772 /* We can only create as the owner/group we are. */
2773
2774 if ((set_owner != myuid) && (set_owner != (uid_t)SMB_UID_NO_CHANGE))
2775 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2776 if ((set_grp != mygid) && (set_grp != (gid_t)SMB_GID_NO_CHANGE))
2777 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2778
2779 if (file_type != UNIX_TYPE_CHARDEV && file_type != UNIX_TYPE_BLKDEV &&
2780 file_type != UNIX_TYPE_FIFO)
2781 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2782
2783 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
2784 0%o for file %s\n", (double)dev, unixmode, fname ));
2785
2786 /* Ok - do the mknod. */
2787 if (SMB_VFS_MKNOD(conn,dos_to_unix_static(fname), unixmode, dev) != 0)
2788 return(UNIXERROR(ERRDOS,ERRnoaccess));
2789
2790 inherit_access_acl(conn, fname, unixmode);
2791
2792 SSVAL(params,0,0);
2793 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2794 return(-1);
2795 #endif /* HAVE_MAKEDEV_FN */
2796
2797 }
2798
2799 /*
2800 * Deal with the UNIX specific mode set.
2801 */
2802
2803 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
2804 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
2805 (unsigned int)unixmode, fname ));
2806 if (SMB_VFS_CHMOD(conn,fname,unixmode) != 0)
2807 return(UNIXERROR(ERRDOS,ERRnoaccess));
2808 }
2809
2810 /*
2811 * Deal with the UNIX specific uid set.
2812 */
2813
2814 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (sbuf.st_uid != set_owner)) {
2815 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
2816 (unsigned int)set_owner, fname ));
2817 if (SMB_VFS_CHOWN(conn,fname,set_owner, (gid_t)-1) != 0)
2818 return(UNIXERROR(ERRDOS,ERRnoaccess));
2819 }
2820
2821 /*
2822 * Deal with the UNIX specific gid set.
2823 */
2824
2825 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (sbuf.st_gid != set_grp)) {
2826 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
2827 (unsigned int)set_owner, fname ));
2828 if (SMB_VFS_CHOWN(conn,fname,(uid_t)-1, set_grp) != 0)
2829 return(UNIXERROR(ERRDOS,ERRnoaccess));
2830 }
2831 break;
2832 }
2833
2834 case SMB_SET_FILE_UNIX_LINK:
2835 {
2836 pstring link_dest;
2837 /* Set a symbolic link. */
2838 /* Don't allow this if follow links is false. */
2839
2840 if (!lp_symlinks(SNUM(conn)))
2841 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2842
2843 /* Disallow if already exists. */
2844 if (VALID_STAT(sbuf))
2845 return(ERROR_DOS(ERRDOS,ERRbadpath));
2846
2847 srvstr_pull(inbuf, link_dest, pdata, sizeof(link_dest), -1, STR_TERMINATE);
2848
2849 if (ensure_link_is_safe(conn, link_dest, link_dest) != 0)
2850 return(UNIXERROR(ERRDOS,ERRnoaccess));
2851
2852 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
2853 fname, link_dest ));
2854
2855 if (SMB_VFS_SYMLINK(conn,link_dest,fname) != 0)
2856 return(UNIXERROR(ERRDOS,ERRnoaccess));
2857 SSVAL(params,0,0);
2858 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2859 return(-1);
2860 }
2861
2862 case SMB_SET_FILE_UNIX_HLINK:
2863 {
2864 pstring link_dest;
2865
2866 /* Set a hard link. */
2867
2868 /* Disallow if already exists. */
2869 if (VALID_STAT(sbuf))
2870 return(ERROR_DOS(ERRDOS,ERRbadpath));
2871
2872 srvstr_pull(inbuf, link_dest, pdata, sizeof(link_dest), -1, STR_TERMINATE);
2873
2874 if (ensure_link_is_safe(conn, link_dest, link_dest) != 0)
2875 return(UNIXERROR(ERRDOS,ERRnoaccess));
2876
2877 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
2878 fname, link_dest ));
2879
2880 if (SMB_VFS_LINK(conn,link_dest,fname) != 0)
2881 return(UNIXERROR(ERRDOS,ERRnoaccess));
2882 SSVAL(params,0,0);
2883 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2884 return(-1);
2885 }
2886
2887 default:
2888 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2889 }
2890
2891 /* get some defaults (no modifications) if any info is zero or -1. */
2892 if (tvs.actime == (time_t)0 || tvs.actime == (time_t)-1)
2893 tvs.actime = sbuf.st_atime;
2894
2895 if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
2896 tvs.modtime = sbuf.st_mtime;
2897
2898 DEBUG(6,("actime: %s " , ctime(&tvs.actime)));
2899 DEBUG(6,("modtime: %s ", ctime(&tvs.modtime)));
2900 DEBUG(6,("size: %.0f ", (double)size));
2901
2902 if (S_ISDIR(sbuf.st_mode))
2903 dosmode |= aDIR;
2904 else
2905 dosmode &= ~aDIR;
2906
2907 DEBUG(6,("dosmode: %x\n" , dosmode));
2908
2909 if(!((info_level == SMB_SET_FILE_END_OF_FILE_INFO) ||
2910 (info_level == SMB_SET_FILE_ALLOCATION_INFO) ||
2911 (info_level == SMB_FILE_ALLOCATION_INFORMATION) ||
2912 (info_level == SMB_FILE_END_OF_FILE_INFORMATION))) {
2913
2914 /*
2915 * Only do this test if we are not explicitly
2916 * changing the size of a file.
2917 */
2918 if (!size)
2919 size = get_file_size(sbuf);
2920 }
2921
2922 /*
2923 * Try and set the times, size and mode of this file -
2924 * if they are different from the current values
2925 */
2926 if (sbuf.st_mtime != tvs.modtime || sbuf.st_atime != tvs.actime) {
2927 if(fsp != NULL) {
2928 /*
2929 * This was a setfileinfo on an open file.
2930 * NT does this a lot. It's actually pointless
2931 * setting the time here, as it will be overwritten
2932 * on the next write, so we save the request
2933 * away and will set it on file close. JRA.
2934 */
2935
2936 if (tvs.modtime != (time_t)0 && tvs.modtime != (time_t)-1) {
2937 DEBUG(10,("call_trans2setfilepathinfo: setting pending modtime to %s\n", ctime(&tvs.modtime) ));
2938 fsp->pending_modtime = tvs.modtime;
2939 }
2940
2941 } else {
2942
2943 DEBUG(10,("call_trans2setfilepathinfo: setting utimes to modified values.\n"));
2944
2945 if(file_utime(conn, fname, &tvs)!=0)
2946 return(UNIXERROR(ERRDOS,ERRnoaccess));
2947 }
2948 }
2949
2950 /* check the mode isn't different, before changing it */
2951 if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, &sbuf))) {
2952
2953 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting dos mode %x\n", fname, dosmode ));
2954
2955 if(file_chmod(conn, fname, dosmode, NULL)) {
2956 DEBUG(2,("chmod of %s failed (%s)\n", fname, strerror(errno)));
2957 return(UNIXERROR(ERRDOS,ERRnoaccess));
2958 }
2959 }
2960
2961 if (size != get_file_size(sbuf)) {
2962
2963 int ret;
2964
2965 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new size to %.0f\n",
2966 fname, (double)size ));
2967
2968 if (fd == -1) {
2969 files_struct *new_fsp = NULL;
2970 int access_mode = 0;
2971 int action = 0;
2972
2973 if(global_oplock_break) {
2974 /* Queue this file modify as we are the process of an oplock break. */
2975
2976 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
2977 DEBUGADD(2,( "in oplock break state.\n"));
2978
2979 push_oplock_pending_smb_message(inbuf, length);
2980 return -1;
2981 }
2982
2983 new_fsp = open_file_shared(conn, fname, &sbuf,
2984 SET_OPEN_MODE(DOS_OPEN_RDWR),
2985 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
2986 0, 0, &access_mode, &action);
2987
2988 if (new_fsp == NULL)
2989 return(UNIXERROR(ERRDOS,ERRbadpath));
2990 ret = vfs_set_filelen(new_fsp, size);
2991 close_file(new_fsp,True);
2992 } else {
2993 ret = vfs_set_filelen(fsp, size);
2994 }
2995
2996 if (ret == -1)
2997 return (UNIXERROR(ERRHRD,ERRdiskfull));
2998 }
2999
3000 SSVAL(params,0,0);
3001 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3002
3003 return(-1);
3004 }
3005
3006 /****************************************************************************
3007 Reply to a TRANS2_MKDIR (make directory with extended attributes).
3008 ****************************************************************************/
3009
3010 static int call_trans2mkdir(connection_struct *conn,
3011 char *inbuf, char *outbuf, int length, int bufsize,
3012 char **pparams, int total_params, char **ppdata, int total_data)
3013 {
3014 char *params = *pparams;
3015 pstring directory;
3016 int ret = -1;
3017 SMB_STRUCT_STAT sbuf;
3018 BOOL bad_path = False;
3019
3020 if (!CAN_WRITE(conn))
3021 return ERROR_DOS(ERRSRV,ERRaccess);
3022
3023 if (total_params < 4)
3024 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3025
3026 srvstr_pull(inbuf, directory, &params[4], sizeof(directory), -1, STR_TERMINATE);
3027
3028 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
3029
3030 unix_convert(directory,conn,0,&bad_path,&sbuf);
3031 if (check_name(directory,conn))
3032 ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory));
3033
3034 if(ret < 0) {
3035 DEBUG(5,("call_trans2mkdir error (%s)\n", strerror(errno)));
3036 set_bad_path_error(errno, bad_path);
3037 return(UNIXERROR(ERRDOS,ERRnoaccess));
3038 }
3039
3040 /* Realloc the parameter and data sizes */
3041 params = Realloc(*pparams,2);
3042 if(params == NULL)
3043 return ERROR_DOS(ERRDOS,ERRnomem);
3044 *pparams = params;
3045
3046 SSVAL(params,0,0);
3047
3048 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3049
3050 return(-1);
3051 }
3052
3053 /****************************************************************************
3054 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
3055 We don't actually do this - we just send a null response.
3056 ****************************************************************************/
3057
3058 static int call_trans2findnotifyfirst(connection_struct *conn,
3059 char *inbuf, char *outbuf, int length, int bufsize,
3060 char **pparams, int total_params, char **ppdata, int total_data)
3061 {
3062 static uint16 fnf_handle = 257;
3063 char *params = *pparams;
3064 uint16 info_level;
3065
3066 if (total_params < 6)
3067 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3068
3069 info_level = SVAL(params,4);
3070 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
3071
3072 switch (info_level) {
3073 case 1:
3074 case 2:
3075 break;
3076 default:
3077 return ERROR_DOS(ERRDOS,ERRunknownlevel);
3078 }
3079
3080 /* Realloc the parameter and data sizes */
3081 params = Realloc(*pparams,6);
3082 if(params == NULL)
3083 return ERROR_DOS(ERRDOS,ERRnomem);
3084 *pparams = params;
3085
3086 SSVAL(params,0,fnf_handle);
3087 SSVAL(params,2,0); /* No changes */
3088 SSVAL(params,4,0); /* No EA errors */
3089
3090 fnf_handle++;
3091
3092 if(fnf_handle == 0)
3093 fnf_handle = 257;
3094
3095 send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0);
3096
3097 return(-1);
3098 }
3099
3100 /****************************************************************************
3101 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
3102 changes). Currently this does nothing.
3103 ****************************************************************************/
3104
3105 static int call_trans2findnotifynext(connection_struct *conn,
3106 char *inbuf, char *outbuf, int length, int bufsize,
3107 char **pparams, int total_params, char **ppdata, int total_data)
3108 {
3109 char *params = *pparams;
3110
3111 DEBUG(3,("call_trans2findnotifynext\n"));
3112
3113 /* Realloc the parameter and data sizes */
3114 params = Realloc(*pparams,4);
3115 if(params == NULL)
3116 return ERROR_DOS(ERRDOS,ERRnomem);
3117 *pparams = params;
3118
3119 SSVAL(params,0,0); /* No changes */
3120 SSVAL(params,2,0); /* No EA errors */
3121
3122 send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0);
3123
3124 return(-1);
3125 }
3126
3127 /****************************************************************************
3128 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
3129 ****************************************************************************/
3130
3131 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf,
3132 char* outbuf, int length, int bufsize,
3133 char **pparams, int total_params, char **ppdata, int total_data)
3134 {
3135 char *params = *pparams;
3136 pstring pathname;
3137 int reply_size = 0;
3138 int max_referral_level;
3139
3140 DEBUG(10,("call_trans2getdfsreferral\n"));
3141
3142 if (total_params < 2)
3143 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3144
3145 max_referral_level = SVAL(params,0);
3146
3147 if(!lp_host_msdfs())
3148 return ERROR_DOS(ERRDOS,ERRbadfunc);
3149
3150 srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), -1, STR_TERMINATE);
3151
3152 if((reply_size = setup_dfs_referral(pathname,max_referral_level,ppdata)) < 0)
3153 return ERROR_DOS(ERRDOS,ERRbadfile);
3154
3155 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
3156 send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size);
3157
3158 return(-1);
3159 }
3160
3161 #define LMCAT_SPL 0x53
3162 #define LMFUNC_GETJOBID 0x60
3163
3164 /****************************************************************************
3165 Reply to a TRANS2_IOCTL - used for OS/2 printing.
3166 ****************************************************************************/
3167
3168 static int call_trans2ioctl(connection_struct *conn, char* inbuf,
3169 char* outbuf, int length, int bufsize,
3170 char **pparams, int total_params, char **ppdata, int total_data)
3171 {
3172 char *pdata = *ppdata;
3173 files_struct *fsp = file_fsp(inbuf,smb_vwv15);
3174
3175 if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
3176 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
3177 pdata = Realloc(*ppdata, 32);
3178 if(pdata == NULL)
3179 return ERROR_DOS(ERRDOS,ERRnomem);
3180 *ppdata = pdata;
3181
3182 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
3183 CAN ACCEPT THIS IN UNICODE. JRA. */
3184
3185 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
3186 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
3187 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
3188 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32);
3189 return(-1);
3190 } else {
3191 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
3192 return ERROR_DOS(ERRSRV,ERRerror);
3193 }
3194 }
3195
3196 /****************************************************************************
3197 Reply to a SMBfindclose (stop trans2 directory search).
3198 ****************************************************************************/
3199
3200 int reply_findclose(connection_struct *conn,
3201 char *inbuf,char *outbuf,int length,int bufsize)
3202 {
3203 int outsize = 0;
3204 int dptr_num=SVALS(inbuf,smb_vwv0);
3205 START_PROFILE(SMBfindclose);
3206
3207 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
3208
3209 dptr_close(&dptr_num);
3210
3211 outsize = set_message(outbuf,0,0,True);
3212
3213 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
3214
3215 END_PROFILE(SMBfindclose);
3216 return(outsize);
3217 }
3218
3219 /****************************************************************************
3220 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
3221 ****************************************************************************/
3222
3223 int reply_findnclose(connection_struct *conn,
3224 char *inbuf,char *outbuf,int length,int bufsize)
3225 {
3226 int outsize = 0;
3227 int dptr_num= -1;
3228 START_PROFILE(SMBfindnclose);
3229
3230 dptr_num = SVAL(inbuf,smb_vwv0);
3231
3232 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
3233
3234 /* We never give out valid handles for a
3235 findnotifyfirst - so any dptr_num is ok here.
3236 Just ignore it. */
3237
3238 outsize = set_message(outbuf,0,0,True);
3239
3240 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
3241
3242 END_PROFILE(SMBfindnclose);
3243 return(outsize);
3244 }
3245
3246 /****************************************************************************
3247 Reply to a SMBtranss2 - just ignore it!
3248 ****************************************************************************/
3249
3250 int reply_transs2(connection_struct *conn,
3251 char *inbuf,char *outbuf,int length,int bufsize)
3252 {
3253 START_PROFILE(SMBtranss2);
3254 DEBUG(4,("Ignoring transs2 of length %d\n",length));
3255 END_PROFILE(SMBtranss2);
3256 return(-1);
3257 }
3258
3259 /****************************************************************************
3260 Reply to a SMBtrans2.
3261 ****************************************************************************/
3262
3263 int reply_trans2(connection_struct *conn,
3264 char *inbuf,char *outbuf,int length,int bufsize)
3265 {
3266 int outsize = 0;
3267 unsigned int total_params = SVAL(inbuf, smb_tpscnt);
3268 unsigned int total_data =SVAL(inbuf, smb_tdscnt);
3269 #if 0
3270 unsigned int max_param_reply = SVAL(inbuf, smb_mprcnt);
3271 unsigned int max_data_reply = SVAL(inbuf, smb_mdrcnt);
3272 unsigned int max_setup_fields = SVAL(inbuf, smb_msrcnt);
3273 BOOL close_tid = BITSETW(inbuf+smb_flags,0);
3274 BOOL no_final_response = BITSETW(inbuf+smb_flags,1);
3275 int32 timeout = IVALS(inbuf,smb_timeout);
3276 #endif
3277 unsigned int suwcnt = SVAL(inbuf, smb_suwcnt);
3278 unsigned int tran_call = SVAL(inbuf, smb_setup0);
3279 char *params = NULL, *data = NULL;
3280 unsigned int num_params, num_params_sofar, num_data, num_data_sofar;
3281 START_PROFILE(SMBtrans2);
3282
3283 if(global_oplock_break && (tran_call == TRANSACT2_OPEN)) {
3284 /* Queue this open message as we are the process of an
3285 * oplock break. */
3286
3287 DEBUG(2,("reply_trans2: queueing message trans2open due to being "));
3288 DEBUGADD(2,( "in oplock break state.\n"));
3289
3290 push_oplock_pending_smb_message(inbuf, length);
3291 END_PROFILE(SMBtrans2);
3292 return -1;
3293 }
3294
3295 if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
3296 && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
3297 END_PROFILE(SMBtrans2);
3298 return ERROR_DOS(ERRSRV,ERRaccess);
3299 }
3300
3301 outsize = set_message(outbuf,0,0,True);
3302
3303 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
3304 is so as a sanity check */
3305 if (suwcnt != 1) {
3306 /*
3307 * Need to have rc=0 for ioctl to get job id for OS/2.
3308 * Network printing will fail if function is not successful.
3309 * Similar function in reply.c will be used if protocol
3310 * is LANMAN1.0 instead of LM1.2X002.
3311 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
3312 * outbuf doesn't have to be set(only job id is used).
3313 */
3314 if ( (suwcnt == 4) && (tran_call == TRANSACT2_IOCTL) &&
3315 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
3316 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
3317 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
3318 } else {
3319 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",suwcnt));
3320 DEBUG(2,("Transaction is %d\n",tran_call));
3321 END_PROFILE(SMBtrans2);
3322 ERROR_DOS(ERRDOS,ERRinvalidparam);
3323 }
3324 }
3325
3326 /* Allocate the space for the maximum needed parameters and data */
3327 if (total_params > 0)
3328 params = (char *)malloc(total_params);
3329 if (total_data > 0)
3330 data = (char *)malloc(total_data);
3331
3332 if ((total_params && !params) || (total_data && !data)) {
3333 DEBUG(2,("Out of memory in reply_trans2\n"));
3334 SAFE_FREE(params);
3335 SAFE_FREE(data);
3336 END_PROFILE(SMBtrans2);
3337 return ERROR_DOS(ERRDOS,ERRnomem);
3338 }
3339
3340 /* Copy the param and data bytes sent with this request into
3341 the params buffer */
3342 num_params = num_params_sofar = SVAL(inbuf,smb_pscnt);
3343 num_data = num_data_sofar = SVAL(inbuf, smb_dscnt);
3344
3345 if (num_params > total_params || num_data > total_data)
3346 exit_server("invalid params in reply_trans2");
3347
3348 if(params) {
3349 unsigned int psoff = SVAL(inbuf, smb_psoff);
3350 if ((psoff + num_params < psoff) || (psoff + num_params < num_params))
3351 goto bad_param;
3352 if (smb_base(inbuf) + psoff + num_params > inbuf + length)
3353 goto bad_param;
3354 memcpy( params, smb_base(inbuf) + psoff, num_params);
3355 }
3356 if(data) {
3357 unsigned int dsoff = SVAL(inbuf, smb_dsoff);
3358 if ((dsoff + num_data < dsoff) || (dsoff + num_data < num_data))
3359 goto bad_param;
3360 if (smb_base(inbuf) + dsoff + num_data > inbuf + length)
3361 goto bad_param;
3362 memcpy( data, smb_base(inbuf) + dsoff, num_data);
3363 }
3364
3365 if(num_data_sofar < total_data || num_params_sofar < total_params) {
3366 /* We need to send an interim response then receive the rest
3367 of the parameter/data bytes */
3368 outsize = set_message(outbuf,0,0,True);
3369 if (!send_smb(smbd_server_fd(),outbuf))
3370 exit_server("reply_trans2: send_smb failed.");
3371
3372 while (num_data_sofar < total_data ||
3373 num_params_sofar < total_params) {
3374 BOOL ret;
3375 unsigned int param_disp;
3376 unsigned int param_off;
3377 unsigned int data_disp;
3378 unsigned int data_off;
3379
3380 ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
3381
3382 if ((ret &&
3383 (CVAL(inbuf, smb_com) != SMBtranss2)) || !ret) {
3384 outsize = set_message(outbuf,0,0,True);
3385 if(ret)
3386 DEBUG(0,("reply_trans2: Invalid secondary trans2 packet\n"));
3387 else
3388 DEBUG(0,("reply_trans2: %s in getting secondary trans2 response.\n",
3389 (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
3390 goto bad_param;
3391 }
3392
3393 /* Revise total_params and total_data in case
3394 they have changed downwards */
3395 if (SVAL(inbuf, smb_tpscnt) < total_params)
3396 total_params = SVAL(inbuf, smb_tpscnt);
3397 if (SVAL(inbuf, smb_tdscnt) < total_data)
3398 total_data = SVAL(inbuf, smb_tdscnt);
3399
3400 num_params = SVAL(inbuf,smb_spscnt);
3401 param_off = SVAL(inbuf, smb_spsoff);
3402 param_disp = SVAL(inbuf, smb_spsdisp);
3403 num_params_sofar += num_params;
3404
3405 num_data = SVAL(inbuf, smb_sdscnt);
3406 data_off = SVAL(inbuf, smb_sdsoff);
3407 data_disp = SVAL(inbuf, smb_sdsdisp);
3408 num_data_sofar += num_data;
3409
3410 if (num_params_sofar > total_params || num_data_sofar > total_data)
3411 goto bad_param;
3412
3413 if (num_params) {
3414 if (param_disp + num_params >= total_params)
3415 goto bad_param;
3416 if ((param_disp + num_params < param_disp) ||
3417 (param_disp + num_params < num_params))
3418 goto bad_param;
3419 if (smb_base(inbuf) + param_off + num_params >= inbuf + bufsize)
3420 goto bad_param;
3421 if (params + param_disp < params)
3422 goto bad_param;
3423
3424 memcpy( &params[param_disp], smb_base(inbuf) + param_off, num_params);
3425 }
3426 if (num_data) {
3427 if (data_disp + num_data >= total_data)
3428 goto bad_param;
3429 if ((data_disp + num_data < data_disp) ||
3430 (data_disp + num_data < num_data))
3431 goto bad_param;
3432 if (smb_base(inbuf) + data_off + num_data >= inbuf + bufsize)
3433 goto bad_param;
3434 if (data + data_disp < data)
3435 goto bad_param;
3436
3437 memcpy( &data[data_disp], smb_base(inbuf) + data_off, num_data);
3438 }
3439 }
3440 }
3441
3442 if (Protocol >= PROTOCOL_NT1) {
3443 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
3444 }
3445
3446 /* Now we must call the relevant TRANS2 function */
3447 switch(tran_call) {
3448 case TRANSACT2_OPEN:
3449 START_PROFILE_NESTED(Trans2_open);
3450 outsize = call_trans2open(conn, inbuf, outbuf, bufsize,
3451 &params, total_params, &data, total_data);
3452 END_PROFILE_NESTED(Trans2_open);
3453 break;
3454
3455 case TRANSACT2_FINDFIRST:
3456 START_PROFILE_NESTED(Trans2_findfirst);
3457 outsize = call_trans2findfirst(conn, inbuf, outbuf, bufsize,
3458 &params, total_params, &data, total_data);
3459 END_PROFILE_NESTED(Trans2_findfirst);
3460 break;
3461
3462 case TRANSACT2_FINDNEXT:
3463 START_PROFILE_NESTED(Trans2_findnext);
3464 outsize = call_trans2findnext(conn, inbuf, outbuf, length, bufsize,
3465 &params, total_params, &data, total_data);
3466 END_PROFILE_NESTED(Trans2_findnext);
3467 break;
3468
3469 case TRANSACT2_QFSINFO:
3470 START_PROFILE_NESTED(Trans2_qfsinfo);
3471 outsize = call_trans2qfsinfo(conn, inbuf, outbuf, length, bufsize,
3472 &params, total_params, &data, total_data);
3473 END_PROFILE_NESTED(Trans2_qfsinfo);
3474 break;
3475
3476 #ifdef HAVE_SYS_QUOTAS
3477 case TRANSACT2_SETFSINFO:
3478 START_PROFILE_NESTED(Trans2_setfsinfo);
3479 outsize = call_trans2setfsinfo(conn, inbuf, outbuf, length, bufsize,
3480 &params, total_params, &data, total_data);
3481 END_PROFILE_NESTED(Trans2_setfsinfo);
3482 break;
3483 #endif
3484 case TRANSACT2_QPATHINFO:
3485 case TRANSACT2_QFILEINFO:
3486 START_PROFILE_NESTED(Trans2_qpathinfo);
3487 outsize = call_trans2qfilepathinfo(conn, inbuf, outbuf, length, bufsize,
3488 &params, total_params, &data, total_data);
3489 END_PROFILE_NESTED(Trans2_qpathinfo);
3490 break;
3491 case TRANSACT2_SETPATHINFO:
3492 case TRANSACT2_SETFILEINFO:
3493 START_PROFILE_NESTED(Trans2_setpathinfo);
3494 outsize = call_trans2setfilepathinfo(conn, inbuf, outbuf, length, bufsize,
3495 &params, total_params, &data, total_data);
3496 END_PROFILE_NESTED(Trans2_setpathinfo);
3497 break;
3498
3499 case TRANSACT2_FINDNOTIFYFIRST:
3500 START_PROFILE_NESTED(Trans2_findnotifyfirst);
3501 outsize = call_trans2findnotifyfirst(conn, inbuf, outbuf, length, bufsize,
3502 &params, total_params, &data, total_data);
3503 END_PROFILE_NESTED(Trans2_findnotifyfirst);
3504 break;
3505
3506 case TRANSACT2_FINDNOTIFYNEXT:
3507 START_PROFILE_NESTED(Trans2_findnotifynext);
3508 outsize = call_trans2findnotifynext(conn, inbuf, outbuf, length, bufsize,
3509 &params, total_params, &data, total_data);
3510 END_PROFILE_NESTED(Trans2_findnotifynext);
3511 break;
3512 case TRANSACT2_MKDIR:
3513 START_PROFILE_NESTED(Trans2_mkdir);
3514 outsize = call_trans2mkdir(conn, inbuf, outbuf, length, bufsize,
3515 &params, total_params, &data, total_data);
3516 END_PROFILE_NESTED(Trans2_mkdir);
3517 break;
3518
3519 case TRANSACT2_GET_DFS_REFERRAL:
3520 START_PROFILE_NESTED(Trans2_get_dfs_referral);
3521 outsize = call_trans2getdfsreferral(conn,inbuf,outbuf,length, bufsize,
3522 &params, total_params, &data, total_data);
3523 END_PROFILE_NESTED(Trans2_get_dfs_referral);
3524 break;
3525 case TRANSACT2_IOCTL:
3526 START_PROFILE_NESTED(Trans2_ioctl);
3527 outsize = call_trans2ioctl(conn,inbuf,outbuf,length, bufsize,
3528 &params, total_params, &data, total_data);
3529 END_PROFILE_NESTED(Trans2_ioctl);
3530 break;
3531 default:
3532 /* Error in request */
3533 DEBUG(2,("Unknown request %d in trans2 call\n", tran_call));
3534 SAFE_FREE(params);
3535 SAFE_FREE(data);
3536 END_PROFILE(SMBtrans2);
3537 return ERROR_DOS(ERRSRV,ERRerror);
3538 }
3539
3540 /* As we do not know how many data packets will need to be
3541 returned here the various call_trans2xxxx calls
3542 must send their own. Thus a call_trans2xxx routine only
3543 returns a value other than -1 when it wants to send
3544 an error packet.
3545 */
3546
3547 SAFE_FREE(params);
3548 SAFE_FREE(data);
3549 END_PROFILE(SMBtrans2);
3550 return outsize; /* If a correct response was needed the
3551 call_trans2xxx calls have already sent
3552 it. If outsize != -1 then it is returning */
3553
3554 bad_param:
3555
3556 SAFE_FREE(params);
3557 SAFE_FREE(data);
3558 END_PROFILE(SMBtrans2);
3559 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3560 }
Samba GIT mirror