bool https_client::connect_server(acl::http_client& client) { logger_debug(DEBUG, 1, "begin connect server"); if (client.open(server_addr_.c_str(), 60, 60, true) == false) { logger_error("failed to connect server %s", server_addr_.c_str()); return false; } else logger_debug(DEBUG, 1, "connect server ok"); if (ssl_conf_) { logger_debug(DEBUG, 1, "begin open ssl"); acl::polarssl_io* ssl = new acl::polarssl_io(*ssl_conf_, false); if (client.get_stream().setup_hook(ssl) == ssl) { logger_error("open ssl client error"); ssl->destroy(); return false; } else logger_debug(DEBUG, 1, "open ssl ok"); } return true; }
bool https_client::connect_server(const acl::string& server_addr, acl::http_client& client) { // 先查本地映射表中有没有映射项 master_service& ms = acl::singleton2<master_service>::get_instance(); const char* addr = ms.get_addr(server_addr.c_str()); if (addr == NULL) addr = server_addr.c_str(); if (client.open(addr, 60, 60, true) == false) { out_.format("connect server %s error", addr); return false; } else logger_debug(DEBUG, 1, "connect server ok"); if (ssl_conf_) { logger_debug(DEBUG, 1, "begin open ssl"); acl::polarssl_io* ssl = new acl::polarssl_io(*ssl_conf_, false); if (client.get_stream().setup_hook(ssl) == ssl) { out_.puts("open ssl client error"); ssl->destroy(); return false; } else logger_debug(DEBUG, 1, "open ssl ok"); } return true; }
int main(int argc, char* argv[]) { Allocator* alloc = allocator_nginx_create(1024); Config* config = config_xml_expat_create(); config_load(config, "../../../src/app/genesis-config.xml"); Reactor* reactor = reactor_create(config, alloc); SourcesManager* sources_manager = NULL; reactor_get_sources_manager(reactor, &sources_manager); MainLoop* main_loop = NULL; reactor_get_main_loop(reactor, &main_loop); Source* timer_source = source_timer_create(2000, test_timer, (void*)reactor); //sources_manager_add_source(sources_manager, timer_source); logger_debug(reactor->logger, "sources_count = %d", sources_manager_get_count(sources_manager)); main_loop_add_source(main_loop, timer_source); logger_debug(reactor->logger, "sources_count = %d", sources_manager_get_count(sources_manager)); reactor_run(reactor); reactor_destroy(reactor); config_destroy(config); allocator_destroy(alloc); return 0; }
int network_listen(struct timeval *timeout) { fd_set set; int ret; flush_list(); setfd(&set); if (timeout) logger_debug("[NETWORK] waiting for next action in %lu:%lu", timeout->tv_sec, timeout->tv_usec); else logger_debug("[NETWORK] waiting for extern action. nothing planified"); if ((ret = (select(g_network->nfds, &set, NULL, NULL, timeout))) > 0) { find_speaker(&set, g_network->read, &extract_from_socket, &execute_from_socket); find_speaker(&set, g_network->listened, &extract_from_listener, &execute_from_listener); } g_network->nfds = 0; return (ret); }
bool logger_servlet::doPost(acl::HttpServletRequest& req, acl::HttpServletResponse&) { const char* uri = req.getRequestUri(); if (uri == NULL || *uri == 0) { logger_debug(DEBUG_HTTP, 1, "getRequestUri null"); return false; } const char* host = req.getRemoteHost(); if (host == NULL || *host == 0) { logger_debug(DEBUG_HTTP, 1, "no Host"); return false; } acl::string url; url.format("http://%s/%s", host, uri); logger("%s", url.c_str()); int n; char buf[8192]; acl::http_client* conn = req.getClient(); while (true) { n = conn->read_body(buf, sizeof(buf)); if (n < 0) return false; else if (n == 0) break; } return true; }
bool ServerIOCallback::read_callback(char* data, int len) { const char* myname = "read_callback"; if (data == NULL || *data == 0 || len <= 0) { logger_warn("invalid data: %s, len: %d", data ? data : "null", len); return false; } // 处理服务端发来的命令 acl::url_coder coder; coder.decode(data); logger_debug(DEBUG_SVR, 1, "client: %s", data); const char* ptr = coder.get("count"); if (ptr == NULL) { logger_warn("%s(%d), %s: no count", __FILE__, __LINE__, myname); return true; } unsigned int nconns = (unsigned int) atoi(ptr); conn_->set_nconns(nconns); // 尝试将服务端连接对象添加进服务端管理对象中 ServerManager::get_instance().set(conn_); return true; }
/** * Format has to contain at least one %s. The first occurrence * of %s is substituted with the binary value of the register. */ void logger_log_register(char* format, volatile unsigned int * register_ptr) { char bin_reg_val [32]; unsigned int register_val = *register_ptr; int i = 0; for(i = 31; i >= 0; i--) { if(register_val & 1) { bin_reg_val[i] = '1'; } else { bin_reg_val[i] = '0'; } register_val >>= 1; } logger_debug(format, bin_reg_val); }
static Ret main_loop_select_add_source(MainLoop* thiz, Source* source) { DECLES_PRIV(priv, thiz); Event event; event_init(&event, EVT_ADD_SOURCE); event.u.extra = source; // source->active = 1; source_enable(source); logger_debug(priv->logger, "%s: add sources", __func__); return source_queue_event(sources_manager_get_primary_source(priv->sources_manager), &event); }
static int finish_elevation(t_case *c, int lvl) { t_node *node; char buffer[BUFFER_SIZE]; int ret; ret = 0; node = c->players->head; logger_debug("Fin d'incantation"); sprintf(buffer, "niveau actuel : %d\n", lvl); while (node) { ((t_player *)node->data)->level = lvl; if (write_socket(((t_player *)node->data)->client->fd, buffer) <= 0) ret = 1; node = node->next; } return (ret); }
static gboolean _exclude_memory_from_core_dump(gpointer area, gsize len) { #if defined(MADV_DONTDUMP) if (madvise(area, len, MADV_DONTDUMP) < 0) { if (errno == EINVAL) { logger_debug("secret storage: MADV_DONTDUMP not supported", "len: %"G_GSIZE_FORMAT", errno: %d\n", len, errno); return TRUE; } logger_fatal("secret storage: cannot madvise buffer", "errno: %d\n", errno); return FALSE; } #endif return TRUE; }
void player_drop_end_cb(t_client *client, int error) { int *ressources; int *inventory; t_tile *tile; logger_debug("[GAME] "); if (!error) { tile = client->player->tile; ressources = (int *)&tile->ressources; inventory = (int *)&client->player->inventory; if (inventory[item] > 0) { inventory[item] -= 1; ressources[item] += 1; client_send(client, REP_OK); } else client_send(client, REP_KO); } else client_send(client, REP_KO); }
int8_t ipc_handle_syscall(ProcessId_t o, uint8_t call_type, message_t* msg) { Process_t* src = process_manager_current_process; Process_t* dst = NULL; if (src->pid == o) { return IPC_DEADLOCK; } if (call_type == IPC_RECEIVE_ASYNC && src->ipc.sender.head == NULL) { return IPC_NOTHING_RECEIVED; } if (o == PROCESS_STDIN) { o = src->stdin; } else if (o == PROCESS_STDOUT) { o = src->stdout; } if (o == PROCESS_INVALID_ID) { return IPC_OTHER_NOT_FOUND; } else if ((call_type & IPC_RECEIVE) != IPC_RECEIVE || o != PROCESS_ANY) { /* allow ANY only on receive */ dst = process_manager_get_process_byid(o); if (dst == NULL) { return IPC_OTHER_NOT_FOUND; } } src->ipc.other = o; src->ipc.msg = mmu_get_physical_address(src->page_table, msg); switch (call_type) { case IPC_SEND: case IPC_SENDREC: /* SEND is falling through here */ _disable_interrupts(); if (dst->state == PROCESS_ZOMBIE) { _enable_interrupts(); return IPC_DEAD; } if (dst->state == PROCESS_BLOCKED && dst->ipc.call_type == IPC_RECEIVE && (dst->ipc.other == src->pid || dst->ipc.other == PROCESS_ANY)) { logger_debug("IPC: SEND-copying src=%i:%s dst=%i:%s", src->pid, src->name, o, (dst != NULL) ? dst->name : "<ANY>"); if (dst->ipc.other == PROCESS_ANY) { dst->ipc.other = src->pid; } _enable_interrupts(); /* both process are now BLOCKED */ copy_msg(src, dst); dst->ipc.call_type = IPC_NOOP; process_manager_set_process_ready(dst); } else { logger_debug("IPC: SEND-blocked src=%i:%s dst=%i:%s", src->pid, src->name, o, (dst != NULL) ? dst->name : "<ANY>"); if (dst->ipc.other == src->pid && dst->ipc.call_type & IPC_SEND) { return IPC_DEADLOCK; } src->ipc.call_type = IPC_SEND; /* place msg for later delivery into the IPC queue of the destination */ linked_list_add(&dst->ipc.sender, src); /* TODO: check for too less memory */ /* pause process */ process_manager_block_current_process(); process_manager_run_process(dst); _enable_interrupts(); } /* msg delivered, falling through receive except for send only */ if (call_type == IPC_SEND) { break; } case IPC_RECEIVE: /* SENDREC and SEND are falling through here */ case IPC_RECEIVE_ASYNC: _disable_interrupts(); if (dst != NULL) { if (dst->state == PROCESS_ZOMBIE) { _enable_interrupts(); return IPC_DEAD; } } else { /* receiving from ANY, maybe someone is already sending to this process */ linked_list_node_t* node; do { node = linked_list_pop_head(&src->ipc.sender); if (node != NULL) { dst = node->value; free(node); } } while (dst != NULL && dst->state == PROCESS_ZOMBIE); } if (dst != NULL && dst->state == PROCESS_BLOCKED && (dst->ipc.call_type & IPC_SEND) == IPC_SEND && dst->ipc.other == src->pid) { logger_debug("IPC: RECIEVED-copying src=%i:%s dst=%i:%s", src->pid, src->name, o, (dst != NULL) ? dst->name : "<ANY>"); /* both process are now BLOCKED */ _enable_interrupts(); /* remove sender out of sender list */ if (o != PROCESS_ANY) { linked_list_node_t* node = src->ipc.sender.head; while (node != NULL) { Process_t* p = node->value; if (p->pid == o) { linked_list_remove(&src->ipc.sender, node); break; } node = node->next; } } copy_msg(dst, src); dst->ipc.call_type = IPC_NOOP; process_manager_set_process_ready(dst); } else { if (dst != NULL && dst->ipc.other == src->pid && dst->ipc.call_type == IPC_RECEIVE) { return IPC_DEADLOCK; } src->ipc.call_type = IPC_RECEIVE; /* wait for msg delivery */ process_manager_block_current_process(); process_manager_run_process(dst); if (dst->state == PROCESS_ZOMBIE) { _enable_interrupts(); return IPC_DEAD; } logger_debug("IPC: RECIEVED-blocked src=%i:%s dst=%i:%s", src->pid, src->name, o, (dst != NULL) ? dst->name : "<ANY>"); _enable_interrupts(); /* msg received */ } break; } return IPC_OK; }
void main(void) { /* logger_init() */ /*uart_get(3, &uart3); uart_protocol_format_t protocol; protocol.baudrate = 0x001A; //115.2Kbps 138; //9.6 Kbps protocol.stopbit = 0x0; //1 stop bit protocol.datalen = 0x3; //length 8 protocol.use_parity = 0x0; uart_init(&uart3, 0x00, protocol); //irq_add_handler(UART3_INTCPS_MAPPING_ID, &uart3_irq_handler); logger_debug("\r\n\r\nSystem initialize ..."); logger_logmode();*/ ram_manager_init(); mmu_table_t* page_table = mmu_init(); /* init led stuff */ turnoff_rgb(); process_manager_init(page_table); binaries[0] = osx_init(&BINARY_driver_manager, &mem_elf_read); driver_manager = process_manager_start_process_bybinary(binaries[0], PROCESS_PRIORITY_HIGH, PROCESS_DRIVER_MANAGER_NAME); /* add drivers to the driver manager */ binaries[1] = osx_init(&BINARY_gpio, &mem_elf_read); // add_driver(binaries[1], "GPIO", GPIO5); /* add drivers to the driver manager */ binaries[4] = osx_init(&BINARY_uart, &mem_elf_read); // add_driver(binaries[4], "UART 21", UART1); add_driver(binaries[4], "UART 22", UART2); // add_driver(binaries[4], "UART 23", UART3); binaries[2] = osx_init(&BINARY_led0_user, &mem_elf_read); //process_manager_start_process_bybinary(binaries[2], PROCESS_PRIORITY_HIGH, "LED(fast) 21 100 100"); //process_manager_start_process_bybinary(binaries[2], PROCESS_PRIORITY_HIGH, "LED(slow) 22 1000"); dmx_uart_set_send_mode(); //TODO: remove //binaries[3] = osx_init(&BINARY_uart2_user, &mem_elf_read); //process_manager_start_process_bybinary(binaries[3], PROCESS_PRIORITY_HIGH, "UART2_user_proc"); //binaries[3] = osx_init(&BINARY_dmx, &mem_elf_read); // TODO: add_driver(binaries[3], "DMX", DMX); //process_manager_start_process_bybinary(binaries[3], PROCESS_PRIORITY_HIGH, "DMX"); binaries[3] = osx_init(&BINARY_tty, &mem_elf_read); process_manager_start_process_bybinary(binaries[3], PROCESS_PRIORITY_HIGH, "tty 23"); binaries[5] = osx_init(&BINARY_cpu_info, &mem_elf_read); process_manager_start_process_bybinary(binaries[5], PROCESS_PRIORITY_HIGH, "CPU_INFO"); binaries[6] = osx_init(&BINARY_dmx, &mem_elf_read); add_driver(binaries[6], "DMX 5", DMX); // binaries[7] = osx_init(&BINARY_dmx_user, &mem_elf_read); // process_manager_start_process_bybinary(binaries[7], PROCESS_PRIORITY_HIGH, "DMX_User_app 5"); binaries[8] = osx_init(&BINARY_dmx_control, &mem_elf_read); process_manager_start_process_bybinary(binaries[8], PROCESS_PRIORITY_HIGH, "DMX_Control 5"); logger_debug("System started ..."); system_main_loop(); }
static Ret main_loop_select_run(MainLoop* thiz) { DECLES_PRIV(priv, thiz); int i = 0; int n = 0; int fd = -1; int mfd = -1; int wait_time = 3600 * 3000; // int wait_time = 1000; int source_wait_time = 0; int ret = 0; struct timeval tv = {0}; Source* source = NULL; int count = 0; priv->running = 1; while(priv->running) { FD_ZERO(&(priv->fdset)); FD_ZERO(&(priv->err_fdset)); count = sources_manager_get_count(priv->sources_manager); logger_debug(priv->logger, "%s: sources count = %d", __func__, count); for (i = 0; i < count; i++) { source = NULL; sources_manager_get(priv->sources_manager, i, &source); if ((fd = source_get_fd(source)) >= 0) { FD_SET(fd, &(priv->fdset)); FD_SET(fd, &(priv->err_fdset)); if (fd > mfd) mfd = fd; ++n; } source_wait_time = source_check(source); logger_debug(priv->logger, "%s: source_wait_time = %d", __func__, source_wait_time); if (source_wait_time >= 0 && source_wait_time < wait_time) { wait_time = source_wait_time; } // process signal sources here; // TODO add time interval into source_signal if (source_get_type(source) == SOURCE_SIGNAL && source->active == 1) { source_dispatch(source); source->active = 0; } } logger_debug(priv->logger, "%s: wait_time = %d", __func__, wait_time); tv.tv_sec = wait_time / 1000; tv.tv_usec = (wait_time % 1000)*1000; ret = select(mfd + 1, &(priv->fdset), NULL, &(priv->err_fdset), &tv); for (i = 0; i < sources_manager_get_count(priv->sources_manager); ) { if (sources_manager_need_refresh(priv->sources_manager)) { break; } sources_manager_get(priv->sources_manager, i, &source); if (source->disable > 0) { sources_manager_del_source(priv->sources_manager, source); continue; } if ((fd = source_get_fd(source)) >= 0 && ret != 0) { if (ret > 0 && FD_ISSET(fd, &(priv->fdset))) { if (source_dispatch(source) != RET_OK) { sources_manager_del_source(priv->sources_manager, source); } else { ++i; } continue; } } else if (FD_ISSET(fd, &(priv->fdset))) { sources_manager_del_source(priv->sources_manager, source); continue; } if ((source_wait_time = source_check(source)) == 0) { if (source_dispatch(source) != RET_OK) { sources_manager_del_source(priv->sources_manager, source); } else { ++i; } continue; } ++i; } } return RET_OK; }
void uart3_irq_handler(void) { char received_char = *((char*) 0x49020000); logger_debug("UART3 - Received a character: %c", received_char); }
void logger_logmode(void) { logger_debug("System currently in %s mode", logger_getmode(_get_CPSR())); }
void ebmq_debug (char *message) { logger_debug(message); }