开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
en50221.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：75k
源码类别：

midi

开发平台：

Unix_Linux

en50221.c：源码内容
  1. /*****************************************************************************
  2.  * en50221.c : implementation of the transport, session and applications
  3.  * layers of EN 50 221
  4.  *****************************************************************************
  5.  * Copyright (C) 2004-2005 the VideoLAN team
  6.  *
  7.  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  8.  * Based on code from libdvbci Copyright (C) 2000 Klaus Schmidinger
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA    02111, USA.
  23.  *****************************************************************************/
  25. #ifdef HAVE_CONFIG_H
  26. # include "config.h"
  27. #endif
  29. #include <vlc_common.h>
  30. #include <vlc_access.h>
  32. #include <sys/ioctl.h>
  33. #include <errno.h>
  35. #include <sys/types.h>
  36. #include <sys/stat.h>
  37. #include <fcntl.h>
  38. #include <time.h>
  39. #include <unistd.h>
  40. #include <sys/stat.h>
  41. #include <sys/poll.h>
  42. #include <netinet/in.h>
  44. /* DVB Card Drivers */
  45. #include <linux/dvb/version.h>
  46. #include <linux/dvb/dmx.h>
  47. #include <linux/dvb/frontend.h>
  48. #include <linux/dvb/ca.h>
  50. /* Include dvbpsi headers */
  51. #ifdef HAVE_DVBPSI_DR_H
  52. #   include <dvbpsi/dvbpsi.h>
  53. #   include <dvbpsi/descriptor.h>
  54. #   include <dvbpsi/pat.h>
  55. #   include <dvbpsi/pmt.h>
  56. #   include <dvbpsi/dr.h>
  57. #   include <dvbpsi/psi.h>
  58. #   include <dvbpsi/demux.h>
  59. #   include <dvbpsi/sdt.h>
  60. #else
  61. #   include "dvbpsi.h"
  62. #   include "descriptor.h"
  63. #   include "tables/pat.h"
  64. #   include "tables/pmt.h"
  65. #   include "descriptors/dr.h"
  66. #   include "psi.h"
  67. #   include "demux.h"
  68. #   include "tables/sdt.h"
  69. #endif
  71. #ifdef ENABLE_HTTPD
  72. #   include "vlc_httpd.h"
  73. #endif
  75. #include "dvb.h"
  77. #include <vlc_charset.h>
  79. #undef DEBUG_TPDU
  80. #define HLCI_WAIT_CAM_READY 0
  81. #define CAM_PROG_MAX MAX_PROGRAMS
  82. //#define CAPMT_WAIT 100             /* uncomment this for slow CAMs */
  84. static void ResourceManagerOpen( access_t * p_access, int i_session_id );
  85. static void ApplicationInformationOpen( access_t * p_access, int i_session_id );
  86. static void ConditionalAccessOpen( access_t * p_access, int i_session_id );
  87. static void DateTimeOpen( access_t * p_access, int i_session_id );
  88. static void MMIOpen( access_t * p_access, int i_session_id );
  90. /*****************************************************************************
  91.  * Utility functions
  92.  *****************************************************************************/
  93. #define SIZE_INDICATOR 0x80
  95. static uint8_t *GetLength( uint8_t *p_data, int *pi_length )
  96. {
  97.     *pi_length = *p_data++;
  99.     if ( (*pi_length & SIZE_INDICATOR) != 0 )
  100.     {
  101.         int l = *pi_length & ~SIZE_INDICATOR;
  102.         int i;
  104.         *pi_length = 0;
  105.         for ( i = 0; i < l; i++ )
  106.             *pi_length = (*pi_length << 8) | *p_data++;
  107.     }
  109.     return p_data;
  110. }
  112. static uint8_t *SetLength( uint8_t *p_data, int i_length )
  113. {
  114.     uint8_t *p = p_data;
  116.     if ( i_length < 128 )
  117.     {
  118.         *p++ = i_length;
  119.     }
  120.     else if ( i_length < 256 )
  121.     {
  122.         *p++ = SIZE_INDICATOR | 0x1;
  123.         *p++ = i_length;
  124.     }
  125.     else if ( i_length < 65536 )
  126.     {
  127.         *p++ = SIZE_INDICATOR | 0x2;
  128.         *p++ = i_length >> 8;
  129.         *p++ = i_length & 0xff;
  130.     }
  131.     else if ( i_length < 16777216 )
  132.     {
  133.         *p++ = SIZE_INDICATOR | 0x3;
  134.         *p++ = i_length >> 16;
  135.         *p++ = (i_length >> 8) & 0xff;
  136.         *p++ = i_length & 0xff;
  137.     }
  138.     else
  139.     {
  140.         *p++ = SIZE_INDICATOR | 0x4;
  141.         *p++ = i_length >> 24;
  142.         *p++ = (i_length >> 16) & 0xff;
  143.         *p++ = (i_length >> 8) & 0xff;
  144.         *p++ = i_length & 0xff;
  145.     }
  147.     return p;
  148. }
  151. /*
  152.  * Transport layer
  153.  */
  155. #define MAX_TPDU_SIZE  4096
  156. #define MAX_TPDU_DATA  (MAX_TPDU_SIZE - 4)
  158. #define DATA_INDICATOR 0x80
  160. #define T_SB           0x80
  161. #define T_RCV          0x81
  162. #define T_CREATE_TC    0x82
  163. #define T_CTC_REPLY    0x83
  164. #define T_DELETE_TC    0x84
  165. #define T_DTC_REPLY    0x85
  166. #define T_REQUEST_TC   0x86
  167. #define T_NEW_TC       0x87
  168. #define T_TC_ERROR     0x88
  169. #define T_DATA_LAST    0xA0
  170. #define T_DATA_MORE    0xA1
  172. static void Dump( bool b_outgoing, uint8_t *p_data, int i_size )
  173. {
  174. #ifdef DEBUG_TPDU
  175.     int i;
  176. #define MAX_DUMP 256
  177.     fprintf(stderr, "%s ", b_outgoing ? "-->" : "<--");
  178.     for ( i = 0; i < i_size && i < MAX_DUMP; i++)
  179.         fprintf(stderr, "%02X ", p_data[i]);
  180.     fprintf(stderr, "%sn", i_size >= MAX_DUMP ? "..." : "");
  181. #else
  182.     VLC_UNUSED(b_outgoing); VLC_UNUSED(p_data); VLC_UNUSED(i_size);
  183. #endif
  184. }
  186. /*****************************************************************************
  187.  * TPDUSend
  188.  *****************************************************************************/
  189. static int TPDUSend( access_t * p_access, uint8_t i_slot, uint8_t i_tag,
  190.                      const uint8_t *p_content, int i_length )
  191. {
  192.     access_sys_t *p_sys = p_access->p_sys;
  193.     uint8_t i_tcid = i_slot + 1;
  194.     uint8_t p_data[MAX_TPDU_SIZE];
  195.     int i_size;
  197.     i_size = 0;
  198.     p_data[0] = i_slot;
  199.     p_data[1] = i_tcid;
  200.     p_data[2] = i_tag;
  202.     switch ( i_tag )
  203.     {
  204.     case T_RCV:
  205.     case T_CREATE_TC:
  206.     case T_CTC_REPLY:
  207.     case T_DELETE_TC:
  208.     case T_DTC_REPLY:
  209.     case T_REQUEST_TC:
  210.         p_data[3] = 1; /* length */
  211.         p_data[4] = i_tcid;
  212.         i_size = 5;
  213.         break;
  215.     case T_NEW_TC:
  216.     case T_TC_ERROR:
  217.         p_data[3] = 2; /* length */
  218.         p_data[4] = i_tcid;
  219.         p_data[5] = p_content[0];
  220.         i_size = 6;
  221.         break;
  223.     case T_DATA_LAST:
  224.     case T_DATA_MORE:
  225.     {
  226.         /* i_length <= MAX_TPDU_DATA */
  227.         uint8_t *p = p_data + 3;
  228.         p = SetLength( p, i_length + 1 );
  229.         *p++ = i_tcid;
  231.         if ( i_length )
  232.             memcpy( p, p_content, i_length );
  233.             i_size = i_length + (p - p_data);
  234.         }
  235.         break;
  237.     default:
  238.         break;
  239.     }
  240.     Dump( true, p_data, i_size );
  242.     if ( write( p_sys->i_ca_handle, p_data, i_size ) != i_size )
  243.     {
  244.         msg_Err( p_access, "cannot write to CAM device (%m)" );
  245.         return VLC_EGENERIC;
  246.     }
  248.     return VLC_SUCCESS;
  249. }
  252. /*****************************************************************************
  253.  * TPDURecv
  254.  *****************************************************************************/
  255. #define CAM_READ_TIMEOUT  3500 // ms
  257. static int TPDURecv( access_t * p_access, uint8_t i_slot, uint8_t *pi_tag,
  258.                      uint8_t *p_data, int *pi_size )
  259. {
  260.     access_sys_t *p_sys = p_access->p_sys;
  261.     uint8_t i_tcid = i_slot + 1;
  262.     int i_size;
  263.     struct pollfd pfd[1];
  265.     pfd[0].fd = p_sys->i_ca_handle;
  266.     pfd[0].events = POLLIN;
  267.     if ( !(poll(pfd, 1, CAM_READ_TIMEOUT) > 0 && (pfd[0].revents & POLLIN)) )
  268.     {
  269.         msg_Err( p_access, "cannot poll from CAM device" );
  270.         return VLC_EGENERIC;
  271.     }
  273.     if ( pi_size == NULL )
  274.     {
  275.         p_data = malloc( MAX_TPDU_SIZE );
  276.     }
  278.     for ( ; ; )
  279.     {
  280.         i_size = read( p_sys->i_ca_handle, p_data, MAX_TPDU_SIZE );
  282.         if ( i_size >= 0 || errno != EINTR )
  283.             break;
  284.     }
  286.     if ( i_size < 5 )
  287.     {
  288.         msg_Err( p_access, "cannot read from CAM device (%d:%m)", i_size );
  289.         if( pi_size == NULL )
  290.             free( p_data );
  291.         return VLC_EGENERIC;
  292.     }
  294.     if ( p_data[1] != i_tcid )
  295.     {
  296.         msg_Err( p_access, "invalid read from CAM device (%d instead of %d)",
  297.                  p_data[1], i_tcid );
  298.         if( pi_size == NULL )
  299.             free( p_data );
  300.         return VLC_EGENERIC;
  301.     }
  303.     *pi_tag = p_data[2];
  304.     p_sys->pb_tc_has_data[i_slot] = (i_size >= 4
  305.                                       && p_data[i_size - 4] == T_SB
  306.                                       && p_data[i_size - 3] == 2
  307.                                       && (p_data[i_size - 1] & DATA_INDICATOR))
  308.                                         ?  true : false;
  310.     Dump( false, p_data, i_size );
  312.     if ( pi_size == NULL )
  313.         free( p_data );
  314.     else
  315.         *pi_size = i_size;
  317.     return VLC_SUCCESS;
  318. }
  321. /*
  322.  * Session layer
  323.  */
  325. #define ST_SESSION_NUMBER           0x90
  326. #define ST_OPEN_SESSION_REQUEST     0x91
  327. #define ST_OPEN_SESSION_RESPONSE    0x92
  328. #define ST_CREATE_SESSION           0x93
  329. #define ST_CREATE_SESSION_RESPONSE  0x94
  330. #define ST_CLOSE_SESSION_REQUEST    0x95
  331. #define ST_CLOSE_SESSION_RESPONSE   0x96
  333. #define SS_OK             0x00
  334. #define SS_NOT_ALLOCATED  0xF0
  336. #define RI_RESOURCE_MANAGER            0x00010041
  337. #define RI_APPLICATION_INFORMATION     0x00020041
  338. #define RI_CONDITIONAL_ACCESS_SUPPORT  0x00030041
  339. #define RI_HOST_CONTROL                0x00200041
  340. #define RI_DATE_TIME                   0x00240041
  341. #define RI_MMI                         0x00400041
  343. static int ResourceIdToInt( uint8_t *p_data )
  344. {
  345.     return ((int)p_data[0] << 24) | ((int)p_data[1] << 16)
  346.             | ((int)p_data[2] << 8) | p_data[3];
  347. }
  349. /*****************************************************************************
  350.  * SPDUSend
  351.  *****************************************************************************/
  352. static int SPDUSend( access_t * p_access, int i_session_id,
  353.                      uint8_t *p_data, int i_size )
  354. {
  355.     access_sys_t *p_sys = p_access->p_sys;
  356.     uint8_t *p_spdu = malloc( i_size + 4 );
  357.     uint8_t *p = p_spdu;
  358.     uint8_t i_tag;
  359.     uint8_t i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  361.     *p++ = ST_SESSION_NUMBER;
  362.     *p++ = 0x02;
  363.     *p++ = (i_session_id >> 8);
  364.     *p++ = i_session_id & 0xff;
  366.     memcpy( p, p_data, i_size );
  368.     i_size += 4;
  369.     p = p_spdu;
  371.     while ( i_size > 0 )
  372.     {
  373.         if ( i_size > MAX_TPDU_DATA )
  374.         {
  375.             if ( TPDUSend( p_access, i_slot, T_DATA_MORE, p,
  376.                            MAX_TPDU_DATA ) != VLC_SUCCESS )
  377.             {
  378.                 msg_Err( p_access, "couldn't send TPDU on session %d",
  379.                          i_session_id );
  380.                 free( p_spdu );
  381.                 return VLC_EGENERIC;
  382.             }
  383.             p += MAX_TPDU_DATA;
  384.             i_size -= MAX_TPDU_DATA;
  385.         }
  386.         else
  387.         {
  388.             if ( TPDUSend( p_access, i_slot, T_DATA_LAST, p, i_size )
  389.                     != VLC_SUCCESS )
  390.             {
  391.                 msg_Err( p_access, "couldn't send TPDU on session %d",
  392.                          i_session_id );
  393.                 free( p_spdu );
  394.                 return VLC_EGENERIC;
  395.             }
  396.             i_size = 0;
  397.         }
  399.         if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) != VLC_SUCCESS
  400.                || i_tag != T_SB )
  401.         {
  402.             msg_Err( p_access, "couldn't recv TPDU on session %d",
  403.                      i_session_id );
  404.             free( p_spdu );
  405.             return VLC_EGENERIC;
  406.         }
  407.     }
  409.     free( p_spdu );
  410.     return VLC_SUCCESS;
  411. }
  413. /*****************************************************************************
  414.  * SessionOpen
  415.  *****************************************************************************/
  416. static void SessionOpen( access_t * p_access, uint8_t i_slot,
  417.                          uint8_t *p_spdu, int i_size )
  418. {
  419.     access_sys_t *p_sys = p_access->p_sys;
  420.     int i_session_id;
  421.     int i_resource_id = ResourceIdToInt( &p_spdu[2] );
  422.     uint8_t p_response[16];
  423.     int i_status = SS_NOT_ALLOCATED;
  424.     uint8_t i_tag;
  426.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  427.     {
  428.         if ( !p_sys->p_sessions[i_session_id - 1].i_resource_id )
  429.             break;
  430.     }
  431.     if ( i_session_id > MAX_SESSIONS )
  432.     {
  433.         msg_Err( p_access, "too many sessions !" );
  434.         return;
  435.     }
  436.     p_sys->p_sessions[i_session_id - 1].i_slot = i_slot;
  437.     p_sys->p_sessions[i_session_id - 1].i_resource_id = i_resource_id;
  438.     p_sys->p_sessions[i_session_id - 1].pf_close = NULL;
  439.     p_sys->p_sessions[i_session_id - 1].pf_manage = NULL;
  441.     if ( i_resource_id == RI_RESOURCE_MANAGER
  442.           || i_resource_id == RI_APPLICATION_INFORMATION
  443.           || i_resource_id == RI_CONDITIONAL_ACCESS_SUPPORT
  444.           || i_resource_id == RI_DATE_TIME
  445.           || i_resource_id == RI_MMI )
  446.     {
  447.         i_status = SS_OK;
  448.     }
  450.     p_response[0] = ST_OPEN_SESSION_RESPONSE;
  451.     p_response[1] = 0x7;
  452.     p_response[2] = i_status;
  453.     p_response[3] = p_spdu[2];
  454.     p_response[4] = p_spdu[3];
  455.     p_response[5] = p_spdu[4];
  456.     p_response[6] = p_spdu[5];
  457.     p_response[7] = i_session_id >> 8;
  458.     p_response[8] = i_session_id & 0xff;
  460.     if ( TPDUSend( p_access, i_slot, T_DATA_LAST, p_response, 9 ) !=
  461.             VLC_SUCCESS )
  462.     {
  463.         msg_Err( p_access,
  464.                  "SessionOpen: couldn't send TPDU on slot %d", i_slot );
  465.         return;
  466.     }
  467.     if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) != VLC_SUCCESS )
  468.     {
  469.         msg_Err( p_access,
  470.                  "SessionOpen: couldn't recv TPDU on slot %d", i_slot );
  471.         return;
  472.     }
  474.     switch ( i_resource_id )
  475.     {
  476.     case RI_RESOURCE_MANAGER:
  477.         ResourceManagerOpen( p_access, i_session_id ); break;
  478.     case RI_APPLICATION_INFORMATION:
  479.         ApplicationInformationOpen( p_access, i_session_id ); break;
  480.     case RI_CONDITIONAL_ACCESS_SUPPORT:
  481.         ConditionalAccessOpen( p_access, i_session_id ); break;
  482.     case RI_DATE_TIME:
  483.         DateTimeOpen( p_access, i_session_id ); break;
  484.     case RI_MMI:
  485.         MMIOpen( p_access, i_session_id ); break;
  487.     case RI_HOST_CONTROL:
  488.     default:
  489.         msg_Err( p_access, "unknown resource id (0x%x)", i_resource_id );
  490.         p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  491.     }
  492. }
  494. #if 0
  495. /* unused code for the moment - commented out to keep gcc happy */
  496. /*****************************************************************************
  497.  * SessionCreate
  498.  *****************************************************************************/
  499. static void SessionCreate( access_t * p_access, int i_slot, int i_resource_id )
  500. {
  501.     access_sys_t *p_sys = p_access->p_sys;
  502.     uint8_t p_response[16];
  503.     uint8_t i_tag;
  504.     int i_session_id;
  506.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  507.     {
  508.         if ( !p_sys->p_sessions[i_session_id - 1].i_resource_id )
  509.             break;
  510.     }
  511.     if ( i_session_id == MAX_SESSIONS )
  512.     {
  513.         msg_Err( p_access, "too many sessions !" );
  514.         return;
  515.     }
  516.     p_sys->p_sessions[i_session_id - 1].i_slot = i_slot;
  517.     p_sys->p_sessions[i_session_id - 1].i_resource_id = i_resource_id;
  518.     p_sys->p_sessions[i_session_id - 1].pf_close = NULL;
  519.     p_sys->p_sessions[i_session_id - 1].pf_manage = NULL;
  520.     p_sys->p_sessions[i_session_id - 1].p_sys = NULL;
  522.     p_response[0] = ST_CREATE_SESSION;
  523.     p_response[1] = 0x6;
  524.     p_response[2] = i_resource_id >> 24;
  525.     p_response[3] = (i_resource_id >> 16) & 0xff;
  526.     p_response[4] = (i_resource_id >> 8) & 0xff;
  527.     p_response[5] = i_resource_id & 0xff;
  528.     p_response[6] = i_session_id >> 8;
  529.     p_response[7] = i_session_id & 0xff;
  531.     if ( TPDUSend( p_access, i_slot, T_DATA_LAST, p_response, 4 ) !=
  532.             VLC_SUCCESS )
  533.     {
  534.         msg_Err( p_access,
  535.                  "SessionCreate: couldn't send TPDU on slot %d", i_slot );
  536.         return;
  537.     }
  538.     if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) != VLC_SUCCESS )
  539.     {
  540.         msg_Err( p_access,
  541.                  "SessionCreate: couldn't recv TPDU on slot %d", i_slot );
  542.         return;
  543.     }
  544. }
  545. #endif
  547. /*****************************************************************************
  548.  * SessionCreateResponse
  549.  *****************************************************************************/
  550. static void SessionCreateResponse( access_t * p_access, uint8_t i_slot,
  551.                                    uint8_t *p_spdu, int i_size )
  552. {
  553.     access_sys_t *p_sys = p_access->p_sys;
  554.     int i_status = p_spdu[2];
  555.     int i_resource_id = ResourceIdToInt( &p_spdu[3] );
  556.     int i_session_id = ((int)p_spdu[7] << 8) | p_spdu[8];
  558.     if ( i_status != SS_OK )
  559.     {
  560.         msg_Err( p_access, "SessionCreateResponse: failed to open session %d"
  561.                  " resource=0x%x status=0x%x", i_session_id, i_resource_id,
  562.                  i_status );
  563.         p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  564.         return;
  565.     }
  567.     switch ( i_resource_id )
  568.     {
  569.     case RI_RESOURCE_MANAGER:
  570.         ResourceManagerOpen( p_access, i_session_id ); break;
  571.     case RI_APPLICATION_INFORMATION:
  572.         ApplicationInformationOpen( p_access, i_session_id ); break;
  573.     case RI_CONDITIONAL_ACCESS_SUPPORT:
  574.         ConditionalAccessOpen( p_access, i_session_id ); break;
  575.     case RI_DATE_TIME:
  576.         DateTimeOpen( p_access, i_session_id ); break;
  577.     case RI_MMI:
  578.         MMIOpen( p_access, i_session_id ); break;
  580.     case RI_HOST_CONTROL:
  581.     default:
  582.         msg_Err( p_access, "unknown resource id (0x%x)", i_resource_id );
  583.         p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  584.     }
  585. }
  587. /*****************************************************************************
  588.  * SessionSendClose
  589.  *****************************************************************************/
  590. static void SessionSendClose( access_t * p_access, int i_session_id )
  591. {
  592.     access_sys_t *p_sys = p_access->p_sys;
  593.     uint8_t p_response[16];
  594.     uint8_t i_tag;
  595.     uint8_t i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  597.     p_response[0] = ST_CLOSE_SESSION_REQUEST;
  598.     p_response[1] = 0x2;
  599.     p_response[2] = i_session_id >> 8;
  600.     p_response[3] = i_session_id & 0xff;
  602.     if ( TPDUSend( p_access, i_slot, T_DATA_LAST, p_response, 4 ) !=
  603.             VLC_SUCCESS )
  604.     {
  605.         msg_Err( p_access,
  606.                  "SessionSendClose: couldn't send TPDU on slot %d", i_slot );
  607.         return;
  608.     }
  609.     if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) != VLC_SUCCESS )
  610.     {
  611.         msg_Err( p_access,
  612.                  "SessionSendClose: couldn't recv TPDU on slot %d", i_slot );
  613.         return;
  614.     }
  615. }
  617. /*****************************************************************************
  618.  * SessionClose
  619.  *****************************************************************************/
  620. static void SessionClose( access_t * p_access, int i_session_id )
  621. {
  622.     access_sys_t *p_sys = p_access->p_sys;
  623.     uint8_t p_response[16];
  624.     uint8_t i_tag;
  625.     uint8_t i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  627.     if ( p_sys->p_sessions[i_session_id - 1].pf_close != NULL )
  628.         p_sys->p_sessions[i_session_id - 1].pf_close( p_access, i_session_id );
  629.     p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  631.     p_response[0] = ST_CLOSE_SESSION_RESPONSE;
  632.     p_response[1] = 0x3;
  633.     p_response[2] = SS_OK;
  634.     p_response[3] = i_session_id >> 8;
  635.     p_response[4] = i_session_id & 0xff;
  637.     if ( TPDUSend( p_access, i_slot, T_DATA_LAST, p_response, 5 ) !=
  638.             VLC_SUCCESS )
  639.     {
  640.         msg_Err( p_access,
  641.                  "SessionClose: couldn't send TPDU on slot %d", i_slot );
  642.         return;
  643.     }
  644.     if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) != VLC_SUCCESS )
  645.     {
  646.         msg_Err( p_access,
  647.                  "SessionClose: couldn't recv TPDU on slot %d", i_slot );
  648.         return;
  649.     }
  650. }
  652. /*****************************************************************************
  653.  * SPDUHandle
  654.  *****************************************************************************/
  655. static void SPDUHandle( access_t * p_access, uint8_t i_slot,
  656.                         uint8_t *p_spdu, int i_size )
  657. {
  658.     access_sys_t *p_sys = p_access->p_sys;
  659.     int i_session_id;
  661.     switch ( p_spdu[0] )
  662.     {
  663.     case ST_SESSION_NUMBER:
  664.         if ( i_size <= 4 )
  665.             return;
  666.         i_session_id = ((int)p_spdu[2] << 8) | p_spdu[3];
  667.         p_sys->p_sessions[i_session_id - 1].pf_handle( p_access, i_session_id,
  668.                                                        p_spdu + 4, i_size - 4 );
  669.         break;
  671.     case ST_OPEN_SESSION_REQUEST:
  672.         if ( i_size != 6 || p_spdu[1] != 0x4 )
  673.             return;
  674.         SessionOpen( p_access, i_slot, p_spdu, i_size );
  675.         break;
  677.     case ST_CREATE_SESSION_RESPONSE:
  678.         if ( i_size != 9 || p_spdu[1] != 0x7 )
  679.             return;
  680.         SessionCreateResponse( p_access, i_slot, p_spdu, i_size );
  681.         break;
  683.     case ST_CLOSE_SESSION_REQUEST:
  684.         if ( i_size != 4 || p_spdu[1] != 0x2 )
  685.             return;
  686.         i_session_id = ((int)p_spdu[2] << 8) | p_spdu[3];
  687.         SessionClose( p_access, i_session_id );
  688.         break;
  690.     case ST_CLOSE_SESSION_RESPONSE:
  691.         if ( i_size != 5 || p_spdu[1] != 0x3 )
  692.             return;
  693.         i_session_id = ((int)p_spdu[3] << 8) | p_spdu[4];
  694.         if ( p_spdu[2] )
  695.         {
  696.             msg_Err( p_access, "closing a session which is not allocated (%d)",
  697.                      i_session_id );
  698.         }
  699.         else
  700.         {
  701.             if ( p_sys->p_sessions[i_session_id - 1].pf_close != NULL )
  702.                 p_sys->p_sessions[i_session_id - 1].pf_close( p_access,
  703.                                                               i_session_id );
  704.             p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  705.         }
  706.         break;
  708.     default:
  709.         msg_Err( p_access, "unexpected tag in SPDUHandle (%x)", p_spdu[0] );
  710.         break;
  711.     }
  712. }
  715. /*
  716.  * Application layer
  717.  */
  719. #define AOT_NONE                    0x000000
  720. #define AOT_PROFILE_ENQ             0x9F8010
  721. #define AOT_PROFILE                 0x9F8011
  722. #define AOT_PROFILE_CHANGE          0x9F8012
  723. #define AOT_APPLICATION_INFO_ENQ    0x9F8020
  724. #define AOT_APPLICATION_INFO        0x9F8021
  725. #define AOT_ENTER_MENU              0x9F8022
  726. #define AOT_CA_INFO_ENQ             0x9F8030
  727. #define AOT_CA_INFO                 0x9F8031
  728. #define AOT_CA_PMT                  0x9F8032
  729. #define AOT_CA_PMT_REPLY            0x9F8033
  730. #define AOT_TUNE                    0x9F8400
  731. #define AOT_REPLACE                 0x9F8401
  732. #define AOT_CLEAR_REPLACE           0x9F8402
  733. #define AOT_ASK_RELEASE             0x9F8403
  734. #define AOT_DATE_TIME_ENQ           0x9F8440
  735. #define AOT_DATE_TIME               0x9F8441
  736. #define AOT_CLOSE_MMI               0x9F8800
  737. #define AOT_DISPLAY_CONTROL         0x9F8801
  738. #define AOT_DISPLAY_REPLY           0x9F8802
  739. #define AOT_TEXT_LAST               0x9F8803
  740. #define AOT_TEXT_MORE               0x9F8804
  741. #define AOT_KEYPAD_CONTROL          0x9F8805
  742. #define AOT_KEYPRESS                0x9F8806
  743. #define AOT_ENQ                     0x9F8807
  744. #define AOT_ANSW                    0x9F8808
  745. #define AOT_MENU_LAST               0x9F8809
  746. #define AOT_MENU_MORE               0x9F880A
  747. #define AOT_MENU_ANSW               0x9F880B
  748. #define AOT_LIST_LAST               0x9F880C
  749. #define AOT_LIST_MORE               0x9F880D
  750. #define AOT_SUBTITLE_SEGMENT_LAST   0x9F880E
  751. #define AOT_SUBTITLE_SEGMENT_MORE   0x9F880F
  752. #define AOT_DISPLAY_MESSAGE         0x9F8810
  753. #define AOT_SCENE_END_MARK          0x9F8811
  754. #define AOT_SCENE_DONE              0x9F8812
  755. #define AOT_SCENE_CONTROL           0x9F8813
  756. #define AOT_SUBTITLE_DOWNLOAD_LAST  0x9F8814
  757. #define AOT_SUBTITLE_DOWNLOAD_MORE  0x9F8815
  758. #define AOT_FLUSH_DOWNLOAD          0x9F8816
  759. #define AOT_DOWNLOAD_REPLY          0x9F8817
  760. #define AOT_COMMS_CMD               0x9F8C00
  761. #define AOT_CONNECTION_DESCRIPTOR   0x9F8C01
  762. #define AOT_COMMS_REPLY             0x9F8C02
  763. #define AOT_COMMS_SEND_LAST         0x9F8C03
  764. #define AOT_COMMS_SEND_MORE         0x9F8C04
  765. #define AOT_COMMS_RCV_LAST          0x9F8C05
  766. #define AOT_COMMS_RCV_MORE          0x9F8C06
  768. /*****************************************************************************
  769.  * APDUGetTag
  770.  *****************************************************************************/
  771. static int APDUGetTag( const uint8_t *p_apdu, int i_size )
  772. {
  773.     if ( i_size >= 3 )
  774.     {
  775.         int i, t = 0;
  776.         for ( i = 0; i < 3; i++ )
  777.             t = (t << 8) | *p_apdu++;
  778.         return t;
  779.     }
  781.     return AOT_NONE;
  782. }
  784. /*****************************************************************************
  785.  * APDUGetLength
  786.  *****************************************************************************/
  787. static uint8_t *APDUGetLength( uint8_t *p_apdu, int *pi_size )
  788. {
  789.     return GetLength( &p_apdu[3], pi_size );
  790. }
  792. /*****************************************************************************
  793.  * APDUSend
  794.  *****************************************************************************/
  795. static int APDUSend( access_t * p_access, int i_session_id, int i_tag,
  796.                      uint8_t *p_data, int i_size )
  797. {
  798.     access_sys_t *p_sys = p_access->p_sys;
  799.     uint8_t *p_apdu = malloc( i_size + 12 );
  800.     uint8_t *p = p_apdu;
  801.     ca_msg_t ca_msg;
  802.     int i_ret;
  804.     *p++ = (i_tag >> 16);
  805.     *p++ = (i_tag >> 8) & 0xff;
  806.     *p++ = i_tag & 0xff;
  807.     p = SetLength( p, i_size );
  808.     if ( i_size )
  809.         memcpy( p, p_data, i_size );
  810.     if ( p_sys->i_ca_type == CA_CI_LINK )
  811.     {
  812.         i_ret = SPDUSend( p_access, i_session_id, p_apdu, i_size + p - p_apdu );
  813.     }
  814.     else
  815.     {
  816.         if ( i_size + p - p_apdu > 256 )
  817.         {
  818.             msg_Err( p_access, "CAM: apdu overflow" );
  819.             i_ret = VLC_EGENERIC;
  820.         }
  821.         else
  822.         {
  823.             ca_msg.length = i_size + p - p_apdu;
  824.             if ( i_size == 0 ) ca_msg.length=3;
  825.             memcpy( ca_msg.msg, p_apdu, i_size + p - p_apdu );
  826.             i_ret = ioctl(p_sys->i_ca_handle, CA_SEND_MSG, &ca_msg );
  827.             if ( i_ret < 0 )
  828.             {
  829.                 msg_Err( p_access, "Error sending to CAM: %m" );
  830.                 i_ret = VLC_EGENERIC;
  831.             }
  832.         }
  833.     }
  834.     free( p_apdu );
  835.     return i_ret;
  836. }
  838. /*
  839.  * Resource Manager
  840.  */
  842. /*****************************************************************************
  843.  * ResourceManagerHandle
  844.  *****************************************************************************/
  845. static void ResourceManagerHandle( access_t * p_access, int i_session_id,
  846.                                    uint8_t *p_apdu, int i_size )
  847. {
  848.     int i_tag = APDUGetTag( p_apdu, i_size );
  850.     switch ( i_tag )
  851.     {
  852.     case AOT_PROFILE_ENQ:
  853.     {
  854.         int resources[] = { htonl(RI_RESOURCE_MANAGER),
  855.                             htonl(RI_APPLICATION_INFORMATION),
  856.                             htonl(RI_CONDITIONAL_ACCESS_SUPPORT),
  857.                             htonl(RI_DATE_TIME),
  858.                             htonl(RI_MMI)
  859.                           };
  860.         APDUSend( p_access, i_session_id, AOT_PROFILE, (uint8_t*)resources,
  861.                   sizeof(resources) );
  862.         break;
  863.     }
  864.     case AOT_PROFILE:
  865.         APDUSend( p_access, i_session_id, AOT_PROFILE_CHANGE, NULL, 0 );
  866.         break;
  868.     default:
  869.         msg_Err( p_access, "unexpected tag in ResourceManagerHandle (0x%x)",
  870.                  i_tag );
  871.     }
  872. }
  874. /*****************************************************************************
  875.  * ResourceManagerOpen
  876.  *****************************************************************************/
  877. static void ResourceManagerOpen( access_t * p_access, int i_session_id )
  878. {
  879.     access_sys_t *p_sys = p_access->p_sys;
  881.     msg_Dbg( p_access, "opening ResourceManager session (%d)", i_session_id );
  883.     p_sys->p_sessions[i_session_id - 1].pf_handle = ResourceManagerHandle;
  885.     APDUSend( p_access, i_session_id, AOT_PROFILE_ENQ, NULL, 0 );
  886. }
  888. /*
  889.  * Application Information
  890.  */
  892. /*****************************************************************************
  893.  * ApplicationInformationEnterMenu
  894.  *****************************************************************************/
  895. static void ApplicationInformationEnterMenu( access_t * p_access,
  896.                                              int i_session_id )
  897. {
  898.     access_sys_t *p_sys = p_access->p_sys;
  899.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  901.     msg_Dbg( p_access, "entering MMI menus on session %d", i_session_id );
  902.     APDUSend( p_access, i_session_id, AOT_ENTER_MENU, NULL, 0 );
  903.     p_sys->pb_slot_mmi_expected[i_slot] = true;
  904. }
  906. /*****************************************************************************
  907.  * ApplicationInformationHandle
  908.  *****************************************************************************/
  909. static void ApplicationInformationHandle( access_t * p_access, int i_session_id,
  910.                                           uint8_t *p_apdu, int i_size )
  911. {
  912.     int i_tag = APDUGetTag( p_apdu, i_size );
  914.     switch ( i_tag )
  915.     {
  916.     case AOT_APPLICATION_INFO:
  917.     {
  918.         int i_type, i_manufacturer, i_code;
  919.         int l = 0;
  920.         uint8_t *d = APDUGetLength( p_apdu, &l );
  922.         if ( l < 4 ) break;
  923.         p_apdu[l + 4] = '';
  925.         i_type = *d++;
  926.         i_manufacturer = ((int)d[0] << 8) | d[1];
  927.         d += 2;
  928.         i_code = ((int)d[0] << 8) | d[1];
  929.         d += 2;
  930.         d = GetLength( d, &l );
  931.         d[l] = '';
  932.         msg_Info( p_access, "CAM: %s, %02X, %04X, %04X",
  933.                   d, i_type, i_manufacturer, i_code );
  934.         break;
  935.     }
  936.     default:
  937.         msg_Err( p_access,
  938.                  "unexpected tag in ApplicationInformationHandle (0x%x)",
  939.                  i_tag );
  940.     }
  941. }
  943. /*****************************************************************************
  944.  * ApplicationInformationOpen
  945.  *****************************************************************************/
  946. static void ApplicationInformationOpen( access_t * p_access, int i_session_id )
  947. {
  948.     access_sys_t *p_sys = p_access->p_sys;
  950.     msg_Dbg( p_access, "opening ApplicationInformation session (%d)", i_session_id );
  952.     p_sys->p_sessions[i_session_id - 1].pf_handle = ApplicationInformationHandle;
  954.     APDUSend( p_access, i_session_id, AOT_APPLICATION_INFO_ENQ, NULL, 0 );
  955. }
  957. /*
  958.  * Conditional Access
  959.  */
  961. #define MAX_CASYSTEM_IDS 64
  963. typedef struct
  964. {
  965.     uint16_t pi_system_ids[MAX_CASYSTEM_IDS + 1];
  966. } system_ids_t;
  968. static bool CheckSystemID( system_ids_t *p_ids, uint16_t i_id )
  969. {
  970.     int i = 0;
  971.     if( !p_ids ) return true;      /* dummy session for high-level CI intf */
  973.     while ( p_ids->pi_system_ids[i] )
  974.     {
  975.         if ( p_ids->pi_system_ids[i] == i_id )
  976.             return true;
  977.         i++;
  978.     }
  980.     return false;
  981. }
  983. /*****************************************************************************
  984.  * CAPMTNeedsDescrambling
  985.  *****************************************************************************/
  986. static bool CAPMTNeedsDescrambling( dvbpsi_pmt_t *p_pmt )
  987. {
  988.     dvbpsi_descriptor_t *p_dr;
  989.     dvbpsi_pmt_es_t *p_es;
  991.     for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
  992.     {
  993.         if( p_dr->i_tag == 0x9 )
  994.         {
  995.             return true;
  996.         }
  997.     }
  998.  
  999.     for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
  1000.     {
  1001.         for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
  1002.              p_dr = p_dr->p_next )
  1003.         {
  1004.             if( p_dr->i_tag == 0x9 )
  1005.             {
  1006.                 return true;
  1007.             }
  1008.         }
  1009.     }
  1011.     return false;
  1012. }
  1014. /*****************************************************************************
  1015.  * CAPMTBuild
  1016.  *****************************************************************************/
  1017. static int GetCADSize( system_ids_t *p_ids, dvbpsi_descriptor_t *p_dr )
  1018. {
  1019.     int i_cad_size = 0;
  1021.     while ( p_dr != NULL )
  1022.     {
  1023.         if( p_dr->i_tag == 0x9 )
  1024.         {
  1025.             uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
  1026.                                     | p_dr->p_data[1];
  1027.             if ( CheckSystemID( p_ids, i_sysid ) )
  1028.                 i_cad_size += p_dr->i_length + 2;
  1029.         }
  1030.         p_dr = p_dr->p_next;
  1031.     }
  1033.     return i_cad_size;
  1034. }
  1036. static uint8_t *CAPMTHeader( system_ids_t *p_ids, uint8_t i_list_mgt,
  1037.                              uint16_t i_program_number, uint8_t i_version,
  1038.                              int i_size, dvbpsi_descriptor_t *p_dr,
  1039.                              uint8_t i_cmd )
  1040. {
  1041.     uint8_t *p_data;
  1043.     if ( i_size )
  1044.         p_data = malloc( 7 + i_size );
  1045.     else
  1046.         p_data = malloc( 6 );
  1048.     p_data[0] = i_list_mgt;
  1049.     p_data[1] = i_program_number >> 8;
  1050.     p_data[2] = i_program_number & 0xff;
  1051.     p_data[3] = ((i_version & 0x1f) << 1) | 0x1;
  1053.     if ( i_size )
  1054.     {
  1055.         int i;
  1057.         p_data[4] = (i_size + 1) >> 8;
  1058.         p_data[5] = (i_size + 1) & 0xff;
  1059.         p_data[6] = i_cmd;
  1060.         i = 7;
  1062.         while ( p_dr != NULL )
  1063.         {
  1064.             if( p_dr->i_tag == 0x9 )
  1065.             {
  1066.                 uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
  1067.                                     | p_dr->p_data[1];
  1068.                 if ( CheckSystemID( p_ids, i_sysid ) )
  1069.                 {
  1070.                     p_data[i] = 0x9;
  1071.                     p_data[i + 1] = p_dr->i_length;
  1072.                     memcpy( &p_data[i + 2], p_dr->p_data, p_dr->i_length );
  1073. //                    p_data[i+4] &= 0x1f;
  1074.                     i += p_dr->i_length + 2;
  1075.                 }
  1076.             }
  1077.             p_dr = p_dr->p_next;
  1078.         }
  1079.     }
  1080.     else
  1081.     {
  1082.         p_data[4] = 0;
  1083.         p_data[5] = 0;
  1084.     }
  1086.     return p_data;
  1087. }
  1089. static uint8_t *CAPMTES( system_ids_t *p_ids, uint8_t *p_capmt,
  1090.                          int i_capmt_size, uint8_t i_type, uint16_t i_pid,
  1091.                          int i_size, dvbpsi_descriptor_t *p_dr,
  1092.                          uint8_t i_cmd )
  1093. {
  1094.     uint8_t *p_data;
  1095.     int i;
  1096.  
  1097.     if ( i_size )
  1098.         p_data = realloc( p_capmt, i_capmt_size + 6 + i_size );
  1099.     else
  1100.         p_data = realloc( p_capmt, i_capmt_size + 5 );
  1102.     i = i_capmt_size;
  1104.     p_data[i] = i_type;
  1105.     p_data[i + 1] = i_pid >> 8;
  1106.     p_data[i + 2] = i_pid & 0xff;
  1108.     if ( i_size )
  1109.     {
  1110.         p_data[i + 3] = (i_size + 1) >> 8;
  1111.         p_data[i + 4] = (i_size + 1) & 0xff;
  1112.         p_data[i + 5] = i_cmd;
  1113.         i += 6;
  1115.         while ( p_dr != NULL )
  1116.         {
  1117.             if( p_dr->i_tag == 0x9 )
  1118.             {
  1119.                 uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
  1120.                                     | p_dr->p_data[1];
  1121.                 if ( CheckSystemID( p_ids, i_sysid ) )
  1122.                 {
  1123.                     p_data[i] = 0x9;
  1124.                     p_data[i + 1] = p_dr->i_length;
  1125.                     memcpy( &p_data[i + 2], p_dr->p_data, p_dr->i_length );
  1126.                     i += p_dr->i_length + 2;
  1127.                 }
  1128.             }
  1129.             p_dr = p_dr->p_next;
  1130.         }
  1131.     }
  1132.     else
  1133.     {
  1134.         p_data[i + 3] = 0;
  1135.         p_data[i + 4] = 0;
  1136.     }
  1138.     return p_data;
  1139. }
  1141. static uint8_t *CAPMTBuild( access_t * p_access, int i_session_id,
  1142.                             dvbpsi_pmt_t *p_pmt, uint8_t i_list_mgt,
  1143.                             uint8_t i_cmd, int *pi_capmt_size )
  1144. {
  1145.     access_sys_t *p_sys = p_access->p_sys;
  1146.     system_ids_t *p_ids =
  1147.         (system_ids_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1148.     dvbpsi_pmt_es_t *p_es;
  1149.     int i_cad_size, i_cad_program_size;
  1150.     uint8_t *p_capmt;
  1152.     i_cad_size = i_cad_program_size =
  1153.             GetCADSize( p_ids, p_pmt->p_first_descriptor );
  1154.     for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
  1155.     {
  1156.         i_cad_size += GetCADSize( p_ids, p_es->p_first_descriptor );
  1157.     }
  1159.     if ( !i_cad_size )
  1160.     {
  1161.         msg_Warn( p_access,
  1162.                   "no compatible scrambling system for SID %d on session %d",
  1163.                   p_pmt->i_program_number, i_session_id );
  1164.         *pi_capmt_size = 0;
  1165.         return NULL;
  1166.     }
  1168.     p_capmt = CAPMTHeader( p_ids, i_list_mgt, p_pmt->i_program_number,
  1169.                            p_pmt->i_version, i_cad_program_size,
  1170.                            p_pmt->p_first_descriptor, i_cmd );
  1172.     if ( i_cad_program_size )
  1173.         *pi_capmt_size = 7 + i_cad_program_size;
  1174.     else
  1175.         *pi_capmt_size = 6;
  1177.     for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
  1178.     {
  1179.         i_cad_size = GetCADSize( p_ids, p_es->p_first_descriptor );
  1181.         if ( i_cad_size || i_cad_program_size )
  1182.         {
  1183.             p_capmt = CAPMTES( p_ids, p_capmt, *pi_capmt_size, p_es->i_type,
  1184.                                p_es->i_pid, i_cad_size,
  1185.                                p_es->p_first_descriptor, i_cmd );
  1186.             if ( i_cad_size )
  1187.                 *pi_capmt_size += 6 + i_cad_size;
  1188.             else
  1189.                 *pi_capmt_size += 5;
  1190.         }
  1191.     }
  1193.     return p_capmt;
  1194. }
  1196. /*****************************************************************************
  1197.  * CAPMTFirst
  1198.  *****************************************************************************/
  1199. static void CAPMTFirst( access_t * p_access, int i_session_id,
  1200.                         dvbpsi_pmt_t *p_pmt )
  1201. {
  1202.     uint8_t *p_capmt;
  1203.     int i_capmt_size;
  1205.     msg_Dbg( p_access, "adding first CAPMT for SID %d on session %d",
  1206.              p_pmt->i_program_number, i_session_id );
  1208.     p_capmt = CAPMTBuild( p_access, i_session_id, p_pmt,
  1209.                           0x3 /* only */, 0x1 /* ok_descrambling */,
  1210.                           &i_capmt_size );
  1212.     if( i_capmt_size )
  1213.     {
  1214.         APDUSend( p_access, i_session_id, AOT_CA_PMT, p_capmt, i_capmt_size );
  1215.         free( p_capmt );
  1216.     }
  1217. }
  1219. /*****************************************************************************
  1220.  * CAPMTAdd
  1221.  *****************************************************************************/
  1222. static void CAPMTAdd( access_t * p_access, int i_session_id,
  1223.                       dvbpsi_pmt_t *p_pmt )
  1224. {
  1225.     uint8_t *p_capmt;
  1226.     int i_capmt_size;
  1228.     if( p_access->p_sys->i_selected_programs >= CAM_PROG_MAX )
  1229.     {
  1230.         msg_Warn( p_access, "Not adding CAPMT for SID %d, too many programs",
  1231.                   p_pmt->i_program_number );
  1232.         return;
  1233.     }
  1234.     p_access->p_sys->i_selected_programs++;
  1235.     if( p_access->p_sys->i_selected_programs == 1 )
  1236.     {
  1237.         CAPMTFirst( p_access, i_session_id, p_pmt );
  1238.         return;
  1239.     }
  1240.  
  1241. #ifdef CAPMT_WAIT
  1242.     msleep( CAPMT_WAIT * 1000 );
  1243. #endif
  1244.  
  1245.     msg_Dbg( p_access, "adding CAPMT for SID %d on session %d",
  1246.              p_pmt->i_program_number, i_session_id );
  1248.     p_capmt = CAPMTBuild( p_access, i_session_id, p_pmt,
  1249.                           0x4 /* add */, 0x1 /* ok_descrambling */,
  1250.                           &i_capmt_size );
  1252.     if( i_capmt_size )
  1253.     {
  1254.         APDUSend( p_access, i_session_id, AOT_CA_PMT, p_capmt, i_capmt_size );
  1255.         free( p_capmt );
  1256.     }
  1257. }
  1259. /*****************************************************************************
  1260.  * CAPMTUpdate
  1261.  *****************************************************************************/
  1262. static void CAPMTUpdate( access_t * p_access, int i_session_id,
  1263.                          dvbpsi_pmt_t *p_pmt )
  1264. {
  1265.     uint8_t *p_capmt;
  1266.     int i_capmt_size;
  1268.     msg_Dbg( p_access, "updating CAPMT for SID %d on session %d",
  1269.              p_pmt->i_program_number, i_session_id );
  1271.     p_capmt = CAPMTBuild( p_access, i_session_id, p_pmt,
  1272.                           0x5 /* update */, 0x1 /* ok_descrambling */,
  1273.                           &i_capmt_size );
  1275.     if( i_capmt_size )
  1276.     {
  1277.         APDUSend( p_access, i_session_id, AOT_CA_PMT, p_capmt, i_capmt_size );
  1278.         free( p_capmt );
  1279.     }
  1280. }
  1282. /*****************************************************************************
  1283.  * CAPMTDelete
  1284.  *****************************************************************************/
  1285. static void CAPMTDelete( access_t * p_access, int i_session_id,
  1286.                          dvbpsi_pmt_t *p_pmt )
  1287. {
  1288.     uint8_t *p_capmt;
  1289.     int i_capmt_size;
  1291.     p_access->p_sys->i_selected_programs--;
  1292.     msg_Dbg( p_access, "deleting CAPMT for SID %d on session %d",
  1293.              p_pmt->i_program_number, i_session_id );
  1295.     p_capmt = CAPMTBuild( p_access, i_session_id, p_pmt,
  1296.                           0x5 /* update */, 0x4 /* not selected */,
  1297.                           &i_capmt_size );
  1299.     if( i_capmt_size )
  1300.     {
  1301.         APDUSend( p_access, i_session_id, AOT_CA_PMT, p_capmt, i_capmt_size );
  1302.         free( p_capmt );
  1303.     }
  1304. }
  1306. /*****************************************************************************
  1307.  * ConditionalAccessHandle
  1308.  *****************************************************************************/
  1309. static void ConditionalAccessHandle( access_t * p_access, int i_session_id,
  1310.                                      uint8_t *p_apdu, int i_size )
  1311. {
  1312.     access_sys_t *p_sys = p_access->p_sys;
  1313.     system_ids_t *p_ids =
  1314.         (system_ids_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1315.     int i_tag = APDUGetTag( p_apdu, i_size );
  1317.     switch ( i_tag )
  1318.     {
  1319.     case AOT_CA_INFO:
  1320.     {
  1321.         int i;
  1322.         int l = 0;
  1323.         uint8_t *d = APDUGetLength( p_apdu, &l );
  1324.         msg_Dbg( p_access, "CA system IDs supported by the application :" );
  1326.         for ( i = 0; i < l / 2; i++ )
  1327.         {
  1328.             p_ids->pi_system_ids[i] = ((uint16_t)d[0] << 8) | d[1];
  1329.             d += 2;
  1330.             msg_Dbg( p_access, "- 0x%x", p_ids->pi_system_ids[i] );
  1331.         }
  1332.         p_ids->pi_system_ids[i] = 0;
  1334.         for ( i = 0; i < MAX_PROGRAMS; i++ )
  1335.         {
  1336.             if ( p_sys->pp_selected_programs[i] != NULL )
  1337.             {
  1338.                 CAPMTAdd( p_access, i_session_id,
  1339.                           p_sys->pp_selected_programs[i] );
  1340.             }
  1341.         }
  1342.         break;
  1343.     }
  1345.     default:
  1346.         msg_Err( p_access,
  1347.                  "unexpected tag in ConditionalAccessHandle (0x%x)",
  1348.                  i_tag );
  1349.     }
  1350. }
  1352. /*****************************************************************************
  1353.  * ConditionalAccessClose
  1354.  *****************************************************************************/
  1355. static void ConditionalAccessClose( access_t * p_access, int i_session_id )
  1356. {
  1357.     access_sys_t *p_sys = p_access->p_sys;
  1359.     msg_Dbg( p_access, "closing ConditionalAccess session (%d)", i_session_id );
  1361.     free( p_sys->p_sessions[i_session_id - 1].p_sys );
  1362. }
  1364. /*****************************************************************************
  1365.  * ConditionalAccessOpen
  1366.  *****************************************************************************/
  1367. static void ConditionalAccessOpen( access_t * p_access, int i_session_id )
  1368. {
  1369.     access_sys_t *p_sys = p_access->p_sys;
  1371.     msg_Dbg( p_access, "opening ConditionalAccess session (%d)", i_session_id );
  1373.     p_sys->p_sessions[i_session_id - 1].pf_handle = ConditionalAccessHandle;
  1374.     p_sys->p_sessions[i_session_id - 1].pf_close = ConditionalAccessClose;
  1375.     p_sys->p_sessions[i_session_id - 1].p_sys = calloc( 1, sizeof(system_ids_t) );
  1377.     APDUSend( p_access, i_session_id, AOT_CA_INFO_ENQ, NULL, 0 );
  1378. }
  1380. /*
  1381.  * Date Time
  1382.  */
  1384. typedef struct
  1385. {
  1386.     int i_interval;
  1387.     mtime_t i_last;
  1388. } date_time_t;
  1390. /*****************************************************************************
  1391.  * DateTimeSend
  1392.  *****************************************************************************/
  1393. static void DateTimeSend( access_t * p_access, int i_session_id )
  1394. {
  1395.     access_sys_t *p_sys = p_access->p_sys;
  1396.     date_time_t *p_date =
  1397.         (date_time_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1399.     time_t t = time(NULL);
  1400.     struct tm tm_gmt;
  1401.     struct tm tm_loc;
  1403.     if ( gmtime_r(&t, &tm_gmt) && localtime_r(&t, &tm_loc) )
  1404.     {
  1405.         int Y = tm_gmt.tm_year;
  1406.         int M = tm_gmt.tm_mon + 1;
  1407.         int D = tm_gmt.tm_mday;
  1408.         int L = (M == 1 || M == 2) ? 1 : 0;
  1409.         int MJD = 14956 + D + (int)((Y - L) * 365.25)
  1410.                     + (int)((M + 1 + L * 12) * 30.6001);
  1411.         uint8_t p_response[7];
  1413. #define DEC2BCD(d) (((d / 10) << 4) + (d % 10))
  1415.         p_response[0] = htons(MJD) >> 8;
  1416.         p_response[1] = htons(MJD) & 0xff;
  1417.         p_response[2] = DEC2BCD(tm_gmt.tm_hour);
  1418.         p_response[3] = DEC2BCD(tm_gmt.tm_min);
  1419.         p_response[4] = DEC2BCD(tm_gmt.tm_sec);
  1420.         p_response[5] = htons(tm_loc.tm_gmtoff / 60) >> 8;
  1421.         p_response[6] = htons(tm_loc.tm_gmtoff / 60) & 0xff;
  1423.         APDUSend( p_access, i_session_id, AOT_DATE_TIME, p_response, 7 );
  1425.         p_date->i_last = mdate();
  1426.     }
  1427. }
  1429. /*****************************************************************************
  1430.  * DateTimeHandle
  1431.  *****************************************************************************/
  1432. static void DateTimeHandle( access_t * p_access, int i_session_id,
  1433.                             uint8_t *p_apdu, int i_size )
  1434. {
  1435.     access_sys_t *p_sys = p_access->p_sys;
  1436.     date_time_t *p_date =
  1437.         (date_time_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1439.     int i_tag = APDUGetTag( p_apdu, i_size );
  1441.     switch ( i_tag )
  1442.     {
  1443.     case AOT_DATE_TIME_ENQ:
  1444.     {
  1445.         int l;
  1446.         const uint8_t *d = APDUGetLength( p_apdu, &l );
  1448.         if ( l > 0 )
  1449.         {
  1450.             p_date->i_interval = *d;
  1451.             msg_Dbg( p_access, "DateTimeHandle : interval set to %d",
  1452.                      p_date->i_interval );
  1453.         }
  1454.         else
  1455.             p_date->i_interval = 0;
  1457.         DateTimeSend( p_access, i_session_id );
  1458.         break;
  1459.     }
  1460.     default:
  1461.         msg_Err( p_access, "unexpected tag in DateTimeHandle (0x%x)", i_tag );
  1462.     }
  1463. }
  1465. /*****************************************************************************
  1466.  * DateTimeManage
  1467.  *****************************************************************************/
  1468. static void DateTimeManage( access_t * p_access, int i_session_id )
  1469. {
  1470.     access_sys_t *p_sys = p_access->p_sys;
  1471.     date_time_t *p_date =
  1472.         (date_time_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1474.     if ( p_date->i_interval
  1475.           && mdate() > p_date->i_last + (mtime_t)p_date->i_interval * 1000000 )
  1476.     {
  1477.         DateTimeSend( p_access, i_session_id );
  1478.     }
  1479. }
  1481. /*****************************************************************************
  1482.  * DateTimeClose
  1483.  *****************************************************************************/
  1484. static void DateTimeClose( access_t * p_access, int i_session_id )
  1485. {
  1486.     access_sys_t *p_sys = p_access->p_sys;
  1488.     msg_Dbg( p_access, "closing DateTime session (%d)", i_session_id );
  1490.     free( p_sys->p_sessions[i_session_id - 1].p_sys );
  1491. }
  1493. /*****************************************************************************
  1494.  * DateTimeOpen
  1495.  *****************************************************************************/
  1496. static void DateTimeOpen( access_t * p_access, int i_session_id )
  1497. {
  1498.     access_sys_t *p_sys = p_access->p_sys;
  1500.     msg_Dbg( p_access, "opening DateTime session (%d)", i_session_id );
  1502.     p_sys->p_sessions[i_session_id - 1].pf_handle = DateTimeHandle;
  1503.     p_sys->p_sessions[i_session_id - 1].pf_manage = DateTimeManage;
  1504.     p_sys->p_sessions[i_session_id - 1].pf_close = DateTimeClose;
  1505.     p_sys->p_sessions[i_session_id - 1].p_sys = calloc( 1, sizeof(date_time_t) );
  1507.     DateTimeSend( p_access, i_session_id );
  1508. }
  1510. /*
  1511.  * MMI
  1512.  */
  1514. /* Display Control Commands */
  1516. #define DCC_SET_MMI_MODE                          0x01
  1517. #define DCC_DISPLAY_CHARACTER_TABLE_LIST          0x02
  1518. #define DCC_INPUT_CHARACTER_TABLE_LIST            0x03
  1519. #define DCC_OVERLAY_GRAPHICS_CHARACTERISTICS      0x04
  1520. #define DCC_FULL_SCREEN_GRAPHICS_CHARACTERISTICS  0x05
  1522. /* MMI Modes */
  1524. #define MM_HIGH_LEVEL                      0x01
  1525. #define MM_LOW_LEVEL_OVERLAY_GRAPHICS      0x02
  1526. #define MM_LOW_LEVEL_FULL_SCREEN_GRAPHICS  0x03
  1528. /* Display Reply IDs */
  1530. #define DRI_MMI_MODE_ACK                              0x01
  1531. #define DRI_LIST_DISPLAY_CHARACTER_TABLES             0x02
  1532. #define DRI_LIST_INPUT_CHARACTER_TABLES               0x03
  1533. #define DRI_LIST_GRAPHIC_OVERLAY_CHARACTERISTICS      0x04
  1534. #define DRI_LIST_FULL_SCREEN_GRAPHIC_CHARACTERISTICS  0x05
  1535. #define DRI_UNKNOWN_DISPLAY_CONTROL_CMD               0xF0
  1536. #define DRI_UNKNOWN_MMI_MODE                          0xF1
  1537. #define DRI_UNKNOWN_CHARACTER_TABLE                   0xF2
  1539. /* Enquiry Flags */
  1541. #define EF_BLIND  0x01
  1543. /* Answer IDs */
  1545. #define AI_CANCEL  0x00
  1546. #define AI_ANSWER  0x01
  1548. typedef struct
  1549. {
  1550.     en50221_mmi_object_t last_object;
  1551. } mmi_t;
  1553. /*****************************************************************************
  1554.  * MMISendObject
  1555.  *****************************************************************************/
  1556. static void MMISendObject( access_t *p_access, int i_session_id,
  1557.                            en50221_mmi_object_t *p_object )
  1558. {
  1559.     access_sys_t *p_sys = p_access->p_sys;
  1560.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  1561.     uint8_t *p_data;
  1562.     int i_size, i_tag;
  1564.     switch ( p_object->i_object_type )
  1565.     {
  1566.     case EN50221_MMI_ANSW:
  1567.         i_tag = AOT_ANSW;
  1568.         i_size = 1 + strlen( p_object->u.answ.psz_answ );
  1569.         p_data = malloc( i_size );
  1570.         p_data[0] = (p_object->u.answ.b_ok == true) ? 0x1 : 0x0;
  1571.         strncpy( (char *)&p_data[1], p_object->u.answ.psz_answ, i_size - 1 );
  1572.         break;
  1574.     case EN50221_MMI_MENU_ANSW:
  1575.         i_tag = AOT_MENU_ANSW;
  1576.         i_size = 1;
  1577.         p_data = malloc( i_size );
  1578.         p_data[0] = p_object->u.menu_answ.i_choice;
  1579.         break;
  1581.     default:
  1582.         msg_Err( p_access, "unknown MMI object %d", p_object->i_object_type );
  1583.         return;
  1584.     }
  1586.     APDUSend( p_access, i_session_id, i_tag, p_data, i_size );
  1587.     free( p_data );
  1589.     p_sys->pb_slot_mmi_expected[i_slot] = true;
  1590. }
  1592. /*****************************************************************************
  1593.  * MMISendClose
  1594.  *****************************************************************************/
  1595. static void MMISendClose( access_t *p_access, int i_session_id )
  1596. {
  1597.     access_sys_t *p_sys = p_access->p_sys;
  1598.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  1600.     APDUSend( p_access, i_session_id, AOT_CLOSE_MMI, NULL, 0 );
  1602.     p_sys->pb_slot_mmi_expected[i_slot] = true;
  1603. }
  1605. /*****************************************************************************
  1606.  * MMIDisplayReply
  1607.  *****************************************************************************/
  1608. static void MMIDisplayReply( access_t *p_access, int i_session_id )
  1609. {
  1610.     uint8_t p_response[2];
  1612.     p_response[0] = DRI_MMI_MODE_ACK;
  1613.     p_response[1] = MM_HIGH_LEVEL;
  1615.     APDUSend( p_access, i_session_id, AOT_DISPLAY_REPLY, p_response, 2 );
  1617.     msg_Dbg( p_access, "sending DisplayReply on session (%d)", i_session_id );
  1618. }
  1620. /*****************************************************************************
  1621.  * MMIGetText
  1622.  *****************************************************************************/
  1623. static char *MMIGetText( access_t *p_access, uint8_t **pp_apdu, int *pi_size )
  1624. {
  1625.     int i_tag = APDUGetTag( *pp_apdu, *pi_size );
  1626.     int l;
  1627.     uint8_t *d;
  1629.     if ( i_tag != AOT_TEXT_LAST )
  1630.     {
  1631.         msg_Err( p_access, "unexpected text tag: %06x", i_tag );
  1632.         *pi_size = 0;
  1633.         return strdup( "" );
  1634.     }
  1636.     d = APDUGetLength( *pp_apdu, &l );
  1638.     *pp_apdu += l + 4;
  1639.     *pi_size -= l + 4;
  1641.     return dvbsi_to_utf8((char*)d,l);
  1642. }
  1644. /*****************************************************************************
  1645.  * MMIHandleEnq
  1646.  *****************************************************************************/
  1647. static void MMIHandleEnq( access_t *p_access, int i_session_id,
  1648.                           uint8_t *p_apdu, int i_size )
  1649. {
  1650.     access_sys_t *p_sys = p_access->p_sys;
  1651.     mmi_t *p_mmi = (mmi_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1652.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  1653.     int l;
  1654.     uint8_t *d = APDUGetLength( p_apdu, &l );
  1656.     en50221_MMIFree( &p_mmi->last_object );
  1657.     p_mmi->last_object.i_object_type = EN50221_MMI_ENQ;
  1658.     p_mmi->last_object.u.enq.b_blind = (*d & 0x1) ? true : false;
  1659.     d += 2; /* skip answer_text_length because it is not mandatory */
  1660.     l -= 2;
  1661.     p_mmi->last_object.u.enq.psz_text = malloc( l + 1 );
  1662.     strncpy( p_mmi->last_object.u.enq.psz_text, (char *)d, l );
  1663.     p_mmi->last_object.u.enq.psz_text[l] = '';
  1665.     msg_Dbg( p_access, "MMI enq: %s%s", p_mmi->last_object.u.enq.psz_text,
  1666.              p_mmi->last_object.u.enq.b_blind == true ? " (blind)" : "" );
  1667.     p_sys->pb_slot_mmi_expected[i_slot] = false;
  1668.     p_sys->pb_slot_mmi_undisplayed[i_slot] = true;
  1669. }
  1671. /*****************************************************************************
  1672.  * MMIHandleMenu
  1673.  *****************************************************************************/
  1674. static void MMIHandleMenu( access_t *p_access, int i_session_id, int i_tag,
  1675.                            uint8_t *p_apdu, int i_size )
  1676. {
  1677.     access_sys_t *p_sys = p_access->p_sys;
  1678.     mmi_t *p_mmi = (mmi_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1679.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  1680.     int l;
  1681.     uint8_t *d = APDUGetLength( p_apdu, &l );
  1683.     en50221_MMIFree( &p_mmi->last_object );
  1684.     p_mmi->last_object.i_object_type = (i_tag == AOT_MENU_LAST) ?
  1685.                                        EN50221_MMI_MENU : EN50221_MMI_LIST;
  1686.     p_mmi->last_object.u.menu.i_choices = 0;
  1687.     p_mmi->last_object.u.menu.ppsz_choices = NULL;
  1689.     if ( l > 0 )
  1690.     {
  1691.         l--; d++; /* choice_nb */
  1693. #define GET_FIELD( x )                                                      
  1694.         if ( l > 0 )                                                        
  1695.         {                                                                   
  1696.             p_mmi->last_object.u.menu.psz_##x                               
  1697.                             = MMIGetText( p_access, &d, &l );               
  1698.             msg_Dbg( p_access, "MMI " STRINGIFY( x ) ": %s",                
  1699.                      p_mmi->last_object.u.menu.psz_##x );                   
  1700.         }
  1702.         GET_FIELD( title );
  1703.         GET_FIELD( subtitle );
  1704.         GET_FIELD( bottom );
  1705. #undef GET_FIELD
  1707.         while ( l > 0 )
  1708.         {
  1709.             char *psz_text = MMIGetText( p_access, &d, &l );
  1710.             TAB_APPEND( p_mmi->last_object.u.menu.i_choices,
  1711.                         p_mmi->last_object.u.menu.ppsz_choices,
  1712.                         psz_text );
  1713.             msg_Dbg( p_access, "MMI choice: %s", psz_text );
  1714.         }
  1715.     }
  1716.     p_sys->pb_slot_mmi_expected[i_slot] = false;
  1717.     p_sys->pb_slot_mmi_undisplayed[i_slot] = true;
  1718. }
  1720. /*****************************************************************************
  1721.  * MMIHandle
  1722.  *****************************************************************************/
  1723. static void MMIHandle( access_t *p_access, int i_session_id,
  1724.                        uint8_t *p_apdu, int i_size )
  1725. {
  1726.     int i_tag = APDUGetTag( p_apdu, i_size );
  1728.     switch ( i_tag )
  1729.     {
  1730.     case AOT_DISPLAY_CONTROL:
  1731.     {
  1732.         int l;
  1733.         uint8_t *d = APDUGetLength( p_apdu, &l );
  1735.         if ( l > 0 )
  1736.         {
  1737.             switch ( *d )
  1738.             {
  1739.             case DCC_SET_MMI_MODE:
  1740.                 if ( l == 2 && d[1] == MM_HIGH_LEVEL )
  1741.                     MMIDisplayReply( p_access, i_session_id );
  1742.                 else
  1743.                     msg_Err( p_access, "unsupported MMI mode %02x", d[1] );
  1744.                 break;
  1746.             default:
  1747.                 msg_Err( p_access, "unsupported display control command %02x",
  1748.                          *d );
  1749.                 break;
  1750.             }
  1751.         }
  1752.         break;
  1753.     }
  1755.     case AOT_ENQ:
  1756.         MMIHandleEnq( p_access, i_session_id, p_apdu, i_size );
  1757.         break;
  1759.     case AOT_LIST_LAST:
  1760.     case AOT_MENU_LAST:
  1761.         MMIHandleMenu( p_access, i_session_id, i_tag, p_apdu, i_size );
  1762.         break;
  1764.     case AOT_CLOSE_MMI:
  1765.         SessionSendClose( p_access, i_session_id );
  1766.         break;
  1768.     default:
  1769.         msg_Err( p_access, "unexpected tag in MMIHandle (0x%x)", i_tag );
  1770.     }
  1771. }
  1773. /*****************************************************************************
  1774.  * MMIClose
  1775.  *****************************************************************************/
  1776. static void MMIClose( access_t *p_access, int i_session_id )
  1777. {
  1778.     access_sys_t *p_sys = p_access->p_sys;
  1779.     int i_slot = p_sys->p_sessions[i_session_id - 1].i_slot;
  1780.     mmi_t *p_mmi = (mmi_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1782.     en50221_MMIFree( &p_mmi->last_object );
  1783.     free( p_sys->p_sessions[i_session_id - 1].p_sys );
  1785.     msg_Dbg( p_access, "closing MMI session (%d)", i_session_id );
  1786.     p_sys->pb_slot_mmi_expected[i_slot] = false;
  1787.     p_sys->pb_slot_mmi_undisplayed[i_slot] = true;
  1788. }
  1790. /*****************************************************************************
  1791.  * MMIOpen
  1792.  *****************************************************************************/
  1793. static void MMIOpen( access_t *p_access, int i_session_id )
  1794. {
  1795.     access_sys_t *p_sys = p_access->p_sys;
  1796.     mmi_t *p_mmi;
  1798.     msg_Dbg( p_access, "opening MMI session (%d)", i_session_id );
  1800.     p_sys->p_sessions[i_session_id - 1].pf_handle = MMIHandle;
  1801.     p_sys->p_sessions[i_session_id - 1].pf_close = MMIClose;
  1802.     p_sys->p_sessions[i_session_id - 1].p_sys = malloc(sizeof(mmi_t));
  1803.     p_mmi = (mmi_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  1804.     p_mmi->last_object.i_object_type = EN50221_MMI_NONE;
  1805. }
  1808. /*
  1809.  * Hardware handling
  1810.  */
  1812. /*****************************************************************************
  1813.  * InitSlot: Open the transport layer
  1814.  *****************************************************************************/
  1815. #define MAX_TC_RETRIES 20
  1817. static int InitSlot( access_t * p_access, int i_slot )
  1818. {
  1819.     access_sys_t *p_sys = p_access->p_sys;
  1820.     int i;
  1822.     if ( TPDUSend( p_access, i_slot, T_CREATE_TC, NULL, 0 )
  1823.             != VLC_SUCCESS )
  1824.     {
  1825.         msg_Err( p_access, "en50221_Init: couldn't send TPDU on slot %d",
  1826.                  i_slot );
  1827.         return VLC_EGENERIC;
  1828.     }
  1830.     /* This is out of the spec */
  1831.     for ( i = 0; i < MAX_TC_RETRIES; i++ )
  1832.     {
  1833.         uint8_t i_tag;
  1834.         if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) == VLC_SUCCESS
  1835.               && i_tag == T_CTC_REPLY )
  1836.         {
  1837.             p_sys->pb_active_slot[i_slot] = true;
  1838.             break;
  1839.         }
  1841.         if ( TPDUSend( p_access, i_slot, T_CREATE_TC, NULL, 0 )
  1842.                 != VLC_SUCCESS )
  1843.         {
  1844.             msg_Err( p_access,
  1845.                      "en50221_Init: couldn't send TPDU on slot %d",
  1846.                      i_slot );
  1847.             continue;
  1848.         }
  1849.     }
  1851.     if ( p_sys->pb_active_slot[i_slot] )
  1852.     {
  1853.         p_sys->i_ca_timeout = 100000;
  1854.         return VLC_SUCCESS;
  1855.     }
  1857.     return VLC_EGENERIC;
  1858. }
  1861. /*
  1862.  * External entry points
  1863.  */
  1865. /*****************************************************************************
  1866.  * en50221_Init : Initialize the CAM for en50221
  1867.  *****************************************************************************/
  1868. int en50221_Init( access_t * p_access )
  1869. {
  1870.     access_sys_t *p_sys = p_access->p_sys;
  1872.     if( p_sys->i_ca_type & CA_CI_LINK )
  1873.     {
  1874.         int i_slot;
  1875.         for ( i_slot = 0; i_slot < p_sys->i_nb_slots; i_slot++ )
  1876.         {
  1877.             if ( ioctl( p_sys->i_ca_handle, CA_RESET, 1 << i_slot) != 0 )
  1878.             {
  1879.                 msg_Err( p_access, "en50221_Init: couldn't reset slot %d",
  1880.                          i_slot );
  1881.             }
  1882.         }
  1884.         p_sys->i_ca_timeout = 100000;
  1885.         /* Wait a bit otherwise it doesn't initialize properly... */
  1886.         msleep( 1000000 );
  1888.         return VLC_SUCCESS;
  1889.     }
  1890.     else
  1891.     {
  1892.         struct ca_slot_info info;
  1893.         info.num = 0;
  1895.         /* We don't reset the CAM in that case because it's done by the
  1896.          * ASIC. */
  1897.         if ( ioctl( p_sys->i_ca_handle, CA_GET_SLOT_INFO, &info ) < 0 )
  1898.         {
  1899.             msg_Err( p_access, "en50221_Init: couldn't get slot info" );
  1900.             close( p_sys->i_ca_handle );
  1901.             p_sys->i_ca_handle = 0;
  1902.             return VLC_EGENERIC;
  1903.         }
  1904.         if( info.flags == 0 )
  1905.         {
  1906.             msg_Err( p_access, "en50221_Init: no CAM inserted" );
  1907.             close( p_sys->i_ca_handle );
  1908.             p_sys->i_ca_handle = 0;
  1909.             return VLC_EGENERIC;
  1910.         }
  1912.         /* Allocate a dummy sessions */
  1913.         p_sys->p_sessions[ 0 ].i_resource_id = RI_CONDITIONAL_ACCESS_SUPPORT;
  1915.         /* Get application info to find out which cam we are using and make
  1916.            sure everything is ready to play */
  1917.         ca_msg_t ca_msg;
  1918.         ca_msg.length=3;
  1919.         ca_msg.msg[0] = ( AOT_APPLICATION_INFO & 0xFF0000 ) >> 16;
  1920.         ca_msg.msg[1] = ( AOT_APPLICATION_INFO & 0x00FF00 ) >> 8;
  1921.         ca_msg.msg[2] = ( AOT_APPLICATION_INFO & 0x0000FF ) >> 0;
  1922.         memset( &ca_msg.msg[3], 0, 253 );
  1923.         APDUSend( p_access, 1, AOT_APPLICATION_INFO_ENQ, NULL, 0 );
  1924.         if ( ioctl( p_sys->i_ca_handle, CA_GET_MSG, &ca_msg ) < 0 )
  1925.         {
  1926.             msg_Err( p_access, "en50221_Init: failed getting message" );
  1927.             return VLC_EGENERIC;
  1928.         }
  1930. #if HLCI_WAIT_CAM_READY
  1931.         while( ca_msg.msg[8] == 0xff && ca_msg.msg[9] == 0xff )
  1932.         {
  1933.             if( !vlc_object_alive (p_access) ) return VLC_EGENERIC;
  1934.             msleep(1);
  1935.             msg_Dbg( p_access, "CAM: please wait" );
  1936.             APDUSend( p_access, 1, AOT_APPLICATION_INFO_ENQ, NULL, 0 );
  1937.             ca_msg.length=3;
  1938.             ca_msg.msg[0] = ( AOT_APPLICATION_INFO & 0xFF0000 ) >> 16;
  1939.             ca_msg.msg[1] = ( AOT_APPLICATION_INFO & 0x00FF00 ) >> 8;
  1940.             ca_msg.msg[2] = ( AOT_APPLICATION_INFO & 0x0000FF ) >> 0;
  1941.             memset( &ca_msg.msg[3], 0, 253 );
  1942.             if ( ioctl( p_sys->i_ca_handle, CA_GET_MSG, &ca_msg ) < 0 )
  1943.             {
  1944.                 msg_Err( p_access, "en50221_Init: failed getting message" );
  1945.                 return VLC_EGENERIC;
  1946.             }
  1947.             msg_Dbg( p_access, "en50221_Init: Got length: %d, tag: 0x%x", ca_msg.length, APDUGetTag( ca_msg.msg, ca_msg.length ) );
  1948.         }
  1949. #else
  1950.         if( ca_msg.msg[8] == 0xff && ca_msg.msg[9] == 0xff )
  1951.         {
  1952.             msg_Err( p_access, "CAM returns garbage as application info!" );
  1953.             return VLC_EGENERIC;
  1954.         }
  1955. #endif
  1956.         msg_Dbg( p_access, "found CAM %s using id 0x%x", &ca_msg.msg[12],
  1957.                  (ca_msg.msg[8]<<8)|ca_msg.msg[9] );
  1958.         return VLC_SUCCESS;
  1959.     }
  1960. }
  1962. /*****************************************************************************
  1963.  * en50221_Poll : Poll the CAM for TPDUs
  1964.  *****************************************************************************/
  1965. int en50221_Poll( access_t * p_access )
  1966. {
  1967.     access_sys_t *p_sys = p_access->p_sys;
  1968.     int i_slot;
  1969.     int i_session_id;
  1971.     for ( i_slot = 0; i_slot < p_sys->i_nb_slots; i_slot++ )
  1972.     {
  1973.         uint8_t i_tag;
  1974.         ca_slot_info_t sinfo;
  1976.         sinfo.num = i_slot;
  1977.         if ( ioctl( p_sys->i_ca_handle, CA_GET_SLOT_INFO, &sinfo ) != 0 )
  1978.         {
  1979.             msg_Err( p_access, "en50221_Poll: couldn't get info on slot %d",
  1980.                      i_slot );
  1981.             continue;
  1982.         }
  1984.         if ( !(sinfo.flags & CA_CI_MODULE_READY) )
  1985.         {
  1986.             if ( p_sys->pb_active_slot[i_slot] )
  1987.             {
  1988.                 msg_Dbg( p_access, "en50221_Poll: slot %d has been removed",
  1989.                          i_slot );
  1990.                 p_sys->pb_active_slot[i_slot] = false;
  1991.                 p_sys->pb_slot_mmi_expected[i_slot] = false;
  1992.                 p_sys->pb_slot_mmi_undisplayed[i_slot] = false;
  1994.                 /* Close all sessions for this slot. */
  1995.                 for ( i_session_id = 1; i_session_id <= MAX_SESSIONS;
  1996.                       i_session_id++ )
  1997.                 {
  1998.                     if ( p_sys->p_sessions[i_session_id - 1].i_resource_id
  1999.                           && p_sys->p_sessions[i_session_id - 1].i_slot
  2000.                                == i_slot )
  2001.                     {
  2002.                         if ( p_sys->p_sessions[i_session_id - 1].pf_close
  2003.                               != NULL )
  2004.                         {
  2005.                             p_sys->p_sessions[i_session_id - 1].pf_close(
  2006.                                                 p_access, i_session_id );
  2007.                         }
  2008.                         p_sys->p_sessions[i_session_id - 1].i_resource_id = 0;
  2009.                     }
  2010.                 }
  2011.             }
  2013.             continue;
  2014.         }
  2015.         else if ( !p_sys->pb_active_slot[i_slot] )
  2016.         {
  2017.             InitSlot( p_access, i_slot );
  2019.             if ( !p_sys->pb_active_slot[i_slot] )
  2020.             {
  2021.                 msg_Dbg( p_access, "en50221_Poll: resetting slot %d", i_slot );
  2023.                 if ( ioctl( p_sys->i_ca_handle, CA_RESET, 1 << i_slot) != 0 )
  2024.                 {
  2025.                     msg_Err( p_access, "en50221_Poll: couldn't reset slot %d",
  2026.                              i_slot );
  2027.                 }
  2028.                 continue;
  2029.             }
  2031.             msg_Dbg( p_access, "en50221_Poll: slot %d is active",
  2032.                      i_slot );
  2033.         }
  2035.         if ( !p_sys->pb_tc_has_data[i_slot] )
  2036.         {
  2037.             if ( TPDUSend( p_access, i_slot, T_DATA_LAST, NULL, 0 ) !=
  2038.                     VLC_SUCCESS )
  2039.             {
  2040.                 msg_Err( p_access,
  2041.                          "en50221_Poll: couldn't send TPDU on slot %d",
  2042.                          i_slot );
  2043.                 continue;
  2044.             }
  2045.             if ( TPDURecv( p_access, i_slot, &i_tag, NULL, NULL ) !=
  2046.                     VLC_SUCCESS )
  2047.             {
  2048.                 msg_Err( p_access,
  2049.                          "en50221_Poll: couldn't recv TPDU on slot %d",
  2050.                          i_slot );
  2051.                 continue;
  2052.             }
  2053.         }
  2055.         while ( p_sys->pb_tc_has_data[i_slot] )
  2056.         {
  2057.             uint8_t p_tpdu[MAX_TPDU_SIZE];
  2058.             int i_size, i_session_size;
  2059.             uint8_t *p_session;
  2061.             if ( TPDUSend( p_access, i_slot, T_RCV, NULL, 0 ) != VLC_SUCCESS )
  2062.             {
  2063.                 msg_Err( p_access,
  2064.                          "en50221_Poll: couldn't send TPDU on slot %d",
  2065.                          i_slot );
  2066.                 continue;
  2067.             }
  2068.             if ( TPDURecv( p_access, i_slot, &i_tag, p_tpdu, &i_size ) !=
  2069.                     VLC_SUCCESS )
  2070.             {
  2071.                 msg_Err( p_access,
  2072.                          "en50221_Poll: couldn't recv TPDU on slot %d",
  2073.                          i_slot );
  2074.                 continue;
  2075.             }
  2077.             p_session = GetLength( &p_tpdu[3], &i_session_size );
  2078.             if ( i_session_size <= 1 )
  2079.                 continue;
  2081.             p_session++;
  2082.             i_session_size--;
  2084.             if ( i_tag != T_DATA_LAST )
  2085.             {
  2086.                 msg_Err( p_access,
  2087.                          "en50221_Poll: fragmented TPDU not supported" );
  2088.                 break;
  2089.             }
  2091.             SPDUHandle( p_access, i_slot, p_session, i_session_size );
  2092.         }
  2093.     }
  2095.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2096.     {
  2097.         if ( p_sys->p_sessions[i_session_id - 1].i_resource_id
  2098.               && p_sys->p_sessions[i_session_id - 1].pf_manage )
  2099.         {
  2100.             p_sys->p_sessions[i_session_id - 1].pf_manage( p_access,
  2101.                                                            i_session_id );
  2102.         }
  2103.     }
  2105.     return VLC_SUCCESS;
  2106. }
  2109. /*****************************************************************************
  2110.  * en50221_SetCAPMT :
  2111.  *****************************************************************************/
  2112. int en50221_SetCAPMT( access_t * p_access, dvbpsi_pmt_t *p_pmt )
  2113. {
  2114.     access_sys_t *p_sys = p_access->p_sys;
  2115.     int i, i_session_id;
  2116.     bool b_update = false;
  2117.     bool b_needs_descrambling = CAPMTNeedsDescrambling( p_pmt );
  2119.     for ( i = 0; i < MAX_PROGRAMS; i++ )
  2120.     {
  2121.         if ( p_sys->pp_selected_programs[i] != NULL
  2122.               && p_sys->pp_selected_programs[i]->i_program_number
  2123.                   == p_pmt->i_program_number )
  2124.         {
  2125.             b_update = true;
  2127.             if ( !b_needs_descrambling )
  2128.             {
  2129.                 dvbpsi_DeletePMT( p_pmt );
  2130.                 p_pmt = p_sys->pp_selected_programs[i];
  2131.                 p_sys->pp_selected_programs[i] = NULL;
  2132.             }
  2133.             else if( p_pmt != p_sys->pp_selected_programs[i] )
  2134.             {
  2135.                 dvbpsi_DeletePMT( p_sys->pp_selected_programs[i] );
  2136.                 p_sys->pp_selected_programs[i] = p_pmt;
  2137.             }
  2139.             break;
  2140.         }
  2141.     }
  2143.     if ( !b_update && b_needs_descrambling )
  2144.     {
  2145.         for ( i = 0; i < MAX_PROGRAMS; i++ )
  2146.         {
  2147.             if ( p_sys->pp_selected_programs[i] == NULL )
  2148.             {
  2149.                 p_sys->pp_selected_programs[i] = p_pmt;
  2150.                 break;
  2151.             }
  2152.         }
  2153.     }
  2155.     if ( b_update || b_needs_descrambling )
  2156.     {
  2157.         for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2158.         {
  2159.             if ( p_sys->p_sessions[i_session_id - 1].i_resource_id
  2160.                     == RI_CONDITIONAL_ACCESS_SUPPORT )
  2161.             {
  2162.                 if ( b_update && b_needs_descrambling )
  2163.                     CAPMTUpdate( p_access, i_session_id, p_pmt );
  2164.                 else if ( b_update )
  2165.                     CAPMTDelete( p_access, i_session_id, p_pmt );
  2166.                 else
  2167.                     CAPMTAdd( p_access, i_session_id, p_pmt );
  2168.             }
  2169.         }
  2170.     }
  2172.     if ( !b_needs_descrambling )
  2173.     {
  2174.         dvbpsi_DeletePMT( p_pmt );
  2175.     }
  2177.     return VLC_SUCCESS;
  2178. }
  2180. /*****************************************************************************
  2181.  * en50221_OpenMMI :
  2182.  *****************************************************************************/
  2183. int en50221_OpenMMI( access_t * p_access, int i_slot )
  2184. {
  2185.     access_sys_t *p_sys = p_access->p_sys;
  2187.     if( p_sys->i_ca_type & CA_CI_LINK )
  2188.     {
  2189.         int i_session_id;
  2190.         for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2191.         {
  2192.             if ( p_sys->p_sessions[i_session_id - 1].i_resource_id == RI_MMI
  2193.                   && p_sys->p_sessions[i_session_id - 1].i_slot == i_slot )
  2194.             {
  2195.                 msg_Dbg( p_access,
  2196.                          "MMI menu is already opened on slot %d (session=%d)",
  2197.                          i_slot, i_session_id );
  2198.                 return VLC_SUCCESS;
  2199.             }
  2200.         }
  2202.         for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2203.         {
  2204.             if ( p_sys->p_sessions[i_session_id - 1].i_resource_id
  2205.                     == RI_APPLICATION_INFORMATION
  2206.                   && p_sys->p_sessions[i_session_id - 1].i_slot == i_slot )
  2207.             {
  2208.                 ApplicationInformationEnterMenu( p_access, i_session_id );
  2209.                 return VLC_SUCCESS;
  2210.             }
  2211.         }
  2213.         msg_Err( p_access, "no application information on slot %d", i_slot );
  2214.         return VLC_EGENERIC;
  2215.     }
  2216.     else
  2217.     {
  2218.         msg_Err( p_access, "MMI menu not supported" );
  2219.         return VLC_EGENERIC;
  2220.     }
  2221. }
  2223. /*****************************************************************************
  2224.  * en50221_CloseMMI :
  2225.  *****************************************************************************/
  2226. int en50221_CloseMMI( access_t * p_access, int i_slot )
  2227. {
  2228.     access_sys_t *p_sys = p_access->p_sys;
  2230.     if( p_sys->i_ca_type & CA_CI_LINK )
  2231.     {
  2232.         int i_session_id;
  2233.         for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2234.         {
  2235.             if ( p_sys->p_sessions[i_session_id - 1].i_resource_id == RI_MMI
  2236.                   && p_sys->p_sessions[i_session_id - 1].i_slot == i_slot )
  2237.             {
  2238.                 MMISendClose( p_access, i_session_id );
  2239.                 return VLC_SUCCESS;
  2240.             }
  2241.         }
  2243.         msg_Warn( p_access, "closing a non-existing MMI session on slot %d",
  2244.                   i_slot );
  2245.         return VLC_EGENERIC;
  2246.     }
  2247.     else
  2248.     {
  2249.         msg_Err( p_access, "MMI menu not supported" );
  2250.         return VLC_EGENERIC;
  2251.     }
  2252. }
  2254. /*****************************************************************************
  2255.  * en50221_GetMMIObject :
  2256.  *****************************************************************************/
  2257. en50221_mmi_object_t *en50221_GetMMIObject( access_t * p_access,
  2258.                                                 int i_slot )
  2259. {
  2260.     access_sys_t *p_sys = p_access->p_sys;
  2261.     int i_session_id;
  2263.     if ( p_sys->pb_slot_mmi_expected[i_slot] == true )
  2264.         return NULL; /* should not happen */
  2266.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2267.     {
  2268.         if ( p_sys->p_sessions[i_session_id - 1].i_resource_id == RI_MMI
  2269.               && p_sys->p_sessions[i_session_id - 1].i_slot == i_slot )
  2270.         {
  2271.             mmi_t *p_mmi =
  2272.                 (mmi_t *)p_sys->p_sessions[i_session_id - 1].p_sys;
  2273.             if ( p_mmi == NULL )
  2274.                 return NULL; /* should not happen */
  2275.             return &p_mmi->last_object;
  2276.         }
  2277.     }
  2279.     return NULL;
  2280. }
  2283. /*****************************************************************************
  2284.  * en50221_SendMMIObject :
  2285.  *****************************************************************************/
  2286. void en50221_SendMMIObject( access_t * p_access, int i_slot,
  2287.                                 en50221_mmi_object_t *p_object )
  2288. {
  2289.     access_sys_t *p_sys = p_access->p_sys;
  2290.     int i_session_id;
  2292.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2293.     {
  2294.         if ( p_sys->p_sessions[i_session_id - 1].i_resource_id == RI_MMI
  2295.               && p_sys->p_sessions[i_session_id - 1].i_slot == i_slot )
  2296.         {
  2297.             MMISendObject( p_access, i_session_id, p_object );
  2298.             return;
  2299.         }
  2300.     }
  2302.     msg_Err( p_access, "SendMMIObject when no MMI session is opened !" );
  2303. }
  2305. /*****************************************************************************
  2306.  * en50221_End :
  2307.  *****************************************************************************/
  2308. void en50221_End( access_t * p_access )
  2309. {
  2310.     access_sys_t *p_sys = p_access->p_sys;
  2311.     int i_session_id, i;
  2313.     for ( i = 0; i < MAX_PROGRAMS; i++ )
  2314.     {
  2315.         if ( p_sys->pp_selected_programs[i] != NULL )
  2316.         {
  2317.             dvbpsi_DeletePMT( p_sys->pp_selected_programs[i] );
  2318.         }
  2319.     }
  2321.     for ( i_session_id = 1; i_session_id <= MAX_SESSIONS; i_session_id++ )
  2322.     {
  2323.         if ( p_sys->p_sessions[i_session_id - 1].i_resource_id
  2324.               && p_sys->p_sessions[i_session_id - 1].pf_close != NULL )
  2325.         {
  2326.             p_sys->p_sessions[i_session_id - 1].pf_close( p_access,
  2327.                                                           i_session_id );
  2328.         }
  2329.     }
  2331.     /* Leave the CAM configured, so that it can be reused in another
  2332.      * program. */
  2333. }
  2335. static inline void *FixUTF8( char *p )
  2336. {
  2337.     EnsureUTF8( p );
  2338.     return p;
  2339. }
  2341. char *dvbsi_to_utf8( char *psz_instring, size_t i_length )
  2342. {
  2343.     const char *psz_encoding, *psz_stringstart;
  2344.     char *psz_outstring, *psz_tmp;
  2345.     char psz_encbuf[12];
  2346.     size_t i_in, i_out;
  2347.     vlc_iconv_t iconv_handle;
  2348.     if( i_length < 1 ) return NULL;
  2349.     if( psz_instring[0] < 0 || psz_instring[0] >= 0x20 )
  2350.     {
  2351.         psz_stringstart = psz_instring;
  2352.         psz_encoding = "ISO_8859-1"; /* should be ISO6937 according to spec, but this seems to be the one used */
  2353.     } else switch( psz_instring[0] )
  2354.     {
  2355.     case 0x01:
  2356.         psz_stringstart = &psz_instring[1];
  2357.         psz_encoding = "ISO_8859-5";
  2358.         break;
  2359.     case 0x02:
  2360.         psz_stringstart = &psz_instring[1];
  2361.         psz_encoding = "ISO_8859-6";
  2362.         break;
  2363.     case 0x03:
  2364.         psz_stringstart = &psz_instring[1];
  2365.         psz_encoding = "ISO_8859-7";
  2366.         break;
  2367.     case 0x04:
  2368.         psz_stringstart = &psz_instring[1];
  2369.         psz_encoding = "ISO_8859-8";
  2370.         break;
  2371.     case 0x05:
  2372.         psz_stringstart = &psz_instring[1];
  2373.         psz_encoding = "ISO_8859-9";
  2374.         break;
  2375.     case 0x06:
  2376.         psz_stringstart = &psz_instring[1];
  2377.         psz_encoding = "ISO_8859-10";
  2378.         break;
  2379.     case 0x07:
  2380.         psz_stringstart = &psz_instring[1];
  2381.         psz_encoding = "ISO_8859-11";
  2382.         break;
  2383.     case 0x08:
  2384.         psz_stringstart = &psz_instring[1]; /*possibly reserved?*/
  2385.         psz_encoding = "ISO_8859-12";
  2386.         break;
  2387.     case 0x09:
  2388.         psz_stringstart = &psz_instring[1];
  2389.         psz_encoding = "ISO_8859-13";
  2390.         break;
  2391.     case 0x0a:
  2392.         psz_stringstart = &psz_instring[1];
  2393.         psz_encoding = "ISO_8859-14";
  2394.         break;
  2395.     case 0x0b:
  2396.         psz_stringstart = &psz_instring[1];
  2397.         psz_encoding = "ISO_8859-15";
  2398.         break;
  2399.     case 0x10:
  2400.         if( i_length < 3 || psz_instring[1] != '' || psz_instring[2] > 0x0f
  2401.             || psz_instring[2] == 0 )
  2402.             return FixUTF8(strndup(psz_instring,i_length));
  2403.         sprintf( psz_encbuf, "ISO_8859-%d", psz_instring[2] );
  2404.         psz_stringstart = &psz_instring[3];
  2405.         psz_encoding = psz_encbuf;
  2406.         break;
  2407.     case 0x11:
  2408.         psz_stringstart = &psz_instring[1];
  2409.         psz_encoding = "UTF-16";
  2410.         break;
  2411.     case 0x12:
  2412.         psz_stringstart = &psz_instring[1];
  2413.         psz_encoding = "KSC5601-1987";
  2414.         break;
  2415.     case 0x13:
  2416.         psz_stringstart = &psz_instring[1];
  2417.         psz_encoding = "GB2312";/*GB-2312-1980 */
  2418.         break;
  2419.     case 0x14:
  2420.         psz_stringstart = &psz_instring[1];
  2421.         psz_encoding = "BIG-5";
  2422.         break;
  2423.     case 0x15:
  2424.         return FixUTF8(strndup(&psz_instring[1],i_length-1));
  2425.         break;
  2426.     default:
  2427.         /* invalid */
  2428.         return FixUTF8(strndup(psz_instring,i_length));
  2429.     }
  2430.     iconv_handle = vlc_iconv_open( "UTF-8", psz_encoding );
  2431.     i_in = i_length - (psz_stringstart - psz_instring );
  2432.     i_out = i_in * 6;
  2433.     psz_outstring = psz_tmp = (char*)malloc( i_out + 1 );
  2434.     vlc_iconv( iconv_handle, &psz_stringstart, &i_in, &psz_tmp, &i_out );
  2435.     vlc_iconv_close( iconv_handle );
  2436.     *psz_tmp = '';
  2437.     return psz_outstring;
  2438. }