#ifndef _CSH_

#define _CSH_ 1

using namespace std;

#include <string>

#include <iostream>

#include <thread>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <signal.h>

#include <errno.h>

#include <time.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <sys/time.h>

#include <openssl/ssl.h>

#include <openssl/bio.h>

#include <openssl/err.h>

#include <sys/wait.h>

#include <sys/select.h>

#include <sys/mman.h>

#include <semaphore.h>

#include <libgen.h>

#include <math.h>

#include "Debug.h"

typedef struct ShareS {			// shared items between procs or threads

	int conns;						// overall connections# both in ring and mash

	int msgs;						// overall forwards#	   both in ring and mash

	int act;							//	active nodes#		   both in ring and mash

	sem_t counterSem;				// semaphore for counters

} ShareT, *ShareP;

#define ShareA(v) if((v = (ShareP) mmap(NULL, sizeof(ShareT), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0)) < 0) SYSERR("mmap")

typedef struct CSS {				// top level attributes

	string text;					// text to be sent in messages

	int ttl;							// TTL for circulating msgs

	int mp0;							// TCP port of first mash node

	int mn;							// intended # of nodes in mash

	int rp0;							// TCP port of first ring node

	int rn;							// intended # of nodes in ring

   struct timespec pace;		// pacing time quantum

   int pacing;						// pacing indicator

	int issl;						// ssl switch: 0=no_ssl, 1=ssl, 2=both

	int connThreshold;			// connection retry threshhold

	int connTO;						// connection timeout in usecs

	int selTO;						// selection timeout in secs

	string cePath;					// SSL certs path

	string caPath;					// CA  certs path

	ShareP shP;

	CSS(DebugP, char*);

} *CSP;

typedef struct HeaderS {		// container header

	int ttl;

	int ts;

	int remPort;

	HeaderS();

	HeaderS(int);

	int len();

} *HeaderP;

typedef struct PayloadS {		// payload structure

	time_t ts;

	char text;

	PayloadS();

	PayloadS(const char *);

	int check(PayloadS*);

	char *deliver();

	string digest();

	void sabotage();

	int len();

} *PayloadP;

typedef struct ContainerS {	// data container sent throug mash or ring

	HeaderS hdr;

	PayloadS payl;

	int len();

} ContainerT, *ContainerP;

typedef class DataC {			// data sent and received

public:

	DebugP deP;

	ContainerP contP;

	int dataLen;

//	int transferLen;

	DataC();

	DataC(DebugP);

	int dttl();

	int ttl();

	void load(int, const char*);

	string unld();

	string digest();

	bool dataOk();

	int ts();

	int remPort();

	int remPort(int);

} *DataP;

typedef struct SocketS {		// info about sockets allocated in node

	int remPort;

	int sc;

	SSL *sslP;

} *SocketP;

typedef enum{ring, mash} topology;

typedef enum{client, server} nodeside;

class ConstellationC {			// constellation of communication nodes (mash or ring)

	DebugP deP;

public:

	topology topo;

	int ssl, first, nodes, *forwP;

	ConstellationC();

	ConstellationC(topology, int);

	int run();

};

typedef ConstellationC *ConstellationP;

class NodeC : public ConstellationC {	// attributes and operations of one node of constellation (mash or ring)

public:

	DebugP deP;

	int locPort;

	int last;

	int kicker;

	int closing;

	thread closingThread;		// thread to close client side sockets

	DataC data;

	int len;

	int ssc;

	SocketP cliSides;

	SocketP srvSides;

	SSL_CTX *ctxP;

	NodeC(ConstellationP, int);

	int run();

	void mainLoop();

	void bindN();

	void conn(int, int);

	void acc(int);

	void closeSocket(int, nodeside);

	int getN(int);

	int readN(int);

	int putN(int);

	int writeN(int);

	int next_node();

	void forward(int);

	void closeClients();

};

typedef NodeC *NodeP;

extern char *gpa(struct sockaddr *);

extern void gai(int, struct addrinfo *ai, DebugP);

#define GAI(level, ai) gai(level, ai, deP)

extern void ssl_err(char*);

extern void abend();

#define SYSERR(e) LOG(0, "%s: %s (%d)", (char*)e, strerror(errno), errno), abend(deP)

#define SSLERR(e) ssl_err((char*)e, deP), abend(deP)

#define SOFTERR(e) LOG(0, e), fflush(stderr)

#define HARDERR(e) SOFTERR(e), abend(deP);

extern CSP csP;

#endif