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