aoc.c

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2010, Digium, Inc.
 *
 * David Vossel <dvossel@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*!
 * \file
 * \brief generic AOC payload generation encoding and decoding
 *
 * \author David Vossel <dvossel@digium.com>
 */

/*** MODULEINFO
	<support_level>core</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/aoc.h"
#include "asterisk/utils.h"
#include "asterisk/strings.h"
#include "asterisk/_private.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_message_router.h"

/*** DOCUMENTATION
	<managerEvent language="en_US" name="AOC-S">
		<managerEventInstance class="EVENT_FLAG_AOC">
			<synopsis>Raised when an Advice of Charge message is sent at the beginning of a call.</synopsis>
			<syntax>
				<channel_snapshot/>
				<parameter name="Chargeable" />
				<parameter name="RateType">
					<enumlist>
						<enum name="NotAvailable" />
						<enum name="Free" />
						<enum name="FreeFromBeginning" />
						<enum name="Duration" />
						<enum name="Flag" />
						<enum name="Volume" />
						<enum name="SpecialCode" />
					</enumlist>
				</parameter>
				<parameter name="Currency" />
				<parameter name="Name" />
				<parameter name="Cost" />
				<parameter name="Multiplier">
					<enumlist>
						<enum name="1/1000" />
						<enum name="1/100" />
						<enum name="1/10" />
						<enum name="1" />
						<enum name="10" />
						<enum name="100" />
						<enum name="1000" />
					</enumlist>
				</parameter>
				<parameter name="ChargingType" />
				<parameter name="StepFunction" />
				<parameter name="Granularity" />
				<parameter name="Length" />
				<parameter name="Scale" />
				<parameter name="Unit">
					<enumlist>
						<enum name="Octect" />
						<enum name="Segment" />
						<enum name="Message" />
					</enumlist>
				</parameter>
				<parameter name="SpecialCode" />
			</syntax>
			<see-also>
				<ref type="managerEvent">AOC-D</ref>
				<ref type="managerEvent">AOC-E</ref>
			</see-also>
		</managerEventInstance>
	</managerEvent>
	<managerEvent language="en_US" name="AOC-D">
		<managerEventInstance class="EVENT_FLAG_AOC">
			<synopsis>Raised when an Advice of Charge message is sent during a call.</synopsis>
			<syntax>
				<channel_snapshot/>
				<parameter name="Charge" />
				<parameter name="Type">
					<enumlist>
						<enum name="NotAvailable" />
						<enum name="Free" />
						<enum name="Currency" />
						<enum name="Units" />
					</enumlist>
				</parameter>
				<parameter name="BillingID">
					<enumlist>
						<enum name="Normal" />
						<enum name="Reverse" />
						<enum name="CreditCard" />
						<enum name="CallForwardingUnconditional" />
						<enum name="CallForwardingBusy" />
						<enum name="CallForwardingNoReply" />
						<enum name="CallDeflection" />
						<enum name="CallTransfer" />
						<enum name="NotAvailable" />
					</enumlist>
				</parameter>
				<parameter name="TotalType">
					<enumlist>
						<enum name="SubTotal" />
						<enum name="Total" />
					</enumlist>
				</parameter>
				<parameter name="Currency" />
				<parameter name="Name" />
				<parameter name="Cost" />
				<parameter name="Multiplier">
					<enumlist>
						<enum name="1/1000" />
						<enum name="1/100" />
						<enum name="1/10" />
						<enum name="1" />
						<enum name="10" />
						<enum name="100" />
						<enum name="1000" />
					</enumlist>
				</parameter>
				<parameter name="Units" />
				<parameter name="NumberOf" />
				<parameter name="TypeOf" />
			</syntax>
			<see-also>
				<ref type="manager">AOCMessage</ref>
				<ref type="managerEvent">AOC-S</ref>
				<ref type="managerEvent">AOC-E</ref>
			</see-also>
		</managerEventInstance>
	</managerEvent>
	<managerEvent language="en_US" name="AOC-E">
		<managerEventInstance class="EVENT_FLAG_AOC">
			<synopsis>Raised when an Advice of Charge message is sent at the end of a call.</synopsis>
			<syntax>
				<channel_snapshot/>
				<parameter name="ChargingAssociation" />
				<parameter name="Number" />
				<parameter name="Plan" />
				<parameter name="ID" />
				<xi:include xpointer="xpointer(/docs/managerEvent[@name='AOC-D']/managerEventInstance/syntax/parameter)" />
			</syntax>
			<see-also>
				<ref type="manager">AOCMessage</ref>
				<ref type="managerEvent">AOC-S</ref>
				<ref type="managerEvent">AOC-D</ref>
			</see-also>
		</managerEventInstance>
	</managerEvent>
***/

/* Encoded Payload Flags */
#define AST_AOC_ENCODED_TYPE_REQUEST    (0 << 0)
#define AST_AOC_ENCODED_TYPE_D          (1 << 0)
#define AST_AOC_ENCODED_TYPE_E          (2 << 0)
#define AST_AOC_ENCODED_TYPE_S          (3 << 0)

#define AST_AOC_ENCODED_REQUEST_S       (1 << 2)
#define AST_AOC_ENCODED_REQUEST_D       (1 << 3)
#define AST_AOC_ENCODED_REQUEST_E       (1 << 4)

#define AST_AOC_ENCODED_CHARGE_NA       (0 << 5)
#define AST_AOC_ENCODED_CHARGE_FREE     (1 << 5)
#define AST_AOC_ENCODED_CHARGE_CURRENCY (2 << 5)
#define AST_AOC_ENCODED_CHARGE_UNIT     (3 << 5)

#define AST_AOC_ENCODED_CHARGE_SUBTOTAL (1 << 7)
#define AST_AOC_ENCODED_CHARGE_TOTAL    (0 << 7)

#define AST_AOC_ENCODE_VERSION 1


static char aoc_debug_enabled = 0;
static void aoc_display_decoded_debug(const struct ast_aoc_decoded *decoded, int decoding, struct ast_channel *chan);
static int aoc_s_add_entry(struct ast_aoc_decoded *decoded, struct ast_aoc_s_entry *entry);

/* AOC Payload Header. Holds all the encoded AOC data to pass on the wire */
struct ast_aoc_encoded {
	uint8_t  version;
	uint8_t  flags;
	uint16_t datalen;
	unsigned char data[0];
};

/* Decoded AOC data */
struct ast_aoc_decoded {
	enum ast_aoc_type msg_type;
	enum ast_aoc_charge_type charge_type;
	enum ast_aoc_request request_flag;
	enum ast_aoc_total_type total_type;

	/* currency information */
	enum ast_aoc_currency_multiplier multiplier;
	unsigned int currency_amount;
	char currency_name[AOC_CURRENCY_NAME_SIZE];

	/* unit information */
	int unit_count;
	struct ast_aoc_unit_entry unit_list[32];

	/* Billing Id */
	enum ast_aoc_billing_id billing_id;

	/* Charging Association information */
	struct ast_aoc_charging_association charging_association;

	/* AOC-S charge information */
	int aoc_s_count;
	struct ast_aoc_s_entry aoc_s_entries[10];

	/* Is this an AOC Termination Request */
	char termination_request;
};

/*! \brief AOC Payload Information Elements */
enum AOC_IE {
	AOC_IE_CURRENCY = 1,
	AOC_IE_UNIT = 2,
	AOC_IE_BILLING = 3,
	AOC_IE_CHARGING_ASSOCIATION = 4,
	AOC_IE_RATE = 5,
	AOC_IE_TERMINATION_REQUEST = 6,
};

/*! \brief AOC IE payload header */
struct aoc_pl_ie_hdr {
	uint8_t ie_id;
	uint8_t datalen;
	char data[0];
} __attribute__((packed));

struct aoc_ie_currency {
	uint32_t amount;
	uint8_t  multiplier;
	char name[AOC_CURRENCY_NAME_SIZE];
} __attribute__((packed));

struct aoc_ie_unit {
	uint32_t amount;
	uint8_t valid_type;
	uint8_t valid_amount;
	uint8_t type;
} __attribute__((packed));

struct aoc_ie_billing {
	uint8_t id;
} __attribute__((packed));

struct aoc_ie_charging_association {
	struct ast_aoc_charging_association ca;
} __attribute__((packed));

struct aoc_ie_charging_rate {
	struct ast_aoc_s_entry entry;
} __attribute__((packed));

struct ast_aoc_decoded *ast_aoc_create(const enum ast_aoc_type msg_type,
		const enum ast_aoc_charge_type charge_type,
		const enum ast_aoc_request requests)
{
	struct ast_aoc_decoded *decoded = NULL;

	/* verify input */
	if (((unsigned int) charge_type > AST_AOC_CHARGE_UNIT) ||
		((unsigned int) msg_type > AST_AOC_E) ||
		((msg_type == AST_AOC_REQUEST) && !requests)) {

		ast_log(LOG_WARNING, "Failed to create ast_aoc_decoded object, invalid input\n");
		return NULL;
	}

	if (!(decoded = ast_calloc(1, sizeof(struct ast_aoc_decoded)))) {
		ast_log(LOG_WARNING, "Failed to create ast_aoc_decoded object \n");
		return NULL;
	}

	decoded->msg_type = msg_type;

	if (msg_type == AST_AOC_REQUEST) {
		decoded->request_flag = requests;
	} else if ((msg_type == AST_AOC_D) || (msg_type == AST_AOC_E)) {
		decoded->charge_type = charge_type;
	}

	return decoded;
}

void *ast_aoc_destroy_decoded(struct ast_aoc_decoded *decoded)
{
	ast_free(decoded);
	return NULL;
}

void *ast_aoc_destroy_encoded(struct ast_aoc_encoded *encoded)
{
	ast_free(encoded);
	return NULL;
}

static void aoc_parse_ie_charging_rate(struct ast_aoc_decoded *decoded, const struct aoc_ie_charging_rate *ie)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = ntohs(ie->entry.charged_item);
	entry.rate_type = ntohs(ie->entry.rate_type);

	switch (entry.rate_type) {
	case AST_AOC_RATE_TYPE_DURATION:
		entry.rate.duration.multiplier = ntohs(ie->entry.rate.duration.multiplier);
		entry.rate.duration.amount = ntohl(ie->entry.rate.duration.amount);
		entry.rate.duration.time = ntohl(ie->entry.rate.duration.time);
		entry.rate.duration.time_scale = ntohs(ie->entry.rate.duration.time_scale);
		entry.rate.duration.granularity_time = ntohl(ie->entry.rate.duration.granularity_time);
		entry.rate.duration.granularity_time_scale = ntohs(ie->entry.rate.duration.granularity_time_scale);
		entry.rate.duration.charging_type = ie->entry.rate.duration.charging_type; /* only one byte */

		if (!ast_strlen_zero(ie->entry.rate.duration.currency_name)) {
			ast_copy_string(entry.rate.duration.currency_name,
				ie->entry.rate.duration.currency_name,
				sizeof(entry.rate.duration.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_FLAT:
		entry.rate.flat.multiplier = ntohs(ie->entry.rate.flat.multiplier);
		entry.rate.flat.amount = ntohl(ie->entry.rate.flat.amount);
		if (!ast_strlen_zero(ie->entry.rate.flat.currency_name)) {
			ast_copy_string(entry.rate.flat.currency_name,
				ie->entry.rate.flat.currency_name,
				sizeof(entry.rate.flat.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_VOLUME:
		entry.rate.volume.multiplier = ntohs(ie->entry.rate.volume.multiplier);
		entry.rate.volume.amount = ntohl(ie->entry.rate.volume.amount);
		entry.rate.volume.volume_unit = ntohs(ie->entry.rate.volume.volume_unit);
		if (!ast_strlen_zero(ie->entry.rate.volume.currency_name)) {
			ast_copy_string(entry.rate.volume.currency_name,
				ie->entry.rate.volume.currency_name,
				sizeof(entry.rate.volume.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_SPECIAL_CODE:
		entry.rate.special_code = ntohs(ie->entry.rate.special_code);
		break;
	}

	aoc_s_add_entry(decoded, &entry);
}

static int aoc_parse_ie(struct ast_aoc_decoded *decoded, unsigned char *data, unsigned int datalen)
{
	enum AOC_IE ie_id;
	unsigned int len;

	while (datalen >= 2) {
		ie_id = data[0];
		len = data[1];
		if (len > datalen -2) {
			ast_log(LOG_ERROR, "AOC information element length exceeds the total message size\n");
			return -1;
		}

		switch(ie_id) {
		case AOC_IE_CURRENCY:
			if (len == sizeof(struct aoc_ie_currency)) {
				struct aoc_ie_currency ie;
				memcpy(&ie, data + 2, len);
				decoded->currency_amount = ntohl(ie.amount);
				decoded->multiplier = ie.multiplier; /* only one byte */
				memcpy(decoded->currency_name, ie.name, sizeof(decoded->currency_name));
			} else {
				ast_log(LOG_WARNING, "Received invalid currency ie\n");
			}
			break;
		case AOC_IE_UNIT:
			if (len == sizeof(struct aoc_ie_unit)) {
				struct aoc_ie_unit ie;
				memcpy(&ie, data + 2, len);
				ast_aoc_add_unit_entry(decoded, ie.valid_amount, ntohl(ie.amount), ie.valid_type, ie.type);
			} else {
				ast_log(LOG_WARNING, "Received invalid unit ie\n");
			}
			break;
		case AOC_IE_BILLING:
			if (len == sizeof(struct aoc_ie_billing)) {
				struct aoc_ie_billing ie;
				memcpy(&ie, data + 2, len);
				decoded->billing_id = ie.id; /* only one byte */
			} else {
				ast_log(LOG_WARNING, "Received invalid billing ie\n");
			}
			break;
		case AOC_IE_CHARGING_ASSOCIATION:
			if (len == sizeof(struct aoc_ie_charging_association)) {
				memcpy(&decoded->charging_association, data + 2, sizeof(decoded->charging_association));
				/* everything in the charging_association struct is a single byte except for the id */
				if (decoded->charging_association.charging_type == AST_AOC_CHARGING_ASSOCIATION_ID) {
					decoded->charging_association.charge.id = ntohl(decoded->charging_association.charge.id);
				}
			} else {
				ast_log(LOG_WARNING, "Received invalid charging association ie\n");
			}
			break;
		case AOC_IE_RATE:
			if (len == sizeof(struct aoc_ie_charging_rate)) {
				struct aoc_ie_charging_rate ie;
				memcpy(&ie, data + 2, len);
				aoc_parse_ie_charging_rate(decoded, &ie);
			} else {
				ast_log(LOG_WARNING, "Received invalid charging rate ie\n");
			}
			break;
		case AOC_IE_TERMINATION_REQUEST:
			if (len == 0) {
				decoded->termination_request = 1;
			} else {
				ast_log(LOG_WARNING, "Received invalid termination request ie\n");
			}
			break;
		default:
			ast_log(LOG_WARNING, "Unknown AOC Information Element, ignoring.\n");
		}

		datalen -= (len + 2);
		data += (len + 2);
	}
	return 0;
}

struct ast_aoc_decoded *ast_aoc_decode(struct ast_aoc_encoded *encoded, size_t size, struct ast_channel *chan)
{
	struct ast_aoc_decoded *decoded;

	/* verify our encoded payload is actually large enough to hold all the ies */
	if ((size - (sizeof(struct ast_aoc_encoded)) != ntohs(encoded->datalen))) {
		ast_log(LOG_WARNING, "Corrupted aoc encoded object, can not decode\n");
		return NULL;
	}

	if (!(decoded = ast_calloc(1, sizeof(struct ast_aoc_decoded)))) {
		ast_log(LOG_WARNING, "Failed to create ast_aoc_decoded object \n");
		return NULL;
	}

	/* decode flags */

	if ((encoded->flags & AST_AOC_ENCODED_TYPE_S) == AST_AOC_ENCODED_TYPE_S) {
		decoded->msg_type = AST_AOC_S;
	} else if (encoded->flags & AST_AOC_ENCODED_TYPE_E) {
		decoded->msg_type = AST_AOC_E;
	} else if (encoded->flags & AST_AOC_ENCODED_TYPE_D) {
		decoded->msg_type = AST_AOC_D;
	} else {
		decoded->msg_type = AST_AOC_REQUEST;
	}

	if (decoded->msg_type == AST_AOC_REQUEST) {
		if (encoded->flags & AST_AOC_ENCODED_REQUEST_S) {
			decoded->request_flag |= AST_AOC_REQUEST_S;
		}
		if (encoded->flags & AST_AOC_ENCODED_REQUEST_D) {
			decoded->request_flag |= AST_AOC_REQUEST_D;
		}
		if (encoded->flags & AST_AOC_ENCODED_REQUEST_E) {
			decoded->request_flag |= AST_AOC_REQUEST_E;
		}
	} else if ((decoded->msg_type == AST_AOC_D) || (decoded->msg_type == AST_AOC_E)) {
		if ((encoded->flags & AST_AOC_ENCODED_CHARGE_UNIT) == AST_AOC_ENCODED_CHARGE_UNIT) {
			decoded->charge_type = AST_AOC_CHARGE_UNIT;
		} else if ((encoded->flags & AST_AOC_ENCODED_CHARGE_CURRENCY) == AST_AOC_ENCODED_CHARGE_CURRENCY) {
			decoded->charge_type = AST_AOC_CHARGE_CURRENCY;
		} else if ((encoded->flags & AST_AOC_ENCODED_CHARGE_FREE) == AST_AOC_ENCODED_CHARGE_FREE) {
			decoded->charge_type = AST_AOC_CHARGE_FREE;
		} else {
			decoded->charge_type = AST_AOC_CHARGE_NA;
		}

		if (encoded->flags & AST_AOC_ENCODED_CHARGE_SUBTOTAL) {
			decoded->total_type = AST_AOC_SUBTOTAL;
		}
	}

	/* decode information elements */
	aoc_parse_ie(decoded, encoded->data, ntohs(encoded->datalen));

	if (aoc_debug_enabled) {
		aoc_display_decoded_debug(decoded, 1, chan);
	}

	return decoded;
}

struct aoc_ie_data {
	unsigned char buf[1024];
	int pos;
};

/*!
 * \internal
 * \brief append an AOC information element
 * \note data is expected to already be in network byte order at this point
 */
static int aoc_append_ie(struct aoc_ie_data *ied, unsigned short ie_id, const void *data, unsigned short datalen)
{
	if (datalen > ((int)sizeof(ied->buf) - ied->pos)) {
		ast_log(LOG_WARNING, "Failure to append AOC information element, out of space \n");
		return -1;
	}
	ied->buf[ied->pos++] = ie_id;
	ied->buf[ied->pos++] = datalen;
	if (datalen) {
		memcpy(ied->buf + ied->pos, data, datalen);
		ied->pos += datalen;
	}
	return 0;
}

static void aoc_create_ie_data_charging_rate(const struct ast_aoc_s_entry *entry, struct aoc_ie_charging_rate *ie)
{
	ie->entry.charged_item = htons(entry->charged_item);
	ie->entry.rate_type = htons(entry->rate_type);

	switch (entry->rate_type) {
	case AST_AOC_RATE_TYPE_DURATION:
		ie->entry.rate.duration.multiplier = htons(entry->rate.duration.multiplier);
		ie->entry.rate.duration.amount = htonl(entry->rate.duration.amount);
		ie->entry.rate.duration.time = htonl(entry->rate.duration.time);
		ie->entry.rate.duration.time_scale = htons(entry->rate.duration.time_scale);
		ie->entry.rate.duration.granularity_time = htonl(entry->rate.duration.granularity_time);
		ie->entry.rate.duration.granularity_time_scale = htons(entry->rate.duration.granularity_time_scale);
		ie->entry.rate.duration.charging_type = entry->rate.duration.charging_type; /* only one byte */

		if (!ast_strlen_zero(entry->rate.duration.currency_name)) {
			ast_copy_string(ie->entry.rate.duration.currency_name,
				entry->rate.duration.currency_name,
				sizeof(ie->entry.rate.duration.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_FLAT:
		ie->entry.rate.flat.multiplier = htons(entry->rate.flat.multiplier);
		ie->entry.rate.flat.amount = htonl(entry->rate.flat.amount);
		if (!ast_strlen_zero(entry->rate.flat.currency_name)) {
			ast_copy_string(ie->entry.rate.flat.currency_name,
				entry->rate.flat.currency_name,
				sizeof(ie->entry.rate.flat.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_VOLUME:
		ie->entry.rate.volume.multiplier = htons(entry->rate.volume.multiplier);
		ie->entry.rate.volume.amount = htonl(entry->rate.volume.amount);
		ie->entry.rate.volume.volume_unit = htons(entry->rate.volume.volume_unit);
		if (!ast_strlen_zero(entry->rate.volume.currency_name)) {
			ast_copy_string(ie->entry.rate.volume.currency_name,
				entry->rate.volume.currency_name,
				sizeof(ie->entry.rate.volume.currency_name));
		}
		break;
	case AST_AOC_RATE_TYPE_SPECIAL_CODE:
		ie->entry.rate.special_code = htons(entry->rate.special_code);
		break;
	}

}
static void aoc_create_ie_data(struct ast_aoc_decoded *decoded, struct aoc_ie_data *ied)
{
	ied->pos = 0;

	if (decoded->currency_amount) {
		struct aoc_ie_currency ie = {
			.amount = htonl(decoded->currency_amount),
			.multiplier = decoded->multiplier, /* only one byte */
			.name = { 0, },
		};

		if (!ast_strlen_zero(decoded->currency_name)) {
			ast_copy_string(ie.name, decoded->currency_name, sizeof(ie.name));
		}

		aoc_append_ie(ied, AOC_IE_CURRENCY, (const void *) &ie, sizeof(ie));
	}

	if (decoded->unit_count) {
		struct aoc_ie_unit ie = { 0 };
		int i;

		for (i = 0; i < decoded->unit_count; i++) {
			ie.valid_amount = decoded->unit_list[i].valid_amount; /* only one byte */
			ie.amount = htonl(decoded->unit_list[i].amount);
			ie.valid_type = decoded->unit_list[i].valid_type; /* only one byte */
			ie.type = decoded->unit_list[i].type; /* only one byte */
			aoc_append_ie(ied, AOC_IE_UNIT, (const void *) &ie, sizeof(ie));
		}
	}

	if (decoded->billing_id) {
		struct aoc_ie_billing ie;
		ie.id = decoded->billing_id; /* only one byte */
		aoc_append_ie(ied, AOC_IE_BILLING, (const void *) &ie, sizeof(ie));
	}

	if (decoded->charging_association.charging_type != AST_AOC_CHARGING_ASSOCIATION_NA) {
		struct aoc_ie_charging_association ie;
		memset(&ie, 0, sizeof(ie));
		ie.ca.charging_type = decoded->charging_association.charging_type;   /* only one byte */
		if (decoded->charging_association.charging_type == AST_AOC_CHARGING_ASSOCIATION_NUMBER) {
			ie.ca.charge.number.plan = decoded->charging_association.charge.number.plan; /* only one byte */
			ast_copy_string(ie.ca.charge.number.number,
				decoded->charging_association.charge.number.number,
				sizeof(ie.ca.charge.number.number));
		} else if (decoded->charging_association.charging_type == AST_AOC_CHARGING_ASSOCIATION_ID) {
			ie.ca.charge.id = htonl(decoded->charging_association.charge.id);
		}
		aoc_append_ie(ied, AOC_IE_CHARGING_ASSOCIATION, (const void *) &ie, sizeof(ie));
	}

	if (decoded->aoc_s_count) {
		struct aoc_ie_charging_rate ie;
		int i;
		for (i = 0; i < decoded->aoc_s_count; i++) {
			memset(&ie, 0, sizeof(ie));
			aoc_create_ie_data_charging_rate(&decoded->aoc_s_entries[i], &ie);
			aoc_append_ie(ied, AOC_IE_RATE, (const void *) &ie, sizeof(ie));
		}
	}

	if (decoded->termination_request) {
		aoc_append_ie(ied, AOC_IE_TERMINATION_REQUEST, NULL, 0);
	}
}

struct ast_aoc_encoded *ast_aoc_encode(struct ast_aoc_decoded *decoded, size_t *out_size, struct ast_channel *chan)
{
	struct aoc_ie_data ied;
	struct ast_aoc_encoded *encoded = NULL;
	size_t size = 0;

	if (!decoded || !out_size) {
		return NULL;
	}

	*out_size = 0;

	/* create information element buffer before allocating the payload,
	 * by doing this the exact size of the payload + the id data can be
	 * allocated all at once. */
	aoc_create_ie_data(decoded, &ied);

	size = sizeof(struct ast_aoc_encoded) + ied.pos;

	if (!(encoded = ast_calloc(1, size))) {
		ast_log(LOG_WARNING, "Failed to create ast_aoc_encoded object during decode routine. \n");
		return NULL;
	}

	/* -- Set ie data buffer */
	if (ied.pos) {
		/* this is safe because encoded was allocated to fit this perfectly */
		memcpy(encoded->data, ied.buf, ied.pos);
		encoded->datalen = htons(ied.pos);
	}

	/* --- Set Flags --- */
	switch (decoded->msg_type) {
	case AST_AOC_S:
		encoded->flags = AST_AOC_ENCODED_TYPE_S;
		break;
	case AST_AOC_D:
		encoded->flags = AST_AOC_ENCODED_TYPE_D;
		break;
	case AST_AOC_E:
		encoded->flags = AST_AOC_ENCODED_TYPE_E;
		break;
	case AST_AOC_REQUEST:
		encoded->flags = AST_AOC_ENCODED_TYPE_REQUEST;
	default:
		break;
	}

	/* if it is type request, set the types requested, else set charge type */
	if (decoded->msg_type == AST_AOC_REQUEST) {
		if (decoded->request_flag & AST_AOC_REQUEST_S) {
			encoded->flags |= AST_AOC_ENCODED_REQUEST_S;
		}
		if (decoded->request_flag & AST_AOC_REQUEST_D) {
			encoded->flags |= AST_AOC_ENCODED_REQUEST_D;
		}
		if (decoded->request_flag & AST_AOC_REQUEST_E) {
			encoded->flags |= AST_AOC_ENCODED_REQUEST_E;
		}
	} else if ((decoded->msg_type == AST_AOC_D) || (decoded->msg_type == AST_AOC_E)) {
		switch (decoded->charge_type) {
		case AST_AOC_CHARGE_UNIT:
			encoded->flags |= AST_AOC_ENCODED_CHARGE_UNIT;
			break;
		case AST_AOC_CHARGE_CURRENCY:
			encoded->flags |= AST_AOC_ENCODED_CHARGE_CURRENCY;
			break;
		case AST_AOC_CHARGE_FREE:
			encoded->flags |= AST_AOC_ENCODED_CHARGE_FREE;
		case AST_AOC_CHARGE_NA:
		default:
			encoded->flags |= AST_AOC_ENCODED_CHARGE_NA;
			break;
		}

		if (decoded->total_type == AST_AOC_SUBTOTAL) {
			encoded->flags |= AST_AOC_ENCODED_CHARGE_SUBTOTAL;
		}
	}

	/* --- Set Version Number --- */
	encoded->version = AST_AOC_ENCODE_VERSION;

	/* set the output size  */
	*out_size = size;

	if (aoc_debug_enabled) {
		aoc_display_decoded_debug(decoded, 0, chan);
	}

	return encoded;
}

static int aoc_s_add_entry(struct ast_aoc_decoded *decoded, struct ast_aoc_s_entry *entry)
{
	if (decoded->aoc_s_count >= ARRAY_LEN(decoded->aoc_s_entries)) {
		return -1;
	}

	decoded->aoc_s_entries[decoded->aoc_s_count] = *entry;
	decoded->aoc_s_count++;

	return 0;
}


unsigned int ast_aoc_s_get_count(struct ast_aoc_decoded *decoded)
{
	return decoded->aoc_s_count;
}

const struct ast_aoc_s_entry *ast_aoc_s_get_rate_info(struct ast_aoc_decoded *decoded, unsigned int entry_number)
{
	if (entry_number >= decoded->aoc_s_count) {
		return NULL;
	}

	return (const struct ast_aoc_s_entry *) &decoded->aoc_s_entries[entry_number];
}

int ast_aoc_s_add_rate_duration(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item,
	unsigned int amount,
	enum ast_aoc_currency_multiplier multiplier,
	const char *currency_name,
	unsigned long time,
	enum ast_aoc_time_scale time_scale,
	unsigned long granularity_time,
	enum ast_aoc_time_scale granularity_time_scale,
	int step_function)
{

	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = AST_AOC_RATE_TYPE_DURATION;
	entry.rate.duration.amount = amount;
	entry.rate.duration.multiplier = multiplier;
	entry.rate.duration.time = time;
	entry.rate.duration.time_scale = time_scale;
	entry.rate.duration.granularity_time = granularity_time;
	entry.rate.duration.granularity_time_scale = granularity_time_scale;
	entry.rate.duration.charging_type = step_function ? 1 : 0;

	if (!ast_strlen_zero(currency_name)) {
		ast_copy_string(entry.rate.duration.currency_name, currency_name, sizeof(entry.rate.duration.currency_name));
	}

	return aoc_s_add_entry(decoded, &entry);
}

int ast_aoc_s_add_rate_flat(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item,
	unsigned int amount,
	enum ast_aoc_currency_multiplier multiplier,
	const char *currency_name)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = AST_AOC_RATE_TYPE_FLAT;
	entry.rate.flat.amount = amount;
	entry.rate.flat.multiplier = multiplier;

	if (!ast_strlen_zero(currency_name)) {
		ast_copy_string(entry.rate.flat.currency_name, currency_name, sizeof(entry.rate.flat.currency_name));
	}

	return aoc_s_add_entry(decoded, &entry);
}


int ast_aoc_s_add_rate_volume(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item,
	enum ast_aoc_volume_unit volume_unit,
	unsigned int amount,
	enum ast_aoc_currency_multiplier multiplier,
	const char *currency_name)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = AST_AOC_RATE_TYPE_VOLUME;
	entry.rate.volume.multiplier = multiplier;
	entry.rate.volume.amount = amount;
	entry.rate.volume.volume_unit = volume_unit;

	if (!ast_strlen_zero(currency_name)) {
		ast_copy_string(entry.rate.volume.currency_name, currency_name, sizeof(entry.rate.volume.currency_name));
	}

	return aoc_s_add_entry(decoded, &entry);
}

int ast_aoc_s_add_rate_special_charge_code(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item,
	unsigned int code)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = AST_AOC_RATE_TYPE_SPECIAL_CODE;
	entry.rate.special_code = code;

	return aoc_s_add_entry(decoded, &entry);
}

int ast_aoc_s_add_rate_free(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item,
	int from_beginning)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = from_beginning ? AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING : AST_AOC_RATE_TYPE_FREE;

	return aoc_s_add_entry(decoded, &entry);
}

int ast_aoc_s_add_rate_na(struct ast_aoc_decoded *decoded,
	enum ast_aoc_s_charged_item charged_item)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = charged_item;
	entry.rate_type = AST_AOC_RATE_TYPE_NA;

	return aoc_s_add_entry(decoded, &entry);
}

int ast_aoc_s_add_special_arrangement(struct ast_aoc_decoded *decoded,
	unsigned int code)
{
	struct ast_aoc_s_entry entry = { 0, };

	entry.charged_item = AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
	entry.rate_type = AST_AOC_RATE_TYPE_SPECIAL_CODE;
	entry.rate.special_code = code;

	return aoc_s_add_entry(decoded, &entry);
}

enum ast_aoc_type ast_aoc_get_msg_type(struct ast_aoc_decoded *decoded)
{
	return decoded->msg_type;
}

enum ast_aoc_charge_type ast_aoc_get_charge_type(struct ast_aoc_decoded *decoded)
{
	return decoded->charge_type;
}

enum ast_aoc_request ast_aoc_get_request(struct ast_aoc_decoded *decoded)
{
	return decoded->request_flag;
}

int ast_aoc_set_total_type(struct ast_aoc_decoded *decoded,
	const enum ast_aoc_total_type type)
{
	decoded->total_type = type;
	return 0;
}

enum ast_aoc_total_type ast_aoc_get_total_type(struct ast_aoc_decoded *decoded)
{
	return decoded->total_type;
}

int ast_aoc_set_currency_info(struct ast_aoc_decoded *decoded,
		const unsigned int amount,
		const enum ast_aoc_currency_multiplier multiplier,
		const char *name)
{

	if (!ast_strlen_zero(name)) {
		ast_copy_string(decoded->currency_name, name, sizeof(decoded->currency_name));
	}

	decoded->currency_amount = amount;

	if (multiplier && (multiplier < AST_AOC_MULT_NUM_ENTRIES)) {
		decoded->multiplier = multiplier;
	} else {
		decoded->multiplier = AST_AOC_MULT_ONE;
	}

	return 0;
}

unsigned int ast_aoc_get_currency_amount(struct ast_aoc_decoded *decoded)
{
	return decoded->currency_amount;
}

enum ast_aoc_currency_multiplier ast_aoc_get_currency_multiplier(struct ast_aoc_decoded *decoded)
{
	return decoded->multiplier;
}

const char *ast_aoc_get_currency_multiplier_decimal(struct ast_aoc_decoded *decoded)
{
	switch (decoded->multiplier) {
	case AST_AOC_MULT_ONETHOUSANDTH:
		return "0.001";
	case AST_AOC_MULT_ONEHUNDREDTH:
		return "0.01";
	case AST_AOC_MULT_ONETENTH:
		return "0.1";
	case AST_AOC_MULT_ONE:
		return "1.0";
	case AST_AOC_MULT_TEN:
		return "10.0";
	case AST_AOC_MULT_HUNDRED:
		return "100.0";
	case AST_AOC_MULT_THOUSAND:
		return "1000.0";
	default:
		return "1.0";
	}
}

const char *ast_aoc_get_currency_name(struct ast_aoc_decoded *decoded)
{
	return decoded->currency_name;
}

int ast_aoc_add_unit_entry(struct ast_aoc_decoded *decoded,
		const unsigned int amount_is_present,
		const unsigned int amount,
		const unsigned int type_is_present,
		const unsigned int type)
{
	if ((decoded->msg_type == AST_AOC_REQUEST) ||
		(decoded->unit_count >= ARRAY_LEN(decoded->unit_list))) {
		return -1;
	}

	if (!amount_is_present && !type_is_present) {
		return -1;
	}

	decoded->unit_list[decoded->unit_count].valid_amount = amount_is_present;
	if (amount_is_present) {
		decoded->unit_list[decoded->unit_count].amount = amount;
	} else {
		decoded->unit_list[decoded->unit_count].amount = 0;
	}

	decoded->unit_list[decoded->unit_count].valid_type = type_is_present;
	if (type_is_present) {