diplodocus.org Git - nmh/blob - uip/vmhsbr.c

   1
   2 /*
   3  * vmhsbr.c -- routines to help vmh along
   4  *
   5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   6  * COPYRIGHT file in the root directory of the nmh distribution for
   7  * complete copyright information.
   8  */
   9
  10 /*
  11  * TODO (for vrsn 2):
  12  *     INI: include width of windows
  13  */
  14
  15 #include <h/mh.h>
  16 #include <h/vmhsbr.h>
  17 #include <h/utils.h>
  18
  19 static char *types[] = {
  20     "OK",
  21     "INI", "ACK", "ERR", "CMD", "QRY", "TTY", "WIN", "DATA", "EOF", "FIN",
  22     "XXX", NULL
  23 };
  24
  25 static  FILE *fp = NULL;
  26
  27 static int PEERrfd = NOTOK;
  28 static int PEERwfd = NOTOK;
  29
  30 /*
  31  * static prototypes
  32  */
  33 static int rclose (struct record *, char *, ...);
  34
  35
  36 int
  37 rcinit (int rfd, int wfd)
  38 {
  39     char *cp, buffer[BUFSIZ];
  40
  41     PEERrfd = rfd;
  42     PEERwfd = wfd;
  43
  44     if ((cp = getenv ("MHVDEBUG")) && *cp) {
  45         snprintf (buffer, sizeof(buffer), "%s.out", invo_name);
  46         if ((fp = fopen (buffer, "w"))) {
  47           fseek (fp, 0L, SEEK_END);
  48           fprintf (fp, "%d: rcinit (%d, %d)\n", (int) getpid(), rfd, wfd);
  49           fflush (fp);
  50         }
  51     }
  52
  53     return OK;
  54 }
  55
  56
  57 int
  58 rcdone (void)
  59 {
  60     if (PEERrfd != NOTOK)
  61         close (PEERrfd);
  62     if (PEERwfd != NOTOK)
  63         close (PEERwfd);
  64
  65     if (fp) {
  66         fclose (fp);
  67         fp = NULL;
  68     }
  69     return OK;
  70 }
  71
  72
  73 int
  74 rc2rc (char code, int len, char *data, struct record *rc)
  75 {
  76     if (rc2peer (code, len, data) == NOTOK)
  77         return NOTOK;
  78
  79     return peer2rc (rc);
  80 }
  81
  82
  83 int
  84 str2rc (char code, char *str, struct record *rc)
  85 {
  86     return rc2rc (code, str ? strlen (str) : 0, str, rc);
  87 }
  88
  89
  90 int
  91 peer2rc (struct record *rc)
  92 {
  93     if (rc->rc_data)
  94         free (rc->rc_data);
  95
  96     if (read (PEERrfd, (char *) rc_head (rc), RHSIZE (rc)) != RHSIZE (rc))
  97         return rclose (rc, "read from peer lost(1)");
  98     if (rc->rc_len) {
  99         rc->rc_data = mh_xmalloc ((unsigned) rc->rc_len + 1);
 100         if (read (PEERrfd, rc->rc_data, rc->rc_len) != rc->rc_len)
 101             return rclose (rc, "read from peer lost(2)");
 102         rc->rc_data[rc->rc_len] = 0;
 103     }
 104     else
 105         rc->rc_data = NULL;
 106
 107     if (fp) {
 108         fseek (fp, 0L, SEEK_END);
 109         fprintf (fp, "%d: <--- %s %d: \"%*.*s\"\n", (int) getpid(),
 110                 types[(unsigned char)rc->rc_type], rc->rc_len,
 111                 rc->rc_len, rc->rc_len, rc->rc_data);
 112         fflush (fp);
 113     }
 114
 115     return rc->rc_type;
 116 }
 117
 118
 119 int
 120 rc2peer (char code, int len, char *data)
 121 {
 122     struct record   rcs;
 123     register struct record *rc = &rcs;
 124
 125     rc->rc_type = code;
 126     rc->rc_len = len;
 127
 128     if (fp) {
 129         fseek (fp, 0L, SEEK_END);
 130         fprintf (fp, "%d: ---> %s %d: \"%*.*s\"\n", (int) getpid(),
 131                 types[(unsigned char)rc->rc_type], rc->rc_len,
 132                 rc->rc_len, rc->rc_len, data);
 133         fflush (fp);
 134     }
 135
 136     if (write (PEERwfd, (char *) rc_head (rc), RHSIZE (rc)) != RHSIZE (rc))
 137         return rclose (rc, "write to peer lost(1)");
 138
 139     if (rc->rc_len)
 140         if (write (PEERwfd, data, rc->rc_len) != rc->rc_len)
 141             return rclose (rc, "write to peer lost(2)");
 142
 143     return OK;
 144 }
 145
 146
 147 int
 148 str2peer (char code, char *str)
 149 {
 150     return rc2peer (code, str ? strlen (str) : 0, str);
 151 }
 152
 153
 154 int
 155 fmt2peer (char code, char *fmt, ...)
 156 {
 157     int     return_value;
 158     va_list ap;
 159
 160     va_start(ap, fmt);
 161     return_value = verr2peer (code, NULL, fmt, ap);
 162     va_end(ap);
 163     return return_value;
 164 }
 165
 166
 167 int
 168 err2peer (char code, char *what, char *fmt, ...)
 169 {
 170     int     return_value;
 171     va_list ap;
 172
 173     va_start(ap, fmt);
 174     return_value = verr2peer(code, what, fmt, ap);
 175     va_end(ap);
 176     return return_value;  /* This routine returned garbage before 1999-07-15. */
 177 }
 178
 179
 180 int
 181 verr2peer (char code, char *what, char *fmt, va_list ap)
 182 {
 183     int eindex = errno;
 184     int len, buflen;
 185     char *bp, *s, buffer[BUFSIZ * 2];
 186
 187     /* Get buffer ready to go */
 188     bp = buffer;
 189     buflen = sizeof(buffer);
 190
 191     vsnprintf (bp, buflen, fmt, ap);
 192     len = strlen (bp);
 193     bp += len;
 194     buflen -= len;
 195
 196     if (what) {
 197         if (*what) {
 198             snprintf (bp, buflen, " %s: ", what);
 199             len = strlen (bp);
 200             bp += len;
 201             buflen -= len;
 202         }
 203         if ((s = strerror (eindex)))
 204             strncpy (bp, s, buflen);
 205         else
 206             snprintf (bp, buflen, "unknown error %d", eindex);
 207         len = strlen (bp);
 208         bp += len;
 209         buflen -= len;
 210     }
 211
 212     return rc2peer (code, bp - buffer, buffer);
 213 }
 214
 215
 216 static int
 217 rclose (struct record *rc, char *fmt, ...)
 218 {
 219     va_list ap;
 220     static char buffer[BUFSIZ * 2];
 221
 222     va_start(ap, fmt);
 223     vsnprintf (buffer, sizeof(buffer), fmt, ap);
 224     va_end(ap);
 225
 226     rc->rc_len = strlen (rc->rc_data = getcpy (buffer));
 227     return (rc->rc_type = RC_XXX);
 228 }