void system_parse_config_sysObjectID(const char *token, char *cptr) { char tmpbuf[1024]; sysObjectIDLength = MAX_OID_LEN; if (!read_objid(cptr, sysObjectID, &sysObjectIDLength)) { snprintf(tmpbuf, sizeof(tmpbuf), "sysobjectid token not a parsable OID:\n\t%s", cptr); config_perror(tmpbuf); // Modified by Gavin Lin, 2008/10/30 //memcpy(sysObjectID, version_sysoid, version_sysoid_len * sizeof(oid)); //sysObjectIDLength = version_sysoid_len; #ifdef CONFIG_MODEL_LRTXXX /* purpose : 0012697 author : Gavin.Lin date : 2010-06-22 */ /* description : Customer requirements */ kd_doCommand("VERSION MODEL", CMD_PRINT, ASH_DO_NOTHING, tmpbuf); if (!strcmp("LRT214", tmpbuf)) { memcpy(sysObjectID, nk_sysobjectid_214, nk_sysobjectid_len * sizeof(oid)); } if (!strcmp("LRT224", tmpbuf)) { memcpy(sysObjectID, nk_sysobjectid_224, nk_sysobjectid_len * sizeof(oid)); } #else memcpy(sysObjectID, nk_sysobjectid, nk_sysobjectid_len * sizeof(oid)); #endif sysObjectIDLength = nk_sysobjectid_len; } }
void parse_config_agentgroup(const char *token, char *cptr) { if (cptr[0] == '#') { char *ecp; int gid = strtoul(cptr + 1, &ecp, 10); if (*ecp != 0) { config_perror("Bad number"); } else { netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_GROUPID, gid); } #if defined(HAVE_GETGRNAM) && defined(HAVE_GRP_H) } else { struct group *info; info = getgrnam(cptr); if (info) netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_GROUPID, info->gr_gid); else config_perror("Group not found in group database"); endgrent(); #endif } }
void snmpd_parse_config_informsink(const char *word, char *cptr) { char tmpbuf[1024]; char *sp, *cp, *pp = NULL; u_short sinkport; if (!snmp_trapcommunity) snmp_trapcommunity = strdup("public"); sp = strtok(cptr, " \t\n"); cp = strtok(NULL, " \t\n"); if (cp) pp = strtok(NULL, " \t\n"); if (cp && pp) { sinkport = atoi(pp); if ((sinkport < 1) || (sinkport > 0xffff)) { config_perror("trapsink port out of range"); sinkport = SNMP_TRAP_PORT; } } else { sinkport = SNMP_TRAP_PORT; } if (create_v2_inform_session(sp, sinkport, cp ? cp : snmp_trapcommunity) == 0) { sprintf(tmpbuf,"cannot create informsink: %s", cptr); config_perror(tmpbuf); } }
static void disk_parse_config_all (const char *token, char *cptr) { #if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS int minpercent = DISKMINPERCENT; if (numdisks == maxdisks) { if (maxdisks == 0) { maxdisks = 50; disks = (struct diskpart *) malloc (maxdisks * sizeof (struct diskpart)); if (!disks) { config_perror ("malloc failed for new disk allocation."); netsnmp_config_error ("\tignoring: %s", cptr); return; } memset (disks, 0, maxdisks * sizeof (struct diskpart)); } else { maxdisks *= 2; disks = (struct diskpart *) realloc (disks, maxdisks * sizeof (struct diskpart)); if (!disks) { config_perror ("malloc failed for new disk allocation."); netsnmp_config_error ("\tignoring: %s", cptr); return; } memset (disks + maxdisks / 2, 0, maxdisks / 2 * sizeof (struct diskpart)); } } /* * read the minimum disk usage percent */ if (cptr != NULL) { if (strchr (cptr, '%') != NULL) { minpercent = atoi (cptr); } } /* * if we have already seen the "includeAllDisks" directive * then search for the disk in the "disks" array and modify * the values. if we havent seen the "includeAllDisks" * directive then include this disk */ if (allDisksIncluded) { config_perror ("includeAllDisks already specified."); netsnmp_config_error ("\tignoring: includeAllDisks %s", cptr); } else { allDisksIncluded = 1; find_and_add_allDisks (minpercent); } #endif /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */ }
void snmpd_parse_config_trapsink(const char *token, char *cptr) { char tmpbuf[1024]; char *sp, *cp, *pp = NULL; int sinkport; char *st; if (!snmp_trapcommunity) snmp_trapcommunity = strdup("public"); sp = strtok_r(cptr, " \t\n", &st); cp = strtok_r(NULL, " \t\n", &st); if (cp) pp = strtok_r(NULL, " \t\n", &st); if (cp && pp) { sinkport = atoi(pp); if ((sinkport < 1) || (sinkport > 0xffff)) { config_perror("trapsink port out of range"); sinkport = SNMP_TRAP_PORT; } } else { sinkport = SNMP_TRAP_PORT; } if (create_v1_trap_session(sp, (u_short)sinkport, cp ? cp : snmp_trapcommunity) == 0) { snprintf(tmpbuf, sizeof(tmpbuf), "cannot create trapsink: %s", cptr); tmpbuf[sizeof(tmpbuf)-1] = '\0'; config_perror(tmpbuf); } }
void snmpd_set_agent_group(const char *token, char *cptr) { #if defined(HAVE_GETGRNAM) && defined(HAVE_GRP_H) struct group *info; #endif if (cptr[0] == '#') { char *ecp; int gid = strtoul(cptr + 1, &ecp, 10); if (*ecp != 0) { config_perror("Bad number"); } else { netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_GROUPID, gid); } } #if defined(HAVE_GETGRNAM) && defined(HAVE_GRP_H) else if ((info = getgrnam(cptr)) != NULL) { netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_GROUPID, info->gr_gid); } else { config_perror("Group not found in group database"); } endpwent(); #endif }
static void proxyOptProc(int argc, char *const *argv, int opt) { switch (opt) { case 'C': while (*optarg) { switch (*optarg++) { case 'n': optind++; if (optind < argc) { context_string = argv[optind - 1]; } else { config_perror("No context name passed to -Cn"); } break; default: config_perror("unknown argument passed to -C"); break; } } break; default: break; /* * shouldn't get here */ } }
/* * parse_snmpNotifyTable(): * parses .conf file entries needed to configure the mib. */ void parse_snmpNotifyTable(const char *token, char *line) { size_t tmpint; struct snmpNotifyTable_data *StorageTmp = SNMP_MALLOC_STRUCT(snmpNotifyTable_data); DEBUGMSGTL(("snmpNotifyTable", "parsing config... ")); if (StorageTmp == NULL) { config_perror("malloc failure"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpNotifyName, &StorageTmp->snmpNotifyNameLen); if (StorageTmp->snmpNotifyName == NULL) { config_perror("invalid specification for snmpNotifyName"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpNotifyTag, &StorageTmp->snmpNotifyTagLen); if (StorageTmp->snmpNotifyTag == NULL) { config_perror("invalid specification for snmpNotifyTag"); return; } line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyType, &tmpint); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyStorageType, &tmpint); if (!StorageTmp->snmpNotifyStorageType) StorageTmp->snmpNotifyStorageType = ST_READONLY; line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyRowStatus, &tmpint); if (!StorageTmp->snmpNotifyRowStatus) StorageTmp->snmpNotifyRowStatus = RS_ACTIVE; if (snmpNotifyTable_add(StorageTmp) != SNMPERR_SUCCESS){ SNMP_FREE(StorageTmp->snmpNotifyName); SNMP_FREE(StorageTmp->snmpNotifyTag); SNMP_FREE(StorageTmp); } DEBUGMSGTL(("snmpNotifyTable", "done.\n")); }
void parse_config_agentuser(const char *token, char *cptr) { if (cptr[0] == '#') { char *ecp; int uid; uid = strtoul(cptr + 1, &ecp, 10); if (*ecp != 0) { config_perror("Bad number"); } else { netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_USERID, uid); } #if defined(HAVE_GETPWNAM) && defined(HAVE_PWD_H) } else { struct passwd *info; info = getpwnam(cptr); if (info) netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_USERID, info->pw_uid); else config_perror("User not found in passwd database"); endpwent(); #endif } }
int vacm_parse_authtokens(const char *token, char **confline) { char authspec[SNMP_MAXBUF_MEDIUM]; char *strtok_state; char *type; int viewtype, viewtypes = 0; *confline = copy_nword(*confline, authspec, sizeof(authspec)); DEBUGMSGTL(("vacm_parse_authtokens","parsing %s",authspec)); if (!*confline) { config_perror("Illegal configuration line: missing fields"); return -1; } type = strtok_r(authspec, ",|:", &strtok_state); while(type && *type != '\0') { viewtype = se_find_value_in_slist(VACM_VIEW_ENUM_NAME, type); if (viewtype < 0 || viewtype >= VACM_MAX_VIEWS) { config_perror("Illegal view name"); } else { viewtypes |= (1 << viewtype); } type = strtok_r(NULL, ",|:", &strtok_state); } DEBUGMSG(("vacm_parse_authtokens"," .. result = 0x%x\n",viewtypes)); return viewtypes; }
static void proxyOptProc(int argc, char *const *argv, int opt) { switch (opt) { case 'C': while (*optarg) { switch (*optarg++) { case 'n': optind++; if (optind < argc) { context_string = argv[optind - 1]; } else { config_perror("No context name passed to -Cn"); } break; case 'c': netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_IGNORE_NO_COMMUNITY, 1); break; default: config_perror("unknown argument passed to -C"); break; } } break; default: break; /* * shouldn't get here */ } }
/* * parse_snmpNotifyFilterTable(): * parses .conf file entries needed to configure the mib. */ void parse_snmpNotifyFilterTable(const char *token, char *line) { size_t tmpint; struct snmpNotifyFilterTable_data *StorageTmp = SNMP_MALLOC_STRUCT(snmpNotifyFilterTable_data); DEBUGMSGTL(("snmpNotifyFilterTable", "parsing config... ")); if (StorageTmp == NULL) { config_perror("malloc failure"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpNotifyFilterProfileName, &StorageTmp->snmpNotifyFilterProfileNameLen); if (StorageTmp->snmpNotifyFilterProfileName == NULL) { config_perror ("invalid specification for snmpNotifyFilterProfileName"); return; } line = read_config_read_data(ASN_OBJECT_ID, line, &StorageTmp->snmpNotifyFilterSubtree, &StorageTmp->snmpNotifyFilterSubtreeLen); if (StorageTmp->snmpNotifyFilterSubtree == NULL) { config_perror("invalid specification for snmpNotifyFilterSubtree"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpNotifyFilterMask, &StorageTmp->snmpNotifyFilterMaskLen); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyFilterType, &tmpint); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyFilterStorageType, &tmpint); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyFilterRowStatus, &tmpint); snmpNotifyFilterTable_add(StorageTmp); DEBUGMSGTL(("snmpNotifyFilterTable", "done.\n")); }
void vacm_parse_setaccess(const char *token, char *param) { char *name, *context, *viewname, *viewval; int imodel, ilevel, iprefix; int viewnum; char *st; struct vacm_accessEntry *ap; if (_vacm_parse_access_common(token, param, &st, &name, &context, &imodel, &ilevel, &iprefix) == PARSE_FAIL) { return; } viewname = strtok_r(NULL, " \t\n", &st); if (!viewname) { config_perror("missing viewname parameter"); return; } viewval = strtok_r(NULL, " \t\n", &st); if (!viewval) { config_perror("missing viewval parameter"); return; } if (strlen(viewval) + 1 > sizeof(ap->views[VACM_VIEW_NOTIFY])) { config_perror("View value too long"); return; } viewnum = se_find_value_in_slist(VACM_VIEW_ENUM_NAME, viewname); if (viewnum < 0 || viewnum >= VACM_MAX_VIEWS) { config_perror("Illegal view name"); return; } ap = vacm_getAccessEntry(name, context, imodel, ilevel); if (!ap) { ap = vacm_createAccessEntry(name, context, imodel, ilevel); DEBUGMSGTL(("vacm:conf:setaccess", "no existing access found; creating a new one\n")); } else { DEBUGMSGTL(("vacm:conf:setaccess", "existing access found, using it\n")); } if (!ap) { config_perror("failed to create access entry"); return; } strcpy(ap->views[viewnum], viewval); ap->contextMatch = iprefix; ap->storageType = SNMP_STORAGE_PERMANENT; ap->status = SNMP_ROW_ACTIVE; free(ap->reserved); ap->reserved = NULL; }
void parse_lookupResultsTable(const char *token, char *line) { size_t tmpint; struct lookupResultsTable_data *StorageTmp = SNMP_MALLOC_STRUCT(lookupResultsTable_data); DEBUGMSGTL(("lookupResultsTable", "parsing config... ")); if (StorageTmp == NULL) { config_perror("malloc failure"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->lookupCtlOwnerIndex, &StorageTmp->lookupCtlOwnerIndexLen); if (StorageTmp->lookupCtlOwnerIndex == NULL) { config_perror("invalid specification for lookupCtlOwnerIndex"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->lookupCtlOperationName, &StorageTmp->lookupCtlOperationNameLen); if (StorageTmp->lookupCtlOperationName == NULL) { config_perror("invalid specification for lookupCtlOperationName"); return; } line = read_config_read_data(ASN_UNSIGNED, line, &StorageTmp->lookupResultsIndex, &tmpint); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->lookupResultsAddressType, &tmpint); line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->lookupResultsAddress, &StorageTmp->lookupResultsAddressLen); if (StorageTmp->lookupResultsAddress == NULL) { config_perror("invalid specification for lookupResultsAddress"); return; } lookupResultsTable_inadd(StorageTmp); /* lookupResultsTable_cleaner(lookupResultsTableStorage); */ DEBUGMSGTL(("lookupResultsTable", "done.\n")); }
/* * parse_snmpNotifyFilterProfileTable(): * parses .conf file entries needed to configure the mib. */ void parse_snmpNotifyFilterProfileTable(const char *token, char *line) { size_t tmpint; struct snmpNotifyFilterProfileTable_data *StorageTmp = SNMP_MALLOC_STRUCT(snmpNotifyFilterProfileTable_data); DEBUGMSGTL(("snmpNotifyFilterProfileTable", "parsing config... ")); if (StorageTmp == NULL) { config_perror("malloc failure"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpTargetParamsName, &StorageTmp->snmpTargetParamsNameLen); if (StorageTmp->snmpTargetParamsName == NULL) { config_perror("invalid specification for snmpTargetParamsName"); return; } line = read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->snmpNotifyFilterProfileName, &StorageTmp->snmpNotifyFilterProfileNameLen); if (StorageTmp->snmpNotifyFilterProfileName == NULL) { config_perror("invalid specification for snmpNotifyFilterProfileName"); return; } line = read_config_read_data(ASN_INTEGER, line, &StorageTmp->snmpNotifyFilterProfileStorType, &tmpint); line = read_config_read_data(ASN_INTEGER, line, &StorageTmp-> snmpNotifyFilterProfileRowStatus, &tmpint); if (snmpNotifyFilterProfileTable_add(StorageTmp) != SNMPERR_SUCCESS){ SNMP_FREE(StorageTmp->snmpTargetParamsName); SNMP_FREE(StorageTmp->snmpNotifyFilterProfileName); SNMP_FREE(StorageTmp); } DEBUGMSGTL(("snmpNotifyFilterProfileTable", "done.\n")); }
/*******************************************************************-o-****** * snmpv3_secLevel_conf * * Parameters: * *word * *cptr * * Line syntax: * defSecurityLevel "noAuthNoPriv" | "authNoPriv" | "authPriv" */ void snmpv3_secLevel_conf(const char *word, char *cptr) { char buf[1024]; if (strcasecmp(cptr, "noAuthNoPriv") == 0 || strcmp(cptr, "1") == 0 || strcasecmp(cptr, "nanp") == 0) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_NOAUTH); } else if (strcasecmp(cptr, "authNoPriv") == 0 || strcmp(cptr, "2") == 0 || strcasecmp(cptr, "anp") == 0) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHNOPRIV); } else if (strcasecmp(cptr, "authPriv") == 0 || strcmp(cptr, "3") == 0 || strcasecmp(cptr, "ap") == 0) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHPRIV); } else { snprintf(buf, sizeof(buf), "Unknown security level: %s", cptr); buf[ sizeof(buf)-1 ] = 0; config_perror(buf); } DEBUGMSGTL(("snmpv3", "default secLevel set to: %s = %d\n", cptr, netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECLEVEL))); }
void hpiSubagent_parse_config_traps (const char *token, char *cptr) { int x = -1; char buf[BUFSIZ]; if (!strncasecmp (cptr, "on", 2) || !strncasecmp (cptr, "yes", 3) || !strncasecmp (cptr, "true", 4)) { x = AGENT_TRUE; snmp_log (LOG_INFO, "Sending EVENTS during startup.\n"); } else if (!strncasecmp (cptr, "off", 3) || !strncasecmp (cptr, "no", 2) || !strncasecmp (cptr, "false", 5)) { x = AGENT_FALSE; snmp_log (LOG_INFO, "Not sending events during startup.\n"); } if ((x != AGENT_TRUE) && (x != AGENT_FALSE)) { sprintf (buf, "hpiSubagent: '%s' unrecognized", cptr); config_perror (buf); } else { send_traps_on_startup = x; } }
void netsnmp_parse_iqueryVersion(const char *token, char *line) { char buf[1024]; #ifndef NETSNMP_DISABLE_SNMPV1 if (!strcmp( line, "1" )) netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_VERSION, SNMP_VERSION_1); else #endif #ifndef NETSNMP_DISABLE_SNMPV2C if (!strcmp( line, "2" ) || !strcasecmp( line, "2c" )) netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_VERSION, SNMP_VERSION_2c); else #endif if (!strcmp( line, "3" )) netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_VERSION, SNMP_VERSION_3); else { snprintf(buf, sizeof(buf), "Unknown version: %s", line); buf[ sizeof(buf)-1 ] = 0; config_perror(buf); } }
void snmpv3_privtype_conf(const char *word, char *cptr) { int testcase = 0; #ifndef NETSNMP_DISABLE_DES if (strcasecmp(cptr, "DES") == 0) { testcase = 1; defaultPrivType = usmDESPrivProtocol; } #endif #if HAVE_AES /* XXX AES: assumes oid length == des oid length */ if (strcasecmp(cptr, "AES128") == 0 || strcasecmp(cptr, "AES") == 0) { testcase = 1; defaultPrivType = usmAES128PrivProtocol; } #endif if (testcase == 0) config_perror("Unknown privacy type"); defaultPrivTypeLen = SNMP_DEFAULT_PRIV_PROTOLEN; DEBUGMSGTL(("snmpv3", "set default privacy type: %s\n", cptr)); }
void opencc_perror(const char* spec) { if (!lib_initialized) { lib_initialize(); } perr(spec); perr("\n"); switch (errnum) { case OPENCC_ERROR_VOID: break; case OPENCC_ERROR_DICTLOAD: dictionary_perror(_("Dictionary loading error")); break; case OPENCC_ERROR_CONFIG: config_perror(_("Configuration error")); break; case OPENCC_ERROR_CONVERTER: converter_perror(_("Converter error")); break; case OPENCC_ERROR_ENCODING: perr(_("Encoding error")); break; default: perr(_("Unknown")); } perr("\n"); }
/*******************************************************************-o-****** * engineIDType_conf * * Parameters: * *word * *cptr * * Line syntax: * engineIDType <1 or 3> * 1 is default for IPv4 engine ID type. Will automatically * chose between IPv4 & IPv6 if either 1 or 2 is specified. * 2 is for IPv6. * 3 is hardware (MAC) address, currently supported under Linux */ void engineIDType_conf(const char *word, char *cptr) { engineIDType = atoi(cptr); /* * verify valid type selected */ switch (engineIDType) { case ENGINEID_TYPE_IPV4: /* IPv4 */ case ENGINEID_TYPE_IPV6: /* IPv6 */ /* * IPV? is always good */ break; #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR) case ENGINEID_TYPE_MACADDR: /* MAC address */ break; #endif default: /* * unsupported one chosen */ config_perror("Unsupported enginedIDType, forcing IPv4"); engineIDType = ENGINEID_TYPE_IPV4; } DEBUGMSGTL(("snmpv3", "engineIDType: %d\n", engineIDType)); }
void version_conf(const char *word, char *cptr) { int valid = 0; #ifndef NETSNMP_DISABLE_SNMPV1 if ((strcmp(cptr, "1") == 0) || (strcmp(cptr, "v1") == 0)) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, NETSNMP_DS_SNMP_VERSION_1); /* bogus value */ valid = 1; } #endif #ifndef NETSNMP_DISABLE_SNMPV2C if ((strcasecmp(cptr, "2c") == 0) || (strcasecmp(cptr, "v2c") == 0)) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, NETSNMP_DS_SNMP_VERSION_2c); valid = 1; } #endif if ((strcasecmp(cptr, "3" ) == 0) || (strcasecmp(cptr, "v3" ) == 0)) { netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, NETSNMP_DS_SNMP_VERSION_3); valid = 1; } if (!valid) { config_perror("Unknown version specification"); return; } DEBUGMSGTL(("snmpv3", "set default version to %d\n", netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION))); }
static void dlmod_parse_config(char *token, char *cptr) { char *dlm_name, *dlm_path; struct dlmod *dlm; if (cptr == NULL) { config_perror("Bad dlmod line"); return; } /* * remove comments */ *(cptr + strcspn(cptr, "#;\r\n")) = '\0'; dlm = dlmod_create_module(); if (!dlm) return; /* * dynamic module name */ dlm_name = strtok(cptr, "\t "); if (dlm_name == NULL) { config_perror("Bad dlmod line"); dlmod_delete_module(dlm); return; } strncpy(dlm->name, dlm_name, sizeof(dlm->name)); /* * dynamic module path */ dlm_path = strtok(NULL, "\t "); if (dlm_path) strncpy(dlm->path, dlm_path, sizeof(dlm->path)); else strncpy(dlm->path, dlm_name, sizeof(dlm->path)); dlmod_load_module(dlm); if (dlm->status == DLMOD_ERROR) snmp_log(LOG_ERR, "%s\n", dlm->error); }
void execfix_parse_config(char *token, char* cptr) { char tmpname[STRMAX]; struct extensible *execp; /* don't allow two entries with the same name */ cptr = copy_word(cptr,tmpname); if ((execp = get_exec_by_name(tmpname)) == NULL) { config_perror("No exec entry registered for this exec name yet."); return; } if (strlen(cptr) > sizeof(execp->fixcmd)) { config_perror("fix command too long."); return; } strcpy(execp->fixcmd, cptr); }
void snmpv3_privtype_conf(const char *word, char *cptr) { if (strcasecmp(cptr,"DES") == 0) defaultPrivType = SNMP_DEFAULT_PRIV_PROTO; else config_perror("Unknown privacy type"); defaultPrivTypeLen = SNMP_DEFAULT_PRIV_PROTOLEN; DEBUGMSGTL(("snmpv3","set default privacy type: %s\n", cptr)); }
static void parse_storage_config(const char *token, char *cptr) { char *val; int ival; char *st; val = strtok_r(cptr, " \t", &st); if (!val) { config_perror("Missing FLAG parameter in storageUseNFS"); return; } ival = atoi(val); if (ival < 1 || ival > 2) { config_perror("storageUseNFS must be 1 or 2"); return; } storageUseNFS = (ival == 1) ? 1 : 0; }
void vacm_parse_access(const char *token, char *param) { char *name, *context, *readView, *writeView, *notify; int imodel, ilevel, iprefix; struct vacm_accessEntry *ap; char *st; if (_vacm_parse_access_common(token, param, &st, &name, &context, &imodel, &ilevel, &iprefix) == PARSE_FAIL) { return; } readView = strtok_r(NULL, " \t\n", &st); if (!readView) { config_perror("missing readView parameter"); return; } writeView = strtok_r(NULL, " \t\n", &st); if (!writeView) { config_perror("missing writeView parameter"); return; } notify = strtok_r(NULL, " \t\n", &st); if (!notify) { config_perror("missing notifyView parameter"); return; } if (strlen(readView) + 1 > sizeof(ap->views[VACM_VIEW_READ])) { config_perror("readView too long"); return; } if (strlen(writeView) + 1 > sizeof(ap->views[VACM_VIEW_WRITE])) { config_perror("writeView too long"); return; } if (strlen(notify) + 1 > sizeof(ap->views[VACM_VIEW_NOTIFY])) { config_perror("notifyView too long"); return; } ap = vacm_createAccessEntry(name, context, imodel, ilevel); if (!ap) { config_perror("failed to create access entry"); return; } strcpy(ap->views[VACM_VIEW_READ], readView); strcpy(ap->views[VACM_VIEW_WRITE], writeView); strcpy(ap->views[VACM_VIEW_NOTIFY], notify); ap->contextMatch = iprefix; ap->storageType = SNMP_STORAGE_PERMANENT; ap->status = SNMP_ROW_ACTIVE; free(ap->reserved); ap->reserved = NULL; }
void snmpd_parse_config_authtrap(char *token, char *cptr) { int i; i = atoi(cptr); if (i < 1 || i > 2) config_perror("authtrapenable must be 1 or 2"); else snmp_enableauthentraps = i; }
void vacm_parse_group(const char *token, char *param) { char group[VACMSTRINGLEN], model[VACMSTRINGLEN], security[VACMSTRINGLEN]; int imodel; struct vacm_groupEntry *gp = NULL; char *st; st = copy_nword(param, group, sizeof(group)-1); st = copy_nword(st, model, sizeof(model)-1); st = copy_nword(st, security, sizeof(security)-1); if (group[0] == 0) { config_perror("missing GROUP parameter"); return; } if (model[0] == 0) { config_perror("missing MODEL parameter"); return; } if (security[0] == 0) { config_perror("missing SECURITY parameter"); return; } if (strcasecmp(model, "v1") == 0) imodel = SNMP_SEC_MODEL_SNMPv1; else if (strcasecmp(model, "v2c") == 0) imodel = SNMP_SEC_MODEL_SNMPv2c; else if (strcasecmp(model, "any") == 0) { config_perror ("bad security model \"any\" should be: v1, v2c, usm or a registered security plugin name - installing anyway"); imodel = SNMP_SEC_MODEL_ANY; } else { if ((imodel = se_find_value_in_slist("snmp_secmods", model)) == SE_DNE) { config_perror ("bad security model, should be: v1, v2c or usm or a registered security plugin name"); return; } } if (strlen(security) + 1 > sizeof(gp->groupName)) { config_perror("security name too long"); return; } gp = vacm_createGroupEntry(imodel, security); if (!gp) { config_perror("failed to create group entry"); return; } strncpy(gp->groupName, group, sizeof(gp->groupName)); gp->groupName[ sizeof(gp->groupName)-1 ] = 0; gp->storageType = SNMP_STORAGE_PERMANENT; gp->status = SNMP_ROW_ACTIVE; free(gp->reserved); gp->reserved = NULL; }
static void _parse_interface_config(const char *token, char *cptr) { netsnmp_conf_if_list *if_ptr, *if_new; char *name, *type, *speed, *ecp; char *st; name = strtok_r(cptr, " \t", &st); if (!name) { config_perror("Missing NAME parameter"); return; } type = strtok_r(NULL, " \t", &st); if (!type) { config_perror("Missing TYPE parameter"); return; } speed = strtok_r(NULL, " \t", &st); if (!speed) { config_perror("Missing SPEED parameter"); return; } if_ptr = conf_list; while (if_ptr) if (strcmp(if_ptr->name, name)) if_ptr = if_ptr->next; else break; if (if_ptr) config_pwarn("Duplicate interface specification"); if_new = SNMP_MALLOC_TYPEDEF(netsnmp_conf_if_list); if (!if_new) { config_perror("Out of memory"); return; } if_new->speed = strtoull(speed, &ecp, 0); if (*ecp) { config_perror("Bad SPEED value"); free(if_new); return; } if_new->type = strtol(type, &ecp, 0); if (*ecp || if_new->type < 0) { config_perror("Bad TYPE"); free(if_new); return; } if_new->name = strdup(name); if (!if_new->name) { config_perror("Out of memory"); free(if_new); return; } if_new->next = conf_list; conf_list = if_new; }