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

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

SNMP编程

开发平台：

Unix_Linux

snmpUDPIPv6Domain.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #ifdef SNMP_TRANSPORT_UDPIPV6_DOMAIN
  5. /*
  6.  * hack-o-matic for Cygwin to use winsock2
  7. */
  8. #if defined(cygwin)
  9. #undef HAVE_UNISTD_H
  10. #undef HAVE_NETINET_IN_H
  11. #undef HAVE_ARPA_INET_H
  12. #undef HAVE_NET_IF_H
  13. #undef HAVE_NETDB_H
  14. #undef HAVE_SYS_PARAM_H
  15. #undef HAVE_SYS_SELECT_H
  16. #undef HAVE_SYS_SOCKET_H
  17. #undef HAVE_IN_ADDR_T
  18. #endif
  20. #include <stdio.h>
  21. #include <sys/types.h>
  22. #include <ctype.h>
  23. #include <errno.h>
  25. #if HAVE_STRING_H
  26. #include <string.h>
  27. #else
  28. #include <strings.h>
  29. #endif
  30. #if HAVE_STDLIB_H
  31. #include <stdlib.h>
  32. #endif
  33. #if HAVE_UNISTD_H
  34. #include <unistd.h>
  35. #endif
  36. #if HAVE_SYS_SOCKET_H
  37. #include <sys/socket.h>
  38. #endif
  40. #if defined(HAVE_WINSOCK_H) || defined(cygwin)
  41.     /*
  42.      *  Windows IPv6 support is part of WinSock2 only
  43.      */
  44. #include <winsock2.h>
  45. #include <ws2tcpip.h>
  46. #undef  HAVE_IF_NAMETOINDEX
  48. extern int         inet_pton(int, const char*, void*);
  49. extern const char *inet_ntop(int, const void*, char*, size_t);
  50. const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
  51. #endif
  53. #if HAVE_NETINET_IN_H
  54. #include <netinet/in.h>
  55. #endif
  56. #if HAVE_ARPA_INET_H
  57. #include <arpa/inet.h>
  58. #endif
  59. #if HAVE_NETDB_H
  60. #include <netdb.h>
  61. #endif
  62. #if HAVE_NET_IF_H
  63. #include <net/if.h>
  64. #endif
  66. #if HAVE_DMALLOC_H
  67. #include <dmalloc.h>
  68. #endif
  70. #include <net-snmp/types.h>
  71. #include <net-snmp/output_api.h>
  72. #include <net-snmp/config_api.h>
  74. #include <net-snmp/library/snmp_transport.h>
  75. #include <net-snmp/library/snmpUDPIPv6Domain.h>
  77. oid netsnmp_UDPIPv6Domain[] = { TRANSPORT_DOMAIN_UDP_IPV6 };
  78. static netsnmp_tdomain udp6Domain;
  80. /*
  81.  * from snmpUDPDomain. not static, but not public, either.
  82.  * (ie don't put it in a public header.)
  83.  */
  84. extern void _netsnmp_udp_sockopt_set(int fd, int server);
  86. /*
  87.  * Return a string representing the address in data, or else the "far end"
  88.  * address if data is NULL.  
  89.  */
  91. static char *
  92. netsnmp_udp6_fmtaddr(netsnmp_transport *t, void *data, int len)
  93. {
  94.     struct sockaddr_in6 *to = NULL;
  96.     DEBUGMSGTL(("netsnmp_udp6", "fmtaddr: t = %p, data = %p, len = %dn", t,
  97.                 data, len));
  98.     if (data != NULL && len == sizeof(struct sockaddr_in6)) {
  99.         to = (struct sockaddr_in6 *) data;
  100.     } else if (t != NULL && t->data != NULL) {
  101.         to = (struct sockaddr_in6 *) t->data;
  102.     }
  103.     if (to == NULL) {
  104.         return strdup("UDP/IPv6: unknown");
  105.     } else {
  106.         char addr[INET6_ADDRSTRLEN];
  107.         char tmp[INET6_ADDRSTRLEN + 8];
  109.         sprintf(tmp, "UDP/IPv6: [%s]:%hd",
  110.                 inet_ntop(AF_INET6, (void *) &(to->sin6_addr), addr,
  111.                           INET6_ADDRSTRLEN), ntohs(to->sin6_port));
  112.         return strdup(tmp);
  113.     }
  114. }
  118. /*
  119.  * You can write something into opaque that will subsequently get passed back 
  120.  * to your send function if you like.  For instance, you might want to
  121.  * remember where a PDU came from, so that you can send a reply there...  
  122.  */
  124. static int
  125. netsnmp_udp6_recv(netsnmp_transport *t, void *buf, int size,
  126.   void **opaque, int *olength)
  127. {
  128.     int             rc = -1;
  129.     socklen_t       fromlen = sizeof(struct sockaddr_in6);
  130.     struct sockaddr *from;
  132.     if (t != NULL && t->sock >= 0) {
  133.         from = (struct sockaddr *) malloc(sizeof(struct sockaddr_in6));
  134.         if (from == NULL) {
  135.             *opaque = NULL;
  136.             *olength = 0;
  137.             return -1;
  138.         } else {
  139.             memset(from, 0, fromlen);
  140.         }
  142. while (rc < 0) {
  143.   rc = recvfrom(t->sock, buf, size, 0, from, &fromlen);
  144.   if (rc < 0 && errno != EINTR) {
  145.     break;
  146.   }
  147. }
  149.         if (rc >= 0) {
  150.     char *str = netsnmp_udp6_fmtaddr(NULL, from, fromlen);
  151.             DEBUGMSGTL(("netsnmp_udp6",
  152. "recvfrom fd %d got %d bytes (from %s)n", t->sock,
  153.                         rc, str));
  154.             free(str);
  155.         } else {
  156.             DEBUGMSGTL(("netsnmp_udp6", "recvfrom fd %d err %d ("%s")n",
  157. t->sock, errno, strerror(errno)));
  158.         }
  159.         *opaque = (void *) from;
  160.         *olength = sizeof(struct sockaddr_in6);
  161.     }
  162.     return rc;
  163. }
  167. static int
  168. netsnmp_udp6_send(netsnmp_transport *t, void *buf, int size,
  169.   void **opaque, int *olength)
  170. {
  171.     int rc = -1;
  172.     struct sockaddr *to = NULL;
  174.     if (opaque != NULL && *opaque != NULL &&
  175.         *olength == sizeof(struct sockaddr_in6)) {
  176.         to = (struct sockaddr *) (*opaque);
  177.     } else if (t != NULL && t->data != NULL &&
  178.                t->data_length == sizeof(struct sockaddr_in6)) {
  179.         to = (struct sockaddr *) (t->data);
  180.     }
  182.     if (to != NULL && t != NULL && t->sock >= 0) {
  183.         char *str = netsnmp_udp6_fmtaddr(NULL, (void *)to,
  184.     sizeof(struct sockaddr_in6));
  185.         DEBUGMSGTL(("netsnmp_udp6", "send %d bytes from %p to %s on fd %dn",
  186.                     size, buf, str, t->sock));
  187.         free(str);
  188. while (rc < 0) {
  189.     rc = sendto(t->sock, buf, size, 0, to,sizeof(struct sockaddr_in6));
  190.     if (rc < 0 && errno != EINTR) {
  191. break;
  192.     }
  193. }
  194.     }
  195.     return rc;
  196. }
  200. static int
  201. netsnmp_udp6_close(netsnmp_transport *t)
  202. {
  203.     int rc = -1;
  204.     if (t != NULL && t->sock >= 0) {
  205.         DEBUGMSGTL(("netsnmp_udp6", "close fd %dn", t->sock));
  206. #ifndef HAVE_CLOSESOCKET
  207.         rc = close(t->sock);
  208. #else
  209.         rc = closesocket(t->sock);
  210. #endif
  211.         t->sock = -1;
  212.     }
  213.     return rc;
  214. }
  218. /*
  219.  * Open a UDP/IPv6-based transport for SNMP.  Local is TRUE if addr is the
  220.  * local address to bind to (i.e. this is a server-type session); otherwise
  221.  * addr is the remote address to send things to.  
  222.  */
  224. netsnmp_transport *
  225. netsnmp_udp6_transport(struct sockaddr_in6 *addr, int local)
  226. {
  227.     netsnmp_transport *t = NULL;
  228.     int             rc = 0;
  229.     char           *str = NULL;
  231.     if (addr == NULL || addr->sin6_family != AF_INET6) {
  232.         return NULL;
  233.     }
  235.     t = (netsnmp_transport *) malloc(sizeof(netsnmp_transport));
  236.     if (t == NULL) {
  237.         return NULL;
  238.     }
  240.     str = netsnmp_udp6_fmtaddr(NULL, (void *) addr,
  241.   sizeof(struct sockaddr_in6));
  242.     DEBUGMSGTL(("netsnmp_udp6", "open %s %sn", local ? "local" : "remote",
  243.                 str));
  244.     free(str);
  246.     memset(t, 0, sizeof(netsnmp_transport));
  248.     t->domain = netsnmp_UDPIPv6Domain;
  249.     t->domain_length =
  250.         sizeof(netsnmp_UDPIPv6Domain) / sizeof(netsnmp_UDPIPv6Domain[0]);
  252.     t->sock = socket(PF_INET6, SOCK_DGRAM, 0);
  253.     if (t->sock < 0) {
  254.         netsnmp_transport_free(t);
  255.         return NULL;
  256.     }
  258.     _netsnmp_udp_sockopt_set(t->sock, local);
  260.     if (local) {
  261.         /*
  262.          * This session is inteneded as a server, so we must bind on to the
  263.          * given IP address, which may include an interface address, or could
  264.          * be INADDR_ANY, but certainly includes a port number.
  265.          */
  267. #ifdef IPV6_V6ONLY
  268.         /* Try to restrict PF_INET6 socket to IPv6 communications only. */
  269.         {
  270.   int one=1;
  271.   if (setsockopt(t->sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&one, sizeof(one)) != 0) {
  272.     DEBUGMSGTL(("netsnmp_udp6", "couldn't set IPV6_V6ONLY to %d bytes: %sn", one, strerror(errno)));
  273.   } 
  274. }
  275. #endif
  277.         rc = bind(t->sock, (struct sockaddr *) addr,
  278.   sizeof(struct sockaddr_in6));
  279.         if (rc != 0) {
  280.             netsnmp_udp6_close(t);
  281.             netsnmp_transport_free(t);
  282.             return NULL;
  283.         }
  284.         t->local = malloc(18);
  285.         if (t->local == NULL) {
  286.             netsnmp_udp6_close(t);
  287.             netsnmp_transport_free(t);
  288.             return NULL;
  289.         }
  290.         memcpy(t->local, addr->sin6_addr.s6_addr, 16);
  291.         t->local[16] = (addr->sin6_port & 0xff00) >> 8;
  292.         t->local[17] = (addr->sin6_port & 0x00ff) >> 0;
  293.         t->local_length = 18;
  294.         t->data = NULL;
  295.         t->data_length = 0;
  296.     } else {
  297.         /*
  298.          * This is a client session.  Save the address in the
  299.          * transport-specific data pointer for later use by netsnmp_udp6_send.
  300.          */
  302.         t->data = malloc(sizeof(struct sockaddr_in6));
  303.         if (t->data == NULL) {
  304.             netsnmp_udp6_close(t);
  305.             netsnmp_transport_free(t);
  306.             return NULL;
  307.         }
  308.         memcpy(t->data, addr, sizeof(struct sockaddr_in6));
  309.         t->data_length = sizeof(struct sockaddr_in6);
  310.         t->remote = malloc(18);
  311.         if (t->remote == NULL) {
  312.             netsnmp_udp6_close(t);
  313.             netsnmp_transport_free(t);
  314.             return NULL;
  315.         }
  316.         memcpy(t->remote, addr->sin6_addr.s6_addr, 16);
  317.         t->remote[16] = (addr->sin6_port & 0xff00) >> 8;
  318.         t->remote[17] = (addr->sin6_port & 0x00ff) >> 0;
  319.         t->remote_length = 18;
  320.     }
  322.     /*
  323.      * 16-bit length field, 8 byte UDP header, 40 byte IPv6 header.  
  324.      */
  326.     t->msgMaxSize = 0xffff - 8 - 40;
  327.     t->f_recv     = netsnmp_udp6_recv;
  328.     t->f_send     = netsnmp_udp6_send;
  329.     t->f_close    = netsnmp_udp6_close;
  330.     t->f_accept   = NULL;
  331.     t->f_fmtaddr  = netsnmp_udp6_fmtaddr;
  333.     return t;
  334. }
  338. int
  339. netsnmp_sockaddr_in6(struct sockaddr_in6 *addr,
  340.                      const char *inpeername, int remote_port)
  341. {
  342.     char           *cp = NULL, *peername = NULL;
  343.     char            debug_addr[INET6_ADDRSTRLEN];
  344. #if HAVE_GETADDRINFO
  345.     struct addrinfo *addrs = NULL;
  346.     struct addrinfo hint;
  347.     int             err;
  348. #elif HAVE_GETIPNODEBYNAME
  349.     struct hostent *hp = NULL;
  350.     int             err;
  351. #elif HAVE_GETHOSTBYNAME
  352.     struct hostent *hp = NULL;
  353. #endif
  355.     if (addr == NULL) {
  356.         return 0;
  357.     }
  359.     DEBUGMSGTL(("netsnmp_sockaddr_in6", "addr %p, peername "%s"n",
  360.                 addr, inpeername ? inpeername : "[NIL]"));
  362.     memset(addr, 0, sizeof(struct sockaddr_in6));
  363.     addr->sin6_family = AF_INET6;
  364.     addr->sin6_addr = in6addr_any;
  366.     if (remote_port > 0) {
  367.         addr->sin6_port = htons(remote_port);
  368.     } else if (netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
  369.   NETSNMP_DS_LIB_DEFAULT_PORT) > 0) {
  370.         addr->sin6_port = htons(netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
  371.  NETSNMP_DS_LIB_DEFAULT_PORT));
  372.     } else {
  373.         addr->sin6_port = htons(SNMP_PORT);
  374.     }
  376.     if (inpeername != NULL) {
  377.         /*
  378.          * Duplicate the peername because we might want to mank around with
  379.          * it.  
  380.          */
  382.         peername = strdup(inpeername);
  383.         if (peername == NULL) {
  384.             return 0;
  385.         }
  387.         for (cp = peername; *cp && isdigit((int) *cp); cp++);
  388.         if (!*cp && atoi(peername) != 0) {
  389.             /*
  390.              * Okay, it looks like JUST a port number.  
  391.              */
  392.             DEBUGMSGTL(("netsnmp_sockaddr_in6", "totally numeric: %dn",
  393.                         atoi(peername)));
  394.             addr->sin6_port = htons(atoi(peername));
  395.             goto resolved;
  396.         }
  398.         /*
  399.          * See if it is an IPv6 address, which covered with square brankets
  400.          * with an appended :port.  
  401.          */
  402.         if (*peername == '[') {
  403.             cp = strchr(peername, ']');
  404.             if (cp != NULL) {
  405.       /*
  406.        * See if it is an IPv6 link-local address with interface
  407.        * name as <zone_id>, like fe80::1234%eth0.
  408.        * Please refer to the internet draft, IPv6 Scoped Address Architecture
  409.        * http://www.ietf.org/internet-drafts/draft-ietf-ipngwg-scoping-arch-04.txt
  410.        *
  411.        */
  412.         char *scope_id;
  413. #ifdef HAVE_IF_NAMETOINDEX
  414.         unsigned int if_index = 0;
  415. #endif
  416.                 *cp = '';
  417. scope_id = strchr(peername + 1, '%');
  418. if (scope_id != NULL) {
  419.     *scope_id = '';
  420. #ifdef HAVE_IF_NAMETOINDEX
  421.     if_index = if_nametoindex(scope_id + 1);
  422. #endif
  423. }
  424.                 if (*(cp + 1) == ':') {
  425.                     if (atoi(cp + 2) != 0 &&
  426.                         inet_pton(AF_INET6, peername + 1,
  427.                                   (void *) &(addr->sin6_addr))) {
  428.                         DEBUGMSGTL(("netsnmp_sockaddr_in6",
  429.                                     "IPv6 address with port suffix :%dn",
  430.                                     atoi(cp + 2)));
  431.                         addr->sin6_port = htons(atoi(cp + 2));
  432. #ifdef HAVE_IF_NAMETOINDEX
  433.                         addr->sin6_scope_id = if_index;
  434. #endif
  435.                         goto resolved;
  436.                     }
  437.                 } else {
  438.                     if (inet_pton
  439.                         (AF_INET6, peername + 1,
  440.                          (void *) &(addr->sin6_addr))) {
  441.                         DEBUGMSGTL(("netsnmp_sockaddr_in6",
  442.                                     "IPv6 address with square branketsn"));
  443.                         addr->sin6_port = htons(SNMP_PORT);
  444. #ifdef HAVE_IF_NAMETOINDEX
  445.                         addr->sin6_scope_id = if_index;
  446. #endif
  447.                         goto resolved;
  448.                     }
  449.                 }
  450. if (scope_id != NULL) {
  451.   *scope_id = '%';
  452. }
  453. *cp = ']';
  454.             }
  455.         }
  457.         cp = strrchr(peername, ':');
  458.         if (cp != NULL) {
  459.     char *scope_id;
  460. #ifdef HAVE_IF_NAMETOINDEX
  461.     unsigned int if_index = 0;
  462. #endif
  463.     *cp = '';
  464.     scope_id = strchr(peername + 1, '%');
  465.     if (scope_id != NULL) {
  466.         *scope_id = '';
  467. #ifdef HAVE_IF_NAMETOINDEX
  468.         if_index = if_nametoindex(scope_id + 1);
  469. #endif
  470.     }
  471.             if (atoi(cp + 1) != 0 &&
  472.                 inet_pton(AF_INET6, peername,
  473.                           (void *) &(addr->sin6_addr))) {
  474.                 DEBUGMSGTL(("netsnmp_sockaddr_in6",
  475.                             "IPv6 address with port suffix :%dn",
  476.                             atoi(cp + 1)));
  477.                 addr->sin6_port = htons(atoi(cp + 1));
  478. #ifdef HAVE_IF_NAMETOINDEX
  479.                 addr->sin6_scope_id = if_index;
  480. #endif
  481.                 goto resolved;
  482.             }
  483.     if (scope_id != NULL) {
  484.       *scope_id = '%';
  485.     }
  486.             *cp = ':';
  487.         }
  489.         /*
  490.          * See if it is JUST an IPv6 address.  
  491.          */
  492.         if (inet_pton(AF_INET6, peername, (void *) &(addr->sin6_addr))) {
  493.             DEBUGMSGTL(("netsnmp_sockaddr_in6", "just IPv6 addressn"));
  494.             goto resolved;
  495.         }
  497.         /*
  498.          * Well, it must be a hostname then, possibly with an appended :port.
  499.          * Sort that out first.  
  500.          */
  502.         cp = strrchr(peername, ':');
  503.         if (cp != NULL) {
  504.             *cp = '';
  505.             if (atoi(cp + 1) != 0) {
  506.                 DEBUGMSGTL(("netsnmp_sockaddr_in6",
  507.                             "hostname(?) with port suffix :%dn",
  508.                             atoi(cp + 1)));
  509.                 addr->sin6_port = htons(atoi(cp + 1));
  510.             } else {
  511.                 /*
  512.                  * No idea, looks bogus but we might as well pass the full thing to
  513.                  * the name resolver below.  
  514.                  */
  515.                 *cp = ':';
  516.                 DEBUGMSGTL(("netsnmp_sockaddr_in6",
  517.                             "hostname(?) with embedded ':'?n"));
  518.             }
  519.             /*
  520.              * Fall through.  
  521.              */
  522.         }
  523. #if HAVE_GETADDRINFO
  524.         memset(&hint, 0, sizeof hint);
  525.         hint.ai_flags = 0;
  526.         hint.ai_family = PF_INET6;
  527.         hint.ai_socktype = SOCK_DGRAM;
  528.         hint.ai_protocol = 0;
  530.         err = getaddrinfo(peername, NULL, &hint, &addrs);
  531.         if (err != 0) {
  532.             snmp_log(LOG_ERR, "getaddrinfo: %s %sn", peername,
  533.                      gai_strerror(err));
  534.             free(peername);
  535.             return 0;
  536.         }
  537.         if (addrs != NULL) {
  538.         DEBUGMSGTL(("netsnmp_sockaddr_in6", "hostname (resolved okay)n"));
  539.         memcpy(&addr->sin6_addr,
  540.                &((struct sockaddr_in6 *) addrs->ai_addr)->sin6_addr,
  541.                sizeof(struct in6_addr));
  542. freeaddrinfo(addrs);
  543.         }
  544. else {
  545.         DEBUGMSGTL(("netsnmp_sockaddr_in6", "Failed to resolve IPv6 hostnamen"));
  546. }
  547. #elif HAVE_GETIPNODEBYNAME
  548.         hp = getipnodebyname(peername, AF_INET6, 0, &err);
  549.         if (hp == NULL) {
  550.             DEBUGMSGTL(("netsnmp_sockaddr_in6",
  551.                         "hostname (couldn't resolve = %d)n", err));
  552.             free(peername);
  553.             return 0;
  554.         }
  555.         DEBUGMSGTL(("netsnmp_sockaddr_in6", "hostname (resolved okay)n"));
  556.         memcpy(&(addr->sin6_addr), hp->h_addr, hp->h_length);
  557. #elif HAVE_GETHOSTBYNAME
  558.         hp = gethostbyname(peername);
  559.         if (hp == NULL) {
  560.             DEBUGMSGTL(("netsnmp_sockaddr_in6",
  561.                         "hostname (couldn't resolve)n"));
  562.             free(peername);
  563.             return 0;
  564.         } else {
  565.             if (hp->h_addrtype != AF_INET6) {
  566.                 DEBUGMSGTL(("netsnmp_sockaddr_in6",
  567.                             "hostname (not AF_INET6!)n"));
  568.                 free(peername);
  569.                 return 0;
  570.             } else {
  571.                 DEBUGMSGTL(("netsnmp_sockaddr_in6",
  572.                             "hostname (resolved okay)n"));
  573.                 memcpy(&(addr->sin6_addr), hp->h_addr, hp->h_length);
  574.             }
  575.         }
  576. #else                           /*HAVE_GETHOSTBYNAME */
  577.         /*
  578.          * There is no name resolving function available.  
  579.          */
  580.         snmp_log(LOG_ERR,
  581.                  "no getaddrinfo()/getipnodebyname()/gethostbyname()n");
  582.         free(peername);
  583.         return 0;
  584. #endif                          /*HAVE_GETHOSTBYNAME */
  585.     } else {
  586.         DEBUGMSGTL(("netsnmp_sockaddr_in6", "NULL peername"));
  587.         return 0;
  588.     }
  590.   resolved:
  591.     DEBUGMSGTL(("netsnmp_sockaddr_in6", "return { AF_INET6, [%s]:%hu }n",
  592.                 inet_ntop(AF_INET6, &addr->sin6_addr, debug_addr,
  593.                           sizeof(debug_addr)), ntohs(addr->sin6_port)));
  594.     free(peername);
  595.     return 1;
  596. }
  599. /*
  600.  * int
  601.  * inet_make_mask_addr( int pf, void *dst, int masklength )
  602.  *      convert from bit length specified masklength to network format, 
  603.  *      which fills 1 from until specified bit length.
  604.  *      dst is usally the structer of sockaddr_in or sockaddr_in6. 
  605.  *      makelength must be an interger from 0 to 32 if pf is PF_INET,
  606.  *      or from 0 to 128 if pf is PF_INET6.
  607.  * return:
  608.  *      0 if the input data, masklength was valid for 
  609.  *      the specified protocol family.
  610.  *      -1 if the the input data wasn't valid.
  611.  */
  613. int
  614. inet_make_mask_addr(int pf, void *dst, int masklength)
  615. {
  617.     unsigned long   Mask = 0;
  618.     int             maskBit = 0x80000000L;
  619.     unsigned char   mask = 0;
  620.     unsigned char   maskbit = 0x80L;
  621.     int             i, j, jj;
  624.     switch (pf) {
  625.     case PF_INET:
  626.         if (masklength < 0 || masklength > 32)
  627.             return -1;
  629.         ((struct in_addr *) dst)->s_addr = 0;
  631.         while (masklength--) {
  632.             Mask |= maskBit;
  633.             maskBit >>= 1;
  634.         }
  635.         ((struct in_addr *) dst)->s_addr = htonl(Mask);
  636.         break;
  638.     case PF_INET6:
  639.         if (masklength < 0 || masklength > 128)
  640.             return -1;
  643.         for (i = 0; i < 16; i++) {
  644.             (*(u_char *) (&((struct in6_addr *) dst)->s6_addr[i])) = 0x00;
  645.         }
  647.         j = (int) masklength / 8;
  648.         jj = masklength % 8;
  650.         for (i = 0; i < j; i++) {
  651.             (*(u_char *) (&((struct in6_addr *) dst)->s6_addr[i])) = 0xff;
  652.         }
  653.         while (jj--) {
  654.             mask |= maskbit;
  655.             maskbit >>= 1;
  656.         }
  657.         (*(u_char *) (&((struct in6_addr *) dst)->s6_addr[j])) = mask;
  658.         break;
  659.     default:
  660.         return -1;              /* unsupported protocol family */
  661.     }
  662.     return 0;
  663. }
  665. /*
  666.  * int
  667.  * inet_addr_complement( int pf, void *src, void *dst )
  668.  *      convert from src to dst, which all bits 
  669.  *      are bit-compliment of src.
  670.  *      Src, dst are ususally sockaddr_in or sockaddr_in6.  
  671.  * return:
  672.  *      0 if the input data src and dst have the same size
  673.  *      -1 if the the input data wasn't valid.
  674.  */
  676. int
  677. inet_addr_complement(int pf, void *src, void *dst)
  678. {
  680.     int             i;
  682.     if (sizeof(src) != sizeof(dst))
  683.         return -1;
  685.     switch (pf) {
  686.     case PF_INET:
  687.         ((struct in_addr *) dst)->s_addr =
  688.             ~((struct in_addr *) src)->s_addr;
  689.         break;
  690.     case PF_INET6:
  691.         for (i = 0; i < 16; i++) {
  692.             (*(u_char *) (&((struct in6_addr *) dst)->s6_addr[i])) =
  693.                 (~(*(u_char *) (&((struct in6_addr *) src)->s6_addr[i])))
  694.                 & 0xff;
  695.         }
  696.         break;
  697.     default:
  698.         return -1;
  699.     }
  700.     return 0;
  701. }
  703. /*
  704.  * int
  705.  * inet_addr_and( int pf, void *src1, void *src2, void *dst) 
  706.  *      take AND operation on src1 and src2, and output the result to dst.
  707.  *      Src1, src2, and dst are ususally sockaddr_in or sockaddr_in6.  
  708.  * return:
  709.  *      0 if the input data src and dst have the same size
  710.  *      -1 if the the input data are not the same size
  711.  */
  713. int
  714. inet_addr_and(int pf, void *src1, void *src2, void *dst)
  715. {
  716.     int             i;
  718.     if (sizeof(src1) != sizeof(src2) || sizeof(src2) != sizeof(dst))
  719.         return -1;
  721.     switch (pf) {
  722.     case PF_INET:
  723.         ((struct in_addr *) dst)->s_addr =
  724.             ((struct in_addr *) src1)->s_addr & ((struct in_addr *) src2)->
  725.             s_addr;
  726.         break;
  728.     case PF_INET6:
  729.         for (i = 0; i < 16; i++) {
  730.             (*(u_char *) (&((struct in6_addr *) dst)->s6_addr[i])) =
  731.                 (*(u_char *) (&((struct in6_addr *) src1)->s6_addr[i])) &
  732.                 (*(u_char *) (&((struct in6_addr *) src2)->s6_addr[i]));
  733.         }
  734.         break;
  735.     default:
  736.         return -1;
  737.     }
  738.     return 0;
  739. }
  742. /*
  743.  * int
  744.  * inet_addrs_consistence (int pf, void *net, void *mask ) 
  745.  *      This function checks if the network address net is consistent
  746.  *      with the netmask address, mask.
  747.  *      Net and mask are ususally sockaddr_in or sockaddr_in6.  
  748.  * Note:
  749.  *      Must spefiey protocol family in pf.
  750.  * return:
  751.  *      0 if there is no consistence with address "net" and "mask".
  752.  *      -1 if network address is inconsistent with netmask address, for 
  753.  *      instance, network address is 192.168.0.128 in spite of netmask, 
  754.  *      which is 255.255.255.0. 
  755.  *      The case that the size of net and mask are different also returns -1.
  756.  */
  758. int
  759. inet_addrs_consistence(int pf, void *net, void *mask)
  760. {
  761.     struct sockaddr_in *tmp, *dst;
  762.     struct sockaddr_in6 *tmp6, *dst6;
  763.     int             ret;
  765.     switch (pf) {
  766.     case PF_INET:
  767.         tmp = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
  768.         if (!tmp) {
  769.             config_perror("Resource failure in inet_addr_consistence()");
  770.             return -1;
  771.         }
  772.         memset(tmp, 0, sizeof(*tmp));
  773.         tmp->sin_family = PF_INET;
  774.         if (inet_addr_complement
  775.             (PF_INET, (struct in_addr *) mask, &tmp->sin_addr) != 0) {
  776.             config_perror("Fail in function of inet_addr_complement()");
  777.             free(tmp);
  778.             return -1;
  779.         }
  780.         dst = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
  781.         if (!dst) {
  782.             config_perror("Resource failure in inet_addr_consistence()");
  783.             free(tmp);
  784.             return -1;
  785.         }
  786.         memset(dst, 0, sizeof(*dst));
  787.         dst->sin_family = PF_INET;
  788.         if (inet_addr_and
  789.             (PF_INET, (struct in_addr *) net, &tmp->sin_addr,
  790.              &dst->sin_addr) != 0) {
  791.             config_perror("Fail in function of inet_addr_and()");
  792.             free(dst);
  793.             free(tmp);
  794.             return -1;
  795.         }
  796.         ret = ((dst->sin_addr.s_addr == INADDR_ANY) ? 0 : -1);
  797.         free(dst);
  798.         free(tmp);
  799.         break;
  800.     case PF_INET6:
  801.         tmp6 = (struct sockaddr_in6 *) malloc(sizeof(struct sockaddr_in6));
  802.         if (!tmp6) {
  803.             config_perror("Resource failure in inet_addr_consistence()");
  804.             return -1;
  805.         }
  806.         memset(tmp6, 0, sizeof(*tmp6));
  807.         tmp6->sin6_family = PF_INET6;
  808.         if (inet_addr_complement
  809.             (PF_INET6, (struct in6_addr *) mask, &tmp6->sin6_addr) != 0) {
  810.             config_perror("Fail in function of inet_addr_complement()");
  811.             free(tmp6);
  812.             return -1;
  813.         }
  814.         dst6 = (struct sockaddr_in6 *) malloc(sizeof(struct sockaddr_in6));
  815.         if (!dst6) {
  816.             config_perror("Resource failure in inet_addr_consistence()");
  817.             free(tmp6);
  818.             return -1;
  819.         }
  820.         memset(dst6, 0, sizeof(*dst6));
  821.         dst6->sin6_family = PF_INET6;
  822.         if (inet_addr_and
  823.             (PF_INET6, (struct in6_addr *) net, &tmp6->sin6_addr,
  824.              &dst6->sin6_addr)) {
  825.             config_perror("Fail in function of inet_addr_and()");
  826.             free(dst6);
  827.             free(tmp6);
  828.             return -1;
  829.         }
  830.         ret = (IN6_IS_ADDR_UNSPECIFIED(&dst6->sin6_addr) == 1 ? 0 : -1);
  831.         free(dst6);
  832.         free(tmp6);
  833.         break;
  834.     default:
  835.         return -1;
  836.     }
  837.     return ret;
  838. }
  840. /*
  841.  * int
  842.  * masked_address_are_equal (pf, from, mask, network) 
  843.  *      This function takes AND operation on address "from" and "mask",
  844.  *      and check the result is equal to address "network". 
  845.  *      From, net and mask are ususally sockaddr_in or sockaddr_in6.  
  846.  * Note:
  847.  *      Must spefiey protocol family in pf.
  848.  * return:
  849.  *      0 if address "from" masked by address "mask" is eqaul to 
  850.  *      address "network". 
  851.  *      -1 if address "from" masked by address "mask" isn't eqaul to 
  852.  *      address "network". For instance, address "from" is 
  853.  *       192.168.0.129 and "mask" is 255.255.255.128. Then, masked 
  854.  *      address is 192.168.0.128. If address "network" is 192.168.0.128,
  855.  *      return 0, otherwise -1.
  856.  *      Also retunn -1 if each address family of from, mask, network
  857.  *      isn't the same.
  858.  */
  860. int
  861. masked_address_are_equal(int af, struct sockaddr_storage *from,
  862.                          struct sockaddr_storage *mask,
  863.                          struct sockaddr_storage *network)
  864. {
  866.     struct sockaddr_storage ss;
  867.     memset(&ss, 0, sizeof(ss));
  869.     switch (af) {
  870.     case PF_INET:
  871.         if (mask->ss_family != PF_INET || network->ss_family != PF_INET) {
  872.             return -1;
  873.         }
  874.         ss.ss_family = PF_INET;
  875.         inet_addr_and(PF_INET,
  876.                       &((struct sockaddr_in *) from)->sin_addr,
  877.                       &((struct sockaddr_in *) mask)->sin_addr,
  878.                       &((struct sockaddr_in *) &ss)->sin_addr);
  879.         if (((struct sockaddr_in *) &ss)->sin_addr.s_addr ==
  880.             ((struct sockaddr_in *) network)->sin_addr.s_addr) {
  881.             return 0;
  882.         } else {
  883.             return -1;
  884.         }
  885.         break;
  886.     case PF_INET6:
  887.         if (mask->ss_family != PF_INET6 || network->ss_family != PF_INET6) {
  888.             return -1;
  889.         }
  890.         ss.ss_family = PF_INET6;
  891.         inet_addr_and(PF_INET6,
  892.                       &((struct sockaddr_in6 *) from)->sin6_addr,
  893.                       &((struct sockaddr_in6 *) mask)->sin6_addr,
  894.                       &((struct sockaddr_in6 *) &ss)->sin6_addr);
  895. #ifndef IN6_ARE_ADDR_EQUAL
  896. #define IN6_ARE_ADDR_EQUAL(a,b) IN6_ADDR_EQUAL(a,b)
  897. #endif
  898.         if (IN6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *) &ss)->sin6_addr,
  899.                                &((struct sockaddr_in6 *) network)->
  900.                                sin6_addr) == 1) {
  901.             return 0;
  902.         } else {
  903.             return -1;
  904.         }
  905.         break;
  906.     default:
  907.         return -1;
  908.     }
  909. }
  911. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  912. /*
  913.  * The following functions provide the "com2sec6" configuration token
  914.  * functionality for compatibility.  
  915.  */
  917. #define EXAMPLE_NETWORK       "NETWORK"
  918. #define EXAMPLE_COMMUNITY     "COMMUNITY"
  920. typedef struct _com2Sec6Entry {
  921.     char            community[VACMSTRINGLEN];
  922.     struct sockaddr_in6 network;
  923.     struct sockaddr_in6 mask;
  924.     char            secName[VACMSTRINGLEN];
  925.     char            contextName[VACMSTRINGLEN];
  926.     struct _com2Sec6Entry *next;
  927. } com2Sec6Entry;
  929. com2Sec6Entry  *com2Sec6List = NULL, *com2Sec6ListLast = NULL;
  932. void
  933. memmove_com2Sec6Entry(com2Sec6Entry * c,
  934.                       char *secName,
  935.                       char *community,
  936.                       struct sockaddr_in6 net, struct sockaddr_in6 mask,
  937.                       char *contextName)
  938. {
  939.     snprintf(c->secName, strlen(secName) + 1, "%s", secName);
  940.     snprintf(c->contextName, strlen(contextName) + 1, "%s", contextName);
  941.     snprintf(c->community, strlen(community) + 1, "%s", community);
  942.     memmove(&c->network, &net, sizeof(net));
  943.     memmove(&c->mask, &mask, sizeof(mask));
  944.     c->next = NULL;
  945. }
  948. void
  949. netsnmp_udp6_parse_security(const char *token, char *param)
  950. {
  951.     char            secName[VACMSTRINGLEN];
  952.     char            contextName[VACMSTRINGLEN];
  953.     char            community[VACMSTRINGLEN];
  954.     char            source[VACMSTRINGLEN];
  955.     char           *cp = NULL, *strnetwork = NULL, *strmask = NULL;
  956.     com2Sec6Entry  *e = NULL;
  957.     struct sockaddr_in6 net, mask;
  958.     struct sockaddr_in tmp;
  960.     memset(&net, 0, sizeof(net));
  961.     memset(&mask, 0, sizeof(mask));
  962.     memset(&tmp, 0, sizeof(tmp));
  963.     net.sin6_family = AF_INET6;
  964.     mask.sin6_family = AF_INET6;
  965.     tmp.sin_family = AF_INET;
  968.     /*
  969.      * Get security, source address/netmask and community strings.  
  970.      */
  971.     cp = copy_nword( param, secName, sizeof(secName));
  972.     if (strcmp(secName, "-Cn") == 0) {
  973.         if (!cp) {
  974.             config_perror("missing CONTEXT_NAME parameter");
  975.             return;
  976.         }
  977.         cp = copy_nword( cp, contextName, sizeof(contextName));
  978.         cp = copy_nword( cp, secName, sizeof(secName));
  979.     } else {
  980.         contextName[0] = '';
  981.     }
  982.     if (secName[0] == '') {
  983.         config_perror("missing NAME parameter");
  984.         return;
  985.     } else if (strlen(secName) > (VACMSTRINGLEN - 1)) {
  986.         config_perror("security name too long");
  987.         return;
  988.     }
  989.     cp = copy_nword( cp, source, sizeof(source));
  990.     if (source[0] == '') {
  991.         config_perror("missing SOURCE parameter");
  992.         return;
  993.     } else if (strncmp(source, EXAMPLE_NETWORK, strlen(EXAMPLE_NETWORK)) ==
  994.                0) {
  995.         config_perror("example config NETWORK not properly configured");
  996.         return;
  997.     }
  998.     cp = copy_nword( cp, community, sizeof(community));
  999.     if (community[0] == '') {
  1000.         config_perror("missing COMMUNITY parametern");
  1001.         return;
  1002.     } else
  1003.         if (strncmp
  1004.             (community, EXAMPLE_COMMUNITY, strlen(EXAMPLE_COMMUNITY))
  1005.             == 0) {
  1006.         config_perror("example config COMMUNITY not properly configured");
  1007.         return;
  1008.     } else if (strlen(community) > (VACMSTRINGLEN - 1)) {
  1009.         config_perror("community name too long");
  1010.         return;
  1011.     }
  1013.     /*
  1014.      * Process the source address/netmask string.  
  1015.      */
  1016.     cp = strchr(source, '/');
  1017.     if (cp != NULL) {
  1018.         /*
  1019.          * Mask given.  
  1020.          */
  1021.         *cp = '';
  1022.         strmask = cp + 1;
  1023.     }
  1025.     /*
  1026.      * Deal with the network part first.  
  1027.      */
  1028.     if ((strcmp(source, "default") == 0) || (strcmp(source, "::") == 0)) {
  1029.         strnetwork = strdup("0::0");
  1030.         strmask = strdup("0::0");
  1032.         inet_pton(AF_INET6, strnetwork, &net.sin6_addr);
  1033.         inet_pton(AF_INET6, strmask, &mask.sin6_addr);
  1035.         e = (com2Sec6Entry *) malloc(sizeof(com2Sec6Entry));
  1036.         if (e == NULL) {
  1037.             config_perror("memory error");
  1038.             return;
  1039.         }
  1040.         /*
  1041.          * Everything is okay.  Copy the parameters to the structure allocated
  1042.          * above and add it to END of the list.  
  1043.          */
  1044.         if (strmask != NULL && strnetwork != NULL) {
  1045.             DEBUGMSGTL(("netsnmp_udp6_parse_security",
  1046.                         "<"%s", %s/%s> => "%s"n", community,
  1047.                         strnetwork, strmask, secName));
  1048.             free(strmask);
  1049.             free(strnetwork);
  1050.         } else {
  1051.             DEBUGMSGTL(("netsnmp_udp6_parse_security",
  1052.                         "Couldn't allocate enough memoryn"));
  1053.         }
  1054.         memmove_com2Sec6Entry(e, secName, community, net, mask, contextName);
  1055.         if (com2Sec6ListLast != NULL) {
  1056.             com2Sec6ListLast->next = e;
  1057.             com2Sec6ListLast = e;
  1058.         } else {
  1059.             com2Sec6ListLast = com2Sec6List = e;
  1060.         }
  1062.     } else {
  1063.         /*
  1064.          * Try interpreting as IPv6 address.  
  1065.          */
  1066.         if (inet_pton(AF_INET6, source, &net.sin6_addr) == 1) {
  1067.             if (strmask == NULL || *strmask == '') {
  1068.                 inet_make_mask_addr(PF_INET6, &mask.sin6_addr, 128);
  1069.             } else {
  1070.                 if (strchr(strmask, ':')) {
  1071.                     if (inet_pton(PF_INET6, strmask, &net.sin6_addr) != 1) {
  1072.                         config_perror("bad mask");
  1073.                         return;
  1074.                     }
  1075.                 } else {
  1076.                     if (inet_make_mask_addr
  1077.                         (PF_INET6, &mask.sin6_addr, atoi(strmask)) != 0) {
  1078.                         config_perror("bad mask");
  1079.                         return;
  1081.                     }
  1082.                 }
  1083.             }
  1084.             /*
  1085.              * Check that the network and mask are consistent.  
  1086.              */
  1087.             if (inet_addrs_consistence
  1088.                 (PF_INET6, &net.sin6_addr, &mask.sin6_addr) != 0) {
  1089.                 config_perror("source/mask mismatch");
  1090.                 return;
  1091.             }
  1093.             e = (com2Sec6Entry *) malloc(sizeof(com2Sec6Entry));
  1094.             if (e == NULL) {
  1095.                 config_perror("memory error");
  1096.                 return;
  1097.             }
  1099.             /*
  1100.              * Everything is okay.  Copy the parameters to the structure allocated
  1101.              * above and add it to END of the list.  
  1102.              */
  1103.             if (strmask != NULL && strnetwork != NULL) {
  1104.                 DEBUGMSGTL(("netsnmp_udp6_parse_security",
  1105.                             "<"%s", %s/%s> => "%s"n", community,
  1106.                             strnetwork, strmask, secName));
  1107.                 free(strmask);
  1108.                 free(strnetwork);
  1109.             } else {
  1110.                 DEBUGMSGTL(("netsnmp_udp6_parse_security",
  1111.                             "Couldn't allocate enough memoryn"));
  1112.             }
  1113.             memmove_com2Sec6Entry(e, secName, community, net, mask,
  1114.                                   contextName);
  1115.             if (com2Sec6ListLast != NULL) {
  1116.                 com2Sec6ListLast->next = e;
  1117.                 com2Sec6ListLast = e;
  1118.             } else {
  1119.                 com2Sec6ListLast = com2Sec6List = e;
  1120.             }
  1122. #if HAVE_GETADDRINFO
  1124.         } else {
  1125.             /*
  1126.              * Nope, Must be a hostname.  
  1127.              */
  1128.             struct addrinfo hints, *ai, *res;
  1129.             char            hbuf[NI_MAXHOST];
  1130.             int             gai_error;
  1132.             memset(&hints, 0, sizeof(hints));
  1133.             hints.ai_family = PF_INET6;
  1134.             hints.ai_socktype = SOCK_DGRAM;
  1135.             if ((gai_error = getaddrinfo(source, NULL, &hints, &res)) != 0) {
  1136.                 config_perror(gai_strerror(gai_error));
  1137.                 return;
  1138.             }
  1140.             for (ai = res; ai != NULL; ai = ai->ai_next) {
  1141.                 if (getnameinfo
  1142.                     (ai->ai_addr, ai->ai_addrlen, hbuf, sizeof(hbuf), NULL,
  1143.                      0, NI_NUMERICHOST)) {
  1144.                     config_perror("getnameinfo failed");
  1145.                 }
  1146.                 memmove(ai->ai_addr, &net, sizeof(struct sockaddr_in6));
  1147.                 inet_make_mask_addr(AF_INET6, &mask.sin6_addr, 127);
  1149.                 e = (com2Sec6Entry *) malloc(sizeof(com2Sec6Entry));
  1150.                 if (e == NULL) {
  1151.                     config_perror("memory error");
  1152.                     return;
  1153.                 }
  1155.                 /*
  1156.                  * Everything is okay.  Copy the parameters to the structure allocated
  1157.                  * above and add it to END of the list.  
  1158.                  */
  1159.                 DEBUGMSGTL(("netsnmp_udp6_parse_security",
  1160.                             "<"%s", %s> => "%s"n", community, hbuf,
  1161.                             secName));
  1162.                 memmove_com2Sec6Entry(e, secName, community, net, mask,
  1163.                                       contextName);
  1164.                 if (com2Sec6ListLast != NULL) {
  1165.                     com2Sec6ListLast->next = e;
  1166.                     com2Sec6ListLast = e;
  1167.                 } else {
  1168.                     com2Sec6ListLast = com2Sec6List = e;
  1169.                 }
  1170.             }
  1171.             if (res != NULL)
  1172.                 freeaddrinfo(res);
  1174. #endif /* HAVE_GETADDRINFO */
  1176.         }
  1177.         /*
  1178.          * free(strnetwork); 
  1179.          */
  1180.     }
  1181. }
  1183. void
  1184. netsnmp_udp6_com2Sec6List_free(void)
  1185. {
  1186.     com2Sec6Entry  *e = com2Sec6List;
  1187.     while (e != NULL) {
  1188.         com2Sec6Entry  *tmp = e;
  1189.         e = e->next;
  1190.         free(tmp);
  1191.     }
  1192.     com2Sec6List = com2Sec6ListLast = NULL;
  1193. }
  1195. #endif /* support for community based SNMP */
  1197. void
  1198. netsnmp_udp6_agent_config_tokens_register(void)
  1199. {
  1200. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  1201.     register_app_config_handler("com2sec6", netsnmp_udp6_parse_security,
  1202.                                 netsnmp_udp6_com2Sec6List_free,
  1203.                                 "[-Cn CONTEXT] secName IPv6-network-address[/netmask] community");
  1204. #endif /* support for community based SNMP */
  1205. }
  1209. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  1210. /*
  1211.  * Return 0 if there are no com2sec entries, or return 1 if there ARE com2sec 
  1212.  * entries.  On return, if a com2sec entry matched the passed parameters,
  1213.  * then *secName points at the appropriate security name, or is NULL if the
  1214.  * parameters did not match any com2sec entry.  
  1215.  */
  1217. int
  1218. netsnmp_udp6_getSecName(void *opaque, int olength,
  1219.                         const char *community,
  1220.                         int community_len, char **secName, char **contextName)
  1221. {
  1222.     com2Sec6Entry  *c;
  1223.     struct sockaddr_in6 *from = (struct sockaddr_in6 *) opaque;
  1224.     char           *ztcommunity = NULL;
  1225.     char            str6[INET6_ADDRSTRLEN];
  1227.     if (secName != NULL) {
  1228.         *secName = NULL;  /* Haven't found anything yet */
  1229.     }
  1231.     /*
  1232.      * Special case if there are NO entries (as opposed to no MATCHING
  1233.      * entries).  
  1234.      */
  1236.     if (com2Sec6List == NULL) {
  1237.         DEBUGMSGTL(("netsnmp_udp6_getSecName", "no com2sec entriesn"));
  1238.         return 0;
  1239.     }
  1241.     /*
  1242.      * If there is no IPv6 source address, 
  1243.      * then there can be no valid security name.  
  1244.      */
  1246.     if (opaque == NULL || olength != sizeof(struct sockaddr_in6)
  1247.         || from->sin6_family != PF_INET6) {
  1248.         DEBUGMSGTL(("netsnmp_udp6_getSecName",
  1249.                     "no IPv6 source address in PDU?n"));
  1250.         return 1;
  1251.     }
  1253.     ztcommunity = (char *) malloc(community_len + 1);
  1254.     if (ztcommunity != NULL) {
  1255.         memcpy(ztcommunity, community, community_len);
  1256.         ztcommunity[community_len] = '';
  1257.     }
  1259.     inet_ntop(AF_INET6, &from->sin6_addr, str6, sizeof(str6));
  1260.     DEBUGMSGTL(("netsnmp_udp6_getSecName", "resolve <"%s", %s>n",
  1261.                 ztcommunity ? ztcommunity : "<malloc error>", str6));
  1263.     for (c = com2Sec6List; c != NULL; c = c->next) {
  1264.         DEBUGMSGTL(("netsnmp_udp6_getSecName",
  1265.                     "compare <"%s", 0x%032/0x%032x>", c->community,
  1266.                     c->network, c->mask));
  1268.         if ((community_len == (int)strlen(c->community)) &&
  1269.             (memcmp(community, c->community, community_len) == 0) &&
  1270.             (masked_address_are_equal(from->sin6_family,
  1271.                                       (struct sockaddr_storage *) from,
  1272.                                       (struct sockaddr_storage *) &c->mask,
  1273.                                       (struct sockaddr_storage *) &c->
  1274.                                       network) == 0)) {
  1275.             DEBUGMSG(("netsnmp_udp6_getSecName", "... SUCCESSn"));
  1276.             if (secName != NULL) {
  1277.                 *secName = c->secName;
  1278.                 *contextName = c->contextName;
  1279.             }
  1280.             break;
  1281.         }
  1282.         DEBUGMSG(("netsnmp_udp6_getSecName", "... nopen"));
  1283.     }
  1284.     if (ztcommunity != NULL) {
  1285.         free(ztcommunity);
  1286.     }
  1287.     return 1;
  1288. }
  1289. #endif /* support for community based SNMP */
  1291. netsnmp_transport *
  1292. netsnmp_udp6_create_tstring(const char *str, int local)
  1293. {
  1294.     struct sockaddr_in6 addr;
  1296.     if (netsnmp_sockaddr_in6(&addr, str, 0)) {
  1297.         return netsnmp_udp6_transport(&addr, local);
  1298.     } else {
  1299.         return NULL;
  1300.     }
  1301. }
  1304. /*
  1305.  * See:
  1306.  * 
  1307.  * http://www.ietf.org/internet-drafts/draft-ietf-ops-taddress-mib-01.txt
  1308.  * 
  1309.  * (or newer equivalent) for details of the TC which we are using for
  1310.  * the mapping here.  
  1311.  */
  1313. netsnmp_transport *
  1314. netsnmp_udp6_create_ostring(const u_char * o, size_t o_len, int local)
  1315. {
  1316.     struct sockaddr_in6 addr;
  1318.     if (o_len == 18) {
  1319.         memset((u_char *) & addr, 0, sizeof(struct sockaddr_in6));
  1320.         addr.sin6_family = AF_INET6;
  1321.         memcpy((u_char *) & (addr.sin6_addr.s6_addr), o, 16);
  1322.         addr.sin6_port = (o[16] << 8) + o[17];
  1323.         return netsnmp_udp6_transport(&addr, local);
  1324.     }
  1325.     return NULL;
  1326. }
  1329. void
  1330. netsnmp_udp6_ctor(void)
  1331. {
  1332.     udp6Domain.name = netsnmp_UDPIPv6Domain;
  1333.     udp6Domain.name_length = sizeof(netsnmp_UDPIPv6Domain) / sizeof(oid);
  1334.     udp6Domain.f_create_from_tstring = netsnmp_udp6_create_tstring;
  1335.     udp6Domain.f_create_from_ostring = netsnmp_udp6_create_ostring;
  1336.     udp6Domain.prefix = calloc(5, sizeof(char *));
  1337.     udp6Domain.prefix[0] = "udp6";
  1338.     udp6Domain.prefix[1] = "ipv6";
  1339.     udp6Domain.prefix[2] = "udpv6";
  1340.     udp6Domain.prefix[3] = "udpipv6";
  1342.     netsnmp_tdomain_register(&udp6Domain);
  1343. }
  1345. #else
  1347. #ifdef NETSNMP_DLL
  1348. /* need this hook for win32 MSVC++ DLL build */
  1349. void
  1350. netsnmp_udp6_agent_config_tokens_register(void)
  1351. { }
  1352. #endif
  1354. #endif /* SNMP_TRANSPORT_UDPIPV6_DOMAIN */