int trap_ReadDirectory(lua_State *s)
{
directory_t *dir;
direntry_t *ent;
const char *path;
int i;
trap_args(s, "ReadDirectory", "s", &path);
path = datapath(path);
dir = OPENDIR(path);
if (dir == NULL) FATAL("Failed to open directory: %s", path);
lua_newtable(s);
i = 1;
for (ent = READDIR(dir); ent != NULL; ent = READDIR(dir)) {
path = DIRENT_NAME(ent);
if (strcmp(path, ".") == 0) continue;
if (strcmp(path, "..") == 0) continue;
lua_pushstring(s, va("%d", i));
lua_pushstring(s, DIRENT_NAME(ent));
lua_settable(s, -3);
++i;
}
CLOSEDIR(dir);
return 1;
}
int GetCdromFile(u8 *mdir, u8 *time, s8 *filename) {
struct iso_directory_record *dir;
char ddir[4096];
u8 *buf;
int i;
i = 0;
while (i < 4096) {
dir = (struct iso_directory_record*) &mdir[i];
if (dir->length[0] == 0) {
return -1;
}
i += dir->length[0];
if (dir->flags[0] & 0x2) { // it's a dir
if (!strnicmp((char*)&dir->name[0], filename, dir->name_len[0])) {
if (filename[dir->name_len[0]] != '\\') continue;
filename+= dir->name_len[0] + 1;
mmssdd(dir->extent, (char*)time);
READDIR(ddir);
i = 0;
}
} else {
if (!strnicmp((char*)&dir->name[0], filename, strlen(filename))) {
mmssdd(dir->extent, (char*)time);
break;
}
}
}
return 0;
}
int LoadCdromFile(const char *filename, EXE_HEADER *head) {
struct iso_directory_record *dir;
u8 time[4],*buf;
u8 mdir[4096], exename[256];
u32 size, addr;
void *psxaddr;
if (sscanf(filename, "cdrom:\\%255s", exename) <= 0)
{
// Some games omit backslash (NFS4)
if (sscanf(filename, "cdrom:%255s", exename) <= 0)
{
SysPrintf("LoadCdromFile: EXE NAME PARSING ERROR (%s (%u))\n", filename, strlen(filename));
exit (1);
}
}
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record *)&buf[12 + 156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, exename) == -1) return -1;
READTRACK();
memcpy(head, buf + 12, sizeof(EXE_HEADER));
size = head->t_size;
addr = head->t_addr;
// Cache clear/invalidate dynarec/int. Fixes startup of Casper/X-Files and possibly others.
psxCpu->Clear(addr, size / 4);
psxRegs.ICache_valid = FALSE;
while (size) {
incTime();
READTRACK();
psxaddr = (void *)PSXM(addr);
assert(psxaddr != NULL);
memcpy(psxaddr, buf + 12, 2048);
size -= 2048;
addr += 2048;
}
return 0;
}
/* the rest of the pattern segments */
#endif /* ANSI_PROTOTYPES */
{
char *saved_end = path_end; /* saved to be resored */
char *pat; /* current pattern segment */
struct stat st; /* to check if file exists */
#ifdef GLOBDEBUG
ffprintf(STDDBG,"do_glob: path = '%s', pat = '%s'\n", main_path, *gpat );
#endif
for ( ; (pat = *gpat) != 0 && no_glob(pat); gpat++ )
{
#ifdef GLOBDEBUG
ffprintf(STDDBG,"no_glob: path = '%s', pat = '%s'\n", main_path, pat );
#endif
*path_end = '/';
(void)strcpy(path_end+1, pat);
path_end += strlen(pat) + 1;
if (GLOBSTAT(main_path, &st) != 0 )
{
*saved_end = '\0';
return;
}
}
if (pat)
matchdir(path_end, gpat);
else
add_name();
*saved_end = '\0';
return;
}
static void
#ifndef ANSI_PROTOTYPES
matchdir(path_end, gpat)
char *path_end; /* ptr to end of main_path */
char **gpat; /* the rest of the pattern segments */
#else /* ANSI_PROTOTYPES */
matchdir(char *path_end, char **gpat)
/* ptr to end of main_path */
/* the rest of the pattern segments */
#endif /* ANSI_PROTOTYPES */
{
char *x; /* scratch */
VOIDDIR *dirp; /* for directory reading */
VOIDDIRENT *dp; /* directory entry */
struct stat st; /* to determine files type */
#ifdef GLOBDEBUG
ffprintf(STDDBG,"matchdir: path = '%s', pat = '%s'\n", main_path, *gpat );
#endif
if ((dirp = OPENDIR(main_path)) == NULL)
return;
*path_end = '/';
while ((dp = READDIR(dirp)) != NULL)
{
char *dirname;
x = dirname = GETNAME(dp); /* was dp->d_name */
if (*x == '.' && (*++x == '\0' || (*x == '.' && *++x == '\0')))
continue;
if (*dirname == '.' && **gpat != '.')
continue;
(void)strcpy(path_end + 1, dirname);
if (glob_match(*gpat, dirname))
{ /* this is a match */
if ( *(gpat+1) == 0 )
{ /* and it is the last */
add_name(); /* so eat it */
continue;
}
if (GLOBSTAT(main_path, &st) == 0 /* else not the last */
&& (st.st_mode & S_IFMT) == S_IFDIR)
do_glob(path_end + strlen(dirname) + 1, gpat + 1);
}
}
(void)CLOSEDIR(dirp);
*path_end = '\0';
}
int LoadCdromFile(const char *filename, EXE_HEADER *head) {
struct iso_directory_record *dir;
u8 time[4],*buf;
u8 mdir[4096];
char exename[256];
u32 size, addr;
void *mem;
sscanf(filename, "cdrom:\\%256s", exename);
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record *)&buf[12 + 156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, exename) == -1) return -1;
READTRACK();
memcpy(head, buf + 12, sizeof(EXE_HEADER));
size = head->t_size;
addr = head->t_addr;
psxCpu->Clear(addr, size / 4);
while (size & ~2047) {
incTime();
READTRACK();
mem = PSXM(addr);
if (mem)
memcpy(mem, buf + 12, 2048);
size -= 2048;
addr += 2048;
}
return 0;
}
int GetCdromFile(u8 *mdir, u8 *time, char *filename) {
struct iso_directory_record *dir;
int retval = -1;
u8 ddir[4096];
u8 *buf;
int i;
// only try to scan if a filename is given
if (!strlen(filename)) return -1;
i = 0;
while (i < 4096) {
dir = (struct iso_directory_record*) &mdir[i];
if (dir->length[0] == 0) {
return -1;
}
i += (u8)dir->length[0];
if (dir->flags[0] & 0x2) { // it's a dir
if (!strnicmp((char *)&dir->name[0], filename, dir->name_len[0])) {
if (filename[dir->name_len[0]] != '\\') continue;
filename += dir->name_len[0] + 1;
mmssdd(dir->extent, (char *)time);
READDIR(ddir);
i = 0;
mdir = ddir;
}
} else {
if (!strnicmp((char *)&dir->name[0], filename, strlen(filename))) {
mmssdd(dir->extent, (char *)time);
retval = 0;
break;
}
}
}
return retval;
}
s32 LoadCdromFile(char *filename, EXE_HEADER *head) {
struct iso_directory_record *dir;
u8 time[4],*buf;
u8 mdir[4096], exename[256];
u32 size, addr;
sscanf(filename, "cdrom:\\%s", exename);
time[0] = (0); time[1] = (2); time[2] = (0x10);
READTRACK();
// skip head and sub, and go to the root directory record
dir = (iso_directory_record*) &buf[12+156];
mmssdd((dir->extent), (char*)time);
READDIR(mdir);
if (GetCdromFile((u8*)mdir, (u8*)time, (s8*)exename) == -1) return -1;
READTRACK();
memcpy(head, buf+12, sizeof(EXE_HEADER));
size = head->t_size;
addr = head->t_addr;
while (size) {
incTime();
READTRACK();
memcpy((void *)PSXM8(addr), buf+12, 2048);
size -= 2048;
addr += 2048;
}
return 0;
}
int LoadCdrom() {
EXE_HEADER tmpHead;
struct iso_directory_record *dir;
u8 time[4], *buf;
u8 mdir[4096];
s8 exename[256];
if (!Config.HLE) {
if (!Config.SlowBoot) psxRegs.pc = psxRegs.GPR.n.ra;
return 0;
}
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record*) &buf[12+156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
// Load SYSTEM.CNF and scan for the main executable
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") == -1) {
// if SYSTEM.CNF is missing, start an existing PSX.EXE
if (GetCdromFile(mdir, time, "PSX.EXE;1") == -1) return -1;
READTRACK();
}
else {
// read the SYSTEM.CNF
READTRACK();
sscanf((char *)buf + 12, "BOOT = cdrom:\\%255s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf((char *)buf + 12, "BOOT = cdrom:%255s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr(buf + 12, "cdrom:");
if (ptr != NULL) {
ptr += 6;
while (*ptr == '\\' || *ptr == '/') ptr++;
strncpy(exename, ptr, 255);
exename[255] = '\0';
ptr = exename;
while (*ptr != '\0' && *ptr != '\r' && *ptr != '\n') ptr++;
*ptr = '\0';
if (GetCdromFile(mdir, time, exename) == -1)
return -1;
} else
return -1;
}
}
// Read the EXE-Header
READTRACK();
}
memcpy(&tmpHead, buf + 12, sizeof(EXE_HEADER));
psxRegs.pc = SWAP32(tmpHead.pc0);
psxRegs.GPR.n.gp = SWAP32(tmpHead.gp0);
psxRegs.GPR.n.sp = SWAP32(tmpHead.s_addr);
if (psxRegs.GPR.n.sp == 0) psxRegs.GPR.n.sp = 0x801fff00;
tmpHead.t_size = SWAP32(tmpHead.t_size);
tmpHead.t_addr = SWAP32(tmpHead.t_addr);
// Read the rest of the main executable
while (tmpHead.t_size) {
void *ptr = (void *)PSXM(tmpHead.t_addr);
incTime();
READTRACK();
if (ptr != NULL) memcpy(ptr, buf+12, 2048);
tmpHead.t_size -= 2048;
tmpHead.t_addr += 2048;
}
return 0;
}
int CheckCdrom() {
struct iso_directory_record *dir;
unsigned char time[4];
char *buf;
unsigned char mdir[4096];
char exename[256];
int i, c;
FreePPFCache();
time[0] = itob(0);
time[1] = itob(2);
time[2] = itob(0x10);
READTRACK();
CdromLabel[0] = '\0';
CdromId[0] = '\0';
strncpy(CdromLabel, buf + 52, 32);
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record *)&buf[12 + 156];
mmssdd(dir->extent, (char *)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") != -1) {
READTRACK();
sscanf(buf + 12, "BOOT = cdrom:\\%256s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf(buf + 12, "BOOT = cdrom:%256s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr(buf + 12, "cdrom:"); // possibly the executable is in some subdir
if (ptr != NULL) {
ptr += 6;
while (*ptr == '\\' || *ptr == '/') ptr++;
strncpy(exename, ptr, 255);
exename[255] = '\0';
ptr = exename;
while (*ptr != '\0' && *ptr != '\r' && *ptr != '\n') ptr++;
*ptr = '\0';
if (GetCdromFile(mdir, time, exename) == -1)
return -1; // main executable not found
} else
return -1;
}
}
} else if (GetCdromFile(mdir, time, "PSX.EXE;1") != -1) {
strcpy(exename, "PSX.EXE;1");
strcpy(CdromId, "SLUS99999");
} else
return -1; // SYSTEM.CNF and PSX.EXE not found
if (CdromId[0] == '\0') {
i = strlen(exename);
if (i >= 2) {
if (exename[i - 2] == ';') i-= 2;
c = 8; i--;
while (i >= 0 && c >= 0) {
if (isalnum(exename[i])) CdromId[c--] = exename[i];
i--;
}
}
}
if (CdromId[0] == '\0')
strcpy(CdromId, "SLUS99999");
if (Config.PsxAuto) { // autodetect system (pal or ntsc)
if (CdromId[2] == 'e' || CdromId[2] == 'E')
Config.PsxType = PSX_TYPE_PAL; // pal
else Config.PsxType = PSX_TYPE_NTSC; // ntsc
}
if (CdromLabel[0] == ' ') {
strncpy(CdromLabel, CdromId, 9);
}
SysPrintf(_("CD-ROM Label: %.32s\n"), CdromLabel);
SysPrintf(_("CD-ROM ID: %.9s\n"), CdromId);
BuildPPFCache();
return 0;
}
int CheckCdrom() {
struct iso_directory_record *dir;
unsigned char time[4],*buf;
unsigned char mdir[4096];
char exename[256];
int i, c;
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
CdromLabel[32]=0;
CdromId[9]=0;
strncpy(CdromLabel, (char*)buf+52, 32);
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record*) &buf[12+156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") != -1) {
READTRACK();
sscanf((char*)buf+12, "BOOT = cdrom:\\%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf((char*)buf+12, "BOOT = cdrom:%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr((char*)buf+12, "cdrom:");
for (i=0; i<32; i++) {
if (ptr[i] == ' ') continue;
if (ptr[i] == '\\') continue;
}
strcpy(exename, ptr);
if (GetCdromFile(mdir, time, exename) == -1)
return 0;
}
}
}
i = strlen(exename);
if (i >= 2) {
if (exename[i - 2] == ';') i-= 2;
c = 8; i--;
while (i >= 0 && c >= 0) {
if (isalnum(exename[i])) CdromId[c--] = exename[i];
i--;
}
}
if (Config.PsxAuto) { // autodetect system (pal or ntsc)
if (strstr(exename, "ES") != NULL)
Config.PsxType = 1; // pal
else Config.PsxType = 0; // ntsc
}
psxUpdateVSyncRate();
//zeromus 21-oct-2009 - why would you want this to be the label? it is not unique.
//if it is not going to be the rom filename then it should be the id which is unique
//if (CdromLabel[0] == ' ') {
strncpy(CdromLabel, CdromId, 9);
//}
SysPrintf("CD-ROM Label: %.32s\n", CdromLabel);
SysPrintf("CD-ROM ID: %.9s\n", CdromId);
return 0;
}
void dir_srch (parse_blk *pfil)
{
struct stat statbuf;
int stat_res;
lv_val *dir1, *dir2, *tmp;
mstr tn;
short p2_len;
char filb[MAX_FBUFF + 1], patb[sizeof(ptstr)], *c, *lastd, *top, *p2, *c1, ch;
mval pat_mval, sub, compare;
bool wildname, seen_wd;
struct dirent *dent;
DIR *dp;
plength *plen;
int closedir_res;
op_kill(zsrch_dir1);
op_kill(zsrch_dir2);
if (!pfil->b_name)
return; /* nothing to search for */
ESTABLISH(dir_ch);
pat_mval.mvtype = MV_STR;
pat_mval.str.addr = patb; /* patb should be sizeof(ptstr.buff) but instead is sizeof(ptstr) since the C compiler
* complains about the former and the latter is just 4 bytes more */
pat_mval.str.len = 0;
sub.mvtype = MV_STR;
sub.str.len = 0;
compare.mvtype = MV_STR;
compare.str.len = 0;
wildname = (pfil->fnb & F_WILD_NAME) != 0;
dir1 = zsrch_dir1;
dir2 = zsrch_dir2;
if (pfil->fnb & F_WILD_DIR)
{
seen_wd = FALSE;
for (c = pfil->l_dir, lastd = c, top = c + pfil->b_dir; c < top;)
{
ch = *c++;
if (ch == '/') /* note the start of each directory segment */
{
if (seen_wd)
break;
lastd = c;
}
if (ch == '?' || ch == '*')
seen_wd = TRUE;
}
assert(c <= top);
sub.str.addr = pfil->l_dir;
sub.str.len = lastd - sub.str.addr;
tmp = op_putindx(VARLSTCNT(2) dir1, &sub);
tmp->v.mvtype = MV_STR; tmp->v.str.len = 0;
for(;;)
{
tn.addr = lastd; /* wildcard segment */
tn.len = c - lastd - 1;
lastd = c;
genpat(&tn, &pat_mval);
seen_wd = FALSE;
p2 = c - 1;
for (; c < top;)
{
ch = *c++;
if (ch == '/') /* note the start of each directory segment */
{
if (seen_wd)
break;
lastd = c;
}
if (ch == '?' || ch == '*')
seen_wd = TRUE;
}
p2_len = lastd - p2; /* length of non-wild segment after wild section */
for (;;)
{
pop_top(dir1, &sub); /* get next item off the top */
if (!sub.str.len)
break;
memcpy(filb, sub.str.addr, sub.str.len);
filb[sub.str.len] = 0;
sub.str.addr = filb;
dp = OPENDIR(filb);
if (!dp)
continue;
while(READDIR(dp, dent))
{
compare.str.addr = &dent->d_name[0];
compare.str.len = strlen(&dent->d_name[0]);
assert(compare.str.len);
if ( dent->d_name[0] == '.'
&& (compare.str.len == 1 || (compare.str.len == 2 && dent->d_name[1] == '.')) )
{
continue; /* don't want to read . and .. */
}
if (compare.str.len + sub.str.len + p2_len > MAX_FBUFF)
continue;
if (do_pattern(&compare, &pat_mval))
{ /* got a hit */
if (stringpool.free + compare.str.len + sub.str.len + p2_len + 1 > stringpool.top)
stp_gcol(compare.str.len + sub.str.len + p2_len + 1);
/* concatenate directory and name */
c1 = (char *)stringpool.free;
tn = sub.str;
s2pool(&tn);
tn = compare.str;
s2pool(&tn);
tn.addr = p2;
tn.len = p2_len;
s2pool(&tn);
*stringpool.free++ = 0;
compare.str.addr = c1;
compare.str.len += sub.str.len + p2_len;
STAT_FILE(compare.str.addr, &statbuf, stat_res);
if (-1 == stat_res)
continue;
if (!(statbuf.st_mode & S_IFDIR))
continue;
/* put in results tree */
tmp = op_putindx(VARLSTCNT(2) dir2, &compare);
tmp->v.mvtype = MV_STR;
tmp->v.str.len = 0;
}
}
CLOSEDIR(dp, closedir_res);
}
tmp = dir1; dir1 = dir2; dir2 = tmp;
if (c >= top)
break;
}
} else
{
sub.str.addr = pfil->l_dir;
sub.str.len = pfil->b_dir;
tmp = op_putindx(VARLSTCNT(2) dir1, &sub);
tmp->v.mvtype = MV_STR; tmp->v.str.len = 0;
}
if (wildname)
{
tn.addr = pfil->l_name;
tn.len = pfil->b_name + pfil->b_ext;
genpat(&tn, &pat_mval);
}
for (;;)
{
pop_top(dir1, &sub); /* get next item off the top */
if (!sub.str.len)
break;
if (wildname)
{
memcpy(filb, sub.str.addr, sub.str.len);
filb[sub.str.len] = 0;
sub.str.addr = filb;
dp = OPENDIR(filb);
if (!dp)
continue;
while(READDIR(dp, dent))
{
compare.str.addr = &dent->d_name[0];
compare.str.len = strlen(&dent->d_name[0]);
if ( dent->d_name[0] == '.'
&& (compare.str.len == 1 || (compare.str.len == 2 && dent->d_name[1] == '.')))
{
continue; /* don't want to read . and .. */
}
if (compare.str.len + sub.str.len > MAX_FBUFF)
continue;
if (do_pattern(&compare, &pat_mval))
{ /* got a hit */
if (stringpool.free + compare.str.len + sub.str.len > stringpool.top)
stp_gcol(compare.str.len + sub.str.len);
/* concatenate directory and name */
c = (char *)stringpool.free;
tn = sub.str;
s2pool(&tn);
tn = compare.str;
s2pool(&tn);
compare.str.addr = c;
compare.str.len += sub.str.len;
/* put in results tree */
tmp = op_putindx(VARLSTCNT(2) ind_var, &compare);
tmp->v.mvtype = MV_STR;
tmp->v.str.len = 0;
plen = (plength *)&tmp->v.m[1];
plen->p.pblk.b_esl = compare.str.len;
plen->p.pblk.b_dir = sub.str.len;
for (c = &compare.str.addr[sub.str.len], c1 = top = &compare.str.addr[compare.str.len];
c < top;
)
{
if (*c++ != '.')
break;
}
for (; c < top;)
{
if (*c++ == '.')
c1 = c - 1;
}
plen->p.pblk.b_ext = top - c1;
plen->p.pblk.b_name = plen->p.pblk.b_esl - plen->p.pblk.b_dir - plen->p.pblk.b_ext;
}
}
CLOSEDIR(dp, closedir_res);
} else
{
assert(pfil->fnb & F_WILD_DIR);
compare.str.addr = pfil->l_name;
compare.str.len = pfil->b_name + pfil->b_ext;
if (compare.str.len + sub.str.len > MAX_FBUFF)
continue;
memcpy(filb, sub.str.addr, sub.str.len);
filb[sub.str.len] = 0;
sub.str.addr = filb;
if (stringpool.free + compare.str.len + sub.str.len > stringpool.top)
stp_gcol(compare.str.len + sub.str.len);
/* concatenate directory and name */
c1 = (char *)stringpool.free;
tn = sub.str;
s2pool(&tn);
tn = compare.str;
s2pool(&tn);
compare.str.addr = c1;
compare.str.len += sub.str.len;
/* put in results tree */
tmp = op_putindx(VARLSTCNT(2) ind_var, &compare);
tmp->v.mvtype = MV_STR; tmp->v.str.len = 0;
plen = (plength *)&tmp->v.m[1];
plen->p.pblk.b_esl = compare.str.len;
plen->p.pblk.b_dir = sub.str.len;
plen->p.pblk.b_name = pfil->b_name;
plen->p.pblk.b_ext = pfil->b_ext;
}
}
op_kill(zsrch_dir1);
op_kill(zsrch_dir2);
REVERT;
}
int CheckCdrom() {
struct iso_directory_record *dir;
unsigned char time[4],*buf;
unsigned char mdir[4096];
char exename[256];
int i, c;
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
strncpy(CdromLabel, buf+52, 11);
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record*) &buf[12+156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") != -1) {
READTRACK();
sscanf((char*)buf+12, "BOOT = cdrom:\\%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf((char*)buf+12, "BOOT = cdrom:%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr(buf+12, "cdrom:");
for (i=0; i<32; i++) {
if (ptr[i] == ' ') continue;
if (ptr[i] == '\\') continue;
}
strcpy(exename, ptr);
if (GetCdromFile(mdir, time, exename) == -1)
return 0;
}
}
}
i = strlen(exename);
if (i >= 2) {
if (exename[i - 2] == ';') i-= 2;
c = 8; i--;
while (i >= 0 && c >= 0) {
if (isalnum(exename[i])) CdromId[c--] = exename[i];
i--;
}
}
if (Config.PsxAuto) { // autodetect system (pal or ntsc)
if (strstr(exename, "ES") != NULL)
Config.PsxType = 1; // pal
else Config.PsxType = 0; // ntsc
}
psxUpdateVSyncRate();
if (CdromLabel[0] == ' ') {
strcpy(CdromLabel, CdromId);
}
SysPrintf("*PCSX*: CdromLabel: %s\n", CdromLabel);
SysPrintf("*PCSX*: CdromId: %s\n", CdromId);
AgemoTrace("Loading cdrom label %s", CdromLabel);
AgemoTrace("Loading cdrom id %s", CdromId);
return 0;
}
int LoadCdrom() {
EXE_HEADER tmpHead;
struct iso_directory_record *dir;
u8 time[4],*buf;
u8 mdir[4096];
s8 exename[256];
int i;
if (!Config.HLE) {
psxRegs.pc = psxRegs.GPR.n.ra;
return 0;
}
time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
READTRACK();
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record*) &buf[12+156];
mmssdd(dir->extent, (char*)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") == -1) {
if (GetCdromFile(mdir, time, "PSX.EXE;1") == -1) return -1;
READTRACK();
}
else {
READTRACK();
sscanf((char*)buf+12, "BOOT = cdrom:\\%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf((char*)buf+12, "BOOT = cdrom:%s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr(buf+12, "cdrom:");
for (i=0; i<32; i++) {
if (ptr[i] == ' ') continue;
if (ptr[i] == '\\') continue;
}
strcpy(exename, ptr);
if (GetCdromFile(mdir, time, exename) == -1)
return -1;
}
}
READTRACK();
}
memcpy(&tmpHead, buf+12, sizeof(EXE_HEADER));
#ifdef __MACOSX__
swapEXE_HEADER(&tmpHead);
#endif
psxRegs.pc = tmpHead.pc0;
psxRegs.GPR.n.gp = tmpHead.gp0;
psxRegs.GPR.n.sp = tmpHead.s_addr;
if (psxRegs.GPR.n.sp == 0) psxRegs.GPR.n.sp = 0x801fff00;
while (tmpHead.t_size) {
void *ptr = (void *)PSXM(tmpHead.t_addr);
incTime();
READTRACK();
if (ptr != NULL) memcpy(ptr, buf+12, 2048);
tmpHead.t_size -= 2048;
tmpHead.t_addr += 2048;
}
return 0;
}
int CheckCdrom() {
struct iso_directory_record *dir;
unsigned char time[4], *buf;
unsigned char mdir[4096];
char exename[256];
int i, len, c;
FreePPFCache();
time[0] = itob(0);
time[1] = itob(2);
time[2] = itob(0x10);
READTRACK();
memset(CdromLabel, 0, sizeof(CdromLabel));
memset(CdromId, 0, sizeof(CdromId));
memset(exename, 0, sizeof(exename));
strncpy(CdromLabel, buf + 52, 32);
// skip head and sub, and go to the root directory record
dir = (struct iso_directory_record *)&buf[12 + 156];
mmssdd(dir->extent, (char *)time);
READDIR(mdir);
if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") != -1) {
READTRACK();
sscanf((char *)buf + 12, "BOOT = cdrom:\\%255s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
sscanf((char *)buf + 12, "BOOT = cdrom:%255s", exename);
if (GetCdromFile(mdir, time, exename) == -1) {
char *ptr = strstr(buf + 12, "cdrom:"); // possibly the executable is in some subdir
if (ptr != NULL) {
ptr += 6;
while (*ptr == '\\' || *ptr == '/') ptr++;
strncpy(exename, ptr, 255);
exename[255] = '\0';
ptr = exename;
while (*ptr != '\0' && *ptr != '\r' && *ptr != '\n') ptr++;
*ptr = '\0';
if (GetCdromFile(mdir, time, exename) == -1)
return -1; // main executable not found
} else
return -1;
}
}
} else if (GetCdromFile(mdir, time, "PSX.EXE;1") != -1) {
strcpy(exename, "PSX.EXE;1");
strcpy(CdromId, "SLUS99999");
} else
return -1; // SYSTEM.CNF and PSX.EXE not found
if (CdromId[0] == '\0') {
len = strlen(exename);
c = 0;
for (i = 0; i < len; ++i) {
if (exename[i] == ';' || c >= sizeof(CdromId) - 1)
break;
if (isalnum(exename[i]))
CdromId[c++] = exename[i];
}
}
if (Config.PsxAuto) { // autodetect system (pal or ntsc)
if((CdromId[2] == 'e') || (CdromId[2] == 'E') ||
!strncmp(CdromId, "DTLS3035", 8) ||
!strncmp(CdromId, "PBPX95001", 9) || // according to redump.org, these PAL
!strncmp(CdromId, "PBPX95007", 9) || // discs have a non-standard ID;
!strncmp(CdromId, "PBPX95008", 9)) // add more serials if they are discovered.
Config.PsxType = PSX_TYPE_PAL; // pal
else Config.PsxType = PSX_TYPE_NTSC; // ntsc
}
if (Config.PsxStock == 0) {
PsxClockSpeed = 33868800; // 33.8688 MHz (stock)
} else {
if (Config.PsxClock == 0) {
PsxClockSpeed = 16934400; // 16.9344 MHz (0.5x)
}
if (Config.PsxClock == 1) {
PsxClockSpeed = 25401600; // 25.4016 MHz (0.75x)
}
if (Config.PsxClock == 2) {
PsxClockSpeed = 50803200; // 50.8032 MHz (1.5x)
}
if (Config.PsxClock == 3) {
PsxClockSpeed = 67737600; // 67.7376 MHz (2x)
}
if (Config.PsxClock == 4) {
PsxClockSpeed = 101606400; // 101.6064 MHz (3x)
}
if (Config.PsxClock == 5) {
PsxClockSpeed = 135475200; // 135.4752 MHz (4x)
}
if (Config.PsxClock == 6) {
PsxClockSpeed = 169344000; // 169.3440 MHz (5x)
}
}
if (CdromLabel[0] == ' ') {
strncpy(CdromLabel, CdromId, 9);
}
SysPrintf(_("CD-ROM Label: %.32s\n"), CdromLabel);
SysPrintf(_("CD-ROM ID: %.9s\n"), CdromId);
SysPrintf(_("CD-ROM EXE Name: %.255s\n"), exename);
BuildPPFCache();
LoadSBI(NULL);
return 0;
}
int main () {
int retval, i;
int fd;
int index_node_number;
/* Some arbitrary data for our files */
memset (data1, '1', sizeof (data1));
memset (data2, '2', sizeof (data1));
memset (data3, '3', sizeof (data1));
#ifdef TEST1
/* ****TEST 1: MAXIMUM file creation**** */
/* Generate MAXIMUM regular files */
for (i = 0; i < MAX_FILES + 1; i++) { // go beyond the limit
sprintf (pathname, "/file%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "creat: File creation error! status: %d\n",
retval);
if (i != MAX_FILES)
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
/* Delete all the files created */
for (i = 0; i < MAX_FILES; i++) {
sprintf (pathname, "/file%d", i);
retval = UNLINK (pathname);
if (retval < 0) {
fprintf (stderr, "unlink: File deletion error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
#endif // TEST1
#ifdef TEST2
/* ****TEST 2: LARGEST file size**** */
/* Generate one LARGEST file */
retval = CREAT ("/bigfile");
if (retval < 0) {
fprintf (stderr, "creat: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = OPEN ("/bigfile"); /* Open file to write to it */
if (retval < 0) {
fprintf (stderr, "open: File open error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
fd = retval; /* Assign valid fd */
/* Try writing to all direct data blocks */
retval = write (fd, data1, sizeof(data1));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE1 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#ifdef TEST_SINGLE_INDIRECT
/* Try writing to all single-indirect data blocks */
retval = write (fd, data2, sizeof(data2));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE2 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#ifdef TEST_DOUBLE_INDIRECT
/* Try writing to all double-indirect data blocks */
retval = write (fd, data3, sizeof(data3));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE3 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#endif // TEST_DOUBLE_INDIRECT
#endif // TEST_SINGLE_INDIRECT
#endif // TEST2
#ifdef TEST3
/* ****TEST 3: Seek and Read file test**** */
retval = LSEEK (fd, 0); /* Go back to the beginning of your file */
if (retval < 0) {
fprintf (stderr, "lseek: File seek error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Try reading from all direct data blocks */
retval = READ (fd, addr, sizeof(data1));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE1 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 1s here... */
printf ("Data at addr: %s\n", addr);
#ifdef TEST_SINGLE_INDIRECT
/* Try reading from all single-indirect data blocks */
retval = READ (fd, addr, sizeof(data2));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE2 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 2s here... */
printf ("Data at addr: %s\n", addr);
#ifdef TEST_DOUBLE_INDIRECT
/* Try reading from all double-indirect data blocks */
retval = write (fd, addr, sizeof(data3));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE3 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 3s here... */
printf ("Data at addr: %s\n", addr);
#endif // TEST_DOUBLE_INDIRECT
#endif // TEST_SINGLE_INDIRECT
/* Close the bigfile */
retval = CLOSE(fd);
if (retval < 0) {
fprintf (stderr, "close: File close error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Remove the biggest file */
retval = UNLINK ("/bigfile");
if (retval < 0) {
fprintf (stderr, "unlink: /bigfile file deletion error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#endif // TEST3
#ifdef TEST4
/* ****TEST 4: Make directory and read directory entries**** */
retval = MKDIR ("/dir1");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 1 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = MKDIR ("/dir1/dir2");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 2 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = MKDIR ("/dir1/dir3");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 3 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = OPEN ("/dir1"); /* Open directory file to read its entries */
if (retval < 0) {
fprintf (stderr, "open: Directory open error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
fd = retval; /* Assign valid fd */
memset (addr, 0, sizeof(addr)); /* Clear scratchpad memory */
while ((retval = READDIR (fd, addr))) { /* 0 indicates end-of-file */
if (retval < 0) {
fprintf (stderr, "readdir: Directory read error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
index_node_number = atoi(&addr[14]);
printf ("Contents at addr: [%s,%d]\n", addr, index_node_number);
}
#endif // TEST4
#ifdef TEST5
/* ****TEST 5: 2 process test**** */
if((retval = fork())) {
if(retval == -1) {
fprintf(stderr, "Failed to fork\n");
exit(EXIT_FAILURE);
}
/* Generate 300 regular files */
for (i = 0; i < 300; i++) {
sprintf (pathname, "/file_p_%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "(Parent) create: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
}
else {
/* Generate 300 regular files */
for (i = 0; i < 300; i++) {
sprintf (pathname, "/file_c_%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "(Child) create: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
}
#endif // TEST5
printf("Congratulations, you have passed all tests!!\n");
return 0;
}
MY_DIR *my_dir(const char *path, myf MyFlags)
{
char *buffer;
MY_DIR *result= 0;
FILEINFO finfo;
DYNAMIC_ARRAY *dir_entries_storage;
MEM_ROOT *names_storage;
DIR *dirp;
struct dirent *dp;
char tmp_path[FN_REFLEN + 2], *tmp_file;
char dirent_tmp[sizeof(struct dirent)+_POSIX_PATH_MAX+1];
DBUG_ENTER("my_dir");
DBUG_PRINT("my",("path: '%s' MyFlags: %d",path,MyFlags));
#if !defined(HAVE_READDIR_R)
mysql_mutex_lock(&THR_LOCK_open);
#endif
dirp = opendir(directory_file_name(tmp_path,(char *) path));
if (dirp == NULL ||
! (buffer= my_malloc(key_memory_MY_DIR,
ALIGN_SIZE(sizeof(MY_DIR)) +
ALIGN_SIZE(sizeof(DYNAMIC_ARRAY)) +
sizeof(MEM_ROOT), MyFlags)))
goto error;
dir_entries_storage= (DYNAMIC_ARRAY*)(buffer + ALIGN_SIZE(sizeof(MY_DIR)));
names_storage= (MEM_ROOT*)(buffer + ALIGN_SIZE(sizeof(MY_DIR)) +
ALIGN_SIZE(sizeof(DYNAMIC_ARRAY)));
if (my_init_dynamic_array(dir_entries_storage, sizeof(FILEINFO),
NULL, /* init_buffer */
ENTRIES_START_SIZE, ENTRIES_INCREMENT))
{
my_free(buffer);
goto error;
}
init_alloc_root(key_memory_MY_DIR, names_storage, NAMES_START_SIZE, NAMES_START_SIZE);
/* MY_DIR structure is allocated and completly initialized at this point */
result= (MY_DIR*)buffer;
tmp_file=strend(tmp_path);
dp= (struct dirent*) dirent_tmp;
while (!(READDIR(dirp,(struct dirent*) dirent_tmp,dp)))
{
if (!(finfo.name= strdup_root(names_storage, dp->d_name)))
goto error;
if (MyFlags & MY_WANT_STAT)
{
if (!(finfo.mystat= (MY_STAT*)alloc_root(names_storage,
sizeof(MY_STAT))))
goto error;
memset(finfo.mystat, 0, sizeof(MY_STAT));
(void) my_stpcpy(tmp_file,dp->d_name);
(void) my_stat(tmp_path, finfo.mystat, MyFlags);
if (!(finfo.mystat->st_mode & MY_S_IREAD))
continue;
}
else
finfo.mystat= NULL;
if (insert_dynamic(dir_entries_storage, (uchar*)&finfo))
goto error;
}
(void) closedir(dirp);
#if !defined(HAVE_READDIR_R)
mysql_mutex_unlock(&THR_LOCK_open);
#endif
result->dir_entry= (FILEINFO *)dir_entries_storage->buffer;
result->number_off_files= dir_entries_storage->elements;
if (!(MyFlags & MY_DONT_SORT))
my_qsort((void *) result->dir_entry, result->number_off_files,
sizeof(FILEINFO), (qsort_cmp) comp_names);
DBUG_RETURN(result);
error:
#if !defined(HAVE_READDIR_R)
mysql_mutex_unlock(&THR_LOCK_open);
#endif
my_errno=errno;
if (dirp)
(void) closedir(dirp);
my_dirend(result);
if (MyFlags & (MY_FAE | MY_WME))
{
char errbuf[MYSYS_STRERROR_SIZE];
my_error(EE_DIR, MYF(0), path,
my_errno, my_strerror(errbuf, sizeof(errbuf), my_errno));
}
DBUG_RETURN((MY_DIR *) NULL);
} /* my_dir */
MY_DIR *my_dir(const char *path, myf MyFlags)
{
DIR *dirp;
struct dirent *dp;
struct fileinfo *fnames;
char *buffer, *obuffer, *tempptr;
uint fcnt,i,size,firstfcnt, maxfcnt,length;
char tmp_path[FN_REFLEN+1],*tmp_file;
my_ptrdiff_t diff;
bool eof;
#ifdef THREAD
char dirent_tmp[sizeof(struct dirent)+_POSIX_PATH_MAX+1];
#endif
DBUG_ENTER("my_dir");
DBUG_PRINT("my",("path: '%s' stat: %d MyFlags: %d",path,MyFlags));
#if defined(THREAD) && !defined(HAVE_READDIR_R)
pthread_mutex_lock(&THR_LOCK_open);
#endif
dirp = opendir(directory_file_name(tmp_path,(my_string) path));
size = STARTSIZE;
if (dirp == NULL || ! (buffer = (char *) my_malloc(size, MyFlags)))
goto error;
fcnt = 0;
tmp_file=strend(tmp_path);
firstfcnt = maxfcnt = (size - sizeof(MY_DIR)) /
(sizeof(struct fileinfo) + FN_LEN);
fnames= (struct fileinfo *) (buffer + sizeof(MY_DIR));
tempptr = (char *) (fnames + maxfcnt);
#ifdef THREAD
dp= (struct dirent*) dirent_tmp;
#else
dp=0;
#endif
eof=0;
for (;;)
{
while (fcnt < maxfcnt &&
!(eof= READDIR(dirp,(struct dirent*) dirent_tmp,dp)))
{
bzero((gptr) (fnames+fcnt),sizeof(fnames[0])); /* for purify */
fnames[fcnt].name = tempptr;
tempptr = strmov(tempptr,dp->d_name) + 1;
if (MyFlags & MY_WANT_STAT)
{
VOID(strmov(tmp_file,dp->d_name));
VOID(my_stat(tmp_path, &fnames[fcnt].mystat, MyFlags));
}
++fcnt;
}
if (eof)
break;
size += STARTSIZE; obuffer = buffer;
if (!(buffer = (char *) my_realloc((gptr) buffer, size,
MyFlags | MY_FREE_ON_ERROR)))
goto error; /* No memory */
length= (uint) (sizeof(struct fileinfo ) * firstfcnt);
diff= PTR_BYTE_DIFF(buffer , obuffer) + (int) length;
fnames= (struct fileinfo *) (buffer + sizeof(MY_DIR));
tempptr= ADD_TO_PTR(tempptr,diff,char*);
for (i = 0; i < maxfcnt; i++)
fnames[i].name = ADD_TO_PTR(fnames[i].name,diff,char*);
/* move filenames upp a bit */
maxfcnt += firstfcnt;
bmove_upp(tempptr,tempptr-length,
(uint) (tempptr- (char*) (fnames+maxfcnt)));
}
(void) closedir(dirp);
{
MY_DIR * s = (MY_DIR *) buffer;
s->number_off_files = (uint) fcnt;
s->dir_entry = fnames;
}
if (!(MyFlags & MY_DONT_SORT))
qsort((void *) fnames, (size_s) fcnt, sizeof(struct fileinfo),
(qsort_cmp) comp_names);
#if defined(THREAD) && !defined(HAVE_READDIR_R)
pthread_mutex_unlock(&THR_LOCK_open);
#endif
DBUG_RETURN((MY_DIR *) buffer);
error:
#if defined(THREAD) && !defined(HAVE_READDIR_R)
pthread_mutex_unlock(&THR_LOCK_open);
#endif
my_errno=errno;
if (dirp)
(void) closedir(dirp);
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_DIR,MYF(ME_BELL+ME_WAITTANG),path,my_errno);
DBUG_RETURN((MY_DIR *) NULL);
} /* my_dir */
MY_DIR *my_dir(const char *path, myf MyFlags)
{
char *buffer;
MY_DIR *result= 0;
FILEINFO finfo;
DYNAMIC_ARRAY *dir_entries_storage;
MEM_ROOT *names_storage;
DIR *dirp;
struct dirent *dp;
char tmp_path[FN_REFLEN+1],*tmp_file;
#ifdef THREAD
char dirent_tmp[sizeof(struct dirent)+_POSIX_PATH_MAX+1];
#endif
DBUG_ENTER("my_dir");
DBUG_PRINT("my",("path: '%s' MyFlags: %d",path,MyFlags));
#if defined(THREAD) && !defined(HAVE_READDIR_R)
mysql_mutex_lock(&THR_LOCK_open);
#endif
dirp = opendir(directory_file_name(tmp_path,(char *) path));
#if defined(__amiga__)
if ((dirp->dd_fd) < 0) /* Directory doesn't exists */
goto error;
#endif
if (dirp == NULL ||
! (buffer= my_malloc(ALIGN_SIZE(sizeof(MY_DIR)) +
ALIGN_SIZE(sizeof(DYNAMIC_ARRAY)) +
sizeof(MEM_ROOT), MyFlags)))
goto error;
dir_entries_storage= (DYNAMIC_ARRAY*)(buffer + ALIGN_SIZE(sizeof(MY_DIR)));
names_storage= (MEM_ROOT*)(buffer + ALIGN_SIZE(sizeof(MY_DIR)) +
ALIGN_SIZE(sizeof(DYNAMIC_ARRAY)));
if (my_init_dynamic_array(dir_entries_storage, sizeof(FILEINFO),
ENTRIES_START_SIZE, ENTRIES_INCREMENT))
{
my_free(buffer);
goto error;
}
init_alloc_root(names_storage, NAMES_START_SIZE, NAMES_START_SIZE);
/* MY_DIR structure is allocated and completly initialized at this point */
result= (MY_DIR*)buffer;
tmp_file=strend(tmp_path);
#ifdef THREAD
dp= (struct dirent*) dirent_tmp;
#else
dp=0;
#endif
while (!(READDIR(dirp,(struct dirent*) dirent_tmp,dp)))
{
if (!(finfo.name= strdup_root(names_storage, dp->d_name)))
goto error;
if (MyFlags & MY_WANT_STAT)
{
if (!(finfo.mystat= (MY_STAT*)alloc_root(names_storage,
sizeof(MY_STAT))))
goto error;
bzero(finfo.mystat, sizeof(MY_STAT));
(void) strmov(tmp_file,dp->d_name);
(void) my_stat(tmp_path, finfo.mystat, MyFlags);
if (!(finfo.mystat->st_mode & MY_S_IREAD))
continue;
}
else
finfo.mystat= NULL;
if (push_dynamic(dir_entries_storage, (uchar*)&finfo))
goto error;
}
(void) closedir(dirp);
#if defined(THREAD) && !defined(HAVE_READDIR_R)
mysql_mutex_unlock(&THR_LOCK_open);
#endif
result->dir_entry= (FILEINFO *)dir_entries_storage->buffer;
result->number_off_files= dir_entries_storage->elements;
if (!(MyFlags & MY_DONT_SORT))
my_qsort((void *) result->dir_entry, result->number_off_files,
sizeof(FILEINFO), (qsort_cmp) comp_names);
DBUG_RETURN(result);
error:
#if defined(THREAD) && !defined(HAVE_READDIR_R)
mysql_mutex_unlock(&THR_LOCK_open);
#endif
my_errno=errno;
if (dirp)
(void) closedir(dirp);
my_dirend(result);
if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_DIR,MYF(ME_BELL+ME_WAITTANG),path,my_errno);
DBUG_RETURN((MY_DIR *) NULL);
} /* my_dir */
void dir_srch(parse_blk *pfil)
{
struct stat statbuf;
int stat_res;
lv_val *dir1, *dir2, *tmp;
mstr tn;
short p2_len;
char filb[MAX_FBUFF + 1], patb[SIZEOF(ptstr)], *c, *lastd, *top, *p2, *c1, ch;
mval pat_mval, sub, compare;
boolean_t wildname, seen_wd;
struct dirent *dent;
DIR *dp;
plength *plen;
int closedir_res;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
op_kill(TREF(zsearch_dir1));
op_kill(TREF(zsearch_dir2));
if (!pfil->b_name)
return; /* nothing to search for */
ESTABLISH(dir_ch);
pat_mval.mvtype = MV_STR;
pat_mval.str.addr = patb; /* patb should be SIZEOF(ptstr.buff) but instead is SIZEOF(ptstr) since the C compiler
* complains about the former and the latter is just 4 bytes more */
pat_mval.str.len = 0;
sub.mvtype = MV_STR;
sub.str.len = 0;
compare.mvtype = MV_STR;
compare.str.len = 0;
wildname = (pfil->fnb & F_WILD_NAME) != 0;
dir1 = TREF(zsearch_dir1);
dir2 = TREF(zsearch_dir2);
if (pfil->fnb & F_WILD_DIR)
{
seen_wd = FALSE;
for (c = pfil->l_dir, lastd = c, top = c + pfil->b_dir; c < top;)
{
ch = *c++;
if (ch == '/') /* note the start of each directory segment */
{
if (seen_wd)
break;
lastd = c;
}
if (ch == '?' || ch == '*')
seen_wd = TRUE;
}
assert(c <= top);
sub.str.addr = pfil->l_dir;
sub.str.len = INTCAST(lastd - sub.str.addr);
tmp = op_putindx(VARLSTCNT(2) dir1, &sub);
tmp->v.mvtype = MV_STR; tmp->v.str.len = 0;
for (;;)
{
tn.addr = lastd; /* wildcard segment */
tn.len = INTCAST(c - lastd - 1);
lastd = c;
genpat(&tn, &pat_mval);
seen_wd = FALSE;
p2 = c - 1;
for (; c < top;)
{
ch = *c++;
if (ch == '/') /* note the start of each directory segment */
{
if (seen_wd)
break;
lastd = c;
}
if (ch == '?' || ch == '*')
seen_wd = TRUE;
}
p2_len = lastd - p2; /* length of non-wild segment after wild section */
for (;;)
{
pop_top(dir1, &sub); /* get next item off the top */
if (!sub.str.len)
break;
memcpy(filb, sub.str.addr, sub.str.len);
filb[sub.str.len] = 0;
sub.str.addr = filb;
dp = OPENDIR(filb);
if (!dp)
continue;
while (READDIR(dp, dent))
{
compare.str.addr = &dent->d_name[0];
compare.str.len = STRLEN(&dent->d_name[0]);
UNICODE_ONLY(
if (gtm_utf8_mode)
compare.mvtype &= ~MV_UTF_LEN; /* to force "char_len" to be recomputed
* in do_pattern */
)
assert(compare.str.len);
if (('.' == dent->d_name[0])
&& ((1 == compare.str.len) || ((2 == compare.str.len) && ('.' == dent->d_name[1]))))
continue; /* don't want to read . and .. */
if (compare.str.len + sub.str.len + p2_len > MAX_FBUFF)
continue;
if (do_pattern(&compare, &pat_mval))
{ /* got a hit */
ENSURE_STP_FREE_SPACE(compare.str.len + sub.str.len + p2_len + 1);
/* concatenate directory and name */
c1 = (char *)stringpool.free;
tn = sub.str;
s2pool(&tn);
tn = compare.str;
s2pool(&tn);
tn.addr = p2;
tn.len = p2_len;
s2pool(&tn);
*stringpool.free++ = 0;
compare.str.addr = c1;
compare.str.len += sub.str.len + p2_len;
STAT_FILE(compare.str.addr, &statbuf, stat_res);
if (-1 == stat_res)
continue;
if (!(statbuf.st_mode & S_IFDIR))
continue;
/* put in results tree */
tmp = op_putindx(VARLSTCNT(2) dir2, &compare);
tmp->v.mvtype = MV_STR;
tmp->v.str.len = 0;
}
}
CLOSEDIR(dp, closedir_res);
}
tmp = dir1; dir1 = dir2; dir2 = tmp;
if (c >= top)
break;
}
