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