?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* fix to display correct form information in REG_BINARY information
[Samba.git] / source / libsmb / clilist.c
blob17a759f9e39371455fdb39ea116e64425eddbfbb
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 #define NO_SYSLOG
22
23 #include "includes.h"
24
25
26 /****************************************************************************
27 interpret a long filename structure - this is mostly guesses at the moment
28 The length of the structure is returned
29 The structure of a long filename depends on the info level. 260 is used
30 by NT and 2 is used by OS/2
31 ****************************************************************************/
32 static int interpret_long_filename(struct cli_state *cli,
33 int level,char *p,file_info *finfo)
34 {
35 extern file_info def_finfo;
36 file_info finfo2;
37 int len;
38 char *base = p;
39
40 if (!finfo) finfo = &finfo2;
41
42 memcpy(finfo,&def_finfo,sizeof(*finfo));
43
44 switch (level)
45 {
46 case 1: /* OS/2 understands this */
47 /* these dates are converted to GMT by
48 make_unix_date */
49 finfo->ctime = make_unix_date2(p+4);
50 finfo->atime = make_unix_date2(p+8);
51 finfo->mtime = make_unix_date2(p+12);
52 finfo->size = IVAL(p,16);
53 finfo->mode = CVAL(p,24);
54 len = CVAL(p, 26);
55 p += 27;
56 p += clistr_align_in(cli, p, 0);
57 /* the len+2 below looks strange but it is
58 important to cope with the differences
59 between win2000 and win9x for this call
60 (tridge) */
61 p += clistr_pull(cli, finfo->name, p,
62 sizeof(finfo->name),
63 len+2,
64 STR_TERMINATE);
65 return PTR_DIFF(p, base);
66
67 case 2: /* this is what OS/2 uses mostly */
68 /* these dates are converted to GMT by
69 make_unix_date */
70 finfo->ctime = make_unix_date2(p+4);
71 finfo->atime = make_unix_date2(p+8);
72 finfo->mtime = make_unix_date2(p+12);
73 finfo->size = IVAL(p,16);
74 finfo->mode = CVAL(p,24);
75 len = CVAL(p, 30);
76 p += 31;
77 /* check for unisys! */
78 p += clistr_pull(cli, finfo->name, p,
79 sizeof(finfo->name),
80 len,
81 STR_NOALIGN);
82 return PTR_DIFF(p, base) + 1;
83
84 case 260: /* NT uses this, but also accepts 2 */
85 {
86 int namelen, slen;
87 p += 4; /* next entry offset */
88 p += 4; /* fileindex */
89
90 /* these dates appear to arrive in a
91 weird way. It seems to be localtime
92 plus the serverzone given in the
93 initial connect. This is GMT when
94 DST is not in effect and one hour
95 from GMT otherwise. Can this really
96 be right??
97
98 I suppose this could be called
99 kludge-GMT. Is is the GMT you get
100 by using the current DST setting on
101 a different localtime. It will be
102 cheap to calculate, I suppose, as
103 no DST tables will be needed */
104
105 finfo->ctime = interpret_long_date(p); p += 8;
106 finfo->atime = interpret_long_date(p); p += 8;
107 finfo->mtime = interpret_long_date(p); p += 8; p += 8;
108 finfo->size = IVAL(p,0); p += 8;
109 p += 8; /* alloc size */
110 finfo->mode = CVAL(p,0); p += 4;
111 namelen = IVAL(p,0); p += 4;
112 p += 4; /* EA size */
113 slen = SVAL(p, 0);
114 p += 2;
115 {
116 /* stupid NT bugs. grr */
117 int flags = 0;
118 if (p[1] == 0 && namelen > 1) flags |= STR_UNICODE;
119 clistr_pull(cli, finfo->short_name, p,
120 sizeof(finfo->short_name),
121 slen, flags);
122 }
123 p += 24; /* short name? */
124 clistr_pull(cli, finfo->name, p,
125 sizeof(finfo->name),
126 namelen, 0);
127 return SVAL(base, 0);
128 }
129 }
130
131 DEBUG(1,("Unknown long filename format %d\n",level));
132 return(SVAL(p,0));
133 }
134
135
136 /****************************************************************************
137 do a directory listing, calling fn on each file found
138 ****************************************************************************/
139 int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
140 void (*fn)(file_info *, const char *, void *), void *state)
141 {
142 int max_matches = 512;
143 int info_level;
144 char *p, *p2;
145 pstring mask;
146 file_info finfo;
147 int i;
148 char *tdl, *dirlist = NULL;
149 int dirlist_len = 0;
150 int total_received = -1;
151 BOOL First = True;
152 int ff_searchcount=0;
153 int ff_eos=0;
154 int ff_lastname=0;
155 int ff_dir_handle=0;
156 int loop_count = 0;
157 char *rparam=NULL, *rdata=NULL;
158 int param_len, data_len;
159 uint16 setup;
160 pstring param;
161
162 /* NT uses 260, OS/2 uses 2. Both accept 1. */
163 info_level = (cli->capabilities&CAP_NT_SMBS)?260:1;
164
165 pstrcpy(mask,Mask);
166
167 while (ff_eos == 0) {
168 loop_count++;
169 if (loop_count > 200) {
170 DEBUG(0,("Error: Looping in FIND_NEXT??\n"));
171 break;
172 }
173
174 if (First) {
175 setup = TRANSACT2_FINDFIRST;
176 SSVAL(param,0,attribute); /* attribute */
177 SSVAL(param,2,max_matches); /* max count */
178 SSVAL(param,4,4+2); /* resume required + close on end */
179 SSVAL(param,6,info_level);
180 SIVAL(param,8,0);
181 p = param+12;
182 p += clistr_push(cli, param+12, mask, -1,
183 STR_TERMINATE);
184 } else {
185 setup = TRANSACT2_FINDNEXT;
186 SSVAL(param,0,ff_dir_handle);
187 SSVAL(param,2,max_matches); /* max count */
188 SSVAL(param,4,info_level);
189 SIVAL(param,6,0); /* ff_resume_key */
190 SSVAL(param,10,8+4+2); /* continue + resume required + close on end */
191 p = param+12;
192 p += clistr_push(cli, param+12, mask, -1,
193 STR_TERMINATE);
194 }
195
196 param_len = PTR_DIFF(p, param);
197
198 if (!cli_send_trans(cli, SMBtrans2,
199 NULL, /* Name */
200 -1, 0, /* fid, flags */
201 &setup, 1, 0, /* setup, length, max */
202 param, param_len, 10, /* param, length, max */
203 NULL, 0,
204 cli->max_xmit /* data, length, max */
205 )) {
206 break;
207 }
208
209 if (!cli_receive_trans(cli, SMBtrans2,
210 &rparam, &param_len,
211 &rdata, &data_len) &&
212 cli_is_dos_error(cli)) {
213 /* we need to work around a Win95 bug - sometimes
214 it gives ERRSRV/ERRerror temprarily */
215 uint8 eclass;
216 uint32 ecode;
217 cli_dos_error(cli, &eclass, &ecode);
218 if (eclass != ERRSRV || ecode != ERRerror) break;
219 msleep(100);
220 continue;
221 }
222
223 if (cli_is_error(cli) || !rdata || !rparam)
224 break;
225
226 if (total_received == -1) total_received = 0;
227
228 /* parse out some important return info */
229 p = rparam;
230 if (First) {
231 ff_dir_handle = SVAL(p,0);
232 ff_searchcount = SVAL(p,2);
233 ff_eos = SVAL(p,4);
234 ff_lastname = SVAL(p,8);
235 } else {
236 ff_searchcount = SVAL(p,0);
237 ff_eos = SVAL(p,2);
238 ff_lastname = SVAL(p,6);
239 }
240
241 if (ff_searchcount == 0)
242 break;
243
244 /* point to the data bytes */
245 p = rdata;
246
247 /* we might need the lastname for continuations */
248 if (ff_lastname > 0) {
249 switch(info_level)
250 {
251 case 260:
252 clistr_pull(cli, mask, p+ff_lastname,
253 sizeof(mask),
254 data_len-ff_lastname,
255 STR_TERMINATE);
256 break;
257 case 1:
258 clistr_pull(cli, mask, p+ff_lastname+1,
259 sizeof(mask),
260 -1,
261 STR_TERMINATE);
262 break;
263 }
264 } else {
265 pstrcpy(mask,"");
266 }
267
268 /* and add them to the dirlist pool */
269 tdl = Realloc(dirlist,dirlist_len + data_len);
270
271 if (!tdl) {
272 DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
273 break;
274 }
275 else dirlist = tdl;
276
277 /* put in a length for the last entry, to ensure we can chain entries
278 into the next packet */
279 for (p2=p,i=0;i<(ff_searchcount-1);i++)
280 p2 += interpret_long_filename(cli,info_level,p2,NULL);
281 SSVAL(p2,0,data_len - PTR_DIFF(p2,p));
282
283 /* grab the data for later use */
284 memcpy(dirlist+dirlist_len,p,data_len);
285 dirlist_len += data_len;
286
287 total_received += ff_searchcount;
288
289 SAFE_FREE(rdata);
290 SAFE_FREE(rparam);
291
292 DEBUG(3,("received %d entries (eos=%d)\n",
293 ff_searchcount,ff_eos));
294
295 if (ff_searchcount > 0) loop_count = 0;
296
297 First = False;
298 }
299
300 for (p=dirlist,i=0;i<total_received;i++) {
301 p += interpret_long_filename(cli,info_level,p,&finfo);
302 fn(&finfo, Mask, state);
303 }
304
305 /* free up the dirlist buffer */
306 SAFE_FREE(dirlist);
307 return(total_received);
308 }
309
310
311
312 /****************************************************************************
313 interpret a short filename structure
314 The length of the structure is returned
315 ****************************************************************************/
316 static int interpret_short_filename(struct cli_state *cli, char *p,file_info *finfo)
317 {
318 extern file_info def_finfo;
319
320 *finfo = def_finfo;
321
322 finfo->mode = CVAL(p,21);
323
324 /* this date is converted to GMT by make_unix_date */
325 finfo->ctime = make_unix_date(p+22);
326 finfo->mtime = finfo->atime = finfo->ctime;
327 finfo->size = IVAL(p,26);
328 clistr_pull(cli, finfo->name, p+30, sizeof(finfo->name), 12, STR_ASCII);
329 if (strcmp(finfo->name, "..") && strcmp(finfo->name, "."))
330 fstrcpy(finfo->short_name,finfo->name);
331
332 return(DIR_STRUCT_SIZE);
333 }
334
335
336 /****************************************************************************
337 do a directory listing, calling fn on each file found
338 this uses the old SMBsearch interface. It is needed for testing Samba,
339 but should otherwise not be used
340 ****************************************************************************/
341 int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
342 void (*fn)(file_info *, const char *, void *), void *state)
343 {
344 char *p;
345 int received = 0;
346 BOOL first = True;
347 char status[21];
348 int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
349 int num_received = 0;
350 int i;
351 char *tdl, *dirlist = NULL;
352 pstring mask;
353
354 ZERO_ARRAY(status);
355
356 pstrcpy(mask,Mask);
357
358 while (1) {
359 memset(cli->outbuf,'\0',smb_size);
360 memset(cli->inbuf,'\0',smb_size);
361
362 set_message(cli->outbuf,2,0,True);
363
364 SCVAL(cli->outbuf,smb_com,SMBsearch);
365
366 SSVAL(cli->outbuf,smb_tid,cli->cnum);
367 cli_setup_packet(cli);
368
369 SSVAL(cli->outbuf,smb_vwv0,num_asked);
370 SSVAL(cli->outbuf,smb_vwv1,attribute);
371
372 p = smb_buf(cli->outbuf);
373 *p++ = 4;
374
375 p += clistr_push(cli, p, first?mask:"", -1, STR_TERMINATE);
376 *p++ = 5;
377 if (first) {
378 SSVAL(p,0,0);
379 p += 2;
380 } else {
381 SSVAL(p,0,21);
382 p += 2;
383 memcpy(p,status,21);
384 p += 21;
385 }
386
387 cli_setup_bcc(cli, p);
388 cli_send_smb(cli);
389 if (!cli_receive_smb(cli)) break;
390
391 received = SVAL(cli->inbuf,smb_vwv0);
392 if (received <= 0) break;
393
394 first = False;
395
396 tdl = Realloc(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
397
398 if (!tdl) {
399 DEBUG(0,("cli_list_old: failed to expand dirlist"));
400 SAFE_FREE(dirlist);
401 return 0;
402 }
403 else dirlist = tdl;
404
405 p = smb_buf(cli->inbuf) + 3;
406
407 memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
408 p,received*DIR_STRUCT_SIZE);
409
410 memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
411
412 num_received += received;
413
414 if (cli_is_error(cli)) break;
415 }
416
417 if (!first) {
418 memset(cli->outbuf,'\0',smb_size);
419 memset(cli->inbuf,'\0',smb_size);
420
421 set_message(cli->outbuf,2,0,True);
422 SCVAL(cli->outbuf,smb_com,SMBfclose);
423 SSVAL(cli->outbuf,smb_tid,cli->cnum);
424 cli_setup_packet(cli);
425
426 SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
427 SSVAL(cli->outbuf, smb_vwv1, attribute);
428
429 p = smb_buf(cli->outbuf);
430 *p++ = 4;
431 fstrcpy(p, "");
432 p += strlen(p) + 1;
433 *p++ = 5;
434 SSVAL(p, 0, 21);
435 p += 2;
436 memcpy(p,status,21);
437 p += 21;
438
439 cli_setup_bcc(cli, p);
440 cli_send_smb(cli);
441 if (!cli_receive_smb(cli)) {
442 DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
443 }
444 }
445
446 for (p=dirlist,i=0;i<num_received;i++) {
447 file_info finfo;
448 p += interpret_short_filename(cli, p,&finfo);
449 fn(&finfo, Mask, state);
450 }
451
452 SAFE_FREE(dirlist);
453 return(num_received);
454 }
455
456
457 /****************************************************************************
458 do a directory listing, calling fn on each file found
459 this auto-switches between old and new style
460 ****************************************************************************/
461 int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
462 void (*fn)(file_info *, const char *, void *), void *state)
463 {
464 if (cli->protocol <= PROTOCOL_LANMAN1) {
465 return cli_list_old(cli, Mask, attribute, fn, state);
466 }
467 return cli_list_new(cli, Mask, attribute, fn, state);
468 }
Samba GIT mirror