?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-rpcclient: Fix Bug #7277. rpcclient was sending invalid data, causing cupsaddsmb...
[Samba.git] / source3 / smbd / trans2.c
blob36b2749700dcbfcc4f64870f8e2a65652afe6f17
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-2007
7 Copyright (C) Steve French 2005
8 Copyright (C) James Peach 2006-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 3 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, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "version.h"
28 #include "smbd/globals.h"
29 #include "../libcli/auth/libcli_auth.h"
30
31 #define DIR_ENTRY_SAFETY_MARGIN 4096
32
33 static char *store_file_unix_basic(connection_struct *conn,
34 char *pdata,
35 files_struct *fsp,
36 const SMB_STRUCT_STAT *psbuf);
37
38 static char *store_file_unix_basic_info2(connection_struct *conn,
39 char *pdata,
40 files_struct *fsp,
41 const SMB_STRUCT_STAT *psbuf);
42
43 /********************************************************************
44 Roundup a value to the nearest allocation roundup size boundary.
45 Only do this for Windows clients.
46 ********************************************************************/
47
48 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
49 {
50 uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
51
52 /* Only roundup for Windows clients. */
53 enum remote_arch_types ra_type = get_remote_arch();
54 if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
55 val = SMB_ROUNDUP(val,rval);
56 }
57 return val;
58 }
59
60 /****************************************************************************
61 Utility functions for dealing with extended attributes.
62 ****************************************************************************/
63
64 /****************************************************************************
65 Refuse to allow clients to overwrite our private xattrs.
66 ****************************************************************************/
67
68 static bool samba_private_attr_name(const char *unix_ea_name)
69 {
70 static const char * const prohibited_ea_names[] = {
71 SAMBA_POSIX_INHERITANCE_EA_NAME,
72 SAMBA_XATTR_DOS_ATTRIB,
73 SAMBA_XATTR_MARKER,
74 XATTR_NTACL_NAME,
75 NULL
76 };
77
78 int i;
79
80 for (i = 0; prohibited_ea_names[i]; i++) {
81 if (strequal( prohibited_ea_names[i], unix_ea_name))
82 return true;
83 }
84 if (StrnCaseCmp(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
85 strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
86 return true;
87 }
88 return false;
89 }
90
91 /****************************************************************************
92 Get one EA value. Fill in a struct ea_struct.
93 ****************************************************************************/
94
95 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn,
96 files_struct *fsp, const char *fname,
97 const char *ea_name, struct ea_struct *pea)
98 {
99 /* Get the value of this xattr. Max size is 64k. */
100 size_t attr_size = 256;
101 char *val = NULL;
102 ssize_t sizeret;
103
104 again:
105
106 val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
107 if (!val) {
108 return NT_STATUS_NO_MEMORY;
109 }
110
111 if (fsp && fsp->fh->fd != -1) {
112 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
113 } else {
114 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
115 }
116
117 if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
118 attr_size = 65536;
119 goto again;
120 }
121
122 if (sizeret == -1) {
123 return map_nt_error_from_unix(errno);
124 }
125
126 DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
127 dump_data(10, (uint8 *)val, sizeret);
128
129 pea->flags = 0;
130 if (strnequal(ea_name, "user.", 5)) {
131 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
132 } else {
133 pea->name = talloc_strdup(mem_ctx, ea_name);
134 }
135 if (pea->name == NULL) {
136 TALLOC_FREE(val);
137 return NT_STATUS_NO_MEMORY;
138 }
139 pea->value.data = (unsigned char *)val;
140 pea->value.length = (size_t)sizeret;
141 return NT_STATUS_OK;
142 }
143
144 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn,
145 files_struct *fsp, const char *fname,
146 char ***pnames, size_t *pnum_names)
147 {
148 /* Get a list of all xattrs. Max namesize is 64k. */
149 size_t ea_namelist_size = 1024;
150 char *ea_namelist = NULL;
151
152 char *p;
153 char **names, **tmp;
154 size_t num_names;
155 ssize_t sizeret = -1;
156
157 if (!lp_ea_support(SNUM(conn))) {
158 if (pnames) {
159 *pnames = NULL;
160 }
161 *pnum_names = 0;
162 return NT_STATUS_OK;
163 }
164
165 /*
166 * TALLOC the result early to get the talloc hierarchy right.
167 */
168
169 names = TALLOC_ARRAY(mem_ctx, char *, 1);
170 if (names == NULL) {
171 DEBUG(0, ("talloc failed\n"));
172 return NT_STATUS_NO_MEMORY;
173 }
174
175 while (ea_namelist_size <= 65536) {
176
177 ea_namelist = TALLOC_REALLOC_ARRAY(
178 names, ea_namelist, char, ea_namelist_size);
179 if (ea_namelist == NULL) {
180 DEBUG(0, ("talloc failed\n"));
181 TALLOC_FREE(names);
182 return NT_STATUS_NO_MEMORY;
183 }
184
185 if (fsp && fsp->fh->fd != -1) {
186 sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
187 ea_namelist_size);
188 } else {
189 sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist,
190 ea_namelist_size);
191 }
192
193 if ((sizeret == -1) && (errno == ERANGE)) {
194 ea_namelist_size *= 2;
195 }
196 else {
197 break;
198 }
199 }
200
201 if (sizeret == -1) {
202 TALLOC_FREE(names);
203 return map_nt_error_from_unix(errno);
204 }
205
206 DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
207 (unsigned int)sizeret));
208
209 if (sizeret == 0) {
210 TALLOC_FREE(names);
211 if (pnames) {
212 *pnames = NULL;
213 }
214 *pnum_names = 0;
215 return NT_STATUS_OK;
216 }
217
218 /*
219 * Ensure the result is 0-terminated
220 */
221
222 if (ea_namelist[sizeret-1] != '\0') {
223 TALLOC_FREE(names);
224 return NT_STATUS_INTERNAL_ERROR;
225 }
226
227 /*
228 * count the names
229 */
230 num_names = 0;
231
232 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
233 num_names += 1;
234 }
235
236 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, names, char *, num_names);
237 if (tmp == NULL) {
238 DEBUG(0, ("talloc failed\n"));
239 TALLOC_FREE(names);
240 return NT_STATUS_NO_MEMORY;
241 }
242
243 names = tmp;
244 num_names = 0;
245
246 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
247 names[num_names++] = p;
248 }
249
250 if (pnames) {
251 *pnames = names;
252 } else {
253 TALLOC_FREE(names);
254 }
255 *pnum_names = num_names;
256 return NT_STATUS_OK;
257 }
258
259 /****************************************************************************
260 Return a linked list of the total EA's. Plus the total size
261 ****************************************************************************/
262
263 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
264 const char *fname, size_t *pea_total_len)
265 {
266 /* Get a list of all xattrs. Max namesize is 64k. */
267 size_t i, num_names;
268 char **names;
269 struct ea_list *ea_list_head = NULL;
270 NTSTATUS status;
271
272 *pea_total_len = 0;
273
274 if (!lp_ea_support(SNUM(conn))) {
275 return NULL;
276 }
277
278 status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
279 &names, &num_names);
280
281 if (!NT_STATUS_IS_OK(status) || (num_names == 0)) {
282 return NULL;
283 }
284
285 for (i=0; i<num_names; i++) {
286 struct ea_list *listp;
287 fstring dos_ea_name;
288
289 if (strnequal(names[i], "system.", 7)
290 || samba_private_attr_name(names[i]))
291 continue;
292
293 listp = TALLOC_P(mem_ctx, struct ea_list);
294 if (listp == NULL) {
295 return NULL;
296 }
297
298 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx, conn, fsp,
299 fname, names[i],
300 &listp->ea))) {
301 return NULL;
302 }
303
304 push_ascii_fstring(dos_ea_name, listp->ea.name);
305
306 *pea_total_len +=
307 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
308
309 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
310 "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
311 (unsigned int)listp->ea.value.length));
312
313 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
314
315 }
316
317 /* Add on 4 for total length. */
318 if (*pea_total_len) {
319 *pea_total_len += 4;
320 }
321
322 DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
323 (unsigned int)*pea_total_len));
324
325 return ea_list_head;
326 }
327
328 /****************************************************************************
329 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
330 that was filled.
331 ****************************************************************************/
332
333 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
334 connection_struct *conn, struct ea_list *ea_list)
335 {
336 unsigned int ret_data_size = 4;
337 char *p = pdata;
338
339 SMB_ASSERT(total_data_size >= 4);
340
341 if (!lp_ea_support(SNUM(conn))) {
342 SIVAL(pdata,4,0);
343 return 4;
344 }
345
346 for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
347 size_t dos_namelen;
348 fstring dos_ea_name;
349 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
350 dos_namelen = strlen(dos_ea_name);
351 if (dos_namelen > 255 || dos_namelen == 0) {
352 break;
353 }
354 if (ea_list->ea.value.length > 65535) {
355 break;
356 }
357 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
358 break;
359 }
360
361 /* We know we have room. */
362 SCVAL(p,0,ea_list->ea.flags);
363 SCVAL(p,1,dos_namelen);
364 SSVAL(p,2,ea_list->ea.value.length);
365 fstrcpy(p+4, dos_ea_name);
366 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
367
368 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
369 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
370 }
371
372 ret_data_size = PTR_DIFF(p, pdata);
373 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
374 SIVAL(pdata,0,ret_data_size);
375 return ret_data_size;
376 }
377
378 static NTSTATUS fill_ea_chained_buffer(TALLOC_CTX *mem_ctx,
379 char *pdata,
380 unsigned int total_data_size,
381 unsigned int *ret_data_size,
382 connection_struct *conn,
383 struct ea_list *ea_list)
384 {
385 uint8_t *p = (uint8_t *)pdata;
386 uint8_t *last_start = NULL;
387
388 *ret_data_size = 0;
389
390 if (!lp_ea_support(SNUM(conn))) {
391 return NT_STATUS_NO_EAS_ON_FILE;
392 }
393
394 for (; ea_list; ea_list = ea_list->next) {
395 size_t dos_namelen;
396 fstring dos_ea_name;
397 size_t this_size;
398
399 if (last_start) {
400 SIVAL(last_start, 0, PTR_DIFF(p, last_start));
401 }
402 last_start = p;
403
404 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
405 dos_namelen = strlen(dos_ea_name);
406 if (dos_namelen > 255 || dos_namelen == 0) {
407 return NT_STATUS_INTERNAL_ERROR;
408 }
409 if (ea_list->ea.value.length > 65535) {
410 return NT_STATUS_INTERNAL_ERROR;
411 }
412
413 this_size = 0x08 + dos_namelen + 1 + ea_list->ea.value.length;
414
415 if (ea_list->next) {
416 size_t pad = 4 - (this_size % 4);
417 this_size += pad;
418 }
419
420 if (this_size > total_data_size) {
421 return NT_STATUS_INFO_LENGTH_MISMATCH;
422 }
423
424 /* We know we have room. */
425 SIVAL(p, 0x00, 0); /* next offset */
426 SCVAL(p, 0x04, ea_list->ea.flags);
427 SCVAL(p, 0x05, dos_namelen);
428 SSVAL(p, 0x06, ea_list->ea.value.length);
429 fstrcpy((char *)(p+0x08), dos_ea_name);
430 memcpy(p + 0x08 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
431
432 total_data_size -= this_size;
433 p += this_size;
434 }
435
436 *ret_data_size = PTR_DIFF(p, pdata);
437 DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size));
438 return NT_STATUS_OK;
439 }
440
441 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
442 {
443 size_t total_ea_len = 0;
444 TALLOC_CTX *mem_ctx = NULL;
445
446 if (!lp_ea_support(SNUM(conn))) {
447 return 0;
448 }
449 mem_ctx = talloc_tos();
450 (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
451 return total_ea_len;
452 }
453
454 /****************************************************************************
455 Ensure the EA name is case insensitive by matching any existing EA name.
456 ****************************************************************************/
457
458 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
459 {
460 size_t total_ea_len;
461 TALLOC_CTX *mem_ctx = talloc_tos();
462 struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
463
464 for (; ea_list; ea_list = ea_list->next) {
465 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
466 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
467 &unix_ea_name[5], ea_list->ea.name));
468 safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
469 break;
470 }
471 }
472 }
473
474 /****************************************************************************
475 Set or delete an extended attribute.
476 ****************************************************************************/
477
478 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp,
479 const struct smb_filename *smb_fname, struct ea_list *ea_list)
480 {
481 char *fname = NULL;
482
483 if (!lp_ea_support(SNUM(conn))) {
484 return NT_STATUS_EAS_NOT_SUPPORTED;
485 }
486
487 /* For now setting EAs on streams isn't supported. */
488 fname = smb_fname->base_name;
489
490 for (;ea_list; ea_list = ea_list->next) {
491 int ret;
492 fstring unix_ea_name;
493
494 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
495 fstrcat(unix_ea_name, ea_list->ea.name);
496
497 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
498
499 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
500
501 if (samba_private_attr_name(unix_ea_name)) {
502 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
503 return NT_STATUS_ACCESS_DENIED;
504 }
505
506 if (ea_list->ea.value.length == 0) {
507 /* Remove the attribute. */
508 if (fsp && (fsp->fh->fd != -1)) {
509 DEBUG(10,("set_ea: deleting ea name %s on "
510 "file %s by file descriptor.\n",
511 unix_ea_name, fsp_str_dbg(fsp)));
512 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
513 } else {
514 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
515 unix_ea_name, fname));
516 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
517 }
518 #ifdef ENOATTR
519 /* Removing a non existent attribute always succeeds. */
520 if (ret == -1 && errno == ENOATTR) {
521 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
522 unix_ea_name));
523 ret = 0;
524 }
525 #endif
526 } else {
527 if (fsp && (fsp->fh->fd != -1)) {
528 DEBUG(10,("set_ea: setting ea name %s on file "
529 "%s by file descriptor.\n",
530 unix_ea_name, fsp_str_dbg(fsp)));
531 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
532 ea_list->ea.value.data, ea_list->ea.value.length, 0);
533 } else {
534 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
535 unix_ea_name, fname));
536 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
537 ea_list->ea.value.data, ea_list->ea.value.length, 0);
538 }
539 }
540
541 if (ret == -1) {
542 #ifdef ENOTSUP
543 if (errno == ENOTSUP) {
544 return NT_STATUS_EAS_NOT_SUPPORTED;
545 }
546 #endif
547 return map_nt_error_from_unix(errno);
548 }
549
550 }
551 return NT_STATUS_OK;
552 }
553 /****************************************************************************
554 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
555 ****************************************************************************/
556
557 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
558 {
559 struct ea_list *ea_list_head = NULL;
560 size_t converted_size, offset = 0;
561
562 while (offset + 2 < data_size) {
563 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
564 unsigned int namelen = CVAL(pdata,offset);
565
566 offset++; /* Go past the namelen byte. */
567
568 /* integer wrap paranioa. */
569 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
570 (offset > data_size) || (namelen > data_size) ||
571 (offset + namelen >= data_size)) {
572 break;
573 }
574 /* Ensure the name is null terminated. */
575 if (pdata[offset + namelen] != '\0') {
576 return NULL;
577 }
578 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
579 &converted_size)) {
580 DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
581 "failed: %s", strerror(errno)));
582 }
583 if (!eal->ea.name) {
584 return NULL;
585 }
586
587 offset += (namelen + 1); /* Go past the name + terminating zero. */
588 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
589 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
590 }
591
592 return ea_list_head;
593 }
594
595 /****************************************************************************
596 Read one EA list entry from the buffer.
597 ****************************************************************************/
598
599 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
600 {
601 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
602 uint16 val_len;
603 unsigned int namelen;
604 size_t converted_size;
605
606 if (!eal) {
607 return NULL;
608 }
609
610 if (data_size < 6) {
611 return NULL;
612 }
613
614 eal->ea.flags = CVAL(pdata,0);
615 namelen = CVAL(pdata,1);
616 val_len = SVAL(pdata,2);
617
618 if (4 + namelen + 1 + val_len > data_size) {
619 return NULL;
620 }
621
622 /* Ensure the name is null terminated. */
623 if (pdata[namelen + 4] != '\0') {
624 return NULL;
625 }
626 if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
627 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
628 strerror(errno)));
629 }
630 if (!eal->ea.name) {
631 return NULL;
632 }
633
634 eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
635 if (!eal->ea.value.data) {
636 return NULL;
637 }
638
639 memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
640
641 /* Ensure we're null terminated just in case we print the value. */
642 eal->ea.value.data[val_len] = '\0';
643 /* But don't count the null. */
644 eal->ea.value.length--;
645
646 if (pbytes_used) {
647 *pbytes_used = 4 + namelen + 1 + val_len;
648 }
649
650 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
651 dump_data(10, eal->ea.value.data, eal->ea.value.length);
652
653 return eal;
654 }
655
656 /****************************************************************************
657 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
658 ****************************************************************************/
659
660 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
661 {
662 struct ea_list *ea_list_head = NULL;
663 size_t offset = 0;
664 size_t bytes_used = 0;
665
666 while (offset < data_size) {
667 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
668
669 if (!eal) {
670 return NULL;
671 }
672
673 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
674 offset += bytes_used;
675 }
676
677 return ea_list_head;
678 }
679
680 /****************************************************************************
681 Count the total EA size needed.
682 ****************************************************************************/
683
684 static size_t ea_list_size(struct ea_list *ealist)
685 {
686 fstring dos_ea_name;
687 struct ea_list *listp;
688 size_t ret = 0;
689
690 for (listp = ealist; listp; listp = listp->next) {
691 push_ascii_fstring(dos_ea_name, listp->ea.name);
692 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
693 }
694 /* Add on 4 for total length. */
695 if (ret) {
696 ret += 4;
697 }
698
699 return ret;
700 }
701
702 /****************************************************************************
703 Return a union of EA's from a file list and a list of names.
704 The TALLOC context for the two lists *MUST* be identical as we steal
705 memory from one list to add to another. JRA.
706 ****************************************************************************/
707
708 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
709 {
710 struct ea_list *nlistp, *flistp;
711
712 for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
713 for (flistp = file_list; flistp; flistp = flistp->next) {
714 if (strequal(nlistp->ea.name, flistp->ea.name)) {
715 break;
716 }
717 }
718
719 if (flistp) {
720 /* Copy the data from this entry. */
721 nlistp->ea.flags = flistp->ea.flags;
722 nlistp->ea.value = flistp->ea.value;
723 } else {
724 /* Null entry. */
725 nlistp->ea.flags = 0;
726 ZERO_STRUCT(nlistp->ea.value);
727 }
728 }
729
730 *total_ea_len = ea_list_size(name_list);
731 return name_list;
732 }
733
734 /****************************************************************************
735 Send the required number of replies back.
736 We assume all fields other than the data fields are
737 set correctly for the type of call.
738 HACK ! Always assumes smb_setup field is zero.
739 ****************************************************************************/
740
741 void send_trans2_replies(connection_struct *conn,
742 struct smb_request *req,
743 const char *params,
744 int paramsize,
745 const char *pdata,
746 int datasize,
747 int max_data_bytes)
748 {
749 /* As we are using a protocol > LANMAN1 then the max_send
750 variable must have been set in the sessetupX call.
751 This takes precedence over the max_xmit field in the
752 global struct. These different max_xmit variables should
753 be merged as this is now too confusing */
754
755 int data_to_send = datasize;
756 int params_to_send = paramsize;
757 int useable_space;
758 const char *pp = params;
759 const char *pd = pdata;
760 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
761 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
762 int data_alignment_offset = 0;
763 bool overflow = False;
764 struct smbd_server_connection *sconn = smbd_server_conn;
765 int max_send = sconn->smb1.sessions.max_send;
766
767 /* Modify the data_to_send and datasize and set the error if
768 we're trying to send more than max_data_bytes. We still send
769 the part of the packet(s) that fit. Strange, but needed
770 for OS/2. */
771
772 if (max_data_bytes > 0 && datasize > max_data_bytes) {
773 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
774 max_data_bytes, datasize ));
775 datasize = data_to_send = max_data_bytes;
776 overflow = True;
777 }
778
779 /* If there genuinely are no parameters or data to send just send the empty packet */
780
781 if(params_to_send == 0 && data_to_send == 0) {
782 reply_outbuf(req, 10, 0);
783 show_msg((char *)req->outbuf);
784 if (!srv_send_smb(smbd_server_fd(),
785 (char *)req->outbuf,
786 true, req->seqnum+1,
787 IS_CONN_ENCRYPTED(conn),
788 &req->pcd)) {
789 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
790 }
791 TALLOC_FREE(req->outbuf);
792 return;
793 }
794
795 /* When sending params and data ensure that both are nicely aligned */
796 /* Only do this alignment when there is also data to send - else
797 can cause NT redirector problems. */
798
799 if (((params_to_send % 4) != 0) && (data_to_send != 0))
800 data_alignment_offset = 4 - (params_to_send % 4);
801
802 /* Space is bufsize minus Netbios over TCP header minus SMB header */
803 /* The alignment_offset is to align the param bytes on an even byte
804 boundary. NT 4.0 Beta needs this to work correctly. */
805
806 useable_space = max_send - (smb_size
807 + 2 * 10 /* wct */
808 + alignment_offset
809 + data_alignment_offset);
810
811 if (useable_space < 0) {
812 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
813 "= %d!!!", useable_space));
814 exit_server_cleanly("send_trans2_replies: Not enough space");
815 }
816
817 while (params_to_send || data_to_send) {
818 /* Calculate whether we will totally or partially fill this packet */
819
820 total_sent_thistime = params_to_send + data_to_send;
821
822 /* We can never send more than useable_space */
823 /*
824 * Note that 'useable_space' does not include the alignment offsets,
825 * but we must include the alignment offsets in the calculation of
826 * the length of the data we send over the wire, as the alignment offsets
827 * are sent here. Fix from Marc_Jacobsen@hp.com.
828 */
829
830 total_sent_thistime = MIN(total_sent_thistime, useable_space);
831
832 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
833 + data_alignment_offset);
834
835 /*
836 * We might have SMBtrans2s in req which was transferred to
837 * the outbuf, fix that.
838 */
839 SCVAL(req->outbuf, smb_com, SMBtrans2);
840
841 /* Set total params and data to be sent */
842 SSVAL(req->outbuf,smb_tprcnt,paramsize);
843 SSVAL(req->outbuf,smb_tdrcnt,datasize);
844
845 /* Calculate how many parameters and data we can fit into
846 * this packet. Parameters get precedence
847 */
848
849 params_sent_thistime = MIN(params_to_send,useable_space);
850 data_sent_thistime = useable_space - params_sent_thistime;
851 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
852
853 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
854
855 /* smb_proff is the offset from the start of the SMB header to the
856 parameter bytes, however the first 4 bytes of outbuf are
857 the Netbios over TCP header. Thus use smb_base() to subtract
858 them from the calculation */
859
860 SSVAL(req->outbuf,smb_proff,
861 ((smb_buf(req->outbuf)+alignment_offset)
862 - smb_base(req->outbuf)));
863
864 if(params_sent_thistime == 0)
865 SSVAL(req->outbuf,smb_prdisp,0);
866 else
867 /* Absolute displacement of param bytes sent in this packet */
868 SSVAL(req->outbuf,smb_prdisp,pp - params);
869
870 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
871 if(data_sent_thistime == 0) {
872 SSVAL(req->outbuf,smb_droff,0);
873 SSVAL(req->outbuf,smb_drdisp, 0);
874 } else {
875 /* The offset of the data bytes is the offset of the
876 parameter bytes plus the number of parameters being sent this time */
877 SSVAL(req->outbuf, smb_droff,
878 ((smb_buf(req->outbuf)+alignment_offset)
879 - smb_base(req->outbuf))
880 + params_sent_thistime + data_alignment_offset);
881 SSVAL(req->outbuf,smb_drdisp, pd - pdata);
882 }
883
884 /* Initialize the padding for alignment */
885
886 if (alignment_offset != 0) {
887 memset(smb_buf(req->outbuf), 0, alignment_offset);
888 }
889
890 /* Copy the param bytes into the packet */
891
892 if(params_sent_thistime) {
893 memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
894 params_sent_thistime);
895 }
896
897 /* Copy in the data bytes */
898 if(data_sent_thistime) {
899 if (data_alignment_offset != 0) {
900 memset((smb_buf(req->outbuf)+alignment_offset+
901 params_sent_thistime), 0,
902 data_alignment_offset);
903 }
904 memcpy(smb_buf(req->outbuf)+alignment_offset
905 +params_sent_thistime+data_alignment_offset,
906 pd,data_sent_thistime);
907 }
908
909 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
910 params_sent_thistime, data_sent_thistime, useable_space));
911 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
912 params_to_send, data_to_send, paramsize, datasize));
913
914 if (overflow) {
915 error_packet_set((char *)req->outbuf,
916 ERRDOS,ERRbufferoverflow,
917 STATUS_BUFFER_OVERFLOW,
918 __LINE__,__FILE__);
919 }
920
921 /* Send the packet */
922 show_msg((char *)req->outbuf);
923 if (!srv_send_smb(smbd_server_fd(),
924 (char *)req->outbuf,
925 true, req->seqnum+1,
926 IS_CONN_ENCRYPTED(conn),
927 &req->pcd))
928 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
929
930 TALLOC_FREE(req->outbuf);
931
932 pp += params_sent_thistime;
933 pd += data_sent_thistime;
934
935 params_to_send -= params_sent_thistime;
936 data_to_send -= data_sent_thistime;
937
938 /* Sanity check */
939 if(params_to_send < 0 || data_to_send < 0) {
940 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
941 params_to_send, data_to_send));
942 return;
943 }
944 }
945
946 return;
947 }
948
949 /****************************************************************************
950 Reply to a TRANSACT2_OPEN.
951 ****************************************************************************/
952
953 static void call_trans2open(connection_struct *conn,
954 struct smb_request *req,
955 char **pparams, int total_params,
956 char **ppdata, int total_data,
957 unsigned int max_data_bytes)
958 {
959 struct smb_filename *smb_fname = NULL;
960 char *params = *pparams;
961 char *pdata = *ppdata;
962 int deny_mode;
963 int32 open_attr;
964 bool oplock_request;
965 #if 0
966 bool return_additional_info;
967 int16 open_sattr;
968 time_t open_time;
969 #endif
970 int open_ofun;
971 uint32 open_size;
972 char *pname;
973 char *fname = NULL;
974 SMB_OFF_T size=0;
975 int fattr=0,mtime=0;
976 SMB_INO_T inode = 0;
977 int smb_action = 0;
978 files_struct *fsp;
979 struct ea_list *ea_list = NULL;
980 uint16 flags = 0;
981 NTSTATUS status;
982 uint32 access_mask;
983 uint32 share_mode;
984 uint32 create_disposition;
985 uint32 create_options = 0;
986 TALLOC_CTX *ctx = talloc_tos();
987
988 /*
989 * Ensure we have enough parameters to perform the operation.
990 */
991
992 if (total_params < 29) {
993 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
994 goto out;
995 }
996
997 flags = SVAL(params, 0);
998 deny_mode = SVAL(params, 2);
999 open_attr = SVAL(params,6);
1000 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1001 if (oplock_request) {
1002 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1003 }
1004
1005 #if 0
1006 return_additional_info = BITSETW(params,0);
1007 open_sattr = SVAL(params, 4);
1008 open_time = make_unix_date3(params+8);
1009 #endif
1010 open_ofun = SVAL(params,12);
1011 open_size = IVAL(params,14);
1012 pname = &params[28];
1013
1014 if (IS_IPC(conn)) {
1015 reply_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
1016 goto out;
1017 }
1018
1019 srvstr_get_path(ctx, params, req->flags2, &fname, pname,
1020 total_params - 28, STR_TERMINATE,
1021 &status);
1022 if (!NT_STATUS_IS_OK(status)) {
1023 reply_nterror(req, status);
1024 goto out;
1025 }
1026
1027 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1028 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
1029 (unsigned int)open_ofun, open_size));
1030
1031 status = filename_convert(ctx,
1032 conn,
1033 req->flags2 & FLAGS2_DFS_PATHNAMES,
1034 fname,
1035 0,
1036 NULL,
1037 &smb_fname);
1038 if (!NT_STATUS_IS_OK(status)) {
1039 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1040 reply_botherror(req,
1041 NT_STATUS_PATH_NOT_COVERED,
1042 ERRSRV, ERRbadpath);
1043 goto out;
1044 }
1045 reply_nterror(req, status);
1046 goto out;
1047 }
1048
1049 if (open_ofun == 0) {
1050 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
1051 goto out;
1052 }
1053
1054 if (!map_open_params_to_ntcreate(smb_fname, deny_mode, open_ofun,
1055 &access_mask, &share_mode,
1056 &create_disposition,
1057 &create_options)) {
1058 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1059 goto out;
1060 }
1061
1062 /* Any data in this call is an EA list. */
1063 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
1064 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
1065 goto out;
1066 }
1067
1068 if (total_data != 4) {
1069 if (total_data < 10) {
1070 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1071 goto out;
1072 }
1073
1074 if (IVAL(pdata,0) > total_data) {
1075 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1076 IVAL(pdata,0), (unsigned int)total_data));
1077 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1078 goto out;
1079 }
1080
1081 ea_list = read_ea_list(talloc_tos(), pdata + 4,
1082 total_data - 4);
1083 if (!ea_list) {
1084 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1085 goto out;
1086 }
1087 } else if (IVAL(pdata,0) != 4) {
1088 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1089 goto out;
1090 }
1091
1092 status = SMB_VFS_CREATE_FILE(
1093 conn, /* conn */
1094 req, /* req */
1095 0, /* root_dir_fid */
1096 smb_fname, /* fname */
1097 access_mask, /* access_mask */
1098 share_mode, /* share_access */
1099 create_disposition, /* create_disposition*/
1100 create_options, /* create_options */
1101 open_attr, /* file_attributes */
1102 oplock_request, /* oplock_request */
1103 open_size, /* allocation_size */
1104 NULL, /* sd */
1105 ea_list, /* ea_list */
1106 &fsp, /* result */
1107 &smb_action); /* psbuf */
1108
1109 if (!NT_STATUS_IS_OK(status)) {
1110 if (open_was_deferred(req->mid)) {
1111 /* We have re-scheduled this call. */
1112 goto out;
1113 }
1114 reply_openerror(req, status);
1115 goto out;
1116 }
1117
1118 size = get_file_size_stat(&smb_fname->st);
1119 fattr = dos_mode(conn, smb_fname);
1120 mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
1121 inode = smb_fname->st.st_ex_ino;
1122 if (fattr & aDIR) {
1123 close_file(req, fsp, ERROR_CLOSE);
1124 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1125 goto out;
1126 }
1127
1128 /* Realloc the size of parameters and data we will return */
1129 *pparams = (char *)SMB_REALLOC(*pparams, 30);
1130 if(*pparams == NULL ) {
1131 reply_nterror(req, NT_STATUS_NO_MEMORY);
1132 goto out;
1133 }
1134 params = *pparams;
1135
1136 SSVAL(params,0,fsp->fnum);
1137 SSVAL(params,2,fattr);
1138 srv_put_dos_date2(params,4, mtime);
1139 SIVAL(params,8, (uint32)size);
1140 SSVAL(params,12,deny_mode);
1141 SSVAL(params,14,0); /* open_type - file or directory. */
1142 SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1143
1144 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1145 smb_action |= EXTENDED_OPLOCK_GRANTED;
1146 }
1147
1148 SSVAL(params,18,smb_action);
1149
1150 /*
1151 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1152 */
1153 SIVAL(params,20,inode);
1154 SSVAL(params,24,0); /* Padding. */
1155 if (flags & 8) {
1156 uint32 ea_size = estimate_ea_size(conn, fsp,
1157 fsp->fsp_name->base_name);
1158 SIVAL(params, 26, ea_size);
1159 } else {
1160 SIVAL(params, 26, 0);
1161 }
1162
1163 /* Send the required number of replies */
1164 send_trans2_replies(conn, req, params, 30, *ppdata, 0, max_data_bytes);
1165 out:
1166 TALLOC_FREE(smb_fname);
1167 }
1168
1169 /*********************************************************
1170 Routine to check if a given string matches exactly.
1171 as a special case a mask of "." does NOT match. That
1172 is required for correct wildcard semantics
1173 Case can be significant or not.
1174 **********************************************************/
1175
1176 static bool exact_match(bool has_wild,
1177 bool case_sensitive,
1178 const char *str,
1179 const char *mask)
1180 {
1181 if (mask[0] == '.' && mask[1] == 0) {
1182 return false;
1183 }
1184
1185 if (has_wild) {
1186 return false;
1187 }
1188
1189 if (case_sensitive) {
1190 return strcmp(str,mask)==0;
1191 } else {
1192 return StrCaseCmp(str,mask) == 0;
1193 }
1194 }
1195
1196 /****************************************************************************
1197 Return the filetype for UNIX extensions.
1198 ****************************************************************************/
1199
1200 static uint32 unix_filetype(mode_t mode)
1201 {
1202 if(S_ISREG(mode))
1203 return UNIX_TYPE_FILE;
1204 else if(S_ISDIR(mode))
1205 return UNIX_TYPE_DIR;
1206 #ifdef S_ISLNK
1207 else if(S_ISLNK(mode))
1208 return UNIX_TYPE_SYMLINK;
1209 #endif
1210 #ifdef S_ISCHR
1211 else if(S_ISCHR(mode))
1212 return UNIX_TYPE_CHARDEV;
1213 #endif
1214 #ifdef S_ISBLK
1215 else if(S_ISBLK(mode))
1216 return UNIX_TYPE_BLKDEV;
1217 #endif
1218 #ifdef S_ISFIFO
1219 else if(S_ISFIFO(mode))
1220 return UNIX_TYPE_FIFO;
1221 #endif
1222 #ifdef S_ISSOCK
1223 else if(S_ISSOCK(mode))
1224 return UNIX_TYPE_SOCKET;
1225 #endif
1226
1227 DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1228 return UNIX_TYPE_UNKNOWN;
1229 }
1230
1231 /****************************************************************************
1232 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1233 ****************************************************************************/
1234
1235 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1236
1237 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1238 const SMB_STRUCT_STAT *psbuf,
1239 uint32 perms,
1240 enum perm_type ptype,
1241 mode_t *ret_perms)
1242 {
1243 mode_t ret = 0;
1244
1245 if (perms == SMB_MODE_NO_CHANGE) {
1246 if (!VALID_STAT(*psbuf)) {
1247 return NT_STATUS_INVALID_PARAMETER;
1248 } else {
1249 *ret_perms = psbuf->st_ex_mode;
1250 return NT_STATUS_OK;
1251 }
1252 }
1253
1254 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1255 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1256 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1257 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1258 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1259 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1260 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1261 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1262 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1263 #ifdef S_ISVTX
1264 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1265 #endif
1266 #ifdef S_ISGID
1267 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1268 #endif
1269 #ifdef S_ISUID
1270 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1271 #endif
1272
1273 switch (ptype) {
1274 case PERM_NEW_FILE:
1275 /* Apply mode mask */
1276 ret &= lp_create_mask(SNUM(conn));
1277 /* Add in force bits */
1278 ret |= lp_force_create_mode(SNUM(conn));
1279 break;
1280 case PERM_NEW_DIR:
1281 ret &= lp_dir_mask(SNUM(conn));
1282 /* Add in force bits */
1283 ret |= lp_force_dir_mode(SNUM(conn));
1284 break;
1285 case PERM_EXISTING_FILE:
1286 /* Apply mode mask */
1287 ret &= lp_security_mask(SNUM(conn));
1288 /* Add in force bits */
1289 ret |= lp_force_security_mode(SNUM(conn));
1290 break;
1291 case PERM_EXISTING_DIR:
1292 /* Apply mode mask */
1293 ret &= lp_dir_security_mask(SNUM(conn));
1294 /* Add in force bits */
1295 ret |= lp_force_dir_security_mode(SNUM(conn));
1296 break;
1297 }
1298
1299 *ret_perms = ret;
1300 return NT_STATUS_OK;
1301 }
1302
1303 /****************************************************************************
1304 Needed to show the msdfs symlinks as directories. Modifies psbuf
1305 to be a directory if it's a msdfs link.
1306 ****************************************************************************/
1307
1308 static bool check_msdfs_link(connection_struct *conn,
1309 const char *pathname,
1310 SMB_STRUCT_STAT *psbuf)
1311 {
1312 int saved_errno = errno;
1313 if(lp_host_msdfs() &&
1314 lp_msdfs_root(SNUM(conn)) &&
1315 is_msdfs_link(conn, pathname, psbuf)) {
1316
1317 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1318 "as a directory\n",
1319 pathname));
1320 psbuf->st_ex_mode = (psbuf->st_ex_mode & 0xFFF) | S_IFDIR;
1321 errno = saved_errno;
1322 return true;
1323 }
1324 errno = saved_errno;
1325 return false;
1326 }
1327
1328
1329 /****************************************************************************
1330 Get a level dependent lanman2 dir entry.
1331 ****************************************************************************/
1332
1333 struct smbd_dirptr_lanman2_state {
1334 connection_struct *conn;
1335 uint32_t info_level;
1336 bool check_mangled_names;
1337 bool has_wild;
1338 bool got_exact_match;
1339 };
1340
1341 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX *ctx,
1342 void *private_data,
1343 const char *dname,
1344 const char *mask,
1345 char **_fname)
1346 {
1347 struct smbd_dirptr_lanman2_state *state =
1348 (struct smbd_dirptr_lanman2_state *)private_data;
1349 bool ok;
1350 char mangled_name[13]; /* mangled 8.3 name. */
1351 bool got_match;
1352 const char *fname;
1353
1354 /* Mangle fname if it's an illegal name. */
1355 if (mangle_must_mangle(dname, state->conn->params)) {
1356 ok = name_to_8_3(dname, mangled_name,
1357 true, state->conn->params);
1358 if (!ok) {
1359 return false;
1360 }
1361 fname = mangled_name;
1362 } else {
1363 fname = dname;
1364 }
1365
1366 got_match = exact_match(state->has_wild,
1367 state->conn->case_sensitive,
1368 fname, mask);
1369 state->got_exact_match = got_match;
1370 if (!got_match) {
1371 got_match = mask_match(fname, mask,
1372 state->conn->case_sensitive);
1373 }
1374
1375 if(!got_match && state->check_mangled_names &&
1376 !mangle_is_8_3(fname, false, state->conn->params)) {
1377 /*
1378 * It turns out that NT matches wildcards against
1379 * both long *and* short names. This may explain some
1380 * of the wildcard wierdness from old DOS clients
1381 * that some people have been seeing.... JRA.
1382 */
1383 /* Force the mangling into 8.3. */
1384 ok = name_to_8_3(fname, mangled_name,
1385 false, state->conn->params);
1386 if (!ok) {
1387 return false;
1388 }
1389
1390 got_match = exact_match(state->has_wild,
1391 state->conn->case_sensitive,
1392 mangled_name, mask);
1393 state->got_exact_match = got_match;
1394 if (!got_match) {
1395 got_match = mask_match(mangled_name, mask,
1396 state->conn->case_sensitive);
1397 }
1398 }
1399
1400 if (!got_match) {
1401 return false;
1402 }
1403
1404 *_fname = talloc_strdup(ctx, fname);
1405 if (*_fname == NULL) {
1406 return false;
1407 }
1408
1409 return true;
1410 }
1411
1412 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX *ctx,
1413 void *private_data,
1414 struct smb_filename *smb_fname,
1415 uint32_t *_mode)
1416 {
1417 struct smbd_dirptr_lanman2_state *state =
1418 (struct smbd_dirptr_lanman2_state *)private_data;
1419 bool ms_dfs_link = false;
1420 uint32_t mode = 0;
1421
1422 if (INFO_LEVEL_IS_UNIX(state->info_level)) {
1423 if (SMB_VFS_LSTAT(state->conn, smb_fname) != 0) {
1424 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1425 "Couldn't lstat [%s] (%s)\n",
1426 smb_fname_str_dbg(smb_fname),
1427 strerror(errno)));
1428 return false;
1429 }
1430 } else if (!VALID_STAT(smb_fname->st) &&
1431 SMB_VFS_STAT(state->conn, smb_fname) != 0) {
1432 /* Needed to show the msdfs symlinks as
1433 * directories */
1434
1435 ms_dfs_link = check_msdfs_link(state->conn,
1436 smb_fname->base_name,
1437 &smb_fname->st);
1438 if (!ms_dfs_link) {
1439 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1440 "Couldn't stat [%s] (%s)\n",
1441 smb_fname_str_dbg(smb_fname),
1442 strerror(errno)));
1443 return false;
1444 }
1445 }
1446
1447 if (ms_dfs_link) {
1448 mode = dos_mode_msdfs(state->conn, smb_fname);
1449 } else {
1450 mode = dos_mode(state->conn, smb_fname);
1451 }
1452
1453 *_mode = mode;
1454 return true;
1455 }
1456
1457 static bool smbd_marshall_dir_entry(TALLOC_CTX *ctx,
1458 connection_struct *conn,
1459 uint16_t flags2,
1460 uint32_t info_level,
1461 struct ea_list *name_list,
1462 bool check_mangled_names,
1463 bool requires_resume_key,
1464 uint32_t mode,
1465 const char *fname,
1466 const struct smb_filename *smb_fname,
1467 uint64_t space_remaining,
1468 uint8_t align,
1469 bool do_pad,
1470 char *base_data,
1471 char **ppdata,
1472 char *end_data,
1473 bool *out_of_space,
1474 uint64_t *last_entry_off)
1475 {
1476 char *p, *q, *pdata = *ppdata;
1477 uint32_t reskey=0;
1478 uint64_t file_size = 0;
1479 uint64_t allocation_size = 0;
1480 uint32_t len;
1481 struct timespec mdate_ts, adate_ts, cdate_ts, create_date_ts;
1482 time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1483 time_t c_date = (time_t)0;
1484 char *nameptr;
1485 char *last_entry_ptr;
1486 bool was_8_3;
1487 off_t off;
1488 off_t pad = 0;
1489
1490 *out_of_space = false;
1491
1492 ZERO_STRUCT(mdate_ts);
1493 ZERO_STRUCT(adate_ts);
1494 ZERO_STRUCT(create_date_ts);
1495 ZERO_STRUCT(cdate_ts);
1496
1497 if (!(mode & aDIR)) {
1498 file_size = get_file_size_stat(&smb_fname->st);
1499 }
1500 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
1501
1502 mdate_ts = smb_fname->st.st_ex_mtime;
1503 adate_ts = smb_fname->st.st_ex_atime;
1504 create_date_ts = get_create_timespec(conn, NULL, smb_fname);
1505 cdate_ts = get_change_timespec(conn, NULL, smb_fname);
1506
1507 if (lp_dos_filetime_resolution(SNUM(conn))) {
1508 dos_filetime_timespec(&create_date_ts);
1509 dos_filetime_timespec(&mdate_ts);
1510 dos_filetime_timespec(&adate_ts);
1511 dos_filetime_timespec(&cdate_ts);
1512 }
1513
1514 create_date = convert_timespec_to_time_t(create_date_ts);
1515 mdate = convert_timespec_to_time_t(mdate_ts);
1516 adate = convert_timespec_to_time_t(adate_ts);
1517 c_date = convert_timespec_to_time_t(cdate_ts);
1518
1519 /* align the record */
1520 off = PTR_DIFF(pdata, base_data);
1521 pad = (off + (align-1)) & ~(align-1);
1522 pad -= off;
1523 off += pad;
1524 /* initialize padding to 0 */
1525 if (pad) {
1526 memset(pdata, 0, pad);
1527 }
1528 space_remaining -= pad;
1529
1530 pdata += pad;
1531 p = pdata;
1532 last_entry_ptr = p;
1533
1534 pad = 0;
1535 off = 0;
1536
1537 switch (info_level) {
1538 case SMB_FIND_INFO_STANDARD:
1539 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1540 if(requires_resume_key) {
1541 SIVAL(p,0,reskey);
1542 p += 4;
1543 }
1544 srv_put_dos_date2(p,0,create_date);
1545 srv_put_dos_date2(p,4,adate);
1546 srv_put_dos_date2(p,8,mdate);
1547 SIVAL(p,12,(uint32)file_size);
1548 SIVAL(p,16,(uint32)allocation_size);
1549 SSVAL(p,20,mode);
1550 p += 23;
1551 nameptr = p;
1552 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1553 p += ucs2_align(base_data, p, 0);
1554 }
1555 len = srvstr_push(base_data, flags2, p,
1556 fname, PTR_DIFF(end_data, p),
1557 STR_TERMINATE);
1558 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1559 if (len > 2) {
1560 SCVAL(nameptr, -1, len - 2);
1561 } else {
1562 SCVAL(nameptr, -1, 0);
1563 }
1564 } else {
1565 if (len > 1) {
1566 SCVAL(nameptr, -1, len - 1);
1567 } else {
1568 SCVAL(nameptr, -1, 0);
1569 }
1570 }
1571 p += len;
1572 break;
1573
1574 case SMB_FIND_EA_SIZE:
1575 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_SIZE\n"));
1576 if (requires_resume_key) {
1577 SIVAL(p,0,reskey);
1578 p += 4;
1579 }
1580 srv_put_dos_date2(p,0,create_date);
1581 srv_put_dos_date2(p,4,adate);
1582 srv_put_dos_date2(p,8,mdate);
1583 SIVAL(p,12,(uint32)file_size);
1584 SIVAL(p,16,(uint32)allocation_size);
1585 SSVAL(p,20,mode);
1586 {
1587 unsigned int ea_size = estimate_ea_size(conn, NULL,
1588 smb_fname->base_name);
1589 SIVAL(p,22,ea_size); /* Extended attributes */
1590 }
1591 p += 27;
1592 nameptr = p - 1;
1593 len = srvstr_push(base_data, flags2,
1594 p, fname, PTR_DIFF(end_data, p),
1595 STR_TERMINATE | STR_NOALIGN);
1596 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1597 if (len > 2) {
1598 len -= 2;
1599 } else {
1600 len = 0;
1601 }
1602 } else {
1603 if (len > 1) {
1604 len -= 1;
1605 } else {
1606 len = 0;
1607 }
1608 }
1609 SCVAL(nameptr,0,len);
1610 p += len;
1611 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1612 break;
1613
1614 case SMB_FIND_EA_LIST:
1615 {
1616 struct ea_list *file_list = NULL;
1617 size_t ea_len = 0;
1618
1619 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_LIST\n"));
1620 if (!name_list) {
1621 return false;
1622 }
1623 if (requires_resume_key) {
1624 SIVAL(p,0,reskey);
1625 p += 4;
1626 }
1627 srv_put_dos_date2(p,0,create_date);
1628 srv_put_dos_date2(p,4,adate);
1629 srv_put_dos_date2(p,8,mdate);
1630 SIVAL(p,12,(uint32)file_size);
1631 SIVAL(p,16,(uint32)allocation_size);
1632 SSVAL(p,20,mode);
1633 p += 22; /* p now points to the EA area. */
1634
1635 file_list = get_ea_list_from_file(ctx, conn, NULL,
1636 smb_fname->base_name,
1637 &ea_len);
1638 name_list = ea_list_union(name_list, file_list, &ea_len);
1639
1640 /* We need to determine if this entry will fit in the space available. */
1641 /* Max string size is 255 bytes. */
1642 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1643 *out_of_space = true;
1644 DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
1645 return False; /* Not finished - just out of space */
1646 }
1647
1648 /* Push the ea_data followed by the name. */
1649 p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1650 nameptr = p;
1651 len = srvstr_push(base_data, flags2,
1652 p + 1, fname, PTR_DIFF(end_data, p+1),
1653 STR_TERMINATE | STR_NOALIGN);
1654 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1655 if (len > 2) {
1656 len -= 2;
1657 } else {
1658 len = 0;
1659 }
1660 } else {
1661 if (len > 1) {
1662 len -= 1;
1663 } else {
1664 len = 0;
1665 }
1666 }
1667 SCVAL(nameptr,0,len);
1668 p += len + 1;
1669 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1670 break;
1671 }
1672
1673 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1674 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1675 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1676 p += 4;
1677 SIVAL(p,0,reskey); p += 4;
1678 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1679 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1680 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1681 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1682 SOFF_T(p,0,file_size); p += 8;
1683 SOFF_T(p,0,allocation_size); p += 8;
1684 SIVAL(p,0,mode); p += 4;
1685 q = p; p += 4; /* q is placeholder for name length. */
1686 {
1687 unsigned int ea_size = estimate_ea_size(conn, NULL,
1688 smb_fname->base_name);
1689 SIVAL(p,0,ea_size); /* Extended attributes */
1690 p += 4;
1691 }
1692 /* Clear the short name buffer. This is
1693 * IMPORTANT as not doing so will trigger
1694 * a Win2k client bug. JRA.
1695 */
1696 if (!was_8_3 && check_mangled_names) {
1697 char mangled_name[13]; /* mangled 8.3 name. */
1698 if (!name_to_8_3(fname,mangled_name,True,
1699 conn->params)) {
1700 /* Error - mangle failed ! */
1701 memset(mangled_name,'\0',12);
1702 }
1703 mangled_name[12] = 0;
1704 len = srvstr_push(base_data, flags2,
1705 p+2, mangled_name, 24,
1706 STR_UPPER|STR_UNICODE);
1707 if (len < 24) {
1708 memset(p + 2 + len,'\0',24 - len);
1709 }
1710 SSVAL(p, 0, len);
1711 } else {
1712 memset(p,'\0',26);
1713 }
1714 p += 2 + 24;
1715 len = srvstr_push(base_data, flags2, p,
1716 fname, PTR_DIFF(end_data, p),
1717 STR_TERMINATE_ASCII);
1718 SIVAL(q,0,len);
1719 p += len;
1720
1721 len = PTR_DIFF(p, pdata);
1722 pad = (len + (align-1)) & ~(align-1);
1723 /*
1724 * offset to the next entry, the caller
1725 * will overwrite it for the last entry
1726 * that's why we always include the padding
1727 */
1728 SIVAL(pdata,0,pad);
1729 /*
1730 * set padding to zero
1731 */
1732 if (do_pad) {
1733 memset(p, 0, pad - len);
1734 p = pdata + pad;
1735 } else {
1736 p = pdata + len;
1737 }
1738 break;
1739
1740 case SMB_FIND_FILE_DIRECTORY_INFO:
1741 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1742 p += 4;
1743 SIVAL(p,0,reskey); p += 4;
1744 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1745 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1746 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1747 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1748 SOFF_T(p,0,file_size); p += 8;
1749 SOFF_T(p,0,allocation_size); p += 8;
1750 SIVAL(p,0,mode); p += 4;
1751 len = srvstr_push(base_data, flags2,
1752 p + 4, fname, PTR_DIFF(end_data, p+4),
1753 STR_TERMINATE_ASCII);
1754 SIVAL(p,0,len);
1755 p += 4 + len;
1756
1757 len = PTR_DIFF(p, pdata);
1758 pad = (len + (align-1)) & ~(align-1);
1759 /*
1760 * offset to the next entry, the caller
1761 * will overwrite it for the last entry
1762 * that's why we always include the padding
1763 */
1764 SIVAL(pdata,0,pad);
1765 /*
1766 * set padding to zero
1767 */
1768 if (do_pad) {
1769 memset(p, 0, pad - len);
1770 p = pdata + pad;
1771 } else {
1772 p = pdata + len;
1773 }
1774 break;
1775
1776 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1777 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1778 p += 4;
1779 SIVAL(p,0,reskey); p += 4;
1780 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1781 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1782 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1783 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1784 SOFF_T(p,0,file_size); p += 8;
1785 SOFF_T(p,0,allocation_size); p += 8;
1786 SIVAL(p,0,mode); p += 4;
1787 q = p; p += 4; /* q is placeholder for name length. */
1788 {
1789 unsigned int ea_size = estimate_ea_size(conn, NULL,
1790 smb_fname->base_name);
1791 SIVAL(p,0,ea_size); /* Extended attributes */
1792 p +=4;
1793 }
1794 len = srvstr_push(base_data, flags2, p,
1795 fname, PTR_DIFF(end_data, p),
1796 STR_TERMINATE_ASCII);
1797 SIVAL(q, 0, len);
1798 p += len;
1799
1800 len = PTR_DIFF(p, pdata);
1801 pad = (len + (align-1)) & ~(align-1);
1802 /*
1803 * offset to the next entry, the caller
1804 * will overwrite it for the last entry
1805 * that's why we always include the padding
1806 */
1807 SIVAL(pdata,0,pad);
1808 /*
1809 * set padding to zero
1810 */
1811 if (do_pad) {
1812 memset(p, 0, pad - len);
1813 p = pdata + pad;
1814 } else {
1815 p = pdata + len;
1816 }
1817 break;
1818
1819 case SMB_FIND_FILE_NAMES_INFO:
1820 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1821 p += 4;
1822 SIVAL(p,0,reskey); p += 4;
1823 p += 4;
1824 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1825 acl on a dir (tridge) */
1826 len = srvstr_push(base_data, flags2, p,
1827 fname, PTR_DIFF(end_data, p),
1828 STR_TERMINATE_ASCII);
1829 SIVAL(p, -4, len);
1830 p += len;
1831
1832 len = PTR_DIFF(p, pdata);
1833 pad = (len + (align-1)) & ~(align-1);
1834 /*
1835 * offset to the next entry, the caller
1836 * will overwrite it for the last entry
1837 * that's why we always include the padding
1838 */
1839 SIVAL(pdata,0,pad);
1840 /*
1841 * set padding to zero
1842 */
1843 if (do_pad) {
1844 memset(p, 0, pad - len);
1845 p = pdata + pad;
1846 } else {
1847 p = pdata + len;
1848 }
1849 break;
1850
1851 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1852 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1853 p += 4;
1854 SIVAL(p,0,reskey); p += 4;
1855 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1856 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1857 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1858 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1859 SOFF_T(p,0,file_size); p += 8;
1860 SOFF_T(p,0,allocation_size); p += 8;
1861 SIVAL(p,0,mode); p += 4;
1862 q = p; p += 4; /* q is placeholder for name length. */
1863 {
1864 unsigned int ea_size = estimate_ea_size(conn, NULL,
1865 smb_fname->base_name);
1866 SIVAL(p,0,ea_size); /* Extended attributes */
1867 p +=4;
1868 }
1869 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1870 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1871 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1872 len = srvstr_push(base_data, flags2, p,
1873 fname, PTR_DIFF(end_data, p),
1874 STR_TERMINATE_ASCII);
1875 SIVAL(q, 0, len);
1876 p += len;
1877
1878 len = PTR_DIFF(p, pdata);
1879 pad = (len + (align-1)) & ~(align-1);
1880 /*
1881 * offset to the next entry, the caller
1882 * will overwrite it for the last entry
1883 * that's why we always include the padding
1884 */
1885 SIVAL(pdata,0,pad);
1886 /*
1887 * set padding to zero
1888 */
1889 if (do_pad) {
1890 memset(p, 0, pad - len);
1891 p = pdata + pad;
1892 } else {
1893 p = pdata + len;
1894 }
1895 break;
1896
1897 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1898 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1899 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1900 p += 4;
1901 SIVAL(p,0,reskey); p += 4;
1902 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1903 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1904 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1905 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1906 SOFF_T(p,0,file_size); p += 8;
1907 SOFF_T(p,0,allocation_size); p += 8;
1908 SIVAL(p,0,mode); p += 4;
1909 q = p; p += 4; /* q is placeholder for name length */
1910 {
1911 unsigned int ea_size = estimate_ea_size(conn, NULL,
1912 smb_fname->base_name);
1913 SIVAL(p,0,ea_size); /* Extended attributes */
1914 p +=4;
1915 }
1916 /* Clear the short name buffer. This is
1917 * IMPORTANT as not doing so will trigger
1918 * a Win2k client bug. JRA.
1919 */
1920 if (!was_8_3 && check_mangled_names) {
1921 char mangled_name[13]; /* mangled 8.3 name. */
1922 if (!name_to_8_3(fname,mangled_name,True,
1923 conn->params)) {
1924 /* Error - mangle failed ! */
1925 memset(mangled_name,'\0',12);
1926 }
1927 mangled_name[12] = 0;
1928 len = srvstr_push(base_data, flags2,
1929 p+2, mangled_name, 24,
1930 STR_UPPER|STR_UNICODE);
1931 SSVAL(p, 0, len);
1932 if (len < 24) {
1933 memset(p + 2 + len,'\0',24 - len);
1934 }
1935 SSVAL(p, 0, len);
1936 } else {
1937 memset(p,'\0',26);
1938 }
1939 p += 26;
1940 SSVAL(p,0,0); p += 2; /* Reserved ? */
1941 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1942 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1943 len = srvstr_push(base_data, flags2, p,
1944 fname, PTR_DIFF(end_data, p),
1945 STR_TERMINATE_ASCII);
1946 SIVAL(q,0,len);
1947 p += len;
1948
1949 len = PTR_DIFF(p, pdata);
1950 pad = (len + (align-1)) & ~(align-1);
1951 /*
1952 * offset to the next entry, the caller
1953 * will overwrite it for the last entry
1954 * that's why we always include the padding
1955 */
1956 SIVAL(pdata,0,pad);
1957 /*
1958 * set padding to zero
1959 */
1960 if (do_pad) {
1961 memset(p, 0, pad - len);
1962 p = pdata + pad;
1963 } else {
1964 p = pdata + len;
1965 }
1966 break;
1967
1968 /* CIFS UNIX Extension. */
1969
1970 case SMB_FIND_FILE_UNIX:
1971 case SMB_FIND_FILE_UNIX_INFO2:
1972 p+= 4;
1973 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
1974
1975 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1976
1977 if (info_level == SMB_FIND_FILE_UNIX) {
1978 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX\n"));
1979 p = store_file_unix_basic(conn, p,
1980 NULL, &smb_fname->st);
1981 len = srvstr_push(base_data, flags2, p,
1982 fname, PTR_DIFF(end_data, p),
1983 STR_TERMINATE);
1984 } else {
1985 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1986 p = store_file_unix_basic_info2(conn, p,
1987 NULL, &smb_fname->st);
1988 nameptr = p;
1989 p += 4;
1990 len = srvstr_push(base_data, flags2, p, fname,
1991 PTR_DIFF(end_data, p), 0);
1992 SIVAL(nameptr, 0, len);
1993 }
1994
1995 p += len;
1996
1997 len = PTR_DIFF(p, pdata);
1998 pad = (len + (align-1)) & ~(align-1);
1999 /*
2000 * offset to the next entry, the caller
2001 * will overwrite it for the last entry
2002 * that's why we always include the padding
2003 */
2004 SIVAL(pdata,0,pad);
2005 /*
2006 * set padding to zero
2007 */
2008 if (do_pad) {
2009 memset(p, 0, pad - len);
2010 p = pdata + pad;
2011 } else {
2012 p = pdata + len;
2013 }
2014 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2015
2016 break;
2017
2018 default:
2019 return false;
2020 }
2021
2022 if (PTR_DIFF(p,pdata) > space_remaining) {
2023 *out_of_space = true;
2024 DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
2025 return false; /* Not finished - just out of space */
2026 }
2027
2028 /* Setup the last entry pointer, as an offset from base_data */
2029 *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
2030 /* Advance the data pointer to the next slot */
2031 *ppdata = p;
2032
2033 return true;
2034 }
2035
2036 bool smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
2037 connection_struct *conn,
2038 struct dptr_struct *dirptr,
2039 uint16 flags2,
2040 const char *path_mask,
2041 uint32 dirtype,
2042 int info_level,
2043 int requires_resume_key,
2044 bool dont_descend,
2045 bool ask_sharemode,
2046 uint8_t align,
2047 bool do_pad,
2048 char **ppdata,
2049 char *base_data,
2050 char *end_data,
2051 int space_remaining,
2052 bool *out_of_space,
2053 bool *got_exact_match,
2054 int *_last_entry_off,
2055 struct ea_list *name_list)
2056 {
2057 const char *p;
2058 const char *mask = NULL;
2059 long prev_dirpos = 0;
2060 uint32_t mode = 0;
2061 char *fname = NULL;
2062 struct smb_filename *smb_fname = NULL;
2063 struct smbd_dirptr_lanman2_state state;
2064 bool ok;
2065 uint64_t last_entry_off = 0;
2066
2067 ZERO_STRUCT(state);
2068 state.conn = conn;
2069 state.info_level = info_level;
2070 state.check_mangled_names = lp_manglednames(conn->params);
2071 state.has_wild = dptr_has_wild(dirptr);
2072 state.got_exact_match = false;
2073
2074 *out_of_space = false;
2075 *got_exact_match = false;
2076
2077 p = strrchr_m(path_mask,'/');
2078 if(p != NULL) {
2079 if(p[1] == '\0') {
2080 mask = "*.*";
2081 } else {
2082 mask = p+1;
2083 }
2084 } else {
2085 mask = path_mask;
2086 }
2087
2088 ok = smbd_dirptr_get_entry(ctx,
2089 dirptr,
2090 mask,
2091 dirtype,
2092 dont_descend,
2093 ask_sharemode,
2094 smbd_dirptr_lanman2_match_fn,
2095 smbd_dirptr_lanman2_mode_fn,
2096 &state,
2097 &fname,
2098 &smb_fname,
2099 &mode,
2100 &prev_dirpos);
2101 if (!ok) {
2102 return false;
2103 }
2104
2105 *got_exact_match = state.got_exact_match;
2106
2107 ok = smbd_marshall_dir_entry(ctx,
2108 conn,
2109 flags2,
2110 info_level,
2111 name_list,
2112 state.check_mangled_names,
2113 requires_resume_key,
2114 mode,
2115 fname,
2116 smb_fname,
2117 space_remaining,
2118 align,
2119 do_pad,
2120 base_data,
2121 ppdata,
2122 end_data,
2123 out_of_space,
2124 &last_entry_off);
2125 TALLOC_FREE(fname);
2126 TALLOC_FREE(smb_fname);
2127 if (*out_of_space) {
2128 dptr_SeekDir(dirptr, prev_dirpos);
2129 return false;
2130 }
2131 if (!ok) {
2132 return false;
2133 }
2134
2135 *_last_entry_off = last_entry_off;
2136 return true;
2137 }
2138
2139 static bool get_lanman2_dir_entry(TALLOC_CTX *ctx,
2140 connection_struct *conn,
2141 struct dptr_struct *dirptr,
2142 uint16 flags2,
2143 const char *path_mask,
2144 uint32 dirtype,
2145 int info_level,
2146 bool requires_resume_key,
2147 bool dont_descend,
2148 bool ask_sharemode,
2149 char **ppdata,
2150 char *base_data,
2151 char *end_data,
2152 int space_remaining,
2153 bool *out_of_space,
2154 bool *got_exact_match,
2155 int *last_entry_off,
2156 struct ea_list *name_list)
2157 {
2158 uint8_t align = 4;
2159 const bool do_pad = true;
2160
2161 if (info_level >= 1 && info_level <= 3) {
2162 /* No alignment on earlier info levels. */
2163 align = 1;
2164 }
2165
2166 return smbd_dirptr_lanman2_entry(ctx, conn, dirptr, flags2,
2167 path_mask, dirtype, info_level,
2168 requires_resume_key, dont_descend, ask_sharemode,
2169 align, do_pad,
2170 ppdata, base_data, end_data,
2171 space_remaining,
2172 out_of_space, got_exact_match,
2173 last_entry_off, name_list);
2174 }
2175
2176 /****************************************************************************
2177 Reply to a TRANS2_FINDFIRST.
2178 ****************************************************************************/
2179
2180 static void call_trans2findfirst(connection_struct *conn,
2181 struct smb_request *req,
2182 char **pparams, int total_params,
2183 char **ppdata, int total_data,
2184 unsigned int max_data_bytes)
2185 {
2186 /* We must be careful here that we don't return more than the
2187 allowed number of data bytes. If this means returning fewer than
2188 maxentries then so be it. We assume that the redirector has
2189 enough room for the fixed number of parameter bytes it has
2190 requested. */
2191 struct smb_filename *smb_dname = NULL;
2192 char *params = *pparams;
2193 char *pdata = *ppdata;
2194 char *data_end;
2195 uint32 dirtype;
2196 int maxentries;
2197 uint16 findfirst_flags;
2198 bool close_after_first;
2199 bool close_if_end;
2200 bool requires_resume_key;
2201 int info_level;
2202 char *directory = NULL;
2203 char *mask = NULL;
2204 char *p;
2205 int last_entry_off=0;
2206 int dptr_num = -1;
2207 int numentries = 0;
2208 int i;
2209 bool finished = False;
2210 bool dont_descend = False;
2211 bool out_of_space = False;
2212 int space_remaining;
2213 bool mask_contains_wcard = False;
2214 struct ea_list *ea_list = NULL;
2215 NTSTATUS ntstatus = NT_STATUS_OK;
2216 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2217 TALLOC_CTX *ctx = talloc_tos();
2218 struct dptr_struct *dirptr = NULL;
2219 struct smbd_server_connection *sconn = smbd_server_conn;
2220
2221 if (total_params < 13) {
2222 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2223 goto out;
2224 }
2225
2226 dirtype = SVAL(params,0);
2227 maxentries = SVAL(params,2);
2228 findfirst_flags = SVAL(params,4);
2229 close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
2230 close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2231 requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2232 info_level = SVAL(params,6);
2233
2234 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2235 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
2236 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
2237 info_level, max_data_bytes));
2238
2239 if (!maxentries) {
2240 /* W2K3 seems to treat zero as 1. */
2241 maxentries = 1;
2242 }
2243
2244 switch (info_level) {
2245 case SMB_FIND_INFO_STANDARD:
2246 case SMB_FIND_EA_SIZE:
2247 case SMB_FIND_EA_LIST:
2248 case SMB_FIND_FILE_DIRECTORY_INFO:
2249 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2250 case SMB_FIND_FILE_NAMES_INFO:
2251 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2252 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2253 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2254 break;
2255 case SMB_FIND_FILE_UNIX:
2256 case SMB_FIND_FILE_UNIX_INFO2:
2257 /* Always use filesystem for UNIX mtime query. */
2258 ask_sharemode = false;
2259 if (!lp_unix_extensions()) {
2260 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2261 goto out;
2262 }
2263 break;
2264 default:
2265 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2266 goto out;
2267 }
2268
2269 srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
2270 params+12, total_params - 12,
2271 STR_TERMINATE, &ntstatus, &mask_contains_wcard);
2272 if (!NT_STATUS_IS_OK(ntstatus)) {
2273 reply_nterror(req, ntstatus);
2274 goto out;
2275 }
2276
2277 ntstatus = filename_convert(ctx, conn,
2278 req->flags2 & FLAGS2_DFS_PATHNAMES,
2279 directory,
2280 (UCF_SAVE_LCOMP |
2281 UCF_ALWAYS_ALLOW_WCARD_LCOMP),
2282 &mask_contains_wcard,
2283 &smb_dname);
2284 if (!NT_STATUS_IS_OK(ntstatus)) {
2285 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
2286 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2287 ERRSRV, ERRbadpath);
2288 goto out;
2289 }
2290 reply_nterror(req, ntstatus);
2291 goto out;
2292 }
2293
2294 mask = smb_dname->original_lcomp;
2295
2296 directory = smb_dname->base_name;
2297
2298 p = strrchr_m(directory,'/');
2299 if(p == NULL) {
2300 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2301 if((directory[0] == '.') && (directory[1] == '\0')) {
2302 mask = talloc_strdup(ctx,"*");
2303 if (!mask) {
2304 reply_nterror(req, NT_STATUS_NO_MEMORY);
2305 goto out;
2306 }
2307 mask_contains_wcard = True;
2308 }
2309 directory = talloc_strdup(talloc_tos(), "./");
2310 if (!directory) {
2311 reply_nterror(req, NT_STATUS_NO_MEMORY);
2312 goto out;
2313 }
2314 } else {
2315 *p = 0;
2316 }
2317
2318 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2319
2320 if (info_level == SMB_FIND_EA_LIST) {
2321 uint32 ea_size;
2322
2323 if (total_data < 4) {
2324 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2325 goto out;
2326 }
2327
2328 ea_size = IVAL(pdata,0);
2329 if (ea_size != total_data) {
2330 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2331 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2332 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2333 goto out;
2334 }
2335
2336 if (!lp_ea_support(SNUM(conn))) {
2337 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2338 goto out;
2339 }
2340
2341 /* Pull out the list of names. */
2342 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2343 if (!ea_list) {
2344 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2345 goto out;
2346 }
2347 }
2348
2349 *ppdata = (char *)SMB_REALLOC(
2350 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2351 if(*ppdata == NULL ) {
2352 reply_nterror(req, NT_STATUS_NO_MEMORY);
2353 goto out;
2354 }
2355 pdata = *ppdata;
2356 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2357
2358 /* Realloc the params space */
2359 *pparams = (char *)SMB_REALLOC(*pparams, 10);
2360 if (*pparams == NULL) {
2361 reply_nterror(req, NT_STATUS_NO_MEMORY);
2362 goto out;
2363 }
2364 params = *pparams;
2365
2366 /* Save the wildcard match and attribs we are using on this directory -
2367 needed as lanman2 assumes these are being saved between calls */
2368
2369 ntstatus = dptr_create(conn,
2370 directory,
2371 False,
2372 True,
2373 req->smbpid,
2374 mask,
2375 mask_contains_wcard,
2376 dirtype,
2377 &dirptr);
2378
2379 if (!NT_STATUS_IS_OK(ntstatus)) {
2380 reply_nterror(req, ntstatus);
2381 goto out;
2382 }
2383
2384 dptr_num = dptr_dnum(dirptr);
2385 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2386
2387 /* Initialize per TRANS2_FIND_FIRST operation data */
2388 dptr_init_search_op(dirptr);
2389
2390 /* We don't need to check for VOL here as this is returned by
2391 a different TRANS2 call. */
2392
2393 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2394 directory,lp_dontdescend(SNUM(conn))));
2395 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2396 dont_descend = True;
2397
2398 p = pdata;
2399 space_remaining = max_data_bytes;
2400 out_of_space = False;
2401
2402 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2403 bool got_exact_match = False;
2404
2405 /* this is a heuristic to avoid seeking the dirptr except when
2406 absolutely necessary. It allows for a filename of about 40 chars */
2407 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2408 out_of_space = True;
2409 finished = False;
2410 } else {
2411 finished = !get_lanman2_dir_entry(ctx,
2412 conn,
2413 dirptr,
2414 req->flags2,
2415 mask,dirtype,info_level,
2416 requires_resume_key,dont_descend,
2417 ask_sharemode,
2418 &p,pdata,data_end,
2419 space_remaining, &out_of_space,
2420 &got_exact_match,
2421 &last_entry_off, ea_list);
2422 }
2423
2424 if (finished && out_of_space)
2425 finished = False;
2426
2427 if (!finished && !out_of_space)
2428 numentries++;
2429
2430 /*
2431 * As an optimisation if we know we aren't looking
2432 * for a wildcard name (ie. the name matches the wildcard exactly)
2433 * then we can finish on any (first) match.
2434 * This speeds up large directory searches. JRA.
2435 */
2436
2437 if(got_exact_match)
2438 finished = True;
2439
2440 /* Ensure space_remaining never goes -ve. */
2441 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2442 space_remaining = 0;
2443 out_of_space = true;
2444 } else {
2445 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2446 }
2447 }
2448
2449 /* Check if we can close the dirptr */
2450 if(close_after_first || (finished && close_if_end)) {
2451 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2452 dptr_close(sconn, &dptr_num);
2453 }
2454
2455 /*
2456 * If there are no matching entries we must return ERRDOS/ERRbadfile -
2457 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2458 * the protocol level is less than NT1. Tested with smbclient. JRA.
2459 * This should fix the OS/2 client bug #2335.
2460 */
2461
2462 if(numentries == 0) {
2463 dptr_close(sconn, &dptr_num);
2464 if (get_Protocol() < PROTOCOL_NT1) {
2465 reply_force_doserror(req, ERRDOS, ERRnofiles);
2466 goto out;
2467 } else {
2468 reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2469 ERRDOS, ERRbadfile);
2470 goto out;
2471 }
2472 }
2473
2474 /* At this point pdata points to numentries directory entries. */
2475
2476 /* Set up the return parameter block */
2477 SSVAL(params,0,dptr_num);
2478 SSVAL(params,2,numentries);
2479 SSVAL(params,4,finished);
2480 SSVAL(params,6,0); /* Never an EA error */
2481 SSVAL(params,8,last_entry_off);
2482
2483 send_trans2_replies(conn, req, params, 10, pdata, PTR_DIFF(p,pdata),
2484 max_data_bytes);
2485
2486 if ((! *directory) && dptr_path(sconn, dptr_num)) {
2487 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2488 if (!directory) {
2489 reply_nterror(req, NT_STATUS_NO_MEMORY);
2490 }
2491 }
2492
2493 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2494 smb_fn_name(req->cmd),
2495 mask, directory, dirtype, numentries ) );
2496
2497 /*
2498 * Force a name mangle here to ensure that the
2499 * mask as an 8.3 name is top of the mangled cache.
2500 * The reasons for this are subtle. Don't remove
2501 * this code unless you know what you are doing
2502 * (see PR#13758). JRA.
2503 */
2504
2505 if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2506 char mangled_name[13];
2507 name_to_8_3(mask, mangled_name, True, conn->params);
2508 }
2509 out:
2510 TALLOC_FREE(smb_dname);
2511 return;
2512 }
2513
2514 /****************************************************************************
2515 Reply to a TRANS2_FINDNEXT.
2516 ****************************************************************************/
2517
2518 static void call_trans2findnext(connection_struct *conn,
2519 struct smb_request *req,
2520 char **pparams, int total_params,
2521 char **ppdata, int total_data,
2522 unsigned int max_data_bytes)
2523 {
2524 /* We must be careful here that we don't return more than the
2525 allowed number of data bytes. If this means returning fewer than
2526 maxentries then so be it. We assume that the redirector has
2527 enough room for the fixed number of parameter bytes it has
2528 requested. */
2529 char *params = *pparams;
2530 char *pdata = *ppdata;
2531 char *data_end;
2532 int dptr_num;
2533 int maxentries;
2534 uint16 info_level;
2535 uint32 resume_key;
2536 uint16 findnext_flags;
2537 bool close_after_request;
2538 bool close_if_end;
2539 bool requires_resume_key;
2540 bool continue_bit;
2541 bool mask_contains_wcard = False;
2542 char *resume_name = NULL;
2543 const char *mask = NULL;
2544 const char *directory = NULL;
2545 char *p = NULL;
2546 uint16 dirtype;
2547 int numentries = 0;
2548 int i, last_entry_off=0;
2549 bool finished = False;
2550 bool dont_descend = False;
2551 bool out_of_space = False;
2552 int space_remaining;
2553 struct ea_list *ea_list = NULL;
2554 NTSTATUS ntstatus = NT_STATUS_OK;
2555 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2556 TALLOC_CTX *ctx = talloc_tos();
2557 struct dptr_struct *dirptr;
2558 struct smbd_server_connection *sconn = smbd_server_conn;
2559
2560 if (total_params < 13) {
2561 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2562 return;
2563 }
2564
2565 dptr_num = SVAL(params,0);
2566 maxentries = SVAL(params,2);
2567 info_level = SVAL(params,4);
2568 resume_key = IVAL(params,6);
2569 findnext_flags = SVAL(params,10);
2570 close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2571 close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2572 requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2573 continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2574
2575 if (!continue_bit) {
2576 /* We only need resume_name if continue_bit is zero. */
2577 srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2578 params+12,
2579 total_params - 12, STR_TERMINATE, &ntstatus,
2580 &mask_contains_wcard);
2581 if (!NT_STATUS_IS_OK(ntstatus)) {
2582 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2583 complain (it thinks we're asking for the directory above the shared
2584 path or an invalid name). Catch this as the resume name is only compared, never used in
2585 a file access. JRA. */
2586 srvstr_pull_talloc(ctx, params, req->flags2,
2587 &resume_name, params+12,
2588 total_params - 12,
2589 STR_TERMINATE);
2590
2591 if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2592 reply_nterror(req, ntstatus);
2593 return;
2594 }
2595 }
2596 }
2597
2598 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2599 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2600 resume_key = %d resume name = %s continue=%d level = %d\n",
2601 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2602 requires_resume_key, resume_key,
2603 resume_name ? resume_name : "(NULL)", continue_bit, info_level));
2604
2605 if (!maxentries) {
2606 /* W2K3 seems to treat zero as 1. */
2607 maxentries = 1;
2608 }
2609
2610 switch (info_level) {
2611 case SMB_FIND_INFO_STANDARD:
2612 case SMB_FIND_EA_SIZE:
2613 case SMB_FIND_EA_LIST:
2614 case SMB_FIND_FILE_DIRECTORY_INFO:
2615 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2616 case SMB_FIND_FILE_NAMES_INFO:
2617 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2618 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2619 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2620 break;
2621 case SMB_FIND_FILE_UNIX:
2622 case SMB_FIND_FILE_UNIX_INFO2:
2623 /* Always use filesystem for UNIX mtime query. */
2624 ask_sharemode = false;
2625 if (!lp_unix_extensions()) {
2626 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2627 return;
2628 }
2629 break;
2630 default:
2631 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2632 return;
2633 }
2634
2635 if (info_level == SMB_FIND_EA_LIST) {
2636 uint32 ea_size;
2637
2638 if (total_data < 4) {
2639 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2640 return;
2641 }
2642
2643 ea_size = IVAL(pdata,0);
2644 if (ea_size != total_data) {
2645 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2646 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2647 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2648 return;
2649 }
2650
2651 if (!lp_ea_support(SNUM(conn))) {
2652 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2653 return;
2654 }
2655
2656 /* Pull out the list of names. */
2657 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2658 if (!ea_list) {
2659 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2660 return;
2661 }
2662 }
2663
2664 *ppdata = (char *)SMB_REALLOC(
2665 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2666 if(*ppdata == NULL) {
2667 reply_nterror(req, NT_STATUS_NO_MEMORY);
2668 return;
2669 }
2670
2671 pdata = *ppdata;
2672 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2673
2674 /* Realloc the params space */
2675 *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2676 if(*pparams == NULL ) {
2677 reply_nterror(req, NT_STATUS_NO_MEMORY);
2678 return;
2679 }
2680
2681 params = *pparams;
2682
2683 /* Check that the dptr is valid */
2684 if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
2685 reply_nterror(req, STATUS_NO_MORE_FILES);
2686 return;
2687 }
2688
2689 directory = dptr_path(sconn, dptr_num);
2690
2691 /* Get the wildcard mask from the dptr */
2692 if((p = dptr_wcard(sconn, dptr_num))== NULL) {
2693 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2694 reply_nterror(req, STATUS_NO_MORE_FILES);
2695 return;
2696 }
2697
2698 mask = p;
2699
2700 /* Get the attr mask from the dptr */
2701 dirtype = dptr_attr(sconn, dptr_num);
2702
2703 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2704 dptr_num, mask, dirtype,
2705 (long)dirptr,
2706 dptr_TellDir(dirptr)));
2707
2708 /* Initialize per TRANS2_FIND_NEXT operation data */
2709 dptr_init_search_op(dirptr);
2710
2711 /* We don't need to check for VOL here as this is returned by
2712 a different TRANS2 call. */
2713
2714 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2715 directory,lp_dontdescend(SNUM(conn))));
2716 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2717 dont_descend = True;
2718
2719 p = pdata;
2720 space_remaining = max_data_bytes;
2721 out_of_space = False;
2722
2723 /*
2724 * Seek to the correct position. We no longer use the resume key but
2725 * depend on the last file name instead.
2726 */
2727
2728 if(!continue_bit && resume_name && *resume_name) {
2729 SMB_STRUCT_STAT st;
2730
2731 long current_pos = 0;
2732 /*
2733 * Remember, name_to_8_3 is called by
2734 * get_lanman2_dir_entry(), so the resume name
2735 * could be mangled. Ensure we check the unmangled name.
2736 */
2737
2738 if (mangle_is_mangled(resume_name, conn->params)) {
2739 char *new_resume_name = NULL;
2740 mangle_lookup_name_from_8_3(ctx,
2741 resume_name,
2742 &new_resume_name,
2743 conn->params);
2744 if (new_resume_name) {
2745 resume_name = new_resume_name;
2746 }
2747 }
2748
2749 /*
2750 * Fix for NT redirector problem triggered by resume key indexes
2751 * changing between directory scans. We now return a resume key of 0
2752 * and instead look for the filename to continue from (also given
2753 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2754 * findfirst/findnext (as is usual) then the directory pointer
2755 * should already be at the correct place.
2756 */
2757
2758 finished = !dptr_SearchDir(dirptr, resume_name, &current_pos, &st);
2759 } /* end if resume_name && !continue_bit */
2760
2761 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2762 bool got_exact_match = False;
2763
2764 /* this is a heuristic to avoid seeking the dirptr except when
2765 absolutely necessary. It allows for a filename of about 40 chars */
2766 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2767 out_of_space = True;
2768 finished = False;
2769 } else {
2770 finished = !get_lanman2_dir_entry(ctx,
2771 conn,
2772 dirptr,
2773 req->flags2,
2774 mask,dirtype,info_level,
2775 requires_resume_key,dont_descend,
2776 ask_sharemode,
2777 &p,pdata,data_end,
2778 space_remaining, &out_of_space,
2779 &got_exact_match,
2780 &last_entry_off, ea_list);
2781 }
2782
2783 if (finished && out_of_space)
2784 finished = False;
2785
2786 if (!finished && !out_of_space)
2787 numentries++;
2788
2789 /*
2790 * As an optimisation if we know we aren't looking
2791 * for a wildcard name (ie. the name matches the wildcard exactly)
2792 * then we can finish on any (first) match.
2793 * This speeds up large directory searches. JRA.
2794 */
2795
2796 if(got_exact_match)
2797 finished = True;
2798
2799 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2800 }
2801
2802 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2803 smb_fn_name(req->cmd),
2804 mask, directory, dirtype, numentries ) );
2805
2806 /* Check if we can close the dirptr */
2807 if(close_after_request || (finished && close_if_end)) {
2808 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2809 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
2810 }
2811
2812 /* Set up the return parameter block */
2813 SSVAL(params,0,numentries);
2814 SSVAL(params,2,finished);
2815 SSVAL(params,4,0); /* Never an EA error */
2816 SSVAL(params,6,last_entry_off);
2817
2818 send_trans2_replies(conn, req, params, 8, pdata, PTR_DIFF(p,pdata),
2819 max_data_bytes);
2820
2821 return;
2822 }
2823
2824 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2825 {
2826 E_md4hash(lp_servicename(SNUM(conn)),objid);
2827 return objid;
2828 }
2829
2830 static void samba_extended_info_version(struct smb_extended_info *extended_info)
2831 {
2832 SMB_ASSERT(extended_info != NULL);
2833
2834 extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
2835 extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
2836 | ((SAMBA_VERSION_MINOR & 0xff) << 16)
2837 | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
2838 #ifdef SAMBA_VERSION_REVISION
2839 extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
2840 #endif
2841 extended_info->samba_subversion = 0;
2842 #ifdef SAMBA_VERSION_RC_RELEASE
2843 extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
2844 #else
2845 #ifdef SAMBA_VERSION_PRE_RELEASE
2846 extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
2847 #endif
2848 #endif
2849 #ifdef SAMBA_VERSION_VENDOR_PATCH
2850 extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
2851 #endif
2852 extended_info->samba_gitcommitdate = 0;
2853 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2854 unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_GIT_COMMIT_TIME);
2855 #endif
2856
2857 memset(extended_info->samba_version_string, 0,
2858 sizeof(extended_info->samba_version_string));
2859
2860 snprintf (extended_info->samba_version_string,
2861 sizeof(extended_info->samba_version_string),
2862 "%s", samba_version_string());
2863 }
2864
2865 NTSTATUS smbd_do_qfsinfo(connection_struct *conn,
2866 TALLOC_CTX *mem_ctx,
2867 uint16_t info_level,
2868 uint16_t flags2,
2869 unsigned int max_data_bytes,
2870 char **ppdata,
2871 int *ret_data_len)
2872 {
2873 char *pdata, *end_data;
2874 int data_len = 0, len;
2875 const char *vname = volume_label(SNUM(conn));
2876 int snum = SNUM(conn);
2877 char *fstype = lp_fstype(SNUM(conn));
2878 uint32 additional_flags = 0;
2879 struct smb_filename smb_fname_dot;
2880 SMB_STRUCT_STAT st;
2881
2882 if (IS_IPC(conn)) {
2883 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2884 DEBUG(0,("smbd_do_qfsinfo: not an allowed "
2885 "info level (0x%x) on IPC$.\n",
2886 (unsigned int)info_level));
2887 return NT_STATUS_ACCESS_DENIED;
2888 }
2889 }
2890
2891 DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
2892
2893 ZERO_STRUCT(smb_fname_dot);
2894 smb_fname_dot.base_name = discard_const_p(char, ".");
2895
2896 if(SMB_VFS_STAT(conn, &smb_fname_dot) != 0) {
2897 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
2898 return map_nt_error_from_unix(errno);
2899 }
2900
2901 st = smb_fname_dot.st;
2902
2903 *ppdata = (char *)SMB_REALLOC(
2904 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2905 if (*ppdata == NULL) {
2906 return NT_STATUS_NO_MEMORY;
2907 }
2908
2909 pdata = *ppdata;
2910 memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2911 end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2912
2913 switch (info_level) {
2914 case SMB_INFO_ALLOCATION:
2915 {
2916 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2917 data_len = 18;
2918 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2919 return map_nt_error_from_unix(errno);
2920 }
2921
2922 block_size = lp_block_size(snum);
2923 if (bsize < block_size) {
2924 uint64_t factor = block_size/bsize;
2925 bsize = block_size;
2926 dsize /= factor;
2927 dfree /= factor;
2928 }
2929 if (bsize > block_size) {
2930 uint64_t factor = bsize/block_size;
2931 bsize = block_size;
2932 dsize *= factor;
2933 dfree *= factor;
2934 }
2935 bytes_per_sector = 512;
2936 sectors_per_unit = bsize/bytes_per_sector;
2937
2938 DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2939 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2940 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2941
2942 SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
2943 SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2944 SIVAL(pdata,l1_cUnit,dsize);
2945 SIVAL(pdata,l1_cUnitAvail,dfree);
2946 SSVAL(pdata,l1_cbSector,bytes_per_sector);
2947 break;
2948 }
2949
2950 case SMB_INFO_VOLUME:
2951 /* Return volume name */
2952 /*
2953 * Add volume serial number - hash of a combination of
2954 * the called hostname and the service name.
2955 */
2956 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2957 /*
2958 * Win2k3 and previous mess this up by sending a name length
2959 * one byte short. I believe only older clients (OS/2 Win9x) use
2960 * this call so try fixing this by adding a terminating null to
2961 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2962 */
2963 len = srvstr_push(
2964 pdata, flags2,
2965 pdata+l2_vol_szVolLabel, vname,
2966 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
2967 STR_NOALIGN|STR_TERMINATE);
2968 SCVAL(pdata,l2_vol_cch,len);
2969 data_len = l2_vol_szVolLabel + len;
2970 DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %d, name = %s\n",
2971 (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
2972 len, vname));
2973 break;
2974
2975 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2976 case SMB_FS_ATTRIBUTE_INFORMATION:
2977
2978 additional_flags = 0;
2979 #if defined(HAVE_SYS_QUOTAS)
2980 additional_flags |= FILE_VOLUME_QUOTAS;
2981 #endif
2982
2983 if(lp_nt_acl_support(SNUM(conn))) {
2984 additional_flags |= FILE_PERSISTENT_ACLS;
2985 }
2986
2987 /* Capabilities are filled in at connection time through STATVFS call */
2988 additional_flags |= conn->fs_capabilities;
2989 additional_flags |= lp_parm_int(conn->params->service,
2990 "share", "fake_fscaps",
2991 0);
2992
2993 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2994 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
2995 additional_flags); /* FS ATTRIBUTES */
2996
2997 SIVAL(pdata,4,255); /* Max filename component length */
2998 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2999 and will think we can't do long filenames */
3000 len = srvstr_push(pdata, flags2, pdata+12, fstype,
3001 PTR_DIFF(end_data, pdata+12),
3002 STR_UNICODE);
3003 SIVAL(pdata,8,len);
3004 data_len = 12 + len;
3005 break;
3006
3007 case SMB_QUERY_FS_LABEL_INFO:
3008 case SMB_FS_LABEL_INFORMATION:
3009 len = srvstr_push(pdata, flags2, pdata+4, vname,
3010 PTR_DIFF(end_data, pdata+4), 0);
3011 data_len = 4 + len;
3012 SIVAL(pdata,0,len);
3013 break;
3014
3015 case SMB_QUERY_FS_VOLUME_INFO:
3016 case SMB_FS_VOLUME_INFORMATION:
3017
3018 /*
3019 * Add volume serial number - hash of a combination of
3020 * the called hostname and the service name.
3021 */
3022 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
3023 (str_checksum(get_local_machine_name())<<16));
3024
3025 /* Max label len is 32 characters. */
3026 len = srvstr_push(pdata, flags2, pdata+18, vname,
3027 PTR_DIFF(end_data, pdata+18),
3028 STR_UNICODE);
3029 SIVAL(pdata,12,len);
3030 data_len = 18+len;
3031
3032 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3033 (int)strlen(vname),vname, lp_servicename(snum)));
3034 break;
3035
3036 case SMB_QUERY_FS_SIZE_INFO:
3037 case SMB_FS_SIZE_INFORMATION:
3038 {
3039 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3040 data_len = 24;
3041 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3042 return map_nt_error_from_unix(errno);
3043 }
3044 block_size = lp_block_size(snum);
3045 if (bsize < block_size) {
3046 uint64_t factor = block_size/bsize;
3047 bsize = block_size;
3048 dsize /= factor;
3049 dfree /= factor;
3050 }
3051 if (bsize > block_size) {
3052 uint64_t factor = bsize/block_size;
3053 bsize = block_size;
3054 dsize *= factor;
3055 dfree *= factor;
3056 }
3057 bytes_per_sector = 512;
3058 sectors_per_unit = bsize/bytes_per_sector;
3059 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3060 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3061 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3062 SBIG_UINT(pdata,0,dsize);
3063 SBIG_UINT(pdata,8,dfree);
3064 SIVAL(pdata,16,sectors_per_unit);
3065 SIVAL(pdata,20,bytes_per_sector);
3066 break;
3067 }
3068
3069 case SMB_FS_FULL_SIZE_INFORMATION:
3070 {
3071 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3072 data_len = 32;
3073 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3074 return map_nt_error_from_unix(errno);
3075 }
3076 block_size = lp_block_size(snum);
3077 if (bsize < block_size) {
3078 uint64_t factor = block_size/bsize;
3079 bsize = block_size;
3080 dsize /= factor;
3081 dfree /= factor;
3082 }
3083 if (bsize > block_size) {
3084 uint64_t factor = bsize/block_size;
3085 bsize = block_size;
3086 dsize *= factor;
3087 dfree *= factor;
3088 }
3089 bytes_per_sector = 512;
3090 sectors_per_unit = bsize/bytes_per_sector;
3091 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3092 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3093 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3094 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3095 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3096 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3097 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3098 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3099 break;
3100 }
3101
3102 case SMB_QUERY_FS_DEVICE_INFO:
3103 case SMB_FS_DEVICE_INFORMATION:
3104 data_len = 8;
3105 SIVAL(pdata,0,0); /* dev type */
3106 SIVAL(pdata,4,0); /* characteristics */
3107 break;
3108
3109 #ifdef HAVE_SYS_QUOTAS
3110 case SMB_FS_QUOTA_INFORMATION:
3111 /*
3112 * what we have to send --metze:
3113 *
3114 * Unknown1: 24 NULL bytes
3115 * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3116 * Hard Quota Limit: 8 bytes seems like uint64_t or so
3117 * Quota Flags: 2 byte :
3118 * Unknown3: 6 NULL bytes
3119 *
3120 * 48 bytes total
3121 *
3122 * details for Quota Flags:
3123 *
3124 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3125 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
3126 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3127 * 0x0001 Enable Quotas: enable quota for this fs
3128 *
3129 */
3130 {
3131 /* we need to fake up a fsp here,
3132 * because its not send in this call
3133 */
3134 files_struct fsp;
3135 SMB_NTQUOTA_STRUCT quotas;
3136
3137 ZERO_STRUCT(fsp);
3138 ZERO_STRUCT(quotas);
3139
3140 fsp.conn = conn;
3141 fsp.fnum = -1;
3142
3143 /* access check */
3144 if (conn->server_info->utok.uid != sec_initial_uid()) {
3145 DEBUG(0,("set_user_quota: access_denied "
3146 "service [%s] user [%s]\n",
3147 lp_servicename(SNUM(conn)),
3148 conn->server_info->unix_name));
3149 return NT_STATUS_ACCESS_DENIED;
3150 }
3151
3152 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3153 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3154 return map_nt_error_from_unix(errno);
3155 }
3156
3157 data_len = 48;
3158
3159 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3160 lp_servicename(SNUM(conn))));
3161
3162 /* Unknown1 24 NULL bytes*/
3163 SBIG_UINT(pdata,0,(uint64_t)0);
3164 SBIG_UINT(pdata,8,(uint64_t)0);
3165 SBIG_UINT(pdata,16,(uint64_t)0);
3166
3167 /* Default Soft Quota 8 bytes */
3168 SBIG_UINT(pdata,24,quotas.softlim);
3169
3170 /* Default Hard Quota 8 bytes */
3171 SBIG_UINT(pdata,32,quotas.hardlim);
3172
3173 /* Quota flag 2 bytes */
3174 SSVAL(pdata,40,quotas.qflags);
3175
3176 /* Unknown3 6 NULL bytes */
3177 SSVAL(pdata,42,0);
3178 SIVAL(pdata,44,0);
3179
3180 break;
3181 }
3182 #endif /* HAVE_SYS_QUOTAS */
3183 case SMB_FS_OBJECTID_INFORMATION:
3184 {
3185 unsigned char objid[16];
3186 struct smb_extended_info extended_info;
3187 memcpy(pdata,create_volume_objectid(conn, objid),16);
3188 samba_extended_info_version (&extended_info);
3189 SIVAL(pdata,16,extended_info.samba_magic);
3190 SIVAL(pdata,20,extended_info.samba_version);
3191 SIVAL(pdata,24,extended_info.samba_subversion);
3192 SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3193 memcpy(pdata+36,extended_info.samba_version_string,28);
3194 data_len = 64;
3195 break;
3196 }
3197
3198 /*
3199 * Query the version and capabilities of the CIFS UNIX extensions
3200 * in use.
3201 */
3202
3203 case SMB_QUERY_CIFS_UNIX_INFO:
3204 {
3205 bool large_write = lp_min_receive_file_size() &&
3206 !srv_is_signing_active(smbd_server_conn);
3207 bool large_read = !srv_is_signing_active(smbd_server_conn);
3208 int encrypt_caps = 0;
3209
3210 if (!lp_unix_extensions()) {
3211 return NT_STATUS_INVALID_LEVEL;
3212 }
3213
3214 switch (conn->encrypt_level) {
3215 case 0:
3216 encrypt_caps = 0;
3217 break;
3218 case 1:
3219 case Auto:
3220 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3221 break;
3222 case Required:
3223 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3224 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3225 large_write = false;
3226 large_read = false;
3227 break;
3228 }
3229
3230 data_len = 12;
3231 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3232 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3233
3234 /* We have POSIX ACLs, pathname, encryption,
3235 * large read/write, and locking capability. */
3236
3237 SBIG_UINT(pdata,4,((uint64_t)(
3238 CIFS_UNIX_POSIX_ACLS_CAP|
3239 CIFS_UNIX_POSIX_PATHNAMES_CAP|
3240 CIFS_UNIX_FCNTL_LOCKS_CAP|
3241 CIFS_UNIX_EXTATTR_CAP|
3242 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3243 encrypt_caps|
3244 (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3245 (large_write ?
3246 CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3247 break;
3248 }
3249
3250 case SMB_QUERY_POSIX_FS_INFO:
3251 {
3252 int rc;
3253 vfs_statvfs_struct svfs;
3254
3255 if (!lp_unix_extensions()) {
3256 return NT_STATUS_INVALID_LEVEL;
3257 }
3258
3259 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
3260
3261 if (!rc) {
3262 data_len = 56;
3263 SIVAL(pdata,0,svfs.OptimalTransferSize);
3264 SIVAL(pdata,4,svfs.BlockSize);
3265 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3266 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3267 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3268 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3269 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3270 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3271 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3272 #ifdef EOPNOTSUPP
3273 } else if (rc == EOPNOTSUPP) {
3274 return NT_STATUS_INVALID_LEVEL;
3275 #endif /* EOPNOTSUPP */
3276 } else {
3277 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3278 return NT_STATUS_DOS(ERRSRV, ERRerror);
3279 }
3280 break;
3281 }
3282
3283 case SMB_QUERY_POSIX_WHOAMI:
3284 {
3285 uint32_t flags = 0;
3286 uint32_t sid_bytes;
3287 int i;
3288
3289 if (!lp_unix_extensions()) {
3290 return NT_STATUS_INVALID_LEVEL;
3291 }
3292
3293 if (max_data_bytes < 40) {
3294 return NT_STATUS_BUFFER_TOO_SMALL;
3295 }
3296
3297 /* We ARE guest if global_sid_Builtin_Guests is
3298 * in our list of SIDs.
3299 */
3300 if (nt_token_check_sid(&global_sid_Builtin_Guests,
3301 conn->server_info->ptok)) {
3302 flags |= SMB_WHOAMI_GUEST;
3303 }
3304
3305 /* We are NOT guest if global_sid_Authenticated_Users
3306 * is in our list of SIDs.
3307 */
3308 if (nt_token_check_sid(&global_sid_Authenticated_Users,
3309 conn->server_info->ptok)) {
3310 flags &= ~SMB_WHOAMI_GUEST;
3311 }
3312
3313 /* NOTE: 8 bytes for UID/GID, irrespective of native
3314 * platform size. This matches
3315 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3316 */
3317 data_len = 4 /* flags */
3318 + 4 /* flag mask */
3319 + 8 /* uid */
3320 + 8 /* gid */
3321 + 4 /* ngroups */
3322 + 4 /* num_sids */
3323 + 4 /* SID bytes */
3324 + 4 /* pad/reserved */
3325 + (conn->server_info->utok.ngroups * 8)
3326 /* groups list */
3327 + (conn->server_info->ptok->num_sids *
3328 SID_MAX_SIZE)
3329 /* SID list */;
3330
3331 SIVAL(pdata, 0, flags);
3332 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3333 SBIG_UINT(pdata, 8,
3334 (uint64_t)conn->server_info->utok.uid);
3335 SBIG_UINT(pdata, 16,
3336 (uint64_t)conn->server_info->utok.gid);
3337
3338
3339 if (data_len >= max_data_bytes) {
3340 /* Potential overflow, skip the GIDs and SIDs. */
3341
3342 SIVAL(pdata, 24, 0); /* num_groups */
3343 SIVAL(pdata, 28, 0); /* num_sids */
3344 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3345 SIVAL(pdata, 36, 0); /* reserved */
3346
3347 data_len = 40;
3348 break;
3349 }
3350
3351 SIVAL(pdata, 24, conn->server_info->utok.ngroups);
3352 SIVAL(pdata, 28, conn->server_info->num_sids);
3353
3354 /* We walk the SID list twice, but this call is fairly
3355 * infrequent, and I don't expect that it's performance
3356 * sensitive -- jpeach
3357 */
3358 for (i = 0, sid_bytes = 0;
3359 i < conn->server_info->ptok->num_sids; ++i) {
3360 sid_bytes += ndr_size_dom_sid(
3361 &conn->server_info->ptok->user_sids[i],
3362 NULL,
3363 0);
3364 }
3365
3366 /* SID list byte count */
3367 SIVAL(pdata, 32, sid_bytes);
3368
3369 /* 4 bytes pad/reserved - must be zero */
3370 SIVAL(pdata, 36, 0);
3371 data_len = 40;
3372
3373 /* GID list */
3374 for (i = 0; i < conn->server_info->utok.ngroups; ++i) {
3375 SBIG_UINT(pdata, data_len,
3376 (uint64_t)conn->server_info->utok.groups[i]);
3377 data_len += 8;
3378 }
3379
3380 /* SID list */
3381 for (i = 0;
3382 i < conn->server_info->ptok->num_sids; ++i) {
3383 int sid_len = ndr_size_dom_sid(
3384 &conn->server_info->ptok->user_sids[i],
3385 NULL,
3386 0);
3387
3388 sid_linearize(pdata + data_len, sid_len,
3389 &conn->server_info->ptok->user_sids[i]);
3390 data_len += sid_len;
3391 }
3392
3393 break;
3394 }
3395
3396 case SMB_MAC_QUERY_FS_INFO:
3397 /*
3398 * Thursby MAC extension... ONLY on NTFS filesystems
3399 * once we do streams then we don't need this
3400 */
3401 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
3402 data_len = 88;
3403 SIVAL(pdata,84,0x100); /* Don't support mac... */
3404 break;
3405 }
3406 /* drop through */
3407 default:
3408 return NT_STATUS_INVALID_LEVEL;
3409 }
3410
3411 *ret_data_len = data_len;
3412 return NT_STATUS_OK;
3413 }
3414
3415 /****************************************************************************
3416 Reply to a TRANS2_QFSINFO (query filesystem info).
3417 ****************************************************************************/
3418
3419 static void call_trans2qfsinfo(connection_struct *conn,
3420 struct smb_request *req,
3421 char **pparams, int total_params,
3422 char **ppdata, int total_data,
3423 unsigned int max_data_bytes)
3424 {
3425 char *params = *pparams;
3426 uint16_t info_level;
3427 int data_len = 0;
3428 NTSTATUS status;
3429
3430 if (total_params < 2) {
3431 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3432 return;
3433 }
3434
3435 info_level = SVAL(params,0);
3436
3437 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3438 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3439 DEBUG(0,("call_trans2qfsinfo: encryption required "
3440 "and info level 0x%x sent.\n",
3441 (unsigned int)info_level));
3442 exit_server_cleanly("encryption required "
3443 "on connection");
3444 return;
3445 }
3446 }
3447
3448 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
3449
3450 status = smbd_do_qfsinfo(conn, req,
3451 info_level,
3452 req->flags2,
3453 max_data_bytes,
3454 ppdata, &data_len);
3455 if (!NT_STATUS_IS_OK(status)) {
3456 reply_nterror(req, status);
3457 return;
3458 }
3459
3460 send_trans2_replies(conn, req, params, 0, *ppdata, data_len,
3461 max_data_bytes);
3462
3463 DEBUG( 4, ( "%s info_level = %d\n",
3464 smb_fn_name(req->cmd), info_level) );
3465
3466 return;
3467 }
3468
3469 /****************************************************************************
3470 Reply to a TRANS2_SETFSINFO (set filesystem info).
3471 ****************************************************************************/
3472
3473 static void call_trans2setfsinfo(connection_struct *conn,
3474 struct smb_request *req,
3475 char **pparams, int total_params,
3476 char **ppdata, int total_data,
3477 unsigned int max_data_bytes)
3478 {
3479 char *pdata = *ppdata;
3480 char *params = *pparams;
3481 uint16 info_level;
3482
3483 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
3484
3485 /* */
3486 if (total_params < 4) {
3487 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3488 total_params));
3489 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3490 return;
3491 }
3492
3493 info_level = SVAL(params,2);
3494
3495 if (IS_IPC(conn)) {
3496 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
3497 info_level != SMB_SET_CIFS_UNIX_INFO) {
3498 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3499 "info level (0x%x) on IPC$.\n",
3500 (unsigned int)info_level));
3501 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3502 return;
3503 }
3504 }
3505
3506 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3507 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
3508 DEBUG(0,("call_trans2setfsinfo: encryption required "
3509 "and info level 0x%x sent.\n",
3510 (unsigned int)info_level));
3511 exit_server_cleanly("encryption required "
3512 "on connection");
3513 return;
3514 }
3515 }
3516
3517 switch(info_level) {
3518 case SMB_SET_CIFS_UNIX_INFO:
3519 {
3520 uint16 client_unix_major;
3521 uint16 client_unix_minor;
3522 uint32 client_unix_cap_low;
3523 uint32 client_unix_cap_high;
3524
3525 if (!lp_unix_extensions()) {
3526 reply_nterror(req,
3527 NT_STATUS_INVALID_LEVEL);
3528 return;
3529 }
3530
3531 /* There should be 12 bytes of capabilities set. */
3532 if (total_data < 8) {
3533 reply_nterror(
3534 req,
3535 NT_STATUS_INVALID_PARAMETER);
3536 return;
3537 }
3538 client_unix_major = SVAL(pdata,0);
3539 client_unix_minor = SVAL(pdata,2);
3540 client_unix_cap_low = IVAL(pdata,4);
3541 client_unix_cap_high = IVAL(pdata,8);
3542 /* Just print these values for now. */
3543 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
3544 cap_low = 0x%x, cap_high = 0x%x\n",
3545 (unsigned int)client_unix_major,
3546 (unsigned int)client_unix_minor,
3547 (unsigned int)client_unix_cap_low,
3548 (unsigned int)client_unix_cap_high ));
3549
3550 /* Here is where we must switch to posix pathname processing... */
3551 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3552 lp_set_posix_pathnames();
3553 mangle_change_to_posix();
3554 }
3555
3556 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
3557 !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
3558 /* Client that knows how to do posix locks,
3559 * but not posix open/mkdir operations. Set a
3560 * default type for read/write checks. */
3561
3562 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
3563
3564 }
3565 break;
3566 }
3567
3568 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
3569 {
3570 NTSTATUS status;
3571 size_t param_len = 0;
3572 size_t data_len = total_data;
3573
3574 if (!lp_unix_extensions()) {
3575 reply_nterror(
3576 req,
3577 NT_STATUS_INVALID_LEVEL);
3578 return;
3579 }
3580
3581 if (lp_smb_encrypt(SNUM(conn)) == false) {
3582 reply_nterror(
3583 req,
3584 NT_STATUS_NOT_SUPPORTED);
3585 return;
3586 }
3587
3588 DEBUG( 4,("call_trans2setfsinfo: "
3589 "request transport encryption.\n"));
3590
3591 status = srv_request_encryption_setup(conn,
3592 (unsigned char **)ppdata,
3593 &data_len,
3594 (unsigned char **)pparams,
3595 &param_len);
3596
3597 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
3598 !NT_STATUS_IS_OK(status)) {
3599 reply_nterror(req, status);
3600 return;
3601 }
3602
3603 send_trans2_replies(conn, req,
3604 *pparams,
3605 param_len,
3606 *ppdata,
3607 data_len,
3608 max_data_bytes);
3609
3610 if (NT_STATUS_IS_OK(status)) {
3611 /* Server-side transport
3612 * encryption is now *on*. */
3613 status = srv_encryption_start(conn);
3614 if (!NT_STATUS_IS_OK(status)) {
3615 exit_server_cleanly(
3616 "Failure in setting "
3617 "up encrypted transport");
3618 }
3619 }
3620 return;
3621 }
3622
3623 case SMB_FS_QUOTA_INFORMATION:
3624 {
3625 files_struct *fsp = NULL;
3626 SMB_NTQUOTA_STRUCT quotas;
3627
3628 ZERO_STRUCT(quotas);
3629
3630 /* access check */
3631 if ((conn->server_info->utok.uid != sec_initial_uid())
3632 ||!CAN_WRITE(conn)) {
3633 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3634 lp_servicename(SNUM(conn)),
3635 conn->server_info->unix_name));
3636 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3637 return;
3638 }
3639
3640 /* note: normaly there're 48 bytes,
3641 * but we didn't use the last 6 bytes for now
3642 * --metze
3643 */
3644 fsp = file_fsp(req, SVAL(params,0));
3645
3646 if (!check_fsp_ntquota_handle(conn, req,
3647 fsp)) {
3648 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3649 reply_nterror(
3650 req, NT_STATUS_INVALID_HANDLE);
3651 return;
3652 }
3653
3654 if (total_data < 42) {
3655 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3656 total_data));
3657 reply_nterror(
3658 req,
3659 NT_STATUS_INVALID_PARAMETER);
3660 return;
3661 }
3662
3663 /* unknown_1 24 NULL bytes in pdata*/
3664
3665 /* the soft quotas 8 bytes (uint64_t)*/
3666 quotas.softlim = (uint64_t)IVAL(pdata,24);
3667 #ifdef LARGE_SMB_OFF_T
3668 quotas.softlim |= (((uint64_t)IVAL(pdata,28)) << 32);
3669 #else /* LARGE_SMB_OFF_T */
3670 if ((IVAL(pdata,28) != 0)&&
3671 ((quotas.softlim != 0xFFFFFFFF)||
3672 (IVAL(pdata,28)!=0xFFFFFFFF))) {
3673 /* more than 32 bits? */
3674 reply_nterror(
3675 req,
3676 NT_STATUS_INVALID_PARAMETER);
3677 return;
3678 }
3679 #endif /* LARGE_SMB_OFF_T */
3680
3681 /* the hard quotas 8 bytes (uint64_t)*/
3682 quotas.hardlim = (uint64_t)IVAL(pdata,32);
3683 #ifdef LARGE_SMB_OFF_T
3684 quotas.hardlim |= (((uint64_t)IVAL(pdata,36)) << 32);
3685 #else /* LARGE_SMB_OFF_T */
3686 if ((IVAL(pdata,36) != 0)&&
3687 ((quotas.hardlim != 0xFFFFFFFF)||
3688 (IVAL(pdata,36)!=0xFFFFFFFF))) {
3689 /* more than 32 bits? */
3690 reply_nterror(
3691 req,
3692 NT_STATUS_INVALID_PARAMETER);
3693 return;
3694 }
3695 #endif /* LARGE_SMB_OFF_T */
3696
3697 /* quota_flags 2 bytes **/
3698 quotas.qflags = SVAL(pdata,40);
3699
3700 /* unknown_2 6 NULL bytes follow*/
3701
3702 /* now set the quotas */
3703 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3704 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3705 reply_nterror(req, map_nt_error_from_unix(errno));
3706 return;
3707 }
3708
3709 break;
3710 }
3711 default:
3712 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3713 info_level));
3714 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3715 return;
3716 break;
3717 }
3718
3719 /*
3720 * sending this reply works fine,
3721 * but I'm not sure it's the same
3722 * like windows do...
3723 * --metze
3724 */
3725 reply_outbuf(req, 10, 0);
3726 }
3727
3728 #if defined(HAVE_POSIX_ACLS)
3729 /****************************************************************************
3730 Utility function to count the number of entries in a POSIX acl.
3731 ****************************************************************************/
3732
3733 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
3734 {
3735 unsigned int ace_count = 0;
3736 int entry_id = SMB_ACL_FIRST_ENTRY;
3737 SMB_ACL_ENTRY_T entry;
3738
3739 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3740 /* get_next... */
3741 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3742 entry_id = SMB_ACL_NEXT_ENTRY;
3743 }
3744 ace_count++;
3745 }
3746 return ace_count;
3747 }
3748
3749 /****************************************************************************
3750 Utility function to marshall a POSIX acl into wire format.
3751 ****************************************************************************/
3752
3753 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
3754 {
3755 int entry_id = SMB_ACL_FIRST_ENTRY;
3756 SMB_ACL_ENTRY_T entry;
3757
3758 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3759 SMB_ACL_TAG_T tagtype;
3760 SMB_ACL_PERMSET_T permset;
3761 unsigned char perms = 0;
3762 unsigned int own_grp;
3763
3764 /* get_next... */
3765 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3766 entry_id = SMB_ACL_NEXT_ENTRY;
3767 }
3768
3769 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
3770 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3771 return False;
3772 }
3773
3774 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
3775 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3776 return False;
3777 }
3778
3779 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
3780 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
3781 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
3782
3783 SCVAL(pdata,1,perms);
3784
3785 switch (tagtype) {
3786 case SMB_ACL_USER_OBJ:
3787 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
3788 own_grp = (unsigned int)pst->st_ex_uid;
3789 SIVAL(pdata,2,own_grp);
3790 SIVAL(pdata,6,0);
3791 break;
3792 case SMB_ACL_USER:
3793 {
3794 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3795 if (!puid) {
3796 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3797 return False;
3798 }
3799 own_grp = (unsigned int)*puid;
3800 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3801 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3802 SIVAL(pdata,2,own_grp);
3803 SIVAL(pdata,6,0);
3804 break;
3805 }
3806 case SMB_ACL_GROUP_OBJ:
3807 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3808 own_grp = (unsigned int)pst->st_ex_gid;
3809 SIVAL(pdata,2,own_grp);
3810 SIVAL(pdata,6,0);
3811 break;
3812 case SMB_ACL_GROUP:
3813 {
3814 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3815 if (!pgid) {
3816 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3817 return False;
3818 }
3819 own_grp = (unsigned int)*pgid;
3820 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3821 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3822 SIVAL(pdata,2,own_grp);
3823 SIVAL(pdata,6,0);
3824 break;
3825 }
3826 case SMB_ACL_MASK:
3827 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
3828 SIVAL(pdata,2,0xFFFFFFFF);
3829 SIVAL(pdata,6,0xFFFFFFFF);
3830 break;
3831 case SMB_ACL_OTHER:
3832 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
3833 SIVAL(pdata,2,0xFFFFFFFF);
3834 SIVAL(pdata,6,0xFFFFFFFF);
3835 break;
3836 default:
3837 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3838 return False;
3839 }
3840 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
3841 }
3842
3843 return True;
3844 }
3845 #endif
3846
3847 /****************************************************************************
3848 Store the FILE_UNIX_BASIC info.
3849 ****************************************************************************/
3850
3851 static char *store_file_unix_basic(connection_struct *conn,
3852 char *pdata,
3853 files_struct *fsp,
3854 const SMB_STRUCT_STAT *psbuf)
3855 {
3856 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3857 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
3858
3859 SOFF_T(pdata,0,get_file_size_stat(psbuf)); /* File size 64 Bit */
3860 pdata += 8;
3861
3862 SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3863 pdata += 8;
3864
3865 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime); /* Change Time 64 Bit */
3866 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime); /* Last access time 64 Bit */
3867 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata+16, psbuf->st_ex_mtime); /* Last modification time 64 Bit */
3868 pdata += 24;
3869
3870 SIVAL(pdata,0,psbuf->st_ex_uid); /* user id for the owner */
3871 SIVAL(pdata,4,0);
3872 pdata += 8;
3873
3874 SIVAL(pdata,0,psbuf->st_ex_gid); /* group id of owner */
3875 SIVAL(pdata,4,0);
3876 pdata += 8;
3877
3878 SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
3879 pdata += 4;
3880
3881 SIVAL(pdata,0,unix_dev_major(psbuf->st_ex_rdev)); /* Major device number if type is device */
3882 SIVAL(pdata,4,0);
3883 pdata += 8;
3884
3885 SIVAL(pdata,0,unix_dev_minor(psbuf->st_ex_rdev)); /* Minor device number if type is device */
3886 SIVAL(pdata,4,0);
3887 pdata += 8;
3888
3889 SINO_T_VAL(pdata,0,(SMB_INO_T)psbuf->st_ex_ino); /* inode number */
3890 pdata += 8;
3891
3892 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode)); /* Standard UNIX file permissions */
3893 SIVAL(pdata,4,0);
3894 pdata += 8;
3895
3896 SIVAL(pdata,0,psbuf->st_ex_nlink); /* number of hard links */
3897 SIVAL(pdata,4,0);
3898 pdata += 8;
3899
3900 return pdata;
3901 }
3902
3903 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3904 * the chflags(2) (or equivalent) flags.
3905 *
3906 * XXX: this really should be behind the VFS interface. To do this, we would
3907 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3908 * Each VFS module could then implement its own mapping as appropriate for the
3909 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3910 */
3911 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
3912 info2_flags_map[] =
3913 {
3914 #ifdef UF_NODUMP
3915 { UF_NODUMP, EXT_DO_NOT_BACKUP },
3916 #endif
3917
3918 #ifdef UF_IMMUTABLE
3919 { UF_IMMUTABLE, EXT_IMMUTABLE },
3920 #endif
3921
3922 #ifdef UF_APPEND
3923 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
3924 #endif
3925
3926 #ifdef UF_HIDDEN
3927 { UF_HIDDEN, EXT_HIDDEN },
3928 #endif
3929
3930 /* Do not remove. We need to guarantee that this array has at least one
3931 * entry to build on HP-UX.
3932 */
3933 { 0, 0 }
3934
3935 };
3936
3937 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
3938 uint32 *smb_fflags, uint32 *smb_fmask)
3939 {
3940 int i;
3941
3942 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3943 *smb_fmask |= info2_flags_map[i].smb_fflag;
3944 if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
3945 *smb_fflags |= info2_flags_map[i].smb_fflag;
3946 }
3947 }
3948 }
3949
3950 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
3951 const uint32 smb_fflags,
3952 const uint32 smb_fmask,
3953 int *stat_fflags)
3954 {
3955 uint32 max_fmask = 0;
3956 int i;
3957
3958 *stat_fflags = psbuf->st_ex_flags;
3959
3960 /* For each flags requested in smb_fmask, check the state of the
3961 * corresponding flag in smb_fflags and set or clear the matching
3962 * stat flag.
3963 */
3964
3965 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3966 max_fmask |= info2_flags_map[i].smb_fflag;
3967 if (smb_fmask & info2_flags_map[i].smb_fflag) {
3968 if (smb_fflags & info2_flags_map[i].smb_fflag) {
3969 *stat_fflags |= info2_flags_map[i].stat_fflag;
3970 } else {
3971 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
3972 }
3973 }
3974 }
3975
3976 /* If smb_fmask is asking to set any bits that are not supported by
3977 * our flag mappings, we should fail.
3978 */
3979 if ((smb_fmask & max_fmask) != smb_fmask) {
3980 return False;
3981 }
3982
3983 return True;
3984 }
3985
3986
3987 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3988 * of file flags and birth (create) time.
3989 */
3990 static char *store_file_unix_basic_info2(connection_struct *conn,
3991 char *pdata,
3992 files_struct *fsp,
3993 const SMB_STRUCT_STAT *psbuf)
3994 {
3995 uint32 file_flags = 0;
3996 uint32 flags_mask = 0;
3997
3998 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
3999
4000 /* Create (birth) time 64 bit */
4001 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER,pdata, psbuf->st_ex_btime);
4002 pdata += 8;
4003
4004 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
4005 SIVAL(pdata, 0, file_flags); /* flags */
4006 SIVAL(pdata, 4, flags_mask); /* mask */
4007 pdata += 8;
4008
4009 return pdata;
4010 }
4011
4012 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4013 const struct stream_struct *streams,
4014 char *data,
4015 unsigned int max_data_bytes,
4016 unsigned int *data_size)
4017 {
4018 unsigned int i;
4019 unsigned int ofs = 0;
4020
4021 for (i = 0; i < num_streams && ofs <= max_data_bytes; i++) {
4022 unsigned int next_offset;
4023 size_t namelen;
4024 smb_ucs2_t *namebuf;
4025
4026 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4027 streams[i].name, &namelen) ||
4028 namelen <= 2)
4029 {
4030 return NT_STATUS_INVALID_PARAMETER;
4031 }
4032
4033 /*
4034 * name_buf is now null-terminated, we need to marshall as not
4035 * terminated
4036 */
4037
4038 namelen -= 2;
4039
4040 SIVAL(data, ofs+4, namelen);
4041 SOFF_T(data, ofs+8, streams[i].size);
4042 SOFF_T(data, ofs+16, streams[i].alloc_size);
4043 memcpy(data+ofs+24, namebuf, namelen);
4044 TALLOC_FREE(namebuf);
4045
4046 next_offset = ofs + 24 + namelen;
4047
4048 if (i == num_streams-1) {
4049 SIVAL(data, ofs, 0);
4050 }
4051 else {
4052 unsigned int align = ndr_align_size(next_offset, 8);
4053
4054 memset(data+next_offset, 0, align);
4055 next_offset += align;
4056
4057 SIVAL(data, ofs, next_offset - ofs);
4058 ofs = next_offset;
4059 }
4060
4061 ofs = next_offset;
4062 }
4063
4064 *data_size = ofs;
4065
4066 return NT_STATUS_OK;
4067 }
4068
4069 /****************************************************************************
4070 Reply to a TRANSACT2_QFILEINFO on a PIPE !
4071 ****************************************************************************/
4072
4073 static void call_trans2qpipeinfo(connection_struct *conn,
4074 struct smb_request *req,
4075 unsigned int tran_call,
4076 char **pparams, int total_params,
4077 char **ppdata, int total_data,
4078 unsigned int max_data_bytes)
4079 {
4080 char *params = *pparams;
4081 char *pdata = *ppdata;
4082 unsigned int data_size = 0;
4083 unsigned int param_size = 2;
4084 uint16 info_level;
4085 files_struct *fsp;
4086
4087 if (!params) {
4088 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4089 return;
4090 }
4091
4092 if (total_params < 4) {
4093 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4094 return;
4095 }
4096
4097 fsp = file_fsp(req, SVAL(params,0));
4098 if (!fsp_is_np(fsp)) {
4099 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4100 return;
4101 }
4102
4103 info_level = SVAL(params,2);
4104
4105 *pparams = (char *)SMB_REALLOC(*pparams,2);
4106 if (*pparams == NULL) {
4107 reply_nterror(req, NT_STATUS_NO_MEMORY);
4108 return;
4109 }
4110 params = *pparams;
4111 SSVAL(params,0,0);
4112 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4113 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4114 if (*ppdata == NULL ) {
4115 reply_nterror(req, NT_STATUS_NO_MEMORY);
4116 return;
4117 }
4118 pdata = *ppdata;
4119
4120 switch (info_level) {
4121 case SMB_FILE_STANDARD_INFORMATION:
4122 memset(pdata,0,24);
4123 SOFF_T(pdata,0,4096LL);
4124 SIVAL(pdata,16,1);
4125 SIVAL(pdata,20,1);
4126 data_size = 24;
4127 break;
4128
4129 default:
4130 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4131 return;
4132 }
4133
4134 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
4135 max_data_bytes);
4136
4137 return;
4138 }
4139
4140 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4141 TALLOC_CTX *mem_ctx,
4142 uint16_t info_level,
4143 files_struct *fsp,
4144 struct smb_filename *smb_fname,
4145 bool delete_pending,
4146 struct timespec write_time_ts,
4147 bool ms_dfs_link,
4148 struct ea_list *ea_list,
4149 int lock_data_count,
4150 char *lock_data,
4151 uint16_t flags2,
4152 unsigned int max_data_bytes,
4153 char **ppdata,
4154 unsigned int *pdata_size)
4155 {
4156 char *pdata = *ppdata;
4157 char *dstart, *dend;
4158 unsigned int data_size;
4159 struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4160 time_t create_time, mtime, atime, c_time;
4161 SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4162 char *p;
4163 char *base_name;
4164 char *dos_fname;
4165 int mode;
4166 int nlink;
4167 NTSTATUS status;
4168 uint64_t file_size = 0;
4169 uint64_t pos = 0;
4170 uint64_t allocation_size = 0;
4171 uint64_t file_index = 0;
4172 uint32_t access_mask = 0;
4173
4174 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4175 return NT_STATUS_INVALID_LEVEL;
4176 }
4177
4178 DEBUG(5,("smbd_do_qfilepathinfo: %s (fnum = %d) level=%d max_data=%u\n",
4179 smb_fname_str_dbg(smb_fname), fsp ? fsp->fnum : -1,
4180 info_level, max_data_bytes));
4181
4182 if (ms_dfs_link) {
4183 mode = dos_mode_msdfs(conn, smb_fname);
4184 } else {
4185 mode = dos_mode(conn, smb_fname);
4186 }
4187
4188 nlink = psbuf->st_ex_nlink;
4189
4190 if (nlink && (mode&aDIR)) {
4191 nlink = 1;
4192 }
4193
4194 if ((nlink > 0) && delete_pending) {
4195 nlink -= 1;
4196 }
4197
4198 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4199 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4200 if (*ppdata == NULL) {
4201 return NT_STATUS_NO_MEMORY;
4202 }
4203 pdata = *ppdata;
4204 dstart = pdata;
4205 dend = dstart + data_size - 1;
4206
4207 if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4208 update_stat_ex_mtime(psbuf, write_time_ts);
4209 }
4210
4211 create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4212 mtime_ts = psbuf->st_ex_mtime;
4213 atime_ts = psbuf->st_ex_atime;
4214 ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4215
4216 if (lp_dos_filetime_resolution(SNUM(conn))) {
4217 dos_filetime_timespec(&create_time_ts);
4218 dos_filetime_timespec(&mtime_ts);
4219 dos_filetime_timespec(&atime_ts);
4220 dos_filetime_timespec(&ctime_ts);
4221 }
4222
4223 create_time = convert_timespec_to_time_t(create_time_ts);
4224 mtime = convert_timespec_to_time_t(mtime_ts);
4225 atime = convert_timespec_to_time_t(atime_ts);
4226 c_time = convert_timespec_to_time_t(ctime_ts);
4227
4228 p = strrchr_m(smb_fname->base_name,'/');
4229 if (!p)
4230 base_name = smb_fname->base_name;
4231 else
4232 base_name = p+1;
4233
4234 /* NT expects the name to be in an exact form of the *full*
4235 filename. See the trans2 torture test */
4236 if (ISDOT(base_name)) {
4237 dos_fname = talloc_strdup(mem_ctx, "\\");
4238 if (!dos_fname) {
4239 return NT_STATUS_NO_MEMORY;
4240 }
4241 } else {
4242 dos_fname = talloc_asprintf(mem_ctx,
4243 "\\%s",
4244 smb_fname->base_name);
4245 if (!dos_fname) {
4246 return NT_STATUS_NO_MEMORY;
4247 }
4248 if (is_ntfs_stream_smb_fname(smb_fname)) {
4249 dos_fname = talloc_asprintf(dos_fname, "%s",
4250 smb_fname->stream_name);
4251 if (!dos_fname) {
4252 return NT_STATUS_NO_MEMORY;
4253 }
4254 }
4255
4256 string_replace(dos_fname, '/', '\\');
4257 }
4258
4259 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4260
4261 if (!fsp) {
4262 /* Do we have this path open ? */
4263 files_struct *fsp1;
4264 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4265 fsp1 = file_find_di_first(fileid);
4266 if (fsp1 && fsp1->initial_allocation_size) {
4267 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4268 }
4269 }
4270
4271 if (!(mode & aDIR)) {
4272 file_size = get_file_size_stat(psbuf);
4273 }
4274
4275 if (fsp) {
4276 pos = fsp->fh->position_information;
4277 }
4278
4279 if (fsp) {
4280 access_mask = fsp->access_mask;
4281 } else {
4282 /* GENERIC_EXECUTE mapping from Windows */
4283 access_mask = 0x12019F;
4284 }
4285
4286 /* This should be an index number - looks like
4287 dev/ino to me :-)
4288
4289 I think this causes us to fail the IFSKIT
4290 BasicFileInformationTest. -tpot */
4291 file_index = ((psbuf->st_ex_ino) & UINT32_MAX); /* FileIndexLow */
4292 file_index |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32; /* FileIndexHigh */
4293
4294 switch (info_level) {
4295 case SMB_INFO_STANDARD:
4296 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4297 data_size = 22;
4298 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
4299 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
4300 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
4301 SIVAL(pdata,l1_cbFile,(uint32)file_size);
4302 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
4303 SSVAL(pdata,l1_attrFile,mode);
4304 break;
4305
4306 case SMB_INFO_QUERY_EA_SIZE:
4307 {
4308 unsigned int ea_size =
4309 estimate_ea_size(conn, fsp,
4310 smb_fname->base_name);
4311 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4312 data_size = 26;
4313 srv_put_dos_date2(pdata,0,create_time);
4314 srv_put_dos_date2(pdata,4,atime);
4315 srv_put_dos_date2(pdata,8,mtime); /* write time */
4316 SIVAL(pdata,12,(uint32)file_size);
4317 SIVAL(pdata,16,(uint32)allocation_size);
4318 SSVAL(pdata,20,mode);
4319 SIVAL(pdata,22,ea_size);
4320 break;
4321 }
4322
4323 case SMB_INFO_IS_NAME_VALID:
4324 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4325 if (fsp) {
4326 /* os/2 needs this ? really ?*/
4327 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
4328 }
4329 /* This is only reached for qpathinfo */
4330 data_size = 0;
4331 break;
4332
4333 case SMB_INFO_QUERY_EAS_FROM_LIST:
4334 {
4335 size_t total_ea_len = 0;
4336 struct ea_list *ea_file_list = NULL;
4337
4338 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4339
4340 ea_file_list =
4341 get_ea_list_from_file(mem_ctx, conn, fsp,
4342 smb_fname->base_name,
4343 &total_ea_len);
4344 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
4345
4346 if (!ea_list || (total_ea_len > data_size)) {
4347 data_size = 4;
4348 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4349 break;
4350 }
4351
4352 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4353 break;
4354 }
4355
4356 case SMB_INFO_QUERY_ALL_EAS:
4357 {
4358 /* We have data_size bytes to put EA's into. */
4359 size_t total_ea_len = 0;
4360
4361 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4362
4363 ea_list = get_ea_list_from_file(mem_ctx, conn, fsp,
4364 smb_fname->base_name,
4365 &total_ea_len);
4366 if (!ea_list || (total_ea_len > data_size)) {
4367 data_size = 4;
4368 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4369 break;
4370 }
4371
4372 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4373 break;
4374 }
4375
4376 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
4377 {
4378 /* This is FileFullEaInformation - 0xF which maps to
4379 * 1015 (decimal) in smbd_do_setfilepathinfo. */
4380
4381 /* We have data_size bytes to put EA's into. */
4382 size_t total_ea_len = 0;
4383 struct ea_list *ea_file_list = NULL;
4384
4385 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
4386
4387 /*TODO: add filtering and index handling */
4388
4389 ea_file_list =
4390 get_ea_list_from_file(mem_ctx, conn, fsp,
4391 smb_fname->base_name,
4392 &total_ea_len);
4393 if (!ea_file_list) {
4394 return NT_STATUS_NO_EAS_ON_FILE;
4395 }
4396
4397 status = fill_ea_chained_buffer(mem_ctx,
4398 pdata,
4399 data_size,
4400 &data_size,
4401 conn, ea_file_list);
4402 if (!NT_STATUS_IS_OK(status)) {
4403 return status;
4404 }
4405 break;
4406 }
4407
4408 case SMB_FILE_BASIC_INFORMATION:
4409 case SMB_QUERY_FILE_BASIC_INFO:
4410
4411 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
4412 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4413 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
4414 } else {
4415 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4416 data_size = 40;
4417 SIVAL(pdata,36,0);
4418 }
4419 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4420 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4421 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4422 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4423 SIVAL(pdata,32,mode);
4424
4425 DEBUG(5,("SMB_QFBI - "));
4426 DEBUG(5,("create: %s ", ctime(&create_time)));
4427 DEBUG(5,("access: %s ", ctime(&atime)));
4428 DEBUG(5,("write: %s ", ctime(&mtime)));
4429 DEBUG(5,("change: %s ", ctime(&c_time)));
4430 DEBUG(5,("mode: %x\n", mode));
4431 break;
4432
4433 case SMB_FILE_STANDARD_INFORMATION:
4434 case SMB_QUERY_FILE_STANDARD_INFO:
4435
4436 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4437 data_size = 24;
4438 SOFF_T(pdata,0,allocation_size);
4439 SOFF_T(pdata,8,file_size);
4440 SIVAL(pdata,16,nlink);
4441 SCVAL(pdata,20,delete_pending?1:0);
4442 SCVAL(pdata,21,(mode&aDIR)?1:0);
4443 SSVAL(pdata,22,0); /* Padding. */
4444 break;
4445
4446 case SMB_FILE_EA_INFORMATION:
4447 case SMB_QUERY_FILE_EA_INFO:
4448 {
4449 unsigned int ea_size =
4450 estimate_ea_size(conn, fsp, smb_fname->base_name);
4451 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4452 data_size = 4;
4453 SIVAL(pdata,0,ea_size);
4454 break;
4455 }
4456
4457 /* Get the 8.3 name - used if NT SMB was negotiated. */
4458 case SMB_QUERY_FILE_ALT_NAME_INFO:
4459 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
4460 {
4461 int len;
4462 char mangled_name[13];
4463 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4464 if (!name_to_8_3(base_name,mangled_name,
4465 True,conn->params)) {
4466 return NT_STATUS_NO_MEMORY;
4467 }
4468 len = srvstr_push(dstart, flags2,
4469 pdata+4, mangled_name,
4470 PTR_DIFF(dend, pdata+4),
4471 STR_UNICODE);
4472 data_size = 4 + len;
4473 SIVAL(pdata,0,len);
4474 break;
4475 }
4476
4477 case SMB_QUERY_FILE_NAME_INFO:
4478 {
4479 int len;
4480 /*
4481 this must be *exactly* right for ACLs on mapped drives to work
4482 */
4483 len = srvstr_push(dstart, flags2,
4484 pdata+4, dos_fname,
4485 PTR_DIFF(dend, pdata+4),
4486 STR_UNICODE);
4487 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4488 data_size = 4 + len;
4489 SIVAL(pdata,0,len);
4490 break;
4491 }
4492
4493 case SMB_FILE_ALLOCATION_INFORMATION:
4494 case SMB_QUERY_FILE_ALLOCATION_INFO:
4495 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4496 data_size = 8;
4497 SOFF_T(pdata,0,allocation_size);
4498 break;
4499
4500 case SMB_FILE_END_OF_FILE_INFORMATION:
4501 case SMB_QUERY_FILE_END_OF_FILEINFO:
4502 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4503 data_size = 8;
4504 SOFF_T(pdata,0,file_size);
4505 break;
4506
4507 case SMB_QUERY_FILE_ALL_INFO:
4508 case SMB_FILE_ALL_INFORMATION:
4509 {
4510 int len;
4511 unsigned int ea_size =
4512 estimate_ea_size(conn, fsp, smb_fname->base_name);
4513 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4514 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4515 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4516 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4517 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4518 SIVAL(pdata,32,mode);
4519 SIVAL(pdata,36,0); /* padding. */
4520 pdata += 40;
4521 SOFF_T(pdata,0,allocation_size);
4522 SOFF_T(pdata,8,file_size);
4523 SIVAL(pdata,16,nlink);
4524 SCVAL(pdata,20,delete_pending);
4525 SCVAL(pdata,21,(mode&aDIR)?1:0);
4526 SSVAL(pdata,22,0);
4527 pdata += 24;
4528 SIVAL(pdata,0,ea_size);
4529 pdata += 4; /* EA info */
4530 len = srvstr_push(dstart, flags2,
4531 pdata+4, dos_fname,
4532 PTR_DIFF(dend, pdata+4),
4533 STR_UNICODE);
4534 SIVAL(pdata,0,len);
4535 pdata += 4 + len;
4536 data_size = PTR_DIFF(pdata,(*ppdata));
4537 break;
4538 }
4539
4540 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
4541 {
4542 int len;
4543 unsigned int ea_size =
4544 estimate_ea_size(conn, fsp, smb_fname->base_name);
4545 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
4546 put_long_date_timespec(conn->ts_res,pdata+0x00,create_time_ts);
4547 put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
4548 put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
4549 put_long_date_timespec(conn->ts_res,pdata+0x18,ctime_ts); /* change time */
4550 SIVAL(pdata, 0x20, mode);
4551 SIVAL(pdata, 0x24, 0); /* padding. */
4552 SBVAL(pdata, 0x28, allocation_size);
4553 SBVAL(pdata, 0x30, file_size);
4554 SIVAL(pdata, 0x38, nlink);
4555 SCVAL(pdata, 0x3C, delete_pending);
4556 SCVAL(pdata, 0x3D, (mode&aDIR)?1:0);
4557 SSVAL(pdata, 0x3E, 0); /* padding */
4558 SBVAL(pdata, 0x40, file_index);
4559 SIVAL(pdata, 0x48, ea_size);
4560 SIVAL(pdata, 0x4C, access_mask);
4561 SBVAL(pdata, 0x50, pos);
4562 SIVAL(pdata, 0x58, mode); /*TODO: mode != mode fix this!!! */
4563 SIVAL(pdata, 0x5C, 0); /* No alignment needed. */
4564
4565 pdata += 0x60;
4566
4567 len = srvstr_push(dstart, flags2,
4568 pdata+4, dos_fname,
4569 PTR_DIFF(dend, pdata+4),
4570 STR_UNICODE);
4571 SIVAL(pdata,0,len);
4572 pdata += 4 + len;
4573 data_size = PTR_DIFF(pdata,(*ppdata));
4574 break;
4575 }
4576 case SMB_FILE_INTERNAL_INFORMATION:
4577
4578 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4579 SBVAL(pdata, 0, file_index);
4580 data_size = 8;
4581 break;
4582
4583 case SMB_FILE_ACCESS_INFORMATION:
4584 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4585 SIVAL(pdata, 0, access_mask);
4586 data_size = 4;
4587 break;
4588
4589 case SMB_FILE_NAME_INFORMATION:
4590 /* Pathname with leading '\'. */
4591 {
4592 size_t byte_len;
4593 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
4594 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4595 SIVAL(pdata,0,byte_len);
4596 data_size = 4 + byte_len;
4597 break;
4598 }
4599
4600 case SMB_FILE_DISPOSITION_INFORMATION:
4601 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4602 data_size = 1;
4603 SCVAL(pdata,0,delete_pending);
4604 break;
4605
4606 case SMB_FILE_POSITION_INFORMATION:
4607 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4608 data_size = 8;
4609 SOFF_T(pdata,0,pos);
4610 break;
4611
4612 case SMB_FILE_MODE_INFORMATION:
4613 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4614 SIVAL(pdata,0,mode);
4615 data_size = 4;
4616 break;
4617
4618 case SMB_FILE_ALIGNMENT_INFORMATION:
4619 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4620 SIVAL(pdata,0,0); /* No alignment needed. */
4621 data_size = 4;
4622 break;
4623
4624 /*
4625 * NT4 server just returns "invalid query" to this - if we try
4626 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4627 * want this. JRA.
4628 */
4629 /* The first statement above is false - verified using Thursby
4630 * client against NT4 -- gcolley.
4631 */
4632 case SMB_QUERY_FILE_STREAM_INFO:
4633 case SMB_FILE_STREAM_INFORMATION: {
4634 unsigned int num_streams;
4635 struct stream_struct *streams;
4636
4637 DEBUG(10,("smbd_do_qfilepathinfo: "
4638 "SMB_FILE_STREAM_INFORMATION\n"));
4639
4640 if (is_ntfs_stream_smb_fname(smb_fname)) {
4641 return NT_STATUS_INVALID_PARAMETER;
4642 }
4643
4644 status = SMB_VFS_STREAMINFO(
4645 conn, fsp, smb_fname->base_name, talloc_tos(),
4646 &num_streams, &streams);
4647
4648 if (!NT_STATUS_IS_OK(status)) {
4649 DEBUG(10, ("could not get stream info: %s\n",
4650 nt_errstr(status)));
4651 return status;
4652 }
4653
4654 status = marshall_stream_info(num_streams, streams,
4655 pdata, max_data_bytes,
4656 &data_size);
4657
4658 if (!NT_STATUS_IS_OK(status)) {
4659 DEBUG(10, ("marshall_stream_info failed: %s\n",
4660 nt_errstr(status)));
4661 return status;
4662 }
4663
4664 TALLOC_FREE(streams);
4665
4666 break;
4667 }
4668 case SMB_QUERY_COMPRESSION_INFO:
4669 case SMB_FILE_COMPRESSION_INFORMATION:
4670 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4671 SOFF_T(pdata,0,file_size);
4672 SIVAL(pdata,8,0); /* ??? */
4673 SIVAL(pdata,12,0); /* ??? */
4674 data_size = 16;
4675 break;
4676
4677 case SMB_FILE_NETWORK_OPEN_INFORMATION:
4678 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4679 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4680 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4681 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4682 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4683 SOFF_T(pdata,32,allocation_size);
4684 SOFF_T(pdata,40,file_size);
4685 SIVAL(pdata,48,mode);
4686 SIVAL(pdata,52,0); /* ??? */
4687 data_size = 56;
4688 break;
4689
4690 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
4691 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4692 SIVAL(pdata,0,mode);
4693 SIVAL(pdata,4,0);
4694 data_size = 8;
4695 break;
4696
4697 /*
4698 * CIFS UNIX Extensions.
4699 */
4700
4701 case SMB_QUERY_FILE_UNIX_BASIC:
4702
4703 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4704 data_size = PTR_DIFF(pdata,(*ppdata));
4705
4706 {
4707 int i;
4708 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
4709
4710 for (i=0; i<100; i++)
4711 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4712 DEBUG(4,("\n"));
4713 }
4714
4715 break;
4716
4717 case SMB_QUERY_FILE_UNIX_INFO2:
4718
4719 pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
4720 data_size = PTR_DIFF(pdata,(*ppdata));
4721
4722 {
4723 int i;
4724 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4725
4726 for (i=0; i<100; i++)
4727 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4728 DEBUG(4,("\n"));
4729 }
4730
4731 break;
4732
4733 case SMB_QUERY_FILE_UNIX_LINK:
4734 {
4735 int len;
4736 char *buffer = TALLOC_ARRAY(mem_ctx, char, PATH_MAX+1);
4737
4738 if (!buffer) {
4739 return NT_STATUS_NO_MEMORY;
4740 }
4741
4742 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4743 #ifdef S_ISLNK
4744 if(!S_ISLNK(psbuf->st_ex_mode)) {
4745 return NT_STATUS_DOS(ERRSRV, ERRbadlink);
4746 }
4747 #else
4748 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
4749 #endif
4750 len = SMB_VFS_READLINK(conn,
4751 smb_fname->base_name,
4752 buffer, PATH_MAX);
4753 if (len == -1) {
4754 return map_nt_error_from_unix(errno);
4755 }
4756 buffer[len] = 0;
4757 len = srvstr_push(dstart, flags2,
4758 pdata, buffer,
4759 PTR_DIFF(dend, pdata),
4760 STR_TERMINATE);
4761 pdata += len;
4762 data_size = PTR_DIFF(pdata,(*ppdata));
4763
4764 break;
4765 }
4766
4767 #if defined(HAVE_POSIX_ACLS)
4768 case SMB_QUERY_POSIX_ACL:
4769 {
4770 SMB_ACL_T file_acl = NULL;
4771 SMB_ACL_T def_acl = NULL;
4772 uint16 num_file_acls = 0;
4773 uint16 num_def_acls = 0;
4774
4775 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
4776 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp);
4777 } else {
4778 file_acl =
4779 SMB_VFS_SYS_ACL_GET_FILE(conn,
4780 smb_fname->base_name,
4781 SMB_ACL_TYPE_ACCESS);
4782 }
4783
4784 if (file_acl == NULL && no_acl_syscall_error(errno)) {
4785 DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
4786 "not implemented on "
4787 "filesystem containing %s\n",
4788 smb_fname->base_name));
4789 return NT_STATUS_NOT_IMPLEMENTED;
4790 }
4791
4792 if (S_ISDIR(psbuf->st_ex_mode)) {
4793 if (fsp && fsp->is_directory) {
4794 def_acl =
4795 SMB_VFS_SYS_ACL_GET_FILE(
4796 conn,
4797 fsp->fsp_name->base_name,
4798 SMB_ACL_TYPE_DEFAULT);
4799 } else {
4800 def_acl =
4801 SMB_VFS_SYS_ACL_GET_FILE(
4802 conn,
4803 smb_fname->base_name,
4804 SMB_ACL_TYPE_DEFAULT);
4805 }
4806 def_acl = free_empty_sys_acl(conn, def_acl);
4807 }
4808
4809 num_file_acls = count_acl_entries(conn, file_acl);
4810 num_def_acls = count_acl_entries(conn, def_acl);
4811
4812 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4813 DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
4814 data_size,
4815 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4816 SMB_POSIX_ACL_HEADER_SIZE) ));
4817 if (file_acl) {
4818 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4819 }
4820 if (def_acl) {
4821 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4822 }
4823 return NT_STATUS_BUFFER_TOO_SMALL;
4824 }
4825
4826 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4827 SSVAL(pdata,2,num_file_acls);
4828 SSVAL(pdata,4,num_def_acls);
4829 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
4830 if (file_acl) {
4831 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4832 }
4833 if (def_acl) {
4834 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4835 }
4836 return NT_STATUS_INTERNAL_ERROR;
4837 }
4838 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
4839 if (file_acl) {
4840 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4841 }
4842 if (def_acl) {
4843 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4844 }
4845 return NT_STATUS_INTERNAL_ERROR;
4846 }
4847
4848 if (file_acl) {
4849 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4850 }
4851 if (def_acl) {
4852 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4853 }
4854 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4855 break;
4856 }
4857 #endif
4858
4859
4860 case SMB_QUERY_POSIX_LOCK:
4861 {
4862 uint64_t count;
4863 uint64_t offset;
4864 uint32 lock_pid;
4865 enum brl_type lock_type;
4866
4867 /* We need an open file with a real fd for this. */
4868 if (!fsp || fsp->is_directory || fsp->fh->fd == -1) {
4869 return NT_STATUS_INVALID_LEVEL;
4870 }
4871
4872 if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
4873 return NT_STATUS_INVALID_PARAMETER;
4874 }
4875
4876 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4877 case POSIX_LOCK_TYPE_READ:
4878 lock_type = READ_LOCK;
4879 break;
4880 case POSIX_LOCK_TYPE_WRITE:
4881 lock_type = WRITE_LOCK;
4882 break;
4883 case POSIX_LOCK_TYPE_UNLOCK:
4884 default:
4885 /* There's no point in asking for an unlock... */
4886 return NT_STATUS_INVALID_PARAMETER;
4887 }
4888
4889 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4890 #if defined(HAVE_LONGLONG)
4891 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4892 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4893 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4894 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4895 #else /* HAVE_LONGLONG */
4896 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4897 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4898 #endif /* HAVE_LONGLONG */
4899
4900 status = query_lock(fsp,
4901 &lock_pid,
4902 &count,
4903 &offset,
4904 &lock_type,
4905 POSIX_LOCK);
4906
4907 if (ERROR_WAS_LOCK_DENIED(status)) {
4908 /* Here we need to report who has it locked... */
4909 data_size = POSIX_LOCK_DATA_SIZE;
4910
4911 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
4912 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
4913 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
4914 #if defined(HAVE_LONGLONG)
4915 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
4916 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
4917 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
4918 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
4919 #else /* HAVE_LONGLONG */
4920 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
4921 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
4922 #endif /* HAVE_LONGLONG */
4923
4924 } else if (NT_STATUS_IS_OK(status)) {
4925 /* For success we just return a copy of what we sent
4926 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4927 data_size = POSIX_LOCK_DATA_SIZE;
4928 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
4929 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
4930 } else {
4931 return status;
4932 }
4933 break;
4934 }
4935
4936 default:
4937 return NT_STATUS_INVALID_LEVEL;
4938 }
4939
4940 *pdata_size = data_size;
4941 return NT_STATUS_OK;
4942 }
4943
4944 /****************************************************************************
4945 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
4946 file name or file id).
4947 ****************************************************************************/
4948
4949 static void call_trans2qfilepathinfo(connection_struct *conn,
4950 struct smb_request *req,
4951 unsigned int tran_call,
4952 char **pparams, int total_params,
4953 char **ppdata, int total_data,
4954 unsigned int max_data_bytes)
4955 {
4956 char *params = *pparams;
4957 char *pdata = *ppdata;
4958 uint16 info_level;
4959 unsigned int data_size = 0;
4960 unsigned int param_size = 2;
4961 struct smb_filename *smb_fname = NULL;
4962 bool delete_pending = False;
4963 struct timespec write_time_ts;
4964 files_struct *fsp = NULL;
4965 struct file_id fileid;
4966 struct ea_list *ea_list = NULL;
4967 int lock_data_count = 0;
4968 char *lock_data = NULL;
4969 bool ms_dfs_link = false;
4970 NTSTATUS status = NT_STATUS_OK;
4971
4972 if (!params) {
4973 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4974 return;
4975 }
4976
4977 ZERO_STRUCT(write_time_ts);
4978
4979 if (tran_call == TRANSACT2_QFILEINFO) {
4980 if (total_params < 4) {
4981 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4982 return;
4983 }
4984
4985 if (IS_IPC(conn)) {
4986 call_trans2qpipeinfo(conn, req, tran_call,
4987 pparams, total_params,
4988 ppdata, total_data,
4989 max_data_bytes);
4990 return;
4991 }
4992
4993 fsp = file_fsp(req, SVAL(params,0));
4994 info_level = SVAL(params,2);
4995
4996 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
4997
4998 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4999 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5000 return;
5001 }
5002
5003 /* Initial check for valid fsp ptr. */
5004 if (!check_fsp_open(conn, req, fsp)) {
5005 return;
5006 }
5007
5008 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
5009 &smb_fname);
5010 if (!NT_STATUS_IS_OK(status)) {
5011 reply_nterror(req, status);
5012 return;
5013 }
5014
5015 if(fsp->fake_file_handle) {
5016 /*
5017 * This is actually for the QUOTA_FAKE_FILE --metze
5018 */
5019
5020 /* We know this name is ok, it's already passed the checks. */
5021
5022 } else if(fsp->is_directory || fsp->fh->fd == -1) {
5023 /*
5024 * This is actually a QFILEINFO on a directory
5025 * handle (returned from an NT SMB). NT5.0 seems
5026 * to do this call. JRA.
5027 */
5028
5029 if (INFO_LEVEL_IS_UNIX(info_level)) {
5030 /* Always do lstat for UNIX calls. */
5031 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5032 DEBUG(3,("call_trans2qfilepathinfo: "
5033 "SMB_VFS_LSTAT of %s failed "
5034 "(%s)\n",
5035 smb_fname_str_dbg(smb_fname),
5036 strerror(errno)));
5037 reply_nterror(req,
5038 map_nt_error_from_unix(errno));
5039 return;
5040 }
5041 } else if (SMB_VFS_STAT(conn, smb_fname)) {
5042 DEBUG(3,("call_trans2qfilepathinfo: "
5043 "SMB_VFS_STAT of %s failed (%s)\n",
5044 smb_fname_str_dbg(smb_fname),
5045 strerror(errno)));
5046 reply_nterror(req,
5047 map_nt_error_from_unix(errno));
5048 return;
5049 }
5050
5051 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5052 get_file_infos(fileid, &delete_pending, &write_time_ts);
5053 } else {
5054 /*
5055 * Original code - this is an open file.
5056 */
5057 if (!check_fsp(conn, req, fsp)) {
5058 return;
5059 }
5060
5061 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5062 DEBUG(3, ("fstat of fnum %d failed (%s)\n",
5063 fsp->fnum, strerror(errno)));
5064 reply_nterror(req,
5065 map_nt_error_from_unix(errno));
5066 return;
5067 }
5068 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5069 get_file_infos(fileid, &delete_pending, &write_time_ts);
5070 }
5071
5072 } else {
5073 char *fname = NULL;
5074
5075 /* qpathinfo */
5076 if (total_params < 7) {
5077 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5078 return;
5079 }
5080
5081 info_level = SVAL(params,0);
5082
5083 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5084
5085 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5086 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5087 return;
5088 }
5089
5090 srvstr_get_path(req, params, req->flags2, &fname, &params[6],
5091 total_params - 6,
5092 STR_TERMINATE, &status);
5093 if (!NT_STATUS_IS_OK(status)) {
5094 reply_nterror(req, status);
5095 return;
5096 }
5097
5098 status = filename_convert(req,
5099 conn,
5100 req->flags2 & FLAGS2_DFS_PATHNAMES,
5101 fname,
5102 0,
5103 NULL,
5104 &smb_fname);
5105 if (!NT_STATUS_IS_OK(status)) {
5106 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5107 reply_botherror(req,
5108 NT_STATUS_PATH_NOT_COVERED,
5109 ERRSRV, ERRbadpath);
5110 return;
5111 }
5112 reply_nterror(req, status);
5113 return;
5114 }
5115
5116 /* If this is a stream, check if there is a delete_pending. */
5117 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5118 && is_ntfs_stream_smb_fname(smb_fname)) {
5119 struct smb_filename *smb_fname_base = NULL;
5120
5121 /* Create an smb_filename with stream_name == NULL. */
5122 status =
5123 create_synthetic_smb_fname(talloc_tos(),
5124 smb_fname->base_name,
5125 NULL, NULL,
5126 &smb_fname_base);
5127 if (!NT_STATUS_IS_OK(status)) {
5128 reply_nterror(req, status);
5129 return;
5130 }
5131
5132 if (INFO_LEVEL_IS_UNIX(info_level)) {
5133 /* Always do lstat for UNIX calls. */
5134 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5135 DEBUG(3,("call_trans2qfilepathinfo: "
5136 "SMB_VFS_LSTAT of %s failed "
5137 "(%s)\n",
5138 smb_fname_str_dbg(smb_fname_base),
5139 strerror(errno)));
5140 TALLOC_FREE(smb_fname_base);
5141 reply_nterror(req,
5142 map_nt_error_from_unix(errno));
5143 return;
5144 }
5145 } else {
5146 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5147 DEBUG(3,("call_trans2qfilepathinfo: "
5148 "fileinfo of %s failed "
5149 "(%s)\n",
5150 smb_fname_str_dbg(smb_fname_base),
5151 strerror(errno)));
5152 TALLOC_FREE(smb_fname_base);
5153 reply_nterror(req,
5154 map_nt_error_from_unix(errno));
5155 return;
5156 }
5157 }
5158
5159 fileid = vfs_file_id_from_sbuf(conn,
5160 &smb_fname_base->st);
5161 TALLOC_FREE(smb_fname_base);
5162 get_file_infos(fileid, &delete_pending, NULL);
5163 if (delete_pending) {
5164 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5165 return;
5166 }
5167 }
5168
5169 if (INFO_LEVEL_IS_UNIX(info_level)) {
5170 /* Always do lstat for UNIX calls. */
5171 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5172 DEBUG(3,("call_trans2qfilepathinfo: "
5173 "SMB_VFS_LSTAT of %s failed (%s)\n",
5174 smb_fname_str_dbg(smb_fname),
5175 strerror(errno)));
5176 reply_nterror(req,
5177 map_nt_error_from_unix(errno));
5178 return;
5179 }
5180
5181 } else if (!VALID_STAT(smb_fname->st) &&
5182 SMB_VFS_STAT(conn, smb_fname) &&
5183 (info_level != SMB_INFO_IS_NAME_VALID)) {
5184 ms_dfs_link = check_msdfs_link(conn,
5185 smb_fname->base_name,
5186 &smb_fname->st);
5187
5188 if (!ms_dfs_link) {
5189 DEBUG(3,("call_trans2qfilepathinfo: "
5190 "SMB_VFS_STAT of %s failed (%s)\n",
5191 smb_fname_str_dbg(smb_fname),
5192 strerror(errno)));
5193 reply_nterror(req,
5194 map_nt_error_from_unix(errno));
5195 return;
5196 }
5197 }
5198
5199 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5200 get_file_infos(fileid, &delete_pending, &write_time_ts);
5201 if (delete_pending) {
5202 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5203 return;
5204 }
5205 }
5206
5207 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d "
5208 "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5209 fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
5210
5211 /* Pull out any data sent here before we realloc. */
5212 switch (info_level) {
5213 case SMB_INFO_QUERY_EAS_FROM_LIST:
5214 {
5215 /* Pull any EA list from the data portion. */
5216 uint32 ea_size;
5217
5218 if (total_data < 4) {
5219 reply_nterror(
5220 req, NT_STATUS_INVALID_PARAMETER);
5221 return;
5222 }
5223 ea_size = IVAL(pdata,0);
5224
5225 if (total_data > 0 && ea_size != total_data) {
5226 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5227 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5228 reply_nterror(
5229 req, NT_STATUS_INVALID_PARAMETER);
5230 return;
5231 }
5232
5233 if (!lp_ea_support(SNUM(conn))) {
5234 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
5235 return;
5236 }
5237
5238 /* Pull out the list of names. */
5239 ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
5240 if (!ea_list) {
5241 reply_nterror(
5242 req, NT_STATUS_INVALID_PARAMETER);
5243 return;
5244 }
5245 break;
5246 }
5247
5248 case SMB_QUERY_POSIX_LOCK:
5249 {
5250 if (fsp == NULL || fsp->fh->fd == -1) {
5251 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
5252 return;
5253 }
5254
5255 if (total_data != POSIX_LOCK_DATA_SIZE) {
5256 reply_nterror(
5257 req, NT_STATUS_INVALID_PARAMETER);
5258 return;
5259 }
5260
5261 /* Copy the lock range data. */
5262 lock_data = (char *)TALLOC_MEMDUP(
5263 req, pdata, total_data);
5264 if (!lock_data) {
5265 reply_nterror(req, NT_STATUS_NO_MEMORY);
5266 return;
5267 }
5268 lock_data_count = total_data;
5269 }
5270 default:
5271 break;
5272 }
5273
5274 *pparams = (char *)SMB_REALLOC(*pparams,2);
5275 if (*pparams == NULL) {
5276 reply_nterror(req, NT_STATUS_NO_MEMORY);
5277 return;
5278 }
5279 params = *pparams;
5280 SSVAL(params,0,0);
5281
5282 /*
5283 * draft-leach-cifs-v1-spec-02.txt
5284 * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
5285 * says:
5286 *
5287 * The requested information is placed in the Data portion of the
5288 * transaction response. For the information levels greater than 0x100,
5289 * the transaction response has 1 parameter word which should be
5290 * ignored by the client.
5291 *
5292 * However Windows only follows this rule for the IS_NAME_VALID call.
5293 */
5294 switch (info_level) {
5295 case SMB_INFO_IS_NAME_VALID:
5296 param_size = 0;
5297 break;
5298 }
5299
5300 if ((info_level & 0xFF00) == 0xFF00) {
5301 /*
5302 * We use levels that start with 0xFF00
5303 * internally to represent SMB2 specific levels
5304 */
5305 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5306 return;
5307 }
5308
5309 status = smbd_do_qfilepathinfo(conn, req, info_level,
5310 fsp, smb_fname,
5311 delete_pending, write_time_ts,
5312 ms_dfs_link, ea_list,
5313 lock_data_count, lock_data,
5314 req->flags2, max_data_bytes,
5315 ppdata, &data_size);
5316 if (!NT_STATUS_IS_OK(status)) {
5317 reply_nterror(req, status);
5318 return;
5319 }
5320
5321 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
5322 max_data_bytes);
5323
5324 return;
5325 }
5326
5327 /****************************************************************************
5328 Set a hard link (called by UNIX extensions and by NT rename with HARD link
5329 code.
5330 ****************************************************************************/
5331
5332 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
5333 connection_struct *conn,
5334 const struct smb_filename *smb_fname_old,
5335 const struct smb_filename *smb_fname_new)
5336 {
5337 NTSTATUS status = NT_STATUS_OK;
5338
5339 /* source must already exist. */
5340 if (!VALID_STAT(smb_fname_old->st)) {
5341 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5342 }
5343
5344 /* Disallow if newname already exists. */
5345 if (VALID_STAT(smb_fname_new->st)) {
5346 return NT_STATUS_OBJECT_NAME_COLLISION;
5347 }
5348
5349 /* No links from a directory. */
5350 if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
5351 return NT_STATUS_FILE_IS_A_DIRECTORY;
5352 }
5353
5354 /* Setting a hardlink to/from a stream isn't currently supported. */
5355 if (is_ntfs_stream_smb_fname(smb_fname_old) ||
5356 is_ntfs_stream_smb_fname(smb_fname_new)) {
5357 return NT_STATUS_INVALID_PARAMETER;
5358 }
5359
5360 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
5361 smb_fname_old->base_name, smb_fname_new->base_name));
5362
5363 if (SMB_VFS_LINK(conn, smb_fname_old->base_name,
5364 smb_fname_new->base_name) != 0) {
5365 status = map_nt_error_from_unix(errno);
5366 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
5367 nt_errstr(status), smb_fname_old->base_name,
5368 smb_fname_new->base_name));
5369 }
5370 return status;
5371 }
5372
5373 /****************************************************************************
5374 Deal with setting the time from any of the setfilepathinfo functions.
5375 ****************************************************************************/
5376
5377 NTSTATUS smb_set_file_time(connection_struct *conn,
5378 files_struct *fsp,
5379 const struct smb_filename *smb_fname,
5380 struct smb_file_time *ft,
5381 bool setting_write_time)
5382 {
5383 struct smb_filename smb_fname_base;
5384 uint32 action =
5385 FILE_NOTIFY_CHANGE_LAST_ACCESS
5386 |FILE_NOTIFY_CHANGE_LAST_WRITE
5387 |FILE_NOTIFY_CHANGE_CREATION;
5388
5389 if (!VALID_STAT(smb_fname->st)) {
5390 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5391 }
5392
5393 /* get some defaults (no modifications) if any info is zero or -1. */
5394 if (null_timespec(ft->create_time)) {
5395 action &= ~FILE_NOTIFY_CHANGE_CREATION;
5396 }
5397
5398 if (null_timespec(ft->atime)) {
5399 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
5400 }
5401
5402 if (null_timespec(ft->mtime)) {
5403 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5404 }
5405
5406 if (!setting_write_time) {
5407 /* ft->mtime comes from change time, not write time. */
5408 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5409 }
5410
5411 /* Ensure the resolution is the correct for
5412 * what we can store on this filesystem. */
5413
5414 round_timespec(conn->ts_res, &ft->create_time);
5415 round_timespec(conn->ts_res, &ft->ctime);
5416 round_timespec(conn->ts_res, &ft->atime);
5417 round_timespec(conn->ts_res, &ft->mtime);
5418
5419 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5420 time_to_asc(convert_timespec_to_time_t(ft->atime))));
5421 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5422 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5423 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5424 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
5425 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5426 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5427
5428 if (setting_write_time) {
5429 /*
5430 * This was a Windows setfileinfo on an open file.
5431 * NT does this a lot. We also need to
5432 * set the time here, as it can be read by
5433 * FindFirst/FindNext and with the patch for bug #2045
5434 * in smbd/fileio.c it ensures that this timestamp is
5435 * kept sticky even after a write. We save the request
5436 * away and will set it on file close and after a write. JRA.
5437 */
5438
5439 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5440 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5441
5442 if (fsp != NULL) {
5443 if (fsp->base_fsp) {
5444 set_sticky_write_time_fsp(fsp->base_fsp,
5445 ft->mtime);
5446 } else {
5447 set_sticky_write_time_fsp(fsp, ft->mtime);
5448 }
5449 } else {
5450 set_sticky_write_time_path(
5451 vfs_file_id_from_sbuf(conn, &smb_fname->st),
5452 ft->mtime);
5453 }
5454 }
5455
5456 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5457
5458 /* Always call ntimes on the base, even if a stream was passed in. */
5459 smb_fname_base = *smb_fname;
5460 smb_fname_base.stream_name = NULL;
5461
5462 if(file_ntimes(conn, &smb_fname_base, ft)!=0) {
5463 return map_nt_error_from_unix(errno);
5464 }
5465
5466 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
5467 smb_fname->base_name);
5468 return NT_STATUS_OK;
5469 }
5470
5471 /****************************************************************************
5472 Deal with setting the dosmode from any of the setfilepathinfo functions.
5473 ****************************************************************************/
5474
5475 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
5476 const struct smb_filename *smb_fname,
5477 uint32 dosmode)
5478 {
5479 struct smb_filename *smb_fname_base = NULL;
5480 NTSTATUS status;
5481
5482 if (!VALID_STAT(smb_fname->st)) {
5483 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5484 }
5485
5486 /* Always operate on the base_name, even if a stream was passed in. */
5487 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5488 NULL, &smb_fname->st,
5489 &smb_fname_base);
5490 if (!NT_STATUS_IS_OK(status)) {
5491 return status;
5492 }
5493
5494 if (dosmode) {
5495 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
5496 dosmode |= aDIR;
5497 } else {
5498 dosmode &= ~aDIR;
5499 }
5500 }
5501
5502 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
5503
5504 /* check the mode isn't different, before changing it */
5505 if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
5506 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5507 "0x%x\n", smb_fname_str_dbg(smb_fname_base),
5508 (unsigned int)dosmode));
5509
5510 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
5511 false)) {
5512 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5513 "%s failed (%s)\n",
5514 smb_fname_str_dbg(smb_fname_base),
5515 strerror(errno)));
5516 status = map_nt_error_from_unix(errno);
5517 goto out;
5518 }
5519 }
5520 status = NT_STATUS_OK;
5521 out:
5522 TALLOC_FREE(smb_fname_base);
5523 return status;
5524 }
5525
5526 /****************************************************************************
5527 Deal with setting the size from any of the setfilepathinfo functions.
5528 ****************************************************************************/
5529
5530 static NTSTATUS smb_set_file_size(connection_struct *conn,
5531 struct smb_request *req,
5532 files_struct *fsp,
5533 const struct smb_filename *smb_fname,
5534 const SMB_STRUCT_STAT *psbuf,
5535 SMB_OFF_T size,
5536 bool fail_after_createfile)
5537 {
5538 NTSTATUS status = NT_STATUS_OK;
5539 struct smb_filename *smb_fname_tmp = NULL;
5540 files_struct *new_fsp = NULL;
5541
5542 if (!VALID_STAT(*psbuf)) {
5543 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5544 }
5545
5546 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
5547
5548 if (size == get_file_size_stat(psbuf)) {
5549 return NT_STATUS_OK;
5550 }
5551
5552 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5553 smb_fname_str_dbg(smb_fname), (double)size));
5554
5555 if (fsp && fsp->fh->fd != -1) {
5556 /* Handle based call. */
5557 if (vfs_set_filelen(fsp, size) == -1) {
5558 return map_nt_error_from_unix(errno);
5559 }
5560 trigger_write_time_update_immediate(fsp);
5561 return NT_STATUS_OK;
5562 }
5563
5564 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
5565 if (!NT_STATUS_IS_OK(status)) {
5566 return status;
5567 }
5568
5569 smb_fname_tmp->st = *psbuf;
5570
5571 status = SMB_VFS_CREATE_FILE(
5572 conn, /* conn */
5573 req, /* req */
5574 0, /* root_dir_fid */
5575 smb_fname_tmp, /* fname */
5576 FILE_WRITE_ATTRIBUTES, /* access_mask */
5577 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
5578 FILE_SHARE_DELETE),
5579 FILE_OPEN, /* create_disposition*/
5580 0, /* create_options */
5581 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
5582 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
5583 0, /* allocation_size */
5584 NULL, /* sd */
5585 NULL, /* ea_list */
5586 &new_fsp, /* result */
5587 NULL); /* pinfo */
5588
5589 TALLOC_FREE(smb_fname_tmp);
5590
5591 if (!NT_STATUS_IS_OK(status)) {
5592 /* NB. We check for open_was_deferred in the caller. */
5593 return status;
5594 }
5595
5596 /* See RAW-SFILEINFO-END-OF-FILE */
5597 if (fail_after_createfile) {
5598 close_file(req, new_fsp,NORMAL_CLOSE);
5599 return NT_STATUS_INVALID_LEVEL;
5600 }
5601
5602 if (vfs_set_filelen(new_fsp, size) == -1) {
5603 status = map_nt_error_from_unix(errno);
5604 close_file(req, new_fsp,NORMAL_CLOSE);
5605 return status;
5606 }
5607
5608 trigger_write_time_update_immediate(new_fsp);
5609 close_file(req, new_fsp,NORMAL_CLOSE);
5610 return NT_STATUS_OK;
5611 }
5612
5613 /****************************************************************************
5614 Deal with SMB_INFO_SET_EA.
5615 ****************************************************************************/
5616
5617 static NTSTATUS smb_info_set_ea(connection_struct *conn,
5618 const char *pdata,
5619 int total_data,
5620 files_struct *fsp,
5621 const struct smb_filename *smb_fname)
5622 {
5623 struct ea_list *ea_list = NULL;
5624 TALLOC_CTX *ctx = NULL;
5625 NTSTATUS status = NT_STATUS_OK;
5626
5627 if (total_data < 10) {
5628
5629 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5630 length. They seem to have no effect. Bug #3212. JRA */
5631
5632 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
5633 /* We're done. We only get EA info in this call. */
5634 return NT_STATUS_OK;
5635 }
5636
5637 return NT_STATUS_INVALID_PARAMETER;
5638 }
5639
5640 if (IVAL(pdata,0) > total_data) {
5641 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5642 IVAL(pdata,0), (unsigned int)total_data));
5643 return NT_STATUS_INVALID_PARAMETER;
5644 }
5645
5646 ctx = talloc_tos();
5647 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
5648 if (!ea_list) {
5649 return NT_STATUS_INVALID_PARAMETER;
5650 }
5651 status = set_ea(conn, fsp, smb_fname, ea_list);
5652
5653 return status;
5654 }
5655
5656 /****************************************************************************
5657 Deal with SMB_FILE_FULL_EA_INFORMATION set.
5658 ****************************************************************************/
5659
5660 static NTSTATUS smb_set_file_full_ea_info(connection_struct *conn,
5661 const char *pdata,
5662 int total_data,
5663 files_struct *fsp)
5664 {
5665 struct ea_list *ea_list = NULL;
5666 NTSTATUS status;
5667
5668 if (!fsp) {
5669 return NT_STATUS_INVALID_HANDLE;
5670 }
5671
5672 if (!lp_ea_support(SNUM(conn))) {
5673 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
5674 "EA's not supported.\n",
5675 (unsigned int)total_data));
5676 return NT_STATUS_EAS_NOT_SUPPORTED;
5677 }
5678
5679 if (total_data < 10) {
5680 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
5681 "too small.\n",
5682 (unsigned int)total_data));
5683 return NT_STATUS_INVALID_PARAMETER;
5684 }
5685
5686 ea_list = read_nttrans_ea_list(talloc_tos(),
5687 pdata,
5688 total_data);
5689
5690 if (!ea_list) {
5691 return NT_STATUS_INVALID_PARAMETER;
5692 }
5693 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
5694
5695 DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
5696 smb_fname_str_dbg(fsp->fsp_name),
5697 nt_errstr(status) ));
5698
5699 return status;
5700 }
5701
5702
5703 /****************************************************************************
5704 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5705 ****************************************************************************/
5706
5707 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
5708 const char *pdata,
5709 int total_data,
5710 files_struct *fsp,
5711 struct smb_filename *smb_fname)
5712 {
5713 NTSTATUS status = NT_STATUS_OK;
5714 bool delete_on_close;
5715 uint32 dosmode = 0;
5716
5717 if (total_data < 1) {
5718 return NT_STATUS_INVALID_PARAMETER;
5719 }
5720
5721 if (fsp == NULL) {
5722 return NT_STATUS_INVALID_HANDLE;
5723 }
5724
5725 delete_on_close = (CVAL(pdata,0) ? True : False);
5726 dosmode = dos_mode(conn, smb_fname);
5727
5728 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5729 "delete_on_close = %u\n",
5730 smb_fname_str_dbg(smb_fname),
5731 (unsigned int)dosmode,
5732 (unsigned int)delete_on_close ));
5733
5734 if (delete_on_close) {
5735 status = can_set_delete_on_close(fsp, dosmode);
5736 if (!NT_STATUS_IS_OK(status)) {
5737 return status;
5738 }
5739 }
5740
5741 /* The set is across all open files on this dev/inode pair. */
5742 if (!set_delete_on_close(fsp, delete_on_close,
5743 &conn->server_info->utok)) {
5744 return NT_STATUS_ACCESS_DENIED;
5745 }
5746 return NT_STATUS_OK;
5747 }
5748
5749 /****************************************************************************
5750 Deal with SMB_FILE_POSITION_INFORMATION.
5751 ****************************************************************************/
5752
5753 static NTSTATUS smb_file_position_information(connection_struct *conn,
5754 const char *pdata,
5755 int total_data,
5756 files_struct *fsp)
5757 {
5758 uint64_t position_information;
5759
5760 if (total_data < 8) {
5761 return NT_STATUS_INVALID_PARAMETER;
5762 }
5763
5764 if (fsp == NULL) {
5765 /* Ignore on pathname based set. */
5766 return NT_STATUS_OK;
5767 }
5768
5769 position_information = (uint64_t)IVAL(pdata,0);
5770 #ifdef LARGE_SMB_OFF_T
5771 position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
5772 #else /* LARGE_SMB_OFF_T */
5773 if (IVAL(pdata,4) != 0) {
5774 /* more than 32 bits? */
5775 return NT_STATUS_INVALID_PARAMETER;
5776 }
5777 #endif /* LARGE_SMB_OFF_T */
5778
5779 DEBUG(10,("smb_file_position_information: Set file position "
5780 "information for file %s to %.0f\n", fsp_str_dbg(fsp),
5781 (double)position_information));
5782 fsp->fh->position_information = position_information;
5783 return NT_STATUS_OK;
5784 }
5785
5786 /****************************************************************************
5787 Deal with SMB_FILE_MODE_INFORMATION.
5788 ****************************************************************************/
5789
5790 static NTSTATUS smb_file_mode_information(connection_struct *conn,
5791 const char *pdata,
5792 int total_data)
5793 {
5794 uint32 mode;
5795
5796 if (total_data < 4) {
5797 return NT_STATUS_INVALID_PARAMETER;
5798 }
5799 mode = IVAL(pdata,0);
5800 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
5801 return NT_STATUS_INVALID_PARAMETER;
5802 }
5803 return NT_STATUS_OK;
5804 }
5805
5806 /****************************************************************************
5807 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5808 ****************************************************************************/
5809
5810 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
5811 struct smb_request *req,
5812 const char *pdata,
5813 int total_data,
5814 const struct smb_filename *smb_fname)
5815 {
5816 char *link_target = NULL;
5817 const char *newname = smb_fname->base_name;
5818 TALLOC_CTX *ctx = talloc_tos();
5819
5820 /* Set a symbolic link. */
5821 /* Don't allow this if follow links is false. */
5822
5823 if (total_data == 0) {
5824 return NT_STATUS_INVALID_PARAMETER;
5825 }
5826
5827 if (!lp_symlinks(SNUM(conn))) {
5828 return NT_STATUS_ACCESS_DENIED;
5829 }
5830
5831 srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
5832 total_data, STR_TERMINATE);
5833
5834 if (!link_target) {
5835 return NT_STATUS_INVALID_PARAMETER;
5836 }
5837
5838 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5839 newname, link_target ));
5840
5841 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
5842 return map_nt_error_from_unix(errno);
5843 }
5844
5845 return NT_STATUS_OK;
5846 }
5847
5848 /****************************************************************************
5849 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5850 ****************************************************************************/
5851
5852 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
5853 struct smb_request *req,
5854 const char *pdata, int total_data,
5855 const struct smb_filename *smb_fname_new)
5856 {
5857 char *oldname = NULL;
5858 struct smb_filename *smb_fname_old = NULL;
5859 TALLOC_CTX *ctx = talloc_tos();
5860 NTSTATUS status = NT_STATUS_OK;
5861
5862 /* Set a hard link. */
5863 if (total_data == 0) {
5864 return NT_STATUS_INVALID_PARAMETER;
5865 }
5866
5867 srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
5868 total_data, STR_TERMINATE, &status);
5869 if (!NT_STATUS_IS_OK(status)) {
5870 return status;
5871 }
5872
5873 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5874 smb_fname_str_dbg(smb_fname_new), oldname));
5875
5876 status = filename_convert(ctx,
5877 conn,
5878 req->flags2 & FLAGS2_DFS_PATHNAMES,
5879 oldname,
5880 0,
5881 NULL,
5882 &smb_fname_old);
5883 if (!NT_STATUS_IS_OK(status)) {
5884 return status;
5885 }
5886
5887 return hardlink_internals(ctx, conn, smb_fname_old, smb_fname_new);
5888 }
5889
5890 /****************************************************************************
5891 Deal with SMB_FILE_RENAME_INFORMATION.
5892 ****************************************************************************/
5893
5894 static NTSTATUS smb_file_rename_information(connection_struct *conn,
5895 struct smb_request *req,
5896 const char *pdata,
5897 int total_data,
5898 files_struct *fsp,
5899 struct smb_filename *smb_fname_src)
5900 {
5901 bool overwrite;
5902 uint32 root_fid;
5903 uint32 len;
5904 char *newname = NULL;
5905 struct smb_filename *smb_fname_dst = NULL;
5906 bool dest_has_wcard = False;
5907 NTSTATUS status = NT_STATUS_OK;
5908 char *p;
5909 TALLOC_CTX *ctx = talloc_tos();
5910
5911 if (total_data < 13) {
5912 return NT_STATUS_INVALID_PARAMETER;
5913 }
5914
5915 overwrite = (CVAL(pdata,0) ? True : False);
5916 root_fid = IVAL(pdata,4);
5917 len = IVAL(pdata,8);
5918
5919 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
5920 return NT_STATUS_INVALID_PARAMETER;
5921 }
5922
5923 srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
5924 len, 0, &status,
5925 &dest_has_wcard);
5926 if (!NT_STATUS_IS_OK(status)) {
5927 return status;
5928 }
5929
5930 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
5931 newname));
5932
5933 status = resolve_dfspath_wcard(ctx, conn,
5934 req->flags2 & FLAGS2_DFS_PATHNAMES,
5935 newname,
5936 true,
5937 &newname,
5938 &dest_has_wcard);
5939 if (!NT_STATUS_IS_OK(status)) {
5940 return status;
5941 }
5942
5943 /* Check the new name has no '/' characters. */
5944 if (strchr_m(newname, '/')) {
5945 return NT_STATUS_NOT_SUPPORTED;
5946 }
5947
5948 if (fsp && fsp->base_fsp) {
5949 /* newname must be a stream name. */
5950 if (newname[0] != ':') {
5951 return NT_STATUS_NOT_SUPPORTED;
5952 }
5953
5954 /* Create an smb_fname to call rename_internals_fsp() with. */
5955 status = create_synthetic_smb_fname(talloc_tos(),
5956 fsp->base_fsp->fsp_name->base_name, newname, NULL,
5957 &smb_fname_dst);
5958 if (!NT_STATUS_IS_OK(status)) {
5959 goto out;
5960 }
5961
5962 /*
5963 * Set the original last component, since
5964 * rename_internals_fsp() requires it.
5965 */
5966 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
5967 newname);
5968 if (smb_fname_dst->original_lcomp == NULL) {
5969 status = NT_STATUS_NO_MEMORY;
5970 goto out;
5971 }
5972
5973 } else {
5974 /*
5975 * Build up an smb_fname_dst based on the filename passed in.
5976 * We basically just strip off the last component, and put on
5977 * the newname instead.
5978 */
5979 char *base_name = NULL;
5980
5981 /* newname must *not* be a stream name. */
5982 if (newname[0] == ':') {
5983 return NT_STATUS_NOT_SUPPORTED;
5984 }
5985
5986 /*
5987 * Strip off the last component (filename) of the path passed
5988 * in.
5989 */
5990 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
5991 if (!base_name) {
5992 return NT_STATUS_NO_MEMORY;
5993 }
5994 p = strrchr_m(base_name, '/');
5995 if (p) {
5996 p[1] = '\0';
5997 } else {
5998 base_name = talloc_strdup(ctx, "./");
5999 if (!base_name) {
6000 return NT_STATUS_NO_MEMORY;
6001 }
6002 }
6003 /* Append the new name. */
6004 base_name = talloc_asprintf_append(base_name,
6005 "%s",
6006 newname);
6007 if (!base_name) {
6008 return NT_STATUS_NO_MEMORY;
6009 }
6010
6011 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
6012 (UCF_SAVE_LCOMP |
6013 (dest_has_wcard ?
6014 UCF_ALWAYS_ALLOW_WCARD_LCOMP :
6015 0)));
6016
6017 /* If an error we expect this to be
6018 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6019
6020 if (!NT_STATUS_IS_OK(status)) {
6021 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
6022 status)) {
6023 goto out;
6024 }
6025 /* Create an smb_fname to call rename_internals_fsp() */
6026 status = create_synthetic_smb_fname(ctx,
6027 base_name, NULL,
6028 NULL,
6029 &smb_fname_dst);
6030 if (!NT_STATUS_IS_OK(status)) {
6031 goto out;
6032 }
6033 }
6034 }
6035
6036 if (fsp) {
6037 DEBUG(10,("smb_file_rename_information: "
6038 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6039 fsp->fnum, fsp_str_dbg(fsp),
6040 smb_fname_str_dbg(smb_fname_dst)));
6041 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
6042 overwrite);
6043 } else {
6044 DEBUG(10,("smb_file_rename_information: "
6045 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6046 smb_fname_str_dbg(smb_fname_src),
6047 smb_fname_str_dbg(smb_fname_dst)));
6048 status = rename_internals(ctx, conn, req, smb_fname_src,
6049 smb_fname_dst, 0, overwrite, false,
6050 dest_has_wcard,
6051 FILE_WRITE_ATTRIBUTES);
6052 }
6053 out:
6054 TALLOC_FREE(smb_fname_dst);
6055 return status;
6056 }
6057
6058 /****************************************************************************
6059 Deal with SMB_SET_POSIX_ACL.
6060 ****************************************************************************/
6061
6062 #if defined(HAVE_POSIX_ACLS)
6063 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
6064 const char *pdata,
6065 int total_data,
6066 files_struct *fsp,
6067 const struct smb_filename *smb_fname)
6068 {
6069 uint16 posix_acl_version;
6070 uint16 num_file_acls;
6071 uint16 num_def_acls;
6072 bool valid_file_acls = True;
6073 bool valid_def_acls = True;
6074
6075 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
6076 return NT_STATUS_INVALID_PARAMETER;
6077 }
6078 posix_acl_version = SVAL(pdata,0);
6079 num_file_acls = SVAL(pdata,2);
6080 num_def_acls = SVAL(pdata,4);
6081
6082 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6083 valid_file_acls = False;
6084 num_file_acls = 0;
6085 }
6086
6087 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6088 valid_def_acls = False;
6089 num_def_acls = 0;
6090 }
6091
6092 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
6093 return NT_STATUS_INVALID_PARAMETER;
6094 }
6095
6096 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
6097 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
6098 return NT_STATUS_INVALID_PARAMETER;
6099 }
6100
6101 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6102 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
6103 (unsigned int)num_file_acls,
6104 (unsigned int)num_def_acls));
6105
6106 if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
6107 smb_fname->base_name, num_file_acls,
6108 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
6109 return map_nt_error_from_unix(errno);
6110 }
6111
6112 if (valid_def_acls && !set_unix_posix_default_acl(conn,
6113 smb_fname->base_name, &smb_fname->st, num_def_acls,
6114 pdata + SMB_POSIX_ACL_HEADER_SIZE +
6115 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
6116 return map_nt_error_from_unix(errno);
6117 }
6118 return NT_STATUS_OK;
6119 }
6120 #endif
6121
6122 /****************************************************************************
6123 Deal with SMB_SET_POSIX_LOCK.
6124 ****************************************************************************/
6125
6126 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
6127 struct smb_request *req,
6128 const char *pdata,
6129 int total_data,
6130 files_struct *fsp)
6131 {
6132 uint64_t count;
6133 uint64_t offset;
6134 uint32 lock_pid;
6135 bool blocking_lock = False;
6136 enum brl_type lock_type;
6137
6138 NTSTATUS status = NT_STATUS_OK;
6139
6140 if (fsp == NULL || fsp->fh->fd == -1) {
6141 return NT_STATUS_INVALID_HANDLE;
6142 }
6143
6144 if (total_data != POSIX_LOCK_DATA_SIZE) {
6145 return NT_STATUS_INVALID_PARAMETER;
6146 }
6147
6148 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
6149 case POSIX_LOCK_TYPE_READ:
6150 lock_type = READ_LOCK;
6151 break;
6152 case POSIX_LOCK_TYPE_WRITE:
6153 /* Return the right POSIX-mappable error code for files opened read-only. */
6154 if (!fsp->can_write) {
6155 return NT_STATUS_INVALID_HANDLE;
6156 }
6157 lock_type = WRITE_LOCK;
6158 break;
6159 case POSIX_LOCK_TYPE_UNLOCK:
6160 lock_type = UNLOCK_LOCK;
6161 break;
6162 default:
6163 return NT_STATUS_INVALID_PARAMETER;
6164 }
6165
6166 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
6167 blocking_lock = False;
6168 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
6169 blocking_lock = True;
6170 } else {
6171 return NT_STATUS_INVALID_PARAMETER;
6172 }
6173
6174 if (!lp_blocking_locks(SNUM(conn))) {
6175 blocking_lock = False;
6176 }
6177
6178 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
6179 #if defined(HAVE_LONGLONG)
6180 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
6181 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
6182 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
6183 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
6184 #else /* HAVE_LONGLONG */
6185 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
6186 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
6187 #endif /* HAVE_LONGLONG */
6188
6189 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6190 "lock_pid = %u, count = %.0f, offset = %.0f\n",
6191 fsp_str_dbg(fsp),
6192 (unsigned int)lock_type,
6193 (unsigned int)lock_pid,
6194 (double)count,
6195 (double)offset ));
6196
6197 if (lock_type == UNLOCK_LOCK) {
6198 status = do_unlock(smbd_messaging_context(),
6199 fsp,
6200 lock_pid,
6201 count,
6202 offset,
6203 POSIX_LOCK);
6204 } else {
6205 uint32 block_smbpid;
6206
6207 struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
6208 fsp,
6209 lock_pid,
6210 count,
6211 offset,
6212 lock_type,
6213 POSIX_LOCK,
6214 blocking_lock,
6215 &status,
6216 &block_smbpid,
6217 NULL);
6218
6219 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
6220 /*
6221 * A blocking lock was requested. Package up
6222 * this smb into a queued request and push it
6223 * onto the blocking lock queue.
6224 */
6225 if(push_blocking_lock_request(br_lck,
6226 req,
6227 fsp,
6228 -1, /* infinite timeout. */
6229 0,
6230 lock_pid,
6231 lock_type,
6232 POSIX_LOCK,
6233 offset,
6234 count,
6235 block_smbpid)) {
6236 TALLOC_FREE(br_lck);
6237 return status;
6238 }
6239 }
6240 TALLOC_FREE(br_lck);
6241 }
6242
6243 return status;
6244 }
6245
6246 /****************************************************************************
6247 Deal with SMB_SET_FILE_BASIC_INFO.
6248 ****************************************************************************/
6249
6250 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
6251 const char *pdata,
6252 int total_data,
6253 files_struct *fsp,
6254 const struct smb_filename *smb_fname)
6255 {
6256 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6257 struct smb_file_time ft;
6258 uint32 dosmode = 0;
6259 NTSTATUS status = NT_STATUS_OK;
6260
6261 ZERO_STRUCT(ft);
6262
6263 if (total_data < 36) {
6264 return NT_STATUS_INVALID_PARAMETER;
6265 }
6266
6267 /* Set the attributes */
6268 dosmode = IVAL(pdata,32);
6269 status = smb_set_file_dosmode(conn, smb_fname, dosmode);
6270 if (!NT_STATUS_IS_OK(status)) {
6271 return status;
6272 }
6273
6274 /* create time */
6275 ft.create_time = interpret_long_date(pdata);
6276
6277 /* access time */
6278 ft.atime = interpret_long_date(pdata+8);
6279
6280 /* write time. */
6281 ft.mtime = interpret_long_date(pdata+16);
6282
6283 /* change time. */
6284 ft.ctime = interpret_long_date(pdata+24);
6285
6286 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6287 smb_fname_str_dbg(smb_fname)));
6288
6289 return smb_set_file_time(conn, fsp, smb_fname, &ft,
6290 true);
6291 }
6292
6293 /****************************************************************************
6294 Deal with SMB_INFO_STANDARD.
6295 ****************************************************************************/
6296
6297 static NTSTATUS smb_set_info_standard(connection_struct *conn,
6298 const char *pdata,
6299 int total_data,
6300 files_struct *fsp,
6301 const struct smb_filename *smb_fname)
6302 {
6303 struct smb_file_time ft;
6304
6305 ZERO_STRUCT(ft);
6306
6307 if (total_data < 12) {
6308 return NT_STATUS_INVALID_PARAMETER;
6309 }
6310
6311 /* create time */
6312 ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
6313 /* access time */
6314 ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
6315 /* write time */
6316 ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
6317
6318 DEBUG(10,("smb_set_info_standard: file %s\n",
6319 smb_fname_str_dbg(smb_fname)));
6320
6321 return smb_set_file_time(conn,
6322 fsp,
6323 smb_fname,
6324 &ft,
6325 true);
6326 }
6327
6328 /****************************************************************************
6329 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6330 ****************************************************************************/
6331
6332 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
6333 struct smb_request *req,
6334 const char *pdata,
6335 int total_data,
6336 files_struct *fsp,
6337 struct smb_filename *smb_fname)
6338 {
6339 uint64_t allocation_size = 0;
6340 NTSTATUS status = NT_STATUS_OK;
6341 files_struct *new_fsp = NULL;
6342
6343 if (!VALID_STAT(smb_fname->st)) {
6344 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6345 }
6346
6347 if (total_data < 8) {
6348 return NT_STATUS_INVALID_PARAMETER;
6349 }
6350
6351 allocation_size = (uint64_t)IVAL(pdata,0);
6352 #ifdef LARGE_SMB_OFF_T
6353 allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
6354 #else /* LARGE_SMB_OFF_T */
6355 if (IVAL(pdata,4) != 0) {
6356 /* more than 32 bits? */
6357 return NT_STATUS_INVALID_PARAMETER;
6358 }
6359 #endif /* LARGE_SMB_OFF_T */
6360
6361 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6362 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6363 (double)allocation_size));
6364
6365 if (allocation_size) {
6366 allocation_size = smb_roundup(conn, allocation_size);
6367 }
6368
6369 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6370 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
6371 (double)allocation_size));
6372
6373 if (fsp && fsp->fh->fd != -1) {
6374 /* Open file handle. */
6375 /* Only change if needed. */
6376 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6377 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
6378 return map_nt_error_from_unix(errno);
6379 }
6380 }
6381 /* But always update the time. */
6382 /*
6383 * This is equivalent to a write. Ensure it's seen immediately
6384 * if there are no pending writes.
6385 */
6386 trigger_write_time_update_immediate(fsp);
6387 return NT_STATUS_OK;
6388 }
6389
6390 /* Pathname or stat or directory file. */
6391 status = SMB_VFS_CREATE_FILE(
6392 conn, /* conn */
6393 req, /* req */
6394 0, /* root_dir_fid */
6395 smb_fname, /* fname */
6396 FILE_WRITE_DATA, /* access_mask */
6397 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
6398 FILE_SHARE_DELETE),
6399 FILE_OPEN, /* create_disposition*/
6400 0, /* create_options */
6401 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
6402 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
6403 0, /* allocation_size */
6404 NULL, /* sd */
6405 NULL, /* ea_list */
6406 &new_fsp, /* result */
6407 NULL); /* pinfo */
6408
6409 if (!NT_STATUS_IS_OK(status)) {
6410 /* NB. We check for open_was_deferred in the caller. */
6411 return status;
6412 }
6413
6414 /* Only change if needed. */
6415 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6416 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
6417 status = map_nt_error_from_unix(errno);
6418 close_file(req, new_fsp, NORMAL_CLOSE);
6419 return status;
6420 }
6421 }
6422
6423 /* Changing the allocation size should set the last mod time. */
6424 /*
6425 * This is equivalent to a write. Ensure it's seen immediately
6426 * if there are no pending writes.
6427 */
6428 trigger_write_time_update_immediate(new_fsp);
6429
6430 close_file(req, new_fsp, NORMAL_CLOSE);
6431 return NT_STATUS_OK;
6432 }
6433
6434 /****************************************************************************
6435 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6436 ****************************************************************************/
6437
6438 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
6439 struct smb_request *req,
6440 const char *pdata,
6441 int total_data,
6442 files_struct *fsp,
6443 const struct smb_filename *smb_fname,
6444 bool fail_after_createfile)
6445 {
6446 SMB_OFF_T size;
6447
6448 if (total_data < 8) {
6449 return NT_STATUS_INVALID_PARAMETER;
6450 }
6451
6452 size = IVAL(pdata,0);
6453 #ifdef LARGE_SMB_OFF_T
6454 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6455 #else /* LARGE_SMB_OFF_T */
6456 if (IVAL(pdata,4) != 0) {
6457 /* more than 32 bits? */
6458 return NT_STATUS_INVALID_PARAMETER;
6459 }
6460 #endif /* LARGE_SMB_OFF_T */
6461 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6462 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6463 (double)size));
6464
6465 return smb_set_file_size(conn, req,
6466 fsp,
6467 smb_fname,
6468 &smb_fname->st,
6469 size,
6470 fail_after_createfile);
6471 }
6472
6473 /****************************************************************************
6474 Allow a UNIX info mknod.
6475 ****************************************************************************/
6476
6477 static NTSTATUS smb_unix_mknod(connection_struct *conn,
6478 const char *pdata,
6479 int total_data,
6480 const struct smb_filename *smb_fname)
6481 {
6482 uint32 file_type = IVAL(pdata,56);
6483 #if defined(HAVE_MAKEDEV)
6484 uint32 dev_major = IVAL(pdata,60);
6485 uint32 dev_minor = IVAL(pdata,68);
6486 #endif
6487 SMB_DEV_T dev = (SMB_DEV_T)0;
6488 uint32 raw_unixmode = IVAL(pdata,84);
6489 NTSTATUS status;
6490 mode_t unixmode;
6491
6492 if (total_data < 100) {
6493 return NT_STATUS_INVALID_PARAMETER;
6494 }
6495
6496 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6497 PERM_NEW_FILE, &unixmode);
6498 if (!NT_STATUS_IS_OK(status)) {
6499 return status;
6500 }
6501
6502 #if defined(HAVE_MAKEDEV)
6503 dev = makedev(dev_major, dev_minor);
6504 #endif
6505
6506 switch (file_type) {
6507 #if defined(S_IFIFO)
6508 case UNIX_TYPE_FIFO:
6509 unixmode |= S_IFIFO;
6510 break;
6511 #endif
6512 #if defined(S_IFSOCK)
6513 case UNIX_TYPE_SOCKET:
6514 unixmode |= S_IFSOCK;
6515 break;
6516 #endif
6517 #if defined(S_IFCHR)
6518 case UNIX_TYPE_CHARDEV:
6519 unixmode |= S_IFCHR;
6520 break;
6521 #endif
6522 #if defined(S_IFBLK)
6523 case UNIX_TYPE_BLKDEV:
6524 unixmode |= S_IFBLK;
6525 break;
6526 #endif
6527 default:
6528 return NT_STATUS_INVALID_PARAMETER;
6529 }
6530
6531 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6532 "%.0f mode 0%o for file %s\n", (double)dev,
6533 (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
6534
6535 /* Ok - do the mknod. */
6536 if (SMB_VFS_MKNOD(conn, smb_fname->base_name, unixmode, dev) != 0) {
6537 return map_nt_error_from_unix(errno);
6538 }
6539
6540 /* If any of the other "set" calls fail we
6541 * don't want to end up with a half-constructed mknod.
6542 */
6543
6544 if (lp_inherit_perms(SNUM(conn))) {
6545 char *parent;
6546 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
6547 &parent, NULL)) {
6548 return NT_STATUS_NO_MEMORY;
6549 }
6550 inherit_access_posix_acl(conn, parent, smb_fname->base_name,
6551 unixmode);
6552 TALLOC_FREE(parent);
6553 }
6554
6555 return NT_STATUS_OK;
6556 }
6557
6558 /****************************************************************************
6559 Deal with SMB_SET_FILE_UNIX_BASIC.
6560 ****************************************************************************/
6561
6562 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
6563 struct smb_request *req,
6564 const char *pdata,
6565 int total_data,
6566 files_struct *fsp,
6567 const struct smb_filename *smb_fname)
6568 {
6569 struct smb_file_time ft;
6570 uint32 raw_unixmode;
6571 mode_t unixmode;
6572 SMB_OFF_T size = 0;
6573 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
6574 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
6575 NTSTATUS status = NT_STATUS_OK;
6576 bool delete_on_fail = False;
6577 enum perm_type ptype;
6578 files_struct *all_fsps = NULL;
6579 bool modify_mtime = true;
6580 struct file_id id;
6581 SMB_STRUCT_STAT sbuf;
6582
6583 ZERO_STRUCT(ft);
6584
6585 if (total_data < 100) {
6586 return NT_STATUS_INVALID_PARAMETER;
6587 }
6588
6589 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
6590 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
6591 size=IVAL(pdata,0); /* first 8 Bytes are size */
6592 #ifdef LARGE_SMB_OFF_T
6593 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6594 #else /* LARGE_SMB_OFF_T */
6595 if (IVAL(pdata,4) != 0) {
6596 /* more than 32 bits? */
6597 return NT_STATUS_INVALID_PARAMETER;
6598 }
6599 #endif /* LARGE_SMB_OFF_T */
6600 }
6601
6602 ft.atime = interpret_long_date(pdata+24); /* access_time */
6603 ft.mtime = interpret_long_date(pdata+32); /* modification_time */
6604 set_owner = (uid_t)IVAL(pdata,40);
6605 set_grp = (gid_t)IVAL(pdata,48);
6606 raw_unixmode = IVAL(pdata,84);
6607
6608 if (VALID_STAT(smb_fname->st)) {
6609 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
6610 ptype = PERM_EXISTING_DIR;
6611 } else {
6612 ptype = PERM_EXISTING_FILE;
6613 }
6614 } else {
6615 ptype = PERM_NEW_FILE;
6616 }
6617
6618 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6619 ptype, &unixmode);
6620 if (!NT_STATUS_IS_OK(status)) {
6621 return status;
6622 }
6623
6624 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6625 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6626 smb_fname_str_dbg(smb_fname), (double)size,
6627 (unsigned int)set_owner, (unsigned int)set_grp,
6628 (int)raw_unixmode));
6629
6630 sbuf = smb_fname->st;
6631
6632 if (!VALID_STAT(sbuf)) {
6633 struct smb_filename *smb_fname_tmp = NULL;
6634 /*
6635 * The only valid use of this is to create character and block
6636 * devices, and named pipes. This is deprecated (IMHO) and
6637 * a new info level should be used for mknod. JRA.
6638 */
6639
6640 status = smb_unix_mknod(conn,
6641 pdata,
6642 total_data,
6643 smb_fname);
6644 if (!NT_STATUS_IS_OK(status)) {
6645 return status;
6646 }
6647
6648 status = copy_smb_filename(talloc_tos(), smb_fname,
6649 &smb_fname_tmp);
6650 if (!NT_STATUS_IS_OK(status)) {
6651 return status;
6652 }
6653
6654 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
6655 status = map_nt_error_from_unix(errno);
6656 TALLOC_FREE(smb_fname_tmp);
6657 SMB_VFS_UNLINK(conn, smb_fname);
6658 return status;
6659 }
6660
6661 sbuf = smb_fname_tmp->st;
6662 TALLOC_FREE(smb_fname_tmp);
6663
6664 /* Ensure we don't try and change anything else. */
6665 raw_unixmode = SMB_MODE_NO_CHANGE;
6666 size = get_file_size_stat(&sbuf);
6667 ft.atime = sbuf.st_ex_atime;
6668 ft.mtime = sbuf.st_ex_mtime;
6669 /*
6670 * We continue here as we might want to change the
6671 * owner uid/gid.
6672 */
6673 delete_on_fail = True;
6674 }
6675
6676 #if 1
6677 /* Horrible backwards compatibility hack as an old server bug
6678 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6679 * */
6680
6681 if (!size) {
6682 size = get_file_size_stat(&sbuf);
6683 }
6684 #endif
6685
6686 /*
6687 * Deal with the UNIX specific mode set.
6688 */
6689
6690 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
6691 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6692 "setting mode 0%o for file %s\n",
6693 (unsigned int)unixmode,
6694 smb_fname_str_dbg(smb_fname)));
6695 if (SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode) != 0) {
6696 return map_nt_error_from_unix(errno);
6697 }
6698 }
6699
6700 /*
6701 * Deal with the UNIX specific uid set.
6702 */
6703
6704 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
6705 (sbuf.st_ex_uid != set_owner)) {
6706 int ret;
6707
6708 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6709 "changing owner %u for path %s\n",
6710 (unsigned int)set_owner,
6711 smb_fname_str_dbg(smb_fname)));
6712
6713 if (S_ISLNK(sbuf.st_ex_mode)) {
6714 ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name,
6715 set_owner, (gid_t)-1);
6716 } else {
6717 ret = SMB_VFS_CHOWN(conn, smb_fname->base_name,
6718 set_owner, (gid_t)-1);
6719 }
6720
6721 if (ret != 0) {
6722 status = map_nt_error_from_unix(errno);
6723 if (delete_on_fail) {
6724 SMB_VFS_UNLINK(conn, smb_fname);
6725 }
6726 return status;
6727 }
6728 }
6729
6730 /*
6731 * Deal with the UNIX specific gid set.
6732 */
6733
6734 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
6735 (sbuf.st_ex_gid != set_grp)) {
6736 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6737 "changing group %u for file %s\n",
6738 (unsigned int)set_owner,
6739 smb_fname_str_dbg(smb_fname)));
6740 if (SMB_VFS_CHOWN(conn, smb_fname->base_name, (uid_t)-1,
6741 set_grp) != 0) {
6742 status = map_nt_error_from_unix(errno);
6743 if (delete_on_fail) {
6744 SMB_VFS_UNLINK(conn, smb_fname);
6745 }
6746 return status;
6747 }
6748 }
6749
6750 /* Deal with any size changes. */
6751
6752 status = smb_set_file_size(conn, req,
6753 fsp,
6754 smb_fname,
6755 &sbuf,
6756 size,
6757 false);
6758 if (!NT_STATUS_IS_OK(status)) {
6759 return status;
6760 }
6761
6762 /* Deal with any time changes. */
6763 if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
6764 /* No change, don't cancel anything. */
6765 return status;
6766 }
6767
6768 id = vfs_file_id_from_sbuf(conn, &sbuf);
6769 for(all_fsps = file_find_di_first(id); all_fsps;
6770 all_fsps = file_find_di_next(all_fsps)) {
6771 /*
6772 * We're setting the time explicitly for UNIX.
6773 * Cancel any pending changes over all handles.
6774 */
6775 all_fsps->update_write_time_on_close = false;
6776 TALLOC_FREE(all_fsps->update_write_time_event);
6777 }
6778
6779 /*
6780 * Override the "setting_write_time"
6781 * parameter here as it almost does what
6782 * we need. Just remember if we modified
6783 * mtime and send the notify ourselves.
6784 */
6785 if (null_timespec(ft.mtime)) {
6786 modify_mtime = false;
6787 }
6788
6789 status = smb_set_file_time(conn,
6790 fsp,
6791 smb_fname,
6792 &ft,
6793 false);
6794 if (modify_mtime) {
6795 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
6796 FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
6797 }
6798 return status;
6799 }
6800
6801 /****************************************************************************
6802 Deal with SMB_SET_FILE_UNIX_INFO2.
6803 ****************************************************************************/
6804
6805 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
6806 struct smb_request *req,
6807 const char *pdata,
6808 int total_data,
6809 files_struct *fsp,
6810 const struct smb_filename *smb_fname)
6811 {
6812 NTSTATUS status;
6813 uint32 smb_fflags;
6814 uint32 smb_fmask;
6815
6816 if (total_data < 116) {
6817 return NT_STATUS_INVALID_PARAMETER;
6818 }
6819
6820 /* Start by setting all the fields that are common between UNIX_BASIC
6821 * and UNIX_INFO2.
6822 */
6823 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
6824 fsp, smb_fname);
6825 if (!NT_STATUS_IS_OK(status)) {
6826 return status;
6827 }
6828
6829 smb_fflags = IVAL(pdata, 108);
6830 smb_fmask = IVAL(pdata, 112);
6831
6832 /* NB: We should only attempt to alter the file flags if the client
6833 * sends a non-zero mask.
6834 */
6835 if (smb_fmask != 0) {
6836 int stat_fflags = 0;
6837
6838 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
6839 smb_fmask, &stat_fflags)) {
6840 /* Client asked to alter a flag we don't understand. */
6841 return NT_STATUS_INVALID_PARAMETER;
6842 }
6843
6844 if (fsp && fsp->fh->fd != -1) {
6845 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
6846 return NT_STATUS_NOT_SUPPORTED;
6847 } else {
6848 if (SMB_VFS_CHFLAGS(conn, smb_fname->base_name,
6849 stat_fflags) != 0) {
6850 return map_nt_error_from_unix(errno);
6851 }
6852 }
6853 }
6854
6855 /* XXX: need to add support for changing the create_time here. You
6856 * can do this for paths on Darwin with setattrlist(2). The right way
6857 * to hook this up is probably by extending the VFS utimes interface.
6858 */
6859
6860 return NT_STATUS_OK;
6861 }
6862
6863 /****************************************************************************
6864 Create a directory with POSIX semantics.
6865 ****************************************************************************/
6866
6867 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
6868 struct smb_request *req,
6869 char **ppdata,
6870 int total_data,
6871 struct smb_filename *smb_fname,
6872 int *pdata_return_size)
6873 {
6874 NTSTATUS status = NT_STATUS_OK;
6875 uint32 raw_unixmode = 0;
6876 uint32 mod_unixmode = 0;
6877 mode_t unixmode = (mode_t)0;
6878 files_struct *fsp = NULL;
6879 uint16 info_level_return = 0;
6880 int info;
6881 char *pdata = *ppdata;
6882
6883 if (total_data < 18) {
6884 return NT_STATUS_INVALID_PARAMETER;
6885 }
6886
6887 raw_unixmode = IVAL(pdata,8);
6888 /* Next 4 bytes are not yet defined. */
6889
6890 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6891 PERM_NEW_DIR, &unixmode);
6892 if (!NT_STATUS_IS_OK(status)) {
6893 return status;
6894 }
6895
6896 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
6897
6898 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
6899 smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
6900
6901 status = SMB_VFS_CREATE_FILE(
6902 conn, /* conn */
6903 req, /* req */
6904 0, /* root_dir_fid */
6905 smb_fname, /* fname */
6906 FILE_READ_ATTRIBUTES, /* access_mask */
6907 FILE_SHARE_NONE, /* share_access */
6908 FILE_CREATE, /* create_disposition*/
6909 FILE_DIRECTORY_FILE, /* create_options */
6910 mod_unixmode, /* file_attributes */
6911 0, /* oplock_request */
6912 0, /* allocation_size */
6913 NULL, /* sd */
6914 NULL, /* ea_list */
6915 &fsp, /* result */
6916 &info); /* pinfo */
6917
6918 if (NT_STATUS_IS_OK(status)) {
6919 close_file(req, fsp, NORMAL_CLOSE);
6920 }
6921
6922 info_level_return = SVAL(pdata,16);
6923
6924 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
6925 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
6926 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
6927 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
6928 } else {
6929 *pdata_return_size = 12;
6930 }
6931
6932 /* Realloc the data size */
6933 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
6934 if (*ppdata == NULL) {
6935 *pdata_return_size = 0;
6936 return NT_STATUS_NO_MEMORY;
6937 }
6938 pdata = *ppdata;
6939
6940 SSVAL(pdata,0,NO_OPLOCK_RETURN);
6941 SSVAL(pdata,2,0); /* No fnum. */
6942 SIVAL(pdata,4,info); /* Was directory created. */
6943
6944 switch (info_level_return) {
6945 case SMB_QUERY_FILE_UNIX_BASIC:
6946 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
6947 SSVAL(pdata,10,0); /* Padding. */
6948 store_file_unix_basic(conn, pdata + 12, fsp,
6949 &smb_fname->st);
6950 break;
6951 case SMB_QUERY_FILE_UNIX_INFO2:
6952 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
6953 SSVAL(pdata,10,0); /* Padding. */
6954 store_file_unix_basic_info2(conn, pdata + 12, fsp,
6955 &smb_fname->st);
6956 break;
6957 default:
6958 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
6959 SSVAL(pdata,10,0); /* Padding. */
6960 break;
6961 }
6962
6963 return status;
6964 }
6965
6966 /****************************************************************************
6967 Open/Create a file with POSIX semantics.
6968 ****************************************************************************/
6969
6970 static NTSTATUS smb_posix_open(connection_struct *conn,
6971 struct smb_request *req,
6972 char **ppdata,
6973 int total_data,
6974 struct smb_filename *smb_fname,
6975 int *pdata_return_size)
6976 {
6977 bool extended_oplock_granted = False;
6978 char *pdata = *ppdata;
6979 uint32 flags = 0;
6980 uint32 wire_open_mode = 0;
6981 uint32 raw_unixmode = 0;
6982 uint32 mod_unixmode = 0;
6983 uint32 create_disp = 0;
6984 uint32 access_mask = 0;
6985 uint32 create_options = 0;
6986 NTSTATUS status = NT_STATUS_OK;
6987 mode_t unixmode = (mode_t)0;
6988 files_struct *fsp = NULL;
6989 int oplock_request = 0;
6990 int info = 0;
6991 uint16 info_level_return = 0;
6992
6993 if (total_data < 18) {
6994 return NT_STATUS_INVALID_PARAMETER;
6995 }
6996
6997 flags = IVAL(pdata,0);
6998 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
6999 if (oplock_request) {
7000 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
7001 }
7002
7003 wire_open_mode = IVAL(pdata,4);
7004
7005 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
7006 return smb_posix_mkdir(conn, req,
7007 ppdata,
7008 total_data,
7009 smb_fname,
7010 pdata_return_size);
7011 }
7012
7013 switch (wire_open_mode & SMB_ACCMODE) {
7014 case SMB_O_RDONLY:
7015 access_mask = FILE_READ_DATA;
7016 break;
7017 case SMB_O_WRONLY:
7018 access_mask = FILE_WRITE_DATA;
7019 break;
7020 case SMB_O_RDWR:
7021 access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
7022 break;
7023 default:
7024 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7025 (unsigned int)wire_open_mode ));
7026 return NT_STATUS_INVALID_PARAMETER;
7027 }
7028
7029 wire_open_mode &= ~SMB_ACCMODE;
7030
7031 if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
7032 create_disp = FILE_CREATE;
7033 } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
7034 create_disp = FILE_OVERWRITE_IF;
7035 } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
7036 create_disp = FILE_OPEN_IF;
7037 } else if ((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL | SMB_O_TRUNC)) == 0) {
7038 create_disp = FILE_OPEN;
7039 } else {
7040 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7041 (unsigned int)wire_open_mode ));
7042 return NT_STATUS_INVALID_PARAMETER;
7043 }
7044
7045 raw_unixmode = IVAL(pdata,8);
7046 /* Next 4 bytes are not yet defined. */
7047
7048 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7049 (VALID_STAT(smb_fname->st) ?
7050 PERM_EXISTING_FILE : PERM_NEW_FILE),
7051 &unixmode);
7052
7053 if (!NT_STATUS_IS_OK(status)) {
7054 return status;
7055 }
7056
7057 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7058
7059 if (wire_open_mode & SMB_O_SYNC) {
7060 create_options |= FILE_WRITE_THROUGH;
7061 }
7062 if (wire_open_mode & SMB_O_APPEND) {
7063 access_mask |= FILE_APPEND_DATA;
7064 }
7065 if (wire_open_mode & SMB_O_DIRECT) {
7066 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
7067 }
7068
7069 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7070 smb_fname_str_dbg(smb_fname),
7071 (unsigned int)wire_open_mode,
7072 (unsigned int)unixmode ));
7073
7074 status = SMB_VFS_CREATE_FILE(
7075 conn, /* conn */
7076 req, /* req */
7077 0, /* root_dir_fid */
7078 smb_fname, /* fname */
7079 access_mask, /* access_mask */
7080 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7081 FILE_SHARE_DELETE),
7082 create_disp, /* create_disposition*/
7083 FILE_NON_DIRECTORY_FILE, /* create_options */
7084 mod_unixmode, /* file_attributes */
7085 oplock_request, /* oplock_request */
7086 0, /* allocation_size */
7087 NULL, /* sd */
7088 NULL, /* ea_list */
7089 &fsp, /* result */
7090 &info); /* pinfo */
7091
7092 if (!NT_STATUS_IS_OK(status)) {
7093 return status;
7094 }
7095
7096 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
7097 extended_oplock_granted = True;
7098 }
7099
7100 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
7101 extended_oplock_granted = True;
7102 }
7103
7104 info_level_return = SVAL(pdata,16);
7105
7106 /* Allocate the correct return size. */
7107
7108 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7109 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7110 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7111 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7112 } else {
7113 *pdata_return_size = 12;
7114 }
7115
7116 /* Realloc the data size */
7117 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7118 if (*ppdata == NULL) {
7119 close_file(req, fsp, ERROR_CLOSE);
7120 *pdata_return_size = 0;
7121 return NT_STATUS_NO_MEMORY;
7122 }
7123 pdata = *ppdata;
7124
7125 if (extended_oplock_granted) {
7126 if (flags & REQUEST_BATCH_OPLOCK) {
7127 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
7128 } else {
7129 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
7130 }
7131 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
7132 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
7133 } else {
7134 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7135 }
7136
7137 SSVAL(pdata,2,fsp->fnum);
7138 SIVAL(pdata,4,info); /* Was file created etc. */
7139
7140 switch (info_level_return) {
7141 case SMB_QUERY_FILE_UNIX_BASIC:
7142 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7143 SSVAL(pdata,10,0); /* padding. */
7144 store_file_unix_basic(conn, pdata + 12, fsp,
7145 &smb_fname->st);
7146 break;
7147 case SMB_QUERY_FILE_UNIX_INFO2:
7148 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7149 SSVAL(pdata,10,0); /* padding. */
7150 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7151 &smb_fname->st);
7152 break;
7153 default:
7154 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7155 SSVAL(pdata,10,0); /* padding. */
7156 break;
7157 }
7158 return NT_STATUS_OK;
7159 }
7160
7161 /****************************************************************************
7162 Delete a file with POSIX semantics.
7163 ****************************************************************************/
7164
7165 static NTSTATUS smb_posix_unlink(connection_struct *conn,
7166 struct smb_request *req,
7167 const char *pdata,
7168 int total_data,
7169 struct smb_filename *smb_fname)
7170 {
7171 NTSTATUS status = NT_STATUS_OK;
7172 files_struct *fsp = NULL;
7173 uint16 flags = 0;
7174 char del = 1;
7175 int info = 0;
7176 int create_options = 0;
7177 int i;
7178 struct share_mode_lock *lck = NULL;
7179
7180 if (total_data < 2) {
7181 return NT_STATUS_INVALID_PARAMETER;
7182 }
7183
7184 flags = SVAL(pdata,0);
7185
7186 if (!VALID_STAT(smb_fname->st)) {
7187 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7188 }
7189
7190 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
7191 !VALID_STAT_OF_DIR(smb_fname->st)) {
7192 return NT_STATUS_NOT_A_DIRECTORY;
7193 }
7194
7195 DEBUG(10,("smb_posix_unlink: %s %s\n",
7196 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
7197 smb_fname_str_dbg(smb_fname)));
7198
7199 if (VALID_STAT_OF_DIR(smb_fname->st)) {
7200 create_options |= FILE_DIRECTORY_FILE;
7201 }
7202
7203 status = SMB_VFS_CREATE_FILE(
7204 conn, /* conn */
7205 req, /* req */
7206 0, /* root_dir_fid */
7207 smb_fname, /* fname */
7208 DELETE_ACCESS, /* access_mask */
7209 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7210 FILE_SHARE_DELETE),
7211 FILE_OPEN, /* create_disposition*/
7212 create_options, /* create_options */
7213 FILE_FLAG_POSIX_SEMANTICS|0777, /* file_attributes */
7214 0, /* oplock_request */
7215 0, /* allocation_size */
7216 NULL, /* sd */
7217 NULL, /* ea_list */
7218 &fsp, /* result */
7219 &info); /* pinfo */
7220
7221 if (!NT_STATUS_IS_OK(status)) {
7222 return status;
7223 }
7224
7225 /*
7226 * Don't lie to client. If we can't really delete due to
7227 * non-POSIX opens return SHARING_VIOLATION.
7228 */
7229
7230 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
7231 NULL);
7232 if (lck == NULL) {
7233 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7234 "lock for file %s\n", fsp_str_dbg(fsp)));
7235 close_file(req, fsp, NORMAL_CLOSE);
7236 return NT_STATUS_INVALID_PARAMETER;
7237 }
7238
7239 /*
7240 * See if others still have the file open. If this is the case, then
7241 * don't delete. If all opens are POSIX delete we can set the delete
7242 * on close disposition.
7243 */
7244 for (i=0; i<lck->num_share_modes; i++) {
7245 struct share_mode_entry *e = &lck->share_modes[i];
7246 if (is_valid_share_mode_entry(e)) {
7247 if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
7248 continue;
7249 }
7250 /* Fail with sharing violation. */
7251 close_file(req, fsp, NORMAL_CLOSE);
7252 TALLOC_FREE(lck);
7253 return NT_STATUS_SHARING_VIOLATION;
7254 }
7255 }
7256
7257 /*
7258 * Set the delete on close.
7259 */
7260 status = smb_set_file_disposition_info(conn,
7261 &del,
7262 1,
7263 fsp,
7264 smb_fname);
7265
7266 if (!NT_STATUS_IS_OK(status)) {
7267 close_file(req, fsp, NORMAL_CLOSE);
7268 TALLOC_FREE(lck);
7269 return status;
7270 }
7271 TALLOC_FREE(lck);
7272 return close_file(req, fsp, NORMAL_CLOSE);
7273 }
7274
7275 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
7276 struct smb_request *req,
7277 TALLOC_CTX *mem_ctx,
7278 uint16_t info_level,
7279 files_struct *fsp,
7280 struct smb_filename *smb_fname,
7281 char **ppdata, int total_data,
7282 int *ret_data_size)
7283 {
7284 char *pdata = *ppdata;
7285 NTSTATUS status = NT_STATUS_OK;
7286 int data_return_size = 0;
7287
7288 *ret_data_size = 0;
7289
7290 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
7291 return NT_STATUS_INVALID_LEVEL;
7292 }
7293
7294 if (!CAN_WRITE(conn)) {
7295 /* Allow POSIX opens. The open path will deny
7296 * any non-readonly opens. */
7297 if (info_level != SMB_POSIX_PATH_OPEN) {
7298 return NT_STATUS_DOS(ERRSRV, ERRaccess);
7299 }
7300 }
7301
7302 DEBUG(3,("smbd_do_setfilepathinfo: %s (fnum %d) info_level=%d "
7303 "totdata=%d\n", smb_fname_str_dbg(smb_fname),
7304 fsp ? fsp->fnum : -1, info_level, total_data));
7305
7306 switch (info_level) {
7307
7308 case SMB_INFO_STANDARD:
7309 {
7310 status = smb_set_info_standard(conn,
7311 pdata,
7312 total_data,
7313 fsp,
7314 smb_fname);
7315 break;
7316 }
7317
7318 case SMB_INFO_SET_EA:
7319 {
7320 status = smb_info_set_ea(conn,
7321 pdata,
7322 total_data,
7323 fsp,
7324 smb_fname);
7325 break;
7326 }
7327
7328 case SMB_SET_FILE_BASIC_INFO:
7329 case SMB_FILE_BASIC_INFORMATION:
7330 {
7331 status = smb_set_file_basic_info(conn,
7332 pdata,
7333 total_data,
7334 fsp,
7335 smb_fname);
7336 break;
7337 }
7338
7339 case SMB_FILE_ALLOCATION_INFORMATION:
7340 case SMB_SET_FILE_ALLOCATION_INFO:
7341 {
7342 status = smb_set_file_allocation_info(conn, req,
7343 pdata,
7344 total_data,
7345 fsp,
7346 smb_fname);
7347 break;
7348 }
7349
7350 case SMB_FILE_END_OF_FILE_INFORMATION:
7351 case SMB_SET_FILE_END_OF_FILE_INFO:
7352 {
7353 /*
7354 * XP/Win7 both fail after the createfile with
7355 * SMB_SET_FILE_END_OF_FILE_INFO but not
7356 * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
7357 * The level is known here, so pass it down
7358 * appropriately.
7359 */
7360 bool should_fail =
7361 (info_level == SMB_SET_FILE_END_OF_FILE_INFO);
7362
7363 status = smb_set_file_end_of_file_info(conn, req,
7364 pdata,
7365 total_data,
7366 fsp,
7367 smb_fname,
7368 should_fail);
7369 break;
7370 }
7371
7372 case SMB_FILE_DISPOSITION_INFORMATION:
7373 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
7374 {
7375 #if 0
7376 /* JRA - We used to just ignore this on a path ?
7377 * Shouldn't this be invalid level on a pathname
7378 * based call ?
7379 */
7380 if (tran_call != TRANSACT2_SETFILEINFO) {
7381 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
7382 }
7383 #endif
7384 status = smb_set_file_disposition_info(conn,
7385 pdata,
7386 total_data,
7387 fsp,
7388 smb_fname);
7389 break;
7390 }
7391
7392 case SMB_FILE_POSITION_INFORMATION:
7393 {
7394 status = smb_file_position_information(conn,
7395 pdata,
7396 total_data,
7397 fsp);
7398 break;
7399 }
7400
7401 case SMB_FILE_FULL_EA_INFORMATION:
7402 {
7403 status = smb_set_file_full_ea_info(conn,
7404 pdata,
7405 total_data,
7406 fsp);
7407 break;
7408 }
7409
7410 /* From tridge Samba4 :
7411 * MODE_INFORMATION in setfileinfo (I have no
7412 * idea what "mode information" on a file is - it takes a value of 0,
7413 * 2, 4 or 6. What could it be?).
7414 */
7415
7416 case SMB_FILE_MODE_INFORMATION:
7417 {
7418 status = smb_file_mode_information(conn,
7419 pdata,
7420 total_data);
7421 break;
7422 }
7423
7424 /*
7425 * CIFS UNIX extensions.
7426 */
7427
7428 case SMB_SET_FILE_UNIX_BASIC:
7429 {
7430 status = smb_set_file_unix_basic(conn, req,
7431 pdata,
7432 total_data,
7433 fsp,
7434 smb_fname);
7435 break;
7436 }
7437
7438 case SMB_SET_FILE_UNIX_INFO2:
7439 {
7440 status = smb_set_file_unix_info2(conn, req,
7441 pdata,
7442 total_data,
7443 fsp,
7444 smb_fname);
7445 break;
7446 }
7447
7448 case SMB_SET_FILE_UNIX_LINK:
7449 {
7450 if (fsp) {
7451 /* We must have a pathname for this. */
7452 return NT_STATUS_INVALID_LEVEL;
7453 }
7454 status = smb_set_file_unix_link(conn, req, pdata,
7455 total_data, smb_fname);
7456 break;
7457 }
7458
7459 case SMB_SET_FILE_UNIX_HLINK:
7460 {
7461 if (fsp) {
7462 /* We must have a pathname for this. */
7463 return NT_STATUS_INVALID_LEVEL;
7464 }
7465 status = smb_set_file_unix_hlink(conn, req,
7466 pdata, total_data,
7467 smb_fname);
7468 break;
7469 }
7470
7471 case SMB_FILE_RENAME_INFORMATION:
7472 {
7473 status = smb_file_rename_information(conn, req,
7474 pdata, total_data,
7475 fsp, smb_fname);
7476 break;
7477 }
7478
7479 #if defined(HAVE_POSIX_ACLS)
7480 case SMB_SET_POSIX_ACL:
7481 {
7482 status = smb_set_posix_acl(conn,
7483 pdata,
7484 total_data,
7485 fsp,
7486 smb_fname);
7487 break;
7488 }
7489 #endif
7490
7491 case SMB_SET_POSIX_LOCK:
7492 {
7493 if (!fsp) {
7494 return NT_STATUS_INVALID_LEVEL;
7495 }
7496 status = smb_set_posix_lock(conn, req,
7497 pdata, total_data, fsp);
7498 break;
7499 }
7500
7501 case SMB_POSIX_PATH_OPEN:
7502 {
7503 if (fsp) {
7504 /* We must have a pathname for this. */
7505 return NT_STATUS_INVALID_LEVEL;
7506 }
7507
7508 status = smb_posix_open(conn, req,
7509 ppdata,
7510 total_data,
7511 smb_fname,
7512 &data_return_size);
7513 break;
7514 }
7515
7516 case SMB_POSIX_PATH_UNLINK:
7517 {
7518 if (fsp) {
7519 /* We must have a pathname for this. */
7520 return NT_STATUS_INVALID_LEVEL;
7521 }
7522
7523 status = smb_posix_unlink(conn, req,
7524 pdata,
7525 total_data,
7526 smb_fname);
7527 break;
7528 }
7529
7530 default:
7531 return NT_STATUS_INVALID_LEVEL;
7532 }
7533
7534 if (!NT_STATUS_IS_OK(status)) {
7535 return status;
7536 }
7537
7538 *ret_data_size = data_return_size;
7539 return NT_STATUS_OK;
7540 }
7541
7542 /****************************************************************************
7543 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7544 ****************************************************************************/
7545
7546 static void call_trans2setfilepathinfo(connection_struct *conn,
7547 struct smb_request *req,
7548 unsigned int tran_call,
7549 char **pparams, int total_params,
7550 char **ppdata, int total_data,
7551 unsigned int max_data_bytes)
7552 {
7553 char *params = *pparams;
7554 char *pdata = *ppdata;
7555 uint16 info_level;
7556 struct smb_filename *smb_fname = NULL;
7557 files_struct *fsp = NULL;
7558 NTSTATUS status = NT_STATUS_OK;
7559 int data_return_size = 0;
7560
7561 if (!params) {
7562 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7563 return;
7564 }
7565
7566 if (tran_call == TRANSACT2_SETFILEINFO) {
7567 if (total_params < 4) {
7568 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7569 return;
7570 }
7571
7572 fsp = file_fsp(req, SVAL(params,0));
7573 /* Basic check for non-null fsp. */
7574 if (!check_fsp_open(conn, req, fsp)) {
7575 return;
7576 }
7577 info_level = SVAL(params,2);
7578
7579 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
7580 &smb_fname);
7581 if (!NT_STATUS_IS_OK(status)) {
7582 reply_nterror(req, status);
7583 return;
7584 }
7585
7586 if(fsp->is_directory || fsp->fh->fd == -1) {
7587 /*
7588 * This is actually a SETFILEINFO on a directory
7589 * handle (returned from an NT SMB). NT5.0 seems
7590 * to do this call. JRA.
7591 */
7592 if (INFO_LEVEL_IS_UNIX(info_level)) {
7593 /* Always do lstat for UNIX calls. */
7594 if (SMB_VFS_LSTAT(conn, smb_fname)) {
7595 DEBUG(3,("call_trans2setfilepathinfo: "
7596 "SMB_VFS_LSTAT of %s failed "
7597 "(%s)\n",
7598 smb_fname_str_dbg(smb_fname),
7599 strerror(errno)));
7600 reply_nterror(req, map_nt_error_from_unix(errno));
7601 return;
7602 }
7603 } else {
7604 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
7605 DEBUG(3,("call_trans2setfilepathinfo: "
7606 "fileinfo of %s failed (%s)\n",
7607 smb_fname_str_dbg(smb_fname),
7608 strerror(errno)));
7609 reply_nterror(req, map_nt_error_from_unix(errno));
7610 return;
7611 }
7612 }
7613 } else if (fsp->print_file) {
7614 /*
7615 * Doing a DELETE_ON_CLOSE should cancel a print job.
7616 */
7617 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
7618 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
7619
7620 DEBUG(3,("call_trans2setfilepathinfo: "
7621 "Cancelling print job (%s)\n",
7622 fsp_str_dbg(fsp)));
7623
7624 SSVAL(params,0,0);
7625 send_trans2_replies(conn, req, params, 2,
7626 *ppdata, 0,
7627 max_data_bytes);
7628 return;
7629 } else {
7630 reply_nterror(req,
7631 NT_STATUS_OBJECT_PATH_NOT_FOUND);
7632 return;
7633 }
7634 } else {
7635 /*
7636 * Original code - this is an open file.
7637 */
7638 if (!check_fsp(conn, req, fsp)) {
7639 return;
7640 }
7641
7642 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
7643 DEBUG(3,("call_trans2setfilepathinfo: fstat "
7644 "of fnum %d failed (%s)\n", fsp->fnum,
7645 strerror(errno)));
7646 reply_nterror(req, map_nt_error_from_unix(errno));
7647 return;
7648 }
7649 }
7650 } else {
7651 char *fname = NULL;
7652
7653 /* set path info */
7654 if (total_params < 7) {
7655 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7656 return;
7657 }
7658
7659 info_level = SVAL(params,0);
7660 srvstr_get_path(req, params, req->flags2, &fname, &params[6],
7661 total_params - 6, STR_TERMINATE,
7662 &status);
7663 if (!NT_STATUS_IS_OK(status)) {
7664 reply_nterror(req, status);
7665 return;
7666 }
7667
7668 status = filename_convert(req, conn,
7669 req->flags2 & FLAGS2_DFS_PATHNAMES,
7670 fname,
7671 0,
7672 NULL,
7673 &smb_fname);
7674 if (!NT_STATUS_IS_OK(status)) {
7675 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7676 reply_botherror(req,
7677 NT_STATUS_PATH_NOT_COVERED,
7678 ERRSRV, ERRbadpath);
7679 return;
7680 }
7681 reply_nterror(req, status);
7682 return;
7683 }
7684
7685 if (INFO_LEVEL_IS_UNIX(info_level)) {
7686 /*
7687 * For CIFS UNIX extensions the target name may not exist.
7688 */
7689
7690 /* Always do lstat for UNIX calls. */
7691 SMB_VFS_LSTAT(conn, smb_fname);
7692
7693 } else if (!VALID_STAT(smb_fname->st) &&
7694 SMB_VFS_STAT(conn, smb_fname)) {
7695 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
7696 "%s failed (%s)\n",
7697 smb_fname_str_dbg(smb_fname),
7698 strerror(errno)));
7699 reply_nterror(req, map_nt_error_from_unix(errno));
7700 return;
7701 }
7702 }
7703
7704 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d "
7705 "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
7706 fsp ? fsp->fnum : -1, info_level,total_data));
7707
7708 /* Realloc the parameter size */
7709 *pparams = (char *)SMB_REALLOC(*pparams,2);
7710 if (*pparams == NULL) {
7711 reply_nterror(req, NT_STATUS_NO_MEMORY);
7712 return;
7713 }
7714 params = *pparams;
7715
7716 SSVAL(params,0,0);
7717
7718 status = smbd_do_setfilepathinfo(conn, req, req,
7719 info_level,
7720 fsp,
7721 smb_fname,
7722 ppdata, total_data,
7723 &data_return_size);
7724 if (!NT_STATUS_IS_OK(status)) {
7725 if (open_was_deferred(req->mid)) {
7726 /* We have re-scheduled this call. */
7727 return;
7728 }
7729 if (blocking_lock_was_deferred(req->mid)) {
7730 /* We have re-scheduled this call. */
7731 return;
7732 }
7733 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7734 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
7735 ERRSRV, ERRbadpath);
7736 return;
7737 }
7738 if (info_level == SMB_POSIX_PATH_OPEN) {
7739 reply_openerror(req, status);
7740 return;
7741 }
7742
7743 reply_nterror(req, status);
7744 return;
7745 }
7746
7747 send_trans2_replies(conn, req, params, 2, *ppdata, data_return_size,
7748 max_data_bytes);
7749
7750 return;
7751 }
7752
7753 /****************************************************************************
7754 Reply to a TRANS2_MKDIR (make directory with extended attributes).
7755 ****************************************************************************/
7756
7757 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
7758 char **pparams, int total_params,
7759 char **ppdata, int total_data,
7760 unsigned int max_data_bytes)
7761 {
7762 struct smb_filename *smb_dname = NULL;
7763 char *params = *pparams;
7764 char *pdata = *ppdata;
7765 char *directory = NULL;
7766 NTSTATUS status = NT_STATUS_OK;
7767 struct ea_list *ea_list = NULL;
7768 TALLOC_CTX *ctx = talloc_tos();
7769
7770 if (!CAN_WRITE(conn)) {
7771 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
7772 return;
7773 }
7774
7775 if (total_params < 5) {
7776 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7777 return;
7778 }
7779
7780 srvstr_get_path(ctx, params, req->flags2, &directory, &params[4],
7781 total_params - 4, STR_TERMINATE,
7782 &status);
7783 if (!NT_STATUS_IS_OK(status)) {
7784 reply_nterror(req, status);
7785 return;
7786 }
7787
7788 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
7789
7790 status = filename_convert(ctx,
7791 conn,
7792 req->flags2 & FLAGS2_DFS_PATHNAMES,
7793 directory,
7794 0,
7795 NULL,
7796 &smb_dname);
7797
7798 if (!NT_STATUS_IS_OK(status)) {
7799 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7800 reply_botherror(req,
7801 NT_STATUS_PATH_NOT_COVERED,
7802 ERRSRV, ERRbadpath);
7803 return;
7804 }
7805 reply_nterror(req, status);
7806 return;
7807 }
7808
7809 /* Any data in this call is an EA list. */
7810 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
7811 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
7812 goto out;
7813 }
7814
7815 /*
7816 * OS/2 workplace shell seems to send SET_EA requests of "null"
7817 * length (4 bytes containing IVAL 4).
7818 * They seem to have no effect. Bug #3212. JRA.
7819 */
7820
7821 if (total_data != 4) {
7822 if (total_data < 10) {
7823 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7824 goto out;
7825 }
7826
7827 if (IVAL(pdata,0) > total_data) {
7828 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
7829 IVAL(pdata,0), (unsigned int)total_data));
7830 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7831 goto out;
7832 }
7833
7834 ea_list = read_ea_list(talloc_tos(), pdata + 4,
7835 total_data - 4);
7836 if (!ea_list) {
7837 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7838 goto out;
7839 }
7840 }
7841 /* If total_data == 4 Windows doesn't care what values
7842 * are placed in that field, it just ignores them.
7843 * The System i QNTC IBM SMB client puts bad values here,
7844 * so ignore them. */
7845
7846 status = create_directory(conn, req, smb_dname);
7847
7848 if (!NT_STATUS_IS_OK(status)) {
7849 reply_nterror(req, status);
7850 goto out;
7851 }
7852
7853 /* Try and set any given EA. */
7854 if (ea_list) {
7855 status = set_ea(conn, NULL, smb_dname, ea_list);
7856 if (!NT_STATUS_IS_OK(status)) {
7857 reply_nterror(req, status);
7858 goto out;
7859 }
7860 }
7861
7862 /* Realloc the parameter and data sizes */
7863 *pparams = (char *)SMB_REALLOC(*pparams,2);
7864 if(*pparams == NULL) {
7865 reply_nterror(req, NT_STATUS_NO_MEMORY);
7866 goto out;
7867 }
7868 params = *pparams;
7869
7870 SSVAL(params,0,0);
7871
7872 send_trans2_replies(conn, req, params, 2, *ppdata, 0, max_data_bytes);
7873
7874 out:
7875 TALLOC_FREE(smb_dname);
7876 return;
7877 }
7878
7879 /****************************************************************************
7880 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
7881 We don't actually do this - we just send a null response.
7882 ****************************************************************************/
7883
7884 static void call_trans2findnotifyfirst(connection_struct *conn,
7885 struct smb_request *req,
7886 char **pparams, int total_params,
7887 char **ppdata, int total_data,
7888 unsigned int max_data_bytes)
7889 {
7890 char *params = *pparams;
7891 uint16 info_level;
7892
7893 if (total_params < 6) {
7894 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7895 return;
7896 }
7897
7898 info_level = SVAL(params,4);
7899 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
7900
7901 switch (info_level) {
7902 case 1:
7903 case 2:
7904 break;
7905 default:
7906 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
7907 return;
7908 }
7909
7910 /* Realloc the parameter and data sizes */
7911 *pparams = (char *)SMB_REALLOC(*pparams,6);
7912 if (*pparams == NULL) {
7913 reply_nterror(req, NT_STATUS_NO_MEMORY);
7914 return;
7915 }
7916 params = *pparams;
7917
7918 SSVAL(params,0,fnf_handle);
7919 SSVAL(params,2,0); /* No changes */
7920 SSVAL(params,4,0); /* No EA errors */
7921
7922 fnf_handle++;
7923
7924 if(fnf_handle == 0)
7925 fnf_handle = 257;
7926
7927 send_trans2_replies(conn, req, params, 6, *ppdata, 0, max_data_bytes);
7928
7929 return;
7930 }
7931
7932 /****************************************************************************
7933 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
7934 changes). Currently this does nothing.
7935 ****************************************************************************/
7936
7937 static void call_trans2findnotifynext(connection_struct *conn,
7938 struct smb_request *req,
7939 char **pparams, int total_params,
7940 char **ppdata, int total_data,
7941 unsigned int max_data_bytes)
7942 {
7943 char *params = *pparams;
7944
7945 DEBUG(3,("call_trans2findnotifynext\n"));
7946
7947 /* Realloc the parameter and data sizes */
7948 *pparams = (char *)SMB_REALLOC(*pparams,4);
7949 if (*pparams == NULL) {
7950 reply_nterror(req, NT_STATUS_NO_MEMORY);
7951 return;
7952 }
7953 params = *pparams;
7954
7955 SSVAL(params,0,0); /* No changes */
7956 SSVAL(params,2,0); /* No EA errors */
7957
7958 send_trans2_replies(conn, req, params, 4, *ppdata, 0, max_data_bytes);
7959
7960 return;
7961 }
7962
7963 /****************************************************************************
7964 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
7965 ****************************************************************************/
7966
7967 static void call_trans2getdfsreferral(connection_struct *conn,
7968 struct smb_request *req,
7969 char **pparams, int total_params,
7970 char **ppdata, int total_data,
7971 unsigned int max_data_bytes)
7972 {
7973 char *params = *pparams;
7974 char *pathname = NULL;
7975 int reply_size = 0;
7976 int max_referral_level;
7977 NTSTATUS status = NT_STATUS_OK;
7978 TALLOC_CTX *ctx = talloc_tos();
7979
7980 DEBUG(10,("call_trans2getdfsreferral\n"));
7981
7982 if (total_params < 3) {
7983 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7984 return;
7985 }
7986
7987 max_referral_level = SVAL(params,0);
7988
7989 if(!lp_host_msdfs()) {
7990 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
7991 return;
7992 }
7993
7994 srvstr_pull_talloc(ctx, params, req->flags2, &pathname, &params[2],
7995 total_params - 2, STR_TERMINATE);
7996 if (!pathname) {
7997 reply_nterror(req, NT_STATUS_NOT_FOUND);
7998 return;
7999 }
8000 if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
8001 ppdata,&status)) < 0) {
8002 reply_nterror(req, status);
8003 return;
8004 }
8005
8006 SSVAL(req->inbuf, smb_flg2,
8007 SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
8008 send_trans2_replies(conn, req,0,0,*ppdata,reply_size, max_data_bytes);
8009
8010 return;
8011 }
8012
8013 #define LMCAT_SPL 0x53
8014 #define LMFUNC_GETJOBID 0x60
8015
8016 /****************************************************************************
8017 Reply to a TRANS2_IOCTL - used for OS/2 printing.
8018 ****************************************************************************/
8019
8020 static void call_trans2ioctl(connection_struct *conn,
8021 struct smb_request *req,
8022 char **pparams, int total_params,
8023 char **ppdata, int total_data,
8024 unsigned int max_data_bytes)
8025 {
8026 char *pdata = *ppdata;
8027 files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
8028
8029 /* check for an invalid fid before proceeding */
8030
8031 if (!fsp) {
8032 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
8033 return;
8034 }
8035
8036 if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
8037 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8038 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
8039 if (*ppdata == NULL) {
8040 reply_nterror(req, NT_STATUS_NO_MEMORY);
8041 return;
8042 }
8043 pdata = *ppdata;
8044
8045 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8046 CAN ACCEPT THIS IN UNICODE. JRA. */
8047
8048 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
8049 srvstr_push(pdata, req->flags2, pdata + 2,
8050 global_myname(), 15,
8051 STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
8052 srvstr_push(pdata, req->flags2, pdata+18,
8053 lp_servicename(SNUM(conn)), 13,
8054 STR_ASCII|STR_TERMINATE); /* Service name */
8055 send_trans2_replies(conn, req, *pparams, 0, *ppdata, 32,
8056 max_data_bytes);
8057 return;
8058 }
8059
8060 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8061 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8062 }
8063
8064 /****************************************************************************
8065 Reply to a SMBfindclose (stop trans2 directory search).
8066 ****************************************************************************/
8067
8068 void reply_findclose(struct smb_request *req)
8069 {
8070 int dptr_num;
8071 struct smbd_server_connection *sconn = smbd_server_conn;
8072
8073 START_PROFILE(SMBfindclose);
8074
8075 if (req->wct < 1) {
8076 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8077 END_PROFILE(SMBfindclose);
8078 return;
8079 }
8080
8081 dptr_num = SVALS(req->vwv+0, 0);
8082
8083 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
8084
8085 dptr_close(sconn, &dptr_num);
8086
8087 reply_outbuf(req, 0, 0);
8088
8089 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
8090
8091 END_PROFILE(SMBfindclose);
8092 return;
8093 }
8094
8095 /****************************************************************************
8096 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8097 ****************************************************************************/
8098
8099 void reply_findnclose(struct smb_request *req)
8100 {
8101 int dptr_num;
8102
8103 START_PROFILE(SMBfindnclose);
8104
8105 if (req->wct < 1) {
8106 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8107 END_PROFILE(SMBfindnclose);
8108 return;
8109 }
8110
8111 dptr_num = SVAL(req->vwv+0, 0);
8112
8113 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
8114
8115 /* We never give out valid handles for a
8116 findnotifyfirst - so any dptr_num is ok here.
8117 Just ignore it. */
8118
8119 reply_outbuf(req, 0, 0);
8120
8121 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
8122
8123 END_PROFILE(SMBfindnclose);
8124 return;
8125 }
8126
8127 static void handle_trans2(connection_struct *conn, struct smb_request *req,
8128 struct trans_state *state)
8129 {
8130 if (get_Protocol() >= PROTOCOL_NT1) {
8131 req->flags2 |= 0x40; /* IS_LONG_NAME */
8132 SSVAL(req->inbuf,smb_flg2,req->flags2);
8133 }
8134
8135 if (conn->encrypt_level == Required && !req->encrypted) {
8136 if (state->call != TRANSACT2_QFSINFO &&
8137 state->call != TRANSACT2_SETFSINFO) {
8138 DEBUG(0,("handle_trans2: encryption required "
8139 "with call 0x%x\n",
8140 (unsigned int)state->call));
8141 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8142 return;
8143 }
8144 }
8145
8146 SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
8147
8148 /* Now we must call the relevant TRANS2 function */
8149 switch(state->call) {
8150 case TRANSACT2_OPEN:
8151 {
8152 START_PROFILE(Trans2_open);
8153 call_trans2open(conn, req,
8154 &state->param, state->total_param,
8155 &state->data, state->total_data,
8156 state->max_data_return);
8157 END_PROFILE(Trans2_open);
8158 break;
8159 }
8160
8161 case TRANSACT2_FINDFIRST:
8162 {
8163 START_PROFILE(Trans2_findfirst);
8164 call_trans2findfirst(conn, req,
8165 &state->param, state->total_param,
8166 &state->data, state->total_data,
8167 state->max_data_return);
8168 END_PROFILE(Trans2_findfirst);
8169 break;
8170 }
8171
8172 case TRANSACT2_FINDNEXT:
8173 {
8174 START_PROFILE(Trans2_findnext);
8175 call_trans2findnext(conn, req,
8176 &state->param, state->total_param,
8177 &state->data, state->total_data,
8178 state->max_data_return);
8179 END_PROFILE(Trans2_findnext);
8180 break;
8181 }
8182
8183 case TRANSACT2_QFSINFO:
8184 {
8185 START_PROFILE(Trans2_qfsinfo);
8186 call_trans2qfsinfo(conn, req,
8187 &state->param, state->total_param,
8188 &state->data, state->total_data,
8189 state->max_data_return);
8190 END_PROFILE(Trans2_qfsinfo);
8191 break;
8192 }
8193
8194 case TRANSACT2_SETFSINFO:
8195 {
8196 START_PROFILE(Trans2_setfsinfo);
8197 call_trans2setfsinfo(conn, req,
8198 &state->param, state->total_param,
8199 &state->data, state->total_data,
8200 state->max_data_return);
8201 END_PROFILE(Trans2_setfsinfo);
8202 break;
8203 }
8204
8205 case TRANSACT2_QPATHINFO:
8206 case TRANSACT2_QFILEINFO:
8207 {
8208 START_PROFILE(Trans2_qpathinfo);
8209 call_trans2qfilepathinfo(conn, req, state->call,
8210 &state->param, state->total_param,
8211 &state->data, state->total_data,
8212 state->max_data_return);
8213 END_PROFILE(Trans2_qpathinfo);
8214 break;
8215 }
8216
8217 case TRANSACT2_SETPATHINFO:
8218 case TRANSACT2_SETFILEINFO:
8219 {
8220 START_PROFILE(Trans2_setpathinfo);
8221 call_trans2setfilepathinfo(conn, req, state->call,
8222 &state->param, state->total_param,
8223 &state->data, state->total_data,
8224 state->max_data_return);
8225 END_PROFILE(Trans2_setpathinfo);
8226 break;
8227 }
8228
8229 case TRANSACT2_FINDNOTIFYFIRST:
8230 {
8231 START_PROFILE(Trans2_findnotifyfirst);
8232 call_trans2findnotifyfirst(conn, req,
8233 &state->param, state->total_param,
8234 &state->data, state->total_data,
8235 state->max_data_return);
8236 END_PROFILE(Trans2_findnotifyfirst);
8237 break;
8238 }
8239
8240 case TRANSACT2_FINDNOTIFYNEXT:
8241 {
8242 START_PROFILE(Trans2_findnotifynext);
8243 call_trans2findnotifynext(conn, req,
8244 &state->param, state->total_param,
8245 &state->data, state->total_data,
8246 state->max_data_return);
8247 END_PROFILE(Trans2_findnotifynext);
8248 break;
8249 }
8250
8251 case TRANSACT2_MKDIR:
8252 {
8253 START_PROFILE(Trans2_mkdir);
8254 call_trans2mkdir(conn, req,
8255 &state->param, state->total_param,
8256 &state->data, state->total_data,
8257 state->max_data_return);
8258 END_PROFILE(Trans2_mkdir);
8259 break;
8260 }
8261
8262 case TRANSACT2_GET_DFS_REFERRAL:
8263 {
8264 START_PROFILE(Trans2_get_dfs_referral);
8265 call_trans2getdfsreferral(conn, req,
8266 &state->param, state->total_param,
8267 &state->data, state->total_data,
8268 state->max_data_return);
8269 END_PROFILE(Trans2_get_dfs_referral);
8270 break;
8271 }
8272
8273 case TRANSACT2_IOCTL:
8274 {
8275 START_PROFILE(Trans2_ioctl);
8276 call_trans2ioctl(conn, req,
8277 &state->param, state->total_param,
8278 &state->data, state->total_data,
8279 state->max_data_return);
8280 END_PROFILE(Trans2_ioctl);
8281 break;
8282 }
8283
8284 default:
8285 /* Error in request */
8286 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
8287 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8288 }
8289 }
8290
8291 /****************************************************************************
8292 Reply to a SMBtrans2.
8293 ****************************************************************************/
8294
8295 void reply_trans2(struct smb_request *req)
8296 {
8297 connection_struct *conn = req->conn;
8298 unsigned int dsoff;
8299 unsigned int dscnt;
8300 unsigned int psoff;
8301 unsigned int pscnt;
8302 unsigned int tran_call;
8303 struct trans_state *state;
8304 NTSTATUS result;
8305
8306 START_PROFILE(SMBtrans2);
8307
8308 if (req->wct < 14) {
8309 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8310 END_PROFILE(SMBtrans2);
8311 return;
8312 }
8313
8314 dsoff = SVAL(req->vwv+12, 0);
8315 dscnt = SVAL(req->vwv+11, 0);
8316 psoff = SVAL(req->vwv+10, 0);
8317 pscnt = SVAL(req->vwv+9, 0);
8318 tran_call = SVAL(req->vwv+14, 0);
8319
8320 result = allow_new_trans(conn->pending_trans, req->mid);
8321 if (!NT_STATUS_IS_OK(result)) {
8322 DEBUG(2, ("Got invalid trans2 request: %s\n",
8323 nt_errstr(result)));
8324 reply_nterror(req, result);
8325 END_PROFILE(SMBtrans2);
8326 return;
8327 }
8328
8329 if (IS_IPC(conn)) {
8330 switch (tran_call) {
8331 /* List the allowed trans2 calls on IPC$ */
8332 case TRANSACT2_OPEN:
8333 case TRANSACT2_GET_DFS_REFERRAL:
8334 case TRANSACT2_QFILEINFO:
8335 case TRANSACT2_QFSINFO:
8336 case TRANSACT2_SETFSINFO:
8337 break;
8338 default:
8339 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8340 END_PROFILE(SMBtrans2);
8341 return;
8342 }
8343 }
8344
8345 if ((state = TALLOC_P(conn, struct trans_state)) == NULL) {
8346 DEBUG(0, ("talloc failed\n"));
8347 reply_nterror(req, NT_STATUS_NO_MEMORY);
8348 END_PROFILE(SMBtrans2);
8349 return;
8350 }
8351
8352 state->cmd = SMBtrans2;
8353
8354 state->mid = req->mid;
8355 state->vuid = req->vuid;
8356 state->setup_count = SVAL(req->vwv+13, 0);
8357 state->setup = NULL;
8358 state->total_param = SVAL(req->vwv+0, 0);
8359 state->param = NULL;
8360 state->total_data = SVAL(req->vwv+1, 0);
8361 state->data = NULL;
8362 state->max_param_return = SVAL(req->vwv+2, 0);
8363 state->max_data_return = SVAL(req->vwv+3, 0);
8364 state->max_setup_return = SVAL(req->vwv+4, 0);
8365 state->close_on_completion = BITSETW(req->vwv+5, 0);
8366 state->one_way = BITSETW(req->vwv+5, 1);
8367
8368 state->call = tran_call;
8369
8370 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8371 is so as a sanity check */
8372 if (state->setup_count != 1) {
8373 /*
8374 * Need to have rc=0 for ioctl to get job id for OS/2.
8375 * Network printing will fail if function is not successful.
8376 * Similar function in reply.c will be used if protocol
8377 * is LANMAN1.0 instead of LM1.2X002.
8378 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8379 * outbuf doesn't have to be set(only job id is used).
8380 */
8381 if ( (state->setup_count == 4)
8382 && (tran_call == TRANSACT2_IOCTL)
8383 && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
8384 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8385 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8386 } else {
8387 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
8388 DEBUG(2,("Transaction is %d\n",tran_call));
8389 TALLOC_FREE(state);
8390 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8391 END_PROFILE(SMBtrans2);
8392 return;
8393 }
8394 }
8395
8396 if ((dscnt > state->total_data) || (pscnt > state->total_param))
8397 goto bad_param;
8398
8399 if (state->total_data) {
8400
8401 if (trans_oob(state->total_data, 0, dscnt)
8402 || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
8403 goto bad_param;
8404 }
8405
8406 /* Can't use talloc here, the core routines do realloc on the
8407 * params and data. */
8408 state->data = (char *)SMB_MALLOC(state->total_data);
8409 if (state->data == NULL) {
8410 DEBUG(0,("reply_trans2: data malloc fail for %u "
8411 "bytes !\n", (unsigned int)state->total_data));
8412 TALLOC_FREE(state);
8413 reply_nterror(req, NT_STATUS_NO_MEMORY);
8414 END_PROFILE(SMBtrans2);
8415 return;
8416 }
8417
8418 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
8419 }
8420
8421 if (state->total_param) {
8422
8423 if (trans_oob(state->total_param, 0, pscnt)
8424 || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
8425 goto bad_param;
8426 }
8427
8428 /* Can't use talloc here, the core routines do realloc on the
8429 * params and data. */
8430 state->param = (char *)SMB_MALLOC(state->total_param);
8431 if (state->param == NULL) {
8432 DEBUG(0,("reply_trans: param malloc fail for %u "
8433 "bytes !\n", (unsigned int)state->total_param));
8434 SAFE_FREE(state->data);
8435 TALLOC_FREE(state);
8436 reply_nterror(req, NT_STATUS_NO_MEMORY);
8437 END_PROFILE(SMBtrans2);
8438 return;
8439 }
8440
8441 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
8442 }
8443
8444 state->received_data = dscnt;
8445 state->received_param = pscnt;
8446
8447 if ((state->received_param == state->total_param) &&
8448 (state->received_data == state->total_data)) {
8449
8450 handle_trans2(conn, req, state);
8451
8452 SAFE_FREE(state->data);
8453 SAFE_FREE(state->param);
8454 TALLOC_FREE(state);
8455 END_PROFILE(SMBtrans2);
8456 return;
8457 }
8458
8459 DLIST_ADD(conn->pending_trans, state);
8460
8461 /* We need to send an interim response then receive the rest
8462 of the parameter/data bytes */
8463 reply_outbuf(req, 0, 0);
8464 show_msg((char *)req->outbuf);
8465 END_PROFILE(SMBtrans2);
8466 return;
8467
8468 bad_param:
8469
8470 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8471 SAFE_FREE(state->data);
8472 SAFE_FREE(state->param);
8473 TALLOC_FREE(state);
8474 END_PROFILE(SMBtrans2);
8475 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8476 }
8477
8478
8479 /****************************************************************************
8480 Reply to a SMBtranss2
8481 ****************************************************************************/
8482
8483 void reply_transs2(struct smb_request *req)
8484 {
8485 connection_struct *conn = req->conn;
8486 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
8487 struct trans_state *state;
8488
8489 START_PROFILE(SMBtranss2);
8490
8491 show_msg((char *)req->inbuf);
8492
8493 if (req->wct < 8) {
8494 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8495 END_PROFILE(SMBtranss2);
8496 return;
8497 }
8498
8499 for (state = conn->pending_trans; state != NULL;
8500 state = state->next) {
8501 if (state->mid == req->mid) {
8502 break;
8503 }
8504 }
8505
8506 if ((state == NULL) || (state->cmd != SMBtrans2)) {
8507 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8508 END_PROFILE(SMBtranss2);
8509 return;
8510 }
8511
8512 /* Revise state->total_param and state->total_data in case they have
8513 changed downwards */
8514
8515 if (SVAL(req->vwv+0, 0) < state->total_param)
8516 state->total_param = SVAL(req->vwv+0, 0);
8517 if (SVAL(req->vwv+1, 0) < state->total_data)
8518 state->total_data = SVAL(req->vwv+1, 0);
8519
8520 pcnt = SVAL(req->vwv+2, 0);
8521 poff = SVAL(req->vwv+3, 0);
8522 pdisp = SVAL(req->vwv+4, 0);
8523
8524 dcnt = SVAL(req->vwv+5, 0);
8525 doff = SVAL(req->vwv+6, 0);
8526 ddisp = SVAL(req->vwv+7, 0);
8527
8528 state->received_param += pcnt;
8529 state->received_data += dcnt;
8530
8531 if ((state->received_data > state->total_data) ||
8532 (state->received_param > state->total_param))
8533 goto bad_param;
8534
8535 if (pcnt) {
8536 if (trans_oob(state->total_param, pdisp, pcnt)
8537 || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
8538 goto bad_param;
8539 }
8540 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
8541 }
8542
8543 if (dcnt) {
8544 if (trans_oob(state->total_data, ddisp, dcnt)
8545 || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
8546 goto bad_param;
8547 }
8548 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
8549 }
8550
8551 if ((state->received_param < state->total_param) ||
8552 (state->received_data < state->total_data)) {
8553 END_PROFILE(SMBtranss2);
8554 return;
8555 }
8556
8557 handle_trans2(conn, req, state);
8558
8559 DLIST_REMOVE(conn->pending_trans, state);
8560 SAFE_FREE(state->data);
8561 SAFE_FREE(state->param);
8562 TALLOC_FREE(state);
8563
8564 END_PROFILE(SMBtranss2);
8565 return;
8566
8567 bad_param:
8568
8569 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8570 DLIST_REMOVE(conn->pending_trans, state);
8571 SAFE_FREE(state->data);
8572 SAFE_FREE(state->param);
8573 TALLOC_FREE(state);
8574 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8575 END_PROFILE(SMBtranss2);
8576 return;
8577 }
Samba GIT mirror