static void task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct sockaddr_in v4; ls = open_listen_socket (); lsock = GNUNET_CONNECTION_create_from_existing (ls); GNUNET_assert (lsock != NULL); #if HAVE_SOCKADDR_IN_SIN_LEN v4.sin_len = sizeof (v4); #endif v4.sin_family = AF_INET; v4.sin_port = htons (PORT); v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK); csock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, (const struct sockaddr *) &v4, sizeof (v4)); GNUNET_assert (csock != NULL); GNUNET_assert (NULL != GNUNET_CONNECTION_notify_transmit_ready (csock, 12, GNUNET_TIME_UNIT_SECONDS, &make_hello, NULL)); GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls, &run_accept, cls); }
static void task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { ls = open_listen_socket (); lsock = GNUNET_CONNECTION_create_from_existing (ls); GNUNET_assert (lsock != NULL); csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT); GNUNET_assert (csock != NULL); GNUNET_assert (NULL != GNUNET_CONNECTION_notify_transmit_ready (csock, 1024, GNUNET_TIME_UNIT_SECONDS, &send_kilo, cls)); }
static void task (void *cls) { ls = open_listen_socket (); lsock = GNUNET_CONNECTION_create_from_existing (ls); GNUNET_assert (lsock != NULL); csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT); GNUNET_assert (csock != NULL); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n"); GNUNET_assert (NULL != GNUNET_CONNECTION_notify_transmit_ready (csock, 12, GNUNET_TIME_UNIT_SECONDS, &make_hello, NULL)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n"); GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, ls, &run_accept, cls); }
int epoll_loop() { #define MAX_EVENTS 10 int epollfd, nfds, n, listen_sock, conn_sock; struct epoll_event ev, events[MAX_EVENTS]; epollfd = epoll_create1(EPOLL_CLOEXEC); if (epollfd == -1) { return -1; } listen_sock = open_listen_socket(); ev.events = EPOLLIN; ev.data.fd = listen_sock; if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) { perror("epoll_ctl: listen_sock"); //exit(EXIT_FAILURE); } for (;;) { nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1); if (nfds == -1) { } for (n = 0; n < nfds; ++n) { if (events[n].data.fd == listen_sock) { conn_sock = accept_connect(listen_sock); if (setnonblocking(conn_sock) < 0) { perror("setnonblocking"); } ev.events = EPOLLIN | EPOLLET; ev.data.fd = conn_sock; if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) { } } else { int fd = events[n].data.fd; char buf[255]; int len = recv(fd, buf, 255, MSG_DONTWAIT); buf[len] = '\0'; printf("%s\n", buf); } } } return 0; }
int main(int argc, char *argv[]) { int res = 0; /* Parse command line parameters */ if (0 != (res = parse_peer_params(argc, argv, &proc_id, &fname))) { dbg_err("parse_args() returned nonzero status:%d", res); goto end; } /* * Parse the DME simulation config file. */ if (0 != (res = parse_file(fname, proc_id, &nodes, &nodes_count))) { dbg_err("parse_file() returned nonzero status:%d", res); goto end; } /* Initialize and allocate any structures/vars used by the generic algorithm */ /* struct genericstruct = calloc(...) */ /* * Init connections (open listening socket) */ if (0 != (res = open_listen_socket(proc_id, nodes, nodes_count))) { dbg_err("open_listen_socket() returned nonzero status:%d", res); goto end; } /* * Register signals (for I/O, alarms, etc.) */ if (0 != (res = init_handlers(nodes[proc_id].sock_fd))) { dbg_err("init_handlers() returned nonzero status"); goto end; } /* Register event handlers that will be called automatically on event occurrence */ register_event_handler(DME_EV_SUP_MSG_IN, handle_supervisor_msg); register_event_handler(DME_EV_PEER_MSG_IN, handle_peer_msg); register_event_handler(DME_EV_WANT_CRITICAL_REG, process_ev_want_cr); register_event_handler(DME_EV_ENTERED_CRITICAL_REG, process_ev_entered_cr); register_event_handler(DME_EV_EXITED_CRITICAL_REG, process_ev_exited_cr); /* * Main loop: just sit here and wait for events (triggered by the supervisor). * All work is done in interrupt handlers mapped to registered functions. */ wait_events(); end: /* * Do cleanup (deallocating dynamic structures) */ deinit_handlers(); /* Close our listening socket */ if (nodes && nodes[proc_id].sock_fd > 0) { close(nodes[proc_id].sock_fd); } /* Free allocated structures */ safe_free(nodes); return res; }
static int32 main_loop() { int32 rc = 0; int32 conn_fd = -1; int32 listen_fd = -1; fd_set rfds; socklen_t addrlen = 0; usockaddr usa; pthread_t tid_ipmi_cb; struct sigaction sa; struct http_request *request = NULL; int32 port = 0; /* ingore sigpipe */ sa.sa_handler = SIG_IGN; sa.sa_flags = 0; sigemptyset(&sa.sa_mask); sigaction(SIGPIPE, &sa, 0); rest_register_handlers(); port = rmm_cfg_get_port(RESTD_PORT); listen_fd = open_listen_socket(port); if (listen_fd == -1) { HTTPD_ERR("Failed to open HTTP server!\n"); return -1; } fprintf(stderr, "Mini-HTTP Server is Running ...\n"); /* Create IPMI callback thread. */ if (pthread_create(&tid_ipmi_cb, NULL, ipmi_cb_thread, NULL) != 0) { close(listen_fd); HTTPD_ERR("Failed to create ipmi callback thread!\n"); return -1; } for (;;) { FD_ZERO(&rfds); FD_SET(listen_fd, &rfds); rc = select(listen_fd + 1, &rfds, NULL, NULL, NULL); if (rc <= 0) continue; addrlen = sizeof(usa); conn_fd = accept(listen_fd, &usa.sa, &addrlen); if (conn_fd < 0) continue; HTTPD_INFO("restd accepted a new connection: fd = %d\n", conn_fd); request = malloc(sizeof(struct http_request)); if (NULL == request) { HTTPD_ERR("Malloc error: %s\n", strerror(errno)); return -1; } memset(request, 0, sizeof(struct http_request)); request->fd = conn_fd; request->from = usa; if (pthread_create(&request->tid_rest_req, NULL, http_process, (void *)request) != 0) { HTTPD_ERR("Failed to create rest_req_thread!\n"); return -1; } } return 0; }
int main(int argc, char **argv) { int listen_sd; int sd; int c; pthread_t thread_id; cfg.listen_host = "127.0.0.1"; cfg.listen_port = 8443; cfg.ca_cert_file = DEFAULT_CA_CERT_FILE; cfg.ca_key_file = DEFAULT_CA_KEY_FILE; cfg.cert_cache_path = DEFAULT_CERT_CACHE_PATH; cfg.client_priority = DEFAULT_CLIENT_PRIORITY; cfg.accounts_inline = NULL; int detect_only = 0; char *detect_host = NULL; while ((c = getopt(argc, argv, "a:C:D:K:m:l:p:h")) != -1) { switch (c) { case 'a': cfg.accounts_inline = optarg; break; case 'l': cfg.listen_host = optarg; break; case 'p': cfg.listen_port = atoi(optarg); break; case 'C': cfg.ca_cert_file = optarg; break; case 'K': cfg.ca_key_file = optarg; break; case 'm': cfg.cert_cache_path = optarg; break; case 'D': detect_only = 1; detect_host = optarg; break; case '?': if (isprint(optopt)) fprintf(stderr, "Unknown option `-%c'.\n", optopt); else fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt); case 'h': default: print_usage(argv[0]); return 1; } } init_gnutls(&cfg); load_ca_cert_and_key(&global_ca, cfg.ca_cert_file, cfg.ca_key_file); srand(time(NULL)); if (detect_only) { fprintf(stderr, "Detecting whether %s:443 supports TLS-SRP...\n", detect_host); return site_uses_tls_srp(detect_host, 443) != 1; /* returncode 0 is success */ } listen_sd = open_listen_socket(cfg.listen_host, cfg.listen_port); if (listen_sd == -1) exit(1); for (;;) { sd = do_accept(listen_sd); pthread_create(&thread_id, NULL, connection_thread, (void*)(long)sd); } close(listen_sd); global_deinit(); return 0; }
int main(int argc, char *argv[]) { int res = 0; if (0 != (res = parse_sup_params(argc, argv, &fname, &logfname, &concurency_ratio, &max_concurrent_proc, &election_interval, &number_of_runs))) { dbg_err("parse_args() returned nonzero status:%d", res); goto end; } /* * Parse the file fname */ if (0 != (res = parse_file(fname, proc_id, &nodes, &nodes_count))) { dbg_err("parse_file() returned nonzero status:%d", res); goto end; } dbg_msg("nodes has %d elements", nodes_count); /* compute the number of maximum concurrent processes (nearest integer) */ if (max_concurrent_proc != 0) { /* The '-c' option was specified on the command line */ fixed_concurent_num = TRUE; } else { /* Compute based on concurrency ratio */ max_concurrent_proc = (nodes_count * concurency_ratio + 50) / 100; fixed_concurent_num = FALSE; } if (max_concurrent_proc < 2) { dbg_err("concurrency ratio or number set too low. At least 2 processes must be concurrent."); goto end; } else if (max_concurrent_proc > nodes_count) { dbg_err("concurrency number is greater than total number of processes. Setting it to maximum."); max_concurrent_proc = nodes_count; } dbg_msg("max_concurrent_proc=%d", max_concurrent_proc); randomizer_init(); /* Allocate the statistics collection storage and open the log file */ synchro_delays = calloc(nodes_count, sizeof(timespec_t)); response_times = calloc(nodes_count, sizeof(timespec_t)); if (NULL == (log_fh = fopen(logfname, "w"))) { dbg_err("Could not open log file %s for writing", logfname); res = ERR_BADFILE; goto end; } /* * Init connections (open listening socket) */ if (0 != (res = open_listen_socket(proc_id, nodes, nodes_count))) { dbg_err("open_listen_socket() returned nonzero status:%d", res); goto end; } /* * Register signals (for I/O, alarms, etc.) */ if (0 != (res = init_handlers(nodes[proc_id].sock_fd))) { dbg_err("init_handlers() returned nonzero status"); goto end; } register_event_handler(DME_SEV_PERIODIC_WORK, do_work); register_event_handler(DME_SEV_SYNCRO, syncro); register_event_handler(DME_SEV_ENDSIMULATION, end_simulation); register_event_handler(DME_SEV_MSG_IN, process_messages); /* wait for peers processes to init, then kick start the supervisor */ sleep(1); /* Start working; mark time */ clock_gettime(CLOCK_REALTIME, &tstamp_supervisor_start); handle_event(DME_SEV_SYNCRO, &tstamp_supervisor_start); sleep(1); handle_event(DME_SEV_PERIODIC_WORK, NULL); /* * Main loop: just sit here and wait for interrupts. * All work is done in interrupt handlers mapped to registered functions. */ wait_events(); end: /* * Do cleanup (deallocating dynamic structures) */ deinit_handlers(); /* Close our listening socket */ if (nodes && nodes[proc_id].sock_fd > 0) { close(nodes[proc_id].sock_fd); } if (log_fh) { fclose(log_fh); } safe_free(nodes); safe_free(synchro_delays); safe_free(response_times); return res; }