source: functions.c @ 3895e23

barnowl_perlaimdebianowlrelease-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since 3895e23 was 3895e23, checked in by James M. Kretchmar <kretch@mit.edu>, 17 years ago
The '!' key (bound to 'view -r') now creates a negative version of the current view and switches to it. i.e. "show me all the messages that are not these"
  • Property mode set to 100644
File size: 92.1 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <signal.h>
5#include <string.h>
6#include <time.h>
7#include <sys/types.h>
8#include <sys/stat.h>
9#include <sys/wait.h>
10#include <errno.h>
11#include <signal.h>
12#include "owl.h"
13
14static const char fileIdent[] = "$Id$";
15
16void owl_function_noop(void)
17{
18  return;
19}
20
21char *owl_function_command(char *cmdbuff)
22{
23  owl_function_debugmsg("executing command: %s", cmdbuff);
24  return owl_cmddict_execute(owl_global_get_cmddict(&g), 
25                             owl_global_get_context(&g), cmdbuff);
26}
27
28void owl_function_command_norv(char *cmdbuff)
29{
30  char *rv;
31  rv=owl_function_command(cmdbuff);
32  if (rv) owl_free(rv);
33}
34
35void owl_function_command_alias(char *alias_from, char *alias_to)
36{
37  owl_cmddict_add_alias(owl_global_get_cmddict(&g), alias_from, alias_to);
38}
39
40owl_cmd *owl_function_get_cmd(char *name)
41{
42  return owl_cmddict_find(owl_global_get_cmddict(&g), name);
43}
44
45void owl_function_show_commands()
46{
47  owl_list l;
48  owl_fmtext fm;
49
50  owl_fmtext_init_null(&fm);
51  owl_fmtext_append_bold(&fm, "Commands:  ");
52  owl_fmtext_append_normal(&fm, "(use 'show command <name>' for details)\n");
53  owl_cmddict_get_names(owl_global_get_cmddict(&g), &l);
54  owl_fmtext_append_list(&fm, &l, "\n", owl_function_cmd_describe);
55  owl_fmtext_append_normal(&fm, "\n");
56  owl_function_popless_fmtext(&fm);
57  owl_cmddict_namelist_free(&l);
58  owl_fmtext_free(&fm);
59}
60
61void owl_function_show_view(char *viewname)
62{
63  owl_view *v;
64  owl_fmtext fm;
65
66  /* we only have the one view right now */
67  v=owl_global_get_current_view(&g);
68  if (viewname && strcmp(viewname, owl_view_get_name(v))) {
69    owl_function_error("No view named '%s'", viewname);
70    return;
71  }
72
73  owl_fmtext_init_null(&fm);
74  owl_view_to_fmtext(v, &fm);
75  owl_function_popless_fmtext(&fm);
76  owl_fmtext_free(&fm);
77}
78
79void owl_function_show_styles() {
80  owl_list l;
81  owl_fmtext fm;
82
83  owl_fmtext_init_null(&fm);
84  owl_fmtext_append_bold(&fm, "Styles:\n");
85  owl_global_get_style_names(&g, &l);
86  owl_fmtext_append_list(&fm, &l, "\n", owl_function_style_describe);
87  owl_fmtext_append_normal(&fm, "\n");
88  owl_function_popless_fmtext(&fm);
89  owl_list_free_all(&l, owl_free);
90  owl_fmtext_free(&fm);
91}
92
93char *owl_function_style_describe(void *name) {
94  char *desc, *s;
95  owl_style *style;
96  style = owl_global_get_style_by_name(&g, name);
97  if (style) {
98    desc = owl_style_get_description(style);
99  } else {
100    desc = "???";
101  }
102  s = owl_sprintf("%-20s - %s%s", name, 
103                  0==owl_style_validate(style)?"":"[INVALID] ",
104                  desc);
105  return s;
106}
107
108char *owl_function_cmd_describe(void *name)
109{
110  owl_cmd *cmd = owl_cmddict_find(owl_global_get_cmddict(&g), name);
111  if (cmd) return owl_cmd_describe(cmd);
112  else return(NULL);
113}
114
115void owl_function_show_command(char *name)
116{
117  owl_function_help_for_command(name);
118}
119
120void owl_function_adminmsg(char *header, char *body)
121{
122  owl_message *m;
123  int followlast;
124
125  followlast=owl_global_should_followlast(&g);
126  m=owl_malloc(sizeof(owl_message));
127  owl_message_create_admin(m, header, body);
128  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
129  owl_view_consider_message(owl_global_get_current_view(&g), m);
130
131  if (followlast) owl_function_lastmsg_noredisplay();
132
133  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
134  if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
135    owl_popwin_refresh(owl_global_get_popwin(&g));
136  }
137 
138  wnoutrefresh(owl_global_get_curs_recwin(&g));
139  owl_global_set_needrefresh(&g);
140}
141
142void owl_function_make_outgoing_zephyr(char *body, char *zwriteline, char *zsig)
143{
144  owl_message *m;
145  int followlast;
146  owl_zwrite z;
147 
148  followlast=owl_global_should_followlast(&g);
149
150  /* create a zwrite for the purpose of filling in other message fields */
151  owl_zwrite_create_from_line(&z, zwriteline);
152
153  /* create the message */
154  m=owl_malloc(sizeof(owl_message));
155  owl_message_create_from_zwriteline(m, zwriteline, body, zsig);
156
157  /* add it to the global list and current view */
158  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
159  owl_view_consider_message(owl_global_get_current_view(&g), m);
160
161  if (followlast) owl_function_lastmsg_noredisplay();
162
163  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
164  if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
165    owl_popwin_refresh(owl_global_get_popwin(&g));
166  }
167 
168  wnoutrefresh(owl_global_get_curs_recwin(&g));
169  owl_global_set_needrefresh(&g);
170  owl_zwrite_free(&z);
171}
172
173int owl_function_make_outgoing_aim(char *body, char *to)
174{
175  owl_message *m;
176  int followlast;
177
178
179  if (!owl_global_is_aimloggedin(&g)) {
180    return(-1);
181  }
182 
183  followlast=owl_global_should_followlast(&g);
184
185  /* create the message */
186  m=owl_malloc(sizeof(owl_message));
187  owl_message_create_aim(m,
188                         owl_global_get_aim_screenname(&g),
189                         to,
190                         body,
191                         OWL_MESSAGE_DIRECTION_OUT,
192                         0);
193
194  /* add it to the global list and current view */
195  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
196  owl_view_consider_message(owl_global_get_current_view(&g), m);
197
198  if (followlast) owl_function_lastmsg_noredisplay();
199
200  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
201  if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
202    owl_popwin_refresh(owl_global_get_popwin(&g));
203  }
204 
205  wnoutrefresh(owl_global_get_curs_recwin(&g));
206  owl_global_set_needrefresh(&g);
207  return(0);
208}
209
210int owl_function_make_outgoing_loopback(char *body)
211{
212  owl_message *m;
213  int followlast;
214
215  followlast=owl_global_should_followlast(&g);
216
217  /* create the message */
218  m=owl_malloc(sizeof(owl_message));
219  owl_message_create_loopback(m, body);
220  owl_message_set_direction_out(m);
221
222  /* add it to the global list and current view */
223  owl_messagelist_append_element(owl_global_get_msglist(&g), m);
224  owl_view_consider_message(owl_global_get_current_view(&g), m);
225
226  if (followlast) owl_function_lastmsg_noredisplay();
227
228  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
229  if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
230    owl_popwin_refresh(owl_global_get_popwin(&g));
231  }
232 
233  wnoutrefresh(owl_global_get_curs_recwin(&g));
234  owl_global_set_needrefresh(&g);
235  return(0);
236}
237
238void owl_function_zwrite_setup(char *line)
239{
240  owl_editwin *e;
241  char buff[1024];
242  owl_zwrite z;
243  int ret;
244
245  /* check the arguments */
246  ret=owl_zwrite_create_from_line(&z, line);
247  if (ret) {
248    owl_function_error("Error in zwrite arugments");
249    owl_zwrite_free(&z);
250    return;
251  }
252
253  /* send a ping if necessary */
254  if (owl_global_is_txping(&g)) {
255    owl_zwrite_send_ping(&z);
256  }
257  owl_zwrite_free(&z);
258
259  /* create and setup the editwin */
260  e=owl_global_get_typwin(&g);
261  owl_editwin_new_style(e, OWL_EDITWIN_STYLE_MULTILINE, owl_global_get_msg_history(&g));
262
263  if (!owl_global_get_lockout_ctrld(&g)) {
264    owl_function_makemsg("Type your zephyr below.  End with ^D or a dot on a line by itself.  ^C will quit.");
265  } else {
266    owl_function_makemsg("Type your zephyr below.  End with a dot on a line by itself.  ^C will quit.");
267  }
268
269  owl_editwin_clear(e);
270  owl_editwin_set_dotsend(e);
271  strcpy(buff, "----> ");
272  strcat(buff, line);
273  strcat(buff, "\n");
274  owl_editwin_set_locktext(e, buff);
275
276  /* make it active */
277  owl_global_set_typwin_active(&g);
278
279  owl_global_set_buffercommand(&g, line);
280}
281
282void owl_function_aimwrite_setup(char *line)
283{
284  owl_editwin *e;
285  char buff[1024];
286
287  /* check the arguments */
288
289  /* create and setup the editwin */
290  e=owl_global_get_typwin(&g);
291  owl_editwin_new_style(e, OWL_EDITWIN_STYLE_MULTILINE, owl_global_get_msg_history(&g));
292
293  if (!owl_global_get_lockout_ctrld(&g)) {
294    owl_function_makemsg("Type your message below.  End with ^D or a dot on a line by itself.  ^C will quit.");
295  } else {
296    owl_function_makemsg("Type your message below.  End with a dot on a line by itself.  ^C will quit.");
297  }
298
299  owl_editwin_clear(e);
300  owl_editwin_set_dotsend(e);
301  strcpy(buff, "----> ");
302  strcat(buff, line);
303  strcat(buff, "\n");
304  owl_editwin_set_locktext(e, buff);
305
306  /* make it active */
307  owl_global_set_typwin_active(&g);
308
309  owl_global_set_buffercommand(&g, line);
310}
311
312void owl_function_loopwrite_setup()
313{
314  owl_editwin *e;
315
316  /* create and setup the editwin */
317  e=owl_global_get_typwin(&g);
318  owl_editwin_new_style(e, OWL_EDITWIN_STYLE_MULTILINE, owl_global_get_msg_history(&g));
319
320  if (!owl_global_get_lockout_ctrld(&g)) {
321    owl_function_makemsg("Type your message below.  End with ^D or a dot on a line by itself.  ^C will quit.");
322  } else {
323    owl_function_makemsg("Type your message below.  End with a dot on a line by itself.  ^C will quit.");
324  }
325
326  owl_editwin_clear(e);
327  owl_editwin_set_dotsend(e);
328  owl_editwin_set_locktext(e, "----> loopwrite\n");
329
330  /* make it active */
331  owl_global_set_typwin_active(&g);
332
333  owl_global_set_buffercommand(&g, "loopwrite");
334}
335
336/* send, log and display an outgoing zephyr.  If 'msg' is NULL
337 * the message is expected to be set from the zwrite line itself
338 */
339void owl_function_zwrite(char *line, char *msg)
340{
341  owl_zwrite z;
342  int i, j;
343  char *mymsg;
344
345  /* create the zwrite and send the message */
346  owl_zwrite_create_from_line(&z, line);
347  if (msg) {
348    owl_zwrite_set_message(&z, msg);
349  }
350
351  owl_zwrite_send_message(&z);
352  owl_function_makemsg("Waiting for ack...");
353
354  mymsg=owl_zwrite_get_message(&z);
355
356  /* display the message as an outgoing message in the receive window */
357  if (owl_global_is_displayoutgoing(&g) && owl_zwrite_is_personal(&z)) {
358    owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
359  }
360
361  /* log it if we have logging turned on */
362  if (owl_global_is_logging(&g) && owl_zwrite_is_personal(&z)) {
363    j=owl_zwrite_get_numrecips(&z);
364    for (i=0; i<j; i++) {
365      owl_log_outgoing_zephyr(owl_zwrite_get_recip_n(&z, i), mymsg);
366    }
367  }
368
369  /* free the zwrite */
370  owl_zwrite_free(&z);
371}
372
373/* send, log and display an outgoing zcrypt zephyr.  If 'msg' is NULL
374 * the message is expected to be set from the zwrite line itself
375 */
376void owl_function_zcrypt(char *line, char *msg)
377{
378  owl_zwrite z;
379  int i, j;
380  char *mymsg;
381  char *cryptmsg;
382#ifdef OWL_ENABLE_ZCRYPT
383  int ret;
384#endif
385
386  /* create the zwrite and send the message */
387  owl_zwrite_create_from_line(&z, line);
388  if (msg) {
389    owl_zwrite_set_message(&z, msg);
390  }
391
392  mymsg=owl_zwrite_get_message(&z);
393#ifdef OWL_ENABLE_ZCRYPT
394  cryptmsg=owl_malloc(strlen(mymsg)*4);
395  ret=owl_zcrypt_encrypt(cryptmsg, mymsg, owl_zwrite_get_class(&z), owl_zwrite_get_instance(&z));
396  if (ret) {
397    owl_function_error("Error in zcrypt, possibly no key found.  Message not sent.");
398    owl_function_beep();
399    owl_free(cryptmsg);
400    return;
401  }
402#else
403  cryptmsg=owl_strdup(mymsg);
404#endif
405
406  owl_zwrite_set_message(&z, cryptmsg);
407  owl_zwrite_set_opcode(&z, "crypt");
408  mymsg=cryptmsg;
409   
410  owl_zwrite_send_message(&z);
411  owl_function_makemsg("Waiting for ack...");
412
413  /* display the message as an outgoing message in the receive window */
414  if (owl_global_is_displayoutgoing(&g) && owl_zwrite_is_personal(&z)) {
415    owl_function_make_outgoing_zephyr(mymsg, line, owl_zwrite_get_zsig(&z));
416  }
417
418  /* log it if we have logging turned on */
419  if (owl_global_is_logging(&g) && owl_zwrite_is_personal(&z)) {
420    j=owl_zwrite_get_numrecips(&z);
421    for (i=0; i<j; i++) {
422      owl_log_outgoing_zephyr(owl_zwrite_get_recip_n(&z, i), mymsg);
423    }
424  }
425
426  /* free the zwrite */
427  owl_free(cryptmsg);
428  owl_zwrite_free(&z);
429}
430
431void owl_function_aimwrite(char *to)
432{
433  int ret;
434  char *msg, *format_msg;
435
436  /* make a formatted copy of the message */
437  msg=owl_editwin_get_text(owl_global_get_typwin(&g));
438  format_msg=owl_strdup(msg);
439  owl_text_wordunwrap(format_msg);
440 
441  /* send the message */
442  ret=owl_aim_send_im(to, format_msg);
443  if (!ret) {
444    owl_function_makemsg("AIM message sent.");
445  } else {
446    owl_function_error("Could not send AIM message.");
447  }
448
449  /* display the message as an outgoing message in the receive window */
450  if (owl_global_is_displayoutgoing(&g)) {
451    owl_function_make_outgoing_aim(msg, to);
452  }
453
454  /* log it if we have logging turned on */
455  if (owl_global_is_logging(&g)) {
456    owl_log_outgoing_aim(to, msg);
457  }
458
459  owl_free(format_msg);
460}
461
462void owl_function_send_aimawymsg(char *to, char *msg)
463{
464  int ret;
465  char *format_msg;
466
467  /* make a formatted copy of the message */
468  format_msg=owl_strdup(msg);
469  owl_text_wordunwrap(format_msg);
470 
471  /* send the message */
472  ret=owl_aim_send_awaymsg(to, format_msg);
473  if (!ret) {
474    /* owl_function_makemsg("AIM message sent."); */
475  } else {
476    owl_function_error("Could not send AIM message.");
477  }
478
479  /* display the message as an outgoing message in the receive window */
480  if (owl_global_is_displayoutgoing(&g)) {
481    owl_function_make_outgoing_aim(msg, to);
482  }
483
484  /* log it if we have logging turned on */
485  if (owl_global_is_logging(&g)) {
486    owl_log_outgoing_aim(to, msg);
487  }
488
489  owl_free(format_msg);
490}
491
492void owl_function_loopwrite()
493{
494  owl_message *m;
495
496  /* create a message and put it on the message queue.  This simulates
497   * an incoming message */
498  m=owl_malloc(sizeof(owl_message));
499  owl_message_create_loopback(m, owl_editwin_get_text(owl_global_get_typwin(&g)));
500  owl_message_set_direction_in(m);
501  owl_global_messagequeue_addmsg(&g, m);
502
503  /* display the message as an outgoing message in the receive window */
504  if (owl_global_is_displayoutgoing(&g)) {
505    owl_function_make_outgoing_loopback(owl_editwin_get_text(owl_global_get_typwin(&g)));
506  }
507
508  /* fake a makemsg */
509  owl_function_makemsg("loopback message sent");
510
511  /* log it if we have logging turned on */
512  if (owl_global_is_logging(&g)) {
513    owl_log_outgoing_loopback(owl_editwin_get_text(owl_global_get_typwin(&g)));
514  }
515}
516
517/* If filter is non-null, looks for the next message matching
518 * that filter.  If skip_deleted, skips any deleted messages.
519 * If last_if_none, will stop at the last message in the view
520 * if no matching messages are found.  */
521void owl_function_nextmsg_full(char *filter, int skip_deleted, int last_if_none)
522{
523  int curmsg, i, viewsize, found;
524  owl_view *v;
525  owl_filter *f = NULL;
526  owl_message *m;
527
528  v=owl_global_get_current_view(&g);
529
530  if (filter) {
531    f=owl_global_get_filter(&g, filter);
532    if (!f) {
533      owl_function_error("No %s filter defined", filter);
534      return;
535    }
536  }
537
538  curmsg=owl_global_get_curmsg(&g);
539  viewsize=owl_view_get_size(v);
540  found=0;
541
542  /* just check to make sure we're in bounds... */
543  if (curmsg>viewsize-1) curmsg=viewsize-1;
544  if (curmsg<0) curmsg=0;
545
546  for (i=curmsg+1; i<viewsize; i++) {
547    m=owl_view_get_element(v, i);
548    if (skip_deleted && owl_message_is_delete(m)) continue;
549    if (f && !owl_filter_message_match(f, m)) continue;
550    found = 1;
551    break;
552  }
553
554  if (i>owl_view_get_size(v)-1) i=owl_view_get_size(v)-1;
555
556  if (!found) {
557    owl_function_makemsg("already at last%s message%s%s",
558                         skip_deleted?" non-deleted":"",
559                         filter?" in ":"", filter?filter:"");
560    /* if (!skip_deleted) owl_function_beep(); */
561  }
562
563  if (last_if_none || found) {
564    owl_global_set_curmsg(&g, i);
565    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
566    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
567    owl_global_set_direction_downwards(&g);
568  }
569}
570
571void owl_function_prevmsg_full(char *filter, int skip_deleted, int first_if_none)
572{
573  int curmsg, i, viewsize, found;
574  owl_view *v;
575  owl_filter *f = NULL;
576  owl_message *m;
577
578  v=owl_global_get_current_view(&g);
579
580  if (filter) {
581    f=owl_global_get_filter(&g, filter);
582    if (!f) {
583      owl_function_error("No %s filter defined", filter);
584      return;
585    }
586  }
587
588  curmsg=owl_global_get_curmsg(&g);
589  viewsize=owl_view_get_size(v);
590  found=0;
591
592  /* just check to make sure we're in bounds... */
593  if (curmsg<0) curmsg=0;
594
595  for (i=curmsg-1; i>=0; i--) {
596    m=owl_view_get_element(v, i);
597    if (skip_deleted && owl_message_is_delete(m)) continue;
598    if (f && !owl_filter_message_match(f, m)) continue;
599    found = 1;
600    break;
601  }
602
603  if (i<0) i=0;
604
605  if (!found) {
606    owl_function_makemsg("already at first%s message%s%s",
607                         skip_deleted?" non-deleted":"",
608                         filter?" in ":"", filter?filter:"");
609    /* if (!skip_deleted) owl_function_beep(); */
610  }
611
612  if (first_if_none || found) {
613    owl_global_set_curmsg(&g, i);
614    owl_function_calculate_topmsg(OWL_DIRECTION_UPWARDS);
615    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
616    owl_global_set_direction_upwards(&g);
617  }
618}
619
620void owl_function_nextmsg()
621{
622  owl_function_nextmsg_full(NULL, 0, 1);
623}
624
625void owl_function_prevmsg()
626{
627  owl_function_prevmsg_full(NULL, 0, 1);
628}
629
630void owl_function_nextmsg_notdeleted()
631{
632  owl_function_nextmsg_full(NULL, 1, 1);
633}
634
635void owl_function_prevmsg_notdeleted()
636{
637  owl_function_prevmsg_full(NULL, 1, 1);
638}
639
640void owl_function_nextmsg_personal()
641{
642  owl_function_nextmsg_full("personal", 0, 0);
643}
644
645void owl_function_prevmsg_personal()
646{
647  owl_function_prevmsg_full("personal", 0, 0);
648}
649
650
651/* if move_after is 1, moves after the delete */
652void owl_function_deletecur(int move_after)
653{
654  int curmsg;
655  owl_view *v;
656
657  v=owl_global_get_current_view(&g);
658
659  /* bail if there's no current message */
660  if (owl_view_get_size(v) < 1) {
661    owl_function_error("No current message to delete");
662    return;
663  }
664
665  /* mark the message for deletion */
666  curmsg=owl_global_get_curmsg(&g);
667  owl_view_delete_element(v, curmsg);
668
669  if (move_after) {
670    /* move the poiner in the appropriate direction
671     * to the next undeleted msg */
672    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
673      owl_function_prevmsg_notdeleted();
674    } else {
675      owl_function_nextmsg_notdeleted();
676    }
677  }
678}
679
680void owl_function_undeletecur(int move_after)
681{
682  int curmsg;
683  owl_view *v;
684
685  v=owl_global_get_current_view(&g);
686 
687  if (owl_view_get_size(v) < 1) {
688    owl_function_error("No current message to undelete");
689    return;
690  }
691  curmsg=owl_global_get_curmsg(&g);
692
693  owl_view_undelete_element(v, curmsg);
694
695  if (move_after) {
696    if (owl_global_get_direction(&g)==OWL_DIRECTION_UPWARDS) {
697      if (curmsg>0) {
698        owl_function_prevmsg();
699      } else {
700        owl_function_nextmsg();
701      }
702    } else {
703      owl_function_nextmsg();
704    }
705  }
706
707  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
708}
709
710void owl_function_expunge()
711{
712  int curmsg;
713  owl_message *m;
714  owl_messagelist *ml;
715  owl_view *v;
716  int lastmsgid=0;
717
718  curmsg=owl_global_get_curmsg(&g);
719  v=owl_global_get_current_view(&g);
720  ml=owl_global_get_msglist(&g);
721
722  m=owl_view_get_element(v, curmsg);
723  if (m) lastmsgid = owl_message_get_id(m);
724
725  /* expunge the message list */
726  owl_messagelist_expunge(ml);
727
728  /* update all views (we only have one right now) */
729  owl_view_recalculate(v);
730
731  /* find where the new position should be
732     (as close as possible to where we last where) */
733  curmsg = owl_view_get_nearest_to_msgid(v, lastmsgid);
734  if (curmsg>owl_view_get_size(v)-1) curmsg = owl_view_get_size(v)-1;
735  if (curmsg<0) curmsg = 0;
736  owl_global_set_curmsg(&g, curmsg);
737  owl_function_calculate_topmsg(OWL_DIRECTION_NONE);
738  /* if there are no messages set the direction to down in case we
739     delete everything upwards */
740  owl_global_set_direction_downwards(&g);
741 
742  owl_function_makemsg("Messages expunged");
743  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
744}
745
746void owl_function_firstmsg()
747{
748  owl_global_set_curmsg(&g, 0);
749  owl_global_set_topmsg(&g, 0);
750  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
751  owl_global_set_direction_downwards(&g);
752}
753
754void owl_function_lastmsg_noredisplay()
755{
756  int oldcurmsg, curmsg;
757  owl_view *v;
758
759  v=owl_global_get_current_view(&g);
760  oldcurmsg=owl_global_get_curmsg(&g);
761  curmsg=owl_view_get_size(v)-1; 
762  if (curmsg<0) curmsg=0;
763  owl_global_set_curmsg(&g, curmsg);
764  if (oldcurmsg < curmsg) {
765    owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
766  } else if (curmsg<owl_view_get_size(v)) {
767    /* If already at the end, blank the screen and move curmsg
768     * past the end of the messages. */
769    owl_global_set_topmsg(&g, curmsg+1);
770    owl_global_set_curmsg(&g, curmsg+1);
771  } 
772  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
773  owl_global_set_direction_downwards(&g);
774}
775
776void owl_function_lastmsg()
777{
778  owl_function_lastmsg_noredisplay();
779  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
780}
781
782void owl_function_shift_right()
783{
784  owl_global_set_rightshift(&g, owl_global_get_rightshift(&g)+10);
785  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
786  owl_global_set_needrefresh(&g);
787}
788
789void owl_function_shift_left()
790{
791  int shift;
792
793  shift=owl_global_get_rightshift(&g);
794  if (shift>=10) {
795    owl_global_set_rightshift(&g, shift-10);
796    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
797    owl_global_set_needrefresh(&g);
798  } else {
799    owl_function_beep();
800    owl_function_makemsg("Already full left");
801  }
802}
803
804void owl_function_unsuball()
805{
806  unsuball();
807  owl_function_makemsg("Unsubscribed from all messages.");
808}
809
810void owl_function_loadsubs(char *file)
811{
812  int ret;
813
814  ret=owl_zephyr_loadsubs(file);
815
816  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
817  if (ret==0) {
818    owl_function_makemsg("Subscribed to messages from file.");
819  } else if (ret==-1) {
820    owl_function_error("Could not open file.");
821  } else {
822    owl_function_error("Error subscribing to messages from file.");
823  }
824}
825
826void owl_function_loadloginsubs(char *file)
827{
828  int ret;
829
830  ret=owl_zephyr_loadloginsubs(file);
831
832  if (!owl_context_is_interactive(owl_global_get_context(&g))) return;
833  if (ret==0) {
834    owl_function_makemsg("Subscribed to login messages from file.");
835  } else if (ret==-1) {
836    owl_function_error("Could not open file for login subscriptions.");
837  } else {
838    owl_function_error("Error subscribing to login messages from file.");
839  }
840}
841
842void owl_function_suspend()
843{
844  endwin();
845  printf("\n");
846  kill(getpid(), SIGSTOP);
847
848  /* resize to reinitialize all the windows when we come back */
849  owl_command_resize();
850}
851
852void owl_function_zaway_toggle()
853{
854  if (!owl_global_is_zaway(&g)) {
855    owl_global_set_zaway_msg(&g, owl_global_get_zaway_msg_default(&g));
856    owl_function_zaway_on();
857  } else {
858    owl_function_zaway_off();
859  }
860}
861
862void owl_function_zaway_on()
863{
864  owl_global_set_zaway_on(&g);
865  owl_function_makemsg("zaway set (%s)", owl_global_get_zaway_msg(&g));
866}
867
868void owl_function_zaway_off()
869{
870  owl_global_set_zaway_off(&g);
871  owl_function_makemsg("zaway off");
872}
873
874void owl_function_aaway_toggle()
875{
876  if (!owl_global_is_aaway(&g)) {
877    owl_global_set_aaway_msg(&g, owl_global_get_aaway_msg_default(&g));
878    owl_function_aaway_on();
879  } else {
880    owl_function_aaway_off();
881  }
882}
883
884void owl_function_aaway_on()
885{
886  owl_global_set_aaway_on(&g);
887  /* owl_aim_set_awaymsg(owl_global_get_zaway_msg(&g)); */
888  owl_function_makemsg("AIM away set (%s)", owl_global_get_aaway_msg(&g));
889}
890
891void owl_function_aaway_off()
892{
893  owl_global_set_aaway_off(&g);
894  /* owl_aim_set_awaymsg(""); */
895  owl_function_makemsg("AIM away off");
896}
897
898void owl_function_quit()
899{
900  char *ret;
901 
902  /* zlog out if we need to */
903  if (owl_global_is_shutdownlogout(&g)) {
904    owl_zephyr_zlog_out();
905  }
906
907  /* execute the commands in shutdown */
908  ret = owl_perlconfig_execute("owl::shutdown();");
909  if (ret) owl_free(ret);
910
911  /* signal our child process, if any */
912  if (owl_global_get_newmsgproc_pid(&g)) {
913    kill(owl_global_get_newmsgproc_pid(&g), SIGHUP);
914  }
915
916  /* Quit zephyr */
917  owl_zephyr_shutdown();
918
919 
920  /* Quit AIM */
921  if (owl_global_is_aimloggedin(&g)) {
922    owl_aim_logout();
923  }
924
925  /* final clean up */
926  endwin();
927  owl_function_debugmsg("Quitting Owl");
928  exit(0);
929}
930
931void owl_function_openurl()
932{
933  /* visit the first url in the current message */
934  owl_message *m;
935  owl_view *v;
936  char *ptr1, *ptr2, *text, url[LINE], tmpbuff[LINE];
937  int webbrowser;
938
939  webbrowser = owl_global_get_webbrowser(&g);
940
941  if (webbrowser < 0 || webbrowser == OWL_WEBBROWSER_NONE) {
942    owl_function_error("No browser selected");
943    return;
944  }
945
946  v=owl_global_get_current_view(&g);
947 
948  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
949
950  if (!m || owl_view_get_size(v)==0) {
951    owl_function_error("No current message selected");
952    return;
953  }
954
955  text=owl_message_get_text(m);
956
957  /* First look for a good URL */ 
958  if ((ptr1=strstr(text, "http://"))!=NULL) {
959    ptr2=strpbrk(ptr1, " \n\t");
960    if (ptr2) {
961      strncpy(url, ptr1, ptr2-ptr1+1);
962      url[ptr2-ptr1+1]='\0';
963    } else {
964      strcpy(url, ptr1);
965    }
966
967    /* if we had <http strip a trailing > */
968    if (ptr1>text && ptr1[-1]=='<') {
969      if (url[strlen(url)-1]=='>') {
970        url[strlen(url)-1]='\0';
971      }
972    }
973  } else if ((ptr1=strstr(text, "https://"))!=NULL) {
974    /* Look for an https URL */ 
975    ptr2=strpbrk(ptr1, " \n\t");
976    if (ptr2) {
977      strncpy(url, ptr1, ptr2-ptr1+1);
978      url[ptr2-ptr1+1]='\0';
979    } else {
980      strcpy(url, ptr1);
981    }
982   
983    /* if we had <http strip a trailing > */
984    if (ptr1>text && ptr1[-1]=='<') {
985      if (url[strlen(url)-1]=='>') {
986        url[strlen(url)-1]='\0';
987      }
988    }
989  } else if ((ptr1=strstr(text, "www."))!=NULL) {
990    /* if we can't find a real url look for www.something */
991    ptr2=strpbrk(ptr1, " \n\t");
992    if (ptr2) {
993      strncpy(url, ptr1, ptr2-ptr1+1);
994      url[ptr2-ptr1+1]='\0';
995    } else {
996      strcpy(url, ptr1);
997    }
998  } else {
999    owl_function_beep();
1000    owl_function_error("Could not find URL to open.");
1001    return;
1002  }
1003
1004  /* Make sure there aren't any quotes or \'s in the url */
1005  for (ptr1 = url; *ptr1; ptr1++) {
1006    if (*ptr1 == '"' || *ptr1 == '\\') {
1007      owl_function_beep();
1008      owl_function_error("URL contains invalid characters.");
1009      return;
1010    }
1011  }
1012 
1013  /* NOTE: There are potentially serious security issues here... */
1014
1015  /* open the page */
1016  owl_function_makemsg("Opening %s", url);
1017  if (webbrowser == OWL_WEBBROWSER_NETSCAPE) {
1018    snprintf(tmpbuff, LINE, "netscape -remote \"openURL(%s)\" > /dev/null 2> /dev/null", url);
1019    system(tmpbuff); 
1020  } else if (webbrowser == OWL_WEBBROWSER_GALEON) {
1021    snprintf(tmpbuff, LINE, "galeon \"%s\" > /dev/null 2> /dev/null &", url);
1022    system(tmpbuff); 
1023  } else if (webbrowser == OWL_WEBBROWSER_OPERA) {
1024    snprintf(tmpbuff, LINE, "opera \"%s\" > /dev/null 2> /dev/null &", url);
1025    system(tmpbuff); 
1026  }
1027}
1028
1029void owl_function_calculate_topmsg(int direction)
1030{
1031  int recwinlines, topmsg, curmsg;
1032  owl_view *v;
1033
1034  v=owl_global_get_current_view(&g);
1035  curmsg=owl_global_get_curmsg(&g);
1036  topmsg=owl_global_get_topmsg(&g);
1037  recwinlines=owl_global_get_recwin_lines(&g);
1038
1039  /*
1040  if (owl_view_get_size(v) < 1) {
1041    return;
1042  }
1043  */
1044
1045  switch (owl_global_get_scrollmode(&g)) {
1046  case OWL_SCROLLMODE_TOP:
1047    topmsg = owl_function_calculate_topmsg_top(direction, v, curmsg, topmsg, recwinlines);
1048    break;
1049  case OWL_SCROLLMODE_NEARTOP:
1050    topmsg = owl_function_calculate_topmsg_neartop(direction, v, curmsg, topmsg, recwinlines);
1051    break;
1052  case OWL_SCROLLMODE_CENTER:
1053    topmsg = owl_function_calculate_topmsg_center(direction, v, curmsg, topmsg, recwinlines);
1054    break;
1055  case OWL_SCROLLMODE_PAGED:
1056    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 0);
1057    break;
1058  case OWL_SCROLLMODE_PAGEDCENTER:
1059    topmsg = owl_function_calculate_topmsg_paged(direction, v, curmsg, topmsg, recwinlines, 1);
1060    break;
1061  case OWL_SCROLLMODE_NORMAL:
1062  default:
1063    topmsg = owl_function_calculate_topmsg_normal(direction, v, curmsg, topmsg, recwinlines);
1064  }
1065  owl_function_debugmsg("Calculated a topmsg of %i", topmsg);
1066  owl_global_set_topmsg(&g, topmsg);
1067}
1068
1069/* Returns what the new topmsg should be. 
1070 * Passed the last direction of movement,
1071 * the current view,
1072 * the current message number in the view,
1073 * the top message currently being displayed,
1074 * and the number of lines in the recwin.
1075 */
1076int owl_function_calculate_topmsg_top(int direction, owl_view *v, int curmsg, int topmsg, int recwinlines)
1077{
1078  return(curmsg);
1079}
1080
1081int owl_function_calculate_topmsg_neartop(int direction, owl_view *v, int curmsg, int topmsg, int recwinlines)
1082{
1083  if (curmsg>0 
1084      && (owl_message_get_numlines(owl_view_get_element(v, curmsg-1))
1085          <  recwinlines/2)) {
1086    return(curmsg-1);
1087  } else {
1088    return(curmsg);
1089  }
1090}
1091 
1092int owl_function_calculate_topmsg_center(int direction, owl_view *v, int curmsg, int topmsg, int recwinlines)
1093{
1094  int i, last, lines;
1095
1096  last = curmsg;
1097  lines = 0;
1098  for (i=curmsg-1; i>=0; i--) {
1099    lines += owl_message_get_numlines(owl_view_get_element(v, i));
1100    if (lines > recwinlines/2) break;
1101    last = i;
1102  }
1103  return(last);
1104}
1105 
1106int owl_function_calculate_topmsg_paged(int direction, owl_view *v, int curmsg, int topmsg, int recwinlines, int center_on_page)
1107{
1108  int i, last, lines, savey;
1109 
1110  /* If we're off the top of the screen, scroll up such that the
1111   * curmsg is near the botton of the screen. */
1112  if (curmsg < topmsg) {
1113    last = curmsg;
1114    lines = 0;
1115    for (i=curmsg; i>=0; i--) {
1116      lines += owl_message_get_numlines(owl_view_get_element(v, i));
1117      if (lines > recwinlines) break;
1118    last = i;
1119    }
1120    if (center_on_page) {
1121      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
1122    } else {
1123      return(last);
1124    }
1125  }
1126
1127  /* Find number of lines from top to bottom of curmsg (store in savey) */
1128  savey=0;
1129  for (i=topmsg; i<=curmsg; i++) {
1130    savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1131  }
1132
1133  /* if we're off the bottom of the screen, scroll down */
1134  if (savey > recwinlines) {
1135    if (center_on_page) {
1136      return(owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines));
1137    } else {
1138      return(curmsg);
1139    }
1140  }
1141
1142  /* else just stay as we are... */
1143  return(topmsg);
1144}
1145
1146int owl_function_calculate_topmsg_normal(int direction, owl_view *v, int curmsg, int topmsg, int recwinlines)
1147{
1148  int savey, j, i, foo, y;
1149
1150  if (curmsg<0) return(topmsg);
1151   
1152  /* If we're off the top of the screen then center */
1153  if (curmsg<topmsg) {
1154    topmsg=owl_function_calculate_topmsg_center(direction, v, curmsg, 0, recwinlines);
1155  }
1156
1157  /* Find number of lines from top to bottom of curmsg (store in savey) */
1158  savey=0;
1159  for (i=topmsg; i<=curmsg; i++) {
1160    savey+=owl_message_get_numlines(owl_view_get_element(v, i));
1161  }
1162
1163  /* If we're off the bottom of the screen, set the topmsg to curmsg
1164   * and scroll upwards */
1165  if (savey > recwinlines) {
1166    topmsg=curmsg;
1167    savey=owl_message_get_numlines(owl_view_get_element(v, i));
1168    direction=OWL_DIRECTION_UPWARDS;
1169  }
1170 
1171  /* If our bottom line is less than 1/4 down the screen then scroll up */
1172  if (direction == OWL_DIRECTION_UPWARDS || direction == OWL_DIRECTION_NONE) {
1173    if (savey < (recwinlines / 4)) {
1174      y=0;
1175      for (j=curmsg; j>=0; j--) {
1176        foo=owl_message_get_numlines(owl_view_get_element(v, j));
1177        /* will we run the curmsg off the screen? */
1178        if ((foo+y) >= recwinlines) {
1179          j++;
1180          if (j>curmsg) j=curmsg;
1181          break;
1182        }
1183        /* have saved 1/2 the screen space? */
1184        y+=foo;
1185        if (y > (recwinlines / 2)) break;
1186      }
1187      if (j<0) j=0;
1188      return(j);
1189    }
1190  }
1191
1192  if (direction == OWL_DIRECTION_DOWNWARDS || direction == OWL_DIRECTION_NONE) {
1193    /* If curmsg bottom line is more than 3/4 down the screen then scroll down */
1194    if (savey > ((recwinlines * 3)/4)) {
1195      y=0;
1196      /* count lines from the top until we can save 1/2 the screen size */
1197      for (j=topmsg; j<curmsg; j++) {
1198        y+=owl_message_get_numlines(owl_view_get_element(v, j));
1199        if (y > (recwinlines / 2)) break;
1200      }
1201      if (j==curmsg) {
1202        j--;
1203      }
1204      return(j+1);
1205    }
1206  }
1207
1208  return(topmsg);
1209}
1210
1211void owl_function_resize()
1212{
1213  owl_global_set_resize_pending(&g);
1214}
1215
1216void owl_function_run_buffercommand()
1217{
1218  char *buff, *ptr;
1219
1220  buff=owl_global_get_buffercommand(&g);
1221  if (!strncmp(buff, "zwrite ", 7)) {
1222    owl_function_zwrite(buff, owl_editwin_get_text(owl_global_get_typwin(&g)));
1223  } else if (!strncmp(buff, "zcrypt ", 7)) {
1224    owl_function_zcrypt(buff, owl_editwin_get_text(owl_global_get_typwin(&g)));
1225  } else if (!strncmp(buff, "aimwrite ", 9)) {
1226    owl_function_aimwrite(buff+9);
1227  } else if (!strncmp(buff, "loopwrite", 9) || !strncmp(buff, "loopwrite ", 10)) {
1228    owl_function_loopwrite();
1229  } else if (!strncmp(buff, "aimlogin ", 9)) {
1230    ptr=owl_sprintf("%s %s", buff, owl_global_get_response(&g));
1231    owl_function_command(ptr);
1232    owl_free(ptr);
1233  } else {
1234    owl_function_error("Internal error: invalid buffercommand %s", buff);
1235  }
1236}
1237
1238void owl_function_debugmsg(char *fmt, ...)
1239{
1240  FILE *file;
1241  time_t now;
1242  char buff1[LINE], buff2[LINE];
1243  va_list ap;
1244  va_start(ap, fmt);
1245
1246  if (!owl_global_is_debug_fast(&g)) return;
1247
1248  file=fopen(owl_global_get_debug_file(&g), "a");
1249  if (!file) return;
1250
1251  now=time(NULL);
1252  strcpy(buff1, ctime(&now));
1253  buff1[strlen(buff1)-1]='\0';
1254
1255  owl_global_get_runtime_string(&g, buff2);
1256 
1257  fprintf(file, "[%i -  %s - %s]: ", (int) getpid(), buff1, buff2);
1258  vfprintf(file, fmt, ap);
1259  fprintf(file, "\n");
1260  fclose(file);
1261
1262  va_end(ap);
1263}
1264
1265void owl_function_refresh()
1266{
1267  owl_function_resize();
1268}
1269
1270void owl_function_beep()
1271{
1272  if (owl_global_is_bell(&g)) {
1273    beep();
1274    owl_global_set_needrefresh(&g); /* do we really need this? */
1275  }
1276}
1277
1278void owl_function_subscribe(char *class, char *inst, char *recip)
1279{
1280  int ret;
1281
1282  ret=owl_zephyr_sub(class, inst, recip);
1283  if (ret) {
1284    owl_function_error("Error subscribing.");
1285  } else {
1286    owl_function_makemsg("Subscribed.");
1287  }
1288}
1289
1290void owl_function_unsubscribe(char *class, char *inst, char *recip)
1291{
1292  int ret;
1293
1294  ret=owl_zephyr_unsub(class, inst, recip);
1295  if (ret) {
1296    owl_function_error("Error subscribing.");
1297  } else {
1298    owl_function_makemsg("Unsubscribed.");
1299  }
1300}
1301
1302void owl_function_set_cursor(WINDOW *win)
1303{
1304  wnoutrefresh(win);
1305}
1306
1307void owl_function_full_redisplay()
1308{
1309  redrawwin(owl_global_get_curs_recwin(&g));
1310  redrawwin(owl_global_get_curs_sepwin(&g));
1311  redrawwin(owl_global_get_curs_typwin(&g));
1312  redrawwin(owl_global_get_curs_msgwin(&g));
1313
1314  wnoutrefresh(owl_global_get_curs_recwin(&g));
1315  wnoutrefresh(owl_global_get_curs_sepwin(&g));
1316  wnoutrefresh(owl_global_get_curs_typwin(&g));
1317  wnoutrefresh(owl_global_get_curs_msgwin(&g));
1318 
1319  sepbar("");
1320  owl_function_makemsg("");
1321
1322  owl_global_set_needrefresh(&g);
1323}
1324
1325void owl_function_popless_text(char *text)
1326{
1327  owl_popwin *pw;
1328  owl_viewwin *v;
1329
1330  pw=owl_global_get_popwin(&g);
1331  v=owl_global_get_viewwin(&g);
1332
1333  owl_popwin_up(pw);
1334  owl_viewwin_init_text(v, owl_popwin_get_curswin(pw),
1335                        owl_popwin_get_lines(pw), owl_popwin_get_cols(pw),
1336                        text);
1337  owl_popwin_refresh(pw);
1338  owl_viewwin_redisplay(v, 0);
1339  owl_global_set_needrefresh(&g);
1340}
1341
1342void owl_function_popless_fmtext(owl_fmtext *fm)
1343{
1344  owl_popwin *pw;
1345  owl_viewwin *v;
1346
1347  pw=owl_global_get_popwin(&g);
1348  v=owl_global_get_viewwin(&g);
1349
1350  owl_popwin_up(pw);
1351  owl_viewwin_init_fmtext(v, owl_popwin_get_curswin(pw),
1352                   owl_popwin_get_lines(pw), owl_popwin_get_cols(pw),
1353                   fm);
1354  owl_popwin_refresh(pw);
1355  owl_viewwin_redisplay(v, 0);
1356  owl_global_set_needrefresh(&g);
1357}
1358
1359void owl_function_popless_file(char *filename)
1360{
1361  owl_fmtext fm;
1362  FILE *file;
1363  char buff[1024];
1364
1365  file=fopen(filename, "r");
1366  if (!file) {
1367    owl_function_error("Could not open file: %s", filename);
1368    return;
1369  }
1370
1371  owl_fmtext_init_null(&fm);
1372  while (fgets(buff, 1024, file)) {
1373    owl_fmtext_append_normal(&fm, buff);
1374    /*    owl_fmtext_append_normal(&fm, "\n"); */
1375  }
1376
1377  owl_function_popless_fmtext(&fm);
1378  owl_fmtext_free(&fm);
1379  fclose(file);
1380}
1381
1382void owl_function_about()
1383{
1384  char buff[5000];
1385
1386  sprintf(buff, "This is owl version %s\n", OWL_VERSION_STRING);
1387  strcat(buff, "\nOwl was written by James Kretchmar at the Massachusetts\n");
1388  strcat(buff, "Institute of Technology.  The first version, 0.5, was\n");
1389  strcat(buff, "released in March 2002.\n");
1390  strcat(buff, "\n");
1391  strcat(buff, "The name 'owl' was chosen in reference to the owls in the\n");
1392  strcat(buff, "Harry Potter novels, who are tasked with carrying messages\n");
1393  strcat(buff, "between Witches and Wizards.\n");
1394  strcat(buff, "\n");
1395  strcat(buff, "Copyright 2002 Massachusetts Institute of Technology\n");
1396  strcat(buff, "\n");
1397  strcat(buff, "Permission to use, copy, modify, and distribute this\n");
1398  strcat(buff, "software and its documentation for any purpose and without\n");
1399  strcat(buff, "fee is hereby granted, provided that the above copyright\n");
1400  strcat(buff, "notice and this permission notice appear in all copies\n");
1401  strcat(buff, "and in supporting documentation.  No representation is\n");
1402  strcat(buff, "made about the suitability of this software for any\n");
1403  strcat(buff, "purpose.  It is provided \"as is\" without express\n");
1404  strcat(buff, "or implied warranty.\n");
1405  owl_function_popless_text(buff);
1406}
1407
1408void owl_function_info()
1409{
1410  owl_message *m;
1411  owl_fmtext fm, attrfm;
1412  char buff[10000];
1413  owl_view *v;
1414#ifdef HAVE_LIBZEPHYR
1415  ZNotice_t *n;
1416#endif
1417
1418  owl_fmtext_init_null(&fm);
1419 
1420  v=owl_global_get_current_view(&g);
1421  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1422  if (!m || owl_view_get_size(v)==0) {
1423    owl_function_error("No message selected\n");
1424    return;
1425  }
1426
1427  owl_fmtext_append_bold(&fm, "General Information:\n");
1428  owl_fmtext_append_normal(&fm, "  Msg Id    : ");
1429  sprintf(buff, "%i", owl_message_get_id(m));
1430  owl_fmtext_append_normal(&fm, buff);
1431  owl_fmtext_append_normal(&fm, "\n");
1432
1433  owl_fmtext_append_normal(&fm, "  Type      : ");
1434  owl_fmtext_append_bold(&fm, owl_message_get_type(m));
1435  owl_fmtext_append_normal(&fm, "\n");
1436
1437  if (owl_message_is_direction_in(m)) {
1438    owl_fmtext_append_normal(&fm, "  Direction : in\n");
1439  } else if (owl_message_is_direction_out(m)) {
1440    owl_fmtext_append_normal(&fm, "  Direction : out\n");
1441  } else if (owl_message_is_direction_none(m)) {
1442    owl_fmtext_append_normal(&fm, "  Direction : none\n");
1443  } else {
1444    owl_fmtext_append_normal(&fm, "  Direction : unknown\n");
1445  }
1446
1447  owl_fmtext_append_normal(&fm, "  Time      : ");
1448  owl_fmtext_append_normal(&fm, owl_message_get_timestr(m));
1449  owl_fmtext_append_normal(&fm, "\n");
1450
1451  if (!owl_message_is_type_admin(m)) {
1452    owl_fmtext_append_normal(&fm, "  Sender    : ");
1453    owl_fmtext_append_normal(&fm, owl_message_get_sender(m));
1454    owl_fmtext_append_normal(&fm, "\n");
1455   
1456    owl_fmtext_append_normal(&fm, "  Recipient : ");
1457    owl_fmtext_append_normal(&fm, owl_message_get_recipient(m));
1458    owl_fmtext_append_normal(&fm, "\n");
1459  }
1460   
1461  if (owl_message_is_type_zephyr(m)) {
1462    owl_fmtext_append_bold(&fm, "\nZephyr Specific Information:\n");
1463   
1464    owl_fmtext_append_normal(&fm, "  Class     : ");
1465    owl_fmtext_append_normal(&fm, owl_message_get_class(m));
1466    owl_fmtext_append_normal(&fm, "\n");
1467    owl_fmtext_append_normal(&fm, "  Instance  : ");
1468    owl_fmtext_append_normal(&fm, owl_message_get_instance(m));
1469    owl_fmtext_append_normal(&fm, "\n");
1470    owl_fmtext_append_normal(&fm, "  Opcode    : ");
1471    owl_fmtext_append_normal(&fm, owl_message_get_opcode(m));
1472    owl_fmtext_append_normal(&fm, "\n");
1473   
1474    owl_fmtext_append_normal(&fm, "  Time      : ");
1475    owl_fmtext_append_normal(&fm, owl_message_get_timestr(m));
1476    owl_fmtext_append_normal(&fm, "\n");
1477#ifdef HAVE_LIBZEPHYR
1478    if (owl_message_is_direction_in(m)) {
1479      char *ptr, tmpbuff[1024];
1480      int i, j, fields, len;
1481
1482      n=owl_message_get_notice(m);
1483
1484      if (!owl_message_is_pseudo(m)) {
1485        owl_fmtext_append_normal(&fm, "  Kind      : ");
1486        if (n->z_kind==UNSAFE) {
1487          owl_fmtext_append_normal(&fm, "UNSAFE\n");
1488        } else if (n->z_kind==UNACKED) {
1489          owl_fmtext_append_normal(&fm, "UNACKED\n");
1490        } else if (n->z_kind==ACKED) {
1491          owl_fmtext_append_normal(&fm, "ACKED\n");
1492        } else if (n->z_kind==HMACK) {
1493          owl_fmtext_append_normal(&fm, "HMACK\n");
1494        } else if (n->z_kind==HMCTL) {
1495          owl_fmtext_append_normal(&fm, "HMCTL\n");
1496        } else if (n->z_kind==SERVACK) {
1497          owl_fmtext_append_normal(&fm, "SERVACK\n");
1498        } else if (n->z_kind==SERVNAK) {
1499          owl_fmtext_append_normal(&fm, "SERVNACK\n");
1500        } else if (n->z_kind==CLIENTACK) {
1501          owl_fmtext_append_normal(&fm, "CLIENTACK\n");
1502        } else if (n->z_kind==STAT) {
1503          owl_fmtext_append_normal(&fm, "STAT\n");
1504        } else {
1505          owl_fmtext_append_normal(&fm, "ILLEGAL VALUE\n");
1506        }
1507      }
1508      owl_fmtext_append_normal(&fm, "  Host      : ");
1509      owl_fmtext_append_normal(&fm, owl_message_get_hostname(m));
1510
1511      if (!owl_message_is_pseudo(m)) {
1512        owl_fmtext_append_normal(&fm, "\n");
1513        sprintf(buff, "  Port      : %i\n", n->z_port);
1514        owl_fmtext_append_normal(&fm, buff);
1515
1516        owl_fmtext_append_normal(&fm,    "  Auth      : ");
1517        owl_fmtext_append_normal(&fm, owl_zephyr_get_authstr(n));
1518        owl_fmtext_append_normal(&fm, "\n");
1519       
1520        /* fix this */
1521        sprintf(buff, "  Checkd Ath: %i\n", n->z_checked_auth);
1522        sprintf(buff, "%s  Multi notc: %s\n", buff, n->z_multinotice);
1523        sprintf(buff, "%s  Num other : %i\n", buff, n->z_num_other_fields);
1524        sprintf(buff, "%s  Msg Len   : %i\n", buff, n->z_message_len);
1525        owl_fmtext_append_normal(&fm, buff);
1526       
1527        sprintf(buff, "  Fields    : %i\n", owl_zephyr_get_num_fields(n));
1528        owl_fmtext_append_normal(&fm, buff);
1529       
1530        fields=owl_zephyr_get_num_fields(n);
1531        for (i=0; i<fields; i++) {
1532          sprintf(buff, "  Field %i   : ", i+1);
1533         
1534          ptr=owl_zephyr_get_field(n, i+1);
1535          len=strlen(ptr);
1536          if (len<30) {
1537            strncpy(tmpbuff, ptr, len);
1538            tmpbuff[len]='\0';
1539          } else {
1540            strncpy(tmpbuff, ptr, 30);
1541            tmpbuff[30]='\0';
1542            strcat(tmpbuff, "...");
1543          }
1544          owl_free(ptr);
1545         
1546          for (j=0; j<strlen(tmpbuff); j++) {
1547            if (tmpbuff[j]=='\n') tmpbuff[j]='~';
1548            if (tmpbuff[j]=='\r') tmpbuff[j]='!';
1549          }
1550         
1551          strcat(buff, tmpbuff);
1552          strcat(buff, "\n");
1553          owl_fmtext_append_normal(&fm, buff);
1554        }
1555        owl_fmtext_append_normal(&fm, "  Default Fm:");
1556        owl_fmtext_append_normal(&fm, n->z_default_format);
1557      }
1558     
1559    }
1560#endif   
1561  }
1562
1563  if (owl_message_is_type_aim(m)) {
1564    owl_fmtext_append_bold(&fm, "\nAIM Specific Information:\n");
1565  }
1566
1567  owl_fmtext_append_bold(&fm, "\nOwl Message Attributes:\n");
1568  owl_message_attributes_tofmtext(m, &attrfm);
1569  owl_fmtext_append_fmtext(&fm, &attrfm);
1570 
1571  owl_function_popless_fmtext(&fm);
1572  owl_fmtext_free(&fm);
1573  owl_fmtext_free(&attrfm);
1574}
1575
1576/* print the current message in a popup window.
1577 * Use the 'default' style regardless of whatever
1578 * style the user may be using
1579 */
1580void owl_function_curmsg_to_popwin()
1581{
1582  owl_popwin *pw;
1583  owl_view *v;
1584  owl_message *m;
1585  owl_style *s;
1586  owl_fmtext fm;
1587
1588  v=owl_global_get_current_view(&g);
1589  s=owl_global_get_style_by_name(&g, "default");
1590  pw=owl_global_get_popwin(&g);
1591
1592  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
1593
1594  if (!m || owl_view_get_size(v)==0) {
1595    owl_function_error("No current message");
1596    return;
1597  }
1598
1599  owl_fmtext_init_null(&fm);
1600  owl_style_get_formattext(s, &fm, m);
1601
1602  owl_function_popless_fmtext(&fm);
1603  owl_fmtext_free(&fm);
1604}
1605
1606void owl_function_page_curmsg(int step)
1607{
1608  /* scroll down or up within the current message IF the message is truncated */
1609
1610  int offset, curmsg, lines;
1611  owl_view *v;
1612  owl_message *m;
1613
1614  offset=owl_global_get_curmsg_vert_offset(&g);
1615  v=owl_global_get_current_view(&g);
1616  curmsg=owl_global_get_curmsg(&g);
1617  m=owl_view_get_element(v, curmsg);
1618  if (!m || owl_view_get_size(v)==0) return;
1619  lines=owl_message_get_numlines(m);
1620
1621  if (offset==0) {
1622    /* Bail if the curmsg isn't the last one displayed */
1623    if (curmsg != owl_mainwin_get_last_msg(owl_global_get_mainwin(&g))) {
1624      owl_function_makemsg("The entire message is already displayed");
1625      return;
1626    }
1627   
1628    /* Bail if we're not truncated */
1629    if (!owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g))) {
1630      owl_function_makemsg("The entire message is already displayed");
1631      return;
1632    }
1633  }
1634 
1635 
1636  /* don't scroll past the last line */
1637  if (step>0) {
1638    if (offset+step > lines-1) {
1639      owl_global_set_curmsg_vert_offset(&g, lines-1);
1640    } else {
1641      owl_global_set_curmsg_vert_offset(&g, offset+step);
1642    }
1643  }
1644
1645  /* would we be before the beginning of the message? */
1646  if (step<0) {
1647    if (offset+step<0) {
1648      owl_global_set_curmsg_vert_offset(&g, 0);
1649    } else {
1650      owl_global_set_curmsg_vert_offset(&g, offset+step);
1651    }
1652  }
1653 
1654  /* redisplay */
1655  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1656  owl_global_set_needrefresh(&g);
1657}
1658
1659void owl_function_resize_typwin(int newsize)
1660{
1661  owl_global_set_typwin_lines(&g, newsize);
1662  owl_function_resize();
1663}
1664
1665void owl_function_typwin_grow()
1666{
1667  int i;
1668
1669  i=owl_global_get_typwin_lines(&g);
1670  owl_function_resize_typwin(i+1);
1671}
1672
1673void owl_function_typwin_shrink()
1674{
1675  int i;
1676
1677  i=owl_global_get_typwin_lines(&g);
1678  if (i>2) {
1679    owl_function_resize_typwin(i-1);
1680  }
1681}
1682
1683void owl_function_mainwin_pagedown()
1684{
1685  int i;
1686
1687  i=owl_mainwin_get_last_msg(owl_global_get_mainwin(&g));
1688  if (i<0) return;
1689  if (owl_mainwin_is_last_msg_truncated(owl_global_get_mainwin(&g))
1690      && (owl_global_get_curmsg(&g) < i)
1691      && (i>0)) {
1692    i--;
1693  }
1694  owl_global_set_curmsg(&g, i);
1695  owl_function_nextmsg();
1696}
1697
1698void owl_function_mainwin_pageup()
1699{
1700  owl_global_set_curmsg(&g, owl_global_get_topmsg(&g));
1701  owl_function_prevmsg();
1702}
1703
1704void owl_function_getsubs()
1705{
1706  char *buff;
1707
1708  buff=owl_zephyr_getsubs();
1709
1710  if (buff) {
1711    owl_function_popless_text(buff);
1712  } else {
1713    owl_function_popless_text("Error getting subscriptions");
1714  }
1715           
1716  owl_free(buff);
1717}
1718
1719#define PABUFLEN 5000
1720void owl_function_printallvars()
1721{
1722  char buff[PABUFLEN], *pos, *name;
1723  owl_list varnames;
1724  int i, numvarnames, rem;
1725
1726  pos = buff;
1727  pos += sprintf(pos, "%-20s = %s\n", "VARIABLE", "VALUE");
1728  pos += sprintf(pos, "%-20s   %s\n",  "--------", "-----");
1729  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1730  rem = (buff+PABUFLEN)-pos-1;
1731  numvarnames = owl_list_get_size(&varnames);
1732  for (i=0; i<numvarnames; i++) {
1733    name = owl_list_get_element(&varnames, i);
1734    if (name && name[0]!='_') {
1735      rem = (buff+PABUFLEN)-pos-1;   
1736      pos += snprintf(pos, rem, "\n%-20s = ", name);
1737      rem = (buff+PABUFLEN)-pos-1;   
1738      owl_variable_get_tostring(owl_global_get_vardict(&g), name, pos, rem);
1739      pos = buff+strlen(buff);
1740    }
1741  }
1742  rem = (buff+PABUFLEN)-pos-1;   
1743  snprintf(pos, rem, "\n");
1744  owl_variable_dict_namelist_free(&varnames);
1745 
1746  owl_function_popless_text(buff);
1747}
1748
1749void owl_function_show_variables()
1750{
1751  owl_list varnames;
1752  owl_fmtext fm; 
1753  int i, numvarnames;
1754  char *varname;
1755
1756  owl_fmtext_init_null(&fm);
1757  owl_fmtext_append_bold(&fm, 
1758      "Variables: (use 'show variable <name>' for details)\n");
1759  owl_variable_dict_get_names(owl_global_get_vardict(&g), &varnames);
1760  numvarnames = owl_list_get_size(&varnames);
1761  for (i=0; i<numvarnames; i++) {
1762    varname = owl_list_get_element(&varnames, i);
1763    if (varname && varname[0]!='_') {
1764      owl_variable_describe(owl_global_get_vardict(&g), varname, &fm);
1765    }
1766  }
1767  owl_variable_dict_namelist_free(&varnames);
1768  owl_function_popless_fmtext(&fm);
1769  owl_fmtext_free(&fm);
1770}
1771
1772void owl_function_show_variable(char *name)
1773{
1774  owl_fmtext fm; 
1775
1776  owl_fmtext_init_null(&fm);
1777  owl_variable_get_help(owl_global_get_vardict(&g), name, &fm);
1778  owl_function_popless_fmtext(&fm);
1779  owl_fmtext_free(&fm); 
1780}
1781
1782/* note: this applies to global message list, not to view.
1783 * If flag is 1, deletes.  If flag is 0, undeletes. */
1784void owl_function_delete_by_id(int id, int flag)
1785{
1786  owl_messagelist *ml;
1787  owl_message *m;
1788  ml = owl_global_get_msglist(&g);
1789  m = owl_messagelist_get_by_id(ml, id);
1790  if (m) {
1791    if (flag == 1) {
1792      owl_message_mark_delete(m);
1793    } else if (flag == 0) {
1794      owl_message_unmark_delete(m);
1795    }
1796    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1797    owl_global_set_needrefresh(&g);
1798  } else {
1799    owl_function_error("No message with id %d: unable to mark for (un)delete",id);
1800  }
1801}
1802
1803void owl_function_delete_automsgs()
1804{
1805  /* mark for deletion all messages in the current view that match the
1806   * 'trash' filter */
1807
1808  int i, j, count;
1809  owl_message *m;
1810  owl_view *v;
1811  owl_filter *f;
1812
1813  /* get the trash filter */
1814  f=owl_global_get_filter(&g, "trash");
1815  if (!f) {
1816    owl_function_error("No trash filter defined");
1817    return;
1818  }
1819
1820  v=owl_global_get_current_view(&g);
1821
1822  count=0;
1823  j=owl_view_get_size(v);
1824  for (i=0; i<j; i++) {
1825    m=owl_view_get_element(v, i);
1826    if (owl_filter_message_match(f, m)) {
1827      count++;
1828      owl_message_mark_delete(m);
1829    }
1830  }
1831  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
1832  owl_function_makemsg("%i messages marked for deletion", count);
1833  owl_global_set_needrefresh(&g);
1834}
1835
1836void owl_function_status()
1837{
1838  char buff[5000];
1839  time_t start;
1840  int up, days, hours, minutes;
1841  owl_fmtext fm;
1842
1843  owl_fmtext_init_null(&fm);
1844
1845  start=owl_global_get_starttime(&g);
1846
1847  owl_fmtext_append_normal(&fm, "General Information:\n");
1848
1849  owl_fmtext_append_normal(&fm, "  Version: ");
1850  owl_fmtext_append_normal(&fm, OWL_VERSION_STRING);
1851  owl_fmtext_append_normal(&fm, "\n");
1852
1853  owl_fmtext_append_normal(&fm, "  Startup Arugments: ");
1854  owl_fmtext_append_normal(&fm, owl_global_get_startupargs(&g));
1855  owl_fmtext_append_normal(&fm, "\n");
1856
1857  owl_fmtext_append_normal(&fm, "  Current Directory: ");
1858  (void) getcwd(buff, MAXPATHLEN);
1859  owl_fmtext_append_normal(&fm, buff);
1860  owl_fmtext_append_normal(&fm, "\n");
1861
1862  sprintf(buff, "  Startup Time: %s", ctime(&start));
1863  owl_fmtext_append_normal(&fm, buff);
1864
1865  up=owl_global_get_runtime(&g);
1866  days=up/86400;
1867  up-=days*86400;
1868  hours=up/3600;
1869  up-=hours*3600;
1870  minutes=up/60;
1871  up-=minutes*60;
1872  sprintf(buff, "  Run Time: %i days %2.2i:%2.2i:%2.2i\n", days, hours, minutes, up);
1873  owl_fmtext_append_normal(&fm, buff);
1874
1875  owl_fmtext_append_normal(&fm, "\nProtocol Options:\n");
1876  owl_fmtext_append_normal(&fm, "  Zephyr included    : ");
1877  if (owl_global_is_havezephyr(&g)) {
1878    owl_fmtext_append_normal(&fm, "yes\n");
1879  } else {
1880    owl_fmtext_append_normal(&fm, "no\n");
1881  }
1882  owl_fmtext_append_normal(&fm, "  AIM included       : yes\n");
1883  owl_fmtext_append_normal(&fm, "  Loopback included  : yes\n");
1884
1885
1886  owl_fmtext_append_normal(&fm, "\nBuild Options:\n");
1887  owl_fmtext_append_normal(&fm, "  Stderr redirection : ");
1888#if OWL_STDERR_REDIR
1889  owl_fmtext_append_normal(&fm, "yes\n");
1890#else
1891  owl_fmtext_append_normal(&fm, "no\n");
1892#endif
1893 
1894
1895  owl_fmtext_append_normal(&fm, "\nMemory Usage:\n");
1896  owl_fmtext_append_normal(&fm, "  Not currently available.\n");
1897  /*
1898  sprintf(buff, "%sMemory Malloced: %i\n", buff, owl_global_get_malloced(&g));
1899  sprintf(buff, "%sMemory Freed: %i\n", buff, owl_global_get_freed(&g));
1900  sprintf(buff, "%sMemory In Use: %i\n", buff, owl_global_get_meminuse(&g));
1901  */
1902
1903  owl_fmtext_append_normal(&fm, "\nAIM Status:\n");
1904  owl_fmtext_append_normal(&fm, "  Logged in: ");
1905  if (owl_global_is_aimloggedin(&g)) {
1906    owl_fmtext_append_normal(&fm, owl_global_get_aim_screenname(&g));
1907    owl_fmtext_append_normal(&fm, "\n");
1908  } else {
1909    owl_fmtext_append_normal(&fm, "(not logged in)\n");
1910  }
1911
1912  owl_fmtext_append_normal(&fm, "  Processing events: ");
1913  if (owl_global_is_doaimevents(&g)) {
1914    owl_fmtext_append_normal(&fm, "yes\n");
1915  } else {
1916    owl_fmtext_append_normal(&fm, "no\n");
1917  }
1918
1919  owl_function_popless_fmtext(&fm);
1920  owl_fmtext_free(&fm);
1921}
1922
1923void owl_function_show_term()
1924{
1925  owl_fmtext fm;
1926  char buff[LINE];
1927
1928  owl_fmtext_init_null(&fm);
1929  sprintf(buff, "Terminal Lines: %i\nTerminal Columns: %i\n",
1930          owl_global_get_lines(&g),
1931          owl_global_get_cols(&g));
1932  owl_fmtext_append_normal(&fm, buff);
1933
1934  if (owl_global_get_hascolors(&g)) {
1935    owl_fmtext_append_normal(&fm, "Color: Yes\n");
1936    sprintf(buff, "Number of color pairs: %i\n", owl_global_get_colorpairs(&g));
1937    owl_fmtext_append_normal(&fm, buff);
1938    sprintf(buff, "Can change colors: %s\n", can_change_color() ? "yes" : "no");
1939    owl_fmtext_append_normal(&fm, buff);
1940  } else {
1941    owl_fmtext_append_normal(&fm, "Color: No\n");
1942  }
1943
1944  owl_function_popless_fmtext(&fm);
1945  owl_fmtext_free(&fm);
1946}
1947
1948/* if type = 0 then normal reply.
1949 * if type = 1 then it's a reply to sender
1950 * if enter = 0 then allow the command to be edited
1951 * if enter = 1 then don't wait for editing
1952 */
1953void owl_function_reply(int type, int enter)
1954{
1955  char *buff=NULL, *oldbuff;
1956  owl_message *m;
1957  owl_filter *f;
1958 
1959  if (owl_view_get_size(owl_global_get_current_view(&g))==0) {
1960    owl_function_error("No message selected");
1961  } else {
1962    char *class, *inst, *to, *cc=NULL;
1963   
1964    m=owl_view_get_element(owl_global_get_current_view(&g), owl_global_get_curmsg(&g));
1965    if (!m) {
1966      owl_function_error("No message selected");
1967      return;
1968    }
1969
1970    /* first check if we catch the reply-lockout filter */
1971    f=owl_global_get_filter(&g, "reply-lockout");
1972    if (f) {
1973      if (owl_filter_message_match(f, m)) {
1974        owl_function_error("Sorry, replies to this message have been disabled by the reply-lockout filter");
1975        return;
1976      }
1977    }
1978
1979    /* admin */
1980    if (owl_message_is_type_admin(m)) {
1981      owl_function_error("You cannot reply to an admin message");
1982      return;
1983    }
1984
1985    /* loopback */
1986    if (owl_message_is_type_loopback(m)) {
1987      owl_function_loopwrite_setup();
1988      return;
1989    }
1990
1991    /* zephyr */
1992    if (owl_message_is_type_zephyr(m)) {
1993      /* if it's a zephyr we sent, send it out the same way again */
1994      if (owl_message_is_direction_out(m)) {
1995        owl_function_zwrite_setup(owl_message_get_zwriteline(m));
1996        owl_global_set_buffercommand(&g, owl_message_get_zwriteline(m));
1997        return;
1998      }
1999
2000      /* Special case a personal reply to a webzephyr user on a class */
2001      if ((type==1) && !strcasecmp(owl_message_get_opcode(m), OWL_WEBZEPHYR_OPCODE)) {
2002        class=OWL_WEBZEPHYR_CLASS;
2003        inst=owl_message_get_sender(m);
2004        to=OWL_WEBZEPHYR_PRINCIPAL;
2005      } else if (!strcasecmp(owl_message_get_class(m), OWL_WEBZEPHYR_CLASS) && owl_message_is_loginout(m)) {
2006        /* Special case LOGIN/LOGOUT notifications on class "webzephyr" */
2007        class=OWL_WEBZEPHYR_CLASS;
2008        inst=owl_message_get_instance(m);
2009        to=OWL_WEBZEPHYR_PRINCIPAL;
2010      } else if (owl_message_is_loginout(m)) {
2011        /* Normal LOGIN/LOGOUT messages */
2012        class="MESSAGE";
2013        inst="PERSONAL";
2014        to=owl_message_get_sender(m);
2015      } else if (type==1) {
2016        /* Personal reply */
2017        class="MESSAGE";
2018        inst="PERSONAL";
2019        to=owl_message_get_sender(m);
2020      } else {
2021        /* General reply */
2022        class=owl_message_get_class(m);
2023        inst=owl_message_get_instance(m);
2024        to=owl_message_get_recipient(m);
2025        cc=owl_message_get_cc(m);
2026        if (!strcmp(to, "") || !strcmp(to, "*")) {
2027          to="";
2028        } else if (to[0]=='@') {
2029          /* leave it, to get the realm */
2030        } else {
2031          to=owl_message_get_sender(m);
2032        }
2033      }
2034       
2035      /* create the command line */
2036      if (!strcasecmp(owl_message_get_opcode(m), "CRYPT")) {
2037        buff=owl_strdup("zcrypt");
2038      } else {
2039        buff = owl_strdup("zwrite");
2040      }
2041      if (strcasecmp(class, "message")) {
2042        buff = owl_sprintf("%s -c %s%s%s", oldbuff=buff, owl_getquoting(class), class, owl_getquoting(class));
2043        owl_free(oldbuff);
2044      }
2045      if (strcasecmp(inst, "personal")) {
2046        buff = owl_sprintf("%s -i %s%s%s", oldbuff=buff, owl_getquoting(inst), inst, owl_getquoting(inst));
2047        owl_free(oldbuff);
2048      }
2049      if (*to != '\0') {
2050        char *tmp, *oldtmp, *tmp2;
2051        tmp=short_zuser(to);
2052        if (cc) {
2053          tmp = owl_util_uniq(oldtmp=tmp, cc, "-");
2054          owl_free(oldtmp);
2055          buff = owl_sprintf("%s -C %s", oldbuff=buff, tmp);
2056          owl_free(oldbuff);
2057        } else {
2058          if (owl_global_is_smartstrip(&g)) {
2059            tmp2=tmp;
2060            tmp=owl_zephyr_smartstripped_user(tmp2);
2061            owl_free(tmp2);
2062          }
2063          buff = owl_sprintf("%s %s", oldbuff=buff, tmp);
2064          owl_free(oldbuff);
2065        }
2066        owl_free(tmp);
2067      }
2068      if (cc) owl_free(cc);
2069    }
2070
2071    /* aim */
2072    if (owl_message_is_type_aim(m)) {
2073      if (owl_message_is_direction_out(m)) {
2074        buff=owl_sprintf("aimwrite %s", owl_message_get_recipient(m));
2075      } else {
2076        buff=owl_sprintf("aimwrite %s", owl_message_get_sender(m));
2077      }
2078    }
2079   
2080    if (enter) {
2081      owl_history *hist = owl_global_get_cmd_history(&g);
2082      owl_history_store(hist, buff);
2083      owl_history_reset(hist);
2084      owl_function_command_norv(buff);
2085    } else {
2086      owl_function_start_command(buff);
2087    }
2088    owl_free(buff);
2089  }
2090}
2091
2092void owl_function_zlocate(int argc, char **argv, int auth)
2093{
2094  owl_fmtext fm;
2095  char *ptr, buff[LINE];
2096  int i;
2097
2098  owl_fmtext_init_null(&fm);
2099
2100  for (i=0; i<argc; i++) {
2101    ptr=long_zuser(argv[i]);
2102    owl_zephyr_zlocate(ptr, buff, auth);
2103    owl_fmtext_append_normal(&fm, buff);
2104    owl_free(ptr);
2105  }
2106
2107  owl_function_popless_fmtext(&fm);
2108  owl_fmtext_free(&fm);
2109}
2110
2111void owl_function_start_command(char *line)
2112{
2113  int i, j;
2114  owl_editwin *tw;
2115
2116  tw=owl_global_get_typwin(&g);
2117  owl_global_set_typwin_active(&g);
2118  owl_editwin_new_style(tw, OWL_EDITWIN_STYLE_ONELINE, 
2119                        owl_global_get_cmd_history(&g));
2120
2121  owl_editwin_set_locktext(tw, "command: ");
2122  owl_global_set_needrefresh(&g);
2123
2124  j=strlen(line);
2125  for (i=0; i<j; i++) {
2126    owl_editwin_process_char(tw, line[i]);
2127  }
2128  owl_editwin_redisplay(tw, 0);
2129
2130  owl_context_set_editline(owl_global_get_context(&g), tw);
2131  owl_function_activate_keymap("editline");
2132}
2133
2134void owl_function_start_question(char *line)
2135{
2136  owl_editwin *tw;
2137
2138  tw=owl_global_get_typwin(&g);
2139  owl_global_set_typwin_active(&g);
2140  owl_editwin_new_style(tw, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
2141
2142  owl_editwin_set_locktext(tw, line);
2143  owl_global_set_needrefresh(&g);
2144
2145  owl_editwin_redisplay(tw, 0);
2146
2147  owl_context_set_editresponse(owl_global_get_context(&g), tw);
2148  owl_function_activate_keymap("editresponse");
2149}
2150
2151void owl_function_start_password(char *line)
2152{
2153  owl_editwin *tw;
2154
2155  tw=owl_global_get_typwin(&g);
2156  owl_global_set_typwin_active(&g);
2157  owl_editwin_new_style(tw, OWL_EDITWIN_STYLE_ONELINE, owl_global_get_cmd_history(&g));
2158  owl_editwin_set_echochar(tw, '*');
2159
2160  owl_editwin_set_locktext(tw, line);
2161  owl_global_set_needrefresh(&g);
2162
2163  owl_editwin_redisplay(tw, 0);
2164
2165  owl_context_set_editresponse(owl_global_get_context(&g), tw);
2166  owl_function_activate_keymap("editresponse");
2167}
2168
2169char *owl_function_exec(int argc, char **argv, char *buff, int type)
2170{
2171  /* if type == 1 display in a popup
2172   * if type == 2 display an admin messages
2173   * if type == 0 return output
2174   * else display in a popup
2175   */
2176  char *newbuff, *redirect = " 2>&1 < /dev/null";
2177  char *out, buff2[1024];
2178  int size;
2179  FILE *p;
2180
2181#if OWL_STDERR_REDIR
2182  redirect = " < /dev/null";
2183#endif
2184
2185  if (argc<2) {
2186    owl_function_error("Wrong number of arguments to the exec command");
2187    return NULL;
2188  }
2189
2190  buff = skiptokens(buff, 1);
2191  newbuff = owl_malloc(strlen(buff)+strlen(redirect)+1);
2192  strcpy(newbuff, buff);
2193  strcat(newbuff, redirect);
2194
2195  p=popen(newbuff, "r");
2196  out=owl_malloc(1024);
2197  size=1024;
2198  strcpy(out, "");
2199  while (fgets(buff2, 1024, p)!=NULL) {
2200    size+=1024;
2201    out=owl_realloc(out, size);
2202    strcat(out, buff2);
2203  }
2204  pclose(p);
2205
2206  if (type==1) {
2207    owl_function_popless_text(out);
2208  } else if (type==0) {
2209    return out;
2210  } else if (type==2) {
2211    owl_function_adminmsg(buff, out);
2212  } else {
2213    owl_function_popless_text(out);
2214  }
2215  owl_free(out);
2216  return NULL;
2217}
2218
2219char *owl_function_perl(int argc, char **argv, char *buff, int type)
2220{
2221  /* if type == 1 display in a popup
2222   * if type == 2 display an admin messages
2223   * if type == 0 return output
2224   * else display in a popup
2225   */
2226  char *perlout;
2227
2228  if (argc<2) {
2229    owl_function_error("Wrong number of arguments to perl command");
2230    return NULL;
2231  }
2232
2233  /* consume first token (argv[0]) */
2234  buff = skiptokens(buff, 1);
2235
2236  perlout = owl_perlconfig_execute(buff);
2237  if (perlout) { 
2238    if (type==1) {
2239      owl_function_popless_text(perlout);
2240    } else if (type==2) {
2241      owl_function_adminmsg(buff, perlout);
2242    } else if (type==0) {
2243      return perlout;
2244    } else {
2245      owl_function_popless_text(perlout);
2246    }
2247    owl_free(perlout);
2248  }
2249  return NULL;
2250}
2251
2252void owl_function_change_currentview_filter(char *filtname)
2253{
2254  owl_view *v;
2255  owl_filter *f;
2256  int curid=-1, newpos, curmsg;
2257  owl_message *curm=NULL;
2258
2259  v=owl_global_get_current_view(&g);
2260
2261  curmsg=owl_global_get_curmsg(&g);
2262  if (curmsg==-1) {
2263    owl_function_debugmsg("Hit the curmsg==-1 case in change_view");
2264  } else {
2265    curm=owl_view_get_element(v, curmsg);
2266    if (curm) {
2267      curid=owl_message_get_id(curm);
2268      owl_view_save_curmsgid(v, curid);
2269    }
2270  }
2271
2272  f=owl_global_get_filter(&g, filtname);
2273  if (!f) {
2274    owl_function_error("Unknown filter %s", filtname);
2275    return;
2276  }
2277
2278  owl_view_new_filter(v, f);
2279
2280  /* Figure out what to set the current message to.
2281   * - If the view we're leaving has messages in it, go to the closest message
2282   *   to the last message pointed to in that view.
2283   * - If the view we're leaving is empty, try to restore the position
2284   *   from the last time we were in the new view.  */
2285  if (curm) {
2286    newpos = owl_view_get_nearest_to_msgid(v, curid);
2287  } else {
2288    newpos = owl_view_get_nearest_to_saved(v);
2289  }
2290
2291  owl_global_set_curmsg(&g, newpos);
2292  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
2293  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2294  owl_global_set_direction_downwards(&g);
2295}
2296
2297void owl_function_create_filter(int argc, char **argv)
2298{
2299  owl_filter *f;
2300  owl_view *v;
2301  int ret, inuse=0;
2302
2303  if (argc < 2) {
2304    owl_function_error("Wrong number of arguments to filter command");
2305    return;
2306  }
2307
2308  owl_function_debugmsg("owl_function_create_filter: starting to create filter named %s", argv[1]);
2309
2310  v=owl_global_get_current_view(&g);
2311
2312  /* don't touch the all filter */
2313  if (!strcmp(argv[1], "all")) {
2314    owl_function_error("You may not change the 'all' filter.");
2315    return;
2316  }
2317
2318  /* deal with the case of trying change the filter color */
2319  if (argc==4 && !strcmp(argv[2], "-c")) {
2320    f=owl_global_get_filter(&g, argv[1]);
2321    if (!f) {
2322      owl_function_error("The filter '%s' does not exist.", argv[1]);
2323      return;
2324    }
2325    if (owl_util_string_to_color(argv[3])==-1) {
2326      owl_function_error("The color '%s' is not available.", argv[3]);
2327      return;
2328    }
2329    owl_filter_set_color(f, owl_util_string_to_color(argv[3]));
2330    owl_global_set_needrefresh(&g);
2331    owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2332    return;
2333  }
2334
2335  /* create the filter and check for errors */
2336  f=owl_malloc(sizeof(owl_filter));
2337  ret=owl_filter_init(f, argv[1], argc-2, argv+2);
2338  if (ret==-1) {
2339    owl_free(f);
2340    owl_function_error("Invalid filter");
2341    return;
2342  }
2343
2344  /* if the named filter is in use by the current view, remember it */
2345  if (!strcmp(owl_view_get_filtname(v), argv[1])) {
2346    inuse=1;
2347  }
2348
2349  /* if the named filter already exists, nuke it */
2350  if (owl_global_get_filter(&g, argv[1])) {
2351    owl_global_remove_filter(&g, argv[1]);
2352  }
2353
2354  /* add the filter */
2355  owl_global_add_filter(&g, f);
2356
2357  /* if it was in use by the current view then update */
2358  if (inuse) {
2359    owl_function_change_currentview_filter(argv[1]);
2360  }
2361  owl_global_set_needrefresh(&g);
2362  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2363}
2364
2365/* If 'filtername' does not start with 'not-' create a filter named
2366 * 'not-<filtername>' defined as "not filter <filtername>".  If the
2367 * filter 'not-<filtername>' already exists, do not overwrite it.  If
2368 * 'filtername' begins with 'not-' and a filter 'filtername' already
2369 * exists, then do nothing.  If the filter 'filtername' does not
2370 * exist, create it and define it as 'not filter <filtername>'
2371 *
2372 * Returns the name of the negated filter, which the caller must free.
2373 */
2374char *owl_function_create_negative_filter(char *filtername)
2375{
2376  char *newname;
2377  owl_filter *tmpfilt;
2378  char *argv[5];
2379
2380  owl_function_debugmsg("owl_function_create_negative_filter");
2381 
2382  if (!strncmp(filtername, "not-", 4)) {
2383    newname=owl_strdup(filtername+4);
2384  } else {
2385    newname=owl_sprintf("not-%s", filtername);
2386  }
2387
2388  tmpfilt=owl_global_get_filter(&g, newname);
2389  if (!tmpfilt) {
2390    argv[0]="filter"; /* anything is fine here */
2391    argv[1]=newname;
2392    argv[2]="not";
2393    argv[3]="filter";
2394    argv[4]=filtername;
2395    owl_function_create_filter(5, argv);
2396  }
2397
2398  owl_function_debugmsg("owl_function_create_negative_filter: returning with %s", newname);
2399  return(newname);
2400}
2401
2402void owl_function_show_filters()
2403{
2404  owl_list *l;
2405  owl_filter *f;
2406  int i, j;
2407  owl_fmtext fm;
2408
2409  owl_fmtext_init_null(&fm);
2410
2411  l=owl_global_get_filterlist(&g);
2412  j=owl_list_get_size(l);
2413
2414  owl_fmtext_append_bold(&fm, "Filters:\n");
2415
2416  for (i=0; i<j; i++) {
2417    f=owl_list_get_element(l, i);
2418    owl_fmtext_append_normal(&fm, "   ");
2419    if (owl_global_get_hascolors(&g)) {
2420      owl_fmtext_append_normal_color(&fm, owl_filter_get_name(f), owl_filter_get_color(f));
2421    } else {
2422      owl_fmtext_append_normal(&fm, owl_filter_get_name(f));
2423    }
2424    owl_fmtext_append_normal(&fm, "\n");
2425  }
2426  owl_function_popless_fmtext(&fm);
2427  owl_fmtext_free(&fm);
2428}
2429
2430void owl_function_show_filter(char *name)
2431{
2432  owl_filter *f;
2433  char buff[5000];
2434
2435  f=owl_global_get_filter(&g, name);
2436  if (!f) {
2437    owl_function_error("There is no filter named %s", name);
2438    return;
2439  }
2440  owl_filter_print(f, buff);
2441  owl_function_popless_text(buff);
2442}
2443
2444void owl_function_show_zpunts()
2445{
2446  owl_filter *f;
2447  owl_list *fl;
2448  char buff[5000];
2449  owl_fmtext fm;
2450  int i, j;
2451
2452  owl_fmtext_init_null(&fm);
2453
2454  fl=owl_global_get_puntlist(&g);
2455  j=owl_list_get_size(fl);
2456  owl_fmtext_append_bold(&fm, "Active zpunt filters:\n");
2457
2458  for (i=0; i<j; i++) {
2459    f=owl_list_get_element(fl, i);
2460    owl_filter_print(f, buff);
2461    owl_fmtext_append_normal(&fm, buff);
2462  }
2463  owl_function_popless_fmtext(&fm);
2464  owl_fmtext_free(&fm);
2465}
2466
2467/* Create a filter for a class, instance if one doesn't exist.  If
2468 * instance is NULL then catch all messgaes in the class.  Returns the
2469 * name of the filter, which the caller must free.
2470 */
2471char *owl_function_classinstfilt(char *class, char *instance) 
2472{
2473  owl_list *fl;
2474  owl_filter *f;
2475  char *argbuff, *filtname;
2476  char *tmpclass, *tmpinstance = NULL;
2477  int len;
2478
2479  fl=owl_global_get_filterlist(&g);
2480
2481  /* name for the filter */
2482  len=strlen(class)+30;
2483  if (instance) len+=strlen(instance);
2484  filtname=owl_malloc(len);
2485  if (!instance) {
2486    sprintf(filtname, "class-%s", class);
2487  } else {
2488    sprintf(filtname, "class-%s-instance-%s", class, instance);
2489  }
2490  /* downcase it */
2491  downstr(filtname);
2492  /* turn spaces into dots */
2493  owl_text_tr(filtname, ' ', '.');
2494 
2495  /* if it already exists then go with it.  This lets users override */
2496  if (owl_global_get_filter(&g, filtname)) {
2497    return(filtname);
2498  }
2499
2500  /* create the new filter */
2501  argbuff=owl_malloc(len+20);
2502  tmpclass=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2503  owl_text_tr(tmpclass, ' ', '.');
2504  if (instance) {
2505    tmpinstance=owl_text_quote(instance, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2506    owl_text_tr(tmpinstance, ' ', '.');
2507  }
2508  sprintf(argbuff, "( class ^%s$ )", tmpclass);
2509  if (tmpinstance) {
2510    sprintf(argbuff, "%s and ( instance ^%s$ )", argbuff, tmpinstance);
2511  }
2512  owl_free(tmpclass);
2513  if (tmpinstance) owl_free(tmpinstance);
2514
2515  f=owl_malloc(sizeof(owl_filter));
2516  owl_filter_init_fromstring(f, filtname, argbuff);
2517
2518  /* add it to the global list */
2519  owl_global_add_filter(&g, f);
2520
2521  owl_free(argbuff);
2522  return(filtname);
2523}
2524
2525/* Create a filter for personal zephyrs to or from the specified
2526 * zephyr user.  Includes login/logout notifications for the user.
2527 * The name of the filter will be 'user-<user>'.  If a filter already
2528 * exists with this name, no new filter will be created.  This allows
2529 * the configuration to override this function.  Returns the name of
2530 * the filter, which the caller must free.
2531 */
2532char *owl_function_zuserfilt(char *user)
2533{
2534  owl_filter *f;
2535  char *argbuff, *longuser, *shortuser, *filtname;
2536
2537  /* stick the local realm on if it's not there */
2538  longuser=long_zuser(user);
2539  shortuser=short_zuser(user);
2540
2541  /* name for the filter */
2542  filtname=owl_malloc(strlen(shortuser)+20);
2543  sprintf(filtname, "user-%s", shortuser);
2544
2545  /* if it already exists then go with it.  This lets users override */
2546  if (owl_global_get_filter(&g, filtname)) {
2547    return(owl_strdup(filtname));
2548  }
2549
2550  /* create the new-internal filter */
2551  f=owl_malloc(sizeof(owl_filter));
2552
2553  argbuff=owl_malloc(strlen(longuser)+1000);
2554  sprintf(argbuff, "( type ^zephyr$ and ( class ^message$ and instance ^personal$ and ");
2555  sprintf(argbuff, "%s ( ( direction ^in$ and sender ^%s$ ) or ( direction ^out$ and recipient ^%s$ ) ) )", argbuff, longuser, longuser);
2556  sprintf(argbuff, "%s or ( ( class ^login$ ) and ( sender ^%s$ ) ) )", argbuff, longuser);
2557
2558  owl_filter_init_fromstring(f, filtname, argbuff);
2559
2560  /* add it to the global list */
2561  owl_global_add_filter(&g, f);
2562
2563  /* free stuff */
2564  owl_free(argbuff);
2565  owl_free(longuser);
2566  owl_free(shortuser);
2567
2568  return(filtname);
2569}
2570
2571/* Create a filter for AIM IM messages to or from the specified
2572 * screenname.  The name of the filter will be 'aimuser-<user>'.  If a
2573 * filter already exists with this name, no new filter will be
2574 * created.  This allows the configuration to override this function.
2575 * Returns the name of the filter, which the caller must free.
2576 */
2577char *owl_function_aimuserfilt(char *user)
2578{
2579  owl_filter *f;
2580  char *argbuff, *filtname;
2581
2582  /* name for the filter */
2583  filtname=owl_malloc(strlen(user)+40);
2584  sprintf(filtname, "aimuser-%s", user);
2585
2586  /* if it already exists then go with it.  This lets users override */
2587  if (owl_global_get_filter(&g, filtname)) {
2588    return(owl_strdup(filtname));
2589  }
2590
2591  /* create the new-internal filter */
2592  f=owl_malloc(sizeof(owl_filter));
2593
2594  argbuff=owl_malloc(1000);
2595  sprintf(argbuff,
2596          "( type ^aim$ and ( ( sender ^%s$ and recipient ^%s$ ) or ( sender ^%s$ and recipient ^%s$ ) ) )",
2597          user, owl_global_get_aim_screenname(&g), owl_global_get_aim_screenname(&g), user);
2598
2599  owl_filter_init_fromstring(f, filtname, argbuff);
2600
2601  /* add it to the global list */
2602  owl_global_add_filter(&g, f);
2603
2604  /* free stuff */
2605  owl_free(argbuff);
2606
2607  return(filtname);
2608}
2609
2610char *owl_function_typefilt(char *type)
2611{
2612  owl_filter *f;
2613  char *argbuff, *filtname;
2614
2615  /* name for the filter */
2616  filtname=owl_sprintf("type-%s", type);
2617
2618  /* if it already exists then go with it.  This lets users override */
2619  if (owl_global_get_filter(&g, filtname)) {
2620    return filtname;
2621  }
2622
2623  /* create the new-internal filter */
2624  f=owl_malloc(sizeof(owl_filter));
2625
2626  argbuff = owl_sprintf("type ^%s$", type);
2627
2628  owl_filter_init_fromstring(f, filtname, argbuff);
2629
2630  /* add it to the global list */
2631  owl_global_add_filter(&g, f);
2632
2633  /* free stuff */
2634  owl_free(argbuff);
2635
2636  return filtname;
2637}
2638
2639/* If flag is 1, marks for deletion.  If flag is 0,
2640 * unmarks for deletion. */
2641void owl_function_delete_curview_msgs(int flag)
2642{
2643  owl_view *v;
2644  int i, j;
2645
2646  v=owl_global_get_current_view(&g);
2647  j=owl_view_get_size(v);
2648  for (i=0; i<j; i++) {
2649    if (flag == 1) {
2650      owl_message_mark_delete(owl_view_get_element(v, i));
2651    } else if (flag == 0) {
2652      owl_message_unmark_delete(owl_view_get_element(v, i));
2653    }
2654  }
2655
2656  owl_function_makemsg("%i messages marked for %sdeletion", j, flag?"":"un");
2657
2658  owl_mainwin_redisplay(owl_global_get_mainwin(&g)); 
2659}
2660
2661/* Create a filter based on the current message.  Returns the name of
2662 * a filter or null.  The caller must free this name.
2663 *
2664 * if the curmsg is a personal zephyr return a filter name
2665 *    to the zephyr converstaion with that user.
2666 * If the curmsg is a zephyr class message, instance foo, recip *,
2667 *    return a filter name to the class, inst.
2668 * If the curmsg is a zephyr class message and type==0 then
2669 *    return a filter name for just the class.
2670 * If the curmsg is a zephyr class message and type==1 then
2671 *    return a filter name for the class and instance.
2672 * If the curmsg is a personal AIM message returna  filter
2673 *    name to the AIM conversation with that user
2674 */
2675char *owl_function_smartfilter(int type)
2676{
2677  owl_view *v;
2678  owl_message *m;
2679  char *zperson, *filtname=NULL;
2680 
2681  v=owl_global_get_current_view(&g);
2682  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2683
2684  if (!m || owl_view_get_size(v)==0) {
2685    owl_function_error("No message selected\n");
2686    return(NULL);
2687  }
2688
2689  /* very simple handling of admin messages for now */
2690  if (owl_message_is_type_admin(m)) {
2691    return(owl_function_typefilt("admin"));
2692  }
2693
2694  /* very simple handling of loopback messages for now */
2695  if (owl_message_is_type_loopback(m)) {
2696    return(owl_function_typefilt("loopback"));
2697  }
2698
2699  /* aim messages */
2700  if (owl_message_is_type_aim(m)) {
2701    if (owl_message_is_direction_in(m)) {
2702      filtname=owl_function_aimuserfilt(owl_message_get_sender(m));
2703    } else if (owl_message_is_direction_out(m)) {
2704      filtname=owl_function_aimuserfilt(owl_message_get_recipient(m));
2705    }
2706    return(filtname);
2707  }
2708
2709  /* narrow personal and login messages to the sender or recip as appropriate */
2710  if (owl_message_is_personal(m) || owl_message_is_loginout(m)) {
2711    if (owl_message_is_type_zephyr(m)) {
2712      if (owl_message_is_direction_in(m)) {
2713        zperson=short_zuser(owl_message_get_sender(m));
2714      } else {
2715        zperson=short_zuser(owl_message_get_recipient(m));
2716      }
2717      filtname=owl_function_zuserfilt(zperson);
2718      owl_free(zperson);
2719      return(filtname);
2720    }
2721    return(NULL);
2722  }
2723
2724  /* narrow class MESSAGE, instance foo, recip * messages to class, inst */
2725  if (!strcasecmp(owl_message_get_class(m), "message") && !owl_message_is_personal(m)) {
2726    filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m));
2727    return(filtname);
2728  }
2729
2730  /* otherwise narrow to the class */
2731  if (type==0) {
2732    filtname=owl_function_classinstfilt(owl_message_get_class(m), NULL);
2733  } else if (type==1) {
2734    filtname=owl_function_classinstfilt(owl_message_get_class(m), owl_message_get_instance(m));
2735  }
2736  return(filtname);
2737}
2738
2739void owl_function_smartzpunt(int type)
2740{
2741  /* Starts a zpunt command based on the current class,instance pair.
2742   * If type=0, uses just class.  If type=1, uses instance as well. */
2743  owl_view *v;
2744  owl_message *m;
2745  char *cmd, *cmdprefix, *mclass, *minst;
2746 
2747  v=owl_global_get_current_view(&g);
2748  m=owl_view_get_element(v, owl_global_get_curmsg(&g));
2749
2750  if (!m || owl_view_get_size(v)==0) {
2751    owl_function_error("No message selected\n");
2752    return;
2753  }
2754
2755  /* for now we skip admin messages. */
2756  if (owl_message_is_type_admin(m)
2757      || owl_message_is_loginout(m)
2758      || !owl_message_is_type_zephyr(m)) {
2759    owl_function_error("smartzpunt doesn't support this message type.");
2760    return;
2761  }
2762
2763  mclass = owl_message_get_class(m);
2764  minst = owl_message_get_instance(m);
2765  if (!mclass || !*mclass || *mclass==' '
2766      || (!strcasecmp(mclass, "message") && !strcasecmp(minst, "personal"))
2767      || (type && (!minst || !*minst|| *minst==' '))) {
2768    owl_function_error("smartzpunt can't safely do this for <%s,%s>",
2769                         mclass, minst);
2770  } else {
2771    cmdprefix = "start-command zpunt ";
2772    cmd = owl_malloc(strlen(cmdprefix)+strlen(mclass)+strlen(minst)+10);
2773    strcpy(cmd, cmdprefix);
2774    strcat(cmd, owl_getquoting(mclass));
2775    strcat(cmd, mclass);
2776    strcat(cmd, owl_getquoting(mclass));
2777    if (type) {
2778      strcat(cmd, " ");
2779      strcat(cmd, owl_getquoting(minst));
2780      strcat(cmd, minst);
2781      strcat(cmd, owl_getquoting(minst));
2782    } else {
2783      strcat(cmd, " *");
2784    }
2785    owl_function_command(cmd);
2786    owl_free(cmd);
2787  }
2788}
2789
2790void owl_function_color_current_filter(char *color)
2791{
2792  owl_filter *f;
2793  char *name;
2794
2795  name=owl_view_get_filtname(owl_global_get_current_view(&g));
2796  f=owl_global_get_filter(&g, name);
2797  if (!f) {
2798    owl_function_error("Unknown filter");
2799    return;
2800  }
2801
2802  /* don't touch the all filter */
2803  if (!strcmp(name, "all")) {
2804    owl_function_error("You may not change the 'all' filter.");
2805    return;
2806  }
2807
2808  /* deal with the case of trying change the filter color */
2809  if (owl_util_string_to_color(color)==-1) {
2810    owl_function_error("No color named '%s' avilable.");
2811    return;
2812  }
2813  owl_filter_set_color(f, owl_util_string_to_color(color));
2814  owl_global_set_needrefresh(&g);
2815  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
2816}
2817
2818void owl_function_show_colors()
2819{
2820  owl_fmtext fm;
2821
2822  owl_fmtext_init_null(&fm);
2823  owl_fmtext_append_normal_color(&fm, "default\n", OWL_COLOR_DEFAULT);
2824  owl_fmtext_append_normal_color(&fm, "red\n", OWL_COLOR_RED);
2825  owl_fmtext_append_normal_color(&fm, "green\n", OWL_COLOR_GREEN);
2826  owl_fmtext_append_normal_color(&fm, "yellow\n", OWL_COLOR_YELLOW);
2827  owl_fmtext_append_normal_color(&fm, "blue\n", OWL_COLOR_BLUE);
2828  owl_fmtext_append_normal_color(&fm, "magenta\n", OWL_COLOR_MAGENTA);
2829  owl_fmtext_append_normal_color(&fm, "cyan\n", OWL_COLOR_CYAN);
2830  owl_fmtext_append_normal_color(&fm, "white\n", OWL_COLOR_WHITE);
2831
2832  owl_function_popless_fmtext(&fm);
2833  owl_fmtext_free(&fm);
2834}
2835
2836/* add the given class, inst, recip to the punt list for filtering.
2837 *   if direction==0 then punt
2838 *   if direction==1 then unpunt
2839 */
2840void owl_function_zpunt(char *class, char *inst, char *recip, int direction)
2841{
2842  owl_filter *f;
2843  owl_list *fl;
2844  char *buff;
2845  char *quoted;
2846  int ret, i, j;
2847
2848  fl=owl_global_get_puntlist(&g);
2849
2850  /* first, create the filter */
2851  f=malloc(sizeof(owl_filter));
2852  buff=malloc(strlen(class)+strlen(inst)+strlen(recip)+100);
2853  strcpy(buff, "class");
2854  if (!strcmp(class, "*")) {
2855    strcat(buff, " .*");
2856  } else {
2857    quoted=owl_text_quote(class, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2858    owl_text_tr(quoted, ' ', '.');
2859    sprintf(buff, "%s ^%s$", buff, quoted);
2860    owl_free(quoted);
2861  }
2862  if (!strcmp(inst, "*")) {
2863    strcat(buff, " and instance .*");
2864  } else {
2865    quoted=owl_text_quote(inst, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2866    owl_text_tr(quoted, ' ', '.');
2867    sprintf(buff, "%s and instance ^%s$", buff, quoted);
2868    owl_free(quoted);
2869  }
2870  if (strcmp(recip, "*")) {
2871    quoted=owl_text_quote(recip, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
2872    owl_text_tr(quoted, ' ', '.');
2873    sprintf(buff, "%s and recipient ^%s$", buff, quoted);
2874    owl_free(quoted);
2875  }
2876 
2877  owl_function_debugmsg("About to filter %s", buff);
2878  ret=owl_filter_init_fromstring(f, "punt-filter", buff);
2879  owl_free(buff);
2880  if (ret) {
2881    owl_function_error("Error creating filter for zpunt");
2882    owl_filter_free(f);
2883    return;
2884  }
2885
2886  /* Check for an identical filter */
2887  j=owl_list_get_size(fl);
2888  for (i=0; i<j; i++) {
2889    if (owl_filter_equiv(f, owl_list_get_element(fl, i))) {
2890      /* if we're punting, then just silently bow out on this duplicate */
2891      if (direction==0) {
2892        owl_filter_free(f);
2893        return;
2894      }
2895
2896      /* if we're unpunting, then remove this filter from the puntlist */
2897      if (direction==1) {
2898        owl_filter_free(owl_list_get_element(fl, i));
2899        owl_list_remove_element(fl, i);
2900        return;
2901      }
2902    }
2903  }
2904
2905  /* If we're punting, add the filter to the global punt list */
2906  if (direction==0) {
2907    owl_list_append_element(fl, f);
2908  }
2909}
2910
2911void owl_function_activate_keymap(char *keymap)
2912{
2913  if (!owl_keyhandler_activate(owl_global_get_keyhandler(&g), keymap)) {
2914    owl_function_error("Unable to activate keymap '%s'", keymap);
2915  }
2916}
2917
2918void owl_function_show_keymaps()
2919{
2920  owl_list l;
2921  owl_fmtext fm;
2922  owl_keymap *km;
2923  owl_keyhandler *kh;
2924  int i, numkm;
2925  char *kmname;
2926
2927  kh = owl_global_get_keyhandler(&g);
2928  owl_fmtext_init_null(&fm);
2929  owl_fmtext_append_bold(&fm, "Keymaps:   ");
2930  owl_fmtext_append_normal(&fm, "(use 'show keymap <name>' for details)\n");
2931  owl_keyhandler_get_keymap_names(kh, &l);
2932  owl_fmtext_append_list(&fm, &l, "\n", owl_function_keymap_summary);
2933  owl_fmtext_append_normal(&fm, "\n");
2934
2935  numkm = owl_list_get_size(&l);
2936  for (i=0; i<numkm; i++) {
2937    kmname = owl_list_get_element(&l, i);
2938    km = owl_keyhandler_get_keymap(kh, kmname);
2939    owl_fmtext_append_bold(&fm, "\n\n----------------------------------------------------------------------------------------------------\n\n");
2940    owl_keymap_get_details(km, &fm);   
2941  }
2942  owl_fmtext_append_normal(&fm, "\n");
2943 
2944  owl_function_popless_fmtext(&fm);
2945  owl_keyhandler_keymap_namelist_free(&l);
2946  owl_fmtext_free(&fm);
2947}
2948
2949char *owl_function_keymap_summary(void *name)
2950{
2951  owl_keymap *km
2952    = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2953  if (km) return owl_keymap_summary(km);
2954  else return(NULL);
2955}
2956
2957/* TODO: implement for real */
2958void owl_function_show_keymap(char *name)
2959{
2960  owl_fmtext fm;
2961  owl_keymap *km;
2962
2963  owl_fmtext_init_null(&fm);
2964  km = owl_keyhandler_get_keymap(owl_global_get_keyhandler(&g), name);
2965  if (km) {
2966    owl_keymap_get_details(km, &fm);
2967  } else {
2968    owl_fmtext_append_normal(&fm, "No such keymap...\n");
2969  } 
2970  owl_function_popless_fmtext(&fm);
2971  owl_fmtext_free(&fm);
2972}
2973
2974void owl_function_help_for_command(char *cmdname)
2975{
2976  owl_fmtext fm;
2977
2978  owl_fmtext_init_null(&fm);
2979  owl_cmd_get_help(owl_global_get_cmddict(&g), cmdname, &fm);
2980  owl_function_popless_fmtext(&fm); 
2981  owl_fmtext_free(&fm);
2982}
2983
2984void owl_function_search_start(char *string, int direction)
2985{
2986  /* direction is OWL_DIRECTION_DOWNWARDS or OWL_DIRECTION_UPWARDS */
2987  owl_global_set_search_active(&g, string);
2988  owl_function_search_helper(0, direction);
2989}
2990
2991void owl_function_search_continue(int direction)
2992{
2993  /* direction is OWL_DIRECTION_DOWNWARDS or OWL_DIRECTION_UPWARDS */
2994  owl_function_search_helper(1, direction);
2995}
2996
2997void owl_function_search_helper(int mode, int direction)
2998{
2999  /* move to a message that contains the string.  If direction is
3000   * OWL_DIRECTION_DOWNWARDS then search fowards, if direction is
3001   * OWL_DIRECTION_UPWARDS then search backwards.
3002   *
3003   * If mode==0 then it will stay on the current message if it
3004   * contains the string.
3005   */
3006
3007  owl_view *v;
3008  int viewsize, i, curmsg, start;
3009  owl_message *m;
3010
3011  v=owl_global_get_current_view(&g);
3012  viewsize=owl_view_get_size(v);
3013  curmsg=owl_global_get_curmsg(&g);
3014 
3015  if (viewsize==0) {
3016    owl_function_error("No messages present");
3017    return;
3018  }
3019
3020  if (mode==0) {
3021    start=curmsg;
3022  } else if (direction==OWL_DIRECTION_DOWNWARDS) {
3023    start=curmsg+1;
3024  } else {
3025    start=curmsg-1;
3026  }
3027
3028  /* bounds check */
3029  if (start>=viewsize || start<0) {
3030    owl_function_error("No further matches found");
3031    return;
3032  }
3033
3034  for (i=start; i<viewsize && i>=0;) {
3035    m=owl_view_get_element(v, i);
3036    if (owl_message_search(m, owl_global_get_search_string(&g))) {
3037      owl_global_set_curmsg(&g, i);
3038      owl_function_calculate_topmsg(direction);
3039      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3040      if (direction==OWL_DIRECTION_DOWNWARDS) {
3041        owl_global_set_direction_downwards(&g);
3042      } else {
3043        owl_global_set_direction_upwards(&g);
3044      }
3045      return;
3046    }
3047    if (direction==OWL_DIRECTION_DOWNWARDS) {
3048      i++;
3049    } else {
3050      i--;
3051    }
3052  }
3053  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3054  owl_function_error("No matches found");
3055}
3056
3057/* strips formatting from ztext and returns the unformatted text.
3058 * caller is responsible for freeing. */
3059char *owl_function_ztext_stylestrip(char *zt)
3060{
3061  owl_fmtext fm;
3062  char *plaintext;
3063
3064  owl_fmtext_init_null(&fm);
3065  owl_fmtext_append_ztext(&fm, zt);
3066  plaintext = owl_fmtext_print_plain(&fm);
3067  owl_fmtext_free(&fm);
3068  return(plaintext);
3069}
3070
3071/* Popup a buddylisting.  If filename is NULL use the default .anyone */
3072void owl_function_buddylist(int aim, int zephyr, char *filename)
3073{
3074  int i, j, x, idle;
3075  owl_fmtext fm;
3076  owl_buddylist *bl;
3077  owl_buddy *b;
3078  owl_list anyone;
3079  char *foo, *timestr;
3080#ifdef HAVE_LIBZEPHYR
3081  char *tmp, *user, *line;
3082  ZLocations_t location[200];
3083  int numlocs, ret;
3084#endif
3085
3086  owl_fmtext_init_null(&fm);
3087
3088  /* AIM first */
3089  if (aim && owl_global_is_aimloggedin(&g)) {
3090    bl=owl_global_get_buddylist(&g);
3091
3092    owl_fmtext_append_bold(&fm, "AIM users logged in:\n");
3093    /* we're assuming AIM for now */
3094    j=owl_buddylist_get_size(bl);
3095    for (i=0; i<j; i++) {
3096      b=owl_buddylist_get_buddy_n(bl, i);
3097      idle=owl_buddy_get_idle_time(b);
3098      if (idle!=0) {
3099        timestr=owl_util_minutes_to_timestr(idle);
3100      } else {
3101        timestr=owl_strdup("");
3102      }
3103      foo=owl_sprintf("  %-20.20s %-12.12s\n", owl_buddy_get_name(b), timestr);
3104      owl_fmtext_append_normal(&fm, foo);
3105      owl_free(timestr);
3106      owl_free(foo);
3107    }
3108  }
3109
3110#ifdef HAVE_LIBZEPHYR
3111  if (zephyr) {
3112    owl_fmtext_append_bold(&fm, "Zephyr users logged in:\n");
3113    owl_list_create(&anyone);
3114    ret=owl_zephyr_get_anyone_list(&anyone, filename);
3115    if (ret) {
3116      owl_fmtext_append_normal(&fm, "  Error opening file for zephyr buddies.\n");
3117    } else {
3118      j=owl_list_get_size(&anyone);
3119      for (i=0; i<j; i++) {
3120        user=owl_list_get_element(&anyone, i);
3121        ret=ZLocateUser(user, &numlocs, ZAUTH);
3122        if (ret!=ZERR_NONE) {
3123          owl_function_error("Error getting location for %s", user);
3124          continue;
3125        }
3126       
3127        numlocs=200;
3128        ret=ZGetLocations(location, &numlocs);
3129        if (ret==0) {
3130          for (x=0; x<numlocs; x++) {
3131            line=malloc(strlen(location[x].host)+strlen(location[x].time)+strlen(location[x].tty)+100);
3132            tmp=short_zuser(user);
3133            sprintf(line, "  %-10.10s %-24.24s %-12.12s  %20.20s\n",
3134                    tmp,
3135                    location[x].host,
3136                    location[x].tty,
3137                    location[x].time);
3138            owl_fmtext_append_normal(&fm, line);
3139            owl_free(tmp);
3140          }
3141          if (numlocs>=200) {
3142            owl_fmtext_append_normal(&fm, "  Too many locations found for this user, truncating.\n");
3143          }
3144        }
3145      }
3146    }
3147    owl_list_free_all(&anyone, owl_free);
3148  }
3149#endif
3150 
3151  owl_function_popless_fmtext(&fm);
3152  owl_fmtext_free(&fm);
3153}
3154
3155/* Dump messages in the current view to the file 'filename'. */
3156void owl_function_dump(char *filename) 
3157{
3158  int i, j, count;
3159  owl_message *m;
3160  owl_view *v;
3161  FILE *file;
3162
3163  v=owl_global_get_current_view(&g);
3164
3165  /* in the future make it ask yes/no */
3166  /*
3167  ret=stat(filename, &sbuf);
3168  if (!ret) {
3169    ret=owl_function_askyesno("File exists, continue? [Y/n]");
3170    if (!ret) return;
3171  }
3172  */
3173
3174  file=fopen(filename, "w");
3175  if (!file) {
3176    owl_function_error("Error opening file");
3177    return;
3178  }
3179
3180  count=0;
3181  j=owl_view_get_size(v);
3182  for (i=0; i<j; i++) {
3183    m=owl_view_get_element(v, i);
3184    fputs(owl_message_get_text(m), file);
3185  }
3186  fclose(file);
3187  owl_function_makemsg("Messages dumped to %s", filename);
3188}
3189
3190void owl_function_do_newmsgproc(void)
3191{
3192  if (owl_global_get_newmsgproc(&g) && strcmp(owl_global_get_newmsgproc(&g), "")) {
3193    /* if there's a process out there, we need to check on it */
3194    if (owl_global_get_newmsgproc_pid(&g)) {
3195      owl_function_debugmsg("Checking on newmsgproc pid==%i", owl_global_get_newmsgproc_pid(&g));
3196      owl_function_debugmsg("Waitpid return is %i", waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG));
3197      waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG);
3198      if (waitpid(owl_global_get_newmsgproc_pid(&g), NULL, WNOHANG)==-1) {
3199        /* it exited */
3200        owl_global_set_newmsgproc_pid(&g, 0);
3201        owl_function_debugmsg("newmsgproc exited");
3202      } else {
3203        owl_function_debugmsg("newmsgproc did not exit");
3204      }
3205    }
3206   
3207    /* if it exited, fork & exec a new one */
3208    if (owl_global_get_newmsgproc_pid(&g)==0) {
3209      int i, myargc;
3210      i=fork();
3211      if (i) {
3212        /* parent set the child's pid */
3213        owl_global_set_newmsgproc_pid(&g, i);
3214        owl_function_debugmsg("I'm the parent and I started a new newmsgproc with pid %i", i);
3215      } else {
3216        /* child exec's the program */
3217        char **parsed;
3218        parsed=owl_parseline(owl_global_get_newmsgproc(&g), &myargc);
3219        if (myargc < 0) {
3220          owl_function_debugmsg("Could not parse newmsgproc '%s': unbalanced quotes?", owl_global_get_newmsgproc(&g));
3221        }
3222        if (myargc <= 0) {
3223          _exit(127);
3224        }
3225        parsed=realloc(parsed, sizeof(*parsed) * (myargc+1));
3226        parsed[myargc] = NULL;
3227       
3228        owl_function_debugmsg("About to exec \"%s\" with %d arguments", parsed[0], myargc);
3229       
3230        execvp(parsed[0], parsed);
3231       
3232       
3233        /* was there an error exec'ing? */
3234        owl_function_debugmsg("Cannot run newmsgproc '%s': cannot exec '%s': %s", 
3235                              owl_global_get_newmsgproc(&g), parsed[0], strerror(errno));
3236        _exit(127);
3237      }
3238    }
3239  }
3240}
3241
3242/* print the xterm escape sequence to raise the window */
3243void owl_function_xterm_raise(void)
3244{
3245  printf("\033[5t");
3246}
3247
3248/* print the xterm escape sequence to deiconify the window */
3249void owl_function_xterm_deiconify(void)
3250{
3251  printf("\033[1t");
3252}
3253
3254/* Add the specified command to the startup file.  Eventually this
3255 * should be clever, and rewriting settings that will obviosly
3256 * override earlier settings with 'set' 'bindkey' and 'alias'
3257 * commands.  For now though we just remove any line that would
3258 * duplicate this one and then append this line to the end of
3259 * startupfile.
3260 */
3261void owl_function_addstartup(char *buff)
3262{
3263  FILE *file;
3264  char *filename;
3265
3266  filename=owl_sprintf("%s/%s", owl_global_get_homedir(&g), OWL_STARTUP_FILE);
3267  file=fopen(filename, "a");
3268  if (!file) {
3269    owl_function_error("Error opening startupfile for new command");
3270    owl_free(filename);
3271    return;
3272  }
3273
3274  /* delete earlier copies */
3275  owl_util_file_deleteline(filename, buff, 1);
3276  owl_free(filename);
3277
3278  /* add this line */
3279  fprintf(file, "%s\n", buff);
3280
3281  fclose(file);
3282}
3283
3284/* Remove the specified command from the startup file. */
3285void owl_function_delstartup(char *buff)
3286{
3287  char *filename;
3288  filename=owl_sprintf("%s/%s", owl_global_get_homedir(&g), OWL_STARTUP_FILE);
3289  owl_util_file_deleteline(filename, buff, 1);
3290  owl_free(filename);
3291}
3292
3293/* Execute owl commands from the given filename.  If the filename
3294 * is NULL, use the default owl startup commands file.
3295 */
3296void owl_function_source(char *filename)
3297{
3298  FILE *file;
3299  char buff[LINE];
3300
3301  if (!filename) {
3302    filename=owl_sprintf("%s/%s", owl_global_get_homedir(&g), OWL_STARTUP_FILE);
3303    file=fopen(filename, "r");
3304    owl_free(filename);
3305  } else {
3306    file=fopen(filename, "r");
3307  }
3308  if (!file) {
3309    /* just fail silently if it doesn't exist */
3310    return;
3311  }
3312  while (fgets(buff, LINE, file)!=NULL) {
3313    buff[strlen(buff)-1]='\0';
3314    owl_function_command(buff);
3315  }
3316  fclose(file);
3317}
3318
3319void owl_function_change_style(owl_view *v, char *stylename)
3320{
3321  owl_style *s;
3322
3323  s=owl_global_get_style_by_name(&g, stylename);
3324  if (!s) {
3325    owl_function_error("No style named %s", stylename);
3326    return;
3327  }
3328  owl_view_set_style(v, s);
3329  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3330  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3331  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3332}
3333
3334void owl_function_toggleoneline()
3335{
3336  owl_view *v;
3337  owl_style *s;
3338
3339  v=owl_global_get_current_view(&g);
3340  s=owl_view_get_style(v);
3341
3342  if (!owl_style_matches_name(s, "oneline")) {
3343    owl_function_change_style(v, "oneline");
3344  } else {
3345    owl_function_change_style(v, owl_global_get_default_style(&g));
3346  }
3347
3348  owl_messagelist_invalidate_formats(owl_global_get_msglist(&g));
3349  owl_function_calculate_topmsg(OWL_DIRECTION_DOWNWARDS);
3350  owl_mainwin_redisplay(owl_global_get_mainwin(&g));
3351}
3352
3353void owl_function_error(char *fmt, ...)
3354{
3355  va_list ap;
3356  char buff[2048], buff2[2048];
3357  char *date;
3358  time_t now;
3359
3360  now=time(NULL);
3361  date=owl_strdup(ctime(&now));
3362  date[strlen(date)-1]='\0';
3363
3364  va_start(ap, fmt);
3365
3366  vsnprintf(buff, 2048, fmt, ap);
3367  sprintf(buff2, "%s %s", date, buff);
3368  owl_function_debugmsg("ERROR: %s", buff);
3369  if (owl_global_get_curs_msgwin(&g)) {
3370    werase(owl_global_get_curs_msgwin(&g));
3371    waddstr(owl_global_get_curs_msgwin(&g), buff); 
3372    wnoutrefresh(owl_global_get_curs_msgwin(&g));
3373    owl_global_set_needrefresh(&g);
3374  }
3375  owl_errqueue_append_err(owl_global_get_errqueue(&g), buff2);
3376  va_end(ap);
3377  owl_free(date);
3378}
3379
3380void owl_function_showerrs()
3381{
3382  owl_fmtext fm;
3383
3384  owl_fmtext_init_null(&fm);
3385  owl_fmtext_append_normal(&fm, "Errors:\n\n");
3386  owl_errqueue_to_fmtext(owl_global_get_errqueue(&g), &fm);
3387  owl_function_popless_fmtext(&fm);
3388}
3389
3390void owl_function_makemsg(char *fmt, ...)
3391{
3392  va_list ap;
3393  char buff[2048];
3394
3395  if (!owl_global_get_curs_msgwin(&g)) return;
3396
3397  va_start(ap, fmt);
3398  werase(owl_global_get_curs_msgwin(&g));
3399 
3400  vsnprintf(buff, 2048, fmt, ap);
3401  owl_function_debugmsg("makemsg: %s", buff);
3402  waddstr(owl_global_get_curs_msgwin(&g), buff); 
3403  wnoutrefresh(owl_global_get_curs_msgwin(&g));
3404  owl_global_set_needrefresh(&g);
3405  va_end(ap);
3406}
3407
3408/* get locations for everyone in .anyone.  If 'notify' is '1' then
3409 * send a pseudo login or logout message for everyone not in sync with
3410 * the global zephyr buddy list.  The list is updated regardless of
3411 * the status of 'notify'.
3412 */
3413void owl_function_zephyr_buddy_check(int notify)
3414{
3415#ifdef HAVE_LIBZEPHYR
3416  int i, j;
3417  owl_list anyone;
3418  owl_message *m;
3419  owl_zbuddylist *zbl;
3420  char *user;
3421  ZLocations_t location[200];
3422  int numlocs, ret;
3423
3424  zbl=owl_global_get_zephyr_buddylist(&g);
3425
3426  owl_list_create(&anyone);
3427  ret=owl_zephyr_get_anyone_list(&anyone, NULL);
3428
3429  j=owl_list_get_size(&anyone);
3430  for (i=0; i<j; i++) {
3431    user=owl_list_get_element(&anyone, i);
3432    ret=ZLocateUser(user, &numlocs, ZAUTH);
3433    if (ret!=ZERR_NONE) {
3434      owl_function_error("Error getting location for %s", user);
3435      continue;
3436    }
3437    numlocs=200;
3438    ret=ZGetLocations(location, &numlocs);
3439    if (ret==0) {
3440      if ((numlocs>0) && !owl_zbuddylist_contains_user(zbl, user)) {
3441        /* Send a PSEUDO LOGIN! */
3442        if (notify) {
3443          m=owl_malloc(sizeof(owl_message));
3444          owl_message_create_pseudo_zlogin(m, 0, user, location[0].host, location[0].time, location[0].tty);
3445          owl_global_messagequeue_addmsg(&g, m);
3446        }
3447        owl_zbuddylist_adduser(zbl, user);
3448        owl_function_debugmsg("owl_function_zephyr_buddy_check: login for %s ", user);
3449      } else if ((numlocs==0) && owl_zbuddylist_contains_user(zbl, user)) {
3450        /* I don't think this ever happens (if there are 0 locations we should get an error from
3451         * ZGetLocations)
3452         */
3453        owl_function_error("owl_function_zephyr_buddy_check: exceptional case logout for %s ",user);
3454      }
3455    } else if ((ret==ZERR_NOLOCATIONS) && owl_zbuddylist_contains_user(zbl, user)) {
3456      /* Send a PSEUDO LOGOUT! */
3457      if (notify) {
3458        m=owl_malloc(sizeof(owl_message));
3459        owl_message_create_pseudo_zlogin(m, 1, user, "", "", "");
3460        owl_global_messagequeue_addmsg(&g, m);
3461      }
3462      owl_zbuddylist_deluser(zbl, user);
3463      owl_function_debugmsg("owl_function_zephyr_buddy_check: logout for %s ",user);
3464    }
3465  }
3466
3467  owl_list_free_all(&anyone, owl_free);
3468#endif
3469}
3470
3471void owl_function_aimsearch_results(char *email, owl_list *namelist)
3472{
3473  owl_fmtext fm;
3474  int i, j;
3475
3476  owl_fmtext_init_null(&fm);
3477  owl_fmtext_append_normal(&fm, "AIM screennames associated with ");
3478  owl_fmtext_append_normal(&fm, email);
3479  owl_fmtext_append_normal(&fm, ":\n");
3480
3481  j=owl_list_get_size(namelist);
3482  for (i=0; i<j; i++) {
3483    owl_fmtext_append_normal(&fm, "  ");
3484    owl_fmtext_append_normal(&fm, owl_list_get_element(namelist, i));
3485    owl_fmtext_append_normal(&fm, "\n");
3486  }
3487
3488  owl_function_popless_fmtext(&fm);
3489  owl_fmtext_free(&fm);
3490}
Note: See TracBrowser for help on using the repository browser.