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