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