Renegade/Code/wwlib/ffactory.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program 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.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*********************************************************************************************** 
 ***              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                                            * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/wwlib/ffactory.cpp                           $* 
 *                                                                                             * 
 *                      $Author:: Jani_p                                                      $*
 *                                                                                             * 
 *                     $Modtime:: 8/24/01 11:50a                                              $*
 *                                                                                             * 
 *                    $Revision:: 17                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------* 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include	"ffactory.h"
#include	"rawfile.h"
#include "bufffile.h"
#include "realcrc.h"
#include	<stdio.h>
#include <stdlib.h>
#include	<assert.h>
#include <string.h>

/*
** Statics
** NOTE: If _TheFileFactory is ever changed to point to an object of a different class which does
** not derive from SimpleFileFactoryClass, _TheSimpleFileFactory should be set to NULL.
*/
SimpleFileFactoryClass		_DefaultFileFactory;
FileFactoryClass *			_TheFileFactory = &_DefaultFileFactory;
SimpleFileFactoryClass *	_TheSimpleFileFactory = &_DefaultFileFactory;

SimpleFileFactoryClass		_DefaultWritingFileFactory;
FileFactoryClass *			_TheWritingFileFactory = &_DefaultWritingFileFactory;

/*
**
*/
file_auto_ptr::file_auto_ptr(FileFactoryClass *fac, const char *filename) :
	_Ptr(NULL), _Fac(fac)
{
	assert(_Fac);
	_Ptr=_Fac->Get_File(filename);
	if ( _Ptr == NULL ) {
		_Ptr = new BufferedFileClass();
	}
}

file_auto_ptr::~file_auto_ptr()
{
	_Fac->Return_File(_Ptr);
}



/*
** RawFileFactoryClass implementation
*/
FileClass * RawFileFactoryClass::Get_File( char const *filename )
{
	return new RawFileClass( filename );
}

void RawFileFactoryClass::Return_File( FileClass *file )
{
	delete file;
}

/*
** SimpleFileFactoryClass implementation
*/

SimpleFileFactoryClass::SimpleFileFactoryClass( void ) :
	IsStripPath( false ),
	Mutex( )
{
}


void SimpleFileFactoryClass::Get_Sub_Directory( StringClass& new_dir ) const
{
	// BEGIN SERIALIZATION

	// We cannot return a const char * here because the StringClass
	// may reallocate its buffer during a call to Set_Sub_Directory.
	// I opted to return a StringClass instead of a reference to 
	// StringClass because it seems like that would behave more
	// reasonably. (no sudden changes from or to empty string in
	// the middle of a calling function.) (DRM, 04/19/01)

	// Jani: Returning a StringClass object causes a memory allocation
	// and release so it is better to take a reference to the
	// destination StringClass object and modify that.

	CriticalSectionClass::LockClass lock(Mutex);
	new_dir=SubDirectory;
	// END SERIALIZATION
}


void SimpleFileFactoryClass::Set_Sub_Directory( const char * sub_directory )
{
	// BEGIN SERIALIZATION

	// StringClass makes no guarantees on the atomicity of assignment.
	// Just to be safe, we lock before executing the assignment code.
	// (DRM, 04/19/01)

	CriticalSectionClass::LockClass lock(Mutex);
	SubDirectory = sub_directory;
	// END SERIALIZATION
}


void SimpleFileFactoryClass::Prepend_Sub_Directory( const char * sub_directory )
{
	int sub_len = strlen(sub_directory);
	// Overflow prevention
	if (sub_len > 1021) {
		WWASSERT(0);
		return;
	} else if (sub_len < 1) {
		return;
	}

	// Ensure sub_directory ends with a slash, and append a semicolon
	char temp_sub_dir[1024];
	strcpy(temp_sub_dir, sub_directory);
	if (temp_sub_dir[sub_len - 1] != '\\') {
		temp_sub_dir[sub_len] = '\\';
		temp_sub_dir[sub_len + 1] = 0;
		sub_len++;
	}
	temp_sub_dir[sub_len] = ';';
	temp_sub_dir[sub_len + 1] = 0;

	// BEGIN SERIALIZATION

	// StringClass makes no guarantees on the atomicity of concatenation.
	// Just to be safe, we lock before executing the concatenation code.
	// (NH, 04/23/01)

	CriticalSectionClass::LockClass lock(Mutex);
	SubDirectory = temp_sub_dir + SubDirectory;

	// END SERIALIZATION
}


void SimpleFileFactoryClass::Append_Sub_Directory( const char * sub_directory )
{
	int sub_len = strlen(sub_directory);
	// Overflow prevention
	if (sub_len > 1022) {
		WWASSERT(0);
		return;
	} else if (sub_len < 1) {
		return;
	}

	// Ensure sub_directory ends with a slash
	char temp_sub_dir[1024];
	strcpy(temp_sub_dir, sub_directory);
	if (temp_sub_dir[sub_len - 1] != '\\') {
		temp_sub_dir[sub_len] = '\\';
		temp_sub_dir[sub_len + 1] = 0;
		sub_len++;
	}

	// BEGIN SERIALIZATION

	// We are doing various dependent operations on SubDirectory.
	// Just to be safe, we lock before this section.
	// (NH, 04/23/01)

	CriticalSectionClass::LockClass lock(Mutex);

	// Ensure a trailing semicolon is present, unless the directory list is empty
	int len = SubDirectory.Get_Length();
	if (len && SubDirectory[len - 1] != ';') {
		SubDirectory += ';';
	}

	SubDirectory += temp_sub_dir;
	// END SERIALIZATION
}


/*
**	Is_Full_Path
*/
static bool
Is_Full_Path (const char *path)
{
	bool retval = false;

	if (path != NULL && path[0] != 0) {
		
		// Check for drive designation
		retval = bool(path[1] == ':');

		// Check for network path
		retval |= bool((path[0] == '\\') && (path[1] == '\\'));
	}

	return retval;
}

/*
**
*/
FileClass * SimpleFileFactoryClass::Get_File( char const *filename )
{
	// strip off the path (if needed). Note that if path stripping is off, and the requested file
	// has a path in its name, and the current subdirectory is not empty, the paths will just be
	// concatenated which may not produce reasonable results.
	StringClass stripped_name(true);
	if (IsStripPath) {
		const char * ptr = ::strrchr( filename, '\\' );

		if (ptr != 0) {
			ptr++;
			stripped_name = ptr;
		} else {
			stripped_name = filename;
		}
	} else {
		stripped_name = filename;
	}

	RawFileClass *file = new BufferedFileClass();// new RawWritingFileClass();
	assert( file );

	//
	//	Do we need to find the path for this file request?
	//
	StringClass new_name(stripped_name,true);
	if (Is_Full_Path ( new_name ) == false) {

		// BEGIN SERIALIZATION

		// We need to lock here because we are using the contents of SubDirectory
		// in two places. I'd rather be overly cautious about the implementation
		// of StringClass and wrap all calls to it. We can optimize later if this
		// proves too slow. (DRM, 04/19/01)

		CriticalSectionClass::LockClass lock(Mutex);

		if (!SubDirectory.Is_Empty()) {

			//
			// SubDirectory may contain a semicolon seperated search path...
			// If the file doesn't exist, we'll set the path to the last dir in
			// the search path.  Therefore newly created files will always go in the
			// last dir in the search path.
			//
			StringClass subdir(SubDirectory,true);

			if (strchr(subdir,';'))
			{
				char *tokstart=subdir.Peek_Buffer();
				const char *tok;
				while((tok=strtok(tokstart, ";")) != NULL) {
					tokstart=NULL;
					new_name.Format("%s%s",tok,stripped_name.Peek_Buffer());
					file->Set_Name( new_name );	// Call Set_Name to force an allocated name
					if (file->Open()) {
						file->Close();
						break;
					}
				}
			} else {
				new_name.Format("%s%s",SubDirectory,stripped_name);
			}
		}

		// END SERIALIZATION
	}
	
	file->Set_Name( new_name );	// Call Set_Name to force an allocated name
	return file;
}

void SimpleFileFactoryClass::Return_File( FileClass *file )
{
	delete file;
}