int rts_error_va(void *csa, int argcnt, va_list var)
{
int msgid;
va_list var_dup;
const err_ctl *ctl;
# ifdef DEBUG
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (TREF(rts_error_unusable) && !TREF(rts_error_unusable_seen))
{
TREF(rts_error_unusable_seen) = TRUE;
/* The below assert ensures that this rts_error invocation is appropriate in the current context of the code that
* triggered this rts_error. If ever this assert fails, investigate the window of DBG_MARK_RTS_ERROR_UNUSABLE
* and DBG_MARK_RTS_ERROR_USABLE in the call-stack.
*/
assert(FALSE);
}
# endif
VAR_COPY(var_dup, var);
if (-1 == gtm_errno)
gtm_errno = errno;
msgid = va_arg(var_dup, int);
/* If there was a previous fatal error that did not yet get printed, do it before overwriting the
* util_output buffer with the about-to-be-handled nested error. This way one will see ALL the
* fatal error messages (e.g. assert failures) in the order in which they occurred instead of
* just the last nested one.
*/
if (DUMPABLE)
PRN_ERROR;
/* This is simply a place holder msg to signal tp restart or otherwise rethrow an error */
if ((ERR_TPRETRY == msgid) || (ERR_REPEATERROR == msgid) || (ERR_REPLONLNRLBK == msgid) || (ERR_JOBINTRRQST == msgid)
|| (ERR_JOBINTRRETHROW == msgid))
{
SET_ERROR_CONDITION(msgid); /* sets "error_condition" & "severity" */
} else
{ /* Note this message is not flushed out. This is so user console is not polluted with messages that are going to be
* handled by a ZTRAP. If ZTRAP is not active, the message will be flushed out in mdb_condition_handler - which is
* usually the top level handler or is rolled over into by higher handlers.
*/
if (IS_GTMSECSHR_IMAGE)
util_out_print(NULL, RESET);
SET_ERROR_CONDITION(msgid); /* sets "error_condition" & "severity" */
gtm_putmsg_list(csa, argcnt, var);
if (DUMPABLE)
created_core = dont_want_core = FALSE; /* We can create a(nother) core now */
if (IS_GTMSECSHR_IMAGE)
util_out_print(NULL, OPER); /* gtmsecshr errors always immediately pushed out */
}
va_end(var_dup);
va_end(var);
DRIVECH(msgid); /* Drive the topmost (inactive) condition handler */
/* Note -- at one time there was code here to catch if we returned from the condition handlers
* when the severity was error or above. That code had to be removed because of several errors
* that are handled and returned from. An example is EOF errors. SE 9/2000
*/
return 0;
}
static int
hitlist_sql_safe_update(hitlist_t *hl, var_t *record, char *value_field,
VAR_INT_T value_diff, char *expire_field, VAR_INT_T expire_diff)
{
var_t *record_copy = NULL;
var_t *field;
int status = -1;
record_copy = VAR_COPY(record);
if (record_copy == NULL)
{
log_error("hitlist_sql_safe_update: var_copy failed");
goto exit;
}
field = vlist_record_lookup(record_copy, value_field);
if (field == NULL)
{
log_error("hitlist_sql_safe_update: vlist_get for %s failed", value_field);
goto exit;
}
* (VAR_INT_T *) field->v_data = value_diff;
field->v_flags |= VF_SQL_SAFE_UPDATE;
field = vlist_record_lookup(record_copy, expire_field);
if (field == NULL)
{
log_error("hitlist_sql_safe_update: vlist_get for %s failed", expire_field);
goto exit;
}
* (VAR_INT_T *) field->v_data = expire_diff;
field->v_flags |= VF_SQL_SAFE_UPDATE;
status = dbt_db_set(&hl->hl_dbt, record_copy);
if (status)
{
log_error("hitlist_sql_safe_update: dbt_db_set failed");
}
exit:
if (record_copy)
{
var_delete(record_copy);
}
return status;
}
static int eval_expression_go(struct _asm_context *asm_context, struct _var *var, struct _operator *last_operator)
{
char token[TOKENLEN];
int token_type;
struct _var var_stack[3];
int var_stack_ptr = 1;
struct _operator operator;
int last_token_was_op = -1;
#ifdef DEBUG
printf("Enter eval_expression_go, var=%d/%f/%d\n", var_get_int32(var), var_get_float(var), var_get_type(var));
#endif
memcpy(&operator, last_operator, sizeof(struct _operator));
VAR_COPY(&var_stack[0], var);
while(1)
{
#ifdef DEBUG
printf("eval_expression> going to grab a token\n");
#endif
token_type = tokens_get(asm_context, token, TOKENLEN);
#ifdef DEBUG
printf("eval_expression> token=%s var_stack_ptr=%d\n", token, var_stack_ptr);
#endif
// Issue 15: Return an error if a stack is full with noe operator.
if (var_stack_ptr == 3 && operator.operation == OPER_UNSET)
{
return -1;
}
if (token_type == TOKEN_QUOTED)
{
if (token[0] == '\\')
{
int e = tokens_escape_char(asm_context, (unsigned char *)token);
if (e == 0) return -1;
if (token[e+1] != 0)
{
print_error("Quoted literal too long.", asm_context);
return -1;
}
sprintf(token, "%d", token[e]);
}
else
{
if (token[1]!=0)
{
print_error("Quoted literal too long.", asm_context);
return -1;
}
sprintf(token, "%d", token[0]);
}
token_type = TOKEN_NUMBER;
}
// Open and close parenthesis
if (IS_TOKEN(token,'('))
{
if (last_token_was_op == 0 && operator.operation != OPER_UNSET)
{
operate(&var_stack[var_stack_ptr-2], &var_stack[var_stack_ptr-1], last_operator);
var_stack_ptr--;
operator.operation = OPER_UNSET;
VAR_COPY(var, &var_stack[var_stack_ptr-1]);
tokens_push(asm_context, token, token_type);
return 0;
}
if (operator.operation == OPER_UNSET && var_stack_ptr == 2)
{
// This is probably the x(r12) case.. so this is actually okay
VAR_COPY(var, &var_stack[var_stack_ptr-1]);
tokens_push(asm_context, token, token_type);
return 0;
}
struct _var paren_var;
struct _operator paren_operator;
paren_operator.precedence = PREC_UNSET;
paren_operator.operation = OPER_UNSET;
memset(&paren_var, 0, sizeof(struct _var));
if (eval_expression_go(asm_context, &paren_var, &paren_operator) != 0)
{
return -1;
}
last_token_was_op = 0;
#ifdef DEBUG
printf("Paren got back %d/%f/%d\n", var_get_int32(&paren_var), var_get_float(&paren_var), var_get_type(&paren_var));
#endif
VAR_COPY(&var_stack[var_stack_ptr++], &paren_var);
token_type = tokens_get(asm_context, token, TOKENLEN);
if (!(token[1] == 0 && token[0] == ')'))
{
print_error("No matching ')'", asm_context);
return -1;
}
continue;
}
if (IS_TOKEN(token,')'))
{
tokens_push(asm_context, token, token_type);
break;
}
// End of expression
if (IS_TOKEN(token,',') || IS_TOKEN(token,']') || token_type == TOKEN_EOF ||
IS_TOKEN(token,'.'))
{
tokens_push(asm_context, token, token_type);
break;
}
if (token_type == TOKEN_EOL)
{
//asm_context->tokens.line++;
tokens_push(asm_context, token, token_type);
break;
}
// Read number
if (token_type == TOKEN_NUMBER)
{
last_token_was_op = 0;
if (var_stack_ptr == 3)
{
print_error_unexp(token, asm_context);
return -1;
}
var_set_int(&var_stack[var_stack_ptr++], atoll(token));
}
else
if (token_type == TOKEN_FLOAT)
{
if (var_stack_ptr == 3)
{
print_error_unexp(token, asm_context);
return -1;
}
var_set_float(&var_stack[var_stack_ptr++], atof(token));
}
else
if (token_type == TOKEN_SYMBOL)
{
last_token_was_op = 1;
struct _operator operator_prev;
memcpy(&operator_prev, &operator, sizeof(struct _operator));
if (get_operator(token, &operator) == -1)
{
print_error_unexp(token, asm_context);
return -1;
}
// Issue 15: 2015-July-21 mkohn - If operator is ~ then reverse
// the next number.
if (operator.operation == OPER_NOT)
{
int64_t num;
if (parse_unary(asm_context, &num, OPER_NOT) != 0) { return -1; }
if (var_stack_ptr == 3)
{
print_error_unexp(token, asm_context);
return -1;
}
var_set_int(&var_stack[var_stack_ptr++], num);
memcpy(&operator, &operator_prev, sizeof(struct _operator));
last_token_was_op = 0;
continue;
}
// Stack pointer probably shouldn't be less than 2
if (var_stack_ptr == 0)
{
printf("Error: Unexpected operator '%s' at %s:%d\n", token, asm_context->tokens.filename, asm_context->tokens.line);
return -1;
}
#ifdef DEBUG
printf("TOKEN %s: precedence %d %d\n", token, last_operator->precedence, operator.precedence);
#endif
if (last_operator->precedence == PREC_UNSET)
{
memcpy(last_operator, &operator, sizeof(struct _operator));
}
else
if (last_operator->precedence > operator.precedence)
{
if (eval_expression_go(asm_context, &var_stack[var_stack_ptr-1], &operator) == -1)
{
return -1;
}
}
else
{
operate(&var_stack[var_stack_ptr-2], &var_stack[var_stack_ptr-1], last_operator);
var_stack_ptr--;
memcpy(last_operator, &operator, sizeof(struct _operator));
}
}
else
{
if (asm_context->pass != 1)
{
print_error_unexp(token, asm_context);
}
return -1;
}
}
#ifdef DEBUG
printf("going to leave operation=%d\n", last_operator->operation);
PRINT_STACK()
#endif
if (last_operator->operation != OPER_UNSET)
{
operate(&var_stack[var_stack_ptr-2], &var_stack[var_stack_ptr-1], last_operator);
var_stack_ptr--;
}
VAR_COPY(var, &var_stack[var_stack_ptr-1]);
return 0;
}
dbt_unlock(dbt);
return r;
}
int
dbt_db_get_from_table(dbt_t *dbt, var_t *attrs, var_t **record)
{
var_t *lookup = NULL;
var_t *v, *template;
ll_t *scheme_ll, *lookup_ll;
ll_entry_t *scheme_pos, *lookup_pos;
lookup = VAR_COPY(dbt->dbt_scheme);
if (lookup == NULL)
{
log_error("dbt_db_get_from_table: VAR_COPY failed");
return -1;
}
scheme_ll = dbt->dbt_scheme->v_data;
scheme_pos = LL_START(scheme_ll);
lookup_ll = lookup->v_data;
lookup_pos = LL_START(lookup_ll);
for (;;)
{
template = ll_next(scheme_ll, &scheme_pos);
caddr_t util_format(caddr_t message, va_list fao, caddr_t buff, int4 size, int faocnt)
{
desc_struct *d;
signed char schar;
unsigned char type, type2;
caddr_t c, outptr, outtop;
uchar_ptr_t ret_ptr;
unsigned char uchar;
short sshort, *s;
unsigned short ushort;
int i, length, max_chars, field_width, repeat_count, int_val;
boolean_t indirect;
qw_num_ptr_t val_ptr;
unsigned char numa[22];
unsigned char *numptr;
VAR_COPY(last_va_list_ptr, fao);
outptr = buff;
outtop = outptr + size - 5; /* 5 bytes to prevent writing across border */
/* 5 comes from line 268 -- 278 */
while (outptr < outtop)
{
/* Look for the '!' that starts an FAO directive */
while ((schar = *message++) != '!')
{
if (schar == '\0')
{
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}
*outptr++ = schar;
if (outptr >= outtop)
{
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}
}
field_width = 0; /* Default values */
repeat_count = 1;
/* Look for a field width (or repeat count) */
if (*message == '#')
{
if (0 < faocnt)
field_width = repeat_count = va_arg(fao, int4);
++message;
} else
{
for (c = message; *c >= '0' && *c <= '9'; ++c)
;
if ((length = c - message) > 0)
{
field_width = repeat_count
= asc2i((uchar_ptr_t)message, length);
message = c;
}
}
if ('@' == *message) /* Indirectly addressed operand */
{
indirect = TRUE;
message++;
} else
indirect = FALSE;
switch (type = *message++)
{
case '/':
assert(!indirect);
*outptr++ = '\n';
continue;
case '_':
assert(!indirect);
*outptr++ = '\t';
continue;
case '^':
assert(!indirect);
*outptr++ = '\f';
continue;
case '!':
assert(!indirect);
*outptr++ = '!';
continue;
case '*':
assert(!indirect);
while ((repeat_count-- > 0) && (outptr < outtop))
*outptr++ = *message;
++message;
continue;
case 'A':
assert(!indirect);
switch(type2 = *message++)
{
case 'C':
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
length = c ? *c++ : 0;
break;
case 'D':
case 'F':
GETFAOVALDEF(faocnt, fao, int4, length, 0);
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
break;
case 'S':
if (faocnt)
{
d = (desc_struct *)va_arg(fao, caddr_t);
faocnt--;
c = d->addr;
length = d->len;
} else
{
c = NULL;
length = 0;
}
break;
case 'Z':
GETFAOVALDEF(faocnt, fao, caddr_t, c, NULL);
length = c ? strlen(c) : 0;
}
max_chars = MIN((outtop - outptr - 1),
(0 == field_width ? length : MIN(field_width, length)));
for (i = 0; i < max_chars; ++i, ++c)
if (type2 == 'F' && (*c < ' ' || *c > '~'))
*outptr++ = '.';
else if (*c == '\0')
--i; /* Don't count nul characters */
else
*outptr++ = *c;
assert(0 <= field_width);
assert(0 <= max_chars);
for (i = field_width - max_chars; i > 0; --i)
*outptr++ = ' ';
continue;
default: /* Rest of numeric types come here */
assert('S' == type || 'U' == type || 'X' == type || 'Z' == type);
numptr = numa;
type2 = *message++;
if (!indirect)
{
if ('S' == type)
switch(type2)
{
case 'B':
GETFAOVALDEF(faocnt, fao, int4, schar, 0);
int_val = schar;
break;
case 'W':
GETFAOVALDEF(faocnt, fao, int4, sshort, 0);
int_val = sshort;
break;
case 'L':
GETFAOVALDEF(faocnt, fao, int4, int_val, 0);
break;
default:
assert(FALSE);
}
else
{
GETFAOVALDEF(faocnt, fao, int4, int_val, 0);
switch(type2)
{
case 'B':
int_val = int_val & 0xFF;
break;
case 'W':
int_val = int_val & 0xFFFF;
break;
case 'L':
int_val = int_val & 0xFFFFFFFF;
break;
default:
assert(FALSE);
}
}
switch (type)
{
case 'S': /* Signed value. Give sign if need to */
if (0 > int_val)
{
*numptr++ = '-';
int_val = -(int_val);
} /* note fall into unsigned */
case 'U':
case 'Z': /* zero filled */
numptr = i2asc(numptr, int_val);
break;
case 'X': /* Hex */
switch (type2)
{ /* length is number of ascii hex chars */
case 'B':
length = sizeof(short);
break;
case 'W':
length = sizeof(int4);
break;
case 'L':
length = sizeof(int4) + sizeof(int4);
break;
default:
assert(FALSE);
}
i2hex(int_val, numptr, length);
numptr += length;
break;
default:
assert(FALSE);
}
} else
{
if ('X' == type) /* Support XH and XJ */
{
assert('H' == type2 || 'J' == type2);
GETFAOVALDEF(faocnt, fao, qw_num_ptr_t, val_ptr, NULL); /* Addr of long type */
if (val_ptr)
{
if (0 != field_width)
{
i2hexl(*val_ptr, numptr, field_width);
numptr += field_width;
} else
{
length = i2hexl_nofill(*val_ptr, numptr, HEX16);
numptr += length;
}
}
} else /* support ZH and ZJ */
{
if ('Z' != type)
GTMASSERT;
assert('H' == type2 || 'J' == type2);
GETFAOVALDEF(faocnt, fao, qw_num_ptr_t, val_ptr, NULL); /* Addr of long type */
if (val_ptr)
{
ret_ptr = i2ascl(numptr, *val_ptr);
length = ret_ptr - (uchar_ptr_t)numptr;
if (0 != field_width)
numptr += MIN(length, field_width);
else
numptr += length;
}
}
}
length = numptr - numa; /* Length of asciified number */
max_chars = MIN((outtop - outptr - 1),
(0 == field_width ? length : MIN(field_width, length)));
if (length < field_width)
{
memset(outptr, (('Z' == type) ? '0' : ' '), field_width - length);
outptr += field_width - length;
}
if ((field_width > 0) && (field_width < length))
{
memset(outptr, '*', field_width);
outptr += field_width;
} else
{
memcpy(outptr, numa, length);
outptr += length;
}
}
}
VAR_COPY(last_va_list_ptr, fao);
return outptr;
}