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