From: Christian Pointner Date: Sat, 30 May 2009 01:56:12 +0000 (+0000) Subject: added nonblock-readline function X-Git-Url: https://git.realraum.at/?a=commitdiff_plain;h=c0f02109c659f75d7fd326983fa7eaa03b74de5c;p=svn42.git added nonblock-readline function --- diff --git a/door_daemon/client_list.h b/door_daemon/client_list.h index 4dd3c21..8bb14f9 100644 --- a/door_daemon/client_list.h +++ b/door_daemon/client_list.h @@ -21,10 +21,13 @@ #ifndef _CLIENT_LIST_H_ #define _CLIENT_LIST_H_ +#include "datatypes.h" + struct client_struct { int fd; int status_listener; struct client_struct* next; + read_buffer_t buffer; }; typedef struct client_struct client_t; diff --git a/door_daemon/datatypes.h b/door_daemon/datatypes.h index 3925f26..3cb3967 100644 --- a/door_daemon/datatypes.h +++ b/door_daemon/datatypes.h @@ -1,35 +1,21 @@ /* - * uAnytun + * door_daemon * - * uAnytun is a tiny implementation of SATP. Unlike Anytun which is a full - * featured implementation uAnytun has no support for multiple connections - * or synchronisation. It is a small single threaded implementation intended - * to act as a client on small platforms. - * The secure anycast tunneling protocol (satp) defines a protocol used - * for communication between any combination of unicast and anycast - * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel - * mode and allows tunneling of every ETHER TYPE protocol (e.g. - * ethernet, ip, arp ...). satp directly includes cryptography and - * message authentication based on the methodes used by SRTP. It is - * intended to deliver a generic, scaleable and secure solution for - * tunneling and relaying of packets of any protocol. - * + * Copyright (C) 2009 Christian Pointner * - * Copyright (C) 2007-2008 Christian Pointner + * This file is part of door_daemon. * - * This file is part of uAnytun. - * - * uAnytun is free software: you can redistribute it and/or modify + * door_daemon is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 3 as * published by the Free Software Foundation. * - * uAnytun is distributed in the hope that it will be useful, + * door_daemon is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with uAnytun. If not, see . + * along with door_daemon. If not, see . */ #ifndef _DATATYPES_H_ @@ -47,33 +33,12 @@ typedef uint64_t u_int64_t; /* typedef int32_t int32_t; */ /* typedef int64_t int64_t; */ -typedef u_int32_t window_size_t; - -typedef u_int32_t seq_nr_t; -#define SEQ_NR_T_NTOH(a) ntohl(a) -#define SEQ_NR_T_HTON(a) htonl(a) -#define SEQ_NR_MAX UINT32_MAX - -typedef u_int16_t sender_id_t; -#define SENDER_ID_T_NTOH(a) ntohs(a) -#define SENDER_ID_T_HTON(a) htons(a) - -typedef u_int16_t payload_type_t; -#define PAYLOAD_TYPE_T_NTOH(a) ntohs(a) -#define PAYLOAD_TYPE_T_HTON(a) htons(a) - -typedef u_int16_t mux_t; -#define MUX_T_NTOH(a) ntohs(a) -#define MUX_T_HTON(a) htons(a) - -typedef u_int32_t satp_prf_label_t; -#define SATP_PRF_LABEL_T_NTOH(a) ntohl(a) -#define SATP_PRF_LABEL_T_HTON(a) htonl(a) - struct buffer_struct { u_int32_t length_; u_int8_t* buf_; }; typedef struct buffer_struct buffer_t; +typedef char read_buffer_t[100]; + #endif diff --git a/door_daemon/door_daemon.c b/door_daemon/door_daemon.c index ba63ff8..22068a0 100644 --- a/door_daemon/door_daemon.c +++ b/door_daemon/door_daemon.c @@ -133,8 +133,10 @@ int send_response(int fd, const char* response) return ret; } -int handle_command(const char* cmd, int fd, cmd_t** cmd_q, client_t* client_lst) +int process_cmd(const char* cmd, int fd, cmd_t **cmd_q, client_t* client_lst) { + log_printf(DEBUG, "processing command from %d", fd); + if(!cmd_q || !cmd) return -1; @@ -195,78 +197,57 @@ int handle_command(const char* cmd, int fd, cmd_t** cmd_q, client_t* client_lst) return 0; } -int process_cmd(int fd, cmd_t **cmd_q, client_t* client_lst) +int process_door(const char* str, int door_fd, cmd_t **cmd_q, client_t* client_lst) { - log_printf(DEBUG, "processing command from %d", fd); - - static char buffer[100]; - int ret = 0; - do { // TODO: replace this whith a actually working non-blocking-readline - memset(buffer, 0, 100); - ret = recv(fd, buffer, sizeof(buffer), 0); - if(!ret) - return 1; - if(ret < 0) - return ret; + log_printf(NOTICE, "door-firmware: %s", str); - char* saveptr; - char* tok = strtok_r(buffer, "\n\r", &saveptr); - do { - if(!tok) - continue; + int cmd_fd = -1; + if(cmd_q && (*cmd_q)) { + cmd_fd = (*cmd_q)->fd; + send_response(cmd_fd, str); + } + + if(!strncmp(str, "Status:", 7)) { + client_t* client; + for(client = client_lst; client; client = client->next) + if(client->status_listener && client->fd != cmd_fd) + send_response(client->fd, str); + } + + cmd_pop(cmd_q); - ret = handle_command(tok, fd, cmd_q, client_lst); - if(ret < 0) - return ret; - } while(tok = strtok_r(NULL, "\n\r", &saveptr)); - } while (ret == -1 && errno == EINTR); - return 0; } -int process_door(int door_fd, cmd_t **cmd_q, client_t* client_lst) +int nonblock_readline(read_buffer_t buffer, int fd, cmd_t** cmd_q, client_t* client_lst, int (*cb)(const char*, int, cmd_t**, client_t*)) { - log_printf(DEBUG, "processing data from door (fd=%d)", door_fd); - - static char buffer[100]; int ret = 0; - do { // TODO: replace this whith a actually working non-blocking-readline - memset(buffer, 0, 100); - ret = read(door_fd, buffer, sizeof(buffer)); - if(!ret) + u_int32_t offset = 0; + for(;;) { + ret = read(fd, &buffer[offset], 1); + if(!ret) return 2; - if(ret < 0) - return ret; - - char* saveptr; - char* tok = strtok_r(buffer, "\n\r", &saveptr); - do { - if(!tok) - continue; - - log_printf(NOTICE, "door-firmware: %s", tok); - - int cmd_fd = -1; - if(cmd_q && (*cmd_q)) { - cmd_fd = (*cmd_q)->fd; - send_response(cmd_fd, tok); - } + else if(ret == -1 && errno == EAGAIN) + return 0; + else + break; - if(!strncmp(tok, "Status:", 7)) { - client_t* client; - for(client = client_lst; client; client = client->next) - if(client->status_listener && client->fd != cmd_fd) - send_response(client->fd, tok); - } + if(buffer[offset] == '\n') { + buffer[offset] = 0; + ret = (cb)(buffer, fd, cmd_q, client_lst); + break; + } - cmd_pop(cmd_q); - } while(tok = strtok_r(NULL, "\n\r", &saveptr)); - } while (ret == -1 && errno == EINTR); + offset++; + if(offset >= sizeof(buffer)) { + log_printf(DEBUG, "string too long (fd=%d)", fd); + return 0; + } + } - return 0; + return ret; } - int main_loop(int door_fd, int cmd_listen_fd) { log_printf(NOTICE, "entering main loop"); @@ -279,6 +260,8 @@ int main_loop(int door_fd, int cmd_listen_fd) cmd_t* cmd_q = NULL; client_t* client_lst = NULL; + read_buffer_t door_buffer; + int sig_fd = signal_init(); if(sig_fd < 0) return -1; @@ -304,7 +287,7 @@ int main_loop(int door_fd, int cmd_listen_fd) } if(FD_ISSET(door_fd, &tmpfds)) { - return_value = process_door(door_fd, &cmd_q, client_lst); + return_value = nonblock_readline(door_buffer, door_fd, &cmd_q, client_lst, process_door); if(return_value) break; } @@ -319,14 +302,15 @@ int main_loop(int door_fd, int cmd_listen_fd) log_printf(DEBUG, "new command connection (fd=%d)", new_fd); FD_SET(new_fd, &readfds); max_fd = (max_fd < new_fd) ? new_fd : max_fd; + fcntl(new_fd, F_SETFL, O_NONBLOCK); client_add(&client_lst, new_fd); } client_t* lst = client_lst; while(lst) { if(FD_ISSET(lst->fd, &tmpfds)) { - return_value = process_cmd(lst->fd, &cmd_q, client_lst); - if(return_value == 1) { + return_value = nonblock_readline(lst->buffer, lst->fd, &cmd_q, client_lst, process_cmd); + if(return_value == 2) { log_printf(DEBUG, "removing closed command connection (fd=%d)", lst->fd); client_t* deletee = lst; lst = lst->next; @@ -503,7 +487,7 @@ int main(int argc, char* argv[]) int door_fd = 0; for(;;) { - door_fd = open(opt.door_dev_, O_RDWR | O_NOCTTY); + door_fd = open(opt.door_dev_, O_RDWR | O_NOCTTY | O_NONBLOCK); if(door_fd < 0) ret = 2; else {