CPICERR.C
/*****************************************************************************
*
* MODULE NAME: CPICERR.C
*
* COPYRIGHTS:
* This module contains code made available by IBM
* Corporation on an AS IS basis. Any one receiving the
* module is considered to be licensed under IBM copyrights
* to use the IBM-provided source code in any way he or she
* deems fit, including copying it, compiling it, modifying
* it, and redistributing it, with or without
* modifications. No license under any IBM patents or
* patent applications is to be implied from this copyright
* license.
*
* A user of the module should understand that IBM cannot
* provide technical support for the module and will not be
* responsible for any consequences of use of the program.
*
* Any notices, including this one, are not to be removed
* from the module without the prior written consent of
* IBM.
*
* AUTHOR: Peter J. Schwaller
* VNET: PJS at RALVM6 Tie Line: 444-4376
* Internet: pjs@ralvm6.vnet.ibm.com (919) 254-4376
*
* John Q. Walker
* VNET: JOHNQ at RALVM6 Tie Line: 444-4414
* Internet: johnq@ralvm6.vnet.ibm.com (919) 254-4414
*
* FUNCTION: Contains procedures to be called for handling
* unexpected CPI-C return codes.
* Contains procedures to be called for handling the
* CPI-C error information cpicerr.
*
* AVAILABILITY:
* These sample programs and source are also available on
* CompuServe through the APPC Information Exchange. To get
* to the APPC forum just type 'GO APPC' from any CompuServe
* prompt. The samples are available in the Sample Programs
* library section. Just search on the keyword CPICPGMS to
* find all the samples in this series.
*
* Updates for the sample programs and support for many more
* CPI-C platforms will also be made available on CompuServe.
*
* RELATED FILES:
* CPICERR.H
*
* CHANGE HISTORY:
* Date Description
* 08/05/92 Version 2.31 of APING, ATELL and AREXEC released to CompuServe.
* This version was also distributed at the APPC/APPN Platform
* Developer's Conference held in Raleigh, NC.
* 08/13/92 Changed all printf and fprintf calls to use a write_*() call.
* Changed cpicerr_handle_rc() to a macro referencing a new call,
* cpicerr_handle_rc_extended(). The macro adds the current
* source file and line number to improve source code debugging.
* 08/15/92 Changed cpicerr_exchange_version() to receive 128 bytes
* instead of 3 bytes. This change was also made to the
* NS/DOS ship code.
* 08/18/92 Removed extra newline in cpicerr_show_rc().
* 09/02/92 Fixed bug in cpicerr_log_cpicerr() when the log_file_path
* was a zero length string.
* 11/15/92 Changed reply structure to include 2 byte indicator.
* 11/17/92 Added send/receipt of operating system string.
* Added cpicerr_exchange_version_plus() to return the string.
*
*****************************************************************************/
/*****************************************************************************
*
* OVERVIEW OF CPICERR CALLS
*
* cpicerr_new() Creates a CPICERR object.
* This must be done before any other
* cpicerr calls can be used.
*
* These calls set values in the cpicerr object structure and affect how
* cpicerr_handle_rc reacts to errors.
*
* cpicerr_set_conv_id() Used to extract conversation state info
* cpicerr_set_exit_level() Level of error on which to exit
* cpicerr_set_log_file_name() What filename to use for logging
* cpicerr_set_log_file_path() Where the filename is
* cpicerr_set_log_level() Level of error on which to log errors
* cpicerr_set_major_version() 8 bit int - see cpicerr_exchange_version
* cpicerr_set_minor_version() 8 bit int - see cpicerr_exchange_version
* cpicerr_set_program_name() String - Output as part of log info
* cpicerr_set_program_info() String - Output as part of log info
* cpicerr_set_show_level() Level of error on which to show errors
*
* cpicerr_handle_rc() Should be called by the program for all
* UNEXPECTED return codes.
* Functions performed are:
* Classification of the return code
* Showing partial info to end user
* Logging complete info to disk
* This is a macro that actually expands
* to cpicerr_handle_rc_extended().
*
* cpicerr_exchange_version() Exchanges version numbers with the
* partner. Very useful when supporting
* multiple versions of a program.
*
* cpicerr_destroy() Destroys the CPICERR object.
*
*
* cpicerr_classify_rc() These are internal calls used by
* cpicerr_show_rc() other cpicerr_handle_rc.
* cpicerr_log_rc()
* cpicerr_log_cpicerr()
* cpicerr_get_message()
* cpicerr_set_rc_info()
* cpicerr_show_product_info()
*
*****************************************************************************/
#if defined(WIN32) || defined(WINDOWS) /*WIN32*/
#include <windows.h> /*WIN32*/
#define GET_OS2_SENSE_DATA /*WIN32*/
#endif /*WIN32*/
#include "wincpic.h"
#ifdef GET_OS2_SENSE_DATA
#include <winappc.h>
#endif
/* Set up constant declarations */
#include "cpicdefs.h"
/* Collection of routines with special ported version for each platform */
#include "cpicport.h"
#include <stdio.h> /* C library includes */
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "cpicerrs.h" /* CPI-C error handling vars. */
/*
* Each of the following is a list of messages, which are actually defined
* in this file below. The messages are grouped together. For example,
* all of the return code messages are in the cpicerr_return_codes list.
*/
extern CPICERR_MESSAGE cpicerr_verbs_short[];
extern CPICERR_MESSAGE cpicerr_verbs_long[];
extern CPICERR_MESSAGE cpicerr_return_codes[];
extern CPICERR_MESSAGE cpicerr_rc_classes[];
extern CPICERR_MESSAGE cpicerr_states_conv[];
extern CPICERR_MESSAGE cpicerr_conv_types[];
extern CPICERR_MESSAGE cpicerr_sync_levels[];
/*****************************************************************************
* Function prototypes for internal routines. In general, these should
* not be called directly by an application program.
*****************************************************************************/
void cpicerr_classify_rc( CM_RETURN_CODE conv_rc,
CPIC_RC_HANDLING * classification);
void cpicerr_show_rc( CPICERR * cpicerr);
void cpicerr_log_rc( CPICERR * cpicerr,
FILE * log_file);
int cpicerr_log_cpicerr( CPICERR * cpicerr,
char * file_name,
int file_line);
char * cpicerr_get_message( CPICERR_MESSAGE_TYPE message_type,
CM_INT32 index);
void cpicerr_set_rc_info( CPICERR * cpicerr,
CPIC_VERB_INDEX verb_index,
CM_RETURN_CODE conv_rc);
void cpicerr_show_product_info(CPICERR * cpicerr);
/*****************************************************************************
* The following function prototypes and macros are used only by the
* OS/2 specific code used to obtain the sense data after an
* allocation failure. They are not necessary, if GET_OS2_SENSE_DATA
* has not been externally defined (with the -D compile flag).
*****************************************************************************/
#ifdef GET_OS2_SENSE_DATA
int cpicerr_os2_appc_allocate(CPICERR * cpicerr);
int
parse_destination(char * in_string,
char * plu_alias,
char * fqplu_name);
/* Macro BLANK_STRING sets string to all blanks */
#define BLANK_STRING(str) memset(str,(int)' ',sizeof(str))
#undef CLEAR_VCB
/* Macro CLEAR_VCB sets the APPC verb control block to zeros */
#define CLEAR_VCB(vcb) memset((char *)&vcb,(int)'\0',sizeof(vcb))
/* convert a string to uppercase, up to length specified */
#define TOUPPER_STRING(str,length) \
{int i; for (i=0;i < length;i ++) \
{str[i] = (char)toupper(str[i]);}}
/* convert an ASCII blank padded string to an ASCIIZ string without pads */
#define SNA2STRING(outstr, instr, max_length) \
{int i; for (i=0;i < max_length && instr[i] != ' ';i ++) \
{outstr[i] = instr[i];} outstr[i] = '\0';}
#endif
/*
* The error REPLY routines below are experimental and may change
* at any time!
*/
void
cpicerr_show_reply(CPICERR_REPLY * reply)
{
unsigned short length;
unsigned short offset;
unsigned short indicator;
int rc = 0;
if (reply->length >= CPICERR_REPLY_MIN_LENGTH) {
write_error(
"\nAn application error was detected by the partner:\n");
indicator =
convert_short_from_network(
*((unsigned short*)&reply->buffer[CPICERR_REPLY_INDICATOR]));
if (indicator == CPICERR_REPLY_INDICATOR_VALUE) {
write_error("Response: %d\n",
(int)reply->buffer[CPICERR_REPLY_RESPONSE]);
write_error("Message Category: %u\n",
convert_short_from_network(
*((unsigned short*)&reply->buffer[CPICERR_REPLY_CATEGORY])));
write_error("Primary Code: %ld\n",
convert_long_from_network(
*((unsigned long *)&reply->buffer[CPICERR_REPLY_PRIMARY])));
write_error("Secondary Code: %ld\n",
convert_long_from_network(
*((unsigned long *)&reply->buffer[CPICERR_REPLY_SECONDARY])));
if (reply->length >=
(unsigned int)(CPICERR_REPLY_MIN_LENGTH + 2)) {
length = convert_short_from_network(
*((unsigned short *)
&reply->buffer[CPICERR_REPLY_PRIMARY_LENGTH]));
if (reply->length >=
(unsigned int)(CPICERR_REPLY_PRIMARY_TEXT+length)) {
reply->buffer[length + CPICERR_REPLY_PRIMARY_TEXT - 1] =
'\0';
write_error("%s\n",
&reply->buffer[CPICERR_REPLY_PRIMARY_TEXT]);
offset = CPICERR_REPLY_PRIMARY_TEXT + length;
if (reply->length >= 2+offset) {
length = convert_short_from_network(
*((unsigned short *)&reply->buffer[offset]));
if (reply->length >= (offset+ 2 +length)) {
reply->buffer[length + offset + 2] = '\0';
write_error("%s\n", &reply->buffer[offset+2]);
}
else {
rc = 1;
}
}
else {
rc = 1;
}
}
else {
rc = 1;
}
}
else {
write_error("No text strings were sent.\n");
}
}
else {
write_error("Record received was not a reply structure.\n");
}
}
else {
rc = 1;
}
if (rc) {
write_error("Reply length error in cpicerr_show_reply().\n");
}
}
CPICERR_REPLY *
cpicerr_create_reply(unsigned int primary_message_buffer_size,
unsigned int secondary_message_buffer_size)
{
CPICERR_REPLY * reply;
reply = calloc(1, sizeof(CPICERR_REPLY));
if (reply == NULL) {
return NULL;
}
reply->buffer_length = CPICERR_REPLY_MIN_LENGTH+
primary_message_buffer_size+1 +
secondary_message_buffer_size+1 +
4; /* two length fields */
reply->buffer = calloc(reply->buffer_length, 1);
if (reply == NULL) {
return NULL;
}
return reply;
}
void
cpicerr_destroy_reply(CPICERR_REPLY * reply)
{
/*
* Make sure we don't free any NULL pointers!
*/
if (reply != NULL) {
if (reply->buffer != NULL) {
free(reply->buffer);
}
free(reply);
}
}
/*
* Requires that cpicerr_set_conv_id() has been called.
*/
int cpicerr_recv_appl_error(CPICERR * cpicerr,
CPICERR_REPLY * reply)
{
CM_RETURN_CODE cm_rc;
CM_INT32 rts_received;
CM_INT32 max_receive_len;
CM_INT32 what_received;
CM_INT32 received_len;
CM_INT32 status_received;
max_receive_len = reply->buffer_length;
cmrcv (cpicerr->conversation_id,
reply->buffer,
&max_receive_len,
&what_received,
&received_len,
&status_received,
&rts_received,
&cm_rc);
reply->length = (unsigned int)received_len;
return reply->buffer[0];
}
void
cpicerr_set_error_reply(CPICERR_REPLY * reply,
REPLY_RESPONSE response,
unsigned int message_category,
unsigned long primary_code,
char * primary_message_text,
unsigned long secondary_code,
char * secondary_message_text)
{
unsigned int length = 0;
unsigned short string_length;
/*
* Check and see that there is at least enough space in the reply_buffer
* to sent the required fields. If there is not enough space, return
* 0 (zero) to the caller, indicating that no bytes were copied into
* the reply_buffer.
*/
if (reply->buffer_length < CPICERR_REPLY_MIN_LENGTH) {
reply->length = 0;
return/* 0 */;
}
*((unsigned short *)&reply->buffer[CPICERR_REPLY_INDICATOR]) =
convert_short_to_network(CPICERR_REPLY_INDICATOR_VALUE);
reply->buffer[CPICERR_REPLY_RESPONSE] = (char)response;
reply->buffer[CPICERR_REPLY_RESERVED] = 0; /* set reserved byte to zero */
*((unsigned short *)&reply->buffer[CPICERR_REPLY_CATEGORY]) =
convert_short_to_network(message_category);
*((unsigned long *)&reply->buffer[CPICERR_REPLY_PRIMARY]) =
convert_long_to_network(primary_code);
*((unsigned long *)&reply->buffer[CPICERR_REPLY_SECONDARY]) =
convert_long_to_network(secondary_code);
length = CPICERR_REPLY_MIN_LENGTH;
/* check length of buffer!!! */
/*
* Copy the length and text of the primary message.
*/
string_length = strlen(primary_message_text) + 1;
*((unsigned short *)&reply->buffer[CPICERR_REPLY_PRIMARY_LENGTH]) =
convert_short_to_network(string_length);
memcpy(&reply->buffer[CPICERR_REPLY_PRIMARY_TEXT],
primary_message_text,
string_length);
convert_to_ascii(&reply->buffer[CPICERR_REPLY_PRIMARY_TEXT],
string_length);
length += 2 + string_length;
/*
* Copy the length and text of the secondary message.
*/
string_length = strlen(secondary_message_text) + 1;
*((unsigned short *)&reply->buffer[length]) =
convert_short_to_network(string_length);
memcpy(&reply->buffer[length+2],
secondary_message_text,
string_length);
convert_to_ascii(&reply->buffer[length+2],
string_length);
length += 2 + string_length;
reply->length = length;
return /* length */;
}
/*
* Requires that cpicerr_set_conv_id() has been called.
*/
int
cpicerr_send_appl_error( CPICERR * cpicerr,
NEXT_STATE next_state,
CPICERR_REPLY * reply)
{
CM_RETURN_CODE cm_rc;
CM_INT32 length;
CM_INT32 rts_received;
CM_SEND_TYPE send_type;
cmserr(cpicerr->conversation_id,
&rts_received,
&cm_rc);
switch (next_state) {
case NEXT_DEALLOCATE:
case NEXT_DEALLOCATE_AND_EXIT:
send_type = CM_SEND_AND_DEALLOCATE;
{
CM_INT32 deallocate_type = CM_DEALLOCATE_FLUSH;
cmsdt(cpicerr->conversation_id,
&deallocate_type,
&cm_rc);
}
break;
case NEXT_SEND:
send_type = CM_SEND_AND_FLUSH;
break;
case NEXT_RECEIVE:
send_type = CM_SEND_AND_PREP_TO_RECEIVE;
{
CM_PREPARE_TO_RECEIVE_TYPE ptr_type;
ptr_type = CM_PREP_TO_RECEIVE_FLUSH;
cmsptr (cpicerr->conversation_id,
&ptr_type,
&cm_rc);
}
break;
}
cmsst (cpicerr->conversation_id,
&send_type,
&cm_rc);
#if 1
if (cm_rc != CM_OK) {
printf("Ouch!!!!!!!!\n");
}
else {
}
#endif
length = reply->length;
cmsend (cpicerr->conversation_id,
reply->buffer,
&length,
&rts_received,
&cm_rc);
if (next_state == NEXT_DEALLOCATE_AND_EXIT) {
exit(EXIT_FAILURE);
}
#if 1
printf("didn't exit\n");
#endif
return0;
}
/*****************************************************************************
*
* cpicerr_new()
*
* Usage:
* This function creates a CPICERR object which should be used on all
* subsequent calls to cpicerr. If an error occurs and a valid object
* cannot be created, NULL will be returned.
*
*****************************************************************************/
CPICERR *
cpicerr_new(void)
{
CPICERR * cpicerr;
/*-----------------------------------------------------------------------*
* Allocate a block for the CPICERR structure. calloc() will initialize
* all bytes to 0.
*-----------------------------------------------------------------------*/
cpicerr = (CPICERR *) calloc(1, sizeof(*cpicerr));
if (cpicerr == NULL) {
return NULL;
}
/*-----------------------------------------------------------------------*
* Save the time of program initialization.
*-----------------------------------------------------------------------*/
cpicerr->program_start_time = time(NULL);
/*-----------------------------------------------------------------------*
* Indicate that the conversation id field has not been set.
*-----------------------------------------------------------------------*/
cpicerr->conv_id_set = FALSE;
/*-----------------------------------------------------------------------*
* Initialize version levels. 0 indicates they have not been set.
*-----------------------------------------------------------------------*/
cpicerr->major_version = 0;
cpicerr->minor_version = 0;
/*-----------------------------------------------------------------------*
* Initialize to always exit after an error occurs.
*-----------------------------------------------------------------------*/
cpicerr->exit_level = ALL_ERRORS;
/*-----------------------------------------------------------------------*
* Initialize to always show errors.
*-----------------------------------------------------------------------*/
cpicerr->show_level = ALL_ERRORS;
/*-----------------------------------------------------------------------*
* Initialize to always log errors.
*-----------------------------------------------------------------------*/
cpicerr->log_level = ALL_ERRORS;
/*-----------------------------------------------------------------------*
* Indicate that cpicerr should process all ERROR_RECEIVED return codes
* (indicating our partner issued Send_Error())
*-----------------------------------------------------------------------*/
cpicerr->handle_error = TRUE;
/*-----------------------------------------------------------------------*
* Initialize strings to NULL in case 0 != NULL
*-----------------------------------------------------------------------*/
cpicerr->program_name = NULL;
cpicerr->program_info = NULL;
cpicerr->log_file_name = NULL;
cpicerr->log_file_path = NULL;
/*-----------------------------------------------------------------------*
* Set the conversation characteristics to invalid values. If this
* isn't done, we could display seemingly valid values for these
* parameters even though they were never set properly.
*-----------------------------------------------------------------------*/
cpicerr->conversation_type = MAX_MESSAGE;
cpicerr->conversation_state = MAX_MESSAGE;
cpicerr->sync_level = MAX_MESSAGE;
return cpicerr;
}
/*****************************************************************************
*
* cpicerr_set_conv_id
*
* Usage:
* This call should be used just before the cmallc call (for clients),
* or just after the cmaccp call (for servers).
*
* This routine will save the conversation id, as well as partner information
* and conversation status which can be extracted from CPI-C.
*
* This information is often helpful for debugging and in many cases cannot
* be obtained after an error occurs, since you no longer have a valid
* conversation id after the conversation has been deallocated.
*
* Returns 0 if everything was processed successfully.
* Returns 1 if an error occurred. In general, the only reason for an
* error to occur is if one of the passed parameters is invalid. Since
* this is just storing information in the footprint, we will not
* attempt to do sophisticated error processing in this procedure.
*
*****************************************************************************/
int
cpicerr_set_conv_id(CPICERR * cpicerr,
unsigned char * conversation_id)
{
CM_RETURN_CODE conv_rc; /* Return code from CPI-C call */
int rc; /* return value for function */
if (cpicerr != (CPICERR *)NULL) {
/*-------------------------------------------------------------------*
* Save the conversation ID.
* This can often be used in conjunction with error logs or trace
* utilities.
*-------------------------------------------------------------------*/
memcpy(cpicerr->conversation_id,
conversation_id,
sizeof(cpicerr->conversation_id));
/*
* Extract the conversation type.
*/
cmect(conversation_id, /* Current conversation ID */
&cpicerr->conversation_type, /* Returned conversation type */
&conv_rc); /* Put the return code here */
if (conv_rc != CM_OK) {
/*
* Set the conversation type to an invalid value and set
* the return code to indicate an error.
*/
cpicerr->conversation_type = MAX_MESSAGE;
rc = 1;
}
/*
* Extract the mode name used for this conversation.
*/
cmemn(conversation_id, /* Current conversation ID */
cpicerr->mode_name, /* Returned mode name */
&(cpicerr->mode_name_length), /* Returned mode name length */
&conv_rc); /* Put the return code here */
if (conv_rc != CM_OK) {
/*
* Make sure the mode name is reset to uninitialized and
* set the return code to indicate an error.
*/
cpicerr->mode_name_length = 0;
rc = 1;
}
/* make sure we place the null terminator at the end of the string */
cpicerr->mode_name[(int)cpicerr->mode_name_length] = '\0';
/*-------------------------------------------------------------------*
* Extract the partner's LU name.
*-------------------------------------------------------------------*/
cmepln(conversation_id, /* Current conversation ID */
cpicerr->partner_LU_name, /* Returned partner LU */
&(cpicerr->partner_LU_name_length),/* Partner LU name length */
&conv_rc); /* Put the return code here */
if (conv_rc != CM_OK) {
/*
* Make sure the partner LU name is reset to uninitialized and
* set the return code to indicate an error.
*/
cpicerr->partner_LU_name_length = 0;
rc = 1;
}
/* make sure we place the null terminator at the end of the string */
cpicerr->partner_LU_name[(int)cpicerr->partner_LU_name_length] = '\0';
/*-------------------------------------------------------------------*
* Extract the conversation sync level.
*-------------------------------------------------------------------*/
cmesl(conversation_id, /* Current conversation ID */
&cpicerr->sync_level, /* Returned sync level */
&conv_rc); /* Put the return code here */
if (conv_rc != CM_OK) {
/*
* Set the sync level to an invalid value and set
* the return code to indicate an error.
*/
cpicerr->sync_level = MAX_MESSAGE;
rc = 1;
}
rc = 0;
} else {
rc = 1;
}
return rc;
}
/*****************************************************************************
*
* cpicerr_set_exit_level
*
* Usage:
* Specify the CPI-C error classification as the exit level.
* When cpicerr_handle_rc() is called, the return code will be classified.
* If the classification is above the exit level, the program will be
* terminated (after conversation cleanup).
*
* A value of ALL_ERRORS can be used to force an exit on any call to
* cpicerr_handle_rc(). This is the DEFAULT value.
*
* A value of NO_ERRORS can be used to indicate that cpicerr should never
* cause an exit. Your application should handle all exit termination.
* This is especially useful when using more than one conversation.
*
* Also see:
* cpicerr_set_log_level
* cpicerr_set_show_level
*****************************************************************************/
int
cpicerr_set_exit_level(CPICERR * cpicerr,
CPIC_RC_HANDLING exit_level)
{
cpicerr->exit_level = exit_level;
return 0;
}
/*****************************************************************************
*
* cpicerr_set_log_file_name
*
* Usage:
* Sets the name of the log file to be used in cpicerr_handle_rc() to
* log complete error information. No attempt is made to verify that
* the log_file_name specified is a valid filename or whether the file
* can be opened. If the log_file_name cannot be opened when logging
* needs to be done, all log output will be sent to stderr instead.
*
* For environments that support directory structures, you should specify
* the filename on cpicerr_set_log_file_name and the directory on
* cpicerr_set_log_file_path. This allows your program to be isolated
* from changes in environments that only support a single level
* of directory (for example, VM).
*
* Also see:
* cpicerr_set_log_file_path
* cpicerr_log_cpicerr (internal)
*****************************************************************************/
int
cpicerr_set_log_file_name(CPICERR * cpicerr,
char * log_file_name)
{
/*-----------------------------------------------------------------------*
* Initialize the name of the log file.
*-----------------------------------------------------------------------*/
cpicerr->log_file_name = (char *) malloc(strlen(log_file_name)+1);
if (cpicerr->log_file_name != NULL) {
strcpy(cpicerr->log_file_name, log_file_name);
return 0;
} else {
return 1;
}
}
/*****************************************************************************
*
* cpicerr_set_log_file_path
*
* Usage:
* Specifies the path qualifier for the log file name specified in the
* cpicerr_set_log_file_name call. If cpicerr_set_log_file_path is used
* without setting the log file name, no error logging will occur.
*
* If you specify a string whose first character is a $, the rest of the
* string will be looked for as an environment variable. For example,
* in OS/2, you put the following in your CONFIG.SYS:
* SET LOGPATH=d:\logfiles
*
* then specify $LOGPATH as a parameter on cpicerr_set_log_file_path.
*
*****************************************************************************/
int
cpicerr_set_log_file_path(CPICERR * cpicerr,
char * log_file_path)
{
char * path;
int rc;
/*-----------------------------------------------------------------------*
* Initialize the name of the log file.
* If the first character is a dollar sign ('$'), then try to extract
* the log file path from the environment. If not, use the path
* as specified.
*-----------------------------------------------------------------------*/
if (log_file_path[0] == '$') {
path = getenv(&log_file_path[1]);
} else {
path = log_file_path;
}
/*-----------------------------------------------------------------------*
* Check that we have a valid log file path string, allocate memory for
* the string and copy it into the cpicerr structure.
*-----------------------------------------------------------------------*/
if (path != NULL) {
cpicerr->log_file_path = (char *) malloc(strlen(path)+1);
if (cpicerr->log_file_path != NULL) {
strcpy(cpicerr->log_file_path, path);
rc = 0;
} else {
rc = 1;
}
}
else {
rc = 1;
}
return rc;
}
/*****************************************************************************
*
* cpicerr_set_log_level
*
* Usage:
* Specify the CPI-C error classification as the log level.
* When cpicerr_handle_rc() is called, the return code will be classified.
* If the classification is above the log level, the return code and
* conversation information will be logged to the log file specified
* with the cpicerr_set_log_file_name and cpicerr_set_log_file_path.
*
* A value of ALL_ERRORS can be used to force logging on any call to
* cpicerr_handle_rc(). This is the DEFAULT value. This is especially
* useful when used on servers.
*
* A value of NO_ERRORS can be used to indicate that cpicerr should never
* cause an error log. Your application should handle all error logging.
*
* Also see:
* cpicerr_set_log_file_name
* cpicerr_set_log_file_path
* cpicerr_log_cpicerr (internal)
* cpicerr_set_exit_level
* cpicerr_set_show_level
*****************************************************************************/
int
cpicerr_set_log_level(CPICERR * cpicerr,
CPIC_RC_HANDLING log_level)
{
cpicerr->log_level = log_level;
return 0;
}
/*****************************************************************************
*
* cpicerr_set_major_version
*
* Usage:
* Sets the major version number for the application.
* The version number can be 0-255.
*
* The version number is used on error logging and by the
* cpicerr_exchange_version() call.
*
* Also see:
* cpicerr_set_minor_version
*****************************************************************************/
int
cpicerr_set_major_version(CPICERR * cpicerr,
unsigned char major_version)
{
cpicerr->major_version = major_version;
return 0;
}
/*****************************************************************************
*
* cpicerr_set_minor_version
*
* Usage:
* Sets the minor version number for the application.
* The version number can be 0-255.
*
* The version number is used on error logging and by the
* cpicerr_exchange_version() call.
*
* Also see:
* cpicerr_set_major_version
*****************************************************************************/
int
cpicerr_set_minor_version(CPICERR * cpicerr,
unsigned char minor_version)
{
cpicerr->minor_version = minor_version;
return 0;
}
/*****************************************************************************
*
* cpicerr_set_program_info
*
* Usage:
* Sets a program information string that is included in the log information.
*****************************************************************************/
int
cpicerr_set_program_info( CPICERR * cpicerr,
char * program_info)
{
int rc;
/*-----------------------------------------------------------------------*
* Save the application's program information string
*-----------------------------------------------------------------------*/
cpicerr->program_info = (char *) malloc(strlen(program_info)+1);
if (cpicerr->program_info != NULL) {
strcpy(cpicerr->program_info, program_info);
rc = 0;
} else {
rc = 1;
}
return rc;
}
/*****************************************************************************
*
* cpicerr_set_program_name
*
* Usage:
* Sets a program name string that is included in the log information.
*****************************************************************************/
int
cpicerr_set_program_name(CPICERR * cpicerr,
char * program_name)
{
int rc;
/*-----------------------------------------------------------------------*
* Save the local program name.
*-----------------------------------------------------------------------*/
cpicerr->program_name = (char *) malloc(strlen(program_name)+1);
if (cpicerr->program_name != NULL) {
strcpy(cpicerr->program_name, program_name);
rc = 0;
} else {
rc = 1;
}
return rc;
}
/*****************************************************************************
*
* cpicerr_set_show_level
*
* Usage:
* Specify the CPI-C error classification as the show level.
* When cpicerr_handle_rc() is called, the return code will be classified.
* If the classification is above the show level, the return code and
* some conversation information will be shown to the user.
*
* A value of ALL_ERRORS can be used to force showing of all calls to
* cpicerr_handle_rc(). This is the DEFAULT value.
*
* A value of NO_ERRORS can be used to indicate that cpicerr should never
* cause an error to be shown to the user.
*
* Also see:
* cpicerr_set_exit_level
* cpicerr_set_log_level
*****************************************************************************/
int
cpicerr_set_show_level(CPICERR * cpicerr,
CPIC_RC_HANDLING show_level)
{
cpicerr->show_level = show_level;
return 0;
}
/******************************************************************************
*
* cpicerr_handle_rc_extended
*
* Note:
* applications should use the cpicerr_handle_rc() macro.
*
* Usage:
* This function should be called to handle any unexpected CPI-C return
* codes. The exact function of this routine depends upon the settings
* that have been made to the CPICERR object.
*
* Functions include:
* Determining the current conversation state
* Classifying the return code (CPIC_RC_HANDLING enum)
* Showing return code info to the user
* Logging the return code and conversation info to disk
* Deallocate the conversation and exit
*
* Also see:
* cpicerr_set_exit_level
* cpicerr_set_log_level
* cpicerr_set_show_level
*
*****************************************************************************/
CPIC_RC_HANDLING
cpicerr_handle_rc_extended(CPICERR * cpicerr,
CPIC_VERB_INDEX verb_index,
CM_RETURN_CODE conv_rc,
char * file_name,
int file_line)
{
/* Displays the CPI-C return code and the verb name. */
CM_RETURN_CODE cm_rc; /* Return code from CPI-C call */
CPIC_RC_HANDLING classification; /* Returned RC classification */
char * string; /* temp var for output strings */
CM_CONVERSATION_STATE conversation_state; /* Current conv. state */
/*-----------------------------------------------------------------------*
* Extract the current conversation state.
* This will not be useful if the conversation has failed or a deallocate
* return code has been received. The conversation state is most useful
* when a state check has occurred.
*-----------------------------------------------------------------------*/
#ifndef ECS_NOT_SUPPORTED
cmecs(cpicerr->conversation_id,
&conversation_state,
&cm_rc);
if (cm_rc == CM_OK) {
cpicerr->conversation_state = conversation_state;
}
else {
cpicerr->conversation_state = CMECS_NOT_SUPPORTED;
}
#else
cpicerr->conversation_state = CMECS_NOT_SUPPORTED;
#endif
/*-----------------------------------------------------------------------*
* Store the error information in the cpicerr structure
*-----------------------------------------------------------------------*/
cpicerr_set_rc_info(cpicerr, verb_index, conv_rc);
/*-----------------------------------------------------------------------*
* Get the classification for this return code.
*-----------------------------------------------------------------------*/
cpicerr_classify_rc(conv_rc, &classification);
if (classification == ERROR_RECEIVED && cpicerr->handle_error == TRUE) {
CPICERR_REPLY * reply;
reply = cpicerr_create_reply(1000,1000);
cpicerr_recv_appl_error(cpicerr, reply);
cpicerr_show_reply(reply);
if (classification >= cpicerr->exit_level) {
CM_INT32 deallocate_type;
/*
* Exit the application, rather than returning to the caller.
*/
deallocate_type = CM_DEALLOCATE_ABEND;
cmsdt(cpicerr -> conversation_id,
&deallocate_type,
&cm_rc);
cmdeal(cpicerr -> conversation_id,
&cm_rc);
do_exit(EXIT_FAILURE);
}
return classification;
}
/*-----------------------------------------------------------------------*
* Show the CPI-C verb and return code.
*-----------------------------------------------------------------------*/
if (classification >= cpicerr->show_level) {
cpicerr_show_rc(cpicerr);
}
/*-----------------------------------------------------------------------*
* Show the classification for this return code.
*-----------------------------------------------------------------------*/
if (classification >= cpicerr->show_level) {
string = cpicerr_get_message(CPIC_RC_CLASSES, classification);
write_error(" return code class: %s\n", string);
/*-------------------------------------------------------------------*
* Show product specific information associated with this error.
*-------------------------------------------------------------------*/
cpicerr_show_product_info(cpicerr);
}
/*-----------------------------------------------------------------------*
* Log this error, along with the infomation in its cpicerr.
*-----------------------------------------------------------------------*/
if (classification >= cpicerr->log_level) {
cpicerr_log_cpicerr(cpicerr, file_name, file_line);
}
if (classification >= cpicerr->exit_level) {
CM_INT32 deallocate_type;
/*-------------------------------------------------------------------*
* Exit the application, rather than returning to the caller.
*-------------------------------------------------------------------*/
deallocate_type = CM_DEALLOCATE_ABEND;
cmsdt(cpicerr -> conversation_id,
&deallocate_type,
&cm_rc);
cmdeal(cpicerr -> conversation_id,
&cm_rc);
do_exit(EXIT_FAILURE); /* Set a failure return code */
}
return classification;
}
/******************************************************************************
*
* cpicerr_exchange_version
*
* Usage:
* Calls cpicerr_exchange_version_plus()
*
*****************************************************************************/
int
cpicerr_exchange_version(CPICERR * cpicerr,
unsigned char * cm_conv_id,
CM_INT32 conv_state,
unsigned char * partner_major_version,
unsigned char * partner_minor_version)
{
return cpicerr_exchange_version_plus(cpicerr,
cm_conv_id,
conv_state,
partner_major_version,
partner_minor_version,
NULL,
0);
}
/******************************************************************************
*
* cpicerr_exchange_version_plus
*
* Usage:
* Send our two version number bytes to the partner and receive our
* partner's two version numbers. The input parameter conv_state
* determines whether our version numbers are sent first, or whether
* we receive the partner's numbers first.
*
* Also will return the remote operating system string, if sent.
*
*****************************************************************************/
int
cpicerr_exchange_version_plus(CPICERR * cpicerr,
unsigned char * cm_conv_id,
CM_INT32 conv_state,
unsigned char * partner_major_version,
unsigned char * partner_minor_version,
unsigned char * opsys_string,
unsigned int opsys_string_length)
{
CM_SEND_TYPE send_type; /* CPI-C send type */
CM_PREPARE_TO_RECEIVE_TYPE prep_to_receive; /* CPI-C prepare to receive */
CM_INT32 cm_rc; /* CPI-C return code */
CM_INT32 length; /* generic length variable */
CM_INT32 rts_received; /* request to send received */
CM_INT32 max_receive_len; /* Max receive length on CMRCV */
CM_INT32 what_received; /* What received parm from CMRCV */
CM_INT32 received_len; /* Amount of data rcvd on CMRCV */
CM_INT32 status_received; /* Status from CMRCV */
unsigned char buffer[EXCHANGE_BUFFER_SIZE]; /* data buffer */
*partner_major_version = 0;
*partner_minor_version = 0;
prep_to_receive = CM_PREP_TO_RECEIVE_FLUSH;
cmsptr(cm_conv_id, /* Set prepare to receive type */
&prep_to_receive,
&cm_rc);
/* The only expected return code is CM_OK */
if (cm_rc != CM_OK) return cpicerr_handle_rc(cpicerr, MSG_CMSPTR, cm_rc);
send_type = CM_BUFFER_DATA;
cmsst(cm_conv_id, /* Set send type */
&send_type,
&cm_rc);
if (cm_rc != CM_OK) return cpicerr_handle_rc(cpicerr, MSG_CMSST, cm_rc);
switch (conv_state) {
case CM_SEND_STATE:
buffer[0] = CPICERR_EXCHANGE_VERSION;
buffer[1] = cpicerr->major_version;
buffer[2] = cpicerr->minor_version;
length = 3;
cmsend(cm_conv_id,
buffer,
&length,
&rts_received,
&cm_rc);
/* The only expected return code is CM_OK */
if (cm_rc != CM_OK)
return cpicerr_handle_rc(cpicerr, MSG_CMSEND, cm_rc);
/* this falls through to the receive code!!! */
case CM_RECEIVE_STATE:
max_receive_len = sizeof(buffer);
cmrcv (cm_conv_id,
buffer,
&max_receive_len,
&what_received,
&received_len,
&status_received,
&rts_received,
&cm_rc);
if (cm_rc == CM_OK) {
if (what_received != CM_NO_DATA_RECEIVED) {
if (received_len > 2 && buffer[0]==CPICERR_EXCHANGE_VERSION) {
*partner_major_version = buffer[1];
*partner_minor_version = buffer[2];
}
if (opsys_string != NULL && opsys_string_length > 1) {
if (received_len > 4 &&
buffer[3]==CPICERR_EXCHANGE_OPSYS_STRING) {
if (received_len < sizeof(buffer)) {
buffer[received_len] = '\0';
}
else {
buffer[sizeof(buffer)] = '\0';
}
{
unsigned int string_length;
string_length = strlen(&buffer[4]);
convert_from_ascii(&buffer[4], string_length);
memcpy(opsys_string,
&buffer[4],
min(string_length, opsys_string_length-1));
opsys_string[min(string_length, opsys_string_length-1)]
= '\0';
}
}
else {
opsys_string[0] = '\0';
}
}
else {
}
}
switch (status_received) {
case CM_CONFIRM_RECEIVED:
cmcfmd(cm_conv_id,
&cm_rc);
if (cm_rc != CM_OK)
return cpicerr_handle_rc(cpicerr, MSG_CMCFMD, cm_rc);
break;
case CM_SEND_RECEIVED:
/* This is good, we don't have to do anything. */
break;
default:
;
/* should do a reply_error here */
}
} else {
return cpicerr_handle_rc(cpicerr, MSG_CMRCV, cm_rc);
}
break;
default:
/* do a reply error here */
return UNRECOVERABLE;
}
if ((conv_state == CM_RECEIVE_STATE) &&
(status_received == CM_SEND_RECEIVED)) {
char * local_opsys_string;
unsigned int local_opsys_string_length;
buffer[0] = CPICERR_EXCHANGE_VERSION;
buffer[1] = cpicerr->major_version;
buffer[2] = cpicerr->minor_version;
local_opsys_string = OPSYS_STRING;
local_opsys_string_length = strlen(local_opsys_string);
if ((local_opsys_string_length + 1+ 3 +1) < sizeof(buffer)) {
buffer[3] = CPICERR_EXCHANGE_OPSYS_STRING;
memcpy(&buffer[4],
local_opsys_string,
local_opsys_string_length);
convert_to_ascii(&buffer[4], local_opsys_string_length);
buffer[4+local_opsys_string_length] ='\0';
length = 4 + local_opsys_string_length + 1;
}
else {
length = 3;
}
cmsend(cm_conv_id,
buffer,
&length,
&rts_received,
&cm_rc);
/* The only expected return code is CM_OK */
if (cm_rc != CM_OK)
return cpicerr_handle_rc(cpicerr, MSG_CMSEND, cm_rc);
cmptr(cm_conv_id,
&cm_rc);
if (cm_rc != CM_OK)
return cpicerr_handle_rc(cpicerr, MSG_CMPTR, cm_rc);
}
return RC_OK;
}
/*****************************************************************************
*
* cpicerr_destroy()
*
* Destroys a CPICERR structure created with cpicerr_new().
* All memory assocated with the input CPICERR pointer is freed.
*
*****************************************************************************/
void
cpicerr_destroy(CPICERR * cpicerr)
{
/*
* Make sure we don't free() a NULL pointer!!!
*/
if (cpicerr != NULL) {
if (cpicerr->program_name != NULL) {
free(cpicerr->program_name);
}
if (cpicerr->program_info != NULL) {
free(cpicerr->program_info);
}
if (cpicerr->log_file_name != NULL) {
free(cpicerr->log_file_name);
}
if (cpicerr->log_file_path != NULL) {
free(cpicerr->log_file_path);
}
free(cpicerr);
}
return;
}
/*****************************************************************************
*
* cpicerr_set_rc_info
*
* Internal call which makes it easier to store return code information
* in the CPICERR structure. Called from cpicerr_handle_rc().
*
*****************************************************************************/
void
cpicerr_set_rc_info(CPICERR * cpicerr,
CPIC_VERB_INDEX verb_index,
CM_RETURN_CODE conv_rc)
/* Store the verb return code information into the cpicerr structure */
{
cpicerr->verb_index = verb_index;
cpicerr->conv_rc = conv_rc;
}
/*****************************************************************************
*
* cpicerr_show_rc
*
* Internal call which will display information about the unexpected
* return code encountered. Called from cpicerr_handle_rc().
*
*****************************************************************************/
void
cpicerr_show_rc(CPICERR * cpicerr)
{
write_error("\n Unexpected CPI-C return code encountered...\n");
/*-----------------------------------------------------------------------*
* Find the CPI-C verb's name, and show it.
*-----------------------------------------------------------------------*/
write_error( " CPI-C verb name: %s, %s\n",
cpicerr_get_message(CPIC_VERBS_SHORT,
(CM_INT32)cpicerr->verb_index),
cpicerr_get_message(CPIC_VERBS_LONG,
(CM_INT32)cpicerr->verb_index));
/*-----------------------------------------------------------------------*
* Find the CPI-C return code's name, and show it.
*-----------------------------------------------------------------------*/
write_error( " CPI-C return code: %lu, %s\n",
cpicerr->conv_rc,
cpicerr_get_message(CPIC_RETURN_CODES, cpicerr->conv_rc));
return;
}
/*****************************************************************************
*
* cpicerr_log_rc
*
* Internal call which will log information about the unexpected
* return code encountered. Called from cpicerr_handle_rc().
*
*****************************************************************************/
void
cpicerr_log_rc(CPICERR * cpicerr,
FILE * log_file)
{
write_log(log_file, " Unexpected CPI-C return code encountered...\n");
/*-----------------------------------------------------------------------*
* Find the CPI-C verb's name, and show it.
*-----------------------------------------------------------------------*/
write_log(log_file,
" CPI-C verb name: %s, %s\n",
cpicerr_get_message(CPIC_VERBS_SHORT,
(CM_INT32)cpicerr->verb_index),
cpicerr_get_message(CPIC_VERBS_LONG,
(CM_INT32)cpicerr->verb_index));
/*-----------------------------------------------------------------------*
* Find the CPI-C return code's name, and show it.
*-----------------------------------------------------------------------*/
write_log(log_file,
" CPI-C return code: %lu, %s\n",
cpicerr->conv_rc,
cpicerr_get_message(CPIC_RETURN_CODES, cpicerr->conv_rc));
return;
}
/*****************************************************************************
*
* cpicerr_classify_rc
*
* Internal call which takes a CPI-C return code and classifies it
* into one of the categories that we have defined.
* Called from cpicerr_handle_rc().
*
*****************************************************************************/
void
cpicerr_classify_rc (CM_RETURN_CODE conv_rc,
CPIC_RC_HANDLING * classification)
{
switch (conv_rc) {
case CM_ALLOCATE_FAILURE_NO_RETRY:
/* configuration defect or protocol defect, local or partner */
case CM_TP_NOT_AVAILABLE_NO_RETRY:
/* partner program could not be sucessfully started */
case CM_RESOURCE_FAILURE_NO_RETRY:
/* communication failure or protocol defect, local or partner */
case CM_DEALLOCATED_ABEND:
/* unrecoverable error in the partner TP */
case CM_DEALLOCATED_ABEND_SVC:
/* unrecoverable error in the partner TP */
case CM_DEALLOCATED_ABEND_TIMER:
/* unrecoverable error in the partner TP */
case CM_CONVERSATION_TYPE_MISMATCH:
case CM_PIP_NOT_SPECIFIED_CORRECTLY:
/* configuration defect or mismatch with the partner */
case CM_OK:
/* application design defect, local or partner program */
case CM_DEALLOCATED_NORMAL:
/* TP design defect, local or partner program */
case CM_PARAMETER_ERROR:
/* local program design or coding defect */
case CM_PROGRAM_PARAMETER_CHECK:
/* local program design or coding defect */
case CM_PROGRAM_STATE_CHECK:
/* local program design or coding defect */
*classification = UNRECOVERABLE;
break;
case CM_ALLOCATE_FAILURE_RETRY:
/* configuration defect or route temporarily down */
case CM_TP_NOT_AVAILABLE_RETRY:
/* congestion at the partner operating system */
case CM_RESOURCE_FAILURE_RETRY:
/* route temporarily down */
*classification = RETRY_CONV;
break;
case CM_UNSUCCESSFUL:
/* verb could not be completed now */
*classification = RETRY_VERB;
break;
case CM_PROGRAM_ERROR_NO_TRUNC:
case CM_SVC_ERROR_NO_TRUNC:
/* partner failed while building a record to send */
case CM_PROGRAM_ERROR_PURGING:
case CM_SVC_ERROR_PURGING:
/* partner failed while processing a received record */
case CM_PROGRAM_ERROR_TRUNC:
case CM_SVC_ERROR_TRUNC:
/* partner failed after partially sending a record */
*classification = ERROR_RECEIVED;
break;
case CM_PRODUCT_SPECIFIC_ERROR:
/********************************/
/* Examine each of these. */
/* In some cases, you may want */
/* to return CONTINUE. */
/********************************/
*classification = UNRECOVERABLE;
break;
case CM_SECURITY_NOT_VALID:
*classification = SECURITY_NOT_VALID;
break;
default:
*classification = UNRECOVERABLE;
break;
}
return;
}
/*****************************************************************************
*
* cpicerr_log_cpicerr()
*
* Internal call which logs complete conversation and error information
* to a log file. Called by cpicerr_handle_rc().
*
*****************************************************************************/
int
cpicerr_log_cpicerr(CPICERR * cpicerr,
char * file_name,
int file_line)
{
int rc; /* return value */
FILE * log_file; /* log file handle */
unsigned count; /* used to extract text strings */
char filepath[256]; /* actual file path for logging */
char last_char;
if (cpicerr != (CPICERR *)NULL) {
/*-------------------------------------------------------------------*
* Save the time of the call to this procedure.
*-------------------------------------------------------------------*/
cpicerr->program_error_time = time(NULL);
filepath[0] = '\0';
if (cpicerr->log_file_path != NULL &&
cpicerr->log_file_path[0] != '\0') {
strcpy(filepath, cpicerr->log_file_path);
last_char =
cpicerr->log_file_path[strlen(cpicerr->log_file_path)-1];
if (!(last_char == '\\' || last_char == '/')) {
strcat(filepath, "/");
}
}
if (cpicerr->log_file_name != NULL) {
strcat(filepath, cpicerr->log_file_name);
}
if ((strlen(filepath) == 0) ||
((log_file = fopen(filepath, "a")) == NULL )) {
log_file = stderr;
}
write_log(log_file,
"------------------------------------------------------\n");
if (cpicerr->program_name != NULL) {
write_log(log_file, " CPI-C error in program: \"%s\"",
cpicerr->program_name);
}
if (cpicerr->program_info != NULL) {
write_log(log_file, ", %s\n", cpicerr->program_info);
}
if (cpicerr->major_version != 0 || cpicerr->minor_version != 0) {
write_log(log_file, " Program version: %u.%u\n",
(unsigned int)cpicerr->major_version,
(unsigned int)cpicerr->minor_version);
}
cpicerr_log_rc(cpicerr, log_file);
if (cpicerr->partner_LU_name[0] != '\0') {
cpicerr->partner_LU_name[(int)cpicerr->partner_LU_name_length]
= '\0';
}
if (cpicerr->mode_name[0] != '\0') {
cpicerr->mode_name[(int)cpicerr->mode_name_length] = '\0';
}
write_log(log_file, " Partner LU name: %s\n",
cpicerr->partner_LU_name);
write_log(log_file, " Mode name: %s\n",
cpicerr->mode_name);
write_log(log_file, " CPI-C conversation ID: ");
for (count = 0; count<sizeof(cpicerr->conversation_id); count++ ) {
write_log(log_file, "%02X",
(unsigned int)cpicerr->conversation_id[count]);
}
write_log(log_file, "\n");
write_log(log_file, "CPI-C conversation state: %lu, %s\n",
cpicerr->conversation_state,
cpicerr_get_message(CPIC_STATES_CONV, cpicerr->conversation_state));
write_log(log_file, " CPI-C conversation type: %lu, %s\n",
cpicerr->conversation_type,
cpicerr_get_message( CPIC_CONV_TYPES, cpicerr->conversation_type));
write_log(log_file, " Conversation sync level: %lu, %s\n",
cpicerr->sync_level,
cpicerr_get_message( CPIC_SYNC_LEVELS, cpicerr->sync_level));
write_log(log_file, " Program start time: %s",
ctime(&(cpicerr->program_start_time)));
write_log(log_file, " Program error time: %s",
ctime(&(cpicerr->program_error_time)));
write_log(log_file, " Called from source file: %s\n", file_name);
write_log(log_file, " at line: %d\n", file_line);
fclose(log_file);
rc = 0;
} else {
rc = 1;
}
return rc;
}
CPICERR_MESSAGE cpicerr_verbs_short[] = {
MSG_CMACCP, "CMACCP",
MSG_CMALLC, "CMALLC",
MSG_CMCFM, "CMCFM",
MSG_CMCFMD, "CMCFMD",
MSG_CMDEAL, "CMDEAL",
MSG_CMECS, "CMECS",
MSG_CMECT, "CMECT",
MSG_CMEMN, "CMEMN",
MSG_CMEPLN, "CMEPLN",
MSG_CMESL, "CMESL",
MSG_CMFLUS, "CMFLUS",
MSG_CMINIT, "CMINIT",
MSG_CMPTR, "CMPTR",
MSG_CMRCV, "CMRCV",
MSG_CMRTS, "CMRTS",
MSG_CMSCT, "CMSCT",
MSG_CMSDT, "CMSDT",
MSG_CMSED, "CMSED",
MSG_CMSEND, "CMSEND",
MSG_CMSERR, "CMSERR",
MSG_CMSF, "CMSF",
MSG_CMSLD, "CMSLD",
MSG_CMSMN, "CMSMN",
MSG_CMSPLN, "CMSPLN",
MSG_CMSPTR, "CMSPTR",
MSG_CMSRC, "CMSRC",
MSG_CMSRT, "CMSRT",
MSG_CMSSL, "CMSSL",
MSG_CMSST, "CMSST",
MSG_CMSTPN, "CMSTPN",
MSG_CMTRTS, "CMTRTS",
MSG_XCSCSU, "XCSCSU",
MSG_XCSCSP, "XCSCSP",
MSG_XCSCST, "XCSCST",
MSG_XCECST, "XCECST",
MSG_XCECSU, "XCECSU",
MSG_XCMSSI, "XCMSSI",
MSG_XCMESI, "XCMESI",
MSG_XCMDSI, "XCMDSI",
MAX_MESSAGE, "ERROR "
};
CPICERR_MESSAGE cpicerr_verbs_long[] = {
MSG_CMACCP, "Accept_Conversation",
MSG_CMALLC, "Allocate",
MSG_CMCFM, "Confirm",
MSG_CMCFMD, "Confirmed",
MSG_CMDEAL, "Deallocate",
MSG_CMECS, "Extract_Conversation_State",
MSG_CMECT, "Extract_Conversation_Type",
MSG_CMEMN, "Extract_Mode_Name",
MSG_CMEPLN, "Extract_Partner_LU_Name",
MSG_CMESL, "Extract_Sync_Level",
MSG_CMFLUS, "Flush",
MSG_CMINIT, "Initialize_Conversation",
MSG_CMPTR, "Prepare_To_Receive",
MSG_CMRCV, "Receive",
MSG_CMRTS, "Request_To_Send",
MSG_CMSCT, "Set_Conversation_Type",
MSG_CMSDT, "Set_Deallocate_Type",
MSG_CMSED, "Set_Error_Direction",
MSG_CMSEND, "Send_Data",
MSG_CMSERR, "Send_Error",
MSG_CMSF, "Set_Fill",
MSG_CMSLD, "Set_Log_Data",
MSG_CMSMN, "Set_Mode_Name",
MSG_CMSPLN, "Set_Partner_LU_Name",
MSG_CMSPTR, "Set_Prepare_To_Receive_Type",
MSG_CMSRC, "Set_Return_Control",
MSG_CMSRT, "Set_Receive_Type",
MSG_CMSSL, "Set_Sync_Level",
MSG_CMSST, "Set_Send_Type",
MSG_CMSTPN, "Set_TP_Name",
MSG_CMTRTS, "Test_Request_To_Send_Received",
MSG_XCSCSU, "Set Conversation Security Userid",
MSG_XCSCSP, "Set Conversation Security Password",
MSG_XCSCST, "Set Conversation Security Type",
MSG_XCECST, "Extract_Conversation_Security_Type",
MSG_XCECSU, "Extract_Conversation_Security_Userid",
MSG_XCMSSI, "Set_CPIC_Side_Information",
MSG_XCMESI, "Extract_CPIC_Side_Information",
MSG_XCMDSI, "Delete_CPIC_Side_Information",
MAX_MESSAGE, "Invalid verb name"
};
CPICERR_MESSAGE cpicerr_return_codes[] = {
CM_OK, "CM_OK",
CM_ALLOCATE_FAILURE_NO_RETRY, "CM_ALLOCATE_FAILURE_NO_RETRY",
CM_ALLOCATE_FAILURE_RETRY, "CM_ALLOCATE_FAILURE_RETRY",
CM_CONVERSATION_TYPE_MISMATCH, "CM_CONVERSATION_TYPE_MISMATCH",
CM_PIP_NOT_SPECIFIED_CORRECTLY, "CM_PIP_NOT_SPECIFIED_CORRECTLY",
CM_SECURITY_NOT_VALID, "CM_SECURITY_NOT_VALID",
CM_TP_NOT_AVAILABLE_NO_RETRY, "CM_TP_NOT_AVAILABLE_NO_RETRY",
CM_TP_NOT_AVAILABLE_RETRY, "CM_TP_NOT_AVAILABLE_RETRY",
CM_DEALLOCATED_ABEND, "CM_DEALLOCATED_ABEND",
CM_DEALLOCATED_NORMAL, "CM_DEALLOCATED_NORMAL",
CM_PARAMETER_ERROR, "CM_PARAMETER_ERROR",
CM_PRODUCT_SPECIFIC_ERROR, "CM_PRODUCT_SPECIFIC_ERROR",
CM_PROGRAM_ERROR_NO_TRUNC, "CM_PROGRAM_ERROR_NO_TRUNC",
CM_PROGRAM_ERROR_PURGING, "CM_PROGRAM_ERROR_PURGING",
CM_PROGRAM_ERROR_TRUNC, "CM_PROGRAM_ERROR_TRUNC",
CM_PROGRAM_PARAMETER_CHECK, "CM_PROGRAM_PARAMETER_CHECK",
CM_PROGRAM_STATE_CHECK, "CM_PROGRAM_STATE_CHECK",
CM_RESOURCE_FAILURE_NO_RETRY, "CM_RESOURCE_FAILURE_NO_RETRY",
CM_RESOURCE_FAILURE_RETRY, "CM_RESOURCE_FAILURE_RETRY",
CM_UNSUCCESSFUL, "CM_UNSUCCESSFUL",
CM_DEALLOCATED_ABEND_SVC, "CM_DEALLOCATED_ABEND_SVC",
CM_DEALLOCATED_ABEND_TIMER, "CM_DEALLOCATED_ABEND_TIMER",
CM_SVC_ERROR_NO_TRUNC, "CM_SVC_ERROR_NO_TRUNC",
CM_SVC_ERROR_PURGING, "CM_SVC_ERROR_PURGING",
CM_SVC_ERROR_TRUNC, "CM_SVC_ERROR_TRUNC",
MAX_MESSAGE, "Invalid Return Code Value"
};
CPICERR_MESSAGE cpicerr_rc_classes[] = {
BACKOUT_RECEIVED, "BACKOUT_RECEIVED",
CONTINUE, "CONTINUE",
ERROR_RECEIVED, "ERROR_RECEIVED",
SECURITY_NOT_VALID, "SECURITY_NOT_VALID",
RETRY_CONV, "RETRY_CONVERSATION",
RETRY_CONV_BO, "RETRY_CONVERSATION_BACKOUT",
RETRY_VERB, "RETRY_LAST_VERB",
UNRECOVERABLE, "UNRECOVERABLE",
UNRECOVERABLE_BO, "UNRECOVERABLE_BACKOUT",
MAX_MESSAGE, "Invalid Return Code Class"
};
CPICERR_MESSAGE cpicerr_states_conv[] = {
CM_INITIALIZE_STATE, "Initialize state",
CM_SEND_STATE, "Send state",
CM_RECEIVE_STATE, "Receive state",
CM_SEND_PENDING_STATE, "Send pending state",
CM_CONFIRM_STATE, "Confirm state",
CM_CONFIRM_SEND_STATE, "Confirm send state",
CM_CONFIRM_DEALLOCATE_STATE, "Confirm deallocate state",
CMECS_NOT_SUPPORTED, "CMECS not supported",
MAX_MESSAGE, "Invalid Conversation State value"
};
CPICERR_MESSAGE cpicerr_sync_levels[] = {
CM_NONE, "None",
CM_CONFIRM, "Confirm",
MAX_MESSAGE, "Invalid Sync Level value"
};
CPICERR_MESSAGE cpicerr_conv_types[] = {
CM_BASIC_CONVERSATION , "Basic",
CM_MAPPED_CONVERSATION, "Mapped",
MAX_MESSAGE, "Invalid conversation type value"
};
CPICERR_MESSAGE_LIST message_list[] = {
CPIC_SYNC_LEVELS, cpicerr_sync_levels,
CPIC_CONV_TYPES, cpicerr_conv_types,
CPIC_STATES_CONV, cpicerr_states_conv,
CPIC_RC_CLASSES, cpicerr_rc_classes,
CPIC_RETURN_CODES, cpicerr_return_codes,
CPIC_VERBS_SHORT, cpicerr_verbs_short,
CPIC_VERBS_LONG, cpicerr_verbs_long,
MAX_MESSAGE, NULL
};
/*****************************************************************************
*
* cpicerr_get_message()
*
* Loop through the message arrays looking for the message type and
* message index. Return a pointer to the appropriate string.
*
* This procedure will never return NULL, thus is safe to use in
* printf() type calls.
*
*****************************************************************************/
char *
cpicerr_get_message(CPICERR_MESSAGE_TYPE message_type, CM_INT32 index)
{
unsigned int count; /* counter through the array */
CPICERR_MESSAGE * messages;
for (count = 0; message_list[count].type < MAX_MESSAGE ; count++ ) {
if (message_list[count].type == message_type) break;
}
if ( (messages = message_list[count].list) == NULL ) {
return "Message list not found.";
}
for (count = 0; messages[count].index < MAX_MESSAGE; count++) {
if (messages[count].index == index) break;
}
return messages[count].message;
}
/*****************************************************************************
*
* cpicerr_show_product_info
*
*****************************************************************************/
void
cpicerr_show_product_info(CPICERR * cpicerr)
{
if (cpicerr->conv_rc == CM_ALLOCATE_FAILURE_NO_RETRY ||
cpicerr->conv_rc == CM_ALLOCATE_FAILURE_RETRY ) {
#if defined(GET_OS2_SENSE_DATA)
#if defined(FAPI)
if (get_machine_mode()) {
#endif
write_error(
"\n Retrying Allocate to extract OS/2 sense data:\n");
cpicerr_os2_appc_allocate(cpicerr);
#if defined(FAPI)
}
#endif
#endif
}
}
#ifdef GET_OS2_SENSE_DATA
cpicerr_os2_appc_allocate(CPICERR * cpicerr)
/*
* This procedure retries the allocate that failed in CPI-C. We are not
* retrying the allocate to establish the connection, but to get more
* error information about why the first allocate failed.
*
* The OS/2 APPC api is used to extract the sense data, which provides
* a more specify reason for an allocation failure.
*/
{
TP_STARTED tp_started; /* Declare a verb control block */
TP_STARTED *ptr_tp_started = (TP_STARTED *)&tp_started;
int length; /* length of lu_alias */
char plu_alias[8+1];
char fqplu_name[17+1];
ALLOCATE allocate; /* Declare a verb control block */
ALLOCATE *ptr_allocate = (ALLOCATE *)&allocate;
TP_ENDED tp_ended; /* Declare a verb control block */
TP_ENDED *ptr_tp_ended = (TP_ENDED *)&tp_ended;
CLEAR_VCB(tp_started); /* Zero the verb control block */
tp_started.opcode = AP_TP_STARTED; /* APPC verb - TP_STARTED */
memset( tp_started.lu_alias, (int)'\0', sizeof(tp_started.lu_alias));
BLANK_STRING(tp_started.tp_name); /* Set 64-byte string to blanks */
ascii_to_ebcdic_field(tp_started.tp_name,
sizeof(tp_started.tp_name));
APPC ((ULONG) (TP_STARTED far *)ptr_tp_started); /* Issue the verb */
if (tp_started.primary_rc == AP_OK) {
CLEAR_VCB(allocate); /* Zero the vcb */
allocate.opcode = AP_B_ALLOCATE; /* Verb - ALLOCATE */
allocate.opext = AP_MAPPED; /* Basic Conversation type */
/* Set the TP_ID */
memcpy (allocate.tp_id, tp_started.tp_id, sizeof(allocate.tp_id));
allocate.sync_level = AP_CONFIRM; /* Sync level-confirm */
allocate.rtn_ctl = AP_WHEN_SESSION_FREE;/* avoid deadlock */
allocate.security = AP_NONE; /* Set security type */
if (!parse_destination(cpicerr->partner_LU_name,
plu_alias,
fqplu_name)) {
if ((length = strlen(plu_alias)) != 0) {
BLANK_STRING(allocate.plu_alias);
memcpy ( allocate.plu_alias,
plu_alias,
min(length, sizeof(allocate.plu_alias)));
/* Set PLU_ALIAS */
} else {
memset (allocate.plu_alias,(int)'\0',sizeof(allocate.plu_alias));
BLANK_STRING(allocate.fqplu_name); /* Set FQ PLU NAME */
memcpy ( allocate.fqplu_name,
fqplu_name,
min(strlen(fqplu_name), sizeof(allocate.fqplu_name)));
TOUPPER_STRING(allocate.fqplu_name, 17);
ascii_to_ebcdic_field(allocate.fqplu_name,
sizeof(allocate.fqplu_name));
}
} else {
BLANK_STRING(allocate.plu_alias);
memcpy ( allocate.plu_alias,
"UNKNOWN",
7);
}
BLANK_STRING(allocate.tp_name); /* Set 64-byte string to blanks */
ascii_to_ebcdic_field(allocate.tp_name,
sizeof(allocate.tp_name));
BLANK_STRING(allocate.mode_name); /* Set 8-byte string to blanks */
memcpy ( allocate.mode_name,
cpicerr->mode_name,
min(strlen(cpicerr->mode_name),
sizeof(allocate.mode_name)));
TOUPPER_STRING(allocate.mode_name, 8);
ascii_to_ebcdic_field(allocate.mode_name,
sizeof(allocate.mode_name));
APPC((ULONG) (ALLOCATE far *) ptr_allocate); /* Issue the verb */
if (allocate.primary_rc != AP_OK) {
write_error(
"\t OS/2 Sense Data: %08lX\n", SWAP4(allocate.sense_data));
}
} else { /* Save the returned tp_id */
return (tp_started.primary_rc);
}
CLEAR_VCB(tp_ended); /* Zero the verb control block */
tp_ended.opcode = AP_TP_ENDED; /* Set the verb opcode */
/* Set the tp_id */
memcpy (tp_ended.tp_id, tp_started.tp_id, sizeof(tp_ended.tp_id));
tp_ended.type = AP_SOFT; /* type: AP_HARD or AP_SOFT */
APPC((ULONG) (TP_ENDED far *) ptr_tp_ended); /* Issue the verb. */
}
int
parse_destination(char * in_string,
char * plu_alias,
char * fqplu_name)
/*
* This procedure is used by cpicerr_os2_appc_allocate verb
*/
{
if (strchr(in_string, '.') != NULL) {
if (in_string[0] == '.') {
in_string++;
}
strcpy(fqplu_name, in_string);
plu_alias[0] = '\0';
} else {
strcpy(plu_alias, in_string);
fqplu_name[0] = '\0';
}
return 0;
}
#endif