416 lines
7.0 KiB
C++
416 lines
7.0 KiB
C++
#include <cassert>
|
|
#include <cstdarg>
|
|
#include <string>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "cvariables.h"
|
|
#include "safestring.h"
|
|
|
|
CVariables::CVariables( )
|
|
{
|
|
var_top = NULL;
|
|
};
|
|
|
|
|
|
void CVariables::Cleanup()
|
|
{
|
|
L_Variables * v, *_v;
|
|
|
|
v = var_top;
|
|
|
|
while (v)
|
|
{
|
|
_v = v->next;
|
|
|
|
free( v->value );
|
|
delete v;
|
|
|
|
v = _v;
|
|
}
|
|
|
|
var_top = NULL; // Used when the desctructor is called explicitly to cleanup
|
|
}
|
|
|
|
CVariables::~CVariables()
|
|
{
|
|
// LOG( "~CVariables()", LOG_MAX );
|
|
Cleanup();
|
|
// LOG( "/~CVariables()", LOG_MAX );
|
|
}
|
|
|
|
L_Variables * CVariables::FindVariable( const char * var, bool create/*=false*/ )
|
|
{
|
|
L_Variables * v;
|
|
|
|
char _var[MAX_CGI_VAR_LEN+1];
|
|
|
|
tolower( var, _var, sizeof(_var) );
|
|
|
|
if (!var_top && !create)
|
|
return NULL;
|
|
|
|
if (!var_top)
|
|
{
|
|
v = var_top = new L_Variables;
|
|
}
|
|
else
|
|
{ // Search to see if such variable already exists
|
|
v = var_top;
|
|
do {
|
|
if ( strcmp( v->name, _var )==0 )
|
|
{
|
|
return v;
|
|
}
|
|
if ( v->next)
|
|
v = v->next;
|
|
else
|
|
break;
|
|
} while ( 1 );
|
|
|
|
// no variable found
|
|
|
|
if ( create )
|
|
{
|
|
v->next = new L_Variables;
|
|
v = v->next;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
v->next = NULL;
|
|
strncpy( v->name, _var, MAX_CGI_VAR_LEN );
|
|
|
|
v->value = NULL; // So we know the space has not been allocated
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
char * CVariables::GetVariable( const char * var )
|
|
{
|
|
L_Variables * v;
|
|
|
|
v = FindVariable( var );
|
|
|
|
if ( !v )
|
|
return NULL;
|
|
else
|
|
return v->value;
|
|
}
|
|
|
|
|
|
bool CVariables::GetBool( char * var, bool test /*= false*/, char * section /*= ""*/ )
|
|
{
|
|
L_Variables * v;
|
|
|
|
v = FindVariable( var );
|
|
|
|
if ( !v )
|
|
return false;
|
|
else
|
|
{
|
|
char * s = v->value;
|
|
return
|
|
strcasecmp( s, "yes" )==0 ||
|
|
strcasecmp( s, "on" )==0 ||
|
|
strcasecmp( s, "1" )==0 ||
|
|
strcasecmp( s, "enable" )==0 ||
|
|
strcasecmp( s, "enabled" )==0 ||
|
|
strcasecmp( s, "true" )==0 ;
|
|
}
|
|
}
|
|
|
|
char * CVariables::GetVariable( const char * var, bool test, char * section /*= ""*/ )
|
|
{
|
|
L_Variables * v;
|
|
|
|
char name_[MAX_CGI_VAR_LEN+1];
|
|
strsafecpy( name_, test?".":"", sizeof( name_ ) );
|
|
strsafecat( name_, section, sizeof(name_) );
|
|
if (section[0])
|
|
strsafecat( name_, "_", sizeof(name_) );
|
|
strsafecat( name_, var, sizeof(name_) );
|
|
|
|
v = FindVariable( name_ );
|
|
|
|
if ( !v )
|
|
return NULL;
|
|
else
|
|
return v->value;
|
|
}
|
|
|
|
char * CVariables::GetVariable( const char * var, char * result, int size )
|
|
{
|
|
L_Variables * v;
|
|
|
|
v = FindVariable( var );
|
|
|
|
if ( !v )
|
|
result[0] = 0;
|
|
else
|
|
{
|
|
strncpy( result, v->value, size );
|
|
result[size-1] = 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
long CVariables::GetVariableLong( char * name, bool *valid /*= NULL*/ )
|
|
{
|
|
char var[20];
|
|
GetVariable( name, var, sizeof(var) );
|
|
|
|
// if (!valid)
|
|
// return atol( var );
|
|
|
|
char * ep;
|
|
long res = strtol( var, &ep, 10 );
|
|
if (valid)
|
|
*valid = var[0] && !*ep;
|
|
return res;
|
|
}
|
|
|
|
|
|
long CVariables::GetVariableLong( char * name, bool test, char * section /*= ""*/ )
|
|
{
|
|
char name_[MAX_CGI_VAR_LEN+1];
|
|
strsafecpy( name_, test?".":"", sizeof( name_ ) );
|
|
strsafecat( name_, section, sizeof(name_) );
|
|
if (section[0])
|
|
strsafecat( name_, "_", sizeof(name_) );
|
|
strsafecat( name_, name, sizeof(name_) );
|
|
|
|
|
|
char var[20];
|
|
GetVariable( name_, var, sizeof(var) );
|
|
return atol( var );
|
|
}
|
|
|
|
|
|
void CVariables::LetInt16( char * var, int value )
|
|
{
|
|
L_Variables * v;
|
|
v = FindVariable( var, true );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
char st[10];
|
|
snprintf( st, sizeof(st), "%d", value);
|
|
|
|
v->value = strdup( st );
|
|
}
|
|
|
|
void CVariables::LetStr( const char * var, const char * value ) // NULL-terminated
|
|
{
|
|
L_Variables * v;
|
|
v = FindVariable( var, true );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
if ( value )
|
|
v->value = strdup( value );
|
|
else
|
|
v->value = strdup( "" );
|
|
}
|
|
|
|
|
|
void CVariables::RenameVariable( const char * name, const char * newname )
|
|
{
|
|
L_Variables * v;
|
|
v = FindVariable( name, true );
|
|
|
|
//logfmt( FLOG_MAX, "RenameVariable(): '%s'->'%s'", name, newname );
|
|
|
|
if ( !v )
|
|
{
|
|
//logfmt( FLOG_MAX, "RenameVariable(): Variable '%s' not found", name );
|
|
return;
|
|
}
|
|
|
|
strsafecpy( v->name, newname, sizeof( v->name ) );
|
|
}
|
|
|
|
|
|
|
|
void CVariables::vLetStrf( char * var, const char * format, va_list ap )
|
|
{
|
|
size_t buf_size = 512;
|
|
char *buffer = new char[buf_size];
|
|
|
|
size_t length;
|
|
|
|
while (true) {
|
|
if (!buffer) {
|
|
assert(buffer); // to stop when debugging
|
|
snprintf(buffer, buf_size, "<alloc problem>");
|
|
break;
|
|
}
|
|
length = vsnprintf(buffer, buf_size, format, ap);
|
|
|
|
if (length >= 0 && length < buf_size - 1) {
|
|
// string fits into current buffer
|
|
break;
|
|
}
|
|
// otherwise resize buffer :
|
|
buf_size *= 2;
|
|
// fprintf(stderr, "Reallocating vstrf-buffer to size=%u\n", buf_size);
|
|
delete [] buffer;
|
|
buffer = new char[buf_size];
|
|
}
|
|
|
|
L_Variables * v;
|
|
v = FindVariable( var, true );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
if (buffer) {
|
|
v->value = strdup( buffer );
|
|
delete [] buffer;
|
|
} else {
|
|
v->value = strdup( "" );
|
|
}
|
|
}
|
|
|
|
|
|
void CVariables::LetStrf( char * var, const char * format, ... )
|
|
{
|
|
va_list ap;
|
|
va_start( ap, format );
|
|
|
|
vLetStrf( var, format, ap );
|
|
|
|
va_end( ap );
|
|
}
|
|
|
|
|
|
/*
|
|
void CVariables::LetStrf( char * var, const char * format, ... )
|
|
{
|
|
char tmp[1000];
|
|
|
|
va_list ap;
|
|
va_start( ap, format );
|
|
vsnprintf( tmp, sizeof(tmp), format, ap );
|
|
va_end( ap );
|
|
|
|
|
|
L_Variables * v;
|
|
v = FindVariable( var, true );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
v->value = strdup( tmp );
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
void CVariables::StrCat( char * var, const char * format, ... )
|
|
{
|
|
char tmp[1000];
|
|
L_Variables * v;
|
|
|
|
v = FindVariable( var, true );
|
|
|
|
va_list ap;
|
|
va_start( ap, format );
|
|
|
|
if ( !v->value )
|
|
vsnprintf( tmp, sizeof(tmp), format, ap );
|
|
else
|
|
{
|
|
// logfmt( FLOG_MAX, "v->value='%s'", v->value );
|
|
strsafecpy( tmp, v->value, sizeof(tmp) );
|
|
strsafecat( tmp, "<br>", sizeof(tmp) );
|
|
int len = strlen(tmp);
|
|
vsnprintf( &tmp[len], sizeof(tmp)-len, format, ap );
|
|
|
|
}
|
|
va_end( ap );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
v->value = strdup( tmp );
|
|
|
|
// logfmt( FLOG_MAX, "tmp='%s'", tmp );
|
|
}
|
|
|
|
|
|
void CVariables::StrCatf( char * var, const char * format, ... )
|
|
{
|
|
char tmp[5000];
|
|
L_Variables * v;
|
|
|
|
v = FindVariable( var, true );
|
|
|
|
va_list ap;
|
|
va_start( ap, format );
|
|
|
|
if ( !v->value )
|
|
vsnprintf( tmp, sizeof(tmp), format, ap );
|
|
else
|
|
{
|
|
// logfmt( FLOG_MAX, "v->value='%s'", v->value );
|
|
strsafecpy( tmp, v->value, sizeof(tmp) );
|
|
//strsafecat( tmp, "<br>", sizeof(tmp) );
|
|
int len = strlen(tmp);
|
|
vsnprintf( &tmp[len], sizeof(tmp)-len, format, ap );
|
|
|
|
}
|
|
va_end( ap );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
v->value = strdup( tmp );
|
|
|
|
// logfmt( FLOG_MAX, "tmp='%s'", tmp );
|
|
}
|
|
|
|
|
|
void CVariables::LetStr( char * var, const char * value, int len ) // non-NULL terminated
|
|
{
|
|
L_Variables * v;
|
|
v = FindVariable( var, true );
|
|
|
|
if (v->value)
|
|
free( v->value );
|
|
|
|
if ( value )
|
|
{
|
|
v->value = (char*)malloc(len+1);
|
|
memcpy( v->value, value, len );
|
|
v->value[len] = 0;
|
|
}
|
|
else
|
|
v->value = strdup( "" );
|
|
}
|
|
|
|
|
|
void CVariables::PrintVars( FILE * f /*= stdout*/ )
|
|
{
|
|
L_Variables * v;
|
|
v = var_top;
|
|
|
|
fprintf( f, "\nVariable listing (NEW):\n\n" );
|
|
while ( v )
|
|
{
|
|
fprintf( f, "%s[%d] = %s\n", v->name, strlen(v->value), v->value );
|
|
v = v->next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
vi:ts=2
|
|
*/
|
|
|