Return to vmhsbr.c CVS log

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

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

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