cconfig.cpp

能够通过输入IP地址扫描端口

/*
	CConfig.cpp
	Classe base per la gestione della configurazione tramite il registro (SDK).
	Luca Piergentili, 14/07/99
	[e-mail]
	http://www.geocities.com/lpiergentili/
*/
#include "env.h"
#include "pragma.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "strcpyn.h"
#include "window.h"
#include "CConfig.h"
#include "CNodeList.h"
#include "CRegKey.h"

/*
	CConfig()
*/
CConfig::CConfig()
{
	m_Config = new CConfigList();
	m_Registry = new CRegKey();
	SetModified(FALSE);
}

/*
	~CConfig()
*/
CConfig::~CConfig()
{
	if(m_Config)
		delete m_Config,m_Config = NULL;
	if(m_Registry)
		delete m_Registry,m_Registry = NULL;
}

/*
	Insert()

	Inserisce nella lista il valore (stringa) per la sezione/chiave specificati.

	LPCSTR	lpcszSectionName	nome sezione
	LPCSTR	lpcszKeyName		nome chiave
	LPCSTR	lpcszKeyValue		valore chiave (stringa)
*/
BOOL CConfig::Insert(LPCSTR lpcszSectionName,LPCSTR lpcszKeyName,LPCSTR lpcszKeyValue)
{
	BOOL bInserted = FALSE;

	if(m_Config)
	{
		CONFIG* c = new CONFIG();
		if(c)
		{
			c->Init(lpcszSectionName,lpcszKeyName,lpcszKeyValue);
			m_Config->Add(c);
			SetModified(TRUE);
			bInserted = TRUE;
		}
	}

	return(bInserted);
}

/*
	Insert()

	Inserisce nella lista il valore (numerico) per la sezione/chiave specificati.

	LPCSTR	lpcszSectionName	nome sezione
	LPCSTR	lpcszKeyName		nome chiave
	LPCSTR	lpcszKeyValue		valore chiave (numero)
*/
BOOL CConfig::Insert(LPCSTR lpcszSectionName,LPCSTR lpcszKeyName,DWORD dwKeyValue)
{
	BOOL bInserted = FALSE;

	if(m_Config)
	{
		CONFIG* c = new CONFIG();
		if(c)
		{
			c->Init(lpcszSectionName,lpcszKeyName,dwKeyValue);
			m_Config->Add(c);
			SetModified(TRUE);
			bInserted = TRUE;
		}
	}

	return(bInserted);
}

/*
	Delete()

	Elimina della lista il valore relativo alla coppia sezione/chiave.
	Non elimina fisicamente l'elemento ma si limita a marcarlo in modo tale che quando la lista
	viene salvata sul registro si possano individuare le chiavi da eliminare fisicamente.

	LPCSTR	lpcszSectionName	nome sezione
	LPCSTR	lpcszKeyName		nome chiave
*/
BOOL CConfig::Delete(LPCSTR lpcszSectionName,LPCSTR lpcszKeyName)
{
	BOOL bDeleted = FALSE;
	CONFIG* c;
	ITERATOR iter;

	// scorre la lista cercando l'entrata relativa alla coppia sezione/chiave
	if((iter = m_Config->First())!=(ITERATOR)NULL)
		while(iter!=(ITERATOR)NULL)
		{
			c = (CONFIG*)iter->data;
			if(c)
				if(strcmp(lpcszSectionName,c->GetSection())==0)
				{
					if(strcmp(lpcszKeyName,c->GetName())==0)
					{
						// marca l'elemento per l'eliminazione
						c->SetType(NULL_TYPE);
						SetModified(TRUE);
						bDeleted = TRUE;
						break;
					}
				}

			iter = m_Config->Next(iter);
		}

	return(bDeleted);
}

/*
	DeleteAll()

	Elimina della lista tutti i valori, rimuovendoli anche dal registro.
*/
BOOL CConfig::DeleteAll(LPCSTR lpcszRootKey)
{
	BOOL bDeleted = TRUE;
	CONFIG* c;
	ITERATOR iter;
	char szKey[REGKEY_MAX_KEY_VALUE+1];

	if(m_Registry)
	{
		m_Registry->Attach(HKEY_LOCAL_MACHINE);

		if((iter = m_Config->First())!=(ITERATOR)NULL)
			while(iter!=(ITERATOR)NULL)
			{
				c = (CONFIG*)iter->data;
				if(c)
				{
					_snprintf(szKey,sizeof(szKey)-1,DEFAULT_REG_KEY"\\%s\\%s",lpcszRootKey,c->GetSection());
					if(m_Registry->Open(HKEY_LOCAL_MACHINE,szKey)==ERROR_SUCCESS)
					{
						m_Registry->DeleteValue(c->GetName());
						m_Registry->Close();
					}
				}

				iter = m_Config->Next(iter);
			}

		m_Registry->Detach();
	
		SetModified(TRUE);
	}

	m_Config->DeleteAll();

	return(bDeleted);
}

/*
	ReloadString()

	Ricarica dal registro il valore stringa associato alla chiave, aggiornando l'elemento
	corrispondente della lista.
*/
LPCSTR CConfig::ReloadString(LPCSTR lpcszRootKey,LPCSTR section,LPCSTR name,LPCSTR defaultvalue/*=NULL*/)
{
	char key[_MAX_PATH+1];
	static char value[_MAX_PATH+1];
	LONG reg;

	memset(key,'\0',sizeof(key));
	_snprintf(key,sizeof(key)-1,"%s\\%s",lpcszRootKey,section);
	memset(value,'\0',sizeof(value));

	m_Registry->Attach(HKEY_LOCAL_MACHINE);

	if((reg = m_Registry->Open(HKEY_LOCAL_MACHINE,key))==ERROR_SUCCESS)
	{
		memset(value,'\0',sizeof(value));
		DWORD valuesize = sizeof(value);
		if(m_Registry->QueryValue(value,name,&valuesize)!=ERROR_SUCCESS)
		{
			if(defaultvalue)
				strcpyn(value,defaultvalue,sizeof(value));
			else
				memset(value,'\0',sizeof(value));
			m_Registry->SetValue(value,name);
		}

		strcpyn(value,(char*)UpdateString(section,name,value),sizeof(value));
		
		m_Registry->Close();
	}

	m_Registry->Detach();

	return(value);
}

/*
	ReloadNumber()

	Ricarica dal registro il valore numerico associato alla chiave, aggiornando l'elemento
	corrispondente della lista.
*/
DWORD CConfig::ReloadNumber(LPCSTR lpcszRootKey,LPCSTR section,LPCSTR name,DWORD defaultvalue/*=0L*/)
{
	char key[_MAX_PATH+1];
	DWORD value = 0;
	LONG reg;

	memset(key,'\0',sizeof(key));
	_snprintf(key,sizeof(key)-1,"%s\\%s",lpcszRootKey,section);

	m_Registry->Attach(HKEY_LOCAL_MACHINE);

	if((reg = CConfig::m_Registry->Open(HKEY_LOCAL_MACHINE,key))==ERROR_SUCCESS)
	{
		if(m_Registry->QueryValue(value,name)!=ERROR_SUCCESS)
		{
			value = defaultvalue;
			m_Registry->SetValue(value,name);
		}

		value = UpdateNumber(section,name,value);

		m_Registry->Close();
	}

	m_Registry->Detach();

	return(value);
}

/*
	String()

	Restituisce o aggiorna il valore (stringa) associato alla sezione/chiave a seconda del parametro
	associato al valore (NULL/-1 recupera, in caso contrario aggiorna).

	LPCSTR	lpcszSectionName	nome sezione
	LPCSTR	lpcszKeyName		nome chiave
	LPCSTR	lpcszKeyValue		valore chiave (stringa)
*/
LPCSTR CConfig::String(LPCSTR lpcszSectionName,LPCSTR lpcszKeyName,LPCSTR lpcszKeyValue/*=NULL*/)
{
	static char* p;
	CONFIG* c;
	ITERATOR iter;

	p = "";

	// scorre la lista cercando l'entrata relativa alla coppia sezione/chiave
	if((iter = m_Config->First())!=(ITERATOR)NULL)
		while(iter!=(ITERATOR)NULL)
		{
			c = (CONFIG*)iter->data;
			if(c)
				if(strcmp(lpcszSectionName,c->GetSection())==0)
				{
					if(strcmp(lpcszKeyName,c->GetName())==0)
					{
						// salta i valori marcati per l'eliminazione (NULL_TYPE)
						if(c->GetType()!=NULL_TYPE)
						{
							if(lpcszKeyValue!=NULL)
							{
								// aggiorna il valore
								c->SetValue(lpcszKeyValue);
								p = (char*)c->GetValue(p);
								break;
							}
							else
							{
								// ricava il valore
								p = (char*)c->GetValue(p);
								if(!*p)
									p = "";
								break;
							}
						}
					}
				}

			iter = m_Config->Next(iter);
		}

	return(p);
}

/*
	Number()

	Restituisce o aggiorna il valore (numerico) associato alla sezione/nome a seconda del parametro
	associato al valore (NULL/-1 recupera, in caso contrario aggiorna).

	LPCSTR	lpcszSectionName	nome sezione
	LPCSTR	lpcszKeyName		nome chiave
	LPCSTR	lpcszKeyValue		valore chiave (numero)
*/
DWORD CConfig::Number(LPCSTR lpcszSectionName,LPCSTR lpcszKeyName,DWORD dwKeyValue/*=(DWORD)-1L*/)
{
	DWORD l = (DWORD)-1L;
	CONFIG* c;
	ITERATOR iter;

	// scorre la lista cercando l'entrata relativa alla coppia sezione/chiave
	if((iter = m_Config->First())!=(ITERATOR)NULL)
		while(iter!=(ITERATOR)NULL)
		{
			c = (CONFIG*)iter->data;
			if(c)
				if(strcmp(lpcszSectionName,c->GetSection())==0)
				{
					if(strcmp(lpcszKeyName,c->GetName())==0)
					{
						// salta i valori marcati per l'eliminazione (NULL_TYPE)
						if(c->GetType()!=NULL_TYPE)
						{
							if(dwKeyValue!=(DWORD)-1L)
							{
								// aggiorna il valore
								c->SetValue(dwKeyValue);
								l = c->GetValue(l);
								break;
							}
							else
							{
								// ricava il valore
								l = c->GetValue(l);
								break;
							}
						}
					}
				}

			iter = m_Config->Next(iter);
		}

	return(l);
}

/*
	Save()

	Salva nel registro i valori presenti nella lista.

	LPCSTR	lpcszRootKey	nome della chiave base
*/
void CConfig::Save(LPCSTR lpcszRootKey)
{
	CONFIG* c;
	ITERATOR iter;
	LONG lRet;
	char szKey[REGKEY_MAX_KEY_VALUE+1];
	memset(szKey,'\0',sizeof(szKey));

	if(m_Registry)
	{
		m_Registry->Attach(HKEY_LOCAL_MACHINE);

		// elimina (dalla lista e dal registro) le chiavi marcate per la cancellazione
		if((iter = m_Config->First())!=(ITERATOR)NULL)
			while(iter!=(ITERATOR)NULL)
			{
				c = (CONFIG*)iter->data;
				if(c)
					// chiave da eliminare
					if(c->GetType()==NULL_TYPE)
					{
						// elimina la chiave dal registro
						_snprintf(szKey,sizeof(szKey)-1,DEFAULT_REG_KEY"\\%s\\%s",lpcszRootKey,c->GetSection());
						if(m_Registry->Open(HKEY_LOCAL_MACHINE,szKey)==ERROR_SUCCESS)
						{
							m_Registry->DeleteValue(c->GetName());
							m_Registry->Close();
						}

						// elimina la chiave dalla lista
						m_Config->Delete(iter);
					}

				iter = m_Config->Next(iter);
			}

		// salva nel registro le chiavi presenti nella lista
		if((iter = m_Config->First())!=(ITERATOR)NULL)
			while(iter!=(ITERATOR)NULL)
			{
				c = (CONFIG*)iter->data;
				if(c)
					// non inserisce nel registro le chiavi eliminate
					if(c->GetType()!=NULL_TYPE)
					{
						_snprintf(szKey,sizeof(szKey)-1,DEFAULT_REG_KEY"\\%s\\%s",lpcszRootKey,c->GetSection());

						if((lRet = m_Registry->Open(HKEY_LOCAL_MACHINE,szKey))!=ERROR_SUCCESS)
							lRet = m_Registry->Create(HKEY_LOCAL_MACHINE,szKey);
						if(lRet==ERROR_SUCCESS)
						{
							if(c->GetType()==LPSTR_TYPE)
								m_Registry->SetValue(c->GetValue((LPCSTR)NULL),c->GetName());
							else if(c->GetType()==DWORD_TYPE)
								m_Registry->SetValue(c->GetValue((DWORD)0L),c->GetName());
							
							m_Registry->Close();
						}
					}

				iter = m_Config->Next(iter);
			}

		m_Registry->Detach();
	
		SetModified(FALSE);
	}
}

/*
	SaveKey()

	Salva nel registro il valori della chiave presente nella lista.

	LPCSTR	lpcszRootKey		nome della chiave base
	LPCSTR	lpcszSectionKey	nome della sezione
	LPCSTR	lpcszNameKey		nome della chiave
*/
void CConfig::SaveKey(LPCSTR lpcszRootKey,LPCSTR lpcszSectionKey,LPCSTR lpcszNameKey)
{
	CONFIG* c;
	ITERATOR iter;
	LONG lRet;