Return to vmhsbr.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip

Annotation of 43BSD/contrib/mh/uip/vmhsbr.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.