// Program name: cfheader.h
// Programmed by: Anthony Barbachan
// Programmed in: C++ (Turbo C++ 3.0 Compatable)
// Purpose: Header file for a cabinet file header object.
// Version: 1.00
// Last modified on: 11/5/1998
// Version: 1.00a
// Last modified on: 11/29/1998
// Changes: Normalize internal functions.  Fixed missing call to previous reset.
// Version: 2.00
// Last modification date: 10-18-1999
// Changes: Replaced code with new classes' code.

#ifndef __CFHEADER_H__
#define __CFHEADER_H__

#include <string.h>
#include <fstream.h>
#include "cftypes.h"
#include "bstring.h"

////////////////////////////////////////////////////////////////////////////////

// This class contains all the fixed fields always preset in a cabinet header

class cabinet_fixed_header
{
	public:
		enum
		{
			PREV_CABINET = 0x0001,
			NEXT_CABINET = 0x0002,
			RESERVE_PRESENT = 0x0004
		};
	protected:
		byte signature[4];		// cabinet file signature
		dword reserved1;		// reserved
		dword size;			// size of this cabinet file in bytes
		dword reserved2;		// reserved
		dword files_offset;		// offset of the first CFFILE entry
		dword reserved3;		// reserved
		byte version_minor;		// cabinet file format version, minor
		byte version_major;		// cabinet file format version, major
		word nfolders;			// number of CFFOLDER entries in this cabinet
		word nfiles;			// number of CFFILE entries in this cabinet
		word flags;			// cabinet file option indicators
		word id;				// must be the same for all cabinets in a set
		word cabinetno;		// number of this cabinet file in a set
	private:
		void clear_variables() { memset(this, 0, sizeof(*this)); }
	public:
		cabinet_fixed_header() { clear_variables(); }
		~cabinet_fixed_header() { }

		void clear() { clear_variables(); }
		void init(void);
		Error read(istream& in);
		Error write(ostream& out);

		byte* get_signature() { return signature; }
		void set_signature(const byte* sig) { memcpy(signature, sig, 4); }
		dword get_size() { return size; }
		void set_size(dword newsize) { size = newsize; }
		dword get_files_offset() { return files_offset; }
		void set_files_offset(dword newoff) { files_offset = newoff; }
		byte get_version_minor() { return version_minor; }
		void set_version_minor(byte newver) { version_minor = newver; }
		byte get_version_major() { return version_major; }
		void set_version_major(byte newver) { version_major = newver; }
		word get_nfolders() { return nfolders; }
		void set_nfolders(word numfolds) { nfolders = numfolds; }
		word get_nfiles() { return nfiles; }
		void set_nfiles(word numfiles) { nfiles = numfiles; }
		word get_flags() { return flags; }
		void set_flags(word newflags) { flags = newflags; }
		word get_id() { return id; }
		void set_id(word newid) { id = newid; }
		word get_cabinetno() { return cabinetno; }
		void set_cabinetno(word newcabno) { cabinetno = newcabno; }

		void set_flag(word f) { flags |= f; }
		void unset_flag(word f) { flags &= ~f; }
		void increase_size_by(dword change) { size += change; }
		void decrease_size_by(dword change) { size -= change; }
		void increase_foffset_by(dword change) { files_offset += change; }
		void decrease_foffset_by(dword change) { files_offset -= change; }
		void increase_nfolders_by(word change) { nfolders += change; }
		void decrease_nfolders_by(word change) { nfolders -= change; }
		void inc_nfolders() { nfolders++; }
		void dec_nfolders() { nfolders--; }
		void increase_nfiles_by(word change) { nfiles += change; }
		void decrease_nfiles_by(word change) { nfiles -= change; }
		void inc_nfiles() { nfiles++; }
		void dec_nfiles() { nfiles--; }

		int valid_header()
		{
			return (signature[0] == 'M') && (signature[1] == 'S') &&
				  (signature[2] == 'C') && (signature[3] == 'F');
		}
		int invalid_header()
		{
			return (signature[0] != 'M') || (signature[1] != 'S') ||
				  (signature[2] != 'C') || (signature[3] != 'F');
		}
		int has_prev() { return flags & PREV_CABINET; }
		int is_first() { return !has_prev(); }
		int has_next() { return flags & NEXT_CABINET; }
		int is_last() { return !has_next(); }
		int has_reserved_area() { return flags & RESERVE_PRESENT; }
};

////////////////////////////////////////////////////////////////////////////////

// This class expands the header information by including optional data

class cabinet_header : public cabinet_fixed_header
{
	protected:
		word cabinet_ra_size;	// (optional) size of per-cabinet reserved area
		byte folder_ra_size;	// (optional) size of per-folder reserved area
		byte datablock_ra_size; 	// (optional) size of per-datablock reserved area
		byte* reserved_area;	// (optional) per-cabinet reserved area
		b_string prev_cabinet;	// (optional) name of previous cabinet file
		b_string prev_disk;		// (optional) name of previous disk
		b_string next_cabinet;	// (optional) name of next cabinet file
		b_string next_disk;		// (optional) name of next disk
	private:
		void clear_variables()
		{
			cabinet_ra_size = 0u;
			folder_ra_size = 0u;
			datablock_ra_size = 0u;
			reserved_area = NULL;
		}
		void free_buffers()
		{
			if(reserved_area != NULL) delete[] reserved_area;
		}
		void clear_class_variables()
		{
			free_buffers();
			prev_cabinet.clear();
			prev_disk.clear();
			next_cabinet.clear();
			next_disk.clear();
			clear_variables();
		}
	public:
		static Error read_string(b_string& str, istream& in);
	public:
		cabinet_header() { clear_variables(); }
		~cabinet_header() { free_buffers(); }

		void clear()
			{ clear_class_variables(); cabinet_fixed_header::clear(); }
		void init() { clear(); cabinet_fixed_header::init(); }
		Error read(istream& in);
		Error write(ostream& out);

		word get_cabinet_ra_size() { return cabinet_ra_size; }
		void set_cabinet_ra_size(word size) { cabinet_ra_size = size; }
		byte get_folder_ra_size() { return folder_ra_size; }
		void set_folder_ra_size(byte size) { folder_ra_size = size; }
		byte get_datablock_ra_size() { return datablock_ra_size; }
		void set_datablock_ra_size(byte size) { datablock_ra_size = size; }
		const byte* get_reserved_area() { return reserved_area; }
		void set_reserved_area(const byte* newra)
			{ memcpy(reserved_area, newra, cabinet_ra_size); }
		const char* get_prev_cabinet() { return (const char *) prev_cabinet; }
		void set_prev_cabinet(const char* val) { prev_cabinet = val; }
		void set_prev_cabinet(b_string& val) { prev_cabinet = val; }
		const char* get_prev_disk() { return (const char *) prev_disk; }
		void set_prev_disk(const char* val) { prev_disk = val; }
		void set_prev_disk(b_string& val) { prev_disk = val; }
		const char* get_next_cabinet() { return (const char *) next_cabinet; }
		void set_next_cabinet(const char* val) { next_cabinet = val; }
		void set_next_cabinet(b_string& val) { next_cabinet = val; }
		const char* get_next_disk() { return (const char *) next_disk; }
		void set_next_disk(const char* val) { next_disk = val; }
		void set_next_disk(b_string& val) { next_disk = val; }
};

////////////////////////////////////////////////////////////////////////////////

#endif