initial commit - pre-alpha version

Makefile

@@ -0,0 +1,47 @@
+PROGRAM = sbig340
+LDFLAGS =
+#-fdata-sections -ffunction-sections -Wl,--gc-sections
+SRCS = $(wildcard *.c)
+DEFINES = $(DEF) -D_XOPEN_SOURCE=1111 -DEBUG
+OBJDIR = mk
+CFLAGS = -Wall -Werror -Wextra -Wno-trampolines -std=gnu99
+OBJS = $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o))
+DEPS = $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.d))
+CC = gcc
+
+all : $(PROGRAM)
+
+$(PROGRAM) : $(OBJS)
+	@echo -e "\t\tLD $(PROGRAM)"
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) -o $(PROGRAM)
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+$(OBJS): $(OBJDIR) $(DEPS)
+
+$(OBJDIR)/%.d: %.c $(OBJDIR)
+	$(CC) -MM -MG $< | sed -e 's,^\([^:]*\)\.o[ ]*:,$(@D)/\1.o $(@D)/\1.d:,' >$@
+
+ifneq ($(MAKECMDGOALS),clean)
+-include $(DEPS)
+endif
+
+$(OBJDIR)/%.o: %.c
+	@echo -e "\t\tCC $<"
+	$(CC) -c $(CFLAGS) $(DEFINES) -o $@ $<
+
+clean:
+	@echo -e "\t\tCLEAN"
+	@rm -f $(OBJS)
+	@rm -f $(DEPS)
+	@rmdir $(OBJDIR) 2>/dev/null || true
+
+xclean: clean
+	@rm -f $(PROGRAM)
+
+gentags:
+	CFLAGS="$(CFLAGS) $(DEFINES)" geany -g $(PROGRAM).c.tags *[hc] 2>/dev/null
+
+.PHONY: gentags clean xclean
+

cmdlnopts.c

@@ -0,0 +1,86 @@
+/*
+ * cmdlnopts.c - the only function that parse cmdln args and returns glob parameters
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <math.h>
+#include "cmdlnopts.h"
+#include "usefull_macros.h"
+
+/*
+ * here are global parameters initialisation
+ */
+int help;
+glob_pars  G;
+
+int rewrite_ifexists = 0, // rewrite existing files == 0 or 1
+    verbose = 0; // each -v increments this value, e.g. -vvv sets it to 3
+#define DEFAULT_COMDEV  "/dev/ttyUSB0"
+//            DEFAULTS
+// default global parameters
+glob_pars const Gdefault = {
+    .daemon = 0,
+    .terminal = 0,
+    .device = DEFAULT_COMDEV,
+    .rest_pars_num = 0,
+    .rest_pars = NULL
+};
+
+/*
+ * Define command line options by filling structure:
+ *  name        has_arg     flag    val     type        argptr              help
+*/
+myoption cmdlnopts[] = {
+    // set 1 to param despite of its repeating number:
+    {"help",    NO_ARGS,    NULL,   'h',    arg_int,    APTR(&help),        _("show this help")},
+    {"daemon",  NO_ARGS,    NULL,   'd',    arg_int,    APTR(&G.daemon),    _("run as daemon")},
+    {"terminal",NO_ARGS,    NULL,   't',    arg_int,    APTR(&G.terminal),  _("run as terminal")},
+    {"device",  NEED_ARG,   NULL,   'i',    arg_string, APTR(&G.device),    _("serial device name (default: " DEFAULT_COMDEV ")")},
+    // simple integer parameter with obligatory arg:
+   end_option
+};
+
+/**
+ * Parse command line options and return dynamically allocated structure
+ *      to global parameters
+ * @param argc - copy of argc from main
+ * @param argv - copy of argv from main
+ * @return allocated structure with global parameters
+ */
+glob_pars *parse_args(int argc, char **argv){
+    int i;
+    void *ptr;
+    ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr);
+    // format of help: "Usage: progname [args]\n"
+    change_helpstring("Usage: %s [args]\n\n\tWhere args are:\n");
+    // parse arguments
+    parseargs(&argc, &argv, cmdlnopts);
+    if(help) showhelp(-1, cmdlnopts);
+    if(argc > 0){
+        G.rest_pars_num = argc;
+        G.rest_pars = calloc(argc, sizeof(char*));
+        for (i = 0; i < argc; i++)
+            G.rest_pars[i] = strdup(argv[i]);
+    }
+    return &G;
+}
+

cmdlnopts.h

@@ -0,0 +1,44 @@
+/*
+ * cmdlnopts.h - comand line options for parceargs
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#pragma once
+#ifndef __CMDLNOPTS_H__
+#define __CMDLNOPTS_H__
+
+#include "parseargs.h"
+
+/*
+ * here are some typedef's for global data
+ */
+typedef struct{
+    int daemon;             // to daemonize
+    int terminal;           // run as terminal (send/receive)
+    char *device;           // serial device name
+    int rest_pars_num;      // number of rest parameters
+    char** rest_pars;       // the rest parameters: array of char*
+} glob_pars;
+
+
+// default & global parameters
+extern int rewrite_ifexists, verbose;
+
+glob_pars *parse_args(int argc, char **argv);
+#endif // __CMDLNOPTS_H__

main.c

@@ -0,0 +1,47 @@
+/*
+ * main.c
+ *
+ * Copyright 2017 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include "usefull_macros.h"
+#include "term.h"
+#include "cmdlnopts.h"
+
+void signals(int signo){
+    restore_console();
+    restore_tty();
+    exit(signo);
+}
+
+int main(int argc, char **argv){
+    initial_setup();
+    glob_pars *G = parse_args(argc, argv);
+    if(G->daemon && G->terminal){
+        WARNX(_("Options --daemon and --terminal can't be together!"));
+        return 1;
+    }
+    if(!try_connect(G->device)){
+        WARNX(_("Check power and connection: device not answer!"));
+        return 1;
+    }
+    if(G->daemon || G->terminal){
+        red(_("All other commandline options rejected!\n"));
+        if(G->terminal) run_terminal(); // non-echo terminal mode
+        if(G->daemon) daemonize();
+    }
+}

parseargs.c

@@ -0,0 +1,497 @@
+/*
+ * parseargs.c - parsing command line arguments & print help
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <stdio.h>  // printf
+#include <getopt.h> // getopt_long
+#include <stdlib.h> // calloc, exit, strtoll
+#include <assert.h> // assert
+#include <string.h> // strdup, strchr, strlen
+#include <strings.h>// strcasecmp
+#include <limits.h> // INT_MAX & so on
+#include <libintl.h>// gettext
+#include <ctype.h>  // isalpha
+#include "parseargs.h"
+#include "usefull_macros.h"
+
+char *helpstring = "%s\n";
+
+/**
+ * Change standard help header
+ * MAY consist ONE "%s" for progname
+ * @param str (i) - new format
+ */
+void change_helpstring(char *s){
+    int pcount = 0, scount = 0;
+    char *str = s;
+    // check `helpstring` and set it to default in case of error
+    for(; pcount < 2; str += 2){
+        if(!(str = strchr(str, '%'))) break;
+        if(str[1] != '%') pcount++; // increment '%' counter if it isn't "%%"
+        else{
+            str += 2; // pass next '%'
+            continue;
+        }
+        if(str[1] == 's') scount++; // increment "%s" counter
+    };
+    if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong
+        /// "îÅÐÒÁ×ÉÌØÎÙÊ ÆÏÒÍÁÔ ÓÔÒÏËÉ ÐÏÍÏÝÉ"
+        ERRX(_("Wrong helpstring!"));
+    }
+    helpstring = s;
+}
+
+/**
+ * Carefull atoll/atoi
+ * @param num (o) - returning value (or NULL if you wish only check number) - allocated by user
+ * @param str (i) - string with number must not be NULL
+ * @param t   (i) - T_INT for integer or T_LLONG for long long (if argtype would be wided, may add more)
+ * @return TRUE if conversion sone without errors, FALSE otherwise
+ */
+static bool myatoll(void *num, char *str, argtype t){
+    long long tmp, *llptr;
+    int *iptr;
+    char *endptr;
+    assert(str);
+    assert(num);
+    tmp = strtoll(str, &endptr, 0);
+    if(endptr == str || *str == '\0' || *endptr != '\0')
+        return FALSE;
+    switch(t){
+        case arg_longlong:
+            llptr = (long long*) num;
+            *llptr = tmp;
+        break;
+        case arg_int:
+        default:
+            if(tmp < INT_MIN || tmp > INT_MAX){
+                /// "ãÅÌÏÅ ×ÎÅ ÄÏÐÕÓÔÉÍÏÇÏ ÄÉÁÐÁÚÏÎÁ"
+                WARNX(_("Integer out of range"));
+                return FALSE;
+            }
+            iptr = (int*)num;
+            *iptr = (int)tmp;
+    }
+    return TRUE;
+}
+
+// the same as myatoll but for double
+// There's no NAN & INF checking here (what if they would be needed?)
+static bool myatod(void *num, const char *str, argtype t){
+    double tmp, *dptr;
+    float *fptr;
+    char *endptr;
+    assert(str);
+    tmp = strtod(str, &endptr);
+    if(endptr == str || *str == '\0' || *endptr != '\0')
+        return FALSE;
+    switch(t){
+        case arg_double:
+            dptr = (double *) num;
+            *dptr = tmp;
+        break;
+        case arg_float:
+        default:
+            fptr = (float *) num;
+            *fptr = (float)tmp;
+        break;
+    }
+    return TRUE;
+}
+
+/**
+ * Get index of current option in array options
+ * @param opt (i) - returning val of getopt_long
+ * @param options (i) - array of options
+ * @return index in array
+ */
+static int get_optind(int opt, myoption *options){
+    int oind;
+    myoption *opts = options;
+    assert(opts);
+    for(oind = 0; opts->name && opts->val != opt; oind++, opts++);
+    if(!opts->name || opts->val != opt) // no such parameter
+    showhelp(-1, options);
+    return oind;
+}
+
+/**
+ * reallocate new value in array of multiple repeating arguments
+ * @arg paptr - address of pointer to array (**void)
+ * @arg type - its type (for realloc)
+ * @return pointer to new (next) value
+ */
+void *get_aptr(void *paptr, argtype type){
+    int i = 1;
+    void **aptr = *((void***)paptr);
+    if(aptr){ // there's something in array
+        void **p = aptr;
+        while(*p++) ++i;
+    }
+    size_t sz = 0;
+    switch(type){
+        default:
+        case arg_none:
+            /// "îÅ ÍÏÇÕ ÉÓÐÏÌØÚÏ×ÁÔØ ÎÅÓËÏÌØËÏ ÐÁÒÁÍÅÔÒÏ× ÂÅÚ ÁÒÇÕÍÅÎÔÏ×!"
+            ERRX("Can't use multiple args with arg_none!");
+        break;
+        case arg_int:
+            sz = sizeof(int);
+        break;
+        case arg_longlong:
+            sz = sizeof(long long);
+        break;
+        case arg_double:
+            sz = sizeof(double);
+        break;
+        case arg_float:
+            sz = sizeof(float);
+        break;
+        case arg_string:
+            sz = 0;
+        break;
+    /*  case arg_function:
+            sz = sizeof(argfn *);
+        break;*/
+    }
+    aptr = realloc(aptr, (i + 1) * sizeof(void*));
+    *((void***)paptr) = aptr;
+    aptr[i] = NULL;
+    if(sz){
+        aptr[i - 1] = malloc(sz);
+    }else
+        aptr[i - 1] = &aptr[i - 1];
+    return aptr[i - 1];
+}
+
+
+/**
+ * Parse command line arguments
+ * ! If arg is string, then value will be strdup'ed!
+ *
+ * @param argc (io) - address of argc of main(), return value of argc stay after `getopt`
+ * @param argv (io) - address of argv of main(), return pointer to argv stay after `getopt`
+ * BE CAREFUL! if you wanna use full argc & argv, save their original values before
+ *      calling this function
+ * @param options (i) - array of `myoption` for arguments parcing
+ *
+ * @exit: in case of error this function show help & make `exit(-1)`
+  */
+void parseargs(int *argc, char ***argv, myoption *options){
+    char *short_options, *soptr;
+    struct option *long_options, *loptr;
+    size_t optsize, i;
+    myoption *opts = options;
+    // check whether there is at least one options
+    assert(opts);
+    assert(opts[0].name);
+    // first we count how much values are in opts
+    for(optsize = 0; opts->name; optsize++, opts++);
+    // now we can allocate memory
+    short_options = calloc(optsize * 3 + 1, 1); // multiply by three for '::' in case of args in opts
+    long_options = calloc(optsize + 1, sizeof(struct option));
+    opts = options; loptr = long_options; soptr = short_options;
+    // in debug mode check the parameters are not repeated
+#ifdef EBUG
+    char **longlist = MALLOC(char*, optsize);
+    char *shortlist = MALLOC(char, optsize);
+#endif
+    // fill short/long parameters and make a simple checking
+    for(i = 0; i < optsize; i++, loptr++, opts++){
+        // check
+        assert(opts->name); // check name
+#ifdef EBUG
+        longlist[i] = strdup(opts->name);
+#endif
+        if(opts->has_arg){
+            assert(opts->type != arg_none); // check error with arg type
+            assert(opts->argptr);  // check pointer
+        }
+        if(opts->type != arg_none) // if there is a flag without arg, check its pointer
+            assert(opts->argptr);
+        // fill long_options
+        // don't do memcmp: what if there would be different alignment?
+        loptr->name     = opts->name;
+        loptr->has_arg  = (opts->has_arg < MULT_PAR) ? opts->has_arg : 1;
+        loptr->flag     = opts->flag;
+        loptr->val      = opts->val;
+        // fill short options if they are:
+        if(!opts->flag && opts->val){
+#ifdef EBUG
+            shortlist[i] = (char) opts->val;
+#endif
+            *soptr++ = opts->val;
+            if(loptr->has_arg) // add ':' if option has required argument
+                *soptr++ = ':';
+            if(loptr->has_arg == 2) // add '::' if option has optional argument
+                *soptr++ = ':';
+        }
+    }
+    // sort all lists & check for repeating
+#ifdef EBUG
+    int cmpstringp(const void *p1, const void *p2){
+        return strcmp(* (char * const *) p1, * (char * const *) p2);
+    }
+    int cmpcharp(const void *p1, const void *p2){
+        return (int)(*(char * const)p1 - *(char *const)p2);
+    }
+    qsort(longlist, optsize, sizeof(char *), cmpstringp);
+    qsort(shortlist,optsize, sizeof(char), cmpcharp);
+    char *prevl = longlist[0], prevshrt = shortlist[0];
+    for(i = 1; i < optsize; ++i){
+        if(longlist[i]){
+            if(prevl){
+                if(strcmp(prevl, longlist[i]) == 0) ERRX("double long arguments: --%s", prevl);
+            }
+            prevl = longlist[i];
+        }
+        if(shortlist[i]){
+            if(prevshrt){
+                if(prevshrt == shortlist[i]) ERRX("double short arguments: -%c", prevshrt);
+            }
+            prevshrt = shortlist[i];
+        }
+    }
+#endif
+    // now we have both long_options & short_options and can parse `getopt_long`
+    while(1){
+        int opt;
+        int oindex = 0, optind = 0; // oindex - number of option in argv, optind - number in options[]
+        if((opt = getopt_long(*argc, *argv, short_options, long_options, &oindex)) == -1) break;
+        if(opt == '?'){
+            opt = optopt;
+            optind = get_optind(opt, options);
+            if(options[optind].has_arg == NEED_ARG || options[optind].has_arg == MULT_PAR)
+                showhelp(optind, options); // need argument
+        }
+        else{
+            if(opt == 0 || oindex > 0) optind = oindex;
+            else optind = get_optind(opt, options);
+        }
+        opts = &options[optind];
+        if(opt == 0 && opts->has_arg == NO_ARGS) continue; // only long option changing integer flag
+        // now check option
+        if(opts->has_arg == NEED_ARG || opts->has_arg == MULT_PAR)
+            if(!optarg) showhelp(optind, options); // need argument
+        void *aptr;
+        if(opts->has_arg == MULT_PAR){
+            aptr = get_aptr(opts->argptr, opts->type);
+        }else
+            aptr = opts->argptr;
+        bool result = TRUE;
+        // even if there is no argument, but argptr != NULL, think that optarg = "1"
+        if(!optarg) optarg = "1";
+        switch(opts->type){
+            default:
+            case arg_none:
+                if(opts->argptr) *((int*)aptr) += 1; // increment value
+            break;
+            case arg_int:
+                result = myatoll(aptr, optarg, arg_int);
+            break;
+            case arg_longlong:
+                result = myatoll(aptr, optarg, arg_longlong);
+            break;
+            case arg_double:
+                result = myatod(aptr, optarg, arg_double);
+            break;
+            case arg_float:
+                result = myatod(aptr, optarg, arg_float);
+            break;
+            case arg_string:
+                result = (*((void**)aptr) = (void*)strdup(optarg));
+            break;
+            case arg_function:
+                result = ((argfn)aptr)(optarg);
+            break;
+        }
+        if(!result){
+            showhelp(optind, options);
+        }
+    }
+    *argc -= optind;
+    *argv += optind;
+}
+
+/**
+ * compare function for qsort
+ * first - sort by short options; second - sort arguments without sort opts (by long options)
+ */
+static int argsort(const void *a1, const void *a2){
+    const myoption *o1 = (myoption*)a1, *o2 = (myoption*)a2;
+    const char *l1 = o1->name, *l2 = o2->name;
+    int s1 = o1->val, s2 = o2->val;
+    int *f1 = o1->flag, *f2 = o2->flag;
+    // check if both options has short arg
+    if(f1 == NULL && f2 == NULL){ // both have short arg
+        return (s1 - s2);
+    }else if(f1 != NULL && f2 != NULL){ // both don't have short arg - sort by long
+        return strcmp(l1, l2);
+    }else{ // only one have short arg -- return it
+        if(f2) return -1; // a1 have short - it is 'lesser'
+        else return 1;
+    }
+}
+
+/**
+ * Show help information based on myoption->help values
+ * @param oindex (i)  - if non-negative, show only help by myoption[oindex].help
+ * @param options (i) - array of `myoption`
+ *
+ * @exit:  run `exit(-1)` !!!
+ */
+void showhelp(int oindex, myoption *options){
+    int max_opt_len = 0; // max len of options substring - for right indentation
+    const int bufsz = 255;
+    char buf[bufsz+1];
+    myoption *opts = options;
+    assert(opts);
+    assert(opts[0].name); // check whether there is at least one options
+    if(oindex > -1){ // print only one message
+        opts = &options[oindex];
+        printf("  ");
+        if(!opts->flag && isalpha(opts->val)) printf("-%c, ", opts->val);
+        printf("--%s", opts->name);
+        if(opts->has_arg == 1) printf("=arg");
+        else if(opts->has_arg == 2) printf("[=arg]");
+        printf("  %s\n", _(opts->help));
+        exit(-1);
+    }
+    // header, by default is just "progname\n"
+    printf("\n");
+    if(strstr(helpstring, "%s")) // print progname
+        printf(helpstring, __progname);
+    else // only text
+        printf("%s", helpstring);
+    printf("\n");
+    // count max_opt_len
+    do{
+        int L = strlen(opts->name);
+        if(max_opt_len < L) max_opt_len = L;
+    }while((++opts)->name);
+    max_opt_len += 14; // format: '-S , --long[=arg]' - get addition 13 symbols
+    opts = options;
+    // count amount of options
+    int N; for(N = 0; opts->name; ++N, ++opts);
+    if(N == 0) exit(-2);
+    // Now print all help (sorted)
+    opts = options;
+    qsort(opts, N, sizeof(myoption), argsort);
+    do{
+        int p = sprintf(buf, "  "); // a little indent
+        if(!opts->flag && opts->val) // .val is short argument
+            p += snprintf(buf+p, bufsz-p, "-%c, ", opts->val);
+        p += snprintf(buf+p, bufsz-p, "--%s", opts->name);
+        if(opts->has_arg == 1) // required argument
+            p += snprintf(buf+p, bufsz-p, "=arg");
+        else if(opts->has_arg == 2) // optional argument
+            p += snprintf(buf+p, bufsz-p, "[=arg]");
+        assert(p < max_opt_len); // there would be magic if p >= max_opt_len
+        printf("%-*s%s\n", max_opt_len+1, buf, _(opts->help)); // write options & at least 2 spaces after
+        ++opts;
+    }while(--N);
+    printf("\n\n");
+    exit(-1);
+}
+
+/**
+ * get suboptions from parameter string
+ * @param str - parameter string
+ * @param opt - pointer to suboptions structure
+ * @return TRUE if all OK
+ */
+bool get_suboption(char *str, mysuboption *opt){
+    int findsubopt(char *par, mysuboption *so){
+        int idx = 0;
+        if(!par) return -1;
+        while(so[idx].name){
+            if(strcasecmp(par, so[idx].name) == 0) return idx;
+            ++idx;
+        }
+        return -1; // badarg
+    }
+    bool opt_setarg(mysuboption *so, int idx, char *val){
+        mysuboption *soptr = &so[idx];
+        bool result = FALSE;
+        void *aptr = soptr->argptr;
+        switch(soptr->type){
+            default:
+            case arg_none:
+                if(soptr->argptr) *((int*)aptr) += 1; // increment value
+                result = TRUE;
+            break;
+            case arg_int:
+                result = myatoll(aptr, val, arg_int);
+            break;
+            case arg_longlong:
+                result = myatoll(aptr, val, arg_longlong);
+            break;
+            case arg_double:
+                result = myatod(aptr, val, arg_double);
+            break;
+            case arg_float:
+                result = myatod(aptr, val, arg_float);
+            break;
+            case arg_string:
+                result = (*((void**)aptr) = (void*)strdup(val));
+            break;
+            case arg_function:
+                result = ((argfn)aptr)(val);
+            break;
+        }
+        return result;
+    }
+    char *tok;
+    bool ret = FALSE;
+    char *tmpbuf;
+    tok = strtok_r(str, ":,", &tmpbuf);
+    do{
+        char *val = strchr(tok, '=');
+        int noarg = 0;
+        if(val == NULL){ // no args
+            val = "1";
+            noarg = 1;
+        }else{
+            *val++ = '\0';
+            if(!*val || *val == ':' || *val == ','){ // no argument - delimeter after =
+                val = "1"; noarg = 1;
+            }
+        }
+        int idx = findsubopt(tok, opt);
+        if(idx < 0){
+            /// "îÅÐÒÁ×ÉÌØÎÙÊ ÐÁÒÁÍÅÔÒ: %s"
+            WARNX(_("Wrong parameter: %s"), tok);
+            goto returning;
+        }
+        if(noarg && opt[idx].has_arg == NEED_ARG){
+            /// "%s: ÎÅÏÂÈÏÄÉÍ ÁÒÇÕÍÅÎÔ!"
+            WARNX(_("%s: argument needed!"), tok);
+            goto returning;
+        }
+        if(!opt_setarg(opt, idx, val)){
+            /// "îÅÐÒÁ×ÉÌØÎÙÊ ÁÒÇÕÍÅÎÔ \"%s\" ÐÁÒÁÍÅÔÒÁ \"%s\""
+            WARNX(_("Wrong argument \"%s\" of parameter \"%s\""), val, tok);
+            goto returning;
+        }
+    }while((tok = strtok_r(NULL, ":,", &tmpbuf)));
+    ret = TRUE;
+returning:
+    return ret;
+}

parseargs.h

@@ -0,0 +1,124 @@
+/*
+ * parseargs.h - headers for parsing command line arguments
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#pragma once
+#ifndef __PARSEARGS_H__
+#define __PARSEARGS_H__
+
+#include <stdbool.h>// bool
+#include <stdlib.h>
+
+#ifndef TRUE
+    #define TRUE true
+#endif
+
+#ifndef FALSE
+    #define FALSE false
+#endif
+
+// macro for argptr
+#define APTR(x)   ((void*)x)
+
+// if argptr is a function:
+typedef  bool(*argfn)(void *arg);
+
+/*
+ * type of getopt's argument
+ * WARNING!
+ * My function change value of flags by pointer, so if you want to use another type
+ * make a latter conversion, example:
+ *      char charg;
+ *      int iarg;
+ *      myoption opts[] = {
+ *      {"value", 1, NULL, 'v', arg_int, &iarg, "char val"}, ..., end_option};
+ *      ..(parse args)..
+ *      charg = (char) iarg;
+ */
+typedef enum {
+    arg_none = 0,   // no arg
+    arg_int,        // integer
+    arg_longlong,   // long long
+    arg_double,     // double
+    arg_float,      // float
+    arg_string,     // char *
+    arg_function    // parse_args will run function `bool (*fn)(char *optarg, int N)`
+} argtype;
+
+/*
+ * Structure for getopt_long & help
+ * BE CAREFUL: .argptr is pointer to data or pointer to function,
+ *      conversion depends on .type
+ *
+ * ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext,
+ * but you can redefine it before `#include "parseargs.h"`
+ *
+ * if arg is string, then value wil be strdup'ed like that:
+ *      char *str;
+ *      myoption opts[] = {{"string", 1, NULL, 's', arg_string, &str, "string val"}, ..., end_option};
+ *      *(opts[1].str) = strdup(optarg);
+ * in other cases argptr should be address of some variable (or pointer to allocated memory)
+ *
+ * NON-NULL argptr should be written inside macro APTR(argptr) or directly: (void*)argptr
+ *
+ * !!!LAST VALUE OF ARRAY SHOULD BE `end_option` or ZEROS !!!
+ *
+ */
+typedef enum{
+    NO_ARGS  = 0,  // first three are the same as in getopt_long
+    NEED_ARG = 1,
+    OPT_ARG  = 2,
+    MULT_PAR
+} hasarg;
+
+typedef struct{
+    // these are from struct option:
+    const char *name;       // long option's name
+    hasarg      has_arg;    // 0 - no args, 1 - nesessary arg, 2 - optionally arg, 4 - need arg & key can repeat (args are stored in null-terminated array)
+    int        *flag;       // NULL to return val, pointer to int - to set its value of val (function returns 0)
+    int         val;        // short opt name (if flag == NULL) or flag's value
+    // and these are mine:
+    argtype     type;       // type of argument
+    void       *argptr;     // pointer to variable to assign optarg value or function `bool (*fn)(char *optarg, int N)`
+    const char *help;       // help string which would be shown in function `showhelp` or NULL
+} myoption;
+
+/*
+ * Suboptions structure, almost the same like myoption
+ * used in parse_subopts()
+ */
+typedef struct{
+    const char *name;
+    hasarg      has_arg;
+    argtype     type;
+    void       *argptr;
+} mysuboption;
+
+// last string of array (all zeros)
+#define end_option {0,0,0,0,0,0,0}
+#define end_suboption {0,0,0,0}
+
+extern const char *__progname;
+
+void showhelp(int oindex, myoption *options);
+void parseargs(int *argc, char ***argv, myoption *options);
+void change_helpstring(char *s);
+bool get_suboption(char *str, mysuboption *opt);
+
+#endif // __PARSEARGS_H__

term.c

@@ -0,0 +1,192 @@
+/*
+ * client.c - simple terminal client
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include "usefull_macros.h"
+#include "term.h"
+/*
+#include <termios.h>        // tcsetattr
+#include <unistd.h>         // tcsetattr, close, read, write
+#include <sys/ioctl.h>      // ioctl
+#include <stdio.h>          // printf, getchar, fopen, perror
+#include <stdlib.h>         // exit
+#include <sys/stat.h>       // read
+#include <fcntl.h>          // read
+#include <signal.h>         // signal
+#include <time.h>           // time
+#include <string.h>         // memcpy
+#include <stdint.h>         // int types
+#include <sys/time.h>       // gettimeofday
+*/
+#define BUFLEN 1024
+
+tcflag_t Bspeeds[] = {
+    B9600,
+    B19200,
+    B38400,
+    B57600,
+    B115200,
+    B230400,
+    B460800
+};
+static const int speedssize = (int)sizeof(Bspeeds)/sizeof(Bspeeds[0]);
+static int curspd = -1;
+int speeds[] = {
+    9600,
+    19200,
+    38400,
+    57600,
+    115200,
+    230400,
+    460800
+};
+
+/**
+ * Return -1 if not connected or value of current speed in bps
+ */
+int get_curspeed(){
+    if(curspd < 0) return -1;
+    return speeds[curspd];
+}
+
+/**
+ * Send command by serial port, return 0 if all OK
+ */
+static uint8_t last_chksum = 0;
+int send_data(uint8_t *buf){
+    if(!*buf) return 1;
+    uint8_t chksum = 0, *ptr = buf;
+    int l;
+    for(l = 0; *ptr; ++l)
+        chksum ^= ~(*ptr++) & 0x7f;
+    DBG("send: %s%c", buf, (char)chksum);
+    if(write_tty(buf, l)) return 1;
+    if(write_tty(&chksum, 1)) return 1;
+    last_chksum = chksum;
+    return 0;
+}
+int send_cmd(uint8_t cmd){
+    uint8_t s[2];
+    s[0] = cmd;
+    s[1] = ~(cmd) & 0x7f;
+    if(write_tty(s, 2)) return 1;
+    last_chksum = s[1];
+    return 0;
+}
+
+/**
+ * Wait for answer with checksum
+ */
+trans_status wait_checksum(){
+    double d0 = dtime();
+    uint8_t chr;
+    do{
+        if(read_tty(&chr, 1)) break;
+    }while(dtime() - d0 < 0.1);
+    if(dtime() - d0 >= 0.1) return TRANS_TIMEOUT;
+    if(chr != last_chksum) return TRANS_BADCHSUM;
+    return TRANS_SUCCEED;
+}
+
+
+/**
+ * wait for answer (not more than 0.1s)
+ * @param rdata (o)  - readed data
+ * @param rdlen (o)  - its length (static array - THREAD UNSAFE)
+ * @return transaction status
+ */
+trans_status wait4answer(uint8_t **rdata, int *rdlen){
+    *rdlen = 0;
+    static uint8_t buf[128];
+    int L = 0;
+    trans_status st = wait_checksum();
+    if(st != TRANS_SUCCEED) return st;
+    double d0 = dtime();
+    do{
+        if((L = read_tty(buf, sizeof(buf)))) break;
+    }while(dtime() - d0 < 0.1);
+    if(!L) return TRANS_TIMEOUT;
+    *rdata = buf;
+    *rdlen = L;
+    return TRANS_SUCCEED;
+}
+
+/**
+ * Try to connect to `device` at different speeds
+ * @return connection speed if success or 0
+ */
+int try_connect(char *device){
+    if(!device) return 0;
+    green(_("Connecting to %s... "), device);
+    for(curspd = 0; curspd < speedssize; ++curspd){
+        tty_init(device, Bspeeds[curspd]);
+        DBG("Try speed %d", speeds[curspd]);
+        int ctr;
+        for(ctr = 0; ctr < 10; ++ctr){ // 10 tries to send data
+            if(send_cmd(CMD_COMM_TEST)) continue;
+            else break;
+        }
+        if(ctr == 10) continue; // error sending data
+        uint8_t *rd;
+        int l;
+        // OK, now check an answer
+        if(TRANS_SUCCEED != wait4answer(&rd, &l) || l != 1 || *rd != ANS_COMM_TEST) continue;
+        DBG("Got it!");
+        green(_("Connection established at B%d.\n"), speeds[curspd]);
+        return speeds[curspd];
+    }
+    green(_("No connection!"));
+    return 0;
+}
+
+/**
+ * run terminal emulation: send user's commands with checksum and show answers
+ */
+void run_terminal(){
+    green(_("Work in terminal mode without echo\n"));
+    int rb;
+    uint8_t buf[BUFLEN];
+    size_t L;
+    setup_con();
+    while(1){
+        if((L = read_tty(buf, BUFLEN))){
+            printf(_("Get data: "));
+            uint8_t *ptr = buf;
+            while(L--){
+                uint8_t c = *ptr++;
+                printf("0x%02x", c);
+                if(c > 31) printf("(%c)", (char)c);
+                printf(" ");
+            }
+            printf("\n");
+        }
+        if((rb = read_console())){
+            printf("Send command: %c ... ", (char)rb);
+            send_cmd((uint8_t)rb);
+            if(TRANS_SUCCEED != wait_checksum()) printf(_("Error.\n"));
+            else printf(_("Done.\n"));
+        }
+    }
+}
+
+/**
+ * Run as daemon
+ */
+void daemonize(){
+}

term.h

@@ -0,0 +1,46 @@
+/*
+ * term.h - functions to work with serial terminal
+ *
+ * Copyright 2017 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#pragma once
+#ifndef __TERM_H__
+#define __TERM_H__
+
+// communication errors
+
+typedef enum{
+    TRANS_SUCCEED = 0,  // no errors
+    TRANS_BADCHSUM,     // wrong checksum
+    TRANS_TIMEOUT       // no data for 0.1s
+} trans_status;
+
+/******************************** Commands definition ********************************/
+// communications test
+#define     CMD_COMM_TEST           'E'
+
+/******************************** Answers definition ********************************/
+#define     ANS_COMM_TEST           'O'
+
+void run_terminal();
+void daemonize();
+int open_serial(char *dev);
+int get_curspeed();
+int try_connect(char *device);
+
+#endif // __TERM_H__

usefull_macros.c

@@ -0,0 +1,369 @@
+/*
+ * usefull_macros.h - a set of usefull functions: memory, color etc
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "usefull_macros.h"
+
+/**
+ * function for different purposes that need to know time intervals
+ * @return double value: time in seconds
+ */
+double dtime(){
+    double t;
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    t = tv.tv_sec + ((double)tv.tv_usec)/1e6;
+    return t;
+}
+
+/******************************************************************************\
+ *                          Coloured terminal
+\******************************************************************************/
+int globErr = 0; // errno for WARN/ERR
+
+// pointers to coloured output printf
+int (*red)(const char *fmt, ...);
+int (*green)(const char *fmt, ...);
+int (*_WARN)(const char *fmt, ...);
+
+/*
+ * format red / green messages
+ * name: r_pr_, g_pr_
+ * @param fmt ... - printf-like format
+ * @return number of printed symbols
+ */
+int r_pr_(const char *fmt, ...){
+    va_list ar; int i;
+    printf(RED);
+    va_start(ar, fmt);
+    i = vprintf(fmt, ar);
+    va_end(ar);
+    printf(OLDCOLOR);
+    return i;
+}
+int g_pr_(const char *fmt, ...){
+    va_list ar; int i;
+    printf(GREEN);
+    va_start(ar, fmt);
+    i = vprintf(fmt, ar);
+    va_end(ar);
+    printf(OLDCOLOR);
+    return i;
+}
+/*
+ * print red error/warning messages (if output is a tty)
+ * @param fmt ... - printf-like format
+ * @return number of printed symbols
+ */
+int r_WARN(const char *fmt, ...){
+    va_list ar; int i = 1;
+    fprintf(stderr, RED);
+    va_start(ar, fmt);
+    if(globErr){
+        errno = globErr;
+        vwarn(fmt, ar);
+        errno = 0;
+    }else
+        i = vfprintf(stderr, fmt, ar);
+    va_end(ar);
+    i++;
+    fprintf(stderr, OLDCOLOR "\n");
+    return i;
+}
+
+static const char stars[] = "****************************************";
+/*
+ * notty variants of coloured printf
+ * name: s_WARN, r_pr_notty
+ * @param fmt ... - printf-like format
+ * @return number of printed symbols
+ */
+int s_WARN(const char *fmt, ...){
+    va_list ar; int i;
+    i = fprintf(stderr, "\n%s\n", stars);
+    va_start(ar, fmt);
+    if(globErr){
+        errno = globErr;
+        vwarn(fmt, ar);
+        errno = 0;
+    }else
+        i = +vfprintf(stderr, fmt, ar);
+    va_end(ar);
+    i += fprintf(stderr, "\n%s\n", stars);
+    i += fprintf(stderr, "\n");
+    return i;
+}
+int r_pr_notty(const char *fmt, ...){
+    va_list ar; int i;
+    i = printf("\n%s\n", stars);
+    va_start(ar, fmt);
+    i += vprintf(fmt, ar);
+    va_end(ar);
+    i += printf("\n%s\n", stars);
+    return i;
+}
+
+/**
+ * Run this function in the beginning of main() to setup locale & coloured output
+ */
+void initial_setup(){
+    // setup coloured output
+    if(isatty(STDOUT_FILENO)){ // make color output in tty
+        red = r_pr_; green = g_pr_;
+    }else{ // no colors in case of pipe
+        red = r_pr_notty; green = printf;
+    }
+    if(isatty(STDERR_FILENO)) _WARN = r_WARN;
+    else _WARN = s_WARN;
+    // Setup locale
+    setlocale(LC_ALL, "");
+    setlocale(LC_NUMERIC, "C");
+#if defined GETTEXT_PACKAGE && defined LOCALEDIR
+    bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
+    textdomain(GETTEXT_PACKAGE);
+#endif
+}
+
+/******************************************************************************\
+ *                                  Memory
+\******************************************************************************/
+/*
+ * safe memory allocation for macro ALLOC
+ * @param N - number of elements to allocate
+ * @param S - size of single element (typically sizeof)
+ * @return pointer to allocated memory area
+ */
+void *my_alloc(size_t N, size_t S){
+    void *p = calloc(N, S);
+    if(!p) ERR("malloc");
+    //assert(p);
+    return p;
+}
+
+/**
+ * Mmap file to a memory area
+ *
+ * @param filename (i) - name of file to mmap
+ * @return stuct with mmap'ed file or die
+ */
+mmapbuf *My_mmap(char *filename){
+    int fd;
+    char *ptr;
+    size_t Mlen;
+    struct stat statbuf;
+    /// "îÅ ÚÁÄÁÎÏ ÉÍÑ ÆÁÊÌÁ!"
+    if(!filename){
+        WARNX(_("No filename given!"));
+        return NULL;
+    }
+    if((fd = open(filename, O_RDONLY)) < 0){
+    /// "îÅ ÍÏÇÕ ÏÔËÒÙÔØ %s ÄÌÑ ÞÔÅÎÉÑ"
+        WARN(_("Can't open %s for reading"), filename);
+        return NULL;
+    }
+    if(fstat (fd, &statbuf) < 0){
+    /// "îÅ ÍÏÇÕ ×ÙÐÏÌÎÉÔØ stat %s"
+        WARN(_("Can't stat %s"), filename);
+        close(fd);
+        return NULL;
+    }
+    Mlen = statbuf.st_size;
+    if((ptr = mmap (0, Mlen, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED){
+    /// "ïÛÉÂËÁ mmap"
+        WARN(_("Mmap error for input"));
+        close(fd);
+        return NULL;
+    }
+    /// "îÅ ÍÏÇÕ ÚÁËÒÙÔØ mmap'ÎÕÔÙÊ ÆÁÊÌ"
+    if(close(fd)) WARN(_("Can't close mmap'ed file"));
+    mmapbuf *ret = MALLOC(mmapbuf, 1);
+    ret->data = ptr;
+    ret->len = Mlen;
+    return  ret;
+}
+
+void My_munmap(mmapbuf *b){
+    if(munmap(b->data, b->len)){
+    /// "îÅ ÍÏÇÕ munmap"
+        ERR(_("Can't munmap"));
+    }
+    FREE(b);
+}
+
+
+/******************************************************************************\
+ *                          Terminal in no-echo mode
+\******************************************************************************/
+static struct termios oldt, newt; // terminal flags
+static int console_changed = 0;
+// run on exit:
+void restore_console(){
+    if(console_changed)
+        tcsetattr(STDIN_FILENO, TCSANOW, &oldt); // return terminal to previous state
+    console_changed = 0;
+}
+
+// initial setup:
+void setup_con(){
+    if(console_changed) return;
+    tcgetattr(STDIN_FILENO, &oldt);
+    newt = oldt;
+    newt.c_lflag &= ~(ICANON | ECHO);
+    if(tcsetattr(STDIN_FILENO, TCSANOW, &newt) < 0){
+        /// "îÅ ÍÏÇÕ ÎÁÓÔÒÏÉÔØ ËÏÎÓÏÌØ"
+        WARN(_("Can't setup console"));
+        tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+        signals(0); //quit?
+    }
+    console_changed = 1;
+}
+
+/**
+ * Read character from console without echo
+ * @return char readed
+ */
+int read_console(){
+    int rb;
+    struct timeval tv;
+    int retval;
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(STDIN_FILENO, &rfds);
+    tv.tv_sec = 0; tv.tv_usec = 10000;
+    retval = select(1, &rfds, NULL, NULL, &tv);
+    if(!retval) rb = 0;
+    else {
+        if(FD_ISSET(STDIN_FILENO, &rfds)) rb = getchar();
+        else rb = 0;
+    }
+    return rb;
+}
+
+/**
+ * getchar() without echo
+ * wait until at least one character pressed
+ * @return character readed
+ */
+int mygetchar(){ // getchar() without need of pressing ENTER
+    int ret;
+    do ret = read_console();
+    while(ret == 0);
+    return ret;
+}
+
+
+/******************************************************************************\
+ *                              TTY with select()
+\******************************************************************************/
+static struct termio oldtty, tty; // TTY flags
+static int comfd = -1; // TTY fd
+
+// run on exit:
+void restore_tty(){
+    if(comfd == -1) return;
+    ioctl(comfd, TCSANOW, &oldtty ); // return TTY to previous state
+    close(comfd);
+    comfd = -1;
+}
+
+#ifndef BAUD_RATE
+#define BAUD_RATE B9600
+#endif
+// init: (speed = B9600 etc)
+void tty_init(char *comdev, tcflag_t speed){
+    DBG("Open port...");
+    if ((comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){
+        WARN("Can't use port %s\n",comdev);
+        ioctl(comfd, TCSANOW, &oldtty); // return TTY to previous state
+        close(comfd);
+        signals(0); // quit?
+    }
+    DBG("OK\nGet current settings...");
+    if(ioctl(comfd,TCGETA,&oldtty) < 0){  // Get settings
+        /// "îÅ ÍÏÇÕ ÐÏÌÕÞÉÔØ ÎÁÓÔÒÏÊËÉ"
+        WARN(_("Can't get settings"));
+        signals(0);
+    }
+    tty = oldtty;
+    tty.c_lflag     = 0; // ~(ICANON | ECHO | ECHOE | ISIG)
+    tty.c_oflag     = 0;
+    tty.c_cflag     = speed|CS8|CREAD|CLOCAL; // 9.6k, 8N1, RW, ignore line ctrl
+    tty.c_cc[VMIN]  = 0;  // non-canonical mode
+    tty.c_cc[VTIME] = 5;
+    if(ioctl(comfd,TCSETA,&tty) < 0){
+        /// "îÅ ÍÏÇÕ ÕÓÔÁÎÏ×ÉÔØ ÎÁÓÔÒÏÊËÉ"
+        WARN(_("Can't set settings"));
+        signals(0);
+    }
+    DBG("OK");
+}
+/**
+ * Read data from TTY
+ * @param buff (o) - buffer for data read
+ * @param length   - buffer len
+ * @return amount of readed bytes
+ */
+size_t read_tty(uint8_t *buff, size_t length){
+    ssize_t L = 0;
+    fd_set rfds;
+    struct timeval tv;
+    int retval;
+    FD_ZERO(&rfds);
+    FD_SET(comfd, &rfds);
+    tv.tv_sec = 0; tv.tv_usec = 50000; // wait for 50ms
+    retval = select(comfd + 1, &rfds, NULL, NULL, &tv);
+    if (!retval) return 0;
+    if(FD_ISSET(comfd, &rfds)){
+        if((L = read(comfd, buff, length)) < 1) return 0;
+    }
+    return (size_t)L;
+}
+
+int write_tty(uint8_t *buff, size_t length){
+    ssize_t L = write(comfd, buff, length);
+    if((size_t)L != length){
+        /// "ïÛÉÂËÁ ÚÁÐÉÓÉ!"
+        WARN("Write error!");
+        return 1;
+    }
+    return 0;
+}
+
+
+/**
+ * Safely convert data from string to double
+ *
+ * @param num (o) - double number read from string
+ * @param str (i) - input string
+ * @return 1 if success, 0 if fails
+ */
+int str2double(double *num, const char *str){
+    double res;
+    char *endptr;
+    if(!str) return 0;
+    res = strtod(str, &endptr);
+    if(endptr == str || *str == '\0' || *endptr != '\0'){
+        /// "îÅÐÒÁ×ÉÌØÎÙÊ ÆÏÒÍÁÔ ÞÉÓÌÁ double!"
+        WARNX("Wrong double number format!");
+        return FALSE;
+    }
+    if(num) *num = res; // you may run it like myatod(NULL, str) to test wether str is double number
+    return TRUE;
+}

usefull_macros.h

@@ -0,0 +1,140 @@
+/*
+ * usefull_macros.h - a set of usefull macros: memory, color etc
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#pragma once
+#ifndef __USEFULL_MACROS_H__
+#define __USEFULL_MACROS_H__
+
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <err.h>
+#include <locale.h>
+#if defined GETTEXT_PACKAGE && defined LOCALEDIR
+/*
+ * GETTEXT
+ */
+#include <libintl.h>
+#define _(String)               gettext(String)
+#define gettext_noop(String)    String
+#define N_(String)              gettext_noop(String)
+#else
+#define _(String)               (String)
+#define N_(String)              (String)
+#endif
+#include <stdlib.h>
+#include <termios.h>
+#include <termio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <stdint.h>
+
+
+// unused arguments with -Wall -Werror
+#define _U_    __attribute__((__unused__))
+
+/*
+ * Coloured messages output
+ */
+#define RED         "\033[1;31;40m"
+#define GREEN       "\033[1;32;40m"
+#define OLDCOLOR    "\033[0;0;0m"
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+#ifndef TRUE
+#define TRUE (1)
+#endif
+
+/*
+ * ERROR/WARNING messages
+ */
+extern int globErr;
+extern void signals(int sig);
+#define ERR(...) do{globErr=errno; _WARN(__VA_ARGS__); signals(9);}while(0)
+#define ERRX(...) do{globErr=0; _WARN(__VA_ARGS__); signals(9);}while(0)
+#define WARN(...) do{globErr=errno; _WARN(__VA_ARGS__);}while(0)
+#define WARNX(...) do{globErr=0; _WARN(__VA_ARGS__);}while(0)
+
+/*
+ * print function name, debug messages
+ * debug mode, -DEBUG
+ */
+#ifdef EBUG
+    #define FNAME() do{ fprintf(stderr, OLDCOLOR); \
+        fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__);} while(0)
+    #define DBG(...) do{ fprintf(stderr, OLDCOLOR); \
+                    fprintf(stderr, "%s (%s, line %d): ", __func__, __FILE__, __LINE__); \
+                    fprintf(stderr, __VA_ARGS__);           \
+                    fprintf(stderr, "\n");} while(0)
+#else
+    #define FNAME()  do{}while(0)
+    #define DBG(...) do{}while(0)
+#endif //EBUG
+
+/*
+ * Memory allocation
+ */
+#define ALLOC(type, var, size)  type * var = ((type *)my_alloc(size, sizeof(type)))
+#define MALLOC(type, size) ((type *)my_alloc(size, sizeof(type)))
+#define FREE(ptr)  do{if(ptr){free(ptr); ptr = NULL;}}while(0)
+
+#ifndef DBL_EPSILON
+#define DBL_EPSILON        (2.2204460492503131e-16)
+#endif
+
+double dtime();
+
+// functions for color output in tty & no-color in pipes
+extern int (*red)(const char *fmt, ...);
+extern int (*_WARN)(const char *fmt, ...);
+extern int (*green)(const char *fmt, ...);
+void * my_alloc(size_t N, size_t S);
+void initial_setup();
+
+// mmap file
+typedef struct{
+    char *data;
+    size_t len;
+} mmapbuf;
+mmapbuf *My_mmap(char *filename);
+void My_munmap(mmapbuf *b);
+
+void restore_console();
+void setup_con();
+int read_console();
+int mygetchar();
+
+void restore_tty();
+void tty_init(char *comdev, tcflag_t speed);
+size_t read_tty(uint8_t *buff, size_t length);
+int write_tty(uint8_t *buff, size_t length);
+
+int str2double(double *num, const char *str);
+
+#endif // __USEFULL_MACROS_H__