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