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/RReqPDU.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 bool WaitPackets(int sd);
  24
  25 class SNMP_AGENT_CREATOR
  26 {
  27 private:
  28     SNMP_AGENT * snmpAgent;
  29
  30 public:
  31     SNMP_AGENT_CREATOR()
  32         : snmpAgent(new SNMP_AGENT())
  33         {
  34         };
  35     ~SNMP_AGENT_CREATOR()
  36         {
  37         printfd(__FILE__, "SNMP_AGENT_CREATOR::~SNMP_AGENT_CREATOR()\n");
  38         delete snmpAgent;
  39         };
  40
  41     SNMP_AGENT * GetPlugin()
  42         {
  43         return snmpAgent;
  44         };
  45 };
  46
  47 SNMP_AGENT_CREATOR sac;
  48
  49 PLUGIN * GetPlugin()
  50 {
  51 return sac.GetPlugin();
  52 }
  53
  54 int SendOpenPDU(int fd)
  55 {
  56 const char * description = "Stg SNMP Agent";
  57 int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1, 5, 2, 1, 1};
  58 asn_enc_rval_t error;
  59 OpenPDU_t msg;
  60
  61 memset(&msg, 0, sizeof(msg));
  62
  63 msg.present = OpenPDU_PR_simple;
  64 asn_long2INTEGER(&msg.choice.simple.version, SimpleOpen__version_version_1);
  65 OBJECT_IDENTIFIER_set_arcs(&msg.choice.simple.identity,
  66                            oid,
  67                            sizeof(oid[0]),
  68                            7);
  69 OCTET_STRING_fromString(&msg.choice.simple.description,
  70                      description);
  71 OCTET_STRING_fromString(&msg.choice.simple.password,
  72                      "");
  73
  74 char buffer[1024];
  75 error = der_encode_to_buffer(&asn_DEF_OpenPDU, &msg, buffer, sizeof(buffer));
  76
  77 if (error.encoded == -1)
  78     {
  79     printfd(__FILE__, "Could not encode OpenPDU (at %s)\n",
  80             error.failed_type ? error.failed_type->name : "unknown");
  81     return -1;
  82     }
  83 else
  84     {
  85     write(fd, buffer, error.encoded);
  86     printfd(__FILE__, "OpenPDU encoded successfully to %d bytes\n", error.encoded);
  87     }
  88 return 0;
  89 }
  90
  91 int SendClosePDU(int fd)
  92 {
  93 ClosePDU_t msg;
  94
  95 memset(&msg, 0, sizeof(msg));
  96
  97 asn_long2INTEGER(&msg, ClosePDU_goingDown);
  98
  99 char buffer[1024];
 100 asn_enc_rval_t error;
 101 error = der_encode_to_buffer(&asn_DEF_ClosePDU, &msg, buffer, sizeof(buffer));
 102
 103 if (error.encoded == -1)
 104     {
 105     printfd(__FILE__, "Could not encode ClosePDU (at %s)\n",
 106             error.failed_type ? error.failed_type->name : "unknown");
 107     return -1;
 108     }
 109 else
 110     {
 111     write(fd, buffer, error.encoded);
 112     printfd(__FILE__, "ClosePDU encoded successfully\n");
 113     }
 114 return 0;
 115 }
 116
 117 int SendRReqPDU(int fd)
 118 {
 119 int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1};
 120 asn_enc_rval_t error;
 121 RReqPDU_t msg;
 122
 123 memset(&msg, 0, sizeof(msg));
 124
 125 msg.priority = 0;
 126 asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly);
 127 OBJECT_IDENTIFIER_set_arcs(&msg.subtree,
 128                            oid,
 129                            sizeof(oid[0]),
 130                            8);
 131
 132 char buffer[1024];
 133 error = der_encode_to_buffer(&asn_DEF_RReqPDU, &msg, buffer, sizeof(buffer));
 134
 135 if (error.encoded == -1)
 136     {
 137     printfd(__FILE__, "Could not encode RReqPDU (at %s)\n",
 138             error.failed_type ? error.failed_type->name : "unknown");
 139     return -1;
 140     }
 141 else
 142     {
 143     write(fd, buffer, error.encoded);
 144     printfd(__FILE__, "RReqPDU encoded successfully to %d bytes\n", error.encoded);
 145     }
 146 return 0;
 147 }
 148
 149 SMUX_PDUs_t * RecvSMUXPDUs(int fd)
 150 {
 151 char buffer[1024];
 152 SMUX_PDUs_t * pdus = NULL;
 153
 154 memset(buffer, 0, sizeof(buffer));
 155
 156 size_t length = read(fd, buffer, sizeof(buffer));
 157 if (length < 1)
 158     return NULL;
 159 asn_dec_rval_t error;
 160 error = ber_decode(0, &asn_DEF_SMUX_PDUs, (void **)&pdus, buffer, length);
 161 if(error.code != RC_OK)
 162     {
 163     printfd(__FILE__, "Failed to decode PDUs at byte %ld\n",
 164             (long)error.consumed);
 165     return NULL;
 166     }
 167 return pdus;
 168 }
 169
 170 int ParseIntInRange(const std::string & str,
 171                     int min,
 172                     int max,
 173                     int * val)
 174 {
 175 if (str2x(str.c_str(), *val))
 176     {
 177     return -1;
 178     }
 179 if (*val < min || *val > max)
 180     {
 181     return -1;
 182     }
 183 return 0;
 184 }
 185
 186 SNMP_AGENT_SETTINGS::SNMP_AGENT_SETTINGS()
 187     : ip(0),
 188       port(0)
 189 {}
 190
 191 int SNMP_AGENT_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 192 {
 193 PARAM_VALUE pv;
 194 std::vector<PARAM_VALUE>::const_iterator pvi;
 195 int p;
 196 ///////////////////////////
 197 pv.param = "Port";
 198 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 199 if (pvi == s.moduleParams.end())
 200     {
 201     errorStr = "Parameter \'Port\' not found.";
 202     printfd(__FILE__, "Parameter 'Port' not found\n");
 203     return -1;
 204     }
 205 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
 206     {
 207     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
 208     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
 209     return -1;
 210     }
 211 port = p;
 212
 213 pv.param = "Password";
 214 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 215 if (pvi == s.moduleParams.end())
 216     {
 217     errorStr = "Parameter \'Password\' not found.";
 218     printfd(__FILE__, "Parameter 'Password' not found\n");
 219     password = "";
 220     }
 221 else
 222     {
 223     password = pvi->value[0];
 224     }
 225
 226 pv.param = "Server";
 227 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 228 if (pvi == s.moduleParams.end())
 229     {
 230     errorStr = "Parameter \'Server\' not found.";
 231     printfd(__FILE__, "Parameter 'Server' not found\n");
 232     return -1;
 233     }
 234 ip = inet_strington(pvi->value[0]);
 235
 236 return 0;
 237 }
 238
 239 SNMP_AGENT::SNMP_AGENT()
 240     : PLUGIN(),
 241       running(false),
 242       stopped(true),
 243       sock(-1)
 244 {
 245 pthread_mutex_init(&mutex, NULL);
 246
 247 smuxHandlers[SMUX_PDUs_PR_close] = &SNMP_AGENT::CloseHandler;
 248 smuxHandlers[SMUX_PDUs_PR_registerResponse] = &SNMP_AGENT::RegisterResponseHandler;
 249 smuxHandlers[SMUX_PDUs_PR_pdus] = &SNMP_AGENT::PDUsHandler;
 250 smuxHandlers[SMUX_PDUs_PR_commitOrRollback] = &SNMP_AGENT::CommitOrRollbackHandler;
 251
 252 pdusHandlers[PDUs_PR_get_request] = &SNMP_AGENT::GetRequestHandler;
 253 pdusHandlers[PDUs_PR_get_next_request] = &SNMP_AGENT::GetNextRequestHandler;
 254 pdusHandlers[PDUs_PR_set_request] = &SNMP_AGENT::SetRequestHandler;
 255 }
 256
 257 SNMP_AGENT::~SNMP_AGENT()
 258 {
 259 printfd(__FILE__, "SNMP_AGENT::~SNMP_AGENT()\n");
 260 pthread_mutex_destroy(&mutex);
 261 }
 262
 263 int SNMP_AGENT::ParseSettings()
 264 {
 265 return snmpAgentSettings.ParseSettings(settings);
 266 }
 267
 268 int SNMP_AGENT::Start()
 269 {
 270 if (PrepareNet())
 271     return -1;
 272
 273 if (!running)
 274     {
 275     if (pthread_create(&thread, NULL, Runner, this))
 276         {
 277         errorStr = "Cannot create thread.";
 278         printfd(__FILE__, "Cannot create thread\n");
 279         return -1;
 280         }
 281     }
 282
 283 return 0;
 284 }
 285
 286 int SNMP_AGENT::Stop()
 287 {
 288 printfd(__FILE__, "SNMP_AGENT::Stop() - Before\n");
 289 running = false;
 290
 291 if (!stopped)
 292     {
 293     //5 seconds to thread stops itself
 294     for (int i = 0; i < 25 && !stopped; i++)
 295         {
 296         struct timespec ts = {0, 200000000};
 297         nanosleep(&ts, NULL);
 298         }
 299
 300     //after 5 seconds waiting thread still running. now killing it
 301     if (!stopped)
 302         {
 303         printfd(__FILE__, "SNMP_AGENT::Stop() - failed to stop thread, killing it\n");
 304         if (pthread_kill(thread, SIGINT))
 305             {
 306             errorStr = "Cannot kill thread.";
 307             printfd(__FILE__, "SNMP_AGENT::Stop() - Cannot kill thread\n");
 308             return -1;
 309             }
 310         printfd(__FILE__, "SNMP_AGENT::Stop() -  killed Run\n");
 311         }
 312     }
 313
 314 pthread_join(thread, NULL);
 315
 316 close(sock);
 317
 318 printfd(__FILE__, "SNMP_AGENT::Stop() - After\n");
 319 return 0;
 320 }
 321
 322 void * SNMP_AGENT::Runner(void * d)
 323 {
 324 SNMP_AGENT * snmpAgent = static_cast<SNMP_AGENT *>(d);
 325
 326 snmpAgent->Run();
 327
 328 return NULL;
 329 }
 330
 331 void SNMP_AGENT::Run()
 332 {
 333 SendOpenPDU(sock);
 334 SendRReqPDU(sock);
 335 running = true;
 336 stopped = false;
 337 printfd(__FILE__, "SNMP_AGENT::Run() - Before\n");
 338 while(running)
 339     {
 340     if (WaitPackets(sock))
 341         {
 342         SMUX_PDUs_t * pdus = RecvSMUXPDUs(sock);
 343         if (pdus)
 344             DispatchPDUs(pdus);
 345         }
 346     if (!running)
 347         break;
 348     }
 349 printfd(__FILE__, "SNMP_AGENT::Run() - After\n");
 350 SendClosePDU(sock);
 351 stopped = true;
 352 }
 353
 354 bool SNMP_AGENT::PrepareNet()
 355 {
 356 sock = socket(AF_INET, SOCK_STREAM, 0);
 357
 358 if (sock < 0)
 359     {
 360     errorStr = "Cannot create socket.";
 361     printfd(__FILE__, "Cannot create socket\n");
 362     return true;
 363     }
 364
 365 struct sockaddr_in addr;
 366
 367 addr.sin_family = AF_INET;
 368 addr.sin_port = htons(snmpAgentSettings.GetPort());
 369 addr.sin_addr.s_addr = snmpAgentSettings.GetIP();
 370
 371 if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)))
 372     {
 373     errorStr = "Cannot connect.";
 374     printfd(__FILE__, "Cannot connect. Message: '%s'\n", strerror(errno));
 375     return true;
 376     }
 377
 378 return false;
 379 }
 380
 381 bool WaitPackets(int sd)
 382 {
 383 fd_set rfds;
 384 FD_ZERO(&rfds);
 385 FD_SET(sd, &rfds);
 386
 387 struct timeval tv;
 388 tv.tv_sec = 0;
 389 tv.tv_usec = 500000;
 390
 391 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
 392 if (res == -1) // Error
 393     {
 394     if (errno != EINTR)
 395         {
 396         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
 397         }
 398     return false;
 399     }
 400
 401 if (res == 0) // Timeout
 402     {
 403     return false;
 404     }
 405
 406 return true;
 407 }
 408
 409 bool SNMP_AGENT::DispatchPDUs(const SMUX_PDUs_t * pdus)
 410 {
 411 SMUXHandlers::iterator it;
 412 it = smuxHandlers.find(pdus->present);
 413 if (it != smuxHandlers.end())
 414     {
 415     return (this->*(it->second))(pdus);
 416     }
 417 else
 418     {
 419     switch (pdus->present)
 420         {
 421         case SMUX_PDUs_PR_NOTHING:
 422             printfd(__FILE__, "PDUs: nothing\n");
 423             break;
 424         case SMUX_PDUs_PR_open:
 425             printfd(__FILE__, "PDUs: open\n");
 426             break;
 427         case SMUX_PDUs_PR_registerRequest:
 428             printfd(__FILE__, "PDUs: registerRequest\n");
 429             break;
 430         default:
 431             printfd(__FILE__, "PDUs: undefined\n");
 432         }
 433     asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 434     }
 435 return false;
 436 }
 437
 438 bool SNMP_AGENT::CloseHandler(const SMUX_PDUs_t * pdus)
 439 {
 440 printfd(__FILE__, "SNMP_AGENT::CloseHandler()\n");
 441 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 442 return false;
 443 }
 444
 445 bool SNMP_AGENT::RegisterResponseHandler(const SMUX_PDUs_t * pdus)
 446 {
 447 printfd(__FILE__, "SNMP_AGENT::RegisterResponseHandler()\n");
 448 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 449 return false;
 450 }
 451
 452 bool SNMP_AGENT::PDUsHandler(const SMUX_PDUs_t * pdus)
 453 {
 454 printfd(__FILE__, "SNMP_AGENT::PDUsHandler()\n");
 455 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 456 PDUsHandlers::iterator it;
 457 it = pdusHandlers.find(pdus->choice.pdus.present);
 458 if (it != pdusHandlers.end())
 459     {
 460     return (this->*(it->second))(&pdus->choice.pdus);
 461     }
 462 else
 463     {
 464     switch (pdus->present)
 465         {
 466         case PDUs_PR_NOTHING:
 467             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - nothing\n");
 468             break;
 469         case PDUs_PR_get_response:
 470             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - get response\n");
 471             break;
 472         case PDUs_PR_trap:
 473             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - trap\n");
 474             break;
 475         default:
 476             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - undefined\n");
 477         }
 478     }
 479 return false;
 480 }
 481
 482 bool SNMP_AGENT::CommitOrRollbackHandler(const SMUX_PDUs_t * pdus)
 483 {
 484 printfd(__FILE__, "SNMP_AGENT::CommitOrRollbackHandler()\n");
 485 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
 486 return false;
 487 }
 488
 489 bool SNMP_AGENT::GetRequestHandler(const PDUs_t * pdus)
 490 {
 491 printfd(__FILE__, "SNMP_AGENT::GetRequestHandler()\n");
 492 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
 493 return false;
 494 }
 495
 496 bool SNMP_AGENT::GetNextRequestHandler(const PDUs_t * pdus)
 497 {
 498 printfd(__FILE__, "SNMP_AGENT::GetNextRequestHandler()\n");
 499 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
 500 return false;
 501 }
 502
 503 bool SNMP_AGENT::SetRequestHandler(const PDUs_t * pdus)
 504 {
 505 printfd(__FILE__, "SNMP_AGENT::SetRequestHandler()\n");
 506 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
 507 return false;
 508 }
 509