]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/snmp/snmp.cpp
Request dispatching added
[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/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