X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/6207d1bdab32119da7d30a3d38d3dcf6a5f09671..0a8aa4fffee15d7e175d857b7248d690081f41fd:/projects/stargazer/plugins/other/snmp/snmp.cpp?ds=inline diff --git a/projects/stargazer/plugins/other/snmp/snmp.cpp b/projects/stargazer/plugins/other/snmp/snmp.cpp index 8587c1bc..2884e6fc 100644 --- a/projects/stargazer/plugins/other/snmp/snmp.cpp +++ b/projects/stargazer/plugins/other/snmp/snmp.cpp @@ -12,7 +12,11 @@ #include "asn1/OpenPDU.h" #include "asn1/ClosePDU.h" -#include "asn1/SMUX-PDUs.h" +#include "asn1/RReqPDU.h" +#include "asn1/GetRequest-PDU.h" +#include "asn1/GetResponse-PDU.h" +#include "asn1/VarBindList.h" +#include "asn1/VarBind.h" #include "asn1/OBJECT_IDENTIFIER.h" #include "asn1/ber_decoder.h" #include "asn1/der_encoder.h" @@ -20,6 +24,64 @@ #include "snmp.h" #include "stg/common.h" +bool WaitPackets(int sd); + +std::string OI2String(OBJECT_IDENTIFIER_t * oi) +{ +std::string res; + +int arcs[1024]; +int count = OBJECT_IDENTIFIER_get_arcs(oi, arcs, sizeof(arcs[0]), 1024); + +if (count > 1024) + return ""; + +for (int i = 0; i < count; ++i) + { + res += "."; + std::string arc; + strprintf(&arc, "%d", arcs[i]); + res += arc; + } + +return res; +} + +bool String2OI(const std::string & str, OBJECT_IDENTIFIER_t * oi) +{ +size_t left = 0, pos = 0, arcPos = 0; +int arcs[1024]; +pos = str.find_first_of('.', left); +if (pos == 0) + { + left = 1; + pos = str.find_first_of('.', left); + } +while (pos != std::string::npos) + { + int arc = 0; + if (str2x(str.substr(left, left - pos), arc)) + { + return false; + } + arcs[arcPos++] = arc; + left = pos + 1; + pos = str.find_first_of('.', left); + } +if (left < str.length()) + { + int arc = 0; + if (str2x(str.substr(left, left - pos), arc)) + { + return false; + } + arcs[arcPos++] = arc; + } +printfd(__FILE__, "String2OI() - arcPos: %d\n", arcPos); +OBJECT_IDENTIFIER_set_arcs(oi, arcs, sizeof(arcs[0]), arcPos); +return true; +} + class SNMP_AGENT_CREATOR { private: @@ -32,6 +94,7 @@ public: }; ~SNMP_AGENT_CREATOR() { + printfd(__FILE__, "SNMP_AGENT_CREATOR::~SNMP_AGENT_CREATOR()\n"); delete snmpAgent; }; @@ -48,33 +111,33 @@ PLUGIN * GetPlugin() return sac.GetPlugin(); } -int output(const void * buffer, size_t size, void * data) -{ -int * fd = static_cast(data); -return write(*fd, buffer, size); -} - int SendOpenPDU(int fd) { const char * description = "Stg SNMP Agent"; -int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1, 5, 2, 1, 1}; +//int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1, 5, 2, 1, 1}; asn_enc_rval_t error; -OpenPDU msg; +OpenPDU_t msg; + +memset(&msg, 0, sizeof(msg)); msg.present = OpenPDU_PR_simple; -asn_long2INTEGER(&msg.choice.simple.version, 1); -OBJECT_IDENTIFIER_set_arcs(&msg.choice.simple.identity, +asn_long2INTEGER(&msg.choice.simple.version, SimpleOpen__version_version_1); +/*OBJECT_IDENTIFIER_set_arcs(&msg.choice.simple.identity, oid, sizeof(oid[0]), - sizeof(oid)); -OCTET_STRING_fromBuf(&msg.choice.simple.description, - description, - sizeof(description)); -OCTET_STRING_fromBuf(&msg.choice.simple.password, - "", - 0); + 7);*/ +if (!String2OI(".1.3.6.1.4.1.9363", &msg.choice.simple.identity)) + { + printfd(__FILE__, "SendOpenPDU() - failed to convert string to OBJECT_IDENTIFIER\n"); + return -1; + } +OCTET_STRING_fromString(&msg.choice.simple.description, + description); +OCTET_STRING_fromString(&msg.choice.simple.password, + ""); -error = der_encode(&asn_DEF_OpenPDU, &msg, output, &fd); +char buffer[1024]; +error = der_encode_to_buffer(&asn_DEF_OpenPDU, &msg, buffer, sizeof(buffer)); if (error.encoded == -1) { @@ -84,17 +147,23 @@ if (error.encoded == -1) } else { - printfd(__FILE__, "OpenPDU encoded successfully"); + write(fd, buffer, error.encoded); + printfd(__FILE__, "OpenPDU encoded successfully to %d bytes\n", error.encoded); } return 0; } int SendClosePDU(int fd) { -ClosePDU msg = ClosePDU_goingDown; +ClosePDU_t msg; + +memset(&msg, 0, sizeof(msg)); + +asn_long2INTEGER(&msg, ClosePDU_goingDown); +char buffer[1024]; asn_enc_rval_t error; -error = der_encode(&asn_DEF_ClosePDU, &msg, output, &fd); +error = der_encode_to_buffer(&asn_DEF_ClosePDU, &msg, buffer, sizeof(buffer)); if (error.encoded == -1) { @@ -104,53 +173,112 @@ if (error.encoded == -1) } else { - printfd(__FILE__, "ClosePDU encoded successfully"); + write(fd, buffer, error.encoded); + printfd(__FILE__, "ClosePDU encoded successfully\n"); + } +return 0; +} + +int SendRReqPDU(int fd) +{ +int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1}; +asn_enc_rval_t error; +RReqPDU_t msg; + +memset(&msg, 0, sizeof(msg)); + +msg.priority = 0; +asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly); +OBJECT_IDENTIFIER_set_arcs(&msg.subtree, + oid, + sizeof(oid[0]), + 8); + +char buffer[1024]; +error = der_encode_to_buffer(&asn_DEF_RReqPDU, &msg, buffer, sizeof(buffer)); + +if (error.encoded == -1) + { + printfd(__FILE__, "Could not encode RReqPDU (at %s)\n", + error.failed_type ? error.failed_type->name : "unknown"); + return -1; + } +else + { + write(fd, buffer, error.encoded); + printfd(__FILE__, "RReqPDU encoded successfully to %d bytes\n", error.encoded); } return 0; } -int RecvSMUXPDUs(int fd) +int SendGetResponsePDU(int fd, GetResponse_PDU_t * getResponse) { -char buffer[8192]; -SMUX_PDUs * pdus; +asn_enc_rval_t error; + +char buffer[1024]; +error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, getResponse, buffer, sizeof(buffer)); + +if (error.encoded == -1) + { + printfd(__FILE__, "Could not encode GetResponsePDU (at %s)\n", + error.failed_type ? error.failed_type->name : "unknown"); + return -1; + } +else + { + write(fd, buffer, error.encoded); + printfd(__FILE__, "GetResponsePDU encoded successfully to %d bytes\n", error.encoded); + } +return 0; +} + +int SendGetResponseErrorPDU(int fd, const PDU_t * getRequest, int errorStatus, int errorIndex) +{ +asn_enc_rval_t error; +GetResponse_PDU_t msg; + +memset(&msg, 0, sizeof(msg)); + +msg.request_id = getRequest->request_id; +asn_long2INTEGER(&msg.error_status, errorStatus); +asn_long2INTEGER(&msg.error_index, errorIndex); + +char buffer[1024]; +error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, &msg, buffer, sizeof(buffer)); + +if (error.encoded == -1) + { + printfd(__FILE__, "Could not encode GetResponsePDU for error (at %s)\n", + error.failed_type ? error.failed_type->name : "unknown"); + return -1; + } +else + { + write(fd, buffer, error.encoded); + printfd(__FILE__, "GetResponsePDU for error encoded successfully to %d bytes\n", error.encoded); + } +return 0; +} + +SMUX_PDUs_t * RecvSMUXPDUs(int fd) +{ +char buffer[1024]; +SMUX_PDUs_t * pdus = NULL; + +memset(buffer, 0, sizeof(buffer)); size_t length = read(fd, buffer, sizeof(buffer)); +if (length < 1) + return NULL; asn_dec_rval_t error; error = ber_decode(0, &asn_DEF_SMUX_PDUs, (void **)&pdus, buffer, length); if(error.code != RC_OK) { printfd(__FILE__, "Failed to decode PDUs at byte %ld\n", (long)error.consumed); - return -1; + return NULL; } -switch (pdus->present) - { - case SMUX_PDUs_PR_NOTHING: - printfd(__FILE__, "PDUs: nothing\n"); - break; - case SMUX_PDUs_PR_open: - printfd(__FILE__, "PDUs: open\n"); - break; - case SMUX_PDUs_PR_close: - printfd(__FILE__, "PDUs: close\n"); - break; - case SMUX_PDUs_PR_registerRequest: - printfd(__FILE__, "PDUs: registerRequest\n"); - break; - case SMUX_PDUs_PR_registerResponse: - printfd(__FILE__, "PDUs: registerResponse\n"); - break; - case SMUX_PDUs_PR_pdus: - printfd(__FILE__, "PDUs: pdus\n"); - break; - case SMUX_PDUs_PR_commitOrRollback: - printfd(__FILE__, "PDUs: commitOrRollback\n"); - break; - default: - printfd(__FILE__, "PDUs: default\n"); - } -asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); -return 0; +return pdus; } int ParseIntInRange(const std::string & str, @@ -224,15 +352,30 @@ return 0; SNMP_AGENT::SNMP_AGENT() : PLUGIN(), + users(NULL), + tariffs(NULL), running(false), stopped(true), sock(-1) { pthread_mutex_init(&mutex, NULL); + +smuxHandlers[SMUX_PDUs_PR_close] = &SNMP_AGENT::CloseHandler; +smuxHandlers[SMUX_PDUs_PR_registerResponse] = &SNMP_AGENT::RegisterResponseHandler; +smuxHandlers[SMUX_PDUs_PR_pdus] = &SNMP_AGENT::PDUsHandler; +smuxHandlers[SMUX_PDUs_PR_commitOrRollback] = &SNMP_AGENT::CommitOrRollbackHandler; + +pdusHandlers[PDUs_PR_get_request] = &SNMP_AGENT::GetRequestHandler; +pdusHandlers[PDUs_PR_get_next_request] = &SNMP_AGENT::GetNextRequestHandler; +pdusHandlers[PDUs_PR_set_request] = &SNMP_AGENT::SetRequestHandler; } SNMP_AGENT::~SNMP_AGENT() { +Sensors::iterator it; +for (it = sensors.begin(); it != sensors.end(); ++it) + delete it->second; +printfd(__FILE__, "SNMP_AGENT::~SNMP_AGENT()\n"); pthread_mutex_destroy(&mutex); } @@ -246,6 +389,20 @@ int SNMP_AGENT::Start() if (PrepareNet()) return -1; +// Users +sensors[".1.3.6.1.4.1.9363.1.1.1"] = new TotalUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.2"] = new ConnectedUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.3"] = new AuthorizedUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.4"] = new AlwaysOnlineUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.5"] = new NoCashUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.7"] = new DisabledDetailStatsUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.8"] = new DisabledUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.9"] = new PassiveUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.10"] = new CreditUsersSensor(*users); +sensors[".1.3.6.1.4.1.9363.1.1.11"] = new FreeMbUsersSensor(*users); +// Tariffs +sensors[".1.3.6.1.4.1.9363.1.2.1"] = new TotalTariffsSensor(*tariffs); + if (!running) { if (pthread_create(&thread, NULL, Runner, this)) @@ -261,10 +418,9 @@ return 0; int SNMP_AGENT::Stop() { +printfd(__FILE__, "SNMP_AGENT::Stop() - Before\n"); running = false; -close(sock); - if (!stopped) { //5 seconds to thread stops itself @@ -277,16 +433,22 @@ if (!stopped) //after 5 seconds waiting thread still running. now killing it if (!stopped) { + printfd(__FILE__, "SNMP_AGENT::Stop() - failed to stop thread, killing it\n"); if (pthread_kill(thread, SIGINT)) { errorStr = "Cannot kill thread."; - printfd(__FILE__, "Cannot kill thread\n"); + printfd(__FILE__, "SNMP_AGENT::Stop() - Cannot kill thread\n"); return -1; } - printfd(__FILE__, "SNMP_AGENT killed Run\n"); + printfd(__FILE__, "SNMP_AGENT::Stop() - killed Run\n"); } } +pthread_join(thread, NULL); + +close(sock); + +printfd(__FILE__, "SNMP_AGENT::Stop() - After\n"); return 0; } @@ -302,13 +464,22 @@ return NULL; void SNMP_AGENT::Run() { SendOpenPDU(sock); +SendRReqPDU(sock); running = true; +stopped = false; +printfd(__FILE__, "SNMP_AGENT::Run() - Before\n"); while(running) { - RecvSMUXPDUs(sock); - struct timespec ts = {1, 0}; - nanosleep(&ts, NULL); + if (WaitPackets(sock)) + { + SMUX_PDUs_t * pdus = RecvSMUXPDUs(sock); + if (pdus) + DispatchPDUs(pdus); + } + if (!running) + break; } +printfd(__FILE__, "SNMP_AGENT::Run() - After\n"); SendClosePDU(sock); stopped = true; } @@ -339,3 +510,166 @@ if (connect(sock, reinterpret_cast(&addr), sizeof(addr))) return false; } + +bool WaitPackets(int sd) +{ +fd_set rfds; +FD_ZERO(&rfds); +FD_SET(sd, &rfds); + +struct timeval tv; +tv.tv_sec = 0; +tv.tv_usec = 500000; + +int res = select(sd + 1, &rfds, NULL, NULL, &tv); +if (res == -1) // Error + { + if (errno != EINTR) + { + printfd(__FILE__, "Error on select: '%s'\n", strerror(errno)); + } + return false; + } + +if (res == 0) // Timeout + { + return false; + } + +return true; +} + +bool SNMP_AGENT::DispatchPDUs(const SMUX_PDUs_t * pdus) +{ +SMUXHandlers::iterator it; +it = smuxHandlers.find(pdus->present); +if (it != smuxHandlers.end()) + { + return (this->*(it->second))(pdus); + } +else + { + switch (pdus->present) + { + case SMUX_PDUs_PR_NOTHING: + printfd(__FILE__, "PDUs: nothing\n"); + break; + case SMUX_PDUs_PR_open: + printfd(__FILE__, "PDUs: open\n"); + break; + case SMUX_PDUs_PR_registerRequest: + printfd(__FILE__, "PDUs: registerRequest\n"); + break; + default: + printfd(__FILE__, "PDUs: undefined\n"); + } + asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); + } +return false; +} + +bool SNMP_AGENT::CloseHandler(const SMUX_PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::CloseHandler()\n"); +asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); +return false; +} + +bool SNMP_AGENT::RegisterResponseHandler(const SMUX_PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::RegisterResponseHandler()\n"); +asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); +return false; +} + +bool SNMP_AGENT::PDUsHandler(const SMUX_PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::PDUsHandler()\n"); +asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); +PDUsHandlers::iterator it; +it = pdusHandlers.find(pdus->choice.pdus.present); +if (it != pdusHandlers.end()) + { + return (this->*(it->second))(&pdus->choice.pdus); + } +else + { + switch (pdus->present) + { + case PDUs_PR_NOTHING: + printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - nothing\n"); + break; + case PDUs_PR_get_response: + printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - get response\n"); + break; + case PDUs_PR_trap: + printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - trap\n"); + break; + default: + printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - undefined\n"); + } + } +return false; +} + +bool SNMP_AGENT::CommitOrRollbackHandler(const SMUX_PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::CommitOrRollbackHandler()\n"); +asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus); +return false; +} + +bool SNMP_AGENT::GetRequestHandler(const PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::GetRequestHandler()\n"); +asn_fprint(stderr, &asn_DEF_PDUs, pdus); +const GetRequest_PDU_t * getRequest = &pdus->choice.get_request; +GetResponse_PDU_t msg; +VarBindList_t * varBindList = &msg.variable_bindings; +memset(&msg, 0, sizeof(msg)); + +msg.request_id = getRequest->request_id; +asn_long2INTEGER(&msg.error_status, 0); +asn_long2INTEGER(&msg.error_index, 0); + +const VarBindList_t * vbl = &getRequest->variable_bindings; +for (int i = 0; i < vbl->list.count; ++i) + { + VarBind_t * vb = getRequest->variable_bindings.list.array[i]; + Sensors::iterator it; + it = sensors.find(OI2String(&vb->name)); + if (it == sensors.end()) + { + SendGetResponseErrorPDU(sock, getRequest, PDU__error_status_noSuchName, i); + return true; + } + + VarBind_t newVb; + memset(&newVb, 0, sizeof(newVb)); + + newVb.name = vb->name; + it->second->GetValue(&newVb.value); + + ASN_SEQUENCE_ADD(varBindList, &newVb); + } + +SendGetResponsePDU(sock, &msg); +asn_fprint(stderr, &asn_DEF_PDU, &msg); +return false; +} + +bool SNMP_AGENT::GetNextRequestHandler(const PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::GetNextRequestHandler()\n"); +asn_fprint(stderr, &asn_DEF_PDUs, pdus); +return false; +} + +bool SNMP_AGENT::SetRequestHandler(const PDUs_t * pdus) +{ +printfd(__FILE__, "SNMP_AGENT::SetRequestHandler()\n"); +asn_fprint(stderr, &asn_DEF_PDUs, pdus); +SendGetResponseErrorPDU(sock, &pdus->choice.set_request, PDU__error_status_readOnly, 0); +return false; +} +