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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
smux.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：57k
源码类别：

SNMP编程

开发平台：

Unix_Linux

smux.c：源码内容
  1. /*
  2.  * Smux module authored by Rohit Dube.
  3.  * Rewritten by Nick Amato <naamato@merit.net>.
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #include <sys/types.h>
  8. #include <ctype.h>
  10. #if HAVE_IO_H                   /* win32 */
  11. #include <io.h>
  12. #endif
  13. #include <stdio.h>
  14. #if HAVE_STDLIB_H
  15. #include <stdlib.h>
  16. #endif
  17. #if HAVE_STRING_H
  18. #include <string.h>
  19. #else
  20. #include <strings.h>
  21. #endif
  22. #if HAVE_UNISTD_H
  23. #include <unistd.h>
  24. #endif
  25. #if HAVE_ERR_H
  26. #include <err.h>
  27. #endif
  28. #if TIME_WITH_SYS_TIME
  29. # ifdef WIN32
  30. #  include <sys/timeb.h>
  31. # else
  32. #  include <sys/time.h>
  33. # endif
  34. # include <time.h>
  35. #else
  36. # if HAVE_SYS_TIME_H
  37. #  include <sys/time.h>
  38. # else
  39. #  include <time.h>
  40. # endif
  41. #endif
  42. #include <errno.h>
  43. #if HAVE_NETDB_H
  44. #include <netdb.h>
  45. #endif
  47. #include <sys/stat.h>
  48. #if HAVE_SYS_SOCKET_H
  49. #include <sys/socket.h>
  50. #elif HAVE_WINSOCK_H
  51. #include <winsock.h>
  52. #endif
  53. #if HAVE_SYS_FILIO_H
  54. #include <sys/filio.h>
  55. #endif
  57. #if HAVE_NETINET_IN_H
  58. #include <netinet/in.h>
  59. #endif
  61. #if HAVE_ARPA_INET_H
  62. #include <arpa/inet.h>
  63. #endif
  65. #if HAVE_SYS_IOCTL_H
  66. #include <sys/ioctl.h>
  67. #endif
  69. #include <net-snmp/net-snmp-includes.h>
  70. #include <net-snmp/agent/net-snmp-agent-includes.h>
  72. #include "smux.h"
  73. #include "util_funcs.h"
  74. #include "mibdefs.h"
  75. #include "snmpd.h"
  77. long            smux_long;
  78. u_long          smux_ulong;
  79. struct sockaddr_in smux_sa;
  80. struct counter64 smux_counter64;
  81. oid             smux_objid[MAX_OID_LEN];
  82. u_char          smux_str[SMUXMAXSTRLEN];
  83. int             smux_listen_sd = -1;
  85. static struct timeval smux_rcv_timeout;
  86. static long   smux_reqid;
  88. void            init_smux(void);
  89. static u_char  *smux_open_process(int, u_char *, size_t *, int *);
  90. static u_char  *smux_rreq_process(int, u_char *, size_t *);
  91. static u_char  *smux_close_process(int, u_char *, size_t *);
  92. static u_char  *smux_trap_process(u_char *, size_t *);
  93. static u_char  *smux_parse(u_char *, oid *, size_t *, size_t *, u_char *);
  94. static u_char  *smux_parse_var(u_char *, size_t *, oid *, size_t *,
  95.                                size_t *, u_char *);
  96. static void     smux_send_close(int, int);
  97. static void     smux_list_detach(smux_reg **, smux_reg **);
  98. static void     smux_replace_active(smux_reg *, smux_reg *);
  99. static void     smux_peer_cleanup(int);
  100. static int      smux_auth_peer(oid *, size_t, char *, int);
  101. static int      smux_build(u_char, long, oid *,
  102.                            size_t *, u_char, u_char *, size_t, u_char *,
  103.                            size_t *);
  104. static int      smux_list_add(smux_reg **, smux_reg *);
  105. static int      smux_pdu_process(int, u_char *, size_t);
  106. static int      smux_send_rrsp(int, int);
  107. static smux_reg *smux_find_match(smux_reg *, int, oid *, size_t, long);
  108. static smux_reg *smux_find_replacement(oid *, size_t);
  109. u_char         *var_smux(struct variable *, oid *, size_t *, int, size_t *,
  110.                          WriteMethod ** write_method);
  111. int             var_smux_write(int, u_char *, u_char, size_t, u_char *,
  112.                                oid *, size_t);
  114. static smux_reg *ActiveRegs;    /* Active registrations                 */
  115. static smux_reg *PassiveRegs;   /* Currently unused registrations       */
  117. static smux_peer_auth *Auths[SMUX_MAX_PEERS];   /* Configured peers */
  118. static int      nauths, npeers = 0;
  120. struct variable2 smux_variables[] = {
  121.     /*
  122.      * bogus entry, as in pass.c 
  123.      */
  124.     {MIBINDEX, ASN_INTEGER, RWRITE, var_smux, 0, {MIBINDEX}},
  125. };
  129. void
  130. smux_parse_smux_socket(const char *token, char *cptr)
  131. {
  132.     DEBUGMSGTL(("smux", "port spec: %sn", cptr));
  133.     netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_SMUX_SOCKET, cptr);
  134. }
  136. void
  137. smux_parse_peer_auth(const char *token, char *cptr)
  138. {
  139.     smux_peer_auth *aptr;
  141.     if ((aptr =
  142.          (smux_peer_auth *) calloc(1, sizeof(smux_peer_auth))) == NULL) {
  143.         snmp_log_perror("smux_parse_peer_auth: malloc");
  144.         return;
  145.     }
  146.     if (nauths == SMUX_MAX_PEERS) {
  147. config_perror("Too many smuxpeers");
  148. return;
  149.     }
  150.     aptr->sa_active_fd = -1;
  151.     if (!cptr) {
  152.         /*
  153.          * null passwords OK 
  154.          */
  155.         Auths[nauths++] = aptr;
  156.         DEBUGMSGTL(("smux_conf", "null passwordn"));
  157.         return;
  158.     }
  160.     /*
  161.      * oid 
  162.      */
  163.     aptr->sa_oid_len = MAX_OID_LEN;
  164.     read_objid( cptr, aptr->sa_oid, &aptr->sa_oid_len );
  166.     DEBUGMSGTL(("smux_conf", "parsing registration for: %sn", cptr));
  168.     cptr = skip_token(cptr);
  169.     DEBUGMSGTL(("smux_conf", "password is: %sn", cptr ? cptr : "NULL"));
  171.     /*
  172.      * password 
  173.      */
  174.     if (cptr)
  175.         strcpy(aptr->sa_passwd, cptr);
  177.     Auths[nauths++] = aptr;
  178. }
  180. void
  181. smux_free_peer_auth(void)
  182. {
  183.     int             i;
  185.     for (i = 0; i < nauths; i++) {
  186.         free(Auths[i]);
  187.         Auths[i] = NULL;
  188.     }
  189.     nauths = 0;
  190. }
  192. void
  193. init_smux(void)
  194. {
  195.     snmpd_register_config_handler("smuxpeer", smux_parse_peer_auth,
  196.                                   smux_free_peer_auth,
  197.                                   "OID-IDENTITY PASSWORD");
  198.     snmpd_register_config_handler("smuxsocket",
  199.                                   smux_parse_smux_socket, NULL,
  200.                                   "SMUX bind address");
  201. }
  203. void
  204. real_init_smux(void)
  205. {
  206.     struct sockaddr_in lo_socket;
  207.     char           *smux_socket;
  208.     int             one = 1;
  210.     if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE) == SUB_AGENT) {
  211.         smux_listen_sd = -1;
  212.         return;
  213.     }
  215.     /*
  216.      * Reqid 
  217.      */
  218.     smux_reqid = 0;
  219.     smux_listen_sd = -1;
  221.     /*
  222.      * Receive timeout 
  223.      */
  224.     smux_rcv_timeout.tv_sec = 0;
  225.     smux_rcv_timeout.tv_usec = 500000;
  227.     /*
  228.      * Get ready to listen on the SMUX port
  229.      */
  230.     memset(&lo_socket, (0), sizeof(lo_socket));
  231.     lo_socket.sin_family = AF_INET;
  233.     smux_socket = netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, 
  234. NETSNMP_DS_SMUX_SOCKET);
  235. #ifdef LOCAL_SMUX
  236.     if (!smux_socket)
  237.         smux_socket = "127.0.0.1";   /* By default, listen on localhost only */
  238. #endif
  239.     netsnmp_sockaddr_in( &lo_socket, smux_socket, SMUXPORT );
  241.     if ((smux_listen_sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  242.         snmp_log_perror("[init_smux] socket failed");
  243.         return;
  244.     }
  245. #ifdef SO_REUSEADDR
  246.     /*
  247.      * At least on Linux, when the master agent terminates, any
  248.      * TCP connections for SMUX peers are put in the TIME_WAIT
  249.      * state for about 60 seconds. If the master agent is started
  250.      * during this time, the bind for the listening socket will
  251.      * fail because the SMUX port is in use.
  252.      */
  253.     if (setsockopt(smux_listen_sd, SOL_SOCKET, SO_REUSEADDR, (char *) &one,
  254.                    sizeof(one)) < 0) {
  255.         snmp_log_perror("[init_smux] setsockopt(SO_REUSEADDR) failed");
  256.     }
  257. #endif                          /* SO_REUSEADDR */
  259.     if (bind(smux_listen_sd, (struct sockaddr *) &lo_socket,
  260.              sizeof(lo_socket)) < 0) {
  261.         snmp_log_perror("[init_smux] bind failed");
  262.         close(smux_listen_sd);
  263.         smux_listen_sd = -1;
  264.         return;
  265.     }
  266. #ifdef SO_KEEPALIVE
  267.     if (setsockopt(smux_listen_sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one,
  268.                    sizeof(one)) < 0) {
  269.         snmp_log_perror("[init_smux] setsockopt(SO_KEEPALIVE) failed");
  270.         close(smux_listen_sd);
  271.         smux_listen_sd = -1;
  272.         return;
  273.     }
  274. #endif                          /* SO_KEEPALIVE */
  276.     if (listen(smux_listen_sd, SOMAXCONN) == -1) {
  277.         snmp_log_perror("[init_smux] listen failed");
  278.         close(smux_listen_sd);
  279.         smux_listen_sd = -1;
  280.         return;
  281.     }
  283.     DEBUGMSGTL(("smux_init",
  284.                 "[smux_init] done; smux listen sd is %d, smux port is %dn",
  285.                 smux_listen_sd, ntohs(lo_socket.sin_port)));
  286. }
  288. u_char         *
  289. var_smux(struct variable * vp,
  290.          oid * name,
  291.          size_t * length,
  292.          int exact, size_t * var_len, WriteMethod ** write_method)
  293. {
  294.     u_char         *valptr, val_type;
  295.     smux_reg       *rptr;
  297.     *write_method = var_smux_write;
  298.     /*
  299.      * search the active registration list 
  300.      */
  301.     for (rptr = ActiveRegs; rptr; rptr = rptr->sr_next) {
  302.         if (0 >= snmp_oidtree_compare(vp->name, vp->namelen, rptr->sr_name,
  303.                                       rptr->sr_name_len))
  304.             break;
  305.     }
  306.     if (rptr == NULL)
  307.         return NULL;
  308.     else if (exact && (*length < rptr->sr_name_len))
  309.         return NULL;
  311.     valptr = smux_snmp_process(exact, name, length,
  312.                                var_len, &val_type, rptr->sr_fd);
  314.     if (valptr == NULL)
  315.         return NULL;
  317.     if ((snmp_oidtree_compare(name, *length, rptr->sr_name,
  318.                               rptr->sr_name_len)) != 0) {
  319.         /*
  320.          * the peer has returned a value outside
  321.          * * of the registered tree
  322.          */
  323.         return NULL;
  324.     } else {
  325.         /*
  326.          * set the type and return the value 
  327.          */
  328.         vp->type = val_type;
  329.         return valptr;
  330.     }
  331. }
  333. int
  334. var_smux_write(int action,
  335.                u_char * var_val,
  336.                u_char var_val_type,
  337.                size_t var_val_len,
  338.                u_char * statP, oid * name, size_t name_len)
  339. {
  340.     smux_reg       *rptr;
  341.     u_char          buf[SMUXMAXPKTSIZE], *ptr, sout[3], type;
  342.     int             reterr;
  343.     size_t          var_len, datalen, name_length, packet_len;
  344.     ssize_t         len;
  345.     long            reqid, errsts, erridx;
  346.     u_char          var_type, *dataptr;
  348.     DEBUGMSGTL(("smux", "[var_smux_write] entering var_smux_writen"));
  350.     len = SMUXMAXPKTSIZE;
  351.     reterr = SNMP_ERR_NOERROR;
  352.     var_len = var_val_len;
  353.     var_type = var_val_type;
  354.     name_length = name_len;
  356.     /*
  357.      * XXX find the descriptor again 
  358.      */
  359.     for (rptr = ActiveRegs; rptr; rptr = rptr->sr_next) {
  360.         if (!snmp_oidtree_compare(name, name_len, rptr->sr_name,
  361.                                   rptr->sr_name_len))
  362.             break;
  363.     }
  365.     switch (action) {
  366.     case RESERVE1:
  367.         DEBUGMSGTL(("smux", "[var_smux_write] entering RESERVE1n"));
  369.         /*
  370.          * length might be long 
  371.          */
  372.         var_len += (*(var_val + 1) & ASN_LONG_LEN) ?
  373.             var_len + ((*(var_val + 1) & 0x7F) + 2) : 2;
  375.         switch (var_val_type) {
  376.         case ASN_INTEGER:
  377.         case ASN_OCTET_STR:
  378.         case ASN_COUNTER:
  379.         case ASN_GAUGE:
  380.         case ASN_TIMETICKS:
  381.         case ASN_UINTEGER:
  382.         case ASN_COUNTER64:
  383.         case ASN_IPADDRESS:
  384.         case ASN_OPAQUE:
  385.         case ASN_NSAP:
  386.         case ASN_OBJECT_ID:
  387.         case ASN_BIT_STR:
  388.             datalen = var_val_len;
  389.             dataptr = var_val;
  390.             break;
  391.         case SNMP_NOSUCHOBJECT:
  392.         case SNMP_NOSUCHINSTANCE:
  393.         case SNMP_ENDOFMIBVIEW:
  394.         case ASN_NULL:
  395.         default:
  396.             DEBUGMSGTL(("smux",
  397.                         "[var_smux_write] variable not supportedn"));
  398.             return SNMP_ERR_GENERR;
  399.             break;
  400.         }
  402.         if ((smux_build((u_char) SMUX_SET, smux_reqid,
  403.                         name, &name_length, var_val_type, dataptr,
  404.                         datalen, buf, &len)) < 0) {
  405.             DEBUGMSGTL(("smux", "[var_smux_write] smux build failedn"));
  406.             return SNMP_ERR_GENERR;
  407.         }
  409.         if (send(rptr->sr_fd, buf, len, 0) < 0) {
  410.             DEBUGMSGTL(("smux", "[var_smux_write] send failedn"));
  411.             return SNMP_ERR_GENERR;
  412.         }
  414.         while (1) {
  415.             /*
  416.              * peek at what's received 
  417.              */
  418.             if ((len = recv(rptr->sr_fd, buf,
  419.                             SMUXMAXPKTSIZE, MSG_PEEK)) <= 0) {
  420.                 DEBUGMSGTL(("smux",
  421.                             "[var_smux_write] peek failed or timed outn"));
  422.                 /*
  423.                  * do we need to do a peer cleanup in this case?? 
  424.                  */
  425.                 smux_peer_cleanup(rptr->sr_fd);
  426.                 return SNMP_ERR_GENERR;
  427.             }
  429.             DEBUGMSGTL(("smux", "[var_smux_write] Peeked at %d bytesn",
  430.                         len));
  431.             DEBUGDUMPSETUP("var_smux_write", buf, len);
  433.             /*
  434.              * determine if we received more than one packet 
  435.              */
  436.             packet_len = len;
  437.             ptr = asn_parse_header(buf, &packet_len, &type);
  438.             packet_len += (ptr - buf);
  439.             if (len > (ssize_t)packet_len) {
  440.                 /*
  441.                  * set length to receive only the first packet 
  442.                  */
  443.                 len = packet_len;
  444.             }
  446.             /*
  447.              * receive the first packet 
  448.              */
  449.             if ((len = recv(rptr->sr_fd, buf, len, 0)) <= 0) {
  450.                 DEBUGMSGTL(("smux",
  451.                             "[var_smux_write] recv failed or timed outn"));
  452.                 /*
  453.                  * do we need to do a peer cleanup in this case?? 
  454.                  */
  455.                 smux_peer_cleanup(rptr->sr_fd);
  456.                 return SNMP_ERR_GENERR;
  457.             }
  459.             DEBUGMSGTL(("smux", "[var_smux_write] Received %d bytesn",
  460.                         len));
  462.             if (buf[0] == SMUX_TRAP) {
  463.                 DEBUGMSGTL(("smux", "[var_smux_write] Received trapn"));
  464.                 snmp_log(LOG_INFO, "Got trap from peer on fd %dn",
  465.                          rptr->sr_fd);
  466.                 ptr = asn_parse_header(buf, &len, &type);
  467.                 smux_trap_process(ptr, &len);
  470.                 /*
  471.                  * go and peek at received data again 
  472.                  */
  473.                 /*
  474.                  * we could receive the reply or another trap 
  475.                  */
  476.             } else {
  477.                 ptr = buf;
  478.                 ptr = asn_parse_header(ptr, &len, &type);
  479.                 if ((ptr == NULL) || type != SNMP_MSG_RESPONSE)
  480.                     return SNMP_ERR_GENERR;
  482.                 ptr =
  483.                     asn_parse_int(ptr, &len, &type, &reqid, sizeof(reqid));
  484.                 if ((ptr == NULL) || type != ASN_INTEGER)
  485.                     return SNMP_ERR_GENERR;
  487.                 ptr =
  488.                     asn_parse_int(ptr, &len, &type, &errsts,
  489.                                   sizeof(errsts));
  490.                 if ((ptr == NULL) || type != ASN_INTEGER)
  491.                     return SNMP_ERR_GENERR;
  493.                 if (errsts) {
  494.                     DEBUGMSGTL(("smux",
  495.                                 "[var_smux_write] errsts returnedn"));
  496.                     return (errsts);
  497.                 }
  499.                 ptr =
  500.                     asn_parse_int(ptr, &len, &type, &erridx,
  501.                                   sizeof(erridx));
  502.                 if ((ptr == NULL) || type != ASN_INTEGER)
  503.                     return SNMP_ERR_GENERR;
  505.                 reterr = SNMP_ERR_NOERROR;
  506.                 break;
  507.             }
  508.         }                       /* while (1) */
  509.         break;                  /* case Action == RESERVE1 */
  511.     case RESERVE2:
  512.         DEBUGMSGTL(("smux", "[var_smux_write] entering RESERVE2n"));
  513.         reterr = SNMP_ERR_NOERROR;
  514.         break;                  /* case Action == RESERVE2 */
  516.     case FREE:
  517.     case COMMIT:
  518.         ptr = sout;
  519.         *(ptr++) = (u_char) SMUX_SOUT;
  520.         *(ptr++) = (u_char) 1;
  521.         if (action == FREE) {
  522.             *ptr = (u_char) 1;  /* rollback */
  523.             DEBUGMSGTL(("smux",
  524.                         "[var_smux_write] entering FREE - sending RollBack n"));
  525.         } else {
  526.             *ptr = (u_char) 0;  /* commit */
  527.             DEBUGMSGTL(("smux",
  528.                         "[var_smux_write] entering FREE - sending Commit n"));
  529.         }
  531.         if ((send(rptr->sr_fd, sout, 3, 0)) < 0) {
  532.             DEBUGMSGTL(("smux",
  533.                         "[var_smux_write] send rollback/commit failedn"));
  534.             return SNMP_ERR_GENERR;
  535.         }
  537.         reterr = SNMP_ERR_NOERROR;
  538.         break;                  /* case Action == COMMIT */
  540.     default:
  541.         break;
  542.     }
  543.     return reterr;
  544. }
  547. int
  548. smux_accept(int sd)
  549. {
  550.     u_char          data[SMUXMAXPKTSIZE], *ptr, type;
  551.     struct sockaddr_in in_socket;
  552.     struct timeval  tv;
  553.     int             fail, fd, alen;
  554.     int             length;
  555.     ssize_t         len;
  557.     alen = sizeof(struct sockaddr_in);
  558.     /*
  559.      * this may be too high 
  560.      */
  561.     tv.tv_sec = 5;
  562.     tv.tv_usec = 0;
  564.     /*
  565.      * connection request 
  566.      */
  567.     DEBUGMSGTL(("smux", "[smux_accept] Calling accept()n"));
  568.     errno = 0;
  569.     if ((fd = accept(sd, (struct sockaddr *) &in_socket, &alen)) < 0) {
  570.         snmp_log_perror("[smux_accept] accept failed");
  571.         return -1;
  572.     } else {
  573.         snmp_log(LOG_INFO, "[smux_accept] accepted fd %d from %s:%dn",
  574.                  fd, inet_ntoa(in_socket.sin_addr),
  575.                  ntohs(in_socket.sin_port));
  576.         if (npeers + 1 == SMUXMAXPEERS) {
  577.             snmp_log(LOG_ERR,
  578.                      "[smux_accept] denied peer on fd %d, limit %d reached",
  579.                      fd, SMUXMAXPEERS);
  580.             close(sd);
  581.             return -1;
  582.         }
  584.         /*
  585.          * now block for an OpenPDU 
  586.          */
  587.         if ((length = recv(fd, (char *) data, SMUXMAXPKTSIZE, 0)) <= 0) {
  588.             DEBUGMSGTL(("smux",
  589.                         "[smux_accept] peer on fd %d died or timed outn",
  590.                         fd));
  591.             close(fd);
  592.             return -1;
  593.         }
  594.         /*
  595.          * try to authorize him 
  596.          */
  597.         ptr = data;
  598.         len = length;
  599.         if ((ptr = asn_parse_header(ptr, &len, &type)) == NULL) {
  600.             smux_send_close(fd, SMUXC_PACKETFORMAT);
  601.             close(fd);
  602.             DEBUGMSGTL(("smux", "[smux_accept] peer on %d sent bad open"));
  603.             return -1;
  604.         } else if (type != (u_char) SMUX_OPEN) {
  605.             smux_send_close(fd, SMUXC_PROTOCOLERROR);
  606.             close(fd);
  607.             DEBUGMSGTL(("smux",
  608.                         "[smux_accept] peer on %d did not send open: (%d)n",
  609.                         type));
  610.             return -1;
  611.         }
  612.         ptr = smux_open_process(fd, ptr, &len, &fail);
  613.         if (fail) {
  614.             smux_send_close(fd, SMUXC_AUTHENTICATIONFAILURE);
  615.             close(fd);
  616.             DEBUGMSGTL(("smux",
  617.                         "[smux_accept] peer on %d failed authenticationn",
  618.                         fd));
  619.             return -1;
  620.         }
  622.         /*
  623.          * he's OK 
  624.          */
  625. #ifdef SO_RCVTIMEO
  626.         if (setsockopt
  627.             (fd, SOL_SOCKET, SO_RCVTIMEO, (void *) &tv, sizeof(tv)) < 0) {
  628.             DEBUGMSGTL(("smux",
  629.                         "[smux_accept] setsockopt(SO_RCVTIMEO) failed fd %dn",
  630.                         fd));
  631.             snmp_log_perror("smux_accept: setsockopt SO_RCVTIMEO");
  632.         }
  633. #endif
  634.         npeers++;
  635.         DEBUGMSGTL(("smux", "[smux_accept] fd %dn", fd));
  637.         /*
  638.          * Process other PDUs already read, e.g. a registerRequest. 
  639.          */
  640.         len = length - (ptr - data);
  641.         if (smux_pdu_process(fd, ptr, len) < 0) {
  642.             /*
  643.              * Easy come, easy go.  Clean-up is already done. 
  644.              */
  645.             return -1;
  646.         }
  647.     }
  648.     return fd;
  649. }
  651. int
  652. smux_process(int fd)
  653. {
  654.     int             length;
  655.     u_char          data[SMUXMAXPKTSIZE];
  657.     length = recv(fd, (char *) data, SMUXMAXPKTSIZE, 0);
  658.     if (length <= 0) {
  659.         /*
  660.          * the peer went away, close this descriptor 
  661.          * * and delete it from the list
  662.          */
  663.         DEBUGMSGTL(("smux",
  664.                     "[smux_process] peer on fd %d died or timed outn",
  665.                     fd));
  666.         smux_peer_cleanup(fd);
  667.         return -1;
  668.     }
  670.     return smux_pdu_process(fd, data, length);
  671. }
  673. static int
  674. smux_pdu_process(int fd, u_char * data, size_t length)
  675. {
  676.     int             error;
  677.     size_t          len;
  678.     u_char         *ptr, type;
  680.     DEBUGMSGTL(("smux", "[smux_pdu_process] Processing %d bytesn",
  681.                 length));
  683.     error = 0;
  684.     ptr = data;
  685.     while (error == 0 && ptr != NULL && ptr < data + length) {
  686.         len = length - (ptr - data);
  687.         ptr = asn_parse_header(ptr, &len, &type);
  688.         DEBUGMSGTL(("smux", "[smux_pdu_process] type is %dn",
  689.                     (int) type));
  690.         switch (type) {
  691.         case SMUX_OPEN:
  692.             smux_send_close(fd, SMUXC_PROTOCOLERROR);
  693.             DEBUGMSGTL(("smux",
  694.                         "[smux_pdu_process] peer on fd %d sent duplicate open?n",
  695.                         fd));
  696.             smux_peer_cleanup(fd);
  697.             error = -1;
  698.             break;
  699.         case SMUX_CLOSE:
  700.             ptr = smux_close_process(fd, ptr, &len);
  701.             smux_peer_cleanup(fd);
  702.             error = -1;
  703.             break;
  704.         case SMUX_RREQ:
  705.             ptr = smux_rreq_process(fd, ptr, &len);
  706.             break;
  707.         case SMUX_RRSP:
  708.             error = -1;
  709.             smux_send_close(fd, SMUXC_PROTOCOLERROR);
  710.             smux_peer_cleanup(fd);
  711.             DEBUGMSGTL(("smux",
  712.                         "[smux_pdu_process] peer on fd %d sent RRSP!n",
  713.                         fd));
  714.             break;
  715.         case SMUX_SOUT:
  716.             error = -1;
  717.             smux_send_close(fd, SMUXC_PROTOCOLERROR);
  718.             smux_peer_cleanup(fd);
  719.             DEBUGMSGTL(("smux", "This shouldn't have happened!n"));
  720.             break;
  721.         case SMUX_TRAP:
  722.             snmp_log(LOG_INFO, "Got trap from peer on fd %dn", fd);
  723.             ptr = smux_trap_process(ptr, &len);
  724.             /*
  725.              * watch out for close on top of this...should return correct end 
  726.              */
  727.             /*
  728.              * debug this... 
  729.              */
  730.             ptr = NULL;
  731.             break;
  732.         default:
  733.             smux_send_close(fd, SMUXC_PACKETFORMAT);
  734.             smux_peer_cleanup(fd);
  735.             DEBUGMSGTL(("smux", "[smux_pdu_process] Wrong type %dn",
  736.                         (int) type));
  737.             error = -1;
  738.             break;
  739.         }
  740.     }
  741.     return error;
  742. }
  744. static u_char  *
  745. smux_open_process(int fd, u_char * ptr, size_t * len, int *fail)
  746. {
  747.     u_char          type;
  748.     long            version;
  749.     oid             oid_name[MAX_OID_LEN];
  750.     char            passwd[SMUXMAXSTRLEN];
  751.     char            descr[SMUXMAXSTRLEN];
  752.     char            oid_print[SMUXMAXSTRLEN];
  753.     int             i;
  754.     size_t          oid_name_len, string_len;
  756.     if (!(ptr = asn_parse_int(ptr, len, &type, &version, sizeof(version)))) {
  757.         DEBUGMSGTL(("smux", "[smux_open_process] version parse failedn"));
  758.         *fail = TRUE;
  759.         return ((ptr += *len));
  760.     }
  761.     DEBUGMSGTL(("smux",
  762.                 "[smux_open_process] version %d, len %d, type %dn",
  763.                 version, *len, (int) type));
  765.     oid_name_len = MAX_OID_LEN;
  766.     if ((ptr = asn_parse_objid(ptr, len, &type, oid_name,
  767.                                &oid_name_len)) == NULL) {
  768.         DEBUGMSGTL(("smux", "[smux_open_process] oid parse failedn"));
  769.         *fail = TRUE;
  770.         return ((ptr += *len));
  771.     }
  772.     snprint_objid(oid_print, sizeof(oid_print), oid_name, oid_name_len);
  774.     if (snmp_get_do_debugging()) {
  775.         DEBUGMSGTL(("smux", "[smux_open_process] smux peer: %sn",
  776.                     oid_print));
  777.         DEBUGMSGTL(("smux", "[smux_open_process] len %d, type %dn", *len,
  778.                     (int) type));
  779.     }
  781.     string_len = SMUXMAXSTRLEN;
  782.     if ((ptr = asn_parse_string(ptr, len, &type, (u_char *) descr,
  783.                                 &string_len)) == NULL) {
  784.         DEBUGMSGTL(("smux", "[smux_open_process] descr parse failedn"));
  785.         *fail = TRUE;
  786.         return ((ptr += *len));
  787.     }
  789.     if (snmp_get_do_debugging()) {
  790.         DEBUGMSGTL(("smux", "[smux_open_process] smux peer descr: "));
  791.         for (i = 0; i < (int) string_len; i++)
  792.             DEBUGMSG(("smux", "%c", descr[i]));
  793.         DEBUGMSG(("smux", "n"));
  794.         DEBUGMSGTL(("smux", "[smux_open_process] len %d, type %dn", *len,
  795.                     (int) type));
  796.     }
  797.     descr[string_len] = 0;
  799.     string_len = SMUXMAXSTRLEN;
  800.     if ((ptr = asn_parse_string(ptr, len, &type, (u_char *) passwd,
  801.                                 &string_len)) == NULL) {
  802.         DEBUGMSGTL(("smux", "[smux_open_process] passwd parse failedn"));
  803.         *fail = TRUE;
  804.         return ((ptr += *len));
  805.     }
  807.     if (snmp_get_do_debugging()) {
  808.         DEBUGMSGTL(("smux", "[smux_open_process] smux peer passwd: "));
  809.         for (i = 0; i < (int) string_len; i++)
  810.             DEBUGMSG(("smux", "%c", passwd[i]));
  811.         DEBUGMSG(("smux", "n"));
  812.         DEBUGMSGTL(("smux", "[smux_open_process] len %d, type %dn", *len,
  813.                     (int) type));
  814.     }
  815.     passwd[string_len] = '';
  816.     if (!smux_auth_peer(oid_name, oid_name_len, passwd, fd)) {
  817.         snmp_log(LOG_WARNING,
  818.                  "refused smux peer: oid %s, descr %sn",
  819.                  oid_print, descr);
  820.         *fail = TRUE;
  821.         return ptr;
  822.     }
  823.     snmp_log(LOG_INFO,
  824.              "accepted smux peer: oid %s, descr %sn",
  825.              oid_print, descr);
  826.     *fail = FALSE;
  827.     return ptr;
  828. }
  830. static void
  831. smux_send_close(int fd, int reason)
  832. {
  833.     u_char          outpacket[3], *ptr;
  835.     ptr = outpacket;
  837.     *(ptr++) = (u_char) SMUX_CLOSE;
  838.     *(ptr++) = (u_char) 1;
  839.     *ptr = (u_char) (reason & 0xFF);
  841.     if (snmp_get_do_debugging())
  842.         DEBUGMSGTL(("smux",
  843.                     "[smux_close] sending close to fd %d, reason %dn", fd,
  844.                     reason));
  846.     /*
  847.      * send a response back 
  848.      */
  849.     if (send(fd, (char *) outpacket, 3, 0) < 0) {
  850.         snmp_log_perror("[smux_snmp_close] send failed");
  851.     }
  852. }
  855. static int
  856. smux_auth_peer(oid * name, size_t namelen, char *passwd, int fd)
  857. {
  858.     int             i;
  860.     for (i = 0; i < nauths; i++) {
  861.         if (snmp_oid_compare(Auths[i]->sa_oid, Auths[i]->sa_oid_len,
  862.                              name, namelen) == 0) {
  863.             if (!(strcmp(Auths[i]->sa_passwd, passwd)) &&
  864.                 (Auths[i]->sa_active_fd == -1)) {
  865.                 /*
  866.                  * matched, mark the auth 
  867.                  */
  868.                 Auths[i]->sa_active_fd = fd;
  869.                 return 1;
  870.             }
  871.         }
  872.     }
  873.     /*
  874.      * did not match oid and passwd 
  875.      */
  876.     return 0;
  877. }
  880. /*
  881.  * XXX - Bells and Whistles:
  882.  * Need to catch signal when snmpd goes down and send close pdu to gated 
  883.  */
  884. static u_char  *
  885. smux_close_process(int fd, u_char * ptr, size_t * len)
  886. {
  887.     long            down = 0;
  888.     int             length = *len;
  890.     /*
  891.      * This is the integer part of the close pdu 
  892.      */
  893.     while (length--) {
  894.         down = (down << 8) | (long) *ptr;
  895.         ptr++;
  896.     }
  898.     DEBUGMSGTL(("smux",
  899.                 "[smux_close_process] close from peer on fd %d reason %dn",
  900.                 fd, down));
  901.     smux_peer_cleanup(fd);
  903.     return NULL;
  904. }
  906. static u_char  *
  907. smux_rreq_process(int sd, u_char * ptr, size_t * len)
  908. {
  909.     long            priority, rpriority;
  910.     long            operation;
  911.     oid             oid_name[MAX_OID_LEN];
  912.     size_t          oid_name_len;
  913.     int             i, result;
  914.     u_char          type;
  915.     smux_reg       *rptr, *nrptr;
  917.     oid_name_len = MAX_OID_LEN;
  918.     ptr = asn_parse_objid(ptr, len, &type, oid_name, &oid_name_len);
  920.     DEBUGMSGTL(("smux", "[smux_rreq_process] smux subtree: "));
  921.     DEBUGMSGOID(("smux", oid_name, oid_name_len));
  922.     DEBUGMSG(("smux", "n"));
  924.     if ((ptr = asn_parse_int(ptr, len, &type, &priority,
  925.                              sizeof(priority))) == NULL) {
  926.         DEBUGMSGTL(("smux",
  927.                     "[smux_rreq_process] priority parse failedn"));
  928.         smux_send_rrsp(sd, -1);
  929.         return NULL;
  930.     }
  931.     DEBUGMSGTL(("smux", "[smux_rreq_process] priority %dn", priority));
  933.     if ((ptr = asn_parse_int(ptr, len, &type, &operation,
  934.                              sizeof(operation))) == NULL) {
  935.         DEBUGMSGTL(("smux",
  936.                     "[smux_rreq_process] operation parse failedn"));
  937.         smux_send_rrsp(sd, -1);
  938.         return NULL;
  939.     }
  940.     DEBUGMSGTL(("smux", "[smux_rreq_process] operation %dn", operation));
  942.     if (operation == SMUX_REGOP_DELETE) {
  943.         /*
  944.          * search the active list for this registration 
  945.          */
  946.         rptr =
  947.             smux_find_match(ActiveRegs, sd, oid_name, oid_name_len,
  948.                             priority);
  949.         if (rptr) {
  950.             rpriority = rptr->sr_priority;
  951.             /*
  952.              * unregister the mib 
  953.              */
  954.             unregister_mib(rptr->sr_name, rptr->sr_name_len);
  955.             /*
  956.              * find a replacement 
  957.              */
  958.             nrptr =
  959.                 smux_find_replacement(rptr->sr_name, rptr->sr_name_len);
  960.             if (nrptr) {
  961.                 /*
  962.                  * found one 
  963.                  */
  964.                 smux_replace_active(rptr, nrptr);
  965.             } else {
  966.                 /*
  967.                  * no replacement found 
  968.                  */
  969.                 smux_list_detach(&ActiveRegs, &rptr);
  970.                 free(rptr);
  971.             }
  972.             smux_send_rrsp(sd, rpriority);
  973.             return ptr;
  974.         }
  975.         /*
  976.          * search the passive list for this registration 
  977.          */
  978.         rptr =
  979.             smux_find_match(PassiveRegs, sd, oid_name, oid_name_len,
  980.                             priority);
  981.         if (rptr) {
  982.             rpriority = rptr->sr_priority;
  983.             smux_list_detach(&PassiveRegs, &rptr);
  984.             free(rptr);
  985.             smux_send_rrsp(sd, rpriority);
  986.             return ptr;
  987.         }
  988.         /*
  989.          * This peer cannot unregister the tree, it does not
  990.          * * belong to him.  Send him an error.
  991.          */
  992.         smux_send_rrsp(sd, -1);
  993.         return ptr;
  995.     } else if ((operation == SMUX_REGOP_REGISTER_RO) ||
  996.                (operation == SMUX_REGOP_REGISTER_RW)) {
  997.         if (priority < -1) {
  998.             DEBUGMSGTL(("smux",
  999.                         "[smux_rreq_process] peer fd %d invalid priority",
  1000.                         sd, priority));
  1001.             smux_send_rrsp(sd, -1);
  1002.             return NULL;
  1003.         }
  1004.         if ((nrptr = malloc(sizeof(smux_reg))) == NULL) {
  1005.             snmp_log_perror("[smux_rreq_process] malloc");
  1006.             smux_send_rrsp(sd, -1);
  1007.             return NULL;
  1008.         }
  1009.         nrptr->sr_priority = priority;
  1010.         nrptr->sr_name_len = oid_name_len;
  1011.         nrptr->sr_fd = sd;
  1012.         for (i = 0; i < (int) oid_name_len; i++)
  1013.             nrptr->sr_name[i] = oid_name[i];
  1015.         /*
  1016.          * See if this tree matches or scopes any of the
  1017.          * * active trees.
  1018.          */
  1019.         for (rptr = ActiveRegs; rptr; rptr = rptr->sr_next) {
  1020.             result =
  1021.                 snmp_oid_compare(oid_name, oid_name_len, rptr->sr_name,
  1022.                                  rptr->sr_name_len);
  1023.             if (result == 0) {
  1024.                 if ((oid_name_len == rptr->sr_name_len)) {
  1025.                     if ((nrptr->sr_priority == -1)) {
  1026.                         nrptr->sr_priority = rptr->sr_priority;
  1027.                         do {
  1028.                             nrptr->sr_priority++;
  1029.                         } while (smux_list_add(&PassiveRegs, nrptr));
  1030.                         goto done;
  1031.                     } else if (nrptr->sr_priority < rptr->sr_priority) {
  1032.                         /*
  1033.                          * Better priority.  There are no better
  1034.                          * * priorities for this tree in the passive list,
  1035.                          * * so replace the current active tree.
  1036.                          */
  1037.                         smux_replace_active(rptr, nrptr);
  1038.                         goto done;
  1039.                     } else {
  1040.                         /*
  1041.                          * Equal or worse priority 
  1042.                          */
  1043.                         do {
  1044.                             nrptr->sr_priority++;
  1045.                         } while (smux_list_add(&PassiveRegs, nrptr) == -1);
  1046.                         goto done;
  1047.                     }
  1048.                 } else if (oid_name_len < rptr->sr_name_len) {
  1049.                     /*
  1050.                      * This tree scopes a current active
  1051.                      * * tree.  Replace the current active tree.
  1052.                      */
  1053.                     smux_replace_active(rptr, nrptr);
  1054.                     goto done;
  1055.                 } else {        /* oid_name_len > rptr->sr_name_len */
  1056.                     /*
  1057.                      * This tree is scoped by a current
  1058.                      * * active tree.  
  1059.                      */
  1060.                     do {
  1061.                         nrptr->sr_priority++;
  1062.                     } while (smux_list_add(&PassiveRegs, nrptr) == -1);
  1063.                     goto done;
  1064.                 }
  1065.             }
  1066.         }
  1067.         /*
  1068.          * We didn't find it in the active list.  Add it at
  1069.          * * the requested priority.
  1070.          */
  1071.         if (nrptr->sr_priority == -1)
  1072.             nrptr->sr_priority = 0;
  1073.         smux_list_add(&ActiveRegs, nrptr);
  1074.         register_mib("smux", (struct variable *)
  1075.                      smux_variables, sizeof(struct variable2),
  1076.                      1, nrptr->sr_name, nrptr->sr_name_len);
  1077.       done:
  1078.         smux_send_rrsp(sd, nrptr->sr_priority);
  1079.         return ptr;
  1080.     } else {
  1081.         DEBUGMSGTL(("smux", "[smux_rreq_process] unknown operationn"));
  1082.         smux_send_rrsp(sd, -1);
  1083.         return NULL;
  1084.     }
  1085. }
  1087. /*
  1088.  * Find the registration with a matching descriptor, OID and priority.  If
  1089.  * the priority is -1 then find a registration with a matching descriptor,
  1090.  * a matching OID, and the highest priority.
  1091.  */
  1092. static smux_reg *
  1093. smux_find_match(smux_reg * regs, int sd, oid * oid_name,
  1094.                 size_t oid_name_len, long priority)
  1095. {
  1096.     smux_reg       *rptr, *bestrptr;
  1098.     bestrptr = NULL;
  1099.     for (rptr = regs; rptr; rptr = rptr->sr_next) {
  1100.         if (rptr->sr_fd != sd)
  1101.             continue;
  1102.         if (snmp_oid_compare
  1103.             (rptr->sr_name, rptr->sr_name_len, oid_name, oid_name_len))
  1104.             continue;
  1105.         if (rptr->sr_priority == priority)
  1106.             return rptr;
  1107.         if (priority != -1)
  1108.             continue;
  1109.         if (bestrptr) {
  1110.             if (bestrptr->sr_priority > rptr->sr_priority)
  1111.                 bestrptr = rptr;
  1112.         } else {
  1113.             bestrptr = rptr;
  1114.         }
  1115.     }
  1116.     return bestrptr;
  1117. }
  1119. static void
  1120. smux_replace_active(smux_reg * actptr, smux_reg * pasptr)
  1121. {
  1122.     smux_list_detach(&ActiveRegs, &actptr);
  1123.     unregister_mib(actptr->sr_name, actptr->sr_name_len);
  1125.     smux_list_detach(&PassiveRegs, &pasptr);
  1126.     (void) smux_list_add(&ActiveRegs, pasptr);
  1128.     register_mib("smux", (struct variable *) smux_variables,
  1129.                  sizeof(struct variable2), 1, pasptr->sr_name,
  1130.                  pasptr->sr_name_len);
  1131.     free(actptr);
  1132. }
  1134. static void
  1135. smux_list_detach(smux_reg ** head, smux_reg ** m_remove)
  1136. {
  1137.     smux_reg       *rptr, *rptr2;
  1139.     if (*head == NULL) {
  1140.         DEBUGMSGTL(("smux", "[smux_list_detach] Ouch!"));
  1141.         return;
  1142.     }
  1143.     if (*head == *m_remove) {
  1144.         *m_remove = *head;
  1145.         *head = (*head)->sr_next;
  1146.         return;
  1147.     }
  1148.     for (rptr = *head, rptr2 = rptr->sr_next; rptr2;
  1149.          rptr2 = rptr2->sr_next, rptr = rptr->sr_next) {
  1150.         if (rptr2 == *m_remove) {
  1151.             *m_remove = rptr2;
  1152.             rptr->sr_next = rptr2->sr_next;
  1153.             return;
  1154.         }
  1155.     }
  1156. }
  1158. /*
  1159.  * Attempt to add a registration (in order) to a list.  If the
  1160.  * add fails (because of an existing registration with equal
  1161.  * priority) return -1.
  1162.  */
  1163. static int
  1164. smux_list_add(smux_reg ** head, smux_reg * add)
  1165. {
  1166.     smux_reg       *rptr;
  1167.     int             result;
  1169.     if (*head == NULL) {
  1170.         *head = add;
  1171.         (*head)->sr_next = NULL;
  1172.         return 0;
  1173.     }
  1174.     for (rptr = *head; rptr->sr_next; rptr = rptr->sr_next) {
  1175.         result = snmp_oid_compare(add->sr_name, add->sr_name_len,
  1176.                                   rptr->sr_name, rptr->sr_name_len);
  1177.         if ((result == 0) && (add->sr_priority == rptr->sr_priority)) {
  1178.             /*
  1179.              * same tree, same pri, nope 
  1180.              */
  1181.             return -1;
  1182.         } else if (result < 0) {
  1183.             /*
  1184.              * this can only happen if we go before the head 
  1185.              */
  1186.             add->sr_next = *head;
  1187.             *head = add;
  1188.             return 0;
  1189.         } else if ((snmp_oid_compare(add->sr_name, add->sr_name_len,
  1190.                                      rptr->sr_next->sr_name,
  1191.                                      rptr->sr_next->sr_name_len)) < 0) {
  1192.             /*
  1193.              * insert here 
  1194.              */
  1195.             add->sr_next = rptr->sr_next;
  1196.             rptr->sr_next = add;
  1197.             return 0;
  1198.         }
  1199.     }
  1200.     /*
  1201.      * compare the last one 
  1202.      */
  1203.     if ((snmp_oid_compare(add->sr_name, add->sr_name_len, rptr->sr_name,
  1204.                           rptr->sr_name_len) == 0)
  1205.         && add->sr_priority == rptr->sr_priority)
  1206.         return -1;
  1207.     else {
  1208.         rptr->sr_next = add;
  1209.         add->sr_next = NULL;
  1210.     }
  1211.     return 0;
  1212. }
  1214. /*
  1215.  * Find a replacement for this registration.  In order
  1216.  * of preference:
  1217.  *
  1218.  *      - Least difference in subtree length
  1219.  *      - Best (lowest) priority
  1220.  *
  1221.  * For example, if we need to replace .1.3.6.1.69, 
  1222.  * we would pick .1.3.6.1.69.1 instead of .1.3.6.69.1.1
  1223.  *
  1224.  */
  1225. static smux_reg *
  1226. smux_find_replacement(oid * name, size_t name_len)
  1227. {
  1228.     smux_reg       *rptr, *bestptr;
  1229.     int             bestlen, difflen;
  1231.     bestlen = SMUX_MAX_PRIORITY;
  1232.     bestptr = NULL;
  1234.     for (rptr = PassiveRegs; rptr; rptr = rptr->sr_next) {
  1235.         if (!snmp_oidtree_compare(rptr->sr_name, rptr->sr_name_len,
  1236.                                   name, name_len)) {
  1237.             if ((difflen = rptr->sr_name_len - name_len)
  1238.                 < bestlen) {
  1239.                 bestlen = difflen;
  1240.                 bestptr = rptr;
  1241.             } else if ((difflen == bestlen) &&
  1242.                        (rptr->sr_priority < bestptr->sr_priority))
  1243.                 bestptr = rptr;
  1244.         }
  1245.     }
  1246.     return bestptr;
  1247. }
  1249. u_char         *
  1250. smux_snmp_process(int exact,
  1251.                   oid * objid,
  1252.                   size_t * len,
  1253.                   size_t * return_len, u_char * return_type, int sd)
  1254. {
  1255.     u_char          packet[SMUXMAXPKTSIZE], *ptr, result[SMUXMAXPKTSIZE];
  1256.     size_t          length = SMUXMAXPKTSIZE;
  1257.     u_char          type;
  1258.     size_t          packet_len;
  1260.     /*
  1261.      * Send the query to the peer
  1262.      */
  1263.     smux_reqid++;
  1265.     if (exact)
  1266.         type = SMUX_GET;
  1267.     else
  1268.         type = SMUX_GETNEXT;
  1270.     if (smux_build(type, smux_reqid, objid, len, 0, NULL,
  1271.                    *len, packet, &length) < 0) {
  1272.         snmp_log(LOG_ERR, "[smux_snmp_process]: smux_build failedn");
  1273.         return NULL;
  1274.     }
  1275.     DEBUGMSGTL(("smux", "[smux_snmp_process] oid from build: "));
  1276.     DEBUGMSGOID(("smux", objid, *len));
  1277.     DEBUGMSG(("smux", "n"));
  1279.     if (send(sd, (char *) packet, length, 0) < 0) {
  1280.         snmp_log_perror("[smux_snmp_process] send failed");
  1281.     }
  1283.     DEBUGMSGTL(("smux",
  1284.                 "[smux_snmp_process] Sent %d request to peer; %d bytesn",
  1285.                 (int) type, length));
  1287.     while (1) {
  1288.         /*
  1289.          * peek at what's received 
  1290.          */
  1291.         length = recv(sd, (char *) result, SMUXMAXPKTSIZE, MSG_PEEK);
  1292.         if (length < 0) {
  1293.             snmp_log_perror("[smux_snmp_process] peek failed");
  1294.             smux_peer_cleanup(sd);
  1295.             return NULL;
  1296.         }
  1298.         DEBUGMSGTL(("smux", "[smux_snmp_process] Peeked at %d bytesn",
  1299.                     length));
  1300.         DEBUGDUMPSETUP("smux_snmp_process", result, length);
  1302.         /*
  1303.          * determine if we received more than one packet 
  1304.          */
  1305.         packet_len = length;
  1306.         ptr = asn_parse_header(result, &packet_len, &type);
  1307.         packet_len += (ptr - result);
  1308.         if (length > packet_len) {
  1309.             /*
  1310.              * set length to receive only the first packet 
  1311.              */
  1312.             length = packet_len;
  1313.         }
  1315.         /*
  1316.          * receive the first packet 
  1317.          */
  1318.         length = recv(sd, (char *) result, length, 0);
  1319.         if (length < 0) {
  1320.             snmp_log_perror("[smux_snmp_process] recv failed");
  1321.             smux_peer_cleanup(sd);
  1322.             return NULL;
  1323.         }
  1325.         DEBUGMSGTL(("smux", "[smux_snmp_process] Received %d bytesn",
  1326.                     length));
  1328.         if (result[0] == SMUX_TRAP) {
  1329.             DEBUGMSGTL(("smux", "[smux_snmp_process] Received trapn"));
  1330.             snmp_log(LOG_INFO, "Got trap from peer on fd %dn", sd);
  1331.             ptr = asn_parse_header(result, &length, &type);
  1332.             smux_trap_process(ptr, &length);
  1334.             /*
  1335.              * go and peek at received data again 
  1336.              */
  1337.             /*
  1338.              * we could receive the reply or another trap 
  1339.              */
  1340.         } else {
  1341.             /*
  1342.              * Interpret reply 
  1343.              */
  1344.             ptr = smux_parse(result, objid, len, return_len, return_type);
  1345.             /*
  1346.              * ptr will point to query result or NULL if error 
  1347.              */
  1348.             break;
  1349.         }
  1350.     }                           /* while (1) */
  1352.     return ptr;
  1353. }
  1355. static u_char  *
  1356. smux_parse(u_char * rsp,
  1357.            oid * objid,
  1358.            size_t * oidlen, size_t * return_len, u_char * return_type)
  1359. {
  1360.     size_t          length = SMUXMAXPKTSIZE;
  1361.     u_char         *ptr, type;
  1362.     long            reqid, errstat, errindex;
  1364.     ptr = rsp;
  1366.     /*
  1367.      * Return pointer to the snmp/smux return value.
  1368.      * return_len should contain the number of bytes in the value
  1369.      * returned above.
  1370.      * objid is the next object, with len for GETNEXT.
  1371.      * objid and len are not changed for GET
  1372.      */
  1373.     ptr = asn_parse_header(ptr, &length, &type);
  1374.     if (ptr == NULL || type != SNMP_MSG_RESPONSE)
  1375.         return NULL;
  1377.     if ((ptr = asn_parse_int(ptr, &length, &type, &reqid,
  1378.                              sizeof(reqid))) == NULL) {
  1379.         DEBUGMSGTL(("smux", "[smux_parse] parse of reqid failedn"));
  1380.         return NULL;
  1381.     }
  1382.     if ((ptr = asn_parse_int(ptr, &length, &type, &errstat,
  1383.                              sizeof(errstat))) == NULL) {
  1384.         DEBUGMSGTL(("smux",
  1385.                     "[smux_parse] parse of error status failedn"));
  1386.         return NULL;
  1387.     }
  1388.     if ((ptr = asn_parse_int(ptr, &length, &type, &errindex,
  1389.                              sizeof(errindex))) == NULL) {
  1390.         DEBUGMSGTL(("smux", "[smux_parse] parse of error index failedn"));
  1391.         return NULL;
  1392.     }
  1394.     /*
  1395.      * XXX How to send something intelligent back in case of an error 
  1396.      */
  1397.     DEBUGMSGTL(("smux",
  1398.                 "[smux_parse] Message type %d, reqid %d, errstat %d, nterrindex %dn",
  1399.                 (int) type, reqid, errstat, errindex));
  1400.     if (ptr == NULL || errstat != SNMP_ERR_NOERROR)
  1401.         return NULL;
  1403.     /*
  1404.      * stuff to return 
  1405.      */
  1406.     return (smux_parse_var
  1407.             (ptr, &length, objid, oidlen, return_len, return_type));
  1408. }
  1411. static u_char  *
  1412. smux_parse_var(u_char * varbind,
  1413.                size_t * varbindlength,
  1414.                oid * objid,
  1415.                size_t * oidlen, size_t * varlength, u_char * vartype)
  1416. {
  1417.     oid             var_name[MAX_OID_LEN];
  1418.     size_t          var_name_len;
  1419.     size_t          var_val_len;
  1420.     u_char         *var_val;
  1421.     size_t          str_len, objid_len;
  1422.     size_t          len;
  1423.     u_char         *ptr;
  1424.     u_char          type;
  1426.     ptr = varbind;
  1427.     len = *varbindlength;
  1429.     DEBUGMSGTL(("smux", "[smux_parse_var] before any processing: "));
  1430.     DEBUGMSGOID(("smux", objid, *oidlen));
  1431.     DEBUGMSG(("smux", "n"));
  1433.     ptr = asn_parse_header(ptr, &len, &type);
  1434.     if (ptr == NULL || type != (ASN_SEQUENCE | ASN_CONSTRUCTOR)) {
  1435.         snmp_log(LOG_NOTICE, "[smux_parse_var] Panic: type %dn",
  1436.                  (int) type);
  1437.         return NULL;
  1438.     }
  1440.     /*
  1441.      * get hold of the objid and the asn1 coded value 
  1442.      */
  1443.     var_name_len = MAX_OID_LEN;
  1444.     ptr = snmp_parse_var_op(ptr, var_name, &var_name_len, vartype,
  1445.                             &var_val_len, &var_val, &len);
  1447.     *oidlen = var_name_len;
  1448.     memcpy(objid, var_name, var_name_len * sizeof(oid));
  1450.     DEBUGMSGTL(("smux", "[smux_parse_var] returning oid : "));
  1451.     DEBUGMSGOID(("smux", objid, *oidlen));
  1452.     DEBUGMSG(("smux", "n"));
  1453.     /*
  1454.      * XXX 
  1455.      */
  1456.     len = SMUXMAXPKTSIZE;
  1457.     DEBUGMSGTL(("smux",
  1458.                 "[smux_parse_var] Asn coded len of var %d, type %dn",
  1459.                 var_val_len, (int) *vartype));
  1461.     switch ((short) *vartype) {
  1462.     case ASN_INTEGER:
  1463.         *varlength = sizeof(long);
  1464.         asn_parse_int(var_val, &len, vartype,
  1465.                       (long *) &smux_long, *varlength);
  1466.         return (u_char *) & smux_long;
  1467.         break;
  1468.     case ASN_COUNTER:
  1469.     case ASN_GAUGE:
  1470.     case ASN_TIMETICKS:
  1471.     case ASN_UINTEGER:
  1472.         *varlength = sizeof(u_long);
  1473.         asn_parse_unsigned_int(var_val, &len, vartype,
  1474.                                (u_long *) & smux_ulong, *varlength);
  1475.         return (u_char *) & smux_ulong;
  1476.         break;
  1477.     case ASN_COUNTER64:
  1478.         *varlength = sizeof(smux_counter64);
  1479.         asn_parse_unsigned_int64(var_val, &len, vartype,
  1480.                                  (struct counter64 *) &smux_counter64,
  1481.                                  *varlength);
  1482.         return (u_char *) & smux_counter64;
  1483.         break;
  1484.     case ASN_IPADDRESS:
  1485.         *varlength = 4;
  1486.         /*
  1487.          * consume the tag and length, but just copy here
  1488.          * because we know it is an ip address
  1489.          */
  1490.         if ((var_val = asn_parse_header(var_val, &len, &type)) == NULL)
  1491.             return NULL;
  1492.         memcpy((u_char *) & (smux_sa.sin_addr.s_addr), var_val,
  1493.                *varlength);
  1494.         return (u_char *) & (smux_sa.sin_addr.s_addr);
  1495.         break;
  1496.     case ASN_OCTET_STR:
  1497.         /*
  1498.          * XXX 
  1499.          */
  1500.         if (len == 0)
  1501.             return NULL;
  1502.         str_len = SMUXMAXSTRLEN;
  1503.         asn_parse_string(var_val, &len, vartype, smux_str, &str_len);
  1504.         *varlength = str_len;
  1505.         return smux_str;
  1506.         break;
  1507.     case ASN_OPAQUE:
  1508.     case ASN_NSAP:
  1509.     case ASN_OBJECT_ID:
  1510.         objid_len = MAX_OID_LEN;
  1511.         asn_parse_objid(var_val, &len, vartype, smux_objid, &objid_len);
  1512.         *varlength = objid_len * sizeof(oid);
  1513.         return (u_char *) smux_objid;
  1514.         break;
  1515.     case SNMP_NOSUCHOBJECT:
  1516.     case SNMP_NOSUCHINSTANCE:
  1517.     case SNMP_ENDOFMIBVIEW:
  1518.     case ASN_NULL:
  1519.         return NULL;
  1520.         break;
  1521.     case ASN_BIT_STR:
  1522.         /*
  1523.          * XXX 
  1524.          */
  1525.         if (len == 0)
  1526.             return NULL;
  1527.         str_len = SMUXMAXSTRLEN;
  1528.         asn_parse_bitstring(var_val, &len, vartype, smux_str, &str_len);
  1529.         *varlength = str_len;
  1530.         return (u_char *) smux_str;
  1531.         break;
  1532.     default:
  1533.         snmp_log(LOG_ERR, "bad type returned (%x)n", *vartype);
  1534.         return NULL;
  1535.         break;
  1536.     }
  1537. }
  1539. /*
  1540.  * XXX This is a bad hack - do not want to muck with ucd code 
  1541.  */
  1542. static int
  1543. smux_build(u_char type,
  1544.            long reqid,
  1545.            oid * objid,
  1546.            size_t * oidlen,
  1547.            u_char val_type,
  1548.            u_char * val, size_t val_len, u_char * packet, size_t * length)
  1549. {
  1550.     u_char         *ptr, *save1, *save2;
  1551.     size_t          len;
  1552.     long            errstat = 0;
  1553.     long            errindex = 0;
  1555.     /*
  1556.      * leave space for Seq and length 
  1557.      */
  1558.     save1 = packet;
  1559.     ptr = packet + 4;
  1560.     len = *length - 4;
  1562.     /*
  1563.      * build reqid 
  1564.      */
  1565.     ptr = asn_build_int(ptr, &len,
  1566.                                  (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1567.                                            ASN_INTEGER), &reqid,
  1568.                                  sizeof(reqid));
  1569.     if (ptr == NULL) {
  1570.         return -1;
  1571.     }
  1573.     /*
  1574.      * build err stat 
  1575.      */
  1576.     ptr = asn_build_int(ptr, &len,
  1577.                         (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1578.                                   ASN_INTEGER), &errstat, sizeof(errstat));
  1579.     if (ptr == NULL) {
  1580.         return -1;
  1581.     }
  1583.     /*
  1584.      * build err index 
  1585.      */
  1586.     ptr = asn_build_int(ptr, &len,
  1587.                         (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1588.                                   ASN_INTEGER), &errindex,
  1589.                         sizeof(errindex));
  1590.     if (ptr == NULL) {
  1591.         return -1;
  1592.     }
  1594.     save2 = ptr;
  1595.     ptr += 4;
  1596.     len -= 4;
  1598.     if (type != SMUX_SET) {
  1599.         val_type = ASN_NULL;
  1600.         val_len = 0;
  1601.     }
  1603.     /*
  1604.      * build var list : snmp_build_var_op not liked by gated XXX 
  1605.      */
  1606.     ptr = snmp_build_var_op(ptr, objid, oidlen, val_type, val_len,
  1607.                             val, &len);
  1608.     if (ptr == NULL) {
  1609.         return -1;
  1610.     }
  1612.     len = ptr - save1;
  1613.     asn_build_sequence(save1, &len, type, (ptr - save1 - 4));
  1615.     len = ptr - save2;
  1616.     asn_build_sequence(save2, &len,
  1617.                        (ASN_SEQUENCE | ASN_CONSTRUCTOR),
  1618.                        (ptr - save2 - 4));
  1620.     *length = ptr - packet;
  1622.     return 0;
  1623. }
  1625. static void
  1626. smux_peer_cleanup(int sd)
  1627. {
  1628.     smux_reg       *nrptr, *rptr, *rptr2;
  1629.     int             nfound, i;
  1631.     nfound = 0;
  1633.     /*
  1634.      * close the descriptor 
  1635.      */
  1636.     close(sd);
  1638.     /*
  1639.      * delete all of the passive registrations that this peer owns 
  1640.      */
  1641.     for (rptr = PassiveRegs; rptr; rptr = nrptr) {
  1642.         nrptr = rptr->sr_next;
  1643.         if (rptr->sr_fd == sd) {
  1644.             smux_list_detach(&PassiveRegs, &rptr);
  1645.             free(rptr);
  1646.         }
  1647.         rptr = nrptr;
  1648.     }
  1649.     /*
  1650.      * find replacements for all of the active registrations found 
  1651.      */
  1652.     for (rptr = ActiveRegs; rptr; rptr = rptr2) {
  1653.         rptr2 = rptr->sr_next;
  1654.         if (rptr->sr_fd == sd) {
  1655.             smux_list_detach(&ActiveRegs, &rptr);
  1656.             unregister_mib(rptr->sr_name, rptr->sr_name_len);
  1657.             if ((nrptr = smux_find_replacement(rptr->sr_name,
  1658.                                                rptr->sr_name_len)) !=
  1659.                 NULL) {
  1660.                 smux_list_detach(&PassiveRegs, &nrptr);
  1661.                 smux_list_add(&ActiveRegs, nrptr);
  1662.                 register_mib("smux", (struct variable *)
  1663.                              smux_variables, sizeof(struct variable2),
  1664.                              1, nrptr->sr_name, nrptr->sr_name_len);
  1665.             }
  1666.             free(rptr);
  1667.         }
  1668.     }
  1670.     /*
  1671.      * decrement the peer count 
  1672.      */
  1673.     npeers--;
  1675.     /*
  1676.      * make his auth available again 
  1677.      */
  1678.     for (i = 0; i < nauths; i++) {
  1679.         if (Auths[i]->sa_active_fd == sd) {
  1680.             char            oid_name[128];
  1681.             Auths[i]->sa_active_fd = -1;
  1682.             snprint_objid(oid_name, sizeof(oid_name), Auths[i]->sa_oid,
  1683.                           Auths[i]->sa_oid_len);
  1684.             snmp_log(LOG_INFO, "peer disconnected: %sn", oid_name);
  1685.         }
  1686.     }
  1687. }
  1689. int
  1690. smux_send_rrsp(int sd, int pri)
  1691. {
  1692.     u_char          outdata[2 + sizeof(int)];
  1693.     u_char         *ptr = outdata;
  1694.     int             intsize = sizeof(int);
  1695.     u_int           mask = ((u_int) 0xFF) << (8 * (sizeof(int) - 1));
  1696.     /*
  1697.      * e.g. mask is 0xFF000000 on a 32-bit machine 
  1698.      */
  1699.     int             sent;
  1701.     /*
  1702.      * This is kind of like calling asn_build_int(), but the
  1703.      * encoding will always be the size of an integer on this
  1704.      * machine, never shorter.
  1705.      */
  1706.     *ptr++ = (u_char) SMUX_RRSP;
  1707.     *ptr++ = (u_char) intsize;
  1709.     /*
  1710.      * Copy each byte, most significant first. 
  1711.      */
  1712.     while (intsize--) {
  1713.         *ptr++ = (u_char) ((pri & mask) >> (8 * (sizeof(int) - 1)));
  1714.         pri <<= 8;
  1715.     }
  1717.     sent = send(sd, (char *) outdata, sizeof outdata, 0);
  1718.     if (sent < 0) {
  1719.         DEBUGMSGTL(("smux", "[smux_send_rrsp] send failedn"));
  1720.     }
  1721.     return (sent);
  1722. }
  1724. static u_char  *
  1725. smux_trap_process(u_char * rsp, size_t * len)
  1726. {
  1727.     oid             sa_enterpriseoid[MAX_OID_LEN], var_name[MAX_OID_LEN];
  1728.     size_t          datalen, var_name_len, var_val_len, maxlen;
  1729.     size_t          sa_enterpriseoid_len;
  1730.     u_char          vartype, *ptr, *var_val;
  1732.     long            trap, specific;
  1733.     u_long          timestamp;
  1735.     netsnmp_variable_list *snmptrap_head, *snmptrap_ptr, *snmptrap_tmp;
  1736.     snmptrap_head = NULL;
  1737.     snmptrap_ptr = NULL;
  1739.     ptr = rsp;
  1741.     /*
  1742.      * parse the sub-agent enterprise oid 
  1743.      */
  1744.     sa_enterpriseoid_len = MAX_OID_LEN;
  1745.     if ((ptr = asn_parse_objid(ptr, len,
  1746.                                &vartype, (oid *) & sa_enterpriseoid,
  1747.                                &sa_enterpriseoid_len)) == NULL) {
  1748.         DEBUGMSGTL(("smux",
  1749.                     "[smux_trap_process] asn_parse_objid failedn"));
  1750.         return NULL;
  1751.     }
  1753.     /*
  1754.      * parse the agent-addr ipAddress 
  1755.      */
  1756.     datalen = SMUXMAXSTRLEN;
  1757.     if (((ptr = asn_parse_string(ptr, len,
  1758.                                  &vartype, smux_str,
  1759.                                  &datalen)) == NULL) ||
  1760.         (vartype != (u_char) ASN_IPADDRESS)) {
  1761.         DEBUGMSGTL(("smux",
  1762.                     "[smux_trap_process] asn_parse_string failedn"));
  1763.         return NULL;
  1764.     }
  1766.     /*
  1767.      * parse the generic trap int 
  1768.      */
  1769.     datalen = sizeof(long);
  1770.     if ((ptr = asn_parse_int(ptr, len, &vartype, &trap, datalen)) == NULL) {
  1771.         DEBUGMSGTL(("smux",
  1772.                     "[smux_trap_process] asn_parse_int generic failedn"));
  1773.         return NULL;
  1774.     }
  1776.     /*
  1777.      * parse the specific trap int 
  1778.      */
  1779.     datalen = sizeof(long);
  1780.     if ((ptr = asn_parse_int(ptr, len,
  1781.                              &vartype, &specific, datalen)) == NULL) {
  1782.         DEBUGMSGTL(("smux",
  1783.                     "[smux_trap_process] asn_parse_int specific failedn"));
  1784.         return NULL;
  1785.     }
  1787.     /*
  1788.      * parse the timeticks timestamp 
  1789.      */
  1790.     datalen = sizeof(u_long);
  1791.     if (((ptr = asn_parse_unsigned_int(ptr, len,
  1792.                                        &vartype, (u_long *) & timestamp,
  1793.                                        datalen)) == NULL) ||
  1794.         (vartype != (u_char) ASN_TIMETICKS)) {
  1795.         DEBUGMSGTL(("smux",
  1796.                     "[smux_trap_process] asn_parse_unsigned_int (timestamp) failedn"));
  1797.         return NULL;
  1798.     }
  1800.     /*
  1801.      * parse out the overall sequence 
  1802.      */
  1803.     ptr = asn_parse_header(ptr, len, &vartype);
  1804.     if (ptr == NULL || vartype != (ASN_SEQUENCE | ASN_CONSTRUCTOR)) {
  1805.         return NULL;
  1806.     }
  1808.     /*
  1809.      * parse the variable bindings 
  1810.      */
  1811.     while (ptr && *len) {
  1813.         /*
  1814.          * get the objid and the asn1 coded value 
  1815.          */
  1816.         var_name_len = MAX_OID_LEN;
  1817.         ptr = snmp_parse_var_op(ptr, var_name, &var_name_len, &vartype,
  1818.                                 &var_val_len, (u_char **) & var_val, len);
  1820.         if (ptr == NULL) {
  1821.             return NULL;
  1822.         }
  1824.         maxlen = SMUXMAXPKTSIZE;
  1825.         switch ((short) vartype) {
  1826.         case ASN_INTEGER:
  1827.             var_val_len = sizeof(long);
  1828.             asn_parse_int(var_val, &maxlen, &vartype,
  1829.                           (long *) &smux_long, var_val_len);
  1830.             var_val = (u_char *) & smux_long;
  1831.             break;
  1832.         case ASN_COUNTER:
  1833.         case ASN_GAUGE:
  1834.         case ASN_TIMETICKS:
  1835.         case ASN_UINTEGER:
  1836.             var_val_len = sizeof(u_long);
  1837.             asn_parse_unsigned_int(var_val, &maxlen, &vartype,
  1838.                                    (u_long *) & smux_ulong, var_val_len);
  1839.             var_val = (u_char *) & smux_ulong;
  1840.             break;
  1841.         case ASN_COUNTER64:
  1842.             var_val_len = sizeof(smux_counter64);
  1843.             asn_parse_unsigned_int64(var_val, &maxlen, &vartype,
  1844.                                      (struct counter64 *) &smux_counter64,
  1845.                                      var_val_len);
  1846.             var_val = (u_char *) & smux_counter64;
  1847.             break;
  1848.         case ASN_IPADDRESS:
  1849.             var_val_len = 4;
  1850.             /*
  1851.              * consume the tag and length, but just copy here
  1852.              * because we know it is an ip address
  1853.              */
  1854.             if ((var_val =
  1855.                  asn_parse_header(var_val, &maxlen, &vartype)) == NULL)
  1856.                 return NULL;
  1857.             memcpy((u_char *) & (smux_sa.sin_addr.s_addr), var_val,
  1858.                    var_val_len);
  1859.             var_val = (u_char *) & (smux_sa.sin_addr.s_addr);
  1860.             break;
  1861.         case ASN_OPAQUE:
  1862.         case ASN_OCTET_STR:
  1863.             /*
  1864.              * XXX 
  1865.              */
  1866.             if (len == 0)
  1867.                 return NULL;
  1868.             var_val_len = SMUXMAXSTRLEN;
  1869.             asn_parse_string(var_val, &maxlen, &vartype,
  1870.                              smux_str, &var_val_len);
  1871.             var_val = smux_str;
  1872.             break;
  1873.         case ASN_OBJECT_ID:
  1874.             var_val_len = MAX_OID_LEN;
  1875.             asn_parse_objid(var_val, &maxlen, &vartype,
  1876.                             smux_objid, &var_val_len);
  1877.             var_val_len *= sizeof(oid);
  1878.             var_val = (u_char *) smux_objid;
  1879.             break;
  1880.         case SNMP_NOSUCHOBJECT:
  1881.         case SNMP_NOSUCHINSTANCE:
  1882.         case SNMP_ENDOFMIBVIEW:
  1883.         case ASN_NULL:
  1884.             var_val = NULL;
  1885.             break;
  1886.         case ASN_BIT_STR:
  1887.             /*
  1888.              * XXX 
  1889.              */
  1890.             if (len == 0)
  1891.                 return NULL;
  1892.             var_val_len = SMUXMAXSTRLEN;
  1893.             asn_parse_bitstring(var_val, &maxlen, &vartype,
  1894.                                 smux_str, &var_val_len);
  1895.             var_val = (u_char *) smux_str;
  1896.             break;
  1897.         case ASN_NSAP:
  1898.         default:
  1899.             snmp_log(LOG_ERR, "bad type returned (%x)n", vartype);
  1900.             var_val = NULL;
  1901.             break;
  1902.         }
  1904.         snmptrap_tmp =
  1905.             (netsnmp_variable_list *)
  1906.             malloc(sizeof(netsnmp_variable_list));
  1907.         if (snmptrap_tmp == NULL)
  1908.             return NULL;
  1909.         memset(snmptrap_tmp, 0, sizeof(netsnmp_variable_list));
  1910.         if (snmptrap_head == NULL) {
  1911.             snmptrap_head = snmptrap_tmp;
  1912.             snmptrap_ptr = snmptrap_head;
  1913.         } else {
  1914.             snmptrap_ptr->next_variable = snmptrap_tmp;
  1915.             snmptrap_ptr = snmptrap_ptr->next_variable;
  1916.         }
  1918.         snmp_set_var_objid(snmptrap_ptr, var_name, var_name_len);
  1919.         snmp_set_var_value(snmptrap_ptr, (char *) var_val, var_val_len);
  1920.         snmptrap_ptr->type = vartype;
  1921.         snmptrap_ptr->next_variable = NULL;
  1923.     }
  1925.     /*
  1926.      * send the traps 
  1927.      */
  1928.     send_enterprise_trap_vars(trap, specific, (oid *) & sa_enterpriseoid,
  1929.                               sa_enterpriseoid_len, snmptrap_head);
  1931.     /*
  1932.      * free trap variables 
  1933.      */
  1934.     snmp_free_varbind(snmptrap_head);
  1936.     return ptr;
  1938. }