CnC_Remastered_Collection

INI.CPP (73204B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/INI.CPP 1     3/03/97 10:24a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : INI.CPP                                                      *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : September 10, 1993                                           *
  *                                                                                             *
  *                  Last Update : November 2, 1996 [JLB]                                       *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  *   INIClass::Clear -- Clears out a section (or all sections) of the INI data.                *
  *   INIClass::Entry_Count -- Fetches the number of entries in a specified section.            *
  *   INIClass::Find_Entry -- Find specified entry within section.                              *
  *   INIClass::Find_Section -- Find the specified section within the INI data.                 *
  *   INIClass::Get_Bool -- Fetch a boolean value for the section and entry specified.          *
  *   INIClass::Get_Entry -- Get the entry identifier name given ordinal number and section name*
  *   INIClass::Get_Fixed -- Fetch a fixed point number from the section & entry.               *
  *   INIClass::Put_Fixed -- Store a fixed point number to the INI database.                    *
  *   INIClass::Get_Hex -- Fetches integer [hex format] from the section and entry specified.   *
  *   INIClass::Get_Int -- Fetch an integer entry from the specified section.                   *
  *   INIClass::Get_PKey -- Fetch a key from the ini database.                                  *
  *   INIClass::Get_String -- Fetch the value of a particular entry in a specified section.     *
  *   INIClass::Get_TextBlock -- Fetch a block of normal text.                                  *
  *   INIClass::Get_UUBlock -- Fetch an encoded block from the section specified.               *
  *   INIClass::INISection::Find_Entry -- Finds a specified entry and returns pointer to it.    *
  *   INIClass::Load -- Load INI data from the file specified.                                  *
  *   INIClass::Load -- Load the INI data from the data stream (straw).                         *
  *   INIClass::Put_Bool -- Store a boolean value into the INI database.                        *
  *   INIClass::Put_Hex -- Store an integer into the INI database, but use a hex format.        *
  *   INIClass::Put_Int -- Stores a signed integer into the INI data base.                      *
  *   INIClass::Put_PKey -- Stores the key to the INI database.                                 *
  *   INIClass::Put_String -- Output a string to the section and entry specified.               *
  *   INIClass::Put_TextBlock -- Stores a block of text into an INI section.                    *
  *   INIClass::Put_UUBlock -- Store a binary encoded data block into the INI database.         *
  *   INIClass::Save -- Save the ini data to the file specified.                                *
  *   INIClass::Save -- Saves the INI data to a pipe stream.                                    *
  *   INIClass::Section_Count -- Counts the number of sections in the INI data.                 *
  *   INIClass::Strip_Comments -- Strips comments of the specified text line.                   *
  *   INIClass::~INIClass -- Destructor for INI handler.                                        *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	<string.h>
 #include	<stdlib.h>
 #include	<stddef.h>
 #include	<stdio.h>
 #include	<ctype.h>
 #include	"ini.h"
 #include	"readline.h"
 #include	"xpipe.h"
 #include	"b64pipe.h"
 #include	"xstraw.h"
 #include	"b64straw.h"
 
 
 #ifdef FIXIT_FAST_LOAD
 #include	"cstraw.h"
 #endif
 
 
 
 // Disable the "temporary object used to initialize a non-constant reference" warning.
 //#pragma warning 665 9
 
 
 /***********************************************************************************************
  * INIClass::~INIClass -- Destructor for INI handler.                                          *
  *                                                                                             *
  *    This is the destructor for the INI class. It handles deleting all of the allocations     *
  *    it might have done.                                                                      *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 INIClass::~INIClass(void)
 {
 	Clear();
 }
 
 
 /***********************************************************************************************
  * INIClass::Clear -- Clears out a section (or all sections) of the INI data.                  *
  *                                                                                             *
  *    This routine is used to clear out the section specified. If no section is specified,     *
  *    then the entire INI data is cleared out. Optionally, this routine can be used to clear   *
  *    out just an individual entry in the specified section.                                   *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section to clear out [pass NULL to clear all].          *
  *                                                                                             *
  *          entry    -- Pointer to optional entry specifier. If this parameter is specified,   *
  *                      then only this specific entry (if found) will be cleared. Otherwise,   *
  *                      the entire section specified will be cleared.                          *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   08/21/1996 JLB : Optionally clears section too.                                           *
  *   11/02/1996 JLB : Updates the index list.                                                  *
  *=============================================================================================*/
 bool INIClass::Clear(char const * section, char const * entry)
 {
 	if (section == NULL) {
 		SectionList.Delete();
 		SectionIndex.Clear();
 	} else {
 		INISection * secptr = Find_Section(section);
 		if (secptr != NULL) {
 			if (entry != NULL) {
 				INIEntry * entptr = secptr->Find_Entry(entry);
 				if (entptr != NULL) {
 					/*
 					**	Remove the entry from the entry index list.
 					*/
 					secptr->EntryIndex.Remove_Index(entptr->Index_ID());
 
 					delete entptr;
 				}
 			} else {
 				/*
 				**	Remove this section index from the section index list.
 				*/
 				SectionIndex.Remove_Index(secptr->Index_ID());
 
 				delete secptr;
 			}
 		}
 	}
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Load -- Load INI data from the file specified.                                    *
  *                                                                                             *
  *    Use this routine to load the INI class with the data from the specified file.            *
  *                                                                                             *
  * INPUT:   file  -- Reference to the file that will be used to fill up this INI manager.      *
  *                                                                                             *
  * OUTPUT:  bool; Was the file loaded successfully?                                            *
  *                                                                                             *
  * WARNINGS:   This routine allocates memory.                                                  *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Load(FileClass & file)
 {
 	return(Load(FileStraw(file)));
 }
 
 
 /***********************************************************************************************
  * INIClass::Load -- Load the INI data from the data stream (straw).                           *
  *                                                                                             *
  *    This will fetch data from the straw and build an INI database from it.                   *
  *                                                                                             *
  * INPUT:   straw -- The straw that the data will be provided from.                            *
  *                                                                                             *
  * OUTPUT:  bool; Was the database loaded ok?                                                  *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/10/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 #ifdef FIXIT_FAST_LOAD
 bool INIClass::Load(Straw & ffile)
 #else
 bool INIClass::Load(Straw & file)
 #endif
 {
 	bool end_of_file = false;
 	char buffer[MAX_LINE_LENGTH];
 
 #ifdef FIXIT_FAST_LOAD
 	CacheStraw file;
 	file.Get_From(ffile);
 #endif
 
 	/*
 	**	Prescan until the first section is found.
 	*/
 	while (!end_of_file) {
 		Read_Line(file, buffer, sizeof(buffer), end_of_file);
 		if (end_of_file) return(false);
 		if (buffer[0] == '[' && strchr(buffer, ']') != NULL) break;
 	}
 
 	/*
 	**	Process a section. The buffer is prefilled with the section name line.
 	*/
 	while (!end_of_file) {
 
 		buffer[0] = ' ';
 		char * ptr = strchr(buffer, ']');
 		if (ptr) *ptr = '\0';
 		strtrim(buffer);
 		INISection * secptr = new INISection(strdup(buffer));
 		if (secptr == NULL) {
 			Clear();
 			return(false);
 		}
 
 		/*
 		**	Read in the entries of this section.
 		*/
 		while (!end_of_file) {
 
 			/*
 			**	If this line is the start of another section, then bail out
 			**	of the entry loop and let the outer section loop take
 			**	care of it.
 			*/
 			int len = Read_Line(file, buffer, sizeof(buffer), end_of_file);
 			if (buffer[0] == '[' && strchr(buffer, ']') != NULL) break;
 
 			/*
 			**	Determine if this line is a comment or blank line. Throw it out if it is.
 			*/
 			Strip_Comments(buffer);
 			if (len == 0 || buffer[0] == ';' || buffer[0] == '=') continue;
 
 			/*
 			**	The line isn't an obvious comment. Make sure that there is the "=" character
 			**	at an appropriate spot.
 			*/
 			char * divider = strchr(buffer, '=');
 			if (!divider) continue;
 
 			/*
 			**	Split the line into entry and value sections. Be sure to catch the
 			**	"=foobar" and "foobar=" cases. These lines are ignored.
 			*/
 			*divider++ = '\0';
 			strtrim(buffer);
 			if (!strlen(buffer)) continue;
 
 			strtrim(divider);
 			if (!strlen(divider)) continue;
 
 			INIEntry * entryptr = new INIEntry(strdup(buffer), strdup(divider));
 			if (entryptr == NULL) {
 				delete secptr;
 				Clear();
 				return(false);
 			}
 
 			secptr->EntryIndex.Add_Index(entryptr->Index_ID(), entryptr);
 			secptr->EntryList.Add_Tail(entryptr);
 		}
 
 		/*
 		**	All the entries for this section have been parsed. If this section is blank, then
 		**	don't bother storing it.
 		*/
 		if (secptr->EntryList.Is_Empty()) {
 			delete secptr;
 		} else {
 			SectionIndex.Add_Index(secptr->Index_ID(), secptr);
 			SectionList.Add_Tail(secptr);
 		}
 	}
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Save -- Save the ini data to the file specified.                                  *
  *                                                                                             *
  *    Use this routine to save the ini data to the file specified. All existing data in the    *
  *    file, if it was present, is replaced.                                                    *
  *                                                                                             *
  * INPUT:   file  -- Reference to the file to write the INI data to.                           *
  *                                                                                             *
  * OUTPUT:  bool; Was the data written to the file?                                            *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Save(FileClass & file) const
 {
 	return(Save(FilePipe(file)));
 }
 
 
 /***********************************************************************************************
  * INIClass::Save -- Saves the INI data to a pipe stream.                                      *
  *                                                                                             *
  *    This routine will output the data of the INI file to a pipe stream.                      *
  *                                                                                             *
  * INPUT:   pipe  -- Reference to the pipe stream to pump the INI image to.                    *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes output to the pipe.                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Save(Pipe & pipe) const
 {
 	int total = 0;
 
 	INISection * secptr = SectionList.First();
 	while (secptr && secptr->Is_Valid()) {
 
 		/*
 		**	Output the section identifier.
 		*/
 		total += pipe.Put("[", 1);
 		total += pipe.Put(secptr->Section, strlen(secptr->Section));
 		total += pipe.Put("]", 1);
 		total += pipe.Put("\r\n", strlen("\r\n"));
 
 		/*
 		**	Output all the entries and values in this section.
 		*/
 		INIEntry * entryptr = secptr->EntryList.First();
 		while (entryptr && entryptr->Is_Valid()) {
 			total += pipe.Put(entryptr->Entry, strlen(entryptr->Entry));
 			total += pipe.Put("=", 1);
 			total += pipe.Put(entryptr->Value, strlen(entryptr->Value));
 			total += pipe.Put("\r\n", strlen("\r\n"));
 
 			entryptr = entryptr->Next();
 		}
 
 		/*
 		**	After the last entry in this section, output an extra
 		**	blank line for readability purposes.
 		*/
 		total += pipe.Put("\r\n", strlen("\r\n"));
 
 		secptr = secptr->Next();
 	}
 	total += pipe.End();
 
 	return(total);
 }
 
 
 /***********************************************************************************************
  * INIClass::Find_Section -- Find the specified section within the INI data.                   *
  *                                                                                             *
  *    This routine will scan through the INI data looking for the section specified. If the    *
  *    section could be found, then a pointer to the section control data is returned.          *
  *                                                                                             *
  * INPUT:   section  -- The name of the section to search for. Don't enclose the name in       *
  *                      brackets. Case is NOT sensitive in the search.                         *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the INI section control structure if the section was     *
  *          found. Otherwise, NULL is returned.                                                *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   11/02/1996 JLB : Uses index manager.                                                      *
  *=============================================================================================*/
 INIClass::INISection * INIClass::Find_Section(char const * section) const
 {
 	if (section != NULL) {
 
 		long crc = CRCEngine()(section, strlen(section));
 
 		if (SectionIndex.Is_Present(crc)) {
 			return(SectionIndex.Fetch_Index(crc));
 		}
 	}
 	return(NULL);
 }
 
 
 /***********************************************************************************************
  * INIClass::Section_Count -- Counts the number of sections in the INI data.                   *
  *                                                                                             *
  *    This routine will scan through all the sections in the INI data and return a count       *
  *    of the number it found.                                                                  *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of sections recorded in the INI data.                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   11/02/1996 JLB : Uses index manager.                                                      *
  *=============================================================================================*/
 int INIClass::Section_Count(void) const
 {
 	return(SectionIndex.Count());
 }
 
 
 /***********************************************************************************************
  * INIClass::Entry_Count -- Fetches the number of entries in a specified section.              *
  *                                                                                             *
  *    This routine will examine the section specified and return with the number of entries    *
  *    associated with it.                                                                      *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section that will be examined.                          *
  *                                                                                             *
  * OUTPUT:  Returns with the number entries in the specified section.                          *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   11/02/1996 JLB : Uses index manager.                                                      *
  *=============================================================================================*/
 int INIClass::Entry_Count(char const * section) const
 {
 	INISection * secptr = Find_Section(section);
 	if (secptr != NULL) {
 		return(secptr->EntryIndex.Count());
 	}
 	return(0);
 }
 
 
 /***********************************************************************************************
  * INIClass::Find_Entry -- Find specified entry within section.                                *
  *                                                                                             *
  *    This support routine will find the specified entry in the specified section. If found,   *
  *    a pointer to the entry control structure will be returned.                               *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section name to search under.                           *
  *                                                                                             *
  *          entry    -- Pointer to the entry name to search for.                               *
  *                                                                                             *
  * OUTPUT:  If the entry was found, then a pointer to the entry control structure will be      *
  *          returned. Otherwise, NULL will be returned.                                        *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 INIClass::INIEntry * INIClass::Find_Entry(char const * section, char const * entry) const
 {
 	INISection * secptr = Find_Section(section);
 	if (secptr != NULL) {
 		return(secptr->Find_Entry(entry));
 	}
 	return(NULL);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_Entry -- Get the entry identifier name given ordinal number and section name. *
  *                                                                                             *
  *    This will return the identifier name for the entry under the section specified. The      *
  *    ordinal number specified is used to determine which entry to retrieve. The entry         *
  *    identifier is the text that appears to the left of the "=" character.                    *
  *                                                                                             *
  * INPUT:   section  -- The section to use.                                                    *
  *                                                                                             *
  *          index    -- The ordinal number to use when fetching an entry name.                 *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the entry name.                                          *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 char const * INIClass::Get_Entry(char const * section, int index) const
 {
 	INISection * secptr = Find_Section(section);
 
 	if (secptr != NULL && index < secptr->EntryIndex.Count()) {
 		INIEntry * entryptr = secptr->EntryList.First();
 
 		while (entryptr != NULL && entryptr->Is_Valid()) {
 			if (index == 0) return(entryptr->Entry);
 			index--;
 			entryptr = entryptr->Next();
 		}
 	}
 	return(NULL);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_UUBlock -- Store a binary encoded data block into the INI database.           *
  *                                                                                             *
  *    Use this routine to store an arbitrary length binary block of data into the INI database.*
  *    This routine will covert the data into displayable form and then break it into lines     *
  *    that are stored in sequence to the section. A section used to store data in this         *
  *    fashion can not be used for any other entries.                                           *
  *                                                                                             *
  * INPUT:   section  -- The section identifier to place the data into.                         *
  *                                                                                             *
  *          block    -- Pointer to the block of binary data to store.                          *
  *                                                                                             *
  *          len      -- The length of the binary data.                                         *
  *                                                                                             *
  * OUTPUT:  bool; Was the data stored to the database?                                         *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_UUBlock(char const * section, void const * block, int len)
 {
 	if (section == NULL || block == NULL || len < 1) return(false);
 
 	Clear(section);
 
 	BufferStraw straw(block, len);
 	Base64Straw bstraw(Base64Straw::ENCODE);
 	bstraw.Get_From(straw);
 
 	int counter = 1;
 
 	for (;;) {
 		char buffer[71];
 		char sbuffer[32];
 
 		int length = bstraw.Get(buffer, sizeof(buffer)-1);
 		buffer[length] = '\0';
 		if (length == 0) break;
 
 		sprintf(sbuffer, "%d", counter);
 		Put_String(section, sbuffer, buffer);
 		counter++;
 	}
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_UUBlock -- Fetch an encoded block from the section specified.                 *
  *                                                                                             *
  *    This routine will take all the entries in the specified section and decompose them into  *
  *    a binary block of data that will be stored into the buffer specified. By using this      *
  *    routine [and the Put_UUBLock counterpart], arbitrary blocks of binary data may be        *
  *    stored in the INI file. A section processed by this routine can contain no other         *
  *    entries than those put there by a previous call to Put_UUBlock.                          *
  *                                                                                             *
  * INPUT:   section  -- The section name to process.                                           *
  *                                                                                             *
  *          block    -- Pointer to the buffer that will hold the retrieved data.               *
  *                                                                                             *
  *          len      -- The length of the buffer. The retrieved data will not fill past this   *
  *                      limit.                                                                 *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes decoded into the buffer specified.                *
  *                                                                                             *
  * WARNINGS:   If the number of bytes retrieved exactly matches the length of the buffer       *
  *             specified, then you might have a condition of buffer "overflow".                *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Get_UUBlock(char const * section, void * block, int len) const
 {
 	if (section == NULL) return(0);
 
 	Base64Pipe b64pipe(Base64Pipe::DECODE);
 	BufferPipe bpipe(block, len);
 
 	b64pipe.Put_To(&bpipe);
 
 	int total = 0;
 	int counter = Entry_Count(section);
 	for (int index = 0; index < counter; index++) {
 		char buffer[128];
 
 		int length = Get_String(section, Get_Entry(section, index), "=", buffer, sizeof(buffer));
 		int outcount = b64pipe.Put(buffer, length);
 		total += outcount;
 	}
 	total += b64pipe.End();
 	return(total);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_TextBlock -- Stores a block of text into an INI section.                      *
  *                                                                                             *
  *    This routine will take an arbitrarily long block of text and store it into the INI       *
  *    database. The text is broken up into lines and each line is then stored as a numbered    *
  *    entry in the specified section. A section used to store text in this way can not be used *
  *    to hold any other entries. The text is presumed to contain space characters scattered    *
  *    throughout it and that one space between words and sentences is natural.                 *
  *                                                                                             *
  * INPUT:   section  -- The section to place the text block into.                              *
  *                                                                                             *
  *          text     -- Pointer to a null terminated text string that holds the block of       *
  *                      text. The length can be arbitrary.                                     *
  *                                                                                             *
  * OUTPUT:  bool; Was the text block placed into the database?                                 *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_TextBlock(char const * section, char const * text)
 {
 	if (section == NULL) return(false);
 
 	Clear(section);
 
 	int index = 1;
 	while (text != NULL && *text != NULL) {
 
 		char buffer[128];
 
 		strncpy(buffer, text, 75);
 		buffer[75] = '\0';
 
 		char b[32];
 		sprintf(b, "%d", index);
 
 		/*
 		**	Scan backward looking for a good break position.
 		*/
 		int count = strlen(buffer);
 		if (count > 0) {
 			if (count >= 75) {
 				while (count) {
 					char c = buffer[count];
 
 					if (isspace(c)) break;
 					count--;
 				}
 
 				if (count == 0) {
 					break;
 				} else {
 					buffer[count] = '\0';
 				}
 			}
 
 			strtrim(buffer);
 			Put_String(section, b, buffer);
 			index++;
 			text = ((char  *)text) + count;
 		} else {
 			break;
 		}
 	}
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_TextBlock -- Fetch a block of normal text.                                    *
  *                                                                                             *
  *    This will take all entries in the specified section and format them into a block of      *
  *    normalized text. That is, text with single spaces between each concatenated line. All    *
  *    entries in the specified section are processed by this routine. Use Put_TextBlock to     *
  *    build the entries in the section.                                                        *
  *                                                                                             *
  * INPUT:   section  -- The section name to process.                                           *
  *                                                                                             *
  *          buffer   -- Pointer to the buffer that will hold the complete text.                *
  *                                                                                             *
  *          len      -- The length of the buffer specified. The text will, at most, fill this  *
  *                      buffer with the last character being forced to null.                   *
  *                                                                                             *
  * OUTPUT:  Returns with the number of characters placed into the buffer. The trailing null    *
  *          is not counted.                                                                    *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Get_TextBlock(char const * section, char * buffer, int len) const
 {
 	if (len <= 0) return(0);
 
 	buffer[0] = '\0';
 	if (len <= 1) return(0);
 
 	int elen = Entry_Count(section);
 	int total = 0;
 	for (int index = 0; index < elen; index++) {
 
 		/*
 		**	Add spacers between lines of fetched text.
 		*/
 		if (index > 0) {
 			*buffer++ = ' ';
 			len--;
 			total++;
 		}
 
 		Get_String(section, Get_Entry(section, index), "", buffer, len);
 
 		int partial = strlen(buffer);
 		total += partial;
 		buffer += partial;
 		len -= partial;
 		if (len <= 1) break;
 	}
 	return(total);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_Int -- Stores a signed integer into the INI data base.                        *
  *                                                                                             *
  *    Use this routine to store an integer value into the section and entry specified.         *
  *                                                                                             *
  * INPUT:   section  -- The identifier for the section that the entry will be placed in.       *
  *                                                                                             *
  *          entry    -- The entry identifier used for the integer number.                      *
  *                                                                                             *
  *          number   -- The integer number to store in the database.                           *
  *                                                                                             *
  *          format   -- The format to store the integer. The format is generally only a        *
  *                      cosmetic affect. The Get_Int operation will interpret the value the    *
  *                      same regardless of what format was used to store the integer.          *
  *                                                                                             *
  *                      0  : plain decimal digit                                               *
  *                      1  : hexadecimal digit (trailing "h")                                  *
  *                      2  : hexadecimal digit (leading "$")                                   *
  *                                                                                             *
  * OUTPUT:  bool; Was the number stored?                                                       *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *   07/10/1996 JLB : Handles multiple integer formats.                                        *
  *=============================================================================================*/
 bool INIClass::Put_Int(char const * section, char const * entry, int number, int format)
 {
 	char buffer[MAX_LINE_LENGTH];
 
 	switch (format) {
 		default:
 		case 0:
 			sprintf(buffer, "%d", number);
 			break;
 
 		case 1:
 			sprintf(buffer, "%Xh", number);
 			break;
 
 		case 2:
 			sprintf(buffer, "$%X", number);
 			break;
 	}
 	return(Put_String(section, entry, buffer));
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_Int -- Fetch an integer entry from the specified section.                     *
  *                                                                                             *
  *    This routine will fetch an integer value from the entry and section specified. If no     *
  *    entry could be found, then the default value will be returned instead.                   *
  *                                                                                             *
  * INPUT:   section  -- The section name to search under.                                      *
  *                                                                                             *
  *          entry    -- The entry name to search for.                                          *
  *                                                                                             *
  *          defvalue -- The default value to use if the specified entry could not be found.    *
  *                                                                                             *
  * OUTPUT:  Returns with the integer value specified in the INI database or else returns the   *
  *          default value.                                                                     *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   07/10/1996 JLB : Handles multiple integer formats.                                        *
  *=============================================================================================*/
 int INIClass::Get_Int(char const * section, char const * entry, int defvalue) const
 {
 	/*
 	**	Verify that the parameters are nominally correct.
 	*/
 	if (section == NULL || entry == NULL) return(defvalue);
 
 	INIEntry * entryptr = Find_Entry(section, entry);
 	if (entryptr && entryptr->Value != NULL) {
 
 		if (*entryptr->Value == '$') {
 			sscanf(entryptr->Value, "$%x", &defvalue);
 		} else {
 			if (tolower(entryptr->Value[strlen(entryptr->Value)-1]) == 'h') {
 				sscanf(entryptr->Value, "%xh", &defvalue);
 			} else {
 				defvalue = atoi(entryptr->Value);
 			}
 		}
 	}
 	return(defvalue);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_Hex -- Store an integer into the INI database, but use a hex format.          *
  *                                                                                             *
  *    This routine is similar to the Put_Int routine, but the number is stored as a hexadecimal*
  *    number.                                                                                  *
  *                                                                                             *
  * INPUT:   section  -- The identifier for the section that the entry will be placed in.       *
  *                                                                                             *
  *          entry    -- The entry identifier to tag to the integer number specified.           *
  *                                                                                             *
  *          number   -- The number to assign the the specified entry and placed in the         *
  *                      specified section.                                                     *
  *                                                                                             *
  * OUTPUT:  bool; Was the number placed into the INI database?                                 *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_Hex(char const * section, char const * entry, int number)
 {
 	char buffer[MAX_LINE_LENGTH];
 
 	sprintf(buffer, "%X", number);
 	return(Put_String(section, entry, buffer));
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_Hex -- Fetches integer [hex format] from the section and entry specified.     *
  *                                                                                             *
  *    This routine will search under the section specified, looking for a matching entry. The  *
  *    value is interpreted as a hexadecimal number and then returned. If no entry could be     *
  *    found, then the default value is returned instead.                                       *
  *                                                                                             *
  * INPUT:   section  -- The section identifier to search under.                                *
  *                                                                                             *
  *          entry    -- The entry identifier to search for.                                    *
  *                                                                                             *
  *          defvalue -- The default value to use if the entry could not be located.            *
  *                                                                                             *
  * OUTPUT:  Returns with the integer value from the specified section and entry. If no entry   *
  *          could be found, then the default value will be returned instead.                   *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Get_Hex(char const * section, char const * entry, int defvalue) const
 {
 	/*
 	**	Verify that the parameters are nominally correct.
 	*/
 	if (section == NULL || entry == NULL) return(defvalue);
 
 	INIEntry * entryptr = Find_Entry(section, entry);
 	if (entryptr && entryptr->Value != NULL) {
 		sscanf(entryptr->Value, "%x", &defvalue);
 	}
 	return(defvalue);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_String -- Output a string to the section and entry specified.                 *
  *                                                                                             *
  *    This routine will put an arbitrary string to the section and entry specified. Any        *
  *    previous matching entry will be replaced.                                                *
  *                                                                                             *
  * INPUT:   section  -- The section identifier to place the string under.                      *
  *                                                                                             *
  *          entry    -- The entry identifier to identify this string [placed under the section]*
  *                                                                                             *
  *          string   -- Pointer to the string to assign to this entry.                         *
  *                                                                                             *
  * OUTPUT:  bool; Was the entry assigned without error?                                        *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *   11/02/1996 JLB : Uses index handler.                                                      *
  *=============================================================================================*/
 bool INIClass::Put_String(char const * section, char const * entry, char const * string)
 {
 	if (section == NULL || entry == NULL) return(false);
 
 	INISection * secptr = Find_Section(section);
 
 	if (secptr == NULL) {
 		secptr = new INISection(strdup(section));
 		if (secptr == NULL) return(false);
 		SectionList.Add_Tail(secptr);
 		SectionIndex.Add_Index(secptr->Index_ID(), secptr);
 	}
 
 	/*
 	**	Remove the old entry if found.
 	*/
 	INIEntry * entryptr = secptr->Find_Entry(entry);
 	if (entryptr != NULL) {
 		secptr->EntryIndex.Remove_Index(entryptr->Index_ID());
 		delete entryptr;
 	}
 
 	/*
 	**	Create and add the new entry.
 	*/
 	if (string != NULL && strlen(string) > 0) {
 		entryptr = new INIEntry(strdup(entry), strdup(string));
 
 		if (entryptr == NULL) {
 			return(false);
 		}
 		secptr->EntryList.Add_Tail(entryptr);
 		secptr->EntryIndex.Add_Index(entryptr->Index_ID(), entryptr);
 	}
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_String -- Fetch the value of a particular entry in a specified section.       *
  *                                                                                             *
  *    This will retrieve the entire text to the right of the "=" character. The text is        *
  *    found by finding a matching entry in the section specified. If no matching entry could   *
  *    be found, then the default value will be stored in the output string buffer.             *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section name to search under.                           *
  *                                                                                             *
  *          entry    -- The entry identifier to search for.                                    *
  *                                                                                             *
  *          defvalue -- If no entry could be found, then this text will be returned.           *
  *                                                                                             *
  *          buffer   -- Output buffer to store the retrieved string into.                      *
  *                                                                                             *
  *          size     -- The size of the output buffer. The maximum string length that could    *
  *                      be retrieved will be one less than this length. This is due to the     *
  *                      forced trailing zero added to the end of the string.                   *
  *                                                                                             *
  * OUTPUT:  Returns with the length of the string retrieved.                                   *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int INIClass::Get_String(char const * section, char const * entry, char const * defvalue, char * buffer, int size) const
 {
 	/*
 	**	Verify that the parameters are nominally legal.
 	*/
 	if (section == NULL || entry == NULL) {
 		if (buffer != NULL && size > 0) {
 			buffer[0] = '\0';
 		}
 		return(0);
 	}
 
 	/*
 	**	Fetch the entry string if it is present. If not, then the normal default
 	**	value will be used as the entry value.
 	*/
 	INIEntry * entryptr = Find_Entry(section, entry);
 	if (entryptr) {
 		if (entryptr->Value) {
 			defvalue = entryptr->Value;
 		}
 	}
 
 	/*
 	**	Fill in the buffer with the entry value and return with the length of the string.
 	*/
 	if (buffer == NULL || !size) {
 		return(0);
 	} else if (defvalue == NULL) {
 		buffer[0] = '\0';
 		return(0);
 	} else if (buffer == defvalue) {
 		return(strlen(buffer));
 	} else {
 		strncpy(buffer, defvalue, size);
 		buffer[size-1] = '\0';
 		strtrim(buffer);
 		return(strlen(buffer));
 	}
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_Bool -- Store a boolean value into the INI database.                          *
  *                                                                                             *
  *    Use this routine to place a boolean value into the INI database. The boolean value will  *
  *    be stored as "yes" or "no".                                                              *
  *                                                                                             *
  * INPUT:   section  -- The section to place the entry and boolean value into.                 *
  *                                                                                             *
  *          entry    -- The entry identifier to tag to the boolean value.                      *
  *                                                                                             *
  *          value    -- The boolean value to place into the database.                          *
  *                                                                                             *
  * OUTPUT:  bool; Was the boolean value placed into the database?                              *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_Bool(char const * section, char const * entry, bool value)
 {
 	if (value) {
 		return(Put_String(section, entry, "yes"));
 	} else {
 		return(Put_String(section, entry, "no"));
 	}
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_Bool -- Fetch a boolean value for the section and entry specified.            *
  *                                                                                             *
  *    This routine will search under the section specified, looking for a matching entry. If   *
  *    one is found, the value is interpreted as a boolean value and then returned. In the case *
  *    of no matching entry, the default value will be returned instead. The boolean value      *
  *    is interpreted using the standard boolean conventions. e.g., "Yes", "Y", "1", "True",    *
  *    "T" are all consider to be a TRUE boolean value.                                         *
  *                                                                                             *
  * INPUT:   section  -- The section to search under.                                           *
  *                                                                                             *
  *          entry    -- The entry to search for.                                               *
  *                                                                                             *
  *          defvalue -- The default value to use if no matching entry could be located.        *
  *                                                                                             *
  * OUTPUT:  Returns with the boolean value of the specified section and entry. If no match     *
  *          then the default boolean value is returned.                                        *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Get_Bool(char const * section, char const * entry, bool defvalue) const
 {
 	/*
 	**	Verify that the parameters are nominally correct.
 	*/
 	if (section == NULL || entry == NULL) return(defvalue);
 
 	INIEntry * entryptr = Find_Entry(section, entry);
 	if (entryptr && entryptr->Value != NULL) {
 		switch (toupper(*entryptr->Value)) {
 			case 'Y':
 			case 'T':
 			case '1':
 				return(true);
 
 			case 'N':
 			case 'F':
 			case '0':
 				return(false);
 		}
 	}
 	return(defvalue);
 }
 
 
 /***********************************************************************************************
  * INIClass::INISection::Find_Entry -- Finds a specified entry and returns pointer to it.      *
  *                                                                                             *
  *    This routine scans the supplied entry for the section specified. This is used for        *
  *    internal database maintenance.                                                           *
  *                                                                                             *
  * INPUT:   entry -- The entry to scan for.                                                    *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the entry control structure if the entry was found.      *
  *          Otherwise it returns NULL.                                                         *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *   11/02/1996 JLB : Uses index handler.                                                      *
  *=============================================================================================*/
 INIClass::INIEntry * INIClass::INISection::Find_Entry(char const * entry) const
 {
 	if (entry != NULL) {
 		int crc = CRCEngine()(entry, strlen(entry));
 		if (EntryIndex.Is_Present(crc)) {
 			return(EntryIndex.Fetch_Index(crc));
 		}
 	}
 	return(NULL);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_PKey -- Stores the key to the INI database.                                   *
  *                                                                                             *
  *    The key stored to the database will have both the exponent and modulus portions saved.   *
  *    Since the fast key only requires the modulus, it is only necessary to save the slow      *
  *    key to the database. However, storing the slow key stores the information necessary to   *
  *    generate the fast and slow keys. Because public key encryption requires one key to be    *
  *    completely secure, only store the fast key in situations where the INI database will     *
  *    be made public.                                                                          *
  *                                                                                             *
  * INPUT:   key   -- The key to store the INI database.                                        *
  *                                                                                             *
  * OUTPUT:  bool; Was the key stored to the database?                                          *
  *                                                                                             *
  * WARNINGS:   Store the fast key for public INI database availability. Store the slow key if  *
  *             the INI database is secure.                                                     *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/08/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_PKey(PKey const & key)
 {
 	char buffer[512];
 
 	int len = key.Encode_Modulus(buffer);
 	Put_UUBlock("PublicKey", buffer, len);
 
 	len = key.Encode_Exponent(buffer);
 	Put_UUBlock("PrivateKey", buffer, len);
 	return(true);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_PKey -- Fetch a key from the ini database.                                    *
  *                                                                                             *
  *    This routine will fetch the key from the INI database. The key fetched is controlled by  *
  *    the parameter. There are two choices of key -- the fast or slow key.                     *
  *                                                                                             *
  * INPUT:   fast  -- Should the fast key be retrieved? The fast key has the advantage of       *
  *                   requiring only the modulus value.                                         *
  *                                                                                             *
  * OUTPUT:  Returns with the key retrieved.                                                    *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/08/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 PKey INIClass::Get_PKey(bool fast) const
 {
 	PKey key;
 	char buffer[512];
 
 	/*
 	**	When retrieving the fast key, the exponent is a known constant. Don't parse the
 	**	exponent from the database.
 	*/
 	if (fast) {
 		BigInt exp = PKey::Fast_Exponent();
 		exp.DEREncode((unsigned char *)buffer);
 		key.Decode_Exponent(buffer);
 	} else {
 		Get_UUBlock("PrivateKey", buffer, sizeof(buffer));
 		key.Decode_Exponent(buffer);
 	}
 
 	Get_UUBlock("PublicKey", buffer, sizeof(buffer));
 	key.Decode_Modulus(buffer);
 
 	return(key);
 }
 
 
 /***********************************************************************************************
  * INIClass::Get_Fixed -- Fetch a fixed point number from the section & entry.                 *
  *                                                                                             *
  *    This routine will examine the section and entry specified and interpret the value        *
  *    as if it were a fixed point number. The format of the fixed point number can be          *
  *    percentage (e.g. 100%) or a floating point number (e.g., 1.7).                           *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section identifier to look under.                       *
  *                                                                                             *
  *          entry    -- Pointer to the entry identifier to examine.                            *
  *                                                                                             *
  *          defvalue -- If the section and entry could not be found, then this value will      *
  *                      be returned.                                                           *
  *                                                                                             *
  * OUTPUT:  Returns with the fixed point number that occurs at the section and entry           *
  *          specified. If it could not be found, then the default value is returned.           *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 fixed INIClass::Get_Fixed(char const * section, char const * entry, fixed defvalue) const
 {
 	char buffer[128];
 	fixed retval = defvalue;
 
 	if (Get_String(section, entry, "", buffer, sizeof(buffer))) {
 		retval = fixed(buffer);
 	}
 	return(retval);
 }
 
 
 /***********************************************************************************************
  * INIClass::Put_Fixed -- Store a fixed point number to the INI database.                      *
  *                                                                                             *
  *    Use this routine to output a fixed point number to the database. The entry will be       *
  *    placed in the section and entry specified. If there was any existing entry, it will      *
  *    be replaced.                                                                             *
  *                                                                                             *
  * INPUT:   section  -- Pointer to the section identifier.                                     *
  *                                                                                             *
  *          entry    -- Pointer to the entry identifier to use for this value.                 *
  *                                                                                             *
  *          value    -- The value to store in the database.                                    *
  *                                                                                             *
  * OUTPUT:  bool; Was the data stored?                                                         *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool INIClass::Put_Fixed(char const * section, char const * entry, fixed value)
 {
 	return(Put_String(section, entry, value.As_ASCII()));
 }
 
 
 /***********************************************************************************************
  * INIClass::Strip_Comments -- Strips comments of the specified text line.                     *
  *                                                                                             *
  *    This routine will scan the string (text line) supplied and if any comment portions are   *
  *    found, they will be trimmed off. Leading and trailing blanks are also removed.           *
  *                                                                                             *
  * INPUT:   buffer   -- Pointer to the null terminate string to be processed.                  *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 void INIClass::Strip_Comments(char * buffer)
 {
 	if (buffer != NULL) {
 		char * comment = strchr(buffer, ';');
 		if (comment) {
 			*comment = '\0';
 			strtrim(buffer);
 		}
 	}
 }