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