Changeset 89ab5c8


Ignore:
Timestamp:
May 23, 2010, 12:47:20 PM (10 years ago)
Author:
Nelson Elhage <nelhage@mit.edu>
Branches:
master, release-1.7, release-1.8, release-1.9
Children:
7cc1092
Parents:
aa0a0b5 (diff), ecaec21 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:
Merge remote branch 'origin/narrow-cc'
Files:
1 added
1 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • functions.c

    r2cfc6d7 r89ab5c8  
    25012501}
    25022502
     2503static char *owl_function_smartfilter_cc(const owl_message *m) {
     2504  const char *ccs;
     2505  char *filtname;
     2506  char *text;
     2507  owl_filter *f;
     2508
     2509  ccs = owl_message_get_attribute_value(m, "zephyr_ccs");
     2510
     2511  filtname = owl_sprintf("conversation-%s", ccs);
     2512  owl_text_tr(filtname, ' ', '-');
     2513
     2514  if (owl_global_get_filter(&g, filtname)) {
     2515    return filtname;
     2516  }
     2517
     2518  text = owl_sprintf("type ^zephyr$ and filter personal and "
     2519                     "zephyr_ccs ^%s%s%s$",
     2520                     owl_getquoting(ccs), ccs, owl_getquoting(ccs));
     2521
     2522  f = owl_filter_new_fromstring(filtname, text);
     2523
     2524  owl_global_add_filter(&g, f);
     2525
     2526  owl_free(text);
     2527
     2528  return filtname;
     2529}
     2530
    25032531/* Create a filter based on the current message.  Returns the name of
    25042532 * a filter or null.  The caller must free this name.
     
    25542582  if (owl_message_is_type_zephyr(m)) {
    25552583    if (owl_message_is_personal(m) || owl_message_is_loginout(m)) {
     2584      if (owl_message_get_attribute_value(m, "zephyr_ccs") != NULL) {
     2585        return owl_function_smartfilter_cc(m);
     2586      }
     2587
    25562588      if (owl_message_is_direction_in(m)) {
    25572589        zperson=short_zuser(owl_message_get_sender(m));
  • logging.c

    r91634ec r839697d  
    128128  char filename[MAXPATHLEN], *logpath;
    129129  char *to, *temp;
     130  GList *cc;
    130131
    131132  /* expand ~ in path names */
     
    135136  if (owl_message_is_type_zephyr(m)) {
    136137    /* If this has CC's, do all but the "recipient" which we'll do below */
    137     to = owl_message_get_cc_without_recipient(m);
    138     if (to != NULL) {
    139       temp = strtok(to, " ");
    140       while (temp != NULL) {
    141           temp = short_zuser(temp);
    142           snprintf(filename, MAXPATHLEN, "%s/%s", logpath, temp);
    143           owl_log_append(m, filename);
    144           temp = strtok(NULL, " ");
    145       }
    146       owl_free(to);
    147     }
     138    cc = owl_message_get_cc_without_recipient(m);
     139    while (cc != NULL) {
     140      temp = short_zuser(cc->data);
     141      snprintf(filename, MAXPATHLEN, "%s/%s", logpath, temp);
     142      owl_log_append(m, filename);
     143
     144      owl_free(cc->data);
     145      cc = g_list_delete_link(cc, cc);
     146    }
     147
    148148    to = short_zuser(owl_message_get_recipient(m));
    149149  } else if (owl_message_is_type_jabber(m)) {
     
    325325     * the sender, as well.
    326326     */
    327     char *cc, *temp;
     327    char *temp;
     328    GList *cc;
    328329    cc = owl_message_get_cc_without_recipient(m);
    329     if (cc != NULL) {
    330       temp = strtok(cc, " ");
    331       while (temp != NULL) {
    332         temp = short_zuser(temp);
    333         if (strcasecmp(temp, frombuff) != 0) {
    334           snprintf(filename, MAXPATHLEN, "%s/%s", logpath, temp);
    335           owl_log_append(m, filename);
    336         }
    337         temp = strtok(NULL, " ");
     330    while (cc != NULL) {
     331      temp = short_zuser(cc->data);
     332      if (strcasecmp(temp, frombuff) != 0) {
     333        snprintf(filename, MAXPATHLEN, "%s/%s", logpath, temp);
     334        owl_log_append(m, filename);
    338335      }
    339       owl_free(cc);
     336
     337      owl_free(cc->data);
     338      cc = g_list_delete_link(cc, cc);
    340339    }
    341340  }
  • message.c

    rc314f39 r89ab5c8  
    593593
    594594/* caller must free return value */
    595 char *owl_message_get_cc_without_recipient(const owl_message *m)
    596 {
    597   char *cc, *out, *end, *shortuser, *recip;
     595GList *owl_message_get_cc_without_recipient(const owl_message *m)
     596{
     597  char *cc, *shortuser, *recip;
    598598  const char *user;
     599  GList *out = NULL;
    599600
    600601  cc = owl_message_get_cc(m);
     
    603604
    604605  recip = short_zuser(owl_message_get_recipient(m));
    605   out = owl_malloc(strlen(cc) + 2);
    606   end = out;
    607606
    608607  user = strtok(cc, " ");
     
    610609    shortuser = short_zuser(user);
    611610    if (strcasecmp(shortuser, recip) != 0) {
    612       strcpy(end, user);
    613       end[strlen(user)] = ' ';
    614       end += strlen(user) + 1;
     611      out = g_list_prepend(out, owl_strdup(user));
    615612    }
    616613    owl_free(shortuser);
    617614    user = strtok(NULL, " ");
    618615  }
    619   end[0] = '\0';
    620616
    621617  owl_free(recip);
    622618  owl_free(cc);
    623 
    624   if (strlen(out) == 0) {
    625     owl_free(out);
    626     out = NULL;
    627   }
    628619
    629620  return(out);
     
    741732  owl_message_set_recipient(m, "looprecip");
    742733  owl_message_set_isprivate(m);
     734}
     735
     736void owl_message_save_ccs(owl_message *m) {
     737  GList *cc;
     738  char *tmp;
     739
     740  cc = owl_message_get_cc_without_recipient(m);
     741
     742  if (cc != NULL) {
     743    GString *recips = g_string_new("");
     744    cc = g_list_prepend(cc, short_zuser(owl_message_get_sender(m)));
     745    cc = g_list_prepend(cc, short_zuser(owl_message_get_recipient(m)));
     746    cc = g_list_sort(cc, (GCompareFunc)strcasecmp);
     747
     748    while(cc != NULL) {
     749      /* Collapse any identical entries */
     750      while (cc->next && strcasecmp(cc->data, cc->next->data) == 0) {
     751        owl_free(cc->data);
     752        cc = g_list_delete_link(cc, cc);
     753      }
     754
     755      tmp = short_zuser(cc->data);
     756      g_string_append(recips, tmp);
     757
     758      owl_free(tmp);
     759      owl_free(cc->data);
     760      cc = g_list_delete_link(cc, cc);
     761
     762      if (cc)
     763        g_string_append_c(recips, ' ');
     764    }
     765
     766    owl_message_set_attribute(m, "zephyr_ccs", recips->str);
     767    g_string_free(recips, true);
     768  }
    743769}
    744770
     
    878904    }
    879905  }
     906
     907  owl_message_save_ccs(m);
    880908}
    881909#else
     
    9721000    owl_message_set_isprivate(m);
    9731001  }
     1002
     1003  owl_message_save_ccs(m);
    9741004}
    9751005
  • Makefile.am

    rae333f0 rc45e1eb  
    11ACLOCAL_AMFLAGS = -I m4
     2CFLAGS += $(EXTRA_CFLAGS)
    23
    34GIT_DESCRIPTION := $(if $(wildcard .git),$(shell git describe --match='barnowl-*' HEAD 2>/dev/null))
     
    4849     keypress.c keymap.c keybinding.c cmd.c context.c \
    4950     aim.c buddy.c buddylist.c style.c errqueue.c \
    50      zbuddylist.c popexec.c obarray.c select.c wcwidth.c \
     51     zbuddylist.c popexec.c select.c wcwidth.c \
    5152     glib_compat.c filterproc.c
    5253
  • commands.c

    r14965e5 rd544237  
    9292              "Use 'show keymaps' to see the existing keymaps.\n"
    9393              "Key sequences may be things like M-C-t or NPAGE.\n\n"
    94               "Ex.: bindkey recv C-b command zwrite -c barnowl"
    95               "SEE ALSO: bindkey"),
     94              "Ex.: bindkey recv C-b command zwrite -c barnowl\n"
     95              "Ex.: bindkey recv m command start-command zwrite -c my-class -i \n\n"
     96              "SEE ALSO: unbindkey, start-command"),
    9697
    9798  OWLCMD_ARGS("unbindkey", owl_command_unbindkey, OWL_CTX_ANY,
     
    100101              "Removes a binding of a key sequence within a keymap.\n"
    101102              "Use 'show keymaps' to see the existing keymaps.\n"
    102               "Ex.: unbindkey recv H"
     103              "Ex.: unbindkey recv H\n\n"
    103104              "SEE ALSO: bindkey"),
    104105
    105106  OWLCMD_ARGS("zwrite", owl_command_zwrite, OWL_CTX_INTERACTIVE,
    106107              "send a zephyr",
    107               "zwrite [-n] [-C] [-c class] [-i instance] [-r realm] [-O opcde] [<user> ...] [-m <message...>]",
     108              "zwrite [-n] [-C] [-c class] [-i instance] [-r realm] [-O opcode] [<user> ...] [-m <message...>]",
    108109              "Zwrite send a zephyr to the one or more users specified.\n\n"
    109110              "The following options are available:\n\n"
     
    137138  OWLCMD_ARGS("zcrypt", owl_command_zcrypt, OWL_CTX_INTERACTIVE,
    138139              "send an encrypted zephyr",
    139               "zcrypt [-n] [-C] [-c class] [-i instance] [-r realm] [-O opcde] [-m <message...>]\n",
     140              "zcrypt [-n] [-C] [-c class] [-i instance] [-r realm] [-O opcode] [-m <message...>]\n",
    140141              "Behaves like zwrite but uses encryption.  Not for use with\n"
    141142              "personal messages\n"),
     
    147148              "allow editing.\n\n"
    148149              "If 'sender' is specified, reply to the sender.\n\n"
    149               "If 'all' or no args are specified, reply publically to the\n"
     150              "If 'all' or no args are specified, reply publicly to the\n"
    150151              "same class/instance for non-personal messages and to the\n"
    151152              "sender for personal messages.\n\n"
     
    265266              "zpunt <class> <instance> [recipient]\n"
    266267              "zpunt <instance>",
    267               "The zpunt command will supress message to the specified\n"
     268              "The zpunt command will suppress messages to the specified\n"
    268269              "zephyr triplet.  In the second usage messages are suppressed\n"
    269270              "for class MESSAGE and the named instance.\n\n"
     
    282283              "punt <filter-text>",
    283284              "punt <filter-text (multiple words)>\n"
    284               "The punt command will supress message to the specified\n"
     285              "The punt command will suppress messages to the specified\n"
    285286              "filter\n\n"
    286287              "SEE ALSO:  unpunt, zpunt, show zpunts\n"),
     
    585586              "name style after the -s argument.\n"
    586587              "\n"
    587               "The other usages listed above are abbreivated forms that simply set\n"
     588              "The other usages listed above are abbreviated forms that simply set\n"
    588589              "the filter of the current view. The -d option allows you to write a\n"
    589590              "filter expression that will be dynamically created by owl and then\n"
     
    593594  OWLCMD_ARGS("smartnarrow", owl_command_smartnarrow, OWL_CTX_INTERACTIVE,
    594595              "view only messages similar to the current message",
    595               "smartnarrow [-i | --instance]  [-r | --relatde]",
     596              "smartnarrow [-i | --instance]  [-r | --related]",
    596597              "If the curmsg is a personal message narrow\n"
    597598              "   to the conversation with that user.\n"
     
    613614              "   message, the filter is to that instance.\n"
    614615              "If the curmsg is a class message, the filter is that class.\n"
    615               "If the curmsg is a class message and '-i' is specied\n"
     616              "If the curmsg is a class message and '-i' is specified\n"
    616617              "    the filter is to that class and instance.\n"),
    617618
     
    673674              "for formatting messages.\n\n"
    674675              "Show variables will list the names of all variables.\n\n"
    675               "Show errors will show a list of errors ecountered by Owl.\n\n"
     676              "Show errors will show a list of errors encountered by Owl.\n\n"
    676677              "SEE ALSO: filter, view, alias, bindkey, help\n"),
    677678 
     
    742743              "set the search highlight string without searching",
    743744              "setsearch <string>",
    744               "The setsearch command highlights all occurences of its\n"
     745              "The setsearch command highlights all occurrences of its\n"
    745746          "argument and makes it the default argument for future\n"
    746747          "search commands, but does not move the cursor.  With\n"
     
    12941295  char opt;
    12951296  int instance = 0, related = 0, i;
    1296   char **tmp_argv = owl_malloc(sizeof(char *) * argc);
     1297  const char **tmp_argv = owl_malloc(sizeof(char *) * argc);
    12971298
    12981299  for (i = 0; i < argc; i++)
    1299     tmp_argv[i] = owl_strdup(argv[i]);
    1300 
    1301   static struct option options[] = {
     1300    tmp_argv[i] = argv[i];
     1301
     1302  static const struct option options[] = {
    13021303    {"instance", 0, 0, 'i'},
    13031304    {"related",  0, 0, 'r'},
    13041305    {NULL,       0, 0, 0}};
    1305   while ((opt = getopt_long(argc, tmp_argv, "ir", options, NULL)) != -1) {
     1306
     1307  optind = 0;
     1308  while ((opt = getopt_long(argc, (char **)tmp_argv, "ir", options, NULL)) != -1) {
    13061309    switch (opt) {
    13071310      case 'i':
     
    13171320  }
    13181321
    1319   for (i = 0; i < argc; i++)
    1320     owl_free(tmp_argv[i]);
    1321   owl_free(tmp_argv);
    1322 
    13231322  filtname = owl_function_smartfilter(instance, related);
    13241323
     
    13291328
    13301329done:
    1331   optind = 0; /* reset getopt */
     1330  owl_free(tmp_argv);
     1331
    13321332  return NULL;
    13331333}
     
    16081608char *owl_command_exec(int argc, const char *const *argv, const char *buff)
    16091609{
    1610   return owl_function_exec(argc, argv, buff, 0);
     1610  return owl_function_exec(argc, argv, buff, OWL_OUTPUT_RETURN);
    16111611}
    16121612
    16131613char *owl_command_pexec(int argc, const char *const *argv, const char *buff)
    16141614{
    1615   return owl_function_exec(argc, argv, buff, 1);
     1615  return owl_function_exec(argc, argv, buff, OWL_OUTPUT_POPUP);
    16161616}
    16171617
    16181618char *owl_command_aexec(int argc, const char *const *argv, const char *buff)
    16191619{
    1620   return owl_function_exec(argc, argv, buff, 2);
     1620  return owl_function_exec(argc, argv, buff, OWL_OUTPUT_ADMINMSG);
    16211621}
    16221622
    16231623char *owl_command_perl(int argc, const char *const *argv, const char *buff)
    16241624{
    1625   return owl_function_perl(argc, argv, buff, 0);
     1625  return owl_function_perl(argc, argv, buff, OWL_OUTPUT_RETURN);
    16261626}
    16271627
    16281628char *owl_command_pperl(int argc, const char *const *argv, const char *buff)
    16291629{
    1630   return owl_function_perl(argc, argv, buff, 1);
     1630  return owl_function_perl(argc, argv, buff, OWL_OUTPUT_POPUP);
    16311631}
    16321632
    16331633char *owl_command_aperl(int argc, const char *const *argv, const char *buff)
    16341634{
    1635   return owl_function_perl(argc, argv, buff, 2);
     1635  return owl_function_perl(argc, argv, buff, OWL_OUTPUT_ADMINMSG);
    16361636}
    16371637
  • doc/releasing-barnowl.txt

    r1ea0249 r5f08dbe  
    1 DOING A BARNOWL RELEASE
     1-*- mode: org *-
     2* DOING A BARNOWL RELEASE
     3  - [ ] Send mail to barnowl-dev indicating that a release is
     4        happening soon, and soliciting any improvements that
     5        developers want included in the release.
     6  - [ ] Wait a while (a week or so, or more if necessary) for any
     7        pending patches to get in.
     8  - [ ] Prepare the -rc commit
     9   - [ ] Run ./scripts/add-changelog NEW-VERSION PREV-TAG..HEAD
     10   - [ ] Edit ChangeLog to combine and filter entries
     11   - [ ] Edit configure.ac to bump the version to 1.Nrc1
     12  - [ ] Commit with message 'BarnOwl 1.Nrc1'; don't push until after
     13        builds all succeed
     14  - [ ] Run scripts/do-release with -f (so it won't complain about
     15        missing changelog), makes a tarball
     16  - [ ] Do a locker build (See DOING A LOCKER BUILD)
     17  - [ ] Update configure.ac on master to bump the version to 1.(N+1)dev
     18  - [ ] Push git git:
     19   - [ ] The RC commit
     20   - [ ] The configure.ac change on master
     21   - [ ] A release-1.N branch pointing at the RC commit
     22  - [ ] Copy tarball into /mit/barnowl/web_scripts/dist
     23  - [ ] Send mail announcing the RC to barnowl-dev@mit.edu
     24  - [ ] Wait 1-2 weeks, collect any bug reports
     25  - [ ] Fix any reported bugs on master
     26  - [ ] Cherry-pick/backport appropriate fixes from master onto
     27        release-1.N
     28  - [ ] If there have been many or large bugfixes, repeat the process
     29        for barnowl 1.Nrc2
    230
    3 [ ] Send mail to barnowl-dev indicating that a release is happening
    4     soon, and soliciting any improvements that developers want
    5     included in the release.
     31* DOING THE ACTUAL RELEASE
     32  - [ ] Update the changelog and configure.ac for barnowl 1.N
     33  - [ ] run ./scripts/do-release
     34  - [ ] Do the locker build
     35  - [ ] Push the release tag
     36  - [ ] Write up release notes
     37        (I usually use the previous release's email as a template)
     38  - [ ] Update the website
     39   - [ ] Add the line that `do-release` printed to the changelog on the home page
     40   - [ ] Add your release notes as /release-notes/1.N
     41  - [ ] Send the release notes to barnowl-users@mit.edu
    642
    7 [ ] Wait a while (a week or so, or more if necessary) for any pending
    8     patches to get in.
     43* DOING A LOCKER BUILD
     44  - [ ] Copy the tarball to build@nelhage.com
     45  - [ ] ssh to build@nelhage.com and kinit
     46  - [ ] On build@nelhage.com, run barnowl-build-all TARBALL.
     47        This script does builds for all Debathena platforms using chroots
     48        on nelhage.com, and ssh's to Athena 9 machines to do the two
     49        Athena 9 builds.
     50  - [ ] Sanity-check the builds
     51   - [ ] Do cursory testing on debathena platforms and both athena9s.
     52   - [ ] chroots on nelhage.com also useful
     53  - [ ] Update symlinks with locker-update script;
     54        - locker-update [-b] [-n] VERSION
     55        - e.g. locker-update -b -n barnowl-1.6rc1
     56   - [ ] Use -b to update the barnowl-beta name
     57   - [ ] Use -n first for dry-run
    958
    10 [ ] Prepare the -rc commit
    11 
    12  [ ] Run ./scripts/add-changelog NEW-VERSION PREV-TAG..HEAD
    13 
    14  [ ] Edit ChangeLog to combine and filter entries
    15 
    16  [ ] Edit configure.ac to bump the version to 1.Nrc1
    17 
    18 [ ] Commit with message 'BarnOwl 1.Nrc1'; don't push until after
    19     builds all succeed
    20 
    21 [ ] Run scripts/do-release with -f (so it won't complain about missing
    22     changelog), makes a tarball
    23 
    24 [ ] Make all the builds
    25  
    26  [ ] On build@nelhage.com, run barnowl-build-all TARBALL to build for
    27      everything with chroots, doesn't do athena 9 builds. Builds into
    28      locker parellel to all other versions.
    29 
    30  [ ] Do two athena9 builds: solaris and linux, usually use multics (or
    31      sun.dialup) for the solaris build, oliver for linux athena9
    32 
    33   [ ] Remember to add gnu; add barnowl
    34 
    35   [ ] eval `barnowl-perl-config` to include the perl modules in the
    36       barnowl locker
    37 
    38   [ ] Run scripts/locker-build TARBALL (barnowl-build-all loops over
    39       all of them in schroots). It overrides existing one.
    40 
    41 [ ] Sanity-check the builds
    42 
    43  [ ] Do cursory testing on debathena platforms and both athena9s.
    44 
    45  [ ] chroots on nelhage.com also useful
    46 
    47 [ ] Update symlinks with locker-update script;
    48 
    49       locker-update [-b] [-n] VERSION
    50 
    51     e.g. locker-update -b -n barnowl-1.6rc1
    52  
    53  [ ] -b for the beta
    54 
    55  [ ] -n first for dry-run
    56 
    57 [ ] Push the RC commit
    58 
    59 [ ] Copy tarball into /mit/barnowl/web_scripts/dist
    60 
    61 [ ] Send mail (rcs to barnowl-dev@, release to barnowl-users@)
    62 
    63 [ ] Make an actual release about a week after the RC
    64 
    65 
    66 LOCKER LAYOUT
    67 
    68 * builds/barnowl-VERSION contains the arch-independent files by
    69   version
    70 
    71 * arch/SYSNAME/bin/barnowl-VERSION is the actual binary
    72 
    73 * arch/SYSNAME/bin/barnowl is a symlink to ../../common/bin/barnowl
    74   (wrapper script runs barnowl.real). .../barnowl.real is a symlink to
    75   the latest version.
    76 
    77 * zcrypt is also installed with a versioned name, but currently
    78   barnowl-N will not run zcrypt-N, so we can't change that interface
    79   at all.
     59* LOCKER LAYOUT
     60  - builds/barnowl-VERSION contains the arch-independent files by
     61    version
     62  - arch/SYSNAME/bin/barnowl-VERSION is the actual binary
     63  - arch/SYSNAME/bin/barnowl is a symlink to ../../common/bin/barnowl
     64    (wrapper script runs barnowl.real). .../barnowl.real is a symlink
     65    to the latest version.
     66  - zcrypt is also installed with a versioned name, but currently
     67    barnowl-N will not run zcrypt-N, so we can't change that interface
     68    at all.
  • global.c

    r719173c4 r20aced3  
    5353  g->filterlist = NULL;
    5454  owl_list_create(&(g->puntlist));
    55   owl_list_create(&(g->messagequeue));
     55  g->messagequeue = g_queue_new();
    5656  owl_dict_create(&(g->styledict));
    5757  g->curmsg_vert_offset=0;
     
    113113  g->pseudologin_notify = 0;
    114114
    115   owl_obarray_init(&(g->obarray));
    116 
    117115  owl_message_init_fmtext_cache();
    118116  owl_list_create(&(g->io_dispatch_list));
     
    120118  g->timerlist = NULL;
    121119  g->interrupted = FALSE;
     120
     121  /* set up a pad for input */
     122  g->input_pad = newpad(1, 1);
     123  nodelay(g->input_pad, 1);
     124  keypad(g->input_pad, 1);
     125  meta(g->input_pad, 1);
    122126}
    123127
     
    179183  idlok(owl_global_get_curs_msgwin(g), FALSE);
    180184
    181   nodelay(owl_global_get_curs_typwin(g), 1);
    182   keypad(owl_global_get_curs_typwin(g), TRUE);
    183185  wmove(owl_global_get_curs_typwin(g), 0, 0);
    184 
    185   meta(owl_global_get_curs_typwin(g), TRUE);
    186186}
    187187
     
    862862void owl_global_messagequeue_addmsg(owl_global *g, owl_message *m)
    863863{
    864   owl_list_append_element(&(g->messagequeue), m);
     864  g_queue_push_tail(g->messagequeue, m);
    865865}
    866866
     
    873873  owl_message *out;
    874874
    875   if (owl_list_get_size(&(g->messagequeue))==0) return(NULL);
    876   out=owl_list_get_element(&(g->messagequeue), 0);
    877   owl_list_remove_element(&(g->messagequeue), 0);
    878   return(out);
     875  if (g_queue_is_empty(g->messagequeue))
     876    return NULL;
     877  out = g_queue_pop_head(g->messagequeue);
     878  return out;
    879879}
    880880
    881881int owl_global_messagequeue_pending(owl_global *g)
    882882{
    883   if (owl_list_get_size(&(g->messagequeue))==0) return(0);
    884   return(1);
     883  return !g_queue_is_empty(g->messagequeue);
    885884}
    886885
     
    10101009}
    10111010
    1012 const char * owl_global_intern(owl_global *g, const char * string)
    1013 {
    1014   return owl_obarray_insert(&(g->obarray), string);
    1015 }
    1016 
    10171011owl_list *owl_global_get_io_dispatch_list(owl_global *g)
    10181012{
  • owl.c

    rf7cf6c2 r3aa0522  
    311311{
    312312  owl_input j;
    313   WINDOW *typwin;
    314 
    315   typwin = owl_global_get_curs_typwin(&g);
    316313
    317314  while (1) {
    318     j.ch = wgetch(typwin);
     315    j.ch = wgetch(g.input_pad);
    319316    if (j.ch == ERR) return;
    320317
     
    339336     
    340337      for (i = 1; i < bytes; i++) {
    341         int tmp =  wgetch(typwin);
     338        int tmp = wgetch(g.input_pad);
    342339        /* If what we got was not a byte, or not a continuation byte */
    343340        if (tmp > 0xff || !(tmp & 0x80 && ~tmp & 0x40)) {
     
    458455#endif /* OWL_STDERR_REDIR */
    459456
    460 void owl_zephyr_buddycheck_timer(owl_timer *t, void *data)
    461 {
    462   if (owl_global_is_pseudologins(&g)) {
    463     owl_function_debugmsg("Doing zephyr buddy check");
    464     owl_function_zephyr_buddy_check(1);
    465   }
     457static int owl_refresh_pre_select_action(owl_ps_action *a, void *data)
     458{
     459  /* if a resize has been scheduled, deal with it */
     460  owl_global_resize(&g, 0, 0);
     461  /* also handle relayouts */
     462  owl_global_relayout(&g);
     463
     464  /* update the terminal if we need to */
     465  if (owl_global_is_needrefresh(&g)) {
     466    /* these are here in case a relayout changes the windows */
     467    WINDOW *sepwin = owl_global_get_curs_sepwin(&g);
     468    WINDOW *typwin = owl_global_get_curs_typwin(&g);
     469
     470    /* push all changed windows to screen */
     471    update_panels();
     472    /* leave the cursor in the appropriate window */
     473    if (!owl_popwin_is_active(owl_global_get_popwin(&g))
     474        && owl_global_get_typwin(&g)) {
     475      owl_function_set_cursor(typwin);
     476    } else {
     477      owl_function_set_cursor(sepwin);
     478    }
     479    doupdate();
     480    owl_global_set_noneedrefresh(&g);
     481  }
     482  return 0;
    466483}
    467484
     
    469486int main(int argc, char **argv, char **env)
    470487{
    471   WINDOW *sepwin, *typwin;
    472488  int argcsave;
    473489  const char *const *argvsave;
     
    583599  owl_function_source(NULL);
    584600
    585   update_panels();
    586 
    587601  /* Set the default style */
    588602  owl_function_debugmsg("startup: setting startup and default style");
     
    605619  owl_global_push_context(&g, OWL_CTX_READCONFIG|OWL_CTX_RECV, NULL, "recv");
    606620
    607   owl_select_add_timer(180, 180, owl_zephyr_buddycheck_timer, NULL, NULL);
    608 
    609   /* If we ever deprecate the mainloop hook, remove this. */
    610   owl_select_add_timer(0, 1, owl_perlconfig_mainloop, NULL, NULL);
    611 
     621  owl_select_add_pre_select_action(owl_refresh_pre_select_action, NULL, NULL);
    612622  owl_select_add_pre_select_action(owl_process_messages, NULL, NULL);
    613623
     
    615625  /* main loop */
    616626  while (1) {
    617 
    618     /* if a resize has been scheduled, deal with it */
    619     owl_global_resize(&g, 0, 0);
    620     /* also handle relayouts */
    621     owl_global_relayout(&g);
    622 
    623     /* these are here in case a relayout changes the windows */
    624     sepwin=owl_global_get_curs_sepwin(&g);
    625     typwin=owl_global_get_curs_typwin(&g);
    626 
    627     /* update the terminal if we need to */
    628     if (owl_global_is_needrefresh(&g)) {
    629       /* push all changed windows to screen */
    630       update_panels();
    631       /* leave the cursor in the appropriate window */
    632       if (!owl_popwin_is_active(owl_global_get_popwin(&g))
    633           && owl_global_get_typwin(&g)) {
    634         owl_function_set_cursor(typwin);
    635       } else {
    636         owl_function_set_cursor(sepwin);
    637       }
    638       doupdate();
    639       owl_global_set_noneedrefresh(&g);
    640     }
    641 
    642627    /* select on FDs we know about. */
    643628    owl_select();
  • owl.h

    rf7cf6c2 r20aced3  
    184184#define OWL_VARIABLE_BOOL       2
    185185#define OWL_VARIABLE_STRING     3
     186
     187#define OWL_OUTPUT_RETURN       0
     188#define OWL_OUTPUT_POPUP        1
     189#define OWL_OUTPUT_ADMINMSG     2
    186190
    187191#define OWL_FILTER_MAX_DEPTH    300
     
    518522} owl_colorpair_mgr;
    519523
    520 typedef struct _owl_obarray {
    521   owl_list strings;
    522 } owl_obarray;
    523 
    524524typedef struct _owl_io_dispatch {
    525525  int fd;                                     /* FD to watch for dispatch. */
     
    565565  owl_view current_view;
    566566  owl_messagelist msglist;
     567  WINDOW *input_pad;
    567568  PANEL *recpan, *seppan, *msgpan, *typpan;
    568569  int needrefresh;
     
    605606  char *aim_screenname_for_filters;     /* currently logged in AIM screen name */
    606607  owl_buddylist buddylist;  /* list of logged in AIM buddies */
    607   owl_list messagequeue;    /* for queueing up aim and other messages */
     608  GQueue *messagequeue;     /* for queueing up aim and other messages */
    608609  owl_dict styledict;       /* global dictionary of available styles */
    609610  char *response;           /* response to the last question asked */
     
    618619  int pseudologin_notify;
    619620  struct termios startup_tio;
    620   owl_obarray obarray;
    621621  owl_list io_dispatch_list;
    622622  owl_list psa_list;
  • perl/lib/BarnOwl/Hooks.pm

    rb30c256 r3aa0522  
    7979our %EXPORT_TAGS = (all => [@EXPORT_OK]);
    8080
     81use BarnOwl::MainLoopCompatHook;
     82
    8183our $startup = BarnOwl::Hook->new;
    8284our $shutdown = BarnOwl::Hook->new;
    8385our $receiveMessage = BarnOwl::Hook->new;
    8486our $newMessage = BarnOwl::Hook->new;
    85 our $mainLoop = BarnOwl::Hook->new;
     87our $mainLoop = BarnOwl::MainLoopCompatHook->new;
    8688our $getBuddyList = BarnOwl::Hook->new;
    8789our $getQuickstart = BarnOwl::Hook->new;
     
    162164    }
    163165   
     166    $mainLoop->check_owlconf();
    164167    $startup->run(0);
    165168    BarnOwl::startup() if *BarnOwl::startup{CODE};
     
    186189   
    187190    BarnOwl::new_msg($m) if *BarnOwl::new_msg{CODE};
    188 }
    189 
    190 sub _mainloop_hook {
    191     $mainLoop->run;
    192     BarnOwl::mainloop_hook() if *BarnOwl::mainloop_hook{CODE};
    193191}
    194192
  • perl/lib/BarnOwl/Timer.pm

    ree183be r8d16e58  
    2121}
    2222
     23sub stop {
     24    my $self = shift;
     25    if(defined($self->{timer})) {
     26        BarnOwl::Internal::remove_timer($self->{timer});
     27        undef $self->{timer};
     28    }
     29}
     30
    2331sub do_callback {
    2432    my $self = shift;
     
    2836sub DESTROY {
    2937    my $self = shift;
    30     if(defined($self->{timer})) {
    31         BarnOwl::Internal::remove_timer($self->{timer});
    32     }
     38    $self->stop;
    3339}
    3440
  • perl/modules/Jabber/lib/BarnOwl/Message/Jabber.pm

    rc854e74 r8278543  
    7777    } elsif ($self->jtype eq 'groupchat') {
    7878        my $room = $self->room;
    79         $filter = "jabber-room-$room";
    80         BarnOwl::command(qw[filter], $filter,
    81                          qw[type ^jabber$ and room], "^\Q$room\E\$");
     79        if ($inst) {
     80            my $subject = $self->subject;
     81            $filter = "jabber-room-$room-subject-$subject";
     82            BarnOwl::command(qw[filter], $filter,
     83                             qw[type ^jabber$ and room], "^\Q$room\E\$",
     84                             qw[and subject], "^\Q$subject\E\$");
     85        } else {
     86            $filter = "jabber-room-$room";
     87            BarnOwl::command(qw[filter], $filter,
     88                             qw[type ^jabber$ and room], "^\Q$room\E\$");
     89        }
    8290        return $filter;
    8391    } elsif ($self->login ne 'none') {
  • perl/modules/Jabber/lib/BarnOwl/Module/Jabber.pm

    r8789410 raa0a0b5  
    285285        {
    286286            summary => "Send a Jabber Message",
    287             usage   => "jwrite <jid> [-t <thread>] [-s <subject>] [-a <account>]"
     287            usage   => "jwrite <jid> [-t <thread>] [-s <subject>] [-a <account>] [-m <message>]"
    288288        }
    289289    );
     
    308308            description => "jmuc sends Jabber commands related to MUC.\n\n"
    309309              . "The following commands are available\n\n"
    310               . "join <muc>  Join a MUC.\n\n"
     310              . "join <muc>[/<nick>]\n"
     311              . "            Join a MUC (with a given nickname, or otherwise your JID).\n\n"
    311312              . "part <muc>  Part a MUC.\n"
    312313              . "            The MUC is taken from the current message if not supplied.\n\n"
     
    377378        my $cjidStr = $conn->baseJIDExists($jidStr);
    378379        if ($cjidStr) {
    379             BarnOwl::error("Already logged in as $cjidStr.");
    380             return;
     380            die("Already logged in as $cjidStr.\n");
    381381        }
    382382    }
     
    387387
    388388    if ( !$uid || !$componentname ) {
    389         BarnOwl::error("usage: $cmd JID");
    390         return;
     389        die("usage: $cmd JID\n");
    391390    }
    392391
    393392    if ( $conn->jidActive($jidStr) ) {
    394         BarnOwl::error("Already logged in as $jidStr.");
    395         return;
     393        die("Already logged in as $jidStr.\n");
    396394    } elsif ($conn->jidExists($jidStr)) {
    397395        return $conn->tryReconnect($jidStr, 1);
     
    526524sub cmd_jlist {
    527525    if ( !( scalar $conn->getJIDs() ) ) {
    528         BarnOwl::error("You are not logged in to Jabber.");
    529         return;
     526        die("You are not logged in to Jabber.\n");
    530527    }
    531528    BarnOwl::popless_ztext( onGetBuddyList() );
     
    534531sub cmd_jwrite {
    535532    if ( !$conn->connected() ) {
    536         BarnOwl::error("You are not logged in to Jabber.");
    537         return;
     533        die("You are not logged in to Jabber.\n");
    538534    }
    539535
     
    543539    my $jwrite_thread  = "";
    544540    my $jwrite_subject = "";
     541    my $jwrite_body;
    545542    my ($to, $from);
    546543    my $jwrite_type    = "chat";
     
    554551        'subject=s' => \$jwrite_subject,
    555552        'account=s' => \$from,
    556         'id=s'     =>  \$jwrite_sid,
     553        'id=s'      => \$jwrite_sid,
     554        'message=s' => \$jwrite_body,
    557555    ) or die("Usage: jwrite <jid> [-t <thread>] [-s <subject>] [-a <account>]\n");
    558556    $jwrite_type = 'groupchat' if $gc;
    559557
    560558    if ( scalar @ARGV != 1 ) {
    561         BarnOwl::error(
    562             "Usage: jwrite <jid> [-t <thread>] [-s <subject>] [-a <account>]");
    563         return;
     559        die("Usage: jwrite <jid> [-t <thread>] [-s <subject>] [-a <account>]\n");
    564560    }
    565561    else {
     
    570566
    571567    unless(scalar @candidates) {
    572         die("Unable to resolve JID $to");
     568        die("Unable to resolve JID $to\n");
    573569    }
    574570
     
    577573    unless(scalar @candidates) {
    578574        if(!$from) {
    579             die("You must specify an account with -a");
     575            die("You must specify an account with -a\n");
    580576        } else {
    581             die("Unable to resolve account $from");
     577            die("Unable to resolve account $from\n");
    582578        }
    583579    }
     
    594590        type    => $jwrite_type
    595591    };
     592
     593    if (defined($jwrite_body)) {
     594        process_owl_jwrite($jwrite_body);
     595        return;
     596    }
    596597
    597598    if(scalar @candidates > 1) {
     
    631632    my $func = $jmuc_commands{$cmd};
    632633    if ( !$func ) {
    633         BarnOwl::error("jmuc: Unknown command: $cmd");
    634         return;
     634        die("jmuc: Unknown command: $cmd\n");
    635635    }
    636636
     
    654654        }
    655655        else {
    656             BarnOwl::error('You must specify an account with -a <jid>');
     656            die("You must specify an account with -a <jid>\n");
    657657        }
    658658        return $func->( $jid, $muc, @ARGV );
     
    667667
    668668    $muc = shift @ARGV
    669       or die("Usage: jmuc join <muc> [-p <password>] [-a <account>]");
     669      or die("Usage: jmuc join <muc> [-p <password>] [-a <account>]\n");
    670670
    671671    die("Error: Must specify a fully-qualified MUC name (e.g. barnowl\@conference.mit.edu)\n")
     
    680680                                                   MaxChars => 0
    681681                                                  });
    682     $completion_jids{$muc} = 1;
     682    $completion_jids{$muc->GetJID('base')} = 1;
    683683    return;
    684684}
     
    688688
    689689    $muc = shift @args if scalar @args;
    690     die("Usage: jmuc part [<muc>] [-a <account>]") unless $muc;
     690    die("Usage: jmuc part [<muc>] [-a <account>]\n") unless $muc;
    691691
    692692    if($conn->getConnectionFromJID($jid)->MUCLeave(JID => $muc)) {
    693693        queue_admin_msg("$jid has left $muc.");
    694694    } else {
    695         die("Error: Not joined to $muc");
     695        die("Error: Not joined to $muc\n");
    696696    }
    697697}
     
    703703    $muc = shift @args if scalar @args;
    704704
    705     die('Usage: jmuc invite <jid> [<muc>] [-a <account>]')
     705    die("Usage: jmuc invite <jid> [<muc>] [-a <account>]\n")
    706706      unless $muc && $invite_jid;
    707707
     
    718718    my ( $jid, $muc, @args ) = @_;
    719719    $muc = shift @args if scalar @args;
    720     die("Usage: jmuc configure [<muc>]") unless $muc;
     720    die("Usage: jmuc configure [<muc>]\n") unless $muc;
    721721    my $iq = Net::Jabber::IQ->new();
    722722    $iq->SetTo($muc);
     
    759759
    760760    $muc = shift @args if scalar @args;
    761     die("Usage: jmuc presence [<muc>]") unless $muc;
     761    die("Usage: jmuc presence [<muc>]\n") unless $muc;
    762762
    763763    if ($muc eq '-a') {
     
    774774    else {
    775775        my $m = $conn->getConnectionFromJID($jid)->FindMUC(jid => $muc);
    776         die("No such muc: $muc") unless $m;
     776        die("No such muc: $muc\n") unless $m;
    777777        BarnOwl::popless_ztext(jmuc_presence_single($m));
    778778    }
     
    801801    my $func = $jroster_commands{$cmd};
    802802    if ( !$func ) {
    803         BarnOwl::error("jroster: Unknown command: $cmd");
    804         return;
     803        die("jroster: Unknown command: $cmd\n");
    805804    }
    806805
     
    825824        }
    826825        else {
    827             BarnOwl::error('You must specify an account with -a <jid>');
     826            die("You must specify an account with -a <jid>\n");
    828827        }
    829828        return $func->( $jid, $name, \@groups, $purgeGroups,  @ARGV );
     
    849848    }
    850849    else {
    851         BarnOwl::error('You must specify an account with -a <jid>');
     850        die("You must specify an account with -a <jid>\n");
    852851    }
    853852
     
    12341233        $completion_jids{$room} = 1;
    12351234
     1235        my $muc;
     1236        if ($dir eq 'in') {
     1237            my $connection = $conn->getConnectionFromSid($props{sid});
     1238            $muc = $connection->FindMUC(jid => $from);
     1239        } else {
     1240            my $connection = $conn->getConnectionFromJID($props{from});
     1241            $muc = $connection->FindMUC(jid => $to);
     1242        }
     1243        $props{from} = $muc->GetFullJID($from) || $nick || $room;
    12361244        $props{sender} = $nick || $room;
    12371245        $props{recipient} = $room;
     
    13311339        return $givenJIDStr if ($conn->jidExists($givenJIDStr) );
    13321340        return resolveConnectedJID($givenJID->GetJID('base')) if $loose;
    1333         die("Invalid account: $givenJIDStr");
     1341        die("Invalid account: $givenJIDStr\n");
    13341342    }
    13351343
     
    13841392        # Not one of ours.
    13851393        else {
    1386             die("Invalid account: $givenJIDStr");
     1394            die("Invalid account: $givenJIDStr\n");
    13871395        }
    13881396
     
    14301438    if($from) {
    14311439        $from_jid = resolveConnectedJID($from, 1);
    1432         die("Unable to resolve account $from") unless $from_jid;
     1440        die("Unable to resolve account $from\n") unless $from_jid;
    14331441        $to_jid = resolveDestJID($to, $from_jid);
    14341442        push @matches, [$from_jid, $to_jid] if $to_jid;
  • perlconfig.c

    r1b1cd2c r3aa0522  
    582582}
    583583
    584 void owl_perlconfig_mainloop(owl_timer *t, void *data)
    585 {
    586   dSP;
    587   if (!owl_perlconfig_is_function("BarnOwl::Hooks::_mainloop_hook"))
    588     return;
    589   PUSHMARK(SP) ;
    590   call_pv("BarnOwl::Hooks::_mainloop_hook", G_DISCARD|G_EVAL);
    591   if(SvTRUE(ERRSV)) {
    592     owl_function_error("%s", SvPV_nolen(ERRSV));
    593   }
    594   return;
    595 }
    596 
    597584void owl_perlconfig_io_dispatch(const owl_io_dispatch *d, void *data)
    598585{
  • popwin.c

    r06cc8d9 r0881cdd  
    2828  popwin = newwin(pw->lines-2, pw->cols-2, startline+1, startcol+1);
    2929  pw->poppanel = new_panel(popwin);
    30  
    31   meta(popwin,TRUE);
    32   nodelay(popwin, 1);
    33   keypad(popwin, TRUE);
    3430
    3531  werase(popwin);
  • scripts/do-release

    r51dbfb5 rc62c755  
    9494NOW=$(date +"%B %d, %Y")
    9595cat <<EOF
    96  * '''$NOW''': BarnOwl $VERS Released. [wiki:Download] it here. or see the [/browser/ChangeLog?rev=$COMMIT ChangeLog]
     96 * '''$NOW''': BarnOwl $VERS Released. [wiki:Download] it here. or see the [wiki:release-notes/$VERS Release Notes] or [/browser/ChangeLog?rev=barnowl-$VERS ChangeLog].
    9797EOF
  • select.c

    r2a17b63 rc3031f3  
    273273
    274274  sigemptyset(&set);
     275  sigaddset(&set, SIGWINCH);
     276  sigaddset(&set, SIGALRM);
     277  sigaddset(&set, SIGPIPE);
     278  sigaddset(&set, SIGTERM);
     279  sigaddset(&set, SIGHUP);
    275280  sigaddset(&set, SIGINT);
    276281  sigprocmask(SIG_BLOCK, &set, oldmask);
  • tester.c

    r4123da1 r3f6555d  
    1616int main(int argc, char **argv, char **env)
    1717{
    18   owl_errqueue_init(owl_global_get_errqueue(&g));
    19   owl_obarray_init(&(g.obarray));
    20   g.context_stack = NULL;
    21   owl_global_push_context(&g, OWL_CTX_STARTUP, NULL, NULL);
     18  /* initialize a fake ncurses, detached from std{in,out} */
     19  FILE *rnull = fopen("/dev/null", "r");
     20  FILE *wnull = fopen("/dev/null", "w");
     21  newterm("xterm", wnull, rnull);
     22  /* initialize global structures */
     23  owl_global_init(&g);
    2224
    2325  numtests = 0;
     
    3133  numfailures += owl_variable_regtest();
    3234  numfailures += owl_filter_regtest();
    33   numfailures += owl_obarray_regtest();
    3435  numfailures += owl_editwin_regtest();
    3536  if (numfailures) {
     
    3738  }
    3839  printf("1..%d\n", numtests);
     40
     41  /* probably not necessary, but tear down the screen */
     42  endwin();
     43  fclose(rnull);
     44  fclose(wnull);
     45
    3946  return(numfailures);
    4047}
     
    293300}
    294301
    295 
    296 int owl_obarray_regtest(void) {
    297   int numfailed = 0;
    298   const char *p,*p2;
    299 
    300   owl_obarray oa;
    301   owl_obarray_init(&oa);
    302 
    303   printf("# BEGIN testing owl_obarray\n");
    304 
    305   p = owl_obarray_insert(&oa, "test");
    306   FAIL_UNLESS("returned string is equal", p && !strcmp(p, "test"));
    307   p2 = owl_obarray_insert(&oa, "test");
    308   FAIL_UNLESS("returned string is equal", p2 && !strcmp(p2, "test"));
    309   FAIL_UNLESS("returned the same string", p2 && p == p2);
    310 
    311   p = owl_obarray_insert(&oa, "test2");
    312   FAIL_UNLESS("returned string is equal", p && !strcmp(p, "test2"));
    313   p2 = owl_obarray_find(&oa, "test2");
    314   FAIL_UNLESS("returned the same string", p2 && !strcmp(p2, "test2"));
    315 
    316   p = owl_obarray_find(&oa, "nothere");
    317   FAIL_UNLESS("Didn't find a string that isn't there", p == NULL);
    318 
    319   printf("# END testing owl_obarray (%d failures)\n", numfailed);
    320 
    321   return numfailed;
    322 }
    323 
    324302int owl_editwin_regtest(void) {
    325303  int numfailed = 0;
  • variable.c

    r4d9e4254 rd544237  
    110110
    111111  OWLVAR_ENUM( "loggingdirection" /* %OwlVarStub */, OWL_LOGGING_DIRECTION_BOTH,
    112                "specifices which kind of messages should be logged",
     112               "specifies which kind of messages should be logged",
    113113               "Can be one of 'both', 'in', or 'out'.  If 'in' is\n"
    114114               "selected, only incoming messages are logged, if 'out'\n"
     
    138138                    "location of users in your .anyone file.  If a user is present\n"
    139139                    "but sent no login message, or a user is not present that sent no\n"
    140                     "logout message, a pseudo login or logout message wil be created\n",
     140                    "logout message, a pseudo login or logout message will be created\n",
    141141                    NULL, owl_variable_pseudologins_set, NULL),
    142142
     
    151151
    152152                 "If non empty, any messages matching the given filter will be logged.\n"
    153                  "This is a completely separate mechanisim from the other logging\n"
     153                 "This is a completely separate mechanism from the other logging\n"
    154154                 "variables like logging, classlogging, loglogins, loggingdirection,\n"
    155155                 "etc.  If you want this variable to control all logging, make sure\n"
     
    198198  OWLVAR_PATH( "newmsgproc" /* %OwlVarStub:newmsgproc */, NULL,
    199199               "name of a program to run when new messages are present",
    200                "The named program will be run when owl recevies new.\n"
     200               "The named program will be run when owl receives new\n"
    201201               "messages.  It will not be run again until the first\n"
    202202               "instance exits"),
     
    213213                 "Called every time you start a zephyrgram without an\n"
    214214                 "explicit zsig.  The default setting implements the policy\n"
    215                  "descripted in the documentation for the 'zsig' variable.\n"),
     215                 "described in the documentation for the 'zsig' variable.\n"),
    216216
    217217  OWLVAR_STRING( "zsig" /* %OwlVarStub */, "",
     
    297297              "number of seconds after AIM login to ignore login messages",
    298298              "This specifies the number of seconds to wait after an\n"
    299               "AIM login before allowing the recipt of AIM login notifications.\n"
     299              "AIM login before allowing the receipt of AIM login notifications.\n"
    300300              "By default this is set to 15.  If you would like to view login\n"
    301301              "notifications of buddies as soon as you login, set it to 0 instead."),
     
    428428int owl_variable_pseudologins_set(owl_variable *v, const void *newval)
    429429{
     430  static owl_timer *timer = NULL;
    430431  if (newval) {
    431432    if (*(const int*)newval == 1) {
    432433      owl_function_zephyr_buddy_check(0);
     434      if (timer == NULL) {
     435        timer = owl_select_add_timer(180, 180, owl_zephyr_buddycheck_timer, NULL, NULL);
     436      }
     437    } else {
     438      if (timer != NULL) {
     439        owl_select_remove_timer(timer);
     440        timer = NULL;
     441      }
    433442    }
    434443  }
  • zephyr.c

    rf25812b r3687413  
    13641364#endif
    13651365
     1366void owl_zephyr_buddycheck_timer(owl_timer *t, void *data)
     1367{
     1368  if (owl_global_is_pseudologins(&g)) {
     1369    owl_function_debugmsg("Doing zephyr buddy check");
     1370    owl_function_zephyr_buddy_check(1);
     1371  } else {
     1372    owl_function_debugmsg("Warning: owl_zephyr_buddycheck_timer call pointless; timer should have been disabled");
     1373  }
     1374}
     1375
    13661376/*
    13671377 * Process zephyrgrams from libzephyr's queue. To prevent starvation,
Note: See TracChangeset for help on using the changeset viewer.