snmp_pdu.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /*
10  * SNMP PDU Encoding
11  *
12  * Complies with:
13  *
14  * RFC 1902: Structure of Management Information for SNMPv2
15  *
16  */
17 
18 /**********************************************************************
19  *
20  * Copyright 1997 by Carnegie Mellon University
21  *
22  * All Rights Reserved
23  *
24  * Permission to use, copy, modify, and distribute this software and its
25  * documentation for any purpose and without fee is hereby granted,
26  * provided that the above copyright notice appear in all copies and that
27  * both that copyright notice and this permission notice appear in
28  * supporting documentation, and that the name of CMU not be
29  * used in advertising or publicity pertaining to distribution of the
30  * software without specific, written prior permission.
31  *
32  * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
33  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
34  * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
35  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
36  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
37  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
38  * SOFTWARE.
39  *
40  * Author: Ryan Troll <ryan+@andrew.cmu.edu>
41  *
42  **********************************************************************/
43 
44 #include "squid.h"
45 
46 #if HAVE_UNISTD_H
47 #include <unistd.h>
48 #endif
49 #if HAVE_STDLIB_H
50 #include <stdlib.h>
51 #endif
52 #if HAVE_SYS_TYPES_H
53 #include <sys/types.h>
54 #endif
55 #if HAVE_CTYPE_H
56 #include <ctype.h>
57 #endif
58 #if HAVE_GNUMALLOC_H
59 #include <gnumalloc.h>
60 #elif HAVE_MALLOC_H
61 #include <malloc.h>
62 #endif
63 #if HAVE_MEMORY_H
64 #include <memory.h>
65 #endif
66 #if HAVE_STRING_H
67 #include <string.h>
68 #endif
69 #if HAVE_STRINGS_H
70 #include <strings.h>
71 #endif
72 #if HAVE_BSTRING_H
73 #include <bstring.h>
74 #endif
75 #if HAVE_SYS_SOCKET_H
76 #include <sys/socket.h>
77 #endif
78 #if HAVE_NETINET_IN_H
79 #include <netinet/in.h>
80 #endif
81 #if HAVE_ARPA_INET_H
82 #include <arpa/inet.h>
83 #endif
84 #if HAVE_SYS_TIME_H
85 #include <sys/time.h>
86 #endif
87 #if HAVE_NETDB_H
88 #include <netdb.h>
89 #endif
90 
91 #include "asn1.h"
92 #include "snmp.h"
93 #include "snmp_api_error.h"
94 #include "snmp_error.h"
95 #include "snmp_msg.h"
96 #include "snmp_pdu.h"
97 #include "snmp_vars.h"
98 
99 #include "util.h"
100 
101 /* #define DEBUG_PDU 1 */
102 /* #define DEBUG_PDU_DECODE 1 */
103 /* #define DEBUG_PDU_ENCODE 1 */
104 
105 #define ASN_PARSE_ERROR(x) { return(x); }
106 
107 /**********************************************************************/
108 
109 /* Create a PDU.
110  */
111 
112 struct snmp_pdu *
114  struct snmp_pdu *pdu;
115 
116 #if DEBUG_PDU
117  snmplib_debug(8, "PDU: Creating\n");
118 #endif
119 
120  pdu = (struct snmp_pdu *) xmalloc(sizeof(struct snmp_pdu));
121  if (pdu == NULL) {
123  return (NULL);
124  }
125  memset((char *) pdu, '\0', sizeof(struct snmp_pdu));
126 
127  pdu->command = command;
130  pdu->address.sin_addr.s_addr = SNMP_DEFAULT_ADDRESS;
131  pdu->enterprise = NULL;
132  pdu->enterprise_length = 0;
133  pdu->variables = NULL;
134 
135 #if DEBUG_PDU
136  snmplib_debug(8, "PDU: Created %x\n", (unsigned int) pdu);
137 #endif
138 
139  return (pdu);
140 }
141 
142 /**********************************************************************/
143 
144 /* Clone an existing PDU.
145  */
146 struct snmp_pdu *
147 snmp_pdu_clone(struct snmp_pdu *Src) {
148  struct snmp_pdu *Dest;
149 
150 #if DEBUG_PDU
151  snmplib_debug(8, "PDU %x: Cloning\n", (unsigned int) Src);
152 #endif
153 
154  Dest = (struct snmp_pdu *) xmalloc(sizeof(struct snmp_pdu));
155  if (Dest == NULL) {
157  return (NULL);
158  }
159  memcpy((char *) Dest, (char *) Src, sizeof(struct snmp_pdu));
160 
161 #if DEBUG_PDU
162  snmplib_debug(8, "PDU %x: Created %x\n", (unsigned int) Src, (unsigned int) Dest);
163 #endif
164  return (Dest);
165 }
166 
167 /**********************************************************************/
168 
169 /*
170  * If there was an error in the input pdu, creates a clone of the pdu
171  * that includes all the variables except the one marked by the errindex.
172  * The command is set to the input command and the reqid, errstat, and
173  * errindex are set to default values.
174  * If the error status didn't indicate an error, the error index didn't
175  * indicate a variable, the pdu wasn't a get response message, or there
176  * would be no remaining variables, this function will return NULL.
177  * If everything was successful, a pointer to the fixed cloned pdu will
178  * be returned.
179  */
180 struct snmp_pdu *
181 snmp_pdu_fix(struct snmp_pdu *pdu, int command) {
182  return (snmp_fix_pdu(pdu, command));
183 }
184 
185 struct snmp_pdu *
186 snmp_fix_pdu(struct snmp_pdu *pdu, int command) {
187  struct variable_list *var, *newvar;
188  struct snmp_pdu *newpdu;
189  int i;
190  int copied = 0;
191 
192 #if DEBUG_PDU
193  snmplib_debug(8, "PDU %x: Fixing. Err index is %d\n",
194  (unsigned int) pdu, (unsigned int) pdu->errindex);
195 #endif
196 
197  if (pdu->command != SNMP_PDU_RESPONSE ||
198  pdu->errstat == SNMP_ERR_NOERROR ||
199  pdu->errindex <= 0) {
201  return (NULL);
202  }
203  /* clone the pdu */
204  newpdu = snmp_pdu_clone(pdu);
205  if (newpdu == NULL)
206  return (NULL);
207 
208  newpdu->variables = 0;
209  newpdu->command = command;
210  newpdu->reqid = SNMP_DEFAULT_REQID;
211  newpdu->errstat = SNMP_DEFAULT_ERRSTAT;
213 
214  /* Loop through the variables, removing whatever isn't necessary */
215 
216  var = pdu->variables;
217  i = 1;
218 
219  /* skip first variable if necessary */
220  if (pdu->errindex == i) {
221  var = var->next_variable;
222  i++;
223  }
224  if (var != NULL) {
225 
226  /* VAR is the first uncopied variable */
227 
228  /* Clone this variable */
229  newpdu->variables = snmp_var_clone(var);
230  if (newpdu->variables == NULL) {
231  snmp_pdu_free(newpdu);
232  return (NULL);
233  }
234  copied++;
235 
236  newvar = newpdu->variables;
237 
238  /* VAR has been copied to NEWVAR. */
239  while (var->next_variable) {
240 
241  /* Skip the item that was bad */
242  if (++i == pdu->errindex) {
243  var = var->next_variable;
244  continue;
245  }
246  /* Copy this var */
248  if (newvar->next_variable == NULL) {
249  snmp_pdu_free(newpdu);
250  return (NULL);
251  }
252  /* Move to the next one */
253  newvar = newvar->next_variable;
254  var = var->next_variable;
255  copied++;
256  }
257  newvar->next_variable = NULL;
258  }
259  /* If we didn't copy anything, free the new pdu. */
260  if (i < pdu->errindex || copied == 0) {
261  snmp_free_pdu(newpdu);
263  return (NULL);
264  }
265 #if DEBUG_PDU
266  snmplib_debug(8, "PDU %x: Fixed PDU is %x\n",
267  (unsigned int) pdu, (unsigned int) newpdu);
268 #endif
269  return (newpdu);
270 }
271 
272 /**********************************************************************/
273 
274 void
276 {
277  snmp_free_pdu(pdu);
278 }
279 
280 /*
281  * Frees the pdu and any xmalloc'd data associated with it.
282  */
283 void
285 {
286  struct variable_list *vp, *ovp;
287 
288  vp = pdu->variables;
289  while (vp) {
290  ovp = vp;
291  vp = vp->next_variable;
292  snmp_var_free(ovp);
293  }
294 
295  if (pdu->enterprise)
296  xfree((char *) pdu->enterprise);
297  xfree((char *) pdu);
298 }
299 
300 /**********************************************************************/
301 
302 /* Encode this PDU into DestBuf.
303  *
304  * Returns a pointer to the next byte in the buffer (where the Variable
305  * Bindings belong.)
306  */
307 
308 /*
309  * RFC 1902: Structure of Management Information for SNMPv2
310  *
311  * PDU ::=
312  * SEQUENCE {
313  * request-id INTEGER32
314  * error-status INTEGER
315  * error-index INTEGER
316  * Variable Bindings
317  * }
318  *
319  * BulkPDU ::=
320  * SEQUENCE {
321  * request-id INTEGER32
322  * non-repeaters INTEGER
323  * max-repetitions INTEGER
324  * Variable Bindings
325  * }
326  */
327 
328 /*
329  * RFC 1157: A Simple Network Management Protocol (SNMP)
330  *
331  * PDU ::=
332  * SEQUENCE {
333  * request-id INTEGER
334  * error-status INTEGER
335  * error-index INTEGER
336  * Variable Bindings
337  * }
338  *
339  * TrapPDU ::=
340  * SEQUENCE {
341  * enterprise NetworkAddress
342  * generic-trap INTEGER
343  * specific-trap INTEGER
344  * time-stamp TIMETICKS
345  * Variable Bindings
346  * }
347  */
348 
349 u_char *
350 snmp_pdu_encode(u_char * DestBuf, int *DestBufLen,
351  struct snmp_pdu *PDU)
352 {
353  u_char *bufp;
354 
355 #if DEBUG_PDU_ENCODE
356  snmplib_debug(8, "PDU: Encoding %d\n", PDU->command);
357 #endif
358 
359  /* ASN.1 Header */
360  switch (PDU->command) {
361 
362  /**********************************************************************/
363 #if TRP_REQ_MSG
364  case TRP_REQ_MSG:
365 
366  /* SNMPv1 Trap */
367 
368  /* enterprise */
369  bufp = asn_build_objid(DestBuf, DestBufLen,
371  (oid *) PDU->enterprise, PDU->enterprise_length);
372  if (bufp == NULL)
373  return (NULL);
374 
375  /* agent-addr */
376  bufp = asn_build_string(bufp, DestBufLen,
377  (u_char) (SMI_IPADDRESS | ASN_PRIMITIVE),
378  (u_char *) & PDU->agent_addr.sin_addr.s_addr,
379  sizeof(PDU->agent_addr.sin_addr.s_addr));
380  if (bufp == NULL)
381  return (NULL);
382 
383  /* generic trap */
384  bufp = asn_build_int(bufp, DestBufLen,
385  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
386  (int *) &PDU->trap_type, sizeof(PDU->trap_type));
387  if (bufp == NULL)
388  return (NULL);
389 
390  /* specific trap */
391  bufp = asn_build_int(bufp, DestBufLen,
392  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
393  (int *) &PDU->specific_type,
394  sizeof(PDU->specific_type));
395  if (bufp == NULL)
396  return (NULL);
397 
398  /* timestamp */
399  bufp = asn_build_unsigned_int(bufp, DestBufLen,
400  (u_char) (SMI_TIMETICKS | ASN_PRIMITIVE),
401  &PDU->time, sizeof(PDU->time));
402  if (bufp == NULL)
403  return (NULL);
404  break;
405 #endif
406 
407  /**********************************************************************/
408 
409  case SNMP_PDU_GETBULK:
410 
411  /* SNMPv2 Bulk Request */
412 
413  /* request id */
414  bufp = asn_build_int(DestBuf, DestBufLen,
415  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
416  &PDU->reqid, sizeof(PDU->reqid));
417  if (bufp == NULL)
418  return (NULL);
419 
420  /* non-repeaters */
421  bufp = asn_build_int(bufp, DestBufLen,
422  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
423  &PDU->non_repeaters,
424  sizeof(PDU->non_repeaters));
425  if (bufp == NULL)
426  return (NULL);
427 
428  /* max-repetitions */
429  bufp = asn_build_int(bufp, DestBufLen,
430  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
431  &PDU->max_repetitions,
432  sizeof(PDU->max_repetitions));
433  if (bufp == NULL)
434  return (NULL);
435  break;
436 
437  /**********************************************************************/
438 
439  default:
440 
441  /* Normal PDU Encoding */
442 
443  /* request id */
444 #if DEBUG_PDU_ENCODE
445  snmplib_debug(8, "PDU: Request ID %d (0x%x)\n", PDU->reqid, DestBuf);
446 #endif
447  bufp = asn_build_int(DestBuf, DestBufLen,
448  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
449  &PDU->reqid, sizeof(PDU->reqid));
450  if (bufp == NULL)
451  return (NULL);
452 
453  /* error status */
454 #if DEBUG_PDU_ENCODE
455  snmplib_debug(8, "PDU: Error Status %d (0x%x)\n", PDU->errstat, bufp);
456 #endif
457  bufp = asn_build_int(bufp, DestBufLen,
458  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
459  &PDU->errstat, sizeof(PDU->errstat));
460  if (bufp == NULL)
461  return (NULL);
462 
463  /* error index */
464 #if DEBUG_PDU_ENCODE
465  snmplib_debug(8, "PDU: Error index %d (0x%x)\n", PDU->errindex, bufp);
466 #endif
467  bufp = asn_build_int(bufp, DestBufLen,
468  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
469  &PDU->errindex, sizeof(PDU->errindex));
470  if (bufp == NULL)
471  return (NULL);
472  break;
473  } /* End of encoding */
474 
475  return (bufp);
476 }
477 
478 /**********************************************************************/
479 
480 /* Decodes PDU from Packet into PDU.
481  *
482  * Returns a pointer to the next byte of the packet, which is where the
483  * Variable Bindings start.
484  */
485 u_char *
486 snmp_pdu_decode(u_char * Packet, /* data */
487  int *Length, /* &length */
488  struct snmp_pdu * PDU)
489 { /* pdu */
490  u_char *bufp;
491  u_char PDUType;
492  u_char ASNType;
493 #if UNUSED_CODE
494  int four;
496 #endif
497 
498  bufp = asn_parse_header(Packet, Length, &PDUType);
499  if (bufp == NULL)
501 
502 #if DEBUG_PDU_DECODE
503  snmplib_debug(8, "PDU Type: %d\n", PDUType);
504 #endif
505 
506  PDU->command = PDUType;
507  switch (PDUType) {
508 
509 #if TRP_REQ_MSG
510  case TRP_REQ_MSG:
511 
512  /* SNMPv1 Trap Message */
513 
514  /* enterprise */
516  bufp = asn_parse_objid(bufp, Length,
517  &ASNType, objid, &PDU->enterprise_length);
518  if (bufp == NULL)
520 
521  PDU->enterprise = (oid *) xmalloc(PDU->enterprise_length * sizeof(oid));
522  if (PDU->enterprise == NULL) {
524  return (NULL);
525  }
526  memcpy((char *) PDU->enterprise, (char *) objid,
527  PDU->enterprise_length * sizeof(oid));
528 
529  /* Agent-addr */
530  four = 4;
531  bufp = asn_parse_string(bufp, Length,
532  &ASNType,
533  (u_char *) & PDU->agent_addr.sin_addr.s_addr,
534  &four);
535  if (bufp == NULL)
537 
538  /* Generic trap */
539  bufp = asn_parse_int(bufp, Length,
540  &ASNType,
541  (int *) &PDU->trap_type,
542  sizeof(PDU->trap_type));
543  if (bufp == NULL)
545 
546  /* Specific Trap */
547  bufp = asn_parse_int(bufp, Length,
548  &ASNType,
549  (int *) &PDU->specific_type,
550  sizeof(PDU->specific_type));
551  if (bufp == NULL)
553 
554  /* Timestamp */
555  bufp = asn_parse_unsigned_int(bufp, Length,
556  &ASNType,
557  &PDU->time, sizeof(PDU->time));
558  if (bufp == NULL)
560  break;
561 #endif
562 
563  /**********************************************************************/
564 
565  case SNMP_PDU_GETBULK:
566 
567  /* SNMPv2 Bulk Request */
568 
569  /* request id */
570  bufp = asn_parse_int(bufp, Length,
571  &ASNType,
572  &PDU->reqid, sizeof(PDU->reqid));
573  if (bufp == NULL)
575 
576  /* non-repeaters */
577  bufp = asn_parse_int(bufp, Length,
578  &ASNType,
579  &PDU->non_repeaters, sizeof(PDU->non_repeaters));
580  if (bufp == NULL)
582 
583  /* max-repetitions */
584  bufp = asn_parse_int(bufp, Length,
585  &ASNType,
586  &PDU->max_repetitions, sizeof(PDU->max_repetitions));
587  if (bufp == NULL)
589  break;
590 
591  /**********************************************************************/
592 
593  default:
594 
595  /* Normal PDU Encoding */
596 
597  /* request id */
598  bufp = asn_parse_int(bufp, Length,
599  &ASNType,
600  &PDU->reqid, sizeof(PDU->reqid));
601  if (bufp == NULL)
603 
604 #if DEBUG_PDU_DECODE
605  snmplib_debug(8, "PDU Request ID: %d\n", PDU->reqid);
606 #endif
607 
608  /* error status */
609  bufp = asn_parse_int(bufp, Length,
610  &ASNType,
611  &PDU->errstat, sizeof(PDU->errstat));
612  if (bufp == NULL)
614 
615 #if DEBUG_PDU_DECODE
616  snmplib_debug(8, "PDU Error Status: %d\n", PDU->errstat);
617 #endif
618 
619  /* error index */
620  bufp = asn_parse_int(bufp, Length,
621  &ASNType,
622  &PDU->errindex, sizeof(PDU->errindex));
623  if (bufp == NULL)
625 
626 #if DEBUG_PDU_DECODE
627  snmplib_debug(8, "PDU Error Index: %d\n", PDU->errindex);
628 #endif
629 
630  break;
631  }
632 
633  return (bufp);
634 }
635 
636 /*
637  * Add a null variable with the requested name to the end of the list of
638  * variables for this pdu.
639  */
640 void
642 {
643  struct variable_list *vars;
644  struct variable_list *ptr;
645 
646  vars = snmp_var_new(name, name_length);
647  if (vars == NULL) {
648  perror("snmp_add_null_var:xmalloc");
649  return;
650  }
651  if (pdu->variables == NULL) {
652  pdu->variables = vars;
653  } else {
654 
655  /* Insert at the end */
656  for (ptr = pdu->variables;
657  ptr->next_variable;
658  ptr = ptr->next_variable)
659  /*EXIT */ ;
660  ptr->next_variable = vars;
661  }
662 
663  return;
664 }
665 
int specific_type
Definition: snmp_pdu.h:69
#define ASN_PRIMITIVE
Definition: asn1.h:65
oid * objid
Definition: snmp_vars.h:52
#define SMI_IPADDRESS
Definition: snmp_vars.h:75
u_char * asn_build_int(u_char *, int *, u_char, int *, int)
Definition: asn1.c:245
SQUIDCEXTERN void snmplib_debug(int, const char *,...) PRINTF_FORMAT_ARG2
Definition: snmplib_debug.c:21
void snmp_set_api_error(int)
#define SNMPERR_UNABLE_TO_FIX
struct variable_list * snmp_var_new(oid *, int)
Definition: snmp_vars.c:112
u_char * snmp_pdu_decode(u_char *Packet, int *Length, struct snmp_pdu *PDU)
Definition: snmp_pdu.c:486
u_char * snmp_pdu_encode(u_char *DestBuf, int *DestBufLen, struct snmp_pdu *PDU)
Definition: snmp_pdu.c:350
oid * enterprise
Definition: snmp_pdu.h:65
int i
Definition: membanger.c:49
u_char * asn_parse_string(u_char *, int *, u_char *, u_char *, int *)
Definition: asn1.c:387
int name_length
Definition: snmp_vars.h:47
void snmp_pdu_free(struct snmp_pdu *pdu)
Definition: snmp_pdu.c:275
u_char * asn_build_objid(u_char *, int *, u_char, oid *, int)
Definition: asn1.c:759
u_int time
Definition: snmp_pdu.h:70
#define SNMP_DEFAULT_ERRINDEX
Definition: snmp_pdu.h:107
#define SNMP_PDU_RESPONSE
Definition: snmp_pdu.h:94
struct variable_list * variables
Definition: snmp_pdu.h:62
u_char * asn_parse_objid(u_char *, int *, u_char *, oid *, int *)
Definition: asn1.c:674
struct snmp_pdu * snmp_fix_pdu(struct snmp_pdu *pdu, int command)
Definition: snmp_pdu.c:186
struct snmp_pdu * snmp_pdu_clone(struct snmp_pdu *Src)
Definition: snmp_pdu.c:147
#define SNMPERR_OS_ERR
#define ASN_INTEGER
Definition: asn1.h:52
void snmp_add_null_var(struct snmp_pdu *pdu, oid *name, int name_length)
Definition: snmp_pdu.c:641
struct snmp_pdu * snmp_pdu_create(int command)
Definition: snmp_pdu.c:113
struct variable_list * next_variable
Definition: snmp_vars.h:45
u_char * asn_build_unsigned_int(u_char *, int *, u_char, u_int *, int)
Definition: asn1.c:311
#define SNMP_ERR_NOERROR
Definition: snmp_error.h:42
void snmp_var_free(struct variable_list *)
Definition: snmp_vars.c:230
u_char * asn_parse_unsigned_int(u_char *, int *, u_char *, u_int *, int)
Definition: asn1.c:179
int errindex
Definition: snmp_pdu.h:56
u_char * asn_build_string(u_char *, int *, u_char, u_char *, int)
Definition: asn1.c:433
#define SNMP_DEFAULT_ADDRESS
Definition: snmp_pdu.h:108
#define ASN_UNIVERSAL
Definition: asn1.h:60
u_char * asn_parse_int(u_char *, int *, u_char *, int *, int)
Definition: asn1.c:114
oid * name
Definition: snmp_vars.h:46
#define ASN_OBJECT_ID
Definition: asn1.h:56
int trap_type
Definition: snmp_pdu.h:68
u_int oid
Definition: asn1.h:42
#define SMI_TIMETICKS
Definition: snmp_vars.h:79
int enterprise_length
Definition: snmp_pdu.h:66
int max_repetitions
Definition: snmp_pdu.h:60
#define SNMP_DEFAULT_ERRSTAT
Definition: snmp_pdu.h:106
#define xmalloc
int command
Definition: snmp_pdu.h:51
#define ASN_PARSE_ERROR(x)
Definition: snmp_pdu.c:105
int reqid
Definition: snmp_pdu.h:54
u_char * asn_parse_header(u_char *, int *, u_char *)
Definition: asn1.c:470
struct sockaddr_in address
Definition: snmp_pdu.h:52
struct snmp_pdu * snmp_pdu_fix(struct snmp_pdu *pdu, int command)
Definition: snmp_pdu.c:181
struct variable_list * snmp_var_clone(struct variable_list *)
Definition: snmp_vars.c:169
struct sockaddr_in agent_addr
Definition: snmp_pdu.h:67
int errstat
Definition: snmp_pdu.h:55
#define xfree
#define MAX_NAME_LEN
Definition: snmp_vars.h:65
#define SNMP_PDU_GETBULK
Definition: snmp_pdu.h:99
#define NULL
Definition: types.h:166
int non_repeaters
Definition: snmp_pdu.h:59
#define SNMP_DEFAULT_REQID
Definition: snmp_pdu.h:109
void snmp_free_pdu(struct snmp_pdu *pdu)
Definition: snmp_pdu.c:284

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors