NAV_TITLE_LIST* nav_get_title_list(const char *root, uint32_t flags, uint32_t min_title_length)
{
BD_DIR_H *dir;
BD_DIRENT ent;
char *path = NULL;
MPLS_PL **pl_list = NULL;
MPLS_PL *pl = NULL;
unsigned int ii, pl_list_size = 0;
int res;
NAV_TITLE_LIST *title_list;
unsigned int title_info_alloc = 100;
title_list = calloc(1, sizeof(NAV_TITLE_LIST));
title_list->title_info = calloc(title_info_alloc, sizeof(NAV_TITLE_INFO));
BD_DEBUG(DBG_NAV, "Root: %s:\n", root);
path = str_printf("%s" DIR_SEP "BDMV" DIR_SEP "PLAYLIST", root);
dir = dir_open(path);
if (dir == NULL) {
BD_DEBUG(DBG_NAV, "Failed to open dir: %s\n", path);
X_FREE(path);
X_FREE(title_list->title_info);
X_FREE(title_list);
return NULL;
}
X_FREE(path);
ii = 0;
for (res = dir_read(dir, &ent); !res; res = dir_read(dir, &ent)) {
if (ent.d_name[0] == '.') {
continue;
}
path = str_printf("%s" DIR_SEP "BDMV" DIR_SEP "PLAYLIST" DIR_SEP "%s",
root, ent.d_name);
if (ii >= pl_list_size) {
MPLS_PL **tmp = NULL;
pl_list_size += 100;
tmp = realloc(pl_list, pl_list_size * sizeof(MPLS_PL*));
if (tmp == NULL) {
X_FREE(path);
break;
}
pl_list = tmp;
}
pl = mpls_parse(path);
X_FREE(path);
if (pl != NULL) {
if ((flags & TITLES_FILTER_DUP_TITLE) &&
!_filter_dup(pl_list, ii, pl)) {
mpls_free(pl);
continue;
}
if ((flags & TITLES_FILTER_DUP_CLIP) && !_filter_repeats(pl, 2)) {
mpls_free(pl);
continue;
}
if (min_title_length > 0 &&
_pl_duration(pl) < min_title_length*45000) {
mpls_free(pl);
continue;
}
if (ii >= title_info_alloc) {
NAV_TITLE_INFO *tmp = NULL;
title_info_alloc += 100;
tmp = realloc(title_list->title_info,
title_info_alloc * sizeof(NAV_TITLE_INFO));
if (tmp == NULL) {
break;
}
title_list->title_info = tmp;
}
pl_list[ii] = pl;
strncpy(title_list->title_info[ii].name, ent.d_name, 11);
title_list->title_info[ii].name[10] = '\0';
title_list->title_info[ii].ref = ii;
title_list->title_info[ii].mpls_id = atoi(ent.d_name);
title_list->title_info[ii].duration = _pl_duration(pl_list[ii]);
ii++;
}
}
dir_close(dir);
title_list->count = ii;
for (ii = 0; ii < title_list->count; ii++) {
mpls_free(pl_list[ii]);
}
X_FREE(pl_list);
return title_list;
}
char* nav_find_main_title(const char *root)
{
BD_DIR_H *dir;
BD_DIRENT ent;
char *path = NULL;
MPLS_PL **pl_list = NULL;
MPLS_PL **tmp = NULL;
MPLS_PL *pl = NULL;
unsigned count, ii, jj, pl_list_size = 0;
int res;
char longest[11];
BD_DEBUG(DBG_NAV, "Root: %s:\n", root);
path = str_printf("%s" DIR_SEP "BDMV" DIR_SEP "PLAYLIST", root);
dir = dir_open(path);
if (dir == NULL) {
fprintf(stderr, "Failed to open dir: %s\n", path);
X_FREE(path);
return NULL;
}
X_FREE(path);
ii = jj = 0;
for (res = dir_read(dir, &ent); !res; res = dir_read(dir, &ent)) {
if (ent.d_name[0] == '.') {
continue;
}
path = str_printf("%s" DIR_SEP "BDMV" DIR_SEP "PLAYLIST" DIR_SEP "%s",
root, ent.d_name);
if (ii >= pl_list_size) {
pl_list_size += 100;
tmp = realloc(pl_list, pl_list_size * sizeof(MPLS_PL*));
if (tmp == NULL) {
X_FREE(path);
break;
}
pl_list = tmp;
}
pl = mpls_parse(path);
X_FREE(path);
if (pl != NULL) {
if (_filter_dup(pl_list, ii, pl) &&
_filter_repeats(pl, 2)) {
pl_list[ii] = pl;
if (_pl_duration(pl_list[ii]) >= _pl_duration(pl_list[jj])) {
strncpy(longest, ent.d_name, 11);
longest[10] = '\0';
jj = ii;
}
ii++;
} else {
mpls_free(pl);
}
}
}
dir_close(dir);
count = ii;
for (ii = 0; ii < count; ii++) {
mpls_free(pl_list[ii]);
}
if (count > 0) {
return str_dup(longest);
} else {
return NULL;
}
}
int main () {
dir=strdup("E:/www/default/foto_content");
dir_read(dir);
return 0;
}
static inline clash_action get_slots(Stream_t *Dir,
char *dosname, char *longname,
struct scan_state *ssp,
ClashHandling_t *ch)
{
int error;
clash_action ret;
int match=0;
direntry_t entry;
int isprimary;
int no_overwrite;
int reason;
int pessimisticShortRename;
pessimisticShortRename = (ch->action[0] == NAMEMATCH_AUTORENAME);
entry.Dir = Dir;
no_overwrite = 1;
if((is_reserved(longname,1)) ||
longname[strspn(longname,". ")] == '\0'){
reason = RESERVED;
isprimary = 1;
} else if(contains_illegals(longname,long_illegals)) {
reason = ILLEGALS;
isprimary = 1;
} else if(is_reserved(dosname,0)) {
reason = RESERVED;
ch->use_longname = 1;
isprimary = 0;
} else if(contains_illegals(dosname,short_illegals)) {
reason = ILLEGALS;
ch->use_longname = 1;
isprimary = 0;
} else {
reason = EXISTS;
clear_scan(longname, ch->use_longname, ssp);
switch (lookupForInsert(Dir, dosname, longname, ssp,
ch->ignore_entry,
ch->source_entry,
pessimisticShortRename &&
ch->use_longname)) {
case -1:
return NAMEMATCH_ERROR;
case 0:
return NAMEMATCH_SKIP;
/* Single-file error error or skip request */
case 5:
return NAMEMATCH_GREW;
/* Grew directory, try again */
case 6:
return NAMEMATCH_SUCCESS; /* Success */
}
match = -2;
if (ssp->longmatch > -1) {
/* Primary Long Name Match */
#ifdef debug
fprintf(stderr,
"Got longmatch=%d for name %s.\n",
longmatch, longname);
#endif
match = ssp->longmatch;
isprimary = 1;
} else if ((ch->use_longname & 1) && (ssp->shortmatch != -1)) {
/* Secondary Short Name Match */
#ifdef debug
fprintf(stderr,
"Got secondary short name match for name %s.\n",
longname);
#endif
match = ssp->shortmatch;
isprimary = 0;
} else if (ssp->shortmatch >= 0) {
/* Primary Short Name Match */
#ifdef debug
fprintf(stderr,
"Got primary short name match for name %s.\n",
longname);
#endif
match = ssp->shortmatch;
isprimary = 1;
} else
return NAMEMATCH_RENAME;
if(match > -1) {
entry.entry = match;
dir_read(&entry, &error);
if (error)
return NAMEMATCH_ERROR;
/* if we can't overwrite, don't propose it */
no_overwrite = (match == ch->source || IS_DIR(&entry));
}
}
ret = process_namematch(isprimary ? longname : dosname, longname,
isprimary, ch, no_overwrite, reason);
if (ret == NAMEMATCH_OVERWRITE && match > -1){
if((entry.dir.attr & 0x5) &&
(ask_confirmation("file is read only, overwrite anyway (y/n) ? ",0,0)))
return NAMEMATCH_RENAME;
/* Free up the file to be overwritten */
if(fatFreeWithDirentry(&entry))
return NAMEMATCH_ERROR;
#if 0
if(isprimary &&
match - ssp->match_free + 1 >= ssp->size_needed){
/* reuse old entry and old short name for overwrite */
ssp->free_start = match - ssp->size_needed + 1;
ssp->free_size = ssp->size_needed;
ssp->slot = match;
ssp->got_slots = 1;
strncpy(dosname, dir.name, 3);
strncpy(dosname + 8, dir.ext, 3);
return ret;
} else
#endif
{
entry.dir.name[0] = DELMARK;
dir_write(&entry);
return NAMEMATCH_RENAME;
}
}
return ret;
}
f_node_ptr dir_open(BYTE * dirname)
{
f_node_ptr fnp;
COUNT drive;
BYTE *p;
WORD i;
struct cds FAR *cdsp;
BYTE *pszPath = dirname + 2;
/* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (f_node_ptr)0)
{
return (f_node_ptr)0;
}
/* Force the fnode into read-write mode */
fnp->f_mode = RDWR;
/* determine what drive we are using... */
if (ParseDosName(dirname, &drive, (BYTE *) 0, (BYTE *) 0, (BYTE *) 0, FALSE)
!= SUCCESS)
{
release_f_node(fnp);
return NULL;
}
/* If the drive was specified, drive is non-negative and */
/* corresponds to the one passed in, i.e., 0 = A, 1 = B, etc. */
/* We use that and skip the "D:" part of the string. */
/* Otherwise, just use the default drive */
if (drive >= 0)
{
dirname += 2; /* Assume FAT style drive */
}
else
{
drive = default_drive;
}
if (drive >= lastdrive) {
release_f_node(fnp);
return NULL;
}
cdsp = &CDSp->cds_table[drive];
/* Generate full path name */
/* not necessary anymore, since truename did that already
i = cdsp->cdsJoinOffset;
ParseDosPath(dirname, (COUNT *) 0, pszPath, (BYTE FAR *) & cdsp->cdsCurrentPath[i]); */
/* for testing only for now */
#if 0
if ((cdsp->cdsFlags & CDSNETWDRV))
{
printf("FailSafe %x \n", Int21AX);
return fnp;
}
#endif
if (cdsp->cdsDpb == 0)
{
release_f_node(fnp);
return NULL;
}
fnp->f_dpb = cdsp->cdsDpb;
/* Perform all directory common handling after all special */
/* handling has been performed. */
if (media_check(fnp->f_dpb) < 0)
{
release_f_node(fnp);
return (f_node_ptr)0;
}
/* Walk the directory tree to find the starting cluster */
/* */
/* Start from the root directory (dirstart = 0) */
dir_init_fnode(fnp, 0);
for (p = pszPath; *p != '\0';)
{
/* skip all path seperators */
while (*p == '\\')
++p;
/* don't continue if we're at the end */
if (*p == '\0')
break;
/* Convert the name into an absolute name for */
/* comparison... */
/* first the file name with trailing spaces... */
memset(TempBuffer, ' ', FNAME_SIZE+FEXT_SIZE);
for (i = 0; i < FNAME_SIZE; i++)
{
if (*p != '\0' && *p != '.' && *p != '/' && *p != '\\')
TempBuffer[i] = *p++;
else
break;
}
/* and the extension (don't forget to */
/* add trailing spaces)... */
if (*p == '.')
++p;
for (i = 0; i < FEXT_SIZE; i++)
{
if (*p != '\0' && *p != '.' && *p != '/' && *p != '\\')
TempBuffer[i + FNAME_SIZE] = *p++;
else
break;
}
/* Now search through the directory to */
/* find the entry... */
i = FALSE;
DosUpFMem((BYTE FAR *) TempBuffer, FNAME_SIZE + FEXT_SIZE);
while (dir_read(fnp) == 1)
{
if (fnp->f_dir.dir_name[0] != '\0' && fnp->f_dir.dir_name[0] != DELETED)
{
if (fcmp(TempBuffer, (BYTE *)fnp->f_dir.dir_name, FNAME_SIZE + FEXT_SIZE))
{
i = TRUE;
break;
}
}
}
if (!i || !(fnp->f_dir.dir_attrib & D_DIR))
{
release_f_node(fnp);
return (f_node_ptr)0;
}
else
{
/* make certain we've moved off */
/* root */
dir_init_fnode(fnp, getdstart(fnp->f_dir));
}
}
return fnp;
}
void dir_read(char *path) {
DIR *dirp;
struct dirent *dp;
struct stat *buf;
char fullpath[1024];
char tn_fullpath[1024];
char dirname[1024];
char cptn_fullpath[1024];
char exec[1024];
buf=malloc(sizeof(*buf));
bzero(buf,sizeof(*buf));
stat(path,buf);
if(S_ISDIR(buf->st_mode)) {
dirp = opendir(path);
while ((dp = readdir(dirp))) {
bzero(buf,sizeof(*buf));
bzero(&fullpath,1024);
if(strcmp(dp->d_name,"..") && strcmp(dp->d_name,".")) {
snprintf(fullpath,BLOCK-1,"%s/%s",path,dp->d_name);
stat(fullpath,buf);
if(S_ISDIR(buf->st_mode)) {
printf("dir: %s\n",fullpath);
dir_read(fullpath);
} else if(S_ISREG(buf->st_mode) && !strstr(dp->d_name,"tn_") && strstr(dp->d_name,".jpg")) {
printf("file: %s\n",fullpath);
bzero(&tn_fullpath,1024);
bzero(&cptn_fullpath,1024);
bzero(&dirname,1024);
snprintf(tn_fullpath,BLOCK-1,"%s/tn_%s",path,dp->d_name);
strncpy(dirname,strrchr(path,'/')+1,strlen(path)-(int)(strrchr(path,'/')-path)-1);
bzero(buf,sizeof(*buf));
stat(tn_fullpath,buf);
if(!S_ISREG(buf->st_mode)) {
bzero(&exec,BLOCK);
snprintf(exec,BLOCK-1,"C:/DRV/im.exe -verbose -resize 120x120 %s %s",fullpath,tn_fullpath);
system(exec);
printf("create: %s\n",tn_fullpath);
}
snprintf(cptn_fullpath,BLOCK-1,"%s/tn_%s.jpg",path,dirname);
bzero(buf,sizeof(*buf));
stat(cptn_fullpath,buf);
if(!S_ISREG(buf->st_mode)) {
bzero(&exec,BLOCK);
snprintf(exec,BLOCK-1,"cp %s %s",tn_fullpath,cptn_fullpath);
system(exec);
}
}
}
}
closedir(dirp);
}
free(buf);
}
COUNT dos_findfirst(UCOUNT attr, BYTE *name)
{
REG f_node_ptr fnp;
REG dmatch *dmp = (dmatch *) TempBuffer;
REG COUNT i;
COUNT nDrive;
BYTE *p;
BYTE local_name[FNAME_SIZE + 1],
local_ext[FEXT_SIZE + 1];
/* printf("ff %Fs\n", name);*/
/* The findfirst/findnext calls are probably the worst of the */
/* DOS calls. They must work somewhat on the fly (i.e. - open */
/* but never close). Since we don't want to lose fnodes every */
/* time a directory is searched, we will initialize the DOS */
/* dirmatch structure and then for every find, we will open the */
/* current directory, do a seek and read, then close the fnode. */
/* Parse out the drive, file name and file extension. */
i = ParseDosName(name, &nDrive, &szDirName[2], local_name, local_ext, TRUE);
if (i != SUCCESS)
return i;
/*
printf("\nff %s", Tname);
printf("ff %s", local_name);
printf("ff %s\n", local_ext);
*/
/* Build the match pattern out of the passed string */
/* copy the part of the pattern which belongs to the filename and is fixed */
for (p = local_name, i = 0; i < FNAME_SIZE && *p; ++p, ++i)
SearchDir.dir_name[i] = *p;
for (; i < FNAME_SIZE; ++i)
SearchDir.dir_name[i] = ' ';
/* and the extension (don't forget to add trailing spaces)... */
for (p = local_ext, i = 0; i < FEXT_SIZE && *p; ++p, ++i)
SearchDir.dir_ext[i] = *p;
for (; i < FEXT_SIZE; ++i)
SearchDir.dir_ext[i] = ' ';
/* Convert everything to uppercase. */
DosUpFMem(SearchDir.dir_name, FNAME_SIZE + FEXT_SIZE);
/* Now search through the directory to find the entry... */
/* Complete building the directory from the passed in */
/* name */
szDirName[0] = 'A' + nDrive;
szDirName[1] = ':';
/* Special handling - the volume id is only in the root */
/* directory and only searched for once. So we need to open */
/* the root and return only the first entry that contains the */
/* volume id bit set. */
if (attr == D_VOLID)
{
szDirName[2] = '\\';
szDirName[3] = '\0';
}
/* Now open this directory so that we can read the */
/* fnode entry and do a match on it. */
/* printf("dir_open %s\n", szDirName);*/
if ((fnp = dir_open(szDirName)) == NULL)
return DE_PATHNOTFND;
/* Now initialize the dirmatch structure. */
nDrive=get_verify_drive(name);
if (nDrive < 0)
return nDrive;
dmp->dm_drive = nDrive;
dmp->dm_attr_srch = attr;
/* Copy the raw pattern from our data segment to the DTA. */
fmemcpy(dmp->dm_name_pat, SearchDir.dir_name, FNAME_SIZE + FEXT_SIZE);
if (attr == D_VOLID)
{
/* Now do the search */
while (dir_read(fnp) == 1)
{
/* Test the attribute and return first found */
if ((fnp->f_dir.dir_attrib & ~(D_RDONLY | D_ARCHIVE)) == D_VOLID)
{
dmp->dm_dircluster = fnp->f_dirstart; /* TE */
memcpy(&SearchDir, &fnp->f_dir, sizeof(struct dirent));
dir_close(fnp);
return SUCCESS;
}
}
/* Now that we've done our failed search, close it and */
/* return an error. */
dir_close(fnp);
return DE_FILENOTFND;
}
/* Otherwise just do a normal find next */
else
{
dmp->dm_entry = 0;
if (!fnp->f_flags.f_droot)
dmp->dm_dircluster = fnp->f_dirstart;
else
dmp->dm_dircluster = 0;
dir_close(fnp);
return dos_findnext();
}
}
COUNT dos_findnext(void)
{
REG dmatch *dmp = (dmatch *) TempBuffer;
REG f_node_ptr fnp;
BOOL found = FALSE;
/* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (f_node_ptr)0)
{
return DE_NFILES;
}
memset(fnp, 0, sizeof(*fnp));
/* Force the fnode into read-write mode */
fnp->f_mode = RDWR;
/* Select the default to help non-drive specified path */
/* searches... */
fnp->f_dpb = CDSp->cds_table[dmp->dm_drive].cdsDpb;
if (media_check(fnp->f_dpb) < 0)
{
release_f_node(fnp);
return DE_NFILES;
}
dir_init_fnode(fnp, dmp->dm_dircluster);
/* Search through the directory to find the entry, but do a */
/* seek first. */
if (dmp->dm_entry > 0)
{
fnp->f_diroff = (ULONG)(dmp->dm_entry - 1) * DIRENT_SIZE;
fnp->f_flags.f_dnew = FALSE;
}
else
{
fnp->f_diroff = 0;
fnp->f_flags.f_dnew = TRUE;
}
/* Loop through the directory */
while (dir_read(fnp) == 1)
{
++dmp->dm_entry;
if (fnp->f_dir.dir_name[0] != '\0' && fnp->f_dir.dir_name[0] != DELETED
&& (fnp->f_dir.dir_attrib & D_VOLID) != D_VOLID )
{
if (fcmp_wild((BYTE FAR *)dmp->dm_name_pat, (BYTE FAR *)fnp->f_dir.dir_name, FNAME_SIZE + FEXT_SIZE))
{
/*
MSD Command.com uses FCB FN 11 & 12 with attrib set to 0x16.
Bits 0x21 seem to get set some where in MSD so Rd and Arc
files are returned.
RdOnly + Archive bits are ignored
*/
/* Test the attribute as the final step */
if (!(fnp->f_dir.dir_attrib & D_VOLID) &&
((~dmp->dm_attr_srch & fnp->f_dir.dir_attrib & (D_DIR | D_SYSTEM | D_HIDDEN)) == 0))
{
found = TRUE;
break;
}
else
continue;
}
}
}
/* If found, transfer it to the dmatch structure */
if (found)
{
dmp->dm_dircluster = fnp->f_dirstart;
memcpy(&SearchDir, &fnp->f_dir, sizeof(struct dirent));
}
/* return the result */
release_f_node(fnp);
return found ? SUCCESS : DE_NFILES;
}
COUNT dos_findfirst(UCOUNT attr, BYTE FAR * name)
{
REG struct f_node FAR *fnp;
REG dmatch FAR *dmp = (dmatch FAR *) dta;
REG COUNT i;
COUNT nDrive;
BYTE *p;
struct cds FAR *cdsp;
static BYTE local_name[FNAME_SIZE + 1],
local_ext[FEXT_SIZE + 1];
/* The findfirst/findnext calls are probably the worst of the */
/* DOS calls. They must work somewhat on the fly (i.e. - open */
/* but never close). Since we don't want to lose fnodes every */
/* time a directory is searched, we will initialize the DOS */
/* dirmatch structure and then for every find, we will open the */
/* current directory, do a seek and read, then close the fnode. */
/* Start out by initializing the dirmatch structure. */
dmp->dm_drive = default_drive;
dmp->dm_entry = 0;
dmp->dm_cluster = 0;
dmp->dm_attr_srch = attr | D_RDONLY | D_ARCHIVE;
/* Parse out the drive, file name and file extension. */
i = ParseDosName(name, &nDrive, &LocalPath[2], local_name, local_ext, TRUE);
if (i != SUCCESS)
return i;
if (nDrive >= 0)
{
dmp->dm_drive = nDrive;
}
else
nDrive = default_drive;
cdsp = &CDSp->cds_table[nDrive];
if (cdsp->cdsFlags & 0x8000)
{
if (Remote_find(REM_FINDFIRST, attr, name, dmp) != 0)
return DE_FILENOTFND;
return SUCCESS;
}
/* Now build a directory. */
if (!LocalPath[2])
strcpy(&LocalPath[2], ".");
/* Build the match pattern out of the passed string */
/* copy the part of the pattern which belongs to the filename and is fixed */
for (p = local_name, i = 0; i < FNAME_SIZE && *p && *p != '*'; ++p, ++i)
SearchDir.dir_name[i] = *p;
if (*p == '*')
{
for (; i < FNAME_SIZE; ++i)
SearchDir.dir_name[i] = '?';
while (*++p) ;
}
else
for (; i < FNAME_SIZE; i++)
SearchDir.dir_name[i] = ' ';
/* and the extension (don't forget to add trailing spaces)... */
for (p = local_ext, i = 0; i < FEXT_SIZE && *p && *p != '*'; ++p, ++i)
SearchDir.dir_ext[i] = *p;
if (*p == '*')
{
for (; i < FEXT_SIZE; ++i)
SearchDir.dir_ext[i] = '?';
while (*++p) ;
}
else
for (; i < FEXT_SIZE; i++)
SearchDir.dir_ext[i] = ' ';
/* Convert everything to uppercase. */
upMem(SearchDir.dir_name, FNAME_SIZE + FEXT_SIZE);
/* Copy the raw pattern from our data segment to the DTA. */
fbcopy((BYTE FAR *) SearchDir.dir_name, dmp->dm_name_pat,
FNAME_SIZE + FEXT_SIZE);
/* Now search through the directory to find the entry... */
/* Special handling - the volume id is only in the root */
/* directory and only searched for once. So we need to open */
/* the root and return only the first entry that contains the */
/* volume id bit set. */
if ((attr & ~(D_RDONLY | D_ARCHIVE)) == D_VOLID)
{
/* Now open this directory so that we can read the */
/* fnode entry and do a match on it. */
if ((fnp = dir_open((BYTE FAR *) "\\")) == NULL)
return DE_PATHNOTFND;
/* Now do the search */
while (dir_read(fnp) == DIRENT_SIZE)
{
/* Test the attribute and return first found */
if ((fnp->f_dir.dir_attrib & ~(D_RDONLY | D_ARCHIVE)) == D_VOLID)
{
pop_dmp(dmp, fnp);
dir_close(fnp);
return SUCCESS;
}
}
/* Now that we've done our failed search, close it and */
/* return an error. */
dir_close(fnp);
return DE_FILENOTFND;
}
/* Otherwise just do a normal find next */
else
{
/* Complete building the directory from the passed in */
/* name */
if (nDrive >= 0)
LocalPath[0] = 'A' + nDrive;
else
LocalPath[0] = 'A' + default_drive;
LocalPath[1] = ':';
/* Now open this directory so that we can read the */
/* fnode entry and do a match on it. */
if ((fnp = dir_open((BYTE FAR *) LocalPath)) == NULL)
return DE_PATHNOTFND;
pop_dmp(dmp, fnp);
dmp->dm_entry = 0;
if (!fnp->f_flags.f_droot)
{
dmp->dm_cluster = fnp->f_dirstart;
dmp->dm_dirstart = fnp->f_dirstart;
}
else
{
dmp->dm_cluster = 0;
dmp->dm_dirstart = 0;
}
dir_close(fnp);
return dos_findnext();
}
}
COUNT dos_findnext(void)
{
REG dmatch FAR *dmp = (dmatch FAR *) dta;
REG struct f_node FAR *fnp;
BOOL found = FALSE;
BYTE FAR *p;
BYTE FAR *q;
COUNT nDrive;
struct cds FAR *cdsp;
/* assign our match parameters pointer. */
dmp = (dmatch FAR *) dta;
nDrive = dmp->dm_drive;
cdsp = &CDSp->cds_table[nDrive];
if (cdsp->cdsFlags & 0x8000)
{
if (Remote_find(REM_FINDNEXT, 0, 0, dmp) != 0)
return DE_FILENOTFND;
return SUCCESS;
}
/* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (struct f_node FAR *)0)
{
return DE_FILENOTFND;
}
/* Force the fnode into read-write mode */
fnp->f_mode = RDWR;
/* Select the default to help non-drive specified path */
/* searches... */
fnp->f_dpb = (struct dpb *)CDSp->cds_table[dmp->dm_drive].cdsDpb;
if (media_check(fnp->f_dpb) < 0)
{
release_f_node(fnp);
return DE_FILENOTFND;
}
fnp->f_dsize = DIRENT_SIZE * (fnp->f_dpb)->dpb_dirents;
/* Search through the directory to find the entry, but do a */
/* seek first. */
if (dmp->dm_entry > 0)
fnp->f_diroff = (dmp->dm_entry - 1) * DIRENT_SIZE;
fnp->f_offset = fnp->f_highwater = fnp->f_diroff;
fnp->f_cluster = dmp->dm_cluster;
fnp->f_cluster_offset = 0l; /*JPP */
fnp->f_flags.f_dmod = dmp->dm_flags.f_dmod;
fnp->f_flags.f_droot = dmp->dm_flags.f_droot;
fnp->f_flags.f_dnew = dmp->dm_flags.f_dnew;
fnp->f_flags.f_ddir = dmp->dm_flags.f_ddir;
fnp->f_flags.f_dfull = dmp->dm_flags.f_dfull;
fnp->f_dirstart = dmp->dm_dirstart;
/* Loop through the directory */
while (dir_read(fnp) == DIRENT_SIZE)
{
++dmp->dm_entry;
if (fnp->f_dir.dir_name[0] != '\0' && fnp->f_dir.dir_name[0] != DELETED)
{
if (fcmp_wild((BYTE FAR *) (dmp->dm_name_pat), (BYTE FAR *) fnp->f_dir.dir_name, FNAME_SIZE + FEXT_SIZE))
{
/* Test the attribute as the final step */
if (!(~dmp->dm_attr_srch & fnp->f_dir.dir_attrib))
{
found = TRUE;
break;
}
else
continue;
}
}
}
/* If found, transfer it to the dmatch structure */
if (found)
pop_dmp(dmp, fnp);
/* return the result */
release_f_node(fnp);
return found ? SUCCESS : DE_FILENOTFND;
}
struct f_node FAR *dir_open(BYTE FAR * dirname)
{
struct f_node FAR *fnp;
COUNT drive;
BYTE *p;
WORD i,
x;
BYTE *s;
struct cds FAR *cdsp;
BYTE *pszPath = &TempCDS.cdsCurrentPath[2];
/* Allocate an fnode if possible - error return (0) if not. */
if ((fnp = get_f_node()) == (struct f_node FAR *)0)
{
return (struct f_node FAR *)NULL;
}
/* Force the fnode into read-write mode */
fnp->f_mode = RDWR;
/* and initialize temporary CDS */
TempCDS.cdsFlags = 0;
/* determine what drive we are using... */
dirname = adjust_far(dirname);
if (ParseDosName(dirname, &drive, (BYTE *) 0, (BYTE *) 0, (BYTE *) 0, FALSE)
!= SUCCESS)
{
release_f_node(fnp);
return NULL;
}
/* If the drive was specified, drive is non-negative and */
/* corresponds to the one passed in, i.e., 0 = A, 1 = B, etc. */
/* We use that and skip the "D:" part of the string. */
/* Otherwise, just use the default drive */
if (drive >= 0)
{
dirname += 2; /* Assume FAT style drive */
TempCDS.cdsDpb = CDSp->cds_table[drive].cdsDpb;
}
else
{
drive = default_drive;
TempCDS.cdsDpb = CDSp->cds_table[drive].cdsDpb;
}
cdsp = &CDSp->cds_table[drive];
TempCDS.cdsCurrentPath[0] = 'A' + drive;
TempCDS.cdsCurrentPath[1] = ':';
TempCDS.cdsJoinOffset = 2;
x = cdsp->cdsJoinOffset;
/* Generate full path name */
ParseDosPath(dirname, (COUNT *) 0, pszPath, (BYTE FAR *) & cdsp->cdsCurrentPath[x]);
if ((cdsp->cdsFlags & 0x8000))
{
printf("FailSafe %x \n", Int21AX);
return fnp;
}
if (TempCDS.cdsDpb == 0)
{
release_f_node(fnp);
return NULL;
}
/* if (drive >= lastdrive)
{
release_f_node(fnp);
return NULL;
}
*/
fnp->f_dpb = (struct dpb *)TempCDS.cdsDpb;
/* Perform all directory common handling after all special */
/* handling has been performed. */
if (media_check((struct dpb *)TempCDS.cdsDpb) < 0)
{
release_f_node(fnp);
return (struct f_node FAR *)0;
}
fnp->f_dsize = DIRENT_SIZE * TempCDS.cdsDpb->dpb_dirents;
fnp->f_diroff = 0l;
fnp->f_flags.f_dmod = FALSE; /* a brand new fnode */
fnp->f_flags.f_dnew = TRUE;
fnp->f_flags.f_dremote = FALSE;
fnp->f_dirstart = 0;
/* Walk the directory tree to find the starting cluster */
/* */
/* Set the root flags since we always start from the root */
fnp->f_flags.f_droot = TRUE;
for (p = pszPath; *p != '\0';)
{
/* skip all path seperators */
while (*p == '\\')
++p;
/* don't continue if we're at the end */
if (*p == '\0')
break;
/* Convert the name into an absolute name for */
/* comparison... */
/* first the file name with trailing spaces... */
for (i = 0; i < FNAME_SIZE; i++)
{
if (*p != '\0' && *p != '.' && *p != '/' && *p != '\\')
TempBuffer[i] = *p++;
else
break;
}
for (; i < FNAME_SIZE; i++)
TempBuffer[i] = ' ';
/* and the extension (don't forget to */
/* add trailing spaces)... */
if (*p == '.')
++p;
for (i = 0; i < FEXT_SIZE; i++)
{
if (*p != '\0' && *p != '.' && *p != '/' && *p != '\\')
TempBuffer[i + FNAME_SIZE] = *p++;
else
break;
}
for (; i < FEXT_SIZE; i++)
TempBuffer[i + FNAME_SIZE] = ' ';
/* Now search through the directory to */
/* find the entry... */
i = FALSE;
upMem((BYTE FAR *) TempBuffer, FNAME_SIZE + FEXT_SIZE);
while (dir_read(fnp) == DIRENT_SIZE)
{
if (fnp->f_dir.dir_name[0] != '\0' && fnp->f_dir.dir_name[0] != DELETED)
{
if (fcmp((BYTE FAR *) TempBuffer, (BYTE FAR *) fnp->f_dir.dir_name, FNAME_SIZE + FEXT_SIZE))
{
i = TRUE;
break;
}
}
}
if (!i || !(fnp->f_dir.dir_attrib & D_DIR))
{
release_f_node(fnp);
return (struct f_node FAR *)0;
}
else
{
/* make certain we've moved off */
/* root */
fnp->f_flags.f_droot = FALSE;
fnp->f_flags.f_ddir = TRUE;
/* set up for file read/write */
fnp->f_offset = 0l;
fnp->f_cluster_offset = 0l; /*JPP */
fnp->f_highwater = 0l;
fnp->f_cluster = fnp->f_dir.dir_start;
fnp->f_dirstart = fnp->f_dir.dir_start;
/* reset the directory flags */
fnp->f_diroff = 0l;
fnp->f_flags.f_dmod = FALSE;
fnp->f_flags.f_dnew = TRUE;
fnp->f_dsize = DIRENT_SIZE * TempCDS.cdsDpb->dpb_dirents;
}
}
return fnp;
}
void dir_read(const char dir[])
{
struct direct **files;
long nfiles, x;
int dir_filter(const struct direct *entry);
char path[500];
char fnames[500];
//
//FILE *doc_dic;
//
nfiles = scandir(dir, &files, dir_filter, alphasort);
for(x=0;x<nfiles;x++)
{
if( files[x]->d_type == DT_DIR )
{
strcpy(path,"\0");
strcpy(path,dir);
strcat(path,"/");
strcat(path,files[x]->d_name);
dir_read(path);
}
}
if(nfiles <= 0);
//return 0;
for(x=0;x<nfiles;x++)
if(files[x]->d_type != DT_DIR)
{
strcpy(fnames,"\0");
sprintf(fnames,"%s/%s", dir, files[x]->d_name);
strcat(fnames,"\0");
//printf("\nIndexing File : %s",fnames);
//////////////Doc Dic start
/*
doc_dic = fopen("../bin/docdic","ab+");
doc_dictionay *dd_node = (doc_dictionay *)malloc(sizeof(doc_dictionay));
dd_node->docID = ++doc_count;
strcpy(dd_node->path,fnames);
dd_node->path[strlen(dd_node->path)]='\0';
fwrite(dd_node,sizeof(doc_dictionay),1,doc_dic);
fclose(doc_dic);
free(dd_node);
*/
//Doc Dic
++doc_count;
g_idocid = doc_count;
//v2.1
strcpy(g_ifile,"\0");//Remove previous contents
strcpy(g_ifile,fnames); //copying current indexing file to global variable g_ifile
g_ifile[strlen(g_ifile)]='\0';
//printf("Indexing File gfile name %s\n",g_ifile);
//End of v2.1
/* */
fflush(stdin);
do_stem(fnames);// stemmed o/p will be in ../bin/stemop
genHash("../bin/stemop"); //For every File read Start building Tree
//Write Doc_Dic
doc_dictionay *dd_node = (doc_dictionay *)malloc(sizeof(doc_dictionay));
dd_node->docID = doc_count;
dd_node->doc_len = doc_len;
strcpy(dd_node->path,fnames);
dd_node->path[strlen(dd_node->path)]='\0';
dd_node->next = NULL;
if(doc_dic_root)
{
doc_dic_last->next = dd_node;
doc_dic_last = dd_node;
}
else
{
doc_dic_root = dd_node;
doc_dic_last = doc_dic_root;
}
//
avg_doc_len = (double) ( (( avg_doc_len*(doc_count-1) ) + doc_len )/doc_count);
}
}
JNIEXPORT jobjectArray JNICALL Java_org_videolan_Libbluray_listBdFilesN(JNIEnv * env,
jclass cls, jlong np, jstring jpath,
jboolean onlyBdRom) {
BLURAY *bd = (BLURAY*)(intptr_t)np;
BD_DISC *disc = bd_get_disc(bd);
const char *path = (*env)->GetStringUTFChars(env, jpath, NULL);
if (!path) {
BD_DEBUG(DBG_JNI | DBG_CRIT, "listBdFilesN() failed: no path\n");
return NULL;
}
BD_DEBUG(DBG_JNI, "listBdFilesN(%s)\n", path);
/* open directory stream */
BD_DIR_H *dp;
if (onlyBdRom) {
dp = disc_open_bdrom_dir(disc, path);
} else {
dp = disc_open_dir(disc, path);
}
if (!dp) {
BD_DEBUG(DBG_JNI, "failed opening directory %s\n", path);
(*env)->ReleaseStringUTFChars(env, jpath, path);
return NULL;
}
(*env)->ReleaseStringUTFChars(env, jpath, path);
/* count files and create java strings (java array size must be known when it is created) */
jstring *files = NULL;
unsigned count = 0;
unsigned allocated = 0;
BD_DIRENT ent;
while (!dir_read(dp, &ent)) {
if (strcmp(ent.d_name, ".") && strcmp(ent.d_name, "..")) {
if (allocated <= count) {
allocated += 512;
jstring *tmp = realloc(files, sizeof(*files) * allocated);
if (!tmp) {
BD_DEBUG(DBG_JNI | DBG_CRIT, "failed allocating memory for %u directory entries\n", allocated);
break;
}
files = tmp;
}
files[count] = (*env)->NewStringUTF(env, ent.d_name);
count++;
}
}
dir_close(dp);
/* allocate java array */
jobjectArray arr = bdj_make_array(env, "java/lang/String", count);
if (!arr) {
BD_DEBUG(DBG_JNI | DBG_CRIT, "failed creating array [%d]\n", count);
} else {
/* populate files to array */
unsigned ii;
for (ii = 0; ii < count; ii++) {
(*env)->SetObjectArrayElement(env, arr, ii, files[ii]);
}
}
X_FREE(files);
return arr;
}
void shell()
{
char shell_buffer[100];
char *tmp1,*tmp2;
tmp1=shell_buffer;
char *mountpt="/hiphop/";
int flag=0;
int cmd_loc=5;
struct file fd;
struct file *fd_p;
//uint64_t *fd1=(uint64_t *)kmalloc(sizeof(struct file));
//fd=(struct file*)fd1;
int i=0;
char commands[3][10]={"echo","ls","cd"};
commands[1][2]='\0';
commands[0][5]='\0';
commands[2][2]='\0';
//char *tmp;
char* tmp3;
//blacken();
clear_screen();
char pwd[40]="";
pwd[0]='\0';
int k=3;
while(1)
{
for(i=0;i<k;i++)
shell_buffer[i]='\0';
flag=0;
cmd_loc=5;
printk("\n Shell ~%s>",pwd);
scank("%s",shell_buffer);
tmp1=shell_buffer;
for(i=0;i<3;i++)
{
tmp2=commands[i];
if(*tmp1!=*tmp2)
continue;
while(*tmp1==*tmp2)
{
tmp1++;
tmp2++;
//printk("[%c] [%c]",*tmp1,*tmp2);
}
if((*tmp2=='\0')&&(*tmp1==' '))
{
flag=1;
tmp1++;
cmd_loc=i;
}
//printk("[i=%d]",i);
}
if(flag==0)
{
printk("command not found");
continue;
}
tmp2=tmp1;
//printk("%s",tmp2);
tmp3=mountpt;
while(*tmp1==*tmp3)
{
tmp1++;
tmp3++;
}
flag=0;
if((*tmp1!='\0')&&(*tmp3=='\0') && *(tmp1-1)=='/')
{
flag=1;
}
switch(cmd_loc)
{
case 0:
//printk("echo encountered");
break;
case 1:
//printk("ls encountered");
strcpy(fd.filename,tmp2);
fd.location=flag;//while(1);
//printk("%s,%d",fd.filename,fd.location);
for(i=0;i<k;i++)
shell_buffer[i]='\0';
// while(1);
//readdir_ls(&fd,shell_buffer,10);
if(flag==1)
dir_read(&fd,shell_buffer,100);
else
read_dir_ls(&fd,shell_buffer,100);
tmp2=shell_buffer;
while(*tmp2!='\0')
{
if(*tmp2==',')
*tmp2='\t';
tmp2++;
}
printk("\n%s",shell_buffer);
//while(1);
break;
case 2:
/*if(strcmp("..",tmp2)==0)
{
if(flag==1)
tmp=pwd+strlen(pwd)-1;
else
tmp=pwd+strlen(pwd)-2;
tmp1=pwd;
while(*tmp!='/' || tmp1!=tmp)
tmp--;
if(tmp1==tmp)
*tmp='\0';
else {
tmp++;
tmp='\0';}
}*/
//else
//{
strcpy(fd.filename,tmp2);
fd.location=flag;
if(flag==1)
{
printk("\n [[%d]]",make_dir(fd.filename));
fd_p=(struct file*)0x1;
//fd_p=file_open(fd.filename,5);
if(fd_p==NULL)
{
printk("NO directory exists");
continue;
}
}
else
{
fd_p=open_file_tarfs(fd.filename);//fd_p=open_dir_tarfs(fd.filename);
if(fd_p==NULL)
{
printk("NO directory exists");
continue;
}
}
strcpy(pwd,tmp2);
//}
//fd.location;
break;
default:
printk("BAD command");
}
}
}
int
diff_dirs (struct comparison const *cmp,
int (*handle_file) (struct comparison const *,
char const *, char const *))
{
struct dirdata dirdata[2];
int volatile val = EXIT_SUCCESS;
int i;
if ((cmp->file[0].desc == -1 || dir_loop (cmp, 0))
&& (cmp->file[1].desc == -1 || dir_loop (cmp, 1)))
{
error (0, 0, "%s: recursive directory loop",
cmp->file[cmp->file[0].desc == -1].name);
return EXIT_TROUBLE;
}
/* Get contents of both dirs. */
for (i = 0; i < 2; i++)
if (! dir_read (&cmp->file[i], &dirdata[i]))
{
perror_with_name (cmp->file[i].name);
val = EXIT_TROUBLE;
}
if (val == EXIT_SUCCESS)
{
char const **volatile names[2];
names[0] = dirdata[0].names;
names[1] = dirdata[1].names;
/* Use locale-specific sorting if possible, else native byte order. */
locale_specific_sorting = true;
if (setjmp (failed_locale_specific_sorting))
locale_specific_sorting = false;
/* Sort the directories. */
for (i = 0; i < 2; i++)
qsort (names[i], dirdata[i].nnames, sizeof *dirdata[i].names,
compare_names_for_qsort);
/* If `-S name' was given, and this is the topmost level of comparison,
ignore all file names less than the specified starting name. */
if (starting_file && ! cmp->parent)
{
while (*names[0] && compare_names (*names[0], starting_file) < 0)
names[0]++;
while (*names[1] && compare_names (*names[1], starting_file) < 0)
names[1]++;
}
/* Loop while files remain in one or both dirs. */
while (*names[0] || *names[1])
{
/* Compare next name in dir 0 with next name in dir 1.
At the end of a dir,
pretend the "next name" in that dir is very large. */
int nameorder = (!*names[0] ? 1 : !*names[1] ? -1
: compare_names (*names[0], *names[1]));
int v1 = (*handle_file) (cmp,
0 < nameorder ? 0 : *names[0]++,
nameorder < 0 ? 0 : *names[1]++);
if (val < v1)
val = v1;
}
}
for (i = 0; i < 2; i++)
{
if (dirdata[i].names)
free (dirdata[i].names);
if (dirdata[i].data)
free (dirdata[i].data);
}
return val;
}
