Debian Codegraph @

agent/mibgroup/disman/traceroute/traceRouteCtlTable.c

raw
1 /*
2 *Copyright(c)2004,Cisco URP imburses and Network Information Center in Beijing University of Posts and Telecommunications researches.
3 *
4 *All right reserved
5 *
6 *File Name:traceRouteCtlTable.c
7 *File Description:Rows of traceRouteCtlTable MIB add delete ans read.
8 * Rows of traceRouteResultsTable MIB add and delete.
9 * Rows of traceRouteProbeHistoryTable MIB add and delete.
10 * Rows of traceRouteHopsTable MIB add and delete.
11 * The main function is also here.
12 *
13 *Current Version:1.0
14 *Author:ChenJing
15 *Date:2004.8.20
16 */
17
18
19 #include <net-snmp/net-snmp-config.h>
20 #include <net-snmp/net-snmp-includes.h>
21 #include <net-snmp/net-snmp-features.h>
22 #include <net-snmp/agent/net-snmp-agent-includes.h>
23 #include <pthread.h>
24 #include <math.h>
25 #include <stddef.h>
26
27 #ifndef NETSNMP_NO_WRITE_SUPPORT
28 netsnmp_feature_require(header_complex_find_entry);
29 #endif /* NETSNMP_NO_WRITE_SUPPORT */
30
31 #include "traceRouteCtlTable.h"
32 #include "traceRouteResultsTable.h"
33 #include "traceRouteProbeHistoryTable.h"
34 #include "traceRouteHopsTable.h"
35 #include "header_complex.h"
36
37 oid traceRouteCtlTable_variables_oid[] =
38 { 1, 3, 6, 1, 2, 1, 81, 1, 2 };
39
40 /* trap */
41 oid traceRoutePathChange[] = { 1, 3, 6, 1, 2, 1, 81, 0, 1 };
42 oid traceRouteTestFailed[] = { 1, 3, 6, 1, 2, 1, 81, 0, 2 };
43 oid traceRouteTestCompleted[] = { 1, 3, 6, 1, 2, 1, 81, 0, 3 };
44
45 struct variable2 traceRouteCtlTable_variables[] = {
46 /*
47 * magic number , variable type , ro/rw , callback fn , L, oidsuffix
48 */
49
50 {COLUMN_TRACEROUTECTLTARGETADDRESSTYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
51 var_traceRouteCtlTable, 2, {1, 3}},
52 {COLUMN_TRACEROUTECTLTARGETADDRESS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
53 var_traceRouteCtlTable, 2, {1, 4}},
54 {COLUMN_TRACEROUTECTLBYPASSROUTETABLE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
55 var_traceRouteCtlTable, 2, {1, 5}},
56 {COLUMN_TRACEROUTECTLDATASIZE, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
57 var_traceRouteCtlTable, 2, {1, 6}},
58 {COLUMN_TRACEROUTECTLTIMEOUT, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
59 var_traceRouteCtlTable, 2, {1, 7}},
60 {COLUMN_TRACEROUTECTLPROBESPERHOP, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
61 var_traceRouteCtlTable, 2, {1, 8}},
62 {COLUMN_TRACEROUTECTLPORT, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
63 var_traceRouteCtlTable, 2, {1, 9}},
64 {COLUMN_TRACEROUTECTLMAXTTL, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
65 var_traceRouteCtlTable, 2, {1, 10}},
66 {COLUMN_TRACEROUTECTLDSFIELD, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
67 var_traceRouteCtlTable, 2, {1, 11}},
68 {COLUMN_TRACEROUTECTLSOURCEADDRESSTYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
69 var_traceRouteCtlTable, 2, {1, 12}},
70 {COLUMN_TRACEROUTECTLSOURCEADDRESS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
71 var_traceRouteCtlTable, 2, {1, 13}},
72 {COLUMN_TRACEROUTECTLIFINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
73 var_traceRouteCtlTable, 2, {1, 14}},
74 {COLUMN_TRACEROUTECTLMISCOPTIONS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
75 var_traceRouteCtlTable, 2, {1, 15}},
76 {COLUMN_TRACEROUTECTLMAXFAILURES, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
77 var_traceRouteCtlTable, 2, {1, 16}},
78 {COLUMN_TRACEROUTECTLDONTFRAGMENT, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
79 var_traceRouteCtlTable, 2, {1, 17}},
80 {COLUMN_TRACEROUTECTLINITIALTTL, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
81 var_traceRouteCtlTable, 2, {1, 18}},
82 {COLUMN_TRACEROUTECTLFREQUENCY, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
83 var_traceRouteCtlTable, 2, {1, 19}},
84 {COLUMN_TRACEROUTECTLSTORAGETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
85 var_traceRouteCtlTable, 2, {1, 20}},
86 {COLUMN_TRACEROUTECTLADMINSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
87 var_traceRouteCtlTable, 2, {1, 21}},
88 {COLUMN_TRACEROUTECTLDESCR, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
89 var_traceRouteCtlTable, 2, {1, 22}},
90 {COLUMN_TRACEROUTECTLMAXROWS, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
91 var_traceRouteCtlTable, 2, {1, 23}},
92 {COLUMN_TRACEROUTECTLTRAPGENERATION, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
93 var_traceRouteCtlTable, 2, {1, 24}},
94 {COLUMN_TRACEROUTECTLCREATEHOPSENTRIES, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
95 var_traceRouteCtlTable, 2, {1, 25}},
96 {COLUMN_TRACEROUTECTLTYPE, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE,
97 var_traceRouteCtlTable, 2, {1, 26}},
98 {COLUMN_TRACEROUTECTLROWSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
99 var_traceRouteCtlTable, 2, {1, 27}}
100
101 };
102
103 /*
104 * global storage of our data, saved in and configured by header_complex()
105 */
106
107 struct header_complex_index *traceRouteCtlTableStorage = NULL;
108 struct header_complex_index *traceRouteResultsTableStorage = NULL;
109 struct header_complex_index *traceRouteProbeHistoryTableStorage = NULL;
110 struct header_complex_index *traceRouteHopsTableStorage = NULL;
111
112 static char *
113 findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from);
114 int
115 traceRouteResultsTable_add(struct traceRouteCtlTable_data *thedata);
116 int
117 traceRouteResultsTable_del(struct traceRouteCtlTable_data *thedata);
118
119 void
120 init_traceRouteCtlTable(void)
121 {
122 DEBUGMSGTL(("traceRouteCtlTable", "initializing... "));
123 /*
124 * register ourselves with the agent to handle our mib tree
125 */
126 REGISTER_MIB("traceRouteCtlTable", traceRouteCtlTable_variables,
127 variable2, traceRouteCtlTable_variables_oid);
128
129 /*
130 * register our config handler(s) to deal with registrations
131 */
132 snmpd_register_config_handler("traceRouteCtlTable",
133 parse_traceRouteCtlTable, NULL, NULL);
134
135 /*
136 * we need to be called back later to store our data
137 */
138 snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
139 store_traceRouteCtlTable, NULL);
140
141 DEBUGMSGTL(("traceRouteCtlTable", "done.\n"));
142 }
143
144 static void
145 init_trResultsTable_ipv4(char *host,
146 struct traceRouteResultsTable_data *StorageTmp)
147 {
148 struct sockaddr whereto; /* Who to try to reach */
149 struct sockaddr_in *to = (struct sockaddr_in *) &whereto;
150 struct hostinfo *hi;
151
152 hi = gethostinfo(host);
153 if (hi == NULL) {
154 DEBUGMSGTL(("traceRouteCtlTable", "hi calloc %s\n",
155 strerror(errno)));
156 exit(1);
157 }
158
159 setsin(to, hi->addrs[0]);
160 if (inet_ntoa(to->sin_addr) == NULL) {
161 StorageTmp->traceRouteResultsIpTgtAddrType = 0;
162 StorageTmp->traceRouteResultsIpTgtAddr = strdup("");
163 StorageTmp->traceRouteResultsIpTgtAddrLen = 0;
164 } else {
165 StorageTmp->traceRouteResultsIpTgtAddrType = 1;
166 StorageTmp->traceRouteResultsIpTgtAddr =
167 (char *) malloc(sizeof(char) *
168 (strlen(inet_ntoa(to->sin_addr)) + 1));
169 if (StorageTmp->traceRouteResultsIpTgtAddr == NULL) {
170 DEBUGMSGTL(("traceRouteCtlTable",
171 "traceRouteResultsIpTgtAddr malloc %s\n",
172 strerror(errno)));
173 exit(1);
174 }
175
176 memcpy(StorageTmp->traceRouteResultsIpTgtAddr, inet_ntoa(to->sin_addr),
177 strlen(inet_ntoa(to->sin_addr)) + 1);
178 StorageTmp->traceRouteResultsIpTgtAddr[strlen(inet_ntoa(to->sin_addr))]
179 = '\0';
180 StorageTmp->traceRouteResultsIpTgtAddrLen =
181 strlen(inet_ntoa(to->sin_addr));
182 }
183 freehostinfo(hi);
184 }
185
186 static void
187 init_trResultsTable_ipv6(char *host,
188 struct traceRouteResultsTable_data *StorageTmp)
189 {
190 struct sockaddr_in6 whereto; /* Who to try to reach */
191 struct sockaddr_in6 *to = (struct sockaddr_in6 *) &whereto;
192 struct hostent *hp = NULL;
193 /* struct hostenv hp; */
194 char pa[64];
195
196 memset(pa, '\0', 64);
197
198 to->sin6_family = AF_INET6;
199 to->sin6_port = htons(33434);
200
201 if (inet_pton(AF_INET6, host, &to->sin6_addr) > 0) {
202 StorageTmp->traceRouteResultsIpTgtAddrType = 2;
203 StorageTmp->traceRouteResultsIpTgtAddr =
204 (char *) malloc(sizeof(char) * (strlen(host) + 1));
205 if (StorageTmp->traceRouteResultsIpTgtAddr == NULL) {
206 DEBUGMSGTL(("traceRouteCtlTable",
207 "traceRouteResultsIpTgtAddr malloc %s\n",
208 strerror(errno)));
209 exit(1);
210 }
211 memset(StorageTmp->traceRouteResultsIpTgtAddr, '\0',
212 sizeof(char) * (strlen(host) + 1));
213 memcpy(StorageTmp->traceRouteResultsIpTgtAddr, host, strlen(host) + 1);
214 StorageTmp->traceRouteResultsIpTgtAddr[strlen(host)] = '\0';
215 StorageTmp->traceRouteResultsIpTgtAddrLen = strlen(host);
216 } else {
217 hp = gethostbyname2(host, AF_INET6);
218 if (hp != NULL) {
219 const char *hostname;
220
221 memmove((caddr_t) & to->sin6_addr, hp->h_addr, 16);
222 hostname = inet_ntop(AF_INET6, &to->sin6_addr, pa, 64);
223 StorageTmp->traceRouteResultsIpTgtAddrType = 2;
224 StorageTmp->traceRouteResultsIpTgtAddr =
225 (char *) malloc(sizeof(char) * (strlen(hostname) + 1));
226 if (StorageTmp->traceRouteResultsIpTgtAddr == NULL) {
227 DEBUGMSGTL(("traceRouteCtlTable",
228 "traceRouteResultsIpTgtAddr malloc %s\n",
229 strerror(errno)));
230 exit(1);
231 }
232 memset(StorageTmp->traceRouteResultsIpTgtAddr, '\0',
233 sizeof(char) * (strlen(host) + 1));
234 memcpy(StorageTmp->traceRouteResultsIpTgtAddr, hostname,
235 strlen(hostname) + 1);
236 StorageTmp->traceRouteResultsIpTgtAddr[strlen(hostname)] = '\0';
237 StorageTmp->traceRouteResultsIpTgtAddrLen = strlen(hostname);
238 } else {
239 DEBUGMSGTL(("traceRouteCtlTable",
240 "traceroute: unknown host %s\n", host));
241
242 StorageTmp->traceRouteResultsIpTgtAddrType = 0;
243 StorageTmp->traceRouteResultsIpTgtAddr = strdup("");
244 StorageTmp->traceRouteResultsIpTgtAddrLen = 0;
245 }
246 }
247 }
248
249 void
250 init_trResultsTable(struct traceRouteCtlTable_data *item)
251 {
252 struct traceRouteResultsTable_data *StorageTmp = NULL;
253 netsnmp_variable_list *vars = NULL;
254 char *host = NULL;
255
256 host =
257 (char *) malloc(sizeof(char) *
258 (item->traceRouteCtlTargetAddressLen + 1));
259
260 if (host == NULL) {
261 DEBUGMSGTL(("traceRouteCtlTable", "host calloc %s\n",
262 strerror(errno)));
263 exit(1);
264 }
265
266 memset(host, '\0',
267 sizeof(char) * (item->traceRouteCtlTargetAddressLen + 1));
268 strcpy(host, item->traceRouteCtlTargetAddress);
269 host[item->traceRouteCtlTargetAddressLen] = '\0';
270
271 StorageTmp = SNMP_MALLOC_STRUCT(traceRouteResultsTable_data);
272 if (StorageTmp == NULL) {
273 DEBUGMSGTL(("traceRouteCtlTable", "StorageTmp malloc %s\n",
274 strerror(errno)));
275 exit(1);
276 }
277
278 StorageTmp->traceRouteCtlOwnerIndex =
279 (char *) malloc(sizeof(char) *
280 (item->traceRouteCtlOwnerIndexLen + 1));
281 if (StorageTmp->traceRouteCtlOwnerIndex == NULL) {
282 DEBUGMSGTL(("traceRouteCtlTable",
283 "traceRouteCtlOwnerIndex malloc %s\n",
284 strerror(errno)));
285 exit(1);
286 }
287
288 memcpy(StorageTmp->traceRouteCtlOwnerIndex,
289 item->traceRouteCtlOwnerIndex,
290 item->traceRouteCtlOwnerIndexLen + 1);
291 StorageTmp->traceRouteCtlOwnerIndex[item->traceRouteCtlOwnerIndexLen] =
292 '\0';
293 StorageTmp->traceRouteCtlOwnerIndexLen =
294 item->traceRouteCtlOwnerIndexLen;
295
296 StorageTmp->traceRouteCtlTestName =
297 (char *) malloc(sizeof(char) *
298 (item->traceRouteCtlTestNameLen + 1));
299 if (StorageTmp->traceRouteCtlTestName == NULL) {
300 DEBUGMSGTL(("traceRouteCtlTable",
301 "traceRouteCtlTestName malloc %s\n", strerror(errno)));
302 exit(1);
303 }
304
305 memcpy(StorageTmp->traceRouteCtlTestName, item->traceRouteCtlTestName,
306 item->traceRouteCtlTestNameLen + 1);
307 StorageTmp->traceRouteCtlTestName[item->traceRouteCtlTestNameLen] =
308 '\0';
309 StorageTmp->traceRouteCtlTestNameLen = item->traceRouteCtlTestNameLen;
310
311 StorageTmp->traceRouteResultsOperStatus = 1;
312
313 switch (item->traceRouteCtlTargetAddressType) {
314 case 1:
315 case 16:
316 init_trResultsTable_ipv4(host, StorageTmp);
317 break;
318 case 2:
319 init_trResultsTable_ipv6(host, StorageTmp);
320 break;
321 }
322
323 StorageTmp->traceRouteResultsCurHopCount = 0;
324 StorageTmp->traceRouteResultsCurProbeCount = 0;
325 StorageTmp->traceRouteResultsTestAttempts = 0;
326 StorageTmp->traceRouteResultsTestSuccesses = 0;
327
328 StorageTmp->traceRouteResultsLastGoodPathLen = 0;
329
330 item->traceRouteResults = StorageTmp;
331
332 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
333 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
334 if ((header_complex_get(traceRouteResultsTableStorage, vars)) != NULL) {
335 traceRouteResultsTable_del(item);
336 }
337 snmp_free_varbind(vars);
338 vars = NULL;
339 if (item->traceRouteResults != NULL) {
340 if (traceRouteResultsTable_add(item) != SNMPERR_SUCCESS) {
341 DEBUGMSGTL(("traceRouteResultsTable",
342 "init an entry error\n"));
343 }
344 }
345 free(host);
346 }
347
348
349
350 int
351 modify_trResultsOper(struct traceRouteCtlTable_data *thedata, long val)
352 {
353 netsnmp_variable_list *vars = NULL;
354 struct traceRouteResultsTable_data *StorageTmp = NULL;
355
356 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
357 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
358
359 if ((StorageTmp =
360 header_complex_get(traceRouteResultsTableStorage,
361 vars)) == NULL) {
362 snmp_free_varbind(vars);
363 vars = NULL;
364 return SNMP_ERR_NOSUCHNAME;
365 } else {
366 StorageTmp->traceRouteResultsOperStatus = val;
367 DEBUGMSGTL(("traceRouteResultsOperStatus", "done.\n"));
368 snmp_free_varbind(vars);
369 vars = NULL;
370 return SNMPERR_SUCCESS;
371 }
372 }
373
374
375 struct traceRouteCtlTable_data *
376 create_traceRouteCtlTable_data(void)
377 {
378 struct traceRouteCtlTable_data *StorageNew = NULL;
379 StorageNew = SNMP_MALLOC_STRUCT(traceRouteCtlTable_data);
380 if (StorageNew == NULL) {
381 exit(1);
382 }
383 StorageNew->traceRouteCtlTargetAddressType = 1;
384 StorageNew->traceRouteCtlTargetAddress = strdup("");
385 StorageNew->traceRouteCtlTargetAddressLen = 0;
386 StorageNew->traceRouteCtlByPassRouteTable = 2;
387 StorageNew->traceRouteCtlDataSize = 0;
388 StorageNew->traceRouteCtlTimeOut = 3;
389 StorageNew->traceRouteCtlProbesPerHop = 3;
390 StorageNew->traceRouteCtlPort = 33434;
391 StorageNew->traceRouteCtlMaxTtl = 30;
392 StorageNew->traceRouteCtlDSField = 0;
393 StorageNew->traceRouteCtlSourceAddressType = 0;
394 StorageNew->traceRouteCtlSourceAddress = strdup("");
395 StorageNew->traceRouteCtlSourceAddressLen = 0;
396 StorageNew->traceRouteCtlIfIndex = 0;
397 StorageNew->traceRouteCtlMiscOptions = strdup("");
398 StorageNew->traceRouteCtlMiscOptionsLen = 0;
399 StorageNew->traceRouteCtlMaxFailures = 5;
400 StorageNew->traceRouteCtlDontFragment = 2;
401 StorageNew->traceRouteCtlInitialTtl = 1;
402 StorageNew->traceRouteCtlFrequency = 0;
403 StorageNew->traceRouteCtlStorageType = ST_NONVOLATILE;
404 StorageNew->traceRouteCtlAdminStatus = 2;
405 StorageNew->traceRouteCtlDescr = (char *) malloc(strlen("00") + 1);
406 if (StorageNew->traceRouteCtlDescr == NULL) {
407 exit(1);
408 }
409 memcpy(StorageNew->traceRouteCtlDescr, "00", strlen("00") + 1);
410 StorageNew->traceRouteCtlDescr[strlen("00")] = '\0';
411 StorageNew->traceRouteCtlDescrLen =
412 strlen(StorageNew->traceRouteCtlDescr);
413
414 StorageNew->traceRouteCtlMaxRows = 50;
415 StorageNew->traceRouteCtlTrapGeneration = strdup("");
416 StorageNew->traceRouteCtlTrapGenerationLen = 0;
417 StorageNew->traceRouteCtlCreateHopsEntries = 2;
418
419 StorageNew->traceRouteCtlType = calloc(1, sizeof(oid) * sizeof(2)); /* 0.0 */
420 StorageNew->traceRouteCtlTypeLen = 2;
421
422 StorageNew->traceRouteResults = NULL;
423 StorageNew->traceRouteProbeHis = NULL;
424 StorageNew->traceRouteHops = NULL;
425
426 StorageNew->storageType = ST_NONVOLATILE;
427 /* StorageNew->traceRouteProbeHistoryMaxIndex=0; */
428 return StorageNew;
429 }
430
431
432 /*
433 * traceRouteCtlTable_add(): adds a structure node to our data set
434 */
435 int
436 traceRouteCtlTable_add(struct traceRouteCtlTable_data *thedata)
437 {
438 netsnmp_variable_list *vars = NULL;
439
440
441 DEBUGMSGTL(("traceRouteCtlTable", "adding data... "));
442 /*
443 * add the index variables to the varbind list, which is
444 * used by header_complex to index the data
445 */
446
447
448 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
449 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlOperationName */
450
451 if (header_complex_add_data(&traceRouteCtlTableStorage, vars, thedata)
452 == NULL) {
453 vars = NULL;
454 return SNMPERR_GENERR;
455 } else {
456
457 DEBUGMSGTL(("traceRouteCtlTable", "registered an entry\n"));
458
459
460 DEBUGMSGTL(("traceRouteCtlTable", "done.\n"));
461 vars = NULL;
462 return SNMPERR_SUCCESS;
463 }
464 }
465
466 int
467 traceRouteResultsTable_add(struct traceRouteCtlTable_data *thedata)
468 {
469 netsnmp_variable_list *vars_list = NULL;
470 struct traceRouteResultsTable_data *p = NULL;
471 p = thedata->traceRouteResults;
472 if (thedata->traceRouteResults != NULL) {
473 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlOwnerIndex, p->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
474 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlTestName, p->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
475 DEBUGMSGTL(("traceRouteResultsTable", "adding data... "));
476 /*
477 * add the index variables to the varbind list, which is
478 * used by header_complex to index the data
479 */
480
481 header_complex_add_data(&traceRouteResultsTableStorage, vars_list,
482 p);
483 DEBUGMSGTL(("traceRouteResultsTable", "out finished\n"));
484 vars_list = NULL;
485 DEBUGMSGTL(("traceRouteResultsTable", "done.\n"));
486 return SNMPERR_SUCCESS;
487 } else {
488 vars_list = NULL;
489 DEBUGMSGTL(("traceRouteResultsTable", "error.\n"));
490 return SNMP_ERR_INCONSISTENTNAME;
491 }
492 }
493
494
495 int
496 traceRouteProbeHistoryTable_add(struct traceRouteProbeHistoryTable_data
497 *thedata)
498 {
499 netsnmp_variable_list *vars_list = NULL;
500 if (thedata != NULL) {
501 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
502 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
503 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &thedata->traceRouteProbeHistoryIndex, sizeof(thedata->traceRouteProbeHistoryIndex)); /* traceRouteProbeHistoryIndex */
504 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &thedata->traceRouteProbeHistoryHopIndex, sizeof(thedata->traceRouteProbeHistoryHopIndex)); /* traceRouteProbeHistoryHopIndex */
505 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &thedata->traceRouteProbeHistoryProbeIndex, sizeof(thedata->traceRouteProbeHistoryProbeIndex)); /* traceRouteProbeHistoryProbeIndex */
506
507 DEBUGMSGTL(("traceRouteProbeHistoryTable", "adding data... "));
508 /*
509 * add the index variables to the varbind list, which is
510 * used by header_complex to index the data
511 */
512
513 if (header_complex_add_data
514 (&traceRouteProbeHistoryTableStorage, vars_list,
515 thedata) == NULL) {
516 vars_list = NULL;
517 return SNMP_ERR_INCONSISTENTNAME;
518 } else {
519 DEBUGMSGTL(("traceRouteProbeHistoryTable", "out finished\n"));
520
521 vars_list = NULL;
522
523 DEBUGMSGTL(("traceRouteProbeHistoryTable", "done.\n"));
524 return SNMPERR_SUCCESS;
525 }
526 } else {
527 return SNMP_ERR_INCONSISTENTNAME;
528 }
529 }
530
531 int
532 traceRouteProbeHistoryTable_addall(struct traceRouteCtlTable_data *thedata)
533 {
534 netsnmp_variable_list *vars_list = NULL;
535 struct traceRouteProbeHistoryTable_data *p = NULL;
536 p = thedata->traceRouteProbeHis;
537 if (thedata->traceRouteProbeHis != NULL)
538 do {
539 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlOwnerIndex, p->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
540 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlTestName, p->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
541 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->traceRouteProbeHistoryIndex, sizeof(p->traceRouteProbeHistoryIndex)); /* traceRouteProbeHistoryIndex */
542 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->traceRouteProbeHistoryHopIndex, sizeof(p->traceRouteProbeHistoryHopIndex)); /* traceRouteProbeHistoryHopIndex */
543 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->traceRouteProbeHistoryProbeIndex, sizeof(p->traceRouteProbeHistoryProbeIndex)); /* traceRouteProbeHistoryProbeIndex */
544
545 DEBUGMSGTL(("traceRouteProbeHistoryTable",
546 "adding data... "));
547 /*
548 * add the index variables to the varbind list, which is
549 * used by header_complex to index the data
550 */
551
552 if (header_complex_add_data
553 (&traceRouteProbeHistoryTableStorage, vars_list,
554 p) == NULL) {
555 vars_list = NULL;
556 return SNMP_ERR_INCONSISTENTNAME;
557 } else {
558
559 struct header_complex_index *temp = NULL;
560 temp = traceRouteProbeHistoryTableStorage;
561 if (traceRouteProbeHistoryTableStorage != NULL)
562 do {
563 DEBUGMSGTL(("traceRouteProbeHistoryTable",
564 "adding data,vars_oid="));
565 DEBUGMSGOID(("traceRouteProbeHistoryTable",
566 temp->name, temp->namelen));
567 DEBUGMSGTL(("traceRouteProbeHistoryTable",
568 "\n "));
569 temp = temp->next;
570 } while (temp != NULL);
571
572 DEBUGMSGTL(("traceRouteProbeHistoryTable",
573 "out finished\n"));
574 DEBUGMSGTL(("traceRouteProbeHistoryTable", "done.\n"));
575 vars_list = NULL;
576 return SNMPERR_SUCCESS;
577 }
578
579 p = p->next;
580 } while (p != NULL);
581
582 return SNMP_ERR_INCONSISTENTNAME;
583 }
584
585
586
587 int
588 traceRouteHopsTable_add(struct traceRouteHopsTable_data *thedata)
589 {
590 netsnmp_variable_list *vars_list = NULL;
591
592 if (thedata != NULL) {
593 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
594 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
595 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &thedata->traceRouteHopsHopIndex, sizeof(thedata->traceRouteHopsHopIndex)); /* traceRouteHopsHopIndex */
596
597 DEBUGMSGTL(("traceRouteHopsTable", "adding data... "));
598 /*
599 * add the index variables to the varbind list, which is
600 * used by header_complex to index the data
601 */
602
603 if (header_complex_add_data
604 (&traceRouteHopsTableStorage, vars_list, thedata) == NULL) {
605 vars_list = NULL;
606 return SNMP_ERR_INCONSISTENTNAME;
607 } else {
608 DEBUGMSGTL(("traceRouteHopsTable", "out finished\n"));
609 DEBUGMSGTL(("traceRouteHopsTable", "done.\n"));
610 vars_list = NULL;
611 return SNMPERR_SUCCESS;
612 }
613 }
614 return SNMPERR_GENERR;
615 }
616
617 int
618 traceRouteHopsTable_addall(struct traceRouteCtlTable_data *thedata)
619 {
620 netsnmp_variable_list *vars_list = NULL;
621 struct traceRouteHopsTable_data *p = NULL;
622 vars_list = NULL;
623 p = thedata->traceRouteHops;
624 if (thedata->traceRouteHops != NULL) {
625 do {
626 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlOwnerIndex, p->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
627 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->traceRouteCtlTestName, p->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
628 snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->traceRouteHopsHopIndex, sizeof(p->traceRouteHopsHopIndex)); /* traceRouteHopsHopIndex */
629
630 DEBUGMSGTL(("traceRouteHopsTable", "adding data... "));
631 /*
632 * add the index variables to the varbind list, which is
633 * used by header_complex to index the data
634 */
635
636 if (header_complex_add_data
637 (&traceRouteHopsTableStorage, vars_list, p) == NULL) {
638 vars_list = NULL;
639 return SNMP_ERR_INCONSISTENTNAME;
640 } else {
641
642 struct header_complex_index *temp = NULL;
643 temp = traceRouteHopsTableStorage;
644 if (traceRouteHopsTableStorage != NULL)
645 do {
646 DEBUGMSGTL(("traceRouteProbeHistoryTable",
647 "adding data,vars_oid="));
648 DEBUGMSGOID(("traceRouteProbeHistoryTable",
649 temp->name, temp->namelen));
650 DEBUGMSGTL(("traceRouteProbeHistoryTable",
651 "\n "));
652 temp = temp->next;
653 } while (temp != NULL);
654 DEBUGMSGTL(("traceRouteHopsTable", "out finished\n"));
655
656 vars_list = NULL;
657 }
658 p = p->next;
659 } while (p != NULL);
660 DEBUGMSGTL(("traceRouteHopsTable", "done.\n"));
661 return SNMPERR_SUCCESS;
662 } else {
663 return SNMP_ERR_INCONSISTENTNAME;
664 }
665
666 }
667
668
669 unsigned long
670 traceRouteProbeHistoryTable_count(struct traceRouteCtlTable_data *thedata)
671 {
672 struct header_complex_index *hciptr2 = NULL;
673 netsnmp_variable_list *vars = NULL;
674 oid newoid[MAX_OID_LEN];
675 size_t newoid_len;
676 unsigned long count = 0;
677
678 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
679 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
680
681 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
682
683 vars = NULL;
684 for (hciptr2 = traceRouteProbeHistoryTableStorage; hciptr2 != NULL;
685 hciptr2 = hciptr2->next) {
686 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
687 == 0) {
688 count = count + 1;
689 }
690 }
691 return count;
692 }
693
694
695
696 unsigned long
697 traceRouteHopsTable_count(struct traceRouteCtlTable_data *thedata)
698 {
699 struct header_complex_index *hciptr2 = NULL;
700 netsnmp_variable_list *vars = NULL;
701 oid newoid[MAX_OID_LEN];
702 size_t newoid_len;
703 unsigned long count = 0;
704
705 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
706 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlOperationName */
707
708 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
709
710 vars = NULL;
711 for (hciptr2 = traceRouteHopsTableStorage; hciptr2 != NULL;
712 hciptr2 = hciptr2->next) {
713 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
714 == 0) {
715 count = count + 1;
716 }
717 }
718 return count;
719 }
720
721
722
723 void
724 traceRouteProbeHistoryTable_delLast(struct traceRouteCtlTable_data
725 *thedata)
726 {
727 struct header_complex_index *hciptr2 = NULL;
728 struct header_complex_index *hcilast = NULL;
729 struct traceRouteProbeHistoryTable_data *StorageTmp = NULL;
730 netsnmp_variable_list *vars = NULL;
731 oid newoid[MAX_OID_LEN];
732 size_t newoid_len = 0;
733 time_t last_time = 2147483647;
734 time_t tp;
735
736 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
737 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlOperationName */
738
739 memset(newoid, '\0', sizeof(oid) * MAX_OID_LEN);
740 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
741
742 for (hcilast = hciptr2 = traceRouteProbeHistoryTableStorage;
743 hciptr2 != NULL; hciptr2 = hciptr2->next) {
744 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
745 == 0) {
746
747 StorageTmp =
748 header_complex_get_from_oid
749 (traceRouteProbeHistoryTableStorage, hciptr2->name,
750 hciptr2->namelen);
751 tp = StorageTmp->traceRouteProbeHistoryTime_time;
752
753 if (last_time > tp) {
754 last_time = tp;
755 hcilast = hciptr2;
756 }
757
758 }
759 }
760 header_complex_extract_entry(&traceRouteProbeHistoryTableStorage, hcilast);
761 DEBUGMSGTL(("traceRouteProbeHistoryTable",
762 "delete the last one success!\n"));
763 vars = NULL;
764 }
765
766
767
768 void
769 traceRouteCtlTable_cleaner(struct header_complex_index *thestuff)
770 {
771 struct header_complex_index *hciptr, *nhciptr;
772 struct traceRouteCtlTable_data *StorageDel;
773
774 DEBUGMSGTL(("traceRouteCtlTable", "cleanerout "));
775 for (hciptr = thestuff; hciptr; hciptr = nhciptr) {
776 nhciptr = hciptr->next;
777 StorageDel =
778 header_complex_extract_entry(&traceRouteCtlTableStorage,
779 hciptr);
780 if (StorageDel != NULL) {
781 free(StorageDel->traceRouteCtlOwnerIndex);
782 free(StorageDel->traceRouteCtlTestName);
783 free(StorageDel->traceRouteCtlTargetAddress);
784 free(StorageDel->traceRouteCtlSourceAddress);
785 free(StorageDel->traceRouteCtlMiscOptions);
786 free(StorageDel->traceRouteCtlDescr);
787 free(StorageDel->traceRouteCtlTrapGeneration);
788 free(StorageDel->traceRouteCtlType);
789 free(StorageDel);
790 }
791 DEBUGMSGTL(("traceRouteCtlTable", "cleaner "));
792 }
793 }
794
795
796 /*
797 * parse_mteObjectsTable():
798 * parses .conf file entries needed to configure the mib.
799 */
800 void
801 parse_traceRouteCtlTable(const char *token, char *line)
802 {
803 size_t tmpint;
804 struct traceRouteCtlTable_data *StorageTmp =
805 SNMP_MALLOC_STRUCT(traceRouteCtlTable_data);
806
807 DEBUGMSGTL(("traceRouteCtlTable", "parsing config... "));
808
809
810 if (StorageTmp == NULL) {
811 config_perror("malloc failure");
812 return;
813 }
814
815
816 line =
817 read_config_read_data(ASN_OCTET_STR, line,
818 &StorageTmp->traceRouteCtlOwnerIndex,
819 &StorageTmp->traceRouteCtlOwnerIndexLen);
820 if (StorageTmp->traceRouteCtlOwnerIndex == NULL) {
821 config_perror("invalid specification for traceRouteCtlOwnerIndex");
822 free(StorageTmp);
823 return;
824 }
825
826 line =
827 read_config_read_data(ASN_OCTET_STR, line,
828 &StorageTmp->traceRouteCtlTestName,
829 &StorageTmp->traceRouteCtlTestNameLen);
830 if (StorageTmp->traceRouteCtlTestName == NULL) {
831 config_perror("invalid specification for traceRouteCtlTestName");
832 free(StorageTmp);
833 return;
834 }
835
836 line =
837 read_config_read_data(ASN_INTEGER, line,
838 &StorageTmp->traceRouteCtlTargetAddressType,
839 &tmpint);
840
841 line =
842 read_config_read_data(ASN_OCTET_STR, line,
843 &StorageTmp->traceRouteCtlTargetAddress,
844 &StorageTmp->traceRouteCtlTargetAddressLen);
845 if (StorageTmp->traceRouteCtlTargetAddress == NULL) {
846 config_perror
847 ("invalid specification for traceRouteCtlTargetAddress");
848 free(StorageTmp);
849 return;
850 }
851
852 line =
853 read_config_read_data(ASN_INTEGER, line,
854 &StorageTmp->traceRouteCtlByPassRouteTable,
855 &tmpint);
856 line =
857 read_config_read_data(ASN_UNSIGNED, line,
858 &StorageTmp->traceRouteCtlDataSize, &tmpint);
859
860 line =
861 read_config_read_data(ASN_UNSIGNED, line,
862 &StorageTmp->traceRouteCtlTimeOut, &tmpint);
863
864 line =
865 read_config_read_data(ASN_UNSIGNED, line,
866 &StorageTmp->traceRouteCtlProbesPerHop,
867 &tmpint);
868
869 line =
870 read_config_read_data(ASN_UNSIGNED, line,
871 &StorageTmp->traceRouteCtlPort, &tmpint);
872
873 line =
874 read_config_read_data(ASN_UNSIGNED, line,
875 &StorageTmp->traceRouteCtlMaxTtl, &tmpint);
876
877 line =
878 read_config_read_data(ASN_UNSIGNED, line,
879 &StorageTmp->traceRouteCtlDSField, &tmpint);
880
881 line =
882 read_config_read_data(ASN_INTEGER, line,
883 &StorageTmp->traceRouteCtlSourceAddressType,
884 &tmpint);
885
886 line =
887 read_config_read_data(ASN_OCTET_STR, line,
888 &StorageTmp->traceRouteCtlSourceAddress,
889 &StorageTmp->traceRouteCtlSourceAddressLen);
890 if (StorageTmp->traceRouteCtlSourceAddress == NULL) {
891 config_perror
892 ("invalid specification for traceRouteCtlSourceAddress");
893 free(StorageTmp);
894 return;
895 }
896
897 line =
898 read_config_read_data(ASN_INTEGER, line,
899 &StorageTmp->traceRouteCtlIfIndex, &tmpint);
900
901 line =
902 read_config_read_data(ASN_OCTET_STR, line,
903 &StorageTmp->traceRouteCtlMiscOptions,
904 &StorageTmp->traceRouteCtlMiscOptionsLen);
905 if (StorageTmp->traceRouteCtlMiscOptions == NULL) {
906 config_perror
907 ("invalid specification for traceRouteCtlMiscOptions");
908 free(StorageTmp);
909 return;
910 }
911
912 line =
913 read_config_read_data(ASN_UNSIGNED, line,
914 &StorageTmp->traceRouteCtlMaxFailures,
915 &tmpint);
916
917 line =
918 read_config_read_data(ASN_INTEGER, line,
919 &StorageTmp->traceRouteCtlDontFragment,
920 &tmpint);
921
922 line =
923 read_config_read_data(ASN_UNSIGNED, line,
924 &StorageTmp->traceRouteCtlInitialTtl,
925 &tmpint);
926
927 line =
928 read_config_read_data(ASN_UNSIGNED, line,
929 &StorageTmp->traceRouteCtlFrequency,
930 &tmpint);
931
932 line =
933 read_config_read_data(ASN_INTEGER, line,
934 &StorageTmp->traceRouteCtlStorageType,
935 &tmpint);
936
937 line =
938 read_config_read_data(ASN_INTEGER, line,
939 &StorageTmp->traceRouteCtlAdminStatus,
940 &tmpint);
941
942 line =
943 read_config_read_data(ASN_OCTET_STR, line,
944 &StorageTmp->traceRouteCtlDescr,
945 &StorageTmp->traceRouteCtlDescrLen);
946 if (StorageTmp->traceRouteCtlDescr == NULL) {
947 config_perror("invalid specification for traceRouteCtlTrapDescr");
948 free(StorageTmp);
949 return;
950 }
951
952 line =
953 read_config_read_data(ASN_UNSIGNED, line,
954 &StorageTmp->traceRouteCtlMaxRows, &tmpint);
955
956 line =
957 read_config_read_data(ASN_OCTET_STR, line,
958 &StorageTmp->traceRouteCtlTrapGeneration,
959 &StorageTmp->traceRouteCtlTrapGenerationLen);
960 if (StorageTmp->traceRouteCtlTrapGeneration == NULL) {
961 config_perror
962 ("invalid specification for traceRouteCtlTrapGeneration");
963 free(StorageTmp);
964 return;
965 }
966
967 line =
968 read_config_read_data(ASN_INTEGER, line,
969 &StorageTmp->traceRouteCtlCreateHopsEntries,
970 &tmpint);
971
972 line =
973 read_config_read_data(ASN_OBJECT_ID, line,
974 &StorageTmp->traceRouteCtlType,
975 &StorageTmp->traceRouteCtlTypeLen);
976 if (StorageTmp->traceRouteCtlType == NULL) {
977 config_perror("invalid specification for traceRouteCtlType");
978 free(StorageTmp);
979 return;
980 }
981
982 line =
983 read_config_read_data(ASN_INTEGER, line,
984 &StorageTmp->traceRouteCtlRowStatus,
985 &tmpint);
986
987 line =
988 read_config_read_data(ASN_UNSIGNED, line,
989 &StorageTmp->traceRouteProbeHistoryMaxIndex,
990 &tmpint);
991
992 StorageTmp->storageType = ST_NONVOLATILE;
993 traceRouteCtlTable_add(StorageTmp);
994 /* traceRouteCtlTable_cleaner(traceRouteCtlTableStorage); */
995
996 DEBUGMSGTL(("traceRouteCtlTable", "done.\n"));
997 }
998
999
1000
1001 /*
1002 * store_traceRouteCtlTable():
1003 * stores .conf file entries needed to configure the mib.
1004 */
1005 int
1006 store_traceRouteCtlTable(int majorID, int minorID, void *serverarg,
1007 void *clientarg)
1008 {
1009 char line[SNMP_MAXBUF];
1010 char *cptr = NULL;
1011 size_t tmpint;
1012 struct traceRouteCtlTable_data *StorageTmp = NULL;
1013 struct header_complex_index *hcindex = NULL;
1014
1015
1016 DEBUGMSGTL(("traceRouteCtlTable", "storing data... "));
1017
1018
1019 for (hcindex = traceRouteCtlTableStorage; hcindex != NULL;
1020 hcindex = hcindex->next) {
1021 StorageTmp = (struct traceRouteCtlTable_data *) hcindex->data;
1022
1023 if (StorageTmp->storageType != ST_READONLY) {
1024 memset(line, 0, sizeof(line));
1025 strcat(line, "traceRouteCtlTable ");
1026 cptr = line + strlen(line);
1027
1028 cptr =
1029 read_config_store_data(ASN_OCTET_STR, cptr,
1030 &StorageTmp->
1031 traceRouteCtlOwnerIndex,
1032 &StorageTmp->
1033 traceRouteCtlOwnerIndexLen);
1034 cptr =
1035 read_config_store_data(ASN_OCTET_STR, cptr,
1036 &StorageTmp->traceRouteCtlTestName,
1037 &StorageTmp->
1038 traceRouteCtlTestNameLen);
1039 cptr =
1040 read_config_store_data(ASN_INTEGER, cptr,
1041 &StorageTmp->
1042 traceRouteCtlTargetAddressType,
1043 &tmpint);
1044 cptr =
1045 read_config_store_data(ASN_OCTET_STR, cptr,
1046 &StorageTmp->
1047 traceRouteCtlTargetAddress,
1048 &StorageTmp->
1049 traceRouteCtlTargetAddressLen);
1050 cptr =
1051 read_config_store_data(ASN_INTEGER, cptr,
1052 &StorageTmp->
1053 traceRouteCtlByPassRouteTable,
1054 &tmpint);
1055 cptr =
1056 read_config_store_data(ASN_UNSIGNED, cptr,
1057 &StorageTmp->traceRouteCtlDataSize,
1058 &tmpint);
1059 cptr =
1060 read_config_store_data(ASN_UNSIGNED, cptr,
1061 &StorageTmp->traceRouteCtlTimeOut,
1062 &tmpint);
1063 cptr =
1064 read_config_store_data(ASN_UNSIGNED, cptr,
1065 &StorageTmp->
1066 traceRouteCtlProbesPerHop, &tmpint);
1067 cptr =
1068 read_config_store_data(ASN_UNSIGNED, cptr,
1069 &StorageTmp->traceRouteCtlPort,
1070 &tmpint);
1071 cptr =
1072 read_config_store_data(ASN_UNSIGNED, cptr,
1073 &StorageTmp->traceRouteCtlMaxTtl,
1074 &tmpint);
1075 cptr =
1076 read_config_store_data(ASN_UNSIGNED, cptr,
1077 &StorageTmp->traceRouteCtlDSField,
1078 &tmpint);
1079
1080 cptr =
1081 read_config_store_data(ASN_INTEGER, cptr,
1082 &StorageTmp->
1083 traceRouteCtlSourceAddressType,
1084 &tmpint);
1085 cptr =
1086 read_config_store_data(ASN_OCTET_STR, cptr,
1087 &StorageTmp->
1088 traceRouteCtlSourceAddress,
1089 &StorageTmp->
1090 traceRouteCtlSourceAddressLen);
1091 cptr =
1092 read_config_store_data(ASN_INTEGER, cptr,
1093 &StorageTmp->traceRouteCtlIfIndex,
1094 &tmpint);
1095 cptr =
1096 read_config_store_data(ASN_OCTET_STR, cptr,
1097 &StorageTmp->
1098 traceRouteCtlMiscOptions,
1099 &StorageTmp->
1100 traceRouteCtlMiscOptionsLen);
1101 cptr =
1102 read_config_store_data(ASN_UNSIGNED, cptr,
1103 &StorageTmp->
1104 traceRouteCtlMaxFailures, &tmpint);
1105 cptr =
1106 read_config_store_data(ASN_INTEGER, cptr,
1107 &StorageTmp->
1108 traceRouteCtlDontFragment, &tmpint);
1109 cptr =
1110 read_config_store_data(ASN_UNSIGNED, cptr,
1111 &StorageTmp->
1112 traceRouteCtlInitialTtl, &tmpint);
1113 cptr =
1114 read_config_store_data(ASN_UNSIGNED, cptr,
1115 &StorageTmp->traceRouteCtlFrequency,
1116 &tmpint);
1117
1118 cptr =
1119 read_config_store_data(ASN_INTEGER, cptr,
1120 &StorageTmp->
1121 traceRouteCtlStorageType, &tmpint);
1122 cptr =
1123 read_config_store_data(ASN_INTEGER, cptr,
1124 &StorageTmp->
1125 traceRouteCtlAdminStatus, &tmpint);
1126 cptr =
1127 read_config_store_data(ASN_OCTET_STR, cptr,
1128 &StorageTmp->traceRouteCtlDescr,
1129 &StorageTmp->traceRouteCtlDescrLen);
1130 cptr =
1131 read_config_store_data(ASN_UNSIGNED, cptr,
1132 &StorageTmp->traceRouteCtlMaxRows,
1133 &tmpint);
1134 cptr =
1135 read_config_store_data(ASN_OCTET_STR, cptr,
1136 &StorageTmp->
1137 traceRouteCtlTrapGeneration,
1138 &StorageTmp->
1139 traceRouteCtlTrapGenerationLen);
1140 cptr =
1141 read_config_store_data(ASN_INTEGER, cptr,
1142 &StorageTmp->
1143 traceRouteCtlCreateHopsEntries,
1144 &tmpint);
1145 cptr =
1146 read_config_store_data(ASN_OBJECT_ID, cptr,
1147 &StorageTmp->traceRouteCtlType,
1148 &StorageTmp->traceRouteCtlTypeLen);
1149 cptr =
1150 read_config_store_data(ASN_INTEGER, cptr,
1151 &StorageTmp->traceRouteCtlRowStatus,
1152 &tmpint);
1153 cptr =
1154 read_config_store_data(ASN_UNSIGNED, cptr,
1155 &StorageTmp->
1156 traceRouteProbeHistoryMaxIndex,
1157 &tmpint);
1158
1159
1160
1161 snmpd_store_config(line);
1162 }
1163 }
1164 DEBUGMSGTL(("traceRouteCtlTable", "done.\n"));
1165 return SNMPERR_SUCCESS;
1166 }
1167
1168
1169
1170
1171 /*
1172 * var_traceRouteCtlTable():
1173 * Handle this table separately from the scalar value case.
1174 * The workings of this are basically the same as for var_mteObjectsTable above.
1175 */
1176 unsigned char *
1177 var_traceRouteCtlTable(struct variable *vp,
1178 oid * name,
1179 size_t *length,
1180 int exact,
1181 size_t *var_len, WriteMethod ** write_method)
1182 {
1183
1184 struct traceRouteCtlTable_data *StorageTmp = NULL;
1185
1186 /*
1187 * this assumes you have registered all your data properly
1188 */
1189 if ((StorageTmp =
1190 header_complex(traceRouteCtlTableStorage, vp, name, length, exact,
1191 var_len, write_method)) == NULL) {
1192 if (vp->magic == COLUMN_TRACEROUTECTLROWSTATUS)
1193 *write_method = write_traceRouteCtlRowStatus;
1194
1195 return NULL;
1196 }
1197
1198 /*
1199 * this is where we do the value assignments for the mib results.
1200 */
1201 switch (vp->magic) {
1202
1203
1204 case COLUMN_TRACEROUTECTLTARGETADDRESSTYPE:
1205 *write_method = write_traceRouteCtlTargetAddressType;
1206 *var_len = sizeof(StorageTmp->traceRouteCtlTargetAddressType);
1207
1208 return (u_char *) & StorageTmp->traceRouteCtlTargetAddressType;
1209
1210 case COLUMN_TRACEROUTECTLTARGETADDRESS:
1211 *write_method = write_traceRouteCtlTargetAddress;
1212 *var_len = (StorageTmp->traceRouteCtlTargetAddressLen);
1213
1214 return (u_char *) StorageTmp->traceRouteCtlTargetAddress;
1215
1216 case COLUMN_TRACEROUTECTLBYPASSROUTETABLE:
1217 *write_method = write_traceRouteCtlByPassRouteTable;
1218 *var_len = sizeof(StorageTmp->traceRouteCtlByPassRouteTable);
1219
1220 return (u_char *) & StorageTmp->traceRouteCtlByPassRouteTable;
1221
1222 case COLUMN_TRACEROUTECTLDATASIZE:
1223 *write_method = write_traceRouteCtlDataSize;
1224 *var_len = sizeof(StorageTmp->traceRouteCtlDataSize);
1225
1226 return (u_char *) & StorageTmp->traceRouteCtlDataSize;
1227
1228 case COLUMN_TRACEROUTECTLTIMEOUT:
1229 *write_method = write_traceRouteCtlTimeOut;
1230 *var_len = sizeof(StorageTmp->traceRouteCtlTimeOut);
1231
1232 return (u_char *) & StorageTmp->traceRouteCtlTimeOut;
1233
1234 case COLUMN_TRACEROUTECTLPROBESPERHOP:
1235 *write_method = write_traceRouteCtlProbesPerHop;
1236 *var_len = sizeof(StorageTmp->traceRouteCtlProbesPerHop);
1237
1238 return (u_char *) & StorageTmp->traceRouteCtlProbesPerHop;
1239
1240 case COLUMN_TRACEROUTECTLPORT:
1241 *write_method = write_traceRouteCtlPort;
1242 *var_len = sizeof(StorageTmp->traceRouteCtlPort);
1243
1244 return (u_char *) & StorageTmp->traceRouteCtlPort;
1245
1246 case COLUMN_TRACEROUTECTLMAXTTL:
1247 *write_method = write_traceRouteCtlMaxTtl;
1248 *var_len = sizeof(StorageTmp->traceRouteCtlMaxTtl);
1249
1250 return (u_char *) & StorageTmp->traceRouteCtlMaxTtl;
1251
1252 case COLUMN_TRACEROUTECTLDSFIELD:
1253 *write_method = write_traceRouteCtlDSField;
1254 *var_len = sizeof(StorageTmp->traceRouteCtlDSField);
1255
1256 return (u_char *) & StorageTmp->traceRouteCtlDSField;
1257
1258 case COLUMN_TRACEROUTECTLSOURCEADDRESSTYPE:
1259 *write_method = write_traceRouteCtlSourceAddressType;
1260 *var_len = sizeof(StorageTmp->traceRouteCtlSourceAddressType);
1261
1262 return (u_char *) & StorageTmp->traceRouteCtlSourceAddressType;
1263
1264 case COLUMN_TRACEROUTECTLSOURCEADDRESS:
1265 *write_method = write_traceRouteCtlSourceAddress;
1266 *var_len = (StorageTmp->traceRouteCtlSourceAddressLen);
1267
1268 return (u_char *) StorageTmp->traceRouteCtlSourceAddress;
1269
1270 case COLUMN_TRACEROUTECTLIFINDEX:
1271 *write_method = write_traceRouteCtlIfIndex;
1272 *var_len = sizeof(StorageTmp->traceRouteCtlIfIndex);
1273
1274 return (u_char *) & StorageTmp->traceRouteCtlIfIndex;
1275
1276 case COLUMN_TRACEROUTECTLMISCOPTIONS:
1277 *write_method = write_traceRouteCtlMiscOptions;
1278 *var_len = (StorageTmp->traceRouteCtlMiscOptionsLen);
1279
1280 return (u_char *) StorageTmp->traceRouteCtlMiscOptions;
1281
1282 case COLUMN_TRACEROUTECTLMAXFAILURES:
1283 *write_method = write_traceRouteCtlMaxFailures;
1284 *var_len = sizeof(StorageTmp->traceRouteCtlMaxFailures);
1285
1286 return (u_char *) & StorageTmp->traceRouteCtlMaxFailures;
1287
1288 case COLUMN_TRACEROUTECTLDONTFRAGMENT:
1289 *write_method = write_traceRouteCtlDontFragment;
1290 *var_len = sizeof(StorageTmp->traceRouteCtlDontFragment);
1291
1292 return (u_char *) & StorageTmp->traceRouteCtlDontFragment;
1293
1294 case COLUMN_TRACEROUTECTLINITIALTTL:
1295 *write_method = write_traceRouteCtlInitialTtl;
1296 *var_len = sizeof(StorageTmp->traceRouteCtlInitialTtl);
1297
1298 return (u_char *) & StorageTmp->traceRouteCtlInitialTtl;
1299
1300 case COLUMN_TRACEROUTECTLFREQUENCY:
1301 *write_method = write_traceRouteCtlFrequency;
1302 *var_len = sizeof(StorageTmp->traceRouteCtlFrequency);
1303
1304 return (u_char *) & StorageTmp->traceRouteCtlFrequency;
1305
1306 case COLUMN_TRACEROUTECTLSTORAGETYPE:
1307 *write_method = write_traceRouteCtlStorageType;
1308 *var_len = sizeof(StorageTmp->traceRouteCtlStorageType);
1309
1310 return (u_char *) & StorageTmp->traceRouteCtlStorageType;
1311
1312 case COLUMN_TRACEROUTECTLADMINSTATUS:
1313 *write_method = write_traceRouteCtlAdminStatus;
1314 *var_len = sizeof(StorageTmp->traceRouteCtlAdminStatus);
1315
1316 return (u_char *) & StorageTmp->traceRouteCtlAdminStatus;
1317
1318 case COLUMN_TRACEROUTECTLDESCR:
1319 *write_method = write_traceRouteCtlDescr;
1320 *var_len = (StorageTmp->traceRouteCtlDescrLen);
1321
1322 return (u_char *) StorageTmp->traceRouteCtlDescr;
1323
1324 case COLUMN_TRACEROUTECTLMAXROWS:
1325 *write_method = write_traceRouteCtlMaxRows;
1326 *var_len = sizeof(StorageTmp->traceRouteCtlMaxRows);
1327
1328 return (u_char *) & StorageTmp->traceRouteCtlMaxRows;
1329
1330 case COLUMN_TRACEROUTECTLTRAPGENERATION:
1331 *write_method = write_traceRouteCtlTrapGeneration;
1332 *var_len = (StorageTmp->traceRouteCtlTrapGenerationLen);
1333
1334 return (u_char *) StorageTmp->traceRouteCtlTrapGeneration;
1335
1336 case COLUMN_TRACEROUTECTLCREATEHOPSENTRIES:
1337 *write_method = write_traceRouteCtlCreateHopsEntries;
1338 *var_len = sizeof(StorageTmp->traceRouteCtlCreateHopsEntries);
1339
1340 return (u_char *) & StorageTmp->traceRouteCtlCreateHopsEntries;
1341
1342 case COLUMN_TRACEROUTECTLTYPE:
1343 *write_method = write_traceRouteCtlType;
1344 *var_len = (StorageTmp->traceRouteCtlTypeLen) * sizeof(oid);
1345
1346 return (u_char *) StorageTmp->traceRouteCtlType;
1347
1348 case COLUMN_TRACEROUTECTLROWSTATUS:
1349 *write_method = write_traceRouteCtlRowStatus;
1350 *var_len = sizeof(StorageTmp->traceRouteCtlRowStatus);
1351
1352 return (u_char *) & StorageTmp->traceRouteCtlRowStatus;
1353
1354 default:
1355 ERROR_MSG("");
1356 }
1357 return NULL;
1358 }
1359
1360
1361
1362 int
1363 traceRouteResultsTable_del(struct traceRouteCtlTable_data *thedata)
1364 {
1365 struct header_complex_index *hciptr2, *nhciptr2;
1366 netsnmp_variable_list *vars = NULL;
1367 oid newoid[MAX_OID_LEN];
1368 size_t newoid_len = 0;
1369
1370 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
1371 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
1372
1373 memset(newoid, '\0', sizeof(oid) * MAX_OID_LEN);
1374 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
1375
1376 for (hciptr2 = traceRouteResultsTableStorage; hciptr2; hciptr2 = nhciptr2) {
1377 nhciptr2 = hciptr2->next;
1378 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
1379 == 0) {
1380 header_complex_extract_entry(&traceRouteResultsTableStorage,
1381 hciptr2);
1382 DEBUGMSGTL(("traceRouteResultsTable", "delete success!\n"));
1383
1384 }
1385 }
1386 vars = NULL;
1387 return SNMPERR_SUCCESS;
1388 }
1389
1390
1391
1392
1393 int
1394 traceRouteProbeHistoryTable_del(struct traceRouteCtlTable_data *thedata)
1395 {
1396 struct header_complex_index *hciptr2, *nhciptr2;
1397 netsnmp_variable_list *vars = NULL;
1398 oid newoid[MAX_OID_LEN];
1399 size_t newoid_len = 0;
1400
1401 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
1402 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlOperationName */
1403
1404 memset(newoid, '\0', sizeof(oid) * MAX_OID_LEN);
1405
1406 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
1407
1408 for (hciptr2 = traceRouteProbeHistoryTableStorage; hciptr2;
1409 hciptr2 = nhciptr2) {
1410 nhciptr2 = hciptr2->next;
1411 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
1412 == 0) {
1413 header_complex_extract_entry(&traceRouteProbeHistoryTableStorage,
1414 hciptr2);
1415 DEBUGMSGTL(("traceRouteProbeHistoryTable",
1416 "delete success!\n"));
1417
1418 }
1419 }
1420 vars = NULL;
1421 return SNMPERR_SUCCESS;
1422 }
1423
1424
1425 int
1426 traceRouteHopsTable_del(struct traceRouteCtlTable_data *thedata)
1427 {
1428 struct header_complex_index *hciptr2, *nhciptr2;
1429 netsnmp_variable_list *vars = NULL;
1430 oid newoid[MAX_OID_LEN];
1431 size_t newoid_len = 0;
1432
1433 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlOwnerIndex, thedata->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
1434 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->traceRouteCtlTestName, thedata->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
1435
1436 memset(newoid, '\0', sizeof(oid) * MAX_OID_LEN);
1437
1438 header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
1439
1440 for (hciptr2 = traceRouteHopsTableStorage; hciptr2; hciptr2 = nhciptr2) {
1441 nhciptr2 = hciptr2->next;
1442 if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
1443 == 0) {
1444 header_complex_extract_entry(&traceRouteHopsTableStorage, hciptr2);
1445 DEBUGMSGTL(("traceRouteHopsTable", "delete success!\n"));
1446 }
1447 }
1448 vars = NULL;
1449 return SNMPERR_SUCCESS;
1450 }
1451
1452 /*
1453 * send trap
1454 */
1455
1456 void
1457 send_traceRoute_trap(struct traceRouteCtlTable_data *item,
1458 oid * trap_oid, size_t trap_oid_len)
1459 {
1460 static oid objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 }; /* snmpTrapIOD.0 */
1461 struct traceRouteHopsTable_data *StorageHops = NULL;
1462 netsnmp_variable_list *var_list = NULL;
1463 netsnmp_variable_list *vars = NULL;
1464 netsnmp_variable_list *var_hops = NULL;
1465 oid newoid[MAX_OID_LEN];
1466 size_t newoid_len = 0;
1467
1468 oid indexoid[MAX_OID_LEN];
1469 size_t indexoid_len = 0;
1470
1471 struct header_complex_index *hciptr;
1472 oid tempoid[MAX_OID_LEN];
1473 size_t tempoid_len = 0;
1474
1475 oid traceRouteCtlTargetAddress[] =
1476 { 1, 3, 6, 1, 2, 1, 81, 1, 2, 1, 4 };
1477 oid traceRouteHopsIpTgAddress[] =
1478 { 1, 3, 6, 1, 2, 1, 81, 1, 5, 1, 3 };
1479
1480 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
1481 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
1482
1483 /*
1484 * snmpTrap oid
1485 */
1486 snmp_varlist_add_variable(&var_list, objid_snmptrap,
1487 sizeof(objid_snmptrap) / sizeof(oid),
1488 ASN_OBJECT_ID, (u_char *) trap_oid,
1489 trap_oid_len * sizeof(oid));
1490
1491 /*
1492 * traceRouteCtlTargetAddress
1493 */
1494 memset(newoid, '\0', MAX_OID_LEN * sizeof(oid));
1495 header_complex_generate_oid(newoid, &newoid_len,
1496 traceRouteCtlTargetAddress,
1497 sizeof(traceRouteCtlTargetAddress) /
1498 sizeof(oid), vars);
1499
1500 snmp_varlist_add_variable(&var_list, newoid,
1501 newoid_len,
1502 ASN_OCTET_STR,
1503 (u_char *) item->traceRouteCtlTargetAddress,
1504 item->traceRouteCtlTargetAddressLen);
1505
1506 for (hciptr = traceRouteHopsTableStorage; hciptr != NULL;
1507 hciptr = hciptr->next) {
1508 memset(indexoid, '\0', MAX_OID_LEN * sizeof(oid));
1509 header_complex_generate_oid(indexoid, &indexoid_len, NULL, 0,
1510 vars);
1511 if (snmp_oid_compare
1512 (indexoid, indexoid_len, hciptr->name, indexoid_len) == 0) {
1513 StorageHops =
1514 (struct traceRouteHopsTable_data *)
1515 header_complex_get_from_oid(traceRouteHopsTableStorage,
1516 hciptr->name, hciptr->namelen);
1517 memset(tempoid, '\0', MAX_OID_LEN * sizeof(oid));
1518 header_complex_generate_oid(tempoid, &tempoid_len,
1519 traceRouteHopsIpTgAddress,
1520 sizeof(traceRouteHopsIpTgAddress) /
1521 sizeof(oid), vars);
1522 snmp_varlist_add_variable(&var_hops, NULL, 0, ASN_UNSIGNED, (char *) &StorageHops->traceRouteHopsHopIndex, sizeof(StorageHops->traceRouteHopsHopIndex)); /* traceRouteCtlTestName */
1523 memset(newoid, '\0', MAX_OID_LEN * sizeof(oid));
1524 header_complex_generate_oid(newoid, &newoid_len, tempoid,
1525 tempoid_len, var_hops);
1526 snmp_varlist_add_variable(&var_list, newoid, newoid_len,
1527 ASN_OCTET_STR,
1528 (u_char *) StorageHops->
1529 traceRouteHopsIpTgtAddress,
1530 StorageHops->
1531 traceRouteHopsIpTgtAddressLen);
1532
1533 var_hops = NULL;
1534 }
1535 }
1536
1537 /*
1538 * XXX: stuff based on event table
1539 */
1540
1541 DEBUGMSG(("pingTest:send_traceRoute_trap", "success!\n"));
1542
1543 send_v2trap(var_list);
1544 snmp_free_varbind(vars);
1545 vars = NULL;
1546 snmp_free_varbind(var_list);
1547 var_list = NULL;
1548 }
1549
1550
1551 int
1552 write_traceRouteCtlTargetAddressType(int action,
1553 u_char * var_val,
1554 u_char var_val_type,
1555 size_t var_val_len,
1556 u_char * statP, oid * name,
1557 size_t name_len)
1558 {
1559 static size_t tmpvar;
1560 struct traceRouteCtlTable_data *StorageTmp = NULL;
1561 size_t newlen =
1562 name_len -
1563 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
1564
1565 if ((StorageTmp =
1566 header_complex(traceRouteCtlTableStorage, NULL,
1567 &name[sizeof(traceRouteCtlTable_variables_oid) /
1568 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
1569 NULL)) == NULL)
1570 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
1571
1572 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
1573 return SNMP_ERR_NOTWRITABLE;
1574 }
1575
1576 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
1577 return SNMP_ERR_NOTWRITABLE;
1578 }
1579 switch (action) {
1580 case RESERVE1:
1581 if (var_val_type != ASN_INTEGER) {
1582 snmp_log(LOG_ERR,
1583 "write to traceRouteCtlTargetAddressType not ASN_INTEGER\n");
1584 return SNMP_ERR_WRONGTYPE;
1585 }
1586 break;
1587
1588
1589 case RESERVE2:
1590 /*
1591 * memory reseveration, final preparation...
1592 */
1593 break;
1594
1595
1596 case FREE:
1597 /*
1598 * Release any resources that have been allocated
1599 */
1600 break;
1601
1602
1603 case ACTION:
1604 /*
1605 * The variable has been stored in objid for
1606 * you to use, and you have just been asked to do something with
1607 * it. Note that anything done here must be reversable in the UNDO case
1608 */
1609 tmpvar = StorageTmp->traceRouteCtlTargetAddressType;
1610 StorageTmp->traceRouteCtlTargetAddressType = *((long *) var_val);
1611 break;
1612
1613
1614 case UNDO:
1615 /*
1616 * Back out any changes made in the ACTION case
1617 */
1618 StorageTmp->traceRouteCtlTargetAddressType = tmpvar;
1619 break;
1620
1621
1622 case COMMIT:
1623 /*
1624 * Things are working well, so it's now safe to make the change
1625 * permanently. Make sure that anything done here can't fail!
1626 */
1627 snmp_store_needed(NULL);
1628 break;
1629 }
1630 return SNMP_ERR_NOERROR;
1631 }
1632
1633
1634
1635 int
1636 write_traceRouteCtlTargetAddress(int action,
1637 u_char * var_val,
1638 u_char var_val_type,
1639 size_t var_val_len,
1640 u_char * statP, oid * name,
1641 size_t name_len)
1642 {
1643 static char *tmpvar;
1644 static size_t tmplen;
1645 struct traceRouteCtlTable_data *StorageTmp = NULL;
1646 size_t newlen =
1647 name_len -
1648 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
1649
1650 if ((StorageTmp =
1651 header_complex(traceRouteCtlTableStorage, NULL,
1652 &name[sizeof(traceRouteCtlTable_variables_oid) /
1653 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
1654 NULL)) == NULL)
1655 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
1656
1657 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
1658 return SNMP_ERR_NOTWRITABLE;
1659 }
1660
1661 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
1662 return SNMP_ERR_NOTWRITABLE;
1663 }
1664
1665 switch (action) {
1666 case RESERVE1:
1667 if (var_val_type != ASN_OCTET_STR) {
1668 snmp_log(LOG_ERR,
1669 "write to traceRouteCtlTargetAddress not ASN_OCTET_STR\n");
1670 return SNMP_ERR_WRONGTYPE;
1671 }
1672 break;
1673
1674
1675 case RESERVE2:
1676 /*
1677 * memory reseveration, final preparation...
1678 */
1679 break;
1680
1681
1682 case FREE:
1683 /*
1684 * Release any resources that have been allocated
1685 */
1686 break;
1687
1688
1689 case ACTION:
1690 /*
1691 * The variable has been stored in long_ret for
1692 * you to use, and you have just been asked to do something with
1693 * it. Note that anything done here must be reversable in the UNDO case
1694 */
1695 tmpvar = StorageTmp->traceRouteCtlTargetAddress;
1696 tmplen = StorageTmp->traceRouteCtlTargetAddressLen;
1697
1698 StorageTmp->traceRouteCtlTargetAddress =
1699 (char *) malloc(var_val_len + 1);
1700 if (StorageTmp->traceRouteCtlTargetAddress == NULL) {
1701 exit(1);
1702 }
1703 memcpy(StorageTmp->traceRouteCtlTargetAddress, var_val,
1704 var_val_len);
1705 StorageTmp->traceRouteCtlTargetAddress[var_val_len] = '\0';
1706 StorageTmp->traceRouteCtlTargetAddressLen = var_val_len;
1707
1708 break;
1709
1710
1711 case UNDO:
1712 /*
1713 * Back out any changes made in the ACTION case
1714 */
1715 SNMP_FREE(StorageTmp->traceRouteCtlTargetAddress);
1716 StorageTmp->traceRouteCtlTargetAddress = tmpvar;
1717 StorageTmp->traceRouteCtlTargetAddressLen = tmplen;
1718 break;
1719
1720
1721 case COMMIT:
1722 /*
1723 * Things are working well, so it's now safe to make the change
1724 * permanently. Make sure that anything done here can't fail!
1725 */
1726 SNMP_FREE(tmpvar);
1727 snmp_store_needed(NULL);
1728 break;
1729 }
1730 return SNMP_ERR_NOERROR;
1731 }
1732
1733 int
1734 write_traceRouteCtlByPassRouteTable(int action,
1735 u_char * var_val,
1736 u_char var_val_type,
1737 size_t var_val_len,
1738 u_char * statP, oid * name,
1739 size_t name_len)
1740 {
1741 static size_t tmpvar;
1742 struct traceRouteCtlTable_data *StorageTmp = NULL;
1743 size_t newlen =
1744 name_len -
1745 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
1746
1747 if ((StorageTmp =
1748 header_complex(traceRouteCtlTableStorage, NULL,
1749 &name[sizeof(traceRouteCtlTable_variables_oid) /
1750 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
1751 NULL)) == NULL)
1752 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
1753
1754 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
1755 return SNMP_ERR_NOTWRITABLE;
1756 }
1757
1758 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
1759 return SNMP_ERR_NOTWRITABLE;
1760 }
1761 switch (action) {
1762 case RESERVE1:
1763 if (var_val_type != ASN_INTEGER) {
1764 snmp_log(LOG_ERR,
1765 "write to traceRouteCtlTargetAddressType not ASN_INTEGER\n");
1766 return SNMP_ERR_WRONGTYPE;
1767 }
1768 break;
1769
1770
1771 case RESERVE2:
1772 /*
1773 * memory reseveration, final preparation...
1774 */
1775 break;
1776
1777
1778 case FREE:
1779 /*
1780 * Release any resources that have been allocated
1781 */
1782 break;
1783
1784
1785 case ACTION:
1786 /*
1787 * The variable has been stored in objid for
1788 * you to use, and you have just been asked to do something with
1789 * it. Note that anything done here must be reversable in the UNDO case
1790 */
1791 tmpvar = StorageTmp->traceRouteCtlByPassRouteTable;
1792 StorageTmp->traceRouteCtlByPassRouteTable = *((long *) var_val);
1793 break;
1794
1795
1796 case UNDO:
1797 /*
1798 * Back out any changes made in the ACTION case
1799 */
1800 StorageTmp->traceRouteCtlByPassRouteTable = tmpvar;
1801 break;
1802
1803
1804 case COMMIT:
1805 /*
1806 * Things are working well, so it's now safe to make the change
1807 * permanently. Make sure that anything done here can't fail!
1808 */
1809 snmp_store_needed(NULL);
1810 break;
1811 }
1812 return SNMP_ERR_NOERROR;
1813
1814 }
1815
1816 int
1817 write_traceRouteCtlDataSize(int action,
1818 u_char * var_val,
1819 u_char var_val_type,
1820 size_t var_val_len,
1821 u_char * statP, oid * name, size_t name_len)
1822 {
1823 static size_t tmpvar;
1824 struct traceRouteCtlTable_data *StorageTmp = NULL;
1825 size_t newlen =
1826 name_len -
1827 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
1828
1829 if ((StorageTmp =
1830 header_complex(traceRouteCtlTableStorage, NULL,
1831 &name[sizeof(traceRouteCtlTable_variables_oid) /
1832 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
1833 NULL)) == NULL)
1834 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
1835
1836 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
1837 return SNMP_ERR_NOTWRITABLE;
1838 }
1839
1840 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
1841 return SNMP_ERR_NOTWRITABLE;
1842 }
1843 switch (action) {
1844 case RESERVE1:
1845 if (var_val_type != ASN_UNSIGNED) {
1846 snmp_log(LOG_ERR,
1847 "write to traceRouteCtlDataSize not ASN_UNSIGNED\n");
1848 return SNMP_ERR_WRONGTYPE;
1849 }
1850 break;
1851
1852
1853 case RESERVE2:
1854 /*
1855 * memory reseveration, final preparation...
1856 */
1857 break;
1858
1859
1860 case FREE:
1861 /*
1862 * Release any resources that have been allocated
1863 */
1864 break;
1865
1866
1867 case ACTION:
1868 /*
1869 * The variable has been stored in objid for
1870 * you to use, and you have just been asked to do something with
1871 * it. Note that anything done here must be reversable in the UNDO case
1872 */
1873 tmpvar = StorageTmp->traceRouteCtlDataSize;
1874 if ((*((long *) var_val)) >= 0 && (*((long *) var_val)) <= 65507)
1875 StorageTmp->traceRouteCtlDataSize = *((long *) var_val);
1876 else
1877 StorageTmp->traceRouteCtlDataSize = 56;
1878 break;
1879
1880
1881 case UNDO:
1882 /*
1883 * Back out any changes made in the ACTION case
1884 */
1885 StorageTmp->traceRouteCtlDataSize = tmpvar;
1886 break;
1887
1888
1889 case COMMIT:
1890 /*
1891 * Things are working well, so it's now safe to make the change
1892 * permanently. Make sure that anything done here can't fail!
1893 */
1894 snmp_store_needed(NULL);
1895 break;
1896 }
1897 return SNMP_ERR_NOERROR;
1898 }
1899
1900
1901
1902
1903 int
1904 write_traceRouteCtlTimeOut(int action,
1905 u_char * var_val,
1906 u_char var_val_type,
1907 size_t var_val_len,
1908 u_char * statP, oid * name, size_t name_len)
1909 {
1910 static size_t tmpvar;
1911 struct traceRouteCtlTable_data *StorageTmp = NULL;
1912 size_t newlen =
1913 name_len -
1914 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
1915
1916 if ((StorageTmp =
1917 header_complex(traceRouteCtlTableStorage, NULL,
1918 &name[sizeof(traceRouteCtlTable_variables_oid) /
1919 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
1920 NULL)) == NULL)
1921 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
1922
1923 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
1924 return SNMP_ERR_NOTWRITABLE;
1925 }
1926
1927 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
1928 return SNMP_ERR_NOTWRITABLE;
1929 }
1930 switch (action) {
1931 case RESERVE1:
1932 if (var_val_type != ASN_UNSIGNED) {
1933 snmp_log(LOG_ERR,
1934 "write to traceRouteCtlDataSize not ASN_UNSIGNED\n");
1935 return SNMP_ERR_WRONGTYPE;
1936 }
1937 break;
1938
1939
1940 case RESERVE2:
1941 /*
1942 * memory reseveration, final preparation...
1943 */
1944 break;
1945
1946
1947 case FREE:
1948 /*
1949 * Release any resources that have been allocated
1950 */
1951 break;
1952
1953
1954 case ACTION:
1955 /*
1956 * The variable has been stored in objid for
1957 * you to use, and you have just been asked to do something with
1958 * it. Note that anything done here must be reversable in the UNDO case
1959 */
1960 tmpvar = StorageTmp->traceRouteCtlTimeOut;
1961
1962 if ((*((long *) var_val)) >= 1 && (*((long *) var_val)) <= 60)
1963 StorageTmp->traceRouteCtlTimeOut = *((long *) var_val);
1964 else
1965 StorageTmp->traceRouteCtlTimeOut = 3;
1966 break;
1967
1968
1969 case UNDO:
1970 /*
1971 * Back out any changes made in the ACTION case
1972 */
1973 StorageTmp->traceRouteCtlTimeOut = tmpvar;
1974 break;
1975
1976
1977 case COMMIT:
1978 /*
1979 * Things are working well, so it's now safe to make the change
1980 * permanently. Make sure that anything done here can't fail!
1981 */
1982 snmp_store_needed(NULL);
1983 break;
1984 }
1985 return SNMP_ERR_NOERROR;
1986 }
1987
1988
1989
1990
1991
1992 int
1993 write_traceRouteCtlProbesPerHop(int action,
1994 u_char * var_val,
1995 u_char var_val_type,
1996 size_t var_val_len,
1997 u_char * statP, oid * name,
1998 size_t name_len)
1999 {
2000 static size_t tmpvar;
2001 struct traceRouteCtlTable_data *StorageTmp = NULL;
2002 size_t newlen =
2003 name_len -
2004 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2005
2006 if ((StorageTmp =
2007 header_complex(traceRouteCtlTableStorage, NULL,
2008 &name[sizeof(traceRouteCtlTable_variables_oid) /
2009 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2010 NULL)) == NULL)
2011 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2012
2013 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2014 return SNMP_ERR_NOTWRITABLE;
2015 }
2016
2017 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2018 return SNMP_ERR_NOTWRITABLE;
2019 }
2020 switch (action) {
2021 case RESERVE1:
2022 if (var_val_type != ASN_UNSIGNED) {
2023 snmp_log(LOG_ERR,
2024 "write to traceRouteCtlDataSize not ASN_UNSIGNED\n");
2025 return SNMP_ERR_WRONGTYPE;
2026 }
2027 break;
2028
2029
2030 case RESERVE2:
2031 /*
2032 * memory reseveration, final preparation...
2033 */
2034 break;
2035
2036
2037 case FREE:
2038 /*
2039 * Release any resources that have been allocated
2040 */
2041 break;
2042
2043
2044 case ACTION:
2045 /*
2046 * The variable has been stored in objid for
2047 * you to use, and you have just been asked to do something with
2048 * it. Note that anything done here must be reversable in the UNDO case
2049 */
2050 tmpvar = StorageTmp->traceRouteCtlProbesPerHop;
2051
2052 if ((*((long *) var_val)) >= 1 && (*((long *) var_val)) <= 10)
2053 StorageTmp->traceRouteCtlProbesPerHop = *((long *) var_val);
2054 else
2055 StorageTmp->traceRouteCtlProbesPerHop = 3;
2056 break;
2057
2058
2059 case UNDO:
2060 /*
2061 * Back out any changes made in the ACTION case
2062 */
2063 StorageTmp->traceRouteCtlProbesPerHop = tmpvar;
2064 break;
2065
2066
2067 case COMMIT:
2068 /*
2069 * Things are working well, so it's now safe to make the change
2070 * permanently. Make sure that anything done here can't fail!
2071 */
2072 snmp_store_needed(NULL);
2073 break;
2074 }
2075 return SNMP_ERR_NOERROR;
2076 }
2077
2078
2079
2080 int
2081 write_traceRouteCtlPort(int action,
2082 u_char * var_val,
2083 u_char var_val_type,
2084 size_t var_val_len,
2085 u_char * statP, oid * name, size_t name_len)
2086 {
2087 static size_t tmpvar;
2088 struct traceRouteCtlTable_data *StorageTmp = NULL;
2089 size_t newlen =
2090 name_len -
2091 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2092
2093 if ((StorageTmp =
2094 header_complex(traceRouteCtlTableStorage, NULL,
2095 &name[sizeof(traceRouteCtlTable_variables_oid) /
2096 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2097 NULL)) == NULL)
2098 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2099
2100 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2101 return SNMP_ERR_NOTWRITABLE;
2102 }
2103
2104 switch (action) {
2105 case RESERVE1:
2106 if (var_val_type != ASN_UNSIGNED) {
2107 snmp_log(LOG_ERR,
2108 "write to traceRouteCtlTargetAddressType not ASN_UNSIGNED\n");
2109 return SNMP_ERR_WRONGTYPE;
2110 }
2111 break;
2112
2113
2114 case RESERVE2:
2115 /*
2116 * memory reseveration, final preparation...
2117 */
2118 break;
2119
2120
2121 case FREE:
2122 /*
2123 * Release any resources that have been allocated
2124 */
2125 break;
2126
2127
2128 case ACTION:
2129 /*
2130 * The variable has been stored in objid for
2131 * you to use, and you have just been asked to do something with
2132 * it. Note that anything done here must be reversable in the UNDO case
2133 */
2134 tmpvar = StorageTmp->traceRouteCtlPort;
2135 StorageTmp->traceRouteCtlPort = *((long *) var_val);
2136 break;
2137
2138
2139 case UNDO:
2140 /*
2141 * Back out any changes made in the ACTION case
2142 */
2143 StorageTmp->traceRouteCtlPort = tmpvar;
2144 break;
2145
2146
2147 case COMMIT:
2148 /*
2149 * Things are working well, so it's now safe to make the change
2150 * permanently. Make sure that anything done here can't fail!
2151 */
2152 snmp_store_needed(NULL);
2153 break;
2154 }
2155 return SNMP_ERR_NOERROR;
2156 }
2157
2158
2159
2160
2161 int
2162 write_traceRouteCtlMaxTtl(int action,
2163 u_char * var_val,
2164 u_char var_val_type,
2165 size_t var_val_len,
2166 u_char * statP, oid * name, size_t name_len)
2167 {
2168 static size_t tmpvar;
2169 struct traceRouteCtlTable_data *StorageTmp = NULL;
2170 size_t newlen =
2171 name_len -
2172 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2173
2174 if ((StorageTmp =
2175 header_complex(traceRouteCtlTableStorage, NULL,
2176 &name[sizeof(traceRouteCtlTable_variables_oid) /
2177 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2178 NULL)) == NULL)
2179 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2180
2181 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2182 return SNMP_ERR_NOTWRITABLE;
2183 }
2184
2185 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2186 return SNMP_ERR_NOTWRITABLE;
2187 }
2188 switch (action) {
2189 case RESERVE1:
2190 if (var_val_type != ASN_UNSIGNED) {
2191 snmp_log(LOG_ERR,
2192 "write to traceRouteCtlDataSize not ASN_UNSIGNED\n");
2193 return SNMP_ERR_WRONGTYPE;
2194 }
2195 break;
2196
2197
2198 case RESERVE2:
2199 /*
2200 * memory reseveration, final preparation...
2201 */
2202 break;
2203
2204
2205 case FREE:
2206 /*
2207 * Release any resources that have been allocated
2208 */
2209 break;
2210
2211
2212 case ACTION:
2213 /*
2214 * The variable has been stored in objid for
2215 * you to use, and you have just been asked to do something with
2216 * it. Note that anything done here must be reversable in the UNDO case
2217 */
2218 tmpvar = StorageTmp->traceRouteCtlMaxTtl;
2219 if ((*((long *) var_val)) >= 1 && (*((long *) var_val)) <= 255)
2220 StorageTmp->traceRouteCtlMaxTtl = *((long *) var_val);
2221 else
2222 StorageTmp->traceRouteCtlMaxTtl = 30;
2223 break;
2224
2225
2226 case UNDO:
2227 /*
2228 * Back out any changes made in the ACTION case
2229 */
2230 StorageTmp->traceRouteCtlMaxTtl = tmpvar;
2231 break;
2232
2233
2234 case COMMIT:
2235 /*
2236 * Things are working well, so it's now safe to make the change
2237 * permanently. Make sure that anything done here can't fail!
2238 */
2239 snmp_store_needed(NULL);
2240 break;
2241 }
2242 return SNMP_ERR_NOERROR;
2243 }
2244
2245
2246 int
2247 write_traceRouteCtlDSField(int action,
2248 u_char * var_val,
2249 u_char var_val_type,
2250 size_t var_val_len,
2251 u_char * statP, oid * name, size_t name_len)
2252 {
2253 static size_t tmpvar;
2254 struct traceRouteCtlTable_data *StorageTmp = NULL;
2255 size_t newlen =
2256 name_len -
2257 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2258
2259 if ((StorageTmp =
2260 header_complex(traceRouteCtlTableStorage, NULL,
2261 &name[sizeof(traceRouteCtlTable_variables_oid) /
2262 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2263 NULL)) == NULL)
2264 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2265
2266 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2267 return SNMP_ERR_NOTWRITABLE;
2268 }
2269
2270 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2271 return SNMP_ERR_NOTWRITABLE;
2272 }
2273 switch (action) {
2274 case RESERVE1:
2275 if (var_val_type != ASN_UNSIGNED) {
2276 snmp_log(LOG_ERR,
2277 "write to traceRouteCtlDataSize not ASN_UNSIGNED\n");
2278 return SNMP_ERR_WRONGTYPE;
2279 }
2280 break;
2281
2282
2283 case RESERVE2:
2284 /*
2285 * memory reseveration, final preparation...
2286 */
2287 break;
2288
2289
2290 case FREE:
2291 /*
2292 * Release any resources that have been allocated
2293 */
2294 break;
2295
2296
2297 case ACTION:
2298 /*
2299 * The variable has been stored in objid for
2300 * you to use, and you have just been asked to do something with
2301 * it. Note that anything done here must be reversable in the UNDO case
2302 */
2303 tmpvar = StorageTmp->traceRouteCtlDSField;
2304 StorageTmp->traceRouteCtlDSField = *((long *) var_val);
2305 break;
2306
2307
2308 case UNDO:
2309 /*
2310 * Back out any changes made in the ACTION case
2311 */
2312 StorageTmp->traceRouteCtlDSField = tmpvar;
2313 break;
2314
2315
2316 case COMMIT:
2317 /*
2318 * Things are working well, so it's now safe to make the change
2319 * permanently. Make sure that anything done here can't fail!
2320 */
2321 snmp_store_needed(NULL);
2322 break;
2323 }
2324 return SNMP_ERR_NOERROR;
2325 }
2326
2327 int
2328 write_traceRouteCtlSourceAddressType(int action,
2329 u_char * var_val,
2330 u_char var_val_type,
2331 size_t var_val_len,
2332 u_char * statP, oid * name,
2333 size_t name_len)
2334 {
2335 static size_t tmpvar;
2336 struct traceRouteCtlTable_data *StorageTmp = NULL;
2337 size_t newlen =
2338 name_len -
2339 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2340
2341 if ((StorageTmp =
2342 header_complex(traceRouteCtlTableStorage, NULL,
2343 &name[sizeof(traceRouteCtlTable_variables_oid) /
2344 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2345 NULL)) == NULL)
2346 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2347
2348 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2349 return SNMP_ERR_NOTWRITABLE;
2350 }
2351
2352 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2353 return SNMP_ERR_NOTWRITABLE;
2354 }
2355 switch (action) {
2356 case RESERVE1:
2357 if (var_val_type != ASN_INTEGER) {
2358 snmp_log(LOG_ERR,
2359 "write to traceRouteCtlMaxRows not ASN_INTEGER\n");
2360 return SNMP_ERR_WRONGTYPE;
2361 }
2362 break;
2363
2364
2365 case RESERVE2:
2366 /*
2367 * memory reseveration, final preparation...
2368 */
2369 break;
2370
2371
2372 case FREE:
2373 /*
2374 * Release any resources that have been allocated
2375 */
2376 break;
2377
2378
2379 case ACTION:
2380 /*
2381 * The variable has been stored in objid for
2382 * you to use, and you have just been asked to do something with
2383 * it. Note that anything done here must be reversable in the UNDO case
2384 */
2385 tmpvar = StorageTmp->traceRouteCtlSourceAddressType;
2386 StorageTmp->traceRouteCtlSourceAddressType = *((long *) var_val);
2387 break;
2388
2389
2390 case UNDO:
2391 /*
2392 * Back out any changes made in the ACTION case
2393 */
2394 StorageTmp->traceRouteCtlSourceAddressType = tmpvar;
2395 break;
2396
2397
2398 case COMMIT:
2399 /*
2400 * Things are working well, so it's now safe to make the change
2401 * permanently. Make sure that anything done here can't fail!
2402 */
2403 snmp_store_needed(NULL);
2404 break;
2405 }
2406 return SNMP_ERR_NOERROR;
2407 }
2408
2409 int
2410 write_traceRouteCtlSourceAddress(int action,
2411 u_char * var_val,
2412 u_char var_val_type,
2413 size_t var_val_len,
2414 u_char * statP, oid * name,
2415 size_t name_len)
2416 {
2417 static char *tmpvar;
2418 static size_t tmplen;
2419 struct traceRouteCtlTable_data *StorageTmp = NULL;
2420 size_t newlen =
2421 name_len -
2422 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2423
2424 if ((StorageTmp =
2425 header_complex(traceRouteCtlTableStorage, NULL,
2426 &name[sizeof(traceRouteCtlTable_variables_oid) /
2427 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2428 NULL)) == NULL)
2429 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2430
2431 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2432 return SNMP_ERR_NOTWRITABLE;
2433 }
2434
2435 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2436 return SNMP_ERR_NOTWRITABLE;
2437 }
2438
2439 switch (action) {
2440 case RESERVE1:
2441 if (var_val_type != ASN_OCTET_STR) {
2442 snmp_log(LOG_ERR,
2443 "write to traceRouteCtlTargetAddress not ASN_OCTET_STR\n");
2444 return SNMP_ERR_WRONGTYPE;
2445 }
2446 break;
2447
2448
2449 case RESERVE2:
2450 /*
2451 * memory reseveration, final preparation...
2452 */
2453 break;
2454
2455
2456 case FREE:
2457 /*
2458 * Release any resources that have been allocated
2459 */
2460 break;
2461
2462
2463 case ACTION:
2464 /*
2465 * The variable has been stored in long_ret for
2466 * you to use, and you have just been asked to do something with
2467 * it. Note that anything done here must be reversable in the UNDO case
2468 */
2469 tmpvar = StorageTmp->traceRouteCtlSourceAddress;
2470 tmplen = StorageTmp->traceRouteCtlSourceAddressLen;
2471 StorageTmp->traceRouteCtlSourceAddress =
2472 (char *) malloc(var_val_len + 1);
2473 if (StorageTmp->traceRouteCtlSourceAddress == NULL) {
2474 exit(1);
2475 }
2476 memcpy(StorageTmp->traceRouteCtlSourceAddress, var_val,
2477 var_val_len + 1);
2478 StorageTmp->traceRouteCtlSourceAddress[var_val_len] = '\0';
2479 StorageTmp->traceRouteCtlSourceAddressLen = var_val_len;
2480 break;
2481
2482
2483 case UNDO:
2484 /*
2485 * Back out any changes made in the ACTION case
2486 */
2487 SNMP_FREE(StorageTmp->traceRouteCtlSourceAddress);
2488 StorageTmp->traceRouteCtlSourceAddress = tmpvar;
2489 StorageTmp->traceRouteCtlSourceAddressLen = tmplen;
2490 break;
2491
2492
2493 case COMMIT:
2494 /*
2495 * Things are working well, so it's now safe to make the change
2496 * permanently. Make sure that anything done here can't fail!
2497 */
2498 SNMP_FREE(tmpvar);
2499 snmp_store_needed(NULL);
2500 break;
2501 }
2502 return SNMP_ERR_NOERROR;
2503 }
2504
2505
2506
2507
2508 int
2509 write_traceRouteCtlIfIndex(int action,
2510 u_char * var_val,
2511 u_char var_val_type,
2512 size_t var_val_len,
2513 u_char * statP, oid * name, size_t name_len)
2514 {
2515 static size_t tmpvar;
2516 struct traceRouteCtlTable_data *StorageTmp = NULL;
2517 size_t newlen =
2518 name_len -
2519 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2520
2521 if ((StorageTmp =
2522 header_complex(traceRouteCtlTableStorage, NULL,
2523 &name[sizeof(traceRouteCtlTable_variables_oid) /
2524 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2525 NULL)) == NULL)
2526 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2527
2528 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2529 return SNMP_ERR_NOTWRITABLE;
2530 }
2531
2532 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2533 return SNMP_ERR_NOTWRITABLE;
2534 }
2535 switch (action) {
2536 case RESERVE1:
2537 if (var_val_type != ASN_INTEGER) {
2538 snmp_log(LOG_ERR,
2539 "write to traceRouteCtlMaxRows not ASN_INTEGER\n");
2540 return SNMP_ERR_WRONGTYPE;
2541 }
2542 break;
2543
2544
2545 case RESERVE2:
2546 /*
2547 * memory reseveration, final preparation...
2548 */
2549 break;
2550
2551
2552 case FREE:
2553 /*
2554 * Release any resources that have been allocated
2555 */
2556 break;
2557
2558
2559 case ACTION:
2560 /*
2561 * The variable has been stored in objid for
2562 * you to use, and you have just been asked to do something with
2563 * it. Note that anything done here must be reversable in the UNDO case
2564 */
2565 tmpvar = StorageTmp->traceRouteCtlIfIndex;
2566 StorageTmp->traceRouteCtlIfIndex = *((long *) var_val);
2567 break;
2568
2569
2570 case UNDO:
2571 /*
2572 * Back out any changes made in the ACTION case
2573 */
2574 StorageTmp->traceRouteCtlIfIndex = tmpvar;
2575 break;
2576
2577
2578 case COMMIT:
2579 /*
2580 * Things are working well, so it's now safe to make the change
2581 * permanently. Make sure that anything done here can't fail!
2582 */
2583 snmp_store_needed(NULL);
2584 break;
2585 }
2586 return SNMP_ERR_NOERROR;
2587 }
2588
2589
2590
2591 int
2592 write_traceRouteCtlMiscOptions(int action,
2593 u_char * var_val,
2594 u_char var_val_type,
2595 size_t var_val_len,
2596 u_char * statP, oid * name, size_t name_len)
2597 {
2598 static char *tmpvar;
2599 static size_t tmplen;
2600 struct traceRouteCtlTable_data *StorageTmp = NULL;
2601 size_t newlen =
2602 name_len -
2603 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2604
2605 if ((StorageTmp =
2606 header_complex(traceRouteCtlTableStorage, NULL,
2607 &name[sizeof(traceRouteCtlTable_variables_oid) /
2608 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2609 NULL)) == NULL)
2610 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2611
2612 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2613 return SNMP_ERR_NOTWRITABLE;
2614 }
2615
2616 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2617 return SNMP_ERR_NOTWRITABLE;
2618 }
2619
2620 switch (action) {
2621 case RESERVE1:
2622 if (var_val_type != ASN_OCTET_STR) {
2623 snmp_log(LOG_ERR,
2624 "write to traceRouteCtlTargetAddress not ASN_OCTET_STR\n");
2625 return SNMP_ERR_WRONGTYPE;
2626 }
2627 break;
2628
2629
2630 case RESERVE2:
2631 /*
2632 * memory reseveration, final preparation...
2633 */
2634 break;
2635
2636
2637 case FREE:
2638 /*
2639 * Release any resources that have been allocated
2640 */
2641 break;
2642
2643
2644 case ACTION:
2645 /*
2646 * The variable has been stored in long_ret for
2647 * you to use, and you have just been asked to do something with
2648 * it. Note that anything done here must be reversable in the UNDO case
2649 */
2650 tmpvar = StorageTmp->traceRouteCtlMiscOptions;
2651 tmplen = StorageTmp->traceRouteCtlMiscOptionsLen;
2652 StorageTmp->traceRouteCtlMiscOptions =
2653 (char *) malloc(var_val_len + 1);
2654 if (StorageTmp->traceRouteCtlMiscOptions == NULL) {
2655 exit(1);
2656 }
2657 memcpy(StorageTmp->traceRouteCtlMiscOptions, var_val,
2658 var_val_len + 1);
2659 StorageTmp->traceRouteCtlMiscOptions[var_val_len] = '\0';
2660 StorageTmp->traceRouteCtlMiscOptionsLen = var_val_len;
2661 break;
2662
2663
2664 case UNDO:
2665 /*
2666 * Back out any changes made in the ACTION case
2667 */
2668 SNMP_FREE(StorageTmp->traceRouteCtlMiscOptions);
2669 StorageTmp->traceRouteCtlMiscOptions = tmpvar;
2670 StorageTmp->traceRouteCtlMiscOptionsLen = tmplen;
2671 break;
2672
2673
2674 case COMMIT:
2675 /*
2676 * Things are working well, so it's now safe to make the change
2677 * permanently. Make sure that anything done here can't fail!
2678 */
2679 SNMP_FREE(tmpvar);
2680 snmp_store_needed(NULL);
2681 break;
2682 }
2683 return SNMP_ERR_NOERROR;
2684 }
2685
2686 int
2687 write_traceRouteCtlMaxFailures(int action,
2688 u_char * var_val,
2689 u_char var_val_type,
2690 size_t var_val_len,
2691 u_char * statP, oid * name, size_t name_len)
2692 {
2693 static size_t tmpvar;
2694 struct traceRouteCtlTable_data *StorageTmp = NULL;
2695 size_t newlen =
2696 name_len -
2697 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2698
2699 if ((StorageTmp =
2700 header_complex(traceRouteCtlTableStorage, NULL,
2701 &name[sizeof(traceRouteCtlTable_variables_oid) /
2702 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2703 NULL)) == NULL)
2704 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2705
2706 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2707 return SNMP_ERR_NOTWRITABLE;
2708 }
2709
2710 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2711 return SNMP_ERR_NOTWRITABLE;
2712 }
2713 switch (action) {
2714 case RESERVE1:
2715 if (var_val_type != ASN_UNSIGNED) {
2716 snmp_log(LOG_ERR,
2717 "write to traceRouteCtlTrapTestFailureFilter not ASN_UNSIGNED\n");
2718 return SNMP_ERR_WRONGTYPE;
2719 }
2720 break;
2721
2722
2723 case RESERVE2:
2724 /*
2725 * memory reseveration, final preparation...
2726 */
2727 break;
2728
2729
2730 case FREE:
2731 /*
2732 * Release any resources that have been allocated
2733 */
2734 break;
2735
2736
2737 case ACTION:
2738 /*
2739 * The variable has been stored in objid for
2740 * you to use, and you have just been asked to do something with
2741 * it. Note that anything done here must be reversable in the UNDO case
2742 */
2743 tmpvar = StorageTmp->traceRouteCtlMaxFailures;
2744 if ((*((long *) var_val)) >= 0 && (*((long *) var_val)) <= 15)
2745 StorageTmp->traceRouteCtlMaxFailures = *((long *) var_val);
2746 else
2747 StorageTmp->traceRouteCtlMaxFailures = 1;
2748 break;
2749
2750
2751 case UNDO:
2752 /*
2753 * Back out any changes made in the ACTION case
2754 */
2755 StorageTmp->traceRouteCtlMaxFailures = tmpvar;
2756 break;
2757
2758
2759 case COMMIT:
2760 /*
2761 * Things are working well, so it's now safe to make the change
2762 * permanently. Make sure that anything done here can't fail!
2763 */
2764 snmp_store_needed(NULL);
2765 break;
2766 }
2767 return SNMP_ERR_NOERROR;
2768 }
2769
2770
2771
2772
2773
2774 int
2775 write_traceRouteCtlDontFragment(int action,
2776 u_char * var_val,
2777 u_char var_val_type,
2778 size_t var_val_len,
2779 u_char * statP, oid * name,
2780 size_t name_len)
2781 {
2782 static size_t tmpvar;
2783 struct traceRouteCtlTable_data *StorageTmp = NULL;
2784 size_t newlen =
2785 name_len -
2786 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2787
2788 if ((StorageTmp =
2789 header_complex(traceRouteCtlTableStorage, NULL,
2790 &name[sizeof(traceRouteCtlTable_variables_oid) /
2791 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2792 NULL)) == NULL)
2793 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2794
2795 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2796 return SNMP_ERR_NOTWRITABLE;
2797 }
2798
2799 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2800 return SNMP_ERR_NOTWRITABLE;
2801 }
2802 switch (action) {
2803 case RESERVE1:
2804 if (var_val_type != ASN_INTEGER) {
2805 snmp_log(LOG_ERR,
2806 "write to traceRouteCtlMaxRows not ASN_INTEGER\n");
2807 return SNMP_ERR_WRONGTYPE;
2808 }
2809 break;
2810
2811
2812 case RESERVE2:
2813 /*
2814 * memory reseveration, final preparation...
2815 */
2816 break;
2817
2818
2819 case FREE:
2820 /*
2821 * Release any resources that have been allocated
2822 */
2823 break;
2824
2825
2826 case ACTION:
2827 /*
2828 * The variable has been stored in objid for
2829 * you to use, and you have just been asked to do something with
2830 * it. Note that anything done here must be reversable in the UNDO case
2831 */
2832 tmpvar = StorageTmp->traceRouteCtlDontFragment;
2833 StorageTmp->traceRouteCtlDontFragment = *((long *) var_val);
2834 break;
2835
2836
2837 case UNDO:
2838 /*
2839 * Back out any changes made in the ACTION case
2840 */
2841 StorageTmp->traceRouteCtlDontFragment = tmpvar;
2842 break;
2843
2844
2845 case COMMIT:
2846 /*
2847 * Things are working well, so it's now safe to make the change
2848 * permanently. Make sure that anything done here can't fail!
2849 */
2850 snmp_store_needed(NULL);
2851 break;
2852 }
2853 return SNMP_ERR_NOERROR;
2854 }
2855
2856
2857
2858
2859 int
2860 write_traceRouteCtlInitialTtl(int action,
2861 u_char * var_val,
2862 u_char var_val_type,
2863 size_t var_val_len,
2864 u_char * statP, oid * name, size_t name_len)
2865 {
2866 static size_t tmpvar;
2867 struct traceRouteCtlTable_data *StorageTmp = NULL;
2868 size_t newlen =
2869 name_len -
2870 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2871
2872 if ((StorageTmp =
2873 header_complex(traceRouteCtlTableStorage, NULL,
2874 &name[sizeof(traceRouteCtlTable_variables_oid) /
2875 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2876 NULL)) == NULL)
2877 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2878
2879 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2880 return SNMP_ERR_NOTWRITABLE;
2881 }
2882
2883 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2884 return SNMP_ERR_NOTWRITABLE;
2885 }
2886 switch (action) {
2887 case RESERVE1:
2888 if (var_val_type != ASN_UNSIGNED) {
2889 snmp_log(LOG_ERR,
2890 "write to traceRouteCtlTrapTestFailureFilter not ASN_UNSIGNED\n");
2891 return SNMP_ERR_WRONGTYPE;
2892 }
2893 break;
2894
2895
2896 case RESERVE2:
2897 /*
2898 * memory reseveration, final preparation...
2899 */
2900 break;
2901
2902
2903 case FREE:
2904 /*
2905 * Release any resources that have been allocated
2906 */
2907 break;
2908
2909
2910 case ACTION:
2911 /*
2912 * The variable has been stored in objid for
2913 * you to use, and you have just been asked to do something with
2914 * it. Note that anything done here must be reversable in the UNDO case
2915 */
2916 tmpvar = StorageTmp->traceRouteCtlInitialTtl;
2917 if ((*((long *) var_val)) >= 0 && (*((long *) var_val)) <= 255)
2918 StorageTmp->traceRouteCtlInitialTtl = *((long *) var_val);
2919 else
2920 StorageTmp->traceRouteCtlInitialTtl = 1;
2921 break;
2922
2923
2924 case UNDO:
2925 /*
2926 * Back out any changes made in the ACTION case
2927 */
2928 StorageTmp->traceRouteCtlInitialTtl = tmpvar;
2929 break;
2930
2931
2932 case COMMIT:
2933 /*
2934 * Things are working well, so it's now safe to make the change
2935 * permanently. Make sure that anything done here can't fail!
2936 */
2937 snmp_store_needed(NULL);
2938 break;
2939 }
2940 return SNMP_ERR_NOERROR;
2941 }
2942
2943
2944 int
2945 write_traceRouteCtlFrequency(int action,
2946 u_char * var_val,
2947 u_char var_val_type,
2948 size_t var_val_len,
2949 u_char * statP, oid * name, size_t name_len)
2950 {
2951 static size_t tmpvar;
2952 struct traceRouteCtlTable_data *StorageTmp = NULL;
2953 size_t newlen =
2954 name_len -
2955 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
2956
2957 if ((StorageTmp =
2958 header_complex(traceRouteCtlTableStorage, NULL,
2959 &name[sizeof(traceRouteCtlTable_variables_oid) /
2960 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
2961 NULL)) == NULL)
2962 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
2963
2964 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
2965 return SNMP_ERR_NOTWRITABLE;
2966 }
2967
2968 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
2969 return SNMP_ERR_NOTWRITABLE;
2970 }
2971 switch (action) {
2972 case RESERVE1:
2973 if (var_val_type != ASN_UNSIGNED) {
2974 snmp_log(LOG_ERR,
2975 "write to traceRouteCtlSourceAddressType not ASN_UNSIGNED\n");
2976 return SNMP_ERR_WRONGTYPE;
2977 }
2978 break;
2979
2980
2981 case RESERVE2:
2982 /*
2983 * memory reseveration, final preparation...
2984 */
2985 break;
2986
2987
2988 case FREE:
2989 /*
2990 * Release any resources that have been allocated
2991 */
2992 break;
2993
2994
2995 case ACTION:
2996 /*
2997 * The variable has been stored in objid for
2998 * you to use, and you have just been asked to do something with
2999 * it. Note that anything done here must be reversable in the UNDO case
3000 */
3001 tmpvar = StorageTmp->traceRouteCtlFrequency;
3002 StorageTmp->traceRouteCtlFrequency = *((long *) var_val);
3003 break;
3004
3005
3006 case UNDO:
3007 /*
3008 * Back out any changes made in the ACTION case
3009 */
3010 StorageTmp->traceRouteCtlFrequency = tmpvar;
3011 break;
3012
3013
3014 case COMMIT:
3015 /*
3016 * Things are working well, so it's now safe to make the change
3017 * permanently. Make sure that anything done here can't fail!
3018 */
3019 snmp_store_needed(NULL);
3020 break;
3021 }
3022 return SNMP_ERR_NOERROR;
3023 }
3024
3025
3026
3027
3028 int
3029 write_traceRouteCtlStorageType(int action,
3030 u_char * var_val,
3031 u_char var_val_type,
3032 size_t var_val_len,
3033 u_char * statP, oid * name, size_t name_len)
3034 {
3035 static size_t tmpvar;
3036 int set_value;
3037 struct traceRouteCtlTable_data *StorageTmp = NULL;
3038 size_t newlen =
3039 name_len -
3040 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3041
3042 if ((StorageTmp =
3043 header_complex(traceRouteCtlTableStorage, NULL,
3044 &name[sizeof(traceRouteCtlTable_variables_oid) /
3045 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3046 NULL)) == NULL)
3047 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3048
3049 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3050 return SNMP_ERR_NOTWRITABLE;
3051 }
3052
3053 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3054 return SNMP_ERR_NOTWRITABLE;
3055 }
3056
3057
3058 set_value = *((long *) var_val);
3059
3060 switch (action) {
3061 case RESERVE1:
3062 if (var_val_type != ASN_INTEGER) {
3063 snmp_log(LOG_ERR,
3064 "write to traceRouteCtlMaxRows not ASN_INTEGER\n");
3065 return SNMP_ERR_WRONGTYPE;
3066 }
3067
3068 if ((StorageTmp->traceRouteCtlStorageType == 2
3069 || StorageTmp->traceRouteCtlStorageType == 3)
3070 && (set_value == 4 || set_value == 5)) {
3071 return SNMP_ERR_WRONGVALUE;
3072 }
3073 break;
3074
3075 case RESERVE2:
3076 /*
3077 * memory reseveration, final preparation...
3078 */
3079 break;
3080
3081
3082 case FREE:
3083 /*
3084 * Release any resources that have been allocated
3085 */
3086 break;
3087
3088
3089 case ACTION:
3090 /*
3091 * The variable has been stored in objid for
3092 * you to use, and you have just been asked to do something with
3093 * it. Note that anything done here must be reversable in the UNDO case
3094 */
3095 tmpvar = StorageTmp->traceRouteCtlStorageType;
3096 StorageTmp->traceRouteCtlStorageType = *((long *) var_val);
3097 break;
3098
3099
3100 case UNDO:
3101 /*
3102 * Back out any changes made in the ACTION case
3103 */
3104 StorageTmp->traceRouteCtlStorageType = tmpvar;
3105 break;
3106
3107
3108 case COMMIT:
3109 /*
3110 * Things are working well, so it's now safe to make the change
3111 * permanently. Make sure that anything done here can't fail!
3112 */
3113 snmp_store_needed(NULL);
3114 break;
3115 }
3116 return SNMP_ERR_NOERROR;
3117 }
3118
3119
3120
3121 int
3122 write_traceRouteCtlAdminStatus(int action,
3123 u_char * var_val,
3124 u_char var_val_type,
3125 size_t var_val_len,
3126 u_char * statP, oid * name, size_t name_len)
3127 {
3128 static size_t tmpvar;
3129 struct traceRouteCtlTable_data *StorageTmp = NULL;
3130 netsnmp_variable_list *vars = NULL;
3131 struct traceRouteResultsTable_data *StorageNew = NULL;
3132 size_t newlen =
3133 name_len -
3134 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3135
3136 if ((StorageTmp =
3137 header_complex(traceRouteCtlTableStorage, NULL,
3138 &name[sizeof(traceRouteCtlTable_variables_oid) /
3139 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3140 NULL)) == NULL)
3141 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3142
3143 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3144 return SNMP_ERR_NOTWRITABLE;
3145 }
3146
3147 switch (action) {
3148 case RESERVE1:
3149 if (var_val_type != ASN_INTEGER) {
3150 snmp_log(LOG_ERR,
3151 "write to traceRouteCtlIfIndex not ASN_INTEGER\n");
3152 return SNMP_ERR_WRONGTYPE;
3153 }
3154 break;
3155
3156
3157 case RESERVE2:
3158 /*
3159 * memory reseveration, final preparation...
3160 */
3161 break;
3162
3163
3164 case FREE:
3165 /*
3166 * Release any resources that have been allocated
3167 */
3168 break;
3169
3170
3171 case ACTION:
3172 /*
3173 * The variable has been stored in objid for
3174 * you to use, and you have just been asked to do something with
3175 * it. Note that anything done here must be reversable in the UNDO case
3176 */
3177 tmpvar = StorageTmp->traceRouteCtlAdminStatus;
3178 StorageTmp->traceRouteCtlAdminStatus = *((long *) var_val);
3179 break;
3180
3181
3182 case UNDO:
3183 /*
3184 * Back out any changes made in the ACTION case
3185 */
3186 StorageTmp->traceRouteCtlAdminStatus = tmpvar;
3187 break;
3188
3189
3190 case COMMIT:
3191 /*
3192 * Things are working well, so it's now safe to make the change
3193 * permanently. Make sure that anything done here can't fail!
3194 */
3195
3196 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) StorageTmp->traceRouteCtlOwnerIndex, StorageTmp->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
3197 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) StorageTmp->traceRouteCtlTestName, StorageTmp->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
3198 StorageNew =
3199 header_complex_get(traceRouteResultsTableStorage, vars);
3200
3201 if (StorageTmp->traceRouteCtlAdminStatus == 1
3202 && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3203 if (StorageNew == NULL)
3204 init_trResultsTable(StorageTmp);
3205 else {
3206 StorageTmp->traceRouteResults->
3207 traceRouteResultsOperStatus = 1;
3208 modify_trResultsOper(StorageTmp, 1);
3209 }
3210 if (StorageTmp->traceRouteCtlFrequency != 0)
3211 StorageTmp->timer_id =
3212 snmp_alarm_register(StorageTmp->traceRouteCtlFrequency,
3213 SA_REPEAT, run_traceRoute,
3214 StorageTmp);
3215 else
3216 StorageTmp->timer_id = snmp_alarm_register(1, 0, run_traceRoute,
3217 StorageTmp);
3218
3219 } else if (StorageTmp->traceRouteCtlAdminStatus == 2
3220 && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3221 snmp_alarm_unregister(StorageTmp->timer_id);
3222 if (StorageNew == NULL)
3223 init_trResultsTable(StorageTmp);
3224 else {
3225 StorageTmp->traceRouteResults->
3226 traceRouteResultsOperStatus = 2;
3227 modify_trResultsOper(StorageTmp, 2);
3228 }
3229 }
3230 snmp_store_needed(NULL);
3231 break;
3232 }
3233 return SNMP_ERR_NOERROR;
3234 }
3235
3236
3237
3238
3239 int
3240 write_traceRouteCtlDescr(int action,
3241 u_char * var_val,
3242 u_char var_val_type,
3243 size_t var_val_len,
3244 u_char * statP, oid * name, size_t name_len)
3245 {
3246 static char *tmpvar;
3247 static size_t tmplen;
3248 struct traceRouteCtlTable_data *StorageTmp = NULL;
3249 size_t newlen =
3250 name_len -
3251 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3252
3253
3254 if ((StorageTmp =
3255 header_complex(traceRouteCtlTableStorage, NULL,
3256 &name[sizeof(traceRouteCtlTable_variables_oid) /
3257 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3258 NULL)) == NULL)
3259 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3260
3261 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3262 return SNMP_ERR_NOTWRITABLE;
3263 }
3264
3265 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3266 return SNMP_ERR_NOTWRITABLE;
3267 }
3268
3269 switch (action) {
3270 case RESERVE1:
3271 if (var_val_type != ASN_OCTET_STR) {
3272 snmp_log(LOG_ERR,
3273 "write to traceRouteCtlTargetAddress not ASN_OCTET_STR\n");
3274 return SNMP_ERR_WRONGTYPE;
3275 }
3276 break;
3277
3278
3279 case RESERVE2:
3280 /*
3281 * memory reseveration, final preparation...
3282 */
3283 break;
3284
3285
3286 case FREE:
3287 /*
3288 * Release any resources that have been allocated
3289 */
3290 break;
3291
3292
3293 case ACTION:
3294 /*
3295 * The variable has been stored in long_ret for
3296 * you to use, and you have just been asked to do something with
3297 * it. Note that anything done here must be reversable in the UNDO case
3298 */
3299 tmpvar = StorageTmp->traceRouteCtlDescr;
3300 tmplen = StorageTmp->traceRouteCtlDescrLen;
3301
3302 StorageTmp->traceRouteCtlDescr = (char *) malloc(var_val_len + 1);
3303 if (StorageTmp->traceRouteCtlDescr == NULL) {
3304 exit(1);
3305 }
3306 memcpy(StorageTmp->traceRouteCtlDescr, var_val, var_val_len + 1);
3307 StorageTmp->traceRouteCtlDescr[var_val_len] = '\0';
3308 StorageTmp->traceRouteCtlDescrLen = var_val_len;
3309
3310 break;
3311
3312
3313 case UNDO:
3314 /*
3315 * Back out any changes made in the ACTION case
3316 */
3317 SNMP_FREE(StorageTmp->traceRouteCtlDescr);
3318 StorageTmp->traceRouteCtlDescr = tmpvar;
3319 StorageTmp->traceRouteCtlDescrLen = tmplen;
3320 break;
3321
3322
3323 case COMMIT:
3324 /*
3325 * Things are working well, so it's now safe to make the change
3326 * permanently. Make sure that anything done here can't fail!
3327 */
3328 SNMP_FREE(tmpvar);
3329 snmp_store_needed(NULL);
3330 break;
3331 }
3332 return SNMP_ERR_NOERROR;
3333 }
3334
3335
3336
3337
3338
3339 int
3340 write_traceRouteCtlMaxRows(int action,
3341 u_char * var_val,
3342 u_char var_val_type,
3343 size_t var_val_len,
3344 u_char * statP, oid * name, size_t name_len)
3345 {
3346 static size_t tmpvar;
3347 struct traceRouteCtlTable_data *StorageTmp = NULL;
3348 size_t newlen =
3349 name_len -
3350 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3351
3352 if ((StorageTmp =
3353 header_complex(traceRouteCtlTableStorage, NULL,
3354 &name[sizeof(traceRouteCtlTable_variables_oid) /
3355 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3356 NULL)) == NULL)
3357 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3358
3359 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3360 return SNMP_ERR_NOTWRITABLE;
3361 }
3362
3363 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3364 return SNMP_ERR_NOTWRITABLE;
3365 }
3366 switch (action) {
3367 case RESERVE1:
3368 if (var_val_type != ASN_UNSIGNED) {
3369 snmp_log(LOG_ERR,
3370 "write to traceRouteCtlDSField not ASN_UNSIGNED\n");
3371 return SNMP_ERR_WRONGTYPE;
3372 }
3373 break;
3374
3375
3376 case RESERVE2:
3377 /*
3378 * memory reseveration, final preparation...
3379 */
3380 break;
3381
3382
3383 case FREE:
3384 /*
3385 * Release any resources that have been allocated
3386 */
3387 break;
3388
3389
3390 case ACTION:
3391 /*
3392 * The variable has been stored in objid for
3393 * you to use, and you have just been asked to do something with
3394 * it. Note that anything done here must be reversable in the UNDO case
3395 */
3396 tmpvar = StorageTmp->traceRouteCtlMaxRows;
3397 StorageTmp->traceRouteCtlMaxRows = *((long *) var_val);
3398 break;
3399
3400
3401 case UNDO:
3402 /*
3403 * Back out any changes made in the ACTION case
3404 */
3405 StorageTmp->traceRouteCtlMaxRows = tmpvar;
3406 break;
3407
3408
3409 case COMMIT:
3410 /*
3411 * Things are working well, so it's now safe to make the change
3412 * permanently. Make sure that anything done here can't fail!
3413 */
3414 snmp_store_needed(NULL);
3415 break;
3416 }
3417 return SNMP_ERR_NOERROR;
3418 }
3419
3420 int
3421 write_traceRouteCtlTrapGeneration(int action,
3422 u_char * var_val,
3423 u_char var_val_type,
3424 size_t var_val_len,
3425 u_char * statP, oid * name,
3426 size_t name_len)
3427 {
3428 static char *tmpvar;
3429 static size_t tmplen;
3430 struct traceRouteCtlTable_data *StorageTmp = NULL;
3431 size_t newlen =
3432 name_len -
3433 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3434 if ((StorageTmp =
3435 header_complex(traceRouteCtlTableStorage, NULL,
3436 &name[sizeof(traceRouteCtlTable_variables_oid) /
3437 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3438 NULL)) == NULL)
3439 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3440
3441 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3442 return SNMP_ERR_NOTWRITABLE;
3443 }
3444
3445 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3446 return SNMP_ERR_NOTWRITABLE;
3447 }
3448
3449 switch (action) {
3450 case RESERVE1:
3451 if (var_val_type != ASN_OCTET_STR) {
3452 snmp_log(LOG_ERR,
3453 "write to traceRouteCtlTargetAddress not ASN_OCTET_STR\n");
3454 return SNMP_ERR_WRONGTYPE;
3455 }
3456 break;
3457
3458
3459 case RESERVE2:
3460 /*
3461 * memory reseveration, final preparation...
3462 */
3463 break;
3464
3465
3466 case FREE:
3467 /*
3468 * Release any resources that have been allocated
3469 */
3470 break;
3471
3472
3473 case ACTION:
3474 /*
3475 * The variable has been stored in long_ret for
3476 * you to use, and you have just been asked to do something with
3477 * it. Note that anything done here must be reversable in the UNDO case
3478 */
3479 tmpvar = StorageTmp->traceRouteCtlTrapGeneration;
3480 tmplen = StorageTmp->traceRouteCtlTrapGenerationLen;
3481 StorageTmp->traceRouteCtlTrapGeneration =
3482 (char *) malloc(var_val_len + 1);
3483 if (StorageTmp->traceRouteCtlTrapGeneration == NULL) {
3484 exit(1);
3485 }
3486
3487 memcpy(StorageTmp->traceRouteCtlTrapGeneration, var_val,
3488 var_val_len + 1);
3489 StorageTmp->traceRouteCtlTrapGeneration[var_val_len] = '\0';
3490 StorageTmp->traceRouteCtlTrapGenerationLen = var_val_len;
3491
3492 break;
3493
3494
3495 case UNDO:
3496 /*
3497 * Back out any changes made in the ACTION case
3498 */
3499 SNMP_FREE(StorageTmp->traceRouteCtlTrapGeneration);
3500 StorageTmp->traceRouteCtlTrapGeneration = tmpvar;
3501 StorageTmp->traceRouteCtlTrapGenerationLen = tmplen;
3502 break;
3503
3504
3505 case COMMIT:
3506 /*
3507 * Things are working well, so it's now safe to make the change
3508 * permanently. Make sure that anything done here can't fail!
3509 */
3510 SNMP_FREE(tmpvar);
3511 snmp_store_needed(NULL);
3512 break;
3513 }
3514 return SNMP_ERR_NOERROR;
3515 }
3516
3517 int
3518 write_traceRouteCtlCreateHopsEntries(int action,
3519 u_char * var_val,
3520 u_char var_val_type,
3521 size_t var_val_len,
3522 u_char * statP, oid * name,
3523 size_t name_len)
3524 {
3525 static size_t tmpvar;
3526 struct traceRouteCtlTable_data *StorageTmp = NULL;
3527 size_t newlen =
3528 name_len -
3529 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3530
3531 if ((StorageTmp =
3532 header_complex(traceRouteCtlTableStorage, NULL,
3533 &name[sizeof(traceRouteCtlTable_variables_oid) /
3534 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3535 NULL)) == NULL)
3536 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3537
3538 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3539 return SNMP_ERR_NOTWRITABLE;
3540 }
3541
3542 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3543 return SNMP_ERR_NOTWRITABLE;
3544 }
3545 switch (action) {
3546 case RESERVE1:
3547 if (var_val_type != ASN_INTEGER) {
3548 snmp_log(LOG_ERR,
3549 "write to traceRouteCtlDSField not ASN_INTEGER\n");
3550 return SNMP_ERR_WRONGTYPE;
3551 }
3552 break;
3553
3554
3555 case RESERVE2:
3556 /*
3557 * memory reseveration, final preparation...
3558 */
3559 break;
3560
3561
3562 case FREE:
3563 /*
3564 * Release any resources that have been allocated
3565 */
3566 break;
3567
3568
3569 case ACTION:
3570 /*
3571 * The variable has been stored in objid for
3572 * you to use, and you have just been asked to do something with
3573 * it. Note that anything done here must be reversable in the UNDO case
3574 */
3575 tmpvar = StorageTmp->traceRouteCtlCreateHopsEntries;
3576 StorageTmp->traceRouteCtlCreateHopsEntries = *((long *) var_val);
3577 break;
3578
3579
3580 case UNDO:
3581 /*
3582 * Back out any changes made in the ACTION case
3583 */
3584 StorageTmp->traceRouteCtlCreateHopsEntries = tmpvar;
3585 break;
3586
3587
3588 case COMMIT:
3589 /*
3590 * Things are working well, so it's now safe to make the change
3591 * permanently. Make sure that anything done here can't fail!
3592 */
3593 snmp_store_needed(NULL);
3594 break;
3595 }
3596 return SNMP_ERR_NOERROR;
3597 }
3598
3599 int
3600 write_traceRouteCtlType(int action,
3601 u_char * var_val,
3602 u_char var_val_type,
3603 size_t var_val_len,
3604 u_char * statP, oid * name, size_t name_len)
3605 {
3606 static oid *tmpvar;
3607 static size_t tmplen;
3608 struct traceRouteCtlTable_data *StorageTmp = NULL;
3609 size_t newlen =
3610 name_len -
3611 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3612
3613 if ((StorageTmp =
3614 header_complex(traceRouteCtlTableStorage, NULL,
3615 &name[sizeof(traceRouteCtlTable_variables_oid) /
3616 sizeof(oid) + 3 - 1], &newlen, 1, NULL,
3617 NULL)) == NULL)
3618 return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
3619
3620 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3621 return SNMP_ERR_NOTWRITABLE;
3622 }
3623
3624 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
3625 return SNMP_ERR_NOTWRITABLE;
3626 }
3627
3628 switch (action) {
3629 case RESERVE1:
3630 if (var_val_type != ASN_OBJECT_ID) {
3631 snmp_log(LOG_ERR,
3632 "write to traceRouteCtlType not ASN_OBJECT_ID\n");
3633 return SNMP_ERR_WRONGTYPE;
3634 }
3635 break;
3636
3637
3638 case RESERVE2:
3639 /*
3640 * memory reseveration, final preparation...
3641 */
3642 break;
3643
3644
3645 case FREE:
3646 /*
3647 * Release any resources that have been allocated
3648 */
3649 break;
3650
3651
3652 case ACTION:
3653 /*
3654 * The variable has been stored in long_ret for
3655 * you to use, and you have just been asked to do something with
3656 * it. Note that anything done here must be reversable in the UNDO case
3657 */
3658 tmpvar = StorageTmp->traceRouteCtlType;
3659 tmplen = StorageTmp->traceRouteCtlTypeLen;
3660
3661 StorageTmp->traceRouteCtlType = (oid *) malloc(var_val_len);
3662 if (StorageTmp->traceRouteCtlType == NULL) {
3663 exit(1);
3664 }
3665 memcpy(StorageTmp->traceRouteCtlType, var_val, var_val_len);
3666 StorageTmp->traceRouteCtlTypeLen = var_val_len / sizeof(oid);
3667 break;
3668
3669
3670 case UNDO:
3671 /*
3672 * Back out any changes made in the ACTION case
3673 */
3674 SNMP_FREE(StorageTmp->traceRouteCtlType);
3675 StorageTmp->traceRouteCtlType = tmpvar;
3676 StorageTmp->traceRouteCtlTypeLen = tmplen;
3677 break;
3678
3679
3680 case COMMIT:
3681 /*
3682 * Things are working well, so it's now safe to make the change
3683 * permanently. Make sure that anything done here can't fail!
3684 */
3685 SNMP_FREE(tmpvar);
3686 snmp_store_needed(NULL);
3687 break;
3688 }
3689 return SNMP_ERR_NOERROR;
3690 }
3691
3692 int
3693 write_traceRouteCtlRowStatus(int action,
3694 u_char * var_val,
3695 u_char var_val_type,
3696 size_t var_val_len,
3697 u_char * statP, oid * name, size_t name_len)
3698 {
3699 struct traceRouteCtlTable_data *StorageTmp = NULL;
3700 static struct traceRouteCtlTable_data *StorageNew = NULL;
3701 static struct traceRouteCtlTable_data *StorageDel = NULL;
3702 size_t newlen =
3703 name_len -
3704 (sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) + 3 - 1);
3705 static int old_value;
3706 int set_value;
3707 static netsnmp_variable_list *vars = NULL;
3708 struct header_complex_index *hciptr = NULL;
3709
3710 StorageTmp =
3711 header_complex(traceRouteCtlTableStorage, NULL,
3712 &name[sizeof(traceRouteCtlTable_variables_oid) /
3713 sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
3714
3715 if (var_val_type != ASN_INTEGER || var_val == NULL) {
3716 snmp_log(LOG_ERR,
3717 "write to traceRouteCtlRowStatus not ASN_INTEGER\n");
3718 return SNMP_ERR_WRONGTYPE;
3719 }
3720 if (StorageTmp && StorageTmp->storageType == ST_READONLY) {
3721 return SNMP_ERR_NOTWRITABLE;
3722 }
3723
3724 set_value = *((long *) var_val);
3725
3726
3727 /*
3728 * check legal range, and notReady is reserved for us, not a user
3729 */
3730 if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
3731 return SNMP_ERR_INCONSISTENTVALUE;
3732
3733
3734 switch (action) {
3735 case RESERVE1:
3736 /*
3737 * stage one: test validity
3738 */
3739 if (StorageTmp == NULL) {
3740 /*
3741 * create the row now?
3742 */
3743
3744 /*
3745 * ditch illegal values now
3746 */
3747 if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
3748
3749 return SNMP_ERR_INCONSISTENTVALUE;
3750 }
3751
3752 /*
3753 * destroying a non-existent row is actually legal
3754 */
3755 if (set_value == RS_DESTROY) {
3756
3757 return SNMP_ERR_NOERROR;
3758 }
3759
3760
3761 /*
3762 * illegal creation values
3763 */
3764 if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
3765 return SNMP_ERR_INCONSISTENTVALUE;
3766 }
3767 } else {
3768 /*
3769 * row exists. Check for a valid state change
3770 */
3771 if (set_value == RS_CREATEANDGO
3772 || set_value == RS_CREATEANDWAIT) {
3773 /*
3774 * can't create a row that exists
3775 */
3776
3777 return SNMP_ERR_INCONSISTENTVALUE;
3778 }
3779
3780 /*
3781 * XXX: interaction with row storage type needed
3782 */
3783
3784 if (StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE &&
3785 set_value != RS_DESTROY) {
3786 /*
3787 * "Once made active an entry may not be modified except to
3788 * delete it." XXX: doesn't this in fact apply to ALL
3789 * columns of the table and not just this one?
3790 */
3791
3792 return SNMP_ERR_INCONSISTENTVALUE;
3793 }
3794 if (StorageTmp->storageType != ST_NONVOLATILE) {
3795
3796 return SNMP_ERR_NOTWRITABLE;
3797 }
3798 }
3799
3800 break;
3801
3802
3803
3804
3805 case RESERVE2:
3806 /*
3807 * memory reseveration, final preparation...
3808 */
3809 if (StorageTmp == NULL) {
3810
3811 if (set_value == RS_DESTROY) {
3812 return SNMP_ERR_NOERROR;
3813 }
3814 /*
3815 * creation
3816 */
3817
3818
3819 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* traceRouteCtlOwnerIndex */
3820 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* traceRouteCtlTestName */
3821
3822 if (header_complex_parse_oid
3823 (&
3824 (name
3825 [sizeof(traceRouteCtlTable_variables_oid) / sizeof(oid) +
3826 2]), newlen, vars) != SNMPERR_SUCCESS) {
3827 /*
3828 * XXX: free, zero vars
3829 */
3830 return SNMP_ERR_INCONSISTENTNAME;
3831 }
3832
3833
3834 StorageNew = create_traceRouteCtlTable_data();
3835 if (vars->val_len <= 32) {
3836 StorageNew->traceRouteCtlOwnerIndex =
3837 malloc(vars->val_len + 1);
3838 memcpy(StorageNew->traceRouteCtlOwnerIndex,
3839 vars->val.string, vars->val_len);
3840 StorageNew->traceRouteCtlOwnerIndex[vars->val_len] = '\0';
3841 StorageNew->traceRouteCtlOwnerIndexLen = vars->val_len;
3842 } else {
3843 StorageNew->traceRouteCtlOwnerIndex = malloc(33);
3844 memcpy(StorageNew->traceRouteCtlOwnerIndex,
3845 vars->val.string, 32);
3846 StorageNew->traceRouteCtlOwnerIndex[32] = '\0';
3847 StorageNew->traceRouteCtlOwnerIndexLen = 32;
3848 }
3849
3850 vars = vars->next_variable;
3851
3852 if (vars->val_len <= 32) {
3853 StorageNew->traceRouteCtlTestName =
3854 malloc(vars->val_len + 1);
3855 memcpy(StorageNew->traceRouteCtlTestName, vars->val.string,
3856 vars->val_len);
3857 StorageNew->traceRouteCtlTestName[vars->val_len] = '\0';
3858 StorageNew->traceRouteCtlTestNameLen = vars->val_len;
3859 } else {
3860 StorageNew->traceRouteCtlTestName = malloc(33);
3861 memcpy(StorageNew->traceRouteCtlTestName, vars->val.string,
3862 32);
3863 StorageNew->traceRouteCtlTestName[32] = '\0';
3864 StorageNew->traceRouteCtlTestNameLen = 32;
3865 }
3866 vars = vars->next_variable;
3867
3868 /*
3869 * XXX: fill in default row values here into StorageNew
3870 */
3871
3872 StorageNew->traceRouteCtlRowStatus = set_value;
3873
3874
3875 /*
3876 * XXX: free, zero vars, no longer needed?
3877 */
3878 }
3879 snmp_free_varbind(vars);
3880 vars = NULL;
3881 break;
3882
3883 case FREE:
3884 /*
3885 * XXX: free, zero vars
3886 */
3887 snmp_free_varbind(vars);
3888 vars = NULL;
3889 /*
3890 * Release any resources that have been allocated
3891 */
3892 break;
3893
3894 case ACTION:
3895 /*
3896 * The variable has been stored in set_value for you to
3897 * use, and you have just been asked to do something with
3898 * it. Note that anything done here must be reversable in
3899 * the UNDO case
3900 */
3901
3902 if (StorageTmp == NULL) {
3903 if (set_value == RS_DESTROY) {
3904 return SNMP_ERR_NOERROR;
3905 }
3906 /*
3907 * row creation, so add it
3908 */
3909 if (StorageNew != NULL) {
3910 #if 1
3911 DEBUGMSGTL(("traceRouteCtlTable",
3912 "write_traceRouteCtlRowStatus entering new=%d... \n",
3913 action));
3914 #endif
3915 traceRouteCtlTable_add(StorageNew);
3916 }
3917
3918 /*
3919 * XXX: ack, and if it is NULL?
3920 */
3921 } else if (set_value != RS_DESTROY) {
3922 /*
3923 * set the flag?
3924 */
3925 old_value = StorageTmp->traceRouteCtlRowStatus;
3926 StorageTmp->traceRouteCtlRowStatus = *((long *) var_val);
3927 } else {
3928 /*
3929 * destroy... extract it for now
3930 */
3931
3932 hciptr =
3933 header_complex_find_entry(traceRouteCtlTableStorage,
3934 StorageTmp);
3935 StorageDel =
3936 header_complex_extract_entry(&traceRouteCtlTableStorage,
3937 hciptr);
3938 snmp_alarm_unregister(StorageDel->timer_id);
3939
3940 traceRouteResultsTable_del(StorageTmp);
3941 traceRouteProbeHistoryTable_del(StorageTmp);
3942 traceRouteHopsTable_del(StorageTmp);
3943 }
3944 break;
3945
3946
3947
3948
3949 case UNDO:
3950 /*
3951 * Back out any changes made in the ACTION case
3952 */
3953 if (StorageTmp == NULL) {
3954 if (set_value == RS_DESTROY) {
3955 return SNMP_ERR_NOERROR;
3956 }
3957 /*
3958 * row creation, so remove it again
3959 */
3960 hciptr =
3961 header_complex_find_entry(traceRouteCtlTableStorage,
3962 StorageTmp);
3963 StorageDel =
3964 header_complex_extract_entry(&traceRouteCtlTableStorage,
3965 hciptr);
3966 /*
3967 * XXX: free it
3968 */
3969 } else if (StorageDel != NULL) {
3970 /*
3971 * row deletion, so add it again
3972 */
3973 traceRouteCtlTable_add(StorageDel);
3974 traceRouteResultsTable_add(StorageDel);
3975 traceRouteProbeHistoryTable_addall(StorageDel);
3976 traceRouteHopsTable_addall(StorageDel);
3977 } else {
3978 StorageTmp->traceRouteCtlRowStatus = old_value;
3979 }
3980 break;
3981
3982
3983
3984
3985 case COMMIT:
3986 /*
3987 * Things are working well, so it's now safe to make the change
3988 * permanently. Make sure that anything done here can't fail!
3989 */
3990 if (StorageTmp == NULL) {
3991 if (set_value == RS_DESTROY) {
3992 return SNMP_ERR_NOERROR;
3993 }
3994 }
3995 if (StorageDel != NULL) {
3996 free(StorageDel->traceRouteCtlOwnerIndex);
3997 StorageDel->traceRouteCtlOwnerIndex = NULL;
3998 free(StorageDel->traceRouteCtlTestName);
3999 StorageDel->traceRouteCtlTestName = NULL;
4000 free(StorageDel->traceRouteCtlTargetAddress);
4001 StorageDel->traceRouteCtlTargetAddress = NULL;
4002 free(StorageDel->traceRouteCtlSourceAddress);
4003 StorageDel->traceRouteCtlSourceAddress = NULL;
4004 free(StorageDel->traceRouteCtlMiscOptions);
4005 StorageDel->traceRouteCtlMiscOptions = NULL;
4006 free(StorageDel->traceRouteCtlDescr);
4007 StorageDel->traceRouteCtlDescr = NULL;
4008 free(StorageDel->traceRouteCtlTrapGeneration);
4009 StorageDel->traceRouteCtlTrapGeneration = NULL;
4010 free(StorageDel->traceRouteCtlType);
4011 StorageDel->traceRouteCtlType = NULL;
4012 free(StorageDel);
4013 StorageDel = NULL;
4014
4015 /*
4016 * XXX: free it, its dead
4017 */
4018 } else {
4019 if (StorageTmp
4020 && StorageTmp->traceRouteCtlRowStatus == RS_CREATEANDGO) {
4021 StorageTmp->traceRouteCtlRowStatus = RS_ACTIVE;
4022 } else if (StorageTmp &&
4023 StorageTmp->traceRouteCtlRowStatus ==
4024 RS_CREATEANDWAIT) {
4025
4026 StorageTmp->traceRouteCtlRowStatus = RS_NOTINSERVICE;
4027 }
4028 }
4029 if (StorageTmp && StorageTmp->traceRouteCtlRowStatus == RS_ACTIVE) {
4030 #if 1
4031 DEBUGMSGTL(("traceRouteCtlTable",
4032 "write_traceRouteCtlRowStatus entering runbefore=%ld... \n",
4033 StorageTmp->traceRouteCtlTargetAddressType));
4034
4035 #endif
4036 if (StorageTmp->traceRouteCtlAdminStatus == 1) {
4037 init_trResultsTable(StorageTmp);
4038 if (StorageTmp->traceRouteCtlFrequency != 0)
4039 StorageTmp->timer_id =
4040 snmp_alarm_register(StorageTmp->
4041 traceRouteCtlFrequency,
4042 SA_REPEAT, run_traceRoute,
4043 StorageTmp);
4044 else
4045 StorageTmp->timer_id =
4046 snmp_alarm_register(1, 0, run_traceRoute, StorageTmp);
4047
4048 }
4049
4050 }
4051 snmp_store_needed(NULL);
4052 break;
4053 }
4054 return SNMP_ERR_NOERROR;
4055 }
4056
4057
4058 static void
4059 run_traceRoute_ipv4(struct traceRouteCtlTable_data *item)
4060 {
4061 u_short port = item->traceRouteCtlPort; /* start udp dest port # for probe packets */
4062 int waittime = item->traceRouteCtlTimeOut; /* time to wait for response (in seconds) */
4063 int nprobes = item->traceRouteCtlProbesPerHop;
4064 char *old_HopsAddress[255];
4065 int count = 0;
4066 int flag = 0;
4067
4068 int code, n, k;
4069 const char *cp;
4070 char *err;
4071 u_char *outp;
4072 u_int32_t *ap;
4073 struct sockaddr whereto; /* Who to try to reach */
4074 struct sockaddr wherefrom; /* Who we are */
4075
4076 struct sockaddr_in *from = (struct sockaddr_in *) &wherefrom;
4077 struct sockaddr_in *to = (struct sockaddr_in *) &whereto;
4078 struct hostinfo *hi;
4079 int on = 1;
4080 struct protoent *pe;
4081 int ttl, probe, i;
4082 int seq = 0;
4083 int tos = 0, settos = 0;
4084 int lsrr = 0;
4085 u_short off = 0;
4086 struct ifaddrlist *al;
4087 char errbuf[132];
4088 int minpacket = 0; /* min ip packet size */
4089
4090
4091 struct ip *outip = NULL; /* last output (udp) packet */
4092 struct udphdr *outudp; /* last output (udp) packet */
4093 int packlen = 0; /* total length of packet */
4094 int optlen = 0; /* length of ip options */
4095 int options = 0; /* socket options */
4096 int s = -1; /* receive (icmp) socket file descriptor */
4097 int sndsock = -1; /* send (udp/icmp) socket file descriptor */
4098 int fd[3] = { -1, -1, -1 };
4099
4100 u_short ident;
4101 /*
4102 * loose source route gateway list (including room for final destination)
4103 */
4104 u_int32_t gwlist[NGATEWAYS + 1];
4105 static const char devnull[] = "/dev/null";
4106 char *device = NULL;
4107 char *source = NULL;
4108 char *hostname;
4109 u_int pausemsecs = 0;
4110 u_char packet[512]; /* last inbound (icmp) packet */
4111
4112 int pmtu = 0; /* Path MTU Discovery (RFC1191) */
4113
4114 struct outdata *outdata; /* last output (udp) packet */
4115
4116 minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
4117 minpacket += sizeof(*outudp);
4118 packlen = minpacket; /* minimum sized packet */
4119
4120 hostname = malloc(item->traceRouteCtlTargetAddressLen + 1);
4121 if (hostname == NULL)
4122 goto out;
4123 memcpy(hostname, item->traceRouteCtlTargetAddress,
4124 item->traceRouteCtlTargetAddressLen + 1);
4125 hostname[item->traceRouteCtlTargetAddressLen] = '\0';
4126
4127 hi = gethostinfo(hostname);
4128 setsin(to, hi->addrs[0]);
4129 if (hi->n > 1)
4130 DEBUGMSGTL(("traceRouteCtlTable",
4131 "Warning: %s has multiple addresses; using %s\n",
4132 hostname, inet_ntoa(to->sin_addr)));
4133 free(hostname);
4134 hostname = strdup(hi->name);
4135 freehostinfo(hi);
4136
4137
4138 netsnmp_set_line_buffering(stdout);
4139
4140 outip = (struct ip *) malloc(packlen);
4141 if (outip == NULL) {
4142 DEBUGMSGTL(("traceRouteCtlTable",
4143 "malloc: %s\n", strerror(errno)));
4144 exit(1);
4145 }
4146 memset((char *) outip, 0, packlen);
4147
4148 outip->ip_v = IPVERSION;
4149 if (settos)
4150 outip->ip_tos = tos;
4151 #ifdef BYTESWAP_IP_HDR
4152 outip->ip_len = htons(packlen);
4153 outip->ip_off = htons(off);
4154 #else
4155 outip->ip_len = packlen;
4156 outip->ip_off = off;
4157 #endif
4158 outp = (u_char *) (outip + 1);
4159 #ifdef HAVE_RAW_OPTIONS
4160 if (lsrr > 0) {
4161 u_char *optlist;
4162
4163 optlist = outp;
4164 outp += optlen;
4165
4166 /*
4167 * final hop
4168 */
4169 gwlist[lsrr] = to->sin_addr.s_addr;
4170
4171 outip->ip_dst.s_addr = gwlist[0];
4172
4173 /*
4174 * force 4 byte alignment
4175 */
4176 optlist[0] = IPOPT_NOP;
4177 /*
4178 * loose source route option
4179 */
4180 optlist[1] = IPOPT_LSRR;
4181 i = lsrr * sizeof(gwlist[0]);
4182 optlist[2] = i + 3;
4183 /*
4184 * Pointer to LSRR addresses
4185 */
4186 optlist[3] = IPOPT_MINOFF;
4187 memcpy(optlist + 4, gwlist + 1, i);
4188 } else
4189 #endif
4190 outip->ip_dst = to->sin_addr;
4191 outip->ip_hl = (outp - (u_char *) outip) >> 2;
4192 ident = (getpid() & 0xffff) | 0x8000;
4193
4194 outip->ip_p = IPPROTO_UDP;
4195
4196 outudp = (struct udphdr *) outp;
4197 outudp->source = htons(ident);
4198 outudp->len =
4199 htons((u_short) (packlen - (sizeof(*outip) + optlen)));
4200 outdata = (struct outdata *) (outudp + 1);
4201
4202 cp = "icmp";
4203 if ((pe = getprotobyname(cp)) == NULL) {
4204 DEBUGMSGTL(("traceRouteCtlTable",
4205 "unknown protocol %s\n", cp));
4206 exit(1);
4207 }
4208
4209 /*
4210 * Insure the socket fds won't be 0, 1 or 2
4211 */
4212 if ((fd[0] = open(devnull, O_RDONLY)) < 0 ||
4213 (fd[1] = open(devnull, O_RDONLY)) < 0 ||
4214 (fd[2] = open(devnull, O_RDONLY)) < 0) {
4215 DEBUGMSGTL(("traceRouteCtlTable",
4216 "open \"%s\": %s\n", devnull, strerror(errno)));
4217 exit(1);
4218 }
4219 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0) {
4220 DEBUGMSGTL(("traceRouteCtlTable",
4221 "icmp socket: %s\n", strerror(errno)));
4222 exit(1);
4223 }
4224 if (options & SO_DEBUG)
4225 (void) setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *) &on,
4226 sizeof(on));
4227 if (options & SO_DONTROUTE)
4228 (void) setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *) &on,
4229 sizeof(on));
4230 #ifndef __hpux
4231 printf("raw\n");
4232 sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
4233 #else
4234 printf("udp\n");
4235 sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
4236 #endif
4237 if (sndsock < 0) {
4238 DEBUGMSGTL(("traceRouteCtlTable",
4239 "raw socket: %s\n", strerror(errno)));
4240 exit(1);
4241 }
4242 #if defined(IP_OPTIONS) && !defined(HAVE_RAW_OPTIONS)
4243 if (lsrr > 0) {
4244 u_char optlist[MAX_IPOPTLEN];
4245
4246 cp = "ip";
4247 if ((pe = getprotobyname(cp)) == NULL) {
4248 DEBUGMSGTL(("traceRouteCtlTable",
4249 "unknown protocol %s\n", cp));
4250 exit(1);
4251 }
4252 /*
4253 * final hop
4254 */
4255 gwlist[lsrr] = to->sin_addr.s_addr;
4256 ++lsrr;
4257
4258 /*
4259 * force 4 byte alignment
4260 */
4261 optlist[0] = IPOPT_NOP;
4262 /*
4263 * loose source route option
4264 */
4265 optlist[1] = IPOPT_LSRR;
4266 i = lsrr * sizeof(gwlist[0]);
4267 optlist[2] = i + 3;
4268 /*
4269 * Pointer to LSRR addresses
4270 */
4271 optlist[3] = IPOPT_MINOFF;
4272 memcpy(optlist + 4, gwlist, i);
4273
4274 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
4275 (char *) optlist,
4276 i + sizeof(gwlist[0]))) < 0) {
4277 DEBUGMSGTL(("traceRouteCtlTable", "IP_OPTIONS: %s\n",
4278 strerror(errno)));
4279 exit(1);
4280 }
4281 }
4282 #endif
4283 #ifdef SO_SNDBUF
4284 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *) &packlen,
4285 sizeof(packlen)) < 0) {
4286 DEBUGMSGTL(("traceRouteCtlTable",
4287 "SO_SNDBUF: %s\n", strerror(errno)));
4288 exit(1);
4289 }
4290 #endif
4291 #ifdef IP_HDRINCL
4292 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *) &on,
4293 sizeof(on)) < 0) {
4294 DEBUGMSGTL(("traceRouteCtlTable",
4295 "IP_HDRINCL: %s\n", strerror(errno)));
4296 exit(1);
4297 }
4298 #else
4299 #ifdef IP_TOS
4300 if (settos && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
4301 (char *) &tos, sizeof(tos)) < 0) {
4302 DEBUGMSGTL(("traceRouteCtlTable",
4303 "setsockopt tos %d: %s\n", strerror(errno)));
4304 exit(1);
4305 }
4306 #endif
4307 #endif
4308 if (options & SO_DEBUG)
4309 (void) setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *) &on,
4310 sizeof(on));
4311 if (options & SO_DONTROUTE)
4312 (void) setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
4313 (char *) &on, sizeof(on));
4314 /*
4315 * Get the interface address list
4316 */
4317 n = ifaddrlist(&al, errbuf);
4318 if (n < 0) {
4319 DEBUGMSGTL(("traceRouteCtlTable",
4320 " ifaddrlist: %s\n", errbuf));
4321 exit(1);
4322 }
4323 if (n == 0) {
4324 DEBUGMSGTL(("traceRouteCtlTable",
4325 " Can't find any network interfaces\n"));
4326
4327 exit(1);
4328 }
4329
4330 /*
4331 * Look for a specific device
4332 */
4333 if (device != NULL) {
4334 for (i = n; i > 0; --i, ++al)
4335 if (strcmp(device, al->device) == 0)
4336 break;
4337 if (i <= 0) {
4338 DEBUGMSGTL(("traceRouteCtlTable",
4339 " Can't find interface %.32s\n", device));
4340
4341 exit(1);
4342 }
4343 }
4344 /*
4345 * Determine our source address
4346 */
4347 if (source == NULL) {
4348 /*
4349 * If a device was specified, use the interface address.
4350 * Otherwise, try to determine our source address.
4351 */
4352 if (device != NULL)
4353 setsin(from, al->addr);
4354 else if ((err = findsaddr(to, from)) != NULL) {
4355 DEBUGMSGTL(("traceRouteCtlTable",
4356 " findsaddr: %s\n", err));
4357 free(err);
4358 exit(1);
4359 }
4360
4361 } else {
4362 hi = gethostinfo(source);
4363 source = hi->name;
4364 hi->name = NULL;
4365 /*
4366 * If the device was specified make sure it
4367 * corresponds to the source address specified.
4368 * Otherwise, use the first address (and warn if
4369 * there are more than one).
4370 */
4371 if (device != NULL) {
4372 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
4373 if (*ap == al->addr)
4374 break;
4375 if (i <= 0) {
4376 DEBUGMSGTL(("traceRouteCtlTable",
4377 " %s is not on interface %.32s\n",
4378 source, device));
4379
4380 exit(1);
4381 }
4382 setsin(from, *ap);
4383 } else {
4384 setsin(from, hi->addrs[0]);
4385 if (hi->n > 1)
4386 DEBUGMSGTL(("traceRouteCtlTable",
4387 " Warning: %s has multiple addresses; using %s\n",
4388 source, inet_ntoa(from->sin_addr)));
4389
4390 }
4391 freehostinfo(hi);
4392 }
4393 /*
4394 * Revert to non-privileged user after opening sockets
4395 */
4396 NETSNMP_IGNORE_RESULT(setgid(getgid()));
4397 NETSNMP_IGNORE_RESULT(setuid(getuid()));
4398
4399 outip->ip_src = from->sin_addr;
4400 #ifndef IP_HDRINCL
4401 if (bind(sndsock, (struct sockaddr *) from, sizeof(*from)) < 0) {
4402 DEBUGMSGTL(("traceRouteCtlTable",
4403 " bind: %s\n", strerror(errno)));
4404 exit(1);
4405 }
4406 #endif
4407 DEBUGMSGTL(("traceRouteCtlTable",
4408 " to %s (%s)", hostname, inet_ntoa(to->sin_addr)));
4409
4410 if (source)
4411 DEBUGMSGTL(("traceRouteCtlTable", " from %s", source));
4412
4413 DEBUGMSGTL(("traceRouteCtlTable",
4414 ", %lu hops max, %d byte packets\n",
4415 item->traceRouteCtlMaxTtl, packlen));
4416 (void) fflush(stderr);
4417
4418 {
4419 struct traceRouteResultsTable_data *StorageResults = NULL;
4420 netsnmp_variable_list *vars_results = NULL;
4421
4422 struct traceRouteHopsTable_data *temp = NULL;
4423 struct traceRouteHopsTable_data *current_temp = NULL;
4424 struct traceRouteHopsTable_data *current = NULL;
4425
4426 unsigned long index = 0;
4427
4428 struct traceRouteProbeHistoryTable_data *temp_his = NULL;
4429 struct traceRouteProbeHistoryTable_data *current_temp_his = NULL;
4430
4431 snmp_varlist_add_variable(&vars_results, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
4432 snmp_varlist_add_variable(&vars_results, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
4433 if ((StorageResults =
4434 header_complex_get(traceRouteResultsTableStorage,
4435 vars_results)) == NULL) {
4436 goto out;
4437 }
4438 snmp_free_varbind(vars_results);
4439 vars_results = NULL;
4440
4441
4442 for (ttl = item->traceRouteCtlInitialTtl;
4443 ttl <= item->traceRouteCtlMaxTtl; ++ttl) {
4444
4445 u_int32_t lastaddr = 0;
4446 int gotlastaddr = 0;
4447 int got_there = 0;
4448 int unreachable = 0;
4449 int sentfirst = 0;
4450 time_t timep = 0;
4451
4452 StorageResults->traceRouteResultsCurHopCount = ttl;
4453 if (item->traceRouteCtlCreateHopsEntries == 1) {
4454 if (ttl == item->traceRouteCtlInitialTtl) {
4455 int k = 0;
4456 struct header_complex_index *hciptr2, *nhciptr2;
4457 netsnmp_variable_list *vars = NULL;
4458 oid newoid[MAX_OID_LEN];
4459 size_t newoid_len;
4460
4461 count = traceRouteHopsTable_count(item);
4462
4463 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
4464 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
4465
4466 header_complex_generate_oid(newoid, &newoid_len, NULL,
4467 0, vars);
4468
4469 for (hciptr2 = traceRouteHopsTableStorage; hciptr2;
4470 hciptr2 = nhciptr2) {
4471 nhciptr2 = hciptr2->next;
4472 if (snmp_oid_compare
4473 (newoid, newoid_len, hciptr2->name,
4474 newoid_len) == 0) {
4475 struct traceRouteHopsTable_data *StorageTmp =
4476 header_complex_extract_entry
4477 (&traceRouteHopsTableStorage, hciptr2);
4478
4479 old_HopsAddress[k] =
4480 (char *) malloc(StorageTmp->
4481 traceRouteHopsIpTgtAddressLen
4482 + 1);
4483 if (old_HopsAddress[k] == NULL) {
4484 exit(1);
4485 }
4486 old_HopsAddress[k] = netsnmp_memdup(
4487 StorageTmp->traceRouteHopsIpTgtAddress,
4488 StorageTmp->
4489 traceRouteHopsIpTgtAddressLen + 1);
4490 old_HopsAddress[k][StorageTmp->
4491 traceRouteHopsIpTgtAddressLen]
4492 = '\0';
4493
4494 k++;
4495 }
4496 }
4497 traceRouteHopsTable_del(item);
4498 index = 0;
4499 }
4500
4501 temp = SNMP_MALLOC_STRUCT(traceRouteHopsTable_data);
4502 temp->traceRouteCtlOwnerIndex =
4503 (char *) malloc(item->traceRouteCtlOwnerIndexLen + 1);
4504 memcpy(temp->traceRouteCtlOwnerIndex,
4505 item->traceRouteCtlOwnerIndex,
4506 item->traceRouteCtlOwnerIndexLen + 1);
4507 temp->traceRouteCtlOwnerIndex[item->
4508 traceRouteCtlOwnerIndexLen] =
4509 '\0';
4510 temp->traceRouteCtlOwnerIndexLen =
4511 item->traceRouteCtlOwnerIndexLen;
4512
4513 temp->traceRouteCtlTestName =
4514 (char *) malloc(item->traceRouteCtlTestNameLen + 1);
4515 memcpy(temp->traceRouteCtlTestName,
4516 item->traceRouteCtlTestName,
4517 item->traceRouteCtlTestNameLen + 1);
4518 temp->traceRouteCtlTestName[item->
4519 traceRouteCtlTestNameLen] =
4520 '\0';
4521 temp->traceRouteCtlTestNameLen =
4522 item->traceRouteCtlTestNameLen;
4523
4524 {
4525 /* add lock to protect */
4526 pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
4527 pthread_mutex_lock(&counter_mutex);
4528 temp->traceRouteHopsHopIndex = ++index;
4529 pthread_mutex_unlock(&counter_mutex);
4530 /* endsadsadsad */
4531 }
4532
4533 temp->traceRouteHopsIpTgtAddressType = 0;
4534 temp->traceRouteHopsIpTgtAddress = strdup("");
4535 temp->traceRouteHopsIpTgtAddressLen = 0;
4536 temp->traceRouteHopsMinRtt = 0;
4537 temp->traceRouteHopsMaxRtt = 0;
4538 temp->traceRouteHopsAverageRtt = 0;
4539 temp->traceRouteHopsRttSumOfSquares = 0;
4540 temp->traceRouteHopsSentProbes = 0;
4541 temp->traceRouteHopsProbeResponses = 0;
4542
4543 temp->traceRouteHopsLastGoodProbeLen = 0;
4544 if (index == 1)
4545 item->traceRouteHops = temp;
4546 else {
4547 (current_temp)->next = temp;
4548 }
4549
4550 current_temp = temp;
4551
4552 if (index + 1 >= item->traceRouteCtlMaxTtl) {
4553 current_temp->next = NULL;
4554 }
4555
4556 if (item->traceRouteHops != NULL)
4557
4558 if (traceRouteHopsTable_add(current_temp) !=
4559 SNMPERR_SUCCESS)
4560 DEBUGMSGTL(("traceRouteHopsTable",
4561 "registered an entry error\n"));
4562
4563 }
4564
4565 {
4566 unsigned long maxRtt = 0;
4567 unsigned long minRtt = 0;
4568 unsigned long averageRtt = 0;
4569 unsigned long sumRtt = 0;
4570 unsigned long responseProbe = 0;
4571 unsigned long sumOfSquare = 0;
4572 for (probe = 0; probe < nprobes; ++probe) {
4573 int cc;
4574 struct timeval t1, t2;
4575 struct timezone tz;
4576 struct ip *ip = NULL;
4577 unsigned long Rtt = 0;
4578
4579 if (sentfirst && pausemsecs > 0)
4580 usleep(pausemsecs * 1000);
4581 (void) gettimeofday(&t1, &tz);
4582 send_probe(to, ++seq, ttl, &t1, outip, outudp, packlen,
4583 optlen, hostname, ident, sndsock, port,
4584 outdata);
4585 ++sentfirst;
4586 while ((cc =
4587 wait_for_reply(s, from, &t1, packet,
4588 waittime)) != 0) {
4589 (void) gettimeofday(&t2, &tz);
4590 timep = 0;
4591 time(&timep);
4592 i = packet_ok(packet, cc, from, seq, ident, pmtu,
4593 port);
4594 /*
4595 * Skip short packet
4596 */
4597 if (i == 0)
4598 continue;
4599 if (!gotlastaddr || from->sin_addr.s_addr != lastaddr) {
4600 struct ip *ip;
4601 int hlen;
4602 ip = (struct ip *) packet;
4603 hlen = ip->ip_hl << 2;
4604 cc -= hlen;
4605 DEBUGMSGTL(("traceRouteCtlTable",
4606 " %s", inet_ntoa(from->sin_addr)));
4607
4608
4609 lastaddr = from->sin_addr.s_addr;
4610 ++gotlastaddr;
4611 }
4612 Rtt = deltaT(&t1, &t2);
4613 responseProbe = responseProbe + 1;
4614 if (probe == 0) {
4615 minRtt = Rtt;
4616 maxRtt = Rtt;
4617 averageRtt = Rtt;
4618 sumRtt = Rtt;
4619 sumOfSquare = Rtt * Rtt;
4620 } else {
4621 if (Rtt < minRtt)
4622 minRtt = Rtt;
4623 if (Rtt > maxRtt)
4624 maxRtt = Rtt;
4625 sumRtt = (sumRtt) + Rtt;
4626 averageRtt =
4627 round((double) (sumRtt) /
4628 (double) responseProbe);
4629 sumOfSquare = sumOfSquare + Rtt * Rtt;
4630 }
4631
4632 StorageResults->traceRouteResultsCurProbeCount =
4633 probe + 1;
4634 if (i == -2) {
4635 #ifndef ARCHAIC
4636 ip = (struct ip *) packet;
4637 if (ip->ip_ttl <= 1)
4638 Printf(" !");
4639 #endif
4640 ++got_there;
4641 break;
4642 }
4643 /*
4644 * time exceeded in transit
4645 */
4646 if (i == -1)
4647 break;
4648 code = i - 1;
4649 switch (code) {
4650
4651 case ICMP_UNREACH_PORT:
4652 #ifndef ARCHAIC
4653 ip = (struct ip *) packet;
4654 if (ip->ip_ttl <= 1)
4655 Printf(" !");
4656 #endif
4657 ++got_there;
4658 break;
4659
4660 case ICMP_UNREACH_NET:
4661 ++unreachable;
4662 Printf(" !N");
4663 break;
4664
4665 case ICMP_UNREACH_HOST:
4666 ++unreachable;
4667 Printf(" !H");
4668 break;
4669
4670 case ICMP_UNREACH_PROTOCOL:
4671 ++got_there;
4672 Printf(" !P");
4673 break;
4674
4675 case ICMP_UNREACH_NEEDFRAG:
4676 ++unreachable;
4677 Printf(" !F-%d", pmtu);
4678 break;
4679
4680 case ICMP_UNREACH_SRCFAIL:
4681 ++unreachable;
4682 Printf(" !S");
4683 break;
4684
4685 case ICMP_UNREACH_FILTER_PROHIB:
4686 ++unreachable;
4687 Printf(" !X");
4688 break;
4689
4690 case ICMP_UNREACH_HOST_PRECEDENCE:
4691 ++unreachable;
4692 Printf(" !V");
4693 break;
4694
4695 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
4696 ++unreachable;
4697 Printf(" !C");
4698 break;
4699
4700 default:
4701 ++unreachable;
4702 Printf(" !<%d>", code);
4703 break;
4704 }
4705 break;
4706 }
4707 if (cc == 0) {
4708 timep = 0;
4709 time(&timep);
4710 Printf(" *");
4711 Rtt = (item->traceRouteCtlTimeOut) * 1000;
4712 }
4713 if (item->traceRouteCtlMaxRows != 0) {
4714
4715 temp_his =
4716 SNMP_MALLOC_STRUCT
4717 (traceRouteProbeHistoryTable_data);
4718 temp_his->traceRouteCtlOwnerIndex =
4719 (char *) malloc(item->traceRouteCtlOwnerIndexLen +
4720 1);
4721 memcpy(temp_his->traceRouteCtlOwnerIndex,
4722 item->traceRouteCtlOwnerIndex,
4723 item->traceRouteCtlOwnerIndexLen + 1);
4724 temp_his->traceRouteCtlOwnerIndex[item->
4725 traceRouteCtlOwnerIndexLen]
4726 = '\0';
4727 temp_his->traceRouteCtlOwnerIndexLen =
4728 item->traceRouteCtlOwnerIndexLen;
4729
4730 temp_his->traceRouteCtlTestName =
4731 (char *) malloc(item->traceRouteCtlTestNameLen +
4732 1);
4733 memcpy(temp_his->traceRouteCtlTestName,
4734 item->traceRouteCtlTestName,
4735 item->traceRouteCtlTestNameLen + 1);
4736 temp_his->traceRouteCtlTestName[item->
4737 traceRouteCtlTestNameLen]
4738 = '\0';
4739 temp_his->traceRouteCtlTestNameLen =
4740 item->traceRouteCtlTestNameLen;
4741
4742 {
4743 /* add lock to protect */
4744 pthread_mutex_t counter_mutex =
4745 PTHREAD_MUTEX_INITIALIZER;
4746 pthread_mutex_lock(&counter_mutex);
4747 if (item->traceRouteProbeHistoryMaxIndex >=
4748 (unsigned long) (2147483647))
4749 item->traceRouteProbeHistoryMaxIndex = 0;
4750 temp_his->traceRouteProbeHistoryIndex =
4751 ++(item->traceRouteProbeHistoryMaxIndex);
4752 pthread_mutex_unlock(&counter_mutex);
4753 /* endsadsadsad */
4754 }
4755
4756 temp_his->traceRouteProbeHistoryHopIndex = ttl;
4757 temp_his->traceRouteProbeHistoryProbeIndex = probe + 1;
4758
4759 temp_his->traceRouteProbeHistoryHAddrType = 1;
4760 temp_his->traceRouteProbeHistoryHAddr =
4761 (char *) malloc(strlen(inet_ntoa(from->sin_addr)) +
4762 1);
4763 strcpy(temp_his->traceRouteProbeHistoryHAddr,
4764 (inet_ntoa(from->sin_addr)));
4765 temp_his->
4766 traceRouteProbeHistoryHAddr[strlen
4767 (inet_ntoa
4768 (from->sin_addr))] =
4769 '\0';
4770 temp_his->traceRouteProbeHistoryHAddrLen =
4771 strlen(inet_ntoa(from->sin_addr));
4772
4773 temp_his->traceRouteProbeHistoryResponse = Rtt;
4774 temp_his->traceRouteProbeHistoryStatus = 1;
4775 temp_his->traceRouteProbeHistoryLastRC = 0;
4776
4777 temp_his->traceRouteProbeHistoryTime_time = timep;
4778 temp_his->traceRouteProbeHistoryTime =
4779 netsnmp_memdup(date_n_time(&timep,
4780 &temp_his->traceRouteProbeHistoryTimeLen),
4781 11);
4782 if (probe == 0)
4783 item->traceRouteProbeHis = temp_his;
4784 else {
4785 (current_temp_his)->next = temp_his;
4786 }
4787
4788 current_temp_his = temp_his;
4789
4790 if (probe + 1 >= nprobes) {
4791 current_temp_his->next = NULL;
4792
4793 }
4794
4795 if (item->traceRouteProbeHis != NULL) {
4796 if (traceRouteProbeHistoryTable_count(item) <
4797 item->traceRouteCtlMaxRows) {
4798 if (traceRouteProbeHistoryTable_add
4799 (current_temp_his) != SNMPERR_SUCCESS)
4800 DEBUGMSGTL(("traceRouteProbeHistoryTable",
4801 "registered an entry error\n"));
4802 } else {
4803 traceRouteProbeHistoryTable_delLast(item);
4804 if (traceRouteProbeHistoryTable_add
4805 (current_temp_his) != SNMPERR_SUCCESS)
4806 DEBUGMSGTL(("traceRouteProbeHistoryTable",
4807 "registered an entry error\n"));
4808
4809 }
4810 }
4811
4812 }
4813
4814 if (item->traceRouteCtlCreateHopsEntries == 1) {
4815 netsnmp_variable_list *vars_hops = NULL;
4816 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
4817 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
4818 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_UNSIGNED, (char *) &index, sizeof(index)); /* traceRouteHopsIndex */
4819 if ((current =
4820 header_complex_get(traceRouteHopsTableStorage,
4821 vars_hops)) == NULL) {
4822 goto out;
4823 }
4824 snmp_free_varbind(vars_hops);
4825 vars_hops = NULL;
4826
4827 current->traceRouteHopsIpTgtAddressType = 1;
4828 current->traceRouteHopsIpTgtAddress =
4829 (char *) malloc(strlen(inet_ntoa(from->sin_addr)) +
4830 1);
4831 current->traceRouteHopsIpTgtAddress =
4832 strdup(inet_ntoa(from->sin_addr));
4833 current->
4834 traceRouteHopsIpTgtAddress[strlen
4835 (inet_ntoa
4836 (from->sin_addr))] =
4837 '\0';
4838 current->traceRouteHopsIpTgtAddressLen =
4839 strlen(inet_ntoa(from->sin_addr));
4840 if (count != 0) {
4841 if (strcmp
4842 (old_HopsAddress[index - 1],
4843 current->traceRouteHopsIpTgtAddress) != 0)
4844 flag = 1;
4845 }
4846
4847 current->traceRouteHopsIpTgtAddressLen =
4848 strlen(inet_ntoa(from->sin_addr));
4849 current->traceRouteHopsMinRtt = minRtt;
4850 current->traceRouteHopsMaxRtt = maxRtt;
4851 current->traceRouteHopsAverageRtt = averageRtt;
4852 current->traceRouteHopsRttSumOfSquares = sumOfSquare;
4853 current->traceRouteHopsSentProbes = probe + 1;
4854 current->traceRouteHopsProbeResponses = responseProbe;
4855 current->traceRouteHopsLastGoodProbe_time = timep;
4856 current->traceRouteHopsLastGoodProbe =
4857 netsnmp_memdup(date_n_time(&timep,
4858 &current->traceRouteHopsLastGoodProbeLen),
4859 11);
4860 }
4861
4862 (void) fflush(stdout);
4863 }
4864 }
4865 putchar('\n');
4866
4867
4868 if (got_there
4869 || (unreachable > 0 && unreachable >= nprobes - 1)) {
4870
4871 if (got_there != 0) {
4872 StorageResults->traceRouteResultsTestAttempts =
4873 StorageResults->traceRouteResultsTestAttempts + 1;
4874
4875 StorageResults->traceRouteResultsTestSuccesses =
4876 StorageResults->traceRouteResultsTestSuccesses + 1;
4877
4878 StorageResults->traceRouteResultsLastGoodPath_time = timep;
4879 StorageResults->traceRouteResultsLastGoodPath =
4880 netsnmp_memdup(date_n_time(&timep,
4881 &StorageResults->
4882 traceRouteResultsLastGoodPathLen),
4883 11);
4884 if ((item->
4885 traceRouteCtlTrapGeneration[0] &
4886 TRACEROUTETRAPGENERATION_TESTCOMPLETED) != 0) {
4887 DEBUGMSGTL(("traceRouteProbeHistoryTable",
4888 "TEST completed!\n"));
4889 send_traceRoute_trap(item, traceRouteTestCompleted,
4890 sizeof
4891 (traceRouteTestCompleted) /
4892 sizeof(oid));
4893 }
4894 }
4895
4896 else {
4897 StorageResults->traceRouteResultsTestAttempts =
4898 StorageResults->traceRouteResultsTestAttempts + 1;
4899 if ((item->
4900 traceRouteCtlTrapGeneration[0] &
4901 TRACEROUTETRAPGENERATION_TESTFAILED) != 0) {
4902 DEBUGMSGTL(("traceRouteProbeHistoryTable",
4903 "test Failed!\n"));
4904 send_traceRoute_trap(item, traceRouteTestFailed,
4905 sizeof(traceRouteTestFailed) /
4906 sizeof(oid));
4907 }
4908 }
4909 break;
4910
4911 } else if (ttl == item->traceRouteCtlMaxTtl
4912 && (probe + 1) == nprobes) {
4913 StorageResults->traceRouteResultsTestAttempts =
4914 StorageResults->traceRouteResultsTestAttempts + 1;
4915
4916 if ((item->
4917 traceRouteCtlTrapGeneration[0] &
4918 TRACEROUTETRAPGENERATION_TESTFAILED) != 0) {
4919 DEBUGMSGTL(("traceRouteProbeHistoryTable",
4920 "test Failed!\n"));
4921 send_traceRoute_trap(item, traceRouteTestFailed,
4922 sizeof(traceRouteTestFailed) /
4923 sizeof(oid));
4924 }
4925 }
4926
4927 }
4928
4929 if (flag == 1) {
4930 DEBUGMSGTL(("traceRouteProbeHistoryTable", "path changed!\n"));
4931 send_traceRoute_trap(item, traceRoutePathChange,
4932 sizeof(traceRoutePathChange) /
4933 sizeof(oid));
4934 }
4935
4936 out:
4937 for (k = 0; k < count; k++)
4938 free(old_HopsAddress[k]);
4939 for (k = 0; k < 3; k++)
4940 if (fd[k] >= 0)
4941 close(fd[k]);
4942 if (s >= 0)
4943 close(s);
4944 if (sndsock >= 0)
4945 close(sndsock);
4946 free(outip);
4947 free(hostname);
4948 }
4949 }
4950
4951 static void
4952 run_traceRoute_ipv6(struct traceRouteCtlTable_data *item)
4953 {
4954 int nprobes = item->traceRouteCtlProbesPerHop;
4955 char *old_HopsAddress[255];
4956 int count = 0;
4957 int flag = 0;
4958
4959 int icmp_sock = -1; /* receive (icmp) socket file descriptor */
4960 int sndsock = -1; /* send (udp) socket file descriptor */
4961
4962 struct sockaddr_in6 whereto; /* Who to try to reach */
4963
4964 struct sockaddr_in6 saddr;
4965 struct sockaddr_in6 firsthop;
4966 char *source = NULL;
4967 char *device = NULL;
4968 char *hostname;
4969
4970 pid_t ident = 0;
4971 u_short port = 32768 + 666; /* start udp dest port # for probe packets */
4972 int options = 0; /* socket options */
4973 int waittime = 5; /* time to wait for response (in seconds) */
4974
4975 char *sendbuff = NULL;
4976 int datalen = sizeof(struct pkt_format);
4977
4978 u_char packet[512]; /* last inbound (icmp) packet */
4979
4980 char pa[64];
4981 struct hostent *hp = NULL;
4982 struct sockaddr_in6 from, *to = NULL;
4983 int i = 0, k, on = 0, probe = 0, seq = 0, tos = 0, ttl = 0;
4984 int socket_errno = 0;
4985
4986 icmp_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
4987 socket_errno = errno;
4988
4989 NETSNMP_IGNORE_RESULT(setuid(getuid()));
4990
4991 on = 1;
4992 seq = tos = 0;
4993 to = (struct sockaddr_in6 *) &whereto;
4994
4995 hostname = malloc(item->traceRouteCtlTargetAddressLen + 1);
4996 if (!hostname)
4997 goto out;
4998 memcpy(hostname, item->traceRouteCtlTargetAddress,
4999 item->traceRouteCtlTargetAddressLen + 1);
5000 hostname[item->traceRouteCtlTargetAddressLen] = '\0';
5001
5002 setlinebuf(stdout);
5003
5004 memset(&whereto, '\0', sizeof(struct sockaddr_in6));
5005
5006 to->sin6_family = AF_INET6;
5007 to->sin6_port = htons(port);
5008
5009 if (inet_pton(AF_INET6, hostname, &to->sin6_addr) <= 0) {
5010 hp = gethostbyname2(hostname, AF_INET6);
5011 if (hp != NULL) {
5012 memmove((caddr_t) & to->sin6_addr, hp->h_addr, 16);
5013 free(hostname);
5014 hostname = strdup((char *) hp->h_name);
5015 } else {
5016 fprintf(stderr, "traceroute: unknown host %s\n", hostname);
5017 free(hostname);
5018 hostname = NULL;
5019 goto out;
5020 }
5021 }
5022 firsthop = *to;
5023
5024 datalen = item->traceRouteCtlDataSize;
5025 if (datalen < (int) sizeof(struct pkt_format)
5026 || datalen >= MAXPACKET) {
5027 Fprintf(stderr,
5028 "traceroute: packet size must be %d <= s < %d.\n",
5029 (int) sizeof(struct pkt_format), MAXPACKET);
5030 datalen = 16;
5031 }
5032
5033 ident = getpid();
5034
5035 sendbuff = malloc(datalen);
5036 if (sendbuff == NULL) {
5037 fprintf(stderr, "malloc failed\n");
5038 goto out;
5039 }
5040
5041 if (icmp_sock < 0) {
5042 errno = socket_errno;
5043 perror("traceroute6: icmp socket");
5044 goto out;
5045 }
5046
5047 if (options & SO_DEBUG)
5048 setsockopt(icmp_sock, SOL_SOCKET, SO_DEBUG,
5049 (char *) &on, sizeof(on));
5050 if (options & SO_DONTROUTE)
5051 setsockopt(icmp_sock, SOL_SOCKET, SO_DONTROUTE,
5052 (char *) &on, sizeof(on));
5053
5054 if ((sndsock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
5055 perror("traceroute: UDP socket");
5056 goto out;
5057 }
5058 #ifdef SO_SNDBUF
5059 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *) &datalen,
5060 sizeof(datalen)) < 0) {
5061 perror("traceroute: SO_SNDBUF");
5062 goto out;
5063 }
5064 #endif /* SO_SNDBUF */
5065
5066 if (options & SO_DEBUG)
5067 (void) setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
5068 (char *) &on, sizeof(on));
5069 if (options & SO_DONTROUTE)
5070 (void) setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
5071 (char *) &on, sizeof(on));
5072
5073 if (source == NULL) {
5074 socklen_t alen;
5075 int probe_fd = socket(AF_INET6, SOCK_DGRAM, 0);
5076
5077 if (probe_fd < 0) {
5078 perror("socket");
5079 close(probe_fd);
5080 goto out;
5081 }
5082 if (device) {
5083 if (setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device,
5084 strlen(device) + 1) == -1)
5085 perror("WARNING: interface is ignored");
5086 }
5087 firsthop.sin6_port = htons(1025);
5088 if (connect(probe_fd, (struct sockaddr *) &firsthop,
5089 sizeof(firsthop)) == -1) {
5090 perror("connect");
5091 close(probe_fd);
5092 goto out;
5093 }
5094 alen = sizeof(saddr);
5095 if (getsockname(probe_fd, (struct sockaddr *) &saddr, &alen) == -1) {
5096 perror("getsockname");
5097 close(probe_fd);
5098 goto out;
5099 }
5100 saddr.sin6_port = 0;
5101 close(probe_fd);
5102 } else {
5103 memset(&saddr, '\0', sizeof(struct sockaddr_in6));
5104 saddr.sin6_family = AF_INET6;
5105 if (inet_pton(AF_INET6, source, &saddr.sin6_addr) < 0) {
5106 Printf("traceroute: unknown addr %s\n", source);
5107 goto out;
5108 }
5109 }
5110
5111 if (bind(sndsock, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) {
5112 perror("traceroute: bind sending socket");
5113 goto out;
5114 }
5115 if (bind(icmp_sock, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) {
5116 perror("traceroute: bind icmp6 socket");
5117 goto out;
5118 }
5119
5120 Fprintf(stderr, "traceroute to %s (%s)", hostname,
5121 inet_ntop(AF_INET6, &to->sin6_addr, pa, 64));
5122
5123 Fprintf(stderr, " from %s",
5124 inet_ntop(AF_INET6, &saddr.sin6_addr, pa, 64));
5125 Fprintf(stderr, ", %lu hops max, %d byte packets\n",
5126 item->traceRouteCtlMaxTtl, datalen);
5127 (void) fflush(stderr);
5128
5129 {
5130 struct traceRouteResultsTable_data *StorageResults = NULL;
5131 netsnmp_variable_list *vars_results = NULL;
5132
5133 struct traceRouteHopsTable_data *temp = NULL;
5134 struct traceRouteHopsTable_data *current_temp = NULL;
5135 struct traceRouteHopsTable_data *current = NULL;
5136
5137 unsigned long index = 0;
5138
5139 struct traceRouteProbeHistoryTable_data *temp_his = NULL;
5140 struct traceRouteProbeHistoryTable_data *current_temp_his = NULL;
5141
5142 snmp_varlist_add_variable(&vars_results, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
5143 snmp_varlist_add_variable(&vars_results, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
5144 if ((StorageResults =
5145 header_complex_get(traceRouteResultsTableStorage,
5146 vars_results)) == NULL) {
5147 goto out;
5148 }
5149 snmp_free_varbind(vars_results);
5150 vars_results = NULL;
5151
5152 for (ttl = item->traceRouteCtlInitialTtl;
5153 ttl <= item->traceRouteCtlMaxTtl; ++ttl) {
5154 struct in6_addr lastaddr = { {{0,}} };
5155 int got_there = 0;
5156 int unreachable = 0;
5157 time_t timep = 0;
5158 Printf("%2d ", ttl);
5159
5160
5161 StorageResults->traceRouteResultsCurHopCount = ttl;
5162 if (item->traceRouteCtlCreateHopsEntries == 1) {
5163 if (ttl == item->traceRouteCtlInitialTtl) {
5164 int k = 0;
5165 struct traceRouteHopsTable_data *StorageTmp;
5166 struct header_complex_index *hciptr2, *nhciptr2;
5167 netsnmp_variable_list *vars = NULL;
5168 oid newoid[MAX_OID_LEN];
5169 size_t newoid_len;
5170
5171 count = traceRouteHopsTable_count(item);
5172
5173 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
5174 snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
5175
5176 header_complex_generate_oid(newoid, &newoid_len, NULL,
5177 0, vars);
5178
5179 snmp_free_varbind(vars);
5180 vars = NULL;
5181
5182 for (hciptr2 = traceRouteHopsTableStorage; hciptr2;
5183 hciptr2 = nhciptr2) {
5184 nhciptr2 = hciptr2->next;
5185 if (snmp_oid_compare
5186 (newoid, newoid_len, hciptr2->name,
5187 newoid_len) == 0) {
5188 StorageTmp =
5189 header_complex_extract_entry
5190 (&traceRouteHopsTableStorage, hciptr2);
5191
5192 old_HopsAddress[k] =
5193 (char *) malloc(StorageTmp->
5194 traceRouteHopsIpTgtAddressLen
5195 + 1);
5196 if (old_HopsAddress[k] == NULL) {
5197 exit(1);
5198 }
5199 old_HopsAddress[k] = netsnmp_memdup(
5200 StorageTmp->traceRouteHopsIpTgtAddress,
5201 StorageTmp->
5202 traceRouteHopsIpTgtAddressLen + 1);
5203 old_HopsAddress[k][StorageTmp->
5204 traceRouteHopsIpTgtAddressLen]
5205 = '\0';
5206
5207 k++;
5208 }
5209 }
5210 traceRouteHopsTable_del(item);
5211 index = 0;
5212 }
5213
5214 temp = SNMP_MALLOC_STRUCT(traceRouteHopsTable_data);
5215 temp->traceRouteCtlOwnerIndex =
5216 (char *) malloc(item->traceRouteCtlOwnerIndexLen + 1);
5217 memcpy(temp->traceRouteCtlOwnerIndex,
5218 item->traceRouteCtlOwnerIndex,
5219 item->traceRouteCtlOwnerIndexLen + 1);
5220 temp->traceRouteCtlOwnerIndex[item->
5221 traceRouteCtlOwnerIndexLen] =
5222 '\0';
5223 temp->traceRouteCtlOwnerIndexLen =
5224 item->traceRouteCtlOwnerIndexLen;
5225
5226 temp->traceRouteCtlTestName =
5227 (char *) malloc(item->traceRouteCtlTestNameLen + 1);
5228 memcpy(temp->traceRouteCtlTestName,
5229 item->traceRouteCtlTestName,
5230 item->traceRouteCtlTestNameLen + 1);
5231 temp->traceRouteCtlTestName[item->
5232 traceRouteCtlTestNameLen] =
5233 '\0';
5234 temp->traceRouteCtlTestNameLen =
5235 item->traceRouteCtlTestNameLen;
5236
5237 {
5238 /* add lock to protect */
5239 pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
5240 pthread_mutex_lock(&counter_mutex);
5241 temp->traceRouteHopsHopIndex = ++index;
5242 pthread_mutex_unlock(&counter_mutex);
5243 /* endsadsadsad */
5244 }
5245
5246 temp->traceRouteHopsIpTgtAddressType = 0;
5247 temp->traceRouteHopsIpTgtAddress = strdup("");
5248 temp->traceRouteHopsIpTgtAddressLen = 0;
5249 temp->traceRouteHopsMinRtt = 0;
5250 temp->traceRouteHopsMaxRtt = 0;
5251 temp->traceRouteHopsAverageRtt = 0;
5252 temp->traceRouteHopsRttSumOfSquares = 0;
5253 temp->traceRouteHopsSentProbes = 0;
5254 temp->traceRouteHopsProbeResponses = 0;
5255
5256 temp->traceRouteHopsLastGoodProbeLen = 0;
5257 if (index == 1)
5258 item->traceRouteHops = temp;
5259 else {
5260 (current_temp)->next = temp;
5261 }
5262
5263 current_temp = temp;
5264
5265 if (index >= item->traceRouteCtlMaxTtl) {
5266 current_temp->next = NULL;
5267 }
5268
5269 if (item->traceRouteHops != NULL)
5270
5271 if (traceRouteHopsTable_add(current_temp) !=
5272 SNMPERR_SUCCESS)
5273 DEBUGMSGTL(("traceRouteHopsTable",
5274 "registered an entry error\n"));
5275
5276 }
5277
5278 {
5279 unsigned long maxRtt = 0;
5280 unsigned long minRtt = 0;
5281 unsigned long averageRtt = 0;
5282 unsigned long sumRtt = 0;
5283 unsigned long responseProbe = 0;
5284 unsigned long sumOfSquare = 0;
5285 for (probe = 0; probe < nprobes; ++probe) {
5286 int cc = 0, reset_timer = 0;
5287 struct timeval t1, t2;
5288 struct timezone tz;
5289 unsigned long Rtt = 0;
5290
5291 gettimeofday(&t1, &tz);
5292
5293 send_probe_v6(++seq, ttl, sendbuff, ident, &tz, sndsock,
5294 datalen, &whereto, hostname);
5295 reset_timer = 1;
5296
5297 while ((cc =
5298 wait_for_reply_v6(icmp_sock, &from, reset_timer,
5299 waittime, icmp_sock,
5300 packet)) != 0) {
5301 gettimeofday(&t2, &tz);
5302 timep = 0;
5303 time(&timep);
5304 if ((i =
5305 packet_ok_v6(packet, cc, &from, seq, &t1,
5306 ident))) {
5307 reset_timer = 1;
5308 if (memcmp
5309 (&from.sin6_addr, &lastaddr,
5310 sizeof(struct in6_addr))) {
5311
5312 memcpy(&lastaddr,
5313 &from.sin6_addr,
5314 sizeof(struct in6_addr));
5315 }
5316
5317 Rtt = deltaT(&t1, &t2);
5318 responseProbe = responseProbe + 1;
5319 if (probe == 0) {
5320 minRtt = Rtt;
5321 maxRtt = Rtt;
5322 averageRtt = Rtt;
5323 sumRtt = Rtt;
5324 sumOfSquare = Rtt * Rtt;
5325 } else {
5326 if (Rtt < minRtt)
5327 minRtt = Rtt;
5328 if (Rtt > maxRtt)
5329 maxRtt = Rtt;
5330 sumRtt = (sumRtt) + Rtt;
5331 averageRtt =
5332 round((double) (sumRtt) /
5333 (double) responseProbe);
5334 sumOfSquare = sumOfSquare + Rtt * Rtt;
5335 }
5336
5337 StorageResults->traceRouteResultsCurProbeCount =
5338 probe + 1;
5339
5340
5341 switch (i - 1) {
5342 case ICMP6_DST_UNREACH_NOPORT:
5343 ++got_there;
5344 break;
5345
5346 case ICMP6_DST_UNREACH_NOROUTE:
5347 ++unreachable;
5348 Printf(" !N");
5349 break;
5350 case ICMP6_DST_UNREACH_ADDR:
5351 ++unreachable;
5352 Printf(" !H");
5353 break;
5354
5355 case ICMP6_DST_UNREACH_ADMIN:
5356 ++unreachable;
5357 Printf(" !S");
5358 break;
5359 }
5360 break;
5361 } else
5362 reset_timer = 0;
5363 }
5364 if (cc == 0) {
5365 timep = 0;
5366 time(&timep);
5367 Printf(" *");
5368 Rtt = (item->traceRouteCtlTimeOut) * 1000;
5369 }
5370
5371 if (item->traceRouteCtlMaxRows != 0) {
5372
5373 temp_his =
5374 SNMP_MALLOC_STRUCT
5375 (traceRouteProbeHistoryTable_data);
5376 temp_his->traceRouteCtlOwnerIndex =
5377 (char *) malloc(item->traceRouteCtlOwnerIndexLen +
5378 1);
5379 memcpy(temp_his->traceRouteCtlOwnerIndex,
5380 item->traceRouteCtlOwnerIndex,
5381 item->traceRouteCtlOwnerIndexLen + 1);
5382 temp_his->traceRouteCtlOwnerIndex[item->
5383 traceRouteCtlOwnerIndexLen]
5384 = '\0';
5385 temp_his->traceRouteCtlOwnerIndexLen =
5386 item->traceRouteCtlOwnerIndexLen;
5387
5388 temp_his->traceRouteCtlTestName =
5389 (char *) malloc(item->traceRouteCtlTestNameLen +
5390 1);
5391 memcpy(temp_his->traceRouteCtlTestName,
5392 item->traceRouteCtlTestName,
5393 item->traceRouteCtlTestNameLen + 1);
5394 temp_his->traceRouteCtlTestName[item->
5395 traceRouteCtlTestNameLen]
5396 = '\0';
5397 temp_his->traceRouteCtlTestNameLen =
5398 item->traceRouteCtlTestNameLen;
5399
5400 {
5401 /* add lock to protect */
5402 pthread_mutex_t counter_mutex =
5403 PTHREAD_MUTEX_INITIALIZER;
5404 pthread_mutex_lock(&counter_mutex);
5405 if (item->traceRouteProbeHistoryMaxIndex >=
5406 (unsigned long) (2147483647))
5407 item->traceRouteProbeHistoryMaxIndex = 0;
5408 temp_his->traceRouteProbeHistoryIndex =
5409 ++(item->traceRouteProbeHistoryMaxIndex);
5410 pthread_mutex_unlock(&counter_mutex);
5411 /* endsadsadsad */
5412 }
5413
5414 temp_his->traceRouteProbeHistoryHopIndex = ttl;
5415 temp_his->traceRouteProbeHistoryProbeIndex = probe + 1;
5416
5417 temp_his->traceRouteProbeHistoryHAddrType = 2;
5418 temp_his->traceRouteProbeHistoryHAddr =
5419 (char *)
5420 malloc(strlen
5421 (inet_ntop
5422 (AF_INET6, &from.sin6_addr, pa, 64)) + 1);
5423 temp_his->traceRouteProbeHistoryHAddr =
5424 strdup(inet_ntop
5425 (AF_INET6, &from.sin6_addr, pa, 64));
5426 temp_his->
5427 traceRouteProbeHistoryHAddr[strlen
5428 (inet_ntop
5429 (AF_INET6,
5430 &from.sin6_addr, pa,
5431 64))] = '\0';
5432 temp_his->traceRouteProbeHistoryHAddrLen =
5433 strlen(inet_ntop
5434 (AF_INET6, &from.sin6_addr, pa, 64));
5435
5436 temp_his->traceRouteProbeHistoryResponse = Rtt;
5437 temp_his->traceRouteProbeHistoryStatus = 1;
5438 temp_his->traceRouteProbeHistoryLastRC = 0;
5439
5440 temp_his->traceRouteProbeHistoryTime_time = timep;
5441 temp_his->traceRouteProbeHistoryTime = netsnmp_memdup(
5442 date_n_time(&timep,
5443 &temp_his->traceRouteProbeHistoryTimeLen), 11);
5444
5445 if (probe == 0)
5446 item->traceRouteProbeHis = temp_his;
5447 else {
5448 (current_temp_his)->next = temp_his;
5449 }
5450
5451 current_temp_his = temp_his;
5452
5453 if (probe + 1 >= nprobes) {
5454 current_temp_his->next = NULL;
5455 }
5456
5457 if (item->traceRouteProbeHis != NULL) {
5458 if (traceRouteProbeHistoryTable_count(item) <
5459 item->traceRouteCtlMaxRows) {
5460 if (traceRouteProbeHistoryTable_add
5461 (current_temp_his) != SNMPERR_SUCCESS)
5462 DEBUGMSGTL(("traceRouteProbeHistoryTable",
5463 "registered an entry error\n"));
5464 } else {
5465 traceRouteProbeHistoryTable_delLast(item);
5466 if (traceRouteProbeHistoryTable_add
5467 (current_temp_his) != SNMPERR_SUCCESS)
5468 DEBUGMSGTL(("traceRouteProbeHistoryTable",
5469 "registered an entry error\n"));
5470
5471 }
5472 }
5473
5474 }
5475 if (item->traceRouteCtlCreateHopsEntries == 1) {
5476 netsnmp_variable_list *vars_hops = NULL;
5477 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlOwnerIndex, item->traceRouteCtlOwnerIndexLen); /* traceRouteCtlOwnerIndex */
5478 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_OCTET_STR, (char *) item->traceRouteCtlTestName, item->traceRouteCtlTestNameLen); /* traceRouteCtlTestName */
5479 snmp_varlist_add_variable(&vars_hops, NULL, 0, ASN_UNSIGNED, (char *) &index, sizeof(index)); /* traceRouteHopsIndex */
5480 if ((current =
5481 header_complex_get(traceRouteHopsTableStorage,
5482 vars_hops)) == NULL)
5483 goto out;
5484 current->traceRouteHopsIpTgtAddressType = 2;
5485 current->traceRouteHopsIpTgtAddress =
5486 (char *)
5487 malloc(strlen
5488 (inet_ntop
5489 (AF_INET6, &from.sin6_addr, pa, 64)) + 1);
5490 current->traceRouteHopsIpTgtAddress =
5491 strdup(inet_ntop
5492 (AF_INET6, &from.sin6_addr, pa, 64));
5493 current->
5494 traceRouteHopsIpTgtAddress[strlen
5495 (inet_ntop
5496 (AF_INET6,
5497 &from.sin6_addr, pa,
5498 64))] = '\0';
5499
5500 if (count != 0) {
5501 if (strcmp
5502 (old_HopsAddress[index - 1],
5503 current->traceRouteHopsIpTgtAddress) != 0)
5504 flag = 1;
5505 }
5506
5507 current->traceRouteHopsIpTgtAddressLen =
5508 strlen(inet_ntop
5509 (AF_INET6, &from.sin6_addr, pa, 64));
5510 current->traceRouteHopsMinRtt = minRtt;
5511 current->traceRouteHopsMaxRtt = maxRtt;
5512 current->traceRouteHopsAverageRtt = averageRtt;
5513 current->traceRouteHopsRttSumOfSquares = sumOfSquare;
5514 current->traceRouteHopsSentProbes = probe + 1;
5515 current->traceRouteHopsProbeResponses = responseProbe;
5516 current->traceRouteHopsLastGoodProbe_time = timep;
5517 current->traceRouteHopsLastGoodProbe =
5518 netsnmp_memdup(date_n_time(&timep,
5519 &current->traceRouteHopsLastGoodProbeLen), 11);
5520
5521 snmp_free_varbind(vars_hops);
5522 vars_hops = NULL;
5523 }
5524
5525
5526 (void) fflush(stdout);
5527 }
5528 }
5529 putchar('\n');
5530
5531
5532 if (got_there || unreachable >= nprobes - 1) {
5533
5534
5535 if (got_there != 0) {
5536 StorageResults->traceRouteResultsTestAttempts =
5537 StorageResults->traceRouteResultsTestAttempts + 1;
5538
5539 StorageResults->traceRouteResultsTestSuccesses =
5540 StorageResults->traceRouteResultsTestSuccesses + 1;
5541 StorageResults->traceRouteResultsLastGoodPath_time = timep;
5542 StorageResults->traceRouteResultsLastGoodPath =
5543 netsnmp_memdup(date_n_time(&timep,
5544 &StorageResults->
5545 traceRouteResultsLastGoodPathLen),
5546 11);
5547 if ((item->
5548 traceRouteCtlTrapGeneration[0] &
5549 TRACEROUTETRAPGENERATION_TESTCOMPLETED) != 0) {
5550 printf("TEST completed!\n");
5551 send_traceRoute_trap(item, traceRouteTestCompleted,
5552 sizeof
5553 (traceRouteTestCompleted) /
5554 sizeof(oid));
5555 }
5556 }
5557
5558 else {
5559 StorageResults->traceRouteResultsTestAttempts =
5560 StorageResults->traceRouteResultsTestAttempts + 1;
5561 if ((item->
5562 traceRouteCtlTrapGeneration[0] &
5563 TRACEROUTETRAPGENERATION_TESTFAILED) != 0) {
5564 printf("test Failed!\n");
5565 send_traceRoute_trap(item, traceRouteTestFailed,
5566 sizeof(traceRouteTestFailed) /
5567 sizeof(oid));
5568 }
5569 }
5570 break;
5571
5572 } else if (ttl == item->traceRouteCtlMaxTtl
5573 && (probe + 1) == nprobes) {
5574 StorageResults->traceRouteResultsTestAttempts =
5575 StorageResults->traceRouteResultsTestAttempts + 1;
5576
5577 if ((item->
5578 traceRouteCtlTrapGeneration[0] &
5579 TRACEROUTETRAPGENERATION_TESTFAILED) != 0) {
5580 printf("test Failed!\n");
5581 send_traceRoute_trap(item, traceRouteTestFailed,
5582 sizeof(traceRouteTestFailed) /
5583 sizeof(oid));
5584 }
5585 }
5586
5587 }
5588 }
5589
5590 if (flag == 1) {
5591 printf("path changed!\n");
5592 send_traceRoute_trap(item, traceRoutePathChange,
5593 sizeof(traceRoutePathChange) /
5594 sizeof(oid));
5595 }
5596
5597 out:
5598 for (k = 0; k < count; k++)
5599 free(old_HopsAddress[k]);
5600
5601 free(sendbuff);
5602 if (sndsock >= 0)
5603 close(sndsock);
5604 if (icmp_sock >= 0)
5605 close(icmp_sock);
5606 free(hostname);
5607 }
5608
5609 void
5610 run_traceRoute(unsigned int clientreg, void *clientarg)
5611 {
5612 struct traceRouteCtlTable_data *item = clientarg;
5613
5614 if (item->traceRouteCtlInitialTtl > item->traceRouteCtlMaxTtl) {
5615 DEBUGMSGTL(("traceRouteCtlTable",
5616 "first ttl (%lu) may not be greater than max ttl (%lu)\n",
5617 item->traceRouteCtlInitialTtl,
5618 item->traceRouteCtlMaxTtl));
5619 return;
5620 }
5621
5622 switch (item->traceRouteCtlTargetAddressType) {
5623 case 1:
5624 case 16:
5625 run_traceRoute_ipv4(item);
5626 break;
5627 case 2:
5628 run_traceRoute_ipv6(item);
5629 break;
5630 }
5631 }
5632
5633 int
5634 wait_for_reply(int sock, struct sockaddr_in *fromp,
5635 const struct timeval *tp, u_char * packet,
5636 int waittime)
5637 {
5638 fd_set fds;
5639 struct timeval now, wait;
5640 struct timezone tz;
5641 int cc = 0;
5642 socklen_t fromlen = sizeof(*fromp);
5643
5644 FD_ZERO(&fds);
5645 FD_SET(sock, &fds);
5646 wait.tv_sec = tp->tv_sec + waittime;
5647 wait.tv_usec = tp->tv_usec;
5648 (void) gettimeofday(&now, &tz);
5649 tvsub(&wait, &now);
5650 if (select(sock + 1, &fds, NULL, NULL, &wait) > 0)
5651 cc = recvfrom(sock, (char *) packet, 512, 0,
5652 (struct sockaddr *) fromp, &fromlen);
5653 return (cc);
5654 }
5655
5656
5657 int
5658 wait_for_reply_v6(int sock, struct sockaddr_in6 *from, int reset_timer,
5659 int waittime, int icmp_sock, u_char * packet)
5660 {
5661 fd_set fds;
5662 static struct timeval wait;
5663 int cc = 0;
5664 socklen_t fromlen = sizeof(*from);
5665
5666 FD_ZERO(&fds);
5667 FD_SET(sock, &fds);
5668 if (reset_timer) {
5669 /*
5670 * traceroute could hang if someone else has a ping
5671 * running and our ICMP reply gets dropped but we don't
5672 * realize it because we keep waking up to handle those
5673 * other ICMP packets that keep coming in. To fix this,
5674 * "reset_timer" will only be true if the last packet that
5675 * came in was for us or if this is the first time we're
5676 * waiting for a reply since sending out a probe. Note
5677 * that this takes advantage of the select() feature on
5678 * Linux where the remaining timeout is written to the
5679 * struct timeval area.
5680 */
5681 wait.tv_sec = waittime;
5682 wait.tv_usec = 0;
5683 }
5684
5685 if (select(sock + 1, &fds, (fd_set *) 0, (fd_set *) 0, &wait) > 0) {
5686 cc = recvfrom(icmp_sock, (char *) packet, 512, 0,
5687 (struct sockaddr *) from, &fromlen);
5688 }
5689
5690 return (cc);
5691 }
5692
5693 /*
5694 * send_probe() uses the BSD-ish udpiphdr.
5695 * Define something that looks enough like it to work.
5696 */
5697 struct udpiphdr {
5698 struct iphdr ui_i;
5699 struct udphdr ui_u;
5700 };
5701 #define ui_src ui_i.saddr
5702 #define ui_dst ui_i.daddr
5703 #define ui_pr ui_i.protocol
5704 #define ui_len ui_i.tot_len
5705
5706 void
5707 send_probe(struct sockaddr_in *whereto, int seq, int ttl,
5708 struct timeval *tp, struct ip *outip,
5709 struct udphdr *outudp, int packlen, int optlen,
5710 char *hostname, u_short ident, int sndsock, u_short port,
5711 struct outdata *outdata)
5712 {
5713 int cc = 0;
5714 struct udpiphdr *ui = NULL, *oui = NULL;
5715 struct ip tip;
5716
5717 outip->ip_ttl = ttl;
5718 #ifndef __hpux
5719 outip->ip_id = htons(ident + seq);
5720 #endif
5721
5722 /*
5723 * In most cases, the kernel will recalculate the ip checksum.
5724 * But we must do it anyway so that the udp checksum comes out
5725 * right.
5726 */
5727
5728 outip->ip_sum =
5729 in_checksum((u_short *) outip, sizeof(*outip) + optlen);
5730 if (outip->ip_sum == 0)
5731 outip->ip_sum = 0xffff;
5732
5733
5734 /*
5735 * Payload
5736 */
5737 outdata->seq = seq;
5738 outdata->ttl = ttl;
5739 outdata->tv = *tp;
5740
5741
5742 outudp->dest = htons(port + seq);
5743
5744
5745 /*
5746 * Checksum (we must save and restore ip header)
5747 */
5748 tip = *outip;
5749 ui = (struct udpiphdr *) outip;
5750 oui = (struct udpiphdr *) &tip;
5751 /*
5752 * Easier to zero and put back things that are ok
5753 */
5754 memset((char *) ui, 0, sizeof(ui->ui_i));
5755 ui->ui_src = oui->ui_src;
5756 ui->ui_dst = oui->ui_dst;
5757 ui->ui_pr = oui->ui_pr;
5758 ui->ui_len = outudp->len;
5759 outudp->check = 0;
5760 outudp->check = in_checksum((u_short *) ui, packlen);
5761 if (outudp->check == 0)
5762 outudp->check = 0xffff;
5763 *outip = tip;
5764
5765
5766 /*
5767 * XXX undocumented debugging hack
5768 */
5769
5770
5771 #if !defined(IP_HDRINCL) && defined(IP_TTL)
5772 printf("ttl\n");
5773 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
5774 (char *) &ttl, sizeof(ttl)) < 0) {
5775 Fprintf(stderr, "%s: setsockopt ttl %d: %s\n",
5776 "traceroute", ttl, strerror(errno));
5777 exit(1);
5778 }
5779 #endif
5780
5781 #ifdef __hpux
5782
5783 Printf("whereto=%s\n",
5784 inet_ntoa(((struct sockaddr_in *) whereto)->sin_addr));
5785 cc = sendto(sndsock, (char *) outudp,
5786 packlen - (sizeof(*outip) + optlen), 0, whereto,
5787 sizeof(*whereto));
5788 if (cc > 0)
5789 cc += sizeof(*outip) + optlen;
5790 #else
5791
5792 cc = sendto(sndsock, (char *) outip,
5793 packlen, 0, (void *)whereto, sizeof(*whereto));
5794 #endif
5795 if (cc < 0 || cc != packlen) {
5796 if (cc < 0)
5797 Fprintf(stderr, "%s: sendto: %s\n", "traceroute", strerror(errno));
5798 Printf("%s: wrote %s %d chars, ret=%d\n",
5799 "traceroute", hostname, packlen, cc);
5800 (void) fflush(stdout);
5801 }
5802 }
5803
5804
5805
5806 void
5807 send_probe_v6(int seq, int ttl, char *sendbuff, pid_t ident,
5808 struct timezone *tz, int sndsock, int datalen,
5809 struct sockaddr_in6 *whereto, char *hostname)
5810 {
5811 struct pkt_format *pkt = (struct pkt_format *) sendbuff;
5812 int i = 0;
5813
5814 pkt->ident = htonl(ident);
5815 pkt->seq = htonl(seq);
5816 gettimeofday(&pkt->tv, tz);
5817
5818 i = setsockopt(sndsock, SOL_IPV6, IPV6_UNICAST_HOPS, &ttl,
5819 sizeof(int));
5820 if (i < 0) {
5821 perror("setsockopt");
5822 exit(1);
5823 }
5824
5825 do {
5826 i = sendto(sndsock, sendbuff, datalen, 0,
5827 (struct sockaddr *) whereto,
5828 sizeof(struct sockaddr_in6));
5829 } while (i < 0 && errno == ECONNREFUSED);
5830
5831 if (i < 0 || i != datalen) {
5832 if (i < 0)
5833 perror("sendto");
5834 Printf("traceroute: wrote %s %d chars, ret=%d\n", hostname,
5835 datalen, i);
5836 (void) fflush(stdout);
5837 }
5838 }
5839
5840
5841 unsigned long
5842 deltaT(struct timeval *t1p, struct timeval *t2p)
5843 {
5844 unsigned long dt;
5845
5846 dt = (unsigned long) ((long) (t2p->tv_sec - t1p->tv_sec) * 1000 +
5847 (long) (t2p->tv_usec - t1p->tv_usec) / 1000);
5848 return (dt);
5849 }
5850
5851
5852 int
5853 packet_ok(u_char * buf, int cc, struct sockaddr_in *from,
5854 int seq, u_short ident, int pmtu NETSNMP_ATTRIBUTE_UNUSED,
5855 u_short port)
5856 {
5857 struct icmp *icp = NULL;
5858 u_char type, code;
5859 int hlen = 0;
5860 #ifndef ARCHAIC
5861 struct ip *ip = NULL;
5862
5863 ip = (struct ip *) buf;
5864 hlen = ip->ip_hl << 2;
5865 if (cc < hlen + ICMP_MINLEN) {
5866
5867 return (0);
5868 }
5869 cc -= hlen;
5870 icp = (struct icmp *) (buf + hlen);
5871 #else
5872 icp = (struct icmp *) buf;
5873 #endif
5874 type = icp->icmp_type;
5875 code = icp->icmp_code;
5876 /*
5877 * Path MTU Discovery (RFC1191)
5878 */
5879 #if 0
5880 if (code != ICMP_UNREACH_NEEDFRAG)
5881 pmtu = 0;
5882 else {
5883 #ifdef HAVE_ICMP_NEXTMTU
5884 pmtu = ntohs(icp->icmp_nextmtu);
5885 #else
5886 pmtu = ntohs(((struct my_pmtu *) &icp->icmp_void)->ipm_nextmtu);
5887 #endif
5888 }
5889 #endif
5890 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
5891 type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
5892 struct ip *hip;
5893 struct udphdr *up;
5894
5895 if(cc < offsetof(struct icmp, icmp_ip) + sizeof(icp->icmp_ip)) {
5896 return (0);
5897 }
5898
5899 hip = &icp->icmp_ip;
5900 hlen = hip->ip_hl << 2;
5901 up = (struct udphdr *) ((u_char *) hip + hlen);
5902 /*
5903 * XXX 8 is a magic number
5904 */
5905 if (hlen + 12 <= cc &&
5906 hip->ip_p == IPPROTO_UDP &&
5907 up->source == htons(ident) && up->dest == htons(port + seq))
5908 return (type == ICMP_TIMXCEED ? -1 : code + 1);
5909 }
5910
5911
5912 return (0);
5913 }
5914
5915
5916
5917
5918 int
5919 packet_ok_v6(u_char * buf, int cc, struct sockaddr_in6 *from, int seq,
5920 struct timeval *tv, pid_t ident)
5921 {
5922 struct icmp6_hdr *icp = NULL;
5923 u_char type, code;
5924
5925 if(cc < sizeof(struct icmp6_hdr))
5926 return 0;
5927
5928 icp = (struct icmp6_hdr *) buf;
5929
5930 type = icp->icmp6_type;
5931 code = icp->icmp6_code;
5932
5933 if ((type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT) ||
5934 type == ICMP6_DST_UNREACH) {
5935 struct ip6_hdr *hip = NULL;
5936 struct udphdr *up = NULL;
5937 int nexthdr = 0;
5938
5939 hip = (struct ip6_hdr *) (icp + 1);
5940 up = (struct udphdr *) (hip + 1);
5941 nexthdr = hip->ip6_nxt;
5942
5943 if (nexthdr == 44) {
5944 nexthdr = *(unsigned char *) up;
5945 up++;
5946 }
5947 if (nexthdr == IPPROTO_UDP) {
5948 struct pkt_format *pkt;
5949
5950 pkt = (struct pkt_format *) (up + 1);
5951
5952 if (ntohl(pkt->ident) == ident && ntohl(pkt->seq) == seq) {
5953 *tv = pkt->tv;
5954 return (type == ICMP6_TIME_EXCEEDED ? -1 : code + 1);
5955 }
5956 }
5957
5958 }
5959
5960 return (0);
5961 }
5962
5963
5964 /*
5965 * Checksum routine for Internet Protocol family headers (C Version)
5966 */
5967
5968 u_short
5969 in_checksum(u_short * addr, int len)
5970 {
5971 int nleft = len;
5972 u_short *w = addr;
5973 u_short answer;
5974 int sum = 0;
5975
5976 /*
5977 * Our algorithm is simple, using a 32 bit accumulator (sum),
5978 * we add sequential 16 bit words to it, and at the end, fold
5979 * back all the carry bits from the top 16 bits into the lower
5980 * 16 bits.
5981 */
5982 while (nleft > 1) {
5983 sum += *w++;
5984 nleft -= 2;
5985 }
5986
5987 /*
5988 * mop up an odd byte, if necessary
5989 */
5990 if (nleft == 1)
5991 sum += *(u_char *) w;
5992
5993 /*
5994 * add back carry outs from top 16 bits to low 16 bits
5995 */
5996 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
5997 sum += (sum >> 16); /* add carry */
5998 answer = (u_short)~sum; /* truncate to 16 bits */
5999 return (answer);
6000 }
6001
6002 /*
6003 * Subtract 2 timeval structs: out = out - in.
6004 * Out is assumed to be >= in.
6005 */
6006 void
6007 tvsub(struct timeval *out, struct timeval *in)
6008 {
6009
6010 if ((out->tv_usec -= in->tv_usec) < 0) {
6011 --out->tv_sec;
6012 out->tv_usec += 1000000;
6013 }
6014 out->tv_sec -= in->tv_sec;
6015 }
6016
6017
6018 struct hostinfo *
6019 gethostinfo(char *hostname)
6020 {
6021 int n;
6022 struct hostent *hp = NULL;
6023 struct hostinfo *hi = NULL;
6024 char **p = NULL;
6025 u_int32_t addr, *ap = NULL;
6026
6027 if (strlen(hostname) > 64) {
6028 Fprintf(stderr, "%s: hostname \"%.32s...\" is too long\n",
6029 "traceroute", hostname);
6030 exit(1);
6031 }
6032 hi = calloc(1, sizeof(*hi));
6033 if (hi == NULL) {
6034 Fprintf(stderr, "%s: calloc %s\n", "traceroute", strerror(errno));
6035 exit(1);
6036 }
6037 addr = inet_addr(hostname);
6038 if ((int32_t) addr != -1) {
6039 hi->name = strdup(hostname);
6040 hi->n = 1;
6041 hi->addrs = calloc(1, sizeof(hi->addrs[0]));
6042 if (hi->addrs == NULL) {
6043 Fprintf(stderr, "%s: calloc %s\n", "traceroute", strerror(errno));
6044 exit(1);
6045 }
6046 hi->addrs[0] = addr;
6047 return (hi);
6048 }
6049
6050 hp = netsnmp_gethostbyname(hostname);
6051 if (hp == NULL) {
6052 Fprintf(stderr, "%s: unknown host %s\n", "traceroute", hostname);
6053 printf("hp=NULL\n");
6054 exit(1);
6055 }
6056 if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
6057 Fprintf(stderr, "%s: bad host %s\n", "traceroute", hostname);
6058 exit(1);
6059 }
6060 hi->name = strdup(hp->h_name);
6061 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
6062 continue;
6063 hi->n = n;
6064 hi->addrs = calloc(n, sizeof(hi->addrs[0]));
6065 if (hi->addrs == NULL) {
6066 Fprintf(stderr, "%s: calloc %s\n", "traceroute", strerror(errno));
6067 exit(1);
6068 }
6069 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
6070 memcpy(ap, *p, sizeof(*ap));
6071 return (hi);
6072 }
6073
6074 void
6075 freehostinfo(struct hostinfo *hi)
6076 {
6077 if (hi->name != NULL) {
6078 free(hi->name);
6079 hi->name = NULL;
6080 }
6081 free(hi->addrs);
6082 free(hi);
6083 }
6084
6085 void
6086 setsin(struct sockaddr_in *sin, u_int32_t addr)
6087 {
6088
6089 memset(sin, 0, sizeof(*sin));
6090 #ifdef HAVE_SOCKADDR_SA_LEN
6091 sin->sin_len = sizeof(*sin);
6092 #endif
6093 sin->sin_family = AF_INET;
6094 sin->sin_addr.s_addr = addr;
6095 }
6096
6097
6098 /*
6099 * Return the source address for the given destination address
6100 */
6101 static char *
6102 findsaddr(const struct sockaddr_in *to,
6103 struct sockaddr_in *from)
6104 {
6105 int i, n;
6106 FILE *f;
6107 u_int32_t mask;
6108 u_int32_t dest, tmask;
6109 struct ifaddrlist *al;
6110 char buf[256], tdevice[256], device[256];
6111 char *errbuf = NULL;
6112 static const char route[] = "/proc/net/route";
6113
6114 if ((f = fopen(route, "r")) == NULL) {
6115 if (asprintf(&errbuf, "open %s: %s", route, strerror(errno)) < 0)
6116 snmp_log(LOG_ERR, "error buffer allocation failed\n");
6117 return errbuf;
6118 }
6119
6120 /*
6121 * Find the appropriate interface
6122 */
6123 n = 0;
6124 mask = 0;
6125 device[0] = '\0';
6126 while (fgets(buf, sizeof(buf), f) != NULL) {
6127 ++n;
6128 if (n == 1 && strncmp(buf, "Iface", 5) == 0)
6129 continue;
6130 if ((i = sscanf(buf, "%s %x %*s %*s %*s %*s %*s %x",
6131 tdevice, &dest, &tmask)) != 3) {
6132 fclose(f);
6133 return strdup("junk in buffer");
6134 }
6135 if ((to->sin_addr.s_addr & tmask) == dest &&
6136 (tmask > mask || mask == 0)) {
6137 mask = tmask;
6138 strcpy(device, tdevice);
6139 }
6140 }
6141 fclose(f);
6142
6143 if (device[0] == '\0')
6144 return strdup("Can't find interface");
6145
6146 /*
6147 * Get the interface address list
6148 */
6149 if ((n = ifaddrlist(&al, errbuf)) < 0)
6150 return (errbuf);
6151
6152 if (n == 0)
6153 return strdup("Can't find any network interfaces");
6154
6155 /*
6156 * Find our appropriate source address
6157 */
6158 for (i = n; i > 0; --i, ++al)
6159 if (strcmp(device, al->device) == 0)
6160 break;
6161 if (i <= 0) {
6162 sprintf(errbuf, "Can't find interface \"%.32s\"", device);
6163 return (errbuf);
6164 }
6165
6166 setsin(from, al->addr);
6167 return (NULL);
6168 }
6169
6170 int
6171 ifaddrlist(struct ifaddrlist **ipaddrp, char *errbuf)
6172 {
6173 int fd, nipaddr;
6174 #ifdef HAVE_SOCKADDR_SA_LEN
6175 int n;
6176 #endif
6177 struct ifreq *ifrp, *ifend, *ifnext;
6178 struct sockaddr_in *sin;
6179 struct ifaddrlist *al;
6180 struct ifconf ifc;
6181 struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
6182 #define MAX_IPADDR (sizeof(ibuf) / sizeof(ibuf[0]))
6183 static struct ifaddrlist ifaddrlist[MAX_IPADDR];
6184 char device[sizeof(ifr.ifr_name) + 1];
6185
6186 fd = socket(AF_INET, SOCK_DGRAM, 0);
6187 if (fd < 0) {
6188 (void) sprintf(errbuf, "socket: %s", strerror(errno));
6189 return (-1);
6190 }
6191 ifc.ifc_len = sizeof(ibuf);
6192 ifc.ifc_buf = (caddr_t) ibuf;
6193
6194 if (ioctl(fd, SIOCGIFCONF, (char *) &ifc) < 0 ||
6195 ifc.ifc_len < sizeof(struct ifreq)) {
6196 if (errno == EINVAL)
6197 (void) sprintf(errbuf,
6198 "SIOCGIFCONF: ifreq struct too small (%d bytes)",
6199 (int)sizeof(ibuf));
6200 else
6201 (void) sprintf(errbuf, "SIOCGIFCONF: %s", strerror(errno));
6202 (void) close(fd);
6203 return (-1);
6204 }
6205 ifrp = ibuf;
6206 ifend = (struct ifreq *) ((char *) ibuf + ifc.ifc_len);
6207
6208 al = ifaddrlist;
6209 nipaddr = 0;
6210 for (; ifrp < ifend; ifrp = ifnext) {
6211 #ifdef HAVE_SOCKADDR_SA_LEN
6212 n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
6213 if (n < sizeof(*ifrp))
6214 ifnext = ifrp + 1;
6215 else
6216 ifnext = (struct ifreq *) ((char *) ifrp + n);
6217 if (ifrp->ifr_addr.sa_family != AF_INET)
6218 continue;
6219 #else
6220 ifnext = ifrp + 1;
6221 #endif
6222 /*
6223 * Need a template to preserve address info that is
6224 * used below to locate the next entry. (Otherwise,
6225 * SIOCGIFFLAGS stomps over it because the requests
6226 * are returned in a union.)
6227 */
6228 strlcpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
6229 if (ioctl(fd, SIOCGIFFLAGS, (char *) &ifr) < 0) {
6230 if (errno == ENXIO)
6231 continue;
6232 (void) sprintf(errbuf, "SIOCGIFFLAGS: %.*s: %s",
6233 (int) sizeof(ifr.ifr_name), ifr.ifr_name,
6234 strerror(errno));
6235 (void) close(fd);
6236 return (-1);
6237 }
6238
6239 /*
6240 * Must be up
6241 */
6242 if ((ifr.ifr_flags & IFF_UP) == 0)
6243 continue;
6244
6245 sprintf(device, "%.*s", (int) sizeof(ifr.ifr_name), ifr.ifr_name);
6246 #ifdef sun
6247 /*
6248 * Ignore sun virtual interfaces
6249 */
6250 if (strchr(device, ':') != NULL)
6251 continue;
6252 #endif
6253 if (ioctl(fd, SIOCGIFADDR, (char *) &ifr) < 0) {
6254 (void) sprintf(errbuf, "SIOCGIFADDR: %s: %s",
6255 device, strerror(errno));
6256 (void) close(fd);
6257 return (-1);
6258 }
6259
6260 if (nipaddr >= MAX_IPADDR) {
6261 (void) sprintf(errbuf, "Too many interfaces (%d)", nipaddr);
6262 (void) close(fd);
6263 return (-1);
6264 }
6265 sin = (struct sockaddr_in *) &ifr.ifr_addr;
6266 al->addr = sin->sin_addr.s_addr;
6267 al->device = strdup(device);
6268 ++al;
6269 ++nipaddr;
6270 }
6271 (void) close(fd);
6272
6273 *ipaddrp = ifaddrlist;
6274 return (nipaddr);
6275 }