]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/snmp/snmp.cpp
Use data sensors in queries
[stg.git] / 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/GetRequest-PDU.h"
17 #include "asn1/GetResponse-PDU.h"
18 #include "asn1/VarBindList.h"
19 #include "asn1/VarBind.h"
20 #include "asn1/OBJECT_IDENTIFIER.h"
21 #include "asn1/ber_decoder.h"
22 #include "asn1/der_encoder.h"
23
24 #include "snmp.h"
25 #include "stg/common.h"
26
27 bool WaitPackets(int sd);
28
29 std::string OI2String(OBJECT_IDENTIFIER_t * oi)
30 {
31 std::string res;
32
33 int arcs[1024];
34 int count = OBJECT_IDENTIFIER_get_arcs(oi, arcs, sizeof(arcs[0]), 1024);
35
36 if (count > 1024)
37     return "";
38
39 for (int i = 0; i < count; ++i)
40     {
41     res += ".";
42     std::string arc;
43     strprintf(&arc, "%d", arcs[i]);
44     res += arc;
45     }
46
47 return res;
48 }
49
50 bool String2OI(const std::string & str, OBJECT_IDENTIFIER_t * oi)
51 {
52 size_t left = 0, pos = 0, arcPos = 0;
53 int arcs[1024];
54 pos = str.find_first_of('.', left);
55 if (pos == 0)
56     {
57     left = 1;
58     pos = str.find_first_of('.', left);
59     }
60 while (pos != std::string::npos)
61     {
62     int arc = 0;
63     if (str2x(str.substr(left, left - pos), arc))
64         {
65         return false;
66         }
67     arcs[arcPos++] = arc;
68     left = pos + 1;
69     pos = str.find_first_of('.', left);
70     }
71 if (left < str.length())
72     {
73     int arc = 0;
74     if (str2x(str.substr(left, left - pos), arc))
75         {
76         return false;
77         }
78     arcs[arcPos++] = arc;
79     }
80 printfd(__FILE__, "String2OI() - arcPos: %d\n", arcPos);
81 OBJECT_IDENTIFIER_set_arcs(oi, arcs, sizeof(arcs[0]), arcPos);
82 return true;
83 }
84
85 class SNMP_AGENT_CREATOR
86 {
87 private:
88     SNMP_AGENT * snmpAgent;
89
90 public:
91     SNMP_AGENT_CREATOR()
92         : snmpAgent(new SNMP_AGENT())
93         {
94         };
95     ~SNMP_AGENT_CREATOR()
96         {
97         printfd(__FILE__, "SNMP_AGENT_CREATOR::~SNMP_AGENT_CREATOR()\n");
98         delete snmpAgent;
99         };
100
101     SNMP_AGENT * GetPlugin()
102         {
103         return snmpAgent;
104         };
105 };
106
107 SNMP_AGENT_CREATOR sac;
108
109 PLUGIN * GetPlugin()
110 {
111 return sac.GetPlugin();
112 }
113
114 int SendOpenPDU(int fd)
115 {
116 const char * description = "Stg SNMP Agent";
117 //int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1, 5, 2, 1, 1};
118 asn_enc_rval_t error;
119 OpenPDU_t msg;
120
121 memset(&msg, 0, sizeof(msg));
122
123 msg.present = OpenPDU_PR_simple;
124 asn_long2INTEGER(&msg.choice.simple.version, SimpleOpen__version_version_1);
125 /*OBJECT_IDENTIFIER_set_arcs(&msg.choice.simple.identity,
126                            oid,
127                            sizeof(oid[0]),
128                            7);*/
129 if (!String2OI(".1.3.6.1.4.1.9363", &msg.choice.simple.identity))
130     {
131     printfd(__FILE__, "SendOpenPDU() - failed to convert string to OBJECT_IDENTIFIER\n");
132     return -1;
133     }
134 OCTET_STRING_fromString(&msg.choice.simple.description,
135                      description);
136 OCTET_STRING_fromString(&msg.choice.simple.password,
137                      "");
138
139 char buffer[1024];
140 error = der_encode_to_buffer(&asn_DEF_OpenPDU, &msg, buffer, sizeof(buffer));
141
142 if (error.encoded == -1)
143     {
144     printfd(__FILE__, "Could not encode OpenPDU (at %s)\n",
145             error.failed_type ? error.failed_type->name : "unknown");
146     return -1;
147     }
148 else
149     {
150     write(fd, buffer, error.encoded);
151     printfd(__FILE__, "OpenPDU encoded successfully to %d bytes\n", error.encoded);
152     }
153 return 0;
154 }
155
156 int SendClosePDU(int fd)
157 {
158 ClosePDU_t msg;
159
160 memset(&msg, 0, sizeof(msg));
161
162 asn_long2INTEGER(&msg, ClosePDU_goingDown);
163
164 char buffer[1024];
165 asn_enc_rval_t error;
166 error = der_encode_to_buffer(&asn_DEF_ClosePDU, &msg, buffer, sizeof(buffer));
167
168 if (error.encoded == -1)
169     {
170     printfd(__FILE__, "Could not encode ClosePDU (at %s)\n",
171             error.failed_type ? error.failed_type->name : "unknown");
172     return -1;
173     }
174 else
175     {
176     write(fd, buffer, error.encoded);
177     printfd(__FILE__, "ClosePDU encoded successfully\n");
178     }
179 return 0;
180 }
181
182 int SendRReqPDU(int fd)
183 {
184 int oid[] = {1, 3, 6, 1, 4, 1, 9363, 1};
185 asn_enc_rval_t error;
186 RReqPDU_t msg;
187
188 memset(&msg, 0, sizeof(msg));
189
190 msg.priority = 0;
191 asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly);
192 OBJECT_IDENTIFIER_set_arcs(&msg.subtree,
193                            oid,
194                            sizeof(oid[0]),
195                            8);
196
197 char buffer[1024];
198 error = der_encode_to_buffer(&asn_DEF_RReqPDU, &msg, buffer, sizeof(buffer));
199
200 if (error.encoded == -1)
201     {
202     printfd(__FILE__, "Could not encode RReqPDU (at %s)\n",
203             error.failed_type ? error.failed_type->name : "unknown");
204     return -1;
205     }
206 else
207     {
208     write(fd, buffer, error.encoded);
209     printfd(__FILE__, "RReqPDU encoded successfully to %d bytes\n", error.encoded);
210     }
211 return 0;
212 }
213
214 int SendGetResponsePDU(int fd, GetResponse_PDU_t * getResponse)
215 {
216 asn_enc_rval_t error;
217
218 char buffer[1024];
219 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, getResponse, buffer, sizeof(buffer));
220
221 if (error.encoded == -1)
222     {
223     printfd(__FILE__, "Could not encode GetResponsePDU (at %s)\n",
224             error.failed_type ? error.failed_type->name : "unknown");
225     return -1;
226     }
227 else
228     {
229     write(fd, buffer, error.encoded);
230     printfd(__FILE__, "GetResponsePDU encoded successfully to %d bytes\n", error.encoded);
231     }
232 return 0;
233 }
234
235 int SendGetResponseErrorPDU(int fd, const PDU_t * getRequest, int errorStatus, int errorIndex)
236 {
237 asn_enc_rval_t error;
238 GetResponse_PDU_t msg;
239
240 memset(&msg, 0, sizeof(msg));
241
242 msg.request_id = getRequest->request_id;
243 asn_long2INTEGER(&msg.error_status, errorStatus);
244 asn_long2INTEGER(&msg.error_index, errorIndex);
245
246 char buffer[1024];
247 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, &msg, buffer, sizeof(buffer));
248
249 if (error.encoded == -1)
250     {
251     printfd(__FILE__, "Could not encode GetResponsePDU for error (at %s)\n",
252             error.failed_type ? error.failed_type->name : "unknown");
253     return -1;
254     }
255 else
256     {
257     write(fd, buffer, error.encoded);
258     printfd(__FILE__, "GetResponsePDU for error encoded successfully to %d bytes\n", error.encoded);
259     }
260 return 0;
261 }
262
263 SMUX_PDUs_t * RecvSMUXPDUs(int fd)
264 {
265 char buffer[1024];
266 SMUX_PDUs_t * pdus = NULL;
267
268 memset(buffer, 0, sizeof(buffer));
269
270 size_t length = read(fd, buffer, sizeof(buffer));
271 if (length < 1)
272     return NULL;
273 asn_dec_rval_t error;
274 error = ber_decode(0, &asn_DEF_SMUX_PDUs, (void **)&pdus, buffer, length);
275 if(error.code != RC_OK)
276     {
277     printfd(__FILE__, "Failed to decode PDUs at byte %ld\n",
278             (long)error.consumed);
279     return NULL;
280     }
281 return pdus;
282 }
283
284 int ParseIntInRange(const std::string & str,
285                     int min,
286                     int max,
287                     int * val)
288 {
289 if (str2x(str.c_str(), *val))
290     {
291     return -1;
292     }
293 if (*val < min || *val > max)
294     {
295     return -1;
296     }
297 return 0;
298 }
299
300 SNMP_AGENT_SETTINGS::SNMP_AGENT_SETTINGS()
301     : ip(0),
302       port(0)
303 {}
304
305 int SNMP_AGENT_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
306 {
307 PARAM_VALUE pv;
308 std::vector<PARAM_VALUE>::const_iterator pvi;
309 int p;
310 ///////////////////////////
311 pv.param = "Port";
312 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
313 if (pvi == s.moduleParams.end())
314     {
315     errorStr = "Parameter \'Port\' not found.";
316     printfd(__FILE__, "Parameter 'Port' not found\n");
317     return -1;
318     }
319 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
320     {
321     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
322     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
323     return -1;
324     }
325 port = p;
326
327 pv.param = "Password";
328 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
329 if (pvi == s.moduleParams.end())
330     {
331     errorStr = "Parameter \'Password\' not found.";
332     printfd(__FILE__, "Parameter 'Password' not found\n");
333     password = "";
334     }
335 else
336     {
337     password = pvi->value[0];
338     }
339
340 pv.param = "Server";
341 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
342 if (pvi == s.moduleParams.end())
343     {
344     errorStr = "Parameter \'Server\' not found.";
345     printfd(__FILE__, "Parameter 'Server' not found\n");
346     return -1;
347     }
348 ip = inet_strington(pvi->value[0]);
349
350 return 0;
351 }
352
353 SNMP_AGENT::SNMP_AGENT()
354     : PLUGIN(),
355       users(NULL),
356       tariffs(NULL),
357       running(false),
358       stopped(true),
359       sock(-1)
360 {
361 pthread_mutex_init(&mutex, NULL);
362
363 smuxHandlers[SMUX_PDUs_PR_close] = &SNMP_AGENT::CloseHandler;
364 smuxHandlers[SMUX_PDUs_PR_registerResponse] = &SNMP_AGENT::RegisterResponseHandler;
365 smuxHandlers[SMUX_PDUs_PR_pdus] = &SNMP_AGENT::PDUsHandler;
366 smuxHandlers[SMUX_PDUs_PR_commitOrRollback] = &SNMP_AGENT::CommitOrRollbackHandler;
367
368 pdusHandlers[PDUs_PR_get_request] = &SNMP_AGENT::GetRequestHandler;
369 pdusHandlers[PDUs_PR_get_next_request] = &SNMP_AGENT::GetNextRequestHandler;
370 pdusHandlers[PDUs_PR_set_request] = &SNMP_AGENT::SetRequestHandler;
371 }
372
373 SNMP_AGENT::~SNMP_AGENT()
374 {
375 Sensors::iterator it;
376 for (it = sensors.begin(); it != sensors.end(); ++it)
377     delete it->second;
378 printfd(__FILE__, "SNMP_AGENT::~SNMP_AGENT()\n");
379 pthread_mutex_destroy(&mutex);
380 }
381
382 int SNMP_AGENT::ParseSettings()
383 {
384 return snmpAgentSettings.ParseSettings(settings);
385 }
386
387 int SNMP_AGENT::Start()
388 {
389 if (PrepareNet())
390     return -1;
391
392 // Users
393 sensors[".1.3.6.1.4.1.9363.1.1.1"] = new TotalUsersSensor(*users);
394 sensors[".1.3.6.1.4.1.9363.1.1.2"] = new ConnectedUsersSensor(*users);
395 sensors[".1.3.6.1.4.1.9363.1.1.3"] = new AuthorizedUsersSensor(*users);
396 sensors[".1.3.6.1.4.1.9363.1.1.4"] = new AlwaysOnlineUsersSensor(*users);
397 sensors[".1.3.6.1.4.1.9363.1.1.5"] = new NoCashUsersSensor(*users);
398 sensors[".1.3.6.1.4.1.9363.1.1.7"] = new DisabledDetailStatsUsersSensor(*users);
399 sensors[".1.3.6.1.4.1.9363.1.1.8"] = new DisabledUsersSensor(*users);
400 sensors[".1.3.6.1.4.1.9363.1.1.9"] = new PassiveUsersSensor(*users);
401 sensors[".1.3.6.1.4.1.9363.1.1.10"] = new CreditUsersSensor(*users);
402 sensors[".1.3.6.1.4.1.9363.1.1.11"] = new FreeMbUsersSensor(*users);
403 // Tariffs
404 sensors[".1.3.6.1.4.1.9363.1.2.1"] = new TotalTariffsSensor(*tariffs);
405
406 if (!running)
407     {
408     if (pthread_create(&thread, NULL, Runner, this))
409         {
410         errorStr = "Cannot create thread.";
411         printfd(__FILE__, "Cannot create thread\n");
412         return -1;
413         }
414     }
415
416 return 0;
417 }
418
419 int SNMP_AGENT::Stop()
420 {
421 printfd(__FILE__, "SNMP_AGENT::Stop() - Before\n");
422 running = false;
423
424 if (!stopped)
425     {
426     //5 seconds to thread stops itself
427     for (int i = 0; i < 25 && !stopped; i++)
428         {
429         struct timespec ts = {0, 200000000};
430         nanosleep(&ts, NULL);
431         }
432
433     //after 5 seconds waiting thread still running. now killing it
434     if (!stopped)
435         {
436         printfd(__FILE__, "SNMP_AGENT::Stop() - failed to stop thread, killing it\n");
437         if (pthread_kill(thread, SIGINT))
438             {
439             errorStr = "Cannot kill thread.";
440             printfd(__FILE__, "SNMP_AGENT::Stop() - Cannot kill thread\n");
441             return -1;
442             }
443         printfd(__FILE__, "SNMP_AGENT::Stop() -  killed Run\n");
444         }
445     }
446
447 pthread_join(thread, NULL);
448
449 close(sock);
450
451 printfd(__FILE__, "SNMP_AGENT::Stop() - After\n");
452 return 0;
453 }
454
455 void * SNMP_AGENT::Runner(void * d)
456 {
457 SNMP_AGENT * snmpAgent = static_cast<SNMP_AGENT *>(d);
458
459 snmpAgent->Run();
460
461 return NULL;
462 }
463
464 void SNMP_AGENT::Run()
465 {
466 SendOpenPDU(sock);
467 SendRReqPDU(sock);
468 running = true;
469 stopped = false;
470 printfd(__FILE__, "SNMP_AGENT::Run() - Before\n");
471 while(running)
472     {
473     if (WaitPackets(sock))
474         {
475         SMUX_PDUs_t * pdus = RecvSMUXPDUs(sock);
476         if (pdus)
477             DispatchPDUs(pdus);
478         }
479     if (!running)
480         break;
481     }
482 printfd(__FILE__, "SNMP_AGENT::Run() - After\n");
483 SendClosePDU(sock);
484 stopped = true;
485 }
486
487 bool SNMP_AGENT::PrepareNet()
488 {
489 sock = socket(AF_INET, SOCK_STREAM, 0);
490
491 if (sock < 0)
492     {
493     errorStr = "Cannot create socket.";
494     printfd(__FILE__, "Cannot create socket\n");
495     return true;
496     }
497
498 struct sockaddr_in addr;
499
500 addr.sin_family = AF_INET;
501 addr.sin_port = htons(snmpAgentSettings.GetPort());
502 addr.sin_addr.s_addr = snmpAgentSettings.GetIP();
503
504 if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)))
505     {
506     errorStr = "Cannot connect.";
507     printfd(__FILE__, "Cannot connect. Message: '%s'\n", strerror(errno));
508     return true;
509     }
510
511 return false;
512 }
513
514 bool WaitPackets(int sd)
515 {
516 fd_set rfds;
517 FD_ZERO(&rfds);
518 FD_SET(sd, &rfds);
519
520 struct timeval tv;
521 tv.tv_sec = 0;
522 tv.tv_usec = 500000;
523
524 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
525 if (res == -1) // Error
526     {
527     if (errno != EINTR)
528         {
529         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
530         }
531     return false;
532     }
533
534 if (res == 0) // Timeout
535     {
536     return false;
537     }
538
539 return true;
540 }
541
542 bool SNMP_AGENT::DispatchPDUs(const SMUX_PDUs_t * pdus)
543 {
544 SMUXHandlers::iterator it;
545 it = smuxHandlers.find(pdus->present);
546 if (it != smuxHandlers.end())
547     {
548     return (this->*(it->second))(pdus);
549     }
550 else
551     {
552     switch (pdus->present)
553         {
554         case SMUX_PDUs_PR_NOTHING:
555             printfd(__FILE__, "PDUs: nothing\n");
556             break;
557         case SMUX_PDUs_PR_open:
558             printfd(__FILE__, "PDUs: open\n");
559             break;
560         case SMUX_PDUs_PR_registerRequest:
561             printfd(__FILE__, "PDUs: registerRequest\n");
562             break;
563         default:
564             printfd(__FILE__, "PDUs: undefined\n");
565         }
566     asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
567     }
568 return false;
569 }
570
571 bool SNMP_AGENT::CloseHandler(const SMUX_PDUs_t * pdus)
572 {
573 printfd(__FILE__, "SNMP_AGENT::CloseHandler()\n");
574 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
575 return false;
576 }
577
578 bool SNMP_AGENT::RegisterResponseHandler(const SMUX_PDUs_t * pdus)
579 {
580 printfd(__FILE__, "SNMP_AGENT::RegisterResponseHandler()\n");
581 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
582 return false;
583 }
584
585 bool SNMP_AGENT::PDUsHandler(const SMUX_PDUs_t * pdus)
586 {
587 printfd(__FILE__, "SNMP_AGENT::PDUsHandler()\n");
588 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
589 PDUsHandlers::iterator it;
590 it = pdusHandlers.find(pdus->choice.pdus.present);
591 if (it != pdusHandlers.end())
592     {
593     return (this->*(it->second))(&pdus->choice.pdus);
594     }
595 else
596     {
597     switch (pdus->present)
598         {
599         case PDUs_PR_NOTHING:
600             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - nothing\n");
601             break;
602         case PDUs_PR_get_response:
603             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - get response\n");
604             break;
605         case PDUs_PR_trap:
606             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - trap\n");
607             break;
608         default:
609             printfd(__FILE__, "SNMP_AGENT::PDUsHandler() - undefined\n");
610         }
611     }
612 return false;
613 }
614
615 bool SNMP_AGENT::CommitOrRollbackHandler(const SMUX_PDUs_t * pdus)
616 {
617 printfd(__FILE__, "SNMP_AGENT::CommitOrRollbackHandler()\n");
618 asn_fprint(stderr, &asn_DEF_SMUX_PDUs, pdus);
619 return false;
620 }
621
622 bool SNMP_AGENT::GetRequestHandler(const PDUs_t * pdus)
623 {
624 printfd(__FILE__, "SNMP_AGENT::GetRequestHandler()\n");
625 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
626 const GetRequest_PDU_t * getRequest = &pdus->choice.get_request;
627 GetResponse_PDU_t msg;
628 VarBindList_t * varBindList = &msg.variable_bindings;
629 memset(&msg, 0, sizeof(msg));
630
631 msg.request_id = getRequest->request_id;
632 asn_long2INTEGER(&msg.error_status, 0);
633 asn_long2INTEGER(&msg.error_index, 0);
634
635 const VarBindList_t * vbl = &getRequest->variable_bindings; 
636 for (int i = 0; i < vbl->list.count; ++i)
637     {
638     VarBind_t * vb = getRequest->variable_bindings.list.array[i];
639     Sensors::iterator it;
640     it = sensors.find(OI2String(&vb->name));
641     if (it == sensors.end())
642         {
643         SendGetResponseErrorPDU(sock, getRequest, PDU__error_status_noSuchName, i);
644         return true;
645         }
646
647     VarBind_t newVb;
648     memset(&newVb, 0, sizeof(newVb));
649
650     newVb.name = vb->name;
651     it->second->GetValue(&newVb.value);
652
653     ASN_SEQUENCE_ADD(varBindList, &newVb);
654     }
655
656 SendGetResponsePDU(sock, &msg);
657 asn_fprint(stderr, &asn_DEF_PDU, &msg);
658 return false;
659 }
660
661 bool SNMP_AGENT::GetNextRequestHandler(const PDUs_t * pdus)
662 {
663 printfd(__FILE__, "SNMP_AGENT::GetNextRequestHandler()\n");
664 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
665 return false;
666 }
667
668 bool SNMP_AGENT::SetRequestHandler(const PDUs_t * pdus)
669 {
670 printfd(__FILE__, "SNMP_AGENT::SetRequestHandler()\n");
671 asn_fprint(stderr, &asn_DEF_PDUs, pdus);
672 SendGetResponseErrorPDU(sock, &pdus->choice.set_request, PDU__error_status_readOnly, 0);
673 return false;
674 }
675