abb4d4f2de76cfebde8bf0ddbb75d33a699e3955
[asterisk/asterisk.git] / addons / ooh323c / src / printHandler.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the COPYING file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16 /* This is an implementation of a simple print handler.  It outputs 
17    the fields of an encoded PER message to stdout in a structured output 
18    format..
19 */
20 #include "asterisk.h"
21 #include "asterisk/lock.h"
22
23 #include <stdlib.h>
24 /* #ifdef HAVE_MALLOC_H
25 #include <malloc.h>
26 #endif */
27 #include "printHandler.h"
28 #include "ootypes.h"
29 #include "rtctype.h"
30 #include "ootrace.h"
31
32 EventHandler printHandler;
33
34 static const char* pVarName;
35 static int gIndentSpaces;
36
37 static const char* bitStrToString 
38 (ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz);
39
40 static const char* octStrToString 
41 (ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz);
42
43 void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data);
44 void ooPrintOIDValue (ASN1OBJID* pOID);
45 void printRealValue (double value);
46
47 void initializePrintHandler(EventHandler *printHandler, char * varname)
48 {
49    printHandler->startElement = &printStartElement;
50    printHandler->endElement = &printEndElement;
51    printHandler->boolValue = &printBoolValue;
52    printHandler->intValue = &printIntValue;
53    printHandler->uIntValue = &printuIntValue ;
54    printHandler->bitStrValue = &printBitStrValue;
55    printHandler->octStrValue = &printOctStrValue;
56    printHandler->charStrValue = &printCharStrValue;
57    printHandler->charStr16BitValue = &printCharStr16BitValue ;
58    printHandler->nullValue = &printNullValue;
59    printHandler->oidValue = &printOidValue;
60    printHandler->enumValue = &printEnumValue;
61    printHandler->openTypeValue = &printOpenTypeValue;
62    pVarName = varname;
63    OOTRACEDBGB2("%s = {\n", pVarName);
64    gIndentSpaces += 3;
65
66 }
67
68 void finishPrint()
69 {
70    OOTRACEDBGB1 ("}\n");
71    gIndentSpaces -= 3;
72    if (gIndentSpaces != 0) {
73       OOTRACEDBGB1 ("ERROR: unbalanced structure\n");
74    }
75 }
76
77 void indent ()
78 {
79    int i=0;
80    for (i = 0; i < gIndentSpaces; i++) OOTRACEDBGB1 (" ");
81 }
82
83 void printStartElement (const char* name, int index)
84 {
85    indent ();
86    OOTRACEDBGB1 (name);
87    if (index >= 0) OOTRACEDBGB2 ("[%d]", index);
88    OOTRACEDBGB1 (" = {\n");
89    gIndentSpaces += 3;
90 }
91
92 void printEndElement (const char* name, int index)
93 {
94    gIndentSpaces -= 3;
95    indent ();
96    OOTRACEDBGB1 ("}\n");
97 }
98
99 void printBoolValue (ASN1BOOL value)
100 {
101    const char* s = value ? "TRUE" : "FALSE";
102    indent ();
103    OOTRACEDBGB2 ("%s\n", s);
104 }
105
106 void printIntValue (ASN1INT value)
107 {
108    indent ();
109    OOTRACEDBGB2 ("%d\n", value);
110 }
111
112 void printuIntValue (ASN1UINT value)
113 {
114    indent ();
115    OOTRACEDBGB2 ("%u\n", value);
116 }
117
118 void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data)
119 {
120 #ifdef __MINGW32__
121    char s[numbits + 8];
122    indent ();
123    OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
124 #else
125    char* s = (char*)malloc(numbits + 8);
126    indent ();
127    OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
128    free(s);
129 #endif
130 }
131
132 void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data)
133 {
134    int bufsiz = (numocts * 2) + 8;
135 #ifdef __MINGW32__
136    char s[bufsiz];
137    indent ();
138    OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
139 #else
140    char* s = (char*)malloc(bufsiz);
141    indent ();
142    OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
143    free(s);
144 #endif
145 }
146
147 void printCharStrValue (const char* value)
148 {
149    indent ();
150    OOTRACEDBGB2 ("\"%s\"\n", value);
151 }
152
153 void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data)
154 {
155    ASN1UINT ui;
156    indent ();
157
158    for (ui = 0; ui < nchars; ui++) {
159       if (data[ui] >= 32 && data[ui] <= 127)
160          OOTRACEDBGB2 ("%c", (char)data[ui]);
161       else
162          OOTRACEDBGB1 ("?");
163    }
164
165    OOTRACEDBGB1 ("\n");
166 }
167
168 void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data)
169 {
170    ASN1UINT ui;
171    indent ();
172
173    for ( ui = 0; ui < nchars; ui++) {
174       if (data[ui] >= 32 && data[ui] <= 127)
175          OOTRACEDBGB2 ("%c", (char)data[ui]);
176       else
177          OOTRACEDBGB2 ("\\%d", data[ui]);
178    }
179
180    OOTRACEDBGB1 ("\n");
181 }
182
183 void printNullValue ()
184 {
185    indent ();
186    OOTRACEDBGB1 ("NULL\n");
187 }
188
189 void ooPrintOIDValue (ASN1OBJID* pOID)
190 {
191    ASN1UINT ui;
192    OOTRACEDBGB1 ("{ \n");
193    for (ui = 0; ui < pOID->numids; ui++) {
194       OOTRACEDBGB2 ("%d ", pOID->subid[ui]);
195    }
196    OOTRACEDBGB1 ("}\n");
197 }
198
199 void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds)
200 {
201    ASN1UINT ui;
202    ASN1OBJID oid;
203    oid.numids = numSubIds;
204
205    for ( ui = 0; ui < numSubIds; ui++)
206       oid.subid[ui] = pSubIds[ui];
207
208    indent ();
209    ooPrintOIDValue (&oid);
210 }
211
212 void printRealValue (double value)
213 {
214    indent ();
215    OOTRACEDBGB2 ("%f\n", value);
216 }
217
218 void printEnumValue (ASN1UINT value)
219 {
220    indent ();
221    OOTRACEDBGB2 ("%u\n", value);
222 }
223
224 void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data)
225 {
226    indent ();
227    OOTRACEDBGB1 ("< encoded data >\n");
228 }
229
230 static const char* bitStrToString 
231 (ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz)
232 {
233    size_t i;
234    unsigned char mask = 0x80;
235
236    if (bufsiz > 0) {
237       buffer[0] = '\'';
238       for (i = 0; i < numbits; i++) {
239          if (i < bufsiz - 1) {
240             buffer[i+1] = (char) (((data[i/8] & mask) != 0) ? '1' : '0');
241             mask >>= 1;
242             if (0 == mask) mask = 0x80;
243          }
244          else break;
245       }
246      i++;
247       if (i < bufsiz - 1) buffer[i++] = '\'';
248       if (i < bufsiz - 1) buffer[i++] = 'B';
249       if (i < bufsiz - 1) buffer[i] = '\0';
250       else buffer[bufsiz - 1] = '\0';
251    }
252
253    return buffer;
254 }
255
256 static const char* octStrToString 
257 (ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz)
258 {
259    size_t i;
260    char lbuf[4];
261
262    if (bufsiz > 0) {
263       buffer[0] = '\'';
264       if (bufsiz > 1) buffer[1] = '\0';
265       for (i = 0; i < numocts; i++) {
266          if (i < bufsiz - 1) {
267             sprintf (lbuf, "%02x", data[i]);
268             strcat (&buffer[(i*2)+1], lbuf);
269          }
270          else break;
271       }
272      i = i*2 + 1;
273       if (i < bufsiz - 1) buffer[i++] = '\'';
274       if (i < bufsiz - 1) buffer[i++] = 'H';
275       if (i < bufsiz - 1) buffer[i] = '\0';
276       else buffer[bufsiz - 1] = '\0';
277    }
278
279    return buffer;
280 }