Final fix memleaks in GkClient codes, same for Timer codes.
[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 AST_MUTEX_DEFINE_STATIC(printlock);
34
35 static const char* pVarName;
36 static int gIndentSpaces;
37
38 static const char* bitStrToString 
39 (ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz);
40
41 static const char* octStrToString 
42 (ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz);
43
44 void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data);
45 void ooPrintOIDValue (ASN1OBJID* pOID);
46 void printRealValue (double value);
47
48 void initializePrintHandler(EventHandler *printHandler, char * varname)
49 {
50    printHandler->startElement = &printStartElement;
51    printHandler->endElement = &printEndElement;
52    printHandler->boolValue = &printBoolValue;
53    printHandler->intValue = &printIntValue;
54    printHandler->uIntValue = &printuIntValue ;
55    printHandler->bitStrValue = &printBitStrValue;
56    printHandler->octStrValue = &printOctStrValue;
57    printHandler->charStrValue = &printCharStrValue;
58    printHandler->charStr16BitValue = &printCharStr16BitValue ;
59    printHandler->nullValue = &printNullValue;
60    printHandler->oidValue = &printOidValue;
61    printHandler->enumValue = &printEnumValue;
62    printHandler->openTypeValue = &printOpenTypeValue;
63    pVarName = varname;
64    ast_mutex_lock(&printlock);
65    OOTRACEDBGB2("%s = {\n", pVarName);
66    gIndentSpaces += 3;
67
68 }
69
70 void finishPrint()
71 {
72    OOTRACEDBGB1 ("}\n");
73    gIndentSpaces -= 3;
74    if (gIndentSpaces != 0) {
75       OOTRACEDBGB1 ("ERROR: unbalanced structure\n");
76    }
77    gIndentSpaces = 0;
78    ast_mutex_unlock(&printlock);
79 }
80
81 void indent ()
82 {
83    int i=0;
84    for (i = 0; i < gIndentSpaces; i++) OOTRACEDBGB1 (" ");
85 }
86
87 void printStartElement (const char* name, int index)
88 {
89    indent ();
90    OOTRACEDBGB1 (name);
91    if (index >= 0) OOTRACEDBGB2 ("[%d]", index);
92    OOTRACEDBGB1 (" = {\n");
93    gIndentSpaces += 3;
94 }
95
96 void printEndElement (const char* name, int index)
97 {
98    gIndentSpaces -= 3;
99    indent ();
100    OOTRACEDBGB1 ("}\n");
101 }
102
103 void printBoolValue (ASN1BOOL value)
104 {
105    const char* s = value ? "TRUE" : "FALSE";
106    indent ();
107    OOTRACEDBGB2 ("%s\n", s);
108 }
109
110 void printIntValue (ASN1INT value)
111 {
112    indent ();
113    OOTRACEDBGB2 ("%d\n", value);
114 }
115
116 void printuIntValue (ASN1UINT value)
117 {
118    indent ();
119    OOTRACEDBGB2 ("%u\n", value);
120 }
121
122 void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data)
123 {
124 #ifdef __MINGW32__
125    char s[numbits + 8];
126    indent ();
127    OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
128 #else
129    char* s = (char*)malloc(numbits + 8);
130    indent ();
131    OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
132    free(s);
133 #endif
134 }
135
136 void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data)
137 {
138    int bufsiz = (numocts * 2) + 8;
139 #ifdef __MINGW32__
140    char s[bufsiz];
141    indent ();
142    OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
143 #else
144    char* s = (char*)malloc(bufsiz);
145    indent ();
146    OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
147    free(s);
148 #endif
149 }
150
151 void printCharStrValue (const char* value)
152 {
153    indent ();
154    OOTRACEDBGB2 ("\"%s\"\n", value);
155 }
156
157 void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data)
158 {
159    ASN1UINT ui;
160    indent ();
161
162    for (ui = 0; ui < nchars; ui++) {
163       if (data[ui] >= 32 && data[ui] <= 127)
164          OOTRACEDBGB2 ("%c", (char)data[ui]);
165       else
166          OOTRACEDBGB1 ("?");
167    }
168
169    OOTRACEDBGB1 ("\n");
170 }
171
172 void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data)
173 {
174    ASN1UINT ui;
175    indent ();
176
177    for ( ui = 0; ui < nchars; ui++) {
178       if (data[ui] >= 32 && data[ui] <= 127)
179          OOTRACEDBGB2 ("%c", (char)data[ui]);
180       else
181          OOTRACEDBGB2 ("\\%d", data[ui]);
182    }
183
184    OOTRACEDBGB1 ("\n");
185 }
186
187 void printNullValue ()
188 {
189    indent ();
190    OOTRACEDBGB1 ("NULL\n");
191 }
192
193 void ooPrintOIDValue (ASN1OBJID* pOID)
194 {
195    ASN1UINT ui;
196    OOTRACEDBGB1 ("{ \n");
197    for (ui = 0; ui < pOID->numids; ui++) {
198       OOTRACEDBGB2 ("%d ", pOID->subid[ui]);
199    }
200    OOTRACEDBGB1 ("}\n");
201 }
202
203 void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds)
204 {
205    ASN1UINT ui;
206    ASN1OBJID oid;
207    oid.numids = numSubIds;
208
209    for ( ui = 0; ui < numSubIds; ui++)
210       oid.subid[ui] = pSubIds[ui];
211
212    indent ();
213    ooPrintOIDValue (&oid);
214 }
215
216 void printRealValue (double value)
217 {
218    indent ();
219    OOTRACEDBGB2 ("%f\n", value);
220 }
221
222 void printEnumValue (ASN1UINT value)
223 {
224    indent ();
225    OOTRACEDBGB2 ("%u\n", value);
226 }
227
228 void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data)
229 {
230    indent ();
231    OOTRACEDBGB1 ("< encoded data >\n");
232 }
233
234 static const char* bitStrToString 
235 (ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz)
236 {
237    size_t i;
238    unsigned char mask = 0x80;
239
240    if (bufsiz > 0) {
241       buffer[0] = '\'';
242       for (i = 0; i < numbits; i++) {
243          if (i < bufsiz - 1) {
244             buffer[i+1] = (char) (((data[i/8] & mask) != 0) ? '1' : '0');
245             mask >>= 1;
246             if (0 == mask) mask = 0x80;
247          }
248          else break;
249       }
250      i++;
251       if (i < bufsiz - 1) buffer[i++] = '\'';
252       if (i < bufsiz - 1) buffer[i++] = 'B';
253       if (i < bufsiz - 1) buffer[i] = '\0';
254       else buffer[bufsiz - 1] = '\0';
255    }
256
257    return buffer;
258 }
259
260 static const char* octStrToString 
261 (ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz)
262 {
263    size_t i;
264    char lbuf[4];
265
266    if (bufsiz > 0) {
267       buffer[0] = '\'';
268       if (bufsiz > 1) buffer[1] = '\0';
269       for (i = 0; i < numocts; i++) {
270          if (i < bufsiz - 1) {
271             sprintf (lbuf, "%02x", data[i]);
272             strcat (&buffer[(i*2)+1], lbuf);
273          }
274          else break;
275       }
276      i = i*2 + 1;
277       if (i < bufsiz - 1) buffer[i++] = '\'';
278       if (i < bufsiz - 1) buffer[i++] = 'H';
279       if (i < bufsiz - 1) buffer[i] = '\0';
280       else buffer[bufsiz - 1] = '\0';
281    }
282
283    return buffer;
284 }