static int start_unix_server(GError **error) { struct sockaddr_un local; worker_data_t wdata; memset(&wdata, 0x00, sizeof(wdata)); memset(&local, 0x00, sizeof(local)); memset(&worker_unix, 0, sizeof(worker_t)); /* Create ressources to monitor */ sock_unix = socket_nonblock(PF_UNIX, SOCK_STREAM, 0); if (sock_unix < 0) { GSETERROR(error, "Failed to create socket : %s", strerror(errno)); return(0); } /* Bind to file */ local.sun_family = AF_UNIX; g_strlcpy(local.sun_path, unix_socket_path, sizeof(local.sun_path)-1); if (-1 == bind(sock_unix, (struct sockaddr *)&local, sizeof(local))) { GSETERROR(error, "Failed to bind socket %d to file %s : %s", sock_unix, unix_socket_path, strerror(errno)); metautils_pclose(&sock_unix); return(0); } /* Listen on that socket */ if (-1 == listen(sock_unix, unix_socket_backlog)) { GSETERROR(error, "Failed to listen on socket %d : %s", sock_unix, strerror(errno)); metautils_pclose(&sock_unix); return(0); } if (!set_unix_permissions(unix_socket_path, error)) { GSETERROR(error, "Failed to set proper permissions on socket %d", sock_unix); metautils_pclose(&sock_unix); return(0); } /* Create worker */ wdata.fd = sock_unix; wdata.sock_timeout = unix_socket_timeout; worker_unix.func = accept_worker; worker_unix.timeout.startup = 0; worker_unix.timeout.activity = 0; memcpy(&(worker_unix.data), &wdata, sizeof(worker_data_t)); /* Accept new connection */ if (!add_fd_to_io_scheduler(&worker_unix, EPOLLIN, error)) { GSETERROR(error,"Failed to add server sock to io_scheduler"); metautils_pclose(&sock_unix); return 0; } INFO("UNIX server started on socket %s", unix_socket_path); return(1); }
int http_request_worker(worker_t *worker, GError **error) { int fd; worker_data_t *data = NULL; http_session_t *http_session = NULL; TRACE("Executing http_request worker"); data = &(worker->data); http_session = (http_session_t*)data->session; if (0 > (fd = addrinfo_connect_nopoll(http_session->addr, 1000, error))) { GSETERROR(error, "Connection to HTTP server failed"); goto error; } worker->func = write_request; worker->data.fd = fd; if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) { GSETERROR(error, "Failed to add socket to io_scheduler"); goto error; } return(1); error: return(0); }
static int start_inet_server(GError **error) { struct sockaddr_in sin; worker_data_t wdata; DEBUG("Starting an INET server bond on 127.0.0.1:%d", inet_socket_port); memset(&wdata, 0x00, sizeof(wdata)); memset(&worker_inet, 0, sizeof(worker_t)); /* Create ressources to monitor */ sock_inet = socket_nonblock(PF_INET, SOCK_STREAM, 0); if (sock_inet < 0) { GSETERROR(error, "Failed to create socket : %s", strerror(errno)); return(0); } sock_set_reuseaddr(sock_inet, TRUE); /* Bind to file */ memset(&sin, 0x00, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(inet_socket_port); if (!inet_aton("127.0.0.1", &(sin.sin_addr))) { GSETERROR(error,"Invalid address : 127.0.0.1 !!!"); return 0; } if (-1 == bind(sock_inet, (struct sockaddr *)&sin, sizeof(sin))) { GSETERROR(error, "Failed to bind socket [%d] to address 127.0.0.1 : %s", sock_inet, strerror(errno)); return(0); } /* Listen on that socket */ if (-1 == listen(sock_inet, inet_socket_backlog)) { GSETERROR(error, "Failed to listen on socket [%d] : %s", sock_inet, strerror(errno)); return(0); } /* Create worker */ wdata.fd = sock_inet; wdata.sock_timeout = inet_socket_timeout; worker_inet.func = accept_worker; worker_inet.timeout.startup = 0; worker_inet.timeout.activity = 0; memcpy(&(worker_inet.data), &wdata, sizeof(worker_data_t)); /* Accept new connection */ if (!add_fd_to_io_scheduler(&worker_inet, EPOLLIN, error)) { GSETERROR(error,"Failed to add server sock to io_scheduler"); return 0; } INFO("INET server started on socket fd=%d 127.0.0.1:%d", sock_inet, inet_socket_port); return(1); }
/** * Check the service still exists and start a worker that will * just perform a TCP-connect test. */ static int _check_tcp_service_task(gpointer udata, GError **error) { struct service_info_s *si; struct namespace_data_s *ns_data; struct taskdata_checksrv_s *task_data; task_data = udata; ns_data = g_hash_table_lookup(namespaces, task_data->ns_name); if (!ns_data) { task_done(task_data->task_name); GSETERROR(error, "Namespace unavailable"); return 0; } /* if the service does not exists, the task itself is de-scheduled */ if (!(si=g_hash_table_lookup(ns_data->local_services, task_data->srv_key)) && !(si=g_hash_table_lookup(ns_data->down_services, task_data->srv_key))) { task_done(task_data->task_name); task_stop(task_data->task_name); INFO("Service [%s] does not exist, stopping task [%s]", task_data->srv_key, task_data->task_name); return 1; } /* Now start a worker for this service. The worker has its own session_data, * without hard reference to the task_t or the namespace_data_t */ do { int fd = addrinfo_connect_nopoll(&(si->addr), 1000, error); if (0 > fd) { GSETERROR(error, "Connection to gridd server failed : (%d) %s", errno, strerror(errno)); return 0; } sock_set_linger(fd, 1, 0); struct workerdata_checksrv_s *wdata = g_malloc0(sizeof(*wdata)); g_strlcpy(wdata->task_name, task_data->task_name, sizeof(wdata->task_name)-1); g_strlcpy(wdata->ns_name, task_data->ns_name, sizeof(wdata->ns_name)-1); g_strlcpy(wdata->srv_key, task_data->srv_key, sizeof(wdata->srv_key)-1); worker_t *worker = g_malloc0(sizeof(worker_t)); worker->func = _check_tcp_service_worker_func; worker->clean = _check_tcp_service_worker_cleaner; worker->timeout.startup = 1000; worker->timeout.activity = 1000; worker->data.sock_timeout = 1000; worker->data.fd = fd; worker->data.session = wdata; if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) { _mark_service_state(task_data->ns_name, wdata->srv_key, FALSE); task_done(task_data->task_name); g_free(worker); g_free(wdata); GSETERROR(error, "Failed to add socket fd=%d to io_scheduler : %s", fd, strerror(errno)); return 0; } TRACE("TCP-connect tried to [%s] for [%s] (fd=%d)", task_data->srv_key, task_data->task_name, fd); } while (0); return 1; }