mmsaevn.c

ICCP Toolkit 是在 Tru64下开发Tase.2通信协议的开发包

  if (!get_chan (&chan))
    {
    (*menu_set_fun) ();
    return;
    }

  if (!get_as_req_info (&req_info))	/* if got all required param	*/
    {
    if (! mp_getas (chan,&req_info))
      print_req_error ();

    if (num_reps)			/* if this an auto repeat -	*/
      {
      if (start_cont ())		/* wait for 1st to complete	*/
	return;
      num_outstanding = 1;
      while (rep_count < num_reps)	/* if enough done -		*/
	{
	if (! mp_getas (chan, &req_info))
	  break;
	num_outstanding++;
	if (cont_serve ())			/* if user hit a key	*/
	  return;
	}
      cont_done ();			/* display results		*/
      }
    }

  (*menu_set_fun) ();
#endif
  }

/************************************************************************/
/*			do_getaes					*/
/* create and send a get alarm enrollment summary request 		*/
/************************************************************************/

ST_VOID do_getaes (ST_VOID)
  {
#if MMS_GETAES_EN & REQ_EN

GETAES_REQ_INFO req_info;
ST_INT chan;

  if (!get_chan (&chan))
    {
    (*menu_set_fun) ();
    return;
    }

  if (!get_as_req_info ((GETAS_REQ_INFO *)&req_info))
    {
    if (! mp_getaes (chan,&req_info))
      print_req_error ();
  
    if (num_reps)			/* if this an auto repeat -	*/
      {
      if (start_cont ())		/* wait for 1st to complete	*/
        return;
      num_outstanding = 1;
      while (rep_count < num_reps)	/* if enough done -		*/
       {
       if (! mp_getaes (chan, &req_info))
         break;
       num_outstanding++;
       if (cont_serve ())			/* if user hit a key	*/
         return;
       }
       cont_done ();			/* display results		*/
      }
    }  
  (*menu_set_fun) ();
#endif
  }

/************************************************************************/
/*			 get_as_req_info 				*/
/************************************************************************/

ST_RET get_as_req_info (GETAS_REQ_INFO *req_info)
  {
ST_INT num;

  req_info->enroll_only = (ST_BOOLEAN) ask (" Enrollments Only = TRUE (Y) ",1);
  req_info->act_alarms_only = (ST_BOOLEAN) ask (" Active Alarms Only = TRUE (Y) ",1);

  printf ("   (0:not acked, 1:acked, 2:all)\n Enter Acknowledgement Filter (default = 0) : ");
  req_info->ack_filter = 0;
  intget (&num);
  if ((num >= 0) && (num <= 2))
    req_info->ack_filter = num;

  printf (" Enter Most Severe Filter (default = 0) : ");
  req_info->most_sev_filter = 0;
  if (intget (&num))
    req_info->most_sev_filter = (ST_UCHAR) num;

  printf (" Enter Least Severe Filter (default = 127) : ");
  req_info->least_sev_filter = 127;
  if (intget (&num))
    req_info->least_sev_filter = (ST_UCHAR) num;

  printf (" Enter Continue After Name (O) : \n");
  if (get_objname (&req_info->ca_name))
    req_info->ca_pres = SD_TRUE;
  else
    req_info->ca_pres = SD_FALSE;

  return (SD_SUCCESS);
  }

/************************************************************************/
/************************************************************************/
/* Common user input routines for event management.			*/
/************************************************************************/
/*			get_evtime					*/
/* get an event time from operator					*/
/************************************************************************/

ST_BOOLEAN get_evtime (EVENT_TIME *info)
  {
ST_INT num;
ST_LONG big;

  printf ("   (0:Time of Day, 1:Time Sequence Id, 2:Undefined)");
  printf ("\n Enter Event Time Type (default = 2) : ");
  info->evtime_tag = 2;
  if (intget (&num))
    {
    if ((num >= 0) && (num <= 2))
      info->evtime_tag = num;
    }

  switch (info->evtime_tag)
    {
    case  (0) :
      info->evtime.time_of_day.form = MMS_BTOD6;
      info->evtime.time_of_day.ms = 12345;
      info->evtime.time_of_day.day = 86399999;
      break;

    case  (1) :
      printf (" Enter Time Sequence Id : ");
      info->evtime.time_seq_id = 0;
      if (longget (&big))
	info->evtime.time_seq_id = (ST_UINT32) big;
      break;

    case  (2) :
      break;
    }
  return (SD_TRUE);
  }

/************************************************************************/
/*			get_modifier					*/
/************************************************************************/

ST_BOOLEAN get_modifier (MODIFIER *mod_ptr)
  {
ST_BOOLEAN data_entered;
ST_INT num;
ST_LONG	big;
ST_CHAR	temp [100];

  printf ("   (0:attach to event condition, 1:attach to semaphore");
  printf ("\n Enter Modifier Choice (0-1) (R) : ");
  if (data_entered = intget (&num))
    {
    switch (num)
      {
      case  (0) :			/* attach to event condition	*/
        mod_ptr->modifier_tag = 0;
        printf (" Enter Event Enrollment Name (R) : \n");
        data_entered = get_objname (&mod_ptr->mod.atec.evenroll_name);
	if (data_entered)
	  {
          printf (" Enter Event Condition Name (R) : \n");
	  data_entered = get_objname (&mod_ptr->mod.atec.evcon_name);
	  }
	if (data_entered)
          {  
	  mod_ptr->mod.atec.causing_transitions = 0x00;
          printf (" Enter Causing Transitions : (default = no) \n");
          if (ask ("   Idle to Disabled   (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x01;
          if (ask ("   Active to Disabled (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x02;
          if (ask ("   Disabled to Idle   (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x04;
          if (ask ("   Active to Idle     (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x08;
          if (ask ("   Disabled to Active (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x10;
          if (ask ("   Idle to Active     (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x20;
          if (ask ("   Any to Deleted     (y/n) : ", 0))
            mod_ptr->mod.atec.causing_transitions |= 0x40;
	  }
	if (data_entered)
          {  
          printf (" Enter Acceptable Delay : (O) ");
          mod_ptr->mod.atec.acc_delay_pres = SD_FALSE;
      	  if (longget (&big))
	    {
            mod_ptr->mod.atec.acc_delay_pres = SD_TRUE;
            mod_ptr->mod.atec.acc_delay = (ST_UINT32) big;
            }
	  }
        break;

      case  (1) :			/* attach to semaphore		*/
        mod_ptr->modifier_tag = 1;
        printf (" Enter Semaphore Name (R) : \n");
        data_entered = get_objname (&mod_ptr->mod.atsem.sem_name);
        if (data_entered)
          {
          printf (" Enter Named Token : (O) ");
          if (strget (temp))
            {
            temp [MAX_IDENT_LEN] = '\x00';
            mod_ptr->mod.atsem.named_token_pres = SD_TRUE;
            strcpy (mod_ptr->mod.atsem.named_token,temp);
            }
          else
            mod_ptr->mod.atsem.named_token_pres = SD_FALSE;
	  }
        if (data_entered)
          {
          mod_ptr->mod.atsem.priority = 64;
          printf (" Enter Priority (0-255) : (R) (default = 64)");
          if (intget (&num))
            {
            if ((num >= 0) && (num <= 255))
              mod_ptr->mod.atsem.priority = (ST_UCHAR) num;
            }
	  }
	if (data_entered)
          {  
          printf (" Enter Acceptable Delay : (O) ");
          mod_ptr->mod.atsem.acc_delay_pres = SD_FALSE;
      	  if (longget (&big))
	    {
            mod_ptr->mod.atsem.acc_delay_pres = SD_TRUE;
            mod_ptr->mod.atsem.acc_delay = (ST_UINT32) big;
            }
	  }
	if (data_entered)
          {  
          printf (" Enter Control Timeout : (O) ");
          mod_ptr->mod.atsem.ctrl_timeout_pres = SD_FALSE;
      	  if (longget (&big))
	    {
            mod_ptr->mod.atsem.ctrl_timeout_pres = SD_TRUE;
            mod_ptr->mod.atsem.ctrl_timeout = (ST_UINT32) big;
            }
	  }
	if (data_entered)
          {  
          printf (" Abort on Timeout : (y/n) (O) ");
          mod_ptr->mod.atsem.abrt_on_timeout_pres = SD_FALSE;
          if (strget (temp))
            {
            if ((temp[0] == 'y') || (temp[0] == 'Y'))
              {
              mod_ptr->mod.atsem.abrt_on_timeout_pres = SD_TRUE;
              mod_ptr->mod.atsem.abrt_on_timeout = SD_TRUE;
	      }
            if ((temp[0] == 'n') || (temp[0] == 'N'))
              {
              mod_ptr->mod.atsem.abrt_on_timeout_pres = SD_TRUE;
              mod_ptr->mod.atsem.abrt_on_timeout = SD_FALSE;
	      }
            }
	  }
	if (data_entered)
          {  
          if (ask (" Relinquish if Connection Lost ? : (default = yes) ",1))
            mod_ptr->mod.atsem.rel_conn_lost = SD_TRUE;
	  else
            mod_ptr->mod.atsem.rel_conn_lost = SD_FALSE;
	  }
        break;

      default   :
        data_entered = SD_FALSE;
        break;
      }
    }

  return (data_entered);
  }

/************************************************************************/
/*			get_service_err					*/
/************************************************************************/

ST_BOOLEAN get_service_err (ERR_INFO *err_ptr)
  {
ST_INT num, len;
ST_LONG	big;
ST_CHAR	temp [100];
ST_UCHAR  *inp_str;

  inp_str = (ST_UCHAR *)dest_buffer;

  printf (" Enter Error Class (0-13) (R) : ");
  err_ptr->eclass = 0;			/* default to VMD-State Error	*/
  if (intget (&num) && (num >= 0) && (num <= 13))
    err_ptr->eclass = num;  
  printf (" Enter Error Code (R) : ");
  err_ptr->code  = 0;			/* default to other 		*/
  if (intget (&num))
    err_ptr->code = num;  

  err_ptr->adtnl.mod_pos_pres = SD_FALSE;
  err_ptr->adtnl.info_pres    = SD_FALSE;
  err_ptr->adtnl.code_pres    = SD_FALSE;
  err_ptr->adtnl.descr_pres   = SD_FALSE;
  err_ptr->adtnl.ssi_pres     = SD_FALSE;

  printf (" Enter Additional code (O) : ");
  if (longget (&big))
    {
    err_ptr->adtnl.info_pres  = SD_TRUE;
    err_ptr->adtnl.code_pres  = SD_TRUE;
    err_ptr->adtnl.code       = big;
    }
  if (ask (" Send Additional Error Description (y/n) : ",0))
    {
    err_ptr->adtnl.info_pres  = SD_TRUE;
    err_ptr->adtnl.descr_pres = SD_TRUE;
    err_ptr->adtnl.descr      = "Error Description";
    }
  if (ask (" Send Service Specific Information (y/n) : ",0))
    {
    printf (" Enter Service Number (0-10) : ");
    num = 0;				/* default to obtainFile	*/
    intget (&num);
    switch (num)
      {
      case  8 :
        printf (" Enter Define Event Enrollment Name :\n");
        if (get_objname (&err_ptr->adtnl.ss_error_oname))
          {
          err_ptr->adtnl.info_pres = SD_TRUE;
          err_ptr->adtnl.ssi_pres  = SD_TRUE;
          err_ptr->adtnl.service   = 8;
          }
        break;
      case 10 :
        printf (" Enter Additional Service Error ASN.1 : ");
        if (len = input_hex ((ST_UCHAR *)temp, 100))
          {
          err_ptr->adtnl.ss_error_len  = len;
          memcpy (inp_str, temp, len);
          err_ptr->adtnl.ss_error_data = inp_str;
          inp_str += len;
          err_ptr->adtnl.info_pres = SD_TRUE;
          err_ptr->adtnl.ssi_pres  = SD_TRUE;
          err_ptr->adtnl.service   = 10;
          }
        break;
      default :
        if (((num >= 0) && (num <= 7)) || (num == 9))
          {
          err_ptr->adtnl.info_pres    = SD_TRUE;
          err_ptr->adtnl.ssi_pres     = SD_TRUE;
          err_ptr->adtnl.service      = num;
          err_ptr->adtnl.ss_error_val = 0;
          printf (" Enter Service Specific Error Value : ");
          if (intget (&num))
            err_ptr->adtnl.ss_error_val = num;
          }
      }
    }
  return (SD_TRUE);
  }

/************************************************************************/
/************************************************************************/
/* Common user output routines for event management.			*/
/************************************************************************/
/*			print_evtime					*/
/* This routine is used to print an event time. 			*/
/************************************************************************/


ST_VOID print_evtime (EVENT_TIME *evt_ptr)
  {

  switch (evt_ptr->evtime_tag)
    {
    case (0)  :
      print_evt_tod (&evt_ptr->evtime.time_of_day);
      break;

    case (1)  :
      printf ("\n   Time Sequence Id: %lu\n", evt_ptr->evtime.time_seq_id);
      break;

    case (2)  :
      printf ("Undefined\n");
      break;

    default   :
      printf ("Invalid Tag     : %d\n", evt_ptr->evtime_tag);
      break;
    }
  }

/************************************************************************/
/*			print_evt_tod					*/
/* This routine is used to print an event time time of day.		*/
/************************************************************************/

ST_VOID print_evt_tod (MMS_BTOD *info)
  {

  printf ("\n   Binary Time of Day : ");
  printf ("\n     Milliseconds since midnight: %ld", info->ms);
  if (info->form == MMS_BTOD6)
    printf ("\n     Days since 1/1/1984        : %ld", info->day);
  else
    printf ("\n     Date not present");
  }

/************************************************************************/
/*			print_modifier					*/
/* This routine is used to print a modifier.	 			*/
/************************************************************************/

ST_VOID print_modifier (MODIFIER *mod_ptr)
  {
  switch (mod_ptr->modifier_tag)
    {
    case (0)  :
      printf (", Attach to Event Condition \n");
      printf ("\n Event Enrollment Name   : ");
      print_objname (&(mod_ptr->mod.atec.evenroll_name));
      printf ("\n Event Condition Name    : ");
      print_objname (&(mod_ptr->mod.atec.evcon_name));
      printf ("\n Causing Transitions     : %02x",
      				mod_ptr->mod.atec.causing_transitions);
      printf ("\n   Idle to Disabled      : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x01)
        printf ("set ");
      else
        printf ("not set ");	        
      printf ("\n   Active to Disabled    : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x02)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n   Disabled to Idle      : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x04)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n   Active to Idle        : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x08)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n   Disabled to Active    : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x10)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n   Idle to Active        : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x20)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n   Any to Deleted        : ");
      if (mod_ptr->mod.atec.causing_transitions & 0x40)
        printf ("set ");
      else
        printf ("not set ");
      printf ("\n Acceptable Delay        : ");
      if (mod_ptr->mod.atec.acc_delay_pres)
        printf ("%ld ", mod_ptr->mod.atec.acc_delay);
      else
        printf ("Not Present ");
      break;

    case (1)  :
      printf (", Attach to Semaphore \n");
      printf ("\n Semaphore Name          : ");
      print_objname (&(mod_ptr->mod.atsem.sem_name));
      printf ("\n Named Token             : ");
      if (mod_ptr->mod.atsem.named_token_pres)
        printf ("%s ", mod_ptr->mod.atsem.named_token);
      else
        printf ("Not Present ");
      printf ("\n Priority                : %u",mod_ptr->mod.atsem.priority);
      printf ("\n Acceptable Delay        : ");
      if (mod_ptr->mod.atsem.acc_delay_pres)
        printf ("%ld ", mod_ptr->mod.atsem.acc_delay);
      else
        printf ("Not Present ");
      printf ("\n Control Timeout         : ");
      if (mod_ptr->mod.atsem.ctrl_timeout_pres)
        printf ("%ld ", mod_ptr->mod.atsem.ctrl_timeout);
      else
        printf ("Not Present ");
      printf ("\n Abort On Timeout        : ");
      if (mod_ptr->mod.atsem.abrt_on_timeout_pres)
        {
	if (mod_ptr->mod.atsem.abrt_on_timeout)
          printf ("YES ");
	else
          printf ("NO ");
	}
      else
        printf ("Not Present ");
      printf ("\n Relinquish if Conn Lost : ");
      if (mod_ptr->mod.atsem.rel_conn_lost)
        printf ("YES ");
      else
        printf ("NO ");
      break;

    default   :
      printf (", Invalid Tag : %d",mod_ptr->modifier_tag);
      break;
    }
  }