u_ivar.c

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

		/* compare lengths */
		if (ptptr->blocked_len <= unv->tptr->blocked_len)
		  {
                  vm_ptr->type = ptptr;
		  }
		else
		  { /* sorry req wants more than we have to give */
                  vm_ptr->result = ACC_RSLT_FAILURE;
                  vm_ptr->err_code = ARE_OBJ_ACC_UNSUPPORTED;
		  }
		}
	      else
	        {
                vm_ptr->result = ACC_RSLT_FAILURE;
                vm_ptr->err_code = ARE_OBJ_ACC_UNSUPPORTED;
	        }
	      }
	    else
	      {
              vm_ptr->result = ACC_RSLT_FAILURE;
              vm_ptr->err_code = ARE_INVAL_ADDR;
	      }
	      break;
	  case SYM_ADDR:
	    sscanf(vl_ptr->var_spec.vs.var_descr.address.addr.sym_addr,"%lx",&address);
	    if (unv = ms_find_unnamed_var(address))
              {
              vm_ptr->alt_acc_pres = 0;
              vm_ptr->result = ACC_RSLT_SUCCESS;
              vm_ptr->data_ptr = (ST_CHAR *) unv->address;
	      /* turn the req ASN.1 into a type and comp lens */
	      /* make up a new type name */
	      sprintf(typename,"%s%d","ttype",ttype_no);
	      ptptr = ms_add_named_type(&m_vmd_select->vmd_wide,
					typename,
		  			vl_ptr->var_spec.vs.var_descr.type.data,
		  			vl_ptr->var_spec.vs.var_descr.type.len);
              if (ptptr != NULL)
		{
		/* remember the type so we can delete it */
  	        ttypes[ttype_no] = ptptr;
		ttype_no++;
		/* compare lengths */
		if (ptptr->blocked_len <= unv->tptr->blocked_len)
		  {
                  vm_ptr->type = ptptr;
		  }
		else
		  { /* sorry req wants more than we have to give */
                  vm_ptr->result = ACC_RSLT_FAILURE;
                  vm_ptr->err_code = ARE_OBJ_ACC_UNSUPPORTED;
		  }
		}
	      else
	        {
                vm_ptr->result = ACC_RSLT_FAILURE;
                vm_ptr->err_code = ARE_OBJ_ACC_UNSUPPORTED;
	        }
	      }
	    else
	      {
              vm_ptr->result = ACC_RSLT_FAILURE;
              vm_ptr->err_code = ARE_INVAL_ADDR;
	      }
	    break;
	  default:
            vm_ptr->result = ACC_RSLT_FAILURE;
            vm_ptr->err_code = ARE_INVAL_ADDR;
	    break;
	  }
        break;
      default:	/* no scat-acc please */
        break;
      }
    } /* end for */

/* now we are ready to send the response - 				*/

  mv_read_response (req_info,num_rslt,vm_info);
  /* free up any temporary described types */
  for (i=0; i<ttype_no; i++)
    {
    ms_del_named_type(&m_vmd_select->vmd_wide,ttypes[i]->type_name);
    }
  chk_free (ttypes);  	

  chk_free (vm_info);
  }
#endif		/* NOT RD_AUTO_RESP */

#endif		/* MMS_READ_EN & RESP_EN */

/************************************************************************/
/* WRITE								*/
/************************************************************************/

#if MMS_WRITE_EN & RESP_EN

/* The defines below control how the indication will be handled		*/
#define WRITE_RESP_MODE		(MV_WRITE_RESP | WR_AUTO_RESP)

#define MV_WRITE_RESP		0x0001	/* use VM if possible		*/
#define EXTRACT_WRITE_DATA	0x0002	/* extract write data		*/
#define WR_AUTO_RESP  		0x0004	/* no user intervention req'd	*/

ST_VOID u_write_ind (MMSREQ_IND *req_info)
  {
register j;
ST_INT i;
WRITE_REQ_INFO	*req_ptr;
VAR_ACC_DATA	*data_ptr;
WRITE_RESP_INFO	*rsp_info;
WRITE_RESULT	*rslt_info;
VARIABLE_LIST    *vlist;
ST_BOOLEAN use_mp_resp;
#if (WRITE_RESP_MODE & EXTRACT_WRITE_DATA)
OBJECT_NAME *vobj;
OBJECT_NAME tobj;
NAMED_TYPE *type;
ST_RET err;
#endif

  req_ptr = (WRITE_REQ_INFO *) req_info->req_info_ptr;

/***** FIRST PRINT DEBUG INFORMATION IF ENABLED ************************/

i = WRITE_RESP_MODE;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Write");
    print_vaspec (&req_ptr->va_spec);
    data_ptr = req_ptr->va_data;
    printf ("\n Number of Data to Write : %d ", req_ptr->num_of_data);
    for (j = 0; j < req_ptr->num_of_data; j++)
      {
      printf ("\n   Write Data %d) ", j+1);
      list_bytes (data_ptr->data,data_ptr->len);
      data_ptr++;
      }
    }

/***** TRANSLATE WRITE DATA IF ENABLED *********************************/

#if (WRITE_RESP_MODE & EXTRACT_WRITE_DATA)
    printf ("\n Convert WRITE DATA to Local Format");
    printf ("\n Number of Write Data = %d ", req_ptr->num_of_data);
    for (j = 0; j < req_ptr->num_of_data; j++)
      {
      printf ("\n\nENTER TYPE of VARIABLE %d - ",j+1);
      if ((vobj = ms_extract_varname ((ST_CHAR *)req_ptr,WRITE,j)) != NULL)
	{
	printf ("having name %s",vobj->obj_name.vmd_spec);
	if (vobj->object_tag == 0)
	  printf (" (VMD-specific scope).\n");
	else if (vobj->object_tag == 1)
	  printf (" (domain = %s).\n",vobj->domain_id);
	else if (vobj->object_tag == 2)
	  printf (" (AA-specific scope).\n");
	}
      if (get_objname (&tobj) && 
	   (type = ms_find_named_type_obj (&tobj,req_info->chan)))
        {
	err = ms_extract_write_data (req_info,j,type,dest_buffer,SD_FALSE);
	if (!err)
	  {
          printf ("\n");
          print_arb_data (dest_buffer, type, SD_FALSE, SD_FALSE, NULL);
          }
        else
  	  printf ("\n Data Extract problem (error = %d) ",err);
	}
      else
        printf ("\n Could Not Find Type");
      }
#endif			/* end of EXTRACT #if */

/***** CREATE RESPONSE **************************************************/

/* create a default response in malloc'd buffer				*/

  rsp_info = (WRITE_RESP_INFO *) chk_malloc (sizeof(WRITE_RESP_INFO) +
                req_ptr->num_of_data * sizeof (WRITE_RESULT));
  rsp_info->num_of_result = req_ptr->num_of_data;
					/* point at first element	*/
  rslt_info = (WRITE_RESULT *) (rsp_info + 1);
  for (i = req_ptr->num_of_data; i ; --i)
    {
    rslt_info->resp_tag = ACC_RSLT_SUCCESS;  /* set all to success	*/
    rslt_info++;
    }

#if WRITE_RESP_MODE & WR_AUTO_RESP
#if WRITE_RESP_MODE & MV_WRITE_RESP
  use_mp_resp = SD_FALSE;
  if (!req_ptr->va_spec.var_acc_tag)	/* if list of variables		*/
    {					/* get pointer to var list	*/
    vlist = (VARIABLE_LIST *) (&req_ptr->va_spec + 1);
    for (i = 0; i < req_ptr->va_spec.num_of_variables; ++i)
      {
      if (vlist->var_spec.var_spec_tag)	/* if not named variable	*/
        {
        use_mp_resp = SD_TRUE;		/* VM won't do it		*/
  	break;
        }
      }
    }

  if (use_mp_resp)
    mp_write_resp (req_info, rsp_info);	/* send primitive response	*/
  else
    mv_write_resp (req_info);		/* let VM write responder do it */

#else					/* don't use VM responder  	*/
  mp_write_resp (req_info, rsp_info);	/* send primitive response	*/
#endif			/* end of MV_WRITE_RESP #endif */	 


#else					/* NOT AUTO RESPONSE  		*/

  rslt_info = (WRITE_RESULT *) (rsp_info + 1);
  if (req_ptr->num_of_data > 0)
    printf ("\n\n   (0-Failure, 1-Success)");
					/* get values for all variables */
  for (i = req_ptr->num_of_data; i ; --i)
    {
    ST_INT num;

    printf ("\n Enter response choice : (default = 1) ");
    if (intget (&num))
      {
      if (num == 0)
	{
	rslt_info->resp_tag = 0;
	rslt_info->failure  = 0;
	printf (" Enter failure code : (default = 0) ");
	if (intget (&num))
	  rslt_info->failure = num;
	}
      }
    rslt_info++;
    }
    mv_write_resp (req_info);		/* let VM write responder do it */

#endif			/* end of AUTO #if */

  
  indic_info_wait ();			/* allow user to see indic info */
  chk_free (rsp_info);		/* free the response info	*/
  }

#endif

/************************************************************************/
/* INFORMATION								*/
/************************************************************************/

#if MMS_INFO_EN & RESP_EN

#define USE_MV_INFO_RPT 	/* define to use the VM info report	*/

ST_VOID u_info_ind (MMSREQ_IND *req_info)
  {
INFO_REQ_INFO *req_ptr;
register j;
NAMED_TYPE *type;
ACCESS_RESULT *ar_ptr;
OBJECT_NAME *vobj;
OBJECT_NAME tobj;
ST_RET err;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Information Report");
    req_ptr = (INFO_REQ_INFO *) req_info->req_info_ptr;
    ar_ptr = req_ptr->acc_rslt_list;

#ifndef USE_MV_INFO_RPT		/* print untranslated primitive data	*/
    print_vaspec (&req_ptr->va_spec);
    printf ("\n Number of Access Results = %d ", req_ptr->num_of_acc_result);
    for (j = 0; j < req_ptr->num_of_acc_result; j++)
      {
      printf ("\n  Result %3d)  ", j+1);
      if (ar_ptr->acc_rslt_tag == ACC_RSLT_FAILURE)
	printf ("Failure : %d ", ar_ptr->failure);
      else
	{
	printf ("Success : ");
	list_bytes (ar_ptr->va_data.data,ar_ptr->va_data.len);
	}
      ar_ptr++;
      }
#else	 			/* print translated data		*/
    if (req_ptr->va_spec.var_acc_tag == VAR_ACC_NAMEDLIST)
      {
      vobj = &req_ptr->va_spec.vl_name;
      printf ("\n Named Variable List name =");
      printf (" %s",vobj->obj_name.vmd_spec);
      if (vobj->object_tag == 0)
        printf (" (VMD-specific scope).\n");
      else if (vobj->object_tag == 1)
        printf (" (domain = %s).\n",vobj->domain_id);
      else if (vobj->object_tag == 2)
        printf (" (AA-specific scope).\n");
      }
    printf ("\n Number of Access Results = %d ", req_ptr->num_of_acc_result);
    for (j = 0; j < req_ptr->num_of_acc_result; j++)
      {
      printf ("\n\n Enter Named Type to decode Data for Variable %d : ",j+1);
      if (req_ptr->va_spec.var_acc_tag == VAR_ACC_VARLIST  &&
          (vobj = ms_extract_varname ((ST_CHAR *)req_ptr,MMSOP_INFO_RPT,j)) != NULL)
        {
        printf ("Having Name '%s'",vobj->obj_name.vmd_spec);
#if 0
        if (vobj->object_tag == 0)
          printf (" (VMD-Specific Scope)");
        else if (vobj->object_tag == 1)
          printf (" (Domain = '%s')",vobj->domain_id);
        else if (vobj->object_tag == 2)
          printf (" (AA-Specific Scope)");
#endif
        }
      if (get_objname (&tobj) && 
	   (type = ms_find_named_type_obj (&tobj,req_info->chan)) && 
	   !(err = ms_extract_info_data (req_info,j,type,dest_buffer,SD_FALSE)))
	{
        print_arb_data (dest_buffer, type, SD_FALSE, SD_FALSE, NULL);
	}
      else
	{
	if (!err)
	  err = MVE_TYPENAME;
	printf ("\n\n Could not extract data - mms_op_err = %d -",err);
	if (err == MVE_MVINFO_ACCESS_ERR)
	  printf ("\n   Access failure : %d ", ar_ptr->failure);
        else
	  {
	  printf (" raw ASN.1 data = \n   ");
	  list_bytes (ar_ptr->va_data.data,ar_ptr->va_data.len);
	  }
	}
      ar_ptr++;
      }
#endif
    }
  indic_info_wait ();
  }
#endif

/************************************************************************/
/* GET VARIABLE NAME DEFINITION 					*/
/************************************************************************/

#define USE_MV_GETVAR_RESP 		/* define to use VM responder	*/


#if MMS_GETVAR_EN & RESP_EN

ST_VOID u_getvar_ind (MMSREQ_IND *req_info)
  {
GETVAR_REQ_INFO	*req_ptr;
#if !defined (USE_MV_GETVAR_RESP)
GETVAR_RESP_INFO  rsp_info;
#endif

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Get Variable Access Attibutes ");
    req_ptr = (GETVAR_REQ_INFO *) req_info->req_info_ptr;
    if (req_ptr->req_tag == GETVAR_NAME)
      print_objname (&req_ptr->name);
    else
      print_address (&req_ptr->address);
    }

#ifdef USE_MV_GETVAR_RESP
  mv_getvar_resp (req_info);
#else
  /*dest_buffer [0] = '\x80';*/
  dest_buffer [0] = '\x40';             /* set the bit next to the MSB  */
  dest_buffer [0] <<= 1;		/* move it left setting the MSB */
  dest_buffer [1] = '\x01';
  dest_buffer [2] = '\x12';

					/* create a default response	*/
  rsp_info.mms_deletable  = SD_FALSE;
  rsp_info.address_pres   = SD_FALSE;
  rsp_info.type_spec.data = dest_buffer;
  rsp_info.type_spec.len  = 3;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    rsp_info.mms_deletable = 
      ask ("\n\n Enter MMS Deletable (y/n) : (default = FALSE) ",0);
  
    init_nxtbuf ();	/* initialize next buffer for address and data	*/
    if (get_address (&rsp_info.address))
      rsp_info.address_pres = SD_TRUE;
    else
      rsp_info.address_pres = SD_FALSE;
    rsp_info.type_spec.data = dest_buffer + 10;
    if (tot_len = get_var_data ("Type Specification", rsp_info.type_spec.data))
      rsp_info.type_spec.len  = tot_len;
    else
      rsp_info.type_spec.data = dest_buffer;
    }

  mp_getvar_resp (req_info, &rsp_info);
#endif			       	/* end of USE_MV_GETVAR_RESP #else	*/

  indic_info_wait ();			/* allow user to see indic info */
  }

#endif

/************************************************************************/
/* DEFINE VARIABLE NAME 						*/
/************************************************************************/

#define USE_MV_DEFVAR_RESP		/* define to use VM responder	*/

#if MMS_DEFVAR_EN & RESP_EN

ST_VOID u_defvar_ind (MMSREQ_IND *req_info)
  {
DEFVAR_REQ_INFO	*req_ptr;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Define Named Variable ");
    req_ptr = (DEFVAR_REQ_INFO *) req_info->req_info_ptr;
    print_objname (&req_ptr->name);
    print_address (&req_ptr->address);
    printf ("\n Type Specification :");
    if (req_ptr->type_spec_pres)
      list_bytes (req_ptr->type_spec.data,req_ptr->type_spec.len);
    else
      printf ("Not Present ");
    }

#ifdef USE_MV_DEFVAR_RESP
  mv_defvar_resp (req_info);
#else
  mp_defvar_resp (req_info);
#endif			       	/* end of USE_MV_DEFVAR_RESP #else	*/

  indic_info_wait ();			/* allow user to see indic info */
  }

#endif

/************************************************************************/
/* DELETE VARIABLE NAME 						*/
/************************************************************************/
#define USE_MV_DELVAR_RESP		/* define to use VM responder	*/

#if MMS_DELVAR_EN & RESP_EN

ST_VOID u_delvar_ind (MMSREQ_IND *req_info)
  {
DELVAR_REQ_INFO *req_ptr;