Big job done. Add common (with SBIG all-sky) FITS file storage.

Makefile

@@ -1,9 +1,9 @@
 # run `make DEF=...` to add extra defines
 PROGRAM := boltwood
-LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all
+LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all -pthread
 SRCS := $(wildcard *.c)
 DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111
-DEFINES += -DEBUG
+#DEFINES += -DEBUG
 OBJDIR := mk
 CFLAGS += -O2 -Wall -Werror -Wextra -Wno-trampolines -std=gnu99
 OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o))

allsky_logger/Makefile

@@ -0,0 +1,45 @@
+# run `make DEF=...` to add extra defines
+PROGRAM := allsky_logger
+LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all
+LDFLAGS += -lcfitsio
+SRCS := $(wildcard *.c)
+DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111
+OBJDIR := mk
+CFLAGS += -O2 -Wall -Wextra -Wno-trampolines -std=gnu99
+DEFINES += -DEBUG
+#CFLAGS += -Werror
+OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o))
+DEPS := $(OBJS:.o=.d)
+CC = gcc
+#CXX = g++
+
+
+all : $(OBJDIR) $(PROGRAM)
+
+$(PROGRAM) : $(OBJS)
+	@echo -e "\t\tLD $(PROGRAM)"
+	$(CC) $(LDFLAGS) $(OBJS) -o $(PROGRAM)
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+ifneq ($(MAKECMDGOALS),clean)
+-include $(DEPS)
+endif
+
+$(OBJDIR)/%.o: %.c
+	@echo -e "\t\tCC $<"
+	$(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $<
+
+clean:
+	@echo -e "\t\tCLEAN"
+	@rm -f $(OBJS) $(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

allsky_logger/Readme.md

@@ -0,0 +1,11 @@
+Logger for SBIG all-sky 
+====================
+
+Store raw FITS images from SBIG FITS dumps adding to headers cloud sensor
+information.
+
+Files stored in subdirectories as ${PWD}/YYYY/MM/DD/hhmmss.fits
+
+The original FITS file should be rewrited by SBIG daemon, this daemon watch
+for changes using inotify and as only file changed, store it appending boltwood
+data.

allsky_logger/cmdlnopts.c

@@ -0,0 +1,86 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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;
+
+#define DEFAULT_COMDEV  "/dev/ttyUSB0"
+//            DEFAULTS
+// default global parameters
+glob_pars const Gdefault = {
+    .cwd = NULL,            // current working directory
+    .port = "55555",        // port to listen boltwood data
+    .server = NULL,         // server name
+    .filename = NULL,       // input file name
+};
+
+/*
+ * Define command line options by filling structure:
+ *  name        has_arg     flag    val     type        argptr              help
+*/
+myoption cmdlnopts[] = {
+// common options
+    {"help",    NO_ARGS,    NULL,   'h',    arg_int,    APTR(&help),        _("show this help")},
+    {"port",    NEED_ARG,   NULL,   'p',    arg_string, APTR(&G.port),      _("port to connect (default: 55555)")},
+    {"address", NEED_ARG,   NULL,   'a',    arg_string, APTR(&G.server),    _("server name")},
+    {"filename",NEED_ARG,   NULL,   'i',    arg_string, APTR(&G.filename),  _("input FITS file name")},
+    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] [working dir]\n\n\tWhere args are:\n"));
+    // parse arguments
+    parseargs(&argc, &argv, cmdlnopts);
+    if(help) showhelp(-1, cmdlnopts);
+    if(argc > 0){ // the rest should be working directory
+        if(argc != 1){
+            red(_("Too many arguments:\n"));
+            for (i = 0; i < argc; i++)
+                printf("\t%s\n", argv[i]);
+            printf(_("Should be path to archive directory\n"));
+            signals(1);
+        }
+        G.cwd = argv[0];
+    }
+    return &G;
+}
+

allsky_logger/cmdlnopts.h

@@ -0,0 +1,41 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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"
+#include "term.h"
+
+/*
+ * here are some typedef's for global data
+ */
+typedef struct{
+    char *port;             // port to connect
+    char *cwd;              // change working directory to given
+    char *server;           // server name
+    char *filename;         // input file name
+} glob_pars;
+
+
+glob_pars *parse_args(int argc, char **argv);
+#endif // __CMDLNOPTS_H__

allsky_logger/imfunctions.c

@@ -0,0 +1,233 @@
+/*
+ *                                                                                                  geany_encoding=koi8-r
+ * imfunctions.c - functions to work with image
+ *
+ * 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 <strings.h> // strncasecmp
+#include <math.h>    // sqrt
+#include <time.h>    // time, gmtime etc
+#include <fitsio.h>  // save fits
+#include <libgen.h>  // basename
+#include <sys/stat.h>// utimensat
+#include <fcntl.h>   // AT_...
+#include <fitsio.h>
+#include <sys/sendfile.h> // sendfile
+
+#include "usefull_macros.h"
+#include "imfunctions.h"
+#include "term.h"
+#include "socket.h"
+
+/**
+ * All image-storing functions modify ctime of saved files to be the time of
+ * exposition start!
+ */
+void modifytimestamp(char *filename, time_t tv_sec){
+    if(!filename) return;
+    struct timespec times[2];
+    memset(times, 0, 2*sizeof(struct timespec));
+    times[0].tv_nsec = UTIME_OMIT;
+    times[1].tv_sec = tv_sec; // change mtime
+    if(utimensat(AT_FDCWD, filename, times, 0)) WARN(_("Can't change timestamp for %s"), filename);
+}
+
+/**
+ * Test if `name` is a fits file with 2D image
+ * @return 1 if all OK
+ */
+int test_fits(char *name){
+    fitsfile *fptr;
+    int status = 0, nfound, ret = 0;
+    long naxes[2];
+    if(fits_open_file(&fptr, name, READONLY, &status)){
+        goto retn;
+    }
+    // test image size
+    if(fits_read_keys_lng(fptr, "NAXIS", 1, 2, naxes, &nfound, &status)){
+        goto retn;
+    }
+    if(naxes[0] > 0 && naxes[1] > 0) ret = 1;
+retn:
+    if(status) fits_report_error(stderr, status);
+    fits_close_file(fptr, &status);
+    return ret;
+}
+
+
+/**
+ * copy FITS file with absolute path 'oldname' to 'newname' in current dir (using sendfile)
+ * @return 0 if all OK
+ *
+static int copyfile(char *oldname, char *newname){
+    struct stat st;
+    int ret = 1, ifd = -1, ofd = -1;
+    if(stat(oldname, &st) || !S_ISREG(st.st_mode)){
+        WARN("stat()");
+        goto rtn;
+    }
+    ifd = open(oldname, O_RDONLY);
+    ofd = open(newname, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH); // rewrite existing files
+    if(ifd < 0 || ofd < 0){
+        WARN("open()");
+        goto rtn;
+    }
+    posix_fadvise(ifd, 0, 0, POSIX_FADV_SEQUENTIAL); // tell kernel that we want to copy file -> sequential
+    posix_fadvise(ofd, 0, 0, POSIX_FADV_SEQUENTIAL);
+    ssize_t bytes = sendfile(ofd, ifd, NULL, st.st_size);
+    if(bytes < 0){
+        WARN("sendfile()");
+        goto rtn;
+    }
+    if(bytes == st.st_size) ret = 0;
+    DBG("copy %s -> %s %ssuccesfull", oldname, newname, ret ? "un" : "");
+rtn:
+    if(ifd > 0) close(ifd);
+    if(ofd > 0) close(ofd);
+    return ret;
+}*/
+
+static void mymkdir(char *name){
+    if(mkdir(name, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)){
+        if(errno != EEXIST)
+            ERR("mkdir()");
+    }
+    DBG("mkdir(%s)", name);
+}
+
+static void gotodir(char *relpath){ // create directory structure
+    if(chdir(relpath)){ // can't chdir -> test
+        if(errno != ENOENT) ERR("Can't chdir");
+    }else return;
+    // no such directory -> create it
+    char *p = relpath;
+    for(; *p; ++p){
+        if(*p == '/'){
+            *p = 0;
+            mymkdir(relpath);
+            *p = '/';
+        }
+    }
+    mymkdir(relpath);
+    if(-1 == chdir(relpath)) ERR("chdir()");
+}
+
+#define TRYFITS(f, ...)                     \
+do{ int status = 0;                         \
+    f(__VA_ARGS__, &status);                \
+    if (status){                            \
+        fits_report_error(stderr, status);  \
+        goto ret;}                          \
+}while(0)
+#define WRITEIREC(k, v, c)                                   \
+do{ int status = 0;                                          \
+    snprintf(record, FLEN_CARD, "%-8s=%21ld / %s", k, v, c); \
+    fits_write_record(ofptr, record, &status);               \
+}while(0)
+#define WRITEDREC(k, v, c)                                  \
+do{ int status = 0;                                         \
+    snprintf(record, FLEN_CARD, "%-8s=%21g / %s", k, v, c); \
+    fits_write_record(ofptr, record, &status);              \
+}while(0)
+
+
+/**
+ * Try to store given FITS file adding boltwood's header
+ * @param name (i) - full path to FITS file
+ * @param data (i) - boltwood's header data
+ * file stored in current directory under YYYY/MM/DD/hh:mm:ss.fits.gz
+ * @return file descriptor for new notifications
+ */
+int store_fits(char *name, datarecord *data){
+    DBG("Try to store %s", name);
+    double t0 = dtime();
+    long modtm = 0; // modification time - to change later
+    char oldwd[PATH_MAX];
+    fitsfile *fptr, *ofptr;
+    int nkeys, bitpix, naxis;
+    long naxes[2];
+    uint16_t *imdat = NULL;
+    TRYFITS(fits_open_file, &fptr, name, READONLY);
+    TRYFITS(fits_get_img_param, fptr, 2, &bitpix, &naxis, naxes);
+    TRYFITS(fits_get_hdrspace, fptr, &nkeys, NULL);
+    DBG("%d keys", nkeys);
+    green("open & get hdr: %gs\n", dtime() - t0);
+    char dateobs[FLEN_KEYWORD], timeobs[FLEN_KEYWORD];
+    TRYFITS(fits_read_key, fptr, TSTRING, "DATE-OBS", dateobs, NULL);
+    DBG("DATE-OBS: %s", dateobs);
+    TRYFITS(fits_read_key, fptr, TSTRING, "START", timeobs, NULL);
+    DBG("START: %s", timeobs);
+    TRYFITS(fits_read_key, fptr, TLONG, "UNIXTIME", &modtm, NULL);
+    DBG("MODTM: %ld", modtm);
+    if(!getcwd(oldwd, PATH_MAX)) ERR("getcwd()");
+    DBG("Current working directory: %s", oldwd);
+    green("+ got headers: %gs\n", dtime() - t0);
+    gotodir(dateobs);
+    char newname[PATH_MAX];
+    snprintf(newname, PATH_MAX, "%s.fits.gz", timeobs);
+    // remove if exists
+    unlink(newname);
+    TRYFITS(fits_create_file, &ofptr, newname);
+    TRYFITS(fits_create_img, ofptr, bitpix, naxis, naxes);
+    // copy all keywords
+    int i, status;
+    char record[81];
+    // copy all the user keywords (not the structural keywords)
+    DBG("got %d user keys, copy them", nkeys);
+    for(i = 1; i <= nkeys; ++i){
+        status = 0;
+        fits_read_record(fptr, i, record, &status);
+        DBG("status: %d", status);
+        if(!status && fits_get_keyclass(record) > TYP_CMPRS_KEY)
+            fits_write_record(ofptr, record, &status);
+        else
+            fits_report_error(stderr, status);
+    }
+    DBG("Boltwood data");
+    // now the file copied -> add header from Boltwood's sensor
+    while(data->varname){
+        if(data->type == INTEGR){
+            WRITEIREC(data->keyname, data->data.i, data->comment);
+        }else{
+           WRITEDREC(data->keyname, data->data.d, data->comment);
+        }
+        ++data;
+    }
+    long npix = naxes[0]*naxes[1];
+    imdat = MALLOC(uint16_t, npix);
+    int anynul = 0;
+    TRYFITS(fits_read_img, fptr, TUSHORT, 1, npix, NULL, imdat, &anynul);
+    DBG("read, anynul = %d", anynul);
+    TRYFITS(fits_write_img, ofptr, TUSHORT, 1, npix, imdat);
+ret:
+    FREE(imdat);
+    status = 0;
+    if(fptr)  fits_close_file(fptr, &status);
+    status = 0;
+    if(ofptr){
+        fits_close_file(ofptr, &status);
+        modifytimestamp(newname, (time_t)modtm);
+    }
+    // as cfitsio removes old file instead of trunkate it, we need to refresh inotify every time!
+    int fd = watch_fits(name);
+    if(chdir(oldwd)){ // return back to BD root directory
+        ERR("Can't chdir");
+    };
+   return fd;
+}

allsky_logger/imfunctions.h

@@ -0,0 +1,32 @@
+/*
+ *                                                                                                  geany_encoding=koi8-r
+ * imfunctions.h
+ *
+ * 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 __IMFUNCTIONS_H__
+#define __IMFUNCTIONS_H__
+#include "socket.h"
+#include "cmdlnopts.h"
+
+int test_fits(char *name);
+int store_fits(char *name, datarecord *data);
+
+#endif // __IMFUNCTIONS_H__

allsky_logger/main.c

@@ -0,0 +1,45 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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 <sys/wait.h>
+#include <sys/prctl.h>
+#include <signal.h>
+#include "cmdlnopts.h"
+#include "imfunctions.h"
+#include "socket.h"
+
+void signals(int signo){
+    exit(signo);
+}
+
+int main(int argc, char **argv){
+    initial_setup();
+    signal(SIGTERM, signals); // kill (-15) - quit
+    signal(SIGHUP, SIG_IGN);  // hup - ignore
+    signal(SIGINT, signals);  // ctrl+C - quit
+    signal(SIGQUIT, signals); // ctrl+\ - quit
+    signal(SIGTSTP, SIG_IGN); // ignore ctrl+Z
+    glob_pars *G = parse_args(argc, argv);
+    if(!G->server) ERRX(_("Please, specify server name"));
+    if(!G->filename) ERRX(_("Please, specify the name of input FITS file"));
+    daemonize(G);
+    return 0;
+}

allsky_logger/parseargs.c

@@ -0,0 +1,497 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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 && s1 && s2){ // both have short arg
+        return (s1 - s2);
+    }else if((f1 != NULL || !s1) && (f2 != NULL || !s2)){ // both don't have short arg - sort by long
+        return strcmp(l1, l2);
+    }else{ // only one have short arg -- return it
+        if(f2 || !s2) 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;
+}

allsky_logger/parseargs.h

@@ -0,0 +1,124 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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__

allsky_logger/socket.c

@@ -0,0 +1,349 @@
+/*
+ *                                                                                                  geany_encoding=koi8-r
+ * socket.c - socket IO
+ *
+ * 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 <netdb.h>      // addrinfo
+#include <arpa/inet.h>  // inet_ntop
+#include <limits.h>     // INT_xxx
+#include <signal.h>     // pthread_kill
+#include <unistd.h>     // daemon
+#include <sys/wait.h>   // wait
+#include <sys/prctl.h>  // prctl
+#include <sys/inotify.h>// inotify_init1
+#include <poll.h>       // pollfd
+
+#include "usefull_macros.h"
+#include "socket.h"
+#include "imfunctions.h"
+
+#define BUFLEN    (1024)
+// Max amount of connections
+#define BACKLOG   (30)
+
+// keyname, comment, type, data
+static datarecord boltwood_data[] = {
+    {"humidstatTempCode"         , "HSCODE"  , "hum. and ambient temp. sensor code (0 - OK)"    , INTEGR, {0}},
+    {"rainCond"                  , "RAINCOND", "rain sensor conditions (1 - no, 2 - rain)"      , INTEGR, {0}},
+    {"skyMinusAmbientTemperature", "TSKYAMB" , "Tsky-Tamb (degrC)"                              , DOUBLE, {0}},
+    {"ambientTemperature"        , "TAMB"    , "ambient temperature (degrC)"                    , DOUBLE, {0}},
+    {"windSpeed"                 , "WIND"    , "wind speed (m/s)"                               , DOUBLE, {0}},
+    {"wetState"                  , "WETSTATE", "wet sensor value (0 - dry, 1 - wet)"            , INTEGR, {0}},
+    {"relHumid"                  , "HUMIDITY", "relative humidity in %"                         , INTEGR, {0}},
+    {"dewPointTemperature"       , "DEWPOINT", "dew point temperature (degrC)"                  , DOUBLE, {0}},
+    {"caseTemperature"           , "TCASE"   , "thermopile case temperature (degrC)"            , DOUBLE, {0}},
+    {"rainHeaterState"           , "RHTRSTAT", "state of rain sensor heater (1 - OK)"           , INTEGR, {0}},
+    {"powerVoltage"              , "PWRVOLT" , "power voltage value (V)"                        , DOUBLE, {0}},
+    {"anemometerTemeratureDiff"  , "ANEMTDIF", "anemometer tip temperature difference(degrC)"   , DOUBLE, {0}},
+    {"wetnessDrop"               , "WETDROP" , "rain drops count for this cycle"                , INTEGR, {0}},
+    {"wetnessAvg"                , "WETAWG"  , "wetness osc. count diff. from base dry value"   , INTEGR, {0}},
+    {"wetnessDry"                , "WETDRY"  , "wetness osc. dry count diff. from base value"   , INTEGR, {0}},
+    {"daylightADC"               , "DAYADC"  , "daylight photodiode raw A/D output"             , INTEGR, {0}},
+    {"tmsrment"                  , "TBOLTWD" , "Boltwood's sensor measurement time (UNIX TIME)" , INTEGR, {0}},
+    {NULL, NULL, NULL, 0, {0}}
+};
+
+/**
+ * Find parameter `par` in pairs "parameter=value"
+ * if found, return pointer to `value`
+ */
+static char *findpar(const char *str, const char *par){
+    size_t L = strlen(par);
+    char *f = strstr((char*)str, par);
+    if(!f) return NULL;
+    f += L;
+    if(*f != '=') return NULL;
+    return (f + 1);
+}
+/**
+ * get integer & double `parameter` value from string `str`, put value to `ret`
+ * @return 1 if all OK
+ */
+static int getintpar(const char *str, const char *parameter, int64_t *ret){
+    int64_t tmp;
+    char *endptr;
+    if(!(str = findpar(str, parameter))) return 0;
+    tmp = strtol(str, &endptr, 0);
+    if(endptr == str || *str == 0 )
+        return 0;
+    if(ret) *ret = tmp;
+    return 1;
+}
+static int getdpar(const char *str, const char *parameter, double *ret){
+    double tmp;
+    char *endptr;
+    if(!(str = findpar(str, parameter))) return 0;
+    tmp = strtod(str, &endptr);
+    if(endptr == str || *str == 0)
+        return 0;
+    if(ret) *ret = tmp;
+    return 1;
+}
+
+/**
+ * Boltwood's sensor data parser
+ * @param buf  (i) - zero-terminated text buffer with data received
+ * @param data (o) - boltwood data (allocated here if *data == NULL) - unchanged if input buffer wrong
+ */
+static void parse_data(char *buf, datarecord **data){
+    if(!data) return;
+    if(!*data){ // copy boltwood_data[] array
+        *data = MALLOC(datarecord, sizeof(boltwood_data));
+        datarecord *rec = boltwood_data, *optr = *data;
+        while(rec->varname){
+            optr->varname = strdup(rec->varname);
+            optr->keyname = strdup(rec->keyname);
+            optr->comment = strdup(rec->comment);
+            optr->type = rec->type;
+            ++rec; ++optr;
+        }
+    }
+    datarecord *rec = boltwood_data;
+    int status = 1; // 1 - good, 0 - bad
+    while(rec->varname){
+        switch(rec->type){
+            case INTEGR:
+                if(!getintpar(buf, rec->varname, &rec->data.i)){
+                    status = 0;
+                    goto ewhile;
+                }
+            break;
+            case DOUBLE:
+            default:
+                if(!getdpar(buf, rec->varname, &rec->data.d)){
+                    status = 0;
+                    goto ewhile;
+                }
+        }
+        ++rec;
+    }
+ewhile:
+    if(status){ // all fields received - copy them
+        rec = boltwood_data;
+        datarecord *optr = *data;
+        while(rec->varname){
+            optr->data = rec->data;
+            ++optr; ++rec;
+        }
+    }
+}
+
+/**
+ * wait for answer from socket
+ * @param sock - socket fd
+ * @return 0 in case of error or timeout, 1 in case of socket ready
+ */
+static int waittoread(int sock){
+    fd_set fds;
+    struct timeval timeout;
+    int rc;
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 100000; // wait not more than 100ms
+    FD_ZERO(&fds);
+    FD_SET(sock, &fds);
+    do{
+        rc = select(sock+1, &fds, NULL, NULL, &timeout);
+        if(rc < 0){
+            if(errno != EINTR){
+                WARN("select()");
+                return 0;
+            }
+            continue;
+        }
+        break;
+    }while(1);
+    if(FD_ISSET(sock, &fds)) return 1;
+    return 0;
+}
+
+/**
+ * Open given FITS file, check it and add to inotify
+ * THREAD UNSAFE!!!
+ * @return inotify file descriptor
+ */
+int watch_fits(char *name){
+    static int oldfd = -1, oldwd = -1;
+    if(oldfd > 0 && oldwd > 0){
+        inotify_rm_watch(oldfd, oldwd);
+        oldfd = -1, oldwd = -1;
+    }
+    if(!test_fits(name)) ERRX(_("File %s is not FITS file with 2D image!"), name);
+    int fd;
+    fd = inotify_init1(IN_NONBLOCK);
+    if(fd == -1) ERR("inotify_init1()");
+    oldfd = fd;
+    FILE* f = fopen(name, "r");
+    if(!f) ERR("fopen()"); // WTF???
+    fclose(f);
+    if((oldwd = inotify_add_watch(fd, name, IN_CLOSE_WRITE)) < 0)
+        ERR("inotify_add_watch()");
+    DBG("file %s added to inotify", name);
+    return fd;
+}
+
+/**
+ * test if user can write something to path & make CWD
+ */
+static void test_path(char *path){
+    if(path){
+        if(chdir(path)) ERR("Can't chdir(%s)", path);
+    }
+    if(access("./", W_OK)) ERR("access()");
+    DBG("OK, user can write to given path");
+}
+
+/**
+ * Client daemon itself
+ * @param G - global parameters
+ * @param infd - inotify file descriptor
+ * @param sock - socket's file descriptor
+ */
+static void client_(char *FITSpath, int infd, int sock){
+    if(sock < 0) return;
+    size_t Bufsiz = BUFLEN;
+    char *recvBuff = MALLOC(char, Bufsiz);
+    datarecord *last_good_msrment = NULL;
+    int poll_num;
+    struct pollfd fds;
+    fds.fd = infd;
+    fds.events = POLLIN;
+    char buf[256];
+    void rlc(size_t newsz){
+        if(newsz >= Bufsiz){
+            Bufsiz += 1024;
+            recvBuff = realloc(recvBuff, Bufsiz);
+            if(!recvBuff){
+                WARN("realloc()");
+                return;
+            }
+            DBG("Buffer reallocated, new size: %zd\n", Bufsiz);
+        }
+    }
+    DBG("Start polling");
+    while(1){
+        poll_num = poll(&fds, 1, 1);
+        if(poll_num == -1){
+           if (errno == EINTR)
+               continue;
+           ERR("poll()");
+           return;
+        }
+        if(poll_num > 0){
+            DBG("changed?");
+            if(fds.revents & POLLIN){
+                ssize_t len = read(infd, &buf, sizeof(buf));
+                if (len == -1 && errno != EAGAIN) {
+                   ERR("read");
+                   return;
+                }else{
+                    DBG("file changed");
+                    usleep(100000); // wait a little for file changes
+                    fds.fd = store_fits(FITSpath, last_good_msrment);
+                }
+            }
+        }
+        if(!waittoread(sock)) continue;
+        size_t offset = 0;
+        do{
+            rlc(offset);
+            ssize_t n = read(sock, &recvBuff[offset], Bufsiz - offset);
+            if(!n) break;
+            if(n < 0){
+                WARN("read");
+                break;
+            }
+            offset += n;
+        }while(waittoread(sock));
+        if(!offset){
+            WARN("Socket closed\n");
+            return;
+        }
+        rlc(offset);
+        recvBuff[offset] = 0;
+        DBG("read %zd bytes", offset);
+        parse_data(recvBuff, &last_good_msrment);
+    }
+}
+
+/**
+ * Connect to socket and run daemon service
+ */
+void daemonize(glob_pars *G){
+    char resolved_path[PATH_MAX];
+    // get full path to FITS file
+    if(!realpath(G->filename, resolved_path)) ERR("realpath()");
+    // open FITS file & add it to inotify
+    int fd = watch_fits(G->filename);
+    // CD to archive directory if user wants
+    test_path(G->cwd);
+    // run fork before socket opening to prevent daemon's death if there's no network
+    #ifndef EBUG
+    green("Daemonize\n");
+    if(daemon(1, 0)){
+        ERR("daemon()");
+    while(1){ // guard for dead processes
+        pid_t childpid = fork();
+        if(childpid){
+            DBG("Created child with PID %d\n", childpid);
+            wait(NULL);
+            WARNX("Child %d died\n", childpid);
+            sleep(1);
+        }else{
+            prctl(PR_SET_PDEATHSIG, SIGTERM); // send SIGTERM to child when parent dies
+            break; // go out to normal functional
+        }
+    }}
+    #endif
+    int sock = -1;
+    struct addrinfo hints, *res, *p;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_PASSIVE;
+    DBG("connect to %s:%s", G->server, G->port);
+    if(getaddrinfo(G->server, G->port, &hints, &res) != 0){
+        ERR("getaddrinfo");
+    }
+    struct sockaddr_in *ia = (struct sockaddr_in*)res->ai_addr;
+    char str[INET_ADDRSTRLEN];
+    inet_ntop(AF_INET, &(ia->sin_addr), str, INET_ADDRSTRLEN);
+    DBG("canonname: %s, port: %u, addr: %s\n", res->ai_canonname, ntohs(ia->sin_port), str);
+    // loop through all the results and bind to the first we can
+    for(p = res; p != NULL; p = p->ai_next){
+        if((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1){
+            WARN("socket");
+            continue;
+        }
+        if(connect(sock, p->ai_addr, p->ai_addrlen) == -1){
+            WARN("connect()");
+            close(sock);
+            continue;
+        }
+        break; // if we get here, we have a successfull connection
+    }
+    if(p == NULL){
+        // looped off the end of the list with no successful bind
+        ERRX("failed to bind socket");
+    }
+    freeaddrinfo(res);
+    client_(resolved_path, fd, sock);
+    close(sock);
+    signals(0);
+}

allsky_logger/socket.h

@@ -0,0 +1,51 @@
+/*
+ *                                                                                                  geany_encoding=koi8-r
+ * socket.h
+ *
+ * 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 __SOCKET_H__
+#define __SOCKET_H__
+
+#include "usefull_macros.h"
+#include "cmdlnopts.h"
+
+typedef enum{
+    INTEGR, // int64_t
+    DOUBLE  // double
+} datatype;
+
+typedef union{
+    double d;
+    int64_t i;
+} bdata;
+
+typedef struct{
+    const char *varname;    // variable name as it comes from socket
+    const char *keyname;    // FITS keyword name
+    const char *comment;    // comment to FITS file
+    datatype type;          // type of data
+    bdata data;             // data itself
+} datarecord;
+
+void daemonize(glob_pars *G);
+int watch_fits(char *name);
+
+#endif // __SOCKET_H__

allsky_logger/usefull_macros.c

@@ -0,0 +1,385 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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){
+    if(comfd == -1){ // not opened
+        if(!comdev){
+            WARNX("comdev == NULL");
+            signals(11);
+        }
+        DBG("Open port...");
+        do{
+            comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK);
+        }while (comfd == -1 && errno == EINTR);
+        if(comfd < 0){
+            WARN(_("Can't open port %s"),comdev);
+            signals(2);
+        }
+        DBG("OK\nGet current settings...");
+        if(ioctl(comfd, TCGETA, &oldtty) < 0){  // Get settings
+            /// "îÅ ÍÏÇÕ ÐÏÌÕÞÉÔØ ÎÁÓÔÒÏÊËÉ"
+            WARN(_("Can't get settings"));
+            signals(2);
+        }
+        DBG("Make exclusive");
+        // make exclusive open
+        if(ioctl(comfd, TIOCEXCL)){
+            WARN(_("Can't do exclusive open"));
+            close(comfd);
+            signals(2);
+        }
+    }
+    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){
+    if(comfd < 0) return 0;
+    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(const uint8_t *buff, size_t length){
+    if(comfd < 0) return 1;
+    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;
+}

allsky_logger/usefull_macros.h

@@ -0,0 +1,140 @@
+/*                                                                                                  geany_encoding=koi8-r
+ * 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(const uint8_t *buff, size_t length);
+
+int str2double(double *num, const char *str);
+
+#endif // __USEFULL_MACROS_H__

cmdlnopts.c

@@ -38,8 +38,9 @@ glob_pars  G;
 glob_pars const Gdefault = {
     .device = DEFAULT_COMDEV,
     .port = "55555",
+    .terminal = 0,
     .rest_pars = NULL,
-    .rest_pars_num = 0,
+    .rest_pars_num = 0
 };
 
 /*
@@ -50,7 +51,8 @@ myoption cmdlnopts[] = {
 // common options
     {"help",    NO_ARGS,    NULL,   'h',    arg_int,    APTR(&help),        _("show this help")},
     {"device",  NEED_ARG,   NULL,   'i',    arg_string, APTR(&G.device),    _("serial device name (default: " DEFAULT_COMDEV ")")},
-    {"port",    NEED_ARG,   NULL,   'p',    arg_string, APTR(&G.port),      _("port to connect (default: 4444)")},
+    {"port",    NEED_ARG,   NULL,   'p',    arg_string, APTR(&G.port),      _("port to connect (default: 55555)")},
+    {"terminal",NO_ARGS,    NULL,   't',    arg_int,    APTR(&G.terminal),  _("run as terminal")},
    end_option
 };
 

cmdlnopts.h

@@ -32,6 +32,7 @@
 typedef struct{
     char *device;           // serial device name
     char *port;             // port to connect
+    int terminal;           // run as terminal
     int rest_pars_num;      // number of rest parameters
     char** rest_pars;       // the rest parameters: array of char*
 } glob_pars;

main.c

@@ -21,6 +21,7 @@
 #include "usefull_macros.h"
 #include <signal.h>
 #include "cmdlnopts.h"
+#include "socket.h"
 
 void signals(int signo){
     restore_console();
@@ -38,7 +39,8 @@ int main(int argc, char **argv){
     glob_pars *G = parse_args(argc, argv);
 
     try_connect(G->device);
-    //daemonize(G->hostname, G->port);
+    if(check_sensor()) signals(15); // there's not Boltwood sensor connected
-    run_terminal();
+    if(G->terminal) run_terminal();
+    else daemonize(G->port);
     return 0;
 }

socket.c

@@ -37,6 +37,9 @@
 // Max amount of connections
 #define BACKLOG   (30)
 
+static uint64_t datctr = 0; // data portions counter
+static boltwood_data boltwood; // global structure with last data
+
 /**************** COMMON FUNCTIONS ****************/
 /**
  * wait for answer from socket
@@ -66,100 +69,63 @@ static int waittoread(int sock){
     return 0;
 }
 
-static uint8_t *findpar(uint8_t *str, char *par){
-    size_t L = strlen(par);
-    char *f = strstr((char*)str, par);
-    if(!f) return NULL;
-    f += L;
-    if(*f != '=') return NULL;
-    return (uint8_t*)(f + 1);
-}
-/**
- * get integer & double `parameter` value from string `str`, put value to `ret`
- * @return 1 if all OK
- */
-static long getintpar(uint8_t *str, char *parameter, long *ret){
-    long tmp;
-    char *endptr;
-    if(!(str = findpar(str, parameter))) return 0;
-    tmp = strtol((char*)str, &endptr, 0);
-    if(endptr == (char*)str || *str == 0 )
-        return 0;
-    if(ret) *ret = tmp;
-    DBG("get par: %s = %ld", parameter, tmp);
-    return 1;
-}
-static int getdpar(uint8_t *str, char *parameter, double *ret){
-    double tmp;
-    char *endptr;
-    if(!(str = findpar(str, parameter))) return 0;
-    tmp = strtod((char*)str, &endptr);
-    if(endptr == (char*)str || *str == 0)
-        return 0;
-    if(ret) *ret = tmp;
-    DBG("get par: %s = %g", parameter, tmp);
-    return 1;
-}
-
 /**************** SERVER FUNCTIONS ****************/
 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-/*
+int send_data(int sock, int webquery){
-int send_ima(int sock, int webquery){
+    DBG("webq=%d", webquery);
     uint8_t buf[BUFLEN10], *bptr = buf, obuff[BUFLEN];
-    ssize_t Len;
+    ssize_t L;
-    size_t rest = BUFLEN10, imS = storedima->W * storedima->H * sizeof(uint16_t);
+    size_t rest = BUFLEN10, Len = 0;
-    #define PUT(key, val) do{Len = snprintf((char*)bptr, rest, "%s=%i\n", key, (int)storedima->val); \
+    #define PUTI(val) do{L = snprintf((char*)bptr, rest, "%s=%d\n", #val, boltwood.val); \
-                if(Len > 0){rest -= Len; bptr += Len;}}while(0)
+                if(L > 0){rest -= L; bptr += L; Len += L;}}while(0)
-    PUT("binning", binning);
+    #define PUTD(val) do{L = snprintf((char*)bptr, rest, "%s=%.1f\n", #val, boltwood.val); \
-    if(storedima->binning == 0xff){
+                if(L > 0){rest -= L; bptr += L; Len += L;}}while(0)
-        PUT("subX", subframe->Xstart);
+    PUTI(humidstatTempCode);
-        PUT("subY", subframe->Xstart);
+    PUTI(rainCond);
-        PUT("subS", subframe->size);
+    PUTD(skyMinusAmbientTemperature);
-    }
+    PUTD(ambientTemperature);
-    Len = snprintf((char*)bptr, rest, "%s=%g\n", "exptime", storedima->exptime);
+    PUTD(windSpeed);
-    if(Len > 0){rest -= Len; bptr += Len;}
+    PUTI(wetState);
-    PUT("imtype", imtype);
+    PUTI(relHumid);
-    PUT("imW", W);
+    PUTD(dewPointTemperature);
-    PUT("imH", H);
+    PUTD(caseTemperature);
-    PUT("exposetime", exposetime);
+    PUTI(rainHeaterState);
-    Len = snprintf((char*)bptr, rest, "imdata=");
+    PUTD(powerVoltage);
-    if(Len){rest -= Len; bptr += Len;}
+    PUTD(anemometerTemeratureDiff);
-    if(rest < imS){
+    PUTI(wetnessDrop);
-        red("rest = %zd, need %zd\n", rest, imS);
+    PUTI(wetnessAvg);
-        return 0; // not enough memory - HOW???
+    PUTI(wetnessDry);
-    }
+    PUTI(daylightADC);
-    if(!memcpy(bptr, storedima->imdata, imS)){
+    L = snprintf((char*)bptr, rest, "tmsrment=%ld\n", boltwood.tmsrment);
-        WARN("memcpy()");
+    if(L > 0){rest -= L; bptr += L; Len += L;}
-        return 0;
+
-    }
-    rest -= imS;
     // OK buffer ready, prepare to send it
     if(webquery){
-        Len = snprintf((char*)obuff, BUFLEN,
+        L = snprintf((char*)obuff, BUFLEN,
             "HTTP/2.0 200 OK\r\n"
             "Access-Control-Allow-Origin: *\r\n"
             "Access-Control-Allow-Methods: GET, POST\r\n"
             "Access-Control-Allow-Credentials: true\r\n"
-            "Content-type: multipart/form-data\r\nContent-Length: %zd\r\n\r\n", Len);
+            "Content-type: text/plain\r\nContent-Length: %zd\r\n\r\n", Len);
-        if(Len < 0){
+        if(L < 0){
             WARN("sprintf()");
             return 0;
         }
-        if(Len != write(sock, obuff, Len)){
+        if(L != write(sock, obuff, L)){
             WARN("write");
             return 0;
         }
         DBG("%s", obuff);
     }
     // send data
-    size_t send = BUFLEN10 - rest;
+    red("send %zd bytes\n", Len);
-    red("send %zd bytes\n", send);
+    DBG("Buf: %s", buf);
-    if(send != (size_t)write(sock, buf, send)){
+    if(Len != (size_t)write(sock, buf, Len)){
         WARN("write()");
         return 0;
     }
     return 1;
-}*/
+}
 
 // search a first word after needle without spaces
 char* stringscan(char *str, char *needle){
@@ -178,44 +144,46 @@ char* stringscan(char *str, char *needle){
 void *handle_socket(void *asock){
     FNAME();
     int sock = *((int*)asock);
-    //int webquery = 0; // whether query is web or regular
+    int webquery = 0; // whether query is web or regular
     char buff[BUFLEN];
-    ssize_t readed;
+    uint64_t locctr = 0;
+    ssize_t rd;
     while(1){
         if(!waittoread(sock)){ // no data incoming
-           /* pthread_mutex_lock(&mutex);
+            DBG("datctr:%lu, locctr: %lu", datctr, locctr);
-                red("Send image, imctr = %ld, locctr = %ld\n", imctr, locctr);
+            pthread_mutex_lock(&mutex);
-                if(send_ima(sock, webquery)){
+            DBG("datctr:%lu, locctr: %lu", datctr, locctr);
-                    locctr = imctr;
+            if(datctr != locctr){
+                red("Send data, datctr = %ld, locctr = %ld\n", datctr, locctr);
+                if(send_data(sock, webquery)){
+                    locctr = datctr;
                     if(webquery){
                         pthread_mutex_unlock(&mutex);
                         break; // end of transmission
                     }
                 }
-            pthread_mutex_unlock(&mutex);*/
+            }
+            pthread_mutex_unlock(&mutex);
             continue;
         }
-        if(!(readed = read(sock, buff, BUFLEN))) continue;
+        if(!(rd = read(sock, buff, BUFLEN-1))) continue;
-        DBG("Got %zd bytes", readed);
+        DBG("Got %zd bytes", rd);
-        if(readed < 0){ // error or disconnect
+        if(rd < 0){ // error or disconnect
-            DBG("Nothing to read from fd %d (ret: %zd)", sock, readed);
+            DBG("Nothing to read from fd %d (ret: %zd)", sock, rd);
             break;
         }
         // add trailing zero to be on the safe side
-        buff[readed] = 0;
+        buff[rd] = 0;
         // now we should check what do user want
         char *got, *found = buff;
         if((got = stringscan(buff, "GET")) || (got = stringscan(buff, "POST"))){ // web query
-            //webquery = 1;
+            webquery = 1;
             char *slash = strchr(got, '/');
             if(slash) found = slash + 1;
             // web query have format GET /some.resource
         }
         // here we can process user data
-        printf("user send: %s\n", found);
+        printf("user send: %s\nfound=%s", buff,found);
-        long ii; double dd;
-        if(getdpar((uint8_t*)found, "exptime", &dd)) printf("exptime: %g\n", dd);
-        if(getintpar((uint8_t*)found, "somepar", &ii)) printf("somepar: %ld\n", ii);
     }
     close(sock);
     //DBG("closed");
@@ -263,6 +231,15 @@ static void daemon_(int sock){
             if(pthread_create(&sock_thread, NULL, server, (void*) &sock))
                 ERR("pthread_create()");
         }
+        // get data
+        boltwood_data b;
+        if(poll_sensor(&b) == 1){
+            pthread_mutex_lock(&mutex);
+            memcpy(&boltwood, &b, sizeof(boltwood_data));
+            ++datctr;
+            pthread_mutex_unlock(&mutex);
+        }
+        usleep(1000); // sleep a little or thread's won't be able to lock mutex
     }while(1);
 }
 

term.c

@@ -71,24 +71,6 @@ static uint16_t calcCRC16(const uint8_t *buf, int nBytes){
     return crc;
 }
 
-/**
- * Send command by serial port, return 0 if all OK
- *static uint8_t last_chksum = 0;
-int send_data(uint8_t *buf, int len){
-    if(len < 1) return 1;
-    uint8_t chksum = 0, *ptr = buf;
-    int l;
-    for(l = 0; l < len; ++l)
-        chksum ^= ~(*ptr++) & 0x7f;
-    DBG("send: %s (chksum: 0x%X)", buf, chksum);
-    if(write_tty(buf, len)) return 1;
-    DBG("cmd sent");
-    if(write_tty(&chksum, 1)) return 1;
-    DBG("checksum sent");
-    last_chksum = chksum;
-    return 0;
-}*/
-
 // send single symbol without CRC
 int send_symbol(uint8_t cmd){
     uint8_t s[5] = {FRAME_START, cmd, '\n', REQUEST_POLL, 0};
@@ -150,8 +132,8 @@ int send_cmd(uint8_t cmd){
  * Try to connect to `device` at given speed (or try all speeds, if speed == 0)
  * @return connection speed if success or 0
  */
-int try_connect(char *device){
+void try_connect(char *device){
-    if(!device) return 0;
+    if(!device) return;
     uint8_t tmpbuf[4096];
     green(_("Connecting to %s... "), device);
     fflush(stdout);
@@ -159,7 +141,6 @@ int try_connect(char *device){
     read_tty(tmpbuf, 4096); // clear rbuf
     green("Ok!");
     printf("\n\n");
-    return 0;
 }
 
 // check CRC and return 0 if all OK
@@ -234,3 +215,151 @@ void run_terminal(){
     }
 }
 
+/**
+ * parser
+ * @param buf (i) - data frame from sensor
+ * @param L       - its length
+ * @param d       - structure to fill
+ *  1. humidstatTempCode
+ *  2. cloudCond
+ *  3. windCond
+ *  4. rainCond
+ *  5. skyCond
+ *  6. roofCloseRequested
+ *  7. skyMinusAmbientTemperature
+ *  8. ambientTemperature
+ *  9. windSpeed
+ * 10. wetSensor
+ * 11. rainSensor
+ * 12. relativeHumidityPercentage
+ * 13. dewPointTemperature
+ * 14. caseTemperature
+ * 15. rainHeaterPercentage
+ * 16. blackBodyTemperature
+ * 17. rainHeaterState
+ * 18. powerVoltage
+ * 19. anemometerTemeratureDiff
+ * 20. wetnessDrop
+ * 21. wetnessAvg
+ * 22. wetnessDry
+ * 23. rainHeaterPWM
+ * 24. anemometerHeaterPWM
+ * 25. thermopileADC
+ * 26. thermistorADC
+ * 27. powerADC
+ * 28. blockADC
+ * 29. anemometerThermistorADC
+ * 30. davisVaneADC
+ * 31. dkMPH
+ * 32. extAnemometerDirection
+ * 33. rawWetnessOsc
+ * 34. dayCond
+ * 35. daylightADC
+ */
+static void parse_answer(uint8_t *buf, size_t L, boltwood_data *d){
+    if(!buf || !L || !d) return;
+    char *endptr;
+    int getint(){
+        if(!buf || !*buf) return -999;
+        long l = strtol((char*)buf, &endptr, 10);
+        if(endptr == (char*)buf) endptr = strchr((char*)buf, ' '); // omit non-number
+        buf = (uint8_t*)endptr;
+        while(*buf == ' ') ++buf;
+        return (int)l;
+    }
+    double getdbl(){
+        if(!buf || !*buf) return -999.;
+        double d = strtod((char*)buf, &endptr);
+        if(endptr == (char*)buf) endptr = strchr((char*)buf, ' '); // omit non-number
+        buf = (uint8_t*)endptr;
+        while(*buf == ' ') ++buf;
+        return d;
+    }
+    d->tmsrment = time(NULL);
+    d->humidstatTempCode = getint(); // 1. humidstatTempCode
+    DBG("buf: %s", buf);
+    getint(); getint();
+    d->rainCond = getint(); // 4. rainCond
+    DBG("buf: %s", buf);
+    getint(); getint();
+    DBG("buf: %s", buf);
+    d->skyMinusAmbientTemperature = getdbl(); // 7. skyMinusAmbientTemperature
+    d->ambientTemperature = getdbl(); // 8. ambientTemperature
+    d->windSpeed = getdbl(); // 9. windSpeed
+    switch(*buf){ // 10. wetSensor
+        case 'N':
+            d->wetState = 0;
+        break;
+        case 'W':
+            d->wetState = 1;
+        break;
+        case 'w':
+            d->wetState = -1;
+        break;
+        default:
+            d->wetState = -2;
+    }
+    getint(); // go to pos 11
+    getint(); d->relHumid = getint(); // 12. relativeHumidityPercentage
+    d->dewPointTemperature = getdbl(); // 13. dewPointTemperature
+    d->caseTemperature = getdbl(); // 14. caseTemperature
+    getint(); getdbl();
+    d->rainHeaterState = getint(); // 17. rainHeaterState
+    d->powerVoltage = getdbl();  // 18. powerVoltage
+    d->anemometerTemeratureDiff = getdbl(); // 19. anemometerTemeratureDiff
+    d->wetnessDrop = getint(); // 20. wetnessDrop
+    d->wetnessAvg = getint(); // 21. wetnessAvg
+    d->wetnessDry = getint(); // 22. wetnessDry
+    while(*buf) ++buf; // roll to end
+    while(*buf != ' ') --buf; ++buf;
+    d->daylightADC = getint(); // 35. daylightADC
+}
+
+/**
+ * Poll sensor for new dataportion
+ * @return: 0 if no data received, -1 if invalid data received, 1 if valid data received
+ */
+int poll_sensor(boltwood_data *d){
+    if(!d) return -1;
+    uint8_t buf[BUFLEN], cmd;
+    size_t L;
+    cmd = REQUEST_POLL;
+    if(write_tty(&cmd, 1)) // start polling
+        WARNX(_("can't request poll"));
+    if((L = read_string(buf, BUFLEN))){
+        if(L > 5 && buf[1] == ANS_DATA_FRAME){
+            if(chk_crc(&buf[2])){
+                WARNX(_("Bad CRC in input data"));
+                send_symbol(CMD_NACK);
+                return -1;
+            }
+            buf[L-5] = 0;
+            send_symbol(CMD_ACK);
+            printf("got: %s\n", &buf[4]);
+            if(buf[2] == DATAFRAME_SENSOR_REPORT){
+                parse_answer(&buf[3], L, d);
+                return 1;
+            }
+        }else if(L > 1){
+            if(buf[1] == ANS_POLLING_FRAME || buf[2] == ANS_POLLING_FRAME){ // polling - send command or ack
+                send_symbol(CMD_ACK);
+            }
+        }
+    }
+    return 0;
+}
+
+/**
+ * check whether connected device is boltwood sensor
+ * @return 1 if NO
+ */
+int check_sensor(){
+    double t0 = dtime();
+    boltwood_data b;
+    green(_("Check if there's a sensor...\n"));
+    while(dtime() - t0 < POLLING_TMOUT){
+        if(poll_sensor(&b) == 1) return 0;
+    }
+    WARNX(_("No sensor detected!"));
+    return 1;
+}

term.h

@@ -22,6 +22,14 @@
 #ifndef __TERM_H__
 #define __TERM_H__
 
+#define FRAME_MAX_LENGTH        (300)
+#define MAX_MEMORY_DUMP_SIZE    (0x800 * 4)
+// terminal timeout (seconds)
+#define     WAIT_TMOUT          (0.2)
+// boltwood polling timeout - 15 seconds
+#define     POLLING_TMOUT       (15.0)
+
+
 // communication errors
 typedef enum{
     TRANS_SUCCEED = 0,  // no errors
@@ -41,26 +49,44 @@ typedef enum{
     FRAME_END = '\n',
 } term_symbols;
 
-#define FRAME_MAX_LENGTH (300)
+// main structure with useful data from cloud sensor
-#define MAX_MEMORY_DUMP_SIZE (0x800 * 4)
+typedef struct{
+    int humidstatTempCode;
+    int rainCond;
+    double skyMinusAmbientTemperature;
+    double ambientTemperature;
+    double windSpeed;
+    int wetState; // 0 - dry, 1 - wet now, -1 - wet recently, -2 - unknown
+    int relHumid;
+    double dewPointTemperature;
+    double caseTemperature;
+    int rainHeaterState;
+    double powerVoltage;
+    double anemometerTemeratureDiff;
+    int wetnessDrop;
+    int wetnessAvg;
+    int wetnessDry;
+    int daylightADC;
+    time_t tmsrment; // measurement time
+} boltwood_data;
 
 
-// terminal timeout (seconds)
-#define     WAIT_TMOUT      (0.2)
-
 /******************************** Commands definition ********************************/
 #define CMD_ACK         'a'
 #define CMD_NACK        'n'
 
-
-
-
 /******************************** Answers definition ********************************/
 #define ANS_COMMAND_ACKED   'A'
 #define ANS_COMMAND_NACKED  'N'
 #define ANS_DATA_FRAME      'M'
 #define ANS_POLLING_FRAME   'P'
 
+/******************************** Data frame types ********************************/
+#define DATAFRAME_SENSOR_REPORT     'D'
+
 void run_terminal();
-int try_connect(char *device);
+void try_connect(char *device);
+int poll_sensor(boltwood_data *d);
+int check_sensor();
+
 #endif // __TERM_H__

usefull_macros.c

@@ -289,17 +289,24 @@ void restore_tty(){
 // init:
 void tty_init(char *comdev){
     DBG("\nOpen port...\n");
-    if ((comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){
+    do{
+        comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK);
+    }while (comfd == -1 && errno == EINTR);
+    if(comfd < 0){
         WARN("Can't use port %s\n",comdev);
-        ioctl(comfd, TCSANOW, &oldtty); // return TTY to previous state
+        signals(-1); // quit?
+    }
+    // make exclusive open
+    if(ioctl(comfd, TIOCEXCL)){
+        WARN(_("Can't do exclusive open"));
         close(comfd);
-        signals(0); // quit?
+        signals(2);
     }
     DBG(" OK\nGet current settings... ");
     if(ioctl(comfd,TCGETA,&oldtty) < 0){  // Get settings
         /// "îÅ ÍÏÇÕ ÐÏÌÕÞÉÔØ ÎÁÓÔÒÏÊËÉ"
         WARN(_("Can't get settings"));
-        signals(0);
+        signals(-1);
     }
     tty = oldtty;
     tty.c_lflag     = 0; // ~(ICANON | ECHO | ECHOE | ISIG)
@@ -310,7 +317,7 @@ void tty_init(char *comdev){
     if(ioctl(comfd,TCSETA,&tty) < 0){
         /// "îÅ ÍÏÇÕ ÕÓÔÁÎÏ×ÉÔØ ÎÁÓÔÒÏÊËÉ"
         WARN(_("Can't set settings"));
-        signals(0);
+        signals(-1);
     }
     DBG(" OK\n");
 }