source: owl.c @ 61f7250

owl
Last change on this file since 61f7250 was 61f7250, checked in by James M. Kretchmar <kretch@mit.edu>, 13 years ago
still need to putenv TERMINFO, fix to earlier commit
  • Property mode set to 100644
File size: 23.8 KB
Line 
1/* Copyright (c) 2002,2003,2004,2009 James M. Kretchmar
2 *
3 * This file is part of Owl.
4 *
5 * Owl is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * Owl is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with Owl.  If not, see <http://www.gnu.org/licenses/>.
17 *
18 * ---------------------------------------------------------------
19 *
20 * As of Owl version 2.1.12 there are patches contributed by
21 * developers of the branched BarnOwl project, Copyright (c)
22 * 2006-2009 The BarnOwl Developers. All rights reserved.
23 */
24
25#include <stdio.h>
26#include <unistd.h>
27#include <stdlib.h>
28#include <string.h>
29#include <signal.h>
30#include <time.h>
31#include <sys/param.h>
32#include <sys/types.h>
33#include <termios.h>
34#include <sys/stat.h>
35#include "owl.h"
36
37#if OWL_STDERR_REDIR
38#ifdef HAVE_SYS_IOCTL_H
39#include <sys/ioctl.h>
40#endif
41#ifdef HAVE_SYS_FILIO_H
42#include <sys/filio.h>
43#endif
44int stderr_replace(void);
45#endif
46
47#define STDIN 0
48
49static const char fileIdent[] = "$Id$";
50
51owl_global g;
52
53int main(int argc, char **argv, char **env)
54{
55  WINDOW *recwin, *sepwin, *typwin, *msgwin;
56  owl_editwin *tw;
57  owl_popwin *pw;
58  int ret, initialsubs, debug, argcsave, followlast;
59  int newmsgs, nexttimediff;
60  struct sigaction sigact;
61  char *configfile, *tty, *perlout, *perlerr, **argvsave;
62  owl_filter *f;
63  owl_style *s;
64  time_t nexttime, now;
65  struct tm *today;
66  char *dir;
67  struct termios tio;
68
69  argcsave=argc;
70  argvsave=argv;
71  configfile=NULL;
72  tty=NULL;
73  debug=0;
74  initialsubs=1;
75  if (argc>0) {
76    argv++;
77    argc--;
78  }
79  while (argc>0) {
80    if (!strcmp(argv[0], "-n")) {
81      initialsubs=0;
82      argv++;
83      argc--;
84    } else if (!strcmp(argv[0], "-c")) {
85      if (argc<2) {
86        fprintf(stderr, "Too few arguments to -c\n");
87        usage();
88        exit(1);
89      }
90      configfile=argv[1];
91      argv+=2;
92      argc-=2;
93    } else if (!strcmp(argv[0], "-t")) {
94      if (argc<2) {
95        fprintf(stderr, "Too few arguments to -t\n");
96        usage();
97        exit(1);
98      }
99      tty=argv[1];
100      argv+=2;
101      argc-=2;
102    } else if (!strcmp(argv[0], "-d")) {
103      debug=1;
104      argv++;
105      argc--;
106    } else if (!strcmp(argv[0], "-D")) {
107      debug=1;
108      unlink(OWL_DEBUG_FILE);
109      argv++;
110      argc--;
111    } else if (!strcmp(argv[0], "-v")) {
112      printf("This is owl version %s\n", OWL_VERSION_STRING);
113      exit(0);
114    } else {
115      fprintf(stderr, "Uknown argument\n");
116      usage();       
117      exit(1);
118    }
119  }
120
121  owl_function_debugmsg("startup: Finished parsing arguments");
122
123#ifdef HAVE_LIBZEPHYR
124  /* zephyr init */
125  ret=owl_zephyr_initialize();
126  if (ret) {
127    exit(1);
128  }
129#endif
130 
131  /* signal handler */
132  /*sigact.sa_handler=sig_handler;*/
133  sigact.sa_sigaction=sig_handler;
134  sigemptyset(&sigact.sa_mask);
135  sigact.sa_flags=SA_SIGINFO;
136  sigaction(SIGWINCH, &sigact, NULL);
137  sigaction(SIGALRM, &sigact, NULL);
138  sigaction(SIGPIPE, &sigact, NULL);
139  sigaction(SIGTERM, &sigact, NULL);
140  sigaction(SIGHUP, &sigact, NULL);
141
142  /* save initial terminal settings */
143  tcgetattr(0, owl_global_get_startup_tio(&g));
144
145  /* turn ISTRIP off */
146  tcgetattr(0, &tio);
147  tio.c_iflag &= ~ISTRIP;
148  tcsetattr(0, TCSAFLUSH, &tio);
149
150  /* screen init */
151  if (!getenv("TERMINFO")) {
152    putenv(owl_sprintf("TERMINFO=%s", TERMINFO));
153    owl_function_debugmsg("startup: setting TERMINFO to %s", TERMINFO);
154  } else {
155    owl_function_debugmsg("startup: leaving TERMINFO as %s from envrionment", getenv("TERMINFO"));
156  }
157
158  initscr();
159  start_color();
160#ifdef HAVE_USE_DEFAULT_COLORS
161  use_default_colors();
162#endif
163  raw();
164  noecho();
165
166  /* define simple color pairs */
167  if (has_colors() && COLOR_PAIRS>=8) {
168    init_pair(OWL_COLOR_BLACK,   COLOR_BLACK,   -1);
169    init_pair(OWL_COLOR_RED,     COLOR_RED,     -1);
170    init_pair(OWL_COLOR_GREEN,   COLOR_GREEN,   -1);
171    init_pair(OWL_COLOR_YELLOW,  COLOR_YELLOW,  -1);
172    init_pair(OWL_COLOR_BLUE,    COLOR_BLUE,    -1);
173    init_pair(OWL_COLOR_MAGENTA, COLOR_MAGENTA, -1);
174    init_pair(OWL_COLOR_CYAN,    COLOR_CYAN,    -1);
175    init_pair(OWL_COLOR_WHITE,   COLOR_WHITE,   -1);
176  }
177
178  /* owl global init */
179  owl_global_init(&g);
180  if (debug) owl_global_set_debug_on(&g);
181  owl_function_debugmsg("startup: first available debugging message");
182  owl_global_set_startupargs(&g, argcsave, argvsave);
183  owl_global_set_haveaim(&g);
184
185  /* prepare stdin dispatch */
186  {
187    owl_dispatch *d = owl_malloc(sizeof(owl_dispatch));
188    owl_function_debugmsg("startup: creating input selector");
189    d->fd = STDIN;
190    d->cfunc = &owl_process_input;
191    d->destroy = NULL;
192    owl_select_add_dispatch(d);
193  }
194
195#ifdef HAVE_LIBZEPHYR
196  owl_global_set_havezephyr(&g);
197  if (!ret) {
198    owl_dispatch *d = owl_malloc(sizeof(owl_dispatch));
199    owl_function_debugmsg("startup: creating zephyr selector");
200    d->fd = ZGetFD();
201    d->cfunc = &owl_zephyr_process_events;
202    d->destroy = NULL;
203    owl_select_add_dispatch(d);
204    owl_global_set_havezephyr(&g);
205  }
206#endif
207
208#if OWL_STDERR_REDIR
209  /* Do this only after we've started curses up... */
210  {
211    owl_dispatch *d = owl_malloc(sizeof(owl_dispatch));
212    owl_function_debugmsg("startup: doing stderr redirection");
213    d->fd = stderr_replace();
214    d->cfunc = stderr_redirect_handler;
215    d->destroy = NULL;
216    owl_function_debugmsg("testing: 1");
217    owl_select_add_dispatch(d);
218    owl_function_debugmsg("testing: 2");
219  }
220
221#endif   
222
223  /* create the owl directory, in case it does not exist */
224  owl_function_debugmsg("startup: creating owl directory, if not present");
225  dir=owl_sprintf("%s/%s", owl_global_get_homedir(&g), OWL_CONFIG_DIR);
226  mkdir(dir, S_IRWXU);
227  owl_free(dir);
228
229  /* set the tty, either from the command line, or by figuring it out */
230  owl_function_debugmsg("startup: setting tty name");
231  if (tty) {
232    owl_global_set_tty(&g, tty);
233  } else {
234    owl_global_set_tty(&g, owl_util_get_default_tty());
235  }
236
237  /* setup the built-in styles */
238  owl_function_debugmsg("startup: creating built-in styles");
239  s=owl_malloc(sizeof(owl_style));
240  owl_style_create_internal(s, "default", &owl_stylefunc_default, "Default message formatting");
241  owl_global_add_style(&g, s);
242
243  s=owl_malloc(sizeof(owl_style));
244  owl_style_create_internal(s, "basic", &owl_stylefunc_basic, "Basic message formatting.");
245  owl_global_add_style(&g, s);
246#if 0
247  s=owl_malloc(sizeof(owl_style));
248  owl_style_create_internal(s, "vt", &owl_stylefunc_vt, "VT message formatting.");
249  owl_global_add_style(&g, s);
250#endif
251  s=owl_malloc(sizeof(owl_style));
252  owl_style_create_internal(s, "oneline", &owl_stylefunc_oneline, "Formats for one-line-per-message");
253  owl_global_add_style(&g, s);
254
255  /* setup the default filters */
256  /* the personal filter will need to change again when AIM chat's are
257   *  included.  Also, there should be an %aimme% */
258  owl_function_debugmsg("startup: creating default filters");
259  f=owl_malloc(sizeof(owl_filter));
260  owl_filter_init_fromstring(f, "personal", "( type ^zephyr$ "
261                             "and class ^message$ and instance ^personal$ "
262                             "and ( recipient ^%me%$ or sender ^%me%$ ) ) "
263                             "or ( type ^aim$ and login ^none$ )");
264  owl_list_append_element(owl_global_get_filterlist(&g), f);
265
266  f=owl_malloc(sizeof(owl_filter));
267  owl_filter_init_fromstring(f, "trash", "class ^mail$ or opcode ^ping$ or type ^admin$ or ( not login ^none$ )");
268  owl_list_append_element(owl_global_get_filterlist(&g), f);
269
270  f=owl_malloc(sizeof(owl_filter));
271  owl_filter_init_fromstring(f, "ping", "opcode ^ping$");
272  owl_list_append_element(owl_global_get_filterlist(&g), f);
273
274  f=owl_malloc(sizeof(owl_filter));
275  owl_filter_init_fromstring(f, "auto", "opcode ^auto$");
276  owl_list_append_element(owl_global_get_filterlist(&g), f);
277
278  f=owl_malloc(sizeof(owl_filter));
279  owl_filter_init_fromstring(f, "login", "not login ^none$");
280  owl_list_append_element(owl_global_get_filterlist(&g), f);
281
282  f=owl_malloc(sizeof(owl_filter));
283  owl_filter_init_fromstring(f, "reply-lockout", "class ^noc or class ^mail$");
284  owl_list_append_element(owl_global_get_filterlist(&g), f);
285
286  f=owl_malloc(sizeof(owl_filter));
287  owl_filter_init_fromstring(f, "out", "direction ^out$");
288  owl_list_append_element(owl_global_get_filterlist(&g), f);
289
290  f=owl_malloc(sizeof(owl_filter));
291  owl_filter_init_fromstring(f, "aim", "type ^aim$");
292  owl_list_append_element(owl_global_get_filterlist(&g), f);
293
294  f=owl_malloc(sizeof(owl_filter));
295  owl_filter_init_fromstring(f, "zephyr", "type ^zephyr$");
296  owl_list_append_element(owl_global_get_filterlist(&g), f);
297
298  f=owl_malloc(sizeof(owl_filter));
299  owl_filter_init_fromstring(f, "none", "false");
300  owl_list_append_element(owl_global_get_filterlist(&g), f);
301
302  f=owl_malloc(sizeof(owl_filter));
303  owl_filter_init_fromstring(f, "all", "true");
304  owl_list_append_element(owl_global_get_filterlist(&g), f);
305
306  /* set the current view */
307  owl_function_debugmsg("startup: setting the current view");
308  owl_view_create(owl_global_get_current_view(&g), "main", f, owl_global_get_style_by_name(&g, "default"));
309
310  /* AIM init */
311  owl_function_debugmsg("startup: doing AIM initialization");
312  owl_aim_init();
313
314  /* process the startup file */
315  owl_function_debugmsg("startup: processing startup file");
316  owl_function_source(NULL);
317
318  /* read the config file */
319  owl_function_debugmsg("startup: processing config file");
320  owl_context_set_readconfig(owl_global_get_context(&g));
321  perlerr=owl_perlconfig_readconfig(configfile);
322  if (perlerr) {
323    endwin();
324    owl_function_error("Error parsing configfile: %s\n", perlerr);
325    fprintf(stderr, "\nError parsing configfile: %s\n", perlerr);
326    fflush(stderr);
327    printf("\nError parsing configfile: %s\n", perlerr);
328    fflush(stdout);
329    exit(1);
330  }
331
332  /* if the config defines a formatting function, add 'perl' as a style */
333  if (owl_global_is_config_format(&g)) {
334    owl_function_debugmsg("Found perl formatting");
335    s=owl_malloc(sizeof(owl_style));
336    owl_style_create_perl(s, "perl", "owl::_format_msg_legacy_wrap",
337                          "User-defined perl style that calls owl::format_msg"
338                          "with legacy global variable support");
339    owl_global_add_style(&g, s);
340    owl_global_set_default_style(&g, "perl");
341  }
342
343  /* execute the startup function in the configfile */
344  owl_function_debugmsg("startup: executing perl startup, if applicable");
345  perlout = owl_perlconfig_execute("owl::startup();");
346  if (perlout) owl_free(perlout);
347 
348  /* hold on to the window names for convenience */
349  msgwin=owl_global_get_curs_msgwin(&g);
350  recwin=owl_global_get_curs_recwin(&g);
351  sepwin=owl_global_get_curs_sepwin(&g);
352  typwin=owl_global_get_curs_typwin(&g);
353  tw=owl_global_get_typwin(&g);
354
355  /* welcome message */
356  owl_function_debugmsg("startup: creating splash message");
357  owl_function_adminmsg("",
358                        "-----------------------------------------------------------------------\n"
359                        "Welcome to Owl version " OWL_VERSION_STRING ".  Press 'h' for on-line help. \n"
360                        "                                                                       \n"
361                        "If you would like to receive release announcements about Owl you can   \n"
362                        "join the owl-users mailing list at http://www.ktools.org/              \n"
363                        "                                                                 ^ ^   \n"
364                        "                                                                 OvO   \n"
365                        "Please report any bugs or suggestions to bug-owl@ktools.org     (   )  \n"
366                        "-----------------------------------------------------------------m-m---\n"
367                        );
368  sepbar(NULL);
369
370  wrefresh(sepwin);
371
372  /* load zephyr subs */
373  if (initialsubs) {
374    int ret2;
375    owl_function_debugmsg("startup: loading initial zephyr subs");
376
377    /* load default subscriptions */
378    ret=owl_zephyr_loaddefaultsubs();
379   
380    /* load subscriptions from subs file */
381    ret2=owl_zephyr_loadsubs(NULL, 0);
382
383    if (ret || ret2) {
384      owl_function_adminmsg("", "Error loading zephyr subscriptions");
385    } else if (ret2!=-1) {
386      owl_global_add_userclue(&g, OWL_USERCLUE_CLASSES);
387    }
388
389    /* load login subscriptions */
390    if (owl_global_is_loginsubs(&g)) {
391      owl_function_debugmsg("startup: loading login subs");
392      owl_function_loadloginsubs(NULL);
393    }
394  }
395
396  /* First buddy check to sync the list without notifications */
397  owl_function_debugmsg("startup: doing initial zephyr buddy check");
398  /* owl_function_zephyr_buddy_check(0); */
399
400  /* set the startup and default style, based on userclue and presence of a
401   * formatting function */
402  owl_function_debugmsg("startup: setting startup and default style");
403  if (0 != strcmp(owl_global_get_default_style(&g), "__unspecified__")) {
404    /* the style was set by the user: leave it alone */
405  } else if (owl_global_is_config_format(&g)) {
406    owl_global_set_default_style(&g, "perl");
407  } else if (owl_global_is_userclue(&g, OWL_USERCLUE_CLASSES)) {
408    owl_global_set_default_style(&g, "default");
409  } else {
410    owl_global_set_default_style(&g, "basic");
411  }
412
413  /* zlog in if we need to */
414  if (owl_global_is_startuplogin(&g)) {
415    owl_function_debugmsg("startup: doing zlog in");
416    owl_zephyr_zlog_in();
417  }
418
419  owl_function_debugmsg("startup: set style for the view");
420  owl_view_set_style(owl_global_get_current_view(&g), 
421                     owl_global_get_style_by_name(&g, owl_global_get_default_style(&g)));   
422
423  owl_function_debugmsg("startup: setting context interactive");
424  owl_context_set_interactive(owl_global_get_context(&g));
425
426  nexttimediff=10;
427  nexttime=time(NULL);
428
429  owl_zephyr_process_events(NULL);
430  owl_function_debugmsg("startup: entering main loop");
431  /* main loop */
432  while (1) {
433
434    /* if a resize has been scheduled, deal with it */
435    owl_global_resize(&g, 0, 0);
436
437    /* these are here in case a resize changes the windows */
438    msgwin=owl_global_get_curs_msgwin(&g);
439    recwin=owl_global_get_curs_recwin(&g);
440    sepwin=owl_global_get_curs_sepwin(&g);
441    typwin=owl_global_get_curs_typwin(&g);
442
443    followlast=owl_global_should_followlast(&g);
444   
445    /* Do AIM stuff */
446    if (owl_global_is_doaimevents(&g)) {
447      /* owl_aim_process_events(); */
448
449      if (owl_global_is_aimloggedin(&g)) {
450        if (owl_timer_is_expired(owl_global_get_aim_buddyinfo_timer(&g))) {
451          /* owl_buddylist_request_idletimes(owl_global_get_buddylist(&g)); */
452          owl_timer_reset(owl_global_get_aim_buddyinfo_timer(&g));
453        }
454      }
455    }
456
457    /* little hack */
458    now=time(NULL);
459    today=localtime(&now);
460    if (today->tm_mon==9 && today->tm_mday==31 && owl_global_get_runtime(&g)<600) {
461      if (time(NULL)>nexttime) {
462        if (nexttimediff==1) {
463          nexttimediff=10;
464        } else {
465          nexttimediff=1;
466        }
467        nexttime+=nexttimediff;
468        owl_hack_animate();
469      }
470    }
471
472    /* Grab incoming messages. */
473    newmsgs=0;
474    while(owl_global_messagequeue_pending(&g)) {
475      owl_message *m=NULL;
476      owl_filter *f;
477
478      m=owl_global_messageuque_popmsg(&g);
479     
480      /* if this message it on the puntlist, nuke it and continue */
481      if (owl_global_message_is_puntable(&g, m)) {
482        owl_message_free(m);
483        continue;
484      }
485
486      /*  login or logout that should be ignored? */
487      if (owl_global_is_ignorelogins(&g) && owl_message_is_loginout(m)) {
488        owl_message_free(m);
489        continue;
490      }
491
492      /* otherwise add it to the global list */
493      owl_messagelist_append_element(owl_global_get_msglist(&g), m);
494      newmsgs=1;
495
496      /* let the config know the new message has been received */
497      owl_perlconfig_getmsg(m, 0, NULL);
498
499      /* add it to any necessary views; right now there's only the current view */
500      owl_view_consider_message(owl_global_get_current_view(&g), m);
501
502      /* do we need to autoreply? */
503      if (owl_global_is_zaway(&g) && !owl_message_get_attribute_value(m, "isauto")) {
504        if (owl_message_is_type_zephyr(m)) {
505          owl_zephyr_zaway(m);
506        } else if (owl_message_is_type_aim(m)) {
507          if (owl_message_is_private(m)) {
508            owl_function_send_aimawymsg(owl_message_get_sender(m), owl_global_get_zaway_msg(&g));
509          }
510        }
511      }
512
513      /* ring the bell if it's a personal */
514      if (!strcmp(owl_global_get_personalbell(&g), "on")) {
515          if (!owl_message_is_loginout(m) &&
516              !owl_message_is_mail(m) &&
517              owl_message_is_private(m)) {
518            owl_function_beep();
519          }
520      } else if (!strcmp(owl_global_get_personalbell(&g), "off")) {
521        /* do nothing */
522      } else {
523        f=owl_global_get_filter(&g, owl_global_get_personalbell(&g));
524        if (f && owl_filter_message_match(f, m)) {
525          owl_function_beep();
526        }
527      }
528
529
530      /* if it matches the alert filter, do the alert action */
531      f=owl_global_get_filter(&g, owl_global_get_alert_filter(&g));
532      if (f && owl_filter_message_match(f, m)) {
533        owl_function_command(owl_global_get_alert_action(&g));
534      }
535
536      /* if it's a zephyr login or logout, update the zbuddylist */
537      if (owl_message_is_type_zephyr(m) && owl_message_is_loginout(m)) {
538        if (owl_message_is_login(m)) {
539          owl_zbuddylist_adduser(owl_global_get_zephyr_buddylist(&g), owl_message_get_sender(m));
540        } else if (owl_message_is_logout(m)) {
541          owl_zbuddylist_deluser(owl_global_get_zephyr_buddylist(&g), owl_message_get_sender(m));
542        } else {
543          owl_function_error("Internal error: received login notice that is neither login nor logout");
544        }
545      }
546
547      /* check for burning ears message */
548      /* this is an unsupported feature */
549      if (owl_global_is_burningears(&g) && owl_message_is_burningears(m)) {
550        char *buff;
551        buff = owl_sprintf("@i(Burning ears message on class %s)", owl_message_get_class(m));
552        owl_function_adminmsg(buff, "");
553        owl_free(buff);
554        owl_function_beep();
555      }
556
557      /* log the message if we need to */
558      owl_log_message(m);
559    }
560
561    /* is it time to check zbuddies? */
562    if (owl_global_is_pseudologins(&g)) {
563      if (owl_timer_is_expired(owl_global_get_zephyr_buddycheck_timer(&g))) {
564        owl_function_debugmsg("Doing zephyr buddy check");
565        owl_function_zephyr_buddy_check(1);
566        owl_timer_reset(owl_global_get_zephyr_buddycheck_timer(&g));
567      }
568    }
569
570    /* follow the last message if we're supposed to */
571    if (newmsgs && followlast) {
572      owl_function_lastmsg_noredisplay();
573    }
574
575    /* do the newmsgproc thing */
576    if (newmsgs) {
577      owl_function_do_newmsgproc();
578    }
579   
580    /* redisplay if necessary */
581    /* this should be optimized to not run if the new messages won't be displayed */
582    if (newmsgs) {
583      owl_mainwin_redisplay(owl_global_get_mainwin(&g));
584      sepbar(NULL);
585      if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
586        owl_popwin_refresh(owl_global_get_popwin(&g));
587        /* TODO: this is a broken kludge */
588        if (owl_global_get_viewwin(&g)) {
589          owl_viewwin_redisplay(owl_global_get_viewwin(&g), 0);
590        }
591      }
592      owl_global_set_needrefresh(&g);
593    }
594
595    /* if a popwin just came up, refresh it */
596    pw=owl_global_get_popwin(&g);
597    if (owl_popwin_is_active(pw) && owl_popwin_needs_first_refresh(pw)) {
598      owl_popwin_refresh(pw);
599      owl_popwin_no_needs_first_refresh(pw);
600      owl_global_set_needrefresh(&g);
601      /* TODO: this is a broken kludge */
602      if (owl_global_get_viewwin(&g)) {
603        owl_viewwin_redisplay(owl_global_get_viewwin(&g), 0);
604      }
605    }
606
607    /* update the terminal if we need to */
608    if (owl_global_is_needrefresh(&g)) {
609      /* leave the cursor in the appropriate window */
610      if (owl_global_is_typwin_active(&g)) {
611        owl_function_set_cursor(typwin);
612      } else {
613        owl_function_set_cursor(sepwin);
614      }
615      doupdate();
616      owl_global_set_noneedrefresh(&g);
617    }
618
619    /* Some calls into libzephyr call Z_WaitForNotice(), which has its
620     * own select loop and may leave zephyrs on the queue. Check for
621     * them now, and process any we find. */
622    owl_zephyr_process_events(NULL);
623
624    /* select on FDs we know about. */
625    owl_select();
626
627    /* Log any error signals */
628    {
629      siginfo_t si;
630      int signum;
631      if ((signum = owl_global_get_errsignal_and_clear(&g, &si)) > 0) {
632        owl_function_error("Got unexpected signal: %d %s  (code: %d band: %d  errno: %d)", 
633                           signum, signum==SIGPIPE?"SIGPIPE":"SIG????",
634                           si.si_code, si.si_band, si.si_errno);
635      }
636    }
637
638  }
639}
640
641void owl_process_input(owl_dispatch *d)
642{
643  int ret, j;
644  owl_popwin *pw;
645  owl_editwin *tw;
646  WINDOW *typwin;
647
648  typwin = owl_global_get_curs_typwin(&g);
649  while (1) {
650    j=wgetch(typwin);
651    if (j==ERR) return;
652
653    pw=owl_global_get_popwin(&g);
654    tw=owl_global_get_typwin(&g);
655   
656    /* find and activate the current keymap.
657     * TODO: this should really get fixed by activating
658     * keymaps as we switch between windows...
659     */
660    if (pw && owl_popwin_is_active(pw) && owl_global_get_viewwin(&g)) {
661      owl_context_set_popless(owl_global_get_context(&g), 
662                              owl_global_get_viewwin(&g));
663      owl_function_activate_keymap("popless");
664    } else if (owl_global_is_typwin_active(&g) 
665               && owl_editwin_get_style(tw)==OWL_EDITWIN_STYLE_ONELINE) {
666      /*
667        owl_context_set_editline(owl_global_get_context(&g), tw);
668        owl_function_activate_keymap("editline");
669      */
670    } else if (owl_global_is_typwin_active(&g) 
671               && owl_editwin_get_style(tw)==OWL_EDITWIN_STYLE_MULTILINE) {
672      owl_context_set_editmulti(owl_global_get_context(&g), tw);
673      owl_function_activate_keymap("editmulti");
674    } else {
675      owl_context_set_recv(owl_global_get_context(&g));
676      owl_function_activate_keymap("recv");
677    }
678    /* now actually handle the keypress */
679    ret = owl_keyhandler_process(owl_global_get_keyhandler(&g), j);
680    if (ret!=0 && ret!=1) {
681      owl_function_makemsg("Unable to handle keypress");
682    }
683  }
684}
685
686void sig_handler(int sig, siginfo_t *si, void *data)
687{
688  if (sig==SIGWINCH) {
689    /* we can't inturrupt a malloc here, so it just sets a flag
690     * schedulding a resize for later
691     */
692    owl_function_resize();
693  } else if (sig==SIGPIPE || sig==SIGCHLD) {
694    /* Set a flag and some info that we got the sigpipe
695     * so we can record that we got it and why... */
696    owl_global_set_errsignal(&g, sig, si);
697  } else if (sig==SIGTERM || sig==SIGHUP) {
698    owl_function_quit();
699  }
700
701}
702
703void usage()
704{
705  fprintf(stderr, "Owl version %s\n", OWL_VERSION_STRING);
706  fprintf(stderr, "Usage: owl [-n] [-d] [-D] [-v] [-h] [-c <configfile>] [-t <ttyname>]\n");
707  fprintf(stderr, "  -n      don't load zephyr subscriptions\n");
708  fprintf(stderr, "  -d      enable debugging\n");
709  fprintf(stderr, "  -D      enable debugging and delete previous debug file\n");
710  fprintf(stderr, "  -v      print the Owl version number and exit\n");
711  fprintf(stderr, "  -h      print this help message\n");
712  fprintf(stderr, "  -c      specify an alternate config file\n");
713  fprintf(stderr, "  -t      set the tty name\n");
714}
715
716#if OWL_STDERR_REDIR
717
718/* Replaces stderr with a pipe so that we can read from it.
719 * Returns the fd of the pipe from which stderr can be read. */
720int stderr_replace(void)
721{
722  int pipefds[2];
723  if (0 != pipe(pipefds)) {
724    perror("pipe");
725    owl_function_debugmsg("stderr_replace: pipe FAILED\n");
726    return -1;
727  }
728    owl_function_debugmsg("stderr_replace: pipe: %d,%d", pipefds[0], pipefds[1]);
729  if (-1 == dup2(pipefds[1], 2 /*stderr*/)) {
730    owl_function_debugmsg("stderr_replace: dup2 FAILED (%s)", strerror(errno));
731    perror("dup2");
732    return -1;
733  }
734  return pipefds[0];
735}
736
737/* Sends stderr (read from rfd) messages to the error console */
738void stderr_redirect_handler(int handle, int rfd, int eventmask, void *data) 
739{
740  int navail, bread;
741  char *buf;
742  /*owl_function_debugmsg("stderr_redirect: called with rfd=%d\n", rfd);*/
743  if (rfd<0) return;
744  if (-1 == ioctl(rfd, FIONREAD, (void*)&navail)) {
745    return;
746  }
747  /*owl_function_debugmsg("stderr_redirect: navail = %d\n", navail);*/
748  if (navail<=0) return;
749  if (navail>256) { navail = 256; }
750  buf = owl_malloc(navail+1);
751  bread = read(rfd, buf, navail);
752  if (buf[navail-1] != '\0') {
753    buf[navail] = '\0';
754  }
755  owl_function_error("Err: %s", buf);
756  owl_free(buf);
757}
758
759#endif /* OWL_STDERR_REDIR */
Note: See TracBrowser for help on using the repository browser.