/*
** Name: pmerr_func - error handling function for PM errors.
**
** Description:
** This routine is called when a PM error is encountered. Typically, this
** is some sort of syntax error revolving around the contents of
** config.dat. This routine formats the error message and displays it to
** the screen.
**
** Inputs:
** err_number - Some specific error number.
** num_arguments - number ofentries in the args array.
** args - an array of error message arguments.
**
** Outputs:
** NOne
**
** Returns:
** VOID
**
** History:
** 22-nov-1993 (bryanp)
** Created for handling config.dat errors.
*/
static VOID
pmerr_func( STATUS err_number, i4 num_arguments, ER_ARGUMENT *args)
{
STATUS status;
char message[ER_MAX_LEN];
i4 text_length;
CL_ERR_DESC sys_err;
status = ERslookup( err_number, (CL_ERR_DESC*)0,
0,
(char *)NULL,
message,
ER_MAX_LEN,
(i4) -1,
&text_length,
&sys_err,
num_arguments,
args
);
if ( status != OK )
{
SIprintf( "IIRUNDBMS: Unable to look up PM error %x\n", err_number );
}
else
{
SIprintf( "IIRUNDBMS: %.*s\n", text_length, message );
}
return;
}
/*{
** Name: II_GetIngresErrorMessage - Lookup error message from message file
**
** Description:
** Return the text associated with the Ingres status.
** The function returns the text associated with the Ingres status including
** the decoded facility representation of the status in the text.
**
** Inputs:
** ingres_status Retrieve the text message associated with this
** value.
** message_length Length of the buffer area to write the message
** including additional space for the end of string
** marker.
** message Pointer to the memory area where the retrieved
** message is to be written.
**
** Outputs:
** message_length If the function returns II_SUCCESSFUL the
** message_length field contains the number of
** storage octets in the message area that were used.
** message The message text associated with the Ingres
** status.
**
** Returns:
** II_SUCCESSFUL The message was retrieved successfully
** II_NULL_PARAM The parameters passed are invalid; no output
** fields are updated.
** II_INSUFFICIENT_BUFFER A larger message area is required.
** II_GET_MESSAGE_ERROR An error orccured during the execution of this
** function.
**
** Example:
** # include "tngapi.h"
**
** II_INT4 status;
** II_INT4 ingres_status = 0xC0132;
** II_INT4 message_length = 20;
** II_CHAR message[MAX_IIERR_LEN + 1;
**
** status = II_GetIngresMessage( ingres_status, &message_length, message );
** if (status != II_SUCCESSFUL)
** {
** if (status == II_INSUFFICIENT_BUFFER)
** {
** printf( "A larger buffer is required\n" );
** }
** }
**
** message_length = MAX_IIERR_LEN + 1;
** status = II_GetIngresMessage( ingres_status, &message_length, message );
** if (status != II_SUCCESSFUL)
** {
** printf( "II_GetIngresMessage failed\n" );
** }
**
** History:
** 20-Jan-2005 (fanra01)
** Created.
}*/
int
II_GetIngresMessage(
unsigned int ingres_status,
int* message_length,
char* message )
{
i4 status;
CL_ERR_DESC clerror;
i4 flags;
i4 msglen = 0;
CL_CLEAR_ERR( &clerror );
while(TRUE)
{
/*
** If any of the parameters are not valid, stop.
*/
if ((message == NULL) || (message_length == NULL) ||
(*message_length == 0))
{
status = II_NULL_PARAM;
break;
}
/*
** Call ERslookup to get the message text from the message file.
** Let the value of flags be:
** ~ER_TEXTONLY is not set, the error is decoded to include
** the error identifier.
** ER_NOPARAM there are no parameter values provided to be
** entered into the message string.
** Let the value of language be:
** -1 use the default language.
*/
flags = ER_NOPARAM;
status = ERslookup( ingres_status, NULL, flags, NULL, message,
*message_length, -1, &msglen, &clerror, 0, NULL );
switch(status)
{
case OK:
*message_length = STlength( message );
status = II_SUCCESSFUL;
break;
case ER_TOOSMALL:
status = II_INSUFFICIENT_BUFFER;
break;
default:
status = II_GET_MESSAGE_ERROR;
break;
}
break;
}
return(status);
}
static char *
er_decode( STATUS msg_id )
{
STATUS old_err;
STATUS errstat;
CL_ERR_DESC err_code;
i4 ret_len;
char lbuf[ sizeof(ERbuf) ];
if( msg_id == OK )
{
errstat = OK;
STcopy( "OK", ERbuf );
}
else if ((errstat = ERslookup(msg_id, /* msg num */
NULL, /* input cl err */
0, /* flags */
(char *) NULL, /* sqlstate */
ERbuf, /* buf */
sizeof(ERbuf), /* sizeof buf */
-1, /* language */
&ret_len, /* msg len */
&err_code, /* output err */
0, /* num params */
NULL) /* params */
) != OK)
{
/* Recurse to decode ER error. If we were processing error
already, give up to halt recursion */
old_err = ERstat; /* OK first time in */
ERstat = errstat; /* now not OK second time through */
if( old_err == OK )
STcopy( lbuf, er_decode( errstat ) );
else
STprintf(ERbuf, "ER err 0x%x", errstat );
STprintf( ERbuf, "0x%x not found: %s", msg_id, lbuf );
}
/* Clear recursion check */
ERstat = OK;
return( ERbuf );
}
int
main(int c, char **v)
{
i4 msg_id;
i4 cnt = 0;
char mbuf[ER_MAX_LEN];
i4 ret_len = 0;
char msgbuf[101];
CL_ERR_DESC clerror;
CL_ERR_DESC err_code;
STATUS stat;
i4 flag = 0;
bool testsysdep = FALSE;
bool logoper = FALSE;
MEadvise(ME_INGRES_ALLOC);
for (++v, --c; c > 0; ++v, --c)
{
char *w = *v;
if (w[0] == '-')
{
switch (w[1])
{
case 't':
flag |= ER_TIMESTAMP;
break;
case 'n':
flag |= ER_NOPARAM;
break;
case 's':
testsysdep = TRUE;
break;
case 'o':
logoper = TRUE;
break;
default:
SIfprintf(stderr, "only valid options are -t, -s, -n and -o\n");
PCexit(FAIL);
}
}
else
SIfprintf(stderr, "ignoring invalid argument \"%s\"\n", v);
}
if (testsysdep) /* test system dependent error reporting */
{
extern int errno;
errno = 13; /* EACCES */
SETCLERR(&clerror, 0x10911, /* ER_INTERR_TESTMSG */ ER_open);
STcopy("II_MSGDIR/erclf.msg", clerror.moreinfo[0].data.string);
clerror.moreinfo[0].size = STlength(clerror.moreinfo[0].data.string);
}
while ((cnt++) < MAX_NUM_OF_LOOKUPS)
{
msg_id = -1;
SIfprintf(stderr, "msg id, in hex, no 0x%s: ",
testsysdep? " (try 10904) " : "");
if( OK != SIgetrec(msgbuf, 100, stdin) )
break;
#if defined(any_aix) && defined(BUILD_ARCH64)
(VOID) STscanf(msgbuf, "%x", &msg_id);
#else
(VOID) STscanf(msgbuf, "%p", &msg_id);
#endif
if (msg_id == -1)
break;
if ((stat = ERslookup(msg_id, testsysdep? &clerror : NULL, flag,
(char *) NULL, mbuf, ER_MAX_LEN, -1, &ret_len, &err_code, 5,
er_arg)) != OK)
{
SIfprintf(stderr,
"ERslookup error. msg id is 0x%x, status is 0x%x\n",
msg_id, stat);
}
else
{
SIfprintf(stderr, "*** ERslookup:\n%s\n", mbuf);
SIfprintf(stderr, "*** ERget:\n%s\n", ERget(msg_id));
}
if (testsysdep)
{
if ((stat = ERslookup(0, &clerror, flag, (char *) NULL, mbuf,
ER_MAX_LEN, -1, &ret_len, &err_code, 5, er_arg)) != OK)
{
SIfprintf(stderr,
"ERslookup error on CL_ERR_DESC. Status is 0x%x\n", stat);
}
else
SIfprintf(stderr, "*** ERslookup (CL error):\n%s\n",mbuf);
}
if (logoper)
{
ERsend( ER_ERROR_MSG|ER_OPER_MSG, mbuf, ret_len, &err_code );
}
}
PCexit(OK);
}
/*{
** Name: rms_dterr - Datatype-related error handler
**
** Description:
** This routine accepts an error code and up to 3 parameter/length pairs
** and inserts this and other information into the ADF control block
** passed to it. This routine, therefore, returns errors as if it were
** ADF; its callers should treat errors from this module the same way it
** treats ADF errors.
**
** Inputs:
** scb The ADF_CB which contains the error block
** adf_errcb
** ad_ebuflen Length of following buffer (if 0, no msg desired)
** ad_errmsgp Pointer to buffer for msg (if NULL, no msg desired)
** errnum The GWF error number of the error
** num_params The number of parameter pairs needed to format this
** error's error message
** p1l Length of parameter 1
** p1p Parameter 1
** .... More of the same (up to 3 pairs)
**
** Outputs:
** scb Contains adf_errcb to hold error info
** adf_errcb
** ad_errcode Error code of error being returned
** ad_class User error or internal error
** ad_usererr Same as ad_errcode
** ad_sqlstate The sqlstate status code for this error
** ad_emsglen Length of msg put into following buffer
** ad_errmsgp Error msg if this pointer was not NULL
**
** Returns:
** E_DB_OK, E_DB_WARN, E_DB_ERROR (depending on the error)
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 01-apr-90 (jrb)
** Created.
** 29-oct-92 (andre)
** in ADF_ERROR, ad_generic_error has been replaced with ad_sqlstate +
** ERlookup() was renamed to ERslookup() and its interface was changed
** to return sqlstate status code instead of generic error number
** 06-nov-96 (lawst01) changed define name from SS50000_MISC_ING_ERRORS
** to SS50000_MISC_ERRORS to match changed name in header file
** sqlstate.h.
[@history_template@]...
*/
DB_STATUS
rms_dterr
(
ADF_CB *scb,
i4 errnum,
i4 num_params,
i4 p1l,
PTR p1p,
i4 p2l,
PTR p2p,
i4 p3l,
PTR p3p
)
{
DB_STATUS status = E_DB_ERROR;
ADF_ERROR *errcb;
STATUS tmp_status;
CL_SYS_ERR sys_err;
ER_ARGUMENT parms[3];
if (scb == NULL)
return(status);
errcb = &scb->adf_errcb;
switch (errnum)
{
case E_GW7026_BAD_FLT_TO_MNY:
case E_GW7050_BAD_ERLOOKUP:
case E_GW7100_NOCVT_AT_STARTUP:
case E_GW7999_INTERNAL_ERROR:
errcb->ad_errclass = ADF_INTERNAL_ERROR;
default:
errcb->ad_errclass = ADF_USER_ERROR;
}
errcb->ad_errcode = errcb->ad_usererr = errnum;
/* see if user really wants an error msg */
if (errcb->ad_ebuflen == 0 || errcb->ad_errmsgp == NULL)
{
char *sqlstate_str = SS50000_MISC_ERRORS;
i4 i;
for (i = 0; i < DB_SQLSTATE_STRING_LEN; i++)
errcb->ad_sqlstate.db_sqlstate[i] = sqlstate_str[i];
errcb->ad_emsglen = 0;
return(status);
}
switch (num_params)
{
case 3:
parms[2].er_size = p3l;
parms[2].er_value = p3p;
/* fall through */
case 2:
parms[1].er_size = p2l;
parms[1].er_value = p2p;
/* fall through */
case 1:
parms[0].er_size = p1l;
parms[0].er_value = p1p;
/* fall through */
case 0:
tmp_status = ERslookup(errnum, 0, ER_TIMESTAMP,
errcb->ad_sqlstate.db_sqlstate,
errcb->ad_errmsgp, errcb->ad_ebuflen, -1,
&errcb->ad_emsglen, &sys_err, num_params,
parms);
break;
}
/* If ERlookup failed, handle it */
if (tmp_status != OK)
{
char *sqlstate_str = SS50000_MISC_ERRORS;
i4 i;
for (i = 0; i < DB_SQLSTATE_STRING_LEN; i++)
errcb->ad_sqlstate.db_sqlstate[i] = sqlstate_str[i];
errcb->ad_errcode = E_GW7050_BAD_ERLOOKUP;
errcb->ad_errclass = ADF_INTERNAL_ERROR;
parms[0].er_size = 4;
parms[0].er_value = (PTR)&errnum;
ERslookup(errcb->ad_errcode, 0, ER_TIMESTAMP,
errcb->ad_sqlstate.db_sqlstate,
errcb->ad_errmsgp,
errcb->ad_ebuflen, -1, &errcb->ad_emsglen,
&sys_err, 1, parms);
status = E_DB_ERROR;
}
return (status);
}
/*
** this is a temporary stub for ERlookup(). It will go away as of the next
** integration.
*/
STATUS
ERlookup(
i4 msg_number,
CL_ERR_DESC *clerror,
i4 flags,
i4 *generic_error,
char *msg_buf,
i4 msg_buf_size,
i4 language,
i4 *msg_length,
CL_ERR_DESC *err_code,
i4 num_param,
ER_ARGUMENT *param )
{
STATUS stat;
char sqlstate[5];
stat = ERslookup(msg_number, clerror, flags, sqlstate, msg_buf,
msg_buf_size, language, msg_length, err_code, num_param, param);
if (stat != OK || generic_error == (i4 *) NULL)
return(stat);
/*
** now convert SQLSTATE to a generic error
**
** here we are using a (AWK-filtered) copy of the routine converting
** SQLSTATEs to generic errors (I am only doing it [making a copy of an ADF
** function] because this stub has a month and a half to live)
*/
{
i4 ss_class, ss_subclass;
static struct
{
i4 dbmserr;
i4 generr;
} numeric_exception[] =
{
{ /* E_AD1127_DECOVF_ERROR */ 0x021127L, 0x9D0B },
{ /* E_GW7015_DECIMAL_OVF */ 0x0F7015L, 0x9D0B },
{ /* E_AD1013_EMBEDDED_NUMOVF */ 0x021013L, 0x9D1C },
{ /* E_CL0503_CV_OVERFLOW */ 0x010503L, 0x9D1C },
{ /* E_GW7000_INTEGER_OVF */ 0x0F7000L, 0x9D1C },
{ /* E_US1068_4200 */ 0x001068L, 0x9D1C },
{ /* E_GW7001_FLOAT_OVF */ 0x0F7001L, 0x9D1D },
{ /* E_GW7004_MONEY_OVF */ 0x0F7004L, 0x9D1D },
{ /* E_US106A_4202 */ 0x00106AL, 0x9D1D },
{ /* E_CL0502_CV_UNDERFLOW */ 0x010502L, 0x9D21 },
{ /* E_GW7002_FLOAT_UND */ 0x0F7002L, 0x9D22 },
{ /* E_GW7005_MONEY_OVF */ 0x0F7005L, 0x9D22 },
{ /* E_US106C_4204 */ 0x00106CL, 0x9D22 },
{ -1L, -1L},
};
static struct
{
i4 dbmserr;
i4 generr;
} division_by_zero[] =
{
{ /* E_US1069_4201 */ 0x001069L, 0x9D1E },
{ /* E_US106B_4203 */ 0x00106BL, 0x9D1F },
{ /* E_AD1126_DECDIV_ERROR */ 0x021126L, 0x9D20 },
{ -1L, -1L},
};
/*
** convert SQLSTATE class (treated as a base 36 number) to a base 10 integer
*/
if (sqlstate[0] > '0' && sqlstate[0] <= '9')
ss_class = (sqlstate[0] - '0') * 36;
else if (sqlstate[0] >= 'A' && sqlstate[0] <= 'Z')
ss_class = (sqlstate[0] - 'A' + 10) * 36;
else
ss_class = 0;
if (sqlstate[1] > '0' && sqlstate[1] <= '9')
ss_class += sqlstate[1] - '0';
else if (sqlstate[1] >= 'A' && sqlstate[1] <= 'Z')
ss_class += sqlstate[1] - 'A' + 10;
/*
** convert SQLSTATE subclass (treated as a base 36 number) to a base 10
** integer
*/
if (sqlstate[2] > '0' && sqlstate[2] <= '9')
ss_subclass = 36 * 36 * (sqlstate[2] - '0');
else if (sqlstate[2] >= 'A' && sqlstate[2] <= 'Z')
ss_subclass = 36 * 36 * (sqlstate[2] - 'A' + 10);
else
ss_subclass = 0;
if (sqlstate[3] > '0' && sqlstate[3] <= '9')
ss_subclass += 36 * (sqlstate[3] - '0');
else if (sqlstate[3] >= 'A' && sqlstate[3] <= 'Z')
ss_subclass += 36 * (sqlstate[3] - 'A' + 10);
if (sqlstate[4] > '0' && sqlstate[4] <= '9')
ss_subclass += sqlstate[4] - '0';
else if (sqlstate[4] >= 'A' && sqlstate[4] <= 'Z')
ss_subclass += sqlstate[4] - 'A' + 10;
switch (ss_class)
{
case 120:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9DD0L;
break;
}
}
break;
}
case 73:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9CA4L;
break;
}
}
break;
}
case 8:
{
switch (ss_subclass)
{
case 3:
{
*generic_error = 0x80E8L;
break;
}
case 6:
{
*generic_error = 0x9088L;
break;
}
case 2:
{
*generic_error = 0x80E8L;
break;
}
case 1:
{
*generic_error = 0x98BCL;
break;
}
case 4:
{
*generic_error = 0x94D4L;
break;
}
case 7:
{
*generic_error = 0x9088L;
break;
}
case 6480:
{
*generic_error = 0x75BCL;
break;
}
default:
{
*generic_error = 0x98BCL;
break;
}
}
break;
}
case 74:
{
switch (ss_subclass)
{
case 73:
{
*generic_error = 0x9D08L;
break;
}
case 8:
{
*generic_error = 0x9D0EL;
break;
}
case 38:
{
i4 i;
for (i = 0;
( division_by_zero[i].dbmserr != -1L
&& division_by_zero[i].dbmserr != msg_number);
i++)
;
if (division_by_zero[i].dbmserr == -1L)
*generic_error = 0x9D24L;
else
*generic_error = division_by_zero[i].generr;
break;
}
case 5:
{
*generic_error = 0x9D0CL;
break;
}
case 74:
{
*generic_error = 0x9D11L;
break;
}
case 41:
{
*generic_error = 0x9D0FL;
break;
}
case 44:
{
*generic_error = 0x7918L;
break;
}
case 7:
{
*generic_error = 0x9D0FL;
break;
}
case 45:
{
*generic_error = 0x7918L;
break;
}
case 77:
{
*generic_error = 0x7918L;
break;
}
case 75:
{
*generic_error = 0x9D08L;
break;
}
case 9:
{
*generic_error = 0x9D0FL;
break;
}
case 2:
{
*generic_error = 0x9D0AL;
break;
}
case 3:
{
i4 i;
for (i = 0;
( numeric_exception[i].dbmserr != -1L
&& numeric_exception[i].dbmserr != msg_number);
i++)
;
if (numeric_exception[i].dbmserr == -1L)
*generic_error = 0x9D24L;
else
*generic_error = numeric_exception[i].generr;
break;
}
case 78:
{
*generic_error = 0x9D08L;
break;
}
case 1:
{
*generic_error = 0x9D09L;
break;
}
case 37:
{
*generic_error = 0x80E8L;
break;
}
case 79:
{
*generic_error = 0x7918L;
break;
}
case 76:
{
*generic_error = 0x98BCL;
break;
}
case 6480:
{
*generic_error = 0x9D17L;
break;
}
default:
{
*generic_error = 0x9D08L;
break;
}
}
break;
}
case 83:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x7D00L;
break;
}
}
break;
}
case 7:
{
switch (ss_subclass)
{
case 3:
{
*generic_error = 0x7D00L;
break;
}
case 8:
{
*generic_error = 0x7D00L;
break;
}
case 9:
{
*generic_error = 0x7D00L;
break;
}
case 5:
{
*generic_error = 0x7D00L;
break;
}
case 6:
{
*generic_error = 0x7D00L;
break;
}
case 1:
{
*generic_error = 0x7D00L;
break;
}
case 2:
{
*generic_error = 0x7D00L;
break;
}
case 4:
{
*generic_error = 0x7D00L;
break;
}
case 7:
{
*generic_error = 0x7D00L;
break;
}
case 6480:
{
*generic_error = 0x98BCL;
break;
}
default:
{
*generic_error = 0x7D00L;
break;
}
}
break;
}
case 10:
{
switch (ss_subclass)
{
case 1:
{
*generic_error = 0x98BCL;
break;
}
case 6480:
{
*generic_error = 0x79E0L;
break;
}
default:
{
*generic_error = 0x98BCL;
break;
}
}
break;
}
case 75:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9D6CL;
break;
}
}
break;
}
case 80:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0xA028L;
break;
}
}
break;
}
case 121:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x98BCL;
break;
}
}
break;
}
case 84:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x7918L;
break;
}
}
break;
}
case 113:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x7D00L;
break;
}
}
break;
}
case 86:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x797CL;
break;
}
}
break;
}
case 112:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x75A8L;
break;
}
}
break;
}
case 76:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9DD0L;
break;
}
}
break;
}
case 123:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x797CL;
break;
}
}
break;
}
case 111:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x75BCL;
break;
}
}
break;
}
case 78:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x75B2L;
break;
}
}
break;
}
case 77:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9E34L;
break;
}
}
break;
}
case 85:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9E34L;
break;
}
}
break;
}
case 2:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x0064L;
break;
}
}
break;
}
case 647:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9088L;
break;
}
}
break;
}
case 0:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x0000L;
break;
}
}
break;
}
case 146:
{
switch (ss_subclass)
{
case 6480:
{
*generic_error = 0x7594L;
break;
}
case 6481:
{
*generic_error = 0x759EL;
break;
}
case 6482:
{
*generic_error = 0x75F8L;
break;
}
case 6483:
{
*generic_error = 0x84D0L;
break;
}
case 6484:
{
*generic_error = 0x75A8L;
break;
}
case 6485:
{
*generic_error = 0x75B2L;
break;
}
case 6486:
{
*generic_error = 0x797CL;
break;
}
case 6487:
{
*generic_error = 0x797CL;
break;
}
default:
{
*generic_error = 0x7918L;
break;
}
}
break;
}
case 82:
{
switch (ss_subclass)
{
case 6480:
{
*generic_error = 0x7594L;
break;
}
case 6481:
{
*generic_error = 0x759EL;
break;
}
case 6482:
{
*generic_error = 0x75F8L;
break;
}
case 6483:
{
*generic_error = 0x84D0L;
break;
}
case 6484:
{
*generic_error = 0x75A8L;
break;
}
case 6485:
{
*generic_error = 0x75B2L;
break;
}
case 6486:
{
*generic_error = 0x797CL;
break;
}
case 6487:
{
*generic_error = 0x797CL;
break;
}
default:
{
*generic_error = 0x7918L;
break;
}
}
break;
}
case 115:
{
switch (ss_subclass)
{
case 6480:
{
*generic_error = 0x7594L;
break;
}
case 6481:
{
*generic_error = 0x759EL;
break;
}
case 6482:
{
*generic_error = 0x75F8L;
break;
}
case 6483:
{
*generic_error = 0x84D0L;
break;
}
case 6484:
{
*generic_error = 0x75A8L;
break;
}
case 6485:
{
*generic_error = 0x75B2L;
break;
}
case 6486:
{
*generic_error = 0x797CL;
break;
}
case 6487:
{
*generic_error = 0x797CL;
break;
}
default:
{
*generic_error = 0x7918L;
break;
}
}
break;
}
case 144:
{
switch (ss_subclass)
{
case 2:
{
*generic_error = 0x9D6CL;
break;
}
case 1:
{
*generic_error = 0xC2ECL;
break;
}
case 3:
{
*generic_error = 0x9088L;
break;
}
default:
{
*generic_error = 0x98BCL;
break;
}
}
break;
}
case 79:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x9EFCL;
break;
}
}
break;
}
case 1:
{
switch (ss_subclass)
{
case 1:
{
*generic_error = 0x0032L;
break;
}
case 2:
{
*generic_error = 0x0032L;
break;
}
case 8:
{
*generic_error = 0x0032L;
break;
}
case 5:
{
*generic_error = 0x0032L;
break;
}
case 3:
{
*generic_error = 0x0032L;
break;
}
case 7:
{
*generic_error = 0x0032L;
break;
}
case 6:
{
*generic_error = 0x0032L;
break;
}
case 10:
{
*generic_error = 0x0032L;
break;
}
case 9:
{
*generic_error = 0x0032L;
break;
}
case 4:
{
*generic_error = 0x0032L;
break;
}
case 6480:
{
*generic_error = 0x0032L;
break;
}
case 6481:
{
*generic_error = 0x0032L;
break;
}
default:
{
*generic_error = 0x0032L;
break;
}
}
break;
}
case 148:
{
switch (ss_subclass)
{
default:
{
*generic_error = 0x7D00L;
break;
}
}
break;
}
case 180:
{
switch (ss_subclass)
{
case 1:
{
*generic_error = 0x7602L;
break;
}
case 2:
{
*generic_error = 0x8CA0L;
break;
}
case 3:
{
*generic_error = 0x8D04L;
break;
}
case 4:
{
*generic_error = 0x8D68L;
break;
}
case 5:
{
*generic_error = 0x9470L;
break;
}
case 6:
{
*generic_error = 0x9858L;
break;
}
case 7:
{
*generic_error = 0x9E98L;
break;
}
case 8:
{
*generic_error = 0xA0F0L;
break;
}
case 9:
{
*generic_error = 0xA154L;
break;
}
case 10:
{
*generic_error = 0x7D00L;
break;
}
case 11:
{
*generic_error = 0x98BCL;
break;
}
case 12:
{
*generic_error = 0x9D0DL;
break;
}
case 13:
{
*generic_error = 0x9D12L;
break;
}
case 14:
{
*generic_error = 0xA21CL;
break;
}
case 15:
{
*generic_error = 0x98BCL;
break;
}
case 16:
{
*generic_error = msg_number;
break;
}
case 17:
{
*generic_error = 0x75BCL;
break;
}
case 18:
{
*generic_error = 0x98BCL;
break;
}
case 19:
{
*generic_error = 0x98BCL;
break;
}
case 20:
{
*generic_error = 0x98BCL;
break;
}
case 21:
{
*generic_error = 0x9088L;
break;
}
case 22:
{
*generic_error = 0x9088L;
break;
}
default:
{
*generic_error = 0x98BCL;
break;
}
}
break;
}
default:
{
*generic_error = 0x98BCL;
break;
}
}
}
return(OK);
}
STATUS
ERslookup(
i4 msg_number,
CL_ERR_DESC *clerror,
i4 flags,
char *sqlstate,
char *msg_buf,
i4 msg_buf_size,
i4 language,
i4 *msg_length,
CL_ERR_DESC *err_code,
i4 num_param,
ER_ARGUMENT *param )
{
i4 erindex; /* index of ERmulti table */
i4 status;
i4 length = 0;
ER_ARGUMENT *p;
ER_ARGUMENT hidden[CLE_INFO_ITEMS]; /* to access info in clerror */
char tempbuf[ER_MAX_LEN+ER_MAX_NAME+2];
i4 templen;
char *p_msg_buf;
char *p_tempbuf;
SYSTIME stime;
char langbuf[ER_MAX_LANGSTR];
EX_CONTEXT context;
ER_SEMFUNCS *sems;
#define D_WIDTH 23
#define F_WIDTH 20
#define X_WIDTH 18
/* Validate the parameters. */
if (msg_buf == 0 || msg_buf_size == 0 || msg_length == 0)
{
return (ER_BADPARAM);
}
if (language != -1 && ERlangstr(language,langbuf) != OK)
{
return (ER_BADLANGUAGE);
}
if (!(flags & ER_NAMEONLY))
{
EXdump(msg_number,0);
}
/* Insert timestamp if requested. */
if (flags & ER_TIMESTAMP)
{
if (msg_buf_size < 21)
{
return (ER_TOOSMALL);
}
TMnow(&stime);
TMstr(&stime,msg_buf);
length = (i4)STlength(msg_buf);
msg_buf[length++] = ' ';
}
/*
** if (clerror && msg_number)
** look up msg_number, optional parameters in clerror->moreinfo
** else if (clerror)
** {
** if (clerror->intern)
** look up clerror.intern, optional params in clerror->moreinfo
** if (clerror->callid)
** look up system error message
** }
*/
if (clerror)
{
if (msg_number) /* Look up message after system error */
{
/*
** Set up an ER_ARGUMENT that references system-dependent
** information in `clerror', and point `param' at it.
*/
i4 i;
for (i = 0; i < CLE_INFO_ITEMS; ++i)
{
/* "...all of whose members begin at offset 0..." (K&R) */
hidden[i].er_value = (PTR)&clerror->moreinfo[i].data._i4;
hidden[i].er_size = clerror->moreinfo[i].size;
}
param = &hidden[0];
num_param = CLE_INFO_ITEMS;
}
else /* retrieve system-dependent error messages */
{
i4 len;
ER_ARGUMENT argv[3];
if (clerror->intern) /* look up internal CL error */
{
i4 i;
for (i = 0; i < CLE_INFO_ITEMS; ++i)
{
argv[i].er_value = (PTR)&clerror->moreinfo[i].data._i4;
argv[i].er_size = clerror->moreinfo[i].size;
}
/*
** Don't timestamp on recursive call, since it's been done
** already (if requested).
*/
if ((status = ERslookup((i4) clerror->intern,
(CL_ERR_DESC*) NULL, flags & ~ER_TIMESTAMP | ER_TEXTONLY,
NULL, &msg_buf[length], msg_buf_size-length, language, &len,
err_code, CLE_INFO_ITEMS, argv)) != OK)
{
return (status);
}
length += len;
if (clerror->callid)
msg_buf[length++] = '\n';
}
if (clerror->callid) /* look up system error message text */
{
DESCRIPTOR msg_desc;
msg_desc.desc_length = sizeof(tempbuf) - 1;
msg_desc.desc_value = tempbuf;
if ((status = cer_sysgetmsg(clerror, &len, &msg_desc, err_code))
!= OK)
{
return(status);
}
argv[0].er_size = argv[1].er_size = argv[2].er_size =
ER_PTR_ARGUMENT;
argv[0].er_value = (PTR)&clerror->errnum;
argv[1].er_value = (PTR)ERNAME((i4) clerror->callid);
argv[2].er_value = (PTR)tempbuf;
if ((status = ERslookup(ER_UNIXERROR, (CL_ERR_DESC*) NULL,
flags & ~ER_TIMESTAMP | ER_TEXTONLY, NULL,
&msg_buf[length], msg_buf_size - length, language,
&len,err_code, 3, argv))
!= OK)
{
return (status);
}
length += len;
}
msg_buf[*msg_length = length] = EOS;
return (OK);
}
}
/*
** Check if error message file is already opened or not yet.
** First see if the language is initialized. If not, initialize
** it and the message files.
** If it is already opened, cer_fndindex function returns the index of
** ERmulti table that internal language code is parameter 'language'.
** If not yet, it returns '-1'.
*/
if (cer_issem(&sems))
{
if (((sems->sem_type & MU_SEM) ?
(*sems->er_p_semaphore)(&sems->er_mu_sem) :
(*sems->er_p_semaphore)(1, &sems->er_sem)) != OK)
{
sems = NULL;
}
}
if ((erindex = cer_fndindex(language)) == -1)
{
if ((status = cer_nxtindex(language,&erindex)) != OK)
{ /* Error in initializing the language */
if (sems)
{
if (sems->sem_type & MU_SEM)
_VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem);
else
_VOID_ (*sems->er_v_semaphore)(&sems->er_sem);
}
return (status);
}
}
/* If the error message file is not opened, open the message file. */
if (!cer_isopen(erindex,ER_SLOWSIDE))
{
if ((status = cer_sinit(language,msg_number,erindex,err_code)) != OK)
{
if (sems)
{
if (sems->sem_type & MU_SEM)
_VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem);
else
_VOID_ (*sems->er_v_semaphore)(&sems->er_sem);
}
return (status);
}
}
/* If not open then just return. */
if (!cer_isopen(erindex,ER_SLOWSIDE))
{
if (sems)
{
if (sems->sem_type & MU_SEM)
_VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem);
else
_VOID_ (*sems->er_v_semaphore)(&sems->er_sem);
}
/*
** As internal file id is '0', openning file will fail.
** In her,return status 'ER_BADOPEN' to show open fail.
*/
return (ER_BADOPEN);
}
/*
** Search message string from file and set to buffer.
** Error status on system call set to 'err_code'.
*/
status = cer_sstr(msg_number, sqlstate, tempbuf,
msg_buf_size - length, erindex, err_code,
flags & ER_TEXTONLY? ER_GET : ER_LOOKUP);
if (sems)
{
if (sems->sem_type & MU_SEM)
_VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem);
else
_VOID_ (*sems->er_v_semaphore)(&sems->er_sem);
}
if (status != OK)
{
return (status);
}
/*
** Format the text with parameters into the callers buffer.
** The message is truncated if it will not fit.
*/
/* Insert part of name from temporary buffer to buffer */
status = OK;
templen = (i4)STlength(tempbuf);
p_msg_buf = &msg_buf[length];
p_tempbuf = tempbuf;
if (!(flags & ER_TEXTONLY))
{
while(*p_tempbuf != '\t')
{
CMcpyinc(p_tempbuf,p_msg_buf);
}
CMcpyinc(p_tempbuf,p_msg_buf);
}
/* ============================================ */
/* Copy text to message substituting arguments. */
/* -------------------------------------------- */
/* (But first, declare an exception handler to */
/* catch bad params that may access violate.) */
/* ============================================ */
if (EXdeclare(er_exhandler, &context))
{
u_i4 res_len;
u_i4 bytes_left_in_buf;
bytes_left_in_buf = (u_i4)(msg_buf_size - (p_msg_buf - msg_buf));
res_len = STlen( STncpy(p_msg_buf,
ERx("*** ERslookup() ERROR: Missing or bad parameter for this message. ***"),
bytes_left_in_buf ));
p_msg_buf[ bytes_left_in_buf - 1 ] = EOS;
p_msg_buf += res_len;
*msg_length = (i4)(p_msg_buf - msg_buf);
EXdelete();
return (OK);
}
for( ;p_tempbuf - tempbuf < templen; CMnext(p_tempbuf))
{
long number;
u_long unumber;
double fnumber;
i4 i;
i4 pnum;
if ( (*p_tempbuf != '%') || (flags & ER_NOPARAM) )
{
if ((p_msg_buf - msg_buf) >= msg_buf_size)
break;
CMcpychar(p_tempbuf,p_msg_buf);
CMnext(p_msg_buf);
continue;
}
if (p_tempbuf - tempbuf + 2 >= templen)
continue;
CMnext(p_tempbuf);
if (*p_tempbuf == '!')
{
if ((p_msg_buf - msg_buf) + 3 >= msg_buf_size)
continue;
CMcpychar(ERx("\r"),p_msg_buf);
CMnext(p_msg_buf);
CMcpychar(ERx("\n"),p_msg_buf);
CMnext(p_msg_buf);
CMcpychar(ERx("\t"),p_msg_buf);
CMnext(p_msg_buf);
continue;
}
/*
** Only works for up to 10 parameters, and makes character set
** assumptions - should be fixed.
*/
if ( *p_tempbuf < '0' || *p_tempbuf > '9' )
{
/* treat any other character as a literal */
if ((p_msg_buf - msg_buf) >= msg_buf_size)
break;
if ( *p_tempbuf != '%' )
{
CMcpychar("%",p_msg_buf);
CMnext(p_msg_buf);
}
CMcpychar(p_tempbuf,p_msg_buf);
CMnext(p_msg_buf);
continue;
}
pnum = *p_tempbuf - '0';
if (pnum >= num_param)
{
EXdelete();
return(ER_BADPARAM);
}
p = ¶m[pnum];
CMnext(p_tempbuf);
switch (*p_tempbuf)
{
case 'd':
/* Convert an integer into the buffer with width D_WIDTH */
if (p->er_size == ER_PTR_ARGUMENT) /* this is ptr to i4 */
number = *(i4 *)p->er_value;
else if (p->er_size == 0) /* this is a i4 */
number = (i4)(SCALARP)p->er_value;
else if (p->er_size == 1)
number = *(i1 *)p->er_value;
else if (p->er_size == 2)
number = *(i2 *)p->er_value;
else if (p->er_size == 4)
number = *(i4 *)p->er_value;
else if (p->er_size == 8)
number = *(i8 *)p->er_value;
else
continue;
if (p_msg_buf - msg_buf + D_WIDTH >= msg_buf_size)
continue;
if (p->er_size == 8)
{
CVla8(number, p_msg_buf);
}
else
{
CVla((i4)number, p_msg_buf);
}
while (*p_msg_buf)
CMnext(p_msg_buf);
continue;
case 'u':
/* Convert an integer into the buffer with width D_WIDTH */
if (p->er_size == ER_PTR_ARGUMENT) /* this is ptr to u_i4 */
number = *(u_i4 *)p->er_value;
else if (p->er_size == 0) /* this is a u_i4 */
number = (u_i4)(SCALARP)p->er_value;
else if (p->er_size == 1)
number = *(u_i1 *)p->er_value;
else if (p->er_size == 2)
number = *(u_i2 *)p->er_value;
else if (p->er_size == 4)
number = *(u_i4 *)p->er_value;
else if (p->er_size == 8)
number = *(u_i8 *)p->er_value;
else
continue;
if (p_msg_buf - msg_buf + D_WIDTH >= msg_buf_size)
continue;
if (p->er_size == 8)
{
CVula8(number, p_msg_buf);
}
else
{
CVula((u_i4)number, p_msg_buf);
}
while (*p_msg_buf)
CMnext(p_msg_buf);
continue;
case 'f':
{
i2 res_width;
/* Convert a float into the buffer with width F_WIDTH */
if (p->er_size == ER_PTR_ARGUMENT) /* Pointer to a double */
fnumber = *(double *)p->er_value;
else if (p->er_size == 4)
fnumber = *(f4 *)p->er_value;
else if (p->er_size == 8)
fnumber = *(f8 *)p->er_value;
else
continue;
if (p_msg_buf - msg_buf + F_WIDTH >= msg_buf_size)
continue;
/* Always convert to 'e' format. */
CVfa(fnumber, (i4) 20, (i4) 5, 'e', '.', p_msg_buf, &res_width);
p_msg_buf += F_WIDTH;
continue;
}
case 'c':
/* Convert a character array into buffer. */
if (p->er_value == 0)
p->er_value = (PTR)ERx("<missing>");
if ((p->er_size == 0) || (p->er_size == ER_PTR_ARGUMENT))
{
for (i = 0; ((char *)p->er_value)[i]; i++)
;
p->er_size = i;
}
if (p_msg_buf - msg_buf + p->er_size >= msg_buf_size)
continue;
if (p->er_size > msg_buf_size - (p_msg_buf - msg_buf))
p->er_size = (i4)(msg_buf_size - (p_msg_buf - msg_buf));
/* p->er_size=STtrmwhite(p_msg_buf);*/
MEcopy(p->er_value, p->er_size, p_msg_buf);
p->er_size = (i4)STtrmnwhite(p_msg_buf, p->er_size);
p_msg_buf += p->er_size;
continue;
case 'x':
/* Convert an integer into the buffer with width D_WIDTH */
if (p->er_size == ER_PTR_ARGUMENT)
unumber = *(u_i4 *)p->er_value;
else if (p->er_size == 0)
unumber = (u_i4)(SCALARP)p->er_value;
else if (p->er_size == 1)
unumber = *(u_i1 *)p->er_value;
else if (p->er_size == 2)
unumber = *(u_i2 *)p->er_value;
else if (p->er_size == 4)
unumber = *(u_i4 *)p->er_value;
else if (p->er_size == 8)
unumber = *(u_i8 *)p->er_value;
if (p_msg_buf - msg_buf + X_WIDTH >= msg_buf_size)
continue;
for (i = 8; --i >= 0; )
{
/* {@fix_me@}
** This is *NOT* machine independent. This relys on an
** ASCII-like character set, where the digits '0'-'9' are
** contiguous and sequential, and the characters 'A'-'F'
** are contiguous and sequential. Both ASCII and EBCDIC
** happen to be this way.
*/
if ((*(p_msg_buf + i) = (unumber & 0x0f) + '0') > '9')
*(p_msg_buf + i) += 'A' - '9' - 1;
unumber >>= 4;
}
p_msg_buf += 8;
continue;
default:
continue;
}
}
*msg_length = (i4)(p_msg_buf - msg_buf);
*p_msg_buf = EOS;
EXdelete();
return (OK);
}
DB_STATUS
uleFormatFcn(
DB_ERROR *dberror,
i4 err_code,
CL_ERR_DESC *clerror,
i4 flag,
DB_SQLSTATE *sqlstate,
char *msg_buffer,
i4 msg_buf_length,
i4 *msg_length,
i4 *uleError,
PTR uleFileName,
i4 uleLineNumber,
i4 num_parms,
... )
{
#define NUM_ER_ARGS 12
struct {
ULE_MHDR hdr;
/* FIX ME should message size be ER_MAX_LEN - sizeof(ULE_MHDR) */
char message[ER_MAX_LEN];
} buffer;
i4 i;
i4 length = 0;
i4 text_length;
i4 status;
CL_ERR_DESC sys_err;
i4 language;
SCF_SESSION sid;
SCF_SCI info[10];
SCF_CB scf_cb;
ER_ARGUMENT er_args[NUM_ER_ARGS];
char hex_chars[16] = {'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f'};
i4 error_code;
i4 local_error_code;
DB_ERROR localDBerror, *DBerror;
PTR FileName;
i4 LineNumber;
char *qbuf = NULL;
char *prev_qbuf = NULL;
char *psqbuf = NULL;
i4 qlen = 0;
i4 prev_qlen = 0;
i4 psqlen = 0;
i4 trace_errno = 0;
i4 trace_stack = 0;
i4 prlen;
char *prbuf;
i2 hdr_size;
i4 NumParms;
va_list ap;
LOCATION loc;
char dev[LO_NM_LEN];
char fprefix[LO_NM_LEN];
char fsuffix[LO_NM_LEN];
char version[LO_NM_LEN];
char path[MAX_LOC + 1];
char filebuf[MAX_LOC + 1];
char LineNo[LO_NM_LEN];
char *MessageArea = (char*)&buffer.message;
char SourceInfo[LO_NM_LEN];
i4 PrefixLen = sizeof(ULE_MHDR);
if (Ule_started == 0)
{
MEfill(sizeof(ULE_MHDR), (u_char)' ', (PTR)&Ule_mhdr);
Ule_started = -1;
}
/*
** If old form (no dberror) or overriding err_code,
** use caller's err_code, File, and Line information,
** otherwise use what's in "dberror".
*/
if ( !dberror || err_code )
{
DBerror = &localDBerror;
DBerror->err_file = uleFileName;
DBerror->err_line = uleLineNumber;
DBerror->err_code = err_code;
DBerror->err_data = 0;
/* Fill caller's dberror with that used */
if ( dberror )
*dberror = *DBerror;
}
else
DBerror = dberror;
error_code = local_error_code = DBerror->err_code;
MessageArea = (char*)&buffer.message;
info[0].sci_code = SCI_SID;
info[0].sci_length = sizeof(sid);
info[0].sci_aresult = (char *) &sid;
info[0].sci_rlength = 0;
info[1].sci_code = SCI_LANGUAGE;
info[1].sci_length = sizeof(language);
info[1].sci_aresult = (char *) &language;
info[1].sci_rlength = 0;
scf_cb.scf_length = sizeof(SCF_CB);
scf_cb.scf_type = SCF_CB_TYPE;
scf_cb.scf_ascii_id = SCF_ASCII_ID;
scf_cb.scf_facility = DB_ULF_ID;
scf_cb.scf_session = DB_NOSESSION;
scf_cb.scf_len_union.scf_ilength = 2;
scf_cb.scf_ptr_union.scf_sci = (SCI_LIST *) &info[0];
/* scf_error is not usually an input parameter */
if (flag == ULE_LOG || flag == ULE_MESSAGE)
{
info[2].sci_code = SCI_QBUF;
info[2].sci_length = sizeof(qbuf);
info[2].sci_aresult = (char *) &qbuf;
info[2].sci_rlength = 0;
info[3].sci_code = SCI_QLEN;
info[3].sci_length = sizeof(qlen);
info[3].sci_aresult = (char *) &qlen;
info[3].sci_rlength = 0;
info[4].sci_code = SCI_TRACE_ERRNO;
info[4].sci_length = sizeof(trace_errno);
info[4].sci_aresult = (char *) &trace_errno;
info[4].sci_rlength = 0;
info[5].sci_code = SCI_PREV_QBUF;
info[5].sci_length = sizeof(prev_qbuf);
info[5].sci_aresult = (char *) &prev_qbuf;
info[5].sci_rlength = 0;
info[6].sci_code = SCI_PREV_QLEN;
info[6].sci_length = sizeof(prev_qlen);
info[6].sci_aresult = (char *) &prev_qlen;
info[6].sci_rlength = 0;
info[7].sci_code = SCI_PSQ_QBUF;
info[7].sci_length = sizeof(psqbuf);
info[7].sci_aresult = (char *) &psqbuf;
info[7].sci_rlength = 0;
info[8].sci_code = SCI_PSQ_QLEN;
info[8].sci_length = sizeof(psqlen);
info[8].sci_aresult = (char *) &psqlen;
info[8].sci_rlength = 0;
info[9].sci_code = SCI_TRACE_STACK;
info[9].sci_length = sizeof(trace_stack);
info[9].sci_aresult = (char *) &trace_stack;
info[9].sci_rlength = 0;
scf_cb.scf_len_union.scf_ilength = 10;
}
status = scf_call(SCU_INFORMATION, &scf_cb);
if (status)
{
language = 1;
sid = 0;
}
if (!language)
language = 1;
/* package up the stack parameters into an ER_ARGUMENT array */
va_start( ap, num_parms );
for( NumParms = 0; NumParms < num_parms && NumParms < NUM_ER_ARGS; NumParms++ )
{
er_args[NumParms].er_size = (i4) va_arg( ap, i4 );
er_args[NumParms].er_value = (PTR) va_arg( ap, PTR );
}
va_end( ap );
*uleError = 0;
if (flag == 0 || flag == ULE_LOG || flag == ULE_LOOKUP)
{
/* Get INGRES message text. */
status = ERslookup( local_error_code,
CLERROR(local_error_code)? clerror : (CL_ERR_DESC*) NULL,
ER_TIMESTAMP,
(sqlstate) ? sqlstate->db_sqlstate : (char *) NULL,
MessageArea,
(i4) sizeof(buffer.message),
(i4) language,
&text_length,
&sys_err,
NumParms,
er_args
);
if (status != OK)
{
CL_ERR_DESC junk;
STprintf(MessageArea, "ULE_FORMAT: ");
length = STlength(MessageArea);
/*
** If uleFormat caller is different than
** error source, identify caller.
*/
if ( flag == ULE_LOG && uleFileName &&
(uleFileName != DBerror->err_file ||
uleLineNumber != DBerror->err_line) )
{
STcopy(uleFileName, filebuf);
STprintf(LineNo, ":%d ", uleLineNumber);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
&MessageArea[length]);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
&MessageArea[length]);
}
length = STlength(MessageArea);
MessageArea[length++] = ' ';
}
STprintf(&MessageArea[length],
"Couldn't look up message %x ",
local_error_code);
length = STlength(MessageArea);
STprintf(&MessageArea[length], "(reason: ER error %x)\n",status);
length = STlength(MessageArea);
status = ERslookup( (i4) status,
&sys_err,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&junk,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
STprintf(&MessageArea[length],
"... ERslookup failed twice: status = %x", status);
length = STlength(MessageArea);
}
else
{
length += text_length;
}
*uleError = E_UL0002_BAD_ERROR_LOOKUP;
}
else
{
length = text_length;
}
/* Get system message text. */
if (clerror)
{
MessageArea[length++] = '\n';
/*
** Extract the distinct clerror source information, filename,
** extension, and line number from CL_ERR_DESC
** and prefix the message text with it.
*/
if ( !CLERROR(error_code) && (FileName = clerror->errfile) )
{
STcopy(FileName, filebuf);
STprintf(LineNo, ":%d ", clerror->errline);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
&MessageArea[length]);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
&MessageArea[length]);
}
length += STlength(&MessageArea[length]);
MessageArea[length++] = ' ';
}
status = ERslookup( (i4) 0,
clerror,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&sys_err,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
CL_ERR_DESC junk;
STprintf(&MessageArea[length],
"ULE_FORMAT: Couldn't look up system error ");
length = STlength(MessageArea);
STprintf(&MessageArea[length],
"(reason: ER error %x)\n", status);
length = STlength(MessageArea);
status = ERslookup( (i4) status,
&sys_err,
(i4) 0,
(sqlstate) ? sqlstate->db_sqlstate
: (char *) NULL,
&MessageArea[length],
(i4) (sizeof(buffer.message) - length),
(i4) language,
&text_length,
&junk,
0,
(ER_ARGUMENT *) NULL
);
if (status != OK)
{
STprintf(&MessageArea[length],
"... ERslookup failed twice: status = %x", status);
length = STlength(MessageArea);
}
else
{
length += text_length;
}
*uleError = E_UL0001_BAD_SYSTEM_LOOKUP;
}
else
{
length += text_length;
}
}
/* Copy into callers buffer if requested. */
if (msg_buffer && msg_buf_length)
{
if (msg_buf_length < length)
length = msg_buf_length;
MEcopy((PTR)MessageArea, length, (PTR)msg_buffer);
*msg_length = length;
}
}
else if (flag == ULE_MESSAGE)
{
if (!msg_buffer || !msg_buf_length)
{
*uleError = E_UL0003_BADPARM;
return (E_DB_ERROR);
}
MEcopy((PTR)msg_buffer, msg_buf_length, (PTR)MessageArea);
length = msg_buf_length;
}
if (flag == ULE_LOG || flag == ULE_MESSAGE)
{
SCF_SESSION tmp_sid = sid;
MEcopy((PTR)&Ule_mhdr, sizeof(ULE_MHDR), (PTR)&buffer.hdr);
for (i = (sizeof(Ule_mhdr.ule_session)) ; --i >= 0; )
{
buffer.hdr.ule_session[i] = hex_chars[(tmp_sid & 0xf)];
tmp_sid >>= 4;
}
/*
** Extract the error source information, filename, extension,
** and line number from CL_ERR_DESC or DB_ERROR
** and format it into the ULE_MHDR.
*/
if ( CLERROR(DBerror->err_code) && clerror && clerror->errfile )
{
FileName = clerror->errfile;
LineNumber = clerror->errline;
}
else
{
FileName = DBerror->err_file;
LineNumber = DBerror->err_line;
}
if ( FileName )
{
STprintf(LineNo, ":%d ", LineNumber);
STcopy(FileName, filebuf);
if ( LOfroms(PATH & FILENAME, filebuf, &loc) ||
LOdetail(&loc, dev, path, fprefix, fsuffix, version) )
{
STpolycat(2, FileName,
LineNo,
SourceInfo);
}
else
{
STpolycat(4, fprefix,
".", fsuffix,
LineNo,
SourceInfo);
}
STmove(SourceInfo, ' ', SourceInfoLen, (PTR)&buffer.hdr.ule_source);
}
/* Echo the message to II_DBMS_LOG, if defined */
TRwrite(NULL, PrefixLen + length, (PTR)&buffer);
status = ERsend(ER_ERROR_MSG, (PTR)&buffer,
PrefixLen + length, &sys_err);
}
