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