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