You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdeutils/ksim/monitors/snmp/snmp.cpp

321 lines
12 KiB

/* This file is part of the KDE project
Copyright (C) 2003 Simon Hausmann <hausmann@kde.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "snmp.h"
#include "snmp_p.h"
#include "snmplib.h"
#include "value_p.h"
#include <tqmutex.h>
#include <assert.h>
using namespace KSim::Snmp;
static const struct EnumStringMapInfo
{
const int enumValue;
const char *stringValue;
const char snmpLibConstant;
} snmpVersionStrings[ 4 ] = {
{ SnmpVersion1, "1", SNMP_VERSION_1 },
{ SnmpVersion2c, "2c", SNMP_VERSION_2c },
{ SnmpVersion3, "3", SNMP_VERSION_3 },
{ 0, 0, 0 }
}, securityLevelStrings[ 4 ] = {
{ NoAuthPriv, "NoAuthPriv", SNMP_SEC_LEVEL_NOAUTH },
{ AuthNoPriv, "AuthNoPriv", SNMP_SEC_LEVEL_AUTHNOPRIV },
{ AuthPriv, "AuthPriv", SNMP_SEC_LEVEL_AUTHPRIV },
{ 0, 0, 0 }
}, authenticationProtocolStrings[ 3 ] = {
{ MD5Auth, "MD5", 0 },
{ SHA1Auth, "SHA1", 0 },
{ 0, 0, 0 }
}, privacyProtocolStrings[ 2 ] = {
{ DESPrivacy, "DES", 0 },
{ 0, 0, 0 }
};
static TQStringList allStrings( const EnumStringMapInfo *array )
{
TQStringList result;
for ( uint i = 0; array[ i ].stringValue; ++i )
result << TQString::fromLatin1( array[ i ].stringValue );
return result;
}
static TQString enumToString( const EnumStringMapInfo *array, int value )
{
for ( uint i = 0; array[ i ].stringValue; ++i )
if ( array[ i ].enumValue == value )
return TQString::fromLatin1( array[ i ].stringValue );
assert( false );
return TQString::null;
}
static int stringToEnum( const EnumStringMapInfo *array, TQString string, bool *ok )
{
string = string.lower();
uint i;
for ( i = 0; array[ i ].stringValue; ++i )
if ( TQString::fromLatin1( array[ i ].stringValue ).lower() == string ) {
if ( ok ) *ok = true;
return array[ i ].enumValue;
}
if ( ok )
*ok = false;
// something..
return array[ 0 ].enumValue;
}
static int extractSnmpLibConstant( const EnumStringMapInfo *array, int enumValue )
{
for ( uint i = 0; array[ i ].stringValue; ++i )
if ( array[ i ].enumValue == enumValue )
return array[ i ].snmpLibConstant;
assert( false );
return 0;
}
int KSim::Snmp::snmpVersionToSnmpLibConstant( SnmpVersion version )
{
return extractSnmpLibConstant( snmpVersionStrings, version );
}
int KSim::Snmp::snmpSecurityLevelToSnmpLibConstant( SecurityLevel secLevel )
{
return extractSnmpLibConstant( securityLevelStrings, secLevel );
}
TQStringList KSim::Snmp::allSnmpVersions()
{
return allStrings( snmpVersionStrings );
}
TQString KSim::Snmp::snmpVersionToString( SnmpVersion version )
{
return enumToString( snmpVersionStrings, version );
}
SnmpVersion KSim::Snmp::stringToSnmpVersion( TQString string, bool *ok )
{
return static_cast<SnmpVersion>( stringToEnum( snmpVersionStrings, string, ok ) );
}
TQStringList KSim::Snmp::allSecurityLevels()
{
return allStrings( securityLevelStrings );
}
TQString KSim::Snmp::securityLevelToString( SecurityLevel level )
{
return enumToString( securityLevelStrings, level );
}
SecurityLevel KSim::Snmp::stringToSecurityLevel( TQString string, bool *ok )
{
return static_cast<SecurityLevel>( stringToEnum( securityLevelStrings, string, ok ) );
}
TQStringList KSim::Snmp::allAuthenticationProtocols()
{
return allStrings( authenticationProtocolStrings );
}
TQString KSim::Snmp::authenticationProtocolToString( AuthenticationProtocol proto )
{
return enumToString( authenticationProtocolStrings, proto );
}
AuthenticationProtocol KSim::Snmp::stringToAuthenticationProtocol( TQString string, bool *ok )
{
return static_cast<AuthenticationProtocol>( stringToEnum( authenticationProtocolStrings, string, ok ) );
}
TQStringList KSim::Snmp::allPrivacyProtocols()
{
return allStrings( privacyProtocolStrings );
}
TQString KSim::Snmp::privacyProtocolToString( PrivacyProtocol proto )
{
return enumToString( privacyProtocolStrings, proto );
}
PrivacyProtocol KSim::Snmp::stringToPrivacyProtocol( TQString string, bool *ok )
{
return static_cast<PrivacyProtocol>( stringToEnum( privacyProtocolStrings, string, ok ) );
}
// I'm afraid of them changing the order in the error constants or the like, hence the
// slow list instead of a fast lookup table
static const struct ErrorMapInfo
{
int errorCode;
ErrorInfo::ErrorType enumValue;
} errorMap[] =
{
// API Errors
{ SNMPERR_GENERR, ErrorInfo::ErrGeneric },
{ SNMPERR_BAD_LOCPORT, ErrorInfo::ErrInvalidLocalPort },
{ SNMPERR_BAD_ADDRESS, ErrorInfo::ErrUnknownHost },
{ SNMPERR_BAD_SESSION, ErrorInfo::ErrUnknownSession },
{ SNMPERR_TOO_LONG, ErrorInfo::ErrTooLong },
{ SNMPERR_NO_SOCKET, ErrorInfo::ErrNoSocket },
{ SNMPERR_V2_IN_V1, ErrorInfo::ErrCannotSendV2PDUOnV1Session },
{ SNMPERR_V1_IN_V2, ErrorInfo::ErrCannotSendV1PDUOnV2Session },
{ SNMPERR_BAD_REPEATERS, ErrorInfo::ErrBadValueForNonRepeaters },
{ SNMPERR_BAD_REPETITIONS, ErrorInfo::ErrBadValueForMaxRepetitions },
{ SNMPERR_BAD_ASN1_BUILD, ErrorInfo::ErrBuildingASN1Representation },
{ SNMPERR_BAD_SENDTO, ErrorInfo::ErrFailureInSendto },
{ SNMPERR_BAD_PARSE, ErrorInfo::ErrBadParseOfASN1Type },
{ SNMPERR_BAD_VERSION, ErrorInfo::ErrBadVersion },
{ SNMPERR_BAD_SRC_PARTY, ErrorInfo::ErrBadSourceParty },
{ SNMPERR_BAD_DST_PARTY, ErrorInfo::ErrBadDestinationParty },
{ SNMPERR_BAD_CONTEXT, ErrorInfo::ErrBadContext },
{ SNMPERR_BAD_COMMUNITY, ErrorInfo::ErrBadCommunity },
{ SNMPERR_NOAUTH_DESPRIV, ErrorInfo::ErrCannotSendNoAuthDesPriv },
{ SNMPERR_BAD_ACL, ErrorInfo::ErrBadACL },
{ SNMPERR_BAD_PARTY, ErrorInfo::ErrBadParty },
{ SNMPERR_ABORT, ErrorInfo::ErrSessionAbortFailure },
{ SNMPERR_UNKNOWN_PDU, ErrorInfo::ErrUnknownPDU },
{ SNMPERR_TIMEOUT, ErrorInfo::ErrTimeout },
{ SNMPERR_BAD_RECVFROM, ErrorInfo::ErrFailureInRecvfrom },
{ SNMPERR_BAD_ENG_ID, ErrorInfo::ErrUnableToDetermineContextEngineID },
{ SNMPERR_BAD_SEC_NAME, ErrorInfo::ErrNoSecurityName },
{ SNMPERR_BAD_SEC_LEVEL, ErrorInfo::ErrUnableToDetermineSecurityLevel },
{ SNMPERR_ASN_PARSE_ERR, ErrorInfo::ErrASN1ParseError },
{ SNMPERR_UNKNOWN_SEC_MODEL, ErrorInfo::ErrUnknownSecurityModel },
{ SNMPERR_INVALID_MSG, ErrorInfo::ErrInvalidMessage },
{ SNMPERR_UNKNOWN_ENG_ID, ErrorInfo::ErrUnknownEngineID },
{ SNMPERR_UNKNOWN_USER_NAME, ErrorInfo::ErrUnknownUserName },
{ SNMPERR_UNSUPPORTED_SEC_LEVEL, ErrorInfo::ErrUnsupportedSecurityLevel },
{ SNMPERR_AUTHENTICATION_FAILURE, ErrorInfo::ErrAuthenticationFailure },
{ SNMPERR_NOT_IN_TIME_WINDOW, ErrorInfo::ErrNotInTimeWindow },
{ SNMPERR_DECRYPTION_ERR, ErrorInfo::ErrDecryptionError },
{ SNMPERR_SC_GENERAL_FAILURE, ErrorInfo::ErrSCAPIGeneralFailure },
{ SNMPERR_SC_NOT_CONFIGURED, ErrorInfo::ErrSCAPISubSystemNotConfigured },
{ SNMPERR_KT_NOT_AVAILABLE, ErrorInfo::ErrNoKeyTools },
{ SNMPERR_UNKNOWN_REPORT, ErrorInfo::ErrUnknownReport },
{ SNMPERR_USM_GENERICERROR, ErrorInfo::ErrUSMGenericError },
{ SNMPERR_USM_UNKNOWNSECURITYNAME, ErrorInfo::ErrUSMUnknownSecurityName },
{ SNMPERR_USM_UNSUPPORTEDSECURITYLEVEL, ErrorInfo::ErrUSMUnsupportedSecurityLevel },
{ SNMPERR_USM_ENCRYPTIONERROR, ErrorInfo::ErrUSMEncryptionError },
{ SNMPERR_USM_AUTHENTICATIONFAILURE, ErrorInfo::ErrUSMAuthenticationFailure },
{ SNMPERR_USM_PARSEERROR, ErrorInfo::ErrUSMParseError },
{ SNMPERR_USM_UNKNOWNENGINEID, ErrorInfo::ErrUSMUnknownEngineID },
{ SNMPERR_USM_NOTINTIMEWINDOW, ErrorInfo::ErrUSMNotInTimeWindow },
{ SNMPERR_USM_DECRYPTIONERROR, ErrorInfo::ErrUSMDecryptionError },
{ SNMPERR_NOMIB, ErrorInfo::ErrMIBNotInitialized },
{ SNMPERR_RANGE, ErrorInfo::ErrValueOutOfRange },
{ SNMPERR_MAX_SUBID, ErrorInfo::ErrSubIdOutOfRange },
{ SNMPERR_BAD_SUBID, ErrorInfo::ErrBadSubIdInOID },
{ SNMPERR_LONG_OID, ErrorInfo::ErrOIDTooLong },
{ SNMPERR_BAD_NAME, ErrorInfo::ErrBadValueName },
{ SNMPERR_VALUE, ErrorInfo::ErrBadValueNotation },
{ SNMPERR_UNKNOWN_OBJID, ErrorInfo::ErrUnknownOID },
{ SNMPERR_NULL_PDU, ErrorInfo::ErrNullPDU },
{ SNMPERR_NO_VARS, ErrorInfo::ErrMissingVariables },
{ SNMPERR_VAR_TYPE, ErrorInfo::ErrBadVariableType },
{ SNMPERR_MALLOC, ErrorInfo::ErrOOM },
{ SNMPERR_KRB5, ErrorInfo::ErrKerberos },
// PDU response errors
{ SNMP_ERR_TOOBIG, ErrorInfo::ErrResponseTooLarge },
{ SNMP_ERR_NOSUCHNAME, ErrorInfo::ErrNoSuchVariable },
{ SNMP_ERR_BADVALUE, ErrorInfo::ErrBadValue },
{ SNMP_ERR_READONLY, ErrorInfo::ErrReadOnly },
{ SNMP_ERR_GENERR, ErrorInfo::ErrGeneric },
{ SNMP_ERR_NOACCESS, ErrorInfo::ErrNoAccess },
{ SNMP_ERR_WRONGTYPE, ErrorInfo::ErrWrongType },
{ SNMP_ERR_WRONGLENGTH, ErrorInfo::ErrWrongLength },
{ SNMP_ERR_WRONGENCODING, ErrorInfo::ErrWrongEncoding },
{ SNMP_ERR_WRONGVALUE, ErrorInfo::ErrWrongValue },
{ SNMP_ERR_NOCREATION, ErrorInfo::ErrNoCreation },
{ SNMP_ERR_INCONSISTENTVALUE, ErrorInfo::ErrInconsistentValue },
{ SNMP_ERR_RESOURCEUNAVAILABLE, ErrorInfo::ErrResourceUnavailable },
{ SNMP_ERR_COMMITFAILED, ErrorInfo::ErrCommitFailed },
{ SNMP_ERR_UNDOFAILED, ErrorInfo::ErrUndoFailed },
{ SNMP_ERR_AUTHORIZATIONERROR, ErrorInfo::ErrAuthorizationFailed },
{ SNMP_ERR_NOTWRITABLE, ErrorInfo::ErrNotWritable },
{ SNMP_ERR_INCONSISTENTNAME, ErrorInfo::ErrInconsistentName },
{ SNMPERR_SUCCESS, ErrorInfo::NoError }
};
ErrorInfo::ErrorType KSim::Snmp::convertSnmpLibErrorToErrorInfo( int error )
{
for ( uint i = 0; errorMap[ i ].errorCode != SNMPERR_SUCCESS; ++i )
if ( errorMap[ i ].errorCode == error )
return errorMap[ i ].enumValue;
return ErrorInfo::ErrUnknown;
}
int KSim::Snmp::convertErrorInfoToSnmpLibError( ErrorInfo::ErrorType error )
{
for ( uint i = 0; errorMap[ i ].errorCode != SNMPERR_SUCCESS; ++i )
if ( errorMap[ i ].enumValue == error )
return errorMap[ i ].errorCode;
assert( false );
return SNMPERR_SUCCESS;
}
int KSim::Snmp::sessionErrorCode( netsnmp_session &session )
{
int errorCode = 0;
SnmpLib::self()->snmp_error( &session, 0, &errorCode, 0 );
return errorCode;
}
static TQString messageForErrorCode( int errorCode )
{
if ( errorCode >= SNMPERR_MAX && errorCode <= SNMPERR_GENERR )
return TQString::fromLatin1( SnmpLib::self()->snmp_api_errstring( errorCode ) );
if ( errorCode >= SNMP_ERR_NOERROR && errorCode <= MAX_SNMP_ERR )
return TQString::fromLatin1( SnmpLib::self()->snmp_errstring( errorCode ) );
return TQString::null;
}
ErrorInfo::ErrorInfo()
{
m_errorCode = NoError;
}
ErrorInfo::ErrorInfo( int internalErrorCode )
{
m_errorCode = convertSnmpLibErrorToErrorInfo( internalErrorCode );
m_errorMessage = messageForErrorCode( internalErrorCode );
}
ErrorInfo::ErrorInfo( ErrorType error )
{
m_errorCode = error;
if ( error != NoError && error != ErrUnknown )
m_errorMessage = messageForErrorCode( convertErrorInfoToSnmpLibError( error ) );
}
/* vim: et sw=4 ts=4
*/