?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rcng - add rcng script to fixup kern.bootfile
[dragonfly.git] / usr.sbin / i4b / isdndecode / facility.c
blob5ae2ab8ed53d9aba8187badcb947e6363d950319
1 /*
2 * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 *
25 *---------------------------------------------------------------------------
26 *
27 * facility.c - decode Q.932 facilities
28 * ------------------------------------
29 *
30 * $Id: facility.c,v 1.5 2000/02/21 15:17:17 hm Exp $
31 *
32 * $FreeBSD: src/usr.sbin/i4b/isdndecode/facility.c,v 1.6.2.1 2001/08/01 17:45:05 obrien Exp $
33 * $DragonFly: src/usr.sbin/i4b/isdndecode/facility.c,v 1.3 2005/11/25 00:58:52 swildner Exp $
34 *
35 * last edit-date: [Mon Feb 21 16:15:43 2000]
36 *
37 *---------------------------------------------------------------------------
38 *
39 * - Q.932 (03/93) Generic Procedures for the Control of
40 * ISDN Supplementaty Services
41 * - Q.950 (03/93) Supplementary Services Protocols, Structure and
42 * General Principles
43 * - ETS 300 179 (10/92) Advice Of Charge: charging information during
44 * the call (AOC-D) supplementary service Service description
45 * - ETS 300 180 (10/92) Advice Of Charge: charging information at the
46 * end of call (AOC-E) supplementary service Service description
47 * - ETS 300 181 (04/93) Advice Of Charge (AOC) supplementary service
48 * Functional capabilities and information flows
49 * - ETS 300 182 (04/93) Advice Of Charge (AOC) supplementary service
50 * Digital Subscriber Signalling System No. one (DSS1) protocol
51 * - X.208 Specification of Abstract Syntax Notation One (ASN.1)
52 * - X.209 Specification of Basic Encoding Rules for
53 * Abstract Syntax Notation One (ASN.1)
54 * - "ASN.1 Abstract Syntax Notation One", Walter Gora, DATACOM-Verlag
55 * 1992, 3rd Edition (ISBN 3-89238-062-7) (german !)
56 *
57 *---------------------------------------------------------------------------*/
58
59 #include "decode.h"
60 #include "facility.h"
61
62 static int do_component(int length, char *pbuf);
63 static char *uni_str(int code);
64 static char *opval_str(int val);
65 static char *bid_str(int val);
66 static void next_state(char *pbuf, int class, int form, int code, int val);
67
68 static int byte_len;
69 static unsigned char *byte_buf;
70 static int state;
71
72 /*---------------------------------------------------------------------------*
73 * decode Q.931/Q.932 facility info element
74 *---------------------------------------------------------------------------*/
75 int
76 q932_facility(char *pbuf, unsigned char *buf)
77 {
78 int len;
79
80 sprintf((pbuf+strlen(pbuf)), "[facility (Q.932): ");
81
82 buf++; /* length */
83
84 len = *buf;
85
86 buf++; /* protocol profile */
87
88 sprintf((pbuf+strlen(pbuf)), "Protocol=");
89
90 switch(*buf & 0x1f)
91 {
92 case FAC_PROTO_ROP:
93 sprintf((pbuf+strlen(pbuf)), "Remote Operations Protocol\n");
94 break;
95
96 case FAC_PROTO_CMIP:
97 sprintf((pbuf+strlen(pbuf)), "CMIP Protocol (Q.941), UNSUPPORTED!\n");
98 return(len+2);
99 break;
100
101 case FAC_PROTO_ACSE:
102 sprintf((pbuf+strlen(pbuf)), "ACSE Protocol (X.217/X.227), UNSUPPORTED!\n");
103 return(len+2);
104 break;
105
106 default:
107 sprintf((pbuf+strlen(pbuf)), "Unknown Protocol (val = 0x%x), UNSUPPORTED!\n", *buf & 0x1f);
108 return(len+2);
109 break;
110 }
111
112 /* next byte */
113
114 buf++;
115 len--;
116
117 /* initialize variables for do_component */
118
119 byte_len = 0;
120 byte_buf = buf;
121 state = ST_EXP_COMP_TYP;
122
123 /* decode facility */
124
125 do_component(len, pbuf);
126
127 sprintf((pbuf+(strlen(pbuf)-1)), "]"); /* XXX replace last newline */
128
129 return(len+3);
130 }
131
132 /*---------------------------------------------------------------------------*
133 * handle a component recursively
134 *---------------------------------------------------------------------------*/
135 static int
136 do_component(int length, char *pbuf)
137 {
138 int comp_tag_class; /* component tag class */
139 int comp_tag_form; /* component form: constructor or primitive */
140 int comp_tag_code; /* component code depending on class */
141 int comp_length = 0; /* component length */
142
143 #ifdef FAC_DEBUG
144 sprintf((pbuf+strlen(pbuf)), "ENTER - comp_length = %d, byte_len = %d, length =%d\n", comp_length, byte_len, length);
145 #endif
146
147 again:
148
149 #ifdef FAC_DEBUG
150 sprintf((pbuf+strlen(pbuf)), "AGAIN - comp_length = %d, byte_len = %d, length =%d\n", comp_length, byte_len, length);
151 #endif
152
153 /*----------------------------------------*/
154 /* first component element: component tag */
155 /*----------------------------------------*/
156
157 /* tag class bits */
158
159 sprintf((pbuf+strlen(pbuf)), "\t0x%02x Tag: ", *byte_buf);
160
161 comp_tag_class = (*byte_buf & 0xc0) >> 6;
162
163 switch(comp_tag_class)
164 {
165 case FAC_TAGCLASS_UNI:
166 sprintf((pbuf+strlen(pbuf)), "Universal");
167 break;
168 case FAC_TAGCLASS_APW:
169 sprintf((pbuf+strlen(pbuf)), "Applic-wide");
170 break;
171 case FAC_TAGCLASS_COS:
172 sprintf((pbuf+strlen(pbuf)), "Context-spec");
173 break;
174 case FAC_TAGCLASS_PRU:
175 sprintf((pbuf+strlen(pbuf)), "Private");
176 break;
177 }
178
179 /* tag form bit */
180
181 comp_tag_form = (*byte_buf & 0x20) > 5;
182
183 sprintf((pbuf+strlen(pbuf)), ", ");
184
185 if(comp_tag_form == FAC_TAGFORM_CON)
186 {
187 sprintf((pbuf+strlen(pbuf)), "Constructor");
188 }
189 else
190 {
191 sprintf((pbuf+strlen(pbuf)), "Primitive");
192 }
193
194 /* tag code bits */
195
196 comp_tag_code = *byte_buf & 0x1f;
197
198 sprintf((pbuf+strlen(pbuf)), ", ");
199
200 if(comp_tag_code == 0x1f)
201 {
202 comp_tag_code = 0;
203
204 byte_buf++;
205 byte_len++;
206
207 while(*byte_buf & 0x80)
208 {
209 comp_tag_code += (*byte_buf & 0x7f);
210 byte_buf++;
211 byte_len++;
212 }
213 comp_tag_code += (*byte_buf & 0x7f);
214 sprintf((pbuf+strlen(pbuf)), "%d (ext)\n", comp_tag_code);
215 }
216 else
217 {
218 comp_tag_code = (*byte_buf & 0x1f);
219
220 if(comp_tag_class == FAC_TAGCLASS_UNI)
221 {
222 sprintf((pbuf+strlen(pbuf)), "%s (%d)\n", uni_str(comp_tag_code), comp_tag_code);
223 }
224 else
225 {
226 sprintf((pbuf+strlen(pbuf)), "code = %d\n", comp_tag_code);
227 }
228 }
229
230 byte_buf++;
231 byte_len++;
232
233 /*--------------------------------------------*/
234 /* second component element: component length */
235 /*--------------------------------------------*/
236
237 sprintf((pbuf+strlen(pbuf)), "\t0x%02x Len: ", *byte_buf);
238
239 comp_length = 0;
240
241 if(*byte_buf & 0x80)
242 {
243 int i = *byte_buf & 0x7f;
244
245 byte_len += i;
246
247 for(;i > 0;i++)
248 {
249 byte_buf++;
250 comp_length += (*byte_buf * (i*256));
251 }
252 sprintf((pbuf+strlen(pbuf)), "%d (long form)\n", comp_length);
253 }
254 else
255 {
256 comp_length = *byte_buf & 0x7f;
257 sprintf((pbuf+strlen(pbuf)), "%d (short form)\n", comp_length);
258 }
259
260 next_state(pbuf, comp_tag_class, comp_tag_form, comp_tag_code, -1);
261
262 byte_len++;
263 byte_buf++;
264
265 if(comp_length)
266 {
267
268 /*---------------------------------------------*/
269 /* third component element: component contents */
270 /*---------------------------------------------*/
271
272 if(comp_tag_form) /* == constructor */
273 {
274 do_component(comp_length, pbuf);
275 }
276 else
277 {
278 int val = 0;
279 if(comp_tag_class == FAC_TAGCLASS_UNI)
280 {
281 switch(comp_tag_code)
282 {
283 case FAC_CODEUNI_INT:
284 case FAC_CODEUNI_ENUM:
285 case FAC_CODEUNI_BOOL:
286 if(comp_length)
287 {
288 int i;
289
290 sprintf((pbuf+strlen(pbuf)), "\t");
291
292 for(i = comp_length-1; i >= 0; i--)
293 {
294 sprintf((pbuf+strlen(pbuf)), "0x%02x ", *byte_buf);
295 val += (*byte_buf + (i*255));
296 byte_buf++;
297 byte_len++;
298 if(i)
299 sprintf((pbuf+strlen(pbuf)), "\n\t");
300 }
301 sprintf((pbuf+strlen(pbuf)), "Val: %d\n", val);
302 }
303 break;
304 default:
305 if(comp_length)
306 {
307 int i;
308
309 sprintf((pbuf+strlen(pbuf)), "\t");
310
311 for(i = comp_length-1; i >= 0; i--)
312 {
313 sprintf((pbuf+strlen(pbuf)), "0x%02x = %d", *byte_buf, *byte_buf);
314 if(isprint(*byte_buf))
315 sprintf((pbuf+strlen(pbuf)), " = '%c'", *byte_buf);
316 byte_buf++;
317 byte_len++;
318 if(i)
319 sprintf((pbuf+strlen(pbuf)), "\n\t");
320 }
321 }
322 break;
323 }
324 }
325
326 else /* comp_tag_class != FAC_TAGCLASS_UNI */
327 {
328 if(comp_length)
329 {
330 int i;
331
332 sprintf((pbuf+strlen(pbuf)), "\t");
333
334 for(i = comp_length-1; i >= 0; i--)
335 {
336 sprintf((pbuf+strlen(pbuf)), "0x%02x", *byte_buf);
337 val += (*byte_buf + (i*255));
338 byte_buf++;
339 byte_len++;
340 if(i)
341 sprintf((pbuf+strlen(pbuf)), "\n\t");
342 }
343 sprintf((pbuf+strlen(pbuf)), "\n");
344 }
345 }
346 next_state(pbuf, comp_tag_class, comp_tag_form, comp_tag_code, val);
347 }
348 }
349
350 #ifdef FAC_DEBUG
351 sprintf((pbuf+strlen(pbuf)), "PREGOTO - comp_length = %d, byte_len = %d, length =%d\n", comp_length, byte_len, length);
352 #endif
353 if(byte_len < length)
354 goto again;
355 #ifdef FAC_DEBUG
356 sprintf((pbuf+strlen(pbuf)), "RETURN - comp_length = %d, byte_len = %d, length =%d\n", comp_length, byte_len, length);
357 #endif
358 return(byte_len);
359 }
360
361 /*---------------------------------------------------------------------------*
362 * print universal id type
363 *---------------------------------------------------------------------------*/
364 static char *
365 uni_str(int code)
366 {
367 static char *tbl[] = {
368 "BOOLEAN",
369 "INTEGER",
370 "BIT STRING",
371 "OCTET STRING",
372 "NULL",
373 "OBJECT IDENTIFIER",
374 "OBJECT DESCRIPTOR",
375 "EXTERNAL",
376 "REAL",
377 "ENUMERATED",
378 "RESERVED11",
379 "RESERVED12",
380 "RESERVED13",
381 "RESERVED14",
382 "RESERVED15",
383 "SEQUENCE",
384 "SET",
385 "NUMERIC STRING",
386 "PRINTABLE STRING",
387 "TELETEX STRING",
388 "ISO646 STRING",
389 "IA5 STRING",
390 "GRAPHIC STRING",
391 "GENERAL STRING"
392 };
393
394 if(code >= 1 && code <= FAC_CODEUNI_GNSTR)
395 return(tbl[code-1]);
396 else
397 return("ERROR, Value out of Range!");
398 }
399
400 /*---------------------------------------------------------------------------*
401 * print operation value
402 *---------------------------------------------------------------------------*/
403 static char *
404 opval_str(int val)
405 {
406 static char buffer[80];
407 char *r;
408
409 switch(val)
410 {
411 case FAC_OPVAL_UUS:
412 r = "uUs";
413 break;
414 case FAC_OPVAL_CUG:
415 r = "cUGCall";
416 break;
417 case FAC_OPVAL_MCID:
418 r = "mCIDRequest";
419 break;
420 case FAC_OPVAL_BTPY:
421 r = "beginTPY";
422 break;
423 case FAC_OPVAL_ETPY:
424 r = "endTPY";
425 break;
426 case FAC_OPVAL_ECT:
427 r = "eCTRequest";
428 break;
429 case FAC_OPVAL_DIV_ACT:
430 r = "activationDiversion";
431 break;
432 case FAC_OPVAL_DIV_DEACT:
433 r = "deactivationDiversion";
434 break;
435 case FAC_OPVAL_DIV_ACTSN:
436 r = "activationStatusNotificationDiv";
437 break;
438 case FAC_OPVAL_DIV_DEACTSN:
439 r = "deactivationStatusNotificationDiv";
440 break;
441 case FAC_OPVAL_DIV_INTER:
442 r = "interrogationDiversion";
443 break;
444 case FAC_OPVAL_DIV_INFO:
445 r = "diversionInformation";
446 break;
447 case FAC_OPVAL_DIV_CALLDEF:
448 r = "callDeflection";
449 break;
450 case FAC_OPVAL_DIV_CALLRER:
451 r = "callRerouting";
452 break;
453 case FAC_OPVAL_DIV_LINF2:
454 r = "divertingLegInformation2";
455 break;
456 case FAC_OPVAL_DIV_INVS:
457 r = "invokeStatus";
458 break;
459 case FAC_OPVAL_DIV_INTER1:
460 r = "interrogationDiversion1";
461 break;
462 case FAC_OPVAL_DIV_LINF1:
463 r = "divertingLegInformation1";
464 break;
465 case FAC_OPVAL_DIV_LINF3:
466 r = "divertingLegInformation3";
467 break;
468 case FAC_OPVAL_ER_CRCO:
469 r = "explicitReservationCreationControl";
470 break;
471 case FAC_OPVAL_ER_MGMT:
472 r = "explicitReservationManagement";
473 break;
474 case FAC_OPVAL_ER_CANC:
475 r = "explicitReservationCancel";
476 break;
477 case FAC_OPVAL_MLPP_QUERY:
478 r = "mLPP lfb Query";
479 break;
480 case FAC_OPVAL_MLPP_CALLR:
481 r = "mLPP Call Request";
482 break;
483 case FAC_OPVAL_MLPP_CALLP:
484 r = "mLPP Call Preemption";
485 break;
486 case FAC_OPVAL_AOC_REQ:
487 r = "chargingRequest";
488 break;
489 case FAC_OPVAL_AOC_S_CUR:
490 r = "aOCSCurrency";
491 break;
492 case FAC_OPVAL_AOC_S_SPC:
493 r = "aOCSSpecialArrangement";
494 break;
495 case FAC_OPVAL_AOC_D_CUR:
496 r = "aOCDCurrency";
497 break;
498 case FAC_OPVAL_AOC_D_UNIT:
499 r = "aOCDChargingUnit";
500 break;
501 case FAC_OPVAL_AOC_E_CUR:
502 r = "aOCECurrency";
503 break;
504 case FAC_OPVAL_AOC_E_UNIT:
505 r = "aOCEChargingUnit";
506 break;
507 case FAC_OPVAL_AOC_IDOFCRG:
508 r = "identificationOfCharge";
509 break;
510 case FAC_OPVAL_CONF_BEG:
511 r = "beginConf";
512 break;
513 case FAC_OPVAL_CONF_ADD:
514 r = "addConf";
515 break;
516 case FAC_OPVAL_CONF_SPLIT:
517 r = "splitConf";
518 break;
519 case FAC_OPVAL_CONF_DROP:
520 r = "dropConf";
521 break;
522 case FAC_OPVAL_CONF_ISOLATE:
523 r = "isolateConf";
524 break;
525 case FAC_OPVAL_CONF_REATT:
526 r = "reattachConf";
527 break;
528 case FAC_OPVAL_CONF_PDISC:
529 r = "partyDISC";
530 break;
531 case FAC_OPVAL_CONF_FCONF:
532 r = "floatConf";
533 break;
534 case FAC_OPVAL_CONF_END:
535 r = "endConf";
536 break;
537 case FAC_OPVAL_CONF_IDCFE:
538 r = "indentifyConferee";
539 break;
540 case FAC_OPVAL_REVC_REQ:
541 r = "requestREV";
542 break;
543 default:
544 sprintf(buffer, "unknown operation value %d!", val);
545 r = buffer;
546 }
547 return(r);
548 }
549
550 /*---------------------------------------------------------------------------*
551 * billing id string
552 *---------------------------------------------------------------------------*/
553 static char *
554 bid_str(int val)
555 {
556 static char buffer[80];
557 char *r;
558
559 switch(val)
560 {
561 case 0:
562 r = "normalCharging";
563 break;
564 case 1:
565 r = "reverseCharging";
566 break;
567 case 2:
568 r = "creditCardCharging";
569 break;
570 case 3:
571 r = "callForwardingUnconditional";
572 break;
573 case 4:
574 r = "callForwardingBusy";
575 break;
576 case 5:
577 r = "callForwardingNoReply";
578 break;
579 case 6:
580 r = "callDeflection";
581 break;
582 case 7:
583 r = "callTransfer";
584 break;
585 default:
586 sprintf(buffer, "unknown billing-id value %d!", val);
587 r = buffer;
588 }
589 return(r);
590 }
591
592 /*---------------------------------------------------------------------------*
593 * invoke component
594 *---------------------------------------------------------------------------*/
595 static void
596 F_1_1(char *pbuf, int val)
597 {
598 #ifdef ST_DEBUG
599 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_1_1, val = %d\n", val);
600 #endif
601 if(val == -1)
602 {
603 sprintf((pbuf+strlen(pbuf)), "\t invokeComponent\n");
604 state = ST_EXP_INV_ID;
605 }
606 }
607
608 /*---------------------------------------------------------------------------*
609 * return result
610 *---------------------------------------------------------------------------*/
611 static void
612 F_1_2(char *pbuf, int val)
613 {
614 #ifdef ST_DEBUG
615 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_1_2, val = %d\n", val);
616 #endif
617 if(val == -1)
618 {
619 sprintf((pbuf+strlen(pbuf)), "\t returnResult\n");
620 state = ST_EXP_RR_INV_ID;
621 }
622 }
623 /*---------------------------------------------------------------------------*
624 * return error
625 *---------------------------------------------------------------------------*/
626 static void
627 F_1_3(char *pbuf, int val)
628 {
629 #ifdef ST_DEBUG
630 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_1_3, val = %d\n", val);
631 #endif
632 if(val == -1)
633 {
634 sprintf((pbuf+strlen(pbuf)), "\t returnError\n");
635 state = ST_EXP_NIX;
636 }
637 }
638 /*---------------------------------------------------------------------------*
639 * reject
640 *---------------------------------------------------------------------------*/
641 static void
642 F_1_4(char *pbuf, int val)
643 {
644 #ifdef ST_DEBUG
645 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_1_4, val = %d\n", val);
646 #endif
647 if(val == -1)
648 {
649 sprintf((pbuf+strlen(pbuf)), "\t reject\n");
650 state = ST_EXP_REJ_INV_ID;
651 }
652 }
653
654 /*---------------------------------------------------------------------------*
655 * return result: invoke id
656 *---------------------------------------------------------------------------*/
657 static void
658 F_RJ2(char *pbuf, int val)
659 {
660 #ifdef ST_DEBUG
661 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RJ2, val = %d\n", val);
662 #endif
663 if(val != -1)
664 {
665 sprintf((pbuf+strlen(pbuf)), "\t InvokeIdentifier = %d\n", val);
666 state = ST_EXP_REJ_OP_VAL;
667 }
668 }
669
670 /*---------------------------------------------------------------------------*
671 * reject, general problem
672 *---------------------------------------------------------------------------*/
673 static void
674 F_RJ30(char *pbuf, int val)
675 {
676 #ifdef ST_DEBUG
677 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RJ30, val = %d\n", val);
678 #endif
679 if(val == -1)
680 {
681 sprintf((pbuf+strlen(pbuf)), "\t General problem\n");
682 }
683 else
684 {
685 switch(val)
686 {
687 case 0:
688 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized component\n");
689 break;
690 case 1:
691 sprintf((pbuf+strlen(pbuf)), "\t problem = mistyped component\n");
692 break;
693 case 2:
694 sprintf((pbuf+strlen(pbuf)), "\t problem = badly structured component\n");
695 break;
696 default:
697 sprintf((pbuf+strlen(pbuf)), "\t problem = unknown problem code 0x%x\n", val);
698 break;
699 }
700 state = ST_EXP_NIX;
701 }
702 }
703
704 /*---------------------------------------------------------------------------*
705 * reject, invoke problem
706 *---------------------------------------------------------------------------*/
707 static void
708 F_RJ31(char *pbuf, int val)
709 {
710 #ifdef ST_DEBUG
711 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RJ31, val = %d\n", val);
712 #endif
713 if(val == -1)
714 {
715 sprintf((pbuf+strlen(pbuf)), "\t Invoke problem\n");
716 }
717 else
718 {
719 switch(val)
720 {
721 case 0:
722 sprintf((pbuf+strlen(pbuf)), "\t problem = duplicate invocation\n");
723 break;
724 case 1:
725 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized operation\n");
726 break;
727 case 2:
728 sprintf((pbuf+strlen(pbuf)), "\t problem = mistyped argument\n");
729 break;
730 case 3:
731 sprintf((pbuf+strlen(pbuf)), "\t problem = resource limitation\n");
732 break;
733 case 4:
734 sprintf((pbuf+strlen(pbuf)), "\t problem = initiator releasing\n");
735 break;
736 case 5:
737 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized linked identifier\n");
738 break;
739 case 6:
740 sprintf((pbuf+strlen(pbuf)), "\t problem = linked resonse unexpected\n");
741 break;
742 case 7:
743 sprintf((pbuf+strlen(pbuf)), "\t problem = unexpected child operation\n");
744 break;
745 default:
746 sprintf((pbuf+strlen(pbuf)), "\t problem = unknown problem code 0x%x\n", val);
747 break;
748 }
749 state = ST_EXP_NIX;
750 }
751 }
752
753 /*---------------------------------------------------------------------------*
754 * reject, return result problem
755 *---------------------------------------------------------------------------*/
756 static void
757 F_RJ32(char *pbuf, int val)
758 {
759 #ifdef ST_DEBUG
760 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RJ32, val = %d\n", val);
761 #endif
762 if(val == -1)
763 {
764 sprintf((pbuf+strlen(pbuf)), "\t Return result problem\n");
765 }
766 else
767 {
768 switch(val)
769 {
770 case 0:
771 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized invocation\n");
772 break;
773 case 1:
774 sprintf((pbuf+strlen(pbuf)), "\t problem = return response unexpected\n");
775 break;
776 case 2:
777 sprintf((pbuf+strlen(pbuf)), "\t problem = mistyped result\n");
778 break;
779 default:
780 sprintf((pbuf+strlen(pbuf)), "\t problem = unknown problem code 0x%x\n", val);
781 break;
782 }
783 state = ST_EXP_NIX;
784 }
785 }
786
787 /*---------------------------------------------------------------------------*
788 * reject, return error problem
789 *---------------------------------------------------------------------------*/
790 static void
791 F_RJ33(char *pbuf, int val)
792 {
793 #ifdef ST_DEBUG
794 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RJ33, val = %d\n", val);
795 #endif
796 if(val == -1)
797 {
798 sprintf((pbuf+strlen(pbuf)), "\t Return error problem\n");
799 }
800 else
801 {
802 switch(val)
803 {
804 case 0:
805 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized invocation\n");
806 break;
807 case 1:
808 sprintf((pbuf+strlen(pbuf)), "\t problem = error response unexpected\n");
809 break;
810 case 2:
811 sprintf((pbuf+strlen(pbuf)), "\t problem = unrecognized error\n");
812 break;
813 case 3:
814 sprintf((pbuf+strlen(pbuf)), "\t problem = unexpected error\n");
815 break;
816 case 4:
817 sprintf((pbuf+strlen(pbuf)), "\t problem = mistyped parameter\n");
818 break;
819 default:
820 sprintf((pbuf+strlen(pbuf)), "\t problem = unknown problem code 0x%x\n", val);
821 break;
822 }
823 state = ST_EXP_NIX;
824 }
825 }
826
827 /*---------------------------------------------------------------------------*
828 * invoke component: invoke id
829 *---------------------------------------------------------------------------*/
830 static void
831 F_2(char *pbuf, int val)
832 {
833 #ifdef ST_DEBUG
834 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_2, val = %d\n", val);
835 #endif
836 if(val != -1)
837 {
838 sprintf((pbuf+strlen(pbuf)), "\t InvokeIdentifier = %d\n", val);
839 state = ST_EXP_OP_VAL;
840 }
841 }
842
843 /*---------------------------------------------------------------------------*
844 * return result: invoke id
845 *---------------------------------------------------------------------------*/
846 static void
847 F_RR2(char *pbuf, int val)
848 {
849 #ifdef ST_DEBUG
850 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RR2, val = %d\n", val);
851 #endif
852 if(val != -1)
853 {
854 sprintf((pbuf+strlen(pbuf)), "\t InvokeIdentifier = %d\n", val);
855 state = ST_EXP_RR_OP_VAL;
856 }
857 }
858
859 /*---------------------------------------------------------------------------*
860 * invoke component: operation value
861 *---------------------------------------------------------------------------*/
862 static void
863 F_3(char *pbuf, int val)
864 {
865 #ifdef ST_DEBUG
866 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_3, val = %d\n", val);
867 #endif
868 if(val != -1)
869 {
870 sprintf((pbuf+strlen(pbuf)), "\t Operation Value = %s (%d)\n", opval_str(val), val);
871 state = ST_EXP_INFO;
872 }
873 }
874
875 /*---------------------------------------------------------------------------*
876 * return result: operation value
877 *---------------------------------------------------------------------------*/
878 static void
879 F_RR3(char *pbuf, int val)
880 {
881 #ifdef ST_DEBUG
882 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RR3, val = %d\n", val);
883 #endif
884 if(val != -1)
885 {
886 sprintf((pbuf+strlen(pbuf)), "\t Operation Value = %s (%d)\n", opval_str(val), val);
887 state = ST_EXP_RR_RESULT;
888 }
889 }
890
891 /*---------------------------------------------------------------------------*
892 * return result: RESULT
893 *---------------------------------------------------------------------------*/
894 static void
895 F_RRR(char *pbuf, int val)
896 {
897 #ifdef ST_DEBUG
898 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_RRR, val = %d\n", val);
899 #endif
900 state = ST_EXP_NIX;
901 }
902
903 /*---------------------------------------------------------------------------*
904 *
905 *---------------------------------------------------------------------------*/
906 static void
907 F_4(char *pbuf, int val)
908 {
909 #ifdef ST_DEBUG
910 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_4, val = %d\n", val);
911 #endif
912 if(val == -1)
913 {
914 sprintf((pbuf+strlen(pbuf)), "\t specificChargingUnits\n");
915 state = ST_EXP_RUL;
916 }
917 }
918
919 /*---------------------------------------------------------------------------*
920 *
921 *---------------------------------------------------------------------------*/
922 static void
923 F_4_1(char *pbuf, int val)
924 {
925 #ifdef ST_DEBUG
926 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_4_1, val = %d\n", val);
927 #endif
928 if(val == -1)
929 {
930 sprintf((pbuf+strlen(pbuf)), "\t freeOfCharge\n");
931 state = ST_EXP_NIX;
932 }
933 }
934
935 /*---------------------------------------------------------------------------*
936 *
937 *---------------------------------------------------------------------------*/
938 static void
939 F_4_2(char *pbuf, int val)
940 {
941 #ifdef ST_DEBUG
942 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_4_2, val = %d\n", val);
943 #endif
944 if(val == -1)
945 {
946 sprintf((pbuf+strlen(pbuf)), "\t chargeNotAvailable\n");
947 state = ST_EXP_NIX;
948 }
949 }
950
951 /*---------------------------------------------------------------------------*
952 *
953 *---------------------------------------------------------------------------*/
954 static void
955 F_5(char *pbuf, int val)
956 {
957 #ifdef ST_DEBUG
958 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_5, val = %d\n", val);
959 #endif
960 if(val == -1)
961 {
962 sprintf((pbuf+strlen(pbuf)), "\t recordedUnitsList [1]\n");
963 state = ST_EXP_RU;
964 }
965 }
966
967 /*---------------------------------------------------------------------------*
968 *
969 *---------------------------------------------------------------------------*/
970 static void
971 F_6(char *pbuf, int val)
972 {
973 #ifdef ST_DEBUG
974 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_6, val = %d\n", val);
975 #endif
976 if(val == -1)
977 {
978 sprintf((pbuf+strlen(pbuf)), "\t RecordedUnits\n");
979 state = ST_EXP_RNOU;
980 }
981 }
982
983 /*---------------------------------------------------------------------------*
984 *
985 *---------------------------------------------------------------------------*/
986 static void
987 F_7(char *pbuf, int val)
988 {
989 #ifdef ST_DEBUG
990 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_7, val = %d\n", val);
991 #endif
992 if(val != -1)
993 {
994 sprintf((pbuf+strlen(pbuf)), "\t NumberOfUnits = %d\n", val);
995 state = ST_EXP_TOCI;
996 }
997 }
998
999 /*---------------------------------------------------------------------------*
1000 *
1001 *---------------------------------------------------------------------------*/
1002 static void
1003 F_8(char *pbuf, int val)
1004 {
1005 #ifdef ST_DEBUG
1006 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_8, val = %d\n", val);
1007 #endif
1008 if(val != -1)
1009 {
1010 sprintf((pbuf+strlen(pbuf)), "\t typeOfChargingInfo = %s\n", val == 0 ? "subTotal" : "total");
1011 state = ST_EXP_DBID;
1012 }
1013 }
1014
1015 /*---------------------------------------------------------------------------*
1016 *
1017 *---------------------------------------------------------------------------*/
1018 static void
1019 F_9(char *pbuf, int val)
1020 {
1021 #ifdef ST_DEBUG
1022 sprintf((pbuf+strlen(pbuf)), "next_state: exec F_9, val = %d\n", val);
1023 #endif
1024 if(val != -1)
1025 {
1026 sprintf((pbuf+strlen(pbuf)), "\t AOCDBillingId = %s (%d)\n", bid_str(val), val);
1027 state = ST_EXP_NIX;
1028 }
1029 }
1030
1031 /*---------------------------------------------------------------------------*
1032 * state table
1033 *---------------------------------------------------------------------------*/
1034 static struct statetab {
1035 int currstate; /* input: current state we are in */
1036 int form; /* input: current tag form */
1037 int class; /* input: current tag class */
1038 int code; /* input: current tag code */
1039 void (*func)(char *,int); /* output: func to exec */
1040 } statetab[] = {
1041
1042 /* current state tag form tag class tag code function */
1043 /* --------------------- ---------------------- ---------------------- ---------------------- ----------------*/
1044
1045 /* invoke */
1046
1047 {ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 1, F_1_1 },
1048 {ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 2, F_1_2 },
1049 {ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 3, F_1_3 },
1050 {ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 4, F_1_4 },
1051 {ST_EXP_INV_ID, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_2 },
1052 {ST_EXP_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_3 },
1053 {ST_EXP_INFO, FAC_TAGFORM_CON, FAC_TAGCLASS_UNI, FAC_CODEUNI_SEQ, F_4 },
1054 {ST_EXP_INFO, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_NULL, F_4_1 },
1055 {ST_EXP_INFO, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 1, F_4_2 },
1056 {ST_EXP_RUL, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 1, F_5 },
1057 {ST_EXP_RU, FAC_TAGFORM_CON, FAC_TAGCLASS_UNI, FAC_CODEUNI_SEQ, F_6 },
1058 {ST_EXP_RNOU, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_7 },
1059 {ST_EXP_TOCI, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 2, F_8 },
1060 {ST_EXP_DBID, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 3, F_9 },
1061
1062 /* return result */
1063
1064 {ST_EXP_RR_INV_ID, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_RR2 },
1065 {ST_EXP_RR_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_RR3 },
1066 {ST_EXP_RR_RESULT, FAC_TAGFORM_CON, FAC_TAGCLASS_UNI, FAC_CODEUNI_SET, F_RRR },
1067
1068 /* current state tag form tag class tag code function */
1069 /* --------------------- ---------------------- ---------------------- ---------------------- ----------------*/
1070 /* reject */
1071
1072 {ST_EXP_REJ_INV_ID, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_RJ2 },
1073 {ST_EXP_REJ_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 0, F_RJ30 },
1074 {ST_EXP_REJ_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 1, F_RJ31 },
1075 {ST_EXP_REJ_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 2, F_RJ32 },
1076 {ST_EXP_REJ_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 3, F_RJ33 },
1077
1078 /* end */
1079
1080 {-1, -1, -1, -1, NULL }
1081 };
1082
1083 /*---------------------------------------------------------------------------*
1084 * state decode for do_component
1085 *---------------------------------------------------------------------------*/
1086 static void
1087 next_state(char *pbuf, int class, int form, int code, int val)
1088 {
1089 int i;
1090
1091 #ifdef ST_DEBUG
1092 sprintf((pbuf+strlen(pbuf)), "next_state: class=%d, form=%d, code=%d, val=%d\n", class, form, code, val);
1093 #endif
1094
1095 for(i=0; ; i++)
1096 {
1097 if((statetab[i].currstate > state) ||
1098 (statetab[i].currstate == -1))
1099 {
1100 break;
1101 }
1102
1103 if((statetab[i].currstate == state) &&
1104 (statetab[i].form == form) &&
1105 (statetab[i].class == class) &&
1106 (statetab[i].code == code))
1107 {
1108 (*statetab[i].func)(pbuf, val);
1109 break;
1110 }
1111 }
1112 }
1113
1114 /* EOF */
1115
DragonFly BSD