Starts UDP stats/status server implementation

include/conf.h

@@ -56,6 +56,7 @@ pyfcgi_conf_t PyFCGI_conf;
 #include "logger.h"
 #include "pyutils.h"
 #include "ipc.h"
+#include "monitor.h"
 
 /**@defgroup ret_status Function & process return status
  */
@@ -74,7 +75,7 @@ pyfcgi_conf_t PyFCGI_conf;
 
 #define PYFCGI_NAME "spawn-fcgi [OPTIONS] -- pyfcgi"
 
-#define PYFCGI_SHORT_OPT "Ce:E:Aw:W:m:ft:L:SvVh"
+#define PYFCGI_SHORT_OPT "Ce:E:Aw:W:m:ft:L:SPsvVh"
 
 #define PYFCGI_LONG_OPT { \
 	{"config", required_argument, 0, 'C'},\
@@ -89,6 +90,7 @@ pyfcgi_conf_t PyFCGI_conf;
 	{"log", required_argument, 0, 'L'},\
 	{"syslog", no_argument, 0, 'S'},\
 	{"pid-file", required_argument, 0, 'P'},\
+	{"socket-server", required_argument, 0, 's'},\
 	{"verbose", no_argument, 0, 'v'},\
 	{"version", no_argument, 0, 'V'},\
 	{"help", no_argument, 0, 'h' },\
@@ -108,6 +110,7 @@ pyfcgi_conf_t PyFCGI_conf;
 	{"Add a logfile using syntax : 'LOGFILE[;FILT][;FMT]'", "LOGGER_SPEC"},\
 	{"Use syslog for logging", NULL},\
 	{"Create a PID file", "FILENAME"},\
+	{"Indicate a socket (for example 'udp://localhost:8765' ) to listen on, replying stats & status", "SOCKET"},\
 	{"Send all loglines on stderr", NULL},\
 	{"Print PyFCGI and Python version and exit", NULL},\
 	{"Display this help and exit", NULL},\
@@ -128,7 +131,12 @@ Logger specification format 'LOGFILE[;FILT][;FMT]' with :\n\
 \t\t- {ident} the defined ident (set by process)\n\
 \t\t- {msg} the log message (can only appear once)\n\
 You can escape { and } by using {{ and }} and all field names can by\n\
-abbreviated to one character.\n"
+abbreviated to one character.\n\n\
+Socket URL specification format : PROT://HOST[:PORT] with PROT on of \n\
+\t- tcp for tcp sockets and HOST a valid INET address\n\
+\t- udp for udp sockets and HOST a valid INET address\n\
+\t- unix for file sockets and HOST a valid path\n\
+"
 
 #define PYENTRY_DEFAULT_FUN "application"
 
@@ -241,6 +249,13 @@ struct pyfcgi_conf_s
 	 * - sems[2] is the stats/status SHM semaphore
 	 */
 	pyfcgi_semdata_t sems[PYFCGI_NSEM];
+
+	/**@brief Stores a copy of the specified socket URL to listen to. */
+	char *mon_socket;
+	/**@brief If 1 force ipv4 */
+	short ipv4;
+	/**@brief If 1 force ipv6 */
+	short ipv6;
 };
 
 

include/monitor.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2019 Weber Yann
+ * 
+ * This file is part of PyFCGI.
+ * 
+ * PyFCGI is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PyFCGI 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with PyFCGI.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**@defgroup monitoring Monitoring a running PyFCGI
+ *
+ * PyFCGI have the ability to listen on a UDP socket, replying to simple
+ * queries (or simple stats).
+ */
+#ifndef _MONITOR__H___
+#define _MONITOR__H___
+#include "config.h"
+
+#include <fcgiapp.h> /* fcgi library; put it first*/
+
+#include <netdb.h>
+#include <strings.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#define UNIX_SOCKPATH_MAX 108
+
+typedef struct pyfcgi_monitor_s pyfcgi_monitor_t;
+typedef union pyfcgi_monitor_addr_u pyfcgi_monitor_addr_t;
+
+#include "conf.h"
+#include "logger.h"
+
+union pyfcgi_monitor_addr_u
+{
+	struct sockaddr_in in;
+	struct sockaddr_in6 in6;
+	struct sockaddr_un un;
+};
+
+/**@brief Local structure storing monitor process informations */
+struct pyfcgi_monitor_s
+{
+	/**@brief Socket fd */
+	int sock_serv;
+	/**@brief domain type & protocol */
+	int sock_args[3];
+	/**@brief Address to bind to */
+	pyfcgi_monitor_addr_t addr;
+};
+
+
+/**@brief Start the stats server monitoring server 
+ * @return PID of the child process and -1 on error
+ * @note When called the configuration has to be parsed */
+pid_t pyfcgi_spawn_monitor();
+
+void pyfcgi_monitor_init();
+void pyfcgi_monitor_loop();
+
+/**@brief Check socket URL validity
+ * @param const char* the URL to check
+ * @return -1 if error else 0
+ * @note Logs error using dprintf(2, ...) because this function will
+ * be called when checking configuration
+ */
+int pyfcgi_monitor_check_sock(const char*);
+
+/**@brief Parse stored socket URL
+ * @param const char* the URL to parse
+ * @param int[3] socket creation arguments
+ * @param pyfcgi_monitor_addr_t the addr to bind to
+ * @return 0 if no error else -1
+ */
+int pyfcgi_monitor_parse_sock(const char*, int[3], pyfcgi_monitor_addr_t*);
+
+/**@brief Parse an addres:port string in a sockaddr_in
+ * @param const char* the hostname:port string
+ * @param int socket family
+ * @param pyfcgi_monitor_addr_t* the addr pointer
+ * @param int* if not NULL will be set to choosen domain
+ * @return 0 if no erro else -1
+ */
+int pyfcgi_monitor_parse_inet_addr(const char*, int, pyfcgi_monitor_addr_t*, int*);
+
+#endif

include/responder.h

@@ -42,7 +42,7 @@
 #define _RESPONDER__H___
 #include "config.h"
 
-#include <fcgi_stdio.h> /* fcgi library; put it first*/
+#include <fcgiapp.h> /* fcgi library; put it first*/
 
 #include <stdlib.h>
 #include <unistd.h>

src/Makefile.am

@@ -6,13 +6,13 @@ pyfcgi_LDADD = $(PYTHON_LDFLAGS)
 
 # libpyfcgi python module
 lib_LTLIBRARIES = libpyfcgi.la
-libpyfcgi_la_SOURCES = python_pyfcgi.c python_ioin.c ipc.c
+libpyfcgi_la_SOURCES = python_pyfcgi.c python_ioin.c ipc.c monitor.c
 libpyfcgi_la_CFLAGS = $(PYTHON_SO_CFLAGS)
 libpyfcgi_la_LDFLAGS = $(PYTHON_SO_LDFLAGS)
 
 # static librarie for check
 noinst_LIBRARIES = libpyfcgi.a
-libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c python_ioin.c ipc.c
+libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c python_ioin.c ipc.c monitor.c
 libpyfcgi_a_CFLAGS = $(PYTHON_CFLAGS)
 
 

src/conf.c

@@ -121,6 +121,14 @@ int parse_args(int argc, char *argv[])
 				PyFCGI_conf.pidfile = strdup(optarg);
 				/**@todo create pidfile and put master pid in it */
 				break;
+			case 's':
+				if(pyfcgi_monitor_check_sock(optarg) < 0)
+				{
+					exit(1);
+				}
+				PyFCGI_conf.mon_socket = strdup(optarg);
+				/**@todo check strdup returned value */
+				break;
 			case 'h':
 				usage();
 				exit(0);

src/monitor.c

@@ -0,0 +1,213 @@
+#include "monitor.h"
+
+
+pid_t pyfcgi_spawn_monitor()
+{
+	pid_t res;
+
+	res = fork();
+	if(res == -1)
+	{
+		pyfcgi_log(LOG_ALERT, "Unable to fork into monitoring server process : %s",
+			strerror(errno));
+		sleep(1);
+	}
+	if(!res)
+	{
+		pyfcgi_logger_set_ident("StatServ");
+		pyfcgi_monitor_init();
+		pyfcgi_monitor_loop();
+		pyfcgi_log(LOG_ALERT, "Monitor loop should never return but just did it...");
+		exit(PYFCGI_FATAL);
+	}
+	return res;
+}
+
+void pyfcgi_monitor_init()
+{
+
+}
+
+void pyfcgi_monitor_loop()
+{
+
+}
+
+int pyfcgi_monitor_check_sock(const char* sockurl)
+{
+	const char *port;
+	short tcp;
+	const char *urlorig;
+
+	urlorig = sockurl;
+
+	if(!(tcp = strncasecmp("tcp://", sockurl, 6)) ||
+		!strncasecmp("udp://", sockurl, 6))
+	{
+		sockurl += 6; //first addr chr
+	}
+	else if(!strncasecmp("unix://", sockurl, 7))
+	{
+		sockurl += 7;
+		if(strlen(sockurl) > UNIX_SOCKPATH_MAX)
+		{
+			dprintf(2, "UNIX socket support only path with length <= %d but given path is %ld bytes long : '%s'",
+				UNIX_SOCKPATH_MAX, strlen(sockurl), urlorig);
+			return -1;
+		}
+		return 0;
+	}
+	else
+	{
+		dprintf(2, "Invalid protocol in '%s'\n", sockurl);
+		return -1;
+	}
+	do { sockurl++; } while(*sockurl && *sockurl != ':');
+	if(!sockurl)
+	{
+		dprintf(2, "%s protocol choosen but not port given : '%s'\n",
+			tcp?"TCP":"UDP", sockurl);
+		return -1;
+	}
+	sockurl++;
+	port = sockurl;
+	while(*sockurl && *sockurl >= '0' && *sockurl <= '9')
+	{
+		sockurl++;
+	}
+	if(sockurl)
+	{
+		dprintf(2, "Invalid port '%s' in socket URL '%s'\n",
+			port, urlorig);
+		return -1;
+	}
+	return 0;
+}
+
+int pyfcgi_monitor_parse_sock(const char *sockurl, int sockargs[3],
+	pyfcgi_monitor_addr_t *listen_addr)
+{
+	const char *addr_ptr;
+	short tcp;
+	int *domain, *type, *protocol;
+	struct sockaddr_un *addr_un;
+
+	domain = &sockargs[0];
+	type = &sockargs[1];
+	protocol = &sockargs[2];
+
+	addr_un = &(listen_addr->un);
+
+	sockurl = PyFCGI_conf.mon_socket;
+	if(strncasecmp("unix://", sockurl, 7))
+	{
+		addr_ptr = sockurl + 7;
+		*domain = AF_UNIX;
+		*type = SOCK_STREAM;
+		*protocol = 0;
+		addr_un->sun_family = AF_UNIX;
+		strncpy(addr_un->sun_path, addr_ptr, UNIX_SOCKPATH_MAX);
+		return 0;
+	}
+
+	if((tcp = strncasecmp("tcp://", sockurl, 6)) &&
+		strncasecmp("udp://", sockurl, 6))
+	{ //Unchecked URL??!!
+		pyfcgi_log(LOG_ERR, "Invalid protocol in URL : '%s'",
+			sockurl);
+		return -1;
+	}
+	addr_ptr = sockurl + 6;
+
+	if(pyfcgi_monitor_parse_inet_addr(addr_ptr, *type, listen_addr, domain))
+	{
+		return -1;
+	}
+	*type = tcp ? SOCK_DGRAM : SOCK_STREAM;
+	*protocol = 0;
+	return 0;
+}
+
+int pyfcgi_monitor_parse_inet_addr(const char* addr_str, int socktype,
+	pyfcgi_monitor_addr_t *listen_addr, int* domain)
+{
+	char *addr, *port, *ptr, *ipstr;
+	char v6str[64];
+	struct addrinfo *infos, hints, *info;
+	short v4, v6, i;
+	int ret;
+
+	// initialize temporary address & port pointers
+	addr = strdup(addr_str);
+	if(!addr)
+	{
+		pyfcgi_log(LOG_ALERT, "strdup() failed to copy socket addr : %s",
+			strerror(errno));
+		return -1;
+	}
+	ptr = addr;
+	do { ptr++; }while(*ptr && *ptr != ':');
+	if(!ptr)
+	{
+		pyfcgi_log(LOG_ERR, "No port found in INET url : %s",
+			addr_str);
+		goto free_err;
+	}
+	*ptr = '\0';
+	port = ptr+1;
+
+	memset(&hints, 0, sizeof(struct addrinfo));
+	v4 = PyFCGI_conf.ipv4;
+	v6 = PyFCGI_conf.ipv6;
+	hints.ai_family = (v4?AF_INET:(v6?AF_INET6:PF_UNSPEC));
+	hints.ai_socktype = socktype;
+	hints.ai_flags = AI_CANONNAME;
+
+	if((ret = getaddrinfo(addr, port, &hints, &infos)))
+	{
+		pyfcgi_log(LOG_ALERT, "getaddrinfo fails on '%s' : %s",
+			gai_strerror(ret));
+		goto free_err;
+	}
+
+	for(info = infos; info != NULL; info = info->ai_next)
+	{
+		if(info->ai_family == AF_INET)
+		{
+			memcpy(&listen_addr->in, info->ai_addr,
+				info->ai_addrlen);
+			ipstr = inet_ntoa(listen_addr->in.sin_addr);
+		}
+		else if(info->ai_family == AF_INET6)
+		{
+			memcpy(&listen_addr->in6, info->ai_addr,
+				info->ai_addrlen);
+			ptr = v6str;
+			for(i=0; i<16; i++)
+			{
+				ptr += snprintf(ptr, 4,
+					"%s%02X", ((i==0)?"":":"),
+					listen_addr->in6.sin6_addr.s6_addr[i]);
+			}
+			ipstr = v6str;
+		}
+		else
+		{
+			continue;
+		}
+		pyfcgi_log(LOG_DEBUG, "Listen addr resolved to %s(%s)",
+			info->ai_canonname,  ipstr);
+
+		freeaddrinfo(infos);
+		free(addr);
+		return 0;
+	}
+
+	pyfcgi_log(LOG_ERR, "Unable to resolve to a valid AF_INET[6] address");
+	freeaddrinfo(infos);
+
+free_err:
+	free(addr);
+	return -1;
+}
+