int cs_accept(int servfd)
{
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
memset(&addr, '\0', addrlen);
int clifd = accept(servfd, (struct sockaddr *)&addr, &addrlen);
if (clifd < 0) {
E("accept() failed.");
return -1;
}
char ip_str[INET_ADDRSTRLEN];
D(GREEN"accept client %d from %s port %d"NO, clifd,
inet_ntop(AF_INET, &addr.sin_addr, ip_str, sizeof(ip_str)),
ntohs(addr.sin_port));
sockfd_buf_t *rwbuf = sockfd_buf_init();
if (rwbuf == NULL) {
E("sockfd_buf_init() failed.");
return -1;
}
sockfd_list[clifd] = rwbuf;
register_readfd(clifd);
return 0;
}
int netsnmp_access_arp_load(netsnmp_arp_access *access)
{
int r, fd = (uintptr_t) access->arch_magic;
struct {
struct nlmsghdr n;
struct ndmsg r;
} req;
if (access->synchronized)
return 0;
if (fd == 0) {
struct sockaddr_nl sa;
fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (fd < 0) {
snmp_log(LOG_ERR,"netsnmp_access_arp_load: netlink socket create error\n");
return -1;
}
access->arch_magic = (void *)(uintptr_t)fd;
memset(&sa, 0, sizeof(sa));
sa.nl_family = AF_NETLINK;
sa.nl_groups = RTMGRP_NEIGH;
if (bind(fd, (struct sockaddr*) &sa, sizeof(sa)) < 0) {
snmp_log(LOG_ERR,"netsnmp_access_arp_load: netlink bind failed\n");
return -1;
}
if (register_readfd(fd, netsnmp_access_arp_read_netlink, access) != 0) {
snmp_log(LOG_ERR,"netsnmp_access_arp_load: error registering netlink socket\n");
return -1;
}
}
DEBUGMSGTL(("access:netlink:arp", "synchronizing arp table\n"));
access->generation++;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = sizeof(req);
req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
req.n.nlmsg_type = RTM_GETNEIGH;
req.r.ndm_family = AF_UNSPEC;
r = send(fd, &req, req.n.nlmsg_len, 0);
if (r < 0) {
snmp_log(LOG_ERR,"netsnmp_access_arp_refresh: send failed\n");
return -1;
}
while (!access->synchronized)
netsnmp_access_arp_read_netlink(fd, access);
access->gc_hook(access);
return 0;
}
/**
* @fn void init_ss7OmMIB(void)
* @brief ss7OmMIB initialization routine.
*
* This is called when the agent starts up. At a minimum, registration of the MIB variables
* structure (ss7OmMIB_variables) should take place here. By default the function also
* registers the configuration handler and configuration store callbacks.
*
* Additional registrations that may be considered here are calls to regsiter_readfd(),
* register_writefd() and register_exceptfd() for hooking into the snmpd event loop, but only when
* used as a loadable module. By default this function establishes a single file descriptor to
* read, or upon which to handle exceptions. Note that the snmpd only supports a maximum of 32
* extneral file descriptors, so these should be used sparingly.
*
* When running as a loadable module, it is also necessary to hook into the snmpd event loop so that
* the current request number can be deteremined. This is accomplished by using a trick of the
* external_signal_scheduled and external_signal_handler mechanism which is called on each event
* loop when external_signal_scheduled is non-zero. This is used to increment the sa_request value
* on each snmpd event loop interation so that calls to MIB tree functions can determine whether
* they belong to a fresh request or not (primarily for cacheing and possibly to clean up non-polled
* file descriptors).
*/
void
init_ss7OmMIB(void)
{
(void) my_fd;
(void) zeroDotZero_oid;
(void) snmpTrapOID_oid;
DEBUGMSGTL(("ss7OmMIB", "init_ss7OmMIB: initializing... "));
/* register ourselves with the agent to handle our mib tree */
REGISTER_MIB("ss7OmMIB", ss7OmMIB_variables, variable4, ss7OmMIB_variables_oid);
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_SHUTDOWN, term_ss7OmMIB, NULL);
/* register our config handler(s) to deal with registrations */
snmpd_register_config_handler("ss7OmMIB", parse_ss7OmMIB, NULL, "HELP STRING");
/* we need to be called back later to store our data */
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA, store_ss7OmMIB, NULL);
/* place any other initialization junk you need here */
if (my_readfd >= 0) {
register_readfd(my_readfd, ss7OmMIB_fd_handler, (void *) 0);
register_exceptfd(my_readfd, ss7OmMIB_fd_handler, (void *) 1);
}
ss7OmMIBold_signal_handler = external_signal_handler[SIGCHLD];
external_signal_handler[SIGCHLD] = &ss7OmMIB_loop_handler;
external_signal_scheduled[SIGCHLD] = 1;
DEBUGMSGTL(("ss7OmMIB", "done.\n"));
}
int main(int argc, char *argv[])
{
sqlite3 *db;
if (sqlite3_open("db/cs.db", &db) != SQLITE_OK) {
E("sqlite3_open() failed.");
return -1;
}
int ret = sockfd_list_init(1024);
if (ret < 0) {
E("sockfd_list_init() failed.");
return -1;
}
int servfd = socket(AF_INET, SOCK_STREAM, 0);
if (servfd == -1) {
E("%s", strerror(errno));
return -1;
}
int optval = 1;
ret = setsockopt(servfd, SOL_SOCKET, SO_REUSEADDR,
&optval, sizeof(optval));
if (ret == -1) {
E("%s", strerror(errno));
return -1;
}
#ifdef SO_REUSEPORT
optval = 1;
ret = setsockopt(servfd, SOL_SOCKET, SO_REUSEPORT,
&optval, sizeof(optval));
if (ret == -1) {
E("%s", strerror(errno));
return -1;
}
#endif
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
memset(&addr, '\0', addrlen);
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = INADDR_ANY;
ret = bind(servfd, (struct sockaddr *)&addr, addrlen);
if (ret == -1) {
E("%s", strerror(errno));
return -1;
}
int backlog = 20;
ret = listen(servfd, backlog);
if (ret == -1) {
E("%s", strerror(errno));
return -1;
}
FD_ZERO(&rfds_g);
FD_ZERO(&wfds_g);
FD_ZERO(&efds_g);
register_readfd(servfd);
fd_set rfds, wfds, efds;
struct timeval timeout;
int n = 0;
int i = 0;
//DIP(INADDR_ANY);
D("cs start 0.0.0.0 %d", PORT);
while (1) {
rfds = rfds_g;
wfds = wfds_g;
efds = efds_g;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
n = select(maxfd + 1, &rfds, &wfds, &efds, &timeout);
if (n < 0) {
if (errno == EINTR)
continue;
E("select() faile.");
break;
} else if (n == 0) {
//D("timeout, nothing to be done.");
} else {
/* FIXME: while (n--) */
for (i = 0; i <= maxfd; i++) {
if (FD_ISSET(i, &rfds)) {
if (i == servfd) {
ret = cs_accept(i);
if (ret == -1) {
E("cs_accept() failed.");
break;
}
} else {
ret = cs_routine(i, db);
if (ret == -1) {
E("cs_routine() failed.");
break;
}
}
} else if (FD_ISSET(i, &wfds)) {
D("write occurrence.");
} else if (FD_ISSET(i, &efds)) {
E("except occurrence.");
} else {
//E("undefined occurrence.");
}
}
}
}
close(servfd);
sqlite3_close(db);
return 0;
}
