sys/dvb/camtransport.c - imx-gst-plugins-bad - Git at Google

 /*
  * camtransport.c - GStreamer CAM (EN50221) transport layer
  * Copyright (C) 2007 Alessandro Decina
  *
  * Authors:
  *   Alessandro Decina <alessandro@nnva.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */

 #include "camtransport.h"
 #include <sys/select.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <errno.h>

 #define GST_CAT_DEFAULT cam_debug_cat
 #define READ_TIMEOUT_SEC 2
 #define READ_TIMEOUT_USEC 0

 #define POLL_INTERVAL 0.300

 /* Layer tags */
 #define TAG_SB 0x80
 #define TAG_RCV 0x81
 #define TAG_CREATE_T_C 0x82
 #define TAG_C_T_C_REPLY 0x83
 #define TAG_DELETE_T_C 0x84
 #define TAG_D_T_C_REPLY 0x85
 #define TAG_REQUEST_T_C 0x86
 #define TAG_NEW_T_C 0x87
 #define TAG_T_C_ERROR 0x88
 #define TAG_DATA_MORE 0xA1
 #define TAG_DATA_LAST 0xA0

 /* Session tags */
 #define TAG_SESSION_NUMBER 0x90
 #define TAG_OPEN_SESSION_REQUEST 0x91
 #define TAG_OPEN_SESSION_RESPONSE 0x92
 #define TAG_CREATE_SESSION 0x93
 #define TAG_CREATE_SESSION_RESPONSE 0x94
 #define TAG_CLOSE_SESSION_REQUEST 0x95
 #define TAG_CLOSE_SESSION_RESPONSE 0x96


 typedef struct
 {
   guint tagid;
   const gchar *description;
 } CamTagMessage;

 static const CamTagMessage debugmessage[] = {
   {TAG_SB, "SB"},
   {TAG_RCV, "RCV"},
   {TAG_CREATE_T_C, "CREATE_T_C"},
   {TAG_C_T_C_REPLY, "CREATE_T_C_REPLY"},
   {TAG_DELETE_T_C, "DELETE_T_C"},
   {TAG_D_T_C_REPLY, "DELETE_T_C_REPLY"},
   {TAG_REQUEST_T_C, "REQUEST_T_C"},
   {TAG_NEW_T_C, "NEW_T_C"},
   {TAG_T_C_ERROR, "T_C_ERROR"},
   {TAG_SESSION_NUMBER, "SESSION_NUMBER"},
   {TAG_OPEN_SESSION_REQUEST, "OPEN_SESSION_REQUEST"},
   {TAG_OPEN_SESSION_RESPONSE, "OPEN_SESSION_RESPONSE"},
   {TAG_CREATE_SESSION, "CREATE_SESSION"},
   {TAG_CREATE_SESSION_RESPONSE, "CREATE_SESSION_RESPONSE"},
   {TAG_CLOSE_SESSION_REQUEST, "CLOSE_SESSION_REQUEST"},
   {TAG_CLOSE_SESSION_RESPONSE, "CLOSE_SESSION_RESPONSE"},
   {TAG_DATA_MORE, "DATA_MORE"},
   {TAG_DATA_LAST, "DATA_LAST"}
 };

 static inline const gchar *
 tag_get_name (guint tagid)
 {
   guint i;

   for (i = 0; i < G_N_ELEMENTS (debugmessage); i++)
     if (debugmessage[i].tagid == tagid)
       return debugmessage[i].description;
   return "UNKNOWN";
 }

 /* utility struct used to store the state of the connections in cam_tl_read_next
  */
 typedef struct
 {
   GList *active;
   GList *idle;
 } CamTLConnectionsStatus;

 void cam_gst_util_dump_mem (const guchar * mem, guint size);

 static CamTLConnection *
 cam_tl_connection_new (CamTL * tl, guint8 id)
 {
   CamTLConnection *connection;

   connection = g_new0 (CamTLConnection, 1);
   connection->tl = tl;
   connection->id = id;
   connection->state = CAM_TL_CONNECTION_STATE_CLOSED;
   connection->has_data = FALSE;

   return connection;
 }

 static void
 cam_tl_connection_destroy (CamTLConnection * connection)
 {
   if (connection->last_poll)
     g_timer_destroy (connection->last_poll);

   g_free (connection);
 }

 CamTL *
 cam_tl_new (int fd)
 {
   CamTL *tl;

   tl = g_new0 (CamTL, 1);
   tl->fd = fd;
   tl->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
       NULL, (GDestroyNotify) cam_tl_connection_destroy);

   return tl;
 }

 void
 cam_tl_destroy (CamTL * tl)
 {
   g_hash_table_destroy (tl->connections);

   g_free (tl);
 }

 /* read data from the module without blocking indefinitely */
 static CamReturn
 cam_tl_read_timeout (CamTL * tl, struct timeval *timeout)
 {
   fd_set read_fd;
   int sret;

   FD_ZERO (&read_fd);
   FD_SET (tl->fd, &read_fd);

   sret = select (tl->fd + 1, &read_fd, NULL, NULL, timeout);
   if (sret == 0) {
     GST_DEBUG ("read timeout");
     return CAM_RETURN_TRANSPORT_TIMEOUT;
   }

   tl->buffer_size = read (tl->fd, &tl->buffer, HOST_BUFFER_SIZE);
   if (tl->buffer_size == -1) {
     GST_ERROR ("error reading tpdu: %s", g_strerror (errno));
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   return CAM_RETURN_OK;
 }

 /* read data from the module using the default timeout */
 static CamReturn
 cam_tl_read (CamTL * tl)
 {
   struct timeval timeout;

   timeout.tv_sec = READ_TIMEOUT_SEC;
   timeout.tv_usec = READ_TIMEOUT_USEC;

   return cam_tl_read_timeout (tl, &timeout);
 }

 /* get the number of bytes to allocate for a TPDU with a body of body_length
  * bytes. Also get the offset from the beginning of the buffer that marks the
  * position of the first byte of the TPDU body */
 void
 cam_tl_calc_buffer_size (CamTL * tl, guint body_length,
     guint * buffer_size, guint * offset)
 {
   guint length_field_len;

   /* the size of a TPDU is:
    * 1 byte slot number
    * 1 byte connection id
    * length_field_len bytes length field
    * 1 byte connection id
    * body_length bytes body
    */

   /* get the length of the lenght_field block */
   length_field_len = cam_calc_length_field_size (body_length);

   *offset = 3 + length_field_len + 1;
   *buffer_size = *offset + body_length;
 }

 /* write the header of a TPDU
  * NOTE: this function assumes that the buffer is large enough to contain the
  * complete TPDU (see cam_tl_calc_buffer_size ()) and that enough space has been
  * left from the beginning of the buffer to write the TPDU header.
  */
 static CamReturn
 cam_tl_connection_write_tpdu (CamTLConnection * connection,
     guint8 tag, guint8 * buffer, guint buffer_size, guint body_length)
 {
   int sret;
   CamTL *tl = connection->tl;
   guint8 length_field_len;

   /* slot number */
   buffer[0] = connection->slot;
   /* connection number */
   buffer[1] = connection->id;
   /* tag */
   buffer[2] = tag;
   /* length can take 1 to 4 bytes */
   length_field_len = cam_write_length_field (&buffer[3], body_length);
   buffer[3 + length_field_len] = connection->id;

   GST_DEBUG ("writing TPDU %x (%s) connection %d (size:%d)",
       buffer[2], tag_get_name (buffer[2]), connection->id, buffer_size);

   //cam_gst_util_dump_mem (buffer, buffer_size);

   sret = write (tl->fd, buffer, buffer_size);
   if (sret == -1) {
     GST_ERROR ("error witing TPDU (%d): %s", errno, g_strerror (errno));
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   tl->expected_tpdus += 1;

   GST_DEBUG ("Sucess writing tpdu 0x%x (%s)", buffer[2],
       tag_get_name (buffer[2]));

   return CAM_RETURN_OK;
 }

 /* convenience function to write control TPDUs (TPDUs having a single-byte body)
  */
 static CamReturn
 cam_tl_connection_write_control_tpdu (CamTLConnection * connection, guint8 tag)
 {
   guint8 tpdu[5];

   /* TPDU layout (5 bytes):
    *
    * slot number (1 byte)
    * connection id (1 byte)
    * tag (1 byte)
    * length (1 byte)
    * connection id (1 byte)
    */

   return cam_tl_connection_write_tpdu (connection, tag, tpdu, 5, 1);
 }

 /* read the next TPDU from the CAM */
 static CamReturn
 cam_tl_read_tpdu_next (CamTL * tl, CamTLConnection ** out_connection)
 {
   CamReturn ret;
   CamTLConnection *connection;
   guint8 connection_id;
   guint8 *tpdu;
   guint8 length_field_len;
   guint8 status;

   ret = cam_tl_read (tl);
   if (CAM_FAILED (ret))
     return ret;

   tpdu = tl->buffer;

   /* must hold at least slot, connection_id, 1byte length_field, connection_id
    */
   if (tl->buffer_size < 4) {
     GST_ERROR ("invalid TPDU length %d", tl->buffer_size);
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   /* LPDU slot */
   /* slot = tpdu[0]; */
   /* LPDU connection id */
   connection_id = tpdu[1];

   connection = g_hash_table_lookup (tl->connections,
       GINT_TO_POINTER ((guint) connection_id));
   if (connection == NULL) {
     /* WHAT? */
     GST_ERROR ("CAM sent a TPDU on an unknown connection: %d", connection_id);
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   /* read the length_field () */
   length_field_len = cam_read_length_field (&tpdu[3], &tl->body_length);

   if (tl->body_length + 3 > tl->buffer_size) {
     GST_ERROR ("invalid TPDU length_field (%d) exceeds "
         "the size of the buffer (%d)", tl->body_length, tl->buffer_size);
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   /* skip slot + connection id + tag + lenght_field () + connection id */
   tl->body = tpdu + 4 + length_field_len;
   /* do not count the connection id byte as part of the body */
   tl->body_length -= 1;

   if (tl->buffer[tl->buffer_size - 4] != TAG_SB) {
     GST_ERROR ("no TAG_SB appended to TPDU");
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   status = tl->buffer[tl->buffer_size - 1];
   if (status & 0x80) {
     connection->has_data = TRUE;
   } else {
     connection->has_data = FALSE;
   }

   GST_DEBUG ("received TPDU %x (%s) more data %d", tpdu[2],
       tag_get_name (tpdu[2]), connection->has_data);
   tl->expected_tpdus -= 1;

   *out_connection = connection;

   return CAM_RETURN_OK;
 }

 /* create a connection with the module */
 CamReturn
 cam_tl_create_connection (CamTL * tl, guint8 slot,
     CamTLConnection ** connection)
 {
   CamReturn ret;
   CamTLConnection *conn = NULL;
   guint count = 10;

   if (tl->connection_ids == 255)
     return CAM_RETURN_TRANSPORT_TOO_MANY_CONNECTIONS;

   conn = cam_tl_connection_new (tl, ++tl->connection_ids);

   /* Some CA devices take a long time to set themselves up,
    * therefore retry every 250ms (for a maximum of 2.5s)
    */
   while (TRUE) {
     /* send a TAG_CREATE_T_C TPDU */
     ret = cam_tl_connection_write_control_tpdu (conn, TAG_CREATE_T_C);
     if (!CAM_FAILED (ret))
       break;
     if (!count)
       goto error;
     GST_DEBUG ("Failed sending initial connection message .. but retrying");
     count--;
     /* Wait 250ms */
     g_usleep (G_USEC_PER_SEC / 4);
   }

   g_hash_table_insert (tl->connections, GINT_TO_POINTER (conn->id), conn);

   *connection = conn;

   return CAM_RETURN_OK;

 error:
   if (conn)
     cam_tl_connection_destroy (conn);

   return ret;
 }

 CamReturn
 cam_tl_connection_delete (CamTLConnection * connection)
 {
   CamReturn ret;

   ret = cam_tl_connection_write_control_tpdu (connection, TAG_DELETE_T_C);
   if (CAM_FAILED (ret))
     return ret;

   connection->state = CAM_TL_CONNECTION_STATE_IN_DELETION;

   return CAM_RETURN_OK;
 }

 static CamReturn
 handle_control_tpdu (CamTL * tl, CamTLConnection * connection)
 {
   if (tl->body_length != 0) {
     GST_ERROR ("got control tpdu of invalid length: %d", tl->body_length);
     return CAM_RETURN_TRANSPORT_ERROR;
   }

   switch (tl->buffer[2]) {
       /* create transport connection reply */
     case TAG_C_T_C_REPLY:
       /* a connection might be closed before it's acknowledged */
       if (connection->state != CAM_TL_CONNECTION_STATE_IN_DELETION) {
         GST_DEBUG ("connection created %d", connection->id);
         connection->state = CAM_TL_CONNECTION_STATE_OPEN;

         if (tl->connection_created)
           tl->connection_created (tl, connection);
       }
       break;
       /* delete transport connection reply */
     case TAG_D_T_C_REPLY:
       connection->state = CAM_TL_CONNECTION_STATE_CLOSED;
       GST_DEBUG ("connection closed %d", connection->id);

       if (tl->connection_deleted)
         tl->connection_deleted (tl, connection);

       g_hash_table_remove (tl->connections,
           GINT_TO_POINTER ((guint) connection->id));
       break;
   }

   return CAM_RETURN_OK;
 }

 static CamReturn
 handle_data_tpdu (CamTL * tl, CamTLConnection * connection)
 {
   if (tl->body_length == 0) {
     /* FIXME: figure out why this seems to happen from time to time with the
      * predator cam */
     GST_WARNING ("Empty data TPDU received");
     return CAM_RETURN_OK;
   }

   if (tl->connection_data)
     return tl->connection_data (tl, connection, tl->body, tl->body_length);

   return CAM_RETURN_OK;
 }

 static void
 foreach_connection_get (gpointer key, gpointer value, gpointer user_data)
 {
   GList **lst = (GList **) user_data;

   *lst = g_list_append (*lst, value);
 }

 CamReturn
 cam_tl_connection_poll (CamTLConnection * connection, gboolean force)
 {
   CamReturn ret;

   if (connection->last_poll == NULL) {
     connection->last_poll = g_timer_new ();
   } else if (!force &&
       g_timer_elapsed (connection->last_poll, NULL) < POLL_INTERVAL) {
     return CAM_RETURN_TRANSPORT_POLL;
   }

   GST_DEBUG ("polling connection %d", connection->id);
   ret = cam_tl_connection_write_control_tpdu (connection, TAG_DATA_LAST);
   if (CAM_FAILED (ret))
     return ret;

   g_timer_start (connection->last_poll);

   return CAM_RETURN_OK;
 }

 /* read all the queued TPDUs */
 CamReturn
 cam_tl_read_all (CamTL * tl, gboolean poll)
 {
   CamReturn ret = CAM_RETURN_OK;
   CamTLConnection *connection;
   GList *connections = NULL;
   GList *walk;
   gboolean done = FALSE;

   while (!done) {
     while (tl->expected_tpdus) {
       /* read the next TPDU from the connection */
       ret = cam_tl_read_tpdu_next (tl, &connection);
       if (CAM_FAILED (ret)) {
         GST_ERROR ("error reading TPDU from module: %d", ret);
         goto out;
       }

       switch (tl->buffer[2]) {
         case TAG_C_T_C_REPLY:
         case TAG_D_T_C_REPLY:
           connection->empty_data = 0;
           ret = handle_control_tpdu (tl, connection);
           break;
         case TAG_DATA_MORE:
         case TAG_DATA_LAST:
           connection->empty_data = 0;
           ret = handle_data_tpdu (tl, connection);
           break;
         case TAG_SB:
           /* this is handled by tpdu_next */
           break;
       }

       if (CAM_FAILED (ret))
         goto out;
     }

     done = TRUE;

     connections = NULL;
     g_hash_table_foreach (tl->connections,
         foreach_connection_get, &connections);

     for (walk = connections; walk; walk = walk->next) {
       CamTLConnection *connection = CAM_TL_CONNECTION (walk->data);

       if (connection->has_data == TRUE && connection->empty_data < 10) {
         ret = cam_tl_connection_write_control_tpdu (connection, TAG_RCV);
         if (CAM_FAILED (ret)) {
           g_list_free (connections);
           goto out;
         }
         /* increment the empty_data counter. If we get data, this will be reset
          * to 0 */
         connection->empty_data++;
         done = FALSE;
       } else if (poll) {
         ret = cam_tl_connection_poll (connection, FALSE);
         if (ret == CAM_RETURN_TRANSPORT_POLL)
           continue;

         if (CAM_FAILED (ret)) {
           g_list_free (connections);
           goto out;
         }

         done = FALSE;
       }
     }

     g_list_free (connections);
   }

 out:
   return ret;
 }

 CamReturn
 cam_tl_connection_write (CamTLConnection * connection,
     guint8 * buffer, guint buffer_size, guint body_length)
 {
   return cam_tl_connection_write_tpdu (connection,
       TAG_DATA_LAST, buffer, buffer_size, 1 + body_length);
 }
	/*
	* camtransport.c - GStreamer CAM (EN50221) transport layer
	* Copyright (C) 2007 Alessandro Decina
	*
	* Authors:
	* Alessandro Decina <alessandro@nnva.org>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library 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
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public
	* License along with this library; if not, write to the
	* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*/

	#include "camtransport.h"
	#include <sys/select.h>
	#include <sys/time.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <errno.h>

	#define GST_CAT_DEFAULT cam_debug_cat
	#define READ_TIMEOUT_SEC 2
	#define READ_TIMEOUT_USEC 0

	#define POLL_INTERVAL 0.300

	/* Layer tags */
	#define TAG_SB 0x80
	#define TAG_RCV 0x81
	#define TAG_CREATE_T_C 0x82
	#define TAG_C_T_C_REPLY 0x83
	#define TAG_DELETE_T_C 0x84
	#define TAG_D_T_C_REPLY 0x85
	#define TAG_REQUEST_T_C 0x86
	#define TAG_NEW_T_C 0x87
	#define TAG_T_C_ERROR 0x88
	#define TAG_DATA_MORE 0xA1
	#define TAG_DATA_LAST 0xA0

	/* Session tags */
	#define TAG_SESSION_NUMBER 0x90
	#define TAG_OPEN_SESSION_REQUEST 0x91
	#define TAG_OPEN_SESSION_RESPONSE 0x92
	#define TAG_CREATE_SESSION 0x93
	#define TAG_CREATE_SESSION_RESPONSE 0x94
	#define TAG_CLOSE_SESSION_REQUEST 0x95
	#define TAG_CLOSE_SESSION_RESPONSE 0x96


	typedef struct
	{
	guint tagid;
	const gchar *description;
	} CamTagMessage;

	static const CamTagMessage debugmessage[] = {
	{TAG_SB, "SB"},
	{TAG_RCV, "RCV"},
	{TAG_CREATE_T_C, "CREATE_T_C"},
	{TAG_C_T_C_REPLY, "CREATE_T_C_REPLY"},
	{TAG_DELETE_T_C, "DELETE_T_C"},
	{TAG_D_T_C_REPLY, "DELETE_T_C_REPLY"},
	{TAG_REQUEST_T_C, "REQUEST_T_C"},
	{TAG_NEW_T_C, "NEW_T_C"},
	{TAG_T_C_ERROR, "T_C_ERROR"},
	{TAG_SESSION_NUMBER, "SESSION_NUMBER"},
	{TAG_OPEN_SESSION_REQUEST, "OPEN_SESSION_REQUEST"},
	{TAG_OPEN_SESSION_RESPONSE, "OPEN_SESSION_RESPONSE"},
	{TAG_CREATE_SESSION, "CREATE_SESSION"},
	{TAG_CREATE_SESSION_RESPONSE, "CREATE_SESSION_RESPONSE"},
	{TAG_CLOSE_SESSION_REQUEST, "CLOSE_SESSION_REQUEST"},
	{TAG_CLOSE_SESSION_RESPONSE, "CLOSE_SESSION_RESPONSE"},
	{TAG_DATA_MORE, "DATA_MORE"},
	{TAG_DATA_LAST, "DATA_LAST"}
	};

	static inline const gchar *
	tag_get_name (guint tagid)
	{
	guint i;

	for (i = 0; i < G_N_ELEMENTS (debugmessage); i++)
	if (debugmessage[i].tagid == tagid)
	return debugmessage[i].description;
	return "UNKNOWN";
	}

	/* utility struct used to store the state of the connections in cam_tl_read_next
	*/
	typedef struct
	{
	GList *active;
	GList *idle;
	} CamTLConnectionsStatus;

	void cam_gst_util_dump_mem (const guchar * mem, guint size);

	static CamTLConnection *
	cam_tl_connection_new (CamTL * tl, guint8 id)
	{
	CamTLConnection *connection;

	connection = g_new0 (CamTLConnection, 1);
	connection->tl = tl;
	connection->id = id;
	connection->state = CAM_TL_CONNECTION_STATE_CLOSED;
	connection->has_data = FALSE;

	return connection;
	}

	static void
	cam_tl_connection_destroy (CamTLConnection * connection)
	{
	if (connection->last_poll)
	g_timer_destroy (connection->last_poll);

	g_free (connection);
	}

	CamTL *
	cam_tl_new (int fd)
	{
	CamTL *tl;

	tl = g_new0 (CamTL, 1);
	tl->fd = fd;
	tl->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
	NULL, (GDestroyNotify) cam_tl_connection_destroy);

	return tl;
	}

	void
	cam_tl_destroy (CamTL * tl)
	{
	g_hash_table_destroy (tl->connections);

	g_free (tl);
	}

	/* read data from the module without blocking indefinitely */
	static CamReturn
	cam_tl_read_timeout (CamTL * tl, struct timeval *timeout)
	{
	fd_set read_fd;
	int sret;

	FD_ZERO (&read_fd);
	FD_SET (tl->fd, &read_fd);

	sret = select (tl->fd + 1, &read_fd, NULL, NULL, timeout);
	if (sret == 0) {
	GST_DEBUG ("read timeout");
	return CAM_RETURN_TRANSPORT_TIMEOUT;
	}

	tl->buffer_size = read (tl->fd, &tl->buffer, HOST_BUFFER_SIZE);
	if (tl->buffer_size == -1) {
	GST_ERROR ("error reading tpdu: %s", g_strerror (errno));
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	return CAM_RETURN_OK;
	}

	/* read data from the module using the default timeout */
	static CamReturn
	cam_tl_read (CamTL * tl)
	{
	struct timeval timeout;

	timeout.tv_sec = READ_TIMEOUT_SEC;
	timeout.tv_usec = READ_TIMEOUT_USEC;

	return cam_tl_read_timeout (tl, &timeout);
	}

	/* get the number of bytes to allocate for a TPDU with a body of body_length
	* bytes. Also get the offset from the beginning of the buffer that marks the
	* position of the first byte of the TPDU body */
	void
	cam_tl_calc_buffer_size (CamTL * tl, guint body_length,
	guint * buffer_size, guint * offset)
	{
	guint length_field_len;

	/* the size of a TPDU is:
	* 1 byte slot number
	* 1 byte connection id
	* length_field_len bytes length field
	* 1 byte connection id
	* body_length bytes body
	*/

	/* get the length of the lenght_field block */
	length_field_len = cam_calc_length_field_size (body_length);

	*offset = 3 + length_field_len + 1;
	buffer_size = offset + body_length;
	}

	/* write the header of a TPDU
	* NOTE: this function assumes that the buffer is large enough to contain the
	* complete TPDU (see cam_tl_calc_buffer_size ()) and that enough space has been
	* left from the beginning of the buffer to write the TPDU header.
	*/
	static CamReturn
	cam_tl_connection_write_tpdu (CamTLConnection * connection,
	guint8 tag, guint8 * buffer, guint buffer_size, guint body_length)
	{
	int sret;
	CamTL *tl = connection->tl;
	guint8 length_field_len;

	/* slot number */
	buffer[0] = connection->slot;
	/* connection number */
	buffer[1] = connection->id;
	/* tag */
	buffer[2] = tag;
	/* length can take 1 to 4 bytes */
	length_field_len = cam_write_length_field (&buffer[3], body_length);
	buffer[3 + length_field_len] = connection->id;

	GST_DEBUG ("writing TPDU %x (%s) connection %d (size:%d)",
	buffer[2], tag_get_name (buffer[2]), connection->id, buffer_size);

	//cam_gst_util_dump_mem (buffer, buffer_size);

	sret = write (tl->fd, buffer, buffer_size);
	if (sret == -1) {
	GST_ERROR ("error witing TPDU (%d): %s", errno, g_strerror (errno));
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	tl->expected_tpdus += 1;

	GST_DEBUG ("Sucess writing tpdu 0x%x (%s)", buffer[2],
	tag_get_name (buffer[2]));

	return CAM_RETURN_OK;
	}

	/* convenience function to write control TPDUs (TPDUs having a single-byte body)
	*/
	static CamReturn
	cam_tl_connection_write_control_tpdu (CamTLConnection * connection, guint8 tag)
	{
	guint8 tpdu[5];

	/* TPDU layout (5 bytes):
	*
	* slot number (1 byte)
	* connection id (1 byte)
	* tag (1 byte)
	* length (1 byte)
	* connection id (1 byte)
	*/

	return cam_tl_connection_write_tpdu (connection, tag, tpdu, 5, 1);
	}

	/* read the next TPDU from the CAM */
	static CamReturn
	cam_tl_read_tpdu_next (CamTL * tl, CamTLConnection ** out_connection)
	{
	CamReturn ret;
	CamTLConnection *connection;
	guint8 connection_id;
	guint8 *tpdu;
	guint8 length_field_len;
	guint8 status;

	ret = cam_tl_read (tl);
	if (CAM_FAILED (ret))
	return ret;

	tpdu = tl->buffer;

	/* must hold at least slot, connection_id, 1byte length_field, connection_id
	*/
	if (tl->buffer_size < 4) {
	GST_ERROR ("invalid TPDU length %d", tl->buffer_size);
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	/* LPDU slot */
	/* slot = tpdu[0]; */
	/* LPDU connection id */
	connection_id = tpdu[1];

	connection = g_hash_table_lookup (tl->connections,
	GINT_TO_POINTER ((guint) connection_id));
	if (connection == NULL) {
	/* WHAT? */
	GST_ERROR ("CAM sent a TPDU on an unknown connection: %d", connection_id);
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	/* read the length_field () */
	length_field_len = cam_read_length_field (&tpdu[3], &tl->body_length);

	if (tl->body_length + 3 > tl->buffer_size) {
	GST_ERROR ("invalid TPDU length_field (%d) exceeds "
	"the size of the buffer (%d)", tl->body_length, tl->buffer_size);
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	/* skip slot + connection id + tag + lenght_field () + connection id */
	tl->body = tpdu + 4 + length_field_len;
	/* do not count the connection id byte as part of the body */
	tl->body_length -= 1;

	if (tl->buffer[tl->buffer_size - 4] != TAG_SB) {
	GST_ERROR ("no TAG_SB appended to TPDU");
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	status = tl->buffer[tl->buffer_size - 1];
	if (status & 0x80) {
	connection->has_data = TRUE;
	} else {
	connection->has_data = FALSE;
	}

	GST_DEBUG ("received TPDU %x (%s) more data %d", tpdu[2],
	tag_get_name (tpdu[2]), connection->has_data);
	tl->expected_tpdus -= 1;

	*out_connection = connection;

	return CAM_RETURN_OK;
	}

	/* create a connection with the module */
	CamReturn
	cam_tl_create_connection (CamTL * tl, guint8 slot,
	CamTLConnection ** connection)
	{
	CamReturn ret;
	CamTLConnection *conn = NULL;
	guint count = 10;

	if (tl->connection_ids == 255)
	return CAM_RETURN_TRANSPORT_TOO_MANY_CONNECTIONS;

	conn = cam_tl_connection_new (tl, ++tl->connection_ids);

	/* Some CA devices take a long time to set themselves up,
	* therefore retry every 250ms (for a maximum of 2.5s)
	*/
	while (TRUE) {
	/* send a TAG_CREATE_T_C TPDU */
	ret = cam_tl_connection_write_control_tpdu (conn, TAG_CREATE_T_C);
	if (!CAM_FAILED (ret))
	break;
	if (!count)
	goto error;
	GST_DEBUG ("Failed sending initial connection message .. but retrying");
	count--;
	/* Wait 250ms */
	g_usleep (G_USEC_PER_SEC / 4);
	}

	g_hash_table_insert (tl->connections, GINT_TO_POINTER (conn->id), conn);

	*connection = conn;

	return CAM_RETURN_OK;

	error:
	if (conn)
	cam_tl_connection_destroy (conn);

	return ret;
	}

	CamReturn
	cam_tl_connection_delete (CamTLConnection * connection)
	{
	CamReturn ret;

	ret = cam_tl_connection_write_control_tpdu (connection, TAG_DELETE_T_C);
	if (CAM_FAILED (ret))
	return ret;

	connection->state = CAM_TL_CONNECTION_STATE_IN_DELETION;

	return CAM_RETURN_OK;
	}

	static CamReturn
	handle_control_tpdu (CamTL * tl, CamTLConnection * connection)
	{
	if (tl->body_length != 0) {
	GST_ERROR ("got control tpdu of invalid length: %d", tl->body_length);
	return CAM_RETURN_TRANSPORT_ERROR;
	}

	switch (tl->buffer[2]) {
	/* create transport connection reply */
	case TAG_C_T_C_REPLY:
	/* a connection might be closed before it's acknowledged */
	if (connection->state != CAM_TL_CONNECTION_STATE_IN_DELETION) {
	GST_DEBUG ("connection created %d", connection->id);
	connection->state = CAM_TL_CONNECTION_STATE_OPEN;

	if (tl->connection_created)
	tl->connection_created (tl, connection);
	}
	break;
	/* delete transport connection reply */
	case TAG_D_T_C_REPLY:
	connection->state = CAM_TL_CONNECTION_STATE_CLOSED;
	GST_DEBUG ("connection closed %d", connection->id);

	if (tl->connection_deleted)
	tl->connection_deleted (tl, connection);

	g_hash_table_remove (tl->connections,
	GINT_TO_POINTER ((guint) connection->id));
	break;
	}

	return CAM_RETURN_OK;
	}

	static CamReturn
	handle_data_tpdu (CamTL * tl, CamTLConnection * connection)
	{
	if (tl->body_length == 0) {
	/* FIXME: figure out why this seems to happen from time to time with the
	* predator cam */
	GST_WARNING ("Empty data TPDU received");
	return CAM_RETURN_OK;
	}

	if (tl->connection_data)
	return tl->connection_data (tl, connection, tl->body, tl->body_length);

	return CAM_RETURN_OK;
	}

	static void
	foreach_connection_get (gpointer key, gpointer value, gpointer user_data)
	{
	GList lst = (GList ) user_data;

	lst = g_list_append (lst, value);
	}

	CamReturn
	cam_tl_connection_poll (CamTLConnection * connection, gboolean force)
	{
	CamReturn ret;

	if (connection->last_poll == NULL) {
	connection->last_poll = g_timer_new ();
	} else if (!force &&
	g_timer_elapsed (connection->last_poll, NULL) < POLL_INTERVAL) {
	return CAM_RETURN_TRANSPORT_POLL;
	}

	GST_DEBUG ("polling connection %d", connection->id);
	ret = cam_tl_connection_write_control_tpdu (connection, TAG_DATA_LAST);
	if (CAM_FAILED (ret))
	return ret;

	g_timer_start (connection->last_poll);

	return CAM_RETURN_OK;
	}

	/* read all the queued TPDUs */
	CamReturn
	cam_tl_read_all (CamTL * tl, gboolean poll)
	{
	CamReturn ret = CAM_RETURN_OK;
	CamTLConnection *connection;
	GList *connections = NULL;
	GList *walk;
	gboolean done = FALSE;

	while (!done) {
	while (tl->expected_tpdus) {
	/* read the next TPDU from the connection */
	ret = cam_tl_read_tpdu_next (tl, &connection);
	if (CAM_FAILED (ret)) {
	GST_ERROR ("error reading TPDU from module: %d", ret);
	goto out;
	}

	switch (tl->buffer[2]) {
	case TAG_C_T_C_REPLY:
	case TAG_D_T_C_REPLY:
	connection->empty_data = 0;
	ret = handle_control_tpdu (tl, connection);
	break;
	case TAG_DATA_MORE:
	case TAG_DATA_LAST:
	connection->empty_data = 0;
	ret = handle_data_tpdu (tl, connection);
	break;
	case TAG_SB:
	/* this is handled by tpdu_next */
	break;
	}

	if (CAM_FAILED (ret))
	goto out;
	}

	done = TRUE;

	connections = NULL;
	g_hash_table_foreach (tl->connections,
	foreach_connection_get, &connections);

	for (walk = connections; walk; walk = walk->next) {
	CamTLConnection *connection = CAM_TL_CONNECTION (walk->data);

	if (connection->has_data == TRUE && connection->empty_data < 10) {
	ret = cam_tl_connection_write_control_tpdu (connection, TAG_RCV);
	if (CAM_FAILED (ret)) {
	g_list_free (connections);
	goto out;
	}
	/* increment the empty_data counter. If we get data, this will be reset
	* to 0 */
	connection->empty_data++;
	done = FALSE;
	} else if (poll) {
	ret = cam_tl_connection_poll (connection, FALSE);
	if (ret == CAM_RETURN_TRANSPORT_POLL)
	continue;

	if (CAM_FAILED (ret)) {
	g_list_free (connections);
	goto out;
	}

	done = FALSE;
	}
	}

	g_list_free (connections);
	}

	out:
	return ret;
	}

	CamReturn
	cam_tl_connection_write (CamTLConnection * connection,
	guint8 * buffer, guint buffer_size, guint body_length)
	{
	return cam_tl_connection_write_tpdu (connection,
	TAG_DATA_LAST, buffer, buffer_size, 1 + body_length);
	}