[svn-commits] trunk r36406 - in /trunk: apps/ doc/ include/asterisk/ res/

svn-commits at lists.digium.com svn-commits at lists.digium.com
Fri Jun 30 08:12:35 MST 2006


Author: mogorman
Date: Fri Jun 30 10:12:35 2006
New Revision: 36406

URL: http://svn.digium.com/view/asterisk?rev=36406&view=rev
Log:
Updates from transnexus to osplookup, removes res_osp
and puts all logic into the app, documentation provided now
in osp.txt.


Added:
    trunk/doc/osp.txt   (with props)
Removed:
    trunk/res/res_osp.c
Modified:
    trunk/apps/app_osplookup.c
    trunk/include/asterisk/astosp.h

Modified: trunk/apps/app_osplookup.c
URL: http://svn.digium.com/view/asterisk/trunk/apps/app_osplookup.c?rev=36406&r1=36405&r2=36406&view=diff
==============================================================================
--- trunk/apps/app_osplookup.c (original)
+++ trunk/apps/app_osplookup.c Fri Jun 30 10:12:35 2006
@@ -18,7 +18,7 @@
 
 /*!
  * \file
- * \brief Open Settlement Protocol Applications
+ * \brief Open Settlement Protocol (OSP) Applications
  *
  * \author Mark Spencer <markster at digium.com>
  * 
@@ -34,91 +34,953 @@
 
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
+#include <sys/types.h>
 #include <stdio.h>
-#include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <string.h>
-#include <ctype.h>
+#include <errno.h>
+#include <osp/osp.h>
+#include <osp/osputils.h>
 
 #include "asterisk/lock.h"
-#include "asterisk/file.h"
-#include "asterisk/logger.h"
+#include "asterisk/config.h"
+#include "asterisk/utils.h"
+#include "asterisk/causes.h"
 #include "asterisk/channel.h"
+#include "asterisk/app.h"
+#include "asterisk/module.h"
 #include "asterisk/pbx.h"
 #include "asterisk/options.h"
-#include "asterisk/config.h"
-#include "asterisk/module.h"
-#include "asterisk/utils.h"
-#include "asterisk/causes.h"
+#include "asterisk/cli.h"
+#include "asterisk/logger.h"
 #include "asterisk/astosp.h"
-#include "asterisk/app.h"
-#include "asterisk/options.h"
-
-static char *app1= "OSPAuth";
-static char *synopsis1 = "OSP authentication";
-static char *descrip1 = 
-"  OSPAuth([provider[|options]]):  Authenticate a SIP INVITE by OSP and sets\n"
-"the variables:\n"
-" ${OSPINHANDLE}:  The in_bound call transaction handle\n"
-" ${OSPINTIMELIMIT}:  The in_bound call duration limit in seconds\n"
-"\n"
-"The option string may contain the following character:\n"
-"	'j' -- jump to n+101 priority if the authentication was NOT successful\n"
-"This application sets the following channel variable upon completion:\n"
-"	OSPAUTHSTATUS	The status of the OSP Auth attempt as a text string, one of\n"
-"		SUCCESS | FAILED | ERROR\n";
-
-static char *app2= "OSPLookup";
-static char *synopsis2 = "Lookup destination by OSP";
-static char *descrip2 = 
-"  OSPLookup(exten[|provider[|options]]):  Looks up an extension via OSP and sets\n"
-"the variables, where 'n' is the number of the result beginning with 1:\n"
-" ${OSPOUTHANDLE}:  The OSP Handle for anything remaining\n"
-" ${OSPTECH}:  The technology to use for the call\n"
-" ${OSPDEST}:  The destination to use for the call\n"
-" ${OSPCALLING}:  The calling number to use for the call\n"
-" ${OSPOUTTOKEN}:  The actual OSP token as a string\n"
-" ${OSPOUTTIMELIMIT}:  The out_bound call duration limit in seconds\n"
-" ${OSPRESULTS}:  The number of OSP results total remaining\n"
-"\n"
-"The option string may contain the following character:\n"
-"	'j' -- jump to n+101 priority if the lookup was NOT successful\n"
-"This application sets the following channel variable upon completion:\n"
-"	OSPLOOKUPSTATUS	The status of the OSP Lookup attempt as a text string, one of\n"
-"		SUCCESS | FAILED | ERROR\n";
-
-static char *app3 = "OSPNext";
-static char *synopsis3 = "Lookup next destination by OSP";
-static char *descrip3 = 
-"  OSPNext(cause[|options]):  Looks up the next OSP Destination for ${OSPOUTHANDLE}\n"
-"See OSPLookup for more information\n"
-"\n"
-"The option string may contain the following character:\n"
-"	'j' -- jump to n+101 priority if the lookup was NOT successful\n"
-"This application sets the following channel variable upon completion:\n"
-"	OSPNEXTSTATUS	The status of the OSP Next attempt as a text string, one of\n"
-"		SUCCESS | FAILED |ERROR\n";
-
-static char *app4 = "OSPFinish";
-static char *synopsis4 = "Record OSP entry";
-static char *descrip4 = 
-"  OSPFinish([status[|options]]):  Records call state for ${OSPINHANDLE}, according to\n"
-"status, which should be one of BUSY, CONGESTION, ANSWER, NOANSWER, or CHANUNAVAIL\n"
-"or coincidentally, just what the Dial application stores in its ${DIALSTATUS}.\n"
-"\n"
-"The option string may contain the following character:\n"
-"	'j' -- jump to n+101 priority if the finish attempt was NOT successful\n"
-"This application sets the following channel variable upon completion:\n"
-"	OSPFINISHSTATUS	The status of the OSP Finish attempt as a text string, one of\n"
-"		SUCCESS | FAILED |ERROR \n";
-
-LOCAL_USER_DECL;
-
-static int ospauth_exec(struct ast_channel *chan, void *data)
+
+/* OSP Buffer Sizes */
+#define OSP_INTSTR_SIZE			((unsigned int)16)			/* OSP signed/unsigned int string buffer size */
+#define OSP_NORSTR_SIZE			((unsigned int)256)			/* OSP normal string buffer size */
+#define OSP_TOKSTR_SIZE			((unsigned int)4096)		/* OSP token string buffer size */
+
+/* OSP Constants */
+#define OSP_INVALID_HANDLE		((int)-1)					/* Invalid OSP handle, provider, transaction etc. */
+#define OSP_CONFIG_FILE			((const char*)"osp.conf")	/* OSP configuration file name */
+#define OSP_GENERAL_CAT			((const char*)"general")	/* OSP global configuration context name */
+#define OSP_DEF_PROVIDER		((const char*)"default")	/* OSP default provider context name */
+#define OSP_MAX_CERTS			((unsigned int)10)			/* OSP max number of cacerts */
+#define OSP_MAX_SRVS			((unsigned int)10)			/* OSP max number of service points */
+#define OSP_DEF_MAXCONNECTIONS	((unsigned int)20)			/* OSP default max_connections */
+#define OSP_MIN_MAXCONNECTIONS	((unsigned int)1)			/* OSP min max_connections */
+#define OSP_MAX_MAXCONNECTIONS	((unsigned int)1000)		/* OSP max max_connections */
+#define OSP_DEF_RETRYDELAY		((unsigned int)0)			/* OSP default retry delay */
+#define OSP_MIN_RETRYDELAY		((unsigned int)0)			/* OSP min retry delay */
+#define OSP_MAX_RETRYDELAY		((unsigned int)10)			/* OSP max retry delay */
+#define OSP_DEF_RETRYLIMIT		((unsigned int)2)			/* OSP default retry times */
+#define OSP_MIN_RETRYLIMIT		((unsigned int)0)			/* OSP min retry times */
+#define OSP_MAX_RETRYLIMIT		((unsigned int)100)			/* OSP max retry times */
+#define OSP_DEF_TIMEOUT			((unsigned int)500)			/* OSP default timeout in ms */
+#define OSP_MIN_TIMEOUT			((unsigned int)200)			/* OSP min timeout in ms */
+#define OSP_MAX_TIMEOUT			((unsigned int)10000)		/* OSP max timeout in ms */
+#define OSP_DEF_AUTHPOLICY		((enum osp_authpolicy)OSP_AUTH_YES)
+#define OSP_AUDIT_URL			((const char*)"localhost")	/* OSP default Audit URL */
+#define OSP_LOCAL_VALIDATION	((int)1)					/* Validate OSP token locally */
+#define OSP_SSL_LIFETIME		((unsigned int)300)			/* SSL life time, in seconds */
+#define OSP_HTTP_PERSISTENCE	((int)1)					/* In seconds */
+#define OSP_CUSTOMER_ID			((const char*)"")			/* OSP customer ID */
+#define OSP_DEVICE_ID			((const char*)"")			/* OSP device ID */
+#define OSP_DEF_DESTINATIONS	((unsigned int)5)			/* OSP default max number of destinations */
+#define OSP_DEF_TIMELIMIT		((unsigned int)0)			/* OSP default duration limit, no limit */
+
+/* OSP Authentication Policy */
+enum osp_authpolicy {
+	OSP_AUTH_NO,		/* Accept any call */
+	OSP_AUTH_YES,		/* Accept call with valid OSP token or without OSP token */
+	OSP_AUTH_EXCLUSIVE	/* Only accept call with valid OSP token */
+};
+
+/* OSP Provider */
+struct osp_provider {
+	char name[OSP_NORSTR_SIZE];						/* OSP provider context name */
+	char privatekey[OSP_NORSTR_SIZE];				/* OSP private key file name */
+	char localcert[OSP_NORSTR_SIZE];				/* OSP local cert file name */
+	unsigned int cacount;							/* Number of cacerts */
+	char cacerts[OSP_MAX_CERTS][OSP_NORSTR_SIZE]; 	/* Cacert file names */
+	unsigned int spcount;							/* Number of service points */
+	char srvpoints[OSP_MAX_SRVS][OSP_NORSTR_SIZE];	/* Service point URLs */
+	int maxconnections;								/* Max number of connections */
+	int retrydelay;									/* Retry delay */
+	int retrylimit;									/* Retry limit */
+	int timeout;									/* Timeout in ms */
+	char source[OSP_NORSTR_SIZE];					/* IP of self */
+	enum osp_authpolicy authpolicy;					/* OSP authentication policy */
+	OSPTPROVHANDLE handle;							/* OSP provider handle */
+	struct osp_provider* next;						/* Pointer to next OSP provider */
+};
+
+/* OSP Application In/Output Results */
+struct osp_result {
+	int inhandle;					/* Inbound transaction handle */
+	int outhandle;					/* Outbound transaction handle */
+	unsigned int intimelimit;		/* Inbound duration limit */
+	unsigned int outtimelimit;		/* Outbound duration limit */
+	char tech[20];					/* Asterisk TECH string */
+	char dest[OSP_NORSTR_SIZE];		/* Destination in called at IP format */
+	char calling[OSP_NORSTR_SIZE];	/* Calling number, may be translated */
+	char token[OSP_TOKSTR_SIZE];	/* Outbound OSP token */
+	int numresults;					/* Number of remain destinations */
+};
+
+/* OSP Module Global Variables */
+AST_MUTEX_DEFINE_STATIC(osplock);							/* Lock of OSP provider list */
+static int osp_initialized = 0;								/* Init flag */
+static int osp_hardware = 0;								/* Hardware accelleration flag */
+static struct osp_provider* ospproviders = NULL;			/* OSP provider list */
+static unsigned int osp_tokenformat = TOKEN_ALGO_SIGNED;	/* Token format supported */
+
+/* OSP Client Wrapper APIs */
+
+/*!
+ * \brief Create OSP provider handle according to configuration
+ * \param cfg OSP configuration
+ * \param provider OSP provider context name
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_create_provider(
+	struct ast_config* cfg,		/* OSP configuration */
+	const char* provider)		/* OSP provider context name */
+{
+	int res;
+	unsigned int t, i, j;
+	struct osp_provider* p;
+	struct ast_variable* v;
+	OSPTPRIVATEKEY privatekey;
+	OSPTCERT localcert;
+	const char* psrvpoints[OSP_MAX_SRVS];
+	OSPTCERT cacerts[OSP_MAX_CERTS];
+	const OSPTCERT* pcacerts[OSP_MAX_CERTS];
+	int error = OSPC_ERR_NO_ERROR;
+
+	if (!(p = ast_calloc(1, sizeof(*p)))) {
+		ast_log(LOG_ERROR, "Out of memory\n");
+		return -1;
+	}
+
+	ast_copy_string(p->name, provider, sizeof(p->name));
+	snprintf(p->privatekey, sizeof(p->privatekey), "%s/%s-privatekey.pem", ast_config_AST_KEY_DIR, provider);
+	snprintf(p->localcert, sizeof(p->localcert), "%s/%s-localcert.pem", ast_config_AST_KEY_DIR, provider);
+	p->maxconnections = OSP_DEF_MAXCONNECTIONS;
+	p->retrydelay = OSP_DEF_RETRYDELAY;
+	p->retrylimit = OSP_DEF_RETRYLIMIT;
+	p->timeout = OSP_DEF_TIMEOUT;
+	p->authpolicy = OSP_DEF_AUTHPOLICY;
+	p->handle = OSP_INVALID_HANDLE;
+
+	v = ast_variable_browse(cfg, provider);
+	while(v) {
+		if (!strcasecmp(v->name, "privatekey")) {
+			if (v->value[0] == '/') {
+				ast_copy_string(p->privatekey, v->value, sizeof(p->privatekey));
+			} else {
+				snprintf(p->privatekey, sizeof(p->privatekey), "%s/%s", ast_config_AST_KEY_DIR, v->value);
+			}
+			ast_log(LOG_DEBUG, "OSP: privatekey '%s'\n", p->privatekey);
+		} else if (!strcasecmp(v->name, "localcert")) {
+			if (v->value[0] == '/') {
+				ast_copy_string(p->localcert, v->value, sizeof(p->localcert));
+			} else {
+				snprintf(p->localcert, sizeof(p->localcert), "%s/%s", ast_config_AST_KEY_DIR, v->value);
+			}
+			ast_log(LOG_DEBUG, "OSP: localcert '%s'\n", p->localcert);
+		} else if (!strcasecmp(v->name, "cacert")) {
+			if (p->cacount < OSP_MAX_CERTS) {
+				if (v->value[0] == '/') {
+					ast_copy_string(p->cacerts[p->cacount], v->value, sizeof(p->cacerts[0]));
+				} else {
+					snprintf(p->cacerts[p->cacount], sizeof(p->cacerts[0]), "%s/%s", ast_config_AST_KEY_DIR, v->value);
+				}
+				ast_log(LOG_DEBUG, "OSP: cacert[%d]: '%s'\n", p->cacount, p->cacerts[p->cacount]);
+				p->cacount++;
+			} else {
+				ast_log(LOG_WARNING, "OSP: Too many CA Certificates at line %d\n", v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "servicepoint")) {
+			if (p->spcount < OSP_MAX_SRVS) {
+				ast_copy_string(p->srvpoints[p->spcount], v->value, sizeof(p->srvpoints[0]));
+				ast_log(LOG_DEBUG, "OSP: servicepoint[%d]: '%s'\n", p->spcount, p->srvpoints[p->spcount]);
+				p->spcount++;
+			} else {
+				ast_log(LOG_WARNING, "OSP: Too many Service Points at line %d\n", v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "maxconnections")) {
+			if ((sscanf(v->value, "%d", &t) == 1) && (t >= OSP_MIN_MAXCONNECTIONS) && (t <= OSP_MAX_MAXCONNECTIONS)) {
+				p->maxconnections = t;
+				ast_log(LOG_DEBUG, "OSP: maxconnections '%d'\n", t);
+			} else {
+				ast_log(LOG_WARNING, "OSP: maxconnections should be an integer from %d to %d, not '%s' at line %d\n", 
+					OSP_MIN_MAXCONNECTIONS, OSP_MAX_MAXCONNECTIONS, v->value, v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "retrydelay")) {
+			if ((sscanf(v->value, "%d", &t) == 1) && (t >= OSP_MIN_RETRYDELAY) && (t <= OSP_MAX_RETRYDELAY)) {
+				p->retrydelay = t;
+				ast_log(LOG_DEBUG, "OSP: retrydelay '%d'\n", t);
+			} else {
+				ast_log(LOG_WARNING, "OSP: retrydelay should be an integer from %d to %d, not '%s' at line %d\n", 
+					OSP_MIN_RETRYDELAY, OSP_MAX_RETRYDELAY, v->value, v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "retrylimit")) {
+			if ((sscanf(v->value, "%d", &t) == 1) && (t >= OSP_MIN_RETRYLIMIT) && (t <= OSP_MAX_RETRYLIMIT)) {
+				p->retrylimit = t;
+				ast_log(LOG_DEBUG, "OSP: retrylimit '%d'\n", t);
+			} else {
+				ast_log(LOG_WARNING, "OSP: retrylimit should be an integer from %d to %d, not '%s' at line %d\n", 
+					OSP_MIN_RETRYLIMIT, OSP_MAX_RETRYLIMIT, v->value, v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "timeout")) {
+			if ((sscanf(v->value, "%d", &t) == 1) && (t >= OSP_MIN_TIMEOUT) && (t <= OSP_MAX_TIMEOUT)) {
+				p->timeout = t;
+				ast_log(LOG_DEBUG, "OSP: timeout '%d'\n", t);
+			} else {
+				ast_log(LOG_WARNING, "OSP: timeout should be an integer from %d to %d, not '%s' at line %d\n", 
+					OSP_MIN_TIMEOUT, OSP_MAX_TIMEOUT, v->value, v->lineno);
+			}
+		} else if (!strcasecmp(v->name, "source")) {
+			ast_copy_string(p->source, v->value, sizeof(p->source));
+			ast_log(LOG_DEBUG, "OSP: source '%s'\n", p->source);
+		} else if (!strcasecmp(v->name, "authpolicy")) {
+			if ((sscanf(v->value, "%d", &t) == 1) && ((t == OSP_AUTH_NO) || (t == OSP_AUTH_YES) || (t == OSP_AUTH_EXCLUSIVE))) {
+				p->authpolicy = t;
+				ast_log(LOG_DEBUG, "OSP: authpolicy '%d'\n", t);
+			} else {
+				ast_log(LOG_WARNING, "OSP: authpolicy should be %d, %d or %d, not '%s' at line %d\n", 
+					OSP_AUTH_NO, OSP_AUTH_YES, OSP_AUTH_EXCLUSIVE, v->value, v->lineno);
+			}
+		}
+		v = v->next;
+	}
+
+	error = OSPPUtilLoadPEMPrivateKey(p->privatekey, &privatekey);
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_WARNING, "OSP: Unable to load privatekey '%s', error '%d'\n", p->privatekey, error);
+		free(p);
+		return 0;
+	}
+
+	error = OSPPUtilLoadPEMCert(p->localcert, &localcert);
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_WARNING, "OSP: Unable to load localcert '%s', error '%d'\n", p->localcert, error);
+		if (privatekey.PrivateKeyData) {
+			free(privatekey.PrivateKeyData);
+		}
+		free(p);
+		return 0;
+	}
+
+	if (p->cacount < 1) {
+		snprintf(p->cacerts[p->cacount], sizeof(p->cacerts[0]), "%s/%s-cacert.pem", ast_config_AST_KEY_DIR, provider);
+		ast_log(LOG_DEBUG, "OSP: cacert[%d]: '%s'\n", p->cacount, p->cacerts[p->cacount]);
+		p->cacount++;
+	}
+	for (i = 0; i < p->cacount; i++) {
+		error = OSPPUtilLoadPEMCert(p->cacerts[i], &cacerts[i]);
+		if (error != OSPC_ERR_NO_ERROR) {
+			ast_log(LOG_WARNING, "OSP: Unable to load cacert '%s', error '%d'\n", p->cacerts[i], error);
+			for (j = 0; j < i; j++) {
+				if (cacerts[j].CertData) {
+					free(cacerts[j].CertData);
+				}
+			}
+			if (localcert.CertData) {
+				free(localcert.CertData);
+			}
+			if (privatekey.PrivateKeyData) {
+				free(privatekey.PrivateKeyData);
+			}
+			free(p);
+			return 0;
+		}
+		pcacerts[i] = &cacerts[i];
+	}
+	
+	for (i = 0; i < p->spcount; i++) {
+		psrvpoints[i] = p->srvpoints[i];
+	}
+
+	error = OSPPProviderNew(
+		p->spcount, psrvpoints,
+		NULL,
+		OSP_AUDIT_URL,
+		&privatekey,
+		&localcert,
+		p->cacount, pcacerts,
+		OSP_LOCAL_VALIDATION,
+		OSP_SSL_LIFETIME,
+		p->maxconnections,
+		OSP_HTTP_PERSISTENCE,
+		p->retrydelay,
+		p->retrylimit,
+		p->timeout,
+		OSP_CUSTOMER_ID,
+		OSP_DEVICE_ID,
+		&p->handle);
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_WARNING, "OSP: Unable to create provider '%s', error '%d'\n", provider, error);
+		free(p);
+		res = -1;
+	} else {
+		ast_log(LOG_DEBUG, "OSP: provider '%s'\n", provider);
+		ast_mutex_lock(&osplock);
+		p->next = ospproviders;
+		ospproviders = p;
+		ast_mutex_unlock(&osplock); 	
+		res = 1;
+	}
+
+	for (i = 0; i < p->cacount; i++) {
+		if (cacerts[i].CertData) {
+			free(cacerts[i].CertData);
+		}
+	}
+	if (localcert.CertData) {
+		free(localcert.CertData);
+	}
+	if (privatekey.PrivateKeyData) {
+		free(privatekey.PrivateKeyData);
+	}
+
+	return res;
+}
+
+/*!
+ * \brief Get OSP authenticiation policy of provider
+ * \param provider OSP provider context name
+ * \param policy OSP authentication policy, output
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_get_policy(
+	const char* provider,		/* OSP provider context name */
+	int* policy)				/* OSP authentication policy, output */
 {
 	int res = 0;
+	struct osp_provider* p;
+
+	ast_mutex_lock(&osplock);
+	p = ospproviders;
+	while(p) {
+		if (!strcasecmp(p->name, provider)) {
+			*policy = p->authpolicy;
+			ast_log(LOG_DEBUG, "OSP: authpolicy '%d'\n", *policy);
+			res = 1;
+			break;
+		}
+		p = p->next;
+	}
+	ast_mutex_unlock(&osplock);
+
+	return res;
+}
+
+/*!
+ * \brief Create OSP transaction handle
+ * \param provider OSP provider context name
+ * \param transaction OSP transaction handle, output
+ * \param sourcesize Size of source buffer, in/output
+ * \param source Source of provider, output
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_create_transaction(
+	const char* provider,		/* OSP provider context name */
+	int* transaction,			/* OSP transaction handle, output */
+	unsigned int sourcesize,	/* Size of source buffer, in/output */
+	char* source)				/* Source of provider context, output */
+{
+	int res = 0;
+	struct osp_provider* p;
+	int error;
+
+	ast_mutex_lock(&osplock);
+	p = ospproviders;
+	while(p) {
+		if (!strcasecmp(p->name, provider)) {
+			error = OSPPTransactionNew(p->handle, transaction);
+			if (error == OSPC_ERR_NO_ERROR) {
+				ast_log(LOG_DEBUG, "OSP: transaction '%d'\n", *transaction);
+				ast_copy_string(source, p->source, sourcesize);
+				ast_log(LOG_DEBUG, "OSP: source '%s'\n", source);
+				res = 1;
+			} else {
+				*transaction = OSP_INVALID_HANDLE;
+				ast_log(LOG_DEBUG, "OSP: Unable to create transaction handle, error '%d'\n", error);
+				res = -1;
+			}
+			break;
+		}
+		p = p->next;
+	}
+	ast_mutex_unlock(&osplock);
+
+	return res;
+}
+
+/*!
+ * \brief Validate OSP token of inbound call
+ * \param transaction OSP transaction handle
+ * \param source Source of inbound call
+ * \param dest Destination of inbound call
+ * \param calling Calling number
+ * \param called Called number
+ * \param token OSP token, may be empty
+ * \param timelimit Call duration limit, output
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_validate_token(
+	int transaction,			/* OSP transaction handle */
+	const char* source,			/* Source of inbound call */
+	const char* dest,			/* Destination of inbound call */
+	const char* calling,		/* Calling number */
+	const char* called,			/* Called number */
+	const char* token,			/* OSP token, may be empty */
+	unsigned int* timelimit)	/* Call duration limit, output */
+{
+	int res;
+	int tokenlen;
+	char tokenstr[OSP_TOKSTR_SIZE];
+	unsigned int authorised;
+	unsigned int dummy = 0;
+	int error;
+
+	tokenlen = ast_base64decode(tokenstr, token, strlen(token));
+	error = OSPPTransactionValidateAuthorisation(
+		transaction, 
+		source, dest, NULL, NULL,
+		calling ? calling : "", OSPC_E164, 
+		called, OSPC_E164, 
+		0, NULL,
+		tokenlen, tokenstr, 
+		&authorised, 
+		timelimit, 
+		&dummy, NULL, 
+		osp_tokenformat); 
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Unable to validate inbound token\n");
+		res = -1;
+	} else if (authorised) {
+		ast_log(LOG_DEBUG, "OSP: Authorised\n");
+		res = 1;
+	} else {
+		ast_log(LOG_DEBUG, "OSP: Unauthorised\n");
+		res = 0;
+	}
+	
+	return res;
+}
+
+/*!
+ * \brief Choose min duration limit
+ * \param in Inbound duration limit
+ * \param out Outbound duration limit
+ * \return min duration limit
+ */
+static unsigned int osp_choose_timelimit(
+	unsigned int in,			/* Inbound duration timelimit */
+	unsigned int out)			/* Outbound duration timelimit */
+{
+	if (in == OSP_DEF_TIMELIMIT) {
+		return out;
+	} else if (out == OSP_DEF_TIMELIMIT) {
+		return in;
+	} else {
+		return in < out ? in : out;
+	}
+}
+
+/*!
+ * \brief Choose min duration limit
+ * \param called Called number
+ * \param calling Calling number
+ * \param destination Destination IP in '[x.x.x.x]' format
+ * \param tokenlen OSP token length
+ * \param token OSP token
+ * \param reason Failure reason, output
+ * \param result OSP lookup results, in/output
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_check_destination(
+	const char* called,				/* Called number */
+	const char* calling,			/* Calling number */
+	char* destination,				/* Destination IP in '[x.x.x.x]' format */
+	unsigned int tokenlen,			/* OSP token length */
+	const char* token,				/* OSP token */
+	enum OSPEFAILREASON* reason,	/* Failure reason, output */
+	struct osp_result* result)		/* OSP lookup results, in/output */
+{
+	int res;
+	OSPE_DEST_OSP_ENABLED enabled;
+	OSPE_DEST_PROT protocol;
+	int error;
+
+	if (strlen(destination) <= 2) {
+		ast_log(LOG_DEBUG, "OSP: Wrong destination format '%s'\n", destination);
+		*reason = OSPC_FAIL_NORMAL_UNSPECIFIED;
+		return -1;
+	} 
+
+	if ((error = OSPPTransactionIsDestOSPEnabled(result->outhandle, &enabled)) != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Unable to get destination OSP version, error '%d'\n", error);
+		*reason = OSPC_FAIL_NORMAL_UNSPECIFIED;
+		return -1;
+	}
+
+	if (enabled == OSPE_OSP_FALSE) {
+		result->token[0] = '\0';
+	} else {
+		ast_base64encode(result->token, token, tokenlen, sizeof(result->token) - 1);
+	}
+
+	if ((error = OSPPTransactionGetDestProtocol(result->outhandle, &protocol)) != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Unable to get destination protocol, error '%d'\n", error);
+		*reason = OSPC_FAIL_NORMAL_UNSPECIFIED; 
+		result->token[0] = '\0';
+		return -1;
+	} 
+
+	res = 1;
+	/* Strip leading and trailing brackets */
+	destination[strlen(destination) - 1] = '\0';
+	switch(protocol) {
+		case OSPE_DEST_PROT_H323_SETUP:
+			ast_log(LOG_DEBUG, "OSP: protocol '%d'\n", protocol);
+			ast_copy_string(result->tech, "H323", sizeof(result->tech));
+			snprintf(result->dest, sizeof(result->dest), "%s@%s", called, destination + 1);
+			ast_copy_string(result->calling, calling, sizeof(result->calling));
+			break;
+		case OSPE_DEST_PROT_SIP:
+			ast_log(LOG_DEBUG, "OSP: protocol '%d'\n", protocol);
+			ast_copy_string(result->tech, "SIP", sizeof(result->tech));
+			snprintf(result->dest, sizeof(result->dest), "%s@%s", called, destination + 1);
+			ast_copy_string(result->calling, calling, sizeof(result->calling));
+			break;
+		case OSPE_DEST_PROT_IAX:
+			ast_log(LOG_DEBUG, "OSP: protocol '%d'\n", protocol);
+			ast_copy_string(result->tech, "IAX", sizeof(result->tech));
+			snprintf(result->dest, sizeof(result->dest), "%s@%s", called, destination + 1);
+			ast_copy_string(result->calling, calling, sizeof(result->calling));
+			break;
+		default:
+			ast_log(LOG_DEBUG, "OSP: Unknown protocol '%d'\n", protocol);
+			*reason = OSPC_FAIL_PROTOCOL_ERROR; 
+			result->token[0] = '\0';
+			res = 0;
+	}
+
+	return res;
+}
+
+/*!
+ * \brief Convert Asterisk status to TC code
+ * \param cause Asterisk hangup cause
+ * \return OSP TC code
+ */
+static enum OSPEFAILREASON asterisk2osp(
+	int cause)						/* Asterisk hangup cause */
+{
+	return (enum OSPEFAILREASON)cause;
+}
+
+/*!
+ * \brief OSP Authentication function
+ * \param provider OSP provider context name
+ * \param transaction OSP transaction handle, output
+ * \param source Source of inbound call
+ * \param calling Calling number
+ * \param called Called number
+ * \param token OSP token, may be empty
+ * \param timelimit Call duration limit, output
+ * \return 1 Authenricated, 0 Unauthenticated, -1 Error
+ */
+static int osp_auth(
+	const char* provider,		/* OSP provider context name */
+	int* transaction,			/* OSP transaction handle, output */
+	const char* source,			/* Source of inbound call */
+	const char* calling,		/* Calling number */
+	const char* called,			/* Called number */
+	const char* token,			/* OSP token, may be empty */
+	unsigned int* timelimit)	/* Call duration limit, output */
+{
+	int res;
+	int policy;
+	char dest[OSP_NORSTR_SIZE];
+
+	*transaction = OSP_INVALID_HANDLE;
+	*timelimit = OSP_DEF_TIMELIMIT;
+
+	if ((res = osp_get_policy(provider, &policy)) <= 0) {
+		ast_log(LOG_DEBUG, "OSP: Unabe to find OSP authentication policy\n");
+		return res;
+	}
+
+	switch (policy) {
+		case OSP_AUTH_NO:
+			res = 1;
+			break;
+		case OSP_AUTH_EXCLUSIVE:
+			if (ast_strlen_zero(token)) {
+				res = 0;
+			} else if ((res = osp_create_transaction(provider, transaction, sizeof(dest), dest)) <= 0) {
+				ast_log(LOG_DEBUG, "OSP: Unable to generate transaction handle\n");
+				*transaction = OSP_INVALID_HANDLE;
+				res = 0;
+			} else if((res = osp_validate_token(*transaction, source, dest, calling, called, token, timelimit)) <= 0) {
+				OSPPTransactionRecordFailure(*transaction, OSPC_FAIL_CALL_REJECTED);
+			}
+			break;
+		case OSP_AUTH_YES:
+		default:
+			if (ast_strlen_zero(token)) {
+				res = 1;
+			} else if ((res = osp_create_transaction(provider, transaction, sizeof(dest), dest)) <= 0) {
+				ast_log(LOG_DEBUG, "OSP: Unable to generate transaction handle\n");
+				*transaction = OSP_INVALID_HANDLE;
+				res = 0;
+			} else if((res = osp_validate_token(*transaction, source, dest, calling, called, token, timelimit)) <= 0) {
+				OSPPTransactionRecordFailure(*transaction, OSPC_FAIL_CALL_REJECTED);
+			}
+			break;
+	}
+
+	return res;
+}
+
+/*!
+ * \brief OSP Lookup function
+ * \param provider OSP provider context name
+ * \param srcdev Source device of outbound call
+ * \param calling Calling number
+ * \param called Called number
+ * \param result Lookup results
+ * \return 1 Found , 0 No route, -1 Error
+ */
+static int osp_lookup(
+	const char* provider,		/* OSP provider conttext name */
+	const char* srcdev,			/* Source device of outbound call */
+	const char* calling,		/* Calling number */
+	const char* called,			/* Called number */
+	struct osp_result* result)	/* OSP lookup results, in/output */
+{
+	int res;
+	char source[OSP_NORSTR_SIZE];
+	unsigned int callidlen;
+	char callid[OSPC_CALLID_MAXSIZE];
+	char callingnum[OSP_NORSTR_SIZE];
+	char callednum[OSP_NORSTR_SIZE];
+	char destination[OSP_NORSTR_SIZE];
+	unsigned int tokenlen;
+	char token[OSP_TOKSTR_SIZE];
+	unsigned int dummy = 0;
+	enum OSPEFAILREASON reason;
+	int error;
+
+	result->outhandle = OSP_INVALID_HANDLE;
+	result->tech[0] = '\0';
+	result->dest[0] = '\0';
+	result->calling[0] = '\0';
+	result->token[0] = '\0';
+	result->numresults = 0;
+	result->outtimelimit = OSP_DEF_TIMELIMIT;
+
+	if ((res = osp_create_transaction(provider, &result->outhandle, sizeof(source), source)) <= 0) {
+		ast_log(LOG_DEBUG, "OSP: Unable to generate transaction handle\n");
+		result->outhandle = OSP_INVALID_HANDLE;
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NORMAL_UNSPECIFIED);
+		}
+		return -1;
+	}
+
+	result->numresults = OSP_DEF_DESTINATIONS;
+	error = OSPPTransactionRequestAuthorisation(
+		result->outhandle, 
+		source, srcdev,
+		calling ? calling : "", OSPC_E164, 
+		called, OSPC_E164, 
+		NULL, 
+		0, NULL, 
+		NULL, 
+		&result->numresults, 
+		&dummy, NULL);
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Unable to request authorization\n");
+		result->numresults = 0;
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NORMAL_UNSPECIFIED);
+		}
+		return -1;
+	}
+
+	if (!result->numresults) {
+		ast_log(LOG_DEBUG, "OSP: No more destination\n");
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+		}
+		return 0;
+	}
+
+	callidlen = sizeof(callid);
+	tokenlen = sizeof(token);
+	error = OSPPTransactionGetFirstDestination(
+		result->outhandle, 
+		0, NULL, NULL, 
+		&result->outtimelimit, 
+		&callidlen, callid,
+		sizeof(callednum), callednum, 
+		sizeof(callingnum), callingnum, 
+		sizeof(destination), destination, 
+		0, NULL, 
+		&tokenlen, token);
+	if (error != OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Unable to get first route\n");
+		result->numresults = 0;
+		result->outtimelimit = OSP_DEF_TIMELIMIT;
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+		}
+		return -1;
+	}
+
+	result->numresults--;
+	result->outtimelimit = osp_choose_timelimit(result->intimelimit, result->outtimelimit);
+	ast_log(LOG_DEBUG, "OSP: outtimelimit '%d'\n", result->outtimelimit);
+	ast_log(LOG_DEBUG, "OSP: called '%s'\n", callednum);
+	ast_log(LOG_DEBUG, "OSP: calling '%s'\n", callingnum);
+	ast_log(LOG_DEBUG, "OSP: destination '%s'\n", destination);
+	ast_log(LOG_DEBUG, "OSP: token size '%d'\n", tokenlen);
+
+	if ((res = osp_check_destination(callednum, callingnum, destination, tokenlen, token, &reason, result)) > 0) {
+		return 1;
+	}
+
+	if (!result->numresults) {
+		ast_log(LOG_DEBUG, "OSP: No more destination\n");
+		result->outtimelimit = OSP_DEF_TIMELIMIT;
+		OSPPTransactionRecordFailure(result->outhandle, reason);
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+		}
+		return 0;
+	}
+
+	while(result->numresults) {
+		callidlen = sizeof(callid);
+		tokenlen = sizeof(token);
+		error = OSPPTransactionGetNextDestination(
+			result->outhandle, 
+			reason, 
+			0, NULL, NULL, 
+			&result->outtimelimit, 
+			&callidlen, callid,
+			sizeof(callednum), callednum, 
+			sizeof(callingnum), callingnum, 
+			sizeof(destination), destination, 
+			0, NULL, 
+			&tokenlen, token);
+		if (error == OSPC_ERR_NO_ERROR) {
+			result->numresults--;
+			result->outtimelimit = osp_choose_timelimit(result->intimelimit, result->outtimelimit);
+			ast_log(LOG_DEBUG, "OSP: outtimelimit '%d'\n", result->outtimelimit);
+			ast_log(LOG_DEBUG, "OSP: called '%s'\n", callednum);
+			ast_log(LOG_DEBUG, "OSP: calling '%s'\n", callingnum);
+			ast_log(LOG_DEBUG, "OSP: destination '%s'\n", destination);
+			ast_log(LOG_DEBUG, "OSP: token size '%d'\n", tokenlen);
+			if ((res = osp_check_destination(callednum, callingnum, destination, tokenlen, token, &reason, result)) > 0) {
+				break;
+			} else if (!result->numresults) {
+				ast_log(LOG_DEBUG, "OSP: No more destination\n");
+				OSPPTransactionRecordFailure(result->outhandle, reason);
+				if (result->inhandle != OSP_INVALID_HANDLE) {
+					OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+				}
+				res = 0;
+				break;
+			}
+		} else {
+			ast_log(LOG_DEBUG, "OSP: Unable to get route, error '%d'\n", error);
+			result->numresults = 0;
+			result->outtimelimit = OSP_DEF_TIMELIMIT;
+			if (result->inhandle != OSP_INVALID_HANDLE) {
+				OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NORMAL_UNSPECIFIED);
+			}
+			res = -1;
+			break;
+		}
+	}
+	return res;
+}
+
+/*!
+ * \brief OSP Lookup Next function
+ * \param cause Asterisk hangup cuase
+ * \param result Lookup results, in/output
+ * \return 1 Found , 0 No route, -1 Error
+ */
+static int osp_next(
+	int cause,					/* Asterisk hangup cuase */
+	struct osp_result* result)	/* OSP lookup results, in/output */
+{
+	int res;
+	unsigned int callidlen;
+	char callid[OSPC_CALLID_MAXSIZE];
+	char callingnum[OSP_NORSTR_SIZE];
+	char callednum[OSP_NORSTR_SIZE];
+	char destination[OSP_NORSTR_SIZE];
+	unsigned int tokenlen;
+	char token[OSP_TOKSTR_SIZE];
+	enum OSPEFAILREASON reason;
+	int error;
+
+	result->tech[0] = '\0';
+	result->dest[0] = '\0';
+	result->calling[0] = '\0';
+	result->token[0] = '\0';
+	result->outtimelimit = OSP_DEF_TIMELIMIT;
+
+	if (result->outhandle == OSP_INVALID_HANDLE) {
+		ast_log(LOG_DEBUG, "OSP: Transaction handle undefined\n");
+		result->numresults = 0;
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NORMAL_UNSPECIFIED);
+		}
+		return -1;
+	}
+
+	reason = asterisk2osp(cause);
+
+	if (!result->numresults) {
+		ast_log(LOG_DEBUG, "OSP: No more destination\n");
+		OSPPTransactionRecordFailure(result->outhandle, reason);
+		if (result->inhandle != OSP_INVALID_HANDLE) {
+			OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+		}
+		return 0;
+	}
+
+	while(result->numresults) {
+		callidlen = sizeof(callid);
+		tokenlen = sizeof(token);
+		error = OSPPTransactionGetNextDestination(
+			result->outhandle, 
+			reason, 
+			0, NULL, NULL, 
+			&result->outtimelimit, 
+			&callidlen, callid,
+			sizeof(callednum), callednum, 
+			sizeof(callingnum), callingnum, 
+			sizeof(destination), destination, 
+			0, NULL, 
+			&tokenlen, token);
+		if (error == OSPC_ERR_NO_ERROR) {
+			result->numresults--;
+			result->outtimelimit = osp_choose_timelimit(result->intimelimit, result->outtimelimit);
+			ast_log(LOG_DEBUG, "OSP: outtimelimit '%d'\n", result->outtimelimit);
+			ast_log(LOG_DEBUG, "OSP: called '%s'\n", callednum);
+			ast_log(LOG_DEBUG, "OSP: calling '%s'\n", callingnum);
+			ast_log(LOG_DEBUG, "OSP: destination '%s'\n", destination);
+			ast_log(LOG_DEBUG, "OSP: token size '%d'\n", tokenlen);
+			if ((res = osp_check_destination(callednum, callingnum, destination, tokenlen, token, &reason, result)) > 0) {
+				res = 1;
+				break;
+			} else if (!result->numresults) {
+				ast_log(LOG_DEBUG, "OSP: No more destination\n");
+				OSPPTransactionRecordFailure(result->outhandle, reason);
+				if (result->inhandle != OSP_INVALID_HANDLE) {
+					OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NO_ROUTE_TO_DEST);
+				}
+				res = 0;
+				break;
+			}
+		} else {
+			ast_log(LOG_DEBUG, "OSP: Unable to get route, error '%d'\n", error);
+			result->token[0] = '\0';
+			result->numresults = 0;
+			result->outtimelimit = OSP_DEF_TIMELIMIT;
+			if (result->inhandle != OSP_INVALID_HANDLE) {
+				OSPPTransactionRecordFailure(result->inhandle, OSPC_FAIL_NORMAL_UNSPECIFIED);
+			}
+			res = -1;
+			break;
+		}
+	}
+
+	return res;
+}
+
+/*!
+ * \brief OSP Finish function
+ * \param handle OSP in/outbound transaction handle
+ * \param recorded If failure reason has been recorded
+ * \param cause Asterisk hangup cause
+ * \param start Call start time
+ * \param connect Call connect time
+ * \param end Call end time
+ * \param release Who release first, 0 source, 1 destination
+ * \return 1 Success, 0 Failed, -1 Error
+ */
+static int osp_finish(
+	int handle,				/* OSP in/outbound transaction handle */
+	int recorded,			/* If failure reason has been recorded */
+	int cause,				/* Asterisk hangup cause */
+	time_t start, 			/* Call start time */
+	time_t connect,			/* Call connect time */
+	time_t end,				/* Call end time */
+	unsigned int release)	/* Who release first, 0 source, 1 destination */
+{
+	int res;
+	enum OSPEFAILREASON reason;
+	time_t alert = 0;
+	unsigned isPddInfoPresent = 0;
+	unsigned pdd = 0;
+	unsigned char* confId = "";
+	unsigned int dummy = 0;
+	int error;
+	
+	if (handle == OSP_INVALID_HANDLE) {
+		return 0;
+	}
+
+	if (!recorded) {
+		reason = asterisk2osp(cause);
+		OSPPTransactionRecordFailure(handle, reason);
+	}
+
+	error = OSPPTransactionReportUsage(
+		handle, 
+		difftime(end, connect), start, end, alert, connect, 
+		isPddInfoPresent, pdd, 
+		release, 
+		confId,
+		0, 0, 0, 0,
+		&dummy, NULL);
+	if (error == OSPC_ERR_NO_ERROR) {
+		ast_log(LOG_DEBUG, "OSP: Usage reported\n");
+		res = 1;
+	} else {
+		ast_log(LOG_DEBUG, "OSP: Unable to report usage, error '%d'\n", error);
+		res = -1;
+	}
+	OSPPTransactionDelete(handle);
+
+	return res;
+}
+
+/* OSP Application APIs */
+
+/*!
+ * \brief OSP Application OSPAuth
+ * \param chan Channel
+ * \param data Parameter
+ * \return 0 Success, -1 Failed
+ */
+static int ospauth_exec(struct ast_channel* chan, void* data)
+{
+	int res;
 	struct localuser* u;
-	char* provider = OSP_DEF_PROVIDER;
+	const char* provider = OSP_DEF_PROVIDER;
 	int priority_jump = 0;
 	struct varshead* headp;
 	struct ast_var_t* current;
@@ -126,9 +988,9 @@
 	const char* token = "";
 	int handle;
 	unsigned int timelimit;
+	char buffer[OSP_INTSTR_SIZE];
+	const char* status;
 	char* tmp;
-	char buffer[OSP_INTSTR_SIZE];
-	char* status;
 
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(provider);
@@ -137,7 +999,11 @@
 
 	LOCAL_USER_ADD(u);
 
-	tmp = ast_strdupa(data);
+	if (!(tmp = ast_strdupa(data))) {
+		ast_log(LOG_ERROR, "Out of memory\n");
+		LOCAL_USER_REMOVE(u);
+		return -1;
+	}
 
 	AST_STANDARD_APP_ARGS(args, tmp);
 
@@ -146,10 +1012,8 @@
 	}
 	ast_log(LOG_DEBUG, "OSPAuth: provider '%s'\n", provider);
 
-	if (args.options) {
-		if (strchr(args.options, 'j')) {
-			priority_jump = 1;
-		}
+	if ((args.options) && (strchr(args.options, 'j'))) {
+		priority_jump = 1;
 	}
 	ast_log(LOG_DEBUG, "OSPAuth: priority jump '%d'\n", priority_jump);
 
@@ -164,16 +1028,15 @@
 	ast_log(LOG_DEBUG, "OSPAuth: source '%s'\n", source);
 	ast_log(LOG_DEBUG, "OSPAuth: token size '%zd'\n", strlen(token));
 
-	res = ast_osp_auth(provider, &handle, source, chan->cid.cid_num, chan->exten, token, &timelimit);
-	if (res > 0) {
-		status = OSP_APP_SUCCESS;
+	
+	if ((res = osp_auth(provider, &handle, source, chan->cid.cid_num, chan->exten, token, &timelimit)) > 0) {
+		status = AST_OSP_SUCCESS;
 	} else {
 		timelimit = OSP_DEF_TIMELIMIT;
 		if (!res) {
-			status = OSP_APP_FAILED;
+			status = AST_OSP_FAILED;
 		} else {
-			handle = OSP_INVALID_HANDLE;
-			status = OSP_APP_ERROR;
+			status = AST_OSP_ERROR;
 		}
 	}
 
@@ -186,34 +1049,41 @@
 	pbx_builtin_setvar_helper(chan, "OSPAUTHSTATUS", status);
 	ast_log(LOG_DEBUG, "OSPAuth: %s\n", status);
 
-	if(!res) {
+	if(res <= 0) {
 		if (priority_jump || ast_opt_priority_jumping) {
 			ast_goto_if_exists(chan, chan->context, chan->exten, chan->priority + 101);
+			res = 0;
 		} else {
 			res = -1;
 		}
-	} else if (res > 0) {
+	} else {
 		res = 0;
 	}
 
 	LOCAL_USER_REMOVE(u);
 
-	return(res);
-}
-
-static int osplookup_exec(struct ast_channel *chan, void *data)
-{
-	int res = 0;
+	return res;
+}
+
+/*!
+ * \brief OSP Application OSPLookup
+ * \param chan Channel
+ * \param data Parameter
+ * \return 0 Success, -1 Failed
+ */
+static int osplookup_exec(struct ast_channel* chan, void* data)
+{
+	int res, cres;
 	struct localuser* u;
-	char* provider = OSP_DEF_PROVIDER;
+	const char* provider = OSP_DEF_PROVIDER;
 	int priority_jump = 0;
 	struct varshead* headp;
 	struct ast_var_t* current;
 	const char* srcdev = "";
+	char buffer[OSP_TOKSTR_SIZE];
+	struct osp_result result;
+	const char* status;
 	char* tmp;
-	char buffer[OSP_TOKSTR_SIZE];
-	struct ast_osp_result result;
-	char* status;
 
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(exten);
@@ -223,12 +1093,16 @@
 	
 	if (ast_strlen_zero(data)) {
 		ast_log(LOG_WARNING, "OSPLookup: Arg required, OSPLookup(exten[|provider[|options]])\n");
-		return(-1);
+		return -1;
 	}
 
 	LOCAL_USER_ADD(u);
 

[... 1317 lines stripped ...]


More information about the svn-commits mailing list