source: message.c @ 8fa9562

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