?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r23727: Explicitly pass down FLAGS2 to srvstr_get_path.
[Samba.git] / source / smbd / trans2.c
blob15394cd8638fdec52f0ac7f15a0603dc79cbbfa2
1 /*
2 Unix SMB/CIFS implementation.
3 SMB transaction2 handling
4 Copyright (C) Jeremy Allison 1994-2007
5 Copyright (C) Stefan (metze) Metzmacher 2003
6 Copyright (C) Volker Lendecke 2005
7 Copyright (C) Steve French 2005
8 Copyright (C) James Peach 2007
9
10 Extensively modified by Andrew Tridgell, 1995
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27 #include "includes.h"
28
29 extern int max_send;
30 extern enum protocol_types Protocol;
31 extern int smb_read_error;
32 extern uint32 global_client_caps;
33 extern struct current_user current_user;
34
35 #define get_file_size(sbuf) ((sbuf).st_size)
36 #define DIR_ENTRY_SAFETY_MARGIN 4096
37
38 static char *store_file_unix_basic(connection_struct *conn,
39 char *pdata,
40 files_struct *fsp,
41 const SMB_STRUCT_STAT *psbuf);
42
43 static char *store_file_unix_basic_info2(connection_struct *conn,
44 char *pdata,
45 files_struct *fsp,
46 const SMB_STRUCT_STAT *psbuf);
47
48 /********************************************************************
49 Roundup a value to the nearest allocation roundup size boundary.
50 Only do this for Windows clients.
51 ********************************************************************/
52
53 SMB_BIG_UINT smb_roundup(connection_struct *conn, SMB_BIG_UINT val)
54 {
55 SMB_BIG_UINT rval = lp_allocation_roundup_size(SNUM(conn));
56
57 /* Only roundup for Windows clients. */
58 enum remote_arch_types ra_type = get_remote_arch();
59 if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
60 val = SMB_ROUNDUP(val,rval);
61 }
62 return val;
63 }
64
65 /********************************************************************
66 Given a stat buffer return the allocated size on disk, taking into
67 account sparse files.
68 ********************************************************************/
69
70 SMB_BIG_UINT get_allocation_size(connection_struct *conn, files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
71 {
72 SMB_BIG_UINT ret;
73
74 if(S_ISDIR(sbuf->st_mode)) {
75 return 0;
76 }
77
78 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
79 ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
80 #else
81 ret = (SMB_BIG_UINT)get_file_size(*sbuf);
82 #endif
83
84 if (fsp && fsp->initial_allocation_size)
85 ret = MAX(ret,fsp->initial_allocation_size);
86
87 return smb_roundup(conn, ret);
88 }
89
90 /****************************************************************************
91 Utility functions for dealing with extended attributes.
92 ****************************************************************************/
93
94 static const char *prohibited_ea_names[] = {
95 SAMBA_POSIX_INHERITANCE_EA_NAME,
96 SAMBA_XATTR_DOS_ATTRIB,
97 NULL
98 };
99
100 /****************************************************************************
101 Refuse to allow clients to overwrite our private xattrs.
102 ****************************************************************************/
103
104 static BOOL samba_private_attr_name(const char *unix_ea_name)
105 {
106 int i;
107
108 for (i = 0; prohibited_ea_names[i]; i++) {
109 if (strequal( prohibited_ea_names[i], unix_ea_name))
110 return True;
111 }
112 return False;
113 }
114
115 /****************************************************************************
116 Get one EA value. Fill in a struct ea_struct.
117 ****************************************************************************/
118
119 static BOOL get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
120 const char *fname, char *ea_name, struct ea_struct *pea)
121 {
122 /* Get the value of this xattr. Max size is 64k. */
123 size_t attr_size = 256;
124 char *val = NULL;
125 ssize_t sizeret;
126
127 again:
128
129 val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
130 if (!val) {
131 return False;
132 }
133
134 if (fsp && fsp->fh->fd != -1) {
135 sizeret = SMB_VFS_FGETXATTR(fsp, fsp->fh->fd, ea_name, val, attr_size);
136 } else {
137 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
138 }
139
140 if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
141 attr_size = 65536;
142 goto again;
143 }
144
145 if (sizeret == -1) {
146 return False;
147 }
148
149 DEBUG(10,("get_ea_value: EA %s is of length %u: ", ea_name, (unsigned int)sizeret));
150 dump_data(10, (uint8 *)val, sizeret);
151
152 pea->flags = 0;
153 if (strnequal(ea_name, "user.", 5)) {
154 pea->name = &ea_name[5];
155 } else {
156 pea->name = ea_name;
157 }
158 pea->value.data = (unsigned char *)val;
159 pea->value.length = (size_t)sizeret;
160 return True;
161 }
162
163 /****************************************************************************
164 Return a linked list of the total EA's. Plus the total size
165 ****************************************************************************/
166
167 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
168 const char *fname, size_t *pea_total_len)
169 {
170 /* Get a list of all xattrs. Max namesize is 64k. */
171 size_t ea_namelist_size = 1024;
172 char *ea_namelist;
173 char *p;
174 ssize_t sizeret;
175 int i;
176 struct ea_list *ea_list_head = NULL;
177
178 *pea_total_len = 0;
179
180 if (!lp_ea_support(SNUM(conn))) {
181 return NULL;
182 }
183
184 for (i = 0, ea_namelist = TALLOC_ARRAY(mem_ctx, char, ea_namelist_size); i < 6;
185 ea_namelist = TALLOC_REALLOC_ARRAY(mem_ctx, ea_namelist, char, ea_namelist_size), i++) {
186
187 if (!ea_namelist) {
188 return NULL;
189 }
190
191 if (fsp && fsp->fh->fd != -1) {
192 sizeret = SMB_VFS_FLISTXATTR(fsp, fsp->fh->fd, ea_namelist, ea_namelist_size);
193 } else {
194 sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist, ea_namelist_size);
195 }
196
197 if (sizeret == -1 && errno == ERANGE) {
198 ea_namelist_size *= 2;
199 } else {
200 break;
201 }
202 }
203
204 if (sizeret == -1)
205 return NULL;
206
207 DEBUG(10,("get_ea_list_from_file: ea_namelist size = %u\n", (unsigned int)sizeret ));
208
209 if (sizeret) {
210 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
211 struct ea_list *listp;
212
213 if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
214 continue;
215
216 listp = TALLOC_P(mem_ctx, struct ea_list);
217 if (!listp)
218 return NULL;
219
220 if (!get_ea_value(mem_ctx, conn, fsp, fname, p, &listp->ea)) {
221 return NULL;
222 }
223
224 {
225 fstring dos_ea_name;
226 push_ascii_fstring(dos_ea_name, listp->ea.name);
227 *pea_total_len += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
228 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len = %u\n",
229 (unsigned int)*pea_total_len, dos_ea_name,
230 (unsigned int)listp->ea.value.length ));
231 }
232 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
233 }
234 /* Add on 4 for total length. */
235 if (*pea_total_len) {
236 *pea_total_len += 4;
237 }
238 }
239
240 DEBUG(10,("get_ea_list_from_file: total_len = %u\n", (unsigned int)*pea_total_len));
241 return ea_list_head;
242 }
243
244 /****************************************************************************
245 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
246 that was filled.
247 ****************************************************************************/
248
249 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
250 connection_struct *conn, struct ea_list *ea_list)
251 {
252 unsigned int ret_data_size = 4;
253 char *p = pdata;
254
255 SMB_ASSERT(total_data_size >= 4);
256
257 if (!lp_ea_support(SNUM(conn))) {
258 SIVAL(pdata,4,0);
259 return 4;
260 }
261
262 for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
263 size_t dos_namelen;
264 fstring dos_ea_name;
265 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
266 dos_namelen = strlen(dos_ea_name);
267 if (dos_namelen > 255 || dos_namelen == 0) {
268 break;
269 }
270 if (ea_list->ea.value.length > 65535) {
271 break;
272 }
273 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
274 break;
275 }
276
277 /* We know we have room. */
278 SCVAL(p,0,ea_list->ea.flags);
279 SCVAL(p,1,dos_namelen);
280 SSVAL(p,2,ea_list->ea.value.length);
281 fstrcpy(p+4, dos_ea_name);
282 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
283
284 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
285 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
286 }
287
288 ret_data_size = PTR_DIFF(p, pdata);
289 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
290 SIVAL(pdata,0,ret_data_size);
291 return ret_data_size;
292 }
293
294 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
295 {
296 size_t total_ea_len = 0;
297 TALLOC_CTX *mem_ctx = NULL;
298
299 if (!lp_ea_support(SNUM(conn))) {
300 return 0;
301 }
302 mem_ctx = talloc_init("estimate_ea_size");
303 (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
304 talloc_destroy(mem_ctx);
305 return total_ea_len;
306 }
307
308 /****************************************************************************
309 Ensure the EA name is case insensitive by matching any existing EA name.
310 ****************************************************************************/
311
312 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
313 {
314 size_t total_ea_len;
315 TALLOC_CTX *mem_ctx = talloc_init("canonicalize_ea_name");
316 struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
317
318 for (; ea_list; ea_list = ea_list->next) {
319 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
320 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
321 &unix_ea_name[5], ea_list->ea.name));
322 safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
323 break;
324 }
325 }
326 talloc_destroy(mem_ctx);
327 }
328
329 /****************************************************************************
330 Set or delete an extended attribute.
331 ****************************************************************************/
332
333 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname, struct ea_list *ea_list)
334 {
335 if (!lp_ea_support(SNUM(conn))) {
336 return NT_STATUS_EAS_NOT_SUPPORTED;
337 }
338
339 for (;ea_list; ea_list = ea_list->next) {
340 int ret;
341 fstring unix_ea_name;
342
343 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
344 fstrcat(unix_ea_name, ea_list->ea.name);
345
346 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
347
348 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
349
350 if (samba_private_attr_name(unix_ea_name)) {
351 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
352 return NT_STATUS_ACCESS_DENIED;
353 }
354
355 if (ea_list->ea.value.length == 0) {
356 /* Remove the attribute. */
357 if (fsp && (fsp->fh->fd != -1)) {
358 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
359 unix_ea_name, fsp->fsp_name));
360 ret = SMB_VFS_FREMOVEXATTR(fsp, fsp->fh->fd, unix_ea_name);
361 } else {
362 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
363 unix_ea_name, fname));
364 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
365 }
366 #ifdef ENOATTR
367 /* Removing a non existent attribute always succeeds. */
368 if (ret == -1 && errno == ENOATTR) {
369 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
370 unix_ea_name));
371 ret = 0;
372 }
373 #endif
374 } else {
375 if (fsp && (fsp->fh->fd != -1)) {
376 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
377 unix_ea_name, fsp->fsp_name));
378 ret = SMB_VFS_FSETXATTR(fsp, fsp->fh->fd, unix_ea_name,
379 ea_list->ea.value.data, ea_list->ea.value.length, 0);
380 } else {
381 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
382 unix_ea_name, fname));
383 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
384 ea_list->ea.value.data, ea_list->ea.value.length, 0);
385 }
386 }
387
388 if (ret == -1) {
389 #ifdef ENOTSUP
390 if (errno == ENOTSUP) {
391 return NT_STATUS_EAS_NOT_SUPPORTED;
392 }
393 #endif
394 return map_nt_error_from_unix(errno);
395 }
396
397 }
398 return NT_STATUS_OK;
399 }
400 /****************************************************************************
401 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
402 ****************************************************************************/
403
404 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
405 {
406 struct ea_list *ea_list_head = NULL;
407 size_t offset = 0;
408
409 while (offset + 2 < data_size) {
410 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
411 unsigned int namelen = CVAL(pdata,offset);
412
413 offset++; /* Go past the namelen byte. */
414
415 /* integer wrap paranioa. */
416 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
417 (offset > data_size) || (namelen > data_size) ||
418 (offset + namelen >= data_size)) {
419 break;
420 }
421 /* Ensure the name is null terminated. */
422 if (pdata[offset + namelen] != '\0') {
423 return NULL;
424 }
425 pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset]);
426 if (!eal->ea.name) {
427 return NULL;
428 }
429
430 offset += (namelen + 1); /* Go past the name + terminating zero. */
431 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
432 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
433 }
434
435 return ea_list_head;
436 }
437
438 /****************************************************************************
439 Read one EA list entry from the buffer.
440 ****************************************************************************/
441
442 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
443 {
444 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
445 uint16 val_len;
446 unsigned int namelen;
447
448 if (!eal) {
449 return NULL;
450 }
451
452 if (data_size < 6) {
453 return NULL;
454 }
455
456 eal->ea.flags = CVAL(pdata,0);
457 namelen = CVAL(pdata,1);
458 val_len = SVAL(pdata,2);
459
460 if (4 + namelen + 1 + val_len > data_size) {
461 return NULL;
462 }
463
464 /* Ensure the name is null terminated. */
465 if (pdata[namelen + 4] != '\0') {
466 return NULL;
467 }
468 pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4);
469 if (!eal->ea.name) {
470 return NULL;
471 }
472
473 eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
474 if (!eal->ea.value.data) {
475 return NULL;
476 }
477
478 memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
479
480 /* Ensure we're null terminated just in case we print the value. */
481 eal->ea.value.data[val_len] = '\0';
482 /* But don't count the null. */
483 eal->ea.value.length--;
484
485 if (pbytes_used) {
486 *pbytes_used = 4 + namelen + 1 + val_len;
487 }
488
489 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
490 dump_data(10, eal->ea.value.data, eal->ea.value.length);
491
492 return eal;
493 }
494
495 /****************************************************************************
496 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
497 ****************************************************************************/
498
499 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
500 {
501 struct ea_list *ea_list_head = NULL;
502 size_t offset = 0;
503 size_t bytes_used = 0;
504
505 while (offset < data_size) {
506 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
507
508 if (!eal) {
509 return NULL;
510 }
511
512 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
513 offset += bytes_used;
514 }
515
516 return ea_list_head;
517 }
518
519 /****************************************************************************
520 Count the total EA size needed.
521 ****************************************************************************/
522
523 static size_t ea_list_size(struct ea_list *ealist)
524 {
525 fstring dos_ea_name;
526 struct ea_list *listp;
527 size_t ret = 0;
528
529 for (listp = ealist; listp; listp = listp->next) {
530 push_ascii_fstring(dos_ea_name, listp->ea.name);
531 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
532 }
533 /* Add on 4 for total length. */
534 if (ret) {
535 ret += 4;
536 }
537
538 return ret;
539 }
540
541 /****************************************************************************
542 Return a union of EA's from a file list and a list of names.
543 The TALLOC context for the two lists *MUST* be identical as we steal
544 memory from one list to add to another. JRA.
545 ****************************************************************************/
546
547 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
548 {
549 struct ea_list *nlistp, *flistp;
550
551 for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
552 for (flistp = file_list; flistp; flistp = flistp->next) {
553 if (strequal(nlistp->ea.name, flistp->ea.name)) {
554 break;
555 }
556 }
557
558 if (flistp) {
559 /* Copy the data from this entry. */
560 nlistp->ea.flags = flistp->ea.flags;
561 nlistp->ea.value = flistp->ea.value;
562 } else {
563 /* Null entry. */
564 nlistp->ea.flags = 0;
565 ZERO_STRUCT(nlistp->ea.value);
566 }
567 }
568
569 *total_ea_len = ea_list_size(name_list);
570 return name_list;
571 }
572
573 /****************************************************************************
574 Send the required number of replies back.
575 We assume all fields other than the data fields are
576 set correctly for the type of call.
577 HACK ! Always assumes smb_setup field is zero.
578 ****************************************************************************/
579
580 int send_trans2_replies(const char *inbuf,
581 char *outbuf,
582 int bufsize,
583 const char *params,
584 int paramsize,
585 const char *pdata,
586 int datasize,
587 int max_data_bytes)
588 {
589 /* As we are using a protocol > LANMAN1 then the max_send
590 variable must have been set in the sessetupX call.
591 This takes precedence over the max_xmit field in the
592 global struct. These different max_xmit variables should
593 be merged as this is now too confusing */
594
595 int data_to_send = datasize;
596 int params_to_send = paramsize;
597 int useable_space;
598 const char *pp = params;
599 const char *pd = pdata;
600 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
601 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
602 int data_alignment_offset = 0;
603
604 /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
605
606 set_message(inbuf,outbuf,10,0,True);
607
608 /* Modify the data_to_send and datasize and set the error if
609 we're trying to send more than max_data_bytes. We still send
610 the part of the packet(s) that fit. Strange, but needed
611 for OS/2. */
612
613 if (max_data_bytes > 0 && datasize > max_data_bytes) {
614 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
615 max_data_bytes, datasize ));
616 datasize = data_to_send = max_data_bytes;
617 error_packet_set(outbuf,ERRDOS,ERRbufferoverflow,STATUS_BUFFER_OVERFLOW,__LINE__,__FILE__);
618 }
619
620 /* If there genuinely are no parameters or data to send just send the empty packet */
621
622 if(params_to_send == 0 && data_to_send == 0) {
623 show_msg(outbuf);
624 if (!send_smb(smbd_server_fd(),outbuf))
625 exit_server_cleanly("send_trans2_replies: send_smb failed.");
626 return 0;
627 }
628
629 /* When sending params and data ensure that both are nicely aligned */
630 /* Only do this alignment when there is also data to send - else
631 can cause NT redirector problems. */
632
633 if (((params_to_send % 4) != 0) && (data_to_send != 0))
634 data_alignment_offset = 4 - (params_to_send % 4);
635
636 /* Space is bufsize minus Netbios over TCP header minus SMB header */
637 /* The alignment_offset is to align the param bytes on an even byte
638 boundary. NT 4.0 Beta needs this to work correctly. */
639
640 useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
641
642 /* useable_space can never be more than max_send minus the alignment offset. */
643
644 useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
645
646 while (params_to_send || data_to_send) {
647 /* Calculate whether we will totally or partially fill this packet */
648
649 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
650
651 /* We can never send more than useable_space */
652 /*
653 * Note that 'useable_space' does not include the alignment offsets,
654 * but we must include the alignment offsets in the calculation of
655 * the length of the data we send over the wire, as the alignment offsets
656 * are sent here. Fix from Marc_Jacobsen@hp.com.
657 */
658
659 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
660
661 set_message(inbuf, outbuf, 10, total_sent_thistime, True);
662
663 /* Set total params and data to be sent */
664 SSVAL(outbuf,smb_tprcnt,paramsize);
665 SSVAL(outbuf,smb_tdrcnt,datasize);
666
667 /* Calculate how many parameters and data we can fit into
668 * this packet. Parameters get precedence
669 */
670
671 params_sent_thistime = MIN(params_to_send,useable_space);
672 data_sent_thistime = useable_space - params_sent_thistime;
673 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
674
675 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
676
677 /* smb_proff is the offset from the start of the SMB header to the
678 parameter bytes, however the first 4 bytes of outbuf are
679 the Netbios over TCP header. Thus use smb_base() to subtract
680 them from the calculation */
681
682 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
683
684 if(params_sent_thistime == 0)
685 SSVAL(outbuf,smb_prdisp,0);
686 else
687 /* Absolute displacement of param bytes sent in this packet */
688 SSVAL(outbuf,smb_prdisp,pp - params);
689
690 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
691 if(data_sent_thistime == 0) {
692 SSVAL(outbuf,smb_droff,0);
693 SSVAL(outbuf,smb_drdisp, 0);
694 } else {
695 /* The offset of the data bytes is the offset of the
696 parameter bytes plus the number of parameters being sent this time */
697 SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
698 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
699 SSVAL(outbuf,smb_drdisp, pd - pdata);
700 }
701
702 /* Copy the param bytes into the packet */
703
704 if(params_sent_thistime)
705 memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
706
707 /* Copy in the data bytes */
708 if(data_sent_thistime)
709 memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
710 data_alignment_offset,pd,data_sent_thistime);
711
712 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
713 params_sent_thistime, data_sent_thistime, useable_space));
714 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
715 params_to_send, data_to_send, paramsize, datasize));
716
717 /* Send the packet */
718 show_msg(outbuf);
719 if (!send_smb(smbd_server_fd(),outbuf))
720 exit_server_cleanly("send_trans2_replies: send_smb failed.");
721
722 pp += params_sent_thistime;
723 pd += data_sent_thistime;
724
725 params_to_send -= params_sent_thistime;
726 data_to_send -= data_sent_thistime;
727
728 /* Sanity check */
729 if(params_to_send < 0 || data_to_send < 0) {
730 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
731 params_to_send, data_to_send));
732 return -1;
733 }
734 }
735
736 return 0;
737 }
738
739 /****************************************************************************
740 Reply to a TRANSACT2_OPEN.
741 ****************************************************************************/
742
743 static int call_trans2open(connection_struct *conn,
744 struct smb_request *req,
745 char *inbuf, char *outbuf, int bufsize,
746 char **pparams, int total_params,
747 char **ppdata, int total_data,
748 unsigned int max_data_bytes)
749 {
750 char *params = *pparams;
751 char *pdata = *ppdata;
752 int deny_mode;
753 int32 open_attr;
754 BOOL oplock_request;
755 #if 0
756 BOOL return_additional_info;
757 int16 open_sattr;
758 time_t open_time;
759 #endif
760 int open_ofun;
761 uint32 open_size;
762 char *pname;
763 pstring fname;
764 SMB_OFF_T size=0;
765 int fattr=0,mtime=0;
766 SMB_INO_T inode = 0;
767 SMB_STRUCT_STAT sbuf;
768 int smb_action = 0;
769 files_struct *fsp;
770 struct ea_list *ea_list = NULL;
771 uint16 flags = 0;
772 NTSTATUS status;
773 uint32 access_mask;
774 uint32 share_mode;
775 uint32 create_disposition;
776 uint32 create_options = 0;
777
778 /*
779 * Ensure we have enough parameters to perform the operation.
780 */
781
782 if (total_params < 29) {
783 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
784 }
785
786 flags = SVAL(params, 0);
787 deny_mode = SVAL(params, 2);
788 open_attr = SVAL(params,6);
789 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
790 if (oplock_request) {
791 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
792 }
793
794 #if 0
795 return_additional_info = BITSETW(params,0);
796 open_sattr = SVAL(params, 4);
797 open_time = make_unix_date3(params+8);
798 #endif
799 open_ofun = SVAL(params,12);
800 open_size = IVAL(params,14);
801 pname = &params[28];
802
803 if (IS_IPC(conn)) {
804 return(ERROR_DOS(ERRSRV,ERRaccess));
805 }
806
807 srvstr_get_path(inbuf, SVAL(inbuf,smb_flg2), fname, pname,
808 sizeof(fname), total_params - 28, STR_TERMINATE,
809 &status);
810 if (!NT_STATUS_IS_OK(status)) {
811 return ERROR_NT(status);
812 }
813
814 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
815 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
816 (unsigned int)open_ofun, open_size));
817
818 /* XXXX we need to handle passed times, sattr and flags */
819
820 status = unix_convert(conn, fname, False, NULL, &sbuf);
821 if (!NT_STATUS_IS_OK(status)) {
822 return ERROR_NT(status);
823 }
824
825 status = check_name(conn, fname);
826 if (!NT_STATUS_IS_OK(status)) {
827 return ERROR_NT(status);
828 }
829
830 if (open_ofun == 0) {
831 return ERROR_NT(NT_STATUS_OBJECT_NAME_COLLISION);
832 }
833
834 if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
835 &access_mask,
836 &share_mode,
837 &create_disposition,
838 &create_options)) {
839 return ERROR_DOS(ERRDOS, ERRbadaccess);
840 }
841
842 /* Any data in this call is an EA list. */
843 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
844 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
845 }
846
847 if (total_data != 4) {
848 if (total_data < 10) {
849 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
850 }
851
852 if (IVAL(pdata,0) > total_data) {
853 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
854 IVAL(pdata,0), (unsigned int)total_data));
855 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
856 }
857
858 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
859 total_data - 4);
860 if (!ea_list) {
861 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
862 }
863 } else if (IVAL(pdata,0) != 4) {
864 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
865 }
866
867 status = open_file_ntcreate(conn, req, fname, &sbuf,
868 access_mask,
869 share_mode,
870 create_disposition,
871 create_options,
872 open_attr,
873 oplock_request,
874 &smb_action, &fsp);
875
876 if (!NT_STATUS_IS_OK(status)) {
877 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
878 /* We have re-scheduled this call. */
879 return -1;
880 }
881 return ERROR_NT(status);
882 }
883
884 size = get_file_size(sbuf);
885 fattr = dos_mode(conn,fname,&sbuf);
886 mtime = sbuf.st_mtime;
887 inode = sbuf.st_ino;
888 if (fattr & aDIR) {
889 close_file(fsp,ERROR_CLOSE);
890 return(ERROR_DOS(ERRDOS,ERRnoaccess));
891 }
892
893 /* Save the requested allocation size. */
894 /* Allocate space for the file if a size hint is supplied */
895 if ((smb_action == FILE_WAS_CREATED) || (smb_action == FILE_WAS_OVERWRITTEN)) {
896 SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)open_size;
897 if (allocation_size && (allocation_size > (SMB_BIG_UINT)size)) {
898 fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
899 if (fsp->is_directory) {
900 close_file(fsp,ERROR_CLOSE);
901 /* Can't set allocation size on a directory. */
902 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
903 }
904 if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
905 close_file(fsp,ERROR_CLOSE);
906 return ERROR_NT(NT_STATUS_DISK_FULL);
907 }
908
909 /* Adjust size here to return the right size in the reply.
910 Windows does it this way. */
911 size = fsp->initial_allocation_size;
912 } else {
913 fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)size);
914 }
915 }
916
917 if (ea_list && smb_action == FILE_WAS_CREATED) {
918 status = set_ea(conn, fsp, fname, ea_list);
919 if (!NT_STATUS_IS_OK(status)) {
920 close_file(fsp,ERROR_CLOSE);
921 return ERROR_NT(status);
922 }
923 }
924
925 /* Realloc the size of parameters and data we will return */
926 *pparams = (char *)SMB_REALLOC(*pparams, 30);
927 if(*pparams == NULL ) {
928 return ERROR_NT(NT_STATUS_NO_MEMORY);
929 }
930 params = *pparams;
931
932 SSVAL(params,0,fsp->fnum);
933 SSVAL(params,2,fattr);
934 srv_put_dos_date2(params,4, mtime);
935 SIVAL(params,8, (uint32)size);
936 SSVAL(params,12,deny_mode);
937 SSVAL(params,14,0); /* open_type - file or directory. */
938 SSVAL(params,16,0); /* open_state - only valid for IPC device. */
939
940 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
941 smb_action |= EXTENDED_OPLOCK_GRANTED;
942 }
943
944 SSVAL(params,18,smb_action);
945
946 /*
947 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
948 */
949 SIVAL(params,20,inode);
950 SSVAL(params,24,0); /* Padding. */
951 if (flags & 8) {
952 uint32 ea_size = estimate_ea_size(conn, fsp, fname);
953 SIVAL(params, 26, ea_size);
954 } else {
955 SIVAL(params, 26, 0);
956 }
957
958 /* Send the required number of replies */
959 send_trans2_replies(inbuf, outbuf, bufsize, params, 30, *ppdata, 0, max_data_bytes);
960
961 return -1;
962 }
963
964 /*********************************************************
965 Routine to check if a given string matches exactly.
966 as a special case a mask of "." does NOT match. That
967 is required for correct wildcard semantics
968 Case can be significant or not.
969 **********************************************************/
970
971 static BOOL exact_match(connection_struct *conn, char *str, char *mask)
972 {
973 if (mask[0] == '.' && mask[1] == 0)
974 return False;
975 if (conn->case_sensitive)
976 return strcmp(str,mask)==0;
977 if (StrCaseCmp(str,mask) != 0) {
978 return False;
979 }
980 if (dptr_has_wild(conn->dirptr)) {
981 return False;
982 }
983 return True;
984 }
985
986 /****************************************************************************
987 Return the filetype for UNIX extensions.
988 ****************************************************************************/
989
990 static uint32 unix_filetype(mode_t mode)
991 {
992 if(S_ISREG(mode))
993 return UNIX_TYPE_FILE;
994 else if(S_ISDIR(mode))
995 return UNIX_TYPE_DIR;
996 #ifdef S_ISLNK
997 else if(S_ISLNK(mode))
998 return UNIX_TYPE_SYMLINK;
999 #endif
1000 #ifdef S_ISCHR
1001 else if(S_ISCHR(mode))
1002 return UNIX_TYPE_CHARDEV;
1003 #endif
1004 #ifdef S_ISBLK
1005 else if(S_ISBLK(mode))
1006 return UNIX_TYPE_BLKDEV;
1007 #endif
1008 #ifdef S_ISFIFO
1009 else if(S_ISFIFO(mode))
1010 return UNIX_TYPE_FIFO;
1011 #endif
1012 #ifdef S_ISSOCK
1013 else if(S_ISSOCK(mode))
1014 return UNIX_TYPE_SOCKET;
1015 #endif
1016
1017 DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
1018 return UNIX_TYPE_UNKNOWN;
1019 }
1020
1021 /****************************************************************************
1022 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1023 ****************************************************************************/
1024
1025 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1026
1027 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1028 SMB_STRUCT_STAT *psbuf,
1029 uint32 perms,
1030 enum perm_type ptype,
1031 mode_t *ret_perms)
1032 {
1033 mode_t ret = 0;
1034
1035 if (perms == SMB_MODE_NO_CHANGE) {
1036 if (!VALID_STAT(*psbuf)) {
1037 return NT_STATUS_INVALID_PARAMETER;
1038 } else {
1039 *ret_perms = psbuf->st_mode;
1040 return NT_STATUS_OK;
1041 }
1042 }
1043
1044 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1045 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1046 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1047 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1048 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1049 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1050 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1051 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1052 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1053 #ifdef S_ISVTX
1054 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1055 #endif
1056 #ifdef S_ISGID
1057 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1058 #endif
1059 #ifdef S_ISUID
1060 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1061 #endif
1062
1063 switch (ptype) {
1064 case PERM_NEW_FILE:
1065 /* Apply mode mask */
1066 ret &= lp_create_mask(SNUM(conn));
1067 /* Add in force bits */
1068 ret |= lp_force_create_mode(SNUM(conn));
1069 break;
1070 case PERM_NEW_DIR:
1071 ret &= lp_dir_mask(SNUM(conn));
1072 /* Add in force bits */
1073 ret |= lp_force_dir_mode(SNUM(conn));
1074 break;
1075 case PERM_EXISTING_FILE:
1076 /* Apply mode mask */
1077 ret &= lp_security_mask(SNUM(conn));
1078 /* Add in force bits */
1079 ret |= lp_force_security_mode(SNUM(conn));
1080 break;
1081 case PERM_EXISTING_DIR:
1082 /* Apply mode mask */
1083 ret &= lp_dir_security_mask(SNUM(conn));
1084 /* Add in force bits */
1085 ret |= lp_force_dir_security_mode(SNUM(conn));
1086 break;
1087 }
1088
1089 *ret_perms = ret;
1090 return NT_STATUS_OK;
1091 }
1092
1093 /****************************************************************************
1094 Get a level dependent lanman2 dir entry.
1095 ****************************************************************************/
1096
1097 static BOOL get_lanman2_dir_entry(connection_struct *conn,
1098 void *inbuf, char *outbuf,
1099 char *path_mask,uint32 dirtype,int info_level,
1100 int requires_resume_key,
1101 BOOL dont_descend,char **ppdata,
1102 char *base_data, int space_remaining,
1103 BOOL *out_of_space, BOOL *got_exact_match,
1104 int *last_entry_off, struct ea_list *name_list, TALLOC_CTX *ea_ctx)
1105 {
1106 const char *dname;
1107 BOOL found = False;
1108 SMB_STRUCT_STAT sbuf;
1109 pstring mask;
1110 pstring pathreal;
1111 pstring fname;
1112 char *p, *q, *pdata = *ppdata;
1113 uint32 reskey=0;
1114 long prev_dirpos=0;
1115 uint32 mode=0;
1116 SMB_OFF_T file_size = 0;
1117 SMB_BIG_UINT allocation_size = 0;
1118 uint32 len;
1119 struct timespec mdate_ts, adate_ts, create_date_ts;
1120 time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1121 char *nameptr;
1122 char *last_entry_ptr;
1123 BOOL was_8_3;
1124 uint32 nt_extmode; /* Used for NT connections instead of mode */
1125 BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1126 BOOL check_mangled_names = lp_manglednames(conn->params);
1127
1128 *fname = 0;
1129 *out_of_space = False;
1130 *got_exact_match = False;
1131
1132 ZERO_STRUCT(mdate_ts);
1133 ZERO_STRUCT(adate_ts);
1134 ZERO_STRUCT(create_date_ts);
1135
1136 if (!conn->dirptr)
1137 return(False);
1138
1139 p = strrchr_m(path_mask,'/');
1140 if(p != NULL) {
1141 if(p[1] == '\0')
1142 pstrcpy(mask,"*.*");
1143 else
1144 pstrcpy(mask, p+1);
1145 } else
1146 pstrcpy(mask, path_mask);
1147
1148
1149 while (!found) {
1150 BOOL got_match;
1151 BOOL ms_dfs_link = False;
1152
1153 /* Needed if we run out of space */
1154 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1155 dname = dptr_ReadDirName(conn->dirptr,&curr_dirpos,&sbuf);
1156
1157 /*
1158 * Due to bugs in NT client redirectors we are not using
1159 * resume keys any more - set them to zero.
1160 * Check out the related comments in findfirst/findnext.
1161 * JRA.
1162 */
1163
1164 reskey = 0;
1165
1166 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1167 (long)conn->dirptr,curr_dirpos));
1168
1169 if (!dname) {
1170 return(False);
1171 }
1172
1173 /*
1174 * fname may get mangled, dname is never mangled.
1175 * Whenever we're accessing the filesystem we use
1176 * pathreal which is composed from dname.
1177 */
1178
1179 pstrcpy(fname,dname);
1180
1181 /* This will mangle fname if it's an illegal name. */
1182 mangle_map(fname,False,True,conn->params);
1183
1184 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask))) {
1185 got_match = mask_match(fname, mask, conn->case_sensitive);
1186 }
1187
1188 if(!got_match && check_mangled_names &&
1189 !mangle_is_8_3(fname, False, conn->params)) {
1190 pstring mangled_name;
1191
1192 /*
1193 * It turns out that NT matches wildcards against
1194 * both long *and* short names. This may explain some
1195 * of the wildcard wierdness from old DOS clients
1196 * that some people have been seeing.... JRA.
1197 */
1198
1199 pstrcpy(mangled_name, fname);
1200
1201 /* Force the mangling into 8.3. */
1202 mangle_map( mangled_name, True, False, conn->params);
1203 if(!(got_match = *got_exact_match = exact_match(conn, mangled_name, mask))) {
1204 got_match = mask_match(mangled_name, mask, conn->case_sensitive);
1205 }
1206 }
1207
1208 if (got_match) {
1209 BOOL isdots = (strequal(dname,"..") || strequal(dname,"."));
1210 if (dont_descend && !isdots) {
1211 continue;
1212 }
1213
1214 pstrcpy(pathreal,conn->dirpath);
1215 if(needslash) {
1216 pstrcat(pathreal,"/");
1217 }
1218 pstrcat(pathreal,dname);
1219
1220 if (INFO_LEVEL_IS_UNIX(info_level)) {
1221 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1222 DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1223 pathreal,strerror(errno)));
1224 continue;
1225 }
1226 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1227 pstring link_target;
1228
1229 /* Needed to show the msdfs symlinks as
1230 * directories */
1231
1232 if(lp_host_msdfs() &&
1233 lp_msdfs_root(SNUM(conn)) &&
1234 ((ms_dfs_link = is_msdfs_link(conn, pathreal, link_target, &sbuf)) == True)) {
1235 DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s "
1236 "as a directory\n",
1237 pathreal));
1238 sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
1239
1240 } else {
1241
1242 DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1243 pathreal,strerror(errno)));
1244 continue;
1245 }
1246 }
1247
1248 if (ms_dfs_link) {
1249 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1250 } else {
1251 mode = dos_mode(conn,pathreal,&sbuf);
1252 }
1253
1254 if (!dir_check_ftype(conn,mode,dirtype)) {
1255 DEBUG(5,("get_lanman2_dir_entry: [%s] attribs didn't match %x\n",fname,dirtype));
1256 continue;
1257 }
1258
1259 if (!(mode & aDIR)) {
1260 file_size = get_file_size(sbuf);
1261 }
1262 allocation_size = get_allocation_size(conn,NULL,&sbuf);
1263
1264 mdate_ts = get_mtimespec(&sbuf);
1265 adate_ts = get_atimespec(&sbuf);
1266 create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1267
1268 if (lp_dos_filetime_resolution(SNUM(conn))) {
1269 dos_filetime_timespec(&create_date_ts);
1270 dos_filetime_timespec(&mdate_ts);
1271 dos_filetime_timespec(&adate_ts);
1272 }
1273
1274 create_date = convert_timespec_to_time_t(create_date_ts);
1275 mdate = convert_timespec_to_time_t(mdate_ts);
1276 adate = convert_timespec_to_time_t(adate_ts);
1277
1278 DEBUG(5,("get_lanman2_dir_entry: found %s fname=%s\n",pathreal,fname));
1279
1280 found = True;
1281
1282 dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1283 }
1284 }
1285
1286 p = pdata;
1287 last_entry_ptr = p;
1288
1289 nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1290
1291 switch (info_level) {
1292 case SMB_FIND_INFO_STANDARD:
1293 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1294 if(requires_resume_key) {
1295 SIVAL(p,0,reskey);
1296 p += 4;
1297 }
1298 srv_put_dos_date2(p,0,create_date);
1299 srv_put_dos_date2(p,4,adate);
1300 srv_put_dos_date2(p,8,mdate);
1301 SIVAL(p,12,(uint32)file_size);
1302 SIVAL(p,16,(uint32)allocation_size);
1303 SSVAL(p,20,mode);
1304 p += 23;
1305 nameptr = p;
1306 p += align_string(outbuf, p, 0);
1307 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1308 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1309 if (len > 2) {
1310 SCVAL(nameptr, -1, len - 2);
1311 } else {
1312 SCVAL(nameptr, -1, 0);
1313 }
1314 } else {
1315 if (len > 1) {
1316 SCVAL(nameptr, -1, len - 1);
1317 } else {
1318 SCVAL(nameptr, -1, 0);
1319 }
1320 }
1321 p += len;
1322 break;
1323
1324 case SMB_FIND_EA_SIZE:
1325 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1326 if(requires_resume_key) {
1327 SIVAL(p,0,reskey);
1328 p += 4;
1329 }
1330 srv_put_dos_date2(p,0,create_date);
1331 srv_put_dos_date2(p,4,adate);
1332 srv_put_dos_date2(p,8,mdate);
1333 SIVAL(p,12,(uint32)file_size);
1334 SIVAL(p,16,(uint32)allocation_size);
1335 SSVAL(p,20,mode);
1336 {
1337 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1338 SIVAL(p,22,ea_size); /* Extended attributes */
1339 }
1340 p += 27;
1341 nameptr = p - 1;
1342 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE | STR_NOALIGN);
1343 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1344 if (len > 2) {
1345 len -= 2;
1346 } else {
1347 len = 0;
1348 }
1349 } else {
1350 if (len > 1) {
1351 len -= 1;
1352 } else {
1353 len = 0;
1354 }
1355 }
1356 SCVAL(nameptr,0,len);
1357 p += len;
1358 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1359 break;
1360
1361 case SMB_FIND_EA_LIST:
1362 {
1363 struct ea_list *file_list = NULL;
1364 size_t ea_len = 0;
1365
1366 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1367 if (!name_list) {
1368 return False;
1369 }
1370 if(requires_resume_key) {
1371 SIVAL(p,0,reskey);
1372 p += 4;
1373 }
1374 srv_put_dos_date2(p,0,create_date);
1375 srv_put_dos_date2(p,4,adate);
1376 srv_put_dos_date2(p,8,mdate);
1377 SIVAL(p,12,(uint32)file_size);
1378 SIVAL(p,16,(uint32)allocation_size);
1379 SSVAL(p,20,mode);
1380 p += 22; /* p now points to the EA area. */
1381
1382 file_list = get_ea_list_from_file(ea_ctx, conn, NULL, pathreal, &ea_len);
1383 name_list = ea_list_union(name_list, file_list, &ea_len);
1384
1385 /* We need to determine if this entry will fit in the space available. */
1386 /* Max string size is 255 bytes. */
1387 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1388 /* Move the dirptr back to prev_dirpos */
1389 dptr_SeekDir(conn->dirptr, prev_dirpos);
1390 *out_of_space = True;
1391 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1392 return False; /* Not finished - just out of space */
1393 }
1394
1395 /* Push the ea_data followed by the name. */
1396 p += fill_ea_buffer(ea_ctx, p, space_remaining, conn, name_list);
1397 nameptr = p;
1398 len = srvstr_push(outbuf, p + 1, fname, -1, STR_TERMINATE | STR_NOALIGN);
1399 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1400 if (len > 2) {
1401 len -= 2;
1402 } else {
1403 len = 0;
1404 }
1405 } else {
1406 if (len > 1) {
1407 len -= 1;
1408 } else {
1409 len = 0;
1410 }
1411 }
1412 SCVAL(nameptr,0,len);
1413 p += len + 1;
1414 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1415 break;
1416 }
1417
1418 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1419 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1420 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1421 p += 4;
1422 SIVAL(p,0,reskey); p += 4;
1423 put_long_date_timespec(p,create_date_ts); p += 8;
1424 put_long_date_timespec(p,adate_ts); p += 8;
1425 put_long_date_timespec(p,mdate_ts); p += 8;
1426 put_long_date_timespec(p,mdate_ts); p += 8;
1427 SOFF_T(p,0,file_size); p += 8;
1428 SOFF_T(p,0,allocation_size); p += 8;
1429 SIVAL(p,0,nt_extmode); p += 4;
1430 q = p; p += 4; /* q is placeholder for name length. */
1431 {
1432 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1433 SIVAL(p,0,ea_size); /* Extended attributes */
1434 p += 4;
1435 }
1436 /* Clear the short name buffer. This is
1437 * IMPORTANT as not doing so will trigger
1438 * a Win2k client bug. JRA.
1439 */
1440 if (!was_8_3 && check_mangled_names) {
1441 pstring mangled_name;
1442 pstrcpy(mangled_name, fname);
1443 mangle_map(mangled_name,True,True,
1444 conn->params);
1445 mangled_name[12] = 0;
1446 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1447 if (len < 24) {
1448 memset(p + 2 + len,'\0',24 - len);
1449 }
1450 SSVAL(p, 0, len);
1451 } else {
1452 memset(p,'\0',26);
1453 }
1454 p += 2 + 24;
1455 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1456 SIVAL(q,0,len);
1457 p += len;
1458 SIVAL(p,0,0); /* Ensure any padding is null. */
1459 len = PTR_DIFF(p, pdata);
1460 len = (len + 3) & ~3;
1461 SIVAL(pdata,0,len);
1462 p = pdata + len;
1463 break;
1464
1465 case SMB_FIND_FILE_DIRECTORY_INFO:
1466 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1467 p += 4;
1468 SIVAL(p,0,reskey); p += 4;
1469 put_long_date_timespec(p,create_date_ts); p += 8;
1470 put_long_date_timespec(p,adate_ts); p += 8;
1471 put_long_date_timespec(p,mdate_ts); p += 8;
1472 put_long_date_timespec(p,mdate_ts); p += 8;
1473 SOFF_T(p,0,file_size); p += 8;
1474 SOFF_T(p,0,allocation_size); p += 8;
1475 SIVAL(p,0,nt_extmode); p += 4;
1476 len = srvstr_push(outbuf, p + 4, fname, -1, STR_TERMINATE_ASCII);
1477 SIVAL(p,0,len);
1478 p += 4 + len;
1479 SIVAL(p,0,0); /* Ensure any padding is null. */
1480 len = PTR_DIFF(p, pdata);
1481 len = (len + 3) & ~3;
1482 SIVAL(pdata,0,len);
1483 p = pdata + len;
1484 break;
1485
1486 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1487 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1488 p += 4;
1489 SIVAL(p,0,reskey); p += 4;
1490 put_long_date_timespec(p,create_date_ts); p += 8;
1491 put_long_date_timespec(p,adate_ts); p += 8;
1492 put_long_date_timespec(p,mdate_ts); p += 8;
1493 put_long_date_timespec(p,mdate_ts); p += 8;
1494 SOFF_T(p,0,file_size); p += 8;
1495 SOFF_T(p,0,allocation_size); p += 8;
1496 SIVAL(p,0,nt_extmode); p += 4;
1497 q = p; p += 4; /* q is placeholder for name length. */
1498 {
1499 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1500 SIVAL(p,0,ea_size); /* Extended attributes */
1501 p +=4;
1502 }
1503 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1504 SIVAL(q, 0, len);
1505 p += len;
1506
1507 SIVAL(p,0,0); /* Ensure any padding is null. */
1508 len = PTR_DIFF(p, pdata);
1509 len = (len + 3) & ~3;
1510 SIVAL(pdata,0,len);
1511 p = pdata + len;
1512 break;
1513
1514 case SMB_FIND_FILE_NAMES_INFO:
1515 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1516 p += 4;
1517 SIVAL(p,0,reskey); p += 4;
1518 p += 4;
1519 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1520 acl on a dir (tridge) */
1521 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1522 SIVAL(p, -4, len);
1523 p += len;
1524 SIVAL(p,0,0); /* Ensure any padding is null. */
1525 len = PTR_DIFF(p, pdata);
1526 len = (len + 3) & ~3;
1527 SIVAL(pdata,0,len);
1528 p = pdata + len;
1529 break;
1530
1531 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1532 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1533 p += 4;
1534 SIVAL(p,0,reskey); p += 4;
1535 put_long_date_timespec(p,create_date_ts); p += 8;
1536 put_long_date_timespec(p,adate_ts); p += 8;
1537 put_long_date_timespec(p,mdate_ts); p += 8;
1538 put_long_date_timespec(p,mdate_ts); p += 8;
1539 SOFF_T(p,0,file_size); p += 8;
1540 SOFF_T(p,0,allocation_size); p += 8;
1541 SIVAL(p,0,nt_extmode); p += 4;
1542 q = p; p += 4; /* q is placeholder for name length. */
1543 {
1544 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1545 SIVAL(p,0,ea_size); /* Extended attributes */
1546 p +=4;
1547 }
1548 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1549 SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1550 SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1551 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1552 SIVAL(q, 0, len);
1553 p += len;
1554 SIVAL(p,0,0); /* Ensure any padding is null. */
1555 len = PTR_DIFF(p, pdata);
1556 len = (len + 3) & ~3;
1557 SIVAL(pdata,0,len);
1558 p = pdata + len;
1559 break;
1560
1561 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1562 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1563 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1564 p += 4;
1565 SIVAL(p,0,reskey); p += 4;
1566 put_long_date_timespec(p,create_date_ts); p += 8;
1567 put_long_date_timespec(p,adate_ts); p += 8;
1568 put_long_date_timespec(p,mdate_ts); p += 8;
1569 put_long_date_timespec(p,mdate_ts); p += 8;
1570 SOFF_T(p,0,file_size); p += 8;
1571 SOFF_T(p,0,allocation_size); p += 8;
1572 SIVAL(p,0,nt_extmode); p += 4;
1573 q = p; p += 4; /* q is placeholder for name length */
1574 {
1575 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1576 SIVAL(p,0,ea_size); /* Extended attributes */
1577 p +=4;
1578 }
1579 /* Clear the short name buffer. This is
1580 * IMPORTANT as not doing so will trigger
1581 * a Win2k client bug. JRA.
1582 */
1583 if (!was_8_3 && check_mangled_names) {
1584 pstring mangled_name;
1585 pstrcpy(mangled_name, fname);
1586 mangle_map(mangled_name,True,True,
1587 conn->params);
1588 mangled_name[12] = 0;
1589 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1590 SSVAL(p, 0, len);
1591 if (len < 24) {
1592 memset(p + 2 + len,'\0',24 - len);
1593 }
1594 SSVAL(p, 0, len);
1595 } else {
1596 memset(p,'\0',26);
1597 }
1598 p += 26;
1599 SSVAL(p,0,0); p += 2; /* Reserved ? */
1600 SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1601 SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1602 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1603 SIVAL(q,0,len);
1604 p += len;
1605 SIVAL(p,0,0); /* Ensure any padding is null. */
1606 len = PTR_DIFF(p, pdata);
1607 len = (len + 3) & ~3;
1608 SIVAL(pdata,0,len);
1609 p = pdata + len;
1610 break;
1611
1612 /* CIFS UNIX Extension. */
1613
1614 case SMB_FIND_FILE_UNIX:
1615 case SMB_FIND_FILE_UNIX_INFO2:
1616 p+= 4;
1617 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
1618
1619 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1620
1621 if (info_level == SMB_FIND_FILE_UNIX) {
1622 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1623 p = store_file_unix_basic(conn, p,
1624 NULL, &sbuf);
1625 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1626 } else {
1627 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1628 p = store_file_unix_basic_info2(conn, p,
1629 NULL, &sbuf);
1630 nameptr = p;
1631 p += 4;
1632 len = srvstr_push(outbuf, p, fname, -1, 0);
1633 SIVAL(nameptr, 0, len);
1634 }
1635
1636 p += len;
1637 SIVAL(p,0,0); /* Ensure any padding is null. */
1638
1639 len = PTR_DIFF(p, pdata);
1640 len = (len + 3) & ~3;
1641 SIVAL(pdata,0,len); /* Offset from this structure to the beginning of the next one */
1642 p = pdata + len;
1643 /* End of SMB_QUERY_FILE_UNIX_BASIC */
1644
1645 break;
1646
1647 default:
1648 return(False);
1649 }
1650
1651
1652 if (PTR_DIFF(p,pdata) > space_remaining) {
1653 /* Move the dirptr back to prev_dirpos */
1654 dptr_SeekDir(conn->dirptr, prev_dirpos);
1655 *out_of_space = True;
1656 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1657 return False; /* Not finished - just out of space */
1658 }
1659
1660 /* Setup the last entry pointer, as an offset from base_data */
1661 *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1662 /* Advance the data pointer to the next slot */
1663 *ppdata = p;
1664
1665 return(found);
1666 }
1667
1668 /****************************************************************************
1669 Reply to a TRANS2_FINDFIRST.
1670 ****************************************************************************/
1671
1672 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
1673 char **pparams, int total_params, char **ppdata, int total_data,
1674 unsigned int max_data_bytes)
1675 {
1676 /* We must be careful here that we don't return more than the
1677 allowed number of data bytes. If this means returning fewer than
1678 maxentries then so be it. We assume that the redirector has
1679 enough room for the fixed number of parameter bytes it has
1680 requested. */
1681 char *params = *pparams;
1682 char *pdata = *ppdata;
1683 uint32 dirtype;
1684 int maxentries;
1685 uint16 findfirst_flags;
1686 BOOL close_after_first;
1687 BOOL close_if_end;
1688 BOOL requires_resume_key;
1689 int info_level;
1690 pstring directory;
1691 pstring mask;
1692 char *p;
1693 int last_entry_off=0;
1694 int dptr_num = -1;
1695 int numentries = 0;
1696 int i;
1697 BOOL finished = False;
1698 BOOL dont_descend = False;
1699 BOOL out_of_space = False;
1700 int space_remaining;
1701 BOOL mask_contains_wcard = False;
1702 SMB_STRUCT_STAT sbuf;
1703 TALLOC_CTX *ea_ctx = NULL;
1704 struct ea_list *ea_list = NULL;
1705 NTSTATUS ntstatus = NT_STATUS_OK;
1706
1707 if (total_params < 13) {
1708 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1709 }
1710
1711 dirtype = SVAL(params,0);
1712 maxentries = SVAL(params,2);
1713 findfirst_flags = SVAL(params,4);
1714 close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1715 close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1716 requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1717 info_level = SVAL(params,6);
1718
1719 *directory = *mask = 0;
1720
1721 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1722 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1723 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1724 info_level, max_data_bytes));
1725
1726 if (!maxentries) {
1727 /* W2K3 seems to treat zero as 1. */
1728 maxentries = 1;
1729 }
1730
1731 switch (info_level) {
1732 case SMB_FIND_INFO_STANDARD:
1733 case SMB_FIND_EA_SIZE:
1734 case SMB_FIND_EA_LIST:
1735 case SMB_FIND_FILE_DIRECTORY_INFO:
1736 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1737 case SMB_FIND_FILE_NAMES_INFO:
1738 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1739 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1740 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1741 break;
1742 case SMB_FIND_FILE_UNIX:
1743 case SMB_FIND_FILE_UNIX_INFO2:
1744 if (!lp_unix_extensions()) {
1745 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1746 }
1747 break;
1748 default:
1749 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1750 }
1751
1752 srvstr_get_path_wcard(inbuf, SVAL(inbuf,smb_flg2), directory,
1753 params+12, sizeof(directory), total_params - 12,
1754 STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1755 if (!NT_STATUS_IS_OK(ntstatus)) {
1756 return ERROR_NT(ntstatus);
1757 }
1758
1759 ntstatus = resolve_dfspath_wcard(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, directory, &mask_contains_wcard);
1760 if (!NT_STATUS_IS_OK(ntstatus)) {
1761 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
1762 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
1763 }
1764 return ERROR_NT(ntstatus);
1765 }
1766
1767 ntstatus = unix_convert(conn, directory, True, NULL, &sbuf);
1768 if (!NT_STATUS_IS_OK(ntstatus)) {
1769 return ERROR_NT(ntstatus);
1770 }
1771 ntstatus = check_name(conn, directory);
1772 if (!NT_STATUS_IS_OK(ntstatus)) {
1773 return ERROR_NT(ntstatus);
1774 }
1775
1776 p = strrchr_m(directory,'/');
1777 if(p == NULL) {
1778 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1779 if((directory[0] == '.') && (directory[1] == '\0')) {
1780 pstrcpy(mask,"*");
1781 mask_contains_wcard = True;
1782 } else {
1783 pstrcpy(mask,directory);
1784 }
1785 pstrcpy(directory,"./");
1786 } else {
1787 pstrcpy(mask,p+1);
1788 *p = 0;
1789 }
1790
1791 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1792
1793 if (info_level == SMB_FIND_EA_LIST) {
1794 uint32 ea_size;
1795
1796 if (total_data < 4) {
1797 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1798 }
1799
1800 ea_size = IVAL(pdata,0);
1801 if (ea_size != total_data) {
1802 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
1803 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
1804 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1805 }
1806
1807 if (!lp_ea_support(SNUM(conn))) {
1808 return ERROR_DOS(ERRDOS,ERReasnotsupported);
1809 }
1810
1811 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
1812 return ERROR_NT(NT_STATUS_NO_MEMORY);
1813 }
1814
1815 /* Pull out the list of names. */
1816 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
1817 if (!ea_list) {
1818 talloc_destroy(ea_ctx);
1819 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1820 }
1821 }
1822
1823 *ppdata = (char *)SMB_REALLOC(
1824 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1825 if(*ppdata == NULL ) {
1826 talloc_destroy(ea_ctx);
1827 return ERROR_NT(NT_STATUS_NO_MEMORY);
1828 }
1829 pdata = *ppdata;
1830
1831 /* Realloc the params space */
1832 *pparams = (char *)SMB_REALLOC(*pparams, 10);
1833 if (*pparams == NULL) {
1834 talloc_destroy(ea_ctx);
1835 return ERROR_NT(NT_STATUS_NO_MEMORY);
1836 }
1837 params = *pparams;
1838
1839 /* Save the wildcard match and attribs we are using on this directory -
1840 needed as lanman2 assumes these are being saved between calls */
1841
1842 ntstatus = dptr_create(conn,
1843 directory,
1844 False,
1845 True,
1846 SVAL(inbuf,smb_pid),
1847 mask,
1848 mask_contains_wcard,
1849 dirtype,
1850 &conn->dirptr);
1851
1852 if (!NT_STATUS_IS_OK(ntstatus)) {
1853 talloc_destroy(ea_ctx);
1854 return ERROR_NT(ntstatus);
1855 }
1856
1857 dptr_num = dptr_dnum(conn->dirptr);
1858 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
1859
1860 /* We don't need to check for VOL here as this is returned by
1861 a different TRANS2 call. */
1862
1863 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1864 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1865 dont_descend = True;
1866
1867 p = pdata;
1868 space_remaining = max_data_bytes;
1869 out_of_space = False;
1870
1871 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1872 BOOL got_exact_match = False;
1873
1874 /* this is a heuristic to avoid seeking the dirptr except when
1875 absolutely necessary. It allows for a filename of about 40 chars */
1876 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1877 out_of_space = True;
1878 finished = False;
1879 } else {
1880 finished = !get_lanman2_dir_entry(conn,
1881 inbuf, outbuf,
1882 mask,dirtype,info_level,
1883 requires_resume_key,dont_descend,
1884 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1885 &last_entry_off, ea_list, ea_ctx);
1886 }
1887
1888 if (finished && out_of_space)
1889 finished = False;
1890
1891 if (!finished && !out_of_space)
1892 numentries++;
1893
1894 /*
1895 * As an optimisation if we know we aren't looking
1896 * for a wildcard name (ie. the name matches the wildcard exactly)
1897 * then we can finish on any (first) match.
1898 * This speeds up large directory searches. JRA.
1899 */
1900
1901 if(got_exact_match)
1902 finished = True;
1903
1904 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1905 }
1906
1907 talloc_destroy(ea_ctx);
1908
1909 /* Check if we can close the dirptr */
1910 if(close_after_first || (finished && close_if_end)) {
1911 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1912 dptr_close(&dptr_num);
1913 }
1914
1915 /*
1916 * If there are no matching entries we must return ERRDOS/ERRbadfile -
1917 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
1918 * the protocol level is less than NT1. Tested with smbclient. JRA.
1919 * This should fix the OS/2 client bug #2335.
1920 */
1921
1922 if(numentries == 0) {
1923 dptr_close(&dptr_num);
1924 if (Protocol < PROTOCOL_NT1) {
1925 return ERROR_DOS(ERRDOS,ERRnofiles);
1926 } else {
1927 return ERROR_BOTH(NT_STATUS_NO_SUCH_FILE,ERRDOS,ERRbadfile);
1928 }
1929 }
1930
1931 /* At this point pdata points to numentries directory entries. */
1932
1933 /* Set up the return parameter block */
1934 SSVAL(params,0,dptr_num);
1935 SSVAL(params,2,numentries);
1936 SSVAL(params,4,finished);
1937 SSVAL(params,6,0); /* Never an EA error */
1938 SSVAL(params,8,last_entry_off);
1939
1940 send_trans2_replies(inbuf, outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata), max_data_bytes);
1941
1942 if ((! *directory) && dptr_path(dptr_num))
1943 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1944
1945 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1946 smb_fn_name(CVAL(inbuf,smb_com)),
1947 mask, directory, dirtype, numentries ) );
1948
1949 /*
1950 * Force a name mangle here to ensure that the
1951 * mask as an 8.3 name is top of the mangled cache.
1952 * The reasons for this are subtle. Don't remove
1953 * this code unless you know what you are doing
1954 * (see PR#13758). JRA.
1955 */
1956
1957 if(!mangle_is_8_3_wildcards( mask, False, conn->params))
1958 mangle_map(mask, True, True, conn->params);
1959
1960 return(-1);
1961 }
1962
1963 /****************************************************************************
1964 Reply to a TRANS2_FINDNEXT.
1965 ****************************************************************************/
1966
1967 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1968 char **pparams, int total_params, char **ppdata, int total_data,
1969 unsigned int max_data_bytes)
1970 {
1971 /* We must be careful here that we don't return more than the
1972 allowed number of data bytes. If this means returning fewer than
1973 maxentries then so be it. We assume that the redirector has
1974 enough room for the fixed number of parameter bytes it has
1975 requested. */
1976 char *params = *pparams;
1977 char *pdata = *ppdata;
1978 int dptr_num;
1979 int maxentries;
1980 uint16 info_level;
1981 uint32 resume_key;
1982 uint16 findnext_flags;
1983 BOOL close_after_request;
1984 BOOL close_if_end;
1985 BOOL requires_resume_key;
1986 BOOL continue_bit;
1987 BOOL mask_contains_wcard = False;
1988 pstring resume_name;
1989 pstring mask;
1990 pstring directory;
1991 char *p;
1992 uint16 dirtype;
1993 int numentries = 0;
1994 int i, last_entry_off=0;
1995 BOOL finished = False;
1996 BOOL dont_descend = False;
1997 BOOL out_of_space = False;
1998 int space_remaining;
1999 TALLOC_CTX *ea_ctx = NULL;
2000 struct ea_list *ea_list = NULL;
2001 NTSTATUS ntstatus = NT_STATUS_OK;
2002
2003 if (total_params < 13) {
2004 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2005 }
2006
2007 dptr_num = SVAL(params,0);
2008 maxentries = SVAL(params,2);
2009 info_level = SVAL(params,4);
2010 resume_key = IVAL(params,6);
2011 findnext_flags = SVAL(params,10);
2012 close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2013 close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2014 requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2015 continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2016
2017 *mask = *directory = *resume_name = 0;
2018
2019 srvstr_get_path_wcard(inbuf, SVAL(inbuf,smb_flg2), resume_name,
2020 params+12, sizeof(resume_name),
2021 total_params - 12, STR_TERMINATE, &ntstatus,
2022 &mask_contains_wcard);
2023 if (!NT_STATUS_IS_OK(ntstatus)) {
2024 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2025 complain (it thinks we're asking for the directory above the shared
2026 path or an invalid name). Catch this as the resume name is only compared, never used in
2027 a file access. JRA. */
2028 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
2029 pstrcpy(resume_name, "..");
2030 } else if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_NAME_INVALID)) {
2031 pstrcpy(resume_name, ".");
2032 } else {
2033 return ERROR_NT(ntstatus);
2034 }
2035 }
2036
2037 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2038 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2039 resume_key = %d resume name = %s continue=%d level = %d\n",
2040 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2041 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2042
2043 if (!maxentries) {
2044 /* W2K3 seems to treat zero as 1. */
2045 maxentries = 1;
2046 }
2047
2048 switch (info_level) {
2049 case SMB_FIND_INFO_STANDARD:
2050 case SMB_FIND_EA_SIZE:
2051 case SMB_FIND_EA_LIST:
2052 case SMB_FIND_FILE_DIRECTORY_INFO:
2053 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2054 case SMB_FIND_FILE_NAMES_INFO:
2055 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2056 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2057 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2058 break;
2059 case SMB_FIND_FILE_UNIX:
2060 case SMB_FIND_FILE_UNIX_INFO2:
2061 if (!lp_unix_extensions()) {
2062 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2063 }
2064 break;
2065 default:
2066 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2067 }
2068
2069 if (info_level == SMB_FIND_EA_LIST) {
2070 uint32 ea_size;
2071
2072 if (total_data < 4) {
2073 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2074 }
2075
2076 ea_size = IVAL(pdata,0);
2077 if (ea_size != total_data) {
2078 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2079 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2080 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2081 }
2082
2083 if (!lp_ea_support(SNUM(conn))) {
2084 return ERROR_DOS(ERRDOS,ERReasnotsupported);
2085 }
2086
2087 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
2088 return ERROR_NT(NT_STATUS_NO_MEMORY);
2089 }
2090
2091 /* Pull out the list of names. */
2092 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
2093 if (!ea_list) {
2094 talloc_destroy(ea_ctx);
2095 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2096 }
2097 }
2098
2099 *ppdata = (char *)SMB_REALLOC(
2100 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2101 if(*ppdata == NULL) {
2102 talloc_destroy(ea_ctx);
2103 return ERROR_NT(NT_STATUS_NO_MEMORY);
2104 }
2105
2106 pdata = *ppdata;
2107
2108 /* Realloc the params space */
2109 *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2110 if(*pparams == NULL ) {
2111 talloc_destroy(ea_ctx);
2112 return ERROR_NT(NT_STATUS_NO_MEMORY);
2113 }
2114
2115 params = *pparams;
2116
2117 /* Check that the dptr is valid */
2118 if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2119 talloc_destroy(ea_ctx);
2120 return ERROR_DOS(ERRDOS,ERRnofiles);
2121 }
2122
2123 string_set(&conn->dirpath,dptr_path(dptr_num));
2124
2125 /* Get the wildcard mask from the dptr */
2126 if((p = dptr_wcard(dptr_num))== NULL) {
2127 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2128 talloc_destroy(ea_ctx);
2129 return ERROR_DOS(ERRDOS,ERRnofiles);
2130 }
2131
2132 pstrcpy(mask, p);
2133 pstrcpy(directory,conn->dirpath);
2134
2135 /* Get the attr mask from the dptr */
2136 dirtype = dptr_attr(dptr_num);
2137
2138 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2139 dptr_num, mask, dirtype,
2140 (long)conn->dirptr,
2141 dptr_TellDir(conn->dirptr)));
2142
2143 /* We don't need to check for VOL here as this is returned by
2144 a different TRANS2 call. */
2145
2146 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2147 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2148 dont_descend = True;
2149
2150 p = pdata;
2151 space_remaining = max_data_bytes;
2152 out_of_space = False;
2153
2154 /*
2155 * Seek to the correct position. We no longer use the resume key but
2156 * depend on the last file name instead.
2157 */
2158
2159 if(*resume_name && !continue_bit) {
2160 SMB_STRUCT_STAT st;
2161
2162 long current_pos = 0;
2163 /*
2164 * Remember, mangle_map is called by
2165 * get_lanman2_dir_entry(), so the resume name
2166 * could be mangled. Ensure we check the unmangled name.
2167 */
2168
2169 if (mangle_is_mangled(resume_name, conn->params)) {
2170 mangle_check_cache(resume_name, sizeof(resume_name)-1,
2171 conn->params);
2172 }
2173
2174 /*
2175 * Fix for NT redirector problem triggered by resume key indexes
2176 * changing between directory scans. We now return a resume key of 0
2177 * and instead look for the filename to continue from (also given
2178 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2179 * findfirst/findnext (as is usual) then the directory pointer
2180 * should already be at the correct place.
2181 */
2182
2183 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2184 } /* end if resume_name && !continue_bit */
2185
2186 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2187 BOOL got_exact_match = False;
2188
2189 /* this is a heuristic to avoid seeking the dirptr except when
2190 absolutely necessary. It allows for a filename of about 40 chars */
2191 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2192 out_of_space = True;
2193 finished = False;
2194 } else {
2195 finished = !get_lanman2_dir_entry(conn,
2196 inbuf, outbuf,
2197 mask,dirtype,info_level,
2198 requires_resume_key,dont_descend,
2199 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
2200 &last_entry_off, ea_list, ea_ctx);
2201 }
2202
2203 if (finished && out_of_space)
2204 finished = False;
2205
2206 if (!finished && !out_of_space)
2207 numentries++;
2208
2209 /*
2210 * As an optimisation if we know we aren't looking
2211 * for a wildcard name (ie. the name matches the wildcard exactly)
2212 * then we can finish on any (first) match.
2213 * This speeds up large directory searches. JRA.
2214 */
2215
2216 if(got_exact_match)
2217 finished = True;
2218
2219 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2220 }
2221
2222 talloc_destroy(ea_ctx);
2223
2224 /* Check if we can close the dirptr */
2225 if(close_after_request || (finished && close_if_end)) {
2226 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2227 dptr_close(&dptr_num); /* This frees up the saved mask */
2228 }
2229
2230 /* Set up the return parameter block */
2231 SSVAL(params,0,numentries);
2232 SSVAL(params,2,finished);
2233 SSVAL(params,4,0); /* Never an EA error */
2234 SSVAL(params,6,last_entry_off);
2235
2236 send_trans2_replies(inbuf, outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata), max_data_bytes);
2237
2238 if ((! *directory) && dptr_path(dptr_num))
2239 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
2240
2241 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2242 smb_fn_name(CVAL(inbuf,smb_com)),
2243 mask, directory, dirtype, numentries ) );
2244
2245 return(-1);
2246 }
2247
2248 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2249 {
2250 E_md4hash(lp_servicename(SNUM(conn)),objid);
2251 return objid;
2252 }
2253
2254 /****************************************************************************
2255 Reply to a TRANS2_QFSINFO (query filesystem info).
2256 ****************************************************************************/
2257
2258 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2259 char **pparams, int total_params, char **ppdata, int total_data,
2260 unsigned int max_data_bytes)
2261 {
2262 char *pdata;
2263 char *params = *pparams;
2264 uint16 info_level;
2265 int data_len, len;
2266 SMB_STRUCT_STAT st;
2267 const char *vname = volume_label(SNUM(conn));
2268 int snum = SNUM(conn);
2269 char *fstype = lp_fstype(SNUM(conn));
2270 int quota_flag = 0;
2271
2272 if (total_params < 2) {
2273 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2274 }
2275
2276 info_level = SVAL(params,0);
2277
2278 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2279
2280 if(SMB_VFS_STAT(conn,".",&st)!=0) {
2281 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2282 return ERROR_DOS(ERRSRV,ERRinvdevice);
2283 }
2284
2285 *ppdata = (char *)SMB_REALLOC(
2286 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2287 if (*ppdata == NULL ) {
2288 return ERROR_NT(NT_STATUS_NO_MEMORY);
2289 }
2290
2291 pdata = *ppdata;
2292 memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2293
2294 switch (info_level) {
2295 case SMB_INFO_ALLOCATION:
2296 {
2297 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2298 data_len = 18;
2299 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2300 return(UNIXERROR(ERRHRD,ERRgeneral));
2301 }
2302
2303 block_size = lp_block_size(snum);
2304 if (bsize < block_size) {
2305 SMB_BIG_UINT factor = block_size/bsize;
2306 bsize = block_size;
2307 dsize /= factor;
2308 dfree /= factor;
2309 }
2310 if (bsize > block_size) {
2311 SMB_BIG_UINT factor = bsize/block_size;
2312 bsize = block_size;
2313 dsize *= factor;
2314 dfree *= factor;
2315 }
2316 bytes_per_sector = 512;
2317 sectors_per_unit = bsize/bytes_per_sector;
2318
2319 DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2320 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2321 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2322
2323 SIVAL(pdata,l1_idFileSystem,st.st_dev);
2324 SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2325 SIVAL(pdata,l1_cUnit,dsize);
2326 SIVAL(pdata,l1_cUnitAvail,dfree);
2327 SSVAL(pdata,l1_cbSector,bytes_per_sector);
2328 break;
2329 }
2330
2331 case SMB_INFO_VOLUME:
2332 /* Return volume name */
2333 /*
2334 * Add volume serial number - hash of a combination of
2335 * the called hostname and the service name.
2336 */
2337 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2338 /*
2339 * Win2k3 and previous mess this up by sending a name length
2340 * one byte short. I believe only older clients (OS/2 Win9x) use
2341 * this call so try fixing this by adding a terminating null to
2342 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2343 */
2344 len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_NOALIGN|STR_TERMINATE);
2345 SCVAL(pdata,l2_vol_cch,len);
2346 data_len = l2_vol_szVolLabel + len;
2347 DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2348 (unsigned)st.st_ctime, len, vname));
2349 break;
2350
2351 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2352 case SMB_FS_ATTRIBUTE_INFORMATION:
2353
2354
2355 #if defined(HAVE_SYS_QUOTAS)
2356 quota_flag = FILE_VOLUME_QUOTAS;
2357 #endif
2358
2359 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2360 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
2361 FILE_SUPPORTS_OBJECT_IDS|
2362 FILE_UNICODE_ON_DISK|
2363 quota_flag); /* FS ATTRIBUTES */
2364
2365 SIVAL(pdata,4,255); /* Max filename component length */
2366 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2367 and will think we can't do long filenames */
2368 len = srvstr_push(outbuf, pdata+12, fstype, -1, STR_UNICODE);
2369 SIVAL(pdata,8,len);
2370 data_len = 12 + len;
2371 break;
2372
2373 case SMB_QUERY_FS_LABEL_INFO:
2374 case SMB_FS_LABEL_INFORMATION:
2375 len = srvstr_push(outbuf, pdata+4, vname, -1, 0);
2376 data_len = 4 + len;
2377 SIVAL(pdata,0,len);
2378 break;
2379
2380 case SMB_QUERY_FS_VOLUME_INFO:
2381 case SMB_FS_VOLUME_INFORMATION:
2382
2383 /*
2384 * Add volume serial number - hash of a combination of
2385 * the called hostname and the service name.
2386 */
2387 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
2388 (str_checksum(get_local_machine_name())<<16));
2389
2390 /* Max label len is 32 characters. */
2391 len = srvstr_push(outbuf, pdata+18, vname, -1, STR_UNICODE);
2392 SIVAL(pdata,12,len);
2393 data_len = 18+len;
2394
2395 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
2396 (int)strlen(vname),vname, lp_servicename(snum)));
2397 break;
2398
2399 case SMB_QUERY_FS_SIZE_INFO:
2400 case SMB_FS_SIZE_INFORMATION:
2401 {
2402 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2403 data_len = 24;
2404 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2405 return(UNIXERROR(ERRHRD,ERRgeneral));
2406 }
2407 block_size = lp_block_size(snum);
2408 if (bsize < block_size) {
2409 SMB_BIG_UINT factor = block_size/bsize;
2410 bsize = block_size;
2411 dsize /= factor;
2412 dfree /= factor;
2413 }
2414 if (bsize > block_size) {
2415 SMB_BIG_UINT factor = bsize/block_size;
2416 bsize = block_size;
2417 dsize *= factor;
2418 dfree *= factor;
2419 }
2420 bytes_per_sector = 512;
2421 sectors_per_unit = bsize/bytes_per_sector;
2422 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2423 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2424 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2425 SBIG_UINT(pdata,0,dsize);
2426 SBIG_UINT(pdata,8,dfree);
2427 SIVAL(pdata,16,sectors_per_unit);
2428 SIVAL(pdata,20,bytes_per_sector);
2429 break;
2430 }
2431
2432 case SMB_FS_FULL_SIZE_INFORMATION:
2433 {
2434 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2435 data_len = 32;
2436 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2437 return(UNIXERROR(ERRHRD,ERRgeneral));
2438 }
2439 block_size = lp_block_size(snum);
2440 if (bsize < block_size) {
2441 SMB_BIG_UINT factor = block_size/bsize;
2442 bsize = block_size;
2443 dsize /= factor;
2444 dfree /= factor;
2445 }
2446 if (bsize > block_size) {
2447 SMB_BIG_UINT factor = bsize/block_size;
2448 bsize = block_size;
2449 dsize *= factor;
2450 dfree *= factor;
2451 }
2452 bytes_per_sector = 512;
2453 sectors_per_unit = bsize/bytes_per_sector;
2454 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2455 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2456 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2457 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2458 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2459 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2460 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2461 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2462 break;
2463 }
2464
2465 case SMB_QUERY_FS_DEVICE_INFO:
2466 case SMB_FS_DEVICE_INFORMATION:
2467 data_len = 8;
2468 SIVAL(pdata,0,0); /* dev type */
2469 SIVAL(pdata,4,0); /* characteristics */
2470 break;
2471
2472 #ifdef HAVE_SYS_QUOTAS
2473 case SMB_FS_QUOTA_INFORMATION:
2474 /*
2475 * what we have to send --metze:
2476 *
2477 * Unknown1: 24 NULL bytes
2478 * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2479 * Hard Quota Limit: 8 bytes seems like SMB_BIG_UINT or so
2480 * Quota Flags: 2 byte :
2481 * Unknown3: 6 NULL bytes
2482 *
2483 * 48 bytes total
2484 *
2485 * details for Quota Flags:
2486 *
2487 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2488 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
2489 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2490 * 0x0001 Enable Quotas: enable quota for this fs
2491 *
2492 */
2493 {
2494 /* we need to fake up a fsp here,
2495 * because its not send in this call
2496 */
2497 files_struct fsp;
2498 SMB_NTQUOTA_STRUCT quotas;
2499
2500 ZERO_STRUCT(fsp);
2501 ZERO_STRUCT(quotas);
2502
2503 fsp.conn = conn;
2504 fsp.fnum = -1;
2505
2506 /* access check */
2507 if (current_user.ut.uid != 0) {
2508 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2509 lp_servicename(SNUM(conn)),conn->user));
2510 return ERROR_DOS(ERRDOS,ERRnoaccess);
2511 }
2512
2513 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2514 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2515 return ERROR_DOS(ERRSRV,ERRerror);
2516 }
2517
2518 data_len = 48;
2519
2520 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
2521
2522 /* Unknown1 24 NULL bytes*/
2523 SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2524 SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2525 SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2526
2527 /* Default Soft Quota 8 bytes */
2528 SBIG_UINT(pdata,24,quotas.softlim);
2529
2530 /* Default Hard Quota 8 bytes */
2531 SBIG_UINT(pdata,32,quotas.hardlim);
2532
2533 /* Quota flag 2 bytes */
2534 SSVAL(pdata,40,quotas.qflags);
2535
2536 /* Unknown3 6 NULL bytes */
2537 SSVAL(pdata,42,0);
2538 SIVAL(pdata,44,0);
2539
2540 break;
2541 }
2542 #endif /* HAVE_SYS_QUOTAS */
2543 case SMB_FS_OBJECTID_INFORMATION:
2544 {
2545 unsigned char objid[16];
2546 memcpy(pdata,create_volume_objectid(conn, objid),16);
2547 data_len = 64;
2548 break;
2549 }
2550
2551 /*
2552 * Query the version and capabilities of the CIFS UNIX extensions
2553 * in use.
2554 */
2555
2556 case SMB_QUERY_CIFS_UNIX_INFO:
2557 if (!lp_unix_extensions()) {
2558 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2559 }
2560 data_len = 12;
2561 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2562 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2563 /* We have POSIX ACLs, pathname and locking capability. */
2564 SBIG_UINT(pdata,4,((SMB_BIG_UINT)(
2565 CIFS_UNIX_POSIX_ACLS_CAP|
2566 CIFS_UNIX_POSIX_PATHNAMES_CAP|
2567 CIFS_UNIX_FCNTL_LOCKS_CAP|
2568 CIFS_UNIX_EXTATTR_CAP|
2569 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
2570 /* Ensure we don't do this on signed or sealed data. */
2571 (srv_is_signing_active() ? 0 : CIFS_UNIX_LARGE_READ_CAP)
2572 )));
2573 break;
2574
2575 case SMB_QUERY_POSIX_FS_INFO:
2576 {
2577 int rc;
2578 vfs_statvfs_struct svfs;
2579
2580 if (!lp_unix_extensions()) {
2581 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2582 }
2583
2584 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2585
2586 if (!rc) {
2587 data_len = 56;
2588 SIVAL(pdata,0,svfs.OptimalTransferSize);
2589 SIVAL(pdata,4,svfs.BlockSize);
2590 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2591 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2592 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2593 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2594 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2595 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2596 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2597 #ifdef EOPNOTSUPP
2598 } else if (rc == EOPNOTSUPP) {
2599 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2600 #endif /* EOPNOTSUPP */
2601 } else {
2602 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2603 return ERROR_DOS(ERRSRV,ERRerror);
2604 }
2605 break;
2606 }
2607
2608 case SMB_QUERY_POSIX_WHOAMI:
2609 {
2610 uint32_t flags = 0;
2611 uint32_t sid_bytes;
2612 int i;
2613
2614 if (!lp_unix_extensions()) {
2615 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2616 }
2617
2618 if (max_data_bytes < 40) {
2619 return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
2620 }
2621
2622 /* We ARE guest if global_sid_Builtin_Guests is
2623 * in our list of SIDs.
2624 */
2625 if (nt_token_check_sid(&global_sid_Builtin_Guests,
2626 current_user.nt_user_token)) {
2627 flags |= SMB_WHOAMI_GUEST;
2628 }
2629
2630 /* We are NOT guest if global_sid_Authenticated_Users
2631 * is in our list of SIDs.
2632 */
2633 if (nt_token_check_sid(&global_sid_Authenticated_Users,
2634 current_user.nt_user_token)) {
2635 flags &= ~SMB_WHOAMI_GUEST;
2636 }
2637
2638 /* NOTE: 8 bytes for UID/GID, irrespective of native
2639 * platform size. This matches
2640 * SMB_QUERY_FILE_UNIX_BASIC and friends.
2641 */
2642 data_len = 4 /* flags */
2643 + 4 /* flag mask */
2644 + 8 /* uid */
2645 + 8 /* gid */
2646 + 4 /* ngroups */
2647 + 4 /* num_sids */
2648 + 4 /* SID bytes */
2649 + 4 /* pad/reserved */
2650 + (current_user.ut.ngroups * 8)
2651 /* groups list */
2652 + (current_user.nt_user_token->num_sids *
2653 SID_MAX_SIZE)
2654 /* SID list */;
2655
2656 SIVAL(pdata, 0, flags);
2657 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
2658 SBIG_UINT(pdata, 8, (SMB_BIG_UINT)current_user.ut.uid);
2659 SBIG_UINT(pdata, 16, (SMB_BIG_UINT)current_user.ut.gid);
2660
2661
2662 if (data_len >= max_data_bytes) {
2663 /* Potential overflow, skip the GIDs and SIDs. */
2664
2665 SIVAL(pdata, 24, 0); /* num_groups */
2666 SIVAL(pdata, 28, 0); /* num_sids */
2667 SIVAL(pdata, 32, 0); /* num_sid_bytes */
2668 SIVAL(pdata, 36, 0); /* reserved */
2669
2670 data_len = 40;
2671 break;
2672 }
2673
2674 SIVAL(pdata, 24, current_user.ut.ngroups);
2675 SIVAL(pdata, 28,
2676 current_user.nt_user_token->num_sids);
2677
2678 /* We walk the SID list twice, but this call is fairly
2679 * infrequent, and I don't expect that it's performance
2680 * sensitive -- jpeach
2681 */
2682 for (i = 0, sid_bytes = 0;
2683 i < current_user.nt_user_token->num_sids; ++i) {
2684 sid_bytes +=
2685 sid_size(&current_user.nt_user_token->user_sids[i]);
2686 }
2687
2688 /* SID list byte count */
2689 SIVAL(pdata, 32, sid_bytes);
2690
2691 /* 4 bytes pad/reserved - must be zero */
2692 SIVAL(pdata, 36, 0);
2693 data_len = 40;
2694
2695 /* GID list */
2696 for (i = 0; i < current_user.ut.ngroups; ++i) {
2697 SBIG_UINT(pdata, data_len,
2698 (SMB_BIG_UINT)current_user.ut.groups[i]);
2699 data_len += 8;
2700 }
2701
2702 /* SID list */
2703 for (i = 0;
2704 i < current_user.nt_user_token->num_sids; ++i) {
2705 int sid_len =
2706 sid_size(&current_user.nt_user_token->user_sids[i]);
2707
2708 sid_linearize(pdata + data_len, sid_len,
2709 &current_user.nt_user_token->user_sids[i]);
2710 data_len += sid_len;
2711 }
2712
2713 break;
2714 }
2715
2716 case SMB_MAC_QUERY_FS_INFO:
2717 /*
2718 * Thursby MAC extension... ONLY on NTFS filesystems
2719 * once we do streams then we don't need this
2720 */
2721 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2722 data_len = 88;
2723 SIVAL(pdata,84,0x100); /* Don't support mac... */
2724 break;
2725 }
2726 /* drop through */
2727 default:
2728 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2729 }
2730
2731
2732 send_trans2_replies(inbuf, outbuf, bufsize, params, 0, pdata, data_len, max_data_bytes);
2733
2734 DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
2735
2736 return -1;
2737 }
2738
2739 /****************************************************************************
2740 Reply to a TRANS2_SETFSINFO (set filesystem info).
2741 ****************************************************************************/
2742
2743 static int call_trans2setfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2744 char **pparams, int total_params, char **ppdata, int total_data,
2745 unsigned int max_data_bytes)
2746 {
2747 char *pdata = *ppdata;
2748 char *params = *pparams;
2749 uint16 info_level;
2750 int outsize;
2751
2752 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
2753
2754 /* */
2755 if (total_params < 4) {
2756 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2757 total_params));
2758 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2759 }
2760
2761 info_level = SVAL(params,2);
2762
2763 switch(info_level) {
2764 case SMB_SET_CIFS_UNIX_INFO:
2765 {
2766 uint16 client_unix_major;
2767 uint16 client_unix_minor;
2768 uint32 client_unix_cap_low;
2769 uint32 client_unix_cap_high;
2770
2771 if (!lp_unix_extensions()) {
2772 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2773 }
2774
2775 /* There should be 12 bytes of capabilities set. */
2776 if (total_data < 8) {
2777 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2778 }
2779 client_unix_major = SVAL(pdata,0);
2780 client_unix_minor = SVAL(pdata,2);
2781 client_unix_cap_low = IVAL(pdata,4);
2782 client_unix_cap_high = IVAL(pdata,8);
2783 /* Just print these values for now. */
2784 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
2785 cap_low = 0x%x, cap_high = 0x%x\n",
2786 (unsigned int)client_unix_major,
2787 (unsigned int)client_unix_minor,
2788 (unsigned int)client_unix_cap_low,
2789 (unsigned int)client_unix_cap_high ));
2790
2791 /* Here is where we must switch to posix pathname processing... */
2792 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2793 lp_set_posix_pathnames();
2794 mangle_change_to_posix();
2795 }
2796
2797 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
2798 !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
2799 /* Client that knows how to do posix locks,
2800 * but not posix open/mkdir operations. Set a
2801 * default type for read/write checks. */
2802
2803 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
2804
2805 }
2806 break;
2807 }
2808 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
2809 {
2810 NTSTATUS status;
2811 size_t param_len = 0;
2812 size_t data_len = total_data;
2813
2814 if (!lp_unix_extensions()) {
2815 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2816 }
2817
2818 DEBUG( 4,("call_trans2setfsinfo: request transport encrption.\n"));
2819
2820 status = srv_request_encryption_setup(conn,
2821 (unsigned char **)ppdata,
2822 &data_len,
2823 (unsigned char **)pparams,
2824 &param_len
2825 );
2826
2827 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
2828 error_packet_set(outbuf, 0, 0, status, __LINE__,__FILE__);
2829 } else if (!NT_STATUS_IS_OK(status)) {
2830 return ERROR_NT(status);
2831 }
2832
2833 send_trans2_replies(inbuf, outbuf, bufsize, *pparams, param_len, *ppdata, data_len, max_data_bytes);
2834
2835 if (NT_STATUS_IS_OK(status)) {
2836 /* Server-side transport encryption is now *on*. */
2837 status = srv_encryption_start(conn);
2838 if (!NT_STATUS_IS_OK(status)) {
2839 exit_server_cleanly("Failure in setting up encrypted transport");
2840 }
2841 }
2842 return -1;
2843 }
2844 case SMB_FS_QUOTA_INFORMATION:
2845 {
2846 files_struct *fsp = NULL;
2847 SMB_NTQUOTA_STRUCT quotas;
2848
2849 ZERO_STRUCT(quotas);
2850
2851 /* access check */
2852 if ((current_user.ut.uid != 0)||!CAN_WRITE(conn)) {
2853 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2854 lp_servicename(SNUM(conn)),conn->user));
2855 return ERROR_DOS(ERRSRV,ERRaccess);
2856 }
2857
2858 /* note: normaly there're 48 bytes,
2859 * but we didn't use the last 6 bytes for now
2860 * --metze
2861 */
2862 fsp = file_fsp(params,0);
2863 if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2864 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2865 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2866 }
2867
2868 if (total_data < 42) {
2869 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
2870 total_data));
2871 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2872 }
2873
2874 /* unknown_1 24 NULL bytes in pdata*/
2875
2876 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2877 quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2878 #ifdef LARGE_SMB_OFF_T
2879 quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2880 #else /* LARGE_SMB_OFF_T */
2881 if ((IVAL(pdata,28) != 0)&&
2882 ((quotas.softlim != 0xFFFFFFFF)||
2883 (IVAL(pdata,28)!=0xFFFFFFFF))) {
2884 /* more than 32 bits? */
2885 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2886 }
2887 #endif /* LARGE_SMB_OFF_T */
2888
2889 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2890 quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2891 #ifdef LARGE_SMB_OFF_T
2892 quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2893 #else /* LARGE_SMB_OFF_T */
2894 if ((IVAL(pdata,36) != 0)&&
2895 ((quotas.hardlim != 0xFFFFFFFF)||
2896 (IVAL(pdata,36)!=0xFFFFFFFF))) {
2897 /* more than 32 bits? */
2898 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2899 }
2900 #endif /* LARGE_SMB_OFF_T */
2901
2902 /* quota_flags 2 bytes **/
2903 quotas.qflags = SVAL(pdata,40);
2904
2905 /* unknown_2 6 NULL bytes follow*/
2906
2907 /* now set the quotas */
2908 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2909 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2910 return ERROR_DOS(ERRSRV,ERRerror);
2911 }
2912
2913 break;
2914 }
2915 default:
2916 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
2917 info_level));
2918 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2919 break;
2920 }
2921
2922 /*
2923 * sending this reply works fine,
2924 * but I'm not sure it's the same
2925 * like windows do...
2926 * --metze
2927 */
2928 outsize = set_message(inbuf, outbuf,10,0,True);
2929
2930 return outsize;
2931 }
2932
2933 #if defined(HAVE_POSIX_ACLS)
2934 /****************************************************************************
2935 Utility function to count the number of entries in a POSIX acl.
2936 ****************************************************************************/
2937
2938 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
2939 {
2940 unsigned int ace_count = 0;
2941 int entry_id = SMB_ACL_FIRST_ENTRY;
2942 SMB_ACL_ENTRY_T entry;
2943
2944 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2945 /* get_next... */
2946 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2947 entry_id = SMB_ACL_NEXT_ENTRY;
2948 }
2949 ace_count++;
2950 }
2951 return ace_count;
2952 }
2953
2954 /****************************************************************************
2955 Utility function to marshall a POSIX acl into wire format.
2956 ****************************************************************************/
2957
2958 static BOOL marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
2959 {
2960 int entry_id = SMB_ACL_FIRST_ENTRY;
2961 SMB_ACL_ENTRY_T entry;
2962
2963 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2964 SMB_ACL_TAG_T tagtype;
2965 SMB_ACL_PERMSET_T permset;
2966 unsigned char perms = 0;
2967 unsigned int own_grp;
2968
2969 /* get_next... */
2970 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2971 entry_id = SMB_ACL_NEXT_ENTRY;
2972 }
2973
2974 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
2975 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
2976 return False;
2977 }
2978
2979 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
2980 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
2981 return False;
2982 }
2983
2984 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
2985 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
2986 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
2987
2988 SCVAL(pdata,1,perms);
2989
2990 switch (tagtype) {
2991 case SMB_ACL_USER_OBJ:
2992 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
2993 own_grp = (unsigned int)pst->st_uid;
2994 SIVAL(pdata,2,own_grp);
2995 SIVAL(pdata,6,0);
2996 break;
2997 case SMB_ACL_USER:
2998 {
2999 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3000 if (!puid) {
3001 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3002 }
3003 own_grp = (unsigned int)*puid;
3004 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3005 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3006 SIVAL(pdata,2,own_grp);
3007 SIVAL(pdata,6,0);
3008 break;
3009 }
3010 case SMB_ACL_GROUP_OBJ:
3011 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3012 own_grp = (unsigned int)pst->st_gid;
3013 SIVAL(pdata,2,own_grp);
3014 SIVAL(pdata,6,0);
3015 break;
3016 case SMB_ACL_GROUP:
3017 {
3018 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3019 if (!pgid) {
3020 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3021 }
3022 own_grp = (unsigned int)*pgid;
3023 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3024 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3025 SIVAL(pdata,2,own_grp);
3026 SIVAL(pdata,6,0);
3027 break;
3028 }
3029 case SMB_ACL_MASK:
3030 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
3031 SIVAL(pdata,2,0xFFFFFFFF);
3032 SIVAL(pdata,6,0xFFFFFFFF);
3033 break;
3034 case SMB_ACL_OTHER:
3035 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
3036 SIVAL(pdata,2,0xFFFFFFFF);
3037 SIVAL(pdata,6,0xFFFFFFFF);
3038 break;
3039 default:
3040 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3041 return False;
3042 }
3043 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
3044 }
3045
3046 return True;
3047 }
3048 #endif
3049
3050 /****************************************************************************
3051 Store the FILE_UNIX_BASIC info.
3052 ****************************************************************************/
3053
3054 static char *store_file_unix_basic(connection_struct *conn,
3055 char *pdata,
3056 files_struct *fsp,
3057 const SMB_STRUCT_STAT *psbuf)
3058 {
3059 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3060 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_mode));
3061
3062 SOFF_T(pdata,0,get_file_size(*psbuf)); /* File size 64 Bit */
3063 pdata += 8;
3064
3065 SOFF_T(pdata,0,get_allocation_size(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3066 pdata += 8;
3067
3068 put_long_date_timespec(pdata,get_ctimespec(psbuf)); /* Change Time 64 Bit */
3069 put_long_date_timespec(pdata+8,get_atimespec(psbuf)); /* Last access time 64 Bit */
3070 put_long_date_timespec(pdata+16,get_mtimespec(psbuf)); /* Last modification time 64 Bit */
3071 pdata += 24;
3072
3073 SIVAL(pdata,0,psbuf->st_uid); /* user id for the owner */
3074 SIVAL(pdata,4,0);
3075 pdata += 8;
3076
3077 SIVAL(pdata,0,psbuf->st_gid); /* group id of owner */
3078 SIVAL(pdata,4,0);
3079 pdata += 8;
3080
3081 SIVAL(pdata,0,unix_filetype(psbuf->st_mode));
3082 pdata += 4;
3083
3084 SIVAL(pdata,0,unix_dev_major(psbuf->st_rdev)); /* Major device number if type is device */
3085 SIVAL(pdata,4,0);
3086 pdata += 8;
3087
3088 SIVAL(pdata,0,unix_dev_minor(psbuf->st_rdev)); /* Minor device number if type is device */
3089 SIVAL(pdata,4,0);
3090 pdata += 8;
3091
3092 SINO_T_VAL(pdata,0,(SMB_INO_T)psbuf->st_ino); /* inode number */
3093 pdata += 8;
3094
3095 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_mode)); /* Standard UNIX file permissions */
3096 SIVAL(pdata,4,0);
3097 pdata += 8;
3098
3099 SIVAL(pdata,0,psbuf->st_nlink); /* number of hard links */
3100 SIVAL(pdata,4,0);
3101 pdata += 8;
3102
3103 return pdata;
3104 }
3105
3106 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3107 * the chflags(2) (or equivalent) flags.
3108 *
3109 * XXX: this really should be behind the VFS interface. To do this, we would
3110 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3111 * Each VFS module could then implement it's own mapping as appropriate for the
3112 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3113 */
3114 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
3115 info2_flags_map[] =
3116 {
3117 #ifdef UF_NODUMP
3118 { UF_NODUMP, EXT_DO_NOT_BACKUP },
3119 #endif
3120
3121 #ifdef UF_IMMUTABLE
3122 { UF_IMMUTABLE, EXT_IMMUTABLE },
3123 #endif
3124
3125 #ifdef UF_APPEND
3126 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
3127 #endif
3128
3129 #ifdef UF_HIDDEN
3130 { UF_HIDDEN, EXT_HIDDEN },
3131 #endif
3132
3133 /* Do not remove. We need to guarantee that this array has at least one
3134 * entry to build on HP-UX.
3135 */
3136 { 0, 0 }
3137
3138 };
3139
3140 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
3141 uint32 *smb_fflags, uint32 *smb_fmask)
3142 {
3143 #ifdef HAVE_STAT_ST_FLAGS
3144 int i;
3145
3146 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3147 *smb_fmask |= info2_flags_map[i].smb_fflag;
3148 if (psbuf->st_flags & info2_flags_map[i].stat_fflag) {
3149 *smb_fflags |= info2_flags_map[i].smb_fflag;
3150 }
3151 }
3152 #endif /* HAVE_STAT_ST_FLAGS */
3153 }
3154
3155 static BOOL map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
3156 const uint32 smb_fflags,
3157 const uint32 smb_fmask,
3158 int *stat_fflags)
3159 {
3160 #ifdef HAVE_STAT_ST_FLAGS
3161 uint32 max_fmask = 0;
3162 int i;
3163
3164 *stat_fflags = psbuf->st_flags;
3165
3166 /* For each flags requested in smb_fmask, check the state of the
3167 * corresponding flag in smb_fflags and set or clear the matching
3168 * stat flag.
3169 */
3170
3171 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3172 max_fmask |= info2_flags_map[i].smb_fflag;
3173 if (smb_fmask & info2_flags_map[i].smb_fflag) {
3174 if (smb_fflags & info2_flags_map[i].smb_fflag) {
3175 *stat_fflags |= info2_flags_map[i].stat_fflag;
3176 } else {
3177 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
3178 }
3179 }
3180 }
3181
3182 /* If smb_fmask is asking to set any bits that are not supported by
3183 * our flag mappings, we should fail.
3184 */
3185 if ((smb_fmask & max_fmask) != smb_fmask) {
3186 return False;
3187 }
3188
3189 return True;
3190 #else
3191 return False;
3192 #endif /* HAVE_STAT_ST_FLAGS */
3193 }
3194
3195
3196 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3197 * of file flags and birth (create) time.
3198 */
3199 static char *store_file_unix_basic_info2(connection_struct *conn,
3200 char *pdata,
3201 files_struct *fsp,
3202 const SMB_STRUCT_STAT *psbuf)
3203 {
3204 uint32 file_flags = 0;
3205 uint32 flags_mask = 0;
3206
3207 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
3208
3209 /* Create (birth) time 64 bit */
3210 put_long_date_timespec(pdata, get_create_timespec(psbuf, False));
3211 pdata += 8;
3212
3213 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
3214 SIVAL(pdata, 0, file_flags); /* flags */
3215 SIVAL(pdata, 4, flags_mask); /* mask */
3216 pdata += 8;
3217
3218 return pdata;
3219 }
3220
3221 /****************************************************************************
3222 Reply to a TRANSACT2_QFILEINFO on a PIPE !
3223 ****************************************************************************/
3224
3225 static int call_trans2qpipeinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
3226 unsigned int tran_call,
3227 char **pparams, int total_params, char **ppdata, int total_data,
3228 unsigned int max_data_bytes)
3229 {
3230 char *params = *pparams;
3231 char *pdata = *ppdata;
3232 unsigned int data_size = 0;
3233 unsigned int param_size = 2;
3234 uint16 info_level;
3235 smb_np_struct *p_pipe = NULL;
3236
3237 if (!params) {
3238 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3239 }
3240
3241 if (total_params < 4) {
3242 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3243 }
3244
3245 p_pipe = get_rpc_pipe_p(params,0);
3246 if (p_pipe == NULL) {
3247 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
3248 }
3249
3250 info_level = SVAL(params,2);
3251
3252 *pparams = (char *)SMB_REALLOC(*pparams,2);
3253 if (*pparams == NULL) {
3254 return ERROR_NT(NT_STATUS_NO_MEMORY);
3255 }
3256 params = *pparams;
3257 SSVAL(params,0,0);
3258 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3259 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3260 if (*ppdata == NULL ) {
3261 return ERROR_NT(NT_STATUS_NO_MEMORY);
3262 }
3263 pdata = *ppdata;
3264
3265 switch (info_level) {
3266 case SMB_FILE_STANDARD_INFORMATION:
3267 memset(pdata,24,0);
3268 SOFF_T(pdata,0,4096LL);
3269 SIVAL(pdata,16,1);
3270 SIVAL(pdata,20,1);
3271 data_size = 24;
3272 break;
3273
3274 default:
3275 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3276 }
3277
3278 send_trans2_replies(inbuf, outbuf, bufsize, params, param_size, *ppdata, data_size, max_data_bytes);
3279
3280 return(-1);
3281 }
3282
3283 /****************************************************************************
3284 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
3285 file name or file id).
3286 ****************************************************************************/
3287
3288 static int call_trans2qfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
3289 unsigned int tran_call,
3290 char **pparams, int total_params, char **ppdata, int total_data,
3291 unsigned int max_data_bytes)
3292 {
3293 char *params = *pparams;
3294 char *pdata = *ppdata;
3295 uint16 info_level;
3296 int mode=0;
3297 int nlink;
3298 SMB_OFF_T file_size=0;
3299 SMB_BIG_UINT allocation_size=0;
3300 unsigned int data_size = 0;
3301 unsigned int param_size = 2;
3302 SMB_STRUCT_STAT sbuf;
3303 pstring fname, dos_fname;
3304 char *fullpathname;
3305 char *base_name;
3306 char *p;
3307 SMB_OFF_T pos = 0;
3308 BOOL delete_pending = False;
3309 int len;
3310 time_t create_time, mtime, atime;
3311 struct timespec create_time_ts, mtime_ts, atime_ts;
3312 files_struct *fsp = NULL;
3313 TALLOC_CTX *data_ctx = NULL;
3314 struct ea_list *ea_list = NULL;
3315 uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
3316 char *lock_data = NULL;
3317
3318 if (!params)
3319 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3320
3321 ZERO_STRUCT(sbuf);
3322
3323 if (tran_call == TRANSACT2_QFILEINFO) {
3324 if (total_params < 4) {
3325 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3326 }
3327
3328 if (IS_IPC(conn)) {
3329 return call_trans2qpipeinfo(conn,
3330 inbuf,
3331 outbuf,
3332 length,
3333 bufsize,
3334 tran_call,
3335 pparams,
3336 total_params,
3337 ppdata,
3338 total_data,
3339 max_data_bytes);
3340 }
3341
3342 fsp = file_fsp(params,0);
3343 info_level = SVAL(params,2);
3344
3345 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
3346
3347 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3348 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3349 }
3350
3351 if(fsp && (fsp->fake_file_handle)) {
3352 /*
3353 * This is actually for the QUOTA_FAKE_FILE --metze
3354 */
3355
3356 pstrcpy(fname, fsp->fsp_name);
3357 /* We know this name is ok, it's already passed the checks. */
3358
3359 } else if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
3360 /*
3361 * This is actually a QFILEINFO on a directory
3362 * handle (returned from an NT SMB). NT5.0 seems
3363 * to do this call. JRA.
3364 */
3365 /* We know this name is ok, it's already passed the checks. */
3366 pstrcpy(fname, fsp->fsp_name);
3367
3368 if (INFO_LEVEL_IS_UNIX(info_level)) {
3369 /* Always do lstat for UNIX calls. */
3370 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3371 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3372 return UNIXERROR(ERRDOS,ERRbadpath);
3373 }
3374 } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
3375 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3376 return UNIXERROR(ERRDOS,ERRbadpath);
3377 }
3378
3379 delete_pending = get_delete_on_close_flag(file_id_sbuf(&sbuf));
3380 } else {
3381 /*
3382 * Original code - this is an open file.
3383 */
3384 CHECK_FSP(fsp,conn);
3385
3386 pstrcpy(fname, fsp->fsp_name);
3387 if (SMB_VFS_FSTAT(fsp,fsp->fh->fd,&sbuf) != 0) {
3388 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
3389 return(UNIXERROR(ERRDOS,ERRbadfid));
3390 }
3391 pos = fsp->fh->position_information;
3392 delete_pending = get_delete_on_close_flag(file_id_sbuf(&sbuf));
3393 access_mask = fsp->access_mask;
3394 }
3395 } else {
3396 NTSTATUS status = NT_STATUS_OK;
3397
3398 /* qpathinfo */
3399 if (total_params < 7) {
3400 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3401 }
3402
3403 info_level = SVAL(params,0);
3404
3405 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
3406
3407 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3408 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3409 }
3410
3411 srvstr_get_path(inbuf, SVAL(inbuf,smb_flg2), fname, &params[6],
3412 sizeof(fname), total_params - 6,
3413 STR_TERMINATE, &status);
3414 if (!NT_STATUS_IS_OK(status)) {
3415 return ERROR_NT(status);
3416 }
3417
3418 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
3419 if (!NT_STATUS_IS_OK(status)) {
3420 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
3421 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
3422 }
3423 return ERROR_NT(status);
3424 }
3425
3426 status = unix_convert(conn, fname, False, NULL, &sbuf);
3427 if (!NT_STATUS_IS_OK(status)) {
3428 return ERROR_NT(status);
3429 }
3430 status = check_name(conn, fname);
3431 if (!NT_STATUS_IS_OK(status)) {
3432 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,nt_errstr(status)));
3433 return ERROR_NT(status);
3434 }
3435
3436 if (INFO_LEVEL_IS_UNIX(info_level)) {
3437 /* Always do lstat for UNIX calls. */
3438 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3439 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3440 return UNIXERROR(ERRDOS,ERRbadpath);
3441 }
3442 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
3443 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3444 return UNIXERROR(ERRDOS,ERRbadpath);
3445 }
3446
3447 delete_pending = get_delete_on_close_flag(file_id_sbuf(&sbuf));
3448 if (delete_pending) {
3449 return ERROR_NT(NT_STATUS_DELETE_PENDING);
3450 }
3451 }
3452
3453 nlink = sbuf.st_nlink;
3454
3455 if ((nlink > 0) && S_ISDIR(sbuf.st_mode)) {
3456 /* NTFS does not seem to count ".." */
3457 nlink -= 1;
3458 }
3459
3460 if ((nlink > 0) && delete_pending) {
3461 nlink -= 1;
3462 }
3463
3464 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3465 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3466 }
3467
3468 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
3469 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
3470
3471 p = strrchr_m(fname,'/');
3472 if (!p)
3473 base_name = fname;
3474 else
3475 base_name = p+1;
3476
3477 mode = dos_mode(conn,fname,&sbuf);
3478 if (!mode)
3479 mode = FILE_ATTRIBUTE_NORMAL;
3480
3481 fullpathname = fname;
3482 if (!(mode & aDIR))
3483 file_size = get_file_size(sbuf);
3484
3485 /* Pull out any data sent here before we realloc. */
3486 switch (info_level) {
3487 case SMB_INFO_QUERY_EAS_FROM_LIST:
3488 {
3489 /* Pull any EA list from the data portion. */
3490 uint32 ea_size;
3491
3492 if (total_data < 4) {
3493 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3494 }
3495 ea_size = IVAL(pdata,0);
3496
3497 if (total_data > 0 && ea_size != total_data) {
3498 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
3499 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3500 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3501 }
3502
3503 if (!lp_ea_support(SNUM(conn))) {
3504 return ERROR_DOS(ERRDOS,ERReasnotsupported);
3505 }
3506
3507 if ((data_ctx = talloc_init("ea_list")) == NULL) {
3508 return ERROR_NT(NT_STATUS_NO_MEMORY);
3509 }
3510
3511 /* Pull out the list of names. */
3512 ea_list = read_ea_name_list(data_ctx, pdata + 4, ea_size - 4);
3513 if (!ea_list) {
3514 talloc_destroy(data_ctx);
3515 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3516 }
3517 break;
3518 }
3519
3520 case SMB_QUERY_POSIX_LOCK:
3521 {
3522 if (fsp == NULL || fsp->fh->fd == -1) {
3523 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
3524 }
3525
3526 if (total_data != POSIX_LOCK_DATA_SIZE) {
3527 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3528 }
3529
3530 if ((data_ctx = talloc_init("lock_request")) == NULL) {
3531 return ERROR_NT(NT_STATUS_NO_MEMORY);
3532 }
3533
3534 /* Copy the lock range data. */
3535 lock_data = (char *)TALLOC_MEMDUP(
3536 data_ctx, pdata, total_data);
3537 if (!lock_data) {
3538 talloc_destroy(data_ctx);
3539 return ERROR_NT(NT_STATUS_NO_MEMORY);
3540 }
3541 }
3542 default:
3543 break;
3544 }
3545
3546 *pparams = (char *)SMB_REALLOC(*pparams,2);
3547 if (*pparams == NULL) {
3548 talloc_destroy(data_ctx);
3549 return ERROR_NT(NT_STATUS_NO_MEMORY);
3550 }
3551 params = *pparams;
3552 SSVAL(params,0,0);
3553 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3554 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3555 if (*ppdata == NULL ) {
3556 talloc_destroy(data_ctx);
3557 return ERROR_NT(NT_STATUS_NO_MEMORY);
3558 }
3559 pdata = *ppdata;
3560
3561 create_time_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
3562 mtime_ts = get_mtimespec(&sbuf);
3563 atime_ts = get_atimespec(&sbuf);
3564
3565 allocation_size = get_allocation_size(conn,fsp,&sbuf);
3566
3567 if (fsp) {
3568 if (!null_timespec(fsp->pending_modtime)) {
3569 /* the pending modtime overrides the current modtime */
3570 mtime_ts = fsp->pending_modtime;
3571 }
3572 } else {
3573 /* Do we have this path open ? */
3574 files_struct *fsp1 = file_find_di_first(file_id_sbuf(&sbuf));
3575 if (fsp1 && !null_timespec(fsp1->pending_modtime)) {
3576 /* the pending modtime overrides the current modtime */
3577 mtime_ts = fsp1->pending_modtime;
3578 }
3579 if (fsp1 && fsp1->initial_allocation_size) {
3580 allocation_size = get_allocation_size(conn, fsp1, &sbuf);
3581 }
3582 }
3583
3584 if (lp_dos_filetime_resolution(SNUM(conn))) {
3585 dos_filetime_timespec(&create_time_ts);
3586 dos_filetime_timespec(&mtime_ts);
3587 dos_filetime_timespec(&atime_ts);
3588 }
3589
3590 create_time = convert_timespec_to_time_t(create_time_ts);
3591 mtime = convert_timespec_to_time_t(mtime_ts);
3592 atime = convert_timespec_to_time_t(atime_ts);
3593
3594 /* NT expects the name to be in an exact form of the *full*
3595 filename. See the trans2 torture test */
3596 if (strequal(base_name,".")) {
3597 pstrcpy(dos_fname, "\\");
3598 } else {
3599 pstr_sprintf(dos_fname, "\\%s", fname);
3600 string_replace(dos_fname, '/', '\\');
3601 }
3602
3603 switch (info_level) {
3604 case SMB_INFO_STANDARD:
3605 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
3606 data_size = 22;
3607 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
3608 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
3609 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
3610 SIVAL(pdata,l1_cbFile,(uint32)file_size);
3611 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
3612 SSVAL(pdata,l1_attrFile,mode);
3613 break;
3614
3615 case SMB_INFO_QUERY_EA_SIZE:
3616 {
3617 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3618 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
3619 data_size = 26;
3620 srv_put_dos_date2(pdata,0,create_time);
3621 srv_put_dos_date2(pdata,4,atime);
3622 srv_put_dos_date2(pdata,8,mtime); /* write time */
3623 SIVAL(pdata,12,(uint32)file_size);
3624 SIVAL(pdata,16,(uint32)allocation_size);
3625 SSVAL(pdata,20,mode);
3626 SIVAL(pdata,22,ea_size);
3627 break;
3628 }
3629
3630 case SMB_INFO_IS_NAME_VALID:
3631 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
3632 if (tran_call == TRANSACT2_QFILEINFO) {
3633 /* os/2 needs this ? really ?*/
3634 return ERROR_DOS(ERRDOS,ERRbadfunc);
3635 }
3636 data_size = 0;
3637 param_size = 0;
3638 break;
3639
3640 case SMB_INFO_QUERY_EAS_FROM_LIST:
3641 {
3642 size_t total_ea_len = 0;
3643 struct ea_list *ea_file_list = NULL;
3644
3645 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
3646
3647 ea_file_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3648 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
3649
3650 if (!ea_list || (total_ea_len > data_size)) {
3651 talloc_destroy(data_ctx);
3652 data_size = 4;
3653 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
3654 break;
3655 }
3656
3657 data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3658 talloc_destroy(data_ctx);
3659 break;
3660 }
3661
3662 case SMB_INFO_QUERY_ALL_EAS:
3663 {
3664 /* We have data_size bytes to put EA's into. */
3665 size_t total_ea_len = 0;
3666
3667 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
3668
3669 data_ctx = talloc_init("ea_ctx");
3670 if (!data_ctx) {
3671 return ERROR_NT(NT_STATUS_NO_MEMORY);
3672 }
3673
3674 ea_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3675 if (!ea_list || (total_ea_len > data_size)) {
3676 talloc_destroy(data_ctx);
3677 data_size = 4;
3678 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
3679 break;
3680 }
3681
3682 data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3683 talloc_destroy(data_ctx);
3684 break;
3685 }
3686
3687 case SMB_FILE_BASIC_INFORMATION:
3688 case SMB_QUERY_FILE_BASIC_INFO:
3689
3690 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
3691 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
3692 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
3693 } else {
3694 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
3695 data_size = 40;
3696 SIVAL(pdata,36,0);
3697 }
3698 put_long_date_timespec(pdata,create_time_ts);
3699 put_long_date_timespec(pdata+8,atime_ts);
3700 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3701 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3702 SIVAL(pdata,32,mode);
3703
3704 DEBUG(5,("SMB_QFBI - "));
3705 DEBUG(5,("create: %s ", ctime(&create_time)));
3706 DEBUG(5,("access: %s ", ctime(&atime)));
3707 DEBUG(5,("write: %s ", ctime(&mtime)));
3708 DEBUG(5,("change: %s ", ctime(&mtime)));
3709 DEBUG(5,("mode: %x\n", mode));
3710 break;
3711
3712 case SMB_FILE_STANDARD_INFORMATION:
3713 case SMB_QUERY_FILE_STANDARD_INFO:
3714
3715 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
3716 data_size = 24;
3717 SOFF_T(pdata,0,allocation_size);
3718 SOFF_T(pdata,8,file_size);
3719 SIVAL(pdata,16,nlink);
3720 SCVAL(pdata,20,delete_pending?1:0);
3721 SCVAL(pdata,21,(mode&aDIR)?1:0);
3722 SSVAL(pdata,22,0); /* Padding. */
3723 break;
3724
3725 case SMB_FILE_EA_INFORMATION:
3726 case SMB_QUERY_FILE_EA_INFO:
3727 {
3728 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3729 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
3730 data_size = 4;
3731 SIVAL(pdata,0,ea_size);
3732 break;
3733 }
3734
3735 /* Get the 8.3 name - used if NT SMB was negotiated. */
3736 case SMB_QUERY_FILE_ALT_NAME_INFO:
3737 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
3738 {
3739 pstring short_name;
3740
3741 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
3742 pstrcpy(short_name,base_name);
3743 /* Mangle if not already 8.3 */
3744 if(!mangle_is_8_3(short_name, True, conn->params)) {
3745 mangle_map(short_name,True,True,conn->params);
3746 }
3747 len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
3748 data_size = 4 + len;
3749 SIVAL(pdata,0,len);
3750 break;
3751 }
3752
3753 case SMB_QUERY_FILE_NAME_INFO:
3754 /*
3755 this must be *exactly* right for ACLs on mapped drives to work
3756 */
3757 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3758 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
3759 data_size = 4 + len;
3760 SIVAL(pdata,0,len);
3761 break;
3762
3763 case SMB_FILE_ALLOCATION_INFORMATION:
3764 case SMB_QUERY_FILE_ALLOCATION_INFO:
3765 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
3766 data_size = 8;
3767 SOFF_T(pdata,0,allocation_size);
3768 break;
3769
3770 case SMB_FILE_END_OF_FILE_INFORMATION:
3771 case SMB_QUERY_FILE_END_OF_FILEINFO:
3772 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
3773 data_size = 8;
3774 SOFF_T(pdata,0,file_size);
3775 break;
3776
3777 case SMB_QUERY_FILE_ALL_INFO:
3778 case SMB_FILE_ALL_INFORMATION:
3779 {
3780 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3781 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
3782 put_long_date_timespec(pdata,create_time_ts);
3783 put_long_date_timespec(pdata+8,atime_ts);
3784 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3785 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3786 SIVAL(pdata,32,mode);
3787 SIVAL(pdata,36,0); /* padding. */
3788 pdata += 40;
3789 SOFF_T(pdata,0,allocation_size);
3790 SOFF_T(pdata,8,file_size);
3791 SIVAL(pdata,16,nlink);
3792 SCVAL(pdata,20,delete_pending);
3793 SCVAL(pdata,21,(mode&aDIR)?1:0);
3794 SSVAL(pdata,22,0);
3795 pdata += 24;
3796 SIVAL(pdata,0,ea_size);
3797 pdata += 4; /* EA info */
3798 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3799 SIVAL(pdata,0,len);
3800 pdata += 4 + len;
3801 data_size = PTR_DIFF(pdata,(*ppdata));
3802 break;
3803 }
3804 case SMB_FILE_INTERNAL_INFORMATION:
3805 /* This should be an index number - looks like
3806 dev/ino to me :-)
3807
3808 I think this causes us to fail the IFSKIT
3809 BasicFileInformationTest. -tpot */
3810
3811 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
3812 SIVAL(pdata,0,sbuf.st_ino); /* FileIndexLow */
3813 SIVAL(pdata,4,sbuf.st_dev); /* FileIndexHigh */
3814 data_size = 8;
3815 break;
3816
3817 case SMB_FILE_ACCESS_INFORMATION:
3818 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
3819 SIVAL(pdata,0,access_mask);
3820 data_size = 4;
3821 break;
3822
3823 case SMB_FILE_NAME_INFORMATION:
3824 /* Pathname with leading '\'. */
3825 {
3826 size_t byte_len;
3827 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
3828 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
3829 SIVAL(pdata,0,byte_len);
3830 data_size = 4 + byte_len;
3831 break;
3832 }
3833
3834 case SMB_FILE_DISPOSITION_INFORMATION:
3835 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
3836 data_size = 1;
3837 SCVAL(pdata,0,delete_pending);
3838 break;
3839
3840 case SMB_FILE_POSITION_INFORMATION:
3841 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
3842 data_size = 8;
3843 SOFF_T(pdata,0,pos);
3844 break;
3845
3846 case SMB_FILE_MODE_INFORMATION:
3847 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
3848 SIVAL(pdata,0,mode);
3849 data_size = 4;
3850 break;
3851
3852 case SMB_FILE_ALIGNMENT_INFORMATION:
3853 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
3854 SIVAL(pdata,0,0); /* No alignment needed. */
3855 data_size = 4;
3856 break;
3857
3858 #if 0
3859 /*
3860 * NT4 server just returns "invalid query" to this - if we try to answer
3861 * it then NTws gets a BSOD! (tridge).
3862 * W2K seems to want this. JRA.
3863 */
3864 case SMB_QUERY_FILE_STREAM_INFO:
3865 #endif
3866 case SMB_FILE_STREAM_INFORMATION:
3867 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
3868 if (mode & aDIR) {
3869 data_size = 0;
3870 } else {
3871 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", (size_t)0xE, False);
3872 SIVAL(pdata,0,0); /* ??? */
3873 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
3874 SOFF_T(pdata,8,file_size);
3875 SOFF_T(pdata,16,allocation_size);
3876 data_size = 24 + byte_len;
3877 }
3878 break;
3879
3880 case SMB_QUERY_COMPRESSION_INFO:
3881 case SMB_FILE_COMPRESSION_INFORMATION:
3882 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
3883 SOFF_T(pdata,0,file_size);
3884 SIVAL(pdata,8,0); /* ??? */
3885 SIVAL(pdata,12,0); /* ??? */
3886 data_size = 16;
3887 break;
3888
3889 case SMB_FILE_NETWORK_OPEN_INFORMATION:
3890 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
3891 put_long_date_timespec(pdata,create_time_ts);
3892 put_long_date_timespec(pdata+8,atime_ts);
3893 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3894 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3895 SOFF_T(pdata,32,allocation_size);
3896 SOFF_T(pdata,40,file_size);
3897 SIVAL(pdata,48,mode);
3898 SIVAL(pdata,52,0); /* ??? */
3899 data_size = 56;
3900 break;
3901
3902 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
3903 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
3904 SIVAL(pdata,0,mode);
3905 SIVAL(pdata,4,0);
3906 data_size = 8;
3907 break;
3908
3909 /*
3910 * CIFS UNIX Extensions.
3911 */
3912
3913 case SMB_QUERY_FILE_UNIX_BASIC:
3914
3915 pdata = store_file_unix_basic(conn, pdata, fsp, &sbuf);
3916 data_size = PTR_DIFF(pdata,(*ppdata));
3917
3918 {
3919 int i;
3920 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
3921
3922 for (i=0; i<100; i++)
3923 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3924 DEBUG(4,("\n"));
3925 }
3926
3927 break;
3928
3929 case SMB_QUERY_FILE_UNIX_INFO2:
3930
3931 pdata = store_file_unix_basic_info2(conn, pdata, fsp, &sbuf);
3932 data_size = PTR_DIFF(pdata,(*ppdata));
3933
3934 {
3935 int i;
3936 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
3937
3938 for (i=0; i<100; i++)
3939 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3940 DEBUG(4,("\n"));
3941 }
3942
3943 break;
3944
3945 case SMB_QUERY_FILE_UNIX_LINK:
3946 {
3947 pstring buffer;
3948
3949 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
3950 #ifdef S_ISLNK
3951 if(!S_ISLNK(sbuf.st_mode))
3952 return(UNIXERROR(ERRSRV,ERRbadlink));
3953 #else
3954 return(UNIXERROR(ERRDOS,ERRbadlink));
3955 #endif
3956 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1); /* read link */
3957 if (len == -1)
3958 return(UNIXERROR(ERRDOS,ERRnoaccess));
3959 buffer[len] = 0;
3960 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
3961 pdata += len;
3962 data_size = PTR_DIFF(pdata,(*ppdata));
3963
3964 break;
3965 }
3966
3967 #if defined(HAVE_POSIX_ACLS)
3968 case SMB_QUERY_POSIX_ACL:
3969 {
3970 SMB_ACL_T file_acl = NULL;
3971 SMB_ACL_T def_acl = NULL;
3972 uint16 num_file_acls = 0;
3973 uint16 num_def_acls = 0;
3974
3975 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
3976 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fh->fd);
3977 } else {
3978 file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
3979 }
3980
3981 if (file_acl == NULL && no_acl_syscall_error(errno)) {
3982 DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
3983 fname ));
3984 return ERROR_NT(NT_STATUS_NOT_IMPLEMENTED);
3985 }
3986
3987 if (S_ISDIR(sbuf.st_mode)) {
3988 if (fsp && fsp->is_directory) {
3989 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
3990 } else {
3991 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
3992 }
3993 def_acl = free_empty_sys_acl(conn, def_acl);
3994 }
3995
3996 num_file_acls = count_acl_entries(conn, file_acl);
3997 num_def_acls = count_acl_entries(conn, def_acl);
3998
3999 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4000 DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
4001 data_size,
4002 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4003 SMB_POSIX_ACL_HEADER_SIZE) ));
4004 if (file_acl) {
4005 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4006 }
4007 if (def_acl) {
4008 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4009 }
4010 return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
4011 }
4012
4013 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4014 SSVAL(pdata,2,num_file_acls);
4015 SSVAL(pdata,4,num_def_acls);
4016 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
4017 if (file_acl) {
4018 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4019 }
4020 if (def_acl) {
4021 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4022 }
4023 return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
4024 }
4025 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
4026 if (file_acl) {
4027 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4028 }
4029 if (def_acl) {
4030 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4031 }
4032 return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
4033 }
4034
4035 if (file_acl) {
4036 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4037 }
4038 if (def_acl) {
4039 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4040 }
4041 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4042 break;
4043 }
4044 #endif
4045
4046
4047 case SMB_QUERY_POSIX_LOCK:
4048 {
4049 NTSTATUS status = NT_STATUS_INVALID_LEVEL;
4050 SMB_BIG_UINT count;
4051 SMB_BIG_UINT offset;
4052 uint32 lock_pid;
4053 enum brl_type lock_type;
4054
4055 if (total_data != POSIX_LOCK_DATA_SIZE) {
4056 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4057 }
4058
4059 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4060 case POSIX_LOCK_TYPE_READ:
4061 lock_type = READ_LOCK;
4062 break;
4063 case POSIX_LOCK_TYPE_WRITE:
4064 lock_type = WRITE_LOCK;
4065 break;
4066 case POSIX_LOCK_TYPE_UNLOCK:
4067 default:
4068 /* There's no point in asking for an unlock... */
4069 talloc_destroy(data_ctx);
4070 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4071 }
4072
4073 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4074 #if defined(HAVE_LONGLONG)
4075 offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4076 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4077 count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4078 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4079 #else /* HAVE_LONGLONG */
4080 offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4081 count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4082 #endif /* HAVE_LONGLONG */
4083
4084 status = query_lock(fsp,
4085 &lock_pid,
4086 &count,
4087 &offset,
4088 &lock_type,
4089 POSIX_LOCK);
4090
4091 if (ERROR_WAS_LOCK_DENIED(status)) {
4092 /* Here we need to report who has it locked... */
4093 data_size = POSIX_LOCK_DATA_SIZE;
4094
4095 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
4096 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
4097 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
4098 #if defined(HAVE_LONGLONG)
4099 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
4100 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
4101 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
4102 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
4103 #else /* HAVE_LONGLONG */
4104 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
4105 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
4106 #endif /* HAVE_LONGLONG */
4107
4108 } else if (NT_STATUS_IS_OK(status)) {
4109 /* For success we just return a copy of what we sent
4110 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4111 data_size = POSIX_LOCK_DATA_SIZE;
4112 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
4113 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
4114 } else {
4115 return ERROR_NT(status);
4116 }
4117 break;
4118 }
4119
4120 default:
4121 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
4122 }
4123
4124 send_trans2_replies(inbuf, outbuf, bufsize, params, param_size, *ppdata, data_size, max_data_bytes);
4125
4126 return(-1);
4127 }
4128
4129 /****************************************************************************
4130 Set a hard link (called by UNIX extensions and by NT rename with HARD link
4131 code.
4132 ****************************************************************************/
4133
4134 NTSTATUS hardlink_internals(connection_struct *conn, pstring oldname, pstring newname)
4135 {
4136 SMB_STRUCT_STAT sbuf1, sbuf2;
4137 pstring last_component_oldname;
4138 pstring last_component_newname;
4139 NTSTATUS status = NT_STATUS_OK;
4140
4141 ZERO_STRUCT(sbuf1);
4142 ZERO_STRUCT(sbuf2);
4143
4144 status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
4145 if (!NT_STATUS_IS_OK(status)) {
4146 return status;
4147 }
4148
4149 status = check_name(conn, oldname);
4150 if (!NT_STATUS_IS_OK(status)) {
4151 return status;
4152 }
4153
4154 /* source must already exist. */
4155 if (!VALID_STAT(sbuf1)) {
4156 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4157 }
4158
4159 status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
4160 if (!NT_STATUS_IS_OK(status)) {
4161 return status;
4162 }
4163
4164 status = check_name(conn, newname);
4165 if (!NT_STATUS_IS_OK(status)) {
4166 return status;
4167 }
4168
4169 /* Disallow if newname already exists. */
4170 if (VALID_STAT(sbuf2)) {
4171 return NT_STATUS_OBJECT_NAME_COLLISION;
4172 }
4173
4174 /* No links from a directory. */
4175 if (S_ISDIR(sbuf1.st_mode)) {
4176 return NT_STATUS_FILE_IS_A_DIRECTORY;
4177 }
4178
4179 /* Ensure this is within the share. */
4180 status = reduce_name(conn, oldname);
4181 if (!NT_STATUS_IS_OK(status)) {
4182 return status;
4183 }
4184
4185 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
4186
4187 if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
4188 status = map_nt_error_from_unix(errno);
4189 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
4190 nt_errstr(status), newname, oldname));
4191 }
4192
4193 return status;
4194 }
4195
4196 /****************************************************************************
4197 Deal with setting the time from any of the setfilepathinfo functions.
4198 ****************************************************************************/
4199
4200 static NTSTATUS smb_set_file_time(connection_struct *conn,
4201 files_struct *fsp,
4202 const char *fname,
4203 const SMB_STRUCT_STAT *psbuf,
4204 struct timespec ts[2])
4205 {
4206 uint32 action =
4207 FILE_NOTIFY_CHANGE_LAST_ACCESS
4208 |FILE_NOTIFY_CHANGE_LAST_WRITE;
4209
4210
4211 if (!VALID_STAT(*psbuf)) {
4212 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4213 }
4214
4215 /* get some defaults (no modifications) if any info is zero or -1. */
4216 if (null_timespec(ts[0])) {
4217 ts[0] = get_atimespec(psbuf);
4218 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
4219 }
4220
4221 if (null_timespec(ts[1])) {
4222 ts[1] = get_mtimespec(psbuf);
4223 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
4224 }
4225
4226 DEBUG(6,("smb_set_file_time: actime: %s " , time_to_asc(convert_timespec_to_time_t(ts[0])) ));
4227 DEBUG(6,("smb_set_file_time: modtime: %s ", time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4228
4229 /*
4230 * Try and set the times of this file if
4231 * they are different from the current values.
4232 */
4233
4234 {
4235 struct timespec mts = get_mtimespec(psbuf);
4236 struct timespec ats = get_atimespec(psbuf);
4237 if ((timespec_compare(&ts[0], &ats) == 0) && (timespec_compare(&ts[1], &mts) == 0)) {
4238 return NT_STATUS_OK;
4239 }
4240 }
4241
4242 if(fsp != NULL) {
4243 /*
4244 * This was a setfileinfo on an open file.
4245 * NT does this a lot. We also need to
4246 * set the time here, as it can be read by
4247 * FindFirst/FindNext and with the patch for bug #2045
4248 * in smbd/fileio.c it ensures that this timestamp is
4249 * kept sticky even after a write. We save the request
4250 * away and will set it on file close and after a write. JRA.
4251 */
4252
4253 if (!null_timespec(ts[1])) {
4254 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
4255 time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4256 fsp_set_pending_modtime(fsp, ts[1]);
4257 }
4258
4259 }
4260 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
4261
4262 if(file_ntimes(conn, fname, ts)!=0) {
4263 return map_nt_error_from_unix(errno);
4264 }
4265 if (action != 0) {
4266 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action, fname);
4267 }
4268 return NT_STATUS_OK;
4269 }
4270
4271 /****************************************************************************
4272 Deal with setting the dosmode from any of the setfilepathinfo functions.
4273 ****************************************************************************/
4274
4275 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
4276 const char *fname,
4277 SMB_STRUCT_STAT *psbuf,
4278 uint32 dosmode)
4279 {
4280 if (!VALID_STAT(*psbuf)) {
4281 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4282 }
4283
4284 if (dosmode) {
4285 if (S_ISDIR(psbuf->st_mode)) {
4286 dosmode |= aDIR;
4287 } else {
4288 dosmode &= ~aDIR;
4289 }
4290 }
4291
4292 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
4293
4294 /* check the mode isn't different, before changing it */
4295 if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, psbuf))) {
4296
4297 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode 0x%x\n",
4298 fname, (unsigned int)dosmode ));
4299
4300 if(file_set_dosmode(conn, fname, dosmode, psbuf, False)) {
4301 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of %s failed (%s)\n",
4302 fname, strerror(errno)));
4303 return map_nt_error_from_unix(errno);
4304 }
4305 }
4306 return NT_STATUS_OK;
4307 }
4308
4309 /****************************************************************************
4310 Deal with setting the size from any of the setfilepathinfo functions.
4311 ****************************************************************************/
4312
4313 static NTSTATUS smb_set_file_size(connection_struct *conn,
4314 struct smb_request *req,
4315 files_struct *fsp,
4316 const char *fname,
4317 SMB_STRUCT_STAT *psbuf,
4318 SMB_OFF_T size)
4319 {
4320 NTSTATUS status = NT_STATUS_OK;
4321 files_struct *new_fsp = NULL;
4322
4323 if (!VALID_STAT(*psbuf)) {
4324 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4325 }
4326
4327 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
4328
4329 if (size == get_file_size(*psbuf)) {
4330 return NT_STATUS_OK;
4331 }
4332
4333 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
4334 fname, (double)size ));
4335
4336 if (fsp && fsp->fh->fd != -1) {
4337 /* Handle based call. */
4338 if (vfs_set_filelen(fsp, size) == -1) {
4339 return map_nt_error_from_unix(errno);
4340 }
4341 return NT_STATUS_OK;
4342 }
4343
4344 status = open_file_ntcreate(conn, req, fname, psbuf,
4345 FILE_WRITE_DATA,
4346 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4347 FILE_OPEN,
4348 0,
4349 FILE_ATTRIBUTE_NORMAL,
4350 FORCE_OPLOCK_BREAK_TO_NONE,
4351 NULL, &new_fsp);
4352
4353 if (!NT_STATUS_IS_OK(status)) {
4354 /* NB. We check for open_was_deferred in the caller. */
4355 return status;
4356 }
4357
4358 if (vfs_set_filelen(new_fsp, size) == -1) {
4359 status = map_nt_error_from_unix(errno);
4360 close_file(new_fsp,NORMAL_CLOSE);
4361 return status;
4362 }
4363
4364 close_file(new_fsp,NORMAL_CLOSE);
4365 return NT_STATUS_OK;
4366 }
4367
4368 /****************************************************************************
4369 Deal with SMB_INFO_SET_EA.
4370 ****************************************************************************/
4371
4372 static NTSTATUS smb_info_set_ea(connection_struct *conn,
4373 const char *pdata,
4374 int total_data,
4375 files_struct *fsp,
4376 const char *fname)
4377 {
4378 struct ea_list *ea_list = NULL;
4379 TALLOC_CTX *ctx = NULL;
4380 NTSTATUS status = NT_STATUS_OK;
4381
4382 if (total_data < 10) {
4383
4384 /* OS/2 workplace shell seems to send SET_EA requests of "null"
4385 length. They seem to have no effect. Bug #3212. JRA */
4386
4387 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
4388 /* We're done. We only get EA info in this call. */
4389 return NT_STATUS_OK;
4390 }
4391
4392 return NT_STATUS_INVALID_PARAMETER;
4393 }
4394
4395 if (IVAL(pdata,0) > total_data) {
4396 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
4397 IVAL(pdata,0), (unsigned int)total_data));
4398 return NT_STATUS_INVALID_PARAMETER;
4399 }
4400
4401 ctx = talloc_init("SMB_INFO_SET_EA");
4402 if (!ctx) {
4403 return NT_STATUS_NO_MEMORY;
4404 }
4405 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
4406 if (!ea_list) {
4407 talloc_destroy(ctx);
4408 return NT_STATUS_INVALID_PARAMETER;
4409 }
4410 status = set_ea(conn, fsp, fname, ea_list);
4411 talloc_destroy(ctx);
4412
4413 return status;
4414 }
4415
4416 /****************************************************************************
4417 Deal with SMB_SET_FILE_DISPOSITION_INFO.
4418 ****************************************************************************/
4419
4420 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
4421 const char *pdata,
4422 int total_data,
4423 files_struct *fsp,
4424 const char *fname,
4425 SMB_STRUCT_STAT *psbuf)
4426 {
4427 NTSTATUS status = NT_STATUS_OK;
4428 BOOL delete_on_close;
4429 uint32 dosmode = 0;
4430
4431 if (total_data < 1) {
4432 return NT_STATUS_INVALID_PARAMETER;
4433 }
4434
4435 if (fsp == NULL) {
4436 return NT_STATUS_INVALID_HANDLE;
4437 }
4438
4439 delete_on_close = (CVAL(pdata,0) ? True : False);
4440 dosmode = dos_mode(conn, fname, psbuf);
4441
4442 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
4443 "delete_on_close = %u\n",
4444 fsp->fsp_name,
4445 (unsigned int)dosmode,
4446 (unsigned int)delete_on_close ));
4447
4448 status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
4449
4450 if (!NT_STATUS_IS_OK(status)) {
4451 return status;
4452 }
4453
4454 /* The set is across all open files on this dev/inode pair. */
4455 if (!set_delete_on_close(fsp, delete_on_close, &current_user.ut)) {
4456 return NT_STATUS_ACCESS_DENIED;
4457 }
4458 return NT_STATUS_OK;
4459 }
4460
4461 /****************************************************************************
4462 Deal with SMB_FILE_POSITION_INFORMATION.
4463 ****************************************************************************/
4464
4465 static NTSTATUS smb_file_position_information(connection_struct *conn,
4466 const char *pdata,
4467 int total_data,
4468 files_struct *fsp)
4469 {
4470 SMB_BIG_UINT position_information;
4471
4472 if (total_data < 8) {
4473 return NT_STATUS_INVALID_PARAMETER;
4474 }
4475
4476 if (fsp == NULL) {
4477 /* Ignore on pathname based set. */
4478 return NT_STATUS_OK;
4479 }
4480
4481 position_information = (SMB_BIG_UINT)IVAL(pdata,0);
4482 #ifdef LARGE_SMB_OFF_T
4483 position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4484 #else /* LARGE_SMB_OFF_T */
4485 if (IVAL(pdata,4) != 0) {
4486 /* more than 32 bits? */
4487 return NT_STATUS_INVALID_PARAMETER;
4488 }
4489 #endif /* LARGE_SMB_OFF_T */
4490
4491 DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
4492 fsp->fsp_name, (double)position_information ));
4493 fsp->fh->position_information = position_information;
4494 return NT_STATUS_OK;
4495 }
4496
4497 /****************************************************************************
4498 Deal with SMB_FILE_MODE_INFORMATION.
4499 ****************************************************************************/
4500
4501 static NTSTATUS smb_file_mode_information(connection_struct *conn,
4502 const char *pdata,
4503 int total_data)
4504 {
4505 uint32 mode;
4506
4507 if (total_data < 4) {
4508 return NT_STATUS_INVALID_PARAMETER;
4509 }
4510 mode = IVAL(pdata,0);
4511 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
4512 return NT_STATUS_INVALID_PARAMETER;
4513 }
4514 return NT_STATUS_OK;
4515 }
4516
4517 /****************************************************************************
4518 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
4519 ****************************************************************************/
4520
4521 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
4522 char *inbuf,
4523 const char *pdata,
4524 int total_data,
4525 const char *fname)
4526 {
4527 pstring link_target;
4528 const char *newname = fname;
4529 NTSTATUS status = NT_STATUS_OK;
4530
4531 /* Set a symbolic link. */
4532 /* Don't allow this if follow links is false. */
4533
4534 if (total_data == 0) {
4535 return NT_STATUS_INVALID_PARAMETER;
4536 }
4537
4538 if (!lp_symlinks(SNUM(conn))) {
4539 return NT_STATUS_ACCESS_DENIED;
4540 }
4541
4542 srvstr_pull(inbuf, SVAL(inbuf, smb_flg2), link_target, pdata,
4543 sizeof(link_target), total_data, STR_TERMINATE);
4544
4545 /* !widelinks forces the target path to be within the share. */
4546 /* This means we can interpret the target as a pathname. */
4547 if (!lp_widelinks(SNUM(conn))) {
4548 pstring rel_name;
4549 char *last_dirp = NULL;
4550
4551 if (*link_target == '/') {
4552 /* No absolute paths allowed. */
4553 return NT_STATUS_ACCESS_DENIED;
4554 }
4555 pstrcpy(rel_name, newname);
4556 last_dirp = strrchr_m(rel_name, '/');
4557 if (last_dirp) {
4558 last_dirp[1] = '\0';
4559 } else {
4560 pstrcpy(rel_name, "./");
4561 }
4562 pstrcat(rel_name, link_target);
4563
4564 status = check_name(conn, rel_name);
4565 if (!NT_STATUS_IS_OK(status)) {
4566 return status;
4567 }
4568 }
4569
4570 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
4571 newname, link_target ));
4572
4573 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
4574 return map_nt_error_from_unix(errno);
4575 }
4576
4577 return NT_STATUS_OK;
4578 }
4579
4580 /****************************************************************************
4581 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
4582 ****************************************************************************/
4583
4584 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
4585 char *inbuf,
4586 char *outbuf,
4587 const char *pdata,
4588 int total_data,
4589 pstring fname)
4590 {
4591 pstring oldname;
4592 NTSTATUS status = NT_STATUS_OK;
4593
4594 /* Set a hard link. */
4595 if (total_data == 0) {
4596 return NT_STATUS_INVALID_PARAMETER;
4597 }
4598
4599 srvstr_get_path(inbuf, SVAL(inbuf,smb_flg2), oldname, pdata,
4600 sizeof(oldname), total_data, STR_TERMINATE, &status);
4601 if (!NT_STATUS_IS_OK(status)) {
4602 return status;
4603 }
4604
4605 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, oldname);
4606 if (!NT_STATUS_IS_OK(status)) {
4607 return status;
4608 }
4609
4610 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
4611 fname, oldname));
4612
4613 return hardlink_internals(conn, oldname, fname);
4614 }
4615
4616 /****************************************************************************
4617 Deal with SMB_FILE_RENAME_INFORMATION.
4618 ****************************************************************************/
4619
4620 static NTSTATUS smb_file_rename_information(connection_struct *conn,
4621 struct smb_request *req,
4622 char *inbuf,
4623 char *outbuf,
4624 const char *pdata,
4625 int total_data,
4626 files_struct *fsp,
4627 pstring fname)
4628 {
4629 BOOL overwrite;
4630 uint32 root_fid;
4631 uint32 len;
4632 pstring newname;
4633 pstring base_name;
4634 BOOL dest_has_wcard = False;
4635 NTSTATUS status = NT_STATUS_OK;
4636 char *p;
4637
4638 if (total_data < 13) {
4639 return NT_STATUS_INVALID_PARAMETER;
4640 }
4641
4642 overwrite = (CVAL(pdata,0) ? True : False);
4643 root_fid = IVAL(pdata,4);
4644 len = IVAL(pdata,8);
4645
4646 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
4647 return NT_STATUS_INVALID_PARAMETER;
4648 }
4649
4650 srvstr_get_path_wcard(inbuf, SVAL(inbuf,smb_flg2), newname, &pdata[12],
4651 sizeof(newname), len, 0, &status,
4652 &dest_has_wcard);
4653 if (!NT_STATUS_IS_OK(status)) {
4654 return status;
4655 }
4656
4657 status = resolve_dfspath_wcard(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, newname, &dest_has_wcard);
4658 if (!NT_STATUS_IS_OK(status)) {
4659 return status;
4660 }
4661
4662 /* Check the new name has no '/' characters. */
4663 if (strchr_m(newname, '/')) {
4664 return NT_STATUS_NOT_SUPPORTED;
4665 }
4666
4667 /* Create the base directory. */
4668 pstrcpy(base_name, fname);
4669 p = strrchr_m(base_name, '/');
4670 if (p) {
4671 p[1] = '\0';
4672 } else {
4673 pstrcpy(base_name, "./");
4674 }
4675 /* Append the new name. */
4676 pstrcat(base_name, newname);
4677
4678 if (fsp) {
4679 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
4680 fsp->fnum, fsp->fsp_name, base_name ));
4681 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
4682 } else {
4683 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
4684 fname, newname ));
4685 status = rename_internals(conn, req, fname, base_name, 0,
4686 overwrite, False, dest_has_wcard);
4687 }
4688
4689 return status;
4690 }
4691
4692 /****************************************************************************
4693 Deal with SMB_SET_POSIX_ACL.
4694 ****************************************************************************/
4695
4696 #if defined(HAVE_POSIX_ACLS)
4697 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
4698 const char *pdata,
4699 int total_data,
4700 files_struct *fsp,
4701 const char *fname,
4702 SMB_STRUCT_STAT *psbuf)
4703 {
4704 uint16 posix_acl_version;
4705 uint16 num_file_acls;
4706 uint16 num_def_acls;
4707 BOOL valid_file_acls = True;
4708 BOOL valid_def_acls = True;
4709
4710 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
4711 return NT_STATUS_INVALID_PARAMETER;
4712 }
4713 posix_acl_version = SVAL(pdata,0);
4714 num_file_acls = SVAL(pdata,2);
4715 num_def_acls = SVAL(pdata,4);
4716
4717 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4718 valid_file_acls = False;
4719 num_file_acls = 0;
4720 }
4721
4722 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4723 valid_def_acls = False;
4724 num_def_acls = 0;
4725 }
4726
4727 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
4728 return NT_STATUS_INVALID_PARAMETER;
4729 }
4730
4731 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
4732 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
4733 return NT_STATUS_INVALID_PARAMETER;
4734 }
4735
4736 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
4737 fname ? fname : fsp->fsp_name,
4738 (unsigned int)num_file_acls,
4739 (unsigned int)num_def_acls));
4740
4741 if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
4742 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
4743 return map_nt_error_from_unix(errno);
4744 }
4745
4746 if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, psbuf, num_def_acls,
4747 pdata + SMB_POSIX_ACL_HEADER_SIZE +
4748 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
4749 return map_nt_error_from_unix(errno);
4750 }
4751 return NT_STATUS_OK;
4752 }
4753 #endif
4754
4755 /****************************************************************************
4756 Deal with SMB_SET_POSIX_LOCK.
4757 ****************************************************************************/
4758
4759 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
4760 char *inbuf,
4761 int length,
4762 const char *pdata,
4763 int total_data,
4764 files_struct *fsp)
4765 {
4766 SMB_BIG_UINT count;
4767 SMB_BIG_UINT offset;
4768 uint32 lock_pid;
4769 BOOL blocking_lock = False;
4770 enum brl_type lock_type;
4771 NTSTATUS status = NT_STATUS_OK;
4772
4773 if (fsp == NULL || fsp->fh->fd == -1) {
4774 return NT_STATUS_INVALID_HANDLE;
4775 }
4776
4777 if (total_data != POSIX_LOCK_DATA_SIZE) {
4778 return NT_STATUS_INVALID_PARAMETER;
4779 }
4780
4781 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4782 case POSIX_LOCK_TYPE_READ:
4783 lock_type = READ_LOCK;
4784 break;
4785 case POSIX_LOCK_TYPE_WRITE:
4786 /* Return the right POSIX-mappable error code for files opened read-only. */
4787 if (!fsp->can_write) {
4788 return NT_STATUS_INVALID_HANDLE;
4789 }
4790 lock_type = WRITE_LOCK;
4791 break;
4792 case POSIX_LOCK_TYPE_UNLOCK:
4793 lock_type = UNLOCK_LOCK;
4794 break;
4795 default:
4796 return NT_STATUS_INVALID_PARAMETER;
4797 }
4798
4799 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
4800 blocking_lock = False;
4801 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
4802 blocking_lock = True;
4803 } else {
4804 return NT_STATUS_INVALID_PARAMETER;
4805 }
4806
4807 if (!lp_blocking_locks(SNUM(conn))) {
4808 blocking_lock = False;
4809 }
4810
4811 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4812 #if defined(HAVE_LONGLONG)
4813 offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4814 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4815 count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4816 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4817 #else /* HAVE_LONGLONG */
4818 offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4819 count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4820 #endif /* HAVE_LONGLONG */
4821
4822 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
4823 "lock_pid = %u, count = %.0f, offset = %.0f\n",
4824 fsp->fsp_name,
4825 (unsigned int)lock_type,
4826 (unsigned int)lock_pid,
4827 (double)count,
4828 (double)offset ));
4829
4830 if (lock_type == UNLOCK_LOCK) {
4831 status = do_unlock(smbd_messaging_context(),
4832 fsp,
4833 lock_pid,
4834 count,
4835 offset,
4836 POSIX_LOCK);
4837 } else {
4838 uint32 block_smbpid;
4839
4840 struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
4841 fsp,
4842 lock_pid,
4843 count,
4844 offset,
4845 lock_type,
4846 POSIX_LOCK,
4847 blocking_lock,
4848 &status,
4849 &block_smbpid);
4850
4851 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
4852 /*
4853 * A blocking lock was requested. Package up
4854 * this smb into a queued request and push it
4855 * onto the blocking lock queue.
4856 */
4857 if(push_blocking_lock_request(br_lck,
4858 inbuf, length,
4859 fsp,
4860 -1, /* infinite timeout. */
4861 0,
4862 lock_pid,
4863 lock_type,
4864 POSIX_LOCK,
4865 offset,
4866 count,
4867 block_smbpid)) {
4868 TALLOC_FREE(br_lck);
4869 return status;
4870 }
4871 }
4872 TALLOC_FREE(br_lck);
4873 }
4874
4875 return status;
4876 }
4877
4878 /****************************************************************************
4879 Deal with SMB_INFO_STANDARD.
4880 ****************************************************************************/
4881
4882 static NTSTATUS smb_set_info_standard(connection_struct *conn,
4883 const char *pdata,
4884 int total_data,
4885 files_struct *fsp,
4886 const char *fname,
4887 const SMB_STRUCT_STAT *psbuf)
4888 {
4889 struct timespec ts[2];
4890
4891 if (total_data < 12) {
4892 return NT_STATUS_INVALID_PARAMETER;
4893 }
4894
4895 /* access time */
4896 ts[0] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastAccess));
4897 /* write time */
4898 ts[1] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastWrite));
4899
4900 DEBUG(10,("smb_set_info_standard: file %s\n",
4901 fname ? fname : fsp->fsp_name ));
4902
4903 return smb_set_file_time(conn,
4904 fsp,
4905 fname,
4906 psbuf,
4907 ts);
4908 }
4909
4910 /****************************************************************************
4911 Deal with SMB_SET_FILE_BASIC_INFO.
4912 ****************************************************************************/
4913
4914 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
4915 const char *pdata,
4916 int total_data,
4917 files_struct *fsp,
4918 const char *fname,
4919 SMB_STRUCT_STAT *psbuf)
4920 {
4921 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
4922 struct timespec write_time;
4923 struct timespec changed_time;
4924 uint32 dosmode = 0;
4925 struct timespec ts[2];
4926 NTSTATUS status = NT_STATUS_OK;
4927
4928 if (total_data < 36) {
4929 return NT_STATUS_INVALID_PARAMETER;
4930 }
4931
4932 /* Set the attributes */
4933 dosmode = IVAL(pdata,32);
4934 status = smb_set_file_dosmode(conn,
4935 fname,
4936 psbuf,
4937 dosmode);
4938 if (!NT_STATUS_IS_OK(status)) {
4939 return status;
4940 }
4941
4942 /* Ignore create time at offset pdata. */
4943
4944 /* access time */
4945 ts[0] = interpret_long_date(pdata+8);
4946
4947 write_time = interpret_long_date(pdata+16);
4948 changed_time = interpret_long_date(pdata+24);
4949
4950 /* mtime */
4951 ts[1] = timespec_min(&write_time, &changed_time);
4952
4953 if ((timespec_compare(&write_time, &ts[1]) == 1) && !null_timespec(write_time)) {
4954 ts[1] = write_time;
4955 }
4956
4957 /* Prefer a defined time to an undefined one. */
4958 if (null_timespec(ts[1])) {
4959 ts[1] = null_timespec(write_time) ? changed_time : write_time;
4960 }
4961
4962 DEBUG(10,("smb_set_file_basic_info: file %s\n",
4963 fname ? fname : fsp->fsp_name ));
4964
4965 return smb_set_file_time(conn,
4966 fsp,
4967 fname,
4968 psbuf,
4969 ts);
4970 }
4971
4972 /****************************************************************************
4973 Deal with SMB_SET_FILE_ALLOCATION_INFO.
4974 ****************************************************************************/
4975
4976 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
4977 struct smb_request *req,
4978 const char *pdata,
4979 int total_data,
4980 files_struct *fsp,
4981 const char *fname,
4982 SMB_STRUCT_STAT *psbuf)
4983 {
4984 SMB_BIG_UINT allocation_size = 0;
4985 NTSTATUS status = NT_STATUS_OK;
4986 files_struct *new_fsp = NULL;
4987
4988 if (!VALID_STAT(*psbuf)) {
4989 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4990 }
4991
4992 if (total_data < 8) {
4993 return NT_STATUS_INVALID_PARAMETER;
4994 }
4995
4996 allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
4997 #ifdef LARGE_SMB_OFF_T
4998 allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4999 #else /* LARGE_SMB_OFF_T */
5000 if (IVAL(pdata,4) != 0) {
5001 /* more than 32 bits? */
5002 return NT_STATUS_INVALID_PARAMETER;
5003 }
5004 #endif /* LARGE_SMB_OFF_T */
5005
5006 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for file %s to %.0f\n",
5007 fname, (double)allocation_size ));
5008
5009 if (allocation_size) {
5010 allocation_size = smb_roundup(conn, allocation_size);
5011 }
5012
5013 if(allocation_size == get_file_size(*psbuf)) {
5014 return NT_STATUS_OK;
5015 }
5016
5017 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new allocation size to %.0f\n",
5018 fname, (double)allocation_size ));
5019
5020 if (fsp && fsp->fh->fd != -1) {
5021 /* Open file handle. */
5022 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
5023 return map_nt_error_from_unix(errno);
5024 }
5025 return NT_STATUS_OK;
5026 }
5027
5028 /* Pathname or stat or directory file. */
5029
5030 status = open_file_ntcreate(conn, req, fname, psbuf,
5031 FILE_WRITE_DATA,
5032 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5033 FILE_OPEN,
5034 0,
5035 FILE_ATTRIBUTE_NORMAL,
5036 FORCE_OPLOCK_BREAK_TO_NONE,
5037 NULL, &new_fsp);
5038
5039 if (!NT_STATUS_IS_OK(status)) {
5040 /* NB. We check for open_was_deferred in the caller. */
5041 return status;
5042 }
5043 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
5044 status = map_nt_error_from_unix(errno);
5045 close_file(new_fsp,NORMAL_CLOSE);
5046 return status;
5047 }
5048
5049 close_file(new_fsp,NORMAL_CLOSE);
5050 return NT_STATUS_OK;
5051 }
5052
5053 /****************************************************************************
5054 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
5055 ****************************************************************************/
5056
5057 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
5058 struct smb_request *req,
5059 const char *pdata,
5060 int total_data,
5061 files_struct *fsp,
5062 const char *fname,
5063 SMB_STRUCT_STAT *psbuf)
5064 {
5065 SMB_OFF_T size;
5066
5067 if (total_data < 8) {
5068 return NT_STATUS_INVALID_PARAMETER;
5069 }
5070
5071 size = IVAL(pdata,0);
5072 #ifdef LARGE_SMB_OFF_T
5073 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
5074 #else /* LARGE_SMB_OFF_T */
5075 if (IVAL(pdata,4) != 0) {
5076 /* more than 32 bits? */
5077 return NT_STATUS_INVALID_PARAMETER;
5078 }
5079 #endif /* LARGE_SMB_OFF_T */
5080 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
5081 "file %s to %.0f\n", fname, (double)size ));
5082
5083 return smb_set_file_size(conn, req,
5084 fsp,
5085 fname,
5086 psbuf,
5087 size);
5088 }
5089
5090 /****************************************************************************
5091 Allow a UNIX info mknod.
5092 ****************************************************************************/
5093
5094 static NTSTATUS smb_unix_mknod(connection_struct *conn,
5095 const char *pdata,
5096 int total_data,
5097 const char *fname,
5098 SMB_STRUCT_STAT *psbuf)
5099 {
5100 uint32 file_type = IVAL(pdata,56);
5101 #if defined(HAVE_MAKEDEV)
5102 uint32 dev_major = IVAL(pdata,60);
5103 uint32 dev_minor = IVAL(pdata,68);
5104 #endif
5105 SMB_DEV_T dev = (SMB_DEV_T)0;
5106 uint32 raw_unixmode = IVAL(pdata,84);
5107 NTSTATUS status;
5108 mode_t unixmode;
5109
5110 if (total_data < 100) {
5111 return NT_STATUS_INVALID_PARAMETER;
5112 }
5113
5114 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_FILE, &unixmode);
5115 if (!NT_STATUS_IS_OK(status)) {
5116 return status;
5117 }
5118
5119 #if defined(HAVE_MAKEDEV)
5120 dev = makedev(dev_major, dev_minor);
5121 #endif
5122
5123 switch (file_type) {
5124 #if defined(S_IFIFO)
5125 case UNIX_TYPE_FIFO:
5126 unixmode |= S_IFIFO;
5127 break;
5128 #endif
5129 #if defined(S_IFSOCK)
5130 case UNIX_TYPE_SOCKET:
5131 unixmode |= S_IFSOCK;
5132 break;
5133 #endif
5134 #if defined(S_IFCHR)
5135 case UNIX_TYPE_CHARDEV:
5136 unixmode |= S_IFCHR;
5137 break;
5138 #endif
5139 #if defined(S_IFBLK)
5140 case UNIX_TYPE_BLKDEV:
5141 unixmode |= S_IFBLK;
5142 break;
5143 #endif
5144 default:
5145 return NT_STATUS_INVALID_PARAMETER;
5146 }
5147
5148 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
5149 0%o for file %s\n", (double)dev, (unsigned int)unixmode, fname ));
5150
5151 /* Ok - do the mknod. */
5152 if (SMB_VFS_MKNOD(conn, fname, unixmode, dev) != 0) {
5153 return map_nt_error_from_unix(errno);
5154 }
5155
5156 /* If any of the other "set" calls fail we
5157 * don't want to end up with a half-constructed mknod.
5158 */
5159
5160 if (lp_inherit_perms(SNUM(conn))) {
5161 inherit_access_acl(
5162 conn, parent_dirname(fname),
5163 fname, unixmode);
5164 }
5165
5166 if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
5167 status = map_nt_error_from_unix(errno);
5168 SMB_VFS_UNLINK(conn,fname);
5169 return status;
5170 }
5171 return NT_STATUS_OK;
5172 }
5173
5174 /****************************************************************************
5175 Deal with SMB_SET_FILE_UNIX_BASIC.
5176 ****************************************************************************/
5177
5178 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
5179 struct smb_request *req,
5180 const char *pdata,
5181 int total_data,
5182 files_struct *fsp,
5183 const char *fname,
5184 SMB_STRUCT_STAT *psbuf)
5185 {
5186 struct timespec ts[2];
5187 uint32 raw_unixmode;
5188 mode_t unixmode;
5189 SMB_OFF_T size = 0;
5190 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
5191 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
5192 NTSTATUS status = NT_STATUS_OK;
5193 BOOL delete_on_fail = False;
5194 enum perm_type ptype;
5195
5196 if (total_data < 100) {
5197 return NT_STATUS_INVALID_PARAMETER;
5198 }
5199
5200 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
5201 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
5202 size=IVAL(pdata,0); /* first 8 Bytes are size */
5203 #ifdef LARGE_SMB_OFF_T
5204 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
5205 #else /* LARGE_SMB_OFF_T */
5206 if (IVAL(pdata,4) != 0) {
5207 /* more than 32 bits? */
5208 return NT_STATUS_INVALID_PARAMETER;
5209 }
5210 #endif /* LARGE_SMB_OFF_T */
5211 }
5212
5213 ts[0] = interpret_long_date(pdata+24); /* access_time */
5214 ts[1] = interpret_long_date(pdata+32); /* modification_time */
5215 set_owner = (uid_t)IVAL(pdata,40);
5216 set_grp = (gid_t)IVAL(pdata,48);
5217 raw_unixmode = IVAL(pdata,84);
5218
5219 if (VALID_STAT(*psbuf)) {
5220 if (S_ISDIR(psbuf->st_mode)) {
5221 ptype = PERM_EXISTING_DIR;
5222 } else {
5223 ptype = PERM_EXISTING_FILE;
5224 }
5225 } else {
5226 ptype = PERM_NEW_FILE;
5227 }
5228
5229 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, ptype, &unixmode);
5230 if (!NT_STATUS_IS_OK(status)) {
5231 return status;
5232 }
5233
5234 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = %s \
5235 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
5236 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
5237
5238 if (!VALID_STAT(*psbuf)) {
5239 /*
5240 * The only valid use of this is to create character and block
5241 * devices, and named pipes. This is deprecated (IMHO) and
5242 * a new info level should be used for mknod. JRA.
5243 */
5244
5245 status = smb_unix_mknod(conn,
5246 pdata,
5247 total_data,
5248 fname,
5249 psbuf);
5250 if (!NT_STATUS_IS_OK(status)) {
5251 return status;
5252 }
5253
5254 /* Ensure we don't try and change anything else. */
5255 raw_unixmode = SMB_MODE_NO_CHANGE;
5256 size = get_file_size(*psbuf);
5257 ts[0] = get_atimespec(psbuf);
5258 ts[1] = get_mtimespec(psbuf);
5259 /*
5260 * We continue here as we might want to change the
5261 * owner uid/gid.
5262 */
5263 delete_on_fail = True;
5264 }
5265
5266 #if 1
5267 /* Horrible backwards compatibility hack as an old server bug
5268 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
5269 * */
5270
5271 if (!size) {
5272 size = get_file_size(*psbuf);
5273 }
5274 #endif
5275
5276 /*
5277 * Deal with the UNIX specific mode set.
5278 */
5279
5280 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
5281 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
5282 (unsigned int)unixmode, fname ));
5283 if (SMB_VFS_CHMOD(conn, fname, unixmode) != 0) {
5284 return map_nt_error_from_unix(errno);
5285 }
5286 }
5287
5288 /*
5289 * Deal with the UNIX specific uid set.
5290 */
5291
5292 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (psbuf->st_uid != set_owner)) {
5293 int ret;
5294
5295 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing owner %u for path %s\n",
5296 (unsigned int)set_owner, fname ));
5297
5298 if (S_ISLNK(psbuf->st_mode)) {
5299 ret = SMB_VFS_LCHOWN(conn, fname, set_owner, (gid_t)-1);
5300 } else {
5301 ret = SMB_VFS_CHOWN(conn, fname, set_owner, (gid_t)-1);
5302 }
5303
5304 if (ret != 0) {
5305 status = map_nt_error_from_unix(errno);
5306 if (delete_on_fail) {
5307 SMB_VFS_UNLINK(conn,fname);
5308 }
5309 return status;
5310 }
5311 }
5312
5313 /*
5314 * Deal with the UNIX specific gid set.
5315 */
5316
5317 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (psbuf->st_gid != set_grp)) {
5318 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
5319 (unsigned int)set_owner, fname ));
5320 if (SMB_VFS_CHOWN(conn, fname, (uid_t)-1, set_grp) != 0) {
5321 status = map_nt_error_from_unix(errno);
5322 if (delete_on_fail) {
5323 SMB_VFS_UNLINK(conn,fname);
5324 }
5325 return status;
5326 }
5327 }
5328
5329 /* Deal with any size changes. */
5330
5331 status = smb_set_file_size(conn, req,
5332 fsp,
5333 fname,
5334 psbuf,
5335 size);
5336 if (!NT_STATUS_IS_OK(status)) {
5337 return status;
5338 }
5339
5340 /* Deal with any time changes. */
5341
5342 return smb_set_file_time(conn,
5343 fsp,
5344 fname,
5345 psbuf,
5346 ts);
5347 }
5348
5349 /****************************************************************************
5350 Deal with SMB_SET_FILE_UNIX_INFO2.
5351 ****************************************************************************/
5352
5353 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
5354 struct smb_request *req,
5355 const char *pdata,
5356 int total_data,
5357 files_struct *fsp,
5358 const char *fname,
5359 SMB_STRUCT_STAT *psbuf)
5360 {
5361 NTSTATUS status;
5362 uint32 smb_fflags;
5363 uint32 smb_fmask;
5364
5365 if (total_data < 116) {
5366 return NT_STATUS_INVALID_PARAMETER;
5367 }
5368
5369 /* Start by setting all the fields that are common between UNIX_BASIC
5370 * and UNIX_INFO2.
5371 */
5372 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
5373 fsp, fname, psbuf);
5374 if (!NT_STATUS_IS_OK(status)) {
5375 return status;
5376 }
5377
5378 smb_fflags = IVAL(pdata, 108);
5379 smb_fmask = IVAL(pdata, 112);
5380
5381 /* NB: We should only attempt to alter the file flags if the client
5382 * sends a non-zero mask.
5383 */
5384 if (smb_fmask != 0) {
5385 int stat_fflags = 0;
5386
5387 if (!map_info2_flags_to_sbuf(psbuf, smb_fflags, smb_fmask,
5388 &stat_fflags)) {
5389 /* Client asked to alter a flag we don't understand. */
5390 return NT_STATUS_INVALID_PARAMETER;
5391 }
5392
5393 if (fsp && fsp->fh->fd != -1) {
5394 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
5395 return NT_STATUS_NOT_SUPPORTED;
5396 } else {
5397 if (SMB_VFS_CHFLAGS(conn, fname, stat_fflags) != 0) {
5398 return map_nt_error_from_unix(errno);
5399 }
5400 }
5401 }
5402
5403 /* XXX: need to add support for changing the create_time here. You
5404 * can do this for paths on Darwin with setattrlist(2). The right way
5405 * to hook this up is probably by extending the VFS utimes interface.
5406 */
5407
5408 return NT_STATUS_OK;
5409 }
5410
5411 /****************************************************************************
5412 Create a directory with POSIX semantics.
5413 ****************************************************************************/
5414
5415 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
5416 struct smb_request *req,
5417 char **ppdata,
5418 int total_data,
5419 const char *fname,
5420 SMB_STRUCT_STAT *psbuf,
5421 int *pdata_return_size)
5422 {
5423 NTSTATUS status = NT_STATUS_OK;
5424 uint32 raw_unixmode = 0;
5425 uint32 mod_unixmode = 0;
5426 mode_t unixmode = (mode_t)0;
5427 files_struct *fsp = NULL;
5428 uint16 info_level_return = 0;
5429 int info;
5430 char *pdata = *ppdata;
5431
5432 if (total_data < 18) {
5433 return NT_STATUS_INVALID_PARAMETER;
5434 }
5435
5436 raw_unixmode = IVAL(pdata,8);
5437 /* Next 4 bytes are not yet defined. */
5438
5439 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_DIR, &unixmode);
5440 if (!NT_STATUS_IS_OK(status)) {
5441 return status;
5442 }
5443
5444 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5445
5446 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
5447 fname, (unsigned int)unixmode ));
5448
5449 status = open_directory(conn, req,
5450 fname,
5451 psbuf,
5452 FILE_READ_ATTRIBUTES, /* Just a stat open */
5453 FILE_SHARE_NONE, /* Ignored for stat opens */
5454 FILE_CREATE,
5455 0,
5456 mod_unixmode,
5457 &info,
5458 &fsp);
5459
5460 if (NT_STATUS_IS_OK(status)) {
5461 close_file(fsp, NORMAL_CLOSE);
5462 }
5463
5464 info_level_return = SVAL(pdata,16);
5465
5466 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5467 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5468 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
5469 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5470 } else {
5471 *pdata_return_size = 12;
5472 }
5473
5474 /* Realloc the data size */
5475 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5476 if (*ppdata == NULL) {
5477 *pdata_return_size = 0;
5478 return NT_STATUS_NO_MEMORY;
5479 }
5480 pdata = *ppdata;
5481
5482 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5483 SSVAL(pdata,2,0); /* No fnum. */
5484 SIVAL(pdata,4,info); /* Was directory created. */
5485
5486 switch (info_level_return) {
5487 case SMB_QUERY_FILE_UNIX_BASIC:
5488 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5489 SSVAL(pdata,10,0); /* Padding. */
5490 store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5491 break;
5492 case SMB_QUERY_FILE_UNIX_INFO2:
5493 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5494 SSVAL(pdata,10,0); /* Padding. */
5495 store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5496 break;
5497 default:
5498 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5499 SSVAL(pdata,10,0); /* Padding. */
5500 break;
5501 }
5502
5503 return status;
5504 }
5505
5506 /****************************************************************************
5507 Open/Create a file with POSIX semantics.
5508 ****************************************************************************/
5509
5510 static NTSTATUS smb_posix_open(connection_struct *conn,
5511 struct smb_request *req,
5512 char **ppdata,
5513 int total_data,
5514 const char *fname,
5515 SMB_STRUCT_STAT *psbuf,
5516 int *pdata_return_size)
5517 {
5518 BOOL extended_oplock_granted = False;
5519 char *pdata = *ppdata;
5520 uint32 flags = 0;
5521 uint32 wire_open_mode = 0;
5522 uint32 raw_unixmode = 0;
5523 uint32 mod_unixmode = 0;
5524 uint32 create_disp = 0;
5525 uint32 access_mask = 0;
5526 uint32 create_options = 0;
5527 NTSTATUS status = NT_STATUS_OK;
5528 mode_t unixmode = (mode_t)0;
5529 files_struct *fsp = NULL;
5530 int oplock_request = 0;
5531 int info = 0;
5532 uint16 info_level_return = 0;
5533
5534 if (total_data < 18) {
5535 return NT_STATUS_INVALID_PARAMETER;
5536 }
5537
5538 flags = IVAL(pdata,0);
5539 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
5540 if (oplock_request) {
5541 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
5542 }
5543
5544 wire_open_mode = IVAL(pdata,4);
5545
5546 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
5547 return smb_posix_mkdir(conn, req,
5548 ppdata,
5549 total_data,
5550 fname,
5551 psbuf,
5552 pdata_return_size);
5553 }
5554
5555 switch (wire_open_mode & SMB_ACCMODE) {
5556 case SMB_O_RDONLY:
5557 access_mask = FILE_READ_DATA;
5558 break;
5559 case SMB_O_WRONLY:
5560 access_mask = FILE_WRITE_DATA;
5561 break;
5562 case SMB_O_RDWR:
5563 access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
5564 break;
5565 default:
5566 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
5567 (unsigned int)wire_open_mode ));
5568 return NT_STATUS_INVALID_PARAMETER;
5569 }
5570
5571 wire_open_mode &= ~SMB_ACCMODE;
5572
5573 if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
5574 create_disp = FILE_CREATE;
5575 } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
5576 create_disp = FILE_OVERWRITE_IF;
5577 } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
5578 create_disp = FILE_OPEN_IF;
5579 } else {
5580 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
5581 (unsigned int)wire_open_mode ));
5582 return NT_STATUS_INVALID_PARAMETER;
5583 }
5584
5585 raw_unixmode = IVAL(pdata,8);
5586 /* Next 4 bytes are not yet defined. */
5587
5588 status = unix_perms_from_wire(conn,
5589 psbuf,
5590 raw_unixmode,
5591 VALID_STAT(*psbuf) ? PERM_EXISTING_FILE : PERM_NEW_FILE,
5592 &unixmode);
5593
5594 if (!NT_STATUS_IS_OK(status)) {
5595 return status;
5596 }
5597
5598 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5599
5600 if (wire_open_mode & SMB_O_SYNC) {
5601 create_options |= FILE_WRITE_THROUGH;
5602 }
5603 if (wire_open_mode & SMB_O_APPEND) {
5604 access_mask |= FILE_APPEND_DATA;
5605 }
5606 if (wire_open_mode & SMB_O_DIRECT) {
5607 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
5608 }
5609
5610 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
5611 fname,
5612 (unsigned int)wire_open_mode,
5613 (unsigned int)unixmode ));
5614
5615 status = open_file_ntcreate(conn, req,
5616 fname,
5617 psbuf,
5618 access_mask,
5619 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5620 create_disp,
5621 0, /* no create options yet. */
5622 mod_unixmode,
5623 oplock_request,
5624 &info,
5625 &fsp);
5626
5627 if (!NT_STATUS_IS_OK(status)) {
5628 return status;
5629 }
5630
5631 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
5632 extended_oplock_granted = True;
5633 }
5634
5635 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
5636 extended_oplock_granted = True;
5637 }
5638
5639 info_level_return = SVAL(pdata,16);
5640
5641 /* Allocate the correct return size. */
5642
5643 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5644 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5645 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
5646 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5647 } else {
5648 *pdata_return_size = 12;
5649 }
5650
5651 /* Realloc the data size */
5652 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5653 if (*ppdata == NULL) {
5654 close_file(fsp,ERROR_CLOSE);
5655 *pdata_return_size = 0;
5656 return NT_STATUS_NO_MEMORY;
5657 }
5658 pdata = *ppdata;
5659
5660 if (extended_oplock_granted) {
5661 if (flags & REQUEST_BATCH_OPLOCK) {
5662 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
5663 } else {
5664 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
5665 }
5666 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
5667 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
5668 } else {
5669 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5670 }
5671
5672 SSVAL(pdata,2,fsp->fnum);
5673 SIVAL(pdata,4,info); /* Was file created etc. */
5674
5675 switch (info_level_return) {
5676 case SMB_QUERY_FILE_UNIX_BASIC:
5677 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5678 SSVAL(pdata,10,0); /* padding. */
5679 store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5680 break;
5681 case SMB_QUERY_FILE_UNIX_INFO2:
5682 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5683 SSVAL(pdata,10,0); /* padding. */
5684 store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5685 break;
5686 default:
5687 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5688 SSVAL(pdata,10,0); /* padding. */
5689 break;
5690 }
5691 return NT_STATUS_OK;
5692 }
5693
5694 /****************************************************************************
5695 Delete a file with POSIX semantics.
5696 ****************************************************************************/
5697
5698 static NTSTATUS smb_posix_unlink(connection_struct *conn,
5699 struct smb_request *req,
5700 const char *pdata,
5701 int total_data,
5702 const char *fname,
5703 SMB_STRUCT_STAT *psbuf)
5704 {
5705 NTSTATUS status = NT_STATUS_OK;
5706 files_struct *fsp = NULL;
5707 uint16 flags = 0;
5708 int info = 0;
5709
5710 if (total_data < 2) {
5711 return NT_STATUS_INVALID_PARAMETER;
5712 }
5713
5714 flags = SVAL(pdata,0);
5715
5716 if (!VALID_STAT(*psbuf)) {
5717 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5718 }
5719
5720 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
5721 !VALID_STAT_OF_DIR(*psbuf)) {
5722 return NT_STATUS_NOT_A_DIRECTORY;
5723 }
5724
5725 DEBUG(10,("smb_posix_unlink: %s %s\n",
5726 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
5727 fname));
5728
5729 if (VALID_STAT_OF_DIR(*psbuf)) {
5730 status = open_directory(conn, req,
5731 fname,
5732 psbuf,
5733 DELETE_ACCESS,
5734 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5735 FILE_OPEN,
5736 FILE_DELETE_ON_CLOSE,
5737 FILE_FLAG_POSIX_SEMANTICS|0777,
5738 &info,
5739 &fsp);
5740 } else {
5741 char del = 1;
5742
5743 status = open_file_ntcreate(conn, req,
5744 fname,
5745 psbuf,
5746 DELETE_ACCESS,
5747 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5748 FILE_OPEN,
5749 0,
5750 FILE_FLAG_POSIX_SEMANTICS|0777,
5751 0, /* No oplock, but break existing ones. */
5752 &info,
5753 &fsp);
5754 /*
5755 * For file opens we must set the delete on close
5756 * after the open.
5757 */
5758
5759 if (!NT_STATUS_IS_OK(status)) {
5760 return status;
5761 }
5762
5763 status = smb_set_file_disposition_info(conn,
5764 &del,
5765 1,
5766 fsp,
5767 fname,
5768 psbuf);
5769 }
5770
5771 if (!NT_STATUS_IS_OK(status)) {
5772 return status;
5773 }
5774 return close_file(fsp, NORMAL_CLOSE);
5775 }
5776
5777 /****************************************************************************
5778 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
5779 ****************************************************************************/
5780
5781 static int call_trans2setfilepathinfo(connection_struct *conn,
5782 struct smb_request *req,
5783 char *inbuf, char *outbuf, int length,
5784 int bufsize,
5785 unsigned int tran_call,
5786 char **pparams, int total_params, char **ppdata, int total_data,
5787 unsigned int max_data_bytes)
5788 {
5789 char *params = *pparams;
5790 char *pdata = *ppdata;
5791 uint16 info_level;
5792 SMB_STRUCT_STAT sbuf;
5793 pstring fname;
5794 files_struct *fsp = NULL;
5795 NTSTATUS status = NT_STATUS_OK;
5796 int data_return_size = 0;
5797
5798 if (!params) {
5799 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5800 }
5801
5802 ZERO_STRUCT(sbuf);
5803
5804 if (tran_call == TRANSACT2_SETFILEINFO) {
5805 if (total_params < 4) {
5806 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5807 }
5808
5809 fsp = file_fsp(params,0);
5810 info_level = SVAL(params,2);
5811
5812 if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
5813 /*
5814 * This is actually a SETFILEINFO on a directory
5815 * handle (returned from an NT SMB). NT5.0 seems
5816 * to do this call. JRA.
5817 */
5818 pstrcpy(fname, fsp->fsp_name);
5819 if (INFO_LEVEL_IS_UNIX(info_level)) {
5820 /* Always do lstat for UNIX calls. */
5821 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
5822 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
5823 return UNIXERROR(ERRDOS,ERRbadpath);
5824 }
5825 } else {
5826 if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
5827 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
5828 return UNIXERROR(ERRDOS,ERRbadpath);
5829 }
5830 }
5831 } else if (fsp && fsp->print_file) {
5832 /*
5833 * Doing a DELETE_ON_CLOSE should cancel a print job.
5834 */
5835 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
5836 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
5837
5838 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
5839
5840 SSVAL(params,0,0);
5841 send_trans2_replies(inbuf, outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5842 return(-1);
5843 } else
5844 return (UNIXERROR(ERRDOS,ERRbadpath));
5845 } else {
5846 /*
5847 * Original code - this is an open file.
5848 */
5849 CHECK_FSP(fsp,conn);
5850
5851 pstrcpy(fname, fsp->fsp_name);
5852
5853 if (SMB_VFS_FSTAT(fsp, fsp->fh->fd, &sbuf) != 0) {
5854 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
5855 return(UNIXERROR(ERRDOS,ERRbadfid));
5856 }
5857 }
5858 } else {
5859 /* set path info */
5860 if (total_params < 7) {
5861 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5862 }
5863
5864 info_level = SVAL(params,0);
5865 srvstr_get_path(inbuf, SVAL(inbuf,smb_flg2), fname, &params[6],
5866 sizeof(fname), total_params - 6, STR_TERMINATE,
5867 &status);
5868 if (!NT_STATUS_IS_OK(status)) {
5869 return ERROR_NT(status);
5870 }
5871
5872 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
5873 if (!NT_STATUS_IS_OK(status)) {
5874 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5875 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
5876 }
5877 return ERROR_NT(status);
5878 }
5879
5880 status = unix_convert(conn, fname, False, NULL, &sbuf);
5881 if (!NT_STATUS_IS_OK(status)) {
5882 return ERROR_NT(status);
5883 }
5884
5885 status = check_name(conn, fname);
5886 if (!NT_STATUS_IS_OK(status)) {
5887 return ERROR_NT(status);
5888 }
5889
5890 if (INFO_LEVEL_IS_UNIX(info_level)) {
5891 /*
5892 * For CIFS UNIX extensions the target name may not exist.
5893 */
5894
5895 /* Always do lstat for UNIX calls. */
5896 SMB_VFS_LSTAT(conn,fname,&sbuf);
5897
5898 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
5899 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
5900 return UNIXERROR(ERRDOS,ERRbadpath);
5901 }
5902 }
5903
5904 if (!CAN_WRITE(conn)) {
5905 return ERROR_DOS(ERRSRV,ERRaccess);
5906 }
5907
5908 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5909 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5910 }
5911
5912 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
5913 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
5914
5915 /* Realloc the parameter size */
5916 *pparams = (char *)SMB_REALLOC(*pparams,2);
5917 if (*pparams == NULL) {
5918 return ERROR_NT(NT_STATUS_NO_MEMORY);
5919 }
5920 params = *pparams;
5921
5922 SSVAL(params,0,0);
5923
5924 if (fsp && !null_timespec(fsp->pending_modtime)) {
5925 /* the pending modtime overrides the current modtime */
5926 set_mtimespec(&sbuf, fsp->pending_modtime);
5927 }
5928
5929 switch (info_level) {
5930
5931 case SMB_INFO_STANDARD:
5932 {
5933 status = smb_set_info_standard(conn,
5934 pdata,
5935 total_data,
5936 fsp,
5937 fname,
5938 &sbuf);
5939 break;
5940 }
5941
5942 case SMB_INFO_SET_EA:
5943 {
5944 status = smb_info_set_ea(conn,
5945 pdata,
5946 total_data,
5947 fsp,
5948 fname);
5949 break;
5950 }
5951
5952 case SMB_SET_FILE_BASIC_INFO:
5953 case SMB_FILE_BASIC_INFORMATION:
5954 {
5955 status = smb_set_file_basic_info(conn,
5956 pdata,
5957 total_data,
5958 fsp,
5959 fname,
5960 &sbuf);
5961 break;
5962 }
5963
5964 case SMB_FILE_ALLOCATION_INFORMATION:
5965 case SMB_SET_FILE_ALLOCATION_INFO:
5966 {
5967 status = smb_set_file_allocation_info(conn, req,
5968 pdata,
5969 total_data,
5970 fsp,
5971 fname,
5972 &sbuf);
5973 break;
5974 }
5975
5976 case SMB_FILE_END_OF_FILE_INFORMATION:
5977 case SMB_SET_FILE_END_OF_FILE_INFO:
5978 {
5979 status = smb_set_file_end_of_file_info(conn, req,
5980 pdata,
5981 total_data,
5982 fsp,
5983 fname,
5984 &sbuf);
5985 break;
5986 }
5987
5988 case SMB_FILE_DISPOSITION_INFORMATION:
5989 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
5990 {
5991 #if 0
5992 /* JRA - We used to just ignore this on a path ?
5993 * Shouldn't this be invalid level on a pathname
5994 * based call ?
5995 */
5996 if (tran_call != TRANSACT2_SETFILEINFO) {
5997 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5998 }
5999 #endif
6000 status = smb_set_file_disposition_info(conn,
6001 pdata,
6002 total_data,
6003 fsp,
6004 fname,
6005 &sbuf);
6006 break;
6007 }
6008
6009 case SMB_FILE_POSITION_INFORMATION:
6010 {
6011 status = smb_file_position_information(conn,
6012 pdata,
6013 total_data,
6014 fsp);
6015 break;
6016 }
6017
6018 /* From tridge Samba4 :
6019 * MODE_INFORMATION in setfileinfo (I have no
6020 * idea what "mode information" on a file is - it takes a value of 0,
6021 * 2, 4 or 6. What could it be?).
6022 */
6023
6024 case SMB_FILE_MODE_INFORMATION:
6025 {
6026 status = smb_file_mode_information(conn,
6027 pdata,
6028 total_data);
6029 break;
6030 }
6031
6032 /*
6033 * CIFS UNIX extensions.
6034 */
6035
6036 case SMB_SET_FILE_UNIX_BASIC:
6037 {
6038 status = smb_set_file_unix_basic(conn, req,
6039 pdata,
6040 total_data,
6041 fsp,
6042 fname,
6043 &sbuf);
6044 break;
6045 }
6046
6047 case SMB_SET_FILE_UNIX_INFO2:
6048 {
6049 status = smb_set_file_unix_info2(conn, req,
6050 pdata,
6051 total_data,
6052 fsp,
6053 fname,
6054 &sbuf);
6055 break;
6056 }
6057
6058 case SMB_SET_FILE_UNIX_LINK:
6059 {
6060 if (tran_call != TRANSACT2_SETPATHINFO) {
6061 /* We must have a pathname for this. */
6062 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6063 }
6064 status = smb_set_file_unix_link(conn,
6065 inbuf,
6066 pdata,
6067 total_data,
6068 fname);
6069 break;
6070 }
6071
6072 case SMB_SET_FILE_UNIX_HLINK:
6073 {
6074 if (tran_call != TRANSACT2_SETPATHINFO) {
6075 /* We must have a pathname for this. */
6076 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6077 }
6078 status = smb_set_file_unix_hlink(conn,
6079 inbuf,
6080 outbuf,
6081 pdata,
6082 total_data,
6083 fname);
6084 break;
6085 }
6086
6087 case SMB_FILE_RENAME_INFORMATION:
6088 {
6089 status = smb_file_rename_information(conn, req,
6090 inbuf,
6091 outbuf,
6092 pdata,
6093 total_data,
6094 fsp,
6095 fname);
6096 break;
6097 }
6098
6099 #if defined(HAVE_POSIX_ACLS)
6100 case SMB_SET_POSIX_ACL:
6101 {
6102 status = smb_set_posix_acl(conn,
6103 pdata,
6104 total_data,
6105 fsp,
6106 fname,
6107 &sbuf);
6108 break;
6109 }
6110 #endif
6111
6112 case SMB_SET_POSIX_LOCK:
6113 {
6114 if (tran_call != TRANSACT2_SETFILEINFO) {
6115 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6116 }
6117 status = smb_set_posix_lock(conn,
6118 inbuf,
6119 length,
6120 pdata,
6121 total_data,
6122 fsp);
6123 break;
6124 }
6125
6126 case SMB_POSIX_PATH_OPEN:
6127 {
6128 if (tran_call != TRANSACT2_SETPATHINFO) {
6129 /* We must have a pathname for this. */
6130 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6131 }
6132
6133 status = smb_posix_open(conn, req,
6134 ppdata,
6135 total_data,
6136 fname,
6137 &sbuf,
6138 &data_return_size);
6139 break;
6140 }
6141
6142 case SMB_POSIX_PATH_UNLINK:
6143 {
6144 if (tran_call != TRANSACT2_SETPATHINFO) {
6145 /* We must have a pathname for this. */
6146 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6147 }
6148
6149 status = smb_posix_unlink(conn, req,
6150 pdata,
6151 total_data,
6152 fname,
6153 &sbuf);
6154 break;
6155 }
6156
6157 default:
6158 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6159 }
6160
6161
6162 if (!NT_STATUS_IS_OK(status)) {
6163 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
6164 /* We have re-scheduled this call. */
6165 return -1;
6166 }
6167 if (blocking_lock_was_deferred(SVAL(inbuf,smb_mid))) {
6168 /* We have re-scheduled this call. */
6169 return -1;
6170 }
6171 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
6172 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
6173 }
6174 return ERROR_NT(status);
6175 }
6176
6177 SSVAL(params,0,0);
6178 send_trans2_replies(inbuf, outbuf, bufsize, params, 2, *ppdata, data_return_size, max_data_bytes);
6179
6180 return -1;
6181 }
6182
6183 /****************************************************************************
6184 Reply to a TRANS2_MKDIR (make directory with extended attributes).
6185 ****************************************************************************/
6186
6187 static int call_trans2mkdir(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6188 char **pparams, int total_params, char **ppdata, int total_data,
6189 unsigned int max_data_bytes)
6190 {
6191 char *params = *pparams;
6192 char *pdata = *ppdata;
6193 pstring directory;
6194 SMB_STRUCT_STAT sbuf;
6195 NTSTATUS status = NT_STATUS_OK;
6196 struct ea_list *ea_list = NULL;
6197
6198 if (!CAN_WRITE(conn))
6199 return ERROR_DOS(ERRSRV,ERRaccess);
6200
6201 if (total_params < 5) {
6202 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6203 }
6204
6205 srvstr_get_path(inbuf, SVAL(inbuf,smb_flg2), directory, &params[4],
6206 sizeof(directory), total_params - 4, STR_TERMINATE,
6207 &status);
6208 if (!NT_STATUS_IS_OK(status)) {
6209 return ERROR_NT(status);
6210 }
6211
6212 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
6213
6214 status = unix_convert(conn, directory, False, NULL, &sbuf);
6215 if (!NT_STATUS_IS_OK(status)) {
6216 return ERROR_NT(status);
6217 }
6218
6219 status = check_name(conn, directory);
6220 if (!NT_STATUS_IS_OK(status)) {
6221 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status)));
6222 return ERROR_NT(status);
6223 }
6224
6225 /* Any data in this call is an EA list. */
6226 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
6227 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
6228 }
6229
6230 /*
6231 * OS/2 workplace shell seems to send SET_EA requests of "null"
6232 * length (4 bytes containing IVAL 4).
6233 * They seem to have no effect. Bug #3212. JRA.
6234 */
6235
6236 if (total_data != 4) {
6237 if (total_data < 10) {
6238 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6239 }
6240
6241 if (IVAL(pdata,0) > total_data) {
6242 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
6243 IVAL(pdata,0), (unsigned int)total_data));
6244 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6245 }
6246
6247 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
6248 total_data - 4);
6249 if (!ea_list) {
6250 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6251 }
6252 } else if (IVAL(pdata,0) != 4) {
6253 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6254 }
6255
6256 status = create_directory(conn, directory);
6257
6258 if (!NT_STATUS_IS_OK(status)) {
6259 return ERROR_NT(status);
6260 }
6261
6262 /* Try and set any given EA. */
6263 if (ea_list) {
6264 status = set_ea(conn, NULL, directory, ea_list);
6265 if (!NT_STATUS_IS_OK(status)) {
6266 return ERROR_NT(status);
6267 }
6268 }
6269
6270 /* Realloc the parameter and data sizes */
6271 *pparams = (char *)SMB_REALLOC(*pparams,2);
6272 if(*pparams == NULL) {
6273 return ERROR_NT(NT_STATUS_NO_MEMORY);
6274 }
6275 params = *pparams;
6276
6277 SSVAL(params,0,0);
6278
6279 send_trans2_replies(inbuf, outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
6280
6281 return(-1);
6282 }
6283
6284 /****************************************************************************
6285 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
6286 We don't actually do this - we just send a null response.
6287 ****************************************************************************/
6288
6289 static int call_trans2findnotifyfirst(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6290 char **pparams, int total_params, char **ppdata, int total_data,
6291 unsigned int max_data_bytes)
6292 {
6293 static uint16 fnf_handle = 257;
6294 char *params = *pparams;
6295 uint16 info_level;
6296
6297 if (total_params < 6) {
6298 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6299 }
6300
6301 info_level = SVAL(params,4);
6302 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
6303
6304 switch (info_level) {
6305 case 1:
6306 case 2:
6307 break;
6308 default:
6309 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6310 }
6311
6312 /* Realloc the parameter and data sizes */
6313 *pparams = (char *)SMB_REALLOC(*pparams,6);
6314 if (*pparams == NULL) {
6315 return ERROR_NT(NT_STATUS_NO_MEMORY);
6316 }
6317 params = *pparams;
6318
6319 SSVAL(params,0,fnf_handle);
6320 SSVAL(params,2,0); /* No changes */
6321 SSVAL(params,4,0); /* No EA errors */
6322
6323 fnf_handle++;
6324
6325 if(fnf_handle == 0)
6326 fnf_handle = 257;
6327
6328 send_trans2_replies(inbuf, outbuf, bufsize, params, 6, *ppdata, 0, max_data_bytes);
6329
6330 return(-1);
6331 }
6332
6333 /****************************************************************************
6334 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
6335 changes). Currently this does nothing.
6336 ****************************************************************************/
6337
6338 static int call_trans2findnotifynext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6339 char **pparams, int total_params, char **ppdata, int total_data,
6340 unsigned int max_data_bytes)
6341 {
6342 char *params = *pparams;
6343
6344 DEBUG(3,("call_trans2findnotifynext\n"));
6345
6346 /* Realloc the parameter and data sizes */
6347 *pparams = (char *)SMB_REALLOC(*pparams,4);
6348 if (*pparams == NULL) {
6349 return ERROR_NT(NT_STATUS_NO_MEMORY);
6350 }
6351 params = *pparams;
6352
6353 SSVAL(params,0,0); /* No changes */
6354 SSVAL(params,2,0); /* No EA errors */
6355
6356 send_trans2_replies(inbuf, outbuf, bufsize, params, 4, *ppdata, 0, max_data_bytes);
6357
6358 return(-1);
6359 }
6360
6361 /****************************************************************************
6362 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
6363 ****************************************************************************/
6364
6365 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6366 char **pparams, int total_params, char **ppdata, int total_data,
6367 unsigned int max_data_bytes)
6368 {
6369 char *params = *pparams;
6370 pstring pathname;
6371 int reply_size = 0;
6372 int max_referral_level;
6373 NTSTATUS status = NT_STATUS_OK;
6374
6375 DEBUG(10,("call_trans2getdfsreferral\n"));
6376
6377 if (total_params < 3) {
6378 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6379 }
6380
6381 max_referral_level = SVAL(params,0);
6382
6383 if(!lp_host_msdfs())
6384 return ERROR_DOS(ERRDOS,ERRbadfunc);
6385
6386 srvstr_pull(inbuf, SVAL(inbuf, smb_flg2), pathname, &params[2],
6387 sizeof(pathname), total_params - 2, STR_TERMINATE);
6388 if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata,&status)) < 0)
6389 return ERROR_NT(status);
6390
6391 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
6392 send_trans2_replies(inbuf, outbuf,bufsize,0,0,*ppdata,reply_size, max_data_bytes);
6393
6394 return(-1);
6395 }
6396
6397 #define LMCAT_SPL 0x53
6398 #define LMFUNC_GETJOBID 0x60
6399
6400 /****************************************************************************
6401 Reply to a TRANS2_IOCTL - used for OS/2 printing.
6402 ****************************************************************************/
6403
6404 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6405 char **pparams, int total_params, char **ppdata, int total_data,
6406 unsigned int max_data_bytes)
6407 {
6408 char *pdata = *ppdata;
6409 files_struct *fsp = file_fsp(inbuf,smb_vwv15);
6410
6411 /* check for an invalid fid before proceeding */
6412
6413 if (!fsp)
6414 return(ERROR_DOS(ERRDOS,ERRbadfid));
6415
6416 if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6417 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6418 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
6419 if (*ppdata == NULL) {
6420 return ERROR_NT(NT_STATUS_NO_MEMORY);
6421 }
6422 pdata = *ppdata;
6423
6424 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
6425 CAN ACCEPT THIS IN UNICODE. JRA. */
6426
6427 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
6428 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
6429 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
6430 send_trans2_replies(inbuf, outbuf,bufsize,*pparams,0,*ppdata,32, max_data_bytes);
6431 return(-1);
6432 } else {
6433 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
6434 return ERROR_DOS(ERRSRV,ERRerror);
6435 }
6436 }
6437
6438 /****************************************************************************
6439 Reply to a SMBfindclose (stop trans2 directory search).
6440 ****************************************************************************/
6441
6442 int reply_findclose(connection_struct *conn,
6443 char *inbuf,char *outbuf,int length,int bufsize)
6444 {
6445 int outsize = 0;
6446 int dptr_num=SVALS(inbuf,smb_vwv0);
6447 START_PROFILE(SMBfindclose);
6448
6449 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
6450
6451 dptr_close(&dptr_num);
6452
6453 outsize = set_message(inbuf, outbuf,0,0,False);
6454
6455 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
6456
6457 END_PROFILE(SMBfindclose);
6458 return(outsize);
6459 }
6460
6461 /****************************************************************************
6462 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
6463 ****************************************************************************/
6464
6465 int reply_findnclose(connection_struct *conn,
6466 char *inbuf,char *outbuf,int length,int bufsize)
6467 {
6468 int outsize = 0;
6469 int dptr_num= -1;
6470 START_PROFILE(SMBfindnclose);
6471
6472 dptr_num = SVAL(inbuf,smb_vwv0);
6473
6474 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
6475
6476 /* We never give out valid handles for a
6477 findnotifyfirst - so any dptr_num is ok here.
6478 Just ignore it. */
6479
6480 outsize = set_message(inbuf, outbuf,0,0,False);
6481
6482 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
6483
6484 END_PROFILE(SMBfindnclose);
6485 return(outsize);
6486 }
6487
6488 static int handle_trans2(connection_struct *conn, struct smb_request *req,
6489 struct trans_state *state,
6490 char *inbuf, char *outbuf, int size, int bufsize)
6491 {
6492 int outsize;
6493
6494 if (Protocol >= PROTOCOL_NT1) {
6495 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
6496 }
6497
6498 /* Now we must call the relevant TRANS2 function */
6499 switch(state->call) {
6500 case TRANSACT2_OPEN:
6501 {
6502 START_PROFILE(Trans2_open);
6503 outsize = call_trans2open(
6504 conn, req, inbuf, outbuf, bufsize,
6505 &state->param, state->total_param,
6506 &state->data, state->total_data,
6507 state->max_data_return);
6508 END_PROFILE(Trans2_open);
6509 break;
6510 }
6511
6512 case TRANSACT2_FINDFIRST:
6513 {
6514 START_PROFILE(Trans2_findfirst);
6515 outsize = call_trans2findfirst(
6516 conn, inbuf, outbuf, bufsize,
6517 &state->param, state->total_param,
6518 &state->data, state->total_data,
6519 state->max_data_return);
6520 END_PROFILE(Trans2_findfirst);
6521 break;
6522 }
6523
6524 case TRANSACT2_FINDNEXT:
6525 {
6526 START_PROFILE(Trans2_findnext);
6527 outsize = call_trans2findnext(
6528 conn, inbuf, outbuf, size, bufsize,
6529 &state->param, state->total_param,
6530 &state->data, state->total_data,
6531 state->max_data_return);
6532 END_PROFILE(Trans2_findnext);
6533 break;
6534 }
6535
6536 case TRANSACT2_QFSINFO:
6537 {
6538 START_PROFILE(Trans2_qfsinfo);
6539 outsize = call_trans2qfsinfo(
6540 conn, inbuf, outbuf, size, bufsize,
6541 &state->param, state->total_param,
6542 &state->data, state->total_data,
6543 state->max_data_return);
6544 END_PROFILE(Trans2_qfsinfo);
6545 break;
6546 }
6547
6548 case TRANSACT2_SETFSINFO:
6549 {
6550 START_PROFILE(Trans2_setfsinfo);
6551 outsize = call_trans2setfsinfo(
6552 conn, inbuf, outbuf, size, bufsize,
6553 &state->param, state->total_param,
6554 &state->data, state->total_data,
6555 state->max_data_return);
6556 END_PROFILE(Trans2_setfsinfo);
6557 break;
6558 }
6559
6560 case TRANSACT2_QPATHINFO:
6561 case TRANSACT2_QFILEINFO:
6562 {
6563 START_PROFILE(Trans2_qpathinfo);
6564 outsize = call_trans2qfilepathinfo(
6565 conn, inbuf, outbuf, size, bufsize, state->call,
6566 &state->param, state->total_param,
6567 &state->data, state->total_data,
6568 state->max_data_return);
6569 END_PROFILE(Trans2_qpathinfo);
6570 break;
6571 }
6572
6573 case TRANSACT2_SETPATHINFO:
6574 case TRANSACT2_SETFILEINFO:
6575 {
6576 START_PROFILE(Trans2_setpathinfo);
6577 outsize = call_trans2setfilepathinfo(
6578 conn, req, inbuf, outbuf, size, bufsize, state->call,
6579 &state->param, state->total_param,
6580 &state->data, state->total_data,
6581 state->max_data_return);
6582 END_PROFILE(Trans2_setpathinfo);
6583 break;
6584 }
6585
6586 case TRANSACT2_FINDNOTIFYFIRST:
6587 {
6588 START_PROFILE(Trans2_findnotifyfirst);
6589 outsize = call_trans2findnotifyfirst(
6590 conn, inbuf, outbuf, size, bufsize,
6591 &state->param, state->total_param,
6592 &state->data, state->total_data,
6593 state->max_data_return);
6594 END_PROFILE(Trans2_findnotifyfirst);
6595 break;
6596 }
6597
6598 case TRANSACT2_FINDNOTIFYNEXT:
6599 {
6600 START_PROFILE(Trans2_findnotifynext);
6601 outsize = call_trans2findnotifynext(
6602 conn, inbuf, outbuf, size, bufsize,
6603 &state->param, state->total_param,
6604 &state->data, state->total_data,
6605 state->max_data_return);
6606 END_PROFILE(Trans2_findnotifynext);
6607 break;
6608 }
6609
6610 case TRANSACT2_MKDIR:
6611 {
6612 START_PROFILE(Trans2_mkdir);
6613 outsize = call_trans2mkdir(
6614 conn, inbuf, outbuf, size, bufsize,
6615 &state->param, state->total_param,
6616 &state->data, state->total_data,
6617 state->max_data_return);
6618 END_PROFILE(Trans2_mkdir);
6619 break;
6620 }
6621
6622 case TRANSACT2_GET_DFS_REFERRAL:
6623 {
6624 START_PROFILE(Trans2_get_dfs_referral);
6625 outsize = call_trans2getdfsreferral(
6626 conn, inbuf, outbuf, size, bufsize,
6627 &state->param, state->total_param,
6628 &state->data, state->total_data,
6629 state->max_data_return);
6630 END_PROFILE(Trans2_get_dfs_referral);
6631 break;
6632 }
6633
6634 case TRANSACT2_IOCTL:
6635 {
6636 START_PROFILE(Trans2_ioctl);
6637 outsize = call_trans2ioctl(
6638 conn, inbuf, outbuf, size, bufsize,
6639 &state->param, state->total_param,
6640 &state->data, state->total_data,
6641 state->max_data_return);
6642 END_PROFILE(Trans2_ioctl);
6643 break;
6644 }
6645
6646 default:
6647 /* Error in request */
6648 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
6649 outsize = ERROR_DOS(ERRSRV,ERRerror);
6650 }
6651
6652 return outsize;
6653 }
6654
6655 /****************************************************************************
6656 Reply to a SMBtrans2.
6657 ****************************************************************************/
6658
6659 int reply_trans2(connection_struct *conn, char *inbuf,char *outbuf,
6660 int size, int bufsize)
6661 {
6662 int outsize = 0;
6663 unsigned int dsoff = SVAL(inbuf, smb_dsoff);
6664 unsigned int dscnt = SVAL(inbuf, smb_dscnt);
6665 unsigned int psoff = SVAL(inbuf, smb_psoff);
6666 unsigned int pscnt = SVAL(inbuf, smb_pscnt);
6667 unsigned int tran_call = SVAL(inbuf, smb_setup0);
6668 struct trans_state *state;
6669 NTSTATUS result;
6670
6671 START_PROFILE(SMBtrans2);
6672
6673 result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
6674 if (!NT_STATUS_IS_OK(result)) {
6675 DEBUG(2, ("Got invalid trans2 request: %s\n",
6676 nt_errstr(result)));
6677 END_PROFILE(SMBtrans2);
6678 return ERROR_NT(result);
6679 }
6680
6681 if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
6682 && (tran_call != TRANSACT2_GET_DFS_REFERRAL)
6683 && (tran_call != TRANSACT2_QFILEINFO)) {
6684 END_PROFILE(SMBtrans2);
6685 return ERROR_DOS(ERRSRV,ERRaccess);
6686 }
6687
6688 if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
6689 DEBUG(0, ("talloc failed\n"));
6690 END_PROFILE(SMBtrans2);
6691 return ERROR_NT(NT_STATUS_NO_MEMORY);
6692 }
6693
6694 state->cmd = SMBtrans2;
6695
6696 state->mid = SVAL(inbuf, smb_mid);
6697 state->vuid = SVAL(inbuf, smb_uid);
6698 state->setup_count = SVAL(inbuf, smb_suwcnt);
6699 state->setup = NULL;
6700 state->total_param = SVAL(inbuf, smb_tpscnt);
6701 state->param = NULL;
6702 state->total_data = SVAL(inbuf, smb_tdscnt);
6703 state->data = NULL;
6704 state->max_param_return = SVAL(inbuf, smb_mprcnt);
6705 state->max_data_return = SVAL(inbuf, smb_mdrcnt);
6706 state->max_setup_return = SVAL(inbuf, smb_msrcnt);
6707 state->close_on_completion = BITSETW(inbuf+smb_vwv5,0);
6708 state->one_way = BITSETW(inbuf+smb_vwv5,1);
6709
6710 state->call = tran_call;
6711
6712 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
6713 is so as a sanity check */
6714 if (state->setup_count != 1) {
6715 /*
6716 * Need to have rc=0 for ioctl to get job id for OS/2.
6717 * Network printing will fail if function is not successful.
6718 * Similar function in reply.c will be used if protocol
6719 * is LANMAN1.0 instead of LM1.2X002.
6720 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
6721 * outbuf doesn't have to be set(only job id is used).
6722 */
6723 if ( (state->setup_count == 4) && (tran_call == TRANSACT2_IOCTL) &&
6724 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6725 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6726 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
6727 } else {
6728 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
6729 DEBUG(2,("Transaction is %d\n",tran_call));
6730 TALLOC_FREE(state);
6731 END_PROFILE(SMBtrans2);
6732 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6733 }
6734 }
6735
6736 if ((dscnt > state->total_data) || (pscnt > state->total_param))
6737 goto bad_param;
6738
6739 if (state->total_data) {
6740 /* Can't use talloc here, the core routines do realloc on the
6741 * params and data. */
6742 state->data = (char *)SMB_MALLOC(state->total_data);
6743 if (state->data == NULL) {
6744 DEBUG(0,("reply_trans2: data malloc fail for %u "
6745 "bytes !\n", (unsigned int)state->total_data));
6746 TALLOC_FREE(state);
6747 END_PROFILE(SMBtrans2);
6748 return(ERROR_DOS(ERRDOS,ERRnomem));
6749 }
6750 if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
6751 goto bad_param;
6752 if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
6753 (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
6754 goto bad_param;
6755
6756 memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
6757 }
6758
6759 if (state->total_param) {
6760 /* Can't use talloc here, the core routines do realloc on the
6761 * params and data. */
6762 state->param = (char *)SMB_MALLOC(state->total_param);
6763 if (state->param == NULL) {
6764 DEBUG(0,("reply_trans: param malloc fail for %u "
6765 "bytes !\n", (unsigned int)state->total_param));
6766 SAFE_FREE(state->data);
6767 TALLOC_FREE(state);
6768 END_PROFILE(SMBtrans2);
6769 return(ERROR_DOS(ERRDOS,ERRnomem));
6770 }
6771 if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
6772 goto bad_param;
6773 if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
6774 (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
6775 goto bad_param;
6776
6777 memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
6778 }
6779
6780 state->received_data = dscnt;
6781 state->received_param = pscnt;
6782
6783 if ((state->received_param == state->total_param) &&
6784 (state->received_data == state->total_data)) {
6785
6786 struct smb_request req;
6787 init_smb_request(&req, (uint8 *)inbuf);
6788
6789 outsize = handle_trans2(conn, &req, state, inbuf, outbuf,
6790 size, bufsize);
6791 SAFE_FREE(state->data);
6792 SAFE_FREE(state->param);
6793 TALLOC_FREE(state);
6794 END_PROFILE(SMBtrans2);
6795 return outsize;
6796 }
6797
6798 DLIST_ADD(conn->pending_trans, state);
6799
6800 /* We need to send an interim response then receive the rest
6801 of the parameter/data bytes */
6802 outsize = set_message(inbuf, outbuf,0,0,False);
6803 show_msg(outbuf);
6804 END_PROFILE(SMBtrans2);
6805 return outsize;
6806
6807 bad_param:
6808
6809 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
6810 SAFE_FREE(state->data);
6811 SAFE_FREE(state->param);
6812 TALLOC_FREE(state);
6813 END_PROFILE(SMBtrans2);
6814 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6815 }
6816
6817
6818 /****************************************************************************
6819 Reply to a SMBtranss2
6820 ****************************************************************************/
6821
6822 int reply_transs2(connection_struct *conn,
6823 char *inbuf,char *outbuf,int size,int bufsize)
6824 {
6825 int outsize = 0;
6826 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
6827 struct trans_state *state;
6828 struct smb_request req;
6829
6830 START_PROFILE(SMBtranss2);
6831
6832 show_msg(inbuf);
6833
6834 for (state = conn->pending_trans; state != NULL;
6835 state = state->next) {
6836 if (state->mid == SVAL(inbuf,smb_mid)) {
6837 break;
6838 }
6839 }
6840
6841 if ((state == NULL) || (state->cmd != SMBtrans2)) {
6842 END_PROFILE(SMBtranss2);
6843 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6844 }
6845
6846 /* Revise state->total_param and state->total_data in case they have
6847 changed downwards */
6848
6849 if (SVAL(inbuf, smb_tpscnt) < state->total_param)
6850 state->total_param = SVAL(inbuf, smb_tpscnt);
6851 if (SVAL(inbuf, smb_tdscnt) < state->total_data)
6852 state->total_data = SVAL(inbuf, smb_tdscnt);
6853
6854 pcnt = SVAL(inbuf, smb_spscnt);
6855 poff = SVAL(inbuf, smb_spsoff);
6856 pdisp = SVAL(inbuf, smb_spsdisp);
6857
6858 dcnt = SVAL(inbuf, smb_sdscnt);
6859 doff = SVAL(inbuf, smb_sdsoff);
6860 ddisp = SVAL(inbuf, smb_sdsdisp);
6861
6862 state->received_param += pcnt;
6863 state->received_data += dcnt;
6864
6865 if ((state->received_data > state->total_data) ||
6866 (state->received_param > state->total_param))
6867 goto bad_param;
6868
6869 if (pcnt) {
6870 if (pdisp+pcnt > state->total_param)
6871 goto bad_param;
6872 if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
6873 goto bad_param;
6874 if (pdisp > state->total_param)
6875 goto bad_param;
6876 if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
6877 (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
6878 goto bad_param;
6879 if (state->param + pdisp < state->param)
6880 goto bad_param;
6881
6882 memcpy(state->param+pdisp,smb_base(inbuf)+poff,
6883 pcnt);
6884 }
6885
6886 if (dcnt) {
6887 if (ddisp+dcnt > state->total_data)
6888 goto bad_param;
6889 if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
6890 goto bad_param;
6891 if (ddisp > state->total_data)
6892 goto bad_param;
6893 if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
6894 (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
6895 goto bad_param;
6896 if (state->data + ddisp < state->data)
6897 goto bad_param;
6898
6899 memcpy(state->data+ddisp, smb_base(inbuf)+doff,
6900 dcnt);
6901 }
6902
6903 if ((state->received_param < state->total_param) ||
6904 (state->received_data < state->total_data)) {
6905 END_PROFILE(SMBtranss2);
6906 return -1;
6907 }
6908
6909 /* construct_reply_common has done us the favor to pre-fill the
6910 * command field with SMBtranss2 which is wrong :-)
6911 */
6912 SCVAL(outbuf,smb_com,SMBtrans2);
6913
6914 init_smb_request(&req, (uint8 *)inbuf);
6915
6916 outsize = handle_trans2(conn, &req, state, inbuf, outbuf, size,
6917 bufsize);
6918
6919 DLIST_REMOVE(conn->pending_trans, state);
6920 SAFE_FREE(state->data);
6921 SAFE_FREE(state->param);
6922 TALLOC_FREE(state);
6923
6924 if (outsize == 0) {
6925 END_PROFILE(SMBtranss2);
6926 return(ERROR_DOS(ERRSRV,ERRnosupport));
6927 }
6928
6929 END_PROFILE(SMBtranss2);
6930 return(outsize);
6931
6932 bad_param:
6933
6934 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
6935 DLIST_REMOVE(conn->pending_trans, state);
6936 SAFE_FREE(state->data);
6937 SAFE_FREE(state->param);
6938 TALLOC_FREE(state);
6939 END_PROFILE(SMBtranss2);
6940 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6941 }
Samba GIT mirror