nvhardv3.c

wm PNE 3.3 source code, running at more than vxworks6.x version.

if (SNMP_Community_Set_Name(community, (bits8_t *) "public",
                            6, BFL_IS_ALLOC) ||
    SNMP_Community_Set_Sec_Name(community, (bits8_t *) "private_user",
                                12, BFL_IS_ALLOC) ||
    SNMP_Community_Install(community, (bits8_t *) "public", 6)) {
    SNMP_Community_Destroy(community);
    return 1;
    }

if ((community = SNMP_Community_Create()) == 0)
    return 1;

SNMP_Community_Set_Storage(community, ETC_STO_VOL);
SNMP_Community_Set_Status(community, ETC_RS_ACTIVE);

if (SNMP_Community_Set_Name(community, (bits8_t *) "private", 7, BFL_IS_ALLOC) ||
    SNMP_Community_Set_Sec_Name(community, (bits8_t *) "private_user",
                                12, BFL_IS_ALLOC) ||
    SNMP_Community_Install(community, (bits8_t *) "private", 7)) {
    SNMP_Community_Destroy(community);
    return 1;
    }

return 0;
}

#endif /* INSTALL_ENVOY_SNMP_COEXISTENCE */
#endif /* INSTALL_ENVOY_SNMP_V3_TARGET */

#if INSTALL_SNMP_V3_DIFFIE_HELLMAN

/* Default "large prime" and base values */

static char OAKLEY_GROUP_2_PRIME[] = 
   "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
   "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
   "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
   "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
   "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381"
   "FFFFFFFFFFFFFFFF";

static int OAKLEY_GROUP_2_BASE = 2;

/* This routine initilizes usmDHParameters instance values */

/*  Memo to AJS:  Move initialization of usmDHParameters to */
/*     to v3_dh.c so that customers can call this.          */

int _nvhard_read_usmDHparams() 
{
    BN_CTX *bnCtx;

    /* Initialize the global prime, base, pvl and encoded string */

    if ((bnCtx = BN_CTX_new()) == NULL)
        printf ("v3_ini.c\envoy_v3_init:  BN_CTX_new failed!\n");

    SNMP_DH_params.prime = BN_new();
    BN_hex2bn (&SNMP_DH_params.prime, OAKLEY_GROUP_2_PRIME);

    SNMP_DH_params.base = BN_new();
    BN_set_word (SNMP_DH_params.base, OAKLEY_GROUP_2_BASE);

    BN_CTX_free (bnCtx);

    SNMP_DH_params.pvl = 0;

    if (SNMP_DH_encodeParams (SNMP_DH_params.prime,
                              OAKLEY_GROUP_2_BASE,
                              SNMP_DH_params.pvl, 
                              &SNMP_DH_params.encodedString) == 0)  return 1;

    return 0;
}

#endif /* INSTALL_SNMP_V3_DIFFIE_HELLMAN */

sbits32_t
  snmp_v3_group_test(SNMP_PKT_T   *pkt,
                     VB_T         *vbp,
                     SNMP_GROUP_T *current,
                     SNMP_GROUP_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_group_set(SNMP_PKT_T   *pkt,
                    VB_T         *vbp,
                    SNMP_GROUP_T *current,
                    SNMP_GROUP_T *new )
{
}

void
  snmp_v3_group_backout(SNMP_GROUP_T *current,
                        SNMP_GROUP_T *new )
{
}

int
  snmp_v3_group_undo(SNMP_PKT_T   *pkt,
                     VB_T         *vbp,
                     SNMP_GROUP_T *current,
                     SNMP_GROUP_T *save )
{
return(0);
}

void
  snmp_v3_group_finished(void)
{
}

sbits32_t
  snmp_v3_access_test(SNMP_PKT_T    *pkt,
                      VB_T          *vbp,
                      SNMP_ACCESS_T *current,
                      SNMP_ACCESS_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_access_set(SNMP_PKT_T    *pkt,
                     VB_T          *vbp,
                     SNMP_ACCESS_T *current,
                     SNMP_ACCESS_T *new )
{
}

void
  snmp_v3_access_backout(SNMP_ACCESS_T *current,
                         SNMP_ACCESS_T *new )
{
}

int
  snmp_v3_access_undo(SNMP_PKT_T    *pkt,
                      VB_T          *vbp,
                      SNMP_ACCESS_T *current,
                      SNMP_ACCESS_T *save )
{
return(0);
}

void
  snmp_v3_access_finished(void)
{
}

sbits32_t
  snmp_v3_user_test(SNMP_PKT_T  *pkt,
                    VB_T        *vbp,
                    SNMP_USER_T *current,
                    SNMP_USER_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_user_set(SNMP_PKT_T  *pkt,
                   VB_T        *vbp,
                   SNMP_USER_T *current,
                   SNMP_USER_T *new )
{
}

void
  snmp_v3_user_backout(SNMP_USER_T *current,
                       SNMP_USER_T *new )
{
}

int
  snmp_v3_user_undo(SNMP_PKT_T  *pkt,
                    VB_T        *vbp,
                    SNMP_USER_T *current,
                    SNMP_USER_T *save )
{
return(0);
}

void
  snmp_v3_user_finished(void)
{
}

#if (INSTALL_ENVOY_SNMP_V3_TARGET)

sbits32_t
  snmp_v3_taddr_test(SNMP_PKT_T         *pkt,
                     VB_T               *vbp,
                     SNMP_TARGET_ADDR_T *current,
                     SNMP_TARGET_ADDR_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_taddr_set(SNMP_PKT_T         *pkt,
                    VB_T               *vbp,
                    SNMP_TARGET_ADDR_T *current,
                    SNMP_TARGET_ADDR_T *new )
{
}

void
  snmp_v3_taddr_backout(SNMP_TARGET_ADDR_T *current,
                        SNMP_TARGET_ADDR_T *new )
{
}

int
  snmp_v3_taddr_undo(SNMP_PKT_T         *pkt,
                     VB_T               *vbp,
                     SNMP_TARGET_ADDR_T *current,
                     SNMP_TARGET_ADDR_T *save )
{
return(0);
}

void
  snmp_v3_taddr_finished(void)
{
}

sbits32_t
  snmp_v3_tparam_test(SNMP_PKT_T           *pkt,
                      VB_T                 *vbp,
                      SNMP_TARGET_PARAMS_T *current,
                      SNMP_TARGET_PARAMS_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_tparam_set(SNMP_PKT_T           *pkt,
                     VB_T                 *vbp,
                     SNMP_TARGET_PARAMS_T *current,
                     SNMP_TARGET_PARAMS_T *new )
{
}

void
  snmp_v3_tparam_backout(SNMP_TARGET_PARAMS_T *current,
                         SNMP_TARGET_PARAMS_T *new )
{
}

int
  snmp_v3_tparam_undo(SNMP_PKT_T           *pkt,
                      VB_T                 *vbp,
                      SNMP_TARGET_PARAMS_T *current,
                      SNMP_TARGET_PARAMS_T *save )
{
return(0);
}

void
  snmp_v3_tparam_finished(void)
{
}

#if (INSTALL_ENVOY_SNMP_V3_NOTIFY)

sbits32_t
  snmp_v3_notify_test(SNMP_PKT_T    *pkt,
                      VB_T          *vbp,
                      SNMP_NOTIFY_T *current,
                      SNMP_NOTIFY_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_notify_set(SNMP_PKT_T    *pkt,
                     VB_T          *vbp,
                     SNMP_NOTIFY_T *current,
                     SNMP_NOTIFY_T *new )
{
}

void
  snmp_v3_notify_backout(SNMP_NOTIFY_T *current,
                         SNMP_NOTIFY_T *new )
{
}

int
  snmp_v3_notify_undo(SNMP_PKT_T    *pkt,
                      VB_T          *vbp,
                      SNMP_NOTIFY_T *current,
                      SNMP_NOTIFY_T *save )
{
return(0);
}

void
  snmp_v3_notify_finished(void)
{
}

sbits32_t
  snmp_v3_nprof_test(SNMP_PKT_T                   *pkt,
                     VB_T                         *vbp,
                     SNMP_NOTIFY_FILTER_PROFILE_T *current,
                     SNMP_NOTIFY_FILTER_PROFILE_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_nprof_set(SNMP_PKT_T                   *pkt,
                    VB_T                         *vbp,
                    SNMP_NOTIFY_FILTER_PROFILE_T *current,
                    SNMP_NOTIFY_FILTER_PROFILE_T *new )
{
}

void
  snmp_v3_nprof_backout(SNMP_NOTIFY_FILTER_PROFILE_T *current,
                        SNMP_NOTIFY_FILTER_PROFILE_T *new )
{
}

int
  snmp_v3_nprof_undo(SNMP_PKT_T                   *pkt,
                     VB_T                         *vbp,
                     SNMP_NOTIFY_FILTER_PROFILE_T *current,
                     SNMP_NOTIFY_FILTER_PROFILE_T *save )
{
return(0);
}

void
  snmp_v3_nprof_finished(void)
{
}

sbits32_t
  snmp_v3_nfilt_test(SNMP_PKT_T           *pkt,
                     VB_T                 *vbp,
                     SNMP_NOTIFY_FILTER_T *current,
                     SNMP_NOTIFY_FILTER_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_nfilt_set(SNMP_PKT_T           *pkt,
                    VB_T                 *vbp,
                    SNMP_NOTIFY_FILTER_T *current,
                    SNMP_NOTIFY_FILTER_T *new )
{
}

void
  snmp_v3_nfilt_backout(SNMP_NOTIFY_FILTER_T *current,
                        SNMP_NOTIFY_FILTER_T *new )
{
}

int
  snmp_v3_nfilt_undo(SNMP_PKT_T           *pkt,
                     VB_T                 *vbp,
                     SNMP_NOTIFY_FILTER_T *current,
                     SNMP_NOTIFY_FILTER_T *save )
{
return(0);
}

void
  snmp_v3_nfilt_finished(void)
{
}

#endif /* INSTALL_ENVOY_SNMP_V3_NOTIFY */

#if INSTALL_ENVOY_SNMP_V3_PROXY
sbits32_t
  snmp_v3_proxy_test(SNMP_PKT_T   *pkt,
                     VB_T         *vbp,
                     SNMP_PROXY_T *current,
                     SNMP_PROXY_T *new )
{
return(NO_ERROR);
}

void
  snmp_v3_proxy_set(SNMP_PKT_T   *pkt,
                    VB_T         *vbp,
                    SNMP_PROXY_T *current,
                    SNMP_PROXY_T *new )
{
}

void
  snmp_v3_proxy_backout(SNMP_PROXY_T *current,
                        SNMP_PROXY_T *new )
{
}

int
  snmp_v3_proxy_undo(SNMP_PKT_T   *pkt,
                     VB_T         *vbp,
                     SNMP_PROXY_T *current,
                     SNMP_PROXY_T *save )
{
return(0);
}

void
  snmp_v3_proxy_finished(void)
{
}

#endif /* INSTALL_ENVOY_SNMP_V3_PROXY */

#if INSTALL_ENVOY_SNMP_COEXISTENCE
sbits32_t
  snmp_community_test(SNMP_PKT_T       *pkt,
                      VB_T             *vbp,
                      SNMP_COMMUNITY_T *current,
                      SNMP_COMMUNITY_T *new )
{
return(NO_ERROR);
}

void
  snmp_community_set(SNMP_PKT_T      *pkt,
                    VB_T             *vbp,
                    SNMP_COMMUNITY_T *current,
                    SNMP_COMMUNITY_T *new )
{
}

void
  snmp_community_backout(SNMP_COMMUNITY_T *current,
                         SNMP_COMMUNITY_T *new )
{
}

int
  snmp_community_undo(SNMP_PKT_T      *pkt,
                     VB_T             *vbp,
                     SNMP_COMMUNITY_T *current,
                     SNMP_COMMUNITY_T *save )
{
return(0);
}

void
  snmp_community_finished(void)
{
}
#endif /* INSTALL_ENVOY_SNMP_COEXISTENCE */
#endif /* INSTALL_ENVOY_SNMP_V3_TARGET */