Wildfire: fix memory leak.
[citadel] / libcitadel / lib / wildfire.c
1 /*@{*/
2
3 #include "sysdep.h"
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <unistd.h>
7 #include <dirent.h>
8 #include <errno.h>
9 #include <stdio.h>
10 #include <stdarg.h>
11 #include <string.h>
12
13 #if HAVE_BACKTRACE
14 #include <execinfo.h>
15 #endif
16
17 #include "libcitadel.h"
18 #include "libcitadellocal.h"
19
20
21 ConstStr WF_MsgStrs[] = {
22         {HKEY("LOG")},
23         {HKEY("INFO")},
24         {HKEY("WARN")},
25         {HKEY("ERROR")},
26         {HKEY("TRACE")},
27         {HKEY("EXCEPTION")}
28 };
29
30 static JsonValue *WFInfo(const char *Filename, long fnlen,
31                          long LineNo, 
32                          WF_MessageType Type)
33 {
34         JsonValue *Val;
35
36         Val = NewJsonObject(NULL, 0);
37         JsonObjectAppend(Val, 
38                          NewJsonPlainString(HKEY("Type"),
39                                             WF_MsgStrs[Type].Key, 
40                                             WF_MsgStrs[Type].len));
41         JsonObjectAppend(Val, 
42                          NewJsonPlainString(HKEY("File"), 
43                                             Filename, fnlen));
44         JsonObjectAppend(Val, 
45                          NewJsonNumber(HKEY("Line"), LineNo));
46         return Val;
47 }
48                             
49
50 JsonValue *WildFireMessage(const char *Filename, long fnlen,
51                            long LineNo,
52                            StrBuf *Msg, 
53                            WF_MessageType Type)
54 {
55         JsonValue *Ret;
56
57         Ret = NewJsonArray(NULL, 0);
58         JsonArrayAppend(Ret, WFInfo(Filename, fnlen,
59                                     LineNo, Type));
60
61         JsonArrayAppend(Ret, 
62                         NewJsonString(NULL, 0, Msg));
63         return Ret;
64 }
65
66 JsonValue *WildFireMessagePlain(const char *Filename, long fnlen,
67                                 long LineNo,
68                                 const char *Message, long len, 
69                                 WF_MessageType Type)
70 {
71         JsonValue *Val;
72         Val = NewJsonArray(NULL, 0);
73
74         JsonArrayAppend(Val, WFInfo(Filename, fnlen,
75                                     LineNo, Type));
76         JsonArrayAppend(Val, 
77                         NewJsonPlainString(NULL, 0, Message, len));
78         return Val;
79 }
80
81 void WildFireAddArray(JsonValue *ReportBase, JsonValue *Array, WF_MessageType Type)
82 {
83         JsonValue *Val;
84         Val = NewJsonArray(NULL, 0);
85         JsonArrayAppend(Val, 
86                         NewJsonPlainString(NULL, 0, 
87                                            WF_MsgStrs[Type].Key, 
88                                            WF_MsgStrs[Type].len));
89
90         JsonArrayAppend(Val, Array);
91 }
92
93 int addr2line_write_pipe[2];
94 int addr2line_read_pipe[2];
95 pid_t addr2line_pid;
96
97 #ifdef HAVE_BACKTRACE
98 /* 
99  * Start up the addr2line daemon so we can decode function pointers
100  */
101 static void start_addr2line_daemon(const char *binary) 
102 {
103         struct stat filestats;
104         int i;
105         const char *addr2line = "/usr/bin/addr2line";
106         const char minuse[] = "-e";
107
108         printf("Starting addr2line daemon for decoding of backtraces\n");
109
110         if ((stat(addr2line, &filestats)==-1) ||
111             (filestats.st_size==0)){
112                 printf("didn't find addr2line daemon in %s: %s\n", addr2line, strerror(errno));
113                 abort();
114         }
115         if (pipe(addr2line_write_pipe) != 0) {
116                 printf("Unable to create pipe for addr2line daemon: %s\n", strerror(errno));
117                 abort();
118         }
119         if (pipe(addr2line_read_pipe) != 0) {
120                 printf("Unable to create pipe for addr2line daemon: %s\n", strerror(errno));
121                 abort();
122         }
123
124         addr2line_pid = fork();
125         if (addr2line_pid < 0) {
126                 printf("Unable to fork addr2line daemon: %s\n", strerror(errno));
127                 abort();
128         }
129         if (addr2line_pid == 0) {
130                 dup2(addr2line_write_pipe[0], 0);
131                 dup2(addr2line_read_pipe[1], 1);
132                 for (i=2; i<256; ++i) close(i);
133                 execl(addr2line, addr2line, minuse, binary, NULL);
134                 printf("Unable to exec addr2line daemon: %s\n", strerror(errno));
135                 abort();
136                 exit(errno);
137         }
138 }
139
140 static int addr2lineBacktrace(StrBuf *Function, 
141                               StrBuf *FileName, 
142                               StrBuf *Pointer, 
143                               StrBuf *Buf,
144                               unsigned int *FunctionLine)
145
146 {
147         const char *err;
148         const char *pch, *pche;
149
150         write(addr2line_write_pipe[1], SKEY(Pointer));
151         if (StrBufTCP_read_line(Buf, &addr2line_read_pipe[0], 0, &err) <= 0)
152         {
153                 StrBufAppendBufPlain(Buf, err, -1, 0);
154                 return 0;
155         }
156         pch = ChrPtr(Buf);
157         pche = strchr(pch, ':');
158         FlushStrBuf(FileName);
159         StrBufAppendBufPlain(FileName, pch, pche - pch, 0);
160         if (pche != NULL)
161         {
162                 pche++;
163                 *FunctionLine = atoi(pche);
164         }
165         else 
166                 *FunctionLine = 0;
167         return 1;
168 }
169
170 static int ParseBacktrace(char *Line, 
171                           StrBuf *Function, 
172                           StrBuf *FileName, 
173                           unsigned int *FunctionLine)
174 {
175         char *pch, *pche;
176
177         pch = Line;
178         pche = strchr(pch, '(');
179         if (pche == NULL) return 0;
180         StrBufAppendBufPlain(FileName, pch, pche - pch, 0);
181         pch = pche + 1;
182         pche = strchr(pch, '+');
183         if (pche == NULL) return 0;
184         StrBufAppendBufPlain(Function, pch, pche - pch, 0);
185         pch = pche + 1;
186         pche = strchr(pch, ')');
187         if (pche == NULL) return 0;
188         *pche = '\0';
189         sscanf(pch, "%x", FunctionLine);
190         StrBufAppendBufPlain(Function, pche + 1, -1, 0);
191         return 1;
192 }
193 #endif
194 long BaseFrames = 0;
195 StrBuf *FullBinaryName = NULL;
196
197 void WildFireShutdown(void)
198 {
199         close(addr2line_write_pipe[0]);
200         close(addr2line_read_pipe[0]);
201
202         FreeStrBuf(&FullBinaryName);
203 }
204
205 void WildFireInitBacktrace(const char *argvNull, int AddBaseFrameSkip)
206 {
207
208 #ifdef HAVE_BACKTRACE
209         void *stack_frames[100];
210         size_t size;
211         long i;
212         char **strings;
213         StrBuf *FileName;
214         StrBuf *Function;
215         StrBuf *Pointer;
216         StrBuf *Buf;
217         unsigned int FunctionLine;
218         struct stat filestats;
219
220         FileName = NewStrBuf();
221         Function = NewStrBuf();
222         Pointer = NewStrBuf();
223         Buf = NewStrBuf();
224
225         BaseFrames = size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
226         BaseFrames --;
227         BaseFrames += AddBaseFrameSkip;
228         strings = backtrace_symbols(stack_frames, size);
229         for (i = 1; i < size; i++) {
230                 if (strings != NULL){
231                         ParseBacktrace(strings[i], Function, 
232                                        FileName, 
233                                        &FunctionLine);
234                         FullBinaryName = NewStrBufDup(FileName);
235                         size = i;
236                 }
237                 else {
238                         char path[256];
239                         getcwd(path, sizeof(path));
240                         FullBinaryName = NewStrBufPlain(path, -1);
241                         StrBufAppendBufPlain(FullBinaryName, HKEY("/"), 0);
242                         StrBufAppendBufPlain(FullBinaryName, argvNull, -1, 0);
243                         i = size;
244                  }
245         }
246         if ((stat(ChrPtr(FullBinaryName), &filestats)==-1) ||
247             (filestats.st_size==0)){
248                 FlushStrBuf(FullBinaryName);
249                 StrBufAppendBufPlain(FullBinaryName, argvNull, -1, 0);
250                 if ((stat(ChrPtr(FullBinaryName), &filestats)==-1) ||
251                     (filestats.st_size==0)){
252                         FlushStrBuf(FullBinaryName);
253                         fprintf(stderr, "unable to open my binary for addr2line checking, verbose backtraces won't work.\n");
254                 }
255         }
256         free(strings);
257         FreeStrBuf(&FileName);
258         FreeStrBuf(&Function);
259         FreeStrBuf(&Pointer);
260         FreeStrBuf(&Buf);
261         if (StrLength(FullBinaryName) > 0)
262                 start_addr2line_daemon(ChrPtr(FullBinaryName));
263 #endif
264
265
266 }
267
268
269 JsonValue *WildFireException(const char *Filename, long FileLen,
270                              long LineNo,
271                              StrBuf *Message,
272                              int StackOffset)
273 {
274         JsonValue *ExcClass;
275         JsonValue *Val;
276         Val = NewJsonArray(NULL, 0);
277
278         JsonArrayAppend(Val, WFInfo(Filename, FileLen,
279                                     LineNo, eEXCEPTION));
280
281         ExcClass = NewJsonObject(WF_MsgStrs[eTRACE].Key, 
282                                  WF_MsgStrs[eTRACE].len);
283         
284         JsonArrayAppend(Val, ExcClass);
285         JsonObjectAppend(ExcClass, 
286                          NewJsonPlainString(HKEY("Class"), 
287                                             HKEY("Exception")));
288         JsonObjectAppend(ExcClass, 
289                          NewJsonString(HKEY("Message"), Message));
290         JsonObjectAppend(ExcClass, 
291                          NewJsonPlainString(HKEY("File"), 
292                                             Filename, FileLen));
293 /*
294         JsonObjectAppend(ExcClass, 
295                          NewJsonPlainString(HKEY("Type"), 
296                                             HKEY("throw")));
297 */
298         JsonObjectAppend(ExcClass, 
299                          NewJsonNumber(HKEY("Line"), LineNo));
300
301 #ifdef HAVE_BACKTRACE
302         {
303                 void *stack_frames[100];
304                 size_t size;
305                 long i;
306                 char **strings;
307                 JsonValue *Trace;
308                 JsonValue *Frame;
309                 StrBuf *FileName;
310                 StrBuf *Function;
311                 StrBuf *Pointer;
312                 StrBuf *Buf;
313                 unsigned int FunctionLine;
314
315                 Trace = NewJsonArray(HKEY("Trace"));
316                 JsonObjectAppend(ExcClass, Trace);
317                 FileName = NewStrBuf();
318                 Function = NewStrBuf();
319                 Pointer = NewStrBuf();
320                 Buf = NewStrBuf();
321
322                 size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
323                 strings = backtrace_symbols(stack_frames, size);
324                 for (i = StackOffset + 1; i < size; i++) {
325                         if (strings != NULL){
326                                 ParseBacktrace(strings[i], Function, 
327                                                FileName,
328                                                &FunctionLine);
329                                 
330                         }
331                         StrBufPrintf(Pointer, "%p\n", stack_frames[i]);
332                         
333                         addr2lineBacktrace(Function, 
334                                            FileName, 
335                                            Pointer, 
336                                            Buf, 
337                                            &FunctionLine);
338
339                         Frame = NewJsonObject(NULL, 0);
340                         JsonArrayAppend(Trace, Frame);
341                         JsonObjectAppend(Frame, 
342                                          NewJsonString(HKEY("function"), Function));
343                         JsonObjectAppend(Frame, 
344                                          NewJsonString(HKEY("file"), FileName));
345                         JsonObjectAppend(Frame, 
346                                          NewJsonNumber(HKEY("line"), FunctionLine));
347                         JsonObjectAppend(Frame, 
348                                          NewJsonArray(HKEY("args")));/* not supportet... */
349
350                         FunctionLine = 0;
351                         FlushStrBuf(FileName);
352                         FlushStrBuf(Function);
353                         FlushStrBuf(Pointer);
354                 }
355                 free(strings);
356                 FreeStrBuf(&FileName);
357                 FreeStrBuf(&Function);
358                 FreeStrBuf(&Pointer);
359                 FreeStrBuf(&Buf);
360         }
361 #endif
362         return Val;
363 }
364
365 void WildFireSerializePayload(StrBuf *JsonBuffer, StrBuf *OutBuf, int *MsgCount, AddHeaderFunc AddHdr)
366 {
367         int n = *MsgCount;
368         StrBuf *Buf;
369         StrBuf *HeaderName;
370         StrBuf *N; 
371         const char Concatenate[] = "\\";
372         const char empty[] = "";
373         const char *Cat;
374         StrBuf *Header;
375
376         if (OutBuf == NULL)
377                 Header = NewStrBuf();
378         if (*MsgCount == 0) {
379                 if (OutBuf != NULL) {
380                         StrBufAppendBufPlain(OutBuf, 
381                                              HKEY( 
382                                                      "X-Wf-Protocol-1" 
383                                                      ": "
384                                                      "http://meta.wildfirehq.org/Protocol/JsonStream/0.2\r\n"), 0);
385                         StrBufAppendBufPlain(OutBuf, 
386                                              HKEY( 
387                                                      "X-Wf-1-Plugin-1" 
388                                                      ": " 
389                                                      "http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.2.0\r\n"), 0);
390                         StrBufAppendBufPlain(OutBuf, 
391                                              HKEY(
392                                                      "X-Wf-1-Structure-1"
393                                                      ": "
394                                                      "http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1\r\n"), 0);
395                 }
396                 else {
397                         AddHdr("X-Wf-Protocol-1", 
398                                "http://meta.wildfirehq.org/Protocol/JsonStream/0.2");
399                         AddHdr("X-Wf-1-Plugin-1",
400                                "http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.2.0");
401                         AddHdr("X-Wf-1-Structure-1",
402                                "http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1");
403                 }
404         }
405
406         N = NewStrBuf();
407         StrBufPrintf(N, "%d", StrLength(JsonBuffer));
408         Buf = NewStrBufPlain(NULL, 1024);
409         HeaderName = NewStrBuf();
410
411         while (StrLength(JsonBuffer) > 0) {
412                 FlushStrBuf(Buf);
413                 StrBufPrintf(HeaderName, "X-Wf-"WF_MAJOR"-"WF_STRUCTINDEX"-"WF_SUB"-%d", n);
414                 if (StrLength(JsonBuffer) > 800) {
415                         StrBufAppendBufPlain(Buf, ChrPtr(JsonBuffer), 800, 0);
416                         StrBufCutLeft(JsonBuffer, 800);
417                         Cat = Concatenate;
418                 }
419                 else {
420                         StrBufAppendBuf(Buf, JsonBuffer, 0);
421                         FlushStrBuf(JsonBuffer);
422                         Cat = empty;
423                 }
424                 if (OutBuf != NULL) {
425                         StrBufAppendPrintf(OutBuf, 
426                                            "%s: %s|%s|%s\r\n", 
427                                            ChrPtr(HeaderName), 
428                                            ChrPtr(N),
429                                            ChrPtr(Buf), 
430                                            Cat);
431                 }
432                 else {
433                         StrBufAppendPrintf(Header, 
434                                            "%s|%s|%s", 
435                                            ChrPtr(N),
436                                            ChrPtr(Buf), 
437                                            Cat);
438                         AddHdr(ChrPtr(HeaderName), ChrPtr(Header));
439                         
440                 }
441
442                 FlushStrBuf(N);
443                 n++;
444         }
445         *MsgCount = n;
446         if (OutBuf == NULL) {
447                 FreeStrBuf(&Header);
448         }
449         FreeStrBuf(&N);
450         FreeStrBuf(&Buf);
451         FreeStrBuf(&HeaderName);
452 }
453
454
455
456
457
458
459 /* this is how we do it...
460 void CreateWildfireSampleMessage(void)
461 {
462         JsonValue *Error;
463                 
464         StrBuf *Buf;
465         StrBuf *Header;
466         StrBuf *Json;
467         int n = 1;
468
469         Header = NewStrBuf();
470         Json = NewStrBuf();
471
472         Error = WildFireMessagePlain(HKEY(__FILE__), __LINE__, HKEY("Info message"), eINFO);
473         SerializeJson(Json, Error);
474         WildFireSerializePayload(Json, Header, &n, NULL);
475         StrBufAppendBuf(WC->HBuf, Header, 0);
476         DeleteJSONValue(Error);
477         FlushStrBuf(Json);
478         FlushStrBuf(Header);
479
480         Error = WildFireMessagePlain(HKEY(__FILE__), __LINE__,  HKEY("Warn message"), eWARN);
481         SerializeJson(Json, Error);
482         WildFireSerializePayload(Json, Header, &n, NULL);
483         StrBufAppendBuf(WC->HBuf, Header, 0);
484         DeleteJSONValue(Error);
485         FlushStrBuf(Json);
486         FlushStrBuf(Header);
487
488         Error = WildFireMessagePlain(HKEY(__FILE__), __LINE__, HKEY("Error message"), eERROR);
489         SerializeJson(Json, Error);
490         WildFireSerializePayload(Json, Header, &n, NULL);
491         StrBufAppendBuf(WC->HBuf, Header, 0);
492         DeleteJSONValue(Error);
493         FlushStrBuf(Json);
494         FlushStrBuf(Header);
495
496         Error = WildFireMessagePlain(HKEY(__FILE__), __LINE__, HKEY("Info message"), eINFO);
497         SerializeJson(Json, Error);
498         WildFireSerializePayload(Json, Header, &n, NULL);
499         StrBufAppendBuf(WC->HBuf, Header, 0);
500         DeleteJSONValue(Error);
501         FlushStrBuf(Json);
502         FlushStrBuf(Header);
503
504         Error = WildFireMessagePlain(HKEY(__FILE__), __LINE__, HKEY("Info message"), eINFO);
505         SerializeJson(Json, Error);
506         WildFireSerializePayload(Json, Header, &n, NULL);
507         StrBufAppendBuf(WC->HBuf, Header, 0);
508         DeleteJSONValue(Error);
509         FlushStrBuf(Json);
510         FlushStrBuf(Header);
511
512
513         Buf = NewStrBufPlain(HKEY("test error message"));
514         Error = WildFireException(Buf, HKEY(__FILE__), __LINE__, 1);
515         SerializeJson(Json, Error);
516         WildFireSerializePayload(Json, Header, &n, NULL);
517         StrBufAppendBuf(WC->HBuf, Header, 0);
518         DeleteJSONValue(Error);
519
520         FlushStrBuf(Json);
521         FlushStrBuf(Header);
522
523 }
524
525 */