/***************************************************************** * TclSetCurrent: *****************************************************************/ int TclSetCurrent() { int sts; char *experiment; static int shot; static DESCRIPTOR_LONG(dsc_shot,&shot); static DYNAMIC_DESCRIPTOR(dsc_experiment); static DYNAMIC_DESCRIPTOR(dsc_asciiShot); cli_get_value("EXPERIMENT",&dsc_experiment); experiment = dsc_experiment.dscA_pointer; if (cli_present("INCREMENT") & 1) { shot = TreeGetCurrentShotId(experiment); shot++; sts = TreeSetCurrentShotId(experiment,shot); } else { cli_get_value("SHOT",&dsc_asciiShot); #ifdef vms dsc_asciiShot.dscB_class = CLASS_S; /* vms: malloc vs str$ */ sts = TdiExecute(&dsc_asciiShot,&dsc_shot MDS_END_ARG); dsc_asciiShot.dscB_class = CLASS_D; #else sts = TdiExecute(&dsc_asciiShot,&dsc_shot MDS_END_ARG); #endif if (sts & 1) sts = TreeSetCurrentShotId(experiment,shot); } if ((sts & 1) != 1) MdsMsg(sts,0); return sts; }
/*************************************************************** * TclEdit: * Open tree for edit ***************************************************************/ int TclEdit() { int shot; int sts; static DYNAMIC_DESCRIPTOR(dsc_filnam); static DYNAMIC_DESCRIPTOR(dsc_asciiShot); cli_get_value("FILE",&dsc_filnam); cli_get_value("SHOTID",&dsc_asciiShot); sscanf(dsc_asciiShot.dscA_pointer,"%d",&shot); if (cli_present("NEW") & 1) sts = TreeOpenNew(dsc_filnam.dscA_pointer,shot); else sts = TreeOpenEdit(dsc_filnam.dscA_pointer,shot); if (sts & 1) TclNodeTouched(0,tree); else { sts = MdsMsg(sts,"Error opening tree-file %s for EDIT", dsc_filnam.dscA_pointer); #ifdef vms lib$signal(sts,0); #endif } return sts; }
/* **++ ** ROUTINE: main ** ** FUNCTIONAL DESCRIPTION: ** ** Main program. Fetches the command from the command line, ** uses CLI$ routines to parse it, then starts the build process. ** ** RETURNS: cond_value, longword (unsigned), write only, by value ** ** PROTOTYPE: ** ** main ** ** IMPLICIT INPUTS: See global definitions at module head. ** ** IMPLICIT OUTPUTS: See global definitions at module head. ** ** COMPLETION CODES: ** ** SS$_NORMAL, MMK__ALLOK : normal successful completion. ** ** SIDE EFFECTS: None. ** **-- */ unsigned int main (void) { DESCRIP cmdstr; char Output_File[256], tmp[256]; $DESCRIPTOR(cmdname, "MMKC "); unsigned int status; int i; /* ** Initialize the globals */ temporary_symbols = 0; for (i = 0; i < MMK_K_SYMTABLE_SIZE; i++) { INIT_QUEUE(global_symbols.symlist[i]); INIT_QUEUE(local_symbols.symlist[i]); INIT_QUEUE(cmdline_symbols.symlist[i]); INIT_QUEUE(builtin_symbols.symlist[i]); } INIT_QUEUE(rules); INIT_QUEUE(dependencies); INIT_QUEUE(dep_internal); INIT_QUEUE(dep_deferred); INIT_QUEUE(suffixes); INIT_QUEUE(do_first); INIT_QUEUE(do_last); exit_status = SS$_NORMAL; ignore = override_silent = override_ignore = symbol_override = 0; skip_intermediates = 0; /* ** Fetch and parse command string */ INIT_DYNDESC(cmdstr); status = lib$get_foreign(&cmdstr); str$prefix(&cmdstr, &cmdname); status = cli$dcl_parse(&cmdstr, MMK_COMPILE_RULES_CLD, lib$get_input, lib$get_input); if (!OK(status)) return (status | STS$M_INHIB_MSG); /* ** Get the command parameters and qualifiers */ Output_File[0] = '\0'; if (cli_present("OUTPUT") == CLI$_PRESENT) { cli_get_value("OUTPUT", Output_File, sizeof(Output_File)); } status = cli_get_value("RULES_FILE", tmp, sizeof(tmp)); if (!OK(status)) return status | STS$M_INHIB_MSG; Read_Description(tmp, "SYS$DISK:[].MMS", 1); if (OK(exit_status)) Generate_Structures(tmp, Output_File); return exit_status | STS$M_INHIB_MSG; }
int mdsdcl_set_command( /* Return: status */ struct _mdsdcl_ctrl *ctrl /* <m> the control structure */ ) { int sts; void *newTable; static DYNAMIC_DESCRIPTOR(dsc_table); /*------------------------------------------------------ * Get tablename and find its address in shared library ... *-----------------------------------------------------*/ sts = cli_get_value("TABLE",&dsc_table); if (sts & 1) { int i; for (i=0;i<dsc_table.dscW_length;i++) dsc_table.dscA_pointer[i] = _tolower(dsc_table.dscA_pointer[i]); if (!strstr(dsc_table.dscA_pointer,"_commands")) str_concat(&dsc_table,&dsc_table,"_commands",0); sts = LibFindImageSymbol(&dsc_table,&dsc_table,&newTable); if (~sts & 1) return(MdsMsg(sts,"Failed to open table %s", dsc_table.dscA_pointer)); /*------------------------------------------------------ *... add newTable address to "tbladr[]" list *-----------------------------------------------------*/ for (i=0 ; i<ctrl->tables ; i++) if (newTable == ctrl->tbladr[i]) break; if (i == ctrl->tables) { if (ctrl->tables >= MAX_TABLES) { fprintf(stderr,"set_command: *WARN* Max_tables exceeded\n"); return(0); } ctrl->tbladr[ctrl->tables++] = newTable; } } /*------------------------------------------------------ * Check for other qualifiers ... *-----------------------------------------------------*/ if (cli_present("HELPLIB") & 1) cli_get_value("HELPLIB",&ctrl->helplib); if (cli_present("PROMPT") & 1) cli_get_value("PROMPT",&ctrl->prompt); if (cli_present("DEF_FILE") & 1) cli_get_value("DEF_FILE",&ctrl->def_file); return(1); }
/*************************************************************** * TclClose: * Close tree file(s). ***************************************************************/ int TclClose() { int sts; static const char promptWritefirst[] = "This tree has been modified, write it before closing? [Y]: "; static DYNAMIC_DESCRIPTOR(exp); static DYNAMIC_DESCRIPTOR(dsc_shotid); int shotid; if (cli_get_value("FILE",&exp) & 1) { cli_get_value("SHOTID",&dsc_shotid); sscanf(dsc_shotid.dscA_pointer,"%d",&shotid); sts = TreeClose(exp.dscA_pointer,shotid); } else { int doall = cli_present("ALL") & 1; while ((sts = TreeClose(0,0)) & 1 && doall); if (doall && sts == TreeNOT_OPEN) sts = TreeNORMAL; } if (sts == TreeWRITEFIRST) { if (cli_present("CONFIRM") == CLI_STS_NEGATED) sts = TreeQuitTree(0,0); else { printf(promptWritefirst); if (yesno(1)) { sts = TreeWriteTree(0,0); if (sts & 1) { TreeClose(0,0); } } else sts = TreeQuitTree(0,0); } } if (sts & 1) TclNodeTouched(0,tree); else MdsMsg(sts,"TclClose: *WARN* unexpected status"); return sts; }
/*************************************************************** * TclShowAttribute: ***************************************************************/ int TclShowAttribute() { int status; int nid; EMPTYXD(xd); static DYNAMIC_DESCRIPTOR(dsc_node); static DYNAMIC_DESCRIPTOR(dsc_attr); static DYNAMIC_DESCRIPTOR(dsc_string); cli_get_value("NODE",&dsc_node); status = TreeFindNode(dsc_node.dscA_pointer,&nid); if (status & 1) { status = cli_get_value("NAME",&dsc_attr); if (status & 1) { status = TreeGetXNci(nid,dsc_attr.dscA_pointer,&xd); if (status & 1) { status = TdiDecompile(&xd,&dsc_string MDS_END_ARG); if (status & 1) { char *p = malloc(dsc_string.dscW_length+1); strncpy(p,dsc_string.dscA_pointer,dsc_string.dscW_length); p[dsc_string.dscW_length]='\0'; TclTextOut(p); free(p); } StrFree1Dx(&dsc_string); MdsFree1Dx(&xd,0); } } else { if (TreeGetXNci(nid,"attributenames",&xd)&1) { TdiSortVal(&xd,&xd MDS_END_ARG); if (xd.dscA_pointer && xd.dscA_pointer->dscB_class == CLASS_A) { typedef ARRAY(char) ARRAY_DSC; ARRAY_DSC *array=(ARRAY_DSC *)xd.dscA_pointer; char *name=array->dscA_pointer; TclTextOut("Defined attributes for this node:"); for (name=array->dscA_pointer;name<array->dscA_pointer+array->dscL_arsize;name+=array->dscW_length) { char *out=malloc(array->dscW_length+6); sprintf(out," %.*s",array->dscW_length,name); TclTextOut(out); free(out); } } else { TclTextOut("No attributes defined for this node"); } MdsFree1Dx(&xd,0); } else {
//------------------------------------------------------------------------- // Delete a crate from the crate db //------------------------------------------------------------------------- int DelCrate() { char crateName[CRATE_NAME_SIZE + 1]; int index, numOfEntries; int status = SUCCESS; static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); // get user input str_free1_dx(&phy_name); // per twf -- clear out field cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); // trim it... sprintf(crateName, "%.6s", phy_name.pointer); // check to see if db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water status = FAILURE; // MAP_ERROR; [2001.07.12] goto DelCrate_Exit; } } // get number of current entries if( (numOfEntries = get_file_count(CRATE_DB)) == 0 ) { // no entries in crate db file if( MSGLVL(IMPORTANT) ) fprintf( stderr, "db file empty, no entries to remove\n" ); status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } // try to remove from crate.db if( (index = lookup_entry(CRATE_DB, crateName)) >= 0 ) { // module does exist if( remove_entry(CRATE_DB, index) != SUCCESS ) { // removal failed status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } } else { // no such module if( MSGLVL(IMPORTANT) ) fprintf( stderr, "delcrate(): entry '%s' not found\n", crateName); status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } DelCrate_Exit: if( MSGLVL(DETAILS) ) { printf("DelCrate() status = %d\n", status); } return SUCCESS; }
/**************************************************************** * mdsdcl_define: * Define an mds macro ... ****************************************************************/ int mdsdcl_define() /* Return: status */ { int i,k; int sts; char name[32]; char *p; struct _mdsdcl_macro *m; static DYNAMIC_DESCRIPTOR(dsc_name); static DYNAMIC_DESCRIPTOR(dsc_cmd); static char fmt1[] = "Macro '%s' is open -- cannot be edited"; sts = cli_get_value("P1",&dsc_name); if (~sts & 1) return(sts); k = dsc_name.dscW_length; if (k >= sizeof(name)) k = sizeof(name) - 1; l2un(name,dsc_name.dscA_pointer,k); name[k] = '\0'; /*======================================================= * Get addr of macro struct. Delete any existing lines ... *======================================================*/ m = get_macro(name); if (m->isOpen) return(MdsMsg(MDSDCL_STS_ERROR,fmt1,m->name)); for (i=0 ; i<m->numLines ; i++) free(m->lines[i]); m->numLines = 0; /*====================================================== * Read new macro from input ... *=====================================================*/ for ( ; (sts = mdsdcl_get_input_nosymbols("DEFMAC> ",&dsc_cmd)) & 1 ; ) { if ((dsc_cmd.dscW_length > 0) && dsc_cmd.dscA_pointer) p = nonblank(dsc_cmd.dscA_pointer); else p = 0; if (!p || end_macro(p)) { break; } if (m->numLines >= m->maxLines) extend_macro(m); m->lines[m->numLines++] = STRING_ALLOC(dsc_cmd.dscA_pointer); } return(1); }
/***************************************************************** * TclAddTag: * Add a tag name to a node *****************************************************************/ int TclAddTag() /* Return: status */ { int nid; int sts; static DYNAMIC_DESCRIPTOR(dsc_nodnam); static DYNAMIC_DESCRIPTOR(dsc_tagnam); cli_get_value("NODE",&dsc_nodnam); cli_get_value("TAGNAME",&dsc_tagnam); l2u(dsc_nodnam.dscA_pointer,0); l2u(dsc_tagnam.dscA_pointer,0); sts = TreeFindNode(dsc_nodnam.dscA_pointer,&nid); if (sts & 1) sts = TreeAddTag(nid,dsc_tagnam.dscA_pointer); if (!(sts & 1)) { MdsMsg(sts,"Error adding tag %s",dsc_tagnam.dscA_pointer); #ifdef vms lib$signal(sts,0); #endif } return sts; }
void lke_setgdr(void) { gd_region *r_top; mval reset; bool def; short len; char buf[256]; int4 rundown_status = EXIT_NRM; /* if gds_rundown went smoothly */ static readonly char init_gdr[] = "gtmgbldir"; gvcmy_rundown(); gv_cur_region = gd_header->regions; r_top = gv_cur_region + gd_header->n_regions; for (gv_cur_region = gd_header->regions, r_top = gv_cur_region + gd_header->n_regions; gv_cur_region < r_top; gv_cur_region++) { tp_change_reg(); UNIX_ONLY(rundown_status |=) gds_rundown(); } if (EXIT_NRM != rundown_status) rts_error(VARLSTCNT(1) ERR_NOTALLDBRNDWN); if (cli_present("gld")) { cli_get_value("gld", buf) ; def = FALSE; reset.mvtype = MV_STR; reset.str.len = STRLEN(buf); reset.str.addr = buf; } else { reset.mvtype = MV_STR; reset.str.len = SIZEOF(init_gdr) - 1; reset.str.addr = init_gdr; } zgbldir(&reset); cs_addrs = 0; cs_data = 0; region_init(FALSE) ; #ifndef MUTEX_MSEM_WAKE mutex_sock_cleanup(); #endif gtmsecshr_sock_cleanup(CLIENT); }
//------------------------------------------------------------------------- //------------------------------------------------------------------------- int ResetHighway() { int status; static DESCRIPTOR( crate_p, "MODULE" ); static DYNAMIC_DESCRIPTOR( wild ); static DYNAMIC_DESCRIPTOR( crate ); cli_get_value( &crate_p, &wild ); if( MSGLVL(DETAILS) ) printf("ResetHighway() invoked -- not implemented\n"); return SUCCESS; }
//------------------------------------------------------------------------- // set a crate on-line or off-line //------------------------------------------------------------------------- int SetCrate() { int status; char *cratename; void *ctx=0; static DESCRIPTOR( crate_p, "CRATE" ); static DESCRIPTOR( quietq, "QUIET" ); static DYNAMIC_DESCRIPTOR( wild ); static DYNAMIC_DESCRIPTOR( crate ); static DESCRIPTOR( offq, "OFFLINE" ); static DESCRIPTOR( onq, "ONLINE" ); int off = cli_present(&offq) & 1; int on = cli_present(&onq ) & 1; int quiet = cli_present(&quietq) & 1; cli_get_value( &crate_p, &wild ); str_upcase( &wild, &wild ); // check to see if db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping crate db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto SetCrate_Exit; } } while (find_crate(wild.pointer,&cratename,&ctx)) { status = turn_crate_on_off_line( cratename , (on) ? ON : OFF ); if (!(status & 1) && !quiet) printf("Error turning crate %s %s\n",cratename,on ? "online" : "offline"); free(cratename); } find_crate_end(&ctx); SetCrate_Exit: return SUCCESS; }
/* * -------------------------------------------------- * Find the qualifier and convert it to 64 bit unsigned decimal number. * * Return: * TRUE - OK * FALSE - Could not convert to hex * -------------------------------------------------- */ boolean_t cli_get_uint64(char *entry, gtm_uint64_t *dst) { char buf[MAX_LINE]; char local_str[MAX_LINE]; assert(strlen(entry) > 0); strncpy(local_str, entry, SIZEOF(local_str) - 1); if ((cli_present(local_str) == CLI_PRESENT) && cli_get_value(local_str, buf)) { if (!cli_str_to_uint64(buf, dst)) { FPRINTF(stderr, "Error: cannot convert %s value to 64-bit unsigned decimal number.\n", buf); return FALSE; } return TRUE; } return FALSE; }
/***************************************************************** * mdsdcl_show_macro: *****************************************************************/ int mdsdcl_show_macro() /* Return: status */ { int i; int full; int sts; struct _mdsdcl_macro *m; static DYNAMIC_DESCRIPTOR(dsc_name); struct _mdsdcl_ctrl *ctrl = &MdsdclGetThreadStatic()->ctrl; sts = cli_get_value("MACRO",&dsc_name); if (sts & 1) { l2u(dsc_name.dscA_pointer,0); m = find_macro(dsc_name.dscA_pointer); if (!m) { fprintf(stderr," --> macro '%s' not defined\n\r", dsc_name.dscA_pointer); return(1); } display_macro(m); return(1); } /*======================================================= * List all defined macros ... *======================================================*/ full = cli_present("FULL") & 1; m = ctrl->macro.list; if (!m) { fprintf(stderr," --> No macros defined\n\n\r"); return(1); } for (i=0 ; i<ctrl->macro.numMacros ; i++,m++) { if (full) display_macro(m); else printf(" %s\n\r",m->name); } return(1); }
/* * -------------------------------------------------- * Find the qualifier and convert it to decimal number * unless 0x prefix. * * Return: * TRUE - OK * FALSE - Could not convert to number * -------------------------------------------------- */ boolean_t cli_get_num(char *entry, int4 *dst) { char buf[MAX_LINE]; char local_str[MAX_LINE]; assert(strlen(entry) > 0); strncpy(local_str, entry, SIZEOF(local_str) - 1); if (cli_present(local_str) == CLI_PRESENT && cli_get_value(local_str, buf)) { if (!cli_str_to_num(buf, dst)) { FPRINTF(stderr, "Error: cannot convert %s string to number.\n", buf); return FALSE; } return TRUE; } return FALSE; }
/**************************************************************** * TclDirectoryTag: * Perform directory of all of the tags ****************************************************************/ int TclDirectoryTag() { int sub_total; int grand_total; char *nodename; char *tagnam; char text[40]; void *ctx; static DYNAMIC_DESCRIPTOR(dsc_tagnam); static DYNAMIC_DESCRIPTOR(dsc_outLine); sub_total = grand_total = 0; while (cli_get_value("TAG",&dsc_tagnam) & 1) { tagnam = dsc_tagnam.dscA_pointer; l2u(tagnam,0); ctx = 0; sub_total = 0; TclTextOut(" "); sprintf(text,"Tag listing for %s",tagnam); TclTextOut(text); TclTextOut(" "); while ((nodename = TreeFindTagWild(tagnam,0,&ctx))) { TclTextOut(nodename); sub_total++; } TreeFindTagEnd(&ctx); grand_total += sub_total; sprintf(text,"Total of %d tags\n",sub_total); TclTextOut(text); } if (grand_total != sub_total) { sprintf(text,"Grand Total of %d tags\n",sub_total); TclTextOut(text); } return 1; }
//------------------------------------------------------------------------- // 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; }
//------------------------------------------------------------------------- //------------------------------------------------------------------------- // show crate status, using crates in 'crate.db' file //------------------------------------------------------------------------- int ShowCrate() { char colorENH[9], colorON[9]; char tmp[7]; char tmp2[11]; int enhanced, i, j, online, moduleFound, numOfCrates, numOfModules; int crateStatus; int status; struct Crate_ Cr8, *pCr8; struct Module_ Mod, *pMod; static DESCRIPTOR( crate_p, "MODULE" ); static DESCRIPTOR( heading1, " CRATE ONL LAM PRV ENH" ); static DESCRIPTOR( heading2, "======= === === === ===" ); static DYNAMIC_DESCRIPTOR( wild ); static DYNAMIC_DESCRIPTOR( crate ); if( ScsiSystemStatus() == 0 ) { status = SUCCESS; // this is the function's status printf("scsi system is %sdown!%s\n", RED, NORMAL); goto ShowCrate_Exit; } if( MSGLVL(DETAILS) ) printf("scsi system is %sup!%s\n", GREEN, NORMAL); // user input cli_get_value( &crate_p, &wild ); str_upcase( &wild, &wild ); // check to see if crate db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping crate.db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto ShowCrate_Exit; } } // check to see if module 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 cts.db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto ShowCrate_Exit; } } printf( "%s\n", heading1.pointer ); // header printf( "%s\n", heading2.pointer ); // header pCr8 = &Cr8; // point to some actual storage pMod = &Mod; // get number of crates in db file if( (numOfCrates = get_file_count(CRATE_DB)) > 0 ) { // possibly something to show if( (numOfModules = get_file_count(CTS_DB)) > 0 ) { // maybe some crates controllers .. for( i = 0; i < numOfCrates; i++ ) { parse_crate_db(CRATEdb+i, pCr8); if( wildcard_match( wild.pointer, pCr8->name, 0,0,0 ) ) { // moduleFound = FALSE; // // for( j = 0; j < numOfModules; ++j ) { // parse_cts_db(CTSdb+j, pMod); // sprintf(tmp, "GK%c%d%02d", // pMod->adapter + 'A', // pMod->id, // pMod->crate // ); // // if( strcmp(tmp, pCr8->name) == EQUAL ) { // if( pMod->slot == 30 ) { // found a crate controller // moduleFound = TRUE; // break; // } // } // } // end of for(modules) ... moduleFound = TRUE; if( moduleFound ) { crateStatus = 0; if(MSGLVL(8)) printf("checking '%s'\n", pCr8->name); status = get_crate_status(pCr8->name, &crateStatus); if( MSGLVL(DETAILS) ) printf("gcs(%s) returned %d, crate 0x%x\n", pCr8->name, status, crateStatus); if( status == SUCCESS ) { // online = !(crateStatus & 0x3c00) ? TRUE : FALSE; // [2002.12.09] // online = !(crateStatus & 0x1000) ? TRUE : FALSE; // [2002.12.09] online = ((crateStatus & 0x1000) != 0x1000) ? TRUE : FALSE; // [2002.12.09] if( !crateStatus || crateStatus == 0x3 ) // [2001.09.10] // [2002.12.09] online = FALSE; // [2002.12.09] sprintf(colorON, "%s", (online) ? GREEN : RED); // enhanced = (online && (crateStatus & 0x4030)) ? TRUE : FALSE; // [2002.12.09] enhanced = (online && (crateStatus & 0x4000)) ? TRUE : FALSE; // [2002.12.09] sprintf(colorENH, "%s", (enhanced) ? GREEN : RED); printf("%s: %s%c%s . . %s%c%s", pCr8->name, colorON, (online) ? '*' : 'X', NORMAL, colorENH, (enhanced) ? '*' : '-', NORMAL ); if( MSGLVL(4) ) printf( " 0x%04x", crateStatus ); printf("\n"); } } // end of if(moduleFound) ... else { printf("%.6s: . . . .\n", pCr8->name); } } // end of if(wildcard) ... } // end of for(crates) ... } // crates, but no modules (ie no controllers) } printf( "%s\n", heading2.pointer ); // header status = SUCCESS; // always (???) ShowCrate_Exit: return status; }
/**************************************************************** * TclSetNode: ****************************************************************/ int TclSetNode() { int nid; int status; int log; int usageMask; void *ctx = 0; char *nodename; static DYNAMIC_DESCRIPTOR(dsc_nodename); static DYNAMIC_DESCRIPTOR(dsc_status); cli_get_value("NODENAME",&dsc_nodename); cli_get_value("STATUS",&dsc_status); nodename = dsc_nodename.dscA_pointer; l2u(nodename,0); log = cli_present("LOG") & 1; usageMask = -1; while ((status = TreeFindNodeWild(nodename,&nid,&ctx,usageMask)) & 1) { if (dsc_status.dscA_pointer) { int statval = atoi(dsc_status.dscA_pointer); NCI_ITM setnci[] = {{sizeof(int), NciSTATUS, 0, 0},{0,NciEND_OF_LIST,0,0}}; setnci[0].pointer = (unsigned char *)&statval; TreeSetNci(nid,setnci); } switch (cli_present("SUBTREE")) { case CLI_STS_PRESENT: status = TreeSetSubtree(nid); break; case CLI_STS_NEGATED: status = TreeSetNoSubtree(nid); break; } if (!(status & 1)) goto error; if (cli_present("ON") & 1) { status = TreeTurnOn(nid); if (status & 1) TclNodeTouched(nid,on_off); else TclErrorOut(status); } else if (cli_present("OFF") & 1) { status = TreeTurnOff(nid); if (status & 1) TclNodeTouched(nid,on_off); else TclErrorOut(status); } if (!(status & 1)) goto error; { int set_flags; int clear_flags; DYNAMIC_DESCRIPTOR(dsc_path); NCI_ITM get_itmlst[] = { {0,NciPATH,(unsigned char *) &dsc_path,0}, {0,NciEND_OF_LIST}}; NCI_ITM set_itmlst[] = { {0,NciSET_FLAGS,(unsigned char *) &set_flags,0}, {0,NciEND_OF_LIST}}; NCI_ITM clear_itmlst[] = { {0,NciCLEAR_FLAGS,(unsigned char *) &clear_flags,0}, {0,NciEND_OF_LIST}}; set_flags = 0; clear_flags = 0; switch (cli_present("WRITE_ONCE")) { case CLI_STS_PRESENT: set_flags |= NciM_WRITE_ONCE; break; case CLI_STS_NEGATED: clear_flags |= NciM_WRITE_ONCE; break; } switch (cli_present("CACHED")) { case CLI_STS_PRESENT: set_flags |= NciM_CACHED; break; case CLI_STS_NEGATED: clear_flags |= NciM_CACHED; break; } switch (cli_present("COMPRESS_ON_PUT")) { case CLI_STS_PRESENT: set_flags |= NciM_COMPRESS_ON_PUT; break; case CLI_STS_NEGATED: clear_flags |= NciM_COMPRESS_ON_PUT; break; } switch (cli_present("COMPRESS_SEGMENTS")) { case CLI_STS_PRESENT: set_flags |= NciM_COMPRESS_SEGMENTS; break; case CLI_STS_NEGATED: clear_flags |= NciM_COMPRESS_SEGMENTS; break; } switch (cli_present("DO_NOT_COMPRESS")) { case CLI_STS_PRESENT: set_flags |= NciM_DO_NOT_COMPRESS; break; case CLI_STS_NEGATED: clear_flags |= NciM_DO_NOT_COMPRESS; break; } switch (cli_present("SHOT_WRITE")) { case CLI_STS_PRESENT: clear_flags |= NciM_NO_WRITE_SHOT; break; case CLI_STS_NEGATED: set_flags |= NciM_NO_WRITE_SHOT; break; } switch (cli_present("MODEL_WRITE")) { case CLI_STS_PRESENT: clear_flags |= NciM_NO_WRITE_MODEL; break; case CLI_STS_NEGATED: set_flags |= NciM_NO_WRITE_MODEL; break; } switch (cli_present("INCLUDED")) { case CLI_STS_PRESENT: set_flags |= NciM_INCLUDE_IN_PULSE; break; case CLI_STS_NEGATED: clear_flags |= NciM_INCLUDE_IN_PULSE; break; } switch (cli_present("ESSENTIAL")) { case CLI_STS_PRESENT: set_flags |= NciM_ESSENTIAL; break; case CLI_STS_NEGATED: clear_flags |= NciM_ESSENTIAL; break; } if (set_flags) status = TreeSetNci(nid,set_itmlst); if (clear_flags) status = TreeSetNci(nid,clear_itmlst); if (status & 1) { if (log) { TreeGetNci(nid,get_itmlst); str_concat(&dsc_path,"Node: ",&dsc_path," modified",0); TclTextOut(dsc_path.dscA_pointer); str_free1_dx(&dsc_path); } } else goto error; } } TreeFindNodeEnd(&ctx); if (status == TreeNNF) goto error; return 1; error: #ifdef vms lib$signal(status,0); #else MdsMsg(status,0); #endif return status; }
bool cli_get_parm(char *entry, char val_buf[]) { char *sp; int ind; int match_ind, res; char local_str[MAX_LINE]; int eof; char *gets_res; int parm_len; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; ind = 0; assert(0 != gpcmd_parm_vals); STRNCPY_STR(local_str, entry, SIZEOF(local_str) - 1); cli_strupper(local_str); match_ind = -1; while (0 < strlen(sp = (gpcmd_parm_vals + ind)->name)) /* implicit assignment intended */ { if (0 == (res = STRNCMP_STR(sp, local_str, MAX_OPT_LEN))) /* implicit assignment intended */ { if (-1 != match_ind) return (FALSE); else match_ind = ind; } else { if (0 < res) break; } ind++; } if (-1 != match_ind) { if (NULL == TAREF1(parm_ary, match_ind)) { if (!((gpcmd_parm_vals + match_ind)->parm_required)) /* Value not required */ return FALSE; /* If no value and required, prompt for it */ PRINTF("%s", (gpcmd_parm_vals + match_ind)->prompt); fflush(stdout); gets_res = cli_fgets(local_str, MAX_LINE, stdin, FALSE); if (gets_res) { parm_len = STRLEN(gets_res); /* chop off newline */ if (parm_len && (local_str[parm_len - 1] == '\n')) { local_str[parm_len - 1] = '\0'; --parm_len; } TAREF1(parm_str_len, match_ind) = parm_len + 1; GROW_HEAP_IF_NEEDED(match_ind); if (parm_len) memcpy(TAREF1(parm_ary, match_ind), &local_str[0], parm_len); *(TAREF1(parm_ary, match_ind) + parm_len) = '\0'; } else { /* No string was returned so create a real ghost to point to. Note that this should be revisited since this is NOT what should be happening. We should be returning FALSE here but need to instead return a null parm since current behaviors have a dependency on it SE 10/2003 */ TAREF1(parm_str_len, match_ind) = 1; GROW_HEAP_IF_NEEDED(match_ind); *TAREF1(parm_ary, match_ind) = '\0'; } } else if (-1 == *TAREF1(parm_ary, match_ind) && 1 == TAREF1(parm_str_len, match_ind)) return (FALSE); strcpy(val_buf, TAREF1(parm_ary, match_ind)); if (!cli_look_next_token(&eof) || (0 == cli_gettoken(&eof))) { TAREF1(parm_str_len, match_ind) = 1; GROW_HEAP_IF_NEEDED(match_ind); *TAREF1(parm_ary, match_ind) = -1; } else { parm_len = STRLEN(cli_token_buf) + 1; if (MAX_LINE < parm_len) { PRINTF("Parameter string too long\n"); fflush(stdout); return (FALSE); } TAREF1(parm_str_len, match_ind) = parm_len; GROW_HEAP_IF_NEEDED(match_ind); memcpy(TAREF1(parm_ary, match_ind), cli_token_buf, parm_len); } } else { /* ----------------- * check qualifiers * ----------------- */ if (!cli_get_value(local_str, val_buf)) return (FALSE); } return (TRUE); }
/**************************************************************** * TclDoMethod: ****************************************************************/ int TclDoMethod() { int i; int argc; int sts; unsigned char do_it; struct descriptor_xd xdarg[255]; static int nid; static unsigned short boolVal; static struct descriptor_s bool_dsc = {sizeof(boolVal), DTYPE_W, CLASS_S, (char *)&boolVal}; static struct descriptor nid_dsc = {4,DTYPE_NID,CLASS_S,(char *)&nid}; static struct descriptor_xd empty_xd = {0,DTYPE_DSC,CLASS_XD,0,0}; static DYNAMIC_DESCRIPTOR(arg); static DYNAMIC_DESCRIPTOR(if_clause); static DYNAMIC_DESCRIPTOR(method); static DYNAMIC_DESCRIPTOR(object); static void *arglist[256] = {(void *)2,&nid_dsc,&method}; cli_get_value("OBJECT",&object); sts = TreeFindNode(object.dscA_pointer,&nid); if (sts & 1) { do_it = (TreeIsOn(nid) | cli_present("OVERRIDE")) & 1; if (cli_present("IF") & 1) { cli_get_value("IF",&if_clause); sts = TdiExecute(&if_clause,&bool_dsc MDS_END_ARG); if (sts & 1) do_it = do_it && boolVal; else do_it = 0; } if (do_it) { int dometh_stat; DESCRIPTOR_LONG(dometh_stat_d,0); cli_get_value("METHOD",&method); argc = 0; if (cli_present("ARGUMENT") & 1) { while (cli_get_value("ARGUMENT",&arg) & 1) { xdarg[argc] = empty_xd; sts = TdiCompile(&arg,&xdarg[argc] MDS_END_ARG); if (sts & 1) { arglist[argc + 3] = xdarg[argc].dscA_pointer; argc++; } else break; } } if (sts & 1) { #ifdef vms arglist[0] = (void *)(argc + 2); #else dometh_stat_d.dscA_pointer = (char *)&dometh_stat; arglist[argc+3] = &dometh_stat_d; arglist[argc+4] = MdsEND_ARG; arglist[0] = (argc + 4)+(char *)0; #endif sts = (char *)LibCallg(arglist,TreeDoMethod)-(char *)0; if (sts & 1) sts = dometh_stat; } str_free1_dx(&arg); str_free1_dx(&method); for (i = 0; i < argc; i++) MdsFree1Dx(&xdarg[i],NULL); } } str_free1_dx(&object); #ifdef vms if (!(sts & 1)) lib$signal(sts,0); #else if (!(sts & 1)) { char msg[512]; sprintf(msg,"Error executing method - %s",MdsGetMsg(sts)); TclTextOut(msg); } #endif return sts; }
/**************************************************************** * TclDirectory: * Perform directory function ****************************************************************/ int TclDirectory() { unsigned int usage; char *tagnam; char textLine[128]; static char fmtTotal[] = "Total of %d node%s."; static char fmtGrandTotal[] = "Grand total of %d node%s."; static DYNAMIC_DESCRIPTOR(dsc_nodnam); static DYNAMIC_DESCRIPTOR(dsc_nodeList); static DYNAMIC_DESCRIPTOR(dsc_outline); char *pathnam; int nid; int status; void *ctx = 0; void *ctx2 = 0; int found = 0; int grand_found = 0; int first_tag; int full; static int nodnamLen; static int retlen; int last_parent_nid = -1; int version; static int parent_nid; static char nodnamC[12+1]; static int relationship; int previous_relationship; static unsigned char nodeUsage; static NCI_ITM general_info_list[] = { {4,NciPARENT,&parent_nid,0} ,{12,NciNODE_NAME,nodnamC,&nodnamLen} ,{4,NciPARENT_RELATIONSHIP,&relationship,0} ,{1,NciUSAGE,&nodeUsage,0} ,{0,NciEND_OF_LIST,0,0} }; static int elmnt; static DYNAMIC_DESCRIPTOR(dsc_allUsage); static DYNAMIC_DESCRIPTOR(dsc_usageStr); int usageMask = -1; parent_nid = 0; full = cli_present("FULL") & 1; if (cli_present("USAGE") & 1) { usageMask = 0; str_free1_dx(&dsc_allUsage); while (cli_get_value("USAGE",&dsc_usageStr) & 1) { str_concat(&dsc_allUsage,&dsc_allUsage,&dsc_usageStr,",",0); str_concat(&dsc_usageStr,"USAGE.",&dsc_usageStr,0); if (cli_get_value(&dsc_usageStr,&dsc_usageStr) & 1) { sscanf(dsc_usageStr.dscA_pointer,"%d",&usage); usageMask = usageMask | (1 << usage); } else MdsMsg(0,"Error getting usage id#",0); } } str_free1_dx(&dsc_outline); while (cli_get_value("NODE",&dsc_nodeList) & 1) { l2u(dsc_nodeList.dscA_pointer,0); for (elmnt=0; str_element(&dsc_nodnam,elmnt,',',&dsc_nodeList) & 1; elmnt++) { while ((status = TreeFindNodeWild(dsc_nodnam.dscA_pointer,&nid,&ctx,usageMask)) & 1) { grand_found++; status = TreeGetNci(nid,general_info_list); nodnamC[nodnamLen] = '\0'; if (parent_nid != last_parent_nid) { if (found) { if (!full && dsc_outline.dscW_length) { TclTextOut(dsc_outline.dscA_pointer); str_free1_dx(&dsc_outline); } TclTextOut(" "); sprintf(textLine,fmtTotal,found,(found>1)?"s":""); TclTextOut(textLine); } TclTextOut(" "); pathnam = TreeGetPath(parent_nid); TclTextOut(pathnam); TreeFree(pathnam); /* free the string */ TclTextOut(" "); found = 0; last_parent_nid = parent_nid; previous_relationship = relationship; } found++; if (full) { if (previous_relationship != relationship) { TclTextOut(" "); previous_relationship = relationship; } if (relationship == NciK_IS_CHILD) str_concat(&dsc_outline," ",nodnamC,0); else str_concat(&dsc_outline," :",nodnamC,0); ctx2 = 0; first_tag = 1; while (tagnam = TreeFindNodeTags(nid,&ctx2)) { str_concat(&dsc_outline,&dsc_outline, (first_tag?" tags: \\":",\\"),tagnam,0); TreeFree(tagnam); first_tag = 0; } TclTextOut(dsc_outline.dscA_pointer); str_free1_dx(&dsc_outline); version=0; while(doFull(nid,nodeUsage,version++)&1); #ifdef vms else lib$signal(status,0); #endif } else { if (previous_relationship != relationship) { TclTextOut(dsc_outline.dscA_pointer); str_free1_dx(&dsc_outline); TclTextOut(" "); previous_relationship = relationship; } if (relationship == NciK_IS_CHILD) str_concat(&dsc_outline, &dsc_outline," ",nodnamC,0); else str_concat(&dsc_outline, &dsc_outline," :",nodnamC,0); if (dsc_outline.dscW_length > 60) { TclTextOut(dsc_outline.dscA_pointer); str_free1_dx(&dsc_outline); } } } TreeFindNodeEnd(&ctx); }
/**************************************************************** * mdsdcl_do_macro: ****************************************************************/ int mdsdcl_do_macro() /* Return: status */ { int i; int icnt; int irepeat; int sts; char prmName[4]; struct _mdsdcl_io *io; struct _mdsdcl_macro *macro; static DYNAMIC_DESCRIPTOR(dsc_util); static char fmt0[] = "Qualifier not supported: use '@'"; static char fmt1[] = "No such command: '%s'"; static char fmt2[] = "Macro '%s' is already in use"; static char fmt3[] = "Exceeded MAX_DEPTH for indirect files & macros"; struct _mdsdcl_ctrl *ctrl = &MdsdclGetThreadStatic()->ctrl; sts = cli_get_value("NAME",&dsc_util); if (~sts & 1) return(MdsMsg(MDSDCL_STS_ERROR,"Error getting NAME")); if (cli_present("INTERACTIVE") & 1) return(MdsMsg(MDSDCL_STS_ERROR,fmt0,0)); if (cli_present("INDIRECT") & 1) { sts = mdsdcl_openIndirectLevel(dsc_util.dscA_pointer); if (!sts & 1) return(MdsMsg(sts,"failed to open file %s",dsc_util.dscA_pointer)); for ( ; sts & 1 ; ) sts = mdsdcl_do_command(0); return((sts==MDSDCL_STS_INDIRECT_EOF) ? 1 : sts); } l2u(dsc_util.dscA_pointer,0); /* convert to uc */ macro = find_macro(dsc_util.dscA_pointer); if (!macro) { MdsMsg(0,"No such command"); return(MDSDCL_STS_ERROR); } if (macro->isOpen) return(MdsMsg(MDSDCL_STS_ERROR,fmt2,dsc_util.dscA_pointer)); /*======================================================= * Get repeat count ... *======================================================*/ sts = cli_get_value("REPEAT",&dsc_util); if (sts & 1) { if (sscanf(dsc_util.dscA_pointer,"%d",&irepeat) != 1) irepeat = 1; } else irepeat = 1; /*======================================================== * Create new ioLevel[] in ctrl struct ... *=======================================================*/ if (ctrl->depth >= MAX_DEPTH) return(MdsMsg(MDSDCL_STS_INDIRECT_ERROR,fmt3,0)); for (icnt=0 ; icnt<irepeat ; icnt++) { macro->isOpen = 1; io = ctrl->ioLevel + ++ctrl->depth; io->fp = 0; io->ioMacro = macro; io->lineno = 0; for (i=0 ; i<8 ; i++) { sprintf(prmName,"P%d",i+1); sts = cli_get_value(prmName,io->ioParameter+i); if (~sts & 1) break; } for ( ; i<8 ; i++) str_free1_dx(io->ioParameter+i); do { sts = mdsdcl_do_command(0); } while (sts & 1); if (sts == MDSDCL_STS_INDIRECT_EOF) continue; else break; } return((sts==MDSDCL_STS_INDIRECT_EOF) ? 1 : sts); }
//------------------------------------------------------------------------- // Add a crate to the crate db //------------------------------------------------------------------------- int AddCrate() { char line[CRATE_ENTRY + 1]; int dbFileSize, fd, numOfEntries; int status = SUCCESS; // assume the best static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); // get user input str_free1_dx(&phy_name); // per twf -- clear out field cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); // [2002.01.08] if( CRATEdbFileIsMapped == FALSE ) { // ... no if( check_for_file(CRATE_DB_FILE) != SUCCESS ) { // ... no if( (fd = Creat(CRATE_DB_FILE, 0666)) == ERROR ) { // no status = FAILURE; goto AddCrate_Exit; } else close(fd); // yes } if( map_data_file(CRATE_DB) != SUCCESS ) { // failure :( status = MAP_ERROR; goto AddCrate_Exit; } // else OK :) } // get current db file count if( (numOfEntries = get_file_count(CRATE_DB)) == FILE_ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto AddCrate_Exit; } if( numOfEntries ) { // 1 or more char pname[7]; sprintf(pname,"%.6s",phy_name.pointer); if( lookup_entry(CRATE_DB, pname) >= 0 ) { // duplicate ! if( MSGLVL(IMPORTANT) ) fprintf( stderr, "duplicate crate name '%.6s' -- not allowed\n", phy_name.pointer ); status = FAILURE; // DUPLICATE; [2001.07.12] goto AddCrate_Exit; } } // get db file size if( (dbFileSize = get_db_file_size(CRATE_DB_FILE)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto AddCrate_Exit; } dbFileSize /= CRATE_ENTRY; // .. current maximum number of possible crate entries // do we need to expand db file? if( (dbFileSize == 0) || (numOfEntries == dbFileSize) ) { // ... yes if( (status = expand_db(CRATE_DB, numOfEntries)) != SUCCESS ) { // expand status = FAILURE; // EXPAND_ERROR; [2001.07.12] // failure goto AddCrate_Exit; } } // else OK // make an entry line, with online and enhanced set as undefined sprintf( line, "%-.6s:...:.:.:.\n", phy_name.pointer ); // add it ... if( (status = add_entry(CRATE_DB, line)) != SUCCESS ) { status = FAILURE; // ASSIGN_ERROR; [2001.07.12] goto AddCrate_Exit; } AddCrate_Exit: if( MSGLVL(DETAILS) ) { printf("AddCrate(): "); ShowStatus(status); } if( status == SUCCESS ) // if everything is OK ... Autoconfig(); // ... map crate to /dev/sg# //ShowCrate(); return status; }
//------------------------------------------------------------------------- //------------------------------------------------------------------------- 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; }
//------------------------------------------------------------------------- // assign a new module to CTS database //------------------------------------------------------------------------- int Assign() { char line[MODULE_ENTRY+1]; int dbFileSize, fd, i, nullMask, numOfEntries, rc; int status = SUCCESS; // assume the best static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); static DESCRIPTOR( log_name_p, "LOG_NAME" ); static DYNAMIC_DESCRIPTOR( log_name ); static DESCRIPTOR( comment_p, "COMMENT" ); static DYNAMIC_DESCRIPTOR( comment ); // get user input cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); cli_get_value( &log_name_p, &log_name ); str_upcase( &log_name, &log_name ); str_free1_dx(&comment); // per twf -- clear out comment field cli_get_value( &comment_p, &comment ); // check to see if db file exists if( check_for_file(CTS_DB_FILE) != SUCCESS ) { // does not exist, yet // try to creat (sic) it if( (fd = Creat(CTS_DB_FILE, 0666)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; // we're done :< } else close(fd); } // check to see if db file is memory mapped if( CTSdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water status = FAILURE; // MAP_ERROR; [2001.07.12] goto Assign_Exit; } } // get current db file count if( (numOfEntries = get_file_count(CTS_DB)) < 0 ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } if( numOfEntries ) { // 1 or more if( lookup_entry(CTS_DB, log_name.pointer) >= 0 ) { // duplicate ! if( MSGLVL(IMPORTANT) ) fprintf( stderr, "duplicate module name '%s' -- not allowed\n", log_name.pointer ); status = FAILURE; // DUPLICATE; [2001.07.12] goto Assign_Exit; } } // get db file size if( (dbFileSize = get_db_file_size(CTS_DB_FILE)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } dbFileSize /= MODULE_ENTRY; // .. current maximum number of possible module entries // do we need to expand db file? if( (dbFileSize == 0) || (numOfEntries == dbFileSize) ) { // ... yes if( expand_db(CTS_DB, numOfEntries) != SUCCESS ) { // expand ... status = FAILURE; // EXPAND_ERROR; [2001.07.12] // ... failure goto Assign_Exit; } } // else OK // create a temporary string sprintf( line, "%-32s %-10s %-40s\n", log_name.pointer, // these were entered by the user phy_name.pointer, comment.pointer ? comment.pointer : "" ); // check comment field for null string, ie "(null)" nullMask = (1 << strlen(nullStr)) - 1; // set all mask bits for( i = COMMENT_INDEX; i < COMMENT_INDEX + strlen(nullStr); ++i ) if( line[i] == nullStr[i - COMMENT_INDEX] ) nullMask &= ~(1 << (i - COMMENT_INDEX)); // clear a bit in mask if( nullMask == 0 ) // all mask bit have been reset, ie matched for( i = COMMENT_INDEX; i < COMMENT_INDEX + strlen(nullStr); ++i ) line[i] = ' '; // make it spaces // add it ... if( add_entry(CTS_DB, line) != SUCCESS ) { status = FAILURE; // ASSIGN_ERROR; [2001.07.12] goto Assign_Exit; } #if NEED_WARM_N_FUZZY // write to a buffer file for a warm fuzzy ... if( (fd = Creat("buffer.db", 0666)) == ERROR ) { if( MSGLVL(ALWAYS) ) perror("creat()"); status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } rc = write(fd, line, sizeof(line)); close(fd); if( rc != sizeof(line) ) { if( MSGLVL(ALWAYS) ) perror("write()"); status = FAILURE; // FILE_ERROR; [2001.07.12] } #endif Assign_Exit: // we're done, so out'a here! if( MSGLVL(DETAILS) ) { printf("Assign(): "); ShowStatus(status); } return status; }