* message queues option, VxFusion.** RETURNS: N/A** NOTE: Call with <distGrpDbSemaphore> taken.** NOMANUAL*/void msgQDistGrpLclSetId    (    DIST_GRP_DB_NODE *   pGrpDbNode,   /* the node to change */    DIST_MSG_Q_GRP_ID    grpId         /* the new ID */    )    {    DIST_OBJ_NODE *   pObjNode;    DIST_MSG_Q_ID     dMsgQId;    int               ix = pGrpDbNode->ixNode;    hashTblRemove (distGrpDbIdId, (HASH_NODE *) &(distGrpDbId[ix]));    pGrpDbNode->grpDbId = grpId;    pObjNode = MSG_Q_ID_TO_DIST_OBJ_NODE (pGrpDbNode->grpDbMsgQId);    dMsgQId = DIST_MSG_Q_GRP_ID_TO_DIST_MSG_Q_ID (grpId);    pObjNode->objNodeId = DIST_MSG_Q_ID_TO_DIST_OBJ_ID (dMsgQId);    hashTblPut (distGrpDbIdId, (HASH_NODE *) &(distGrpDbId[ix]));    }/***************************************************************************** msgQDistGrpLclCreate - create a new group in local database (VxFusion option)** This routine creates a new group in the local database.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: A ptr to the group node.** NOTE: Call with <distGrpDbSemaphore> taken.** NOMANUAL*/DIST_GRP_DB_NODE * msgQDistGrpLclCreate    (    char *               grpName,     /* group name */    DIST_MSG_Q_GRP_ID    grpId,       /* group ID */    DIST_GRP_STATE       grpState     /* initial state */    )    {    DIST_GRP_DB_NODE *   pDbNode;    DIST_OBJ_NODE *      pObjNode;    /* get a free database node */    if (! (pDbNode = (DIST_GRP_DB_NODE *) sllGet (&msgQDistGrpFreeList)))        {        return (NULL);    /* database is full */        }    /* init database node */    bcopy (grpName, (char *) &(pDbNode->grpDbName), strlen (grpName) + 1);    sllInit (&(pDbNode->grpDbMsgQIdLst));    pDbNode->grpDbState = grpState;    pDbNode->grpDbId = grpId;    pDbNode->pGrpDbGapNode = NULL;    /* Create message queue id. */    pObjNode = distObjNodeGet();    pObjNode->objNodeType    = DIST_OBJ_TYPE_MSG_Q;    pObjNode->objNodeId      = DIST_MSG_Q_GRP_ID_TO_DIST_OBJ_ID (grpId);    pDbNode->grpDbMsgQId = DIST_OBJ_NODE_TO_MSG_Q_ID (pObjNode);    /* Link group name hash node in name hash table. */    hashTblPut (distGrpDbNmId, (HASH_NODE *) &(distGrpDbNm[pDbNode->ixNode]));    /* Link group id hash node in id hash table. */    hashTblPut (distGrpDbIdId, (HASH_NODE *) &(distGrpDbId[pDbNode->ixNode]));#ifdef DIST_MSG_Q_GRP_REPORT    printf ("msgQDistGrpLclCreate: `%s' (id 0x%lx, state %d) created\n",            grpName, grpId, grpState);#endif    return (pDbNode);    }/***************************************************************************** msgQDistGrpLclAddMember - add a member to a group in the local database (VxFusion option)** This routine adds a member to a group in the local database.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: OK, if the member was added; ERROR, if not.** NOMANUAL*/STATUS msgQDistGrpLclAddMember    (    DIST_GRP_DB_NODE * pDbNode,      /* ptr to node of group */    MSG_Q_ID           msgQId        /* msgQ ID to add to group */    )    {    DIST_GRP_MSG_Q_NODE * distGrpMsgQNode;    distGrpMsgQNode = (DIST_GRP_MSG_Q_NODE *)                        malloc (sizeof (DIST_GRP_MSG_Q_NODE));    if (distGrpMsgQNode == NULL)        return (ERROR);    /* out of memory */    distGrpMsgQNode->msgQId = msgQId;    msgQDistGrpDbLock();    sllPutAtHead (&(pDbNode->grpDbMsgQIdLst), (SL_NODE *) distGrpMsgQNode);    msgQDistGrpDbUnlock();    return (OK);    }/***************************************************************************** msgQDistGrpLclFindById - Find a group's node given in group ID (VxFusion option)** This routine looks up a group node when given the group ID.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: A pointer to a group node, or NULL.** NOTE: Take <distGrpDbSemaphore> before calling.** NOMANUAL*/DIST_GRP_DB_NODE * msgQDistGrpLclFindById    (    DIST_MSG_Q_GRP_ID distGrpId    /* the group ID to look for */    )    {    DIST_GRP_HASH_NODE    hMatchNode;    DIST_GRP_HASH_NODE *  pHNode;    DIST_GRP_DB_NODE      dbMatchNode;    hMatchNode.pDbNode = &dbMatchNode;    dbMatchNode.grpDbId = distGrpId;    pHNode = (DIST_GRP_HASH_NODE *) hashTblFind (distGrpDbIdId,                                                 (HASH_NODE *) &hMatchNode,                                                 KEY_CMP_ARG_ID);    if (pHNode == NULL)        return (NULL);    /* not found */    return (pHNode->pDbNode);    }/***************************************************************************** msgQDistGrpLclFindByName - Find a group node given a group name (VxFusion option)** This routine looks up a group node when given the name of the group.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: A pointer to a group node, or NULL.** NOTE: Call with <distGrpDbSemaphore> taken.** NOMANUAL*/DIST_GRP_DB_NODE * msgQDistGrpLclFindByName    (    char * grpName         /* group name to find */    )    {    DIST_GRP_HASH_NODE  hMatchNode, *pHNode;    DIST_GRP_DB_NODE    dbMatchNode;    hMatchNode.pDbNode = &dbMatchNode;    bcopy (grpName, (char *) &(dbMatchNode.grpDbName), strlen (grpName) + 1);    pHNode = (DIST_GRP_HASH_NODE *) hashTblFind (distGrpDbNmId,                                                 (HASH_NODE *) &hMatchNode,                                                 KEY_CMP_ARG_STR);    if (pHNode == NULL)        return (NULL);    /* not found */    return (pHNode->pDbNode);    }/***************************************************************************** msgQDistGrpLclEach - Step through nodes in the database (VxFusion option)** This routine steps through all nodes in the database, calling <routine>* with argument <routineArg> for each node.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: N/A** NOTE: Takes <distGrpDbSemaphore>.** NOMANUAL*/void msgQDistGrpLclEach    (    FUNCPTR routine,        /* routine to call for each node */    int     routineArg      /* argument to pass to routine */    )    {    msgQDistGrpDbLock();        hashTblEach (distGrpDbNmId, routine, routineArg);    msgQDistGrpDbUnlock();    }/***************************************************************************** msgQDistGrpBurst - burst out group database (VxFusion option)** This routine is used by INCO to update the remote group database on* node <nodeId>. All entries in the database are transmitted.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: STATUS of remote operation.** NOMANUAL*/STATUS msgQDistGrpBurst    (    DIST_NODE_ID    nodeId          /* node to update */    )    {    DIST_GRP_BURST    burst;    burst.burstNodeId = nodeId;    burst.burstStatus = OK;    msgQDistGrpLclEach ((FUNCPTR) msgQDistGrpBurstOne, (int) &burst);    return (burst.burstStatus);    }/***************************************************************************** msgQDistGrpBurstOne - burst out single group database entry (VxFusion option)** This routine bursts out a database entry to a node.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: TRUE, if successfully; FALSE, if not.** NOMANUAL*/BOOL msgQDistGrpBurstOne    (    DIST_GRP_HASH_NODE * pGrpHashNode,   /* specifies node to send */    DIST_GRP_BURST *     pBurst          /* target node */    )    {    DIST_PKT_DGDB_ADD    pktAdd;    DIST_GRP_DB_NODE *   pNode = pGrpHashNode->pDbNode;    DIST_IOVEC           distIOVec[2];    STATUS               status;    pktAdd.pktDgdbAddHdr.pktType = DIST_PKT_TYPE_DGDB;    pktAdd.pktDgdbAddHdr.pktSubType = DIST_PKT_TYPE_DGDB_ADD;    pktAdd.pktDgdbAddId = htons (pNode->grpDbId);    pktAdd.pktDgdbAddCreator = htonl (pNode->grpDbNodeId);    /* use IOV stuff here, since we do not want to copy data */    distIOVec[0].pIOBuffer = &pktAdd;    distIOVec[0].IOLen = DIST_PKT_HDR_SIZEOF (DIST_PKT_DGDB_ADD);    distIOVec[1].pIOBuffer = (char *) &pNode->grpDbName;    distIOVec[1].IOLen = strlen ((char *) &pNode->grpDbName) + 1;    status = distNetIOVSend (pBurst->burstNodeId, &distIOVec[0], 2,            WAIT_FOREVER, DIST_DGDB_PRIO);    if ((pBurst->burstStatus = status) == ERROR)        return (FALSE);    return (TRUE);    }/***************************************************************************** msgQDistGrpHCmpStr - determine if two nodes have the same name (VxFusion option)** This routine is the hash compare function for group names.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: TRUE, if the nodes have the same name; FALSE, otherwise.** NOMANUAL*/LOCAL BOOL msgQDistGrpHCmpStr    (    DIST_GRP_HASH_NODE * pMatchHNode,   /* first node */    DIST_GRP_HASH_NODE * pHNode,        /* second node */    int                  keyCmpArg      /* not used */    )    {        UNUSED_ARG(keyCmpArg);        if (strcmp ((char *) &pMatchHNode->pDbNode->grpDbName,                (char *) &pHNode->pDbNode->grpDbName) == 0)        return (TRUE);    else        return (FALSE);    }/***************************************************************************** msgQDistGrpHFuncStr - hash function for strings (VxFusion option)** This routine computes the hash value for a node's group name.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: The hash value.** NOMANUAL*/LOCAL INT32 msgQDistGrpHFuncStr    (    int                    elements,    /* elements in hash table */    DIST_GRP_HASH_NODE *   pHNode,      /* node whose name to hash */    int                    seed         /* seed for hashing */    )    {    char * tkey;    int    hash = 0;    for (tkey = (char *) &pHNode->pDbNode->grpDbName; *tkey != '\0'; tkey++)        hash = hash * seed + (unsigned int) *tkey;    return (hash & (elements - 1));    }/***************************************************************************** msgQDistGrpHCmpId - compare two group ID's (VxFusion option)** This routine is the hash compare function for group ID's.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: TRUE, if ID's match; FALSE, otherwise.** NOMANUAL*/LOCAL BOOL msgQDistGrpHCmpId    (    DIST_GRP_HASH_NODE *   pMatchNode,  /* first node */    DIST_GRP_HASH_NODE *   pHNode,      /* second node */    int                    keyArg       /* unused */    )    {    DIST_MSG_Q_GRP_ID    distGrpId1 = pMatchNode->pDbNode->grpDbId;    DIST_MSG_Q_GRP_ID    distGrpId2 = pHNode->pDbNode->grpDbId;        UNUSED_ARG(keyArg);        if (distGrpId1 == distGrpId2)        return (TRUE);    else        return (FALSE);    }/***************************************************************************** msgQDistGrpHFuncId - hash function for group ID's (VxFusion option)** This routine computes a hash value for a group's ID.** AVAILABILITY* This routine is distributed as a component of the unbundled distributed* message queues option, VxFusion.** RETURNS: The hash value.** NOMANUAL*/LOCAL INT32 msgQDistGrpHFuncId    (    int                    elements,   /* elements in hash table */    DIST_GRP_HASH_NODE *   pHNode,     /* node whose ID to hash */    int                    divisor     /* used by hash computation */    )    {    return ((pHNode->pDbNode->grpDbId % divisor) & (elements - 1));    }