snmpUDPDomain.c

00001 /* Portions of this file are subject to the following copyright(s).  See
00002  * the Net-SNMP's COPYING file for more details and other copyrights
00003  * that may apply:
00004  */
00005 /*
00006  * Portions of this file are copyrighted by:
00007  * Copyright Copyright 2003 Sun Microsystems, Inc. All rights reserved.
00008  * Use is subject to license terms specified in the COPYING file
00009  * distributed with the Net-SNMP package.
00010  */
00011 
00012 #include <net-snmp/net-snmp-config.h>
00013 
00014 #include <stdio.h>
00015 #include <sys/types.h>
00016 #include <ctype.h>
00017 #include <errno.h>
00018 
00019 #if HAVE_STRING_H
00020 #include <string.h>
00021 #else
00022 #include <strings.h>
00023 #endif
00024 #if HAVE_STDLIB_H
00025 #include <stdlib.h>
00026 #endif
00027 #if HAVE_UNISTD_H
00028 #include <unistd.h>
00029 #endif
00030 #if HAVE_SYS_SOCKET_H
00031 #include <sys/socket.h>
00032 #endif
00033 #if HAVE_NETINET_IN_H
00034 #include <netinet/in.h>
00035 #endif
00036 #if HAVE_ARPA_INET_H
00037 #include <arpa/inet.h>
00038 #endif
00039 #if HAVE_NETDB_H
00040 #include <netdb.h>
00041 #endif
00042 #if HAVE_SYS_UIO_H
00043 #include <sys/uio.h>
00044 #endif
00045 
00046 #if HAVE_WINSOCK_H
00047 #include <winsock2.h>
00048 #include <ws2tcpip.h>
00049 #endif
00050 
00051 #if HAVE_DMALLOC_H
00052 #include <dmalloc.h>
00053 #endif
00054 
00055 #include <net-snmp/types.h>
00056 #include <net-snmp/output_api.h>
00057 #include <net-snmp/config_api.h>
00058 
00059 #include <net-snmp/library/snmp_transport.h>
00060 #include <net-snmp/library/snmpUDPDomain.h>
00061 #include <net-snmp/library/system.h>
00062 #include <net-snmp/library/tools.h>
00063 
00064 #ifndef INADDR_NONE
00065 #define INADDR_NONE     -1
00066 #endif
00067 
00068 #ifdef  MSG_DONTWAIT
00069 #define NETSNMP_DONTWAIT MSG_DONTWAIT
00070 #else
00071 #define NETSNMP_DONTWAIT 0
00072 #endif
00073 
00074 static netsnmp_tdomain udpDomain;
00075 
00076 typedef struct netsnmp_udp_addr_pair_s {
00077     struct sockaddr_in remote_addr;
00078     struct in_addr local_addr;
00079 } netsnmp_udp_addr_pair;
00080 
00081 /*
00082  * not static, since snmpUDPIPv6Domain needs it, but not public, either.
00083  * (ie don't put it in a public header.)
00084  */
00085 void _netsnmp_udp_sockopt_set(int fd, int server);
00086 int
00087 netsnmp_sockaddr_in2(struct sockaddr_in *addr,
00088                      const char *inpeername, const char *default_target);
00089 
00090 /*
00091  * Return a string representing the address in data, or else the "far end"
00092  * address if data is NULL.  
00093  */
00094 
00095 char *
00096 netsnmp_udp_fmtaddr(netsnmp_transport *t, void *data, int len)
00097 {
00098     netsnmp_udp_addr_pair *addr_pair = NULL;
00099     struct hostent *host;
00100 
00101     if (data != NULL && len == sizeof(netsnmp_udp_addr_pair)) {
00102         addr_pair = (netsnmp_udp_addr_pair *) data;
00103     } else if (t != NULL && t->data != NULL) {
00104         addr_pair = (netsnmp_udp_addr_pair *) t->data;
00105     }
00106 
00107     if (addr_pair == NULL) {
00108         return strdup("UDP: unknown");
00109     } else {
00110         struct sockaddr_in *to = NULL;
00111         char tmp[64];
00112         to = (struct sockaddr_in *) &(addr_pair->remote_addr);
00113         if (to == NULL) {
00114             sprintf(tmp, "UDP: unknown->[%s]",
00115                     inet_ntoa(addr_pair->local_addr));
00116         } else if ( t && t->flags & NETSNMP_TRANSPORT_FLAG_HOSTNAME ) {
00117             host = gethostbyaddr((char *)&to->sin_addr, 4, AF_INET);
00118             return (host ? strdup(host->h_name) : NULL); 
00119         } else {
00120             sprintf(tmp, "UDP: [%s]:%hu->",
00121                     inet_ntoa(to->sin_addr), ntohs(to->sin_port));
00122             sprintf(tmp + strlen(tmp), "[%s]", inet_ntoa(addr_pair->local_addr));
00123         }
00124         return strdup(tmp);
00125     }
00126 }
00127 
00128 
00129 
00130 #if defined(linux) && defined(IP_PKTINFO)
00131 
00132 # define netsnmp_dstaddr(x) (&(((struct in_pktinfo *)(CMSG_DATA(x)))->ipi_addr))
00133 
00134 int netsnmp_udp_recvfrom(int s, void *buf, int len, struct sockaddr *from, socklen_t *fromlen, struct in_addr *dstip)
00135 {
00136     int r;
00137     struct iovec iov[1];
00138     char cmsg[CMSG_SPACE(sizeof(struct in_pktinfo))];
00139     struct cmsghdr *cmsgptr;
00140     struct msghdr msg;
00141 
00142     iov[0].iov_base = buf;
00143     iov[0].iov_len = len;
00144 
00145     memset(&msg, 0, sizeof msg);
00146     msg.msg_name = from;
00147     msg.msg_namelen = *fromlen;
00148     msg.msg_iov = iov;
00149     msg.msg_iovlen = 1;
00150     msg.msg_control = &cmsg;
00151     msg.msg_controllen = sizeof(cmsg);
00152 
00153     r = recvmsg(s, &msg, NETSNMP_DONTWAIT);
00154 
00155     if (r == -1) {
00156         return -1;
00157     }
00158     
00159     DEBUGMSGTL(("netsnmp_udp", "got source addr: %s\n", inet_ntoa(((struct sockaddr_in *)from)->sin_addr)));
00160     for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
00161         if (cmsgptr->cmsg_level == SOL_IP && cmsgptr->cmsg_type == IP_PKTINFO) {
00162             memcpy((void *) dstip, netsnmp_dstaddr(cmsgptr), sizeof(struct in_addr));
00163             DEBUGMSGTL(("netsnmp_udp", "got destination (local) addr %s\n",
00164                     inet_ntoa(*dstip)));
00165         }
00166     }
00167     return r;
00168 }
00169 
00170 int netsnmp_udp_sendto(int fd, struct in_addr *srcip, struct sockaddr *remote,
00171                         void *data, int len)
00172 {
00173     struct iovec iov = { data, len };
00174     struct {
00175         struct cmsghdr cm;
00176         struct in_pktinfo ipi;
00177     } cmsg;
00178     struct msghdr m;
00179 
00180     memset(&cmsg, 0, sizeof(cmsg));
00181     cmsg.cm.cmsg_len = sizeof(struct cmsghdr) + sizeof(struct in_pktinfo);
00182     cmsg.cm.cmsg_level = SOL_IP;
00183     cmsg.cm.cmsg_type = IP_PKTINFO;
00184     cmsg.ipi.ipi_ifindex = 0;
00185     cmsg.ipi.ipi_spec_dst.s_addr = (srcip ? srcip->s_addr : INADDR_ANY);
00186 
00187     m.msg_name          = remote;
00188     m.msg_namelen       = sizeof(struct sockaddr_in);
00189     m.msg_iov           = &iov;
00190     m.msg_iovlen        = 1;
00191     m.msg_control       = &cmsg;
00192     m.msg_controllen    = sizeof(cmsg);
00193     m.msg_flags         = 0;
00194 
00195     return sendmsg(fd, &m, MSG_NOSIGNAL|MSG_DONTWAIT);
00196 }
00197 #endif /* linux && IP_PKTINFO */
00198 
00199 /*
00200  * You can write something into opaque that will subsequently get passed back 
00201  * to your send function if you like.  For instance, you might want to
00202  * remember where a PDU came from, so that you can send a reply there...  
00203  */
00204 
00205 static int
00206 netsnmp_udp_recv(netsnmp_transport *t, void *buf, int size,
00207                  void **opaque, int *olength)
00208 {
00209     int             rc = -1;
00210     socklen_t       fromlen = sizeof(struct sockaddr);
00211     netsnmp_udp_addr_pair *addr_pair = NULL;
00212     struct sockaddr *from;
00213 
00214     if (t != NULL && t->sock >= 0) {
00215         addr_pair = (netsnmp_udp_addr_pair *) malloc(sizeof(netsnmp_udp_addr_pair));
00216         if (addr_pair == NULL) {
00217             *opaque = NULL;
00218             *olength = 0;
00219             return -1;
00220         } else {
00221             memset(addr_pair, 0, sizeof(netsnmp_udp_addr_pair));
00222             from = (struct sockaddr *) &(addr_pair->remote_addr);
00223         }
00224 
00225         while (rc < 0) {
00226 #if defined(linux) && defined(IP_PKTINFO)
00227             rc = netsnmp_udp_recvfrom(t->sock, buf, size, from, &fromlen, &(addr_pair->local_addr));
00228 #else
00229             rc = recvfrom(t->sock, buf, size, NETSNMP_DONTWAIT, from, &fromlen);
00230 #endif /* linux && IP_PKTINFO */
00231             if (rc < 0 && errno != EINTR) {
00232                 break;
00233             }
00234         }
00235 
00236         if (rc >= 0) {
00237             char *str = netsnmp_udp_fmtaddr(NULL, addr_pair, sizeof(netsnmp_udp_addr_pair));
00238             DEBUGMSGTL(("netsnmp_udp",
00239                         "recvfrom fd %d got %d bytes (from %s)\n",
00240                         t->sock, rc, str));
00241             free(str);
00242         } else {
00243             DEBUGMSGTL(("netsnmp_udp", "recvfrom fd %d err %d (\"%s\")\n",
00244                         t->sock, errno, strerror(errno)));
00245         }
00246         *opaque = (void *)addr_pair;
00247         *olength = sizeof(netsnmp_udp_addr_pair);
00248     }
00249     return rc;
00250 }
00251 
00252 
00253 
00254 static int
00255 netsnmp_udp_send(netsnmp_transport *t, void *buf, int size,
00256                  void **opaque, int *olength)
00257 {
00258     int rc = -1;
00259     netsnmp_udp_addr_pair *addr_pair = NULL;
00260     struct sockaddr *to = NULL;
00261 
00262     if (opaque != NULL && *opaque != NULL &&
00263         *olength == sizeof(netsnmp_udp_addr_pair)) {
00264         addr_pair = (netsnmp_udp_addr_pair *) (*opaque);
00265     } else if (t != NULL && t->data != NULL &&
00266                 t->data_length == sizeof(netsnmp_udp_addr_pair)) {
00267         addr_pair = (netsnmp_udp_addr_pair *) (t->data);
00268     }
00269 
00270     to = (struct sockaddr *) &(addr_pair->remote_addr);
00271 
00272     if (to != NULL && t != NULL && t->sock >= 0) {
00273         char *str = netsnmp_udp_fmtaddr(NULL, (void *) addr_pair,
00274                                         sizeof(netsnmp_udp_addr_pair));
00275         DEBUGMSGTL(("netsnmp_udp", "send %d bytes from %p to %s on fd %d\n",
00276                     size, buf, str, t->sock));
00277         free(str);
00278         while (rc < 0) {
00279 #if defined(linux) && defined(IP_PKTINFO)
00280             rc = netsnmp_udp_sendto(t->sock, addr_pair ? &(addr_pair->local_addr) : NULL, to, buf, size);
00281 #else
00282             rc = sendto(t->sock, buf, size, 0, to, sizeof(struct sockaddr));
00283 #endif /* linux && IP_PKTINFO */
00284             if (rc < 0 && errno != EINTR) {
00285                 DEBUGMSGTL(("netsnmp_udp", "sendto error, rc %d (errno %d)\n",
00286                             rc, errno));
00287                 break;
00288             }
00289         }
00290     }
00291     return rc;
00292 }
00293 
00294 
00295 
00296 static int
00297 netsnmp_udp_close(netsnmp_transport *t)
00298 {
00299     int rc = -1;
00300     if (t->sock >= 0) {
00301 #ifndef HAVE_CLOSESOCKET
00302         rc = close(t->sock);
00303 #else
00304         rc = closesocket(t->sock);
00305 #endif
00306         t->sock = -1;
00307     }
00308     return rc;
00309 }
00310 
00311 /*
00312  * find largest possible buffer between current size and specified size.
00313  *
00314  * Try to maximize the current buffer of type "optname"
00315  * to the maximum allowable size by the OS (as close to
00316  * size as possible)
00317  */
00318 static int
00319 _sock_buffer_maximize(int s, int optname, const char *buftype, int size)
00320 {
00321     int            curbuf = 0;
00322     socklen_t      curbuflen = sizeof(int);
00323     int            lo, mid, hi;
00324 
00325     /*
00326      * First we need to determine our current buffer
00327      */
00328     if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf,
00329                     &curbuflen) == 0) 
00330             && (curbuflen == sizeof(int))) {
00331 
00332         DEBUGMSGTL(("verbose:socket:buffer:max", "Current %s is %d\n",
00333                     buftype, curbuf));
00334 
00335         /*
00336          * Let's not be stupid ... if we were asked for less than what we
00337          * already have, then forget about it
00338          */
00339         if (size <= curbuf) {
00340             DEBUGMSGTL(("verbose:socket:buffer:max",
00341                         "Requested %s <= current buffer\n", buftype));
00342             return curbuf;
00343         }
00344 
00345         /*
00346          * Do a binary search the optimal buffer within 1k of the point of
00347          * failure. This is rather bruteforce, but simple
00348          */
00349         hi = size;
00350         lo = curbuf;
00351 
00352         while (hi - lo > 1024) {
00353             mid = (lo + hi) / 2;
00354             if (setsockopt(s, SOL_SOCKET, optname, (void *) &mid,
00355                         sizeof(int)) == 0) {
00356                 lo = mid; /* Success: search between mid and hi */
00357             } else {
00358                 hi = mid; /* Failed: search between lo and mid */
00359             }
00360         }
00361 
00362         /*
00363          * Now print if this optimization helped or not
00364          */
00365         if (getsockopt(s,SOL_SOCKET, optname, (void *) &curbuf,
00366                     &curbuflen) == 0) {
00367             DEBUGMSGTL(("socket:buffer:max", 
00368                         "Maximized %s: %d\n",buftype, curbuf));
00369         } 
00370     } else {
00371         /*
00372          * There is really not a lot we can do anymore.
00373          * If the OS doesn't give us the current buffer, then what's the 
00374          * point in trying to make it better
00375          */
00376         DEBUGMSGTL(("socket:buffer:max", "Get %s failed ... giving up!\n",
00377                     buftype));
00378         curbuf = -1;
00379     }
00380 
00381     return curbuf;
00382 }
00383 
00384 
00385 static const char *
00386 _sock_buf_type_get(int optname, int local)
00387 {
00388     if (optname == SO_SNDBUF) {
00389         if (local)
00390             return "server send buffer";
00391         else
00392             return "client send buffer";
00393     } else if (optname == SO_RCVBUF) {
00394         if (local)
00395             return "server receive buffer";
00396         else
00397             return "client receive buffer";
00398     }
00399 
00400     return "unknown buffer";
00401 }
00402 
00403 /*
00404  *
00405  * Get the requested buffersize, based on
00406  * - sockettype : client (local = 0) or server (local = 1) 
00407  * - buffertype : send (optname = SO_SNDBUF) or recv (SO_RCVBUF)
00408  *
00409  * In case a compile time buffer was specified, then use that one
00410  * if there was no runtime configuration override
00411  */
00412 static int
00413 _sock_buffer_size_get(int optname, int local, const char **buftype)
00414 {
00415     int size;
00416 
00417     if (NULL != buftype)
00418         *buftype = _sock_buf_type_get(optname, local);
00419 
00420     if (optname == SO_SNDBUF) {
00421         if (local) {
00422             size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
00423                     NETSNMP_DS_LIB_SERVERSENDBUF);
00424 #ifdef NETSNMP_DEFAULT_SERVER_SEND_BUF
00425             if (size <= 0)
00426                size = NETSNMP_DEFAULT_SERVER_SEND_BUF;
00427 #endif
00428         } else {
00429             size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
00430                     NETSNMP_DS_LIB_CLIENTSENDBUF);
00431 #ifdef NETSNMP_DEFAULT_CLIENT_SEND_BUF
00432             if (size <= 0)
00433                size = NETSNMP_DEFAULT_CLIENT_SEND_BUF;
00434 #endif
00435         }
00436     } else if (optname == SO_RCVBUF) {
00437         if (local) {
00438             size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
00439                     NETSNMP_DS_LIB_SERVERRECVBUF);
00440 #ifdef NETSNMP_DEFAULT_SERVER_RECV_BUF
00441             if (size <= 0)
00442                size = NETSNMP_DEFAULT_SERVER_RECV_BUF;
00443 #endif
00444         } else {
00445             size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
00446                     NETSNMP_DS_LIB_CLIENTRECVBUF);
00447 #ifdef NETSNMP_DEFAULT_CLIENT_RECV_BUF
00448             if (size <= 0)
00449                size = NETSNMP_DEFAULT_CLIENT_RECV_BUF;
00450 #endif
00451         }
00452     } else {
00453         size = 0;
00454     }
00455 
00456     DEBUGMSGTL(("socket:buffer", "Requested %s is %d\n",
00457                 (buftype) ? *buftype : "unknown buffer", size));
00458 
00459     return(size);
00460 }
00461 
00462 /*
00463  * set socket buffer size
00464  *
00465  * @param ss     : socket
00466  * @param optname: SO_SNDBUF or SO_RCVBUF
00467  * @param local  : 1 for server, 0 for client
00468  * @param reqbuf : requested size, or 0 for default
00469  *
00470  * @retval    -1 : error
00471  * @retval    >0 : new buffer size
00472  */
00473 int
00474 netsnmp_sock_buffer_set(int s, int optname, int local, int size)
00475 {
00476 #if ! defined(SO_SNDBUF) && ! defined(SO_RCVBUF)
00477     DEBUGMSGTL(("socket:buffer", "Changing socket buffer is not supported\n"));
00478     return -1;
00479 #else
00480     const char     *buftype;
00481     int            curbuf = 0;
00482     socklen_t      curbuflen = sizeof(int);
00483 
00484 #   ifndef  SO_SNDBUF
00485     if (SO_SNDBUF == optname) {
00486         DEBUGMSGTL(("socket:buffer",
00487                     "Changing socket send buffer is not supported\n"));
00488         return -1;
00489     }
00490 #   endif                          /*SO_SNDBUF */
00491 #   ifndef  SO_RCVBUF
00492     if (SO_RCVBUF == optname) {
00493         DEBUGMSGTL(("socket:buffer",
00494                     "Changing socket receive buffer is not supported\n"));
00495         return -1;
00496     }
00497 #   endif                          /*SO_RCVBUF */
00498 
00499     /*
00500      * What is the requested buffer size ?
00501      */
00502     if (0 == size)
00503         size = _sock_buffer_size_get(optname, local, &buftype);
00504     else {
00505         buftype = _sock_buf_type_get(optname, local);
00506         DEBUGMSGT(("verbose:socket:buffer", "Requested %s is %d\n",
00507                    buftype, size));
00508     }
00509 
00510     if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf,
00511                     &curbuflen) == 0) 
00512         && (curbuflen == sizeof(int))) {
00513         
00514         DEBUGMSGT(("verbose:socket:buffer", "Original %s is %d\n",
00515                    buftype, curbuf));
00516         if (curbuf >= size) {
00517             DEBUGMSGT(("verbose:socket:buffer",
00518                       "New %s size is smaller than original!\n", buftype));
00519         }
00520     }
00521 
00522     /*
00523      * If the buffersize was not specified or it was a negative value
00524      * then don't change the OS buffers at all
00525      */
00526     if (size <= 0) {
00527        DEBUGMSGT(("socket:buffer",
00528                     "%s not valid or not specified; using OS default(%d)\n",
00529                     buftype,curbuf));
00530        return curbuf;
00531     }
00532 
00533     /*
00534      * Try to set the requested send buffer
00535      */
00536     if (setsockopt(s, SOL_SOCKET, optname, (void *) &size, sizeof(int)) == 0) {
00537         /*
00538          * Because some platforms lie about the actual buffer that has been 
00539          * set (Linux will always say it worked ...), we print some 
00540          * diagnostic output for debugging
00541          */
00542         DEBUGIF("socket:buffer") {
00543             DEBUGMSGT(("socket:buffer", "Set %s to %d\n",
00544                        buftype, size));
00545             if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf,
00546                             &curbuflen) == 0) 
00547                     && (curbuflen == sizeof(int))) {
00548 
00549                 DEBUGMSGT(("verbose:socket:buffer",
00550                            "Now %s is %d\n", buftype, curbuf));
00551             }
00552         }
00553         /*
00554          * If the new buffer is smaller than the size we requested, we will
00555          * try to increment the new buffer with 1k increments 
00556          * (this will sometime allow us to reach a more optimal buffer.)
00557          *   For example : On Solaris, if the max OS buffer is 100k and you
00558          *   request 110k, you end up with the default 8k :-(
00559          */
00560         if (curbuf < size) {
00561             curbuf = _sock_buffer_maximize(s, optname, buftype, size);
00562             if(-1 != curbuf)
00563                 size = curbuf;
00564         }
00565 
00566     } else {
00567         /*
00568          * Obviously changing the buffer failed, most like like because we 
00569          * requested a buffer greater than the OS limit.
00570          * Therefore we need to search for an optimal buffer that is close
00571          * enough to the point of failure.
00572          * This will allow us to reach a more optimal buffer.
00573          *   For example : On Solaris, if the max OS buffer is 100k and you 
00574          *   request 110k, you end up with the default 8k :-(
00575          *   After this quick seach we would get 1k close to 100k (the max)
00576          */
00577         DEBUGMSGTL(("socket:buffer", "couldn't set %s to %d\n",
00578                     buftype, size));
00579 
00580         curbuf = _sock_buffer_maximize(s, optname, buftype, size);
00581         if(-1 != curbuf)
00582             size = curbuf;
00583     }
00584 
00585     return size;
00586 #endif
00587 }
00588 
00589 /*
00590  * Open a UDP-based transport for SNMP.  Local is TRUE if addr is the local
00591  * address to bind to (i.e. this is a server-type session); otherwise addr is 
00592  * the remote address to send things to.  
00593  */
00594 
00595 netsnmp_transport *
00596 netsnmp_udp_transport(struct sockaddr_in *addr, int local)
00597 {
00598     netsnmp_transport *t = NULL;
00599     int             rc = 0;
00600     char           *str = NULL;
00601     char           *client_socket = NULL;
00602     netsnmp_udp_addr_pair addr_pair;
00603 
00604     if (addr == NULL || addr->sin_family != AF_INET) {
00605         return NULL;
00606     }
00607 
00608     memset(&addr_pair, 0, sizeof(netsnmp_udp_addr_pair));
00609     memcpy(&(addr_pair.remote_addr), addr, sizeof(struct sockaddr_in));
00610 
00611     t = (netsnmp_transport *) malloc(sizeof(netsnmp_transport));
00612     if (t == NULL) {
00613         return NULL;
00614     }
00615 
00616     str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
00617                                  sizeof(netsnmp_udp_addr_pair));
00618     DEBUGMSGTL(("netsnmp_udp", "open %s %s\n", local ? "local" : "remote",
00619                 str));
00620     free(str);
00621 
00622     memset(t, 0, sizeof(netsnmp_transport));
00623 
00624     t->domain = netsnmpUDPDomain;
00625     t->domain_length = netsnmpUDPDomain_len;
00626 
00627     t->sock = socket(PF_INET, SOCK_DGRAM, 0);
00628     if (t->sock < 0) {
00629         netsnmp_transport_free(t);
00630         return NULL;
00631     }
00632 
00633     _netsnmp_udp_sockopt_set(t->sock, local);
00634 
00635     if (local) {
00636         /*
00637          * This session is inteneded as a server, so we must bind on to the
00638          * given IP address, which may include an interface address, or could
00639          * be INADDR_ANY, but certainly includes a port number.
00640          */
00641 
00642       t->local = (u_char *) malloc(6);
00643         if (t->local == NULL) {
00644             netsnmp_transport_free(t);
00645             return NULL;
00646         }
00647         memcpy(t->local, (u_char *) & (addr->sin_addr.s_addr), 4);
00648         t->local[4] = (htons(addr->sin_port) & 0xff00) >> 8;
00649         t->local[5] = (htons(addr->sin_port) & 0x00ff) >> 0;
00650         t->local_length = 6;
00651 
00652 #if defined(linux) && defined(IP_PKTINFO)
00653         { 
00654             int sockopt = 1;
00655             if (setsockopt(t->sock, SOL_IP, IP_PKTINFO, &sockopt, sizeof sockopt) == -1) {
00656                 DEBUGMSGTL(("netsnmp_udp", "couldn't set IP_PKTINFO: %s\n",
00657                     strerror(errno)));
00658                 netsnmp_transport_free(t);
00659                 return NULL;
00660             }
00661             DEBUGMSGTL(("netsnmp_udp", "set IP_PKTINFO\n"));
00662         }
00663 #endif
00664         rc = bind(t->sock, (struct sockaddr *) addr,
00665                   sizeof(struct sockaddr));
00666         if (rc != 0) {
00667             netsnmp_udp_close(t);
00668             netsnmp_transport_free(t);
00669             return NULL;
00670         }
00671         t->data = NULL;
00672         t->data_length = 0;
00673     } else {
00674         /*
00675          * This is a client session.  If we've been given a
00676          * client address to send from, then bind to that.
00677          * Otherwise the send will use "something sensible".
00678          */
00679         client_socket = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
00680                                               NETSNMP_DS_LIB_CLIENT_ADDR);
00681         if (client_socket) {
00682             struct sockaddr_in client_addr;
00683             netsnmp_sockaddr_in2(&client_addr, client_socket, NULL);
00684             addr_pair.local_addr = client_addr.sin_addr;
00685             rc = bind(t->sock, (struct sockaddr *)&client_addr,
00686                   sizeof(struct sockaddr));
00687             if ( rc != 0 ) {
00688                 DEBUGMSGTL(("netsnmp_udp", "failed to bind for clientaddr: %d %s\n",
00689                             errno, strerror(errno)));
00690                 netsnmp_udp_close(t);
00691                 netsnmp_transport_free(t);
00692                 return NULL;
00693             }
00694         }
00695 
00696         str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
00697                  sizeof(netsnmp_udp_addr_pair));
00698         DEBUGMSGTL(("netsnmp_udp", "client open %s\n", str));
00699         free(str);
00700 
00701         /*
00702          * Save the (remote) address in the
00703          * transport-specific data pointer for later use by netsnmp_udp_send.
00704          */
00705 
00706         t->data = malloc(sizeof(netsnmp_udp_addr_pair));
00707         t->remote = (u_char *)malloc(6);
00708         if (t->data == NULL || t->remote == NULL) {
00709             netsnmp_transport_free(t);
00710             return NULL;
00711         }
00712         memcpy(t->remote, (u_char *) & (addr->sin_addr.s_addr), 4);
00713         t->remote[4] = (htons(addr->sin_port) & 0xff00) >> 8;
00714         t->remote[5] = (htons(addr->sin_port) & 0x00ff) >> 0;
00715         t->remote_length = 6;
00716         memcpy(t->data, &addr_pair, sizeof(netsnmp_udp_addr_pair));
00717         t->data_length = sizeof(netsnmp_udp_addr_pair);
00718     }
00719 
00720     /*
00721      * 16-bit length field, 8 byte UDP header, 20 byte IPv4 header  
00722      */
00723 
00724     t->msgMaxSize = 0xffff - 8 - 20;
00725     t->f_recv     = netsnmp_udp_recv;
00726     t->f_send     = netsnmp_udp_send;
00727     t->f_close    = netsnmp_udp_close;
00728     t->f_accept   = NULL;
00729     t->f_fmtaddr  = netsnmp_udp_fmtaddr;
00730 
00731     return t;
00732 }
00733 
00734 
00735 void
00736 _netsnmp_udp_sockopt_set(int fd, int local)
00737 {
00738 #ifdef  SO_BSDCOMPAT
00739     /*
00740      * Patch for Linux.  Without this, UDP packets that fail get an ICMP
00741      * response.  Linux turns the failed ICMP response into an error message
00742      * and return value, unlike all other OS's.  
00743      */
00744     if (0 == netsnmp_os_prematch("Linux","2.4"))
00745     {
00746         int             one = 1;
00747         DEBUGMSGTL(("socket:option", "setting socket option SO_BSDCOMPAT\n"));
00748         setsockopt(fd, SOL_SOCKET, SO_BSDCOMPAT, (void *) &one,
00749                    sizeof(one));
00750     }
00751 #endif                          /*SO_BSDCOMPAT */
00752     /*
00753      * SO_REUSEADDR will allow multiple apps to open the same port at
00754      * the same time. Only the last one to open the socket will get
00755      * data. Obviously, for an agent, this is a bad thing. There should
00756      * only be one listener.
00757      */
00758 #ifdef ALLOW_PORT_HIJACKING
00759 #ifdef  SO_REUSEADDR
00760     /*
00761      * Allow the same port to be specified multiple times without failing.
00762      *    (useful for a listener)
00763      */
00764     {
00765         int             one = 1;
00766         DEBUGMSGTL(("socket:option", "setting socket option SO_REUSEADDR\n"));
00767         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *) &one,
00768                    sizeof(one));
00769     }
00770 #endif                          /*SO_REUSEADDR */
00771 #endif
00772 
00773     /*
00774      * Try to set the send and receive buffers to a reasonably large value, so
00775      * that we can send and receive big PDUs (defaults to 8192 bytes (!) on
00776      * Solaris, for instance).  Don't worry too much about errors -- just
00777      * plough on regardless.  
00778      */
00779     netsnmp_sock_buffer_set(fd, SO_SNDBUF, local, 0);
00780     netsnmp_sock_buffer_set(fd, SO_RCVBUF, local, 0);
00781 }
00782 
00783 int
00784 netsnmp_sockaddr_in2(struct sockaddr_in *addr,
00785                      const char *inpeername, const char *default_target)
00786 {
00787     int ret;
00788 
00789     if (addr == NULL) {
00790         return 0;
00791     }
00792 
00793     DEBUGMSGTL(("netsnmp_sockaddr_in",
00794                 "addr %p, inpeername \"%s\", default_target \"%s\"\n",
00795                 addr, inpeername ? inpeername : "[NIL]",
00796                 default_target ? default_target : "[NIL]"));
00797 
00798     memset(addr, 0, sizeof(struct sockaddr_in));
00799     addr->sin_addr.s_addr = htonl(INADDR_ANY);
00800     addr->sin_family = AF_INET;
00801     addr->sin_port = htons((u_short)SNMP_PORT);
00802 
00803     {
00804         int port = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
00805                                       NETSNMP_DS_LIB_DEFAULT_PORT);
00806 
00807         if (port != 0) {
00808             addr->sin_port = htons((u_short)port);
00809         } else if (default_target != NULL)
00810             netsnmp_sockaddr_in2(addr, default_target, NULL);
00811     }
00812 
00813     if (inpeername != NULL && *inpeername != '\0') {
00814         const char     *host, *port;
00815         char           *peername = NULL;
00816         char           *cp;
00817         /*
00818          * Duplicate the peername because we might want to mank around with
00819          * it.  
00820          */
00821 
00822         peername = strdup(inpeername);
00823         if (peername == NULL) {
00824             return 0;
00825         }
00826 
00827         /*
00828          * Try and extract an appended port number.  
00829          */
00830         cp = strchr(peername, ':');
00831         if (cp != NULL) {
00832             *cp = '\0';
00833             port = cp + 1;
00834             host = peername;
00835         } else {
00836             host = NULL;
00837             port = peername;
00838         }
00839 
00840         /*
00841          * Try to convert the user port specifier
00842          */
00843         if (port && *port == '\0')
00844             port = NULL;
00845 
00846         if (port != NULL) {
00847             long int l;
00848             char* ep;
00849 
00850             DEBUGMSGTL(("netsnmp_sockaddr_in", "check user service %s\n",
00851                         port));
00852 
00853             l = strtol(port, &ep, 10);
00854             if (ep != port && *ep == '\0' && 0 <= l && l <= 0x0ffff)
00855                 addr->sin_port = htons((u_short)l);
00856             else {
00857                 if (host == NULL) {
00858                     DEBUGMSGTL(("netsnmp_sockaddr_in",
00859                                 "servname not numeric, "
00860                                 "check if it really is a destination)\n"));
00861                     host = port;
00862                     port = NULL;
00863                 } else {
00864                     DEBUGMSGTL(("netsnmp_sockaddr_in",
00865                                 "servname not numeric\n"));
00866                     free(peername);
00867                     return 0;
00868                 }
00869             }
00870         }
00871 
00872         /*
00873          * Try to convert the user host specifier
00874          */
00875         if (host && *host == '\0')
00876             host = NULL;
00877 
00878         if (host != NULL) {
00879             DEBUGMSGTL(("netsnmp_sockaddr_in",
00880                         "check destination %s\n", host));
00881 
00882 
00883             if (strcmp(peername, "255.255.255.255") == 0 ) {
00884                 /*
00885                  * The explicit broadcast address hack
00886                  */
00887                 DEBUGMSGTL(("netsnmp_sockaddr_in", "Explicit UDP broadcast\n"));
00888                 addr->sin_addr.s_addr = INADDR_NONE;
00889             } else {
00890                 ret =
00891                     netsnmp_gethostbyname_v4(peername, &addr->sin_addr.s_addr);
00892                 if (ret < 0) {
00893                     DEBUGMSGTL(("netsnmp_sockaddr_in",
00894                                 "couldn't resolve hostname\n"));
00895                     free(peername);
00896                     return 0;
00897                 }
00898                 DEBUGMSGTL(("netsnmp_sockaddr_in",
00899                             "hostname (resolved okay)\n"));
00900             }
00901         }
00902         free(peername);
00903     }
00904 
00905     /*
00906      * Finished
00907      */
00908 
00909     DEBUGMSGTL(("netsnmp_sockaddr_in", "return { AF_INET, %s:%hu }\n",
00910                 inet_ntoa(addr->sin_addr), ntohs(addr->sin_port)));
00911     return 1;
00912 }
00913 
00914 
00915 int
00916 netsnmp_sockaddr_in(struct sockaddr_in *addr,
00917                     const char *inpeername, int remote_port)
00918 {
00919     char buf[sizeof(int) * 3 + 2];
00920     sprintf(buf, ":%u", remote_port);
00921     return netsnmp_sockaddr_in2(addr, inpeername, remote_port ? buf : NULL);
00922 }
00923 
00924 #if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
00925 /*
00926  * The following functions provide the "com2sec" configuration token
00927  * functionality for compatibility.  
00928  */
00929 
00930 #define EXAMPLE_NETWORK         "NETWORK"
00931 #define EXAMPLE_COMMUNITY       "COMMUNITY"
00932 
00933 typedef struct _com2SecEntry {
00934     char            community[COMMUNITY_MAX_LEN];
00935     unsigned long   network;
00936     unsigned long   mask;
00937     char            secName[VACMSTRINGLEN];
00938     char            contextName[VACMSTRINGLEN];
00939     struct _com2SecEntry *next;
00940 } com2SecEntry;
00941 
00942 com2SecEntry   *com2SecList = NULL, *com2SecListLast = NULL;
00943 
00944 void
00945 netsnmp_udp_parse_security(const char *token, char *param)
00946 {
00947     char            secName[VACMSTRINGLEN];
00948     char            contextName[VACMSTRINGLEN];
00949     char            community[COMMUNITY_MAX_LEN];
00950     char            source[SNMP_MAXBUF_SMALL];
00951     char           *cp = NULL;
00952     const char     *strmask = NULL;
00953     com2SecEntry   *e = NULL;
00954     in_addr_t   network = 0, mask = 0;
00955 
00956     /*
00957      * Get security, source address/netmask and community strings.  
00958      */
00959 
00960     cp = copy_nword( param, secName, sizeof(secName));
00961     if (strcmp(secName, "-Cn") == 0) {
00962         if (!cp) {
00963             config_perror("missing CONTEXT_NAME parameter");
00964             return;
00965         }
00966         cp = copy_nword( cp, contextName, sizeof(contextName));
00967         cp = copy_nword( cp, secName, sizeof(secName));
00968     } else {
00969         contextName[0] = '\0';
00970     }
00971     if (secName[0] == '\0') {
00972         config_perror("missing NAME parameter");
00973         return;
00974     } else if (strlen(secName) > (VACMSTRINGLEN - 1)) {
00975         config_perror("security name too long");
00976         return;
00977     }
00978     cp = copy_nword( cp, source, sizeof(source));
00979     if (source[0] == '\0') {
00980         config_perror("missing SOURCE parameter");
00981         return;
00982     } else if (strncmp(source, EXAMPLE_NETWORK, strlen(EXAMPLE_NETWORK)) ==
00983                0) {
00984         config_perror("example config NETWORK not properly configured");
00985         return;
00986     }
00987     cp = copy_nword( cp, community, sizeof(community));
00988     if (community[0] == '\0') {
00989         config_perror("missing COMMUNITY parameter\n");
00990         return;
00991     } else
00992         if (strncmp
00993             (community, EXAMPLE_COMMUNITY, strlen(EXAMPLE_COMMUNITY))
00994             == 0) {
00995         config_perror("example config COMMUNITY not properly configured");
00996         return;
00997     } else if (strlen(community) > (COMMUNITY_MAX_LEN - 1)) {
00998         config_perror("community name too long");
00999         return;
01000     }
01001 
01002     /*
01003      * Process the source address/netmask string.  
01004      */
01005 
01006     cp = strchr(source, '/');
01007     if (cp != NULL) {
01008         /*
01009          * Mask given.  
01010          */
01011         *cp = '\0';
01012         strmask = cp + 1;
01013     }
01014 
01015     /*
01016      * Deal with the network part first.  
01017      */
01018 
01019     if ((strcmp(source, "default") == 0)
01020         || (strcmp(source, "0.0.0.0") == 0)) {
01021         network = 0;
01022         strmask = "0.0.0.0";
01023     } else {
01024         /*
01025          * Try interpreting as a dotted quad.  
01026          */
01027         network = inet_addr(source);
01028 
01029         if (network == (in_addr_t) -1) {
01030             /*
01031              * Nope, wasn't a dotted quad.  Must be a hostname.  
01032              */
01033             int ret = netsnmp_gethostbyname_v4(source, &network);
01034             if (ret < 0) {
01035                 config_perror("cannot resolve source hostname");
01036                 return;
01037             }
01038         }
01039     }
01040 
01041     /*
01042      * Now work out the mask.  
01043      */
01044 
01045     if (strmask == NULL || *strmask == '\0') {
01046         /*
01047          * No mask was given.  Use 255.255.255.255.  
01048          */
01049         mask = 0xffffffffL;
01050     } else {
01051         if (strchr(strmask, '.')) {
01052             /*
01053              * Try to interpret mask as a dotted quad.  
01054              */
01055             mask = inet_addr(strmask);
01056             if (mask == (in_addr_t) -1 &&
01057                 strncmp(strmask, "255.255.255.255", 15) != 0) {
01058                 config_perror("bad mask");
01059                 return;
01060             }
01061         } else {
01062             /*
01063              * Try to interpret mask as a "number of 1 bits".  
01064              */
01065             int             maskLen = atoi(strmask), maskBit = 0x80000000L;
01066             if (maskLen <= 0 || maskLen > 32) {
01067                 config_perror("bad mask length");
01068                 return;
01069             }
01070             while (maskLen--) {
01071                 mask |= maskBit;
01072                 maskBit >>= 1;
01073             }
01074             mask = htonl(mask);
01075         }
01076     }
01077 
01078     /*
01079      * Check that the network and mask are consistent.  
01080      */
01081 
01082     if (network & ~mask) {
01083         config_perror("source/mask mismatch");
01084         return;
01085     }
01086 
01087     e = (com2SecEntry *) malloc(sizeof(com2SecEntry));
01088     if (e == NULL) {
01089         config_perror("memory error");
01090         return;
01091     }
01092 
01093     /*
01094      * Everything is okay.  Copy the parameters to the structure allocated
01095      * above and add it to END of the list.  
01096      */
01097 
01098     DEBUGMSGTL(("netsnmp_udp_parse_security",
01099                 "<\"%s\", 0x%08x/0x%08x> => \"%s\"\n", community, network,
01100                 mask, secName));
01101 
01102     strcpy(e->contextName, contextName);
01103     strcpy(e->secName, secName);
01104     strcpy(e->community, community);
01105     e->network = network;
01106     e->mask = mask;
01107     e->next = NULL;
01108 
01109     if (com2SecListLast != NULL) {
01110         com2SecListLast->next = e;
01111         com2SecListLast = e;
01112     } else {
01113         com2SecListLast = com2SecList = e;
01114     }
01115 }
01116 
01117 
01118 void
01119 netsnmp_udp_com2SecList_free(void)
01120 {
01121     com2SecEntry   *e = com2SecList;
01122     while (e != NULL) {
01123         com2SecEntry   *tmp = e;
01124         e = e->next;
01125         free(tmp);
01126     }
01127     com2SecList = com2SecListLast = NULL;
01128 }
01129 #endif /* support for community based SNMP */
01130 
01131 void
01132 netsnmp_udp_agent_config_tokens_register(void)
01133 {
01134 #if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
01135     register_app_config_handler("com2sec", netsnmp_udp_parse_security,
01136                                 netsnmp_udp_com2SecList_free,
01137                                 "[-Cn CONTEXT] secName IPv4-network-address[/netmask] community");
01138 #endif /* support for community based SNMP */
01139 }
01140 
01141 
01142 
01143 /*
01144  * Return 0 if there are no com2sec entries, or return 1 if there ARE com2sec 
01145  * entries.  On return, if a com2sec entry matched the passed parameters,
01146  * then *secName points at the appropriate security name, or is NULL if the
01147  * parameters did not match any com2sec entry.  
01148  */
01149 
01150 #if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
01151 int
01152 netsnmp_udp_getSecName(void *opaque, int olength,
01153                        const char *community,
01154                        size_t community_len, char **secName,
01155                        char **contextName)
01156 {
01157     com2SecEntry   *c;
01158     netsnmp_udp_addr_pair *addr_pair = (netsnmp_udp_addr_pair *) opaque;
01159     struct sockaddr_in *from = (struct sockaddr_in *) &(addr_pair->remote_addr);
01160     char           *ztcommunity = NULL;
01161 
01162     if (secName != NULL) {
01163         *secName = NULL;  /* Haven't found anything yet */
01164     }
01165 
01166     /*
01167      * Special case if there are NO entries (as opposed to no MATCHING
01168      * entries).  
01169      */
01170 
01171     if (com2SecList == NULL) {
01172         DEBUGMSGTL(("netsnmp_udp_getSecName", "no com2sec entries\n"));
01173         return 0;
01174     }
01175 
01176     /*
01177      * If there is no IPv4 source address, then there can be no valid security
01178      * name.  
01179      */
01180 
01181    DEBUGMSGTL(("netsnmp_udp_getSecName", "opaque = %p (len = %d), sizeof = %d, family = %d (%d)\n",
01182    opaque, olength, (int)sizeof(netsnmp_udp_addr_pair), from->sin_family, AF_INET));
01183     if (opaque == NULL || olength != sizeof(netsnmp_udp_addr_pair) ||
01184         from->sin_family != AF_INET) {
01185         DEBUGMSGTL(("netsnmp_udp_getSecName",
01186                     "no IPv4 source address in PDU?\n"));
01187         return 1;
01188     }
01189 
01190     DEBUGIF("netsnmp_udp_getSecName") {
01191         ztcommunity = (char *)malloc(community_len + 1);
01192         if (ztcommunity != NULL) {
01193             memcpy(ztcommunity, community, community_len);
01194             ztcommunity[community_len] = '\0';
01195         }
01196 
01197         DEBUGMSGTL(("netsnmp_udp_getSecName", "resolve <\"%s\", 0x%08x>\n",
01198                     ztcommunity ? ztcommunity : "<malloc error>",
01199                     from->sin_addr.s_addr));
01200     }
01201 
01202     for (c = com2SecList; c != NULL; c = c->next) {
01203         DEBUGMSGTL(("netsnmp_udp_getSecName","compare <\"%s\", 0x%08lx/0x%08lx>",
01204                     c->community, c->network, c->mask));
01205         if ((community_len == strlen(c->community)) &&
01206             (memcmp(community, c->community, community_len) == 0) &&
01207             ((from->sin_addr.s_addr & c->mask) == c->network)) {
01208             DEBUGMSG(("netsnmp_udp_getSecName", "... SUCCESS\n"));
01209             if (secName != NULL) {
01210                 *secName = c->secName;
01211                 *contextName = c->contextName;
01212             }
01213             break;
01214         }
01215         DEBUGMSG(("netsnmp_udp_getSecName", "... nope\n"));
01216     }
01217     if (ztcommunity != NULL) {
01218         free(ztcommunity);
01219     }
01220     return 1;
01221 }
01222 #endif /* support for community based SNMP */
01223 
01224 
01225 netsnmp_transport *
01226 netsnmp_udp_create_tstring(const char *str, int local,
01227                            const char *default_target)
01228 {
01229     struct sockaddr_in addr;
01230 
01231     if (netsnmp_sockaddr_in2(&addr, str, default_target)) {
01232         return netsnmp_udp_transport(&addr, local);
01233     } else {
01234         return NULL;
01235     }
01236 }
01237 
01238 
01239 netsnmp_transport *
01240 netsnmp_udp_create_ostring(const u_char * o, size_t o_len, int local)
01241 {
01242     struct sockaddr_in addr;
01243 
01244     if (o_len == 6) {
01245         unsigned short porttmp = (o[4] << 8) + o[5];
01246         addr.sin_family = AF_INET;
01247         memcpy((u_char *) & (addr.sin_addr.s_addr), o, 4);
01248         addr.sin_port = htons(porttmp);
01249         return netsnmp_udp_transport(&addr, local);
01250     }
01251     return NULL;
01252 }
01253 
01254 
01255 void
01256 netsnmp_udp_ctor(void)
01257 {
01258     udpDomain.name = netsnmpUDPDomain;
01259     udpDomain.name_length = netsnmpUDPDomain_len;
01260     udpDomain.prefix = (const char**)calloc(2, sizeof(char *));
01261     udpDomain.prefix[0] = "udp";
01262 
01263     udpDomain.f_create_from_tstring_new = netsnmp_udp_create_tstring;
01264     udpDomain.f_create_from_ostring = netsnmp_udp_create_ostring;
01265 
01266     netsnmp_tdomain_register(&udpDomain);
01267 }