source: message.c @ 004d683

release-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since 004d683 was 4d86e06, checked in by Anders Kaseorg <andersk@mit.edu>, 12 years ago
Get rid of a whole bunch of useless casts. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
  • Property mode set to 100644
File size: 22.3 KB
Line 
1#include <stdlib.h>
2#include <unistd.h>
3#include <string.h>
4#include <sys/socket.h>
5#include <netdb.h>
6#include <sys/types.h>
7#include <sys/socket.h>
8#include <netinet/in.h>
9#include <arpa/inet.h>
10#include <time.h>
11#include "owl.h"
12
13static owl_fmtext_cache fmtext_cache[OWL_FMTEXT_CACHE_SIZE];
14static owl_fmtext_cache * fmtext_cache_next = fmtext_cache;
15
16void owl_message_init_fmtext_cache ()
17{
18    int i;
19    for(i = 0; i < OWL_FMTEXT_CACHE_SIZE; i++) {
20        owl_fmtext_init_null(&(fmtext_cache[i].fmtext));
21        fmtext_cache[i].message = NULL;
22    }
23}
24
25owl_fmtext_cache * owl_message_next_fmtext() /*noproto*/
26{
27    owl_fmtext_cache * f = fmtext_cache_next;
28    if(fmtext_cache_next->message != NULL) {
29        owl_message_invalidate_format(fmtext_cache_next->message);
30    }
31    fmtext_cache_next++;
32    if(fmtext_cache_next - fmtext_cache == OWL_FMTEXT_CACHE_SIZE)
33        fmtext_cache_next = fmtext_cache;
34    return f;
35}
36
37void owl_message_init(owl_message *m)
38{
39  m->id=owl_global_get_nextmsgid(&g);
40  owl_message_set_direction_none(m);
41  m->delete=0;
42
43  owl_message_set_hostname(m, "");
44  owl_list_create(&(m->attributes));
45 
46  /* save the time */
47  m->time=time(NULL);
48  m->timestr=owl_strdup(ctime(&(m->time)));
49  m->timestr[strlen(m->timestr)-1]='\0';
50
51  m->fmtext = NULL;
52}
53
54/* add the named attribute to the message.  If an attribute with the
55 * name already exists, replace the old value with the new value
56 */
57void owl_message_set_attribute(owl_message *m, char *attrname, const char *attrvalue)
58{
59  int i, j;
60  owl_pair *p = NULL, *pair = NULL;
61
62  /* look for an existing pair with this key, */
63  j=owl_list_get_size(&(m->attributes));
64  for (i=0; i<j; i++) {
65    p=owl_list_get_element(&(m->attributes), i);
66    if (!strcmp(owl_pair_get_key(p), attrname)) {
67      owl_free(owl_pair_get_value(p));
68      pair = p;
69      break;
70    }
71  }
72
73  if(pair ==  NULL) {
74    pair = owl_malloc(sizeof(owl_pair));
75    owl_pair_create(pair, owl_global_intern(&g, attrname), NULL);
76    owl_list_append_element(&(m->attributes), pair);
77  }
78  owl_pair_set_value(pair, owl_validate_or_convert(attrvalue));
79}
80
81/* return the value associated with the named attribute, or NULL if
82 * the attribute does not exist
83 */
84char *owl_message_get_attribute_value(owl_message *m, char *attrname)
85{
86  int i, j;
87  owl_pair *p;
88
89  j=owl_list_get_size(&(m->attributes));
90  for (i=0; i<j; i++) {
91    p=owl_list_get_element(&(m->attributes), i);
92    if (!strcmp(owl_pair_get_key(p), attrname)) {
93      return(owl_pair_get_value(p));
94    }
95  }
96
97  /*
98  owl_function_debugmsg("No attribute %s found for message %i",
99                        attrname,
100                        owl_message_get_id(m));
101  */
102  return(NULL);
103}
104
105/* We cheat and indent it for now, since we really want this for
106 * the 'info' function.  Later there should just be a generic
107 * function to indent fmtext.
108 */
109void owl_message_attributes_tofmtext(owl_message *m, owl_fmtext *fm) {
110  int i, j;
111  owl_pair *p;
112  char *buff;
113
114  owl_fmtext_init_null(fm);
115
116  j=owl_list_get_size(&(m->attributes));
117  for (i=0; i<j; i++) {
118    p=owl_list_get_element(&(m->attributes), i);
119    buff=owl_sprintf("  %-15.15s: %-35.35s\n", owl_pair_get_key(p), owl_pair_get_value(p));
120    if(buff == NULL) {
121      buff=owl_sprintf("  %-15.15s: %-35.35s\n", owl_pair_get_key(p), "<error>");
122      if(buff == NULL)
123        buff=owl_strdup("   <error>\n");
124    }
125    owl_fmtext_append_normal(fm, buff);
126    owl_free(buff);
127  }
128}
129
130void owl_message_invalidate_format(owl_message *m)
131{
132  if(m->fmtext) {
133    m->fmtext->message = NULL;
134    owl_fmtext_clear(&(m->fmtext->fmtext));
135    m->fmtext=NULL;
136  }
137}
138
139owl_fmtext *owl_message_get_fmtext(owl_message *m)
140{
141  owl_message_format(m);
142  return(&(m->fmtext->fmtext));
143}
144
145void owl_message_format(owl_message *m)
146{
147  owl_style *s;
148  owl_view *v;
149
150  if (!m->fmtext) {
151    m->fmtext = owl_message_next_fmtext();
152    m->fmtext->message = m;
153    /* for now we assume there's just the one view and use that style */
154    v=owl_global_get_current_view(&g);
155    s=owl_view_get_style(v);
156
157    owl_style_get_formattext(s, &(m->fmtext->fmtext), m);
158  }
159}
160
161void owl_message_set_class(owl_message *m, char *class)
162{
163  owl_message_set_attribute(m, "class", class);
164}
165
166char *owl_message_get_class(owl_message *m)
167{
168  char *class;
169
170  class=owl_message_get_attribute_value(m, "class");
171  if (!class) return("");
172  return(class);
173}
174
175void owl_message_set_instance(owl_message *m, char *inst)
176{
177  owl_message_set_attribute(m, "instance", inst);
178}
179
180char *owl_message_get_instance(owl_message *m)
181{
182  char *instance;
183
184  instance=owl_message_get_attribute_value(m, "instance");
185  if (!instance) return("");
186  return(instance);
187}
188
189void owl_message_set_sender(owl_message *m, char *sender)
190{
191  owl_message_set_attribute(m, "sender", sender);
192}
193
194char *owl_message_get_sender(owl_message *m)
195{
196  char *sender;
197
198  sender=owl_message_get_attribute_value(m, "sender");
199  if (!sender) return("");
200  return(sender);
201}
202
203void owl_message_set_zsig(owl_message *m, char *zsig)
204{
205  owl_message_set_attribute(m, "zsig", zsig);
206}
207
208char *owl_message_get_zsig(owl_message *m)
209{
210  char *zsig;
211
212  zsig=owl_message_get_attribute_value(m, "zsig");
213  if (!zsig) return("");
214  return(zsig);
215}
216
217void owl_message_set_recipient(owl_message *m, char *recip)
218{
219  owl_message_set_attribute(m, "recipient", recip);
220}
221
222char *owl_message_get_recipient(owl_message *m)
223{
224  /* this is stupid for outgoing messages, we need to fix it. */
225
226  char *recip;
227
228  recip=owl_message_get_attribute_value(m, "recipient");
229  if (!recip) return("");
230  return(recip);
231}
232
233void owl_message_set_realm(owl_message *m, const char *realm)
234{
235  owl_message_set_attribute(m, "realm", realm);
236}
237
238char *owl_message_get_realm(owl_message *m)
239{
240  char *realm;
241 
242  realm=owl_message_get_attribute_value(m, "realm");
243  if (!realm) return("");
244  return(realm);
245}
246
247void owl_message_set_body(owl_message *m, char *body)
248{
249  owl_message_set_attribute(m, "body", body);
250}
251
252char *owl_message_get_body(owl_message *m)
253{
254  char *body;
255
256  body=owl_message_get_attribute_value(m, "body");
257  if (!body) return("");
258  return(body);
259}
260
261
262void owl_message_set_opcode(owl_message *m, char *opcode)
263{
264  owl_message_set_attribute(m, "opcode", opcode);
265}
266
267char *owl_message_get_opcode(owl_message *m)
268{
269  char *opcode;
270
271  opcode=owl_message_get_attribute_value(m, "opcode");
272  if (!opcode) return("");
273  return(opcode);
274}
275
276
277void owl_message_set_islogin(owl_message *m)
278{
279  owl_message_set_attribute(m, "loginout", "login");
280}
281
282
283void owl_message_set_islogout(owl_message *m)
284{
285  owl_message_set_attribute(m, "loginout", "logout");
286}
287
288int owl_message_is_loginout(owl_message *m)
289{
290  char *res;
291
292  res=owl_message_get_attribute_value(m, "loginout");
293  if (!res) return(0);
294  return(1);
295}
296
297int owl_message_is_login(owl_message *m)
298{
299  char *res;
300
301  res=owl_message_get_attribute_value(m, "loginout");
302  if (!res) return(0);
303  if (!strcmp(res, "login")) return(1);
304  return(0);
305}
306
307
308int owl_message_is_logout(owl_message *m)
309{
310  char *res;
311
312  res=owl_message_get_attribute_value(m, "loginout");
313  if (!res) return(0);
314  if (!strcmp(res, "logout")) return(1);
315  return(0);
316}
317
318void owl_message_set_isprivate(owl_message *m)
319{
320  owl_message_set_attribute(m, "isprivate", "true");
321}
322
323int owl_message_is_private(owl_message *m)
324{
325  char *res;
326
327  res=owl_message_get_attribute_value(m, "isprivate");
328  if (!res) return(0);
329  return !strcmp(res, "true");
330}
331
332char *owl_message_get_timestr(owl_message *m)
333{
334  if (m->timestr) return(m->timestr);
335  return("");
336}
337
338void owl_message_set_type_admin(owl_message *m)
339{
340  owl_message_set_attribute(m, "type", "admin");
341}
342
343void owl_message_set_type_loopback(owl_message *m)
344{
345  owl_message_set_attribute(m, "type", "loopback");
346}
347
348void owl_message_set_type_zephyr(owl_message *m)
349{
350  owl_message_set_attribute(m, "type", "zephyr");
351}
352
353void owl_message_set_type_aim(owl_message *m)
354{
355  owl_message_set_attribute(m, "type", "AIM");
356}
357
358void owl_message_set_type(owl_message *m, char* type)
359{
360  owl_message_set_attribute(m, "type", type);
361}
362
363int owl_message_is_type(owl_message *m, char *type) {
364  char * t = owl_message_get_attribute_value(m, "type");
365  if(!t) return 0;
366  return !strcasecmp(t, type);
367}
368                                               
369int owl_message_is_type_admin(owl_message *m)
370{
371  return owl_message_is_type(m, "admin");
372}
373
374int owl_message_is_type_zephyr(owl_message *m)
375{
376  return owl_message_is_type(m, "zephyr");
377}
378
379int owl_message_is_type_aim(owl_message *m)
380{
381  return owl_message_is_type(m, "aim");
382}
383
384/* XXX TODO: deprecate this */
385int owl_message_is_type_jabber(owl_message *m)
386{
387  return owl_message_is_type(m, "jabber");
388}
389
390int owl_message_is_type_loopback(owl_message *m)
391{
392  return owl_message_is_type(m, "loopback");
393}
394
395int owl_message_is_pseudo(owl_message *m)
396{
397  if (owl_message_get_attribute_value(m, "pseudo")) return(1);
398  return(0);
399}
400
401char *owl_message_get_text(owl_message *m)
402{
403  owl_message_format(m);
404  return(owl_fmtext_get_text(&(m->fmtext->fmtext)));
405}
406
407void owl_message_set_direction_in(owl_message *m)
408{
409  m->direction=OWL_MESSAGE_DIRECTION_IN;
410}
411
412void owl_message_set_direction_out(owl_message *m)
413{
414  m->direction=OWL_MESSAGE_DIRECTION_OUT;
415}
416
417void owl_message_set_direction_none(owl_message *m)
418{
419  m->direction=OWL_MESSAGE_DIRECTION_NONE;
420}
421
422void owl_message_set_direction(owl_message *m, int direction)
423{
424  m->direction=direction;
425}
426
427int owl_message_is_direction_in(owl_message *m)
428{
429  if (m->direction==OWL_MESSAGE_DIRECTION_IN) return(1);
430  return(0);
431}
432
433int owl_message_is_direction_out(owl_message *m)
434{
435  if (m->direction==OWL_MESSAGE_DIRECTION_OUT) return(1);
436  return(0);
437}
438
439int owl_message_is_direction_none(owl_message *m)
440{
441  if (m->direction==OWL_MESSAGE_DIRECTION_NONE) return(1);
442  return(0);
443}
444
445int owl_message_get_numlines(owl_message *m)
446{
447  if (m == NULL) return(0);
448  owl_message_format(m);
449  return(owl_fmtext_num_lines(&(m->fmtext->fmtext)));
450}
451
452void owl_message_mark_delete(owl_message *m)
453{
454  if (m == NULL) return;
455  m->delete=1;
456}
457
458void owl_message_unmark_delete(owl_message *m)
459{
460  if (m == NULL) return;
461  m->delete=0;
462}
463
464char *owl_message_get_zwriteline(owl_message *m)
465{
466  char *z = owl_message_get_attribute_value(m, "zwriteline");
467  if (!z) return "";
468  return z;
469}
470
471void owl_message_set_zwriteline(owl_message *m, char *line)
472{
473  owl_message_set_attribute(m, "zwriteline", line);
474}
475
476int owl_message_is_delete(owl_message *m)
477{
478  if (m == NULL) return(0);
479  if (m->delete==1) return(1);
480  return(0);
481}
482
483#ifdef HAVE_LIBZEPHYR
484ZNotice_t *owl_message_get_notice(owl_message *m)
485{
486  return(&(m->notice));
487}
488#else
489void *owl_message_get_notice(owl_message *m)
490{
491  return(NULL);
492}
493#endif
494
495void owl_message_set_hostname(owl_message *m, char *hostname)
496{
497  m->hostname=owl_global_intern(&g, hostname);
498}
499
500char *owl_message_get_hostname(owl_message *m)
501{
502  return(m->hostname);
503}
504
505void owl_message_curs_waddstr(owl_message *m, WINDOW *win, int aline, int bline, int acol, int bcol, int fgcolor, int bgcolor)
506{
507  owl_fmtext a, b;
508
509  /* this will ensure that our cached copy is up to date */
510  owl_message_format(m);
511
512  owl_fmtext_init_null(&a);
513  owl_fmtext_init_null(&b);
514 
515  owl_fmtext_truncate_lines(&(m->fmtext->fmtext), aline, bline-aline, &a);
516  owl_fmtext_truncate_cols(&a, acol, bcol, &b);
517  owl_fmtext_colorize(&b, fgcolor);
518  owl_fmtext_colorizebg(&b, bgcolor);
519
520  owl_fmtext_curs_waddstr(&b, win);
521
522  owl_fmtext_free(&a);
523  owl_fmtext_free(&b);
524}
525
526int owl_message_is_personal(owl_message *m)
527{
528  owl_filter * f = owl_global_get_filter(&g, "personal");
529  if(!f) {
530      owl_function_error("personal filter is not defined");
531      return (0);
532  }
533  return owl_filter_message_match(f, m);
534}
535
536int owl_message_is_question(owl_message *m)
537{
538  if(!owl_message_is_type_admin(m)) return 0;
539  if(owl_message_get_attribute_value(m, "question") != NULL) return 1;
540  return 0;
541}
542
543int owl_message_is_answered(owl_message *m) {
544  char *q;
545  if(!owl_message_is_question(m)) return 0;
546  q = owl_message_get_attribute_value(m, "question");
547  if(!q) return 0;
548  return !strcmp(q, "answered");
549}
550
551void owl_message_set_isanswered(owl_message *m) {
552  owl_message_set_attribute(m, "question", "answered");
553}
554
555int owl_message_is_mail(owl_message *m)
556{
557  if (owl_message_is_type_zephyr(m)) {
558    if (!strcasecmp(owl_message_get_class(m), "mail") && owl_message_is_private(m)) {
559      return(1);
560    } else {
561      return(0);
562    }
563  }
564  return(0);
565}
566
567/* caller must free return value. */
568char *owl_message_get_cc(owl_message *m)
569{
570  char *cur, *out, *end;
571
572  cur = owl_message_get_body(m);
573  while (*cur && *cur==' ') cur++;
574  if (strncasecmp(cur, "cc:", 3)) return(NULL);
575  cur+=3;
576  while (*cur && *cur==' ') cur++;
577  out = owl_strdup(cur);
578  end = strchr(out, '\n');
579  if (end) end[0] = '\0';
580  return(out);
581}
582
583/* caller must free return value */
584char *owl_message_get_cc_without_recipient(owl_message *m)
585{
586  char *cc, *out, *end, *user, *shortuser, *recip;
587
588  cc = owl_message_get_cc(m);
589  if (cc == NULL)
590    return NULL;
591
592  recip = short_zuser(owl_message_get_recipient(m));
593  out = owl_malloc(strlen(cc));
594  end = out;
595
596  user = strtok(cc, " ");
597  while (user != NULL) {
598    shortuser = short_zuser(user);
599    if (strcasecmp(shortuser, recip) != 0) {
600      strcpy(end, user);
601      end[strlen(user)] = ' ';
602      end += strlen(user) + 1;
603    }
604    free(shortuser);
605    user = strtok(NULL, " ");
606  }
607  end[0] = '\0';
608
609  owl_free(recip);
610  owl_free(cc);
611
612  if (strlen(out) == 0) {
613    owl_free(out);
614    out = NULL;
615  }
616
617  return(out);
618}
619
620int owl_message_get_id(owl_message *m)
621{
622  return(m->id);
623}
624
625char *owl_message_get_type(owl_message *m) {
626  char * type = owl_message_get_attribute_value(m, "type");
627  if(!type) {
628    return "generic";
629  }
630  return type;
631}
632
633char *owl_message_get_direction(owl_message *m) {
634  switch (m->direction) {
635  case OWL_MESSAGE_DIRECTION_IN:
636    return("in");
637  case OWL_MESSAGE_DIRECTION_OUT:
638    return("out");
639  case OWL_MESSAGE_DIRECTION_NONE:
640    return("none");
641  default:
642    return("unknown");
643  }
644}
645
646int owl_message_parse_direction(char *d) {
647  if(!strcmp(d, "in")) {
648    return OWL_MESSAGE_DIRECTION_IN;
649  } else if(!strcmp(d, "out")) {
650    return OWL_MESSAGE_DIRECTION_OUT;
651  } else {
652    return OWL_MESSAGE_DIRECTION_NONE;
653  }
654}
655
656
657char *owl_message_get_login(owl_message *m) {
658  if (owl_message_is_login(m)) {
659    return "login";
660  } else if (owl_message_is_logout(m)) {
661    return "logout";
662  } else {
663    return "none";
664  }
665}
666
667
668char *owl_message_get_header(owl_message *m) {
669  return owl_message_get_attribute_value(m, "adminheader");
670}
671
672/* return 1 if the message contains "string", 0 otherwise.  This is
673 * case insensitive because the functions it uses are
674 */
675int owl_message_search(owl_message *m, char *string)
676{
677
678  owl_message_format(m); /* is this necessary? */
679 
680  return (owl_fmtext_search(&(m->fmtext->fmtext), string));
681}
682
683
684/* if loginout == -1 it's a logout message
685 *                 0 it's not a login/logout message
686 *                 1 it's a login message
687 */
688void owl_message_create_aim(owl_message *m, char *sender, char *recipient, char *text, int direction, int loginout)
689{
690  owl_message_init(m);
691  owl_message_set_body(m, text);
692  owl_message_set_sender(m, sender);
693  owl_message_set_recipient(m, recipient);
694  owl_message_set_type_aim(m);
695
696  if (direction==OWL_MESSAGE_DIRECTION_IN) {
697    owl_message_set_direction_in(m);
698  } else if (direction==OWL_MESSAGE_DIRECTION_OUT) {
699    owl_message_set_direction_out(m);
700  }
701
702  /* for now all messages that aren't loginout are private */
703  if (!loginout) {
704    owl_message_set_isprivate(m);
705  }
706
707  if (loginout==-1) {
708    owl_message_set_islogout(m);
709  } else if (loginout==1) {
710    owl_message_set_islogin(m);
711  }
712}
713
714void owl_message_create_admin(owl_message *m, char *header, char *text)
715{
716  owl_message_init(m);
717  owl_message_set_type_admin(m);
718  owl_message_set_body(m, text);
719  owl_message_set_attribute(m, "adminheader", header); /* just a hack for now */
720}
721
722/* caller should set the direction */
723void owl_message_create_loopback(owl_message *m, char *text)
724{
725  owl_message_init(m);
726  owl_message_set_type_loopback(m);
727  owl_message_set_body(m, text);
728  owl_message_set_sender(m, "loopsender");
729  owl_message_set_recipient(m, "looprecip");
730  owl_message_set_isprivate(m);
731}
732
733#ifdef HAVE_LIBZEPHYR
734void owl_message_create_from_znotice(owl_message *m, ZNotice_t *n)
735{
736  struct hostent *hent;
737  char *ptr, *tmp, *tmp2;
738  int len;
739
740  owl_message_init(m);
741 
742  owl_message_set_type_zephyr(m);
743  owl_message_set_direction_in(m);
744 
745  /* first save the full notice */
746  memcpy(&(m->notice), n, sizeof(ZNotice_t));
747
748  /* a little gross, we'll replace \r's with ' ' for now */
749  owl_zephyr_hackaway_cr(&(m->notice));
750 
751  /* save the time, we need to nuke the string saved by message_init */
752  if (m->timestr) owl_free(m->timestr);
753  m->time=n->z_time.tv_sec;
754  m->timestr=owl_strdup(ctime(&(m->time)));
755  m->timestr[strlen(m->timestr)-1]='\0';
756
757  /* set other info */
758  owl_message_set_sender(m, n->z_sender);
759  owl_message_set_class(m, n->z_class);
760  owl_message_set_instance(m, n->z_class_inst);
761  owl_message_set_recipient(m, n->z_recipient);
762  if (n->z_opcode) {
763    owl_message_set_opcode(m, n->z_opcode);
764  } else {
765    owl_message_set_opcode(m, "");
766  }
767  owl_message_set_zsig(m, owl_zephyr_get_zsig(n, &len));
768
769  if ((ptr=strchr(n->z_recipient, '@'))!=NULL) {
770    owl_message_set_realm(m, ptr+1);
771  } else {
772    owl_message_set_realm(m, owl_zephyr_get_realm());
773  }
774
775  /* Set the "isloginout" attribute if it's a login message */
776  if (!strcasecmp(n->z_class, "login") || !strcasecmp(n->z_class, OWL_WEBZEPHYR_CLASS)) {
777    if (!strcasecmp(n->z_opcode, "user_login") || !strcasecmp(n->z_opcode, "user_logout")) {
778      tmp=owl_zephyr_get_field(n, 1);
779      owl_message_set_attribute(m, "loginhost", tmp);
780      owl_free(tmp);
781
782      tmp=owl_zephyr_get_field(n, 3);
783      owl_message_set_attribute(m, "logintty", tmp);
784      owl_free(tmp);
785    }
786
787    if (!strcasecmp(n->z_opcode, "user_login")) {
788      owl_message_set_islogin(m);
789    } else if (!strcasecmp(n->z_opcode, "user_logout")) {
790      owl_message_set_islogout(m);
791    }
792  }
793
794 
795  /* set the "isprivate" attribute if it's a private zephyr.
796   ``private'' means recipient is non-empty and doesn't start wit
797   `@' */
798  if (*n->z_recipient && *n->z_recipient != '@') {
799    owl_message_set_isprivate(m);
800  }
801
802  /* set the "isauto" attribute if it's an autoreply */
803  if (!strcasecmp(n->z_message, "Automated reply:") ||
804      !strcasecmp(n->z_opcode, "auto")) {
805    owl_message_set_attribute(m, "isauto", "");
806  }
807
808  /* save the hostname */
809  owl_function_debugmsg("About to do gethostbyaddr");
810  hent=gethostbyaddr(&(n->z_uid.zuid_addr), sizeof(n->z_uid.zuid_addr), AF_INET);
811  if (hent && hent->h_name) {
812    owl_message_set_hostname(m, hent->h_name);
813  } else {
814    owl_message_set_hostname(m, inet_ntoa(n->z_sender_addr));
815  }
816
817  /* set the body */
818  tmp=owl_zephyr_get_message(n, m);
819  if (owl_global_is_newlinestrip(&g)) {
820    tmp2=owl_util_stripnewlines(tmp);
821    owl_message_set_body(m, tmp2);
822    owl_free(tmp2);
823  } else {
824    owl_message_set_body(m, tmp);
825  }
826  owl_free(tmp);
827
828#ifdef OWL_ENABLE_ZCRYPT
829  /* if zcrypt is enabled try to decrypt the message */
830  if (owl_global_is_zcrypt(&g) && !strcasecmp(n->z_opcode, "crypt")) {
831    char *out;
832    int ret;
833
834    out=owl_malloc(strlen(owl_message_get_body(m))*16+20);
835    ret=owl_zcrypt_decrypt(out, owl_message_get_body(m), owl_message_get_class(m), owl_message_get_instance(m));
836    if (ret==0) {
837      owl_message_set_body(m, out);
838    } else {
839      owl_free(out);
840    }
841  }
842#endif 
843}
844#else
845void owl_message_create_from_znotice(owl_message *m, void *n)
846{
847}
848#endif
849
850/* If 'direction' is '0' it is a login message, '1' is a logout message. */
851void owl_message_create_pseudo_zlogin(owl_message *m, int direction, char *user, char *host, char *time, char *tty)
852{
853  char *longuser, *ptr;
854
855#ifdef HAVE_LIBZEPHYR
856  memset(&(m->notice), 0, sizeof(ZNotice_t));
857#endif
858 
859  longuser=long_zuser(user);
860 
861  owl_message_init(m);
862 
863  owl_message_set_type_zephyr(m);
864  owl_message_set_direction_in(m);
865
866  owl_message_set_attribute(m, "pseudo", "");
867  owl_message_set_attribute(m, "loginhost", host ? host : "");
868  owl_message_set_attribute(m, "logintty", tty ? tty : "");
869
870  owl_message_set_sender(m, longuser);
871  owl_message_set_class(m, "LOGIN");
872  owl_message_set_instance(m, longuser);
873  owl_message_set_recipient(m, "");
874  if (direction==0) {
875    owl_message_set_opcode(m, "USER_LOGIN");
876    owl_message_set_islogin(m);
877  } else if (direction==1) {
878    owl_message_set_opcode(m, "USER_LOGOUT");
879    owl_message_set_islogout(m);
880  }
881
882  if ((ptr=strchr(longuser, '@'))!=NULL) {
883    owl_message_set_realm(m, ptr+1);
884  } else {
885    owl_message_set_realm(m, owl_zephyr_get_realm());
886  }
887
888  owl_message_set_body(m, "<uninitialized>");
889
890  /* save the hostname */
891  owl_function_debugmsg("create_pseudo_login: host is %s", host ? host : "");
892  owl_message_set_hostname(m, host ? host : "");
893  owl_free(longuser);
894}
895
896void owl_message_create_from_zwriteline(owl_message *m, char *line, char *body, char *zsig)
897{
898  owl_zwrite z;
899  int ret;
900  char hostbuff[5000];
901 
902  owl_message_init(m);
903
904  /* create a zwrite for the purpose of filling in other message fields */
905  owl_zwrite_create_from_line(&z, line);
906
907  /* set things */
908  owl_message_set_direction_out(m);
909  owl_message_set_type_zephyr(m);
910  owl_message_set_sender(m, owl_zephyr_get_sender());
911  owl_message_set_class(m, owl_zwrite_get_class(&z));
912  owl_message_set_instance(m, owl_zwrite_get_instance(&z));
913  if (owl_zwrite_get_numrecips(&z)>0) {
914    char *longzuser = long_zuser(owl_zwrite_get_recip_n(&z, 0));
915    owl_message_set_recipient(m,
916                              longzuser); /* only gets the first user, must fix */
917    owl_free(longzuser);
918  }
919  owl_message_set_opcode(m, owl_zwrite_get_opcode(&z));
920  owl_message_set_realm(m, owl_zwrite_get_realm(&z)); /* also a hack, but not here */
921  owl_message_set_zwriteline(m, line);
922  owl_message_set_body(m, body);
923  owl_message_set_zsig(m, zsig);
924 
925  /* save the hostname */
926  ret=gethostname(hostbuff, MAXHOSTNAMELEN);
927  hostbuff[MAXHOSTNAMELEN]='\0';
928  if (ret) {
929    owl_message_set_hostname(m, "localhost");
930  } else {
931    owl_message_set_hostname(m, hostbuff);
932  }
933
934  /* set the "isprivate" attribute if it's a private zephyr. */
935  if (owl_zwrite_is_personal(&z)) {
936    owl_message_set_isprivate(m);
937  }
938
939  owl_zwrite_free(&z);
940}
941
942void owl_message_free(owl_message *m)
943{
944  int i, j;
945  owl_pair *p;
946#ifdef HAVE_LIBZEPHYR   
947  if (owl_message_is_type_zephyr(m) && owl_message_is_direction_in(m)) {
948    ZFreeNotice(&(m->notice));
949  }
950#endif
951  if (m->timestr) owl_free(m->timestr);
952
953  /* free all the attributes */
954  j=owl_list_get_size(&(m->attributes));
955  for (i=0; i<j; i++) {
956    p=owl_list_get_element(&(m->attributes), i);
957    owl_free(owl_pair_get_value(p));
958    owl_free(p);
959  }
960
961  owl_list_free_simple(&(m->attributes));
962 
963  owl_message_invalidate_format(m);
964}
Note: See TracBrowser for help on using the repository browser.