u_ijou.c

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

    }

  /* read the journal							*/
  readJrnlFile (pstJrnl->usr);

  /* add the entries to the local journal				*/
  pstEC = (ENTRY_CONTENT *) (pstReqInfo + 1);
  for (i=0; i < pstReqInfo->num_of_jou_entry; i++)
    {
    if ( (pstEC->entry_form_tag == 2) && pstEC->ef.data.list_of_var_pres)
      numVars = pstEC->ef.data.num_of_var;
    entrySize = sizeof (JOURNAL_ENTRY) + numVars * sizeof (VAR_INFO);
    pstJE = chk_malloc (entrySize);

    /* assign an entry ID						*/
    sprintf (buf, "%d", ++lastEntryId);
    len = strlen (buf);
    pstJE->entry_id_len = len;
    pstJE->entry_id = chk_malloc (len);
    memcpy (pstJE->entry_id, buf, len);

    /* determine the originator						*/
    assInfoToAppRef (&s_ass_info[chan], &stAppRef);
    if (ms_appref_to_asn1 (&stAppRef, (ST_UCHAR *) buf, 1024, &temp, &len) == SD_SUCCESS) 
      {
      tmp = chk_malloc (len);
      memcpy (tmp, temp, len);
      }
    else
      {
      tmp = chk_malloc (2);
      tmp[0] = 0x30;
      tmp[1] = 0x00;
      len =2;
      }
    pstJE->orig_ae_len = len;
    pstJE->orig_ae = tmp;
    
    /* copy the entry content						*/
    memcpy (&pstJE->ent_content, pstEC, sizeof (ENTRY_CONTENT));
    if (pstEC->entry_form_tag == 3)		/* annotation		*/
      {
      len = strlen (pstEC->ef.annotation);
      pstJE->ent_content.ef.annotation = chk_malloc (len + 1);
      strcpy (pstJE->ent_content.ef.annotation, pstEC->ef.annotation);
      }

    /* take care of any variables					*/
    viIn =  (VAR_INFO *) (pstEC + 1);
    viOut = (VAR_INFO *) (pstJE + 1);
    for (j=0; j < numVars; j++, viIn++, viOut++)
      {
      len = strlen (viIn->var_tag);
      viOut->var_tag = chk_malloc (len +1);
      strcpy (viOut->var_tag, viIn->var_tag);
      viOut->value_spec.len = viIn->value_spec.len;
      viOut->value_spec.data = chk_malloc (viIn->value_spec.len);
      memcpy (viOut->value_spec.data, viIn->value_spec.data, 
      	      viIn->value_spec.len);
      }

    addToLocalJrnl (pstJE);
    pstEC = (ENTRY_CONTENT *) viIn;
    }	/* end the for loop						*/

  /* write the local journal						*/
  writeLocalJrnl (pstJrnl);

  /* send the response							*/
  mp_jwrite_resp (req_info);			/* send the response	*/
  }

/************************************************************************/
/* INITIALIZE JOURNAL							*/
/************************************************************************/

#if MMS_JINIT_EN & RESP_EN

ST_VOID u_jinit_ind (MMSREQ_IND *req_info)
  {
JINIT_RESP_INFO	rsp_info;
JINIT_REQ_INFO  *ptr;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Initialize Journal ");
    ptr    = (JINIT_REQ_INFO *) req_info->req_info_ptr;
    printf ("\n Journal Name            : ");
    print_objname (&(ptr->jou_name));
    printf ("\n Limiting Specification  : ");
    if (ptr->limit_spec_pres)
      {
      printf ("\n  Limiting Time          : ");
      print_evt_tod (&ptr->limit_time);
      printf ("  Limiting Entry         : ");
      if (ptr->limit_entry_pres) 
        list_bytes (ptr->limit_entry,ptr->limit_entry_len);
      else
        printf ("Not Present");
      }
    else
      printf ("Not Present");
    }

  /* interactive response						*/
  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    printf ("\n\n Enter deleted entries (default = 0) : ");
    rsp_info.del_entries = 0;
    if (longget (&lnum))
      rsp_info.del_entries = (ST_UINT) lnum;

    mp_jinit_resp (req_info, &rsp_info);	/* send the response	*/
    }
  else
    sendJinitResp (req_info);

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

#endif

/************************************************************************/
/* sendJinitResp:  init the local journal as specified in req_info	*/
/************************************************************************/

static ST_VOID sendJinitResp (MMSREQ_IND *req_info)
  {
JINIT_RESP_INFO	stRespInfo;
JINIT_REQ_INFO  *pstReqInfo;
ST_INT 		chan;
DOMAIN_OBJS 	*pstDomObj;
ST_CHAR 	*jrnlName;
ST_BOOLEAN	bHaveLimitTime=SD_FALSE, bHaveLimitEntry=SD_FALSE;
FILE 		*fp;
ST_BOOLEAN	bDone;
int		i, lastDeleted;
ST_UINT32	deletedEntries = 0;
JOURNAL_ENTRY   *pstJE; 
JOURNAL		*pstJrnl;

  pstReqInfo = (JINIT_REQ_INFO *) req_info->req_info_ptr;
  chan = req_info->chan;

  /* find the requested journal						*/
  if (pstReqInfo->jou_name.object_tag == AA_SPEC)
    {
    pstDomObj = mms_chan_info[chan].objs.aa_objs;
    jrnlName = pstReqInfo->jou_name.obj_name.aa_spec;
    }
  else if (pstReqInfo->jou_name.object_tag == DOM_SPEC)
    {
    pstDomObj = ms_find_dom_objs (&pstReqInfo->jou_name, chan);
    jrnlName = pstReqInfo->jou_name.obj_name.item_id;
    }
  else
    {
    pstDomObj = &m_vmd_select->vmd_wide;
    jrnlName = pstReqInfo->jou_name.obj_name.vmd_spec;
    }
    
  pstJrnl = ms_find_journal (pstDomObj, jrnlName);
  if (!pstJrnl)
    {
    mp_err_resp (req_info, 2, 1);
    return;
    }

  /* read the journal							*/
  if (readJrnlFile (pstJrnl->usr) != SD_SUCCESS)
    {
    mp_err_resp (req_info, 2, 1);
    return;
    }

  /* determine entries to delete					*/
  if (pstReqInfo->limit_spec_pres)
    {
    bHaveLimitTime = SD_TRUE;
    if (pstReqInfo->limit_entry_pres)
      bHaveLimitEntry = SD_TRUE;
    }

  /* if no limits - delete all entries					*/
  if (!bHaveLimitTime)
    {
    stRespInfo.del_entries = localJrnlLevel;
    fp = fopen (pstJrnl->usr, "w");
    if (fp)
      fclose (fp);
    }
  else
    {
    /* delete all TimeStamps less than limitTime			*/
    lastDeleted = -1;
    for (i=0; i<localJrnlLevel; i++)
      {
      if (compareMmsBtod (&pstLocalJrnl[i]->ent_content.occur_time,
      			  &pstReqInfo->limit_time) < 0)
	{
	pstJE = pstLocalJrnl[i];
	pstLocalJrnl[i]=NULL;
	freeJournalEntry (pstJE);
	chk_free (pstJE);
 	deletedEntries++;
	lastDeleted = i;
	}
      }

    /* delete entries based on limitEntry				*/
    if (bHaveLimitEntry)
      {
      bDone = SD_FALSE;
      i = lastDeleted + 1;
      while (i<localJrnlLevel && !bDone)
        {
        if (compareMmsBtod (&pstLocalJrnl[i]->ent_content.occur_time,
      			    &pstReqInfo->limit_time) == 0)
	  {
	  pstJE = pstLocalJrnl[i];
	  if ( (pstJE->entry_id_len == pstReqInfo->limit_entry_len) &&
	       (memcmp (pstJE->entry_id, pstReqInfo->limit_entry,
	     	        pstJE->entry_id_len) == 0) )
	    bDone = SD_TRUE;
	  pstLocalJrnl[i]=NULL;
	  freeJournalEntry (pstJE);
	  chk_free (pstJE);
 	  deletedEntries++;
	  i++;
	  }
        else
          bDone = SD_TRUE;
        }
      }
    else    /* if no limit entry - delete all the rest with same timestamp  */
      {
      i = lastDeleted + 1;
      while ((i < localJrnlLevel) && 
             (compareMmsBtod (&pstLocalJrnl[i]->ent_content.occur_time,
      			      &pstReqInfo->limit_time) == 0))
        {
	pstJE = pstLocalJrnl[i];
	pstLocalJrnl[i]=NULL;
	freeJournalEntry (pstJE);
	chk_free (pstJE);
 	deletedEntries++;
	i++;
	}
      }		/* end if bHaveLimitEntry				*/

    /* update the file							*/
    writeLocalJrnl (pstJrnl);
    stRespInfo.del_entries = deletedEntries;
    }

  mp_jinit_resp (req_info, &stRespInfo);	/* send the response	*/
  freeLocalJrnl ();
  }

/************************************************************************/
/* REPORT JOURNAL STATUS						*/
/************************************************************************/

#if MMS_JSTAT_EN & RESP_EN

ST_VOID u_jstat_ind (MMSREQ_IND *req_info)
  {
JSTAT_RESP_INFO	rsp_info;
JSTAT_REQ_INFO  *ptr;
ST_UCHAR  *inp_str;
DOMAIN_OBJS 	*pstDomObj;
ST_CHAR 	*jrnlName;
ST_INT chan;
JOURNAL 	*pstJrnl;

  chan = req_info->chan;
  ptr  = (JSTAT_REQ_INFO *) req_info->req_info_ptr;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Report Journal Status ");
    printf ("\n Journal Name : ");
    print_objname (&(ptr->jou_name));
    }

  /* figure out which DOMAIN_OBJS to use		*/
  if (ptr->jou_name.object_tag == AA_SPEC)
    {
    pstDomObj = mms_chan_info[chan].objs.aa_objs;
    jrnlName = ptr->jou_name.obj_name.aa_spec;
    }
  else if (ptr->jou_name.object_tag == DOM_SPEC)
    {
    pstDomObj = ms_find_dom_objs (&ptr->jou_name, chan);
    jrnlName = ptr->jou_name.obj_name.item_id;
    }
  else
    {
    pstDomObj = &m_vmd_select->vmd_wide;
    jrnlName = ptr->jou_name.obj_name.vmd_spec;
    }

  pstJrnl = ms_find_journal (pstDomObj, jrnlName);
  if (!pstJrnl)
    {
    mp_err_resp (req_info, 2, 1);
    return;
    }

  if (readJrnlFile (pstJrnl->usr) == SD_SUCCESS)
    {
    rsp_info.cur_entries = localJrnlLevel;
    rsp_info.mms_deletable = pstJrnl->deletable;
    }
  else
    {
    rsp_info.cur_entries = 0;	/* create a default response, no entries*/
    rsp_info.mms_deletable = SD_TRUE;
    }
  freeLocalJrnl ();

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    printf ("\n\n Enter current entries (default = 0) : ");
    rsp_info.cur_entries = 0;
    if (longget (&lnum))
      rsp_info.cur_entries = (ST_UINT) lnum;
    inp_str = (ST_UCHAR *)dest_buffer;
    if (ask (" MMS Deletable (1=yes, 0=no)? ",1))
      rsp_info.mms_deletable = 1;
    else
      rsp_info.mms_deletable = 0;
    }
  
  mp_jstat_resp (req_info, &rsp_info);		/* send the response	*/
  indic_info_wait ();			/* allow user to see indic info */
  }

#endif

/************************************************************************/
/* CREATE JOURNAL							*/
/************************************************************************/

#if MMS_JCREATE_EN & RESP_EN

ST_VOID u_jcreate_ind (MMSREQ_IND *req_info)
  {
JCREATE_REQ_INFO *ptr;
JOURNAL 	*pstJrnl;
DOMAIN_OBJS 	*pstDomObj;
ST_CHAR 	*jrnlName, *jrnlFile;
ST_INT chan;

  chan = req_info->chan;
  ptr    = (JCREATE_REQ_INFO *) req_info->req_info_ptr;

  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Create Journal ");
    printf ("\n Journal Name : ");
    print_objname (&(ptr->jou_name));
    }

  /* figure out which DOMAIN_OBJS to use		*/
  if (ptr->jou_name.object_tag == AA_SPEC)
    {
    pstDomObj = mms_chan_info[chan].objs.aa_objs;
    jrnlName = ptr->jou_name.obj_name.aa_spec;
    }
  else if (ptr->jou_name.object_tag == DOM_SPEC)
    {
    pstDomObj = ms_find_dom_objs (&ptr->jou_name, chan);
    jrnlName = ptr->jou_name.obj_name.item_id;
    }
  else
    {
    pstDomObj = &m_vmd_select->vmd_wide;
    jrnlName = ptr->jou_name.obj_name.vmd_spec;
    }
    
  pstJrnl = ms_add_journal (pstDomObj, jrnlName, SD_TRUE);
  if (!pstJrnl)
    mp_err_resp (req_info, 2, 5);
  else
    {
    jrnlFile = chk_malloc (strlen(jrnlName)+5);
    sprintf (jrnlFile, "%s.cfg", jrnlName);
    pstJrnl->usr = jrnlFile;
    mp_jcreate_resp (req_info);			/* send the response	*/
    }

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

#endif

/************************************************************************/
/* DELETE JOURNAL							*/
/************************************************************************/

#if MMS_JDELETE_EN & RESP_EN

ST_VOID u_jdelete_ind (MMSREQ_IND *req_info)
  {
JDELETE_REQ_INFO *ptr;
DOMAIN_OBJS 	*pstDomObj;
ST_CHAR 	*jrnlName;
ST_INT chan;

  chan = req_info->chan;
  ptr    = (JDELETE_REQ_INFO *) req_info->req_info_ptr;
  if (mms_debug_sel & MMS_LOG_USR_IND)
    {
    indic_info_print (req_info,"Delete Journal ");
    printf ("\n Journal Name : ");
    print_objname (&(ptr->jou_name));
    }

  /* figure out which DOMAIN_OBJS to use		*/
  if (ptr->jou_name.object_tag == AA_SPEC)
    {
    pstDomObj = mms_chan_info[chan].objs.aa_objs;
    jrnlName = ptr->jou_name.obj_name.aa_spec;
    }
  else if (ptr->jou_name.object_tag == DOM_SPEC)
    {
    pstDomObj = ms_find_dom_objs (&ptr->jou_name, chan);
    jrnlName = ptr->jou_name.obj_name.item_id;
    }
  else
    {
    pstDomObj = &m_vmd_select->vmd_wide;
    jrnlName = ptr->jou_name.obj_name.vmd_spec;
    }

  if (ms_del_journal (pstDomObj, jrnlName) != SD_SUCCESS)
    mp_err_resp (req_info, 2, 1);
  else
    mp_jdelete_resp (req_info);			/* send the response	*/
  indic_info_wait ();			/* allow user to see indic info */
  }

#endif



/************************************************************************/
/* read a journal.cfg file						*/
/* Not a lot of error checking is provided.  User is required to ensure */
/* mandatory data is present.  Only Integer16, Double and Vstring64 data*/
/* is supported for the VarTag data.  All errors will be output to the  */
/* slog file.								*/
/************************************************************************/


typedef struct entryCtrl
  {
  ST_BOOLEAN bInProgress;
  ST_BOOLEAN bDiscardEntry;
  ST_INT     numEntries;
  JOURNAL_ENTRY currEntry;
  ST_INT16   numVars;
  VAR_INFO   *aPtr;
  } ENTRY_CTRL;

static ENTRY_CTRL *entryCtrl;
static VAR_INFO *currVarInfo;