head 1.4;
branch ;
access ;
symbols ;
locks ;
comment @@;


1.4
date 1996.02.15.22.25.06; author Sven_Goethel; state Exp;
branches ;
next 1.3;

1.3
date 1996.02.13.06.35.57; author Sven_Goethel; state Exp;
branches ;
next 1.2;

1.2
date 1995.11.29.02.49.40; author Sven_Goethel; state Exp;
branches ;
next 1.1;

1.1
date 1995.11.29.02.26.06; author Sven_Goethel; state Exp;
branches ;
next ;


desc
@@


1.4
log
@see rcfs.c
@
text
@#ifndef _RC_FS_H
#define _RC_FS_H

	#include <stdio.h>
	#ifndef _C166_
		#include <assert.h>
	#else
		#define _WITH_KL_806_
		#define assert(a) if(!(a))INT_ERR(__LINE__);
	#endif
	#include "metatype.h"

	#ifdef _WITH_KL_806_
		# ifndef _C166_
			# define STDH66 /* stop use c166 prototypes for TERMINAL.66 */
		# endif
		# include "mainterm.h"
		# include "termdac1.h66"
	#endif

	#include "permssn.h"

  /* a try to kill inode managment overhead while reading .. writing */
  #define _HANDLE_WITH_INODE_

  /* because of a bug in the kl806-block-file-system of version BF1.3e BETA,
     the maximum ramcard size is restricted to 65024 Bytes.
     if '__KL806_BF1_3e__' is defined the format command will
     only use the 65024 bytes !
  */
  #define __KL806__
  #define __KL806_BF1_3f__
  #define KL806_VERSION "1.3f BETA"

	/*
	 * $Log: rcfs.h $
	 * Revision 1.3  1996/02/13 06:35:57  Sven_Goethel
	 * it works
	 * Revision 1.2  1995/11/29 02:49:40  Sven_Goethel
	 * *** empty log message ***
	*/

	/* rc_fs  a simple file-system including
						a directory-structure and permittion control.
						this fs is created for the pcmcia-ramcard, or other devices ...
						the minix-filesystem (a LINUX-Filesystem) teached me how to
						implement.

						Because of magic conditions of the ramcard low level filesystem (fs),
						supported by Duerkopp-Adler(DA), the block-size is fixed by 256.
						Also the first seventeen bytes must be non zero and
						the last block byte (rel adress 0xff) is used for the
						8 bit CRC-Checksum !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
						All those things will give this ramcard-filesystem (rc-fs)
						a non flexible structure.
						The 18 Bytes garbage will also reduce the totally amount of
						netto ram size of the fs !!!!!!!!!!!!!!!!!!!!!!!!!!
	*/

	/* rc_fs  UPDATE
						The ramcard low level filesystem (fs) supported by Duerkopp-Adler(DA),
						contains true raw-block level functions NOW !
						All restrictions described upper, are removed !
	*/

	/* IMPLEMENTATION-NOTES
		 =====================

		 o The RCFS-Filesystem is created in a defined layer model.
		 o A layer is an implementation level.
		 o The level 0 means a low-level layer,
			 the level 1 means a higher-level layer, and so on.
		 o Functions defined in one layer can NEVER call a function defined in
			 a higher layer.
		 o Functions defined in one layer can allways call a function defined in
			 a lower layer.
		 o Normally, except the level 3 (user-level-functions), a function
			 in one layer only calls functions in the next lower layer.

		 LEVEL PERMISSION :

		 LEVEL #           CAN ACCESS LEVEL         DESCRIPTION
		 ========================================================
		 0                 -                        Basic I/O-Block-Functions
		 1                 0                        Inode and Zone (inode-depending)
																								I/O-Functions
		 2                 1                        Inode (dir-depending) Functions
		 3                 2,1,0                    User Functions (deklared here)
	*/

	/* rc := ramcard
		 fs := filesystem
		 inode := information node ( the fs structure )
		 sb := superblock ( contains fs geometrics and magic number )
		 bmp := bitmap ( contains marks for used/unused inodes/datazones )
		 crc := checksum defined as followed
						crc := 0
						for ( i=0; i<size; i++) crc += memory[i] ;
						( crc must be equal for any other times, the memory is not modified )


		 assume that :
		 =============
			[unsigned] short 			:= 16 bit
			[unsigned] long				:= 32 bit
			[unsigned] char				:=  8 bit

			1kBytes := 2^10 == 1024 Bytes
			128kB := 128 * 2^10 == 131072 Bytes
	*/

	/* RCFS Return-Values */
	typedef unsigned short rc_state;

	/* messing up level */
	#define RCFS_OK 								0
	#define RCFS_BLK_ERR						1
	#define RCFS_WRONG_FS						2
	#define RCFS_INVALID_SB					3
	#define RCFS_INODE_USED					4
	#define RCFS_INODE_UNUSED				5
	#define RCFS_ZONE_USED					6
	#define RCFS_ZONE_UNUSED				7
	#define RCFS_WRONG_IBLK_NO			8
	#define RCFS_INODE_FULL					9
	#define RCFS_NO_MORE_MEM			 10
	#define RCFS_MOUNTED           11
	#define RCFS_NOT_MOUNTED       12
	#define RCFS_WRONG_ZONE_NO     13
	#define RCFS_WRONG_INODE_NO    14
	#define RCFS_DISK_FULL         15

	/* critical level */
	#define RCFS_FILE_NOT_FOUND    			20
	#define RCFS_FILE_EXIST    			    21
	#define RCFS_WRONG_PERMISSION    		22
	#define RCFS_FILE_IS_DIR    			  23
	#define RCFS_FILE_IS_NOT_DIR   		  24
	#define RCFS_INVALID_DIR   		      25
	#define RCFS_INVALID_FILENAME       26

	#define RCFS_WRONG_HANDLE    			  30
	#define RCFS_WRONG_OPEN_MODE 			  31
	#define RCFS_LAST_ERROR             31


	/* magic number for rc_fs */
	#define RC_MAGIC	 0x1E1E         /* HIGH and LOW byte must be equal */
	#define MAGIC_MIN_BLCK_SIZE 256   /* fixed minimum block size */

	#define MAGIC_INODE_NUMBER_ROOT 0 /* inode number of the root directory */

	#define MAGIC_SB_BLOCK_NUMBER 1 /* block number of rcfs-superblock */


	/* sb-state bits */
	#define RC_MOUNTED 1U   /* RC inserted ?? */
	#define RC_VALID   2U   /* RC formatted with rc_fs */
	#define RC_READ    4U   /* RC readable */
	#define RC_WRITE   8U   /* RC writeable */
	#define RC_RDWR    12U  /* := RC_WRITE | RC_READ */
	#define RC_EXE     16U  /* executable */

	/* uid-state bits ( 9 pieces POSIX-STANDARD) */
	#define RC_OWN_RD     1U  /* readable for owner */
	#define RC_OWN_WR     2U  /* writeable for owner */
	#define RC_OWN_RDWR   3U  /* := RC_OWN_RD | RC_OWN_WR */
	#define RC_OWN_EX     4U  /* executable for owner */
	#define RC_GRP_RD     8U  /* readable for group */
	#define RC_GRP_WR    16U  /* writeable for group */
	#define RC_GRP_RDWR  24U  /* := RC_GRP_RD | RC_GRP_WR */
	#define RC_GRP_EX    32U  /* executable for owner */
	#define RC_ALL_RD    64U  /* readable for all */
	#define RC_ALL_WR   128U  /* writeable for all */
	#define RC_ALL_RDWR 192U  /* := RC_GRP_RD | RC_GRP_WR */
	#define RC_ALL_EX   256U /* executable for all */
	#define RC_DIR			512U  /* directory */

	/* rc_fs geometrics  :
		 ===================

		ASSUME that all 16bit values (unsigned short) will be stored in the format
					 Low-Byte High-Byte !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

		ASSUME that blk_sz and rc_sz expecting an even value !!
		e.g. ' the ramcard-size is 128 kBytes
					 (suggest that 2^10 Bytes == 1024 Bytes == 1kByte)
					 rc_sz := 2^10 * 128 Bytes == 1024 * 128 Bytes == 131072 Bytes

					 ALL CALCULATIONS ARE FOR INTEGERS !!!!


		 THE FIRST CALCULATIONS PASS :
		 =============================

		 usable_blk_sz:= blk_sz ;

		 max_blks     := rc_sz / blk_sz - 1 - 1
																			^   ^ for magic stuff
																			^ for SB

		 MAX-INODES ( one inode per block EQUALS 100 pct. inodes ) :
			 inode_number := max_blks - 2
																	^ for min. bmp's

		 inodes_p_blk		:= sizeof(rc_inode) / usable_blk_sz ;
		 inode_blks 		:= inode_number / inodes_p_blk ;
		 zone_blks    	:= max_blks - 2 - inode_blks
																	^ for min. bmp's
		 inode_bmp_sz 	:= inode_number / 8 + 1
		 inode_bmp_blks := inode_bmp_sz / usable_blk_sz + 1
		 zone_bmp_sz  	:= zone_blks / 8 + 1
		 zone_bmp_blks 	:= zone_bmp_sz / usable_blk_sz + 1

		 THE SECOND CALCULATION PASS (BMP-CORRECTION):
		 ==============================================

		 zone_blks      := zone_blks - zone_bmp_blks - inode_bmp_blks + 2

		 ( needed if the bmp-blks are greater than 2 !!!! )


		 BLOCK #   			  |  USAGE
		 ================================
				[1]      			|  SB
				[2  - a[			|  inode_bmp
				[a  - b[ 			|  zone_bmp
				[b  - c[ 			|  inodes
				[c  - d[ 			|  data-zone

		 while :
				a := 2 + inode_bmp_blks
				b := a + zone_bmp_blks
				c := b + inode_blks
				d := c + zone_blks

				be sure that d <= max_blks !!!!
	*/

	/*
     NOW OBSOLETE :
     ==============
		 note that because of DA low level rc-fs's GARBAGE,
		 the block size is fixed by 256 bytes,
		 the r/w access for a block starts at blk_udata_start (adress 17)
		 and ends at blk_udata_end (adress 254).
		 These values are stored in the fs-superblock because of the
		 hope, that DA will support a real block access for their ramcard-driver !!!
		 All functions do notice the sb-entrys for the GARBAGE space !!!

     NOW NEW :
     =========
     the superblock is of the minimum block size 256 Bytes Data.
     At the end there is now an VERSION STRING to check out
     changes etc ....

     THE VERSION STRING in the format :
           "XXXX.YY ZZ MM/DD/YYYY" with an EOS at the end !!!!

            XXXX.YY : Version
                 ZZ : Media Type
                      01 = RamCard 4 KL806-Duerkopp-Adler Terminal Machine

     THE DIR LONG COMMAND will Display the Version-Number ....
	*/

  #define RCFS_VERSION_STRING       "0001.00 01 02/14/1996"
  #define RC_MAGIC_SIGNATURE 0x0100 /* new superblock with version ... */

	typedef struct {
		unsigned short	magic_number;   /* for indicating this rc_fs */
		unsigned short 	blk_sz;			  	/* variable block size support not for da */
		unsigned long 	rc_sz;					/* ramcard size unformatted */
		unsigned short 	inode_number;   /* the number of the inodes */
		unsigned short 	zone_number;    /* the number of the data-zones */
		unsigned short 	root_inode;     /* the inode number of the root dir. */
		unsigned short 	inode_bmp_blks; /* the block size of the inode bmp */
		unsigned short 	zone_bmp_blks;  /* the block size of the zone bmp */
		unsigned short 	first_inode;	  /* the block number of the 1st inode */
		unsigned short 	first_zone;		  /* the block number of the 1st data zone */
		unsigned short  states;         /* ramcard state-flags ?? */
		unsigned short	uid;            /* uid bits */
    unsigned short  magic_signature;/* with xtension and stuff ???? */
    unsigned short  xtensions[103];  /* future extensions */
    char            version[22];    /* THE VERSION STRING */
	} rc_sb;

	/* ALL IZ... values are representing a number of unsigned short */
	#define IZPTR 				7 	 			/* number of the zone pointer (SEE NOTE)*/
	#define IZPTRPTR 		 10         /* size of the loaded heap of the
																		 double indirected blk-ptr blk  */

	/* assume that a pointer uses two bytes,
		 so that the the number of 128 pointers needs 256 bytes
		 and will fit exactly in the minimum block size
		 (SEE NOTE)
	*/
	#define IZPTRBLK     128         /* the size of the indirect ptr blk*/
	#define IZPTRPTRBLK  128         /* the size of the
																		 double indirected blk-ptr blk*/

	/* NOTE :
		 ======
		 IZPTR, IZPTRBLK and IZPTRPTRBLK are FILESYSTEM depended,
		 that means if you change these values,
		 your filesystem may be no more compatible to these original values !
	*/

	typedef struct {
		unsigned short  user;           /* user id */
		unsigned short  group;          /* user id */
		unsigned long   size; 					/* totally zones size */
		unsigned short  csec;
		unsigned short  cday_cmonth;    /* cday 0-99, cmonth 100-999 */
		unsigned short  cyear;					/* creation time */
		unsigned short  msec;
		unsigned short  mday_mmonth;    /* mday 0-99, mmonth 100-999 */
		unsigned short  myear;					/* last modification time */
		unsigned short	uid;            /* uid bits */
		unsigned short  zone_ptr[IZPTR];/* IZPTR zones ( minix-fs has seven ) */
		unsigned short  zone_ptrptr;    /* indirect zone pointer for very BIG FILES */
		unsigned long   crc32bit;       /* 32bit crc checksum over all referenced blks */
	} rc_inode;

	#define FNAMESZ	14U                /* like minix */

	typedef struct {
		unsigned short  inode;
		char            fname[FNAMESZ+1];
	} rc_dir_entry;


	/* RC-FS : LEVEL 0 */
	/* =============== */

	/* direct block-memory access and calculation */

	unsigned char Calc8BitCRC(const unsigned char *, unsigned short size);
	unsigned long Calc32BitCRC(const unsigned char *, unsigned short size);

	void 						put_ushort(unsigned char *dest, unsigned short val);
	unsigned short 	get_ushort(const unsigned char *src);

	void put_ushort_array(unsigned char *buffer, const unsigned short *usa,
												unsigned short usa_sz
											 );
	void get_ushort_array(const unsigned char *buffer, unsigned short *usa,
												unsigned short usa_sz
											 );

	void put_ulong(unsigned char *dest, unsigned long val);
	unsigned long get_ulong(const unsigned char *src);

	rc_state rc_writesb(const rc_sb *sb, bool erase_bmp);
	rc_state rc_readsb(rc_sb *);
	rc_state sync(void);

	rc_state rc_writeinode(rc_inode *inode, unsigned short inumber);
	rc_state rc_readinode(rc_inode *inode, unsigned short inumber);

	rc_state rc_markinode(unsigned short number);
	rc_state rc_unmarkinode(unsigned short number);
	rc_state rc_markzone(unsigned short number);
	rc_state rc_unmarkzone(unsigned short number);



	/* RC-FS : LEVEL 1 */
	/* =============== */

	/* rc_calc_crc32, rc_addblks, rc_getblks, rc_truncateblks
		 will nout update the refered inode only -- no media writing
	*/
	/* rc_createinode, rc_getinode, rc_putinode, rc_rminode
		 will save the inode to the media, if modified.
		 all functions test if mounted, inode-marked/unmarked in the bmp, etc...
		 (validation checking )
	*/

	rc_state rc_calc_crc32(rc_inode *inode, unsigned long *crc32);

	/* rc_addblks appends the block at the inode */
	/* rc_getblks gets the numbered block of the inode */
	/* rc_truncateblks truncates all blcks of the inode at the given byte position*/

	rc_state rc_addblks(const unsigned char *, unsigned short sz, rc_inode *);
	rc_state rc_getblks(unsigned char *, unsigned short sz,
											rc_inode *, unsigned long byteofs);
	rc_state rc_truncateblks(rc_inode *, unsigned long byteofs);

	/* rc_createinode creats a new inode with size zero and the todays stamp,
										and returns the created inode plus its inode number
										f(usr,grp,uid) -> inumber
	*/
	/* rc_getinode, rc_putinode
		 gets or puts the inode includes validation checking !
		 puts saves the inode to the media !
	*/
	/* rc_rminode removes an inode with all its data-zone's
								( but does not take care if inode respons to a directory,
									for directory integrity use LEVEL 3 fkt. )
								f(inumber) -> nil
	*/
	rc_state rc_createinode(unsigned short *inumber,
													unsigned short user, unsigned short group,
													unsigned short uid);
	rc_state rc_getinode(rc_inode *inode, unsigned short inumber);
	rc_state rc_putinode(rc_inode *inode, unsigned short inumber);
	rc_state rc_rminode(unsigned short inumber);


	/* RC-FS : LEVEL 2 */
	/* =============== */

  const char * rc_getuidstr(unsigned short uid);

	/* TestPermission checks the permission for inode access, return true if OK */
	bool TestPermission(const rc_inode *inode,
											unsigned short user, unsigned short group,
											unsigned short mode
										 );

	/* rc_mkdirinode : f(dir_inumber,name,usr,grp,uid) -> new_inumber
		 If uid contents the RC_DIR bit, this functions assumes that a new
		 directory will be created ! In this case a data block for the inode
		 will be created with the general files '.' and '..' !!!!!!!!!!!!!!!
		 Otherwise the inode does not reference any block, so that the file size
		 equals zero !!!!!!!
		 The function checks if the name ( no slashes etc. are allowed )
		 does allready exist.
		 READ/WRITE permission for dir_inumber will be checked !
	*/
	/* rc_getdirinode : f(dir_inumber,usr,grp,name) -> inumber
		 Trys to receive the fitting inode-number according to the file 'name'
		 the 'name' can be a valid filename included '.' and '..' !!!
		 READ permission for dir_inumber will be checked !
	*/
	/* rc_rmdirinode : f(dir_inumber, name, recursive) -> nil
		 removes the found file 'name' in the directory 'dir_inumber',
		 if the found file is an directory, the flag 'recursive' indicates,
		 if the whole directory include its sub-directorys and files will be
		 removed !!!
		 READ/WRITE permission for dir_inumber will be checked !
	*/

	rc_state rc_mkdirinode(unsigned short *new_inumber,
												 unsigned short dir_inumber,
												 const char *name,
												 unsigned short user, unsigned short group,
												 unsigned short uid);
	rc_state rc_getdirinode(unsigned short *inumber,
													unsigned short dir_inode,
													unsigned short user, unsigned short group,
													const char *name
												 );
	rc_state rc_rmdirinode(unsigned short dir_inumber, const char *name,
												 unsigned short user, unsigned short group,
												 bool recursiv
												 );



	/* RC-FS : LEVEL 3 -- USER LEVEL */
	/*                 -- to provide file permissions, you will need
												the permssn.c/h module !!!!!!!!!!!!!!!!!!!
	*/

	rc_state rc_mount(bool write_back);
	rc_state rc_umount(void);
  rc_state rc_checkfs(bool verbose);

	rc_state rc_format(unsigned short blk_sz,
										 double inode_pct, unsigned short uid );

	rc_state rc_mkdir(const char *fname);
	rc_state rc_cd(const char *fname);

  rc_state rc_dir(char *dest, unsigned short dest_sz,
                  char *prefix,
								  bool recursiv, bool flong);

	rc_state rc_rm(const char *fname, bool recursiv);
	rc_state rc_remove(const char *fname);

	rc_state rc_IsExistFile (const char *name, bool *flag);
	rc_state rc_IsExistDir (const char *name, bool *flag);
	rc_state rc_IsExist (const char *name, bool *flag);

	/* rc_open modes : (READ WRITE like the SB - STATES) */
	#ifndef RC_READ
		#define RC_READ 	4U
	#endif
	#ifndef RC_WRITE
		#define RC_WRITE 	8U
	#endif
	#ifndef RC_RDWR
		#define RC_RDWR 	12U
	#endif
	#define RC_BINARY 	16U /* ignored */
	#define RC_TEXT 		32U /* ignored */
	#define RC_CREATE		64U
	#define RC_APPEND	 128U

  #define RC_DEF_FILE_BUFFER_SZ 1024

	typedef struct {
		unsigned short inumber; /* the inode-number off .. */
		unsigned short open_mode;
		unsigned short mode;
		unsigned long byte_pos;
		bool eof;
		/* things to support buffered access */
		unsigned char *buffer;
		unsigned short bufferidx;
    unsigned short buffersz;
    #ifdef _HANDLE_WITH_INODE_
      rc_inode inode;
    #endif
	} rc_handle;

  void rc_set_fbuffer_sz(unsigned short sz);

	rc_handle * rc_open(const char *fname, unsigned short mode);
	rc_state rc_close(rc_handle *hdle);

	rc_state  rc_rewind(rc_handle *hdle);
	rc_state rc_flush(rc_handle *hdle);

	rc_state rc_geterr(void);
	int rc_iseof(rc_handle *hdle);

	unsigned short rc_write(rc_handle *hdle, const unsigned char *mem,
													unsigned short size
												 );
	unsigned short  rc_read(rc_handle *hdle, unsigned char *mem, unsigned short size);

	/*
		whence for rc_fseek :
		======================
		SEEK_SET : Sucht ab Dateianfang
		SEEK_CUR : Sucht ab der aktuellen Position
		SEEK_END : Sucht vom Dateiende her
	*/
	#ifndef SEEK_SET
		#define SEEK_SET 0
	#endif
	#ifndef SEEK_CUR
		#define SEEK_CUR 1
	#endif
	#ifndef SEEK_END
		#define SEEK_END 2
	#endif
	int rc_fseek(rc_handle *hdle, long offset, int whence);
	unsigned long rc_ftell(rc_handle *hdle);

	int  rc_printf(rc_handle *hdle, const char *fmt, ... );
	int  rc_getc(rc_handle *hdle);
  unsigned short rc_puts(const char *str, rc_handle *hdle);
	unsigned short  rc_putc(char c, rc_handle *hdle);

	void rc_put_err(rc_state state);
	const char * rc_get_err(rc_state state);

#endif
@


1.3
log
@it works
@
text
@d37 2
d241 2
d249 1
d251 14
a264 1
		 All functions do notice the sb-entrys for the GARBAGE space !!!
d266 4
d283 3
@


1.2
log
@*** empty log message ***
@
text
@d1 2
d4 8
d13 112
d125 5
a129 2
#ifndef _RC_FS_H
#define _RC_FS_H
d131 8
a138 3
/*
 * $Log: rcfs.h $
*/
d140 3
a142 5
/* rc_fs  a simple file-system including 
          a directory-structure and permittion control.
					this fs is created for the pcmcia-ramcard, or other devices ...
					the minix-filesystem (a LINUX-Filesystem) teached me how to
					implement.
a143 10
					Because of magic conditions of the ramcard low level filesystem (fs),
					supported by Duerkopp-Adler(DA), the block-size is fixed by 256.
					Also the first seventeen bytes must be non zero and
					the last block byte (rel adress 0xff) is used for the
					8 bit CRC-Checksum !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          All those things will give this ramcard-filesystem (rc-fs) 
					a non flexible structure.
					The 18 Bytes garbage will also reduce the totally amount of
					netto ram size of the fs !!!!!!!!!!!!!!!!!!!!!!!!!!
*/
d145 3
a147 9
/* rc := ramcard
   fs := filesystem
   inode := information node ( the fs structure )
	 sb := superblock ( contains fs geometrics and magic number )
	 bmp := bitmap ( contains marks for used/unused inodes/datazones )
	 crc := checksum defined as followed 
	 				crc := 0
					for ( i=0; i<size; i++) crc += memory[i] ;
					( crc must be equal for any other times, the memory is not modified )
d149 1
d151 1
a151 5
	 assume that :
	 =============
	 	[unsigned] short 			:= 16 bit
		[unsigned] long				:= 32 bit
		[unsigned] char				:=  8 bit
a152 3
		1kBytes := 2^10 == 1024 Bytes
		128kB := 128 * 2^10 == 131072 Bytes
*/
d154 7
a160 12
/* magic number for rc_fs */
#define RC_MAGIC	 0x1E1E
#define MIN_BLCK_SIZE 256         /* minimum block size */
#define MAGIC_BLCK_SIZE 256       /* fixed block size */
#define MAGIC_PROLOG 17           /* 17 bytes magic garbage for DA-Ramcard
                                     at block start (really garbage)
																	*/
#define MAGIC_PROLOG_FILLING 255  /* fill-pattern for MAGIC_PROLOG */
#define MAGIC_EPILOG 1            /* 1 bytes magic garbage for DA-Ramcard
                                     at block end (checksum)
																	*/
#define MAGIC_NETTO_BLCK 	MAGIC_BLCK_SIZE-MAGIC_PROLOG-MAGIC_EPILOG
d162 14
a175 6
/* sb-state bits */
#define RC_MOUNTED 1   /* RC inserted ?? */
#define RC_VALID   2   /* RC formatted with rc_fs */
#define RC_READ    4   /* RC readable */ 
#define RC_WRITE   8   /* RC writeable */
#define RC_RDWR    12  /* := RC_WRITE | RC_READ */
d177 2
a178 14
/* uid-state bits ( 9 pieces POSIX-STANDARD) */
#define RC_OWN_RD     1  /* readable for owner */
#define RC_OWN_WR     2  /* writeable for owner */
#define RC_OWN_RDWR   3  /* := RC_OWN_RD | RC_OWN_WR */
#define RC_OWN_EX     4  /* executable for owner */
#define RC_GRP_RD     8  /* readable for group */
#define RC_GRP_WR    16  /* writeable for group */
#define RC_GRP_RDWR  24  /* := RC_GRP_RD | RC_GRP_WR */
#define RC_GRP_EX    32  /* executable for owner */
#define RC_ALL_RD    64  /* readable for all */
#define RC_ALL_WR   128  /* writeable for all */
#define RC_ALL_RDWR 192  /* := RC_GRP_RD | RC_GRP_WR */
#define RC_ALL_EX   256  /* executable for all */
#define RC_DIR			512  /* directory ??? */        
d180 2
a181 1
#define INODE_ROOT 1              /* inode number of the root directory */
d183 4
a186 2
/* rc_fs geometrics  :
   ===================
d188 1
a188 5
  ASSUME that blk_sz and rc_sz expecting an value, that kan be divided
	       through the number 2 !!!!
	e.g. ' the ramcard-size is 128 kBytes
	       (suggest that 2^10 Bytes == 1024 Bytes == 1kByte)
				 rc_sz := 2^10 * 128 Bytes == 1024 * 128 Bytes == 131072 Bytes
a189 1
				 ALL CALCULATIONS ARE FOR INTEGERS !!!!
d191 2
d194 1
a194 2
   THE FIRST CALCULATIONS PASS :
	 =============================
d196 3
a198 3
   max_blks     := rc_sz / blk_sz - 1 - 1
	                                  ^   ^ for magic stuff
	                                  ^ for SB
d200 3
a202 3
   MAX-INODES ( one inode per block minus rounding const. ) :
		 inode_number := max_blks - 2
		 														^ for min. bmp's
d204 8
a211 7
   inode_blks   	:= inode_number * sizeof(rc_inode) / blk_sz + 1
	 zone_blks    	:= max_blks - 2 - inode_blks
															  ^ for min. bmp's	
	 inode_bmp_sz 	:= inode_number / 8 + 1
	 inode_bmp_blks := inode_bmp_sz / blk_sz + 1
	 zone_bmp_sz  	:= zone_blks / 8 + 1 
	 zone_bmp_blks 	:= zone_bmp_sz / blk_sz + 1
d213 2
a214 2
   THE SECOND CALCULATION PASS (BMP-CORRECTION):
	 ==============================================
d216 1
a216 1
	 zone_blks      := zone_blks - zone_bmp_blks - inode_bmp_blks + 2
d218 1
a218 1
   ( needed if the bmp-blks are greater than 2 !!!! )
d221 7
a227 7
	 BLOCK #   			  |  USAGE
	 ================================
	 		[1]      			|  SB
			[2  - a[			|  inode_bmp
			[a  - b[ 			|  zone_bmp
			[b  - c[ 			|  inodes
			[c  - d[ 			|  data-zone
d229 5
a233 5
   while :
	 		a := 2 + inode_bmp_blks
			b := a + zone_bmp_blks
			c := b + inode_blks
			d := c + zone_blks
d235 2
a236 2
			be sure that d <= max_blks !!!!
*/
d238 7
a244 7
/*
   note that because of DA low level rc-fs's GARBAGE,
	 the block size is fixed by 256 bytes,
	 the r/w access for a block starts at blk_udata_start (adress 17)
	 and ends at blk_udata_end (adress 254).
	 These values are stored in the fs-superblock because of the
	 hope, that DA will support a real block access for their ramcard-driver !!!
d246 16
a261 16
	 All functions do notice the sb-entrys for the GARBAGE space !!!
*/
typedef struct {
	unsigned short	magic_number; 	/* for indicating this rc_fs */
	unsigned char 	blk_sz;			  	/* variable block size support not for da */
	unsigned char   blk_udata_start /* beginn of usable block-data */
	unsigned char   blk_udata_end   /* end of usable block-data */
	unsigned char 	rc_sz;					/* ramcard size unformatted */
	unsigned short 	inode_number;   /* the number of the inodes */
	unsigned short 	zone_number;    /* the number of the data-zones */
	unsigned short 	root_inode;     /* the inode number of the root dir. */
	unsigned short 	first_inode;	  /* the block number of the 1st inode */
	unsigned short 	first_zone;		  /* the block number of the 1st data zone */
	unsigned char	  states;         /* ramcard state-flags ?? */
	unsigned short	uid;            /* uid bits */
} rc_sb;
d263 4
a266 1
#define IZPTR 7 									/* number of the zone pointer */
d268 8
a275 12
typedef struct {
  unsigned char   user;           /* user id */
  unsigned char   group;          /* user id */
	unsigned short  size; 					/* totally zones size */
	long					  ctime;					/* creation time */
	long					  atime;					/* last access time */
	unsigned short	uid;            /* uid bits */
	unsigned short  zone_ptr[IZPTR];/* seven zones */
	unsigned short  zone_ptrptr;    /* indirect zone pointer for very BIG FILES */
	unsigned long   z_crc;          /* 32 bit crc checksum of all used zones */ 
	unsigned char   i_crc;          /*  8 bit crc checksum of this inode */ 
} rc_inode;
d277 6
a282 1
#define FNAMESZ	14                /* like minix */
d284 15
a298 5
typedef struct {
  unsigned short  inode;
	char            fname[FNAMESZ];
	unsigned short	uid;            /* uid bits */
} rc_dir_entry;
d300 1
a300 3
#ifndef BYTE
  typedef unsigned char BYTE;
#endif
d302 4
a306 1
/* RC-FS : LEVEL 0 */
d308 2
a309 2
unsigned char Calc8BitCRC(const BYTE *, unsigned short size);
unsigned long Calc32BitCRC(const BYTE *, unsigned short size);
d311 1
a311 4
/* rc_mksb puts the sb to its magic_place ( 1. Block ) */
/* rc_getsb gets the sb from its magic_place ( 1. Block ) */
rc_error rc_mksb(const rc_sb *);
rc_error rc_getsb(rc_sb **);
d313 2
a314 4
rc_error rc_markinode(const rc_sb *, unsigned short number);
rc_error rc_unmarkinode(const rc_sb *, unsigned short number);
rc_error rc_markzone(const rc_sb *, unsigned short number);
rc_error rc_unmarkzone(const rc_sb *, unsigned short number);
d316 2
d319 6
a324 1
/* RC-FS : LEVEL 1 */
d326 96
a421 7
/* Be sure that the BYTE pointer points to a memory of blk_sz */
/* rc_addblk appends the block at the inode */
/* rc_getblk gets the numbered block of the inode */
/* rc_rmblk removes the numbered block of the inode */
rc_error rc_addblk(const BYTE *, const rc_inode *);
rc_error rc_getblk(BYTE *, const rc_inode *, unsigned short number);
rc_error rc_rmblk(const rc_inode *, unsigned short number);
d422 13
a434 4
bool     rc_check_rd_perm(const rc_inode *,
                          unsigned char user, unsigned char group);
bool     rc_check_wr_perm(const rc_inode *,
                          unsigned char user, unsigned char group);
a435 1
/* RC-FS : LEVEL 2 */
a436 14
/* rc_createinode creats a new inode with size zero and the todays stamp,
                  and returns the created inode plus its inode number
									f(usr,grp,uid) -> new_inode, inumber
*/
/* rc_getinode gets a numbered inode and returns it */
/* rc_rminode removes an inode with all its data-zone's   
              ( non sub-directorys ( for integrity rm use LEVEL 3 fkt. ) )
									f(inumber) -> inode
*/
rc_error rc_createinode(rc_inode *, unsigned short *inumber, 
                        unsigned char user, unsigned char group,
												unsigned short uid); 
rc_error rc_getinode(rc_inode *, unsigned short inumber);
rc_error rc_rminode(unsigned short inumber);
d438 4
a441 5
/* RC-FS : LEVEL 3 */
/* rc_mkdirinode : f(parent_inode,name,usr,grp,uid) -> new_inode, new_inumber */
/* rc_getdirentry : f(parent_inode,dir_entry_number) -> rc_dir_entry */
/* rc_getdirinode : f(parent_inode,name) -> inode, inumber */
/* rc_rmdirinode : f(inumber) -> nil */
d443 3
a445 12
rc_error rc_mkdirinode(rc_inode *new_inode, unsigned short *new_inumber,
                       const rc_inode *parent_inode,
                       const char *name, 
                       unsigned char user, unsigned char group,
											 unsigned short uid); 
rc_error rc_getdirentry(rc_dir_entry *, 
												const rc_inode *parent_inode,
												unsigned short dnumber);
rc_error rc_getdirinode(rc_inode *inode, unsigned short *inumber, 
												const rc_inode *parent_inode,
												const char *name);
rc_error rc_rmdirinode(unsigned short inumber);
d447 2
d450 2
a451 4
/* RC-FS : LEVEL 4 -- USER LEVEL */
/*                 -- to provide file permissions, you will need
                      the permssn.c/h module !!!!!!!!!!!!!!!!!!!
*/
d453 3
a455 12
/* rc_open modes : (READ WRITE like the SB - STATES) */
#ifndef RC_READ
	#define RC_READ 	4
#endif
#ifndef RC_WRITE
	#define RC_WRITE 	8
#endif
#ifndef RC_RDWR
	#define RC_RDWR 	12
#endif
#define RC_BINARY 	16
#define RC_TEXT 		32
d457 2
a458 8
rc_error rc_format(unsigned char blk_sz, unsigned char rc_sz, char inode_pct,
									 unsigned short uid);
rc_error rc_mkdir(const char *, unsigned char user, unsigned char group,
									unsigned short uid);
rc_error rc_cd(const char *, unsigned char user, unsigned char group,
							 unsigned short uid);
rc_error rc_rmdir(const char *, unsigned char user, unsigned char group,
									unsigned short uid);
d460 3
a462 3
rc_error rc_open(rc_handle *, const char *fname, unsigned char mode);
rc_error rc_close(rc_handle );
rc_error rc_remove(const char *);
d464 14
a477 2
unsigned short  rc_write(rc_handle rch, const BYTE *mem, unsigned short size);
unsigned short  rc_read(rc_handle rch, BYTE *mem, unsigned short size);
d479 1
a479 3
unsigned short  rc_printf(rc_handle rch, const char *fmt, ... );
unsigned short  rc_getc(rc_handle rch);
unsigned short  rc_putc(char c, rc_handle rch);
d481 14
a494 2
char *rc_gets(BYTE *str, unsigned short n, rc_handle rch);
int fputs(const BYTE *str, rc_handle rch);
d496 42
@


1.1
log
@Initial revision
@
text
@d6 4
d15 10
d50 10
a83 1
#define MIN_BLCK_SIZE 256         /* minimum block size */
d100 3
a102 2
   max_blks     := rc_sz / blk_sz - 1
	                                  ^for SB
d141 10
d153 3
a155 1
	unsigned char 	blk_sz;			  	/* variable block size support */
@