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