projects/stargazer/plugins/other/snmp/snmp.cpp

   1 #include <sys/types.h>
   2 #include <sys/socket.h>
   3 #include <arpa/inet.h>
   4
   5 #include <cstring>
   6 #include <cerrno>
   7 #include <ctime>
   8 #include <csignal>
   9
  10 #include <vector>
  11 #include <algorithm>
  12
  13 #include "asn1/OpenPDU.h"
  14 #include "asn1/ClosePDU.h"
  15 #include "asn1/SMUX-PDUs.h"
  16 #include "asn1/OBJECT_IDENTIFIER.h"
  17 #include "asn1/ber_decoder.h"
  18 #include "asn1/der_encoder.h"
  19
  20 #include "snmp.h"
  21 #include "stg/common.h"
  22
  23 class SNMP_AGENT_CREATOR
  24 {
  25 private:
  26     SNMP_AGENT * snmpAgent;
  27
  28 public:
  29     SNMP_AGENT_CREATOR()
  30         : snmpAgent(new SNMP_AGENT())
  31         {
  32         };
  33     ~SNMP_AGENT_CREATOR()
  34         {
  35         delete snmpAgent;
  36         };
  37
  38     SNMP_AGENT * GetPlugin()
  39         {
  40         return snmpAgent;
  41         };
  42 };
  43
  44 SNMP_AGENT_CREATOR sac;
  45
  46 PLUGIN * GetPlugin()
  47 {
  48 return sac.GetPlugin();
  49 }
  50
  51 int output(const void * buffer, size_t size, void * data)
  52 {
  53 int * fd = static_cast<int *>(data);
  54 return write(*fd, buffer, size);
  55 }
  56
  57 int SendOpenPDU(int fd)
  58 {
  59 const char * description = "Stg SNMP Agent";
  60 int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1, 5, 2, 1, 1};
  61 asn_enc_rval_t error;
  62 OpenPDU msg;
  63
  64 msg.present = OpenPDU_PR_simple;
  65 asn_long2INTEGER(&msg.choice.simple.version, 1);
  66 OBJECT_IDENTIFIER_set_arcs(&msg.choice.simple.identity,
  67                            oid,
  68                            sizeof(oid[0]),
  69                            sizeof(oid));
  70 OCTET_STRING_fromBuf(&msg.choice.simple.description,
  71                      description,
  72                      sizeof(description));
  73 OCTET_STRING_fromBuf(&msg.choice.simple.password,
  74                      "",
  75                      0);
  76
  77 error = der_encode(&asn_DEF_OpenPDU, &msg, output, &fd);
  78
  79 if (error.encoded == -1)
  80     {
  81     printfd(__FILE__, "Could not encode OpenPDU (at %s)\n",
  82             error.failed_type ? error.failed_type->name : "unknown");
  83     return -1;
  84     }
  85 else
  86     {
  87     printfd(__FILE__, "OpenPDU encoded successfully");
  88     }
  89 return 0;
  90 }
  91
  92 int SendClosePDU(int fd)
  93 {
  94 ClosePDU msg = ClosePDU_goingDown;
  95
  96 asn_enc_rval_t error;
  97 error = der_encode(&asn_DEF_ClosePDU, &msg, output, &fd);
  98
  99 if (error.encoded == -1)
 100     {
 101     printfd(__FILE__, "Could not encode ClosePDU (at %s)\n",
 102             error.failed_type ? error.failed_type->name : "unknown");
 103     return -1;
 104     }
 105 else
 106     {
 107     printfd(__FILE__, "ClosePDU encoded successfully");
 108     }
 109 return 0;
 110 }
 111
 112 int RecvSMUXPDUs(int fd)
 113 {
 114 char buffer[8192];
 115 SMUX_PDUs * pdus;
 116
 117 size_t length = read(fd, buffer, sizeof(buffer));
 118 asn_dec_rval_t error;
 119 error = ber_decode(0, &asn_DEF_SMUX_PDUs, (void **)&pdus, buffer, length);
 120 if(error.code != RC_OK)
 121     {
 122     printfd(__FILE__, "Failed to decode PDUs at byte %ld\n",
 123             (long)error.consumed);
 124     return -1;
 125     }
 126 switch (pdus->present)
 127     {
 128     case SMUX_PDUs_PR_NOTHING:
 129         printfd(__FILE__, "PDUs: nothing\n");
 130         break;
 131     case SMUX_PDUs_PR_open:
 132         printfd(__FILE__, "PDUs: open\n");
 133         break;
 134     case SMUX_PDUs_PR_close:
 135         printfd(__FILE__, "PDUs: close\n");
 136         break;
 137     case SMUX_PDUs_PR_registerRequest:
 138         printfd(__FILE__, "PDUs: registerRequest\n");
 139         break;
 140     case SMUX_PDUs_PR_registerResponse:
 141         printfd(__FILE__, "PDUs: registerResponse\n");
 142         break;
 143     case SMUX_PDUs_PR_pdus:
 144         printfd(__FILE__, "PDUs: pdus\n");
 145         break;
 146     case SMUX_PDUs_PR_commitOrRollback:
 147         printfd(__FILE__, "PDUs: commitOrRollback\n");
 148         break;
 149     default:
 150         printfd(__FILE__, "PDUs: default\n");
 151     }
 152 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 153 return 0;
 154 }
 155
 156 int ParseIntInRange(const std::string & str,
 157                     int min,
 158                     int max,
 159                     int * val)
 160 {
 161 if (str2x(str.c_str(), *val))
 162     {
 163     return -1;
 164     }
 165 if (*val < min || *val > max)
 166     {
 167     return -1;
 168     }
 169 return 0;
 170 }
 171
 172 SNMP_AGENT_SETTINGS::SNMP_AGENT_SETTINGS()
 173     : ip(0),
 174       port(0)
 175 {}
 176
 177 int SNMP_AGENT_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 178 {
 179 PARAM_VALUE pv;
 180 std::vector<PARAM_VALUE>::const_iterator pvi;
 181 int p;
 182 ///////////////////////////
 183 pv.param = "Port";
 184 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 185 if (pvi == s.moduleParams.end())
 186     {
 187     errorStr = "Parameter \'Port\' not found.";
 188     printfd(__FILE__, "Parameter 'Port' not found\n");
 189     return -1;
 190     }
 191 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
 192     {
 193     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
 194     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
 195     return -1;
 196     }
 197 port = p;
 198
 199 pv.param = "Password";
 200 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 201 if (pvi == s.moduleParams.end())
 202     {
 203     errorStr = "Parameter \'Password\' not found.";
 204     printfd(__FILE__, "Parameter 'Password' not found\n");
 205     password = "";
 206     }
 207 else
 208     {
 209     password = pvi->value[0];
 210     }
 211
 212 pv.param = "Server";
 213 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 214 if (pvi == s.moduleParams.end())
 215     {
 216     errorStr = "Parameter \'Server\' not found.";
 217     printfd(__FILE__, "Parameter 'Server' not found\n");
 218     return -1;
 219     }
 220 ip = inet_strington(pvi->value[0]);
 221
 222 return 0;
 223 }
 224
 225 SNMP_AGENT::SNMP_AGENT()
 226     : PLUGIN(),
 227       running(false),
 228       stopped(true),
 229       sock(-1)
 230 {
 231 pthread_mutex_init(&mutex, NULL);
 232 }
 233
 234 SNMP_AGENT::~SNMP_AGENT()
 235 {
 236 pthread_mutex_destroy(&mutex);
 237 }
 238
 239 int SNMP_AGENT::ParseSettings()
 240 {
 241 return snmpAgentSettings.ParseSettings(settings);
 242 }
 243
 244 int SNMP_AGENT::Start()
 245 {
 246 if (PrepareNet())
 247     return -1;
 248
 249 if (!running)
 250     {
 251     if (pthread_create(&thread, NULL, Runner, this))
 252         {
 253         errorStr = "Cannot create thread.";
 254         printfd(__FILE__, "Cannot create thread\n");
 255         return -1;
 256         }
 257     }
 258
 259 return 0;
 260 }
 261
 262 int SNMP_AGENT::Stop()
 263 {
 264 running = false;
 265
 266 close(sock);
 267
 268 if (!stopped)
 269     {
 270     //5 seconds to thread stops itself
 271     for (int i = 0; i < 25 && !stopped; i++)
 272         {
 273         struct timespec ts = {0, 200000000};
 274         nanosleep(&ts, NULL);
 275         }
 276
 277     //after 5 seconds waiting thread still running. now killing it
 278     if (!stopped)
 279         {
 280         if (pthread_kill(thread, SIGINT))
 281             {
 282             errorStr = "Cannot kill thread.";
 283             printfd(__FILE__, "Cannot kill thread\n");
 284             return -1;
 285             }
 286         printfd(__FILE__, "SNMP_AGENT killed Run\n");
 287         }
 288     }
 289
 290 return 0;
 291 }
 292
 293 void * SNMP_AGENT::Runner(void * d)
 294 {
 295 SNMP_AGENT * snmpAgent = static_cast<SNMP_AGENT *>(d);
 296
 297 snmpAgent->Run();
 298
 299 return NULL;
 300 }
 301
 302 void SNMP_AGENT::Run()
 303 {
 304 SendOpenPDU(sock);
 305 running = true;
 306 while(running)
 307     {
 308     RecvSMUXPDUs(sock);
 309     struct timespec ts = {1, 0};
 310     nanosleep(&ts, NULL);
 311     }
 312 SendClosePDU(sock);
 313 stopped = true;
 314 }
 315
 316 bool SNMP_AGENT::PrepareNet()
 317 {
 318 sock = socket(AF_INET, SOCK_STREAM, 0);
 319
 320 if (sock < 0)
 321     {
 322     errorStr = "Cannot create socket.";
 323     printfd(__FILE__, "Cannot create socket\n");
 324     return true;
 325     }
 326
 327 struct sockaddr_in addr;
 328
 329 addr.sin_family = AF_INET;
 330 addr.sin_port = htons(snmpAgentSettings.GetPort());
 331 addr.sin_addr.s_addr = snmpAgentSettings.GetIP();
 332
 333 if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)))
 334     {
 335     errorStr = "Cannot connect.";
 336     printfd(__FILE__, "Cannot connect. Message: '%s'\n", strerror(errno));
 337     return true;
 338     }
 339
 340 return false;
 341 }