?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-winbind: Implemented samr backend function sam_trusted_domains.
[Samba/gebeck_regimport.git] / source3 / libsmb / clilist.c
blob93f67c7e63df89530eaaca5e36ee1f207dc2e7f1
1 /*
2 Unix SMB/CIFS implementation.
3 client directory list routines
4 Copyright (C) Andrew Tridgell 1994-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21
22 /****************************************************************************
23 Calculate a safe next_entry_offset.
24 ****************************************************************************/
25
26 static size_t calc_next_entry_offset(const char *base, const char *pdata_end)
27 {
28 size_t next_entry_offset = (size_t)IVAL(base,0);
29
30 if (next_entry_offset == 0 ||
31 base + next_entry_offset < base ||
32 base + next_entry_offset > pdata_end) {
33 next_entry_offset = pdata_end - base;
34 }
35 return next_entry_offset;
36 }
37
38 /****************************************************************************
39 Interpret a long filename structure - this is mostly guesses at the moment.
40 The length of the structure is returned
41 The structure of a long filename depends on the info level.
42 SMB_FIND_FILE_BOTH_DIRECTORY_INFO is used
43 by NT and SMB_FIND_EA_SIZE is used by OS/2
44 ****************************************************************************/
45
46 static size_t interpret_long_filename(TALLOC_CTX *ctx,
47 struct cli_state *cli,
48 int level,
49 const char *p,
50 const char *pdata_end,
51 file_info *finfo,
52 uint32 *p_resume_key,
53 DATA_BLOB *p_last_name_raw)
54 {
55 int len;
56 size_t ret;
57 const char *base = p;
58
59 data_blob_free(p_last_name_raw);
60
61 if (p_resume_key) {
62 *p_resume_key = 0;
63 }
64 ZERO_STRUCTP(finfo);
65 finfo->cli = cli;
66
67 switch (level) {
68 case SMB_FIND_INFO_STANDARD: /* OS/2 understands this */
69 /* these dates are converted to GMT by
70 make_unix_date */
71 if (pdata_end - base < 27) {
72 return pdata_end - base;
73 }
74 finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
75 finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
76 finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
77 finfo->size = IVAL(p,16);
78 finfo->mode = CVAL(p,24);
79 len = CVAL(p, 26);
80 p += 27;
81 p += clistr_align_in(cli, p, 0);
82
83 /* We can safely use len here (which is required by OS/2)
84 * and the NAS-BASIC server instead of +2 or +1 as the
85 * STR_TERMINATE flag below is
86 * actually used as the length calculation.
87 * The len is merely an upper bound.
88 * Due to the explicit 2 byte null termination
89 * in cli_receive_trans/cli_receive_nt_trans
90 * we know this is safe. JRA + kukks
91 */
92
93 if (p + len > pdata_end) {
94 return pdata_end - base;
95 }
96
97 /* the len+2 below looks strange but it is
98 important to cope with the differences
99 between win2000 and win9x for this call
100 (tridge) */
101 ret = clistr_pull_talloc(ctx,
102 cli->inbuf,
103 &finfo->name,
104 p,
105 len+2,
106 STR_TERMINATE);
107 if (ret == (size_t)-1) {
108 return pdata_end - base;
109 }
110 p += ret;
111 return PTR_DIFF(p, base);
112
113 case SMB_FIND_EA_SIZE: /* this is what OS/2 uses mostly */
114 /* these dates are converted to GMT by
115 make_unix_date */
116 if (pdata_end - base < 31) {
117 return pdata_end - base;
118 }
119 finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
120 finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
121 finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
122 finfo->size = IVAL(p,16);
123 finfo->mode = CVAL(p,24);
124 len = CVAL(p, 30);
125 p += 31;
126 /* check for unisys! */
127 if (p + len + 1 > pdata_end) {
128 return pdata_end - base;
129 }
130 ret = clistr_pull_talloc(ctx,
131 cli->inbuf,
132 &finfo->name,
133 p,
134 len,
135 STR_NOALIGN);
136 if (ret == (size_t)-1) {
137 return pdata_end - base;
138 }
139 p += ret;
140 return PTR_DIFF(p, base) + 1;
141
142 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO: /* NT uses this, but also accepts 2 */
143 {
144 size_t namelen, slen;
145
146 if (pdata_end - base < 94) {
147 return pdata_end - base;
148 }
149
150 p += 4; /* next entry offset */
151
152 if (p_resume_key) {
153 *p_resume_key = IVAL(p,0);
154 }
155 p += 4; /* fileindex */
156
157 /* Offset zero is "create time", not "change time". */
158 p += 8;
159 finfo->atime_ts = interpret_long_date(p);
160 p += 8;
161 finfo->mtime_ts = interpret_long_date(p);
162 p += 8;
163 finfo->ctime_ts = interpret_long_date(p);
164 p += 8;
165 finfo->size = IVAL2_TO_SMB_BIG_UINT(p,0);
166 p += 8;
167 p += 8; /* alloc size */
168 finfo->mode = CVAL(p,0);
169 p += 4;
170 namelen = IVAL(p,0);
171 p += 4;
172 p += 4; /* EA size */
173 slen = SVAL(p, 0);
174 if (slen > 24) {
175 /* Bad short name length. */
176 return pdata_end - base;
177 }
178 p += 2;
179 {
180 /* stupid NT bugs. grr */
181 int flags = 0;
182 if (p[1] == 0 && namelen > 1) flags |= STR_UNICODE;
183 clistr_pull(cli->inbuf, finfo->short_name, p,
184 sizeof(finfo->short_name),
185 slen, flags);
186 }
187 p += 24; /* short name? */
188 if (p + namelen < p || p + namelen > pdata_end) {
189 return pdata_end - base;
190 }
191 ret = clistr_pull_talloc(ctx,
192 cli->inbuf,
193 &finfo->name,
194 p,
195 namelen,
196 0);
197 if (ret == (size_t)-1) {
198 return pdata_end - base;
199 }
200
201 /* To be robust in the face of unicode conversion failures
202 we need to copy the raw bytes of the last name seen here.
203 Namelen doesn't include the terminating unicode null, so
204 copy it here. */
205
206 if (p_last_name_raw) {
207 *p_last_name_raw = data_blob(NULL, namelen+2);
208 memcpy(p_last_name_raw->data, p, namelen);
209 SSVAL(p_last_name_raw->data, namelen, 0);
210 }
211 return calc_next_entry_offset(base, pdata_end);
212 }
213 }
214
215 DEBUG(1,("Unknown long filename format %d\n",level));
216 return calc_next_entry_offset(base, pdata_end);
217 }
218
219 /****************************************************************************
220 Do a directory listing, calling fn on each file found.
221 ****************************************************************************/
222
223 int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
224 void (*fn)(const char *, file_info *, const char *, void *), void *state)
225 {
226 #if 1
227 int max_matches = 1366; /* Match W2k - was 512. */
228 #else
229 int max_matches = 512;
230 #endif
231 int info_level;
232 char *p, *p2, *rdata_end;
233 char *mask = NULL;
234 file_info finfo;
235 int i;
236 char *dirlist = NULL;
237 int dirlist_len = 0;
238 int total_received = -1;
239 bool First = True;
240 int ff_searchcount=0;
241 int ff_eos=0;
242 int ff_dir_handle=0;
243 int loop_count = 0;
244 char *rparam=NULL, *rdata=NULL;
245 unsigned int param_len, data_len;
246 uint16 setup;
247 char *param;
248 uint32 resume_key = 0;
249 TALLOC_CTX *frame = talloc_stackframe();
250 DATA_BLOB last_name_raw = data_blob(NULL, 0);
251
252 /* NT uses SMB_FIND_FILE_BOTH_DIRECTORY_INFO,
253 OS/2 uses SMB_FIND_EA_SIZE. Both accept SMB_FIND_INFO_STANDARD. */
254 info_level = (cli->capabilities&CAP_NT_SMBS)?
255 SMB_FIND_FILE_BOTH_DIRECTORY_INFO : SMB_FIND_INFO_STANDARD;
256
257 mask = SMB_STRDUP(Mask);
258 if (!mask) {
259 TALLOC_FREE(frame);
260 return -1;
261 }
262
263 ZERO_STRUCT(finfo);
264
265 while (ff_eos == 0) {
266 size_t nlen = 2*(strlen(mask)+1);
267
268 loop_count++;
269 if (loop_count > 200) {
270 DEBUG(0,("Error: Looping in FIND_NEXT??\n"));
271 break;
272 }
273
274 param = SMB_MALLOC_ARRAY(char, 12+nlen+last_name_raw.length+2);
275 if (!param) {
276 break;
277 }
278
279 if (First) {
280 setup = TRANSACT2_FINDFIRST;
281 SSVAL(param,0,attribute); /* attribute */
282 SSVAL(param,2,max_matches); /* max count */
283 SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
284 SSVAL(param,6,info_level);
285 SIVAL(param,8,0);
286 p = param+12;
287 p += clistr_push(cli, param+12, mask,
288 nlen, STR_TERMINATE);
289 } else {
290 setup = TRANSACT2_FINDNEXT;
291 SSVAL(param,0,ff_dir_handle);
292 SSVAL(param,2,max_matches); /* max count */
293 SSVAL(param,4,info_level);
294 /* For W2K servers serving out FAT filesystems we *must* set the
295 resume key. If it's not FAT then it's returned as zero. */
296 SIVAL(param,6,resume_key); /* ff_resume_key */
297 /* NB. *DON'T* use continue here. If you do it seems that W2K and bretheren
298 can miss filenames. Use last filename continue instead. JRA */
299 SSVAL(param,10,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
300 p = param+12;
301 if (last_name_raw.length) {
302 memcpy(p, last_name_raw.data, last_name_raw.length);
303 p += last_name_raw.length;
304 } else {
305 p += clistr_push(cli, param+12, mask,
306 nlen, STR_TERMINATE);
307 }
308 }
309
310 param_len = PTR_DIFF(p, param);
311
312 if (!cli_send_trans(cli, SMBtrans2,
313 NULL, /* Name */
314 -1, 0, /* fid, flags */
315 &setup, 1, 0, /* setup, length, max */
316 param, param_len, 10, /* param, length, max */
317 NULL, 0,
318 #if 0
319 /* w2k value. */
320 MIN(16384,cli->max_xmit) /* data, length, max. */
321 #else
322 cli->max_xmit /* data, length, max. */
323 #endif
324 )) {
325 SAFE_FREE(param);
326 TALLOC_FREE(frame);
327 break;
328 }
329
330 SAFE_FREE(param);
331
332 if (!cli_receive_trans(cli, SMBtrans2,
333 &rparam, &param_len,
334 &rdata, &data_len) &&
335 cli_is_dos_error(cli)) {
336 /* We need to work around a Win95 bug - sometimes
337 it gives ERRSRV/ERRerror temprarily */
338 uint8 eclass;
339 uint32 ecode;
340
341 SAFE_FREE(rdata);
342 SAFE_FREE(rparam);
343
344 cli_dos_error(cli, &eclass, &ecode);
345
346 /*
347 * OS/2 might return "no more files",
348 * which just tells us, that searchcount is zero
349 * in this search.
350 * Guenter Kukkukk <linux@kukkukk.com>
351 */
352
353 if (eclass == ERRDOS && ecode == ERRnofiles) {
354 ff_searchcount = 0;
355 cli_reset_error(cli);
356 break;
357 }
358
359 if (eclass != ERRSRV || ecode != ERRerror)
360 break;
361 smb_msleep(100);
362 continue;
363 }
364
365 if (cli_is_error(cli) || !rdata || !rparam) {
366 SAFE_FREE(rdata);
367 SAFE_FREE(rparam);
368 break;
369 }
370
371 if (total_received == -1)
372 total_received = 0;
373
374 /* parse out some important return info */
375 p = rparam;
376 if (First) {
377 ff_dir_handle = SVAL(p,0);
378 ff_searchcount = SVAL(p,2);
379 ff_eos = SVAL(p,4);
380 } else {
381 ff_searchcount = SVAL(p,0);
382 ff_eos = SVAL(p,2);
383 }
384
385 if (ff_searchcount == 0) {
386 SAFE_FREE(rdata);
387 SAFE_FREE(rparam);
388 break;
389 }
390
391 /* point to the data bytes */
392 p = rdata;
393 rdata_end = rdata + data_len;
394
395 /* we might need the lastname for continuations */
396 for (p2=p,i=0;i<ff_searchcount && p2 < rdata_end;i++) {
397 if ((info_level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) &&
398 (i == ff_searchcount-1)) {
399 /* Last entry - fixup the last offset length. */
400 SIVAL(p2,0,PTR_DIFF((rdata + data_len),p2));
401 }
402 p2 += interpret_long_filename(frame,
403 cli,
404 info_level,
405 p2,
406 rdata_end,
407 &finfo,
408 &resume_key,
409 &last_name_raw);
410
411 if (!finfo.name) {
412 DEBUG(0,("cli_list_new: Error: unable to parse name from info level %d\n",
413 info_level));
414 ff_eos = 1;
415 break;
416 }
417 if (!First && *mask && strcsequal(finfo.name, mask)) {
418 DEBUG(0,("Error: Looping in FIND_NEXT as name %s has already been seen?\n",
419 finfo.name));
420 ff_eos = 1;
421 break;
422 }
423 }
424
425 SAFE_FREE(mask);
426 if (ff_searchcount > 0 && ff_eos == 0 && finfo.name) {
427 mask = SMB_STRDUP(finfo.name);
428 } else {
429 mask = SMB_STRDUP("");
430 }
431 if (!mask) {
432 SAFE_FREE(rdata);
433 SAFE_FREE(rparam);
434 break;
435 }
436
437 /* grab the data for later use */
438 /* and add them to the dirlist pool */
439 dirlist = (char *)SMB_REALLOC(dirlist,dirlist_len + data_len);
440
441 if (!dirlist) {
442 DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
443 SAFE_FREE(rdata);
444 SAFE_FREE(rparam);
445 break;
446 }
447
448 memcpy(dirlist+dirlist_len,p,data_len);
449 dirlist_len += data_len;
450
451 total_received += ff_searchcount;
452
453 SAFE_FREE(rdata);
454 SAFE_FREE(rparam);
455
456 DEBUG(3,("received %d entries (eos=%d)\n",
457 ff_searchcount,ff_eos));
458
459 if (ff_searchcount > 0)
460 loop_count = 0;
461
462 First = False;
463 }
464
465 /* see if the server disconnected or the connection otherwise failed */
466 if (cli_is_error(cli)) {
467 total_received = -1;
468 } else {
469 /* no connection problem. let user function add each entry */
470 rdata_end = dirlist + dirlist_len;
471 for (p=dirlist,i=0;i<total_received;i++) {
472 p += interpret_long_filename(frame,
473 cli,
474 info_level,
475 p,
476 rdata_end,
477 &finfo,
478 NULL,
479 NULL);
480 if (!finfo.name) {
481 DEBUG(0,("cli_list_new: unable to parse name from info level %d\n",
482 info_level));
483 break;
484 }
485 fn(cli->dfs_mountpoint, &finfo, Mask, state);
486 }
487 }
488
489 /* free up the dirlist buffer and last name raw blob */
490 SAFE_FREE(dirlist);
491 data_blob_free(&last_name_raw);
492 SAFE_FREE(mask);
493 TALLOC_FREE(frame);
494 return(total_received);
495 }
496
497 /****************************************************************************
498 Interpret a short filename structure.
499 The length of the structure is returned.
500 ****************************************************************************/
501
502 static bool interpret_short_filename(TALLOC_CTX *ctx,
503 struct cli_state *cli,
504 char *p,
505 file_info *finfo)
506 {
507 size_t ret;
508 ZERO_STRUCTP(finfo);
509
510 finfo->cli = cli;
511 finfo->mode = CVAL(p,21);
512
513 /* this date is converted to GMT by make_unix_date */
514 finfo->ctime_ts.tv_sec = cli_make_unix_date(cli, p+22);
515 finfo->ctime_ts.tv_nsec = 0;
516 finfo->mtime_ts.tv_sec = finfo->atime_ts.tv_sec = finfo->ctime_ts.tv_sec;
517 finfo->mtime_ts.tv_nsec = finfo->atime_ts.tv_nsec = 0;
518 finfo->size = IVAL(p,26);
519 ret = clistr_pull_talloc(ctx,
520 cli->inbuf,
521 &finfo->name,
522 p+30,
523 12,
524 STR_ASCII);
525 if (ret == (size_t)-1) {
526 return false;
527 }
528
529 if (finfo->name) {
530 strlcpy(finfo->short_name,
531 finfo->name,
532 sizeof(finfo->short_name));
533 }
534 return true;
535 }
536
537 /****************************************************************************
538 Do a directory listing, calling fn on each file found.
539 this uses the old SMBsearch interface. It is needed for testing Samba,
540 but should otherwise not be used.
541 ****************************************************************************/
542
543 int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
544 void (*fn)(const char *, file_info *, const char *, void *), void *state)
545 {
546 char *p;
547 int received = 0;
548 bool first = True;
549 char status[21];
550 int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
551 int num_received = 0;
552 int i;
553 char *dirlist = NULL;
554 char *mask = NULL;
555 TALLOC_CTX *frame = NULL;
556
557 ZERO_ARRAY(status);
558
559 mask = SMB_STRDUP(Mask);
560 if (!mask) {
561 return -1;
562 }
563
564 while (1) {
565 memset(cli->outbuf,'\0',smb_size);
566 memset(cli->inbuf,'\0',smb_size);
567
568 cli_set_message(cli->outbuf,2,0,True);
569
570 SCVAL(cli->outbuf,smb_com,SMBsearch);
571
572 SSVAL(cli->outbuf,smb_tid,cli->cnum);
573 cli_setup_packet(cli);
574
575 SSVAL(cli->outbuf,smb_vwv0,num_asked);
576 SSVAL(cli->outbuf,smb_vwv1,attribute);
577
578 p = smb_buf(cli->outbuf);
579 *p++ = 4;
580
581 p += clistr_push(cli, p, first?mask:"",
582 cli->bufsize - PTR_DIFF(p,cli->outbuf),
583 STR_TERMINATE);
584 *p++ = 5;
585 if (first) {
586 SSVAL(p,0,0);
587 p += 2;
588 } else {
589 SSVAL(p,0,21);
590 p += 2;
591 memcpy(p,status,21);
592 p += 21;
593 }
594
595 cli_setup_bcc(cli, p);
596 cli_send_smb(cli);
597 if (!cli_receive_smb(cli)) break;
598
599 received = SVAL(cli->inbuf,smb_vwv0);
600 if (received <= 0) break;
601
602 /* Ensure we received enough data. */
603 if ((cli->inbuf+4+smb_len(cli->inbuf) - (smb_buf(cli->inbuf)+3)) <
604 received*DIR_STRUCT_SIZE) {
605 break;
606 }
607
608 first = False;
609
610 dirlist = (char *)SMB_REALLOC(
611 dirlist,(num_received + received)*DIR_STRUCT_SIZE);
612 if (!dirlist) {
613 DEBUG(0,("cli_list_old: failed to expand dirlist"));
614 SAFE_FREE(mask);
615 return 0;
616 }
617
618 p = smb_buf(cli->inbuf) + 3;
619
620 memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
621 p,received*DIR_STRUCT_SIZE);
622
623 memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
624
625 num_received += received;
626
627 if (cli_is_error(cli)) break;
628 }
629
630 if (!first) {
631 memset(cli->outbuf,'\0',smb_size);
632 memset(cli->inbuf,'\0',smb_size);
633
634 cli_set_message(cli->outbuf,2,0,True);
635 SCVAL(cli->outbuf,smb_com,SMBfclose);
636 SSVAL(cli->outbuf,smb_tid,cli->cnum);
637 cli_setup_packet(cli);
638
639 SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
640 SSVAL(cli->outbuf, smb_vwv1, attribute);
641
642 p = smb_buf(cli->outbuf);
643 *p++ = 4;
644 fstrcpy(p, "");
645 p += strlen(p) + 1;
646 *p++ = 5;
647 SSVAL(p, 0, 21);
648 p += 2;
649 memcpy(p,status,21);
650 p += 21;
651
652 cli_setup_bcc(cli, p);
653 cli_send_smb(cli);
654 if (!cli_receive_smb(cli)) {
655 DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
656 }
657 }
658
659 frame = talloc_stackframe();
660 for (p=dirlist,i=0;i<num_received;i++) {
661 file_info finfo;
662 if (!interpret_short_filename(frame, cli, p, &finfo)) {
663 break;
664 }
665 p += DIR_STRUCT_SIZE;
666 fn("\\", &finfo, Mask, state);
667 }
668 TALLOC_FREE(frame);
669
670 SAFE_FREE(mask);
671 SAFE_FREE(dirlist);
672 return(num_received);
673 }
674
675 /****************************************************************************
676 Do a directory listing, calling fn on each file found.
677 This auto-switches between old and new style.
678 ****************************************************************************/
679
680 int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
681 void (*fn)(const char *, file_info *, const char *, void *), void *state)
682 {
683 if (cli->protocol <= PROTOCOL_LANMAN1)
684 return cli_list_old(cli, Mask, attribute, fn, state);
685 return cli_list_new(cli, Mask, attribute, fn, state);
686 }
reg import