static int pop3_fastuidl( int sock, struct query *ctl, unsigned int count, int *newp)
{
int ok;
unsigned int first_nr, last_nr, try_nr;
char id [IDLEN+1];
first_nr = 0;
last_nr = count + 1;
while (first_nr < last_nr - 1)
{
struct idlist *newl;
try_nr = (first_nr + last_nr) / 2;
if ((ok = pop3_getuidl(sock, try_nr, id, sizeof(id))) != 0)
return ok;
if ((newl = str_in_list(&ctl->oldsaved, id, FALSE)))
{
flag mark = newl->val.status.mark;
if (mark == UID_DELETED || mark == UID_EXPUNGED)
{
if (outlevel >= O_VERBOSE)
report(stderr, GT_("id=%s (num=%u) was deleted, but is still present!\n"), id, try_nr);
/* just mark it as seen now! */
newl->val.status.mark = mark = UID_SEEN;
}
/* narrow the search region! */
if (mark == UID_UNSEEN)
{
if (outlevel >= O_DEBUG)
report(stdout, GT_("%u is unseen\n"), try_nr);
last_nr = try_nr;
}
else
first_nr = try_nr;
/* save the number */
newl->val.status.num = try_nr;
}
else
{
if (outlevel >= O_DEBUG)
report(stdout, GT_("%u is unseen\n"), try_nr);
last_nr = try_nr;
/* save it */
newl = save_str(&ctl->oldsaved, id, UID_UNSEEN);
newl->val.status.num = try_nr;
}
}
if (outlevel >= O_DEBUG && last_nr <= count)
report(stdout, GT_("%u is first unseen\n"), last_nr);
/* update last! */
*newp = count - first_nr;
last = first_nr;
return 0;
}
void add_if_name(char **if_list, size_t *if_list_alloc, size_t *if_list_offset, const char *name)
{
if (FAIL == str_in_list(*if_list, name, ZBX_IF_SEP))
{
if ('\0' != **if_list)
zbx_chrcpy_alloc(if_list, if_list_alloc, if_list_offset, ZBX_IF_SEP);
zbx_strcpy_alloc(if_list, if_list_alloc, if_list_offset, name);
}
}
void X86_Intel_printInst(MCInst *MI, SStream *O, void *Info)
{
//if (TSFlags & X86II::LOCK)
// O << "\tlock\n";
if (printAliasInstr(MI, O)) {
char *mnem = cs_strdup(O->buffer);
char *tab = strchr(mnem, '\t');
if (tab)
*tab = '\0';
// reflect the new insn name (alias) in the opcode
MCInst_setOpcode(MI, X86_get_insn_id2(X86_map_insn(mnem)));
cs_mem_free(mnem);
} else
printInstruction(MI, O, NULL);
if (MI->csh->detail) {
char tmp[64];
if (get_first_op(O->buffer, tmp)) {
int post;
char *acc_regs[] = { "al", "ax", "eax", "rax", NULL };
unsigned int acc_regs_id[] = { X86_REG_AL, X86_REG_AX, X86_REG_EAX, X86_REG_RAX };
if (tmp[0] != 0 && ((post = str_in_list(acc_regs, tmp)) != -1)) {
// first op is register, so set operand size following register size
MI->flat_insn.x86.op_size = 1 << post;
// tmp is a register
if ((MI->flat_insn.x86.operands[0].type != X86_OP_INVALID) &&
((MI->flat_insn.x86.operands[0].type != X86_OP_REG) ||
(MI->flat_insn.x86.operands[0].reg != acc_regs_id[post]))) {
// first op is register, so insert its detail to position 0
int i;
for (i = MI->flat_insn.x86.op_count; i > 0; i--) {
memcpy(&(MI->flat_insn.x86.operands[i]), &(MI->flat_insn.x86.operands[i - 1]),
sizeof(MI->flat_insn.x86.operands[0]));
}
MI->flat_insn.x86.operands[0].type = X86_OP_REG;
MI->flat_insn.x86.operands[0].reg = x86_map_regname(tmp);
MI->flat_insn.x86.op_count++;
}
}
}
}
}
/******************************************************************************
* *
* Function: DMget_table_data *
* *
* Purpose: get configuration changes to required node for specified table *
* *
* Parameters: *
* *
* Return value: SUCCESS - processed successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int DMget_table_data(int nodeid, unsigned char dest_nodetype, const ZBX_TABLE *table,
char **data, size_t *data_alloc, size_t *data_offset,
char **ptbls, size_t *ptbls_alloc, size_t *ptbls_offset)
{
const char *__function_name = "DMget_table_data";
int f, res = SUCCEED;
const ZBX_TABLE *fk_table;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() [table:'%s']", __function_name, table->table);
if (SUCCEED == str_in_list(*ptbls, table->table, ','))
goto out;
if (0 != *ptbls_offset)
zbx_chrcpy_alloc(ptbls, ptbls_alloc, ptbls_offset, ',');
zbx_strcpy_alloc(ptbls, ptbls_alloc, ptbls_offset, table->table);
for (f = 0; NULL != table->fields[f].name; f++)
{
if (0 == (table->fields[f].flags & ZBX_SYNC))
continue;
if (NULL == table->fields[f].fk_table)
continue;
fk_table = DBget_table(table->fields[f].fk_table);
DMget_table_data(nodeid, dest_nodetype, fk_table, data, data_alloc, data_offset,
ptbls, ptbls_alloc, ptbls_offset);
}
DMcollect_table_data(nodeid, dest_nodetype, table, data, data_alloc, data_offset);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
int SERVICES(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int start_type, service_state, ret;
char *type, *state, *exclude, *buf = NULL, *utf8;
SC_HANDLE h_mgr;
ENUM_SERVICE_STATUS_PROCESS *ssp = NULL;
DWORD sz = 0, szn, i, services, resume_handle = 0;
if (3 < request->nparam)
return SYSINFO_RET_FAIL;
type = get_rparam(request, 0);
state = get_rparam(request, 1);
exclude = get_rparam(request, 2);
if (NULL == type || '\0' == *type || 0 == strcmp(type, "all")) /* default parameter */
start_type = ZBX_SRV_STARTTYPE_ALL;
else if (0 == strcmp(type, "automatic"))
start_type = ZBX_SRV_STARTTYPE_AUTOMATIC;
else if (0 == strcmp(type, "manual"))
start_type = ZBX_SRV_STARTTYPE_MANUAL;
else if (0 == strcmp(type, "disabled"))
start_type = ZBX_SRV_STARTTYPE_DISABLED;
else
return SYSINFO_RET_FAIL;
if (NULL == state || '\0' == *state || 0 == strcmp(state, "all")) /* default parameter */
service_state = ZBX_SRV_STATE_ALL;
else if (0 == strcmp(state, "stopped"))
service_state = ZBX_SRV_STATE_STOPPED;
else if (0 == strcmp(state, "started"))
service_state = ZBX_SRV_STATE_STARTED;
else if (0 == strcmp(state, "start_pending"))
service_state = ZBX_SRV_STATE_START_PENDING;
else if (0 == strcmp(state, "stop_pending"))
service_state = ZBX_SRV_STATE_STOP_PENDING;
else if (0 == strcmp(state, "running"))
service_state = ZBX_SRV_STATE_RUNNING;
else if (0 == strcmp(state, "continue_pending"))
service_state = ZBX_SRV_STATE_CONTINUE_PENDING;
else if (0 == strcmp(state, "pause_pending"))
service_state = ZBX_SRV_STATE_PAUSE_PENDING;
else if (0 == strcmp(state, "paused"))
service_state = ZBX_SRV_STATE_PAUSED;
else
return SYSINFO_RET_FAIL;
if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ)))
return SYSINFO_RET_FAIL;
while (0 != (ret = EnumServicesStatusEx(h_mgr, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL,
(LPBYTE)ssp, sz, &szn, &services, &resume_handle, NULL)) || ERROR_MORE_DATA == GetLastError())
{
for (i = 0; i < services; i++)
{
SC_HANDLE h_srv;
if (NULL == (h_srv = OpenService(h_mgr, ssp[i].lpServiceName, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG)))
continue;
if (SUCCEED == check_service_starttype(h_srv, start_type))
{
if (SUCCEED == check_service_state(h_srv, service_state))
{
utf8 = zbx_unicode_to_utf8(ssp[i].lpServiceName);
if (NULL == exclude || FAIL == str_in_list(exclude, utf8, ','))
buf = zbx_strdcatf(buf, "%s\n", utf8);
zbx_free(utf8);
}
}
CloseServiceHandle(h_srv);
}
if (0 == szn)
break;
if (NULL == ssp)
{
sz = szn;
ssp = (ENUM_SERVICE_STATUS_PROCESS *)zbx_malloc((void *)ssp, sz);
}
}
zbx_free(ssp);
CloseServiceHandle(h_mgr);
if (NULL == buf)
buf = zbx_strdup(buf, "0");
SET_STR_RESULT(result, buf);
return SYSINFO_RET_OK;
}
/******************************************************************************
* *
* Function: update_checksums *
* *
* Purpose: overwrite old checksums with new ones *
* *
* Parameters: *
* *
* Return value: SUCCESS - calculated successfully *
* FAIL - an error occurred *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int update_checksums(int nodeid, int synked_nodetype, int synked, const char *tablename,
const zbx_uint64_t id, const char *fields)
{
const char *__function_name = "update_checksums";
char *r[2], *d[2], sync[129], *s;
char c[2], sql[2][256];
char cksum[32 * 72 + 72], *ck;
char *exsql = NULL;
size_t exsql_alloc = 64 * ZBX_KIBIBYTE, exsql_offset = 0;
int cksumtype;
DB_RESULT result;
DB_ROW row;
int f;
const ZBX_TABLE *table;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
exsql = zbx_malloc(exsql, exsql_alloc);
DBbegin();
DBbegin_multiple_update(&exsql, &exsql_alloc, &exsql_offset);
c[0] = SUCCEED == synked ? '1' : ' '; /* for new and updated records */
c[1] = SUCCEED == synked ? '2' : ' '; /* for deleted records */
if (NULL != tablename)
{
zbx_snprintf(sql[0], sizeof(sql[0]), " and curr.tablename='%s' and curr.recordid=" ZBX_FS_UI64,
tablename, id);
zbx_snprintf(sql[1], sizeof(sql[1]), " and prev.tablename='%s' and prev.recordid=" ZBX_FS_UI64,
tablename, id);
}
else
{
*sql[0] = '\0';
*sql[1] = '\0';
}
result = DBselect(
/* new records */
"select curr.tablename,curr.recordid,prev.cksum,curr.cksum,NULL"
" from node_cksum curr"
" left join node_cksum prev"
" on prev.nodeid=curr.nodeid"
" and prev.tablename=curr.tablename"
" and prev.recordid=curr.recordid"
" and prev.cksumtype=%d"
" where curr.nodeid=%d"
" and curr.cksumtype=%d"
" and prev.tablename is null%s"
" union all "
/* updated records */
"select curr.tablename,curr.recordid,prev.cksum,curr.cksum,prev.sync"
" from node_cksum curr, node_cksum prev"
" where curr.nodeid=%d"
" and prev.nodeid=curr.nodeid"
" and curr.tablename=prev.tablename"
" and curr.recordid=prev.recordid"
" and curr.cksumtype=%d"
" and prev.cksumtype=%d%s"
" union all "
/* deleted records */
"select prev.tablename,prev.recordid,prev.cksum,curr.cksum,prev.sync"
" from node_cksum prev"
" left join node_cksum curr"
" on curr.nodeid=prev.nodeid"
" and curr.tablename=prev.tablename"
" and curr.recordid=prev.recordid"
" and curr.cksumtype=%d"
" where prev.nodeid=%d"
" and prev.cksumtype=%d"
" and curr.tablename is null%s",
NODE_CKSUM_TYPE_OLD, nodeid, NODE_CKSUM_TYPE_NEW, sql[0],
nodeid, NODE_CKSUM_TYPE_NEW, NODE_CKSUM_TYPE_OLD, sql[0],
NODE_CKSUM_TYPE_NEW, nodeid, NODE_CKSUM_TYPE_OLD, sql[1]);
while (NULL != (row = DBfetch(result)))
{
if (NULL == (table = DBget_table(row[0])))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot find table [%s]", row[0]);
continue;
}
memset(sync, ' ', sizeof(sync));
if (FAIL == DBis_null(row[4]))
memcpy(sync, row[4], strlen(row[4]));
s = sync;
ck = cksum;
*ck = '\0';
/* special (simpler) processing for operation DELETE */
if (SUCCEED == DBis_null(row[3]))
{
if (SUCCEED == synked)
s[synked_nodetype] = c[1];
if ((0 == CONFIG_MASTER_NODEID || s[1] == c[1]) && (CONFIG_NODEID == nodeid || s[0] == c[1]))
{
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset,
"delete from node_cksum"
" where nodeid=%d"
" and cksumtype=%d"
" and tablename='%s'"
" and recordid=%s;\n",
nodeid, NODE_CKSUM_TYPE_OLD, row[0], row[1]);
DBexecute_overflowed_sql(&exsql, &exsql_alloc, &exsql_offset);
continue;
}
s += 2;
}
else
{
r[0] = SUCCEED == DBis_null(row[2]) ? NULL : row[2];
r[1] = row[3];
f = 0;
do {
while ((table->fields[f].flags & ZBX_SYNC) == 0)
f++;
/* "host_inventory" table has more than 64 fields */
/* remaining fields are processed as one */
if (128 == s - sync)
s -= 2;
d[0] = NULL;
d[1] = NULL;
if (NULL != r[0] && NULL != (d[0] = strchr(r[0], ',')))
*d[0] = '\0';
if (NULL != r[1] && NULL != (d[1] = strchr(r[1], ',')))
*d[1] = '\0';
if (NULL == tablename || SUCCEED == str_in_list(fields, table->fields[f].name, ','))
{
ck += zbx_snprintf(ck, 64, "%s,", NULL != r[1] ? r[1] : r[0]);
if (NULL == r[0] || NULL == r[1] || 0 != strcmp(r[0], r[1]))
{
s[0] = s[1] = ' ';
s[synked_nodetype] = c[0];
}
else
{
if (SUCCEED == synked)
s[synked_nodetype] = c[0];
}
}
else
ck += zbx_snprintf(ck, 64, "%s,", NULL != r[0] ? r[0] : "");
s += 2;
f++;
if (d[0] != NULL)
{
*d[0] = ',';
r[0] = d[0] + 1;
}
else
r[0] = NULL;
if (d[1] != NULL)
{
*d[1] = ',';
r[1] = d[1] + 1;
}
else
r[1] = NULL;
} while (d[0] != NULL || d[1] != NULL);
*--ck = '\0';
}
*s = '\0';
if (SUCCEED == DBis_null(row[2]) || SUCCEED == DBis_null(row[3]) ||
0 != strcmp(row[4], sync) || 0 != strcmp(row[2], row[3]))
{
cksumtype = (DBis_null(row[2]) == SUCCEED) ? NODE_CKSUM_TYPE_NEW : NODE_CKSUM_TYPE_OLD;
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset,
"update node_cksum"
" set cksumtype=%d,"
"cksum='%s',"
"sync='%s'"
" where nodeid=%d"
" and cksumtype=%d"
" and tablename='%s'"
" and recordid=%s;\n",
NODE_CKSUM_TYPE_OLD, cksum, sync,
nodeid, cksumtype, row[0], row[1]);
DBexecute_overflowed_sql(&exsql, &exsql_alloc, &exsql_offset);
}
}
DBfree_result(result);
DBend_multiple_update(&exsql, &exsql_alloc, &exsql_offset);
if (exsql_offset > 16) /* In ORACLE always present begin..end; */
DBexecute("%s", exsql);
zbx_free(exsql);
DBcommit();
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return SUCCEED;
}
/******************************************************************************
* *
* Function: update_checksums *
* *
* Purpose: overwrite old checksums with new ones *
* *
* Parameters: *
* *
* Return value: SUCCESS - calculated successfully *
* FAIL - an error occurred *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int update_checksums(int nodeid, int synked_nodetype, int synked, const char *tablename, const zbx_uint64_t id, char *fields)
{
const char *__function_name = "update_checksums";
char *r[2], *d[2], sync[129], *s;
char c[2], sql[2][256];
char cksum[32*64+32], *ck;
char *exsql = NULL;
int exsql_alloc = 65536, exsql_offset = 0, cksumtype;
DB_RESULT result;
DB_ROW row;
int f;
const ZBX_TABLE *table;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
exsql = zbx_malloc(exsql, exsql_alloc);
DBbegin();
#ifdef HAVE_ORACLE
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset, 8, "begin\n");
#endif
c[0] = synked == SUCCEED ? '1' : ' '; /* for new and updated records */
c[1] = synked == SUCCEED ? '2' : ' '; /* for deleted records */
if (NULL != tablename) {
zbx_snprintf(sql[0], sizeof(sql[0]), " and curr.tablename='%s' and curr.recordid=" ZBX_FS_UI64,
tablename, id);
zbx_snprintf(sql[1], sizeof(sql[1]), " and prev.tablename='%s' and prev.recordid=" ZBX_FS_UI64,
tablename, id);
} else {
*sql[0] = '\0';
*sql[1] = '\0';
}
/* Find updated records */
result = DBselect("select curr.tablename,curr.recordid,prev.cksum,curr.cksum,prev.sync "
"from node_cksum curr, node_cksum prev "
"where curr.nodeid=%d and prev.nodeid=curr.nodeid and "
"curr.tablename=prev.tablename and curr.recordid=prev.recordid and "
"curr.cksumtype=%d and prev.cksumtype=%d%s "
"union all "
/* Find new records */
"select curr.tablename,curr.recordid,prev.cksum,curr.cksum,NULL "
"from node_cksum curr left join node_cksum prev "
"on prev.nodeid=curr.nodeid and prev.tablename=curr.tablename and "
"prev.recordid=curr.recordid and prev.cksumtype=%d "
"where curr.nodeid=%d and curr.cksumtype=%d and prev.tablename is null%s "
"union all "
/* Find deleted records */
"select prev.tablename,prev.recordid,prev.cksum,curr.cksum,prev.sync "
"from node_cksum prev left join node_cksum curr "
"on curr.nodeid=prev.nodeid and curr.tablename=prev.tablename and "
"curr.recordid=prev.recordid and curr.cksumtype=%d "
"where prev.nodeid=%d and prev.cksumtype=%d and curr.tablename is null%s",
nodeid, NODE_CKSUM_TYPE_NEW, NODE_CKSUM_TYPE_OLD, sql[0],
NODE_CKSUM_TYPE_OLD, nodeid, NODE_CKSUM_TYPE_NEW, sql[0],
NODE_CKSUM_TYPE_NEW, nodeid, NODE_CKSUM_TYPE_OLD, sql[1]);
while (NULL != (row = DBfetch(result)))
{
/* Found table */
if (NULL == (table = DBget_table(row[0])))
{
zabbix_log(LOG_LEVEL_WARNING, "Cannot find table [%s]",
row[0]);
continue;
}
if (FAIL == DBis_null(row[4]))
zbx_strlcpy(sync, row[4], sizeof(sync));
else
memset(sync, ' ', sizeof(sync));
s = sync;
ck = cksum;
*ck = '\0';
/* Special (simpler) processing for operation DELETE */
if (SUCCEED == DBis_null(row[3]))
{
if (synked == SUCCEED)
{
if (synked_nodetype == ZBX_NODE_SLAVE)
s[0] = c[1];
else if (synked_nodetype == ZBX_NODE_MASTER)
s[1] = c[1];
}
if ((0 == CONFIG_MASTER_NODEID || s[1] == c[1]) &&
(CONFIG_NODEID == nodeid || s[0] == c[1]))
{
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset, 256,
"delete from node_cksum"
" where nodeid=%d"
" and cksumtype=%d"
" and tablename='%s'"
" and recordid=%s;\n",
nodeid, NODE_CKSUM_TYPE_OLD, row[0], row[1]);
DBexecute_overflowed_sql(&exsql, &exsql_alloc, &exsql_offset);
continue;
}
s += 2;
}
else
{
r[0] = DBis_null(row[2]) == SUCCEED ? NULL : row[2];
r[1] = row[3];
f = 0;
do {
while ((table->fields[f].flags & ZBX_SYNC) == 0)
f++;
d[0] = NULL;
d[1] = NULL;
if (NULL != r[0] && NULL != (d[0] = strchr(r[0], ',')))
*d[0] = '\0';
if (NULL != r[1] && NULL != (d[1] = strchr(r[1], ',')))
*d[1] = '\0';
if (NULL == tablename || SUCCEED == str_in_list(fields, table->fields[f].name, ','))
{
ck += zbx_snprintf(ck, 64, "%s,", NULL != r[1] ? r[1] : r[0]);
if (r[0] == NULL || r[1] == NULL || strcmp(r[0], r[1]) != 0)
{
if (synked_nodetype == ZBX_NODE_SLAVE)
{
s[0] = c[0];
s[1] = ' ';
}
else if (synked_nodetype == ZBX_NODE_MASTER)
{
s[0] = ' ';
s[1] = c[0];
}
}
else
{
if (synked == SUCCEED)
{
if (synked_nodetype == ZBX_NODE_SLAVE)
s[0] = c[0];
else if (synked_nodetype == ZBX_NODE_MASTER)
s[1] = c[0];
}
}
}
else
ck += zbx_snprintf(ck, 64, "%s,", NULL != r[0] ? r[0] : "");
s += 2;
f++;
if (d[0] != NULL)
{
*d[0] = ',';
r[0] = d[0] + 1;
}
else
r[0] = NULL;
if (d[1] != NULL)
{
*d[1] = ',';
r[1] = d[1] + 1;
}
else
r[1] = NULL;
} while (d[0] != NULL || d[1] != NULL);
*--ck = '\0';
}
*s = '\0';
if (SUCCEED == DBis_null(row[2]) || SUCCEED == DBis_null(row[3]) ||
0 != strcmp(row[4], sync) || 0 != strcmp(row[2], row[3]))
{
cksumtype = (DBis_null(row[2]) == SUCCEED) ? NODE_CKSUM_TYPE_NEW : NODE_CKSUM_TYPE_OLD;
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset, 2560,
"update node_cksum"
" set cksumtype=%d,"
"cksum='%s',"
"sync='%s'"
" where nodeid=%d"
" and cksumtype=%d"
" and tablename='%s'"
" and recordid=%s;\n",
NODE_CKSUM_TYPE_OLD, cksum, sync,
nodeid, cksumtype, row[0], row[1]);
DBexecute_overflowed_sql(&exsql, &exsql_alloc, &exsql_offset);
}
}
DBfree_result(result);
#ifdef HAVE_ORACLE
zbx_snprintf_alloc(&exsql, &exsql_alloc, &exsql_offset, 8, "end;\n");
#endif
if (exsql_offset > 16) /* In ORACLE always present begin..end; */
DBexecute("%s", exsql);
zbx_free(exsql);
DBcommit();
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return SUCCEED;
}
/* checks to see if reference sequence looks okay wrt a given
list of features */
int ref_seq_okay(List *features, MSA *msa, int offset3,
int indel_strict, int splice_strict, List *problems) {
List *signals = NULL;
char *seq = NULL;
int seqalloc = 0;
int idx, retval = TRUE;
GFF_Feature *feat, *lastfeat_helper = NULL;
if (indel_strict) {
signals = lst_new_ptr(10);
str_split(str_new_charstr(SIGNALS), ",", signals);
}
for (idx = 0; idx < lst_size(features); idx++) {
int i, j, len, has_gaps = 0;
feat = lst_get_ptr(features, idx);
if (seqalloc <= feat->end - feat->start + 2) {
seqalloc = (feat->end - feat->start) * 2;
seq = srealloc(seq, seqalloc * sizeof(char));
}
for (i = feat->start - 1, len = 0; i < feat->end; i++) {
if (ss_get_char_pos(msa, i, 0, 0) != GAP_CHAR)
seq[len++] = ss_get_char_pos(msa, i, 0, 0);
else if (!has_gaps) has_gaps = 1;
}
seq[len] = '\0';
if (feat->strand == '-') msa_reverse_compl_seq(seq, len);
if (str_equals_charstr(feat->feature, GFF_START_TYPE) && strcmp(seq, "ATG") != 0) {
problem_add(problems, feat, BAD_REF_START, -1, -1);
retval = FALSE;
}
else if (str_equals_charstr(feat->feature, GFF_STOP_TYPE) &&
(feat->frame != 0 || !is_stop_codon(seq))) {
problem_add(problems, feat, BAD_REF_STOP, -1, -1);
retval = FALSE;
}
else if (str_starts_with_charstr(feat->feature, SPLICE_5) &&
!is_valid_5splice(seq, splice_strict)) {
problem_add(problems, feat, BAD_REF_5_SPLICE, -1, -1);
retval = FALSE;
}
else if (str_starts_with_charstr(feat->feature, SPLICE_3) &&
!is_valid_3splice(&seq[offset3], splice_strict)) {
problem_add(problems, feat, BAD_REF_3_SPLICE, -1, -1);
retval = FALSE;
}
else if (str_equals_charstr(feat->feature, GFF_CDS_TYPE)) {
for (i = (3 - feat->frame) % 3; i <= len - 3; i += 3) {
if (is_stop_codon(&seq[i])) {
problem_add(problems, feat, BAD_REF_ORF, -1, -1);
retval = FALSE;
break;
}
}
}
if (indel_strict) {
int strict_okay = TRUE;
List *signals = lst_new_ptr(10);
str_split(str_new_charstr(SIGNALS), ",", signals);
if (str_in_list(feat->feature, signals)) {
/* reject any signal feature with gaps in the ref seq, unless they
appear in a non-critical part of a splice site or in a
"prestart" feature */
if (has_gaps) {
if (str_starts_with_charstr(feat->feature, SPLICE_5)) {
if (ss_get_char_pos(msa, feat->start-1, 0, 0) == GAP_CHAR ||
ss_get_char_pos(msa, feat->start, 0, 0) == GAP_CHAR)
strict_okay = FALSE;
}
else if (str_starts_with_charstr(feat->feature, SPLICE_3)) {
if (ss_get_char_pos(msa, feat->end-1, 0, 0) == GAP_CHAR ||
ss_get_char_pos(msa, feat->end-2, 0, 0) == GAP_CHAR)
strict_okay = FALSE;
}
else if (!str_equals_charstr(feat->feature, "prestart"))
strict_okay = FALSE;
}
/* in addition, if two signals occur consec. with gaps and
only gaps between them, assume a violation of
--indel-strict */
if (lastfeat_helper != NULL && lastfeat_helper->end < feat->start-1) {
int allgaps = 1;
for (j = lastfeat_helper->end; allgaps && j < feat->start-1; j++)
/* note indexing: -1+1 for end and -1
for start */
if (ss_get_char_pos(msa, j, 0, 0) != GAP_CHAR) allgaps = 0;
if (allgaps)
strict_okay = FALSE;
}
lastfeat_helper = feat;
}
else lastfeat_helper = NULL;
/* also exclude CDS exons of length less than 6 in indel_strict
case -- these cause problems in exoniphy training because
start_codon is adjacent to cds5ss */
if (str_equals_charstr(feat->feature, GFF_CDS_TYPE) && len <= 6)
strict_okay = FALSE;
if (!strict_okay) {
problem_add(problems, feat, BAD_REF_INDEL_STRICT_FAIL, -1, -1);
retval = FALSE;
}
lst_free_strings(signals);
lst_free(signals);
}
}
if (seq != NULL) sfree(seq);
return retval;
}
/******************************************************************************
* *
* Function: process_updated_records *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void process_updated_records(int nodeid, char *data)
{
const char *__function_name = "process_updated_records";
char *r, *lf, *value_esc;
int op, dnum;
const ZBX_TABLE *table = NULL;
const ZBX_FIELD *field = NULL;
zbx_uint64_t recid;
char *dsql = NULL,
*isql = NULL, *ifld = NULL, *ival = NULL,
*usql = NULL, *ufld = NULL;
size_t dsql_alloc = 4 * ZBX_KIBIBYTE, dsql_offset = 0, dtmp_offset = 0,
isql_alloc = 4 * ZBX_KIBIBYTE, isql_offset = 0,
ifld_alloc = 4 * ZBX_KIBIBYTE, ifld_offset = 0,
ival_alloc = 4 * ZBX_KIBIBYTE, ival_offset = 0,
usql_alloc = 4 * ZBX_KIBIBYTE, usql_offset = 0,
ufld_alloc = 4 * ZBX_KIBIBYTE, ufld_offset = 0;
DB_RESULT result;
DB_ROW row;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
dsql = zbx_malloc(dsql, dsql_alloc);
isql = zbx_malloc(isql, isql_alloc);
ifld = zbx_malloc(ifld, ifld_alloc);
ival = zbx_malloc(ival, ival_alloc);
usql = zbx_malloc(usql, usql_alloc);
ufld = zbx_malloc(ufld, ufld_alloc);
#ifdef HAVE_ORACLE
DBbegin_multiple_update(&dsql, &dsql_alloc, &dsql_offset);
DBbegin_multiple_update(&isql, &isql_alloc, &isql_offset);
DBbegin_multiple_update(&usql, &usql_alloc, &usql_offset);
#endif
for (r = data; '\0' != *r;)
{
if (NULL != (lf = strchr(r, '\n')))
*lf = '\0';
/* table name */
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
if (NULL == table || 0 != strcmp(table->table, buf))
{
if (NULL == (table = DBget_table(buf)))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s(): cannot find table [%s]", __function_name, buf);
goto next;
}
}
/* record id */
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
ZBX_STR2UINT64(recid, buf);
if (NULL == r)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s(): invalid record", __function_name);
goto next;
}
if ('0' == *r) /* NODE_CONFIGLOG_OP_UPDATE */
{
result = DBselect("select 0 from %s where %s=" ZBX_FS_UI64,
table->table, table->recid, recid);
if (NULL == (row = DBfetch(result)))
op = NODE_CONFIGLOG_OP_ADD;
else
op = NODE_CONFIGLOG_OP_UPDATE;
DBfree_result(result);
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
ifld_offset = 0;
ival_offset = 0;
ufld_offset = 0;
dtmp_offset = dsql_offset;
dnum = 0;
if (op == NODE_CONFIGLOG_OP_ADD && NULL != table->uniq)
{
zbx_snprintf_alloc(&dsql, &dsql_alloc, &dsql_offset,
"delete from %s where ", table->table);
}
while (NULL != r)
{
/* field name */
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
if (NULL == (field = DBget_field(table, buf)))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s(): cannot find field [%s.%s]",
__function_name, table->table, buf);
goto next;
}
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset, "%s=", buf);
else /* NODE_CONFIGLOG_OP_ADD */
zbx_snprintf_alloc(&ifld, &ifld_alloc, &ifld_offset, "%s,", buf);
/* value type (ignored) */
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);
if (0 == strcmp(buf, "NULL"))
{
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_strcpy_alloc(&ufld, &ufld_alloc, &ufld_offset, "NULL,");
else /* NODE_CONFIGLOG_OP_ADD */
zbx_strcpy_alloc(&ival, &ival_alloc, &ival_offset, "NULL,");
continue;
}
switch (field->type)
{
case ZBX_TYPE_ID:
/* if the field relates the same table
* for example: host.proxy_hostid relates with host.hostid
*/
if (NODE_CONFIGLOG_OP_ADD == op &&
NULL != field->fk_table &&
0 == strcmp(table->table, field->fk_table))
{
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset, "%s=%s,",
field->name, buf);
zbx_strcpy_alloc(&ival, &ival_alloc, &ival_offset, "NULL,");
break;
}
case ZBX_TYPE_INT:
case ZBX_TYPE_UINT:
case ZBX_TYPE_FLOAT:
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset,
"%s,", buf);
else /* NODE_CONFIGLOG_OP_ADD */
{
zbx_snprintf_alloc(&ival, &ival_alloc, &ival_offset,
"%s,", buf);
if (NULL != table->uniq && SUCCEED == str_in_list(table->uniq, field->name, ','))
{
zbx_snprintf_alloc(&dsql, &dsql_alloc, &dsql_offset,
"%s=%s and ", field->name, buf);
dnum++;
}
}
break;
case ZBX_TYPE_BLOB:
if ('\0' == *buf)
{
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_strcpy_alloc(&ufld, &ufld_alloc, &ufld_offset, "'',");
else /* NODE_CONFIGLOG_OP_ADD */
zbx_strcpy_alloc(&ival, &ival_alloc, &ival_offset, "'',");
}
else
{
#if defined(HAVE_POSTGRESQL)
size_t len;
len = zbx_hex2binary(buf);
DBbytea_escape((u_char *)buf, len, &tmp, &tmp_alloc);
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset,
"'%s',", tmp);
else /* NODE_CONFIGLOG_OP_ADD */
zbx_snprintf_alloc(&ival, &ival_alloc, &ival_offset,
"'%s',", tmp);
#else
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset,
"0x%s,", buf);
else /* NODE_CONFIGLOG_OP_ADD */
zbx_snprintf_alloc(&ival, &ival_alloc, &ival_offset,
"0x%s,", buf);
#endif
}
break;
default: /* ZBX_TYPE_TEXT, ZBX_TYPE_CHAR */
zbx_hex2binary(buf);
value_esc = DBdyn_escape_string(buf);
if (NODE_CONFIGLOG_OP_UPDATE == op)
zbx_snprintf_alloc(&ufld, &ufld_alloc, &ufld_offset,
"'%s',", value_esc);
else /* NODE_CONFIGLOG_OP_ADD */
{
zbx_snprintf_alloc(&ival, &ival_alloc, &ival_offset,
"'%s',", value_esc);
if (NULL != table->uniq && SUCCEED == str_in_list(table->uniq, field->name, ','))
{
zbx_snprintf_alloc(&dsql, &dsql_alloc, &dsql_offset,
"%s='%s' and ", field->name, value_esc);
dnum++;
}
}
zbx_free(value_esc);
}
}
if (dsql_offset != dtmp_offset)
{
if (dnum != num_param(table->uniq))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s(): missing required fields [%s][%s]",
__function_name, table->table, table->uniq);
dsql_offset = dtmp_offset;
goto next;
}
dsql_offset -= 5;
zbx_strcpy_alloc(&dsql, &dsql_alloc, &dsql_offset, ";\n");
}
if (0 != ifld_offset)
{
ifld[--ifld_offset] = '\0';
ival[--ival_offset] = '\0';
zbx_snprintf_alloc(&isql, &isql_alloc, &isql_offset,
"insert into %s (%s,%s) values (" ZBX_FS_UI64 ",%s);\n",
table->table, table->recid, ifld, recid, ival);
}
if (0 != ufld_offset)
{
ufld[--ufld_offset] = '\0';
zbx_snprintf_alloc(&usql, &usql_alloc, &usql_offset,
"update %s set %s where %s=" ZBX_FS_UI64 ";\n",
table->table, ufld, table->recid, recid);
}
if (dsql_offset > ZBX_MAX_SQL_SIZE || isql_offset > ZBX_MAX_SQL_SIZE || usql_offset > ZBX_MAX_SQL_SIZE)
{
DBend_multiple_update(&dsql, &dsql_alloc, &dsql_offset);
DBend_multiple_update(&isql, &isql_alloc, &isql_offset);
DBend_multiple_update(&usql, &usql_alloc, &usql_offset);
if (dsql_offset > 16)
DBexecute("%s", dsql);
if (isql_offset > 16)
DBexecute("%s", isql);
if (usql_offset > 16)
DBexecute("%s", usql);
dsql_offset = 0;
isql_offset = 0;
usql_offset = 0;
#ifdef HAVE_ORACLE
DBbegin_multiple_update(&dsql, &dsql_alloc, &dsql_offset);
DBbegin_multiple_update(&isql, &isql_alloc, &isql_offset);
DBbegin_multiple_update(&usql, &usql_alloc, &usql_offset);
#endif
}
}
next:
if (lf != NULL)
{
*lf++ = '\n';
r = lf;
}
else
break;
}
DBend_multiple_update(&dsql, &dsql_alloc, &dsql_offset);
DBend_multiple_update(&isql, &isql_alloc, &isql_offset);
DBend_multiple_update(&usql, &usql_alloc, &usql_offset);
if (dsql_offset > 16)
DBexecute("%s", dsql);
if (isql_offset > 16)
DBexecute("%s", isql);
if (usql_offset > 16)
DBexecute("%s", usql);
zbx_free(ufld);
zbx_free(usql);
zbx_free(ival);
zbx_free(ifld);
zbx_free(isql);
zbx_free(dsql);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
int fdt_find_regions(const void *fdt, char * const inc[], int inc_count,
char * const exc_prop[], int exc_prop_count,
struct fdt_region region[], int max_regions,
char *path, int path_len, int add_string_tab)
{
int stack[FDT_MAX_DEPTH];
char *end;
int nextoffset = 0;
uint32_t tag;
int count = 0;
int start = -1;
int depth = -1;
int want = 0;
int base = fdt_off_dt_struct(fdt);
end = path;
*end = '\0';
do {
const struct fdt_property *prop;
const char *name;
const char *str;
int include = 0;
int stop_at = 0;
int offset;
int len;
offset = nextoffset;
tag = fdt_next_tag(fdt, offset, &nextoffset);
stop_at = nextoffset;
switch (tag) {
case FDT_PROP:
include = want >= 2;
stop_at = offset;
prop = fdt_get_property_by_offset(fdt, offset, NULL);
str = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
if (str_in_list(str, exc_prop, exc_prop_count))
include = 0;
break;
case FDT_NOP:
include = want >= 2;
stop_at = offset;
break;
case FDT_BEGIN_NODE:
depth++;
if (depth == FDT_MAX_DEPTH)
return -FDT_ERR_BADSTRUCTURE;
name = fdt_get_name(fdt, offset, &len);
if (end - path + 2 + len >= path_len)
return -FDT_ERR_NOSPACE;
if (end != path + 1)
*end++ = '/';
strcpy(end, name);
end += len;
stack[depth] = want;
if (want == 1)
stop_at = offset;
if (str_in_list(path, inc, inc_count))
want = 2;
else if (want)
want--;
else
stop_at = offset;
include = want;
break;
case FDT_END_NODE:
include = want;
want = stack[depth--];
while (end > path && *--end != '/')
;
*end = '\0';
break;
case FDT_END:
include = 1;
break;
}
if (include && start == -1) {
/* Should we merge with previous? */
if (count && count <= max_regions &&
offset == region[count - 1].offset +
region[count - 1].size - base)
start = region[--count].offset - base;
else
start = offset;
}
if (!include && start != -1) {
if (count < max_regions) {
region[count].offset = base + start;
region[count].size = stop_at - start;
}
count++;
start = -1;
}
} while (tag != FDT_END);
if (nextoffset != fdt_size_dt_struct(fdt))
return -FDT_ERR_BADLAYOUT;
/* Add a region for the END tag and the string table */
if (count < max_regions) {
region[count].offset = base + start;
region[count].size = nextoffset - start;
if (add_string_tab)
region[count].size += fdt_size_dt_strings(fdt);
}
count++;
return count;
}
