userapps/opensource/net-snmp/agent/mibgroup/target/target.c

   1 #include <net-snmp/net-snmp-config.h>
   2
   3 #if HAVE_WINSOCK_H
   4 #include <winsock.h>
   5 #endif
   6 #if HAVE_STRING_H
   7 #include <string.h>
   8 #else
   9 #include <strings.h>
  10 #endif
  11
  12 #include <net-snmp/net-snmp-includes.h>
  13 #include <net-snmp/agent/net-snmp-agent-includes.h>
  14
  15 #include "snmpTargetAddrEntry.h"
  16 #include "snmpTargetParamsEntry.h"
  17 #include "target.h"
  18
  19 #define MAX_TAGS 128
  20
  21 netsnmp_session *
  22 get_target_sessions(char *taglist, TargetFilterFunction * filterfunct,
  23                     void *filterArg)
  24 {
  25     netsnmp_session *ret = NULL, thissess;
  26     struct targetAddrTable_struct *targaddrs;
  27     char            buf[SPRINT_MAX_LEN];
  28     char            tags[MAX_TAGS][SPRINT_MAX_LEN], *cp;
  29     int             numtags = 0, i;
  30     static struct targetParamTable_struct *param;
  31
  32     DEBUGMSGTL(("target_sessions", "looking for: %s\n", taglist));
  33     for (cp = taglist; cp && numtags < MAX_TAGS;) {
  34         cp = copy_nword(cp, tags[numtags], sizeof(tags[numtags]));
  35         DEBUGMSGTL(("target_sessions", " for: %d=%s\n", numtags,
  36                     tags[numtags]));
  37         numtags++;
  38     }
  39
  40     for (targaddrs = get_addrTable(); targaddrs;
  41          targaddrs = targaddrs->next) {
  42
  43         /*
  44          * legal row?
  45          */
  46         if (targaddrs->tDomain == NULL ||
  47             targaddrs->tAddress == NULL ||
  48             targaddrs->rowStatus != SNMP_ROW_ACTIVE) {
  49             DEBUGMSGTL(("target_sessions", "  which is not ready yet\n"));
  50             continue;
  51         }
  52
  53         if (netsnmp_tdomain_support
  54             (targaddrs->tDomain, targaddrs->tDomainLen, NULL, NULL) == 0) {
  55             snmp_log(LOG_ERR,
  56                      "unsupported domain for target address table entry %s\n",
  57                      targaddrs->name);
  58         }
  59
  60         /*
  61          * check tag list to see if we match
  62          */
  63         if (targaddrs->tagList) {
  64             /*
  65              * loop through tag list looking for requested tags
  66              */
  67             for (cp = targaddrs->tagList; cp;) {
  68                 cp = copy_nword(cp, buf, sizeof(buf));
  69                 for (i = 0; i < numtags; i++) {
  70                     if (strcmp(buf, tags[i]) == 0) {
  71                         /*
  72                          * found a valid target table entry
  73                          */
  74                         DEBUGMSGTL(("target_sessions", "found one: %s\n",
  75                                     tags[i]));
  76
  77                         if (targaddrs->params) {
  78                             param = get_paramEntry(targaddrs->params);
  79                             if (!param
  80                                 || param->rowStatus != SNMP_ROW_ACTIVE) {
  81                                 /*
  82                                  * parameter entry must exist and be active
  83                                  */
  84                                 continue;
  85                             }
  86                         } else {
  87                             /*
  88                              * parameter entry must be specified
  89                              */
  90                             continue;
  91                         }
  92
  93                         /*
  94                          * last chance for caller to opt-out.  Call
  95                          * filtering function
  96                          */
  97                         if (filterfunct &&
  98                             (*(filterfunct)) (targaddrs, param,
  99                                               filterArg)) {
 100                             continue;
 101                         }
 102
 103                         if (targaddrs->storageType != ST_READONLY &&
 104                             targaddrs->sess &&
 105                             param->updateTime >=
 106                             targaddrs->sessionCreationTime) {
 107                             /*
 108                              * parameters have changed, nuke the old session
 109                              */
 110                             snmp_close(targaddrs->sess);
 111                             targaddrs->sess = NULL;
 112                         }
 113
 114                         /*
 115                          * target session already exists?
 116                          */
 117                         if (targaddrs->sess == NULL) {
 118                             /*
 119                              * create an appropriate snmp session and add
 120                              * it to our return list
 121                              */
 122                             netsnmp_transport *t = NULL;
 123
 124                             t = netsnmp_tdomain_transport_oid(targaddrs->
 125                                                               tDomain,
 126                                                               targaddrs->
 127                                                               tDomainLen,
 128                                                               targaddrs->
 129                                                               tAddress,
 130                                                               targaddrs->
 131                                                               tAddressLen,
 132                                                               0);
 133                             if (t == NULL) {
 134                                 DEBUGMSGTL(("target_sessions",
 135                                             "bad dest \""));
 136                                 DEBUGMSGOID(("target_sessions",
 137                                              targaddrs->tDomain,
 138                                              targaddrs->tDomainLen));
 139                                 DEBUGMSG(("target_sessions", "\", \""));
 140                                 DEBUGMSGHEX(("target_sessions",
 141                                              targaddrs->tAddress,
 142                                              targaddrs->tAddressLen));
 143                                 DEBUGMSG(("target_sessions", "\n"));
 144                                 continue;
 145                             } else {
 146                                 char           *dst_str =
 147                                     t->f_fmtaddr(t, NULL, 0);
 148                                 if (dst_str != NULL) {
 149                                     DEBUGMSGTL(("target_sessions",
 150                                                 "  to: %s\n", dst_str));
 151                                     free(dst_str);
 152                                 }
 153                             }
 154                             memset(&thissess, 0, sizeof(thissess));
 155                             thissess.timeout = (targaddrs->timeout) * 1000;
 156                             thissess.retries = targaddrs->retryCount;
 157                             DEBUGMSGTL(("target_sessions",
 158                                         "timeout: %d -> %d\n",
 159                                         targaddrs->timeout,
 160                                         thissess.timeout));
 161
 162                             if (param->mpModel == SNMP_VERSION_3 &&
 163                                 param->secModel != 3) {
 164                                 snmp_log(LOG_ERR,
 165                                          "unsupported model/secmodel combo for target %s\n",
 166                                          targaddrs->name);
 167                                 /*
 168                                  * XXX: memleak
 169                                  */
 170                                 netsnmp_transport_free(t);
 171                                 continue;
 172                             }
 173                             thissess.version = param->mpModel;
 174                             if (param->mpModel == SNMP_VERSION_3) {
 175                                 thissess.securityName = param->secName;
 176                                 thissess.securityNameLen =
 177                                     strlen(thissess.securityName);
 178                                 thissess.securityLevel = param->secLevel;
 179                             } else {
 180                                 thissess.community =
 181                                     (u_char *) strdup(param->secName);
 182                                 thissess.community_len =
 183                                     strlen((char *) thissess.community);
 184                             }
 185
 186                             targaddrs->sess = snmp_add(&thissess, t,
 187                                                        NULL, NULL);
 188                             targaddrs->sessionCreationTime = time(NULL);
 189                         }
 190                         if (targaddrs->sess) {
 191                             if (ret) {
 192                                 targaddrs->sess->next = ret;
 193                             }
 194                             ret = targaddrs->sess;
 195                         } else {
 196                             snmp_sess_perror("target session", &thissess);
 197                         }
 198                     }
 199                 }
 200             }
 201         }
 202     }
 203     return ret;
 204 }