m2pppsecuritysecretslibtest.c

这是全套的PPP协议的源码

        printf("R = NULL\n");
        }
    }

/*****************************************/

STATUS m2pppSecuritySecretsDatabaseSortPrint(void)
    {
    PPP_SECURITY_SECRETS_DATA_ENTRY * auxData = NULL;
    PPP_SECURITY_SECRETS_ENTRY * aux = NULL;

    if  (NULL == pppSecretsDataTree)
        {
        printf("pppSecretsDataTree is NULL\n");
        return ERROR;
        }
    else
        {
        printf("BEGIN SEQUENTIAL SNAPSHOT OF DATA TREE\n");
        }
    
    PPP_SECRETS_SEM_TAKE;

    auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
           avlMinimumGet((void *) pppSecretsDataTree);

    while (auxData != NULL)
        {
        printSecretsDataNode(auxData);
        auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
                  avlSuccessorGet(pppSecretsDataTree,
                                  (GENERIC_ARGUMENT)((void *)auxData),
                                  ldpiDataKeyCompare);
        }

    printf("END SEQUENTIAL SNAPSHOT OF DATA TREE\n");

    if  (NULL == pppSecretsTree)
        {
        printf("pppSecretsTree is NULL\n");
        return ERROR;
        }
    else
        {
        printf("BEGIN SEQUENTIAL SNAPSHOT OF PRIMARY TREE\n");
        }
    
    aux = (PPP_SECURITY_SECRETS_ENTRY *) 
           avlMinimumGet((void *) pppSecretsTree);

    while (aux != NULL)
        {
        printSecretsNode(aux);
        aux = (PPP_SECURITY_SECRETS_ENTRY *) 
              avlSuccessorGet(pppSecretsTree,
                             (GENERIC_ARGUMENT)((void *)aux),
                             m2pppAgentKeyCompare);
        }

    PPP_SECRETS_SEM_GIVE;

    printf("END SEQUENTIAL SNAPSHOT OF PRIMARY TREE\n");

    return OK;

    }

void secretsDataKeyPrint(PPP_SECURITY_SECRETS_DATA_ENTRY * pDataEntry)
    {
    UINT32                          link;
    PPP_SECURITY_SECRETS_DIRECTION  direction;
    PPP_SECURITY_PROTOCOL           protocol;
    char *                          identity;
    char *                          secret;

    if  (NULL == pDataEntry)
        {
        printf("secretsDataNodeNicePrint <nodep> input was NULL\n");
        return;
        }
    
    link =      pDataEntry->pppSecuritySecretsLink;
    direction = pDataEntry->pppSecuritySecretsDirection;
    protocol =  pDataEntry->pppSecuritySecretsProtocol;
    identity =  pDataEntry->pppSecuritySecretsIdentity;
    secret =    pDataEntry->pppSecuritySecretsSecret;

    printf("(%11u, ",link);

    if  (PPP_SECURITY_SECRETS_DIRECTION_LOCAL_TO_REMOTE == direction)
        {
        printf("  TO_PEER, ");
        }
    else if (PPP_SECURITY_SECRETS_DIRECTION_REMOTE_TO_LOCAL == direction)
        {
        printf("FROM_PEER, ");
        }
    else 
        {
        printf("unrecongnizable direction\n");
        return;
        }

    if  (PPP_SECURITY_PAP_PROTOCOL == protocol)
        {
        printf(" PAP, ");
        }
    else if (PPP_SECURITY_CHAP_MD5_PROTOCOL == protocol)
        {
        printf("CHAP, ");
        }
    else 
        {
        printf("unrecongnizable protocol\n");
        return;
        }

    printf("%8.8s", identity);
    if  ( strlen(identity) > 8 )
        {
        printf("*)");
        }
    else
        {
        printf(" )");
        }
    return;
    }


/*****************************************/

STATUS m2pppSecuritySecretsSnapShow(void)
    {
    PPP_SECURITY_SECRETS_DATA_ENTRY * auxData = NULL;
    PPP_SECURITY_SECRETS_ENTRY * aux = NULL;
    char * secret = NULL;
    UINT32 count1 = 0;
    UINT32 count2 = 0;

    if  (NULL == pppSecretsDataTree)
        {
        printf("pppSecretsDataTree is NULL\n");
        return ERROR;
        }
    else
        {
        printf("\nbegin(sequential snapshot of data tree)\n");
        }
    
    PPP_SECRETS_SEM_TAKE;

    auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
           avlMinimumGet((void *) pppSecretsDataTree);

    while (auxData != NULL)
        {
        count1++;

        secretsDataKeyPrint(auxData);

        secret = auxData->pppSecuritySecretsSecret;
        printf(" [%8.8s", secret);
        if  ( strlen(secret) > 8 )
            {
            printf("*] ");
            }
        else
            {
            printf(" ] ");
            }

        printf("(%11u, ",auxData->pppSecuritySecretsLink);
        printf("%11u)\n",auxData->pppSecuritySecretsIdIndex);

        auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
                  avlSuccessorGet(pppSecretsDataTree,
                                  (GENERIC_ARGUMENT)((void *)auxData),
                                  ldpiDataKeyCompare);

        }
    printf("there are %11u nodes on the data tree\n", count1);

    printf("end(sequential snapshot of data tree)\n");

    if  (NULL == pppSecretsTree)
        {
        printf("pppSecretsTree is NULL\n");
        PPP_SECRETS_SEM_GIVE;
        return ERROR;
        }
    else
        {
        printf("begin(sequential snapshot of primary tree)\n");
        }
    
    aux = (PPP_SECURITY_SECRETS_ENTRY *) 
           avlMinimumGet((void *) pppSecretsTree);

    while (aux != NULL)
        {
        count2++;

        auxData = aux->pSecretsDataEntry;

        printf("(%11u, ",auxData->pppSecuritySecretsLink);
        printf("%11u) ",auxData->pppSecuritySecretsIdIndex);

        secret = auxData->pppSecuritySecretsSecret;
        printf("[%8.8s", secret);
        if  ( strlen(secret) > 8 )
            {
            printf("*] ");
            }
        else
            {
            printf(" ] ");
            }

        secretsDataKeyPrint(auxData);

        printf("\n");

        aux = (PPP_SECURITY_SECRETS_ENTRY *) 
              avlSuccessorGet(pppSecretsTree,
                             (GENERIC_ARGUMENT)((void *)aux),
                             m2pppAgentKeyCompare);
        }

    PPP_SECRETS_SEM_GIVE;

    printf("there are %11u nodes on the primary tree\n", count2);
    if  ( count1 == count2)
        {
        printf("#{nodes on data tree} == #{nodes on primary tree}\n");
        }
    else
        {
        printf("           !@#$5^&*() !@#$5^&*() !@#$5^&*()\n");
        printf("!@#$5^&*() !@#$5^&*() inconsistency !@#$5^&*() !@#$5^&*()\n");
        printf("           !@#$5^&*() !@#$5^&*() !@#$5^&*()\n");
        }
        
    printf("end(sequential snapshot of primary tree)\n\n");

    return OK;

    }
/*****************************************/

STATUS m2pppSecurityDatabaseConsistencyCheck(void)
    {
    PPP_SECURITY_SECRETS_DATA_ENTRY * auxData = NULL;
    PPP_SECURITY_SECRETS_ENTRY * aux = NULL;
    UINT32 count1 = 0;
    UINT32 count2 = 0;
    UINT32 link;
    UINT32 idIndex;
    PPP_SECURITY_SECRETS_DATA_ENTRY keyDataEntry;
    PPP_SECURITY_SECRETS_ENTRY keyEntry;

    if  (NULL == pppSecretsDataTree)
        {
        printf("pppSecretsDataTree is NULL\n");
        return ERROR;
        }
    else
        {
        printf("\nbegin(data tree originated consistency tests)\n");
        }
    
    PPP_SECRETS_SEM_TAKE;

    auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
           avlMinimumGet((void *) pppSecretsDataTree);

    while (auxData != NULL)
        {
        count1++;

        if  (auxData != (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
                        (avlSearch(pppSecretsDataTree,
                                  (GENERIC_ARGUMENT)((void *)auxData),
                                  ldpiDataKeyCompare)))
            {
            printf("inconsistency: test1 for data node pointed by %p failed\n",
                   auxData);
            PPP_SECRETS_SEM_GIVE;
            return ERROR;
            }

        link = auxData->pppSecuritySecretsLink;
        idIndex = auxData->pppSecuritySecretsIdIndex;
        POPULATE_PPP_SECRETS_KEY_ENTRY;

        if  (auxData != ((PPP_SECURITY_SECRETS_ENTRY *) 
                         (avlSearch(pppSecretsTree,
                                    (GENERIC_ARGUMENT)((void *)&keyEntry),
                                    m2pppAgentKeyCompare)))->
                        pSecretsDataEntry)
            {
            printf("inconsistency: test2 for data node pointed by %p failed\n",
                   auxData);
            PPP_SECRETS_SEM_GIVE;
            return ERROR;
            }

        auxData = (PPP_SECURITY_SECRETS_DATA_ENTRY *) 
                  avlSuccessorGet(pppSecretsDataTree,
                                  (GENERIC_ARGUMENT)((void *)auxData),
                                  ldpiDataKeyCompare);

        }
    printf("there are %11u nodes on the data tree\n", count1);

    printf("end(data tree originated consistency tests)\n");

    if  (NULL == pppSecretsTree)
        {
        printf("pppSecretsTree is NULL\n");
        PPP_SECRETS_SEM_GIVE;
        return ERROR;
        }
    else
        {
        printf("begin(primary tree originated consistency tests)\n");
        }
    
    aux = (PPP_SECURITY_SECRETS_ENTRY *) 
           avlMinimumGet((void *) pppSecretsTree);

    while (aux != NULL)
        {
        count2++;

        auxData = aux->pSecretsDataEntry;

        if  (aux != (PPP_SECURITY_SECRETS_ENTRY *)
                    (avlSearch(pppSecretsTree,
                               (GENERIC_ARGUMENT)((void *)aux),
                               m2pppAgentKeyCompare)))
            {
            printf("inconsistency: test1 for primary node ");
            printf("pointed by %p failed\n", aux);
            PPP_SECRETS_SEM_GIVE;
            return ERROR;
            }

        if  (aux->pSecretsDataEntry != 
             (PPP_SECURITY_SECRETS_DATA_ENTRY *)
             (avlSearch(pppSecretsDataTree,
                        (GENERIC_ARGUMENT)((void *)(aux->pSecretsDataEntry)),
                        ldpiDataKeyCompare)))
            {
            printf("inconsistency: test2 for primary node ");
            printf("pointed by %p failed\n", aux);
            PPP_SECRETS_SEM_GIVE;
            return ERROR;
            }

        aux = (PPP_SECURITY_SECRETS_ENTRY *) 
              avlSuccessorGet(pppSecretsTree,
                             (GENERIC_ARGUMENT)((void *)aux),
                             m2pppAgentKeyCompare);
        }

    PPP_SECRETS_SEM_GIVE;

    printf("there are %11u nodes on the primary tree\n", count2);
    if  ( count1 == count2)
        {
        printf("#{nodes on data tree} == #{nodes on primary tree}\n");
        }
    else
        {
        printf("           !@#$5^&*() !@#$5^&*() !@#$5^&*()\n");
        printf("!@#$5^&*() !@#$5^&*() inconsistency !@#$5^&*() !@#$5^&*()\n");
        printf("           !@#$5^&*() !@#$5^&*() !@#$5^&*()\n");
        }
        
    printf("end(primary tree originated consistency tests)\n\n");

    return OK;

    }