kolan
/
gkrellm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
gkrellm/server/main.c

1700 lines
41 KiB
C
Raw Blame History

/* GKrellM
| Copyright (C) 1999-2007 Bill Wilson
|
| Author: Bill Wilson billw@gkrellm.net
| Latest versions might be found at: http://gkrellm.net
|
|
| GKrellM 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.
|
| GKrellM 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 "gkrellmd.h"
#include "gkrellmd-private.h"
#include "log-private.h"
#if !defined(WIN32)
#include <syslog.h>
#endif // !WIN32
// win32 defines addrinfo but only supports getaddrinfo call on winxp or newer
#if !defined(HAVE_GETADDRINFO) && !defined(WIN32)
struct addrinfo
{
int ai_flags; /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
int ai_family; /* PF_xxx */
int ai_socktype; /* SOCK_xxx */
int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
size_t ai_addrlen; /* length of ai_addr */
char *ai_canonname; /* canonical name for hostname */
struct sockaddr *ai_addr; /* binary address */
struct addrinfo *ai_next; /* next structure in linked list */
};
#endif // !HAVE_GETADDRINFO
#if !defined(IPV6_V6ONLY) && defined(IPV6_BINDV6ONLY)
#define IPV6_V6ONLY IPV6_BINDV6ONLY
#endif
struct GkrellmdConfig _GK;
GkrellmdTicks GK;
GList *gkrellmd_client_list,
*gkrellmd_plugin_config_list;
static GList *allow_host_list;
#if !defined(WIN32)
static gboolean detach_flag;
struct
{
uid_t uid;
uid_t gid;
}
drop_privs = { 0, 0 };
#endif /* !defined(WIN32) */
#if defined(WIN32)
/*
Flag that determines if gkrellmd was started as a console app (FALSE)
or as a service (TRUE)
*/
static gboolean service_is_one = FALSE;
// Flag that is TRUE while gkrellmd should stay in its main loop
static gboolean service_running = FALSE;
// Unique name for the installed windows service (do not translate!)
static wchar_t* service_name = L"gkrellmd";
// User visible name for the installed windows service
static wchar_t* service_display_name = L"GKrellM Daemon";
/*
Current service status if running as a service, may be stopped or running
(pausing is not supported)
*/
static SERVICE_STATUS service_status;
/*
Handle that allows changing the service status.
Main use is to stop the running service.
*/
static SERVICE_STATUS_HANDLE service_status_handle = 0;
/*
Handle to our event log source.
The Windows Event Log is used as a replacement for syslog-logging.
*/
static HANDLE h_event_log = NULL;
#endif /* defined(WIN32) */
static gboolean
gkrellmd_syslog_init()
{
#if defined(WIN32)
h_event_log = RegisterEventSourceW(NULL, service_name);
if (h_event_log == NULL)
{
g_warning("Cannot register event source for logging into Windows Event Log.\n");
return FALSE;
}
#else
// Unix needs no logging initialization
#endif
return TRUE;
}
static gboolean
gkrellmd_syslog_cleanup()
{
#if defined(WIN32)
if (h_event_log)
DeregisterEventSource(h_event_log);
h_event_log = NULL;
#else
// Unix needs no further logging cleanup
#endif
return TRUE;
}
static void gkrellmd_syslog_log(GLogLevelFlags log_level, const gchar *message)
{
#if defined(WIN32)
WORD event_type;
const char *p_buf[1];
// Abort if event source is missing
if (h_event_log == NULL)
return;
event_type = EVENTLOG_INFORMATION_TYPE;
if (log_level & G_LOG_LEVEL_WARNING)
event_type = EVENTLOG_WARNING_TYPE;
if (log_level & G_LOG_LEVEL_CRITICAL || log_level & G_LOG_LEVEL_ERROR)
event_type = EVENTLOG_ERROR_TYPE;
p_buf[0] = message;
ReportEventA(
h_event_log, // Event source handle (HANDLE)
event_type, // Event type (WORD)
0, // Event category (WORD)
0, // Event identifier (DWORD)
NULL, // user security identifier (PSID)
1, // Number of substitution strings (WORD)
0, // Data Size (DWORD)
p_buf, // Pointer to strings
NULL // Pointer to Data
);
#else
int facility_priority;
// default to info and override with other states if they are more important
facility_priority = LOG_MAKEPRI(LOG_DAEMON, LOG_INFO);
if (log_level & G_LOG_LEVEL_DEBUG)
facility_priority = LOG_MAKEPRI(LOG_DAEMON, LOG_DEBUG);
if (log_level & G_LOG_LEVEL_WARNING)
facility_priority = LOG_MAKEPRI(LOG_DAEMON, LOG_WARNING);
if (log_level & G_LOG_LEVEL_ERROR)
facility_priority = LOG_MAKEPRI(LOG_DAEMON, LOG_ERR);
if (log_level & G_LOG_LEVEL_CRITICAL)
facility_priority = LOG_MAKEPRI(LOG_DAEMON, LOG_CRIT);
syslog(facility_priority, message);
#endif // defined(WIN32)
} // gkrellmd_syslog_log()
static void
make_pidfile(void)
{
#if !defined(WIN32)
FILE *f;
if (!_GK.pidfile)
return;
f = fopen(_GK.pidfile, "w");
if (f)
{
fprintf(f, "%d\n", getpid());
fclose(f);
}
else
g_warning("Can't create pidfile %s\n", _GK.pidfile);
#endif
}
static void
remove_pidfile(void)
{
#if !defined(WIN32)
if (_GK.pidfile)
unlink(_GK.pidfile);
#endif
}
static void
gkrellmd_cleanup()
{
gkrellm_sys_main_cleanup();
gkrellm_log_cleanup();
remove_pidfile();
}
static void
cb_sigterm(gint sig)
{
g_message("GKrellM Daemon %d.%d.%d%s: Exiting normally\n",
GKRELLMD_VERSION_MAJOR, GKRELLMD_VERSION_MINOR,
GKRELLMD_VERSION_REV, GKRELLMD_EXTRAVERSION);
gkrellmd_cleanup();
exit(0);
}
gint
gkrellmd_send_to_client(GkrellmdClient *client, gchar *buf)
{
gint n;
if (!client->alive)
return 0;
#if defined(MSG_NOSIGNAL)
n = send(client->fd, buf, strlen(buf), MSG_NOSIGNAL);
#else
n = send(client->fd, buf, strlen(buf), 0);
#endif
if (n < 0 && errno == EPIPE)
{
if (_GK.verbose)
g_print("Write on closed pipe to host %s\n", client->hostname);
client->alive = FALSE;
}
return n;
}
#if 0
static gint
getline(gint fd, gchar *buf, gint len)
{
fd_set read_fds;
struct timeval tv;
gchar *s;
gint result, n;
FD_ZERO(&read_fds);
FD_SET(fd, &read_fds);
tv.tv_usec = 0;
tv.tv_sec = 15;
s = buf;
*s = '\0';
for (n = 0; n < len - 1; ++n)
{
result = select(fd + 1, &read_fds, NULL, NULL, &tv);
if (result <= 0 || read(fd, s, 1) != 1)
break;
if (*s == '\n')
{
*s = '\0';
break;
}
*++s = '\0';
}
return n;
}
#endif
#ifdef HAVE_GETADDRINFO
static gboolean
is_valid_reverse(char *addr, char *host, sa_family_t family)
{
struct addrinfo hints, *res, *r;
int error, good;
char addrbuf[NI_MAXHOST];
/* Reject numeric addresses */
memset(&hints, 0, sizeof(hints));
hints.ai_family = family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
if (getaddrinfo(host, NULL, &hints, &res) == 0)
{
freeaddrinfo(res);
return 0;
}
/* Check for spoof */
memset(&hints, 0, sizeof(hints));
hints.ai_family = family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if (getaddrinfo(host, NULL, &hints, &res) != 0)
return 0;
good = 0;
for (r = res; good == 0 && r; r = r->ai_next)
{
error = getnameinfo(r->ai_addr, r->ai_addrlen,
addrbuf, sizeof(addrbuf), NULL, 0,
NI_NUMERICHOST | NI_WITHSCOPEID);
if (error == 0 && strcmp(addr, addrbuf) == 0)
{
good = 1;
break;
}
}
freeaddrinfo(res);
return good;
}
#endif
/* Check for CIDR match.
*/
static gboolean
cidr_match(struct sockaddr *sa, socklen_t salen, char *allowed)
{
#ifdef HAVE_GETADDRINFO
struct addrinfo hints, *res;
struct sockaddr_storage ss;
char *buf;
char *p, *ep;
guchar *addr, *pat;
uint32_t mask;
int plen;
#if defined(INET6)
int i;
#endif
gboolean result;
buf = g_strdup(allowed);
plen = -1;
if ((p = strchr(buf, '/')) != NULL)
{
plen = strtoul(p + 1, &ep, 10);
if (errno != 0 || ep == NULL || *ep != '\0' || plen < 0)
{
g_free(buf);
return FALSE;
}
*p = '\0';
allowed = buf;
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
result = getaddrinfo(allowed, NULL, &hints, &res);
g_free(buf);
if (result != 0)
return FALSE;
memcpy(&ss, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
if (sa->sa_family != ((struct sockaddr *)&ss)->sa_family)
return FALSE;
switch (sa->sa_family)
{
#if defined(INET6)
case AF_INET6:
if (plen < 0)
plen = 128;
if (plen > 128)
return FALSE;
if (((struct sockaddr_in6 *)&ss)->sin6_scope_id != 0 &&
((struct sockaddr_in6 *)&ss)->sin6_scope_id !=
((struct sockaddr_in6 *)sa)->sin6_scope_id)
return FALSE;
addr = (guchar *)&((struct sockaddr_in6 *)sa)->sin6_addr;
pat = (guchar *)&((struct sockaddr_in6 *)&ss)->sin6_addr;
i = 0;
while (plen > 0)
{
if (plen < 32)
{
mask = htonl(~(0xffffffff >> plen));
if ((*(uint32_t *)&addr[i] & mask) !=
(*(uint32_t *)&pat[i] & mask))
return FALSE;
break;
}
if (*(uint32_t *)&addr[i] !=
*(uint32_t *)&pat[i])
return FALSE;
i += 4;
plen -= 32;
}
break;
#endif
case AF_INET:
if (plen < 0)
plen = 32;
if (plen > 32)
return FALSE;
addr = (guchar *)&((struct sockaddr_in *)sa)->sin_addr;
pat = (guchar *)&((struct sockaddr_in *)&ss)->sin_addr;
mask = htonl(~(0xffffffff >> plen));
if ((*(uint32_t *)addr & mask) !=
(*(uint32_t *)pat & mask))
return FALSE;
break;
default:
return FALSE;
}
return TRUE;
#else
return FALSE;
#endif
}
static gboolean
allow_host(GkrellmdClient *client, struct sockaddr *sa, socklen_t salen)
{
GList *list;
#ifdef HAVE_GETADDRINFO
int error;
char hostbuf[NI_MAXHOST], addrbuf[NI_MAXHOST];
#else
struct hostent *hostent;
#endif
gchar buf[128];
gchar *hostname = NULL,
*addr = NULL;
gchar *s, *allowed;
#ifdef HAVE_GETADDRINFO
error = getnameinfo(sa, salen, addrbuf, sizeof(addrbuf),
NULL, 0, NI_NUMERICHOST | NI_WITHSCOPEID);
if (error == 0)
{
addr = addrbuf;
error = getnameinfo(sa, salen, hostbuf, sizeof(hostbuf),
NULL, 0, NI_NAMEREQD);
if (error == 0 &&
is_valid_reverse(addrbuf, hostbuf, sa->sa_family))
hostname = hostbuf;
}
#else
hostent = gethostbyaddr((gchar *)&((struct sockaddr_in *)sa)->sin_addr,
sizeof(struct in_addr), AF_INET);
if (hostent)
hostname = hostent->h_name;
addr = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
#endif
client->hostname = g_strdup(hostname ? hostname : addr);
if (!allow_host_list)
return TRUE;
for (list = allow_host_list; list; list = list->next)
{
allowed = (gchar *) list->data;
if ( (hostname && !strcmp(hostname, allowed))
|| (addr && !strcmp(addr, allowed))
|| !strcmp("ALL", allowed)
)
return TRUE;
if (addr && cidr_match(sa, salen, allowed))
return TRUE;
/* Check for simple IPv4 subnet match. Worry later about ranges and
| other hosts_access type patterns.
*/
if ( addr
&& (s = strrchr(allowed, (int) '.')) != NULL
&& *(s + 1) == '*' && *(s + 2) == '\0'
&& !strncmp(addr, allowed, (gint) (s - allowed + 1))
)
return TRUE;
}
snprintf(buf, sizeof(buf), _("Connection not allowed from %s\n"),
hostname ? hostname : addr);
g_warning(buf),
gkrellmd_send_to_client(client, "<error>\n");
gkrellmd_send_to_client(client, buf);
return FALSE;
}
/* client sends line: gkrellm x.y.z
*/
static GkrellmdClient *
accept_client(gint fd, struct sockaddr *sa, socklen_t salen)
{
GkrellmdClient *client;
gchar buf[64], name[32];
gboolean client_limit;
gint err;
client = g_new0(GkrellmdClient, 1);
client->fd = fd;
client->alive = TRUE;
client_limit = (g_list_length(gkrellmd_client_list) >= _GK.max_clients);
if (!allow_host(client, sa, salen) || client_limit)
{
if (client_limit)
{
g_message(_("Too many clients, rejecting %s\n"), client->hostname);
gkrellmd_send_to_client(client,
"<error>\nClient limit exceeded.\n");
}
g_free(client->hostname);
g_free(client);
return NULL;
}
err = recv(fd, buf, sizeof(buf), 0);
if (err > 0)
buf[err] = '\0';
else
buf[0] = '\0';
//getline(fd, buf, sizeof(buf));
if (_GK.verbose)
g_print(_("connect string from client: %s\n"), buf);
if ( sscanf(buf, "%31s %d.%d.%d", name, &client->major_version,
&client->minor_version, &client->rev_version) == 4
&& !strcmp(name, "gkrellm")
)
{
gkrellmd_client_list = g_list_append(gkrellmd_client_list, client);
return client;
}
g_warning(_("Bad connect line from %s: %s\n"), client->hostname, buf);
gkrellmd_send_to_client(client, "<error>\nBad connect string!");
g_free(client->hostname);
g_free(client);
return NULL;
}
static void
remove_client(gint fd)
{
GList *list;
GkrellmdClient *client;
for (list = gkrellmd_client_list; list; list = list->next)
{
client = (GkrellmdClient *) list->data;
if (client->fd == fd)
{
g_message(_("Removing client %s\n"), client->hostname);
close(fd);
g_free(client->hostname);
g_free(client);
gkrellmd_client_list = g_list_remove(gkrellmd_client_list, client);
break;
}
}
}
static gint
parse_config(gchar *config, gchar *arg)
{
if (!strcmp(config, "clear-hosts") || !strcmp(config, "c"))
{
gkrellm_free_glist_and_data(&allow_host_list);
return 0;
}
if (!strcmp(config, "syslog"))
{
gkrellm_log_register(gkrellmd_syslog_log, gkrellmd_syslog_init,
gkrellmd_syslog_cleanup);
return 0;
}
#if !defined(WIN32)
if (!strcmp(config, "detach") || !strcmp(config, "d"))
{
detach_flag = TRUE;
return 0;
}
#endif
// All following options take one argument that should be passed in arg
if (!arg || !*arg)
return -1;
if (!strcmp(config, "update-hz") || !strcmp(config, "u"))
_GK.update_HZ = atoi(arg);
else if (!strcmp(config, "port") || !strcmp(config, "P"))
_GK.server_port = atoi(arg);
else if (!strcmp(config, "address") || !strcmp(config, "A"))
_GK.server_address = g_strdup(arg);
else if (!strcmp(config, "max-clients") || !strcmp(config, "m"))
_GK.max_clients = atoi(arg);
else if (!strcmp(config, "allow-host") || !strcmp(config, "a"))
allow_host_list = g_list_append(allow_host_list, g_strdup(arg));
else if (!strcmp(config, "plugin-enable") || !strcmp(config, "pe"))
gkrellmd_plugin_enable_list
= g_list_append(gkrellmd_plugin_enable_list, g_strdup(arg));
else if (!strcmp(config, "plugin") || !strcmp(config, "p"))
_GK.command_line_plugin = g_strdup(arg);
else if (!strcmp(config, "io-timeout"))
_GK.io_timeout = atoi(arg);
else if (!strcmp(config, "reconnect-timeout"))
_GK.reconnect_timeout = atoi(arg);
else if (!strcmp(config, "fs-interval"))
_GK.fs_interval = atoi(arg);
else if (!strcmp(config, "nfs-interval"))
_GK.nfs_interval = atoi(arg);
else if (!strcmp(config, "inet-interval"))
_GK.inet_interval = atoi(arg);
else if (!strcmp(config, "mbmon-port"))
_GK.mbmon_port = atoi(arg);
else if (!strcmp(config, "net-timer"))
_GK.net_timer = g_strdup(arg);
else if (!strcmp(config, "debug-level") || !strcmp(config, "debug"))
_GK.debug_level = (gint) strtoul(arg, NULL, 0);
else if (!strcmp(config, "logfile"))
gkrellm_log_set_filename(arg);
#if !defined(WIN32)
else if (!strcmp(config, "pidfile"))
_GK.pidfile = g_strdup(arg);
else if (!strcmp(config, "mailbox"))
gkrellmd_add_mailbox(arg);
else if (!strcmp(config, "user") || !strcmp(config, "U"))
{
struct passwd *tmp;
if ((tmp = getpwnam(arg)) != (struct passwd*) 0)
drop_privs.uid = tmp->pw_uid;
else
return -1;
}
else if (!strcmp(config, "group") || !strcmp(config, "G"))
{
struct group *tmp;
if ((tmp = getgrnam(arg)) != (struct group*) 0)
drop_privs.gid = tmp->gr_gid;
else
return -1;
}
#endif
else
return -1;
return 1;
}
static void
load_config(gchar *path)
{
FILE *f;
PluginConfigRec *cfg;
gchar buf[128+32+2], config[32], arg[128];
gchar *s, *plugin_config_block = NULL;
//g_print("Trying to load config from file '%s'\n", path);
f = fopen(path, "r");
if (!f)
return;
while (fgets(buf, sizeof(buf), f))
{
if (!buf[0] || buf[0] == '#')
continue;
if (buf[0] == '[' || buf[0] == '<')
{
if (buf[1] == '/')
{
g_free(plugin_config_block);
plugin_config_block = NULL;
}
else
{
if ( (s = strchr(buf, ']')) != NULL
|| (s = strchr(buf, '>')) != NULL
)
*s = '\0';
plugin_config_block = g_strdup(&buf[1]);
}
continue;
}
if (plugin_config_block)
{
cfg = g_new0(PluginConfigRec, 1);
cfg->name = g_strdup(plugin_config_block);
if ((s = strchr(buf, '\n')) != NULL)
*s = '\0';
cfg->line = g_strdup(buf);
gkrellmd_plugin_config_list
= g_list_append(gkrellmd_plugin_config_list, cfg);
}
else /* main gkrellmd config line */
{
arg[0] = '\0';
sscanf(buf, "%31s %127s", config, arg);
parse_config(config, arg);
}
}
fclose(f);
}
const gchar *
gkrellmd_config_getline(GkrellmdMonitor *mon)
{
GList *list;
PluginConfigRec *cfg;
if (!mon->privat)
{
mon->privat = g_new0(GkrellmdMonitorPrivate, 1);
mon->privat->config_list = gkrellmd_plugin_config_list;
}
for (list = mon->privat->config_list; list; list = list->next)
{
cfg = (PluginConfigRec *) list->data;
if (!strcmp(cfg->name, mon->name))
{
mon->privat->config_list = list->next;
return cfg->line;
}
}
return NULL;
}
static void
read_config(void)
{
gchar *path;
#if defined(WIN32)
gchar *install_path;
#endif
_GK.update_HZ = 3;
_GK.debug_level = 0;
_GK.max_clients = 2;
_GK.server_port = GKRELLMD_SERVER_PORT;
_GK.fs_interval = 2;
_GK.nfs_interval = 16;
_GK.inet_interval = 1;
#if defined(GKRELLMD_SYS_ETC)
path = g_build_filename(GKRELLMD_SYS_ETC, GKRELLMD_CONFIG, NULL);
load_config(path);
g_free(path);
#endif
#if defined(GKRELLMD_LOCAL_ETC)
path = g_build_filename(GKRELLMD_LOCAL_ETC, GKRELLMD_CONFIG, NULL);
load_config(path);
g_free(path);
#endif
// on windows also load config from INSTALLDIR/etc/gkrellmd.conf
#if defined(WIN32)
#if GLIB_CHECK_VERSION(2,16,0)
install_path = g_win32_get_package_installation_directory_of_module(NULL);
path = g_build_filename(install_path, "etc", GKRELLMD_CONFIG, NULL);
#else
// deprecated since glib 2.16
install_path = g_win32_get_package_installation_subdirectory(NULL, NULL, "etc");
path = g_build_filename(install_path, GKRELLMD_CONFIG, NULL);
#endif
load_config(path);
g_free(install_path);
g_free(path);
#endif
_GK.homedir = (gchar *) g_get_home_dir();
if (_GK.homedir == NULL)
_GK.homedir = "."; // FIXME: doesn't look right to me
path = g_build_filename(_GK.homedir, GKRELLMD_USER_CONFIG, NULL);
load_config(path);
g_free(path);
}
static void
usage(void)
{
#if defined(WIN32)
g_print(_("usage: gkrellmd command [options]\n"));
g_print(_("commands:\n"));
g_print(_(" --console run gkrellmd on console (not as a service)\n"));
g_print(_(" --install install gkrellmd service and exit\n"));
g_print(_(" --uninstall uninstall gkrellmd service and exit\n"));
g_print(_(" -h, --help display this help and exit\n"));
g_print(_(" -v, --version output version information and exit\n"));
g_print(_("options (only for command '--console'):\n"));
g_print(_(" -u, --update-hz F Monitor update frequency\n"));
g_print(_(" -m, --max-clients N Number of simultaneous clients\n"));
g_print(_(" -A, --address A Address of network interface to listen on\n"));
g_print(_(" -P, --port P Server port to listen on\n"));
g_print(_(" -a, --allow-host host Allow connections from specified hosts\n"));
g_print(_(" -c, --clear-hosts Clears the current list of allowed hosts\n"));
g_print(_(" --io-timeout N Close connection after N seconds of no I/O\n"));
g_print(_(" --reconnect-timeout N Try to connect every N seconds after\n"
" a disconnect\n"));
g_print(_(" -p, --plugin name Enable a command line plugin\n"));
g_print(_(" -pe, --plugin-enable name Enable an installed plugin\n"));
g_print(_(" --plist List plugins and exit\n"));
g_print(_(" --plog Print plugin install log\n"));
g_print(_(" -V, --verbose increases the verbosity of gkrellmd\n"));
g_print(_(" -d, --debug-level n Turn debugging on for selective code sections.\n"));
#else
g_print(_("usage: gkrellmd [options]\n"));
g_print(_("options:\n"));
g_print(_(" -u, --update-hz F Monitor update frequency\n"));
g_print(_(" -m, --max-clients N Number of simultaneous clients\n"));
g_print(_(" -A, --address A Address of network interface to listen on\n"));
g_print(_(" -P, --port P Server port to listen on\n"));
g_print(_(" -a, --allow-host host Allow connections from specified hosts\n"));
g_print(_(" -c, --clear-hosts Clears the current list of allowed hosts\n"));
g_print(_(" --io-timeout N Close connection after N seconds of no I/O\n"));
g_print(_(" --reconnect-timeout N Try to connect every N seconds after\n"
" a disconnect\n"));
g_print(_(" --mailbox path Send local mailbox counts to gkrellm clients.\n"));
g_print(_(" -d, --detach Run in background and detach from terminal\n"));
g_print(_(" -U, --user username Change to this username after startup\n"));
g_print(_(" -G, --group groupname Change to this group after startup\n"));
g_print(_(" -p, --plugin name Enable a command line plugin\n"));
g_print(_(" -pe, --plugin-enable name Enable an installed plugin\n"));
g_print(_(" --plist List plugins and exit\n"));
g_print(_(" --plog Print plugin install log\n"));
g_print(_(" --pidfile path Create a PID file\n"));
g_print(_(" -V, --verbose increases the verbosity of gkrellmd\n"));
g_print(_(" -h, --help display this help and exit\n"));
g_print(_(" -v, --version output version information and exit\n"));
#endif
}
static void
get_args(gint argc, gchar **argv)
{
gchar *s;
gint i, r;
for (i = 1; i < argc; ++i)
{
s = argv[i];
if (*s == '-')
{
++s;
if (*s == '-')
++s;
}
if (!strcmp(s, "verbose") || !strcmp(s, "V"))
_GK.verbose += 1;
else if (!strcmp(s, "plist"))
_GK.list_plugins = TRUE;
else if (!strcmp(s, "plog"))
_GK.log_plugins = TRUE;
#if !defined(WIN32)
else if (!strcmp(s, "without-libsensors"))
_GK.without_libsensors = TRUE;
#endif /* !WIN32 */
else if ((!strcmp(s, "debug-level") || !strcmp(s, "d")) && i < argc - 1)
_GK.debug_level = (gint) strtoul(argv[++i], NULL, 0);
else if ( i < argc
&& ((r = parse_config(s, (i < argc - 1) ? argv[i+1] : NULL)) >= 0)
)
{
i += r;
}
else
{
g_print(_("Bad arg: %s\n"), argv[i]);
usage();
exit(0);
}
} // for()
}
static int *
socksetup(int af)
{
struct addrinfo hints, *res, *r;
gint maxs, *s, *socks;
#ifndef HAVE_GETADDRINFO
struct sockaddr_in sin;
#else
gchar portnumber[6];
gint error;
#endif
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
#ifdef HAVE_GETADDRINFO
hints.ai_flags = AI_PASSIVE;
hints.ai_family = af;
snprintf(portnumber, sizeof(portnumber), "%d", _GK.server_port);
if (!_GK.server_address || strlen(_GK.server_address) == 0)
{
error = getaddrinfo(NULL, portnumber, &hints, &res);
}
else
{
error = getaddrinfo(_GK.server_address, portnumber, &hints, &res);
}
if (error)
{
g_warning("gkrellmd %s\n", gai_strerror(error));
return NULL;
}
#else
/* Set up the address structure for the listen socket and bind the
| listen address to the socket.
*/
hints.ai_family = PF_INET;
hints.ai_addrlen = sizeof(struct sockaddr_in);
hints.ai_next = NULL;
hints.ai_addr = (struct sockaddr *) &sin;
sin.sin_family = PF_INET;
if (!_GK.server_address || strlen(_GK.server_address) == 0)
{
sin.sin_addr.s_addr = INADDR_ANY;
}
else
{
sin.sin_addr.s_addr = inet_addr(_GK.server_address);
}
sin.sin_port = htons(_GK.server_port);
res = &hints;
#endif
/* count max number of sockets we may open */
for (maxs = 0, r = res; r; r = r->ai_next, maxs++)
;
socks = malloc((maxs + 1) * sizeof(int));
if (!socks)
{
g_warning("Could not allocate memory for sockets\n");
return NULL;
}
*socks = 0; /* num of sockets counter at start of array */
s = socks + 1;
for (r = res; r; r = r->ai_next)
{
*s = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
if (*s < 0)
continue;
/* SO_REUSEADDR flag allows the server to restart immediately
*/
if (1)
{
#if defined(WIN32)
const char on = 1;
#else
const int on = 1;
#endif
if (setsockopt(*s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
{
g_warning("gkrellmd: setsockopt (SO_REUSEADDR) failed\n");
close(*s);
continue;
}
}
#ifdef IPV6_V6ONLY
if (r->ai_family == AF_INET6)
{
const int on = 1;
if (setsockopt(*s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0)
{
g_warning("gkrellmd: setsockopt (IPV6_V6ONLY) failed\n");
close(*s);
continue;
}
}
#endif
if (bind(*s, r->ai_addr, r->ai_addrlen) < 0)
{
close(*s);
continue;
}
(*socks)++;
s++;
}
#ifdef HAVE_GETADDRINFO
if (res)
freeaddrinfo(res);
#endif
if (*socks == 0)
{
g_warning("Could not bind to any socket\n");
free(socks);
return NULL;
}
return socks;
}
#if !defined(WIN32)
/* XXX: Recent glibc seems to have daemon(), too. */
#if defined(BSD4_4)
#define HAVE_DAEMON
#endif
#if !defined(HAVE_DAEMON) && !defined(WIN32) && !defined(__solaris__)
#include <paths.h>
#endif
#if !defined(_PATH_DEVNULL)
#define _PATH_DEVNULL "/dev/null"
#endif
static gboolean
detach_from_terminal(void)
{
#if !defined(HAVE_DAEMON)
gint i, fd;
#endif /* HAVE_DAEMON */
if (getppid() == 1) /* already a daemon */
return TRUE;
#if defined(HAVE_DAEMON)
if (daemon(0, 0))
{
g_warning("Detach failed: %s\n", strerror(errno));
return FALSE;
}
#else
i = fork();
if (i > 0)
exit(0);
if (i < 0 || setsid() == -1) /* new session process group */
{
g_warning("Detach failed: %s\n", strerror(errno));
return FALSE;
}
if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1)
{
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
if (fd > 2)
close(fd);
}
chdir("/");
#endif /* HAVE_DAEMON */
// signal(SIGCHLD, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGHUP, SIG_IGN);
#if !defined(MSG_NOSIGNAL)
signal(SIGPIPE, SIG_IGN);
#endif /* MSG_NOSIGNAL */
}
#endif /* !defined(WIN32) */
static void
drop_privileges(void)
{
#if !defined(WIN32)
if (drop_privs.gid > (uid_t)0)
{
(void) setgroups((size_t)0, (gid_t*)0);
(void) setgid(drop_privs.gid);
}
if (drop_privs.uid > (uid_t)0)
(void) setuid(drop_privs.uid);
#endif
}
static gint
gkrellmd_run(gint argc, gchar **argv)
{
#ifdef HAVE_GETADDRINFO
struct sockaddr_storage client_addr;
#else
struct sockaddr_in client_addr;
#endif
fd_set read_fds, test_fds;
struct timeval tv;
GkrellmdClient *client;
size_t addr_len;
gint fd, server_fd, client_fd, i;
#if defined(WIN32)
gulong nbytes;
#else
gint nbytes;
#endif /* defined(WIN32) */
gint max_fd = -1;
gint listen_fds = 0;
gint interval, result;
read_config();
get_args(argc, argv);
// first message that might get logged
g_message("Starting GKrellM Daemon %d.%d.%d%s\n", GKRELLMD_VERSION_MAJOR,
GKRELLMD_VERSION_MINOR, GKRELLMD_VERSION_REV,
GKRELLMD_EXTRAVERSION);
if (_GK.verbose)
g_print("update_HZ=%d\n", _GK.update_HZ);
#if defined(WIN32)
if (!service_is_one)
{
signal(SIGTERM, cb_sigterm);
signal(SIGINT, cb_sigterm);
}
#else
if ( detach_flag
&& !_GK.log_plugins && !_GK.list_plugins && _GK.debug_level == 0
)
{
if (detach_from_terminal() == FALSE)
return 1;
}
else
{
signal(SIGTERM, cb_sigterm);
signal(SIGQUIT, cb_sigterm);
signal(SIGTSTP, SIG_IGN);
signal(SIGINT, cb_sigterm);
}
#endif /* defined(WIN32) */
make_pidfile();
gkrellm_sys_main_init();
drop_privileges();
#if GLIB_CHECK_VERSION(2,0,0)
g_thread_init(NULL);
#endif
_GK.start_time = time(0);
if (_GK.update_HZ < 1 || _GK.update_HZ > 10)
_GK.update_HZ = 3;
if (_GK.fs_interval < 1 || _GK.fs_interval > 1000)
_GK.fs_interval = 2;
if (_GK.nfs_interval > 10000)
_GK.nfs_interval = 16;
if (_GK.inet_interval > 20)
_GK.inet_interval = 20;
gkrellmd_load_monitors();
_GK.server_fd = socksetup(PF_UNSPEC);
if (_GK.server_fd == NULL)
{
g_warning("socket() failed: %s\n", strerror(errno));
gkrellmd_cleanup();
return 1;
}
/* Listen on the socket so a client gkrellm can connect.
*/
FD_ZERO(&read_fds);
for (i = 1; i <= _GK.server_fd[0]; ++i)
{
if (listen(_GK.server_fd[i], 5) == -1)
{
close(_GK.server_fd[i]);
continue;
}
++listen_fds;
FD_SET(_GK.server_fd[i], &read_fds);
if (max_fd < _GK.server_fd[i])
max_fd = _GK.server_fd[i];
}
if (listen_fds <= 0)
{
g_warning("listen() failed: %s\n", strerror(errno));
gkrellmd_cleanup();
return 1;
}
interval = 1000000 / _GK.update_HZ;
gkrellm_debug(DEBUG_SERVER, "Entering main event loop\n");
// main event loop
#if defined(WIN32)
/* endless loop if:
- we're a service and our service_running flag is TRUE
- we're a console-app (--console argument passed at startup
*/
while(service_running == TRUE || service_is_one == FALSE)
#else
while(1)
#endif
{
test_fds = read_fds;
#ifdef HAVE_GETADDRINFO
addr_len = sizeof(struct sockaddr_storage);
#else
addr_len = sizeof(struct sockaddr_in);
#endif
tv.tv_usec = interval;
tv.tv_sec = 0;
result = select(max_fd + 1, &test_fds, NULL, NULL, &tv);
if (result == -1)
{
if (errno == EINTR)
continue;
g_warning("select() failed: %s\n", strerror(errno));
gkrellmd_cleanup();
return 1;
}
#if 0 /* BUG, result is 0 when test_fds has a set fd!! */
if (result == 0)
{
gkrellmd_update_monitors();
continue;
}
#endif
for (fd = 0; fd <= max_fd; ++fd)
{
if (!FD_ISSET(fd, &test_fds))
continue;
server_fd = -1;
for (i = 1; i <= _GK.server_fd[0]; ++i)
{
if (fd == _GK.server_fd[i])
{
server_fd = fd;
break;
}
}
if (server_fd >= 0)
{
gkrellm_debug(DEBUG_SERVER, "Calling accept() for new client connection\n");
client_fd = accept(server_fd,
(struct sockaddr *) &client_addr,
(socklen_t *) (void *)&addr_len);
if (client_fd == -1)
{
g_warning("accept() failed: %s\n",
strerror(errno));
gkrellmd_cleanup();
return 1;
}
if (client_fd > max_fd)
max_fd = client_fd;
client = accept_client(client_fd,
(struct sockaddr *)&client_addr, addr_len);
if (!client)
{
close(client_fd);
continue;
}
FD_SET(client_fd, &read_fds);
gkrellmd_serve_setup(client);
g_message(_("Accepted client %s:%u\n"),
client->hostname,
ntohs(((struct sockaddr_in *)&client_addr)->sin_port));
}
else
{
gkrellm_debug(DEBUG_SERVER, "Reading data from client connection\n");
#if defined(WIN32)
ioctlsocket(fd, FIONREAD, &nbytes);
#else
ioctl(fd, FIONREAD, &nbytes);
#endif
if (nbytes == 0)
{
remove_client(fd);
FD_CLR(fd, &read_fds);
}
else
gkrellmd_client_read(fd, nbytes);
}
}
gkrellmd_update_monitors();
} // while(1)
return 0;
} // gkrellmd_main()
#if defined(WIN32)
static void service_update_status(DWORD newState)
{
service_status.dwCurrentState = newState;
SetServiceStatus(service_status_handle, &service_status);
}
void WINAPI service_control_handler(DWORD controlCode)
{
switch (controlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
service_update_status(SERVICE_STOP_PENDING);
service_running = FALSE;
return;
default:
break;
}
}
void WINAPI service_main(DWORD argc, WCHAR* argv[])
{
gchar **argv_utf8;
DWORD i;
/* Init service status */
service_status.dwServiceType = SERVICE_WIN32;
service_status.dwCurrentState = SERVICE_STOPPED;
service_status.dwControlsAccepted = 0;
service_status.dwWin32ExitCode = NO_ERROR;
service_status.dwServiceSpecificExitCode = NO_ERROR;
service_status.dwCheckPoint = 0;
service_status.dwWaitHint = 0;
service_status_handle = RegisterServiceCtrlHandlerW(service_name, service_control_handler);
if (service_status_handle)
{
// convert all strings in argv pointer array from utf16 to utf8
argv_utf8 = g_malloc(argc * sizeof(gchar *));
for (i = 0; i < argc; i++)
argv_utf8[i] = g_utf16_to_utf8(argv[i], -1, NULL, NULL, NULL);
// service is starting
service_update_status(SERVICE_START_PENDING);
// service is running
service_status.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
service_update_status(SERVICE_RUNNING);
service_running = TRUE;
// gkrellmd_main returns on error or as soon as
// service_running is FALSE (see service_control_handler())
gkrellmd_run(argc, argv_utf8);
// service was stopped
service_update_status(SERVICE_STOP_PENDING);
// services are not stopped via process signals so we have to
// clean up like in cb_sigterm() but without calling exit()!
g_message("GKrellM Daemon %d.%d.%d%s: Exiting normally\n",
GKRELLMD_VERSION_MAJOR, GKRELLMD_VERSION_MINOR,
GKRELLMD_VERSION_REV, GKRELLMD_EXTRAVERSION);
gkrellmd_cleanup();
// free all strings in pointer array and free the array itself
for (i = 0; i < argc; i++)
g_free(argv_utf8[i]);
g_free(argv_utf8);
// service is now stopped
service_status.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
service_update_status(SERVICE_STOPPED);
// process is automatically terminated by windows now
}
}
void service_run()
{
SERVICE_TABLE_ENTRYW service_table[] =
{ {service_name, service_main}, { 0, 0 } };
service_is_one = TRUE;
// Blocking system call, will return if service is not needed anymore
StartServiceCtrlDispatcherW(service_table);
}
static gboolean service_wait_for_stop(SC_HANDLE serviceHandle)
{
static const gulong waitTimeoutSec = 30;
SERVICE_STATUS status;
GTimer *waitTimer = NULL;
gboolean ret = FALSE;
if (!QueryServiceStatus(serviceHandle, &status))
{
g_warning("Could not query status of %ls (%ld)\n", service_display_name, GetLastError());
return FALSE;
}
waitTimer = g_timer_new(); /* create and start */
while (status.dwCurrentState == SERVICE_STOP_PENDING)
{
g_usleep(status.dwWaitHint * 1000);
if (!QueryServiceStatus(serviceHandle, &status))
{
g_warning("Could not query status of %ls (%ld)\n", service_display_name, GetLastError());
ret = FALSE;
break;
}
if (status.dwCurrentState == SERVICE_STOPPED)
{
ret = TRUE;
break;
}
if (g_timer_elapsed(waitTimer, NULL) > waitTimeoutSec)
{
g_warning("Stopping %ls timed out\n", service_display_name);
ret = FALSE;
break;
}
} /*while*/
g_timer_destroy(waitTimer);
return ret;
}
static gboolean service_stop(SC_HANDLE serviceHandle)
{
SERVICE_STATUS svcStatus;
if (!QueryServiceStatus(serviceHandle, &svcStatus))
{
g_warning("Could not query status of %ls (%ld)\n", service_display_name, GetLastError());
return FALSE;
}
/* service not running at all, just return that stopping worked out */
if (svcStatus.dwCurrentState == SERVICE_STOPPED)
{
g_print(_("%ls already stopped\n"), service_display_name);
return TRUE;
}
/* service already stopping, just wait for its exit */
if (svcStatus.dwCurrentState == SERVICE_STOP_PENDING)
{
return service_wait_for_stop(serviceHandle);
}
/* Service is running, let's stop it */
if (!ControlService(serviceHandle, SERVICE_CONTROL_STOP, &svcStatus))
{
g_warning(_("Could not stop %ls (%ld)\n"), service_display_name, GetLastError());
return FALSE;
}
// Wait for the service to stop.
if (svcStatus.dwCurrentState == SERVICE_STOP_PENDING)
{
return service_wait_for_stop(serviceHandle);
}
return TRUE;
}
static gboolean service_install()
{
WCHAR path[_MAX_PATH + 1];
SC_HANDLE scmHandle;
SC_HANDLE svcHandle;
DWORD err;
g_print(_("Installing %ls...\n"), service_display_name);
if (GetModuleFileNameW(0, path, sizeof(path)/sizeof(path[0])) < 1)
{
g_warning("Could not determine path to gkrellmd service binary, error 0x%ld\n", GetLastError());
return FALSE;
}
scmHandle = OpenSCManagerW(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
if (!scmHandle)
{
err = GetLastError();
if (err == ERROR_ACCESS_DENIED)
g_warning("Could not connect to service manager, access denied\n");
else
g_warning("Could not connect to service manager, error 0x%lXd\n", err);
return FALSE;
}
svcHandle = CreateServiceW(scmHandle, service_name, service_display_name,
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START,
SERVICE_ERROR_NORMAL, path, 0, 0, 0, 0, 0);
if (!svcHandle)
{
err = GetLastError();
if (err == ERROR_ACCESS_DENIED)
g_warning("Could not install %ls, access denied\n", service_display_name);
else if (err == ERROR_SERVICE_EXISTS || err == ERROR_DUPLICATE_SERVICE_NAME)
g_warning("Could not install %ls, a service of the same name already exists\n", service_display_name);
else
g_warning("Could not install %ls, error 0x%lX\n", service_display_name, err);
CloseServiceHandle(scmHandle);
return FALSE;
}
else
{
g_print(_("%ls has been installed.\n"), service_display_name);
}
g_print(_("Starting %ls...\n"), service_display_name);
if (!StartServiceW(svcHandle, 0, NULL))
{
err = GetLastError();
if (err == ERROR_ACCESS_DENIED)
g_warning("Could not start %ls, access denied\n", service_display_name);
else
g_warning("Could not start %ls, error 0x%lX\n", service_display_name, err);
}
else
{
g_print(_("%ls has been started.\n"), service_display_name);
}
CloseServiceHandle(svcHandle);
CloseServiceHandle(scmHandle);
return TRUE;
} /* service_install() */
static gboolean service_uninstall()
{
SC_HANDLE scmHandle;
SC_HANDLE svcHandle;
BOOL delRet = FALSE;
gchar *errmsg;
g_print(_("Uninstalling %ls...\n"), service_display_name);
scmHandle = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
if (!scmHandle)
{
errmsg = g_win32_error_message(GetLastError());
g_warning("Could not connect to service manager: %s\n", errmsg);
g_free(errmsg);
return FALSE;
}
svcHandle = OpenServiceW(scmHandle, service_name,
SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE);
if (!svcHandle)
{
errmsg = g_win32_error_message(GetLastError());
g_warning("Could not open %ls: %s\n", service_display_name, errmsg);
g_free(errmsg);
}
else
{
// handle to gkrellm service aquired, now stop and uninstall it
if (service_stop(svcHandle))
{
delRet = DeleteService(svcHandle);
if (!delRet)
{
errmsg = g_win32_error_message(GetLastError());
g_warning("Could not uninstall %ls: %s\n",
service_display_name, errmsg);
g_free(errmsg);
}
else
{
g_print(_("%ls has been uninstalled.\n"), service_display_name);
}
}
CloseServiceHandle(svcHandle);
}
CloseServiceHandle(scmHandle);
return delRet ? TRUE : FALSE;
} /* service_uninstall() */
#endif /* defined(WIN32) */
GkrellmdTicks *
gkrellmd_ticks(void)
{
return &GK;
}
gint
gkrellmd_get_timer_ticks(void)
{
return GK.timer_ticks;
}
int main(int argc, char* argv[])
{
int i;
char *opt;
#ifdef ENABLE_NLS
#ifdef LOCALEDIR
#if defined(WIN32)
/*
Prepend app install path to relative locale dir, don't rely on CWD being correct
*/
if (!G_IS_DIR_SEPARATOR(LOCALEDIR[0]))
{
gchar* locale_dir;
locale_dir = g_win32_get_package_installation_subdirectory(NULL, NULL, LOCALEDIR);
if (locale_dir != NULL)
{
bindtextdomain(PACKAGE_D, locale_dir);
g_free(locale_dir);
}
}
else
{
bindtextdomain(PACKAGE_D, LOCALEDIR);
}
#else
bindtextdomain(PACKAGE_D, LOCALEDIR);
#endif /* !WIN32 */
#endif /* LOCALEDIR */
textdomain(PACKAGE_D);
bind_textdomain_codeset(PACKAGE_D, "UTF-8");
#endif /* ENABLE_NLS */
// Init logging-chain
gkrellm_log_init();
/* Parse arguments for actions that exit gkrellmd immediately */
for (i = 1; i < argc; ++i)
{
opt = argv[i];
if (*opt == '-')
{
++opt;
if (*opt == '-')
++opt;
}
if (!strcmp(opt, "help") || !strcmp(opt, "h"))
{
usage();
return 0;
}
else if (!strcmp(opt, "version") || !strcmp(opt, "v"))
{
g_print("gkrellmd %d.%d.%d%s\n", GKRELLMD_VERSION_MAJOR,
GKRELLMD_VERSION_MINOR, GKRELLMD_VERSION_REV,
GKRELLMD_EXTRAVERSION);
return 0;
}
#if defined(WIN32)
else if (!strcmp(opt, "install"))
{
return (service_install() ? 1 : 0);
}
else if (!strcmp(opt, "uninstall"))
{
return (service_uninstall() ? 1 : 0);
}
else if (!strcmp(opt, "console"))
{
/*
Special case for windows: run gkrellmd on console and not as
a service. This is helpful for debugging purposes.
*/
int retVal;
int newArgc = 0;
char **newArgv = malloc((argc - 1) * sizeof(char *));
int j;
for (j = 0; j < argc; ++j)
{
/* filter out option "--console" */
if (j == i)
continue;
newArgv[newArgc++] = argv[j];
}
retVal = gkrellmd_run(newArgc, newArgv);
free(newArgv);
return retVal;
}
#endif /* defined(WIN32) */
}
#if defined(WIN32)
// win32: register service and wait for the service to be started/stopped
service_run();
return 0;
#else
// Unix: just enter main loop
return gkrellmd_run(argc, argv);
#endif
}
Reference in New Issue View Git Blame Copy Permalink