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