// :vi sw=4 ts=4 noet:
/*
==================================================================================
	Copyright (c) 2019 Nokia 
	Copyright (c) 2018-2019 AT&T Intellectual Property.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================================
*/

/*
	Mnemonic:	rt_generic_static.c
	Abstract:	These are route table functions which are not specific to the 
				underlying protocol.  rtable_static, and rtable_nng_static
				have transport provider specific code.

				This file must be included before the nng/nano specific file as
				it defines types. 

	Author:		E. Scott Daniels
	Date:		5  February 2019
*/

#ifndef rt_generic_static_c
#define rt_generic_static_c

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>


/*
	Passed to a symtab foreach callback to construct a list of pointers from 
	a current symtab.
*/
typedef struct thing_list {
	int nalloc;
	int nused;
	void** things;
} thing_list_t;


/*
	Given a message type create a route table entry and add to the hash keyed on the
	message type.  Once in the hash, endpoints can be added with uta_add_ep. Size
	is the number of group slots to allocate in the entry.
*/
static rtable_ent_t* uta_add_rte( route_table_t* rt, int mtype, int nrrgroups ) {
	rtable_ent_t* rte;

	if( rt == NULL ) {
		return NULL;
	}

	if( (rte = (rtable_ent_t *) malloc( sizeof( *rte ) )) == NULL ) {
		fprintf( stderr, "rmr_add_rte: malloc failed for entry\n" );
		return NULL;
	}
	memset( rte, 0, sizeof( *rte ) );

	if( nrrgroups <= 0 ) {
		nrrgroups = 10;
	}

	if( (rte->rrgroups = (rrgroup_t **) malloc( sizeof( rrgroup_t * ) * nrrgroups )) == NULL ) {
		fprintf( stderr, "rmr_add_rte: malloc failed for rrgroup array\n" );
		free( rte );
		return NULL;
	}
	memset( rte->rrgroups, 0, sizeof( rrgroup_t *) * nrrgroups );
	rte->nrrgroups = nrrgroups;

	rmr_sym_map( rt->hash, mtype, rte );							// add to hash using numeric mtype as key

	if( DEBUG ) fprintf( stderr, "[DBUG] route table entry created: mt=%d groups=%d\n", mtype, nrrgroups );
	return rte;
}

/*
	Parse a single record recevied from the route table generator, or read
	from a static route table file.  Start records cause a new table to 
	be started (if a partial table was received it is discarded. Table
	entry records are added to the currenly 'in progress' table, and an 
	end record causes the in progress table to be finalised and the
	currently active table is replaced.
*/
static void parse_rt_rec( uta_ctx_t* ctx, char* buf, int vlevel ) {
	int i;
	int ntoks;							// number of tokens found in something
	int ngtoks;
	int	grp;							// group number
	rtable_ent_t*	rte;				// route table entry added
	char*	tokens[128];
	char*	gtokens[64];				// groups
	char*	tok;						// pointer into a token or string

	if( ! buf ) {
		return;
	}

	while( *buf && isspace( *buf ) ) {							// skip leading whitespace
		buf++;
	}
	for( tok = buf + (strlen( buf ) - 1); tok > buf && isspace( *tok ); tok-- );	// trim trailing spaces too
	*(tok+1) = 0;

	if( (ntoks = uta_tokenise( buf, tokens, 128, '|' )) > 0 ) {
		switch( *(tokens[0]) ) {
			case 0:													// ignore blanks
				// fallthrough
			case '#':												// and comment lines
				break;

			case 'n':												// newrt|{start|end}
				if( strcmp( tokens[1], "end" ) == 0 ) {				// wrap up the table we were building
					if( ctx->new_rtable ) {
						uta_rt_drop( ctx->old_rtable );				// time to drop one that was previously replaced
						ctx->old_rtable = ctx->rtable;				// currently active becomes old and allowed to 'drain'
						ctx->rtable = ctx->new_rtable;				// one we've been adding to becomes active
						ctx->new_rtable = NULL;
						if( DEBUG > 1 || (vlevel > 1) ) fprintf( stderr, "[DBUG] end of route table noticed\n" );
					} else {
						if( DEBUG > 1 ) fprintf( stderr, "[DBUG] end of route table noticed, but one was not started!\n" );
						ctx->new_rtable = NULL;
					}
				} else {											// start a new table.
					if( ctx->new_rtable != NULL ) {					// one in progress?  this forces it out
						if( DEBUG > 1 || (vlevel > 1) ) fprintf( stderr, "[DBUG] new table; dropping incomplete table\n" );
						uta_rt_drop( ctx->new_rtable );
					}	

					if( ctx->rtable )  {
						ctx->new_rtable = uta_rt_clone( ctx->rtable );	// create by cloning endpoint entries from active table
					} else {
						ctx->new_rtable = uta_rt_init(  );				// don't have one yet, just crate empty
					}
					if( DEBUG > 1 || (vlevel > 1)  ) fprintf( stderr, "[DBUG] start of route table noticed\n" );
				}
				break;

			case 'r':					// assume rt entry
				if( ! ctx->new_rtable ) {			// bad sequence, or malloc issue earlier; ignore siliently
					break;
				}

				if( ((tok = strchr( tokens[1], ',' )) == NULL ) || 					// no sender names
					(uta_has_str( tokens[1],  ctx->my_name, ',', 127) >= 0) ||		// our name isn't in the list
					has_myip( tokens[1], ctx->ip_list, ',', 127 ) ) {				// the list has one of our IP addresses 

					if( DEBUG > 1 || (vlevel > 1) ) fprintf( stderr, "[DBUG] create rte for mtype=%s\n", tokens[1] );
					
					if( (ngtoks = uta_tokenise( tokens[2], gtokens, 64, ';' )) > 0 ) {					// split last field by groups first
						rte = uta_add_rte( ctx->new_rtable, atoi( tokens[1] ), ngtoks );			// get/create entry for message type
						for( grp = 0; grp < ngtoks; grp++ ) {
							if( (ntoks = uta_tokenise( gtokens[grp], tokens, 64, ',' )) > 0 ) {
								for( i = 0; i < ntoks; i++ ) {
									if( DEBUG > 1  || (vlevel > 1)) fprintf( stderr, "[DBUG]    add endpoint  %s\n", tokens[i] );
									uta_add_ep( ctx->new_rtable, rte, tokens[i], grp );
								}
							}
						}
					}
				} else {
					if( DEBUG || (vlevel > 2) ) 
						fprintf( stderr, "entry not included, sender not matched: %s\n", tokens[1] );
				}

				break;

			default:
				if( DEBUG ) fprintf( stderr, "[WRN] rmr_rtc: unrecognised request: %s\n", tokens[0] );
				break;
		}
	}
}

/*
	This function attempts to open a static route table in order to create a 'seed'
	table during initialisation.  The environment variable RMR_SEED_RT is expected
	to contain the necessary path to the file. If missing, or if the file is empty,
	no route table will be available until one is received from the generator. 

	This function is probably most useful for testing situations, or extreme 
	cases where the routes are static.
*/
static void read_static_rt( uta_ctx_t* ctx, int vlevel ) {
	int		i;
	char*	fname;
	char*	fbuf;				// buffer with file contents
	char*	rec;				// start of the record
	char*	eor;				// end of the record
	int		rcount = 0;			// record count for debug

	if( (fname = getenv( ENV_SEED_RT )) == NULL ) {
		return;
	}

	if( (fbuf = uta_fib( fname ) ) == NULL ) {			// read file into a single buffer
		fprintf( stderr, "[WRN] seed route table could not be opened: %s: %s\n", fname, strerror( errno ) );
		return;
	}

	if( DEBUG ) fprintf( stderr, "[INFO] seed route table successfully opened: %s\n", fname );
	for( rec = fbuf; rec && *rec; rec = eor+1 ) {
		rcount++;
		if( (eor = strchr( rec, '\n' )) != NULL ) {
			*eor = 0;
		}

		parse_rt_rec( ctx, rec, vlevel );
	}

	if( DEBUG ) fprintf( stderr, "[INFO] seed route table successfully parsed: %d records\n", rcount );
	free( fbuf );
}

/*
	Callback driven for each named thing in a symtab. We collect the pointers to those
	things for later use (cloning).
*/
static void collect_things( void* st, void* entry, char const* name, void* thing, void* vthing_list ) {
	thing_list_t*	tl;

	if( (tl = (thing_list_t *) vthing_list) == NULL ) {
		return;
	}

	if( thing == NULL ) {
		return;
	}

	tl->things[tl->nused++] = thing;		// save a reference to the thing
}

/*
	Called to delete a route table entry struct. We delete the array of endpoint 
	pointers, but NOT the endpoints referenced as those are referenced from 
	multiple entries.
*/
static void del_rte( void* st, void* entry, char const* name, void* thing, void* data ) {
	rtable_ent_t*	rte;
	int i;

	if( (rte = (rtable_ent_t *) thing) == NULL ) {
		return;
	}

	if( rte->rrgroups ) {									// clean up the round robin groups
		for( i = 0; i < rte->nrrgroups; i++ ) {
			if( rte->rrgroups[i] ) {
				free( rte->rrgroups[i]->epts );			// ditch list of endpoint pointers (end points are reused; don't trash them)
			}
		}

		free( rte->rrgroups );
	}

	free( rte );											// finally, drop the potato
}

/*
	Read an entire file into a buffer. We assume for route table files
	they will be smallish and so this won't be a problem.
	Returns a pointer to the buffer, or nil. Caller must free.
	Terminates the buffer with a nil character for string processing.

	If we cannot stat the file, we assume it's empty or missing and return
	an empty buffer, as opposed to a nil, so the caller can generate defaults
	or error if an empty/missing file isn't tolerated.
*/
static char* uta_fib( char* fname ) {
	struct stat	stats;
	off_t		fsize = 8192;	// size of the file
	off_t		nread;			// number of bytes read
	int			fd;
	char*		buf;			// input buffer
	
	if( (fd = open( fname, O_RDONLY )) >= 0 ) {
		if( fstat( fd, &stats ) >= 0 ) {
			if( stats.st_size <= 0 ) {					// empty file
				close( fd );
				fd = -1;
			} else {
				fsize = stats.st_size;						// stat ok, save the file size
			}
		} else {
			fsize = 8192; 								// stat failed, we'll leave the file open and try to read a default max of 8k
		}
	}

	if( fd < 0 ) {											// didn't open or empty
		if( (buf = (char *) malloc( sizeof( char ) * 1 )) == NULL ) {
			return NULL;
		}

		*buf = 0;
		return buf;
	}

	// add a size limit check here

	if( (buf = (char *) malloc( sizeof( char ) * fsize + 2 )) == NULL ) {		// enough to add nil char to make string
		close( fd );
		errno = ENOMEM;
		return NULL;
	}

	nread = read( fd, buf, fsize );
	if( nread < 0 || nread > fsize ) {							// failure of some kind
		free( buf );
		errno = EFBIG;											// likely too much to handle
		close( fd );
		return NULL;
	}

	buf[nread] = 0;

	close( fd );
	return buf;
}

/*
	Create and initialise a route table; Returns a pointer to the table struct.
*/
static route_table_t* uta_rt_init( ) {
	route_table_t*	rt;

	if( (rt = (route_table_t *) malloc( sizeof( route_table_t ) )) == NULL ) {
		return NULL;
	}

	if( (rt->hash = rmr_sym_alloc( 509 )) == NULL ) {		// modest size, prime
		free( rt );
		return NULL;
	}

	return rt;
}

/*
	Clone (sort of) an existing route table.  This is done to preserve the endpoint
	names referenced in a table (and thus existing sessions) when a new set
	of message type to endpoint name mappings is received.  A new route table
	with only endpoint name references is returned based on the active table in
	the context.
*/
static route_table_t* uta_rt_clone( route_table_t* srt ) {
	endpoint_t*		ep;		// an endpoint 
	route_table_t*	nrt;	// new route table
	route_table_t*	art;	// active route table
	void*	sst;			// source symtab
	void*	nst;			// new symtab
	thing_list_t things;
	int i;

	if( srt == NULL ) {
		return NULL;
	}

	if( (nrt = (route_table_t *) malloc( sizeof( *nrt ) )) == NULL ) {
		return NULL;
	}

	if( (nrt->hash = rmr_sym_alloc( 509 )) == NULL ) {		// modest size, prime
		free( nrt );
		return NULL;
	}

	things.nalloc = 2048;
	things.nused = 0;
	things.things = (void **) malloc( sizeof( void * ) * things.nalloc );
	if( things.things == NULL ) {
		free( nrt->hash );
		free( nrt );
		return NULL;
	}

	sst = srt->hash;											// convenience pointers (src symtab)
	nst = nrt->hash;

	rmr_sym_foreach_class( sst, 1, collect_things, &things );		// collect the named endpoints in the active table
	
	for( i = 0; i < things.nused; i++ ) {
		ep = (endpoint_t *) things.things[i];
		rmr_sym_put( nst, ep->name, 1, ep );						// slam this one into the new table
	}

	free( things.things );
	return nrt;
}

/*
	Given a name, find the endpoint struct in the provided route table.
*/
static endpoint_t* uta_get_ep( route_table_t* rt, char const* ep_name ) {

	if( rt == NULL || rt->hash == NULL || ep_name == NULL || *ep_name == 0 ) {
		return NULL;
	}

	return rmr_sym_get( rt->hash, ep_name, 1 );
}

/*
	Drop the given route table. Purge all type 0 entries, then drop the symtab itself.
*/
static void uta_rt_drop( route_table_t* rt ) {
	if( rt == NULL ) {
		return;
	}

	rmr_sym_foreach_class( rt->hash, 0, del_rte, NULL );		// free each rte referenced by the hash, but NOT the endpoints
	rmr_sym_free( rt->hash );									// free all of the hash related data
	free( rt );
}

/*
	Look up and return the pointer to the endpoint stuct matching the given name.
	If not in the hash, a new endpoint is created, added to the hash. Should always
	return a pointer.
*/
static endpoint_t* rt_ensure_ep( route_table_t* rt, char const* ep_name ) {
	endpoint_t*	ep;

	if( !rt || !ep_name || ! *ep_name ) {
		fprintf( stderr, "[WARN] rmr: rt_ensure:  internal mishap, something undefined rt=%p ep_name=%p\n", rt, ep_name );
		errno = EINVAL;
		return NULL;
	}

	if( (ep = uta_get_ep( rt, ep_name )) == NULL ) { 					// not there yet, make
		if( (ep = (endpoint_t *) malloc( sizeof( *ep ) )) == NULL ) {
			fprintf( stderr, "[WARN] rmr: rt_ensure:  malloc failed for endpoint creation: %s\n", ep_name );
			errno = ENOMEM;
			return NULL;
		}

		ep->open = 0;					// not connected
		ep->addr = uta_h2ip( ep_name );
		ep->name = strdup( ep_name );

		rmr_sym_put( rt->hash, ep_name, 1, ep );
	}

	return ep;
}


#endif