static void
init_netlink()
{
struct sock *nl_sl;
/* Create net_link socket to receive notifications of changes of RLOC
* status. */
netlink_fd = opent_netlink_socket();
nl_sl = sockmstr_register_read_listener(smaster, process_netlink_msg, NULL,
netlink_fd);
/* Request to dump the routing tables to obtain the gatways when
* processing the netlink messages */
request_route_table(RT_TABLE_MAIN, AF_INET);
process_netlink_msg(nl_sl);
request_route_table(RT_TABLE_MAIN, AF_INET6);
process_netlink_msg(nl_sl);
}
void event_loop(void)
{
int max_fd;
fd_set readfds;
time_t curr,prev; //Modified by acabello
/*
* calculate the max_fd for select. Is there a better way
* to do this?
*/
max_fd = (v4_receive_fd > v6_receive_fd) ? v4_receive_fd : v6_receive_fd;
max_fd = (max_fd > netlink_fd) ? max_fd : netlink_fd;
max_fd = (max_fd > nlh.fd) ? max_fd : nlh.fd;
max_fd = (max_fd > map_register_timer_fd)? max_fd : map_register_timer_fd;
// Modified by acabello
prev=time(NULL);
for (EVER) {
FD_ZERO(&readfds);
FD_SET(v4_receive_fd,&readfds);
FD_SET(v6_receive_fd,&readfds);
FD_SET(netlink_fd,&readfds);
FD_SET(nlh.fd, &readfds);
FD_SET(map_register_timer_fd, &readfds);
if (have_input(max_fd,&readfds) == -1)
break; /* news is bad */
if (FD_ISSET(v4_receive_fd,&readfds))
process_lisp_msg(v4_receive_fd, AF_INET);
if (FD_ISSET(v6_receive_fd,&readfds))
process_lisp_msg(v6_receive_fd, AF_INET6);
if (FD_ISSET(netlink_fd,&readfds))
process_netlink_msg();
if (FD_ISSET(nlh.fd,&readfds))
process_netlink_iface();
if (FD_ISSET(map_register_timer_fd,&readfds))
periodic_map_register();
// Modified by acabello
// Each second expire_datacache
// This can be improved by using threading and timer_create()
curr=time(NULL);
if ((curr-prev)>LISPD_EXPIRE_TIMEOUT) {
expire_datacache();
prev=time(NULL);
}
}
}
JNIEXPORT void JNICALL Java_org_lispmob_noroot_LISPmob_1JNI_lispd_1loop(JNIEnv * env, jclass cl)
{
int max_fd;
fd_set readfds;
int retval;
if (nat_aware == TRUE){
initial_info_request_process();
}else{
initial_map_register_process();
/*
* SMR proxy-ITRs list to be updated with new mappings
*/
init_smr(NULL,NULL);
}
/*
* RLOC Probing proxy ETRs
*/
programming_petr_rloc_probing();
/*
* calculate the max_fd for select.
*/
max_fd = tun_fd;
if (default_rloc_afi != AF_INET6){
max_fd = (max_fd > ipv4_data_input_fd) ? max_fd : ipv4_data_input_fd;
max_fd = (max_fd > ipv4_control_input_fd) ? max_fd : ipv4_control_input_fd;
}
if (default_rloc_afi != AF_INET){
max_fd = (max_fd > ipv6_data_input_fd) ? max_fd : ipv6_data_input_fd;
max_fd = (max_fd > ipv6_control_input_fd) ? max_fd : ipv6_control_input_fd;
}
max_fd = (max_fd > timers_fd) ? max_fd : timers_fd;
max_fd = (max_fd > netlink_fd) ? max_fd : netlink_fd;
lispd_running = TRUE;
while (lispd_running) {
FD_ZERO(&readfds);
FD_SET(tun_fd, &readfds);
if (default_rloc_afi != AF_INET6){
FD_SET(ipv4_data_input_fd, &readfds);
FD_SET(ipv4_control_input_fd, &readfds);
}
if (default_rloc_afi != AF_INET){
FD_SET(ipv6_data_input_fd, &readfds);
FD_SET(ipv6_control_input_fd, &readfds);
}
FD_SET(timers_fd, &readfds);
FD_SET(netlink_fd, &readfds);
retval = have_input(max_fd, &readfds);
if (retval != GOOD) {
continue; /* interrupted */
}
if (default_rloc_afi != AF_INET6){
if (FD_ISSET(ipv4_data_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv4 packet");
process_input_packet(ipv4_data_input_fd, AF_INET);
}
if (FD_ISSET(ipv4_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv4 packet in the control input buffer (4342)");
process_ctr_msg(ipv4_control_input_fd, AF_INET);
}
}
if (default_rloc_afi != AF_INET){
if (FD_ISSET(ipv6_data_input_fd, &readfds)) {
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv6 packet");
process_input_packet(ipv6_data_input_fd, AF_INET6);
}
if (FD_ISSET(ipv6_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv6 packet in the control input buffer (4342)");
process_ctr_msg(ipv6_control_input_fd, AF_INET6);
}
}
if (FD_ISSET(tun_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received packet in the tun buffer");
process_output_packet(tun_fd);
}
if (FD_ISSET(timers_fd,&readfds)){
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received something in the timer fd");
process_timer_signal(timers_fd);
}
if (FD_ISSET(netlink_fd,&readfds)){
lispd_log_msg(LISP_LOG_DEBUG_3,"Received notification from net link");
process_netlink_msg(netlink_fd);
}
}
lispd_log_msg(LISP_LOG_DEBUG_2,"event_loop: Exiting from event loop");
}
void event_loop()
{
int max_fd;
fd_set readfds;
int retval;
/*
* calculate the max_fd for select.
*/
max_fd = tun_fd;
if (default_rloc_afi != AF_INET6){
max_fd = (max_fd > ipv4_data_input_fd) ? max_fd : ipv4_data_input_fd;
max_fd = (max_fd > ipv4_control_input_fd) ? max_fd : ipv4_control_input_fd;
}
if (default_rloc_afi != AF_INET){
max_fd = (max_fd > ipv6_data_input_fd) ? max_fd : ipv6_data_input_fd;
max_fd = (max_fd > ipv6_control_input_fd) ? max_fd : ipv6_control_input_fd;
}
max_fd = (max_fd > timers_fd) ? max_fd : timers_fd;
max_fd = (max_fd > netlink_fd) ? max_fd : netlink_fd;
lispd_running = TRUE;
while (lispd_running) {
FD_ZERO(&readfds);
FD_SET(tun_fd, &readfds);
if (default_rloc_afi != AF_INET6){
FD_SET(ipv4_data_input_fd, &readfds);
FD_SET(ipv4_control_input_fd, &readfds);
}
if (default_rloc_afi != AF_INET){
FD_SET(ipv6_data_input_fd, &readfds);
FD_SET(ipv6_control_input_fd, &readfds);
}
FD_SET(timers_fd, &readfds);
FD_SET(netlink_fd, &readfds);
retval = have_input(max_fd, &readfds);
if (retval != GOOD) {
continue; /* interrupted */
}
if (default_rloc_afi != AF_INET6){
if (FD_ISSET(ipv4_data_input_fd, &readfds)) {
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv4 packet");
process_input_packet(ipv4_data_input_fd, AF_INET);
}
if (FD_ISSET(ipv4_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv4 packet in the control input buffer (4342)");
process_ctr_msg(ipv4_control_input_fd, AF_INET);
}
}
if (default_rloc_afi != AF_INET){
if (FD_ISSET(ipv6_data_input_fd, &readfds)) {
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv6 packet");
process_input_packet(ipv6_data_input_fd, AF_INET6);
}
if (FD_ISSET(ipv6_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv6 packet in the control input buffer (4342)");
process_ctr_msg(ipv6_control_input_fd, AF_INET6);
}
}
if (FD_ISSET(tun_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received packet in the tun buffer");
process_output_packet(tun_fd);
}
if (FD_ISSET(timers_fd,&readfds)){
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received something in the timer fd");
process_timer_signal(timers_fd);
}
if (FD_ISSET(netlink_fd,&readfds)){
lispd_log_msg(LISP_LOG_DEBUG_3,"Received notification from net link");
process_netlink_msg(netlink_fd);
}
}
}
int main(int argc, char **argv)
{
uint32_t iseed = 0; /* initial random number generator */
pid_t pid = 0; /* child pid */
pid_t sid = 0;
init_globales();
/*
* Parse command line options
*/
handle_lispd_command_line(argc, argv);
#ifndef ANDROID
/*
* Check for required capabilities and drop unnecssary privileges
*/
if(check_capabilities() != GOOD) {
exit_cleanup();
}
#else
/*
* Check for superuser privileges
*/
if (geteuid() != 0) {
lispd_log_msg(LISP_LOG_INFO,"Running %s requires superuser privileges! Exiting...\n", LISPD);
exit_cleanup();
}
#endif
/*
* Initialize the random number generator
*/
iseed = (unsigned int) time (NULL);
srandom(iseed);
/*
* Set up signal handlers
*/
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
/*
* set up databases
*/
if (db_init() != GOOD ||
map_cache_init() != GOOD ||
init_referral_cache() != GOOD){
exit_cleanup();
}
/*
* see if we need to daemonize, and if so, do it
*/
if (daemonize) {
lispd_log_msg(LISP_LOG_DEBUG_1, "Starting the daemonizing process1");
if ((pid = fork()) < 0) {
exit_cleanup();
}
umask(0);
if (pid > 0){
exit(EXIT_SUCCESS);
}
if ((sid = setsid()) < 0){
exit_cleanup();
}
if ((chdir("/")) < 0){
exit_cleanup();
}
}
/*
* create timers
*/
if (build_timers_event_socket(&timers_fd) != GOOD)
{
lispd_log_msg(LISP_LOG_CRIT, " Error programing the timer signal. Exiting...");
exit_cleanup();
}
init_timers();
/*
* Create net_link socket to receive notifications of changes of RLOC status.
*/
if ((netlink_fd = opent_netlink_socket()) == -1){
lispd_log_msg(LISP_LOG_CRIT, " Error programing netlink socket. Exiting...");
exit_cleanup();
}
/*
* Parse config file. Format of the file depends on the node: Linux Box or OpenWRT router
*/
#ifdef OPENWRT
if (config_file == NULL){
config_file = strdup("/etc/config/lispd");
}
err = handle_uci_lispd_config_file(config_file);
#else
if (config_file == NULL){
config_file = strdup("/etc/lispd.conf");
}
err = handle_lispd_config_file(config_file);
#endif
if (err != GOOD){
lispd_log_msg(LISP_LOG_CRIT,"Wrong configuration.");
exit_cleanup();
}
if (ddt_client == FALSE){
drop_referral_cache();
}
if (nat_aware == TRUE){
nat_set_xTR_ID();
}
/*
* Select the default rlocs for output data packets and output control packets
*/
set_default_output_ifaces();
set_default_ctrl_ifaces();
/*
* Create tun interface
*/
if (create_tun(TUN_IFACE_NAME,
TUN_RECEIVE_SIZE,
TUN_MTU) != GOOD){
exit_cleanup();
}
/*
* Assign address to the tun interface and add routing to this interface
*/
if (configure_routing_to_tun() != GOOD){
exit_cleanup();
}
/*
* Generate receive sockets for control (4342) and data port (4341)
*/
if (default_rloc_afi == AF_UNSPEC || default_rloc_afi == AF_INET){
ipv4_control_input_fd = open_control_input_socket(AF_INET);
ipv4_data_input_fd = open_data_input_socket(AF_INET);
}
if (default_rloc_afi == AF_UNSPEC || default_rloc_afi == AF_INET6){
ipv6_control_input_fd = open_control_input_socket(AF_INET6);
ipv6_data_input_fd = open_data_input_socket(AF_INET6);
}
/*
* Request to dump the routing tables to obtain the gatways when processing the netlink messages
*/
request_route_table(RT_TABLE_MAIN, AF_INET);
process_netlink_msg(netlink_fd);
request_route_table(RT_TABLE_MAIN, AF_INET6);
process_netlink_msg(netlink_fd);
#ifdef OPENWRT
lispd_log_msg(LISP_LOG_INFO,"LISPmob %s compiled for openWRT\n", LISPD_VERSION);
#else
#ifdef ANDROID
lispd_log_msg(LISP_LOG_INFO,"LISPmob %s compiled for Android\n", LISPD_VERSION);
#else
lispd_log_msg(LISP_LOG_INFO,"LISPmob %s compiled for Linux\n", LISPD_VERSION);
#endif
#endif
lispd_log_msg(LISP_LOG_INFO,"LISPmob (%s): 'lispd' started...", LISPD_VERSION);
if (router_mode == TRUE){
lispd_log_msg(LISP_LOG_INFO,"Running as an xTR router");
}else{
lispd_log_msg(LISP_LOG_INFO,"Running as a LISP mobile node");
}
/*
* Register to the Map-Server(s)
*/
if (nat_aware == TRUE){
initial_info_request_process();
}else{
initial_map_register_process();
/*
* SMR proxy-ITRs list to be updated with new mappings
*/
init_smr(NULL,NULL);
}
/*
* RLOC Probing proxy ETRs
*/
programming_petr_rloc_probing();
event_loop();
lispd_log_msg(LISP_LOG_INFO, "Exiting..."); /* event_loop returned bad */
closelog();
return(0);
}
void main_loop(void)
{
struct pollfd fds[2];
memset(fds, 0, sizeof(fds));
fds[0].fd = sock;
fds[0].events = POLLIN;
fds[0].revents = 0;
#if HAVE_NETLINK
fds[1].fd = netlink_socket();
fds[1].events = POLLIN;
fds[1].revents = 0;
#else
fds[1].fd = -1;
fds[1].events = 0;
fds[1].revents = 0;
#endif
for (;;) {
struct Interface *next = NULL;
struct Interface *iface;
int timeout = -1;
int rc;
if (IfaceList) {
timeout = next_time_msec(IfaceList);
next = IfaceList;
for (iface = IfaceList; iface; iface = iface->next) {
int t;
t = next_time_msec(iface);
if (timeout > t) {
timeout = t;
next = iface;
}
}
}
dlog(LOG_DEBUG, 5, "polling for %g seconds.", timeout/1000.0);
rc = poll(fds, sizeof(fds)/sizeof(fds[0]), timeout);
if (rc > 0) {
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[0].fd");
}
else if (fds[0].revents & POLLIN) {
int len, hoplimit;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
unsigned char msg[MSG_SIZE_RECV];
len = recv_rs_ra(msg, &rcv_addr, &pkt_info, &hoplimit);
if (len > 0) {
process(IfaceList, msg, len,
&rcv_addr, pkt_info, hoplimit);
}
}
#ifdef HAVE_NETLINK
if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[1].fd");
}
else if (fds[1].revents & POLLIN) {
process_netlink_msg(fds[1].fd);
}
#endif
}
else if ( rc == 0 ) {
if (next)
timer_handler(next);
}
else if ( rc == -1 && errno != EINTR ) {
flog(LOG_ERR, "poll error: %s", strerror(errno));
}
if (sigterm_received || sigint_received) {
flog(LOG_WARNING, "Exiting, sigterm or sigint received.\n");
break;
}
if (sighup_received)
{
reload_config();
sighup_received = 0;
}
if (sigusr1_received)
{
reset_prefix_lifetimes();
sigusr1_received = 0;
}
}
}
static struct Interface * main_loop(int sock, struct Interface *ifaces, char const *conf_path)
{
struct pollfd fds[2];
sigset_t sigmask;
sigset_t sigempty;
struct sigaction sa;
sigemptyset(&sigempty);
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGHUP);
sigaddset(&sigmask, SIGTERM);
sigaddset(&sigmask, SIGINT);
sigaddset(&sigmask, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigmask, NULL);
sa.sa_handler = sighup_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGHUP, &sa, 0);
sa.sa_handler = sigterm_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTERM, &sa, 0);
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
sa.sa_handler = sigusr1_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, 0);
memset(fds, 0, sizeof(fds));
fds[0].fd = sock;
fds[0].events = POLLIN;
#if HAVE_NETLINK
fds[1].fd = netlink_socket();
fds[1].events = POLLIN;
#else
fds[1].fd = -1;
#endif
for (;;) {
struct timespec *tsp = 0;
struct Interface *next_iface_to_expire = find_iface_by_time(ifaces);
if (next_iface_to_expire) {
static struct timespec ts;
int timeout = next_time_msec(next_iface_to_expire);
ts.tv_sec = timeout / 1000;
ts.tv_nsec = (timeout - 1000 * ts.tv_sec) * 1000000;
tsp = &ts;
dlog(LOG_DEBUG, 1, "polling for %g second(s), next iface is %s", timeout / 1000.0,
next_iface_to_expire->props.name);
} else {
dlog(LOG_DEBUG, 1, "no iface is next. Polling indefinitely");
}
#ifdef HAVE_PPOLL
int rc = ppoll(fds, sizeof(fds) / sizeof(fds[0]), tsp, &sigempty);
#else
int rc = poll(fds, sizeof(fds) / sizeof(fds[0]), 1000*tsp->tv_sec);
#endif
if (rc > 0) {
#ifdef HAVE_NETLINK
if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[1].fd");
} else if (fds[1].revents & POLLIN) {
process_netlink_msg(fds[1].fd, ifaces);
}
#endif
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[0].fd");
} else if (fds[0].revents & POLLIN) {
int len, hoplimit;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
unsigned char msg[MSG_SIZE_RECV];
unsigned char chdr[CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int))];
len = recv_rs_ra(sock, msg, &rcv_addr, &pkt_info, &hoplimit, chdr);
if (len > 0 && pkt_info) {
process(sock, ifaces, msg, len, &rcv_addr, pkt_info, hoplimit);
} else if (!pkt_info) {
dlog(LOG_INFO, 4, "recv_rs_ra returned null pkt_info");
} else if (len <= 0) {
dlog(LOG_INFO, 4, "recv_rs_ra returned len <= 0: %d", len);
}
}
} else if (rc == 0) {
if (next_iface_to_expire)
timer_handler(sock, next_iface_to_expire);
} else if (rc == -1) {
dlog(LOG_INFO, 3, "poll returned early: %s", strerror(errno));
}
if (sigint_received) {
flog(LOG_WARNING, "exiting, %d sigint(s) received", sigint_received);
break;
}
if (sigterm_received) {
flog(LOG_WARNING, "exiting, %d sigterm(s) received", sigterm_received);
break;
}
if (sighup_received) {
dlog(LOG_INFO, 3, "sig hup received");
ifaces = reload_config(sock, ifaces, conf_path);
sighup_received = 0;
}
if (sigusr1_received) {
dlog(LOG_INFO, 3, "sig usr1 received");
reset_prefix_lifetimes(ifaces);
sigusr1_received = 0;
}
}
return ifaces;
}
void event_loop()
{
int max_fd;
fd_set readfds;
int retval;
/*
* calculate the max_fd for select.
*/
max_fd = ipv4_data_input_fd;
max_fd = (max_fd > ipv6_data_input_fd) ? max_fd : ipv6_data_input_fd;
max_fd = (max_fd > ipv4_control_input_fd) ? max_fd : ipv4_control_input_fd;
max_fd = (max_fd > ipv6_control_input_fd) ? max_fd : ipv6_control_input_fd;
max_fd = (max_fd > tun_receive_fd) ? max_fd : tun_receive_fd;
max_fd = (max_fd > timers_fd) ? max_fd : timers_fd;
max_fd = (max_fd > netlink_fd) ? max_fd : netlink_fd;
for (;;) {
FD_ZERO(&readfds);
FD_SET(tun_receive_fd, &readfds);
FD_SET(ipv4_data_input_fd, &readfds);
FD_SET(ipv6_data_input_fd, &readfds);
FD_SET(ipv4_control_input_fd, &readfds);
FD_SET(ipv6_control_input_fd, &readfds);
FD_SET(timers_fd, &readfds);
FD_SET(netlink_fd, &readfds);
retval = have_input(max_fd, &readfds);
if (retval != GOOD) {
continue; /* interrupted */
}
if (FD_ISSET(ipv4_data_input_fd, &readfds)) {
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv4 packet");
process_input_packet(ipv4_data_input_fd, AF_INET, tun_receive_fd);
}
if (FD_ISSET(ipv6_data_input_fd, &readfds)) {
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received input IPv6 packet");
process_input_packet(ipv6_data_input_fd, AF_INET6, tun_receive_fd);
}
if (FD_ISSET(ipv4_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv4 packet in the control input buffer (4342)");
process_lisp_ctr_msg(ipv4_control_input_fd, AF_INET);
}
if (FD_ISSET(ipv6_control_input_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received IPv6 packet in the control input buffer (4342)");
process_lisp_ctr_msg(ipv6_control_input_fd, AF_INET6);
}
if (FD_ISSET(tun_receive_fd, &readfds)) {
lispd_log_msg(LISP_LOG_DEBUG_3,"Received packet in the tun buffer");
process_output_packet(tun_receive_fd, tun_receive_buf, TUN_RECEIVE_SIZE);
}
if (FD_ISSET(timers_fd,&readfds)){
//lispd_log_msg(LISP_LOG_DEBUG_3,"Received something in the timer fd");
process_timer_signal(timers_fd);
}
if (FD_ISSET(netlink_fd,&readfds)){
lispd_log_msg(LISP_LOG_DEBUG_3,"Received notification from net link");
process_netlink_msg(netlink_fd);
}
}
}
int main(int argc, char **argv)
{
lisp_addr_t *tun_v4_addr;
lisp_addr_t *tun_v6_addr;
char *tun_dev_name = TUN_IFACE_NAME;
#ifdef ROUTER
#ifdef OPENWRT
lispd_log_msg(LISP_LOG_INFO,"LISPmob compiled for openWRT xTR\n");
#else
lispd_log_msg(LISP_LOG_INFO,"LISPmob compiled for linux xTR\n");
#endif
#else
lispd_log_msg(LISP_LOG_INFO,"LISPmob compiled for mobile node\n");
#endif
/*
* Check for superuser privileges
*/
if (geteuid()) {
lispd_log_msg(LISP_LOG_INFO,"Running %s requires superuser privileges! Exiting...\n", LISPD);
exit_cleanup();
}
/*
* Initialize the random number generator
*/
iseed = (unsigned int) time (NULL);
srandom(iseed);
/*
* Set up signal handlers
*/
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
/*
* set up databases
*/
db_init();
map_cache_init();
/*
* Parse command line options
*/
handle_lispd_command_line(argc, argv);
/*
* see if we need to daemonize, and if so, do it
*/
if (daemonize) {
lispd_log_msg(LISP_LOG_DEBUG_1, "Starting the daemonizing process");
if ((pid = fork()) < 0) {
exit_cleanup();
}
umask(0);
if (pid > 0)
exit_cleanup();
if ((sid = setsid()) < 0)
exit_cleanup();
if ((chdir("/")) < 0)
exit_cleanup();
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
/*
* create timers
*/
if (build_timers_event_socket(&timers_fd) == 0)
{
lispd_log_msg(LISP_LOG_CRIT, " Error programing the timer signal. Exiting...");
exit_cleanup();
}
init_timers();
/*
* Parse config file. Format of the file depends on the node: Linux Box or OpenWRT router
*/
#ifdef OPENWRT
if (config_file == NULL){
config_file = "/etc/config/lispd";
}
handle_uci_lispd_config_file(config_file);
#else
if (config_file == NULL){
config_file = "/etc/lispd.conf";
}
handle_lispd_config_file(config_file);
#endif
if (map_servers == NULL){
lispd_log_msg(LISP_LOG_CRIT, "No Map Server configured. Exiting...");
exit_cleanup();
}
if (map_resolvers == NULL){
lispd_log_msg(LISP_LOG_CRIT, "No Map Resolver configured. Exiting...");
exit_cleanup();
}
if (proxy_etrs == NULL){
lispd_log_msg(LISP_LOG_WARNING, "No Proxy-ETR defined. Packets to non-LISP destinations will be "
"forwarded natively (no LISP encapsulation). This may prevent mobility in some scenarios.");
sleep(3);
}else{
calculate_balancing_vectors (
proxy_etrs->mapping,
&(((rmt_mapping_extended_info *)(proxy_etrs->mapping->extended_info))->rmt_balancing_locators_vecs));
}
/*
* Select the default rlocs for output data packets and output control packets
*/
set_default_output_ifaces();
set_default_ctrl_ifaces();
/*
* Create tun interface
*/
create_tun(tun_dev_name,
TUN_RECEIVE_SIZE,
TUN_MTU,
&tun_receive_fd,
&tun_ifindex,
&tun_receive_buf);
/*
* Assign address to the tun interface
* Assign route to 0.0.0.0/1 and 128.0.0.0/1 via tun interface
* ::/1 and 8000::/1
*/
#ifdef ROUTER
tun_v4_addr = get_main_eid(AF_INET);
if (tun_v4_addr != NULL){
tun_v4_addr = (lisp_addr_t *)malloc(sizeof(lisp_addr_t));
get_lisp_addr_from_char(TUN_LOCAL_V4_ADDR,tun_v4_addr);
}
tun_v6_addr = get_main_eid(AF_INET6);
if (tun_v6_addr != NULL){
tun_v6_addr = (lisp_addr_t *)malloc(sizeof(lisp_addr_t));
get_lisp_addr_from_char(TUN_LOCAL_V6_ADDR,tun_v6_addr);
}
#else
tun_v4_addr = get_main_eid(AF_INET);
tun_v6_addr = get_main_eid(AF_INET6);
#endif
tun_bring_up_iface(tun_dev_name);
if (tun_v4_addr != NULL){
tun_add_eid_to_iface(*tun_v4_addr,tun_dev_name);
set_tun_default_route_v4();
}
if (tun_v6_addr != NULL){
tun_add_eid_to_iface(*tun_v6_addr,tun_dev_name);
set_tun_default_route_v6();
}
#ifdef ROUTER
if (tun_v4_addr != NULL){
free(tun_v4_addr);
}
if (tun_v6_addr != NULL){
free(tun_v6_addr);
}
#endif
/*
* Generate receive sockets for control (4342) and data port (4341)
*/
if (default_rloc_afi == -1 || default_rloc_afi == AF_INET){
ipv4_control_input_fd = open_control_input_socket(AF_INET);
ipv4_data_input_fd = open_data_input_socket(AF_INET);
}
if (default_rloc_afi == -1 || default_rloc_afi == AF_INET6){
ipv6_control_input_fd = open_control_input_socket(AF_INET6);
ipv6_data_input_fd = open_data_input_socket(AF_INET6);
}
/*
* Create net_link socket to receive notifications of changes of RLOC status.
*/
netlink_fd = opent_netlink_socket();
lispd_log_msg(LISP_LOG_INFO,"LISPmob (0.3.3): 'lispd' started...");
/*
* Request to dump the routing tables to obtain the gatways when processing the netlink messages
*/
request_route_table(RT_TABLE_MAIN, AF_INET);
process_netlink_msg(netlink_fd);
request_route_table(RT_TABLE_MAIN, AF_INET6);
process_netlink_msg(netlink_fd);
/*
* Register to the Map-Server(s)
*/
map_register (NULL,NULL);
/*
* SMR proxy-ITRs list to be updated with new mappings
*/
init_smr(NULL,NULL);
/*
* RLOC Probing proxy ETRs
*/
programming_petr_rloc_probing();
event_loop();
lispd_log_msg(LISP_LOG_INFO, "Exiting..."); /* event_loop returned bad */
closelog();
return(0);
}
