767 lines
15 KiB
C
767 lines
15 KiB
C
/*
|
|
* DOS-FS
|
|
* NOV 1993 Erik Bos (erik@(trashcan.)hacktic.nl)
|
|
*
|
|
* FindFile by Bob, hacked for dos & unixpaths by Erik.
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <pwd.h>
|
|
#include <dirent.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
|
|
#if defined(__linux__) || defined(sun)
|
|
#include <sys/vfs.h>
|
|
#endif
|
|
#if defined(__NetBSD__) || defined(__FreeBSD__)
|
|
#include <sys/types.h>
|
|
#include <sys/mount.h>
|
|
#endif
|
|
|
|
#include "windows.h"
|
|
#include "msdos.h"
|
|
#include "prototypes.h"
|
|
#include "autoconf.h"
|
|
|
|
/* #define DEBUG */
|
|
|
|
#define WINE_INI_USER "~/.winerc"
|
|
#define MAX_OPEN_DIRS 16
|
|
#define MAX_DOS_DRIVES 26
|
|
|
|
extern char WindowsDirectory[256], SystemDirectory[256],TempDirectory[256];
|
|
|
|
char WindowsPath[256];
|
|
|
|
static int CurrentDrive = 2;
|
|
|
|
struct DosDriveStruct { /* eg: */
|
|
char *rootdir; /* /usr/windows */
|
|
char cwd[256]; /* / */
|
|
char label[13]; /* DRIVE-A */
|
|
unsigned int serialnumber; /* ABCD5678 */
|
|
int disabled; /* 0 */
|
|
};
|
|
|
|
static struct DosDriveStruct DosDrives[MAX_DOS_DRIVES];
|
|
static struct dosdirent DosDirs[MAX_OPEN_DIRS];
|
|
|
|
static void ExpandTildeString(char *s)
|
|
{
|
|
struct passwd *entry;
|
|
char temp[1024], *ptr = temp;
|
|
|
|
strcpy(temp, s);
|
|
while (*ptr)
|
|
{
|
|
if (*ptr != '~') {
|
|
*s++ = *ptr++;
|
|
continue;
|
|
}
|
|
ptr++;
|
|
if ( (entry = getpwuid(getuid())) == NULL) {
|
|
continue;
|
|
}
|
|
strcpy(s, entry->pw_dir);
|
|
s += strlen(entry->pw_dir);
|
|
}
|
|
}
|
|
|
|
void ChopOffSlash(char *path)
|
|
{
|
|
if (path[strlen(path)-1] == '/' || path[strlen(path)-1] == '\\')
|
|
path[strlen(path)-1] = '\0';
|
|
}
|
|
|
|
void DOS_InitFS(void)
|
|
{
|
|
int x;
|
|
char drive[2], temp[256], *ptr;
|
|
|
|
GetPrivateProfileString("wine", "windows", "c:\\windows",
|
|
WindowsDirectory, sizeof(WindowsDirectory), WINE_INI);
|
|
|
|
GetPrivateProfileString("wine", "system", "c:\\windows\\system",
|
|
SystemDirectory, sizeof(SystemDirectory), WINE_INI);
|
|
|
|
GetPrivateProfileString("wine", "temp", "c:\\windows",
|
|
TempDirectory, sizeof(TempDirectory), WINE_INI);
|
|
|
|
GetPrivateProfileString("wine", "path", "c:\\windows;c:\\windows\\system",
|
|
WindowsPath, sizeof(WindowsPath), WINE_INI);
|
|
|
|
ChopOffSlash(WindowsDirectory);
|
|
ToDos(WindowsDirectory);
|
|
|
|
ChopOffSlash(SystemDirectory);
|
|
ToDos(SystemDirectory);
|
|
|
|
ChopOffSlash(TempDirectory);
|
|
ToDos(TempDirectory);
|
|
|
|
ToDos(WindowsPath);
|
|
ExpandTildeString(WindowsPath);
|
|
|
|
for (x=0; x!=MAX_DOS_DRIVES; x++) {
|
|
DosDrives[x].serialnumber = (0xEB0500L | x);
|
|
|
|
drive[0] = 'A' + x;
|
|
drive[1] = '\0';
|
|
GetPrivateProfileString("drives", drive, "*", temp, sizeof(temp), WINE_INI);
|
|
if (!strcmp(temp, "*") || *temp == '\0') {
|
|
DosDrives[x].rootdir = NULL;
|
|
DosDrives[x].cwd[0] = '\0';
|
|
DosDrives[x].label[0] = '\0';
|
|
DosDrives[x].disabled = 1;
|
|
continue;
|
|
}
|
|
ExpandTildeString(temp);
|
|
if ((ptr = (char *) malloc(strlen(temp)+1)) == NULL) {
|
|
fprintf(stderr,"DOSFS: can't malloc for drive info!");
|
|
continue;
|
|
}
|
|
ChopOffSlash(temp);
|
|
DosDrives[x].rootdir = ptr;
|
|
strcpy(DosDrives[x].rootdir, temp);
|
|
strcpy(DosDrives[x].cwd, "/windows/");
|
|
strcpy(DosDrives[x].label, "DRIVE-");
|
|
strcat(DosDrives[x].label, drive);
|
|
DosDrives[x].disabled = 0;
|
|
}
|
|
DOS_SetDefaultDrive(2);
|
|
|
|
for (x=0; x!=MAX_DOS_DRIVES; x++) {
|
|
if (DosDrives[x].rootdir != NULL) {
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "DOSFS: %c: => %-40s %s %s %X %d\n",
|
|
'A'+x,
|
|
DosDrives[x].rootdir,
|
|
DosDrives[x].cwd,
|
|
DosDrives[x].label,
|
|
DosDrives[x].serialnumber,
|
|
DosDrives[x].disabled
|
|
);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
for (x=0; x!=MAX_OPEN_DIRS ; x++)
|
|
DosDirs[x].inuse = 0;
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"wine.ini = %s\n",WINE_INI);
|
|
fprintf(stderr,"win.ini = %s\n",WIN_INI);
|
|
fprintf(stderr,"windir = %s\n",WindowsDirectory);
|
|
fprintf(stderr,"sysdir = %s\n",SystemDirectory);
|
|
fprintf(stderr,"tempdir = %s\n",TempDirectory);
|
|
fprintf(stderr,"path = %s\n",WindowsPath);
|
|
#endif
|
|
}
|
|
|
|
WORD DOS_GetEquipment(void)
|
|
{
|
|
WORD equipment;
|
|
int diskdrives = 0;
|
|
|
|
/* borrowed from Ralph Brown's interrupt lists
|
|
|
|
bits 15-14: number of parallel devices
|
|
bit 13: [Conv] Internal modem
|
|
bit 12: reserved
|
|
bits 11- 9: number of serial devices
|
|
bit 8: reserved
|
|
bits 7- 6: number of diskette drives minus one
|
|
bits 5- 4: Initial video mode:
|
|
00b = EGA,VGA,PGA
|
|
01b = 40 x 25 color
|
|
10b = 80 x 25 color
|
|
11b = 80 x 25 mono
|
|
bit 3: reserved
|
|
bit 2: [PS] =1 if pointing device
|
|
[non-PS] reserved
|
|
bit 1: =1 if math co-processor
|
|
bit 0: =1 if diskette available for boot
|
|
*/
|
|
|
|
if (DosDrives[0].rootdir != NULL)
|
|
diskdrives++;
|
|
if (DosDrives[1].rootdir != NULL)
|
|
diskdrives++;
|
|
if (diskdrives)
|
|
diskdrives--;
|
|
|
|
equipment = (diskdrives << 6) || 0x02;
|
|
|
|
return (equipment);
|
|
}
|
|
|
|
int DOS_ValidDrive(int drive)
|
|
{
|
|
/*
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"ValidDrive %c (%d)\n",'A'+drive,drive);
|
|
#endif
|
|
*/
|
|
if (drive >= MAX_DOS_DRIVES)
|
|
return 0;
|
|
if (DosDrives[drive].rootdir == NULL)
|
|
return 0;
|
|
if (DosDrives[drive].disabled)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int DOS_GetDefaultDrive(void)
|
|
{
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"GetDefaultDrive (%c)\n",'A'+CurrentDrive);
|
|
#endif
|
|
|
|
return( CurrentDrive);
|
|
}
|
|
|
|
void DOS_SetDefaultDrive(int drive)
|
|
{
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"SetDefaultDrive to %c:\n",'A'+drive);
|
|
#endif
|
|
|
|
if (DOS_ValidDrive(drive))
|
|
CurrentDrive = drive;
|
|
}
|
|
|
|
void ToUnix(char *s)
|
|
{
|
|
/* \WINDOWS\\SYSTEM => /windows/system */
|
|
|
|
char *p;
|
|
|
|
for (p = s; *p; p++)
|
|
{
|
|
if (*p != '\\')
|
|
*s++ = tolower(*p);
|
|
else {
|
|
*s++ = '/';
|
|
if (*(p+1) == '/' || *(p+1) == '\\')
|
|
p++;
|
|
}
|
|
}
|
|
*s = '\0';
|
|
}
|
|
|
|
void ToDos(char *s)
|
|
{
|
|
/* /windows//system => \WINDOWS\SYSTEM */
|
|
|
|
char *p;
|
|
for (p = s; *p; p++)
|
|
{
|
|
if (*p != '/')
|
|
*s++ = toupper(*p);
|
|
else {
|
|
*s++ = '\\';
|
|
if (*s == '/' || *s == '\\')
|
|
p++;
|
|
}
|
|
}
|
|
*s = '\0';
|
|
}
|
|
|
|
int DOS_DisableDrive(int drive)
|
|
{
|
|
if (drive >= MAX_DOS_DRIVES)
|
|
return 0;
|
|
if (DosDrives[drive].rootdir == NULL)
|
|
return 0;
|
|
|
|
DosDrives[drive].disabled = 1;
|
|
return 1;
|
|
}
|
|
|
|
int DOS_EnableDrive(int drive)
|
|
{
|
|
if (drive >= MAX_DOS_DRIVES)
|
|
return 0;
|
|
if (DosDrives[drive].rootdir == NULL)
|
|
return 0;
|
|
|
|
DosDrives[drive].disabled = 0;
|
|
return 1;
|
|
}
|
|
|
|
static void GetUnixDirName(char *rootdir, char *name)
|
|
{
|
|
int filename = 1;
|
|
char *nameptr, *cwdptr;
|
|
|
|
cwdptr = rootdir + strlen(rootdir);
|
|
nameptr = name;
|
|
/*
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"GetUnixDirName: %s <=> %s => ",rootdir, name);
|
|
#endif
|
|
*/
|
|
while (*nameptr) {
|
|
if (*nameptr == '.' & !filename) {
|
|
nameptr++;
|
|
if (*nameptr == '\0') {
|
|
cwdptr--;
|
|
break;
|
|
}
|
|
if (*nameptr == '.') {
|
|
cwdptr--;
|
|
while (cwdptr != rootdir) {
|
|
cwdptr--;
|
|
if (*cwdptr == '/') {
|
|
*(cwdptr+1) = '\0';
|
|
goto next;
|
|
}
|
|
}
|
|
goto next;
|
|
}
|
|
if (*nameptr == '\\' || *nameptr == '/') {
|
|
next: nameptr++;
|
|
filename = 0;
|
|
continue;
|
|
}
|
|
}
|
|
if (*nameptr == '\\' || *nameptr == '/') {
|
|
filename = 0;
|
|
if (nameptr == name)
|
|
cwdptr = rootdir;
|
|
*cwdptr++='/';
|
|
nameptr++;
|
|
continue;
|
|
}
|
|
filename = 1;
|
|
*cwdptr++ = *nameptr++;
|
|
}
|
|
*cwdptr = '\0';
|
|
|
|
ToUnix(rootdir);
|
|
/*
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"%s\n", rootdir);
|
|
#endif
|
|
*/
|
|
}
|
|
|
|
char *GetUnixFileName(char *dosfilename)
|
|
{
|
|
/* a:\windows\system.ini => /dos/windows/system.ini */
|
|
|
|
char temp[256];
|
|
int drive;
|
|
|
|
if (dosfilename[1] == ':')
|
|
{
|
|
drive = (islower(*dosfilename) ? toupper(*dosfilename) : *dosfilename) - 'A';
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return NULL;
|
|
else
|
|
dosfilename+=2;
|
|
} else
|
|
drive = CurrentDrive;
|
|
|
|
strcpy(temp, DosDrives[drive].rootdir);
|
|
strcat(temp, DosDrives[drive].cwd);
|
|
GetUnixDirName(temp + strlen(DosDrives[drive].rootdir), dosfilename);
|
|
|
|
ToUnix(temp);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"GetUnixFileName: %s => %s\n", dosfilename, temp);
|
|
#endif
|
|
|
|
return(temp);
|
|
}
|
|
|
|
char *DOS_GetCurrentDir(int drive)
|
|
{
|
|
/* should return 'WINDOWS\SYSTEM' */
|
|
|
|
char temp[256];
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
strcpy(temp, DosDrives[drive].cwd);
|
|
ToDos(temp);
|
|
fprintf(stderr, "2 %s\n", temp);
|
|
ChopOffSlash(temp);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_GetCWD: %c: %s\n",'A'+drive, temp + 1);
|
|
#endif
|
|
return (temp + 1);
|
|
}
|
|
|
|
int DOS_ChangeDir(int drive, char *dirname)
|
|
{
|
|
char temp[256];
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
strcpy(temp, dirname);
|
|
ToUnix(temp);
|
|
|
|
GetUnixDirName(DosDrives[drive].cwd, temp);
|
|
strcat(DosDrives[drive].cwd,"/");
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_SetCWD: %c: %s\n",'A'+drive, DosDrives[drive].cwd);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
int DOS_MakeDir(int drive, char *dirname)
|
|
{
|
|
char temp[256];
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
strcpy(temp, DosDrives[drive].cwd);
|
|
GetUnixDirName(temp, dirname);
|
|
strcat(DosDrives[drive].cwd,"/");
|
|
|
|
ToUnix(temp);
|
|
mkdir(temp,0);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_MakeDir: %c:\%s => %s",'A'+drive, dirname, temp);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
int DOS_GetSerialNumber(int drive, unsigned long *serialnumber)
|
|
{
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
*serialnumber = DosDrives[drive].serialnumber;
|
|
return 1;
|
|
}
|
|
|
|
int DOS_SetSerialNumber(int drive, unsigned long serialnumber)
|
|
{
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
DosDrives[drive].serialnumber = serialnumber;
|
|
return 1;
|
|
}
|
|
|
|
char *DOS_GetVolumeLabel(int drive)
|
|
{
|
|
if (!DOS_ValidDrive(drive))
|
|
return NULL;
|
|
|
|
return (DosDrives[drive].label);
|
|
}
|
|
|
|
int DOS_SetVolumeLabel(int drive, char *label)
|
|
{
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
strncpy(DosDrives[drive].label, label, 8);
|
|
return 1;
|
|
}
|
|
|
|
int DOS_GetFreeSpace(int drive, long *size, long *available)
|
|
{
|
|
struct statfs info;
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
if (statfs(DosDrives[drive].rootdir, &info) < 0) {
|
|
fprintf(stderr,"dosfs: cannot do statfs(%s)\n",DosDrives[drive].rootdir);
|
|
return 0;
|
|
}
|
|
|
|
*size = info.f_bsize * info.f_blocks / 1024;
|
|
*available = info.f_bavail * info.f_bsize / 1024;
|
|
|
|
return 1;
|
|
}
|
|
|
|
char *FindFile(char *buffer, int buflen, char *filename, char **extensions,
|
|
char *path)
|
|
{
|
|
char *workingpath, *dirname, *rootname, **e;
|
|
DIR *d;
|
|
struct dirent *f;
|
|
int rootnamelen, found = 0;
|
|
struct stat filestat;
|
|
|
|
if (strchr(filename, '\\') != NULL)
|
|
{
|
|
strncpy(buffer, GetUnixFileName(filename), buflen);
|
|
ToUnix(buffer);
|
|
return buffer;
|
|
}
|
|
|
|
if (strchr(filename, '/') != NULL)
|
|
{
|
|
strncpy(buffer, filename, buflen);
|
|
return buffer;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"FindFile: looking for %s\n", filename);
|
|
#endif
|
|
|
|
rootnamelen = strlen(filename);
|
|
if ((rootname = malloc(rootnamelen + 1)) == NULL)
|
|
return NULL;
|
|
strcpy(rootname, filename);
|
|
ToUnix(rootname);
|
|
|
|
if ((workingpath = malloc(strlen(path) + 1)) == NULL)
|
|
return NULL;
|
|
strcpy(workingpath, path);
|
|
|
|
for(dirname = strtok(workingpath, ";");
|
|
dirname != NULL;
|
|
dirname = strtok(NULL, ";"))
|
|
{
|
|
if (strchr(dirname, '\\') != NULL)
|
|
d = opendir( GetUnixFileName(dirname) );
|
|
else
|
|
d = opendir( dirname );
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"in %s\n",dirname);
|
|
#endif
|
|
|
|
if (d != NULL)
|
|
{
|
|
while ((f = readdir(d)) != NULL)
|
|
{
|
|
if (strncasecmp(rootname, f->d_name, rootnamelen) == 0)
|
|
{
|
|
if (extensions == NULL ||
|
|
strcasecmp(rootname, f->d_name) == 0)
|
|
found = 1;
|
|
else
|
|
if (f->d_name[rootnamelen] == '.')
|
|
for (e = extensions; *e != NULL; e++)
|
|
if (strcasecmp(*e, f->d_name + rootnamelen + 1)
|
|
== 0)
|
|
{
|
|
found = 1;
|
|
break;
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
if (strchr(dirname, '\\') != NULL)
|
|
strncpy(buffer, GetUnixFileName(dirname), buflen);
|
|
else
|
|
strncpy(buffer, dirname, buflen);
|
|
|
|
strncat(buffer, "/", buflen - strlen(buffer));
|
|
strncat(buffer, f->d_name, buflen - strlen(buffer));
|
|
|
|
stat(buffer, &filestat);
|
|
if (S_ISREG(filestat.st_mode)) {
|
|
closedir(d);
|
|
free(rootname);
|
|
ToUnix(buffer);
|
|
return buffer;
|
|
} else
|
|
found = 0;
|
|
}
|
|
}
|
|
}
|
|
closedir(d);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**********************************************************************
|
|
* WineIniFileName
|
|
*/
|
|
char *WineIniFileName(void)
|
|
{
|
|
int fd;
|
|
static char *filename = NULL;
|
|
char name[256];
|
|
|
|
if (filename)
|
|
return filename;
|
|
|
|
strcpy(name, WINE_INI_USER);
|
|
ExpandTildeString(name);
|
|
if ((fd = open(name, O_RDONLY)) != -1) {
|
|
close(fd);
|
|
filename = malloc(strlen(name) + 1);
|
|
strcpy(filename, name);
|
|
return(filename);
|
|
}
|
|
if ((fd = open(WINE_INI_GLOBAL, O_RDONLY)) != -1) {
|
|
close(fd);
|
|
filename = malloc(strlen(WINE_INI_GLOBAL) + 1);
|
|
strcpy(filename, WINE_INI_GLOBAL);
|
|
return(filename);
|
|
}
|
|
fprintf(stderr,"wine: can't open configuration file %s or %s !\n",
|
|
WINE_INI_GLOBAL, WINE_INI_USER);
|
|
exit(1);
|
|
}
|
|
|
|
char *WinIniFileName(void)
|
|
{
|
|
static char *name = NULL;
|
|
|
|
if (name)
|
|
return name;
|
|
|
|
name = malloc(1024);
|
|
|
|
strcpy(name, GetUnixFileName(WindowsDirectory));
|
|
strcat(name, "/");
|
|
strcat(name, "win.ini");
|
|
ToUnix(name);
|
|
|
|
name = realloc(name, strlen(name) + 1);
|
|
|
|
return name;
|
|
}
|
|
|
|
static int match(char *filename, char *filemask)
|
|
{
|
|
int x, masklength = strlen(filemask);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "match: %s, %s\n", filename, filemask);
|
|
#endif
|
|
|
|
for (x = 0; x != masklength ; x++) {
|
|
/* printf("(%c%c) ", *filename, filemask[x]);
|
|
*/
|
|
if (!*filename)
|
|
/* stop if EOFname */
|
|
return 1;
|
|
|
|
if (filemask[x] == '?') {
|
|
/* skip the next char */
|
|
filename++;
|
|
continue;
|
|
}
|
|
|
|
if (filemask[x] == '*') {
|
|
/* skip each char until '.' or EOFname */
|
|
while (*filename && *filename !='.')
|
|
filename++;
|
|
continue;
|
|
}
|
|
if (filemask[x] != *filename)
|
|
return 0;
|
|
|
|
filename++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
struct dosdirent *DOS_opendir(char *dosdirname)
|
|
{
|
|
int x,y;
|
|
char *unixdirname;
|
|
char temp[256];
|
|
|
|
for (x=0; x != MAX_OPEN_DIRS && DosDirs[x].inuse; x++)
|
|
;
|
|
|
|
if (x == MAX_OPEN_DIRS)
|
|
return NULL;
|
|
|
|
if ((unixdirname = GetUnixFileName(dosdirname)) == NULL)
|
|
return NULL;
|
|
|
|
strcpy(temp, unixdirname);
|
|
y = strlen(temp);
|
|
while (y--)
|
|
{
|
|
if (temp[y] == '/')
|
|
{
|
|
temp[y++] = '\0';
|
|
strcpy(DosDirs[x].filemask, temp +y);
|
|
ToDos(DosDirs[x].filemask);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_opendir: %s -> %s\n", unixdirname, temp);
|
|
#endif
|
|
|
|
DosDirs[x].inuse = 1;
|
|
strcpy(DosDirs[x].unixpath, temp);
|
|
|
|
if ((DosDirs[x].ds = opendir(temp)) == NULL)
|
|
return NULL;
|
|
|
|
return &DosDirs[x];
|
|
}
|
|
|
|
|
|
struct dosdirent *DOS_readdir(struct dosdirent *de)
|
|
{
|
|
char temp[256];
|
|
struct dirent *d;
|
|
struct stat st;
|
|
|
|
if (!de->inuse)
|
|
return NULL;
|
|
|
|
do {
|
|
if ((d = readdir(de->ds)) == NULL)
|
|
{
|
|
closedir(de->ds);
|
|
de->inuse = 0;
|
|
return de;
|
|
}
|
|
|
|
strcpy(de->filename, d->d_name);
|
|
if (d->d_reclen > 12)
|
|
de->filename[12] = '\0';
|
|
|
|
ToDos(de->filename);
|
|
} while ( !match(de->filename, de->filemask) );
|
|
|
|
strcpy(temp,de->unixpath);
|
|
strcat(temp,"/");
|
|
strcat(temp,de->filename);
|
|
ToUnix(temp);
|
|
|
|
stat (temp, &st);
|
|
de->attribute = 0x0;
|
|
if S_ISDIR(st.st_mode)
|
|
de->attribute |= FA_DIREC;
|
|
|
|
de->filesize = st.st_size;
|
|
de->filetime = st.st_mtime;
|
|
|
|
return de;
|
|
}
|
|
|
|
void DOS_closedir(struct dosdirent *de)
|
|
{
|
|
if (de->inuse)
|
|
{
|
|
closedir(de->ds);
|
|
de->inuse = 0;
|
|
}
|
|
}
|