?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added Streamrelay libdvbcsa - thanks to lpm11 <lpm11@lpm11>, fegol, icb, loka, kitte8...
[oscam.git] / module-streamrelay.c
blob80b10d40230fbe1903d0154a5bd1ad256becfa11
1 #define MODULE_LOG_PREFIX "relay"
2
3 #include "globals.h"
4
5 #ifdef MODULE_STREAMRELAY
6
7 #include "module-streamrelay.h"
8 #include "oscam-config.h"
9 #include "oscam-net.h"
10 #include "oscam-string.h"
11 #include "oscam-time.h"
12 #include "oscam-chk.h"
13
14 #define STREAM_UNDEFINED 0x00
15 #define STREAM_VIDEO 0x01
16 #define STREAM_AUDIO 0x02
17 #define STREAM_SUBTITLE 0x03
18 #define STREAM_TELETEXT 0x04
19
20 extern int32_t exit_oscam;
21
22 typedef struct
23 {
24 int32_t connfd;
25 int32_t connid;
26 } stream_client_conn_data;
27
28 char stream_source_host[256];
29 char *stream_source_auth = NULL;
30 uint32_t cluster_size = 50;
31
32 static uint8_t stream_server_mutex_init = 0;
33 static pthread_mutex_t stream_server_mutex;
34 static int32_t glistenfd, gconncount = 0, gconnfd[STREAM_SERVER_MAX_CONNECTIONS];
35
36 static pthread_mutex_t fixed_key_srvid_mutex;
37 static uint16_t stream_cur_srvid[STREAM_SERVER_MAX_CONNECTIONS];
38 static stream_client_key_data key_data[STREAM_SERVER_MAX_CONNECTIONS];
39
40 #ifdef MODULE_RADEGAST
41 static int32_t gRadegastFd = 0;
42
43 static bool connect_to_radegast(void)
44 {
45 struct SOCKADDR cservaddr;
46
47 if (gRadegastFd == 0)
48 gRadegastFd = socket(DEFAULT_AF, SOCK_STREAM, 0);
49
50 if (gRadegastFd < 0)
51 {
52 gRadegastFd = 0;
53 return false;
54 }
55
56 int32_t flags = fcntl(gRadegastFd, F_GETFL);
57 fcntl(gRadegastFd, F_SETFL, flags | O_NONBLOCK);
58
59 bzero(&cservaddr, sizeof(cservaddr));
60 SIN_GET_FAMILY(cservaddr) = DEFAULT_AF;
61 SIN_GET_PORT(cservaddr) = htons(cfg.rad_port);
62 SIN_GET_ADDR(cservaddr) = cfg.rad_srvip;
63
64 if (connect(gRadegastFd, (struct sockaddr *)&cservaddr, sizeof(cservaddr)) == -1)
65 {
66 return false;
67 }
68
69 return true;
70 }
71
72 static void close_radegast_connection(void)
73 {
74 close(gRadegastFd);
75 gRadegastFd = 0;
76 }
77
78 static bool send_to_radegast(uint8_t* data, int len)
79 {
80 if (send(gRadegastFd, data, len, 0) < 0)
81 {
82 cs_log("send_to_radegast: Send failure");
83 return false;
84 }
85 return true;
86 }
87
88 static void radegast_client_ecm(stream_client_data *cdata)
89 {
90 uint16_t section_length = SCT_LEN(cdata->ecm_data);
91 uint8_t md5tmp[MD5_DIGEST_LENGTH];
92 MD5(cdata->ecm_data, section_length, md5tmp);
93
94 if (!memcmp(cdata->ecm_md5, md5tmp, MD5_DIGEST_LENGTH)) { return; }
95 memcpy(cdata->ecm_md5, md5tmp, MD5_DIGEST_LENGTH);
96
97 uint16_t packet_len;
98 static uint8_t header_len = 2;
99 static uint8_t payload_static_len = 12;
100
101 if (gRadegastFd <= 0)
102 { connect_to_radegast(); }
103
104 packet_len = header_len + payload_static_len + section_length;
105 uint8_t outgoing_data[packet_len];
106 outgoing_data[0] = 1;
107 outgoing_data[1] = payload_static_len + section_length;
108 outgoing_data[2] = 10; // caid
109 outgoing_data[3] = 2;
110 outgoing_data[4] = cdata->caid >> 8;
111 outgoing_data[5] = cdata->caid & 0xFF;
112 outgoing_data[6] = 9; // srvid
113 outgoing_data[7] = 4;
114 outgoing_data[8] = cdata->srvid & 0xFF;
115 outgoing_data[10] = cdata->srvid >> 8;
116 outgoing_data[12] = 3;
117 outgoing_data[13] = section_length;
118
119 memcpy(outgoing_data + header_len + payload_static_len, cdata->ecm_data, section_length);
120
121 if (!send_to_radegast(outgoing_data, packet_len))
122 {
123 close_radegast_connection();
124 if (connect_to_radegast())
125 {
126 send_to_radegast(outgoing_data, packet_len);
127 }
128 }
129 }
130
131 void ParseEcmData(stream_client_data *cdata)
132 {
133 uint8_t *data = cdata->ecm_data;
134 uint16_t section_length = SCT_LEN(data);
135
136 if (section_length < 11)
137 {
138 return;
139 }
140
141 radegast_client_ecm(cdata);
142 }
143 #endif // MODULE_RADEGAST
144
145 static void write_cw(ECM_REQUEST *er, int32_t connid)
146 {
147 const uint8_t ecm = (caid_is_videoguard(er->caid) && (er->ecm[4] != 0 && (er->ecm[2] - er->ecm[4]) == 4)) ? er->ecm[21] : 0;
148 if (memcmp(er->cw, "\x00\x00\x00\x00\x00\x00\x00\x00", 8) != 0)
149 {
150 dvbcsa_bs_key_set(er->cw, key_data[connid].key[EVEN]);
151 }
152
153 if (memcmp(er->cw + 8, "\x00\x00\x00\x00\x00\x00\x00\x00", 8) != 0)
154 {
155 dvbcsa_bs_key_set(er->cw + 8, key_data[connid].key[ODD]);
156 }
157 }
158
159 bool stream_write_cw(ECM_REQUEST *er)
160 {
161 int32_t i;
162 if (er->rc == E_FOUND)
163 {
164 bool cw_written = false;
165 //SAFE_MUTEX_LOCK(&fixed_key_srvid_mutex);
166 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
167 {
168 if (stream_cur_srvid[i] == er->srvid)
169 {
170 write_cw(er, i);
171 cw_written = true;
172 // don't return as there might be more connections for the same channel (e.g. recordings)
173 }
174 }
175 //SAFE_MUTEX_UNLOCK(&fixed_key_srvid_mutex);
176 return cw_written;
177 }
178 return true;
179 }
180
181 static void SearchTsPackets(const uint8_t *buf, const uint32_t bufLength, uint16_t *packetSize, uint16_t *startOffset)
182 {
183 uint32_t i;
184
185 for (i = 0; i < bufLength; i++)
186 {
187 if (buf[i] == 0x47)
188 {
189 // if three packets align, probably safe to assume correct size
190 if ((buf[i + 188] == 0x47) & (buf[i + 376] == 0x47))
191 {
192 (*packetSize) = 188;
193 (*startOffset) = i;
194 return;
195 }
196 else if ((buf[i + 204] == 0x47) & (buf[i + 408] == 0x47))
197 {
198 (*packetSize) = 204;
199 (*startOffset) = i;
200 return;
201 }
202 else if ((buf[i + 208] == 0x47) & (buf[i + 416] == 0x47))
203 {
204 (*packetSize) = 208;
205 (*startOffset) = i;
206 return;
207 }
208 }
209 }
210
211 (*packetSize) = 0;
212 (*startOffset) = 0;
213 }
214
215 typedef void (*ts_data_callback)(stream_client_data *cdata);
216
217 static void ParseTsData(const uint8_t table_id, const uint8_t table_mask, const uint8_t min_table_length, int8_t *flag,
218 uint8_t *data, const uint16_t data_length, uint16_t *data_pos, const int8_t payloadStart,
219 const uint8_t *buf, const int32_t len, ts_data_callback func, stream_client_data *cdata)
220 {
221 int32_t i;
222 uint16_t offset = 0;
223 bool found_start = 0;
224
225 if (len < 1)
226 {
227 return;
228 }
229
230 if (*flag == 0 && !payloadStart)
231 {
232 return;
233 }
234
235 if (*flag == 0)
236 {
237 *data_pos = 0;
238 offset = 1 + buf[0];
239 }
240 else if (payloadStart)
241 {
242 offset = 1;
243 }
244
245 if ((len - offset) < 1)
246 {
247 return;
248 }
249
250 const int32_t free_data_length = (data_length - *data_pos);
251 const int32_t copySize = (len - offset) > free_data_length ? free_data_length : (len - offset);
252
253 memcpy(data + *data_pos, buf + offset, copySize);
254 *data_pos += copySize;
255
256 for (i = 0; i < *data_pos; i++)
257 {
258 if ((data[i] & table_mask) == table_id)
259 {
260 if (i != 0)
261 {
262 if (*data_pos - i > i)
263 {
264 memmove(data, &data[i], *data_pos - i);
265 }
266 else
267 {
268 memcpy(data, &data[i], *data_pos - i);
269 }
270
271 *data_pos -= i;
272 }
273 found_start = 1;
274 break;
275 }
276 }
277
278 const uint16_t section_length = SCT_LEN(data);
279
280 if (!found_start || (section_length > data_length) || (section_length < min_table_length))
281 {
282 *flag = 0;
283 return;
284 }
285
286 if ((*data_pos < section_length) || (*data_pos < 3))
287 {
288 *flag = 2;
289 return;
290 }
291
292 func(cdata);
293
294 found_start = 0;
295 for (i = section_length; i < *data_pos; i++)
296 {
297 if ((data[i] & table_mask) == table_id)
298 {
299 if (*data_pos - i > i)
300 {
301 memmove(data, &data[i], *data_pos - i);
302 }
303 else
304 {
305 memcpy(data, &data[i], *data_pos - i);
306 }
307
308 *data_pos -= i;
309 found_start = 1;
310 break;
311 }
312 }
313
314 if (!found_start || (data_length < *data_pos + copySize + 1))
315 {
316 *data_pos = 0;
317 }
318
319 *flag = 1;
320 }
321
322 static void ParsePatData(stream_client_data *cdata)
323 {
324 int32_t i;
325 uint16_t srvid;
326 #ifdef __BISS__
327 cdata->STREAMpidcount = 0;
328 #endif
329 for (i = 8; i + 7 < SCT_LEN(cdata->pat_data); i += 4)
330 {
331 srvid = b2i(2, cdata->pat_data + i);
332 if (srvid == 0)
333 {
334 continue;
335 }
336
337 if (cdata->srvid == srvid)
338 {
339 cdata->pmt_pid = b2i(2, cdata->pat_data + i + 2) & 0x1FFF;
340 cs_log_dbg(D_READER, "Stream client %i found pmt pid: 0x%04X (%i)",
341 cdata->connid, cdata->pmt_pid, cdata->pmt_pid);
342 break;
343 }
344 }
345 }
346
347 static void ParseDescriptors(const uint8_t *buffer, const uint16_t info_length, uint8_t *type)
348 {
349 uint32_t i;
350 uint8_t j, descriptor_length = 0;
351
352 if (info_length < 1)
353 {
354 return;
355 }
356
357 for (i = 0; i + 1 < info_length; i += descriptor_length + 2)
358 {
359 descriptor_length = buffer[i + 1];
360 switch (buffer[i]) // descriptor tag
361 {
362 case 0x05: // Registration descriptor
363 {
364 // "HDMV" format identifier is removed
365 // Cam does not need to know about Blu-ray
366 const char format_identifiers_audio[10][5] =
367 {
368 "AC-3", "BSSD", "dmat", "DRA1", "DTS1",
369 "DTS2", "DTS3", "EAC3", "mlpa", "Opus",
370 };
371 for (j = 0; j < 10; j++)
372 {
373 if (memcmp(buffer + i + 2, format_identifiers_audio[j], 4) == 0)
374 {
375 *type = STREAM_AUDIO;
376 break;
377 }
378 }
379 break;
380 }
381 //case 0x09: // CA descriptor
382 //{
383 // break;
384 //}
385 case 0x46: // VBI teletext descriptor (DVB)
386 case 0x56: // teletext descriptor (DVB)
387 {
388 *type = STREAM_TELETEXT;
389 break;
390 }
391 case 0x59: // subtitling descriptor (DVB)
392 {
393 *type = STREAM_SUBTITLE;
394 break;
395 }
396 case 0x6A: // AC-3 descriptor (DVB)
397 case 0x7A: // enhanced AC-3 descriptor (DVB)
398 case 0x7B: // DTS descriptor (DVB)
399 case 0x7C: // AAC descriptor (DVB)
400 case 0x81: // AC-3 descriptor (ATSC)
401 case 0xCC: // Enhanced AC-3 descriptor (ATSC)
402 {
403 *type = STREAM_AUDIO;
404 break;
405 }
406 case 0x7F: // extension descriptor (DVB)
407 {
408 switch(buffer[i + 2]) // extension descriptor tag
409 {
410 case 0x0E: // DTS-HD descriptor (DVB)
411 case 0x0F: // DTS Neural descriptor (DVB)
412 case 0x15: // AC-4 descriptor (DVB)
413 *type = STREAM_AUDIO;
414 break;
415
416 case 0x20: // TTML subtitling descriptor (DVB)
417 *type = STREAM_SUBTITLE;
418 break;
419
420 default:
421 *type = STREAM_UNDEFINED;
422 break;
423 }
424 break;
425 }
426 default:
427 break;
428 }
429 }
430 }
431
432 static void stream_parse_pmt_ca_descriptor(const uint8_t *data, const int32_t data_pos, const int32_t offset, const uint16_t info_length, stream_client_data *cdata)
433 {
434 if (cdata->ecm_pid)
435 {
436 return;
437 }
438
439 // parse program descriptors (we are looking only for CA descriptor here)
440 int32_t i;
441 uint16_t caid;
442 uint8_t descriptor_tag, descriptor_length = 0;
443
444 for (i = offset; i + 1 < offset + info_length; i += descriptor_length + 2)
445 {
446 descriptor_tag = data[i + data_pos];
447 descriptor_length = data[i + 1 + data_pos];
448 if (descriptor_length < 1)
449 {
450 break;
451 }
452
453 if (i + 1 + descriptor_length >= offset + info_length)
454 {
455 break;
456 }
457
458 if (descriptor_tag == 0x09 && descriptor_length >= 4)
459 {
460 caid = b2i(2, data + i + 2 + data_pos);
461 if (chk_ctab_ex(caid, &cfg.stream_relay_ctab))
462 {
463 if (cdata->caid == NO_CAID_VALUE)
464 {
465 cdata->caid = caid;
466 }
467
468 if (cdata->caid != caid)
469 {
470 continue;
471 }
472 cdata->ecm_pid = b2i(2, data + i + 4 + data_pos) & 0x1FFF;
473 cs_log_dbg(D_READER, "Stream client %i found ecm pid: 0x%04X (%i)",
474 cdata->connid, cdata->ecm_pid, cdata->ecm_pid);
475 }
476 }
477 }
478 }
479
480 static void ParsePmtData(stream_client_data *cdata)
481 {
482 int32_t i;
483 uint16_t program_info_length = 0, es_info_length = 0, elementary_pid;
484 const uint16_t section_length = SCT_LEN(cdata->pmt_data);
485 uint8_t offset = 0;
486
487 cdata->ecm_pid = 0;
488 cdata->pcr_pid = b2i(2, cdata->pmt_data + 8) & 0x1FFF;
489
490 if (cdata->pcr_pid != 0x1FFF)
491 {
492 cs_log_dbg(D_READER, "Stream client %i found pcr pid: 0x%04X (%i)",
493 cdata->connid, cdata->pcr_pid, cdata->pcr_pid);
494 }
495 program_info_length = b2i(2, cdata->pmt_data + 10) & 0xFFF;
496 if (!program_info_length)
497 {
498 offset = 5;
499 program_info_length = (b2i(2, cdata->pmt_data + 10 + offset) & 0xFFF);
500 }
501 if (12 + offset + program_info_length >= section_length) { return; }
502 stream_parse_pmt_ca_descriptor(cdata->pmt_data, 0, 12 + offset, program_info_length, cdata);
503
504 offset = offset == 5 ? 0 : program_info_length;
505 for (i = 12 + offset; i + 4 < section_length; i += 5 + es_info_length)
506 {
507 elementary_pid = b2i(2, cdata->pmt_data + i + 1) & 0x1FFF;
508 es_info_length = b2i(2, cdata->pmt_data + i + 3) & 0xFFF;
509 switch (cdata->pmt_data[i]) // stream type
510 {
511 case 0x01:
512 case 0x02:
513 case 0x10:
514 case 0x1B:
515 case 0x20:
516 case 0x24:
517 case 0x25:
518 case 0x42:
519 case 0xD1:
520 case 0xEA:
521 {
522 cs_log_dbg(D_READER, "Stream client %i found video pid: 0x%04X (%i)",
523 cdata->connid, elementary_pid, elementary_pid);
524 stream_parse_pmt_ca_descriptor(cdata->pmt_data, i, 5, es_info_length, cdata);
525 break;
526 }
527 case 0x03:
528 case 0x04:
529 case 0x0F:
530 case 0x11:
531 case 0x1C:
532 case 0x2D:
533 case 0x2E:
534 case 0x81:
535 {
536 cs_log_dbg(D_READER, "Stream client %i found audio pid: 0x%04X (%i)",
537 cdata->connid, elementary_pid, elementary_pid);
538 break;
539 }
540 case 0x06:
541 //case 0x81: // some ATSC AC-3 streams do not contain the AC-3 descriptor!
542 case 0x87:
543 {
544 uint8_t type = STREAM_UNDEFINED;
545 ParseDescriptors(cdata->pmt_data + i + 5, es_info_length, &type);
546 if (type == STREAM_AUDIO)
547 {
548 cs_log_dbg(D_READER, "Stream client %i found audio pid: 0x%04X (%i)",
549 cdata->connid, elementary_pid, elementary_pid);
550 }
551 else if (type == STREAM_TELETEXT)
552 {
553 cs_log_dbg(D_READER, "Stream client %i found teletext pid: 0x%04X (%i)",
554 cdata->connid, elementary_pid, elementary_pid);
555 }
556 break;
557 }
558 }
559 #ifdef __BISS__
560 cdata->STREAMpids[cdata->STREAMpidcount] = elementary_pid;
561 cdata->STREAMpidcount++;
562 #endif
563 }
564 }
565
566 static void ParseTsPackets(stream_client_data *data, uint8_t *stream_buf, uint32_t bufLength, uint16_t packetSize)
567 {
568 uint8_t payloadStart;
569 uint16_t pid, offset;
570 uint32_t i, tsHeader;
571
572 for (i = 0; i < bufLength; i += packetSize)
573 {
574 tsHeader = b2i(4, stream_buf + i);
575 pid = (tsHeader & 0x1FFF00) >> 8;
576 payloadStart = (tsHeader & 0x400000) >> 22;
577
578 if (tsHeader & 0x20)
579 {
580 offset = 4 + stream_buf[i + 4] + 1;
581 }
582 else
583 {
584 offset = 4;
585 }
586
587 if (packetSize - offset < 1)
588 {
589 continue;
590 }
591
592 if (pid == 0x0000 && data->have_pat_data != 1) // Search the PAT for the PMT pid
593 {
594 ParseTsData(0x00, 0xFF, 16, &data->have_pat_data, data->pat_data, sizeof(data->pat_data),
595 &data->pat_data_pos, payloadStart, stream_buf + i + offset, packetSize - offset, ParsePatData, data);
596 continue;
597 }
598
599 if (pid == data->pmt_pid && data->have_pmt_data != 1) // Search the PMT for PCR, ECM, Video and Audio pids
600 {
601 ParseTsData(0x02, 0xFF, 21, &data->have_pmt_data, data->pmt_data, sizeof(data->pmt_data),
602 &data->pmt_data_pos, payloadStart, stream_buf + i + offset, packetSize - offset, ParsePmtData, data);
603 continue;
604 }
605
606 // We have bot PAT and PMT data - No need to search the rest of the packets
607 if (data->have_pat_data == 1 && data->have_pmt_data == 1)
608 {
609 break;
610 }
611 }
612 }
613
614 static void decrypt(struct dvbcsa_bs_batch_s *tsbbatch, uint16_t fill[2], const uint8_t oddeven, const int32_t connid)
615 {
616 if (fill[oddeven] > 0)
617 {
618 #if 0
619 uint16_t i;
620 for(i = fill[oddeven]; i <= cluster_size; i++)
621 {
622 tsbbatch[i].data = NULL;
623 tsbbatch[i].len = 0;
624 }
625 #else
626 tsbbatch[fill[oddeven]].data = NULL;
627 #endif
628 //cs_log_dbg(D_READER, "dvbcsa (%s), batch=%d", oddeven == ODD ? "odd" : "even", fill[oddeven]);
629
630 fill[oddeven] = 0;
631
632 dvbcsa_bs_decrypt(key_data[connid].key[oddeven], tsbbatch, 184);
633 }
634 }
635 #define decrypt(a) decrypt(tsbbatch, fill, a, data->connid)
636
637 static void DescrambleTsPackets(stream_client_data *data, uint8_t *stream_buf, uint32_t bufLength, uint16_t packetSize, struct dvbcsa_bs_batch_s *tsbbatch)
638 {
639 uint32_t i, tsHeader;
640 uint16_t offset, fill[2] = {0,0};
641 uint8_t oddeven = 0;
642 #ifdef MODULE_RADEGAST
643 uint16_t pid;
644 uint8_t payloadStart;
645 #endif
646
647 for (i = 0; i < bufLength; i += packetSize)
648 {
649 tsHeader = b2i(4, stream_buf + i);
650 #ifdef MODULE_RADEGAST
651 pid = (tsHeader & 0x1FFF00) >> 8;
652 payloadStart = (tsHeader & 0x400000) >> 22;
653 #endif
654 offset = (tsHeader & 0x20) ? 4 + stream_buf[i + 4] + 1 : 4;
655 if (packetSize - offset < 1)
656 {
657 continue;
658 }
659 #ifdef MODULE_RADEGAST
660 #ifdef __BISS__
661 if(data->ecm_pid == 0x1FFF && caid_is_biss_fixed(data->caid))
662 {
663 uint32_t j, n;
664 uint16_t ecm_len = 7;
665 data->ecm_data[0] = 0x80; // to pass the cache check it must be 0x80 or 0x81
666 data->ecm_data[1] = 0x00;
667 data->ecm_data[2] = 0x04;
668 i2b_buf(2, data->srvid, data->ecm_data + 3);
669 i2b_buf(2, data->pmt_pid, data->ecm_data + 5);
670 for(j = 0, n = 7; j < data->STREAMpidcount; j++, n += 2)
671 {
672 i2b_buf(2, data->STREAMpids[j], data->ecm_data + n);
673 data->ecm_data[2] += 2;
674 ecm_len += 2;
675 }
676 data->ens &= 0x0FFFFFFF; // clear top 4 bits (in case of DVB-T/C or garbage), prepare for flagging
677 data->ens |= 0xA0000000; // flag to emu: this is the namespace, not a pid
678 i2b_buf(2, data->tsid, data->ecm_data + ecm_len); // place tsid after the last stream pid
679 i2b_buf(2, data->onid, data->ecm_data + ecm_len + 2); // place onid right after tsid
680 i2b_buf(4, data->ens, data->ecm_data + ecm_len + 4); // place namespace at the end of the ecm
681 data->ecm_data[2] += 8;
682 ParseEcmData(data);
683 } else
684 #endif // __BISS__
685 if (data->ecm_pid && pid == data->ecm_pid) // Process the ECM data
686 {
687 // set to null pid
688 stream_buf[i + 1] |= 0x1F;
689 stream_buf[i + 2] = 0xFF;
690 ParseTsData(0x80, 0xFE, 3, &data->have_ecm_data, data->ecm_data, sizeof(data->ecm_data),
691 &data->ecm_data_pos, payloadStart, stream_buf + i + offset, packetSize - offset, ParseEcmData, data);
692 continue;
693 }
694 #endif // MODULE_RADEGAST
695 if ((tsHeader & 0xC0) == 0)
696 {
697 continue;
698 }
699
700 stream_buf[i + 3] &= 0x3f; // consider it decrypted now
701 oddeven = (tsHeader & 0xC0) == 0xC0 ? ODD: EVEN;
702 decrypt(oddeven == ODD ? EVEN : ODD);
703 tsbbatch[fill[oddeven]].data = &stream_buf[i + offset];
704 tsbbatch[fill[oddeven]].len = packetSize - offset;
705 fill[oddeven]++;
706
707 if (fill[oddeven] > cluster_size - 1)
708 {
709 decrypt(oddeven);
710 }
711 }
712
713 decrypt(oddeven);
714 }
715
716 static int32_t connect_to_stream(char *http_buf, int32_t http_buf_len, char *stream_path)
717 {
718 struct SOCKADDR cservaddr;
719 IN_ADDR_T in_addr;
720
721 int32_t streamfd = socket(DEFAULT_AF, SOCK_STREAM, 0);
722 if (streamfd == -1) { return -1; }
723
724 struct timeval tv;
725 tv.tv_sec = 2;
726 tv.tv_usec = 0;
727 if (setsockopt(streamfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof tv))
728 {
729 cs_log("ERROR: setsockopt() failed for SO_RCVTIMEO");
730 return -1;
731 }
732
733 bzero(&cservaddr, sizeof(cservaddr));
734 SIN_GET_FAMILY(cservaddr) = DEFAULT_AF;
735 SIN_GET_PORT(cservaddr) = htons(cfg.stream_source_port);
736 cs_resolve(stream_source_host, &in_addr, NULL, NULL);
737 SIN_GET_ADDR(cservaddr) = in_addr;
738
739 if (connect(streamfd, (struct sockaddr *)&cservaddr, sizeof(cservaddr)) == -1)
740 {
741 cs_log("WARNING: Connect to stream source port %d failed", cfg.stream_source_port);
742 return -1;
743 }
744
745 if (stream_source_auth)
746 {
747 snprintf(http_buf, http_buf_len, "GET %s HTTP/1.1\nHost: %s:%u\n"
748 "User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0\n"
749 "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\n"
750 "Accept-Language: en-US\n"
751 "Authorization: Basic %s\n"
752 "Connection: keep-alive\n\n", stream_path, stream_source_host, cfg.stream_source_port, stream_source_auth);
753 }
754 else
755 {
756 snprintf(http_buf, http_buf_len, "GET %s HTTP/1.1\nHost: %s:%u\n"
757 "User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Firefox/38.0\n"
758 "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\n"
759 "Accept-Language: en-US\n"
760 "Connection: keep-alive\n\n", stream_path, stream_source_host, cfg.stream_source_port);
761 }
762
763 if (send(streamfd, http_buf, cs_strlen(http_buf), 0) == -1) { return -1; }
764 return streamfd;
765 }
766
767 static void stream_client_disconnect(stream_client_conn_data *conndata)
768 {
769 int32_t i;
770
771 SAFE_MUTEX_LOCK(&fixed_key_srvid_mutex);
772 stream_cur_srvid[conndata->connid] = NO_SRVID_VALUE;
773 SAFE_MUTEX_UNLOCK(&fixed_key_srvid_mutex);
774
775 SAFE_MUTEX_LOCK(&stream_server_mutex);
776 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
777 {
778 if (gconnfd[i] == conndata->connfd)
779 {
780 gconnfd[i] = -1;
781 gconncount--;
782 }
783 }
784 SAFE_MUTEX_UNLOCK(&stream_server_mutex);
785
786 shutdown(conndata->connfd, 2);
787 close(conndata->connfd);
788
789 cs_log("Stream client %i disconnected",conndata->connid);
790
791 NULLFREE(conndata);
792 }
793
794 static void *stream_client_handler(void *arg)
795 {
796 stream_client_conn_data *conndata = (stream_client_conn_data *)arg;
797 stream_client_data *data;
798
799 char *http_buf, stream_path[255], stream_path_copy[255];
800 char *saveptr, *token, http_version[4];
801
802 int8_t streamConnectErrorCount = 0, streamDataErrorCount = 0;
803 int32_t bytesRead = 0, http_status_code = 0;
804 int32_t i, clientStatus, streamStatus, streamfd;
805
806 uint8_t *stream_buf;
807 uint16_t packetCount = 0, packetSize = 0, startOffset = 0;
808 uint32_t remainingDataPos, remainingDataLength, tmp_pids[4];
809
810 const int32_t cur_dvb_buffer_size = DVB_BUFFER_SIZE_CSA;
811 const int32_t cur_dvb_buffer_wait = DVB_BUFFER_WAIT_CSA;
812
813 struct dvbcsa_bs_batch_s *tsbbatch;
814
815 cs_log("Stream client %i connected", conndata->connid);
816
817 if (!cs_malloc(&http_buf, 1024))
818 {
819 stream_client_disconnect(conndata);
820 return NULL;
821 }
822
823 if (!cs_malloc(&stream_buf, DVB_BUFFER_SIZE))
824 {
825 NULLFREE(http_buf);
826 stream_client_disconnect(conndata);
827 return NULL;
828 }
829
830 if (!cs_malloc(&data, sizeof(stream_client_data)))
831 {
832 NULLFREE(http_buf);
833 NULLFREE(stream_buf);
834 stream_client_disconnect(conndata);
835 return NULL;
836 }
837
838 clientStatus = recv(conndata->connfd, http_buf, 1024, 0);
839 if (clientStatus < 1)
840 {
841 NULLFREE(http_buf);
842 NULLFREE(stream_buf);
843 NULLFREE(data);
844 stream_client_disconnect(conndata);
845 return NULL;
846 }
847
848 http_buf[1023] = '\0';
849 if (sscanf(http_buf, "GET %254s ", stream_path) < 1)
850 {
851 NULLFREE(http_buf);
852 NULLFREE(stream_buf);
853 NULLFREE(data);
854 stream_client_disconnect(conndata);
855 return NULL;
856 }
857
858 cs_strncpy(stream_path_copy, stream_path, sizeof(stream_path));
859
860 token = strtok_r(stream_path_copy, ":", &saveptr); // token 0
861 for (i = 1; token != NULL && i < 7; i++) // tokens 1 to 6
862 {
863 token = strtok_r(NULL, ":", &saveptr);
864 if (token == NULL)
865 {
866 break;
867 }
868
869 if (i >= 3) // We olny need token 3 (srvid), 4 (tsid), 5 (onid) and 6 (ens)
870 {
871 if (sscanf(token, "%x", &tmp_pids[i - 3]) != 1)
872 {
873 tmp_pids[i - 3] = 0;
874 }
875 }
876 }
877
878 data->srvid = tmp_pids[0] & 0xFFFF;
879 data->tsid = tmp_pids[1] & 0xFFFF;
880 data->onid = tmp_pids[2] & 0xFFFF;
881 data->ens = tmp_pids[3];
882
883 if (data->srvid == 0) // We didn't get a srvid - Exit
884 {
885 NULLFREE(http_buf);
886 NULLFREE(stream_buf);
887 NULLFREE(data);
888 stream_client_disconnect(conndata);
889 return NULL;
890 }
891
892 key_data[conndata->connid].key[ODD] = dvbcsa_bs_key_alloc();
893 key_data[conndata->connid].key[EVEN] = dvbcsa_bs_key_alloc();
894
895 if (!cs_malloc(&tsbbatch, (cluster_size + 1) * sizeof(struct dvbcsa_bs_batch_s)))
896 {
897 NULLFREE(http_buf);
898 NULLFREE(stream_buf);
899 NULLFREE(data);
900 stream_client_disconnect(conndata);
901 return NULL;
902 }
903
904 SAFE_MUTEX_LOCK(&fixed_key_srvid_mutex);
905 stream_cur_srvid[conndata->connid] = data->srvid;
906 SAFE_MUTEX_UNLOCK(&fixed_key_srvid_mutex);
907
908 cs_log("Stream client %i request %s", conndata->connid, stream_path);
909
910 cs_log_dbg(D_READER, "Stream client %i received srvid: %04X tsid: %04X onid: %04X ens: %08X",
911 conndata->connid, data->srvid, data->tsid, data->onid, data->ens);
912
913 snprintf(http_buf, 1024, "HTTP/1.0 200 OK\nConnection: Close\nContent-Type: video/mpeg\nServer: stream_enigma2\n\n");
914 clientStatus = send(conndata->connfd, http_buf, cs_strlen(http_buf), 0);
915
916 data->connid = conndata->connid;
917 data->caid = NO_CAID_VALUE;
918 data->have_pat_data = 0;
919 data->have_pmt_data = 0;
920 data->have_cat_data = 0;
921 data->have_ecm_data = 0;
922 data->have_emm_data = 0;
923
924 while (!exit_oscam && clientStatus != -1 && streamConnectErrorCount < 3
925 && streamDataErrorCount < 15)
926 {
927 streamfd = connect_to_stream(http_buf, 1024, stream_path);
928 if (streamfd == -1)
929 {
930 cs_log("WARNING: stream client %i cannot connect to stream source", conndata->connid);
931 streamConnectErrorCount++;
932 cs_sleepms(500);
933 continue;
934 }
935 streamStatus = 0;
936 bytesRead = 0;
937 while (!exit_oscam && clientStatus != -1 && streamStatus != -1
938 #if 0
939 && streamConnectErrorCount < 3 && streamDataErrorCount < 15)
940 #else
941 && (streamConnectErrorCount < 3 || streamDataErrorCount < 15))
942 #endif
943 {
944 streamStatus = recv(streamfd, stream_buf + bytesRead, cur_dvb_buffer_size - bytesRead, MSG_WAITALL);
945 if (streamStatus == 0) // socket closed
946 {
947 cs_log("WARNING: stream client %i - stream source closed connection", conndata->connid);
948 streamConnectErrorCount++;
949 cs_sleepms(100);
950 break;
951 }
952 if (streamStatus < 0) // error
953 {
954 if ((errno == EWOULDBLOCK) | (errno == EAGAIN))
955 {
956 cs_log("WARNING: stream client %i no data from stream source", conndata->connid);
957 streamDataErrorCount++; // 2 sec timeout * 15 = 30 seconds no data -> close
958 cs_sleepms(100);
959 continue;
960 }
961 cs_log("WARNING: stream client %i error receiving data from stream source", conndata->connid);
962 streamConnectErrorCount++;
963 cs_sleepms(100);
964 break;
965 }
966 if (streamStatus < cur_dvb_buffer_size - bytesRead) // probably just received header but no stream
967 {
968 if (!bytesRead && streamStatus > 13 &&
969 sscanf((const char*)stream_buf, "HTTP/%3s %d ", http_version , &http_status_code) == 2 &&
970 http_status_code != 200)
971 {
972 cs_log("ERROR: stream client %i got %d response from stream source", conndata->connid, http_status_code);
973 streamConnectErrorCount++;
974 cs_sleepms(100);
975 break;
976 }
977 else
978 {
979 cs_log_dbg(0, "WARNING: stream client %i non-full buffer from stream source", conndata->connid);
980 streamDataErrorCount++;
981 cs_sleepms(100);
982 }
983 }
984 else
985 {
986 streamDataErrorCount = 0;
987 }
988
989 streamConnectErrorCount = 0;
990 bytesRead += streamStatus;
991
992 if (bytesRead >= cur_dvb_buffer_wait)
993 {
994 startOffset = 0;
995
996 // only search if not starting on ts packet or unknown packet size
997 if (stream_buf[0] != 0x47 || packetSize == 0)
998 {
999 SearchTsPackets(stream_buf, bytesRead, &packetSize, &startOffset);
1000 }
1001
1002 if (packetSize == 0)
1003 {
1004 bytesRead = 0;
1005 }
1006 else
1007 {
1008 packetCount = ((bytesRead - startOffset) / packetSize);
1009
1010 // We have both PAT and PMT data - We can start descrambling
1011 if (data->have_pat_data == 1 && data->have_pmt_data == 1)
1012 {
1013 if (chk_ctab_ex(data->caid, &cfg.stream_relay_ctab) && (data->caid != 0xA101 || data->caid == NO_CAID_VALUE))
1014 {
1015 DescrambleTsPackets(data, stream_buf + startOffset, packetCount * packetSize, packetSize, tsbbatch);
1016 }
1017 else
1018 {
1019 cs_log_dbg(D_READER, "Stream client %i caid %04X not enabled in stream relay config",
1020 conndata->connid, data->caid);
1021 }
1022 }
1023 else // Search PAT and PMT packets for service information
1024 {
1025 ParseTsPackets(data, stream_buf + startOffset, packetCount * packetSize, packetSize);
1026 }
1027
1028 clientStatus = send(conndata->connfd, stream_buf + startOffset, packetCount * packetSize, 0);
1029
1030 remainingDataPos = startOffset + (packetCount * packetSize);
1031 remainingDataLength = bytesRead - remainingDataPos;
1032
1033 if (remainingDataPos < remainingDataLength)
1034 {
1035 memmove(stream_buf, stream_buf + remainingDataPos, remainingDataLength);
1036 }
1037 else
1038 {
1039 memcpy(stream_buf, stream_buf + remainingDataPos, remainingDataLength);
1040 }
1041
1042 bytesRead = remainingDataLength;
1043 }
1044 }
1045 }
1046
1047 close(streamfd);
1048 }
1049
1050 NULLFREE(http_buf);
1051 NULLFREE(stream_buf);
1052
1053 dvbcsa_bs_key_free(key_data[conndata->connid].key[ODD]);
1054 dvbcsa_bs_key_free(key_data[conndata->connid].key[EVEN]);
1055 NULLFREE(tsbbatch);
1056
1057 NULLFREE(data);
1058
1059 stream_client_disconnect(conndata);
1060 return NULL;
1061 }
1062
1063 void *stream_server(void *UNUSED(a))
1064 {
1065 struct sockaddr_in servaddr, cliaddr;
1066 socklen_t clilen;
1067 int32_t connfd, reuse = 1, i;
1068 int8_t connaccepted;
1069 stream_client_conn_data *conndata;
1070
1071 cluster_size = dvbcsa_bs_batch_size();
1072 cs_log("INFO: "
1073 #if DVBCSA_KEY_ECM > 0
1074 "(ecm) "
1075 #endif
1076 "dvbcsa parallel mode = %d", cluster_size);
1077
1078 if (!stream_server_mutex_init)
1079 {
1080 SAFE_MUTEX_INIT(&stream_server_mutex, NULL);
1081 stream_server_mutex_init = 1;
1082 }
1083
1084 SAFE_MUTEX_LOCK(&fixed_key_srvid_mutex);
1085 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
1086 {
1087 stream_cur_srvid[i] = NO_SRVID_VALUE;
1088 }
1089 SAFE_MUTEX_UNLOCK(&fixed_key_srvid_mutex);
1090
1091 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
1092 {
1093 gconnfd[i] = -1;
1094 }
1095
1096 glistenfd = socket(AF_INET, SOCK_STREAM, 0);
1097 if (glistenfd == -1)
1098 {
1099 cs_log("ERROR: cannot create stream server socket");
1100 return NULL;
1101 }
1102
1103 bzero(&servaddr,sizeof(servaddr));
1104 servaddr.sin_family = AF_INET;
1105 servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
1106 servaddr.sin_port = htons(cfg.stream_relay_port);
1107 setsockopt(glistenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
1108
1109 if (bind(glistenfd,(struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
1110 {
1111 cs_log("ERROR: cannot bind to stream server socket");
1112 close(glistenfd);
1113 return NULL;
1114 }
1115
1116 if (listen(glistenfd, 3) == -1)
1117 {
1118 cs_log("ERROR: cannot listen to stream server socket");
1119 close(glistenfd);
1120 return NULL;
1121 }
1122
1123 while (!exit_oscam)
1124 {
1125 clilen = sizeof(cliaddr);
1126 connfd = accept(glistenfd,(struct sockaddr *)&cliaddr, &clilen);
1127
1128 if (connfd == -1)
1129 {
1130 cs_log("ERROR: accept() failed");
1131 break;
1132 }
1133
1134 connaccepted = 0;
1135
1136 #ifdef MODULE_RADEGAST
1137 if(cfg.stream_client_source_host)
1138 {
1139 // Read ip of client who wants to play the stream
1140 unsigned char *ip = (unsigned char *)&cliaddr.sin_addr.s_addr;
1141 cs_log("Stream Client ip is: %d.%d.%d.%d, will fetch stream there\n", ip[0], ip[1], ip[2], ip[3]);
1142
1143 // Store ip of client in stream_source_host variable
1144 snprintf(stream_source_host, sizeof(stream_source_host), "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
1145 }
1146 #endif
1147
1148 if (cs_malloc(&conndata, sizeof(stream_client_conn_data)))
1149 {
1150 SAFE_MUTEX_LOCK(&stream_server_mutex);
1151 if (gconncount < STREAM_SERVER_MAX_CONNECTIONS)
1152 {
1153 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
1154 {
1155 if (gconnfd[i] == -1)
1156 {
1157 gconnfd[i] = connfd;
1158 gconncount++;
1159 connaccepted = 1;
1160
1161 conndata->connfd = connfd;
1162 conndata->connid = i;
1163
1164 break;
1165 }
1166 }
1167 }
1168 SAFE_MUTEX_UNLOCK(&stream_server_mutex);
1169 }
1170
1171 if (connaccepted)
1172 {
1173 int on = 1;
1174 if (setsockopt(connfd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) < 0)
1175 {
1176 cs_log("ERROR: stream client %i setsockopt() failed for TCP_NODELAY", conndata->connid);
1177 }
1178
1179 start_thread("stream client", stream_client_handler, (void*)conndata, NULL, 1, 0);
1180 }
1181 else
1182 {
1183 shutdown(connfd, 2);
1184 close(connfd);
1185 cs_log("ERROR: stream server client dropped because of too many connections (%i)", STREAM_SERVER_MAX_CONNECTIONS);
1186 }
1187
1188 cs_sleepms(20);
1189 }
1190
1191 close(glistenfd);
1192
1193 return NULL;
1194 }
1195
1196 void init_stream_server(void)
1197 {
1198 char authtmp[128];
1199
1200 if (cfg.stream_relay_enabled)
1201 {
1202
1203 cs_strncpy(stream_source_host, cfg.stream_source_host, sizeof(stream_source_host));
1204
1205 if (cfg.stream_source_auth_user && cfg.stream_source_auth_password)
1206 {
1207 snprintf(authtmp, sizeof(authtmp), "%s:%s", cfg.stream_source_auth_user, cfg.stream_source_auth_password);
1208 b64encode(authtmp, cs_strlen(authtmp), &stream_source_auth);
1209 }
1210
1211 start_thread("stream_server", stream_server, NULL, NULL, 1, 1);
1212 cs_log("Stream Relay server initialized");
1213 }
1214 }
1215
1216 void stop_stream_server(void)
1217 {
1218 int32_t i;
1219
1220 SAFE_MUTEX_LOCK(&stream_server_mutex);
1221 for (i = 0; i < STREAM_SERVER_MAX_CONNECTIONS; i++)
1222 {
1223 if (gconnfd[i] != -1)
1224 {
1225 shutdown(gconnfd[i], 2);
1226 close(gconnfd[i]);
1227 gconnfd[i] = -1;
1228 }
1229 }
1230
1231 gconncount = 0;
1232 SAFE_MUTEX_UNLOCK(&stream_server_mutex);
1233
1234 #ifdef MODULE_RADEGAST
1235 close_radegast_connection();
1236 #endif
1237
1238 shutdown(glistenfd, 2);
1239 close(glistenfd);
1240 }
1241
1242 #endif // MODULE_STREAMRELAY
Open Source Conditional Access Modul