static void
extract_orb2orb_orbargs( char *what, char *cmdline_fromorb, char *cmdline_toorb )
{
char *split_what;
Tbl *orb2orb_args;
split_what = strdup( what );
orb2orb_args = split( split_what, ' ' );
shifttbl( orb2orb_args );
strcpy( cmdline_fromorb, shifttbl( orb2orb_args ) );
if( cmdline_fromorb[0] == '-' ) {
/* Old style orb2orb command-line;
* assume no start-time, period,
* or end-time are specified:
*/
strcpy( cmdline_toorb, poptbl( orb2orb_args ) );
strcpy( cmdline_fromorb, poptbl( orb2orb_args ) );
} else {
strcpy( cmdline_toorb, shifttbl( orb2orb_args ) );
}
free( split_what );
freetbl( orb2orb_args, 0 );
return;
}
int
sinfo_update ( Arr * sold, Arr * snew )
{
int i;
int n1, n2;
int numfields;
char * field;
char * value;
char * newval;
char * oldval;
int newp, oldp;
Tbl * fields;
fields = keysarr( getpf( snew, FIELDS ) );
numfields = maxtbl( fields );
for ( i = 0; i < numfields; i++ )
{
field = (char*) poptbl( fields );
value = get_station_field( snew, field );
oldval = get_station_field( sold, field );
if ( strcmp( field, LATENCY ) == 0 )
{
newp = atoi( getpf( snew, LATENCY_ORDER ) );
oldp = atoi( getpf( sold, LATENCY_ORDER ) );
if ( ( !oldp && newp ) || ( newp < oldp ) )
{
set_station_field( sold, field, strdup(value) );
setarr( sold, LATENCY_ORDER, create_pf( itoa(newp), PFSTRING ) );
}
else if ( ( ( newp == oldp ) || ( !newp && !oldp ) ) &&
( atoi( value ) < atoi( oldval ) ) )
{
set_station_field( sold, field, strdup(value) );
setarr( sold, LATENCY_ORDER, create_pf( itoa(newp), PFSTRING ) );
}
}
else
/* If this is a channels value, we want to merge the values */
if ( strcmp( field, NUMCHANS ) == 0 )
{
(!value)? (n1 = 0): (n1 = atoi( value ));
(!oldval)? (n2 = 0): (n2 = atoi( oldval ));
set_station_field( sold, field, itoa( n1 + n2 ) );
}
else
if ( value != NULL )
set_station_field( sold, field, strdup(value) );
}
freetbl( fields, 0 );
return 1;
}
int
clrarr( Arr * arr, void (*free_value )() )
{
Tbl * tbl;
char * key;
void * oldval;
int size;
int i;
tbl = keysarr( arr );
size = maxtbl( tbl );
for ( i = 0; i < size; i++ )
{
key = poptbl( tbl );
oldval = delarr( arr, key );
if ( oldval ) free_value( oldval );
}
freetbl( tbl, 0 );
return 1;
}
int
get_priority( char * alert_name, orbinfo * oi )
{
int i;
int size;
Arr * level;
Tbl * alerttbl;
alerttbl = valsarr( oi->alert_stages );
size = maxtbl( alerttbl );
for ( i = 0; i < size; i++ )
{
level = (Arr*) poptbl( alerttbl );
if ( strcmp( getarr( level, NAME ), alert_name ) == 0 )
{
freetbl( alerttbl, 0 );
return atoi( getarr( level, PRIORITY ));
}
}
freetbl( alerttbl, 0 );
return -1;
}
/* Recursively removes pf instances from the pf object and returns the
* objects' contents in an entirely new structure so that no memory is reused.
* Requires the caller have some knowledge about the structure of the data. */
void *
pf_collapse( Pf * pf )
{
Arr * currarr;
Tbl * currtbl;
char * key;
void * value;
int i;
int size;
if ( pf == NULL ) return NULL;
switch( pf->type )
{
case PFARR: currtbl = keysarr( pf->value.arr );
size = maxtbl( currtbl );
/* currarr = newarr( pf->value.arr->rb_comp ); */
currarr = newarr( strcmp );
for ( i = 0; i < size; i++ )
{
key = poptbl( currtbl );
value = pf_collapse( getarr( pf->value.arr, key ) );
setarr( currarr, key, value );
}
freetbl( currtbl, 0 );
return currarr;
case PFTBL: size = maxtbl( pf->value.tbl );
currtbl = newtbl( size );
for ( i = 0; i < size; i++ )
settbl( currtbl, i,
pf_collapse( gettbl( pf->value.tbl, i ) ) );
return currtbl;
default: return strdup( pf->value.s );
}
}
static void
parse_orbname( char *orbname, char *orb_address, int *orb_port )
{
char *split_orbname;
Tbl *orbname_parts;
char orbname_port[STRSZ];
Hook *hook = 0;
static Pf *pfnames = 0;
int len = 0;
if( STREQ( orbname, ":" ) ) {
strcpy( orb_address, "127.0.0.1" );
strcpy( orbname_port, "" );
} else {
split_orbname = strdup( orbname );
orbname_parts = split( split_orbname, ':' );
if( maxtbl( orbname_parts ) == 1 && orbname[0] == ':' ) {
strcpy( orb_address, "127.0.0.1" );
strcpy( orbname_port, poptbl( orbname_parts ) );
} else if( maxtbl( orbname_parts ) == 1 ) {
strcpy( orb_address, shifttbl( orbname_parts ) );
strcpy( orbname_port, "" );
} else if( maxtbl( orbname_parts ) == 2 ) {
strcpy( orb_address, shifttbl( orbname_parts ) );
strcpy( orbname_port, poptbl( orbname_parts ) );
} else {
elog_complain( 0, "pforbstat: unexpected error translating orb2orb argument <%s>\n",
orbname );
strcpy( orb_address, "" );
strcpy( orbname_port, "" );
}
free( split_orbname );
freetbl( orbname_parts, 0 );
}
if( ( len = strlen( orbname_port ) ) > 0 ) {
if( orbname_port[len-1] == '@' ) {
orbname_port[len-1] = '\0';
}
}
if( STREQ( orbname_port, "" ) ) {
*orb_port = ORB_TCP_PORT;
} else if( strmatches( orbname_port, "^[0-9]+$", &hook ) ) {
*orb_port = atoi( orbname_port );
} else {
if( pfnames == 0 ) {
pfread( "orbserver_names", &pfnames );
}
if( pfget_string( pfnames, orbname_port ) == 0 ) {
elog_complain( 0, "pforbstat: couldn't translate orb port \":%s\"\n", orbname_port );
*orb_port = 0;
} else {
*orb_port = pfget_int( pfnames, orbname_port );
}
}
return;
}
int
set_sinfo_limits( Arr * sinfo, orbinfo * oi, char * pkttype )
{
int i, j;
int size, size2;
int numalerts;
Arr * alert_ranges;
Arr* ranges;
Arr * oldval;
Pf * newfieldlist;
Arr * field;
Pf * thresholds;
Pf * thresh;
double high;
double low;
double * val;
Tbl* levels;
Tbl* byfield;
Tbl* fields;
char* level;
char * name;
int priority = 0;
/* Find the alert thresholds applicable to this packet type. If packet
type not mentioned by name, use the default values. */
if ( !( ranges = getarr( oi->alert_ranges, pkttype) ) )
if ( !( ranges = getarr( oi->alert_ranges, "all") ) ) return 0;
thresholds = pfnew( PFARR );
thresholds->value.arr = newarr( strcmp );
oldval = setarr( sinfo, THRESHOLD, thresholds );
/* if ( oldval ) freearr( oldval, recurse_free_pf ); */
/* First grab the list of alert levels for this packet type. */
levels = keysarr( ranges );
numalerts = maxtbl( levels );
for ( i =0; i < numalerts; i++ )
{
level = poptbl( levels );
byfield = (Tbl*) getarr( ranges, level );
newfieldlist = create_pf ( newarr( strcmp ), PFARR );
setarr( thresholds->value.arr, level, newfieldlist );
priority = get_priority( level, oi );
/* Next, get the thresholds for this current alert level. */
size = maxtbl( byfield );
for ( j = 0; j < size; j++ )
{
/* From this, examine each field. */
field = (Arr*) gettbl( byfield, j );
thresh = create_pf( newarr( strcmp ), PFARR );
setarr ( thresh->value.arr, HIGH,
create_pf( strdup( getarr( field, HIGH ) ), PFSTRING) );
setarr ( thresh->value.arr, LOW,
create_pf( strdup( getarr( field, LOW ) ), PFSTRING) );
setarr ( thresh->value.arr, PRIORITY,
create_pf( itoa( priority ), PFSTRING));
name = getarr( field, NAME );
if ( name == NULL )
continue;
oldval = setarr( newfieldlist->value.arr, name, thresh );
if ( oldval ) free( oldval );
}
}
freetbl( levels, 0 );
return 1;
}
