mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-25 11:37:56 +00:00
1de7b4b805
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
1040 lines
22 KiB
Plaintext
1040 lines
22 KiB
Plaintext
%{
|
|
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2009-2010 The FreeBSD Foundation
|
|
* Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>
|
|
* All rights reserved.
|
|
*
|
|
* This software was developed by Pawel Jakub Dawidek under sponsorship from
|
|
* the FreeBSD Foundation.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include <sys/param.h> /* MAXHOSTNAMELEN */
|
|
#include <sys/queue.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sysexits.h>
|
|
#include <unistd.h>
|
|
|
|
#include <pjdlog.h>
|
|
|
|
#include "hast.h"
|
|
|
|
extern int depth;
|
|
extern int lineno;
|
|
|
|
extern FILE *yyin;
|
|
extern char *yytext;
|
|
|
|
static struct hastd_config *lconfig;
|
|
static struct hast_resource *curres;
|
|
static bool mynode, hadmynode;
|
|
|
|
static char depth0_control[HAST_ADDRSIZE];
|
|
static char depth0_pidfile[PATH_MAX];
|
|
static char depth0_listen_tcp4[HAST_ADDRSIZE];
|
|
static char depth0_listen_tcp6[HAST_ADDRSIZE];
|
|
static TAILQ_HEAD(, hastd_listen) depth0_listen;
|
|
static int depth0_replication;
|
|
static int depth0_checksum;
|
|
static int depth0_compression;
|
|
static int depth0_timeout;
|
|
static char depth0_exec[PATH_MAX];
|
|
static int depth0_metaflush;
|
|
|
|
static char depth1_provname[PATH_MAX];
|
|
static char depth1_localpath[PATH_MAX];
|
|
static int depth1_metaflush;
|
|
|
|
extern void yyerror(const char *);
|
|
extern int yylex(void);
|
|
extern void yyrestart(FILE *);
|
|
|
|
static int isitme(const char *name);
|
|
static bool family_supported(int family);
|
|
static int node_names(char **namesp);
|
|
%}
|
|
|
|
%token CONTROL PIDFILE LISTEN REPLICATION CHECKSUM COMPRESSION METAFLUSH
|
|
%token TIMEOUT EXEC RESOURCE NAME LOCAL REMOTE SOURCE ON OFF
|
|
%token FULLSYNC MEMSYNC ASYNC NONE CRC32 SHA256 HOLE LZF
|
|
%token NUM STR OB CB
|
|
|
|
%type <str> remote_str
|
|
%type <num> replication_type
|
|
%type <num> checksum_type
|
|
%type <num> compression_type
|
|
%type <num> boolean
|
|
|
|
%union
|
|
{
|
|
int num;
|
|
char *str;
|
|
}
|
|
|
|
%token <num> NUM
|
|
%token <str> STR
|
|
|
|
%%
|
|
|
|
statements:
|
|
|
|
|
statements statement
|
|
;
|
|
|
|
statement:
|
|
control_statement
|
|
|
|
|
pidfile_statement
|
|
|
|
|
listen_statement
|
|
|
|
|
replication_statement
|
|
|
|
|
checksum_statement
|
|
|
|
|
compression_statement
|
|
|
|
|
timeout_statement
|
|
|
|
|
exec_statement
|
|
|
|
|
metaflush_statement
|
|
|
|
|
node_statement
|
|
|
|
|
resource_statement
|
|
;
|
|
|
|
control_statement: CONTROL STR
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
if (strlcpy(depth0_control, $2,
|
|
sizeof(depth0_control)) >=
|
|
sizeof(depth0_control)) {
|
|
pjdlog_error("control argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (!mynode)
|
|
break;
|
|
if (strlcpy(lconfig->hc_controladdr, $2,
|
|
sizeof(lconfig->hc_controladdr)) >=
|
|
sizeof(lconfig->hc_controladdr)) {
|
|
pjdlog_error("control argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("control at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
pidfile_statement: PIDFILE STR
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
if (strlcpy(depth0_pidfile, $2,
|
|
sizeof(depth0_pidfile)) >=
|
|
sizeof(depth0_pidfile)) {
|
|
pjdlog_error("pidfile argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (!mynode)
|
|
break;
|
|
if (strlcpy(lconfig->hc_pidfile, $2,
|
|
sizeof(lconfig->hc_pidfile)) >=
|
|
sizeof(lconfig->hc_pidfile)) {
|
|
pjdlog_error("pidfile argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("pidfile at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
listen_statement: LISTEN STR
|
|
{
|
|
struct hastd_listen *lst;
|
|
|
|
lst = calloc(1, sizeof(*lst));
|
|
if (lst == NULL) {
|
|
pjdlog_error("Unable to allocate memory for listen address.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
if (strlcpy(lst->hl_addr, $2, sizeof(lst->hl_addr)) >=
|
|
sizeof(lst->hl_addr)) {
|
|
pjdlog_error("listen argument is too long.");
|
|
free($2);
|
|
free(lst);
|
|
return (1);
|
|
}
|
|
switch (depth) {
|
|
case 0:
|
|
TAILQ_INSERT_TAIL(&depth0_listen, lst, hl_next);
|
|
break;
|
|
case 1:
|
|
if (mynode)
|
|
TAILQ_INSERT_TAIL(&depth0_listen, lst, hl_next);
|
|
else
|
|
free(lst);
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("listen at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
replication_statement: REPLICATION replication_type
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
depth0_replication = $2;
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
curres->hr_replication = $2;
|
|
curres->hr_original_replication = $2;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("replication at wrong depth level");
|
|
}
|
|
}
|
|
;
|
|
|
|
replication_type:
|
|
FULLSYNC { $$ = HAST_REPLICATION_FULLSYNC; }
|
|
|
|
|
MEMSYNC { $$ = HAST_REPLICATION_MEMSYNC; }
|
|
|
|
|
ASYNC { $$ = HAST_REPLICATION_ASYNC; }
|
|
;
|
|
|
|
checksum_statement: CHECKSUM checksum_type
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
depth0_checksum = $2;
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
curres->hr_checksum = $2;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("checksum at wrong depth level");
|
|
}
|
|
}
|
|
;
|
|
|
|
checksum_type:
|
|
NONE { $$ = HAST_CHECKSUM_NONE; }
|
|
|
|
|
CRC32 { $$ = HAST_CHECKSUM_CRC32; }
|
|
|
|
|
SHA256 { $$ = HAST_CHECKSUM_SHA256; }
|
|
;
|
|
|
|
compression_statement: COMPRESSION compression_type
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
depth0_compression = $2;
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
curres->hr_compression = $2;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("compression at wrong depth level");
|
|
}
|
|
}
|
|
;
|
|
|
|
compression_type:
|
|
NONE { $$ = HAST_COMPRESSION_NONE; }
|
|
|
|
|
HOLE { $$ = HAST_COMPRESSION_HOLE; }
|
|
|
|
|
LZF { $$ = HAST_COMPRESSION_LZF; }
|
|
;
|
|
|
|
timeout_statement: TIMEOUT NUM
|
|
{
|
|
if ($2 <= 0) {
|
|
pjdlog_error("Negative or zero timeout.");
|
|
return (1);
|
|
}
|
|
switch (depth) {
|
|
case 0:
|
|
depth0_timeout = $2;
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
curres->hr_timeout = $2;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("timeout at wrong depth level");
|
|
}
|
|
}
|
|
;
|
|
|
|
exec_statement: EXEC STR
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
if (strlcpy(depth0_exec, $2, sizeof(depth0_exec)) >=
|
|
sizeof(depth0_exec)) {
|
|
pjdlog_error("Exec path is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
if (strlcpy(curres->hr_exec, $2,
|
|
sizeof(curres->hr_exec)) >=
|
|
sizeof(curres->hr_exec)) {
|
|
pjdlog_error("Exec path is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("exec at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
metaflush_statement: METAFLUSH boolean
|
|
{
|
|
switch (depth) {
|
|
case 0:
|
|
depth0_metaflush = $2;
|
|
break;
|
|
case 1:
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
depth1_metaflush = $2;
|
|
break;
|
|
case 2:
|
|
if (!mynode)
|
|
break;
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
curres->hr_metaflush = $2;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("metaflush at wrong depth level");
|
|
}
|
|
}
|
|
;
|
|
|
|
boolean:
|
|
ON { $$ = 1; }
|
|
|
|
|
OFF { $$ = 0; }
|
|
;
|
|
|
|
node_statement: ON node_start OB node_entries CB
|
|
{
|
|
mynode = false;
|
|
}
|
|
;
|
|
|
|
node_start: STR
|
|
{
|
|
switch (isitme($1)) {
|
|
case -1:
|
|
free($1);
|
|
return (1);
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
mynode = true;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("invalid isitme() return value");
|
|
}
|
|
free($1);
|
|
}
|
|
;
|
|
|
|
node_entries:
|
|
|
|
|
node_entries node_entry
|
|
;
|
|
|
|
node_entry:
|
|
control_statement
|
|
|
|
|
pidfile_statement
|
|
|
|
|
listen_statement
|
|
;
|
|
|
|
resource_statement: RESOURCE resource_start OB resource_entries CB
|
|
{
|
|
if (curres != NULL) {
|
|
/*
|
|
* There must be section for this node, at least with
|
|
* remote address configuration.
|
|
*/
|
|
if (!hadmynode) {
|
|
char *names;
|
|
|
|
if (node_names(&names) != 0)
|
|
return (1);
|
|
pjdlog_error("No resource %s configuration for this node (acceptable node names: %s).",
|
|
curres->hr_name, names);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Let's see if there are some resource-level settings
|
|
* that we can use for node-level settings.
|
|
*/
|
|
if (curres->hr_provname[0] == '\0' &&
|
|
depth1_provname[0] != '\0') {
|
|
/*
|
|
* Provider name is not set at node-level,
|
|
* but is set at resource-level, use it.
|
|
*/
|
|
strlcpy(curres->hr_provname, depth1_provname,
|
|
sizeof(curres->hr_provname));
|
|
}
|
|
if (curres->hr_localpath[0] == '\0' &&
|
|
depth1_localpath[0] != '\0') {
|
|
/*
|
|
* Path to local provider is not set at
|
|
* node-level, but is set at resource-level,
|
|
* use it.
|
|
*/
|
|
strlcpy(curres->hr_localpath, depth1_localpath,
|
|
sizeof(curres->hr_localpath));
|
|
}
|
|
if (curres->hr_metaflush == -1 && depth1_metaflush != -1) {
|
|
/*
|
|
* Metaflush is not set at node-level,
|
|
* but is set at resource-level, use it.
|
|
*/
|
|
curres->hr_metaflush = depth1_metaflush;
|
|
}
|
|
|
|
/*
|
|
* If provider name is not given, use resource name
|
|
* as provider name.
|
|
*/
|
|
if (curres->hr_provname[0] == '\0') {
|
|
strlcpy(curres->hr_provname, curres->hr_name,
|
|
sizeof(curres->hr_provname));
|
|
}
|
|
|
|
/*
|
|
* Remote address has to be configured at this point.
|
|
*/
|
|
if (curres->hr_remoteaddr[0] == '\0') {
|
|
pjdlog_error("Remote address not configured for resource %s.",
|
|
curres->hr_name);
|
|
return (1);
|
|
}
|
|
/*
|
|
* Path to local provider has to be configured at this
|
|
* point.
|
|
*/
|
|
if (curres->hr_localpath[0] == '\0') {
|
|
pjdlog_error("Path to local component not configured for resource %s.",
|
|
curres->hr_name);
|
|
return (1);
|
|
}
|
|
|
|
/* Put it onto resource list. */
|
|
TAILQ_INSERT_TAIL(&lconfig->hc_resources, curres, hr_next);
|
|
curres = NULL;
|
|
}
|
|
}
|
|
;
|
|
|
|
resource_start: STR
|
|
{
|
|
/* Check if there is no duplicate entry. */
|
|
TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) {
|
|
if (strcmp(curres->hr_name, $1) == 0) {
|
|
pjdlog_error("Resource %s configured more than once.",
|
|
curres->hr_name);
|
|
free($1);
|
|
return (1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Clear those, so we can tell if they were set at
|
|
* resource-level or not.
|
|
*/
|
|
depth1_provname[0] = '\0';
|
|
depth1_localpath[0] = '\0';
|
|
depth1_metaflush = -1;
|
|
hadmynode = false;
|
|
|
|
curres = calloc(1, sizeof(*curres));
|
|
if (curres == NULL) {
|
|
pjdlog_error("Unable to allocate memory for resource.");
|
|
free($1);
|
|
return (1);
|
|
}
|
|
if (strlcpy(curres->hr_name, $1,
|
|
sizeof(curres->hr_name)) >=
|
|
sizeof(curres->hr_name)) {
|
|
pjdlog_error("Resource name is too long.");
|
|
free(curres);
|
|
free($1);
|
|
return (1);
|
|
}
|
|
free($1);
|
|
curres->hr_role = HAST_ROLE_INIT;
|
|
curres->hr_previous_role = HAST_ROLE_INIT;
|
|
curres->hr_replication = -1;
|
|
curres->hr_original_replication = -1;
|
|
curres->hr_checksum = -1;
|
|
curres->hr_compression = -1;
|
|
curres->hr_version = 1;
|
|
curres->hr_timeout = -1;
|
|
curres->hr_exec[0] = '\0';
|
|
curres->hr_provname[0] = '\0';
|
|
curres->hr_localpath[0] = '\0';
|
|
curres->hr_localfd = -1;
|
|
curres->hr_localflush = true;
|
|
curres->hr_metaflush = -1;
|
|
curres->hr_remoteaddr[0] = '\0';
|
|
curres->hr_sourceaddr[0] = '\0';
|
|
curres->hr_ggateunit = -1;
|
|
}
|
|
;
|
|
|
|
resource_entries:
|
|
|
|
|
resource_entries resource_entry
|
|
;
|
|
|
|
resource_entry:
|
|
replication_statement
|
|
|
|
|
checksum_statement
|
|
|
|
|
compression_statement
|
|
|
|
|
timeout_statement
|
|
|
|
|
exec_statement
|
|
|
|
|
metaflush_statement
|
|
|
|
|
name_statement
|
|
|
|
|
local_statement
|
|
|
|
|
resource_node_statement
|
|
;
|
|
|
|
name_statement: NAME STR
|
|
{
|
|
switch (depth) {
|
|
case 1:
|
|
if (strlcpy(depth1_provname, $2,
|
|
sizeof(depth1_provname)) >=
|
|
sizeof(depth1_provname)) {
|
|
pjdlog_error("name argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (!mynode)
|
|
break;
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
if (strlcpy(curres->hr_provname, $2,
|
|
sizeof(curres->hr_provname)) >=
|
|
sizeof(curres->hr_provname)) {
|
|
pjdlog_error("name argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("name at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
local_statement: LOCAL STR
|
|
{
|
|
switch (depth) {
|
|
case 1:
|
|
if (strlcpy(depth1_localpath, $2,
|
|
sizeof(depth1_localpath)) >=
|
|
sizeof(depth1_localpath)) {
|
|
pjdlog_error("local argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (!mynode)
|
|
break;
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
if (strlcpy(curres->hr_localpath, $2,
|
|
sizeof(curres->hr_localpath)) >=
|
|
sizeof(curres->hr_localpath)) {
|
|
pjdlog_error("local argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("local at wrong depth level");
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
resource_node_statement:ON resource_node_start OB resource_node_entries CB
|
|
{
|
|
mynode = false;
|
|
}
|
|
;
|
|
|
|
resource_node_start: STR
|
|
{
|
|
if (curres != NULL) {
|
|
switch (isitme($1)) {
|
|
case -1:
|
|
free($1);
|
|
return (1);
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
mynode = hadmynode = true;
|
|
break;
|
|
default:
|
|
PJDLOG_ABORT("invalid isitme() return value");
|
|
}
|
|
}
|
|
free($1);
|
|
}
|
|
;
|
|
|
|
resource_node_entries:
|
|
|
|
|
resource_node_entries resource_node_entry
|
|
;
|
|
|
|
resource_node_entry:
|
|
name_statement
|
|
|
|
|
local_statement
|
|
|
|
|
remote_statement
|
|
|
|
|
source_statement
|
|
|
|
|
metaflush_statement
|
|
;
|
|
|
|
remote_statement: REMOTE remote_str
|
|
{
|
|
PJDLOG_ASSERT(depth == 2);
|
|
if (mynode) {
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
if (strlcpy(curres->hr_remoteaddr, $2,
|
|
sizeof(curres->hr_remoteaddr)) >=
|
|
sizeof(curres->hr_remoteaddr)) {
|
|
pjdlog_error("remote argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
remote_str:
|
|
NONE { $$ = strdup("none"); }
|
|
|
|
|
STR { }
|
|
;
|
|
|
|
source_statement: SOURCE STR
|
|
{
|
|
PJDLOG_ASSERT(depth == 2);
|
|
if (mynode) {
|
|
PJDLOG_ASSERT(curres != NULL);
|
|
if (strlcpy(curres->hr_sourceaddr, $2,
|
|
sizeof(curres->hr_sourceaddr)) >=
|
|
sizeof(curres->hr_sourceaddr)) {
|
|
pjdlog_error("source argument is too long.");
|
|
free($2);
|
|
return (1);
|
|
}
|
|
}
|
|
free($2);
|
|
}
|
|
;
|
|
|
|
%%
|
|
|
|
static int
|
|
isitme(const char *name)
|
|
{
|
|
char buf[MAXHOSTNAMELEN];
|
|
unsigned long hostid;
|
|
char *pos;
|
|
size_t bufsize;
|
|
|
|
/*
|
|
* First check if the given name matches our full hostname.
|
|
*/
|
|
if (gethostname(buf, sizeof(buf)) < 0) {
|
|
pjdlog_errno(LOG_ERR, "gethostname() failed");
|
|
return (-1);
|
|
}
|
|
if (strcmp(buf, name) == 0)
|
|
return (1);
|
|
|
|
/*
|
|
* Check if it matches first part of the host name.
|
|
*/
|
|
pos = strchr(buf, '.');
|
|
if (pos != NULL && (size_t)(pos - buf) == strlen(name) &&
|
|
strncmp(buf, name, pos - buf) == 0) {
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Check if it matches host UUID.
|
|
*/
|
|
bufsize = sizeof(buf);
|
|
if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
|
|
pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
|
|
return (-1);
|
|
}
|
|
if (strcasecmp(buf, name) == 0)
|
|
return (1);
|
|
|
|
/*
|
|
* Check if it matches hostid.
|
|
*/
|
|
bufsize = sizeof(hostid);
|
|
if (sysctlbyname("kern.hostid", &hostid, &bufsize, NULL, 0) < 0) {
|
|
pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostid) failed");
|
|
return (-1);
|
|
}
|
|
(void)snprintf(buf, sizeof(buf), "hostid%lu", hostid);
|
|
if (strcmp(buf, name) == 0)
|
|
return (1);
|
|
|
|
/*
|
|
* Looks like this isn't about us.
|
|
*/
|
|
return (0);
|
|
}
|
|
|
|
static bool
|
|
family_supported(int family)
|
|
{
|
|
int sock;
|
|
|
|
sock = socket(family, SOCK_STREAM, 0);
|
|
if (sock == -1 && errno == EPROTONOSUPPORT)
|
|
return (false);
|
|
if (sock >= 0)
|
|
(void)close(sock);
|
|
return (true);
|
|
}
|
|
|
|
static int
|
|
node_names(char **namesp)
|
|
{
|
|
static char names[MAXHOSTNAMELEN * 3];
|
|
char buf[MAXHOSTNAMELEN];
|
|
unsigned long hostid;
|
|
char *pos;
|
|
size_t bufsize;
|
|
|
|
if (gethostname(buf, sizeof(buf)) < 0) {
|
|
pjdlog_errno(LOG_ERR, "gethostname() failed");
|
|
return (-1);
|
|
}
|
|
|
|
/* First component of the host name. */
|
|
pos = strchr(buf, '.');
|
|
if (pos != NULL && pos != buf) {
|
|
(void)strlcpy(names, buf, MIN((size_t)(pos - buf + 1),
|
|
sizeof(names)));
|
|
(void)strlcat(names, ", ", sizeof(names));
|
|
}
|
|
|
|
/* Full host name. */
|
|
(void)strlcat(names, buf, sizeof(names));
|
|
(void)strlcat(names, ", ", sizeof(names));
|
|
|
|
/* Host UUID. */
|
|
bufsize = sizeof(buf);
|
|
if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
|
|
pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
|
|
return (-1);
|
|
}
|
|
(void)strlcat(names, buf, sizeof(names));
|
|
(void)strlcat(names, ", ", sizeof(names));
|
|
|
|
/* Host ID. */
|
|
bufsize = sizeof(hostid);
|
|
if (sysctlbyname("kern.hostid", &hostid, &bufsize, NULL, 0) < 0) {
|
|
pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostid) failed");
|
|
return (-1);
|
|
}
|
|
(void)snprintf(buf, sizeof(buf), "hostid%lu", hostid);
|
|
(void)strlcat(names, buf, sizeof(names));
|
|
|
|
*namesp = names;
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
yyerror(const char *str)
|
|
{
|
|
|
|
pjdlog_error("Unable to parse configuration file at line %d near '%s': %s",
|
|
lineno, yytext, str);
|
|
}
|
|
|
|
struct hastd_config *
|
|
yy_config_parse(const char *config, bool exitonerror)
|
|
{
|
|
int ret;
|
|
|
|
curres = NULL;
|
|
mynode = false;
|
|
depth = 0;
|
|
lineno = 0;
|
|
|
|
depth0_timeout = HAST_TIMEOUT;
|
|
depth0_replication = HAST_REPLICATION_MEMSYNC;
|
|
depth0_checksum = HAST_CHECKSUM_NONE;
|
|
depth0_compression = HAST_COMPRESSION_HOLE;
|
|
strlcpy(depth0_control, HAST_CONTROL, sizeof(depth0_control));
|
|
strlcpy(depth0_pidfile, HASTD_PIDFILE, sizeof(depth0_pidfile));
|
|
TAILQ_INIT(&depth0_listen);
|
|
strlcpy(depth0_listen_tcp4, HASTD_LISTEN_TCP4,
|
|
sizeof(depth0_listen_tcp4));
|
|
strlcpy(depth0_listen_tcp6, HASTD_LISTEN_TCP6,
|
|
sizeof(depth0_listen_tcp6));
|
|
depth0_exec[0] = '\0';
|
|
depth0_metaflush = 1;
|
|
|
|
lconfig = calloc(1, sizeof(*lconfig));
|
|
if (lconfig == NULL) {
|
|
pjdlog_error("Unable to allocate memory for configuration.");
|
|
if (exitonerror)
|
|
exit(EX_TEMPFAIL);
|
|
return (NULL);
|
|
}
|
|
|
|
TAILQ_INIT(&lconfig->hc_listen);
|
|
TAILQ_INIT(&lconfig->hc_resources);
|
|
|
|
yyin = fopen(config, "r");
|
|
if (yyin == NULL) {
|
|
pjdlog_errno(LOG_ERR, "Unable to open configuration file %s",
|
|
config);
|
|
yy_config_free(lconfig);
|
|
if (exitonerror)
|
|
exit(EX_OSFILE);
|
|
return (NULL);
|
|
}
|
|
yyrestart(yyin);
|
|
ret = yyparse();
|
|
fclose(yyin);
|
|
if (ret != 0) {
|
|
yy_config_free(lconfig);
|
|
if (exitonerror)
|
|
exit(EX_CONFIG);
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Let's see if everything is set up.
|
|
*/
|
|
if (lconfig->hc_controladdr[0] == '\0') {
|
|
strlcpy(lconfig->hc_controladdr, depth0_control,
|
|
sizeof(lconfig->hc_controladdr));
|
|
}
|
|
if (lconfig->hc_pidfile[0] == '\0') {
|
|
strlcpy(lconfig->hc_pidfile, depth0_pidfile,
|
|
sizeof(lconfig->hc_pidfile));
|
|
}
|
|
if (!TAILQ_EMPTY(&depth0_listen))
|
|
TAILQ_CONCAT(&lconfig->hc_listen, &depth0_listen, hl_next);
|
|
if (TAILQ_EMPTY(&lconfig->hc_listen)) {
|
|
struct hastd_listen *lst;
|
|
|
|
if (family_supported(AF_INET)) {
|
|
lst = calloc(1, sizeof(*lst));
|
|
if (lst == NULL) {
|
|
pjdlog_error("Unable to allocate memory for listen address.");
|
|
yy_config_free(lconfig);
|
|
if (exitonerror)
|
|
exit(EX_TEMPFAIL);
|
|
return (NULL);
|
|
}
|
|
(void)strlcpy(lst->hl_addr, depth0_listen_tcp4,
|
|
sizeof(lst->hl_addr));
|
|
TAILQ_INSERT_TAIL(&lconfig->hc_listen, lst, hl_next);
|
|
} else {
|
|
pjdlog_debug(1,
|
|
"No IPv4 support in the kernel, not listening on IPv4 address.");
|
|
}
|
|
if (family_supported(AF_INET6)) {
|
|
lst = calloc(1, sizeof(*lst));
|
|
if (lst == NULL) {
|
|
pjdlog_error("Unable to allocate memory for listen address.");
|
|
yy_config_free(lconfig);
|
|
if (exitonerror)
|
|
exit(EX_TEMPFAIL);
|
|
return (NULL);
|
|
}
|
|
(void)strlcpy(lst->hl_addr, depth0_listen_tcp6,
|
|
sizeof(lst->hl_addr));
|
|
TAILQ_INSERT_TAIL(&lconfig->hc_listen, lst, hl_next);
|
|
} else {
|
|
pjdlog_debug(1,
|
|
"No IPv6 support in the kernel, not listening on IPv6 address.");
|
|
}
|
|
if (TAILQ_EMPTY(&lconfig->hc_listen)) {
|
|
pjdlog_error("No address to listen on.");
|
|
yy_config_free(lconfig);
|
|
if (exitonerror)
|
|
exit(EX_TEMPFAIL);
|
|
return (NULL);
|
|
}
|
|
}
|
|
TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) {
|
|
PJDLOG_ASSERT(curres->hr_provname[0] != '\0');
|
|
PJDLOG_ASSERT(curres->hr_localpath[0] != '\0');
|
|
PJDLOG_ASSERT(curres->hr_remoteaddr[0] != '\0');
|
|
|
|
if (curres->hr_replication == -1) {
|
|
/*
|
|
* Replication is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
curres->hr_replication = depth0_replication;
|
|
curres->hr_original_replication = depth0_replication;
|
|
}
|
|
if (curres->hr_checksum == -1) {
|
|
/*
|
|
* Checksum is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
curres->hr_checksum = depth0_checksum;
|
|
}
|
|
if (curres->hr_compression == -1) {
|
|
/*
|
|
* Compression is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
curres->hr_compression = depth0_compression;
|
|
}
|
|
if (curres->hr_timeout == -1) {
|
|
/*
|
|
* Timeout is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
curres->hr_timeout = depth0_timeout;
|
|
}
|
|
if (curres->hr_exec[0] == '\0') {
|
|
/*
|
|
* Exec is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
strlcpy(curres->hr_exec, depth0_exec,
|
|
sizeof(curres->hr_exec));
|
|
}
|
|
if (curres->hr_metaflush == -1) {
|
|
/*
|
|
* Metaflush is not set at resource-level.
|
|
* Use global or default setting.
|
|
*/
|
|
curres->hr_metaflush = depth0_metaflush;
|
|
}
|
|
}
|
|
|
|
return (lconfig);
|
|
}
|
|
|
|
void
|
|
yy_config_free(struct hastd_config *config)
|
|
{
|
|
struct hastd_listen *lst;
|
|
struct hast_resource *res;
|
|
|
|
while ((lst = TAILQ_FIRST(&depth0_listen)) != NULL) {
|
|
TAILQ_REMOVE(&depth0_listen, lst, hl_next);
|
|
free(lst);
|
|
}
|
|
while ((lst = TAILQ_FIRST(&config->hc_listen)) != NULL) {
|
|
TAILQ_REMOVE(&config->hc_listen, lst, hl_next);
|
|
free(lst);
|
|
}
|
|
while ((res = TAILQ_FIRST(&config->hc_resources)) != NULL) {
|
|
TAILQ_REMOVE(&config->hc_resources, res, hr_next);
|
|
free(res);
|
|
}
|
|
free(config);
|
|
}
|