// Status check function void check_timerfunc(void *arg) { struct ip_info ipConfig; wifi_get_ip_info(STATION_IF, &ipConfig); if (ipConfig.ip.addr != 0) { connection_status = CONNECTION_CONNECTED; //ets_uart_printf("[check_timerfunc] Connected? "); ets_uart_printf("C %d.%d.%d.%d\r\n", IP2STR(&ipConfig.ip)); //ets_uart_printf("C"); if (mode == MODE_AP) { // Just Station and no AP setup_stationmode(); // Turn off HTTP server stop_server(); } } else if (connection_status == CONNECTION_CONNECTING) { ets_uart_printf("X"); //print("[check_timerfunc] No IP"); } else { ets_uart_printf("U"); if (mode != MODE_AP) { // Setup AP and Server setup_ap(); setup_server(); } } }
// Currently this main will setup the socket and accept a single client. // After handling the client, it will exit. // You will need to extend this to handle multiple concurrent clients // and remain running until it receives a shut-down command. int main() { int server_socket = setup_server(); if (server_socket < 0) { exit(1); } status s = grab_persisted_data(); if (s.code != OK) { log_err(s.error_message); return 0; } // Populate the global dsl commands and catalogs dsl_commands = dsl_commands_init(); catalogs = init_catalogs(); log_info("Waiting for a connection %d ...\n", server_socket); struct sockaddr_un remote; socklen_t t = sizeof(remote); int client_socket = 0; if ((client_socket = accept(server_socket, (struct sockaddr *)&remote, &t)) == -1) { log_err("L%d: Failed to accept a new connection.\n", __LINE__); exit(1); } handle_client(client_socket); return 0; }
int setup_serial_io(ClientOrServer cs, unsigned port) { if (cs == CLIENT) { return setup_client(port); } else if (cs == SERVER) { return setup_server(port); } else return 0; }
int main(int argc, char **argv) { int connfd = -1, listenfd = -1; unsigned int len = 0; char buff = malloc(sizeof(char) * BUFFER_SIZE + 1); memset(buff, 0x0, BUFFER_SIZE+1); listenfd = setup_server(PORT); while( 1 ) { printf("socket in place awaiting connection...\n"); if( (connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0) { perror("Error accepting client connection.\n"); return TCP_SOCKET_ERROR; } len = read(connfd, buff, BUFFER_SIZE); if(len < strlen(PASSWORD) || (strncmp(buff, PASSWORD, strlen(PASSWORD)) == 0)) { write(listenfd, INCORRECT_MSG, strlen(INCORRECT_MSG)); } else { write(listenfd, CORRECT_MSG, strlen(CORRECT_MSG)); } close(connfd); } return 0; }
/* * kern_return_t * bootstrap_create_server(mach_port_t bootstrap_port, * cmd_t server_cmd, * integer_t server_uid, * boolean_t on_demand, * mach_port_t *server_portp) * * Returns send rights to server_port of service. At this point, the * server appears active, so nothing will try to launch it. The server_port * can be used to delare services associated with this server by calling * bootstrap_create_service() and passing server_port as the bootstrap port. * * Errors: Returns appropriate kernel errors on rpc failure. * Returns BOOTSTRAP_NOT_PRIVILEGED, if bootstrap port invalid. */ kern_return_t x_bootstrap_create_server( mach_port_t bootstrap_port, cmd_t server_cmd, int server_uid, boolean_t on_demand, audit_token_t client_audit_token, mach_port_t *server_portp) { server_t *serverp; struct auditinfo audit_info; bootstrap_info_t *bootstrap; uid_t client_euid; bootstrap = lookup_bootstrap_by_port(bootstrap_port); debug("Server create attempt: \"%s\" bootstrap %x", server_cmd, bootstrap_port); /* No forwarding allowed for this call - security risk (we run as root) */ if (!bootstrap || !active_bootstrap(bootstrap)) { debug("Server create: \"%s\": invalid bootstrap %x", server_cmd, bootstrap_port); return BOOTSTRAP_NOT_PRIVILEGED; } /* get the identity of the requestor and set up audit_info of server */ audit_token_to_au32(client_audit_token, &audit_info.ai_auid, &client_euid, NULL /* egid */, NULL /* ruid */, NULL /* rgid */, NULL /* pid */, &audit_info.ai_asid, &audit_info.ai_termid); if (client_euid != 0 && client_euid != server_uid) { notice("Server create: \"%s\": insufficient privilege for specified uid (euid-%d != requested-%d)", server_cmd, client_euid, server_uid); return BOOTSTRAP_NOT_PRIVILEGED; } serverp = new_server( bootstrap, server_cmd, server_uid, (on_demand) ? DEMAND : RESTARTABLE, audit_info); setup_server(serverp); info("New server %x in bootstrap %x: \"%s\"", serverp->port, bootstrap_port, server_cmd); *server_portp = serverp->port; return BOOTSTRAP_SUCCESS; }
void setup() { rfm70.begin(); rfm70.onReceive(receiveEvent); rfm70.confIRQ(6, 0, 1, 0); rfm70.Register_IRQ(irq_func); setup_server(); // setup_client(); // users[0] = myclient; users[0] = act1; rfthrd = new rfthread(users, 1); rfthrd->init_ok(); }
void wifi_event ( System_Event_t *e ) { int event = e->event; if ( event == EVENT_STAMODE_GOT_IP ) { os_printf ( "WIFI Event, got IP\n" ); show_ip (); setup_server (); } else if ( event == EVENT_STAMODE_CONNECTED ) { os_printf ( "WIFI Event, connected\n" ); } else if ( event == EVENT_STAMODE_DISCONNECTED ) { os_printf ( "WIFI Event, disconnected\n" ); } else { os_printf ( "Unknown event %d !\n", event ); } }
int server_create(prelude_client_profile_t *cp, const char *addr, unsigned int port, prelude_bool_t keepalive, const char *pass, gnutls_x509_privkey_t key, gnutls_x509_crt_t cacrt, gnutls_x509_crt_t crt) { int sock; size_t size; struct pollfd pfd[128]; gnutls_dh_params_t dh_params; #ifdef GNUTLS_SRP_ENABLED int ret; ret = gnutls_srp_allocate_server_credentials(&srpcred); if ( ret < 0 ) { fprintf(stderr, "error creating SRP credentials: %s.\n", gnutls_strerror(ret)); return -1; } gnutls_srp_set_server_credentials_function(srpcred, srp_callback); #endif one_shot_passwd = pass; gnutls_anon_allocate_server_credentials(&anoncred); fprintf(stderr, "Generating %d bits Diffie-Hellman key for anonymous authentication...", ANON_DH_BITS); gnutls_dh_params_init(&dh_params); gnutls_dh_params_generate2(dh_params, ANON_DH_BITS); gnutls_anon_set_server_dh_params(anoncred, dh_params); fprintf(stderr, "\n"); size = sizeof(pfd) / sizeof(*pfd); sock = setup_server(addr, port, pfd, &size); if ( sock < 0 ) return -1; wait_connection(cp, sock, pfd, size, keepalive, key, cacrt, crt); #ifdef GNUTLS_SRP_ENABLED gnutls_srp_free_server_credentials(srpcred); #endif gnutls_anon_free_server_credentials(anoncred); return 0; }
int main(int argc, char **argv) { GOptionContext *context; GError *error = NULL; guint signal_watch; guint server_watch; context = g_option_context_new(NULL); g_option_context_add_main_entries(context, options, NULL); if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) { if (error != NULL) { g_printerr("%s\n", error->message); g_error_free(error); } else g_printerr("An unknown error occurred\n"); return EXIT_FAILURE; } g_option_context_free(context); if (option_device == NULL) { if (option_ifx == TRUE) { option_device = g_strdup("/dev/ttyIFX0"); } else { g_printerr("No valid device specified\n"); return EXIT_FAILURE; } } main_loop = g_main_loop_new(NULL, FALSE); signal_watch = setup_signalfd(); server_watch = setup_server(); g_main_loop_run(main_loop); g_source_remove(server_watch); g_source_remove(signal_watch); g_main_loop_unref(main_loop); g_free(option_device); return EXIT_SUCCESS; }
int main(int argc, char** argv) { signal(SIGINT,signal_handler);//TODO: OBSOLETE, use sigaction signal(SIGTERM,signal_handler); openlog("smlaunch",LOG_CONS|LOG_PID,LOG_USER); setlogmask(LOG_DEBUG); sm_log(LOG_INFO,"starting %s server\n",argv[0]); player_init(); //TODO: make this an option of some kind //actually...not setting this will be an option //daemon(0,0); setup_server(); start_listening(); exit_program(EXIT_SUCCESS);//most likely will never be reached return (0); }
int main(int argc , char *argv[]) { int socket_desc , client_sock , c; struct sockaddr_in server , client; //Create socket socket_desc = create_socket(); //Prepare the sockaddr_in structure setup_server(&server); bind_server_to_socket(socket_desc, &server); //Listen listen(socket_desc , LISTEN_QUEUE_SIZE); //Accept and incoming connection c = sizeof(struct sockaddr_in); threadpool_t *pool = create_threadpool(); while((client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c))) { if( threadpool_add(pool, connection_handler, (void*) &client_sock, 0)) { perror("could not create thread"); return 1; } //Now join the thread , so that we dont terminate before the threa } if (client_sock < 0) { perror("accept failed"); return 1; } return 0; }
int main() { const int port = 8000; http_server svc; //bring up tls machine, this need to be done before server setup int ng = tls_engine_inhale("server-cert.pem", "server-key.pem", 0); assert(ng == 0); setup_server(&svc, "0.0.0.0", port); //the length of path passed explicitly to stop strlen calling router *rtr = get_router(&svc); addroute(rtr, "/redfish", 8, write_res); printf("Listening on %d\n", port); //run forever run(&svc); tls_engine_stop(); return 0; }
int setupListenServer(struct addrinfo **pAddrInfo, int pPort) { char tService[SERVLEN]; sprintf(tService, "%d", pPort); // copies port to string int tFamily = AF_INET; //#ifdef AF_INET6 //printf("Listening on IPv6 Socket\n"); //tFamily = AF_INET6; //#else //printf("Listening on IPv4 Socket"); //#endif if(getAddr(NULL, tService, tFamily, SOCK_STREAM, pAddrInfo)) { return ERROR; // getAddr prints out error message } int tSocketDescriptor = setup_server(*pAddrInfo); char tAddr[INET6_ADDRSTRLEN]; socklen_t tSize = INET6_ADDRSTRLEN; inet_ntop((*pAddrInfo)->ai_family, (*pAddrInfo)->ai_addr, tAddr, tSize); //printf("Size is: %d\n", tSize); return tSocketDescriptor; }
int main(int argc, char **argv) { int rv; /* Set program name globally */ program_invocation_name = argv[0]; program_invocation_short_name = basename(argv[0]); /* Log to stderr until (and if) we daemonize */ fsa_log_to = ADM_LOG_TO_STDERR; fsa_log_level = ADM_LOG_LEVEL; /* parse command line args/opts into globals */ rv = parse_cmdline_opts(argc, argv); if (rv == -1) { return EXIT_FAILURE; } /* check if debugging output turned on */ if (debug_flag) { fsa_log_level = LOG_DEBUG; } /* handle simple commands (help/version) */ if (help_flag) { print_help(); return EXIT_SUCCESS; } if (version_flag) { print_version(); return EXIT_SUCCESS; } /* make sure a valid port number is set/specified */ rv = init_server_port(); if (rv == -1) { return EXIT_FAILURE; } /* check that bin dir exists and is readable */ rv = check_bin_dir(); if (rv == -1) { return EXIT_FAILURE; } /* daemonize if needed */ if (daemonize_flag) { daemonize(); } /* set up server listening socket */ rv = setup_server(); if (rv == -1) { return EXIT_FAILURE; } if (daemonize_flag) { /* make info message a bit clearer in syslog */ fsa_error(LOG_INFO, "%s started on port %s", program_invocation_short_name, server_port); } else { fsa_error(LOG_INFO, "started on port %s", server_port); } /* handle client connections and requests */ rv = server_loop(); if (rv == -1) { return EXIT_FAILURE; } return EXIT_SUCCESS; }
/** * @param argc: Number of command line arguments supplied. * @param argv: Char* array containing the command line arguments supplied. * @return: To the system, normally 0. * @brief: The first function once enotes is called. */ int main(int argc, char *argv[]) { int note_count; /* IPC Check */ ecore_ipc_init(); dml("IPC Initiated Successfully", 1); /* loading will increment this if there are notes if not we may need to * create a blank one */ note_count = 0; if ((ecore_config_init("enotes")) == ECORE_CONFIG_ERR_FAIL) { ecore_ipc_shutdown(); return (-1); } ecore_app_args_set(argc, (const char **) argv); ecore_config_app_describe("E-Notes - Sticky Notes for Enlightenment\n\ Copyright (c) Thomas Fletcher\n\ Usage: enotes [options]"); /* Read the Usage and Configurations */ main_config = mainconfig_new(); if (read_configuration(main_config) != ECORE_CONFIG_PARSE_CONTINUE) { ecore_config_shutdown(); ecore_ipc_shutdown(); ecore_shutdown(); mainconfig_free(main_config); return (-1); } dml("Successfully Read Configurations and Usage", 1); process_note_storage_locations(); if (find_server() != 0) { if (remotecmd != NULL) send_to_server(remotecmd); else send_to_server("DEFNOTE"); } else { dml("Server wasn't found.. Creating one", 1); /* Setup Server */ setup_server(); /* Initialise the E-Libs */ ecore_init(); ecore_x_init(NULL); ecore_app_args_set(argc, (const char **) argv); if (!ecore_evas_init()) { mainconfig_free(main_config); return -1; } ewl_init(&argc, argv); edje_init(); dml("Efl Successfully Initiated", 1); autoload(); /* create autosave timer */ update_autosave(); if (remotecmd != NULL) handle_ipc_message(remotecmd); /* Begin the Control Centre */ if (main_config->controlcentre == 1) { setup_cc(); dml("Control Centre Setup", 1); } else { dml("No Control Centre - Displaying Notice", 1); if (get_note_count() == 0) new_note(); } if (main_config->welcome == 1) { open_welcome(); } /* Begin the main loop */ dml("Starting Main Loop", 1); ecore_main_loop_begin(); dml("Main Loop Ended", 1); /* Save Controlcentre Settings */ set_cc_pos(); autosave(); if (autosave_timer) ecore_timer_del(autosave_timer); /* Save and Free the Configuration */ ecore_config_save(); dml("Configuration Saved", 1); mainconfig_free(main_config); dml("Configuration Structure Free'd", 1); /* Shutdown the E-Libs */ edje_shutdown(); ecore_evas_shutdown(); ecore_x_shutdown(); ecore_shutdown(); dml("Efl Shutdown", 1); } /* End IPC */ ecore_ipc_shutdown(); dml("IPC Shutdown", 1); dml("Leaving.", 1); return (0); }
int main() { int socket_id, client, e; struct sigaction action = { .sa_handler = sighandler, .sa_flags = 0 }; sigemptyset(&action.sa_mask); sigaction(SIGINT, &action, NULL); socket_id = setup_server(PORT); if (socket_id < 0) { perror("Error setting up server"); exit(-1); } printf("<server> listening on %d\n", PORT); client = accept(socket_id, NULL, NULL); // blocks here on connection printf("<server> connected: %d\n", client); while (running) { e = handle_request(client); if (e < 0) { running = 0; } } close(client); close(socket_id); } int setup_server(int port) { int socket_id, e; socket_id = socket(AF_INET, SOCK_STREAM, 0); if (socket_id < 0) return socket_id; struct sockaddr_in listener = { .sin_family = AF_INET, // socket type IPv4 .sin_port = htons(port), // port # .sin_addr.s_addr = INADDR_ANY }; e = bind(socket_id, (struct sockaddr *)&listener, sizeof(listener)); if (e < 0) return e; e = listen(socket_id, 1); if (e < 0) return e; return socket_id; } int handle_request(int socket) { int read_bytes, e; char * message = NULL; read_bytes = len_prefix_read(socket, (void **)&message); if (read_bytes < 0) return read_bytes; printf("client[%d]: %s", socket, message); char * resp = "RECEIVED"; e = len_prefix_write(socket, resp, strlen(resp)); free(message); return e; }
void setUp () { setup_test_context (); setup_zap_handler (); setup_server (); }
int main(int argc, char* argv[]) { bool deamonMode = true; size_t serverNum = 1; bool verboseMode = false; std::string bindAddr; int bindPort = ROUND_DEFAULT_NODE_BIND_PORT; // Parse options int ch; while ((ch = getopt(argc, argv, "fhn:p:i:v")) != -1) { switch (ch) { case 'f': { deamonMode = false; } break; case 'h': { printusage(); exit(EXIT_SUCCESS); } break; case 'i': { bindAddr = optarg; } break; case 'n': { serverNum = atoi(optarg); } break; case 'p': { bindPort = atoi(optarg); } break; case 'v': { verboseMode = true; } break; default: printusage(); exit(EXIT_FAILURE); } } // Setup Logger /* Round::Logger *logger = server.getLogger(); logger->setLevel((verboseMode ? Round::LoggerLevel::TRACE : Round::LoggerLevel::INFO)); if (deamonMode) { std::string logFilename; if (server.getLogFilename(&logFilename, &err)) { Round::LoggerFileTarget *fileTarget = new Round::LoggerStdFileTarget(); if (fileTarget->open(logFilename)) { logger->addTarget(fileTarget); } else delete fileTarget; } } else { logger->addTarget(new Round::LoggerStdoutTarget()); logger->addTarget(new Round::LoggerStderrTarget()); } */ /* if (0 < configFilename.length()) { if (!server.loadConfigFromString(configFilename, &err)) { Round::RoundLog(err); exit(EXIT_FAILURE); } } if (0 < bindAddr.length()) { if (!server.setBindAddress(bindAddr, &err)) { Round::RoundLog(err); exit(EXIT_FAILURE); } } */ /* if (0 < bindCluster.length()) { if (!server.setCluster(bindCluster, &err)) { Round::RoundLog(err); exit(EXIT_FAILURE); } } */ // Setup deamon if (deamonMode) { int pid = fork(); if (pid < 0) exit(EXIT_FAILURE); if (0 < pid) exit(EXIT_SUCCESS); if (setsid() < 0) exit(EXIT_FAILURE); if (chdir("/") < 0) { exit(EXIT_FAILURE); } umask(0); close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); } // Setup Server RoundServerList *servers = round_server_list_new(); if (!servers) exit(EXIT_FAILURE); for (size_t n = 0; n < serverNum; n++) { RoundServer *server = round_server_new(); if (!server) exit(EXIT_FAILURE); if (0 < bindAddr.length()) { round_server_setbindaddress(server, bindAddr.c_str()); } round_server_setbindport(server, bindPort); setup_server(server); if (!round_server_start(server)) { exit(EXIT_FAILURE); } round_server_list_add(servers, server); bindPort = round_server_getbindport(server) + 1; } // Start server bool isRunnging = true; while (isRunnging) { sigset_t sigSet; if (sigfillset(&sigSet) != 0) break; int sigNo; if (sigwait(&sigSet, &sigNo) != 0) break; switch (sigNo) { case SIGTERM: case SIGINT: case SIGKILL: { round_server_list_stop(servers); isRunnging = false; } break; case SIGHUP: { if (!round_server_list_start(servers)) { exit(EXIT_FAILURE); } } break; } } round_server_list_delete(servers); return EXIT_SUCCESS; }
/* * delete the entry. Only the process who has published * the service_name has the right to remove this * service - the server will verify and report the result */ static int unpublish ( const char *service_name, ompi_info_t *info ) { int rc, ret, flag; bool global_scope; orte_process_name_t *info_host; opal_buffer_t *buf; orte_data_server_cmd_t cmd=ORTE_DATA_SERVER_UNPUBLISH; orte_std_cntr_t cnt; orte_rml_recv_cb_t xfer; ompi_info_get_bool(info, "ompi_global_scope", &global_scope, &flag); if (0 == flag) { /* scope was not defined - see if server exists */ if (!server_setup) { setup_server(); } if (mca_pubsub_orte_component.server_found) { /* server was found - use it as our default store */ info_host = &mca_pubsub_orte_component.server; global_scope = true; } else { /* server was not found - use our HNP as default store */ info_host = ORTE_PROC_MY_HNP; } } else if (!global_scope) { /* if the scope is not global, then unpublish the value from the HNP */ info_host = ORTE_PROC_MY_HNP; } else { /* has the server been setup yet? */ if (!server_setup) { setup_server(); } /* unpublish the value from the global ompi_server, but error * if that server wasn't contacted */ if (!mca_pubsub_orte_component.server_found) { opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:no-server", true, (long)ORTE_PROC_MY_NAME->vpid, "unpublish from"); return OMPI_ERR_NOT_FOUND; } info_host = &mca_pubsub_orte_component.server; } OPAL_OUTPUT_VERBOSE((1, ompi_pubsub_base_framework.framework_output, "%s pubsub:orte: unpublish service %s scope %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), service_name, global_scope ? "Global" : "Local")); /* construct the buffer */ buf = OBJ_NEW(opal_buffer_t); /* pack the unpublish command */ if (OPAL_SUCCESS != (rc = opal_dss.pack(buf, &cmd, 1, ORTE_DATA_SERVER_CMD))) { ORTE_ERROR_LOG(rc); OBJ_RELEASE(buf); goto CLEANUP; } /* pack the service name */ if (OPAL_SUCCESS != (rc = opal_dss.pack(buf, &service_name, 1, OPAL_STRING))) { ORTE_ERROR_LOG(rc); OBJ_RELEASE(buf); goto CLEANUP; } /* send the command */ if (0 > (rc = orte_rml.send_buffer_nb(info_host, buf, ORTE_RML_TAG_DATA_SERVER, orte_rml_send_callback, NULL))) { ORTE_ERROR_LOG(rc); OBJ_RELEASE(buf); goto CLEANUP; } /* get the answer */ OBJ_CONSTRUCT(&xfer, orte_rml_recv_cb_t); xfer.active = true; orte_rml.recv_buffer_nb(ORTE_NAME_WILDCARD, ORTE_RML_TAG_DATA_CLIENT, ORTE_RML_NON_PERSISTENT, orte_rml_recv_callback, &xfer); OMPI_WAIT_FOR_COMPLETION(xfer.active); /* unpack the result */ cnt = 1; if (OPAL_SUCCESS != (rc = opal_dss.unpack(&xfer.data, &ret, &cnt, OPAL_INT))) { ORTE_ERROR_LOG(rc); OBJ_DESTRUCT(&xfer); goto CLEANUP; } OBJ_DESTRUCT(&xfer); rc = ret; CLEANUP: return rc; }
static char* lookup ( const char *service_name, ompi_info_t *info ) { orte_process_name_t *info_host; opal_buffer_t *buf; orte_data_server_cmd_t cmd=ORTE_DATA_SERVER_LOOKUP; orte_std_cntr_t cnt=0; char *port_name=NULL; int ret, rc, flag, i; char value[256], **tokens, *ptr; int lookup[2] = { GLOBAL, LOCAL }; size_t num_tokens; orte_rml_recv_cb_t xfer; /* Look in the MPI_Info (ompi_info_t*) for the key * "ompi_lookup_order". Acceptable values are: * * - "local" -- only check the local scope * - "global" -- only check the global scope * - "local,global" -- check the local scope first, then check the * global scope * - "global,local" -- check the global scope first, then check the * local scope * * Give a little leeway in terms of whitespace in the value. * * The lookup[2] array will contain the results: lookup[0] is the * first scope to check, lookup[1] is the 2nd. Either value may * be NONE, LOCAL, or GLOBAL. If both are NONE, clearly that's an * error. :-) */ ompi_info_get(info, "ompi_lookup_order", sizeof(value) - 1, value, &flag); if (flag) { ptr = &value[0]; while (isspace(*ptr) && (ptr - value) < (int)sizeof(value)) { ++ptr; } if (ptr - value < (int)sizeof(value)) { tokens = opal_argv_split(ptr, ','); if (NULL != tokens) { if ((num_tokens = opal_argv_count(tokens)) > 2) { /* too many values in the comma-delimited list */ opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:too-many-orders", true, (long)ORTE_PROC_MY_NAME->vpid, (long)num_tokens); opal_argv_free(tokens); return NULL; } for (i = 0; i < 2; ++i) { if (NULL != tokens[i]) { if (0 == strcasecmp(tokens[i], "local")) { lookup[i] = LOCAL; } else if (0 == strcasecmp(tokens[i], "global")) { lookup[i] = GLOBAL; } else { /* unrecognized value -- that's an error */ opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:unknown-order", true, (long)ORTE_PROC_MY_NAME->vpid); opal_argv_free(tokens); return NULL; } } else { lookup[i] = NONE; } } opal_argv_free(tokens); } } if (NONE == lookup[0]) { /* if the user provided an info key, then we at least must * be given one place to look */ opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:unknown-order", true, (long)ORTE_PROC_MY_NAME->vpid); return NULL; } } else { /* if no info key was provided, then we default to the global * server IF it is active */ if (!server_setup) { setup_server(); } lookup[1] = NONE; if (mca_pubsub_orte_component.server_found) { lookup[0] = GLOBAL; } else { /* global server was not found - just look local */ lookup[0] = LOCAL; } } OPAL_OUTPUT_VERBOSE((1, ompi_pubsub_base_framework.framework_output, "%s pubsub:orte: lookup service %s scope %d", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), service_name, lookup[0])); /* go find the value */ for (i=0; i < 2; i++) { if (LOCAL == lookup[i]) { /* if the scope is local, then lookup the value on the HNP */ info_host = ORTE_PROC_MY_HNP; } else if (GLOBAL == lookup[i]) { /* has the server been setup yet? */ if (!server_setup) { setup_server(); } /* lookup the value on the global ompi_server, but error * if that server wasn't contacted */ if (!mca_pubsub_orte_component.server_found) { opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:no-server", true, (long)ORTE_PROC_MY_NAME->vpid, "lookup from"); return NULL; } info_host = &mca_pubsub_orte_component.server; } else if (NONE == lookup[i]) { continue; } else { /* unknown host! */ opal_show_help("help-ompi-pubsub-orte.txt", "pubsub-orte:unknown-order", true, (long)ORTE_PROC_MY_NAME->vpid); return NULL; } /* go look it up */ /* construct the buffer */ buf = OBJ_NEW(opal_buffer_t); /* pack the lookup command */ if (OPAL_SUCCESS != (ret = opal_dss.pack(buf, &cmd, 1, ORTE_DATA_SERVER_CMD))) { ORTE_ERROR_LOG(ret); OBJ_RELEASE(buf); goto CLEANUP; } /* pack the service name */ if (OPAL_SUCCESS != (ret = opal_dss.pack(buf, &service_name, 1, OPAL_STRING))) { ORTE_ERROR_LOG(ret); OBJ_RELEASE(buf); goto CLEANUP; } /* send the cmd */ if (0 > (ret = orte_rml.send_buffer_nb(info_host, buf, ORTE_RML_TAG_DATA_SERVER, orte_rml_send_callback, NULL))) { ORTE_ERROR_LOG(ret); OBJ_RELEASE(buf); goto CLEANUP; } /* get the answer */ OBJ_CONSTRUCT(&xfer, orte_rml_recv_cb_t); xfer.active = true; orte_rml.recv_buffer_nb(ORTE_NAME_WILDCARD, ORTE_RML_TAG_DATA_CLIENT, ORTE_RML_NON_PERSISTENT, orte_rml_recv_callback, &xfer); OMPI_WAIT_FOR_COMPLETION(xfer.active); /* unpack the return code */ cnt = 1; if (OPAL_SUCCESS != (ret = opal_dss.unpack(&xfer.data, &rc, &cnt, OPAL_INT))) { ORTE_ERROR_LOG(ret); goto CLEANUP; } OPAL_OUTPUT_VERBOSE((1, ompi_pubsub_base_framework.framework_output, "%s pubsub:orte: lookup returned status %d", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), rc)); if (ORTE_SUCCESS == rc) { /* the server was able to lookup the port - unpack the port name */ cnt=1; if (OPAL_SUCCESS != (ret = opal_dss.unpack(&xfer.data, &port_name, &cnt, OPAL_STRING))) { ORTE_ERROR_LOG(ret); OBJ_DESTRUCT(&xfer); goto CLEANUP; } OPAL_OUTPUT_VERBOSE((1, ompi_pubsub_base_framework.framework_output, "%s pubsub:orte: lookup returned port %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (NULL == port_name) ? "NULL" : port_name)); if (NULL != port_name) { /* got an answer - return it */ OBJ_DESTRUCT(&xfer); return port_name; } } /* if we didn't get a port_name, then continue */ OBJ_DESTRUCT(&xfer); } /* only get here if we tried both options and failed - since the * buffer will already have been cleaned up, just return */ CLEANUP: return NULL; }
int main (int argc, char *argv[]) { int index; int c; int dflag = 0; char *cvalue = NULL; while ((c = getopt(argc, argv, "c:Dhv")) != -1) { switch (c) { case 'c': cvalue = optarg; break; case 'D': dflag = 1; break; case 'h': printf("Usage: %s [-c config_file] [-v] [-h]\n", argv[0]); return 0; case 'v': printf("%s v%s (revision %s) (%s)\n", APPLICATION_NAME, ROCNET_VERSION, ROCNET_REVISION, ROCNET_REVDATE); return 0; case '?': if (optopt == 'c') { fprintf(stderr, "-%c missing argument.\n", optopt); } else if (isprint (optopt)) { fprintf (stderr, "Unknown option `-%c'.\n", optopt); } else { fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); } return 1; default: abort(); } } for (index = optind; index < argc; index++) { printf("Non-option argument %s\n", argv[index]); } // setup logging now setlogmask(LOG_UPTO(LOG_DEBUG)); openlog(PROG_ID, LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); syslog(LOG_NOTICE, "%s starting", PROG_ID); if (cvalue){ parse_file(cvalue); } else { parse_file(FILE_PATH); } if (setup_server() < 0) { syslog(LOG_ERR, "%s exiting [setup_server() failed]", PROG_ID); exit(EXIT_FAILURE); } // should we run as a daemon if (dflag) { if (daemon(0,0) < 0) { syslog(LOG_ERR, "error creating daemon: %s", strerror(errno)); exit(EXIT_FAILURE); } } else { print_config(); printf("-------\n"); printItemsList(); printf("\t\t-------\n"); } start_agent(); return 0; }
/* Main Engine. * Coordinates all the required setup, sending & receiving from users */ void Server::start () { // client address structure (to be recieved) struct sockaddr_in client; socklen_t client_len = sizeof (struct sockaddr_storage); // message structure im_message msg; size_t msg_len = sizeof (msg); cout << "Server: Starting... \n"; // Setup server if (!setup_server ()) { cerr << "Server: Setup Failed\n "; return; } cout << "Server: Start Successful\n"; // receive message from users while (1) { int len = 0; memset (&msg, 0, sizeof (msg)); len = recvfrom (master_socket, &msg, msg_len, 0, (struct sockaddr *) &client, &client_len); if (len == -1) continue; else if (len != msg_len) { // Some problem in the message sent cerr << "Some problem occurred in sending the message\n"; } else { #ifdef _DEBUG_ char host[NI_MAXHOST], service[NI_MAXSERV]; int s = getnameinfo ((struct sockaddr *) &client, client_len, host, NI_MAXHOST, service, NI_MAXSERV, NI_NUMERICSERV); if (s == 0) printf ("Received %d bytes from %s:%s\n", len, host, service); else fprintf (stderr, "getaddrnameinfo: %s\n", gai_strerror (s)); #endif // check the type of message received if (msg.type == REGISTRATION_MESSAGE) { // register the user if (!register_user (&msg, &client)) cerr << "Server: cannot register the user " << msg.from << endl; else cout << "Server: registered user " << msg.from << endl; } else if (msg.type == DEREGISTRATION_MESSAGE) { // deregister the user if (!deregister_user (&msg, &client)) cerr << "Server: cannot deregister the user " << msg.from << endl; else cout << "Server: deregistered user " << msg.from << endl; } else { // instant message if (!send_instant_msg (&msg, &client)) { cerr << "Server: cannot send message from " << msg.from; cerr << "to " << msg.to << endl; } else { cout << "Server: message sent from " << msg.from; cout << " to " << msg.to << endl; } } } } }
int main(int argc, char **argv) { const char *bind_addr = NULL; const char *port = NULL; const char *dest = NULL; #ifdef ENABLE_FORK int daemonize = 0; #endif #ifdef ENABLE_CHGUSER const char *user = NULL; #endif (void)argc; /* unused */ while(*(++argv) != NULL) { if(strcmp(*argv, "-h") == 0 || strcmp(*argv, "--help") == 0) { print_help(stdout); return 0; } else if(strcmp(*argv, "-b") == 0 || strcmp(*argv, "--bind") == 0) { if(bind_addr != NULL) { fprintf(stderr, "Error: --bind was passed multiple times\n"); return 1; } if(*(++argv) == NULL) { fprintf(stderr, "Error: missing argument for --bind\n"); return 1; } bind_addr = *argv; } else if(strcmp(*argv, "-p") == 0 || strcmp(*argv, "--port") == 0) { if(port != NULL) { fprintf(stderr, "Error: --port was passed multiple times\n"); return 1; } if(*(++argv) == NULL) { fprintf(stderr, "Error: missing argument for --port\n"); return 1; } port = *argv; } else if(strcmp(*argv, "-d") == 0 || strcmp(*argv, "--daemon") == 0) { #ifdef ENABLE_FORK daemonize = 1; #else fprintf(stderr, "Error: --daemon is not available\n"); return 1; #endif } else if(strcmp(*argv, "-u") == 0 || strcmp(*argv, "--user") == 0) { #ifdef ENABLE_CHGUSER if(user != NULL) { fprintf(stderr, "Error: --user was passed multiple times\n"); return 1; } if(*(++argv) == NULL) { fprintf(stderr, "Error: missing argument for --user\n"); return 1; } user = *argv; #else fprintf(stderr, "Error: --user is not available\n"); return 1; #endif } else { if(dest != NULL) { fprintf(stderr, "Error: multiple destinations specified\n"); return 1; } dest = *argv; } } if(port == NULL) port = "80"; if(dest == NULL) { fprintf(stderr, "Error: no destination specified\n"); return 1; } #ifdef __WIN32__ { /* Initializes WINSOCK */ WSADATA wsa; if(WSAStartup(MAKEWORD(1, 1), &wsa) != 0) { fprintf(stderr, "Error: can't initialize WINSOCK\n"); return 3; } } #endif { int serv_sock; /* Poor man's exception handling... */ int ret = setup_server(&serv_sock, bind_addr, port); if(ret != 0) return ret; #ifdef ENABLE_CHGUSER if(user != NULL) { struct passwd *pwd = getpwnam(user); if(pwd == NULL) { fprintf(stderr, "Error: user %s is unknown\n", user); return 2; } if(setresuid(pwd->pw_uid, pwd->pw_uid, pwd->pw_uid) == -1) { fprintf(stderr, "Error: can't change user to %s\n", user); return 2; } } #endif #ifdef ENABLE_FORK if(daemonize) { switch(fork()) { case -1: perror("Error: fork() failed"); break; case 0: /* child: go on... */ fclose(stdin); fclose(stdout); fclose(stderr); break; default: /* parent: exit with success */ return 0; break; } } #endif ret = serve(serv_sock, dest); my_closesocket(serv_sock); return ret; } }
PROCESS_THREAD(tftpd_process, ev, data) { static struct etimer t; static tftp_header *h; static int len, block, ack; static int tries; static int fd = -1; #if WITH_EXEC static char *elf_err; #endif PROCESS_BEGIN(); etimer_set(&t, CLOCK_CONF_SECOND*3); PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_TIMER); setup_server(); #if WITH_EXEC elfloader_init(); #endif print_local_addresses(); while(1) { /* connection from client */ RECV_PACKET(h); len = 0; init_config(); if(h->op == uip_htons(TFTP_RRQ)) { connect_back(); PRINTF("< rrq for %s\n", h->filename); len += strlen(h->filename)+1; if(strcmp("octet", h->filename+len)) { send_error(EUNDEF, "only octet mode supported"); goto close_connection; } len += strlen(h->filename+len)+1; /* skip mode */ parse_opts(h->options+len, uip_datalen()-len-2); if(config.to_ack & OACK_ERROR) { send_error(EOPTNEG, ""); goto close_connection; } fd = cfs_open(h->filename, CFS_READ); if(fd<0) { send_error(ENOTFOUND, ""); goto close_connection; } block = 0; ack = 0; tries = TFTP_MAXTRIES; PRINTF("starting transfer...\n"); for(;;) { if(send_oack()) len = config.blksize; /* XXX hack to prevent loop exit*/ else len = send_data(fd, block+1); if(len<0) { send_error(EUNDEF, "read failed"); goto close_file; } RECV_PACKET_TIMEOUT(h,t); if(ev == PROCESS_EVENT_TIMER) { PRINTF("ack timed out, tries left: %d\n", tries); if(--tries<=0) goto close_file; continue; } if(h->op != uip_htons(TFTP_ACK)) { send_error(EBADOP, ""); goto close_file; } config.to_ack = 0; tries = TFTP_MAXTRIES; ack = uip_htons(h->block_nr); if(ack == block+1) block++; if(len < config.blksize && ack == block) goto done; } } else if(h->op == uip_htons(TFTP_WRQ)) { connect_back(); PRINTF("< wrq for %s\n", h->filename); len += strlen(h->filename)+1; strncpy(config.filename, h->filename, sizeof(config.filename)-1); if(strcmp("octet", h->filename+strlen(h->filename)+1)) { send_error(EUNDEF, "only octet mode supported"); goto close_connection; } len += strlen(h->filename+len)+1; /* skip mode */ parse_opts(h->options+len, uip_datalen()-len-2); if(config.to_ack & OACK_ERROR) { send_error(EOPTNEG, ""); goto close_connection; } cfs_remove(h->filename); fd = cfs_open(h->filename, CFS_WRITE); if(fd<0) { send_error(EACCESS, ""); goto close_connection; } block = 0; ack = 0; tries = TFTP_MAXTRIES; PRINTF("starting transfer...\n"); if(!send_oack()) send_ack(block); for(;;) { RECV_PACKET_TIMEOUT(h,t); if(ev == PROCESS_EVENT_TIMER) { PRINTF("data timed out, tries left: %d\n", tries); if(--tries<=0) goto close_file; len = config.blksize; /* XXX hack to prevent loop exit*/ goto resend_ack; } if(h->op != uip_htons(TFTP_DATA)) { send_error(EBADOP, ""); goto close_file; } config.to_ack = 0; tries = TFTP_MAXTRIES; ack = uip_htons(h->block_nr); if(ack != block+1) continue; /* else */ block++; len = recv_data(fd, block); if(len<0) { send_error(EUNDEF, "write failed"); goto close_file; } #if WITH_EXEC if(len < config.blksize) { if(config.exec) { if(exec_file(config.filename, &elf_err) != 0) { send_error(EUNDEF, elf_err); goto close_file; } } } #endif resend_ack: if(!send_oack()) send_ack(block); if(len < config.blksize) goto done; } } done: PRINTF("done.\n"); close_file: if(fd>=0) cfs_close(fd); fd = -1; close_connection: if(client_conn) uip_udp_remove(client_conn); client_conn = 0; PRINTF("connection closed.\n"); } PROCESS_END(); }
void setup_output() { char hdr[1024]; hdr[sizeof(hdr)-1] = 0; hdr[0] = 0; lastBytesRead = pcm->bytesRead(); lastBytesWritten = pcm->bytesWritten(); threadspercore = new int[gbl.ncores]; labels[fThreads].max = gbl.ncpus; labels[fInst].max = gbl.ncores * 4 * gbl.hz; labels[fFlopsSP].max = gbl.ncores * 8 * 2 * gbl.hz; labels[fFlopsDP].max = gbl.ncores * 4 * 2 * gbl.hz; hdrLabels[0] = "Time"; hdrLabels[1] = "Threads"; hdrIndexes[0] - fTime; hdrIndexes[1] = fThreads; int j = 2; for (int i = 0; i < nfields; ++i) if (i != fTime && i != fThreads) { hdrLabels[j] = labels[i].name; hdrIndexes[j] = i; ++j; } bool first = true; for (int i = 0; i < nfields; ++i) { if (first) first = false; else strncat(hdr, ",", sizeof(hdr)-1); strncat(hdr, hdrLabels[i], sizeof(hdr)-1); } strncat(hdr, "\n", sizeof(hdr)-1); if (gbl.server) { setup_server(); } else if (gbl.outfile) { outfile = fopen(gbl.outfile, "w"); if (outfile == NULL) err(1, "create %s", gbl.outfile); } gbl.hdr[0] = 0; gbl.hdr[sizeof(gbl.hdr)-1] = 0; if (gbl.server) { for (int i = 0; i < nfields; ++i) if (i != fTime) snprintf(gbl.hdr+strlen(gbl.hdr), sizeof(gbl.hdr)-1, "%s=%g,%s,%g\n", labels[i].name, labels[i].max, labels[i].units, labels[i].factor); strncat(gbl.hdr, hdr, sizeof(gbl.hdr)-1); } else if (outfile) { for (int i = 0; i < nfields; ++i) if (i != fTime) fprintf(outfile, "%s=%g,%s,%g\n", labels[i].name, labels[i].max, labels[i].units, labels[i].factor); fprintf(outfile, hdr); } starttsc = _rdtsc(); }
int main( void ) { int* connfd; struct sockaddr_in cliaddr; socklen_t clilen; pthread_t mythread; int n, index; char buffer[1000]; char* banner = "Hello This is the server Please enter your name: "; char* banner2 = "SORRY....chat room is full, So you have to wait until you get the chance....\n "; /* Install signal handler for SIGINT */ signal(SIGINT,cleanup); listenfd = setup_server(); listen(listenfd,MAXCLIENTS); clilen = sizeof(cliaddr); /* Initialise any synchronisation variables like mutexes, attributes and memory */ while(!quit){ /* Accept an incoming connection */ connfd = malloc(sizeof(int)); *connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen); /** find the next free index **/ index = next_free(); if(index == -1){ send(*connfd,banner2,strlen(banner2),0); close(*connfd); } else{ send(*connfd,banner,strlen(banner),0); n = recv(*connfd,buffer,MAXMSG,0); buffer[n]=0; /* Allocate and set up new client_t struct in clients array */ clients[index] = malloc(sizeof(client_t)); clients[index]->index = index; clients[index]->sd = *connfd; clients[index]->name = buffer; /** threads are created here **/ if ( pthread_create( &mythread, NULL, handle_client, connfd) ){ printf("error creating thread."); abort(); } clients[index]->tid = mythread; /* Create a DETACHED thread to handle the new client until the quit is set */ } } puts("Shutting down client connections...\n"); close(listenfd); return 0; }
//----------------------- funcao principal do programa ------------------------ int main(int argc, char *argv[]) { // usa porta predefinida port = SERVERPORT; // configura socket do servidor setup_server(); // inicializa estrutura para verificacao de eventos de leitura no socket int pollret; for (pollret = 0; pollret < MAXCONCLIENTS; pollret++) { sockets[pollret].fd = -1; sockets[pollret].events = POLLIN | POLLPRI; } conclients = 0; // thread p aguardar e estabelecer novas conexoes... if (pthread_create(&thread, NULL, acceptconnections, 0)) fatal("thread_creation: %s.", strerror(errno)); // recebe mensagens dos clientes e as reenvia para todos os clientes // conectados, enquanto houver clientes conectados msg_t *msg; msg = (msg_t *) malloc (sizeof (msg_t)); int count; do { // aguarda por evento nos sockets while (!conclients || !(pollret = poll(sockets, conclients, 1000))); // verifica os eventos ocorridos nos sockets dos clientes for (count = 0; count < conclients; count++) { msg->msgtype = Message; // se ha conteudo a ser lido no socket if ( (sockets[count].revents & POLLIN) || (sockets[count].revents & POLLPRI)) { // recebe msg do cliente e reenvia a todos recv(sockets[count].fd, msg, sizeof(msg_t), 0); if (msg->msgtype != Logout) { printf("%s envia: %s\n", msg->user, msg->msgbuff); sendtoall(msg); } } // se cliente solicitou logout ou ocorreu erro com seu socket if ( (sockets[count].revents & POLLHUP) || (sockets[count].revents & POLLNVAL) || msg->msgtype == Logout ) { // gera msg para avisar sobre a saida do usuario printf("Usuario '%s' desconectou-se.\n", conusers[count]); strcpy(msg->user, "SERVER"); strcpy(msg->msgbuff, "Usuario '"); strcat(msg->msgbuff, conusers[count]); strcat(msg->msgbuff, "' desconectou-se."); msg->msgtype = Message; // remove usuario removeclientat(count); // informa os demais da saida do usuario sendtoall(msg); // cliente desconectado, retorna o contador count--; // se nao ha clientes conectados, finaliza o servidor if (!conclients) conclients = -1; } } } while (conclients != -1); // encerra o socket do servidor close(serversock); return 0; }
void Socket::before_fork() { setup_server(); }
int main() { int listening_socket, client_socket, e; struct sigaction action = { .sa_handler = sighandler, .sa_flags = 0 }; sigemptyset(&action.sa_mask); sigaction(SIGINT, &action, NULL); int listener = 1; listening_socket = setup_server(PORT); if (listening_socket < 0) { perror("Error setting up server"); exit(-1); } struct user client; while (running) { if (listener) { printf("<server> listening on %d\n", PORT); client_socket = accept(listening_socket, NULL, NULL); // blocks here on connection e = handshake(client_socket, &client); printf("<server> connected: %s\n", client.name); fflush(stdout); listener = fork(); if (listener) { close(client_socket); } else { close(listening_socket); } } else { e = handle_request(client_socket, client); if (e < 0) { running = 0; } } } if (listener) { close(listening_socket); } else { remove(client.name); struct signal sig = new_disconnect_sig(); write(client_socket, &sig, sizeof(sig)); close(client_socket); } return 0; } int setup_server(int port) { int listening_socket, e; listening_socket = socket(AF_INET, SOCK_STREAM, 0); if (listening_socket < 0) return listening_socket; struct sockaddr_in listener = { .sin_family = AF_INET, // socket type IPv4 .sin_port = htons(port), // port # .sin_addr.s_addr = INADDR_ANY }; e = bind(listening_socket, (struct sockaddr *)&listener, sizeof(listener)); if (e < 0) return e; e = listen(listening_socket, 1); if (e < 0) return e; return listening_socket; } int fetch_a_message(int socket_id, char *pipe_path, struct signal* sig) { int e; int pipe_id = open(pipe_path, O_RDONLY | O_NONBLOCK); if (pipe_id < 0) return -1; fd_set fd; FD_ZERO(&fd); FD_SET(socket_id, &fd); FD_SET(pipe_id, &fd); int m = socket_id > pipe_id ? socket_id : pipe_id; select(m+1, &fd, NULL, NULL, NULL); if ( FD_ISSET(socket_id, &fd) ) { e = read(socket_id, sig, sizeof(*sig)); } else if ( FD_ISSET(pipe_id, &fd) ){ e = read(pipe_id, sig, sizeof(*sig)); } else { e = 0; }; close(pipe_id); return e; }
void ICACHE_FLASH_ATTR init_done() { setup_server(); }