Annotation of multiplexer/en300468ts.c, revision 1.20
1.1 oskar 1: /*
2: * SI table generator (EN 300468)
1.3 oskar 3: * Copyright (C) 2004,2005 Oskar Schirmer (schirmer@scara.com)
1.1 oskar 4: *
5: * This program is free software; you can redistribute it and/or modify
6: * it under the terms of the GNU General Public License as published by
7: * the Free Software Foundation; either version 2 of the License, or
8: * (at your option) any later version.
9: *
10: * This program is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: * GNU General Public License for more details.
14: *
15: * You should have received a copy of the GNU General Public License
16: * along with this program; if not, write to the Free Software
17: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18: */
19:
20: /*
21: * Module: SI table generator
1.5 oskar 22: * Purpose: From a list of descriptive files generate SI tables and feed
1.1 oskar 23: * them to stdout.
24: * known bug: missing check for section length <= 1021
25: */
26:
27: //#define DEBUG
28:
29: #include <limits.h>
30: #include <unistd.h>
31: #include <stdio.h>
32: #include <stdlib.h>
1.6 oskar 33: #include <stdint.h>
1.1 oskar 34: #include <sys/stat.h>
35: #include <fcntl.h>
36: #include <signal.h>
37: #include <sys/poll.h>
38: #include <errno.h>
39: #include <string.h>
40: #include <ctype.h>
41: #include <sys/time.h>
42:
43: #include "crc32.h"
44:
45: #ifdef PATH_MAX
46: #define MY_PATH_MAX PATH_MAX
47: #else
48: #define MY_PATH_MAX 4096
49: #endif
50:
51: static struct pollfd *pfd = NULL;
52: static int npfd = 0;
53: static int ipfd;
54:
55: #define TABLE_PID_FIRST 0x10
56: #define TABLE_PID_LAST 0x1F
57: #define TABBUF_SIZE (1<<15)
58: #define MAX_PSI_SIZE (4096+1)
59:
60: static unsigned int tabin[TABLE_PID_LAST-TABLE_PID_FIRST+1];
61: static unsigned int tabinold[TABLE_PID_LAST-TABLE_PID_FIRST+1];
62: static unsigned int tabout[TABLE_PID_LAST-TABLE_PID_FIRST+1];
63: static unsigned char conticnt[TABLE_PID_LAST-TABLE_PID_FIRST+1];
64: static unsigned char *tabbuf[TABLE_PID_LAST-TABLE_PID_FIRST+1];
65:
66: #define TABLEID_FIRST 0x40
67: #define TABLEID_LAST 0x7F
68:
69: static unsigned char nextversion[TABLEID_LAST-TABLEID_FIRST+1];
70:
71: #define TS_PACKET_SIZE 188
72: #define TS_HEADSLEN 3
73: #define TS_PACKET_HEADSIZE 4
1.4 oskar 74: #define TS_PFIELDLEN 1
1.1 oskar 75: #define TS_SYNC_BYTE 0x47
76: #define OUTBUF_PACKETS 256
77: #define OUTBUF_SIZE (TS_PACKET_SIZE*OUTBUF_PACKETS)
78:
79: static unsigned int outin = 0;
80: static unsigned int outout = 0;
81: static unsigned char outbuf[OUTBUF_SIZE];
82:
83: static void pollfd_init()
84: {
85: ipfd = 0;
86: }
87:
88: static int pollfd_add(int f, short e)
89: {
90: if (npfd <= ipfd) {
91: npfd = 2*npfd+1;
92: pfd = realloc(pfd, npfd * sizeof(struct pollfd));
93: }
94: pfd[ipfd].fd = f;
95: pfd[ipfd].events = e;
96: return ipfd++;
97: }
98:
99: static int pollfd_poll(int timeout)
100: {
101: return poll(pfd, ipfd, timeout);
102: }
103:
104: static int pollfd_rev(int i)
105: {
106: return pfd[i].revents;
107: }
108:
109: static void signalhandler(int sig)
110: {
111: exit(0);
112: }
113:
114: static void system_init()
115: {
116: signal(SIGINT, (void *) (*signalhandler));
117: signal(SIGPIPE, SIG_IGN);
118: }
119:
120: static void unblockf(int f)
121: {
122: int r;
123: r = fcntl(f, F_GETFL);
124: if (r >= 0) {
125: r = fcntl(f, F_SETFL, r | O_NONBLOCK);
126: }
127: if (r < 0) {
128: fprintf(stderr, "fcntl failed(%d): %d\n", errno, f);
129: }
130: }
131:
132: enum enumsi {
1.5 oskar 133: #define ENDEF_BEGIN(name,pid,tableid) name ,
134: #define ENDEF_END
135: #define ENDEF_NUMBER0(name)
136: #define ENDEF_NUMBER1(name)
137: #define ENDEF_DESCR
138: #define ENDEF_DATETIME
139: #define ENDEF_LOOP
140: #define ENDEF_LOOPEND0
141: #include "en300468ts.table"
142: #undef ENDEF_BEGIN
143: #undef ENDEF_END
144: #undef ENDEF_NUMBER0
145: #undef ENDEF_NUMBER1
146: #undef ENDEF_DESCR
147: #undef ENDEF_DATETIME
148: #undef ENDEF_LOOP
149: #undef ENDEF_LOOPEND0
1.1 oskar 150: num_si,
151: si_none = -1
152: };
153:
154: #define DESCR_FIRST 0x40
155: #define DESCR_LAST 0x6E
156: #define PMT_POSS 0
157:
158: static unsigned char descrcnt[DESCR_LAST-DESCR_FIRST+1];
159:
160: const static unsigned char possible_descr[DESCR_LAST-DESCR_FIRST+1] = {
161: (1<<nit),
162: (1<<nit) | (1<<bat),
163: 0 /* (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit) */,
164: (1<<nit),
165: (1<<nit),
166: PMT_POSS,
167: PMT_POSS,
168: (1<<bat) | (1<<sdt) | (1<<sit),
169: (1<<sdt) | (1<<sit),
170: (1<<bat) | (1<<sdt) | (1<<sit),
171: (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit),
172: (1<<sdt) | (1<<sit),
173: (1<<sdt) | (1<<sit),
174: (1<<eit) | (1<<sit),
175: (1<<eit) | (1<<sit),
176: (1<<eit) | (1<<sit),
177: (1<<eit) | (1<<sit),
178: (1<<sdt) | PMT_POSS | (1<<sit),
179: PMT_POSS,
180: (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit),
181: (1<<eit) | (1<<sit),
182: (1<<eit) | (1<<sit),
183: PMT_POSS,
184: (1<<sdt) | (1<<eit) | (1<<sit),
185: (1<<tot),
186: PMT_POSS,
187: (1<<nit),
188: (1<<nit),
189: (1<<bat),
190: (1<<sdt) | (1<<sit),
191: (1<<eit) | (1<<sit),
192: (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | PMT_POSS | (1<<sit),
193: PMT_POSS,
194: (1<<eit) | (1<<sit),
195: (1<<nit),
196: (1<<sit),
197: (1<<sdt) | (1<<eit) | (1<<sit),
198: PMT_POSS,
199: PMT_POSS,
200: 0,
201: 0,
202: (1<<eit),
203: PMT_POSS,
204: PMT_POSS,
205: (1<<nit),
206: (1<<nit),
207: (1<<nit)
208: };
209:
210: #define LOOP_DEPTH 4
211: #define REALLOC_CHUNK 32
212:
1.17 oskar 213: static struct {
214: int tablen;
215: int itab;
216: int fd;
217: int isdescr; /* 0: main table, >0: descr loop depth */
218: int descrtag;
219: int isyn;
220: int isyntab;
221: int numcount;
222: int loopbegin[LOOP_DEPTH];
223: int loopcount[LOOP_DEPTH];
224: int ibuf;
225: char buf[2048];
226: } tabnew;
227:
1.1 oskar 228: struct sitab {
229: struct sitab *next;
230: unsigned char version;
231: unsigned char tableid;
232: long pid;
233: long freqmsec;
234: enum enumsi esi;
235: unsigned long *tab;
1.16 oskar 236: struct timeval soon;
1.1 oskar 237: unsigned char descrnum[DESCR_LAST-DESCR_FIRST+1];
238: };
239:
240: static struct sitab *newtab = NULL;
241: static struct sitab *runtab = NULL;
242:
243: #define SYNTAX_END 0
244: #define SYNTAX_LOOPEND 1
245: #define SYNTAX_LOOP 2
246: #define SYNTAX_DESCR 3
247: #define SYNTAX_DESCRTAG 4
248: #define SYNTAX_DATETIME 5
249: #define SYNTAX_STRING 6
1.5 oskar 250: #define SYNTAX_NUMBER -1
1.1 oskar 251:
1.5 oskar 252: #define ENDEF_BEGIN(name,tag) \
253: const static signed char syntax_##name [] = {SYNTAX_DESCRTAG,
254: #define ENDEF_END SYNTAX_END};
255: #define ENDEF_NUMBER0(name) SYNTAX_NUMBER
256: #define ENDEF_NUMBER1(name) SYNTAX_NUMBER,
257: #define ENDEF_DATETIME SYNTAX_DATETIME,
258: #define ENDEF_LOOP SYNTAX_LOOP,
259: #define ENDEF_LOOPEND0
260: #define ENDEF_LOOPEND1 SYNTAX_LOOPEND,
261: #define ENDEF_STRING(name) SYNTAX_STRING,
262: #define ENDEF_STRING3(name) SYNTAX_STRING,
263: #include "en300468ts.descr"
264: #undef ENDEF_BEGIN
265: #undef ENDEF_END
266: #undef ENDEF_NUMBER0
267: #undef ENDEF_NUMBER1
268: #undef ENDEF_DATETIME
269: #undef ENDEF_LOOP
270: #undef ENDEF_LOOPEND0
271: #undef ENDEF_LOOPEND1
272: #undef ENDEF_STRING
273: #undef ENDEF_STRING3
1.1 oskar 274:
275: static unsigned char *gen_network_name(struct sitab *st, unsigned char *p,
276: unsigned long **tt)
277: {
278: unsigned char *d = p;
279: unsigned long *t = *tt;
280: int i;
281: i = *t++;
282: memcpy(d, t, i);
283: d += i;
284: t += (i + sizeof(long) - 1) / sizeof(long);
285: *tt = t;
286: return d;
287: }
288:
289: static unsigned char *gen_service_list(struct sitab *st, unsigned char *p,
290: unsigned long **tt)
291: {
292: unsigned char *d = p;
293: unsigned long *t = *tt;
294: int i;
295: i = *t++;
296: while (i > 0) {
297: *d++ = *t >> 8;
298: *d++ = *t++;
299: *d++ = *t++;
300: i -= 1;
301: }
302: *tt = t;
303: return d;
304: }
305:
306: static unsigned char *gen_satellite_delivery_system(struct sitab *st,
307: unsigned char *p, unsigned long **tt)
308: {
309: unsigned char *d = p;
310: unsigned long *t = *tt;
311: unsigned char c;
312: *d++ = *t >> 24;
313: *d++ = *t >> 16;
314: *d++ = *t >> 8;
315: *d++ = *t++;
316: *d++ = *t >> 8;
317: *d++ = *t++;
318: c = *t++ << 7;
319: c |= (*t++ & 0x03) << 5;
320: *d++ = c | (*t++ & 0x1F);
321: *d++ = *t >> 20;
322: *d++ = *t >> 12;
323: *d++ = *t >> 4;
324: c = *t++ << 4;
325: *d++ = c | (*t++ & 0x0F);
326: *tt = t;
327: return d;
328: }
329:
330: static unsigned char *gen_cable_delivery_system(struct sitab *st,
331: unsigned char *p, unsigned long **tt)
332: {
333: unsigned char *d = p;
334: unsigned long *t = *tt;
335: unsigned char c;
336: *d++ = *t >> 24;
337: *d++ = *t >> 16;
338: *d++ = *t >> 8;
339: *d++ = *t++;
340: *d++ = 0xFF;
341: *d++ = 0xF0 | *t++;
342: *d++ = *t++;
343: *d++ = *t >> 20;
344: *d++ = *t >> 12;
345: *d++ = *t >> 4;
346: c = *t++ << 4;
347: *d++ = c | (*t++ & 0x0F);
348: *tt = t;
349: return d;
350: }
351:
352: static unsigned char *gen_bouquet_name(struct sitab *st, unsigned char *p,
353: unsigned long **tt)
354: {
355: unsigned char *d = p;
356: unsigned long *t = *tt;
357: int i;
358: i = *t++;
359: memcpy(d, t, i);
360: d += i;
361: t += (i + sizeof(long) - 1) / sizeof(long);
362: *tt = t;
363: return d;
364: }
365:
366: static unsigned char *gen_service(struct sitab *st, unsigned char *p,
367: unsigned long **tt)
368: {
369: unsigned char *d = p;
370: unsigned long *t = *tt;
371: int i;
372: *d++ = *t++;
373: *d++ = i = *t++;
374: memcpy(d, t, i);
375: d += i;
376: t += (i + sizeof(long) - 1) / sizeof(long);
377: *d++ = i = *t++;
378: memcpy(d, t, i);
379: d += i;
380: t += (i + sizeof(long) - 1) / sizeof(long);
381: *tt = t;
382: return d;
383: }
384:
385: static unsigned char *gen_country_availability(struct sitab *st,
386: unsigned char *p, unsigned long **tt)
387: {
388: unsigned char *d = p;
389: unsigned long *t = *tt;
390: int i, j;
391: *d++ = (*t++ << 7) | 0x7F;
392: i = *t++;
393: while (i > 0) {
394: j = *t++;
395: memcpy(d, t, 3);
396: d += 3;
397: t += (j + sizeof(long) - 1) / sizeof(long);
398: i -= 1;
399: }
400: *tt = t;
401: return d;
402: }
403:
404: static unsigned char *gen_linkage(struct sitab *st, unsigned char *p,
405: unsigned long **tt)
406: {
407: unsigned char *d = p;
408: unsigned long *t = *tt;
409: int i;
410: unsigned char l, h, o;
411: unsigned long n, s;
412: *d++ = *t >> 8;
413: *d++ = *t++;
414: *d++ = *t >> 8;
415: *d++ = *t++;
416: *d++ = *t >> 8;
417: *d++ = *t++;
418: *d++ = l = *t++;
419: h = *t++ & 0x0F;
420: o = *t++ & 0x01;
421: n = *t++;
422: s = *t++;
423: if (l == 8) {
424: *d++ = (h << 4) | 0x0E | o;
425: if ((h >= 1) && (h <= 3)) {
426: *d++ = n >> 8;
427: *d++ = n;
428: }
429: if (o == 0) {
430: *d++ = s >> 8;
431: *d++ = s;
432: }
433: }
434: i = *t++;
435: while (i > 0) {
436: *d++ = *t++;
437: i -= 1;
438: }
439: *tt = t;
440: return d;
441: }
442:
443: static unsigned char *gen_nvod_reference(struct sitab *st, unsigned char *p,
444: unsigned long **tt)
445: {
446: unsigned char *d = p;
447: unsigned long *t = *tt;
448: int i;
449: i = *t++;
450: while (i > 0) {
451: *d++ = *t >> 8;
452: *d++ = *t++;
453: *d++ = *t >> 8;
454: *d++ = *t++;
455: *d++ = *t >> 8;
456: *d++ = *t++;
457: i -= 1;
458: }
459: *tt = t;
460: return d;
461: }
462:
463: static unsigned char *gen_time_shifted_service(struct sitab *st,
464: unsigned char *p, unsigned long **tt)
465: {
466: unsigned char *d = p;
467: unsigned long *t = *tt;
468: *d++ = *t >> 8;
469: *d++ = *t++;
470: *tt = t;
471: return d;
472: }
473:
474: static unsigned char *gen_short_event(struct sitab *st, unsigned char *p,
475: unsigned long **tt)
476: {
477: unsigned char *d = p;
478: unsigned long *t = *tt;
479: int i;
480: i = *t++;
481: memcpy(d, t, 3);
482: d += 3;
483: t += (i + sizeof(long) - 1) / sizeof(long);
484: *d++ = i = *t++;
485: memcpy(d, t, i);
486: d += i;
487: t += (i + sizeof(long) - 1) / sizeof(long);
488: *d++ = i = *t++;
489: memcpy(d, t, i);
490: d += i;
491: t += (i + sizeof(long) - 1) / sizeof(long);
492: *tt = t;
493: return d;
494: }
495:
496: static unsigned char *gen_extended_event(struct sitab *st, unsigned char *p,
497: unsigned long **tt)
498: {
499: unsigned char *d = p;
500: unsigned long *t = *tt;
501: int i, j;
502: *d++ = (descrcnt[0x4E - DESCR_FIRST] << 4)
503: | (st->descrnum[0x4E - DESCR_FIRST] & 0x0F);
504: i = *t++;
505: memcpy(d, t, 3);
506: d += 4;
507: t += (i + sizeof(long) - 1) / sizeof(long);
508: i = *t++;
509: while (i > 0) {
510: *d++ = j = *t++;
511: memcpy(d, t, j);
512: d += j;
513: t += (j + sizeof(long) - 1) / sizeof(long);
514: *d++ = j = *t++;
515: memcpy(d, t, j);
516: d += j;
517: t += (j + sizeof(long) - 1) / sizeof(long);
518: i -= 1;
519: }
520: p[4] = d-p-5;
521: *d++ = i = *t++;
522: memcpy(d, t, i);
523: d += i;
524: t += (i + sizeof(long) - 1) / sizeof(long);
525: *tt = t;
526: return d;
527: }
528:
529: static unsigned char *gen_time_shifted_event(struct sitab *st, unsigned char *p,
530: unsigned long **tt)
531: {
532: unsigned char *d = p;
533: unsigned long *t = *tt;
534: *d++ = *t >> 8;
535: *d++ = *t++;
536: *d++ = *t >> 8;
537: *d++ = *t++;
538: *tt = t;
539: return d;
540: }
541:
542: static unsigned char *gen_component(struct sitab *st, unsigned char *p,
543: unsigned long **tt)
544: {
545: unsigned char *d = p;
546: unsigned long *t = *tt;
547: int i;
548: *d++ = 0xF0 | *t++;
549: *d++ = *t++;
550: *d++ = *t++;
551: i = *t++;
552: memcpy(d, t, 3);
553: d += 3;
554: t += (i + sizeof(long) - 1) / sizeof(long);
555: i = *t++;
556: memcpy(d, t, i);
557: d += i;
558: t += (i + sizeof(long) - 1) / sizeof(long);
559: *tt = t;
560: return d;
561: }
562:
563: static unsigned char *gen_mosaic(struct sitab *st, unsigned char *p,
564: unsigned long **tt)
565: {
566: unsigned char *d = p;
567: unsigned long *t = *tt;
568: unsigned char *e;
569: unsigned char c;
570: int i, j;
571: c = *t++ << 7;
572: c = c | ((*t++ & 0x07) << 4);
573: *d++ = c | 0x08 | (*t++ & 0x07);
574: i = *t++;
575: while (i > 0) {
576: *d++ = (*t++ << 2) | 0x03;
577: *d++ = 0xF8 | *t++;
578: e = d++;
579: j = *t++;
580: while (j > 0) {
581: *d++ = 0xC0 | *t++;
582: j -= 1;
583: }
584: *e = d-e-1;
585: switch (*d++ = *t++) {
586: case 0x01:
587: *d++ = t[0] >> 8;
588: *d++ = t[0];
589: break;
590: case 0x02:
591: case 0x03:
592: *d++ = t[1] >> 8;
593: *d++ = t[1];
594: *d++ = t[2] >> 8;
595: *d++ = t[2];
596: *d++ = t[3] >> 8;
597: *d++ = t[3];
598: break;
599: case 0x04:
600: *d++ = t[1] >> 8;
601: *d++ = t[1];
602: *d++ = t[2] >> 8;
603: *d++ = t[2];
604: *d++ = t[3] >> 8;
605: *d++ = t[3];
606: *d++ = t[4] >> 8;
607: *d++ = t[4];
608: break;
609: }
610: t += 5;
611: i -= 1;
612: }
613: *tt = t;
614: return d;
615: }
616:
617: static unsigned char *gen_ca_identifier(struct sitab *st, unsigned char *p,
618: unsigned long **tt)
619: {
620: unsigned char *d = p;
621: unsigned long *t = *tt;
622: int i;
623: i = *t++;
624: while (i > 0) {
625: *d++ = *t >> 8;
626: *d++ = *t++;
627: i -= 1;
628: }
629: *tt = t;
630: return d;
631: }
632:
633: static unsigned char *gen_content(struct sitab *st, unsigned char *p,
634: unsigned long **tt)
635: {
636: unsigned char *d = p;
637: unsigned long *t = *tt;
638: int i;
639: i = *t++;
640: while (i > 0) {
641: *d++ = *t++;
642: *d++ = *t++;
643: i -= 1;
644: }
645: *tt = t;
646: return d;
647: }
648:
649: static unsigned char *gen_parental_rating(struct sitab *st, unsigned char *p,
650: unsigned long **tt)
651: {
652: unsigned char *d = p;
653: unsigned long *t = *tt;
654: int i, j;
655: i = *t++;
656: while (i > 0) {
657: j = *t++;
658: memcpy(d, t, 3);
659: d += 3;
660: t += (j + sizeof(long) - 1) / sizeof(long);
661: *d++ = *t++;
662: i -= 1;
663: }
664: *tt = t;
665: return d;
666: }
667:
668: static unsigned char *gen_telephone(struct sitab *st, unsigned char *p,
669: unsigned long **tt)
670: {
671: unsigned char *d = p;
672: unsigned long *t = *tt;
673: unsigned char c;
674: int i;
675: c = *t++ << 5;
676: *d = 0xC0 | c | (*t++ & 0x1F);
677: d += 3;
678: i = *t++;
679: c = i << 5;
680: memcpy(d, t, i);
681: d += i;
682: t += (i + sizeof(long) - 1) / sizeof(long);
683: i = *t++;
684: c |= (i & 0x07) << 2;
685: memcpy(d, t, i);
686: d += i;
687: t += (i + sizeof(long) - 1) / sizeof(long);
688: i = *t++;
689: p[1] = 0x80 | c | (i & 0x03);
690: memcpy(d, t, i);
691: d += i;
692: t += (i + sizeof(long) - 1) / sizeof(long);
693: i = *t++;
694: c = i << 4;
695: memcpy(d, t, i);
696: d += i;
697: t += (i + sizeof(long) - 1) / sizeof(long);
698: i = *t++;
699: p[2] = 0x80 | c | (i & 0x0F);
700: memcpy(d, t, i);
701: d += i;
702: t += (i + sizeof(long) - 1) / sizeof(long);
703: *tt = t;
704: return d;
705: }
706:
707: static unsigned char *gen_local_time_offset(struct sitab *st, unsigned char *p,
708: unsigned long **tt)
709: {
710: unsigned char *d = p;
711: unsigned long *t = *tt;
712: unsigned char c;
713: int i, j;
714: i = *t++;
715: while (i > 0) {
716: j = *t++;
717: memcpy(d, t, 3);
718: d += 3;
719: t += (j + sizeof(long) - 1) / sizeof(long);
720: c = *t++ << 2;
721: *d++ = c | 0x02 | (*t++ & 0x01);
722: *d++ = *t >> 8;
723: *d++ = *t++;
724: *d++ = *t >> 8;
725: *d++ = *t++;
726: *d++ = *t >> 16;
727: *d++ = *t >> 8;
728: *d++ = *t++;
729: *d++ = *t >> 8;
730: *d++ = *t++;
731: i -= 1;
732: }
733: *tt = t;
734: return d;
735: }
736:
737: static unsigned char *gen_terrestrial_delivery_system(struct sitab *st,
738: unsigned char *p, unsigned long **tt)
739: {
740: unsigned char *d = p;
741: unsigned long *t = *tt;
742: unsigned char c;
743: *d++ = *t >> 24;
744: *d++ = *t >> 16;
745: *d++ = *t >> 8;
746: *d++ = *t++;
747: *d++ = (*t++ << 5) | 0x1F;
748: c = *t++ << 6;
749: c |= (*t++ & 0x07) << 3;
750: *d++ = c | (*t++ & 0x07);
751: c = *t++ << 5;
752: c |= (*t++ & 0x03) << 3;
753: c |= (*t++ & 0x03) << 1;
754: *d++ = c | (*t++ & 0x01);
755: *d++ = 0xFF;
756: *d++ = 0xFF;
757: *d++ = 0xFF;
758: *d++ = 0xFF;
759: *tt = t;
760: return d;
761: }
762:
763: static unsigned char *gen_multilingual_network_name(struct sitab *st,
764: unsigned char *p, unsigned long **tt)
765: {
766: unsigned char *d = p;
767: unsigned long *t = *tt;
768: int i, j;
769: i = *t++;
770: while (i > 0) {
771: j = *t++;
772: memcpy(d, t, 3);
773: d += 3;
774: t += (j + sizeof(long) - 1) / sizeof(long);
775: *d++ = j = *t++;
776: memcpy(d, t, j);
777: d += j;
778: t += (j + sizeof(long) - 1) / sizeof(long);
779: i -= 1;
780: }
781: *tt = t;
782: return d;
783: }
784:
785: static unsigned char *gen_multilingual_bouquet_name(struct sitab *st,
786: unsigned char *p, unsigned long **tt)
787: {
788: unsigned char *d = p;
789: unsigned long *t = *tt;
790: int i, j;
791: i = *t++;
792: while (i > 0) {
793: j = *t++;
794: memcpy(d, t, 3);
795: d += 3;
796: t += (j + sizeof(long) - 1) / sizeof(long);
797: *d++ = j = *t++;
798: memcpy(d, t, j);
799: d += j;
800: t += (j + sizeof(long) - 1) / sizeof(long);
801: i -= 1;
802: }
803: *tt = t;
804: return d;
805: }
806:
807: static unsigned char *gen_multilingual_service_name(struct sitab *st,
808: unsigned char *p, unsigned long **tt)
809: {
810: unsigned char *d = p;
811: unsigned long *t = *tt;
812: int i, j;
813: i = *t++;
814: while (i > 0) {
815: j = *t++;
816: memcpy(d, t, 3);
817: d += 3;
818: t += (j + sizeof(long) - 1) / sizeof(long);
819: *d++ = j = *t++;
820: memcpy(d, t, j);
821: d += j;
822: t += (j + sizeof(long) - 1) / sizeof(long);
823: *d++ = j = *t++;
824: memcpy(d, t, j);
825: d += j;
826: t += (j + sizeof(long) - 1) / sizeof(long);
827: i -= 1;
828: }
829: *tt = t;
830: return d;
831: }
832:
833: static unsigned char *gen_multilingual_component(struct sitab *st,
834: unsigned char *p, unsigned long **tt)
835: {
836: unsigned char *d = p;
837: unsigned long *t = *tt;
838: int i, j;
839: *d++ = *t++;
840: i = *t++;
841: while (i > 0) {
842: j = *t++;
843: memcpy(d, t, 3);
844: d += 3;
845: t += (j + sizeof(long) - 1) / sizeof(long);
846: *d++ = j = *t++;
847: memcpy(d, t, j);
848: d += j;
849: t += (j + sizeof(long) - 1) / sizeof(long);
850: i -= 1;
851: }
852: *tt = t;
853: return d;
854: }
855:
856: static unsigned char *gen_private_data_specifier(struct sitab *st,
857: unsigned char *p, unsigned long **tt)
858: {
859: unsigned char *d = p;
860: unsigned long *t = *tt;
861: *d++ = *t >> 24;
862: *d++ = *t >> 16;
863: *d++ = *t >> 8;
864: *d++ = *t++;
865: *tt = t;
866: return d;
867: }
868:
869: static unsigned char *gen_short_smoothing_buffer(struct sitab *st,
870: unsigned char *p, unsigned long **tt)
871: {
872: unsigned char *d = p;
873: unsigned long *t = *tt;
874: unsigned char c;
875: c = *t++ << 6;
876: *d++ = c | (*t++ & 0x3F);
877: *tt = t;
878: return d;
879: }
880:
881: static unsigned char *gen_frequency_list(struct sitab *st, unsigned char *p,
882: unsigned long **tt)
883: {
884: unsigned char *d = p;
885: unsigned long *t = *tt;
886: int i;
887: *d++ = 0xFC | *t++;
888: i = *t++;
889: while (i > 0) {
890: *d++ = *t >> 24;
891: *d++ = *t >> 16;
892: *d++ = *t >> 8;
893: *d++ = *t++;
894: i -= 1;
895: }
896: *tt = t;
897: return d;
898: }
899:
900: static unsigned char *gen_partial_transport_stream(struct sitab *st,
901: unsigned char *p, unsigned long **tt)
902: {
903: unsigned char *d = p;
904: unsigned long *t = *tt;
905: *d++ = 0xC0 | (*t >> 16);
906: *d++ = *t >> 8;
907: *d++ = *t++;
908: *d++ = 0xC0 | (*t >> 16);
909: *d++ = *t >> 8;
910: *d++ = *t++;
911: *d++ = 0xC0 | (*t >> 8);
912: *d++ = *t++;
913: *tt = t;
914: return d;
915: }
916:
917: static unsigned char *gen_data_broadcast(struct sitab *st, unsigned char *p,
918: unsigned long **tt)
919: {
920: unsigned char *d = p;
921: unsigned long *t = *tt;
922: int i;
923: *d++ = *t >> 8;
924: *d++ = *t++;
925: *d++ = *t++;
926: *d++ = i = *t++;
927: while (i > 0) {
928: *d++ = *t++;
929: i -= 1;
930: }
931: i = *t++;
932: memcpy(d, t, 3);
933: d += 3;
934: t += (i + sizeof(long) - 1) / sizeof(long);
935: *d++ = i = *t++;
936: memcpy(d, t, i);
937: d += i;
938: t += (i + sizeof(long) - 1) / sizeof(long);
939: *tt = t;
940: return d;
941: }
942:
943: static unsigned char *gen_pdc(struct sitab *st, unsigned char *p,
944: unsigned long **tt)
945: {
946: unsigned char *d = p;
947: unsigned long *t = *tt;
948: *d++ = 0xF0 | (*t >> 16);
949: *d++ = *t >> 8;
950: *d++ = *t++;
951: *tt = t;
952: return d;
953: }
954:
955: static unsigned char *gen_cell_list(struct sitab *st, unsigned char *p,
956: unsigned long **tt)
957: {
958: unsigned char *d = p;
959: unsigned long *t = *tt;
960: unsigned char c;
961: int i, j;
962: i = *t++;
963: while (i > 0) {
964: *d++ = *t >> 8;
965: *d++ = *t++;
966: *d++ = *t >> 8;
967: *d++ = *t++;
968: *d++ = *t >> 8;
969: *d++ = *t++;
970: *d++ = *t >> 4;
971: c = *t++ << 4;
972: *d++ = c | ((*t >> 8) & 0x0F);
973: *d++ = *t++;
974: j = *t++;
975: *d++ = 8 * j;
976: while (j > 0) {
977: *d++ = *t++;
978: *d++ = *t >> 8;
979: *d++ = *t++;
980: *d++ = *t >> 8;
981: *d++ = *t++;
982: *d++ = *t >> 4;
983: c = *t++ << 4;
984: *d++ = c | ((*t >> 8) & 0x0F);
985: *d++ = *t++;
986: j -= 1;
987: }
988: i -= 1;
989: }
990: *tt = t;
991: return d;
992: }
993:
994: static unsigned char *gen_cell_frequency_link(struct sitab *st,
995: unsigned char *p, unsigned long **tt)
996: {
997: unsigned char *d = p;
998: unsigned long *t = *tt;
999: int i, j;
1000: i = *t++;
1001: while (i > 0) {
1002: *d++ = *t >> 8;
1003: *d++ = *t++;
1004: *d++ = *t >> 24;
1005: *d++ = *t >> 16;
1006: *d++ = *t >> 8;
1007: *d++ = *t++;
1008: j = *t++;
1009: *d++ = 5 * j;
1010: while (j > 0) {
1011: *d++ = *t++;
1012: *d++ = *t >> 24;
1013: *d++ = *t >> 16;
1014: *d++ = *t >> 8;
1015: *d++ = *t++;
1016: j -= 1;
1017: }
1018: i -= 1;
1019: }
1020: *tt = t;
1021: return d;
1022: }
1023:
1024: static unsigned char *gen_announcement_support(struct sitab *st,
1025: unsigned char *p, unsigned long **tt)
1026: {
1027: unsigned char *d = p;
1028: unsigned long *t = *tt;
1029: unsigned char c, v;
1030: int i;
1031: *d++ = *t >> 8;
1032: *d++ = *t++;
1033: i = *t++;
1034: while (i > 0) {
1035: c = *t++ << 4;
1036: v = *t++ & 0x07;
1037: *d++ = c | 0x08 | v;
1038: switch (v) {
1039: case 0x01:
1040: case 0x02:
1041: case 0x03:
1042: *d++ = *t >> 8;
1043: *d++ = *t++;
1044: *d++ = *t >> 8;
1045: *d++ = *t++;
1046: *d++ = *t >> 8;
1047: *d++ = *t++;
1048: *d++ = *t++;
1049: break;
1050: }
1051: i -= 1;
1052: }
1053: *tt = t;
1054: return d;
1055: }
1056:
1057: const static signed char *const descr_syntax[DESCR_LAST-DESCR_FIRST+1] = {
1058: &syntax_network_name[0],
1059: &syntax_service_list[0],
1060: NULL,
1061: &syntax_satellite_delivery_system[0],
1062: &syntax_cable_delivery_system[0],
1063: NULL,
1064: NULL,
1065: &syntax_bouquet_name[0],
1066: &syntax_service[0],
1067: &syntax_country_availability[0],
1068: &syntax_linkage[0],
1069: &syntax_nvod_reference[0],
1070: &syntax_time_shifted_service[0],
1071: &syntax_short_event[0],
1072: &syntax_extended_event[0],
1073: &syntax_time_shifted_event[0],
1074: &syntax_component[0],
1075: &syntax_mosaic[0],
1076: NULL,
1077: &syntax_ca_identifier[0],
1078: &syntax_content[0],
1079: &syntax_parental_rating[0],
1080: NULL,
1081: &syntax_telephone[0],
1082: &syntax_local_time_offset[0],
1083: NULL,
1084: &syntax_terrestrial_delivery_system[0],
1085: &syntax_multilingual_network_name[0],
1086: &syntax_multilingual_bouquet_name[0],
1087: &syntax_multilingual_service_name[0],
1088: &syntax_multilingual_component[0],
1089: &syntax_private_data_specifier[0],
1090: NULL,
1091: &syntax_short_smoothing_buffer[0],
1092: &syntax_frequency_list[0],
1093: &syntax_partial_transport_stream[0],
1094: &syntax_data_broadcast[0],
1095: NULL,
1096: NULL,
1097: NULL,
1098: NULL,
1099: &syntax_pdc[0],
1100: NULL,
1101: NULL,
1102: &syntax_cell_list[0],
1103: &syntax_cell_frequency_link[0],
1104: &syntax_announcement_support[0]
1105: };
1106:
1107: static unsigned char *gendescr(struct sitab *st, unsigned char *p,
1108: unsigned long **tt, unsigned char msb)
1109: {
1110: unsigned char *d = p+2;
1111: unsigned long *t = *tt;
1112: unsigned char *b;
1113: unsigned char v;
1114: int i;
1115: i = *t++;
1116: while (i > 0) {
1117: b = d+2;
1118: switch (*d = v = *t++) {
1.5 oskar 1119: #define ENDEF_BEGIN(name,tag) case tag : d = gen_##name (st, b, &t); break;
1120: #define ENDEF_END
1121: #define ENDEF_NUMBER0(name)
1122: #define ENDEF_NUMBER1(name)
1123: #define ENDEF_DATETIME
1124: #define ENDEF_LOOP
1125: #define ENDEF_LOOPEND0
1126: #define ENDEF_LOOPEND1
1127: #define ENDEF_STRING(name)
1128: #define ENDEF_STRING3(name)
1129: #include "en300468ts.descr"
1130: #undef ENDEF_BEGIN
1131: #undef ENDEF_END
1132: #undef ENDEF_NUMBER0
1133: #undef ENDEF_NUMBER1
1134: #undef ENDEF_DATETIME
1135: #undef ENDEF_LOOP
1136: #undef ENDEF_LOOPEND0
1137: #undef ENDEF_LOOPEND1
1138: #undef ENDEF_STRING
1139: #undef ENDEF_STRING3
1.1 oskar 1140: default:
1141: fprintf(stderr, "error: descr not implemented (%02x)\n", *d);
1142: exit(1);
1143: }
1144: descrcnt[v-DESCR_FIRST] += 1;
1145: b[-1] = d-b;
1146: i -= 1;
1147: }
1148: i = d-p-2;
1149: p[0] = msb | (i >> 8);
1150: p[1] = i;
1151: *tt = t;
1152: return d;
1153: }
1154:
1.5 oskar 1155: #define ENDEF_BEGIN(name,pid,tableid) \
1156: const static signed char syntax_##name [] = {
1157: #define ENDEF_END SYNTAX_END};
1158: #define ENDEF_NUMBER0(name) SYNTAX_NUMBER
1159: #define ENDEF_NUMBER1(name) SYNTAX_NUMBER,
1160: #define ENDEF_DESCR SYNTAX_DESCR,
1161: #define ENDEF_DATETIME SYNTAX_DATETIME,
1162: #define ENDEF_LOOP SYNTAX_LOOP,
1163: #define ENDEF_LOOPEND0
1164: #include "en300468ts.table"
1165: #undef ENDEF_BEGIN
1166: #undef ENDEF_END
1167: #undef ENDEF_NUMBER0
1168: #undef ENDEF_NUMBER1
1169: #undef ENDEF_DESCR
1170: #undef ENDEF_DATETIME
1171: #undef ENDEF_LOOP
1172: #undef ENDEF_LOOPEND0
1.1 oskar 1173:
1174: static int gentab_nit(struct sitab *st, unsigned char *b)
1175: {
1176: unsigned char *p = b;
1177: unsigned long *t = st->tab;
1178: unsigned char *q;
1179: int i;
1180: *p = st->tableid;
1181: p += 3;
1182: *p++ = *t >> 8;
1183: *p++ = *t++;
1184: *p++ = 0xC0 | (st->version << 1) | 0x01;
1185: *p++ = 0;
1186: *p++ = 0;
1187: p = gendescr(st, p, &t, 0xF0);
1188: q = p;
1189: p += 2;
1190: i = *t++;
1191: while (i > 0) {
1192: *p++ = *t >> 8;
1193: *p++ = *t++;
1194: *p++ = *t >> 8;
1195: *p++ = *t++;
1196: p = gendescr(st, p, &t, 0xF0);
1197: i -= 1;
1198: }
1199: i = p-q-2;
1200: q[0] = 0xF0 | (i >> 8);
1201: q[1] = i;
1202: i = p-b+1;
1203: b[1] = 0xF0 | (i >> 8);
1204: b[2] = i;
1205: crc32_calc(b, i-1, p);
1206: return p-b+4;
1207: }
1208:
1209: static int gentab_sdt(struct sitab *st, unsigned char *b)
1210: {
1211: unsigned char *p = b;
1212: unsigned long *t = st->tab;
1213: int i;
1214: unsigned char c;
1215: *p = st->tableid;
1216: p += 3;
1217: *p++ = *t >> 8;
1218: *p++ = *t++;
1219: *p++ = 0xC0 | (st->version << 1) | 0x01;
1220: *p++ = 0;
1221: *p++ = 0;
1222: *p++ = *t >> 8;
1223: *p++ = *t++;
1224: *p++ = 0xFF;
1225: i = *t++;
1226: while (i > 0) {
1227: *p++ = *t >> 8;
1228: *p++ = *t++;
1229: c = *t++ << 1;
1230: *p++ = 0xFC | c | (*t++ & 1);
1231: c = *t++ << 5;
1232: p = gendescr(st, p, &t, c);
1233: i -= 1;
1234: }
1235: i = p-b+1;
1236: b[1] = 0xF0 | (i >> 8);
1237: b[2] = i;
1238: crc32_calc(b, i-1, p);
1239: return p-b+4;
1240: }
1241:
1242: static int gentab_bat(struct sitab *st, unsigned char *b)
1243: {
1244: unsigned char *p = b;
1245: unsigned long *t = st->tab;
1246: unsigned char *q;
1247: int i;
1248: *p = st->tableid;
1249: p += 3;
1250: *p++ = *t >> 8;
1251: *p++ = *t++;
1252: *p++ = 0xC0 | (st->version << 1) | 0x01;
1253: *p++ = 0;
1254: *p++ = 0;
1255: p = gendescr(st, p, &t, 0xF0);
1256: q = p;
1257: p += 2;
1258: i = *t++;
1259: while (i > 0) {
1260: *p++ = *t >> 8;
1261: *p++ = *t++;
1262: *p++ = *t >> 8;
1263: *p++ = *t++;
1264: p = gendescr(st, p, &t, 0xF0);
1265: i -= 1;
1266: }
1267: i = p-q-2;
1268: q[0] = 0xF0 | (i >> 8);
1269: q[1] = i;
1270: i = p-b+1;
1271: b[1] = 0xF0 | (i >> 8);
1272: b[2] = i;
1273: crc32_calc(b, i-1, p);
1274: return p-b+4;
1275: }
1276:
1277: static int gentab_eit(struct sitab *st, unsigned char *b)
1278: {
1279: unsigned char *p = b;
1280: unsigned long *t = st->tab;
1281: int i;
1.8 oskar 1282: unsigned char c;
1.1 oskar 1283: struct sitab *gt;
1284: *p = i = st->tableid;
1285: p += 3;
1286: *p++ = *t >> 8;
1287: *p++ = *t++;
1288: *p++ = 0xC0 | (st->version << 1) | 0x01;
1289: *p++ = 0;
1290: *p++ = 0;
1291: *p++ = *t >> 8;
1292: *p++ = *t++;
1293: *p++ = *t >> 8;
1294: *p++ = *t++;
1295: *p++ = 0;
1296: gt = runtab;
1297: while (gt != NULL) {
1298: if ((gt->esi == eit) && (gt->tableid > i)) {
1299: i = gt->tableid;
1300: }
1301: gt = gt->next;
1302: }
1303: *p++ = i;
1304: i = *t++;
1.8 oskar 1305: while (i > 0) {
1306: *p++ = *t >> 8;
1307: *p++ = *t++;
1308: *p++ = *t >> 8;
1309: *p++ = *t++;
1310: *p++ = *t >> 16;
1311: *p++ = *t >> 8;
1312: *p++ = *t++;
1313: *p++ = *t >> 16;
1314: *p++ = *t >> 8;
1315: *p++ = *t++;
1316: c = *t++ << 5;
1317: p = gendescr(st, p, &t, c);
1318: i -= 1;
1319: }
1.1 oskar 1320: i = p-b+1;
1321: b[1] = 0xF0 | (i >> 8);
1322: b[2] = i;
1323: crc32_calc(b, i-1, p);
1324: return p-b+4;
1325: }
1326:
1327: static int gentab_rst(struct sitab *st, unsigned char *b)
1328: {
1329: unsigned char *p = b;
1330: unsigned long *t = st->tab;
1331: int i;
1332: *p = st->tableid;
1333: p += 3;
1334: i = *t++;
1335: while (i > 0) {
1336: *p++ = *t >> 8;
1337: *p++ = *t++;
1338: *p++ = *t >> 8;
1339: *p++ = *t++;
1340: *p++ = *t >> 8;
1341: *p++ = *t++;
1342: *p++ = *t >> 8;
1343: *p++ = *t++;
1344: *p++ = 0xF8 | *t++;
1345: i -= 1;
1346: }
1347: i = p-b-3;
1348: b[1] = 0xF0 | (i >> 8);
1349: b[2] = i;
1350: return p-b;
1351: }
1352:
1353: static unsigned char *gentvdatetime(unsigned char *p, struct timeval *tv)
1354: {
1355: unsigned long d, s;
1356: s = tv->tv_sec;
1357: d = s / 86400;
1358: s = s % 86400;
1359: d += 40587;
1360: *p++ = d >> 8;
1361: *p++ = d;
1362: d = s / 3600;
1363: s = s % 3600;
1364: d += (d / 10) * 6;
1365: *p++ = d;
1366: d = s / 60;
1367: s = s % 60;
1368: d += (d / 10) * 6;
1369: *p++ = d;
1370: s += (s / 10) * 6;
1371: *p++ = s;
1372: return p;
1373: }
1374:
1375: static int gentab_tdt(struct sitab *st, unsigned char *b, struct timeval *tv)
1376: {
1377: unsigned char *p = b;
1378: *p++ = st->tableid;
1379: *p++ = 0xF0;
1380: *p++ = 0x05;
1381: p = gentvdatetime(p, tv);
1382: return p-b;
1383: }
1384:
1385: static int gentab_tot(struct sitab *st, unsigned char *b, struct timeval *tv)
1386: {
1387: unsigned char *p = b;
1388: unsigned long *t = st->tab;
1389: int i;
1390: *p = st->tableid;
1391: p += 3;
1392: p = gentvdatetime(p, tv);
1393: p = gendescr(st, p, &t, 0xF0);
1394: i = p-b+1;
1395: b[1] = 0xF0 | (i >> 8);
1396: b[2] = i;
1397: crc32_calc(b, i-1, p);
1398: return p-b+4;
1399: }
1400:
1401: static int gentab_sit(struct sitab *st, unsigned char *b)
1402: {
1403: unsigned char *p = b;
1404: unsigned long *t = st->tab;
1.3 oskar 1405: unsigned char c;
1406: int i;
1.1 oskar 1407: *p = st->tableid;
1.3 oskar 1408: p += 3;
1409: *p++ = 0xFF;
1410: *p++ = 0xFF;
1411: *p++ = 0xC0 | (st->version << 1) | 0x01;
1412: *p++ = 0;
1413: *p++ = 0;
1414: p = gendescr(st, p, &t, 0xF0);
1415: i = *t++;
1416: while (i > 0) {
1417: *p++ = *t >> 8;
1418: *p++ = *t++;
1419: c = *t++ << 4;
1420: p = gendescr(st, p, &t, 0x80 | c);
1421: i -= 1;
1422: }
1423: i = p-b+1;
1424: b[1] = 0xF0 | (i >> 8);
1425: b[2] = i;
1426: crc32_calc(b, i-1, p);
1427: return p-b+4;
1.1 oskar 1428: }
1429:
1430: static int gentab_dit(struct sitab *st, unsigned char *b)
1431: {
1432: unsigned char *p = b;
1433: unsigned long *t = st->tab;
1.3 oskar 1434: *p++ = st->tableid;
1435: *p++ = 0xF0;
1436: *p++ = 0x01;
1437: *p++ = (*t++ << 7) | 0x7F;
1.1 oskar 1438: return p-b;
1439: }
1440:
1441: const static signed char *const tab_syntax[num_si] = {
1.5 oskar 1442: #define ENDEF_BEGIN(name,pid,tableid) &syntax_##name [0],
1443: #define ENDEF_END
1444: #define ENDEF_NUMBER0(name)
1445: #define ENDEF_NUMBER1(name)
1446: #define ENDEF_DESCR
1447: #define ENDEF_DATETIME
1448: #define ENDEF_LOOP
1449: #define ENDEF_LOOPEND0
1450: #include "en300468ts.table"
1451: #undef ENDEF_BEGIN
1452: #undef ENDEF_END
1453: #undef ENDEF_NUMBER0
1454: #undef ENDEF_NUMBER1
1455: #undef ENDEF_DESCR
1456: #undef ENDEF_DATETIME
1457: #undef ENDEF_LOOP
1458: #undef ENDEF_LOOPEND0
1.1 oskar 1459: };
1460:
1461: const static signed char *const *const syntax[2] = {
1462: &tab_syntax[0],
1463: &descr_syntax[0]
1464: };
1465:
1466: static void gentab(struct sitab *st, struct timeval *tv)
1467: {
1.10 oskar 1468: int i, l;
1.1 oskar 1469: unsigned char *b;
1470: memset(&descrcnt[0], 0, sizeof(descrcnt));
1.10 oskar 1471: i = st->pid - TABLE_PID_FIRST;
1472: b = &tabbuf[i][tabin[i]];
1.1 oskar 1473: *b++ = st->pid >> 8;
1474: *b++ = st->pid;
1475: switch (st->esi) {
1476: case nit: l = gentab_nit(st, b); break;
1477: case sdt: l = gentab_sdt(st, b); break;
1478: case bat: l = gentab_bat(st, b); break;
1479: case eit: l = gentab_eit(st, b); break;
1480: case rst: l = gentab_rst(st, b); break;
1481: case tdt: l = gentab_tdt(st, b, tv); break;
1482: case tot: l = gentab_tot(st, b, tv); break;
1483: case sit: l = gentab_sit(st, b); break;
1484: case dit: l = gentab_dit(st, b); break;
1485: default:
1486: fprintf(stderr, "internal error (gentab, %d)\n", st->esi);
1487: exit(1);
1488: }
1.10 oskar 1489: tabin[i] += l+2;
1.1 oskar 1490: }
1491:
1492: static enum enumsi alloctab(long pid, long tid)
1493: {
1494: enum enumsi e = si_none;
1495: switch (pid) {
1496: case 0x0010:
1497: if ((tid == 0x40) || (tid == 0x41)) {
1498: e = nit;
1499: } else {
1500: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1501: }
1502: break;
1503: case 0x0011:
1504: if ((tid == 0x42) || (tid == 0x46)) {
1505: e = sdt;
1506: } else if (tid == 0x4A) {
1507: e = bat;
1508: } else {
1509: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1510: }
1511: break;
1512: case 0x0012:
1513: if ((tid >= 0x4E) && (tid <= 0x6F)) {
1514: e = eit;
1515: } else {
1516: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1517: }
1518: break;
1519: case 0x0013:
1520: if (tid == 0x71) {
1521: e = rst;
1522: } else {
1523: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1524: }
1525: break;
1526: case 0x0014:
1527: if (tid == 0x70) {
1528: e = tdt;
1529: } else if (tid == 0x73) {
1530: e = tot;
1531: } else {
1532: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1533: }
1534: break;
1535: case 0x001E:
1536: if (tid == 0x7E) {
1537: e = dit;
1538: } else {
1539: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1540: }
1541: break;
1542: case 0x001F:
1543: if (tid == 0x7F) {
1544: e = sit;
1545: } else {
1546: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1547: }
1548: break;
1549: default:
1550: fprintf(stderr, "bad pid: 0x%04lx\n", pid);
1551: break;
1552: }
1553: return e;
1554: }
1555:
1556: static void droptab(long pid, long tableid)
1557: {
1558: struct sitab **pst;
1559: struct sitab *st;
1560: pst = &runtab;
1.20 ! oskar 1561: while ((st = *pst)) {
! 1562: if ((st->pid == pid) && (st->tableid == tableid)) {
! 1563: *pst = st->next;
! 1564: nextversion[st->tableid - TABLEID_FIRST] = (st->version + 1) & 0x1F;
! 1565: free(st->tab);
! 1566: free(st);
! 1567: } else {
! 1568: pst = &st->next;
! 1569: }
1.1 oskar 1570: }
1571: }
1572:
1.19 oskar 1573: static void maketab(long pid, long tableid, long freqmsec, int fd)
1.1 oskar 1574: {
1575: struct sitab *t;
1576: enum enumsi e;
1577: e = alloctab(pid, tableid);
1578: if (e >= 0) {
1.20 ! oskar 1579: t = malloc(sizeof(struct sitab));
! 1580: if (t != NULL) {
1.1 oskar 1581: t->pid = pid;
1582: t->tableid = tableid;
1.20 ! oskar 1583: t->freqmsec = freqmsec;
! 1584: t->esi = e;
! 1585: t->tab = NULL;
! 1586: memset(&t->descrnum[0], 0, sizeof(t->descrnum));
! 1587: memset(&tabnew, 0, sizeof(tabnew));
! 1588: tabnew.fd = fd;
! 1589: newtab = t;
! 1590: }
1.1 oskar 1591: }
1592: }
1593:
1594: static int tabline(char *b, int n)
1595: {
1596: char *e, *a, *z;
1597: int i;
1598: long v[3];
1599: char c;
1600: if ((n <= 0) || ((e = memchr(b, '\n', n)) == NULL)) {
1601: return 0;
1602: }
1603: *e = 0;
1.13 oskar 1604: if (b < e) {
1.1 oskar 1605: z = b+1;
1606: i = 0;
1607: c = toupper(*b);
1608: switch (c) {
1609: case '-':
1610: do {
1611: a = z;
1612: v[i] = strtol(a, &z, 0);
1613: } while ((a != z) && (++i < 2));
1614: if (a == z) {
1615: fprintf(stderr, "invalid line(%d): %s\n", a-b, b);
1616: } else {
1617: droptab(v[0], v[1]);
1618: }
1619: break;
1620: case 'S':
1621: do {
1622: a = z;
1623: v[i] = strtol(a, &z, 0);
1624: } while ((a != z) && (++i < 3));
1625: if (a == z) {
1626: fprintf(stderr, "invalid line(%d): %s\n", a-b, b);
1627: } else {
1628: while (isspace(*z)) {
1629: z += 1;
1630: }
1631: i = open(z, O_RDONLY | O_NONBLOCK);
1632: if (i < 0) {
1633: fprintf(stderr, "open failed(%d): %s\n", errno, z);
1634: } else {
1635: #ifdef DEBUG
1636: fprintf(stderr, "table: %c, %ld, %ld, %ld, <%s>\n",
1637: c, v[0], v[1], v[2], z);
1638: #endif
1.19 oskar 1639: maketab(v[0], v[1], v[2], i);
1.1 oskar 1640: }
1641: }
1642: break;
1643: }
1644: }
1645: return e-b+1;
1646: }
1647:
1648: static int taballoc(struct sitab *st, int cnt)
1649: {
1.17 oskar 1650: while (tabnew.tablen < (tabnew.itab + cnt)) {
1651: tabnew.tablen += REALLOC_CHUNK;
1652: st->tab = realloc(st->tab, tabnew.tablen * sizeof(unsigned long));
1.1 oskar 1653: if (st->tab == NULL) {
1654: return -ENOMEM;
1655: }
1656: }
1657: return 0;
1658: }
1659:
1660: static long longval(char **n, int d)
1661: {
1662: long v;
1663: int i;
1664: char c;
1665: v = 0;
1666: for (i = 0; i < d; i++) {
1667: c = *(*n)++;
1668: if (!isdigit(c)) {
1669: return -ENOMEM;
1670: }
1671: v = 10*v+c-'0';
1672: }
1673: return v;
1674: }
1675:
1676: static int siline(struct sitab *st, char *b, int n)
1677: {
1678: char *e, *a, *z;
1679: long v;
1680: int s, i;
1.17 oskar 1681: s = syntax[(tabnew.isdescr > 0) ? 1 : 0]
1682: [(tabnew.isdescr > 0) ? tabnew.descrtag : st->esi][tabnew.isyn];
1.1 oskar 1683: if ((s == SYNTAX_END) || (s == SYNTAX_LOOPEND)) {
1684: int lc;
1685: #ifdef DEBUG
1686: fprintf(stderr, "end:\n");
1687: #endif
1.17 oskar 1688: if ((lc = --tabnew.loopcount[0]) <= 0) {
1.1 oskar 1689: if (lc == 0) {
1690: for (i = 0; i < LOOP_DEPTH-1; i++) {
1.17 oskar 1691: tabnew.loopbegin[i] = tabnew.loopbegin[i+1];
1692: tabnew.loopcount[i] = tabnew.loopcount[i+1];
1.1 oskar 1693: }
1.17 oskar 1694: tabnew.loopcount[LOOP_DEPTH-1] = 0;
1.1 oskar 1695: if (s == SYNTAX_LOOPEND) {
1.17 oskar 1696: tabnew.isyn += 1;
1697: } else if (tabnew.isdescr > 0) {
1698: if (--tabnew.isdescr == 0) {
1699: tabnew.isyn = tabnew.isyntab;
1.1 oskar 1700: }
1701: }
1702: return 0;
1703: } else {
1.17 oskar 1704: tabnew.tablen = tabnew.itab;
1705: st->tab = realloc(st->tab, tabnew.itab * sizeof(unsigned long));
1.1 oskar 1706: return -ENOBUFS;
1707: }
1708: } else {
1.17 oskar 1709: tabnew.isyn = tabnew.loopbegin[0];
1.1 oskar 1710: return 0;
1711: }
1712: }
1713: if ((n <= 0) || ((e = memchr(b, '\n', n)) == NULL)) {
1714: return -EAGAIN;
1715: }
1716: *e = 0;
1717: a = b;
1718: while (isspace(*a)) {
1719: a += 1;
1720: }
1721: if (taballoc(st, 1)) {
1722: return -ENOMEM;
1723: }
1724: if (a != e) {
1725: switch (s) {
1726: default:
1727: if (s > 0) {
1728: fprintf(stderr, "internal syntax error\n");
1729: exit(1);
1730: }
1.17 oskar 1731: if (tabnew.numcount == 0) {
1732: tabnew.numcount = s;
1.1 oskar 1733: }
1734: v = strtoul(a, &z, 0);
1735: if (a == z) {
1736: return -EINVAL;
1737: }
1738: #ifdef DEBUG
1739: fprintf(stderr, "number: %ld, %d..%d\n", v, a-b, z-b);
1740: #endif
1.17 oskar 1741: st->tab[tabnew.itab++] = v;
1742: if (++tabnew.numcount == 0) {
1743: tabnew.isyn += 1;
1.1 oskar 1744: }
1745: *e = '\n';
1746: return z-b;
1747: case SYNTAX_LOOP:
1748: v = strtol(a, &z, 0);
1749: if (a == z) {
1750: return -EINVAL;
1751: }
1752: #ifdef DEBUG
1753: fprintf(stderr, "loop: %ld, %d..%d\n", v, a-b, z-b);
1754: #endif
1.17 oskar 1755: st->tab[tabnew.itab++] = v;
1.1 oskar 1756: if (v != 0) {
1.17 oskar 1757: if (tabnew.isdescr > 0) {
1758: tabnew.isdescr += 1;
1.1 oskar 1759: }
1.7 oskar 1760: for (i = LOOP_DEPTH-2; i >= 0; i--) {
1.17 oskar 1761: tabnew.loopbegin[i+1] = tabnew.loopbegin[i];
1762: tabnew.loopcount[i+1] = tabnew.loopcount[i];
1.1 oskar 1763: }
1.17 oskar 1764: tabnew.loopbegin[0] = ++tabnew.isyn;
1765: tabnew.loopcount[0] = v;
1.1 oskar 1766: } else {
1767: do {
1.17 oskar 1768: tabnew.isyn += 1;
1769: s = syntax[(tabnew.isdescr > 0) ? 1 : 0]
1770: [(tabnew.isdescr > 0) ? tabnew.descrtag : st->esi]
1771: [tabnew.isyn];
1.1 oskar 1772: if (s == SYNTAX_LOOP) {
1773: v += 1;
1774: }
1775: } while ((s != SYNTAX_END) && ((s != SYNTAX_LOOPEND) || (--v >= 0)));
1776: if (s == SYNTAX_LOOPEND) {
1.17 oskar 1777: tabnew.isyn += 1;
1.1 oskar 1778: }
1779: }
1780: *e = '\n';
1781: return z-b;
1782: case SYNTAX_DESCR:
1783: v = strtol(a, &z, 0);
1784: if (a == z) {
1785: return -EINVAL;
1786: }
1787: #ifdef DEBUG
1788: fprintf(stderr, "descr: %ld, %d..%d\n", v, a-b, z-b);
1789: #endif
1.17 oskar 1790: st->tab[tabnew.itab++] = v;
1791: tabnew.isyn += 1;
1.1 oskar 1792: if (v != 0) {
1.17 oskar 1793: tabnew.isdescr = 1;
1794: tabnew.descrtag = 0;
1.7 oskar 1795: for (i = LOOP_DEPTH-2; i >= 0; i--) {
1.17 oskar 1796: tabnew.loopbegin[i+1] = tabnew.loopbegin[i];
1797: tabnew.loopcount[i+1] = tabnew.loopcount[i];
1.1 oskar 1798: }
1.17 oskar 1799: tabnew.loopbegin[0] = 0;
1800: tabnew.loopcount[0] = v;
1801: tabnew.isyntab = tabnew.isyn;
1802: tabnew.isyn = 0;
1.1 oskar 1803: }
1804: *e = '\n';
1805: return z-b;
1806: case SYNTAX_DESCRTAG:
1807: v = strtol(a, &z, 0);
1808: if (a == z) {
1809: return -EINVAL;
1810: }
1811: #ifdef DEBUG
1812: fprintf(stderr, "descrtag: %ld, %d..%d\n", v, a-b, z-b);
1813: #endif
1.17 oskar 1814: st->tab[tabnew.itab++] = v;
1.1 oskar 1815: v -= DESCR_FIRST;
1816: if ((v < 0) || (v > (DESCR_LAST - DESCR_FIRST))) {
1817: return -EINVAL;
1818: }
1819: st->descrnum[v] += 1;
1820: if (!((1 << st->esi) & possible_descr[v])) {
1821: return -EINVAL;
1822: }
1.17 oskar 1823: tabnew.descrtag = v;
1824: tabnew.isyn += 1;
1.1 oskar 1825: *e = '\n';
1826: return z-b;
1827: case SYNTAX_DATETIME:
1828: /* yyyy/mm/dd hh:mm:ss */
1829: z = a;
1830: i = e-z;
1831: if (i < 19) {
1832: return -EINVAL;
1833: }
1834: if (taballoc(st, 2)) {
1835: return -ENOMEM;
1836: }
1837: if ((v = longval(&z, 4)) < 0) {
1838: return v;
1839: }
1840: if ((v < 1582) || (*z++ != '/')) {
1841: return -EINVAL;
1842: }
1843: if ((s = longval(&z, 2)) < 0) {
1844: return s;
1845: }
1846: s -= 1;
1847: if ((s < 0) || (s > 11) || (*z++ != '/')) {
1848: return -EINVAL;
1849: }
1850: s -= 2;
1851: if (s < 0) {
1852: s += 12;
1853: v -= 1;
1854: }
1855: v = (1461*v)/4 - ((v/100+1)*3)/4 + (153*s)/5;
1856: if ((s = longval(&z, 2)) < 0) {
1857: return s;
1858: }
1859: if ((s <= 0) || (s > 31)) {
1860: return -EINVAL;
1861: }
1862: v += s - 678912;
1.17 oskar 1863: st->tab[tabnew.itab++] = v;
1.1 oskar 1864: v = 0;
1865: s = ' ';
1866: for (i = 2; i >= 0; i--) {
1867: if (*z++ != s) {
1868: return -EINVAL;
1869: }
1870: s = *z++;
1871: if (!isdigit(s)) {
1872: return -EINVAL;
1873: }
1874: v = (v<<4) + (s-'0');
1875: s = *z++;
1876: if (!isdigit(s)) {
1877: return -EINVAL;
1878: }
1879: v = (v<<4) + (s-'0');
1880: s = ':';
1881: }
1.17 oskar 1882: st->tab[tabnew.itab++] = v;
1.1 oskar 1883: #ifdef DEBUG
1884: fprintf(stderr, "datetime: %04lx %06lx, %d..%d\n",
1.17 oskar 1885: st->tab[tabnew.itab-2], v, a-b, z-b);
1.1 oskar 1886: #endif
1.17 oskar 1887: tabnew.isyn += 1;
1.1 oskar 1888: *e = '\n';
1889: return z-b;
1890: case SYNTAX_STRING:
1891: if (*a++ != '"') {
1892: return -EINVAL;
1893: }
1894: v = 0;
1895: z = strchr(a, '"');
1896: if (z == NULL) {
1897: return -EINVAL;
1898: }
1899: i = v;
1900: v += z-a;
1901: taballoc(st, 1 + (v + sizeof(long) - 1) / sizeof(long));
1.17 oskar 1902: memcpy(((char *)&st->tab[tabnew.itab+1]) + i, a, z-a);
1.1 oskar 1903: z += 1;
1904: while (*z == '"') {
1905: a = z;
1906: z = strchr(a+1, '"');
1907: if (z == NULL) {
1908: return -EINVAL;
1909: }
1910: i = v;
1911: v += z-a;
1912: taballoc(st, 1 + (v + sizeof(long) - 1) / sizeof(long));
1.17 oskar 1913: memcpy(((char *)&st->tab[tabnew.itab+1]) + i, a, z-a);
1.1 oskar 1914: z += 1;
1915: }
1.17 oskar 1916: st->tab[tabnew.itab] = v;
1.1 oskar 1917: #ifdef DEBUG
1918: fprintf(stderr, "string: %ld, %d..%d\n", v, a-b, z-b);
1919: #endif
1.17 oskar 1920: tabnew.itab += 1 + (v + sizeof(long) - 1) / sizeof(long);
1921: tabnew.isyn += 1;
1.1 oskar 1922: *e = '\n';
1923: return z-b;
1924: }
1925: } else {
1926: return e-b+1;
1927: }
1928: }
1929:
1930: static unsigned int tab2ts(unsigned char *t, unsigned char *conticnt)
1931: {
1932: unsigned int l, d;
1933: unsigned char *i = &t[2];
1934: unsigned char *o;
1935: unsigned char c = *conticnt;
1.4 oskar 1936: l = ((t[3] & 0x0F) << 8) + t[4] + TS_HEADSLEN + TS_PFIELDLEN;
1.1 oskar 1937: d = (l-1) % (TS_PACKET_SIZE - TS_PACKET_HEADSIZE) + 1;
1938: if (outin >= OUTBUF_SIZE) {
1939: outin = 0;
1940: }
1.9 oskar 1941: #ifdef DEBUG
1942: fprintf(stderr, "tab2ts(%02x,%02x,%02x,%02x,%02x; %2d), l=%d, d=%d, o:%d\n",
1943: t[0], t[1], t[2], t[3], t[4], c, l, d, outin);
1944: #endif
1.1 oskar 1945: o = &outbuf[outin];
1946: if (d <= (TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1)) {
1947: if (d < (TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1)) {
1948: o[5] = 0; /* no indicators, no flags, padding: */
1949: memset(&o[6], -1, TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 2 - d);
1950: }
1951: o[4] = TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1 - d;
1952: o[3] = (0x00 << 6) | (0x03 << 4) | c;
1953: } else {
1954: o[3] = (0x00 << 6) | (0x01 << 4) | c;
1955: }
1.4 oskar 1956: o[TS_PACKET_SIZE - d] = 0; /* pointer_field */
1957: d -= TS_PFIELDLEN;
1.1 oskar 1958: memcpy(&o[TS_PACKET_SIZE - d], i, d);
1959: i += d;
1.4 oskar 1960: d = l - d - TS_PFIELDLEN;
1.1 oskar 1961: o[1] = (0 << 7) | (1 << 6) | (0 << 5) | t[0];
1962: o[2] = t[1];
1963: o[0] = TS_SYNC_BYTE;
1964: c = (c + 1) & 0x0F;
1965: outin += TS_PACKET_SIZE;
1966: while (d > 0) {
1967: if (outin >= OUTBUF_SIZE) {
1968: outin = 0;
1969: }
1970: o = &outbuf[outin];
1971: o[3] = (0x00 << 6) | (0x01 << 4) | c;
1972: memcpy(&o[4], i, TS_PACKET_SIZE-TS_PACKET_HEADSIZE);
1973: i += (TS_PACKET_SIZE - TS_PACKET_HEADSIZE);
1974: d -= (TS_PACKET_SIZE - TS_PACKET_HEADSIZE);
1975: o[1] = (0 << 7) | (0 << 6) | (0 << 5) | t[0];
1976: o[2] = t[1];
1977: o[0] = TS_SYNC_BYTE;
1978: c = (c + 1) & 0x0F;
1979: outin += TS_PACKET_SIZE;
1980: }
1981: *conticnt = c;
1.11 oskar 1982: return l+1;
1.1 oskar 1983: }
1984:
1985: static void argloop(int f0)
1986: {
1987: int i0 = 0;
1.12 oskar 1988: int o0 = 0;
1.1 oskar 1989: char buf0[PATH_MAX];
1990: do {
1991: int i, n, r, n0, n1, nst, tmo;
1992: struct timeval tv;
1993: struct sitab *st;
1994: struct sitab **pst;
1995: pollfd_init();
1.12 oskar 1996: tmo = -1;
1997: n0 = -1;
1998: nst = -1;
1999: if (newtab != NULL) {
1.17 oskar 2000: nst = pollfd_add(tabnew.fd, POLLIN);
1.18 oskar 2001: } else if ((r = tabline(&buf0[o0], i0 - o0))) {
1.12 oskar 2002: o0 += r;
2003: tmo = 0;
1.1 oskar 2004: } else {
1.18 oskar 2005: if ((o0 > 0) && (i0 > o0)) {
2006: memmove(&buf0[0], &buf0[o0], i0 - o0);
1.12 oskar 2007: }
1.18 oskar 2008: i0 -= o0;
2009: o0 = 0;
1.12 oskar 2010: if (i0 == sizeof(buf0)-1) {
2011: buf0[sizeof(buf0)-1] = '\n';
2012: i0 += 1;
2013: tmo = 0;
2014: } else if (f0 >= 0) {
2015: n0 = pollfd_add(f0, POLLIN);
1.1 oskar 2016: }
2017: }
2018: if (outin == 0) {
2019: r = OUTBUF_SIZE;
2020: n1 = -1;
2021: } else {
2022: r = outout - outin;
2023: if (r < 0) {
2024: r += OUTBUF_SIZE;
2025: }
2026: n1 = pollfd_add(STDOUT_FILENO, POLLOUT);
2027: }
1.12 oskar 2028: i = 0;
2029: while (tmo != 0 && i <= TABLE_PID_LAST-TABLE_PID_FIRST) {
1.1 oskar 2030: if ((tabin[i] > tabout[i])
2031: && (r >= (((((tabbuf[i][tabout[i]+3] & 0x0F) << 8)
1.4 oskar 2032: + tabbuf[i][tabout[i]+4] + TS_HEADSLEN + TS_PFIELDLEN
1.1 oskar 2033: + TS_PACKET_SIZE - TS_PACKET_HEADSIZE)
2034: * 131) / 128))) {
2035: tmo = 0;
1.9 oskar 2036: #ifdef DEBUG
2037: {
2038: int x;
2039: fprintf(stderr, "tabbuf[%d..%d-1]:\n", tabout[i], tabin[i]);
2040: for (x = tabout[i]; x < tabin[i]; x++) {
2041: fprintf(stderr, "%02x ", tabbuf[i][x]);
2042: }
2043: fprintf(stderr, "\n");
2044: }
2045: #endif
1.1 oskar 2046: }
1.12 oskar 2047: i += 1;
1.1 oskar 2048: }
2049: gettimeofday(&tv, NULL);
2050: st = runtab;
2051: while (st != NULL) {
2052: i = st->pid - TABLE_PID_FIRST;
2053: if ((i < 0) || (i >= (TABLE_PID_LAST-TABLE_PID_FIRST))) {
2054: fprintf(stderr, "internal error (pid)\n");
2055: exit(1);
2056: }
2057: tabinold[i] = tabin[i];
2058: if (tmo != 0) {
2059: if (tabin[i] == 0) {
1.16 oskar 2060: i = (st->soon.tv_sec - tv.tv_sec) * 1000
2061: + (st->soon.tv_usec - tv.tv_usec) / 1000;
1.1 oskar 2062: if (i <= 0) {
2063: tmo = 0;
2064: } else if ((tmo < 0) || (i < tmo)) {
2065: tmo = i;
2066: }
2067: }
2068: }
2069: st = st->next;
2070: }
2071: n = pollfd_poll(tmo);
2072: gettimeofday(&tv, NULL);
2073: for (i = 0; i <= TABLE_PID_LAST-TABLE_PID_FIRST; i++) {
2074: while ((tabin[i] > tabout[i])
2075: && (r >= (((((tabbuf[i][tabout[i]+3] & 0x0F) << 8)
1.4 oskar 2076: + tabbuf[i][tabout[i]+4] + TS_HEADSLEN + TS_PFIELDLEN
1.1 oskar 2077: + TS_PACKET_SIZE - TS_PACKET_HEADSIZE)
2078: * 131) / 128))) {
2079: tabout[i] += tab2ts(&tabbuf[i][tabout[i]], &conticnt[i]);
2080: r = outout - outin;
2081: if (r < 0) {
2082: r += OUTBUF_SIZE;
2083: }
2084: }
2085: if (tabin[i] <= tabout[i]) {
2086: tabin[i] = tabout[i] = 0;
2087: }
2088: }
2089: if ((n > 0) && (n1 >= 0) && (r = pollfd_rev(n1))) {
2090: if (r & (POLLNVAL | POLLERR)) {
2091: fprintf(stderr, "poll error: %x\n", r);
2092: return;
2093: }
2094: if (outout >= OUTBUF_SIZE) {
2095: outout = 0;
2096: }
2097: r = ((outin > outout) ? outin : OUTBUF_SIZE) - outout;
2098: r = write(STDOUT_FILENO, &outbuf[outout], r);
2099: if (r < 0) {
2100: fprintf(stderr, "write error(%d)\n", errno);
2101: return;
2102: }
2103: if (r == 0) {
2104: exit(0);
2105: }
2106: outout += r;
2107: if (outout == outin) {
2108: outin = outout = 0;
2109: }
2110: }
2111: pst = &runtab;
2112: while ((st = *pst) != NULL) {
2113: i = st->pid - TABLE_PID_FIRST;
2114: if ((tabinold[i] == 0)
2115: && (tabin[i] < (TABBUF_SIZE-MAX_PSI_SIZE+1-2))
1.16 oskar 2116: && ((st->soon.tv_sec < tv.tv_sec)
2117: || ((st->soon.tv_sec == tv.tv_sec)
2118: && (st->soon.tv_usec <= tv.tv_usec)))) {
1.1 oskar 2119: if (st->freqmsec > 0) {
1.16 oskar 2120: i = (st->soon.tv_sec - tv.tv_sec) * 1000
2121: + (st->soon.tv_usec - tv.tv_usec) / 1000;
1.1 oskar 2122: if (i < -st->freqmsec) {
1.16 oskar 2123: st->soon = tv;
1.1 oskar 2124: } else {
1.16 oskar 2125: st->soon.tv_sec += st->freqmsec / 1000;
2126: st->soon.tv_usec += (st->freqmsec % 1000) * 1000;
2127: if (st->soon.tv_usec > 1000000) {
2128: st->soon.tv_usec -= 1000000;
2129: st->soon.tv_sec += 1;
1.1 oskar 2130: }
2131: }
2132: }
2133: #ifdef DEBUG
2134: fprintf(stderr, "do tab: %ld.%06ld: %ld, %u\n", tv.tv_sec, tv.tv_usec,
2135: st->pid, st->tableid);
2136: #endif
2137: gentab(st, &tv);
2138: if (st->freqmsec <= 0) {
2139: *pst = st->next;
2140: nextversion[st->tableid - TABLEID_FIRST] = (st->version + 1) & 0x1F;
2141: free(st->tab);
2142: free(st);
2143: } else {
2144: pst = &st->next;
2145: }
2146: } else {
2147: pst = &st->next;
2148: }
2149: }
1.15 oskar 2150: if ((n > 0) && (nst >= 0) && (r = pollfd_rev(nst))) {
2151: if (r & (POLLNVAL | POLLERR)) {
2152: fprintf(stderr, "poll error: %x\n", r);
1.17 oskar 2153: close(tabnew.fd);
1.15 oskar 2154: free(newtab->tab);
2155: free(newtab);
2156: newtab = NULL;
2157: } else {
1.17 oskar 2158: i = tabnew.ibuf;
2159: r = read(tabnew.fd, &tabnew.buf[i], sizeof(tabnew.buf) - i - 1);
1.15 oskar 2160: if (r <= 0) {
1.17 oskar 2161: fprintf(stderr, "read error(%d): %d\n", errno, tabnew.fd);
2162: close(tabnew.fd);
1.15 oskar 2163: free(newtab->tab);
2164: free(newtab);
2165: newtab = NULL;
2166: } else {
2167: int j = 0;
2168: i += r;
1.17 oskar 2169: while ((r = siline(newtab, &tabnew.buf[j], i)) >= 0) {
1.15 oskar 2170: j += r;
2171: i -= r;
2172: }
2173: switch (r) {
2174: case -ENOBUFS:
1.17 oskar 2175: close(tabnew.fd);
1.15 oskar 2176: #ifdef DEBUG
1.17 oskar 2177: fprintf(stderr, "done, itab=%d\n", tabnew.itab);
2178: for (i = 0; i < tabnew.itab; i++) {
1.15 oskar 2179: fprintf(stderr, "%lu,", newtab->tab[i]);
2180: }
2181: fprintf(stderr, "\n");
2182: #endif
2183: i = newtab->pid - TABLE_PID_FIRST;
2184: if ((tabbuf[i] == NULL)
2185: && ((tabbuf[i] = malloc(TABBUF_SIZE)) == NULL)) {
2186: fprintf(stderr, "malloc failed for table buffer pid=%02lx\n",
2187: newtab->pid);
2188: free(newtab->tab);
2189: free(newtab);
1.1 oskar 2190: } else {
1.20 ! oskar 2191: droptab(newtab->pid, newtab->tableid);
! 2192: newtab->version = nextversion[newtab->tableid - TABLEID_FIRST];
1.16 oskar 2193: newtab->soon = tv;
1.15 oskar 2194: newtab->next = runtab;
2195: runtab = newtab;
2196: }
1.20 ! oskar 2197: newtab = NULL;
1.15 oskar 2198: break;
2199: case -EAGAIN:
2200: if (i > 0) {
1.17 oskar 2201: memmove(&tabnew.buf[0], &tabnew.buf[j], i);
1.1 oskar 2202: }
1.17 oskar 2203: tabnew.ibuf = i;
1.15 oskar 2204: break;
2205: default:
2206: fprintf(stderr, "eval error: %d\n", r);
1.17 oskar 2207: close(tabnew.fd);
1.15 oskar 2208: free(newtab->tab);
2209: free(newtab);
2210: newtab = NULL;
2211: break;
1.1 oskar 2212: }
2213: }
1.15 oskar 2214: }
2215: n -= 1;
1.1 oskar 2216: }
2217: if ((n > 0) && (n0 >= 0) && (r = pollfd_rev(n0))) {
2218: if (r & (POLLNVAL | POLLERR)) {
2219: fprintf(stderr, "poll error: %x\n", r);
2220: return;
2221: }
2222: r = read(f0, &buf0[i0], sizeof(buf0) - i0 - 1);
2223: if (r < 0) {
2224: fprintf(stderr, "read error(%d): %d\n", errno, f0);
2225: return;
2226: }
2227: if (r == 0) {
2228: return;
2229: }
2230: i0 += r;
2231: n -= 1;
2232: }
2233: } while (1);
2234: }
2235:
2236: int main(int argc, char *argv[])
2237: {
2238: int f = -1;
2239: int a;
2240: if (sizeof(unsigned) != sizeof(struct loop_descr *)) {
2241: fprintf(stderr, "data type prerequisites not met\n");
2242: return 1;
2243: }
2244: gen_crc32_table();
2245: system_init();
2246: unblockf(STDIN_FILENO);
2247: unblockf(STDOUT_FILENO);
2248: memset(&tabin[0], 0, sizeof(tabin));
2249: memset(&tabout[0], 0, sizeof(tabout));
2250: memset(&conticnt[0], 0, sizeof(conticnt));
2251: memset(&nextversion[0], 0, sizeof(nextversion));
2252: for (a = TABLE_PID_LAST-TABLE_PID_FIRST; a >= 0; a--) {
2253: tabbuf[a] = NULL;
2254: }
2255: a = 1;
2256: do {
2257: if ((a < argc) && (strcmp(argv[a], "-"))) {
2258: f = open(argv[a], O_RDONLY | O_NONBLOCK);
2259: if (f < 0) {
2260: fprintf(stderr, "open failed(%d): %s\n", errno, argv[a]);
2261: }
2262: } else {
2263: f = STDIN_FILENO;
2264: }
2265: argloop(f);
2266: } while (++a < argc);
2267: argloop(-1);
2268: return 0;
2269: }
LinuxTV legacy CVS <linuxtv.org/cvs>