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