![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tftpsubs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / tftp|
Return to tftpsubs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / tftp |
1.1 root 1: /*
2: * Copyright (c) 1985 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)tftpsubs.c 1.2 (Berkeley) 2/7/86";
9: #endif not lint
10:
11: /* Simple minded read-ahead/write-behind subroutines for tftp user and
12: server. Written originally with multiple buffers in mind, but current
13: implementation has two buffer logic wired in.
14:
15: Todo: add some sort of final error check so when the write-buffer
16: is finally flushed, the caller can detect if the disk filled up
17: (or had an i/o error) and return a nak to the other side.
18:
19: Jim Guyton 10/85
20: */
21:
22: #include <sys/types.h>
23: #include <sys/socket.h>
24: #include <sys/ioctl.h>
25: #include <netinet/in.h>
26: #include <arpa/tftp.h>
27: #include <stdio.h>
28:
29: #define PKTSIZE SEGSIZE+4 /* should be moved to tftp.h */
30:
31: struct bf {
32: int counter; /* size of data in buffer, or flag */
33: char buf[PKTSIZE]; /* room for data packet */
34: } bfs[2];
35:
36: /* Values for bf.counter */
37: #define BF_ALLOC -3 /* alloc'd but not yet filled */
38: #define BF_FREE -2 /* free */
39: /* [-1 .. SEGSIZE] = size of data in the data buffer */
40:
41: static int nextone; /* index of next buffer to use */
42: static int current; /* index of buffer in use */
43:
44: /* control flags for crlf conversions */
45: int newline = 0; /* fillbuf: in middle of newline expansion */
46: int prevchar = -1; /* putbuf: previous char (cr check) */
47:
48: struct tftphdr *rw_init();
49:
50: struct tftphdr *w_init() { return rw_init(0); } /* write-behind */
51: struct tftphdr *r_init() { return rw_init(1); } /* read-ahead */
52:
53: struct tftphdr *
54: rw_init(x) /* init for either read-ahead or write-behind */
55: int x; /* zero for write-behind, one for read-head */
56: {
57: newline = 0; /* init crlf flag */
58: prevchar = -1;
59: bfs[0].counter = BF_ALLOC; /* pass out the first buffer */
60: current = 0;
61: bfs[1].counter = BF_FREE;
62: nextone = x; /* ahead or behind? */
63: return (struct tftphdr *)bfs[0].buf;
64: }
65:
66:
67: /* Have emptied current buffer by sending to net and getting ack.
68: Free it and return next buffer filled with data.
69: */
70: readit(file, dpp, convert)
71: FILE *file; /* file opened for read */
72: struct tftphdr **dpp;
73: int convert; /* if true, convert to ascii */
74: {
75: struct bf *b;
76:
77: bfs[current].counter = BF_FREE; /* free old one */
78: current = !current; /* "incr" current */
79:
80: b = &bfs[current]; /* look at new buffer */
81: if (b->counter == BF_FREE) /* if it's empty */
82: read_ahead(file, convert); /* fill it */
83: /* assert(b->counter != BF_FREE); /* check */
84: *dpp = (struct tftphdr *)b->buf; /* set caller's ptr */
85: return b->counter;
86: }
87:
88: /*
89: * fill the input buffer, doing ascii conversions if requested
90: * conversions are lf -> cr,lf and cr -> cr, nul
91: */
92: read_ahead(file, convert)
93: FILE *file; /* file opened for read */
94: int convert; /* if true, convert to ascii */
95: {
96: register int i;
97: register char *p;
98: register int c;
99: struct bf *b;
100: struct tftphdr *dp;
101:
102: b = &bfs[nextone]; /* look at "next" buffer */
103: if (b->counter != BF_FREE) /* nop if not free */
104: return;
105: nextone = !nextone; /* "incr" next buffer ptr */
106:
107: dp = (struct tftphdr *)b->buf;
108:
109: if (convert == 0) {
110: b->counter = read(fileno(file), dp->th_data, SEGSIZE);
111: return;
112: }
113:
114: p = dp->th_data;
115: for (i = 0 ; i < SEGSIZE; i++) {
116: if (newline) {
117: if (prevchar == '\n')
118: c = '\n'; /* lf to cr,lf */
119: else c = '\0'; /* cr to cr,nul */
120: newline = 0;
121: }
122: else {
123: c = getc(file);
124: if (c == EOF) break;
125: if (c == '\n' || c == '\r') {
126: prevchar = c;
127: c = '\r';
128: newline = 1;
129: }
130: }
131: *p++ = c;
132: }
133: b->counter = (int)(p - dp->th_data);
134: }
135:
136: /* Update count associated with the buffer, get new buffer
137: from the queue. Calls write_behind only if next buffer not
138: available.
139: */
140: writeit(file, dpp, ct, convert)
141: FILE *file;
142: struct tftphdr **dpp;
143: int convert;
144: {
145: bfs[current].counter = ct; /* set size of data to write */
146: current = !current; /* switch to other buffer */
147: if (bfs[current].counter != BF_FREE) /* if not free */
148: write_behind(file, convert); /* flush it */
149: bfs[current].counter = BF_ALLOC; /* mark as alloc'd */
150: *dpp = (struct tftphdr *)bfs[current].buf;
151: return ct; /* this is a lie of course */
152: }
153:
154: /*
155: * Output a buffer to a file, converting from netascii if requested.
156: * CR,NUL -> CR and CR,LF => LF.
157: * Note spec is undefined if we get CR as last byte of file or a
158: * CR followed by anything else. In this case we leave it alone.
159: */
160: write_behind(file, convert)
161: FILE *file;
162: int convert;
163: {
164: char *buf;
165: int count;
166: register int ct;
167: register char *p;
168: register int c; /* current character */
169: struct bf *b;
170: struct tftphdr *dp;
171:
172: b = &bfs[nextone];
173: if (b->counter < -1) /* anything to flush? */
174: return 0; /* just nop if nothing to do */
175:
176: count = b->counter; /* remember byte count */
177: b->counter = BF_FREE; /* reset flag */
178: dp = (struct tftphdr *)b->buf;
179: nextone = !nextone; /* incr for next time */
180: buf = dp->th_data;
181:
182: if (count <= 0) return -1; /* nak logic? */
183:
184: if (convert == 0)
185: return write(fileno(file), buf, count);
186:
187: p = buf;
188: ct = count;
189: while (ct--) { /* loop over the buffer */
190: c = *p++; /* pick up a character */
191: if (prevchar == '\r') { /* if prev char was cr */
192: if (c == '\n') /* if have cr,lf then just */
193: fseek(file, -1, 1); /* smash lf on top of the cr */
194: else
195: if (c == '\0') /* if have cr,nul then */
196: goto skipit; /* just skip over the putc */
197: /* else just fall through and allow it */
198: }
199: putc(c, file);
200: skipit:
201: prevchar = c;
202: }
203: return count;
204: }
205:
206:
207: /* When an error has occurred, it is possible that the two sides
208: * are out of synch. Ie: that what I think is the other side's
209: * response to packet N is really their response to packet N-1.
210: *
211: * So, to try to prevent that, we flush all the input queued up
212: * for us on the network connection on our host.
213: *
214: * We return the number of packets we flushed (mostly for reporting
215: * when trace is active).
216: */
217:
218: int
219: synchnet(f)
220: int f; /* socket to flush */
221: {
222: int i, j = 0;
223: char rbuf[PKTSIZE];
224: struct sockaddr_in from;
225: int fromlen;
226:
227: while (1) {
228: (void) ioctl(f, FIONREAD, &i);
229: if (i) {
230: j++;
231: fromlen = sizeof from;
232: (void) recvfrom(f, rbuf, sizeof (rbuf), 0,
233: (caddr_t)&from, &fromlen);
234: } else {
235: return(j);
236: }
237: }
238: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.