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