char *ServerFindServers(void **ctx, char *wild_match)
{
#ifndef HAVE_WINDOWS_H
char *ans = 0;
DIR *dir = (DIR *)*ctx;
if (dir == 0)
{
char *serverdir = getenv("MDSIP_SERVER_LOGDIR");
if (serverdir)
*ctx = dir = opendir(serverdir);
}
if (dir)
{
int done = 0;
while (!done)
{
struct dirent *entry = readdir(dir);
done = 1;
if (entry)
{
static char *ans_c = 0;
if (ans_c)
free(ans_c);
ans_c = strcpy(malloc(strlen(entry->d_name)+1),entry->d_name);
if ((strcmp(ans_c,".") == 0) || (strcmp(ans_c,"..") == 0))
done = 0;
else
{
struct descriptor ans_d = {0,DTYPE_T,CLASS_S,0};
struct descriptor wild_d = {0,DTYPE_T,CLASS_S,0};
ans_d.pointer = ans_c;
ans_d.length = strlen(ans_c);
wild_d.pointer = wild_match;
wild_d.length = strlen(wild_match);
if (!(StrMatchWild(&ans_d,&wild_d) & 1))
done = 0;
else
ans = ans_c;
}
}
else
closedir(dir);
}
}
return ans;
#else
return 0;
#endif
}
/*****************************************************
Routine to return a new tag search data structure.
******************************************************/
static TAG_SEARCH *NewTagSearch(char *tagnam_ptr)
{
static DESCRIPTOR(top, "TOP");
static DESCRIPTOR(colons, "::");
TAG_SEARCH *ctx = (TAG_SEARCH *) malloc(sizeof(TAG_SEARCH));
static struct descriptor_d empty = {0, DTYPE_T, CLASS_D, 0};
struct descriptor tag_dsc = {0, DTYPE_T, CLASS_S, 0};
unsigned short tree_len;
char *cptr;
static unsigned short one = 1;
tag_dsc.length = strlen(tagnam_ptr);
tag_dsc.pointer = tagnam_ptr;
ctx->search_tag = empty;
ctx->search_tree = empty;
ctx->next_tag = -1;
ctx->this_tree_info = 0;
ctx->remote = 0;
if (*(char *) tag_dsc.pointer == '\\')
{
tag_dsc.length--;
(char *) tag_dsc.pointer++;
}
if ((cptr = strstr(tagnam_ptr,"::")) != 0)
{
tree_len = cptr - tagnam_ptr;
StrCopyR(&ctx->search_tree, &tree_len, tag_dsc.pointer);
tag_dsc.length -= (tree_len + 2);
tag_dsc.pointer += (tree_len + 2);
}
else
StrCopyR(&ctx->search_tree, &one, "*");
if (tag_dsc.length)
StrCopyDx(&ctx->search_tag, &tag_dsc);
else
StrCopyR(&ctx->search_tag, &one, "*");
StrUpcase(&ctx->search_tree,&ctx->search_tree);
StrUpcase(&ctx->search_tag,&ctx->search_tag);
ctx->top_match = StrMatchWild(&top, &ctx->search_tag) & 1;
return ctx;
}
/********************************************
Routine to return the next subtree in this
tree which matches the wildcard tree spec.
*********************************************/
static int NextTagTree(PINO_DATABASE *dblist, TAG_SEARCH *ctx)
{
unsigned char found = 0;
if (ctx->this_tree_info == (TREE_INFO *) 0)
ctx->this_tree_info = dblist->tree_info;
else
ctx->this_tree_info = ctx->this_tree_info->next_info;
for (found = 0; !found && ctx->this_tree_info; ctx->this_tree_info = ctx->this_tree_info->next_info)
{
struct descriptor treenam = {0, DTYPE_T, CLASS_S, 0};
treenam.length = strlen(ctx->this_tree_info->treenam);
treenam.pointer = ctx->this_tree_info->treenam;
if (StrMatchWild(&treenam, &ctx->search_tree) & 1)
{
found = 1;
break;
}
}
if (found)
return 1;
else
return TreeNMT;
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
int ShowModule()
{
char db_tmp[64]; // enough space for a logical name and a cstring terminator [2002.02.20]
int i, numOfEntries, status = SUCCESS;
static DESCRIPTOR( physical, "PHYSICAL" );
static DESCRIPTOR( module_p, "MODULE" );
static DESCRIPTOR( format_p, "FORMAT" );
static DESCRIPTOR( blank, " " );
static DESCRIPTOR( heading1, " # Logical Name Physical Comment" ); // header
static DESCRIPTOR( heading2, "==== ================================ ========== ========================================" );
static DYNAMIC_DESCRIPTOR( wild );
struct Module_ Mod, *pMod;
struct descriptor pattern;
int format = cli_present(&format_p) & 1;
int physical_name = cli_present(&physical) & 1; // 2002.01.16
cli_get_value( &module_p, &wild );
StrUpcase( &wild, &wild ); // convert to upper case
if( MSGLVL(DETAILS) )
printf("ShowModule(): in %s order\n", (physical_name) ? "physical" : "logical" );
// check to see if db file memory mapped
if( CTSdbFileIsMapped == FALSE ) { // is not, so try
if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water
if( MSGLVL(IMPORTANT) )
fprintf( stderr, "error memory mapping database file\n" );
status = FAILURE; // MAP_ERROR; [2001.07.12]
goto Showmodule_Exit;
}
}
// db file now mapped, continue
pMod = &Mod; // point to some actual storage
if( (numOfEntries = get_file_count(CTS_DB)) > 0 ) { // something to show
printf( "%s\n", heading1.pointer );
printf( "%s%d\n", heading2.pointer, numOfEntries );
for( i = 0; i < numOfEntries; i++ ) {
parse_cts_db( CTSdb+i, pMod ); // extract info from db
memset(db_tmp, ' ', 32);
db_tmp[33] = '\0';
if( physical_name ) // duh, physical name
sprintf( db_tmp, "GK%c%d%02d:N%d",
pMod->adapter + 'A', pMod->id, pMod->crate, pMod->slot
);
else
sprintf( db_tmp, "%s", pMod->name );
pattern.pointer = db_tmp;
pattern.length = strlen(db_tmp);
if( StrMatchWild( &pattern, &wild ) & 1 ) {
// printf( "%s%3d: %.84s<%s\n", CYAN, i+1, (char *)CTSdb+(i * MODULE_ENTRY), NORMAL ); // fancy, with color
printf( "%3d: %.84s<\n", i+1, (char *)CTSdb+(i * MODULE_ENTRY) );
}
} // end of for() loop
printf( "%s\n", heading2.pointer );
}
else {
if( MSGLVL(IMPORTANT) )
fprintf( stderr, "db file is empty, no modules to show\n" );
status = SUCCESS; // Not necessarily an ERROR; [2002.02.19]
goto Showmodule_Exit;
}
Showmodule_Exit:
if( MSGLVL(DETAILS) ) {
printf("ShowModule(): "); ShowStatus(status);
}
return status;
}
//-------------------------------------------------------------------------
// deassign a module
//-------------------------------------------------------------------------
int Deassign()
{
char db_tmp[64];
int i, index, modulesToDeassign, modulesDeassigned, numOfEntries, physical_name;
int status = SUCCESS;
struct Module_ Mod, *pMod;
static DESCRIPTOR( physical, "PHYSICAL" );
static DESCRIPTOR( modname_p, "MODULE" );
static DYNAMIC_DESCRIPTOR( modname );
static DYNAMIC_DESCRIPTOR( wild );
struct descriptor pattern;
// get user data
cli_get_value( &modname_p, &wild );
StrUpcase( &wild, &wild );
physical_name = cli_present(&physical) & 1;
if( MSGLVL(DETAILS) )
printf("Deassign(): %s module: <%s>\n", physical_name ? "physical" : "logical", wild.pointer);
// check to see if db file memory mapped
if( CTSdbFileIsMapped == FALSE ) { // is not, so try ...
if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water
status = MAP_ERROR; // [2002.02.21]
goto Deassign_Exit;
}
}
// get number of current entries
if( (numOfEntries = get_file_count(CTS_DB)) == 0 ) { // no entries in cts db file
if( MSGLVL(IMPORTANT) )
fprintf( stderr, "db file empty, no entries to remove\n" );
status = DEASSIGN_ERROR; // [2002.02.21]
goto Deassign_Exit;
}
// if we get this far, then there are modules in the database
modulesToDeassign = modulesDeassigned = 0; // initialize counts
pMod = &Mod; // point to some actual storage
// first, we need to count the number to deassign ...
for( i = 0; i < numOfEntries; ++i ) { // scan entire list
// look up module name(s). NB! more than one logical name may be
// assigned to the same, unique physical name.
parse_cts_db( CTSdb+i, pMod ); // extract info from db
memset(db_tmp, ' ', 32); // clear out buffer
db_tmp[33] = '\0'; // ensure buffer 'ends'
if( physical_name ) // physical name
sprintf( db_tmp, "GK%c%d%02d:N%d",
pMod->adapter + 'A',
pMod->id,
pMod->crate,
pMod->slot
);
else // logical name
sprintf( db_tmp, "%s", pMod->name );
// prepare for 'wild' match
pattern.pointer = db_tmp;
pattern.length = strlen(db_tmp);
if( StrMatchWild( &pattern, &wild ) & 1 ) {
++modulesToDeassign; //
}
} // end of for() loop, all entries checked
// now actually remove them
while( modulesToDeassign ) {
for( i = 0; i < get_file_count(CTS_DB); ++i ) {
// look up module name(s). NB! more than one logical name may be
// assigned to the same, unique physical name.
parse_cts_db( CTSdb+i, pMod ); // extract info from db
memset(db_tmp, ' ', 32); // clear out buffer
db_tmp[33] = '\0'; // ensure buffer 'ends'
if( physical_name ) // physical name
sprintf( db_tmp, "GK%c%d%02d:N%d",
pMod->adapter + 'A',
pMod->id,
pMod->crate,
pMod->slot
);
else // logical name
sprintf( db_tmp, "%s", pMod->name );
// prepare for 'wild' match
pattern.pointer = db_tmp;
pattern.length = strlen(db_tmp);
if( StrMatchWild( &pattern, &wild ) & 1 ) {
if( remove_entry(CTS_DB, i) != SUCCESS ) { // removal failed
status = DEASSIGN_ERROR; // [2002.02.21]
goto Deassign_Exit;
}
else
++modulesDeassigned; // keep track of successes :)
}
}
--modulesToDeassign; // one less to remove ...
}
Deassign_Exit:
if( MSGLVL(DETAILS) ) {
printf("Deassign(%d): ", modulesDeassigned); ShowStatus(status);
}
return status;
}
char *_TreeFindTagWild(void *dbid, char *wild, int *nidout, void **ctx_inout)
{
PINO_DATABASE *dblist = (PINO_DATABASE *)dbid;
/***************************
check that there is a tree
open.
****************************/
if (!IS_OPEN(dblist))
return NULL;
if (dblist->remote)
return FindTagWildRemote(dblist,wild,nidout,ctx_inout);
else
{
NID *nid_ptr = (NID *)nidout;
TAG_SEARCH **ctx = (TAG_SEARCH **)ctx_inout;
int status = 1;
unsigned char found,done;
static char answer[128];
/**********************************
If this is the first time then
allocate a context block and fill
it in with a parse of the tagname.
***********************************/
if (*ctx == (TAG_SEARCH *) 0)
{
*ctx = NewTagSearch(wild);
if (*ctx == (TAG_SEARCH *) 0)
status = TreeNMT;
else
status = NextTagTree(dblist, *ctx);
}
/*************************************
Loop looking for a tag that matches
**************************************/
for (found = 0, done = 0; (status & 1) && !found && !done;)
{
/*************************************
if out of tags in this tree then
see if there is another one
**************************************/
if ((*ctx)->next_tag >= (*ctx)->this_tree_info->header->tags)
{
status = NextTagTree(dblist, *ctx);
if (status & 1)
(*ctx)->next_tag = -1;
else
{
done = 1;
break;
}
}
else
{
/**********************************************
else if this is the first time for this tree
try to return the \TOP tag.
otherwise - move on to next tag for next
time through the loop.
***********************************************/
if ((*ctx)->next_tag == -1)
{
if ((*ctx)->top_match)
{
done = 1;
found = 1;
}
else
((*ctx)->next_tag)++;
}
else
{
/****************************************
Else
loop looking for a tag that matches
*****************************************/
for (; !done && ((*ctx)->next_tag < (*ctx)->this_tree_info->header->tags);)
{
unsigned short len;
static struct descriptor_s s_tag_dsc = { sizeof(TAG_NAME), DTYPE_T, CLASS_S, 0};
static struct descriptor_d tag_dsc = {0, DTYPE_T, CLASS_D, 0};
s_tag_dsc.pointer =
(char *) (*ctx)->this_tree_info->tag_info[swapint((char *)&(*ctx)->this_tree_info->tags[(*ctx)->next_tag])].name;
StrTrim(&tag_dsc, &s_tag_dsc,&len);
if (StrMatchWild(&tag_dsc, &((*ctx)->search_tag)) & 1)
{
done = 1;
found = 1;
}
else
((*ctx)->next_tag)++;
}
}
}
}
/********************************************
If done and found then fill in the answer
*********************************************/
if (found)
{
NODE *nptr = (*ctx)->this_tree_info->node;
static char tagname[sizeof(TAG_NAME)+1];
if ((*ctx)->next_tag != -1)
{
static struct descriptor_s s_tag_name = {sizeof(TAG_NAME), DTYPE_T, CLASS_S, 0};
static struct descriptor_s tag_name = {sizeof(TAG_NAME), DTYPE_T, CLASS_S, tagname};
unsigned short len;
s_tag_name.pointer =
(char *) (*ctx)->this_tree_info->tag_info[swapint((char *)&(*ctx)->this_tree_info->tags[(*ctx)->next_tag])].name;
StrTrim(&tag_name, &s_tag_name,&len);
tagname[len]='\0';
nptr += swapint(&(*ctx)->this_tree_info->tag_info[swapint((char *)&(*ctx)->this_tree_info->tags[(*ctx)->next_tag])].node_idx);
}
else
strcpy(tagname,"TOP");
strcpy(answer,"\\");
strcat(answer,(*ctx)->this_tree_info->treenam);
strcat(answer,"::");
strcat(answer,tagname);
if (nid_ptr)
node_to_nid(dblist, nptr, nid_ptr);
((*ctx)->next_tag)++;
status = 1;
}
else
{
TreeFindTagEnd(ctx_inout);
status = TreeNMT;
}
return (status & 1) ? answer : NULL;
}
}
