verzweifelter Versuch es zu reparieren, back to master

.gitignore

@@ -6,5 +6,5 @@ cube/pubsubc.a
 test
 .bash_history
 .vscode
-tools/ENV
+
 

cube/Core/Src/main.c

@@ -98,7 +98,7 @@ int main(void)
   MX_SPI2_Init();
   MX_TIM1_Init();
   MX_USART1_UART_Init();
-  MX_IWDG_Init();
+  // MX_IWDG_Init();
   /* USER CODE BEGIN 2 */
   my_setup_2();
 

cube/User/Inc/networkAbstractionLayer_impl.h

@@ -2,11 +2,12 @@
 #define _NETWORK_ABSTRACTION_LAYER_IMPL_H_
 
 #include <stdint.h>
-#include <stdbool.h>
 
 uint64_t networkSntpQuery();
+
+
 int8_t networkUdpSend(char *hostname, uint16_t port, uint8_t *buf, uint16_t bufLen);
 void networkImplInit();
-bool isNetworkAvailable();
+
 
 #endif /* _NETWORK_ABSTRACTION_LAYER_IMPL_H_ */

cube/User/Inc/show.h

@@ -12,7 +12,7 @@ typedef enum {
     LED_BLUE
 } signalPin_t;
 
-typedef enum { ON, OFF, TOGGLE, BLINK, BLINK_FAST } signalAction_t;
+typedef enum { ON, OFF, TOGGLE, BLINK } signalAction_t;
 
 void showInit();
 void show(signalPin_t signalPin, signalAction_t action);

cube/User/Inc/wizHelper.h

@@ -7,9 +7,10 @@
 
 
 int wizInit();
-bool wizIsNetworkAvailable();
+bool isNetworkAvailable();
 uint8_t* wizGetIPAddress();
 bool wizDnsQuery(char *name, uint8_t *ip);
+uint64_t wizSntpQuery();
 
 
 #endif // _WIZHELPER_H_

cube/User/Src/counter.c

@@ -48,7 +48,7 @@ void counterMinuteTick(void *handle) {
             minuteBuffer->s.totalRunningHours = deviceStats->totalRunningHours;
             minuteBuffer->s.totalPowercycles = deviceStats->totalPowercycles;
             minuteBuffer->s.totalWatchdogResets = deviceStats->totalWatchdogResets;
-            minuteBuffer->s.version = strtoll(VERSION, NULL, 16);
+            minuteBuffer->s.version = strtol(VERSION, NULL, 16);
 
 
             memset(minuteBuffer->s.deviceId, 0, sizeof(minuteBuffer->s.deviceId));

cube/User/Src/networkAbstractionLayer.c

@@ -3,7 +3,6 @@
 #include <iwdg.h>
 #include <logger.h>
 #include <sinkStruct.h>
-#include <show.h>
 #include <config.h>
 
 #include <networkAbstractionLayer_impl.h>
@@ -15,13 +14,12 @@ static t_seconds seconds = { .seconds = 0, .missedUpdates = 0, .valid = false };
 static t_configBlock *config;
 
 
-
 static void networkSecondsHandler(void *handle) {
     static bool tryAgain = false;
 
     seconds.seconds += 1;
 
-    if (! seconds.valid && isNetworkAvailable()) {
+    if (! seconds.valid) {
         coloredMsg(LOG_YELLOW, "nsh, initially querying time");
         uint64_t tmpSeconds = networkSntpQuery();
         if (tmpSeconds != 0) {
@@ -29,7 +27,6 @@ static void networkSecondsHandler(void *handle) {
             seconds.seconds = tmpSeconds;
             seconds.missedUpdates = 0;
             seconds.valid = true;
-            show(LED_GREEN, ON);
         } else {
             coloredMsg(LOG_YELLOW, "nsh, failed");
             seconds.missedUpdates += 1;
@@ -41,7 +38,6 @@ static void networkSecondsHandler(void *handle) {
             coloredMsg(LOG_YELLOW, "nsh, success, network time is %lu", tmpSeconds);
             seconds.missedUpdates = 0;
             tryAgain = false;
-            show(LED_GREEN, ON);
             if (seconds.seconds != tmpSeconds) {
                 coloredMsg(LOG_YELLOW, "nsh, local time updated");
                 seconds.seconds = tmpSeconds;

cube/User/Src/networkAbstractionLayer_lan.c

@@ -4,196 +4,135 @@
 #include <networkAbstractionLayer_impl.h>
 #include <logger.h>
 #include <PontCoopScheduler.h>
-
 #include <wizHelper.h>
 #include <wizchip_conf.h>
 #include <socket.h>
+#include <wizchip_conf.h>
 #include <config.h>
-#include <sntp.h>
-
 
 static t_configBlock *config;
 
 
-
+const uint16_t MAX_RECV_RETRY_COUNT = 100;
-static const uint64_t UNIX_NTP_EPOCH_DIFF = 2208988800;
+const uint64_t UNIX_NTP_EPOCH_DIFF = 2208988800;
-static const uint16_t NTP_PORT = 123;
-static const uint16_t MAX_SNTP_RETRIES = 100;
-extern const uint8_t SNTP_SOCK;
-
-
 
 const uint8_t SEND_LI_VN_MODE = 0xe3; // LI: unknown (3), VN: 4, Mode: Client (3)
-typedef struct s_ntpStruct {
+typedef struct {
     uint8_t   li_vn_mode;
-    uint8_t   stratum;
+	uint8_t   stratum;
-    uint8_t   poll;
+	uint8_t   poll;
-    uint8_t   precision;
+	uint8_t   precision;
-    uint32_t  rootdelay;
+	uint32_t  rootdelay;
-    uint32_t  rootdisp;
+	uint32_t  rootdisp;
-    uint32_t  refid;
+	uint32_t  refid;
-    //uint64_t  reftime;
+	uint64_t  reftime;
-    uint32_t reftime_h;
+	uint64_t  org;
-    uint32_t reftime_l;
+	uint64_t  rec;
-    //uint64_t  org;
+	uint64_t  xmt;
-    uint32_t org_h;
-    uint32_t org_l;
-    //uint64_t  rec;
-    uint32_t rec_h;
-    uint32_t rec_l;
-    //uint64_t  xmt;
-    uint32_t xmt_h;
-    uint32_t xmt_l;
-} t_ntpStruct;
-
-typedef union __attribute__((__packed__)) {
-    t_ntpStruct s;
-    uint8_t b[sizeof(t_ntpStruct)];
 } ntpMsg_t;
 
-typedef struct {
+extern uint8_t SNTP_SOCK;
-    ntpMsg_t ntpMsg;
-    uint8_t ntpAddr[4];
-    uint16_t retryCount;
-    uint64_t seconds;
-    enum {
-        SNTP_STATE_IDLE,
-        SNTP_STATE_START, 
-        SNTP_STATE_SEND,
-        SNTP_STATE_RECV,
-        SNTP_STATE_DONE,
-        SNTP_STATE_ERROR
-    } sntpState;
-} sntpEngineHandle_t;
 
-sntpEngineHandle_t sntpEngineHandle = { 
+const uint16_t NTP_PORT = 123;
-    .seconds = 0, 
+
-    .retryCount = 0, 
+enum { 
-    .sntpState = SNTP_STATE_IDLE 
+    SNTP_STATE_IDLE, 
-};
+    SNTP_STATE_START,
+    SNTP_STATE_SEND,
+    SNTP_STATE_RECV,
+    SNTP_STATE_ERROR,
+    SNTP_STATE_DONE 
+} sntpState = SNTP_STATE_IDLE;
+uint64_t seconds;
 
 
-void networkSntpEngine(void *handle) {
+/*
-    sntpEngineHandle_t *localHandle = (sntpEngineHandle_t*) handle;
+static void networkSntpEngine(void *handle) {
-    if (isNetworkAvailable()) {
+    static uint16_t retryCount = 0;
-        switch (localHandle->sntpState) {
+
-            case SNTP_STATE_START:
+    coloredMsg(LOG_BLUE, "nes, %u", sntpState);
-                coloredMsg(LOG_BLUE, "nes, resolve ntp server");
+
-                if (! wizDnsQuery(config->ntpServer, localHandle->ntpAddr)) {
+    switch (sntpState) {
-                    coloredMsg(LOG_BLUE, "nes, failed to resolve ntp server");
+        case SNTP_STATE_START:
-                    localHandle->sntpState = SNTP_STATE_ERROR;
+            coloredMsg(LOG_BLUE, "nes, about to send");
-                } else {
+            uint8_t ntpAddr[4];
-                    localHandle->sntpState = SNTP_STATE_SEND;
+            if (! wizDnsQuery(config->ntpServer, ntpAddr)) {
-                    schAdd(networkSntpEngine, (void*) localHandle, 10, 0);
+                coloredMsg(LOG_BLUE, "nes, failed to resolve ntp server");
-                }
+                sntpState = SNTP_STATE_ERROR;
-                break;
+            } else {
-            case SNTP_STATE_SEND:
-                coloredMsg(LOG_BLUE, "nes, about to call SNTP");
-                localHandle->retryCount = 0;
                 socket(SNTP_SOCK, Sn_MR_UDP, NTP_PORT, 0);
+                retryCount = 0;
                 uint8_t sockState = getSn_SR(SNTP_SOCK);
                 if (sockState == SOCK_UDP) {
-                    memset(&(localHandle->ntpMsg), 0, sizeof(localHandle->ntpMsg));
+                    ntpMsg_t ntpMsg;
-                    localHandle->ntpMsg.s.li_vn_mode = SEND_LI_VN_MODE;
+                    memset(&ntpMsg, 0, sizeof(ntpMsg));
-                    localHandle->ntpMsg.s.xmt_l = 1;
+                    ntpMsg.li_vn_mode = SEND_LI_VN_MODE;
-                    sendto(SNTP_SOCK, localHandle->ntpMsg.b, 
+                    sendto(SNTP_SOCK, (uint8_t*)&ntpMsg, sizeof(ntpMsg), ntpAddr, NTP_PORT);
-                           sizeof(localHandle->ntpMsg.b), localHandle->ntpAddr, NTP_PORT);
                     coloredMsg(LOG_BLUE, "nes, sent");
-                    localHandle->sntpState = SNTP_STATE_RECV;
+                    sntpState = SNTP_STATE_RECV;
-                    schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
+                    schAdd(networkSntpEngine, NULL, 1000, 0);
                 } else {
-                    coloredMsg(LOG_BLUE, "nes, socket in unexpected state %d", sockState);
+                    coloredMsg(LOG_BLUE, "nes, socket in unexpected state: %d", sockState);
-                    localHandle->sntpState = SNTP_STATE_ERROR;
+                    sntpState = SNTP_STATE_ERROR;
                 }
-                break;
+            }
-            case SNTP_STATE_RECV:
+            break;
-                coloredMsg(LOG_BLUE, "nes, check receive");
+        case SNTP_STATE_RECV:
-                localHandle->retryCount += 1;
+            coloredMsg(LOG_BLUE, "nes, check receive");
-                uint16_t recvLen = getSn_RX_RSR(SNTP_SOCK);
+            uint16_t recvLen = getSn_RX_RSR(SNTP_SOCK);
-                if (recvLen == 0) {
+            if (recvLen == 0) {
-                    if (localHandle->retryCount > MAX_SNTP_RETRIES) {
+                retryCount += 1;
-                        coloredMsg(LOG_BLUE, "nes, max retry count reached, failed");
+                if (retryCount > MAX_RECV_RETRY_COUNT) {
-                        localHandle->sntpState = SNTP_STATE_ERROR;
+                    coloredMsg(LOG_BLUE, "nes max retry count reached, failed");
-                    } else {
+                    sntpState = SNTP_STATE_ERROR;
-                        coloredMsg(LOG_BLUE, "nes, nothing received yet, try again");
-                        schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
-                    }
-                } else if (recvLen >= sizeof(localHandle->ntpMsg)) {
-                    memset(&(localHandle->ntpMsg), 0, sizeof(localHandle->ntpMsg));
-                    uint8_t srcAddr[4];
-                    uint16_t srcPort;
-                    
-                    recvfrom(SNTP_SOCK, localHandle->ntpMsg.b,
-                             sizeof(localHandle->ntpMsg.b), srcAddr, &srcPort);
-                    
-                    
-                    uint8_t *buf = localHandle->ntpMsg.b;
-                    uint8_t x = 0;
-                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
-                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
-                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
-                    x += 16;
-                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
-                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
-                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
-                    x += 16;
-                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
-                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
-                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
-                    x += 16;
-                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
-                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
-                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
-
-                    close(SNTP_SOCK);
-                    coloredMsg(LOG_BLUE, "nes, msg received from %d.%d.%d.%d:%d", 
-                               srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3],
-                               srcPort);
-                    
-                    coloredMsg(LOG_BLUE, "nes, received in the %d. cycles", localHandle->retryCount);
-                    uint32_t xmt_h = 
-                        (localHandle->ntpMsg.s.xmt_h & 0x0000000ff) << 24 |
-                        (localHandle->ntpMsg.s.xmt_h & 0x00000ff00) << 8 |
-                        (localHandle->ntpMsg.s.xmt_h & 0x000ff0000) >> 8 |
-                        (localHandle->ntpMsg.s.xmt_h & 0x0ff000000) >> 24;
-                    localHandle->seconds = ((uint64_t)xmt_h) - UNIX_NTP_EPOCH_DIFF;
-                    coloredMsg(LOG_BLUE, "nes, xmt: %08x", xmt_h);
-                    coloredMsg(LOG_BLUE, "nes, seconds: %lu", localHandle->seconds);
-                    localHandle->sntpState = SNTP_STATE_DONE;
                 } else {
-                    coloredMsg(LOG_BLUE, "nes, invalid number of octets received: %d", recvLen);
+                    coloredMsg(LOG_BLUE, "nes, nothing received yet, try again");
-                    localHandle->sntpState = SNTP_STATE_ERROR;
+                    schAdd(networkSntpEngine, NULL, 100, 0);
                 }
-                break;
+            } else if (recvLen == sizeof(ntpMsg_t)) {
-            default:
+                ntpMsg_t ntpMsg;
-                coloredMsg(LOG_BLUE, "nes, unexpected state");
+                memset(&ntpMsg, 0, sizeof(ntpMsg_t));
-        }
+                uint8_t srcAddr[4];
-    } else {
+                uint16_t srcPort;
-        coloredMsg(LOG_BLUE, "nes, no network yet, try again");
+                recvfrom(SNTP_SOCK, (uint8_t*)&ntpMsg, sizeof(ntpMsg_t), srcAddr, &srcPort);
-        schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
+                close(SNTP_SOCK);
+                coloredMsg(LOG_BLUE, "nes, msg received from %d.%d.%d.%d:%d", 
+                           srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3],
+                           srcPort);
+                coloredMsg(LOG_BLUE, "nes, received in the %d. cycles", retryCount);
+                seconds = ntpMsg.rec - UNIX_NTP_EPOCH_DIFF;
+                coloredMsg(LOG_BLUE, "nes, seconds: %lu", seconds);
+                sntpState = SNTP_STATE_DONE;
+            } else {
+                coloredMsg(LOG_BLUE, "nes, invalid number of octets received: %d", recvLen);
+                sntpState = SNTP_STATE_ERROR;
+            }
+            break;
+        default:
+            coloredMsg(LOG_BLUE, "nes, unexpected state");
     }
 }
+*/
+
 
 uint64_t networkSntpQuery() {
+    /*
     uint64_t res = 0;
-
+    if (sntpState == SNTP_STATE_IDLE) {
-    if (sntpEngineHandle.sntpState == SNTP_STATE_IDLE) {
+        sntpState = SNTP_STATE_START;
-        coloredMsg(LOG_BLUE, "nsq, start sntp request");
+        schAdd(networkSntpEngine, NULL, 1, 0);
-        sntpEngineHandle.sntpState = SNTP_STATE_START;
+    } else if (sntpState == SNTP_STATE_ERROR) {
-        schAdd(networkSntpEngine, (void*) &sntpEngineHandle, 1, 0);
+        sntpState = SNTP_STATE_IDLE;
-    } else if (sntpEngineHandle.sntpState == SNTP_STATE_DONE) {
+    } else if (sntpState == SNTP_STATE_DONE) {
-        coloredMsg(LOG_BLUE, "nsq, start sntp done");
+        sntpState = SNTP_STATE_IDLE;
-        res = sntpEngineHandle.seconds;
+        res = seconds;
-        coloredMsg(LOG_BLUE, "nsq, time is %lu", res);
-        sntpEngineHandle.sntpState = SNTP_STATE_IDLE;
-    } else if (sntpEngineHandle.sntpState == SNTP_STATE_ERROR) {
-        coloredMsg(LOG_BLUE, "nsq, start sntp failed");
-        sntpEngineHandle.sntpState = SNTP_STATE_IDLE;
     }
-
     return res;
+    */
+   return 0;
 }
 
+
 extern uint8_t SINK_SOCK;
 
 int8_t networkUdpSend(char *hostname, uint16_t port, uint8_t *buf, uint16_t bufLen) {
@@ -220,10 +159,6 @@ int8_t networkUdpSend(char *hostname, uint16_t port, uint8_t *buf, uint16_t bufL
     return 1;
 }
 
-bool isNetworkAvailable() {
-    return wizIsNetworkAvailable();
-}
-
 void networkImplInit() {
     config = getConfig();
     wizInit();

cube/User/Src/show.c

@@ -1,7 +1,6 @@
 #include <main.h>
 #include <show.h>
 #include <PontCoopScheduler.h>
-#include <show.h>
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -25,20 +24,9 @@ showElement_t showElement[] = {
 };
 
 static void showHandler(void *handle) {
-    const uint8_t MAX_CNT = 3;
-    static uint8_t cnt = 0;
-    cnt += 1;
-    if (cnt > MAX_CNT) {
-        cnt = 0;
-    }
-
     uint8_t idx = 0;
     while (showElement[idx].port) {
         if (showElement[idx].currentState == BLINK) {
-            if (cnt == MAX_CNT) {
-                HAL_GPIO_TogglePin(showElement[idx].port, showElement[idx].pin);
-            }
-        } else if (showElement[idx].currentState == BLINK_FAST) {
             HAL_GPIO_TogglePin(showElement[idx].port, showElement[idx].pin);
         }
         idx++;
@@ -55,5 +43,5 @@ void show(signalPin_t signalPin, signalAction_t action) {
 }
 
 void showInit() {
-    schAdd(showHandler, NULL, 0, 100);
+    schAdd(showHandler, NULL, 0, 250);
 }

cube/User/Src/wizHelper.c

@@ -33,7 +33,7 @@ extern const uint8_t DNS_SOCK;
 
 static bool networkAvailable = false;
 
-bool wizIsNetworkAvailable() {
+bool isNetworkAvailable() {
     return networkAvailable;
 }
 
@@ -86,7 +86,7 @@ static void wizDHCPAssign() {
     coloredMsg(LOG_BLUE, "wizda, set netinfo again");
 
     networkAvailable = true;
-    show(LED_GREEN, BLINK_FAST);
+    show(LED_GREEN, ON);
     coloredMsg(LOG_BLUE, "wizda, network is available");
 }
 

docs/test1.txt

@@ -1,8 +0,0 @@
-24 02 03 e9 00 00 06 86  00 00 02 cc c0 a8 64 0f
-e3 e6 85 7c b7 79 4a eb  00 00 00 00 00 00 00 00
-e3 e6 86 b4 cb 75 ef d3  e3 e6 86 b4 cb 7c 22 82
-00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
-
-1614546999
-
-2208988800

sink/.gitignore

@@ -0,0 +1 @@
+build/

sink/Makefile

@@ -0,0 +1,42 @@
+BUILD_DIR = build
+
+C_SOURCES = \
+../cube/User/Src/sha256.c \
+sink20169.c \
+logging.c
+
+
+C_INCLUDES = \
+-I. \
+-I../cube/User/Inc
+
+VERSION := $(shell git rev-parse --short=8 HEAD)
+
+CC = gcc
+CFLAGS = $(C_INCLUDES) -Wall -Werror -std=c99 -DVERSION="\"$(VERSION)\""
+LDFLAGS = -lconfig -lcurl
+TARGET = sink20169
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),OpenBSD)
+  CFLAGS += -I/usr/local/include -DOpenBSD=1
+  LDFLAGS += -L/usr/local/lib
+endif
+
+all: $(BUILD_DIR)/$(TARGET)
+
+OBJECTS = $(addprefix $(BUILD_DIR)/,$(notdir $(C_SOURCES:.c=.o)))
+vpath %.c $(sort $(dir $(C_SOURCES)))
+
+$(BUILD_DIR)/%.o: %.c Makefile | $(BUILD_DIR)
+	$(CC) -c $(CFLAGS) $< -o $@
+
+$(BUILD_DIR)/$(TARGET): $(OBJECTS) Makefile
+	$(CC) $(OBJECTS) $(LDFLAGS) -o $@
+
+$(BUILD_DIR):
+	mkdir $@
+
+.phony: clean
+clean:
+	-rm -rf $(BUILD_DIR)

sink/logging.c

@@ -0,0 +1,53 @@
+#define _DEFAULT_SOURCE
+
+#include <syslog.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+extern bool verbose;
+int facility = LOG_LOCAL0;
+
+void setfacility(const char *facility_p) {
+  if (! strcmp(facility_p, "LOCAL0")) {
+    facility = LOG_LOCAL0;
+  } else if (! strcmp(facility_p, "LOCAL1")) {
+    facility = LOG_LOCAL1;
+  } else if (! strcmp(facility_p, "LOCAL2")) {
+    facility = LOG_LOCAL2;
+  } else if (! strcmp(facility_p, "LOCAL3")) {
+    facility = LOG_LOCAL3;
+  } else if (! strcmp(facility_p, "LOCAL4")) {
+    facility = LOG_LOCAL4;
+  } else if (! strcmp(facility_p, "LOCAL5")) {
+    facility = LOG_LOCAL5;
+  } else if (! strcmp(facility_p, "LOCAL6")) {
+    facility = LOG_LOCAL6;
+  } else if (! strcmp(facility_p, "LOCAL7")) {
+    facility = LOG_LOCAL7;
+  } else if (! strcmp(facility_p, "USER")) {
+    facility = LOG_USER;
+  } else if (! strcmp(facility_p, "DAEMON")) {
+    facility = LOG_DAEMON;
+  }
+}
+
+
+void logmsg(int prio, const char* format, ...) {
+  va_list vl;
+  char buf[1024];
+
+  va_start(vl, format);
+  vsnprintf(buf, sizeof(buf), format, vl);
+  va_end(vl);
+
+  if (verbose) {
+    printf("%s\n", buf);
+  }
+
+  openlog("counter", 0, facility);
+  syslog(prio, "%s", buf);
+  closelog();
+}
+

sink/logging.h

@@ -0,0 +1,8 @@
+#ifndef _LOGGING_H_
+#define _LOGGING_H_
+
+#include <syslog.h>
+
+void logmsg(int prio, const char* format, ...);
+void setfacility(const char *facility_p);
+#endif // _LOGGING_H_

sink/readme.md

@@ -0,0 +1,3 @@
+Make sure libconfig and libcurl are available.
+On Linux (Debian) install libconfig-dev and libcurl4-openssl-dev,
+on OpenBSD install libconfig and curl.

sink/sink20169.c

@@ -0,0 +1,423 @@
+#define _DEFAULT_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <getopt.h>
+#include <pwd.h>
+
+#include <libconfig.h>
+#include <curl/curl.h>
+
+#include <sinkStruct.h>
+#include <logging.h>
+#include <sha256.h>
+
+
+const char DEFAULT_CONFIG_FILENAME[] = "./sink20169.cfg";
+
+typedef struct {
+    const char *deviceId;
+    const char *location;
+    const char *sharedSecret;
+} t_device;
+
+typedef struct {
+    config_t cfg;
+    uint16_t numOfDevices;
+    t_device *devices;    
+} t_configHandle;
+
+typedef struct {
+    t_configHandle *configHandle;
+    int receiveSockFd;
+} t_receiverHandle;
+
+typedef struct {
+    t_configHandle *configHandle;
+    const char *influxUser;
+    const char *influxPass;
+    const char *influxServer;
+    uint16_t influxPort;
+    const char *influxDatabase;
+    const char *influxMeasurement;
+    char influxUrl[1024];
+} t_forwarderHandle;
+
+bool verbose = false;
+
+
+int initConfig(const char *configFilename, t_configHandle *configHandle) {
+    configHandle->numOfDevices = 0;
+    configHandle->devices = NULL;
+
+    config_init(&(configHandle->cfg));
+    if (! config_read_file(&(configHandle->cfg), configFilename)) {
+        logmsg(LOG_ERR, "failed to read config file: %s:%d - %s\n",
+            config_error_file(&(configHandle->cfg)), config_error_line(&(configHandle->cfg)),
+            config_error_text(&(configHandle->cfg)));
+        config_destroy(&(configHandle->cfg));
+        return -1;
+    }
+
+    config_setting_t *devicesConfig = config_lookup(&(configHandle->cfg), "devices");
+    if (devicesConfig == NULL) {
+        logmsg(LOG_ERR, "receiver: no devices configuration found");
+        return -2;
+    }
+    configHandle->numOfDevices = config_setting_length(devicesConfig);
+    configHandle->devices = (t_device*) malloc(configHandle->numOfDevices * sizeof(t_device));
+    for (uint16_t i = 0; i < configHandle->numOfDevices; i++) {
+        config_setting_t *deviceConfig = config_setting_get_elem(devicesConfig, i);
+        if (! config_setting_lookup_string(deviceConfig, "deviceId", &(configHandle->devices[i].deviceId))) {
+            logmsg(LOG_ERR, "no deviceId for device %d", i);
+            return -3;
+        }
+        if (! config_setting_lookup_string(deviceConfig, "location", &(configHandle->devices[i].location))) {
+            logmsg(LOG_ERR, "no location for device %d", i);
+            return -4;
+        }
+        if (! config_setting_lookup_string(deviceConfig, "sharedSecret", &(configHandle->devices[i].sharedSecret))) {
+            logmsg(LOG_ERR, "no sharedSecret for device %d", i);
+            return -5;
+        }
+        if (strlen(configHandle->devices[i].sharedSecret) >= SHA256_BLOCK_SIZE) {
+            logmsg(LOG_ERR, "Configured sharedsecret for device %d is too long", i);
+            return -6;
+        }
+        logmsg(LOG_INFO, "Device loaded: %d %s %s %s", i, 
+               configHandle->devices[i].deviceId, 
+               configHandle->devices[i].location, 
+               configHandle->devices[i].sharedSecret);
+    }
+
+    return 0;
+}
+
+void deinitConfig(t_configHandle *configHandle) {
+    config_destroy(&(configHandle->cfg));
+    if (configHandle->devices) {
+        free(configHandle->devices);
+        configHandle->devices = NULL;
+    }
+}
+
+t_device *findDevice(t_configHandle *configHandle, char *deviceId) {
+    for (uint16_t i = 0; i < configHandle->numOfDevices; i++) {
+        if (! strcmp(configHandle->devices[i].deviceId, deviceId)) {
+            return &(configHandle->devices[i]);
+        }
+    }
+    return NULL;
+}
+
+int initReceiver(t_configHandle *configHandle, t_receiverHandle *handle) {
+    handle->configHandle = configHandle;
+
+    struct sockaddr_in servaddr;
+
+    handle->receiveSockFd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (handle->receiveSockFd == -1) {
+        logmsg(LOG_ERR, "failed to create receive socket: %d", errno);
+        return -1;
+    }
+
+    int receivePort = 20169;
+    config_lookup_int(&(configHandle->cfg), "receivePort", &receivePort);
+    if (receivePort < 1 || receivePort > 65535) {
+        logmsg(LOG_ERR, "illegal receive port configured");
+        return -2;
+    }
+
+    memset(&servaddr, 0, sizeof(servaddr));
+    servaddr.sin_family = AF_INET;
+    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+    servaddr.sin_port = htons(receivePort);
+
+    if (-1 == bind(handle->receiveSockFd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
+        logmsg(LOG_ERR, "unable to bind receive: %d", errno);
+        return -3;
+    }
+    return 0;
+}
+
+void deinitReceiver(t_receiverHandle *handle) {
+    close(handle->receiveSockFd);
+}
+
+int receiveAndVerifyMinuteBuffer(t_receiverHandle *handle, t_minuteBuffer *buf) {
+    struct sockaddr_in cliaddr;
+    socklen_t cliaddrlen = sizeof(cliaddr);
+
+    int n = recvfrom(handle->receiveSockFd, buf->b, sizeof(buf->b), MSG_TRUNC,
+                     (struct sockaddr *) &cliaddr, &cliaddrlen);
+    logmsg(LOG_INFO, "received %d octets from %d.%d.%d.%d", 
+           n, 
+           (cliaddr.sin_addr.s_addr & 0x0ff), 
+           ((cliaddr.sin_addr.s_addr >> 8) & 0x0ff), 
+           ((cliaddr.sin_addr.s_addr >> 16) & 0x0ff), 
+           ((cliaddr.sin_addr.s_addr >> 24) & 0x0ff));
+
+    if (n != sizeof(buf->b)) {
+        logmsg(LOG_INFO, "Illegal packet size: %d", n);
+        return -1;
+    }
+
+    t_device *device = findDevice(handle->configHandle, buf->s.deviceId);    
+    const char *sharedSecret = device->sharedSecret;
+
+    uint8_t receivedHash[SHA256_BLOCK_SIZE];
+    memcpy(receivedHash, buf->s.hash, SHA256_BLOCK_SIZE);
+    memcpy(buf->s.hash, sharedSecret, SHA256_BLOCK_SIZE);
+
+    SHA256_CTX ctx;
+    uint8_t calculatedHash[SHA256_BLOCK_SIZE];
+    sha256_init(&ctx);
+    sha256_update(&ctx, buf->b, sizeof(buf->b));
+    sha256_final(&ctx, calculatedHash);
+
+    if (memcmp(receivedHash, calculatedHash, SHA256_BLOCK_SIZE) != 0) {
+        logmsg(LOG_INFO, "Invalid hash in msg for device %s", buf->s.deviceId);
+        return -5;
+    }
+
+    return 0;
+}
+
+
+int initForwarder(t_configHandle *configHandle, t_forwarderHandle *handle) {
+    handle->configHandle = configHandle;
+
+    handle->influxUser = NULL;
+    handle->influxPass = NULL;
+    handle->influxServer = NULL;
+    handle->influxDatabase = NULL;
+    handle->influxMeasurement = NULL;
+
+    config_lookup_string(&(configHandle->cfg), "influxUser", &(handle->influxUser));
+    config_lookup_string(&(configHandle->cfg), "influxPass", &(handle->influxPass));
+    config_lookup_string(&(configHandle->cfg), "influxServer", &(handle->influxServer));
+    config_lookup_string(&(configHandle->cfg), "influxDatabase", &(handle->influxDatabase));
+    config_lookup_string(&(configHandle->cfg), "influxMeasurement", &(handle->influxMeasurement));
+
+    int influxPort = 8086;
+    config_lookup_int(&(configHandle->cfg), "influxPort", &influxPort);
+    if (influxPort < 1 || influxPort > 65535) {
+        logmsg(LOG_ERR, "illegal influx port configured");
+        return -2;
+    }
+    handle->influxPort = influxPort;
+
+    if (! handle->influxServer) {
+        logmsg(LOG_ERR, "no influxServer configured");
+        return -1;
+    }
+    if (! handle->influxDatabase) {
+        logmsg(LOG_ERR, "no influxDatabase configured");
+        return -2;
+    }
+    if (! handle->influxMeasurement) {
+        logmsg(LOG_ERR, "no influxMeasurement configured");
+        return -3;
+    }
+
+    int res = snprintf(handle->influxUrl, sizeof(handle->influxUrl),
+                       "http://%s:%d/write?db=%s&precision=s",
+                       handle->influxServer, handle->influxPort, handle->influxDatabase);
+    if (res > sizeof(handle->influxUrl)) {
+        logmsg(LOG_ERR, "influxUrl has not enough space");
+        return -4;
+    }
+    logmsg(LOG_INFO, "influxUrl is %s", handle->influxUrl);
+
+    return 0;
+}
+
+void deinitForwarder(t_forwarderHandle *handle) {
+
+}
+
+int httpPostRequest(char *url, const char *user, const char *pass, char *payload) {
+    CURL *curl = curl_easy_init();
+    if (! curl) {
+        logmsg(LOG_ERR, "error instantiating curl");
+        return -1;
+    }
+
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    if (user && pass) {
+        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
+        curl_easy_setopt(curl, CURLOPT_USERNAME, user);
+        curl_easy_setopt(curl, CURLOPT_PASSWORD, pass);
+    }
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
+
+    CURLcode res = curl_easy_perform(curl);
+    if (res != CURLE_OK) {
+        logmsg(LOG_ERR, "post request failed: %s", curl_easy_strerror(res));
+        return -2;
+    }
+
+    curl_easy_cleanup(curl);
+
+    return 0;
+}
+
+int forwardMinuteBuffer(t_forwarderHandle *handle, t_minuteBuffer *buf) {
+    logmsg(LOG_INFO, "D: %s, R: %u, P: %u, W: %u, V: %08x", 
+           buf->s.deviceId, buf->s.totalRunningHours, buf->s.totalPowercycles, buf->s.totalWatchdogResets,
+           buf->s.version);
+           
+    t_device *device = findDevice(handle->configHandle, buf->s.deviceId);
+    const char *location = device->location;
+
+    for (uint8_t j = 0; j < SECONDS_PER_MINUTE; j++) {
+        uint64_t timestamp = buf->s.timestamp + j;
+        logmsg(LOG_DEBUG, "Time: %lu, Frequency: %u", timestamp, buf->s.frequency[j]);
+
+        int frequency_before_point = buf->s.frequency[j] / 1000;
+        int frequency_behind_point = buf->s.frequency[j] - (frequency_before_point * 1000);
+
+        char payload[256];
+        int res = snprintf(payload, sizeof(payload),
+                           "%s,valid=1,location=%s,host=%s freq=%d.%03d"
+#ifdef OpenBSD
+                           " %llu"
+#else
+                           " %lu"
+#endif                                                      
+                           "",
+                           handle->influxMeasurement, location, buf->s.deviceId, 
+                           frequency_before_point, frequency_behind_point, 
+                           timestamp);
+        if (res > sizeof(payload)) {
+            logmsg(LOG_ERR, "payload buffer to small");
+            return -1;
+        }
+        logmsg(LOG_DEBUG, "Payload: %s", payload);
+        res = httpPostRequest(handle->influxUrl, handle->influxUser, handle->influxPass, payload);
+        if (res == 0) {
+            logmsg(LOG_DEBUG, "Successfully sent to InfluxDB");
+        }
+    }
+
+    logmsg(LOG_INFO, "Successfully sent whole minute to InfluxDB");
+    return 0;
+}
+
+void usage() {
+    printf("sinkserver for mainsfrequency counter\n");
+    printf("https://home.hottis.de/gitlab/wolutator/mains-frequency-counter-stm32\n");
+    printf("Version: " VERSION "\n");
+    printf("\nUsage\n");
+    printf("  -f FILENAME R..... Config file to be used\n");
+    printf("  -v ............... Verbose, writes all logging on stdout too\n");
+    printf("  -s FACILITY ...... Sets syslog facility, only LOCAL[0..7]\n");
+    printf("                     USER and DAEMON are supported\n");
+    printf("  -n USER .......... If started as root drop privileges and become\n");
+    printf("                     USER\n");
+    printf("  -b ............... fork into background\n");
+    printf("  -h ............... This help\n");
+}
+
+int main(int argc, char **argv) {
+    t_configHandle configHandle;
+    t_forwarderHandle forwarderHandle;
+    t_receiverHandle receiverHandle;
+
+
+    const char *configFilename = DEFAULT_CONFIG_FILENAME;
+    const char *dropPrivilegesToUser = NULL;
+    bool doFork = false;
+
+    int c;
+    while ((c = getopt(argc, argv, "f:vs:hn:b")) != -1) {
+        switch (c) {
+            case 'f':
+                configFilename = strdup(optarg);
+                break;
+            case 'v':
+                verbose = true;
+                break;
+            case 's':
+                setfacility(optarg);
+                break;
+            case 'n':
+                dropPrivilegesToUser = strdup(optarg);
+                break;
+            case 'b':
+                doFork = true;
+                break;
+            case 'h':
+                usage();
+                exit(0);
+                break;
+        }
+    }
+
+    if ((getuid() == 0) && (dropPrivilegesToUser != NULL)) {
+        logmsg(LOG_INFO, "dropping root privileges, become %s", dropPrivilegesToUser);
+        struct passwd *userEntry = getpwnam(dropPrivilegesToUser);
+        if (userEntry == NULL) {
+            logmsg(LOG_ERR, "can not find entry for user %s", dropPrivilegesToUser);
+            exit(1);
+        }        
+
+        if (setuid(userEntry->pw_uid) != 0) {
+            logmsg(LOG_ERR, "unable to drop root privileges to %d", userEntry->pw_uid);
+            exit(2);
+        }
+    }
+
+    if (0 != initConfig(configFilename, &configHandle)) {
+        logmsg(LOG_ERR, "error when reading configuration");
+        exit(3);
+    }
+    
+    if (doFork) {
+        int pid = fork();
+        if (pid == -1) {
+            logmsg(LOG_ERR, "error when forking into background: %d", errno);
+            exit(4);
+        }
+        if (pid != 0) {
+            logmsg(LOG_INFO, "successfully forking into background, child's pid is %d", pid);
+            exit(0);
+        }
+    }
+
+    if (0 != initReceiver(&configHandle, &receiverHandle)) {
+        logmsg(LOG_ERR, "error when initializing receiver");
+        exit(5);
+    }
+
+    if (0 != initForwarder(&configHandle, &forwarderHandle)) {
+        logmsg(LOG_ERR, "error when initializing forwarder");
+        exit(6);
+    }
+
+
+    while (1) {
+        t_minuteBuffer buf;
+        
+        if (receiveAndVerifyMinuteBuffer(&receiverHandle, &buf) < 0) {
+            logmsg(LOG_ERR, "error in receiveAndVerify");
+            continue;
+        }
+
+        if (forwardMinuteBuffer(&forwarderHandle, &buf) < 0) {
+            logmsg(LOG_ERR, "error in send");
+        }
+    }
+
+
+    deinitForwarder(&forwarderHandle);
+    deinitReceiver(&receiverHandle);
+    deinitConfig(&configHandle);
+}

sink/sink20169.cfg

@@ -0,0 +1,18 @@
+// influxUser = "";
+// influxPass = "";
+influxServer = "172.16.10.16";
+influxPort = 8086;
+influxDatabase = "smarthome2";
+influxMeasurement = "mainsfrequency";
+
+receivePort = 20169;
+
+devices = (
+    {
+        deviceId = "MainsCnt01";
+        // sharedSecret must have exactly 31 characters
+        sharedSecret = "Uj6*uKDp@8Kvfa4g5eRMLUfVsSuqjxW";
+        // location must neither contains spaces nor commas or any other URL-special characters
+        location = "Essen_DE";
+    }
+);

tools/ENV.tmpl

@@ -1,2 +0,0 @@
-export PRIVATETOKEN=privateToken
-

tools/release.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-RELEASENAME=$1
-RELEASETAG=$2
-DESCRIPTION=$3
-
-if [ "$RELEASENAME" = "" -o "$RELEASETAG" = "" -o "$DESCRIPTION" = "" ]; then
-  echo "release.sh RELEASENAME RELEASETAG DESCRIPTION"
-  exit 1
-fi
-
-RELEASETAGTARGET=`git rev-parse --short=8 HEAD`
-
-gitlabreleaseuploader.py \
-  --privateToken $PRIVATETOKEN \
-  --projectId 128 \
-  --projectUrl https://home.hottis.de/gitlab/wolutator/mains-frequency-counter-stm32 \
-  --releaseName "$RELEASENAME" \
-  --createRelease \
-  --releaseTag $RELEASETAG \
-  --releaseTagTarget $RELEASETAGTARGET \
-  --createReleaseTag \
-  --description "$DESCRIPTION" \
-  --instanceUrl https://home.hottis.de/gitlab \
-  --verbose \
-  --file cube/build/cube.elf
-