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