Data-Over-Voice
[lcr.git] / ie.cpp
1
2 /*****************************************************************************\
3 **                                                                           **
4 ** PBX4Linux                                                                 **
5 **                                                                           **
6 **---------------------------------------------------------------------------**
7 ** Copyright: Andreas Eversberg                                              **
8 **                                                                           **
9 ** information elements encode and decode                                    **
10 **                                                                           **
11 \*****************************************************************************/ 
12
13 /*
14  the pointer of enc_ie_* always points to the IE itself
15  if qi is not NULL (TE-mode), offset is set
16 */
17
18 /* support stuff */
19 static void strnncpy(unsigned char *dest, unsigned char *src, int len, int dst_len)
20 {
21         if (len > dst_len-1)
22                 len = dst_len-1;
23         UNCPY((char *)dest, (char *)src, len);
24         dest[len] = '\0';
25 }
26
27
28 /* IE_COMPLETE */
29 void Pdss1::enc_ie_complete(struct l3_msg *l3m, int complete)
30 {
31
32         if (complete<0 || complete>1) {
33                 PERROR("complete(%d) is out of range.\n", complete);
34                 return;
35         }
36
37         if (complete) {
38                 add_trace("complete", NULL, NULL);
39                 l3m->sending_complete++;
40         }
41 }
42
43 void Pdss1::dec_ie_complete(struct l3_msg *l3m, int *complete)
44 {
45         *complete = 0;
46         // special case: p is not a pointer, it's a value
47         unsigned char p = l3m->sending_complete;
48         if (p)
49                 *complete = 1;
50
51         if (*complete)
52                 add_trace("complete", NULL, NULL);
53 }
54
55
56 /* IE_BEARER */
57 void Pdss1::enc_ie_bearer(struct l3_msg *l3m, int coding, int capability, int mode, int rate, int multi, int user)
58 {
59         unsigned char p[256];
60         int l;
61
62         if (coding<0 || coding>3) {
63                 PERROR("coding(%d) is out of range.\n", coding);
64                 return;
65         }
66         if (capability<0 || capability>31) {
67                 PERROR("capability(%d) is out of range.\n", capability);
68                 return;
69         }
70         if (mode<0 || mode>3) {
71                 PERROR("mode(%d) is out of range.\n", mode);
72                 return;
73         }
74         if (rate<0 || rate>31) {
75                 PERROR("rate(%d) is out of range.\n", rate);
76                 return;
77         }
78         if (multi>127) {
79                 PERROR("multi(%d) is out of range.\n", multi);
80                 return;
81         }
82         if (user>31) {
83                 PERROR("user L1(%d) is out of range.\n", user);
84                 return;
85         }
86         if (rate!=24 && multi>=0) {
87                 PERROR("multi(%d) is only possible if rate(%d) would be 24.\n", multi, rate);
88                 multi = -1;
89         }
90
91         add_trace("bearer", "coding", "%d", coding);
92         add_trace("bearer", "capability", "%d", capability);
93         add_trace("bearer", "mode", "%d", mode);
94         add_trace("bearer", "rate", "%d", rate);
95         add_trace("bearer", "multi", "%d", multi);
96         add_trace("bearer", "user", "%d", user);
97
98         l = 2 + (multi>=0) + (user>=0);
99         p[0] = IE_BEARER;
100         p[1] = l;
101         p[2] = 0x80 + (coding<<5) + capability;
102         p[3] = 0x80 + (mode<<5) + rate;
103         if (multi >= 0)
104                 p[4] = 0x80 + multi;
105         if (user >= 0)
106                 p[4+(multi>=0)] = 0xa0 + user;
107         add_layer3_ie(l3m, p[0], p[1], p+2);
108 }
109
110 void Pdss1::dec_ie_bearer(struct l3_msg *l3m, int *coding, int *capability, int *mode, int *rate, int *multi, int *user)
111 {
112         *coding = -1;
113         *capability = -1;
114         *mode = -1;
115         *rate = -1;
116         *multi = -1;
117         *user = -1;
118
119         unsigned char *p = l3m->bearer_capability;
120         if (!p)
121                 return;
122         if (p[0] < 2) {
123                 add_trace("bearer", "error", "IE too short (len=%d)", p[0]);
124                 return;
125         }
126
127         *coding = (p[1]&0x60) >> 5;
128         *capability = p[1] & 0x1f;
129         if (p[0]>=2) {
130                 *mode = (p[2]&0x60) >> 5;
131                 *rate = p[2] & 0x1f;
132         }
133         if (p[0]>=3 && *rate==0x18) {
134                 *multi = p[3] & 0x7f;
135                 if (p[0]>=4)
136                         *user = p[4] & 0x1f;
137         } else {
138                 if (p[0]>=3)
139                         *user = p[3] & 0x1f;
140         }
141
142         add_trace("bearer", "coding", "%d", *coding);
143         add_trace("bearer", "capability", "%d", *capability);
144         add_trace("bearer", "mode", "%d", *mode);
145         add_trace("bearer", "rate", "%d", *rate);
146         add_trace("bearer", "multi", "%d", *multi);
147         add_trace("bearer", "user", "%d", *user);
148 }
149
150
151 /* IE_HLC */
152 void Pdss1::enc_ie_hlc(struct l3_msg *l3m, int coding, int interpretation, int presentation, int hlc, int exthlc)
153 {
154         unsigned char p[256];
155         int l;
156
157         if (coding<0 || coding>3) {
158                 PERROR("coding(%d) is out of range.\n", coding);
159                 return;
160         }
161         if (interpretation<0 || interpretation>7) {
162                 PERROR("interpretation(%d) is out of range.\n", interpretation);
163                 return;
164         }
165         if (presentation<0 || presentation>3) {
166                 PERROR("presentation(%d) is out of range.\n", presentation);
167                 return;
168         }
169         if (hlc<0 || hlc>127) {
170                 PERROR("hlc(%d) is out of range.\n", hlc);
171                 return;
172         }
173         if (exthlc>127) {
174                 PERROR("hlc(%d) is out of range.\n", exthlc);
175                 return;
176         }
177
178         add_trace("hlc", "coding", "%d", coding);
179         add_trace("hlc", "interpretation", "%d", interpretation);
180         add_trace("hlc", "presentation", "%d", presentation);
181         add_trace("hlc", "hlc", "%d", hlc);
182         if (exthlc >= 0)
183                 add_trace("hlc", "exthlc", "%d", exthlc);
184
185         l = 2 + (exthlc>=0);
186         p[0] = IE_HLC;
187         p[1] = l;
188         p[2] = 0x80 + (coding<<5) + (interpretation<<2) + presentation;
189         if (exthlc >= 0) {
190                 p[3] = hlc;
191                 p[4] = 0x80 + exthlc;
192         } else
193                 p[3] = 0x80 + hlc;
194         add_layer3_ie(l3m, p[0], p[1], p+2);
195 }
196
197 void Pdss1::dec_ie_hlc(struct l3_msg *l3m, int *coding, int *interpretation, int *presentation, int *hlc, int *exthlc)
198 {
199         *coding = -1;
200         *interpretation = -1;
201         *presentation = -1;
202         *hlc = -1;
203         *exthlc = -1;
204
205         unsigned char *p = l3m->hlc;
206         if (!p)
207                 return;
208         if (p[0] < 2) {
209                 add_trace("hlc", "error", "IE too short (len=%d)", p[0]);
210                 return;
211         }
212
213         *coding = (p[1]&0x60) >> 5;
214         *interpretation = (p[1]&0x1c) >> 2;
215         *presentation = p[1] & 0x03;
216         *hlc = p[2] & 0x7f;
217         if (p[0]>=3) {
218                 *exthlc = p[3] & 0x7f;
219         }
220
221         add_trace("hlc", "coding", "%d", *coding);
222         add_trace("hlc", "interpretation", "%d", *interpretation);
223         add_trace("hlc", "presentation", "%d", *presentation);
224         add_trace("hlc", "hlc", "%d", *hlc);
225         if (*exthlc >= 0)
226                 add_trace("hlc", "exthlc", "%d", *exthlc);
227 }
228
229
230 /* IE_CALL_ID */
231 void Pdss1::enc_ie_call_id(struct l3_msg *l3m, unsigned char *callid, int callid_len)
232 {
233         unsigned char p[256];
234         int l;
235
236         char buffer[25];
237         int i;
238
239         if (!callid || callid_len<=0) {
240                 return;
241         }
242         if (callid_len > 8) {
243                 PERROR("callid_len(%d) is out of range.\n", callid_len);
244                 return;
245         }
246
247         i = 0;
248         while(i < callid_len) {
249                 UPRINT(buffer+(i*3), " %02x", callid[i]);
250                 i++;
251         }
252                 
253         add_trace("callid", NULL, "%s", buffer[0]?buffer+1:"<none>");
254
255         l = callid_len;
256         p[0] = IE_CALL_ID;
257         p[1] = l;
258         memcpy(p+2, callid, callid_len);
259         add_layer3_ie(l3m, p[0], p[1], p+2);
260 }
261
262 void Pdss1::dec_ie_call_id(struct l3_msg *l3m, unsigned char *callid, int *callid_len)
263 {
264         char buffer[25];
265         int i;
266
267         *callid_len = -1;
268
269         unsigned char *p = l3m->call_id;
270         if (!p)
271                 return;
272         if (p[0] > 8) {
273                 add_trace("callid", "error", "IE too long (len=%d)", p[0]);
274                 return;
275         }
276
277         *callid_len = p[0];
278         memcpy(callid, p+1, *callid_len);
279
280         i = 0;
281         while(i < *callid_len) {
282                 UPRINT(buffer+(i*3), " %02x", callid[i]);
283                 i++;
284         }
285                 
286         add_trace("callid", NULL, "%s", buffer[0]?buffer+1:"<none>");
287 }
288
289
290 /* IE_CALLED_PN */
291 void Pdss1::enc_ie_called_pn(struct l3_msg *l3m, int type, int plan, unsigned char *number, int number_len)
292 {
293         unsigned char p[256];
294         int l;
295
296         if (type<0 || type>7) {
297                 PERROR("type(%d) is out of range.\n", type);
298                 return;
299         }
300         if (plan<0 || plan>15) {
301                 PERROR("plan(%d) is out of range.\n", plan);
302                 return;
303         }
304         if (!number[0]) {
305                 PERROR("number is not given.\n");
306                 return;
307         }
308
309         add_trace("called_pn", "type", "%d", type);
310         add_trace("called_pn", "plan", "%d", plan);
311         UNCPY((char *)p, (char *)number, number_len);
312         p[number_len] = '\0';
313         add_trace("called_pn", "number", "%s", p);
314
315         l = 1+number_len;
316         p[0] = IE_CALLED_PN;
317         p[1] = l;
318         p[2] = 0x80 + (type<<4) + plan;
319         UNCPY((char *)p+3, (char *)number, number_len);
320         add_layer3_ie(l3m, p[0], p[1], p+2);
321 }
322
323 void Pdss1::dec_ie_called_pn(struct l3_msg *l3m, int *type, int *plan, unsigned char *number, int number_len)
324 {
325         *type = -1;
326         *plan = -1;
327         *number = '\0';
328
329         unsigned char *p = l3m->called_nr;
330         if (!p)
331                 return;
332         if (p[0] < 2) {
333                 add_trace("called_pn", "error", "IE too short (len=%d)", p[0]);
334                 return;
335         }
336
337         *type = (p[1]&0x70) >> 4;
338         *plan = p[1] & 0xf;
339         strnncpy(number, p+2, p[0]-1, number_len);
340
341         add_trace("called_pn", "type", "%d", *type);
342         add_trace("called_pn", "plan", "%d", *plan);
343         add_trace("called_pn", "number", "%s", number);
344 }
345
346
347 /* IE_CALLING_PN */
348 void Pdss1::enc_ie_calling_pn(struct l3_msg *l3m, int type, int plan, int present, int screen, unsigned char *number, int type2, int plan2, int present2, int screen2, unsigned char *number2)
349 {
350         unsigned char p[256];
351         int l;
352
353         if (type<0 || type>7) {
354                 PERROR("type(%d) is out of range.\n", type);
355                 return;
356         }
357         if (plan<0 || plan>15) {
358                 PERROR("plan(%d) is out of range.\n", plan);
359                 return;
360         }
361         if (present>3) {
362                 PERROR("present(%d) is out of range.\n", present);
363                 return;
364         }
365         if (present >= 0) if (screen<0 || screen>3) {
366                 PERROR("screen(%d) is out of range.\n", screen);
367                 return;
368         }
369
370         add_trace("calling_pn", "type", "%d", type);
371         add_trace("calling_pn", "plan", "%d", plan);
372         add_trace("calling_pn", "present", "%d", present);
373         add_trace("calling_pn", "screen", "%d", screen);
374         add_trace("calling_pn", "number", "%s", number);
375
376         l = 1;
377         if (number) if (number[0])
378                 l += strlen((char *)number);
379         if (present >= 0)
380                 l += 1;
381         p[0] = IE_CALLING_PN;
382         p[1] = l;
383         if (present >= 0) {
384                 p[2] = 0x00 + (type<<4) + plan;
385                 p[3] = 0x80 + (present<<5) + screen;
386                 if (number) if (number[0])
387                         UNCPY((char *)p+4, (char *)number, strlen((char *)number));
388         } else {
389                 p[2] = 0x80 + (type<<4) + plan;
390                 if (number) if (number[0])
391                         UNCPY((char *)p+3, (char *)number, strlen((char *)number));
392         }
393         add_layer3_ie(l3m, p[0], p[1], p+2);
394
395         /* second calling party number */
396         if (type2 < 0)
397                 return;
398         
399         if (type2>7) {
400                 PERROR("type2(%d) is out of range.\n", type2);
401                 return;
402         }
403         if (plan2<0 || plan2>15) {
404                 PERROR("plan2(%d) is out of range.\n", plan2);
405                 return;
406         }
407         if (present2>3) {
408                 PERROR("present2(%d) is out of range.\n", present2);
409                 return;
410         }
411         if (present2 >= 0) if (screen2<0 || screen2>3) {
412                 PERROR("screen2(%d) is out of range.\n", screen2);
413                 return;
414         }
415
416         add_trace("call_pn 2", "type", "%d", type2);
417         add_trace("call_pn 2", "plan", "%d", plan2);
418         add_trace("call_pn 2", "present", "%d", present2);
419         add_trace("call_pn 2", "screen", "%d", screen2);
420         add_trace("call_pn 2", "number", "%s", number2);
421
422         l = 1;
423         if (number2) if (number2[0])
424                 l += strlen((char *)number2);
425         if (present2 >= 0)
426                 l += 1;
427         p[0] = IE_CALLING_PN;
428         p[1] = l;
429         if (present2 >= 0) {
430                 p[2] = 0x00 + (type2<<4) + plan2;
431                 p[3] = 0x80 + (present2<<5) + screen2;
432                 if (number2) if (number2[0])
433                         UNCPY((char *)p+4, (char *)number2, strlen((char *)number2));
434         } else {
435                 p[2] = 0x80 + (type2<<4) + plan2;
436                 if (number2) if (number2[0])
437                         UNCPY((char *)p+3, (char *)number2, strlen((char *)number2));
438         }
439         add_layer3_ie(l3m, p[0], p[1], p+2);
440 }
441
442 void Pdss1::dec_ie_calling_pn(struct l3_msg *l3m, int *type, int *plan, int *present, int *screen, unsigned char *number, int number_len, int *type2, int *plan2, int *present2, int *screen2, unsigned char *number2, int number_len2)
443 {
444         *type = -1;
445         *plan = -1;
446         *present = -1;
447         *screen = -1;
448         *number = '\0';
449         *type2 = -1;
450         *plan2 = -1;
451         *present2 = -1;
452         *screen2 = -1;
453         *number2 = '\0';
454         unsigned int numextra = sizeof(l3m->extra) / sizeof(struct m_extie);
455         unsigned int i;
456
457         unsigned char *p = l3m->calling_nr;
458         if (!p)
459                 return;
460         if (p[0] < 1) {
461                 add_trace("calling_pn", "error", "IE too short (len=%d)", p[0]);
462                 return;
463         }
464
465         *type = (p[1]&0x70) >> 4;
466         *plan = p[1] & 0xf;
467         if (!(p[1] & 0x80)) {
468                 if (p[0] < 2) {
469                         add_trace("calling_pn", "error", "IE too short (len=%d)", p[0]);
470                         return;
471                 }
472                 *present = (p[2]&0x60) >> 5;
473                 *screen = p[2] & 0x3;
474                 strnncpy(number, p+3, p[0]-2, number_len);
475         } else {
476                 strnncpy(number, p+2, p[0]-1, number_len);
477         }
478
479         add_trace("calling_pn", "type", "%d", *type);
480         add_trace("calling_pn", "plan", "%d", *plan);
481         add_trace("calling_pn", "present", "%d", *present);
482         add_trace("calling_pn", "screen", "%d", *screen);
483         add_trace("calling_pn", "number", "%s", number);
484
485         /* second calling party number */
486         p = NULL;
487         i = 0;
488         while(i < numextra) {
489                 if (!l3m->extra[i].val)
490                         break;
491                 if (l3m->extra[i].ie == IE_CALLING_PN) {
492                         p = l3m->extra[i].val;
493                         break;
494                 }
495                 i++;
496         }
497         if (!p)
498                 return;
499         if (p[0] < 1) {
500                 add_trace("calling_pn2", "error", "IE too short (len=%d)", p[0]);
501                 return;
502         }
503
504         *type2 = (p[1]&0x70) >> 4;
505         *plan2 = p[1] & 0xf;
506         if (!(p[1] & 0x80)) {
507                 if (p[0] < 2) {
508                         add_trace("calling_pn2", "error", "IE too short (len=%d)", p[0]);
509                         return;
510                 }
511                 *present2 = (p[2]&0x60) >> 5;
512                 *screen2 = p[2] & 0x3;
513                 strnncpy(number2, p+3, p[0]-2, number_len2);
514         } else {
515                 strnncpy(number2, p+2, p[0]-1, number_len2);
516         }
517
518         add_trace("call_pn 2", "type", "%d", *type2);
519         add_trace("call_pn 2", "plan", "%d", *plan2);
520         add_trace("call_pn 2", "present", "%d", *present2);
521         add_trace("call_pn 2", "screen", "%d", *screen2);
522         add_trace("call_pn 2", "number", "%s", number2);
523 }
524
525
526 /* IE_CONNECTED_PN */
527 void Pdss1::enc_ie_connected_pn(struct l3_msg *l3m, int type, int plan, int present, int screen, unsigned char *number)
528 {
529         unsigned char p[256];
530         int l;
531
532         if (type<0 || type>7) {
533                 PERROR("type(%d) is out of range.\n", type);
534                 return;
535         }
536         if (plan<0 || plan>15) {
537                 PERROR("plan(%d) is out of range.\n", plan);
538                 return;
539         }
540         if (present>3) {
541                 PERROR("present(%d) is out of range.\n", present);
542                 return;
543         }
544         if (present >= 0) if (screen<0 || screen>3) {
545                 PERROR("screen(%d) is out of range.\n", screen);
546                 return;
547         }
548
549         add_trace("connect_pn", "type", "%d", type);
550         add_trace("connect_pn", "plan", "%d", plan);
551         add_trace("connect_pn", "present", "%d", present);
552         add_trace("connect_pn", "screen", "%d", screen);
553         add_trace("connect_pn", "number", "%s", number);
554
555         l = 1;
556         if (number) if (number[0])
557                 l += strlen((char *)number);
558         if (present >= 0)
559                 l += 1;
560         p[0] = IE_CONNECT_PN;
561         p[1] = l;
562         if (present >= 0) {
563                 p[2] = 0x00 + (type<<4) + plan;
564                 p[3] = 0x80 + (present<<5) + screen;
565                 if (number) if (number[0])
566                         UNCPY((char *)p+4, (char *)number, strlen((char *)number));
567         } else {
568                 p[2] = 0x80 + (type<<4) + plan;
569                 if (number) if (number[0])
570                         UNCPY((char *)p+3, (char *)number, strlen((char *)number));
571         }
572         add_layer3_ie(l3m, p[0], p[1], p+2);
573 }
574
575 void Pdss1::dec_ie_connected_pn(struct l3_msg *l3m, int *type, int *plan, int *present, int *screen, unsigned char *number, int number_len)
576 {
577         *type = -1;
578         *plan = -1;
579         *present = -1;
580         *screen = -1;
581         *number = '\0';
582
583         unsigned char *p = l3m->connected_nr;
584         if (!p)
585                 return;
586         if (p[0] < 1) {
587                 add_trace("connect_pn", "error", "IE too short (len=%d)", p[0]);
588                 return;
589         }
590
591         *type = (p[1]&0x70) >> 4;
592         *plan = p[1] & 0xf;
593         if (!(p[1] & 0x80)) {
594                 if (p[0] < 2) {
595                         add_trace("connect_pn", "error", "IE too short (len=%d)", p[0]);
596                         return;
597                 }
598                 *present = (p[2]&0x60) >> 5;
599                 *screen = p[2] & 0x3;
600                 strnncpy(number, p+3, p[0]-2, number_len);
601         } else {
602                 strnncpy(number, p+2, p[0]-1, number_len);
603         }
604
605         add_trace("connect_pn", "type", "%d", *type);
606         add_trace("connect_pn", "plan", "%d", *plan);
607         add_trace("connect_pn", "present", "%d", *present);
608         add_trace("connect_pn", "screen", "%d", *screen);
609         add_trace("connect_pn", "number", "%s", number);
610 }
611
612
613 /* IE_CAUSE */
614 void Pdss1::enc_ie_cause(struct l3_msg *l3m, int location, int cause)
615 {
616         unsigned char p[256];
617         int l;
618
619         if (location<0 || location>10) {
620                 PERROR("location(%d) is out of range.\n", location);
621                 return;
622         }
623         if (cause<0 || cause>127) {
624                 PERROR("cause(%d) is out of range.\n", cause);
625                 return;
626         }
627
628         add_trace("cause", "location", "%d", location);
629         add_trace("cause", "value", "%d", cause);
630
631         l = 2;
632         p[0] = IE_CAUSE;
633         p[1] = l;
634         p[2] = 0x80 + location;
635         p[3] = 0x80 + cause;
636         add_layer3_ie(l3m, p[0], p[1], p+2);
637 }
638 void enc_ie_cause_standalone(struct l3_msg *l3m, int location, int cause)
639 {
640         unsigned char p[256];
641         p[0] = IE_CAUSE;
642         p[1] = 2;
643         p[2] = 0x80 + location;
644         p[3] = 0x80 + cause;
645         add_layer3_ie(l3m, p[0], p[1], p+2);
646 }
647
648
649 void Pdss1::dec_ie_cause(struct l3_msg *l3m, int *location, int *cause)
650 {
651         *location = -1;
652         *cause = -1;
653
654         unsigned char *p = l3m->cause;
655         if (!p)
656                 return;
657         if (p[0] < 2) {
658                 add_trace("cause", "error", "IE too short (len=%d)", p[0]);
659                 return;
660         }
661
662         *location = p[1] & 0x0f;
663         *cause = p[2] & 0x7f;
664
665         add_trace("cause", "location", "%d", *location);
666         add_trace("cause", "value", "%d", *cause);
667 }
668
669
670 /* IE_CHANNEL_ID */
671 void Pdss1::enc_ie_channel_id(struct l3_msg *l3m, int exclusive, int channel)
672 {
673         unsigned char p[256];
674         int l;
675         int pri = p_m_mISDNport->pri;
676
677         if (exclusive<0 || exclusive>1) {
678                 PERROR("exclusive(%d) is out of range.\n", exclusive);
679                 return;
680         }
681         if ((channel<=0 && channel!=CHANNEL_NO && channel!=CHANNEL_ANY)
682          || (!pri && channel>2)
683          || (pri && channel>127)
684          || (pri && channel==16)) {
685                 PERROR("channel(%d) is out of range.\n", channel);
686                 return;
687         }
688
689         add_trace("channel_id", "exclusive", "%d", exclusive);
690         switch(channel) {
691                 case CHANNEL_ANY:
692                 add_trace("channel_id", "channel", "any channel");
693                 break;
694                 case CHANNEL_NO:
695                 add_trace("channel_id", "channel", "no channel");
696                 break;
697                 default:
698                 add_trace("channel_id", "channel", "%d", channel);
699         }
700
701         if (!pri) {
702                 /* BRI */
703                 l = 1;
704                 p[0] = IE_CHANNEL_ID;
705                 p[1] = l;
706                 if (channel == CHANNEL_NO)
707                         channel = 0;
708                 else if (channel == CHANNEL_ANY)
709                         channel = 3;
710                 p[2] = 0x80 + (exclusive<<3) + channel;
711                 add_layer3_ie(l3m, p[0], p[1], p+2);
712         } else {
713                 /* PRI */
714                 if (channel == CHANNEL_NO || channel == CHANNEL_ANY) {
715                         if (channel == CHANNEL_NO)
716                                 channel = 0;
717                         else
718                                 channel = 3;
719                         l = 1;
720                         p[0] = IE_CHANNEL_ID;
721                         p[1] = l;
722                         p[2] = 0x80 + 0x20 + channel;
723                         add_layer3_ie(l3m, p[0], p[1], p+2);
724                         return; /* end */
725                 }
726                 l = 3;
727                 p[0] = IE_CHANNEL_ID;
728                 p[1] = l;
729                 p[2] = 0x80 + 0x20 + (exclusive<<3) + 0x01;
730                 p[3] = 0x80 + 3; /* CCITT, Number, B-type */
731                 p[4] = 0x80 + channel;
732                 add_layer3_ie(l3m, p[0], p[1], p+2);
733         }
734 }
735
736 void Pdss1::dec_ie_channel_id(struct l3_msg *l3m, int *exclusive, int *channel)
737 {
738         int pri = p_m_mISDNport->pri;
739
740         *exclusive = -1;
741         *channel = -1;
742
743         unsigned char *p = l3m->channel_id;
744         if (!p)
745                 return;
746         if (p[0] < 1) {
747                 add_trace("channel_id", "error", "IE too short (len=%d)", p[0]);
748                 return;
749         }
750
751         if (p[1] & 0x40) {
752                 add_trace("channel_id", "error", "refering to channels of other interfaces is not supported");
753                 return;
754         }
755         if (p[1] & 0x04) {
756                 add_trace("channel_id", "error", "using d-channel is not supported");
757                 return;
758         }
759
760         *exclusive = (p[1]&0x08) >> 3;
761         if (!pri) {
762                 /* BRI */
763                 if (p[1] & 0x20) {
764                         add_trace("channel_id", "error", "extended channel ID with non PRI interface");
765                         return;
766                 }
767                 *channel = p[1] & 0x03;
768                 if (*channel == 3)
769                         *channel = CHANNEL_ANY;
770                 else if (*channel == 0)
771                         *channel = CHANNEL_NO;
772         } else {
773                 /* PRI */
774                 if (p[0] < 1) {
775
776                         add_trace("channel_id", "error", "IE too short for PRI (len=%d)", p[0]);
777                         return;
778                 }
779                 if (!(p[1] & 0x20)) {
780                         add_trace("channel_id", "error", "basic channel ID with PRI interface");
781                         return;
782                 }
783                 if ((p[1]&0x03) == 0x00) {
784                         /* no channel */
785                         *channel = CHANNEL_NO;
786                         return;
787                 }
788                 if ((p[1]&0x03) == 0x03) {
789                         /* any channel */
790                         *channel = CHANNEL_ANY;
791                         return;
792                 }
793                 if (p[0] < 3) {
794                         add_trace("channel_id", "error", "IE too short for PRI with channel (len=%d)", p[0]);
795                         return;
796                 }
797                 if (p[2] & 0x10) {
798                         add_trace("channel_id", "error", "channel map not supported");
799                         return;
800                 }
801                 *channel = p[3] & 0x7f;
802                 if ((*channel<1) || (*channel==16)) {
803                         add_trace("channel_id", "error", "PRI interface channel out of range (%d)", *channel);
804                         return;
805                 }
806         }
807
808         add_trace("channel_id", "exclusive", "%d", *exclusive);
809         switch(*channel) {
810                 case CHANNEL_ANY:
811                 add_trace("channel_id", "channel", "any channel");
812                 break;
813                 case CHANNEL_NO:
814                 add_trace("channel_id", "channel", "no channel");
815                 break;
816                 default:
817                 add_trace("channel_id", "channel", "%d", *channel);
818         }
819 }
820
821
822 /* IE_DATE */
823 void Pdss1::enc_ie_date(struct l3_msg *l3m, time_t ti, int no_seconds)
824 {
825         unsigned char p[256];
826         int l;
827
828         struct tm *tm;
829
830         tm = localtime(&ti);
831         if (!tm) {
832                 PERROR("localtime() returned NULL.\n");
833                 return;
834         }
835
836         add_trace("date", "day", "%d.%d.%d", tm->tm_mday, tm->tm_mon+1, tm->tm_year%100);
837         add_trace("date", "time", "%d:%d:%d", tm->tm_hour, tm->tm_min, tm->tm_sec);
838
839         l = 5 + (!no_seconds);
840         p[0] = IE_DATE;
841         p[1] = l;
842         p[2] = tm->tm_year % 100;
843         p[3] = tm->tm_mon + 1;
844         p[4] = tm->tm_mday;
845         p[5] = tm->tm_hour;
846         p[6] = tm->tm_min;
847         if (!no_seconds)
848                 p[7] = tm->tm_sec;
849         add_layer3_ie(l3m, p[0], p[1], p+2);
850 }
851
852
853 /* IE_DISPLAY */
854 void Pdss1::enc_ie_display(struct l3_msg *l3m, unsigned char *display)
855 {
856         unsigned char p[256];
857         int l;
858
859         if (!display[0]) {
860                 PERROR("display text not given.\n");
861                 return;
862         }
863
864         if (strlen((char *)display) > 80) {
865                 PERROR("display text too long (max 80 chars), cutting.\n");
866                 display[80] = '\0';
867         }
868
869         add_trace("display", NULL, "%s", display);
870
871         l = strlen((char *)display);
872         p[0] = IE_DISPLAY;
873         p[1] = l;
874         UNCPY((char *)p+2, (char *)display, strlen((char *)display));
875         add_layer3_ie(l3m, p[0], p[1], p+2);
876 }
877
878 void Pdss1::dec_ie_display(struct l3_msg *l3m, unsigned char *display, int display_len)
879 {
880         *display = '\0';
881
882         unsigned char *p = l3m->display;
883         if (!p)
884                 return;
885         if (p[0] < 1) {
886                 add_trace("display", "error", "IE too short (len=%d)", p[0]);
887                 return;
888         }
889
890         strnncpy(display, p+1, p[0], display_len);
891
892         add_trace("display", NULL, "%s", display);
893 }
894
895
896 /* IE_KEYPAD */
897 void Pdss1::enc_ie_keypad(struct l3_msg *l3m, unsigned char *keypad)
898 {
899         unsigned char p[256];
900         int l;
901
902         if (!keypad[0]) {
903                 PERROR("keypad info not given.\n");
904                 return;
905         }
906
907         add_trace("keypad", NULL, "%s", keypad);
908
909         l = strlen((char *)keypad);
910         p[0] = IE_KEYPAD;
911         p[1] = l;
912         UNCPY((char *)p+2, (char *)keypad, strlen((char *)keypad));
913         add_layer3_ie(l3m, p[0], p[1], p+2);
914 }
915
916 void Pdss1::dec_ie_keypad(struct l3_msg *l3m, unsigned char *keypad, int keypad_len)
917 {
918         *keypad = '\0';
919
920         unsigned char *p = l3m->keypad;
921         if (!p)
922                 return;
923         if (p[0] < 1) {
924                 add_trace("keypad", "error", "IE too short (len=%d)", p[0]);
925                 return;
926         }
927
928         strnncpy(keypad, p+1, p[0], keypad_len);
929
930         add_trace("keypad", NULL, "%s", keypad);
931 }
932
933
934 /* IE_NOTIFY */
935 void Pdss1::enc_ie_notify(struct l3_msg *l3m, int notify)
936 {
937         unsigned char p[256];
938         int l;
939
940         if (notify<0 || notify>0x7f) {
941                 PERROR("notify(%d) is out of range.\n", notify);
942                 return;
943         }
944
945         add_trace("notify", NULL, "%d", notify);
946
947         l = 1;
948         p[0] = IE_NOTIFY;
949         p[1] = l;
950         p[2] = 0x80 + notify;
951         add_layer3_ie(l3m, p[0], p[1], p+2);
952 }
953
954 void Pdss1::dec_ie_notify(struct l3_msg *l3m, int *notify)
955 {
956         *notify = -1;
957
958         unsigned char *p = l3m->notify;
959         if (!p)
960                 return;
961         if (p[0] < 1) {
962                 add_trace("notify", "error", "IE too short (len=%d)", p[0]);
963                 return;
964         }
965
966         *notify = p[1] & 0x7f;
967
968         add_trace("notify", NULL, "%d", *notify);
969 }
970
971
972 /* IE_PROGRESS */
973 void Pdss1::enc_ie_progress(struct l3_msg *l3m, int coding, int location, int progress)
974 {
975         unsigned char p[256];
976         int l;
977
978         if (coding<0 || coding>0x03) {
979                 PERROR("coding(%d) is out of range.\n", coding);
980                 return;
981         }
982         if (location<0 || location>0x0f) {
983                 PERROR("location(%d) is out of range.\n", location);
984                 return;
985         }
986         if (progress<0 || progress>0x7f) {
987                 PERROR("progress(%d) is out of range.\n", progress);
988                 return;
989         }
990
991         add_trace("progress", "codeing", "%d", coding);
992         add_trace("progress", "location", "%d", location);
993         add_trace("progress", "indicator", "%d", progress);
994
995         l = 2;
996         p[0] = IE_PROGRESS;
997         p[1] = l;
998         p[2] = 0x80 + (coding<<5) + location;
999         p[3] = 0x80 + progress;
1000         add_layer3_ie(l3m, p[0], p[1], p+2);
1001 }
1002
1003 void Pdss1::dec_ie_progress(struct l3_msg *l3m, int *coding, int *location, int *progress)
1004 {
1005         *coding = -1;
1006         *location = -1;
1007         *progress = -1;
1008
1009         unsigned char *p = l3m->progress;
1010         if (!p)
1011                 return;
1012         if (p[0] < 1) {
1013                 add_trace("progress", "error", "IE too short (len=%d)", p[0]);
1014                 return;
1015         }
1016
1017         *coding = (p[1]&0x60) >> 5;
1018         *location = p[1] & 0x0f;
1019         *progress = p[2] & 0x7f;
1020
1021         add_trace("progress", "codeing", "%d", *coding);
1022         add_trace("progress", "location", "%d", *location);
1023         add_trace("progress", "indicator", "%d", *progress);
1024 }
1025
1026
1027 /* IE_REDIR_NR (redirecting = during MT_SETUP) */
1028 void Pdss1::enc_ie_redir_nr(struct l3_msg *l3m, int type, int plan, int present, int screen, int reason, unsigned char *number)
1029 {
1030         unsigned char p[256];
1031         int l;
1032
1033         if (type<0 || type>7) {
1034                 PERROR("type(%d) is out of range.\n", type);
1035                 return;
1036         }
1037         if (plan<0 || plan>15) {
1038                 PERROR("plan(%d) is out of range.\n", plan);
1039                 return;
1040         }
1041         if (present > 3) {
1042                 PERROR("present(%d) is out of range.\n", present);
1043                 return;
1044         }
1045         if (present >= 0) if (screen<0 || screen>3) {
1046                 PERROR("screen(%d) is out of range.\n", screen);
1047                 return;
1048         }
1049         if (reason > 0x0f) {
1050                 PERROR("reason(%d) is out of range.\n", reason);
1051                 return;
1052         }
1053
1054         add_trace("redir'ing", "type", "%d", type);
1055         add_trace("redir'ing", "plan", "%d", plan);
1056         add_trace("redir'ing", "present", "%d", present);
1057         add_trace("redir'ing", "screen", "%d", screen);
1058         add_trace("redir'ing", "reason", "%d", reason);
1059         add_trace("redir'ing", "number", "%s", number);
1060
1061         l = 1;
1062         if (number)
1063                 l += strlen((char *)number);
1064         if (present >= 0) {
1065                 l += 1;
1066                 if (reason >= 0)
1067                         l += 1;
1068         }
1069         p[0] = IE_REDIR_NR;
1070         p[1] = l;
1071         if (present >= 0) {
1072                 if (reason >= 0) {
1073                         p[2] = 0x00 + (type<<4) + plan;
1074                         p[3] = 0x00 + (present<<5) + screen;
1075                         p[4] = 0x80 + reason;
1076                         if (number)
1077                                 UNCPY((char *)p+5, (char *)number, strlen((char *)number));
1078                 } else {
1079                         p[2] = 0x00 + (type<<4) + plan;
1080                         p[3] = 0x80 + (present<<5) + screen;
1081                         if (number)
1082                                 UNCPY((char *)p+4, (char *)number, strlen((char *)number));
1083                 }
1084         } else {
1085                 p[2] = 0x80 + (type<<4) + plan;
1086                 if (number) if (number[0])
1087                         UNCPY((char *)p+3, (char *)number, strlen((char *)number));
1088         }
1089         add_layer3_ie(l3m, p[0], p[1], p+2);
1090 }
1091
1092 void Pdss1::dec_ie_redir_nr(struct l3_msg *l3m, int *type, int *plan, int *present, int *screen, int *reason, unsigned char *number, int number_len)
1093 {
1094         *type = -1;
1095         *plan = -1;
1096         *present = -1;
1097         *screen = -1;
1098         *reason = -1;
1099         *number = '\0';
1100
1101         unsigned char *p = l3m->redirecting_nr;
1102         if (!p)
1103                 return;
1104         if (p[0] < 1) {
1105                 add_trace("redir'ing", "error", "IE too short (len=%d)", p[0]);
1106                 return;
1107         }
1108
1109         *type = (p[1]&0x70) >> 4;
1110         *plan = p[1] & 0xf;
1111         if (!(p[1] & 0x80)) {
1112                 *present = (p[2]&0x60) >> 5;
1113                 *screen = p[2] & 0x3;
1114                 if (!(p[2] & 0x80)) {
1115                         *reason = p[3] & 0x0f;
1116                         strnncpy(number, p+4, p[0]-3, number_len);
1117                 } else {
1118                         strnncpy(number, p+3, p[0]-2, number_len);
1119                 }
1120         } else {
1121                 strnncpy(number, p+2, p[0]-1, number_len);
1122         }
1123
1124         add_trace("redir'ing", "type", "%d", *type);
1125         add_trace("redir'ing", "plan", "%d", *plan);
1126         add_trace("redir'ing", "present", "%d", *present);
1127         add_trace("redir'ing", "screen", "%d", *screen);
1128         add_trace("redir'ing", "reason", "%d", *reason);
1129         add_trace("redir'ing", "number", "%s", number);
1130 }
1131
1132
1133 /* IE_REDIR_DN (redirection = during MT_NOTIFY) */
1134 void Pdss1::enc_ie_redir_dn(struct l3_msg *l3m, int type, int plan, int present, unsigned char *number)
1135 {
1136         unsigned char p[256];
1137         int l;
1138
1139         if (type<0 || type>7) {
1140                 PERROR("type(%d) is out of range.\n", type);
1141                 return;
1142         }
1143         if (plan<0 || plan>15) {
1144                 PERROR("plan(%d) is out of range.\n", plan);
1145                 return;
1146         }
1147         if (present > 3) {
1148                 PERROR("present(%d) is out of range.\n", present);
1149                 return;
1150         }
1151
1152         add_trace("redir'tion", "type", "%d", type);
1153         add_trace("redir'tion", "plan", "%d", plan);
1154         add_trace("redir'tion", "present", "%d", present);
1155         add_trace("redir'tion", "number", "%s", number);
1156
1157         l = 1;
1158         if (number)
1159                 l += strlen((char *)number);
1160         if (present >= 0)
1161                 l += 1;
1162         p[0] = IE_REDIR_DN;
1163         p[1] = l;
1164         if (present >= 0) {
1165                 p[2] = 0x00 + (type<<4) + plan;
1166                 p[3] = 0x80 + (present<<5);
1167                 if (number)
1168                         UNCPY((char *)p+4, (char *)number, strlen((char *)number));
1169         } else {
1170                 p[2] = 0x80 + (type<<4) + plan;
1171                 if (number)
1172                         UNCPY((char *)p+3, (char *)number, strlen((char *)number));
1173         }
1174         add_layer3_ie(l3m, p[0], p[1], p+2);
1175 }
1176
1177 void Pdss1::dec_ie_redir_dn(struct l3_msg *l3m, int *type, int *plan, int *present, unsigned char *number, int number_len)
1178 {
1179         *type = -1;
1180         *plan = -1;
1181         *present = -1;
1182         *number = '\0';
1183
1184         unsigned char *p = l3m->redirection_nr;
1185         if (!p)
1186                 return;
1187         if (p[0] < 1) {
1188                 add_trace("redir'tion", "error", "IE too short (len=%d)", p[0]);
1189                 return;
1190         }
1191
1192         *type = (p[1]&0x70) >> 4;
1193         *plan = p[1] & 0xf;
1194         if (!(p[1] & 0x80)) {
1195                 *present = (p[2]&0x60) >> 5;
1196                 strnncpy(number, p+3, p[0]-2, number_len);
1197         } else {
1198                 strnncpy(number, p+2, p[0]-1, number_len);
1199         }
1200
1201         add_trace("redir'tion", "type", "%d", *type);
1202         add_trace("redir'tion", "plan", "%d", *plan);
1203         add_trace("redir'tion", "present", "%d", *present);
1204         add_trace("redir'tion", "number", "%s", number);
1205 }
1206
1207
1208 /* IE_FACILITY */
1209 void Pdss1::enc_ie_facility(struct l3_msg *l3m, unsigned char *facility, int facility_len)
1210 {
1211         unsigned char p[256];
1212         int l;
1213
1214         char buffer[768];
1215         int i;
1216
1217         if (!facility || facility_len<=0) {
1218                 return;
1219         }
1220
1221         i = 0;
1222         while(i < facility_len) {
1223                 UPRINT(buffer+(i*3), " %02x", facility[i]);
1224                 i++;
1225         }
1226                 
1227         add_trace("facility", NULL, "%s", buffer+1);
1228
1229         l = facility_len;
1230         p[0] = IE_FACILITY;
1231         p[1] = l;
1232         memcpy(p+2, facility, facility_len);
1233         add_layer3_ie(l3m, p[0], p[1], p+2);
1234 }
1235
1236 void Pdss1::dec_ie_facility(struct l3_msg *l3m, unsigned char *facility, int *facility_len)
1237 {
1238         char debug[768];
1239         int i;
1240
1241         *facility_len = 0;
1242
1243         unsigned char *p = l3m->facility;
1244         if (!p)
1245                 return;
1246
1247         *facility_len = p[0];
1248         memcpy(facility, p+1, *facility_len);
1249
1250         i = 0;
1251         while(i < *facility_len) {
1252                 UPRINT(debug+(i*3), " %02x", facility[i]);
1253                 i++;
1254         }
1255         debug[i*3] = '\0';
1256                 
1257         add_trace("facility", NULL, "%s", debug[0]?debug+1:"<none>");
1258 }
1259
1260
1261 void Pdss1::dec_facility_centrex(struct l3_msg *l3m, unsigned char *cnip, int cnip_len)
1262 {
1263         unsigned char centrex[256];
1264         char debug[768];
1265         int facility_len = 0;
1266         int i = 0, j;
1267         *cnip = '\0';
1268
1269         dec_ie_facility(l3m, centrex, &facility_len);
1270         if (facility_len >= 2) {
1271                 if (centrex[i++] != CENTREX_FAC)
1272                         return;
1273                 if (centrex[i++] != CENTREX_ID)
1274                         return;
1275         }
1276
1277         /* loop sub IEs of facility */
1278         while(facility_len > i+1) {
1279                 if (centrex[i+1]+i+1 > facility_len) {
1280                         PERROR("short read of centrex facility.\n");
1281                         return;
1282                 }
1283                 switch(centrex[i]) {
1284                         case 0x80:
1285                         strnncpy(cnip, &centrex[i+2], centrex[i+1], cnip_len);
1286                         add_trace("facility", "cnip", "%s", cnip);
1287                         break;
1288
1289                         default:
1290                         j = 0;
1291                         while(j < centrex[i+1]) {
1292                                 UPRINT(debug+(j*3), " %02x", centrex[i+1+j]);
1293                                 i++;
1294                         }
1295                         add_trace("facility", "CENTREX", "unknown=0x%02x len=%d%s\n", centrex[i], centrex[i+1], debug);
1296                 }
1297                 i += 1+centrex[i+1];
1298         }
1299 }
1300
1301
1302 /* IE_USERUSER */
1303 void Pdss1::enc_ie_useruser(struct l3_msg *l3m, int protocol, unsigned char *user, int user_len)
1304 {
1305         unsigned char p[256];
1306         int l;
1307
1308         char buffer[768];
1309         int i;
1310
1311         if (protocol<0 || protocol>127) {
1312                 PERROR("protocol(%d) is out of range.\n", protocol);
1313                 return;
1314         }
1315         if (!user || user_len<=0) {
1316                 return;
1317         }
1318
1319         i = 0;
1320         while(i < user_len) {
1321                 UPRINT(buffer+(i*3), " %02x", user[i]);
1322                 i++;
1323         }
1324                 
1325         add_trace("useruser", "protocol", "%d", protocol);
1326         add_trace("useruser", "value", "%s", buffer);
1327
1328         l = user_len;
1329         p[0] = IE_USER_USER;
1330         p[1] = l;
1331         p[2] = 0x80 + protocol;
1332         memcpy(p+3, user, user_len);
1333         add_layer3_ie(l3m, p[0], p[1], p+2);
1334 }
1335
1336 void Pdss1::dec_ie_useruser(struct l3_msg *l3m, int *protocol, unsigned char *user, int *user_len)
1337 {
1338         char buffer[768];
1339         int i;
1340
1341         *user_len = 0;
1342         *protocol = -1;
1343
1344         unsigned char *p = l3m->useruser;
1345         if (!p)
1346                 return;
1347
1348         *user_len = p[0]-1;
1349         if (p[0] < 1)
1350                 return;
1351         *protocol = p[1];
1352         memcpy(user, p+2, (*user_len<=128)?*(user_len):128); /* clip to 128 maximum */
1353
1354         i = 0;
1355         while(i < *user_len) {
1356                 UPRINT(buffer+(i*3), " %02x", user[i]);
1357                 i++;
1358         }
1359         buffer[i*3] = '\0';
1360                 
1361         add_trace("useruser", "protocol", "%d", *protocol);
1362         add_trace("useruser", "value", "%s", buffer);
1363 }
1364
1365