* Copyright (c) 1983 Regents of the University of California.
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
static char sccsid
[] = "@(#)tftpsubs.c 5.4 (Berkeley) 6/29/88";
/* Simple minded read-ahead/write-behind subroutines for tftp user and
server. Written originally with multiple buffers in mind, but current
implementation has two buffer logic wired in.
Todo: add some sort of final error check so when the write-buffer
is finally flushed, the caller can detect if the disk filled up
(or had an i/o error) and return a nak to the other side.
#define PKTSIZE SEGSIZE+4 /* should be moved to tftp.h */
int counter
; /* size of data in buffer, or flag */
char buf
[PKTSIZE
]; /* room for data packet */
/* Values for bf.counter */
#define BF_ALLOC -3 /* alloc'd but not yet filled */
#define BF_FREE -2 /* free */
/* [-1 .. SEGSIZE] = size of data in the data buffer */
static int nextone
; /* index of next buffer to use */
static int current
; /* index of buffer in use */
/* control flags for crlf conversions */
int newline
= 0; /* fillbuf: in middle of newline expansion */
int prevchar
= -1; /* putbuf: previous char (cr check) */
struct tftphdr
*rw_init();
struct tftphdr
*w_init() { return rw_init(0); } /* write-behind */
struct tftphdr
*r_init() { return rw_init(1); } /* read-ahead */
rw_init(x
) /* init for either read-ahead or write-behind */
int x
; /* zero for write-behind, one for read-head */
newline
= 0; /* init crlf flag */
bfs
[0].counter
= BF_ALLOC
; /* pass out the first buffer */
bfs
[1].counter
= BF_FREE
;
nextone
= x
; /* ahead or behind? */
return (struct tftphdr
*)bfs
[0].buf
;
/* Have emptied current buffer by sending to net and getting ack.
Free it and return next buffer filled with data.
readit(file
, dpp
, convert
)
FILE *file
; /* file opened for read */
int convert
; /* if true, convert to ascii */
bfs
[current
].counter
= BF_FREE
; /* free old one */
current
= !current
; /* "incr" current */
b
= &bfs
[current
]; /* look at new buffer */
if (b
->counter
== BF_FREE
) /* if it's empty */
read_ahead(file
, convert
); /* fill it */
/* assert(b->counter != BF_FREE); /* check */
*dpp
= (struct tftphdr
*)b
->buf
; /* set caller's ptr */
* fill the input buffer, doing ascii conversions if requested
* conversions are lf -> cr,lf and cr -> cr, nul
read_ahead(file
, convert
)
FILE *file
; /* file opened for read */
int convert
; /* if true, convert to ascii */
b
= &bfs
[nextone
]; /* look at "next" buffer */
if (b
->counter
!= BF_FREE
) /* nop if not free */
nextone
= !nextone
; /* "incr" next buffer ptr */
dp
= (struct tftphdr
*)b
->buf
;
b
->counter
= read(fileno(file
), dp
->th_data
, SEGSIZE
);
for (i
= 0 ; i
< SEGSIZE
; i
++) {
c
= '\n'; /* lf to cr,lf */
else c
= '\0'; /* cr to cr,nul */
if (c
== '\n' || c
== '\r') {
b
->counter
= (int)(p
- dp
->th_data
);
/* Update count associated with the buffer, get new buffer
from the queue. Calls write_behind only if next buffer not
writeit(file
, dpp
, ct
, convert
)
bfs
[current
].counter
= ct
; /* set size of data to write */
current
= !current
; /* switch to other buffer */
if (bfs
[current
].counter
!= BF_FREE
) /* if not free */
write_behind(file
, convert
); /* flush it */
bfs
[current
].counter
= BF_ALLOC
; /* mark as alloc'd */
*dpp
= (struct tftphdr
*)bfs
[current
].buf
;
return ct
; /* this is a lie of course */
* Output a buffer to a file, converting from netascii if requested.
* CR,NUL -> CR and CR,LF => LF.
* Note spec is undefined if we get CR as last byte of file or a
* CR followed by anything else. In this case we leave it alone.
write_behind(file
, convert
)
register int c
; /* current character */
if (b
->counter
< -1) /* anything to flush? */
return 0; /* just nop if nothing to do */
count
= b
->counter
; /* remember byte count */
b
->counter
= BF_FREE
; /* reset flag */
dp
= (struct tftphdr
*)b
->buf
;
nextone
= !nextone
; /* incr for next time */
if (count
<= 0) return -1; /* nak logic? */
return write(fileno(file
), buf
, count
);
while (ct
--) { /* loop over the buffer */
c
= *p
++; /* pick up a character */
if (prevchar
== '\r') { /* if prev char was cr */
if (c
== '\n') /* if have cr,lf then just */
fseek(file
, -1, 1); /* smash lf on top of the cr */
if (c
== '\0') /* if have cr,nul then */
goto skipit
; /* just skip over the putc */
/* else just fall through and allow it */
/* When an error has occurred, it is possible that the two sides
* are out of synch. Ie: that what I think is the other side's
* response to packet N is really their response to packet N-1.
* So, to try to prevent that, we flush all the input queued up
* for us on the network connection on our host.
* We return the number of packets we flushed (mostly for reporting
int f
; /* socket to flush */
(void) ioctl(f
, FIONREAD
, &i
);
(void) recvfrom(f
, rbuf
, sizeof (rbuf
), 0,
(caddr_t
)&from
, &fromlen
);