ictassoc.c

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

	    ICA_Log_Err2 ("ERROR:  DefineDomainNames status = %d %s", 
	    		   status, icPerror (status));
            }
	  else
	    {
	    ICA_Log_Flow3 ("Remote %s Doms %s, %s defined OK",
	     		    pstRemote->remoteName, 
			    pstRemote->localDom, 
			    pstRemote->remoteDom);
	    }
	  }
        }
      }	 	/* end the if */
    pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }		/* end the while */

  return rtnVal;
  }

/************************************************************************/
/* doDefFeatures:  traverse list and call icDefineLocalFeatures		*/
/************************************************************************/

ST_RET doDefFeatures(ICTA_REMOTE_INFO *remoteListHead)
  {
ICTA_REMOTE_INFO *pstRemote;
icInt status;
ST_RET rtnVal = SD_SUCCESS;


  pstRemote = remoteListHead;
  while ( pstRemote && pstRemote->bIsServer && pstRemote->bRemoteDefined )
    {
    status = icDefineLocalFeatures(pstRemote->remoteId,
				   pstRemote->serverObj->stFeatures.bBlock2,
				   pstRemote->serverObj->stFeatures.bBlock3,
				   pstRemote->serverObj->stFeatures.bBlock4,
				   pstRemote->serverObj->stFeatures.bBlock5,
				   pstRemote->serverObj->stFeatures.bBlock6,
				   pstRemote->serverObj->stFeatures.bBlock7,
				   pstRemote->serverObj->stFeatures.bBlock8,
				   pstRemote->serverObj->stFeatures.bBlock9,
				   &pstRemote->serverObj->stFeatures.supportedFeatures);

    if (status)
      {
      ICA_Log_Err2("ERROR:  Define Local Features status = %d %s\n", 
                    status, icPerror(status));
      rtnVal = SD_FAILURE;
      }
    else
      {
      ICA_Log_Flow1("Local Features '%s' Defined Successfully.", 
                     pstRemote->remoteName);
      }

    pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }

  return rtnVal;
  }

/************************************************************************/
/* doDefLinks:  traverse remote list, traverse associated link list and	*/
/*		call icDefineLink					*/
/************************************************************************/

ST_INT doDefLinks(ICTA_REMOTE_INFO *remoteListHead, int who)
  {
ICTA_LINK_INFO *pstLink;
ICTA_REMOTE_INFO *pstRemote;
icInt status;
ST_INT rtnVal = SD_SUCCESS;
int i;
icChar *tempRemotes[MAX_REMOTE_ARNAMES];
icInt numRemAr = 0;

  pstRemote = remoteListHead;
  while (pstRemote)
    {   
    if (!pstRemote->bRemoteDefined)
      {
      pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		  ((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
      continue;
      }

    if ( (who == ICTA_CLIENT && pstRemote->bIsClient) ||
         (who == ICTA_SERVER && pstRemote->bIsServer) ||
	 (who == ICTA_BOTH) )
      {
      pstLink = pstRemote->linkList;
      while (pstLink && !pstLink->bLinkDefined)
        {
        pstLink->nChannel = currChannelNum++;

        if (bUseNewDefLink)
          {
          for (i = 0; i < MAX_REMOTE_ARNAMES; i++)
            {
            tempRemotes[i] = pstLink->remoteArs[i];
            if (pstLink->remoteArs[i] != NULL)
              numRemAr = i + 1;
            }

          status = icDefineLinkEx (pstRemote->remoteId, pstLink->nChannel,
                                   pstLink->localAr, tempRemotes, numRemAr, 
                                   pstLink->nCriticalTimeout, 
                                   (icUserData) pstLink, &pstLink->linkId);
          }
        else
          {
          status = icDefineLink(pstRemote->remoteId,
			        pstLink->nChannel,
			        pstLink->localAr,
			        pstLink->remoteArs[0],
			        pstLink->remoteArs[1],
			        pstLink->remoteArs[2],
			        pstLink->remoteArs[3],
			        pstLink->nCriticalTimeout,
			       (icUserData) pstLink,
			       &pstLink->linkId);
          }

        if (status)
          {
          ICA_Log_Err2("ERROR:  Define Link Status = %d %s\n", 
                       status, icPerror(status));
	  ICA_Log_ErrC2("       Local AR '%s' to Remote AR '%s'",
	                pstLink->localAr, pstLink->remoteArs[0]);
	  rtnVal = SD_FAILURE;
          }
        else
          {
          pstLink->bLinkDefined = icTrue;
	  ICA_Log_Flow2("Link '%s' to '%s' Defined Successfully.",
	                pstLink->localAr, pstLink->remoteArs[0]);
          }	       
        pstLink = (ICTA_LINK_INFO *) list_get_next
		  ((ST_VOID *)pstRemote->linkList, (ST_VOID *)pstLink);
        }	/* end the while pstLink */
      }		/* end the if		 */
    pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }		/* end the while pstRemote */

  return rtnVal;
  }

/************************************************************************/
/* doStartRemote:  start one or a bunch of remotes			*/
/************************************************************************/

static ST_RET doStartRemote(int howMany, int who,
			    ICTA_REMOTE_INFO *remoteListHead)
  {
ICTA_REMOTE_INFO *pstRemote;
icInt status;
ST_RET rtnVal;

  rtnVal = SD_SUCCESS;
  pstRemote = remoteListHead;
  while (pstRemote)
    {
    if ((pstRemote->bRemoteDefined && !pstRemote->bRemoteStarted) &&
       (((who == ICTA_CLIENT) && pstRemote->bIsClient) ||
        ((who == ICTA_SERVER) && pstRemote->bIsServer) ||
	( who == ICTA_BOTH) ) )
      {
      if (bUseNewStartRem)
        {
        status = icStartRemoteEx (pstRemote->remoteId, 
                                  linkUpCallBackEx, 
                                  linkDownCallBackEx);
        }
      else
        {
        status = icStartRemote(pstRemote->remoteId,
			       linkUpCallBack,
			       linkDownCallBack);
        }

      if (status)
        {
        ICA_Log_Err2("ERROR:  Unable to Start Remote, status=%d %s\n", 
                     status, icPerror(status));
        ICA_Log_ErrC1("       Remote= '%s'", pstRemote->remoteName);
        rtnVal = SD_FAILURE;
        }
      else
        {
        pstRemote->bRemoteStarted = icTrue;
        ICA_Log_Flow1("Remote '%s' Started OK.", pstRemote->remoteName);
        }
      }	
    if (howMany == ICTA_DO_ONE)
      pstRemote = NULL;
    else
      pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		  ((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);

    }

  return rtnVal;
  }

/************************************************************************/
/* doStopRemote:  stop one or a bunch of remotes			*/
/************************************************************************/

static ST_RET doStopRemote(int howMany, int who,
			   ICTA_REMOTE_INFO *remoteListHead)
  {
ICTA_REMOTE_INFO *pstRemote;
icInt status;
ST_RET rtnVal;

  rtnVal = SD_SUCCESS;
  pstRemote = remoteListHead;
  while (pstRemote)
    {
    if ((pstRemote->bRemoteDefined && pstRemote->bRemoteStarted) &&
       (((who == ICTA_CLIENT) && pstRemote->bIsClient) ||
        ((who == ICTA_SERVER) && pstRemote->bIsServer) ||
	( who == ICTA_BOTH) ) )
      {
      status = icStopRemote(pstRemote->remoteId,
			    remoteStopCallBack);
      if (status)
        {
        ICA_Log_Err2("ERROR:  Unable to Stop Remote, status=%d %s\n", 
                     status, icPerror(status));
        ICA_Log_ErrC1("       Remote= '%s'", pstRemote->remoteName);
        rtnVal = SD_FAILURE;
        }
      else
        {
        pstRemote->bRemoteStarted = icFalse;
        ICA_Log_Flow1("Remote '%s' Stopped OK.", pstRemote->remoteName);
        }
      }  
    if (howMany == ICTA_DO_ONE)
      pstRemote = NULL;
    else
      pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		  ((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }

  return rtnVal;
  }

/************************************************************************/
/* doStartLinks:  start links for one or a bunch of remotes		*/
/************************************************************************/

static ST_RET doStartLinks(int howMany, int who,
			   ICTA_REMOTE_INFO *remoteListHead)
  {
ICTA_LINK_INFO *pstLink;
ICTA_REMOTE_INFO *pstRemote;
ST_RET  rtnVal = SD_SUCCESS;


  pstRemote = remoteListHead;
  while (pstRemote)
    { 
    if ( (who == ICTA_CLIENT && pstRemote->bIsClient) ||
         (who == ICTA_SERVER && pstRemote->bIsServer) ||
	 (who == ICTA_BOTH) )
      {
      pstLink = pstRemote->linkList;
      while (pstLink)
        {
        icStartLink(pstLink->linkId);
        pstLink->bLinkStarted = icTrue;
        ICA_Log_Flow2("Link '%s' to '%s' Started OK.",
	              pstLink->localAr, pstLink->remoteArs[0]);

        pstLink = (ICTA_LINK_INFO *) list_get_next
		  ((ST_VOID *)pstRemote->linkList, (ST_VOID *)pstLink);
	}
      }
    if (howMany == ICTA_DO_ONE)
      pstRemote = NULL;
    else
      pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		  ((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }

  return rtnVal;
  }

/************************************************************************/
/* doStopLinks:  stop links for one or a bunch of remotes		*/
/************************************************************************/

ST_RET doStopLinks(int howMany, ICTA_REMOTE_INFO *remoteListHead)
  {
ICTA_LINK_INFO *pstLink;
ICTA_REMOTE_INFO *pstRemote;
ST_RET rtnVal = SD_SUCCESS;

  pstRemote = remoteListHead;
  while (pstRemote)
    {   
    pstLink = pstRemote->linkList;
    while (pstLink)
      {
      icStopLink(pstLink->linkId);
      pstLink->bLinkStarted = icFalse;
      ICA_Log_Flow2("Link '%s' to '%s' Stopped OK.",
	            pstLink->localAr, pstLink->remoteArs[0]);

      pstLink = (ICTA_LINK_INFO *) list_get_next
		((ST_VOID *)pstRemote->linkList, (ST_VOID *)pstLink);
      }
    if (howMany == ICTA_DO_ONE)
      pstRemote = NULL;
    else
      pstRemote = (ICTA_REMOTE_INFO *) list_get_next
		  ((ST_VOID *)remoteListHead, (ST_VOID *)pstRemote);
    }

  return rtnVal;
  }

/************************************************************************/
/* Association Oriented CallBack Functions:				*/
/************************************************************************/
/* linkUpCallBack:  called by API when link started			*/
/*		    data established at icDefineLink			*/
/************************************************************************/

void linkUpCallBack(icLinkId lid, icUserData data)
  {
ICTA_LINK_INFO *pstLink;

  pstLink = (ICTA_LINK_INFO *)data;
  pstLink->bLinkUp = icTrue;
  printf ("\nLinkUpCallBack:  localAR='%s', remoteAR='%s'\n", 
          pstLink->localAr, pstLink->remoteArs[0]);
  }      
  
/************************************************************************/
/* linkUpCallBackEx:  called by API when link started                   */
/*                    call icStartRemoteEx to use this callback         */
/************************************************************************/

void linkUpCallBackEx (icLinkId linkId, icChar *arName, icUserData data)
  {
ICTA_LINK_INFO *pstLink;

  pstLink = (ICTA_LINK_INFO *)data;
  pstLink->bLinkUp = icTrue;
  printf ("\nLinkUpCallBack:  localAR='%s', remoteAR='%s'\n", 
          pstLink->localAr, arName);
  }

/************************************************************************/
/* linkDownCallBack:  called by API when link is stopped		*/
/*		      data established at icDefineLink			*/
/************************************************************************/

void linkDownCallBack(icLinkId lid, icUserData data)
  {
ICTA_LINK_INFO *pstLink;

  pstLink = (ICTA_LINK_INFO *)data;
  pstLink->bLinkUp = icFalse;
  printf ("\nLinkDownCallBack:  localAR='%s', remoteAR='%s'\n",
          pstLink->localAr, pstLink->remoteArs[0]);
  }      

/************************************************************************/
/* linkDownCallBackEx:  called by API when link is stopped              */
/*                      call icStartRemoteEx to use this callback       */
/************************************************************************/

void linkDownCallBackEx (icLinkId linkId, icChar *arName, icUserData data)
  {
ICTA_LINK_INFO *pstLink;

  pstLink = (ICTA_LINK_INFO *)data;
  pstLink->bLinkUp = icFalse;
  printf ("\nLinkDownCallBack:  localAR='%s', remoteAR='%s'\n",
          pstLink->localAr, arName);
  }

/************************************************************************/
/* remoteStopCallBack:  called by API in response to icRemoteStop     	*/
/*			data established at icDefineRemote		*/
/************************************************************************/

void remoteStopCallBack (icRemoteId rid, icUserData data)
  {
ICTA_REMOTE_INFO *pstRemote;

  pstRemote = (ICTA_REMOTE_INFO *)data;
  pstRemote->bRemoteStarted = icFalse;
  printf("\nRemote '%s' has been stopped.", pstRemote->remoteName);

  }