/*********************************************************************************************************
* Software License Agreement (BSD License)                                                               *
* Author: Sebastien Decugis <sdecugis@nict.go.jp>							 *
*													 *
* Copyright (c) 2009, WIDE Project and NICT								 *
* All rights reserved.											 *
* 													 *
* Redistribution and use of this software in source and binary forms, with or without modification, are  *
* permitted provided that the following conditions are met:						 *
* 													 *
* * Redistributions of source code must retain the above 						 *
*   copyright notice, this list of conditions and the 							 *
*   following disclaimer.										 *
*    													 *
* * Redistributions in binary form must reproduce the above 						 *
*   copyright notice, this list of conditions and the 							 *
*   following disclaimer in the documentation and/or other						 *
*   materials provided with the distribution.								 *
* 													 *
* * Neither the name of the WIDE Project or NICT nor the 						 *
*   names of its contributors may be used to endorse or 						 *
*   promote products derived from this software without 						 *
*   specific prior written permission of WIDE Project and 						 *
*   NICT.												 *
* 													 *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 	 *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 	 *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF   *
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.								 *
*********************************************************************************************************/

/* This file contains definitions for both radius_gw extension and subextensions. */

#ifndef _RG_COMMON_H
#define _RG_COMMON_H

/* Some headers that are useful in many files */
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdint.h>
#include <dlfcn.h>
#include <sys/socket.h>
#include <netdb.h>

/* This should be overwritten before including this file */
#ifndef DEFINE_DEBUG_MACRO
# define DEFINE_DEBUG_MACRO	rg_common
# ifndef RG_COMMON_VERBO
#  define RG_COMMON_VERBO	0
# endif /* RG_COMMON_VERBO */
static int rg_common_verbosity = RG_COMMON_VERBO;
#endif /* DEFINE_DEBUG_MACRO */

/* Include the waaad API definition */
#define IN_EXTENSION
#include <waaad/waaad.h>

/* Include host-specific defines */
#include "rg_host.h"

/* Include hostap files for RADIUS processings */
#include "hostap_compat.h"
#include "md5.h"
#include "radius.h"

/* Include the radius_gw API definition */
#include "rg_api.h"

/* Type of message / server */
#define RGW_EXT_TYPE_AUTH	1
#define RGW_EXT_TYPE_ACCT	2


/**************************************************************/
/*              Additional RADIUS definitions                 */
/**************************************************************/
/* Attributes missing from radius.h (not used in EAP) */
enum { RADIUS_ATTR_CHAP_PASSWORD = 3,
       RADIUS_ATTR_SERVICE_TYPE = 6,
       RADIUS_ATTR_FRAMED_PROTOCOL = 7,
       RADIUS_ATTR_FRAMED_IP_ADDRESS = 8,
       RADIUS_ATTR_FRAMED_IP_NETMASK = 9,
       RADIUS_ATTR_FRAMED_ROUTING = 10,
       RADIUS_ATTR_FILTER_ID = 11,
       RADIUS_ATTR_FRAMED_COMPRESSION = 13,
       RADIUS_ATTR_LOGIN_IP_HOST = 14,
       RADIUS_ATTR_LOGIN_SERVICE = 15,
       RADIUS_ATTR_LOGIN_TCP_PORT = 16,
       RADIUS_ATTR_CALLBACK_NUMBER = 19,
       RADIUS_ATTR_CALLBACK_ID = 20,
       RADIUS_ATTR_FRAMED_ROUTE = 22,
       RADIUS_ATTR_FRAMED_IPX_NETWORK = 23,
       RADIUS_ATTR_LOGIN_LAT_SERVICE = 34,
       RADIUS_ATTR_LOGIN_LAT_NODE = 35,
       RADIUS_ATTR_LOGIN_LAT_GROUP = 36,
       RADIUS_ATTR_FRAMED_APPLETALK_LINK = 37,
       RADIUS_ATTR_FRAMED_APPLETALK_NETWORK = 38,
       RADIUS_ATTR_FRAMED_APPLETALK_ZONE = 39,
       RADIUS_ATTR_CHAP_CHALLENGE = 60,
       RADIUS_ATTR_PORT_LIMIT = 62,
       RADIUS_ATTR_LOGIN_LAT_PORT = 63,
       RADIUS_ATTR_TUNNEL_CLIENT_ENDPOINT = 66,
       RADIUS_ATTR_TUNNEL_SERVER_ENDPOINT = 67,
       RADIUS_ATTR_TUNNEL_PASSWORD = 69,
       RADIUS_ATTR_ARAP_PASSWORD = 70,
       RADIUS_ATTR_ARAP_FEATURES = 71,
       RADIUS_ATTR_ARAP_ZONE_ACCESS = 72,
       RADIUS_ATTR_ARAP_SECURITY = 73,
       RADIUS_ATTR_ARAP_SECURITY_DATA = 74,
       RADIUS_ATTR_PASSWORD_RETRY = 75,
       RADIUS_ATTR_PROMPT = 76,
       RADIUS_ATTR_CONFIGURATION_TOKEN = 78,
       RADIUS_ATTR_TUNNEL_ASSIGNEMENT_ID = 82,
       RADIUS_ATTR_TUNNEL_PREFERENCE = 83,
       RADIUS_ATTR_ARAP_CHALLENGE_RESPONSE = 84,
       RADIUS_ATTR_NAS_PORT_ID = 87,
       RADIUS_ATTR_FRAMED_POOL = 88,
       RADIUS_ATTR_TUNNEL_CLIENT_AUTH_ID = 90,
       RADIUS_ATTR_TUNNEL_SERVER_AUTH_ID = 91,
       RADIUS_ATTR_ORIGINATING_LINE_INFO = 94,
       RADIUS_ATTR_FRAMED_INTERFACE_ID = 96,
       RADIUS_ATTR_FRAMED_IPV6_PREFIX = 97,
       RADIUS_ATTR_LOGIN_IPV6_HOST = 98,
       RADIUS_ATTR_FRAMED_IPV6_ROUTE = 99,
       RADIUS_ATTR_FRAMED_IPV6_POOL = 100,
       RADIUS_ATTR_ERROR_CAUSE = 101,
       RADIUS_ATTR_EAP_KEY_NAME = 102
};

enum {  DIAM_ATTR_USER_NAME = 1,
	DIAM_ATTR_USER_PASSWORD = 2,
	DIAM_ATTR_SERVICE_TYPE = 6,
	DIAM_ATTR_FRAMED_PROTOCOL = 7,
	DIAM_ATTR_FRAMED_IP_ADDRESS = 8,
	DIAM_ATTR_FRAMED_IP_NETMASK = 9,
	DIAM_ATTR_FRAMED_ROUTING = 10,
	DIAM_ATTR_FILTER_ID = 11,
	DIAM_ATTR_FRAMED_MTU = 12,
	DIAM_ATTR_FRAMED_COMPRESSION = 13,
	DIAM_ATTR_LOGIN_IP_HOST = 14,
	DIAM_ATTR_LOGIN_SERVICE = 15,
	DIAM_ATTR_LOGIN_TCP_PORT = 16,
	DIAM_ATTR_REPLY_MESSAGE = 18,
	DIAM_ATTR_CALLBACK_NUMBER = 19,
	DIAM_ATTR_CALLBACK_ID = 20,
	DIAM_ATTR_FRAMED_ROUTE = 22,
	DIAM_ATTR_FRAMED_IPX_NETWORK = 23,
	DIAM_ATTR_STATE = 24,
	DIAM_ATTR_CLASS = 25,
	DIAM_ATTR_IDLE_TIMEOUT = 28,
	DIAM_ATTR_LOGIN_LAT_SERVICE = 34,
	DIAM_ATTR_LOGIN_LAT_NODE = 35,
	DIAM_ATTR_LOGIN_LAT_GROUP = 36,
	DIAM_ATTR_FRAMED_APPLETALK_LINK = 37,
	DIAM_ATTR_FRAMED_APPLETALK_NETWORK = 38,
	DIAM_ATTR_FRAMED_APPLETALK_ZONE = 39,
	DIAM_ATTR_PORT_LIMIT = 62,
	DIAM_ATTR_LOGIN_LAT_PORT = 63,
	DIAM_ATTR_TUNNEL_TYPE = 64,
	DIAM_ATTR_TUNNEL_MEDIUM_TYPE = 65,
	DIAM_ATTR_TUNNEL_CLIENT_ENDPOINT = 66,
	DIAM_ATTR_TUNNEL_SERVER_ENDPOINT = 67,
	DIAM_ATTR_TUNNEL_PASSWORD = 69,
	DIAM_ATTR_ARAP_FEATURES = 71,
	DIAM_ATTR_ARAP_ZONE_ACCESS = 72,
	DIAM_ATTR_ARAP_SECURITY = 73,
	DIAM_ATTR_ARAP_SECURITY_DATA = 74,
	DIAM_ATTR_PASSWORD_RETRY = 75,
	DIAM_ATTR_PROMPT = 76,
	DIAM_ATTR_CONFIGURATION_TOKEN = 78,
	DIAM_ATTR_TUNNEL_PRIVATE_GROUP_ID = 81,
	DIAM_ATTR_TUNNEL_ASSIGNEMENT_ID = 82,
	DIAM_ATTR_TUNNEL_PREFERENCE = 83,
	DIAM_ATTR_ARAP_CHALLENGE_RESPONSE = 84,
	DIAM_ATTR_ACCT_INTERIM_INTERVAL = 85,
	DIAM_ATTR_FRAMED_POOL = 88,
	DIAM_ATTR_TUNNEL_CLIENT_AUTH_ID = 90,
	DIAM_ATTR_TUNNEL_SERVER_AUTH_ID = 91,
	DIAM_ATTR_FRAMED_INTERFACE_ID = 96,
	DIAM_ATTR_FRAMED_IPV6_PREFIX = 97,
	DIAM_ATTR_LOGIN_IPV6_HOST = 98,
	DIAM_ATTR_FRAMED_IPV6_ROUTE = 99,
	DIAM_ATTR_FRAMED_IPV6_POOL = 100,
	DIAM_ATTR_EAP_KEY_NAME = 102,
	DIAM_ATTR_AUTH_APPLICATION_ID = 258,
	DIAM_ATTR_MULTI_ROUND_TIMEOUT = 272,
	DIAM_ATTR_AUTH_REQUEST_TYPE = 274,
	DIAM_ATTR_AUTH_GRACE_PERIOD = 276,
	DIAM_ATTR_AUTH_SESSION_STATE = 277,
	DIAM_ATTR_ORIGIN_STATE_ID = 278,
	DIAM_ATTR_FAILED_AVP = 279,
	DIAM_ATTR_ERROR_MESSAGE = 281,
	DIAM_ATTR_ERROR_REPORTING_HOST = 294,
	DIAM_ATTR_NAS_FILTER_RULE = 400,
	DIAM_ATTR_TUNNELING = 401,
	DIAM_ATTR_QOS_FILTER_RULE = 407,
	DIAM_ATTR_ORIGIN_AAA_PROTOCOL = 408,
	DIAM_ATTR_EAP_PAYLOAD = 462,
	DIAM_ATTR_EAP_REISSUED_PAYLOAD = 463,
	DIAM_ATTR_EAP_MASTER_SESSION_KEY = 464,
	DIAM_ATTR_ACCOUNTING_EAP_AUTH_METHOD = 465
};


/**************************************************************/
/*      Functions exported by the common library extension    */
/**************************************************************/

/* List management */
struct rg_list {
	struct rg_list *next;
	struct rg_list *prev;
	struct rg_list *head;
};
void rg_list_init(struct rg_list * plist);
int  rg_list_is_empty(struct rg_list * plist);
void rg_list_insert_after(struct rg_list * ref, struct rg_list * item);
void rg_list_insert_before(struct rg_list * ref, struct rg_list * item);
void rg_list_unlink(struct rg_list * plist);

/* Others */
int rg_thread_term(pthread_t * th);
void rg_cleanup_mutex(void * mtx);

int rg_pointers_init(void ** hdl);
void rg_pointers_fini(void **hdl);
#define rg_pointers_resolve( ptr, hdl, fct, ret ) {				\
	ptr = dlsym(hdl, fct);							\
	if (!ptr) {								\
		TRACE_DEBUG(INFO, "Error in dlsym(" fct "): %s", dlerror());	\
		return ret;							\
	}									\
}


/****************************************/
/*      Debug and related stuff         */
/****************************************/

#include <assert.h>
#ifndef ASSERT
#define ASSERT(x) assert(x)
#endif /* ASSERT */


/* CHECK_* macro from the daemon */
/* Helper for tracing the CHECK_* macros bellow */
#define TRACE_DEBUG_ALL( str ) 	\
	TRACE_DEBUG(CALL, str );


/* Macros to check a return value and branch out in case of error.
 * These macro are to be used only when errors are highly improbable, not for expected errors.
 */

/* Check the return value of a system function and execute fallback in case of error */
#define CHECK_SYS_DO( __call__, __fallback__  ) { 					\
	int __ret__;									\
	TRACE_DEBUG_ALL( "Check SYS: " #__call__ );					\
	__ret__ = (__call__);								\
	if (__ret__ < 0) {								\
		int __err__ = errno;	/* We may handle EINTR here */			\
		log_error("An unexpected error occured (%s), turn on debug for detail\n",\
			strerror(__err__));						\
		TRACE_DEBUG(INFO, "Error in '" #__call__ "': %s", strerror(__err__));	\
		__fallback__;								\
	}										\
}
/* Check the return value of a system function, return error code on error */
#define CHECK_SYS( __call__  ) { 							\
	int __ret__;									\
	TRACE_DEBUG_ALL( "Check SYS: " #__call__ );					\
	__ret__ = (__call__);								\
	if (__ret__ < 0) {								\
		int __err__ = errno;	/* We may handle EINTR here */			\
		log_error("An unexpected error occured (%s), turn on debug for detail\n",\
			strerror(__err__));						\
		TRACE_DEBUG(INFO, "Error in '" #__call__ "': %s", strerror(__err__));	\
		return __err__;								\
	}										\
}

/* Check the return value of a POSIX function and execute fallback in case of error or special value */
#define CHECK_POSIX_DO2( __call__, __val__, __fallback1__, __fallback2__ ) {			\
	int __ret__;										\
	TRACE_DEBUG_ALL( "Check POSIX: " #__call__ );						\
	__ret__ = (__call__);									\
	if (__ret__ != 0) {									\
		if (__ret__ == (__val__)) {							\
			__fallback1__;								\
		} else {									\
			log_error("An unexpected error, see log for detail\n");			\
			TRACE_DEBUG(INFO, "Error in '" #__call__ "': %s", strerror(__ret__));	\
			__fallback2__;								\
		}										\
	}											\
}

/* Check the return value of a POSIX function and execute fallback in case of error */
#define CHECK_POSIX_DO( __call__, __fallback__ ) 					\
	CHECK_POSIX_DO2( (__call__), 0, , __fallback__ );

/* Check the return value of a POSIX function and return it if error */
#define CHECK_POSIX( __call__ ) { 							\
	int __v__;									\
	CHECK_POSIX_DO( __v__ = (__call__), return __v__ );				\
}

/* Check that a memory allocator did not return NULL, otherwise log an error and execute fallback */
#define CHECK_MALLOC_DO( __call__, __fallback__ ) { 					\
	void *  __ret__;								\
	TRACE_DEBUG_ALL( "Check MALLOC: " #__call__ );					\
	__ret__ = (void *)( __call__ );							\
	if (__ret__ == NULL) {								\
		int __err__ = errno;							\
		log_error("Memory allocation failed: %s\n", strerror(__err__));		\
		TRACE_DEBUG(INFO, "Error in '" #__call__ "': %s", strerror(__err__));	\
		__fallback__;								\
	}										\
}

/* Check that a memory allocator did not return NULL, otherwise return ENOMEM */
#define CHECK_MALLOC( __call__ )							\
	CHECK_MALLOC_DO( __call__, return ENOMEM );


/* The next functions can be used also for expected errors */

/* Check parameters at function entry, execute fallback on error */
#define CHECK_PARAMS_DO( __bool__, __fallback__ )					\
	TRACE_DEBUG_ALL( "Check PARAMS: " #__bool__ );					\
	if ( ! (__bool__) ) {								\
		TRACE_DEBUG(INFO, "Invalid parameter received in " #__bool__ );		\
		__fallback__;								\
	}
/* Check parameters at function entry, return EINVAL if the boolean is false (similar to assert) */
#define CHECK_PARAMS( __bool__ )							\
	CHECK_PARAMS_DO( __bool__, return EINVAL );

/* Check the return value of an internal function, log and propagate */
#define CHECK_FCT_DO( __call__, __fallback__ ) {					\
	int __ret__;									\
	TRACE_DEBUG_ALL( "Check FCT: " #__call__ );					\
	__ret__ = (__call__);								\
	if (__ret__ != 0) {								\
		TRACE_DEBUG(INFO, "Error in '" #__call__ "': %s", strerror(__ret__));	\
		__fallback__;								\
	}										\
}
/* Check the return value of a function call, return any error code */
#define CHECK_FCT( __call__ ) {								\
	int __v__;									\
	CHECK_FCT_DO( __v__ = (__call__), return __v__ );				\
}
		

#endif /* _RG_COMMON_H */