add datetime mgr
[enigma2.git] / lib / dvb_ci / dvbci_session.cpp
1 /* DVB CI Transport Connection */
2
3 #include <lib/dvb_ci/dvbci_session.h>
4 #include <lib/dvb_ci/dvbci_resmgr.h>
5 #include <lib/dvb_ci/dvbci_appmgr.h>
6 #include <lib/dvb_ci/dvbci_camgr.h>
7 #include <lib/dvb_ci/dvbci_datetimemgr.h>
8
9 int eDVBCISession::buildLengthField(unsigned char *pkt, int len)
10 {
11         if (len < 127)
12         {
13                 *pkt++=len;
14                 return 1;
15         } else if (len < 256)
16         {
17                 *pkt++=0x81;
18                 *pkt++=len;
19                 return 2;
20         } else if (len < 65535)
21         {
22                 *pkt++=0x82;
23                 *pkt++=len>>8;
24                 *pkt++=len;
25                 return 3;
26         } else
27         {
28                 printf("too big length\n");
29                 exit(0);
30         }
31 }
32
33 int eDVBCISession::parseLengthField(const unsigned char *pkt, int &len)
34 {
35         len=0;
36         if (!(*pkt&0x80)) 
37         {
38                 len = *pkt;
39                 return 1;
40         }
41         for (int i=0; i<(pkt[0]&0x7F); ++i)
42         {
43                 len <<= 8;
44                 len |= pkt[i + 1];
45         }
46         return (pkt[0] & 0x7F) + 1;
47 }
48
49 void eDVBCISession::sendAPDU(const unsigned char *tag, const void *data, int len)
50 {
51         unsigned char pkt[len+3+4];
52         int l;
53         memcpy(pkt, tag, 3);
54         l=buildLengthField(pkt+3, len);
55         if (data)
56                 memcpy(pkt+3+l, data, len);
57         sendSPDU(0x90, 0, 0, pkt, len+3+l);
58 }
59
60 void eDVBCISession::sendSPDU(unsigned char tag, const void *data, int len, const void *apdu, int alen)
61 {
62         sendSPDU(slot, tag, data, len, session_nb, apdu, alen);
63 }
64
65 void eDVBCISession::sendSPDU(eDVBCISlot *slot, unsigned char tag, const void *data, int len, unsigned short session_nb, const void *apdu,int alen)
66 {
67         unsigned char pkt[4096];
68         unsigned char *ptr=pkt;
69         *ptr++=tag;
70         ptr+=buildLengthField(ptr, len+2);
71         if (data)
72                 memcpy(ptr, data, len);
73         ptr+=len;
74         *ptr++=session_nb>>8;
75         *ptr++=session_nb;
76
77         if (apdu)
78                 memcpy(ptr, apdu, alen);
79
80         ptr+=alen;
81         slot->write(pkt, ptr - pkt);
82 }
83
84 void eDVBCISession::sendOpenSessionResponse(eDVBCISlot *slot, unsigned char session_status, const unsigned char *resource_identifier, unsigned short session_nb)
85 {
86         char pkt[6];
87         pkt[0]=session_status;
88         printf("sendOpenSessionResponse\n");
89         memcpy(pkt + 1, resource_identifier, 4);
90         sendSPDU(slot, 0x92, pkt, 5, session_nb);
91 }
92
93 void eDVBCISession::recvCreateSessionResponse(const unsigned char *data)
94 {
95         status = data[0];
96         state = stateStarted;
97         action = 1;
98         printf("create Session Response, status %x\n", status);
99 }
100
101 void eDVBCISession::recvCloseSessionRequest(const unsigned char *data)
102 {
103         state = stateInDeletion;
104         action = 1;
105         printf("close Session Request\n");
106 }
107
108 eDVBCISession *eDVBCISession::createSession(eDVBCISlot *slot, const unsigned char *resource_identifier, unsigned char &status)
109 {
110         eDVBCISession *session;
111         unsigned long tag;
112         unsigned short session_nb;
113         for (session_nb=1; session_nb < SLMS; ++session_nb)
114                 if (!sessions[session_nb-1])
115                         break;
116         if (session_nb == SLMS)
117         {
118                 status=0xF3;
119                 return 0;
120         }
121
122         tag = resource_identifier[0] << 24;
123         tag|= resource_identifier[1] << 16;
124         tag|= resource_identifier[2] << 8;
125         tag|= resource_identifier[3];
126
127         switch (tag)
128         {
129         case 0x00010041:
130                 session=new eDVBCIResourceManagerSession;
131                 printf("RESOURCE MANAGER\n");
132                 break;
133         case 0x00020041:
134                 session=slot->application_manager = new eDVBCIApplicationManagerSession;
135                 printf("APPLICATION MANAGER\n");
136                 break;
137         case 0x00030041:
138                 session=slot->ca_manager=new eDVBCICAManagerSession;
139                 printf("CA MANAGER\n");
140                 break;
141         case 0x00240041:
142                 session=new eDVBCIDateTimeSession;
143                 printf("DATE-TIME\n");
144                 break;
145         case 0x00400041:
146 //              session=new eDVBCIMMISession;
147                 printf("MMI\n");
148                 break;
149         case 0x00100041:
150 //              session=new eDVBCIAuthSession;
151                 printf("AuthSession\n");
152                 break;
153         case 0x00200041:
154         default:
155                 printf("unknown resource type %02x %02x %02x %02x\n", resource_identifier[0], resource_identifier[1], resource_identifier[2],resource_identifier[3]);
156                 session=0;
157                 status=0xF0;
158         }
159
160         if (!session)
161         {
162                 printf("unknown session.. expect crash\n");
163                 return 0;
164         }
165         printf("new session_nb: %d\n", session_nb);
166         session->session_nb = session_nb;
167         if (session)
168         {
169                 printf("session ok, status %02x\n", session->status);
170                 status = session->getStatus();
171                 if (status)
172                 {
173                         delete session;
174                         session = 0;
175                 }
176                 sessions[session_nb - 1] = session;
177                 session->slot = slot;
178         }
179         session->state = stateInCreation;
180         return session;
181 }
182
183 void eDVBCISession::receiveData(eDVBCISlot *slot, const unsigned char *ptr, size_t len)
184 {
185         const unsigned char *pkt = (const unsigned char*)ptr;
186         unsigned char tag = *pkt++;
187         int llen, hlen;
188         
189         llen = parseLengthField(pkt, hlen);
190         pkt += llen;
191         
192         eDVBCISession *session = NULL;
193         
194         if(tag == 0x91)
195         {
196                 unsigned char status;
197                 session = createSession(slot, pkt, status);
198                 sendOpenSessionResponse(slot, status, pkt, session?session->session_nb:0);
199
200                 if (session)
201                 {
202                         session->state=stateStarted;
203                         session->action=1;
204                 }
205         }
206         else
207         {
208                 unsigned session_nb;
209                 session_nb=pkt[hlen-2]<<8;
210                 session_nb|=pkt[hlen-1]&0xFF;
211                 
212                 if ((!session_nb) || (session_nb >= SLMS))
213                 {
214                         printf("PROTOCOL: illegal session number %x\n", session_nb);
215                         return;
216                 }
217                 
218                 session=sessions[session_nb-1];
219                 if (!session)
220                 {
221                         printf("PROTOCOL: data on closed session %x\n", session_nb);
222                         return;
223                 }
224
225                 switch (tag)
226                 {
227                 case 0x90:
228                         break;
229                 case 0x94:
230                         session->recvCreateSessionResponse(pkt);
231                         break;
232                 case 0x95:
233                         printf("recvCloseSessionRequest\n");
234                         session->recvCloseSessionRequest(pkt);
235                         break;
236                 default:
237                         printf("INTERNAL: nyi, tag %02x.\n", tag);
238                         return;
239                 }
240         }
241         
242         hlen += llen + 1; // lengthfield and tag
243
244         pkt = ((const unsigned char*)ptr) + hlen;
245         len -= hlen;
246
247         if (session)
248                 while (len > 0)
249                 {
250                         int alen;
251                         const unsigned char *tag=pkt;
252                         pkt+=3; // tag
253                         len-=3;
254                         hlen=parseLengthField(pkt, alen);
255                         pkt+=hlen;
256                         len-=hlen;
257
258                         //if (eDVBCIModule::getInstance()->workarounds_active & eDVBCIModule::workaroundMagicAPDULength)
259                         //{
260                         //      if (((len-alen) > 0) && ((len - alen) < 3))
261                         //      {
262                         //              printf("WORKAROUND: applying work around MagicAPDULength\n");
263                         //              alen=len;
264                         //      }
265                         //}
266                         if (session->receivedAPDU(tag, pkt, alen))
267                                 session->action = 1;
268                         pkt+=alen;
269                         len-=alen;
270                 }
271                 
272         if (len)
273                 printf("PROTOCOL: warning, TL-Data has invalid length\n");
274 }