0fd6d431cf
1. Don't use the MSDOSFS code for accessing FreeBSD distribution data. Use Robert Nordier's stand-alone DOS I/O library for the purpose. It this works as well as Robert says it does, it should drastically reduce (or even eliminate) our "I can't install from my DOS partition!" calls. 2. As a result of the above, go to stdio file descriptors for all media types. 3. Taking advantage of #2, start using libftpio for FTP transfers instead of maintaining our own parallel version of the FTP transfer code. Yay! I ripped something out for a change! #1 Submitted-By: Robert Nordier <rnordier@iafrica.com>
675 lines
16 KiB
C
675 lines
16 KiB
C
/*
|
|
* Copyright (c) 1996 Robert Nordier
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include "dosio.h"
|
|
|
|
#define SECSIZ 512 /* sector size */
|
|
#define SSHIFT 9 /* SECSIZ shift */
|
|
#define DEPSEC 16 /* directory entries per sector */
|
|
#define DSHIFT 4 /* DEPSEC shift */
|
|
#define NFATS 2 /* number of FATs */
|
|
#define DENMSZ 8 /* DE name size */
|
|
#define DEXTSZ 3 /* DE extension size */
|
|
#define DENXSZ 11 /* DE name + extension size */
|
|
#define LOCLUS 2 /* lowest cluster number */
|
|
|
|
/* DOS "BIOS Parameter Block" */
|
|
typedef struct {
|
|
u_char secsiz[2]; /* sector size */
|
|
u_char spc; /* sectors per cluster */
|
|
u_char ressec[2]; /* reserved sectors */
|
|
u_char fats; /* FATs */
|
|
u_char dirents[2]; /* root directory entries */
|
|
u_char secs[2]; /* total sectors */
|
|
u_char media; /* media descriptor */
|
|
u_char spf[2]; /* sectors per FAT */
|
|
u_char spt[2]; /* sectors per track */
|
|
u_char heads[2]; /* drive heads */
|
|
u_char hidsec[4]; /* hidden sectors */
|
|
u_char lsecs[4]; /* huge sectors */
|
|
} DOS_BPB;
|
|
|
|
/* Fixed portion of DOS boot sector */
|
|
typedef struct {
|
|
u_char jmp[3]; /* usually 80x86 'jmp' opcode */
|
|
u_char oem[8]; /* OEM name and version */
|
|
DOS_BPB bpb; /* BPB */
|
|
u_char drive; /* drive number */
|
|
u_char reserved; /* reserved */
|
|
u_char extsig; /* extended boot signature */
|
|
u_char volid[4]; /* volume ID */
|
|
u_char label[11]; /* volume label */
|
|
u_char fstype[8]; /* file system type */
|
|
} DOS_BS;
|
|
|
|
/* Supply missing "." and ".." root directory entries */
|
|
static DOS_DE dot[2] = {
|
|
{". ", " ", FA_DIR, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0}, {0x21, 0}, {0, 0}, {0, 0, 0, 0} },
|
|
{".. ", " ", FA_DIR, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0}, {0x21, 0}, {0, 0}, {0, 0, 0, 0} }
|
|
};
|
|
|
|
/* I/O error handler address */
|
|
int (*dos_ioerr)(int op) = NULL;
|
|
|
|
/* The usual conversion macros to avoid multiplication and division */
|
|
#define bytsec(n) ((n) >> (SSHIFT))
|
|
#define secbyt(s) ((u_long)(s) << (SSHIFT))
|
|
#define entsec(e) ((e) >> (DSHIFT))
|
|
#define bytblk(fs, n) ((n) >> (fs)->bshift)
|
|
#define blkbyt(fs, b) ((u_long)(b) << (fs)->bshift)
|
|
#define blksec(fs, b) ((u_long)(b) << ((fs)->bshift - (SSHIFT)))
|
|
|
|
/* Convert cluster number to offset within filesystem */
|
|
#define blkoff(fs, b) secbyt((fs)->lsndta) + blkbyt(fs, (b) - (LOCLUS))
|
|
|
|
/* Convert cluster number to logical sector number */
|
|
#define blklsn(fs, b) ((fs)->lsndta + blksec(fs, (b) - (LOCLUS)))
|
|
|
|
/* Convert cluster number to offset within FAT */
|
|
#define fatoff(fat12, c) ((u_long)(c) + ((fat12) ? (c) >> 1 : (c)))
|
|
|
|
/* Does cluster number reference a valid data cluster? */
|
|
#define okclus(fs, c) ((c) >= (LOCLUS) && (c) <= (fs)->xclus)
|
|
|
|
/* Return on error */
|
|
#define RETERR(err) { \
|
|
errno = err; \
|
|
return -1; \
|
|
}
|
|
|
|
static int dosunmount(DOS_FS *fs);
|
|
static int dosstat(DOS_FS *fs, DOS_DE *de, struct stat *sb);
|
|
static int parsebs(DOS_FS *fs, DOS_BS *bs);
|
|
static int namede(DOS_FS *fs, const char *path, DOS_DE **dep);
|
|
static DOS_DE *lookup(DOS_FS *fs, unsigned c, const u_char *nx, int *err);
|
|
static off_t fsize(DOS_FS *fs, DOS_DE *de);
|
|
static u_short fatget(DOS_FS *fs, u_short c);
|
|
static int fatend(int fat12, u_short c);
|
|
static int fatcnt(DOS_FS *fs, u_short c);
|
|
static int ioread(int fd, off_t offset, void *buf, size_t nbytes);
|
|
static int ioget(int fd, u_long lsec, void *buf, u_int nsec);
|
|
static u_char *nxname(const char *name, char **endptr);
|
|
static int sepchar(int c);
|
|
static int wildchar(int c);
|
|
static int doschar(int c);
|
|
|
|
/*
|
|
* Mount DOS filesystem
|
|
*/
|
|
int
|
|
dos_mount(DOS_FS *fs, const char *devname)
|
|
{
|
|
char buf[SECSIZ];
|
|
int err;
|
|
|
|
memset(fs, 0, sizeof(DOS_FS));
|
|
if ((fs->fd = open(devname, O_RDONLY)) == -1)
|
|
RETERR(errno);
|
|
if (!(err = ioget(fs->fd, 0, buf, 1)) &&
|
|
!(err = parsebs(fs, (DOS_BS *)buf)))
|
|
if (!(fs->fat = malloc(secbyt(fs->spf))))
|
|
err = errno;
|
|
else
|
|
err = ioget(fs->fd, fs->lsnfat, fs->fat, fs->spf);
|
|
if (err) {
|
|
dosunmount(fs);
|
|
RETERR(err);
|
|
}
|
|
fs->bsize = secbyt(fs->spc);
|
|
fs->bshift = ffs(fs->bsize) - 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Unmount mounted filesystem
|
|
*/
|
|
int
|
|
dos_unmount(DOS_FS *fs)
|
|
{
|
|
int err;
|
|
|
|
if (fs->links)
|
|
RETERR(EBUSY);
|
|
if ((err = dosunmount(fs)))
|
|
RETERR(err);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Common code shared by dos_mount() and dos_unmount()
|
|
*/
|
|
static
|
|
int dosunmount(DOS_FS *fs)
|
|
{
|
|
if (fs->fat)
|
|
free(fs->fat);
|
|
return close(fs->fd) ? errno : 0;
|
|
}
|
|
|
|
/*
|
|
* Determine free data space in filesystem (in bytes)
|
|
*/
|
|
u_long
|
|
dos_free(DOS_FS *fs)
|
|
{
|
|
unsigned n, c;
|
|
|
|
n = 0;
|
|
for (c = LOCLUS; c <= fs->xclus; c++)
|
|
if (!fatget(fs, c))
|
|
n++;
|
|
return blkbyt(fs, n);
|
|
}
|
|
|
|
/*
|
|
* Close open file
|
|
*/
|
|
int
|
|
dos_close(void *v)
|
|
{
|
|
DOS_FILE *f = v;
|
|
|
|
f->fs->links--;
|
|
free(f);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Reposition with file
|
|
*/
|
|
fpos_t
|
|
dos_seek(void *v, fpos_t offset, int whence)
|
|
{
|
|
off_t off;
|
|
u_long size;
|
|
DOS_FILE *f = v;
|
|
|
|
size = cv4(f->de.size);
|
|
switch (whence) {
|
|
case SEEK_SET:
|
|
off = 0;
|
|
break;
|
|
case SEEK_CUR:
|
|
off = f->offset;
|
|
break;
|
|
case SEEK_END:
|
|
off = size;
|
|
break;
|
|
default:
|
|
RETERR(EINVAL);
|
|
}
|
|
off += offset;
|
|
if (off < 0 || off > size)
|
|
RETERR(EINVAL);
|
|
f->offset = off;
|
|
f->c = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Read from file
|
|
*/
|
|
int
|
|
dos_read(void *v, char *buf, int nbytes)
|
|
{
|
|
off_t size;
|
|
u_long off, cnt, n;
|
|
unsigned clus, c;
|
|
int err;
|
|
DOS_FILE *f = v;
|
|
|
|
if ((size = fsize(f->fs, &f->de)) == -1)
|
|
RETERR(EBADFS);
|
|
if (nbytes > (n = size - f->offset))
|
|
nbytes = n;
|
|
off = f->offset;
|
|
if ((clus = cv2(f->de.clus)))
|
|
off &= f->fs->bsize - 1;
|
|
c = f->c;
|
|
cnt = nbytes;
|
|
while (cnt) {
|
|
n = 0;
|
|
if (!c) {
|
|
if ((c = clus))
|
|
n = bytblk(f->fs, f->offset);
|
|
} else if (!off)
|
|
n++;
|
|
while (n--) {
|
|
c = fatget(f->fs, c);
|
|
if (!okclus(f->fs, c))
|
|
RETERR(EBADFS);
|
|
}
|
|
if (!clus || (n = f->fs->bsize - off) > cnt)
|
|
n = cnt;
|
|
if ((err = ioread(f->fs->fd, (c ? blkoff(f->fs, c) :
|
|
secbyt(f->fs->lsndir)) + off,
|
|
buf, n)))
|
|
RETERR(err);
|
|
f->offset += n;
|
|
f->c = c;
|
|
off = 0;
|
|
buf += n;
|
|
cnt -= n;
|
|
}
|
|
return nbytes;
|
|
}
|
|
|
|
/*
|
|
* Get file status
|
|
*/
|
|
int
|
|
dos_stat(DOS_FS *fs, const char *path, struct stat *sb)
|
|
{
|
|
DOS_DE *de;
|
|
int err;
|
|
|
|
if ((err = namede(fs, path, &de)) || (err = dosstat(fs, de, sb)))
|
|
RETERR(err);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get file status of open file
|
|
*/
|
|
int
|
|
dos_fstat(DOS_FILE *f, struct stat *sb)
|
|
{
|
|
int err;
|
|
|
|
if ((err = dosstat(f->fs, &f->de, sb)))
|
|
RETERR(err);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* File status primitive
|
|
*/
|
|
static int
|
|
dosstat(DOS_FS *fs, DOS_DE *de, struct stat *sb)
|
|
{
|
|
|
|
memset(sb, 0, sizeof(struct stat));
|
|
sb->st_mode = (de->attr & FA_DIR) ? S_IFDIR | 0777 : S_IFREG | 0666;
|
|
if (de->attr & FA_RDONLY)
|
|
sb->st_mode &= ~0222;
|
|
if (de->attr & FA_HIDDEN)
|
|
sb->st_mode &= ~0007;
|
|
if (de->attr & FA_SYSTEM)
|
|
sb->st_mode &= ~0077;
|
|
sb->st_nlink = 1;
|
|
dos_cvtime(&sb->st_atime, cv2(de->date), cv2(de->time));
|
|
sb->st_mtime = sb->st_atime;
|
|
sb->st_ctime = sb->st_atime;
|
|
if ((sb->st_size = fsize(fs, de)) == -1)
|
|
return EBADFS;
|
|
if (!(de->attr & FA_DIR) || cv2(de->clus))
|
|
sb->st_blocks = bytblk(fs, sb->st_size + fs->bsize - 1);
|
|
sb->st_blksize = fs->bsize;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Convert from DOS date and time
|
|
*/
|
|
void
|
|
dos_cvtime(time_t *timer, u_short ddate, u_short dtime)
|
|
{
|
|
struct tm tm;
|
|
|
|
memset(&tm, 0, sizeof(tm));
|
|
tm.tm_sec = (dtime & 0x1f) << 1;
|
|
tm.tm_min = dtime >> 5 & 0x3f;
|
|
tm.tm_hour = dtime >> 11;
|
|
tm.tm_mday = ddate & 0x1f;
|
|
tm.tm_mon = (ddate >> 5 & 0xf) - 1;
|
|
tm.tm_year = 80 + (ddate >> 9);
|
|
*timer = mktime(&tm);
|
|
}
|
|
|
|
/*
|
|
* Open DOS file
|
|
*/
|
|
FILE *
|
|
dos_open(DOS_FS *fs, const char *path)
|
|
{
|
|
DOS_DE *de;
|
|
DOS_FILE *f;
|
|
u_long size;
|
|
u_int clus;
|
|
int err;
|
|
FILE *fp;
|
|
|
|
if ((err = namede(fs, path, &de)))
|
|
return NULL;
|
|
clus = cv2(de->clus);
|
|
size = cv4(de->size);
|
|
if ((clus && (!okclus(fs, clus) || (!(de->attr & FA_DIR) && !size))) ||
|
|
(!clus && !(de->attr & FA_DIR) && size))
|
|
return NULL;
|
|
f = (DOS_FILE *)malloc(sizeof(DOS_FILE));
|
|
memset(f, 0, sizeof(DOS_FILE));
|
|
f->fs = fs;
|
|
fs->links++;
|
|
f->de = *de;
|
|
fp = funopen(f, dos_read, NULL, dos_seek, dos_close);
|
|
return fp;
|
|
}
|
|
|
|
/*
|
|
* Parse DOS boot sector
|
|
*/
|
|
static int
|
|
parsebs(DOS_FS *fs, DOS_BS *bs)
|
|
{
|
|
u_long sc;
|
|
|
|
if ((bs->jmp[0] != 0xe9 && (bs->jmp[0] != 0xeb || bs->jmp[2] != 0x90)) ||
|
|
bs->bpb.media < 0xf0 ||
|
|
cv2(bs->bpb.secsiz) != SECSIZ ||
|
|
!bs->bpb.spc || (bs->bpb.spc ^ (bs->bpb.spc - 1)) < bs->bpb.spc)
|
|
return EINVAL;
|
|
fs->spf = cv2(bs->bpb.spf);
|
|
fs->dirents = cv2(bs->bpb.dirents);
|
|
fs->spc = bs->bpb.spc;
|
|
sc = cv2(bs->bpb.secs);
|
|
if (!sc && bs->extsig == 0x29)
|
|
sc = cv4(bs->bpb.lsecs);
|
|
if (!sc || bs->bpb.fats != NFATS || bs->bpb.spc > 64)
|
|
return EINVAL;
|
|
if (!fs->dirents || fs->dirents & (DEPSEC - 1))
|
|
return EINVAL;
|
|
fs->lsnfat = cv2(bs->bpb.ressec);
|
|
fs->lsndir = fs->lsnfat + (u_long)fs->spf * NFATS;
|
|
fs->lsndta = fs->lsndir + entsec(fs->dirents);
|
|
if (fs->lsndta > sc || !(sc = (sc - fs->lsndta) / fs->spc) || sc >= 0xfff6)
|
|
return EINVAL;
|
|
fs->fat12 = sc < 0xff6;
|
|
fs->xclus = sc + 1;
|
|
if (fs->spf < bytsec(fatoff(fs->fat12, fs->xclus) + SECSIZ))
|
|
return EINVAL;
|
|
if (bs->extsig == 0x29)
|
|
fs->volid = cv4(bs->volid);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Return directory entry from path
|
|
*/
|
|
static int
|
|
namede(DOS_FS *fs, const char *path, DOS_DE **dep)
|
|
{
|
|
DOS_DE *de;
|
|
u_char *nx;
|
|
int err;
|
|
|
|
err = 0;
|
|
de = dot;
|
|
if (*path == '/')
|
|
path++;
|
|
while (*path) {
|
|
if (!(nx = nxname(path, (char **)&path)))
|
|
return EINVAL;
|
|
if (!(de->attr & FA_DIR))
|
|
return ENOTDIR;
|
|
if (!(de = lookup(fs, cv2(de->clus), nx, &err)))
|
|
return err ? err : ENOENT;
|
|
if (*path == '/')
|
|
path++;
|
|
}
|
|
*dep = de;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Lookup path segment
|
|
*/
|
|
static DOS_DE *
|
|
lookup(DOS_FS *fs, unsigned c, const u_char *nx, int *err)
|
|
{
|
|
static DOS_DE dir[DEPSEC];
|
|
u_long lsec;
|
|
u_int nsec;
|
|
int s, e;
|
|
|
|
if (!c)
|
|
for (e = 0; e < 2; e++)
|
|
if (!memcmp(dot + e, nx, DENXSZ))
|
|
return dot + e;
|
|
nsec = !c ? entsec(fs->dirents) : fs->spc;
|
|
lsec = 0;
|
|
do {
|
|
if (!c && !lsec)
|
|
lsec = fs->lsndir;
|
|
else if okclus(fs, c)
|
|
lsec = blklsn(fs, c);
|
|
else {
|
|
*err = EBADFS;
|
|
return NULL;
|
|
}
|
|
for (s = 0; s < nsec; s++) {
|
|
if ((e = ioget(fs->fd, lsec + s, dir, 1))) {
|
|
*err = e;
|
|
return NULL;
|
|
}
|
|
for (e = 0; e < DEPSEC; e++) {
|
|
if (!*dir[e].name)
|
|
return NULL;
|
|
if (*dir[e].name == 0xe5 || dir[e].attr & FA_LABEL)
|
|
continue;
|
|
if (!memcmp(dir + e, nx, DENXSZ))
|
|
return dir + e;
|
|
}
|
|
}
|
|
} while (c && !fatend(fs->fat12, c = fatget(fs, c)));
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Return size of file in bytes
|
|
*/
|
|
static off_t
|
|
fsize(DOS_FS *fs, DOS_DE *de)
|
|
{
|
|
u_long size;
|
|
u_int c;
|
|
int n;
|
|
|
|
if (!(size = cv4(de->size)) && de->attr & FA_DIR)
|
|
if (!(c = cv2(de->clus)))
|
|
size = fs->dirents * sizeof(DOS_DE);
|
|
else {
|
|
if ((n = fatcnt(fs, c)) == -1)
|
|
return n;
|
|
size = blkbyt(fs, n);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/*
|
|
* Return next cluster in cluster chain
|
|
*/
|
|
static u_short
|
|
fatget(DOS_FS *fs, u_short c)
|
|
{
|
|
u_short x;
|
|
|
|
x = cv2(fs->fat + fatoff(fs->fat12, c));
|
|
return fs->fat12 ? c & 1 ? x >> 4 : x & 0xfff : x;
|
|
}
|
|
|
|
/*
|
|
* Count number of clusters in chain
|
|
*/
|
|
static int
|
|
fatcnt(DOS_FS *fs, u_short c)
|
|
{
|
|
int n;
|
|
|
|
for (n = 0; okclus(fs, c); n++)
|
|
c = fatget(fs, c);
|
|
return fatend(fs->fat12, c) ? n : -1;
|
|
}
|
|
|
|
/*
|
|
* Is cluster an end-of-chain marker?
|
|
*/
|
|
static int
|
|
fatend(int fat12, u_short c)
|
|
{
|
|
return c > (fat12 ? 0xff7 : 0xfff7) || c == 0xfff0;
|
|
}
|
|
|
|
/*
|
|
* Offset-based I/O primitive
|
|
*/
|
|
static int
|
|
ioread(int fd, off_t offset, void *buf, size_t nbytes)
|
|
{
|
|
char tmp[SECSIZ];
|
|
u_int off, n;
|
|
int err;
|
|
|
|
if ((off = offset & (SECSIZ - 1))) {
|
|
offset -= off;
|
|
if ((err = ioget(fd, bytsec(offset), tmp, 1)))
|
|
return err;
|
|
offset += SECSIZ;
|
|
if ((n = SECSIZ - off) > nbytes)
|
|
n = nbytes;
|
|
memcpy(buf, tmp + off, n);
|
|
buf += n;
|
|
nbytes -= n;
|
|
}
|
|
n = nbytes & (SECSIZ - 1);
|
|
if (nbytes -= n) {
|
|
if ((err = ioget(fd, bytsec(offset), buf, bytsec(nbytes))))
|
|
return err;
|
|
offset += nbytes;
|
|
buf += nbytes;
|
|
}
|
|
if (n) {
|
|
if ((err = ioget(fd, bytsec(offset), tmp, 1)))
|
|
return err;
|
|
memcpy(buf, tmp, n);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Sector-based I/O primitive
|
|
*/
|
|
static int
|
|
ioget(int fd, u_long lsec, void *buf, u_int nsec)
|
|
{
|
|
size_t nbytes;
|
|
ssize_t n;
|
|
|
|
nbytes = secbyt(nsec);
|
|
do {
|
|
if (lseek(fd, secbyt(lsec), SEEK_SET) == -1)
|
|
return errno;
|
|
n = read(fd, buf, nbytes);
|
|
} while (n == -1 && errno == EIO && dos_ioerr && dos_ioerr(0));
|
|
if (n != nbytes)
|
|
return n == -1 ? errno : EIO;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Convert name to DOS directory (name + extension) format
|
|
*/
|
|
static u_char *
|
|
nxname(const char *name, char **endptr)
|
|
{
|
|
static u_char nx[DENXSZ];
|
|
int i;
|
|
|
|
memset(nx, ' ', sizeof(nx));
|
|
for (i = 0; i < DENMSZ && doschar(*name); i++)
|
|
nx[i] = toupper(*name++);
|
|
if (i) {
|
|
if (i == DENMSZ)
|
|
while (!sepchar(*name))
|
|
name++;
|
|
if (*name == '.') {
|
|
name++;
|
|
for (i = 0; i < DEXTSZ && doschar(*name); i++)
|
|
nx[DENMSZ + i] = toupper(*name++);
|
|
if (i == DEXTSZ)
|
|
while(!sepchar(*name))
|
|
name++;
|
|
}
|
|
} else if (*name == '.') {
|
|
nx[0] = *name++;
|
|
if (*name == '.')
|
|
nx[1] = *name++;
|
|
}
|
|
if ((*name && *name != '/') || *nx == ' ')
|
|
return NULL;
|
|
if (*nx == 0xe5)
|
|
*nx = 5;
|
|
*endptr = (char *)name;
|
|
return nx;
|
|
}
|
|
|
|
/*
|
|
* Is character a path-separator?
|
|
*/
|
|
static int
|
|
sepchar(int c)
|
|
{
|
|
return !wildchar(c) && !doschar(c);
|
|
}
|
|
|
|
/*
|
|
* Is character a wildcard?
|
|
*/
|
|
static int
|
|
wildchar(int c)
|
|
{
|
|
return c == '*' || c == '?';
|
|
}
|
|
|
|
/*
|
|
* Is character valid in a DOS name?
|
|
*/
|
|
static int
|
|
doschar(int c)
|
|
{
|
|
return c & 0x80 || (c >= ' ' && !strchr("\"*+,./:;<=>?[\\]|", c));
|
|
}
|