static int
onlp_snmp_sensor_register_oid__(onlp_oid_t oid, void* cookie)
{
onlp_oid_hdr_t hdr;
onlp_snmp_sensor_t s;
onlp_oid_hdr_get(oid, &hdr);
AIM_MEMSET(&s, 0x0, sizeof(onlp_snmp_sensor_t));
switch(ONLP_OID_TYPE_GET(oid))
{
case ONLP_OID_TYPE_THERMAL:
#if ONLP_SNMP_CONFIG_INCLUDE_THERMALS == 1
s.sensor_id = oid;
sprintf(s.name, "%d - ", ONLP_OID_ID_GET(oid));
aim_strlcpy(s.desc, hdr.description, sizeof(s.desc));
if(onlp_snmp_sensor_reg__(ONLP_SNMP_SENSOR_TYPE_TEMP, &s) < 0) {
AIM_LOG_ERROR("onlp_snmp_sensor_reg for OID 0x%x failed.", oid);
}
#endif
break;
case ONLP_OID_TYPE_FAN:
#if ONLP_SNMP_CONFIG_INCLUDE_FANS == 1
s.sensor_id = oid;
sprintf(s.name, "%d - ", ONLP_OID_ID_GET(oid));
aim_strlcpy(s.desc, hdr.description, sizeof(s.desc));
if(onlp_snmp_sensor_reg__(ONLP_SNMP_SENSOR_TYPE_FAN, &s) < 0) {
AIM_LOG_ERROR("onlp_snmp_sensor_reg for OID 0x%x failed.", oid);
}
#endif
break;
case ONLP_OID_TYPE_PSU:
#if ONLP_SNMP_CONFIG_INCLUDE_PSUS == 1
/* Register Sensors for VIN,VOUT,IIN,IOUT,PIN,POUT */
s.sensor_id = oid;
sprintf(s.name, "%d - ", ONLP_OID_ID_GET(oid));
aim_strlcpy(s.desc, hdr.description, sizeof(s.desc));
if(onlp_snmp_sensor_reg__(ONLP_SNMP_SENSOR_TYPE_PSU, &s) < 0) {
AIM_LOG_ERROR("onlp_snmp_sensor_reg for OID 0x%x failed.", oid);
}
#endif
break;
default:
AIM_LOG_INFO("snmp type %s id %d unsupported",
onlp_oid_type_name(ONLP_OID_TYPE_GET(oid)),
ONLP_OID_ID_GET(oid));
break;
}
return 0;
}
int
vpi_mmap_interface_create(vpi_interface_t** vi, char* args[], int flags,
const char* vpi_name_ptr)
{
struct sockaddr_ll sockaddr;
struct packet_mreq sockparams;
struct tpacket_req treq;
struct ifreq ifreq;
vpi_interface_mmap_t* nvi = aim_zmalloc(sizeof(*nvi));
char** arg = args;
int version;
int i;
frame_control_t* fc;
AIM_REFERENCE(flags);
if(nvi == NULL) {
VPI_MERROR("interface allocation failed for %s.",
vpi_name_ptr);
return -1;
}
/*
* Point our log_string to our name so we can use it immediately
* in log messages.
*/
nvi->log_string = vpi_name_ptr;
/*
* The first argument is the type -- skip for now
*/
arg++;
aim_strlcpy(nvi->interface_name, *arg, sizeof(nvi->interface_name));
/* Create RAW socket */
if((nvi->fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) {
VPI_ERROR(nvi, "socket() failed: %s\n", strerror(errno));
aim_free(nvi);
return -1;
}
/* Set version */
version = TPACKET_V2;
if(setsockopt(nvi->fd, SOL_PACKET, PACKET_VERSION,
&version, sizeof(version)) < 0) {
VPI_ERROR(nvi, "setsockopt() version failed: %s\n", strerror(errno));
aim_free(nvi);
return -1;
}
/*
* Get the interface index for the requested interface, as specified
* in the current argument.
*/
VPI_MEMSET(&ifreq, 0, sizeof(ifreq));
aim_strlcpy(ifreq.ifr_name, nvi->interface_name, IFNAMSIZ);
if(ioctl(nvi->fd, SIOCGIFINDEX, &ifreq) < 0) {
VPI_ERROR(nvi, "ioctl() failed: %s", strerror(errno));
close(nvi->fd);
aim_free(nvi);
return -1;
}
nvi->ifindex = ifreq.ifr_ifindex;
VPI_INFO(nvi, "ifndex is %d", nvi->ifindex);
/* Set promisc */
VPI_MEMSET(&sockparams, 0, sizeof(sockparams));
sockparams.mr_type = PACKET_MR_PROMISC;
sockparams.mr_ifindex = nvi->ifindex;
if(setsockopt(nvi->fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
(void *)&sockparams, sizeof(sockparams)) < 0) {
VPI_ERROR(nvi, "setsockopt() promisc failed. %s\n", strerror(errno));
close(nvi->fd);
aim_free(nvi);
return -1;
}
/* Set up rx_ring buffer */
VPI_MEMSET(&treq, 0, sizeof(treq));
treq.tp_block_size = BLOCK_SIZE;
treq.tp_frame_size = FRAME_SIZE;
treq.tp_block_nr = NUM_BLOCKS;
treq.tp_frame_nr = NUM_FRAMES;;
if(setsockopt(nvi->fd, SOL_PACKET, PACKET_RX_RING,
(void*)&treq , sizeof(treq)) < 0) {
VPI_ERROR(nvi, "setsockopt() rx_ring failed. %s\n", strerror(errno));
close(nvi->fd);
aim_free(nvi);
return -1;
}
/* If num blocks change, bail! */
if(treq.tp_block_nr != NUM_BLOCKS) {
AIM_DIE("Unhandled: RX_RING block number changed!\n");
}
/* Set up rx_ring */
nvi->rx_ring.buf = mmap(NULL, BLOCK_SIZE*NUM_BLOCKS,
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED,
nvi->fd, 0);
if(nvi->rx_ring.buf == MAP_FAILED) {
VPI_ERROR(nvi, "mmap() failed.\n");
close(nvi->fd);
aim_free(nvi);
return -1;
}
/* Set up rx_ring and frame controls */
nvi->rx_ring.current_frame = 0;
for(i = 0; i < NUM_FRAMES; i++) {
fc = &nvi->rx_ring.frames[i];
fc->base = nvi->rx_ring.buf + (i*FRAME_SIZE);
}
/* Bind */
VPI_MEMSET(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sll_family = AF_PACKET;
sockaddr.sll_protocol = htons(ETH_P_ALL);
sockaddr.sll_ifindex = nvi->ifindex;
if(bind(nvi->fd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0) {
VPI_ERROR(nvi, "bind() failed.\n");
close(nvi->fd);
aim_free(nvi);
return -1;
}
nvi->interface.send = vpi_mmap_interface_send;
nvi->interface.recv = vpi_mmap_interface_recv;
nvi->interface.recv_ready = vpi_mmap_interface_recv_ready;
nvi->interface.destroy = vpi_mmap_interface_destroy;
nvi->interface.descriptor = vpi_mmap_interface_descriptor;
*vi = (vpi_interface_t*)nvi;
return 0;
}
int
vpi_veth_interface_create(vpi_interface_t** vi, char* args[], int flags,
const char* vpi_name_ptr)
{
struct sockaddr_ll sockaddr;
struct ifreq ifreq;
vpi_interface_veth_t* nvi = aim_zmalloc(sizeof(*nvi));
char** arg = args;
AIM_REFERENCE(flags);
if(nvi == NULL) {
VPI_MERROR("interface allocation failed for %s.",
vpi_name_ptr);
return -1;
}
/*
* Point our log_string to our name so we can use it immediately
* in log messages.
*/
nvi->log_string = vpi_name_ptr;
/*
* The first argument is the type -- skip for now
*/
arg++;
aim_strlcpy(nvi->interface_name, *arg, sizeof(nvi->interface_name));
/* Create RAW socket */
if((nvi->fd = socket(PF_PACKET, SOCK_RAW, 0)) < 0) {
VPI_ERROR(nvi, "socket() failed: %s\n", strerror(errno));
aim_free(nvi);
return -1;
}
/*
* Get the interface index for the requested interface, as specified
* in the current argument.
*/
VPI_MEMSET(&ifreq, 0, sizeof(ifreq));
aim_strlcpy(ifreq.ifr_name, nvi->interface_name, IFNAMSIZ);
if(ioctl(nvi->fd, SIOCGIFINDEX, &ifreq) < 0) {
VPI_ERROR(nvi, "ioctl() failed: %s", strerror(errno));
close(nvi->fd);
aim_free(nvi);
return -1;
}
nvi->ifindex = ifreq.ifr_ifindex;
VPI_INFO(nvi, "ifndex is %d", nvi->ifindex);
VPI_MEMSET(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sll_family=AF_PACKET;
sockaddr.sll_protocol = htons(ETH_P_ALL);
sockaddr.sll_ifindex = ifreq.ifr_ifindex;
if(bind(nvi->fd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0) {
VPI_ERROR(nvi, "bind() failed");
return -1;
}
nvi->interface.send = vpi_veth_interface_send;
nvi->interface.recv = vpi_veth_interface_recv;
nvi->interface.recv_ready = vpi_veth_interface_recv_ready;
nvi->interface.destroy = vpi_veth_interface_destroy;
nvi->interface.descriptor = vpi_veth_interface_descriptor;
*vi = (vpi_interface_t*)nvi;
return 0;
}
int
faultd_handler_register(int localfd,
const char* pipename,
const char* binaryname)
{
int rv;
struct sigaction saction;
void* dummy_backtrace[1];
int dummy_backtrace_size;
int fd;
if ( (rv = pthread_spin_init(&thread_lock__, 0)) ) {
return rv;
}
/*
* These calls to backtrace are to assure that
* backtrace() and backtrace_symbols_fd() have actually
* been loaded into our process -- its possible they
* come from a dynamic library, and we don't want them
* to get loaded at fault-time.
*/
dummy_backtrace_size = backtrace(dummy_backtrace, 1);
/** Note - we could just pass an invalid descriptor here, but it
* it flags errors in valgrind.
*/
fd = open("/dev/null", O_WRONLY);
backtrace_symbols_fd(dummy_backtrace, dummy_backtrace_size, fd);
close(fd);
AIM_MEMSET(&faultd_info__, 0, sizeof(faultd_info__));
if(!binaryname) {
binaryname = "Not specified.";
}
aim_strlcpy(faultd_info__.binary, binaryname, sizeof(faultd_info__.binary));
if(pipename) {
faultd_client_create(&faultd_client__, pipename);
}
AIM_MEMSET(&saction, 0, sizeof(saction));
saction.sa_sigaction = faultd_signal_handler__;
sigfillset(&saction.sa_mask);
saction.sa_flags = SA_SIGINFO | SA_RESETHAND;
rv = sigaction (SIGSEGV, &saction, NULL);
rv |= sigaction (SIGILL, &saction, NULL);
rv |= sigaction (SIGFPE, &saction, NULL);
rv |= sigaction (SIGBUS, &saction, NULL);
rv |= sigaction (SIGQUIT, &saction, NULL);
rv |= sigaction (SIGALRM, &saction, NULL);
/*
* SIGUSR2 can be used to request a backtrace explicitly.
* In this case, we don't want to reset the handler.
*/
saction.sa_flags = SA_SIGINFO;
rv |= sigaction (SIGUSR2, &saction, NULL);
/*
* The local fault handler will attempt to write a subset of
* the fault information (signal type and backtrace)
* to the localfd descriptor if specified.
*/
localfd__ = localfd;
return rv;
}
int
vpi_pcapdump_interface_create(vpi_interface_t** vi, char* args[], int flags,
const char* vpi_name_ptr)
{
vpi_interface_pcapdump_t* nvi = aim_zmalloc(sizeof(*nvi));
char** arg = args;
char errbuf[PCAP_ERRBUF_SIZE];
AIM_REFERENCE(flags);
if(nvi == NULL) {
VPI_MERROR("interface allocation failed for %s.",
vpi_name_ptr);
return -1;
}
/*
* Point our log_string to our name so we can use it immediately
* in log messages.
*/
nvi->log_string = vpi_name_ptr;
/*
* The first argument is the type -- skip for now
*/
arg++;
if((nvi->pcap = pcap_open_dead(DLT_EN10MB, 10000)) == NULL) {
VPI_ERROR(nvi, "pcap_open_dead() failed: %s\n",
*arg, errbuf);
aim_free(nvi);
return -1;
}
/*
* next arg - filename name.
*/
if((nvi->pcap_dumper = pcap_dump_open(nvi->pcap, *arg)) == NULL) {
VPI_ERROR(nvi, "pcap_dump_open(%s) failed\n", *arg);
pcap_close(nvi->pcap);
aim_free(nvi);
return -1;
}
arg++;
if(*arg) {
/*
* if the next arg is 'mpls', packets will be encapsulated
* in an MPLS frame with the outer fields indicating useful
* information, like port number, send or recieved, etc
*/
if(!VPI_STRCMP(*arg, "mpls")) {
nvi->mpls = 1;
}
arg++;
if(*arg) {
/*
* Set the label field
*/
aim_strlcpy(nvi->ident, *arg, sizeof(nvi->ident));
}
}
nvi->interface.send = vpi_pcapdump_interface_send;
nvi->interface.recv = NULL;
nvi->interface.recv_ready = NULL;
nvi->interface.destroy = vpi_pcapdump_interface_destroy;
nvi->interface.descriptor = NULL;
*vi = (vpi_interface_t*)nvi;
return 0;
}
