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