开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
snmp_pdu.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：16k
源码类别：

代理服务器

开发平台：

Unix_Linux

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