From aaee3363c4c8c44bf676393155f2c9bd32a66c31 Mon Sep 17 00:00:00 2001 From: jensadne Date: Wed, 3 Sep 2008 22:25:24 +0000 Subject: [PATCH] =?UTF-8?q?Tenkte=20denne=20var=20grei=20=C3=A5=20ha=20med?= =?UTF-8?q?=20ogs=C3=A5=20:-)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tikidisk-src/LESMEG | 37 ++ tikidisk-src/Makefile | 26 ++ tikidisk-src/tikidisk.c | 805 ++++++++++++++++++++++++++++++++++++++ tikidisk-src/tikidisk.txt | 118 ++++++ 4 files changed, 986 insertions(+) create mode 100644 tikidisk-src/LESMEG create mode 100644 tikidisk-src/Makefile create mode 100644 tikidisk-src/tikidisk.c create mode 100644 tikidisk-src/tikidisk.txt diff --git a/tikidisk-src/LESMEG b/tikidisk-src/LESMEG new file mode 100644 index 0000000..2f94ba2 --- /dev/null +++ b/tikidisk-src/LESMEG @@ -0,0 +1,37 @@ +tikidisk V1.1, 24 august 2001 +----------------------------- + +Dette er kildefilene til 'tikidisk'. Denne fila gir en oppskrift på +hvordan kompilere. For informasjon om bruk av kommandoen, se +tikidisk.txt. + +Jeg gir tillatelse til å bruke og spre disse filene fritt. Ønsker du å +gjøre forandringer ser jeg helst at du tar kontakt med meg. Dette +fordi jeg ikke anser meg for ferdig med dette programmet enda. Da +unngår vi at flere jobber på de samme tingene. Men jeg tar gjerne imot +forslag til forbedringer. + +Disse kildefilene skal ikke brukes til kommersielle formål på noen som +helst måte, hverken i original eller modifisert form. + +Kompilering: +------------ + +Kompilering er rett fram. Det du trenger er GCC og GNU-make, eller noe +tilsvarende. Skriv kommandoen "make" i samme katalog som kildefilene, +og tikidisk kompileres. Dette skal gå smertefritt under alle +operativsystemer, bare du har GCC og make. Kildefilene er skrevet i +ANSI-C, og skal i teorien kompilere med alle ANSI-C kompilatorer. + +Har du problemer, så ta kontakt med meg. + +Disse filene skal være med: +--------------------------- + +- tikidisk.c +- Makefile +- LESMEG +- tikidisk.txt + +--- +Asbjørn Djupdal, djupdal@stud.ntnu.no diff --git a/tikidisk-src/Makefile b/tikidisk-src/Makefile new file mode 100644 index 0000000..a4644f2 --- /dev/null +++ b/tikidisk-src/Makefile @@ -0,0 +1,26 @@ +# Makefile for tikidisk V1.1 +# Asbjørn Djupdal 2001 + +CC = gcc + +CFLAGS = -Wall -O +LDFLAGS = -s +#LDFLAGS = -s -noixemul # amiga-versjon uten ixemul.library +#LDFLAGS = -s -mno-cygwin # win32-versjon uten cygwin.dll + +#------------------------------------------------------------------------------ +# Regler +#------------------------------------------------------------------------------ + +# Alle objektfiler som skal linkes +OBJECTS = tikidisk.o + +tikidisk : $(OBJECTS) + $(CC) -o $@ $(OBJECTS) $(LDFLAGS) + +tikidisk.o : tikidisk.c Makefile + $(CC) -c $< $(CFLAGS) + +.PHONY : clean +clean : + rm -f tikidisk tikidisk.exe *.o diff --git a/tikidisk-src/tikidisk.c b/tikidisk-src/tikidisk.c new file mode 100644 index 0000000..1cffcc3 --- /dev/null +++ b/tikidisk-src/tikidisk.c @@ -0,0 +1,805 @@ +/* tikidisk.c V1.1 + * + * CP/M-2.2 filsystem som jobber mot TIKI-100 diskettfiler + * + * Burde fungere med alle CP/M-2.2 diskettfiler, bare riktige diskparametre oppgis. + * Foreløpig kjenner programmet bare igjen TIKI-100 diskettfiler. + * + * Copyright (c) Asbjørn Djupdal 2001 + */ + +#include +#include +#include +#include + +typedef unsigned char byte; +typedef unsigned short word; +typedef short boolean; + +#ifndef TRUE +#define TRUE ~0 +#endif +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef NULL +#define NULL 0 +#endif + +#define DISK90K 1*40*18*128 +#define DISK200K 1*40*10*512 +#define DISK400K 2*40*10*512 +#define DISK800K 2*80*10*512 + +/* protos */ +int main (int argc, char *argv[]); + +void saveFile (byte *entry); +void addFile (char *efn, byte user); +void delFile (char *ffn, byte user); + +byte *getEntry (int entryNumber); +byte *getExtent (byte *entry, int extentNumber); +byte *getMatch (char *ffn, byte user); +byte *getSector (int sectorNumber); + +int getExtentNumber (byte *entry); +void setExtentNumber (byte *entry, int extentNumber); +int getBytesInEntry (byte *entry); +void setBytesInEntry (byte *entry, int bytesInExtent); +int getBlockNumber (byte *entry, int alNumber); +void setBlockNumber (byte *entry, int alNumber, int blockNumber); + +void getFilename (char *filename, byte *entry); +int getFilesize (byte *entry); +byte getUsernumber (byte *entry); +void getAttribs (char *attribs, byte *entry); +void setNameAndUser (byte *ffnEntry, char *ffn, byte user); + +void buildBAM (void); +int allocateBlock (void); + +boolean entryNotDeleted (byte *entry); +void deleteEntry (byte *entry); +boolean entryEquals (byte *ffnEntry, byte *entry); +char legalChar (char c); +char *stripPath (char *ffn); + +/* globals */ +byte diskImage[DISK800K]; /* her legges diskettfil */ +boolean *bam = NULL; /* Block Availability Map */ + +int numberOfEntries; /* antall kataloginnganger */ +int systemSectors; /* antall sektorer med bootkode */ +int sectorSize; /* bytes pr. sektor */ +int *convertSectorNumber; /* tabell som mapper sektornummer */ +int sectorsPerTrack; /* antall sektorer pr. spor */ +int exm; /* antall bytes pr. AL */ +int bytesPerAL; /* blokkstørrelse */ +int blockSize; /* bytes pr. blokk */ +int sectorsPerBlock; /* sektorer pr. blokk */ +int numberOfBlocks; /* antall blokker (untatt systemsektorer) */ +int directoryBlocks; /* antall blokker brukt av kataloginnganger */ +int numberOfALs; /* antall ALs pr. kataloginngang */ + +int convertSectorNumber18[18] = {0, 5, 10, 15, 2, 7, 12, 17, 4, 9, 14, 1, 6, 11, 16, 3, 8, 13}; +int convertSectorNumber10[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + +/* functions */ +int main (int argc, char *argv[]) { + int size; + byte user; + + if (argc < 4) { + fprintf (stderr, "tikidisk V1.1 Copyright (c) Asbjørn Djupdal 2001\n" + "\n" + "Brukes: tikidisk {lxad}[brukernummer] \n" + " l = list filer\n" + " x = hent ut filer\n" + " a = legg til filer\n" + " d = slett filer\n" + "\n"); + exit (1); + } + + { /* les diskfil */ + FILE *diskImageFp; + + if (!(diskImageFp = fopen (argv[1], "rb"))) { + fprintf (stderr, "Kan ikke åpne diskfil %s\n", argv[1]); + exit (1); + } + size = fread (diskImage, 1, DISK800K, diskImageFp); + fclose (diskImageFp); + } + + /* sett diskparametre */ + switch (size) { + case DISK90K: + convertSectorNumber = convertSectorNumber18; + numberOfEntries = 32; + systemSectors = 3 * 18; + sectorSize = 128; + sectorsPerTrack = 18; + exm = 0; + bytesPerAL = 1; + blockSize = 1024; + numberOfBlocks = 83; + directoryBlocks = 1; + break; + case DISK200K: + convertSectorNumber = convertSectorNumber10; + numberOfEntries = 64; + systemSectors = 20; + sectorSize = 512; + sectorsPerTrack = 10; + exm = 0; + bytesPerAL = 1; + blockSize = 1024; + numberOfBlocks = 190; + directoryBlocks = 2; + break; + case DISK400K: + convertSectorNumber = convertSectorNumber10; + numberOfEntries = 128; + systemSectors = 20; + sectorSize = 512; + sectorsPerTrack = 10; + exm = 1; + bytesPerAL = 1; + blockSize = 2048; + numberOfBlocks = 195; + directoryBlocks = 2; + break; + case DISK800K: + convertSectorNumber = convertSectorNumber10; + numberOfEntries = 128; + systemSectors = 20; + sectorSize = 512; + sectorsPerTrack = 10; + exm = 0; + bytesPerAL = 2; + blockSize = 2048; + numberOfBlocks = 395; + directoryBlocks = 2; + break; + default: + fprintf (stderr, "Ikke en gyldig diskfil\n"); + exit (1); + } + sectorsPerBlock = blockSize / sectorSize; + numberOfALs = 16 / bytesPerAL; + + { /* finn brukernummer */ + char *ptr; + + user = (byte)strtol (argv[2] + 1, &ptr, 10); + if (ptr == argv[2] + 1) { /* brukernummer ikke angitt */ + user = (byte)'?'; + } else if (user > 15) { + fprintf (stderr, "Ulovlig brukernummer\n"); + exit (1); + } + } + + /* utfør kommando */ + switch (*argv[2]) { + case 'l': { + /* list filer */ + int files = 0; + int bytes = 0; + byte *entry; + + if ((entry = getMatch (argv[3], user))) { + do { + char filename[13]; + char attribs[4]; + int filesize = getFilesize (entry); + + getFilename (filename, entry); + getAttribs (attribs, entry); + printf (" %6d %s %02d: %s\n", filesize, attribs, getUsernumber (entry), filename); + files++; + bytes += filesize; + } while ((entry = getMatch (NULL, 0))); + } + printf ("%d filer, %d bytes\n", files, bytes); + break; + } + case 'x': { + /* lagre filer */ + int i = 3; + + while (argv[i]) { + byte *entry; + + if ((entry = getMatch (argv[i], user))) { + do { + saveFile (entry); + } while ((entry = getMatch (NULL, 0))); + } + i++; + } + break; + } + case 'a': { + /* legg til filer */ + int i = 3; + + if (user == (byte)'?') { + user = 0; + } + + while (argv[i]) { + addFile (argv[i], user); + i++; + } + break; + } + case 'd': { + /* slett filer */ + int i = 3; + + while (argv[i]) { + delFile (argv[i], user); + i++; + } + break; + } + default: + fprintf (stderr, "Ulovlig kommando\n"); + exit (1); + } + + /* lagre diskfil */ + if ((*argv[2] == 'a') || (*argv[2] == 'd')) { + FILE *diskImageFp; + + if ((diskImageFp = fopen (argv[1], "wb"))) { + fwrite (diskImage, 1, size, diskImageFp); + fclose (diskImageFp); + } + } + + free (bam); + return 0; +} + +/* Trekker ut fil fra diskettfil og lagrer på disk + * + * entry: en ekstent til filen som skal lagres + */ +void saveFile (byte *entry) { + char filename[13]; + FILE *fp; + + getFilename (filename, entry); + + if ((fp = fopen (filename, "wb"))) { + int extentNumber = 0; + + printf ("Henter ut %02d:%s...\n", getUsernumber (entry), filename); + + /* gå gjennom alle extenter */ + while ((entry = getExtent (entry, extentNumber++))) { + boolean done = FALSE; + int blockNumber; + int alNumber = 0; + int bytesRemaining = getBytesInEntry (entry); + + /* gå gjennom alle blokker */ + while (!done && (alNumber < numberOfALs)) { + if ((blockNumber = getBlockNumber (entry, alNumber))) { + int i; + + /* lagre sektorer i blokk */ + for (i = 0; i < sectorsPerBlock; i++) { + int sectorNumber = ((blockNumber * blockSize) / sectorSize) + systemSectors + i; + + if (bytesRemaining) { + int bytesToWrite = (bytesRemaining < sectorSize ? bytesRemaining : sectorSize); + + fwrite (getSector (sectorNumber), 1, bytesToWrite, fp); + bytesRemaining -= bytesToWrite; + } else { + done = TRUE; + } + } + } + alNumber++; + } + } + fclose (fp); + } +} + +/* Henter inn fil fra disk og legger inn i diskettfil + * + * efn: entydig filnavn til fil som skal legges til + * user: entydig brukernummer som fil skal lagres under + */ +void addFile (char *efn, byte user) { + FILE *fp; + byte *entry = NULL; + int extentNumber = 0; + int alNumber = 0; + int sectorNumber = 0; + int bytesInExtent = 0; + byte *sectorData; + boolean done = FALSE; + + if (!(fp = fopen (efn, "rb"))) { + fprintf (stderr, "Kan ikke åpne %s\n", efn); + return; + } + + if (!(sectorData = malloc (sectorSize))) { + fprintf (stderr, "Ikke nok minne\n"); + free (bam); + exit (1); + } + + delFile (stripPath (efn), user); + + buildBAM(); + + printf ("Legger til %02d:%s...\n", user, efn); + + while (!done) { + int bytesRead = fread (sectorData, 1, sectorSize, fp); + + if (bytesRead) { + + /* finn ledig kataloginngang */ + if (!(bytesInExtent % (numberOfALs * blockSize))) { + int entryNumber = 0; + + if (entry) setBytesInEntry (entry, bytesInExtent); + + do { + if (entryNumber >= numberOfEntries) { + fprintf (stderr, "Ikke nok ledige kataloginnganger\n"); + free (sectorData); + free (bam); + exit (1); + } + entry = getEntry (entryNumber); + entryNumber++; + } while (entryNotDeleted (entry)); + + memset (entry, 0, 32); + setNameAndUser (entry, stripPath (efn), user); + setExtentNumber (entry, extentNumber++); + alNumber = 0; + bytesInExtent = 0; + } + + /* finn ledig blokk */ + if (!(bytesInExtent % blockSize)) { + int blockNumber; + + if (!(blockNumber = allocateBlock())) { + fprintf (stderr, "Ikke nok ledige blokker\n"); + free (sectorData); + free (bam); + exit (1); + } + setBlockNumber (entry, alNumber++, blockNumber); + sectorNumber = ((blockNumber * blockSize) / sectorSize) + systemSectors; + } + + /* skriv til sektor */ + memcpy (getSector (sectorNumber++), sectorData, sectorSize); + bytesInExtent += bytesRead; + + } else { + done = TRUE; + setBytesInEntry (entry, bytesInExtent); + } + } + free (sectorData); +} + +/* Sletter filer fra diskettfil + * + * ffn: flertydig filnavn til filer som skal slettes + * user: flertydig brukernummer til filer som skal slettes + */ +void delFile (char *ffn, byte user) { + byte *entry; + + if ((entry = getMatch (ffn, user))) { + /* gå gjennom alle entries (filer) */ + do { + int extentNumber = 0; + byte *extent; + char filename[13]; + + getFilename (filename, entry); + + printf ("Sletter %02d:%s...\n", getUsernumber (entry), filename); + + /* slett alle extenter til filen */ + while ((extent = getExtent (entry, extentNumber++))) { + deleteEntry (extent); + } + } while ((entry = getMatch (NULL, 0))); + } +} + +/* Gir peker til entry i diskettfil + * + * entryNumber: nummer på entry som skal returneres + */ +byte *getEntry (int entryNumber) { + int dirSector = systemSectors + ((entryNumber * 32) / sectorSize); + int offsetInSector = (entryNumber * 32) % sectorSize; + + return getSector (dirSector) + offsetInSector; +} + +/* Gir peker til extent i diskettfil, eller NULL derom ikke funnet + * + * entry: en allerede kjent extent + * extentNumber: nummer til ønsket extent + */ +byte *getExtent (byte *entry, int extentNumber) { + int entryNumber; + + for (entryNumber = 0; entryNumber < numberOfEntries; entryNumber++) { + byte *curEntry = getEntry (entryNumber); + + if (entryNotDeleted (curEntry) && entryEquals (entry, curEntry) && + (getExtentNumber (curEntry) == extentNumber)) { + return curEntry; + } + } + return NULL; +} + +/* Gir peker til neste fil (extent 0) som passer, eller NULL dersom ikke flere passer + * + * ffn: flertydig filnavn til filer som skal finnes + * Angi ffn kun første gang funksjonen kalles. For å finne de resterende filer + * som passer, kall funksjonen med ffn = NULL + * user: flertydig brukernummer til filer som skal finnes + */ +byte *getMatch (char *ffn, byte user) { + static byte ffnEntry[12]; + static int entryNumber; + + if (ffn != NULL) { + entryNumber = 0; + setNameAndUser (ffnEntry, ffn, user); + } + + while (entryNumber < numberOfEntries) { + byte *entry = getEntry (entryNumber); + entryNumber++; + if (entryNotDeleted (entry) && entryEquals (ffnEntry, entry) && (getExtentNumber (entry) == 0)) { + return entry; + } + } + return NULL; +} + +/* Gir peker til stedet der data for angitt sektor befinner seg + * + * sectorNumber: nummer på sektor som ønskes + */ +byte *getSector (int sectorNumber) { + int realSectorNumber = (sectorNumber / sectorsPerTrack) * sectorsPerTrack + + convertSectorNumber[sectorNumber % sectorsPerTrack]; + return diskImage + realSectorNumber * sectorSize; +} + +/* Gir nummeret på extent (fra EX og S2 feltene) + * + * entry: kataloginngang man ønsker extentnummeret til + */ +int getExtentNumber (byte *entry) { + return (*(entry + 14) * 32 + *(entry + 12)) / (exm + 1); +} + +/* Setter nummer på extent (til EX og S2 feltene) + * + * entry: kataloginngang man skal sette extentnummeret til + * extentNumber: extentnummeret som skal settes + */ +void setExtentNumber (byte *entry, int extentNumber) { + *(entry + 14) = extentNumber / 32; + *(entry + 12) = ((extentNumber % 32) * (exm + 1)); +} + +/* Gir antall bytes lagret i extent (fra RC og EX feltene) + * + * entry: extent man ønsker størrelsen til + */ +int getBytesInEntry (byte *entry) { + return ((*(entry + 12) & exm) * 128 + *(entry + 15)) * 128; +} + +/* Setter antall bytes lagret i extent (til RC og EX feltene) + * + * entry: kataloginngang man skal sette størrelsen til + * bytesInExtent: antall bytes som skal settes + */ +void setBytesInEntry (byte *entry, int bytesInExtent) { + int recordsInExtent = bytesInExtent / 128; + + if (bytesInExtent % 128) recordsInExtent++; + + if (recordsInExtent % 0x80) { + *(entry + 15) = recordsInExtent % 0x80; + } else { + *(entry + 15) = 0x80; + } + if (recordsInExtent > 0x80) { + *(entry + 12) += (recordsInExtent / 0x80); + } +} + +/* Gir nummeret på blokken som befinner seg i en AL + * + * entry: kataloginngang + * alNumber: nummer på AL man ønsker blokknummeret til + */ +int getBlockNumber (byte *entry, int alNumber) { + int al1 = *(entry + 16 + (alNumber * bytesPerAL)); + int al2 = *(entry + 16 + (alNumber * bytesPerAL) + 1); + + return (bytesPerAL == 1 ? al1 : al1 + (al2 * 256)); +} + +/* Setter nummer på blokk i an AL + * + * entry: kataloginngang + * alNumber: nummer på AL + * blockNumber: nummer på blokk + */ +void setBlockNumber (byte *entry, int alNumber, int blockNumber) { + if (bytesPerAL < 2) { + *(entry + 16 + alNumber) = blockNumber; + } else { + *(entry + 16 + (alNumber * 2)) = blockNumber; + *(entry + 16 + (alNumber * 2) + 1) = blockNumber / 256; + } +} + +/* Kopierer filnavn fra en kataloginngang til en streng + * + * filename: streng som filnavn skal kopieres til + * entry: kataloginngang man ønsker filnavnet til + */ +void getFilename (char *filename, byte *entry) { + int i = 0, j = 0; + + entry++; + /* kopier filnavn */ + while ((i < 8) && (*entry != ' ')) { + filename[i++] = legalChar (*entry++); + } + entry += 8 - i; + filename[i++] = '.'; + /* kopier filtype */ + while ((j++ < 3) && (*entry != ' ')) { + filename[i++] = legalChar ((*entry++) & 0x7f); + } + filename[i] = '\0'; +} + +/* Gir størrelsen på en fil + * + * entry: en extent til fila man ønsker størrelsen til + */ +int getFilesize (byte *entry) { + int filesize = 0; + boolean done = FALSE; + int extentNumber = 0; + + while (!done) { + if (!(entry = getExtent (entry, extentNumber++))) { + done = TRUE; + } else { + filesize += getBytesInEntry (entry); + } + } + return filesize; +} + +/* Gir brukernummeret til en kataloginngang + * + * entry: kataloginngang man ønsker brukernummeret til + */ +byte getUsernumber (byte *entry) { + return *entry; +} + +/* Lager en streng som representerer attributtene til en kataloginngang + * + * attribs: streng som attributtinfo skal skrives til + * entry: kataloginngang man ønsker attributtinfo til + */ +void getAttribs (char *attribs, byte *entry) { + *(attribs + 0) = (*(entry + 9)) & 0x80 ? 'l' : '-'; + *(attribs + 1) = (*(entry + 10)) & 0x80 ? 's' : '-'; + *(attribs + 2) = (*(entry + 11)) & 0x80 ? 'a' : '-'; + *(attribs + 3) = '\0'; +} + +/* Kopierer filnavn og brukernummer inn i en kataloginngang + * + * ffnEntry: kataloginngang man skal skrive til + * ffn: flertydig filnavn som skal skrives fra + * user: flertydig brukernummer som skal skrives fra + */ +void setNameAndUser (byte *ffnEntry, char *ffn, byte user) { + int i; + + /* kopier brukernummer */ + *ffnEntry++ = user; + + /* kopier filnavn */ + for (i = 0; i < 8; i++, ffnEntry++) { + if (*ffn == '*') { + *ffnEntry = (byte)'?'; + } else if (*ffn == '?') { + *ffnEntry = (byte)'?'; + ffn++; + } else if (*ffn == '.') { + *ffnEntry = (byte)' '; + } else if (*ffn == '\0') { + *ffnEntry = (byte)' '; + } else { + *ffnEntry = (byte)legalChar (*ffn); + ffn++; + } + } + + /* finn filtype */ + if (strchr (ffn, '.')) { + ffn = strchr (ffn, '.') + 1; + + /* kopier filtype */ + for (i = 0; i < 3; i++) { + if (*ffn == '*') { + *ffnEntry++ = (byte)'?'; + } else if (*ffn == '?') { + *ffnEntry++ = (byte)'?'; + ffn++; + } else if (*ffn == '.') { + ffn++; + } else if (*ffn == '\0') { + *ffnEntry++ = (byte)' '; + } else { + *ffnEntry++ = (byte)legalChar (*ffn); + ffn++; + } + } + } +} + +/* Bygger Block Availability Map for diskettfil + */ +void buildBAM (void) { + int entryNumber; + + free (bam); + if (!(bam = malloc (sizeof (boolean) * numberOfBlocks))) { + fprintf (stderr, "Ikke nok minne\n"); + exit (1); + } + + memset (bam, 0, sizeof (boolean) * numberOfBlocks); + + { /* merk katalogblokker som opptatte */ + int blockNumber; + + for (blockNumber = 0; blockNumber < directoryBlocks; blockNumber++) { + *(bam + blockNumber) = TRUE; + } + } + + /* gå gjennom alle kataloginnganger */ + for (entryNumber = 0; entryNumber < numberOfEntries; entryNumber++) { + byte *entry = getEntry (entryNumber); + + if (entryNotDeleted (entry)) { + int blockNumber; + int alNumber = 0; + + /* merk alle blokker som denne kataloginngangen bruker som opptatt */ + while ((alNumber < numberOfALs) && (blockNumber = getBlockNumber (entry, alNumber))) { + *(bam + blockNumber) = TRUE; + alNumber++; + } + } + } +} + +/* Allokerer en blokk og gir nummeret på den nye blokken + */ +int allocateBlock (void) { + int blockNumber; + + for (blockNumber = 0; blockNumber < numberOfBlocks; blockNumber++) { + if (!*(bam + blockNumber)) { + *(bam + blockNumber) = TRUE; + return blockNumber; + } + } + return 0; +} + +/* Gir slettet-status til en kataloginngang + * entry: kataloginngang + */ +boolean entryNotDeleted (byte *entry) { + return (*entry < 32); +} + +/* Sletter en kataloginngang + * entry: kataloginngang + */ +void deleteEntry (byte *entry) { + *entry = 0xe5; +} + +/* Sjekker om to kataloginnganger har samme navn og brukernummer + * + * ffnEntry: kataloginngang med flertydig navn og brukernummer + * entry: kataloginngang som ffnEntry skal sjekkes mot + */ +boolean entryEquals (byte *ffnEntry, byte *entry) { + if (((*(ffnEntry + 0) == '?') || (*(ffnEntry + 0) == *(entry + 0))) && + + ((*(ffnEntry + 1) == '?') || (*(ffnEntry + 1) == *(entry + 1))) && + ((*(ffnEntry + 2) == '?') || (*(ffnEntry + 2) == *(entry + 2))) && + ((*(ffnEntry + 3) == '?') || (*(ffnEntry + 3) == *(entry + 3))) && + ((*(ffnEntry + 4) == '?') || (*(ffnEntry + 4) == *(entry + 4))) && + ((*(ffnEntry + 5) == '?') || (*(ffnEntry + 5) == *(entry + 5))) && + ((*(ffnEntry + 6) == '?') || (*(ffnEntry + 6) == *(entry + 6))) && + ((*(ffnEntry + 7) == '?') || (*(ffnEntry + 7) == *(entry + 7))) && + ((*(ffnEntry + 8) == '?') || (*(ffnEntry + 8) == *(entry + 8))) && + + ((*(ffnEntry + 9) == '?') || (*(ffnEntry + 9) == *(entry + 9))) && + ((*(ffnEntry + 10) == '?') || (*(ffnEntry + 10) == *(entry + 10))) && + ((*(ffnEntry + 11) == '?') || (*(ffnEntry + 11) == *(entry + 11)))) { + return TRUE; + } + return FALSE; +} + +/* Konverterer et tegn til et tegn som kan brukes i alle filnavn på så godt + * som alle operativsystem + * + * c: tegn som skal konverteres + */ +char legalChar (char c) { + const char *legalChars = "_^$~!#&-{}@'"; + + if (!strchr (legalChars, c)) { + if ((c < 48) || (c > 57 && c < 65) || (c > 90 && c < 97) || (c >122)) { + return '#'; + } + } + return toupper (c); +} + +/* Gir en peker til første tegn i filnavnet (etter evt. sti) + * + * ffn: filnavn med evt. sti + */ +char *stripPath (char *ffn) { + char *ptr; + + if (!(ptr = strrchr (ffn, '/'))) { + if (!(ptr = strrchr (ffn, '\\'))) { + if (!(ptr = strrchr (ffn, ':'))) { + ptr = ffn - 1; + } + } + } + return ptr + 1; +} diff --git a/tikidisk-src/tikidisk.txt b/tikidisk-src/tikidisk.txt new file mode 100644 index 0000000..08d7ed1 --- /dev/null +++ b/tikidisk-src/tikidisk.txt @@ -0,0 +1,118 @@ +tikidisk V1.1, 24 august 2001 + +Copyright (c) Asbjørn Djupdal 2001 + +Jeg gir tillatelse til å bruke og spre dette verktøyet fritt bortsett +fra til kommersielle formål. Det skal aldri tjenes penger på dette +produktet. + + +Kort beskrivelse: +----------------- + +Et program som lar deg manipulere TIKI-100 diskettfiler. +Støtter alle TIKI-100 diskettfiler. +Kildefiler tilgjengelige på min TIKI-100 hjemmeside: +http://www.stud.ntnu.no/tiki/ + +Bruk: +----- + +tikidisk {lxad}[brukernr] + +Hvor + + {lxad} er en (og bare en) av disse: + l = vis liste over filer i diskettfila + x = hent ut filer fra diskettfila + a = legg filer til diskettfila + d = slett filer fra diskettfila + + [brukernr] er brukernummer til filens eier. Dersom denne + utelates vil det tilsvare alle brukere for + kommandoene 'l','x' og 'd', mens for kommandoen a vil + det tilsvare bruker 0. + er navn på diskettfilen, må oppgis + er en eller flere filnavn + +Eksempler: +---------- + +Her er noen eksempler på bruk av 'tikidisk'. Får du ikke disse +eksemplene til å virke så les merknad om jokertegn senere i denne +teksten. + +tikidisk disk.dsk l *.* + - lister hele katalogen til disk.dsk på skjermen + +tikidisk disk.dsk x1 *.* + - henter ut alle filer med brukernummer 1 fra disk.dsk + +tikidisk disk.dsk x1 fil1.xxx fil2.xxx + - henter ut fil1.xxx og fil2.xxx med brukernummer 1 + +tikidisk disk.dsk x *.txt + - henter ut alle filer med filtype "txt", uansett brukernummer + +tikidisk disk.dsk a1 fil1.xxx + - legger fil1.xxx til disk.dsk med brukernummer 1 + +tikidisk disk.dsk a fil1.xxx + - legger fil1.xxx til disk.dsk med brukernummer 0 + +tikidisk disk.dsk d *.txt + - sletter alle filer med filtype "txt" fra disk.dsk + + +Merk: +----- + +- Du godt kan utelate brukernummer. Det vil føre til at for + kommandoene 'l','x' og 'd' vil alle filer med riktig filnavn + "treffe", uansett hvilket brukernummer de har. For kommandoen 'a' + vil programmet benytte brukernummer 0. + +- Jokertegn fungerer akkurat som på en TIKI-100, du kan benytte både * + og ?. + +- Noen kommandolinje-systemer (hovedsaklig UNIX-shell) ekspanderer + automatisk jokertegn før argumentene sendes til kommandoen. Det + fører til at du må ha gåseøyne (") rundt alle argumenter som + inneholder jokertegn, unntatt for kommandoen 'a' fordi det der er + ønskelig at systemet skal ekspandere jokertegn. + + Eks: + tikidisk disk.dsk l "*.*" + - lister hele katalogen til disk.dsk + +Format på listing av katalog: +----------------------------- + +Ved bruk av l-kommadoen får du en liste som ser slik ut: + + 128 --- 00: TEST.FIL + 256 lsa 01: TEST2.FIL +2 filer, 384 bytes + +Det første tallet er filstørrelsen i bytes. +Så kommer filattributtene: skrivebeskyttet (l), system (s) og arkivert (a). +Neste tall er brukernummer til fila. +Til slutt kommer filnavnet. + +Nederst vises antall filer i diskettfila, og totalt antall bytes for alle +filene. + +Historie: +--------- + +* 24 aug 2001 Versjon 1.1 + - Nesten helt omskrevet + - Lagt til støtte for jokertegn + - Lagt til støtte for 90k-diskettfiler. + - Kildefiler tilgjengelig +* 22 jan 2001 Versjon 1.0 + +-------------------------------------------------------------------------------- + +Har du spørsmål eller kommentarer, så ta kontakt med meg: +Asbjørn Djupdal, djupdal@stud.ntnu.no