Continuing monitor server

Implementing a dummy stream response loop sending PyFCGI version

include/conf.h

 
 #define PYFCGI_NAME "spawn-fcgi [OPTIONS] -- pyfcgi"
 
-#define PYFCGI_SHORT_OPT "Ce:E:Aw:W:m:ft:L:SPsvVh"
+#define PYFCGI_SHORT_OPT "Ce:E:Aw:W:m:ft:L:SPs:vVh"
 
 #define PYFCGI_LONG_OPT { \
 	{"config", required_argument, 0, 'C'},\

include/monitor.h

 #include <arpa/inet.h>
 
 #define UNIX_SOCKPATH_MAX 108
+#define PYFCGI_MONITOR_STREAM_BACKLOG 5
 
 typedef struct pyfcgi_monitor_s pyfcgi_monitor_t;
 typedef union pyfcgi_monitor_addr_u pyfcgi_monitor_addr_t;
 	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 */
+	int sockserv;
+	int sockargs[3];
 	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();
+/**@brief Main function for socket stats server
+ *
+ * Create the socket & bind to indicated address. If bind fails, sleep 30s, then
+ * exit, in order to retry the whole process
+ */
 void pyfcgi_monitor_loop();
 
+void pyfcgi_monitor_stream_loop();
+void pyfcgi_monitor_dgram_loop();
+
 /**@brief Check socket URL validity
  * @param const char* the URL to check
  * @return -1 if error else 0
  * @return 0 if no erro else -1
  * @todo add support for xxx://[IPV6]:port
  */
-int pyfcgi_monitor_parse_inet_addr(const char*, int, pyfcgi_monitor_addr_t*, int*);
+int pyfcgi_monitor_parse_inet_addr(const char*, int, pyfcgi_monitor_addr_t*,
+	int*);
 
 #endif

include/responder.h

  */
 int pyfcgi_pool_idle(const struct timespec *timeout);
 
-/**@brief Exit after closing all stuff like semaphores
- * @ingroup work_master_proc
- */
-void clean_exit(int);
-
 /**@brief Handle signals and forward it to workers */
 void pool_sighandler(int signum);
 

src/monitor.c

 #include "monitor.h"
 
+static pyfcgi_monitor_t pyfcgi_mon;
+
+static void clean_exit(int status)
+{
+	if(pyfcgi_mon.sockserv)
+	{
+		close(pyfcgi_mon.sockserv);
+	}
+	exit(status);
+}
 
 pid_t pyfcgi_spawn_monitor()
 {
 	pid_t res;
 
+	if(!PyFCGI_conf.mon_socket)
+	{
+		pyfcgi_log(LOG_ERR, "No socket url set but pyfcgi_spawn_monitor called !");
+		return -1;
+	}
+
+	memset(&pyfcgi_mon, 0, sizeof(pyfcgi_mon));
+
 	res = fork();
 	if(res == -1)
 	{
 		sleep(1);
 	}
 	if(!res)
-	{
+	{ //child process
 		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);
+		clean_exit(PYFCGI_FATAL);
 	}
 	return res;
 }
 
-void pyfcgi_monitor_init()
+
+void pyfcgi_monitor_loop()
 {
+	pyfcgi_monitor_addr_t addr;
+	int *sockargs;
+	socklen_t addrlen;
 
+	sockargs = pyfcgi_mon.sockargs;
+
+	if(pyfcgi_monitor_parse_sock(PyFCGI_conf.mon_socket, sockargs,
+		&addr) < 0)
+	{
+		pyfcgi_log(LOG_WARNING,
+			"Unable to parse socket URL, monitoring server not starting...");
+		free(PyFCGI_conf.mon_socket);
+		PyFCGI_conf.mon_socket = NULL;
+		clean_exit(PYFCGI_ERR);
+	}
+
+	if( (pyfcgi_mon.sockserv = socket(sockargs[0], sockargs[1],
+		sockargs[2])) < 0)
+	{
+		pyfcgi_log(LOG_ERR, "Unable to create socket : %s",
+			strerror(errno));
+		sleep(1);
+		clean_exit(PYFCGI_ERR);
+	}
+
+	if(sockargs[0] == AF_INET)
+	{
+		addrlen = sizeof(struct sockaddr_in);
+	}
+	else if(sockargs[0] == AF_INET6)
+	{
+		addrlen = sizeof(struct sockaddr_in6);
+	}
+	else
+	{
+		addrlen = sizeof(struct sockaddr_un);
+	}
+	
+	if(bind(pyfcgi_mon.sockserv, (struct sockaddr*)&addr, addrlen) < 0)
+	{
+		pyfcgi_log(LOG_ERR, "Unable to bind socket... Retrying in 10s");
+		close(pyfcgi_mon.sockserv);
+		sleep(30);
+		clean_exit(PYFCGI_ERR);
+	}
+	pyfcgi_log(LOG_INFO, "Listening on %s", PyFCGI_conf.mon_socket);
+	//bind successfull, sending to appropriate response loop
+	if(pyfcgi_mon.sockargs[1] == SOCK_DGRAM)
+	{
+		pyfcgi_monitor_dgram_loop();
+	}
+	else
+	{
+		pyfcgi_monitor_stream_loop();
+	}
 }
 
-void pyfcgi_monitor_loop()
+void pyfcgi_monitor_stream_loop(pyfcgi_monitor_addr_t addr_serv)
 {
+	pyfcgi_monitor_addr_t cliaddr;
+	socklen_t addrlen;
+	int sockcli;
+	char ipstr[64];
+	char name[] = "PYFCGI_"VERSION"\n";
 
+	addrlen = sizeof(cliaddr);
+	if(listen(pyfcgi_mon.sockserv, PYFCGI_MONITOR_STREAM_BACKLOG) < 0)
+	{
+		pyfcgi_log(LOG_ERR, "Unable to listen on socket : %s",
+			strerror(errno));
+		clean_exit(PYFCGI_ERR);
+	}
+
+	while( (sockcli = accept(pyfcgi_mon.sockserv,
+		(struct sockaddr*)&cliaddr, &addrlen)) >= 0)
+	{
+		pyfcgi_log(LOG_DEBUG, "New client");
+		if(!inet_ntop(pyfcgi_mon.sockargs[0], (void*)&cliaddr, ipstr, 64))
+		{
+			pyfcgi_log(LOG_WARNING,
+				"inet_ntop fails to represent client address : %s",
+				strerror(errno));
+			strcpy(ipstr, "XXX");
+		}
+		pyfcgi_log(LOG_INFO, "Sending stats to %s", ipstr);
+		
+		send(sockcli, name, strlen(name), 0);
+		close(sockcli);
+		
+		addrlen = sizeof(cliaddr);
+	}
+	pyfcgi_log(LOG_ERR, "Unable to accept new connection on socket : %s",
+		strerror(errno));
+}
+
+void pyfcgi_monitor_dgram_loop()
+{
+	pyfcgi_log(LOG_ERR, "Dgram server not implemented.... exiting server");
+	free(PyFCGI_conf.mon_socket);
+	PyFCGI_conf.mon_socket = NULL;
+	clean_exit(PYFCGI_ERR);
 }
 
 int pyfcgi_monitor_check_sock(const char* sockurl)
 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];
+	char *addr, *port, *ptr, ipstr[64];
 	struct addrinfo *infos, hints, *info;
-	short v4, v6, i;
+	short v4, v6;
 	int ret;
 
 	// initialize temporary address & port pointers
 		{
 			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;
 		}
 		*domain = info->ai_family;
+		if(!inet_ntop(*domain, info->ai_addr, ipstr, 64))
+		{
+			pyfcgi_log(LOG_ERR, "Unable to format IP in string : %s",
+				strerror(errno));
+			strcpy(ipstr, "IP");
+		}
 		pyfcgi_log(LOG_DEBUG, "Listen addr resolved to %s(%s)",
 			info->ai_canonname,  ipstr);
 

src/responder.c

  */
 #include "responder.h"
 
+/**@brief Exit after closing all stuff like semaphores
+ * @ingroup work_master_proc */
+static void clean_exit(int status)
+{
+	pyfcgi_IPC_close(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
+	//temporarly destroy everything....
+	pyfcgi_IPC_destroy(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
+	//pyfcgi_IPC_destroy(IPC_WSTATE);
+	exit(status);
+}
+
 void init_context()
 {
 	PyFCGI_conf.context.pid = getpid();
 	return 1; //idle
 }
 
-void clean_exit(int status)
-{
-	pyfcgi_IPC_close(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
-	//temporarly destroy everything....
-	pyfcgi_IPC_destroy(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
-	//pyfcgi_IPC_destroy(IPC_WSTATE);
-	exit(status);
-}
-
 void pool_sighandler(int signum)
 {
 	unsigned int i;