/* The asserts include a return on fail; cleanup in the caller */ static int _dm_test_net_retry(struct unit_test_state *uts) { /* * eth1 is disabled and netretry is yes, so the ping should succeed and * the active device should be eth0 */ sandbox_eth_disable_response(1, true); env_set("ethact", "eth@10004000"); env_set("netretry", "yes"); sandbox_eth_skip_timeout(); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); /* * eth1 is disabled and netretry is no, so the ping should fail and the * active device should be eth1 */ env_set("ethact", "eth@10004000"); env_set("netretry", "no"); sandbox_eth_skip_timeout(); ut_asserteq(-ENONET, net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); return 0; }
//int init_net(int count , char *ip, int port); //int net_loop(); int main(int argc,char** argv) { char ip[10]="127.0.0.1"; int port=10002; int MAX_EPOLL_CNT=100; if(init_proc()){ return -1; } init_net(MAX_EPOLL_CNT, ip, 10000); for(int loop=0 ; loop < MAX_PID_CNT ; loop++ ){ int pid=fork(); if( pid>0 ){ std::cout<<"parent start:"<<getpid()<<std::endl; }else if(pid==0){ std::cout<<"child start"<<" pid: "<<getpid()<<" parent:"<<getppid()<<std::endl; exit_net(); while(1){ net_loop(0); } }else{ exit(-1); } } while(1){ net_loop(1); } exit_net(); return 0; }
static int _dm_test_eth_rotate2(struct unit_test_state *uts) { /* Make sure we can skip invalid devices */ env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); /* Make sure we can handle device name which is not eth# */ env_set("ethact", "sbe5"); ut_assertok(net_loop(PING)); ut_asserteq_str("sbe5", env_get("ethact")); return 0; }
/* The asserts include a return on fail; cleanup in the caller */ static int _dm_test_eth_rotate1(struct unit_test_state *uts) { /* Make sure that the default is to rotate to the next interface */ env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); /* If ethrotate is no, then we should fail on a bad MAC */ env_set("ethact", "eth@10004000"); env_set("ethrotate", "no"); ut_asserteq(-EINVAL, net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); return 0; }
static int nc_stdio_tstc(struct stdio_dev *dev) { #ifdef CONFIG_DM_ETH struct udevice *eth; #else struct eth_device *eth; #endif if (input_recursion) return 0; if (input_size) return 1; eth = eth_get_dev(); if (eth_is_active(eth)) return 0; /* inside net loop */ input_recursion = 1; net_timeout = 1; net_loop(NETCONS); /* kind of poll */ input_recursion = 0; return input_size != 0; }
int net_getline (char **s, size_t *l) { got_it_ok = 0; _s = s; _l = l; rl_callback_handler_install (0, got_it); net_loop (1, is_got_it); return 0; }
static int dm_test_eth_prime(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); /* Expected to be "eth@10003000" because of ethprime variable */ env_set("ethact", NULL); env_set("ethprime", "eth5"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); /* Expected to be "eth@10002000" because it is first */ env_set("ethact", NULL); env_set("ethprime", NULL); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); return 0; }
static int dm_test_eth(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); env_set("ethact", "eth@10002000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth@10003000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); return 0; }
int net_getline (char **s, size_t *l) { fflush (stdout); // rl_already_prompted = 1; got_it_ok = 0; _s = s; _l = l; // rl_callback_handler_install (0, got_it); net_loop (2, is_got_it); return 0; }
static void nc_send_packet(const char *buf, int len) { #ifdef CONFIG_DM_ETH struct udevice *eth; #else struct eth_device *eth; #endif int inited = 0; uchar *pkt; uchar *ether; struct in_addr ip; debug_cond(DEBUG_DEV_PKT, "output: \"%*.*s\"\n", len, len, buf); eth = eth_get_dev(); if (eth == NULL) return; if (!memcmp(nc_ether, net_null_ethaddr, 6)) { if (eth_is_active(eth)) return; /* inside net loop */ output_packet = buf; output_packet_len = len; input_recursion = 1; net_loop(NETCONS); /* wait for arp reply and send packet */ input_recursion = 0; output_packet_len = 0; return; } if (!eth_is_active(eth)) { if (eth_is_on_demand_init()) { if (eth_init() < 0) return; eth_set_last_protocol(NETCONS); } else { eth_init_state_only(); } inited = 1; } pkt = (uchar *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE; memcpy(pkt, buf, len); ether = nc_ether; ip = nc_ip; net_send_udp_packet(ether, ip, nc_out_port, nc_in_port, len); if (inited) { if (eth_is_on_demand_init()) eth_halt(); else eth_halt_state_only(); } }
static int dm_test_eth_alias(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); env_set("ethact", "eth0"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth1"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); /* Expected to fail since eth2 is not defined in the device tree */ env_set("ethact", "eth2"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth5"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); return 0; }
int loop (void) { on_start (); if (binlog_enabled) { double t = get_double_time (); logprintf ("replay log start\n"); replay_log (); logprintf ("replay log end in %lf seconds\n", get_double_time () - t); write_binlog (); #ifdef USE_LUA lua_binlog_end (); #endif } else { read_auth_file (); } update_prompt (); assert (DC_list[dc_working_num]); if (!DC_working || !DC_working->auth_key_id) { // if (auth_state == 0) { DC_working = DC_list[dc_working_num]; assert (!DC_working->auth_key_id); dc_authorize (DC_working); assert (DC_working->auth_key_id); auth_state = 100; write_auth_file (); } if (verbosity) { logprintf ("Requesting info about DC...\n"); } do_help_get_config (); net_loop (0, mcs); if (verbosity) { logprintf ("DC_info: %d new DC got\n", new_dc_num); } int i; for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) { dc_authorize (DC_list[i]); assert (DC_list[i]->auth_key_id); write_auth_file (); } if (auth_state == 100 || !(DC_working->has_auth)) { registeringStarted(); start_registering(); } registeringFinished(); return connect_to_server(); }
static int dm_test_eth_async_ping_reply(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler); /* Used by all of the ut_assert macros in the tx_handler */ sandbox_eth_set_priv(0, uts); env_set("ethact", "eth@10002000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); sandbox_eth_set_tx_handler(0, NULL); return 0; }
static int update_load(char *filename, ulong msec_max, int cnt_max, ulong addr) { int size, rv; ulong saved_timeout_msecs; int saved_timeout_count; char *saved_netretry, *saved_bootfile; rv = 0; /* save used globals and env variable */ saved_timeout_msecs = tftp_timeout_ms; saved_timeout_count = tftp_timeout_count_max; saved_netretry = strdup(getenv("netretry")); saved_bootfile = strdup(net_boot_file_name); /* set timeouts for auto-update */ tftp_timeout_ms = msec_max; tftp_timeout_count_max = cnt_max; /* we don't want to retry the connection if errors occur */ setenv("netretry", "no"); /* download the update file */ load_addr = addr; copy_filename(net_boot_file_name, filename, sizeof(net_boot_file_name)); size = net_loop(TFTPGET); if (size < 0) rv = 1; else if (size > 0) flush_cache(addr, size); /* restore changed globals and env variable */ tftp_timeout_ms = saved_timeout_msecs; tftp_timeout_count_max = saved_timeout_count; setenv("netretry", saved_netretry); if (saved_netretry != NULL) free(saved_netretry); if (saved_bootfile != NULL) { copy_filename(net_boot_file_name, saved_bootfile, sizeof(net_boot_file_name)); free(saved_bootfile); } return rv; }
static int do_fastboot_udp(int argc, char *const argv[], uintptr_t buf_addr, size_t buf_size) { #if CONFIG_IS_ENABLED(UDP_FUNCTION_FASTBOOT) int err = net_loop(FASTBOOT); if (err < 0) { printf("fastboot udp error: %d\n", err); return CMD_RET_FAILURE; } return CMD_RET_SUCCESS; #else pr_err("Fastboot UDP not enabled\n"); return CMD_RET_FAILURE; #endif }
/** * This test case is trying to test the following scenario: * - All ethernet devices are not probed * - "ethaddr" for all ethernet devices are not set * - "ethact" is set to a valid ethernet device name * * With Sandbox default test configuration, all ethernet devices are * probed after power-up, so we have to manually create such scenario: * - Remove all ethernet devices * - Remove all "ethaddr" environment variables * - Set "ethact" to the first ethernet device * * Do a ping test to see if anything goes wrong. */ static int dm_test_eth_act(struct unit_test_state *uts) { struct udevice *dev[DM_TEST_ETH_NUM]; const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000", "sbe5", "eth@10004000"}; const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr", "eth3addr", "eth1addr"}; char ethaddr[DM_TEST_ETH_NUM][18]; int i; memset(ethaddr, '\0', sizeof(ethaddr)); net_ping_ip = string_to_ip("1.1.2.2"); /* Prepare the test scenario */ for (i = 0; i < DM_TEST_ETH_NUM; i++) { ut_assertok(uclass_find_device_by_name(UCLASS_ETH, ethname[i], &dev[i])); ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL)); /* Invalidate MAC address */ strncpy(ethaddr[i], env_get(addrname[i]), 17); /* Must disable access protection for ethaddr before clearing */ env_set(".flags", addrname[i]); env_set(addrname[i], NULL); } /* Set ethact to "eth@10002000" */ env_set("ethact", ethname[0]); /* Segment fault might happen if something is wrong */ ut_asserteq(-ENODEV, net_loop(PING)); for (i = 0; i < DM_TEST_ETH_NUM; i++) { /* Restore the env */ env_set(".flags", addrname[i]); env_set(addrname[i], ethaddr[i]); /* Probe the device again */ ut_assertok(device_probe(dev[i])); } env_set(".flags", NULL); env_set("ethact", NULL); return 0; }
void kadnode_loop(void) { if (gconf && gconf->is_running == 0) { conf_check(); main_setup(); // Loop over all sockets and file descriptors net_loop(); // Export peers if a file is provided peerfile_export(); main_free(); conf_free(); } }
int spl_net_load_image(const char *device) { struct image_header *header; int rv; env_init(); env_relocate(); setenv("autoload", "yes"); if (IS_ENABLED(CONFIG_SPL_LOAD_FIT)) load_addr = CONFIG_SPL_LOAD_FIT_ADDRESS; else load_addr = CONFIG_SYS_TEXT_BASE - sizeof(struct image_header); rv = eth_initialize(); if (rv == 0) { printf("No Ethernet devices found\n"); return -ENODEV; } if (device) setenv("ethact", device); rv = net_loop(BOOTP); if (rv < 0) { printf("Problem booting with BOOTP\n"); return rv; } header = (struct image_header *)load_addr; if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_net_load_read; spl_load_simple_fit(&load, 0, header); } else { spl_parse_image_header((struct image_header *)load_addr); } return 0; }
static int spl_net_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { struct image_header *header = (struct image_header *)load_addr; int rv; env_init(); env_relocate(); env_set("autoload", "yes"); rv = eth_initialize(); if (rv == 0) { printf("No Ethernet devices found\n"); return -ENODEV; } if (bootdev->boot_device_name) env_set("ethact", bootdev->boot_device_name); rv = net_loop(BOOTP); if (rv < 0) { printf("Problem booting with BOOTP\n"); return rv; } if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_net_load_read; rv = spl_load_simple_fit(spl_image, &load, 0, header); } else { debug("Legacy image\n"); rv = spl_parse_image_header(spl_image, header); if (rv) return rv; memcpy((void *)spl_image->load_addr, header, spl_image->size); } return rv; }
static int nc_stdio_getc(struct stdio_dev *dev) { uchar c; input_recursion = 1; net_timeout = 0; /* no timeout */ while (!input_size) net_loop(NETCONS); input_recursion = 0; c = input_buffer[input_offset++]; if (input_offset >= sizeof(input_buffer)) input_offset -= sizeof(input_buffer); input_size--; return c; }
void iface_loop(void) { char errbuf[PCAP_ERRBUF_SIZE]; unsigned i; const signed promisc = 1; do { /* set up each iface */ for (i = 0; i < Iface_Cnt; i++) { printf("Opening %s... ", Dev_Str[i]); Pcap[i] = pcap_open_live(Dev_Str[i], MAX_CAP, promisc, 0, errbuf); if (NULL == Pcap[i]) { printf("%s\n", errbuf); continue; } printf("OK.\n"); Datalink[i] = pcap_datalink(Pcap[i]); } net_loop(); printf("interfaces down...\n"); } while (!Shutdown); printf("iface loop done.\n"); }
void restart_child_process() { close(pipe_handles[1]); do_del_conn(pipe_handles[2], 2); shmq_destroy (); shmq_create(); pipe_create (); pid_t pid; if ((pid = fork ()) < 0) ERROR_LOG("fork child process, fail"); //parent process else if (pid > 0) { close (pipe_handles[3]); close (pipe_handles[0]); do_add_conn (pipe_handles[2], PIPE_TYPE_FD, NULL); //child process } else { close (pipe_handles[1]); close (pipe_handles[2]); net_init (MAXFDS, pipe_handles[0]); if (handle_init () != 0) goto out; while (!stop || !handle_fini ()) net_loop (1000, RCVBUFSZ, 0); out: shmq_destroy (); } }
int loop (void) { on_start (); read_auth_file (); readline_active = 1; rl_set_prompt (""); assert (DC_list[dc_working_num]); if (auth_state == 0) { DC_working = DC_list[dc_working_num]; assert (!DC_working->auth_key_id); dc_authorize (DC_working); assert (DC_working->auth_key_id); auth_state = 100; write_auth_file (); } if (verbosity) { logprintf ("Requesting info about DC...\n"); } do_help_get_config (); net_loop (0, mcs); if (verbosity) { logprintf ("DC_info: %d new DC got\n", new_dc_num); } int i; for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) { dc_authorize (DC_list[i]); assert (DC_list[i]->auth_key_id); write_auth_file (); } if (auth_state == 100) { if (!default_username) { size_t size = 0; char *user = 0; if (!user) { printf ("Telephone number (with '+' sign): "); if (net_getline (&user, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } set_default_username (user); } } int res = do_auth_check_phone (default_username); assert (res >= 0); logprintf ("%s\n", res > 0 ? "phone registered" : "phone not registered"); if (res > 0) { do_send_code (default_username); char *code = 0; size_t size = 0; printf ("Code from sms: "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (do_send_code_result (code) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } auth_state = 300; } else { printf ("User is not registered. Do you want to register? [Y/n] "); char *code; size_t size; if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (!*code || *code == 'y') { printf ("Ok, starting registartion.\n"); } else { printf ("Then try again\n"); exit (EXIT_SUCCESS); } char *first_name; printf ("Name: "); if (net_getline (&first_name, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } char *last_name; printf ("Name: "); if (net_getline (&last_name, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } int dc_num = do_get_nearest_dc (); assert (dc_num >= 0 && dc_num <= MAX_DC_NUM && DC_list[dc_num]); dc_working_num = dc_num; DC_working = DC_list[dc_working_num]; do_send_code (default_username); printf ("Code from sms: "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (do_send_code_result_auth (code, first_name, last_name) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } auth_state = 300; } } for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->has_auth) { do_export_auth (i); do_import_auth (i); DC_list[i]->has_auth = 1; write_auth_file (); } write_auth_file (); fflush (stdin); fflush (stdout); fflush (stderr); rl_callback_handler_install (get_default_prompt (), interpreter); rl_attempted_completion_function = (CPPFunction *) complete_text; rl_completion_entry_function = complete_none; do_get_dialog_list (); return main_loop (); }
int main_loop (void) { net_loop (1, ret1); return 0; }
int loop (void) { //on_start (); tgl_set_callback (TLS, &upd_cb); //TLS->temp_key_expire_time = 60; struct event_base *ev = event_base_new (); tgl_set_ev_base (TLS, ev); tgl_set_net_methods (TLS, &tgl_conn_methods); tgl_set_timer_methods (TLS, &tgl_libevent_timers); assert (TLS->timer_methods); tgl_set_download_directory (TLS, get_downloads_directory ()); tgl_register_app_id (TLS, TELEGRAM_CLI_APP_ID, TELEGRAM_CLI_APP_HASH); tgl_init (TLS); if (binlog_enabled) { double t = tglt_get_double_time (); if (verbosity >= E_DEBUG) { logprintf ("replay log start\n"); } tgl_replay_log (TLS); if (verbosity >= E_DEBUG) { logprintf ("replay log end in %lf seconds\n", tglt_get_double_time () - t); } tgl_reopen_binlog_for_writing (TLS); } else { read_auth_file (); read_state_file (); read_secret_chat_file (); } binlog_read = 1; #ifdef USE_LUA lua_binlog_end (); #endif if (sfd >= 0) { struct event *ev = event_new (TLS->ev_base, sfd, EV_READ | EV_PERSIST, accept_incoming, 0); event_add (ev, 0); } if (usfd >= 0) { struct event *ev = event_new (TLS->ev_base, usfd, EV_READ | EV_PERSIST, accept_incoming, 0); event_add (ev, 0); } update_prompt (); if (reset_authorization) { tgl_peer_t *P = tgl_peer_get (TLS, TGL_MK_USER (TLS->our_id)); if (P && P->user.phone && reset_authorization == 1) { set_default_username (P->user.phone); } bl_do_reset_authorization (TLS); } net_loop (0, all_authorized); int i; for (i = 0; i <= TLS->max_dc_num; i++) if (TLS->DC_list[i] && !tgl_authorized_dc (TLS, TLS->DC_list[i])) { assert (0); } if (!tgl_signed_dc (TLS, TLS->DC_working)) { if (disable_output) { fprintf (stderr, "Can not login without output\n"); do_halt (1); } if (!default_username) { size_t size = 0; char *user = 0; if (!user) { printf ("Telephone number (with '+' sign): "); if (net_getline (&user, &size) == -1) { perror ("getline()"); do_halt (1); } set_default_username (user); } } tgl_do_send_code (TLS, default_username, sign_in_callback, 0); net_loop (0, sent_code); if (verbosity >= E_DEBUG) { logprintf ("%s\n", should_register ? "phone not registered" : "phone registered"); } if (!should_register) { char *code = 0; size_t size = 0; printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); do_halt (1); } if (!strcmp (code, "call")) { printf ("You typed \"call\", switching to phone system.\n"); tgl_do_phone_call (TLS, default_username, hash, 0, 0); printf ("Calling you! Code: "); continue; } if (tgl_do_send_code_result (TLS, default_username, hash, code, sign_in_result, 0) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } } else { printf ("User is not registered. Do you want to register? [Y/n] "); char *code; size_t size; if (net_getline (&code, &size) == -1) { perror ("getline()"); do_halt (1); } if (!*code || *code == 'y' || *code == 'Y') { printf ("Ok, starting registartion.\n"); } else { printf ("Then try again\n"); do_halt (1); } char *first_name; printf ("First name: "); if (net_getline (&first_name, &size) == -1) { perror ("getline()"); do_halt (1); } char *last_name; printf ("Last name: "); if (net_getline (&last_name, &size) == -1) { perror ("getline()"); do_halt (1); } printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); do_halt (1); } if (!strcmp (code, "call")) { printf ("You typed \"call\", switching to phone system.\n"); tgl_do_phone_call (TLS, default_username, hash, 0, 0); printf ("Calling you! Code: "); continue; } if (tgl_do_send_code_result_auth (TLS, default_username, hash, code, first_name, last_name, sign_in_result, 0) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } } net_loop (0, signed_in); //bl_do_dc_signed (TLS->DC_working); } for (i = 0; i <= TLS->max_dc_num; i++) if (TLS->DC_list[i] && !tgl_signed_dc (TLS, TLS->DC_list[i])) { tgl_do_export_auth (TLS, i, export_auth_callback, (void*)(long)TLS->DC_list[i]); cur_a_dc = TLS->DC_list[i]; net_loop (0, dc_signed_in); assert (tgl_signed_dc (TLS, TLS->DC_list[i])); } write_auth_file (); fflush (stdout); fflush (stderr); //read_state_file (); //read_secret_chat_file (); set_interface_callbacks (); tglm_send_all_unsent (TLS); tgl_do_get_difference (TLS, sync_from_start, get_difference_callback, 0); net_loop (0, dgot); assert (!(TLS->locks & TGL_LOCK_DIFF)); TLS->started = 1; if (wait_dialog_list) { d_got_ok = 0; tgl_do_get_dialog_list (TLS, dlist_cb, 0); net_loop (0, dgot); } #ifdef USE_LUA lua_diff_end (); #endif if (start_command) { safe_quit = 1; while (*start_command) { char *start = start_command; while (*start_command && *start_command != '\n') { start_command ++; } if (*start_command) { *start_command = 0; start_command ++; } interpreter_ex (start, 0); } } /*tgl_do_get_dialog_list (get_dialogs_callback, 0); if (wait_dialog_list) { dialog_list_got = 0; net_loop (0, dlgot); }*/ return main_loop (); }
/* * Interpreter command to boot VxWorks from a memory image. The image can * be either an ELF image or a raw binary. Will attempt to setup the * bootline and other parameters correctly. */ int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { unsigned long addr; /* Address of image */ unsigned long bootaddr; /* Address to put the bootline */ char *bootline; /* Text of the bootline */ char *tmp; /* Temporary char pointer */ char build_buf[128]; /* Buffer for building the bootline */ int ptr = 0; #ifdef CONFIG_X86 struct e820info *info; struct e820entry *data; #endif /* * Check the loadaddr variable. * If we don't know where the image is then we're done. */ if (argc < 2) addr = load_addr; else addr = simple_strtoul(argv[1], NULL, 16); #if defined(CONFIG_CMD_NET) /* * Check to see if we need to tftp the image ourselves * before starting */ if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) { if (net_loop(TFTPGET) <= 0) return 1; printf("Automatic boot of VxWorks image at address 0x%08lx ...\n", addr); } #endif /* * This should equate to * NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET * from the VxWorks BSP header files. * This will vary from board to board */ #if defined(CONFIG_WALNUT) tmp = (char *)CONFIG_SYS_NVRAM_BASE_ADDR + 0x500; eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); memcpy(tmp, &build_buf[3], 3); #elif defined(CONFIG_SYS_VXWORKS_MAC_PTR) tmp = (char *)CONFIG_SYS_VXWORKS_MAC_PTR; eth_getenv_enetaddr("ethaddr", (uchar *)build_buf); memcpy(tmp, build_buf, 6); #else puts("## Ethernet MAC address not copied to NV RAM\n"); #endif /* * Use bootaddr to find the location in memory that VxWorks * will look for the bootline string. The default value is * (LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET) as defined by * VxWorks BSP. For example, on PowerPC it defaults to 0x4200. */ tmp = getenv("bootaddr"); if (!tmp) { printf("## VxWorks bootline address not specified\n"); } else { bootaddr = simple_strtoul(tmp, NULL, 16); /* * Check to see if the bootline is defined in the 'bootargs' * parameter. If it is not defined, we may be able to * construct the info. */ bootline = getenv("bootargs"); if (bootline) { memcpy((void *)bootaddr, bootline, max(strlen(bootline), (size_t)255)); flush_cache(bootaddr, max(strlen(bootline), (size_t)255)); } else { tmp = getenv("bootdev"); if (tmp) ptr = sprintf(build_buf, tmp); else printf("## VxWorks boot device not specified\n"); tmp = getenv("bootfile"); if (tmp) ptr += sprintf(build_buf + ptr, "host:%s ", tmp); else ptr += sprintf(build_buf + ptr, "host:vxWorks "); /* * The following parameters are only needed if 'bootdev' * is an ethernet device, otherwise they are optional. */ tmp = getenv("ipaddr"); if (tmp) { ptr += sprintf(build_buf + ptr, "e=%s", tmp); tmp = getenv("netmask"); if (tmp) { u32 mask = getenv_ip("netmask").s_addr; ptr += sprintf(build_buf + ptr, ":%08x ", ntohl(mask)); } else { ptr += sprintf(build_buf + ptr, " "); } } tmp = getenv("serverip"); if (tmp) ptr += sprintf(build_buf + ptr, "h=%s ", tmp); tmp = getenv("gatewayip"); if (tmp) ptr += sprintf(build_buf + ptr, "g=%s ", tmp); tmp = getenv("hostname"); if (tmp) ptr += sprintf(build_buf + ptr, "tn=%s ", tmp); tmp = getenv("othbootargs"); if (tmp) ptr += sprintf(build_buf + ptr, tmp); memcpy((void *)bootaddr, build_buf, max(strlen(build_buf), (size_t)255)); flush_cache(bootaddr, max(strlen(build_buf), (size_t)255)); } printf("## Using bootline (@ 0x%lx): %s\n", bootaddr, (char *)bootaddr); } #ifdef CONFIG_X86 /* * Since E820 information is critical to the kernel, if we don't * specify these in the environments, use a default one. */ tmp = getenv("e820data"); if (tmp) data = (struct e820entry *)simple_strtoul(tmp, NULL, 16); else data = (struct e820entry *)VXWORKS_E820_DATA_ADDR; tmp = getenv("e820info"); if (tmp) info = (struct e820info *)simple_strtoul(tmp, NULL, 16); else info = (struct e820info *)VXWORKS_E820_INFO_ADDR; memset(info, 0, sizeof(struct e820info)); info->sign = E820_SIGNATURE; info->entries = install_e820_map(E820MAX, data); info->addr = (info->entries - 1) * sizeof(struct e820entry) + VXWORKS_E820_DATA_ADDR; #endif /* * If the data at the load address is an elf image, then * treat it like an elf image. Otherwise, assume that it is a * binary image. */ if (valid_elf_image(addr)) addr = load_elf_image_shdr(addr); else puts("## Not an ELF image, assuming binary\n"); printf("## Starting vxWorks at 0x%08lx ...\n", addr); dcache_disable(); #ifdef CONFIG_X86 /* VxWorks on x86 uses stack to pass parameters */ ((asmlinkage void (*)(int))addr)(0); #else ((void (*)(int))addr)(0); #endif puts("## vxWorks terminated\n"); return 1; }
static size_t tftp_read_file(const char *file_name) { /* update global variable load_addr before tftp file from network */ load_addr = get_load_addr(); return net_loop(TFTPGET); }
int loop (void) { on_start (); if (binlog_enabled) { replay_log (); write_binlog (); } else { read_auth_file (); } update_prompt (); assert (DC_list[dc_working_num]); if (!DC_working || !DC_working->auth_key_id) { // if (auth_state == 0) { DC_working = DC_list[dc_working_num]; assert (!DC_working->auth_key_id); dc_authorize (DC_working); assert (DC_working->auth_key_id); auth_state = 100; write_auth_file (); } if (verbosity) { logprintf ("Requesting info about DC...\n"); } do_help_get_config (); net_loop (0, mcs); if (verbosity) { logprintf ("DC_info: %d new DC got\n", new_dc_num); } int i; for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->auth_key_id) { dc_authorize (DC_list[i]); assert (DC_list[i]->auth_key_id); write_auth_file (); } if (auth_state == 100 || !(DC_working->has_auth)) { if (!default_username) { size_t size = 0; char *user = 0; if (!user) { printf ("Telephone number (with '+' sign): "); if (net_getline (&user, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } set_default_username (user); } } int res = do_auth_check_phone (default_username); assert (res >= 0); logprintf ("%s\n", res > 0 ? "phone registered" : "phone not registered"); if (res > 0) { do_send_code (default_username); char *code = 0; size_t size = 0; printf ("Code from sms: "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (do_send_code_result (code) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } auth_state = 300; } else { printf ("User is not registered. Do you want to register? [Y/n] "); char *code; size_t size; if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (!*code || *code == 'y' || *code == 'Y') { printf ("Ok, starting registartion.\n"); } else { printf ("Then try again\n"); exit (EXIT_SUCCESS); } char *first_name; printf ("Name: "); if (net_getline (&first_name, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } char *last_name; printf ("Name: "); if (net_getline (&last_name, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } int dc_num = do_get_nearest_dc (); assert (dc_num >= 0 && dc_num <= MAX_DC_NUM && DC_list[dc_num]); dc_working_num = dc_num; DC_working = DC_list[dc_working_num]; do_send_code (default_username); printf ("Code from sms: "); while (1) { if (net_getline (&code, &size) == -1) { perror ("getline()"); exit (EXIT_FAILURE); } if (do_send_code_result_auth (code, first_name, last_name) >= 0) { break; } printf ("Invalid code. Try again: "); free (code); } auth_state = 300; } } for (i = 0; i <= MAX_DC_NUM; i++) if (DC_list[i] && !DC_list[i]->has_auth) { do_export_auth (i); do_import_auth (i); DC_list[i]->has_auth = 1; if (binlog_enabled) { int *ev = alloc_log_event (8); ev[0] = LOG_DC_SIGNED; ev[1] = i; add_log_event (ev, 8); } write_auth_file (); } write_auth_file (); fflush (stdin); fflush (stdout); fflush (stderr); read_state_file (); read_secret_chat_file (); set_interface_callbacks (); do_get_difference (); net_loop (0, dgot); do_get_dialog_list (); return main_loop (); }
int main(int argc, char* argv[]) { pid_t pid; parse_args(argc, argv); if (config_init(argv[1]) == -1) { BOOT_LOG(-1, "Failed to Parse File '%s'", argv[1]); } if (config_init("common.conf") == -1) { BOOT_LOG(-1, "Failed to Parse File '%s'", argv[1]); } daemon_start(argc, argv); load_bind_file(); log_init_ex( config_get_strval("log_dir"), config_get_intval("log_level", log_lvl_trace), config_get_intval("log_size", 1<<30), config_get_intval("max_log_files", 0), config_get_strval("log_prefix") , config_get_intval("log_save_next_file_interval_min", 0) ); //Èç¹ûʹÓÃÔà´Ê¼ì²âÂß¼£¬Ôò¿ªÆô¸¸½ø³ÌµÄÔà´Ê¸üÐÂÂß¼. if (config_get_intval("tm_dirty_use_dirty_logical", 1) == 1) { if (tm_dirty_daemon( config_get_strval("tm_dirty_local_dirty_file_path"), config_get_strval("tm_dirty_server_addr"), config_get_intval("tm_dirty_update_cycle", 600), NULL) == -1) { BOOT_LOG(-1, "FAILED TO RUN TM_DIRTY_DAEMON"); } } net_init(MAXFDS, MAXFDS); bind_config_t* bc = get_bind_conf(); //-------------------------------- net_start(config_get_strval("online_ip"), config_get_intval("online_port", 443), bc->configs); //-------------------------------- // bind_config_elem_t* bc_elem; int i = 0; for ( ; i != bc->bind_num; ++i ) { bind_config_elem_t* bc_elem = &(bc->configs[i]); shmq_create(bc_elem); if ( (pid = fork ()) < 0 ) { BOOT_LOG(-1, "fork child process"); } else if (pid > 0) { //parent process close_shmq_pipe(bc, i, 0); do_add_conn(bc_elem->sendq.pipe_handles[0], PIPE_TYPE_FD, 0, bc_elem); //net_start(bc_elem->bind_ip, bc_elem->bind_port, bc_elem); } else { //child process run_worker_process(bc, i, i + 1); } } while (!stop) { net_loop(-1, PAGESIZE, 1); } net_exit(); shmq_destroy(0, bc->bind_num); daemon_stop(); return 0; }
int loop (void) { tgl_set_callback (TLS, &upd_cb); struct event_base *ev = event_base_new (); tgl_set_ev_base (TLS, ev); tgl_set_net_methods (TLS, &tgl_conn_methods); tgl_set_timer_methods (TLS, &tgl_libevent_timers); assert (TLS->timer_methods); tgl_set_download_directory (TLS, get_downloads_directory ()); tgl_register_app_id (TLS, TELEGRAM_CLI_APP_ID, TELEGRAM_CLI_APP_HASH); tgl_set_app_version (TLS, "Telegram-cli " TELEGRAM_CLI_VERSION); if (ipv6_enabled) { tgl_enable_ipv6 (TLS); } if (bot_mode) { tgl_enable_bot (TLS); } if (disable_link_preview) { tgl_disable_link_preview (TLS); } assert (tgl_init (TLS) >= 0); /*if (binlog_enabled) { double t = tglt_get_double_time (); if (verbosity >= E_DEBUG) { logprintf ("replay log start\n"); } tgl_replay_log (TLS); if (verbosity >= E_DEBUG) { logprintf ("replay log end in %lf seconds\n", tglt_get_double_time () - t); } tgl_reopen_binlog_for_writing (TLS); } else {*/ read_auth_file (); read_state_file (); read_secret_chat_file (); //} binlog_read = 1; #ifdef USE_LUA lua_binlog_end (); #endif #ifdef USE_PYTHON py_binlog_end (); #endif if (sfd >= 0) { struct event *ev = event_new (TLS->ev_base, sfd, EV_READ | EV_PERSIST, accept_incoming, 0); event_add (ev, 0); } if (usfd >= 0) { struct event *ev = event_new (TLS->ev_base, usfd, EV_READ | EV_PERSIST, accept_incoming, 0); event_add (ev, 0); } update_prompt (); if (reset_authorization) { tgl_peer_t *P = tgl_peer_get (TLS, TLS->our_id); if (P && P->user.phone && reset_authorization == 1) { set_default_username (P->user.phone); } bl_do_reset_authorization (TLS); } set_interface_callbacks (); tgl_login (TLS); net_loop (); return 0; }