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