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