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