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