doc_routines.c

/*
 * doc_routines.c - General message system code.
 */
#include <stdio_ext.h>

#include "defs.h"
#include "ext.h"

/**********************************************************************
 * countmsgs
 **********************************************************************/
int countmsgs(void) {
  uint8_t count = 0;
  uint8_t new = 0;
  uint8_t i;

  for (i = 0; i < MSGSPERRM; i++) {
    /* this counts the messages that still exist in main file */
    if (room->num[i] > 0L) {
      count++;
      if (room->num[i] > ouruser->lastseen[curr] &&
          (curr != MAIL_RM_NBR ||
           ouruser->mr[MAILMSGS - MSGSPERRM + i].pos > 0)) {
        new ++;
      }
    }
  }

  if (new > 0) {
    colorize(BOLD_YELLOW"[%s]  "BOLD_CYAN"%d "BOLD_GREEN"messages,"BOLD_CYAN" %d "BOLD_GREEN"new\n", msg->room[curr].name,
             count, new);
  }

  /* hack to suppress this message when our room contains no posts */
  if (msg->room[curr].descupdate > msg->room[curr].num[MSGSPERRM - 1]) {
    msg->room[curr].descupdate = msg->room[curr].num[MSGSPERRM - 1];
  }

  if (msg->room[curr].descupdate > ouruser->lastseen[curr]) {
    my_printf(
        "\n*** Forum description has been updated, hit 'i' to view it. ***\n");
  }
  return (new);
}

/**********************************************************************
 * debug report
 **********************************************************************/
void debug(void) {}

/**********************************************************************
* knrooms
* List all known rooms with unread messages, list all known rooms
* with unread messages, and list all forgotten rooms.
-----------------------------------------------------------------------*/
void knrooms(struct user *tmpuser) {
  int16_t i;
  int8_t limit = 24;
  int16_t linenbr;
  int16_t newlength;
  int16_t oldlength = 1;
  char tmpstr[80];
  uint8_t rm_nbr;

  if (checkmail(tmpuser, NOISY) <= 0)
    my_printf("No mail for %s\n", tmpuser->name);

  linenbr = 5;
  colorize("\n   "BOLD_CYAN"Forums with unread messages:\n"BOLD_YELLOW);

  for (rm_nbr = 0; rm_nbr < MAXROOMS; ++rm_nbr) {
    if (rm_nbr != MAIL_RM_NBR) {
      if ((msg->room[rm_nbr].flags & QR_INUSE) &&
          (msg->room[rm_nbr].highest > tmpuser->lastseen[rm_nbr]) &&
          ((rm_nbr != YELLS_RM_NBR) || tmpuser->f_admin) &&
          (msg->room[rm_nbr].gen != tmpuser->forget[rm_nbr]) &&
          (tmpuser->generation[rm_nbr] != RODSERLING) &&
          (tmpuser->forget[rm_nbr] != NEWUSERFORGET) &&
          (((msg->room[rm_nbr].flags & QR_PRIVATE) == NO) || tmpuser->f_prog ||
           (msg->room[rm_nbr].gen == tmpuser->generation[rm_nbr]))) {
        checked_snprintf(tmpstr, sizeof(tmpstr), " %d\056%s>  ", rm_nbr,
                         msg->room[rm_nbr].name);
        while (strlen(tmpstr) % limit) {
          strcat(tmpstr, " ");
        }

        newlength = oldlength + strlen(tmpstr);

        if (newlength > MARGIN) {
          my_putchar('\n');
          if (++linenbr >= rows - 1 && line_more(&linenbr, -1)) {
            return;
          }
          oldlength = 1;
        }

        my_printf("%s", tmpstr);
        oldlength = oldlength + strlen(tmpstr);

      } /* end of monster if */
    }
  } /* end for loop */

  if (oldlength != 1) { /* finish up last line of this list */
    my_putchar('\n');
  }

  /* Now, want to leave the bottom of the screen blank */
  for (i = linenbr; i < rows - 1; ++i) {
    my_putchar('\n');
    if (++linenbr >= rows - 1 && line_more(&linenbr, -1)) {
      return;
    }
  }
  linenbr = 3;
  oldlength = 1;
  colorize("\n  "BOLD_CYAN" No unseen messages in:\n"BOLD_GREEN);

  /* now list the rooms that are all read */
  for (rm_nbr = 0; rm_nbr < MAXROOMS; ++rm_nbr) {
    if (rm_nbr != MAIL_RM_NBR) {
      if ((msg->room[rm_nbr].flags & QR_INUSE) &&
          (msg->room[rm_nbr].highest <= tmpuser->lastseen[rm_nbr]) &&
          ((rm_nbr != YELLS_RM_NBR) || tmpuser->f_admin) &&
          (msg->room[rm_nbr].gen != tmpuser->forget[rm_nbr]) &&
          (tmpuser->generation[rm_nbr] != RODSERLING) &&
          (tmpuser->forget[rm_nbr] != NEWUSERFORGET) &&
          (((msg->room[rm_nbr].flags & QR_PRIVATE) == NO) || tmpuser->f_prog ||
           (msg->room[rm_nbr].gen == tmpuser->generation[rm_nbr]))) {
        checked_snprintf(tmpstr, sizeof(tmpstr), " %d\056%s>  ", rm_nbr,
                         msg->room[rm_nbr].name);
        while (strlen(tmpstr) % limit) {
          strcat(tmpstr, " ");
        }
        newlength = oldlength + strlen(tmpstr);

        if (newlength > MARGIN) {
          my_putchar('\n');
          if (++linenbr >= rows - 1 && line_more(&linenbr, -1)) {
            return;
          }
          oldlength = 1;
        }

        my_printf("%s", tmpstr);
        oldlength = oldlength + strlen(tmpstr);
      } /* end of monster if */
    }
  } /* end of for */

  if (oldlength != 1) {
    my_putchar('\n');
  }

  /* Now, want to leave the bottom of the screen blank */
  for (i = linenbr; i < rows - 1; ++i) {
    my_putchar('\n');
    if (++linenbr >= rows - 1 && line_more(&linenbr, -1)) {
      return;
    }
  }
  linenbr = 2;
  colorize("\n  "BOLD_CYAN" Forgotten public forums:\n"BOLD_GREEN);

  /* Zapped room list */
  for (rm_nbr = 0; rm_nbr < MAXROOMS; ++rm_nbr) {
    if ((msg->room[rm_nbr].flags & QR_INUSE) &&
        ((msg->room[rm_nbr].gen == tmpuser->forget[rm_nbr]) /* zapped */
         || (tmpuser->forget[rm_nbr] == NEWUSERFORGET) ||
         (tmpuser->generation[rm_nbr] == RODSERLING)) &&
        ((rm_nbr != YELLS_RM_NBR) || tmpuser->f_admin) &&
        (((msg->room[rm_nbr].flags & QR_PRIVATE) == NO) || tmpuser->f_prog ||
         (msg->room[rm_nbr].gen == tmpuser->generation[rm_nbr]))) {
      checked_snprintf(tmpstr, sizeof(tmpstr), " %d\056%s>  ", rm_nbr,
                       msg->room[rm_nbr].name);
      while (strlen(tmpstr) % limit) strcat(tmpstr, " ");
      newlength = oldlength + strlen(tmpstr);

      if (newlength > MARGIN) {
        my_putchar('\n');
        if (++linenbr >= rows - 1 && line_more(&linenbr, -1)) return;
        oldlength = 1;
      }

      my_printf("%s", tmpstr);
      oldlength = oldlength + strlen(tmpstr);
    } /* end of monster if */
  }   /* end of for */

  if (oldlength != 1) {
    my_putchar('\n');
  }
} /* end function */

/************************************************************
 * line_more
 * Increments the linenumber unless noprompt is wanted.  At a
 * screenful, it prompts for space or Q,
 * returns 0 for okay keep going, -1 for quit reading.
 ************************************************************/
int line_more(int16_t *nbr, int16_t percent) {
  int chr;
  int savenox = mybtmp->nox;

  *nbr = 0;
  if (!rows) {
    return 0;
  }

  if (client) {
    my_putchar(IAC);
    my_putchar(MORE_M);
  }
  for (;;) {
    colorize(BOLD_YELLOW"--MORE--");
    if (percent > 99) {
      percent = 99;
    }
    if (percent > -1) {
      my_printf("(%d%%) ", percent);
    } else {
      my_putchar(' ');
    }

    if (!savenox) {
      checkx(0);
    }

    if (client) {
      for (;;) {
        chr = get_single_quiet("0123456789NpPqQSvxY/? \021\n");
        if (chr != 17 || !client || numposts <= 0) break;
      }
    } else {
      chr = get_single_quiet("0123456789NpPqQSvxY/? \n");
    }

    if (strchr("0123456789QxpP?/", chr)) {
      if (!ouruser) {
        continue;
      } else if (guest) {
        my_printf("\n\nThe Guest user cannot do that.\n\n");
        continue;
      } else {
        mybtmp->nox = 1;
      }
    }

    switch (chr) {
      case SP:
      case 'Y':
        colorize("\r"BOLD_GREEN"              \r");
        if (client) {
          my_putchar(IAC);
          my_putchar(MORE_M);
        }
        return (0);

      case LF:
        *nbr = rows - 1;
        colorize("\r"BOLD_GREEN"              \r");
        if (client) {
          my_putchar(IAC);
          my_putchar(MORE_M);
        }
        return (0);

      case 17: /* ctrl-Q */
      case 'N':
      case 'q':
      case 'S':
        colorize("\r"BOLD_GREEN"              \r");
        if (client) {
          my_putchar(IAC);
          my_putchar(MORE_M);
        }
        return (-1);

      case 'p':
      case 'P':
        profile_user(chr == 'P');
        my_putchar('\n');
        break;

      case 'Q':
        get_syself_help(chr);
        my_putchar('\n');
        break;

      case 'v':
        express(-1);
        my_putchar('\n');
        break;

      case 'x':
        express(10);
        my_putchar('\n');
        break;

      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        express(chr - '0');
        my_putchar('\n');
        break;

      case '?':
      case '/':
        my_printf("\n\nThe help for this section is not yet available.\n");
        my_putchar('\n');
        break;
    }
  }
}

void flush_input(int sec) {
  int i;
  int flush = -1;

  if (sec) {
    bbs_sleep(sec);
  }
  if (tty) {
    // while (INPUT_LEFT())
    //   (void)getchar();
    __fpurge(stdin);
    tcflush(0, TCIFLUSH);
  } else {
    while ((i = telrcv(&flush)) >= 0) {
      if (!block && i != 17) {
        byte++;
      }
    }
    if (errno != EWOULDBLOCK) {
      my_exit(0);
    }
  }
}

/**********************************************************************
 * fr_delete (rmnbr, msgnum, fullrm)
 *  Reads the contents of the fullrm structure for a given room #
 *  Passes back a new fullrm structure to keep things in sync.
 *  Returns: 0 - message deleted ok.
 *           1 - couldn't find message to delete
 *
 *  int rmnbr - the room #
 *  long delnum - the msg # to delete
 *  struct fullrm *fullrm - the new updated fullrm (out)
 *********************************************************************/
void fr_delete(int32_t delnum, int32_t pos) {
  int16_t i;
  struct mheader *mh;

  if (curr == MAIL_RM_NBR) {
    /*
     * We only delete mail from our personal mailbox....just like regular US
     * Mail, you can't stop something from arriving once its sent.
     *
     * We have to delete mail from both our fullroom array AND our user file,
     * because our user file is constantly updated as mail is sent to us,
     * while our fullroom array is static for as long as we are in the Mail>
     * room (because we don't reread it when deleting mail -- no reason to do
     * so!)  User file integrity is preserved because the BBS is always locked
     * during mail operations.  After munging the user file, we just fall
     * through into some of the regular delete code, minus the file handling.
     */
    for (i = MAILMSGS - 1; ouruser->mr[i].num != delnum && i >= 0; --i)
      ;
    for (; i > 0; i--) {
      ouruser->mr[i].num = ouruser->mr[i - 1].num;
      ouruser->mr[i].pos = ouruser->mr[i - 1].pos;
    }
    if (!i) {
      ouruser->mr[0].num = ouruser->mr[0].pos = 0L;
    }
  } else {
    /* set up the parameters to copy a deleted message */
    if (pos >= 0) {
      mh = (struct mheader *)(msgstart + pos);

      if (mh->magic != M_MAGIC) {
        my_printf("No magic when deleting");
        return;
      }
      // Have to increase the highest value in order for it to be shown as new.
      mh->old_msgid =  mh->msgid;
      mh->msgid = ++msg->highest;
      mh->deleted = true;
      mh->deleted_by_num = ouruser->usernum;
      mh->del_room_num = curr;
      mh->dtime = time(0);
      mh->mtype = MES_NORMAL;

      strcpy(mh->deleted_by_name, ouruser->name);

      strcpy(mh->del_room_name, msg->room[curr].name);
      fr_post(DELMSG_RM_NBR, ++msg->room[DELMSG_RM_NBR].posted, pos, mh->msgid,
              NULL);
    }

    i = curr == MAIL_RM_NBR ? MAILMSGS - 1 : MSGSPERRM - 1;
    for (i = MSGSPERRM - 1; msg->room[curr].num[i] != delnum && i >= 0; --i)
      ;
    for (; i > 0; i--) {
      msg->room[curr].num[i] = msg->room[curr].num[i - 1];
      msg->room[curr].chron[i] = msg->room[curr].chron[i - 1];
      msg->room[curr].pos[i] = msg->room[curr].pos[i - 1];
    }
    if (!i) {
      msg->room[curr].num[0] = msg->room[curr].pos[0] = 0L;
    }
  }

  for (i = MSGSPERRM - 1; room->num[i] != delnum && i >= 0; --i)
    ;
  for (; i > 0; i--) {
    room->num[i] = room->num[i - 1];
    room->chron[i] = room->chron[i - 1];
    room->pos[i] = room->pos[i - 1];
  }
  if (!i) {
    room->num[0] = room->pos[0] = 0L;
  }
}

/********************************************************************
 * fr_post (room, msgnum, pos, tmpuser)
 *  Reads the contents of the fullrm structure for a given room #
 *
 *  int rm;
 *  long num;                   The eternal number of the message    *
 *  long msgnum;                The message # for the room           *
 *  long pos;                   Position in the msgmain file         *
 *********************************************************************/
void fr_post(uint8_t rm, int32_t msgnum, int32_t pos, int32_t mmhi,
             struct user *tmpuser) {
  uint8_t i;

  if (rm == MAIL_RM_NBR)
    if (tmpuser) {
      for (i = 0; i < MAILMSGS - 1; i++) {
        ouruser->mr[i].num = ouruser->mr[i + 1].num;
        ouruser->mr[i].pos = ouruser->mr[i + 1].pos;
        tmpuser->mr[i].num = tmpuser->mr[i + 1].num;
        tmpuser->mr[i].pos = tmpuser->mr[i + 1].pos;
      }
      ouruser->mr[MAILMSGS - 1].num = tmpuser->mr[MAILMSGS - 1].num = mmhi;
      /*
       * your own posts are marked with a negative number so checkmail won't
       * report what you wrote as being new
       */
      ouruser->mr[MAILMSGS - 1].pos = -pos;
      tmpuser->mr[MAILMSGS - 1].pos = pos;
    } else {
      for (i = 0; i < MAILMSGS - 1; i++) {
        ouruser->mr[i].num = ouruser->mr[i + 1].num;
        ouruser->mr[i].pos = ouruser->mr[i + 1].pos;
      }
      ouruser->mr[MAILMSGS - 1].num = mmhi;
      /*
       * your own posts are marked with a negative number so checkmail won't
       * report what you wrote as being new
       */
      ouruser->mr[MAILMSGS - 1].pos = -pos;
    }
  else {
    for (i = 0; i < MSGSPERRM - 1; i++) {
      msg->room[rm].num[i] = msg->room[rm].num[i + 1];
      msg->room[rm].chron[i] = msg->room[rm].chron[i + 1];
      msg->room[rm].pos[i] = msg->room[rm].pos[i + 1];
    }
    msg->room[rm].num[MSGSPERRM - 1] = msg->room[rm].highest = mmhi;
    msg->room[rm].chron[MSGSPERRM - 1] = msgnum;
    msg->room[rm].pos[MSGSPERRM - 1] = pos;
  }

  if (rm == curr) {
    for (i = 0; i < MSGSPERRM - 1; i++) {
      room->num[i] = room->num[i + 1];
      room->chron[i] = room->chron[i + 1];
      room->pos[i] = room->pos[i + 1];
    }
    room->num[MSGSPERRM - 1] = room->highest = mmhi;
    room->chron[MSGSPERRM - 1] = rm == MAIL_RM_NBR ? mmhi : msgnum;
    room->pos[MSGSPERRM - 1] = pos;
  }
}

/**********************************************************************
 * read room description
 **********************************************************************/
void readdesc(void) {
  bool dummy;
  char name[MAXALIAS + 1];
  unsigned char *p;
  size_t size;

  char *file = my_sprintf(NULL, "%sroom%d", DESCDIR, curr);
  size = 0;
  if (!(p = mmap_file(file, &size)) || size == 0) {
    colorize(BOLD_RED"No Forum Info is available\n");
    if (p) {
      munmap((void *)p, size);
    }
    free(file);
    return;
  }
  free(file);

  readmessage(p, &dummy, name, FALSE, 0);

  munmap((void *)p, size);
}

/**************************************************************************
 * storeug
 * Store <u>ngoto information in prev_rm
 * do an <U>ngoto prev_rm and save the universal message number of the message
 * last seen in *uglastmsg.
 ***************************************************************************/
void storeug(int32_t *uglastmsg, int32_t *ugtemp) {
  *uglastmsg = *ugtemp;
  *ugtemp = ouruser->lastseen[curr];
}

/**********************************************************************
 * ungoto
 **********************************************************************/
void ungoto(int prev, int32_t *uglastmsg, int32_t *ugtemp) {
  if (prev == TWILIGHTZONE) return;

  ouruser->lastseen[curr] = *ugtemp;
  curr = prev;
  ouruser->lastseen[curr] = *uglastmsg;
  *ugtemp = *uglastmsg;

  openroom();
}

/********************************************************************
 * updatels
 * update last seen: make all messages old in current room.
 * Notate ouruser record accordingly.
 **********************************************************************/
void updatels(short *prev) {
  *prev = curr;
  ouruser->lastseen[curr] = room->num[MSGSPERRM - 1];
}

/**********************************************************************
 * yesno
 * Waits for a keypress and outputs Yes or No,
 * returns Y == YES , N == NO
 **********************************************************************/
bool yesno(int16_t def) {
  char i;

  if (def < 0) {
    i = get_single_quiet("YN");
  } else {
    my_printf("(%s) ", def ? "Yes" : "No");
    i = get_single_quiet(" \nYN");
    if (i == '\n' || i == ' ') {
      i = def ? 'Y' : 'N';
    }
  }
  if (i == 'Y') {
    my_printf("Yes\n");
    return (YES);
  }
  my_printf("No\n");
  return (NO);
}

void do_fortune(void) {
  char *cmd = FORTUNE;
  char *p;
  char buf[BUFSIZ];
  FILE *fp;

  if ((fp = popen(cmd, "r")) == NULL) {
    return;
  }

  while (fgets(buf, BUFSIZ, fp) != NULL) {
    if ((p = strrchr(buf, '\n')) != NULL) {
      *p = 0;
    }
    my_printf("%s\n", buf);
  }
  pclose(fp);
}

/*
char *months[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
*/

char *days[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

char *formtime(int how, time_t timetoform) {
  static char tstring[80];
  struct tm *tm;
  int hr; /* AM/PM conversion */
  const char *stamp = "";

  tm = localtime(&timetoform);

  if (ouruser->f_ampm) {
    hr = !tm->tm_hour ? 12 : tm->tm_hour > 12 ? tm->tm_hour - 12 : tm->tm_hour;
    stamp = tm->tm_hour >= 12 ? " PM" : " AM";
  } else {
    hr = tm->tm_hour;
  }

  switch (how) {
    case 1:
      /* Mon Jan 1, 2000  1:23 PM */
      checked_snprintf(tstring, sizeof(tstring), "%s %s %d, %d %d:%02d%s",
                       days[tm->tm_wday], months[tm->tm_mon], tm->tm_mday,
                       1900 + tm->tm_year, hr, tm->tm_min, stamp);
      break;

    case 2:
      /* Jan 1, 2000  1:23 PM */
      checked_snprintf(tstring, sizeof(tstring), "%s %d, %d %d:%02d%s",
                       months[tm->tm_mon], tm->tm_mday, 1900 + tm->tm_year, hr,
                       tm->tm_min, stamp);
      break;

    case 3:
      /* 1/1/00  1:23 PM */
      checked_snprintf(tstring, sizeof(tstring), "%d/%d/%02d %d:%02d%s",
                       tm->tm_mon + 1, tm->tm_mday, tm->tm_year % 100, hr,
                       tm->tm_min, stamp);
      break;

    case 4:
      /* 1:23 PM */
      checked_snprintf(tstring, sizeof(tstring), "%d:%02d%s", hr, tm->tm_min,
                       stamp);
      break;

    case 5:
      /* Jan 1, 2000 */
      checked_snprintf(tstring, sizeof(tstring), "%s %d, %d",
                       months[tm->tm_mon], tm->tm_mday, 1900 + tm->tm_year);
      break;

    case 6: /* X message */
      checked_snprintf(tstring, sizeof(tstring), "%d:%02d%s on %s %d, %d", hr,
                       tm->tm_min, stamp, months[tm->tm_mon], tm->tm_mday,
                       1900 + tm->tm_year);
      break;

    default:
      my_printf("Unknown error in formtime\n");
      break;
  }
  return (tstring);
}

#include <utmpx.h>
char *gethost(void) {
  struct utmpx *ut;
  char *tp;
  static char hname[MAXHOSTNAMELEN + 1];

  if (*hname) {
    return (hname);
  }

  /* Take our argument's word over anyone else's */
  if (ARGV[1]) {
    checked_snprintf(hname, sizeof(hname), "%s", ARGV[1]);
  } else {
    if ((tp = ttyname(0)) == NULL) {
      return NULL;
    }

    /* So outside buttheads don't 'talk bbs' */
    chmod(tp, 0600);
    tp = strchr(tp, '/') + 5;
    checked_snprintf(hname, sizeof(hname), "%s", tp);

    /* Not all systems have this, so you may have to roll your own... */

    setutxent();
    while ((ut = getutxent()) != NULL) {
      if (!strncmp(hname, ut->ut_line, sizeof(ut->ut_line)) &&
          ut->ut_pid == pid && *ut->ut_host) {
        checked_snprintf(hname, sizeof(hname), "%s", ut->ut_host);
        break;
      }
    }
    endutxent();
  }

  return (hname);
}

/*
 * a case insensitive strstr().
 */
const char *mystrstr(const char *haystack, const char *needle) {
  const size_t nlen = strlen(needle);

  const char *s;
  for (s = haystack; *s; s++) {
    if (/* *s == *needle && */ !strncasecmp(s, needle, nlen)) {
      break;
    }
  }

  if (!*s) {
    return (char *)NULL;
  } else {
    return s;
  }
}

char *mystrstr_nonconst(char *haystack, const char *needle) {
  return (char *)mystrstr(haystack, needle);
}

void bcdplus1encode(int32_t number) {
  char digit;
  int32_t remainder;

  if (number < 0) {
    return;
  }

  remainder = number / 10;
  digit = number - remainder * 10 + 1;

  if (remainder > 0) {
    bcdplus1encode(remainder);
  }

  my_putc(digit, stdout);
}