void
gcadm_resume( GCADM_RCB * rcb )
{
STATUS status;
GCADM_SCB * scb=rcb->scb;
if ( GCADM_global.gcadm_trace_level >= 4 )
TRdisplay( "%4d GCADM resume: entry\n", scb->aid );
/*
** resume GCA services
*/
MEfill(sizeof(scb->parms.gca_all_parm), 0, &scb->parms.gca_all_parm);
scb->parms.gca_all_parm.gca_assoc_id = scb->aid;
scb->parms.gca_all_parm.gca_completion = gcadm_complete;
scb->parms.gca_all_parm.gca_closure = (PTR)rcb;
gca_call( &scb->gca_cb, rcb->operation,
(GCA_PARMLIST *)&scb->parms,
GCA_ASYNC_FLAG | GCA_ALT_EXIT | GCA_RESUME,
(PTR)rcb, -1, &status);
if ( status != OK )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM resume: disassociate error: 0x%x\n",
scb->aid, status );
if ( rcb )
rcb->status = status;
}
return;
}
STATUS
gcn_testaddr( char *target, i4 direct, char *username )
{
GCA_RQ_PARMS request;
i4 count = 0;
STATUS status;
STATUS req_status;
MEfill( sizeof( request ), '\0', (PTR)&request );
request.gca_partner_name = target;
request.gca_modifiers = direct ? GCA_NO_XLATE : 0;
request.gca_user_name = username;
gca_call( &gcn_gca_cb, GCA_REQUEST, (GCA_PARMLIST *)&request,
GCA_SYNC_FLAG, NULL, -1, &status );
gcn_checkerr( "GCA_REQUEST", &status,
request.gca_status, &request.gca_os_status );
/*
** If we connected successfully, release the connection.
*/
if ( status == OK )
gcn_send( request.gca_assoc_id, GCA_RELEASE,
(char *)&count, sizeof( count ), TRUE );
/*
** Even failed GCA_REQUEST calls need to call GCA_DISASSOC.
*/
gcn_release( request.gca_assoc_id );
return( status );
}
STATUS
gcn_recv( i4 assoc_id, char *buff, i4 buff_len, bool formatted,
i4 *msg_type, i4 *msg_size, bool *eod, bool *eog )
{
GCA_RV_PARMS recv;
STATUS status;
MEfill( sizeof( recv ), 0, (PTR)&recv );
recv.gca_association_id = assoc_id;
recv.gca_flow_type_indicator = GCA_NORMAL;
recv.gca_modifiers = formatted ? GCA_FORMATTED : 0;
recv.gca_buffer = buff;
recv.gca_b_length = buff_len;
gca_call( &gcn_gca_cb, GCA_RECEIVE, (GCA_PARMLIST *)&recv,
GCA_SYNC_FLAG, NULL, GCN_RCV_TIMEOUT, &status );
gcn_checkerr("GCA_RECEIVE", &status, recv.gca_status, &recv.gca_os_status);
if ( status != OK ) return( status );
*msg_type = recv.gca_message_type;
*msg_size = recv.gca_d_length;
*eod = recv.gca_end_of_data;
*eog = recv.gca_end_of_group;
return( OK );
}
STATUS
gcn_fastselect( u_i4 oper_code, char *target )
{
GCA_RQ_PARMS request;
i4 assoc_no;
STATUS status;
STATUS tmp_stat;
MEfill( sizeof( request ), '\0', (PTR)&request );
request.gca_partner_name = target;
request.gca_modifiers = oper_code;
gca_call( &gcn_gca_cb, GCA_REQUEST, (GCA_PARMLIST *)&request,
GCA_SYNC_FLAG, NULL, (i4)(-1), &status );
if ( status == OK ) status = request.gca_status;
if ( status != E_GC0040_CS_OK )
{
gcn_checkerr( "GCA_REQUEST", &status,
request.gca_status, &request.gca_os_status);
}
gcn_release( request.gca_assoc_id );
return( status );
}
STATUS
gcn_request( char *gcn_host, i4 *assoc_no, i4 *protocol )
{
GCA_RQ_PARMS request;
STATUS status = OK;
char tbuff[ GC_HOSTNAME_MAX + 12 ];
char *target;
i4 len;
/*
** Prepare for GCA_REQUEST service call
*/
len = (gcn_host ? STlength( gcn_host ) + 2 : 0) + 10;
target = (len <= sizeof( tbuff ))
? tbuff : (char *)MEreqmem( 0, len, FALSE, NULL );
if ( ! target ) return( E_GC0013_ASSFL_MEM );
STprintf( target, "%s%s/IINMSVR",
gcn_host ? gcn_host : "", gcn_host ? "::" : "" );
MEfill( sizeof( request ), '\0', (PTR)&request );
request.gca_peer_protocol = GCA_PROTOCOL_LEVEL_63;
request.gca_partner_name = target;
/*
** Make GCA_REQUEST service call
*/
gca_call( &gcn_gca_cb, GCA_REQUEST, (GCA_PARMLIST *)&request,
GCA_SYNC_FLAG, NULL, GCN_RCV_TIMEOUT, &status );
gcn_checkerr( "GCA_REQUEST",
&status, request.gca_status, &request.gca_os_status );
if ( status != OK ) goto done;
if ( gcn_host && request.gca_peer_protocol < GCA_PROTOCOL_LEVEL_50 )
{
gcn_release( request.gca_assoc_id );
CL_CLEAR_ERR( &request.gca_os_status );
gcn_checkerr( "GCA_REQUEST",
&status, E_GC000A_INT_PROT_LVL, &request.gca_os_status );
goto done;
}
*assoc_no = request.gca_assoc_id;
*protocol = request.gca_peer_protocol;
done :
if ( target != tbuff ) MEfree( (PTR)target );
return( status );
}
STATUS
gcn_release( i4 assoc_no )
{
GCA_DA_PARMS disc;
STATUS status;
MEfill( sizeof( disc ), '\0', (PTR)&disc );
disc.gca_association_id = assoc_no;
gca_call( &gcn_gca_cb, GCA_DISASSOC, (GCA_PARMLIST *)&disc,
GCA_SYNC_FLAG, NULL, -1, &status );
gcn_checkerr("GCA_DISASSOC", &status, disc.gca_status, &disc.gca_os_status);
return( status );
}
STATUS
gcn_term( VOID )
{
GCA_TE_PARMS term;
STATUS status;
/*
** Make GCA_TERMINATE call.
*/
MEfill( sizeof( term ), 0, (PTR)&term );
gca_call( &gcn_gca_cb, GCA_TERMINATE, (GCA_PARMLIST *)&term,
GCA_SYNC_FLAG, NULL, -1, &status );
gcn_checkerr( "GCA_TERMINATE",
&status, term.gca_status, &term.gca_os_status);
return( status );
}
STATUS
gcn_init( VOID )
{
GCA_IN_PARMS init;
STATUS status;
MEfill( sizeof( init ), '\0', (PTR)&init );
init.gca_modifiers = GCA_API_VERSION_SPECD;
init.gca_api_version = GCA_API_LEVEL_5;
init.gca_local_protocol = GCA_PROTOCOL_LEVEL_63;
gca_call( &gcn_gca_cb, GCA_INITIATE, (GCA_PARMLIST *)&init,
GCA_SYNC_FLAG, NULL, -1, &status );
gcn_checkerr( "GCA_INITIATE",
&status, init.gca_status, &init.gca_os_status );
return( status );
}
STATUS
gcn_send( i4 assoc_id,
i4 msg_type, char *msg_buf, i4 msg_size, bool eod )
{
GCA_SD_PARMS send;
STATUS status;
MEfill( sizeof( send ), '\0', (PTR)&send );
send.gca_association_id = assoc_id;
send.gca_message_type = msg_type;
send.gca_modifiers = GCA_FORMATTED;
send.gca_buffer = msg_buf;
send.gca_msg_length = msg_size;
send.gca_end_of_data = eod;
gca_call( &gcn_gca_cb, GCA_SEND, (GCA_PARMLIST *)&send,
GCA_SYNC_FLAG, NULL, -1, &status );
gcn_checkerr( "GCA_SEND", &status, send.gca_status, &send.gca_os_status );
return( status );
}
void
gcadm_sm( GCADM_RCB *rcb )
{
u_i1 i, action;
GCADM_SCB *scb = rcb->scb;
STATUS status;
i4 save_aid;
if ( scb->sequence >= ADMS_CNT || rcb->event >= ADMI_CNT )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM sm: invalid %d %d \n",
scb->aid, scb->sequence, rcb->event);
scb->status = E_GC5005_INTERNAL_ERROR;
return;
}
gcadm_eval( rcb );
if ( scb->sequence >= ADMS_CNT || rcb->event >= ADMI_CNT ||
smt[ scb->sequence ][ rcb->event ].next >= ADMS_CNT ||
smt[ scb->sequence ][ rcb->event ].action >= ADMAS_CNT )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM sm: invalid %d %d \n",
scb->aid, scb->sequence, rcb->event);
gcadm_errlog ( E_GC5003_FSM_STATE );
return;
}
if ( GCADM_global.gcadm_trace_level >= 4 )
TRdisplay( "%4d GCADM sm: entry\n",scb->aid );
if ( GCADM_global.gcadm_trace_level >= 5 )
TRdisplay( "%4d GCADM sm: state %s event %s => %s\n", scb->aid,
states[ scb->sequence ], events[ rcb->event ],
states[ smt[ scb->sequence ][ rcb->event ].next ] );
action = smt[ scb->sequence ][ rcb->event ].action;
/*
** Make the state transition now
*/
scb->sequence = smt[ scb->sequence ][ rcb->event ].next;
save_aid = scb->aid;
for( i = 0; i < ADMA_MAX; i++ )
{
if ( GCADM_global.gcadm_trace_level >= 5 &&
act_seq[action][i] != ADMA_NOOP )
TRdisplay( "%4d GCADM sm: action %s, %p\n", save_aid,
actions[ act_seq[ action ][ i ] ], rcb );
switch( act_seq[ action ][ i ] )
{
case ADMA_NOOP : /* Do nothing, end of action sequence */
i = ADMA_MAX;
break;
case ADMA_SEND : /* issue GCA_SEND request */
MEfill(sizeof(scb->parms), 0, &scb->parms);
rcb->operation = GCA_SEND;
scb->parms.gca_sd_parm.gca_message_type = scb->msg_type;
scb->parms.gca_sd_parm.gca_end_of_data = TRUE;
scb->parms.gca_sd_parm.gca_buffer = scb->buffer;
scb->parms.gca_sd_parm.gca_msg_length = scb->buf_len;
scb->parms.gca_sd_parm.gca_association_id = scb->aid;
scb->parms.gca_sd_parm.gca_completion = gcadm_complete;
scb->parms.gca_sd_parm.gca_closure = (PTR)rcb;
if ( scb->msg_type == GCA_TUPLES )
scb->parms.gca_sd_parm.gca_descriptor = (PTR)(&scb->tdesc_buf);
gca_call( &scb->gca_cb, GCA_SEND,
(GCA_PARMLIST *)&scb->parms,
GCA_ASYNC_FLAG | GCA_ALT_EXIT,
(PTR)rcb, -1, &status);
if ( status != OK )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM sm: send error: 0x%x\n",
save_aid, status );
rcb->status = status;
rcb->event = ADMI_RQST_FAIL;
gcadm_event ( rcb );
}
break;
case ADMA_RECV : /* Issue GCA_RECEIVE request */
MEfill(sizeof(scb->parms), 0, &scb->parms);
rcb->operation = GCA_RECEIVE;
scb->parms.gca_rv_parm.gca_buffer = scb->buffer;
scb->parms.gca_rv_parm.gca_assoc_id = scb->aid;
scb->parms.gca_rv_parm.gca_b_length = GCADM_global.gcadm_buff_len;
scb->parms.gca_rv_parm.gca_flow_type_indicator = GCA_NORMAL;
scb->parms.gca_rv_parm.gca_completion = gcadm_complete;
scb->parms.gca_rv_parm.gca_closure = (PTR)rcb;
gca_call( &scb->gca_cb, GCA_RECEIVE,
(GCA_PARMLIST *)&scb->parms,
GCA_ASYNC_FLAG | GCA_ALT_EXIT,
(PTR)rcb, -1, &status);
if ( status != OK )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM sm: receive error: 0x%x\n",
save_aid, status );
rcb->status = status;
rcb->event = ADMI_RQST_FAIL;
gcadm_event ( rcb );
}
break;
case ADMA_DISA : /* Issue GCA_DISASSOC request */
/*
** Disassociate the client connection.
*/
rcb->operation = GCA_DISASSOC;
scb->admin_flag |= GCADM_DISC;
MEfill(sizeof(scb->parms.gca_da_parm), 0, &scb->parms.gca_da_parm);
scb->parms.gca_da_parm.gca_association_id = scb->aid;
scb->parms.gca_da_parm.gca_completion = gcadm_complete;
scb->parms.gca_da_parm.gca_closure = (PTR)rcb;
gca_call( &scb->gca_cb, GCA_DISASSOC,
(GCA_PARMLIST *)&scb->parms.gca_da_parm,
GCA_ASYNC_FLAG | GCA_ALT_EXIT,
(PTR)rcb, -1, &status);
if ( status != OK )
{
if ( GCADM_global.gcadm_trace_level >= 1 )
TRdisplay( "%4d GCADM sm: disassociate error: 0x%x\n",
save_aid, status );
rcb->status = status;
rcb->event = ADMI_RQST_FAIL;
gcadm_event ( rcb );
}
break;
case ADMA_ACPT : /* build gca_accept msg */
scb->msg_type = GCA_ACCEPT;
scb->buf_len = 0;
break;
case ADMA_QUERY : /* process query */
{
char *q_data;
i4 lang_id, q_modifier, gca_type, gca_prec;
/* parse received data to get query text */
/* save query len and text in scb */
q_data = (char *) scb->parms.gca_rv_parm.gca_data_area;
q_data += GCA_GETI4_MACRO( q_data, &lang_id );
q_data += GCA_GETI4_MACRO( q_data, &q_modifier );
q_data += GCA_GETI4_MACRO( q_data, &gca_type );
q_data += GCA_GETI4_MACRO( q_data, &gca_prec );
if ( gca_type == DB_QTXT_TYPE)
{
if ( q_modifier & GCA_COMP_MASK )
scb->admin_flag |= GCADM_COMP_MASK;
q_data += GCA_GETI4_MACRO( q_data, &scb->buf_len );
q_data += GCA_GETBUF_MACRO( q_data, scb->buf_len,
scb->buffer );
scb->status = OK;
}
break;
}
case ADMA_TUPL : /* build GCA_TUPLES msg */
{
GCADM_RSLT *rslt;
i4 fill_len, zero=0;
i2 i2_len;
GCA_TU_DATA *tu_data;
rslt = (GCADM_RSLT *) scb->rsltlst_entry;
scb->rsltlst_entry = (GCADM_RSLT *) rslt->rslt_q.q_next;
scb->msg_type = GCA_TUPLES;
tu_data = (GCA_TU_DATA *)scb->buffer;
if ( scb->admin_flag & GCADM_COMP_MASK )
scb->buf_len = rslt->rslt_len +2 ;
else
scb->buf_len = scb->row_len;
i2_len = (i2)rslt->rslt_len;
tu_data += GCA_PUTI2_MACRO( &i2_len, tu_data);
tu_data += GCA_PUTBUF_MACRO( rslt->rslt_text, rslt->rslt_len,
tu_data);
if ( ! ( scb->admin_flag & GCADM_COMP_MASK ))
{
fill_len = scb->row_len - rslt->rslt_len;
MEfill ( fill_len, 0, tu_data );
}
scb->row_count++;
break;
}
case ADMA_RESP : /* build gca_response msg */
scb->msg_type = GCA_RESPONSE;
scb->buf_len = gcadm_format_re_data( scb );
break;
case ADMA_RLSE : /* build gca_relese msg */
scb->msg_type = GCA_RELEASE;
scb->buf_len = gcadm_format_err_data
( scb->buffer, NULL, scb->status, 0, NULL );
break;
case ADMA_CALLBACK : /* request result call back */
{
GCADM_RQST_PARMS rqst_parms;
GCADM_CMPL_PARMS cmpl_parms;
scb->admin_flag |= GCADM_CALLBACK;
if ( scb->rqst_cb )
{
GCADM_RQST_FUNC rqst_cb = scb->rqst_cb;
rqst_parms.gcadm_scb = (PTR)scb;
rqst_parms.rqst_cb_parms = scb->rqst_cb_parms;
rqst_parms.length = scb->buf_len;
rqst_parms.request = scb->buffer;
rqst_parms.sess_status = scb->status;
scb->rqst_cb = NULL;
(rqst_cb)( &rqst_parms );
}
else if ( scb->rslt_cb )
{
GCADM_CMPL_FUNC rslt_cb = scb->rslt_cb;
cmpl_parms.gcadm_scb = (PTR)scb;
cmpl_parms.rslt_cb_parms = scb->rslt_cb_parms;
cmpl_parms.rslt_status = scb->status;
scb->rslt_cb = NULL;
(rslt_cb)( &cmpl_parms );
}
break;
}
case ADMA_FAIL : /* set failed status */
if ( rcb->status )
scb->status = rcb->status;
else
scb->status = FAIL;
break;
case ADMA_BAD_STAT : /* set status error */
scb->status = E_GC5008_INVALID_MSG_STATE;
break;
case ADMA_FREE_RCB : /* Free RCB */
gcadm_free_rcb( rcb );
rcb = NULL;
break;
case ADMA_FREE : /* Free SCB */
gcadm_free_rcb( rcb );
gcadm_free_scb( scb );
rcb = NULL;
scb = NULL;
break;
}
}
return;
}
STATUS
gcn_bedcheck( VOID )
{
GCA_FS_PARMS fast;
STATUS status;
CL_ERR_DESC sys_err;
char gcn_addr[ GCA_SERVER_ID_LNG + 1 ];
static char msg_buff[ GCA_FS_MAX_DATA ];
char obj_buffer [ 32 ];
char *p, *var;
i4 len, server_flags;
char gca_partner_name[] = "/IINMSVR";
/*
** We can bail out early if Name Server
** ID has not been globally registered.
*/
status = GCnsid( GC_FIND_NSID, gcn_addr, sizeof( gcn_addr ), &sys_err );
if ( status == GC_NM_SRVR_ID_ERR ) return( E_GC0126_GCN_NO_GCN );
/*
** Roll up GCM_GET message.
*/
p = msg_buff; /* point to start of message data */
p += sizeof( i4 ); /* bump past error_status */
p += sizeof( i4 ); /* bump past error_index */
p += sizeof( i4 ); /* bump past future[0] */
p += sizeof( i4 ); /* bump past future[1] */
p += gcm_put_int( p, -1 ); /* set client_perms */
p += gcm_put_int( p, 1 ); /* set row_count */
p += gcm_put_int( p, 1 ); /* set element_count */
p += gcm_put_str( p, GCA_MIB_CLIENT_FLAGS ); /* classid */
p += gcm_put_str( p, "" ); /* instance */
p += gcm_put_str( p, "" ); /* value */
p += gcm_put_int( p, 0 ); /* perms */
/*
** Issue GCA_FASTSELECT.
*/
MEfill( sizeof( fast ), '\0', (PTR)&fast );
fast.gca_partner_name = gca_partner_name;
fast.gca_modifiers = GCA_RQ_GCM;
fast.gca_peer_protocol = GCA_PROTOCOL_LEVEL_62;
fast.gca_buffer = msg_buff;
fast.gca_b_length = sizeof( msg_buff );
fast.gca_message_type = GCM_GETNEXT;
fast.gca_msg_length = p - msg_buff;
gca_call( &gcn_gca_cb, GCA_FASTSELECT, (GCA_PARMLIST *)&fast,
GCA_SYNC_FLAG, NULL, -1, &status );
if ( status == OK && fast.gca_status != OK ) status = fast.gca_status;
/*
** If we can't probe it, we'll just
** have to assume it is a GCN.
*/
if ( status == E_GC003F_PM_NOPERM )
status = OK;
else if ( status == OK )
{
/*
** Unroll GCM msg.
*/
p = msg_buff;
p += gcm_get_int( p, &status );
/*
** if GCM GET succeeded, test server flags.
*/
if ( status == OK )
{
p += sizeof( i4 ); /* bump past element_count */
p += sizeof( i4 ); /* bump past error_index */
p += sizeof( i4 ); /* bump past future[0] */
p += sizeof( i4 ); /* bump past future[1] */
p += sizeof( i4 ); /* bump past client_perms */
p += sizeof( i4 ); /* bump past row_count */
p += gcm_get_str( p, &var, &len ); /* skip classid */
p += gcm_get_str( p, &var, &len ); /* skip instance */
p += gcm_get_str( p, &var, &len ); /* get value */
MEcopy( var, len, obj_buffer );
obj_buffer[ len ] = '\0';
CVan( obj_buffer, &server_flags );
if ( ! (server_flags & GCA_RG_IINMSVR) )
status = E_GC0126_GCN_NO_GCN;
}
}
return( status );
}
