Conference azur::mcc

4786.0. "'notify requests' -> 'show details'" by TAVIS::ORNA () Wed Mar 31 1993 08:39

Hello,

We are developing an AM on an ULTRIX configuration.
When we get an event, we want to operate the 'show details'
options in the IM in the 'notify requests' window.
We tried it with 1 attribute and it worked ok, but when
we tried it with 2 attributes, it put the content of the
second attribute in the field of the first and the content
of the first attribute in the second field in the 'show details'
window.


This is the sources of the send_event
-------------------------------------

1)  This file is the subroutine which create the ILV buffer
    to be sent to the event_put
--------------------------------------

#include <string.h>
#include <mcc_descrip.h>
#include <mcc_interface_def.h>    /*  MCC Interface Defintions File */
#include <mcc_vea_def.h>          /*  MCC verb, entity, attrib constants */
#include <mcc_msg.h>              /*  MCC message definitions file */
#include "mcc_exchange_types.h"
#include "mcc_desframe.h"         /*  MCC Design Framework */
#include "mcc_exchange.h"         /*  General EXCHANGE Header File */
#include "mcc_exchange_01.h"      /*  General EXCHANGE Header File */
#include "mcc_show_exchange.h"    /*  Show directive EXCHANGE Header */

/******************************************************************/
/* Routine : mcc_exchange_send_message				  */
/* -----------------------------------				  */
/*								  */
/* The routine send get message form the EXCHANGE and send it to  */
/* to DECMCC							  */
/* DECMCC will send alarm to user				  */
/*								  */
/* INPUT PARAMETERS :						  */
/* ------------------						  */
/*	entity_spec : contains the fully specified entity and	  */
/*		      child entity instances .			  */
/* 	event_partiton :					  */
/*		      The event patition code   		  */
/*      event_code :						  */
/*		      The code event report                       */
/*	event_first_attr : Contains the event first attr string.  */
/*	event_second_attr : Contains the event second attr string.*/
/*	event_third_attr : Contains the event third attr string.  */
/******************************************************************/
MCC_T_CVR mcc_exchange_send_message(entity_spec,
                                    event_partiton, 
                                    event_code,
                                    entity_name,
                                    event_first_attr,
                                    event_second_attr ,
                                    event_third_attr)

MCC_A_AES entity_spec;
MCC_T_UNSLONG event_partiton;
MCC_T_UNSLONG event_code;
char *entity_name ,
     *event_first_attr ,
     *event_second_attr ,
     *event_third_attr ;
{
   MCC_T_Descriptor instance ,
                    first_descriptor ,
                    second_descriptor ,
                    third_descriptor ,
                    event_data ,
                    *time ;
   MCC_T_CVR status = MCC_S_NORMAL ;
   MCC_T_UNSLONG arg_event_report = MCC_K_ARG_EVENT_REPORT ;
   unsigned long type = MCC_K_DT_BIN_ABS_TIM ,
                 next_id ,
                 ilv_list_mode = MCC_K_ILV_LIST_VALUE ;
   struct MCC_R_ILV_CONTEXT    ctx;
   char                        event_report_buffer[128];

/*   event_data.mcc_w_maxstrlen = 4000 ;
   event_data.mcc_w_curlen    = 0 ;
   event_data.mcc_b_dtype     = DSC_K_DTYPE_T ;
   event_data.mcc_b_class     = DSC_K_CLASS_S ;
   event_data.mcc_b_flags     = 0 ;
   event_data.mcc_b_ver       = MCC_K_VER_DESCRIPTOR ;
   event_data.mcc_l_dt        = MCC_K_DT_ILV ;
   event_data.mcc_l_id        = event_code ;
   event_data.mcc_a_link      = MCC_K_NULL_PTR ;
   event_data.mcc_a_pointer   = (unsigned char *) mcc_malloc(4000) ;
   if ( event_data.mcc_a_pointer == NULL )
     status = MCC_S_INSVIRMEM ; */

   if ( event_first_attr[0] != NULL )
   {
      event_data.mcc_a_pointer   = (unsigned char *)event_first_attr  ;
      event_data.mcc_w_maxstrlen = 500 ;
      event_data.mcc_w_curlen    = strlen (event_first_attr)  ;
      event_data.mcc_b_dtype     = 0 ;
      event_data.mcc_b_class     = DSC_K_CLASS_S ;
      event_data.mcc_b_flags     = 0 ;
      event_data.mcc_b_ver       = MCC_K_VER_DESCRIPTOR ;
      event_data.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      event_data.mcc_a_link      = MCC_K_NULL_PTR ;
   }

   if ( event_second_attr[0] != NULL )
   {
      second_descriptor.mcc_a_pointer   = (unsigned char *)event_second_attr  ;
      second_descriptor.mcc_w_maxstrlen = 500 ;
      second_descriptor.mcc_w_curlen    = strlen (event_second_attr)  ;
      second_descriptor.mcc_b_dtype     = 0 ;
      second_descriptor.mcc_b_class     = DSC_K_CLASS_S ;
      second_descriptor.mcc_b_flags     = 0 ;
      second_descriptor.mcc_b_ver       = MCC_K_VER_DESCRIPTOR ;
      second_descriptor.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      second_descriptor.mcc_a_link      = MCC_K_NULL_PTR ;
   }

   if ( event_third_attr[0] != NULL )
   {
      third_descriptor.mcc_a_pointer   = (unsigned char *)event_third_attr  ;
      third_descriptor.mcc_w_maxstrlen = 500 ;
      third_descriptor.mcc_w_curlen    = strlen (event_third_attr)  ;
      third_descriptor.mcc_b_dtype     = 0 ;
      third_descriptor.mcc_b_class     = DSC_K_CLASS_S ;
      third_descriptor.mcc_b_flags     = 0 ;
      third_descriptor.mcc_b_ver       = MCC_K_VER_DESCRIPTOR ;
      third_descriptor.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      third_descriptor.mcc_a_link      = MCC_K_NULL_PTR ;
   }

   switch ( event_code )
   {
   /*case MCC_K_LINKSET_UP :
      first_descriptor.mcc_l_id      = MCC_K_LINKSET_NAME_U_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_NAME_U_rep ;
      break ;
   case MCC_K_LINKSET_DOWN :
      first_descriptor.mcc_l_id      = MCC_K_LINKSET_NAME_D_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_NAME_D_rep ;
      break ; */
   case MCC_K_LINK_UP :
      event_data.mcc_l_id      = MCC_K_LINK_NAME_U_rep ;
      second_descriptor.mcc_l_id     = MCC_K_SWITCH_NAME_U_rep ;
      break ;
   case MCC_K_LINK_DOWN :
      event_data.mcc_l_id      = MCC_K_LINK_NAME_D_rep ;
      second_descriptor.mcc_l_id     = MCC_K_SWITCH_NAME_D_rep ;
      third_descriptor.mcc_l_id      = MCC_K_REASON_TEXT_rep ;
      break ;
   case MCC_K_CCSM_UP :
      event_data.mcc_l_id      = MCC_K_CCSM_NAME_U_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_NAME_UP_rep ;
      break ;
   case MCC_K_CCSM_DOWN :
      event_data.mcc_l_id      = MCC_K_CCSM_NAME_D_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_NAME_DOWN_rep ;
      break ;
   case MCC_K_N7SACE_UP :
      event_data.mcc_l_id      = MCC_K_N7SACE_NAME_U_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_N_UP_rep ;
      break ;
   case MCC_K_N7SACE_DOWN :
      event_data.mcc_l_id      = MCC_K_N7SACE_NAME_D_rep ;
      second_descriptor.mcc_l_id     = MCC_K_EXCHANGE_N_DOWN_rep ;
      break ;
   case MCC_K_COMMUNICATION_UP :
      event_data.mcc_l_id      = MCC_K_SWITCH_NAME_UP_rep ;
      second_descriptor.mcc_l_id      = 0 ;
      break ;
   case MCC_K_COMMUNICATION_DOWN :
      event_data.mcc_l_id      = MCC_K_SWITCH_NAME_DOWN_rep ;
      second_descriptor.mcc_l_id      = 0 ;
      break ;
   }
	
   status = mcc_time_create(&time,&type,0,0) ;
   if (  BAD(status)  )
   {
      printf("error from mcc_time_create %d\n",status);
      return(status) ;
   }

   status = mcc_time_get_current(time) ;
   if (  BAD(status)  )
   {
      printf("error from mcc_time_get_current %d\n",status);
      return(status) ;
   }
   
   status = mcc_ilv_put_param_begin(&ctx , &event_data) ;

/*   if ( (GOOD(status)) && 
         (event_data.mcc_l_id != 0) && 
         ( event_first_attr[0] != NULL) )
   {
      status = mcc_ilv_put( &ctx,
                            &first_descriptor,
                            MCC_K_NULL_PTR );
   } */

   if ( (GOOD(status)) && 
         (second_descriptor.mcc_l_id != 0) && 
         ( event_second_attr[0] != NULL) )
   {
      status = mcc_ilv_put( &ctx,
                            &second_descriptor,
                            MCC_K_NULL_PTR );
   }

   if ( (GOOD(status)) && 
         ( event_third_attr[0] != NULL) )
   {
      status = mcc_ilv_put( &ctx,
                            &third_descriptor,
                            MCC_K_NULL_PTR );
   }

   /*
    *  ---------------------- End Encoding the Reply -----------------------
    *  All done building the Reply Argument
    *    o End the Construction
    *    o End the Parameter List
    */

   if (GOOD(status))
      status = mcc_ilv_put_param_end( &ctx,
                                      &event_data );
                                                             
   if (GOOD(status))
      status = mcc_event_put(entity_spec,
			     &event_partiton,
			     &event_code,
			     &event_data,
			     time);
   if (  BAD(status)  )
   {
      printf("error from mcc_event_put %d\n",status);
      return(status) ;
   }
   return(status) ;

----------------------------------------------------------

2) This file contains the main which call the subroutine

#include <string.h>
#include <mcc_descrip.h>
#include <mcc_interface_def.h>    /*  MCC Interface Defintions File */
#include <mcc_vea_def.h>          /*  MCC verb, entity, attrib constants */
#include <mcc_msg.h>              /*  MCC message definitions file */
#include "mcc_exchange_types.h"
#include "mcc_desframe.h"         /*  MCC Design Framework */
#include "mcc_exchange.h"         /*  General EXCHANGE Header File */
#include "mcc_exchange_01.h"      /*  General EXCHANGE Header File */
#include "mcc_show_exchange.h"    /*  Show directive EXCHANGE Header */
#include "mcc_exchange_mir_calls.h"

#define BLANK 32
CACHE cache ;

char *p_exchange_g_mir_directory = EXCHANGE_K_MIR_LOCATION ;
char *p_exchange_g_mir_instance = EXCHANGE_K_MIR_INSTANCE_NAME;
char *p_exchange_g_mir_attribute = EXCHANGE_K_MIR_ATTRIBUTE_NAME ;
char *p_exchange_g_mir_lock = EXCHANGE_K_MIR_LOCK_NAME ;

MCC_T_CVR mcc_exchange_send_message() ;

mcc_xmm_log(fake)
int fake;
{
    return(0);
}

main(int argc , char *argv[])
{
  
   MCC_A_AES entity = MCC_K_NULL_PTR ;
   MCC_T_UNSLONG event_partition = MCC_K_PRT_CONFIGURATION_EVENTS ,
                 buffer ,
                 event_code ;
   unsigned long attribute ;
   MCC_T_CVR status ;
   MCC_T_Descriptor event_report ,
                    linkset_report ,
                    link_report ,
                    board_report ;
   char entity_name[404] ,
        linkset_name[404] ,
        link_name[404] ,
        board_name[404] ,
        *ptr ,
        *event_first_attr ,
        *event_third_attr ,
        *event_second_attr ;
   void print_message() ;
   MCC_T_CVR dns_status ;
   MCC_T_FullName fullname ;
   MCC_T_Unsigned16 length ,
                    f_length ;
   struct EXLIB_R_MIR_CONTEXT  *p_mir_context  = MCC_K_NULL_PTR ;
   MCC_T_Unsigned32 class ,
                    wild_type = MCC_K_AES_NOT_WILD ;

   if ( argc != 6 )
   {
      print_message() ;
      exit(1) ;
   }

   mcc_fw_init();

   strcpy(entity_name , argv[1] );
   printf("entity name is %s\n",entity_name) ;
   event_code = atoi(argv[2]) ;
   event_first_attr = argv[3];
   event_second_attr = argv[4];
   event_third_attr = argv[5];
   if ( (ptr=strstr(entity_name," ")) != NULL )
   {
      *ptr = NULL;
      ptr+= strlen(" ") ;
      if ( *ptr == 'L' )
      {
         ptr += 2 ;
         strcpy(linkset_name,ptr);
         if ( (ptr=strstr(ptr," ")) != NULL)
         {
            *ptr = NULL;
            ptr+= strlen(" ") ;
            strcpy(link_name,ptr);
         }
         else
            link_name[0] = NULL ;
      }
      else
      {
         linkset_name[0] = NULL ;
         ptr += 2 ;
         strcpy(board_name,ptr);
      }
   }
   else
   {
      board_name[0] = NULL ;
      linkset_name[0] = NULL ;
      link_name[0] = NULL ;
   }

   length = strlen (entity_name) ;

   status = mcc_dns_opaque_fullname(entity_name,&length,fullname,
                                    &f_length,&dns_status) ;
   if (  BAD(status)  )
   {
     printf("error from mcc_dns_opaque_fullname %d\n",status);
     exit(1);
   }

   event_report.mcc_w_maxstrlen = sizeof(MCC_T_FullName) ;
   event_report.mcc_w_curlen    = f_length ;
   event_report.mcc_b_dtype     = DSC_K_DTYPE_T;
   event_report.mcc_b_class     = DSC_K_CLASS_S;
   event_report.mcc_b_flags     = 0;
   event_report.mcc_b_ver       = MCC_K_VER_DESCRIPTOR;
   event_report.mcc_a_link      = MCC_K_NULL_PTR;
   event_report.mcc_a_pointer   = (unsigned char *) fullname ;
   event_report.mcc_l_id        = MCC_K_EXCHANGE_NAME;
   event_report.mcc_l_dt        = MCC_K_DT_FULL_NAME;
   class = MCC_K_CLASS_EXCHANGE ;

   status = mcc_aes_create ( &entity, &class ,
                             &event_report , &wild_type );

   if ( BAD(status)  )
   {
      printf("error %d in board mcc_aes_create\n",status);
      exit(1);
   }

   if ( linkset_name[0] != NULL )
   {
      ptr = strchr(linkset_name,BLANK );
      if ( ptr != NULL )
         *ptr = NULL ;
      linkset_report.mcc_w_maxstrlen = 500 ;
      linkset_report.mcc_w_curlen    = strlen(linkset_name) ;
      linkset_report.mcc_b_dtype     = DSC_K_DTYPE_T;
      linkset_report.mcc_b_class     = DSC_K_CLASS_S;
      linkset_report.mcc_b_flags     = 0;
      linkset_report.mcc_b_ver       = MCC_K_VER_DESCRIPTOR;
      linkset_report.mcc_a_link      = MCC_K_NULL_PTR;
      linkset_report.mcc_a_pointer   = (unsigned char *) linkset_name ;
      linkset_report.mcc_l_id        = MCC_K_LINKSET_NAME;
      linkset_report.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      class = MCC_K_CLASS_LINKSET ;
      status = mcc_aes_create ( &entity, &class ,
                                &linkset_report , &wild_type );
      if ( BAD(status)  )
      {
         printf("error %d in linkset mcc_aes_create\n",status);
         exit(1);
      }
   }

   if ( link_name[0] != NULL )
   {
      link_report.mcc_w_maxstrlen = 500 ;
      link_report.mcc_w_curlen    = strlen(link_name) ;
      link_report.mcc_b_dtype     = DSC_K_DTYPE_T;
      link_report.mcc_b_class     = DSC_K_CLASS_S;
      link_report.mcc_b_flags     = 0;
      link_report.mcc_b_ver       = MCC_K_VER_DESCRIPTOR;
      link_report.mcc_a_link      = MCC_K_NULL_PTR;
      link_report.mcc_a_pointer   = (unsigned char *) link_name ;
      link_report.mcc_l_id        = MCC_K_LINK_NAME;
      link_report.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      class = MCC_K_CLASS_LINK ;
      status = mcc_aes_create ( &entity, &class ,
                                &link_report , &wild_type );
      if ( BAD(status)  )
      {
         printf("error %d in link mcc_aes_create\n",status);
         exit(1);
      }
   }

   if ( board_name[0] != NULL )
   {
      board_report.mcc_w_maxstrlen = 500 ;
      board_report.mcc_w_curlen    = strlen(board_name) ;
      board_report.mcc_b_dtype     = DSC_K_DTYPE_T;
      board_report.mcc_b_class     = DSC_K_CLASS_S;
      board_report.mcc_b_flags     = 0;
      board_report.mcc_b_ver       = MCC_K_VER_DESCRIPTOR;
      board_report.mcc_a_link      = MCC_K_NULL_PTR;
      board_report.mcc_a_pointer   = (unsigned char *) board_name ;
      board_report.mcc_l_id        = MCC_K_BOARD_NAME;
      board_report.mcc_l_dt        = MCC_K_DT_LATIN1STRING ;
      class = MCC_K_CLASS_BOARD ;
      status = mcc_aes_create ( &entity, &class ,
                                &board_report , &wild_type );
      if ( BAD(status)  )
      {
         printf("error %d in board mcc_aes_create\n",status);
         exit(1);
      }
   }

   switch ( event_code )
   {
   case MCC_K_LINK_UP :
      attribute = MCC_K_LINK_STATE ;
      buffer = 1 ;
      break ;
   case MCC_K_LINK_DOWN :
      attribute = MCC_K_LINK_STATE ;
      buffer = 0 ;
      break ;
   case MCC_K_CCSM_UP :
      attribute = MCC_K_BOARD_STATE ;
      buffer = 1 ;
      break ;
   case MCC_K_CCSM_DOWN :
      attribute = MCC_K_BOARD_STATE ;
      buffer = 0 ;
      break ;
   case MCC_K_N7SACE_UP :
      attribute = MCC_K_BOARD_STATE ;
      buffer = 1 ;
      break ;
   case MCC_K_N7SACE_DOWN :
      attribute = MCC_K_BOARD_STATE ;
      buffer = 0 ;
      break ;
   case MCC_K_COMMUNICATION_UP :
      attribute = MCC_K_EXCHANGE_STATE ;
      buffer = 1 ;
      break ;
   case MCC_K_COMMUNICATION_DOWN :
      attribute = MCC_K_EXCHANGE_STATE ;
      buffer = 0 ;
      break ;
   }

   if ( GOOD(status) )
   {
      status = exlib_mir_open( p_exchange_g_mir_directory,
                               p_exchange_g_mir_instance,
                               p_exchange_g_mir_attribute,
                               p_exchange_g_mir_lock,
                               EXCHANGE_K_MIR_ATTR_SIZE,
                               MCC_K_PRT_STATUS,
                               &p_mir_context );

      if ( status == MCC_S_REPOSEXIST )
         status = MCC_S_NORMAL;
      else
      {
         /* error during open data-base    */
         printf("error during open data-base\n");
         exit(1);
      }
   }

   /* ---- Put the status attribute into MIR ---- */
   /*************************************************/
   if ( GOOD(status) )
   {
      status = exlib_write_status( entity,
                                   p_mir_context,
                                   attribute ,
                                   buffer );
      printf("status from exlib_write_status %d\n",status);
   }

   if ( GOOD(status) )
      status = mcc_exchange_send_message ( entity,
                                           event_partition,
                                           event_code,
                                           entity_name,
                                           event_first_attr ,
                                           event_second_attr ,
                                           event_third_attr);

   printf("status from send_message %d \n",status);

}

void print_message()
{

   printf("Use this program as followed:\n") ;
   printf("send_event entity_name event_id event_first_attr event_second_attr event_third_attr where\n");
   printf("entity_name \"exchange_id [L linkset_id/B board_id] [link_id]\"\n");
   printf("event_id 3 - linkup , 4 - linkdown\n");
   printf("         5 - ccsmup , 6 - ccsmdown\n");
   printf("         7 - n7saceup , 8 - n7sacedown\n");
   printf("         9 - commup , 10 - commdown\n");
   printf("event_first_attr 'value of the argument for the event'\n");
   printf("event_second_attr 'value of the argument for the event'\n");
   printf("event_third_attr 'value of the argument for the event only for linkdown otherwise null string'\n");

   return;
}



+++++++++++++++++++++++++++++++++++++++++++++++++++++

Can someone help and see what the problem is?

Thanks,
Orna.