![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmhsbr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip|
Return to vmhsbr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip |
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.