void process_client(void *arg) { int i; char b; t_buffer *buffers[4]; t_buffer buffer[4]; t_rinoosocket *socket = arg; buffer_static(&buffer[0], big_buffer, BUFFER_SIZE); buffers[0] = &buffer[0]; rinoo_log("server - client accepted"); rinoo_log("server - sending %d bytes", BUFFER_SIZE); XTEST(rinoo_socket_writev(socket, buffers, 1) == BUFFER_SIZE); rinoo_log("server - receiving 'b'"); XTEST(rinoo_socket_read(socket, &b, 1) == 1); XTEST(b == 'b'); for (i = 0; i < 4; i++) { buffer_static(&buffer[i], big_buffer + (i * (BUFFER_SIZE / 4)), BUFFER_SIZE / 4); buffers[i] = &buffer[i]; } rinoo_log("server - sending %d bytes", BUFFER_SIZE); XTEST(rinoo_socket_writev(socket, buffers, 4) == BUFFER_SIZE); rinoo_log("server - receiving 'b'"); XTEST(rinoo_socket_read(socket, &b, 1) == 1); XTEST(b == 'b'); rinoo_log("server - receiving nothing"); XTEST(rinoo_socket_read(socket, &b, 1) == -1); rinoo_socket_destroy(socket); }
/** * HTTP client processing callback * * @param context Pointer to a HTTP easy context */ static void rinoohttp_easy_client_process(void *context) { int i; bool found; t_buffer body; t_rinoohttp http; t_rinoohttp_easy_context *econtext = context; rinoohttp_init(econtext->socket, &http); while (rinoohttp_request_get(&http)) { for (i = 0, found = false; i < econtext->nbroutes && found == false; i++) { if (econtext->routes[i].uri == NULL || buffer_strcmp(&http.request.uri, econtext->routes[i].uri) == 0 || (econtext->routes[i].type == RINOO_HTTP_ROUTE_DIR && buffer_strncmp(&http.request.uri, econtext->routes[i].uri, strlen(econtext->routes[i].uri)) == 0)) { rinoohttp_easy_route_call(&http, &econtext->routes[i]); found = true; } } if (found == false) { http.response.code = 404; strtobuffer(&body, RINOO_HTTP_ERROR_404); rinoohttp_response_send(&http, &body); } rinoohttp_reset(&http); } rinoohttp_destroy(&http); rinoo_socket_destroy(econtext->socket); free(econtext); }
void task_client(void *socket) { char a; rinoo_socket_write(socket, "Hello world!\n", 13); rinoo_socket_read(socket, &a, 1); rinoo_socket_destroy(socket); }
void process_client(void *arg) { char a; t_rinoosocket *socket = arg; rinoo_log("server - client accepted"); rinoo_log("server - receiving nothing, waiting timeout"); XTEST(rinoo_socket_read(socket, &a, 1) <= 0); rinoo_socket_destroy(socket); }
void task_server(void *sched) { t_socket *server; t_socket *client; server = rinoo_tcp_server(sched, IP_ANY, 4242); while ((client = rinoo_tcp_accept(server, NULL, NULL)) != NULL) { rinoo_task_start(sched, task_client, client); } rinoo_socket_destroy(server); }
void server_func(void *unused(arg)) { t_socket *server; t_socket *client; server = rinoo_tcp_server(rinoo_sched_self(), IP_ANY, 4242); XTEST(server != NULL); client = rinoo_tcp_accept(server, NULL, NULL); XTEST(client != NULL); rinoo_log("client accepted"); rinoo_task_start(rinoo_sched_self(), process_client, client); rinoo_socket_destroy(server); }
/** * HTTP server processing callback * * @param context Pointer to a HTTP easy context */ static void rinoohttp_easy_server_process(void *context) { t_rinoosocket *client; t_rinoohttp_easy_context *c_context; t_rinoohttp_easy_context *s_context = context; while ((client = rinoo_tcp_accept(s_context->socket, NULL, NULL)) != NULL) { c_context = malloc(sizeof(*c_context)); if (c_context == NULL) { rinoo_socket_destroy(client); rinoo_socket_destroy(s_context->socket); free(s_context); return; } c_context->socket = client; c_context->routes = s_context->routes; c_context->nbroutes = s_context->nbroutes; rinoo_task_start(s_context->socket->node.sched, rinoohttp_easy_client_process, c_context); } rinoo_socket_destroy(s_context->socket); free(s_context); }
void http_server_process(void *socket) { t_buffer content; t_http http; XTEST(rinoo_http_init(socket, &http) == 0); XTEST(rinoo_http_request_get(&http)); http.response.code = 200; strtobuffer(&content, HTTP_CONTENT); XTEST(rinoo_http_response_send(&http, &content) == 0); rinoo_http_destroy(&http); rinoo_socket_destroy(socket); }
void client_func(void *unused(arg)) { t_buffer buffer; t_socket *client; client = rinoo_tcp_client(rinoo_sched_self(), IP_LOOPBACK, 4242, 0); XTEST(client != NULL); str = malloc(sizeof(*str) * TRANSFER_SIZE); XTEST(str != NULL); memset(str, 'a', TRANSFER_SIZE); buffer_static(&buffer, str, TRANSFER_SIZE); XTEST(rinoo_socket_writeb(client, &buffer) == TRANSFER_SIZE); rinoo_socket_destroy(client); }
void client_func(void *arg) { int i; ssize_t res; ssize_t total; char tmp[8]; struct sockaddr_in6 addr = { 0 }; t_rinoosocket *socket; t_rinoosched *sched = arg; socket = rinoo_socket(sched, &socket_class_tcp6); XTEST(socket != NULL); addr.sin6_port = htons(4242); addr.sin6_family = AF_INET6; addr.sin6_addr = in6addr_loopback; XTEST(rinoo_socket_connect(socket, (struct sockaddr *) &addr, sizeof(addr)) == 0); rinoo_log("client - connected"); rinoo_log("client - reading %d bytes", BUFFER_SIZE); for (i = 0; i < BUFFER_SIZE / 8; i++) { res = 0; total = 0; while (total < 8 && (res = rinoo_socket_read(socket, tmp + total, 8 - total)) > 0) { total += res; } if (res < 0) { rinoo_log("Error: %s", strerror(errno)); } XTEST(res > 0); XTEST(memcmp(tmp, "xxxxxxxx", 8) == 0); } rinoo_log("client - sending 'b'"); rinoo_log("client - reading %d bytes", BUFFER_SIZE); XTEST(rinoo_socket_write(socket, "b", 1) == 1); for (i = 0; i < BUFFER_SIZE / 8; i++) { res = 0; total = 0; while (total < 8 && (res = rinoo_socket_read(socket, tmp + total, 8 - total)) > 0) { total += res; } if (res < 0) { rinoo_log("Error: %s", strerror(errno)); } XTEST(res > 0); XTEST(memcmp(tmp, "xxxxxxxx", 8) == 0); } rinoo_log("client - sending 'b'"); XTEST(rinoo_socket_write(socket, "b", 1) == 1); rinoo_socket_destroy(socket); }
void process_client(void *socket) { t_buffer *buffer; buffer = buffer_create(NULL); XTEST(buffer != NULL); while (rinoo_socket_readb(socket, buffer) > 0) { rinoo_log("receiving..."); } XTEST(buffer_size(buffer) == TRANSFER_SIZE); XTEST(buffer_strncmp(buffer, str, TRANSFER_SIZE) == 0); buffer_destroy(buffer); free(str); rinoo_socket_destroy(socket); }
void http_server(void *sched) { t_ip ip; uint16_t port; t_socket *server; t_socket *client; server = rinoo_tcp_server(sched, IP_ANY, 4242); XTEST(server != NULL); client = rinoo_tcp_accept(server, &ip, &port); XTEST(client != NULL); rinoo_log("server - accepting client (%s:%d)", inet_ntoa(*(struct in_addr *) &ip), port); rinoo_task_start(sched, http_server_process, client); rinoo_socket_destroy(server); }
void http_client(void *sched) { t_http http; t_socket *client; client = rinoo_tcp_client(sched, IP_LOOPBACK, 4242, 0); XTEST(client != NULL); XTEST(rinoo_http_init(client, &http) == 0); XTEST(rinoo_http_request_send(&http, RINOO_HTTP_METHOD_GET, "/", NULL) == 0); XTEST(rinoo_http_response_get(&http)); XTEST(buffer_size(&http.response.content) == strlen(HTTP_CONTENT)); XTEST(http.response.code == 200); rinoo_http_destroy(&http); rinoo_socket_destroy(client); }
void server_func(void *arg) { t_rinoosocket *server; t_rinoosocket *client; struct sockaddr_in6 addr = { 0 }; t_rinoosched *sched = arg; server = rinoo_socket(sched, &socket_class_tcp6); XTEST(server != NULL); addr.sin6_port = htons(4242); addr.sin6_family = AF_INET6; addr.sin6_addr = in6addr_any; XTEST(rinoo_socket_bind(server, (struct sockaddr *) &addr, sizeof(addr), 42) == 0); rinoo_log("server listening..."); client = rinoo_socket_accept(server, NULL, NULL); XTEST(client != NULL); rinoo_task_start(sched, process_client, client); rinoo_socket_destroy(server); }
void client_func(void *arg) { char a; struct sockaddr_in6 addr = { 0 }; t_rinoosocket *socket; t_rinoosched *sched = arg; socket = rinoo_socket(sched, &socket_class_tcp6); XTEST(socket != NULL); addr.sin6_port = htons(4242); addr.sin6_family = AF_INET6; addr.sin6_addr = in6addr_loopback; XTEST(rinoo_socket_connect(socket, (struct sockaddr *) &addr, sizeof(addr)) == 0); rinoo_log("client - connected"); rinoo_socket_timeout(socket, 1000); XTEST(rinoo_socket_read(socket, &a, 1) == -1); rinoo_log("server - timeout"); perror("socket"); rinoo_socket_destroy(socket); }
void rsc_start_client(void *client_sched) { bool redo; uint32_t i; t_email email; t_session session = { 0 }; redo = true; email = *config->email; session.email = &email; session.helo = config->session.helo; session.read = buffer_create(NULL); if (session.read == NULL) { goto send_error; } session.write = buffer_create(NULL); if (session.write == NULL) { goto send_error; } rinoo_email_session_set(&email, &session); while (redo) { session.socket = rinoo_tcp_client(client_sched, &config->connection.ip, config->connection.port, config->connection.timeout * 1000); if (session.socket == NULL) { rinoo_log("Error: %s", strerror(errno)); config->stats.thread[rinoo_sched_self()->id].failed++; rsc_log(config, RSC_LOG_ERROR, "Couldn't create socket to %s:%d", config->connection.server, config->connection.port); goto send_error; } config->stats.thread[rinoo_sched_self()->id].sessions++; if (rinoo_smtp_start(&email) != 0) { goto send_error; } for (i = 0; i < config->session.nbmsg; i++) { if (rinoo_smtp_send(&email) != 0) { goto send_error; } config->stats.thread[rinoo_sched_self()->id].sent++; } if (rinoo_smtp_end(&email) != 0) { goto send_error; } rinoo_socket_destroy(session.socket); session.socket = NULL; config->stats.thread[rinoo_sched_self()->id].sessions--; if (config->mode == RSC_MODE_SECOND) { if (rinoo_task_wait(client_sched, 1000) != 0) { goto send_error; } } else if (config->mode != RSC_MODE_FLOOD) { redo = false; } } send_error: if (session.read != NULL) { buffer_destroy(session.read); } if (session.write != NULL) { buffer_destroy(session.write); } if (session.socket != NULL) { config->stats.thread[rinoo_sched_self()->id].sessions--; config->stats.thread[rinoo_sched_self()->id].failed++; rinoo_socket_destroy(session.socket); } if (__atomic_fetch_sub(&thread_counter, 1, __ATOMIC_SEQ_CST) == 1) { sched->stop = true; } }