/*
* adfCheckEntry
*
*/
RETCODE adfCheckEntry(struct Volume* vol, SECTNUM nSect, int level)
{
struct bEntryBlock entry;
RETCODE rc;
adfReadEntryBlock(vol,nSect,&entry);
switch(entry.secType) {
case ST_FILE:
rc = adfCheckFile(vol, nSect, (struct bFileHeaderBlock*)&entry, level);
break;
case ST_DIR:
rc = adfCheckDir(vol, nSect, (struct bDirBlock*)&entry, level);
break;
default:
/* printf("adfCheckEntry : not supported\n");*/ /* BV */
rc = RC_ERROR;
}
return rc;
}
/*
* adfUndelDir
*
*/
RETCODE adfUndelDir(struct Volume* vol, SECTNUM pSect, SECTNUM nSect,
struct bDirBlock* entry)
{
RETCODE rc;
struct bEntryBlock parent;
char name[MAXNAMELEN+1];
/* check if the given parent sector pointer seems OK */
if ( (rc=adfCheckParent(vol,pSect)) != RC_OK)
return rc;
if (pSect!=entry->parent) {
(*adfEnv.wFct)("adfUndelDir : the given parent sector isn't the entry parent");
return RC_ERROR;
}
if (!adfIsBlockFree(vol, entry->headerKey))
return RC_ERROR;
if (isDIRCACHE(vol->dosType) && !adfIsBlockFree(vol,entry->extension))
return RC_ERROR;
if (adfReadEntryBlock(vol, pSect, &parent)!=RC_OK)
return RC_ERROR;
strncpy(name, entry->dirName, entry->nameLen);
name[(int)entry->nameLen] = '\0';
/* insert the entry in the parent hashTable, with the headerKey sector pointer */
adfSetBlockUsed(vol,entry->headerKey);
adfCreateEntry(vol, &parent, name, entry->headerKey);
if (isDIRCACHE(vol->dosType)) {
adfAddInCache(vol, &parent, (struct bEntryBlock *)entry);
adfSetBlockUsed(vol,entry->extension);
}
adfUpdateBitmap(vol);
return RC_OK;
}
/*
* adfCreateFile
*
*/
RETCODE adfCreateFile(struct Volume* vol, SECTNUM nParent, char *name,
struct bFileHeaderBlock *fhdr)
{
SECTNUM nSect;
struct bEntryBlock parent;
/*puts("adfCreateFile in");*/
if (adfReadEntryBlock(vol, nParent, &parent)!=RC_OK)
return RC_ERROR;
/* -1 : do not use a specific, already allocated sector */
nSect = adfCreateEntry(vol, &parent, name, -1);
if (nSect==-1) return RC_ERROR;
/*printf("new fhdr=%d\n",nSect);*/
memset(fhdr,0,512);
fhdr->nameLen = (char)min(MAXNAMELEN, strlen(name));
memcpy(fhdr->fileName,name,fhdr->nameLen);
fhdr->headerKey = nSect;
if (parent.secType==ST_ROOT)
fhdr->parent = vol->rootBlock;
else if (parent.secType==ST_DIR)
fhdr->parent = parent.headerKey;
else
(*adfEnv.wFct)("adfCreateFile : unknown parent secType");
adfTime2AmigaTime(adfGiveCurrentTime(),
&(fhdr->days),&(fhdr->mins),&(fhdr->ticks));
if (adfWriteFileHdrBlock(vol,nSect,fhdr)!=RC_OK)
return RC_ERROR;
if (isDIRCACHE(vol->dosType))
adfAddInCache(vol, &parent, (struct bEntryBlock *)fhdr);
adfUpdateBitmap(vol);
if (adfEnv.useNotify)
(*adfEnv.notifyFct)(nParent,ST_FILE);
return RC_OK;
}
RETCODE adfBlockPtr2EntryName(struct Volume *vol, SECTNUM nSect, SECTNUM lPar,
char **name, long *size)
{
struct bEntryBlock entryBlk;
struct Entry entry;
if (*name==0) {
adfReadEntryBlock(vol, nSect, &entryBlk);
*size = entryBlk.byteSize;
return RC_OK;
adfEntBlock2Entry(&entryBlk, &entry); //error
/* if (entryBlk.secType!=ST_ROOT && entry.parent!=lPar)
printf("path=%s\n",path(vol,entry.parent));
*/
*name = strdup("");
if (*name==NULL)
return RC_MALLOC;
return RC_OK;
}
else
return RC_OK;
}
/*
* adfFileFlush
*
*/
void adfFlushFile(struct File *file)
{
struct bEntryBlock parent;
struct bOFSDataBlock *data;
if (file->currentExt) {
if (file->writeMode)
adfWriteFileExtBlock(file->volume, file->currentExt->headerKey,
file->currentExt);
}
if (file->currentData) {
if (file->writeMode) {
file->fileHdr->byteSize = file->pos;
if (isOFS(file->volume->dosType)) {
data = (struct bOFSDataBlock *)file->currentData;
data->dataSize = file->posInDataBlk;
}
if (file->fileHdr->byteSize>0)
adfWriteDataBlock(file->volume, file->curDataPtr,
file->currentData);
}
}
if (file->writeMode) {
file->fileHdr->byteSize = file->pos;
/*printf("pos=%ld\n",file->pos);*/
adfTime2AmigaTime(adfGiveCurrentTime(),
&(file->fileHdr->days),&(file->fileHdr->mins),&(file->fileHdr->ticks) );
adfWriteFileHdrBlock(file->volume, file->fileHdr->headerKey, file->fileHdr);
if (isDIRCACHE(file->volume->dosType)) {
/*printf("parent=%ld\n",file->fileHdr->parent);*/
adfReadEntryBlock(file->volume, file->fileHdr->parent, &parent);
adfUpdateCache(file->volume, &parent, (struct bEntryBlock*)file->fileHdr,FALSE);
}
adfUpdateBitmap(file->volume);
}
}
/*
* adfGetDirEntCache
*
* replace 'adfGetDirEnt'. returns a the dir contents based on the dircache list
*/
struct List* adfGetDirEntCache(struct Volume *vol, SECTNUM dir, BOOL recurs)
{
struct bEntryBlock parent;
struct bDirCacheBlock dirc;
int offset, n;
struct List *cell, *head;
struct CacheEntry caEntry;
struct Entry *entry;
SECTNUM nSect;
if (adfReadEntryBlock(vol,dir,&parent)!=RC_OK)
return NULL;
nSect = parent.extension;
cell = head = NULL;
do {
/* one loop per cache block */
n = offset = 0;
if (adfReadDirCBlock(vol, nSect, &dirc)!=RC_OK)
return NULL;
while (n<dirc.recordsNb) {
/* one loop per record */
entry = (struct Entry*)calloc(1,sizeof(struct Entry));
if (!entry) {
adfFreeDirList(head);
return NULL;
}
adfGetCacheEntry(&dirc, &offset, &caEntry);
/* converts a cache entry into a dir entry */
entry->type = (int)caEntry.type;
#if defined (WIN32)
entry->name = _strdup(caEntry.name);
#else
entry->name = strdup(caEntry.name);
#endif
if (entry->name==NULL) {
free(entry); adfFreeDirList(head);
return NULL;
}
entry->sector = caEntry.header;
#if defined (WIN32)
entry->comment = _strdup(caEntry.comm);
#else
entry->comment = strdup(caEntry.comm);
#endif
if (entry->comment==NULL) {
free(entry->name); adfFreeDirList(head);
return NULL;
}
entry->size = caEntry.size;
entry->access = caEntry.protect;
adfDays2Date( caEntry.days, &(entry->year), &(entry->month),
&(entry->days) );
entry->hour = caEntry.mins/60;
entry->mins = caEntry.mins%60;
entry->secs = caEntry.ticks/50;
/* add it into the linked list */
if (head==NULL)
head = cell = newCell(NULL, (void*)entry);
else
cell = newCell(cell, (void*)entry);
if (cell==NULL) {
adfFreeEntry(entry);
adfFreeDirList(head);
return NULL;
}
if (recurs && entry->type==ST_DIR)
cell->subdir = adfGetDirEntCache(vol,entry->sector,recurs);
n++;
}
nSect = dirc.nextDirC;
}while (nSect!=0);
return head;
}
static int changedir(FSMNG * fsmng,char * path,SECTNUM * curdir,int dir)
{
int i,ret;
char tmppath[512];
char * tmpptr;
struct bEntryBlock entry;
struct Volume * adfvolume;
adfvolume = (struct Volume *)fsmng->volume;
if(strlen(path))
{
i = 0;
if(path[i]=='/')
{
ret = adfToRootDir(adfvolume);
i++;
}
while(path[i])
{
tmpptr = strchr(&path[i],'/');
memset(tmppath,0,sizeof(tmppath));
if(tmpptr)
{
strncpy(tmppath,&path[i],tmpptr-&path[i]);
i = i + (tmpptr-&path[i]) + 1;
}
else
{
strcpy(tmppath,&path[i]);
i = i + strlen(&path[i]);
}
if(strlen(tmppath))
ret = adfChangeDir(adfvolume,tmppath);
else
break;
}
}
if(!ret)
{
ret = adfReadEntryBlock(adfvolume,adfvolume->curDirPtr,&entry);
if(!ret)
{
if(dir)
{
if(entry.secType == ST_DIR || entry.secType == ST_ROOT)
{
if(curdir)
*curdir = adfvolume->curDirPtr;
return 0;
}
else
return 1;
}
else
{
if(entry.secType == ST_FILE || entry.secType == ST_LFILE)
{
if(curdir)
*curdir = adfvolume->curDirPtr;
return 0;
}
else
return 1;
}
}
}
return ret;
}
/*
* adfFileOpen
*
*/
struct File* adfOpenFile(struct Volume *vol, char* name, char *mode)
{
struct File *file;
SECTNUM nSect;
struct bEntryBlock entry, parent;
BOOL write;
char filename[200];
write=( strcmp("w",mode)==0 || strcmp("a",mode)==0 );
if (write && vol->dev->readOnly) {
(*adfEnv.wFct)("adfFileOpen : device is mounted 'read only'");
return NULL;
}
adfReadEntryBlock(vol, vol->curDirPtr, &parent);
nSect = adfNameToEntryBlk(vol, parent.hashTable, name, &entry, NULL);
if (!write && nSect==-1) {
sprintf(filename,"adfFileOpen : file \"%s\" not found.",name);
(*adfEnv.wFct)(filename);
/*fprintf(stdout,"filename %s %d, parent =%d\n",name,strlen(name),vol->curDirPtr);*/
return NULL;
}
if (!write && hasR(entry.access)) {
(*adfEnv.wFct)("adfFileOpen : access denied"); return NULL; }
/* if (entry.secType!=ST_FILE) {
(*adfEnv.wFct)("adfFileOpen : not a file"); return NULL; }
if (write && (hasE(entry.access)||hasW(entry.access))) {
(*adfEnv.wFct)("adfFileOpen : access denied"); return NULL; }
*/ if (write && nSect!=-1) {
(*adfEnv.wFct)("adfFileOpen : file already exists"); return NULL; }
file = (struct File*)calloc(1,sizeof(struct File));
if (!file) { (*adfEnv.wFct)("adfFileOpen : malloc"); return NULL; }
file->fileHdr = (struct bFileHeaderBlock*)calloc(1,sizeof(struct bFileHeaderBlock));
if (!file->fileHdr) {
(*adfEnv.wFct)("adfFileOpen : malloc");
free(file); return NULL;
}
file->currentData = calloc(1,512*sizeof(unsigned char));
if (!file->currentData) {
(*adfEnv.wFct)("adfFileOpen : malloc");
free(file->fileHdr); free(file); return NULL;
}
file->volume = vol;
file->pos = 0;
file->posInExtBlk = 0;
file->posInDataBlk = 0;
file->writeMode = write;
file->currentExt = NULL;
file->nDataBlock = 0;
if (strcmp("w",mode)==0) {
memset(file->fileHdr,0,512);
adfCreateFile(vol,vol->curDirPtr,name,file->fileHdr);
file->eof = TRUE;
}
else if (strcmp("a",mode)==0) {
memcpy(file->fileHdr,&entry,sizeof(struct bFileHeaderBlock));
file->eof = TRUE;
adfFileSeek(file, file->fileHdr->byteSize);
}
else if (strcmp("r",mode)==0) {
memcpy(file->fileHdr,&entry,sizeof(struct bFileHeaderBlock));
file->eof = FALSE;
}
/*puts("adfOpenFile");*/
return(file);
}
/*
* adfCreateEntry
*
* if 'thisSect'==-1, allocate a sector, and insert its pointer into the hashTable of 'dir', using the
* name 'name'. if 'thisSect'!=-1, insert this sector pointer into the hashTable
* (here 'thisSect' must be allocated before in the bitmap).
*/
SECTNUM adfCreateEntry(struct Volume *vol, struct bEntryBlock *dir, char *name,
SECTNUM thisSect )
{
BOOL intl;
struct bEntryBlock updEntry;
int len, hashValue;
RETCODE rc;
char name2[MAXNAMELEN+1], name3[MAXNAMELEN+1];
SECTNUM nSect, newSect, newSect2;
struct bRootBlock* root;
/*puts("adfCreateEntry in");*/
intl = isINTL(vol->dosType) || isDIRCACHE(vol->dosType);
len = min(strlen(name), MAXNAMELEN) ;
myToUpper((unsigned char*)name2, (unsigned char*)name, len, intl);
hashValue = adfGetHashValue((unsigned char*)name, intl);
nSect = dir->hashTable[ hashValue ];
if ( nSect==0 ) {
if (thisSect!=-1)
newSect = thisSect;
else {
newSect = adfGet1FreeBlock(vol);
if (newSect==-1) {
(*adfEnv.wFct)("adfCreateEntry : nSect==-1");
return -1;
}
}
dir->hashTable[ hashValue ] = newSect;
if (dir->secType==ST_ROOT) {
root = (struct bRootBlock*)dir;
adfTime2AmigaTime(adfGiveCurrentTime(),
&(root->cDays),&(root->cMins),&(root->cTicks));
rc=adfWriteRootBlock(vol, vol->rootBlock, root);
}
else {
adfTime2AmigaTime(adfGiveCurrentTime(),&(dir->days),&(dir->mins),&(dir->ticks));
rc=adfWriteDirBlock(vol, dir->headerKey, (struct bDirBlock*)dir);
}
/*puts("adfCreateEntry out, dir");*/
if (rc!=RC_OK) {
adfSetBlockFree(vol, newSect);
return -1;
}
else
return( newSect );
}
do {
if (adfReadEntryBlock(vol, nSect, &updEntry)!=RC_OK)
return -1;
if (updEntry.nameLen==len) {
myToUpper((unsigned char*)name3,(unsigned char*)updEntry.name,updEntry.nameLen,intl);
if (strncmp(name3,name2,len)==0) {
(*adfEnv.wFct)("adfCreateEntry : entry already exists");
return -1;
}
}
nSect = updEntry.nextSameHash;
}while(nSect!=0);
if (thisSect!=-1)
newSect2 = thisSect;
else {
newSect2 = adfGet1FreeBlock(vol);
if (newSect2==-1) {
(*adfEnv.wFct)("adfCreateEntry : nSect==-1");
return -1;
}
}
rc = RC_OK;
updEntry.nextSameHash = newSect2;
if (updEntry.secType==ST_DIR)
rc=adfWriteDirBlock(vol, updEntry.headerKey, (struct bDirBlock*)&updEntry);
else if (updEntry.secType==ST_FILE)
rc=adfWriteFileHdrBlock(vol, updEntry.headerKey,
(struct bFileHeaderBlock*)&updEntry);
else
(*adfEnv.wFct)("adfCreateEntry : unknown entry type");
/*puts("adfCreateEntry out, hash");*/
if (rc!=RC_OK) {
adfSetBlockFree(vol, newSect2);
return -1;
}
else
return(newSect2);
}
/*
* adfRenameEntry
*
*/
RETCODE adfRenameEntry(struct Volume *vol, SECTNUM pSect, char *oldName,
SECTNUM nPSect, char *newName)
{
struct bEntryBlock parent, previous, entry, nParent;
SECTNUM nSect2, nSect, prevSect, tmpSect;
int hashValueO, hashValueN, len;
char name2[MAXNAMELEN+1], name3[MAXNAMELEN+1];
BOOL intl;
RETCODE rc;
if (strcmp(oldName,newName)==0)
return RC_OK;
intl = isINTL(vol->dosType) || isDIRCACHE(vol->dosType);
len = strlen(newName);
myToUpper((unsigned char*)name2, (unsigned char*)newName, len, intl);
myToUpper((unsigned char*)name3, (unsigned char*)oldName, strlen(oldName), intl);
/* newName == oldName ? */
if (adfReadEntryBlock( vol, pSect, &parent )!=RC_OK)
return RC_ERROR;
hashValueO = adfGetHashValue((unsigned char*)oldName, intl);
nSect = adfNameToEntryBlk(vol, parent.hashTable, oldName, &entry, &prevSect);
if (nSect==-1) {
(*adfEnv.wFct)("adfRenameEntry : existing entry not found");
return RC_ERROR;
}
/* change name and parent dir */
entry.nameLen = (char)min(31, strlen(newName));
memcpy(entry.name, newName, entry.nameLen);
entry.parent = nPSect;
tmpSect = entry.nextSameHash;
entry.nextSameHash = 0;
if (adfWriteEntryBlock(vol, nSect, &entry)!=RC_OK)
return RC_ERROR;
/* del from the oldname list */
/* in hashTable */
if (prevSect==0) {
parent.hashTable[hashValueO] = tmpSect;
if (parent.secType==ST_ROOT)
rc = adfWriteRootBlock(vol, pSect, (struct bRootBlock*)&parent);
else
rc = adfWriteDirBlock(vol, pSect, (struct bDirBlock*)&parent);
if (rc!=RC_OK)
return rc;
}
else {
/* in linked list */
if (adfReadEntryBlock(vol, prevSect, &previous)!=RC_OK)
return RC_ERROR;
/* entry.nextSameHash (tmpSect) could be == 0 */
previous.nextSameHash = tmpSect;
if (adfWriteEntryBlock(vol, prevSect, &previous)!=RC_OK)
return RC_ERROR;
}
if (adfReadEntryBlock( vol, nPSect, &nParent )!=RC_OK)
return RC_ERROR;
hashValueN = adfGetHashValue((unsigned char*)newName, intl);
nSect2 = nParent.hashTable[ hashValueN ];
/* no list */
if (nSect2==0) {
nParent.hashTable[ hashValueN ] = nSect;
if (nParent.secType==ST_ROOT)
rc = adfWriteRootBlock(vol, nPSect, (struct bRootBlock*)&nParent);
else
rc = adfWriteDirBlock(vol, nPSect, (struct bDirBlock*)&nParent);
}
else {
/* a list exists : addition at the end */
/* len = strlen(newName);
* name2 == newName
*/
do {
if (adfReadEntryBlock(vol, nSect2, &previous)!=RC_OK)
return -1;
if (previous.nameLen==len) {
myToUpper((unsigned char*)name3,(unsigned char*)previous.name,previous.nameLen,intl);
if (strncmp(name3,name2,len)==0) {
(*adfEnv.wFct)("adfRenameEntry : entry already exists");
return -1;
}
}
nSect2 = previous.nextSameHash;
/*printf("sect=%ld\n",nSect2);*/
}while(nSect2!=0);
previous.nextSameHash = nSect;
if (previous.secType==ST_DIR)
rc=adfWriteDirBlock(vol, previous.headerKey,
(struct bDirBlock*)&previous);
else if (previous.secType==ST_FILE)
rc=adfWriteFileHdrBlock(vol, previous.headerKey,
(struct bFileHeaderBlock*)&previous);
else {
(*adfEnv.wFct)("adfRenameEntry : unknown entry type");
rc = RC_ERROR;
}
}
if (rc!=RC_OK)
return rc;
if (isDIRCACHE(vol->dosType)) {
if (pSect==nPSect) {
adfUpdateCache(vol, &parent, (struct bEntryBlock*)&entry,TRUE);
}
else {
adfDelFromCache(vol,&parent,entry.headerKey);
adfAddInCache(vol,&nParent,&entry);
}
}
/*
if (isDIRCACHE(vol->dosType) && pSect!=nPSect) {
adfUpdateCache(vol, &nParent, (struct bEntryBlock*)&entry,TRUE);
}
*/
return RC_OK;
}
/*
* adfGetRDirEnt
*
*/
struct List* adfGetRDirEnt(struct Volume* vol, SECTNUM nSect, BOOL recurs )
{
struct bEntryBlock entryBlk;
struct List *cell, *head;
int i;
struct Entry *entry;
SECTNUM nextSector;
int32_t *hashTable;
struct bEntryBlock parent;
if (adfEnv.useDirCache && isDIRCACHE(vol->dosType))
return (adfGetDirEntCache(vol, nSect, recurs ));
if (adfReadEntryBlock(vol,nSect,&parent)!=RC_OK)
return NULL;
hashTable = parent.hashTable;
cell = head = NULL;
for(i=0; i<HT_SIZE; i++) {
if (hashTable[i]!=0) {
entry = (struct Entry *)calloc(1,sizeof(struct Entry));
if (!entry) {
adfFreeDirList(head);
(*adfEnv.eFct)("adfGetDirEnt : malloc");
return NULL;
}
if (adfReadEntryBlock(vol, hashTable[i], &entryBlk)!=RC_OK) {
adfFreeDirList(head);
return NULL;
}
if (adfEntBlock2Entry(&entryBlk, entry)!=RC_OK) {
adfFreeDirList(head); return NULL;
}
entry->sector = hashTable[i];
if (head==NULL)
head = cell = newCell(0, (void*)entry);
else
cell = newCell(cell, (void*)entry);
if (cell==NULL) {
adfFreeDirList(head); return NULL;
}
if (recurs && entry->type==ST_DIR)
cell->subdir = adfGetRDirEnt(vol,entry->sector,recurs);
/* same hashcode linked list */
nextSector = entryBlk.nextSameHash;
while( nextSector!=0 ) {
entry = (struct Entry *)calloc(1,sizeof(struct Entry));
if (!entry) {
adfFreeDirList(head);
(*adfEnv.eFct)("adfGetDirEnt : malloc");
return NULL;
}
if (adfReadEntryBlock(vol, nextSector, &entryBlk)!=RC_OK) {
adfFreeDirList(head); return NULL;
}
if (adfEntBlock2Entry(&entryBlk, entry)!=RC_OK) {
adfFreeDirList(head);
return NULL;
}
entry->sector = nextSector;
cell = newCell(cell, (void*)entry);
if (cell==NULL) {
adfFreeDirList(head); return NULL;
}
if (recurs && entry->type==ST_DIR)
cell->subdir = adfGetRDirEnt(vol,entry->sector,recurs);
nextSector = entryBlk.nextSameHash;
}
}
}
/* if (parent.extension && isDIRCACHE(vol->dosType) )
adfReadDirCache(vol,parent.extension);
*/
return head;
}
/*
* adfRemoveEntry
*
*/
RETCODE adfRemoveEntry(struct Volume *vol, SECTNUM pSect, char *name)
{
struct bEntryBlock parent, previous, entry;
SECTNUM nSect2, nSect;
int hashVal;
BOOL intl;
char buf[200];
if (adfReadEntryBlock( vol, pSect, &parent )!=RC_OK)
return RC_ERROR;
nSect = adfNameToEntryBlk(vol, parent.hashTable, name, &entry, &nSect2);
if (nSect==-1) {
sprintf(buf, "adfRemoveEntry : entry '%s' not found", name);
(*adfEnv.wFct)(buf);
return RC_ERROR;
}
/* if it is a directory, is it empty ? */
if ( entry.secType==ST_DIR && !isDirEmpty((struct bDirBlock*)&entry) ) {
sprintf(buf, "adfRemoveEntry : directory '%s' not empty", name);
(*adfEnv.wFct)(buf);
return RC_ERROR;
}
/* printf("name=%s nSect2=%ld\n",name, nSect2);*/
/* in parent hashTable */
if (nSect2==0) {
intl = isINTL(vol->dosType) || isDIRCACHE(vol->dosType);
hashVal = adfGetHashValue( (unsigned char*)name, intl );
/*printf("hashTable=%d nexthash=%d\n",parent.hashTable[hashVal],
entry.nextSameHash);*/
parent.hashTable[hashVal] = entry.nextSameHash;
if (adfWriteEntryBlock(vol, pSect, &parent)!=RC_OK)
return RC_ERROR;
}
/* in linked list */
else {
if (adfReadEntryBlock(vol, nSect2, &previous)!=RC_OK)
return RC_ERROR;
previous.nextSameHash = entry.nextSameHash;
if (adfWriteEntryBlock(vol, nSect2, &previous)!=RC_OK)
return RC_ERROR;
}
if (entry.secType==ST_FILE) {
adfFreeFileBlocks(vol, (struct bFileHeaderBlock*)&entry);
if (adfEnv.useNotify)
(*adfEnv.notifyFct)(pSect,ST_FILE);
}
else if (entry.secType==ST_DIR) {
adfSetBlockFree(vol, nSect);
/* free dir cache block : the directory must be empty, so there's only one cache block */
if (isDIRCACHE(vol->dosType))
adfSetBlockFree(vol, entry.extension);
if (adfEnv.useNotify)
(*adfEnv.notifyFct)(pSect,ST_DIR);
}
else {
sprintf(buf, "adfRemoveEntry : secType %d not supported", entry.secType);
(*adfEnv.wFct)(buf);
return RC_ERROR;
}
if (isDIRCACHE(vol->dosType))
adfDelFromCache(vol, &parent, entry.headerKey);
adfUpdateBitmap(vol);
return RC_OK;
}