Initial commit
Change-Id: I6a4444e3c193dae437cd7929f4c39aba7b749efa
diff --git a/libfdcore/messages.c b/libfdcore/messages.c
new file mode 100644
index 0000000..2242827
--- /dev/null
+++ b/libfdcore/messages.c
@@ -0,0 +1,452 @@
+/*********************************************************************************************************
+* Software License Agreement (BSD License) *
+* Author: Sebastien Decugis <sdecugis@freediameter.net> *
+* *
+* Copyright (c) 2015, 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. *
+*********************************************************************************************************/
+
+#include "fdcore-internal.h"
+
+static struct dict_object * dict_avp_SI = NULL; /* Session-Id */
+static struct dict_object * dict_avp_OH = NULL; /* Origin-Host */
+static struct dict_object * dict_avp_OR = NULL; /* Origin-Realm */
+static struct dict_object * dict_avp_EM = NULL; /* Error-Message */
+static struct dict_object * dict_avp_ERH = NULL; /* Error-Reporting-Host */
+static struct dict_object * dict_avp_FAVP= NULL; /* Failed-AVP */
+static struct dict_object * dict_avp_RC = NULL; /* Result-Code */
+struct dict_object * fd_dict_avp_OSI = NULL; /* Origin-State-Id */
+struct dict_object * fd_dict_cmd_CER = NULL; /* Capabilities-Exchange-Request */
+struct dict_object * fd_dict_cmd_DWR = NULL; /* Device-Watchdog-Request */
+struct dict_object * fd_dict_avp_DC = NULL; /* Disconnect-Cause */
+struct dict_object * fd_dict_cmd_DPR = NULL; /* Disconnect-Peer-Request */
+
+/* Resolve the dictionary objects */
+int fd_msg_init(void)
+{
+ TRACE_ENTRY("");
+
+ /* Initialize the dictionary objects that we may use frequently */
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Session-Id", &dict_avp_SI , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Origin-Host", &dict_avp_OH , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Origin-Realm", &dict_avp_OR , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Origin-State-Id", &fd_dict_avp_OSI , ENOENT) );
+
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Result-Code", &dict_avp_RC , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Error-Message", &dict_avp_EM , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Error-Reporting-Host", &dict_avp_ERH , ENOENT) );
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Failed-AVP", &dict_avp_FAVP, ENOENT) );
+
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Disconnect-Cause", &fd_dict_avp_DC , ENOENT) );
+
+ CHECK_FCT( fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &fd_dict_cmd_CER, ENOENT ) );
+ CHECK_FCT( fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request", &fd_dict_cmd_DWR, ENOENT ) );
+ CHECK_FCT( fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Disconnect-Peer-Request", &fd_dict_cmd_DPR, ENOENT ) );
+
+
+ return 0;
+}
+
+/* Add Origin-Host, Origin-Realm, Origin-State-Id AVPS at the end of the message */
+int fd_msg_add_origin ( struct msg * msg, int osi )
+{
+ union avp_value val;
+ struct avp * avp_OH = NULL;
+ struct avp * avp_OR = NULL;
+ struct avp * avp_OSI = NULL;
+
+ TRACE_ENTRY("%p", msg);
+ CHECK_PARAMS( msg );
+
+ /* Create the Origin-Host AVP */
+ CHECK_FCT( fd_msg_avp_new( dict_avp_OH, 0, &avp_OH ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.os.data = (os0_t)fd_g_config->cnf_diamid;
+ val.os.len = fd_g_config->cnf_diamid_len;
+ CHECK_FCT( fd_msg_avp_setvalue( avp_OH, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_OH ) );
+
+
+ /* Create the Origin-Realm AVP */
+ CHECK_FCT( fd_msg_avp_new( dict_avp_OR, 0, &avp_OR ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.os.data = (os0_t)fd_g_config->cnf_diamrlm;
+ val.os.len = fd_g_config->cnf_diamrlm_len;
+ CHECK_FCT( fd_msg_avp_setvalue( avp_OR, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_OR ) );
+
+ if (osi) {
+ /* Create the Origin-State-Id AVP */
+ CHECK_FCT( fd_msg_avp_new( fd_dict_avp_OSI, 0, &avp_OSI ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.u32 = fd_g_config->cnf_orstateid;
+ CHECK_FCT( fd_msg_avp_setvalue( avp_OSI, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_OSI ) );
+ }
+
+ return 0;
+}
+
+/* Create a new Session-Id and add at the beginning of the message. */
+int fd_msg_new_session( struct msg * msg, os0_t opt, size_t optlen )
+{
+ union avp_value val;
+ struct avp * avp = NULL;
+ struct session * sess = NULL;
+ os0_t sid;
+ size_t sidlen;
+
+ TRACE_ENTRY("%p %p %zd", msg, opt, optlen);
+ CHECK_PARAMS( msg );
+
+ /* Check there is not already a session in the message */
+ CHECK_FCT( fd_msg_sess_get(fd_g_config->cnf_dict, msg, &sess, NULL) );
+ CHECK_PARAMS( sess == NULL );
+
+ /* Ok, now create the session */
+ CHECK_FCT( fd_sess_new ( &sess, fd_g_config->cnf_diamid, fd_g_config->cnf_diamid_len, opt, optlen ) );
+ CHECK_FCT( fd_sess_getsid( sess, &sid, &sidlen) );
+
+ /* Create an AVP to hold it */
+ CHECK_FCT( fd_msg_avp_new( dict_avp_SI, 0, &avp ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.os.data = sid;
+ val.os.len = sidlen;
+ CHECK_FCT( fd_msg_avp_setvalue( avp, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_FIRST_CHILD, avp ) );
+
+ /* Save the session associated with the message */
+ CHECK_FCT( fd_msg_sess_set( msg, sess) );
+
+ /* Done! */
+ return 0;
+}
+
+
+/* Add Result-Code and eventually Failed-AVP, Error-Message and Error-Reporting-Host AVPs */
+int fd_msg_rescode_set( struct msg * msg, char * rescode, char * errormsg, struct avp * optavp, int type_id )
+{
+ union avp_value val;
+ struct avp * avp_RC = NULL;
+ struct avp * avp_EM = NULL;
+ struct avp * avp_ERH = NULL;
+ struct avp * avp_FAVP= NULL;
+ uint32_t rc_val = 0;
+ int set_e_bit=0;
+ int std_err_msg=0;
+
+ TRACE_ENTRY("%p %s %p %p %d", msg, rescode, errormsg, optavp, type_id);
+
+ CHECK_PARAMS( msg && rescode );
+
+ /* Find the enum value corresponding to the rescode string, this will give the class of error */
+ {
+ struct dict_object * enum_obj = NULL;
+ struct dict_enumval_request req;
+ memset(&req, 0, sizeof(struct dict_enumval_request));
+
+ /* First, get the enumerated type of the Result-Code AVP (this is fast, no need to cache the object) */
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, dict_avp_RC, &(req.type_obj), ENOENT ) );
+
+ /* Now search for the value given as parameter */
+ req.search.enum_name = rescode;
+ CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &req, &enum_obj, ENOTSUP) );
+
+ /* finally retrieve its data */
+ CHECK_FCT_DO( fd_dict_getval( enum_obj, &(req.search) ), return EINVAL );
+
+ /* copy the found value, we're done */
+ rc_val = req.search.enum_value.u32;
+ }
+
+ if (type_id == 1) {
+ /* Add the Origin-Host and Origin-Realm AVP */
+ CHECK_FCT( fd_msg_add_origin ( msg, 0 ) );
+ }
+
+ /* Create the Result-Code AVP */
+ CHECK_FCT( fd_msg_avp_new( dict_avp_RC, 0, &avp_RC ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.u32 = rc_val;
+ CHECK_FCT( fd_msg_avp_setvalue( avp_RC, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_RC ) );
+
+ if (type_id == 2) {
+ /* Add the Error-Reporting-Host AVP */
+
+ CHECK_FCT( fd_msg_avp_new( dict_avp_ERH, 0, &avp_ERH ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+ val.os.data = (uint8_t *)fd_g_config->cnf_diamid;
+ val.os.len = fd_g_config->cnf_diamid_len;
+ CHECK_FCT( fd_msg_avp_setvalue( avp_ERH, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_ERH ) );
+
+ }
+
+ /* Now add the optavp in a FailedAVP if provided */
+ if (optavp) {
+ struct avp * optavp_cpy = NULL;
+ struct avp_hdr *opt_hdr, *optcpy_hdr;
+ struct dict_object * opt_model = NULL;
+ int is_grouped = 0;
+
+ /* Create the Failed-AVP AVP */
+ CHECK_FCT( fd_msg_avp_new( dict_avp_FAVP, 0, &avp_FAVP ) );
+
+ /* Was this AVP a grouped one? Best effort only here */
+ if (!fd_msg_model ( optavp, &opt_model ) && (opt_model != NULL)) {
+ struct dict_avp_data dictdata;
+ CHECK_FCT( fd_dict_getval(opt_model, &dictdata) );
+ if (dictdata.avp_basetype == AVP_TYPE_GROUPED)
+ is_grouped = 1;
+ }
+
+ /* Create a new AVP with a copy of the data of the invalid or missing AVP */
+ optavp_cpy = optavp;
+
+ if (is_grouped) {
+ CHECK_FCT( fd_msg_avp_new( opt_model, 0, &optavp_cpy) );
+ } else {
+ CHECK_FCT( fd_msg_avp_new( NULL, AVPFL_SET_BLANK_VALUE | AVPFL_SET_RAWDATA_FROM_AVP, &optavp_cpy) );
+
+ CHECK_FCT( fd_msg_avp_hdr(optavp, &opt_hdr) );
+ CHECK_FCT( fd_msg_avp_hdr(optavp_cpy, &optcpy_hdr) );
+ memcpy(optcpy_hdr, opt_hdr, sizeof(struct avp_hdr));
+ }
+
+ /* Add the passed AVP inside it */
+ CHECK_FCT( fd_msg_avp_add( avp_FAVP, MSG_BRW_LAST_CHILD, optavp_cpy ) );
+
+ /* And add to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_FAVP ) );
+ }
+
+
+ /* Deal with the 'E' bit and the error message */
+ switch (rc_val / 1000) {
+ case 1: /* Informational */
+ case 2: /* Success */
+ /* Nothing special here: no E bit, no error message unless one is specified */
+ break;
+
+ case 3: /* Protocol Errors */
+ set_e_bit = 1;
+ std_err_msg = 1;
+ break;
+
+ case 4: /* Transcient Failure */
+ case 5: /* Permanent Failure */
+ default:
+ std_err_msg = 1;
+ break;
+
+ }
+
+ {
+ struct msg_hdr * hdr = NULL;
+
+ CHECK_FCT( fd_msg_hdr( msg, &hdr ) );
+
+ if (set_e_bit)
+ hdr->msg_flags |= CMD_FLAG_ERROR;
+ else
+ hdr->msg_flags &= ~ CMD_FLAG_ERROR;
+ }
+
+ if (std_err_msg || errormsg) {
+ /* Add the Error-Message AVP */
+
+ CHECK_FCT( fd_msg_avp_new( dict_avp_EM, 0, &avp_EM ) );
+
+ /* Set its value */
+ memset(&val, 0, sizeof(val));
+
+ if (errormsg) {
+ val.os.data = (uint8_t *)errormsg;
+ val.os.len = strlen(errormsg);
+ } else {
+ val.os.data = (uint8_t *)rescode;
+ val.os.len = strlen(rescode);
+ }
+ CHECK_FCT( fd_msg_avp_setvalue( avp_EM, &val ) );
+
+ /* Add it to the message */
+ CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp_EM ) );
+ }
+
+ return 0;
+}
+
+static int fd_msg_send_int( struct msg ** pmsg, void (*anscb)(void *, struct msg **), void * data, void (*expirecb)(void *, DiamId_t, size_t, struct msg **), const struct timespec *timeout )
+{
+ struct msg_hdr *hdr;
+ DiamId_t diamid;
+
+ /* Save the callback in the message, with the timeout */
+ CHECK_FCT( fd_msg_anscb_associate( *pmsg, anscb, data, expirecb, timeout ) );
+
+ /* If this is a new request, call the HOOK_MESSAGE_LOCAL hook */
+ if ( (fd_msg_hdr(*pmsg, &hdr) == 0)
+ && (hdr->msg_flags & CMD_FLAG_REQUEST)
+ && (fd_msg_source_get(*pmsg, &diamid, NULL) == 0)
+ && (diamid == NULL)) {
+ fd_hook_call(HOOK_MESSAGE_LOCAL, *pmsg, NULL, NULL, fd_msg_pmdl_get(*pmsg));
+ }
+
+ /* Post the message in the outgoing queue */
+ CHECK_FCT( fd_fifo_post(fd_g_outgoing, pmsg) );
+
+ return 0;
+}
+
+/* Send a message and optionally register a callback for an answer */
+int fd_msg_send ( struct msg ** pmsg, void (*anscb)(void *, struct msg **), void * data )
+{
+ TRACE_ENTRY("%p %p %p", pmsg, anscb, data);
+ CHECK_PARAMS( pmsg );
+
+ return fd_msg_send_int(pmsg, anscb, data, NULL, NULL);
+}
+
+/* The variation of the same function with a timeout callback */
+int fd_msg_send_timeout ( struct msg ** pmsg, void (*anscb)(void *, struct msg **), void * data, void (*expirecb)(void *, DiamId_t, size_t, struct msg **), const struct timespec *timeout )
+{
+ TRACE_ENTRY("%p %p %p %p %p", pmsg, anscb, data, expirecb, timeout);
+ CHECK_PARAMS( pmsg && expirecb && timeout );
+
+ return fd_msg_send_int(pmsg, anscb, data, expirecb, timeout);
+}
+
+
+/* Parse a message against our dictionary, and in case of error log and eventually build the error reply -- returns the parsing status */
+int fd_msg_parse_or_error( struct msg ** msg, struct msg **error)
+{
+ int ret = 0;
+ struct msg * m;
+ struct msg_hdr * hdr = NULL;
+ struct fd_pei pei;
+
+ TRACE_ENTRY("%p", msg);
+
+ CHECK_PARAMS(msg && *msg && error);
+ m = *msg;
+ *error = NULL;
+
+ /* Parse the message against our dictionary */
+ ret = fd_msg_parse_rules ( m, fd_g_config->cnf_dict, &pei);
+ if ((ret != EBADMSG) /* Parsing grouped AVP failed / Conflicting rule found */
+ && (ret != ENOTSUP)) /* Command is not supported / Mandatory AVP is not supported */
+ return ret; /* 0 or another error */
+
+ /* Log */
+ fd_hook_call(HOOK_MESSAGE_PARSING_ERROR, m, NULL, pei.pei_message ?: pei.pei_errcode, fd_msg_pmdl_get(m));
+
+ CHECK_FCT( fd_msg_hdr(m, &hdr) );
+
+ /* Now create an answer error if the message is a query */
+ if (hdr->msg_flags & CMD_FLAG_REQUEST) {
+
+ /* Create the error message */
+ CHECK_FCT( fd_msg_new_answer_from_req ( fd_g_config->cnf_dict, &m, pei.pei_protoerr ? MSGFL_ANSW_ERROR : 0 ) );
+
+ /* Set the error code */
+ CHECK_FCT( fd_msg_rescode_set(m, pei.pei_errcode, pei.pei_message, pei.pei_avp, 1 ) );
+
+ /* free the pei AVP to avoid memory leak */
+ if (pei.pei_avp_free) {
+ fd_msg_free(pei.pei_avp);
+ }
+
+ *msg = NULL;
+ *error = m;
+
+ } else {
+ do { /* Rescue error messages */
+ struct avp * avp;
+ union avp_value * rc = NULL;
+
+ /* Search the Result-Code AVP */
+ CHECK_FCT_DO( fd_msg_browse(*msg, MSG_BRW_FIRST_CHILD, &avp, NULL), break );
+ while (avp) {
+ struct avp_hdr * ahdr;
+ CHECK_FCT_DO( fd_msg_avp_hdr( avp, &ahdr ), break );
+
+ if ((ahdr->avp_code == AC_RESULT_CODE) && (! (ahdr->avp_flags & AVP_FLAG_VENDOR)) ) {
+ /* Parse this AVP */
+ ASSERT( ahdr->avp_value );
+ rc = ahdr->avp_value;
+ break;
+ }
+
+ /* Go to next AVP */
+ CHECK_FCT_DO( fd_msg_browse(avp, MSG_BRW_NEXT, &avp, NULL), break );
+ }
+
+ if (rc) {
+ switch (rc->u32 / 1000) {
+ case 1: /* 1xxx : Informational */
+ case 2: /* 2xxx : Sucess */
+ /* In these cases, we want the message to validate the ABNF, so we will discard the bad message */
+ break;
+
+ default: /* Other errors */
+ /* We let the application decide what to do with the message, we rescue it */
+ *error = m;
+ }
+ }
+ } while (0);
+ }
+
+ return EBADMSG; /* We convert ENOTSUP to EBADMSG as well */
+}