Imported Upstream version 1.1.1+rev1207upstream/1.1.1+rev1207

1 files changed, 631 insertions, 0 deletions

diff --git a/lib/libdvben50221/en50221_app_ca.c b/lib/libdvben50221/en50221_app_ca.c
new file mode 100644
index 0000000..22d4499
--- /dev/null
+++ b/lib/libdvben50221/en50221_app_ca.c
@@ -0,0 +1,631 @@
+/*
+    en50221 encoder An implementation for libdvb
+    an implementation for the en50221 transport layer
+
+    Copyright (C) 2004, 2005 Manu Abraham <abraham.manu@gmail.com>
+    Copyright (C) 2005 Julian Scheel (julian at jusst dot de)
+    Copyright (C) 2006 Andrew de Quincey (adq_dvb@lidskialf.net)
+
+    This library is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as
+    published by the Free Software Foundation; either version 2.1 of
+    the License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+*/
+
+#include <string.h>
+#include <libdvbmisc/dvbmisc.h>
+#include <pthread.h>
+#include <libucsi/mpeg/descriptor.h>
+#include "en50221_app_ca.h"
+#include "asn_1.h"
+
+// tags supported by this resource
+#define TAG_CA_INFO_ENQUIRY     0x9f8030
+#define TAG_CA_INFO             0x9f8031
+#define TAG_CA_PMT              0x9f8032
+#define TAG_CA_PMT_REPLY        0x9f8033
+
+struct en50221_app_ca {
+	struct en50221_app_send_functions *funcs;
+
+	en50221_app_ca_info_callback ca_info_callback;
+	void *ca_info_callback_arg;
+
+	en50221_app_ca_pmt_reply_callback ca_pmt_reply_callback;
+	void *ca_pmt_reply_callback_arg;
+
+	pthread_mutex_t lock;
+};
+
+struct ca_pmt_descriptor {
+	uint8_t *descriptor;
+	uint16_t length;
+
+	struct ca_pmt_descriptor *next;
+};
+
+struct ca_pmt_stream {
+	uint8_t stream_type;
+	uint16_t pid;
+	struct ca_pmt_descriptor *descriptors;
+	uint32_t descriptors_length;
+	uint32_t descriptors_count;
+
+	struct ca_pmt_stream *next;
+};
+
+static int en50221_ca_extract_pmt_descriptors(struct mpeg_pmt_section *pmt,
+					      struct ca_pmt_descriptor **outdescriptors);
+static int en50221_ca_extract_streams(struct mpeg_pmt_section *pmt,
+				      struct ca_pmt_stream **outstreams);
+static void en50221_ca_try_move_pmt_descriptors(struct ca_pmt_descriptor **pmt_descriptors,
+						struct ca_pmt_stream **pmt_streams);
+static uint32_t en50221_ca_calculate_length(struct ca_pmt_descriptor *pmt_descriptors,
+					    uint32_t *pmt_descriptors_length,
+					    struct ca_pmt_stream *pmt_streams);
+static int en50221_app_ca_parse_info(struct en50221_app_ca *ca,
+				     uint8_t slot_id,
+				     uint16_t session_number,
+				     uint8_t * data, uint32_t data_length);
+static int en50221_app_ca_parse_reply(struct en50221_app_ca *ca,
+				      uint8_t slot_id,
+				      uint16_t session_number,
+				      uint8_t * data,
+				      uint32_t data_length);
+
+
+
+struct en50221_app_ca *en50221_app_ca_create(struct en50221_app_send_functions *funcs)
+{
+	struct en50221_app_ca *ca = NULL;
+
+	// create structure and set it up
+	ca = malloc(sizeof(struct en50221_app_ca));
+	if (ca == NULL) {
+		return NULL;
+	}
+	ca->funcs = funcs;
+	ca->ca_info_callback = NULL;
+	ca->ca_pmt_reply_callback = NULL;
+
+	pthread_mutex_init(&ca->lock, NULL);
+
+	// done
+	return ca;
+}
+
+void en50221_app_ca_destroy(struct en50221_app_ca *ca)
+{
+	pthread_mutex_destroy(&ca->lock);
+	free(ca);
+}
+
+void en50221_app_ca_register_info_callback(struct en50221_app_ca *ca,
+					   en50221_app_ca_info_callback
+					   callback, void *arg)
+{
+	pthread_mutex_lock(&ca->lock);
+	ca->ca_info_callback = callback;
+	ca->ca_info_callback_arg = arg;
+	pthread_mutex_unlock(&ca->lock);
+}
+
+void en50221_app_ca_register_pmt_reply_callback(struct en50221_app_ca *ca,
+						en50221_app_ca_pmt_reply_callback
+						callback, void *arg)
+{
+	pthread_mutex_lock(&ca->lock);
+	ca->ca_pmt_reply_callback = callback;
+	ca->ca_pmt_reply_callback_arg = arg;
+	pthread_mutex_unlock(&ca->lock);
+}
+
+int en50221_app_ca_info_enq(struct en50221_app_ca *ca,
+			    uint16_t session_number)
+{
+	uint8_t data[4];
+
+	data[0] = (TAG_CA_INFO_ENQUIRY >> 16) & 0xFF;
+	data[1] = (TAG_CA_INFO_ENQUIRY >> 8) & 0xFF;
+	data[2] = TAG_CA_INFO_ENQUIRY & 0xFF;
+	data[3] = 0;
+	return ca->funcs->send_data(ca->funcs->arg, session_number, data, 4);
+}
+
+int en50221_app_ca_pmt(struct en50221_app_ca *ca,
+		       uint16_t session_number,
+		       uint8_t * ca_pmt, uint32_t ca_pmt_length)
+{
+	uint8_t buf[10];
+
+	// set up the tag
+	buf[0] = (TAG_CA_PMT >> 16) & 0xFF;
+	buf[1] = (TAG_CA_PMT >> 8) & 0xFF;
+	buf[2] = TAG_CA_PMT & 0xFF;
+
+	// encode the length field
+	int length_field_len;
+	if ((length_field_len = asn_1_encode(ca_pmt_length, buf + 3, 3)) < 0) {
+		return -1;
+	}
+	// build the iovecs
+	struct iovec iov[2];
+	iov[0].iov_base = buf;
+	iov[0].iov_len = 3 + length_field_len;
+	iov[1].iov_base = ca_pmt;
+	iov[1].iov_len = ca_pmt_length;
+
+	// create the data and send it
+	return ca->funcs->send_datav(ca->funcs->arg, session_number, iov, 2);
+}
+
+int en50221_app_ca_message(struct en50221_app_ca *ca,
+			   uint8_t slot_id,
+			   uint16_t session_number,
+			   uint32_t resource_id,
+			   uint8_t * data, uint32_t data_length)
+{
+	(void) resource_id;
+
+	// get the tag
+	if (data_length < 3) {
+		print(LOG_LEVEL, ERROR, 1, "Received short data\n");
+		return -1;
+	}
+	uint32_t tag = (data[0] << 16) | (data[1] << 8) | data[2];
+
+	switch (tag) {
+	case TAG_CA_INFO:
+		return en50221_app_ca_parse_info(ca, slot_id,
+						 session_number, data + 3,
+						 data_length - 3);
+	case TAG_CA_PMT_REPLY:
+		return en50221_app_ca_parse_reply(ca, slot_id,
+						  session_number, data + 3,
+						  data_length - 3);
+	}
+
+	print(LOG_LEVEL, ERROR, 1, "Received unexpected tag %x\n", tag);
+	return -1;
+}
+
+int en50221_ca_format_pmt(struct mpeg_pmt_section *pmt, uint8_t * data,
+			  uint32_t data_length, int move_ca_descriptors,
+			  uint8_t ca_pmt_list_management,
+			  uint8_t ca_pmt_cmd_id)
+{
+	struct ca_pmt_descriptor *pmt_descriptors = NULL;
+	uint32_t pmt_descriptors_length = 0;
+	struct ca_pmt_stream *pmt_streams = NULL;
+	uint32_t total_required_length = 0;
+	struct ca_pmt_descriptor *cur_d;
+	struct ca_pmt_stream *cur_s;
+	int result = -1;
+
+	// extract the descriptors and streams
+	if (en50221_ca_extract_pmt_descriptors(pmt, &pmt_descriptors))
+		goto cleanup;
+	if (en50221_ca_extract_streams(pmt, &pmt_streams))
+		goto cleanup;
+
+	// try and merge them if we have no PMT descriptors
+	if ((pmt_descriptors == NULL) && move_ca_descriptors) {
+		en50221_ca_try_move_pmt_descriptors(&pmt_descriptors,
+						    &pmt_streams);
+	}
+	// calculate the length of all descriptors/streams and the total length required
+	total_required_length =
+	    en50221_ca_calculate_length(pmt_descriptors,
+					&pmt_descriptors_length,
+					pmt_streams);
+
+	// ensure we were supplied with enough data
+	if (total_required_length > data_length) {
+		goto cleanup;
+	}
+	// format the start of the PMT
+	uint32_t data_pos = 0;
+	data[data_pos++] = ca_pmt_list_management;
+	data[data_pos++] = mpeg_pmt_section_program_number(pmt) >> 8;
+	data[data_pos++] = mpeg_pmt_section_program_number(pmt);
+	data[data_pos++] =
+	    (pmt->head.version_number << 1) | pmt->head.
+	    current_next_indicator;
+	data[data_pos++] = (pmt_descriptors_length >> 8) & 0x0f;
+	data[data_pos++] = pmt_descriptors_length;
+
+	// append the PMT descriptors
+	if (pmt_descriptors_length) {
+		data[data_pos++] = ca_pmt_cmd_id;
+		cur_d = pmt_descriptors;
+		while (cur_d) {
+			memcpy(data + data_pos, cur_d->descriptor,
+			       cur_d->length);
+			data_pos += cur_d->length;
+			cur_d = cur_d->next;
+		}
+	}
+	// now, append the streams
+	cur_s = pmt_streams;
+	while (cur_s) {
+		data[data_pos++] = cur_s->stream_type;
+		data[data_pos++] = (cur_s->pid >> 8) & 0x1f;
+		data[data_pos++] = cur_s->pid;
+		data[data_pos++] = (cur_s->descriptors_length >> 8) & 0x0f;
+		data[data_pos++] = cur_s->descriptors_length;
+
+		// append the stream descriptors
+		if (cur_s->descriptors_length) {
+			data[data_pos++] = ca_pmt_cmd_id;
+			cur_d = cur_s->descriptors;
+			while (cur_d) {
+				memcpy(data + data_pos, cur_d->descriptor,
+				       cur_d->length);
+				data_pos += cur_d->length;
+				cur_d = cur_d->next;
+			}
+		}
+		cur_s = cur_s->next;
+	}
+	result = data_pos;
+
+
+      cleanup:
+	// free the PMT descriptors
+	cur_d = pmt_descriptors;
+	while (cur_d) {
+		struct ca_pmt_descriptor *next = cur_d->next;
+		free(cur_d);
+		cur_d = next;
+	}
+
+	// free the streams
+	cur_s = pmt_streams;
+	while (cur_s) {
+		struct ca_pmt_stream *next_s = cur_s->next;
+
+		// free the stream descriptors
+		cur_d = cur_s->descriptors;
+		while (cur_d) {
+			struct ca_pmt_descriptor *next_d = cur_d->next;
+			free(cur_d);
+			cur_d = next_d;
+		}
+
+		free(cur_s);
+		cur_s = next_s;
+	}
+	return result;
+}
+
+
+
+
+
+
+
+static int en50221_ca_extract_pmt_descriptors(struct mpeg_pmt_section *pmt,
+					      struct ca_pmt_descriptor **outdescriptors)
+{
+	struct ca_pmt_descriptor *descriptors = NULL;
+	struct ca_pmt_descriptor *descriptors_tail = NULL;
+	struct ca_pmt_descriptor *cur_d;
+
+	struct descriptor *cur_descriptor;
+	mpeg_pmt_section_descriptors_for_each(pmt, cur_descriptor) {
+		if (cur_descriptor->tag == dtag_mpeg_ca) {
+			// create a new structure for this one
+			struct ca_pmt_descriptor *new_d =
+			    malloc(sizeof(struct ca_pmt_descriptor));
+			if (new_d == NULL) {
+				goto error_exit;
+			}
+			new_d->descriptor = (uint8_t *) cur_descriptor;
+			new_d->length = cur_descriptor->len + 2;
+			new_d->next = NULL;
+
+			// append it to the list
+			if (descriptors == NULL) {
+				descriptors = new_d;
+			} else {
+				descriptors_tail->next = new_d;
+			}
+			descriptors_tail = new_d;
+		}
+	}
+	*outdescriptors = descriptors;
+	return 0;
+
+error_exit:
+	cur_d = descriptors;
+	while (cur_d) {
+		struct ca_pmt_descriptor *next = cur_d->next;
+		free(cur_d);
+		cur_d = next;
+	}
+	return -1;
+}
+
+static int en50221_ca_extract_streams(struct mpeg_pmt_section *pmt,
+				      struct ca_pmt_stream **outstreams)
+{
+	struct ca_pmt_stream *streams = NULL;
+	struct ca_pmt_stream *streams_tail = NULL;
+	struct mpeg_pmt_stream *cur_stream;
+	struct descriptor *cur_descriptor;
+	struct ca_pmt_stream *cur_s;
+
+	mpeg_pmt_section_streams_for_each(pmt, cur_stream) {
+		struct ca_pmt_descriptor *descriptors_tail = NULL;
+
+		// create a new structure
+		struct ca_pmt_stream *new_s =
+		    malloc(sizeof(struct ca_pmt_stream));
+		if (new_s == NULL) {
+			goto exit_cleanup;
+		}
+		new_s->stream_type = cur_stream->stream_type;
+		new_s->pid = cur_stream->pid;
+		new_s->descriptors = NULL;
+		new_s->next = NULL;
+		new_s->descriptors_count = 0;
+
+		// append it to the list
+		if (streams == NULL) {
+			streams = new_s;
+		} else {
+			streams_tail->next = new_s;
+		}
+		streams_tail = new_s;
+
+		// now process the descriptors
+		mpeg_pmt_stream_descriptors_for_each(cur_stream,
+						     cur_descriptor) {
+			if (cur_descriptor->tag == dtag_mpeg_ca) {
+				// create a new structure
+				struct ca_pmt_descriptor *new_d =
+				    malloc(sizeof(struct ca_pmt_descriptor));
+				if (new_d == NULL) {
+					goto exit_cleanup;
+				}
+				new_d->descriptor =
+				    (uint8_t *) cur_descriptor;
+				new_d->length = cur_descriptor->len + 2;
+				new_d->next = NULL;
+
+				// append it to the list
+				if (new_s->descriptors == NULL) {
+					new_s->descriptors = new_d;
+				} else {
+					descriptors_tail->next = new_d;
+				}
+				descriptors_tail = new_d;
+				new_s->descriptors_count++;
+			}
+		}
+	}
+	*outstreams = streams;
+	return 0;
+
+exit_cleanup:
+	// free the streams
+	cur_s = streams;
+	while (cur_s) {
+		struct ca_pmt_stream *next_s = cur_s->next;
+
+		// free the stream descriptors
+		struct ca_pmt_descriptor *cur_d = cur_s->descriptors;
+		while (cur_d) {
+			struct ca_pmt_descriptor *next_d = cur_d->next;
+			free(cur_d);
+			cur_d = next_d;
+		}
+
+		free(cur_s);
+		cur_s = next_s;
+	}
+	return -1;
+}
+
+static void en50221_ca_try_move_pmt_descriptors(struct ca_pmt_descriptor **pmt_descriptors,
+						struct ca_pmt_stream **pmt_streams)
+{
+	// get the first stream
+	struct ca_pmt_stream *first_stream = *pmt_streams;
+	if (first_stream == NULL)
+		return;
+
+	// Check that all the other streams with CA descriptors have exactly the same CA descriptors
+	struct ca_pmt_stream *cur_stream = first_stream->next;
+	while (cur_stream) {
+		// if there are differing numbers of descriptors, exit right now
+		if (cur_stream->descriptors_count != first_stream->descriptors_count)
+			return;
+
+		// now verify the descriptors match
+		struct ca_pmt_descriptor *cur_descriptor = cur_stream->descriptors;
+		struct ca_pmt_descriptor *first_cur_descriptor = first_stream->descriptors;
+		while (cur_descriptor) {
+			// check the descriptors are the same length
+			if (cur_descriptor->length != first_cur_descriptor->length)
+				return;
+
+			// check their contents match
+			if (memcmp(cur_descriptor->descriptor,
+			    	   first_cur_descriptor->descriptor,
+				   cur_descriptor->length)) {
+				return;
+			}
+			// move to next
+			cur_descriptor = cur_descriptor->next;
+			first_cur_descriptor = first_cur_descriptor->next;
+		}
+
+		// move to next
+		cur_stream = cur_stream->next;
+	}
+
+	// if we end up here, all descriptors in all streams matched
+
+	// hook the first stream's descriptors into the PMT's
+	*pmt_descriptors = first_stream->descriptors;
+	first_stream->descriptors = NULL;
+	first_stream->descriptors_count = 0;
+
+	// now free up all the descriptors in the other streams
+	cur_stream = first_stream->next;
+	while (cur_stream) {
+		struct ca_pmt_descriptor *cur_descriptor = cur_stream->descriptors;
+		while (cur_descriptor) {
+			struct ca_pmt_descriptor *next = cur_descriptor->next;
+			free(cur_descriptor);
+			cur_descriptor = next;
+		}
+		cur_stream->descriptors = NULL;
+		cur_stream->descriptors_count = 0;
+		cur_stream = cur_stream->next;
+	}
+}
+
+static uint32_t en50221_ca_calculate_length(struct ca_pmt_descriptor *pmt_descriptors,
+					    uint32_t *pmt_descriptors_length,
+					    struct ca_pmt_stream *pmt_streams)
+{
+	uint32_t total_required_length = 6;	// header
+	struct ca_pmt_stream *cur_s;
+
+	// calcuate the PMT descriptors length
+	(*pmt_descriptors_length) = 0;
+	struct ca_pmt_descriptor *cur_d = pmt_descriptors;
+	while (cur_d) {
+		(*pmt_descriptors_length) += cur_d->length;
+		cur_d = cur_d->next;
+	}
+
+	// add on 1 byte for the ca_pmt_cmd_id if we have some descriptors.
+	if (*pmt_descriptors_length)
+		(*pmt_descriptors_length)++;
+
+	// update the total required length
+	total_required_length += *pmt_descriptors_length;
+
+	// calculate the length of descriptors in the streams
+	cur_s = pmt_streams;
+	while (cur_s) {
+		// calculate the size of descriptors in this stream
+		cur_s->descriptors_length = 0;
+		cur_d = cur_s->descriptors;
+		while (cur_d) {
+			cur_s->descriptors_length += cur_d->length;
+			cur_d = cur_d->next;
+		}
+
+		// add on 1 byte for the ca_pmt_cmd_id if we have some descriptors.
+		if (cur_s->descriptors_length)
+			cur_s->descriptors_length++;
+
+		// update the total required length;
+		total_required_length += 5 + cur_s->descriptors_length;
+
+		cur_s = cur_s->next;
+	}
+
+	// done
+	return total_required_length;
+}
+
+static int en50221_app_ca_parse_info(struct en50221_app_ca *ca,
+				     uint8_t slot_id,
+				     uint16_t session_number,
+				     uint8_t * data, uint32_t data_length)
+{
+	// first of all, decode the length field
+	uint16_t asn_data_length;
+	int length_field_len;
+	if ((length_field_len = asn_1_decode(&asn_data_length, data, data_length)) < 0) {
+		print(LOG_LEVEL, ERROR, 1, "ASN.1 decode error\n");
+		return -1;
+	}
+	// check it
+	if (asn_data_length > (data_length - length_field_len)) {
+		print(LOG_LEVEL, ERROR, 1, "Received short data\n");
+		return -1;
+	}
+	data += length_field_len;
+
+	// parse
+	uint32_t ca_id_count = asn_data_length / 2;
+
+	// byteswap the IDs
+	uint16_t *ids = (uint16_t *) data;
+	uint32_t i;
+	for (i = 0; i < ca_id_count; i++) {
+		bswap16(data);
+		data += 2;
+	}
+
+	// tell the app
+	pthread_mutex_lock(&ca->lock);
+	en50221_app_ca_info_callback cb = ca->ca_info_callback;
+	void *cb_arg = ca->ca_info_callback_arg;
+	pthread_mutex_unlock(&ca->lock);
+	if (cb) {
+		return cb(cb_arg, slot_id, session_number, ca_id_count,
+			  ids);
+	}
+	return 0;
+}
+
+static int en50221_app_ca_parse_reply(struct en50221_app_ca *ca,
+				      uint8_t slot_id,
+				      uint16_t session_number,
+				      uint8_t * data, uint32_t data_length)
+{
+	// first of all, decode the length field
+	uint16_t asn_data_length;
+	int length_field_len;
+	if ((length_field_len = asn_1_decode(&asn_data_length, data, data_length)) < 0) {
+		print(LOG_LEVEL, ERROR, 1, "ASN.1 decode error\n");
+		return -1;
+	}
+	// check it
+	if (asn_data_length < 4) {
+		print(LOG_LEVEL, ERROR, 1, "Received short data\n");
+		return -1;
+	}
+	if (asn_data_length > (data_length - length_field_len)) {
+		print(LOG_LEVEL, ERROR, 1, "Received short data\n");
+		return -1;
+	}
+	data += length_field_len;
+	data_length -= length_field_len;
+
+	// process the reply table to fix endian issues
+	uint32_t pos = 4;
+	bswap16(data);
+	while (pos < asn_data_length) {
+		bswap16(data + pos);
+		pos += 3;
+	}
+
+	// tell the app
+	pthread_mutex_lock(&ca->lock);
+	en50221_app_ca_pmt_reply_callback cb = ca->ca_pmt_reply_callback;
+	void *cb_arg = ca->ca_pmt_reply_callback_arg;
+	pthread_mutex_unlock(&ca->lock);
+	if (cb) {
+		return cb(cb_arg, slot_id, session_number,
+			  (struct en50221_app_pmt_reply *) data,
+			  asn_data_length);
+	}
+	return 0;
+}