803 lines
15 KiB
C
803 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>
|
|
#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 <dirent.h>
|
|
#include "windows.h"
|
|
#include "wine.h"
|
|
#include "int21.h"
|
|
|
|
/*
|
|
#define DEBUG
|
|
*/
|
|
#define MAX_OPEN_DIRS 16
|
|
|
|
extern char WindowsDirectory[256], SystemDirectory[256],TempDirectory[256];
|
|
|
|
char WindowsPath[256];
|
|
|
|
void DOS_DeInitFS(void);
|
|
int DOS_SetDefaultDrive(int);
|
|
char *GetDirectUnixFileName(char *);
|
|
void ToDos(char *);
|
|
void ToUnix(char *);
|
|
|
|
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 */
|
|
};
|
|
|
|
struct DosDriveStruct DosDrives[MAX_DOS_DRIVES];
|
|
|
|
struct dosdirent DosDirs[MAX_OPEN_DIRS];
|
|
|
|
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);
|
|
|
|
ToDos(WindowsDirectory);
|
|
ToDos(SystemDirectory);
|
|
ToDos(TempDirectory);
|
|
ToDos(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;
|
|
}
|
|
|
|
if ((ptr = (char *) malloc(strlen(temp)+1)) == NULL) {
|
|
fprintf(stderr,"DOSFS: can't malloc for drive info!");
|
|
continue;
|
|
}
|
|
if (temp[strlen(temp)-1] == '/')
|
|
temp[strlen(temp)] = '\0';
|
|
DosDrives[x].rootdir = ptr;
|
|
strcpy(DosDrives[x].rootdir, temp);
|
|
strcpy(DosDrives[x].cwd, "/");
|
|
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
|
|
}
|
|
|
|
void DOS_DeInitFS(void)
|
|
{
|
|
int x;
|
|
|
|
for (x=0; x!=MAX_DOS_DRIVES ; x++)
|
|
if (DosDrives[x].rootdir != NULL) {
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, "DOSFS: %c: => %s %s %s %X %d\n",
|
|
'A'+x,
|
|
DosDrives[x].rootdir,
|
|
DosDrives[x].cwd,
|
|
DosDrives[x].label,
|
|
DosDrives[x].serialnumber,
|
|
DosDrives[x].disabled
|
|
);
|
|
free(DosDrives[x].rootdir);
|
|
#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);
|
|
}
|
|
|
|
int DOS_SetDefaultDrive(int drive)
|
|
{
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"SetDefaultDrive to %c:\n",'A'+drive);
|
|
#endif
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 1;
|
|
|
|
CurrentDrive = drive;
|
|
}
|
|
|
|
void ToUnix(char *s)
|
|
{
|
|
while (*s) {
|
|
if (*s == '/')
|
|
break;
|
|
if (*s == '\\')
|
|
*s = '/';
|
|
if (isupper(*s))
|
|
*s = tolower(*s);
|
|
s++;
|
|
}
|
|
}
|
|
|
|
void ToDos(char *s)
|
|
{
|
|
while (*s) {
|
|
if (*s == '/')
|
|
*s = '\\';
|
|
if (islower(*s))
|
|
*s = toupper(*s);
|
|
s++;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void GetUnixDirName(char *rootdir, char *name)
|
|
{
|
|
int filename;
|
|
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 *GetDirectUnixFileName(char *dosfilename)
|
|
{
|
|
/* a:\windows\system.ini => /dos/windows/system.ini */
|
|
|
|
static char temp[256];
|
|
int drive;
|
|
char x;
|
|
|
|
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,"GetDirectUnixFileName: %c:%s => %s\n",'A'+ drive, dosfilename, temp);
|
|
#endif
|
|
|
|
return(temp);
|
|
}
|
|
|
|
char *GetUnixFileName(char *dosfilename)
|
|
{
|
|
char *dirname, *unixname, workingpath[256], temp[256];
|
|
|
|
/* check if program specified a path */
|
|
|
|
if (*dosfilename == '.' || *dosfilename == '\\')
|
|
return( GetDirectUnixFileName(dosfilename) );
|
|
|
|
/* nope, lets find it */
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"GetUnixFileName: %s\n",dosfilename);
|
|
#endif
|
|
|
|
strcpy(workingpath, WindowsPath);
|
|
|
|
for(dirname = strtok(workingpath, ";") ;
|
|
dirname != NULL;
|
|
dirname = strtok(NULL, ";"))
|
|
{
|
|
strcpy(temp,dirname);
|
|
if (temp[strlen(temp)-1] != '\\')
|
|
strcat(temp,"\\");
|
|
strcat(temp,dosfilename);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"trying %s\n",temp);
|
|
#endif
|
|
|
|
if ( (unixname = GetDirectUnixFileName(temp)) != NULL)
|
|
return unixname;
|
|
}
|
|
puts("FAILED!");
|
|
return NULL;
|
|
}
|
|
|
|
char *DOS_GetCurrentDir(int drive, char *dirname)
|
|
{
|
|
/* should return 'windows\system' */
|
|
|
|
char temp[256];
|
|
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
strcpy(temp, DosDrives[drive].cwd);
|
|
ToDos(temp);
|
|
|
|
if (temp[strlen(temp)-1] == '\\')
|
|
temp[strlen(temp)] = '\0';
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_GetCWD: %c:\%s",'A'+drive, temp+1);
|
|
#endif
|
|
return (temp+1);
|
|
}
|
|
|
|
int DOS_ChangeDir(int drive, char *dirname)
|
|
{
|
|
if (!DOS_ValidDrive(drive))
|
|
return 0;
|
|
|
|
GetUnixDirName(DosDrives[drive].cwd, dirname);
|
|
strcat(DosDrives[drive].cwd,"/");
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"DOS_SetCWD: %c:\%s",'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
|
|
}
|
|
|
|
/*
|
|
void main(void)
|
|
{
|
|
strcpy(DosDrives[0].cwd, "1/2/3/");
|
|
|
|
puts(DosDrives[0].cwd);
|
|
ChangeDir(0,"..");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
ChangeDir(0,"..\\..");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
ChangeDir(0,".");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
ChangeDir(0,"test");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
ChangeDir(0,"\\qwerty\\ab");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
ChangeDir(0,"erik\\.\\bos\\..\\24");
|
|
puts(DosDrives[0].cwd);
|
|
|
|
}
|
|
*/
|
|
|
|
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;
|
|
}
|
|
|
|
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 *rootname, char **extensions,
|
|
char *path)
|
|
{
|
|
char *workingpath;
|
|
char *dirname;
|
|
DIR *d;
|
|
struct dirent *f;
|
|
char **e;
|
|
int rootnamelen;
|
|
int found = 0;
|
|
|
|
|
|
if (strchr(rootname, '\\') != NULL)
|
|
{
|
|
strncpy(buffer, GetDirectUnixFileName(rootname), buflen);
|
|
ToUnix(buffer);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"FindFile: %s -> %s\n",rootname,buffer);
|
|
#endif
|
|
|
|
return buffer;
|
|
}
|
|
|
|
if (strchr(rootname, '/') != NULL)
|
|
{
|
|
strncpy(buffer, rootname, buflen);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"FindFile: %s -> %s\n",rootname,buffer);
|
|
#endif
|
|
|
|
return buffer;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr,"FindFile: looking for %s\n",rootname);
|
|
#endif
|
|
|
|
ToUnix(rootname);
|
|
|
|
rootnamelen = strlen(rootname);
|
|
workingpath = malloc(strlen(path) + 1);
|
|
if (workingpath == NULL)
|
|
return NULL;
|
|
strcpy(workingpath, path);
|
|
|
|
for(dirname = strtok(workingpath, ";");
|
|
dirname != NULL;
|
|
dirname = strtok(NULL, ";"))
|
|
{
|
|
if (strchr(dirname, '\\')!=NULL)
|
|
d = opendir( GetDirectUnixFileName(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, GetDirectUnixFileName(dirname), buflen);
|
|
else
|
|
strncpy(buffer, dirname, buflen);
|
|
|
|
if (buffer[strlen(buffer)-1]!='/')
|
|
strncat(buffer, "/", buflen - strlen(buffer));
|
|
|
|
strncat(buffer, f->d_name, buflen - strlen(buffer));
|
|
closedir(d);
|
|
|
|
ToUnix(buffer);
|
|
|
|
return buffer;
|
|
}
|
|
}
|
|
}
|
|
closedir(d);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**********************************************************************
|
|
* WineIniFileName
|
|
*/
|
|
char *WineIniFileName(void)
|
|
{
|
|
static char *IniName = NULL, *env;
|
|
|
|
char inipath[256];
|
|
|
|
if (IniName)
|
|
return IniName;
|
|
|
|
getcwd(inipath, 256);
|
|
|
|
if ((env = getenv("HOME")) !=NULL) {
|
|
strcat(inipath, ";");
|
|
strcat(inipath, env);
|
|
}
|
|
if ((env = getenv("WINEPATH")) !=NULL) {
|
|
strcat(inipath, ";");
|
|
strcat(inipath, env);
|
|
}
|
|
|
|
IniName = malloc(1024);
|
|
if (FindFile(IniName, 1024, "wine.ini", NULL, inipath) == NULL)
|
|
{
|
|
free(IniName);
|
|
IniName = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
IniName = realloc(IniName, strlen(IniName) + 1);
|
|
|
|
ToUnix(IniName);
|
|
|
|
return IniName;
|
|
}
|
|
|
|
char *WinIniFileName()
|
|
{
|
|
static char name[256];
|
|
|
|
strcpy(name,GetDirectUnixFileName(WindowsDirectory));
|
|
strcat(name,"win.ini");
|
|
|
|
ToUnix(name);
|
|
|
|
return name;
|
|
}
|
|
|
|
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++) {
|
|
#ifdef DEBUG
|
|
printf("(%c%c) ", *filename, filemask[x]);
|
|
#endif
|
|
|
|
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 = GetDirectUnixFileName(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) );
|
|
|
|
de->attribute = 0x0;
|
|
|
|
strcpy(temp,de->unixpath);
|
|
strcat(temp,"/");
|
|
strcat(temp,de->filename);
|
|
ToUnix(temp);
|
|
stat (temp, &st);
|
|
if S_ISDIR(st.st_mode)
|
|
de->attribute |= 0x08;
|
|
|
|
return de;
|
|
}
|
|
|
|
void DOS_closedir(struct dosdirent *de)
|
|
{
|
|
if (de->inuse)
|
|
{
|
|
closedir(de->ds);
|
|
de->inuse = 0;
|
|
}
|
|
}
|