warifmimetypes.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarIfMimeTypes.h"   // class implemented
#include "WarAutoLock.h"

#ifndef WAR_LOG_H
#   include "WarLog.h"
#endif

using namespace std;

#define AUTO_LOCK WarAutoLock my_lock((WarCriticalSection&)mLock);

/////////////////////////////// PUBLIC ///////////////////////////////////////

//============================= LIFECYCLE ====================================

WarIfMimeTypes::WarIfMimeTypes(WarIfSite& SiteRef)
: mIsInitialized(false)
{
	// Open the registry key
    mRegKey.Open(SiteRef.GetRegKey().GetRef(WAR_WINNT_REG_MIME_TYPES));

	// Open the regkey for defined types
	mRegDefined.Open(mRegKey.GetRef(WAR_WINNT_REG_DEFINED));

}// WarIfMimeTypes


WarIfMimeTypes::~WarIfMimeTypes()
{
}// ~WarIfMimeTypes


//============================= OPERATORS ====================================
//============================= OPERATIONS ===================================

void WarIfMimeTypes::SetFilePath(const war_ccsysstr_t filePath) 
throw(WarException)
{
	mRegKey.SetValue(WAR_WINNT_REG_FILENAME, filePath);
}

void WarIfMimeTypes::SetOsOption(bool doUseLocalOs) 
throw(WarException)
{
	mRegKey.SetValue(WAR_WINNT_USE_LOCAL_OS, doUseLocalOs);
}

void WarIfMimeTypes::SetMimeTypes(const mime_map_t& mimeMap) 
throw(WarException)
{
	// Delete the old types
	mRegDefined.DeleteAllValues();

	// Set new types
	for(mime_map_t::const_iterator P = mimeMap.begin()
		; P != mimeMap.end()
		; ++P)
	{
		war_registrypath_t key = P->first;
		WarCollector<war_fsysch_t> value = P->second;
		mRegDefined.SetValue(key.GetPath(), value.GetValue());
	}
}

bool WarIfMimeTypes::ResolvMimeType(const filename_t& extName,
									mime_type_t& dstMimeType) const
{
	AUTO_LOCK;
	
	if (!mIsInitialized)
	{
		((WarIfMimeTypes *)this)->LoadMimeDefinitions();
		((WarIfMimeTypes *)this)->mIsInitialized = true;
	}
	
	mime_map_t::const_iterator P = mMimeMap.find(extName);
	
	if (P != mMimeMap.end())
	{
		dstMimeType = P->second;
		return true;
	}

#ifdef WIN32
	{
		if (mRegHkeyRoot.IsOpen())
		{
			// Lookup the mime-type in the registry. If it is found, we
			// add it to the internal map to save another lookup in the 
			// registry the nest time someone asks for it.

			WarWin32Registry key;
			try
			{
				war_registrypath_t key_name;
				key_name << "." << extName;
				key.Open(mRegHkeyRoot.GetRef(key_name.GetPath()));
				war_regstr_t mime_type = key.GetStrValue(_T("Content Type"));
				
				WarCollector<char> my_mime_type = mime_type;
				
				((WarIfMimeTypes *)this)->mMimeMap.insert(mime_map_t::value_type(
					extName, my_mime_type.GetValue()));

				dstMimeType = my_mime_type.GetValue();
				return true;
			}
			catch(WarException)
			{
			}
		}
	}
#endif
	
	return false;
}


//============================= CALLBACK   ===================================
//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================

WarIfMimeTypes::filename_t 
WarIfMimeTypes::GetFilePath() throw(WarException)
{
	return mRegKey.GetStrValue(WAR_WINNT_REG_FILENAME);
}

bool WarIfMimeTypes::GetOsOption() throw(WarException)
{
	return mRegKey.GetIntValue(WAR_WINNT_USE_LOCAL_OS);
}

void WarIfMimeTypes::GetMimeTypes(mime_map_t& mimeMap) 
throw(WarException)
{
	WarWin32Registry::keyname_list_t values;
	mRegDefined.EnumValue(values);

	for(WarWin32Registry::keyname_list_t::const_iterator 
		P = values.begin()
		; P != values.end()
		; ++P)
	{
		WarCollector<char> mime_type = 
			mRegDefined.GetStrValue(P->c_str());
		
		mimeMap.insert(mime_map_t::value_type(
			*P, mime_type.GetValue()));
	}
}



/////////////////////////////// PROTECTED  ///////////////////////////////////

void WarIfMimeTypes::LoadMimeDefinitions()
{
	
	// We assume that the object is locked!

	// Load from site definition
	GetMimeTypes(mMimeMap);
	
	// Load from file
	try
	{
		struct file_t
		{
		public:
			file_t()
			{
				mFp = NULL;
			}

			~file_t()
			{
				if (NULL != mFp)
				{
					fclose(mFp);
					mFp = NULL;
				}
			}
			
			FILE *mFp;
		} my_fp;
		
		filename_t mime_file_name = GetFilePath();
		if (!mime_file_name.empty())
		{
			
			if ((my_fp.mFp = _tfopen(mime_file_name.c_str(), _T("r"))) == NULL)
			{
				WarLog warn_log(WARLOG_WARNINGS, "WarIfMimeTypes::LoadMimeDefinitions()");
				
				warn_log << "Failed to open file \"" 
					<< mime_file_name
					<< "\". Mime-definitions from that file will not be available."
					<< WarSystemError()
					<< war_endl;
			}
			else
			{
				char buf[1024* 8];
				char *p;
				while(( p = fgets(buf, sizeof(buf), my_fp.mFp)) != NULL)
				{
					while(isspace(*p))
						++p;
					if ('#' == *p)
						continue; // Comment
					if (!*p)
						continue; // Empty line


					// Application-tag
					const char *mime_type = p, *ext = NULL;

					while(*p && !isspace(*p))
						++p;
					if (isspace(*p))
						*p++ = 0;
					while(isspace(*p))
						++p;
					
					// Extension (can be more than one!)
					while(*p)
					{
						while(isspace(*p))
							++p;
						ext = p;
						
						while(!isspace(*p))
							++p;
						if (isspace(*p))
							*p++ = 0;
						
						if (*mime_type && ext && *ext)
						{
							WarCollector<war_sysch_t> my_mime_ext = ext;
							WarCollector<char> my_mime_type = mime_type;
							
							mMimeMap.insert(mime_map_t::value_type(
								my_mime_ext.GetValue(), 
								my_mime_type.GetValue()));
							
						}
					}
					
				}
			}
		}
	}
	catch(WarException)
	{
	}

	if (GetOsOption())
	{
#ifdef WIN32
		
		try
		{
			mRegHkeyRoot.Open(HKEY_CLASSES_ROOT, 
				war_registrypath_t(_T("\\")), 
				KEY_READ);
		}
		catch(WarException& ex)
		{
			WarLog warn_log(WARLOG_WARNINGS, "WarIfMimeTypes::LoadMimeDefinitions()");
				
			warn_log << "Failed to open HKEY_CLASSES_ROOT in the registry. " 
					<< "Mime-definitions from Windows will not be available."
					<< ex
					<< war_endl;
		}

#endif // WIN32
	}
}

/////////////////////////////// PRIVATE    ///////////////////////////////////