static int db_odbc_discovery(DC_ITEM *item, AGENT_REQUEST *request, AGENT_RESULT *result)
{
const char *__function_name = "db_odbc_discovery";
int ret = NOTSUPPORTED, i, j;
ZBX_ODBC_DBH dbh;
ZBX_ODBC_ROW row;
char **columns, *p, macro[MAX_STRING_LEN];
struct zbx_json json;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() query:'%s'", __function_name, item->params);
if (2 != request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters."));
goto out;
}
if (SUCCEED != odbc_DBconnect(&dbh, request->params[1], item->username, item->password, CONFIG_TIMEOUT))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror()));
goto out;
}
if (NULL != odbc_DBselect(&dbh, item->params))
{
columns = zbx_malloc(NULL, sizeof(char *) * dbh.col_num);
if (SUCCEED == get_result_columns(&dbh, columns))
{
for (i = 0; i < dbh.col_num; i++)
zabbix_log(LOG_LEVEL_DEBUG, "%s() column[%d]:'%s'", __function_name, i + 1, columns[i]);
for (i = 0; i < dbh.col_num; i++)
{
for (p = columns[i]; '\0' != *p; p++)
{
if (0 != isalpha((unsigned char)*p))
*p = toupper((unsigned char)*p);
if (SUCCEED != is_macro_char(*p))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL,
"Cannot convert column #%d name to macro.", i + 1));
goto clean;
}
}
for (j = 0; j < i; j++)
{
if (0 == strcmp(columns[i], columns[j]))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL,
"Duplicate macro name: {#%s}.", columns[i]));
goto clean;
}
}
}
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
while (NULL != (row = odbc_DBfetch(&dbh)))
{
zbx_json_addobject(&json, NULL);
for (i = 0; i < dbh.col_num; i++)
{
zbx_snprintf(macro, MAX_STRING_LEN, "{#%s}", columns[i]);
zbx_json_addstring(&json, macro, row[i], ZBX_JSON_TYPE_STRING);
}
zbx_json_close(&json);
}
zbx_json_close(&json);
SET_STR_RESULT(result, zbx_strdup(NULL, json.buffer));
zbx_json_free(&json);
ret = SUCCEED;
clean:
for (i = 0; i < dbh.col_num; i++)
zbx_free(columns[i]);
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain column names."));
zbx_free(columns);
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror()));
odbc_DBclose(&dbh);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static void scan_script( void )
{
inputcb * cb;
mac_entry * me;
char * p;
char * pt;
int toklen;
int k;
bool cwfound;
cb = input_cbs;
p = scan_start + 1;
scan_restart = scan_start;
if( (*p == '*') || !strnicmp( p, "cm ", 3 ) ) {
scan_start = scan_stop + 1; // .cm +++ ignore comment up to EOL
return; // .* +++ ignore comment up to EOL
}
if( *p == SCR_char && *(p+1) == SCR_char ) {
pt = token_buf;
*pt++ = SCR_char; // special for ...label
*pt++ = SCR_char;
*pt = '\0';
me = NULL;
scan_start = p + 2;
toklen = 2;
} else {
if( *p == '\'' ) { // .'
p++;
ProcFlags.CW_sep_ignore = 1;
} else {
if( CW_sep_char == '\0') {
ProcFlags.CW_sep_ignore = 1;// No separator char no split
} else{
ProcFlags.CW_sep_ignore = 0;
}
if( *p == SCR_char ) { // ..
p++;
ProcFlags.macro_ignore = 1;
me = NULL;
} else {
ProcFlags.macro_ignore = 0;
}
}
if( ProcFlags.literal ) { // no macro or split line if literal
ProcFlags.CW_sep_ignore = 1;
ProcFlags.macro_ignore = 1;
}
if( !ProcFlags.CW_sep_ignore ) { // scan line for CW_sep_char
char * pchar;
pchar = search_separator( buff2, CW_sep_char );
if( pchar != NULL ) {
if( *(pchar + 1) != '\0' ) { // only split if more follows
split_input( buff2, pchar + 1, false );// ignore CW_sep_char
}
*pchar= '\0'; // delete CW_sep_char
buff2_lg = strlen( buff2 ); // new length of first part
}
}
scan_start = p;
pt = token_buf;
while( *p && is_macro_char( *p ) ) { // end of controlword
*pt++ = tolower( *p++ ); // copy lowercase to TokenBuf
}
*pt = '\0';
toklen = pt - token_buf;
if( *p && (*p != ' ') || toklen == 0 ) {// no valid script controlword / macro
// if( !ProcFlags.literal ) { // TBD
// cw_err();
// }
scan_start = scan_restart; // treat as text
return;
}
if( toklen >= MAC_NAME_LENGTH ) {
*(token_buf + MAC_NAME_LENGTH) = '\0';
}
if( !ProcFlags.macro_ignore ) {
me = find_macro( macro_dict, token_buf );
} else {
me = NULL;
}
}
if( me != NULL ) { // macro found
if( GlobalFlags.firstpass && cb->fmflags & II_research ) {
if( cb->fmflags & II_macro ) {
printf_research( "L%d %c%s macro found in macro %s(%d)\n\n",
inc_level, SCR_char, token_buf,
cb->s.m->mac->name, cb->s.m->lineno );
} else {
printf_research( "L%d %c%s macro found in file %s(%d)\n\n",
inc_level, SCR_char, token_buf,
cb->s.f->filename, cb->s.f->lineno );
}
add_SCR_tag_research( token_buf );
}
add_macro_cb_entry( me, NULL );
inc_inc_level();
add_macro_parms( p );
scan_restart = scan_stop + 1;
} else { // try script controlword
cwfound = false;
if( cb->fmflags & II_research && GlobalFlags.firstpass ) {
if( cb->fmflags & II_macro ) {
printf_research( "L%d %c%s CW found in macro %s(%d)\n\n",
inc_level, SCR_char, token_buf,
cb->s.m->mac->name, cb->s.m->lineno );
} else {
printf_research( "L%d %c%s CW found in file %s(%d)\n\n",
inc_level, SCR_char, token_buf,
cb->s.f->filename, cb->s.f->lineno );
}
add_SCR_tag_research( token_buf );
}
if( toklen == SCR_KW_LENGTH ) {
for( k = 0; k < SCR_TAGMAX; ++k ) {
if( !strcmp( scr_tags[k].tagname, token_buf ) ) {
#if 0
if( !ProcFlags.fb_document_done &&
scr_tags[k].cwflags & cw_o_t ) {
/***************************************************/
/* if this is the first cw which produces output */
/* set page geometry and margins from layout */
/***************************************************/
do_layout_end_processing();
}
#endif
if( !ProcFlags.layout && (scr_tags[k].cwflags & cw_o_t) ) {
/********************************************************/
/* this is the first control word which produces output */
/* start the document, the layout is done */
/* start_doc_sect() calls do_layout_end_processing() */
/********************************************************/
start_doc_sect();
}
if( ProcFlags.literal ) { // .li active
if( !strcmp( token_buf, "li" ) ) { // .li
scan_start = p; // found, process
scr_tags[k].tagproc();
}
} else {
scan_start = p; // script controlword found, process
if( scr_tags[k].cwflags & cw_break ) {
scr_process_break();// output incomplete line, if any
}
scr_tags[k].tagproc();
}
cwfound = true;
break;
}
}
}
if( !cwfound ) {
cw_err(); // unrecognized control word
}
}
scan_start = scan_restart;
}
String parse_macro(Queue *repQueue, String macro) {
String buf = init_string();
Statement *s = NULL;
String temp = NULL;
char c;
char *p;
while (*macro) {
c = *macro;
if (c == PAREN_L) {
s = next_macro_statement(repQueue, macro);
p = strchr(macro, PAREN_R);
if (!p)
return NULL;
macro = p + 1;
temp = to_string_statement(s);
buf = dyna_strcat(buf, temp);
} else if (is_macro_char(c)) {
macro += strlen(macro_word(c));
p = strchr(macro, '[');
if (!p)
return NULL;
macro = p + 1;
s = next_macro_statement(repQueue, macro);
p = strchr(macro, ']');
if (!p)
return NULL;
macro = p + 1;
switch (c) {
case 'E':
temp = extract(s);
break;
case 'F':
temp = funcname(s);
if (temp == NULL)
return NULL;
break;
case 'T':
temp = target(s);
break;
case 'M':
temp = match(s);
break;
case 'A':
temp = arglist(s);
break;
default:
break;
}
buf = dyna_strcat(buf, temp);
} else if (c == '\\') {
macro++;
buf = append_char(buf, *macro);
if (*macro)
macro++;
} else {
buf = append_char(buf, *macro);
if (*macro)
macro++;
}
}
return buf;
}
void scr_gt( void )
{
char * p;
char * pn;
char savetag;
int k;
int len;
char macname[MAC_NAME_LENGTH + 1];
condcode cc;
gtentry * wk;
gtflags tag_flags;
enum {
f_add = 1,
f_change,
f_delete,
f_off,
f_on,
f_print
} function;
garginit(); // find end of CW
/***********************************************************************/
/* isolate tagname or use previous if tagname * */
/***********************************************************************/
cc = getarg(); // Tagname
if( cc == omit ) {
// no operands
tag_name_missing_err();
return;
}
p = tok_start;
if( *p == '*' ) { // single * as tagname
if( arg_flen > 1 ) {
xx_err( err_tag_name_inv );
return;
}
savetag = '*'; // remember for possible global delete / print
if( GlobalFlags.firstpass && input_cbs->fmflags & II_research ) {
if( tag_entry != NULL ) {
out_msg(" using tagname %s %s\n", tagname, tag_entry->name );
}
}
} else {
savetag = ' '; // no global function for delete / print
init_tag_att(); // forget previous values for quick access
attname[0] = '*';
pn = tagname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < TAG_NAME_LENGTH ) {
*pn++ = tolower( *p++ );// copy lowercase tagname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < TAG_NAME_LENGTH; k++ ) {
tagname[k] = '\0';
}
tagname[TAG_NAME_LENGTH] = '\0';
if( len < arg_flen ) {
xx_err( err_tag_name_inv );
return;
}
}
/***********************************************************************/
/* get function operand add, change, ... */
/***********************************************************************/
cc = getarg();
if( cc == omit ) {
xx_err( err_tag_func_inv );
return;
}
p = tok_start;
function = 0;
switch( tolower( *p ) ) {
case 'a':
if( !strnicmp( "ADD ", p, 4 ) ) {
function = f_add;
}
break;
case 'c' :
if( (arg_flen > 2) && (arg_flen < 7)
&& !strnicmp( "CHANGE", p, arg_flen ) ) {
function = f_change;
}
break;
case 'o' :
if( !strnicmp( "OFF", p, 3 ) ) {
function = f_off;
} else {
if( !strnicmp( "ON", p, 2 ) ) {
function = f_on;
}
}
break;
case 'd' :
if( (arg_flen > 2) && (arg_flen < 7)
&& !strnicmp( "DELETE", p, arg_flen ) ) {
function = f_delete;
}
break;
case 'p' :
if( (arg_flen > 1) && (arg_flen < 6)
&& !strnicmp( "PRINT", p, arg_flen ) ) {
function = f_print;
}
break;
default:
// nothing
break;
}
if( function == 0 ) { // no valid function specified
xx_err( err_tag_func_inv );
return;
}
cc = getarg(); // get possible next parm
/***********************************************************************/
/* for add and change get macroname */
/***********************************************************************/
if( function == f_add || function == f_change ) { // need macroname
if( cc == omit ) {
xx_err( err_tag_mac_name );
return;
}
p = tok_start;
pn = macname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < MAC_NAME_LENGTH ) {
*pn++ = tolower( *p++ ); // copy lowercase macroname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < MAC_NAME_LENGTH; k++ ) {
macname[k] = '\0';
}
macname[MAC_NAME_LENGTH] = '\0';
tag_flags = 0;
if( function == f_add ) { // collect tag options
cc = scan_tag_options( &tag_flags );
if( cc != omit ) { // not all processed error
xx_err( err_tag_opt_inv );
}
tag_entry = add_tag( &tag_dict, tagname, macname, tag_flags ); // add to dictionary
// if tag_entry is now NULL, error (+ msg) was output in add_tag
} else { // is function change
tag_entry = change_tag( &tag_dict, tagname, macname );
}
} else {
/***********************************************************************/
/* after delete, off, on, print nothing allowed */
/***********************************************************************/
if( cc != omit ) {
xx_err( err_tag_toomany ); // nothing more allowed
}
switch( function ) {
case f_print :
if( savetag == '*' ) {
print_tag_dict( tag_dict );
} else {
print_tag_entry( find_tag( &tag_dict, tagname ) );
}
break;
case f_delete :
if( savetag == '*' ) {
free_tag_dict( &tag_dict );
} else {
free_tag( &tag_dict, find_tag( &tag_dict, tagname ) );
}
break;
case f_off :
if( savetag == '*' && tag_entry != NULL ) {// off for last defined
tag_entry->tagflags |= tag_off;
} else {
wk = find_tag( &tag_dict, tagname );
if( wk != NULL ) {
wk->tagflags |= tag_off;
}
}
break;
case f_on :
if( savetag == '*' && tag_entry != NULL ) {// on for last defined
tag_entry->tagflags |= tag_off;
} else {
wk = find_tag( &tag_dict, tagname );
if( wk != NULL ) {
wk->tagflags &= ~tag_off;
}
}
break;
default:
break;
}
}
scan_restart = scan_stop +1;
return;
}
void scr_ga( void )
{
char * p;
char * pn;
char savetag;
char saveatt;
int k;
int len;
condcode cc;
gaflags att_flags;
gavalflags val_flags;
gavalentry * gaval;
gaentry * gawk;
savetag = ' ';
saveatt = ' ';
att_flags = 0;
val_flags = 0;
garginit(); // find end of CW
cc = getarg(); // Tagname or *
if( cc == omit || (*tok_start == '*' && tag_entry == NULL) ) {
// no operands or tagname * and no previous definition
tag_name_missing_err();
}
if( tag_entry == NULL ) { // error during previous .gt
scan_restart = scan_stop + 1; // ignore .ga
return;
}
/***********************************************************************/
/* isolate tagname use previous if tagname * */
/***********************************************************************/
p = tok_start;
if( *p == '*' ) { // single * as tagname
if( arg_flen > 1 ) {
xx_err( err_tag_name_inv );
return;
}
savetag = '*'; // remember for possible quick access
if( GlobalFlags.firstpass && input_cbs->fmflags & II_research ) {
out_msg(" using tagname %s\n", tagname );
}
} else {
savetag = ' '; // no quick access
init_tag_att(); // forget previous values for quick access
pn = tagname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < TAG_NAME_LENGTH ) {
*pn++ = tolower( *p++ );// copy lowercase tagname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < TAG_NAME_LENGTH; k++ ) {
tagname[k] = '\0';
}
tagname[TAG_NAME_LENGTH] = '\0';
if( len < arg_flen ) {
xx_err( err_tag_name_inv );// name contains invalid or too many chars
return;
}
tag_entry = find_tag( &tag_dict, tagname );
if( tag_entry == NULL ) {
nottag_err(); // tagname not defined
return;
}
}
/***********************************************************************/
/* isolate attname use previous if attname * */
/***********************************************************************/
cc = getarg(); // Attribute name or *
if( cc == omit || (*tok_start == '*' && att_entry == NULL) ) {
// no operands or attname * and no previous definition
xx_err( err_att_name_inv );
return;
}
p = tok_start;
if( *p == '*' ) { // single * as attname
if( arg_flen > 1 ) {
xx_err( err_att_name_inv );
return;
}
saveatt = '*'; // remember for possible quick access
if( GlobalFlags.firstpass && input_cbs->fmflags & II_research ) {
out_msg(" using attname %s\n", attname );
}
att_flags = att_entry->attflags;
} else {
saveatt = ' '; // no quick access
att_entry = NULL;
pn = attname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < ATT_NAME_LENGTH ) {
*pn++ = tolower( *p++ );// copy lowercase tagname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < ATT_NAME_LENGTH; k++ ) {
attname[k] = '\0';
}
attname[ATT_NAME_LENGTH] = '\0';
if( len < arg_flen ) {
xx_err( err_att_name_inv );// attname with invalid or too many chars
cc = neg;
return;
}
}
/***********************************************************************/
/* process options A and options B */
/***********************************************************************/
if( cc != omit ) {
if( saveatt != '*' ) { // no quickaccess for attribute
gawk = NULL;
for( gawk = tag_entry->attribs; gawk != NULL;
gawk = gawk->next ) {
if( !stricmp( attname, gawk->name ) ) {
att_flags = gawk->attflags; // get possible uppercase option
break;
}
}
} else {
att_flags = att_entry->attflags;
}
cc = scan_att_optionsA( &att_flags ); // process options A
if( cc != omit ) {
cc = scan_att_optionsB( &val_flags, cc, &att_flags );// process option B
if( cc != omit ) {
xx_err( err_tag_toomany ); // excess parameters
return;
}
}
}
/***********************************************************************/
/* scanning complete add/modify attribute in dictionary */
/***********************************************************************/
if( saveatt != '*' ) { // no quickaccess for attribute
for( att_entry = tag_entry->attribs; att_entry != NULL;
att_entry = att_entry->next ) {
if( !stricmp( attname, att_entry->name ) ) {
break;
}
}
}
if( att_entry == NULL ) { // new attribute
att_entry = mem_alloc( sizeof( gaentry ) );
att_entry->next = tag_entry->attribs;
tag_entry->attribs = att_entry;
att_entry->vals = NULL;
att_entry->attflags = att_flags;
strcpy( att_entry->name, attname );
} else {
att_entry->attflags = att_flags;// update flags
}
gaval = mem_alloc( sizeof (gavalentry ) );
if( att_entry->vals == NULL ) {
att_entry->vals = gaval;
} else {
gavalentry * valwk;
for( valwk = att_entry->vals; valwk != NULL;
valwk = valwk->next ) {
if( valwk->next == NULL ) {
break; // last entry found
}
}
valwk->next = gaval;
}
gaval->next = NULL;
gaval->valflags = val_flags;
if( val_flags & val_length ) {
gaval->a.length = ranges[0];
} else if( val_flags & val_range ) {
for( k = 0; k < 4; k++ ) {
gaval->a.range[k] = ranges[k];
}
} else if( val_flags & val_value ) {
strcpy_s( gaval->a.value, sizeof( gaval->a.value ), stringval );
} else if( val_flags & val_valptr ) {
gaval->a.valptr = valptr;
}
scan_restart = scan_stop + 1;
return;
}