kopia lustrzana https://github.com/weetmuts/wmbusmeters
939 wiersze
30 KiB
C++
939 wiersze
30 KiB
C++
/*
|
|
Copyright (C) 2017-2022 Fredrik Öhrström (gpl-3.0-or-later)
|
|
|
|
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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include"cmdline.h"
|
|
#include"drivers.h"
|
|
#include"meters.h"
|
|
#include"util.h"
|
|
|
|
#include<string>
|
|
#include<unistd.h>
|
|
|
|
using namespace std;
|
|
|
|
static bool isDaemon(int argc, char **argv);
|
|
static bool checkIfUseConfig(int argc, char **argv);
|
|
static shared_ptr<Configuration> parseNormalCommandLine(Configuration *c, int argc, char **argv);
|
|
static shared_ptr<Configuration> parseCommandLineWithUseConfig(Configuration *c, int argc, char **argv, bool pid_file_expected);
|
|
|
|
shared_ptr<Configuration> parseCommandLine(int argc, char **argv)
|
|
{
|
|
Configuration * c = new Configuration;
|
|
|
|
c->bin_dir = dirname(currentProcessExe());
|
|
|
|
if (isDaemon(argc, argv))
|
|
{
|
|
c->daemon = true;
|
|
if (argc < 2)
|
|
{
|
|
error("Usage error: wmbusmetersd must have at least a single argument to the pid file.\n");
|
|
}
|
|
return parseCommandLineWithUseConfig(c, argc, argv, true);
|
|
}
|
|
|
|
if (argc < 2)
|
|
{
|
|
c->need_help = true;
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
|
|
if (checkIfUseConfig(argc, argv))
|
|
{
|
|
return parseCommandLineWithUseConfig(c, argc, argv, false);
|
|
}
|
|
|
|
return parseNormalCommandLine(c, argc, argv);
|
|
}
|
|
|
|
void enableEarlyLoggingFromCommandLine(int argc, char **argv)
|
|
{
|
|
int i = 1;
|
|
// First find all logging flags, --silent --verbose --normal --debug
|
|
while (argv[i] && argv[i][0] == '-')
|
|
{
|
|
if (!strcmp(argv[i], "--silent")) {
|
|
i++;
|
|
silentLogging(true);
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--verbose")) {
|
|
verboseEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--normal")) {
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--debug")) {
|
|
verboseEnabled(true);
|
|
debugEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--trace")) {
|
|
verboseEnabled(true);
|
|
debugEnabled(true);
|
|
traceEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
static shared_ptr<Configuration> parseNormalCommandLine(Configuration *c, int argc, char **argv)
|
|
{
|
|
int i = 1;
|
|
// First find all logging flags, --silent --verbose --normal --debug
|
|
while (argv[i] && argv[i][0] == '-')
|
|
{
|
|
if (!strcmp(argv[i], "--silent")) {
|
|
c->silent = true;
|
|
i++;
|
|
silentLogging(true);
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--verbose")) {
|
|
c->verbose = true;
|
|
verboseEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--normal")) {
|
|
c->silent = false;
|
|
c->verbose = false;
|
|
c->debug = false;
|
|
c->trace = false;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--debug")) {
|
|
c->debug = true;
|
|
verboseEnabled(true);
|
|
debugEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--trace")) {
|
|
c->debug = true;
|
|
c->trace = true;
|
|
verboseEnabled(true);
|
|
debugEnabled(true);
|
|
traceEnabled(true);
|
|
i++;
|
|
continue;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
// Now do the rest of the arguments.
|
|
i = 1;
|
|
while (argv[i] && argv[i][0] == '-')
|
|
{
|
|
if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-help") || !strcmp(argv[i], "--help")) {
|
|
c->need_help = true;
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
if (!strcmp(argv[i], "--silent") ||
|
|
!strcmp(argv[i], "--verbose") ||
|
|
!strcmp(argv[i], "--normal") ||
|
|
!strcmp(argv[i], "--debug") ||
|
|
!strcmp(argv[i], "--trace"))
|
|
{
|
|
// Handled already.
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--device=", 9) || // Deprecated
|
|
!strncmp(argv[i], "--overridedevice=", 17))
|
|
{
|
|
error("You can only use --overridedevice=xyz with --useconfig=xyz\n");
|
|
}
|
|
if (!strcmp(argv[i], "--version")) {
|
|
c->version = true;
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
if (!strcmp(argv[i], "--license")) {
|
|
c->license = true;
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
if (!strcmp(argv[i], "--analyze")) {
|
|
c->analyze = true;
|
|
if (isatty(1))
|
|
{
|
|
c->analyze_format = OutputFormat::TERMINAL;
|
|
}
|
|
else
|
|
{
|
|
c->analyze_format = OutputFormat::PLAIN;
|
|
}
|
|
c->analyze_driver = "";
|
|
c->analyze_key = "";
|
|
c->analyze_verbose = false;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--analyze=", 10)) {
|
|
c->analyze = true;
|
|
if (isatty(1))
|
|
{
|
|
c->analyze_format = OutputFormat::TERMINAL;
|
|
}
|
|
else
|
|
{
|
|
c->analyze_format = OutputFormat::PLAIN;
|
|
}
|
|
c->analyze_driver = "";
|
|
c->analyze_key = "";
|
|
c->analyze_verbose = false;
|
|
string arg = string(argv[i]+10);
|
|
vector<string> args = splitString(arg, ':');
|
|
|
|
for (auto s : args)
|
|
{
|
|
bool inv = false;
|
|
if (isHexStringStrict(s, &inv))
|
|
{
|
|
if (inv)
|
|
{
|
|
error("Bad key \"%s\"", s.c_str());
|
|
}
|
|
c->analyze_key = s;
|
|
}
|
|
else if (s == "plain") c->analyze_format = OutputFormat::PLAIN;
|
|
else if (s == "terminal") c->analyze_format = OutputFormat::TERMINAL;
|
|
else if (s == "json") c->analyze_format = OutputFormat::JSON;
|
|
else if (s == "html") c->analyze_format = OutputFormat::HTML;
|
|
else if (s == "verbose") c->analyze_verbose = true;
|
|
else
|
|
{
|
|
MeterInfo mi;
|
|
mi.parse("x", s, "00000000", "");
|
|
|
|
if (mi.driver_name.str() == "")
|
|
{
|
|
error("Not a valid meter driver \"%s\"\n", s.c_str());
|
|
}
|
|
c->analyze_driver = s;
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--logtimestamps=", 16))
|
|
{
|
|
string ts = string(argv[i]+16);
|
|
debug("(cmdline) add log timestamps \"%s\"\n", ts.c_str());
|
|
if (ts == "never")
|
|
{
|
|
c->addtimestamps = AddLogTimestamps::Never;
|
|
}
|
|
else if (ts == "always")
|
|
{
|
|
c->addtimestamps = AddLogTimestamps::Always;
|
|
}
|
|
else if (ts == "important")
|
|
{
|
|
c->addtimestamps = AddLogTimestamps::Important;
|
|
}
|
|
else
|
|
{
|
|
error("No such timestamp setting \"%s\" possible values are: never always important\n",
|
|
ts.c_str());
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--internaltesting")) {
|
|
c->internaltesting = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--profile=", 10)) {
|
|
c->analyze_profile = atoi(argv[i]+10);
|
|
if (c->analyze_profile <= 0) error("Illegal profile value, must be greater than zero.\n");
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--donotprobe=", 13))
|
|
{
|
|
string df = string(argv[i]+13);
|
|
debug("(cmdline) do not probe \"%s\"\n", df.c_str());
|
|
c->do_not_probe_ttys.insert(df);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--listento=", 11))
|
|
{
|
|
LinkModeSet lms = parseLinkModes(argv[i]+11);
|
|
if (lms.empty())
|
|
{
|
|
error("Unknown default link mode \"%s\"!\n", argv[i]+11);
|
|
}
|
|
if (!c->default_device_linkmodes.empty()) {
|
|
error("You have already specified a default link mode!\n");
|
|
}
|
|
c->default_device_linkmodes = lms;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
LinkMode lm = isLinkModeOption(argv[i]);
|
|
if (lm != LinkMode::UNKNOWN) {
|
|
if (!c->default_device_linkmodes.empty())
|
|
{
|
|
error("You have already specified a default link mode!\n");
|
|
}
|
|
// Add to the empty set.
|
|
c->default_device_linkmodes.addLinkMode(lm);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--logtelegrams")) {
|
|
c->logtelegrams = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--logsummary")) {
|
|
c->logsummary = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--ppjson"))
|
|
{
|
|
c->pretty_print_json = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--format=", 9))
|
|
{
|
|
if (!strcmp(argv[i]+9, "json"))
|
|
{
|
|
c->json = true;
|
|
c->fields = false;
|
|
}
|
|
else
|
|
if (!strcmp(argv[i]+9, "fields"))
|
|
{
|
|
c->json = false;
|
|
c->fields = true;
|
|
c->separator = ';';
|
|
}
|
|
else
|
|
if (!strcmp(argv[i]+9, "hr"))
|
|
{
|
|
c->json = false;
|
|
c->fields = false;
|
|
c->separator = '\t';
|
|
}
|
|
else
|
|
{
|
|
error("Unknown output format: \"%s\"\n", argv[i]+9);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--selectfields=", 15)) {
|
|
if (strlen(argv[i]) > 15)
|
|
{
|
|
string s = string(argv[i]+15);
|
|
handleSelectedFields(c, s);
|
|
} else {
|
|
error("You must supply fields to be selected.\n");
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--separator=", 12)) {
|
|
if (!c->fields) {
|
|
error("You must specify --format=fields before --separator=X\n");
|
|
}
|
|
if (strlen(argv[i]) != 13) {
|
|
error("You must supply a single character as the field separator.\n");
|
|
}
|
|
c->separator = argv[i][12];
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--meterfilesaction", 18)) {
|
|
if (strlen(argv[i]) > 18 && argv[i][18] == '=') {
|
|
if (!strncmp(argv[i]+19, "overwrite", 9)) {
|
|
c->meterfiles_action = MeterFileType::Overwrite;
|
|
} else if (!strncmp(argv[i]+19, "append", 6)) {
|
|
c->meterfiles_action = MeterFileType::Append;
|
|
} else {
|
|
error("No such meter file action %s\n", argv[i]+19);
|
|
}
|
|
} else {
|
|
error("Incorrect option %s\n", argv[i]);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--meterfilesnaming", 18)) {
|
|
if (strlen(argv[i]) > 18 && argv[i][18] == '=') {
|
|
if (!strncmp(argv[i]+19, "name-id", 7))
|
|
{
|
|
c->meterfiles_naming = MeterFileNaming::NameId;
|
|
}
|
|
else if (!strncmp(argv[i]+19, "name", 4))
|
|
{
|
|
c->meterfiles_naming = MeterFileNaming::Name;
|
|
}
|
|
else if (!strncmp(argv[i]+19, "id", 2))
|
|
{
|
|
c->meterfiles_naming = MeterFileNaming::Id;
|
|
} else
|
|
{
|
|
error("No such meter file naming %s\n", argv[i]+19);
|
|
}
|
|
} else {
|
|
error("Incorrect option %s\n", argv[i]);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--meterfilestimestamp", 21)) {
|
|
if (strlen(argv[i]) > 22 && argv[i][21] == '=') {
|
|
if (!strncmp(argv[i]+22, "day", 3))
|
|
{
|
|
c->meterfiles_timestamp = MeterFileTimestamp::Day;
|
|
}
|
|
else if (!strncmp(argv[i]+22, "hour", 4))
|
|
{
|
|
c->meterfiles_timestamp = MeterFileTimestamp::Hour;
|
|
}
|
|
else if (!strncmp(argv[i]+22, "minute", 6))
|
|
{
|
|
c->meterfiles_timestamp = MeterFileTimestamp::Minute;
|
|
}
|
|
else if (!strncmp(argv[i]+22, "micros", 5))
|
|
{
|
|
c->meterfiles_timestamp = MeterFileTimestamp::Micros;
|
|
}
|
|
else if (!strncmp(argv[i]+22, "never", 5))
|
|
{
|
|
c->meterfiles_timestamp = MeterFileTimestamp::Never;
|
|
} else
|
|
{
|
|
error("No such meter file timestamp \"%s\"\n", argv[i]+22);
|
|
}
|
|
} else {
|
|
error("Incorrect option %s\n", argv[i]);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--meterfiles") ||
|
|
(!strncmp(argv[i], "--meterfiles", 12) &&
|
|
strlen(argv[i]) > 12 &&
|
|
argv[i][12] == '='))
|
|
{
|
|
c->meterfiles = true;
|
|
size_t len = strlen(argv[i]);
|
|
if (len > 13) {
|
|
c->meterfiles_dir = string(argv[i]+13, len-13);
|
|
} else {
|
|
c->meterfiles_dir = "/tmp";
|
|
}
|
|
if (!checkIfDirExists(c->meterfiles_dir.c_str())) {
|
|
error("Cannot write meter files into dir \"%s\"\n", c->meterfiles_dir.c_str());
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--logfile=", 10)) {
|
|
c->use_logfile = true;
|
|
if (strlen(argv[i]) > 10) {
|
|
size_t len = strlen(argv[i])-10;
|
|
if (len > 0) {
|
|
c->logfile = string(argv[i]+10, len);
|
|
} else {
|
|
error("Not a valid log file name.\n");
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--usestderr", 11)) {
|
|
c->use_stderr_for_log = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--ignoreduplicates", 18)) {
|
|
if (argv[i][18] == 0)
|
|
{
|
|
c->ignore_duplicate_telegrams = true;
|
|
}
|
|
else
|
|
{
|
|
if (!strcmp(argv[i]+18, "=true"))
|
|
{
|
|
c->ignore_duplicate_telegrams = true;
|
|
}
|
|
else if (!strcmp(argv[i]+18, "=false"))
|
|
{
|
|
c->ignore_duplicate_telegrams = false;
|
|
}
|
|
else
|
|
{
|
|
error("You must specify true or false after --ignoreduplicates=\n");
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--usestdoutforlogging", 13)) {
|
|
c->use_stderr_for_log = false;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--shell=", 8)) {
|
|
string cmd = string(argv[i]+8);
|
|
if (cmd == "") {
|
|
error("The telegram shell command cannot be empty.\n");
|
|
}
|
|
c->telegram_shells.push_back(cmd);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--metershell=", 13)) {
|
|
string cmd = string(argv[i]+13);
|
|
if (cmd == "") {
|
|
error("The meter shell command cannot be empty.\n");
|
|
}
|
|
c->meter_shells.push_back(cmd);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--alarmshell=", 13)) {
|
|
string cmd = string(argv[i]+13);
|
|
if (cmd == "") {
|
|
error("The alarm shell command cannot be empty.\n");
|
|
}
|
|
c->alarm_shells.push_back(cmd);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--json_", 7) ||
|
|
!strncmp(argv[i], "--field_", 8))
|
|
{
|
|
// For example: --json_floor=42
|
|
// or --field_floor=42
|
|
// they are equivalent.
|
|
int off = 7;
|
|
if (!strncmp(argv[i], "--field_", 8)) { off = 8; }
|
|
|
|
string extra_constant_field = string(argv[i]+off);
|
|
if (extra_constant_field == "") {
|
|
error("The extra constant field command cannot be empty.\n");
|
|
}
|
|
// The extra "floor"="42" will be pushed to the json.
|
|
debug("Added extra constant field %s\n", extra_constant_field.c_str());
|
|
c->extra_constant_fields.push_back(extra_constant_field);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--calculate_", 12))
|
|
{
|
|
// For example: --calculate_adjusted_kwh='total_kwh + 12345 kwh'
|
|
string extra_calculated_field = string(argv[i]+12);
|
|
if (extra_calculated_field == "") {
|
|
error("The calculated field command cannot be empty.\n");
|
|
}
|
|
debug("(cmdline) add calculated field %s\n", extra_calculated_field.c_str());
|
|
c->extra_calculated_fields.push_back(extra_calculated_field);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--listenvs=", 11)) {
|
|
c->list_shell_envs = true;
|
|
c->list_meter = string(argv[i]+11);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--listfields=", 13)) {
|
|
c->list_fields = true;
|
|
c->list_meter = string(argv[i]+13);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--listmeters=", 13)) {
|
|
c->list_meters = true;
|
|
c->list_meters_search = string(argv[i]+13);
|
|
i++;
|
|
continue;
|
|
}
|
|
else if (!strncmp(argv[i], "--listmeters", 12)) {
|
|
c->list_meters = true;
|
|
c->list_meters_search = "";
|
|
i++;
|
|
continue;
|
|
}
|
|
else if (!strcmp(argv[i], "--listunits")) {
|
|
c->list_units = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--oneshot")) {
|
|
c->oneshot = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--exitafter=", 12) && strlen(argv[i]) > 12) {
|
|
c->exitafter = parseTime(argv[i]+12);
|
|
if (c->exitafter <= 0) {
|
|
error("Not a valid time to exit after. \"%s\"\n", argv[i]+12);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--nodeviceexit")) {
|
|
c->nodeviceexit = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--pollinterval=", 15) && strlen(argv[i]) > 15) {
|
|
c->pollinterval = parseTime(argv[i]+15);
|
|
if (c->pollinterval <= 0) {
|
|
error("Not a valid time to regularly poll meters. \"%s\"\n", argv[i]+15);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--identitymode=", 15) && strlen(argv[i]) > 15) {
|
|
c->identity_mode = toIdentityMode(argv[i]+15);
|
|
if (c->identity_mode == IdentityMode::INVALID)
|
|
{
|
|
error("Not a valid identity mode. \"%s\"\n", argv[i]+15);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--resetafter=", 13) && strlen(argv[i]) > 13) {
|
|
c->resetafter = parseTime(argv[i]+13);
|
|
if (c->resetafter <= 0) {
|
|
error("Not a valid time to regularly reset after. \"%s\"\n", argv[i]+13);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--alarmtimeout=", 15)) {
|
|
c->alarm_timeout = parseTime(argv[i]+15);
|
|
if (c->alarm_timeout <= 0) {
|
|
error("Not a valid alarm timeout. \"%s\"\n", argv[i]+15);
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--alarmexpectedactivity=", 24)) {
|
|
string ea = string(argv[i]+24);
|
|
if (!isValidTimePeriod(ea))
|
|
{
|
|
error("Not a valid time period string. \"%s\"\n", ea.c_str());
|
|
}
|
|
c->alarm_expected_activity = ea;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--driversdir=", 13))
|
|
{
|
|
size_t len = strlen(argv[i]) - 13;
|
|
c->drivers_dir = string(argv[i]+13, len);
|
|
if (!checkIfDirExists(c->drivers_dir.c_str()))
|
|
{
|
|
error("You must supply a valid directory to --driversdir=<dir>\n");
|
|
}
|
|
i++;
|
|
loadDriversFromDir(c->drivers_dir);
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--driver=", 9))
|
|
{
|
|
size_t len = strlen(argv[i]) - 9;
|
|
string file_name = string(argv[i]+9, len);
|
|
if (!checkFileExists(file_name.c_str()))
|
|
{
|
|
error("You must supply a valid file to --driver=<file>\n");
|
|
}
|
|
i++;
|
|
loadDriver(file_name, NULL);
|
|
continue;
|
|
}
|
|
|
|
error("Unknown option \"%s\"\n", argv[i]);
|
|
}
|
|
|
|
bool found_at_least_one_device_or_hex = false;
|
|
while (argv[i])
|
|
{
|
|
if (!strncmp(argv[i], "--", 2))
|
|
{
|
|
// We have found a device and the next parameter is an option.
|
|
error("All command line options must be placed before the devices, %s is placed wrong.\n", argv[i]);
|
|
}
|
|
bool ok = handleDeviceOrHex(c, argv[i]);
|
|
if (ok)
|
|
{
|
|
found_at_least_one_device_or_hex = true;
|
|
}
|
|
else
|
|
{
|
|
if (!found_at_least_one_device_or_hex)
|
|
{
|
|
error("At least one valid device (or hex) must be supplied!\n");
|
|
}
|
|
// There are more arguments...
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (c->supplied_bus_devices.size() == 0 &&
|
|
c->use_auto_device_detect == false &&
|
|
!c->list_shell_envs &&
|
|
!c->list_fields &&
|
|
!c->list_meters &&
|
|
!c->list_units)
|
|
{
|
|
error("You must supply at least one device to communicate using (w)mbus.\n");
|
|
}
|
|
|
|
while (argv[i] != 0 && SendBusContent::isLikely(argv[i]))
|
|
{
|
|
SendBusContent sbc;
|
|
bool ok = sbc.parse(argv[i]);
|
|
if (!ok)
|
|
{
|
|
error("Not a valid send bus content command.\n");
|
|
}
|
|
c->send_bus_content.push_back(sbc);
|
|
i++;
|
|
}
|
|
|
|
if ((argc-i) % 4 != 0) {
|
|
error("For each meter you must supply a: name,type,id and key.\n");
|
|
}
|
|
int num_meters = (argc-i)/4;
|
|
|
|
for (int m=0; m<num_meters; ++m)
|
|
{
|
|
string bus;
|
|
string name = argv[m*4+i+0];
|
|
string driver = argv[m*4+i+1];
|
|
string address_expressions = argv[m*4+i+2];
|
|
string key = argv[m*4+i+3];
|
|
|
|
MeterInfo mi;
|
|
|
|
if (!isValidSequenceOfAddressExpressions(address_expressions))
|
|
{
|
|
error("Not a valid meter id nor a valid sequence of match expression \"%s\"\n", address_expressions.c_str());
|
|
}
|
|
|
|
mi.parse(name, driver, address_expressions, key);
|
|
mi.poll_interval = c->pollinterval;
|
|
mi.identity_mode = c->identity_mode;
|
|
|
|
if (!isValidKey(key, mi))
|
|
{
|
|
error("Not a valid meter key \"%s\"\n", key.c_str());
|
|
}
|
|
|
|
if (mi.driver_name.str() == "")
|
|
{
|
|
error("Not a valid meter driver \"%s\"\n", driver.c_str());
|
|
}
|
|
|
|
c->meters.push_back(mi);
|
|
}
|
|
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
|
|
shared_ptr<Configuration> parseCommandLineWithUseConfig(Configuration *c, int argc, char **argv, bool pid_file_expected)
|
|
{
|
|
int i = 1;
|
|
|
|
while (argv[i] && argv[i][0] == '-')
|
|
{
|
|
if (!strncmp(argv[i], "--useconfig", 11))
|
|
{
|
|
if (strlen(argv[i]) == 11)
|
|
{
|
|
c->useconfig = true;
|
|
c->config_root = "";
|
|
}
|
|
else if (strlen(argv[i]) > 12 && argv[i][11] == '=')
|
|
{
|
|
size_t len = strlen(argv[i]) - 12;
|
|
c->useconfig = true;
|
|
c->config_root = string(argv[i]+12, len);
|
|
if (c->config_root == "/") {
|
|
c->config_root = "";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error("You must supply a directory to --useconfig=dir\n");
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--verbose", 9))
|
|
{
|
|
c->overrides.loglevel_override = "verbose";
|
|
debug("(useconfig) loglevel override \"%s\"\n", c->overrides.loglevel_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--normal", 8))
|
|
{
|
|
c->overrides.loglevel_override = "normal";
|
|
debug("(useconfig) loglevel override \"%s\"\n", c->overrides.loglevel_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--silent", 8))
|
|
{
|
|
c->overrides.loglevel_override = "silent";
|
|
debug("(useconfig) loglevel override \"%s\"\n", c->overrides.loglevel_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--debug", 7))
|
|
{
|
|
c->overrides.loglevel_override = "debug";
|
|
debug("(useconfig) loglevel override \"%s\"\n", c->overrides.loglevel_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--trace", 7))
|
|
{
|
|
c->overrides.loglevel_override = "trace";
|
|
debug("(useconfig) loglevel override \"%s\"\n", c->overrides.loglevel_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--device=", 9)) // Deprecated
|
|
{
|
|
c->overrides.device_override = string(argv[i]+9);
|
|
debug("(useconfig) device override \"%s\"\n", c->overrides.device_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--overridedevice=", 17))
|
|
{
|
|
c->overrides.device_override = string(argv[i]+17);
|
|
debug("(useconfig) device override \"%s\"\n", c->overrides.device_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--listento=", 11))
|
|
{
|
|
c->overrides.listento_override = string(argv[i]+11);
|
|
debug("(useconfig) listento override \"%s\"\n", c->overrides.listento_override.c_str());
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--exitafter=", 12) && strlen(argv[i]) > 12) {
|
|
int s = parseTime(argv[i]+12);
|
|
if (s <= 0) {
|
|
error("Not a valid time to exit after. \"%s\"\n", argv[i]+12);
|
|
}
|
|
c->overrides.exitafter_override = argv[i]+12;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strcmp(argv[i], "--oneshot")) {
|
|
c->overrides.oneshot_override = "true";
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!strncmp(argv[i], "--logfile=", 10)) {
|
|
size_t len = strlen(argv[i])-10;
|
|
if (len > 0) {
|
|
c->overrides.logfile_override = string(argv[i]+10, len);
|
|
} else {
|
|
error("Not a valid log file name.\n");
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
error("Usage error: --useconfig=... can only be used in combination with:\n"
|
|
"--overridedevice= --listento= --exitafter= --oneshot= --logfile= --silent --normal --verbose --debug --trace\n");
|
|
break;
|
|
}
|
|
|
|
if (pid_file_expected)
|
|
{
|
|
if (!argv[i])
|
|
{
|
|
error("Usage error: you must supply the pid file as the last argument to wmbusmetersd.\n");
|
|
}
|
|
if (argv[i][0] == '-')
|
|
{
|
|
error("Usage error: the pid file name must not start with minus (-). Please change \"%s\".\n", argv[i]);
|
|
}
|
|
c->pid_file = argv[i];
|
|
i++;
|
|
|
|
if (i < argc)
|
|
{
|
|
error("Usage error: you must supply the pid file as the last argument to wmbusmetersd.\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (i < argc)
|
|
{
|
|
error("Usage error: too many arguments \"%s\" with --useconfig=...\n", argv[i]);
|
|
}
|
|
}
|
|
return shared_ptr<Configuration>(c);
|
|
}
|
|
|
|
static bool isDaemon(int argc, char **argv)
|
|
{
|
|
const char *filename = strrchr(argv[0], '/');
|
|
|
|
if (filename)
|
|
{
|
|
filename++;
|
|
}
|
|
else
|
|
{
|
|
filename = argv[0];
|
|
}
|
|
|
|
return !strcmp(filename, "wmbusmetersd");
|
|
}
|
|
|
|
static bool checkIfUseConfig(int argc, char **argv)
|
|
{
|
|
while (*argv != NULL)
|
|
{
|
|
if (!strncmp(*argv, "--useconfig", 11)) return true;
|
|
argv++;
|
|
}
|
|
|
|
return false;
|
|
}
|