541 lines
17 KiB
C
541 lines
17 KiB
C
/****************************************************************************
|
|
* This file is part of the project AqHome.
|
|
* AqHome (c) by 2023 Martin Preuss, all rights reserved.
|
|
*
|
|
* The license for this file can be found in the file COPYING which you
|
|
* should have received along with this file.
|
|
****************************************************************************/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
|
|
#include "./init.h"
|
|
#include "./aqhomed_p.h"
|
|
#include "./tty_log.h"
|
|
#include "./devicesread.h"
|
|
#include "./devicesdump.h"
|
|
|
|
#include "aqhome/aqhome.h"
|
|
#include "aqhome/msg/endpoint_tty.h"
|
|
#include "aqhome/ipc/endpoint_ipc.h"
|
|
#include "aqhome/ipc/endpoint_ipcclient.h"
|
|
|
|
#include <gwenhywfar/gwenhywfar.h>
|
|
#include <gwenhywfar/args.h>
|
|
#include <gwenhywfar/debug.h>
|
|
#include <gwenhywfar/endpoint_tcpd.h>
|
|
#include <gwenhywfar/endpoint_multilayer.h>
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
# include <sys/types.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------------------
|
|
* defines
|
|
* ------------------------------------------------------------------------------------------------
|
|
*/
|
|
|
|
#define I18N(msg) msg
|
|
#define I18S(msg) msg
|
|
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------------------
|
|
* forward declarations
|
|
* ------------------------------------------------------------------------------------------------
|
|
*/
|
|
|
|
static int _setupTty(AQHOMED *aqh, GWEN_DB_NODE *dbArgs);
|
|
static void _setupIpcd(AQHOMED *aqh, GWEN_DB_NODE *dbArgs);
|
|
static void _setupBroker(AQHOMED *aqh, GWEN_DB_NODE *dbArgs);
|
|
static GWEN_MSG_ENDPOINT *_acceptIpcFn(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKET *sk, const GWEN_INETADDRESS *addr, void *data);
|
|
static void _setupLog(AQHOMED *aqh, GWEN_DB_NODE *dbArgs);
|
|
static void _setupDb(AQHOMED *aqh, GWEN_DB_NODE *dbArgs);
|
|
static int _loadDeviceList(AQHOMED *aqh);
|
|
|
|
static int _readArgs(int argc, char **argv, GWEN_DB_NODE *dbArgs);
|
|
static int _createPidFile(const char *pidFilename);
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------------------
|
|
* implementations
|
|
* ------------------------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int AqHomed_Init(AQHOMED *aqh, int argc, char **argv)
|
|
{
|
|
GWEN_DB_NODE *dbArgs;
|
|
int rv;
|
|
const char *s;
|
|
|
|
dbArgs=GWEN_DB_Group_new("args");
|
|
rv=_readArgs(argc, argv, dbArgs);
|
|
if (rv<0) {
|
|
DBG_ERROR(NULL, "Error reading args (%d)", rv);
|
|
return rv;
|
|
}
|
|
AQH_MergeConfigFileIntoConfig(dbArgs, "ConfigFile");
|
|
aqh->dbArgs=dbArgs;
|
|
|
|
s=GWEN_DB_GetCharValue(dbArgs, "loglevel", 0, NULL);
|
|
if (s && *s) {
|
|
GWEN_LOGGER_LEVEL ll;
|
|
|
|
ll=GWEN_Logger_Name2Level(s);
|
|
GWEN_Logger_SetLevel(NULL, ll);
|
|
}
|
|
|
|
s=GWEN_DB_GetCharValue(dbArgs, "pidfile", 0, AQHOMED_DEFAULT_PIDFILE);
|
|
if (s && *s) {
|
|
AqHomed_SetPidFile(aqh, s);
|
|
rv=_createPidFile(s);
|
|
if (rv<0) {
|
|
DBG_ERROR(NULL, "Error creating PID file (%d)", rv);
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
aqh->timeout=GWEN_DB_GetIntValue(dbArgs, "timeout", 0, 0);
|
|
|
|
aqh->nodeAddress=GWEN_DB_GetIntValue(dbArgs, "nodeAddress", 0, AQHOMED_DEFAULT_NODEADDR);
|
|
|
|
rv=_loadDeviceList(aqh);
|
|
if (rv<0) {
|
|
DBG_ERROR(NULL, "Error loading device list(%d)", rv);
|
|
return rv;
|
|
}
|
|
#if 0
|
|
else {
|
|
GWEN_BUFFER *dbuf;
|
|
|
|
dbuf=GWEN_Buffer_new(0, 256, 0, 1);
|
|
AqHomeNodes_DumpDevices(aqh->deviceDefList, dbuf);
|
|
fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(dbuf));
|
|
GWEN_Buffer_free(dbuf);
|
|
}
|
|
#endif
|
|
|
|
_setupDb(aqh, dbArgs);
|
|
|
|
rv=_setupTty(aqh, dbArgs);
|
|
if (rv<0) {
|
|
DBG_ERROR(NULL, "Error setting up TTY endpoint (%d)", rv);
|
|
return rv;
|
|
}
|
|
|
|
_setupIpcd(aqh, dbArgs);
|
|
_setupBroker(aqh, dbArgs);
|
|
_setupLog(aqh, dbArgs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int _setupTty(AQHOMED *aqh, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
const char *devicePath;
|
|
|
|
devicePath=GWEN_DB_GetCharValue(dbArgs, "device", 0, AQHOMED_DEFAULT_DEVICE);
|
|
if (devicePath && *devicePath) {
|
|
GWEN_MSG_ENDPOINT *epTty;
|
|
|
|
epTty=AQH_TtyEndpoint_new(devicePath, AQHOME_ENDPOINTGROUP_NODE);
|
|
if (epTty==NULL) {
|
|
DBG_ERROR(NULL, "Error creating endpoint TTY");
|
|
return GWEN_ERROR_GENERIC;
|
|
}
|
|
GWEN_MsgEndpoint_Tree2_AddChild(aqh->rootEndpoint, epTty);
|
|
aqh->ttyEndpoint=epTty;
|
|
}
|
|
else {
|
|
DBG_ERROR(NULL, "Missing device path");
|
|
return GWEN_ERROR_GENERIC;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void _setupIpcd(AQHOMED *aqh, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
const char *tcpAddress;
|
|
int tcpPort;
|
|
|
|
tcpAddress=GWEN_DB_GetCharValue(dbArgs, "tcpAddress", 0, NULL);
|
|
if (!(tcpAddress && *tcpAddress))
|
|
tcpAddress=GWEN_DB_GetCharValue(dbArgs, "ConfigFile/nodesAddress", 0, NULL);
|
|
|
|
tcpPort=GWEN_DB_GetIntValue(dbArgs, "tcpPort", 0, -1);
|
|
if (tcpPort<0)
|
|
tcpPort=GWEN_DB_GetIntValue(dbArgs, "ConfigFile/nodesPort", 0, AQHOMED_DEFAULT_IPC_PORT);
|
|
|
|
if (tcpAddress && *tcpAddress && tcpPort) {
|
|
GWEN_MSG_ENDPOINT *ep;
|
|
|
|
ep=GWEN_TcpdEndpoint_new(tcpAddress, tcpPort, NULL, AQHOME_ENDPOINTGROUP_IPC);
|
|
GWEN_TcpdEndpoint_SetAcceptFn(ep, _acceptIpcFn, aqh);
|
|
|
|
GWEN_MsgEndpoint_Tree2_AddChild(aqh->rootEndpoint, ep);
|
|
aqh->ipcdEndpoint=ep;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void _setupBroker(AQHOMED *aqh, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
const char *brokerAddress;
|
|
int brokerPort;
|
|
const char *brokerClientId;
|
|
|
|
brokerAddress=GWEN_DB_GetCharValue(dbArgs, "brokerAddress", 0, NULL);
|
|
if (!(brokerAddress && *brokerAddress))
|
|
brokerAddress=GWEN_DB_GetCharValue(dbArgs, "ConfigFile/brokerAddress", 0, "127.0.0.1");
|
|
|
|
brokerPort=GWEN_DB_GetIntValue(dbArgs, "brokerPort", 0, -1);
|
|
if (brokerPort<0)
|
|
brokerPort=GWEN_DB_GetIntValue(dbArgs, "ConfigFile/brokerPort", 0, AQHOMED_DEFAULT_BROKER_PORT);
|
|
|
|
brokerClientId=GWEN_DB_GetCharValue(dbArgs, "brokerClientId", 0, AQHOMED_DEFAULT_BROKER_CLIENTID);
|
|
|
|
if (brokerAddress && *brokerAddress && brokerPort) {
|
|
GWEN_MSG_ENDPOINT *ep;
|
|
GWEN_MSG_ENDPOINT *ipcBaseEndpoint;
|
|
int rv;
|
|
|
|
ep=AQH_ClientIpcEndpoint_new("brokerIpcClient", 0);
|
|
ipcBaseEndpoint=AQH_IpcEndpoint_CreateIpcTcpClient(brokerAddress, brokerPort, "brokerPhysEndpoint", 0);
|
|
AQH_IpcEndpoint_SetServiceName(ipcBaseEndpoint, brokerClientId);
|
|
GWEN_MsgEndpoint_Tree2_AddChild(ep, ipcBaseEndpoint);
|
|
|
|
GWEN_MsgEndpoint_Tree2_AddChild(aqh->rootEndpoint, ep);
|
|
aqh->brokerEndpoint=ep;
|
|
|
|
rv=GWEN_MultilayerEndpoint_StartConnect(ep);
|
|
if (rv<0 && rv!=GWEN_ERROR_IN_PROGRESS) {
|
|
DBG_ERROR(NULL, "Error connecting to broker server %s:%d (%d), will retry later", brokerAddress, brokerPort, rv);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
GWEN_MSG_ENDPOINT *_acceptIpcFn(GWEN_UNUSED GWEN_MSG_ENDPOINT *ep,
|
|
GWEN_SOCKET *sk,
|
|
GWEN_UNUSED const GWEN_INETADDRESS *addr,
|
|
GWEN_UNUSED void *data)
|
|
{
|
|
/* AQHOMED *aqh;
|
|
*
|
|
* aqh=(AQHOMED*) data;
|
|
*/
|
|
DBG_INFO(NULL, "Incoming IPC connection");
|
|
return AQH_IpcEndpoint_CreateIpcTcpServiceForSocket(sk, NULL, AQHOME_ENDPOINTGROUP_IPC);
|
|
}
|
|
|
|
|
|
|
|
void _setupLog(AQHOMED *aqh, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
const char *logFile;
|
|
|
|
logFile=GWEN_DB_GetCharValue(dbArgs, "logfile", 0, NULL);
|
|
if (logFile && *logFile)
|
|
AqHomed_SetLogFile(aqh, logFile);
|
|
}
|
|
|
|
|
|
|
|
void _setupDb(AQHOMED *aqh, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
const char *s;
|
|
|
|
s=GWEN_DB_GetCharValue(dbArgs, "dbfile", 0, NULL);
|
|
if (s && *s) {
|
|
GWEN_DB_NODE *dbNodeDb;
|
|
int rv;
|
|
|
|
AqHomed_SetDbFile(aqh, s);
|
|
|
|
dbNodeDb=GWEN_DB_Group_new("dbNodes");
|
|
rv=GWEN_DB_ReadFile(dbNodeDb, s, GWEN_DB_FLAGS_DEFAULT|GWEN_PATH_FLAGS_CREATE_GROUP);
|
|
if (rv==0) {
|
|
AQH_NodeDb_fromDb(aqh->nodeDb, dbNodeDb);
|
|
}
|
|
GWEN_DB_Group_free(dbNodeDb);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int _loadDeviceList(AQHOMED *aqh)
|
|
{
|
|
AQHNODE_DEVICE_LIST *deviceList;
|
|
|
|
deviceList=AqHomeNodes_ReadDataDeviceFiles();
|
|
if (deviceList==NULL) {
|
|
DBG_ERROR(NULL, "Error reading device list");
|
|
return GWEN_ERROR_GENERIC;
|
|
}
|
|
aqh->deviceDefList=deviceList;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int _createPidFile(const char *pidFilename)
|
|
{
|
|
FILE *f;
|
|
int pidfd;
|
|
|
|
if (remove(pidFilename)==0) {
|
|
DBG_ERROR(0, "Old PID file existed, removed. (Unclean shutdown?)");
|
|
}
|
|
|
|
#ifdef HAVE_SYS_STAT_H
|
|
pidfd = open(pidFilename, O_EXCL|O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
|
|
if (pidfd < 0) {
|
|
DBG_ERROR(NULL, "Could not create PID file \"%s\" (%s), aborting.", pidFilename, strerror(errno));
|
|
return GWEN_ERROR_IO;
|
|
}
|
|
|
|
f = fdopen(pidfd, "w");
|
|
#else /* HAVE_STAT_H */
|
|
f=fopen(pidFilename,"w+");
|
|
#endif /* HAVE_STAT_H */
|
|
|
|
/* write pid */
|
|
#ifdef HAVE_GETPID
|
|
fprintf(f,"%d\n",getpid());
|
|
#else
|
|
fprintf(f,"-1\n");
|
|
#endif
|
|
if (fclose(f)) {
|
|
DBG_ERROR(0, "Could not close PID file \"%s\" (%s), aborting.", pidFilename, strerror(errno));
|
|
return GWEN_ERROR_IO;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int _readArgs(int argc, char **argv, GWEN_DB_NODE *dbArgs)
|
|
{
|
|
int rv;
|
|
const GWEN_ARGS args[]= {
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"loglevel", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"L", /* short option */
|
|
"loglevel", /* long option */
|
|
I18S("Specify loglevel"), /* short description */
|
|
I18S("Specify loglevel") /* long description */
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"cfgdir", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"D", /* short option */
|
|
"cfgdir", /* long option */
|
|
I18S("Specify the configuration folder"),
|
|
I18S("Specify the configuration folder")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"charset", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
0, /* short option */
|
|
"charset", /* long option */
|
|
I18S("Specify the output character set"), /* short description */
|
|
I18S("Specify the output character set") /* long description */
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"device", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"d", /* short option */
|
|
"device", /* long option */
|
|
I18S("Specify the device to communicate with (e.g. /dev/ttyUSB0)"),
|
|
I18S("Specify the device to communicate with (e.g. /dev/ttyUSB0)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Int, /* type */
|
|
"nodeAddress", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"n", /* short option */
|
|
"node", /* long option */
|
|
I18S("Specify the node address for the AqHome node adaptor (default 240)"),
|
|
I18S("Specify the node address for the AqHome node adaptor (default 240)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"logFile", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"l", /* short option */
|
|
"logfile", /* long option */
|
|
I18S("Specify a logfile to log received messages to"),
|
|
I18S("Specify a logfile to log received messages to")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"tcpAddress", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"t", /* short option */
|
|
"tcpaddress", /* long option */
|
|
I18S("Specify the TCP address to listen on (disabled if missing)"),
|
|
I18S("Specify the TCP address to listen on (disabled if missing)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Int, /* type */
|
|
"tcpPort", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"P", /* short option */
|
|
"tcpport", /* long option */
|
|
I18S("Specify the TCP port to listen on (default: 45454)"),
|
|
I18S("Specify the TCP port to listen on (default: 45454)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"brokerAddress", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"ba", /* short option */
|
|
"brokeraddress", /* long option */
|
|
I18S("Specify the address of the broker server to connect to (disabled if missing)"),
|
|
I18S("Specify the address of the broker server to connect to (disabled if missing)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Int, /* type */
|
|
"brokerPort", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"bp", /* short option */
|
|
"brokerport", /* long option */
|
|
I18S("Specify the port of the broker server (default: 1899)"),
|
|
I18S("Specify the port of the broker server (default: 1899)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"brokerClientId", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
NULL, /* short option */
|
|
"brokerclientid", /* long option */
|
|
I18S("Specify client id for the broker server (default: \"nodes\")"),
|
|
I18S("Specify client id for the broker server (default: \"nodes\")")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"dbfile", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"db", /* short option */
|
|
"dbfile", /* long option */
|
|
I18S("Specify DB file to read/write node database"),
|
|
I18S("Specify DB file to read/write node database")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Char, /* type */
|
|
"pidfile", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"p", /* short option */
|
|
"pidfile", /* long option */
|
|
I18S("Specify the PID file"),
|
|
I18S("Specify the PID file")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
|
|
GWEN_ArgsType_Int, /* type */
|
|
"timeout", /* name */
|
|
0, /* minnum */
|
|
1, /* maxnum */
|
|
"T", /* short option */
|
|
"timeout", /* long option */
|
|
I18S("Specify timeout in second (default: no timeout)"),
|
|
I18S("Specify timeout in second (default: no timeout)")
|
|
},
|
|
{
|
|
GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
|
|
GWEN_ArgsType_Int, /* type */
|
|
"help", /* name */
|
|
0, /* minnum */
|
|
0, /* maxnum */
|
|
"h", /* short option */
|
|
"help",
|
|
I18S("Show this help screen."),
|
|
I18S("Show this help screen.")
|
|
}
|
|
};
|
|
|
|
rv=GWEN_Args_Check(argc, argv, 1, 0, args, dbArgs);
|
|
if (rv==GWEN_ARGS_RESULT_ERROR) {
|
|
fprintf(stderr, "ERROR: Could not parse arguments main\n");
|
|
return GWEN_ERROR_INVALID;
|
|
}
|
|
else if (rv==GWEN_ARGS_RESULT_HELP) {
|
|
GWEN_BUFFER *ubuf;
|
|
|
|
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
|
|
GWEN_Buffer_AppendArgs(ubuf,
|
|
I18N("This is version %s.\nUsage: %s [OPTIONS]\n\nOptions:\n"),
|
|
AQHOME_VERSION_STRING,
|
|
argv[0]);
|
|
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
|
|
fprintf(stderr, "ERROR: Could not create help string\n");
|
|
return 1;
|
|
}
|
|
GWEN_Buffer_AppendString(ubuf, "\n");
|
|
|
|
fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
|
|
GWEN_Buffer_free(ubuf);
|
|
return GWEN_ERROR_CLOSE;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|