开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
usmUser.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：53k
源码类别：

SNMP编程

开发平台：

Unix_Linux

usmUser.c：源码内容
  1. /*
  2.  * usmUser.c
  3.  */
  5. #include <net-snmp/net-snmp-config.h>
  6. #include <stdlib.h>
  8. #if HAVE_STRING_H
  9. #include <string.h>
  10. #else
  11. #include <strings.h>
  12. #endif
  14. #if HAVE_WINSOCK_H
  15. #include <winsock.h>
  16. #endif
  18. #include <net-snmp/net-snmp-includes.h>
  19. #include <net-snmp/agent/net-snmp-agent-includes.h>
  21. #include "util_funcs.h"
  22. #include "usmUser.h"
  24. int usmStatusCheck(struct usmUser *uptr);
  26. struct variable4 usmUser_variables[] = {
  27.     {USMUSERSPINLOCK, ASN_INTEGER, RWRITE, var_usmUser, 1, {1}},
  28.     {USMUSERSECURITYNAME, ASN_OCTET_STR, RONLY, var_usmUser, 3, {2, 1, 3}},
  29.     {USMUSERCLONEFROM, ASN_OBJECT_ID, RWRITE, var_usmUser, 3, {2, 1, 4}},
  30.     {USMUSERAUTHPROTOCOL, ASN_OBJECT_ID, RWRITE, var_usmUser, 3,
  31.      {2, 1, 5}},
  32.     {USMUSERAUTHKEYCHANGE, ASN_OCTET_STR, RWRITE, var_usmUser, 3,
  33.      {2, 1, 6}},
  34.     {USMUSEROWNAUTHKEYCHANGE, ASN_OCTET_STR, RWRITE, var_usmUser, 3,
  35.      {2, 1, 7}},
  36.     {USMUSERPRIVPROTOCOL, ASN_OBJECT_ID, RWRITE, var_usmUser, 3,
  37.      {2, 1, 8}},
  38.     {USMUSERPRIVKEYCHANGE, ASN_OCTET_STR, RWRITE, var_usmUser, 3,
  39.      {2, 1, 9}},
  40.     {USMUSEROWNPRIVKEYCHANGE, ASN_OCTET_STR, RWRITE, var_usmUser, 3,
  41.      {2, 1, 10}},
  42.     {USMUSERPUBLIC, ASN_OCTET_STR, RWRITE, var_usmUser, 3, {2, 1, 11}},
  43.     {USMUSERSTORAGETYPE, ASN_INTEGER, RWRITE, var_usmUser, 3, {2, 1, 12}},
  44.     {USMUSERSTATUS, ASN_INTEGER, RWRITE, var_usmUser, 3, {2, 1, 13}},
  46. };
  48. oid             usmUser_variables_oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 2 };
  51. /*
  52.  * needed for the write_ functions to find the start of the index 
  53.  */
  54. #define USM_MIB_LENGTH 12
  56. static unsigned int usmUserSpinLock = 0;
  58. void
  59. init_usmUser(void)
  60. {
  61.     REGISTER_MIB("snmpv3/usmUser", usmUser_variables, variable4,
  62.                  usmUser_variables_oid);
  63. }
  65. void
  66. init_register_usmUser_context(const char *contextName) {
  67.     register_mib_context("snmpv3/usmUser",
  68.                          (struct variable *) usmUser_variables,
  69.                          sizeof(struct variable4),
  70.                          sizeof(usmUser_variables)/sizeof(struct variable4),
  71.                          usmUser_variables_oid,
  72.                          sizeof(usmUser_variables_oid)/sizeof(oid),
  73.                          DEFAULT_MIB_PRIORITY, 0, 0, NULL,
  74.                          contextName, -1, 0);
  75. }
  77. /*******************************************************************-o-******
  78.  * usm_generate_OID
  79.  *
  80.  * Parameters:
  81.  * *prefix (I) OID prefix to the usmUser table entry.
  82.  *  prefixLen (I)
  83.  * *uptr (I) Pointer to a user in the user list.
  84.  * *length (O) Length of generated index OID.
  85.  *      
  86.  * Returns:
  87.  * Pointer to the OID index for the user (uptr)  -OR-
  88.  * NULL on failure.
  89.  *
  90.  *
  91.  * Generate the index OID for a given usmUser name.  'length' is set to
  92.  * the length of the index OID.
  93.  *
  94.  * Index OID format is:
  95.  *
  96.  *    <...prefix>.<engineID_length>.<engineID>.<user_name_length>.<user_name>
  97.  */
  98. oid            *
  99. usm_generate_OID(oid * prefix, size_t prefixLen, struct usmUser *uptr,
  100.                  size_t * length)
  101. {
  102.     oid            *indexOid;
  103.     int             i;
  105.     *length = 2 + uptr->engineIDLen + strlen(uptr->name) + prefixLen;
  106.     indexOid = (oid *) malloc(*length * sizeof(oid));
  107.     if (indexOid) {
  108.         memmove(indexOid, prefix, prefixLen * sizeof(oid));
  110.         indexOid[prefixLen] = uptr->engineIDLen;
  111.         for (i = 0; i < (int) uptr->engineIDLen; i++)
  112.             indexOid[prefixLen + 1 + i] = (oid) uptr->engineID[i];
  114.         indexOid[prefixLen + uptr->engineIDLen + 1] = strlen(uptr->name);
  115.         for (i = 0; i < (int) strlen(uptr->name); i++)
  116.             indexOid[prefixLen + uptr->engineIDLen + 2 + i] =
  117.                 (oid) uptr->name[i];
  118.     }
  119.     return indexOid;
  121. }                               /* end usm_generate_OID() */
  123. /*
  124.  * usm_parse_oid(): parses an index to the usmTable to break it down into
  125.  * a engineID component and a name component.  The results are stored in:
  126.  * 
  127.  * **engineID:   a newly malloced string.
  128.  * *engineIDLen: The length of the malloced engineID string above.
  129.  * **name:       a newly malloced string.
  130.  * *nameLen:     The length of the malloced name string above.
  131.  * 
  132.  * returns 1 if an error is encountered, or 0 if successful.
  133.  */
  134. int
  135. usm_parse_oid(oid * oidIndex, size_t oidLen,
  136.               unsigned char **engineID, size_t * engineIDLen,
  137.               unsigned char **name, size_t * nameLen)
  138. {
  139.     int             nameL;
  140.     int             engineIDL;
  141.     int             i;
  143.     /*
  144.      * first check the validity of the oid 
  145.      */
  146.     if ((oidLen <= 0) || (!oidIndex)) {
  147.         DEBUGMSGTL(("usmUser",
  148.                     "parse_oid: null oid or zero length oid passed inn"));
  149.         return 1;
  150.     }
  151.     engineIDL = *oidIndex;      /* initial engineID length */
  152.     if ((int) oidLen < engineIDL + 2) {
  153.         DEBUGMSGTL(("usmUser",
  154.                     "parse_oid: invalid oid length: less than the engineIDLenn"));
  155.         return 1;
  156.     }
  157.     nameL = oidIndex[engineIDL + 1];    /* the initial name length */
  158.     if ((int) oidLen != engineIDL + nameL + 2) {
  159.         DEBUGMSGTL(("usmUser",
  160.                     "parse_oid: invalid oid length: length is not exactn"));
  161.         return 1;
  162.     }
  164.     /*
  165.      * its valid, malloc the space and store the results 
  166.      */
  167.     if (engineID == NULL || name == NULL) {
  168.         DEBUGMSGTL(("usmUser",
  169.                     "parse_oid: null storage pointer passed in.n"));
  170.         return 1;
  171.     }
  173.     *engineID = (unsigned char *) malloc(engineIDL);
  174.     if (*engineID == NULL) {
  175.         DEBUGMSGTL(("usmUser",
  176.                     "parse_oid: malloc of the engineID failedn"));
  177.         return 1;
  178.     }
  179.     *engineIDLen = engineIDL;
  181.     *name = (unsigned char *) malloc(nameL + 1);
  182.     if (*name == NULL) {
  183.         DEBUGMSGTL(("usmUser", "parse_oid: malloc of the name failedn"));
  184.         free(*engineID);
  185.         return 1;
  186.     }
  187.     *nameLen = nameL;
  189.     for (i = 0; i < engineIDL; i++) {
  190.         if (oidIndex[i + 1] > 255) {
  191.             goto UPO_parse_error;
  192.         }
  193.         engineID[0][i] = (unsigned char) oidIndex[i + 1];
  194.     }
  196.     for (i = 0; i < nameL; i++) {
  197.         if (oidIndex[i + 2 + engineIDL] > 255) {
  198.           UPO_parse_error:
  199.             free(*engineID);
  200.             free(*name);
  201.             return 1;
  202.         }
  203.         name[0][i] = (unsigned char) oidIndex[i + 2 + engineIDL];
  204.     }
  205.     name[0][nameL] = 0;
  207.     return 0;
  209. }                               /* end usm_parse_oid() */
  211. /*******************************************************************-o-******
  212.  * usm_parse_user
  213.  *
  214.  * Parameters:
  215.  * *name Complete OID indexing a given usmUser entry.
  216.  *  name_length
  217.  *      
  218.  * Returns:
  219.  * Pointer to a usmUser  -OR-
  220.  * NULL if name does not convert to a usmUser.
  221.  * 
  222.  * Convert an (full) OID and return a pointer to a matching user in the
  223.  * user list if one exists.
  224.  */
  225. struct usmUser *
  226. usm_parse_user(oid * name, size_t name_len)
  227. {
  228.     struct usmUser *uptr;
  230.     char           *newName;
  231.     u_char         *engineID;
  232.     size_t          nameLen, engineIDLen;
  234.     /*
  235.      * get the name and engineID out of the incoming oid 
  236.      */
  237.     if (usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  238.                       &engineID, &engineIDLen, (u_char **) & newName,
  239.                       &nameLen))
  240.         return NULL;
  242.     /*
  243.      * Now see if a user exists with these index values 
  244.      */
  245.     uptr = usm_get_user(engineID, engineIDLen, newName);
  246.     free(engineID);
  247.     free(newName);
  249.     return uptr;
  251. }                               /* end usm_parse_user() */
  253. /*******************************************************************-o-******
  254.  * var_usmUser
  255.  *
  256.  * Parameters:
  257.  *   *vp    (I)     Variable-binding associated with this action.
  258.  *   *name    (I/O)   Input name requested, output name found.
  259.  *   *length  (I/O)   Length of input and output oid's.
  260.  *    exact   (I)     TRUE if an exact match was requested.
  261.  *   *var_len (O)     Length of variable or 0 if function returned.
  262.  * (**write_method)   Hook to name a write method (UNUSED).
  263.  *      
  264.  * Returns:
  265.  * Pointer to (char *) containing related data of length 'length'
  266.  *   (May be NULL.)
  267.  *
  268.  *
  269.  * Call-back function passed to the agent in order to return information
  270.  * for the USM MIB tree.
  271.  *
  272.  *
  273.  * If this invocation is not for USMUSERSPINLOCK, lookup user name
  274.  * in the usmUser list.
  275.  *
  276.  * If the name does not match any user and the request
  277.  * is for an exact match, -or- if the usmUser list is empty, create a 
  278.  * new list entry.
  279.  *
  280.  * Finally, service the given USMUSER* var-bind.  A NULL user generally
  281.  * results in a NULL return value.
  282.  */
  283. u_char         *
  284. var_usmUser(struct variable * vp,
  285.             oid * name,
  286.             size_t * length,
  287.             int exact, size_t * var_len, WriteMethod ** write_method)
  288. {
  289.     struct usmUser *uptr = NULL, *nptr, *pptr;
  290.     int             i, rtest, result;
  291.     oid            *indexOid;
  292.     size_t          len;
  294.     /*
  295.      * variables we may use later 
  296.      */
  297.     static long     long_ret;
  298.     static u_char   string[1];
  299.     static oid      objid[2];   /* for .0.0 */
  301.     *write_method = 0;          /* assume it isnt writable for the time being */
  302.     *var_len = sizeof(long_ret);        /* assume an integer and change later if not */
  304.     if (vp->magic != USMUSERSPINLOCK) {
  305.         oid             newname[MAX_OID_LEN];
  306.         len = (*length < vp->namelen) ? *length : vp->namelen;
  307.         rtest = snmp_oid_compare(name, len, vp->name, len);
  308.         if (rtest > 0 ||
  309.             /*
  310.              * (rtest == 0 && !exact && (int) vp->namelen+1 < (int) *length) || 
  311.              */
  312.             (exact == 1 && rtest != 0)) {
  313.             if (var_len)
  314.                 *var_len = 0;
  315.             return 0;
  316.         }
  317.         memset(newname, 0, sizeof(newname));
  318.         if (((int) *length) <= (int) vp->namelen || rtest == -1) {
  319.             /*
  320.              * oid is not within our range yet 
  321.              */
  322.             /*
  323.              * need to fail if not exact 
  324.              */
  325.             uptr = usm_get_userList();
  327.         } else {
  328.             for (nptr = usm_get_userList(), pptr = NULL, uptr = NULL;
  329.                  nptr != NULL; pptr = nptr, nptr = nptr->next) {
  330.                 indexOid =
  331.                     usm_generate_OID(vp->name, vp->namelen, nptr, &len);
  332.                 result = snmp_oid_compare(name, *length, indexOid, len);
  333.                 DEBUGMSGTL(("usmUser", "Checking user: %s - ",
  334.                             nptr->name));
  335.                 for (i = 0; i < (int) nptr->engineIDLen; i++) {
  336.                     DEBUGMSG(("usmUser", " %x", nptr->engineID[i]));
  337.                 }
  338.                 DEBUGMSG(("usmUser", " - %d n  -> OID: ", result));
  339.                 DEBUGMSGOID(("usmUser", indexOid, len));
  340.                 DEBUGMSG(("usmUser", "n"));
  342.                 free(indexOid);
  344.                 if (exact) {
  345.                     if (result == 0) {
  346.                         uptr = nptr;
  347.                     }
  348.                 } else {
  349.                     if (result == 0) {
  350.                         /*
  351.                          * found an exact match.  Need the next one for !exact 
  352.                          */
  353.                         uptr = nptr->next;
  354.                     } else if (result == -1) {
  355.                         uptr = nptr;
  356.                         break;
  357.                     }
  358.                 }
  359.             }
  360.         }                       /* endif -- name <= vp->name */
  362.         /*
  363.          * if uptr is NULL and exact we need to continue for creates 
  364.          */
  365.         if (uptr == NULL && !exact)
  366.             return (NULL);
  368.         if (uptr) {
  369.             indexOid = usm_generate_OID(vp->name, vp->namelen, uptr, &len);
  370.             *length = len;
  371.             memmove(name, indexOid, len * sizeof(oid));
  372.             DEBUGMSGTL(("usmUser", "Found user: %s - ", uptr->name));
  373.             for (i = 0; i < (int) uptr->engineIDLen; i++) {
  374.                 DEBUGMSG(("usmUser", " %x", uptr->engineID[i]));
  375.             }
  376.             DEBUGMSG(("usmUser", "n  -> OID: "));
  377.             DEBUGMSGOID(("usmUser", indexOid, len));
  378.             DEBUGMSG(("usmUser", "n"));
  380.             free(indexOid);
  381.         }
  382.     } else {
  383.         if (header_generic(vp, name, length, exact, var_len, write_method))
  384.             return 0;
  385.     }                           /* endif -- vp->magic != USMUSERSPINLOCK */
  387.     switch (vp->magic) {
  388.     case USMUSERSPINLOCK:
  389.         *write_method = write_usmUserSpinLock;
  390.         long_ret = usmUserSpinLock;
  391.         return (unsigned char *) &long_ret;
  393.     case USMUSERSECURITYNAME:
  394.         if (uptr) {
  395.             *var_len = strlen(uptr->secName);
  396.             return (unsigned char *) uptr->secName;
  397.         }
  398.         return NULL;
  400.     case USMUSERCLONEFROM:
  401.         *write_method = write_usmUserCloneFrom;
  402.         if (uptr) {
  403.             objid[0] = 0;       /* "When this object is read, the ZeroDotZero OID */
  404.             objid[1] = 0;       /*  is returned." */
  405.             *var_len = sizeof(oid) * 2;
  406.             return (unsigned char *) objid;
  407.         }
  408.         return NULL;
  410.     case USMUSERAUTHPROTOCOL:
  411.         *write_method = write_usmUserAuthProtocol;
  412.         if (uptr) {
  413.             *var_len = uptr->authProtocolLen * sizeof(oid);
  414.             return (u_char *) uptr->authProtocol;
  415.         }
  416.         return NULL;
  418.     case USMUSERAUTHKEYCHANGE:
  419.     case USMUSEROWNAUTHKEYCHANGE:
  420.         /*
  421.          * we treat these the same, and let the calling module
  422.          * distinguish between them 
  423.          */
  424.         *write_method = write_usmUserAuthKeyChange;
  425.         if (uptr) {
  426.             *string = 0;        /* always return a NULL string */
  427.             *var_len = 0;
  428.             return string;
  429.         }
  430.         return NULL;
  432.     case USMUSERPRIVPROTOCOL:
  433.         *write_method = write_usmUserPrivProtocol;
  434.         if (uptr) {
  435.             *var_len = uptr->privProtocolLen * sizeof(oid);
  436.             return (u_char *) uptr->privProtocol;
  437.         }
  438.         return NULL;
  440.     case USMUSERPRIVKEYCHANGE:
  441.     case USMUSEROWNPRIVKEYCHANGE:
  442.         /*
  443.          * we treat these the same, and let the calling module
  444.          * distinguish between them 
  445.          */
  446.         *write_method = write_usmUserPrivKeyChange;
  447.         if (uptr) {
  448.             *string = 0;        /* always return a NULL string */
  449.             *var_len = 0;
  450.             return string;
  451.         }
  452.         return NULL;
  454.     case USMUSERPUBLIC:
  455.         *write_method = write_usmUserPublic;
  456.         if (uptr) {
  457.             if (uptr->userPublicString) {
  458.                 *var_len = strlen((char *) uptr->userPublicString);
  459.                 return uptr->userPublicString;
  460.             }
  461.             *string = 0;
  462.             *var_len = 0;       /* return an empty string if the public
  463.                                  * string hasn't been defined yet */
  464.             return string;
  465.         }
  466.         return NULL;
  468.     case USMUSERSTORAGETYPE:
  469.         *write_method = write_usmUserStorageType;
  470.         if (uptr) {
  471.             long_ret = uptr->userStorageType;
  472.             return (unsigned char *) &long_ret;
  473.         }
  474.         return NULL;
  476.     case USMUSERSTATUS:
  477.         *write_method = write_usmUserStatus;
  478.         if (uptr) {
  479.             long_ret = uptr->userStatus;
  480.             return (unsigned char *) &long_ret;
  481.         }
  482.         return NULL;
  484.     default:
  485.         DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_usmUsern",
  486.                     vp->magic));
  487.     }
  488.     return 0;
  490. }                               /* end var_usmUser() */
  492. /*
  493.  * write_usmUserSpinLock(): called when a set is performed on the
  494.  * usmUserSpinLock object 
  495.  */
  496. int
  497. write_usmUserSpinLock(int action,
  498.                       u_char * var_val,
  499.                       u_char var_val_type,
  500.                       size_t var_val_len,
  501.                       u_char * statP, oid * name, size_t name_len)
  502. {
  503.     /*
  504.      * variables we may use later 
  505.      */
  506.     static long     long_ret;
  508.     if (var_val_type != ASN_INTEGER) {
  509.         DEBUGMSGTL(("usmUser",
  510.                     "write to usmUserSpinLock not ASN_INTEGERn"));
  511.         return SNMP_ERR_WRONGTYPE;
  512.     }
  513.     if (var_val_len > sizeof(long_ret)) {
  514.         DEBUGMSGTL(("usmUser", "write to usmUserSpinLock: bad lengthn"));
  515.         return SNMP_ERR_WRONGLENGTH;
  516.     }
  517.     long_ret = *((long *) var_val);
  518.     if (long_ret != (long) usmUserSpinLock)
  519.         return SNMP_ERR_INCONSISTENTVALUE;
  520.     if (action == COMMIT) {
  521.         if (usmUserSpinLock == 2147483647)
  522.             usmUserSpinLock = 0;
  523.         else
  524.             usmUserSpinLock++;
  525.     }
  526.     return SNMP_ERR_NOERROR;
  527. }                               /* end write_usmUserSpinLock() */
  529. /*******************************************************************-o-******
  530.  * write_usmUserCloneFrom
  531.  *
  532.  * Parameters:
  533.  *  action
  534.  * *var_val
  535.  *  var_val_type
  536.  *  var_val_len
  537.  * *statP (UNUSED)
  538.  * *name OID of user to clone from.
  539.  *  name_len
  540.  *      
  541.  * Returns:
  542.  * SNMP_ERR_NOERROR On success  -OR-  If user exists
  543.  *   and has already been cloned.
  544.  * SNMP_ERR_GENERR Local function call failures.
  545.  * SNMP_ERR_INCONSISTENTNAME 'name' does not exist in user list
  546.  *   -OR-  user to clone from != RS_ACTIVE.
  547.  * SNMP_ERR_WRONGLENGTH OID length > than local buffer size.
  548.  * SNMP_ERR_WRONGTYPE ASN_OBJECT_ID is wrong.
  549.  *
  550.  *
  551.  * XXX:  should handle action=UNDO's.
  552.  */
  553. int
  554. write_usmUserCloneFrom(int action,
  555.                        u_char * var_val,
  556.                        u_char var_val_type,
  557.                        size_t var_val_len,
  558.                        u_char * statP, oid * name, size_t name_len)
  559. {
  560.     struct usmUser *uptr, *cloneFrom;
  562.     if (action == RESERVE1) {
  563.         if (var_val_type != ASN_OBJECT_ID) {
  564.             DEBUGMSGTL(("usmUser",
  565.                         "write to usmUserCloneFrom not ASN_OBJECT_IDn"));
  566.             return SNMP_ERR_WRONGTYPE;
  567.         }
  568.         if (var_val_len > USM_LENGTH_OID_MAX * sizeof(oid) ||
  569.             var_val_len % sizeof(oid) != 0) {
  570.             DEBUGMSGTL(("usmUser",
  571.                         "write to usmUserCloneFrom: bad lengthn"));
  572.             return SNMP_ERR_WRONGLENGTH;
  573.         }
  574.     } else if (action == RESERVE2) {
  575.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  576.             /*
  577.              * We don't allow creations here.  
  578.              */
  579.             return SNMP_ERR_INCONSISTENTNAME;
  580.         }
  582.         /*
  583.          * Has the user already been cloned?  If so, writes to this variable
  584.          * are defined to have no effect and to produce no error.  
  585.          */
  586.         if (uptr->cloneFrom != NULL) {
  587.             return SNMP_ERR_NOERROR;
  588.         }
  590.         cloneFrom =
  591.             usm_parse_user((oid *) var_val, var_val_len / sizeof(oid));
  592.         if (cloneFrom == NULL || cloneFrom->userStatus != SNMP_ROW_ACTIVE) {
  593.             return SNMP_ERR_INCONSISTENTNAME;
  594.         }
  595.         uptr->cloneFrom = snmp_duplicate_objid((oid *) var_val,
  596.                                                var_val_len / sizeof(oid));
  597.         usm_cloneFrom_user(cloneFrom, uptr);
  599.         if (usmStatusCheck(uptr) && uptr->userStatus == SNMP_ROW_NOTREADY) {
  600.             uptr->userStatus = SNMP_ROW_NOTINSERVICE;
  601.         }
  602.     }
  604.     return SNMP_ERR_NOERROR;
  605. }
  607. /*******************************************************************-o-******
  608.  * write_usmUserAuthProtocol
  609.  *
  610.  * Parameters:
  611.  *  action
  612.  * *var_val OID of auth transform to set.
  613.  *  var_val_type
  614.  *  var_val_len
  615.  * *statP
  616.  * *name OID of user upon which to perform set operation.
  617.  *  name_len
  618.  *      
  619.  * Returns:
  620.  * SNMP_ERR_NOERROR On success.
  621.  * SNMP_ERR_GENERR
  622.  * SNMP_ERR_INCONSISTENTVALUE
  623.  * SNMP_ERR_NOSUCHNAME
  624.  * SNMP_ERR_WRONGLENGTH
  625.  * SNMP_ERR_WRONGTYPE
  626.  */
  627. int
  628. write_usmUserAuthProtocol(int action,
  629.                           u_char * var_val,
  630.                           u_char var_val_type,
  631.                           size_t var_val_len,
  632.                           u_char * statP, oid * name, size_t name_len)
  633. {
  634.     static oid     *optr;
  635.     static size_t   olen;
  636.     static int      resetOnFail;
  637.     struct usmUser *uptr;
  639.     if (action == RESERVE1) {
  640.         resetOnFail = 0;
  641.         if (var_val_type != ASN_OBJECT_ID) {
  642.             DEBUGMSGTL(("usmUser",
  643.                         "write to usmUserAuthProtocol not ASN_OBJECT_IDn"));
  644.             return SNMP_ERR_WRONGTYPE;
  645.         }
  646.         if (var_val_len > USM_LENGTH_OID_MAX * sizeof(oid) ||
  647.             var_val_len % sizeof(oid) != 0) {
  648.             DEBUGMSGTL(("usmUser",
  649.                         "write to usmUserAuthProtocol: bad lengthn"));
  650.             return SNMP_ERR_WRONGLENGTH;
  651.         }
  652.     } else if (action == RESERVE2) {
  653.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  654.             return SNMP_ERR_INCONSISTENTNAME;
  655.         }
  657.         if (uptr->userStatus == RS_ACTIVE
  658.             || uptr->userStatus == RS_NOTREADY
  659.             || uptr->userStatus == RS_NOTINSERVICE) {
  660.             /*
  661.              * The authProtocol is already set.  It is only legal to CHANGE it
  662.              * to usmNoAuthProtocol...  
  663.              */
  664.             if (snmp_oid_compare
  665.                 ((oid *) var_val, var_val_len / sizeof(oid),
  666.                  usmNoAuthProtocol,
  667.                  sizeof(usmNoAuthProtocol) / sizeof(oid)) == 0) {
  668.                 /*
  669.                  * ... and then only if the privProtocol is equal to
  670.                  * usmNoPrivProtocol.  
  671.                  */
  672.                 if (snmp_oid_compare
  673.                     (uptr->privProtocol, uptr->privProtocolLen,
  674.                      usmNoPrivProtocol,
  675.                      sizeof(usmNoPrivProtocol) / sizeof(oid)) != 0) {
  676.                     return SNMP_ERR_INCONSISTENTVALUE;
  677.                 }
  678.                 optr = uptr->authProtocol;
  679.                 olen = uptr->authProtocolLen;
  680.                 resetOnFail = 1;
  681.                 uptr->authProtocol = snmp_duplicate_objid((oid *) var_val,
  682.                                                           var_val_len /
  683.                                                           sizeof(oid));
  684.                 if (uptr->authProtocol == NULL) {
  685.                     return SNMP_ERR_RESOURCEUNAVAILABLE;
  686.                 }
  687.                 uptr->authProtocolLen = var_val_len / sizeof(oid);
  688.             } else
  689.                 if (snmp_oid_compare
  690.                     ((oid *) var_val, var_val_len / sizeof(oid),
  691.                      uptr->authProtocol, uptr->authProtocolLen) == 0) {
  692.                 /*
  693.                  * But it's also okay to set it to the same thing as it
  694.                  * currently is.  
  695.                  */
  696.                 return SNMP_ERR_NOERROR;
  697.             } else {
  698.                 return SNMP_ERR_INCONSISTENTVALUE;
  699.             }
  700.         } else {
  701.             /*
  702.              * This row is under creation.  It's okay to set
  703.              * usmUserAuthProtocol to any valid authProtocol but it will be
  704.              * overwritten when usmUserCloneFrom is set (so don't write it if
  705.              * that has already been set).  
  706.              */
  708.             if (snmp_oid_compare
  709.                 ((oid *) var_val, var_val_len / sizeof(oid),
  710.                  usmNoAuthProtocol,
  711.                  sizeof(usmNoAuthProtocol) / sizeof(oid)) == 0
  712. #ifndef DISABLE_MD5
  713.                 || snmp_oid_compare((oid *) var_val,
  714.                                     var_val_len / sizeof(oid),
  715.                                     usmHMACMD5AuthProtocol,
  716.                                     sizeof(usmHMACMD5AuthProtocol) /
  717.                                     sizeof(oid)) == 0
  718. #endif
  719.                 || snmp_oid_compare((oid *) var_val,
  720.                                     var_val_len / sizeof(oid),
  721.                                     usmHMACSHA1AuthProtocol,
  722.                                     sizeof(usmHMACSHA1AuthProtocol) /
  723.                                     sizeof(oid)) == 0) {
  724.                 if (uptr->cloneFrom != NULL) {
  725.                     optr = uptr->authProtocol;
  726.                     olen = uptr->authProtocolLen;
  727.                     resetOnFail = 1;
  728.                     uptr->authProtocol =
  729.                         snmp_duplicate_objid((oid *) var_val,
  730.                                              var_val_len / sizeof(oid));
  731.                     if (uptr->authProtocol == NULL) {
  732.                         return SNMP_ERR_RESOURCEUNAVAILABLE;
  733.                     }
  734.                     uptr->authProtocolLen = var_val_len / sizeof(oid);
  735.                 }
  736.             } else {
  737.                 /*
  738.                  * Unknown authentication protocol.  
  739.                  */
  740.                 return SNMP_ERR_WRONGVALUE;
  741.             }
  742.         }
  743.     } else if (action == COMMIT) {
  744.         SNMP_FREE(optr);
  745.         optr = NULL;
  746.     } else if (action == FREE || action == UNDO) {
  747.         if ((uptr = usm_parse_user(name, name_len)) != NULL) {
  748.             if (resetOnFail) {
  749.                 SNMP_FREE(uptr->authProtocol);
  750.                 uptr->authProtocol = optr;
  751.                 uptr->authProtocolLen = olen;
  752.             }
  753.         }
  754.     }
  755.     return SNMP_ERR_NOERROR;
  756. }                               /* end write_usmUserAuthProtocol() */
  758. /*******************************************************************-o-******
  759.  * write_usmUserAuthKeyChange
  760.  *
  761.  * Parameters:
  762.  *  action
  763.  * *var_val Octet string representing new KeyChange value.
  764.  *  var_val_type
  765.  *  var_val_len
  766.  * *statP (UNUSED)
  767.  * *name OID of user upon which to perform set operation.
  768.  *  name_len
  769.  *      
  770.  * Returns:
  771.  * SNMP_ERR_NOERR Success.
  772.  * SNMP_ERR_WRONGTYPE
  773.  * SNMP_ERR_WRONGLENGTH
  774.  * SNMP_ERR_NOSUCHNAME
  775.  * SNMP_ERR_GENERR
  776.  *
  777.  * Note: This function handles both the usmUserAuthKeyChange and
  778.  *       usmUserOwnAuthKeyChange objects.  We are not passed the name
  779.  *       of the user requseting the keychange, so we leave this to the
  780.  *       calling module to verify when and if we should be called.  To
  781.  *       change this would require a change in the mib module API to
  782.  *       pass in the securityName requesting the change.
  783.  *
  784.  * XXX:  should handle action=UNDO's.
  785.  */
  786. int
  787. write_usmUserAuthKeyChange(int action,
  788.                            u_char * var_val,
  789.                            u_char var_val_type,
  790.                            size_t var_val_len,
  791.                            u_char * statP, oid * name, size_t name_len)
  792. {
  793.     struct usmUser *uptr;
  794.     unsigned char   buf[SNMP_MAXBUF_SMALL];
  795.     size_t          buflen = SNMP_MAXBUF_SMALL;
  796.     const char      fnAuthKey[] = "write_usmUserAuthKeyChange";
  797.     const char      fnOwnAuthKey[] = "write_usmUserOwnAuthKeyChange";
  798.     const char     *fname;
  799.     static unsigned char *oldkey;
  800.     static size_t   oldkeylen;
  801.     static int      resetOnFail;
  803.     if (name[USM_MIB_LENGTH - 1] == 6) {
  804.         fname = fnAuthKey;
  805.     } else {
  806.         fname = fnOwnAuthKey;
  807.     }
  809.     if (action == RESERVE1) {
  810.         resetOnFail = 0;
  811.         if (var_val_type != ASN_OCTET_STR) {
  812.             DEBUGMSGTL(("usmUser", "write to %s not ASN_OCTET_STRn",
  813.                         fname));
  814.             return SNMP_ERR_WRONGTYPE;
  815.         }
  816.         if (var_val_len == 0) {
  817.             return SNMP_ERR_WRONGLENGTH;
  818.         }
  819.     } else if (action == RESERVE2) {
  820.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  821.             return SNMP_ERR_INCONSISTENTNAME;
  822.         } else {
  823. #ifndef DISABLE_MD5
  824.             if (snmp_oid_compare(uptr->authProtocol, uptr->authProtocolLen,
  825.                                  usmHMACMD5AuthProtocol,
  826.                                  sizeof(usmHMACMD5AuthProtocol) /
  827.                                  sizeof(oid)) == 0) {
  828.                 if (var_val_len != 0 && var_val_len != 32) {
  829.                     return SNMP_ERR_WRONGLENGTH;
  830.                 }
  831.             } else
  832. #endif
  833.                 if (snmp_oid_compare
  834.                     (uptr->authProtocol, uptr->authProtocolLen,
  835.                      usmHMACSHA1AuthProtocol,
  836.                      sizeof(usmHMACSHA1AuthProtocol) / sizeof(oid)) == 0) {
  837.                 if (var_val_len != 0 && var_val_len != 40) {
  838.                     return SNMP_ERR_WRONGLENGTH;
  839.                 }
  840.             }
  841.         }
  842.     } else if (action == ACTION) {
  843.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  844.             return SNMP_ERR_INCONSISTENTNAME;
  845.         }
  846.         if (uptr->cloneFrom == NULL) {
  847.             return SNMP_ERR_INCONSISTENTNAME;
  848.         }
  849.         if (snmp_oid_compare(uptr->authProtocol, uptr->authProtocolLen,
  850.                              usmNoAuthProtocol,
  851.                              sizeof(usmNoAuthProtocol) / sizeof(oid)) ==
  852.             0) {
  853.             /*
  854.              * "When the value of the corresponding usmUserAuthProtocol is
  855.              * usmNoAuthProtocol, then a set is successful, but effectively
  856.              * is a no-op."  
  857.              */
  858.             DEBUGMSGTL(("usmUser",
  859.                         "%s: noAuthProtocol keyChange... success!n",
  860.                         fname));
  861.             return SNMP_ERR_NOERROR;
  862.         }
  864.         /*
  865.          * Change the key.  
  866.          */
  867.         DEBUGMSGTL(("usmUser", "%s: changing auth key for user %sn",
  868.                     fname, uptr->secName));
  870.         if (decode_keychange(uptr->authProtocol, uptr->authProtocolLen,
  871.                              uptr->authKey, uptr->authKeyLen,
  872.                              var_val, var_val_len,
  873.                              buf, &buflen) != SNMPERR_SUCCESS) {
  874.             DEBUGMSGTL(("usmUser", "%s: ... failedn", fname));
  875.             return SNMP_ERR_GENERR;
  876.         }
  877.         DEBUGMSGTL(("usmUser", "%s: ... succeededn", fname));
  878.         resetOnFail = 1;
  879.         oldkey = uptr->authKey;
  880.         oldkeylen = uptr->authKeyLen;
  881.         memdup(&uptr->authKey, buf, buflen);
  882.         if (uptr->authKey == NULL) {
  883.             return SNMP_ERR_RESOURCEUNAVAILABLE;
  884.         }
  885.         uptr->authKeyLen = buflen;
  886.     } else if (action == COMMIT) {
  887.         SNMP_FREE(oldkey);
  888.         oldkey = NULL;
  889.     } else if (action == UNDO) {
  890.         if ((uptr = usm_parse_user(name, name_len)) != NULL && resetOnFail) {
  891.             SNMP_FREE(uptr->authKey);
  892.             uptr->authKey = oldkey;
  893.             uptr->authKeyLen = oldkeylen;
  894.         }
  895.     }
  897.     return SNMP_ERR_NOERROR;
  898. }                               /* end write_usmUserAuthKeyChange() */
  900. int
  901. write_usmUserPrivProtocol(int action,
  902.                           u_char * var_val,
  903.                           u_char var_val_type,
  904.                           size_t var_val_len,
  905.                           u_char * statP, oid * name, size_t name_len)
  906. {
  907.     static oid     *optr;
  908.     static size_t   olen;
  909.     static int      resetOnFail;
  910.     struct usmUser *uptr;
  912.     if (action == RESERVE1) {
  913.         resetOnFail = 0;
  914.         if (var_val_type != ASN_OBJECT_ID) {
  915.             DEBUGMSGTL(("usmUser",
  916.                         "write to usmUserPrivProtocol not ASN_OBJECT_IDn"));
  917.             return SNMP_ERR_WRONGTYPE;
  918.         }
  919.         if (var_val_len > USM_LENGTH_OID_MAX * sizeof(oid) ||
  920.             var_val_len % sizeof(oid) != 0) {
  921.             DEBUGMSGTL(("usmUser",
  922.                         "write to usmUserPrivProtocol: bad lengthn"));
  923.             return SNMP_ERR_WRONGLENGTH;
  924.         }
  925.     } else if (action == RESERVE2) {
  926.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  927.             return SNMP_ERR_INCONSISTENTNAME;
  928.         }
  930.         if (uptr->userStatus == RS_ACTIVE
  931.             || uptr->userStatus == RS_NOTREADY
  932.             || uptr->userStatus == RS_NOTINSERVICE) {
  933.             /*
  934.              * The privProtocol is already set.  It is only legal to CHANGE it
  935.              * to usmNoPrivProtocol.  
  936.              */
  937.             if (snmp_oid_compare
  938.                 ((oid *) var_val, var_val_len / sizeof(oid),
  939.                  usmNoPrivProtocol,
  940.                  sizeof(usmNoPrivProtocol) / sizeof(oid)) == 0) {
  941.                 resetOnFail = 1;
  942.                 optr = uptr->privProtocol;
  943.                 olen = uptr->privProtocolLen;
  944.                 uptr->privProtocol = snmp_duplicate_objid((oid *) var_val,
  945.                                                           var_val_len /
  946.                                                           sizeof(oid));
  947.                 if (uptr->privProtocol == NULL) {
  948.                     return SNMP_ERR_RESOURCEUNAVAILABLE;
  949.                 }
  950.                 uptr->privProtocolLen = var_val_len / sizeof(oid);
  951.             } else
  952.                 if (snmp_oid_compare
  953.                     ((oid *) var_val, var_val_len / sizeof(oid),
  954.                      uptr->privProtocol, uptr->privProtocolLen) == 0) {
  955.                 /*
  956.                  * But it's also okay to set it to the same thing as it
  957.                  * currently is.  
  958.                  */
  959.                 return SNMP_ERR_NOERROR;
  960.             } else {
  961.                 return SNMP_ERR_INCONSISTENTVALUE;
  962.             }
  963.         } else {
  964.             /*
  965.              * This row is under creation.  It's okay to set
  966.              * usmUserPrivProtocol to any valid privProtocol with the proviso
  967.              * that if usmUserAuthProtocol is set to usmNoAuthProtocol, it may
  968.              * only be set to usmNoPrivProtocol.  The value will be overwritten
  969.              * when usmUserCloneFrom is set (so don't write it if that has
  970.              * already been set).  
  971.              */
  972.             if (snmp_oid_compare(uptr->authProtocol, uptr->authProtocolLen,
  973.                                  usmNoAuthProtocol,
  974.                                  sizeof(usmNoAuthProtocol) /
  975.                                  sizeof(oid)) == 0) {
  976.                 if (snmp_oid_compare
  977.                     ((oid *) var_val, var_val_len / sizeof(oid),
  978.                      usmNoPrivProtocol,
  979.                      sizeof(usmNoPrivProtocol) / sizeof(oid)) != 0) {
  980.                     return SNMP_ERR_INCONSISTENTVALUE;
  981.                 }
  982.             } else {
  983.                 if (snmp_oid_compare
  984.                     ((oid *) var_val, var_val_len / sizeof(oid),
  985.                      usmNoPrivProtocol,
  986.                      sizeof(usmNoPrivProtocol) / sizeof(oid)) != 0
  987. #ifndef DISABLE_DES
  988.                     && snmp_oid_compare((oid *) var_val,
  989.                                         var_val_len / sizeof(oid),
  990.                                         usmDESPrivProtocol,
  991.                                         sizeof(usmDESPrivProtocol) /
  992.                                         sizeof(oid) != 0)
  993. #endif
  994.                     && snmp_oid_compare((oid *) var_val,
  995.                                         var_val_len / sizeof(oid),
  996.                                         usmAESPrivProtocol,
  997.                                         sizeof(usmAESPrivProtocol) /
  998.                                         sizeof(oid) != 0)) {
  999.                     return SNMP_ERR_WRONGVALUE;
  1000.                 }
  1001.             }
  1002.             resetOnFail = 1;
  1003.             optr = uptr->privProtocol;
  1004.             olen = uptr->privProtocolLen;
  1005.             uptr->privProtocol = snmp_duplicate_objid((oid *) var_val,
  1006.                                                       var_val_len /
  1007.                                                       sizeof(oid));
  1008.             if (uptr->privProtocol == NULL) {
  1009.                 return SNMP_ERR_RESOURCEUNAVAILABLE;
  1010.             }
  1011.             uptr->privProtocolLen = var_val_len / sizeof(oid);
  1012.         }
  1013.     } else if (action == COMMIT) {
  1014.         SNMP_FREE(optr);
  1015.         optr = NULL;
  1016.     } else if (action == FREE || action == UNDO) {
  1017.         if ((uptr = usm_parse_user(name, name_len)) != NULL) {
  1018.             if (resetOnFail) {
  1019.                 SNMP_FREE(uptr->privProtocol);
  1020.                 uptr->privProtocol = optr;
  1021.                 uptr->privProtocolLen = olen;
  1022.             }
  1023.         }
  1024.     }
  1026.     return SNMP_ERR_NOERROR;
  1027. }                               /* end write_usmUserPrivProtocol() */
  1029. /*
  1030.  * Note: This function handles both the usmUserPrivKeyChange and
  1031.  *       usmUserOwnPrivKeyChange objects.  We are not passed the name
  1032.  *       of the user requseting the keychange, so we leave this to the
  1033.  *       calling module to verify when and if we should be called.  To
  1034.  *       change this would require a change in the mib module API to
  1035.  *       pass in the securityName requesting the change.
  1036.  *
  1037.  */
  1038. int
  1039. write_usmUserPrivKeyChange(int action,
  1040.                            u_char * var_val,
  1041.                            u_char var_val_type,
  1042.                            size_t var_val_len,
  1043.                            u_char * statP, oid * name, size_t name_len)
  1044. {
  1045.     struct usmUser *uptr;
  1046.     unsigned char   buf[SNMP_MAXBUF_SMALL];
  1047.     size_t          buflen = SNMP_MAXBUF_SMALL;
  1048.     const char      fnPrivKey[] = "write_usmUserPrivKeyChange";
  1049.     const char      fnOwnPrivKey[] = "write_usmUserOwnPrivKeyChange";
  1050.     const char     *fname;
  1051.     static unsigned char *oldkey;
  1052.     static size_t   oldkeylen;
  1053.     static int      resetOnFail;
  1055.     if (name[USM_MIB_LENGTH - 1] == 9) {
  1056.         fname = fnPrivKey;
  1057.     } else {
  1058.         fname = fnOwnPrivKey;
  1059.     }
  1061.     if (action == RESERVE1) {
  1062.         resetOnFail = 0;
  1063.         if (var_val_type != ASN_OCTET_STR) {
  1064.             DEBUGMSGTL(("usmUser", "write to %s not ASN_OCTET_STRn",
  1065.                         fname));
  1066.             return SNMP_ERR_WRONGTYPE;
  1067.         }
  1068.         if (var_val_len == 0) {
  1069.             return SNMP_ERR_WRONGLENGTH;
  1070.         }
  1071.     } else if (action == RESERVE2) {
  1072.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  1073.             return SNMP_ERR_INCONSISTENTNAME;
  1074.         } else {
  1075. #ifndef DISABLE_DES
  1076.             if (snmp_oid_compare(uptr->privProtocol, uptr->privProtocolLen,
  1077.                                  usmDESPrivProtocol,
  1078.                                  sizeof(usmDESPrivProtocol) /
  1079.                                  sizeof(oid)) == 0) {
  1080.                 if (var_val_len != 0 && var_val_len != 32) {
  1081.                     return SNMP_ERR_WRONGLENGTH;
  1082.                 }
  1083.             }
  1084. #endif
  1085.             if (snmp_oid_compare(uptr->privProtocol, uptr->privProtocolLen,
  1086.                                  usmAESPrivProtocol,
  1087.                                  sizeof(usmAESPrivProtocol) /
  1088.                                  sizeof(oid)) == 0) {
  1089.                 if (var_val_len != 0 && var_val_len != 32) {
  1090.                     return SNMP_ERR_WRONGLENGTH;
  1091.                 }
  1092.             }
  1093.         }
  1094.     } else if (action == ACTION) {
  1095.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  1096.             return SNMP_ERR_INCONSISTENTNAME;
  1097.         }
  1098.         if (uptr->cloneFrom == NULL) {
  1099.             return SNMP_ERR_INCONSISTENTNAME;
  1100.         }
  1101.         if (snmp_oid_compare(uptr->privProtocol, uptr->privProtocolLen,
  1102.                              usmNoPrivProtocol,
  1103.                              sizeof(usmNoPrivProtocol) / sizeof(oid)) ==
  1104.             0) {
  1105.             /*
  1106.              * "When the value of the corresponding usmUserPrivProtocol is
  1107.              * usmNoPrivProtocol, then a set is successful, but effectively
  1108.              * is a no-op."  
  1109.              */
  1110.             DEBUGMSGTL(("usmUser",
  1111.                         "%s: noPrivProtocol keyChange... success!n",
  1112.                         fname));
  1113.             return SNMP_ERR_NOERROR;
  1114.         }
  1116.         /*
  1117.          * Change the key. 
  1118.          */
  1119.         DEBUGMSGTL(("usmUser", "%s: changing priv key for user %sn",
  1120.                     fname, uptr->secName));
  1122.         if (decode_keychange(uptr->authProtocol, uptr->authProtocolLen,
  1123.                              uptr->privKey, uptr->privKeyLen,
  1124.                              var_val, var_val_len,
  1125.                              buf, &buflen) != SNMPERR_SUCCESS) {
  1126.             DEBUGMSGTL(("usmUser", "%s: ... failedn", fname));
  1127.             return SNMP_ERR_GENERR;
  1128.         }
  1129.         DEBUGMSGTL(("usmUser", "%s: ... succeededn", fname));
  1130.         resetOnFail = 1;
  1131.         oldkey = uptr->privKey;
  1132.         oldkeylen = uptr->privKeyLen;
  1133.         memdup(&uptr->privKey, buf, buflen);
  1134.         if (uptr->privKey == NULL) {
  1135.             return SNMP_ERR_RESOURCEUNAVAILABLE;
  1136.         }
  1137.         uptr->privKeyLen = buflen;
  1138.     } else if (action == COMMIT) {
  1139.         SNMP_FREE(oldkey);
  1140.         oldkey = NULL;
  1141.     } else if (action == UNDO) {
  1142.         if ((uptr = usm_parse_user(name, name_len)) != NULL && resetOnFail) {
  1143.             SNMP_FREE(uptr->privKey);
  1144.             uptr->privKey = oldkey;
  1145.             uptr->privKeyLen = oldkeylen;
  1146.         }
  1147.     }
  1149.     return SNMP_ERR_NOERROR;
  1150. }                               /* end write_usmUserPrivKeyChange() */
  1152. int
  1153. write_usmUserPublic(int action,
  1154.                     u_char * var_val,
  1155.                     u_char var_val_type,
  1156.                     size_t var_val_len,
  1157.                     u_char * statP, oid * name, size_t name_len)
  1158. {
  1159.     struct usmUser *uptr = NULL;
  1161.     if (var_val_type != ASN_OCTET_STR) {
  1162.         DEBUGMSGTL(("usmUser",
  1163.                     "write to usmUserPublic not ASN_OCTET_STRn"));
  1164.         return SNMP_ERR_WRONGTYPE;
  1165.     }
  1166.     if (var_val_len < 0 || var_val_len > 32) {
  1167.         DEBUGMSGTL(("usmUser", "write to usmUserPublic: bad lengthn"));
  1168.         return SNMP_ERR_WRONGLENGTH;
  1169.     }
  1170.     if (action == COMMIT) {
  1171.         /*
  1172.          * don't allow creations here 
  1173.          */
  1174.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  1175.             return SNMP_ERR_NOSUCHNAME;
  1176.         }
  1177.         if (uptr->userPublicString)
  1178.             free(uptr->userPublicString);
  1179.         uptr->userPublicString = (u_char *) malloc(var_val_len + 1);
  1180.         if (uptr->userPublicString == NULL) {
  1181.             return SNMP_ERR_GENERR;
  1182.         }
  1183.         memcpy(uptr->userPublicString, var_val, var_val_len);
  1184.         uptr->userPublicString[var_val_len] = 0;
  1185.         DEBUGMSG(("usmUser", "setting public string: %d - %sn",
  1186.                   var_val_len, uptr->userPublicString));
  1187.     }
  1188.     return SNMP_ERR_NOERROR;
  1189. }                               /* end write_usmUserPublic() */
  1191. int
  1192. write_usmUserStorageType(int action,
  1193.                          u_char * var_val,
  1194.                          u_char var_val_type,
  1195.                          size_t var_val_len,
  1196.                          u_char * statP, oid * name, size_t name_len)
  1197. {
  1198.     long            long_ret = *((long *) var_val);
  1199.     static long     oldValue;
  1200.     struct usmUser *uptr;
  1201.     static int      resetOnFail;
  1203.     if (action == RESERVE1) {
  1204.         resetOnFail = 0;
  1205.         if (var_val_type != ASN_INTEGER) {
  1206.             DEBUGMSGTL(("usmUser",
  1207.                         "write to usmUserStorageType not ASN_INTEGERn"));
  1208.             return SNMP_ERR_WRONGTYPE;
  1209.         }
  1210.         if (var_val_len != sizeof(long)) {
  1211.             DEBUGMSGTL(("usmUser",
  1212.                         "write to usmUserStorageType: bad lengthn"));
  1213.             return SNMP_ERR_WRONGLENGTH;
  1214.         }
  1215.         if (long_ret < 1 || long_ret > 5) {
  1216.             return SNMP_ERR_WRONGVALUE;
  1217.         }
  1218.     } else if (action == RESERVE2) {
  1219.         if ((uptr = usm_parse_user(name, name_len)) == NULL) {
  1220.             return SNMP_ERR_INCONSISTENTNAME;
  1221.         }
  1222.         if ((long_ret == ST_VOLATILE || long_ret == ST_NONVOLATILE) &&
  1223.             (uptr->userStorageType == ST_VOLATILE ||
  1224.              uptr->userStorageType == ST_NONVOLATILE)) {
  1225.             oldValue = uptr->userStorageType;
  1226.             uptr->userStorageType = long_ret;
  1227.             resetOnFail = 1;
  1228.         } else {
  1229.             /*
  1230.              * From RFC2574:
  1231.              * 
  1232.              * "Note that any user who employs authentication or privacy must
  1233.              * allow its secret(s) to be updated and thus cannot be 'readOnly'.
  1234.              * 
  1235.              * If an initial set operation tries to set the value to 'readOnly'
  1236.              * for a user who employs authentication or privacy, then an
  1237.              * 'inconsistentValue' error must be returned.  Note that if the
  1238.              * value has been previously set (implicit or explicit) to any
  1239.              * value, then the rules as defined in the StorageType Textual
  1240.              * Convention apply.  
  1241.              */
  1242.             DEBUGMSGTL(("usmUser",
  1243.                         "long_ret %d uptr->st %d uptr->status %dn",
  1244.                         long_ret, uptr->userStorageType,
  1245.                         uptr->userStatus));
  1247.             if (long_ret == ST_READONLY &&
  1248.                 uptr->userStorageType != ST_READONLY &&
  1249.                 (uptr->userStatus == RS_ACTIVE ||
  1250.                  uptr->userStatus == RS_NOTINSERVICE)) {
  1251.                 return SNMP_ERR_WRONGVALUE;
  1252.             } else if (long_ret == ST_READONLY &&
  1253.                        (snmp_oid_compare
  1254.                         (uptr->privProtocol, uptr->privProtocolLen,
  1255.                          usmNoPrivProtocol,
  1256.                          sizeof(usmNoPrivProtocol) / sizeof(oid)) != 0
  1257.                         || snmp_oid_compare(uptr->authProtocol,
  1258.                                             uptr->authProtocolLen,
  1259.                                             usmNoAuthProtocol,
  1260.                                             sizeof(usmNoAuthProtocol) /
  1261.                                             sizeof(oid)) != 0)) {
  1262.                 return SNMP_ERR_INCONSISTENTVALUE;
  1263.             } else {
  1264.                 return SNMP_ERR_WRONGVALUE;
  1265.             }
  1266.         }
  1267.     } else if (action == UNDO || action == FREE) {
  1268.         if ((uptr = usm_parse_user(name, name_len)) != NULL && resetOnFail) {
  1269.             uptr->userStorageType = oldValue;
  1270.         }
  1271.     }
  1272.     return SNMP_ERR_NOERROR;
  1273. }                               /* end write_usmUserStorageType() */
  1275. /*
  1276.  * Return 1 if enough objects have been set up to transition rowStatus to
  1277.  * notInService(2) or active(1).  
  1278.  */
  1280. int
  1281. usmStatusCheck(struct usmUser *uptr)
  1282. {
  1283.     if (uptr == NULL) {
  1284.         return 0;
  1285.     } else {
  1286.         if (uptr->cloneFrom == NULL) {
  1287.             return 0;
  1288.         }
  1289.     }
  1290.     return 1;
  1291. }
  1293. /*******************************************************************-o-******
  1294.  * write_usmUserStatus
  1295.  *
  1296.  * Parameters:
  1297.  *  action
  1298.  * *var_val
  1299.  *  var_val_type
  1300.  *  var_val_len
  1301.  * *statP
  1302.  * *name
  1303.  *  name_len
  1304.  *      
  1305.  * Returns:
  1306.  * SNMP_ERR_NOERROR On success.
  1307.  * SNMP_ERR_GENERR
  1308.  * SNMP_ERR_INCONSISTENTNAME
  1309.  * SNMP_ERR_INCONSISTENTVALUE
  1310.  * SNMP_ERR_WRONGLENGTH
  1311.  * SNMP_ERR_WRONGTYPE
  1312.  */
  1313. int
  1314. write_usmUserStatus(int action,
  1315.                     u_char * var_val,
  1316.                     u_char var_val_type,
  1317.                     size_t var_val_len,
  1318.                     u_char * statP, oid * name, size_t name_len)
  1319. {
  1320.     /*
  1321.      * variables we may use later 
  1322.      */
  1323.     static long     long_ret;
  1324.     unsigned char  *engineID;
  1325.     size_t          engineIDLen;
  1326.     char           *newName;
  1327.     size_t          nameLen;
  1328.     struct usmUser *uptr = NULL;
  1330.     if (action == RESERVE1) {
  1331.         if (var_val_type != ASN_INTEGER) {
  1332.             DEBUGMSGTL(("usmUser",
  1333.                         "write to usmUserStatus not ASN_INTEGERn"));
  1334.             return SNMP_ERR_WRONGTYPE;
  1335.         }
  1336.         if (var_val_len != sizeof(long_ret)) {
  1337.             DEBUGMSGTL(("usmUser",
  1338.                         "write to usmUserStatus: bad lengthn"));
  1339.             return SNMP_ERR_WRONGLENGTH;
  1340.         }
  1341.         long_ret = *((long *) var_val);
  1342.         if (long_ret == RS_NOTREADY || long_ret < 1 || long_ret > 6) {
  1343.             return SNMP_ERR_WRONGVALUE;
  1344.         }
  1346.         /*
  1347.          * See if we can parse the oid for engineID/name first.  
  1348.          */
  1349.         if (usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  1350.                           &engineID, &engineIDLen, (u_char **) & newName,
  1351.                           &nameLen)) {
  1352.             return SNMP_ERR_INCONSISTENTNAME;
  1353.         }
  1355.         if (engineIDLen < 5 || engineIDLen > 32 || nameLen < 1
  1356.             || nameLen > 32) {
  1357.             SNMP_FREE(engineID);
  1358.             SNMP_FREE(newName);
  1359.             return SNMP_ERR_NOCREATION;
  1360.         }
  1362.         /*
  1363.          * Now see if a user already exists with these index values. 
  1364.          */
  1365.         uptr = usm_get_user(engineID, engineIDLen, newName);
  1367.         if (uptr != NULL) {
  1368.             if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
  1369.                 SNMP_FREE(engineID);
  1370.                 SNMP_FREE(newName);
  1371.                 long_ret = RS_NOTREADY;
  1372.                 return SNMP_ERR_INCONSISTENTVALUE;
  1373.             }
  1374.             SNMP_FREE(engineID);
  1375.             SNMP_FREE(newName);
  1376.         } else {
  1377.             if (long_ret == RS_ACTIVE || long_ret == RS_NOTINSERVICE) {
  1378.                 SNMP_FREE(engineID);
  1379.                 SNMP_FREE(newName);
  1380.                 return SNMP_ERR_INCONSISTENTVALUE;
  1381.             }
  1382.             if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
  1383.                 if ((uptr = usm_create_user()) == NULL) {
  1384.                     SNMP_FREE(engineID);
  1385.                     SNMP_FREE(newName);
  1386.                     return SNMP_ERR_RESOURCEUNAVAILABLE;
  1387.                 }
  1388.                 uptr->engineID = engineID;
  1389.                 uptr->name = newName;
  1390.                 uptr->secName = strdup(uptr->name);
  1391.                 if (uptr->secName == NULL) {
  1392.                     usm_free_user(uptr);
  1393.                     return SNMP_ERR_RESOURCEUNAVAILABLE;
  1394.                 }
  1395.                 uptr->engineIDLen = engineIDLen;
  1397.                 /*
  1398.                  * Set status to createAndGo or createAndWait so we can tell
  1399.                  * that this row is under creation.  
  1400.                  */
  1402.                 uptr->userStatus = long_ret;
  1404.                 /*
  1405.                  * Add to the list of users (we will take it off again
  1406.                  * later if something goes wrong).  
  1407.                  */
  1409.                 usm_add_user(uptr);
  1410.             } else {
  1411.                 SNMP_FREE(engineID);
  1412.                 SNMP_FREE(newName);
  1413.             }
  1414.         }
  1415.     } else if (action == ACTION) {
  1416.         usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  1417.                       &engineID, &engineIDLen, (u_char **) & newName,
  1418.                       &nameLen);
  1419.         uptr = usm_get_user(engineID, engineIDLen, newName);
  1420.         SNMP_FREE(engineID);
  1421.         SNMP_FREE(newName);
  1423.         if (uptr != NULL) {
  1424.             if (long_ret == RS_CREATEANDGO || long_ret == RS_ACTIVE) {
  1425.                 if (usmStatusCheck(uptr)) {
  1426.                     uptr->userStatus = RS_ACTIVE;
  1427.                 } else {
  1428.                     SNMP_FREE(engineID);
  1429.                     SNMP_FREE(newName);
  1430.                     return SNMP_ERR_INCONSISTENTVALUE;
  1431.                 }
  1432.             } else if (long_ret == RS_CREATEANDWAIT) {
  1433.                 if (usmStatusCheck(uptr)) {
  1434.                     uptr->userStatus = RS_NOTINSERVICE;
  1435.                 } else {
  1436.                     uptr->userStatus = RS_NOTREADY;
  1437.                 }
  1438.             } else if (long_ret == RS_NOTINSERVICE) {
  1439.                 if (uptr->userStatus == RS_ACTIVE ||
  1440.                     uptr->userStatus == RS_NOTINSERVICE) {
  1441.                     uptr->userStatus = RS_NOTINSERVICE;
  1442.                 } else {
  1443.                     return SNMP_ERR_INCONSISTENTVALUE;
  1444.                 }
  1445.             }
  1446.         }
  1447.     } else if (action == COMMIT) {
  1448.         usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  1449.                       &engineID, &engineIDLen, (u_char **) & newName,
  1450.                       &nameLen);
  1451.         uptr = usm_get_user(engineID, engineIDLen, newName);
  1452.         SNMP_FREE(engineID);
  1453.         SNMP_FREE(newName);
  1455.         if (uptr != NULL) {
  1456.             if (long_ret == RS_DESTROY) {
  1457.                 usm_remove_user(uptr);
  1458.                 usm_free_user(uptr);
  1459.             }
  1460.         }
  1461.     } else if (action == UNDO || action == FREE) {
  1462.         usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  1463.                       &engineID, &engineIDLen, (u_char **) & newName,
  1464.                       &nameLen);
  1465.         uptr = usm_get_user(engineID, engineIDLen, newName);
  1466.         SNMP_FREE(engineID);
  1467.         SNMP_FREE(newName);
  1469.         if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
  1470.             usm_remove_user(uptr);
  1471.             usm_free_user(uptr);
  1472.         }
  1473.     }
  1475.     return SNMP_ERR_NOERROR;
  1476. }
  1478. #if 0
  1480.     /*
  1481.      * see if we can parse the oid for engineID/name first 
  1482.      */
  1483. if (usm_parse_oid(&name[USM_MIB_LENGTH], name_len - USM_MIB_LENGTH,
  1484.                   &engineID, &engineIDLen, (u_char **) & newName,
  1485.                   &nameLen))
  1486.     return SNMP_ERR_INCONSISTENTNAME;
  1488.     /*
  1489.      * Now see if a user already exists with these index values 
  1490.      */
  1491. uptr = usm_get_user(engineID, engineIDLen, newName);
  1494. if (uptr) {                     /* If so, we set the appropriate value... */
  1495.     free(engineID);
  1496.     free(newName);
  1497.     if (long_ret == RS_CREATEANDGO || long_ret == RS_CREATEANDWAIT) {
  1498.         return SNMP_ERR_INCONSISTENTVALUE;
  1499.     }
  1500.     if (long_ret == RS_DESTROY) {
  1501.         usm_remove_user(uptr);
  1502.         usm_free_user(uptr);
  1503.     } else {
  1504.         uptr->userStatus = long_ret;
  1505.     }
  1507. } else {                        /* ...else we create a new user */
  1508.     /*
  1509.      * check for a valid status column set 
  1510.      */
  1511.     if (long_ret == RS_ACTIVE || long_ret == RS_NOTINSERVICE) {
  1512.         free(engineID);
  1513.         free(newName);
  1514.         return SNMP_ERR_INCONSISTENTVALUE;
  1515.     }
  1516.     if (long_ret == RS_DESTROY) {
  1517.         /*
  1518.          * destroying a non-existent row is actually legal 
  1519.          */
  1520.         free(engineID);
  1521.         free(newName);
  1522.         return SNMP_ERR_NOERROR;
  1523.     }
  1525.     /*
  1526.      * generate a new user 
  1527.      */
  1528.     if ((uptr = usm_create_user()) == NULL) {
  1529.         free(engineID);
  1530.         free(newName);
  1531.         return SNMP_ERR_GENERR;
  1532.     }
  1534.     /*
  1535.      * copy in the engineID 
  1536.      */
  1537.     uptr->engineID = (unsigned char *) malloc(engineIDLen);
  1538.     if (uptr->engineID == NULL) {
  1539.         free(engineID);
  1540.         free(newName);
  1541.         usm_free_user(uptr);
  1542.         return SNMP_ERR_GENERR;
  1543.     }
  1544.     uptr->engineIDLen = engineIDLen;
  1545.     memcpy(uptr->engineID, engineID, engineIDLen);
  1546.     free(engineID);
  1548.     /*
  1549.      * copy in the name and secname 
  1550.      */
  1551.     if ((uptr->name = strdup(newName)) == NULL) {
  1552.         free(newName);
  1553.         usm_free_user(uptr);
  1554.         return SNMP_ERR_GENERR;
  1555.     }
  1556.     free(newName);
  1557.     if ((uptr->secName = strdup(uptr->name)) == NULL) {
  1558.         usm_free_user(uptr);
  1559.         return SNMP_ERR_GENERR;
  1560.     }
  1562.     /*
  1563.      * set the status of the row based on the request 
  1564.      */
  1565.     if (long_ret == RS_CREATEANDGO)
  1566.         uptr->userStatus = RS_ACTIVE;
  1567.     else if (long_ret == RS_CREATEANDWAIT)
  1568.         uptr->userStatus = RS_NOTINSERVICE;
  1570.     /*
  1571.      * finally, add it to our list of users 
  1572.      */
  1573.     usm_add_user(uptr);
  1575. }                               /* endif -- uptr */
  1576. }                               /* endif -- action==COMMIT */
  1578. return SNMP_ERR_NOERROR;
  1580. }                               /* end write_usmUserStatus() */
  1581. #endif