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