source: logging.c @ 3066d23

barnowl_perlaimdebianrelease-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since 3066d23 was 3066d23, checked in by Alejandro R. Sedeño <asedeno@mit.edu>, 14 years ago
Fix outgoing jabber logging. Added two new perlglue functions: * log_message - takes a message hash, turns it into an owl message, and passes it to the logger. * add_and_log_message - combination off add_message and log_message. Takes a message hash, turns it into an owl message, logs it, and adds the same message to the message list if needed. This exists for convenience, so we don't have to convert the message hash twice. Also, took out an extraneous check from logging.c.
  • Property mode set to 100644
File size: 15.0 KB
Line 
1#include "owl.h"
2#include <stdlib.h>
3#include <string.h>
4#include <ctype.h>
5#include <sys/param.h>
6
7static const char fileIdent[] = "$Id$";
8
9/* This is now the one function that should be called to log a
10 * message.  It will do all the work necessary by calling the other
11 * functions in this file as necessary.
12 */
13void owl_log_message(owl_message *m) {
14  owl_function_debugmsg("owl_log_message: entering");
15
16  if (m == NULL) {
17    owl_function_debugmsg("owl_log_message: passed null message");
18    return;
19  }
20
21  /* should we be logging this message? */
22  if (!owl_log_shouldlog_message(m)) {
23    owl_function_debugmsg("owl_log_message: not logging message");
24    return;
25  }
26
27  /* handle incmoing messages */
28  if (owl_message_is_direction_in(m)) {
29    owl_log_incoming(m);
30    owl_function_debugmsg("owl_log_message: leaving");
31    return;
32  }
33
34  /* handle outgoing messages */
35  if (owl_message_is_type_aim(m)) {
36    owl_log_outgoing_aim(m);
37  } else if (owl_message_is_type_zephyr(m)) {
38    owl_log_outgoing_zephyr(m);
39  } else if (owl_message_is_type_loopback(m)) {
40    owl_log_outgoing_loopback(m);
41  } else if (owl_message_is_type_jabber(m)) {
42   owl_log_outgoing_jabber(m);   
43  }else {
44    owl_function_error("Unknown message type for logging");
45  }
46  owl_function_debugmsg("owl_log_message: leaving");
47}
48
49/* Return 1 if we should log the given message, otherwise return 0 */
50int owl_log_shouldlog_message(owl_message *m) {
51  owl_filter *f;
52
53  /* If there's a logfilter and this message matches it, log */
54  f=owl_global_get_filter(&g, owl_global_get_logfilter(&g));
55  if (f && owl_filter_message_match(f, m)) return(1);
56
57  /* otherwise we do things based on the logging variables */
58
59  /* skip login/logout messages if appropriate */
60  if (!owl_global_is_loglogins(&g) && owl_message_is_loginout(m)) return(0);
61     
62  /* check for nolog */
63  if (!strcasecmp(owl_message_get_opcode(m), "nolog") || !strcasecmp(owl_message_get_instance(m), "nolog")) return(0);
64
65  /* check direction */
66  if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_IN) && owl_message_is_direction_out(m)) {
67    return(0);
68  }
69  if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_OUT) && owl_message_is_direction_in(m)) {
70    return(0);
71  }
72
73  if (owl_message_is_type_zephyr(m)) {
74    if (owl_message_is_personal(m) && !owl_global_is_logging(&g)) return(0);
75    if (!owl_message_is_personal(m) && !owl_global_is_classlogging(&g)) return(0);
76  } else {
77    if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
78      if (!owl_global_is_logging(&g)) return(0);
79    } else {
80      if (!owl_global_is_classlogging(&g)) return(0);
81    }
82  }
83  return(1);
84}
85
86void owl_log_outgoing_zephyr(owl_message *m)
87{
88  FILE *file;
89  char filename[MAXPATHLEN], *logpath;
90  char *to, *text;
91
92  /* strip local realm */
93  to=short_zuser(owl_message_get_recipient(m));
94
95  /* expand ~ in path names */
96  logpath=owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
97
98  text=owl_message_get_body(m);
99
100  snprintf(filename, MAXPATHLEN, "%s/%s", logpath, to);
101  file=fopen(filename, "a");
102  if (!file) {
103    owl_function_error("Unable to open file for outgoing logging");
104    owl_free(logpath);
105    owl_free(to);
106    return;
107  }
108  fprintf(file, "OUTGOING (owl): %s\n%s\n", to, text);
109  if (text[strlen(text)-1]!='\n') {
110    fprintf(file, "\n");
111  }
112  fclose(file);
113
114  snprintf(filename, MAXPATHLEN, "%s/all", logpath);
115  owl_free(logpath);
116  file=fopen(filename, "a");
117  if (!file) {
118    owl_function_error("Unable to open file for outgoing logging");
119    owl_free(to);
120    return;
121  }
122  fprintf(file, "OUTGOING (owl): %s\n%s\n", to, text);
123  if (text[strlen(text)-1]!='\n') {
124    fprintf(file, "\n");
125  }
126  fclose(file);
127
128  owl_free(to);
129}
130
131void owl_log_outgoing_zephyr_error(char *to, char *text)
132{
133  FILE *file;
134  char filename[MAXPATHLEN], *logpath;
135  char *tobuff, *zwriteline;
136  owl_message *m;
137
138  /* create a present message so we can pass it to
139   * owl_log_shouldlog_message()
140   */
141  zwriteline=owl_sprintf("zwrite %s", to);
142  m=owl_function_make_outgoing_zephyr(text, zwriteline, "");
143  owl_free(zwriteline);
144  if (!owl_log_shouldlog_message(m)) {
145    owl_message_free(m);
146    return;
147  }
148  owl_message_free(m);
149
150  /* chop off a local realm */
151  tobuff=short_zuser(to);
152
153  /* expand ~ in path names */
154  logpath = owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
155
156  snprintf(filename, MAXPATHLEN, "%s/%s", logpath, tobuff);
157  file=fopen(filename, "a");
158  if (!file) {
159    owl_function_error("Unable to open file for outgoing logging");
160    owl_free(logpath);
161    owl_free(tobuff);
162    return;
163  }
164  fprintf(file, "ERROR (owl): %s\n%s\n", tobuff, text);
165  if (text[strlen(text)-1]!='\n') {
166    fprintf(file, "\n");
167  }
168  fclose(file);
169
170  snprintf(filename, MAXPATHLEN, "%s/all", logpath);
171  owl_free(logpath);
172  file=fopen(filename, "a");
173  if (!file) {
174    owl_function_error("Unable to open file for outgoing logging");
175    owl_free(tobuff);
176    return;
177  }
178  fprintf(file, "ERROR (owl): %s\n%s\n", tobuff, text);
179  if (text[strlen(text)-1]!='\n') {
180    fprintf(file, "\n");
181  }
182  fclose(file);
183
184  owl_free(tobuff);
185}
186
187void owl_log_outgoing_jabber(owl_message *m)
188{
189  FILE *file;
190  char filename[MAXPATHLEN], *logpath;
191  char *tobuff, *normalto, *text;
192  owl_function_debugmsg("owl_log_outgoing_jabber: entering");
193  /* normalize and downcase the screenname */
194  normalto = owl_message_get_recipient(m);
195 
196  /* downstr(normalto); */
197  tobuff=owl_sprintf("jabber:%s", normalto);
198  /* owl_free(normalto); */
199
200  /* expand ~ in path names */
201  logpath = owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
202
203  text=owl_message_get_body(m);
204 
205  snprintf(filename, MAXPATHLEN, "%s/%s", logpath, tobuff);
206  file=fopen(filename, "a");
207  if (!file) {
208    owl_function_error("Unable to open file for outgoing logging");
209    owl_free(logpath);
210    owl_free(tobuff);
211    return;
212  }
213  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
214  if (text[strlen(text)-1]!='\n') {
215    fprintf(file, "\n");
216  }
217  fclose(file);
218
219  snprintf(filename, MAXPATHLEN, "%s/all", logpath);
220  owl_free(logpath);
221  file=fopen(filename, "a");
222  if (!file) {
223    owl_function_error("Unable to open file for outgoing logging");
224    owl_free(tobuff);
225    return;
226  }
227  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
228  if (text[strlen(text)-1]!='\n') {
229    fprintf(file, "\n");
230  }
231  fclose(file);
232
233  owl_free(tobuff);
234}
235
236
237void owl_log_outgoing_aim(owl_message *m)
238{
239  FILE *file;
240  char filename[MAXPATHLEN], *logpath;
241  char *tobuff, *normalto, *text;
242
243  owl_function_debugmsg("owl_log_outgoing_aim: entering");
244
245  /* normalize and downcase the screenname */
246  normalto=owl_aim_normalize_screenname(owl_message_get_recipient(m));
247  downstr(normalto);
248  tobuff=owl_sprintf("aim:%s", normalto);
249  owl_free(normalto);
250
251  /* expand ~ in path names */
252  logpath = owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
253
254  text=owl_message_get_body(m);
255 
256  snprintf(filename, MAXPATHLEN, "%s/%s", logpath, tobuff);
257  file=fopen(filename, "a");
258  if (!file) {
259    owl_function_error("Unable to open file for outgoing logging");
260    owl_free(logpath);
261    owl_free(tobuff);
262    return;
263  }
264  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
265  if (text[strlen(text)-1]!='\n') {
266    fprintf(file, "\n");
267  }
268  fclose(file);
269
270  snprintf(filename, MAXPATHLEN, "%s/all", logpath);
271  owl_free(logpath);
272  file=fopen(filename, "a");
273  if (!file) {
274    owl_function_error("Unable to open file for outgoing logging");
275    owl_free(tobuff);
276    return;
277  }
278  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
279  if (text[strlen(text)-1]!='\n') {
280    fprintf(file, "\n");
281  }
282  fclose(file);
283
284  owl_free(tobuff);
285}
286
287void owl_log_outgoing_loopback(owl_message *m)
288{
289  FILE *file;
290  char filename[MAXPATHLEN], *logpath;
291  char *tobuff, *text;
292
293  tobuff=owl_sprintf("loopback");
294
295  /* expand ~ in path names */
296  logpath = owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
297
298  text=owl_message_get_body(m);
299
300  snprintf(filename, MAXPATHLEN, "%s/%s", logpath, tobuff);
301  file=fopen(filename, "a");
302  if (!file) {
303    owl_function_error("Unable to open file for outgoing logging");
304    owl_free(logpath);
305    owl_free(tobuff);
306    return;
307  }
308  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
309  if (text[strlen(text)-1]!='\n') {
310    fprintf(file, "\n");
311  }
312  fclose(file);
313
314  snprintf(filename, MAXPATHLEN, "%s/all", logpath);
315  owl_free(logpath);
316  file=fopen(filename, "a");
317  if (!file) {
318    owl_function_error("Unable to open file for outgoing logging");
319    owl_free(tobuff);
320    return;
321  }
322  fprintf(file, "OUTGOING (owl): %s\n%s\n", tobuff, text);
323  if (text[strlen(text)-1]!='\n') {
324    fprintf(file, "\n");
325  }
326  fclose(file);
327
328  owl_free(tobuff);
329}
330
331void owl_log_incoming(owl_message *m)
332{
333  FILE *file, *allfile;
334  char filename[MAXPATHLEN], allfilename[MAXPATHLEN], *logpath;
335  char *frombuff=NULL, *from=NULL, *zsig=NULL;
336  int len, ch, i, personal;
337
338  /* figure out if it's a "personal" message or not */
339  if (owl_message_is_type_zephyr(m)) {
340    if (owl_message_is_personal(m)) {
341      personal=1;
342    } else {
343      personal=0;
344    }
345  } else if (owl_message_is_type_jabber(m)) {
346          /* This needs to be fixed to handle groupchat */
347          char* msgtype = owl_message_get_attribute_value(m,"jtype");
348          if (msgtype && !strcmp(msgtype,"groupchat")) {
349                  personal =0;
350          } else {
351             personal=1;
352          }
353  } else {
354    if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
355      personal=1;
356    } else {
357      personal=0;
358    }
359  }
360
361 
362
363  if (owl_message_is_type_zephyr(m)) {
364    if (personal) {
365      from=frombuff=short_zuser(owl_message_get_sender(m));
366    } else {
367      from=frombuff=owl_strdup(owl_message_get_class(m));
368    }
369  } else if (owl_message_is_type_aim(m)) {
370    /* we do not yet handle chat rooms */
371    char *normalto;
372    normalto=owl_aim_normalize_screenname(owl_message_get_sender(m));
373    downstr(normalto);
374    from=frombuff=owl_sprintf("aim:%s", normalto);
375    owl_free(normalto);
376  } else if (owl_message_is_type_loopback(m)) {
377    from=frombuff=owl_strdup("loopback");
378  } else if (owl_message_is_type_jabber(m)) {
379    if (personal) {
380      from=frombuff=owl_sprintf("jabber:%s",owl_message_get_sender(m));
381    } else {
382      from=frombuff=owl_sprintf("jabber:%s",owl_message_get_recipient(m));
383    }
384  } else {
385    from=frombuff=owl_strdup("unknown");
386  }
387 
388  /* check for malicious sender formats */
389  len=strlen(frombuff);
390  if (len<1 || len>35) from="weird";
391  if (strchr(frombuff, '/')) from="weird";
392
393  ch=frombuff[0];
394  if (!isalnum(ch)) from="weird";
395
396  for (i=0; i<len; i++) {
397    if (frombuff[i]<'!' || frombuff[i]>='~') from="weird";
398  }
399
400  if (!strcmp(frombuff, ".") || !strcasecmp(frombuff, "..")) from="weird";
401
402  if (!personal) {
403    if (strcmp(from, "weird")) downstr(from);
404  }
405
406  /* create the filename (expanding ~ in path names) */
407  if (personal) {
408    logpath = owl_text_substitute(owl_global_get_logpath(&g), "~", owl_global_get_homedir(&g));
409    snprintf(filename, MAXPATHLEN, "%s/%s", logpath, from);
410    snprintf(allfilename, MAXPATHLEN, "%s/all", logpath);
411
412  } else {
413    logpath = owl_text_substitute(owl_global_get_classlogpath(&g), "~", owl_global_get_homedir(&g));
414    snprintf(filename, MAXPATHLEN, "%s/%s", logpath, from);
415  }
416  owl_free(logpath);
417 
418  file=fopen(filename, "a");
419  if (!file) {
420    owl_function_error("Unable to open file for incoming logging");
421    owl_free(frombuff);
422    return;
423  }
424
425  allfile=NULL;
426  if (personal) {
427    allfile=fopen(allfilename, "a");
428    if (!allfile) {
429      owl_function_error("Unable to open file for incoming logging");
430      owl_free(frombuff);
431      fclose(file);
432      return;
433    }
434  }
435
436  /* write to the main file */
437  if (owl_message_is_type_zephyr(m)) {
438    char *tmp;
439   
440    tmp=short_zuser(owl_message_get_sender(m));
441    fprintf(file, "Class: %s Instance: %s", owl_message_get_class(m), owl_message_get_instance(m));
442    if (strcmp(owl_message_get_opcode(m), "")) fprintf(file, " Opcode: %s", owl_message_get_opcode(m));
443    fprintf(file, "\n");
444    fprintf(file, "Time: %s Host: %s\n", owl_message_get_timestr(m), owl_message_get_hostname(m));
445    zsig=owl_message_get_zsig(m);
446    fprintf(file, "From: %s <%s>\n\n", zsig, tmp);
447    fprintf(file, "%s\n\n", owl_message_get_body(m));
448    owl_free(tmp);
449  } else if (owl_message_is_type_aim(m) && !owl_message_is_loginout(m)) {
450    fprintf(file, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
451    fprintf(file, "Time: %s\n\n", owl_message_get_timestr(m));
452    fprintf(file, "%s\n\n", owl_message_get_body(m));
453  } else if (owl_message_is_type_aim(m) && owl_message_is_loginout(m)) {
454    fprintf(file, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
455    fprintf(file, "Time: %s\n\n", owl_message_get_timestr(m));
456    if (owl_message_is_login(m)) fprintf(file, "LOGIN\n\n");
457    if (owl_message_is_logout(m)) fprintf(file, "LOGOUT\n\n");
458  } else if (owl_message_is_type_jabber(m)) {
459    fprintf(file, "From: <%s> To: <%s>\n",owl_message_get_sender(m), owl_message_get_recipient(m));
460    fprintf(file, "Time: %s\n\n", owl_message_get_timestr(m));
461    fprintf(file, "%s\n\n",owl_message_get_body(m));
462  }
463  else {
464    fprintf(file, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
465    fprintf(file, "Time: %s\n\n", owl_message_get_timestr(m));
466    fprintf(file, "%s\n\n", owl_message_get_body(m));
467  }
468
469  fclose(file);
470
471  /* if it's a personal message, also write to the 'all' file */
472  if (personal) {
473    if (owl_message_is_type_zephyr(m)) {
474      char *tmp;
475
476      tmp=short_zuser(owl_message_get_sender(m));
477      fprintf(allfile, "Class: %s Instance: %s", owl_message_get_class(m), owl_message_get_instance(m));
478      if (strcmp(owl_message_get_opcode(m), "")) fprintf(allfile, " Opcode: %s", owl_message_get_opcode(m));
479      fprintf(allfile, "\n");
480      fprintf(allfile, "Time: %s Host: %s\n", owl_message_get_timestr(m), owl_message_get_hostname(m));
481      fprintf(allfile, "From: %s <%s>\n\n", zsig, tmp);
482      fprintf(allfile, "%s\n\n", owl_message_get_body(m));
483      owl_free(tmp);
484    } else if (owl_message_is_type_aim(m) && !owl_message_is_loginout(m)) {
485      fprintf(allfile, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
486      fprintf(allfile, "Time: %s\n\n", owl_message_get_timestr(m));
487      fprintf(allfile, "%s\n\n", owl_message_get_body(m));
488    } else if (owl_message_is_type_aim(m) && owl_message_is_loginout(m)) {
489      fprintf(allfile, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
490      fprintf(allfile, "Time: %s\n\n", owl_message_get_timestr(m));
491      if (owl_message_is_login(m)) fprintf(allfile, "LOGIN\n\n");
492      if (owl_message_is_logout(m)) fprintf(allfile, "LOGOUT\n\n");
493    } else {
494      fprintf(allfile, "From: <%s> To: <%s>\n", owl_message_get_sender(m), owl_message_get_recipient(m));
495      fprintf(allfile, "Time: %s\n\n", owl_message_get_timestr(m));
496      fprintf(allfile, "%s\n\n", owl_message_get_body(m));
497    }
498    fclose(allfile);
499  }
500
501  owl_free(frombuff);
502}
Note: See TracBrowser for help on using the repository browser.