/*
====================
WriteTextureClass
====================
*/
void WriteTextureClass( char *name )
{
FILE *h;
int i;
hobj_t *texturecls;
hobj_t *tmp;
hpair_t *pair;
char idtext[256];
texturecls = NewClass( "textures", "textures0" );
for ( i = 0; i < p_wtexturenum; i++ )
{
sprintf( idtext, "#%u", p_wtextures[i].clsname );
tmp = NewClass( "texture", idtext );
sprintf( idtext, "%s", p_wtextures[i].ident );
pair = NewHPair2( "string", "ident", idtext );
InsertHPair( tmp, pair );
InsertClass( texturecls, tmp );
}
h = fopen( name, "w" );
WriteClass( texturecls, h );
fclose( h );
}
/*
====================
MakeBigBox
====================
*/
void MakeBigBox( fp_t size )
{
vec3d_t norm;
fp_t dist;
int i;
hobj_t *brushes;
hobj_t *brush;
hobj_t *surface;
int plane;
hpair_t *pair;
FILE *h;
brushes = NewClass( "bspbrushes", "bigbox0" );
brush = NewClass( "bspbrush", "bigbox" );
InsertClass( brushes, brush );
pair = NewHPair2( "ref", "original", "null" );
InsertHPair( brush, pair );
pair = NewHPair2( "int" , "content", "0" );
InsertHPair( brush, pair );
for ( i = 0; i < 3; i++ )
{
char tt[256];
surface = NewClass( "surface", "noname" );
InsertClass( brush, surface );
pair = NewHPair2( "int", "content", "0" );
InsertHPair( surface, pair );
Vec3dInit( norm, 0.0, 0.0, 0.0 );
norm[i] = 1.0;
dist = size; //tree->max[i] + 64.0;
plane = FindPlane( norm, dist );
sprintf( tt, "#%d", p_planes[plane].clsname );
pair = NewHPair2( "ref", "plane", tt );
InsertHPair( surface, pair );
surface = NewClass( "surface", "noname" );
InsertClass( brush, surface );
pair = NewHPair2( "int", "content", "0" );
InsertHPair( surface, pair );
Vec3dInit( norm, 0.0, 0.0, 0.0 );
norm[i] = -1.0;
dist = size; //- (tree->min[i] - 64.0);
plane = FindPlane( norm, dist );
sprintf( tt, "#%d", p_planes[plane].clsname );
pair = NewHPair2( "ref", "plane", tt );
InsertHPair( surface, pair );
}
h = fopen( "_bigbox.hobj", "w" );
if ( !h )
Error( "can't write bigbox class.\n" );
WriteClass( brushes, h );
fclose( h );
}
/*
====================
ConvertSBrushes
====================
*/
void ConvertSBrushes( hmanager_t *hm, char *name )
{
FILE *h;
hobj_t *sbrushcls;
hobj_search_iterator_t iter;
hobj_t *brush;
int num;
hobj_t *bspbrushcls;
bspbrushcls = NewClass( "bspbrushes", "bspbrushes0" );
sbrushcls = HManagerGetRootClass( hm );
if ( !sbrushcls )
Error( "can't find class 'sbrush'\n" );
InitClassSearchIterator( &iter, sbrushcls, "brush" );
total_faces = 0;
for ( num = 0; ( brush = SearchGetNextClass( &iter ) ) ; num++ )
{
ConvertBrushClass( bspbrushcls, brush );
}
printf( " ok\n" );
printf( "brushes: %d\n", num );
printf( "faces: %d\n", total_faces );
printf( "generated pump brushes: %d\n", pump_brushes );
h = fopen( name, "w" );
WriteClass( bspbrushcls, h );
fclose( h );
}
hobj_t * BuildCBspbrushClass( cbspbrush_t *b, hmanager_t *planehm, hmanager_t *texdefhm )
{
int i;
hpair_t *pair;
hobj_t *brush;
hobj_t *surface;
char tt[256];
sprintf( tt, "#%u", HManagerGetFreeID() );
brush = NewClass( "bspbrush", tt );
sprintf( tt, "%u", b->contents );
pair = NewHPair2( "int", "content", tt );
InsertHPair( brush, pair );
pair = FindHPair( b->original, "original" );
if ( pair )
{
pair = NewHPair2( "ref", "original", pair->value );
InsertHPair( brush, pair );
}
for ( i = 0; i < b->surfacenum; i++ )
{
sprintf( tt, "#%u", HManagerGetFreeID() );
surface = NewClass( "surface", tt );
// clsref plane
pair = NewHPair2( "ref", "plane", b->surfaces[i].pl->self->name );
InsertHPair( surface, pair );
// clsref texdef
if ( b->surfaces[i].td )
{
pair = NewHPair2( "ref", "texdef", b->surfaces[i].td->self->name );
InsertHPair( surface, pair );
}
// contents
sprintf( tt, "%u", b->surfaces[i].contents );
pair = NewHPair2( "int", "content", tt );
InsertHPair( surface, pair );
InsertClass( brush, surface );
}
return brush;
}
/*
====================
WriteTexdefClass
====================
*/
void WriteTexdefClass( char *name )
{
FILE *h;
int i;
hobj_t *texdefcls;
hobj_t *tmp;
hpair_t *pair;
char idtext[256];
texdefcls = NewClass( "texdefs", "texdefs0" );
for ( i = 0; i < p_wtexdefnum; i++ )
{
sprintf( idtext, "#%u", p_wtexdefs[i].clsname );
tmp = NewClass( "texdef", idtext );
sprintf( idtext, "#%u", p_wtexdefs[i].clsref_texture );
pair = NewHPair2( "ref", "texture", idtext );
InsertHPair( tmp, pair );
sprintf( idtext, "%u", p_wtexdefs[i].flags );
pair = NewHPair2( "int", "flags", idtext );
InsertHPair( tmp, pair );
sprintf( idtext, "%f %f", p_wtexdefs[i].vec[0][0], p_wtexdefs[i].vec[0][1] );
pair = NewHPair2( "vec2d", "vec0", idtext );
InsertHPair( tmp, pair );
sprintf( idtext, "%f %f", p_wtexdefs[i].vec[1][0], p_wtexdefs[i].vec[1][1] );
pair = NewHPair2( "vec2d", "vec1", idtext );
InsertHPair( tmp, pair );
sprintf( idtext, "%f %f", p_wtexdefs[i].shift[0], p_wtexdefs[i].shift[1] );
pair = NewHPair2( "vec2d", "shift", idtext );
InsertHPair( tmp, pair );
EasyNewVec2d( tmp, "scale", p_wtexdefs[i].scale );
EasyNewFloat( tmp, "rotate", p_wtexdefs[i].rotate );
InsertClass( texdefcls, tmp );
}
h = fopen( name, "w" );
WriteClass( texdefcls, h );
fclose( h );
}
const char * SV_AddPlayer( const char *in )
{
hobj_t *player_obj;
ati_t *player;
unique_t id;
const char *ptr;
char tkn[256];
__named_message( "\n" );
if ( sv_num_player >= SV_MAX_PLAYER )
{
__warning( "reached SV_MAX_PLAYER\n" );
return "fail";
}
ptr = in;
Parse_GetToken( &ptr, tkn, 256 );
if ( !tkn[0] )
{
__warning( "missing player id, ignore\n" );
return "fail";
}
id = StringToUnique( tkn );
if ( id == UNIQUE_INVALIDE )
{
__warning( "player got an invalid id, ignore\n" );
return "fail";
}
player = L_AtiSearchById( id );
if ( player )
{
__warning( "there is already a player with this id\n" );
return "fail";
}
player_obj = NewClass( "player", tkn );
SV_PlayerObjGetNickname( player_obj );
player = ATI_CreatePlayer( player_obj );
L_AtiChangeToWakeUp( player );
sv_num_player++;
return "ok";
}
/*---------------------------------------------------------------------------*/
MERGE_CLASS NewLabeledClass (
char *Label)
{
MERGE_CLASS MergeClass;
MergeClass = new MERGE_CLASS_NODE;
MergeClass->Label = (char*)Emalloc (strlen (Label)+1);
strcpy (MergeClass->Label, Label);
MergeClass->Class = NewClass (MAX_NUM_PROTOS, MAX_NUM_CONFIGS);
return (MergeClass);
} /* NewLabeledClass */
void BuildClassFromNodeList( u_list_t *node_list, char *name )
{
int i;
u_list_iter_t iter;
node_t *n;
hobj_t *node;
hobj_t *root;
FILE *h;
// indexing nodes
U_ListIterInit( &iter, node_list );
for ( i = 0; ( n = U_ListIterNext( &iter ) ) ; i++ )
{
n->index = i;
}
root = NewClass( "bspnodes", "bspnodes0" );
// build class
U_ListIterInit( &iter, node_list );
for ( ; ( n = U_ListIterNext( &iter ) ) ; )
{
node = EasyNewClass( "bspnode" );
InsertClass( root, node );
EasyNewInt( node, "index", n->index );
if ( n->vertex_list )
{
// leaf
EasyNewString( node, "type", "leaf" );
}
else
{
EasyNewString( node, "type", "node" );
EasyNewVec3d( node, "norm", n->norm );
EasyNewFloat( node, "dist", n->dist );
EasyNewInt( node, "child_front", n->child[0]->index );
EasyNewInt( node, "child_back", n->child[1]->index );
}
}
h = fopen( name, "w" );
if ( !h )
Error( "can't open node class\n" );
WriteClass( root, h );
fclose( h );
}
static void Unix_GetMacAddress(enum cfagenttype ag, int fd, struct ifreq *ifr, struct ifreq *ifp, Rlist **interfaces,
Rlist **hardware)
{
char name[CF_MAXVARSIZE];
if (ag != cf_know)
{
snprintf(name, CF_MAXVARSIZE, "hardware_mac[%s]", ifp->ifr_name);
}
else
{
snprintf(name, CF_MAXVARSIZE, "hardware_mac[interface_name]");
}
# ifdef SIOCGIFHWADDR
char hw_mac[CF_MAXVARSIZE];
ioctl(fd, SIOCGIFHWADDR, ifr);
snprintf(hw_mac, CF_MAXVARSIZE - 1, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
(unsigned char) ifr->ifr_hwaddr.sa_data[0],
(unsigned char) ifr->ifr_hwaddr.sa_data[1],
(unsigned char) ifr->ifr_hwaddr.sa_data[2],
(unsigned char) ifr->ifr_hwaddr.sa_data[3],
(unsigned char) ifr->ifr_hwaddr.sa_data[4], (unsigned char) ifr->ifr_hwaddr.sa_data[5]);
NewScalar("sys", name, hw_mac, cf_str);
AppendRlist(hardware, hw_mac, CF_SCALAR);
AppendRlist(interfaces, ifp->ifr_name, CF_SCALAR);
snprintf(name, CF_MAXVARSIZE, "mac_%s", CanonifyName(hw_mac));
NewClass(name);
# else
NewScalar("sys", name, "mac_unknown", cf_str);
NewClass("mac_unknown");
# endif
}
hobj_t * BuildVertexClass( vec3d_t v )
{
hobj_t *vertex;
hpair_t *pair;
char tt[256];
sprintf( tt, "#%u", HManagerGetFreeID() );
vertex = NewClass( "vertex", tt );
sprintf( tt, "%f %f %f", v[0], v[1], v[2] );
pair = NewHPair2( "vec3d", "point", tt );
InsertHPair( vertex, pair );
return vertex;
}
void UnifyVertices( face_t *list, char *vertex_name )
{
face_t *f;
hobj_t *vertexcls;
FILE *h;
hpair_t *pair;
hobj_t *poly;
printf( "unify vertices ...\n" );
vertexcls = NewClass( "vertices", "vertices0" );
out_facevertexnum = 0;
out_vertexnum = 0;
InitHashtab();
for ( f = list; f ; f=f->next )
{
pair = FindHPair( f->self, "lightdef" );
// copy lightdef
InsertClass( f->surface, poly = BuildFixPolygonClass( f->fix, vertexcls ) );
if ( pair )
{
pair = NewHPair2( pair->type, pair->key, pair->value );
InsertHPair( poly, pair );
}
if ( f->fix2 )
{
InsertClass( f->surface, poly = BuildFixPolygonClass( f->fix2, vertexcls ) );
if ( pair )
{
pair = NewHPair2( pair->type, pair->key, pair->value );
InsertHPair( poly, pair );
}
}
}
printf( " %d unique vertices\n", out_vertexnum );
printf( " %d face vertices\n", out_facevertexnum );
printf( "write vertex class ...\n" );
h = fopen( vertex_name, "w" );
if ( !h )
Error( "can't open file.\n" );
WriteClass( vertexcls, h );
fclose( h );
}
/*********************************************************
NAME : AddSystemClass
DESCRIPTION : Performs all necessary allocations
for adding a system class
INPUTS : 1) The name-string of the system class
2) The address of the parent class
(NULL if none)
RETURNS : The address of the new system class
SIDE EFFECTS : Allocations performed
NOTES : Assumes system-class name is unique
Also assumes SINGLE INHERITANCE for
system classes to simplify precedence
list determination
Adds classes to has table but NOT to
class list (this is responsibility
of caller)
*********************************************************/
static DEFCLASS *AddSystemClass(
void *theEnv,
char *name,
DEFCLASS *parent)
{
DEFCLASS *sys;
long i;
char defaultScopeMap[1];
sys = NewClass(theEnv,(SYMBOL_HN *) EnvAddSymbol(theEnv,name));
sys->abstract = 1;
#if DEFRULE_CONSTRUCT
sys->reactive = 0;
#endif
IncrementSymbolCount(sys->header.name);
sys->installed = 1;
sys->system = 1;
sys->hashTableIndex = HashClass(sys->header.name);
AddClassLink(theEnv,&sys->allSuperclasses,sys,-1);
if (parent != NULL)
{
AddClassLink(theEnv,&sys->directSuperclasses,parent,-1);
AddClassLink(theEnv,&parent->directSubclasses,sys,-1);
AddClassLink(theEnv,&sys->allSuperclasses,parent,-1);
for (i = 1 ; i < parent->allSuperclasses.classCount ; i++)
AddClassLink(theEnv,&sys->allSuperclasses,parent->allSuperclasses.classArray[i],-1);
}
sys->nxtHash = DefclassData(theEnv)->ClassTable[sys->hashTableIndex];
DefclassData(theEnv)->ClassTable[sys->hashTableIndex] = sys;
/* =========================================
Add default scope maps for a system class
There is only one module (MAIN) so far -
which has an id of 0
========================================= */
ClearBitString((void *) defaultScopeMap,(int) sizeof(char));
SetBitMap(defaultScopeMap,0);
#if DEFMODULE_CONSTRUCT
sys->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) defaultScopeMap,(int) sizeof(char));
IncrementBitMapCount(sys->scopeMap);
#endif
return(sys);
}
void WritePortalClass( char *portal_name, char *node_name, cnode_t *topnode )
{
hobj_t *portalcls;
FILE *h;
portalcls = NewClass( "portals", "portals0" );
BuildPortalClassRecursive( topnode, portalcls );
DeepDumpClass( portalcls );
DeepDumpClass( topnode->self );
h = fopen( portal_name, "w" );
WriteClass( portalcls, h );
fclose( h );
h = fopen( node_name, "w" );
WriteClass( topnode->self, h );
fclose( h );
}
static void BuildClassFromTri_CB( void *obj )
{
trimesh_tri_t *t = obj;
hobj_t *tri;
hpair_t *pair;
char tt[256];
sprintf( tt, "#%u", t->id );
tri = NewClass( "tri", tt );
InsertClass( g_tri_root, tri );
sprintf( tt, "#%u", t->knot_refs[0]->id );
pair = NewHPair2( "ref", "0", tt );
InsertHPair( tri, pair );
sprintf( tt, "#%u", t->knot_refs[1]->id );
pair = NewHPair2( "ref", "1", tt );
InsertHPair( tri, pair );
sprintf( tt, "#%u", t->knot_refs[2]->id );
pair = NewHPair2( "ref", "2", tt );
InsertHPair( tri, pair );
}
/*
==============================
TriMesh_BuildClassFromVertices
==============================
*/
hobj_t * TriMesh_BuildClassFromVertices( trimesh_t *mesh )
{
hobj_t *vertex_root;
u_list_iter_t iter;
trimesh_vertex_t *v;
char tt[256];
vertex_root = EasyNewClass( "vertices" );
U_ListIterInit( &iter, &mesh->vertex_list );
for ( ; ( v = U_ListIterNext( &iter ) ) ; )
{
hobj_t *vertex;
sprintf( tt, "#%u", v->id );
vertex = NewClass( "vertex", tt );
EasyNewVec3d( vertex, "vec", v->vec );
InsertClass( vertex_root, vertex );
}
return vertex_root;
}
hobj_t * BuildFixPolygonClass( polygon_t *p, hobj_t *vertexcls )
{
hobj_t *fixpoly;
hpair_t *pair;
char tt[256];
int i;
sprintf( tt, "#%u", HManagerGetFreeID() );
fixpoly = NewClass( "fixpolygon", tt );
sprintf( tt, "%d", p->pointnum );
pair = NewHPair2( "int", "pointnum", tt );
InsertHPair( fixpoly, pair );
for( i = 0; i < p->pointnum; i++ )
{
sprintf( tt, "%d", i );
pair = NewHPair2( "ref", tt, FindVertex( p->p[i], vertexcls )->name );
InsertHPair( fixpoly, pair );
}
return fixpoly;
}
/***************************************************************************************
NAME : ParseDefclass
DESCRIPTION : (defclass ...) is a construct (as
opposed to a function), thus no variables
may be used. This means classes may only
be STATICALLY defined (like rules).
INPUTS : The logical name of the router
for the parser input
RETURNS : FALSE if successful parse, TRUE otherwise
SIDE EFFECTS : Inserts valid class definition into
Class Table.
NOTES : H/L Syntax :
(defclass <name> [<comment>]
(is-a <superclass-name>+)
<class-descriptor>*)
<class-descriptor> :== (slot <name> <slot-descriptor>*) |
(role abstract|concrete) |
(pattern-match reactive|non-reactive)
These are for documentation only:
(message-handler <name> [<type>])
<slot-descriptor> :== (default <default-expression>) |
(default-dynamic <default-expression>) |
(storage shared|local) |
(access read-only|read-write|initialize-only) |
(propagation no-inherit|inherit) |
(source composite|exclusive)
(pattern-match reactive|non-reactive)
(visibility public|private)
(override-message <message-name>)
(type ...) |
(cardinality ...) |
(allowed-symbols ...) |
(allowed-strings ...) |
(allowed-numbers ...) |
(allowed-integers ...) |
(allowed-floats ...) |
(allowed-values ...) |
(allowed-instance-names ...) |
(allowed-classes ...) |
(range ...)
<default-expression> ::= ?NONE | ?VARIABLE | <expression>*
***************************************************************************************/
globle int ParseDefclass(
void *theEnv,
char *readSource)
{
SYMBOL_HN *cname;
DEFCLASS *cls;
PACKED_CLASS_LINKS *sclasses,*preclist;
TEMP_SLOT_LINK *slots = NULL;
int roleSpecified = FALSE,
abstract = FALSE,
parseError;
#if DEFRULE_CONSTRUCT
int patternMatchSpecified = FALSE,
reactive = TRUE;
#endif
SetPPBufferStatus(theEnv,ON);
FlushPPBuffer(theEnv);
SetIndentDepth(theEnv,3);
SavePPBuffer(theEnv,"(defclass ");
#if BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE
if ((Bloaded(theEnv)) && (! ConstructData(theEnv)->CheckSyntaxMode))
{
CannotLoadWithBloadMessage(theEnv,"defclass");
return(TRUE);
}
#endif
cname = GetConstructNameAndComment(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken,"defclass",
EnvFindDefclass,NULL,"#",TRUE,
TRUE,TRUE);
if (cname == NULL)
return(TRUE);
if (ValidClassName(theEnv,ValueToString(cname),&cls) == FALSE)
return(TRUE);
sclasses = ParseSuperclasses(theEnv,readSource,cname);
if (sclasses == NULL)
return(TRUE);
preclist = FindPrecedenceList(theEnv,cls,sclasses);
if (preclist == NULL)
{
DeletePackedClassLinks(theEnv,sclasses,TRUE);
return(TRUE);
}
parseError = FALSE;
GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);
while (GetType(DefclassData(theEnv)->ObjectParseToken) != RPAREN)
{
if (GetType(DefclassData(theEnv)->ObjectParseToken) != LPAREN)
{
SyntaxErrorMessage(theEnv,"defclass");
parseError = TRUE;
break;
}
PPBackup(theEnv);
PPCRAndIndent(theEnv);
SavePPBuffer(theEnv,"(");
GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);
if (GetType(DefclassData(theEnv)->ObjectParseToken) != SYMBOL)
{
SyntaxErrorMessage(theEnv,"defclass");
parseError = TRUE;
break;
}
if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),ROLE_RLN) == 0)
{
if (ParseSimpleQualifier(theEnv,readSource,ROLE_RLN,CONCRETE_RLN,ABSTRACT_RLN,
&roleSpecified,&abstract) == FALSE)
{
parseError = TRUE;
break;
}
}
#if DEFRULE_CONSTRUCT
else if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),MATCH_RLN) == 0)
{
if (ParseSimpleQualifier(theEnv,readSource,MATCH_RLN,NONREACTIVE_RLN,REACTIVE_RLN,
&patternMatchSpecified,&reactive) == FALSE)
{
parseError = TRUE;
break;
}
}
#endif
else if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),SLOT_RLN) == 0)
{
slots = ParseSlot(theEnv,readSource,slots,preclist,FALSE,FALSE);
if (slots == NULL)
{
parseError = TRUE;
break;
}
}
else if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),SGL_SLOT_RLN) == 0)
{
slots = ParseSlot(theEnv,readSource,slots,preclist,FALSE,TRUE);
if (slots == NULL)
{
parseError = TRUE;
break;
}
}
else if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),MLT_SLOT_RLN) == 0)
{
slots = ParseSlot(theEnv,readSource,slots,preclist,TRUE,TRUE);
if (slots == NULL)
{
parseError = TRUE;
break;
}
}
else if (strcmp(DOToString(DefclassData(theEnv)->ObjectParseToken),HANDLER_DECL) == 0)
{
if (ReadUntilClosingParen(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken) == FALSE)
{
parseError = TRUE;
break;
}
}
else
{
SyntaxErrorMessage(theEnv,"defclass");
parseError = TRUE;
break;
}
GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);
}
if ((GetType(DefclassData(theEnv)->ObjectParseToken) != RPAREN) || (parseError == TRUE))
{
DeletePackedClassLinks(theEnv,sclasses,TRUE);
DeletePackedClassLinks(theEnv,preclist,TRUE);
DeleteSlots(theEnv,slots);
return(TRUE);
}
SavePPBuffer(theEnv,"\n");
/* =========================================================================
The abstract/reactive qualities of a class are inherited if not specified
========================================================================= */
if (roleSpecified == FALSE)
{
if (preclist->classArray[1]->system && /* Change to cause */
(DefclassData(theEnv)->ClassDefaultsMode == CONVENIENCE_MODE)) /* default role of */
{ abstract = FALSE; } /* classes to be concrete. */
else
{ abstract = preclist->classArray[1]->abstract; }
}
#if DEFRULE_CONSTRUCT
if (patternMatchSpecified == FALSE)
{
if ((preclist->classArray[1]->system) && /* Change to cause */
(! abstract) && /* default pattern-match */
(DefclassData(theEnv)->ClassDefaultsMode == CONVENIENCE_MODE)) /* of classes to be */
{ reactive = TRUE; } /* reactive. */
else
{ reactive = preclist->classArray[1]->reactive; }
}
/* ================================================================
An abstract class cannot have direct instances, thus it makes no
sense for it to be reactive since it will have no objects to
respond to pattern-matching
================================================================ */
if (abstract && reactive)
{
PrintErrorID(theEnv,"CLASSPSR",1,FALSE);
EnvPrintRouter(theEnv,WERROR,"An abstract class cannot be reactive.\n");
DeletePackedClassLinks(theEnv,sclasses,TRUE);
DeletePackedClassLinks(theEnv,preclist,TRUE);
DeleteSlots(theEnv,slots);
return(TRUE);
}
#endif
/* =======================================================
If we're only checking syntax, don't add the
successfully parsed defclass to the KB.
======================================================= */
if (ConstructData(theEnv)->CheckSyntaxMode)
{
DeletePackedClassLinks(theEnv,sclasses,TRUE);
DeletePackedClassLinks(theEnv,preclist,TRUE);
DeleteSlots(theEnv,slots);
return(FALSE);
}
cls = NewClass(theEnv,cname);
cls->abstract = abstract;
#if DEFRULE_CONSTRUCT
cls->reactive = reactive;
#endif
cls->directSuperclasses.classCount = sclasses->classCount;
cls->directSuperclasses.classArray = sclasses->classArray;
/* =======================================================
This is a hack to let functions which need to iterate
over a class AND its superclasses to conveniently do so
The real precedence list starts in position 1
======================================================= */
preclist->classArray[0] = cls;
cls->allSuperclasses.classCount = preclist->classCount;
cls->allSuperclasses.classArray = preclist->classArray;
rtn_struct(theEnv,packedClassLinks,sclasses);
rtn_struct(theEnv,packedClassLinks,preclist);
/* =================================
Shove slots into contiguous array
================================= */
if (slots != NULL)
PackSlots(theEnv,cls,slots);
AddClass(theEnv,cls);
return(FALSE);
}
GenericAgentConfig CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig config = GenericAgentDefaultConfig(cf_common);
while ((c = getopt_long(argc, argv, "advnIf:D:N:VSrxMb:pg:h", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
if (optarg && strlen(optarg) < 5)
{
FatalError(" -f used but argument \"%s\" incorrect", optarg);
}
SetInputFile(optarg);
MINUSF = true;
break;
case 'd':
NewClass("opt_debug");
DEBUG = true;
break;
case 'b':
if (optarg)
{
config.bundlesequence = SplitStringAsRList(optarg, ',');
CBUNDLESEQUENCE_STR = optarg;
}
break;
case 'K':
IGNORELOCK = true;
break;
case 'D':
NewClassesFromString(optarg);
break;
case 'N':
NegateClassesFromString(optarg);
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
LOOKUP = true;
NewClass("opt_dry_run");
break;
case 'V':
PrintVersionBanner("cf-promises");
exit(0);
case 'h':
Syntax("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(0);
case 'r':
PrependRScalar(&GOALS, "goal.*", CF_SCALAR);
SHOWREPORTS = true;
break;
case 'x':
SelfDiagnostic();
exit(0);
case 'a':
printf("Self-analysis is not yet implemented.\n");
exit(0);
break;
/*
case 'p':
SHOW_PARSE_TREE = true;
break;
*/
case 'g':
USE_GCC_BRIEF_FORMAT = true;
break;
default:
Syntax("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(cf_error, "", "Unexpected argument with no preceding option: %s\n", argv[optind]);
}
CfDebug("Set debugging\n");
return config;
}
int foo1(void)
{
bar();
return(NewClass(1));
}
int foo2(void)
{
return(NewClass(2));
}
void KeepControlPromises()
{ struct Constraint *cp;
char rettype;
void *retval;
struct Rlist *rp;
for (cp = ControlBodyConstraints(cf_agent); cp != NULL; cp=cp->next)
{
if (IsExcluded(cp->classes))
{
continue;
}
if (GetVariable("control_common",cp->lval,&retval,&rettype) != cf_notype)
{
/* Already handled in generic_agent */
continue;
}
if (GetVariable("control_agent",cp->lval,&retval,&rettype) == cf_notype)
{
CfOut(cf_error,"","Unknown lval %s in agent control body",cp->lval);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_maxconnections].lval) == 0)
{
CFA_MAXTHREADS = (int)Str2Int(retval);
CfOut(cf_verbose,"","SET maxconnections = %d\n",CFA_MAXTHREADS);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_checksum_alert_time].lval) == 0)
{
CF_PERSISTENCE = (int)Str2Int(retval);
CfOut(cf_verbose,"","SET checksum_alert_time = %d\n",CF_PERSISTENCE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_agentfacility].lval) == 0)
{
SetFacility(retval);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_agentaccess].lval) == 0)
{
ACCESSLIST = (struct Rlist *) retval;
CheckAgentAccess(ACCESSLIST);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_refresh_processes].lval) == 0)
{
struct Rlist *rp;
if (VERBOSE)
{
printf("%s> SET refresh_processes when starting: ",VPREFIX);
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
printf(" %s",(char *)rp->item);
PrependItem(&PROCESSREFRESH,rp->item,NULL);
}
printf("\n");
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_abortclasses].lval) == 0)
{
struct Rlist *rp;
CfOut(cf_verbose,"","SET Abort classes from ...\n");
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
char name[CF_MAXVARSIZE] = "";
strncpy(name, rp->item, CF_MAXVARSIZE - 1);
CanonifyNameInPlace(name);
if (!IsItemIn(ABORTHEAP,name))
{
AppendItem(&ABORTHEAP,name,cp->classes);
}
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_abortbundleclasses].lval) == 0)
{
struct Rlist *rp;
CfOut(cf_verbose,"","SET Abort bundle classes from ...\n");
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
char name[CF_MAXVARSIZE] = "";
strncpy(name, rp->item, CF_MAXVARSIZE - 1);
CanonifyNameInPlace(name);
if (!IsItemIn(ABORTBUNDLEHEAP,name))
{
AppendItem(&ABORTBUNDLEHEAP,name,cp->classes);
}
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_addclasses].lval) == 0)
{
struct Rlist *rp;
CfOut(cf_verbose,"","-> Add classes ...\n");
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
CfOut(cf_verbose,""," -> ... %s\n",rp->item);
NewClass(rp->item);
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_auditing].lval) == 0)
{
AUDIT = GetBoolean(retval);
CfOut(cf_verbose,"","SET auditing = %d\n",AUDIT);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_alwaysvalidate].lval) == 0)
{
ALWAYS_VALIDATE = GetBoolean(retval);
CfOut(cf_verbose,"","SET alwaysvalidate = %d\n",ALWAYS_VALIDATE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_secureinput].lval) == 0)
{
CFPARANOID = GetBoolean(retval);
CfOut(cf_verbose,"","SET secure input = %d\n",CFPARANOID);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_binarypaddingchar].lval) == 0)
{
PADCHAR = *(char *)retval;
CfOut(cf_verbose,"","SET binarypaddingchar = %c\n",PADCHAR);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_bindtointerface].lval) == 0)
{
strncpy(BINDINTERFACE,retval,CF_BUFSIZE-1);
CfOut(cf_verbose,"","SET bindtointerface = %s\n",BINDINTERFACE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_hashupdates].lval) == 0)
{
CHECKSUMUPDATES = GetBoolean(retval);
CfOut(cf_verbose,"","SET ChecksumUpdates %d\n",CHECKSUMUPDATES);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_exclamation].lval) == 0)
{
EXCLAIM = GetBoolean(retval);
CfOut(cf_verbose,"","SET exclamation %d\n",EXCLAIM);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_childlibpath].lval) == 0)
{
char output[CF_BUFSIZE];
snprintf(output,CF_BUFSIZE,"LD_LIBRARY_PATH=%s",(char *)retval);
if (putenv(strdup(output)) == 0)
{
CfOut(cf_verbose,"","Setting %s\n",output);
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_defaultcopytype].lval) == 0)
{
DEFAULT_COPYTYPE = (char *)retval;
CfOut(cf_verbose,"","SET defaultcopytype = %c\n",DEFAULT_COPYTYPE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_fsinglecopy].lval) == 0)
{
SINGLE_COPY_LIST = (struct Rlist *)retval;
CfOut(cf_verbose,"","SET file single copy list\n");
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_fautodefine].lval) == 0)
{
AUTO_DEFINE_LIST = (struct Rlist *)retval;
CfOut(cf_verbose,"","SET file auto define list\n");
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_dryrun].lval) == 0)
{
DONTDO = GetBoolean(retval);
CfOut(cf_verbose,"","SET dryrun = %c\n",DONTDO);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_inform].lval) == 0)
{
INFORM = GetBoolean(retval);
CfOut(cf_verbose,"","SET inform = %c\n",INFORM);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_verbose].lval) == 0)
{
VERBOSE = GetBoolean(retval);
CfOut(cf_verbose,"","SET inform = %c\n",VERBOSE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_repository].lval) == 0)
{
VREPOSITORY = strdup(retval);
CfOut(cf_verbose,"","SET repository = %s\n",VREPOSITORY);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_skipidentify].lval) == 0)
{
SKIPIDENTIFY = GetBoolean(retval);
CfOut(cf_verbose,"","SET skipidentify = %d\n",SKIPIDENTIFY);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_suspiciousnames].lval) == 0)
{
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
PrependItem(&SUSPICIOUSLIST,rp->item,NULL);
CfOut(cf_verbose,"", "-> Concidering %s as suspicious file", rp->item);
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_repchar].lval) == 0)
{
REPOSCHAR = *(char *)retval;
CfOut(cf_verbose,"","SET repchar = %c\n",REPOSCHAR);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_mountfilesystems].lval) == 0)
{
CF_MOUNTALL = GetBoolean(retval);
CfOut(cf_verbose,"","SET mountfilesystems = %d\n",CF_MOUNTALL);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_editfilesize].lval) == 0)
{
EDITFILESIZE = Str2Int(retval);
CfOut(cf_verbose,"","SET EDITFILESIZE = %d\n",EDITFILESIZE);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_ifelapsed].lval) == 0)
{
VIFELAPSED = Str2Int(retval);
CfOut(cf_verbose,"","SET ifelapsed = %d\n",VIFELAPSED);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_expireafter].lval) == 0)
{
VEXPIREAFTER = Str2Int(retval);
CfOut(cf_verbose,"","SET ifelapsed = %d\n",VEXPIREAFTER);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_timeout].lval) == 0)
{
CONNTIMEOUT = Str2Int(retval);
CfOut(cf_verbose,"","SET timeout = %d\n",CONNTIMEOUT);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_max_children].lval) == 0)
{
CFA_BACKGROUND_LIMIT = Str2Int(retval);
CfOut(cf_verbose,"","SET MAX_CHILDREN = %d\n",CFA_BACKGROUND_LIMIT);
if (CFA_BACKGROUND_LIMIT > 10)
{
CfOut(cf_error,"","Silly value for max_children in agent control promise (%d > 10)",CFA_BACKGROUND_LIMIT);
CFA_BACKGROUND_LIMIT = 1;
}
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_syslog].lval) == 0)
{
LOGGING = GetBoolean(retval);
CfOut(cf_verbose,"","SET syslog = %d\n",LOGGING);
continue;
}
if (strcmp(cp->lval,CFA_CONTROLBODY[cfa_environment].lval) == 0)
{
struct Rlist *rp;
CfOut(cf_verbose,"","SET environment variables from ...\n");
for (rp = (struct Rlist *) retval; rp != NULL; rp = rp->next)
{
if (putenv(rp->item) != 0)
{
CfOut(cf_error, "putenv", "Failed to set environment variable %s", rp->item);
}
}
continue;
}
}
if (GetVariable("control_common",CFG_CONTROLBODY[cfg_lastseenexpireafter].lval,&retval,&rettype) != cf_notype)
{
LASTSEENEXPIREAFTER = Str2Int(retval);
}
if (GetVariable("control_common",CFG_CONTROLBODY[cfg_fips_mode].lval,&retval,&rettype) != cf_notype)
{
FIPS_MODE = GetBoolean(retval);
CfOut(cf_verbose,"","SET FIPS_MODE = %d\n",FIPS_MODE);
}
if (GetVariable("control_common",CFG_CONTROLBODY[cfg_syslog_port].lval,&retval,&rettype) != cf_notype)
{
SYSLOGPORT = (unsigned short)Str2Int(retval);
CfOut(cf_verbose,"","SET syslog_port to %d",SYSLOGPORT);
}
if (GetVariable("control_common",CFG_CONTROLBODY[cfg_syslog_host].lval,&retval,&rettype) != cf_notype)
{
strncpy(SYSLOGHOST,Hostname2IPString(retval),CF_MAXVARSIZE-1);
CfOut(cf_verbose,"","SET syslog_host to %s",SYSLOGHOST);
}
#ifdef HAVE_NOVA
Nova_Initialize();
#endif
}
void Unix_FindV6InterfaceInfo(void)
{
FILE *pp = NULL;
char buffer[CF_BUFSIZE];
/* Whatever the manuals might say, you cannot get IPV6
interface configuration from the ioctls. This seems
to be implemented in a non standard way across OSes
BSDi has done getifaddrs(), solaris 8 has a new ioctl, Stevens
book shows the suggestion which has not been implemented...
*/
CfOut(cf_verbose, "", "Trying to locate my IPv6 address\n");
switch (VSYSTEMHARDCLASS)
{
case cfnt:
/* NT cannot do this */
return;
case irix:
case irix4:
case irix64:
if ((pp = cf_popen("/usr/etc/ifconfig -a", "r")) == NULL)
{
CfOut(cf_verbose, "", "Could not find interface info\n");
return;
}
break;
case hp:
if ((pp = cf_popen("/usr/sbin/ifconfig -a", "r")) == NULL)
{
CfOut(cf_verbose, "", "Could not find interface info\n");
return;
}
break;
case aix:
if ((pp = cf_popen("/etc/ifconfig -a", "r")) == NULL)
{
CfOut(cf_verbose, "", "Could not find interface info\n");
return;
}
break;
default:
if ((pp = cf_popen("/sbin/ifconfig -a", "r")) == NULL)
{
CfOut(cf_verbose, "", "Could not find interface info\n");
return;
}
}
/* Don't know the output format of ifconfig on all these .. hope for the best*/
while (!feof(pp))
{
fgets(buffer, CF_BUFSIZE - 1, pp);
if (ferror(pp)) /* abortable */
{
break;
}
if (strcasestr(buffer, "inet6"))
{
Item *ip, *list = NULL;
char *sp;
list = SplitStringAsItemList(buffer, ' ');
for (ip = list; ip != NULL; ip = ip->next)
{
for (sp = ip->name; *sp != '\0'; sp++)
{
if (*sp == '/') /* Remove CIDR mask */
{
*sp = '\0';
}
}
if (IsIPV6Address(ip->name) && (strcmp(ip->name, "::1") != 0))
{
CfOut(cf_verbose, "", "Found IPv6 address %s\n", ip->name);
AppendItem(&IPADDRESSES, ip->name, "");
NewClass(ip->name);
}
}
DeleteItemList(list);
}
}
cf_pclose(pp);
}
void Unix_GetInterfaceInfo(enum cfagenttype ag)
{
int fd, len, i, j, first_address = false, ipdefault = false;
struct ifreq ifbuf[CF_IFREQ], ifr, *ifp;
struct ifconf list;
struct sockaddr_in *sin;
struct hostent *hp;
char *sp, workbuf[CF_BUFSIZE];
char ip[CF_MAXVARSIZE];
char name[CF_MAXVARSIZE];
char last_name[CF_BUFSIZE];
Rlist *interfaces = NULL, *hardware = NULL, *ips = NULL;
CfDebug("Unix_GetInterfaceInfo()\n");
memset(ifbuf, 0, sizeof(ifbuf));
InitIgnoreInterfaces();
last_name[0] = '\0';
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
CfOut(cf_error, "socket", "Couldn't open socket");
exit(1);
}
list.ifc_len = sizeof(ifbuf);
list.ifc_req = ifbuf;
# ifdef SIOCGIFCONF
if (ioctl(fd, SIOCGIFCONF, &list) == -1 || (list.ifc_len < (sizeof(struct ifreq))))
# else
if (ioctl(fd, OSIOCGIFCONF, &list) == -1 || (list.ifc_len < (sizeof(struct ifreq))))
# endif
{
CfOut(cf_error, "ioctl", "Couldn't get interfaces - old kernel? Try setting CF_IFREQ to 1024");
exit(1);
}
last_name[0] = '\0';
for (j = 0, len = 0, ifp = list.ifc_req; len < list.ifc_len;
len += SIZEOF_IFREQ(*ifp), j++, ifp = (struct ifreq *) ((char *) ifp + SIZEOF_IFREQ(*ifp)))
{
if (ifp->ifr_addr.sa_family == 0)
{
continue;
}
if (ifp->ifr_name == NULL || strlen(ifp->ifr_name) == 0)
{
continue;
}
/* Skip virtual network interfaces for Linux, which seems to be a problem */
if (IgnoreInterface(ifp->ifr_name))
{
continue;
}
if (strstr(ifp->ifr_name, ":"))
{
if (VSYSTEMHARDCLASS == linuxx)
{
CfOut(cf_verbose, "", "Skipping apparent virtual interface %d: %s\n", j + 1, ifp->ifr_name);
continue;
}
}
else
{
CfOut(cf_verbose, "", "Interface %d: %s\n", j + 1, ifp->ifr_name);
}
// Ignore the loopback
if (strcmp(ifp->ifr_name, "lo") == 0)
{
continue;
}
if (strncmp(last_name, ifp->ifr_name, sizeof(ifp->ifr_name)) == 0)
{
first_address = false;
}
else
{
strncpy(last_name, ifp->ifr_name, sizeof(ifp->ifr_name));
if (!first_address)
{
NewScalar("sys", "interface", last_name, cf_str);
first_address = true;
}
}
snprintf(workbuf, CF_BUFSIZE, "net_iface_%s", CanonifyName(ifp->ifr_name));
NewClass(workbuf);
if (ifp->ifr_addr.sa_family == AF_INET)
{
strncpy(ifr.ifr_name, ifp->ifr_name, sizeof(ifp->ifr_name));
if (ioctl(fd, SIOCGIFFLAGS, &ifr) == -1)
{
CfOut(cf_error, "ioctl", "No such network device");
//close(fd);
//return;
continue;
}
if ((ifr.ifr_flags & IFF_BROADCAST) && !(ifr.ifr_flags & IFF_LOOPBACK))
{
sin = (struct sockaddr_in *) &ifp->ifr_addr;
if (IgnoreJailInterface(j + 1, sin))
{
CfOut(cf_verbose, "", "Ignoring interface %d", j + 1);
continue;
}
CfDebug("Adding hostip %s..\n", inet_ntoa(sin->sin_addr));
NewClass(inet_ntoa(sin->sin_addr));
if ((hp =
gethostbyaddr((char *) &(sin->sin_addr.s_addr), sizeof(sin->sin_addr.s_addr), AF_INET)) == NULL)
{
CfDebug("No hostinformation for %s not found\n", inet_ntoa(sin->sin_addr));
}
else
{
if (hp->h_name != NULL)
{
CfDebug("Adding hostname %s..\n", hp->h_name);
NewClass(hp->h_name);
if (hp->h_aliases != NULL)
{
for (i = 0; hp->h_aliases[i] != NULL; i++)
{
CfOut(cf_verbose, "", "Adding alias %s..\n", hp->h_aliases[i]);
NewClass(hp->h_aliases[i]);
}
}
}
}
if (strcmp(inet_ntoa(sin->sin_addr), "0.0.0.0") == 0)
{
// Maybe we need to do something windows specific here?
CfOut(cf_verbose, "", " !! Cannot discover hardware IP, using DNS value");
strcpy(ip, "ipv4_");
strcat(ip, VIPADDRESS);
AppendItem(&IPADDRESSES, VIPADDRESS, "");
AppendRlist(&ips, VIPADDRESS, CF_SCALAR);
for (sp = ip + strlen(ip) - 1; (sp > ip); sp--)
{
if (*sp == '.')
{
*sp = '\0';
NewClass(ip);
}
}
strcpy(ip, VIPADDRESS);
i = 3;
for (sp = ip + strlen(ip) - 1; (sp > ip); sp--)
{
if (*sp == '.')
{
*sp = '\0';
snprintf(name, CF_MAXVARSIZE - 1, "ipv4_%d[%s]", i--, CanonifyName(VIPADDRESS));
NewScalar("sys", name, ip, cf_str);
}
}
//close(fd);
//return;
continue;
}
strncpy(ip, "ipv4_", CF_MAXVARSIZE);
strncat(ip, inet_ntoa(sin->sin_addr), CF_MAXVARSIZE - 6);
NewClass(ip);
if (!ipdefault)
{
ipdefault = true;
NewScalar("sys", "ipv4", inet_ntoa(sin->sin_addr), cf_str);
strcpy(VIPADDRESS, inet_ntoa(sin->sin_addr));
}
AppendItem(&IPADDRESSES, inet_ntoa(sin->sin_addr), "");
AppendRlist(&ips, inet_ntoa(sin->sin_addr), CF_SCALAR);
for (sp = ip + strlen(ip) - 1; (sp > ip); sp--)
{
if (*sp == '.')
{
*sp = '\0';
NewClass(ip);
}
}
// Set the IPv4 on interface array
strcpy(ip, inet_ntoa(sin->sin_addr));
if (ag != cf_know)
{
snprintf(name, CF_MAXVARSIZE - 1, "ipv4[%s]", CanonifyName(ifp->ifr_name));
}
else
{
snprintf(name, CF_MAXVARSIZE - 1, "ipv4[interface_name]");
}
NewScalar("sys", name, ip, cf_str);
i = 3;
for (sp = ip + strlen(ip) - 1; (sp > ip); sp--)
{
if (*sp == '.')
{
*sp = '\0';
if (ag != cf_know)
{
snprintf(name, CF_MAXVARSIZE - 1, "ipv4_%d[%s]", i--, CanonifyName(ifp->ifr_name));
}
else
{
snprintf(name, CF_MAXVARSIZE - 1, "ipv4_%d[interface_name]", i--);
}
NewScalar("sys", name, ip, cf_str);
}
}
}
// Set the hardware/mac address array
Unix_GetMacAddress(ag, fd, &ifr, ifp, &interfaces, &hardware);
}
}
close(fd);
NewList("sys", "interfaces", interfaces, cf_slist);
NewList("sys", "hardware_addresses", hardware, cf_slist);
NewList("sys", "ip_addresses", ips, cf_slist);
}
hobj_t * BuildVisleaf( hobj_t *leaf, hmanager_t *portalhm, hmanager_t *nodehm, hmanager_t *planehm )
{
hpair_search_iterator_t iter;
bool_t flip;
cplane_t *pl;
hobj_t *portal;
hobj_t *otherleaf;
hobj_t *vportal;
hobj_t *plane;
hobj_t *visleaf;
hpair_t *pair;
char tt[256];
vec3d_t center, pc, min, max;
int num;
Vec3dInit( center, 0, 0, 0 );
Vec3dInitBB( min, max, 999999.9 );
sprintf( tt, "#%u", HManagerGetFreeID() );
visleaf = NewClass( "visleaf", tt );
InitHPairSearchIterator( &iter, leaf, "portal" );
for ( num = 0; ( pair = SearchGetNextHPair( &iter ) ); num++ )
{
portal = HManagerSearchClassName( portalhm, pair->value );
if ( !portal )
Error( "leaf '%s' can't find portal '%s'.\n", leaf->name, pair->value );
CalcPortalCenter( portal, pc, min, max );
Vec3dAdd( center, center, pc );
// get otherleaf
pair = FindHPair( portal, "frontnode" );
if ( !pair )
Error( "missing 'frontnode' in portal '%s'.\n", portal->name );
if ( !strcmp( pair->value, leaf->name ) )
{
// I'm the frontnode of the portal, let's go to the backnode
pair = FindHPair( portal, "backnode" );
if ( !pair )
Error( "missing 'backnode' in portal '%s'.\n", portal->name );
otherleaf = HManagerSearchClassName( nodehm, pair->value );
if ( !otherleaf )
Error( "portal '%s' can't find leaf '%s'.\n", portal->name, pair->value );
flip = true;
}
else
{
otherleaf = HManagerSearchClassName( nodehm, pair->value );
if ( !otherleaf )
Error( "portal '%s' can't find leaf '%s'.\n", portal->name, pair->value );
flip = false;
}
pair = FindHPair( portal, "plane" );
if ( !pair )
Error( "missing 'plane' of portal '%s'.\n", portal->name );
plane = HManagerSearchClassName( planehm, pair->value );
if ( !plane )
Error( "portal '%s' can't find plane '%s'.\n", portal->name, pair->value );
pl = GetClassExtra( plane );
if ( flip )
pl = pl->flipplane;
sprintf( tt, "#%u", HManagerGetFreeID() );
vportal = NewClass( "portal", tt );
pair = NewHPair2( "ref", "plane", pl->self->name );
InsertHPair( vportal, pair );
CopyPortalPolygonToPortal( vportal, portal, flip );
pair = FindHPair( portal, "state" );
if ( !pair )
Error( "missing 'state' of portal '%s'.\n", portal->name );
if ( !strcmp( pair->value, "open" ) )
{
// open portal goes to othernode
pair = NewHPair2( "ref", "otherleaf", otherleaf->name );
InsertHPair( vportal, pair );
}
else
{
// closed portals
pair = NewHPair2( "ref", "touchleaf", otherleaf->name );
InsertHPair( visleaf, pair );
// hack: also insert touchleaf into the closed portal
pair = NewHPair2( pair->type, pair->key, pair->value );
InsertHPair( vportal, pair );
}
InsertClass( visleaf, vportal );
}
// leaf center
Vec3dScale( center, 1.0/num, center );
pair = NewHPair2( "vec3d", "center", "x" );
HPairCastFromVec3d( center, pair );
InsertHPair( visleaf, pair );
// leaf bounds min
pair = NewHPair2( "vec3d", "min", "x" );
HPairCastFromVec3d( min, pair );
InsertHPair( visleaf, pair );
// leaf bounds max
pair = NewHPair2( "vec3d", "max", "X" );
HPairCastFromVec3d( max, pair );
InsertHPair( visleaf, pair );
return visleaf;
}
void CheckOpts(int argc,char **argv)
{ extern char *optarg;
int optindex = 0;
int c;
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
while ((c=getopt_long(argc,argv,"t:q:d:b:vnKhIif:D:VSxo:s:MH:",OPTIONS,&optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
strncpy(VINPUTFILE,optarg,CF_BUFSIZE-1);
VINPUTFILE[CF_BUFSIZE-1] = '\0';
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = atoi(optarg);
}
break;
case 'd':
NewClass("opt_debug");
switch ((optarg==NULL) ? '3' : *optarg)
{
case '1':
D1 = true;
DEBUG = true;
break;
case '2':
D2 = true;
DEBUG = true;
break;
default:
DEBUG = true;
break;
}
break;
case 'q':
if (optarg==NULL)
{
strcpy(MENU,"delta");
}
else
{
strncpy(MENU,optarg,CF_MAXVARSIZE);
}
break;
case 'K': IGNORELOCK = true;
break;
case 's': strncpy(SENDCLASSES,optarg,CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
FatalError("Argument too long\n");
}
break;
case 'D': strncpy(DEFINECLASSES,optarg,CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
FatalError("Argument too long\n");
}
break;
case 'H':
HOSTLIST = SplitStringAsRList(optarg,',');
break;
case 'o':
strncpy(REMOTE_AGENT_OPTIONS,optarg,CF_MAXVARSIZE);
break;
case 'I': INFORM = true;
break;
case 'i': INTERACTIVE = true;
break;
case 'v': VERBOSE = true;
break;
case 'n': DONTDO = true;
IGNORELOCK = true;
NewClass("opt_dry_run");
break;
case 't':
CONNTIMEOUT = atoi(optarg);
break;
case 'V': PrintVersionBanner("cf-runagent");
exit(0);
case 'h': Syntax("cf-runagent - Run agent",OPTIONS,HINTS,ID);
exit(0);
case 'M': ManPage("cf-runagent - Run agent",OPTIONS,HINTS,ID);
exit(0);
case 'x': SelfDiagnostic();
exit(0);
default: Syntax("cf-runagent - Run agent",OPTIONS,HINTS,ID);
exit(1);
}
}
Debug("Set debugging\n");
}
int main( int argc, char *argv[] )
{
char *in_node_name;
char *in_portal_name;
char *in_plane_name;
char *out_node_name;
char *out_visleaf_name;
hmanager_t *nodehm;
hmanager_t *portalhm;
hmanager_t *planehm;
hobj_t *visleafcls;
tokenstream_t *ts;
FILE *h;
printf( "===== visleaf - build a initial visleaf class for pvs generation =====\n" );
SetCmdArgs( argc, argv );
in_portal_name = GetCmdOpt2( "-p" );
in_node_name = GetCmdOpt2( "-n" );
in_plane_name = GetCmdOpt2( "-pl" );
out_node_name = GetCmdOpt2( "-o" );
out_visleaf_name = GetCmdOpt2( "-v" );
if ( !in_portal_name )
{
in_portal_name = "_mkpcout_portal.hobj";
printf( " default input portal class: %s\n", in_portal_name );
}
else
{
printf( " input portal class: %s\n", in_portal_name );
}
if ( !in_node_name )
{
in_node_name = "_leafflood_bspnode.hobj";
printf( " default input bspnode class: %s\n", in_node_name );
}
else
{
printf( " input bspnode class: %s\n", in_node_name );
}
if ( !out_node_name )
{
out_node_name = "_visleaf_bspnode.hobj";
printf( " default output bspnode class: %s\n", out_node_name );
}
else
{
printf( " output bspnode class: %s\n", out_node_name );
}
if ( !in_plane_name )
{
in_plane_name = "_plane.hobj";
printf( " default input plane class: %s\n", in_plane_name );
}
else
{
printf( " input plane class: %s\n", in_plane_name );
}
if ( !out_visleaf_name )
{
out_visleaf_name = "_visleaf_visleaf.hobj";
printf( " default output visleaf class: %s\n", out_visleaf_name );
}
else
{
printf( " output visleaf class: %s\n", out_visleaf_name );
}
printf( "load portal class ...\n" );
ts = BeginTokenStream( in_portal_name );
if ( !ts )
Error( "can't open portal class.\n" );
portalhm = NewHManager();
HManagerSetRootClass( portalhm, ReadClass( ts ) );
EndTokenStream( ts );
HManagerRebuildHash( portalhm );
printf( "load bspnode class ...\n" );
ts = BeginTokenStream( in_node_name );
if ( !ts )
Error( "can't open bspnode class.\n" );
nodehm = NewHManager();
HManagerSetRootClass( nodehm, ReadClass( ts ) );
EndTokenStream( ts );
HManagerRebuildHash( nodehm );
planehm = ReadPlaneClass( in_plane_name );
printf( "build visleafs ...\n" );
visleafcls = NewClass( "visleafs", "visleafs0" );
BuildVisleafsRecursive( HManagerGetRootClass( nodehm ), portalhm, nodehm, planehm, visleafcls );
printf( "fix otherleaf clsref ...\n" );
printf( " %d visleafs total\n", FixOtherleafs( visleafcls, nodehm ) );
h = fopen( out_visleaf_name, "w" );
if ( !h )
Error( "can't open file.\n" );
WriteClass( visleafcls, h );
fclose( h );
h = fopen( out_node_name, "w" );
if ( !h )
Error( "can't open file.\n" );
WriteClass( HManagerGetRootClass( nodehm ), h );
fclose( h );
HManagerSaveID();
}
/*
====================
BuildPortalClass
====================
*/
hobj_t * BuildPortalClass( portal_t *p )
{
hobj_t *portal;
hpair_t *pair;
int i;
char tt[256];
sprintf( tt, "#%u", HManagerGetFreeID() );
portal = NewClass( "portal", tt );
sprintf( tt, "%s", p->nodes[0]->self->name );
pair = NewHPair2( "ref", "frontnode", tt );
InsertHPair( portal, pair );
pair = FindHPair( p->nodes[0]->self, "contents" );
if ( !pair )
Error( "missing 'contents' in node '%s'.\n", p->nodes[0]->self->name );
pair = NewHPair2( "int", "front_contents", pair->value );
InsertHPair( portal, pair );
sprintf( tt, "%s", p->nodes[1]->self->name );
pair = NewHPair2( "ref", "backnode", tt );
InsertHPair( portal, pair );
pair = FindHPair( p->nodes[1]->self, "contents" );
if ( !pair )
Error( "missing 'contents' in node '%s'.\n", p->nodes[1]->self->name );
pair = NewHPair2( "int", "back_contents", pair->value );
InsertHPair( portal, pair );
#if 0
sprintf( tt, "%f %f %f", p->norm[0], p->norm[1], p->norm[2] );
pair = NewHPair2( "vec3d", "norm", tt );
InsertHPair( portal, pair );
sprintf( tt, "%f", p->dist );
pair = NewHPair2( "float", "dist", tt );
InsertHPair( portal, pair );
#else
sprintf( tt, "%s", p->pl->self->name );
pair = NewHPair2( "ref", "plane", tt );
InsertHPair( portal, pair );
#endif
sprintf( tt, "%d", p->p->pointnum );
pair = NewHPair2( "int", "pointnum", tt );
InsertHPair( portal, pair );
for ( i = 0; i < p->p->pointnum; i++ )
{
pair = NewHPair( );
sprintf( pair->type, "vec3d" );
sprintf( pair->key, "%d", i );
HPairCastFromVec3d( p->p->p[i], pair );
// sprintf( pair->value, "%f %f %f", p->p->p[i][0], p->p->p[i][1], p->p->p[i][2] );
InsertHPair( portal, pair );
}
p->self = portal;
return portal;
}
int main( int argc, char *argv[] )
{
char *in_brush_name;
char *out_shape_name;
char *out_glmesh_name;
char *in_plane_name;
char *in_texdef_name;
char *in_texture_name;
char *in_tm_name;
char *path_name;
hobj_t *brush_root;
hmanager_t *plane_hm;
hmanager_t *texdef_hm;
hmanager_t *texture_hm;
hobj_t *tm_root;
hobj_t *meshtile_root;
hobj_search_iterator_t brush_iter;
hobj_search_iterator_t surf_iter;
hobj_search_iterator_t surf2_iter;
hobj_t *brush;
hobj_t *surf;
hobj_t *surf2;
hobj_t *shape_root;
hobj_t *shape;
FILE *h;
int num_total_tris;
char tt[256];
gld = GLD_BeginSession( "xxx" );
GLD_StartRecord( gld );
GLD_BeginList( gld, "polys", "line" );
puts( "===== meshtile1 - create meshtiles from surfaces =====" );
SetCmdArgs( argc, argv );
if ( argc == 1 )
{
puts( "usage:" );
puts( " -i : input bspbrush class" );
puts( " -o : output shape class" );
puts( " -obin : output glmesh binary" );
puts( " -pl : input plane class" );
puts( " -td : input texdef class" );
puts( " -tx : input texture class" );
puts( " -tm : input texture material class" );
puts( " -path : config path to ./shape_config and ./meshtiles" );
exit(-1);
}
in_brush_name = GetCmdOpt2( "-i" );
out_shape_name = GetCmdOpt2( "-o" );
out_glmesh_name = GetCmdOpt2( "-obin" );
in_plane_name = GetCmdOpt2( "-pl" );
in_texdef_name = GetCmdOpt2( "-td" );
in_texture_name = GetCmdOpt2( "-tx" );
in_tm_name = GetCmdOpt2( "-tm" );
path_name = GetCmdOpt2( "-path" );
if ( !in_brush_name )
Error( "no input bspbrush class\n" );
if ( !out_shape_name )
Error( "no output shape class\n" );
if ( !out_glmesh_name )
Error( "no output glmesh binary\n" );
if ( !in_plane_name )
Error( "no input plane class\n" );
if ( !in_texdef_name )
Error( "no input texdef class\n" );
if ( !in_texture_name )
Error( "no input texture class\n" );
if ( !in_tm_name )
Error( "no input texture material class\n" );
if ( !path_name )
Error( "no config path\n" );
brush_root = ReadClassFile( in_brush_name );
if ( !brush_root )
Error( "can't read bspbrush class\n" );
texdef_hm = NewHManagerLoadClass( in_texdef_name );
if ( !texdef_hm )
Error( "can't read texdef class\n" );
plane_hm = ReadPlaneClass( in_plane_name );
texture_hm = NewHManagerLoadClass( in_texture_name );
if ( !texture_hm )
Error( "can't read texture class\n" );
tm_root = ReadClassFile( in_tm_name );
if ( !tm_root )
Error( "can't read texture material class" );
sprintf( tt, "%s/shape_config/meshtile.hobj", path_name );
meshtile_root = ReadClassFile( tt );
if ( !meshtile_root )
Error( "can't read meshtile class ( %s )\n", tt );
shape_root = NewClass( "shapes", "meshtiles0" );
//
// for all c5 brushes
//
num_total_tris = 0;
InitClassSearchIterator( &brush_iter, brush_root, "bspbrush" );
for ( ; ( brush = SearchGetNextClass( &brush_iter ) ) ; )
{
int b_contents;
int num_surf;
vec3d_t v;
hobj_t *surf_poly_obj;
polygon_t *surf_poly;
EasyFindInt( &b_contents, brush, "content" );
if ( b_contents != 5 )
{
continue;
}
//
// for all surfaces
//
InitClassSearchIterator( &surf_iter, brush, "surface" );
for ( num_surf = 0; ( surf = SearchGetNextClass( &surf_iter ) ) ; num_surf++ )
{
int s_contents;
hobj_t *plane;
hobj_t *texdef;
hobj_t *texture;
hobj_t *meshtile;
hpair_t *pair;
hpair_t *mat_pair;
#if 1
EasyFindInt( &s_contents, surf, "content" );
if ( !(s_contents & 32) )
{
// no substructur flag
continue;
}
#endif
// GenerateMeshtile( surf, plane_hm, texdef_hm,
plane = EasyLookupClsref( surf, "plane", plane_hm );
texdef = EasyLookupClsref( surf, "texdef", texdef_hm );
texture = EasyLookupClsref( texdef, "texture", texture_hm );
pair = FindHPair( texture, "ident" );
if ( !pair )
Error( "missing key 'ident'\n" );
meshtile = FindClass( meshtile_root, pair->value );
if ( !meshtile )
{
Error( "no meshtile defs for ident '%s'\n", pair->value );
}
mat_pair = FindHPair( tm_root, pair->value );
{
int i, j;
vec3d_t norm;
fp_t dist;
hobj_t *plane2;
vec3d_t norm2;
fp_t dist2;
fp_t rotate;
vec2d_t shift;
vec2d_t scale;
vec2d_t vec0, vec1;
fp_t u_size, v_size, height;
u_list_t *raw_poly_list;
u_list_t *base_tile_mesh;
surf_poly_obj = FindClassType( surf, "polygon" );
surf_poly = CreatePolygonFromClass( surf_poly_obj );
EasyFindVec3d( norm, plane, "norm" );
EasyFindFloat( &dist, plane, "dist" );
EasyFindVec2d( shift, texdef, "shift" );
EasyFindVec2d( vec0, texdef, "vec0" );
EasyFindVec2d( vec1, texdef, "vec1" );
if ( vec0[0] == 0.0 && vec0[1] == 0.0 )
{
vec0[0] = 1.0;
}
if ( vec1[0] == 0.0 && vec1[1] == 0.0 )
{
vec1[1] = 1.0;
}
EasyFindVec2d( scale, texdef, "scale" );
EasyFindFloat( &rotate, texdef, "rotate" );
EasyFindFloat( &u_size, meshtile, "u_size" );
EasyFindFloat( &v_size, meshtile, "v_size" );
EasyFindFloat( &height, meshtile, "height" );
pair = FindHPair( meshtile, "raw_path" );
if ( !pair )
Error( "missing key 'raw_path'\n" );
sprintf( tt, "%s/%s", path_name, pair->value );
raw_poly_list = ReadPolygonList( tt );
if ( !raw_poly_list )
Error( "can't load raw polygons\n" );
printf( "%s: %d raw polygons/tile \n", pair->value, U_ListLength( raw_poly_list ) );
NormalizePolygonList( raw_poly_list );
{
vec3d_t scl;
scl[0] = u_size;
scl[1] = v_size;
scl[2] = height;
ScalePolygonList( raw_poly_list, scl );
}
{
vec3d_t shf;
shf[0] = 0.0;
shf[1] = 0.0;
shf[2] = -height;
ShiftPolygonList( raw_poly_list, shf );
}
base_tile_mesh = GenBaseTileMesh( surf_poly, norm, dist, vec0, vec1, shift, raw_poly_list, u_size, v_size, rotate, scale );
//
// clip base by all surface planes
//
InitClassSearchIterator( &surf2_iter, brush, "surface" );
for ( ; ( surf2 = SearchGetNextClass( &surf2_iter ) ) ; )
{
if ( surf2 == surf )
continue;
EasyFindInt( &s_contents, surf2, "content" );
if ( !(s_contents & 32) )
{
// no substructur flag
continue;
}
plane2 = EasyLookupClsref( surf2, "plane", plane_hm );
EasyFindVec3d( norm2, plane2, "norm" );
EasyFindFloat( &dist2, plane2, "dist" );
ClipPolygonList( base_tile_mesh, norm2, dist2 );
}
for ( i = 0; i < surf_poly->pointnum; i++ )
{
j = (i+1==surf_poly->pointnum)?0:(i+1);
// search surf, which the edge is on
InitClassSearchIterator( &surf2_iter, brush, "surface" );
for ( ; ( surf2 = SearchGetNextClass( &surf2_iter ) ) ; )
{
if ( surf2 == surf )
continue;
plane2 = EasyLookupClsref( surf2, "plane", plane_hm );
EasyFindVec3d( norm2, plane2, "norm" );
EasyFindFloat( &dist2, plane2, "dist" );
if ( fabs(Vec3dDotProduct( surf_poly->p[i], norm2 )-dist2 ) < 0.1 &&
fabs(Vec3dDotProduct( surf_poly->p[j], norm2 )-dist2 ) < 0.1 )
{
// that's the surf
vec3d_t delta1, delta2;
vec3d_t cross;
Vec3dSub( delta1, surf_poly->p[j], surf_poly->p[i] );
Vec3dAdd( delta2, norm, norm2 );
Vec3dUnify( delta1 );
Vec3dUnify( delta2 );
Vec3dCrossProduct( cross, delta1, delta2 );
Vec3dUnify( cross );
dist2 = Vec3dInitPlane2( cross, surf_poly->p[i] );
ClipPolygonList( base_tile_mesh, cross, dist2 );
break;
}
}
}
// DrawPolygonList( base_tile_mesh );
//
// build meshtile shape
//
plane = EasyLookupClsref( surf, "plane", plane_hm );
shape = BuildMeshTileShape( surf_poly_obj, plane, texdef, mat_pair, base_tile_mesh );
BuildTriMesh( shape, base_tile_mesh );
InsertClass( shape_root, shape );
num_total_tris += U_ListLength( base_tile_mesh );
}
}
}
printf( " generated %d triangles\n", num_total_tris );
GLD_EndList( gld );
GLD_Update( gld );
GLD_Pause( gld );
GLD_EndSession( gld );
h = fopen( out_shape_name, "w" );
if ( !h )
Error( "can't write shape class\n" );
WriteClass( shape_root, h );
fclose( h );
h = fopen( out_glmesh_name, "w" );
if ( !h )
Error( "can't write glmesh binary\n" );
fwrite( glmesh_base, glmesh_ofs, 1, h );
fclose( h );
HManagerSaveID();
exit(0);
}
void KeepControlPromises(Policy *policy)
{
Rval retval;
Rlist *rp;
Seq *constraints = ControlBodyConstraints(policy, AGENT_TYPE_AGENT);
if (constraints)
{
for (size_t i = 0; i < SeqLength(constraints); i++)
{
Constraint *cp = SeqAt(constraints, i);
if (IsExcluded(cp->classes, NULL))
{
continue;
}
if (GetVariable("control_common", cp->lval, &retval) != DATA_TYPE_NONE)
{
/* Already handled in generic_agent */
continue;
}
if (GetVariable("control_agent", cp->lval, &retval) == DATA_TYPE_NONE)
{
CfOut(cf_error, "", "Unknown lval %s in agent control body", cp->lval);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_maxconnections].lval) == 0)
{
CFA_MAXTHREADS = (int) Str2Int(retval.item);
CfOut(cf_verbose, "", "SET maxconnections = %d\n", CFA_MAXTHREADS);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_checksum_alert_time].lval) == 0)
{
CF_PERSISTENCE = (int) Str2Int(retval.item);
CfOut(cf_verbose, "", "SET checksum_alert_time = %d\n", CF_PERSISTENCE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_agentfacility].lval) == 0)
{
SetFacility(retval.item);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_agentaccess].lval) == 0)
{
ACCESSLIST = (Rlist *) retval.item;
CheckAgentAccess(ACCESSLIST, InputFiles(policy));
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_refresh_processes].lval) == 0)
{
Rlist *rp;
if (VERBOSE)
{
printf("%s> SET refresh_processes when starting: ", VPREFIX);
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
printf(" %s", (char *) rp->item);
PrependItem(&PROCESSREFRESH, rp->item, NULL);
}
printf("\n");
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_abortclasses].lval) == 0)
{
Rlist *rp;
CfOut(cf_verbose, "", "SET Abort classes from ...\n");
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
char name[CF_MAXVARSIZE] = "";
strncpy(name, rp->item, CF_MAXVARSIZE - 1);
AddAbortClass(name, cp->classes);
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_abortbundleclasses].lval) == 0)
{
Rlist *rp;
CfOut(cf_verbose, "", "SET Abort bundle classes from ...\n");
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
char name[CF_MAXVARSIZE] = "";
strncpy(name, rp->item, CF_MAXVARSIZE - 1);
if (!IsItemIn(ABORTBUNDLEHEAP, name))
{
AppendItem(&ABORTBUNDLEHEAP, name, cp->classes);
}
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_addclasses].lval) == 0)
{
Rlist *rp;
CfOut(cf_verbose, "", "-> Add classes ...\n");
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
CfOut(cf_verbose, "", " -> ... %s\n", ScalarValue(rp));
NewClass(rp->item, NULL);
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_auditing].lval) == 0)
{
CfOut(cf_verbose, "", "This option does nothing and is retained for compatibility reasons");
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_alwaysvalidate].lval) == 0)
{
ALWAYS_VALIDATE = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET alwaysvalidate = %d\n", ALWAYS_VALIDATE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_allclassesreport].lval) == 0)
{
ALLCLASSESREPORT = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET allclassesreport = %d\n", ALLCLASSESREPORT);
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_secureinput].lval) == 0)
{
CFPARANOID = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET secure input = %d\n", CFPARANOID);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_binarypaddingchar].lval) == 0)
{
CfOut(cf_verbose, "", "binarypaddingchar is obsolete and does nothing\n");
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_bindtointerface].lval) == 0)
{
strncpy(BINDINTERFACE, retval.item, CF_BUFSIZE - 1);
CfOut(cf_verbose, "", "SET bindtointerface = %s\n", BINDINTERFACE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_hashupdates].lval) == 0)
{
bool enabled = GetBoolean(retval.item);
SetChecksumUpdates(enabled);
CfOut(cf_verbose, "", "SET ChecksumUpdates %d\n", enabled);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_exclamation].lval) == 0)
{
CfOut(cf_verbose, "", "exclamation control is deprecated and does not do anything\n");
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_childlibpath].lval) == 0)
{
char output[CF_BUFSIZE];
snprintf(output, CF_BUFSIZE, "LD_LIBRARY_PATH=%s", (char *) retval.item);
if (putenv(xstrdup(output)) == 0)
{
CfOut(cf_verbose, "", "Setting %s\n", output);
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_defaultcopytype].lval) == 0)
{
DEFAULT_COPYTYPE = (char *) retval.item;
CfOut(cf_verbose, "", "SET defaultcopytype = %s\n", DEFAULT_COPYTYPE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_fsinglecopy].lval) == 0)
{
SINGLE_COPY_LIST = (Rlist *) retval.item;
CfOut(cf_verbose, "", "SET file single copy list\n");
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_fautodefine].lval) == 0)
{
SetFileAutoDefineList(ListRvalValue(retval));
CfOut(cf_verbose, "", "SET file auto define list\n");
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_dryrun].lval) == 0)
{
DONTDO = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET dryrun = %c\n", DONTDO);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_inform].lval) == 0)
{
INFORM = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET inform = %c\n", INFORM);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_verbose].lval) == 0)
{
VERBOSE = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET inform = %c\n", VERBOSE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_repository].lval) == 0)
{
SetRepositoryLocation(retval.item);
CfOut(cf_verbose, "", "SET repository = %s\n", ScalarRvalValue(retval));
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_skipidentify].lval) == 0)
{
bool enabled = GetBoolean(retval.item);
SetSkipIdentify(enabled);
CfOut(cf_verbose, "", "SET skipidentify = %d\n", (int) enabled);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_suspiciousnames].lval) == 0)
{
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
AddFilenameToListOfSuspicious(ScalarValue(rp));
CfOut(cf_verbose, "", "-> Considering %s as suspicious file", ScalarValue(rp));
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_repchar].lval) == 0)
{
char c = *(char *) retval.item;
SetRepositoryChar(c);
CfOut(cf_verbose, "", "SET repchar = %c\n", c);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_mountfilesystems].lval) == 0)
{
CF_MOUNTALL = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET mountfilesystems = %d\n", CF_MOUNTALL);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_editfilesize].lval) == 0)
{
EDITFILESIZE = Str2Int(retval.item);
CfOut(cf_verbose, "", "SET EDITFILESIZE = %d\n", EDITFILESIZE);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_ifelapsed].lval) == 0)
{
VIFELAPSED = Str2Int(retval.item);
CfOut(cf_verbose, "", "SET ifelapsed = %d\n", VIFELAPSED);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_expireafter].lval) == 0)
{
VEXPIREAFTER = Str2Int(retval.item);
CfOut(cf_verbose, "", "SET ifelapsed = %d\n", VEXPIREAFTER);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_timeout].lval) == 0)
{
CONNTIMEOUT = Str2Int(retval.item);
CfOut(cf_verbose, "", "SET timeout = %jd\n", (intmax_t) CONNTIMEOUT);
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_max_children].lval) == 0)
{
CFA_BACKGROUND_LIMIT = Str2Int(retval.item);
CfOut(cf_verbose, "", "SET MAX_CHILDREN = %d\n", CFA_BACKGROUND_LIMIT);
if (CFA_BACKGROUND_LIMIT > 10)
{
CfOut(cf_error, "", "Silly value for max_children in agent control promise (%d > 10)",
CFA_BACKGROUND_LIMIT);
CFA_BACKGROUND_LIMIT = 1;
}
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_syslog].lval) == 0)
{
CfOut(cf_verbose, "", "SET syslog = %d\n", GetBoolean(retval.item));
continue;
}
if (strcmp(cp->lval, CFA_CONTROLBODY[cfa_environment].lval) == 0)
{
Rlist *rp;
CfOut(cf_verbose, "", "SET environment variables from ...\n");
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
if (putenv(rp->item) != 0)
{
CfOut(cf_error, "putenv", "Failed to set environment variable %s", ScalarValue(rp));
}
}
continue;
}
}
}
if (GetVariable("control_common", CFG_CONTROLBODY[cfg_lastseenexpireafter].lval, &retval) != DATA_TYPE_NONE)
{
LASTSEENEXPIREAFTER = Str2Int(retval.item) * 60;
}
if (GetVariable("control_common", CFG_CONTROLBODY[cfg_fips_mode].lval, &retval) != DATA_TYPE_NONE)
{
FIPS_MODE = GetBoolean(retval.item);
CfOut(cf_verbose, "", "SET FIPS_MODE = %d\n", FIPS_MODE);
}
if (GetVariable("control_common", CFG_CONTROLBODY[cfg_syslog_port].lval, &retval) != DATA_TYPE_NONE)
{
SetSyslogPort(Str2Int(retval.item));
CfOut(cf_verbose, "", "SET syslog_port to %s", ScalarRvalValue(retval));
}
if (GetVariable("control_common", CFG_CONTROLBODY[cfg_syslog_host].lval, &retval) != DATA_TYPE_NONE)
{
SetSyslogHost(Hostname2IPString(retval.item));
CfOut(cf_verbose, "", "SET syslog_host to %s", Hostname2IPString(retval.item));
}
#ifdef HAVE_NOVA
Nova_Initialize();
#endif
}
void CheckOpts(int argc,char **argv)
{ extern char *optarg;
char arg[CF_BUFSIZE],*sp;
int optindex = 0;
int c,alpha = false,v6 = false;
/* Because of the MacOS linker we have to call this from each agent
individually before Generic Initialize */
POLICY_SERVER[0] = '\0';
while ((c=getopt_long(argc,argv,"rd:vnKIf:D:N:Vs:x:MBb:",OPTIONS,&optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
if (optarg == NULL)
{
FatalError(" -f used but no argument");
}
if (optarg && strlen(optarg) < 5)
{
snprintf(arg,CF_MAXVARSIZE," -f used but argument \"%s\" incorrect",optarg);
FatalError(arg);
}
strncpy(VINPUTFILE,optarg,CF_BUFSIZE-1);
MINUSF = true;
break;
case 'b':
if (optarg)
{
CBUNDLESEQUENCE = SplitStringAsRList(optarg,',');
CBUNDLESEQUENCE_STR = optarg;
}
break;
case 'd':
NewClass("opt_debug");
switch ((optarg==NULL) ? '3' : *optarg)
{
case '1':
D1 = true;
DEBUG = true;
break;
case '2':
D2 = true;
DEBUG = true;
break;
default:
DEBUG = true;
break;
}
break;
case 'B':
BOOTSTRAP = true;
MINUSF = true;
IGNORELOCK = true;
NewClass("bootstrap_mode");
break;
case 's':
// temporary assure that network functions are working
OpenNetwork();
strncpy(POLICY_SERVER,Hostname2IPString(optarg),CF_BUFSIZE-1);
CloseNetwork();
for (sp = POLICY_SERVER; *sp != '\0'; sp++)
{
if (isalpha(*sp))
{
alpha = true;
}
if (ispunct(*sp) && *sp != ':' && *sp != '.')
{
alpha = true;
}
if (*sp == ':')
{
v6 = true;
}
}
if (alpha && !v6)
{
FatalError("Error specifying policy server. The policy server's IP address could not be looked up. Please use the IP address instead if there is no error.");
}
break;
case 'K':
IGNORELOCK = true;
break;
case 'D': NewClassesFromString(optarg);
break;
case 'N': NegateClassesFromString(optarg,&VNEGHEAP);
break;
case 'I': INFORM = true;
break;
case 'v': VERBOSE = true;
break;
case 'n': DONTDO = true;
IGNORELOCK = true;
NewClass("opt_dry_run");
break;
case 'V':
PrintVersionBanner("cf-agent");
exit(0);
case 'h':
Syntax("cf-agent - cfengine's change agent",OPTIONS,HINTS,ID);
exit(0);
case 'M':
ManPage("cf-agent - cfengine's change agent",OPTIONS,HINTS,ID);
exit(0);
case 'x':
AgentDiagnostic(optarg);
exit(0);
case 'r':
SHOWREPORTS = true;
break;
default: Syntax("cf-agent - cfengine's change agent",OPTIONS,HINTS,ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(cf_error,"","Unexpected argument with no preceding option: %s\n",argv[optind]);
FatalError("Aborted");
}
Debug("Set debugging\n");
}
