?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/smb: add basic session->smb2.channel_sequence handling
[Samba/gebeck_regimport.git] / source3 / smbd / trans2.c
blob73feaf879846cc9bd9b6fef2efa42b082e176956
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(ctx, SNUM(conn))));
2499 if (in_list(directory,lp_dontdescend(ctx, 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(ctx, SNUM(conn))));
2828 if (in_list(directory,lp_dontdescend(ctx, 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(talloc_tos(), 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(talloc_tos(), SNUM(conn));
2996 int snum = SNUM(conn);
2997 char *fstype = lp_fstype(talloc_tos(), 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(talloc_tos(), 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(talloc_tos(), 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,
3154 lp_servicename(talloc_tos(), snum)));
3155 break;
3156
3157 case SMB_QUERY_FS_SIZE_INFO:
3158 case SMB_FS_SIZE_INFORMATION:
3159 {
3160 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3161 data_len = 24;
3162 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3163 return map_nt_error_from_unix(errno);
3164 }
3165 block_size = lp_block_size(snum);
3166 if (bsize < block_size) {
3167 uint64_t factor = block_size/bsize;
3168 bsize = block_size;
3169 dsize /= factor;
3170 dfree /= factor;
3171 }
3172 if (bsize > block_size) {
3173 uint64_t factor = bsize/block_size;
3174 bsize = block_size;
3175 dsize *= factor;
3176 dfree *= factor;
3177 }
3178 bytes_per_sector = 512;
3179 sectors_per_unit = bsize/bytes_per_sector;
3180 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3181 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3182 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3183 SBIG_UINT(pdata,0,dsize);
3184 SBIG_UINT(pdata,8,dfree);
3185 SIVAL(pdata,16,sectors_per_unit);
3186 SIVAL(pdata,20,bytes_per_sector);
3187 break;
3188 }
3189
3190 case SMB_FS_FULL_SIZE_INFORMATION:
3191 {
3192 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3193 data_len = 32;
3194 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3195 return map_nt_error_from_unix(errno);
3196 }
3197 block_size = lp_block_size(snum);
3198 if (bsize < block_size) {
3199 uint64_t factor = block_size/bsize;
3200 bsize = block_size;
3201 dsize /= factor;
3202 dfree /= factor;
3203 }
3204 if (bsize > block_size) {
3205 uint64_t factor = bsize/block_size;
3206 bsize = block_size;
3207 dsize *= factor;
3208 dfree *= factor;
3209 }
3210 bytes_per_sector = 512;
3211 sectors_per_unit = bsize/bytes_per_sector;
3212 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3213 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3214 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3215 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3216 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3217 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3218 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3219 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3220 break;
3221 }
3222
3223 case SMB_QUERY_FS_DEVICE_INFO:
3224 case SMB_FS_DEVICE_INFORMATION:
3225 {
3226 uint32_t characteristics = FILE_DEVICE_IS_MOUNTED;
3227
3228 if (!CAN_WRITE(conn)) {
3229 characteristics |= FILE_READ_ONLY_DEVICE;
3230 }
3231 data_len = 8;
3232 SIVAL(pdata,0,FILE_DEVICE_DISK); /* dev type */
3233 SIVAL(pdata,4,characteristics);
3234 break;
3235 }
3236
3237 #ifdef HAVE_SYS_QUOTAS
3238 case SMB_FS_QUOTA_INFORMATION:
3239 /*
3240 * what we have to send --metze:
3241 *
3242 * Unknown1: 24 NULL bytes
3243 * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3244 * Hard Quota Limit: 8 bytes seems like uint64_t or so
3245 * Quota Flags: 2 byte :
3246 * Unknown3: 6 NULL bytes
3247 *
3248 * 48 bytes total
3249 *
3250 * details for Quota Flags:
3251 *
3252 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3253 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
3254 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3255 * 0x0001 Enable Quotas: enable quota for this fs
3256 *
3257 */
3258 {
3259 /* we need to fake up a fsp here,
3260 * because its not send in this call
3261 */
3262 files_struct fsp;
3263 SMB_NTQUOTA_STRUCT quotas;
3264
3265 ZERO_STRUCT(fsp);
3266 ZERO_STRUCT(quotas);
3267
3268 fsp.conn = conn;
3269 fsp.fnum = FNUM_FIELD_INVALID;
3270
3271 /* access check */
3272 if (get_current_uid(conn) != 0) {
3273 DEBUG(0,("set_user_quota: access_denied "
3274 "service [%s] user [%s]\n",
3275 lp_servicename(talloc_tos(), SNUM(conn)),
3276 conn->session_info->unix_info->unix_name));
3277 return NT_STATUS_ACCESS_DENIED;
3278 }
3279
3280 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3281 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3282 return map_nt_error_from_unix(errno);
3283 }
3284
3285 data_len = 48;
3286
3287 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3288 lp_servicename(talloc_tos(), SNUM(conn))));
3289
3290 /* Unknown1 24 NULL bytes*/
3291 SBIG_UINT(pdata,0,(uint64_t)0);
3292 SBIG_UINT(pdata,8,(uint64_t)0);
3293 SBIG_UINT(pdata,16,(uint64_t)0);
3294
3295 /* Default Soft Quota 8 bytes */
3296 SBIG_UINT(pdata,24,quotas.softlim);
3297
3298 /* Default Hard Quota 8 bytes */
3299 SBIG_UINT(pdata,32,quotas.hardlim);
3300
3301 /* Quota flag 2 bytes */
3302 SSVAL(pdata,40,quotas.qflags);
3303
3304 /* Unknown3 6 NULL bytes */
3305 SSVAL(pdata,42,0);
3306 SIVAL(pdata,44,0);
3307
3308 break;
3309 }
3310 #endif /* HAVE_SYS_QUOTAS */
3311 case SMB_FS_OBJECTID_INFORMATION:
3312 {
3313 unsigned char objid[16];
3314 struct smb_extended_info extended_info;
3315 memcpy(pdata,create_volume_objectid(conn, objid),16);
3316 samba_extended_info_version (&extended_info);
3317 SIVAL(pdata,16,extended_info.samba_magic);
3318 SIVAL(pdata,20,extended_info.samba_version);
3319 SIVAL(pdata,24,extended_info.samba_subversion);
3320 SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3321 memcpy(pdata+36,extended_info.samba_version_string,28);
3322 data_len = 64;
3323 break;
3324 }
3325
3326 /*
3327 * Query the version and capabilities of the CIFS UNIX extensions
3328 * in use.
3329 */
3330
3331 case SMB_QUERY_CIFS_UNIX_INFO:
3332 {
3333 bool large_write = lp_min_receive_file_size() &&
3334 !srv_is_signing_active(conn->sconn);
3335 bool large_read = !srv_is_signing_active(conn->sconn);
3336 int encrypt_caps = 0;
3337
3338 if (!lp_unix_extensions()) {
3339 return NT_STATUS_INVALID_LEVEL;
3340 }
3341
3342 switch (conn->encrypt_level) {
3343 case 0:
3344 encrypt_caps = 0;
3345 break;
3346 case 1:
3347 case Auto:
3348 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3349 break;
3350 case Required:
3351 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3352 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3353 large_write = false;
3354 large_read = false;
3355 break;
3356 }
3357
3358 data_len = 12;
3359 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3360 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3361
3362 /* We have POSIX ACLs, pathname, encryption,
3363 * large read/write, and locking capability. */
3364
3365 SBIG_UINT(pdata,4,((uint64_t)(
3366 CIFS_UNIX_POSIX_ACLS_CAP|
3367 CIFS_UNIX_POSIX_PATHNAMES_CAP|
3368 CIFS_UNIX_FCNTL_LOCKS_CAP|
3369 CIFS_UNIX_EXTATTR_CAP|
3370 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3371 encrypt_caps|
3372 (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3373 (large_write ?
3374 CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3375 break;
3376 }
3377
3378 case SMB_QUERY_POSIX_FS_INFO:
3379 {
3380 int rc;
3381 vfs_statvfs_struct svfs;
3382
3383 if (!lp_unix_extensions()) {
3384 return NT_STATUS_INVALID_LEVEL;
3385 }
3386
3387 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
3388
3389 if (!rc) {
3390 data_len = 56;
3391 SIVAL(pdata,0,svfs.OptimalTransferSize);
3392 SIVAL(pdata,4,svfs.BlockSize);
3393 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3394 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3395 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3396 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3397 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3398 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3399 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3400 #ifdef EOPNOTSUPP
3401 } else if (rc == EOPNOTSUPP) {
3402 return NT_STATUS_INVALID_LEVEL;
3403 #endif /* EOPNOTSUPP */
3404 } else {
3405 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3406 return NT_STATUS_DOS(ERRSRV, ERRerror);
3407 }
3408 break;
3409 }
3410
3411 case SMB_QUERY_POSIX_WHOAMI:
3412 {
3413 uint32_t flags = 0;
3414 uint32_t sid_bytes;
3415 int i;
3416
3417 if (!lp_unix_extensions()) {
3418 return NT_STATUS_INVALID_LEVEL;
3419 }
3420
3421 if (max_data_bytes < 40) {
3422 return NT_STATUS_BUFFER_TOO_SMALL;
3423 }
3424
3425 if (security_session_user_level(conn->session_info, NULL) < SECURITY_USER) {
3426 flags |= SMB_WHOAMI_GUEST;
3427 }
3428
3429 /* NOTE: 8 bytes for UID/GID, irrespective of native
3430 * platform size. This matches
3431 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3432 */
3433 data_len = 4 /* flags */
3434 + 4 /* flag mask */
3435 + 8 /* uid */
3436 + 8 /* gid */
3437 + 4 /* ngroups */
3438 + 4 /* num_sids */
3439 + 4 /* SID bytes */
3440 + 4 /* pad/reserved */
3441 + (conn->session_info->unix_token->ngroups * 8)
3442 /* groups list */
3443 + (conn->session_info->security_token->num_sids *
3444 SID_MAX_SIZE)
3445 /* SID list */;
3446
3447 SIVAL(pdata, 0, flags);
3448 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3449 SBIG_UINT(pdata, 8,
3450 (uint64_t)conn->session_info->unix_token->uid);
3451 SBIG_UINT(pdata, 16,
3452 (uint64_t)conn->session_info->unix_token->gid);
3453
3454
3455 if (data_len >= max_data_bytes) {
3456 /* Potential overflow, skip the GIDs and SIDs. */
3457
3458 SIVAL(pdata, 24, 0); /* num_groups */
3459 SIVAL(pdata, 28, 0); /* num_sids */
3460 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3461 SIVAL(pdata, 36, 0); /* reserved */
3462
3463 data_len = 40;
3464 break;
3465 }
3466
3467 SIVAL(pdata, 24, conn->session_info->unix_token->ngroups);
3468 SIVAL(pdata, 28, conn->session_info->security_token->num_sids);
3469
3470 /* We walk the SID list twice, but this call is fairly
3471 * infrequent, and I don't expect that it's performance
3472 * sensitive -- jpeach
3473 */
3474 for (i = 0, sid_bytes = 0;
3475 i < conn->session_info->security_token->num_sids; ++i) {
3476 sid_bytes += ndr_size_dom_sid(
3477 &conn->session_info->security_token->sids[i],
3478 0);
3479 }
3480
3481 /* SID list byte count */
3482 SIVAL(pdata, 32, sid_bytes);
3483
3484 /* 4 bytes pad/reserved - must be zero */
3485 SIVAL(pdata, 36, 0);
3486 data_len = 40;
3487
3488 /* GID list */
3489 for (i = 0; i < conn->session_info->unix_token->ngroups; ++i) {
3490 SBIG_UINT(pdata, data_len,
3491 (uint64_t)conn->session_info->unix_token->groups[i]);
3492 data_len += 8;
3493 }
3494
3495 /* SID list */
3496 for (i = 0;
3497 i < conn->session_info->security_token->num_sids; ++i) {
3498 int sid_len = ndr_size_dom_sid(
3499 &conn->session_info->security_token->sids[i],
3500 0);
3501
3502 sid_linearize(pdata + data_len, sid_len,
3503 &conn->session_info->security_token->sids[i]);
3504 data_len += sid_len;
3505 }
3506
3507 break;
3508 }
3509
3510 case SMB_MAC_QUERY_FS_INFO:
3511 /*
3512 * Thursby MAC extension... ONLY on NTFS filesystems
3513 * once we do streams then we don't need this
3514 */
3515 if (strequal(lp_fstype(talloc_tos(), SNUM(conn)),"NTFS")) {
3516 data_len = 88;
3517 SIVAL(pdata,84,0x100); /* Don't support mac... */
3518 break;
3519 }
3520 /* drop through */
3521 default:
3522 return NT_STATUS_INVALID_LEVEL;
3523 }
3524
3525 *ret_data_len = data_len;
3526 return NT_STATUS_OK;
3527 }
3528
3529 /****************************************************************************
3530 Reply to a TRANS2_QFSINFO (query filesystem info).
3531 ****************************************************************************/
3532
3533 static void call_trans2qfsinfo(connection_struct *conn,
3534 struct smb_request *req,
3535 char **pparams, int total_params,
3536 char **ppdata, int total_data,
3537 unsigned int max_data_bytes)
3538 {
3539 char *params = *pparams;
3540 uint16_t info_level;
3541 int data_len = 0;
3542 NTSTATUS status;
3543
3544 if (total_params < 2) {
3545 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3546 return;
3547 }
3548
3549 info_level = SVAL(params,0);
3550
3551 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3552 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3553 DEBUG(0,("call_trans2qfsinfo: encryption required "
3554 "and info level 0x%x sent.\n",
3555 (unsigned int)info_level));
3556 exit_server_cleanly("encryption required "
3557 "on connection");
3558 return;
3559 }
3560 }
3561
3562 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
3563
3564 status = smbd_do_qfsinfo(conn, req,
3565 info_level,
3566 req->flags2,
3567 max_data_bytes,
3568 ppdata, &data_len);
3569 if (!NT_STATUS_IS_OK(status)) {
3570 reply_nterror(req, status);
3571 return;
3572 }
3573
3574 send_trans2_replies(conn, req, params, 0, *ppdata, data_len,
3575 max_data_bytes);
3576
3577 DEBUG( 4, ( "%s info_level = %d\n",
3578 smb_fn_name(req->cmd), info_level) );
3579
3580 return;
3581 }
3582
3583 /****************************************************************************
3584 Reply to a TRANS2_SETFSINFO (set filesystem info).
3585 ****************************************************************************/
3586
3587 static void call_trans2setfsinfo(connection_struct *conn,
3588 struct smb_request *req,
3589 char **pparams, int total_params,
3590 char **ppdata, int total_data,
3591 unsigned int max_data_bytes)
3592 {
3593 struct smbd_server_connection *sconn = req->sconn;
3594 char *pdata = *ppdata;
3595 char *params = *pparams;
3596 uint16 info_level;
3597
3598 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",
3599 lp_servicename(talloc_tos(), SNUM(conn))));
3600
3601 /* */
3602 if (total_params < 4) {
3603 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3604 total_params));
3605 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3606 return;
3607 }
3608
3609 info_level = SVAL(params,2);
3610
3611 if (IS_IPC(conn)) {
3612 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
3613 info_level != SMB_SET_CIFS_UNIX_INFO) {
3614 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3615 "info level (0x%x) on IPC$.\n",
3616 (unsigned int)info_level));
3617 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3618 return;
3619 }
3620 }
3621
3622 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3623 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
3624 DEBUG(0,("call_trans2setfsinfo: encryption required "
3625 "and info level 0x%x sent.\n",
3626 (unsigned int)info_level));
3627 exit_server_cleanly("encryption required "
3628 "on connection");
3629 return;
3630 }
3631 }
3632
3633 switch(info_level) {
3634 case SMB_SET_CIFS_UNIX_INFO:
3635 if (!lp_unix_extensions()) {
3636 DEBUG(2,("call_trans2setfsinfo: "
3637 "SMB_SET_CIFS_UNIX_INFO is invalid with "
3638 "unix extensions off\n"));
3639 reply_nterror(req,
3640 NT_STATUS_INVALID_LEVEL);
3641 return;
3642 }
3643
3644 /* There should be 12 bytes of capabilities set. */
3645 if (total_data < 12) {
3646 reply_nterror(
3647 req,
3648 NT_STATUS_INVALID_PARAMETER);
3649 return;
3650 }
3651 sconn->smb1.unix_info.client_major = SVAL(pdata,0);
3652 sconn->smb1.unix_info.client_minor = SVAL(pdata,2);
3653 sconn->smb1.unix_info.client_cap_low = IVAL(pdata,4);
3654 sconn->smb1.unix_info.client_cap_high = IVAL(pdata,8);
3655 /* Just print these values for now. */
3656 DEBUG(10, ("call_trans2setfsinfo: set unix_info info. "
3657 "major = %u, minor = %u cap_low = 0x%x, "
3658 "cap_high = 0x%xn",
3659 (unsigned int)sconn->
3660 smb1.unix_info.client_major,
3661 (unsigned int)sconn->
3662 smb1.unix_info.client_minor,
3663 (unsigned int)sconn->
3664 smb1.unix_info.client_cap_low,
3665 (unsigned int)sconn->
3666 smb1.unix_info.client_cap_high));
3667
3668 /* Here is where we must switch to posix pathname processing... */
3669 if (sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3670 lp_set_posix_pathnames();
3671 mangle_change_to_posix();
3672 }
3673
3674 if ((sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
3675 !(sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
3676 /* Client that knows how to do posix locks,
3677 * but not posix open/mkdir operations. Set a
3678 * default type for read/write checks. */
3679
3680 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
3681
3682 }
3683 break;
3684
3685 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
3686 {
3687 NTSTATUS status;
3688 size_t param_len = 0;
3689 size_t data_len = total_data;
3690
3691 if (!lp_unix_extensions()) {
3692 reply_nterror(
3693 req,
3694 NT_STATUS_INVALID_LEVEL);
3695 return;
3696 }
3697
3698 if (lp_smb_encrypt(SNUM(conn)) == false) {
3699 reply_nterror(
3700 req,
3701 NT_STATUS_NOT_SUPPORTED);
3702 return;
3703 }
3704
3705 if (req->sconn->smb1.echo_handler.trusted_fde) {
3706 DEBUG( 2,("call_trans2setfsinfo: "
3707 "request transport encryption disabled"
3708 "with 'fork echo handler = yes'\n"));
3709 reply_nterror(
3710 req,
3711 NT_STATUS_NOT_SUPPORTED);
3712 return;
3713 }
3714
3715 DEBUG( 4,("call_trans2setfsinfo: "
3716 "request transport encryption.\n"));
3717
3718 status = srv_request_encryption_setup(conn,
3719 (unsigned char **)ppdata,
3720 &data_len,
3721 (unsigned char **)pparams,
3722 &param_len);
3723
3724 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
3725 !NT_STATUS_IS_OK(status)) {
3726 reply_nterror(req, status);
3727 return;
3728 }
3729
3730 send_trans2_replies(conn, req,
3731 *pparams,
3732 param_len,
3733 *ppdata,
3734 data_len,
3735 max_data_bytes);
3736
3737 if (NT_STATUS_IS_OK(status)) {
3738 /* Server-side transport
3739 * encryption is now *on*. */
3740 status = srv_encryption_start(conn);
3741 if (!NT_STATUS_IS_OK(status)) {
3742 char *reason = talloc_asprintf(talloc_tos(),
3743 "Failure in setting "
3744 "up encrypted transport: %s",
3745 nt_errstr(status));
3746 exit_server_cleanly(reason);
3747 }
3748 }
3749 return;
3750 }
3751
3752 case SMB_FS_QUOTA_INFORMATION:
3753 {
3754 files_struct *fsp = NULL;
3755 SMB_NTQUOTA_STRUCT quotas;
3756
3757 ZERO_STRUCT(quotas);
3758
3759 /* access check */
3760 if ((get_current_uid(conn) != 0) || !CAN_WRITE(conn)) {
3761 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3762 lp_servicename(talloc_tos(), SNUM(conn)),
3763 conn->session_info->unix_info->unix_name));
3764 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3765 return;
3766 }
3767
3768 /* note: normaly there're 48 bytes,
3769 * but we didn't use the last 6 bytes for now
3770 * --metze
3771 */
3772 fsp = file_fsp(req, SVAL(params,0));
3773
3774 if (!check_fsp_ntquota_handle(conn, req,
3775 fsp)) {
3776 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3777 reply_nterror(
3778 req, NT_STATUS_INVALID_HANDLE);
3779 return;
3780 }
3781
3782 if (total_data < 42) {
3783 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3784 total_data));
3785 reply_nterror(
3786 req,
3787 NT_STATUS_INVALID_PARAMETER);
3788 return;
3789 }
3790
3791 /* unknown_1 24 NULL bytes in pdata*/
3792
3793 /* the soft quotas 8 bytes (uint64_t)*/
3794 quotas.softlim = BVAL(pdata,24);
3795
3796 /* the hard quotas 8 bytes (uint64_t)*/
3797 quotas.hardlim = BVAL(pdata,32);
3798
3799 /* quota_flags 2 bytes **/
3800 quotas.qflags = SVAL(pdata,40);
3801
3802 /* unknown_2 6 NULL bytes follow*/
3803
3804 /* now set the quotas */
3805 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3806 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
3807 reply_nterror(req, map_nt_error_from_unix(errno));
3808 return;
3809 }
3810
3811 break;
3812 }
3813 default:
3814 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3815 info_level));
3816 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3817 return;
3818 break;
3819 }
3820
3821 /*
3822 * sending this reply works fine,
3823 * but I'm not sure it's the same
3824 * like windows do...
3825 * --metze
3826 */
3827 reply_outbuf(req, 10, 0);
3828 }
3829
3830 #if defined(HAVE_POSIX_ACLS)
3831 /****************************************************************************
3832 Utility function to count the number of entries in a POSIX acl.
3833 ****************************************************************************/
3834
3835 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
3836 {
3837 unsigned int ace_count = 0;
3838 int entry_id = SMB_ACL_FIRST_ENTRY;
3839 SMB_ACL_ENTRY_T entry;
3840
3841 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3842 /* get_next... */
3843 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3844 entry_id = SMB_ACL_NEXT_ENTRY;
3845 }
3846 ace_count++;
3847 }
3848 return ace_count;
3849 }
3850
3851 /****************************************************************************
3852 Utility function to marshall a POSIX acl into wire format.
3853 ****************************************************************************/
3854
3855 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
3856 {
3857 int entry_id = SMB_ACL_FIRST_ENTRY;
3858 SMB_ACL_ENTRY_T entry;
3859
3860 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3861 SMB_ACL_TAG_T tagtype;
3862 SMB_ACL_PERMSET_T permset;
3863 unsigned char perms = 0;
3864 unsigned int own_grp;
3865
3866 /* get_next... */
3867 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3868 entry_id = SMB_ACL_NEXT_ENTRY;
3869 }
3870
3871 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
3872 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3873 return False;
3874 }
3875
3876 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
3877 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3878 return False;
3879 }
3880
3881 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
3882 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
3883 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
3884
3885 SCVAL(pdata,1,perms);
3886
3887 switch (tagtype) {
3888 case SMB_ACL_USER_OBJ:
3889 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
3890 own_grp = (unsigned int)pst->st_ex_uid;
3891 SIVAL(pdata,2,own_grp);
3892 SIVAL(pdata,6,0);
3893 break;
3894 case SMB_ACL_USER:
3895 {
3896 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3897 if (!puid) {
3898 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3899 return False;
3900 }
3901 own_grp = (unsigned int)*puid;
3902 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3903 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3904 SIVAL(pdata,2,own_grp);
3905 SIVAL(pdata,6,0);
3906 break;
3907 }
3908 case SMB_ACL_GROUP_OBJ:
3909 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3910 own_grp = (unsigned int)pst->st_ex_gid;
3911 SIVAL(pdata,2,own_grp);
3912 SIVAL(pdata,6,0);
3913 break;
3914 case SMB_ACL_GROUP:
3915 {
3916 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3917 if (!pgid) {
3918 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3919 return False;
3920 }
3921 own_grp = (unsigned int)*pgid;
3922 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3923 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3924 SIVAL(pdata,2,own_grp);
3925 SIVAL(pdata,6,0);
3926 break;
3927 }
3928 case SMB_ACL_MASK:
3929 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
3930 SIVAL(pdata,2,0xFFFFFFFF);
3931 SIVAL(pdata,6,0xFFFFFFFF);
3932 break;
3933 case SMB_ACL_OTHER:
3934 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
3935 SIVAL(pdata,2,0xFFFFFFFF);
3936 SIVAL(pdata,6,0xFFFFFFFF);
3937 break;
3938 default:
3939 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3940 return False;
3941 }
3942 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
3943 }
3944
3945 return True;
3946 }
3947 #endif
3948
3949 /****************************************************************************
3950 Store the FILE_UNIX_BASIC info.
3951 ****************************************************************************/
3952
3953 static char *store_file_unix_basic(connection_struct *conn,
3954 char *pdata,
3955 files_struct *fsp,
3956 const SMB_STRUCT_STAT *psbuf)
3957 {
3958 uint64_t file_index = get_FileIndex(conn, psbuf);
3959 dev_t devno;
3960
3961 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3962 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
3963
3964 SOFF_T(pdata,0,get_file_size_stat(psbuf)); /* File size 64 Bit */
3965 pdata += 8;
3966
3967 SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3968 pdata += 8;
3969
3970 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime); /* Change Time 64 Bit */
3971 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime); /* Last access time 64 Bit */
3972 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata+16, psbuf->st_ex_mtime); /* Last modification time 64 Bit */
3973 pdata += 24;
3974
3975 SIVAL(pdata,0,psbuf->st_ex_uid); /* user id for the owner */
3976 SIVAL(pdata,4,0);
3977 pdata += 8;
3978
3979 SIVAL(pdata,0,psbuf->st_ex_gid); /* group id of owner */
3980 SIVAL(pdata,4,0);
3981 pdata += 8;
3982
3983 SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
3984 pdata += 4;
3985
3986 if (S_ISBLK(psbuf->st_ex_mode) || S_ISCHR(psbuf->st_ex_mode)) {
3987 devno = psbuf->st_ex_rdev;
3988 } else {
3989 devno = psbuf->st_ex_dev;
3990 }
3991
3992 SIVAL(pdata,0,unix_dev_major(devno)); /* Major device number if type is device */
3993 SIVAL(pdata,4,0);
3994 pdata += 8;
3995
3996 SIVAL(pdata,0,unix_dev_minor(devno)); /* Minor device number if type is device */
3997 SIVAL(pdata,4,0);
3998 pdata += 8;
3999
4000 SINO_T_VAL(pdata,0,(SMB_INO_T)file_index); /* inode number */
4001 pdata += 8;
4002
4003 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode)); /* Standard UNIX file permissions */
4004 SIVAL(pdata,4,0);
4005 pdata += 8;
4006
4007 SIVAL(pdata,0,psbuf->st_ex_nlink); /* number of hard links */
4008 SIVAL(pdata,4,0);
4009 pdata += 8;
4010
4011 return pdata;
4012 }
4013
4014 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
4015 * the chflags(2) (or equivalent) flags.
4016 *
4017 * XXX: this really should be behind the VFS interface. To do this, we would
4018 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
4019 * Each VFS module could then implement its own mapping as appropriate for the
4020 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
4021 */
4022 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
4023 info2_flags_map[] =
4024 {
4025 #ifdef UF_NODUMP
4026 { UF_NODUMP, EXT_DO_NOT_BACKUP },
4027 #endif
4028
4029 #ifdef UF_IMMUTABLE
4030 { UF_IMMUTABLE, EXT_IMMUTABLE },
4031 #endif
4032
4033 #ifdef UF_APPEND
4034 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
4035 #endif
4036
4037 #ifdef UF_HIDDEN
4038 { UF_HIDDEN, EXT_HIDDEN },
4039 #endif
4040
4041 /* Do not remove. We need to guarantee that this array has at least one
4042 * entry to build on HP-UX.
4043 */
4044 { 0, 0 }
4045
4046 };
4047
4048 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
4049 uint32 *smb_fflags, uint32 *smb_fmask)
4050 {
4051 int i;
4052
4053 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4054 *smb_fmask |= info2_flags_map[i].smb_fflag;
4055 if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
4056 *smb_fflags |= info2_flags_map[i].smb_fflag;
4057 }
4058 }
4059 }
4060
4061 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
4062 const uint32 smb_fflags,
4063 const uint32 smb_fmask,
4064 int *stat_fflags)
4065 {
4066 uint32 max_fmask = 0;
4067 int i;
4068
4069 *stat_fflags = psbuf->st_ex_flags;
4070
4071 /* For each flags requested in smb_fmask, check the state of the
4072 * corresponding flag in smb_fflags and set or clear the matching
4073 * stat flag.
4074 */
4075
4076 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4077 max_fmask |= info2_flags_map[i].smb_fflag;
4078 if (smb_fmask & info2_flags_map[i].smb_fflag) {
4079 if (smb_fflags & info2_flags_map[i].smb_fflag) {
4080 *stat_fflags |= info2_flags_map[i].stat_fflag;
4081 } else {
4082 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
4083 }
4084 }
4085 }
4086
4087 /* If smb_fmask is asking to set any bits that are not supported by
4088 * our flag mappings, we should fail.
4089 */
4090 if ((smb_fmask & max_fmask) != smb_fmask) {
4091 return False;
4092 }
4093
4094 return True;
4095 }
4096
4097
4098 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
4099 * of file flags and birth (create) time.
4100 */
4101 static char *store_file_unix_basic_info2(connection_struct *conn,
4102 char *pdata,
4103 files_struct *fsp,
4104 const SMB_STRUCT_STAT *psbuf)
4105 {
4106 uint32 file_flags = 0;
4107 uint32 flags_mask = 0;
4108
4109 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4110
4111 /* Create (birth) time 64 bit */
4112 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER,pdata, psbuf->st_ex_btime);
4113 pdata += 8;
4114
4115 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
4116 SIVAL(pdata, 0, file_flags); /* flags */
4117 SIVAL(pdata, 4, flags_mask); /* mask */
4118 pdata += 8;
4119
4120 return pdata;
4121 }
4122
4123 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4124 const struct stream_struct *streams,
4125 char *data,
4126 unsigned int max_data_bytes,
4127 unsigned int *data_size)
4128 {
4129 unsigned int i;
4130 unsigned int ofs = 0;
4131
4132 for (i = 0; i < num_streams && ofs <= max_data_bytes; i++) {
4133 unsigned int next_offset;
4134 size_t namelen;
4135 smb_ucs2_t *namebuf;
4136
4137 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4138 streams[i].name, &namelen) ||
4139 namelen <= 2)
4140 {
4141 return NT_STATUS_INVALID_PARAMETER;
4142 }
4143
4144 /*
4145 * name_buf is now null-terminated, we need to marshall as not
4146 * terminated
4147 */
4148
4149 namelen -= 2;
4150
4151 SIVAL(data, ofs+4, namelen);
4152 SOFF_T(data, ofs+8, streams[i].size);
4153 SOFF_T(data, ofs+16, streams[i].alloc_size);
4154 memcpy(data+ofs+24, namebuf, namelen);
4155 TALLOC_FREE(namebuf);
4156
4157 next_offset = ofs + 24 + namelen;
4158
4159 if (i == num_streams-1) {
4160 SIVAL(data, ofs, 0);
4161 }
4162 else {
4163 unsigned int align = ndr_align_size(next_offset, 8);
4164
4165 memset(data+next_offset, 0, align);
4166 next_offset += align;
4167
4168 SIVAL(data, ofs, next_offset - ofs);
4169 ofs = next_offset;
4170 }
4171
4172 ofs = next_offset;
4173 }
4174
4175 *data_size = ofs;
4176
4177 return NT_STATUS_OK;
4178 }
4179
4180 /****************************************************************************
4181 Reply to a TRANSACT2_QFILEINFO on a PIPE !
4182 ****************************************************************************/
4183
4184 static void call_trans2qpipeinfo(connection_struct *conn,
4185 struct smb_request *req,
4186 unsigned int tran_call,
4187 char **pparams, int total_params,
4188 char **ppdata, int total_data,
4189 unsigned int max_data_bytes)
4190 {
4191 char *params = *pparams;
4192 char *pdata = *ppdata;
4193 unsigned int data_size = 0;
4194 unsigned int param_size = 2;
4195 uint16 info_level;
4196 files_struct *fsp;
4197
4198 if (!params) {
4199 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4200 return;
4201 }
4202
4203 if (total_params < 4) {
4204 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4205 return;
4206 }
4207
4208 fsp = file_fsp(req, SVAL(params,0));
4209 if (!fsp_is_np(fsp)) {
4210 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4211 return;
4212 }
4213
4214 info_level = SVAL(params,2);
4215
4216 *pparams = (char *)SMB_REALLOC(*pparams,2);
4217 if (*pparams == NULL) {
4218 reply_nterror(req, NT_STATUS_NO_MEMORY);
4219 return;
4220 }
4221 params = *pparams;
4222 SSVAL(params,0,0);
4223 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4224 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4225 if (*ppdata == NULL ) {
4226 reply_nterror(req, NT_STATUS_NO_MEMORY);
4227 return;
4228 }
4229 pdata = *ppdata;
4230
4231 switch (info_level) {
4232 case SMB_FILE_STANDARD_INFORMATION:
4233 memset(pdata,0,24);
4234 SOFF_T(pdata,0,4096LL);
4235 SIVAL(pdata,16,1);
4236 SIVAL(pdata,20,1);
4237 data_size = 24;
4238 break;
4239
4240 default:
4241 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4242 return;
4243 }
4244
4245 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
4246 max_data_bytes);
4247
4248 return;
4249 }
4250
4251 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4252 TALLOC_CTX *mem_ctx,
4253 uint16_t info_level,
4254 files_struct *fsp,
4255 struct smb_filename *smb_fname,
4256 bool delete_pending,
4257 struct timespec write_time_ts,
4258 struct ea_list *ea_list,
4259 int lock_data_count,
4260 char *lock_data,
4261 uint16_t flags2,
4262 unsigned int max_data_bytes,
4263 char **ppdata,
4264 unsigned int *pdata_size)
4265 {
4266 char *pdata = *ppdata;
4267 char *dstart, *dend;
4268 unsigned int data_size;
4269 struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4270 time_t create_time, mtime, atime, c_time;
4271 SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4272 char *p;
4273 char *base_name;
4274 char *dos_fname;
4275 int mode;
4276 int nlink;
4277 NTSTATUS status;
4278 uint64_t file_size = 0;
4279 uint64_t pos = 0;
4280 uint64_t allocation_size = 0;
4281 uint64_t file_index = 0;
4282 uint32_t access_mask = 0;
4283
4284 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4285 return NT_STATUS_INVALID_LEVEL;
4286 }
4287
4288 DEBUG(5,("smbd_do_qfilepathinfo: %s (%s) level=%d max_data=%u\n",
4289 smb_fname_str_dbg(smb_fname),
4290 fsp_fnum_dbg(fsp),
4291 info_level, max_data_bytes));
4292
4293 mode = dos_mode(conn, smb_fname);
4294 nlink = psbuf->st_ex_nlink;
4295
4296 if (nlink && (mode&FILE_ATTRIBUTE_DIRECTORY)) {
4297 nlink = 1;
4298 }
4299
4300 if ((nlink > 0) && delete_pending) {
4301 nlink -= 1;
4302 }
4303
4304 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4305 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4306 if (*ppdata == NULL) {
4307 return NT_STATUS_NO_MEMORY;
4308 }
4309 pdata = *ppdata;
4310 dstart = pdata;
4311 dend = dstart + data_size - 1;
4312
4313 if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4314 update_stat_ex_mtime(psbuf, write_time_ts);
4315 }
4316
4317 create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4318 mtime_ts = psbuf->st_ex_mtime;
4319 atime_ts = psbuf->st_ex_atime;
4320 ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4321
4322 if (lp_dos_filetime_resolution(SNUM(conn))) {
4323 dos_filetime_timespec(&create_time_ts);
4324 dos_filetime_timespec(&mtime_ts);
4325 dos_filetime_timespec(&atime_ts);
4326 dos_filetime_timespec(&ctime_ts);
4327 }
4328
4329 create_time = convert_timespec_to_time_t(create_time_ts);
4330 mtime = convert_timespec_to_time_t(mtime_ts);
4331 atime = convert_timespec_to_time_t(atime_ts);
4332 c_time = convert_timespec_to_time_t(ctime_ts);
4333
4334 p = strrchr_m(smb_fname->base_name,'/');
4335 if (!p)
4336 base_name = smb_fname->base_name;
4337 else
4338 base_name = p+1;
4339
4340 /* NT expects the name to be in an exact form of the *full*
4341 filename. See the trans2 torture test */
4342 if (ISDOT(base_name)) {
4343 dos_fname = talloc_strdup(mem_ctx, "\\");
4344 if (!dos_fname) {
4345 return NT_STATUS_NO_MEMORY;
4346 }
4347 } else {
4348 dos_fname = talloc_asprintf(mem_ctx,
4349 "\\%s",
4350 smb_fname->base_name);
4351 if (!dos_fname) {
4352 return NT_STATUS_NO_MEMORY;
4353 }
4354 if (is_ntfs_stream_smb_fname(smb_fname)) {
4355 dos_fname = talloc_asprintf(dos_fname, "%s",
4356 smb_fname->stream_name);
4357 if (!dos_fname) {
4358 return NT_STATUS_NO_MEMORY;
4359 }
4360 }
4361
4362 string_replace(dos_fname, '/', '\\');
4363 }
4364
4365 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4366
4367 if (!fsp) {
4368 /* Do we have this path open ? */
4369 files_struct *fsp1;
4370 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4371 fsp1 = file_find_di_first(conn->sconn, fileid);
4372 if (fsp1 && fsp1->initial_allocation_size) {
4373 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4374 }
4375 }
4376
4377 if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
4378 file_size = get_file_size_stat(psbuf);
4379 }
4380
4381 if (fsp) {
4382 pos = fsp->fh->position_information;
4383 }
4384
4385 if (fsp) {
4386 access_mask = fsp->access_mask;
4387 } else {
4388 /* GENERIC_EXECUTE mapping from Windows */
4389 access_mask = 0x12019F;
4390 }
4391
4392 /* This should be an index number - looks like
4393 dev/ino to me :-)
4394
4395 I think this causes us to fail the IFSKIT
4396 BasicFileInformationTest. -tpot */
4397 file_index = get_FileIndex(conn, psbuf);
4398
4399 switch (info_level) {
4400 case SMB_INFO_STANDARD:
4401 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4402 data_size = 22;
4403 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
4404 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
4405 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
4406 SIVAL(pdata,l1_cbFile,(uint32)file_size);
4407 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
4408 SSVAL(pdata,l1_attrFile,mode);
4409 break;
4410
4411 case SMB_INFO_QUERY_EA_SIZE:
4412 {
4413 unsigned int ea_size =
4414 estimate_ea_size(conn, fsp,
4415 smb_fname->base_name);
4416 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4417 data_size = 26;
4418 srv_put_dos_date2(pdata,0,create_time);
4419 srv_put_dos_date2(pdata,4,atime);
4420 srv_put_dos_date2(pdata,8,mtime); /* write time */
4421 SIVAL(pdata,12,(uint32)file_size);
4422 SIVAL(pdata,16,(uint32)allocation_size);
4423 SSVAL(pdata,20,mode);
4424 SIVAL(pdata,22,ea_size);
4425 break;
4426 }
4427
4428 case SMB_INFO_IS_NAME_VALID:
4429 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4430 if (fsp) {
4431 /* os/2 needs this ? really ?*/
4432 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
4433 }
4434 /* This is only reached for qpathinfo */
4435 data_size = 0;
4436 break;
4437
4438 case SMB_INFO_QUERY_EAS_FROM_LIST:
4439 {
4440 size_t total_ea_len = 0;
4441 struct ea_list *ea_file_list = NULL;
4442
4443 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4444
4445 ea_file_list =
4446 get_ea_list_from_file(mem_ctx, conn, fsp,
4447 smb_fname->base_name,
4448 &total_ea_len);
4449 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
4450
4451 if (!ea_list || (total_ea_len > data_size)) {
4452 data_size = 4;
4453 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4454 break;
4455 }
4456
4457 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4458 break;
4459 }
4460
4461 case SMB_INFO_QUERY_ALL_EAS:
4462 {
4463 /* We have data_size bytes to put EA's into. */
4464 size_t total_ea_len = 0;
4465
4466 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4467
4468 ea_list = get_ea_list_from_file(mem_ctx, conn, fsp,
4469 smb_fname->base_name,
4470 &total_ea_len);
4471 if (!ea_list || (total_ea_len > data_size)) {
4472 data_size = 4;
4473 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4474 break;
4475 }
4476
4477 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4478 break;
4479 }
4480
4481 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
4482 {
4483 /* This is FileFullEaInformation - 0xF which maps to
4484 * 1015 (decimal) in smbd_do_setfilepathinfo. */
4485
4486 /* We have data_size bytes to put EA's into. */
4487 size_t total_ea_len = 0;
4488 struct ea_list *ea_file_list = NULL;
4489
4490 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
4491
4492 /*TODO: add filtering and index handling */
4493
4494 ea_file_list =
4495 get_ea_list_from_file(mem_ctx, conn, fsp,
4496 smb_fname->base_name,
4497 &total_ea_len);
4498 if (!ea_file_list) {
4499 return NT_STATUS_NO_EAS_ON_FILE;
4500 }
4501
4502 status = fill_ea_chained_buffer(mem_ctx,
4503 pdata,
4504 data_size,
4505 &data_size,
4506 conn, ea_file_list);
4507 if (!NT_STATUS_IS_OK(status)) {
4508 return status;
4509 }
4510 break;
4511 }
4512
4513 case SMB_FILE_BASIC_INFORMATION:
4514 case SMB_QUERY_FILE_BASIC_INFO:
4515
4516 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
4517 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4518 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
4519 } else {
4520 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4521 data_size = 40;
4522 SIVAL(pdata,36,0);
4523 }
4524 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4525 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4526 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4527 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4528 SIVAL(pdata,32,mode);
4529
4530 DEBUG(5,("SMB_QFBI - "));
4531 DEBUG(5,("create: %s ", ctime(&create_time)));
4532 DEBUG(5,("access: %s ", ctime(&atime)));
4533 DEBUG(5,("write: %s ", ctime(&mtime)));
4534 DEBUG(5,("change: %s ", ctime(&c_time)));
4535 DEBUG(5,("mode: %x\n", mode));
4536 break;
4537
4538 case SMB_FILE_STANDARD_INFORMATION:
4539 case SMB_QUERY_FILE_STANDARD_INFO:
4540
4541 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4542 data_size = 24;
4543 SOFF_T(pdata,0,allocation_size);
4544 SOFF_T(pdata,8,file_size);
4545 SIVAL(pdata,16,nlink);
4546 SCVAL(pdata,20,delete_pending?1:0);
4547 SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4548 SSVAL(pdata,22,0); /* Padding. */
4549 break;
4550
4551 case SMB_FILE_EA_INFORMATION:
4552 case SMB_QUERY_FILE_EA_INFO:
4553 {
4554 unsigned int ea_size =
4555 estimate_ea_size(conn, fsp, smb_fname->base_name);
4556 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4557 data_size = 4;
4558 SIVAL(pdata,0,ea_size);
4559 break;
4560 }
4561
4562 /* Get the 8.3 name - used if NT SMB was negotiated. */
4563 case SMB_QUERY_FILE_ALT_NAME_INFO:
4564 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
4565 {
4566 int len;
4567 char mangled_name[13];
4568 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4569 if (!name_to_8_3(base_name,mangled_name,
4570 True,conn->params)) {
4571 return NT_STATUS_NO_MEMORY;
4572 }
4573 len = srvstr_push(dstart, flags2,
4574 pdata+4, mangled_name,
4575 PTR_DIFF(dend, pdata+4),
4576 STR_UNICODE);
4577 data_size = 4 + len;
4578 SIVAL(pdata,0,len);
4579 break;
4580 }
4581
4582 case SMB_QUERY_FILE_NAME_INFO:
4583 {
4584 int len;
4585 /*
4586 this must be *exactly* right for ACLs on mapped drives to work
4587 */
4588 len = srvstr_push(dstart, flags2,
4589 pdata+4, dos_fname,
4590 PTR_DIFF(dend, pdata+4),
4591 STR_UNICODE);
4592 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4593 data_size = 4 + len;
4594 SIVAL(pdata,0,len);
4595 break;
4596 }
4597
4598 case SMB_FILE_ALLOCATION_INFORMATION:
4599 case SMB_QUERY_FILE_ALLOCATION_INFO:
4600 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4601 data_size = 8;
4602 SOFF_T(pdata,0,allocation_size);
4603 break;
4604
4605 case SMB_FILE_END_OF_FILE_INFORMATION:
4606 case SMB_QUERY_FILE_END_OF_FILEINFO:
4607 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4608 data_size = 8;
4609 SOFF_T(pdata,0,file_size);
4610 break;
4611
4612 case SMB_QUERY_FILE_ALL_INFO:
4613 case SMB_FILE_ALL_INFORMATION:
4614 {
4615 int len;
4616 unsigned int ea_size =
4617 estimate_ea_size(conn, fsp, smb_fname->base_name);
4618 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4619 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4620 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4621 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4622 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4623 SIVAL(pdata,32,mode);
4624 SIVAL(pdata,36,0); /* padding. */
4625 pdata += 40;
4626 SOFF_T(pdata,0,allocation_size);
4627 SOFF_T(pdata,8,file_size);
4628 SIVAL(pdata,16,nlink);
4629 SCVAL(pdata,20,delete_pending);
4630 SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4631 SSVAL(pdata,22,0);
4632 pdata += 24;
4633 SIVAL(pdata,0,ea_size);
4634 pdata += 4; /* EA info */
4635 len = srvstr_push(dstart, flags2,
4636 pdata+4, dos_fname,
4637 PTR_DIFF(dend, pdata+4),
4638 STR_UNICODE);
4639 SIVAL(pdata,0,len);
4640 pdata += 4 + len;
4641 data_size = PTR_DIFF(pdata,(*ppdata));
4642 break;
4643 }
4644
4645 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
4646 {
4647 int len;
4648 unsigned int ea_size =
4649 estimate_ea_size(conn, fsp, smb_fname->base_name);
4650 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
4651 put_long_date_timespec(conn->ts_res,pdata+0x00,create_time_ts);
4652 put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
4653 put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
4654 put_long_date_timespec(conn->ts_res,pdata+0x18,ctime_ts); /* change time */
4655 SIVAL(pdata, 0x20, mode);
4656 SIVAL(pdata, 0x24, 0); /* padding. */
4657 SBVAL(pdata, 0x28, allocation_size);
4658 SBVAL(pdata, 0x30, file_size);
4659 SIVAL(pdata, 0x38, nlink);
4660 SCVAL(pdata, 0x3C, delete_pending);
4661 SCVAL(pdata, 0x3D, (mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4662 SSVAL(pdata, 0x3E, 0); /* padding */
4663 SBVAL(pdata, 0x40, file_index);
4664 SIVAL(pdata, 0x48, ea_size);
4665 SIVAL(pdata, 0x4C, access_mask);
4666 SBVAL(pdata, 0x50, pos);
4667 SIVAL(pdata, 0x58, mode); /*TODO: mode != mode fix this!!! */
4668 SIVAL(pdata, 0x5C, 0); /* No alignment needed. */
4669
4670 pdata += 0x60;
4671
4672 len = srvstr_push(dstart, flags2,
4673 pdata+4, dos_fname,
4674 PTR_DIFF(dend, pdata+4),
4675 STR_UNICODE);
4676 SIVAL(pdata,0,len);
4677 pdata += 4 + len;
4678 data_size = PTR_DIFF(pdata,(*ppdata));
4679 break;
4680 }
4681 case SMB_FILE_INTERNAL_INFORMATION:
4682
4683 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4684 SBVAL(pdata, 0, file_index);
4685 data_size = 8;
4686 break;
4687
4688 case SMB_FILE_ACCESS_INFORMATION:
4689 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4690 SIVAL(pdata, 0, access_mask);
4691 data_size = 4;
4692 break;
4693
4694 case SMB_FILE_NAME_INFORMATION:
4695 /* Pathname with leading '\'. */
4696 {
4697 size_t byte_len;
4698 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
4699 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4700 SIVAL(pdata,0,byte_len);
4701 data_size = 4 + byte_len;
4702 break;
4703 }
4704
4705 case SMB_FILE_DISPOSITION_INFORMATION:
4706 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4707 data_size = 1;
4708 SCVAL(pdata,0,delete_pending);
4709 break;
4710
4711 case SMB_FILE_POSITION_INFORMATION:
4712 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4713 data_size = 8;
4714 SOFF_T(pdata,0,pos);
4715 break;
4716
4717 case SMB_FILE_MODE_INFORMATION:
4718 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4719 SIVAL(pdata,0,mode);
4720 data_size = 4;
4721 break;
4722
4723 case SMB_FILE_ALIGNMENT_INFORMATION:
4724 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4725 SIVAL(pdata,0,0); /* No alignment needed. */
4726 data_size = 4;
4727 break;
4728
4729 /*
4730 * NT4 server just returns "invalid query" to this - if we try
4731 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4732 * want this. JRA.
4733 */
4734 /* The first statement above is false - verified using Thursby
4735 * client against NT4 -- gcolley.
4736 */
4737 case SMB_QUERY_FILE_STREAM_INFO:
4738 case SMB_FILE_STREAM_INFORMATION: {
4739 unsigned int num_streams = 0;
4740 struct stream_struct *streams = NULL;
4741
4742 DEBUG(10,("smbd_do_qfilepathinfo: "
4743 "SMB_FILE_STREAM_INFORMATION\n"));
4744
4745 if (is_ntfs_stream_smb_fname(smb_fname)) {
4746 return NT_STATUS_INVALID_PARAMETER;
4747 }
4748
4749 status = vfs_streaminfo(conn, fsp, smb_fname->base_name,
4750 talloc_tos(), &num_streams, &streams);
4751
4752 if (!NT_STATUS_IS_OK(status)) {
4753 DEBUG(10, ("could not get stream info: %s\n",
4754 nt_errstr(status)));
4755 return status;
4756 }
4757
4758 status = marshall_stream_info(num_streams, streams,
4759 pdata, max_data_bytes,
4760 &data_size);
4761
4762 if (!NT_STATUS_IS_OK(status)) {
4763 DEBUG(10, ("marshall_stream_info failed: %s\n",
4764 nt_errstr(status)));
4765 return status;
4766 }
4767
4768 TALLOC_FREE(streams);
4769
4770 break;
4771 }
4772 case SMB_QUERY_COMPRESSION_INFO:
4773 case SMB_FILE_COMPRESSION_INFORMATION:
4774 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4775 SOFF_T(pdata,0,file_size);
4776 SIVAL(pdata,8,0); /* ??? */
4777 SIVAL(pdata,12,0); /* ??? */
4778 data_size = 16;
4779 break;
4780
4781 case SMB_FILE_NETWORK_OPEN_INFORMATION:
4782 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4783 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4784 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4785 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4786 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4787 SOFF_T(pdata,32,allocation_size);
4788 SOFF_T(pdata,40,file_size);
4789 SIVAL(pdata,48,mode);
4790 SIVAL(pdata,52,0); /* ??? */
4791 data_size = 56;
4792 break;
4793
4794 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
4795 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4796 SIVAL(pdata,0,mode);
4797 SIVAL(pdata,4,0);
4798 data_size = 8;
4799 break;
4800
4801 /*
4802 * CIFS UNIX Extensions.
4803 */
4804
4805 case SMB_QUERY_FILE_UNIX_BASIC:
4806
4807 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4808 data_size = PTR_DIFF(pdata,(*ppdata));
4809
4810 DEBUG(4,("smbd_do_qfilepathinfo: "
4811 "SMB_QUERY_FILE_UNIX_BASIC\n"));
4812 dump_data(4, (uint8_t *)(*ppdata), data_size);
4813
4814 break;
4815
4816 case SMB_QUERY_FILE_UNIX_INFO2:
4817
4818 pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
4819 data_size = PTR_DIFF(pdata,(*ppdata));
4820
4821 {
4822 int i;
4823 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4824
4825 for (i=0; i<100; i++)
4826 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4827 DEBUG(4,("\n"));
4828 }
4829
4830 break;
4831
4832 case SMB_QUERY_FILE_UNIX_LINK:
4833 {
4834 int len;
4835 char *buffer = talloc_array(mem_ctx, char, PATH_MAX+1);
4836
4837 if (!buffer) {
4838 return NT_STATUS_NO_MEMORY;
4839 }
4840
4841 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4842 #ifdef S_ISLNK
4843 if(!S_ISLNK(psbuf->st_ex_mode)) {
4844 return NT_STATUS_DOS(ERRSRV, ERRbadlink);
4845 }
4846 #else
4847 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
4848 #endif
4849 len = SMB_VFS_READLINK(conn,
4850 smb_fname->base_name,
4851 buffer, PATH_MAX);
4852 if (len == -1) {
4853 return map_nt_error_from_unix(errno);
4854 }
4855 buffer[len] = 0;
4856 len = srvstr_push(dstart, flags2,
4857 pdata, buffer,
4858 PTR_DIFF(dend, pdata),
4859 STR_TERMINATE);
4860 pdata += len;
4861 data_size = PTR_DIFF(pdata,(*ppdata));
4862
4863 break;
4864 }
4865
4866 #if defined(HAVE_POSIX_ACLS)
4867 case SMB_QUERY_POSIX_ACL:
4868 {
4869 SMB_ACL_T file_acl = NULL;
4870 SMB_ACL_T def_acl = NULL;
4871 uint16 num_file_acls = 0;
4872 uint16 num_def_acls = 0;
4873
4874 if (fsp && fsp->fh->fd != -1) {
4875 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp);
4876 } else {
4877 file_acl =
4878 SMB_VFS_SYS_ACL_GET_FILE(conn,
4879 smb_fname->base_name,
4880 SMB_ACL_TYPE_ACCESS);
4881 }
4882
4883 if (file_acl == NULL && no_acl_syscall_error(errno)) {
4884 DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
4885 "not implemented on "
4886 "filesystem containing %s\n",
4887 smb_fname->base_name));
4888 return NT_STATUS_NOT_IMPLEMENTED;
4889 }
4890
4891 if (S_ISDIR(psbuf->st_ex_mode)) {
4892 if (fsp && fsp->is_directory) {
4893 def_acl =
4894 SMB_VFS_SYS_ACL_GET_FILE(
4895 conn,
4896 fsp->fsp_name->base_name,
4897 SMB_ACL_TYPE_DEFAULT);
4898 } else {
4899 def_acl =
4900 SMB_VFS_SYS_ACL_GET_FILE(
4901 conn,
4902 smb_fname->base_name,
4903 SMB_ACL_TYPE_DEFAULT);
4904 }
4905 def_acl = free_empty_sys_acl(conn, def_acl);
4906 }
4907
4908 num_file_acls = count_acl_entries(conn, file_acl);
4909 num_def_acls = count_acl_entries(conn, def_acl);
4910
4911 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4912 DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
4913 data_size,
4914 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4915 SMB_POSIX_ACL_HEADER_SIZE) ));
4916 if (file_acl) {
4917 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4918 }
4919 if (def_acl) {
4920 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4921 }
4922 return NT_STATUS_BUFFER_TOO_SMALL;
4923 }
4924
4925 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4926 SSVAL(pdata,2,num_file_acls);
4927 SSVAL(pdata,4,num_def_acls);
4928 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
4929 if (file_acl) {
4930 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4931 }
4932 if (def_acl) {
4933 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4934 }
4935 return NT_STATUS_INTERNAL_ERROR;
4936 }
4937 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
4938 if (file_acl) {
4939 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4940 }
4941 if (def_acl) {
4942 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4943 }
4944 return NT_STATUS_INTERNAL_ERROR;
4945 }
4946
4947 if (file_acl) {
4948 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4949 }
4950 if (def_acl) {
4951 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4952 }
4953 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4954 break;
4955 }
4956 #endif
4957
4958
4959 case SMB_QUERY_POSIX_LOCK:
4960 {
4961 uint64_t count;
4962 uint64_t offset;
4963 uint64_t smblctx;
4964 enum brl_type lock_type;
4965
4966 /* We need an open file with a real fd for this. */
4967 if (!fsp || fsp->fh->fd == -1) {
4968 return NT_STATUS_INVALID_LEVEL;
4969 }
4970
4971 if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
4972 return NT_STATUS_INVALID_PARAMETER;
4973 }
4974
4975 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4976 case POSIX_LOCK_TYPE_READ:
4977 lock_type = READ_LOCK;
4978 break;
4979 case POSIX_LOCK_TYPE_WRITE:
4980 lock_type = WRITE_LOCK;
4981 break;
4982 case POSIX_LOCK_TYPE_UNLOCK:
4983 default:
4984 /* There's no point in asking for an unlock... */
4985 return NT_STATUS_INVALID_PARAMETER;
4986 }
4987
4988 smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4989 #if defined(HAVE_LONGLONG)
4990 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4991 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4992 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4993 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4994 #else /* HAVE_LONGLONG */
4995 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4996 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4997 #endif /* HAVE_LONGLONG */
4998
4999 status = query_lock(fsp,
5000 &smblctx,
5001 &count,
5002 &offset,
5003 &lock_type,
5004 POSIX_LOCK);
5005
5006 if (ERROR_WAS_LOCK_DENIED(status)) {
5007 /* Here we need to report who has it locked... */
5008 data_size = POSIX_LOCK_DATA_SIZE;
5009
5010 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
5011 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
5012 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, (uint32_t)smblctx);
5013 #if defined(HAVE_LONGLONG)
5014 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
5015 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
5016 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
5017 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
5018 #else /* HAVE_LONGLONG */
5019 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
5020 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
5021 #endif /* HAVE_LONGLONG */
5022
5023 } else if (NT_STATUS_IS_OK(status)) {
5024 /* For success we just return a copy of what we sent
5025 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
5026 data_size = POSIX_LOCK_DATA_SIZE;
5027 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
5028 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
5029 } else {
5030 return status;
5031 }
5032 break;
5033 }
5034
5035 default:
5036 return NT_STATUS_INVALID_LEVEL;
5037 }
5038
5039 *pdata_size = data_size;
5040 return NT_STATUS_OK;
5041 }
5042
5043 /****************************************************************************
5044 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
5045 file name or file id).
5046 ****************************************************************************/
5047
5048 static void call_trans2qfilepathinfo(connection_struct *conn,
5049 struct smb_request *req,
5050 unsigned int tran_call,
5051 char **pparams, int total_params,
5052 char **ppdata, int total_data,
5053 unsigned int max_data_bytes)
5054 {
5055 char *params = *pparams;
5056 char *pdata = *ppdata;
5057 uint16 info_level;
5058 unsigned int data_size = 0;
5059 unsigned int param_size = 2;
5060 struct smb_filename *smb_fname = NULL;
5061 bool delete_pending = False;
5062 struct timespec write_time_ts;
5063 files_struct *fsp = NULL;
5064 struct file_id fileid;
5065 struct ea_list *ea_list = NULL;
5066 int lock_data_count = 0;
5067 char *lock_data = NULL;
5068 NTSTATUS status = NT_STATUS_OK;
5069
5070 if (!params) {
5071 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5072 return;
5073 }
5074
5075 ZERO_STRUCT(write_time_ts);
5076
5077 if (tran_call == TRANSACT2_QFILEINFO) {
5078 if (total_params < 4) {
5079 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5080 return;
5081 }
5082
5083 if (IS_IPC(conn)) {
5084 call_trans2qpipeinfo(conn, req, tran_call,
5085 pparams, total_params,
5086 ppdata, total_data,
5087 max_data_bytes);
5088 return;
5089 }
5090
5091 fsp = file_fsp(req, SVAL(params,0));
5092 info_level = SVAL(params,2);
5093
5094 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
5095
5096 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5097 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5098 return;
5099 }
5100
5101 /* Initial check for valid fsp ptr. */
5102 if (!check_fsp_open(conn, req, fsp)) {
5103 return;
5104 }
5105
5106 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
5107 &smb_fname);
5108 if (!NT_STATUS_IS_OK(status)) {
5109 reply_nterror(req, status);
5110 return;
5111 }
5112
5113 if(fsp->fake_file_handle) {
5114 /*
5115 * This is actually for the QUOTA_FAKE_FILE --metze
5116 */
5117
5118 /* We know this name is ok, it's already passed the checks. */
5119
5120 } else if(fsp->fh->fd == -1) {
5121 /*
5122 * This is actually a QFILEINFO on a directory
5123 * handle (returned from an NT SMB). NT5.0 seems
5124 * to do this call. JRA.
5125 */
5126
5127 if (INFO_LEVEL_IS_UNIX(info_level)) {
5128 /* Always do lstat for UNIX calls. */
5129 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5130 DEBUG(3,("call_trans2qfilepathinfo: "
5131 "SMB_VFS_LSTAT of %s failed "
5132 "(%s)\n",
5133 smb_fname_str_dbg(smb_fname),
5134 strerror(errno)));
5135 reply_nterror(req,
5136 map_nt_error_from_unix(errno));
5137 return;
5138 }
5139 } else if (SMB_VFS_STAT(conn, smb_fname)) {
5140 DEBUG(3,("call_trans2qfilepathinfo: "
5141 "SMB_VFS_STAT of %s failed (%s)\n",
5142 smb_fname_str_dbg(smb_fname),
5143 strerror(errno)));
5144 reply_nterror(req,
5145 map_nt_error_from_unix(errno));
5146 return;
5147 }
5148
5149 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5150 get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5151 } else {
5152 /*
5153 * Original code - this is an open file.
5154 */
5155 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5156 DEBUG(3, ("fstat of %s failed (%s)\n",
5157 fsp_fnum_dbg(fsp), strerror(errno)));
5158 reply_nterror(req,
5159 map_nt_error_from_unix(errno));
5160 return;
5161 }
5162 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5163 get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5164 }
5165
5166 } else {
5167 uint32_t name_hash;
5168 char *fname = NULL;
5169 uint32_t ucf_flags = 0;
5170
5171 /* qpathinfo */
5172 if (total_params < 7) {
5173 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5174 return;
5175 }
5176
5177 info_level = SVAL(params,0);
5178
5179 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5180
5181 if (INFO_LEVEL_IS_UNIX(info_level)) {
5182 if (!lp_unix_extensions()) {
5183 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5184 return;
5185 }
5186 if (info_level == SMB_QUERY_FILE_UNIX_BASIC ||
5187 info_level == SMB_QUERY_FILE_UNIX_INFO2 ||
5188 info_level == SMB_QUERY_FILE_UNIX_LINK) {
5189 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
5190 }
5191 }
5192
5193 srvstr_get_path(req, params, req->flags2, &fname, &params[6],
5194 total_params - 6,
5195 STR_TERMINATE, &status);
5196 if (!NT_STATUS_IS_OK(status)) {
5197 reply_nterror(req, status);
5198 return;
5199 }
5200
5201 status = filename_convert(req,
5202 conn,
5203 req->flags2 & FLAGS2_DFS_PATHNAMES,
5204 fname,
5205 ucf_flags,
5206 NULL,
5207 &smb_fname);
5208 if (!NT_STATUS_IS_OK(status)) {
5209 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5210 reply_botherror(req,
5211 NT_STATUS_PATH_NOT_COVERED,
5212 ERRSRV, ERRbadpath);
5213 return;
5214 }
5215 reply_nterror(req, status);
5216 return;
5217 }
5218
5219 /* If this is a stream, check if there is a delete_pending. */
5220 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5221 && is_ntfs_stream_smb_fname(smb_fname)) {
5222 struct smb_filename *smb_fname_base = NULL;
5223
5224 /* Create an smb_filename with stream_name == NULL. */
5225 status =
5226 create_synthetic_smb_fname(talloc_tos(),
5227 smb_fname->base_name,
5228 NULL, NULL,
5229 &smb_fname_base);
5230 if (!NT_STATUS_IS_OK(status)) {
5231 reply_nterror(req, status);
5232 return;
5233 }
5234
5235 if (INFO_LEVEL_IS_UNIX(info_level)) {
5236 /* Always do lstat for UNIX calls. */
5237 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5238 DEBUG(3,("call_trans2qfilepathinfo: "
5239 "SMB_VFS_LSTAT of %s failed "
5240 "(%s)\n",
5241 smb_fname_str_dbg(smb_fname_base),
5242 strerror(errno)));
5243 TALLOC_FREE(smb_fname_base);
5244 reply_nterror(req,
5245 map_nt_error_from_unix(errno));
5246 return;
5247 }
5248 } else {
5249 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5250 DEBUG(3,("call_trans2qfilepathinfo: "
5251 "fileinfo of %s failed "
5252 "(%s)\n",
5253 smb_fname_str_dbg(smb_fname_base),
5254 strerror(errno)));
5255 TALLOC_FREE(smb_fname_base);
5256 reply_nterror(req,
5257 map_nt_error_from_unix(errno));
5258 return;
5259 }
5260 }
5261
5262 status = file_name_hash(conn,
5263 smb_fname_str_dbg(smb_fname_base),
5264 &name_hash);
5265 if (!NT_STATUS_IS_OK(status)) {
5266 TALLOC_FREE(smb_fname_base);
5267 reply_nterror(req, status);
5268 return;
5269 }
5270
5271 fileid = vfs_file_id_from_sbuf(conn,
5272 &smb_fname_base->st);
5273 TALLOC_FREE(smb_fname_base);
5274 get_file_infos(fileid, name_hash, &delete_pending, NULL);
5275 if (delete_pending) {
5276 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5277 return;
5278 }
5279 }
5280
5281 if (INFO_LEVEL_IS_UNIX(info_level)) {
5282 /* Always do lstat for UNIX calls. */
5283 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5284 DEBUG(3,("call_trans2qfilepathinfo: "
5285 "SMB_VFS_LSTAT of %s failed (%s)\n",
5286 smb_fname_str_dbg(smb_fname),
5287 strerror(errno)));
5288 reply_nterror(req,
5289 map_nt_error_from_unix(errno));
5290 return;
5291 }
5292
5293 } else {
5294 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
5295 DEBUG(3,("call_trans2qfilepathinfo: "
5296 "SMB_VFS_STAT of %s failed (%s)\n",
5297 smb_fname_str_dbg(smb_fname),
5298 strerror(errno)));
5299 reply_nterror(req,
5300 map_nt_error_from_unix(errno));
5301 return;
5302 }
5303 }
5304
5305 status = file_name_hash(conn,
5306 smb_fname_str_dbg(smb_fname),
5307 &name_hash);
5308 if (!NT_STATUS_IS_OK(status)) {
5309 reply_nterror(req, status);
5310 return;
5311 }
5312
5313 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5314 get_file_infos(fileid, name_hash, &delete_pending, &write_time_ts);
5315 if (delete_pending) {
5316 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5317 return;
5318 }
5319 }
5320
5321 DEBUG(3,("call_trans2qfilepathinfo %s (%s) level=%d call=%d "
5322 "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5323 fsp_fnum_dbg(fsp),
5324 info_level,tran_call,total_data));
5325
5326 /* Pull out any data sent here before we realloc. */
5327 switch (info_level) {
5328 case SMB_INFO_QUERY_EAS_FROM_LIST:
5329 {
5330 /* Pull any EA list from the data portion. */
5331 uint32 ea_size;
5332
5333 if (total_data < 4) {
5334 reply_nterror(
5335 req, NT_STATUS_INVALID_PARAMETER);
5336 return;
5337 }
5338 ea_size = IVAL(pdata,0);
5339
5340 if (total_data > 0 && ea_size != total_data) {
5341 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5342 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5343 reply_nterror(
5344 req, NT_STATUS_INVALID_PARAMETER);
5345 return;
5346 }
5347
5348 if (!lp_ea_support(SNUM(conn))) {
5349 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
5350 return;
5351 }
5352
5353 /* Pull out the list of names. */
5354 ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
5355 if (!ea_list) {
5356 reply_nterror(
5357 req, NT_STATUS_INVALID_PARAMETER);
5358 return;
5359 }
5360 break;
5361 }
5362
5363 case SMB_QUERY_POSIX_LOCK:
5364 {
5365 if (fsp == NULL || fsp->fh->fd == -1) {
5366 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
5367 return;
5368 }
5369
5370 if (total_data != POSIX_LOCK_DATA_SIZE) {
5371 reply_nterror(
5372 req, NT_STATUS_INVALID_PARAMETER);
5373 return;
5374 }
5375
5376 /* Copy the lock range data. */
5377 lock_data = (char *)talloc_memdup(
5378 req, pdata, total_data);
5379 if (!lock_data) {
5380 reply_nterror(req, NT_STATUS_NO_MEMORY);
5381 return;
5382 }
5383 lock_data_count = total_data;
5384 }
5385 default:
5386 break;
5387 }
5388
5389 *pparams = (char *)SMB_REALLOC(*pparams,2);
5390 if (*pparams == NULL) {
5391 reply_nterror(req, NT_STATUS_NO_MEMORY);
5392 return;
5393 }
5394 params = *pparams;
5395 SSVAL(params,0,0);
5396
5397 /*
5398 * draft-leach-cifs-v1-spec-02.txt
5399 * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
5400 * says:
5401 *
5402 * The requested information is placed in the Data portion of the
5403 * transaction response. For the information levels greater than 0x100,
5404 * the transaction response has 1 parameter word which should be
5405 * ignored by the client.
5406 *
5407 * However Windows only follows this rule for the IS_NAME_VALID call.
5408 */
5409 switch (info_level) {
5410 case SMB_INFO_IS_NAME_VALID:
5411 param_size = 0;
5412 break;
5413 }
5414
5415 if ((info_level & 0xFF00) == 0xFF00) {
5416 /*
5417 * We use levels that start with 0xFF00
5418 * internally to represent SMB2 specific levels
5419 */
5420 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5421 return;
5422 }
5423
5424 status = smbd_do_qfilepathinfo(conn, req, info_level,
5425 fsp, smb_fname,
5426 delete_pending, write_time_ts,
5427 ea_list,
5428 lock_data_count, lock_data,
5429 req->flags2, max_data_bytes,
5430 ppdata, &data_size);
5431 if (!NT_STATUS_IS_OK(status)) {
5432 reply_nterror(req, status);
5433 return;
5434 }
5435
5436 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
5437 max_data_bytes);
5438
5439 return;
5440 }
5441
5442 /****************************************************************************
5443 Set a hard link (called by UNIX extensions and by NT rename with HARD link
5444 code.
5445 ****************************************************************************/
5446
5447 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
5448 connection_struct *conn,
5449 struct smb_request *req,
5450 bool overwrite_if_exists,
5451 const struct smb_filename *smb_fname_old,
5452 struct smb_filename *smb_fname_new)
5453 {
5454 NTSTATUS status = NT_STATUS_OK;
5455
5456 /* source must already exist. */
5457 if (!VALID_STAT(smb_fname_old->st)) {
5458 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5459 }
5460
5461 if (VALID_STAT(smb_fname_new->st)) {
5462 if (overwrite_if_exists) {
5463 if (S_ISDIR(smb_fname_new->st.st_ex_mode)) {
5464 return NT_STATUS_FILE_IS_A_DIRECTORY;
5465 }
5466 status = unlink_internals(conn,
5467 req,
5468 FILE_ATTRIBUTE_NORMAL,
5469 smb_fname_new,
5470 false);
5471 if (!NT_STATUS_IS_OK(status)) {
5472 return status;
5473 }
5474 } else {
5475 /* Disallow if newname already exists. */
5476 return NT_STATUS_OBJECT_NAME_COLLISION;
5477 }
5478 }
5479
5480 /* No links from a directory. */
5481 if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
5482 return NT_STATUS_FILE_IS_A_DIRECTORY;
5483 }
5484
5485 /* Setting a hardlink to/from a stream isn't currently supported. */
5486 if (is_ntfs_stream_smb_fname(smb_fname_old) ||
5487 is_ntfs_stream_smb_fname(smb_fname_new)) {
5488 return NT_STATUS_INVALID_PARAMETER;
5489 }
5490
5491 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
5492 smb_fname_old->base_name, smb_fname_new->base_name));
5493
5494 if (SMB_VFS_LINK(conn, smb_fname_old->base_name,
5495 smb_fname_new->base_name) != 0) {
5496 status = map_nt_error_from_unix(errno);
5497 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
5498 nt_errstr(status), smb_fname_old->base_name,
5499 smb_fname_new->base_name));
5500 }
5501 return status;
5502 }
5503
5504 /****************************************************************************
5505 Deal with setting the time from any of the setfilepathinfo functions.
5506 NOTE !!!! The check for FILE_WRITE_ATTRIBUTES access must be done *before*
5507 calling this function.
5508 ****************************************************************************/
5509
5510 NTSTATUS smb_set_file_time(connection_struct *conn,
5511 files_struct *fsp,
5512 const struct smb_filename *smb_fname,
5513 struct smb_file_time *ft,
5514 bool setting_write_time)
5515 {
5516 struct smb_filename smb_fname_base;
5517 uint32 action =
5518 FILE_NOTIFY_CHANGE_LAST_ACCESS
5519 |FILE_NOTIFY_CHANGE_LAST_WRITE
5520 |FILE_NOTIFY_CHANGE_CREATION;
5521
5522 if (!VALID_STAT(smb_fname->st)) {
5523 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5524 }
5525
5526 /* get some defaults (no modifications) if any info is zero or -1. */
5527 if (null_timespec(ft->create_time)) {
5528 action &= ~FILE_NOTIFY_CHANGE_CREATION;
5529 }
5530
5531 if (null_timespec(ft->atime)) {
5532 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
5533 }
5534
5535 if (null_timespec(ft->mtime)) {
5536 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5537 }
5538
5539 if (!setting_write_time) {
5540 /* ft->mtime comes from change time, not write time. */
5541 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5542 }
5543
5544 /* Ensure the resolution is the correct for
5545 * what we can store on this filesystem. */
5546
5547 round_timespec(conn->ts_res, &ft->create_time);
5548 round_timespec(conn->ts_res, &ft->ctime);
5549 round_timespec(conn->ts_res, &ft->atime);
5550 round_timespec(conn->ts_res, &ft->mtime);
5551
5552 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5553 time_to_asc(convert_timespec_to_time_t(ft->atime))));
5554 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5555 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5556 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5557 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
5558 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5559 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5560
5561 if (setting_write_time) {
5562 /*
5563 * This was a Windows setfileinfo on an open file.
5564 * NT does this a lot. We also need to
5565 * set the time here, as it can be read by
5566 * FindFirst/FindNext and with the patch for bug #2045
5567 * in smbd/fileio.c it ensures that this timestamp is
5568 * kept sticky even after a write. We save the request
5569 * away and will set it on file close and after a write. JRA.
5570 */
5571
5572 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5573 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5574
5575 if (fsp != NULL) {
5576 if (fsp->base_fsp) {
5577 set_sticky_write_time_fsp(fsp->base_fsp,
5578 ft->mtime);
5579 } else {
5580 set_sticky_write_time_fsp(fsp, ft->mtime);
5581 }
5582 } else {
5583 set_sticky_write_time_path(
5584 vfs_file_id_from_sbuf(conn, &smb_fname->st),
5585 ft->mtime);
5586 }
5587 }
5588
5589 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5590
5591 /* Always call ntimes on the base, even if a stream was passed in. */
5592 smb_fname_base = *smb_fname;
5593 smb_fname_base.stream_name = NULL;
5594
5595 if(file_ntimes(conn, &smb_fname_base, ft)!=0) {
5596 return map_nt_error_from_unix(errno);
5597 }
5598
5599 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
5600 smb_fname->base_name);
5601 return NT_STATUS_OK;
5602 }
5603
5604 /****************************************************************************
5605 Deal with setting the dosmode from any of the setfilepathinfo functions.
5606 NB. The check for FILE_WRITE_ATTRIBUTES access on this path must have been
5607 done before calling this function.
5608 ****************************************************************************/
5609
5610 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
5611 const struct smb_filename *smb_fname,
5612 uint32 dosmode)
5613 {
5614 struct smb_filename *smb_fname_base = NULL;
5615 NTSTATUS status;
5616
5617 if (!VALID_STAT(smb_fname->st)) {
5618 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5619 }
5620
5621 /* Always operate on the base_name, even if a stream was passed in. */
5622 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5623 NULL, &smb_fname->st,
5624 &smb_fname_base);
5625 if (!NT_STATUS_IS_OK(status)) {
5626 return status;
5627 }
5628
5629 if (dosmode) {
5630 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
5631 dosmode |= FILE_ATTRIBUTE_DIRECTORY;
5632 } else {
5633 dosmode &= ~FILE_ATTRIBUTE_DIRECTORY;
5634 }
5635 }
5636
5637 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
5638
5639 /* check the mode isn't different, before changing it */
5640 if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
5641 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5642 "0x%x\n", smb_fname_str_dbg(smb_fname_base),
5643 (unsigned int)dosmode));
5644
5645 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
5646 false)) {
5647 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5648 "%s failed (%s)\n",
5649 smb_fname_str_dbg(smb_fname_base),
5650 strerror(errno)));
5651 status = map_nt_error_from_unix(errno);
5652 goto out;
5653 }
5654 }
5655 status = NT_STATUS_OK;
5656 out:
5657 TALLOC_FREE(smb_fname_base);
5658 return status;
5659 }
5660
5661 /****************************************************************************
5662 Deal with setting the size from any of the setfilepathinfo functions.
5663 ****************************************************************************/
5664
5665 static NTSTATUS smb_set_file_size(connection_struct *conn,
5666 struct smb_request *req,
5667 files_struct *fsp,
5668 const struct smb_filename *smb_fname,
5669 const SMB_STRUCT_STAT *psbuf,
5670 off_t size,
5671 bool fail_after_createfile)
5672 {
5673 NTSTATUS status = NT_STATUS_OK;
5674 struct smb_filename *smb_fname_tmp = NULL;
5675 files_struct *new_fsp = NULL;
5676
5677 if (!VALID_STAT(*psbuf)) {
5678 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5679 }
5680
5681 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
5682
5683 if (size == get_file_size_stat(psbuf)) {
5684 return NT_STATUS_OK;
5685 }
5686
5687 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5688 smb_fname_str_dbg(smb_fname), (double)size));
5689
5690 if (fsp && fsp->fh->fd != -1) {
5691 /* Handle based call. */
5692 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
5693 return NT_STATUS_ACCESS_DENIED;
5694 }
5695
5696 if (vfs_set_filelen(fsp, size) == -1) {
5697 return map_nt_error_from_unix(errno);
5698 }
5699 trigger_write_time_update_immediate(fsp);
5700 return NT_STATUS_OK;
5701 }
5702
5703 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
5704 if (!NT_STATUS_IS_OK(status)) {
5705 return status;
5706 }
5707
5708 smb_fname_tmp->st = *psbuf;
5709
5710 status = SMB_VFS_CREATE_FILE(
5711 conn, /* conn */
5712 req, /* req */
5713 0, /* root_dir_fid */
5714 smb_fname_tmp, /* fname */
5715 FILE_WRITE_DATA, /* access_mask */
5716 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
5717 FILE_SHARE_DELETE),
5718 FILE_OPEN, /* create_disposition*/
5719 0, /* create_options */
5720 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
5721 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
5722 0, /* allocation_size */
5723 0, /* private_flags */
5724 NULL, /* sd */
5725 NULL, /* ea_list */
5726 &new_fsp, /* result */
5727 NULL); /* pinfo */
5728
5729 TALLOC_FREE(smb_fname_tmp);
5730
5731 if (!NT_STATUS_IS_OK(status)) {
5732 /* NB. We check for open_was_deferred in the caller. */
5733 return status;
5734 }
5735
5736 /* See RAW-SFILEINFO-END-OF-FILE */
5737 if (fail_after_createfile) {
5738 close_file(req, new_fsp,NORMAL_CLOSE);
5739 return NT_STATUS_INVALID_LEVEL;
5740 }
5741
5742 if (vfs_set_filelen(new_fsp, size) == -1) {
5743 status = map_nt_error_from_unix(errno);
5744 close_file(req, new_fsp,NORMAL_CLOSE);
5745 return status;
5746 }
5747
5748 trigger_write_time_update_immediate(new_fsp);
5749 close_file(req, new_fsp,NORMAL_CLOSE);
5750 return NT_STATUS_OK;
5751 }
5752
5753 /****************************************************************************
5754 Deal with SMB_INFO_SET_EA.
5755 ****************************************************************************/
5756
5757 static NTSTATUS smb_info_set_ea(connection_struct *conn,
5758 const char *pdata,
5759 int total_data,
5760 files_struct *fsp,
5761 const struct smb_filename *smb_fname)
5762 {
5763 struct ea_list *ea_list = NULL;
5764 TALLOC_CTX *ctx = NULL;
5765 NTSTATUS status = NT_STATUS_OK;
5766
5767 if (total_data < 10) {
5768
5769 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5770 length. They seem to have no effect. Bug #3212. JRA */
5771
5772 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
5773 /* We're done. We only get EA info in this call. */
5774 return NT_STATUS_OK;
5775 }
5776
5777 return NT_STATUS_INVALID_PARAMETER;
5778 }
5779
5780 if (IVAL(pdata,0) > total_data) {
5781 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5782 IVAL(pdata,0), (unsigned int)total_data));
5783 return NT_STATUS_INVALID_PARAMETER;
5784 }
5785
5786 ctx = talloc_tos();
5787 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
5788 if (!ea_list) {
5789 return NT_STATUS_INVALID_PARAMETER;
5790 }
5791
5792 status = set_ea(conn, fsp, smb_fname, ea_list);
5793
5794 return status;
5795 }
5796
5797 /****************************************************************************
5798 Deal with SMB_FILE_FULL_EA_INFORMATION set.
5799 ****************************************************************************/
5800
5801 static NTSTATUS smb_set_file_full_ea_info(connection_struct *conn,
5802 const char *pdata,
5803 int total_data,
5804 files_struct *fsp)
5805 {
5806 struct ea_list *ea_list = NULL;
5807 NTSTATUS status;
5808
5809 if (!fsp) {
5810 return NT_STATUS_INVALID_HANDLE;
5811 }
5812
5813 if (!lp_ea_support(SNUM(conn))) {
5814 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
5815 "EA's not supported.\n",
5816 (unsigned int)total_data));
5817 return NT_STATUS_EAS_NOT_SUPPORTED;
5818 }
5819
5820 if (total_data < 10) {
5821 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
5822 "too small.\n",
5823 (unsigned int)total_data));
5824 return NT_STATUS_INVALID_PARAMETER;
5825 }
5826
5827 ea_list = read_nttrans_ea_list(talloc_tos(),
5828 pdata,
5829 total_data);
5830
5831 if (!ea_list) {
5832 return NT_STATUS_INVALID_PARAMETER;
5833 }
5834
5835 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
5836
5837 DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
5838 smb_fname_str_dbg(fsp->fsp_name),
5839 nt_errstr(status) ));
5840
5841 return status;
5842 }
5843
5844
5845 /****************************************************************************
5846 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5847 ****************************************************************************/
5848
5849 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
5850 const char *pdata,
5851 int total_data,
5852 files_struct *fsp,
5853 struct smb_filename *smb_fname)
5854 {
5855 NTSTATUS status = NT_STATUS_OK;
5856 bool delete_on_close;
5857 uint32 dosmode = 0;
5858
5859 if (total_data < 1) {
5860 return NT_STATUS_INVALID_PARAMETER;
5861 }
5862
5863 if (fsp == NULL) {
5864 return NT_STATUS_INVALID_HANDLE;
5865 }
5866
5867 delete_on_close = (CVAL(pdata,0) ? True : False);
5868 dosmode = dos_mode(conn, smb_fname);
5869
5870 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5871 "delete_on_close = %u\n",
5872 smb_fname_str_dbg(smb_fname),
5873 (unsigned int)dosmode,
5874 (unsigned int)delete_on_close ));
5875
5876 if (delete_on_close) {
5877 status = can_set_delete_on_close(fsp, dosmode);
5878 if (!NT_STATUS_IS_OK(status)) {
5879 return status;
5880 }
5881 }
5882
5883 /* The set is across all open files on this dev/inode pair. */
5884 if (!set_delete_on_close(fsp, delete_on_close,
5885 conn->session_info->security_token,
5886 conn->session_info->unix_token)) {
5887 return NT_STATUS_ACCESS_DENIED;
5888 }
5889 return NT_STATUS_OK;
5890 }
5891
5892 /****************************************************************************
5893 Deal with SMB_FILE_POSITION_INFORMATION.
5894 ****************************************************************************/
5895
5896 static NTSTATUS smb_file_position_information(connection_struct *conn,
5897 const char *pdata,
5898 int total_data,
5899 files_struct *fsp)
5900 {
5901 uint64_t position_information;
5902
5903 if (total_data < 8) {
5904 return NT_STATUS_INVALID_PARAMETER;
5905 }
5906
5907 if (fsp == NULL) {
5908 /* Ignore on pathname based set. */
5909 return NT_STATUS_OK;
5910 }
5911
5912 position_information = (uint64_t)IVAL(pdata,0);
5913 position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
5914
5915 DEBUG(10,("smb_file_position_information: Set file position "
5916 "information for file %s to %.0f\n", fsp_str_dbg(fsp),
5917 (double)position_information));
5918 fsp->fh->position_information = position_information;
5919 return NT_STATUS_OK;
5920 }
5921
5922 /****************************************************************************
5923 Deal with SMB_FILE_MODE_INFORMATION.
5924 ****************************************************************************/
5925
5926 static NTSTATUS smb_file_mode_information(connection_struct *conn,
5927 const char *pdata,
5928 int total_data)
5929 {
5930 uint32 mode;
5931
5932 if (total_data < 4) {
5933 return NT_STATUS_INVALID_PARAMETER;
5934 }
5935 mode = IVAL(pdata,0);
5936 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
5937 return NT_STATUS_INVALID_PARAMETER;
5938 }
5939 return NT_STATUS_OK;
5940 }
5941
5942 /****************************************************************************
5943 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5944 ****************************************************************************/
5945
5946 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
5947 struct smb_request *req,
5948 const char *pdata,
5949 int total_data,
5950 const struct smb_filename *smb_fname)
5951 {
5952 char *link_target = NULL;
5953 const char *newname = smb_fname->base_name;
5954 TALLOC_CTX *ctx = talloc_tos();
5955
5956 /* Set a symbolic link. */
5957 /* Don't allow this if follow links is false. */
5958
5959 if (total_data == 0) {
5960 return NT_STATUS_INVALID_PARAMETER;
5961 }
5962
5963 if (!lp_symlinks(SNUM(conn))) {
5964 return NT_STATUS_ACCESS_DENIED;
5965 }
5966
5967 srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
5968 total_data, STR_TERMINATE);
5969
5970 if (!link_target) {
5971 return NT_STATUS_INVALID_PARAMETER;
5972 }
5973
5974 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5975 newname, link_target ));
5976
5977 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
5978 return map_nt_error_from_unix(errno);
5979 }
5980
5981 return NT_STATUS_OK;
5982 }
5983
5984 /****************************************************************************
5985 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5986 ****************************************************************************/
5987
5988 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
5989 struct smb_request *req,
5990 const char *pdata, int total_data,
5991 struct smb_filename *smb_fname_new)
5992 {
5993 char *oldname = NULL;
5994 struct smb_filename *smb_fname_old = NULL;
5995 TALLOC_CTX *ctx = talloc_tos();
5996 NTSTATUS status = NT_STATUS_OK;
5997
5998 /* Set a hard link. */
5999 if (total_data == 0) {
6000 return NT_STATUS_INVALID_PARAMETER;
6001 }
6002
6003 srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
6004 total_data, STR_TERMINATE, &status);
6005 if (!NT_STATUS_IS_OK(status)) {
6006 return status;
6007 }
6008
6009 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
6010 smb_fname_str_dbg(smb_fname_new), oldname));
6011
6012 status = filename_convert(ctx,
6013 conn,
6014 req->flags2 & FLAGS2_DFS_PATHNAMES,
6015 oldname,
6016 0,
6017 NULL,
6018 &smb_fname_old);
6019 if (!NT_STATUS_IS_OK(status)) {
6020 return status;
6021 }
6022
6023 return hardlink_internals(ctx, conn, req, false,
6024 smb_fname_old, smb_fname_new);
6025 }
6026
6027 /****************************************************************************
6028 Deal with SMB2_FILE_RENAME_INFORMATION_INTERNAL
6029 ****************************************************************************/
6030
6031 static NTSTATUS smb2_file_rename_information(connection_struct *conn,
6032 struct smb_request *req,
6033 const char *pdata,
6034 int total_data,
6035 files_struct *fsp,
6036 struct smb_filename *smb_fname_src)
6037 {
6038 bool overwrite;
6039 uint32_t len;
6040 char *newname = NULL;
6041 struct smb_filename *smb_fname_dst = NULL;
6042 NTSTATUS status = NT_STATUS_OK;
6043 TALLOC_CTX *ctx = talloc_tos();
6044
6045 if (!fsp) {
6046 return NT_STATUS_INVALID_HANDLE;
6047 }
6048
6049 if (total_data < 20) {
6050 return NT_STATUS_INVALID_PARAMETER;
6051 }
6052
6053 overwrite = (CVAL(pdata,0) ? True : False);
6054 len = IVAL(pdata,16);
6055
6056 if (len > (total_data - 20) || (len == 0)) {
6057 return NT_STATUS_INVALID_PARAMETER;
6058 }
6059
6060 srvstr_get_path(ctx, pdata, req->flags2, &newname,
6061 &pdata[20], len, STR_TERMINATE,
6062 &status);
6063 if (!NT_STATUS_IS_OK(status)) {
6064 return status;
6065 }
6066
6067 DEBUG(10,("smb2_file_rename_information: got name |%s|\n",
6068 newname));
6069
6070 status = filename_convert(ctx,
6071 conn,
6072 req->flags2 & FLAGS2_DFS_PATHNAMES,
6073 newname,
6074 UCF_SAVE_LCOMP,
6075 NULL,
6076 &smb_fname_dst);
6077 if (!NT_STATUS_IS_OK(status)) {
6078 return status;
6079 }
6080
6081 if (fsp->base_fsp) {
6082 /* newname must be a stream name. */
6083 if (newname[0] != ':') {
6084 return NT_STATUS_NOT_SUPPORTED;
6085 }
6086
6087 /* Create an smb_fname to call rename_internals_fsp() with. */
6088 status = create_synthetic_smb_fname(talloc_tos(),
6089 fsp->base_fsp->fsp_name->base_name, newname, NULL,
6090 &smb_fname_dst);
6091 if (!NT_STATUS_IS_OK(status)) {
6092 goto out;
6093 }
6094
6095 /*
6096 * Set the original last component, since
6097 * rename_internals_fsp() requires it.
6098 */
6099 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6100 newname);
6101 if (smb_fname_dst->original_lcomp == NULL) {
6102 status = NT_STATUS_NO_MEMORY;
6103 goto out;
6104 }
6105
6106 }
6107
6108 DEBUG(10,("smb2_file_rename_information: "
6109 "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
6110 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6111 smb_fname_str_dbg(smb_fname_dst)));
6112 status = rename_internals_fsp(conn, fsp, smb_fname_dst,
6113 (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM),
6114 overwrite);
6115
6116 out:
6117 TALLOC_FREE(smb_fname_dst);
6118 return status;
6119 }
6120
6121 static NTSTATUS smb_file_link_information(connection_struct *conn,
6122 struct smb_request *req,
6123 const char *pdata,
6124 int total_data,
6125 files_struct *fsp,
6126 struct smb_filename *smb_fname_src)
6127 {
6128 bool overwrite;
6129 uint32_t len;
6130 char *newname = NULL;
6131 struct smb_filename *smb_fname_dst = NULL;
6132 NTSTATUS status = NT_STATUS_OK;
6133 TALLOC_CTX *ctx = talloc_tos();
6134
6135 if (!fsp) {
6136 return NT_STATUS_INVALID_HANDLE;
6137 }
6138
6139 if (total_data < 20) {
6140 return NT_STATUS_INVALID_PARAMETER;
6141 }
6142
6143 overwrite = (CVAL(pdata,0) ? true : false);
6144 len = IVAL(pdata,16);
6145
6146 if (len > (total_data - 20) || (len == 0)) {
6147 return NT_STATUS_INVALID_PARAMETER;
6148 }
6149
6150 srvstr_get_path(ctx, pdata, req->flags2, &newname,
6151 &pdata[20], len, STR_TERMINATE,
6152 &status);
6153 if (!NT_STATUS_IS_OK(status)) {
6154 return status;
6155 }
6156
6157 DEBUG(10,("smb_file_link_information: got name |%s|\n",
6158 newname));
6159
6160 status = filename_convert(ctx,
6161 conn,
6162 req->flags2 & FLAGS2_DFS_PATHNAMES,
6163 newname,
6164 UCF_SAVE_LCOMP,
6165 NULL,
6166 &smb_fname_dst);
6167 if (!NT_STATUS_IS_OK(status)) {
6168 return status;
6169 }
6170
6171 if (fsp->base_fsp) {
6172 /* No stream names. */
6173 return NT_STATUS_NOT_SUPPORTED;
6174 }
6175
6176 DEBUG(10,("smb_file_link_information: "
6177 "SMB_FILE_LINK_INFORMATION (%s) %s -> %s\n",
6178 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6179 smb_fname_str_dbg(smb_fname_dst)));
6180 status = hardlink_internals(ctx,
6181 conn,
6182 req,
6183 overwrite,
6184 fsp->fsp_name,
6185 smb_fname_dst);
6186
6187 TALLOC_FREE(smb_fname_dst);
6188 return status;
6189 }
6190
6191 /****************************************************************************
6192 Deal with SMB_FILE_RENAME_INFORMATION.
6193 ****************************************************************************/
6194
6195 static NTSTATUS smb_file_rename_information(connection_struct *conn,
6196 struct smb_request *req,
6197 const char *pdata,
6198 int total_data,
6199 files_struct *fsp,
6200 struct smb_filename *smb_fname_src)
6201 {
6202 bool overwrite;
6203 uint32 root_fid;
6204 uint32 len;
6205 char *newname = NULL;
6206 struct smb_filename *smb_fname_dst = NULL;
6207 bool dest_has_wcard = False;
6208 NTSTATUS status = NT_STATUS_OK;
6209 char *p;
6210 TALLOC_CTX *ctx = talloc_tos();
6211
6212 if (total_data < 13) {
6213 return NT_STATUS_INVALID_PARAMETER;
6214 }
6215
6216 overwrite = (CVAL(pdata,0) ? True : False);
6217 root_fid = IVAL(pdata,4);
6218 len = IVAL(pdata,8);
6219
6220 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
6221 return NT_STATUS_INVALID_PARAMETER;
6222 }
6223
6224 srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
6225 len, 0, &status,
6226 &dest_has_wcard);
6227 if (!NT_STATUS_IS_OK(status)) {
6228 return status;
6229 }
6230
6231 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
6232 newname));
6233
6234 status = resolve_dfspath_wcard(ctx, conn,
6235 req->flags2 & FLAGS2_DFS_PATHNAMES,
6236 newname,
6237 true,
6238 !conn->sconn->using_smb2,
6239 &newname,
6240 &dest_has_wcard);
6241 if (!NT_STATUS_IS_OK(status)) {
6242 return status;
6243 }
6244
6245 /* Check the new name has no '/' characters. */
6246 if (strchr_m(newname, '/')) {
6247 return NT_STATUS_NOT_SUPPORTED;
6248 }
6249
6250 if (fsp && fsp->base_fsp) {
6251 /* newname must be a stream name. */
6252 if (newname[0] != ':') {
6253 return NT_STATUS_NOT_SUPPORTED;
6254 }
6255
6256 /* Create an smb_fname to call rename_internals_fsp() with. */
6257 status = create_synthetic_smb_fname(talloc_tos(),
6258 fsp->base_fsp->fsp_name->base_name, newname, NULL,
6259 &smb_fname_dst);
6260 if (!NT_STATUS_IS_OK(status)) {
6261 goto out;
6262 }
6263
6264 /*
6265 * Set the original last component, since
6266 * rename_internals_fsp() requires it.
6267 */
6268 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6269 newname);
6270 if (smb_fname_dst->original_lcomp == NULL) {
6271 status = NT_STATUS_NO_MEMORY;
6272 goto out;
6273 }
6274
6275 } else {
6276 /*
6277 * Build up an smb_fname_dst based on the filename passed in.
6278 * We basically just strip off the last component, and put on
6279 * the newname instead.
6280 */
6281 char *base_name = NULL;
6282
6283 /* newname must *not* be a stream name. */
6284 if (newname[0] == ':') {
6285 return NT_STATUS_NOT_SUPPORTED;
6286 }
6287
6288 /*
6289 * Strip off the last component (filename) of the path passed
6290 * in.
6291 */
6292 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
6293 if (!base_name) {
6294 return NT_STATUS_NO_MEMORY;
6295 }
6296 p = strrchr_m(base_name, '/');
6297 if (p) {
6298 p[1] = '\0';
6299 } else {
6300 base_name = talloc_strdup(ctx, "");
6301 if (!base_name) {
6302 return NT_STATUS_NO_MEMORY;
6303 }
6304 }
6305 /* Append the new name. */
6306 base_name = talloc_asprintf_append(base_name,
6307 "%s",
6308 newname);
6309 if (!base_name) {
6310 return NT_STATUS_NO_MEMORY;
6311 }
6312
6313 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
6314 (UCF_SAVE_LCOMP |
6315 (dest_has_wcard ?
6316 UCF_ALWAYS_ALLOW_WCARD_LCOMP :
6317 0)));
6318
6319 /* If an error we expect this to be
6320 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6321
6322 if (!NT_STATUS_IS_OK(status)) {
6323 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
6324 status)) {
6325 goto out;
6326 }
6327 /* Create an smb_fname to call rename_internals_fsp() */
6328 status = create_synthetic_smb_fname(ctx,
6329 base_name, NULL,
6330 NULL,
6331 &smb_fname_dst);
6332 if (!NT_STATUS_IS_OK(status)) {
6333 goto out;
6334 }
6335 }
6336 }
6337
6338 if (fsp) {
6339 DEBUG(10,("smb_file_rename_information: "
6340 "SMB_FILE_RENAME_INFORMATION (%s) %s -> %s\n",
6341 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
6342 smb_fname_str_dbg(smb_fname_dst)));
6343 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
6344 overwrite);
6345 } else {
6346 DEBUG(10,("smb_file_rename_information: "
6347 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6348 smb_fname_str_dbg(smb_fname_src),
6349 smb_fname_str_dbg(smb_fname_dst)));
6350 status = rename_internals(ctx, conn, req, smb_fname_src,
6351 smb_fname_dst, 0, overwrite, false,
6352 dest_has_wcard,
6353 FILE_WRITE_ATTRIBUTES);
6354 }
6355 out:
6356 TALLOC_FREE(smb_fname_dst);
6357 return status;
6358 }
6359
6360 /****************************************************************************
6361 Deal with SMB_SET_POSIX_ACL.
6362 ****************************************************************************/
6363
6364 #if defined(HAVE_POSIX_ACLS)
6365 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
6366 const char *pdata,
6367 int total_data,
6368 files_struct *fsp,
6369 const struct smb_filename *smb_fname)
6370 {
6371 uint16 posix_acl_version;
6372 uint16 num_file_acls;
6373 uint16 num_def_acls;
6374 bool valid_file_acls = True;
6375 bool valid_def_acls = True;
6376
6377 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
6378 return NT_STATUS_INVALID_PARAMETER;
6379 }
6380 posix_acl_version = SVAL(pdata,0);
6381 num_file_acls = SVAL(pdata,2);
6382 num_def_acls = SVAL(pdata,4);
6383
6384 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6385 valid_file_acls = False;
6386 num_file_acls = 0;
6387 }
6388
6389 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6390 valid_def_acls = False;
6391 num_def_acls = 0;
6392 }
6393
6394 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
6395 return NT_STATUS_INVALID_PARAMETER;
6396 }
6397
6398 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
6399 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
6400 return NT_STATUS_INVALID_PARAMETER;
6401 }
6402
6403 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6404 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
6405 (unsigned int)num_file_acls,
6406 (unsigned int)num_def_acls));
6407
6408 if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
6409 smb_fname->base_name, num_file_acls,
6410 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
6411 return map_nt_error_from_unix(errno);
6412 }
6413
6414 if (valid_def_acls && !set_unix_posix_default_acl(conn,
6415 smb_fname->base_name, &smb_fname->st, num_def_acls,
6416 pdata + SMB_POSIX_ACL_HEADER_SIZE +
6417 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
6418 return map_nt_error_from_unix(errno);
6419 }
6420 return NT_STATUS_OK;
6421 }
6422 #endif
6423
6424 /****************************************************************************
6425 Deal with SMB_SET_POSIX_LOCK.
6426 ****************************************************************************/
6427
6428 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
6429 struct smb_request *req,
6430 const char *pdata,
6431 int total_data,
6432 files_struct *fsp)
6433 {
6434 uint64_t count;
6435 uint64_t offset;
6436 uint64_t smblctx;
6437 bool blocking_lock = False;
6438 enum brl_type lock_type;
6439
6440 NTSTATUS status = NT_STATUS_OK;
6441
6442 if (fsp == NULL || fsp->fh->fd == -1) {
6443 return NT_STATUS_INVALID_HANDLE;
6444 }
6445
6446 if (total_data != POSIX_LOCK_DATA_SIZE) {
6447 return NT_STATUS_INVALID_PARAMETER;
6448 }
6449
6450 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
6451 case POSIX_LOCK_TYPE_READ:
6452 lock_type = READ_LOCK;
6453 break;
6454 case POSIX_LOCK_TYPE_WRITE:
6455 /* Return the right POSIX-mappable error code for files opened read-only. */
6456 if (!fsp->can_write) {
6457 return NT_STATUS_INVALID_HANDLE;
6458 }
6459 lock_type = WRITE_LOCK;
6460 break;
6461 case POSIX_LOCK_TYPE_UNLOCK:
6462 lock_type = UNLOCK_LOCK;
6463 break;
6464 default:
6465 return NT_STATUS_INVALID_PARAMETER;
6466 }
6467
6468 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
6469 blocking_lock = False;
6470 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
6471 blocking_lock = True;
6472 } else {
6473 return NT_STATUS_INVALID_PARAMETER;
6474 }
6475
6476 if (!lp_blocking_locks(SNUM(conn))) {
6477 blocking_lock = False;
6478 }
6479
6480 smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
6481 #if defined(HAVE_LONGLONG)
6482 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
6483 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
6484 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
6485 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
6486 #else /* HAVE_LONGLONG */
6487 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
6488 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
6489 #endif /* HAVE_LONGLONG */
6490
6491 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6492 "smblctx = %llu, count = %.0f, offset = %.0f\n",
6493 fsp_str_dbg(fsp),
6494 (unsigned int)lock_type,
6495 (unsigned long long)smblctx,
6496 (double)count,
6497 (double)offset ));
6498
6499 if (lock_type == UNLOCK_LOCK) {
6500 status = do_unlock(req->sconn->msg_ctx,
6501 fsp,
6502 smblctx,
6503 count,
6504 offset,
6505 POSIX_LOCK);
6506 } else {
6507 uint64_t block_smblctx;
6508
6509 struct byte_range_lock *br_lck = do_lock(req->sconn->msg_ctx,
6510 fsp,
6511 smblctx,
6512 count,
6513 offset,
6514 lock_type,
6515 POSIX_LOCK,
6516 blocking_lock,
6517 &status,
6518 &block_smblctx,
6519 NULL);
6520
6521 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
6522 /*
6523 * A blocking lock was requested. Package up
6524 * this smb into a queued request and push it
6525 * onto the blocking lock queue.
6526 */
6527 if(push_blocking_lock_request(br_lck,
6528 req,
6529 fsp,
6530 -1, /* infinite timeout. */
6531 0,
6532 smblctx,
6533 lock_type,
6534 POSIX_LOCK,
6535 offset,
6536 count,
6537 block_smblctx)) {
6538 TALLOC_FREE(br_lck);
6539 return status;
6540 }
6541 }
6542 TALLOC_FREE(br_lck);
6543 }
6544
6545 return status;
6546 }
6547
6548 /****************************************************************************
6549 Deal with SMB_SET_FILE_BASIC_INFO.
6550 ****************************************************************************/
6551
6552 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
6553 const char *pdata,
6554 int total_data,
6555 files_struct *fsp,
6556 const struct smb_filename *smb_fname)
6557 {
6558 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6559 struct smb_file_time ft;
6560 uint32 dosmode = 0;
6561 NTSTATUS status = NT_STATUS_OK;
6562
6563 ZERO_STRUCT(ft);
6564
6565 if (total_data < 36) {
6566 return NT_STATUS_INVALID_PARAMETER;
6567 }
6568
6569 status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
6570 if (!NT_STATUS_IS_OK(status)) {
6571 return status;
6572 }
6573
6574 /* Set the attributes */
6575 dosmode = IVAL(pdata,32);
6576 status = smb_set_file_dosmode(conn, smb_fname, dosmode);
6577 if (!NT_STATUS_IS_OK(status)) {
6578 return status;
6579 }
6580
6581 /* create time */
6582 ft.create_time = interpret_long_date(pdata);
6583
6584 /* access time */
6585 ft.atime = interpret_long_date(pdata+8);
6586
6587 /* write time. */
6588 ft.mtime = interpret_long_date(pdata+16);
6589
6590 /* change time. */
6591 ft.ctime = interpret_long_date(pdata+24);
6592
6593 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6594 smb_fname_str_dbg(smb_fname)));
6595
6596 return smb_set_file_time(conn, fsp, smb_fname, &ft,
6597 true);
6598 }
6599
6600 /****************************************************************************
6601 Deal with SMB_INFO_STANDARD.
6602 ****************************************************************************/
6603
6604 static NTSTATUS smb_set_info_standard(connection_struct *conn,
6605 const char *pdata,
6606 int total_data,
6607 files_struct *fsp,
6608 const struct smb_filename *smb_fname)
6609 {
6610 NTSTATUS status;
6611 struct smb_file_time ft;
6612
6613 ZERO_STRUCT(ft);
6614
6615 if (total_data < 12) {
6616 return NT_STATUS_INVALID_PARAMETER;
6617 }
6618
6619 /* create time */
6620 ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
6621 /* access time */
6622 ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
6623 /* write time */
6624 ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
6625
6626 DEBUG(10,("smb_set_info_standard: file %s\n",
6627 smb_fname_str_dbg(smb_fname)));
6628
6629 status = check_access(conn, fsp, smb_fname, FILE_WRITE_ATTRIBUTES);
6630 if (!NT_STATUS_IS_OK(status)) {
6631 return status;
6632 }
6633
6634 return smb_set_file_time(conn,
6635 fsp,
6636 smb_fname,
6637 &ft,
6638 true);
6639 }
6640
6641 /****************************************************************************
6642 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6643 ****************************************************************************/
6644
6645 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
6646 struct smb_request *req,
6647 const char *pdata,
6648 int total_data,
6649 files_struct *fsp,
6650 struct smb_filename *smb_fname)
6651 {
6652 uint64_t allocation_size = 0;
6653 NTSTATUS status = NT_STATUS_OK;
6654 files_struct *new_fsp = NULL;
6655
6656 if (!VALID_STAT(smb_fname->st)) {
6657 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6658 }
6659
6660 if (total_data < 8) {
6661 return NT_STATUS_INVALID_PARAMETER;
6662 }
6663
6664 allocation_size = (uint64_t)IVAL(pdata,0);
6665 allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
6666 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6667 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6668 (double)allocation_size));
6669
6670 if (allocation_size) {
6671 allocation_size = smb_roundup(conn, allocation_size);
6672 }
6673
6674 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6675 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
6676 (double)allocation_size));
6677
6678 if (fsp && fsp->fh->fd != -1) {
6679 /* Open file handle. */
6680 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
6681 return NT_STATUS_ACCESS_DENIED;
6682 }
6683
6684 /* Only change if needed. */
6685 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6686 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
6687 return map_nt_error_from_unix(errno);
6688 }
6689 }
6690 /* But always update the time. */
6691 /*
6692 * This is equivalent to a write. Ensure it's seen immediately
6693 * if there are no pending writes.
6694 */
6695 trigger_write_time_update_immediate(fsp);
6696 return NT_STATUS_OK;
6697 }
6698
6699 /* Pathname or stat or directory file. */
6700 status = SMB_VFS_CREATE_FILE(
6701 conn, /* conn */
6702 req, /* req */
6703 0, /* root_dir_fid */
6704 smb_fname, /* fname */
6705 FILE_WRITE_DATA, /* access_mask */
6706 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
6707 FILE_SHARE_DELETE),
6708 FILE_OPEN, /* create_disposition*/
6709 0, /* create_options */
6710 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
6711 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
6712 0, /* allocation_size */
6713 0, /* private_flags */
6714 NULL, /* sd */
6715 NULL, /* ea_list */
6716 &new_fsp, /* result */
6717 NULL); /* pinfo */
6718
6719 if (!NT_STATUS_IS_OK(status)) {
6720 /* NB. We check for open_was_deferred in the caller. */
6721 return status;
6722 }
6723
6724 /* Only change if needed. */
6725 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6726 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
6727 status = map_nt_error_from_unix(errno);
6728 close_file(req, new_fsp, NORMAL_CLOSE);
6729 return status;
6730 }
6731 }
6732
6733 /* Changing the allocation size should set the last mod time. */
6734 /*
6735 * This is equivalent to a write. Ensure it's seen immediately
6736 * if there are no pending writes.
6737 */
6738 trigger_write_time_update_immediate(new_fsp);
6739
6740 close_file(req, new_fsp, NORMAL_CLOSE);
6741 return NT_STATUS_OK;
6742 }
6743
6744 /****************************************************************************
6745 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6746 ****************************************************************************/
6747
6748 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
6749 struct smb_request *req,
6750 const char *pdata,
6751 int total_data,
6752 files_struct *fsp,
6753 const struct smb_filename *smb_fname,
6754 bool fail_after_createfile)
6755 {
6756 off_t size;
6757
6758 if (total_data < 8) {
6759 return NT_STATUS_INVALID_PARAMETER;
6760 }
6761
6762 size = IVAL(pdata,0);
6763 size |= (((off_t)IVAL(pdata,4)) << 32);
6764 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6765 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6766 (double)size));
6767
6768 return smb_set_file_size(conn, req,
6769 fsp,
6770 smb_fname,
6771 &smb_fname->st,
6772 size,
6773 fail_after_createfile);
6774 }
6775
6776 /****************************************************************************
6777 Allow a UNIX info mknod.
6778 ****************************************************************************/
6779
6780 static NTSTATUS smb_unix_mknod(connection_struct *conn,
6781 const char *pdata,
6782 int total_data,
6783 const struct smb_filename *smb_fname)
6784 {
6785 uint32 file_type = IVAL(pdata,56);
6786 #if defined(HAVE_MAKEDEV)
6787 uint32 dev_major = IVAL(pdata,60);
6788 uint32 dev_minor = IVAL(pdata,68);
6789 #endif
6790 SMB_DEV_T dev = (SMB_DEV_T)0;
6791 uint32 raw_unixmode = IVAL(pdata,84);
6792 NTSTATUS status;
6793 mode_t unixmode;
6794
6795 if (total_data < 100) {
6796 return NT_STATUS_INVALID_PARAMETER;
6797 }
6798
6799 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6800 PERM_NEW_FILE, &unixmode);
6801 if (!NT_STATUS_IS_OK(status)) {
6802 return status;
6803 }
6804
6805 #if defined(HAVE_MAKEDEV)
6806 dev = makedev(dev_major, dev_minor);
6807 #endif
6808
6809 switch (file_type) {
6810 #if defined(S_IFIFO)
6811 case UNIX_TYPE_FIFO:
6812 unixmode |= S_IFIFO;
6813 break;
6814 #endif
6815 #if defined(S_IFSOCK)
6816 case UNIX_TYPE_SOCKET:
6817 unixmode |= S_IFSOCK;
6818 break;
6819 #endif
6820 #if defined(S_IFCHR)
6821 case UNIX_TYPE_CHARDEV:
6822 unixmode |= S_IFCHR;
6823 break;
6824 #endif
6825 #if defined(S_IFBLK)
6826 case UNIX_TYPE_BLKDEV:
6827 unixmode |= S_IFBLK;
6828 break;
6829 #endif
6830 default:
6831 return NT_STATUS_INVALID_PARAMETER;
6832 }
6833
6834 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6835 "%.0f mode 0%o for file %s\n", (double)dev,
6836 (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
6837
6838 /* Ok - do the mknod. */
6839 if (SMB_VFS_MKNOD(conn, smb_fname->base_name, unixmode, dev) != 0) {
6840 return map_nt_error_from_unix(errno);
6841 }
6842
6843 /* If any of the other "set" calls fail we
6844 * don't want to end up with a half-constructed mknod.
6845 */
6846
6847 if (lp_inherit_perms(SNUM(conn))) {
6848 char *parent;
6849 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
6850 &parent, NULL)) {
6851 return NT_STATUS_NO_MEMORY;
6852 }
6853 inherit_access_posix_acl(conn, parent, smb_fname->base_name,
6854 unixmode);
6855 TALLOC_FREE(parent);
6856 }
6857
6858 return NT_STATUS_OK;
6859 }
6860
6861 /****************************************************************************
6862 Deal with SMB_SET_FILE_UNIX_BASIC.
6863 ****************************************************************************/
6864
6865 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
6866 struct smb_request *req,
6867 const char *pdata,
6868 int total_data,
6869 files_struct *fsp,
6870 const struct smb_filename *smb_fname)
6871 {
6872 struct smb_file_time ft;
6873 uint32 raw_unixmode;
6874 mode_t unixmode;
6875 off_t size = 0;
6876 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
6877 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
6878 NTSTATUS status = NT_STATUS_OK;
6879 bool delete_on_fail = False;
6880 enum perm_type ptype;
6881 files_struct *all_fsps = NULL;
6882 bool modify_mtime = true;
6883 struct file_id id;
6884 struct smb_filename *smb_fname_tmp = NULL;
6885 SMB_STRUCT_STAT sbuf;
6886
6887 ZERO_STRUCT(ft);
6888
6889 if (total_data < 100) {
6890 return NT_STATUS_INVALID_PARAMETER;
6891 }
6892
6893 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
6894 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
6895 size=IVAL(pdata,0); /* first 8 Bytes are size */
6896 size |= (((off_t)IVAL(pdata,4)) << 32);
6897 }
6898
6899 ft.atime = interpret_long_date(pdata+24); /* access_time */
6900 ft.mtime = interpret_long_date(pdata+32); /* modification_time */
6901 set_owner = (uid_t)IVAL(pdata,40);
6902 set_grp = (gid_t)IVAL(pdata,48);
6903 raw_unixmode = IVAL(pdata,84);
6904
6905 if (VALID_STAT(smb_fname->st)) {
6906 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
6907 ptype = PERM_EXISTING_DIR;
6908 } else {
6909 ptype = PERM_EXISTING_FILE;
6910 }
6911 } else {
6912 ptype = PERM_NEW_FILE;
6913 }
6914
6915 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6916 ptype, &unixmode);
6917 if (!NT_STATUS_IS_OK(status)) {
6918 return status;
6919 }
6920
6921 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6922 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6923 smb_fname_str_dbg(smb_fname), (double)size,
6924 (unsigned int)set_owner, (unsigned int)set_grp,
6925 (int)raw_unixmode));
6926
6927 sbuf = smb_fname->st;
6928
6929 if (!VALID_STAT(sbuf)) {
6930 /*
6931 * The only valid use of this is to create character and block
6932 * devices, and named pipes. This is deprecated (IMHO) and
6933 * a new info level should be used for mknod. JRA.
6934 */
6935
6936 status = smb_unix_mknod(conn,
6937 pdata,
6938 total_data,
6939 smb_fname);
6940 if (!NT_STATUS_IS_OK(status)) {
6941 return status;
6942 }
6943
6944 status = copy_smb_filename(talloc_tos(), smb_fname,
6945 &smb_fname_tmp);
6946 if (!NT_STATUS_IS_OK(status)) {
6947 return status;
6948 }
6949
6950 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
6951 status = map_nt_error_from_unix(errno);
6952 TALLOC_FREE(smb_fname_tmp);
6953 SMB_VFS_UNLINK(conn, smb_fname);
6954 return status;
6955 }
6956
6957 sbuf = smb_fname_tmp->st;
6958 smb_fname = smb_fname_tmp;
6959
6960 /* Ensure we don't try and change anything else. */
6961 raw_unixmode = SMB_MODE_NO_CHANGE;
6962 size = get_file_size_stat(&sbuf);
6963 ft.atime = sbuf.st_ex_atime;
6964 ft.mtime = sbuf.st_ex_mtime;
6965 /*
6966 * We continue here as we might want to change the
6967 * owner uid/gid.
6968 */
6969 delete_on_fail = True;
6970 }
6971
6972 #if 1
6973 /* Horrible backwards compatibility hack as an old server bug
6974 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6975 * */
6976
6977 if (!size) {
6978 size = get_file_size_stat(&sbuf);
6979 }
6980 #endif
6981
6982 /*
6983 * Deal with the UNIX specific mode set.
6984 */
6985
6986 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
6987 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6988 "setting mode 0%o for file %s\n",
6989 (unsigned int)unixmode,
6990 smb_fname_str_dbg(smb_fname)));
6991 if (SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode) != 0) {
6992 return map_nt_error_from_unix(errno);
6993 }
6994 }
6995
6996 /*
6997 * Deal with the UNIX specific uid set.
6998 */
6999
7000 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
7001 (sbuf.st_ex_uid != set_owner)) {
7002 int ret;
7003
7004 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7005 "changing owner %u for path %s\n",
7006 (unsigned int)set_owner,
7007 smb_fname_str_dbg(smb_fname)));
7008
7009 if (S_ISLNK(sbuf.st_ex_mode)) {
7010 ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name,
7011 set_owner, (gid_t)-1);
7012 } else {
7013 ret = SMB_VFS_CHOWN(conn, smb_fname->base_name,
7014 set_owner, (gid_t)-1);
7015 }
7016
7017 if (ret != 0) {
7018 status = map_nt_error_from_unix(errno);
7019 if (delete_on_fail) {
7020 SMB_VFS_UNLINK(conn, smb_fname);
7021 }
7022 return status;
7023 }
7024 }
7025
7026 /*
7027 * Deal with the UNIX specific gid set.
7028 */
7029
7030 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
7031 (sbuf.st_ex_gid != set_grp)) {
7032 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7033 "changing group %u for file %s\n",
7034 (unsigned int)set_owner,
7035 smb_fname_str_dbg(smb_fname)));
7036 if (SMB_VFS_CHOWN(conn, smb_fname->base_name, (uid_t)-1,
7037 set_grp) != 0) {
7038 status = map_nt_error_from_unix(errno);
7039 if (delete_on_fail) {
7040 SMB_VFS_UNLINK(conn, smb_fname);
7041 }
7042 return status;
7043 }
7044 }
7045
7046 /* Deal with any size changes. */
7047
7048 status = smb_set_file_size(conn, req,
7049 fsp,
7050 smb_fname,
7051 &sbuf,
7052 size,
7053 false);
7054 if (!NT_STATUS_IS_OK(status)) {
7055 return status;
7056 }
7057
7058 /* Deal with any time changes. */
7059 if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
7060 /* No change, don't cancel anything. */
7061 return status;
7062 }
7063
7064 id = vfs_file_id_from_sbuf(conn, &sbuf);
7065 for(all_fsps = file_find_di_first(conn->sconn, id); all_fsps;
7066 all_fsps = file_find_di_next(all_fsps)) {
7067 /*
7068 * We're setting the time explicitly for UNIX.
7069 * Cancel any pending changes over all handles.
7070 */
7071 all_fsps->update_write_time_on_close = false;
7072 TALLOC_FREE(all_fsps->update_write_time_event);
7073 }
7074
7075 /*
7076 * Override the "setting_write_time"
7077 * parameter here as it almost does what
7078 * we need. Just remember if we modified
7079 * mtime and send the notify ourselves.
7080 */
7081 if (null_timespec(ft.mtime)) {
7082 modify_mtime = false;
7083 }
7084
7085 status = smb_set_file_time(conn,
7086 fsp,
7087 smb_fname,
7088 &ft,
7089 false);
7090 if (modify_mtime) {
7091 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
7092 FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
7093 }
7094 return status;
7095 }
7096
7097 /****************************************************************************
7098 Deal with SMB_SET_FILE_UNIX_INFO2.
7099 ****************************************************************************/
7100
7101 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
7102 struct smb_request *req,
7103 const char *pdata,
7104 int total_data,
7105 files_struct *fsp,
7106 const struct smb_filename *smb_fname)
7107 {
7108 NTSTATUS status;
7109 uint32 smb_fflags;
7110 uint32 smb_fmask;
7111
7112 if (total_data < 116) {
7113 return NT_STATUS_INVALID_PARAMETER;
7114 }
7115
7116 /* Start by setting all the fields that are common between UNIX_BASIC
7117 * and UNIX_INFO2.
7118 */
7119 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
7120 fsp, smb_fname);
7121 if (!NT_STATUS_IS_OK(status)) {
7122 return status;
7123 }
7124
7125 smb_fflags = IVAL(pdata, 108);
7126 smb_fmask = IVAL(pdata, 112);
7127
7128 /* NB: We should only attempt to alter the file flags if the client
7129 * sends a non-zero mask.
7130 */
7131 if (smb_fmask != 0) {
7132 int stat_fflags = 0;
7133
7134 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
7135 smb_fmask, &stat_fflags)) {
7136 /* Client asked to alter a flag we don't understand. */
7137 return NT_STATUS_INVALID_PARAMETER;
7138 }
7139
7140 if (fsp && fsp->fh->fd != -1) {
7141 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
7142 return NT_STATUS_NOT_SUPPORTED;
7143 } else {
7144 if (SMB_VFS_CHFLAGS(conn, smb_fname->base_name,
7145 stat_fflags) != 0) {
7146 return map_nt_error_from_unix(errno);
7147 }
7148 }
7149 }
7150
7151 /* XXX: need to add support for changing the create_time here. You
7152 * can do this for paths on Darwin with setattrlist(2). The right way
7153 * to hook this up is probably by extending the VFS utimes interface.
7154 */
7155
7156 return NT_STATUS_OK;
7157 }
7158
7159 /****************************************************************************
7160 Create a directory with POSIX semantics.
7161 ****************************************************************************/
7162
7163 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
7164 struct smb_request *req,
7165 char **ppdata,
7166 int total_data,
7167 struct smb_filename *smb_fname,
7168 int *pdata_return_size)
7169 {
7170 NTSTATUS status = NT_STATUS_OK;
7171 uint32 raw_unixmode = 0;
7172 uint32 mod_unixmode = 0;
7173 mode_t unixmode = (mode_t)0;
7174 files_struct *fsp = NULL;
7175 uint16 info_level_return = 0;
7176 int info;
7177 char *pdata = *ppdata;
7178
7179 if (total_data < 18) {
7180 return NT_STATUS_INVALID_PARAMETER;
7181 }
7182
7183 raw_unixmode = IVAL(pdata,8);
7184 /* Next 4 bytes are not yet defined. */
7185
7186 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7187 PERM_NEW_DIR, &unixmode);
7188 if (!NT_STATUS_IS_OK(status)) {
7189 return status;
7190 }
7191
7192 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7193
7194 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
7195 smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
7196
7197 status = SMB_VFS_CREATE_FILE(
7198 conn, /* conn */
7199 req, /* req */
7200 0, /* root_dir_fid */
7201 smb_fname, /* fname */
7202 FILE_READ_ATTRIBUTES, /* access_mask */
7203 FILE_SHARE_NONE, /* share_access */
7204 FILE_CREATE, /* create_disposition*/
7205 FILE_DIRECTORY_FILE, /* create_options */
7206 mod_unixmode, /* file_attributes */
7207 0, /* oplock_request */
7208 0, /* allocation_size */
7209 0, /* private_flags */
7210 NULL, /* sd */
7211 NULL, /* ea_list */
7212 &fsp, /* result */
7213 &info); /* pinfo */
7214
7215 if (NT_STATUS_IS_OK(status)) {
7216 close_file(req, fsp, NORMAL_CLOSE);
7217 }
7218
7219 info_level_return = SVAL(pdata,16);
7220
7221 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7222 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7223 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7224 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7225 } else {
7226 *pdata_return_size = 12;
7227 }
7228
7229 /* Realloc the data size */
7230 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7231 if (*ppdata == NULL) {
7232 *pdata_return_size = 0;
7233 return NT_STATUS_NO_MEMORY;
7234 }
7235 pdata = *ppdata;
7236
7237 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7238 SSVAL(pdata,2,0); /* No fnum. */
7239 SIVAL(pdata,4,info); /* Was directory created. */
7240
7241 switch (info_level_return) {
7242 case SMB_QUERY_FILE_UNIX_BASIC:
7243 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7244 SSVAL(pdata,10,0); /* Padding. */
7245 store_file_unix_basic(conn, pdata + 12, fsp,
7246 &smb_fname->st);
7247 break;
7248 case SMB_QUERY_FILE_UNIX_INFO2:
7249 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7250 SSVAL(pdata,10,0); /* Padding. */
7251 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7252 &smb_fname->st);
7253 break;
7254 default:
7255 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7256 SSVAL(pdata,10,0); /* Padding. */
7257 break;
7258 }
7259
7260 return status;
7261 }
7262
7263 /****************************************************************************
7264 Open/Create a file with POSIX semantics.
7265 ****************************************************************************/
7266
7267 #define SMB_O_RDONLY_MAPPING (FILE_READ_DATA|FILE_READ_ATTRIBUTES|FILE_READ_EA)
7268 #define SMB_O_WRONLY_MAPPING (FILE_WRITE_DATA|FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA)
7269
7270 static NTSTATUS smb_posix_open(connection_struct *conn,
7271 struct smb_request *req,
7272 char **ppdata,
7273 int total_data,
7274 struct smb_filename *smb_fname,
7275 int *pdata_return_size)
7276 {
7277 bool extended_oplock_granted = False;
7278 char *pdata = *ppdata;
7279 uint32 flags = 0;
7280 uint32 wire_open_mode = 0;
7281 uint32 raw_unixmode = 0;
7282 uint32 mod_unixmode = 0;
7283 uint32 create_disp = 0;
7284 uint32 access_mask = 0;
7285 uint32 create_options = FILE_NON_DIRECTORY_FILE;
7286 NTSTATUS status = NT_STATUS_OK;
7287 mode_t unixmode = (mode_t)0;
7288 files_struct *fsp = NULL;
7289 int oplock_request = 0;
7290 int info = 0;
7291 uint16 info_level_return = 0;
7292
7293 if (total_data < 18) {
7294 return NT_STATUS_INVALID_PARAMETER;
7295 }
7296
7297 flags = IVAL(pdata,0);
7298 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
7299 if (oplock_request) {
7300 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
7301 }
7302
7303 wire_open_mode = IVAL(pdata,4);
7304
7305 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
7306 return smb_posix_mkdir(conn, req,
7307 ppdata,
7308 total_data,
7309 smb_fname,
7310 pdata_return_size);
7311 }
7312
7313 switch (wire_open_mode & SMB_ACCMODE) {
7314 case SMB_O_RDONLY:
7315 access_mask = SMB_O_RDONLY_MAPPING;
7316 break;
7317 case SMB_O_WRONLY:
7318 access_mask = SMB_O_WRONLY_MAPPING;
7319 break;
7320 case SMB_O_RDWR:
7321 access_mask = (SMB_O_RDONLY_MAPPING|
7322 SMB_O_WRONLY_MAPPING);
7323 break;
7324 default:
7325 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7326 (unsigned int)wire_open_mode ));
7327 return NT_STATUS_INVALID_PARAMETER;
7328 }
7329
7330 wire_open_mode &= ~SMB_ACCMODE;
7331
7332 /* First take care of O_CREAT|O_EXCL interactions. */
7333 switch (wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) {
7334 case (SMB_O_CREAT | SMB_O_EXCL):
7335 /* File exists fail. File not exist create. */
7336 create_disp = FILE_CREATE;
7337 break;
7338 case SMB_O_CREAT:
7339 /* File exists open. File not exist create. */
7340 create_disp = FILE_OPEN_IF;
7341 break;
7342 case 0:
7343 /* File exists open. File not exist fail. */
7344 create_disp = FILE_OPEN;
7345 break;
7346 case SMB_O_EXCL:
7347 /* O_EXCL on its own without O_CREAT is undefined. */
7348 default:
7349 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7350 (unsigned int)wire_open_mode ));
7351 return NT_STATUS_INVALID_PARAMETER;
7352 }
7353
7354 /* Next factor in the effects of O_TRUNC. */
7355 wire_open_mode &= ~(SMB_O_CREAT | SMB_O_EXCL);
7356
7357 if (wire_open_mode & SMB_O_TRUNC) {
7358 switch (create_disp) {
7359 case FILE_CREATE:
7360 /* (SMB_O_CREAT | SMB_O_EXCL | O_TRUNC) */
7361 /* Leave create_disp alone as
7362 (O_CREAT|O_EXCL|O_TRUNC) == (O_CREAT|O_EXCL)
7363 */
7364 /* File exists fail. File not exist create. */
7365 break;
7366 case FILE_OPEN_IF:
7367 /* SMB_O_CREAT | SMB_O_TRUNC */
7368 /* File exists overwrite. File not exist create. */
7369 create_disp = FILE_OVERWRITE_IF;
7370 break;
7371 case FILE_OPEN:
7372 /* SMB_O_TRUNC */
7373 /* File exists overwrite. File not exist fail. */
7374 create_disp = FILE_OVERWRITE;
7375 break;
7376 default:
7377 /* Cannot get here. */
7378 smb_panic("smb_posix_open: logic error");
7379 return NT_STATUS_INVALID_PARAMETER;
7380 }
7381 }
7382
7383 raw_unixmode = IVAL(pdata,8);
7384 /* Next 4 bytes are not yet defined. */
7385
7386 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7387 (VALID_STAT(smb_fname->st) ?
7388 PERM_EXISTING_FILE : PERM_NEW_FILE),
7389 &unixmode);
7390
7391 if (!NT_STATUS_IS_OK(status)) {
7392 return status;
7393 }
7394
7395 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7396
7397 if (wire_open_mode & SMB_O_SYNC) {
7398 create_options |= FILE_WRITE_THROUGH;
7399 }
7400 if (wire_open_mode & SMB_O_APPEND) {
7401 access_mask |= FILE_APPEND_DATA;
7402 }
7403 if (wire_open_mode & SMB_O_DIRECT) {
7404 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
7405 }
7406
7407 if ((wire_open_mode & SMB_O_DIRECTORY) ||
7408 VALID_STAT_OF_DIR(smb_fname->st)) {
7409 if (access_mask != SMB_O_RDONLY_MAPPING) {
7410 return NT_STATUS_FILE_IS_A_DIRECTORY;
7411 }
7412 create_options &= ~FILE_NON_DIRECTORY_FILE;
7413 create_options |= FILE_DIRECTORY_FILE;
7414 }
7415
7416 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7417 smb_fname_str_dbg(smb_fname),
7418 (unsigned int)wire_open_mode,
7419 (unsigned int)unixmode ));
7420
7421 status = SMB_VFS_CREATE_FILE(
7422 conn, /* conn */
7423 req, /* req */
7424 0, /* root_dir_fid */
7425 smb_fname, /* fname */
7426 access_mask, /* access_mask */
7427 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7428 FILE_SHARE_DELETE),
7429 create_disp, /* create_disposition*/
7430 create_options, /* create_options */
7431 mod_unixmode, /* file_attributes */
7432 oplock_request, /* oplock_request */
7433 0, /* allocation_size */
7434 0, /* private_flags */
7435 NULL, /* sd */
7436 NULL, /* ea_list */
7437 &fsp, /* result */
7438 &info); /* pinfo */
7439
7440 if (!NT_STATUS_IS_OK(status)) {
7441 return status;
7442 }
7443
7444 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
7445 extended_oplock_granted = True;
7446 }
7447
7448 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
7449 extended_oplock_granted = True;
7450 }
7451
7452 info_level_return = SVAL(pdata,16);
7453
7454 /* Allocate the correct return size. */
7455
7456 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7457 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7458 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7459 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7460 } else {
7461 *pdata_return_size = 12;
7462 }
7463
7464 /* Realloc the data size */
7465 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7466 if (*ppdata == NULL) {
7467 close_file(req, fsp, ERROR_CLOSE);
7468 *pdata_return_size = 0;
7469 return NT_STATUS_NO_MEMORY;
7470 }
7471 pdata = *ppdata;
7472
7473 if (extended_oplock_granted) {
7474 if (flags & REQUEST_BATCH_OPLOCK) {
7475 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
7476 } else {
7477 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
7478 }
7479 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
7480 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
7481 } else {
7482 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7483 }
7484
7485 SSVAL(pdata,2,fsp->fnum);
7486 SIVAL(pdata,4,info); /* Was file created etc. */
7487
7488 switch (info_level_return) {
7489 case SMB_QUERY_FILE_UNIX_BASIC:
7490 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7491 SSVAL(pdata,10,0); /* padding. */
7492 store_file_unix_basic(conn, pdata + 12, fsp,
7493 &smb_fname->st);
7494 break;
7495 case SMB_QUERY_FILE_UNIX_INFO2:
7496 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7497 SSVAL(pdata,10,0); /* padding. */
7498 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7499 &smb_fname->st);
7500 break;
7501 default:
7502 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7503 SSVAL(pdata,10,0); /* padding. */
7504 break;
7505 }
7506 return NT_STATUS_OK;
7507 }
7508
7509 /****************************************************************************
7510 Delete a file with POSIX semantics.
7511 ****************************************************************************/
7512
7513 static NTSTATUS smb_posix_unlink(connection_struct *conn,
7514 struct smb_request *req,
7515 const char *pdata,
7516 int total_data,
7517 struct smb_filename *smb_fname)
7518 {
7519 NTSTATUS status = NT_STATUS_OK;
7520 files_struct *fsp = NULL;
7521 uint16 flags = 0;
7522 char del = 1;
7523 int info = 0;
7524 int create_options = 0;
7525 int i;
7526 struct share_mode_lock *lck = NULL;
7527
7528 if (total_data < 2) {
7529 return NT_STATUS_INVALID_PARAMETER;
7530 }
7531
7532 flags = SVAL(pdata,0);
7533
7534 if (!VALID_STAT(smb_fname->st)) {
7535 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7536 }
7537
7538 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
7539 !VALID_STAT_OF_DIR(smb_fname->st)) {
7540 return NT_STATUS_NOT_A_DIRECTORY;
7541 }
7542
7543 DEBUG(10,("smb_posix_unlink: %s %s\n",
7544 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
7545 smb_fname_str_dbg(smb_fname)));
7546
7547 if (VALID_STAT_OF_DIR(smb_fname->st)) {
7548 create_options |= FILE_DIRECTORY_FILE;
7549 }
7550
7551 status = SMB_VFS_CREATE_FILE(
7552 conn, /* conn */
7553 req, /* req */
7554 0, /* root_dir_fid */
7555 smb_fname, /* fname */
7556 DELETE_ACCESS, /* access_mask */
7557 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7558 FILE_SHARE_DELETE),
7559 FILE_OPEN, /* create_disposition*/
7560 create_options, /* create_options */
7561 FILE_FLAG_POSIX_SEMANTICS|0777, /* file_attributes */
7562 0, /* oplock_request */
7563 0, /* allocation_size */
7564 0, /* private_flags */
7565 NULL, /* sd */
7566 NULL, /* ea_list */
7567 &fsp, /* result */
7568 &info); /* pinfo */
7569
7570 if (!NT_STATUS_IS_OK(status)) {
7571 return status;
7572 }
7573
7574 /*
7575 * Don't lie to client. If we can't really delete due to
7576 * non-POSIX opens return SHARING_VIOLATION.
7577 */
7578
7579 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
7580 if (lck == NULL) {
7581 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7582 "lock for file %s\n", fsp_str_dbg(fsp)));
7583 close_file(req, fsp, NORMAL_CLOSE);
7584 return NT_STATUS_INVALID_PARAMETER;
7585 }
7586
7587 /*
7588 * See if others still have the file open. If this is the case, then
7589 * don't delete. If all opens are POSIX delete we can set the delete
7590 * on close disposition.
7591 */
7592 for (i=0; i<lck->data->num_share_modes; i++) {
7593 struct share_mode_entry *e = &lck->data->share_modes[i];
7594 if (is_valid_share_mode_entry(e)) {
7595 if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
7596 continue;
7597 }
7598 if (share_mode_stale_pid(lck->data, i)) {
7599 continue;
7600 }
7601 /* Fail with sharing violation. */
7602 close_file(req, fsp, NORMAL_CLOSE);
7603 TALLOC_FREE(lck);
7604 return NT_STATUS_SHARING_VIOLATION;
7605 }
7606 }
7607
7608 /*
7609 * Set the delete on close.
7610 */
7611 status = smb_set_file_disposition_info(conn,
7612 &del,
7613 1,
7614 fsp,
7615 smb_fname);
7616
7617 if (!NT_STATUS_IS_OK(status)) {
7618 close_file(req, fsp, NORMAL_CLOSE);
7619 TALLOC_FREE(lck);
7620 return status;
7621 }
7622 TALLOC_FREE(lck);
7623 return close_file(req, fsp, NORMAL_CLOSE);
7624 }
7625
7626 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
7627 struct smb_request *req,
7628 TALLOC_CTX *mem_ctx,
7629 uint16_t info_level,
7630 files_struct *fsp,
7631 struct smb_filename *smb_fname,
7632 char **ppdata, int total_data,
7633 int *ret_data_size)
7634 {
7635 char *pdata = *ppdata;
7636 NTSTATUS status = NT_STATUS_OK;
7637 int data_return_size = 0;
7638
7639 *ret_data_size = 0;
7640
7641 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
7642 return NT_STATUS_INVALID_LEVEL;
7643 }
7644
7645 if (!CAN_WRITE(conn)) {
7646 /* Allow POSIX opens. The open path will deny
7647 * any non-readonly opens. */
7648 if (info_level != SMB_POSIX_PATH_OPEN) {
7649 return NT_STATUS_DOS(ERRSRV, ERRaccess);
7650 }
7651 }
7652
7653 DEBUG(3,("smbd_do_setfilepathinfo: %s (%s) info_level=%d "
7654 "totdata=%d\n", smb_fname_str_dbg(smb_fname),
7655 fsp_fnum_dbg(fsp),
7656 info_level, total_data));
7657
7658 switch (info_level) {
7659
7660 case SMB_INFO_STANDARD:
7661 {
7662 status = smb_set_info_standard(conn,
7663 pdata,
7664 total_data,
7665 fsp,
7666 smb_fname);
7667 break;
7668 }
7669
7670 case SMB_INFO_SET_EA:
7671 {
7672 status = smb_info_set_ea(conn,
7673 pdata,
7674 total_data,
7675 fsp,
7676 smb_fname);
7677 break;
7678 }
7679
7680 case SMB_SET_FILE_BASIC_INFO:
7681 case SMB_FILE_BASIC_INFORMATION:
7682 {
7683 status = smb_set_file_basic_info(conn,
7684 pdata,
7685 total_data,
7686 fsp,
7687 smb_fname);
7688 break;
7689 }
7690
7691 case SMB_FILE_ALLOCATION_INFORMATION:
7692 case SMB_SET_FILE_ALLOCATION_INFO:
7693 {
7694 status = smb_set_file_allocation_info(conn, req,
7695 pdata,
7696 total_data,
7697 fsp,
7698 smb_fname);
7699 break;
7700 }
7701
7702 case SMB_FILE_END_OF_FILE_INFORMATION:
7703 case SMB_SET_FILE_END_OF_FILE_INFO:
7704 {
7705 /*
7706 * XP/Win7 both fail after the createfile with
7707 * SMB_SET_FILE_END_OF_FILE_INFO but not
7708 * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
7709 * The level is known here, so pass it down
7710 * appropriately.
7711 */
7712 bool should_fail =
7713 (info_level == SMB_SET_FILE_END_OF_FILE_INFO);
7714
7715 status = smb_set_file_end_of_file_info(conn, req,
7716 pdata,
7717 total_data,
7718 fsp,
7719 smb_fname,
7720 should_fail);
7721 break;
7722 }
7723
7724 case SMB_FILE_DISPOSITION_INFORMATION:
7725 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
7726 {
7727 #if 0
7728 /* JRA - We used to just ignore this on a path ?
7729 * Shouldn't this be invalid level on a pathname
7730 * based call ?
7731 */
7732 if (tran_call != TRANSACT2_SETFILEINFO) {
7733 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
7734 }
7735 #endif
7736 status = smb_set_file_disposition_info(conn,
7737 pdata,
7738 total_data,
7739 fsp,
7740 smb_fname);
7741 break;
7742 }
7743
7744 case SMB_FILE_POSITION_INFORMATION:
7745 {
7746 status = smb_file_position_information(conn,
7747 pdata,
7748 total_data,
7749 fsp);
7750 break;
7751 }
7752
7753 case SMB_FILE_FULL_EA_INFORMATION:
7754 {
7755 status = smb_set_file_full_ea_info(conn,
7756 pdata,
7757 total_data,
7758 fsp);
7759 break;
7760 }
7761
7762 /* From tridge Samba4 :
7763 * MODE_INFORMATION in setfileinfo (I have no
7764 * idea what "mode information" on a file is - it takes a value of 0,
7765 * 2, 4 or 6. What could it be?).
7766 */
7767
7768 case SMB_FILE_MODE_INFORMATION:
7769 {
7770 status = smb_file_mode_information(conn,
7771 pdata,
7772 total_data);
7773 break;
7774 }
7775
7776 /*
7777 * CIFS UNIX extensions.
7778 */
7779
7780 case SMB_SET_FILE_UNIX_BASIC:
7781 {
7782 status = smb_set_file_unix_basic(conn, req,
7783 pdata,
7784 total_data,
7785 fsp,
7786 smb_fname);
7787 break;
7788 }
7789
7790 case SMB_SET_FILE_UNIX_INFO2:
7791 {
7792 status = smb_set_file_unix_info2(conn, req,
7793 pdata,
7794 total_data,
7795 fsp,
7796 smb_fname);
7797 break;
7798 }
7799
7800 case SMB_SET_FILE_UNIX_LINK:
7801 {
7802 if (fsp) {
7803 /* We must have a pathname for this. */
7804 return NT_STATUS_INVALID_LEVEL;
7805 }
7806 status = smb_set_file_unix_link(conn, req, pdata,
7807 total_data, smb_fname);
7808 break;
7809 }
7810
7811 case SMB_SET_FILE_UNIX_HLINK:
7812 {
7813 if (fsp) {
7814 /* We must have a pathname for this. */
7815 return NT_STATUS_INVALID_LEVEL;
7816 }
7817 status = smb_set_file_unix_hlink(conn, req,
7818 pdata, total_data,
7819 smb_fname);
7820 break;
7821 }
7822
7823 case SMB_FILE_RENAME_INFORMATION:
7824 {
7825 status = smb_file_rename_information(conn, req,
7826 pdata, total_data,
7827 fsp, smb_fname);
7828 break;
7829 }
7830
7831 case SMB2_FILE_RENAME_INFORMATION_INTERNAL:
7832 {
7833 /* SMB2 rename information. */
7834 status = smb2_file_rename_information(conn, req,
7835 pdata, total_data,
7836 fsp, smb_fname);
7837 break;
7838 }
7839
7840 case SMB_FILE_LINK_INFORMATION:
7841 {
7842 status = smb_file_link_information(conn, req,
7843 pdata, total_data,
7844 fsp, smb_fname);
7845 break;
7846 }
7847
7848 #if defined(HAVE_POSIX_ACLS)
7849 case SMB_SET_POSIX_ACL:
7850 {
7851 status = smb_set_posix_acl(conn,
7852 pdata,
7853 total_data,
7854 fsp,
7855 smb_fname);
7856 break;
7857 }
7858 #endif
7859
7860 case SMB_SET_POSIX_LOCK:
7861 {
7862 if (!fsp) {
7863 return NT_STATUS_INVALID_LEVEL;
7864 }
7865 status = smb_set_posix_lock(conn, req,
7866 pdata, total_data, fsp);
7867 break;
7868 }
7869
7870 case SMB_POSIX_PATH_OPEN:
7871 {
7872 if (fsp) {
7873 /* We must have a pathname for this. */
7874 return NT_STATUS_INVALID_LEVEL;
7875 }
7876
7877 status = smb_posix_open(conn, req,
7878 ppdata,
7879 total_data,
7880 smb_fname,
7881 &data_return_size);
7882 break;
7883 }
7884
7885 case SMB_POSIX_PATH_UNLINK:
7886 {
7887 if (fsp) {
7888 /* We must have a pathname for this. */
7889 return NT_STATUS_INVALID_LEVEL;
7890 }
7891
7892 status = smb_posix_unlink(conn, req,
7893 pdata,
7894 total_data,
7895 smb_fname);
7896 break;
7897 }
7898
7899 default:
7900 return NT_STATUS_INVALID_LEVEL;
7901 }
7902
7903 if (!NT_STATUS_IS_OK(status)) {
7904 return status;
7905 }
7906
7907 *ret_data_size = data_return_size;
7908 return NT_STATUS_OK;
7909 }
7910
7911 /****************************************************************************
7912 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7913 ****************************************************************************/
7914
7915 static void call_trans2setfilepathinfo(connection_struct *conn,
7916 struct smb_request *req,
7917 unsigned int tran_call,
7918 char **pparams, int total_params,
7919 char **ppdata, int total_data,
7920 unsigned int max_data_bytes)
7921 {
7922 char *params = *pparams;
7923 char *pdata = *ppdata;
7924 uint16 info_level;
7925 struct smb_filename *smb_fname = NULL;
7926 files_struct *fsp = NULL;
7927 NTSTATUS status = NT_STATUS_OK;
7928 int data_return_size = 0;
7929
7930 if (!params) {
7931 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7932 return;
7933 }
7934
7935 if (tran_call == TRANSACT2_SETFILEINFO) {
7936 if (total_params < 4) {
7937 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7938 return;
7939 }
7940
7941 fsp = file_fsp(req, SVAL(params,0));
7942 /* Basic check for non-null fsp. */
7943 if (!check_fsp_open(conn, req, fsp)) {
7944 return;
7945 }
7946 info_level = SVAL(params,2);
7947
7948 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
7949 &smb_fname);
7950 if (!NT_STATUS_IS_OK(status)) {
7951 reply_nterror(req, status);
7952 return;
7953 }
7954
7955 if(fsp->fh->fd == -1) {
7956 /*
7957 * This is actually a SETFILEINFO on a directory
7958 * handle (returned from an NT SMB). NT5.0 seems
7959 * to do this call. JRA.
7960 */
7961 if (INFO_LEVEL_IS_UNIX(info_level)) {
7962 /* Always do lstat for UNIX calls. */
7963 if (SMB_VFS_LSTAT(conn, smb_fname)) {
7964 DEBUG(3,("call_trans2setfilepathinfo: "
7965 "SMB_VFS_LSTAT of %s failed "
7966 "(%s)\n",
7967 smb_fname_str_dbg(smb_fname),
7968 strerror(errno)));
7969 reply_nterror(req, map_nt_error_from_unix(errno));
7970 return;
7971 }
7972 } else {
7973 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
7974 DEBUG(3,("call_trans2setfilepathinfo: "
7975 "fileinfo of %s failed (%s)\n",
7976 smb_fname_str_dbg(smb_fname),
7977 strerror(errno)));
7978 reply_nterror(req, map_nt_error_from_unix(errno));
7979 return;
7980 }
7981 }
7982 } else if (fsp->print_file) {
7983 /*
7984 * Doing a DELETE_ON_CLOSE should cancel a print job.
7985 */
7986 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
7987 fsp->fh->private_options |= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE;
7988
7989 DEBUG(3,("call_trans2setfilepathinfo: "
7990 "Cancelling print job (%s)\n",
7991 fsp_str_dbg(fsp)));
7992
7993 SSVAL(params,0,0);
7994 send_trans2_replies(conn, req, params, 2,
7995 *ppdata, 0,
7996 max_data_bytes);
7997 return;
7998 } else {
7999 reply_nterror(req,
8000 NT_STATUS_OBJECT_PATH_NOT_FOUND);
8001 return;
8002 }
8003 } else {
8004 /*
8005 * Original code - this is an open file.
8006 */
8007 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
8008 DEBUG(3,("call_trans2setfilepathinfo: fstat "
8009 "of %s failed (%s)\n", fsp_fnum_dbg(fsp),
8010 strerror(errno)));
8011 reply_nterror(req, map_nt_error_from_unix(errno));
8012 return;
8013 }
8014 }
8015 } else {
8016 char *fname = NULL;
8017 uint32_t ucf_flags = 0;
8018
8019 /* set path info */
8020 if (total_params < 7) {
8021 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8022 return;
8023 }
8024
8025 info_level = SVAL(params,0);
8026 srvstr_get_path(req, params, req->flags2, &fname, &params[6],
8027 total_params - 6, STR_TERMINATE,
8028 &status);
8029 if (!NT_STATUS_IS_OK(status)) {
8030 reply_nterror(req, status);
8031 return;
8032 }
8033
8034 if (info_level == SMB_SET_FILE_UNIX_BASIC ||
8035 info_level == SMB_SET_FILE_UNIX_INFO2 ||
8036 info_level == SMB_FILE_RENAME_INFORMATION ||
8037 info_level == SMB_POSIX_PATH_UNLINK) {
8038 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
8039 }
8040
8041 status = filename_convert(req, conn,
8042 req->flags2 & FLAGS2_DFS_PATHNAMES,
8043 fname,
8044 ucf_flags,
8045 NULL,
8046 &smb_fname);
8047 if (!NT_STATUS_IS_OK(status)) {
8048 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8049 reply_botherror(req,
8050 NT_STATUS_PATH_NOT_COVERED,
8051 ERRSRV, ERRbadpath);
8052 return;
8053 }
8054 reply_nterror(req, status);
8055 return;
8056 }
8057
8058 if (INFO_LEVEL_IS_UNIX(info_level)) {
8059 /*
8060 * For CIFS UNIX extensions the target name may not exist.
8061 */
8062
8063 /* Always do lstat for UNIX calls. */
8064 SMB_VFS_LSTAT(conn, smb_fname);
8065
8066 } else if (!VALID_STAT(smb_fname->st) &&
8067 SMB_VFS_STAT(conn, smb_fname)) {
8068 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
8069 "%s failed (%s)\n",
8070 smb_fname_str_dbg(smb_fname),
8071 strerror(errno)));
8072 reply_nterror(req, map_nt_error_from_unix(errno));
8073 return;
8074 }
8075 }
8076
8077 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (%s) info_level=%d "
8078 "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
8079 fsp_fnum_dbg(fsp),
8080 info_level,total_data));
8081
8082 /* Realloc the parameter size */
8083 *pparams = (char *)SMB_REALLOC(*pparams,2);
8084 if (*pparams == NULL) {
8085 reply_nterror(req, NT_STATUS_NO_MEMORY);
8086 return;
8087 }
8088 params = *pparams;
8089
8090 SSVAL(params,0,0);
8091
8092 status = smbd_do_setfilepathinfo(conn, req, req,
8093 info_level,
8094 fsp,
8095 smb_fname,
8096 ppdata, total_data,
8097 &data_return_size);
8098 if (!NT_STATUS_IS_OK(status)) {
8099 if (open_was_deferred(req->sconn, req->mid)) {
8100 /* We have re-scheduled this call. */
8101 return;
8102 }
8103 if (blocking_lock_was_deferred_smb1(req->sconn, req->mid)) {
8104 /* We have re-scheduled this call. */
8105 return;
8106 }
8107 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8108 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
8109 ERRSRV, ERRbadpath);
8110 return;
8111 }
8112 if (info_level == SMB_POSIX_PATH_OPEN) {
8113 reply_openerror(req, status);
8114 return;
8115 }
8116
8117 reply_nterror(req, status);
8118 return;
8119 }
8120
8121 send_trans2_replies(conn, req, params, 2, *ppdata, data_return_size,
8122 max_data_bytes);
8123
8124 return;
8125 }
8126
8127 /****************************************************************************
8128 Reply to a TRANS2_MKDIR (make directory with extended attributes).
8129 ****************************************************************************/
8130
8131 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
8132 char **pparams, int total_params,
8133 char **ppdata, int total_data,
8134 unsigned int max_data_bytes)
8135 {
8136 struct smb_filename *smb_dname = NULL;
8137 char *params = *pparams;
8138 char *pdata = *ppdata;
8139 char *directory = NULL;
8140 NTSTATUS status = NT_STATUS_OK;
8141 struct ea_list *ea_list = NULL;
8142 TALLOC_CTX *ctx = talloc_tos();
8143
8144 if (!CAN_WRITE(conn)) {
8145 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8146 return;
8147 }
8148
8149 if (total_params < 5) {
8150 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8151 return;
8152 }
8153
8154 srvstr_get_path(ctx, params, req->flags2, &directory, &params[4],
8155 total_params - 4, STR_TERMINATE,
8156 &status);
8157 if (!NT_STATUS_IS_OK(status)) {
8158 reply_nterror(req, status);
8159 return;
8160 }
8161
8162 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
8163
8164 status = filename_convert(ctx,
8165 conn,
8166 req->flags2 & FLAGS2_DFS_PATHNAMES,
8167 directory,
8168 0,
8169 NULL,
8170 &smb_dname);
8171
8172 if (!NT_STATUS_IS_OK(status)) {
8173 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8174 reply_botherror(req,
8175 NT_STATUS_PATH_NOT_COVERED,
8176 ERRSRV, ERRbadpath);
8177 return;
8178 }
8179 reply_nterror(req, status);
8180 return;
8181 }
8182
8183 /*
8184 * OS/2 workplace shell seems to send SET_EA requests of "null"
8185 * length (4 bytes containing IVAL 4).
8186 * They seem to have no effect. Bug #3212. JRA.
8187 */
8188
8189 if (total_data && (total_data != 4)) {
8190 /* Any data in this call is an EA list. */
8191 if (total_data < 10) {
8192 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8193 goto out;
8194 }
8195
8196 if (IVAL(pdata,0) > total_data) {
8197 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
8198 IVAL(pdata,0), (unsigned int)total_data));
8199 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8200 goto out;
8201 }
8202
8203 ea_list = read_ea_list(talloc_tos(), pdata + 4,
8204 total_data - 4);
8205 if (!ea_list) {
8206 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8207 goto out;
8208 }
8209
8210 if (!lp_ea_support(SNUM(conn))) {
8211 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
8212 goto out;
8213 }
8214 }
8215 /* If total_data == 4 Windows doesn't care what values
8216 * are placed in that field, it just ignores them.
8217 * The System i QNTC IBM SMB client puts bad values here,
8218 * so ignore them. */
8219
8220 status = create_directory(conn, req, smb_dname);
8221
8222 if (!NT_STATUS_IS_OK(status)) {
8223 reply_nterror(req, status);
8224 goto out;
8225 }
8226
8227 /* Try and set any given EA. */
8228 if (ea_list) {
8229 status = set_ea(conn, NULL, smb_dname, ea_list);
8230 if (!NT_STATUS_IS_OK(status)) {
8231 reply_nterror(req, status);
8232 goto out;
8233 }
8234 }
8235
8236 /* Realloc the parameter and data sizes */
8237 *pparams = (char *)SMB_REALLOC(*pparams,2);
8238 if(*pparams == NULL) {
8239 reply_nterror(req, NT_STATUS_NO_MEMORY);
8240 goto out;
8241 }
8242 params = *pparams;
8243
8244 SSVAL(params,0,0);
8245
8246 send_trans2_replies(conn, req, params, 2, *ppdata, 0, max_data_bytes);
8247
8248 out:
8249 TALLOC_FREE(smb_dname);
8250 return;
8251 }
8252
8253 /****************************************************************************
8254 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
8255 We don't actually do this - we just send a null response.
8256 ****************************************************************************/
8257
8258 static void call_trans2findnotifyfirst(connection_struct *conn,
8259 struct smb_request *req,
8260 char **pparams, int total_params,
8261 char **ppdata, int total_data,
8262 unsigned int max_data_bytes)
8263 {
8264 char *params = *pparams;
8265 uint16 info_level;
8266
8267 if (total_params < 6) {
8268 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8269 return;
8270 }
8271
8272 info_level = SVAL(params,4);
8273 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
8274
8275 switch (info_level) {
8276 case 1:
8277 case 2:
8278 break;
8279 default:
8280 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
8281 return;
8282 }
8283
8284 /* Realloc the parameter and data sizes */
8285 *pparams = (char *)SMB_REALLOC(*pparams,6);
8286 if (*pparams == NULL) {
8287 reply_nterror(req, NT_STATUS_NO_MEMORY);
8288 return;
8289 }
8290 params = *pparams;
8291
8292 SSVAL(params,0,fnf_handle);
8293 SSVAL(params,2,0); /* No changes */
8294 SSVAL(params,4,0); /* No EA errors */
8295
8296 fnf_handle++;
8297
8298 if(fnf_handle == 0)
8299 fnf_handle = 257;
8300
8301 send_trans2_replies(conn, req, params, 6, *ppdata, 0, max_data_bytes);
8302
8303 return;
8304 }
8305
8306 /****************************************************************************
8307 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
8308 changes). Currently this does nothing.
8309 ****************************************************************************/
8310
8311 static void call_trans2findnotifynext(connection_struct *conn,
8312 struct smb_request *req,
8313 char **pparams, int total_params,
8314 char **ppdata, int total_data,
8315 unsigned int max_data_bytes)
8316 {
8317 char *params = *pparams;
8318
8319 DEBUG(3,("call_trans2findnotifynext\n"));
8320
8321 /* Realloc the parameter and data sizes */
8322 *pparams = (char *)SMB_REALLOC(*pparams,4);
8323 if (*pparams == NULL) {
8324 reply_nterror(req, NT_STATUS_NO_MEMORY);
8325 return;
8326 }
8327 params = *pparams;
8328
8329 SSVAL(params,0,0); /* No changes */
8330 SSVAL(params,2,0); /* No EA errors */
8331
8332 send_trans2_replies(conn, req, params, 4, *ppdata, 0, max_data_bytes);
8333
8334 return;
8335 }
8336
8337 /****************************************************************************
8338 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
8339 ****************************************************************************/
8340
8341 static void call_trans2getdfsreferral(connection_struct *conn,
8342 struct smb_request *req,
8343 char **pparams, int total_params,
8344 char **ppdata, int total_data,
8345 unsigned int max_data_bytes)
8346 {
8347 char *params = *pparams;
8348 char *pathname = NULL;
8349 int reply_size = 0;
8350 int max_referral_level;
8351 NTSTATUS status = NT_STATUS_OK;
8352 TALLOC_CTX *ctx = talloc_tos();
8353
8354 DEBUG(10,("call_trans2getdfsreferral\n"));
8355
8356 if (total_params < 3) {
8357 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8358 return;
8359 }
8360
8361 max_referral_level = SVAL(params,0);
8362
8363 if(!lp_host_msdfs()) {
8364 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8365 return;
8366 }
8367
8368 srvstr_pull_talloc(ctx, params, req->flags2, &pathname, &params[2],
8369 total_params - 2, STR_TERMINATE);
8370 if (!pathname) {
8371 reply_nterror(req, NT_STATUS_NOT_FOUND);
8372 return;
8373 }
8374 if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
8375 ppdata,&status)) < 0) {
8376 reply_nterror(req, status);
8377 return;
8378 }
8379
8380 SSVAL((discard_const_p(uint8_t, req->inbuf)), smb_flg2,
8381 SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
8382 send_trans2_replies(conn, req,0,0,*ppdata,reply_size, max_data_bytes);
8383
8384 return;
8385 }
8386
8387 #define LMCAT_SPL 0x53
8388 #define LMFUNC_GETJOBID 0x60
8389
8390 /****************************************************************************
8391 Reply to a TRANS2_IOCTL - used for OS/2 printing.
8392 ****************************************************************************/
8393
8394 static void call_trans2ioctl(connection_struct *conn,
8395 struct smb_request *req,
8396 char **pparams, int total_params,
8397 char **ppdata, int total_data,
8398 unsigned int max_data_bytes)
8399 {
8400 char *pdata = *ppdata;
8401 files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
8402
8403 /* check for an invalid fid before proceeding */
8404
8405 if (!fsp) {
8406 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
8407 return;
8408 }
8409
8410 if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
8411 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8412 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
8413 if (*ppdata == NULL) {
8414 reply_nterror(req, NT_STATUS_NO_MEMORY);
8415 return;
8416 }
8417 pdata = *ppdata;
8418
8419 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8420 CAN ACCEPT THIS IN UNICODE. JRA. */
8421
8422 /* Job number */
8423 SSVAL(pdata, 0, print_spool_rap_jobid(fsp->print_file));
8424
8425 srvstr_push(pdata, req->flags2, pdata + 2,
8426 lp_netbios_name(), 15,
8427 STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
8428 srvstr_push(pdata, req->flags2, pdata+18,
8429 lp_servicename(talloc_tos(), SNUM(conn)), 13,
8430 STR_ASCII|STR_TERMINATE); /* Service name */
8431 send_trans2_replies(conn, req, *pparams, 0, *ppdata, 32,
8432 max_data_bytes);
8433 return;
8434 }
8435
8436 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8437 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8438 }
8439
8440 /****************************************************************************
8441 Reply to a SMBfindclose (stop trans2 directory search).
8442 ****************************************************************************/
8443
8444 void reply_findclose(struct smb_request *req)
8445 {
8446 int dptr_num;
8447 struct smbd_server_connection *sconn = req->sconn;
8448
8449 START_PROFILE(SMBfindclose);
8450
8451 if (req->wct < 1) {
8452 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8453 END_PROFILE(SMBfindclose);
8454 return;
8455 }
8456
8457 dptr_num = SVALS(req->vwv+0, 0);
8458
8459 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
8460
8461 dptr_close(sconn, &dptr_num);
8462
8463 reply_outbuf(req, 0, 0);
8464
8465 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
8466
8467 END_PROFILE(SMBfindclose);
8468 return;
8469 }
8470
8471 /****************************************************************************
8472 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8473 ****************************************************************************/
8474
8475 void reply_findnclose(struct smb_request *req)
8476 {
8477 int dptr_num;
8478
8479 START_PROFILE(SMBfindnclose);
8480
8481 if (req->wct < 1) {
8482 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8483 END_PROFILE(SMBfindnclose);
8484 return;
8485 }
8486
8487 dptr_num = SVAL(req->vwv+0, 0);
8488
8489 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
8490
8491 /* We never give out valid handles for a
8492 findnotifyfirst - so any dptr_num is ok here.
8493 Just ignore it. */
8494
8495 reply_outbuf(req, 0, 0);
8496
8497 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
8498
8499 END_PROFILE(SMBfindnclose);
8500 return;
8501 }
8502
8503 static void handle_trans2(connection_struct *conn, struct smb_request *req,
8504 struct trans_state *state)
8505 {
8506 if (get_Protocol() >= PROTOCOL_NT1) {
8507 req->flags2 |= 0x40; /* IS_LONG_NAME */
8508 SSVAL((discard_const_p(uint8_t, req->inbuf)),smb_flg2,req->flags2);
8509 }
8510
8511 if (conn->encrypt_level == Required && !req->encrypted) {
8512 if (state->call != TRANSACT2_QFSINFO &&
8513 state->call != TRANSACT2_SETFSINFO) {
8514 DEBUG(0,("handle_trans2: encryption required "
8515 "with call 0x%x\n",
8516 (unsigned int)state->call));
8517 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8518 return;
8519 }
8520 }
8521
8522 SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
8523
8524 /* Now we must call the relevant TRANS2 function */
8525 switch(state->call) {
8526 case TRANSACT2_OPEN:
8527 {
8528 START_PROFILE(Trans2_open);
8529 call_trans2open(conn, req,
8530 &state->param, state->total_param,
8531 &state->data, state->total_data,
8532 state->max_data_return);
8533 END_PROFILE(Trans2_open);
8534 break;
8535 }
8536
8537 case TRANSACT2_FINDFIRST:
8538 {
8539 START_PROFILE(Trans2_findfirst);
8540 call_trans2findfirst(conn, req,
8541 &state->param, state->total_param,
8542 &state->data, state->total_data,
8543 state->max_data_return);
8544 END_PROFILE(Trans2_findfirst);
8545 break;
8546 }
8547
8548 case TRANSACT2_FINDNEXT:
8549 {
8550 START_PROFILE(Trans2_findnext);
8551 call_trans2findnext(conn, req,
8552 &state->param, state->total_param,
8553 &state->data, state->total_data,
8554 state->max_data_return);
8555 END_PROFILE(Trans2_findnext);
8556 break;
8557 }
8558
8559 case TRANSACT2_QFSINFO:
8560 {
8561 START_PROFILE(Trans2_qfsinfo);
8562 call_trans2qfsinfo(conn, req,
8563 &state->param, state->total_param,
8564 &state->data, state->total_data,
8565 state->max_data_return);
8566 END_PROFILE(Trans2_qfsinfo);
8567 break;
8568 }
8569
8570 case TRANSACT2_SETFSINFO:
8571 {
8572 START_PROFILE(Trans2_setfsinfo);
8573 call_trans2setfsinfo(conn, req,
8574 &state->param, state->total_param,
8575 &state->data, state->total_data,
8576 state->max_data_return);
8577 END_PROFILE(Trans2_setfsinfo);
8578 break;
8579 }
8580
8581 case TRANSACT2_QPATHINFO:
8582 case TRANSACT2_QFILEINFO:
8583 {
8584 START_PROFILE(Trans2_qpathinfo);
8585 call_trans2qfilepathinfo(conn, req, state->call,
8586 &state->param, state->total_param,
8587 &state->data, state->total_data,
8588 state->max_data_return);
8589 END_PROFILE(Trans2_qpathinfo);
8590 break;
8591 }
8592
8593 case TRANSACT2_SETPATHINFO:
8594 case TRANSACT2_SETFILEINFO:
8595 {
8596 START_PROFILE(Trans2_setpathinfo);
8597 call_trans2setfilepathinfo(conn, req, state->call,
8598 &state->param, state->total_param,
8599 &state->data, state->total_data,
8600 state->max_data_return);
8601 END_PROFILE(Trans2_setpathinfo);
8602 break;
8603 }
8604
8605 case TRANSACT2_FINDNOTIFYFIRST:
8606 {
8607 START_PROFILE(Trans2_findnotifyfirst);
8608 call_trans2findnotifyfirst(conn, req,
8609 &state->param, state->total_param,
8610 &state->data, state->total_data,
8611 state->max_data_return);
8612 END_PROFILE(Trans2_findnotifyfirst);
8613 break;
8614 }
8615
8616 case TRANSACT2_FINDNOTIFYNEXT:
8617 {
8618 START_PROFILE(Trans2_findnotifynext);
8619 call_trans2findnotifynext(conn, req,
8620 &state->param, state->total_param,
8621 &state->data, state->total_data,
8622 state->max_data_return);
8623 END_PROFILE(Trans2_findnotifynext);
8624 break;
8625 }
8626
8627 case TRANSACT2_MKDIR:
8628 {
8629 START_PROFILE(Trans2_mkdir);
8630 call_trans2mkdir(conn, req,
8631 &state->param, state->total_param,
8632 &state->data, state->total_data,
8633 state->max_data_return);
8634 END_PROFILE(Trans2_mkdir);
8635 break;
8636 }
8637
8638 case TRANSACT2_GET_DFS_REFERRAL:
8639 {
8640 START_PROFILE(Trans2_get_dfs_referral);
8641 call_trans2getdfsreferral(conn, req,
8642 &state->param, state->total_param,
8643 &state->data, state->total_data,
8644 state->max_data_return);
8645 END_PROFILE(Trans2_get_dfs_referral);
8646 break;
8647 }
8648
8649 case TRANSACT2_IOCTL:
8650 {
8651 START_PROFILE(Trans2_ioctl);
8652 call_trans2ioctl(conn, req,
8653 &state->param, state->total_param,
8654 &state->data, state->total_data,
8655 state->max_data_return);
8656 END_PROFILE(Trans2_ioctl);
8657 break;
8658 }
8659
8660 default:
8661 /* Error in request */
8662 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
8663 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8664 }
8665 }
8666
8667 /****************************************************************************
8668 Reply to a SMBtrans2.
8669 ****************************************************************************/
8670
8671 void reply_trans2(struct smb_request *req)
8672 {
8673 connection_struct *conn = req->conn;
8674 unsigned int dsoff;
8675 unsigned int dscnt;
8676 unsigned int psoff;
8677 unsigned int pscnt;
8678 unsigned int tran_call;
8679 struct trans_state *state;
8680 NTSTATUS result;
8681
8682 START_PROFILE(SMBtrans2);
8683
8684 if (req->wct < 14) {
8685 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8686 END_PROFILE(SMBtrans2);
8687 return;
8688 }
8689
8690 dsoff = SVAL(req->vwv+12, 0);
8691 dscnt = SVAL(req->vwv+11, 0);
8692 psoff = SVAL(req->vwv+10, 0);
8693 pscnt = SVAL(req->vwv+9, 0);
8694 tran_call = SVAL(req->vwv+14, 0);
8695
8696 result = allow_new_trans(conn->pending_trans, req->mid);
8697 if (!NT_STATUS_IS_OK(result)) {
8698 DEBUG(2, ("Got invalid trans2 request: %s\n",
8699 nt_errstr(result)));
8700 reply_nterror(req, result);
8701 END_PROFILE(SMBtrans2);
8702 return;
8703 }
8704
8705 if (IS_IPC(conn)) {
8706 switch (tran_call) {
8707 /* List the allowed trans2 calls on IPC$ */
8708 case TRANSACT2_OPEN:
8709 case TRANSACT2_GET_DFS_REFERRAL:
8710 case TRANSACT2_QFILEINFO:
8711 case TRANSACT2_QFSINFO:
8712 case TRANSACT2_SETFSINFO:
8713 break;
8714 default:
8715 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8716 END_PROFILE(SMBtrans2);
8717 return;
8718 }
8719 }
8720
8721 if ((state = talloc(conn, struct trans_state)) == NULL) {
8722 DEBUG(0, ("talloc failed\n"));
8723 reply_nterror(req, NT_STATUS_NO_MEMORY);
8724 END_PROFILE(SMBtrans2);
8725 return;
8726 }
8727
8728 state->cmd = SMBtrans2;
8729
8730 state->mid = req->mid;
8731 state->vuid = req->vuid;
8732 state->setup_count = SVAL(req->vwv+13, 0);
8733 state->setup = NULL;
8734 state->total_param = SVAL(req->vwv+0, 0);
8735 state->param = NULL;
8736 state->total_data = SVAL(req->vwv+1, 0);
8737 state->data = NULL;
8738 state->max_param_return = SVAL(req->vwv+2, 0);
8739 state->max_data_return = SVAL(req->vwv+3, 0);
8740 state->max_setup_return = SVAL(req->vwv+4, 0);
8741 state->close_on_completion = BITSETW(req->vwv+5, 0);
8742 state->one_way = BITSETW(req->vwv+5, 1);
8743
8744 state->call = tran_call;
8745
8746 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8747 is so as a sanity check */
8748 if (state->setup_count != 1) {
8749 /*
8750 * Need to have rc=0 for ioctl to get job id for OS/2.
8751 * Network printing will fail if function is not successful.
8752 * Similar function in reply.c will be used if protocol
8753 * is LANMAN1.0 instead of LM1.2X002.
8754 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8755 * outbuf doesn't have to be set(only job id is used).
8756 */
8757 if ( (state->setup_count == 4)
8758 && (tran_call == TRANSACT2_IOCTL)
8759 && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
8760 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8761 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8762 } else {
8763 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
8764 DEBUG(2,("Transaction is %d\n",tran_call));
8765 TALLOC_FREE(state);
8766 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8767 END_PROFILE(SMBtrans2);
8768 return;
8769 }
8770 }
8771
8772 if ((dscnt > state->total_data) || (pscnt > state->total_param))
8773 goto bad_param;
8774
8775 if (state->total_data) {
8776
8777 if (trans_oob(state->total_data, 0, dscnt)
8778 || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
8779 goto bad_param;
8780 }
8781
8782 /* Can't use talloc here, the core routines do realloc on the
8783 * params and data. */
8784 state->data = (char *)SMB_MALLOC(state->total_data);
8785 if (state->data == NULL) {
8786 DEBUG(0,("reply_trans2: data malloc fail for %u "
8787 "bytes !\n", (unsigned int)state->total_data));
8788 TALLOC_FREE(state);
8789 reply_nterror(req, NT_STATUS_NO_MEMORY);
8790 END_PROFILE(SMBtrans2);
8791 return;
8792 }
8793
8794 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
8795 }
8796
8797 if (state->total_param) {
8798
8799 if (trans_oob(state->total_param, 0, pscnt)
8800 || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
8801 goto bad_param;
8802 }
8803
8804 /* Can't use talloc here, the core routines do realloc on the
8805 * params and data. */
8806 state->param = (char *)SMB_MALLOC(state->total_param);
8807 if (state->param == NULL) {
8808 DEBUG(0,("reply_trans: param malloc fail for %u "
8809 "bytes !\n", (unsigned int)state->total_param));
8810 SAFE_FREE(state->data);
8811 TALLOC_FREE(state);
8812 reply_nterror(req, NT_STATUS_NO_MEMORY);
8813 END_PROFILE(SMBtrans2);
8814 return;
8815 }
8816
8817 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
8818 }
8819
8820 state->received_data = dscnt;
8821 state->received_param = pscnt;
8822
8823 if ((state->received_param == state->total_param) &&
8824 (state->received_data == state->total_data)) {
8825
8826 handle_trans2(conn, req, state);
8827
8828 SAFE_FREE(state->data);
8829 SAFE_FREE(state->param);
8830 TALLOC_FREE(state);
8831 END_PROFILE(SMBtrans2);
8832 return;
8833 }
8834
8835 DLIST_ADD(conn->pending_trans, state);
8836
8837 /* We need to send an interim response then receive the rest
8838 of the parameter/data bytes */
8839 reply_outbuf(req, 0, 0);
8840 show_msg((char *)req->outbuf);
8841 END_PROFILE(SMBtrans2);
8842 return;
8843
8844 bad_param:
8845
8846 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8847 SAFE_FREE(state->data);
8848 SAFE_FREE(state->param);
8849 TALLOC_FREE(state);
8850 END_PROFILE(SMBtrans2);
8851 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8852 }
8853
8854
8855 /****************************************************************************
8856 Reply to a SMBtranss2
8857 ****************************************************************************/
8858
8859 void reply_transs2(struct smb_request *req)
8860 {
8861 connection_struct *conn = req->conn;
8862 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
8863 struct trans_state *state;
8864
8865 START_PROFILE(SMBtranss2);
8866
8867 show_msg((const char *)req->inbuf);
8868
8869 /* Windows clients expect all replies to
8870 a transact secondary (SMBtranss2 0x33)
8871 to have a command code of transact
8872 (SMBtrans2 0x32). See bug #8989
8873 and also [MS-CIFS] section 2.2.4.47.2
8874 for details.
8875 */
8876 req->cmd = SMBtrans2;
8877
8878 if (req->wct < 8) {
8879 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8880 END_PROFILE(SMBtranss2);
8881 return;
8882 }
8883
8884 for (state = conn->pending_trans; state != NULL;
8885 state = state->next) {
8886 if (state->mid == req->mid) {
8887 break;
8888 }
8889 }
8890
8891 if ((state == NULL) || (state->cmd != SMBtrans2)) {
8892 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8893 END_PROFILE(SMBtranss2);
8894 return;
8895 }
8896
8897 /* Revise state->total_param and state->total_data in case they have
8898 changed downwards */
8899
8900 if (SVAL(req->vwv+0, 0) < state->total_param)
8901 state->total_param = SVAL(req->vwv+0, 0);
8902 if (SVAL(req->vwv+1, 0) < state->total_data)
8903 state->total_data = SVAL(req->vwv+1, 0);
8904
8905 pcnt = SVAL(req->vwv+2, 0);
8906 poff = SVAL(req->vwv+3, 0);
8907 pdisp = SVAL(req->vwv+4, 0);
8908
8909 dcnt = SVAL(req->vwv+5, 0);
8910 doff = SVAL(req->vwv+6, 0);
8911 ddisp = SVAL(req->vwv+7, 0);
8912
8913 state->received_param += pcnt;
8914 state->received_data += dcnt;
8915
8916 if ((state->received_data > state->total_data) ||
8917 (state->received_param > state->total_param))
8918 goto bad_param;
8919
8920 if (pcnt) {
8921 if (trans_oob(state->total_param, pdisp, pcnt)
8922 || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
8923 goto bad_param;
8924 }
8925 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
8926 }
8927
8928 if (dcnt) {
8929 if (trans_oob(state->total_data, ddisp, dcnt)
8930 || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
8931 goto bad_param;
8932 }
8933 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
8934 }
8935
8936 if ((state->received_param < state->total_param) ||
8937 (state->received_data < state->total_data)) {
8938 END_PROFILE(SMBtranss2);
8939 return;
8940 }
8941
8942 handle_trans2(conn, req, state);
8943
8944 DLIST_REMOVE(conn->pending_trans, state);
8945 SAFE_FREE(state->data);
8946 SAFE_FREE(state->param);
8947 TALLOC_FREE(state);
8948
8949 END_PROFILE(SMBtranss2);
8950 return;
8951
8952 bad_param:
8953
8954 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8955 DLIST_REMOVE(conn->pending_trans, state);
8956 SAFE_FREE(state->data);
8957 SAFE_FREE(state->param);
8958 TALLOC_FREE(state);
8959 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8960 END_PROFILE(SMBtranss2);
8961 return;
8962 }
reg import