/*
* Convenience wrapper on logwrite() which printf-formats the
* string.
*/
static void logprintf(struct LogContext *ctx, const char *fmt, ...)
{
va_list ap;
char *data;
va_start(ap, fmt);
data = dupvprintf(fmt, ap);
va_end(ap);
logwrite(ctx, data, strlen(data));
sfree(data);
}
void prg_exit(int exit_code) {
if (daemon_mode) logwrite("miniupdate terminated.\n");
//if (pid_file != NULL) free(pid_file);
if (log_file != NULL) free(log_file);
if (log_fd != NULL) {
fclose(log_fd);
}
unlink(pid_file);
exit(exit_code);
}
static int cf_dvbs_trans_pol(struct lc_centry *ce, struct lc_value *val) {
if (strcasecmp(val->string, "h") == 0) {
adapter->fe.dvbs.t_pol=POL_H;
} else if(strcasecmp(val->string, "v") == 0) {
adapter->fe.dvbs.t_pol=POL_V;
} else {
logwrite(LOG_ERROR, "Illegal polarization \"%s\" in line %d\n", val->string, ce->vline);
return 0;
}
return 1;
}
static int fe_api5_checkcap(struct adapter_s *adapter) {
struct dtv_property p[1];
struct dtv_properties cmds;
p[0].cmd = DTV_DELIVERY_SYSTEM;
cmds.props = p;
cmds.num = 1;
if (ioctl(adapter->fe.fd, FE_GET_PROPERTY, &cmds)) {
logwrite(LOG_DEBUG, "fe: ioctl(FE_GET_PROPERTY) failed - no DVBS2 aka API 5 support?");
return 0;
}
switch (p[0].u.data) {
case(SYS_DVBS):
if (adapter->type == AT_DVBS)
break;
logwrite(LOG_ERROR, "fe: Adapter %d is an DVB-S card - config is not for DVB-S", adapter->no);
exit(-1);
case(SYS_DVBS2):
if (adapter->type == AT_DVBS || adapter->type == AT_DVBS2)
break;
logwrite(LOG_ERROR, "fe: Adapter %d is an DVB-S2 card - config is not DVB-S or S2", adapter->no);
exit(-1);
case(SYS_DVBT):
if (adapter->type == AT_DVBT)
break;
logwrite(LOG_ERROR, "fe: Adapter %d is an DVB-T card - config is not for DVB-T", adapter->no);
exit(-1);
case(SYS_DVBC_ANNEX_B):
case(SYS_DVBC_ANNEX_AC):
if (adapter->type == AT_DVBC)
break;
logwrite(LOG_ERROR, "fe: Adapter %d is an DVB-C card - config is not for DVB-C", adapter->no);
exit(-1);
}
return 1;
}
static void logfopen_callback(void *handle, int mode)
{
struct LogContext *ctx = (struct LogContext *)handle;
char buf[256], *event;
struct tm tm;
const char *fmode;
if (mode == 0) {
ctx->state = L_ERROR; /* disable logging */
} else {
fmode = (mode == 1 ? "ab" : "wb");
ctx->lgfp = f_open(&ctx->currlogfilename, fmode, FALSE);
if (ctx->lgfp)
ctx->state = L_OPEN;
else
ctx->state = L_ERROR;
}
if (ctx->state == L_OPEN) {
/* Write header line into log file. */
tm = ltime();
strftime(buf, 24, "%Y.%m.%d %H:%M:%S", &tm);
logprintf(ctx, "=~=~=~=~=~=~=~=~=~=~=~= PuTTY log %s"
" =~=~=~=~=~=~=~=~=~=~=~=\r\n", buf);
}
event = dupprintf("%s session log (%s mode) to file: %s",
ctx->state == L_ERROR ?
(mode == 0 ? "Disabled writing" : "Error writing") :
(mode == 1 ? "Appending" : "Writing new"),
(ctx->cfg.logtype == LGTYP_ASCII ? "ASCII" :
ctx->cfg.logtype == LGTYP_DEBUG ? "raw" :
ctx->cfg.logtype == LGTYP_PACKETS ? "SSH packets" :
ctx->cfg.logtype == LGTYP_SSHRAW ? "SSH raw data" :
"unknown"),
filename_to_str(&ctx->currlogfilename));
logevent(ctx->frontend, event);
sfree(event);
/*
* Having either succeeded or failed in opening the log file,
* we should write any queued data out.
*/
assert(ctx->state != L_OPENING); /* make _sure_ it won't be requeued */
while (bufchain_size(&ctx->queue)) {
void *data;
int len;
bufchain_prefix(&ctx->queue, &data, &len);
logwrite(ctx, data, len);
bufchain_consume(&ctx->queue, len);
}
}
void StrokeGroup::MoveSG(double vec[])
{
try{
for(int i=0;i<nstrokes;i++)
strklist[i].MoveStrk(vec);
}
catch(exception& e)
{
string str="StrokeGroup:Exception in MoveSG: ";
str.append(e.what());
logwrite(str);
}
}
PVOID MemAlloc(ULONG cb)
{
PVOID pv = NULL;
if ( !cb ) return NULL;
// if the RAM semaphore is locked gives CPU time to the other threads
// so they can finish their job and release the semaphore
heapLock();
pv = _umalloc(hp, cb);
heapUnlock();
logwrite("malloc - address : %08x size : %8u\n", (ULONG)pv, cb);
TRACE2("malloc - address : %08x size : %8u", (ULONG)pv, cb);
return pv;
}
void ts_packet_decode(uint8_t *ts) {
logwrite(LOG_DEBUG, "ts_packet_decode\n");
dump_hex(LOG_DEBUG, "pdecode:", ts, TS_PACKET_SIZE);
logwrite(LOG_DEBUG, "\tsync: %02x\n", ts[0]);
logwrite(LOG_DEBUG, "\ttransport_error_indicator: %d\n", ts[1]&0x80 ? 1 : 0);
logwrite(LOG_DEBUG, "\tpayload_unit_start_indicator: %d\n", ts[1]&0x40 ? 1 : 0);
logwrite(LOG_DEBUG, "\ttransport_priority: %d\n", ts[1]&0x20 ? 1 : 0);
logwrite(LOG_DEBUG, "\tpid: %d\n", (ts[1]<<8|ts[2])&0x1fff);
logwrite(LOG_DEBUG, "\ttransport_scrambling_control: %d\n", (ts[3]>>6) & 0x3);
logwrite(LOG_DEBUG, "\tadaption_field_control: %d\n", (ts[3]>>4) & 0x3);
logwrite(LOG_DEBUG, "\tcontinuity_counter: %d\n", ts[3]&0xf);
}
static void output_remove_receiver(struct http_receiver_s *hr) {
struct output_s *o=hr->output;
struct http_connection *hc=hr->hc;
o->http_receiver=g_list_remove(o->http_receiver, hr);
o->receiver--;
logwrite(LOG_INFO, "stream_http: dropping connection to %s for %s",
inet_ntoa(hc->sin.sin_addr),
hc->url);
http_drop_connection(hc);
free(hr);
}
static int rmailfunc(char *addrlist)
{
char *p, *p1;
int r, noaddr=1;
conf=0;
cnews=0;
debug(4, "rmailfunc(\"%s\")", addrlist);
p=addrlist;
while (isspace(*p)) p++;
for (; *p; lseek(fileno(stdin), 0, SEEK_SET))
{
for (p1=p; *p1 && !isspace(*p1); p1++);
if (p1-p>=sizeof(addr))
{ logwrite('?', "Too long address\n");
return 1;
}
strncpy(addr, p, (int)(p1-p));
addr[(int)(p1-p)]='\0';
ibufsrc=BUFSIZE;
msgsize=-1;
if (!myfgets(gotstr, sizeof(gotstr)))
{ logwrite('?', "Incorrect message\n");
return 1;
}
if (isbeg(gotstr)!=0)
{ logwrite('?', "Incorrect message start\n");
return 1;
}
r=msg_unmime(-1);
if (r) return r;
noaddr=0;
for (p=p1; isspace(*p); p++);
}
debug(4, "rmailfunc ok");
return noaddr;
}
void dump_hex(int level, const char *prefix, uint8_t *buf, int size) {
int i;
unsigned char ch;
char sascii[17];
char linebuffer[16*4+1];
/* Speedup */
if (level > loglevel)
return;
sascii[16]=0x0;
for(i=0;i<size;i++) {
ch=buf[i];
if (i%16 == 0) {
sprintf(linebuffer, "%04x ", i);
}
sprintf(&linebuffer[(i%16)*3], "%02x ", ch);
if (ch >= ' ' && ch <= '}')
sascii[i%16]=ch;
else
sascii[i%16]='.';
if (i%16 == 15)
logwrite(level, "%s %s %s", prefix, linebuffer, sascii);
}
/* i++ after loop */
if (i%16 != 0) {
for(;i%16 != 0;i++) {
sprintf(&linebuffer[(i%16)*3], " ");
sascii[i%16]=' ';
}
logwrite(level, "%s %s %s", prefix, linebuffer, sascii);
}
}
void StrokeGroup::InterpStrokesForSVM()
{
try{
for(int i=0;i<nstrokes;i++)
{
strklist[i].InterpStrkForSVM();
}
}
catch(exception& e)
{
string str="StrokeGroup:Exception in InterpStrokesForSVM: ";
str.append(e.what());
logwrite(str);
}
}
void MainWindow::DisplayFirmwareInfo(void)
{
uint8_t buff[16];
QString digistr;
QChar fw_major, fw_minor;
qDebug() << "Reading Firmware info...";
if((fmtxCmdStatus = fmtxIoAppCommand(GET_REV, buff, 0)) !=FMTX_MODE_OK) goto display_firmware_err;
digistr = QString::number(buff[1]).rightJustified(2, '0', false);
ui->lineEdit_hw_id_txpart->setText(QString("SI47").append(digistr));
fw_major = QChar(buff[2]);
fw_minor = QChar(buff[3]);
ui->lineEdit_hw_id_txfwrev->setText(QString(fw_major) + "." + QString(fw_minor));
ui->lineEdit_hw_id_txpatchid->setText(QString::number(buff[4]) + "." + QString::number(buff[5]));
fw_major = QChar(buff[6]);
fw_minor = QChar(buff[7]);
ui->lineEdit_hw_id_txcomprev->setText(QString(fw_major) + "." + QString(fw_minor));
ui->lineEdit_hw_id_txchiprev->setText(QString(QChar(buff[8])));
qDebug() << "Chip identified: SI47" << digistr << "-" << QString(QChar(buff[8])) << QString(QChar(buff[2])) << QString(QChar(buff[3])) << "-GM(R)";
logwrite(LOG_INFO, "CHIP: si47%d, fw=%c.%c, patch_id=0x%02x.0x%02x, "
"chip_fw=%c.%c, chip_rev=%c",
buff[1],
buff[2],buff[3],
buff[4],buff[5],
buff[6],buff[7],
buff[8]);
if ((buff[1] == 11)||(buff[1] == 13)){
if (buff[2] < 2){
qDebug() << "Chip supports RDS, but firmware: " << QString(QChar(buff[8])) << "." << QString(QChar(buff[2])) << "is NOT, please change your chip to more modern one...";
} else {
qDebug() << "Chip supports RDS";
}
}
qDebug() << "Firmware info readed";
return;
display_firmware_err:
qDebug() << "Error while reading firmware info";
}
StrokeGroup::StrokeGroup()
{
try
{
label="none";
nstrokes = 0;
origin[0]=0;
origin[1]=0;
}
catch(exception& e)
{
string str="StrokeGroup:Exception in constructor: ";
str.append(e.what());
logwrite(str);
}
}
static int cf_sap_scope(struct lc_centry *ce, struct lc_value *val) {
if (strcasecmp(val->string, "global") == 0) {
sap->scope=SAP_SCOPE_GLOBAL;
} else if(strcasecmp(val->string, "org") == 0) {
sap->scope=SAP_SCOPE_ORG;
} else if(strcasecmp(val->string, "local") == 0) {
sap->scope=SAP_SCOPE_LOCAL;
} else if(strcasecmp(val->string, "link") == 0) {
sap->scope=SAP_SCOPE_LINK;
} else {
logwrite(LOG_ERROR, "Illegal SAP scope \"%s\" in line %d\n", val->string, ce->vline);
return 0;
}
return 1;
}
// Masks the constant value in the signature tree of a trigger node, if the trigger node was the first
// node to be installed in a constant node under the index structure, and there is some constant value
// that was not copied completely in the constant node; rather its reference was stored.
static void save_const_node_info (syntree *signature_tree)
{
switch (signature_tree->type)
{
case FUNCTION_CALL_TYPE:
// Currently it is being used only by free text predicate index.
ASSERT (tm_stricmp(get_chars (signature_tree->left_tree->datum), "contains") == 0);
// We set the free text predicate syntree in the signature tree to be NULL, so that it is not
// deleted with the triggger's syntax tree. This free text predicate syntree is required by
// the constant node in the index.
signature_tree->right_tree->right_tree->left_tree = NULL;
break;
default:
logwrite ("Internal Error: bad indexable predicate found.");
TMAN_HALT;
}
}
void StrokeGroup::AddStrk2SG(Stroke strk)
{
try
{
if(nstrokes==0)
{
strklist.clear();
}
strklist.push_back(strk);
nstrokes++;
}
catch(exception& e)
{
string str="StrokeGroup:Exception in constructor: ";
str.append(e.what());
logwrite(str);
}
}
StrokeGroup::StrokeGroup(double argorigin[])
{
try
{
label="none";
nstrokes = 0;
origin[0]=argorigin[0];
origin[1]=argorigin[1];
Stroke emptystrk;
emptystrk.RandStrk(0);
strklist.push_back(emptystrk);
}
catch(exception& e)
{
string str="StrokeGroup:Exception in constructor1: ";
str.append(e.what());
logwrite(str);
}
}
/*
* Apply section filter to opened demux interface.
*
*/
int demux_set_sct_filter(int fd, int pid,
struct dmx_filter *df, int flags, int timeout) {
struct dmx_sct_filter_params sctFilterParams;
memset(&sctFilterParams, 0, sizeof(struct dmx_sct_filter_params));
sctFilterParams.pid=pid;
sctFilterParams.timeout=timeout;
sctFilterParams.flags=flags;
memcpy(&sctFilterParams.filter, df, sizeof(struct dmx_filter));
if (ioctl(fd, DMX_SET_FILTER, &sctFilterParams) < 0) {
logwrite(LOG_ERROR, "demux: ioctl DMX_SET_PES_FILTER failed for pid %u",pid);
exit(-1);
}
return 0;
}
static double match_score_ft_basic_pred (ft_doc_index *doc_idx, ft_basic_pred *ft_pred)
{
int basic_pred_type;
ASSERT (ft_pred);
basic_pred_type = ft_pred->basic_pred_type;
switch (basic_pred_type)
{
case FT_OR_TYPE:
return (match_score_or_basic_pred (doc_idx, ft_pred));
case FT_AND_TYPE:
return (match_score_and_basic_pred (doc_idx, ft_pred));
case FT_ACCRUE_TYPE:
return (match_score_accrue_basic_pred (doc_idx, ft_pred));
default:
logwrite ("Internal Error: wrong type '%d' appeared in match_score_ft_basic_pred", basic_pred_type);
TMAN_HALT;
}
return 0.0; // Never reached.
}
static double match_score (ft_doc_index *doc_idx, void *ft_node)
{
int *type;
type = ft_node;
ASSERT (type);
switch (*type)
{
case FT_AND_TYPE:
return (match_score_ft_and (doc_idx, (syntree *)ft_node));
case FT_OR_TYPE:
return (match_score_ft_or (doc_idx, (syntree *)ft_node));
case FT_BASIC_PRED_TYPE:
return (match_score_ft_basic_pred (doc_idx, (ft_basic_pred *)ft_node));
default:
logwrite ("Internal Error: wrong type '%d' appeared in match_score", type);
TMAN_HALT;
}
return 0.0; // Never reached.
}
// Deletes the constant node from the index.
// Calls specific index structure routines to delete the constant node. It is the index implementor's responsibility
// to dispose the constant node properly.
static void delete_const_node_from_pred_index (constant_node *const_node_to_delete, predicate_index *pred_index, int index)
{
int *pred_type;
ASSERT (const_node_to_delete);
ASSERT (pred_index);
pred_type = (int *)pred_index->index; // Get the predicate index type.
switch (*pred_type)
{
case SKIP_LIST_TYPE:
delete_const_node_from_sig_skiplist ((slnode *)const_node_to_delete, pred_index->index);
break;
case FT_PREDICATE_INDEX_TYPE:
delete_const_node_from_ft_pred_index ((ft_pred_constant *)const_node_to_delete, pred_index->index, index);
break;
default:
logwrite ("Internal Error: bad index type encountered while deleting the constant node from predicate index.");
TMAN_HALT;
}
}
RCG_node *get_node_from_RCG(char *name, RCG *graph)
{
ListElement *cursor;
RCG_node *node;
ASSERT (name);
ASSERT (graph);
for (node = (RCG_node *)List_getFirst(graph->nodes, &cursor);
node;
node = (RCG_node *)List_getNext(&cursor))
{
if (strcmp(node->tuple_variable_name, name) == 0)
return node;
}
logwrite ("Internal error: tuple variable %s not found in rule condition graph (RCG).", name);
TMAN_HALT;
return NULL;
}
double StrokeGroup::LocaliseSGCoordSysInChar()
{
Matrix<double> sgbnds;
double offset[2];
try{
sgbnds = SGBounds();
//to shift all strokes in SG such that the left bound is at origin.
origin[0]= sgbnds(1);
//offset[0]=origin[0]*(-1);
offset[0]=origin[0]=0;
origin[1]=offset[1]=0;
MoveSG(offset);
}
catch(exception& e)
{
string str="StrokeGroup:Exception in LocaliseSGCoordSysInChar: ";
str.append(e.what());
logwrite(str);
}
return(origin[0]);
}
Matrix<double> StrokeGroup::SGBounds()
{
Matrix<double> sgbnds(1,4),strkbnds(1,4),tmpbnds;
double xl,xr,yb,yt;
int i,bndsmode;
try{
if(nstrokes==0){
sgbnds.MakeNull();
return sgbnds;
}
bndsmode = 1; //y-coord increases bottom up
for(i=0;i<nstrokes;i++){
tmpbnds = strklist[i].StrkBounds(bndsmode);
if(i==0)
strkbnds=tmpbnds;
strkbnds.Append(tmpbnds,1);
}
xl = strkbnds.Min(1,2);
xr = strkbnds.Max(2,2);
yb = strkbnds.Min(3,2);
yt = strkbnds.Max(4,2);
sgbnds.Set(1,1,xl);
sgbnds.Set(1,2,xr);
sgbnds.Set(1,3,yb);
sgbnds.Set(1,4,yt);
}
catch(exception& e)
{
string str="StrokeGroup:Exception in SGBounds: ";
str.append(e.what());
logwrite(str);
}
return(sgbnds);
}
static int output_cb_http(struct http_connection *hc, int cbtype, void *arg) {
switch(cbtype) {
case(HCB_QUERY): {
struct http_receiver_s *hr;
struct output_s *o=arg; /* HCB_QUERY returns http_url args */
hr=calloc(1, sizeof(struct http_receiver_s));
hr->hc=hc;
hr->output=o;
/* Put into stream output list */
o->http_receiver=g_list_append(o->http_receiver, hr);
o->receiver++;
/* Store http_receiver into http_connection structure */
hc->arg=hr;
/* Return head */
http_header_start(hc, "200 OK", "application/octet-stream");
http_header_nocache(hc);
http_header_clength(hc, -1);
http_header_end(hc);
logwrite(LOG_INFO, "stream_http: connection from %s for %s",
inet_ntoa(hc->sin.sin_addr),
hc->url);
break;
}
case(HCB_ERROR): {
output_remove_receiver(hc->arg);
break;
}
}
return 1;
}
void print_RCG(RCG *graph)
{
ListElement *node_cursor, *tree_cursor;
RCG_node *node;
syntree *tree;
ASSERT(graph);
for (node = List_getFirst(graph->nodes, &node_cursor);
node;
node = List_getNext(&node_cursor))
{
logwrite("Node is %s\n", node->tuple_variable_name);
logwrite("data source is %s\n", node->datasrc_name);
logwrite("The selection predicates in the node are ");
for (tree = List_getFirst(node->selection_predicates_list, &tree_cursor);
tree;
tree = List_getNext(&tree_cursor))
{
print_tree(tree, 0);
logwrite ("");
}
logwrite ("The decorated selction predicate for the node is");
print_tree(node->decorated_selection_predicate, 0);
logwrite ("The join predicates in the node are");
for (tree = List_getFirst(node->join_predicates_list, &tree_cursor);
tree;
tree = List_getNext(&tree_cursor))
{
print_tree(tree, 0);
logwrite ("");
}
}
}
void print_tree (void *arg, int level)
{
int *type;
type = (int *) arg;
if (!type)
return;
/*
* indent (level);
* logwrite ("print_tree: Type code %d @ %p", *type, arg);
*/
switch (*type)
{
case STATEMENT_LIST_TYPE:
statement_list_print_tree (arg, level);
break;
case CREATE_TRIGGER_TYPE:
create_trigger_print_tree (arg, level);
break;
case CREATE_TRIGGERSET_TYPE:
create_triggerset_print_tree (arg, level);
break;
case DROP_TRIGGER_TYPE:
drop_trigger_print_tree (arg, level);
break;
case DROP_TRIGGERSET_TYPE:
drop_triggerset_print_tree (arg, level);
break;
case ENABLE_TRIGGER_TYPE:
enable_trigger_print_tree (arg, level);
break;
case DISABLE_TRIGGER_TYPE:
disable_trigger_print_tree (arg, level);
break;
case ENABLE_ALL_TRIGGERSETS_TYPE:
enable_all_triggersets_print_tree (arg, level);
break;
case DISABLE_ALL_TRIGGERSETS_TYPE:
disable_all_triggersets_print_tree (arg, level);
break;
case ENABLE_TRIGGERSET_TYPE:
enable_triggerset_print_tree (arg, level);
break;
case DISABLE_TRIGGERSET_TYPE:
disable_triggerset_print_tree (arg, level);
break;
case ECHO_TYPE:
echo_print_tree (arg, level);
break;
case DATASRC_SPEC_TYPE:
datasrc_spec_print_tree (arg, level);
break;
case CREATE_DATASRC_TYPE:
create_datasrc_print_tree (arg, level);
break;
case DROP_DATASRC_TYPE:
drop_datasrc_print_tree (arg, level);
break;
case ENABLE_DATASRC_TYPE:
enable_datasrc_print_tree (arg, level);
break;
case DISABLE_DATASRC_TYPE:
disable_datasrc_print_tree (arg, level);
break;
case DOT_TYPE:
dot_print_tree (arg, level);
break;
case ACTION_CLAUSE_TYPE:
action_clause_print_tree (arg, level);
break;
case INT_LIT_TYPE:
int_lit_print_tree (arg, level);
break;
case DBL_LIT_TYPE:
dbl_lit_print_tree (arg, level);
break;
case STR_LIT_TYPE:
str_lit_print_tree (arg, level);
break;
case BOOL_LIT_TYPE:
bool_lit_print_tree (arg, level);
break;
case DECIMAL_LIT_TYPE:
decimal_lit_print_tree(arg, level);
break;
case DATETIME_LIT_TYPE:
datetime_lit_print_tree(arg, level);
break;
case DATE_LIT_TYPE:
date_lit_print_tree(arg, level);
break;
case INTERVAL_LIT_TYPE:
interval_lit_print_tree(arg, level);
break;
case ID_TYPE:
id_print_tree (arg, level);
break;
case AND_TYPE:
and_print_tree (arg, level);
break;
case OR_TYPE:
or_print_tree (arg, level);
break;
case NOT_TYPE:
not_print_tree (arg, level);
break;
case LESS_TYPE:
less_print_tree (arg, level);
break;
case GREATER_TYPE:
greater_print_tree (arg, level);
break;
case EQUAL_TYPE:
equal_print_tree (arg, level);
break;
case NOT_EQUAL_TYPE:
not_equal_print_tree (arg, level);
break;
case LESS_EQUAL_TYPE:
less_equal_print_tree (arg, level);
break;
case GREATER_EQUAL_TYPE:
greater_equal_print_tree (arg, level);
break;
case ADD_TYPE:
add_print_tree (arg, level);
break;
case SUBTRACT_TYPE:
subtract_print_tree (arg, level);
break;
case MULTIPLY_TYPE:
multiply_print_tree (arg, level);
break;
case DIVIDE_TYPE:
divide_print_tree (arg, level);
break;
case UNARY_MINUS_TYPE:
unary_minus_print_tree (arg, level);
break;
case LIKE_TYPE:
like_print_tree (arg, level);
break;
case EXPR_LIST_TYPE:
expr_list_print_tree (arg, level);
break;
case FUNCTION_CALL_TYPE:
function_call_print_tree (arg, level);
break;
case INT_TO_DOUBLE_TYPE:
int_to_double_print_tree (arg, level);
break;
case DBL_TO_SMALLFLT_TYPE:
double_to_smallfloat_print_tree (arg, level);
break;
case DATE_TO_DATETIME_TYPE:
date_to_datetime_print_tree(arg, level);
break;
case DOUBLE_TO_DECIMAL_TYPE:
double_to_decimal_print_tree(arg, level);
break;
case INT_TO_DECIMAL_TYPE:
int_to_decimal_print_tree(arg, level);
break;
case FROM_CLAUSE_TYPE:
from_clause_print_tree (arg, level);
break;
case DATASRC_LIST_TYPE:
datasrc_list_print_tree (arg, level);
break;
case IN_TYPE:
in_print_tree (arg, level);
break;
case WHEN_CLAUSE_TYPE:
when_clause_print_tree (arg, level);
break;
case AFTER_CLAUSE_TYPE:
after_clause_print_tree (arg, level);
break;
case COMM_BLOCK_TYPE:
comm_block_print_tree (arg, level);
break;
case UPDATE_TYPE:
update_print_tree (arg, level);
break;
case INSERT_TYPE:
insert_print_tree (arg, level);
break;
case INSERT_UPDATE_TYPE:
insert_update_print_tree (arg, level);
break;
case DELETE_TYPE:
delete_print_tree (arg, level);
break;
case FORM_PARAM_LIST_TYPE:
form_param_list_print_tree (arg, level);
break;
case PARAM_SPEC_TYPE:
param_spec_print_tree (arg, level);
break;
case TYPE_TYPE:
type_print_tree (arg, level);
break;
case TYPEEXT_TYPE:
typeext_print_tree (arg, level);
break;
case TYPE_NAME_TYPE:
type_name_print_tree (arg, level);
break;
case EXECSQL_TYPE:
execsql_print_tree (arg, level);
break;
case DATASRC_NAME_TYPE:
datasrc_name_print_tree (arg, level);
break;
case SKIP_TYPE:
skip_print_tree (arg, level);
break;
case SUBMIT_TYPE:
submit_print_tree (arg, level);
break;
case SOURCE_TYPE:
source_print_tree (arg, level);
break;
case SEND_NOTICE_TYPE:
send_notice_print_tree (arg, level);
break;
case NOTICE_MESSAGE_TYPE:
notice_message_print_tree (arg, level);
break;
case SEND_MAIL_TYPE:
send_mail_print_tree (arg, level);
break;
case EMAIL_ADDR_TYPE:
email_addr_print_tree(arg, level);
break;
case EMAIL_CONTENT_TYPE:
email_content_print_tree(arg, level);
break;
case FT_PREDICATE_TYPE:
ft_predicate_print_tree (arg, level);
break;
case FT_OR_TYPE:
ft_or_print_tree (arg, level);
break;
case FT_ACCRUE_TYPE:
ft_accrue_print_tree (arg, level);
break;
case FT_AND_TYPE:
ft_and_print_tree (arg, level);
break;
case FT_NOT_TYPE:
ft_not_print_tree (arg, level);
break;
case FT_WORD_TYPE:
ft_word_print_tree (arg, level);
break;
case FT_PHRASE_TYPE:
ft_phrase_print_tree (arg, level);
break;
case FT_BASIC_PRED_TYPE:
ft_basic_pred_print_tree (arg, level);
break;
case FT_PHRASE_INFO_TYPE:
ft_phrase_info_print_tree (arg, level);
break;
case VARARRAY_TYPE:
va_print_tree (arg, level);
break;
case FT_DOC_INDEX_TYPE:
ft_doc_index_print_tree (arg);
break;
case FT_DOC_TRIE_LEAF_TYPE:
ft_doc_trie_leaf_print_tree ((ft_doc_trie_leaf *)arg, level);
break;
case FT_DOC_TRIE_BRANCH_TYPE:
ft_doc_trie_branch_print_tree ((ft_doc_trie_branch *)arg, level);
break;
case FT_PRED_TRIE_NODE_TYPE:
ft_pred_trie_node_print_tree ((ft_pred_trie_node *)arg, level);
break;
case FT_PRED_TRIE_BRANCH_TYPE:
ft_pred_trie_branch_print_tree ((ft_pred_trie_branch *)arg, level);
break;
case FT_PRED_TRIE_LEAF_TYPE:
ft_pred_trie_leaf_print_tree ((ft_pred_trie_leaf *)arg, level);
break;
default:
logwrite ("Internal error: called print_tree with unknown type code %d.", *type);
TMAN_HALT;
break;
}
}
int getifaddr(const char *ifname, char *ipaddr) {
/* init vars */
int numreqs = 30, sd, n, tick, found=0;
struct ifconf ifc;
struct ifreq *ifr;
struct in_addr *ia;
char *tmpip;
/* cheap way to empty the result */
*ipaddr = '\0';
sd=socket(AF_INET, SOCK_STREAM, 0);
ifc.ifc_buf = NULL;
ifc.ifc_len = sizeof(struct ifreq) * numreqs;
if ((ifc.ifc_buf = realloc(ifc.ifc_buf, ifc.ifc_len)) == NULL) {
logwrite("getifaddr: Fatal error in memory allocation");
close(sd);
prg_exit(EXIT_FAILURE);
return(-1);
}
if (ioctl(sd, SIOCGIFCONF, &ifc) < 0) {
free(ifc.ifc_buf);
close(sd);
logwrite("getifaddr: error in ioctl call");
return(-1);
}
ifr = ifc.ifc_req;
for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq)) {
ia= (struct in_addr *) ((ifr->ifr_ifru.ifru_addr.sa_data)+2);
if ((tick = strcmp(ifr->ifr_ifrn.ifrn_name, ifname)) == 0) {
tmpip = inet_ntoa(*ia);
if (log_verbose) {
sprintf(msg, "getifaddr: IP of %s:%s", ifname, tmpip);
logwrite(msg);
}
if (sscanf(tmpip, "%u.%u.%u.%u", &int_tmp,&int_tmp,&int_tmp,&int_tmp) == 4) {
strncpy(ipaddr, tmpip, IPADDR_LEN);
found = 1;
} else {
if (log_verbose) logwrite("getifaddr: error in IP format");
}
break;
}
ifr++;
}
free(ifc.ifc_buf);
close(sd);
if (found) {
return(0);
} else {
return(-1);
}
}
void open_db_connection (TM_CONN_HNDL *conn_hndl)
{
TM_CONNECTION *conn;
SQLRETURN retcode;
*conn_hndl = tman_malloc(sizeof(TM_CONNECTION));
conn = (TM_CONNECTION *) *conn_hndl;
/*Allocate environment handle */
retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(conn->henv));
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
{
/* Set the ODBC version environment attribute */
retcode = SQLSetEnvAttr(conn->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
{
/* Allocate connection handle */
retcode = SQLAllocHandle(SQL_HANDLE_DBC, conn->henv, &(conn->hdbc));
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
{
/* Set login timeout to 5 seconds. */
#pragma warning (disable : 4022)
SQLSetConnectAttr(conn->hdbc, SQL_LOGIN_TIMEOUT, 5, 0);
#pragma warning (default : 4022)
/* Connect to data source */
retcode = SQLConnect(conn->hdbc, (SQLCHAR*) odbc_dsn, SQL_NTS,
(SQLCHAR*) username, SQL_NTS,
(SQLCHAR*) password, SQL_NTS);
if ((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO))
{
checkerr(conn->henv, SQL_HANDLE_ENV);
logwrite("Error: could not open a connection to the ODBC data source.");
logwrite("Please verify that the Configuration Wizard has been run, the DBMS is running,");
logwrite("and that the username and password are valid.");
SQLFreeHandle(SQL_HANDLE_DBC, conn->hdbc);
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
tman_free(conn_hndl);
return;
}
}
else
{
checkerr(conn->henv, SQL_HANDLE_ENV);
logwrite("Error: could not connect to ODBC data source. Please check the username, password and permissions.");
logwrite("Ensure that the DBMS is running.");
SQLFreeHandle(SQL_HANDLE_DBC, conn->hdbc);
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
tman_free(conn_hndl);
return;
}
}
}
else
{
checkerr(conn->henv, SQL_HANDLE_ENV);
logwrite("Error: could not connect to ODBC data source. Please check the username, password and permissions.");
logwrite("Ensure that the DBMS is running.");
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
tman_free(conn_hndl);
}
}
