9ba6d198c4cd8f96ecde0f7856442ade1bb25c1f
[samba.git] / source3 / 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                    2006-2007
9
10    Extensively modified by Andrew Tridgell, 1995
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3 of the License, or
15    (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27
28 extern int max_send;
29 extern enum protocol_types Protocol;
30 extern uint32 global_client_caps;
31
32 #define get_file_size(sbuf) ((sbuf).st_size)
33 #define DIR_ENTRY_SAFETY_MARGIN 4096
34
35 static char *store_file_unix_basic(connection_struct *conn,
36                                 char *pdata,
37                                 files_struct *fsp,
38                                 const SMB_STRUCT_STAT *psbuf);
39
40 static char *store_file_unix_basic_info2(connection_struct *conn,
41                                 char *pdata,
42                                 files_struct *fsp,
43                                 const SMB_STRUCT_STAT *psbuf);
44
45 /********************************************************************
46  Roundup a value to the nearest allocation roundup size boundary.
47  Only do this for Windows clients.
48 ********************************************************************/
49
50 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
51 {
52         uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
53
54         /* Only roundup for Windows clients. */
55         enum remote_arch_types ra_type = get_remote_arch();
56         if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
57                 val = SMB_ROUNDUP(val,rval);
58         }
59         return val;
60 }
61
62 /********************************************************************
63  Given a stat buffer return the allocated size on disk, taking into
64  account sparse files.
65 ********************************************************************/
66
67 uint64_t get_allocation_size(connection_struct *conn, files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
68 {
69         uint64_t ret;
70
71         if(S_ISDIR(sbuf->st_mode)) {
72                 return 0;
73         }
74
75 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
76         ret = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_blocks;
77 #else
78         ret = (uint64_t)get_file_size(*sbuf);
79 #endif
80
81         if (fsp && fsp->initial_allocation_size)
82                 ret = MAX(ret,fsp->initial_allocation_size);
83
84         return smb_roundup(conn, ret);
85 }
86
87 /****************************************************************************
88  Utility functions for dealing with extended attributes.
89 ****************************************************************************/
90
91 /****************************************************************************
92  Refuse to allow clients to overwrite our private xattrs.
93 ****************************************************************************/
94
95 static bool samba_private_attr_name(const char *unix_ea_name)
96 {
97         static const char *prohibited_ea_names[] = {
98                 SAMBA_POSIX_INHERITANCE_EA_NAME,
99                 SAMBA_XATTR_DOS_ATTRIB,
100                 NULL
101         };
102
103         int i;
104
105         for (i = 0; prohibited_ea_names[i]; i++) {
106                 if (strequal( prohibited_ea_names[i], unix_ea_name))
107                         return true;
108         }
109         if (StrnCaseCmp(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
110                         strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
111                 return true;
112         }
113         return false;
114 }
115
116 /****************************************************************************
117  Get one EA value. Fill in a struct ea_struct.
118 ****************************************************************************/
119
120 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn,
121                       files_struct *fsp, const char *fname,
122                       const char *ea_name, struct ea_struct *pea)
123 {
124         /* Get the value of this xattr. Max size is 64k. */
125         size_t attr_size = 256;
126         char *val = NULL;
127         ssize_t sizeret;
128
129  again:
130
131         val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
132         if (!val) {
133                 return NT_STATUS_NO_MEMORY;
134         }
135
136         if (fsp && fsp->fh->fd != -1) {
137                 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
138         } else {
139                 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
140         }
141
142         if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
143                 attr_size = 65536;
144                 goto again;
145         }
146
147         if (sizeret == -1) {
148                 return map_nt_error_from_unix(errno);
149         }
150
151         DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
152         dump_data(10, (uint8 *)val, sizeret);
153
154         pea->flags = 0;
155         if (strnequal(ea_name, "user.", 5)) {
156                 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
157         } else {
158                 pea->name = talloc_strdup(mem_ctx, ea_name);
159         }
160         if (pea->name == NULL) {
161                 TALLOC_FREE(val);
162                 return NT_STATUS_NO_MEMORY;
163         }
164         pea->value.data = (unsigned char *)val;
165         pea->value.length = (size_t)sizeret;
166         return NT_STATUS_OK;
167 }
168
169 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn,
170                                 files_struct *fsp, const char *fname,
171                                 char ***pnames, size_t *pnum_names)
172 {
173         /* Get a list of all xattrs. Max namesize is 64k. */
174         size_t ea_namelist_size = 1024;
175         char *ea_namelist = NULL;
176
177         char *p;
178         char **names, **tmp;
179         size_t num_names;
180         ssize_t sizeret = -1;
181
182         if (!lp_ea_support(SNUM(conn))) {
183                 *pnames = NULL;
184                 *pnum_names = 0;
185                 return NT_STATUS_OK;
186         }
187
188         /*
189          * TALLOC the result early to get the talloc hierarchy right.
190          */
191
192         names = TALLOC_ARRAY(mem_ctx, char *, 1);
193         if (names == NULL) {
194                 DEBUG(0, ("talloc failed\n"));
195                 return NT_STATUS_NO_MEMORY;
196         }
197
198         while (ea_namelist_size <= 65536) {
199
200                 ea_namelist = TALLOC_REALLOC_ARRAY(
201                         names, ea_namelist, char, ea_namelist_size);
202                 if (ea_namelist == NULL) {
203                         DEBUG(0, ("talloc failed\n"));
204                         TALLOC_FREE(names);
205                         return NT_STATUS_NO_MEMORY;
206                 }
207
208                 if (fsp && fsp->fh->fd != -1) {
209                         sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
210                                                      ea_namelist_size);
211                 } else {
212                         sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist,
213                                                     ea_namelist_size);
214                 }
215
216                 if ((sizeret == -1) && (errno == ERANGE)) {
217                         ea_namelist_size *= 2;
218                 }
219                 else {
220                         break;
221                 }
222         }
223
224         if (sizeret == -1) {
225                 TALLOC_FREE(names);
226                 return map_nt_error_from_unix(errno);
227         }
228
229         DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
230                    (unsigned int)sizeret));
231
232         if (sizeret == 0) {
233                 TALLOC_FREE(names);
234                 *pnames = NULL;
235                 *pnum_names = 0;
236                 return NT_STATUS_OK;
237         }
238
239         /*
240          * Ensure the result is 0-terminated
241          */
242
243         if (ea_namelist[sizeret-1] != '\0') {
244                 TALLOC_FREE(names);
245                 return NT_STATUS_INTERNAL_ERROR;
246         }
247
248         /*
249          * count the names
250          */
251         num_names = 0;
252
253         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
254                 num_names += 1;
255         }
256
257         tmp = TALLOC_REALLOC_ARRAY(mem_ctx, names, char *, num_names);
258         if (tmp == NULL) {
259                 DEBUG(0, ("talloc failed\n"));
260                 TALLOC_FREE(names);
261                 return NT_STATUS_NO_MEMORY;
262         }
263
264         names = tmp;
265         num_names = 0;
266
267         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
268                 names[num_names++] = p;
269         }
270
271         *pnames = names;
272         *pnum_names = num_names;
273         return NT_STATUS_OK;
274 }
275
276 /****************************************************************************
277  Return a linked list of the total EA's. Plus the total size
278 ****************************************************************************/
279
280 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
281                                         const char *fname, size_t *pea_total_len)
282 {
283         /* Get a list of all xattrs. Max namesize is 64k. */
284         size_t i, num_names;
285         char **names;
286         struct ea_list *ea_list_head = NULL;
287         NTSTATUS status;
288
289         *pea_total_len = 0;
290
291         if (!lp_ea_support(SNUM(conn))) {
292                 return NULL;
293         }
294
295         status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
296                                         &names, &num_names);
297
298         if (!NT_STATUS_IS_OK(status) || (num_names == 0)) {
299                 return NULL;
300         }
301
302         for (i=0; i<num_names; i++) {
303                 struct ea_list *listp;
304                 fstring dos_ea_name;
305
306                 if (strnequal(names[i], "system.", 7)
307                     || samba_private_attr_name(names[i]))
308                         continue;
309
310                 listp = TALLOC_P(mem_ctx, struct ea_list);
311                 if (listp == NULL) {
312                         return NULL;
313                 }
314
315                 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx, conn, fsp,
316                                                   fname, names[i],
317                                                   &listp->ea))) {
318                         return NULL;
319                 }
320
321                 push_ascii_fstring(dos_ea_name, listp->ea.name);
322
323                 *pea_total_len +=
324                         4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
325
326                 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
327                           "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
328                           (unsigned int)listp->ea.value.length));
329
330                 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
331
332         }
333
334         /* Add on 4 for total length. */
335         if (*pea_total_len) {
336                 *pea_total_len += 4;
337         }
338
339         DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
340                    (unsigned int)*pea_total_len));
341
342         return ea_list_head;
343 }
344
345 /****************************************************************************
346  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
347  that was filled.
348 ****************************************************************************/
349
350 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
351         connection_struct *conn, struct ea_list *ea_list)
352 {
353         unsigned int ret_data_size = 4;
354         char *p = pdata;
355
356         SMB_ASSERT(total_data_size >= 4);
357
358         if (!lp_ea_support(SNUM(conn))) {
359                 SIVAL(pdata,4,0);
360                 return 4;
361         }
362
363         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
364                 size_t dos_namelen;
365                 fstring dos_ea_name;
366                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
367                 dos_namelen = strlen(dos_ea_name);
368                 if (dos_namelen > 255 || dos_namelen == 0) {
369                         break;
370                 }
371                 if (ea_list->ea.value.length > 65535) {
372                         break;
373                 }
374                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
375                         break;
376                 }
377
378                 /* We know we have room. */
379                 SCVAL(p,0,ea_list->ea.flags);
380                 SCVAL(p,1,dos_namelen);
381                 SSVAL(p,2,ea_list->ea.value.length);
382                 fstrcpy(p+4, dos_ea_name);
383                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
384
385                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
386                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
387         }
388
389         ret_data_size = PTR_DIFF(p, pdata);
390         DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
391         SIVAL(pdata,0,ret_data_size);
392         return ret_data_size;
393 }
394
395 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
396 {
397         size_t total_ea_len = 0;
398         TALLOC_CTX *mem_ctx = NULL;
399
400         if (!lp_ea_support(SNUM(conn))) {
401                 return 0;
402         }
403         mem_ctx = talloc_tos();
404         (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
405         return total_ea_len;
406 }
407
408 /****************************************************************************
409  Ensure the EA name is case insensitive by matching any existing EA name.
410 ****************************************************************************/
411
412 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
413 {
414         size_t total_ea_len;
415         TALLOC_CTX *mem_ctx = talloc_tos();
416         struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
417
418         for (; ea_list; ea_list = ea_list->next) {
419                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
420                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
421                                 &unix_ea_name[5], ea_list->ea.name));
422                         safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
423                         break;
424                 }
425         }
426 }
427
428 /****************************************************************************
429  Set or delete an extended attribute.
430 ****************************************************************************/
431
432 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname, struct ea_list *ea_list)
433 {
434         if (!lp_ea_support(SNUM(conn))) {
435                 return NT_STATUS_EAS_NOT_SUPPORTED;
436         }
437
438         for (;ea_list; ea_list = ea_list->next) {
439                 int ret;
440                 fstring unix_ea_name;
441
442                 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
443                 fstrcat(unix_ea_name, ea_list->ea.name);
444
445                 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
446
447                 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
448
449                 if (samba_private_attr_name(unix_ea_name)) {
450                         DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
451                         return NT_STATUS_ACCESS_DENIED;
452                 }
453
454                 if (ea_list->ea.value.length == 0) {
455                         /* Remove the attribute. */
456                         if (fsp && (fsp->fh->fd != -1)) {
457                                 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
458                                         unix_ea_name, fsp->fsp_name));
459                                 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
460                         } else {
461                                 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
462                                         unix_ea_name, fname));
463                                 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
464                         }
465 #ifdef ENOATTR
466                         /* Removing a non existent attribute always succeeds. */
467                         if (ret == -1 && errno == ENOATTR) {
468                                 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
469                                                 unix_ea_name));
470                                 ret = 0;
471                         }
472 #endif
473                 } else {
474                         if (fsp && (fsp->fh->fd != -1)) {
475                                 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
476                                         unix_ea_name, fsp->fsp_name));
477                                 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
478                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
479                         } else {
480                                 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
481                                         unix_ea_name, fname));
482                                 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
483                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
484                         }
485                 }
486
487                 if (ret == -1) {
488 #ifdef ENOTSUP
489                         if (errno == ENOTSUP) {
490                                 return NT_STATUS_EAS_NOT_SUPPORTED;
491                         }
492 #endif
493                         return map_nt_error_from_unix(errno);
494                 }
495
496         }
497         return NT_STATUS_OK;
498 }
499 /****************************************************************************
500  Read a list of EA names from an incoming data buffer. Create an ea_list with them.
501 ****************************************************************************/
502
503 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
504 {
505         struct ea_list *ea_list_head = NULL;
506         size_t converted_size, offset = 0;
507
508         while (offset + 2 < data_size) {
509                 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
510                 unsigned int namelen = CVAL(pdata,offset);
511
512                 offset++; /* Go past the namelen byte. */
513
514                 /* integer wrap paranioa. */
515                 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
516                                 (offset > data_size) || (namelen > data_size) ||
517                                 (offset + namelen >= data_size)) {
518                         break;
519                 }
520                 /* Ensure the name is null terminated. */
521                 if (pdata[offset + namelen] != '\0') {
522                         return NULL;
523                 }
524                 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
525                                        &converted_size)) {
526                         DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
527                                  "failed: %s", strerror(errno)));
528                 }
529                 if (!eal->ea.name) {
530                         return NULL;
531                 }
532
533                 offset += (namelen + 1); /* Go past the name + terminating zero. */
534                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
535                 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
536         }
537
538         return ea_list_head;
539 }
540
541 /****************************************************************************
542  Read one EA list entry from the buffer.
543 ****************************************************************************/
544
545 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
546 {
547         struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
548         uint16 val_len;
549         unsigned int namelen;
550         size_t converted_size;
551
552         if (!eal) {
553                 return NULL;
554         }
555
556         if (data_size < 6) {
557                 return NULL;
558         }
559
560         eal->ea.flags = CVAL(pdata,0);
561         namelen = CVAL(pdata,1);
562         val_len = SVAL(pdata,2);
563
564         if (4 + namelen + 1 + val_len > data_size) {
565                 return NULL;
566         }
567
568         /* Ensure the name is null terminated. */
569         if (pdata[namelen + 4] != '\0') {
570                 return NULL;
571         }
572         if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
573                 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
574                          strerror(errno)));
575         }
576         if (!eal->ea.name) {
577                 return NULL;
578         }
579
580         eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
581         if (!eal->ea.value.data) {
582                 return NULL;
583         }
584
585         memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
586
587         /* Ensure we're null terminated just in case we print the value. */
588         eal->ea.value.data[val_len] = '\0';
589         /* But don't count the null. */
590         eal->ea.value.length--;
591
592         if (pbytes_used) {
593                 *pbytes_used = 4 + namelen + 1 + val_len;
594         }
595
596         DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
597         dump_data(10, eal->ea.value.data, eal->ea.value.length);
598
599         return eal;
600 }
601
602 /****************************************************************************
603  Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
604 ****************************************************************************/
605
606 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
607 {
608         struct ea_list *ea_list_head = NULL;
609         size_t offset = 0;
610         size_t bytes_used = 0;
611
612         while (offset < data_size) {
613                 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
614
615                 if (!eal) {
616                         return NULL;
617                 }
618
619                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
620                 offset += bytes_used;
621         }
622
623         return ea_list_head;
624 }
625
626 /****************************************************************************
627  Count the total EA size needed.
628 ****************************************************************************/
629
630 static size_t ea_list_size(struct ea_list *ealist)
631 {
632         fstring dos_ea_name;
633         struct ea_list *listp;
634         size_t ret = 0;
635
636         for (listp = ealist; listp; listp = listp->next) {
637                 push_ascii_fstring(dos_ea_name, listp->ea.name);
638                 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
639         }
640         /* Add on 4 for total length. */
641         if (ret) {
642                 ret += 4;
643         }
644
645         return ret;
646 }
647
648 /****************************************************************************
649  Return a union of EA's from a file list and a list of names.
650  The TALLOC context for the two lists *MUST* be identical as we steal
651  memory from one list to add to another. JRA.
652 ****************************************************************************/
653
654 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
655 {
656         struct ea_list *nlistp, *flistp;
657
658         for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
659                 for (flistp = file_list; flistp; flistp = flistp->next) {
660                         if (strequal(nlistp->ea.name, flistp->ea.name)) {
661                                 break;
662                         }
663                 }
664
665                 if (flistp) {
666                         /* Copy the data from this entry. */
667                         nlistp->ea.flags = flistp->ea.flags;
668                         nlistp->ea.value = flistp->ea.value;
669                 } else {
670                         /* Null entry. */
671                         nlistp->ea.flags = 0;
672                         ZERO_STRUCT(nlistp->ea.value);
673                 }
674         }
675
676         *total_ea_len = ea_list_size(name_list);
677         return name_list;
678 }
679
680 /****************************************************************************
681   Send the required number of replies back.
682   We assume all fields other than the data fields are
683   set correctly for the type of call.
684   HACK ! Always assumes smb_setup field is zero.
685 ****************************************************************************/
686
687 void send_trans2_replies(connection_struct *conn,
688                         struct smb_request *req,
689                          const char *params,
690                          int paramsize,
691                          const char *pdata,
692                          int datasize,
693                          int max_data_bytes)
694 {
695         /* As we are using a protocol > LANMAN1 then the max_send
696          variable must have been set in the sessetupX call.
697          This takes precedence over the max_xmit field in the
698          global struct. These different max_xmit variables should
699          be merged as this is now too confusing */
700
701         int data_to_send = datasize;
702         int params_to_send = paramsize;
703         int useable_space;
704         const char *pp = params;
705         const char *pd = pdata;
706         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
707         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
708         int data_alignment_offset = 0;
709         bool overflow = False;
710
711         /* Modify the data_to_send and datasize and set the error if
712            we're trying to send more than max_data_bytes. We still send
713            the part of the packet(s) that fit. Strange, but needed
714            for OS/2. */
715
716         if (max_data_bytes > 0 && datasize > max_data_bytes) {
717                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
718                         max_data_bytes, datasize ));
719                 datasize = data_to_send = max_data_bytes;
720                 overflow = True;
721         }
722
723         /* If there genuinely are no parameters or data to send just send the empty packet */
724
725         if(params_to_send == 0 && data_to_send == 0) {
726                 reply_outbuf(req, 10, 0);
727                 show_msg((char *)req->outbuf);
728                 return;
729         }
730
731         /* When sending params and data ensure that both are nicely aligned */
732         /* Only do this alignment when there is also data to send - else
733                 can cause NT redirector problems. */
734
735         if (((params_to_send % 4) != 0) && (data_to_send != 0))
736                 data_alignment_offset = 4 - (params_to_send % 4);
737
738         /* Space is bufsize minus Netbios over TCP header minus SMB header */
739         /* The alignment_offset is to align the param bytes on an even byte
740                 boundary. NT 4.0 Beta needs this to work correctly. */
741
742         useable_space = max_send - (smb_size
743                                     + 2 * 10 /* wct */
744                                     + alignment_offset
745                                     + data_alignment_offset);
746
747         if (useable_space < 0) {
748                 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
749                           "= %d!!!", useable_space));
750                 exit_server_cleanly("send_trans2_replies: Not enough space");
751         }
752
753         while (params_to_send || data_to_send) {
754                 /* Calculate whether we will totally or partially fill this packet */
755
756                 total_sent_thistime = params_to_send + data_to_send;
757
758                 /* We can never send more than useable_space */
759                 /*
760                  * Note that 'useable_space' does not include the alignment offsets,
761                  * but we must include the alignment offsets in the calculation of
762                  * the length of the data we send over the wire, as the alignment offsets
763                  * are sent here. Fix from Marc_Jacobsen@hp.com.
764                  */
765
766                 total_sent_thistime = MIN(total_sent_thistime, useable_space);
767
768                 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
769                              + data_alignment_offset);
770
771                 /*
772                  * We might have SMBtrans2s in req which was transferred to
773                  * the outbuf, fix that.
774                  */
775                 SCVAL(req->outbuf, smb_com, SMBtrans2);
776
777                 /* Set total params and data to be sent */
778                 SSVAL(req->outbuf,smb_tprcnt,paramsize);
779                 SSVAL(req->outbuf,smb_tdrcnt,datasize);
780
781                 /* Calculate how many parameters and data we can fit into
782                  * this packet. Parameters get precedence
783                  */
784
785                 params_sent_thistime = MIN(params_to_send,useable_space);
786                 data_sent_thistime = useable_space - params_sent_thistime;
787                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
788
789                 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
790
791                 /* smb_proff is the offset from the start of the SMB header to the
792                         parameter bytes, however the first 4 bytes of outbuf are
793                         the Netbios over TCP header. Thus use smb_base() to subtract
794                         them from the calculation */
795
796                 SSVAL(req->outbuf,smb_proff,
797                       ((smb_buf(req->outbuf)+alignment_offset)
798                        - smb_base(req->outbuf)));
799
800                 if(params_sent_thistime == 0)
801                         SSVAL(req->outbuf,smb_prdisp,0);
802                 else
803                         /* Absolute displacement of param bytes sent in this packet */
804                         SSVAL(req->outbuf,smb_prdisp,pp - params);
805
806                 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
807                 if(data_sent_thistime == 0) {
808                         SSVAL(req->outbuf,smb_droff,0);
809                         SSVAL(req->outbuf,smb_drdisp, 0);
810                 } else {
811                         /* The offset of the data bytes is the offset of the
812                                 parameter bytes plus the number of parameters being sent this time */
813                         SSVAL(req->outbuf, smb_droff,
814                               ((smb_buf(req->outbuf)+alignment_offset)
815                                - smb_base(req->outbuf))
816                               + params_sent_thistime + data_alignment_offset);
817                         SSVAL(req->outbuf,smb_drdisp, pd - pdata);
818                 }
819
820                 /* Initialize the padding for alignment */
821
822                 if (alignment_offset != 0) {
823                         memset(smb_buf(req->outbuf), 0, alignment_offset);
824                 }
825
826                 /* Copy the param bytes into the packet */
827
828                 if(params_sent_thistime) {
829                         memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
830                                params_sent_thistime);
831                 }
832
833                 /* Copy in the data bytes */
834                 if(data_sent_thistime) {
835                         if (data_alignment_offset != 0) {
836                                 memset((smb_buf(req->outbuf)+alignment_offset+
837                                         params_sent_thistime), 0,
838                                        data_alignment_offset);
839                         }
840                         memcpy(smb_buf(req->outbuf)+alignment_offset
841                                +params_sent_thistime+data_alignment_offset,
842                                pd,data_sent_thistime);
843                 }
844
845                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
846                         params_sent_thistime, data_sent_thistime, useable_space));
847                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
848                         params_to_send, data_to_send, paramsize, datasize));
849
850                 if (overflow) {
851                         error_packet_set((char *)req->outbuf,
852                                          ERRDOS,ERRbufferoverflow,
853                                          STATUS_BUFFER_OVERFLOW,
854                                          __LINE__,__FILE__);
855                 }
856
857                 /* Send the packet */
858                 show_msg((char *)req->outbuf);
859                 if (!srv_send_smb(smbd_server_fd(),
860                                 (char *)req->outbuf,
861                                 IS_CONN_ENCRYPTED(conn)))
862                         exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
863
864                 TALLOC_FREE(req->outbuf);
865
866                 pp += params_sent_thistime;
867                 pd += data_sent_thistime;
868
869                 params_to_send -= params_sent_thistime;
870                 data_to_send -= data_sent_thistime;
871
872                 /* Sanity check */
873                 if(params_to_send < 0 || data_to_send < 0) {
874                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
875                                 params_to_send, data_to_send));
876                         return;
877                 }
878         }
879
880         return;
881 }
882
883 /****************************************************************************
884  Reply to a TRANSACT2_OPEN.
885 ****************************************************************************/
886
887 static void call_trans2open(connection_struct *conn,
888                             struct smb_request *req,
889                             char **pparams, int total_params,
890                             char **ppdata, int total_data,
891                             unsigned int max_data_bytes)
892 {
893         char *params = *pparams;
894         char *pdata = *ppdata;
895         int deny_mode;
896         int32 open_attr;
897         bool oplock_request;
898 #if 0
899         bool return_additional_info;
900         int16 open_sattr;
901         time_t open_time;
902 #endif
903         int open_ofun;
904         uint32 open_size;
905         char *pname;
906         char *fname = NULL;
907         SMB_OFF_T size=0;
908         int fattr=0,mtime=0;
909         SMB_INO_T inode = 0;
910         SMB_STRUCT_STAT sbuf;
911         int smb_action = 0;
912         files_struct *fsp;
913         struct ea_list *ea_list = NULL;
914         uint16 flags = 0;
915         NTSTATUS status;
916         uint32 access_mask;
917         uint32 share_mode;
918         uint32 create_disposition;
919         uint32 create_options = 0;
920         TALLOC_CTX *ctx = talloc_tos();
921
922         /*
923          * Ensure we have enough parameters to perform the operation.
924          */
925
926         if (total_params < 29) {
927                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
928                 return;
929         }
930
931         flags = SVAL(params, 0);
932         deny_mode = SVAL(params, 2);
933         open_attr = SVAL(params,6);
934         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
935         if (oplock_request) {
936                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
937         }
938
939 #if 0
940         return_additional_info = BITSETW(params,0);
941         open_sattr = SVAL(params, 4);
942         open_time = make_unix_date3(params+8);
943 #endif
944         open_ofun = SVAL(params,12);
945         open_size = IVAL(params,14);
946         pname = &params[28];
947
948         if (IS_IPC(conn)) {
949                 reply_doserror(req, ERRSRV, ERRaccess);
950                 return;
951         }
952
953         srvstr_get_path(ctx, params, req->flags2, &fname, pname,
954                         total_params - 28, STR_TERMINATE,
955                         &status);
956         if (!NT_STATUS_IS_OK(status)) {
957                 reply_nterror(req, status);
958                 return;
959         }
960
961         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
962                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
963                 (unsigned int)open_ofun, open_size));
964
965         if (open_ofun == 0) {
966                 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
967                 return;
968         }
969
970         if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
971                                 &access_mask,
972                                 &share_mode,
973                                 &create_disposition,
974                                 &create_options)) {
975                 reply_doserror(req, ERRDOS, ERRbadaccess);
976                 return;
977         }
978
979         /* Any data in this call is an EA list. */
980         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
981                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
982                 return;
983         }
984
985         if (total_data != 4) {
986                 if (total_data < 10) {
987                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
988                         return;
989                 }
990
991                 if (IVAL(pdata,0) > total_data) {
992                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
993                                 IVAL(pdata,0), (unsigned int)total_data));
994                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
995                         return;
996                 }
997
998                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
999                                        total_data - 4);
1000                 if (!ea_list) {
1001                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1002                         return;
1003                 }
1004         } else if (IVAL(pdata,0) != 4) {
1005                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1006                 return;
1007         }
1008
1009         status = SMB_VFS_CREATE_FILE(
1010                 conn,                                   /* conn */
1011                 req,                                    /* req */
1012                 0,                                      /* root_dir_fid */
1013                 fname,                                  /* fname */
1014                 true,                                   /* is_dos_path */
1015                 access_mask,                            /* access_mask */
1016                 share_mode,                             /* share_access */
1017                 create_disposition,                     /* create_disposition*/
1018                 create_options,                         /* create_options */
1019                 open_attr,                              /* file_attributes */
1020                 oplock_request,                         /* oplock_request */
1021                 open_size,                              /* allocation_size */
1022                 NULL,                                   /* sd */
1023                 ea_list,                                /* ea_list */
1024                 &fsp,                                   /* result */
1025                 &smb_action,                            /* pinfo */
1026                 &sbuf);                                 /* psbuf */
1027
1028         if (!NT_STATUS_IS_OK(status)) {
1029                 if (open_was_deferred(req->mid)) {
1030                         /* We have re-scheduled this call. */
1031                         return;
1032                 }
1033                 reply_openerror(req, status);
1034                 return;
1035         }
1036
1037         size = get_file_size(sbuf);
1038         fattr = dos_mode(conn,fsp->fsp_name,&sbuf);
1039         mtime = sbuf.st_mtime;
1040         inode = sbuf.st_ino;
1041         if (fattr & aDIR) {
1042                 close_file(req, fsp, ERROR_CLOSE);
1043                 reply_doserror(req, ERRDOS,ERRnoaccess);
1044                 return;
1045         }
1046
1047         /* Realloc the size of parameters and data we will return */
1048         *pparams = (char *)SMB_REALLOC(*pparams, 30);
1049         if(*pparams == NULL ) {
1050                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1051                 return;
1052         }
1053         params = *pparams;
1054
1055         SSVAL(params,0,fsp->fnum);
1056         SSVAL(params,2,fattr);
1057         srv_put_dos_date2(params,4, mtime);
1058         SIVAL(params,8, (uint32)size);
1059         SSVAL(params,12,deny_mode);
1060         SSVAL(params,14,0); /* open_type - file or directory. */
1061         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1062
1063         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1064                 smb_action |= EXTENDED_OPLOCK_GRANTED;
1065         }
1066
1067         SSVAL(params,18,smb_action);
1068
1069         /*
1070          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1071          */
1072         SIVAL(params,20,inode);
1073         SSVAL(params,24,0); /* Padding. */
1074         if (flags & 8) {
1075                 uint32 ea_size = estimate_ea_size(conn, fsp, fsp->fsp_name);
1076                 SIVAL(params, 26, ea_size);
1077         } else {
1078                 SIVAL(params, 26, 0);
1079         }
1080
1081         /* Send the required number of replies */
1082         send_trans2_replies(conn, req, params, 30, *ppdata, 0, max_data_bytes);
1083 }
1084
1085 /*********************************************************
1086  Routine to check if a given string matches exactly.
1087  as a special case a mask of "." does NOT match. That
1088  is required for correct wildcard semantics
1089  Case can be significant or not.
1090 **********************************************************/
1091
1092 static bool exact_match(connection_struct *conn,
1093                 const char *str,
1094                 const char *mask)
1095 {
1096         if (mask[0] == '.' && mask[1] == 0)
1097                 return False;
1098         if (conn->case_sensitive)
1099                 return strcmp(str,mask)==0;
1100         if (StrCaseCmp(str,mask) != 0) {
1101                 return False;
1102         }
1103         if (dptr_has_wild(conn->dirptr)) {
1104                 return False;
1105         }
1106         return True;
1107 }
1108
1109 /****************************************************************************
1110  Return the filetype for UNIX extensions.
1111 ****************************************************************************/
1112
1113 static uint32 unix_filetype(mode_t mode)
1114 {
1115         if(S_ISREG(mode))
1116                 return UNIX_TYPE_FILE;
1117         else if(S_ISDIR(mode))
1118                 return UNIX_TYPE_DIR;
1119 #ifdef S_ISLNK
1120         else if(S_ISLNK(mode))
1121                 return UNIX_TYPE_SYMLINK;
1122 #endif
1123 #ifdef S_ISCHR
1124         else if(S_ISCHR(mode))
1125                 return UNIX_TYPE_CHARDEV;
1126 #endif
1127 #ifdef S_ISBLK
1128         else if(S_ISBLK(mode))
1129                 return UNIX_TYPE_BLKDEV;
1130 #endif
1131 #ifdef S_ISFIFO
1132         else if(S_ISFIFO(mode))
1133                 return UNIX_TYPE_FIFO;
1134 #endif
1135 #ifdef S_ISSOCK
1136         else if(S_ISSOCK(mode))
1137                 return UNIX_TYPE_SOCKET;
1138 #endif
1139
1140         DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1141         return UNIX_TYPE_UNKNOWN;
1142 }
1143
1144 /****************************************************************************
1145  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1146 ****************************************************************************/
1147
1148 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1149
1150 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1151                                 SMB_STRUCT_STAT *psbuf,
1152                                 uint32 perms,
1153                                 enum perm_type ptype,
1154                                 mode_t *ret_perms)
1155 {
1156         mode_t ret = 0;
1157
1158         if (perms == SMB_MODE_NO_CHANGE) {
1159                 if (!VALID_STAT(*psbuf)) {
1160                         return NT_STATUS_INVALID_PARAMETER;
1161                 } else {
1162                         *ret_perms = psbuf->st_mode;
1163                         return NT_STATUS_OK;
1164                 }
1165         }
1166
1167         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1168         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1169         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1170         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1171         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1172         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1173         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1174         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1175         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1176 #ifdef S_ISVTX
1177         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1178 #endif
1179 #ifdef S_ISGID
1180         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1181 #endif
1182 #ifdef S_ISUID
1183         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1184 #endif
1185
1186         switch (ptype) {
1187         case PERM_NEW_FILE:
1188                 /* Apply mode mask */
1189                 ret &= lp_create_mask(SNUM(conn));
1190                 /* Add in force bits */
1191                 ret |= lp_force_create_mode(SNUM(conn));
1192                 break;
1193         case PERM_NEW_DIR:
1194                 ret &= lp_dir_mask(SNUM(conn));
1195                 /* Add in force bits */
1196                 ret |= lp_force_dir_mode(SNUM(conn));
1197                 break;
1198         case PERM_EXISTING_FILE:
1199                 /* Apply mode mask */
1200                 ret &= lp_security_mask(SNUM(conn));
1201                 /* Add in force bits */
1202                 ret |= lp_force_security_mode(SNUM(conn));
1203                 break;
1204         case PERM_EXISTING_DIR:
1205                 /* Apply mode mask */
1206                 ret &= lp_dir_security_mask(SNUM(conn));
1207                 /* Add in force bits */
1208                 ret |= lp_force_dir_security_mode(SNUM(conn));
1209                 break;
1210         }
1211
1212         *ret_perms = ret;
1213         return NT_STATUS_OK;
1214 }
1215
1216 /****************************************************************************
1217  Needed to show the msdfs symlinks as directories. Modifies psbuf
1218  to be a directory if it's a msdfs link.
1219 ****************************************************************************/
1220
1221 static bool check_msdfs_link(connection_struct *conn,
1222                                 const char *pathname,
1223                                 SMB_STRUCT_STAT *psbuf)
1224 {
1225         int saved_errno = errno;
1226         if(lp_host_msdfs() &&
1227                 lp_msdfs_root(SNUM(conn)) &&
1228                 is_msdfs_link(conn, pathname, psbuf)) {
1229
1230                 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1231                         "as a directory\n",
1232                         pathname));
1233                 psbuf->st_mode = (psbuf->st_mode & 0xFFF) | S_IFDIR;
1234                 errno = saved_errno;
1235                 return true;
1236         }
1237         errno = saved_errno;
1238         return false;
1239 }
1240
1241
1242 /****************************************************************************
1243  Get a level dependent lanman2 dir entry.
1244 ****************************************************************************/
1245
1246 static bool get_lanman2_dir_entry(TALLOC_CTX *ctx,
1247                                 connection_struct *conn,
1248                                 uint16 flags2,
1249                                 const char *path_mask,
1250                                 uint32 dirtype,
1251                                 int info_level,
1252                                 int requires_resume_key,
1253                                 bool dont_descend,
1254                                 bool ask_sharemode,
1255                                 char **ppdata,
1256                                 char *base_data,
1257                                 char *end_data,
1258                                 int space_remaining,
1259                                 bool *out_of_space,
1260                                 bool *got_exact_match,
1261                                 int *last_entry_off,
1262                                 struct ea_list *name_list)
1263 {
1264         const char *dname;
1265         bool found = False;
1266         SMB_STRUCT_STAT sbuf;
1267         const char *mask = NULL;
1268         char *pathreal = NULL;
1269         const char *fname = NULL;
1270         char *p, *q, *pdata = *ppdata;
1271         uint32 reskey=0;
1272         long prev_dirpos=0;
1273         uint32 mode=0;
1274         SMB_OFF_T file_size = 0;
1275         uint64_t allocation_size = 0;
1276         uint32 len;
1277         struct timespec mdate_ts, adate_ts, create_date_ts;
1278         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1279         char *nameptr;
1280         char *last_entry_ptr;
1281         bool was_8_3;
1282         uint32 nt_extmode; /* Used for NT connections instead of mode */
1283         bool needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1284         bool check_mangled_names = lp_manglednames(conn->params);
1285         char mangled_name[13]; /* mangled 8.3 name. */
1286
1287         *out_of_space = False;
1288         *got_exact_match = False;
1289
1290         ZERO_STRUCT(mdate_ts);
1291         ZERO_STRUCT(adate_ts);
1292         ZERO_STRUCT(create_date_ts);
1293
1294         if (!conn->dirptr) {
1295                 return(False);
1296         }
1297
1298         p = strrchr_m(path_mask,'/');
1299         if(p != NULL) {
1300                 if(p[1] == '\0') {
1301                         mask = talloc_strdup(ctx,"*.*");
1302                 } else {
1303                         mask = p+1;
1304                 }
1305         } else {
1306                 mask = path_mask;
1307         }
1308
1309         while (!found) {
1310                 bool got_match;
1311                 bool ms_dfs_link = False;
1312
1313                 /* Needed if we run out of space */
1314                 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1315                 dname = dptr_ReadDirName(ctx,conn->dirptr,&curr_dirpos,&sbuf);
1316
1317                 /*
1318                  * Due to bugs in NT client redirectors we are not using
1319                  * resume keys any more - set them to zero.
1320                  * Check out the related comments in findfirst/findnext.
1321                  * JRA.
1322                  */
1323
1324                 reskey = 0;
1325
1326                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1327                         (long)conn->dirptr,curr_dirpos));
1328
1329                 if (!dname) {
1330                         return(False);
1331                 }
1332
1333                 /*
1334                  * fname may get mangled, dname is never mangled.
1335                  * Whenever we're accessing the filesystem we use
1336                  * pathreal which is composed from dname.
1337                  */
1338
1339                 pathreal = NULL;
1340                 fname = dname;
1341
1342                 /* Mangle fname if it's an illegal name. */
1343                 if (mangle_must_mangle(dname,conn->params)) {
1344                         if (!name_to_8_3(dname,mangled_name,True,conn->params)) {
1345                                 continue; /* Error - couldn't mangle. */
1346                         }
1347                         fname = mangled_name;
1348                 }
1349
1350                 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask))) {
1351                         got_match = mask_match(fname, mask, conn->case_sensitive);
1352                 }
1353
1354                 if(!got_match && check_mangled_names &&
1355                    !mangle_is_8_3(fname, False, conn->params)) {
1356                         /*
1357                          * It turns out that NT matches wildcards against
1358                          * both long *and* short names. This may explain some
1359                          * of the wildcard wierdness from old DOS clients
1360                          * that some people have been seeing.... JRA.
1361                          */
1362                         /* Force the mangling into 8.3. */
1363                         if (!name_to_8_3( fname, mangled_name, False, conn->params)) {
1364                                 continue; /* Error - couldn't mangle. */
1365                         }
1366
1367                         if(!(got_match = *got_exact_match = exact_match(conn, mangled_name, mask))) {
1368                                 got_match = mask_match(mangled_name, mask, conn->case_sensitive);
1369                         }
1370                 }
1371
1372                 if (got_match) {
1373                         bool isdots = (ISDOT(dname) || ISDOTDOT(dname));
1374
1375                         if (dont_descend && !isdots) {
1376                                 continue;
1377                         }
1378
1379                         if (needslash) {
1380                                 pathreal = NULL;
1381                                 pathreal = talloc_asprintf(ctx,
1382                                         "%s/%s",
1383                                         conn->dirpath,
1384                                         dname);
1385                         } else {
1386                                 pathreal = talloc_asprintf(ctx,
1387                                         "%s%s",
1388                                         conn->dirpath,
1389                                         dname);
1390                         }
1391
1392                         if (!pathreal) {
1393                                 return False;
1394                         }
1395
1396                         if (INFO_LEVEL_IS_UNIX(info_level)) {
1397                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1398                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1399                                                 pathreal,strerror(errno)));
1400                                         TALLOC_FREE(pathreal);
1401                                         continue;
1402                                 }
1403                         } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1404                                 /* Needed to show the msdfs symlinks as
1405                                  * directories */
1406
1407                                 ms_dfs_link = check_msdfs_link(conn, pathreal, &sbuf);
1408                                 if (!ms_dfs_link) {
1409                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1410                                                 pathreal,strerror(errno)));
1411                                         TALLOC_FREE(pathreal);
1412                                         continue;
1413                                 }
1414                         }
1415
1416                         if (ms_dfs_link) {
1417                                 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1418                         } else {
1419                                 mode = dos_mode(conn,pathreal,&sbuf);
1420                         }
1421
1422                         if (!dir_check_ftype(conn,mode,dirtype)) {
1423                                 DEBUG(5,("get_lanman2_dir_entry: [%s] attribs didn't match %x\n",fname,dirtype));
1424                                 TALLOC_FREE(pathreal);
1425                                 continue;
1426                         }
1427
1428                         if (!(mode & aDIR)) {
1429                                 file_size = get_file_size(sbuf);
1430                         }
1431                         allocation_size = get_allocation_size(conn,NULL,&sbuf);
1432
1433                         mdate_ts = get_mtimespec(&sbuf);
1434                         adate_ts = get_atimespec(&sbuf);
1435                         create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1436
1437                         if (ask_sharemode) {
1438                                 struct timespec write_time_ts;
1439                                 struct file_id fileid;
1440
1441                                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
1442                                 get_file_infos(fileid, NULL, &write_time_ts);
1443                                 if (!null_timespec(write_time_ts)) {
1444                                         mdate_ts = write_time_ts;
1445                                 }
1446                         }
1447
1448                         if (lp_dos_filetime_resolution(SNUM(conn))) {
1449                                 dos_filetime_timespec(&create_date_ts);
1450                                 dos_filetime_timespec(&mdate_ts);
1451                                 dos_filetime_timespec(&adate_ts);
1452                         }
1453
1454                         create_date = convert_timespec_to_time_t(create_date_ts);
1455                         mdate = convert_timespec_to_time_t(mdate_ts);
1456                         adate = convert_timespec_to_time_t(adate_ts);
1457
1458                         DEBUG(5,("get_lanman2_dir_entry: found %s fname=%s\n",pathreal,fname));
1459
1460                         found = True;
1461
1462                         dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1463                 }
1464         }
1465
1466         p = pdata;
1467         last_entry_ptr = p;
1468
1469         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1470
1471         switch (info_level) {
1472                 case SMB_FIND_INFO_STANDARD:
1473                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1474                         if(requires_resume_key) {
1475                                 SIVAL(p,0,reskey);
1476                                 p += 4;
1477                         }
1478                         srv_put_dos_date2(p,0,create_date);
1479                         srv_put_dos_date2(p,4,adate);
1480                         srv_put_dos_date2(p,8,mdate);
1481                         SIVAL(p,12,(uint32)file_size);
1482                         SIVAL(p,16,(uint32)allocation_size);
1483                         SSVAL(p,20,mode);
1484                         p += 23;
1485                         nameptr = p;
1486                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1487                                 p += ucs2_align(base_data, p, 0);
1488                         }
1489                         len = srvstr_push(base_data, flags2, p,
1490                                           fname, PTR_DIFF(end_data, p),
1491                                           STR_TERMINATE);
1492                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1493                                 if (len > 2) {
1494                                         SCVAL(nameptr, -1, len - 2);
1495                                 } else {
1496                                         SCVAL(nameptr, -1, 0);
1497                                 }
1498                         } else {
1499                                 if (len > 1) {
1500                                         SCVAL(nameptr, -1, len - 1);
1501                                 } else {
1502                                         SCVAL(nameptr, -1, 0);
1503                                 }
1504                         }
1505                         p += len;
1506                         break;
1507
1508                 case SMB_FIND_EA_SIZE:
1509                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1510                         if(requires_resume_key) {
1511                                 SIVAL(p,0,reskey);
1512                                 p += 4;
1513                         }
1514                         srv_put_dos_date2(p,0,create_date);
1515                         srv_put_dos_date2(p,4,adate);
1516                         srv_put_dos_date2(p,8,mdate);
1517                         SIVAL(p,12,(uint32)file_size);
1518                         SIVAL(p,16,(uint32)allocation_size);
1519                         SSVAL(p,20,mode);
1520                         {
1521                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1522                                 SIVAL(p,22,ea_size); /* Extended attributes */
1523                         }
1524                         p += 27;
1525                         nameptr = p - 1;
1526                         len = srvstr_push(base_data, flags2,
1527                                           p, fname, PTR_DIFF(end_data, p),
1528                                           STR_TERMINATE | STR_NOALIGN);
1529                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1530                                 if (len > 2) {
1531                                         len -= 2;
1532                                 } else {
1533                                         len = 0;
1534                                 }
1535                         } else {
1536                                 if (len > 1) {
1537                                         len -= 1;
1538                                 } else {
1539                                         len = 0;
1540                                 }
1541                         }
1542                         SCVAL(nameptr,0,len);
1543                         p += len;
1544                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1545                         break;
1546
1547                 case SMB_FIND_EA_LIST:
1548                 {
1549                         struct ea_list *file_list = NULL;
1550                         size_t ea_len = 0;
1551
1552                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1553                         if (!name_list) {
1554                                 return False;
1555                         }
1556                         if(requires_resume_key) {
1557                                 SIVAL(p,0,reskey);
1558                                 p += 4;
1559                         }
1560                         srv_put_dos_date2(p,0,create_date);
1561                         srv_put_dos_date2(p,4,adate);
1562                         srv_put_dos_date2(p,8,mdate);
1563                         SIVAL(p,12,(uint32)file_size);
1564                         SIVAL(p,16,(uint32)allocation_size);
1565                         SSVAL(p,20,mode);
1566                         p += 22; /* p now points to the EA area. */
1567
1568                         file_list = get_ea_list_from_file(ctx, conn, NULL, pathreal, &ea_len);
1569                         name_list = ea_list_union(name_list, file_list, &ea_len);
1570
1571                         /* We need to determine if this entry will fit in the space available. */
1572                         /* Max string size is 255 bytes. */
1573                         if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1574                                 /* Move the dirptr back to prev_dirpos */
1575                                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1576                                 *out_of_space = True;
1577                                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1578                                 return False; /* Not finished - just out of space */
1579                         }
1580
1581                         /* Push the ea_data followed by the name. */
1582                         p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1583                         nameptr = p;
1584                         len = srvstr_push(base_data, flags2,
1585                                           p + 1, fname, PTR_DIFF(end_data, p+1),
1586                                           STR_TERMINATE | STR_NOALIGN);
1587                         if (flags2 & FLAGS2_UNICODE_STRINGS) {
1588                                 if (len > 2) {
1589                                         len -= 2;
1590                                 } else {
1591                                         len = 0;
1592                                 }
1593                         } else {
1594                                 if (len > 1) {
1595                                         len -= 1;
1596                                 } else {
1597                                         len = 0;
1598                                 }
1599                         }
1600                         SCVAL(nameptr,0,len);
1601                         p += len + 1;
1602                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1603                         break;
1604                 }
1605
1606                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1607                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1608                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1609                         p += 4;
1610                         SIVAL(p,0,reskey); p += 4;
1611                         put_long_date_timespec(p,create_date_ts); p += 8;
1612                         put_long_date_timespec(p,adate_ts); p += 8;
1613                         put_long_date_timespec(p,mdate_ts); p += 8;
1614                         put_long_date_timespec(p,mdate_ts); p += 8;
1615                         SOFF_T(p,0,file_size); p += 8;
1616                         SOFF_T(p,0,allocation_size); p += 8;
1617                         SIVAL(p,0,nt_extmode); p += 4;
1618                         q = p; p += 4; /* q is placeholder for name length. */
1619                         {
1620                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1621                                 SIVAL(p,0,ea_size); /* Extended attributes */
1622                                 p += 4;
1623                         }
1624                         /* Clear the short name buffer. This is
1625                          * IMPORTANT as not doing so will trigger
1626                          * a Win2k client bug. JRA.
1627                          */
1628                         if (!was_8_3 && check_mangled_names) {
1629                                 if (!name_to_8_3(fname,mangled_name,True,
1630                                                    conn->params)) {
1631                                         /* Error - mangle failed ! */
1632                                         memset(mangled_name,'\0',12);
1633                                 }
1634                                 mangled_name[12] = 0;
1635                                 len = srvstr_push(base_data, flags2,
1636                                                   p+2, mangled_name, 24,
1637                                                   STR_UPPER|STR_UNICODE);
1638                                 if (len < 24) {
1639                                         memset(p + 2 + len,'\0',24 - len);
1640                                 }
1641                                 SSVAL(p, 0, len);
1642                         } else {
1643                                 memset(p,'\0',26);
1644                         }
1645                         p += 2 + 24;
1646                         len = srvstr_push(base_data, flags2, p,
1647                                           fname, PTR_DIFF(end_data, p),
1648                                           STR_TERMINATE_ASCII);
1649                         SIVAL(q,0,len);
1650                         p += len;
1651                         SIVAL(p,0,0); /* Ensure any padding is null. */
1652                         len = PTR_DIFF(p, pdata);
1653                         len = (len + 3) & ~3;
1654                         SIVAL(pdata,0,len);
1655                         p = pdata + len;
1656                         break;
1657
1658                 case SMB_FIND_FILE_DIRECTORY_INFO:
1659                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1660                         p += 4;
1661                         SIVAL(p,0,reskey); p += 4;
1662                         put_long_date_timespec(p,create_date_ts); p += 8;
1663                         put_long_date_timespec(p,adate_ts); p += 8;
1664                         put_long_date_timespec(p,mdate_ts); p += 8;
1665                         put_long_date_timespec(p,mdate_ts); p += 8;
1666                         SOFF_T(p,0,file_size); p += 8;
1667                         SOFF_T(p,0,allocation_size); p += 8;
1668                         SIVAL(p,0,nt_extmode); p += 4;
1669                         len = srvstr_push(base_data, flags2,
1670                                           p + 4, fname, PTR_DIFF(end_data, p+4),
1671                                           STR_TERMINATE_ASCII);
1672                         SIVAL(p,0,len);
1673                         p += 4 + len;
1674                         SIVAL(p,0,0); /* Ensure any padding is null. */
1675                         len = PTR_DIFF(p, pdata);
1676                         len = (len + 3) & ~3;
1677                         SIVAL(pdata,0,len);
1678                         p = pdata + len;
1679                         break;
1680
1681                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1682                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1683                         p += 4;
1684                         SIVAL(p,0,reskey); p += 4;
1685                         put_long_date_timespec(p,create_date_ts); p += 8;
1686                         put_long_date_timespec(p,adate_ts); p += 8;
1687                         put_long_date_timespec(p,mdate_ts); p += 8;
1688                         put_long_date_timespec(p,mdate_ts); p += 8;
1689                         SOFF_T(p,0,file_size); p += 8;
1690                         SOFF_T(p,0,allocation_size); p += 8;
1691                         SIVAL(p,0,nt_extmode); p += 4;
1692                         q = p; p += 4; /* q is placeholder for name length. */
1693                         {
1694                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1695                                 SIVAL(p,0,ea_size); /* Extended attributes */
1696                                 p +=4;
1697                         }
1698                         len = srvstr_push(base_data, flags2, p,
1699                                           fname, PTR_DIFF(end_data, p),
1700                                           STR_TERMINATE_ASCII);
1701                         SIVAL(q, 0, len);
1702                         p += len;
1703
1704                         SIVAL(p,0,0); /* Ensure any padding is null. */
1705                         len = PTR_DIFF(p, pdata);
1706                         len = (len + 3) & ~3;
1707                         SIVAL(pdata,0,len);
1708                         p = pdata + len;
1709                         break;
1710
1711                 case SMB_FIND_FILE_NAMES_INFO:
1712                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1713                         p += 4;
1714                         SIVAL(p,0,reskey); p += 4;
1715                         p += 4;
1716                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
1717                            acl on a dir (tridge) */
1718                         len = srvstr_push(base_data, flags2, p,
1719                                           fname, PTR_DIFF(end_data, p),
1720                                           STR_TERMINATE_ASCII);
1721                         SIVAL(p, -4, len);
1722                         p += len;
1723                         SIVAL(p,0,0); /* Ensure any padding is null. */
1724                         len = PTR_DIFF(p, pdata);
1725                         len = (len + 3) & ~3;
1726                         SIVAL(pdata,0,len);
1727                         p = pdata + len;
1728                         break;
1729
1730                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1731                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1732                         p += 4;
1733                         SIVAL(p,0,reskey); p += 4;
1734                         put_long_date_timespec(p,create_date_ts); p += 8;
1735                         put_long_date_timespec(p,adate_ts); p += 8;
1736                         put_long_date_timespec(p,mdate_ts); p += 8;
1737                         put_long_date_timespec(p,mdate_ts); p += 8;
1738                         SOFF_T(p,0,file_size); p += 8;
1739                         SOFF_T(p,0,allocation_size); p += 8;
1740                         SIVAL(p,0,nt_extmode); p += 4;
1741                         q = p; p += 4; /* q is placeholder for name length. */
1742                         {
1743                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1744                                 SIVAL(p,0,ea_size); /* Extended attributes */
1745                                 p +=4;
1746                         }
1747                         SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1748                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1749                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1750                         len = srvstr_push(base_data, flags2, p,
1751                                           fname, PTR_DIFF(end_data, p),
1752                                           STR_TERMINATE_ASCII);
1753                         SIVAL(q, 0, len);
1754                         p += len; 
1755                         SIVAL(p,0,0); /* Ensure any padding is null. */
1756                         len = PTR_DIFF(p, pdata);
1757                         len = (len + 3) & ~3;
1758                         SIVAL(pdata,0,len);
1759                         p = pdata + len;
1760                         break;
1761
1762                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1763                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1764                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1765                         p += 4;
1766                         SIVAL(p,0,reskey); p += 4;
1767                         put_long_date_timespec(p,create_date_ts); p += 8;
1768                         put_long_date_timespec(p,adate_ts); p += 8;
1769                         put_long_date_timespec(p,mdate_ts); p += 8;
1770                         put_long_date_timespec(p,mdate_ts); p += 8;
1771                         SOFF_T(p,0,file_size); p += 8;
1772                         SOFF_T(p,0,allocation_size); p += 8;
1773                         SIVAL(p,0,nt_extmode); p += 4;
1774                         q = p; p += 4; /* q is placeholder for name length */
1775                         {
1776                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1777                                 SIVAL(p,0,ea_size); /* Extended attributes */
1778                                 p +=4;
1779                         }
1780                         /* Clear the short name buffer. This is
1781                          * IMPORTANT as not doing so will trigger
1782                          * a Win2k client bug. JRA.
1783                          */
1784                         if (!was_8_3 && check_mangled_names) {
1785                                 if (!name_to_8_3(fname,mangled_name,True,
1786                                                 conn->params)) {
1787                                         /* Error - mangle failed ! */
1788                                         memset(mangled_name,'\0',12);
1789                                 }
1790                                 mangled_name[12] = 0;
1791                                 len = srvstr_push(base_data, flags2,
1792                                                   p+2, mangled_name, 24,
1793                                                   STR_UPPER|STR_UNICODE);
1794                                 SSVAL(p, 0, len);
1795                                 if (len < 24) {
1796                                         memset(p + 2 + len,'\0',24 - len);
1797                                 }
1798                                 SSVAL(p, 0, len);
1799                         } else {
1800                                 memset(p,'\0',26);
1801                         }
1802                         p += 26;
1803                         SSVAL(p,0,0); p += 2; /* Reserved ? */
1804                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1805                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1806                         len = srvstr_push(base_data, flags2, p,
1807                                           fname, PTR_DIFF(end_data, p),
1808                                           STR_TERMINATE_ASCII);
1809                         SIVAL(q,0,len);
1810                         p += len;
1811                         SIVAL(p,0,0); /* Ensure any padding is null. */
1812                         len = PTR_DIFF(p, pdata);
1813                         len = (len + 3) & ~3;
1814                         SIVAL(pdata,0,len);
1815                         p = pdata + len;
1816                         break;
1817
1818                 /* CIFS UNIX Extension. */
1819
1820                 case SMB_FIND_FILE_UNIX:
1821                 case SMB_FIND_FILE_UNIX_INFO2:
1822                         p+= 4;
1823                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1824
1825                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1826
1827                         if (info_level == SMB_FIND_FILE_UNIX) {
1828                                 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1829                                 p = store_file_unix_basic(conn, p,
1830                                                         NULL, &sbuf);
1831                                 len = srvstr_push(base_data, flags2, p,
1832                                                   fname, PTR_DIFF(end_data, p),
1833                                                   STR_TERMINATE);
1834                         } else {
1835                                 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1836                                 p = store_file_unix_basic_info2(conn, p,
1837                                                         NULL, &sbuf);
1838                                 nameptr = p;
1839                                 p += 4;
1840                                 len = srvstr_push(base_data, flags2, p, fname,
1841                                                   PTR_DIFF(end_data, p), 0);
1842                                 SIVAL(nameptr, 0, len);
1843                         }
1844
1845                         p += len;
1846                         SIVAL(p,0,0); /* Ensure any padding is null. */
1847
1848                         len = PTR_DIFF(p, pdata);
1849                         len = (len + 3) & ~3;
1850                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
1851                         p = pdata + len;
1852                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
1853
1854                         break;
1855
1856                 default:
1857                         return(False);
1858         }
1859
1860
1861         if (PTR_DIFF(p,pdata) > space_remaining) {
1862                 /* Move the dirptr back to prev_dirpos */
1863                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1864                 *out_of_space = True;
1865                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1866                 return False; /* Not finished - just out of space */
1867         }
1868
1869         /* Setup the last entry pointer, as an offset from base_data */
1870         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1871         /* Advance the data pointer to the next slot */
1872         *ppdata = p;
1873
1874         return(found);
1875 }
1876
1877 /****************************************************************************
1878  Reply to a TRANS2_FINDFIRST.
1879 ****************************************************************************/
1880
1881 static void call_trans2findfirst(connection_struct *conn,
1882                                  struct smb_request *req,
1883                                  char **pparams, int total_params,
1884                                  char **ppdata, int total_data,
1885                                  unsigned int max_data_bytes)
1886 {
1887         /* We must be careful here that we don't return more than the
1888                 allowed number of data bytes. If this means returning fewer than
1889                 maxentries then so be it. We assume that the redirector has
1890                 enough room for the fixed number of parameter bytes it has
1891                 requested. */
1892         char *params = *pparams;
1893         char *pdata = *ppdata;
1894         char *data_end;
1895         uint32 dirtype;
1896         int maxentries;
1897         uint16 findfirst_flags;
1898         bool close_after_first;
1899         bool close_if_end;
1900         bool requires_resume_key;
1901         int info_level;
1902         char *directory = NULL;
1903         char *mask = NULL;
1904         char *p;
1905         int last_entry_off=0;
1906         int dptr_num = -1;
1907         int numentries = 0;
1908         int i;
1909         bool finished = False;
1910         bool dont_descend = False;
1911         bool out_of_space = False;
1912         int space_remaining;
1913         bool mask_contains_wcard = False;
1914         SMB_STRUCT_STAT sbuf;
1915         struct ea_list *ea_list = NULL;
1916         NTSTATUS ntstatus = NT_STATUS_OK;
1917         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
1918         TALLOC_CTX *ctx = talloc_tos();
1919
1920         if (total_params < 13) {
1921                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1922                 return;
1923         }
1924
1925         dirtype = SVAL(params,0);
1926         maxentries = SVAL(params,2);
1927         findfirst_flags = SVAL(params,4);
1928         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1929         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1930         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1931         info_level = SVAL(params,6);
1932
1933         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1934 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1935                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1936                 info_level, max_data_bytes));
1937
1938         if (!maxentries) {
1939                 /* W2K3 seems to treat zero as 1. */
1940                 maxentries = 1;
1941         }
1942  
1943         switch (info_level) {
1944                 case SMB_FIND_INFO_STANDARD:
1945                 case SMB_FIND_EA_SIZE:
1946                 case SMB_FIND_EA_LIST:
1947                 case SMB_FIND_FILE_DIRECTORY_INFO:
1948                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1949                 case SMB_FIND_FILE_NAMES_INFO:
1950                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1951                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1952                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1953                         break;
1954                 case SMB_FIND_FILE_UNIX:
1955                 case SMB_FIND_FILE_UNIX_INFO2:
1956                         /* Always use filesystem for UNIX mtime query. */
1957                         ask_sharemode = false;
1958                         if (!lp_unix_extensions()) {
1959                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
1960                                 return;
1961                         }
1962                         break;
1963                 default:
1964                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
1965                         return;
1966         }
1967
1968         srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
1969                               params+12, total_params - 12,
1970                               STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1971         if (!NT_STATUS_IS_OK(ntstatus)) {
1972                 reply_nterror(req, ntstatus);
1973                 return;
1974         }
1975
1976         ntstatus = resolve_dfspath_wcard(ctx, conn,
1977                         req->flags2 & FLAGS2_DFS_PATHNAMES,
1978                         directory,
1979                         &directory,
1980                         &mask_contains_wcard);
1981         if (!NT_STATUS_IS_OK(ntstatus)) {
1982                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
1983                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
1984                                         ERRSRV, ERRbadpath);
1985                         return;
1986                 }
1987                 reply_nterror(req, ntstatus);
1988                 return;
1989         }
1990
1991         ntstatus = unix_convert(ctx, conn, directory, True, &directory, &mask, &sbuf);
1992         if (!NT_STATUS_IS_OK(ntstatus)) {
1993                 reply_nterror(req, ntstatus);
1994                 return;
1995         }
1996
1997         ntstatus = check_name(conn, directory);
1998         if (!NT_STATUS_IS_OK(ntstatus)) {
1999                 reply_nterror(req, ntstatus);
2000                 return;
2001         }
2002
2003         p = strrchr_m(directory,'/');
2004         if(p == NULL) {
2005                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2006                 if((directory[0] == '.') && (directory[1] == '\0')) {
2007                         mask = talloc_strdup(ctx,"*");
2008                         if (!mask) {
2009                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2010                                 return;
2011                         }
2012                         mask_contains_wcard = True;
2013                 }
2014                 directory = talloc_strdup(talloc_tos(), "./");
2015                 if (!directory) {
2016                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2017                         return;
2018                 }
2019         } else {
2020                 *p = 0;
2021         }
2022
2023         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2024
2025         if (info_level == SMB_FIND_EA_LIST) {
2026                 uint32 ea_size;
2027
2028                 if (total_data < 4) {
2029                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2030                         return;
2031                 }
2032
2033                 ea_size = IVAL(pdata,0);
2034                 if (ea_size != total_data) {
2035                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2036 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2037                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2038                         return;
2039                 }
2040
2041                 if (!lp_ea_support(SNUM(conn))) {
2042                         reply_doserror(req, ERRDOS, ERReasnotsupported);
2043                         return;
2044                 }
2045
2046                 /* Pull out the list of names. */
2047                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2048                 if (!ea_list) {
2049                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2050                         return;
2051                 }
2052         }
2053
2054         *ppdata = (char *)SMB_REALLOC(
2055                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2056         if(*ppdata == NULL ) {
2057                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2058                 return;
2059         }
2060         pdata = *ppdata;
2061         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2062
2063         /* Realloc the params space */
2064         *pparams = (char *)SMB_REALLOC(*pparams, 10);
2065         if (*pparams == NULL) {
2066                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2067                 return;
2068         }
2069         params = *pparams;
2070
2071         /* Save the wildcard match and attribs we are using on this directory - 
2072                 needed as lanman2 assumes these are being saved between calls */
2073
2074         ntstatus = dptr_create(conn,
2075                                 directory,
2076                                 False,
2077                                 True,
2078                                 req->smbpid,
2079                                 mask,
2080                                 mask_contains_wcard,
2081                                 dirtype,
2082                                 &conn->dirptr);
2083
2084         if (!NT_STATUS_IS_OK(ntstatus)) {
2085                 reply_nterror(req, ntstatus);
2086                 return;
2087         }
2088
2089         dptr_num = dptr_dnum(conn->dirptr);
2090         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2091
2092         /* We don't need to check for VOL here as this is returned by
2093                 a different TRANS2 call. */
2094
2095         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
2096         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2097                 dont_descend = True;
2098
2099         p = pdata;
2100         space_remaining = max_data_bytes;
2101         out_of_space = False;
2102
2103         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2104                 bool got_exact_match = False;
2105
2106                 /* this is a heuristic to avoid seeking the dirptr except when 
2107                         absolutely necessary. It allows for a filename of about 40 chars */
2108                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2109                         out_of_space = True;
2110                         finished = False;
2111                 } else {
2112                         finished = !get_lanman2_dir_entry(ctx,
2113                                         conn,
2114                                         req->flags2,
2115                                         mask,dirtype,info_level,
2116                                         requires_resume_key,dont_descend,
2117                                         ask_sharemode,
2118                                         &p,pdata,data_end,
2119                                         space_remaining, &out_of_space,
2120                                         &got_exact_match,
2121                                         &last_entry_off, ea_list);
2122                 }
2123
2124                 if (finished && out_of_space)
2125                         finished = False;
2126
2127                 if (!finished && !out_of_space)
2128                         numentries++;
2129
2130                 /*
2131                  * As an optimisation if we know we aren't looking
2132                  * for a wildcard name (ie. the name matches the wildcard exactly)
2133                  * then we can finish on any (first) match.
2134                  * This speeds up large directory searches. JRA.
2135                  */
2136
2137                 if(got_exact_match)
2138                         finished = True;
2139
2140                 /* Ensure space_remaining never goes -ve. */
2141                 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2142                         space_remaining = 0;
2143                         out_of_space = true;
2144                 } else {
2145                         space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2146                 }
2147         }
2148
2149         /* Check if we can close the dirptr */
2150         if(close_after_first || (finished && close_if_end)) {
2151                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2152                 dptr_close(&dptr_num);
2153         }
2154
2155         /*
2156          * If there are no matching entries we must return ERRDOS/ERRbadfile -
2157          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2158          * the protocol level is less than NT1. Tested with smbclient. JRA.
2159          * This should fix the OS/2 client bug #2335.
2160          */
2161
2162         if(numentries == 0) {
2163                 dptr_close(&dptr_num);
2164                 if (Protocol < PROTOCOL_NT1) {
2165                         reply_doserror(req, ERRDOS, ERRnofiles);
2166                         return;
2167                 } else {
2168                         reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2169                                         ERRDOS, ERRbadfile);
2170                         return;
2171                 }
2172         }
2173
2174         /* At this point pdata points to numentries directory entries. */
2175
2176         /* Set up the return parameter block */
2177         SSVAL(params,0,dptr_num);
2178         SSVAL(params,2,numentries);
2179         SSVAL(params,4,finished);
2180         SSVAL(params,6,0); /* Never an EA error */
2181         SSVAL(params,8,last_entry_off);
2182
2183         send_trans2_replies(conn, req, params, 10, pdata, PTR_DIFF(p,pdata),
2184                             max_data_bytes);
2185
2186         if ((! *directory) && dptr_path(dptr_num)) {
2187                 directory = talloc_strdup(talloc_tos(),dptr_path(dptr_num));
2188                 if (!directory) {
2189                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2190                 }
2191         }
2192
2193         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2194                 smb_fn_name(req->cmd),
2195                 mask, directory, dirtype, numentries ) );
2196
2197         /*
2198          * Force a name mangle here to ensure that the
2199          * mask as an 8.3 name is top of the mangled cache.
2200          * The reasons for this are subtle. Don't remove
2201          * this code unless you know what you are doing
2202          * (see PR#13758). JRA.
2203          */
2204
2205         if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2206                 char mangled_name[13];
2207                 name_to_8_3(mask, mangled_name, True, conn->params);
2208         }
2209
2210         return;
2211 }
2212
2213 /****************************************************************************
2214  Reply to a TRANS2_FINDNEXT.
2215 ****************************************************************************/
2216
2217 static void call_trans2findnext(connection_struct *conn,
2218                                 struct smb_request *req,
2219                                 char **pparams, int total_params,
2220                                 char **ppdata, int total_data,
2221                                 unsigned int max_data_bytes)
2222 {
2223         /* We must be careful here that we don't return more than the
2224                 allowed number of data bytes. If this means returning fewer than
2225                 maxentries then so be it. We assume that the redirector has
2226                 enough room for the fixed number of parameter bytes it has
2227                 requested. */
2228         char *params = *pparams;
2229         char *pdata = *ppdata;
2230         char *data_end;
2231         int dptr_num;
2232         int maxentries;
2233         uint16 info_level;
2234         uint32 resume_key;
2235         uint16 findnext_flags;
2236         bool close_after_request;
2237         bool close_if_end;
2238         bool requires_resume_key;
2239         bool continue_bit;
2240         bool mask_contains_wcard = False;
2241         char *resume_name = NULL;
2242         const char *mask = NULL;
2243         const char *directory = NULL;
2244         char *p = NULL;
2245         uint16 dirtype;
2246         int numentries = 0;
2247         int i, last_entry_off=0;
2248         bool finished = False;
2249         bool dont_descend = False;
2250         bool out_of_space = False;
2251         int space_remaining;
2252         struct ea_list *ea_list = NULL;
2253         NTSTATUS ntstatus = NT_STATUS_OK;
2254         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2255         TALLOC_CTX *ctx = talloc_tos();
2256
2257         if (total_params < 13) {
2258                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2259                 return;
2260         }
2261
2262         dptr_num = SVAL(params,0);
2263         maxentries = SVAL(params,2);
2264         info_level = SVAL(params,4);
2265         resume_key = IVAL(params,6);
2266         findnext_flags = SVAL(params,10);
2267         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2268         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2269         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2270         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2271
2272         srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2273                               params+12,
2274                               total_params - 12, STR_TERMINATE, &ntstatus,
2275                               &mask_contains_wcard);
2276         if (!NT_STATUS_IS_OK(ntstatus)) {
2277                 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2278                    complain (it thinks we're asking for the directory above the shared
2279                    path or an invalid name). Catch this as the resume name is only compared, never used in
2280                    a file access. JRA. */
2281                 srvstr_pull_talloc(ctx, params, req->flags2,
2282                                 &resume_name, params+12,
2283                                 total_params - 12,
2284                                 STR_TERMINATE);
2285
2286                 if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2287                         reply_nterror(req, ntstatus);
2288                         return;
2289                 }
2290         }
2291
2292         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2293 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2294 resume_key = %d resume name = %s continue=%d level = %d\n",
2295                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end, 
2296                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2297
2298         if (!maxentries) {
2299                 /* W2K3 seems to treat zero as 1. */
2300                 maxentries = 1;
2301         }
2302
2303         switch (info_level) {
2304                 case SMB_FIND_INFO_STANDARD:
2305                 case SMB_FIND_EA_SIZE:
2306                 case SMB_FIND_EA_LIST:
2307                 case SMB_FIND_FILE_DIRECTORY_INFO:
2308                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2309                 case SMB_FIND_FILE_NAMES_INFO:
2310                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2311                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2312                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2313                         break;
2314                 case SMB_FIND_FILE_UNIX:
2315                 case SMB_FIND_FILE_UNIX_INFO2:
2316                         /* Always use filesystem for UNIX mtime query. */
2317                         ask_sharemode = false;
2318                         if (!lp_unix_extensions()) {
2319                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2320                                 return;
2321                         }
2322                         break;
2323                 default:
2324                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2325                         return;
2326         }
2327
2328         if (info_level == SMB_FIND_EA_LIST) {
2329                 uint32 ea_size;
2330
2331                 if (total_data < 4) {
2332                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2333                         return;
2334                 }
2335
2336                 ea_size = IVAL(pdata,0);
2337                 if (ea_size != total_data) {
2338                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2339 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2340                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2341                         return;
2342                 }
2343
2344                 if (!lp_ea_support(SNUM(conn))) {
2345                         reply_doserror(req, ERRDOS, ERReasnotsupported);
2346                         return;
2347                 }
2348
2349                 /* Pull out the list of names. */
2350                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2351                 if (!ea_list) {
2352                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2353                         return;
2354                 }
2355         }
2356
2357         *ppdata = (char *)SMB_REALLOC(
2358                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2359         if(*ppdata == NULL) {
2360                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2361                 return;
2362         }
2363
2364         pdata = *ppdata;
2365         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2366
2367         /* Realloc the params space */
2368         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2369         if(*pparams == NULL ) {
2370                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2371                 return;
2372         }
2373
2374         params = *pparams;
2375
2376         /* Check that the dptr is valid */
2377         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2378                 reply_doserror(req, ERRDOS, ERRnofiles);
2379                 return;
2380         }
2381
2382         string_set(&conn->dirpath,dptr_path(dptr_num));
2383
2384         /* Get the wildcard mask from the dptr */
2385         if((p = dptr_wcard(dptr_num))== NULL) {
2386                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2387                 reply_doserror(req, ERRDOS, ERRnofiles);
2388                 return;
2389         }
2390
2391         mask = p;
2392         directory = conn->dirpath;
2393
2394         /* Get the attr mask from the dptr */
2395         dirtype = dptr_attr(dptr_num);
2396
2397         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2398                 dptr_num, mask, dirtype,
2399                 (long)conn->dirptr,
2400                 dptr_TellDir(conn->dirptr)));
2401
2402         /* We don't need to check for VOL here as this is returned by
2403                 a different TRANS2 call. */
2404
2405         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2406         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2407                 dont_descend = True;
2408
2409         p = pdata;
2410         space_remaining = max_data_bytes;
2411         out_of_space = False;
2412
2413         /*
2414          * Seek to the correct position. We no longer use the resume key but
2415          * depend on the last file name instead.
2416          */
2417
2418         if(*resume_name && !continue_bit) {
2419                 SMB_STRUCT_STAT st;
2420
2421                 long current_pos = 0;
2422                 /*
2423                  * Remember, name_to_8_3 is called by
2424                  * get_lanman2_dir_entry(), so the resume name
2425                  * could be mangled. Ensure we check the unmangled name.
2426                  */
2427
2428                 if (mangle_is_mangled(resume_name, conn->params)) {
2429                         char *new_resume_name = NULL;
2430                         mangle_lookup_name_from_8_3(ctx,
2431                                                 resume_name,
2432                                                 &new_resume_name,
2433                                                 conn->params);
2434                         if (new_resume_name) {
2435                                 resume_name = new_resume_name;
2436                         }
2437                 }
2438
2439                 /*
2440                  * Fix for NT redirector problem triggered by resume key indexes
2441                  * changing between directory scans. We now return a resume key of 0
2442                  * and instead look for the filename to continue from (also given
2443                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2444                  * findfirst/findnext (as is usual) then the directory pointer
2445                  * should already be at the correct place.
2446                  */
2447
2448                 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2449         } /* end if resume_name && !continue_bit */
2450
2451         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2452                 bool got_exact_match = False;
2453
2454                 /* this is a heuristic to avoid seeking the dirptr except when 
2455                         absolutely necessary. It allows for a filename of about 40 chars */
2456                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2457                         out_of_space = True;
2458                         finished = False;
2459                 } else {
2460                         finished = !get_lanman2_dir_entry(ctx,
2461                                                 conn,
2462                                                 req->flags2,
2463                                                 mask,dirtype,info_level,
2464                                                 requires_resume_key,dont_descend,
2465                                                 ask_sharemode,
2466                                                 &p,pdata,data_end,
2467                                                 space_remaining, &out_of_space,
2468                                                 &got_exact_match,
2469                                                 &last_entry_off, ea_list);
2470                 }
2471
2472                 if (finished && out_of_space)
2473                         finished = False;
2474
2475                 if (!finished && !out_of_space)
2476                         numentries++;
2477
2478                 /*
2479                  * As an optimisation if we know we aren't looking
2480                  * for a wildcard name (ie. the name matches the wildcard exactly)
2481                  * then we can finish on any (first) match.
2482                  * This speeds up large directory searches. JRA.
2483                  */
2484
2485                 if(got_exact_match)
2486                         finished = True;
2487
2488                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2489         }
2490
2491         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2492                 smb_fn_name(req->cmd),
2493                 mask, directory, dirtype, numentries ) );
2494
2495         /* Check if we can close the dirptr */
2496         if(close_after_request || (finished && close_if_end)) {
2497                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2498                 dptr_close(&dptr_num); /* This frees up the saved mask */
2499         }
2500
2501         /* Set up the return parameter block */
2502         SSVAL(params,0,numentries);
2503         SSVAL(params,2,finished);
2504         SSVAL(params,4,0); /* Never an EA error */
2505         SSVAL(params,6,last_entry_off);
2506
2507         send_trans2_replies(conn, req, params, 8, pdata, PTR_DIFF(p,pdata),
2508                             max_data_bytes);
2509
2510         return;
2511 }
2512
2513 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2514 {
2515         E_md4hash(lp_servicename(SNUM(conn)),objid);
2516         return objid;
2517 }
2518
2519 static void samba_extended_info_version(struct smb_extended_info *extended_info)
2520 {
2521         SMB_ASSERT(extended_info != NULL);
2522
2523         extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
2524         extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
2525                                        | ((SAMBA_VERSION_MINOR & 0xff) << 16)
2526                                        | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
2527 #ifdef SAMBA_VERSION_REVISION
2528         extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
2529 #endif
2530         extended_info->samba_subversion = 0;
2531 #ifdef SAMBA_VERSION_RC_RELEASE
2532         extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
2533 #else
2534 #ifdef SAMBA_VERSION_PRE_RELEASE
2535         extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
2536 #endif
2537 #endif
2538 #ifdef SAMBA_VERSION_VENDOR_PATCH
2539         extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
2540 #endif
2541         extended_info->samba_gitcommitdate = 0;
2542 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2543         unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_GIT_COMMIT_TIME);
2544 #endif
2545
2546         memset(extended_info->samba_version_string, 0,
2547                sizeof(extended_info->samba_version_string));
2548
2549         snprintf (extended_info->samba_version_string,
2550                   sizeof(extended_info->samba_version_string),
2551                   "%s", samba_version_string());
2552 }
2553
2554 /****************************************************************************
2555  Reply to a TRANS2_QFSINFO (query filesystem info).
2556 ****************************************************************************/
2557
2558 static void call_trans2qfsinfo(connection_struct *conn,
2559                                struct smb_request *req,
2560                                char **pparams, int total_params,
2561                                char **ppdata, int total_data,
2562                                unsigned int max_data_bytes)
2563 {
2564         char *pdata, *end_data;
2565         char *params = *pparams;
2566         uint16 info_level;
2567         int data_len, len;
2568         SMB_STRUCT_STAT st;
2569         const char *vname = volume_label(SNUM(conn));
2570         int snum = SNUM(conn);
2571         char *fstype = lp_fstype(SNUM(conn));
2572         uint32 additional_flags = 0;
2573         
2574         if (total_params < 2) {
2575                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2576                 return;
2577         }
2578
2579         info_level = SVAL(params,0);
2580
2581         if (IS_IPC(conn)) {
2582                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2583                         DEBUG(0,("call_trans2qfsinfo: not an allowed "
2584                                 "info level (0x%x) on IPC$.\n",
2585                                 (unsigned int)info_level));
2586                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
2587                         return;
2588                 }
2589         }
2590
2591         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
2592                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2593                         DEBUG(0,("call_trans2qfsinfo: encryption required "
2594                                 "and info level 0x%x sent.\n",
2595                                 (unsigned int)info_level));
2596                         exit_server_cleanly("encryption required "
2597                                 "on connection");
2598                         return;
2599                 }
2600         }
2601
2602         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2603
2604         if(SMB_VFS_STAT(conn,".",&st)!=0) {
2605                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2606                 reply_doserror(req, ERRSRV, ERRinvdevice);
2607                 return;
2608         }
2609
2610         *ppdata = (char *)SMB_REALLOC(
2611                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2612         if (*ppdata == NULL ) {
2613                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2614                 return;
2615         }
2616
2617         pdata = *ppdata;
2618         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2619         end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2620
2621         switch (info_level) {
2622                 case SMB_INFO_ALLOCATION:
2623                 {
2624                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2625                         data_len = 18;
2626                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2627                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2628                                 return;
2629                         }
2630
2631                         block_size = lp_block_size(snum);
2632                         if (bsize < block_size) {
2633                                 uint64_t factor = block_size/bsize;
2634                                 bsize = block_size;
2635                                 dsize /= factor;
2636                                 dfree /= factor;
2637                         }
2638                         if (bsize > block_size) {
2639                                 uint64_t factor = bsize/block_size;
2640                                 bsize = block_size;
2641                                 dsize *= factor;
2642                                 dfree *= factor;
2643                         }
2644                         bytes_per_sector = 512;
2645                         sectors_per_unit = bsize/bytes_per_sector;
2646
2647                         DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2648 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2649                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2650
2651                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
2652                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2653                         SIVAL(pdata,l1_cUnit,dsize);
2654                         SIVAL(pdata,l1_cUnitAvail,dfree);
2655                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
2656                         break;
2657                 }
2658
2659                 case SMB_INFO_VOLUME:
2660                         /* Return volume name */
2661                         /* 
2662                          * Add volume serial number - hash of a combination of
2663                          * the called hostname and the service name.
2664                          */
2665                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2666                         /*
2667                          * Win2k3 and previous mess this up by sending a name length
2668                          * one byte short. I believe only older clients (OS/2 Win9x) use
2669                          * this call so try fixing this by adding a terminating null to
2670                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2671                          */
2672                         len = srvstr_push(
2673                                 pdata, req->flags2,
2674                                 pdata+l2_vol_szVolLabel, vname,
2675                                 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
2676                                 STR_NOALIGN|STR_TERMINATE);
2677                         SCVAL(pdata,l2_vol_cch,len);
2678                         data_len = l2_vol_szVolLabel + len;
2679                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2680                                 (unsigned)st.st_ctime, len, vname));
2681                         break;
2682
2683                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2684                 case SMB_FS_ATTRIBUTE_INFORMATION:
2685
2686                         additional_flags = 0;
2687 #if defined(HAVE_SYS_QUOTAS)
2688                         additional_flags |= FILE_VOLUME_QUOTAS;
2689 #endif
2690
2691                         if(lp_nt_acl_support(SNUM(conn))) {
2692                                 additional_flags |= FILE_PERSISTENT_ACLS;
2693                         }
2694
2695                         /* Capabilities are filled in at connection time through STATVFS call */
2696                         additional_flags |= conn->fs_capabilities;
2697
2698                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2699                                 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
2700                                 additional_flags); /* FS ATTRIBUTES */
2701
2702                         SIVAL(pdata,4,255); /* Max filename component length */
2703                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2704                                 and will think we can't do long filenames */
2705                         len = srvstr_push(pdata, req->flags2, pdata+12, fstype,
2706                                           PTR_DIFF(end_data, pdata+12),
2707                                           STR_UNICODE);
2708                         SIVAL(pdata,8,len);
2709                         data_len = 12 + len;
2710                         break;
2711
2712                 case SMB_QUERY_FS_LABEL_INFO:
2713                 case SMB_FS_LABEL_INFORMATION:
2714                         len = srvstr_push(pdata, req->flags2, pdata+4, vname,
2715                                           PTR_DIFF(end_data, pdata+4), 0);
2716                         data_len = 4 + len;
2717                         SIVAL(pdata,0,len);
2718                         break;
2719
2720                 case SMB_QUERY_FS_VOLUME_INFO:      
2721                 case SMB_FS_VOLUME_INFORMATION:
2722
2723                         /* 
2724                          * Add volume serial number - hash of a combination of
2725                          * the called hostname and the service name.
2726                          */
2727                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^ 
2728                                 (str_checksum(get_local_machine_name())<<16));
2729
2730                         /* Max label len is 32 characters. */
2731                         len = srvstr_push(pdata, req->flags2, pdata+18, vname,
2732                                           PTR_DIFF(end_data, pdata+18),
2733                                           STR_UNICODE);
2734                         SIVAL(pdata,12,len);
2735                         data_len = 18+len;
2736
2737                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n", 
2738                                 (int)strlen(vname),vname, lp_servicename(snum)));
2739                         break;
2740
2741                 case SMB_QUERY_FS_SIZE_INFO:
2742                 case SMB_FS_SIZE_INFORMATION:
2743                 {
2744                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2745                         data_len = 24;
2746                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2747                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2748                                 return;
2749                         }
2750                         block_size = lp_block_size(snum);
2751                         if (bsize < block_size) {
2752                                 uint64_t factor = block_size/bsize;
2753                                 bsize = block_size;
2754                                 dsize /= factor;
2755                                 dfree /= factor;
2756                         }
2757                         if (bsize > block_size) {
2758                                 uint64_t factor = bsize/block_size;
2759                                 bsize = block_size;
2760                                 dsize *= factor;
2761                                 dfree *= factor;
2762                         }
2763                         bytes_per_sector = 512;
2764                         sectors_per_unit = bsize/bytes_per_sector;
2765                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2766 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2767                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2768                         SBIG_UINT(pdata,0,dsize);
2769                         SBIG_UINT(pdata,8,dfree);
2770                         SIVAL(pdata,16,sectors_per_unit);
2771                         SIVAL(pdata,20,bytes_per_sector);
2772                         break;
2773                 }
2774
2775                 case SMB_FS_FULL_SIZE_INFORMATION:
2776                 {
2777                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2778                         data_len = 32;
2779                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2780                                 reply_unixerror(req, ERRHRD, ERRgeneral);
2781                                 return;
2782                         }
2783                         block_size = lp_block_size(snum);
2784                         if (bsize < block_size) {
2785                                 uint64_t factor = block_size/bsize;
2786                                 bsize = block_size;
2787                                 dsize /= factor;
2788                                 dfree /= factor;
2789                         }
2790                         if (bsize > block_size) {
2791                                 uint64_t factor = bsize/block_size;
2792                                 bsize = block_size;
2793                                 dsize *= factor;
2794                                 dfree *= factor;
2795                         }
2796                         bytes_per_sector = 512;
2797                         sectors_per_unit = bsize/bytes_per_sector;
2798                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2799 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2800                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2801                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2802                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2803                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2804                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2805                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2806                         break;
2807                 }
2808
2809                 case SMB_QUERY_FS_DEVICE_INFO:
2810                 case SMB_FS_DEVICE_INFORMATION:
2811                         data_len = 8;
2812                         SIVAL(pdata,0,0); /* dev type */
2813                         SIVAL(pdata,4,0); /* characteristics */
2814                         break;
2815
2816 #ifdef HAVE_SYS_QUOTAS
2817                 case SMB_FS_QUOTA_INFORMATION:
2818                 /* 
2819                  * what we have to send --metze:
2820                  *
2821                  * Unknown1:            24 NULL bytes
2822                  * Soft Quota Treshold: 8 bytes seems like uint64_t or so
2823                  * Hard Quota Limit:    8 bytes seems like uint64_t or so
2824                  * Quota Flags:         2 byte :
2825                  * Unknown3:            6 NULL bytes
2826                  *
2827                  * 48 bytes total
2828                  * 
2829                  * details for Quota Flags:
2830                  * 
2831                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2832                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
2833                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2834                  * 0x0001 Enable Quotas: enable quota for this fs
2835                  *
2836                  */
2837                 {
2838                         /* we need to fake up a fsp here,
2839                          * because its not send in this call
2840                          */
2841                         files_struct fsp;
2842                         SMB_NTQUOTA_STRUCT quotas;
2843                         
2844                         ZERO_STRUCT(fsp);
2845                         ZERO_STRUCT(quotas);
2846                         
2847                         fsp.conn = conn;
2848                         fsp.fnum = -1;
2849                         
2850                         /* access check */
2851                         if (conn->server_info->utok.uid != 0) {
2852                                 DEBUG(0,("set_user_quota: access_denied "
2853                                          "service [%s] user [%s]\n",
2854                                          lp_servicename(SNUM(conn)),
2855                                          conn->server_info->unix_name));
2856                                 reply_doserror(req, ERRDOS, ERRnoaccess);
2857                                 return;
2858                         }
2859                         
2860                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2861                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2862                                 reply_doserror(req, ERRSRV, ERRerror);
2863                                 return;
2864                         }
2865
2866                         data_len = 48;
2867
2868                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));          
2869                 
2870                         /* Unknown1 24 NULL bytes*/
2871                         SBIG_UINT(pdata,0,(uint64_t)0);
2872                         SBIG_UINT(pdata,8,(uint64_t)0);
2873                         SBIG_UINT(pdata,16,(uint64_t)0);
2874                 
2875                         /* Default Soft Quota 8 bytes */
2876                         SBIG_UINT(pdata,24,quotas.softlim);
2877
2878                         /* Default Hard Quota 8 bytes */
2879                         SBIG_UINT(pdata,32,quotas.hardlim);
2880         
2881                         /* Quota flag 2 bytes */
2882                         SSVAL(pdata,40,quotas.qflags);
2883                 
2884                         /* Unknown3 6 NULL bytes */
2885                         SSVAL(pdata,42,0);
2886                         SIVAL(pdata,44,0);
2887                         
2888                         break;
2889                 }
2890 #endif /* HAVE_SYS_QUOTAS */
2891                 case SMB_FS_OBJECTID_INFORMATION:
2892                 {
2893                         unsigned char objid[16];
2894                         struct smb_extended_info extended_info;
2895                         memcpy(pdata,create_volume_objectid(conn, objid),16);
2896                         samba_extended_info_version (&extended_info);
2897                         SIVAL(pdata,16,extended_info.samba_magic);
2898                         SIVAL(pdata,20,extended_info.samba_version);
2899                         SIVAL(pdata,24,extended_info.samba_subversion);
2900                         SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
2901                         memcpy(pdata+36,extended_info.samba_version_string,28);
2902                         data_len = 64;
2903                         break;
2904                 }
2905
2906                 /*
2907                  * Query the version and capabilities of the CIFS UNIX extensions
2908                  * in use.
2909                  */
2910
2911                 case SMB_QUERY_CIFS_UNIX_INFO:
2912                 {
2913                         bool large_write = lp_min_receive_file_size() &&
2914                                                 !srv_is_signing_active();
2915                         bool large_read = !srv_is_signing_active();
2916                         int encrypt_caps = 0;
2917
2918                         if (!lp_unix_extensions()) {
2919                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2920                                 return;
2921                         }
2922
2923                         switch (conn->encrypt_level) {
2924                         case 0:
2925                                 encrypt_caps = 0;
2926                                 break;
2927                         case 1:
2928                         case Auto:
2929                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
2930                                 break;
2931                         case Required:
2932                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
2933                                                 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
2934                                 large_write = false;
2935                                 large_read = false;
2936                                 break;
2937                         }
2938
2939                         data_len = 12;
2940                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2941                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2942
2943                         /* We have POSIX ACLs, pathname, encryption, 
2944                          * large read/write, and locking capability. */
2945
2946                         SBIG_UINT(pdata,4,((uint64_t)(
2947                                         CIFS_UNIX_POSIX_ACLS_CAP|
2948                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
2949                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
2950                                         CIFS_UNIX_EXTATTR_CAP|
2951                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
2952                                         encrypt_caps|
2953                                         (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
2954                                         (large_write ?
2955                                         CIFS_UNIX_LARGE_WRITE_CAP : 0))));
2956                         break;
2957                 }
2958
2959                 case SMB_QUERY_POSIX_FS_INFO:
2960                 {
2961                         int rc;
2962                         vfs_statvfs_struct svfs;
2963
2964                         if (!lp_unix_extensions()) {
2965                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2966                                 return;
2967                         }
2968
2969                         rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2970
2971                         if (!rc) {
2972                                 data_len = 56;
2973                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
2974                                 SIVAL(pdata,4,svfs.BlockSize);
2975                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2976                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2977                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2978                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2979                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2980                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2981                                 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2982 #ifdef EOPNOTSUPP
2983                         } else if (rc == EOPNOTSUPP) {
2984                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2985                                 return;
2986 #endif /* EOPNOTSUPP */
2987                         } else {
2988                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2989                                 reply_doserror(req, ERRSRV, ERRerror);
2990                                 return;
2991                         }
2992                         break;
2993                 }
2994
2995                 case SMB_QUERY_POSIX_WHOAMI:
2996                 {
2997                         uint32_t flags = 0;
2998                         uint32_t sid_bytes;
2999                         int i;
3000
3001                         if (!lp_unix_extensions()) {
3002                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3003                                 return;
3004                         }
3005
3006                         if (max_data_bytes < 40) {
3007                                 reply_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
3008                                 return;
3009                         }
3010
3011                         /* We ARE guest if global_sid_Builtin_Guests is
3012                          * in our list of SIDs.
3013                          */
3014                         if (nt_token_check_sid(&global_sid_Builtin_Guests,
3015                                                conn->server_info->ptok)) {
3016                                 flags |= SMB_WHOAMI_GUEST;
3017                         }
3018
3019                         /* We are NOT guest if global_sid_Authenticated_Users
3020                          * is in our list of SIDs.
3021                          */
3022                         if (nt_token_check_sid(&global_sid_Authenticated_Users,
3023                                                conn->server_info->ptok)) {
3024                                 flags &= ~SMB_WHOAMI_GUEST;
3025                         }
3026
3027                         /* NOTE: 8 bytes for UID/GID, irrespective of native
3028                          * platform size. This matches
3029                          * SMB_QUERY_FILE_UNIX_BASIC and friends.
3030                          */
3031                         data_len = 4 /* flags */
3032                             + 4 /* flag mask */
3033                             + 8 /* uid */
3034                             + 8 /* gid */
3035                             + 4 /* ngroups */
3036                             + 4 /* num_sids */
3037                             + 4 /* SID bytes */
3038                             + 4 /* pad/reserved */
3039                             + (conn->server_info->utok.ngroups * 8)
3040                                 /* groups list */
3041                             + (conn->server_info->ptok->num_sids *
3042                                     SID_MAX_SIZE)
3043                                 /* SID list */;
3044
3045                         SIVAL(pdata, 0, flags);
3046                         SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3047                         SBIG_UINT(pdata, 8,
3048                                   (uint64_t)conn->server_info->utok.uid);
3049                         SBIG_UINT(pdata, 16,
3050                                   (uint64_t)conn->server_info->utok.gid);
3051
3052
3053                         if (data_len >= max_data_bytes) {
3054                                 /* Potential overflow, skip the GIDs and SIDs. */
3055
3056                                 SIVAL(pdata, 24, 0); /* num_groups */
3057                                 SIVAL(pdata, 28, 0); /* num_sids */
3058                                 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3059                                 SIVAL(pdata, 36, 0); /* reserved */
3060
3061                                 data_len = 40;
3062                                 break;
3063                         }
3064
3065                         SIVAL(pdata, 24, conn->server_info->utok.ngroups);
3066                         SIVAL(pdata, 28, conn->server_info->num_sids);
3067
3068                         /* We walk the SID list twice, but this call is fairly
3069                          * infrequent, and I don't expect that it's performance
3070                          * sensitive -- jpeach
3071                          */
3072                         for (i = 0, sid_bytes = 0;
3073                              i < conn->server_info->ptok->num_sids; ++i) {
3074                                 sid_bytes += ndr_size_dom_sid(
3075                                         &conn->server_info->ptok->user_sids[i],
3076                                         0);
3077                         }
3078
3079                         /* SID list byte count */
3080                         SIVAL(pdata, 32, sid_bytes);
3081
3082                         /* 4 bytes pad/reserved - must be zero */
3083                         SIVAL(pdata, 36, 0);
3084                         data_len = 40;
3085
3086                         /* GID list */
3087                         for (i = 0; i < conn->server_info->utok.ngroups; ++i) {
3088                                 SBIG_UINT(pdata, data_len,
3089                                           (uint64_t)conn->server_info->utok.groups[i]);
3090                                 data_len += 8;
3091                         }
3092
3093                         /* SID list */
3094                         for (i = 0;
3095                             i < conn->server_info->ptok->num_sids; ++i) {
3096                                 int sid_len = ndr_size_dom_sid(
3097                                         &conn->server_info->ptok->user_sids[i],
3098                                         0);
3099
3100                                 sid_linearize(pdata + data_len, sid_len,
3101                                     &conn->server_info->ptok->user_sids[i]);
3102                                 data_len += sid_len;
3103                         }
3104
3105                         break;
3106                 }
3107
3108                 case SMB_MAC_QUERY_FS_INFO:
3109                         /*
3110                          * Thursby MAC extension... ONLY on NTFS filesystems
3111                          * once we do streams then we don't need this
3112                          */
3113                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
3114                                 data_len = 88;
3115                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
3116                                 break;
3117                         }
3118                         /* drop through */
3119                 default:
3120                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3121                         return;
3122         }
3123
3124
3125         send_trans2_replies(conn, req, params, 0, pdata, data_len,
3126                             max_data_bytes);
3127
3128         DEBUG( 4, ( "%s info_level = %d\n",
3129                     smb_fn_name(req->cmd), info_level) );
3130
3131         return;
3132 }
3133
3134 /****************************************************************************
3135  Reply to a TRANS2_SETFSINFO (set filesystem info).
3136 ****************************************************************************/
3137
3138 static void call_trans2setfsinfo(connection_struct *conn,
3139                                  struct smb_request *req,
3140                                  char **pparams, int total_params,
3141                                  char **ppdata, int total_data,
3142                                  unsigned int max_data_bytes)
3143 {
3144         char *pdata = *ppdata;
3145         char *params = *pparams;
3146         uint16 info_level;
3147
3148         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
3149
3150         /*  */
3151         if (total_params < 4) {
3152                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3153                         total_params));
3154                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3155                 return;
3156         }
3157
3158         info_level = SVAL(params,2);
3159
3160         if (IS_IPC(conn)) {
3161                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
3162                                 info_level != SMB_SET_CIFS_UNIX_INFO) {
3163                         DEBUG(0,("call_trans2setfsinfo: not an allowed "
3164                                 "info level (0x%x) on IPC$.\n",
3165                                 (unsigned int)info_level));
3166                         reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3167                         return;
3168                 }
3169         }
3170
3171         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3172                 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
3173                         DEBUG(0,("call_trans2setfsinfo: encryption required "
3174                                 "and info level 0x%x sent.\n",
3175                                 (unsigned int)info_level));
3176                         exit_server_cleanly("encryption required "
3177                                 "on connection");
3178                         return;
3179                 }
3180         }
3181
3182         switch(info_level) {
3183                 case SMB_SET_CIFS_UNIX_INFO:
3184                         {
3185                                 uint16 client_unix_major;
3186                                 uint16 client_unix_minor;
3187                                 uint32 client_unix_cap_low;
3188                                 uint32 client_unix_cap_high;
3189
3190                                 if (!lp_unix_extensions()) {
3191                                         reply_nterror(req,
3192                                                       NT_STATUS_INVALID_LEVEL);
3193                                         return;
3194                                 }
3195
3196                                 /* There should be 12 bytes of capabilities set. */
3197                                 if (total_data < 8) {
3198                                         reply_nterror(
3199                                                 req,
3200                                                 NT_STATUS_INVALID_PARAMETER);
3201                                         return;
3202                                 }
3203                                 client_unix_major = SVAL(pdata,0);
3204                                 client_unix_minor = SVAL(pdata,2);
3205                                 client_unix_cap_low = IVAL(pdata,4);
3206                                 client_unix_cap_high = IVAL(pdata,8);
3207                                 /* Just print these values for now. */
3208                                 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
3209 cap_low = 0x%x, cap_high = 0x%x\n",
3210                                         (unsigned int)client_unix_major,
3211                                         (unsigned int)client_unix_minor,
3212                                         (unsigned int)client_unix_cap_low,
3213                                         (unsigned int)client_unix_cap_high ));
3214
3215                                 /* Here is where we must switch to posix pathname processing... */
3216                                 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3217                                         lp_set_posix_pathnames();
3218                                         mangle_change_to_posix();
3219                                 }
3220
3221                                 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
3222                                     !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
3223                                         /* Client that knows how to do posix locks,
3224                                          * but not posix open/mkdir operations. Set a
3225                                          * default type for read/write checks. */
3226
3227                                         lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
3228
3229                                 }
3230                                 break;
3231                         }
3232
3233                 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
3234                         {
3235                                 NTSTATUS status;
3236                                 size_t param_len = 0;
3237                                 size_t data_len = total_data;
3238
3239                                 if (!lp_unix_extensions()) {
3240                                         reply_nterror(
3241                                                 req,
3242                                                 NT_STATUS_INVALID_LEVEL);
3243                                         return;
3244                                 }
3245
3246                                 if (lp_smb_encrypt(SNUM(conn)) == false) {
3247                                         reply_nterror(
3248                                                 req,
3249                                                 NT_STATUS_NOT_SUPPORTED);
3250                                         return;
3251                                 }
3252
3253                                 DEBUG( 4,("call_trans2setfsinfo: "
3254                                         "request transport encryption.\n"));
3255
3256                                 status = srv_request_encryption_setup(conn,
3257                                                                 (unsigned char **)ppdata,
3258                                                                 &data_len,
3259                                                                 (unsigned char **)pparams,
3260                                                                 &param_len);
3261
3262                                 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
3263                                                 !NT_STATUS_IS_OK(status)) {
3264                                         reply_nterror(req, status);
3265                                         return;
3266                                 }
3267
3268                                 send_trans2_replies(conn, req,
3269                                                 *pparams,
3270                                                 param_len,
3271                                                 *ppdata,
3272                                                 data_len,
3273                                                 max_data_bytes);
3274
3275                                 if (NT_STATUS_IS_OK(status)) {
3276                                         /* Server-side transport
3277                                          * encryption is now *on*. */
3278                                         status = srv_encryption_start(conn);
3279                                         if (!NT_STATUS_IS_OK(status)) {
3280                                                 exit_server_cleanly(
3281                                                         "Failure in setting "
3282                                                         "up encrypted transport");
3283                                         }
3284                                 }
3285                                 return;
3286                         }
3287
3288                 case SMB_FS_QUOTA_INFORMATION:
3289                         {
3290                                 files_struct *fsp = NULL;
3291                                 SMB_NTQUOTA_STRUCT quotas;
3292         
3293                                 ZERO_STRUCT(quotas);
3294
3295                                 /* access check */
3296                                 if ((conn->server_info->utok.uid != 0)
3297                                     ||!CAN_WRITE(conn)) {
3298                                         DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3299                                                  lp_servicename(SNUM(conn)),
3300                                                  conn->server_info->unix_name));
3301                                         reply_doserror(req, ERRSRV, ERRaccess);
3302                                         return;
3303                                 }
3304
3305                                 /* note: normaly there're 48 bytes,
3306                                  * but we didn't use the last 6 bytes for now 
3307                                  * --metze 
3308                                  */
3309                                 fsp = file_fsp(req, SVAL(params,0));
3310
3311                                 if (!check_fsp_ntquota_handle(conn, req,
3312                                                               fsp)) {
3313                                         DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3314                                         reply_nterror(
3315                                                 req, NT_STATUS_INVALID_HANDLE);
3316                                         return;
3317                                 }
3318
3319                                 if (total_data < 42) {
3320                                         DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3321                                                 total_data));
3322                                         reply_nterror(
3323                                                 req,
3324                                                 NT_STATUS_INVALID_PARAMETER);
3325                                         return;
3326                                 }
3327                         
3328                                 /* unknown_1 24 NULL bytes in pdata*/
3329                 
3330                                 /* the soft quotas 8 bytes (uint64_t)*/
3331                                 quotas.softlim = (uint64_t)IVAL(pdata,24);
3332 #ifdef LARGE_SMB_OFF_T
3333                                 quotas.softlim |= (((uint64_t)IVAL(pdata,28)) << 32);
3334 #else /* LARGE_SMB_OFF_T */
3335                                 if ((IVAL(pdata,28) != 0)&&
3336                                         ((quotas.softlim != 0xFFFFFFFF)||
3337                                         (IVAL(pdata,28)!=0xFFFFFFFF))) {
3338                                         /* more than 32 bits? */
3339                                         reply_nterror(
3340                                                 req,
3341                                                 NT_STATUS_INVALID_PARAMETER);
3342                                         return;
3343                                 }
3344 #endif /* LARGE_SMB_OFF_T */
3345                 
3346                                 /* the hard quotas 8 bytes (uint64_t)*/
3347                                 quotas.hardlim = (uint64_t)IVAL(pdata,32);
3348 #ifdef LARGE_SMB_OFF_T
3349                                 quotas.hardlim |= (((uint64_t)IVAL(pdata,36)) << 32);
3350 #else /* LARGE_SMB_OFF_T */
3351                                 if ((IVAL(pdata,36) != 0)&&
3352                                         ((quotas.hardlim != 0xFFFFFFFF)||
3353                                         (IVAL(pdata,36)!=0xFFFFFFFF))) {
3354                                         /* more than 32 bits? */
3355                                         reply_nterror(
3356                                                 req,
3357                                                 NT_STATUS_INVALID_PARAMETER);
3358                                         return;
3359                                 }
3360 #endif /* LARGE_SMB_OFF_T */
3361                 
3362                                 /* quota_flags 2 bytes **/
3363                                 quotas.qflags = SVAL(pdata,40);
3364                 
3365                                 /* unknown_2 6 NULL bytes follow*/
3366                 
3367                                 /* now set the quotas */
3368                                 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3369                                         DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3370                                         reply_doserror(req, ERRSRV, ERRerror);
3371                                         return;
3372                                 }
3373                         
3374                                 break;
3375                         }
3376                 default:
3377                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3378                                 info_level));
3379                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3380                         return;
3381                         break;
3382         }
3383
3384         /* 
3385          * sending this reply works fine, 
3386          * but I'm not sure it's the same 
3387          * like windows do...
3388          * --metze
3389          */
3390         reply_outbuf(req, 10, 0);
3391 }
3392
3393 #if defined(HAVE_POSIX_ACLS)
3394 /****************************************************************************
3395  Utility function to count the number of entries in a POSIX acl.
3396 ****************************************************************************/
3397
3398 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
3399 {
3400         unsigned int ace_count = 0;
3401         int entry_id = SMB_ACL_FIRST_ENTRY;
3402         SMB_ACL_ENTRY_T entry;
3403
3404         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3405                 /* get_next... */
3406                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3407                         entry_id = SMB_ACL_NEXT_ENTRY;
3408                 }
3409                 ace_count++;
3410         }
3411         return ace_count;
3412 }
3413
3414 /****************************************************************************
3415  Utility function to marshall a POSIX acl into wire format.
3416 ****************************************************************************/
3417
3418 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
3419 {
3420         int entry_id = SMB_ACL_FIRST_ENTRY;
3421         SMB_ACL_ENTRY_T entry;
3422
3423         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3424                 SMB_ACL_TAG_T tagtype;
3425                 SMB_ACL_PERMSET_T permset;
3426                 unsigned char perms = 0;
3427                 unsigned int own_grp;
3428
3429                 /* get_next... */
3430                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3431                         entry_id = SMB_ACL_NEXT_ENTRY;
3432                 }
3433
3434                 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
3435                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3436                         return False;
3437                 }
3438
3439                 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
3440                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3441                         return False;
3442                 }
3443
3444                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
3445                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
3446                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
3447
3448                 SCVAL(pdata,1,perms);
3449
3450                 switch (tagtype) {
3451                         case SMB_ACL_USER_OBJ:
3452                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
3453                                 own_grp = (unsigned int)pst->st_uid;
3454                                 SIVAL(pdata,2,own_grp);
3455                                 SIVAL(pdata,6,0);
3456                                 break;
3457                         case SMB_ACL_USER:
3458                                 {
3459                                         uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3460                                         if (!puid) {
3461                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3462                                                 return False;
3463                                         }
3464                                         own_grp = (unsigned int)*puid;
3465                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3466                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3467                                         SIVAL(pdata,2,own_grp);
3468                                         SIVAL(pdata,6,0);
3469                                         break;
3470                                 }
3471                         case SMB_ACL_GROUP_OBJ:
3472                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3473                                 own_grp = (unsigned int)pst->st_gid;
3474                                 SIVAL(pdata,2,own_grp);
3475                                 SIVAL(pdata,6,0);
3476                                 break;
3477                         case SMB_ACL_GROUP:
3478                                 {
3479                                         gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3480                                         if (!pgid) {
3481                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3482                                                 return False;
3483                                         }
3484                                         own_grp = (unsigned int)*pgid;
3485                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3486                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3487                                         SIVAL(pdata,2,own_grp);
3488                                         SIVAL(pdata,6,0);
3489                                         break;
3490                                 }
3491                         case SMB_ACL_MASK: