📄 usmuser.c
字号:
uptr = usm_get_userList();
} else {
for(nptr = usm_get_userList(), pptr = NULL, uptr = NULL; nptr != NULL;
pptr = nptr, nptr = nptr->next) {
indexOid = usm_generate_OID(vp->name, vp->namelen, nptr, &len);
result = snmp_oid_compare(name, *length, indexOid, len);
DEBUGMSGTL(("usmUser", "Checking user: %s - ", nptr->name));
for(i = 0; i < (int)nptr->engineIDLen; i++) {
DEBUGMSG(("usmUser", " %x",nptr->engineID[i]));
}
DEBUGMSG(("usmUser"," - %d \n -> OID: ", result));
DEBUGMSGOID(("usmUser", indexOid, len));
DEBUGMSG(("usmUser","\n"));
free(indexOid);
if (exact) {
if (result == 0) {
uptr = nptr;
}
} else {
if (result == 0) {
/* found an exact match. Need the next one for !exact */
uptr = nptr->next;
} else if (result == 1) {
uptr = nptr;
}
}
}
} /* endif -- name <= vp->name */
/* if uptr is NULL and exact we need to continue for creates */
if (uptr == NULL && !exact)
return(NULL);
if (uptr) {
indexOid = usm_generate_OID(vp->name, vp->namelen, uptr, &len);
*length = len;
memmove(name, indexOid, len*sizeof(oid));
DEBUGMSGTL(("usmUser", "Found user: %s - ", uptr->name));
for(i = 0; i < (int)uptr->engineIDLen; i++) {
DEBUGMSG(("usmUser", " %x",uptr->engineID[i]));
}
DEBUGMSG(("usmUser","\n -> OID: "));
DEBUGMSGOID(("usmUser", indexOid, len));
DEBUGMSG(("usmUser","\n"));
free(indexOid);
}
} else {
if (header_generic(vp,name,length,exact,var_len,write_method))
return 0;
} /* endif -- vp->magic != USMUSERSPINLOCK */
switch(vp->magic) {
case USMUSERSPINLOCK:
*write_method = write_usmUserSpinLock;
long_ret = usmUserSpinLock;
return (unsigned char *) &long_ret;
case USMUSERSECURITYNAME:
if (uptr) {
*var_len = strlen(uptr->secName);
return (unsigned char *) uptr->secName;
}
return NULL;
case USMUSERCLONEFROM:
*write_method = write_usmUserCloneFrom;
if (uptr) {
objid[0] = 0; /* "When this object is read, the ZeroDotZero OID */
objid[1] = 0; /* is returned." */
*var_len = sizeof(oid)*2;
return (unsigned char *) objid;
}
return NULL;
case USMUSERAUTHPROTOCOL:
*write_method = write_usmUserAuthProtocol;
if (uptr) {
*var_len = uptr->authProtocolLen*sizeof(oid);
return (u_char *)uptr->authProtocol;
}
return NULL;
case USMUSERAUTHKEYCHANGE:
case USMUSEROWNAUTHKEYCHANGE:
/* we treat these the same, and let the calling module
distinguish between them */
*write_method = write_usmUserAuthKeyChange;
if (uptr) {
*string = 0; /* always return a NULL string */
*var_len = 0;
return string;
}
return NULL;
case USMUSERPRIVPROTOCOL:
*write_method = write_usmUserPrivProtocol;
if (uptr) {
*var_len = uptr->privProtocolLen*sizeof(oid);
return (u_char *)uptr->privProtocol;
}
return NULL;
case USMUSERPRIVKEYCHANGE:
case USMUSEROWNPRIVKEYCHANGE:
/* we treat these the same, and let the calling module
distinguish between them */
*write_method = write_usmUserPrivKeyChange;
if (uptr) {
*string = 0; /* always return a NULL string */
*var_len = 0;
return string;
}
return NULL;
case USMUSERPUBLIC:
*write_method = write_usmUserPublic;
if (uptr) {
if (uptr->userPublicString) {
*var_len = strlen((char *)uptr->userPublicString);
return uptr->userPublicString;
}
*string = 0;
*var_len = 0; /* return an empty string if the public
string hasn't been defined yet */
return string;
}
return NULL;
case USMUSERSTORAGETYPE:
*write_method = write_usmUserStorageType;
if (uptr) {
long_ret = uptr->userStorageType;
return (unsigned char *) &long_ret;
}
return NULL;
case USMUSERSTATUS:
*write_method = write_usmUserStatus;
if (uptr) {
long_ret = uptr->userStatus;
return (unsigned char *) &long_ret;
}
return NULL;
default:
DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_usmUser\n", vp->magic));
}
return 0;
} /* end var_usmUser() */
/* write_usmUserSpinLock(): called when a set is performed on the
usmUserSpinLock object */
int
write_usmUserSpinLock(
int action,
u_char *var_val,
u_char var_val_type,
size_t var_val_len,
u_char *statP,
oid *name,
size_t name_len)
{
/* variables we may use later */
static long long_ret;
if (var_val_type != ASN_INTEGER){
DEBUGMSGTL(("usmUser","write to usmUserSpinLock not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > sizeof(long_ret)){
DEBUGMSGTL(("usmUser","write to usmUserSpinLock: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
long_ret = *((long *) var_val);
if (long_ret != (long)usmUserSpinLock)
return SNMP_ERR_INCONSISTENTVALUE;
if (action == COMMIT) {
if (usmUserSpinLock == 2147483647) {
usmUserSpinLock = 0;
} else {
usmUserSpinLock++;
}
}
return SNMP_ERR_NOERROR;
} /* end write_usmUserSpinLock() */
/*******************************************************************-o-******
* write_usmUserCloneFrom
*
* Parameters:
* action
* *var_val
* var_val_type
* var_val_len
* *statP (UNUSED)
* *name OID of user to clone from.
* name_len
*
* Returns:
* SNMP_ERR_NOERROR On success -OR- If user exists
* and has already been cloned.
* SNMP_ERR_GENERR Local function call failures.
* SNMP_ERR_INCONSISTENTNAME 'name' does not exist in user list
* -OR- user to clone from != RS_ACTIVE.
* SNMP_ERR_WRONGLENGTH OID length > than local buffer size.
* SNMP_ERR_WRONGTYPE ASN_OBJECT_ID is wrong.
*
*
* XXX: should handle action=UNDO's.
*/
int
write_usmUserCloneFrom(
int action,
u_char *var_val,
u_char var_val_type,
size_t var_val_len,
u_char *statP,
oid *name,
size_t name_len)
{
/* variables we may use later */
static oid objid[USM_LENGTH_OID_MAX], *oidptr;
struct usmUser *uptr, *cloneFrom;
size_t size;
if (var_val_type != ASN_OBJECT_ID){
DEBUGMSGTL(("usmUser","write to usmUserCloneFrom not ASN_OBJECT_ID\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > sizeof(objid)){
DEBUGMSGTL(("usmUser","write to usmUserCloneFrom: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (action == COMMIT){
/* parse the clonefrom objid */
size = var_val_len/sizeof(oid);
memcpy(objid, var_val, var_val_len);
if ((uptr = usm_parse_user(name, name_len)) == NULL)
/* We don't allow creations here */
return SNMP_ERR_INCONSISTENTNAME;
/* have the user already been cloned? If so, second cloning is
not allowed, but does not generate an error */
if (uptr->cloneFrom)
return SNMP_ERR_NOERROR;
/* does the cloneFrom user exist? */
if ((cloneFrom = usm_parse_user(objid, size)) == NULL)
/* We don't allow creations here */
return SNMP_ERR_INCONSISTENTNAME;
/* is it active */
if (cloneFrom->userStatus != RS_ACTIVE)
return SNMP_ERR_INCONSISTENTNAME;
/* set the cloneFrom OID */
if ((oidptr = snmp_duplicate_objid(objid, size/sizeof(oid))) == NULL)
return SNMP_ERR_GENERR;
/* do the actual cloning */
if (uptr->cloneFrom)
free(uptr->cloneFrom);
uptr->cloneFrom = oidptr;
usm_cloneFrom_user(cloneFrom, uptr);
} /* endif: action == COMMIT */
return SNMP_ERR_NOERROR;
} /* end write_usmUserCloneFrom() */
/*******************************************************************-o-******
* write_usmUserAuthProtocol
*
* Parameters:
* action
* *var_val OID of auth transform to set.
* var_val_type
* var_val_len
* *statP
* *name OID of user upon which to perform set operation.
* name_len
*
* Returns:
* SNMP_ERR_NOERROR On success.
* SNMP_ERR_GENERR
* SNMP_ERR_INCONSISTENTVALUE
* SNMP_ERR_NOSUCHNAME
* SNMP_ERR_WRONGLENGTH
* SNMP_ERR_WRONGTYPE
*/
int
write_usmUserAuthProtocol(
int action,
u_char *var_val,
u_char var_val_type,
size_t var_val_len,
u_char *statP,
oid *name,
size_t name_len)
{
/* variables we may use later */
static oid objid[USM_LENGTH_OID_MAX];
static oid *optr;
struct usmUser *uptr;
size_t size;
if (var_val_type != ASN_OBJECT_ID){
DEBUGMSGTL(("usmUser","write to usmUserAuthProtocol not ASN_OBJECT_ID\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > sizeof(objid)){
DEBUGMSGTL(("usmUser","write to usmUserAuthProtocol: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (action == COMMIT){
size = var_val_len/sizeof(oid);
memcpy(objid, var_val, var_val_len);
/* don't allow creations here */
if ((uptr = usm_parse_user(name, name_len)) == NULL)
return SNMP_ERR_NOSUCHNAME;
/* check the objid for validity */
/* only allow sets to perform a change to usmNoAuthProtocol */
if (snmp_oid_compare(objid, size, usmNoAuthProtocol,
sizeof(usmNoAuthProtocol)/sizeof(oid)) != 0)
return SNMP_ERR_INCONSISTENTVALUE;
/* if the priv protocol is not usmNoPrivProtocol, we can't change */
if (snmp_oid_compare(uptr->privProtocol, uptr->privProtocolLen, usmNoPrivProtocol,
sizeof(usmNoPrivProtocol)/sizeof(oid)) != 0)
return SNMP_ERR_INCONSISTENTVALUE;
/* finally, we can do it */
optr = uptr->authProtocol;
if ((uptr->authProtocol = snmp_duplicate_objid(objid, size))
== NULL) {
uptr->authProtocol = optr;
return SNMP_ERR_GENERR;
}
free(optr);
uptr->authProtocolLen = size;
}
return SNMP_ERR_NOERROR;
} /* end write_usmUserAuthProtocol() */
/*******************************************************************-o-******
* write_usmUserAuthKeyChange
*
* Parameters:
* action
* *var_val Octet string representing new KeyChange value.
* var_val_type
* var_val_len
* *statP (UNUSED)
* *name OID of user upon which to perform set operation.
* name_len
*
* Returns:
* SNMP_ERR_NOERR Success.
* SNMP_ERR_WRONGTYPE
* SNMP_ERR_WRONGLENGTH
* SNMP_ERR_NOSUCHNAME
* SNMP_ERR_GENERR
*
* Note: This function handles both the usmUserAuthKeyChange and
* usmUserOwnAuthKeyChange objects. We are not passed the name
* of the user requseting the keychange, so we leave this to the
* calling module to verify when and if we should be called. To
* change this would require a change in the mib module API to
* pass in the securityName requesting the change.
*
* XXX: should handle action=UNDO's.
*/
int
write_usmUserAuthKeyChange(
int action,
u_char *var_val,
u_char var_val_type,
size_t var_val_len,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -