diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/Makefile | 16 | ||||
-rw-r--r-- | src/anylike.c | 41 | ||||
-rw-r--r-- | src/datatypes.h | 46 | ||||
-rw-r--r-- | src/main_loop.lua | 27 | ||||
-rw-r--r-- | src/options.c | 258 | ||||
-rw-r--r-- | src/options.h | 52 | ||||
-rw-r--r-- | src/string_list.c | 113 | ||||
-rw-r--r-- | src/string_list.h | 56 |
8 files changed, 597 insertions, 12 deletions
diff --git a/src/Makefile b/src/Makefile index 4252608..2136d1a 100644 --- a/src/Makefile +++ b/src/Makefile @@ -29,14 +29,14 @@ endif EXECUTABLE := anylike -# OBJ := log.o \ -# string_list.o \ -# sig_handler.o \ -# sysexec.o \ -# options.o \ -# anylike.o - -OBJ := anylike.o +# log.o \ +# sig_handler.o \ +# sysexec.o \ + +OBJ := options.o \ + string_list.o \ + anylike.o + SRC := $(OBJ:%.o=%.c) diff --git a/src/anylike.c b/src/anylike.c index ae65ef9..50c7d5d 100644 --- a/src/anylike.c +++ b/src/anylike.c @@ -28,7 +28,10 @@ #include <lua50/lua.h> -int main(int argc, char* argv[]) +#include "datatypes.h" +#include "options.h" + +int main_loop(options_t* opt) { lua_State *L; L = lua_open(); @@ -40,5 +43,39 @@ int main(int argc, char* argv[]) lua_close(L); - return 0; + return 0; +} + +int main(int argc, char* argv[]) +{ + options_t opt; + int ret = options_parse(&opt, argc, argv); + if(ret) { + if(ret > 0) { + fprintf(stderr, "syntax error near: %s\n\n", argv[ret]); + } + if(ret == -2) { + fprintf(stderr, "memory error on options_parse, exitting\n"); + } + if(ret == -3) { + options_print_version(); + } + + if(ret != -2 && ret != -3) + options_print_usage(); + + if(ret == -1 || ret == -3) + ret = 0; + + options_clear(&opt); + exit(ret); + } + + options_parse_post(&opt); + + ret = main_loop(&opt); + + options_clear(&opt); + + return ret; } diff --git a/src/datatypes.h b/src/datatypes.h new file mode 100644 index 0000000..ed6444f --- /dev/null +++ b/src/datatypes.h @@ -0,0 +1,46 @@ +/* + * anylike + * + * anylike is a ... + * + * + * Copyright (C) 2009-2010 Markus Grueneis <gimpf@anylike.org> + * Christian Pointner <equinox@anylike.org> + * + * This file is part of anylike. + * + * anylike is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * anylike 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 anylike. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef ANYLIKE_datatypes_h_INCLUDED +#define ANYLIKE_datatypes_h_INCLUDED + +#include <stdint.h> + +typedef uint8_t u_int8_t; +typedef uint16_t u_int16_t; +typedef uint32_t u_int32_t; +typedef uint64_t u_int64_t; +/* typedef int8_t int8_t; */ +/* typedef int16_t int16_t; */ +/* typedef int32_t int32_t; */ +/* typedef int64_t int64_t; */ + +struct buffer_struct { + u_int32_t length_; + u_int8_t* buf_; +}; +typedef struct buffer_struct buffer_t; + +#endif diff --git a/src/main_loop.lua b/src/main_loop.lua index 861e401..64963bb 100644 --- a/src/main_loop.lua +++ b/src/main_loop.lua @@ -1,3 +1,26 @@ --- sample lua script +-- +-- anylike +-- +-- anylike is a ... +-- +-- +-- Copyright (C) 2007-2008 Markus Grueneis <gimpf@anylike.org> +-- Christian Pointner <equinox@anylike.org> +-- +-- This file is part of anylike. +-- +-- anylike is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- anylike 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 anylike. If not, see <http://www.gnu.org/licenses/>. +-- + print("lua: main_loop started"); --- end lua script
\ No newline at end of file diff --git a/src/options.c b/src/options.c new file mode 100644 index 0000000..8684181 --- /dev/null +++ b/src/options.c @@ -0,0 +1,258 @@ +/* + * anylike + * + * anylike is a ... + * + * + * Copyright (C) 2009-2010 Markus Grueneis <gimpf@anylike.org> + * Christian Pointner <equinox@anylike.org> + * + * This file is part of anylike. + * + * anylike is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * anylike 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 anylike. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "datatypes.h" +#include "version.h" + +#include "options.h" + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <ctype.h> + +#define PARSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + VALUE = 1; + +#define PARSE_INVERSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + VALUE = 0; + +#define PARSE_INT_PARAM(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + { \ + if(argc < 1) \ + return i; \ + VALUE = atoi(argv[i+1]); \ + argc--; \ + i++; \ + } + +#define PARSE_STRING_PARAM(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return i; \ + if(VALUE) free(VALUE); \ + VALUE = strdup(argv[i+1]); \ + if(!VALUE) \ + return -2; \ + argc--; \ + i++; \ + } + +#define PARSE_STRING_PARAM_SEC(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return i; \ + if(VALUE) free(VALUE); \ + VALUE = strdup(argv[i+1]); \ + if(!VALUE) \ + return -2; \ + size_t j; \ + for(j=0; j < strlen(argv[i+1]); ++j) \ + argv[i+1][j] = '#'; \ + argc--; \ + i++; \ + } + +#define PARSE_HEXSTRING_PARAM_SEC(SHORT, LONG, VALUE) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return i; \ + int ret; \ + ret = options_parse_hex_string(argv[i+1], &VALUE); \ + if(ret > 0) \ + return i+1; \ + else if(ret < 0) \ + return ret; \ + size_t j; \ + for(j=0; j < strlen(argv[i+1]); ++j) \ + argv[i+1][j] = '#'; \ + argc--; \ + i++; \ + } + +#define PARSE_STRING_LIST(SHORT, LONG, LIST) \ + else if(!strcmp(str,SHORT) || !strcmp(str,LONG)) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return i; \ + int ret = string_list_add(&LIST, argv[i+1]); \ + if(ret == -2) \ + return ret; \ + else if(ret) \ + return i+1; \ + argc--; \ + i++; \ + } + +int options_parse_hex_string(const char* hex, buffer_t* buffer) +{ + if(!hex || !buffer) + return -1; + + u_int32_t hex_len = strlen(hex); + if(hex_len%2) + return 1; + + if(buffer->buf_) + free(buffer->buf_); + + buffer->length_ = hex_len/2; + buffer->buf_ = malloc(buffer->length_); + if(!buffer->buf_) { + buffer->length_ = 0; + return -2; + } + + const char* ptr = hex; + int i; + for(i=0;i<buffer->length_;++i) { + u_int32_t tmp; + sscanf(ptr, "%2X", &tmp); + buffer->buf_[i] = (u_int8_t)tmp; + ptr += 2; + } + + return 0; +} + + +int options_parse(options_t* opt, int argc, char* argv[]) +{ + if(!opt) + return -1; + + options_default(opt); + + if(opt->progname_) + free(opt->progname_); + opt->progname_ = strdup(argv[0]); + if(!opt->progname_) + return -2; + + argc--; + + int i; + for(i=1; argc > 0; ++i) + { + char* str = argv[i]; + argc--; + + if(!strcmp(str,"-h") || !strcmp(str,"--help")) + return -1; + else if(!strcmp(str,"-v") || !strcmp(str,"--version")) + return -3; + PARSE_INVERSE_BOOL_PARAM("-D","--nodaemonize", opt->daemonize_) + PARSE_STRING_PARAM("-u","--username", opt->username_) + PARSE_STRING_PARAM("-g","--groupname", opt->groupname_) + PARSE_STRING_PARAM("-C","--chroot", opt->chroot_dir_) + PARSE_STRING_PARAM("-P","--write-pid", opt->pid_file_) + PARSE_STRING_LIST("-L","--log", opt->log_targets_) + else + return i; + } + + return 0; +} + +void options_parse_post(options_t* opt) +{ + if(!opt) + return; + +// nothing here +} + +void options_default(options_t* opt) +{ + if(!opt) + return; + + opt->progname_ = strdup("anylike"); + opt->daemonize_ = 1; + opt->username_ = NULL; + opt->groupname_ = NULL; + opt->chroot_dir_ = NULL; + opt->pid_file_ = NULL; + string_list_init(&opt->log_targets_); +} + +void options_clear(options_t* opt) +{ + if(!opt) + return; + + if(opt->progname_) + free(opt->progname_); + if(opt->username_) + free(opt->username_); + if(opt->groupname_) + free(opt->groupname_); + if(opt->chroot_dir_) + free(opt->chroot_dir_); + if(opt->pid_file_) + free(opt->pid_file_); + string_list_clear(&opt->log_targets_); +} + +void options_print_usage() +{ + printf("USAGE:\n"); + printf("anylike [-h|--help] prints this...\n"); + printf(" [-v|--version] print version info and exit\n"); + printf(" [-D|--nodaemonize] don't run in background\n"); + printf(" [-u|--username] <username> change to this user\n"); + printf(" [-g|--groupname] <groupname> change to this group\n"); + printf(" [-C|--chroot] <path> chroot to this directory\n"); + printf(" [-P|--write-pid] <path> write pid to this file\n"); + printf(" [-L|--log] <target>:<level>[,<param1>[,<param2>..]]\n"); + printf(" add a log target, can be invoked several times\n"); +} + +void options_print_version() +{ + printf("%s\n", VERSION_STRING_0); + printf("%s\n", VERSION_STRING_1); +} + +void options_print(options_t* opt) +{ + if(!opt) + return; + + printf("progname: '%s'\n", opt->progname_); + printf("daemonize: %d\n", opt->daemonize_); + printf("username: '%s'\n", opt->username_); + printf("groupname: '%s'\n", opt->groupname_); + printf("chroot_dir: '%s'\n", opt->chroot_dir_); + printf("pid_file: '%s'\n", opt->pid_file_); + printf("log_targets: \n"); + string_list_print(&opt->log_targets_, " '", "'\n"); +} diff --git a/src/options.h b/src/options.h new file mode 100644 index 0000000..1ffebda --- /dev/null +++ b/src/options.h @@ -0,0 +1,52 @@ +/* + * anylike + * + * anylike is a ... + * + * + * Copyright (C) 2009-2010 Markus Grueneis <gimpf@anylike.org> + * Christian Pointner <equinox@anylike.org> + * + * This file is part of anylike. + * + * anylike is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * anylike 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 anylike. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef ANYLIKE_options_h_INCLUDED +#define ANYLIKE_options_h_INCLUDED + +#include "string_list.h" +#include "datatypes.h" + +struct options_struct { + char* progname_; + int daemonize_; + char* username_; + char* groupname_; + char* chroot_dir_; + char* pid_file_; + string_list_t log_targets_; +}; +typedef struct options_struct options_t; + +int options_parse_hex_string(const char* hex, buffer_t* buffer); + +int options_parse(options_t* opt, int argc, char* argv[]); +void options_parse_post(options_t* opt); +void options_default(options_t* opt); +void options_clear(options_t* opt); +void options_print_usage(); +void options_print(options_t* opt); + +#endif diff --git a/src/string_list.c b/src/string_list.c new file mode 100644 index 0000000..a4f4ab8 --- /dev/null +++ b/src/string_list.c @@ -0,0 +1,113 @@ +/* + * uAnytun + * + * 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) 2007-2008 Christian Pointner <equinox@anytun.org> + * + * This file is part of uAnytun. + * + * uAnytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * uAnytun 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 <http://www.gnu.org/licenses/>. + */ + +#include <string.h> +#include <stdlib.h> +#include <stdio.h> + +#include "string_list.h" + +void string_list_init(string_list_t* list) +{ + if(!list) + return; + + list->first_ = NULL; +} + +void string_list_clear(string_list_t* list) +{ + if(!list) + return; + + while(list->first_) { + string_list_element_t* tmp; + tmp = list->first_; + list->first_ = tmp->next_; + if(tmp->string_) + free(tmp->string_); + free(tmp); + } +} + +int string_list_add(string_list_t* list, const char* string) +{ + if(!list) + return -1; + + if(!list->first_) { + list->first_ = malloc(sizeof(string_list_element_t)); + if(!list->first_) + return -2; + + list->first_->next_ = 0; + list->first_->string_ = strdup(string); + if(!list->first_->string_) { + free(list->first_); + list->first_ = NULL; + return -2; + } + } + else { + string_list_element_t* tmp = list->first_; + while(tmp->next_) + tmp = tmp->next_; + + tmp->next_ = malloc(sizeof(string_list_element_t)); + if(!tmp->next_) + return -2; + + tmp->next_->next_ = 0; + tmp->next_->string_ = strdup(string); + if(!tmp->next_->string_) { + free(tmp->next_); + tmp->next_ = NULL; + return -2; + } + } + return 0; +} + +void string_list_print(string_list_t* list, const char* head, const char* tail) +{ + if(!list) + return; + + string_list_element_t* tmp = list->first_; + while(tmp) { + printf("%s%s%s", head, tmp->string_, tail); + tmp = tmp->next_; + } +} diff --git a/src/string_list.h b/src/string_list.h new file mode 100644 index 0000000..cd054cb --- /dev/null +++ b/src/string_list.h @@ -0,0 +1,56 @@ +/* + * uAnytun + * + * 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) 2007-2008 Christian Pointner <equinox@anytun.org> + * + * This file is part of uAnytun. + * + * uAnytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * uAnytun 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 <http://www.gnu.org/licenses/>. + */ + +#ifndef UANYTUN_string_list_h_INCLUDED +#define UANYTUN_string_list_h_INCLUDED + +struct string_list_element_struct { + char* string_; + struct string_list_element_struct* next_; +}; +typedef struct string_list_element_struct string_list_element_t; + +struct string_list_struct { + string_list_element_t* first_; +}; +typedef struct string_list_struct string_list_t; + +void string_list_init(string_list_t* list); +void string_list_clear(string_list_t* list); +int string_list_add(string_list_t* list, const char* string); + +void string_list_print(string_list_t* list, const char* head, const char* tail); + +#endif |