]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/snmp/snmp.cpp
8587c1bcb2f7d946dab5941ff8d03ced8aabed39
[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/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 }