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