r25117: The mega-patch Jerry was waiting for. Remove all pstrings from
[tprouty/samba.git] / source / smbd / trans2.c
1 /*
2    Unix SMB/CIFS implementation.
3    SMB transaction2 handling
4    Copyright (C) Jeremy Allison                 1994-2007
5    Copyright (C) Stefan (metze) Metzmacher      2003
6    Copyright (C) Volker Lendecke                2005-2007
7    Copyright (C) Steve French                   2005
8    Copyright (C) James Peach                    2007
9
10    Extensively modified by Andrew Tridgell, 1995
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3 of the License, or
15    (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27
28 extern int max_send;
29 extern enum protocol_types Protocol;
30 extern 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 void send_trans2_replies(struct smb_request *req,
580                          const char *params,
581                          int paramsize,
582                          const char *pdata,
583                          int datasize,
584                          int max_data_bytes)
585 {
586         /* As we are using a protocol > LANMAN1 then the max_send
587          variable must have been set in the sessetupX call.
588          This takes precedence over the max_xmit field in the
589          global struct. These different max_xmit variables should
590          be merged as this is now too confusing */
591
592         int data_to_send = datasize;
593         int params_to_send = paramsize;
594         int useable_space;
595         const char *pp = params;
596         const char *pd = pdata;
597         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
598         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
599         int data_alignment_offset = 0;
600         BOOL overflow = False;
601
602         /* Modify the data_to_send and datasize and set the error if
603            we're trying to send more than max_data_bytes. We still send
604            the part of the packet(s) that fit. Strange, but needed
605            for OS/2. */
606
607         if (max_data_bytes > 0 && datasize > max_data_bytes) {
608                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
609                         max_data_bytes, datasize ));
610                 datasize = data_to_send = max_data_bytes;
611                 overflow = True;
612         }
613
614         /* If there genuinely are no parameters or data to send just send the empty packet */
615
616         if(params_to_send == 0 && data_to_send == 0) {
617                 reply_outbuf(req, 10, 0);
618                 show_msg((char *)req->outbuf);
619                 return;
620         }
621
622         /* When sending params and data ensure that both are nicely aligned */
623         /* Only do this alignment when there is also data to send - else
624                 can cause NT redirector problems. */
625
626         if (((params_to_send % 4) != 0) && (data_to_send != 0))
627                 data_alignment_offset = 4 - (params_to_send % 4);
628
629         /* Space is bufsize minus Netbios over TCP header minus SMB header */
630         /* The alignment_offset is to align the param bytes on an even byte
631                 boundary. NT 4.0 Beta needs this to work correctly. */
632
633         useable_space = max_send - (smb_size
634                                     + 2 * 10 /* wct */
635                                     + alignment_offset
636                                     + data_alignment_offset);
637
638         /* useable_space can never be more than max_send minus the alignment offset. */
639
640         useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
641
642         while (params_to_send || data_to_send) {
643                 /* Calculate whether we will totally or partially fill this packet */
644
645                 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
646
647                 /* We can never send more than useable_space */
648                 /*
649                  * Note that 'useable_space' does not include the alignment offsets,
650                  * but we must include the alignment offsets in the calculation of
651                  * the length of the data we send over the wire, as the alignment offsets
652                  * are sent here. Fix from Marc_Jacobsen@hp.com.
653                  */
654
655                 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
656
657                 reply_outbuf(req, 10, total_sent_thistime);
658
659                 /* Set total params and data to be sent */
660                 SSVAL(req->outbuf,smb_tprcnt,paramsize);
661                 SSVAL(req->outbuf,smb_tdrcnt,datasize);
662
663                 /* Calculate how many parameters and data we can fit into
664                  * this packet. Parameters get precedence
665                  */
666
667                 params_sent_thistime = MIN(params_to_send,useable_space);
668                 data_sent_thistime = useable_space - params_sent_thistime;
669                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
670
671                 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
672
673                 /* smb_proff is the offset from the start of the SMB header to the
674                         parameter bytes, however the first 4 bytes of outbuf are
675                         the Netbios over TCP header. Thus use smb_base() to subtract
676                         them from the calculation */
677
678                 SSVAL(req->outbuf,smb_proff,
679                       ((smb_buf(req->outbuf)+alignment_offset)
680                        - smb_base(req->outbuf)));
681
682                 if(params_sent_thistime == 0)
683                         SSVAL(req->outbuf,smb_prdisp,0);
684                 else
685                         /* Absolute displacement of param bytes sent in this packet */
686                         SSVAL(req->outbuf,smb_prdisp,pp - params);
687
688                 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
689                 if(data_sent_thistime == 0) {
690                         SSVAL(req->outbuf,smb_droff,0);
691                         SSVAL(req->outbuf,smb_drdisp, 0);
692                 } else {
693                         /* The offset of the data bytes is the offset of the
694                                 parameter bytes plus the number of parameters being sent this time */
695                         SSVAL(req->outbuf, smb_droff,
696                               ((smb_buf(req->outbuf)+alignment_offset)
697                                - smb_base(req->outbuf))
698                               + params_sent_thistime + data_alignment_offset);
699                         SSVAL(req->outbuf,smb_drdisp, pd - pdata);
700                 }
701
702                 /* Initialize the padding for alignment */
703
704                 if (alignment_offset != 0) {
705                         memset(smb_buf(req->outbuf), 0, alignment_offset);
706                 }
707
708                 /* Copy the param bytes into the packet */
709
710                 if(params_sent_thistime) {
711                         memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
712                                params_sent_thistime);
713                 }
714
715                 /* Copy in the data bytes */
716                 if(data_sent_thistime) {
717                         if (data_alignment_offset != 0) {
718                                 memset((smb_buf(req->outbuf)+alignment_offset+
719                                         params_sent_thistime), 0,
720                                        data_alignment_offset);
721                         }
722                         memcpy(smb_buf(req->outbuf)+alignment_offset
723                                +params_sent_thistime+data_alignment_offset,
724                                pd,data_sent_thistime);
725                 }
726
727                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
728                         params_sent_thistime, data_sent_thistime, useable_space));
729                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
730                         params_to_send, data_to_send, paramsize, datasize));
731
732                 if (overflow) {
733                         error_packet_set((char *)req->outbuf,
734                                          ERRDOS,ERRbufferoverflow,
735                                          STATUS_BUFFER_OVERFLOW,
736                                          __LINE__,__FILE__);
737                 }
738
739                 /* Send the packet */
740                 show_msg((char *)req->outbuf);
741                 if (!send_smb(smbd_server_fd(),(char *)req->outbuf))
742                         exit_server_cleanly("send_trans2_replies: send_smb failed.");
743
744                 TALLOC_FREE(req->outbuf);
745
746                 pp += params_sent_thistime;
747                 pd += data_sent_thistime;
748
749                 params_to_send -= params_sent_thistime;
750                 data_to_send -= data_sent_thistime;
751
752                 /* Sanity check */
753                 if(params_to_send < 0 || data_to_send < 0) {
754                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
755                                 params_to_send, data_to_send));
756                         return;
757                 }
758         }
759
760         return;
761 }
762
763 /****************************************************************************
764  Reply to a TRANSACT2_OPEN.
765 ****************************************************************************/
766
767 static void call_trans2open(connection_struct *conn,
768                             struct smb_request *req,
769                             char **pparams, int total_params,
770                             char **ppdata, int total_data,
771                             unsigned int max_data_bytes)
772 {
773         char *params = *pparams;
774         char *pdata = *ppdata;
775         int deny_mode;
776         int32 open_attr;
777         BOOL oplock_request;
778 #if 0
779         BOOL return_additional_info;
780         int16 open_sattr;
781         time_t open_time;
782 #endif
783         int open_ofun;
784         uint32 open_size;
785         char *pname;
786         char *fname = NULL;
787         SMB_OFF_T size=0;
788         int fattr=0,mtime=0;
789         SMB_INO_T inode = 0;
790         SMB_STRUCT_STAT sbuf;
791         int smb_action = 0;
792         files_struct *fsp;
793         struct ea_list *ea_list = NULL;
794         uint16 flags = 0;
795         NTSTATUS status;
796         uint32 access_mask;
797         uint32 share_mode;
798         uint32 create_disposition;
799         uint32 create_options = 0;
800         TALLOC_CTX *ctx = talloc_tos();
801
802         /*
803          * Ensure we have enough parameters to perform the operation.
804          */
805
806         if (total_params < 29) {
807                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
808                 return;
809         }
810
811         flags = SVAL(params, 0);
812         deny_mode = SVAL(params, 2);
813         open_attr = SVAL(params,6);
814         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
815         if (oplock_request) {
816                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
817         }
818
819 #if 0
820         return_additional_info = BITSETW(params,0);
821         open_sattr = SVAL(params, 4);
822         open_time = make_unix_date3(params+8);
823 #endif
824         open_ofun = SVAL(params,12);
825         open_size = IVAL(params,14);
826         pname = &params[28];
827
828         if (IS_IPC(conn)) {
829                 reply_doserror(req, ERRSRV, ERRaccess);
830                 return;
831         }
832
833         srvstr_get_path(ctx, params, req->flags2, &fname, pname,
834                         total_params - 28, STR_TERMINATE,
835                         &status);
836         if (!NT_STATUS_IS_OK(status)) {
837                 reply_nterror(req, status);
838                 return;
839         }
840
841         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
842                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
843                 (unsigned int)open_ofun, open_size));
844
845         /* XXXX we need to handle passed times, sattr and flags */
846
847         status = unix_convert(conn, fname, False, &fname, NULL, &sbuf);
848         if (!NT_STATUS_IS_OK(status)) {
849                 reply_nterror(req, status);
850                 return;
851         }
852
853         status = check_name(conn, fname);
854         if (!NT_STATUS_IS_OK(status)) {
855                 reply_nterror(req, status);
856                 return;
857         }
858
859         if (open_ofun == 0) {
860                 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
861                 return;
862         }
863
864         if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
865                                 &access_mask,
866                                 &share_mode,
867                                 &create_disposition,
868                                 &create_options)) {
869                 reply_doserror(req, ERRDOS, ERRbadaccess);
870                 return;
871         }
872
873         /* Any data in this call is an EA list. */
874         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
875                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
876                 return;
877         }
878
879         if (total_data != 4) {
880                 if (total_data < 10) {
881                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
882                         return;
883                 }
884
885                 if (IVAL(pdata,0) > total_data) {
886                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
887                                 IVAL(pdata,0), (unsigned int)total_data));
888                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
889                         return;
890                 }
891
892                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
893                                        total_data - 4);
894                 if (!ea_list) {
895                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
896                         return;
897                 }
898         } else if (IVAL(pdata,0) != 4) {
899                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
900                 return;
901         }
902
903         status = open_file_ntcreate(conn, req, fname, &sbuf,
904                 access_mask,
905                 share_mode,
906                 create_disposition,
907                 create_options,
908                 open_attr,
909                 oplock_request,
910                 &smb_action, &fsp);
911
912         if (!NT_STATUS_IS_OK(status)) {
913                 if (open_was_deferred(req->mid)) {
914                         /* We have re-scheduled this call. */
915                         return;
916                 }
917                 reply_openerror(req, status);
918                 return;
919         }
920
921         size = get_file_size(sbuf);
922         fattr = dos_mode(conn,fname,&sbuf);
923         mtime = sbuf.st_mtime;
924         inode = sbuf.st_ino;
925         if (fattr & aDIR) {
926                 close_file(fsp,ERROR_CLOSE);
927                 reply_doserror(req, ERRDOS,ERRnoaccess);
928                 return;
929         }
930
931         /* Save the requested allocation size. */
932         /* Allocate space for the file if a size hint is supplied */
933         if ((smb_action == FILE_WAS_CREATED) || (smb_action == FILE_WAS_OVERWRITTEN)) {
934                 SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)open_size;
935                 if (allocation_size && (allocation_size > (SMB_BIG_UINT)size)) {
936                         fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
937                         if (fsp->is_directory) {
938                                 close_file(fsp,ERROR_CLOSE);
939                                 /* Can't set allocation size on a directory. */
940                                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
941                                 return;
942                         }
943                         if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
944                                 close_file(fsp,ERROR_CLOSE);
945                                 reply_nterror(req, NT_STATUS_DISK_FULL);
946                                 return;
947                         }
948
949                         /* Adjust size here to return the right size in the reply.
950                            Windows does it this way. */
951                         size = fsp->initial_allocation_size;
952                 } else {
953                         fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)size);
954                 }
955         }
956
957         if (ea_list && smb_action == FILE_WAS_CREATED) {
958                 status = set_ea(conn, fsp, fname, ea_list);
959                 if (!NT_STATUS_IS_OK(status)) {
960                         close_file(fsp,ERROR_CLOSE);
961                         reply_nterror(req, status);
962                         return;
963                 }
964         }
965
966         /* Realloc the size of parameters and data we will return */
967         *pparams = (char *)SMB_REALLOC(*pparams, 30);
968         if(*pparams == NULL ) {
969                 reply_nterror(req, NT_STATUS_NO_MEMORY);
970                 return;
971         }
972         params = *pparams;
973
974         SSVAL(params,0,fsp->fnum);
975         SSVAL(params,2,fattr);
976         srv_put_dos_date2(params,4, mtime);
977         SIVAL(params,8, (uint32)size);
978         SSVAL(params,12,deny_mode);
979         SSVAL(params,14,0); /* open_type - file or directory. */
980         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
981
982         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
983                 smb_action |= EXTENDED_OPLOCK_GRANTED;
984         }
985
986         SSVAL(params,18,smb_action);
987
988         /*
989          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
990          */
991         SIVAL(params,20,inode);
992         SSVAL(params,24,0); /* Padding. */
993         if (flags & 8) {
994                 uint32 ea_size = estimate_ea_size(conn, fsp, fname);
995                 SIVAL(params, 26, ea_size);
996         } else {
997                 SIVAL(params, 26, 0);
998         }
999
1000         /* Send the required number of replies */
1001         send_trans2_replies(req, params, 30, *ppdata, 0, max_data_bytes);
1002 }
1003
1004 /*********************************************************
1005  Routine to check if a given string matches exactly.
1006  as a special case a mask of "." does NOT match. That
1007  is required for correct wildcard semantics
1008  Case can be significant or not.
1009 **********************************************************/
1010
1011 static BOOL exact_match(connection_struct *conn,
1012                 const char *str,
1013                 const char *mask)
1014 {
1015         if (mask[0] == '.' && mask[1] == 0)
1016                 return False;
1017         if (conn->case_sensitive)
1018                 return strcmp(str,mask)==0;
1019         if (StrCaseCmp(str,mask) != 0) {
1020                 return False;
1021         }
1022         if (dptr_has_wild(conn->dirptr)) {
1023                 return False;
1024         }
1025         return True;
1026 }
1027
1028 /****************************************************************************
1029  Return the filetype for UNIX extensions.
1030 ****************************************************************************/
1031
1032 static uint32 unix_filetype(mode_t mode)
1033 {
1034         if(S_ISREG(mode))
1035                 return UNIX_TYPE_FILE;
1036         else if(S_ISDIR(mode))
1037                 return UNIX_TYPE_DIR;
1038 #ifdef S_ISLNK
1039         else if(S_ISLNK(mode))
1040                 return UNIX_TYPE_SYMLINK;
1041 #endif
1042 #ifdef S_ISCHR
1043         else if(S_ISCHR(mode))
1044                 return UNIX_TYPE_CHARDEV;
1045 #endif
1046 #ifdef S_ISBLK
1047         else if(S_ISBLK(mode))
1048                 return UNIX_TYPE_BLKDEV;
1049 #endif
1050 #ifdef S_ISFIFO
1051         else if(S_ISFIFO(mode))
1052                 return UNIX_TYPE_FIFO;
1053 #endif
1054 #ifdef S_ISSOCK
1055         else if(S_ISSOCK(mode))
1056                 return UNIX_TYPE_SOCKET;
1057 #endif
1058
1059         DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
1060         return UNIX_TYPE_UNKNOWN;
1061 }
1062
1063 /****************************************************************************
1064  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1065 ****************************************************************************/
1066
1067 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1068
1069 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1070                                 SMB_STRUCT_STAT *psbuf,
1071                                 uint32 perms,
1072                                 enum perm_type ptype,
1073                                 mode_t *ret_perms)
1074 {
1075         mode_t ret = 0;
1076
1077         if (perms == SMB_MODE_NO_CHANGE) {
1078                 if (!VALID_STAT(*psbuf)) {
1079                         return NT_STATUS_INVALID_PARAMETER;
1080                 } else {
1081                         *ret_perms = psbuf->st_mode;
1082                         return NT_STATUS_OK;
1083                 }
1084         }
1085
1086         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1087         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1088         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1089         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1090         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1091         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1092         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1093         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1094         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1095 #ifdef S_ISVTX
1096         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1097 #endif
1098 #ifdef S_ISGID
1099         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1100 #endif
1101 #ifdef S_ISUID
1102         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1103 #endif
1104
1105         switch (ptype) {
1106         case PERM_NEW_FILE:
1107                 /* Apply mode mask */
1108                 ret &= lp_create_mask(SNUM(conn));
1109                 /* Add in force bits */
1110                 ret |= lp_force_create_mode(SNUM(conn));
1111                 break;
1112         case PERM_NEW_DIR:
1113                 ret &= lp_dir_mask(SNUM(conn));
1114                 /* Add in force bits */
1115                 ret |= lp_force_dir_mode(SNUM(conn));
1116                 break;
1117         case PERM_EXISTING_FILE:
1118                 /* Apply mode mask */
1119                 ret &= lp_security_mask(SNUM(conn));
1120                 /* Add in force bits */
1121                 ret |= lp_force_security_mode(SNUM(conn));
1122                 break;
1123         case PERM_EXISTING_DIR:
1124                 /* Apply mode mask */
1125                 ret &= lp_dir_security_mask(SNUM(conn));
1126                 /* Add in force bits */
1127                 ret |= lp_force_dir_security_mode(SNUM(conn));
1128                 break;
1129         }
1130
1131         *ret_perms = ret;
1132         return NT_STATUS_OK;
1133 }
1134
1135 /****************************************************************************
1136  Get a level dependent lanman2 dir entry.
1137 ****************************************************************************/
1138
1139 static BOOL get_lanman2_dir_entry(TALLOC_CTX *ctx,
1140                                 connection_struct *conn,
1141                                 uint16 flags2,
1142                                 const char *path_mask,
1143                                 uint32 dirtype,
1144                                 int info_level,
1145                                 int requires_resume_key,
1146                                 BOOL dont_descend,
1147                                 char **ppdata,
1148                                 char *base_data,
1149                                 char *end_data,
1150                                 int space_remaining,
1151                                 BOOL *out_of_space,
1152                                 BOOL *got_exact_match,
1153                                 int *last_entry_off,
1154                                 struct ea_list *name_list)
1155 {
1156         const char *dname;
1157         BOOL found = False;
1158         SMB_STRUCT_STAT sbuf;
1159         const char *mask = NULL;
1160         char *pathreal = NULL;
1161         const char *fname = NULL;
1162         char *p, *q, *pdata = *ppdata;
1163         uint32 reskey=0;
1164         long prev_dirpos=0;
1165         uint32 mode=0;
1166         SMB_OFF_T file_size = 0;
1167         SMB_BIG_UINT allocation_size = 0;
1168         uint32 len;
1169         struct timespec mdate_ts, adate_ts, create_date_ts;
1170         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1171         char *nameptr;
1172         char *last_entry_ptr;
1173         BOOL was_8_3;
1174         uint32 nt_extmode; /* Used for NT connections instead of mode */
1175         BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1176         BOOL check_mangled_names = lp_manglednames(conn->params);
1177         char mangled_name[13]; /* mangled 8.3 name. */
1178
1179         *out_of_space = False;
1180         *got_exact_match = False;
1181
1182         ZERO_STRUCT(mdate_ts);
1183         ZERO_STRUCT(adate_ts);
1184         ZERO_STRUCT(create_date_ts);
1185
1186         if (!conn->dirptr) {
1187                 return(False);
1188         }
1189
1190         p = strrchr_m(path_mask,'/');
1191         if(p != NULL) {
1192                 if(p[1] == '\0') {
1193                         mask = talloc_strdup(ctx,"*.*");
1194                 } else {
1195                         mask = p+1;
1196                 }
1197         } else {
1198                 mask = path_mask;
1199         }
1200
1201         while (!found) {
1202                 BOOL got_match;
1203                 BOOL ms_dfs_link = False;
1204
1205                 /* Needed if we run out of space */
1206                 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1207                 dname = dptr_ReadDirName(ctx,conn->dirptr,&curr_dirpos,&sbuf);
1208
1209                 /*
1210                  * Due to bugs in NT client redirectors we are not using
1211                  * resume keys any more - set them to zero.
1212                  * Check out the related comments in findfirst/findnext.
1213                  * JRA.
1214                  */
1215
1216                 reskey = 0;
1217
1218                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1219                         (long)conn->dirptr,curr_dirpos));
1220
1221                 if (!dname) {
1222                         return(False);
1223                 }
1224
1225                 /*
1226                  * fname may get mangled, dname is never mangled.
1227                  * Whenever we're accessing the filesystem we use
1228                  * pathreal which is composed from dname.
1229                  */
1230
1231                 pathreal = NULL;
1232                 fname = dname;
1233
1234                 /* Mangle fname if it's an illegal name. */
1235                 if (mangle_must_mangle(dname,conn->params)) {
1236                         if (!name_to_8_3(dname,mangled_name,True,conn->params)) {
1237                                 continue; /* Error - couldn't mangle. */
1238                         }
1239                         fname = mangled_name;
1240                 }
1241
1242                 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask))) {
1243                         got_match = mask_match(fname, mask, conn->case_sensitive);
1244                 }
1245
1246                 if(!got_match && check_mangled_names &&
1247                    !mangle_is_8_3(fname, False, conn->params)) {
1248                         /*
1249                          * It turns out that NT matches wildcards against
1250                          * both long *and* short names. This may explain some
1251                          * of the wildcard wierdness from old DOS clients
1252                          * that some people have been seeing.... JRA.
1253                          */
1254                         /* Force the mangling into 8.3. */
1255                         if (!name_to_8_3( fname, mangled_name, False, conn->params)) {
1256                                 continue; /* Error - couldn't mangle. */
1257                         }
1258
1259                         if(!(got_match = *got_exact_match = exact_match(conn, mangled_name, mask))) {
1260                                 got_match = mask_match(mangled_name, mask, conn->case_sensitive);
1261                         }
1262                 }
1263
1264                 if (got_match) {
1265                         BOOL isdots = (ISDOT(dname) || ISDOTDOT(dname));
1266
1267                         if (dont_descend && !isdots) {
1268                                 continue;
1269                         }
1270
1271                         if (needslash) {
1272                                 pathreal = NULL;
1273                                 pathreal = talloc_asprintf(ctx,
1274                                         "%s/%s",
1275                                         conn->dirpath,
1276                                         dname);
1277                         } else {
1278                                 pathreal = talloc_asprintf(ctx,
1279                                         "%s%s",
1280                                         conn->dirpath,
1281                                         dname);
1282                         }
1283
1284                         if (!pathreal) {
1285                                 return False;
1286                         }
1287
1288                         if (INFO_LEVEL_IS_UNIX(info_level)) {
1289                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1290                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1291                                                 pathreal,strerror(errno)));
1292                                         TALLOC_FREE(pathreal);
1293                                         continue;
1294                                 }
1295                         } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1296                                 /* Needed to show the msdfs symlinks as
1297                                  * directories */
1298
1299                                 if(lp_host_msdfs() &&
1300                                    lp_msdfs_root(SNUM(conn)) &&
1301                                    ((ms_dfs_link = is_msdfs_link(conn, pathreal, &sbuf)) == True)) {
1302                                         DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s "
1303                                                 "as a directory\n",
1304                                                 pathreal));
1305                                         sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
1306
1307                                 } else {
1308
1309                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1310                                                 pathreal,strerror(errno)));
1311                                         TALLOC_FREE(pathreal);
1312                                         continue;
1313                                 }
1314                         }
1315
1316                         if (ms_dfs_link) {
1317                                 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1318                         } else {
1319                                 mode = dos_mode(conn,pathreal,&sbuf);
1320                         }
1321
1322                         if (!dir_check_ftype(conn,mode,dirtype)) {
1323                                 DEBUG(5,("get_lanman2_dir_entry: [%s] attribs didn't match %x\n",fname,dirtype));
1324                                 TALLOC_FREE(pathreal);
1325                                 continue;
1326                         }
1327
1328                         if (!(mode & aDIR)) {
1329                                 file_size = get_file_size(sbuf);
1330                         }
1331                         allocation_size = get_allocation_size(conn,NULL,&sbuf);
1332
1333                         mdate_ts = get_mtimespec(&sbuf);
1334                         adate_ts = get_atimespec(&sbuf);
1335                         create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1336
1337                         if (lp_dos_filetime_resolution(SNUM(conn))) {
1338                                 dos_filetime_timespec(&create_date_ts);
1339                                 dos_filetime_timespec(&mdate_ts);
1340                                 dos_filetime_timespec(&adate_ts);
1341                         }
1342
1343                         create_date = convert_timespec_to_time_t(create_date_ts);
1344                         mdate = convert_timespec_to_time_t(mdate_ts);
1345                         adate = convert_timespec_to_time_t(adate_ts);
1346
1347                         DEBUG(5,("get_lanman2_dir_entry: found %s fname=%s\n",pathreal,fname));
1348
1349                         found = True;
1350
1351                         dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1352                 }
1353         }
1354
1355         p = pdata;
1356         last_entry_ptr = p;
1357
1358         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1359
1360         switch (info_level) {
1361                 case SMB_FIND_INFO_STANDARD:
1362                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1363                         if(requires_resume_key) {
1364                                 SIVAL(p,0,reskey);
1365                                 p += 4;
1366                         }
1367                         srv_put_dos_date2(p,0,create_date);
1368                         srv_put_dos_date2(p,4,adate);
1369                         srv_put_dos_date2(p,8,mdate);
1370                         SIVAL(p,12,(uint32)file_size);
1371                         SIVAL(p,16,(uint32)allocation_size);
1372                         SSVAL(p,20,mode);
1373                         p += 23;
1374                         nameptr = p;
1375                         p += align_string(pdata, p, 0);
1376                         len = srvstr_push(base_data, flags2, p,
1377                                           fname, PTR_DIFF(end_data, p),
1378                                           STR_TERMINATE);
1379                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1380                                 if (len > 2) {
1381                                         SCVAL(nameptr, -1, len - 2);
1382                                 } else {
1383                                         SCVAL(nameptr, -1, 0);
1384                                 }
1385                         } else {
1386                                 if (len > 1) {
1387                                         SCVAL(nameptr, -1, len - 1);
1388                                 } else {
1389                                         SCVAL(nameptr, -1, 0);
1390                                 }
1391                         }
1392                         p += len;
1393                         break;
1394
1395                 case SMB_FIND_EA_SIZE:
1396                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1397                         if(requires_resume_key) {
1398                                 SIVAL(p,0,reskey);
1399                                 p += 4;
1400                         }
1401                         srv_put_dos_date2(p,0,create_date);
1402                         srv_put_dos_date2(p,4,adate);
1403                         srv_put_dos_date2(p,8,mdate);
1404                         SIVAL(p,12,(uint32)file_size);
1405                         SIVAL(p,16,(uint32)allocation_size);
1406                         SSVAL(p,20,mode);
1407                         {
1408                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1409                                 SIVAL(p,22,ea_size); /* Extended attributes */
1410                         }
1411                         p += 27;
1412                         nameptr = p - 1;
1413                         len = srvstr_push(base_data, flags2,
1414                                           p, fname, PTR_DIFF(end_data, p),
1415                                           STR_TERMINATE | STR_NOALIGN);
1416                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1417                                 if (len > 2) {
1418                                         len -= 2;
1419                                 } else {
1420                                         len = 0;
1421                                 }
1422                         } else {
1423                                 if (len > 1) {
1424                                         len -= 1;
1425                                 } else {
1426                                         len = 0;
1427                                 }
1428                         }
1429                         SCVAL(nameptr,0,len);
1430                         p += len;
1431                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1432                         break;
1433
1434                 case SMB_FIND_EA_LIST:
1435                 {
1436                         struct ea_list *file_list = NULL;
1437                         size_t ea_len = 0;
1438
1439                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1440                         if (!name_list) {
1441                                 return False;
1442                         }
1443                         if(requires_resume_key) {
1444                                 SIVAL(p,0,reskey);
1445                                 p += 4;
1446                         }
1447                         srv_put_dos_date2(p,0,create_date);
1448                         srv_put_dos_date2(p,4,adate);
1449                         srv_put_dos_date2(p,8,mdate);
1450                         SIVAL(p,12,(uint32)file_size);
1451                         SIVAL(p,16,(uint32)allocation_size);
1452                         SSVAL(p,20,mode);
1453                         p += 22; /* p now points to the EA area. */
1454
1455                         file_list = get_ea_list_from_file(ctx, conn, NULL, pathreal, &ea_len);
1456                         name_list = ea_list_union(name_list, file_list, &ea_len);
1457
1458                         /* We need to determine if this entry will fit in the space available. */
1459                         /* Max string size is 255 bytes. */
1460                         if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1461                                 /* Move the dirptr back to prev_dirpos */
1462                                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1463                                 *out_of_space = True;
1464                                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1465                                 return False; /* Not finished - just out of space */
1466                         }
1467
1468                         /* Push the ea_data followed by the name. */
1469                         p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1470                         nameptr = p;
1471                         len = srvstr_push(base_data, flags2,
1472                                           p + 1, fname, PTR_DIFF(end_data, p),
1473                                           STR_TERMINATE | STR_NOALIGN);
1474                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1475                                 if (len > 2) {
1476                                         len -= 2;
1477                                 } else {
1478                                         len = 0;
1479                                 }
1480                         } else {
1481                                 if (len > 1) {
1482                                         len -= 1;
1483                                 } else {
1484                                         len = 0;
1485                                 }
1486                         }
1487                         SCVAL(nameptr,0,len);
1488                         p += len + 1;
1489                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1490                         break;
1491                 }
1492
1493                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1494                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1495                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1496                         p += 4;
1497                         SIVAL(p,0,reskey); p += 4;
1498                         put_long_date_timespec(p,create_date_ts); p += 8;
1499                         put_long_date_timespec(p,adate_ts); p += 8;
1500                         put_long_date_timespec(p,mdate_ts); p += 8;
1501                         put_long_date_timespec(p,mdate_ts); p += 8;
1502                         SOFF_T(p,0,file_size); p += 8;
1503                         SOFF_T(p,0,allocation_size); p += 8;
1504                         SIVAL(p,0,nt_extmode); p += 4;
1505                         q = p; p += 4; /* q is placeholder for name length. */
1506                         {
1507                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1508                                 SIVAL(p,0,ea_size); /* Extended attributes */
1509                                 p += 4;
1510                         }
1511                         /* Clear the short name buffer. This is
1512                          * IMPORTANT as not doing so will trigger
1513                          * a Win2k client bug. JRA.
1514                          */
1515                         if (!was_8_3 && check_mangled_names) {
1516                                 if (!name_to_8_3(fname,mangled_name,True,
1517                                                    conn->params)) {
1518                                         /* Error - mangle failed ! */
1519                                         memset(mangled_name,'\0',12);
1520                                 }
1521                                 mangled_name[12] = 0;
1522                                 len = srvstr_push(base_data, flags2,
1523                                                   p+2, mangled_name, 24,
1524                                                   STR_UPPER|STR_UNICODE);
1525                                 if (len < 24) {
1526                                         memset(p + 2 + len,'\0',24 - len);
1527                                 }
1528                                 SSVAL(p, 0, len);
1529                         } else {
1530                                 memset(p,'\0',26);
1531                         }
1532                         p += 2 + 24;
1533                         len = srvstr_push(base_data, flags2, p,
1534                                           fname, PTR_DIFF(end_data, p),
1535                                           STR_TERMINATE_ASCII);
1536                         SIVAL(q,0,len);
1537                         p += len;
1538                         SIVAL(p,0,0); /* Ensure any padding is null. */
1539                         len = PTR_DIFF(p, pdata);
1540                         len = (len + 3) & ~3;
1541                         SIVAL(pdata,0,len);
1542                         p = pdata + len;
1543                         break;
1544
1545                 case SMB_FIND_FILE_DIRECTORY_INFO:
1546                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1547                         p += 4;
1548                         SIVAL(p,0,reskey); p += 4;
1549                         put_long_date_timespec(p,create_date_ts); p += 8;
1550                         put_long_date_timespec(p,adate_ts); p += 8;
1551                         put_long_date_timespec(p,mdate_ts); p += 8;
1552                         put_long_date_timespec(p,mdate_ts); p += 8;
1553                         SOFF_T(p,0,file_size); p += 8;
1554                         SOFF_T(p,0,allocation_size); p += 8;
1555                         SIVAL(p,0,nt_extmode); p += 4;
1556                         len = srvstr_push(base_data, flags2,
1557                                           p + 4, fname, PTR_DIFF(end_data, p),
1558                                           STR_TERMINATE_ASCII);
1559                         SIVAL(p,0,len);
1560                         p += 4 + len;
1561                         SIVAL(p,0,0); /* Ensure any padding is null. */
1562                         len = PTR_DIFF(p, pdata);
1563                         len = (len + 3) & ~3;
1564                         SIVAL(pdata,0,len);
1565                         p = pdata + len;
1566                         break;
1567
1568                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1569                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1570                         p += 4;
1571                         SIVAL(p,0,reskey); p += 4;
1572                         put_long_date_timespec(p,create_date_ts); p += 8;
1573                         put_long_date_timespec(p,adate_ts); p += 8;
1574                         put_long_date_timespec(p,mdate_ts); p += 8;
1575                         put_long_date_timespec(p,mdate_ts); p += 8;
1576                         SOFF_T(p,0,file_size); p += 8;
1577                         SOFF_T(p,0,allocation_size); p += 8;
1578                         SIVAL(p,0,nt_extmode); p += 4;
1579                         q = p; p += 4; /* q is placeholder for name length. */
1580                         {
1581                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1582                                 SIVAL(p,0,ea_size); /* Extended attributes */
1583                                 p +=4;
1584                         }
1585                         len = srvstr_push(base_data, flags2, p,
1586                                           fname, PTR_DIFF(end_data, p),
1587                                           STR_TERMINATE_ASCII);
1588                         SIVAL(q, 0, len);
1589                         p += len;
1590
1591                         SIVAL(p,0,0); /* Ensure any padding is null. */
1592                         len = PTR_DIFF(p, pdata);
1593                         len = (len + 3) & ~3;
1594                         SIVAL(pdata,0,len);
1595                         p = pdata + len;
1596                         break;
1597
1598                 case SMB_FIND_FILE_NAMES_INFO:
1599                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1600                         p += 4;
1601                         SIVAL(p,0,reskey); p += 4;
1602                         p += 4;
1603                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
1604                            acl on a dir (tridge) */
1605                         len = srvstr_push(base_data, flags2, p,
1606                                           fname, PTR_DIFF(end_data, p),
1607                                           STR_TERMINATE_ASCII);
1608                         SIVAL(p, -4, len);
1609                         p += len;
1610                         SIVAL(p,0,0); /* Ensure any padding is null. */
1611                         len = PTR_DIFF(p, pdata);
1612                         len = (len + 3) & ~3;
1613                         SIVAL(pdata,0,len);
1614                         p = pdata + len;
1615                         break;
1616
1617                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1618                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1619                         p += 4;
1620                         SIVAL(p,0,reskey); p += 4;
1621                         put_long_date_timespec(p,create_date_ts); p += 8;
1622                         put_long_date_timespec(p,adate_ts); p += 8;
1623                         put_long_date_timespec(p,mdate_ts); p += 8;
1624                         put_long_date_timespec(p,mdate_ts); p += 8;
1625                         SOFF_T(p,0,file_size); p += 8;
1626                         SOFF_T(p,0,allocation_size); p += 8;
1627                         SIVAL(p,0,nt_extmode); p += 4;
1628                         q = p; p += 4; /* q is placeholder for name length. */
1629                         {
1630                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1631                                 SIVAL(p,0,ea_size); /* Extended attributes */
1632                                 p +=4;
1633                         }
1634                         SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1635                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1636                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1637                         len = srvstr_push(base_data, flags2, p,
1638                                           fname, PTR_DIFF(end_data, p),
1639                                           STR_TERMINATE_ASCII);
1640                         SIVAL(q, 0, len);
1641                         p += len; 
1642                         SIVAL(p,0,0); /* Ensure any padding is null. */
1643                         len = PTR_DIFF(p, pdata);
1644                         len = (len + 3) & ~3;
1645                         SIVAL(pdata,0,len);
1646                         p = pdata + len;
1647                         break;
1648
1649                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1650                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1651                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1652                         p += 4;
1653                         SIVAL(p,0,reskey); p += 4;
1654                         put_long_date_timespec(p,create_date_ts); p += 8;
1655                         put_long_date_timespec(p,adate_ts); p += 8;
1656                         put_long_date_timespec(p,mdate_ts); p += 8;
1657                         put_long_date_timespec(p,mdate_ts); p += 8;
1658                         SOFF_T(p,0,file_size); p += 8;
1659                         SOFF_T(p,0,allocation_size); p += 8;
1660                         SIVAL(p,0,nt_extmode); p += 4;
1661                         q = p; p += 4; /* q is placeholder for name length */
1662                         {
1663                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1664                                 SIVAL(p,0,ea_size); /* Extended attributes */
1665                                 p +=4;
1666                         }
1667                         /* Clear the short name buffer. This is
1668                          * IMPORTANT as not doing so will trigger
1669                          * a Win2k client bug. JRA.
1670                          */
1671                         if (!was_8_3 && check_mangled_names) {
1672                                 if (!name_to_8_3(fname,mangled_name,True,
1673                                                 conn->params)) {
1674                                         /* Error - mangle failed ! */
1675                                         memset(mangled_name,'\0',12);
1676                                 }
1677                                 mangled_name[12] = 0;
1678                                 len = srvstr_push(base_data, flags2,
1679                                                   p+2, mangled_name, 24,
1680                                                   STR_UPPER|STR_UNICODE);
1681                                 SSVAL(p, 0, len);
1682                                 if (len < 24) {
1683                                         memset(p + 2 + len,'\0',24 - len);
1684                                 }
1685                                 SSVAL(p, 0, len);
1686                         } else {
1687                                 memset(p,'\0',26);
1688                         }
1689                         p += 26;
1690                         SSVAL(p,0,0); p += 2; /* Reserved ? */
1691                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1692                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1693                         len = srvstr_push(base_data, flags2, p,
1694                                           fname, PTR_DIFF(end_data, p),
1695                                           STR_TERMINATE_ASCII);
1696                         SIVAL(q,0,len);
1697                         p += len;
1698                         SIVAL(p,0,0); /* Ensure any padding is null. */
1699                         len = PTR_DIFF(p, pdata);
1700                         len = (len + 3) & ~3;
1701                         SIVAL(pdata,0,len);
1702                         p = pdata + len;
1703                         break;
1704
1705                 /* CIFS UNIX Extension. */
1706
1707                 case SMB_FIND_FILE_UNIX:
1708                 case SMB_FIND_FILE_UNIX_INFO2:
1709                         p+= 4;
1710                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1711
1712                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1713
1714                         if (info_level == SMB_FIND_FILE_UNIX) {
1715                                 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1716                                 p = store_file_unix_basic(conn, p,
1717                                                         NULL, &sbuf);
1718                                 len = srvstr_push(base_data, flags2, p,
1719                                                   fname, PTR_DIFF(end_data, p),
1720                                                   STR_TERMINATE);
1721                         } else {
1722                                 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1723                                 p = store_file_unix_basic_info2(conn, p,
1724                                                         NULL, &sbuf);
1725                                 nameptr = p;
1726                                 p += 4;
1727                                 len = srvstr_push(base_data, flags2, p, fname,
1728                                                   PTR_DIFF(end_data, p), 0);
1729                                 SIVAL(nameptr, 0, len);
1730                         }
1731
1732                         p += len;
1733                         SIVAL(p,0,0); /* Ensure any padding is null. */
1734
1735                         len = PTR_DIFF(p, pdata);
1736                         len = (len + 3) & ~3;
1737                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
1738                         p = pdata + len;
1739                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
1740
1741                         break;
1742
1743                 default:
1744                         return(False);
1745         }
1746
1747
1748         if (PTR_DIFF(p,pdata) > space_remaining) {
1749                 /* Move the dirptr back to prev_dirpos */
1750                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1751                 *out_of_space = True;
1752                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1753                 return False; /* Not finished - just out of space */
1754         }
1755
1756         /* Setup the last entry pointer, as an offset from base_data */
1757         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1758         /* Advance the data pointer to the next slot */
1759         *ppdata = p;
1760
1761         return(found);
1762 }
1763
1764 /****************************************************************************
1765  Reply to a TRANS2_FINDFIRST.
1766 ****************************************************************************/
1767
1768 static void call_trans2findfirst(connection_struct *conn,
1769                                  struct smb_request *req,
1770                                  char **pparams, int total_params,
1771                                  char **ppdata, int total_data,
1772                                  unsigned int max_data_bytes)
1773 {
1774         /* We must be careful here that we don't return more than the
1775                 allowed number of data bytes. If this means returning fewer than
1776                 maxentries then so be it. We assume that the redirector has
1777                 enough room for the fixed number of parameter bytes it has
1778                 requested. */
1779         char *params = *pparams;
1780         char *pdata = *ppdata;
1781         char *data_end;
1782         uint32 dirtype;
1783         int maxentries;
1784         uint16 findfirst_flags;
1785         BOOL close_after_first;
1786         BOOL close_if_end;
1787         BOOL requires_resume_key;
1788         int info_level;
1789         char *directory = NULL;
1790         const char *mask = NULL;
1791         char *p;
1792         int last_entry_off=0;
1793         int dptr_num = -1;
1794         int numentries = 0;
1795         int i;
1796         BOOL finished = False;
1797         BOOL dont_descend = False;
1798         BOOL out_of_space = False;
1799         int space_remaining;
1800         BOOL mask_contains_wcard = False;
1801         SMB_STRUCT_STAT sbuf;
1802         struct ea_list *ea_list = NULL;
1803         NTSTATUS ntstatus = NT_STATUS_OK;
1804         TALLOC_CTX *ctx = talloc_tos();
1805
1806         if (total_params < 13) {
1807                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1808                 return;
1809         }
1810
1811         dirtype = SVAL(params,0);
1812         maxentries = SVAL(params,2);
1813         findfirst_flags = SVAL(params,4);
1814         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1815         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1816         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1817         info_level = SVAL(params,6);
1818
1819         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1820 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1821                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1822                 info_level, max_data_bytes));
1823
1824         if (!maxentries) {
1825                 /* W2K3 seems to treat zero as 1. */
1826                 maxentries = 1;
1827         }
1828  
1829         switch (info_level) {
1830                 case SMB_FIND_INFO_STANDARD:
1831                 case SMB_FIND_EA_SIZE:
1832                 case SMB_FIND_EA_LIST:
1833                 case SMB_FIND_FILE_DIRECTORY_INFO:
1834                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1835                 case SMB_FIND_FILE_NAMES_INFO:
1836                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1837                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1838                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1839                         break;
1840                 case SMB_FIND_FILE_UNIX:
1841                 case SMB_FIND_FILE_UNIX_INFO2:
1842                         if (!lp_unix_extensions()) {
1843                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
1844                                 return;
1845                         }
1846                         break;
1847                 default:
1848                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
1849                         return;
1850         }
1851
1852         srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
1853                               params+12, total_params - 12,
1854                               STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1855         if (!NT_STATUS_IS_OK(ntstatus)) {
1856                 reply_nterror(req, ntstatus);
1857                 return;
1858         }
1859
1860         ntstatus = resolve_dfspath_wcard(ctx, conn,
1861                         req->flags2 & FLAGS2_DFS_PATHNAMES,
1862                         directory,
1863                         &directory,
1864                         &mask_contains_wcard);
1865         if (!NT_STATUS_IS_OK(ntstatus)) {
1866                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
1867                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
1868                                         ERRSRV, ERRbadpath);
1869                         return;
1870                 }
1871                 reply_nterror(req, ntstatus);
1872                 return;
1873         }
1874
1875         ntstatus = unix_convert(conn, directory, True, &directory, NULL, &sbuf);
1876         if (!NT_STATUS_IS_OK(ntstatus)) {
1877                 reply_nterror(req, ntstatus);
1878                 return;
1879         }
1880
1881         ntstatus = check_name(conn, directory);
1882         if (!NT_STATUS_IS_OK(ntstatus)) {
1883                 reply_nterror(req, ntstatus);
1884                 return;
1885         }
1886
1887         p = strrchr_m(directory,'/');
1888         if(p == NULL) {
1889                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1890                 if((directory[0] == '.') && (directory[1] == '\0')) {
1891                         mask = "*";
1892                         mask_contains_wcard = True;
1893                 } else {
1894                         mask = directory;
1895                 }
1896                 directory = talloc_strdup(talloc_tos(), "./");
1897                 if (!directory) {
1898                         reply_nterror(req, NT_STATUS_NO_MEMORY);
1899                         return;
1900                 }
1901         } else {
1902                 mask = p+1;
1903                 *p = 0;
1904         }
1905
1906         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1907
1908         if (info_level == SMB_FIND_EA_LIST) {
1909                 uint32 ea_size;
1910
1911                 if (total_data < 4) {
1912                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1913                         return;
1914                 }
1915
1916                 ea_size = IVAL(pdata,0);
1917                 if (ea_size != total_data) {
1918                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
1919 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
1920                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1921                         return;
1922                 }
1923
1924                 if (!lp_ea_support(SNUM(conn))) {
1925                         reply_doserror(req, ERRDOS, ERReasnotsupported);
1926                         return;
1927                 }
1928
1929                 /* Pull out the list of names. */
1930                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
1931                 if (!ea_list) {
1932                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1933                         return;
1934                 }
1935         }
1936
1937         *ppdata = (char *)SMB_REALLOC(
1938                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1939         if(*ppdata == NULL ) {
1940                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1941                 return;
1942         }
1943         pdata = *ppdata;
1944         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
1945
1946         /* Realloc the params space */
1947         *pparams = (char *)SMB_REALLOC(*pparams, 10);
1948         if (*pparams == NULL) {
1949                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1950                 return;
1951         }
1952         params = *pparams;
1953
1954         /* Save the wildcard match and attribs we are using on this directory - 
1955                 needed as lanman2 assumes these are being saved between calls */
1956
1957         ntstatus = dptr_create(conn,
1958                                 directory,
1959                                 False,
1960                                 True,
1961                                 req->smbpid,
1962                                 mask,
1963                                 mask_contains_wcard,
1964                                 dirtype,
1965                                 &conn->dirptr);
1966
1967         if (!NT_STATUS_IS_OK(ntstatus)) {
1968                 reply_nterror(req, ntstatus);
1969                 return;
1970         }
1971
1972         dptr_num = dptr_dnum(conn->dirptr);
1973         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
1974
1975         /* We don't need to check for VOL here as this is returned by
1976                 a different TRANS2 call. */
1977
1978         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1979         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1980                 dont_descend = True;
1981
1982         p = pdata;
1983         space_remaining = max_data_bytes;
1984         out_of_space = False;
1985
1986         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1987                 BOOL got_exact_match = False;
1988
1989                 /* this is a heuristic to avoid seeking the dirptr except when 
1990                         absolutely necessary. It allows for a filename of about 40 chars */
1991                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1992                         out_of_space = True;
1993                         finished = False;
1994                 } else {
1995                         TALLOC_CTX *sub_ctx = talloc_stackframe();
1996
1997                         finished = !get_lanman2_dir_entry(sub_ctx,
1998                                         conn,
1999                                         req->flags2,
2000                                         mask,dirtype,info_level,
2001                                         requires_resume_key,dont_descend,
2002                                         &p,pdata,data_end,
2003                                         space_remaining, &out_of_space,
2004                                         &got_exact_match,
2005                                         &last_entry_off, ea_list);
2006
2007                         TALLOC_FREE(sub_ctx);
2008                 }
2009
2010                 if (finished && out_of_space)
2011                         finished = False;
2012
2013                 if (!finished && !out_of_space)
2014                         numentries++;
2015
2016                 /*
2017                  * As an optimisation if we know we aren't looking
2018                  * for a wildcard name (ie. the name matches the wildcard exactly)
2019                  * then we can finish on any (first) match.
2020                  * This speeds up large directory searches. JRA.
2021                  */
2022
2023                 if(got_exact_match)
2024                         finished = True;
2025
2026                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2027         }
2028
2029         /* Check if we can close the dirptr */
2030         if(close_after_first || (finished && close_if_end)) {
2031                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2032                 dptr_close(&dptr_num);
2033         }
2034
2035         /*
2036          * If there are no matching entries we must return ERRDOS/ERRbadfile -
2037          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2038          * the protocol level is less than NT1. Tested with smbclient. JRA.
2039          * This should fix the OS/2 client bug #2335.
2040          */
2041
2042         if(numentries == 0) {
2043                 dptr_close(&dptr_num);
2044                 if (Protocol < PROTOCOL_NT1) {
2045                         reply_doserror(req, ERRDOS, ERRnofiles);
2046                         return;
2047                 } else {
2048                         reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2049                                         ERRDOS, ERRbadfile);
2050                         return;
2051                 }
2052         }
2053
2054         /* At this point pdata points to numentries directory entries. */
2055
2056         /* Set up the return parameter block */
2057         SSVAL(params,0,dptr_num);
2058         SSVAL(params,2,numentries);
2059         SSVAL(params,4,finished);
2060         SSVAL(params,6,0); /* Never an EA error */
2061         SSVAL(params,8,last_entry_off);
2062
2063         send_trans2_replies(req, params, 10, pdata, PTR_DIFF(p,pdata),
2064                             max_data_bytes);
2065
2066         if ((! *directory) && dptr_path(dptr_num)) {
2067                 directory = talloc_strdup(talloc_tos(),dptr_path(dptr_num));
2068                 if (!directory) {
2069                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2070                 }
2071         }
2072
2073         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2074                 smb_fn_name(CVAL(req->inbuf,smb_com)),
2075                 mask, directory, dirtype, numentries ) );
2076
2077         /*
2078          * Force a name mangle here to ensure that the
2079          * mask as an 8.3 name is top of the mangled cache.
2080          * The reasons for this are subtle. Don't remove
2081          * this code unless you know what you are doing
2082          * (see PR#13758). JRA.
2083          */
2084
2085         if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2086                 char mangled_name[13];
2087                 name_to_8_3(mask, mangled_name, True, conn->params);
2088         }
2089
2090         return;
2091 }
2092
2093 /****************************************************************************
2094  Reply to a TRANS2_FINDNEXT.
2095 ****************************************************************************/
2096
2097 static void call_trans2findnext(connection_struct *conn,
2098                                 struct smb_request *req,
2099                                 char **pparams, int total_params,
2100                                 char **ppdata, int total_data,
2101                                 unsigned int max_data_bytes)
2102 {
2103         /* We must be careful here that we don't return more than the
2104                 allowed number of data bytes. If this means returning fewer than
2105                 maxentries then so be it. We assume that the redirector has
2106                 enough room for the fixed number of parameter bytes it has
2107                 requested. */
2108         char *params = *pparams;
2109         char *pdata = *ppdata;
2110         char *data_end;
2111         int dptr_num;
2112         int maxentries;
2113         uint16 info_level;
2114         uint32 resume_key;
2115         uint16 findnext_flags;
2116         BOOL close_after_request;
2117         BOOL close_if_end;
2118         BOOL requires_resume_key;
2119         BOOL continue_bit;
2120         BOOL mask_contains_wcard = False;
2121         char *resume_name = NULL;
2122         const char *mask = NULL;
2123         const char *directory = NULL;
2124         char *p = NULL;
2125         uint16 dirtype;
2126         int numentries = 0;
2127         int i, last_entry_off=0;
2128         BOOL finished = False;
2129         BOOL dont_descend = False;
2130         BOOL out_of_space = False;
2131         int space_remaining;
2132         struct ea_list *ea_list = NULL;
2133         NTSTATUS ntstatus = NT_STATUS_OK;
2134         TALLOC_CTX *ctx = talloc_tos();
2135
2136         if (total_params < 13) {
2137                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2138                 return;
2139         }
2140
2141         dptr_num = SVAL(params,0);
2142         maxentries = SVAL(params,2);
2143         info_level = SVAL(params,4);
2144         resume_key = IVAL(params,6);
2145         findnext_flags = SVAL(params,10);
2146         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2147         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2148         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2149         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2150
2151         srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2152                               params+12,
2153                               total_params - 12, STR_TERMINATE, &ntstatus,
2154                               &mask_contains_wcard);
2155         if (!NT_STATUS_IS_OK(ntstatus)) {
2156                 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2157                    complain (it thinks we're asking for the directory above the shared
2158                    path or an invalid name). Catch this as the resume name is only compared, never used in
2159                    a file access. JRA. */
2160                 srvstr_pull_talloc(ctx, params, req->flags2,
2161                                 &resume_name, params+12,
2162                                 total_params - 12,
2163                                 STR_TERMINATE);
2164
2165                 if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2166                         reply_nterror(req, ntstatus);
2167                         return;
2168                 }
2169         }
2170
2171         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2172 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2173 resume_key = %d resume name = %s continue=%d level = %d\n",
2174                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end, 
2175                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2176
2177         if (!maxentries) {
2178                 /* W2K3 seems to treat zero as 1. */
2179                 maxentries = 1;
2180         }
2181
2182         switch (info_level) {
2183                 case SMB_FIND_INFO_STANDARD:
2184                 case SMB_FIND_EA_SIZE:
2185                 case SMB_FIND_EA_LIST:
2186                 case SMB_FIND_FILE_DIRECTORY_INFO:
2187                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2188                 case SMB_FIND_FILE_NAMES_INFO:
2189                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2190                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2191                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2192                         break;
2193                 case SMB_FIND_FILE_UNIX:
2194                 case SMB_FIND_FILE_UNIX_INFO2:
2195                         if (!lp_unix_extensions()) {
2196                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2197                                 return;
2198                         }
2199                         break;
2200                 default:
2201                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2202                         return;
2203         }
2204
2205         if (info_level == SMB_FIND_EA_LIST) {
2206                 uint32 ea_size;
2207
2208                 if (total_data < 4) {
2209                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2210                         return;
2211                 }
2212
2213                 ea_size = IVAL(pdata,0);
2214                 if (ea_size != total_data) {
2215                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2216 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2217                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2218                         return;
2219                 }
2220
2221                 if (!lp_ea_support(SNUM(conn))) {
2222                         reply_doserror(req, ERRDOS, ERReasnotsupported);
2223                         return;
2224                 }
2225
2226                 /* Pull out the list of names. */
2227                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2228                 if (!ea_list) {
2229                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2230                         return;
2231                 }
2232         }
2233
2234         *ppdata = (char *)SMB_REALLOC(
2235                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2236         if(*ppdata == NULL) {
2237                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2238                 return;
2239         }
2240
2241         pdata = *ppdata;
2242         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2243
2244         /* Realloc the params space */
2245         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2246         if(*pparams == NULL ) {
2247                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2248                 return;
2249         }
2250
2251         params = *pparams;
2252
2253         /* Check that the dptr is valid */
2254         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2255                 reply_doserror(req, ERRDOS, ERRnofiles);
2256                 return;
2257         }
2258
2259         string_set(&conn->dirpath,dptr_path(dptr_num));
2260
2261         /* Get the wildcard mask from the dptr */
2262         if((p = dptr_wcard(dptr_num))== NULL) {
2263                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2264                 reply_doserror(req, ERRDOS, ERRnofiles);
2265                 return;
2266         }
2267
2268         mask = p;
2269         directory = conn->dirpath;
2270
2271         /* Get the attr mask from the dptr */
2272         dirtype = dptr_attr(dptr_num);
2273
2274         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2275                 dptr_num, mask, dirtype,
2276                 (long)conn->dirptr,
2277                 dptr_TellDir(conn->dirptr)));
2278
2279         /* We don't need to check for VOL here as this is returned by
2280                 a different TRANS2 call. */
2281
2282         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2283         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2284                 dont_descend = True;
2285
2286         p = pdata;
2287         space_remaining = max_data_bytes;
2288         out_of_space = False;
2289
2290         /*
2291          * Seek to the correct position. We no longer use the resume key but
2292          * depend on the last file name instead.
2293          */
2294
2295         if(*resume_name && !continue_bit) {
2296                 SMB_STRUCT_STAT st;
2297
2298                 long current_pos = 0;
2299                 /*
2300                  * Remember, name_to_8_3 is called by
2301                  * get_lanman2_dir_entry(), so the resume name
2302                  * could be mangled. Ensure we check the unmangled name.
2303                  */
2304
2305                 if (mangle_is_mangled(resume_name, conn->params)) {
2306                         char *new_resume_name = NULL;
2307                         mangle_lookup_name_from_8_3(ctx,
2308                                                 resume_name,
2309                                                 &new_resume_name,
2310                                                 conn->params);
2311                         if (new_resume_name) {
2312                                 resume_name = new_resume_name;
2313                         }
2314                 }
2315
2316                 /*
2317                  * Fix for NT redirector problem triggered by resume key indexes
2318                  * changing between directory scans. We now return a resume key of 0
2319                  * and instead look for the filename to continue from (also given
2320                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2321                  * findfirst/findnext (as is usual) then the directory pointer
2322                  * should already be at the correct place.
2323                  */
2324
2325                 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2326         } /* end if resume_name && !continue_bit */
2327
2328         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2329                 BOOL got_exact_match = False;
2330
2331                 /* this is a heuristic to avoid seeking the dirptr except when 
2332                         absolutely necessary. It allows for a filename of about 40 chars */
2333                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2334                         out_of_space = True;
2335                         finished = False;
2336                 } else {
2337                         TALLOC_CTX *sub_ctx = talloc_stackframe();
2338
2339                         finished = !get_lanman2_dir_entry(sub_ctx,
2340                                                 conn,
2341                                                 req->flags2,
2342                                                 mask,dirtype,info_level,
2343                                                 requires_resume_key,dont_descend,
2344                                                 &p,pdata,data_end,
2345                                                 space_remaining, &out_of_space,
2346                                                 &got_exact_match,
2347                                                 &last_entry_off, ea_list);
2348
2349                         TALLOC_FREE(sub_ctx);
2350                 }
2351
2352                 if (finished && out_of_space)
2353                         finished = False;
2354
2355                 if (!finished && !out_of_space)
2356                         numentries++;
2357
2358                 /*
2359                  * As an optimisation if we know we aren't looking
2360                  * for a wildcard name (ie. the name matches the wildcard exactly)
2361                  * then we can finish on any (first) match.
2362                  * This speeds up large directory searches. JRA.
2363                  */
2364
2365                 if(got_exact_match)
2366                         finished = True;
2367
2368                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2369         }
2370
2371         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2372                 smb_fn_name(CVAL(req->inbuf,smb_com)),
2373                 mask, directory, dirtype, numentries ) );
2374
2375         /* Check if we can close the dirptr */
2376         if(close_after_request || (finished && close_if_end)) {
2377                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2378                 dptr_close(&dptr_num); /* This frees up the saved mask */
2379         }
2380
2381         /* Set up the return parameter block */
2382         SSVAL(params,0,numentries);
2383         SSVAL(params,2,finished);
2384         SSVAL(params,4,0); /* Never an EA error */
2385         SSVAL(params,6,last_entry_off);
2386
2387         send_trans2_replies(req, params, 8, pdata, PTR_DIFF(p,pdata),
2388                             max_data_bytes);
2389
2390         return;
2391 }
2392
2393 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2394 {
2395         E_md4hash(lp_servicename(SNUM(conn)),objid);
2396         return objid;
2397 }
2398
2399 /****************************************************************************
2400  Reply to a TRANS2_QFSINFO (query filesystem info).
2401 ****************************************************************************/
2402
2403 static void call_trans2qfsinfo(connection_struct *conn,
2404                                struct smb_request *req,
2405                                char **pparams, int total_params,
2406                                char **ppdata, int total_data,
2407                                unsigned int max_data_bytes)
2408 {
2409         char *pdata, *end_data;
2410         char *params = *pparams;
2411         uint16 info_level;
2412         int data_len, len;
2413         SMB_STRUCT_STAT st;
2414         const char *vname = volume_label(SNUM(conn));
2415         int snum = SNUM(conn);
2416         char *fstype = lp_fstype(SNUM(conn));
2417         int quota_flag = 0;
2418
2419         if (total_params < 2) {
2420                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2421                 return;
2422         }
2423
2424         info_level = SVAL(params,0);
2425
2426         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2427
2428         if(SMB_VFS_STAT(conn,".",&st)!=0) {
2429                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2430                 reply_doserror(req, ERRSRV, ERRinvdevice);
2431                 return;
2432         }
2433
2434         *ppdata = (char *)SMB_REALLOC(
2435                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2436         if (*ppdata == NULL ) {
2437                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2438                 return;
2439         }
2440
2441         pdata = *ppdata;
2442         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2443         end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2444
2445         switch (info_level) {
2446                 case SMB_INFO_ALLOCATION:
2447                 {
2448                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2449                         data_len = 18;
2450                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2451                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2452                                 return;
2453                         }
2454
2455                         block_size = lp_block_size(snum);
2456                         if (bsize < block_size) {
2457                                 SMB_BIG_UINT factor = block_size/bsize;
2458                                 bsize = block_size;
2459                                 dsize /= factor;
2460                                 dfree /= factor;
2461                         }
2462                         if (bsize > block_size) {
2463                                 SMB_BIG_UINT factor = bsize/block_size;
2464                                 bsize = block_size;
2465                                 dsize *= factor;
2466                                 dfree *= factor;
2467                         }
2468                         bytes_per_sector = 512;
2469                         sectors_per_unit = bsize/bytes_per_sector;
2470
2471                         DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2472 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2473                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2474
2475                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
2476                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2477                         SIVAL(pdata,l1_cUnit,dsize);
2478                         SIVAL(pdata,l1_cUnitAvail,dfree);
2479                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
2480                         break;
2481                 }
2482
2483                 case SMB_INFO_VOLUME:
2484                         /* Return volume name */
2485                         /* 
2486                          * Add volume serial number - hash of a combination of
2487                          * the called hostname and the service name.
2488                          */
2489                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2490                         /*
2491                          * Win2k3 and previous mess this up by sending a name length
2492                          * one byte short. I believe only older clients (OS/2 Win9x) use
2493                          * this call so try fixing this by adding a terminating null to
2494                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2495                          */
2496                         len = srvstr_push(
2497                                 pdata, req->flags2,
2498                                 pdata+l2_vol_szVolLabel, vname,
2499                                 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
2500                                 STR_NOALIGN|STR_TERMINATE);
2501                         SCVAL(pdata,l2_vol_cch,len);
2502                         data_len = l2_vol_szVolLabel + len;
2503                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2504                                 (unsigned)st.st_ctime, len, vname));
2505                         break;
2506
2507                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2508                 case SMB_FS_ATTRIBUTE_INFORMATION:
2509
2510
2511 #if defined(HAVE_SYS_QUOTAS)
2512                         quota_flag = FILE_VOLUME_QUOTAS;
2513 #endif
2514
2515                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2516                                 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
2517                                 FILE_SUPPORTS_OBJECT_IDS|
2518                                 FILE_UNICODE_ON_DISK|
2519                                 quota_flag); /* FS ATTRIBUTES */
2520
2521                         SIVAL(pdata,4,255); /* Max filename component length */
2522                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2523                                 and will think we can't do long filenames */
2524                         len = srvstr_push(pdata, req->flags2, pdata+12, fstype,
2525                                           PTR_DIFF(end_data, pdata+12),
2526                                           STR_UNICODE);
2527                         SIVAL(pdata,8,len);
2528                         data_len = 12 + len;
2529                         break;
2530
2531                 case SMB_QUERY_FS_LABEL_INFO:
2532                 case SMB_FS_LABEL_INFORMATION:
2533                         len = srvstr_push(pdata, req->flags2, pdata+4, vname,
2534                                           PTR_DIFF(end_data, pdata+4), 0);
2535                         data_len = 4 + len;
2536                         SIVAL(pdata,0,len);
2537                         break;
2538
2539                 case SMB_QUERY_FS_VOLUME_INFO:      
2540                 case SMB_FS_VOLUME_INFORMATION:
2541
2542                         /* 
2543                          * Add volume serial number - hash of a combination of
2544                          * the called hostname and the service name.
2545                          */
2546                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^ 
2547                                 (str_checksum(get_local_machine_name())<<16));
2548
2549                         /* Max label len is 32 characters. */
2550                         len = srvstr_push(pdata, req->flags2, pdata+18, vname,
2551                                           PTR_DIFF(end_data, pdata+18),
2552                                           STR_UNICODE);
2553                         SIVAL(pdata,12,len);
2554                         data_len = 18+len;
2555
2556                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n", 
2557                                 (int)strlen(vname),vname, lp_servicename(snum)));
2558                         break;
2559
2560                 case SMB_QUERY_FS_SIZE_INFO:
2561                 case SMB_FS_SIZE_INFORMATION:
2562                 {
2563                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2564                         data_len = 24;
2565                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2566                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2567                                 return;
2568                         }
2569                         block_size = lp_block_size(snum);
2570                         if (bsize < block_size) {
2571                                 SMB_BIG_UINT factor = block_size/bsize;
2572                                 bsize = block_size;
2573                                 dsize /= factor;
2574                                 dfree /= factor;
2575                         }
2576                         if (bsize > block_size) {
2577                                 SMB_BIG_UINT factor = bsize/block_size;
2578                                 bsize = block_size;
2579                                 dsize *= factor;
2580                                 dfree *= factor;
2581                         }
2582                         bytes_per_sector = 512;
2583                         sectors_per_unit = bsize/bytes_per_sector;
2584                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2585 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2586                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2587                         SBIG_UINT(pdata,0,dsize);
2588                         SBIG_UINT(pdata,8,dfree);
2589                         SIVAL(pdata,16,sectors_per_unit);
2590                         SIVAL(pdata,20,bytes_per_sector);
2591                         break;
2592                 }
2593
2594                 case SMB_FS_FULL_SIZE_INFORMATION:
2595                 {
2596                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2597                         data_len = 32;
2598                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2599                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2600                                 return;
2601                         }
2602                         block_size = lp_block_size(snum);
2603                         if (bsize < block_size) {
2604                                 SMB_BIG_UINT factor = block_size/bsize;
2605                                 bsize = block_size;
2606                                 dsize /= factor;
2607                                 dfree /= factor;
2608                         }
2609                         if (bsize > block_size) {
2610                                 SMB_BIG_UINT factor = bsize/block_size;
2611                                 bsize = block_size;
2612                                 dsize *= factor;
2613                                 dfree *= factor;
2614                         }
2615                         bytes_per_sector = 512;
2616                         sectors_per_unit = bsize/bytes_per_sector;
2617                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2618 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2619                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2620                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2621                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2622                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2623                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2624                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2625                         break;
2626                 }
2627
2628                 case SMB_QUERY_FS_DEVICE_INFO:
2629                 case SMB_FS_DEVICE_INFORMATION:
2630                         data_len = 8;
2631                         SIVAL(pdata,0,0); /* dev type */
2632                         SIVAL(pdata,4,0); /* characteristics */
2633                         break;
2634
2635 #ifdef HAVE_SYS_QUOTAS
2636                 case SMB_FS_QUOTA_INFORMATION:
2637                 /* 
2638                  * what we have to send --metze:
2639                  *
2640                  * Unknown1:            24 NULL bytes
2641                  * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2642                  * Hard Quota Limit:    8 bytes seems like SMB_BIG_UINT or so
2643                  * Quota Flags:         2 byte :
2644                  * Unknown3:            6 NULL bytes
2645                  *
2646                  * 48 bytes total
2647                  * 
2648                  * details for Quota Flags:
2649                  * 
2650                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2651                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
2652                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2653                  * 0x0001 Enable Quotas: enable quota for this fs
2654                  *
2655                  */
2656                 {
2657                         /* we need to fake up a fsp here,
2658                          * because its not send in this call
2659                          */
2660                         files_struct fsp;
2661                         SMB_NTQUOTA_STRUCT quotas;
2662                         
2663                         ZERO_STRUCT(fsp);
2664                         ZERO_STRUCT(quotas);
2665                         
2666                         fsp.conn = conn;
2667                         fsp.fnum = -1;
2668                         
2669                         /* access check */
2670                         if (current_user.ut.uid != 0) {
2671                                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2672                                         lp_servicename(SNUM(conn)),conn->user));
2673                                 reply_doserror(req, ERRDOS, ERRnoaccess);
2674                                 return;
2675                         }
2676                         
2677                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2678                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2679                                 reply_doserror(req, ERRSRV, ERRerror);
2680                                 return;
2681                         }
2682
2683                         data_len = 48;
2684
2685                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));          
2686                 
2687                         /* Unknown1 24 NULL bytes*/
2688                         SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2689                         SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2690                         SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2691                 
2692                         /* Default Soft Quota 8 bytes */
2693                         SBIG_UINT(pdata,24,quotas.softlim);
2694
2695                         /* Default Hard Quota 8 bytes */
2696                         SBIG_UINT(pdata,32,quotas.hardlim);
2697         
2698                         /* Quota flag 2 bytes */
2699                         SSVAL(pdata,40,quotas.qflags);
2700                 
2701                         /* Unknown3 6 NULL bytes */
2702                         SSVAL(pdata,42,0);
2703                         SIVAL(pdata,44,0);
2704                         
2705                         break;
2706                 }
2707 #endif /* HAVE_SYS_QUOTAS */
2708                 case SMB_FS_OBJECTID_INFORMATION:
2709                 {
2710                         unsigned char objid[16];
2711                         memcpy(pdata,create_volume_objectid(conn, objid),16);
2712                         data_len = 64;
2713                         break;
2714                 }
2715
2716                 /*
2717                  * Query the version and capabilities of the CIFS UNIX extensions
2718                  * in use.
2719                  */
2720
2721                 case SMB_QUERY_CIFS_UNIX_INFO:
2722                         if (!lp_unix_extensions()) {
2723                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2724                                 return;
2725                         }
2726                         data_len = 12;
2727                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2728                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2729                         /* We have POSIX ACLs, pathname and locking capability. */
2730                         SBIG_UINT(pdata,4,((SMB_BIG_UINT)(
2731                                         CIFS_UNIX_POSIX_ACLS_CAP|
2732                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
2733                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
2734                                         CIFS_UNIX_EXTATTR_CAP|
2735                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
2736                                         /* Ensure we don't do this on signed or sealed data. */
2737                                         (srv_is_signing_active() ? 0 : CIFS_UNIX_LARGE_READ_CAP)
2738                                         )));
2739                         break;
2740
2741                 case SMB_QUERY_POSIX_FS_INFO:
2742                 {
2743                         int rc;
2744                         vfs_statvfs_struct svfs;
2745
2746                         if (!lp_unix_extensions()) {
2747                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2748                                 return;
2749                         }
2750
2751                         rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2752
2753                         if (!rc) {
2754                                 data_len = 56;
2755                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
2756                                 SIVAL(pdata,4,svfs.BlockSize);
2757                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2758                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2759                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2760                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2761                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2762                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2763                                 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2764 #ifdef EOPNOTSUPP
2765                         } else if (rc == EOPNOTSUPP) {
2766                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2767                                 return;
2768 #endif /* EOPNOTSUPP */
2769                         } else {
2770                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2771                                 reply_doserror(req, ERRSRV, ERRerror);
2772                                 return;
2773                         }
2774                         break;
2775                 }
2776
2777                 case SMB_QUERY_POSIX_WHOAMI:
2778                 {
2779                         uint32_t flags = 0;
2780                         uint32_t sid_bytes;
2781                         int i;
2782
2783                         if (!lp_unix_extensions()) {
2784                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2785                                 return;
2786                         }
2787
2788                         if (max_data_bytes < 40) {
2789                                 reply_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
2790                                 return;
2791                         }
2792
2793                         /* We ARE guest if global_sid_Builtin_Guests is
2794                          * in our list of SIDs.
2795                          */
2796                         if (nt_token_check_sid(&global_sid_Builtin_Guests,
2797                                     current_user.nt_user_token)) {
2798                                 flags |= SMB_WHOAMI_GUEST;
2799                         }
2800
2801                         /* We are NOT guest if global_sid_Authenticated_Users
2802                          * is in our list of SIDs.
2803                          */
2804                         if (nt_token_check_sid(&global_sid_Authenticated_Users,
2805                                     current_user.nt_user_token)) {
2806                                 flags &= ~SMB_WHOAMI_GUEST;
2807                         }
2808
2809                         /* NOTE: 8 bytes for UID/GID, irrespective of native
2810                          * platform size. This matches
2811                          * SMB_QUERY_FILE_UNIX_BASIC and friends.
2812                          */
2813                         data_len = 4 /* flags */
2814                             + 4 /* flag mask */
2815                             + 8 /* uid */
2816                             + 8 /* gid */
2817                             + 4 /* ngroups */
2818                             + 4 /* num_sids */
2819                             + 4 /* SID bytes */
2820                             + 4 /* pad/reserved */
2821                             + (current_user.ut.ngroups * 8)
2822                                 /* groups list */
2823                             + (current_user.nt_user_token->num_sids *
2824                                     SID_MAX_SIZE)
2825                                 /* SID list */;
2826
2827                         SIVAL(pdata, 0, flags);
2828                         SIVAL(pdata, 4, SMB_WHOAMI_MASK);
2829                         SBIG_UINT(pdata, 8, (SMB_BIG_UINT)current_user.ut.uid);
2830                         SBIG_UINT(pdata, 16, (SMB_BIG_UINT)current_user.ut.gid);
2831
2832
2833                         if (data_len >= max_data_bytes) {
2834                                 /* Potential overflow, skip the GIDs and SIDs. */
2835
2836                                 SIVAL(pdata, 24, 0); /* num_groups */
2837                                 SIVAL(pdata, 28, 0); /* num_sids */
2838                                 SIVAL(pdata, 32, 0); /* num_sid_bytes */
2839                                 SIVAL(pdata, 36, 0); /* reserved */
2840
2841                                 data_len = 40;
2842                                 break;
2843                         }
2844
2845                         SIVAL(pdata, 24, current_user.ut.ngroups);
2846                         SIVAL(pdata, 28,
2847                                 current_user.nt_user_token->num_sids);
2848
2849                         /* We walk the SID list twice, but this call is fairly
2850                          * infrequent, and I don't expect that it's performance
2851                          * sensitive -- jpeach
2852                          */
2853                         for (i = 0, sid_bytes = 0;
2854                             i < current_user.nt_user_token->num_sids; ++i) {
2855                                 sid_bytes +=
2856                                     sid_size(&current_user.nt_user_token->user_sids[i]);
2857                         }
2858
2859                         /* SID list byte count */
2860                         SIVAL(pdata, 32, sid_bytes);
2861
2862                         /* 4 bytes pad/reserved - must be zero */
2863                         SIVAL(pdata, 36, 0);
2864                         data_len = 40;
2865
2866                         /* GID list */
2867                         for (i = 0; i < current_user.ut.ngroups; ++i) {
2868                                 SBIG_UINT(pdata, data_len,
2869                                         (SMB_BIG_UINT)current_user.ut.groups[i]);
2870                                 data_len += 8;
2871                         }
2872
2873                         /* SID list */
2874                         for (i = 0;
2875                             i < current_user.nt_user_token->num_sids; ++i) {
2876                                 int sid_len =
2877                                     sid_size(&current_user.nt_user_token->user_sids[i]);
2878
2879                                 sid_linearize(pdata + data_len, sid_len,
2880                                     &current_user.nt_user_token->user_sids[i]);
2881                                 data_len += sid_len;
2882                         }
2883
2884                         break;
2885                 }
2886
2887                 case SMB_MAC_QUERY_FS_INFO:
2888                         /*
2889                          * Thursby MAC extension... ONLY on NTFS filesystems
2890                          * once we do streams then we don't need this
2891                          */
2892                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2893                                 data_len = 88;
2894                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
2895                                 break;
2896                         }
2897                         /* drop through */
2898                 default:
2899                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2900                         return;
2901         }
2902
2903
2904         send_trans2_replies(req, params, 0, pdata, data_len,
2905                             max_data_bytes);
2906
2907         DEBUG( 4, ( "%s info_level = %d\n",
2908                     smb_fn_name(CVAL(req->inbuf,smb_com)), info_level) );
2909
2910         return;
2911 }
2912
2913 /****************************************************************************
2914  Reply to a TRANS2_SETFSINFO (set filesystem info).
2915 ****************************************************************************/
2916
2917 static void call_trans2setfsinfo(connection_struct *conn,
2918                                  struct smb_request *req,
2919                                  char **pparams, int total_params,
2920                                  char **ppdata, int total_data,
2921                                  unsigned int max_data_bytes)
2922 {
2923         char *pdata = *ppdata;
2924         char *params = *pparams;
2925         uint16 info_level;
2926
2927         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
2928
2929         /*  */
2930         if (total_params < 4) {
2931                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2932                         total_params));
2933                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2934                 return;
2935         }
2936
2937         info_level = SVAL(params,2);
2938
2939         switch(info_level) {
2940                 case SMB_SET_CIFS_UNIX_INFO:
2941                         {
2942                                 uint16 client_unix_major;
2943