自学教程：C++ snmp_sess_init函数代码示例

/* * simple synchronous loop */void synchronous (void){  struct host *hp;  for (hp = hosts; hp->name; hp++) {    struct snmp_session ss, *sp;    struct oid *op;    snmp_sess_init(&ss);			/* initialize session */    ss.version = SNMP_VERSION_2c;    ss.peername = strdup(hp->name);    ss.community = strdup(hp->community);    ss.community_len = strlen(ss.community);    if (!(sp = snmp_open(&ss))) {      snmp_perror("snmp_open");      continue;    }    for (op = oids; op->Name; op++) {      struct snmp_pdu *req, *resp;      int status;      req = snmp_pdu_create(SNMP_MSG_GET);      snmp_add_null_var(req, op->Oid, op->OidLen);      status = snmp_synch_response(sp, req, &resp);      if (!print_result(status, sp, resp)) break;      snmp_free_pdu(resp);    }    snmp_close(sp);  }}

static void csnmp_host_open_session (host_definition_t *host){  struct snmp_session sess;  if (host->sess_handle != NULL)    csnmp_host_close_session (host);  snmp_sess_init (&sess);  sess.peername = host->address;  sess.community = (u_char *) host->community;  sess.community_len = strlen (host->community);  sess.version = (host->version == 1) ? SNMP_VERSION_1 : SNMP_VERSION_2c;  /* snmp_sess_open will copy the `struct snmp_session *'. */  host->sess_handle = snmp_sess_open (&sess);  if (host->sess_handle == NULL)  {    char *errstr = NULL;    snmp_error (&sess, NULL, NULL, &errstr);    ERROR ("snmp plugin: host %s: snmp_sess_open failed: %s",	host->name, (errstr == NULL) ? "Unknown problem" : errstr);    sfree (errstr);  }} /* void csnmp_host_open_session */

intinit_master_agent(int dest_port,                   int (*pre_parse) (struct snmp_session *, snmp_ipaddr),                  int (*post_parse) (struct snmp_session *, struct snmp_pdu *,int)){    struct snmp_session sess, *session;    if ( ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_ROLE) != MASTER_AGENT )	return 0; /* no error if ! MASTER_AGENT */    DEBUGMSGTL(("snmpd","installing master agent on port %d/n", dest_port));    snmp_sess_init( &sess );        sess.version = SNMP_DEFAULT_VERSION;    sess.peername = SNMP_DEFAULT_PEERNAME;    sess.community_len = SNMP_DEFAULT_COMMUNITY_LEN;         sess.local_port = dest_port;    sess.callback = handle_snmp_packet;    sess.authenticator = NULL;    sess.flags = ds_get_int(DS_APPLICATION_ID, DS_AGENT_FLAGS);    session = snmp_open_ex( &sess, pre_parse, 0, post_parse, 0, 0 );    if ( session == NULL ) {      /* diagnose snmp_open errors with the input struct snmp_session pointer */	snmp_sess_perror("init_master_agent", &sess);		return 1;    }    main_session = session;	return 0;}

void snmp_start_read_rssi(char *host) {	struct snmp_pdu *pdu;	struct snmp_session session;	const char *community = "public";	if (oid_rssi_ts1_length == 0 || oid_rssi_ts2_length == 0)		return;	snmp_rssi_received = 0;	if (snmp_session_rssi != NULL) {		snmp_close(snmp_session_rssi);		snmp_session_rssi = NULL;	}	snmp_sess_init(&session);	session.version = SNMP_VERSION_1;	session.peername = strdup(host);	session.community = (unsigned char *)strdup(community);	session.community_len = strlen(community);	session.callback = snmp_get_rssi_cb;	if (!(snmp_session_rssi = snmp_open(&session))) {		console_log("snmp error: error opening session to host %s/n", host);		return;	}	pdu = snmp_pdu_create(SNMP_MSG_GET);	snmp_add_null_var(pdu, oid_rssi_ts1, oid_rssi_ts1_length);	snmp_add_null_var(pdu, oid_rssi_ts2, oid_rssi_ts2_length);	if (!snmp_send(snmp_session_rssi, pdu))		console_log("snmp error: error sending rssi request to host %s/n", host);	free(session.peername);	free(session.community);}

/* Init SNMP Session * alorbach, 2008-02-12 */static rsRetVal omsnmp_initSession(instanceData *pData){	DEFiRet;	netsnmp_session session;		/* should not happen, but if session is not cleared yet - we do it now! */	if (pData->snmpsession != NULL)		omsnmp_exitSession(pData);	dbgprintf( "omsnmp_initSession: ENTER - Target = '%s' on Port = '%d'/n", pData->szTarget, pData->iPort);	putenv(strdup("POSIXLY_CORRECT=1"));		snmp_sess_init(&session);	session.version = pData->iSNMPVersion;	session.callback = NULL; /* NOT NEEDED */	session.callback_magic = NULL;	session.peername = (char*) pData->szTargetAndPort;		/* Set SNMP Community */	if (session.version == SNMP_VERSION_1 || session.version == SNMP_VERSION_2c)	{			session.community = (unsigned char *) pData->szCommunity;		session.community_len = strlen((char*) pData->szCommunity);	}	pData->snmpsession = snmp_open(&session);	if (pData->snmpsession == NULL) {		errmsg.LogError(0, RS_RET_SUSPENDED, "omsnmp_initSession: snmp_open to host '%s' on Port '%d' failed/n", pData->szTarget, pData->iPort);		/* Stay suspended */		iRet = RS_RET_SUSPENDED;	}	RETiRet;}

int init_ilo_snmp_session(struct ilo_snmp_priv * priv_ptr){  int ret = NAGIOS_ILO_SUCCESS_STATUS;  netsnmp_session session;  init_snmp("Nagios_hpilo_snmp");  snmp_sess_init(&session);  session.peername = strdup(priv_ptr->options.host);  session.community = strdup(priv_ptr->options.community);  session.community_len = strlen((char *) session.community);  session.version = priv_ptr->options.version;  session.timeout = priv_ptr->options.timeout;  session.retries = priv_ptr->options.retries;  priv_ptr->session = snmp_open(&session);  if (priv_ptr->session == NULL)     {      snmp_error(&session, &session.s_errno, &session.s_snmp_errno,		 &priv_ptr->err_str);      ret = NAGIOS_ILO_FAIL_STATUS;    }  return ret;}

QtNetSNMP::SNMPSession *QtNetSNMP::QSNMPCore::createSession(SNMPVersion version, const QString& community, const QString& agent) throw(QSNMPException){    SNMPSession session;    SNMPSession *openedSession;    std::string stdCommunity = community.toStdString();    std::string stdAgent = agent.toStdString();    if(version != SNMPv1 && version != SNMPv2)        throw QSNMPException("QSNMPCore :: Create Session :: Version not supported");    snmp_sess_init(&session);    session.remote_port = _port;    session.retries = _retries;    session.timeout = _timeout;    session.version = version;    session.community = reinterpret_cast<u_char *>(const_cast<char *>(stdCommunity.c_str()));    session.community_len = stdCommunity.length();    session.peername = const_cast<char *>(stdAgent.c_str());    SOCK_STARTUP;    if(!(openedSession = snmp_open(&session))) {        SOCK_CLEANUP;        throw QSNMPException("QSNMPCore :: Create Session :: Open Session");    }    return openedSession;}

static struct snmp_pdu *snmp_get_item(char *host, char *community, char *mib_item){	struct snmp_session session, *ss;	struct snmp_pdu *request = NULL, *result = NULL;	oid Oid[MAX_OID_LEN];	unsigned int oid_len = MAX_OID_LEN;	/* initialize the SNMP session */	snmp_sess_init(&session);	session.peername = host;	session.community = (uchar_t *)community;	session.community_len = strlen((const char *)session.community);	session.version = SNMP_VERSION_1;	session.retries = 0;	if ((ss = snmp_open(&session)) == NULL)		return (NULL);	/* add the requested data */	if (!read_objid(mib_item, Oid, &oid_len))		snmp_perror(mib_item);	/* initialize the request PDU */	request = snmp_pdu_create(SNMP_MSG_GET);	snmp_add_null_var(request, Oid, oid_len);	(void) snmp_synch_response(ss, request, &result);	snmp_close(ss);	return (result);}

HSNMP SnmpOpen(const char* ipAddress) {	HSNMP m_sessp;  struct snmp_session session;  snmp_sess_init(&session);			                  // structure defaults  session.version = SNMP_VERSION_2c;  session.peername = strdup(ipAddress);  session.community = (u_char*)strdup(readCommunity);  session.community_len = strlen((char*)session.community);  session.timeout = 100000;   // timeout (us)  session.retries = 3;        // retries  if(!(m_sessp = snmp_sess_open(&session))) {    int liberr, syserr;    char *errstr;    snmp_error(&session, &liberr, &syserr, &errstr);    syslog(LOG_ERR,"Open SNMP session for host /"%s/": %s",ipAddress,errstr);    free(errstr);    return 0;  }//  m_session = snmp_sess_session(m_sessp);     // get the session pointer   syslog(LOG_INFO,"SNMP session for host /"%s/" opened",ipAddress);  return m_sessp;}

static voidConnectingEntry(UNUSED tState self){    netsnmp_session init;    netsnmp_transport* t;    void* sess;    if(sessp) {        snmp_sess_close(sessp);        sessp = NULL;    }    snmp_sess_init(&init);    init.version = AGENTX_VERSION_1;    init.retries = 0; /* Retries are handled by the state machine */    init.timeout = SNMP_DEFAULT_TIMEOUT;    init.flags |= SNMP_FLAGS_STREAM_SOCKET;    init.callback = handle_agentx_response;    init.authenticator = NULL;    if(!(t = netsnmp_transport_open_client(                 "agentx", netsnmp_ds_get_string(                     NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_X_SOCKET)))) {        snmp_log(LOG_ERR, "Failed to connect to AgentX server/n");        change_state(&Exit);    } else if(!(sess = snmp_sess_add_ex(                           &init, t, NULL, agentx_parse, NULL, NULL,                           agentx_realloc_build, agentx_check_packet, NULL))) {        snmp_log(LOG_ERR, "Failed to create session/n");        change_state(&Exit);    } else {        sessp = sess;        change_state(&Opening);    }}

/* *  creates a snmp session */static struct snmp_session *MPC_open(char *hostname, int port, char *community){    static struct snmp_session session;    struct snmp_session *sptr;    DEBUGCALL;    /* create session */    snmp_sess_init(&session);    /* fill session */    session.peername = hostname;    session.version = SNMP_VERSION_1;    session.remote_port = port;    session.community = (u_char *)community;    session.community_len = strlen(community);    session.retries = 5;    session.timeout = 1000000;    /* open session */    sptr = snmp_open(&session);    if (sptr == NULL) {        MPC_error(&session, __FUNCTION__, "cannot open snmp session");    }    /* return pointer to opened session */    return (sptr);}

static netsnmp_session *snmp_init (const char *target){	static netsnmp_session *session = NULL;#ifndef NETSNMPV54	char default_port[128];	snprintf (default_port, sizeof (default_port), "%s:162", target);#endif	if (session) {		return (session);	}	if (target == NULL) {		return NULL;	}	session = malloc (sizeof (netsnmp_session));	snmp_sess_init (session);	session->version = SNMP_VERSION_2c;	session->callback = NULL;	session->callback_magic = NULL;	session = snmp_add(session,#ifdef NETSNMPV54		netsnmp_transport_open_client ("snmptrap", target),#else		netsnmp_tdomain_transport (default_port, 0, "udp"),#endif		NULL, NULL);	if (session == NULL) {		qb_log(LOG_ERR, 0, "Could not create snmp transport");	}	return (session);}

static void test_exec_sensor_cb(const char *cjson_sensor,				void (*msg_cb)(void *opaque,					       rb_message_list *msgs,					       size_t i),				void *opaque,				size_t n) {	const size_t aux_mem_wrap_fail_in = mem_wrap_fail_in; // Exclude this							      // code	mem_wrap_fail_in = 0;	struct _worker_info worker_info;	memset(&worker_info, 0, sizeof(worker_info));	snmp_sess_init(&worker_info.default_session);	struct json_object *json_sensor = json_tokener_parse(cjson_sensor);	rb_sensor_t *sensor = parse_rb_sensor(json_sensor, &worker_info);	json_object_put(json_sensor);	mem_wrap_fail_in = aux_mem_wrap_fail_in;	for (size_t i = 0; i < n; ++i) {		rb_message_list messages;		rb_message_list_init(&messages);		process_rb_sensor(&worker_info, sensor, &messages);		msg_cb(opaque, &messages, i);	}	rb_sensor_put(sensor);}

/** * Helper for snmp_init */static void init_session_helper(netsnmp_session *s, char *community){	snmp_sess_init(s);	s->peername = strdup(TC1_IP_ADDR);	s->version = SNMP_VERSION_2c;	s->community = (unsigned char *)strdup(community);	s->community_len = strlen(community);}

void asynchronous(void){  struct session *hs;  struct host *hp;  /* startup all hosts */  for (hs = sessions, hp = hosts; hp->name; hs++, hp++) {    struct snmp_pdu *req;    struct snmp_session sess;    snmp_sess_init(&sess);			/* initialize session */    sess.version = SNMP_VERSION_2c;    sess.peername = strdup(hp->name);    sess.community = strdup(hp->community);    sess.community_len = strlen(sess.community);    sess.callback = asynch_response;		/* default callback */    sess.callback_magic = hs;    if (!(hs->sess = snmp_open(&sess))) {      snmp_perror("snmp_open");      continue;    }    hs->current_oid = oids;    req = snmp_pdu_create(SNMP_MSG_GET);	/* send the first GET */    snmp_add_null_var(req, hs->current_oid->Oid, hs->current_oid->OidLen);    if (snmp_send(hs->sess, req))      active_hosts++;    else {      snmp_perror("snmp_send");      snmp_free_pdu(req);    }  }  /* loop while any active hosts */  while (active_hosts) {    int fds = 0, block = 1;    fd_set fdset;    struct timeval timeout;    FD_ZERO(&fdset);    snmp_select_info(&fds, &fdset, &timeout, &block);    fds = select(fds, &fdset, NULL, NULL, block ? NULL : &timeout);    if (fds < 0) {        perror("select failed");        exit(1);    }    if (fds)        snmp_read(&fdset);    else        snmp_timeout();  }  /* cleanup */  for (hp = hosts, hs = sessions; hp->name; hs++, hp++) {    if (hs->sess) snmp_close(hs->sess);  }}

void Session::initSession(snmp_session &sess){	snmp_sess_init(&sess); // Setup defaults	sess.peername = new char[m_peerName.length()+1];	strncpy(sess.peername, m_peerName.latin1(), m_peerName.length()+1);		// Casts are to move the variables to the original type.	sess.retries = (int)m_retries;	sess.timeout = (long)m_timeout;}

void init_master(void){    struct snmp_session sess, *session;    if ( ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_ROLE) != MASTER_AGENT )	return;    DEBUGMSGTL(("agentx/master","initializing.../n"));    snmp_sess_init( &sess );    sess.version  = AGENTX_VERSION_1;    sess.flags  |= SNMP_FLAGS_STREAM_SOCKET;    if ( ds_get_string(DS_APPLICATION_ID, DS_AGENT_X_SOCKET) )	sess.peername = strdup(ds_get_string(DS_APPLICATION_ID, DS_AGENT_X_SOCKET));    else	sess.peername = strdup(AGENTX_SOCKET);    if ( sess.peername[0] == '/' ) {			/*			 *  If this is a Unix pathname,			 *  try and create the directory first.			 */	if (mkdirhier(sess.peername, AGENT_DIRECTORY_MODE, 1)) {	    snmp_log(LOG_ERR,		"Failed to create the directory for the agentX socket: %s/n",                 sess.peername);	}    }			/*			 *  Otherwise, let 'snmp_open' interpret the string.			 */    sess.local_port  = AGENTX_PORT;         /* Indicate server & set default port */    sess.remote_port = 0;    sess.callback = handle_master_agentx_packet;    session = snmp_open_ex( &sess, 0, agentx_parse, 0, agentx_build,                            agentx_check_packet );    if ( session == NULL && sess.s_errno == EADDRINUSE ) {		/*		 * Could be a left-over socket (now deleted)		 * Try again		 */        session = snmp_open_ex( &sess, 0, agentx_parse, 0, agentx_build,                            agentx_check_packet );    }    if ( session == NULL ) {      /* diagnose snmp_open errors with the input struct snmp_session pointer */	snmp_sess_perror("init_master", &sess);        if (!ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_NO_ROOT_ACCESS))          exit(1);    }    DEBUGMSGTL(("agentx/master","initializing...   DONE/n"));}

/* Main program 	Queries various SNMP values on cisco devices.*/int main(int argc, char *argv[]) {	char* output;	struct snmp_session session;	char arg;//	int i;//	long snmpVer;	/* Initialize and build snmp session, add version, community, host, etc */	init_snmp("Linux_checks");		snmp_sess_init( &session );	switch (arg = snmp_parse_args(argc, argv, &session, "C:", optProc)) {	case -3:		exit(1);	case -2:		exit(0);	case -1:		usage();		exit(1);	default:		break;	}		/* Check warning/critical test values to verify they are within the appropriate ranges */	if ((crit > 100) && (strcmp(mode, "sessions"))) {		printf("Critical threshold should be less than 100!/n");		usage();		exit(RESULT_UNKNOWN);	}	else if (crit < 0) {		printf("Critical threshould must be greater than 0!/n");		usage();		exit(RESULT_UNKNOWN);	}	else if ((warn < 0) && (strcmp(mode, "sessions"))) {		printf("Warning threshold must be greater than or equal to 0!/n");		usage();		exit(RESULT_UNKNOWN);	}	else if (warn > crit) {		printf("Warning threshold must not be greater than critical threshold!/n");		usage();		exit(RESULT_UNKNOWN);	}			output = checkCPU(&session);		printf("%s", output);	return exitVal;}

// initialize connection to snmp agentvoid init(char* ip , char* community) {    init_snmp("cs158b");    /*     * Initialize a "session" that defines who we're going to talk to     */    snmp_sess_init( &session );                   /* set up defaults */    session.peername = strdup(ip); // ip    session.version = SNMP_VERSION_2c;    session.community = community; // community    session.community_len = strlen(session.community);}

u_char         *cmu_snmp_parse(netsnmp_session * session,               netsnmp_pdu *pdu, u_char * data, size_t length){    u_char         *bufp = NULL;    snmp_sess_init(session);    /* gimme a break! */    switch (pdu->version) {    case SNMP_VERSION_1:    case SNMP_VERSION_2c:    case SNMP_DEFAULT_VERSION:        break;    default:        return NULL;    }#ifndef NO_INTERNAL_VARLIST    if (snmp_parse(0, session, pdu, data, length) != SNMP_ERR_NOERROR) {        return NULL;    }#else    /*     * while there are two versions of variable_list:     * use an internal variable list for snmp_parse;     * clone the result.     */    if (1) {        netsnmp_pdu    *snmp_clone_pdu(netsnmp_pdu *);        netsnmp_pdu    *snmp_2clone_pdu(netsnmp_pdu *from_pdu,                                        netsnmp_pdu *to_pdu);        netsnmp_pdu    *ipdu;        ipdu = snmp_clone_pdu(pdu);        if (snmp_parse(0, session, ipdu, data, length) != SNMP_ERR_NOERROR) {            snmp_free_internal_pdu(ipdu);            return NULL;        }        pdu = snmp_2clone_pdu(ipdu, pdu);        snmp_free_internal_pdu(ipdu);    }#endif                          /* NO_INTERNAL_VAR_LIST */    /*     * Add a null to meet the caller's expectations.      */    bufp = (u_char *) malloc(1 + pdu->community_len);    if (bufp && pdu->community_len) {        memcpy(bufp, pdu->community, pdu->community_len);        bufp[pdu->community_len] = '/0';    }    return (bufp);}

intsnmp_init(selector_t *sel){    struct snmp_session session;#ifdef HAVE_NETSNMP    netsnmp_transport *transport = NULL;    static char *snmp_default_port = "udp:162";    netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,			   NETSNMP_DS_LIB_MIB_ERRORS,			   0);    init_snmp("ipmi_ui");    transport = netsnmp_tdomain_transport(snmp_default_port, 1, "udp");    if (!transport) {        snmp_sess_perror("ipmi_ui", &session);	return -1;    }#else    void *transport = NULL;#endif    snmp_sess_init(&session);    session.peername = SNMP_DEFAULT_PEERNAME;    session.version = SNMP_DEFAULT_VERSION;    session.community_len = SNMP_DEFAULT_COMMUNITY_LEN;    session.retries = SNMP_DEFAULT_RETRIES;    session.timeout = SNMP_DEFAULT_TIMEOUT;    session.local_port = SNMP_TRAP_PORT;    session.callback = snmp_input;    session.callback_magic = transport;    session.authenticator = NULL;    session.isAuthoritative = SNMP_SESS_UNKNOWNAUTH;#ifdef HAVE_NETSNMP    snmp_session = snmp_add(&session, transport, snmp_pre_parse, NULL);#else    snmp_session = snmp_open_ex(&session, snmp_pre_parse,				NULL, NULL, NULL, NULL);#endif    if (snmp_session == NULL) {        snmp_sess_perror("ipmi_ui", &session);	return -1;    }    ipmi_sel_set_read_fds_handler(sel,				  snmp_add_read_fds,				  snmp_check_read_fds,				  snmp_check_timeout,				  NULL);    return 0;}

static intSnmp_init(SnmpObject *self, PyObject *args, PyObject *kwds){	PyObject *host=NULL, *community=NULL;	char *chost=NULL, *ccommunity=NULL;	int version = 2;	struct snmp_session session;	static char *kwlist[] = {"ip", "community", "version", NULL};			if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist, 		&host, &community, &version))		return -1;	snmp_sess_init(&session);	if ((chost = PyString_AsString(host)) == NULL)		return -1;	switch (version) {	case 1:		session.version = SNMP_VERSION_1;		break;	case 2:		session.version = SNMP_VERSION_2c;		break;	default:		PyErr_Format(PyExc_ValueError, "invalid SNMP version: %d",		    version);		return -1;	}	if ((ccommunity = PyString_AsString(community)) == NULL)		return -1;	session.community_len = strlen(ccommunity);	if ((session.community = (u_char*)strdup(ccommunity)) == NULL) {		PyErr_NoMemory();		return -1;	}	if ((session.peername = strdup(chost)) == NULL) {		PyErr_NoMemory();		return -1;	}	if ((self->ss = snmp_open(&session)) == NULL) {		Snmp_raise_error(&session);		free(session.community);		free(session.peername);		return -1;	}	if ((self->defers = PyDict_New()) == NULL)		return -1;	if (Snmp_updatereactor() == -1)		return -1;	return 0;}

struct snmp_mtp_session *snmp_mtp_session_create(){	struct snmp_mtp_session *session = talloc_zero(NULL, struct snmp_mtp_session);	if (!session)		return NULL;	init_snmp("cellmgr_ng");	snmp_sess_init(&session->session);	session->session.version = SNMP_VERSION_1;	session->session.community = (unsigned char *) "private";	session->session.community_len = strlen((const char *) session->session.community);	session->session.myvoid = session;	return session;}

/* Init SNMP Session * alorbach, 2008-02-12 */static rsRetValomsnmp_initSession(wrkrInstanceData_t *pWrkrData){	netsnmp_session session;	instanceData *pData;	char szTargetAndPort[MAXHOSTNAMELEN+128]; /* work buffer for specifying a full target and port string */	DEFiRet;		/* should not happen, but if session is not cleared yet - we do it now! */	if (pWrkrData->snmpsession != NULL)		omsnmp_exitSession(pWrkrData);	pData = pWrkrData->pData;	snprintf((char*)szTargetAndPort, sizeof(szTargetAndPort), "%s:%s:%d",			(pData->szTransport == NULL) ? "udp" : (char*)pData->szTransport,			pData->szTarget, pData->iPort == 0 ? 162 : pData->iPort);	dbgprintf( "omsnmp_initSession: ENTER - Target = '%s' on Port = '%d'/n", pData->szTarget, pData->iPort);	if (setenv("POSIXLY_CORRECT", "1", 1) == -1)		ABORT_FINALIZE(RS_RET_ERR);		snmp_sess_init(&session);	session.version = pData->iSNMPVersion;	session.callback = NULL; /* NOT NEEDED */	session.callback_magic = NULL;	session.peername = (char*) szTargetAndPort;		/* Set SNMP Community */	if (session.version == SNMP_VERSION_1 || session.version == SNMP_VERSION_2c) {			session.community = (unsigned char *) pData->szCommunity			== NULL ? (uchar*)"public" : pData->szCommunity;		session.community_len = strlen((char*) session.community);	}	pWrkrData->snmpsession = snmp_open(&session);	if (pWrkrData->snmpsession == NULL) {		errmsg.LogError(0, RS_RET_SUSPENDED, "omsnmp_initSession: snmp_open to host '%s' on Port '%d' "		"failed/n", pData->szTarget, pData->iPort);		/* Stay suspended */		iRet = RS_RET_SUSPENDED;	}finalize_it:	RETiRet;}

QSnmp::QSnmp(const QString &peername, const QByteArray &community) {	init_snmp("door_control");	snmp_sess_init(&session);	session.peername = strdup(peername.toUtf8().constData()); //"192.168.0.100";	session.version = SNMP_VERSION_1;	session.community = (unsigned char*)strdup(community.constData()); //(unsigned char*)"private";	session.community_len = strlen((char*)session.community);	ss = snmp_open(&session);	if (!ss) {		snmp_perror("ack");		snmp_log(LOG_ERR, "something horrible happened!!!/n");		return;	}	qDebug("QSnmp: session established");}

void snmp::session::open(const std::string & peername, const std::string & community){    if (!_initialized)    {        init_snmp("snmpapp");        _initialized = true;    }    ::snmp_session session;    snmp_sess_init(&session);    session.peername = const_cast<char *>(peername.c_str());    session.version = SNMP_VERSION_1;    session.community = reinterpret_cast<u_char *>(const_cast<char *>(community.c_str()));    session.community_len = community.size();    _ss = snmp_open(&session);    if (!_ss) throw std::runtime_error("Failed to open SNMP session");}

static netsnmp_session *snmptrapd_add_session(netsnmp_transport *t) {    netsnmp_session sess, *session = &sess, *rc = NULL;    snmp_sess_init(session);    session->peername = SNMP_DEFAULT_PEERNAME;  /* Original code had NULL here */    session->version = SNMP_DEFAULT_VERSION;    session->community_len = SNMP_DEFAULT_COMMUNITY_LEN;    session->retries = SNMP_DEFAULT_RETRIES;    session->timeout = SNMP_DEFAULT_TIMEOUT;    session->callback = snmp_input;    session->callback_magic = (void *) t;    session->authenticator = NULL;    sess.isAuthoritative = SNMP_SESS_UNKNOWNAUTH;    rc = snmp_add(session, t, pre_parse, NULL);    if (rc == NULL) {        snmp_sess_perror("snmptrapd", session);    }    return rc;}

struct snmp_session *simpleSNMPopen(gchar *peername,	       gint port,	       gchar *community,	       void *data){    struct snmp_session session, *ss;    /*     * initialize session to default values     */    snmp_sess_init( &session );    session.version = SNMP_VERSION_1;    session.community = community;    session.community_len = strlen(community);    session.peername = peername;    session.remote_port = port;    session.retries = SNMP_DEFAULT_RETRIES;    session.timeout = SNMP_DEFAULT_TIMEOUT;    session.callback = snmp_input;    session.callback_magic = data; /* most likely a Reader */    session.authenticator = NULL;#ifdef STREAM    session.flags |= SNMP_FLAGS_STREAM_SOCKET;#endif    /*      * Open an SNMP session.     */    ss = snmp_open(&session);    if (ss == NULL){        snmp_sess_perror("snmp_open", &session);        // exit(1);    }    return ss;}

struct snmp_session *session_open(const char *chost, const char *ccommunity) {  struct snmp_session *ss, session;  char *host, *community;  host=calloc(strlen(chost)+1, sizeof(char));  strcpy(host, chost);  community=calloc(strlen(ccommunity)+1, sizeof(char));  strcpy(community, ccommunity);  /* Initialize the SNMP library */  init_snmp("snmpapp");  /* Initialize the session */  snmp_sess_init( &session );  session.version = SNMP_VERSION_2c;  session.peername = host;  session.community = (u_char*)community;  session.community_len = strlen(community);                                                                                                    netsnmp_ds_set_int( NETSNMP_DS_LIBRARY_ID,		NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,		NETSNMP_OID_OUTPUT_UCD );//                NETSNMP_OID_OUTPUT_NONE);  SOCK_STARTUP  /* open the SNMP session */  ss = snmp_open(&session);  if (ss == NULL) {    perror("Cant snmp_open");    exit(-1);  }  netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,                                                      NETSNMP_OID_OUTPUT_NUMERIC);  return ss;}