/*
* adfVolumeInfo
*
*/
void adfVolumeInfo(struct Volume *vol)
{
struct bRootBlock root;
char diskName[35];
int days,month,year;
if (adfReadRootBlock(vol, vol->rootBlock, &root)!=RC_OK)
return;
memset(diskName, 0, 35);
memcpy(diskName, root.diskName, root.nameLen);
printf ("Name : %-30s\n",vol->volName);
printf ("Type : ");
switch(vol->dev->devType) {
case DEVTYPE_FLOPDD:
printf ("Floppy Double Density : 880 KBytes\n");
break;
case DEVTYPE_FLOPHD:
printf ("Floppy High Density : 1760 KBytes\n");
break;
case DEVTYPE_HARDDISK:
printf ("Hard Disk partition : %3.1f KBytes\n",
(vol->lastBlock - vol->firstBlock +1) * 512.0/1024.0);
break;
case DEVTYPE_HARDFILE:
printf ("HardFile : %3.1f KBytes\n",
(vol->lastBlock - vol->firstBlock +1) * 512.0/1024.0);
break;
default:
printf ("Unknown devType!\n");
}
printf ("Filesystem : ");
printf("%s ",isFFS(vol->dosType) ? "FFS" : "OFS");
if (isINTL(vol->dosType))
printf ("INTL ");
if (isDIRCACHE(vol->dosType))
printf ("DIRCACHE ");
putchar('\n');
printf("Free blocks = %d\n", adfCountFreeBlocks(vol));
if (vol->readOnly)
printf("Read only\n");
else
printf("Read/Write\n");
/* created */
adfDays2Date(root.coDays, &year, &month, &days);
printf ("created %d/%02d/%02d %d:%02d:%02d\n",days,month,year,
root.coMins/60,root.coMins%60,root.coTicks/50);
adfDays2Date(root.days, &year, &month, &days);
printf ("last access %d/%02d/%02d %d:%02d:%02d, ",days,month,year,
root.mins/60,root.mins%60,root.ticks/50);
adfDays2Date(root.cDays, &year, &month, &days);
printf ("%d/%02d/%02d %d:%02d:%02d\n",days,month,year,
root.cMins/60,root.cMins%60,root.cTicks/50);
}
/*
* adfNameToEntryBlk
*
*/
SECTNUM adfNameToEntryBlk(struct Volume *vol, int32_t ht[], char* name,
struct bEntryBlock *entry, SECTNUM *nUpdSect)
{
int hashVal;
unsigned char upperName[MAXNAMELEN+1];
unsigned char upperName2[MAXNAMELEN+1];
SECTNUM nSect;
int nameLen;
BOOL found;
SECTNUM updSect;
BOOL intl;
intl = isINTL(vol->dosType) || isDIRCACHE(vol->dosType);
hashVal = adfGetHashValue( (unsigned char*)name, intl );
nameLen = min(strlen(name), MAXNAMELEN);
myToUpper( upperName, (unsigned char*)name, nameLen, intl );
nSect = ht[hashVal];
/*printf("name=%s ht[%d]=%d upper=%s len=%d\n",name,hashVal,nSect,upperName,nameLen);
printf("hashVal=%d\n",adfGetHashValue(upperName, intl ));
if (!strcmp("españa.country",name)) {
int i;
for(i=0; i<HT_SIZE; i++) printf("ht[%d]=%d ",i,ht[i]);
}*/
if (nSect==0)
return -1;
updSect = 0;
found = FALSE;
do {
if (adfReadEntryBlock(vol, nSect, entry)!=RC_OK)
return -1;
if (nameLen==entry->nameLen) {
myToUpper( upperName2, (unsigned char*)entry->name, nameLen, intl );
/*printf("2=%s %s\n",upperName2,upperName);*/
found = strncmp((char*)upperName, (char*)upperName2, nameLen)==0;
}
if (!found) {
updSect = nSect;
nSect = entry->nextSameHash;
}
}while( !found && nSect!=0 );
if ( nSect==0 && !found )
return -1;
else {
if (nUpdSect!=NULL)
*nUpdSect = updSect;
return nSect;
}
}
BOOL VolPropPage::OnInitDialog()
{
CPropertyPage::OnInitDialog();
WinADFDoc *pDoc = (WinADFDoc*)MDIGetActiveDoc();
ASSERT_VALID(pDoc);
ASSERT(pDoc->IsKindOf(RUNTIME_CLASS(WinADFDoc)));
Volume *pVol = pDoc->GetVolume();
GetDlgItem(IDC_VOLNAME)->SetWindowText(pVol->getName().c_str());
int8_t type = pVol->getType();
CButton *pButton = (CButton*)GetDlgItem(IDC_FFS);
pButton->SetCheck(isFFS(type));
pButton = (CButton*)GetDlgItem(IDC_INTL);
pButton->SetCheck(isINTL(type));
pButton = (CButton*)GetDlgItem(IDC_DIRCACHE);
pButton->SetCheck(isDIRCACHE(type));
uint32_t totalblocks = (pVol->getLastBlock()+1) - pVol->getFirstBlock();
uint32_t totalcap = totalblocks * BSIZE;
CString fmt;
fmt.Format("%s KB", comma(totalcap / 1024).c_str());
GetDlgItem(IDC_VOL_TOTAL)->SetWindowText(fmt);
uint32_t freeblocks = pVol->freeblocks();
uint32_t freecap = freeblocks * BSIZE;
fmt.Format("%s KB", comma(freecap / 1024).c_str());
GetDlgItem(IDC_VOL_FREE)->SetWindowText(fmt);
uint32_t full = totalblocks - freeblocks;
m_FullProgress.SetRange32(0, totalblocks);
m_FullProgress.SetPos(full);
m_FullProgress.SendMessage(PBM_SETBARCOLOR, 0, COLOR_PURPLE);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void printVol(struct Volume* vol, int volNum)
{
printf("Volume : ");
switch(vol->dev->devType) {
case DEVTYPE_FLOPDD:
printf ("Floppy 880 KBytes,");
break;
case DEVTYPE_FLOPHD:
printf ("Floppy 1760 KBytes,");
break;
case DEVTYPE_HARDDISK:
printf ("HD partition #%d %3.1f KBytes,", volNum, (vol->lastBlock - vol->firstBlock +1) * 512.0/1024.0);
break;
case DEVTYPE_HARDFILE:
printf ("HardFile %3.1f KBytes,", (vol->lastBlock - vol->firstBlock +1) * 512.0/1024.0);
break;
default:
printf ("???,");
}
if (vol->volName!=NULL)
printf(" \"%s\"", vol->volName);
printf(" between sectors [%ld-%ld].",vol->firstBlock, vol->lastBlock);
printf(" %s ",isFFS(vol->dosType) ? "FFS" : "OFS");
if (isINTL(vol->dosType))
printf ("INTL ");
if (isDIRCACHE(vol->dosType))
printf ("DIRCACHE ");
printf(". Filled at %2.1f%%.\n", 100.0-
(adfCountFreeBlocks(vol)*100.0)/(vol->lastBlock - vol->firstBlock +1) );
}
/*
* 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;
}
/*
* 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;
}
