Merge branch 'vendor/TCPDUMP'
[dragonfly.git] / usr.bin / doscmd / cwd.c
1 /*
2  * Copyright (c) 1992, 1993, 1996
3  *      Berkeley Software Design, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Berkeley Software
16  *      Design, Inc.
17  *
18  * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  *      BSDI cwd.c,v 2.2 1996/04/08 19:32:25 bostic Exp
31  *
32  * $FreeBSD: src/usr.bin/doscmd/cwd.c,v 1.6.2.3 2002/04/25 11:04:50 tg Exp $
33  * $DragonFly: src/usr.bin/doscmd/cwd.c,v 1.3 2006/08/03 16:40:48 swildner Exp $
34  */
35
36 #include <sys/types.h>
37 #include <sys/param.h>
38 #include <sys/mount.h>
39 #include <dirent.h>
40 #include <errno.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <stdio.h>
46
47 #include "doscmd.h"
48 #include "cwd.h"
49
50 /* Local functions */
51 static inline int       isvalid(unsigned);
52 static inline int       isdot(unsigned);
53 static inline int       isslash(unsigned);
54 static void             to_dos_fcb(u_char *, u_char *);
55
56 #define D_REDIR         0x0080000       /* XXX - ack */
57 #define D_TRAPS3        0x0200000
58
59 typedef struct {
60     u_char              *path;
61     u_char              *cwd;
62     int                 len;
63     int                 maxlen;
64     int                 read_only:1;
65 } Path_t;
66
67 typedef struct Name_t {
68     u_char              *real;
69     struct Name_t       *next;
70     u_char              name[9];
71     u_char              ext[4];
72 } Name_t;
73
74
75 #define MAX_DRIVE       26
76
77 static Path_t paths[MAX_DRIVE];
78 static Name_t *names;
79
80 /*
81  * Initialize the drive to be based at 'base' in the BSD filesystem
82  */
83 void
84 init_path(int drive, const u_char *base, const u_char *dir)
85 {
86     Path_t *d;
87
88     if (drive < 0 || drive >= MAX_DRIVE)
89         return;
90
91     debug(D_TRAPS3, "init_path(%d, %s, %s)\n", drive, base, dir);
92
93     d = &paths[drive];
94
95     if (d->path)
96         free(d->path);
97
98     if ((d->path = ustrdup(base)) == NULL)
99         fatal("strdup in init_path for %c:%s: %s", drntol(drive), base,
100               strerror(errno));
101
102     if (d->maxlen < 2) {
103         d->maxlen = 128;
104         if ((d->cwd = (u_char *)malloc(d->maxlen)) == NULL)
105             fatal("malloc in init_path for %c:%s: %s", drntol(drive), base,
106                   strerror(errno));
107     }
108
109     d->cwd[0] = '\\';
110     d->cwd[1] = 0;
111     d->len = 1;
112     if (dir) {
113         if (ustrncmp(base, dir, ustrlen(base)) == 0)
114                 dir += ustrlen(base);
115         while (*dir == '/')
116             ++dir;
117
118         while (*dir) {
119             u_char dosname[15];
120             u_char realname[256];
121             u_char *r = realname;
122
123             while ((*r = *dir) && *dir++ != '/') {
124                 ++r;
125             }
126             *r = 0;
127             while (*dir == '/')
128                 ++dir;
129
130             dosname[0] = drntol(drive);
131             dosname[1] = ':';
132             real_to_dos(realname, &dosname[2]);
133
134             if (dos_setcwd(dosname)) {
135                 fprintf(stderr, "Failed to CD to directory %s in %s\n",
136                                  dosname, d->cwd);
137             }
138         }
139     }
140 }
141
142 /*
143  * Mark this drive as read only
144  */
145 void
146 dos_makereadonly(int drive)
147 {
148
149     if (drive < 0 || drive >= MAX_DRIVE)
150         return;
151     paths[drive].read_only = 1;
152 }
153
154 /*
155  * Return read-only status of drive
156  */
157 int
158 dos_readonly(int drive)
159 {
160
161     if (drive < 0 || drive >= MAX_DRIVE)
162         return (0);
163     debug(D_REDIR, "dos_readonly(%d) -> %d\n", drive, paths[drive].read_only);
164     return (paths[drive].read_only);
165 }
166
167 /*
168  * Return DOS's idea of the CWD for drive
169  * Return 0 if the drive specified is not mapped (or bad)
170  */
171 u_char *
172 dos_getcwd(int drive)
173 {
174
175     if (drive < 0 || drive >= MAX_DRIVE)
176         return (0);
177     debug(D_REDIR, "dos_getcwd(%d) -> %s\n", drive, paths[drive].cwd);
178     return (paths[drive].cwd);
179 }
180
181 /*
182  * Return DOS's idea of the CWD for drive
183  * Return 0 if the drive specified is not mapped (or bad)
184  */
185 u_char *
186 dos_getpath(int drive)
187 {
188
189     if (drive < 0 || drive >= MAX_DRIVE)
190         return (0);
191     debug(D_REDIR, "dos_getpath(%d) -> %s\n", drive, paths[drive].path);
192     return (paths[drive].path);
193 }
194
195 /*
196  * Fix up a DOS path name.  Strip out all '.' and '..' entries, turn
197  * '/' into '\\' and convert all lowercase to uppercase.
198  * Returns 0 on success or DOS errno
199  */
200 int
201 dos_makepath(u_char *where, u_char *newpath)
202 {
203     int drive;
204     u_char **dirs;
205     u_char *np;
206     Path_t *d;
207     u_char tmppath[1024];
208     u_char *snewpath = newpath;
209
210     if (where[0] != '\0' && where[1] == ':') {
211         drive = drlton(*where);
212         *newpath++ = *where++;
213         *newpath++ = *where++;
214     } else {
215         drive = diskdrive;
216         *newpath++ = drntol(diskdrive);
217         *newpath++ = ':';
218     }
219
220     if (drive < 0 || drive >= MAX_DRIVE) {
221         debug(D_REDIR,"drive %c invalid\n", drntol(drive));
222         return (DISK_DRIVE_INVALID);
223     }
224
225     d = &paths[drive];
226     if (d->cwd == NULL) {
227         debug(D_REDIR,"no cwd for drive %c\n",drntol(drive));
228         return (DISK_DRIVE_INVALID);
229     }
230
231     debug(D_REDIR, "dos_makepath(%d, %s)\n", drive, where);
232
233     np = newpath;
234     if (*where != '\\' && *where != '/') {
235         ustrncpy(tmppath, d->cwd, 1024);
236         if (d->cwd[1])
237             ustrncat(tmppath, "/", 1024 - ustrlen(tmppath));
238         ustrncat(tmppath, where, 1024 - ustrlen(tmppath));
239     } else {
240         ustrncpy(tmppath, where, 1024 - ustrlen(tmppath));
241     }
242
243     dirs = get_entries(tmppath);
244     if (dirs == NULL)
245         return (PATH_NOT_FOUND);
246
247     np = newpath;
248     while (*dirs) {
249         u_char *dir = *dirs++;
250         if (*dir == '/' || *dir == '\\') {
251             np = newpath + 1;
252             newpath[0] = '\\';
253         } else if (dir[0] == '.' && dir[1] == 0) {
254             ;
255         } else if (dir[0] == '.' && dir[1] == '.' && dir[2] == '\0') {
256             while (np[-1] != '/' && np[-1] != '\\')
257                 --np;
258             if (np - 1 > newpath)
259                 --np;
260         } else {
261             if (np[-1] != '\\')
262                 *np++ = '\\';
263             while ((*np = *dir++) && np - snewpath < 1023)
264                 ++np;
265         }
266     }
267     *np = 0;
268
269     return (0);
270 }
271
272 /*
273  * Set DOS's idea of the CWD for drive to be where.
274  * Returns DOS errno on failuer.
275  */
276 int
277 dos_setcwd(u_char *where)
278 {
279     u_char new_path[1024];
280     u_char real_path[1024];
281     int drive;
282     struct stat sb;
283     Path_t *d;
284     int error;
285
286     debug(D_REDIR, "dos_setcwd(%s)\n", where);
287
288     error = dos_makepath(where, new_path);
289     if (error)
290         return (error);
291
292     error = dos_to_real_path(new_path, real_path, &drive);
293     if (error)
294         return (error);
295     
296     if (ustat(real_path, &sb) < 0 || !S_ISDIR(sb.st_mode))
297         return (PATH_NOT_FOUND);
298     if (uaccess(real_path, R_OK | X_OK))
299         return (PATH_NOT_FOUND);
300     
301     d = &paths[drive];
302     d->len = ustrlen(new_path + 2);
303
304     if (d->len + 1 > d->maxlen) {
305         free(d->cwd);
306         d->maxlen = d->len + 1 + 32;
307         d->cwd = (u_char *)malloc(d->maxlen);
308         if (d->cwd == NULL)
309             fatal("malloc in dos_setcwd for %c:%s: %s", drntol(drive),
310                   new_path, strerror(errno));
311     }
312     ustrncpy(d->cwd, new_path + 2, d->maxlen - d->len);
313     return (0);
314 }
315
316 /*
317  * Given a DOS path dos_path and a drive, convert it to a BSD pathname
318  * and store the result in real_path.
319  * Return DOS errno on failure.
320  */
321 int
322 dos_to_real_path(u_char *dos_path, u_char *real_path, int *drivep)
323 {
324     Path_t *d;
325     u_char new_path[1024];
326     u_char *rp;
327     u_char **dirs;
328     u_char *dir;
329     int drive;
330
331     debug(D_REDIR, "dos_to_real_path(%s)\n", dos_path);
332
333     if (dos_path[0] != '\0' && dos_path[1] == ':') {
334         drive = drlton(*dos_path);
335         dos_path++;
336         dos_path++;
337     } else {
338         drive = diskdrive;
339     }
340
341     d = &paths[drive];
342     if (d->cwd == NULL)
343         return (DISK_DRIVE_INVALID);
344
345     ustrcpy(real_path, d->path);
346
347     rp = real_path;
348     while (*rp)
349         ++rp;
350
351     ustrncpy(new_path, dos_path, 1024 - ustrlen(new_path));
352
353     dirs = get_entries(new_path);
354     if (dirs == NULL)
355         return (PATH_NOT_FOUND);
356
357     /*
358      * Skip the leading /
359      * There are no . or .. entries to worry about either
360      */
361
362     while ((dir = *++dirs) != 0) {
363         *rp++ = '/';
364         dos_to_real(dir, rp);
365         while (*rp)
366             ++rp;
367     }
368
369     *drivep = drive;
370     return (0);
371 }
372
373 /*
374  * Provide a few istype() style functions.
375  * isvalid:     True if the character is a valid DOS filename character
376  * isdot:       True if '.'
377  * isslash:     True if '/' or '\'
378  *
379  * 0 - invalid
380  * 1 - okay
381  * 2 - *
382  * 3 - dot
383  * 4 - slash
384  * 5 - colon
385  * 6 - ?
386  * 7 - lowercase
387  */
388 u_char cattr[256] = {
389     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,    /* 0x00 */
390     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,    /* 0x10 */
391     0, 1, 0, 1, 1, 1, 1, 1,  1, 1, 2, 0, 0, 1, 3, 4,    /* 0x20 */
392     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 5, 0, 0, 0, 0, 6,    /* 0x30 */
393     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,    /* 0x40 */
394     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 0, 4, 0, 1, 1,    /* 0x50 */
395     1, 7, 7, 7, 7, 7, 7, 7,  7, 7, 7, 7, 7, 7, 7, 7,    /* 0x60 */
396     7, 7, 7, 7, 7, 7, 7, 7,  7, 7, 7, 1, 0, 1, 1, 0,    /* 0x70 */
397     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,    /* 0x80 */
398     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
399     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
400     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
401     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
402     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
403     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
404     1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
405 };
406
407 static inline int
408 isvalid(unsigned c)
409 {
410     return (cattr[c & 0xff] == 1);
411 }
412
413 static inline int
414 isdot(unsigned c)
415 {
416     return (cattr[c & 0xff] == 3);
417 }
418
419 static inline int
420 isslash(unsigned c)
421 {
422     return (cattr[c & 0xff] == 4);
423 }
424
425 /*
426  * Given a real component, compute the DOS component.
427  */
428 void
429 real_to_dos(u_char *real, u_char *dos)
430 {
431     Name_t *n;
432     Name_t *nn;
433     u_char *p;
434     u_char nm[9], ex[4];
435     int ncnt, ecnt;
436     int echar = '0';
437     int nchar = '0';
438
439     if (real[0] == '.' && (real[1] == '\0'
440                            || (real[1] == '.' && real[2] == '\0'))) {
441         sprintf((char *)dos, "%.8s", real);
442         return;
443     }
444
445     n = names;
446     while (n) {
447         if (ustrcmp(real, n->real) == 0) {
448             if (n->ext[0])
449                 sprintf((char *)dos, "%.8s.%.3s", n->name, n->ext);
450             else
451                 sprintf((char *)dos, "%.8s", n->name);
452             return;
453         }
454         n = n->next;
455     }
456
457     p = real;
458     ncnt = ecnt = 0;
459     while (isvalid(*p) && ncnt < 8) {
460         nm[ncnt] = *p;
461         ++ncnt;
462         ++p;
463     }
464     if (isdot(*p)) {
465         ++p;
466         while (isvalid(*p) && ecnt < 3) {
467             ex[ecnt] = *p;
468             ++ecnt;
469             ++p;
470         }
471     }
472     nm[ncnt] = '\0';
473     ex[ecnt] = '\0';
474
475     if (!*p && ncnt <= 8 && ecnt <= 3) {
476         n = names;
477         while (n) {
478             if (ustrncmp(n->name, nm, 8) == 0 && ustrncmp(n->ext, ex, 3) == 0) {
479                 break;
480             }
481             n = n->next;
482         }
483         if (n == 0) {
484             ustrcpy(dos, real);
485             return;
486         }
487     }
488
489     n = (Name_t *)malloc(sizeof(Name_t));
490
491     if (!n)
492         fatal("malloc in real_to_dos: %s\n", strerror(errno));
493
494     n->real = ustrdup(real);
495
496     if (!n->real)
497         fatal("strdup in real_to_dos: %s\n", strerror(errno));
498
499     p = real;
500     ncnt = ecnt = 0;
501     while (*p && ncnt < 8) {
502         if (isvalid(*p))
503             n->name[ncnt] = *p;
504         else if (islower(*p))
505             n->name[ncnt] = toupper(*p);
506         else if (isdot(*p))
507             break;
508         else
509             n->name[ncnt] = (*p |= 0x80);
510         ++ncnt;
511         ++p;
512     }
513     if (isdot(*p)) {
514         ++p;
515         while (*p && ecnt < 3) { 
516             if (isvalid(*p))
517                 n->ext[ecnt] = *p;
518             else if (islower(*p))
519                 n->ext[ecnt] = toupper(*p);
520 #if 0
521             else if (isdot(*p))
522                 ERROR
523 #endif
524             else
525                 n->ext[ecnt] = (*p |= 0x80);
526             ++ecnt;
527             ++p;
528         }
529     }
530     n->name[ncnt] = '\0';
531     n->ext[ecnt] = '\0';
532
533     for (;;) {
534         nn = names;
535         while (nn) {
536             if (ustrncmp(n->name, nn->name, 8) == 0 &&
537                 ustrncmp(n->ext, nn->ext, 3) == 0) {
538                     break;
539             }
540             nn = nn->next;
541         }
542         if (!nn)
543             break;
544         /*      
545          * Dang, this name was already in the cache.
546          * Let's munge it a little and try again.
547          */
548         if (ecnt < 3) {
549             n->ext[ecnt] = echar;
550             if (echar == '9') {
551                 echar = 'A';
552             } else if (echar == 'Z') {
553                 ++ecnt;
554                 echar = '0';
555             } else {
556                 ++echar;
557             }
558         } else if (ncnt < 8) {
559             n->name[ncnt] = nchar;
560             if (nchar == '9') {
561                 nchar = 'A';
562             } else if (nchar == 'Z') {
563                 ++ncnt;
564                 nchar = '0';
565             } else {
566                 ++nchar;
567             }
568         } else if (n->ext[2] < 'Z')
569             n->ext[2]++;
570         else if (n->ext[1] < 'Z')
571             n->ext[1]++;
572         else if (n->ext[0] < 'Z')
573             n->ext[0]++;
574         else if (n->name[7] < 'Z')
575             n->name[7]++;
576         else if (n->name[6] < 'Z')
577             n->name[6]++;
578         else if (n->name[5] < 'Z')
579             n->name[5]++;
580         else if (n->name[4] < 'Z')
581             n->name[4]++;
582         else if (n->name[3] < 'Z')
583             n->name[3]++;
584         else if (n->name[2] < 'Z')
585             n->name[2]++;
586         else if (n->name[1] < 'Z')
587             n->name[1]++;
588         else if (n->name[0] < 'Z')
589             n->name[0]++;
590         else
591             break;
592     }
593
594     if (n->ext[0])
595         sprintf((char *)dos, "%.8s.%.3s", n->name, n->ext);
596     else
597         sprintf((char *)dos, "%.8s", n->name);
598     n->next = names;
599     names = n;
600 }
601
602
603 /*
604  * Given a DOS component, compute the REAL component.
605  */
606 void
607 dos_to_real(u_char *dos, u_char *real)
608 {
609     int ncnt = 0;
610     int ecnt = 0;
611     u_char name[8];
612     u_char ext[3];
613     Name_t *n = names;
614
615     while (ncnt < 8 && (isvalid(*dos) || islower(*dos))) {
616         name[ncnt++] = islower(*dos) ? toupper(*dos) : *dos;
617         ++dos;
618     }
619     if (ncnt < 8)
620         name[ncnt] = 0;
621
622     if (isdot(*dos)) {
623         while (ecnt < 3 && (isvalid(*++dos) || islower(*dos))) {
624             ext[ecnt++] = islower(*dos) ? toupper(*dos) : *dos;
625         }
626     }
627     if (ecnt < 3)
628         ext[ecnt] = 0;
629
630     while (n) {
631         if (!ustrncmp(name, n->name, 8) && !ustrncmp(ext, n->ext, 3)) {
632             ustrcpy(real, n->real);
633             return;
634         }
635         n = n->next;
636     }
637
638     if (ext[0])
639         sprintf((char *)real, "%-.8s.%-.3s", name, ext);
640     else
641         sprintf((char *)real, "%-.8s", name);
642
643     while (*real) {
644         if (isupper(*real))
645             *real = tolower(*real);
646         ++real;
647     }
648 }
649
650 /*
651  * convert a path into an argv[] like vector of components.
652  * If the path starts with a '/' or '\' then the first entry
653  * will be "/" or "\".  This is the only case in which a "/"
654  * or "\" may appear in an entry.
655  * Also convert all lowercase to uppercase.
656  * The data returned is in a static area, so a second call will
657  * erase the data of the first.
658  */
659 u_char **
660 get_entries(u_char *path)
661 {
662     static u_char *entries[128];        /* Maximum depth... */
663     static u_char mypath[1024];
664     u_char **e = entries;
665     u_char *p = mypath;
666
667     ustrncpy(mypath+1, path, 1022);
668     p = mypath+1;
669     mypath[1023] = 0;
670     if (path[0] == '/' || path[0] == '\\') {
671         mypath[0] = path[0];
672         *e++ = mypath;
673         *p++ = 0;
674     }
675     while (*p && e < entries + 127) {
676         while (*p && (*p == '/' || *p == '\\')) {
677             ++p;
678         }
679
680         if (!*p)
681             break;
682         *e++ = p;
683         while (*p && (*p != '/' && *p != '\\')) {
684             if (islower(*p))
685                 *p = tolower(*p);
686             ++p;
687         }
688         /*
689          * skip over the '/' or '\'
690          */
691         if (*p)
692             *p++ = 0;
693     }
694     *e = 0;
695     return (entries);
696 }
697
698 /*
699  * Return file system statistics for drive.
700  * Return the DOS errno on failure.
701  */
702 int
703 get_space(int drive, fsstat_t *fs)
704 {
705     Path_t *d;
706     struct statfs *buf;
707     int nfs;
708     int i;
709     struct statfs *me = 0;
710
711     if (drive < 0 || drive >= MAX_DRIVE)
712         return (DISK_DRIVE_INVALID);
713
714     d = &paths[drive];
715
716     if (!d->path)
717         return (DISK_DRIVE_INVALID);
718
719     nfs = getfsstat(0, 0, MNT_WAIT);
720
721     buf = (struct statfs *)malloc(sizeof(struct statfs) * nfs);
722     if (buf == NULL) {
723         perror("get_space");
724         return (DISK_DRIVE_INVALID);
725     }
726     nfs = getfsstat(buf, sizeof(struct statfs) * nfs, MNT_WAIT);
727
728     for (i = 0; i < nfs; ++i) {
729         if (strncmp(buf[i].f_mntonname, (char *)d->path, strlen(buf[i].f_mntonname)))
730             continue;
731         if (me && strlen(me->f_mntonname) > strlen(buf[i].f_mntonname))
732             continue;
733         me = buf + i;
734     }
735     if (!me) {
736         free(buf);
737         return (3);
738     }
739     fs->bytes_sector = 512;
740     fs->sectors_cluster = me->f_bsize / fs->bytes_sector;
741     fs->total_clusters = me->f_blocks / fs->sectors_cluster;
742     while (fs->total_clusters > 0xFFFF) {
743         fs->sectors_cluster *= 2;
744         fs->total_clusters = me->f_blocks / fs->sectors_cluster;
745     }
746     fs->avail_clusters = me->f_bavail / fs->sectors_cluster;
747     free(buf);
748     return (0);
749 }
750
751 #if 0
752 DIR *dp = 0;
753 u_char searchdir[1024];
754 u_char *searchend;
755 #endif
756
757 /*
758  * Convert a dos filename into normal form (8.3 format, space padded)
759  */
760 static void
761 to_dos_fcb(u_char *p, u_char *expr)
762 {
763     int i;
764
765     if (expr[0] == '.') {
766         p[0] = '.';
767         if (expr[1] == '\0') {
768             for (i = 1; i < 11; i++)
769                 p[i] = ' ';
770             return;
771         }
772         if (expr[1] == '.') {
773             p[1] = '.';
774             if (expr[2] == '\0') {
775                 for (i = 2; i < 11; i++)
776                     p[i] = ' ';
777                 return;
778             }
779         }
780     }
781
782     for (i = 8; i > 0; i--) {
783         switch (*expr) {
784         case '\0':
785         case '.':
786                 for (; i > 0; i--)
787                         *p++ = ' ';
788                 break;
789         case '*':
790                 for (; i > 0; i--)
791                         *p++ = '?';
792                 break;
793         default:
794                 if (islower(*expr)) {
795                         *p++ = toupper(*expr++);
796                         break;
797                 }
798         case '?':
799                 *p++ = *expr++;
800                 break;
801         }
802     }
803
804     while (*expr != '\0' && *expr != '.')
805         ++expr;
806     if (*expr)
807         ++expr;
808
809     for (i = 3; i > 0; i--) {
810         switch (*expr) {
811         case '\0':
812         case '.':
813                 for (; i > 0; i--)
814                         *p++ = ' ';
815                 break;
816         case '*':
817                 for (; i > 0; i--)
818                         *p++ = '?';
819                 break;
820         default:
821                 if (islower(*expr)) {
822                         *p++ = toupper(*expr++);
823                         break;
824                 }
825         case '?':
826                 *p++ = *expr++;
827                 break;
828         }
829     }
830 }
831
832 /*
833 ** DOS can't handle multiple concurrent searches, and if we leave the
834 ** search instance in the DTA we get screwed as soon as someone starts lots
835 ** of searches without finishing them properly.
836 ** We allocate a single search structure, and recycle it if find_first()
837 ** is called before a search ends.
838 */
839 static search_t dir_search;
840
841 /*
842  * Find the first file on drive which matches the path with the given
843  * attributes attr.
844  * If found, the result is placed in dir (32 bytes).
845  * The DTA is populated as required by DOS, but the state area is ignored.
846  * Returns DOS errno on failure.
847  */
848 int
849 find_first(u_char *path, int attr, dosdir_t *dir, find_block_t *dta)
850 {
851     u_char new_path[1024], real_path[1024];
852     u_char *expr, *slash;
853     int drive;
854     int error;
855     search_t *search = &dir_search;
856
857     debug(D_REDIR, "find_first(%s, %x, %x)\n", path, attr, (int)dta);
858
859     error = dos_makepath(path, new_path);
860     if (error)
861         return (error);
862
863     expr = new_path;
864     slash = 0;
865     while (*expr != '\0') {
866         if (*expr == '\\' || *expr == '/')
867             slash = expr;
868         expr++;
869     }
870     *slash++ = '\0';
871
872     error = dos_to_real_path(new_path, real_path, &drive);
873     if (error)
874         return (error);
875
876     if (attr == VOLUME_LABEL)   /* never find a volume label */
877         return (NO_MORE_FILES);
878
879     if (search->dp)             /* stale search? */
880         closedir(search->dp);
881
882     search->dp = opendir(real_path);
883     if (search->dp == NULL)
884         return (PATH_NOT_FOUND);
885
886     ustrncpy(search->searchdir, real_path, 1024 - ustrlen(real_path));
887     search->searchend = search->searchdir;
888     while (*search->searchend)
889         ++search->searchend;
890     *search->searchend++ = '/';
891
892     search->dp->dd_fd = squirrel_fd(search->dp->dd_fd);
893
894     dta->drive = drive | 0x80;
895     to_dos_fcb(dta->pattern, slash);
896     dta->flag = attr;
897
898     return (find_next(dir, dta));
899 }
900
901 /*
902  * Continue on where find_first left off.
903  * The results will be placed in dir.
904  * DTA state area is ignored.
905  */
906 int
907 find_next(dosdir_t *dir, find_block_t *dta)
908 {
909     search_t *search = &dir_search;
910     struct dirent *d;
911     struct stat sb;
912     u_char name[16];
913
914     if (!search->dp)
915         return (NO_MORE_FILES);
916
917 #if 0
918     debug(D_REDIR, "find_next()\n");
919 #endif
920
921     while ((d = readdir(search->dp)) != 0) {
922         real_to_dos((u_char *)d->d_name, name);
923         to_dos_fcb(dir->name, name);
924 #if 0
925 printf("find_next: |%-11.11s| |%-11.11s| |%s| |%s|\n", dta->pattern, dir->name, d->d_name, name);
926 #endif
927         if (dos_match(dta->pattern, dir->name) == 0)
928             continue;
929
930         ustrcpy(search->searchend, (u_char *)d->d_name);
931         if (ustat(search->searchdir, &sb) < 0)
932             continue;
933 #if 0
934 printf("find_next: %x\n", sb.st_mode);
935 #endif
936         if (S_ISDIR(sb.st_mode)) {
937             if (!(dta->flag & DIRECTORY)) {
938                 continue;
939             }
940         }
941         dir->attr = (S_ISDIR(sb.st_mode) ? DIRECTORY : 0) |
942                     (uaccess(search->searchdir, W_OK) < 0 ? READ_ONLY_FILE : 0);
943         encode_dos_file_time(sb.st_mtime, &dir->date, &dir->time);
944         dir->start = 1;
945         dir->size = sb.st_size;
946 #if 0
947 printf("find_next: found %s\n",name);
948 #endif
949         return (0);
950     }
951     closedir(search->dp);
952     search->dp = NULL;
953     return (NO_MORE_FILES);
954 }
955
956 /*
957  * perfrom hokey DOS pattern matching.  pattern may contain the wild cards
958  * '*' and '?' only.  Follow the DOS convention that '?*', '*?' and '**' all
959  * are the same as '*'.  Also, allow '?' to match the blank padding in a
960  * name (hence, ???? matchs all of "a", "ab", "abc" and "abcd" but not "abcde")
961  * Return 1 if a match is found, 0 if not.
962  * 
963  * XXX This appears to be severely busted! (no * handling - normal?)
964  */
965 int
966 dos_match(u_char *pattern, u_char *string)
967 {
968     int i;
969
970     /*
971      * Check the base part first
972      */
973     for (i = 11; i > 0; i--) {
974         if (*pattern != '?' && *string != *pattern)
975             return (0);
976         pattern++, string++;
977     }
978     return (1);
979 }