int pwm_init () { int mem_fd; mem_fd = open_memory(); if ( mem_fd < 0) { debug("[%s] Can't open /dev/mem.\n", __func__); return -1; } // FIXME: Check return values? gpio = map_register(mem_fd, GPIO_BASE); clk = map_register(mem_fd, CLOCK_BASE); pwm = map_register(mem_fd, PWM_BASE); /* GPIO18= PWM channel-A Funct. 5 Setup GPIO18 as PWM output */ INP_GPIO(18); SET_GPIO_ALT(18, 5); /* Derive PWM clock direct from X-tal thus any system auto-slow-down-clock-to-save-power does not effect it The values below depends on the X-tal frequency! */ PWMCLK_DIV = 0x5A000000 | (32 << 12);/* set pwm div to 32 (19.2/3 = 600KHz) */ PWMCLK_CNTL = 0x5A000011; /* Source=osc and enable */ /* Make sure it is off and that the B driver (GPIO4) is low */ GPIO_CLR0 = 1 << 4; /* Set GPIO 4 LOW */ PWM_CONTROL = 0; usleep(100); /* I use 1024 steps for the PWM (Just a nice value which I happen to like) */ PWM0_RANGE = PWM_MAX; usleep(100); PWM_CONTROL = PWM0_ENABLE; usleep(100); return 1; }
CScriptEngine::CScriptEngine(CContext & ctx, CMeasure & measure, CVectorMap & vector_map) { throw_null(state = luaL_newstate(), "Не удалось инициализировать интерпретатор Lua"); luaL_openlibs(state); opencv_register(state); // Регистрация биндингов к OpenCV auxiliary_register(state); // Регистрация биндингов к дополнительному функционалу context_register(state); // Регистрация биндингов к функционалу, обрабатывающем контекст map_register(state); // Регистрация биндингов к функционалу, управляющему ВММ // ############################################################################ // Регистрация функции - обработчика доступа к модулям lua_pushlightuserdata(state, this); lua_pushlightuserdata(state, & ctx); lua_pushlightuserdata(state, & measure); lua_pushlightuserdata(state, & vector_map); lua_pushcclosure(state, run_module, 4); // TODO Отладить lua_setglobal(state, "algo"); }
int main(int argc, char **argv) { /* * Check for superuser privileges */ if (geteuid()) { printf("Running %s requires superuser privileges! Exiting...\n", LISPD); exit(EXIT_FAILURE); } /* * 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 syslog now, checking to see if we're daemonizing... */ set_up_syslog(); /* * Unload/load LISP kernel modules */ system("/sbin/modprobe -r lisp lisp_int"); if (system("/sbin/modprobe lisp")) { syslog(LOG_DAEMON, "Loading the 'lisp' kernel module failed! Exiting..."); exit(EXIT_FAILURE); } syslog(LOG_DAEMON, "Loaded the 'lisp' kernel module"); sleep(1); if (system("/sbin/modprobe lisp_int")) { syslog(LOG_DAEMON, "Loading the 'lisp_int' kernel module failed! Exiting..."); exit(EXIT_FAILURE); } syslog(LOG_DAEMON, "Loaded the 'lisp_int' kernel module"); sleep(1); /* * Setup LISP and routing netlink sockets */ if (!setup_netlink()) { syslog(LOG_DAEMON, "Can't set up netlink socket for lisp_mod communication"); exit(EXIT_FAILURE); } if (!setup_netlink_iface()) { syslog(LOG_DAEMON, "Can't set up netlink socket for interface events"); exit(EXIT_FAILURE); } syslog(LOG_DAEMON, "Netlink sockets created"); /* * set up databases */ AF4_database = New_Patricia(sizeof(struct in_addr) * 8); AF6_database = New_Patricia(sizeof(struct in6_addr) * 8); /* * Parse command line options */ handle_lispd_command_line(argc, argv); // Modified by acabello // init_datacache has the following parameters: // void (*cbk)(datacache_elt_t*); -> callback function (see example in lispd_lib.c) if (!init_datacache(callback_elt)) { syslog(LOG_DAEMON, "malloc (datacache): %s", strerror(errno)); exit(EXIT_FAILURE); } /* * Now do the config file */ handle_lispd_config_file(); /* * now build the v4/v6 receive sockets */ if (build_receive_sockets() == 0) exit(EXIT_FAILURE); /* * create timers */ if ((map_register_timer_fd = timerfd_create(CLOCK_REALTIME, 0)) == -1) syslog(LOG_INFO, "Could not create periodic map register timer"); /* * see if we need to daemonize, and if so, do it */ if (daemonize) { syslog(LOG_INFO, "Starting the daemonizing process"); if ((pid = fork()) < 0) { exit(EXIT_FAILURE); } umask(0); if (pid > 0) exit(EXIT_SUCCESS); if ((sid = setsid()) < 0) exit(EXIT_FAILURE); if ((chdir("/")) < 0) exit(EXIT_FAILURE); close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); } /* PN XXX * comment out test definition to avoid any * interactions with the data plane */ #define test #ifdef test int ret = register_lispd_process(); if (ret < 0) { syslog(LOG_INFO, "Couldn't register lispd process, err: %d", ret); exit(EXIT_FAILURE); } syslog(LOG_DAEMON, "Registered lispd with kernel module"); ret = install_database_mappings(); if (ret < 0) { syslog(LOG_INFO, "Could not install database mappings, err: %d", ret); exit(EXIT_FAILURE); } syslog(LOG_DAEMON, "Installed database mappings"); ret = install_map_cache_entries(); if (ret < 0) { syslog(LOG_INFO, "Could not install static map-cache entries, err: %d", ret); } #endif /* * Dump routing table so we can get the gateway address for source routing */ if (!dump_routing_table(AF_INET, RT_TABLE_MAIN)) syslog(LOG_INFO, "Dumping main routing table failed"); /* * Register to the Map-Server(s) */ if (!map_register(AF6_database)) syslog(LOG_INFO, "Could not map register AF_INET6 with Map Servers"); if (!map_register(AF4_database)) syslog(LOG_INFO, "Could not map register AF_INET with Map Servers"); event_loop(); syslog(LOG_INFO, "Exiting..."); /* event_loop returned bad */ closelog(); return(0); }
void FrameMap::initialize() { assert(!_init_done, "once"); assert(nof_cpu_regs == LP64_ONLY(16) NOT_LP64(8), "wrong number of CPU registers"); map_register(0, rsi); rsi_opr = LIR_OprFact::single_cpu(0); map_register(1, rdi); rdi_opr = LIR_OprFact::single_cpu(1); map_register(2, rbx); rbx_opr = LIR_OprFact::single_cpu(2); map_register(3, rax); rax_opr = LIR_OprFact::single_cpu(3); map_register(4, rdx); rdx_opr = LIR_OprFact::single_cpu(4); map_register(5, rcx); rcx_opr = LIR_OprFact::single_cpu(5); #ifndef _LP64 // The unallocatable registers are at the end map_register(6, rsp); map_register(7, rbp); #else map_register( 6, r8); r8_opr = LIR_OprFact::single_cpu(6); map_register( 7, r9); r9_opr = LIR_OprFact::single_cpu(7); map_register( 8, r11); r11_opr = LIR_OprFact::single_cpu(8); map_register( 9, r13); r13_opr = LIR_OprFact::single_cpu(9); map_register(10, r14); r14_opr = LIR_OprFact::single_cpu(10); // r12 is allocated conditionally. With compressed oops it holds // the heapbase value and is not visible to the allocator. map_register(11, r12); r12_opr = LIR_OprFact::single_cpu(11); // The unallocatable registers are at the end map_register(12, r10); r10_opr = LIR_OprFact::single_cpu(12); map_register(13, r15); r15_opr = LIR_OprFact::single_cpu(13); map_register(14, rsp); map_register(15, rbp); #endif // _LP64 #ifdef _LP64 long0_opr = LIR_OprFact::double_cpu(3 /*eax*/, 3 /*eax*/); long1_opr = LIR_OprFact::double_cpu(2 /*ebx*/, 2 /*ebx*/); #else long0_opr = LIR_OprFact::double_cpu(3 /*eax*/, 4 /*edx*/); long1_opr = LIR_OprFact::double_cpu(2 /*ebx*/, 5 /*ecx*/); #endif // _LP64 fpu0_float_opr = LIR_OprFact::single_fpu(0); fpu0_double_opr = LIR_OprFact::double_fpu(0); xmm0_float_opr = LIR_OprFact::single_xmm(0); xmm0_double_opr = LIR_OprFact::double_xmm(0); _caller_save_cpu_regs[0] = rsi_opr; _caller_save_cpu_regs[1] = rdi_opr; _caller_save_cpu_regs[2] = rbx_opr; _caller_save_cpu_regs[3] = rax_opr; _caller_save_cpu_regs[4] = rdx_opr; _caller_save_cpu_regs[5] = rcx_opr; #ifdef _LP64 _caller_save_cpu_regs[6] = r8_opr; _caller_save_cpu_regs[7] = r9_opr; _caller_save_cpu_regs[8] = r11_opr; _caller_save_cpu_regs[9] = r13_opr; _caller_save_cpu_regs[10] = r14_opr; _caller_save_cpu_regs[11] = r12_opr; #endif // _LP64 _xmm_regs[0] = xmm0; _xmm_regs[1] = xmm1; _xmm_regs[2] = xmm2; _xmm_regs[3] = xmm3; _xmm_regs[4] = xmm4; _xmm_regs[5] = xmm5; _xmm_regs[6] = xmm6; _xmm_regs[7] = xmm7; #ifdef _LP64 _xmm_regs[8] = xmm8; _xmm_regs[9] = xmm9; _xmm_regs[10] = xmm10; _xmm_regs[11] = xmm11; _xmm_regs[12] = xmm12; _xmm_regs[13] = xmm13; _xmm_regs[14] = xmm14; _xmm_regs[15] = xmm15; #endif // _LP64 for (int i = 0; i < 8; i++) { _caller_save_fpu_regs[i] = LIR_OprFact::single_fpu(i); } for (int i = 0; i < nof_caller_save_xmm_regs ; i++) { _caller_save_xmm_regs[i] = LIR_OprFact::single_xmm(i); } _init_done = true; rsi_oop_opr = as_oop_opr(rsi); rdi_oop_opr = as_oop_opr(rdi); rbx_oop_opr = as_oop_opr(rbx); rax_oop_opr = as_oop_opr(rax); rdx_oop_opr = as_oop_opr(rdx); rcx_oop_opr = as_oop_opr(rcx); rsi_metadata_opr = as_metadata_opr(rsi); rdi_metadata_opr = as_metadata_opr(rdi); rbx_metadata_opr = as_metadata_opr(rbx); rax_metadata_opr = as_metadata_opr(rax); rdx_metadata_opr = as_metadata_opr(rdx); rcx_metadata_opr = as_metadata_opr(rcx); rsp_opr = as_pointer_opr(rsp); rbp_opr = as_pointer_opr(rbp); #ifdef _LP64 r8_oop_opr = as_oop_opr(r8); r9_oop_opr = as_oop_opr(r9); r11_oop_opr = as_oop_opr(r11); r12_oop_opr = as_oop_opr(r12); r13_oop_opr = as_oop_opr(r13); r14_oop_opr = as_oop_opr(r14); r8_metadata_opr = as_metadata_opr(r8); r9_metadata_opr = as_metadata_opr(r9); r11_metadata_opr = as_metadata_opr(r11); r12_metadata_opr = as_metadata_opr(r12); r13_metadata_opr = as_metadata_opr(r13); r14_metadata_opr = as_metadata_opr(r14); #endif // _LP64 VMRegPair regs; BasicType sig_bt = T_OBJECT; SharedRuntime::java_calling_convention(&sig_bt, ®s, 1, true); receiver_opr = as_oop_opr(regs.first()->as_Register()); }
int main(int argc, char **argv) { int fd = 0; pid_t pid = 0; /* child pid */ pid_t sid = 0; init(); /* * set up databases */ if (!db_init()) { log_msg(INFO, "Couldn't create databases"); exit(EXIT_FAILURE); } /* * Parse command line options */ handle_lispd_command_line(argc, argv); /* * see if we need to daemonize, and if so, do it */ if (lispd_config.daemonize) { log_msg(INFO, "lispd is backgrounding..."); if ((pid = fork()) < 0) { exit(EXIT_FAILURE); } if (pid > 0) { log_msg(INFO, "done. Running as PID %d", pid); exit(EXIT_SUCCESS); } umask(0); if ((sid = setsid()) < 0) exit(EXIT_FAILURE); if ((chdir("/")) < 0) exit(EXIT_FAILURE); /* * Redirect standard files to /dev/null save fd in * case we need to get back to stdout later */ fd = dup(fileno(stdout)); } signal(SIGHUP, signal_handler); signal(SIGTERM, signal_handler); signal(SIGINT, signal_handler); signal(SIGQUIT, signal_handler); init_timers(); /* * Check if lispd is already running. Only allow one instance! */ if (!get_process_lock(getpid())) { log_msg(FATAL, "lispd already running, please stop before restarting. If this seems wrong" " remove %s.", LISPD_LOCKFILE); printf("lispd already running, please stop before restarting.\n If this appears wrong," " remove %s.\n", LISPD_LOCKFILE); exit(EXIT_FAILURE); } if (!setup_netlink()) { log_msg(FATAL, "Can't set up netlink socket (is the kernel module loaded?), exiting..."); die(EXIT_FAILURE); } if (!setup_rtnetlink()) { log_msg(FATAL, "Can't setup rtnetlink socket, exiting..."); die(EXIT_FAILURE); } if (!register_lispd_process()) { log_msg(FATAL, "Couldn't register lispd process, exiting..."); die(EXIT_FAILURE); } log_msg(INFO, "Version %d.%d.%d starting up...", MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION); /* * now build the v4/v6 receive sockets */ if (build_receive_sockets() == 0) { log_msg(FATAL, " exiting..."); die(EXIT_FAILURE); } if (build_event_socket() == 0) { log_msg(FATAL, " exiting..."); die(EXIT_FAILURE); } log_msg(INFO, "Built receive/event sockets"); /* * Now do the config file */ if (handle_lispd_config_file()) { log_msg(FATAL, "Fatal error parsing config file."); dump_fatal_error(); die(EXIT_FAILURE); } /* * set up syslog now, checking to see if we're daemonizing... */ setup_log(); log_msg(INFO, "Read config file"); if (!install_database_mappings()) { log_msg(FATAL, " exiting..."); die(EXIT_FAILURE); } #ifdef DEADCODE if (!install_map_cache_entries()) log_msg(INFO, "Could not install static map-cache entries"); #endif if (!map_register()) log_msg(INFO, "Could not map register."); set_timer(RLOCProbeScan, RLOC_PROBE_CHECK_INTERVAL); clear_map_cache(); listen_on_well_known_port(); dump_info_file(); event_loop(); log_msg(INFO, "exiting..."); /* event_loop returned bad */ remove_process_lock(); exit(0); }
int main(int argc, char **argv) { lisp_addr_t *tun_v4_addr = NULL; lisp_addr_t *tun_v6_addr = NULL; char *tun_dev_name = TUN_IFACE_NAME; uint32_t iseed = 0; /* initial random number generator */ pid_t pid = 0; /* child pid */ pid_t sid = 0; #ifdef OPENWRT lispd_log_msg(LISP_LOG_INFO,"LISPmob %s compiled for openWRT\n", LISPD_VERSION); #else #ifdef ANDROID open_log_file(); 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 init_globales(); #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 */ db_init(); map_cache_init(); init_referral_cache(); /* * 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 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) == 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"; } err = handle_uci_lispd_config_file(config_file); #else if (config_file == NULL){ config_file = "/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(); } /* * 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 */ if (router_mode == TRUE){ 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); } 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(); } if (router_mode == TRUE){ if (tun_v4_addr != NULL){ free(tun_v4_addr); } if (tun_v6_addr != NULL){ free(tun_v6_addr); } } /* * 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); } /* * Create net_link socket to receive notifications of changes of RLOC status. */ netlink_fd = opent_netlink_socket(); 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"); } /* * 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); }
int process_info_reply_msg( uint8_t *packet, lisp_addr_t local_rloc) { uint8_t *ptr = packet; uint8_t lisp_type = 0; uint8_t reply = 0; uint64_t nonce = 0; uint16_t key_id = 0; uint16_t auth_data_len = 0; uint8_t *auth_data_pos = NULL; uint32_t ttl = 0; uint8_t eid_mask_len = 0; lisp_addr_t eid_prefix = {.afi=AF_UNSPEC}; uint16_t ms_udp_port = 0; uint16_t etr_udp_port = 0; uint32_t info_reply_hdr_len = 0; uint32_t lcaf_addr_len = 0; uint32_t pckt_len = 0; uint16_t *lcaf_afi = NULL; lisp_addr_t global_etr_rloc = {.afi=AF_UNSPEC}; lisp_addr_t ms_rloc = {.afi=AF_UNSPEC}; lisp_addr_t private_etr_rloc = {.afi=AF_UNSPEC}; lispd_rtr_locators_list *rtr_locators_list = NULL; lispd_mapping_elt *mapping = NULL; lispd_locator_elt *locator = NULL; lcl_locator_extended_info *lcl_locator_ext_inf = NULL; char rtrs_list_str[2000]; int rtrs_list_str_size = 0; lispd_rtr_locators_list *aux_rtr_locators_list = NULL; uint8_t is_behind_nat = FALSE; /* * Get source port and address. */ err = extract_info_nat_header(ptr, &lisp_type, &reply, &nonce, &key_id, &auth_data_len, &auth_data_pos, &ttl, &eid_mask_len, &eid_prefix, &info_reply_hdr_len); if (err != GOOD){ lispd_log_msg(LISP_LOG_DEBUG_1,"process_info_reply_msg: Couldn't process Info Reply message"); return (BAD); } ptr = CO(ptr,info_reply_hdr_len); lcaf_afi = (uint16_t *)ptr; if ( ntohs(*lcaf_afi) != LISP_AFI_LCAF){ lispd_log_msg(LISP_LOG_DEBUG_1,"process_info_reply_msg: Malformed packet"); return (BAD); } ptr = CO(ptr,FIELD_AFI_LEN); /* Extract Info-Reply body fields */ err = extract_nat_lcaf_data(ptr, &ms_udp_port, &etr_udp_port, &global_etr_rloc, &ms_rloc, &private_etr_rloc, &rtr_locators_list, &lcaf_addr_len); if (err == BAD) { lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Error extracting packet data"); return (BAD); } /* Leave only RTR with same afi as the local rloc where we received the message */ remove_rtr_locators_with_afi_different_to(&rtr_locators_list, local_rloc.afi); lcaf_addr_len = lcaf_addr_len + FIELD_AFI_LEN; /* Print the extracted information of the message */ if (is_loggable(LISP_LOG_DEBUG_2)){ aux_rtr_locators_list = rtr_locators_list; rtrs_list_str[0] = '\0'; while (aux_rtr_locators_list != NULL){ sprintf(rtrs_list_str + rtrs_list_str_size, " %s ", get_char_from_lisp_addr_t(aux_rtr_locators_list->locator->address)); rtrs_list_str_size = rtrs_list_str_size + strlen(rtrs_list_str); aux_rtr_locators_list = aux_rtr_locators_list->next; } lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply message data->" "Nonce: %s , KeyID: %hu ,TTL: %u , EID-prefix: %s/%hhu , " "MS UDP Port Number: %hu , ETR UDP Port Number: %hu , Global ETR RLOC Address: %s , " "MS RLOC Address: %s , Private ETR RLOC Address: %s, RTR RLOC Compatible list: %s", get_char_from_nonce(nonce), key_id, ttl, get_char_from_lisp_addr_t(eid_prefix),eid_mask_len, ms_udp_port, etr_udp_port, get_char_from_lisp_addr_t(global_etr_rloc), get_char_from_lisp_addr_t(ms_rloc),get_char_from_lisp_addr_t(private_etr_rloc),rtrs_list_str); } /* Checking the nonce */ if (check_nonce(nat_ir_nonce,nonce) == GOOD ){ lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Correct nonce field checking "); free(nat_ir_nonce); nat_ir_nonce = NULL; }else{ lispd_log_msg(LISP_LOG_DEBUG_1, "Info-Reply: Error checking nonce field. No Info Request generated with nonce: %s", get_char_from_nonce (nonce)); return (BAD); } /* Check authentication data */ pckt_len = info_reply_hdr_len + lcaf_addr_len; if(BAD == check_auth_field(key_id, map_servers->key, (void *) packet, pckt_len, auth_data_pos)){ lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Error checking auth data field"); return(BAD); }else{ lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Correct auth data field checking"); } // TODO Select the best RTR from the list retrieved from the Info-Reply /* Check if behind NAT */ switch (compare_lisp_addr_t(&global_etr_rloc, &local_rloc)) { case 0: is_behind_nat = FALSE; lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: MN is not behind NAT"); break; case 1: case 2: is_behind_nat = TRUE; lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: MN is behind NAT"); break; case -1: is_behind_nat = UNKNOWN; lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: Unknown state"); break; } if (is_behind_nat == TRUE){ if (rtr_locators_list == NULL){ lispd_log_msg(LISP_LOG_WARNING, "process_info_reply_msg: The interface with IP address %s is behind NAT" " but there is no RTR compatible with local AFI", get_char_from_lisp_addr_t(local_rloc)); } mapping = lookup_eid_exact_in_db(eid_prefix, eid_mask_len); if (mapping == NULL){ lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Info Reply is not for any local EID"); return (BAD); } locator = get_locator_from_mapping(mapping,local_rloc); if (locator == NULL){ lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Info Reply received in the wrong locator"); return (BAD); } lcl_locator_ext_inf = (lcl_locator_extended_info *)locator->extended_info; if (lcl_locator_ext_inf->rtr_locators_list != NULL){ free_rtr_list(lcl_locator_ext_inf->rtr_locators_list); } lcl_locator_ext_inf->rtr_locators_list = rtr_locators_list; if (nat_status == NO_NAT || nat_status == PARTIAL_NAT){ nat_status = PARTIAL_NAT; }else{ nat_status = FULL_NAT; } }else{ if (nat_status == FULL_NAT || nat_status == PARTIAL_NAT){ nat_status = PARTIAL_NAT; }else{ nat_status = NO_NAT; } } /* If we are behind NAT, the program timer to send Info Request after TTL minutes */ if (is_behind_nat == TRUE){ if (info_reply_ttl_timer == NULL) { info_reply_ttl_timer = create_timer(INFO_REPLY_TTL_TIMER); } start_timer(info_reply_ttl_timer, ttl*60, info_request, (void *)mapping); lispd_log_msg(LISP_LOG_DEBUG_1, "Reprogrammed info request in %d minutes",ttl); }else{ stop_timer(info_reply_ttl_timer); info_reply_ttl_timer = NULL; } /* Once we know the NAT state we send a Map-Register */ map_register(NULL,NULL); return (GOOD); }
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); }