---

local.vtc

Go to the documentation of this file.

/* -*- C -*- */
load_path += ";/afs/athena/user/c/a/cat/project/vt/hacks;/mit/dmaze/vtc";
Load("rmtio");
Load("disp");
Load("cquote");
Load("fquote");
Load("filter");
Load("shell");
Load("bimap");
Load("color");
line_numbers = 1;
default_pager_state = 0;
zfieldregex = regcomp("^([0-9]+): (.*)$");
rndseed(time);

Load("zephyr-core");
Load("zaway");
Load("zclassmap");
Load("zdefout");
Load("zformat");
Load("zpunt");
Load("zreplay");
Load("zsend");
Load("zsend-zcrypt");
Load("zsend-zwrite");
Load("zsig-random");
Load("zsig-responses");
Load("zsig-t");
Load("zwindow");

func zauth_letter(z)
{
  if (is_webzephyr(z))
    return '&';
  else if (stricmp(z->auth, "yes") == 0)
  {
    if (stricmp(z->opcode, "crypt") == 0)
      return '*';
    else
      return'+';
  }
  else if (stricmp(z->auth, "no") == 0)
    return '-';
  else if (stricmp(z->auth, "forged") == 0)
    return '?';
  else
    return ' ';
}

func should_wrap(body) [count, indent, do_wrap, s]
{
  indent = -1;
  do_wrap = 1;
  for (s = explode(body, "\n") + 1; *s; s++)
  {
    count = 0;
    for (; **s == ' ' || **s == '\t'; (*s)++)
      count++;
    if (indent == -1)
    {
      indent = count;
    }
    else if (count - indent > 1 || count - indent < -1)
    {
      do_wrap = 0;
      break;
    }
  }
  /* Hack to not wrap messages with equals signs.  This can be annoying. */
  /*
  if (body[strcspn(body, "=")] != 0)
    do_wrap = 0;
  */

  return do_wrap;
}

func zephyr_output() [z, line, fields, i, s, p, ival, cval, do_wrap,
                      annot, win, body, sig, pipe, style, auth2, front,
                      wz]
{
  /* Extract fields from the current zephyr and initialize a new one. */
  z = cur_rmt->zephyr;
  cur_rmt->zephyr = new_zgram();

  /* Drop trailing newlines from the zephyr. */
  zapply(.chop, z);

  /* Pull the fields out of the zephyr. */
  fields = alloc(z->numfields);
  for (i = 0; i < z->numfields; ++i)
  {
    fields[i] = chop(z->fields[i] ?: "");
  }

  /* Create a history line. */
  line = bprintf("%s\n%s\n%s\n{%s}\n<%s>\n[%s]\n%s:",
                 z->fromhost, z->ztime, z->auth, z->opcode,
                 z->class, z->instance, z->sender);
  for (i = 0; i < z->numfields; ++i)
  {
    line += "\n/\n" + fields[i];
  }
  add_hist(line, S_NORM);

  /* "Normal" zephyrgrams have two fields: a body and a signature. 
   * For abnormal zephyrs, set the body to the concatenated list of
   * fields, and set the signature to empty. */
  if (z->numfields == 2)
  {
    sig = fields[0];
    body = fields[1];
  }
  else
  {
    sig = "";
    body = "";
    for(i = 0; i < z->numfields; ++i)
    {
      body += fields[i];
      if (i != z->numfields - 1)
        body += " / ";
    }
  }

  /* Fold newlines in the zephyr and other things we're tracking. */
  zapply(.fold_newlines, z);
  zapply(.clean_string, z);
  sig = fold_newlines(sig);
  sig = clean_string(sig);

  /* Reduce the things we know about the zephyr's authenticity to a
   * single letter. */
  auth2 = zauth_letter(z);

  /* Notice if the current signature is something we want to respond to. */
  note_zsig_responses(z, sig);

  /* Find the right window to display the message in. */
  win = find_win(z);

  /* Use heuristics to determine whether we should fold newlines in
   * the body of the message. */
  do_wrap = should_wrap(body);

  /* Look for abbreviations for the class or class and instance. */
  style = style_of_zephyr(z);

  /* special-case login/logout messages and personals */
  if (stricmp(z->opcode, "user_login") == 0)
    style = find_style("green");
  else if (stricmp(z->opcode, "user_logout") == 0)
    style = find_style("red");
  if (z->personal && (stricmp(z->class, "mail") != 0))
    style = S_HILITE;

        /* A few translations on the instance for aesthetic purposes. */
    /*
    if ((!personal && stricmp(instance, "personal") == 0))
        instance = "";
        */

  /* Construct the class/instance field of the displayed message, using
   * abbreviations if we have them. */
  cval = mapped_class(z->class);
  ival = mapped_instance(z->class, z->instance);
  
  if (cval)
    s = bprintf("%s/%s", cval, z->instance);
  else
    s = bprintf("<%s>/%s", z->class, z->instance);
    
  /* Notice if this is a cross-realm zephyr.  If it is, display the full
   * username (with Zephyr realm) instead of user/host. */
  xrealm = 0;
  if (z->sender[strcspn(z->sender, "@")] != 0)
    xrealm = 1;
  
  /* Start building the line, starting with the sender and class/instance
   * field, then appending the body (either folded or raw, depending on
   * what we decided up above. */
  if (is_noc(z))    /* Special case for the NOC */
  {
    front = bprintf("%c%22s %5s %12s ", auth2, z->sender,
                    z->ztime, fields[1]);
    body = z->instance + ":";
    for (i = 2; i < z->numfields; i++)
    {
      body += " " + fields[i];
    }
    do_wrap = 1;
  }
  else if (is_wz_personal(z)) /* Special case for Webzephyr personals */
  {
    front = bprintf("%c%22s %5s %12s ", auth2, z->instance, z->ztime,
                    "wz/...");
  }
  else
  {
    if (xrealm || is_rcmd(z))
      front = bprintf("%c%22s %5s ", auth2, z->sender, z->ztime);
    else
      front = bprintf("%c%8s %13s %5s ", auth2,
                      z->sender, z->fromhost, z->ztime);
    /* Pad out class/instance to at least 12 characters */
    if (strlen(s) <= 12)
      front += bprintf("%12s ", s);
    else
      front += s + " ";
  }
  
  /* Ignore this all as a special case for -c login... */
  if (stricmp(z->class, "login") == 0)
  {
    front = bprintf("%c%8s %13s %5s %12s ", auth2,
                   z->sender, z->fromhost, z->ztime, "");
    if (stricmp(z->opcode, "user_login") == 0)
    {
      body = "Logged in on ";
    }
    else if (stricmp(z->opcode, "user_logout") == 0)
    {
      body = "Logged out from ";
    }
    else
    {
      body = opcode + ": ";
    }
    body += fields[0];
    if (fields[2])
      body += " (" + fields[2] + ")";
    do_wrap = 1;
    sig = "";
    opcode = "";
  }
    
  /* Finish the line by appending the zsig and opcode. */
  if (is_noc(z))
    opcode = "";
  annot = ((*sig) ? "-- " + sig : "") + ((*sig && *(z->opcode)) ? " " : "") +
          ((*(z->opcode)) ? "{" + z->opcode + "}" : "");
  annot += ((*annot) ? " " : "") + bprintf("(%d)", lineno - 1);

  line = make_line(front, body, annot, do_wrap);

  /* Possibly respond to zephyrs if we're away. */
  zaway_respond(z, sig);
  
  /* Log the displayed message if we have a logfile open. */
  if (cur_rmt->logfile)
  {
    fwrite(cur_rmt->logfile, line);
    fflush(cur_rmt->logfile);
  }

  /* Don't print anything if we've punted the message. */
  if (is_zpunted(z))
    return;
    
  /* Ignore certain cases of -c mail personals too. */
  if ((stricmp(z->class, "mail") == 0) && z->personal)
  {
    if (stristr(fields[1], "debian") && !stristr(fields[1], "dmaze@debian"))
    {
      return;
    }
  }

  output(line, style, win);
}

func is_rcmd(z) [sender2, n]
{
  if (stricmp(z->sender, "rcmd.", 5) == 0)
  {
    sender2 = z->sender;
    sender2 += 5;
    n = strlen(sender2);
    if (stricmp(z->fromhost, sender2, n-1) == 0)
    {
      return 1;
    }
  }
  
  return 0;
}

func is_noc(z)
{
  if (is_rcmd(z) &&
      stricmp(z->class, "noc") == 0 &&
      stricmp(z->opcode, "echo") == 0)
    return 1;
  return 0;
}

func is_webzephyr(z)
{
  if (stricmp(z->sender, "daemon.webzephyr") == 0)
    return 1;
  return 0;
}

func is_wz_personal(z)
{
  if (is_webzephyr(z) &&
      stricmp(z->class, "webzephyr") == 0 &&
      z->personal)
    return 1;
  return 0;
}

func make_line(front, body, annot, do_wrap) [line, fbody, s, p, col, spaces]
{
  line = front;
  /* Add the body.  If do_wrap is set, wrap lines (easy).  If not,
   * print one line in body per line in output, subject to wrapping
   * constraints. */
  body = clean_string(body);
  if (do_wrap)
  {
    fbody = fold_newlines(body);
    line += wrap(fbody, cols - 1, 43, strlen(line));
  }
  else
  {
    s = explode(body, "\n") + 1;
    if (*s)
    {
      /* If the front matter is short enough that we don't need
       * an extra line break, put the first line after it
       * (with a possibly shorter line). */
      if (strlen(front) <= 43)
      {
        line += wrap(*s, cols - 1, 43, strlen(front));
        if (s[1])
          line += bprintf("%43s", "");
        s++;
      }
      for (; *s; s++)
      {
        line += wrap(*s, cols - 1, 43, 43);
        if (s[1])
          line += bprintf("%43s", "");
      }
    }
  }
  /* Add the annotation.  Right-justify it if that makes sense. */
  line[strlen(line) - 1] = 0;
  p = strrchr(line, '\n');
  col = (p) ? line + strlen(line) - (p + 1) : strlen(line);
  if (col + 1 + strlen(annot) > cols - 1)
  {
    line = bprintf("%s\n%43s%s", line, "",
                   wrap(annot, cols - 1, 46, 43));
  }
  else
  {
    spaces = cols - 1 - (col + strlen(annot));
    line += cfield("", spaces) + annot + "\n";
  }
  return line;
}

func zephyr_outbound(rmt, line) [zout]
{
  /* Check: if we're in the middle of a multi-line zephyrgram, either
   * send it or append the current line to it. */
  if (zout_pipe)
  {
    zout = zout_pipe;
    if (strcmp(line, ".") != 0)
    {
      /* Just more text; append to the body. */
      zout->body += line + "\n";
      return;
    }
    /* Else fall through to the sending code */
    zout_pipe = NULL;
  }
  else
  {
    zout = outbound_parse(rmt, line);
    if (!zout) return;
    zout->body = softwrap(zout->body, 60);
  }
  
  /* Don't send if we've just started a multiline message. */
  if (zout && !zout_pipe)
  {
    generate_signature(zout);
    zout_send(zout);
  }
}
ZEPHYR->outbound = .zephyr_outbound;

func Nopipe()
{
  zout_pipe = NULL;
}
add_cmd("nopipe", 0, .Nopipe, "/nopipe");

func generate_signature(zout)
{
  /* Use a fixed zsig for <message,6.035*,*>. */
  if (((!zout->class || (stricmp(zout->class, "message") == 0))) &&
      (zout->instance && (stricmp(zout->instance, "6.035", 5) == 0)))
    zout->sig = "Give me the brain...I forgot what lattice is.";
  /* Check for a timely zsig response. */
  if (!zout->sig)
    zout->sig = get_zsig_response(zout->class, zout->instance);
  /* Use a Red Line zsig. */
  /* if (!zout->sig)
     zout->sig = red_line_zsig(); */
  /* Use a random zsig from a file. */
  /* if (!zout->sig)
     zout->sig = random_zsig(); */
  /* Use a fixed zsig. */
  if (!zout->sig)
    zout->sig = "Quantum singularity on the front stairs";
}

/* >recipient message */
zreg1 = regcomp("^(>([^ ]+)) *(.*)$");

/* -instance message */
zreg2 = regcomp("^(-([^ -][^ ]*)) *(.*)$");

/* <class>/instance message, or <class>instance message */
zreg3 = regcomp("^(<([^>]+)>/?([^ ]*)) *(.*)$");

/* class/instance message, or class/ message, or /instance message */
zreg4 = regcomp("^(([^/ ]*)/([^ ]*)) *(.*)$");

/* abbrev message */
zreg5 = regcomp("^(([^/ ]*)) *(.*)$");

/* &recip message, for Webzephyr */
zreg6 = regcomp("^(&([^ ]+)) +(.*)$");

func outbound_parse(rmt, line) [multi, crypt, a, zout, ival,
                                used_default_instance, default]
{
  /* Initial setup */
  multi = 0;
  crypt = 0;
  
  /* Strip leading whitespace. */
  while (*line == ' ')
    line++;

  /* Use default recipient if '>', '.', or '-' followed by space. */
  if (strchr(">-", *line) && line[1] == ' ')
  {
    default = get_default_recip(rmt);
    if (!default)
    {
      printf("No default set.\n");
      return;
    }
    if (*line == '>' && *default != '>')
    {
      printf("Default is not a personal.\n");
      return;
    }
    line = bprintf("%s%s", default, line + 1);
  }

  /* Look for leading modifiers. */
  while(*line)
  {
    if (*line == '|')
      multi = 1;
    else if (*line == '*')
      crypt = 1;
    else
      break;
    line++;
  }

  /* Ignore empty lines. */
  if (!*line)
    return;

  /* Set up the zout structure.  Use zcrypt if appropriate. */
  zout = new_zoutgoing();
  if (crypt)
    zout->sender = .zsend_zcrypt;
  else
    zout->sender = .zsend_zwrite;

  /* Check line against the various command formats.  After a successful
   * match of any command format, a[1] is always the part of the line
   * that specifies the recipient, so we can use it for the default. */
  if (regexec(zreg1, line))
  {
    a = regmatch_array(zreg1);
    zout->recip = a[2];
    zout->body = a[3];
  }
  else if (regexec(zreg2, line))
  {
    a = regmatch_array(zreg2);
    zout->instance = a[2];
    zout->body = a[3];
  }
  else if (regexec(zreg3, line))
  {
    a = regmatch_array(zreg3);
    zout->class = a[2];
    zout->instance = a[3];
    zout->body = a[4];
  }
  else if (regexec(zreg6, line))
  {
    a = regmatch_array(zreg6);
    zout->class = "webzephyr";
    zout->instance = a[2];
    zout->recip = "daemon.webzephyr";
    zout->body = a[3];
  }
  else if (regexec(zreg4, line))
  {
    a = regmatch_array(zreg4);
    zout->class = unmapped_class(a[2]);
    if (!zout->class) zout->class = a[2];
    zout->instance = a[3];
    zout->body = a[4];
  }
  else if (regexec(zreg5, line))
  {
    a = regmatch_array(zreg5);
    /* Could be a class/instance abbreviation. */
    ival = unmapped_instance(a[2]);
    if (ival)
      {
        zout->class = ival[0];
        zout->instance = ival[1];
      }
    if (!zout->class)
      zout->class = unmapped_class(a[2]);
    if (!zout->class)
    {
      printf("Unknown class \"%s\".\n", a[2]);
      return;
    }
    zout->body = a[3];
  }
  else
  {
    printf("Illegal zephyr input.\n");
    return;
  }

  /* Update or use the default instance for the class. */
  used_default_instance = use_default_instance(rmt, zout);
  
  /* Update the default recipient and status bar. */
  if (cur_win)
    {
      default = bprintf("%s%s", crypt ? "*" : "", a[1]);
      while (*default && default[strlen(default) - 1] == ' ')
        default[strlen(default) - 1] = 0;
      if (zout->class && *zout->class && used_default_instance)
          strcat(default, bprintf("/%s", zout->instance));
      set_default_recip(rmt, default);
    }

  /* Save zout in zout_pipe if appropriate.  Do other assorted late-stage
   * processing, too. */
  if (multi)
    {
      if (zout->body && *zout->body)
        zout->body += "\n";
      else
        zout->body = "";
      zout_pipe = zout;
      return zout;
    }

  /* Punt if no body. */
  if (!zout->body || !*zout->body)
    return;

  return zout;
}

/* ----- Output windows for specific classes ----- */

[win] if (!windows_inited) {
    windows_inited = 1;
    win = std_split(active, 3);
    set_class_output("noc", win);
    set_class_output("filsrv", win);
    set_class_output("moira", win);
}

/* ----- Miscellaneous stuff ----- */

/* Key bindings: M-< and M-> to shrink and enlarge the input window,
 * M-backspace to delete a word backwards, ^b and ^f to switch windows. */
func shrink_active() { resize(active, win_bottom(active)); }
func enlarge_active() { resize(active, win_bottom(active) + 2); }
bind(ctrl("^[<"), .shrink_active);
bind(ctrl("^[>"), .enlarge_active);
bind(ctrl("^[^H"), K_BWORD);
bind(ctrl("^b"), .prev_win);
bind(ctrl("^f"), .next_win);

bind(ctrl("^[[A") , .prevline);
bind(ctrl("^[[B") , .nextline);
bind(ctrl("^[OA") , .prevline);
bind(ctrl("^[OB") , .nextline);
bind(ctrl("^[^H"), K_BWORD);
bind(ctrl("^[[C") , K_CRIGHT);
bind(ctrl("^[[D") , K_CLEFT);
bind(ctrl("^[OC") , K_CRIGHT);
bind(ctrl("^[OD") , K_CLEFT);
bind(ctrl("^[[E") , K_CWRIGHT);
bind(ctrl("^[^[[C") , K_CWRIGHT);
bind(ctrl("^[^[OC") , K_CWRIGHT);
bind(ctrl("^[[F") , K_CWLEFT);
bind(ctrl("^[^B") , K_CWLEFT);
bind(ctrl("^[^[[D") , K_CWLEFT);
bind(ctrl("^[^[OD") , K_CWLEFT);
bind(ctrl("^[^[^[") , K_MODE);
bind(ctrl("^[[G") , K_CUP);
bind(ctrl("^[[H") , K_CDOWN);
bind(ctrl("^[^[[A") , K_CUP);
bind(ctrl("^[^[[B") , K_CDOWN);
bind(ctrl("^[^[OA") , K_CUP);
bind(ctrl("^[^[OB") , K_CDOWN);

[fp, line] if (!zephyr_initialized) {
    do_mailcheck =  0;
    zephyr_initialized = 1;
    resize(active, win_bottom(active) + 2);
    Load("~/.settings");
    /* Load_zsigs(defzsigfile); */
    Load_zsigs("~/Private/zsigs-thesis");
    World("Zephyr");
    More("on");
    /* default_pager_state = 1; */
}

/* vim:set syntax=c: */

---