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