#include "CS.h"

CSP csP;
DebugP deP;

void abend(DebugP deP) {
//	LOG(0, "ABORT, netstat:");
//	int pid;
//	if(!(pid = fork())) {
//		execl("/bin/bash", "/bin/bash", "-c", "netstat -n --inet -a | grep 1[123][0-9][0-9][0-9] >net_stat", (char *) NULL);
//		exit(EXIT_SUCCESS);
//	}
//	waitpid(pid, NULL, 0);
	LOG(0, "ABORT, backtrace:");
	back_trace();
	kill(0, SIGTERM);
	exit(EXIT_FAILURE);
}
char *gpa(struct sockaddr *ai_addr) {				// returns string with IP4 address & port assigned to the socket
	char *s = malloc(64);
	unsigned short port = *(unsigned short*) ai_addr->sa_data;
	char *a = ai_addr->sa_data + 2;
	sprintf(s, "%hhu.%hhu.%hhu.%hhu %hu", a[0], a[1], a[2], a[3], ntohs(port));
	return s;
}
void gai(int level, struct addrinfo *ai, DebugP pr) {	// logs assigned IP4 addresses from addrinfo chain
	struct addrinfo *sa = ai;
	if (csP->debMaxLev >= level) do {
		char *s = gpa(sa->ai_addr);
		strcpy(pr->msg, s); free(s);
		deb(level, pr);
	} while ((sa = sa->ai_next));
	fflush(stderr);
}
void ssl_err(DebugP pr, char *s) {
	long e;
	e = ERR_get_error();
	LOG(4, "ssl err, e=%lu", e);
	while(e) {
		LOG(0, "%s: %s", s, ERR_error_string(e, NULL));
		e = ERR_get_error();
		LOG(4, "ssl err, e=%lu", e);
	}
	abend(pr);
}
static int getArg(char *a) {
	return (getenv(a) != NULL) ? atoi(getenv(a)) : 0;
}
static void constellation(topology topo, int ssl) {
	DEBID("%sSSL %s", ssl ? "" : "non", topo==mash ? "MASH" : "RING");
	int first, nodes, *forw, pid, stat, exitRc = EXIT_SUCCESS;
	pid_t *pids;
	if(topo==ring) { first=csP->rp0; nodes=csP->rn; }
	if(topo==mash) { first=csP->mp0; nodes=csP->mn; }
	if(nodes == 0) exit(0);
	if(nodes == 1) { LOG(0, "1 node configuration not implemented"); exit(0); }
	LOG(1, "%d node(s) starting...", nodes);
	pids = malloc(nodes*sizeof(int));
	first += ssl*500;
	if((forw = mmap(NULL, sizeof(int), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0)) < 0) SYSERR("mmap");
	*forw = 1;
	for(int i = 0; i < nodes; i++) {
		if(!(pid = fork())) Node(topo, forw, first+i, first, nodes, ssl);
		else { LOG(3, "node %u established in process %u", first+i, pid); pids[i] = (pid_t)pid; }	   
	}
	LOG(2, "all nodes established");
	while((pid = wait(&stat)) > 0) {
		if(WIFEXITED(stat)) {
			LOG(4, "node process %u ended with exit(%d)", pid, WEXITSTATUS(stat));
			if(WEXITSTATUS(stat) != EXIT_SUCCESS) exitRc = EXIT_FAILURE;
		}
		else { LOG(4, "node process %u crashed", pid); exitRc = EXIT_FAILURE; }
	}
	LOG(1, "ENDED %s", exitRc == EXIT_SUCCESS ? "OK" : "BADLY");
	exit(exitRc);
}
int main(int argc, char *argv[]) {
	CST cs;
	csP = &cs;
	deP = &(csP->debug);
	ShareA(csP->shP);
	struct sigaction ign;

	if(sem_init(&(csP->shP->debugSem), 1, 1) < 0) ERR("LOG sem_init");
	debug_init(argv[0]);
	DEBID("client/server demo");
	if(getArg("DEB") >= 0) csP->debMaxLev = getArg("DEB");

	if(sem_init(&csP->shP->counterSem, 1, 1) < 0) SYSERR("sem_init");
	ign.sa_flags = 0;
	ign.sa_handler = SIG_IGN;
	if(sigaction(SIGUSR2, &ign, NULL)<0) SYSERR("sigaction");

	csP->shP->msgs = 0;
	csP->shP->conns = 0;
	csP->text="bla bla";
	csP->ttl = 3;
	csP->rp0 = 11000;
	csP->mp0 = 12000;
	csP->rn = 0;
	csP->mn = 0;
	csP->pace.tv_sec = csP->pace.tv_nsec = 0;
	csP->connThreshold = 77;			// connection retries threshold
	csP->connTO = 0.01 * 1000*1000;	// connection timeout in usecs
	csP->selTO = 1;						// selection timeout in secs
	csP->issl = 0;
	csP->caP = (char*)"/home/local/etc/ssl/certs/";
	char *sslPathSuffP = "/../CS/";

	if(getenv("T") != NULL) csP->text = getenv("T");
	if(getenv("CEP") != NULL) {
		csP->ceP = (char*)malloc(strlen(getenv("CEP")));
		strcpy(csP->ceP, getenv("CEP")); }
	else {csP->ceP = (char*)malloc(strlen(dirname(argv[0])) + strlen(sslPathSuffP) + 1);
		strcpy(csP->ceP, dirname(argv[0]));
		strcpy(csP->ceP + strlen(dirname(argv[0])), sslPathSuffP); }
	if(getenv("CAP") != NULL)  {
		csP->caP = (char*)malloc(strlen(getenv("CAP")) + 1);
		strcpy(csP->caP, getenv("CAP"));	}
	if(getArg("TTL") > 0) csP->ttl = getArg("TTL");
	if(getArg("RP0") > 0) csP->rp0 = getArg("RP0");
	if(getArg("MP0") > 0) csP->mp0 = getArg("MP0");
	if(getArg("N") >= 0) {
		csP->mn = getArg("N");
		csP->rn = csP->mn; }
	if(getArg("SSL") >= 0) csP->issl = getArg("SSL");
	if(getArg("RN") >= 0) csP->rn = getArg("RN");
	if(getArg("MN") >= 0) csP->mn = getArg("MN");
	csP->shP->act = csP->rn + csP->mn;		// initialize active node processes counter
	if(csP->issl > 1) csP->shP->act += csP->shP->act;
	csP->pacing = 0;
   if(getenv("P") != NULL) {
	  	double d = atof(getenv("P"));
	  	csP->pace.tv_sec=(time_t)trunc(d);
	  	csP->pace.tv_nsec=(d-csP->pace.tv_sec)*1000*1000*1000;
	  	if(csP->pace.tv_sec > 0 || csP->pace.tv_nsec > 0) csP->pacing = 1;
   }
	if(getArg("RS") >= 0) srandom(getArg("RS"));
//	LOG(5, "initialized: ssl=%u, ssl path: %s, CA path: %s, pace=%f",
//				csP->issl, csP->ceP, csP->caP, (double)csP->pace.tv_sec+(double)csP->pace.tv_nsec/(1000*1000*1000));
   LOG(1, "pgm=%s, ttl=%u, pace=%lu.%03lu, seed=%u, SSL=%u, debug=%d",\
   			argv[0], csP->ttl, csP->pace.tv_sec, csP->pace.tv_nsec/(1000*1000), getArg("RS"), csP->issl, csP->debMaxLev);
   if(csP->issl > 0) LOG(3, "certs path=%s, CA certs path=%s", csP->ceP, csP->caP);

	if(csP->issl < 2) {		// 0 = no ssl, 1 = with SSL, 2 = both
		if(!fork()) constellation(ring, csP->issl);
		if(!fork()) constellation(mash, csP->issl);
	} else for(int i = 0; i < 2; i++) {
		if(!fork()) constellation(ring, i);
		if(!fork()) constellation(mash, i);
	}

	int stat, pid;
	while((pid = wait(&stat)) > 0) if(WIFEXITED(stat)) LOG(4, "constellation process %u ended with exit(%d)", pid, WEXITSTATUS(stat));

	LOG(1, "final balance: forwards=%d, connections=%d", csP->shP->msgs, csP->shP->conns);
	return 0;
}