/*! \fn int db_insert(MYSQL *mysql, const char *query) * \brief inserts a row or rows in a database table. * \param mysql the database connection object * \param query the database query to execute * * Unless the SQL_readonly boolean is set to TRUE, the function will execute * the SQL statement specified in the query variable. * * \return TRUE if successful, or FALSE if not. * */ int db_insert(MYSQL *mysql, const char *query) { int error; int error_count = 0; char query_frag[BUFSIZE]; /* save a fragment just in case */ snprintf(query_frag, BUFSIZE, "%s", query); /* show the sql query */ if (set.log_level == 5) { CACTID_LOG_DEBUG(("DEBUG: SQL:'%s'", query_frag)); } while(1) { if (set.SQL_readonly == FALSE) { if (mysql_query(mysql, query)) { error = mysql_errno(mysql); if ((error == 1213) || (error == 1205)) { usleep(50000); error_count++; if (error_count > 30) { CACTID_LOG(("ERROR: Too many Lock/Deadlock errors occurred!, SQL Fragment:'%s'\n", query_frag)); return FALSE; } continue; }else{ CACTID_LOG(("ERROR: A database insert failed! Error:'%i', SQL Fragment:'%s'\n", error, query_frag)); return FALSE; } }else{ return TRUE; } }else{ return TRUE; } } }
/*! \fn MYSQL_RES *db_query(MYSQL *mysql, const char *query) * \brief executes a query and returns a pointer to the result set. * \param mysql the database connection object * \param query the database query to execute * * This function will execute the SQL statement specified in the query variable. * * \return MYSQL_RES a MySQL result structure * */ MYSQL_RES *db_query(MYSQL *mysql, const char *query) { MYSQL_RES *mysql_res = 0; int error = 0; int error_count = 0; char query_frag[BUFSIZE]; /* save a fragment just in case */ snprintf(query_frag, BUFSIZE, "%s", query); /* show the sql query */ CACTID_LOG_DEBUG(("DEBUG: SQL:'%s'", query_frag)); while (1) { if (mysql_query(mysql, query)) { error = mysql_errno(mysql); if ((error == 1213) || (error == 1205)) { #ifndef SOLAR_THREAD usleep(50000); #endif error_count++; if (error_count > 30) { CACTID_LOG(("ERROR: Too many Lock/Deadlock errors occurred!, SQL Fragment:'%s'\n", query_frag)); die("ERROR: Fatal MySQL Query Error, exiting!"); } continue; } break; }else{ mysql_res = mysql_store_result(mysql); return mysql_res; } } }
/*! \fn main(int argc, char *argv[]) * \brief The Cactid program entry point * \param argc The number of arguments passed to the function plus one (+1) * \param argv An array of the command line arguments * * The Cactid entry point. This function performs the following tasks. * 1) Processes command line input parameters * 2) Processes the Cactid configuration file to obtain database access information * 3) Process runtime parameters from the settings table * 4) Initialize the runtime threads and mutexes for the threaded environment * 5) Initialize Net-SNMP, MySQL, and the PHP Script Server (if required) * 6) Spawns X threads in order to process hosts * 7) Loop until either all hosts have been processed or until the poller runtime * has been exceeded * 8) Close database and free variables * 9) Log poller process statistics if required * 10) Exit * * Note: Command line runtime parameters override any database settings. * * \return 0 if SUCCESS, or -1 if FAILED * */ int main(int argc, char *argv[]) { struct timeval now; char *conf_file = NULL; double begin_time, end_time, current_time; int poller_interval; int num_rows; int device_counter = 0; int poller_counter = 0; int last_active_threads = 0; long int EXTERNAL_THREAD_SLEEP = 100000; long int internal_thread_sleep; time_t nowbin; struct tm now_time; struct tm *now_ptr; pthread_t* threads = NULL; pthread_attr_t attr; int* ids = NULL; MYSQL mysql; MYSQL_RES *result = NULL; MYSQL_ROW mysql_row; int canexit = 0; int host_id; int i; int mutex_status = 0; int thread_status = 0; UNUSED_PARAMETER(argc); /* we operate strictly with argv */ /* establish php processes and initialize space */ php_processes = (php_t*) calloc(MAX_PHP_SERVERS, sizeof(php_t)); for (i = 0; i < MAX_PHP_SERVERS; i++) { php_processes[i].php_state = PHP_BUSY; } /* set start time for cacti */ begin_time = get_time_as_double(); /* get time for poller_output table */ if (time(&nowbin) == (time_t) - 1) { die("ERROR: Could not get time of day from time()\n"); } localtime_r(&nowbin,&now_time); now_ptr = &now_time; if (strftime(start_datetime, sizeof(start_datetime), "%Y-%m-%d %H:%M:%S", now_ptr) == (size_t) 0) { die("ERROR: Could not get string from strftime()\n"); } /* set default verbosity */ set.log_level = POLLER_VERBOSITY_LOW; /* get static defaults for system */ config_defaults(); /*! ---------------------------------------------------------------- * PROCESS COMMAND LINE * * Run through the list of ARGV words looking for parameters we * know about. Most have two flavors (-C + --conf), and many * themselves take a parameter. * * These parameters can be structured in two ways: * * --conf=FILE both parts in one argv[] string * --conf FILE two separate argv[] strings * * We set "arg" to point to "--conf", and "opt" to point to FILE. * The helper routine * * In each loop we set "arg" to next argv[] string, then look * to see if it has an equal sign. If so, we split it in half * and point to the option separately. * * NOTE: most direction to the program is given with dash-type * parameters, but we also allow standalone numeric device IDs * in "first last" format: this is how poller.php calls this * program. */ /* initialize some global variables */ set.start_host_id = -1; set.end_host_id = -1; set.php_initialized = FALSE; set.logfile_processed = FALSE; set.parent_fork = CACTID_PARENT; for (argv++; *argv; argv++) { char *arg = *argv; char *opt = strchr(arg, '='); /* pick off the =VALUE part */ if (opt) *opt++ = '\0'; if (STRIMATCH(arg, "-f") || STRIMATCH(arg, "--first")) { if (HOSTID_DEFINED(set.start_host_id)) { die("ERROR: %s can only be used once", arg); } set.start_host_id = atoi(opt = getarg(opt, &argv)); if (!HOSTID_DEFINED(set.start_host_id)) { die("ERROR: '%s=%s' is invalid first-host ID", arg, opt); } } else if (STRIMATCH(arg, "-l") || STRIMATCH(arg, "--last")) { if (HOSTID_DEFINED(set.end_host_id)) { die("ERROR: %s can only be used once", arg); } set.end_host_id = atoi(opt = getarg(opt, &argv)); if (!HOSTID_DEFINED(set.end_host_id)) { die("ERROR: '%s=%s' is invalid last-host ID", arg, opt); } } else if (STRIMATCH(arg, "-p") || STRIMATCH(arg, "--poller")) { set.poller_id = atoi(getarg(opt, &argv)); } else if (STRIMATCH(arg, "-h") || STRIMATCH(arg, "-v") || STRIMATCH(arg, "--help") || STRIMATCH(arg, "--version")) { display_help(); exit(EXIT_SUCCESS); } else if (STRIMATCH(arg, "-O") || STRIMATCH(arg, "--option")) { char *setting = getarg(opt, &argv); char *value = strchr(setting, ':'); if (*value) { *value++ = '\0'; }else{ die("ERROR: -O requires setting:value"); } set_option(setting, value); } else if (STRIMATCH(arg, "-R") || STRIMATCH(arg, "--readonly") || STRIMATCH(arg, "--read-only")) { set.SQL_readonly = TRUE; } else if (STRIMATCH(arg, "-C") || STRIMATCH(arg, "--conf")) { conf_file = strdup(getarg(opt, &argv)); } else if (STRIMATCH(arg, "-S") || STRIMATCH(arg, "--stdout")) { set_option("log_destination", "STDOUT"); } else if (STRIMATCH(arg, "-L") || STRIMATCH(arg, "--log")) { set_option("log_destination", getarg(opt, &argv)); } else if (STRIMATCH(arg, "-V") || STRIMATCH(arg, "--verbosity")) { set_option("log_verbosity", getarg(opt, &argv)); } else if (STRIMATCH(arg, "--snmponly") || STRIMATCH(arg, "--snmp-only")) { set.snmponly = TRUE; } else if (!HOSTID_DEFINED(set.start_host_id) && all_digits(arg)) { set.start_host_id = atoi(arg); } else if (!HOSTID_DEFINED(set.end_host_id) && all_digits(arg)) { set.end_host_id = atoi(arg); } else { die("ERROR: %s is an unknown command-line parameter", arg); } } /* we require either both the first and last hosts, or niether host */ if (HOSTID_DEFINED(set.start_host_id) != HOSTID_DEFINED(set.end_host_id)) { die("ERROR: must provide both -f/-l, or neither"); } if (set.start_host_id > set.end_host_id) { die("ERROR: Invalid row spec; first host_id must be less than the second"); } /* read configuration file to establish local environment */ if (conf_file) { if ((read_cactid_config(conf_file)) < 0) { die("ERROR: Could not read config file: %s\n", conf_file); } }else{ if (!(conf_file = calloc(1, BUFSIZE))) { die("ERROR: Fatal malloc error: cactid.c conf_file!\n"); } for (i=0; i<CONFIG_PATHS; i++) { snprintf(conf_file, BUFSIZE-1, "%s%s", config_paths[i], DEFAULT_CONF_FILE); if (read_cactid_config(conf_file) >= 0) { break; } if (i == CONFIG_PATHS-1) { snprintf(conf_file, BUFSIZE-1, "%s%s", config_paths[0], DEFAULT_CONF_FILE); } } } /* read settings table from the database to further establish environment */ read_config_options(); /* set the poller interval for those who use less than 5 minute intervals */ if (set.poller_interval == 0) { poller_interval = 300; }else { poller_interval = set.poller_interval; } /* calculate the external_tread_sleep value */ internal_thread_sleep = EXTERNAL_THREAD_SLEEP * set.num_parent_processes / 2; if (set.log_level == POLLER_VERBOSITY_DEBUG) { CACTID_LOG_DEBUG(("CACTID: Version %s starting\n", VERSION)); }else{ printf("CACTID: Version %s starting\n", VERSION); } /* connect to database */ db_connect(set.dbdb, &mysql); /* initialize SNMP */ CACTID_LOG_DEBUG(("CACTID: Initializing Net-SNMP API\n")); snmp_cactid_init(); /* initialize PHP if required */ CACTID_LOG_DEBUG(("CACTID: Initializing PHP Script Server\n")); /* tell cactid that it is parent, and set the poller id */ set.parent_fork = CACTID_PARENT; set.poller_id = 0; /* initialize the script server */ if (set.php_required) { php_init(PHP_INIT); set.php_initialized = TRUE; set.php_current_server = 0; } /* obtain the list of hosts to poll */ { char querybuf[256], *qp = querybuf; qp += sprintf(qp, "SELECT id FROM host"); qp += sprintf(qp, " WHERE disabled=''"); qp += append_hostrange(qp, "id"); /* AND id BETWEEN a AND b */ qp += sprintf(qp, " ORDER BY id"); result = db_query(&mysql, querybuf); } num_rows = mysql_num_rows(result) + 1; /* add 1 for host = 0 */ if (!(threads = (pthread_t *)malloc(num_rows * sizeof(pthread_t)))) { die("ERROR: Fatal malloc error: cactid.c threads!\n"); } if (!(ids = (int *)malloc(num_rows * sizeof(int)))) { die("ERROR: Fatal malloc error: cactid.c host id's!\n"); } /* initialize threads and mutexes */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); init_mutexes(); CACTID_LOG_DEBUG(("DEBUG: Initial Value of Active Threads is %i\n", active_threads)); /* tell fork processes that they are now active */ set.parent_fork = CACTID_FORK; /* loop through devices until done */ while ((device_counter < num_rows) && (canexit == 0)) { mutex_status = thread_mutex_trylock(LOCK_THREAD); switch (mutex_status) { case 0: if (last_active_threads != active_threads) { last_active_threads = active_threads; } while ((active_threads < set.threads) && (device_counter < num_rows)) { if (device_counter > 0) { mysql_row = mysql_fetch_row(result); host_id = atoi(mysql_row[0]); ids[device_counter] = host_id; }else{ ids[device_counter] = 0; } /* create child process */ thread_status = pthread_create(&threads[device_counter], &attr, child, &ids[device_counter]); switch (thread_status) { case 0: CACTID_LOG_DEBUG(("DEBUG: Valid Thread to be Created\n")); device_counter++; active_threads++; CACTID_LOG_DEBUG(("DEBUG: The Value of Active Threads is %i\n", active_threads)); break; case EAGAIN: CACTID_LOG(("ERROR: The System Lacked the Resources to Create a Thread\n")); break; case EFAULT: CACTID_LOG(("ERROR: The Thread or Attribute Was Invalid\n")); break; case EINVAL: CACTID_LOG(("ERROR: The Thread Attribute is Not Initialized\n")); break; default: CACTID_LOG(("ERROR: Unknown Thread Creation Error\n")); break; } usleep(internal_thread_sleep); /* get current time and exit program if time limit exceeded */ if (poller_counter >= 20) { current_time = get_time_as_double(); if ((current_time - begin_time + 6) > poller_interval) { CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n")); canexit = 1; break; } poller_counter = 0; }else{ poller_counter++; } } thread_mutex_unlock(LOCK_THREAD); break; case EDEADLK: CACTID_LOG(("ERROR: Deadlock Occured\n")); break; case EBUSY: break; case EINVAL: CACTID_LOG(("ERROR: Attempt to Unlock an Uninitialized Mutex\n")); break; case EFAULT: CACTID_LOG(("ERROR: Attempt to Unlock an Invalid Mutex\n")); break; default: CACTID_LOG(("ERROR: Unknown Mutex Lock Error Code Returned\n")); break; } usleep(internal_thread_sleep); /* get current time and exit program if time limit exceeded */ if (poller_counter >= 20) { current_time = get_time_as_double(); if ((current_time - begin_time + 6) > poller_interval) { CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n")); canexit = 1; break; } poller_counter = 0; }else{ poller_counter++; } } /* wait for all threads to complete */ while (canexit == 0) { if (thread_mutex_trylock(LOCK_THREAD) == 0) { if (last_active_threads != active_threads) { last_active_threads = active_threads; } if (active_threads == 0) { canexit = 1; } thread_mutex_unlock(LOCK_THREAD); } usleep(EXTERNAL_THREAD_SLEEP); /* get current time and exit program if time limit exceeded */ if (poller_counter >= 20) { current_time = get_time_as_double(); if ((current_time - begin_time + 6) > poller_interval) { CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n")); canexit = 1; break; } poller_counter = 0; }else{ poller_counter++; } } /* tell Cactid that it is now parent */ set.parent_fork = CACTID_PARENT; /* print out stats */ gettimeofday(&now, NULL); /* update the db for |data_time| on graphs */ db_insert(&mysql, "replace into settings (name,value) values ('date',NOW())"); db_insert(&mysql, "insert into poller_time (poller_id, start_time, end_time) values (0, NOW(), NOW())"); /* cleanup and exit program */ pthread_attr_destroy(&attr); CACTID_LOG_DEBUG(("DEBUG: Thread Cleanup Complete\n")); /* close the php script server */ if (set.php_required) { php_close(PHP_INIT); } CACTID_LOG_DEBUG(("DEBUG: PHP Script Server Pipes Closed\n")); /* free malloc'd variables */ free(threads); free(ids); free(conf_file); CACTID_LOG_DEBUG(("DEBUG: Allocated Variable Memory Freed\n")); /* shutdown SNMP */ snmp_cactid_close(); CACTID_LOG_DEBUG(("CACTID: Net-SNMP API Shutdown Completed\n")); /* close mysql */ mysql_free_result(result); mysql_close(&mysql); CACTID_LOG_DEBUG(("DEBUG: MYSQL Free & Close Completed\n")); /* finally add some statistics to the log and exit */ end_time = TIMEVAL_TO_DOUBLE(now); CACTID_LOG_MEDIUM(("Time: %.4f s, Threads: %i, Hosts: %i\n", (end_time - begin_time), set.threads, num_rows)); exit(EXIT_SUCCESS); }
/*! \fn char *snmp_get_multi(host_t *current_host, snmp_oids_t *snmp_oids, int num_oids) * \brief performs multiple OID snmp_get's in a single network call * * This function will a group of snmp OID's for a host. The host snmp * session must already be established. The function will modify elements of * the snmp_oids array with the results from the snmp api call. * */ void snmp_get_multi(host_t *current_host, snmp_oids_t *snmp_oids, int num_oids) { struct snmp_pdu *pdu = NULL; struct snmp_pdu *response = NULL; struct variable_list *vars = NULL; int status; int i; int max_repetitions = 1; int non_repeaters = 0; struct nameStruct { oid name[MAX_OID_LEN]; size_t name_len; } *name, *namep; /* load up oids */ namep = name = (struct nameStruct *) calloc(num_oids, sizeof(*name)); pdu = snmp_pdu_create(SNMP_MSG_GET); for (i = 0; i < num_oids; i++) { namep->name_len = MAX_OID_LEN; if (!snmp_parse_oid(snmp_oids[i].oid, namep->name, &namep->name_len)) { CACTID_LOG(("Host[%i] ERROR: Problems parsing Multi SNMP OID! (oid: %s)\n", current_host->id, snmp_oids[i].oid)); /* Mark this OID as "bad" */ SET_UNDEFINED(snmp_oids[i].result); }else{ snmp_add_null_var(pdu, namep->name, namep->name_len); } namep++; } status = STAT_DESCRIP_ERROR; /* execute the multi-get request */ retry: status = snmp_sess_synch_response(current_host->snmp_session, pdu, &response); /* liftoff, successful poll, process it!! */ if (status == STAT_SUCCESS) { if (response == NULL) { CACTID_LOG(("ERROR: An internal Net-Snmp error condition detected in Cacti snmp_get_multi\n")); status = STAT_ERROR; }else{ if (response->errstat == SNMP_ERR_NOERROR) { vars = response->variables; for(i = 0; i < num_oids && vars; i++) { if (!IS_UNDEFINED(snmp_oids[i].result)) { #ifdef USE_NET_SNMP snmp_snprint_value(snmp_oids[i].result, sizeof(snmp_oids[i].result), vars->name, vars->name_length, vars); #else sprint_value(snmp_oids[i].result, vars->name, vars->name_length, vars); #endif vars = vars->next_variable; } } }else{ if (response->errindex != 0) { /* removed errored OID and then retry */ int count; /* Find our index against errindex */ count = 0; for(i = 0; i < num_oids && count < response->errindex; i++) { if ( ! IS_UNDEFINED(snmp_oids[i].result) ) { count++; } } i--; SET_UNDEFINED(snmp_oids[i].result); for (count = 1, vars = response->variables; vars && count != response->errindex; vars = vars->next_variable, count++) { } pdu = snmp_fix_pdu(response, SNMP_MSG_GET); snmp_free_pdu(response); response = NULL; if (pdu != NULL) { goto retry; }else{ status = STAT_DESCRIP_ERROR; } }else{ status = STAT_DESCRIP_ERROR; } } } } if (status != STAT_SUCCESS) { current_host->ignore_host = 1; for (i = 0; i < num_oids; i++) { SET_UNDEFINED(snmp_oids[i].result); } } if (response != NULL) { snmp_free_pdu(response); } }
/*! \fn char *snmp_getnext(host_t *current_host, char *snmp_oid) * \brief performs a single snmp_getnext for a specific snmp OID * * This function will poll a specific snmp OID for a host. The host snmp * session must already be established. * * \return returns the character representaton of the snmp OID, or "U" if * unsuccessful. * */ char *snmp_getnext(host_t *current_host, char *snmp_oid) { struct snmp_pdu *pdu = NULL; struct snmp_pdu *response = NULL; struct variable_list *vars = NULL; oid anOID[MAX_OID_LEN]; size_t anOID_len = MAX_OID_LEN; int status; char *result_string; if (!(result_string = (char *) malloc(BUFSIZE))) { die("ERROR: Fatal malloc error: snmp.c snmp_get!"); } result_string[0] = '\0'; status = STAT_DESCRIP_ERROR; if (current_host->snmp_session != NULL) { anOID_len = MAX_OID_LEN; pdu = snmp_pdu_create(SNMP_MSG_GETNEXT); if (!snmp_parse_oid(snmp_oid, anOID, &anOID_len)) { CACTID_LOG(("ERROR: Problems parsing SNMP OID\n")); SET_UNDEFINED(result_string); return result_string; }else{ snmp_add_null_var(pdu, anOID, anOID_len); } /* poll host */ status = snmp_sess_synch_response(current_host->snmp_session, pdu, &response); /* liftoff, successful poll, process it!! */ if (status == STAT_SUCCESS) { if (response == NULL) { CACTID_LOG(("ERROR: An internal Net-Snmp error condition detected in Cacti snmp_get\n")); SET_UNDEFINED(result_string); status = STAT_ERROR; }else{ if (response->errstat == SNMP_ERR_NOERROR) { vars = response->variables; #ifdef USE_NET_SNMP snprint_value(result_string, BUFSIZE, anOID, anOID_len, vars); #else sprint_value(result_string, anOID, anOID_len, vars); #endif } } } if (response) { snmp_free_pdu(response); response = NULL; } }else{ status = STAT_DESCRIP_ERROR; } if (status != STAT_SUCCESS) { current_host->ignore_host = TRUE; SET_UNDEFINED(result_string); } return result_string; }
/*! \fn void *snmp_host_init(int host_id, char *hostname, int snmp_version, * char *snmp_community, char *snmp_username, char *snmp_password, int snmp_port, * int snmp_timeout) * \brief initializes an snmp_session object for a Cactid host * * This function will initialize NET-SNMP or UCD-SNMP for the Cactid host * in question. * */ void *snmp_host_init(int host_id, char *hostname, int snmp_version, char *snmp_community, char *snmp_username, char *snmp_password, int snmp_port, int snmp_timeout) { void *sessp = NULL; struct snmp_session session; char hostnameport[BUFSIZE]; /* initialize SNMP */ snmp_sess_init(&session); #ifdef USE_NET_SNMP /* Prevent update of the snmpapp.conf file */ #ifdef NETSNMP_DS_LIB_DONT_PERSIST_STATE netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_PERSIST_STATE, 1); #endif /* Prevent update of the snmpapp.conf file */ #ifdef NETSNMP_DS_LIB_DISABLE_PERSISTENT_LOAD netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DISABLE_PERSISTENT_LOAD, 1); #endif #ifdef NETSNMP_DS_LIB_DONT_PRINT_UNITS netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_PRINT_UNITS, 1); #endif netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_QUICK_PRINT, 1); netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_PRINT_BARE_VALUE, 1); netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_NUMERIC_TIMETICKS, 1); #else ds_set_boolean(DS_LIBRARY_ID, DS_LIB_QUICK_PRINT, 1); ds_set_boolean(DS_LIBRARY_ID, DS_LIB_PRINT_BARE_VALUE, 1); ds_set_boolean(DS_LIBRARY_ID, DS_LIB_NUMERIC_TIMETICKS, 1); #endif /* verify snmp version is accurate */ if (snmp_version == 2) { session.version = SNMP_VERSION_2c; }else if (snmp_version == 1) { session.version = SNMP_VERSION_1; }else if (snmp_version == 3) { session.version = SNMP_VERSION_3; }else { CACTID_LOG(("Host[%i] ERROR: SNMP Version Error for Host '%s'\n", host_id, hostname)); return 0; } snprintf(hostnameport, sizeof(hostnameport), "%s:%i", hostname, snmp_port); session.peername = hostnameport; session.retries = 3; session.remote_port = snmp_port; session.timeout = (snmp_timeout * 1000); /* net-snmp likes microseconds */ if ((snmp_version == 2) || (snmp_version == 1)) { session.community = snmp_community; session.community_len = strlen(snmp_community); }else { /* set the SNMPv3 user name */ session.securityName = snmp_username; session.securityNameLen = strlen(session.securityName); session.securityAuthKeyLen = USM_AUTH_KU_LEN; /* set the authentication method to MD5 */ session.securityAuthProto = snmp_duplicate_objid(usmHMACMD5AuthProtocol, OIDSIZE(usmHMACMD5AuthProtocol)); session.securityAuthProtoLen = OIDSIZE(usmHMACMD5AuthProtocol); /* set the privacy protocol to none */ session.securityPrivProto = usmNoPrivProtocol; session.securityPrivProtoLen = OIDSIZE(usmNoPrivProtocol); session.securityPrivKeyLen = USM_PRIV_KU_LEN; /* set the security level to authenticate, but not encrypted */ session.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV; /* set the authentication key to the hashed version. The password must me at least 8 char */ if (generate_Ku(session.securityAuthProto, session.securityAuthProtoLen, (u_char *) snmp_password, strlen(snmp_password), session.securityAuthKey, &(session.securityAuthKeyLen)) != SNMPERR_SUCCESS) { CACTID_LOG(("SNMP: Error generating SNMPv3 Ku from authentication pass phrase.")); } } /* open SNMP Session */ thread_mutex_lock(LOCK_SNMP); sessp = snmp_sess_open(&session); thread_mutex_unlock(LOCK_SNMP); if (!sessp) { CACTID_LOG(("ERROR: Problem initializing SNMP session '%s'\n", hostname)); } return sessp; }