?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
local.h: Removed ununsed SHARE_MODES_XXX defines. Upped SMBD_RELOAD_CHECK
[Samba.git] / source / smbd / trans2.c
blob1b199f01ba920e42452eff986ae0b49189893255
1 /*
2 Unix SMB/Netbios implementation.
3 Version 1.9.
4 SMB transaction2 handling
5 Copyright (C) Jeremy Allison 1994-1997
6
7 Extensively modified by Andrew Tridgell, 1995
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "trans2.h"
26
27 extern int DEBUGLEVEL;
28 extern int Protocol;
29 extern connection_struct Connections[];
30 extern files_struct Files[];
31 extern BOOL case_sensitive;
32 extern int Client;
33
34 /****************************************************************************
35 Send the required number of replies back.
36 We assume all fields other than the data fields are
37 set correctly for the type of call.
38 HACK ! Always assumes smb_setup field is zero.
39 ****************************************************************************/
40 static int send_trans2_replies(char *outbuf, int bufsize, char *params,
41 int paramsize, char *pdata, int datasize)
42 {
43 /* As we are using a protocol > LANMAN1 then the max_send
44 variable must have been set in the sessetupX call.
45 This takes precedence over the max_xmit field in the
46 global struct. These different max_xmit variables should
47 be merged as this is now too confusing */
48
49 extern int max_send;
50 int data_to_send = datasize;
51 int params_to_send = paramsize;
52 int useable_space;
53 char *pp = params;
54 char *pd = pdata;
55 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
56 int alignment_offset = 1;
57
58 /* Initially set the wcnt area to be 10 - this is true for all
59 trans2 replies */
60 set_message(outbuf,10,0,True);
61
62 /* If there genuinely are no parameters or data to send just send
63 the empty packet */
64 if(params_to_send == 0 && data_to_send == 0)
65 {
66 send_smb(Client,outbuf);
67 return 0;
68 }
69
70 /* Space is bufsize minus Netbios over TCP header minus SMB header */
71 /* The alignment_offset is to align the param and data bytes on an even byte
72 boundary. NT 4.0 Beta needs this to work correctly. */
73 useable_space = bufsize - ((smb_buf(outbuf)+alignment_offset) - outbuf);
74 /* useable_space can never be more than max_send minus the
75 alignment offset. */
76 useable_space = MIN(useable_space, max_send - alignment_offset);
77
78 while( params_to_send || data_to_send)
79 {
80 /* Calculate whether we will totally or partially fill this packet */
81 total_sent_thistime = params_to_send + data_to_send + alignment_offset;
82 /* We can never send more than useable_space */
83 total_sent_thistime = MIN(total_sent_thistime, useable_space);
84
85 set_message(outbuf, 10, total_sent_thistime, True);
86
87 /* Set total params and data to be sent */
88 SSVAL(outbuf,smb_tprcnt,paramsize);
89 SSVAL(outbuf,smb_tdrcnt,datasize);
90
91 /* Calculate how many parameters and data we can fit into
92 this packet. Parameters get precedence */
93
94 params_sent_thistime = MIN(params_to_send,useable_space);
95 data_sent_thistime = useable_space - params_sent_thistime;
96 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
97
98 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
99 if(params_sent_thistime == 0)
100 {
101 SSVAL(outbuf,smb_proff,0);
102 SSVAL(outbuf,smb_prdisp,0);
103 } else {
104 /* smb_proff is the offset from the start of the SMB header to the
105 parameter bytes, however the first 4 bytes of outbuf are
106 the Netbios over TCP header. Thus use smb_base() to subtract
107 them from the calculation */
108 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
109 /* Absolute displacement of param bytes sent in this packet */
110 SSVAL(outbuf,smb_prdisp,pp - params);
111 }
112
113 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
114 if(data_sent_thistime == 0)
115 {
116 SSVAL(outbuf,smb_droff,0);
117 SSVAL(outbuf,smb_drdisp, 0);
118 } else {
119 /* The offset of the data bytes is the offset of the
120 parameter bytes plus the number of parameters being sent this time */
121 SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
122 smb_base(outbuf)) + params_sent_thistime);
123 SSVAL(outbuf,smb_drdisp, pd - pdata);
124 }
125
126 /* Copy the param bytes into the packet */
127 if(params_sent_thistime)
128 memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
129 /* Copy in the data bytes */
130 if(data_sent_thistime)
131 memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime,pd,data_sent_thistime);
132
133 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
134 params_sent_thistime, data_sent_thistime, useable_space));
135 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
136 params_to_send, data_to_send, paramsize, datasize));
137
138 /* Send the packet */
139 send_smb(Client,outbuf);
140
141 pp += params_sent_thistime;
142 pd += data_sent_thistime;
143
144 params_to_send -= params_sent_thistime;
145 data_to_send -= data_sent_thistime;
146
147 /* Sanity check */
148 if(params_to_send < 0 || data_to_send < 0)
149 {
150 DEBUG(2,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
151 params_to_send, data_to_send));
152 return -1;
153 }
154 }
155
156 return 0;
157 }
158
159
160 /****************************************************************************
161 reply to a TRANSACT2_OPEN
162 ****************************************************************************/
163 static int call_trans2open(char *inbuf, char *outbuf, int bufsize, int cnum,
164 char **pparams, char **ppdata)
165 {
166 char *params = *pparams;
167 int16 open_mode = SVAL(params, 2);
168 int16 open_attr = SVAL(params,6);
169 BOOL oplock_request = BITSETW(params,1);
170 #if 0
171 BOOL return_additional_info = BITSETW(params,0);
172 int16 open_sattr = SVAL(params, 4);
173 time_t open_time = make_unix_date3(params+8);
174 #endif
175 int16 open_ofun = SVAL(params,12);
176 int32 open_size = IVAL(params,14);
177 char *pname = &params[28];
178 int16 namelen = strlen(pname)+1;
179
180 pstring fname;
181 int fnum = -1;
182 int unixmode;
183 int size=0,fmode=0,mtime=0,rmode;
184 int32 inode = 0;
185 struct stat sbuf;
186 int smb_action = 0;
187
188 StrnCpy(fname,pname,namelen);
189
190 DEBUG(3,("trans2open %s cnum=%d mode=%d attr=%d ofun=%d size=%d\n",
191 fname,cnum,open_mode, open_attr, open_ofun, open_size));
192
193 /* XXXX we need to handle passed times, sattr and flags */
194
195 unix_convert(fname,cnum,0);
196
197 fnum = find_free_file();
198 if (fnum < 0)
199 return(ERROR(ERRSRV,ERRnofids));
200
201 if (!check_name(fname,cnum))
202 return(UNIXERROR(ERRDOS,ERRnoaccess));
203
204 unixmode = unix_mode(cnum,open_attr | aARCH);
205
206
207 open_file_shared(fnum,cnum,fname,open_mode,open_ofun,unixmode,
208 &rmode,&smb_action);
209
210 if (!Files[fnum].open)
211 return(UNIXERROR(ERRDOS,ERRnoaccess));
212
213 if (fstat(Files[fnum].fd_ptr->fd,&sbuf) != 0) {
214 close_file(fnum);
215 return(ERROR(ERRDOS,ERRnoaccess));
216 }
217
218 size = sbuf.st_size;
219 fmode = dos_mode(cnum,fname,&sbuf);
220 mtime = sbuf.st_mtime;
221 inode = sbuf.st_ino;
222 if (fmode & aDIR) {
223 close_file(fnum);
224 return(ERROR(ERRDOS,ERRnoaccess));
225 }
226
227 /* Realloc the size of parameters and data we will return */
228 params = *pparams = Realloc(*pparams, 28);
229 if(params == NULL)
230 return(ERROR(ERRDOS,ERRnomem));
231
232 bzero(params,28);
233 SSVAL(params,0,fnum);
234 SSVAL(params,2,fmode);
235 put_dos_date2(params,4, mtime);
236 SIVAL(params,8, size);
237 SSVAL(params,12,rmode);
238
239 if (oplock_request && lp_fake_oplocks(SNUM(cnum))) {
240 smb_action |= (1<<15);
241 }
242
243 SSVAL(params,18,smb_action);
244 SIVAL(params,20,inode);
245
246 /* Send the required number of replies */
247 send_trans2_replies(outbuf, bufsize, params, 28, *ppdata, 0);
248
249 return -1;
250 }
251
252 /****************************************************************************
253 get a level dependent lanman2 dir entry.
254 ****************************************************************************/
255 static int get_lanman2_dir_entry(int cnum,char *path_mask,int dirtype,int info_level,
256 int requires_resume_key,
257 BOOL dont_descend,char **ppdata,
258 char *base_data, int space_remaining,
259 BOOL *out_of_space,
260 int *last_name_off)
261 {
262 char *dname;
263 BOOL found = False;
264 struct stat sbuf;
265 pstring mask;
266 pstring pathreal;
267 pstring fname;
268 BOOL matched;
269 char *p, *pdata = *ppdata;
270 int reskey=0, prev_dirpos=0;
271 int mode=0;
272 uint32 size=0,len;
273 uint32 mdate=0, adate=0, cdate=0;
274 char *nameptr;
275 BOOL isrootdir = (strequal(Connections[cnum].dirpath,"./") ||
276 strequal(Connections[cnum].dirpath,".") ||
277 strequal(Connections[cnum].dirpath,"/"));
278 BOOL was_8_3;
279 int nt_extmode; /* Used for NT connections instead of mode */
280 BOOL needslash = ( Connections[cnum].dirpath[strlen(Connections[cnum].dirpath) -1] != '/');
281
282 *fname = 0;
283 *out_of_space = False;
284
285 if (!Connections[cnum].dirptr)
286 return(False);
287
288 p = strrchr(path_mask,'/');
289 if(p != NULL)
290 {
291 if(p[1] == '\0')
292 strcpy(mask,"*.*");
293 else
294 strcpy(mask, p+1);
295 }
296 else
297 strcpy(mask, path_mask);
298
299 while (!found)
300 {
301 /* Needed if we run out of space */
302 prev_dirpos = TellDir(Connections[cnum].dirptr);
303 dname = ReadDirName(Connections[cnum].dirptr);
304
305 reskey = TellDir(Connections[cnum].dirptr);
306
307 DEBUG(6,("get_lanman2_dir_entry:readdir on dirptr 0x%x now at offset %d\n",
308 Connections[cnum].dirptr,TellDir(Connections[cnum].dirptr)));
309
310 if (!dname)
311 return(False);
312
313 matched = False;
314
315 strcpy(fname,dname);
316
317 if(mask_match(fname, mask, case_sensitive, True))
318 {
319 BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
320 if (dont_descend && !isdots)
321 continue;
322
323 if (isrootdir && isdots)
324 continue;
325
326 strcpy(pathreal,Connections[cnum].dirpath);
327 if(needslash)
328 strcat(pathreal,"/");
329 strcat(pathreal,fname);
330 if (sys_stat(pathreal,&sbuf) != 0)
331 {
332 DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",pathreal,strerror(errno)));
333 continue;
334 }
335
336 mode = dos_mode(cnum,pathreal,&sbuf);
337
338 if (!dir_check_ftype(cnum,mode,&sbuf,dirtype)) {
339 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
340 continue;
341 }
342
343 size = sbuf.st_size;
344 mdate = sbuf.st_mtime;
345 adate = sbuf.st_atime;
346 cdate = sbuf.st_ctime;
347 if(mode & aDIR)
348 size = 0;
349
350 DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
351
352 found = True;
353 }
354 }
355
356
357
358 p = pdata;
359 nameptr = p;
360
361 name_map_mangle(fname,False,SNUM(cnum));
362
363 nt_extmode = mode ? mode : NT_FILE_ATTRIBUTE_NORMAL;
364
365 switch (info_level)
366 {
367 case 1:
368 if(requires_resume_key) {
369 SIVAL(p,0,reskey);
370 p += 4;
371 }
372 put_dos_date2(p,l1_fdateCreation,cdate);
373 put_dos_date2(p,l1_fdateLastAccess,adate);
374 put_dos_date2(p,l1_fdateLastWrite,mdate);
375 SIVAL(p,l1_cbFile,size);
376 SIVAL(p,l1_cbFileAlloc,ROUNDUP(size,1024));
377 SSVAL(p,l1_attrFile,mode);
378 SCVAL(p,l1_cchName,strlen(fname));
379 strcpy(p + l1_achName, fname);
380 nameptr = p + l1_achName;
381 p += l1_achName + strlen(fname) + 1;
382 break;
383
384 case 2:
385 /* info_level 2 */
386 if(requires_resume_key) {
387 SIVAL(p,0,reskey);
388 p += 4;
389 }
390 put_dos_date2(p,l2_fdateCreation,cdate);
391 put_dos_date2(p,l2_fdateLastAccess,adate);
392 put_dos_date2(p,l2_fdateLastWrite,mdate);
393 SIVAL(p,l2_cbFile,size);
394 SIVAL(p,l2_cbFileAlloc,ROUNDUP(size,1024));
395 SSVAL(p,l2_attrFile,mode);
396 SIVAL(p,l2_cbList,0); /* No extended attributes */
397 SCVAL(p,l2_cchName,strlen(fname));
398 strcpy(p + l2_achName, fname);
399 nameptr = p + l2_achName;
400 p += l2_achName + strlen(fname) + 1;
401 break;
402
403 case 3:
404 SIVAL(p,0,reskey);
405 put_dos_date2(p,4,cdate);
406 put_dos_date2(p,8,adate);
407 put_dos_date2(p,12,mdate);
408 SIVAL(p,16,size);
409 SIVAL(p,20,ROUNDUP(size,1024));
410 SSVAL(p,24,mode);
411 SIVAL(p,26,4);
412 CVAL(p,30) = strlen(fname);
413 strcpy(p+31, fname);
414 nameptr = p+31;
415 p += 31 + strlen(fname) + 1;
416 break;
417
418 case 4:
419 if(requires_resume_key) {
420 SIVAL(p,0,reskey);
421 p += 4;
422 }
423 SIVAL(p,0,33+strlen(fname)+1);
424 put_dos_date2(p,4,cdate);
425 put_dos_date2(p,8,adate);
426 put_dos_date2(p,12,mdate);
427 SIVAL(p,16,size);
428 SIVAL(p,20,ROUNDUP(size,1024));
429 SSVAL(p,24,mode);
430 CVAL(p,32) = strlen(fname);
431 strcpy(p + 33, fname);
432 nameptr = p+33;
433 p += 33 + strlen(fname) + 1;
434 break;
435
436 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
437 was_8_3 = is_8_3(fname, True);
438 len = 94+strlen(fname);
439 len = (len + 3) & ~3;
440 SIVAL(p,0,len); p += 4;
441 SIVAL(p,0,reskey); p += 4;
442 put_long_date(p,cdate); p += 8;
443 put_long_date(p,adate); p += 8;
444 put_long_date(p,mdate); p += 8;
445 put_long_date(p,mdate); p += 8;
446 SIVAL(p,0,size); p += 8;
447 SIVAL(p,0,size); p += 8;
448 SIVAL(p,0,nt_extmode); p += 4;
449 SIVAL(p,0,strlen(fname)); p += 4;
450 SIVAL(p,0,0); p += 4;
451 if (!was_8_3) {
452 strcpy(p+2,fname);
453 if (!name_map_mangle(p+2,True,SNUM(cnum)))
454 (p+2)[12] = 0;
455 } else
456 *(p+2) = 0;
457 strupper(p+2);
458 SSVAL(p,0,strlen(p+2));
459 p += 2 + 24;
460 /* nameptr = p; */
461 strcpy(p,fname); p += strlen(p);
462 p = pdata + len;
463 break;
464
465 case SMB_FIND_FILE_DIRECTORY_INFO:
466 len = 64+strlen(fname);
467 len = (len + 3) & ~3;
468 SIVAL(p,0,len); p += 4;
469 SIVAL(p,0,reskey); p += 4;
470 put_long_date(p,cdate); p += 8;
471 put_long_date(p,adate); p += 8;
472 put_long_date(p,mdate); p += 8;
473 put_long_date(p,mdate); p += 8;
474 SIVAL(p,0,size); p += 8;
475 SIVAL(p,0,size); p += 8;
476 SIVAL(p,0,nt_extmode); p += 4;
477 SIVAL(p,0,strlen(fname)); p += 4;
478 strcpy(p,fname);
479 p = pdata + len;
480 break;
481
482
483 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
484 len = 68+strlen(fname);
485 len = (len + 3) & ~3;
486 SIVAL(p,0,len); p += 4;
487 SIVAL(p,0,reskey); p += 4;
488 put_long_date(p,cdate); p += 8;
489 put_long_date(p,adate); p += 8;
490 put_long_date(p,mdate); p += 8;
491 put_long_date(p,mdate); p += 8;
492 SIVAL(p,0,size); p += 8;
493 SIVAL(p,0,size); p += 8;
494 SIVAL(p,0,nt_extmode); p += 4;
495 SIVAL(p,0,strlen(fname)); p += 4;
496 SIVAL(p,0,0); p += 4;
497 strcpy(p,fname);
498 p = pdata + len;
499 break;
500
501 case SMB_FIND_FILE_NAMES_INFO:
502 len = 12+strlen(fname);
503 len = (len + 3) & ~3;
504 SIVAL(p,0,len); p += 4;
505 SIVAL(p,0,reskey); p += 4;
506 SIVAL(p,0,strlen(fname)); p += 4;
507 strcpy(p,fname);
508 p = pdata + len;
509 break;
510
511 default:
512 return(False);
513 }
514
515
516 if (PTR_DIFF(p,pdata) > space_remaining) {
517 /* Move the dirptr back to prev_dirpos */
518 SeekDir(Connections[cnum].dirptr, prev_dirpos);
519 *out_of_space = True;
520 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
521 return False; /* Not finished - just out of space */
522 }
523
524 /* Setup the last_filename pointer, as an offset from base_data */
525 *last_name_off = PTR_DIFF(nameptr,base_data);
526 /* Advance the data pointer to the next slot */
527 *ppdata = p;
528 return(found);
529 }
530
531 /****************************************************************************
532 reply to a TRANS2_FINDFIRST
533 ****************************************************************************/
534 static int call_trans2findfirst(char *inbuf, char *outbuf, int bufsize, int cnum,
535 char **pparams, char **ppdata)
536 {
537 /* We must be careful here that we don't return more than the
538 allowed number of data bytes. If this means returning fewer than
539 maxentries then so be it. We assume that the redirector has
540 enough room for the fixed number of parameter bytes it has
541 requested. */
542 uint32 max_data_bytes = SVAL(inbuf, smb_mdrcnt);
543 char *params = *pparams;
544 char *pdata = *ppdata;
545 int dirtype = SVAL(params,0);
546 int maxentries = SVAL(params,2);
547 BOOL close_after_first = BITSETW(params+4,0);
548 BOOL close_if_end = BITSETW(params+4,1);
549 BOOL requires_resume_key = BITSETW(params+4,2);
550 int info_level = SVAL(params,6);
551 pstring directory;
552 pstring mask;
553 char *p, *wcard;
554 int last_name_off=0;
555 int dptr_num = -1;
556 int numentries = 0;
557 int i;
558 BOOL finished = False;
559 BOOL dont_descend = False;
560 BOOL out_of_space = False;
561 int space_remaining;
562
563 *directory = *mask = 0;
564
565 DEBUG(3,("call_trans2findfirst: dirtype = %d, maxentries = %d, close_after_first=%d, close_if_end = %d requires_resume_key = %d level = %d, max_data_bytes = %d\n",
566 dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
567 info_level, max_data_bytes));
568
569 switch (info_level)
570 {
571 case 1:
572 case 2:
573 case 3:
574 case 4:
575 case SMB_FIND_FILE_DIRECTORY_INFO:
576 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
577 case SMB_FIND_FILE_NAMES_INFO:
578 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
579 break;
580 default:
581 return(ERROR(ERRDOS,ERRunknownlevel));
582 }
583
584 strcpy(directory, params + 12); /* Complete directory path with
585 wildcard mask appended */
586
587 DEBUG(5,("path=%s\n",directory));
588
589 unix_convert(directory,cnum,0);
590 if(!check_name(directory,cnum)) {
591 return(ERROR(ERRDOS,ERRbadpath));
592 }
593
594 p = strrchr(directory,'/');
595 if(p == NULL) {
596 strcpy(mask,directory);
597 strcpy(directory,"./");
598 } else {
599 strcpy(mask,p+1);
600 *p = 0;
601 }
602
603 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
604
605 pdata = *ppdata = Realloc(*ppdata, max_data_bytes + 1024);
606 if(!*ppdata)
607 return(ERROR(ERRDOS,ERRnomem));
608 bzero(pdata,max_data_bytes);
609
610 /* Realloc the params space */
611 params = *pparams = Realloc(*pparams, 10);
612 if(params == NULL)
613 return(ERROR(ERRDOS,ERRnomem));
614
615 dptr_num = dptr_create(cnum,directory, True ,SVAL(inbuf,smb_pid));
616 if (dptr_num < 0)
617 return(ERROR(ERRDOS,ERRbadpath));
618
619 /* convert the formatted masks */
620 {
621 p = mask;
622 while (*p) {
623 if (*p == '<') *p = '*';
624 if (*p == '>') *p = '?';
625 if (*p == '"') *p = '.';
626 p++;
627 }
628 }
629
630 /* a special case for 16 bit apps */
631 if (strequal(mask,"????????.???")) strcpy(mask,"*");
632
633 /* handle broken clients that send us old 8.3 format */
634 string_sub(mask,"????????","*");
635 string_sub(mask,".???",".*");
636
637 /* Save the wildcard match and attribs we are using on this directory -
638 needed as lanman2 assumes these are being saved between calls */
639
640 if(!(wcard = strdup(mask))) {
641 dptr_close(dptr_num);
642 return(ERROR(ERRDOS,ERRnomem));
643 }
644
645 dptr_set_wcard(dptr_num, wcard);
646 dptr_set_attr(dptr_num, dirtype);
647
648 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n",dptr_num, wcard, dirtype));
649
650 /* We don't need to check for VOL here as this is returned by
651 a different TRANS2 call. */
652
653 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
654 Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum))));
655 if (in_list(Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum)),case_sensitive))
656 dont_descend = True;
657
658 p = pdata;
659 space_remaining = max_data_bytes;
660 out_of_space = False;
661
662 for (i=0;(i<maxentries) && !finished && !out_of_space;i++)
663 {
664
665 /* this is a heuristic to avoid seeking the dirptr except when
666 absolutely necessary. It allows for a filename of about 40 chars */
667 if (space_remaining < DIRLEN_GUESS && numentries > 0)
668 {
669 out_of_space = True;
670 finished = False;
671 }
672 else
673 {
674 finished =
675 !get_lanman2_dir_entry(cnum,mask,dirtype,info_level,
676 requires_resume_key,dont_descend,
677 &p,pdata,space_remaining, &out_of_space,
678 &last_name_off);
679 }
680
681 if (finished && out_of_space)
682 finished = False;
683
684 if (!finished && !out_of_space)
685 numentries++;
686 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
687 }
688
689 /* Check if we can close the dirptr */
690 if(close_after_first || (finished && close_if_end))
691 {
692 dptr_close(dptr_num);
693 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
694 dptr_num = -1;
695 }
696
697 /* At this point pdata points to numentries directory entries. */
698
699 /* Set up the return parameter block */
700 SSVAL(params,0,dptr_num);
701 SSVAL(params,2,numentries);
702 SSVAL(params,4,finished);
703 SSVAL(params,6,0); /* Never an EA error */
704 SSVAL(params,8,last_name_off);
705
706 send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata));
707
708 if ((! *directory) && dptr_path(dptr_num))
709 sprintf(directory,"(%s)",dptr_path(dptr_num));
710
711 DEBUG(4,("%s %s mask=%s directory=%s cnum=%d dirtype=%d numentries=%d\n",
712 timestring(),
713 smb_fn_name(CVAL(inbuf,smb_com)),
714 mask,directory,cnum,dirtype,numentries));
715
716 return(-1);
717 }
718
719
720 /****************************************************************************
721 reply to a TRANS2_FINDNEXT
722 ****************************************************************************/
723 static int call_trans2findnext(char *inbuf, char *outbuf, int length, int bufsize,
724 int cnum, char **pparams, char **ppdata)
725 {
726 /* We must be careful here that we don't return more than the
727 allowed number of data bytes. If this means returning fewer than
728 maxentries then so be it. We assume that the redirector has
729 enough room for the fixed number of parameter bytes it has
730 requested. */
731 int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
732 char *params = *pparams;
733 char *pdata = *ppdata;
734 int16 dptr_num = SVAL(params,0);
735 int maxentries = SVAL(params,2);
736 uint16 info_level = SVAL(params,4);
737 uint32 resume_key = IVAL(params,6);
738 BOOL close_after_request = BITSETW(params+10,0);
739 BOOL close_if_end = BITSETW(params+10,1);
740 BOOL requires_resume_key = BITSETW(params+10,2);
741 BOOL continue_bit = BITSETW(params+10,3);
742 pstring mask;
743 pstring directory;
744 char *p;
745 uint16 dirtype;
746 int numentries = 0;
747 int i, last_name_off=0;
748 BOOL finished = False;
749 BOOL dont_descend = False;
750 BOOL out_of_space = False;
751 int space_remaining;
752
753 *mask = *directory = 0;
754
755 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, close_after_request=%d, close_if_end = %d requires_resume_key = %d resume_key = %d continue=%d level = %d\n",
756 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
757 requires_resume_key, resume_key, continue_bit, info_level));
758
759 switch (info_level)
760 {
761 case 1:
762 case 2:
763 case 3:
764 case 4:
765 case SMB_FIND_FILE_DIRECTORY_INFO:
766 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
767 case SMB_FIND_FILE_NAMES_INFO:
768 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
769 break;
770 default:
771 return(ERROR(ERRDOS,ERRunknownlevel));
772 }
773
774 pdata = *ppdata = Realloc( *ppdata, max_data_bytes + 1024);
775 if(!*ppdata)
776 return(ERROR(ERRDOS,ERRnomem));
777 bzero(pdata,max_data_bytes);
778
779 /* Realloc the params space */
780 params = *pparams = Realloc(*pparams, 6*SIZEOFWORD);
781 if(!params)
782 return(ERROR(ERRDOS,ERRnomem));
783
784 /* Check that the dptr is valid */
785 if(!(Connections[cnum].dirptr = dptr_fetch_lanman2(SNUM(cnum), params, dptr_num)))
786 return(ERROR(ERRDOS,ERRnofiles));
787
788 string_set(&Connections[cnum].dirpath,dptr_path(dptr_num));
789
790 /* Get the wildcard mask from the dptr */
791 if((p = dptr_wcard(dptr_num))== NULL) {
792 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
793 return (ERROR(ERRDOS,ERRnofiles));
794 }
795 strcpy(mask, p);
796 strcpy(directory,Connections[cnum].dirpath);
797
798 /* Get the attr mask from the dptr */
799 dirtype = dptr_attr(dptr_num);
800
801 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%X,%d)\n",
802 dptr_num, mask, dirtype,
803 Connections[cnum].dirptr,
804 TellDir(Connections[cnum].dirptr)));
805
806 /* We don't need to check for VOL here as this is returned by
807 a different TRANS2 call. */
808
809 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum))));
810 if (in_list(Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum)),case_sensitive))
811 dont_descend = True;
812
813 p = pdata;
814 space_remaining = max_data_bytes;
815 out_of_space = False;
816
817 /* If we have a resume key - seek to the correct position. */
818 if(requires_resume_key && !continue_bit)
819 SeekDir(Connections[cnum].dirptr, resume_key);
820
821 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++)
822 {
823 /* this is a heuristic to avoid seeking the dirptr except when
824 absolutely necessary. It allows for a filename of about 40 chars */
825 if (space_remaining < DIRLEN_GUESS && numentries > 0)
826 {
827 out_of_space = True;
828 finished = False;
829 }
830 else
831 {
832 finished =
833 !get_lanman2_dir_entry(cnum,mask,dirtype,info_level,
834 requires_resume_key,dont_descend,
835 &p,pdata,space_remaining, &out_of_space,
836 &last_name_off);
837 }
838
839 if (finished && out_of_space)
840 finished = False;
841
842 if (!finished && !out_of_space)
843 numentries++;
844 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
845 }
846
847 /* Check if we can close the dirptr */
848 if(close_after_request || (finished && close_if_end))
849 {
850 dptr_close(dptr_num); /* This frees up the saved mask */
851 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
852 dptr_num = -1;
853 }
854
855
856 /* Set up the return parameter block */
857 SSVAL(params,0,numentries);
858 SSVAL(params,2,finished);
859 SSVAL(params,4,0); /* Never an EA error */
860 SSVAL(params,6,last_name_off);
861
862 send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata));
863
864 if ((! *directory) && dptr_path(dptr_num))
865 sprintf(directory,"(%s)",dptr_path(dptr_num));
866
867 DEBUG(3,("%s %s mask=%s directory=%s cnum=%d dirtype=%d numentries=%d\n",
868 timestring(),
869 smb_fn_name(CVAL(inbuf,smb_com)),
870 mask,directory,cnum,dirtype,numentries));
871
872 return(-1);
873 }
874
875 /****************************************************************************
876 reply to a TRANS2_QFSINFO (query filesystem info)
877 ****************************************************************************/
878 static int call_trans2qfsinfo(char *inbuf, char *outbuf, int length, int bufsize,
879 int cnum, char **pparams, char **ppdata)
880 {
881 char *pdata = *ppdata;
882 char *params = *pparams;
883 uint16 info_level = SVAL(params,0);
884 int data_len;
885 struct stat st;
886 char *vname = volume_label(SNUM(cnum));
887
888 DEBUG(3,("call_trans2qfsinfo: cnum = %d, level = %d\n", cnum, info_level));
889
890 if(sys_stat(".",&st)!=0) {
891 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
892 return (ERROR(ERRSRV,ERRinvdevice));
893 }
894
895 pdata = *ppdata = Realloc(*ppdata, 1024); bzero(pdata,1024);
896
897 switch (info_level)
898 {
899 case 1:
900 {
901 int dfree,dsize,bsize;
902 data_len = 18;
903 sys_disk_free(".",&bsize,&dfree,&dsize);
904 SIVAL(pdata,l1_idFileSystem,st.st_dev);
905 SIVAL(pdata,l1_cSectorUnit,bsize/512);
906 SIVAL(pdata,l1_cUnit,dsize);
907 SIVAL(pdata,l1_cUnitAvail,dfree);
908 SSVAL(pdata,l1_cbSector,512);
909 DEBUG(5,("call_trans2qfsinfo : bsize=%d, id=%x, cSectorUnit=%d, cUnit=%d, cUnitAvail=%d, cbSector=%d\n",
910 bsize, st.st_dev, bsize/512, dsize, dfree, 512));
911 break;
912 }
913 case 2:
914 {
915 /* Return volume name */
916 int volname_len = MIN(strlen(vname),11);
917 data_len = l2_vol_szVolLabel + volname_len + 1;
918 put_dos_date2(pdata,l2_vol_fdateCreation,st.st_ctime);
919 SCVAL(pdata,l2_vol_cch,volname_len);
920 StrnCpy(pdata+l2_vol_szVolLabel,vname,volname_len);
921 DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",st.st_ctime, volname_len,
922 pdata+l2_vol_szVolLabel));
923 break;
924 }
925 case SMB_QUERY_FS_ATTRIBUTE_INFO:
926 data_len = 12 + 2*strlen(FSTYPE_STRING);
927 SIVAL(pdata,0,0x4006); /* FS ATTRIBUTES == long filenames supported? */
928 SIVAL(pdata,4,128); /* Max filename component length */
929 SIVAL(pdata,8,2*strlen(FSTYPE_STRING));
930 PutUniCode(pdata+12,FSTYPE_STRING);
931 break;
932 case SMB_QUERY_FS_LABEL_INFO:
933 data_len = 4 + strlen(vname);
934 SIVAL(pdata,0,strlen(vname));
935 strcpy(pdata+4,vname);
936 break;
937 case SMB_QUERY_FS_VOLUME_INFO:
938 data_len = 18 + 2*strlen(vname);
939 SIVAL(pdata,12,2*strlen(vname));
940 PutUniCode(pdata+18,vname);
941 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol = %s\n", strlen(vname),
942 vname));
943 break;
944 case SMB_QUERY_FS_SIZE_INFO:
945 {
946 int dfree,dsize,bsize;
947 data_len = 24;
948 sys_disk_free(".",&bsize,&dfree,&dsize);
949 SIVAL(pdata,0,dsize);
950 SIVAL(pdata,8,dfree);
951 SIVAL(pdata,16,bsize/512);
952 SIVAL(pdata,20,512);
953 }
954 break;
955 case SMB_QUERY_FS_DEVICE_INFO:
956 data_len = 8;
957 SIVAL(pdata,0,0); /* dev type */
958 SIVAL(pdata,4,0); /* characteristics */
959 break;
960 default:
961 return(ERROR(ERRDOS,ERRunknownlevel));
962 }
963
964
965 send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len);
966
967 DEBUG(4,("%s %s info_level =%d\n",timestring(),smb_fn_name(CVAL(inbuf,smb_com)), info_level));
968
969 return -1;
970 }
971
972 /****************************************************************************
973 reply to a TRANS2_SETFSINFO (set filesystem info)
974 ****************************************************************************/
975 static int call_trans2setfsinfo(char *inbuf, char *outbuf, int length, int bufsize,
976 int cnum, char **pparams, char **ppdata)
977 {
978 /* Just say yes we did it - there is nothing that
979 can be set here so it doesn't matter. */
980 int outsize;
981 DEBUG(3,("call_trans2setfsinfo\n"));
982
983 if (!CAN_WRITE(cnum))
984 return(ERROR(ERRSRV,ERRaccess));
985
986 outsize = set_message(outbuf,10,0,True);
987
988 return outsize;
989 }
990
991 /****************************************************************************
992 reply to a TRANS2_QFILEINFO (query file info by fileid)
993 ****************************************************************************/
994 static int call_trans2qfilepathinfo(char *inbuf, char *outbuf, int length,
995 int bufsize,int cnum,
996 char **pparams,char **ppdata,
997 int total_data)
998 {
999 char *params = *pparams;
1000 char *pdata = *ppdata;
1001 uint16 tran_call = SVAL(inbuf, smb_setup0);
1002 uint16 info_level;
1003 int mode=0;
1004 int size=0;
1005 unsigned int data_size;
1006 struct stat sbuf;
1007 pstring fname1;
1008 char *fname;
1009 char *p;
1010 int l,pos;
1011
1012
1013 if (tran_call == TRANSACT2_QFILEINFO) {
1014 int16 fnum = SVALS(params,0);
1015 info_level = SVAL(params,2);
1016
1017 CHECK_FNUM(fnum,cnum);
1018 CHECK_ERROR(fnum);
1019
1020 fname = Files[fnum].name;
1021 if (fstat(Files[fnum].fd_ptr->fd,&sbuf) != 0) {
1022 DEBUG(3,("fstat of fnum %d failed (%s)\n",fnum, strerror(errno)));
1023 return(UNIXERROR(ERRDOS,ERRbadfid));
1024 }
1025 pos = lseek(Files[fnum].fd_ptr->fd,0,SEEK_CUR);
1026 } else {
1027 /* qpathinfo */
1028 info_level = SVAL(params,0);
1029 fname = &fname1[0];
1030 strcpy(fname,&params[6]);
1031 unix_convert(fname,cnum,0);
1032 if (!check_name(fname,cnum) || sys_stat(fname,&sbuf)) {
1033 DEBUG(3,("fileinfo of %s failed (%s)\n",fname,strerror(errno)));
1034 return(UNIXERROR(ERRDOS,ERRbadpath));
1035 }
1036 pos = 0;
1037 }
1038
1039
1040 DEBUG(3,("call_trans2qfilepathinfo %s level=%d call=%d total_data=%d\n",
1041 fname,info_level,tran_call,total_data));
1042
1043 p = strrchr(fname,'/');
1044 if (!p)
1045 p = fname;
1046 else
1047 p++;
1048 l = strlen(p);
1049 mode = dos_mode(cnum,fname,&sbuf);
1050 size = sbuf.st_size;
1051 if (mode & aDIR) size = 0;
1052
1053 params = *pparams = Realloc(*pparams,2); bzero(params,2);
1054 data_size = 1024;
1055 pdata = *ppdata = Realloc(*ppdata, data_size);
1056
1057 if (total_data > 0 && IVAL(pdata,0) == total_data) {
1058 /* uggh, EAs for OS2 */
1059 DEBUG(4,("Rejecting EA request with total_data=%d\n",total_data));
1060 #if 0
1061 SSVAL(params,0,ERROR_EAS_NOT_SUPPORTED);
1062 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
1063 return(-1);
1064 #else
1065 return(ERROR(ERRDOS,ERROR_EAS_NOT_SUPPORTED));
1066 #endif
1067 }
1068
1069 bzero(pdata,data_size);
1070
1071 switch (info_level)
1072 {
1073 case SMB_INFO_STANDARD:
1074 case SMB_INFO_QUERY_EA_SIZE:
1075 data_size = (info_level==1?22:26);
1076 put_dos_date2(pdata,l1_fdateCreation,sbuf.st_ctime); /* create = inode mod */
1077 put_dos_date2(pdata,l1_fdateLastAccess,sbuf.st_atime); /* access time */
1078 put_dos_date2(pdata,l1_fdateLastWrite,sbuf.st_mtime); /* write time */
1079 SIVAL(pdata,l1_cbFile,size);
1080 SIVAL(pdata,l1_cbFileAlloc,ROUNDUP(size,1024));
1081 SSVAL(pdata,l1_attrFile,mode);
1082 SIVAL(pdata,l1_attrFile+2,4); /* this is what OS2 does */
1083 break;
1084
1085 case SMB_INFO_QUERY_EAS_FROM_LIST:
1086 data_size = 24;
1087 put_dos_date2(pdata,0,sbuf.st_ctime); /* create time = inode mod time */
1088 put_dos_date2(pdata,4,sbuf.st_atime);
1089 put_dos_date2(pdata,8,sbuf.st_mtime);
1090 SIVAL(pdata,12,size);
1091 SIVAL(pdata,16,ROUNDUP(size,1024));
1092 SIVAL(pdata,20,mode);
1093 break;
1094
1095 case SMB_INFO_QUERY_ALL_EAS:
1096 data_size = 4;
1097 SIVAL(pdata,0,data_size);
1098 break;
1099
1100 case 6:
1101 return(ERROR(ERRDOS,ERRbadfunc)); /* os/2 needs this */
1102
1103 case SMB_QUERY_FILE_BASIC_INFO:
1104 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
1105 put_long_date(pdata,sbuf.st_ctime); /* create time = inode mod time */
1106 put_long_date(pdata+8,sbuf.st_atime); /* access time */
1107 put_long_date(pdata+16,sbuf.st_mtime); /* write time */
1108 put_long_date(pdata+24,sbuf.st_mtime); /* change time */
1109 SIVAL(pdata,32,mode);
1110
1111 DEBUG(5,("SMB_QFBI - "));
1112 DEBUG(5,("create: %s ", ctime(&sbuf.st_ctime)));
1113 DEBUG(5,("access: %s ", ctime(&sbuf.st_atime)));
1114 DEBUG(5,("write: %s ", ctime(&sbuf.st_mtime)));
1115 DEBUG(5,("change: %s ", ctime(&sbuf.st_mtime)));
1116 DEBUG(5,("mode: %x\n", mode));
1117
1118 break;
1119
1120 case SMB_QUERY_FILE_STANDARD_INFO:
1121 data_size = 22;
1122 SIVAL(pdata,0,size);
1123 SIVAL(pdata,8,size);
1124 SIVAL(pdata,16,sbuf.st_nlink);
1125 CVAL(pdata,20) = 0;
1126 CVAL(pdata,21) = (mode&aDIR)?1:0;
1127 break;
1128
1129 case SMB_QUERY_FILE_EA_INFO:
1130 data_size = 4;
1131 break;
1132
1133 case SMB_QUERY_FILE_NAME_INFO:
1134 case SMB_QUERY_FILE_ALT_NAME_INFO:
1135 data_size = 4 + l;
1136 SIVAL(pdata,0,l);
1137 strcpy(pdata+4,fname);
1138 break;
1139 case SMB_QUERY_FILE_ALLOCATION_INFO:
1140 case SMB_QUERY_FILE_END_OF_FILEINFO:
1141 data_size = 8;
1142 SIVAL(pdata,0,size);
1143 break;
1144
1145 case SMB_QUERY_FILE_ALL_INFO:
1146 put_long_date(pdata,sbuf.st_ctime); /* create time = inode mod time */
1147 put_long_date(pdata+8,sbuf.st_atime); /* access time */
1148 put_long_date(pdata+16,sbuf.st_mtime); /* write time */
1149 put_long_date(pdata+24,sbuf.st_mtime); /* change time */
1150 SIVAL(pdata,32,mode);
1151 pdata += 40;
1152 SIVAL(pdata,0,size);
1153 SIVAL(pdata,8,size);
1154 SIVAL(pdata,16,sbuf.st_nlink);
1155 CVAL(pdata,20) = 0;
1156 CVAL(pdata,21) = (mode&aDIR)?1:0;
1157 pdata += 24;
1158 pdata += 8; /* index number */
1159 pdata += 4; /* EA info */
1160 if (mode & aRONLY)
1161 SIVAL(pdata,0,0xA9);
1162 else
1163 SIVAL(pdata,0,0xd01BF);
1164 pdata += 4;
1165 SIVAL(pdata,0,pos); /* current offset */
1166 pdata += 8;
1167 SIVAL(pdata,0,mode); /* is this the right sort of mode info? */
1168 pdata += 4;
1169 pdata += 4; /* alignment */
1170 SIVAL(pdata,0,l);
1171 strcpy(pdata+4,fname);
1172 pdata += 4 + l;
1173 data_size = PTR_DIFF(pdata,(*ppdata));
1174 break;
1175
1176 case SMB_QUERY_FILE_STREAM_INFO:
1177 data_size = 24 + l;
1178 SIVAL(pdata,0,pos);
1179 SIVAL(pdata,4,size);
1180 SIVAL(pdata,12,size);
1181 SIVAL(pdata,20,l);
1182 strcpy(pdata+24,fname);
1183 break;
1184 default:
1185 return(ERROR(ERRDOS,ERRunknownlevel));
1186 }
1187
1188 send_trans2_replies( outbuf, bufsize, params, 2, *ppdata, data_size);
1189
1190 return(-1);
1191 }
1192
1193 /****************************************************************************
1194 reply to a TRANS2_SETFILEINFO (set file info by fileid)
1195 ****************************************************************************/
1196 static int call_trans2setfilepathinfo(char *inbuf, char *outbuf, int length,
1197 int bufsize, int cnum, char **pparams,
1198 char **ppdata, int total_data)
1199 {
1200 char *params = *pparams;
1201 char *pdata = *ppdata;
1202 uint16 tran_call = SVAL(inbuf, smb_setup0);
1203 uint16 info_level;
1204 int mode=0;
1205 int size=0;
1206 struct utimbuf tvs;
1207 struct stat st;
1208 pstring fname1;
1209 char *fname;
1210 int fd = -1;
1211
1212 if (!CAN_WRITE(cnum))
1213 return(ERROR(ERRSRV,ERRaccess));
1214
1215 if (tran_call == TRANSACT2_SETFILEINFO) {
1216 int16 fnum = SVALS(params,0);
1217 info_level = SVAL(params,2);
1218
1219 CHECK_FNUM(fnum,cnum);
1220 CHECK_ERROR(fnum);
1221
1222 fname = Files[fnum].name;
1223 fd = Files[fnum].fd_ptr->fd;
1224
1225 if(fstat(fd,&st)!=0) {
1226 DEBUG(3,("fstat of %s failed (%s)\n", fname, strerror(errno)));
1227 return(ERROR(ERRDOS,ERRbadpath));
1228 }
1229 } else {
1230 /* set path info */
1231 info_level = SVAL(params,0);
1232 fname = fname1;
1233 strcpy(fname,&params[6]);
1234 unix_convert(fname,cnum,0);
1235 if(!check_name(fname, cnum))
1236 return(ERROR(ERRDOS,ERRbadpath));
1237
1238 if(sys_stat(fname,&st)!=0) {
1239 DEBUG(3,("stat of %s failed (%s)\n", fname, strerror(errno)));
1240 return(ERROR(ERRDOS,ERRbadpath));
1241 }
1242 }
1243
1244 DEBUG(3,("call_trans2setfilepathinfo(%d) %s info_level=%d totdata=%d\n",
1245 tran_call,fname,info_level,total_data));
1246
1247 /* Realloc the parameter and data sizes */
1248 params = *pparams = Realloc(*pparams,2); SSVAL(params,0,0);
1249 if(params == NULL)
1250 return(ERROR(ERRDOS,ERRnomem));
1251
1252 size = st.st_size;
1253 tvs.modtime = st.st_mtime;
1254 tvs.actime = st.st_atime;
1255 mode = dos_mode(cnum,fname,&st);
1256
1257 if (total_data > 0 && IVAL(pdata,0) == total_data) {
1258 /* uggh, EAs for OS2 */
1259 DEBUG(4,("Rejecting EA request with total_data=%d\n",total_data));
1260 SSVAL(params,0,ERROR_EAS_NOT_SUPPORTED);
1261
1262 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
1263
1264 return(-1);
1265 }
1266
1267 switch (info_level)
1268 {
1269 case SMB_INFO_STANDARD:
1270 case SMB_INFO_QUERY_EA_SIZE:
1271 {
1272 /* access time */
1273 tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
1274
1275 /* write time */
1276 tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
1277
1278 mode = SVAL(pdata,l1_attrFile);
1279 size = IVAL(pdata,l1_cbFile);
1280 break;
1281 }
1282
1283 /* XXXX um, i don't think this is right.
1284 it's also not in the cifs6.txt spec.
1285 */
1286 case SMB_INFO_QUERY_EAS_FROM_LIST:
1287 tvs.actime = make_unix_date2(pdata+8);
1288 tvs.modtime = make_unix_date2(pdata+12);
1289 size = IVAL(pdata,16);
1290 mode = IVAL(pdata,24);
1291 break;
1292
1293 /* XXXX nor this. not in cifs6.txt, either. */
1294 case SMB_INFO_QUERY_ALL_EAS:
1295 tvs.actime = make_unix_date2(pdata+8);
1296 tvs.modtime = make_unix_date2(pdata+12);
1297 size = IVAL(pdata,16);
1298 mode = IVAL(pdata,24);
1299 break;
1300
1301 case SMB_SET_FILE_BASIC_INFO:
1302 {
1303 /* Ignore create time at offset pdata. */
1304
1305 /* access time */
1306 tvs.actime = interpret_long_date(pdata+8);
1307
1308 /* write time + changed time, combined. */
1309 tvs.modtime=MAX(interpret_long_date(pdata+16),
1310 interpret_long_date(pdata+24));
1311
1312 /* attributes */
1313 mode = IVAL(pdata,32);
1314 break;
1315 }
1316
1317 case SMB_SET_FILE_END_OF_FILE_INFO:
1318 {
1319 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
1320 return(ERROR(ERRDOS,ERRunknownlevel));
1321 size = IVAL(pdata,0);
1322 break;
1323 }
1324
1325 case SMB_SET_FILE_DISPOSITION_INFO: /* not supported yet */
1326 case SMB_SET_FILE_ALLOCATION_INFO: /* not supported yet */
1327 default:
1328 {
1329 return(ERROR(ERRDOS,ERRunknownlevel));
1330 }
1331 }
1332
1333 DEBUG(6,("actime: %s " , ctime(&tvs.actime)));
1334 DEBUG(6,("modtime: %s ", ctime(&tvs.modtime)));
1335 DEBUG(6,("size: %x " , size));
1336 DEBUG(6,("mode: %x\n" , mode));
1337
1338 /* get some defaults (no modifications) if any info is zero. */
1339 if (!tvs.actime) tvs.actime = st.st_atime;
1340 if (!tvs.modtime) tvs.modtime = st.st_mtime;
1341 if (!size) size = st.st_size;
1342
1343 /* Try and set the times, size and mode of this file -
1344 if they are different from the current values
1345 */
1346 if (st.st_mtime != tvs.modtime || st.st_atime != tvs.actime)
1347 {
1348 if(sys_utime(fname, &tvs)!=0)
1349 {
1350 return(ERROR(ERRDOS,ERRnoaccess));
1351 }
1352 }
1353
1354 /* check the mode isn't different, before changing it */
1355 if (mode != dos_mode(cnum, fname, &st) && dos_chmod(cnum, fname, mode, NULL))
1356 {
1357 DEBUG(2,("chmod of %s failed (%s)\n", fname, strerror(errno)));
1358 return(ERROR(ERRDOS,ERRnoaccess));
1359 }
1360
1361 if(size != st.st_size)
1362 {
1363 if (fd == -1)
1364 {
1365 fd = sys_open(fname,O_RDWR,0);
1366 if (fd == -1)
1367 {
1368 return(ERROR(ERRDOS,ERRbadpath));
1369 }
1370 set_filelen(fd, size);
1371 close(fd);
1372 }
1373 else
1374 {
1375 set_filelen(fd, size);
1376 }
1377 }
1378
1379 SSVAL(params,0,0);
1380
1381 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
1382
1383 return(-1);
1384 }
1385
1386 /****************************************************************************
1387 reply to a TRANS2_MKDIR (make directory with extended attributes).
1388 ****************************************************************************/
1389 static int call_trans2mkdir(char *inbuf, char *outbuf, int length, int bufsize,
1390 int cnum, char **pparams, char **ppdata)
1391 {
1392 char *params = *pparams;
1393 pstring directory;
1394 int ret = -1;
1395
1396 if (!CAN_WRITE(cnum))
1397 return(ERROR(ERRSRV,ERRaccess));
1398
1399 strcpy(directory, &params[4]);
1400
1401 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
1402
1403 unix_convert(directory,cnum,0);
1404 if (check_name(directory,cnum))
1405 ret = sys_mkdir(directory,unix_mode(cnum,aDIR));
1406
1407 if(ret < 0)
1408 {
1409 DEBUG(5,("call_trans2mkdir error (%s)\n", strerror(errno)));
1410 return(UNIXERROR(ERRDOS,ERRnoaccess));
1411 }
1412
1413 /* Realloc the parameter and data sizes */
1414 params = *pparams = Realloc(*pparams,2);
1415 if(params == NULL)
1416 return(ERROR(ERRDOS,ERRnomem));
1417
1418 SSVAL(params,0,0);
1419
1420 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
1421
1422 return(-1);
1423 }
1424
1425 /****************************************************************************
1426 reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes)
1427 We don't actually do this - we just send a null response.
1428 ****************************************************************************/
1429 static int call_trans2findnotifyfirst(char *inbuf, char *outbuf, int length, int bufsize,
1430 int cnum, char **pparams, char **ppdata)
1431 {
1432 static uint16 fnf_handle = 257;
1433 char *params = *pparams;
1434 uint16 info_level = SVAL(params,4);
1435
1436 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
1437
1438 switch (info_level)
1439 {
1440 case 1:
1441 case 2:
1442 break;
1443 default:
1444 return(ERROR(ERRDOS,ERRunknownlevel));
1445 }
1446
1447 /* Realloc the parameter and data sizes */
1448 params = *pparams = Realloc(*pparams,6);
1449 if(params == NULL)
1450 return(ERROR(ERRDOS,ERRnomem));
1451
1452 SSVAL(params,0,fnf_handle);
1453 SSVAL(params,2,0); /* No changes */
1454 SSVAL(params,4,0); /* No EA errors */
1455
1456 fnf_handle++;
1457
1458 if(fnf_handle == 0)
1459 fnf_handle = 257;
1460
1461 send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0);
1462
1463 return(-1);
1464 }
1465
1466 /****************************************************************************
1467 reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
1468 changes). Currently this does nothing.
1469 ****************************************************************************/
1470 static int call_trans2findnotifynext(char *inbuf, char *outbuf, int length, int bufsize,
1471 int cnum, char **pparams, char **ppdata)
1472 {
1473 char *params = *pparams;
1474
1475 DEBUG(3,("call_trans2findnotifynext\n"));
1476
1477 /* Realloc the parameter and data sizes */
1478 params = *pparams = Realloc(*pparams,4);
1479 if(params == NULL)
1480 return(ERROR(ERRDOS,ERRnomem));
1481
1482 SSVAL(params,0,0); /* No changes */
1483 SSVAL(params,2,0); /* No EA errors */
1484
1485 send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0);
1486
1487 return(-1);
1488 }
1489
1490 /****************************************************************************
1491 reply to a SMBfindclose (stop trans2 directory search)
1492 ****************************************************************************/
1493 int reply_findclose(char *inbuf,char *outbuf,int length,int bufsize)
1494 {
1495 int cnum;
1496 int outsize = 0;
1497 int16 dptr_num=SVALS(inbuf,smb_vwv0);
1498
1499 cnum = SVAL(inbuf,smb_tid);
1500
1501 DEBUG(3,("reply_findclose, cnum = %d, dptr_num = %d\n", cnum, dptr_num));
1502
1503 dptr_close(dptr_num);
1504
1505 outsize = set_message(outbuf,0,0,True);
1506
1507 DEBUG(3,("%s SMBfindclose cnum=%d, dptr_num = %d\n",timestring(),cnum,dptr_num));
1508
1509 return(outsize);
1510 }
1511
1512 /****************************************************************************
1513 reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search)
1514 ****************************************************************************/
1515 int reply_findnclose(char *inbuf,char *outbuf,int length,int bufsize)
1516 {
1517 int cnum;
1518 int outsize = 0;
1519 int dptr_num= -1;
1520
1521 cnum = SVAL(inbuf,smb_tid);
1522 dptr_num = SVAL(inbuf,smb_vwv0);
1523
1524 DEBUG(3,("reply_findnclose, cnum = %d, dptr_num = %d\n", cnum, dptr_num));
1525
1526 /* We never give out valid handles for a
1527 findnotifyfirst - so any dptr_num is ok here.
1528 Just ignore it. */
1529
1530 outsize = set_message(outbuf,0,0,True);
1531
1532 DEBUG(3,("%s SMB_findnclose cnum=%d, dptr_num = %d\n",timestring(),cnum,dptr_num));
1533
1534 return(outsize);
1535 }
1536
1537
1538 /****************************************************************************
1539 reply to a SMBtranss2 - just ignore it!
1540 ****************************************************************************/
1541 int reply_transs2(char *inbuf,char *outbuf,int length,int bufsize)
1542 {
1543 DEBUG(4,("Ignoring transs2 of length %d\n",length));
1544 return(-1);
1545 }
1546
1547 /****************************************************************************
1548 reply to a SMBtrans2
1549 ****************************************************************************/
1550 int reply_trans2(char *inbuf,char *outbuf,int length,int bufsize)
1551 {
1552 int outsize = 0;
1553 int cnum = SVAL(inbuf,smb_tid);
1554 unsigned int total_params = SVAL(inbuf, smb_tpscnt);
1555 unsigned int total_data =SVAL(inbuf, smb_tdscnt);
1556 #if 0
1557 unsigned int max_param_reply = SVAL(inbuf, smb_mprcnt);
1558 unsigned int max_data_reply = SVAL(inbuf, smb_mdrcnt);
1559 unsigned int max_setup_fields = SVAL(inbuf, smb_msrcnt);
1560 BOOL close_tid = BITSETW(inbuf+smb_flags,0);
1561 BOOL no_final_response = BITSETW(inbuf+smb_flags,1);
1562 int32 timeout = IVALS(inbuf,smb_timeout);
1563 #endif
1564 unsigned int suwcnt = SVAL(inbuf, smb_suwcnt);
1565 unsigned int tran_call = SVAL(inbuf, smb_setup0);
1566 char *params = NULL, *data = NULL;
1567 int num_params, num_params_sofar, num_data, num_data_sofar;
1568
1569 outsize = set_message(outbuf,0,0,True);
1570
1571 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
1572 is so as a sanity check */
1573 if(suwcnt != 1 )
1574 {
1575 DEBUG(2,("Invalid smb_sucnt in trans2 call\n"));
1576 return(ERROR(ERRSRV,ERRerror));
1577 }
1578
1579 /* Allocate the space for the maximum needed parameters and data */
1580 if (total_params > 0)
1581 params = (char *)malloc(total_params);
1582 if (total_data > 0)
1583 data = (char *)malloc(total_data);
1584
1585 if ((total_params && !params) || (total_data && !data))
1586 {
1587 DEBUG(2,("Out of memory in reply_trans2\n"));
1588 return(ERROR(ERRDOS,ERRnomem));
1589 }
1590
1591 /* Copy the param and data bytes sent with this request into
1592 the params buffer */
1593 num_params = num_params_sofar = SVAL(inbuf,smb_pscnt);
1594 num_data = num_data_sofar = SVAL(inbuf, smb_dscnt);
1595
1596 memcpy( params, smb_base(inbuf) + SVAL(inbuf, smb_psoff), num_params);
1597 memcpy( data, smb_base(inbuf) + SVAL(inbuf, smb_dsoff), num_data);
1598
1599 if(num_data_sofar < total_data || num_params_sofar < total_params)
1600 {
1601 /* We need to send an interim response then receive the rest
1602 of the parameter/data bytes */
1603 outsize = set_message(outbuf,0,0,True);
1604 send_smb(Client,outbuf);
1605
1606 while( num_data_sofar < total_data || num_params_sofar < total_params)
1607 {
1608 if(!receive_smb(Client,inbuf, SMB_SECONDARY_WAIT) ||
1609 CVAL(inbuf, smb_com) != SMBtranss2)
1610 {
1611 outsize = set_message(outbuf,0,0,True);
1612 DEBUG(2,("Invalid secondary trans2 packet\n"));
1613 free(params);
1614 free(data);
1615 return(ERROR(ERRSRV,ERRerror));
1616 }
1617
1618 /* Revise total_params and total_data in case they have changed downwards */
1619 total_params = SVAL(inbuf, smb_tpscnt);
1620 total_data = SVAL(inbuf, smb_tdscnt);
1621 num_params_sofar += (num_params = SVAL(inbuf,smb_spscnt));
1622 num_data_sofar += ( num_data = SVAL(inbuf, smb_sdscnt));
1623 memcpy( &params[ SVAL(inbuf, smb_spsdisp)],
1624 smb_base(inbuf) + SVAL(inbuf, smb_spsoff), num_params);
1625 memcpy( &data[SVAL(inbuf, smb_sdsdisp)],
1626 smb_base(inbuf)+ SVAL(inbuf, smb_sdsoff), num_data);
1627 }
1628 }
1629
1630 if (Protocol >= PROTOCOL_NT1) {
1631 uint16 flg2 = SVAL(outbuf,smb_flg2);
1632 SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
1633 }
1634
1635 /* Now we must call the relevant TRANS2 function */
1636 switch(tran_call)
1637 {
1638 case TRANSACT2_OPEN:
1639 outsize = call_trans2open(inbuf, outbuf, bufsize, cnum, &params, &data);
1640 break;
1641 case TRANSACT2_FINDFIRST:
1642 outsize = call_trans2findfirst(inbuf, outbuf, bufsize, cnum, &params, &data);
1643 break;
1644 case TRANSACT2_FINDNEXT:
1645 outsize = call_trans2findnext(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1646 break;
1647 case TRANSACT2_QFSINFO:
1648 outsize = call_trans2qfsinfo(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1649 break;
1650 case TRANSACT2_SETFSINFO:
1651 outsize = call_trans2setfsinfo(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1652 break;
1653 case TRANSACT2_QPATHINFO:
1654 case TRANSACT2_QFILEINFO:
1655 outsize = call_trans2qfilepathinfo(inbuf, outbuf, length, bufsize, cnum, &params, &data, total_data);
1656 break;
1657 case TRANSACT2_SETPATHINFO:
1658 case TRANSACT2_SETFILEINFO:
1659 outsize = call_trans2setfilepathinfo(inbuf, outbuf, length, bufsize, cnum, &params, &data, total_data);
1660 break;
1661 case TRANSACT2_FINDNOTIFYFIRST:
1662 outsize = call_trans2findnotifyfirst(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1663 break;
1664 case TRANSACT2_FINDNOTIFYNEXT:
1665 outsize = call_trans2findnotifynext(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1666 break;
1667 case TRANSACT2_MKDIR:
1668 outsize = call_trans2mkdir(inbuf, outbuf, length, bufsize, cnum, &params, &data);
1669 break;
1670 default:
1671 /* Error in request */
1672 DEBUG(2,("%s Unknown request %d in trans2 call\n",timestring(), tran_call));
1673 if(params)
1674 free(params);
1675 if(data)
1676 free(data);
1677 return (ERROR(ERRSRV,ERRerror));
1678 }
1679
1680 /* As we do not know how many data packets will need to be
1681 returned here the various call_trans2xxxx calls
1682 must send their own. Thus a call_trans2xxx routine only
1683 returns a value other than -1 when it wants to send
1684 an error packet.
1685 */
1686
1687 if(params)
1688 free(params);
1689 if(data)
1690 free(data);
1691 return outsize; /* If a correct response was needed the call_trans2xxx
1692 calls have already sent it. If outsize != -1 then it is
1693 returning an error packet. */
1694 }
Samba GIT mirror