struct agent_netsnmp_set_info *
save_set_vars(netsnmp_session * ss, netsnmp_pdu *pdu)
{
struct agent_netsnmp_set_info *ptr;
struct timeval now;
extern struct timeval starttime;
ptr = (struct agent_netsnmp_set_info *)
malloc(sizeof(struct agent_netsnmp_set_info));
if (ptr == NULL)
return NULL;
/*
* Save the important information
*/
ptr->transID = pdu->transid;
ptr->sess = ss;
ptr->mode = SNMP_MSG_INTERNAL_SET_RESERVE1;
gettimeofday(&now, NULL);
ptr->uptime = calculate_time_diff(&now, &starttime);
ptr->var_list = snmp_clone_varbind(pdu->variables);
if (ptr->var_list == NULL) {
free(ptr);
return NULL;
}
ptr->next = Sets;
Sets = ptr;
return ptr;
}
/* snmpv3_local_snmpEngineTime(): return the number of seconds since the
snmpv3 engine last incremented engine_boots */
u_long
snmpv3_local_snmpEngineTime(void)
{
struct timeval now;
gettimeofday(&now, NULL);
return calculate_time_diff(&now, &snmpv3starttime)/100;
}
int
open_agentx_session(netsnmp_session * session, netsnmp_pdu *pdu)
{
netsnmp_session *sp;
struct timeval now;
DEBUGMSGTL(("agentx/master", "open %08p\n", session));
sp = (netsnmp_session *) malloc(sizeof(netsnmp_session));
if (sp == NULL) {
session->s_snmp_errno = AGENTX_ERR_OPEN_FAILED;
return -1;
}
memcpy(sp, session, sizeof(netsnmp_session));
sp->sessid = snmp_get_next_sessid();
sp->version = pdu->version;
sp->timeout = pdu->time;
/*
* Be careful with fields: if these aren't zeroed, they will get free()d
* more than once when the session is closed -- once in the main session,
* and once in each subsession. Basically, if it's not being used for
* some AgentX-specific purpose, it ought to be zeroed here.
*/
sp->community = NULL;
sp->peername = NULL;
sp->contextEngineID = NULL;
sp->contextName = NULL;
sp->securityEngineID = NULL;
sp->securityPrivProto = NULL;
/*
* This next bit utilises unused SNMPv3 fields
* to store the subagent OID and description.
* This really ought to use AgentX-specific fields,
* but it hardly seems worth it for a one-off use.
*
* But I'm willing to be persuaded otherwise.... */
sp->securityAuthProto = snmp_duplicate_objid(pdu->variables->name,
pdu->variables->
name_length);
sp->securityAuthProtoLen = pdu->variables->name_length;
sp->securityName = strdup((char *) pdu->variables->val.string);
gettimeofday(&now, NULL);
sp->engineTime = calculate_time_diff(&now, &starttime);
sp->subsession = session; /* link back to head */
sp->flags |= SNMP_FLAGS_SUBSESSION;
sp->flags &= ~AGENTX_MSG_FLAG_NETWORK_BYTE_ORDER;
sp->flags |= (pdu->flags & AGENTX_MSG_FLAG_NETWORK_BYTE_ORDER);
sp->next = session->subsession;
session->subsession = sp;
DEBUGMSGTL(("agentx/master", "opened %08p = %d with flags = %02x\n",
sp, sp->sessid, sp->flags & AGENTX_MSG_FLAGS_MASK));
return sp->sessid;
}
void sdwrap_baseline (void)
{
temp test_bin;
// gettimeofday and store it in a global
gettimeofday(&start_time, NULL);
for (int i=0; i<1000000; i++) {
strcpy(test_bin.a, "test1");
strcpy(test_bin.b, "test2");
strcpy(test_bin.c, "test3");
strcpy(test_bin.d, "test4");
strcpy(test_bin.e, "test5");
// strcpy(test_bin.c, "test5");
sdwrap_hist_event(CALLHOME_TEST_TRACE_BINARY_LOG, sizeof(test_bin), &test_bin);
}
// Get end time and calculate time diff from start_time
gettimeofday(&end_time, NULL);
calculate_time_diff("sdwrap");
}
void
lttng_baseline (void)
{
char str1[6], str2[6];
char str3[6];
char str4[6];
char str5[6];
strcpy(str1, "test1");
strcpy(str2, "test2");
strcpy(str3, "test3");
strcpy(str4, "test4");
strcpy(str5, "test5");
gettimeofday(&start_time, NULL);
for (int i=0; i<1000000; i++) {
// strcpy(str3, "test5");
// tracepoint(tp_0, my_second_tracepoint, str1, str2, str3);
tracepoint(tp_0, my_second_tracepoint, str1, str2, str3, str4, str5);
}
gettimeofday(&end_time, NULL);
calculate_time_diff("lttng");
}
void send_enterprise_trap_vars (int trap,
int specific,
oid *enterprise, int enterprise_length,
struct variable_list *vars)
{
struct variable_list uptime_var, snmptrap_var, enterprise_var;
struct variable_list *v2_vars, *last_var=NULL;
struct snmp_pdu *template_pdu, *pdu;
struct timeval now;
long uptime;
struct sockaddr_in *pduIp;
struct trap_sink *sink;
oid temp_oid[MAX_OID_LEN];
/*
* Initialise SNMPv2 required variables
*/
gettimeofday(&now, NULL);
uptime = calculate_time_diff(&now, &starttime);
memset (&uptime_var, 0, sizeof (struct variable_list));
snmp_set_var_objid( &uptime_var, sysuptime_oid, OID_LENGTH(sysuptime_oid));
snmp_set_var_value( &uptime_var, (u_char *)&uptime, sizeof(uptime) );
uptime_var.type = ASN_TIMETICKS;
uptime_var.next_variable = &snmptrap_var;
memset (&snmptrap_var, 0, sizeof (struct variable_list));
snmp_set_var_objid( &snmptrap_var, snmptrap_oid, OID_LENGTH(snmptrap_oid));
/* value set later .... */
snmptrap_var.type = ASN_OBJECT_ID;
if ( vars )
snmptrap_var.next_variable = vars;
else
snmptrap_var.next_variable = &enterprise_var;
/* find end of provided varbind list,
ready to append the enterprise info if necessary */
last_var = vars;
while ( last_var && last_var->next_variable )
last_var = last_var->next_variable;
memset (&enterprise_var, 0, sizeof (struct variable_list));
snmp_set_var_objid( &enterprise_var,
snmptrapenterprise_oid, OID_LENGTH(snmptrapenterprise_oid));
snmp_set_var_value( &enterprise_var, (u_char *)enterprise, enterprise_length*sizeof(oid));
enterprise_var.type = ASN_OBJECT_ID;
enterprise_var.next_variable = NULL;
v2_vars = &uptime_var;
/*
* Create a template PDU, ready for sending
*/
template_pdu = snmp_pdu_create( SNMP_MSG_TRAP );
if ( template_pdu == NULL ) {
/* Free memory if value stored dynamically */
snmp_set_var_value( &enterprise_var, NULL, 0);
return;
}
template_pdu->trap_type = trap;
template_pdu->specific_type = specific;
if ( snmp_clone_mem((void **)&template_pdu->enterprise,
enterprise, enterprise_length*sizeof(oid))) {
snmp_free_pdu( template_pdu );
snmp_set_var_value( &enterprise_var, NULL, 0);
return;
}
template_pdu->enterprise_length = enterprise_length;
template_pdu->flags |= UCD_MSG_FLAG_FORCE_PDU_COPY;
pduIp = (struct sockaddr_in *)&template_pdu->agent_addr;
pduIp->sin_family = AF_INET;
pduIp->sin_len = sizeof(*pduIp);
pduIp->sin_addr.s_addr = get_myaddr();
template_pdu->time = uptime;
/*
* Now use the parameters to determine
* which v2 variables are needed,
* and what values they should take.
*/
switch ( trap ) {
case -1: /*
* SNMPv2 only
* Check to see whether the variables provided
* are sufficient for SNMPv2 notifications
*/
if (vars && snmp_oid_compare(vars->name, vars->name_length,
sysuptime_oid, OID_LENGTH(sysuptime_oid)) == 0 )
v2_vars = vars;
else
if (vars && snmp_oid_compare(vars->name, vars->name_length,
snmptrap_oid, OID_LENGTH(snmptrap_oid)) == 0 )
uptime_var.next_variable = vars;
else {
/* Hmmm... we don't seem to have a value - oops! */
snmptrap_var.next_variable = vars;
}
last_var = NULL; /* Don't need enterprise info */
break;
/* "Standard" SNMPv1 traps */
case SNMP_TRAP_COLDSTART:
snmp_set_var_value( &snmptrap_var,
(u_char *)cold_start_oid,
sizeof(cold_start_oid));
break;
case SNMP_TRAP_WARMSTART:
snmp_set_var_value( &snmptrap_var,
(u_char *)warm_start_oid,
sizeof(warm_start_oid));
break;
case SNMP_TRAP_LINKDOWN:
snmp_set_var_value( &snmptrap_var,
(u_char *)link_down_oid,
sizeof(link_down_oid));
break;
case SNMP_TRAP_LINKUP:
snmp_set_var_value( &snmptrap_var,
(u_char *)link_up_oid,
sizeof(link_up_oid));
break;
case SNMP_TRAP_AUTHFAIL:
if (snmp_enableauthentraps == SNMP_AUTHENTICATED_TRAPS_DISABLED) {
snmp_free_pdu( template_pdu );
snmp_set_var_value( &enterprise_var, NULL, 0);
return;
}
snmp_set_var_value( &snmptrap_var,
(u_char *)auth_fail_oid,
sizeof(auth_fail_oid));
break;
case SNMP_TRAP_EGPNEIGHBORLOSS:
snmp_set_var_value( &snmptrap_var,
(u_char *)egp_xxx_oid,
sizeof(egp_xxx_oid));
break;
case SNMP_TRAP_ENTERPRISESPECIFIC:
memcpy( &temp_oid,
(char *)enterprise,
(enterprise_length)*sizeof(oid));
temp_oid[ enterprise_length ] = 0;
temp_oid[ enterprise_length+1 ] = specific;
snmp_set_var_value( &snmptrap_var,
(u_char *)&temp_oid,
(enterprise_length+2)*sizeof(oid));
snmptrap_var.next_variable = vars;
last_var = NULL; /* Don't need version info */
break;
}
/*
* Now loop through the list of trap sinks,
* sending an appropriately formatted PDU to each
*/
for ( sink = sinks ; sink ; sink=sink->next ) {
if ( sink->version == SNMP_VERSION_1 && trap == -1 )
continue; /* Skip v1 sinks for v2 only traps */
template_pdu->version = sink->version;
template_pdu->command = sink->pdutype;
if ( sink->version != SNMP_VERSION_1 ) {
template_pdu->variables = v2_vars;
if ( last_var )
last_var->next_variable = &enterprise_var;
}
else
template_pdu->variables = vars;
pdu = snmp_clone_pdu( template_pdu );
pdu->sessid = sink->sesp->sessid; /* AgentX only ? */
if ( snmp_send( sink->sesp, pdu) == 0 ) {
snmp_sess_perror ("snmpd: send_trap", sink->sesp);
snmp_free_pdu( pdu );
}
else {
snmp_increment_statistic(STAT_SNMPOUTTRAPS);
snmp_increment_statistic(STAT_SNMPOUTPKTS);
}
if ( sink->version != SNMP_VERSION_1 && last_var )
last_var->next_variable = NULL;
}
/* Free memory if values stored dynamically */
snmp_set_var_value( &enterprise_var, NULL, 0);
snmp_set_var_value( &snmptrap_var, NULL, 0);
/* Ensure we don't free anything we shouldn't */
if ( last_var )
last_var->next_variable = NULL;
template_pdu->variables = NULL;
snmp_free_pdu( template_pdu );
}
int
handle_master_agentx_packet(int operation,
netsnmp_session * session,
int reqid, netsnmp_pdu *pdu, void *magic)
{
netsnmp_agent_session *asp;
struct timeval now;
if (operation == NETSNMP_CALLBACK_OP_DISCONNECT) {
DEBUGMSGTL(("agentx/master",
"transport disconnect on session %08p\n", session));
/*
* Shut this session down gracefully.
*/
close_agentx_session(session, -1);
return 1;
} else if (operation != NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE) {
DEBUGMSGTL(("agentx/master", "unexpected callback op %d\n",
operation));
return 1;
}
/*
* Okay, it's a NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE op.
*/
if (magic) {
asp = (netsnmp_agent_session *) magic;
} else {
asp = init_agent_snmp_session(session, pdu);
}
DEBUGMSGTL(("agentx/master", "handle pdu (req=0x%x,trans=0x%x,sess=0x%x)\n",
pdu->reqid,pdu->transid, pdu->sessid));
switch (pdu->command) {
case AGENTX_MSG_OPEN:
asp->pdu->sessid = open_agentx_session(session, pdu);
if (asp->pdu->sessid == -1)
asp->status = session->s_snmp_errno;
break;
case AGENTX_MSG_CLOSE:
asp->status = close_agentx_session(session, pdu->sessid);
break;
case AGENTX_MSG_REGISTER:
asp->status = register_agentx_list(session, pdu);
break;
case AGENTX_MSG_UNREGISTER:
asp->status = unregister_agentx_list(session, pdu);
break;
case AGENTX_MSG_INDEX_ALLOCATE:
asp->status = allocate_idx_list(session, asp->pdu);
if (asp->status != AGENTX_ERR_NOERROR) {
snmp_free_pdu(asp->pdu);
asp->pdu = snmp_clone_pdu(pdu);
}
break;
case AGENTX_MSG_INDEX_DEALLOCATE:
asp->status = release_idx_list(session, pdu);
break;
case AGENTX_MSG_ADD_AGENT_CAPS:
asp->status = add_agent_caps_list(session, pdu);
break;
case AGENTX_MSG_REMOVE_AGENT_CAPS:
asp->status = remove_agent_caps_list(session, pdu);
break;
case AGENTX_MSG_NOTIFY:
asp->status = agentx_notify(session, pdu);
break;
case AGENTX_MSG_PING:
asp->status = agentx_ping_response(session, pdu);
break;
/*
* TODO: Other admin packets
*/
case AGENTX_MSG_GET:
case AGENTX_MSG_GETNEXT:
case AGENTX_MSG_GETBULK:
case AGENTX_MSG_TESTSET:
case AGENTX_MSG_COMMITSET:
case AGENTX_MSG_UNDOSET:
case AGENTX_MSG_CLEANUPSET:
case AGENTX_MSG_RESPONSE:
/*
* Shouldn't be handled here
*/
break;
default:
asp->status = AGENTX_ERR_PARSE_FAILED;
break;
}
gettimeofday(&now, NULL);
asp->pdu->time = calculate_time_diff(&now, &starttime);
asp->pdu->command = AGENTX_MSG_RESPONSE;
asp->pdu->errstat = asp->status;
DEBUGMSGTL(("agentx/master", "send response, stat %d (req=0x%x,trans="
"0x%x,sess=0x%x)\n",
asp->status, pdu->reqid,pdu->transid, pdu->sessid));
if (!snmp_send(asp->session, asp->pdu)) {
char *eb = NULL;
int pe, pse;
snmp_error(asp->session, &pe, &pse, &eb);
snmp_free_pdu(asp->pdu);
DEBUGMSGTL(("agentx/master", "FAILED %d %d %s\n", pe, pse, eb));
free(eb);
}
asp->pdu = NULL;
free_agent_snmp_session(asp);
return 1;
}
