[lonetic/bufio,lonetix/bgp,tools/bgpgrep,tools/peerindex] Add support for buffered input

lonetix/bgp/dump_isolario.c

@@ -159,7 +159,7 @@ static void NormalizeExtendedTimestamp(Dumpfmtctx *ctx)
 	ctx->microsecs %= 1000000;
 }
 
-static void DumpUnknown(Stmbuf *sb, BgpType type)
+static void DumpUnknown(Stmwrbuf *sb, BgpType type)
 {
 	Bufio_Putc(sb, UNKNOWN_MARKER);
 	Bufio_Putc(sb, SEP_CHAR);
@@ -167,7 +167,7 @@ static void DumpUnknown(Stmbuf *sb, BgpType type)
 	Bufio_Putsn(sb, SEPS_BUF, 8);
 }
 
-static Sint32 DumpCaps(Stmbuf *sb, Bgpcapiter *caps, const Dumpfmtctx *ctx)
+static Sint32 DumpCaps(Stmwrbuf *sb, Bgpcapiter *caps, const Dumpfmtctx *ctx)
 {
 	const char *s;
 	Bgpcap     *cap;
@@ -193,7 +193,7 @@ static Sint32 DumpCaps(Stmbuf *sb, Bgpcapiter *caps, const Dumpfmtctx *ctx)
 	return ncaps;
 }
 
-static Judgement DumpAttributes(Stmbuf           *sb,
+static Judgement DumpAttributes(Stmwrbuf         *sb,
                                 const Bgpattrseg *tpa,
                                 Bgpattrtab        table,
                                 const Dumpfmtctx *ctx)
@@ -402,7 +402,7 @@ static Judgement DumpAttributes(Stmbuf           *sb,
 	return OK;
 }
 
-static void DumpMrtInfoTrailer(Stmbuf *sb, const Dumpfmtctx *ctx)
+static void DumpMrtInfoTrailer(Stmwrbuf *sb, const Dumpfmtctx *ctx)
 {
 	char buf[128];
 
@@ -440,7 +440,7 @@ static void DumpMrtInfoTrailer(Stmbuf *sb, const Dumpfmtctx *ctx)
 	Bufio_Puts(sb, EOLN);
 }
 
-static void WarnCorrupted(Stmbuf *sb, const Dumpfmtctx *ctx)
+static void WarnCorrupted(Stmwrbuf *sb, const Dumpfmtctx *ctx)
 {
 	Bufio_Putc(sb, SEP_CHAR_BAD);
 	if (ctx->withColors)
@@ -452,7 +452,7 @@ static void WarnCorrupted(Stmbuf *sb, const Dumpfmtctx *ctx)
 }
 
 static Sint32 DumpRoutesFast(char              marker,
-                             Stmbuf           *sb,
+                             Stmwrbuf           *sb,
                              Bgpmpiter        *prefixes,
                              const Bgpattrseg *tpa,
                              Bgpattrtab        table,
@@ -519,7 +519,7 @@ static unsigned InsertRoute(Prefixtree **pr, Prefixtree *n)
 }
 
 static Sint32 DumpRouteWithPathId(char              marker,
-                                  Stmbuf           *sb,
+                                  Stmwrbuf         *sb,
                                   const Prefixtree *n,
                                   const Bgpattrseg *tpa,
                                   Bgpattrtab        table,
@@ -558,7 +558,7 @@ static Sint32 DumpRouteWithPathId(char              marker,
 }
 
 static Sint32 DumpRoutes(char              marker,
-                         Stmbuf           *sb,
+                         Stmwrbuf         *sb,
                          Bgpmpiter        *prefixes,
                          const Bgpattrseg *tpa,
                          Bgpattrtab        table,
@@ -614,7 +614,7 @@ static Sint32 DumpRoutes(char              marker,
 	return nprefixes;
 }
 
-static Judgement DumpBgp(Stmbuf        *sb,
+static Judgement DumpBgp(Stmwrbuf      *sb,
                          BgpType        type,
                          const void    *data,
                          size_t         nbytes,
@@ -720,7 +720,7 @@ static Sint64 Isolario_DumpMsg(const Bgphdr *hdr,
                                const StmOps *ops,
                                Bgpattrtab    table)
 {
-	Stmbuf sb;
+	Stmwrbuf sb;
 
 	size_t nbytes = beswap16(hdr->len);
 	assert(nbytes >= BGP_HDRSIZ);
@@ -731,7 +731,7 @@ static Sint64 Isolario_DumpMsg(const Bgphdr *hdr,
 	ctx.isAsn32bit = BGP_ISASN32BIT(flags);
 	ctx.isAddPath  = BGP_ISADDPATH(flags);
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 	DumpBgp(&sb, hdr->type, hdr + 1, nbytes, table, &ctx);
 	return Bufio_Flush(&sb);
 }
@@ -742,7 +742,7 @@ static Sint64 Isolario_DumpMsgWc(const Bgphdr *hdr,
                                  const StmOps *ops,
                                  Bgpattrtab    table)
 {
-	Stmbuf sb;
+	Stmwrbuf sb;
 
 	size_t nbytes = beswap16(hdr->len);
 	assert(nbytes >= BGP_HDRSIZ);
@@ -754,7 +754,7 @@ static Sint64 Isolario_DumpMsgWc(const Bgphdr *hdr,
 	ctx.isAddPath  = BGP_ISADDPATH(flags);
 	ctx.withColors = TRUE;
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 	DumpBgp(&sb, hdr->type, hdr + 1, nbytes, table, &ctx);
 
 	return Bufio_Flush(&sb);
@@ -770,12 +770,12 @@ static Sint64 Isolario_DumpRibv2(const Mrthdr       *hdr,
 	assert(hdr->type == MRT_TABLE_DUMPV2);
 	assert(TABLE_DUMPV2_ISRIB(hdr->subtype));
 
-	Stmbuf     sb;
+	Stmwrbuf   sb;
 	Dumpfmtctx ctx;
 	char       buf[APPFX_STRLEN + 1];
 	char      *ep;
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.hasPeer      = TRUE;
@@ -865,13 +865,13 @@ static Sint64 Isolario_DumpRib(const Mrthdr    *hdr,
 {
 	assert(hdr->type == MRT_TABLE_DUMP);
 
-	Stmbuf     sb;
+	Stmwrbuf   sb;
 	Dumpfmtctx ctx;
 	RawPrefix  pfx;
 	char       buf[APPFX_STRLEN + 1];
 	char      *ep;
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.hasPeer      = TRUE;
@@ -930,14 +930,14 @@ static Sint64 Isolario_DumpBgp4mp(const Mrthdr    *hdr,
 {
 	assert(hdr->type == MRT_BGP4MP || hdr->type == MRT_BGP4MP_ET);
 
-	Stmbuf     sb;
+	Stmwrbuf   sb;
 	Dumpfmtctx ctx;
 	size_t     offset;  // offset to BGP4MP payload
 	size_t     len;
 
 	const Bgp4mphdr *bgp4mp = BGP4MP_HDR(hdr);
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 
 	len = beswap32(hdr->len);
 
@@ -1058,12 +1058,12 @@ static Sint64 Isolario_DumpZebra(const Mrthdr   *hdr,
 {
 	assert(hdr->type == MRT_BGP);
 
-	Stmbuf     sb;
+	Stmwrbuf   sb;
 	Dumpfmtctx ctx;
 
 	const Zebrahdr *zebra = ZEBRA_HDR(hdr);
 
-	Bufio_Init(&sb, streamp, ops);
+	Bufio_WrInit(&sb, streamp, ops);
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.hasPeer         = TRUE;

lonetix/bufio.c

@@ -18,36 +18,91 @@
 #include <stdio.h>
 #include <string.h>
 
-Sint64 Bufio_Flush(Stmbuf *sb)
+static Judgement Bufio_FillRdBuf(Stmrdbuf *sb)
+{
+	assert(sb->pos == sb->availIn);
+
+	Sint64 n = sb->ops->Read(sb->streamp, sb->buf, sizeof(sb->buf));
+	if (n < 0) {
+		sb->hasError = TRUE;
+		return NG;
+	}
+
+	sb->isEof = (n == 0);
+
+	sb->availIn  = n;
+	sb->totalIn += n;
+	sb->pos      = 0;
+	return OK;
+}
+
+Sint64 Bufio_Read(Stmrdbuf *sb, void *buf, size_t nbytes)
+{
+	assert(sb->ops->Read);
+
+	if (sb->hasError)
+		return -1;  // refuse unless somebody clears error
+
+	Uint8 *dest = (Uint8 *) buf;
+	while (nbytes > 0) {
+		if (sb->pos >= sb->availIn) {
+			if (Bufio_FillRdBuf(sb) != OK) {
+				if (dest > (Uint8 *) buf)
+					break; // delay error to next read
+
+				return -1;
+			}
+			if (sb->isEof)
+				break;  // end of file
+		}
+
+		size_t size = MIN((size_t) (sb->availIn - sb->pos), nbytes);
+
+		memcpy(dest, sb->buf + sb->pos, size);
+		sb->pos += size;
+
+		nbytes -= size;
+		dest   += size;
+	}
+
+	return dest - (Uint8 *) buf;
+}
+
+void Bufio_Close(Stmrdbuf *sb)
+{
+	if (sb->ops->Close) sb->ops->Close(sb->streamp);
+}
+
+Sint64 Bufio_Flush(Stmwrbuf *sb)
 {
 	assert(sb->ops->Write);
 
-	while (sb->len > 0) {
+	while (sb->availOut > 0) {
-		Sint64 n = sb->ops->Write(sb->streamp, sb->buf, sb->len);
+		Sint64 n = sb->ops->Write(sb->streamp, sb->buf, sb->availOut);
 		if (n < 0)
-			return NG;
+			return -1;
 
-		memmove(sb->buf, sb->buf + n, sb->len - n);
+		memmove(sb->buf, sb->buf + n, sb->availOut - n);
-		sb->len   -= n;
+		sb->availOut -= n;
-		sb->total += n;
+		sb->totalOut += n;
 	}
 
-	return sb->total;
+	return sb->totalOut;
 }
 
-Sint64 _Bufio_Putsn(Stmbuf *sb, const char *s, size_t nbytes)
+Sint64 _Bufio_Putsn(Stmwrbuf *sb, const char *s, size_t nbytes)
 {
-	if (sb->len + nbytes > sizeof(sb->buf) && Bufio_Flush(sb) == -1)
+	if (sb->availOut + nbytes > sizeof(sb->buf) && Bufio_Flush(sb) == -1)
 		return -1;
 	if (nbytes > sizeof(sb->buf))
 		return sb->ops->Write(sb->streamp, sb, nbytes);
 
-	memcpy(sb->buf + sb->len, s, nbytes);
+	memcpy(sb->buf + sb->availOut, s, nbytes);
-	sb->len += nbytes;
+	sb->availOut += nbytes;
 	return nbytes;
 }
 
-Sint64 Bufio_Putu(Stmbuf *sb, unsigned long long val)
+Sint64 Bufio_Putu(Stmwrbuf *sb, unsigned long long val)
 {
 	char buf[DIGS(val) + 1];
 
@@ -55,7 +110,7 @@ Sint64 Bufio_Putu(Stmbuf *sb, unsigned long long val)
 	return Bufio_Putsn(sb, buf, eptr - buf);
 }
 
-Sint64 Bufio_Putx(Stmbuf *sb, unsigned long long val)
+Sint64 Bufio_Putx(Stmwrbuf *sb, unsigned long long val)
 {
 	char buf[XDIGS(val) + 1];
 
@@ -63,7 +118,7 @@ Sint64 Bufio_Putx(Stmbuf *sb, unsigned long long val)
 	return Bufio_Putsn(sb, buf, eptr - buf);
 }
 
-Sint64 Bufio_Puti(Stmbuf *sb, long long val)
+Sint64 Bufio_Puti(Stmwrbuf *sb, long long val)
 {
 	char buf[1 + DIGS(val) + 1];
 
@@ -71,7 +126,7 @@ Sint64 Bufio_Puti(Stmbuf *sb, long long val)
 	return Bufio_Putsn(sb, buf, eptr - buf);
 }
 
-Sint64 Bufio_Putf(Stmbuf *sb, double val)
+Sint64 Bufio_Putf(Stmwrbuf *sb, double val)
 {
 	char buf[DOUBLE_STRLEN + 1];
 
@@ -79,7 +134,7 @@ Sint64 Bufio_Putf(Stmbuf *sb, double val)
 	return Bufio_Putsn(sb, buf, eptr - buf);
 }
 
-Sint64 Bufio_Printf(Stmbuf *sb, const char *fmt, ...)
+Sint64 Bufio_Printf(Stmwrbuf *sb, const char *fmt, ...)
 {
 	va_list va;
 	Sint64  n;
@@ -91,7 +146,7 @@ Sint64 Bufio_Printf(Stmbuf *sb, const char *fmt, ...)
 	return n;
 }
 
-Sint64 Bufio_Vprintf(Stmbuf *sb, const char *fmt, va_list va)
+Sint64 Bufio_Vprintf(Stmwrbuf *sb, const char *fmt, va_list va)
 {
 	va_list vc;
 	char   *buf;
@@ -117,3 +172,39 @@ Sint64 Bufio_Vprintf(Stmbuf *sb, const char *fmt, va_list va)
 	return Bufio_Putsn(sb, buf, n2);
 }
 
+static Sint64 Bufio_StmRead(void *streamp, void *buf, size_t nbytes)
+{
+	return Bufio_Read((Stmrdbuf *) streamp, buf, nbytes);
+}
+
+static Sint64 Bufio_StmTell(void *streamp)
+{
+	Stmrdbuf *sb = (Stmrdbuf *) streamp;
+
+	return (sb->hasError) ? -1 : sb->totalIn + (Sint64) sb->pos;
+}
+
+static void Bufio_StmClose(void *streamp)
+{
+	Bufio_Close((Stmrdbuf *) streamp);
+}
+
+static const StmOps _Stm_RdBufOps = {
+	Bufio_StmRead,
+	NULL,
+	NULL,
+	Bufio_StmTell,
+	NULL,
+	Bufio_StmClose
+};
+static const StmOps _Stm_NcRdBufOps = {
+	Bufio_StmRead,
+	NULL,
+	NULL,
+	Bufio_StmTell,
+	NULL,
+	NULL
+};
+
+const StmOps *const Stm_RdBufOps   = &_Stm_RdBufOps;
+const StmOps *const Stm_NcRdBufOps = &_Stm_NcRdBufOps;

lonetix/include/df/bufio.h

@@ -3,7 +3,7 @@
 /**
  * \file      bufio.h
  *
- * Buffered stream writing utilities.
+ * Buffered stream input/output utilities.
  *
  * \copyright The DoubleFourteen Code Forge (C) All Rights Reserved
  * \author    Lorenzo Cogotti
@@ -26,27 +26,81 @@
  * and reduce calls to a stream's `Write()` operation.
  */
 typedef struct {
-	Sint64        total;            ///< Total bytes flushed to output
+	Sint64        totalOut;         ///< Total bytes flushed to output
-	Uint32        len;              ///< Bytes currently buffered
+	Uint32        availOut;         ///< Bytes currently buffered
 	char          buf[STM_BUFSIZ];  ///< Output buffer
 	void         *streamp;          ///< Output stream pointer
 	const StmOps *ops;              ///< Output stream operations
-} Stmbuf;
+} Stmwrbuf;
+
+/**
+ * Buffered input helper structure.
+ *
+ * A small `struct` holding an input buffer.
+ * Reading variant of the `Stmwrbuf` structure.
+ *
+ * In contrast with `Stmwrbuf`, this struct may be used
+ * as a stream with `Stm_RdBufOps` and `Stm_NcRdBufOps`.
+ */
+typedef struct {
+	Sint64        totalIn;          ///< Total bytes read from input.
+	Uint16        availIn;          ///< Bytes currently buffered.
+	Uint16        pos;              ///< Offset inside buffer to next byte to be returned.
+	Boolean8      hasError;         ///< Whether a read error was encountered
+	Boolean8      isEof;            ///< Whether last Read() from input returned 0
+	char          buf[STM_BUFSIZ];  ///< Input buffer
+	void         *streamp;          ///< Input stream pointer
+	const StmOps *ops;              ///< Input stream operations
+} Stmrdbuf;
+
+/// Clear `Stmrdbuf` error flag, if set.
+FORCE_INLINE void BUFIO_CLRERROR(Stmrdbuf *sb)
+{
+	sb->hasError = FALSE;
+}
+
+/// Clear `Stmrdbuf` EOF flag, if set.
+FORCE_INLINE void BUFIO_CLREOF(Stmrdbuf *sb)
+{
+	sb->isEof = FALSE;
+}
+
+/**
+ * Initialize the buffer for reading from `streamp` using the
+ * `ops` stream operations.
+ *
+ * \param [out] sb      Buffer to be initialized, must not be `NULL`
+ * \param [in]  streamp Output stream pointer
+ * \param [in]  ops     Output stream operations, must not be `NULL`
+ *                      and must provide a `Read()` operation
+ */
+FORCE_INLINE void Bufio_RdInit(Stmrdbuf *sb, void *streamp, const StmOps *ops)
+{
+	sb->totalIn  = 0;
+	sb->availIn  = 0;
+	sb->hasError = FALSE;
+	sb->isEof    = FALSE;
+	sb->streamp  = streamp;
+	sb->ops      = ops;
+}
+
+Sint64 Bufio_Read(Stmrdbuf *sb, void *buf, size_t nbytes);
+void Bufio_Close(Stmrdbuf *sb);
 
 /**
  * Flush the buffer to output stream.
  *
  * \return On success returns the **total** bytes written to output
- *         stream since last call to `Bufio_Init()`,
+ *         stream since last call to `Bufio_WrInit()`,
- *         that is the value stored inside `sb->total` field after the flush
+ *         that is the value stored inside `sb->totalOut` field after the flush
  *         operations. Otherwise returns -1.
  *
  * \note Partial flushes are possible on partial writes, in which case
  *       some amount of data will remain buffered in `sb` and may be
- *       flushed later on; `sb->total` and `sb->len` will still be updated
+ *       flushed later on; `sb->totalOut` and `sb->len` will still be updated
  *       consistently.
  */
-Sint64 Bufio_Flush(Stmbuf *sb);
+Sint64 Bufio_Flush(Stmwrbuf *sb);
 
 /**
  * Initialize the buffer for writing to `streamp` using the
@@ -57,12 +111,12 @@ Sint64 Bufio_Flush(Stmbuf *sb);
  * \param [in]  ops     Output stream operations, must not be `NULL`
  *                      and must provide a `Write()` operation
  */
-FORCE_INLINE void Bufio_Init(Stmbuf       *sb,
+FORCE_INLINE void Bufio_WrInit(Stmwrbuf     *sb,
                                void         *streamp,
                                const StmOps *ops)
 {
-	sb->total   = 0;
+	sb->totalOut = 0;
-	sb->len     = 0;
+	sb->availOut = 0;
 	sb->streamp  = streamp;
 	sb->ops      = ops;
 }
@@ -77,16 +131,16 @@ FORCE_INLINE void Bufio_Init(Stmbuf       *sb,
  *         -1 on error.
  *
  * @{
- *   \fn Sint64 Bufio_Putu(Stmbuf *, unsigned long long)
+ *   \fn Sint64 Bufio_Putu(Stmwrbuf *, unsigned long long)
- *   \fn Sint64 Bufio_Putx(Stmbuf *, unsigned long long)
+ *   \fn Sint64 Bufio_Putx(Stmwrbuf *, unsigned long long)
- *   \fn Sint64 Bufio_Puti(Stmbuf *, long long)
+ *   \fn Sint64 Bufio_Puti(Stmwrbuf *, long long)
- *   \fn Sint64 Bufio_Putf(Stmbuf *, double)
+ *   \fn Sint64 Bufio_Putf(Stmwrbuf *, double)
  * @}
  */
-Sint64 Bufio_Putu(Stmbuf *sb, unsigned long long val);
+Sint64 Bufio_Putu(Stmwrbuf *sb, unsigned long long val);
-Sint64 Bufio_Putx(Stmbuf *sb, unsigned long long val);
+Sint64 Bufio_Putx(Stmwrbuf *sb, unsigned long long val);
-Sint64 Bufio_Puti(Stmbuf *sb, long long val);
+Sint64 Bufio_Puti(Stmwrbuf *sb, long long val);
-Sint64 Bufio_Putf(Stmbuf *sb, double val);
+Sint64 Bufio_Putf(Stmwrbuf *sb, double val);
 
 /**
  * Write a single character to `sb`.
@@ -96,12 +150,12 @@ Sint64 Bufio_Putf(Stmbuf *sb, double val);
  *
  * \note `\0` may be written and buffered like any other `char`.
  */
-FORCE_INLINE Sint64 Bufio_Putc(Stmbuf *sb, char c)
+FORCE_INLINE Sint64 Bufio_Putc(Stmwrbuf *sb, char c)
 {
-	if (sb->len == sizeof(sb->buf) && Bufio_Flush(sb) == -1)
+	if (sb->availOut == sizeof(sb->buf) && Bufio_Flush(sb) == -1)
 		return -1;
 
-	sb->buf[sb->len++] = c;
+	sb->buf[sb->availOut++] = c;
 	return 1;
 }
 
@@ -117,7 +171,7 @@ FORCE_INLINE Sint64 Bufio_Putc(Stmbuf *sb, char c)
  * \return Number of bytes written to `sb` on success (equal to
  *         `nbytes`), -1 on error.
  */
-Sint64 _Bufio_Putsn(Stmbuf *, const char *, size_t);
+Sint64 _Bufio_Putsn(Stmwrbuf *, const char *, size_t);
 
 #ifdef __GNUC__
 // Optimize to call Bufio_Putc() if 'nbytes' is statically known to be 1
@@ -137,7 +191,7 @@ Sint64 _Bufio_Putsn(Stmbuf *, const char *, size_t);
  * \return Number of bytes written to `sb` on success (equal
  *         to string length), -1 on error.
  */
-FORCE_INLINE Sint64 Bufio_Puts(Stmbuf *sb, const char *s)
+FORCE_INLINE Sint64 Bufio_Puts(Stmwrbuf *sb, const char *s)
 {
 	EXTERNC size_t strlen(const char *); // avoids #include
 
@@ -152,11 +206,14 @@ FORCE_INLINE Sint64 Bufio_Puts(Stmbuf *sb, const char *s)
  * \return Number of bytes written to `sb` on success, -1 on error.
  *
  * @{
- *   \fn Sint64 Bufio_Printf(Stmbuf *, const char *, ...)
+ *   \fn Sint64 Bufio_Printf(Stmwrbuf *, const char *, ...)
- *   \fn Sint64 Bufio_Vprintf(Stmbuf *, const char *, va_list)
+ *   \fn Sint64 Bufio_Vprintf(Stmwrbuf *, const char *, va_list)
  * @}
  */
-CHECK_PRINTF(2, 3) Sint64 Bufio_Printf(Stmbuf *, const char *, ...);
+CHECK_PRINTF(2, 3) Sint64 Bufio_Printf(Stmwrbuf *, const char *, ...);
-CHECK_PRINTF(2, 0) Sint64 Bufio_Vprintf(Stmbuf *, const char *, va_list);
+CHECK_PRINTF(2, 0) Sint64 Bufio_Vprintf(Stmwrbuf *, const char *, va_list);
+
+extern const StmOps *const Stm_RdBufOps;
+extern const StmOps *const Stm_NcRdBufOps;
 
 #endif

tools/bgpgrep/bgpgrep.c

@@ -316,8 +316,10 @@ static void Bgpgrep_OpenMrtDump(const char *filename)
 	S.filename = filename;
 	if (strcmp(S.filename, "-") == 0) {
 		// Direct read from stdin - assume uncompressed.
-		S.inf    = STM_FILDES(CON_FILDES(STDIN));
+		Bufio_RdInit(&S.infBuf, STM_FILDES(CON_FILDES(STDIN)), Stm_NcFildesOps);
-		S.infOps = Stm_NcFildesOps;
+
+		S.inf    = &S.infBuf;
+		S.infOps = Stm_NcRdBufOps;
 		return;
 	}
 
@@ -352,8 +354,10 @@ static void Bgpgrep_OpenMrtDump(const char *filename)
 
 	} else {
 		// Assume uncompressed file
-		S.inf    = STM_FILDES(fh);
+		Bufio_RdInit(&S.infBuf, STM_FILDES(fh), Stm_FildesOps);
-		S.infOps = Stm_FildesOps;
+
+		S.inf    = &S.infBuf;
+		S.infOps = Stm_RdBufOps;
 	}
 }
 

tools/bgpgrep/bgpgrep_local.h

@@ -16,6 +16,7 @@
 #include "bgp/mrt.h"
 #include "bgp/patricia.h"
 #include "bgp/vm.h"
+#include "bufio.h"
 
 #include <setjmp.h>
 
@@ -113,6 +114,7 @@ struct BgpgrepState {
 	const char   *filename;  // current file being processed
 	void         *inf;       // NOTE: may be NULL even in a file is open
 	const StmOps *infOps;    // if NULL no file is open
+	Stmrdbuf      infBuf;    // input buffer in case we're reading from uncompressed source
 
 	// Miscellaneous global flags and data
 	Boolean8  noColor;

tools/peerindex/peerindex.c

@@ -226,8 +226,10 @@ static void Peerindex_OpenMrtDump(const char *filename)
 	S.filename = filename;
 	if (strcmp(S.filename, "-") == 0) {
 		// Direct read from stdin, assume uncompressed
-		S.inf    = STM_FILDES(CON_FILDES(STDIN));
+		Bufio_RdInit(&S.infBuf, STM_FILDES(CON_FILDES(STDIN)), Stm_NcFildesOps);
-		S.infOps = Stm_NcFildesOps;
+
+		S.inf    = &S.infBuf;
+		S.infOps = Stm_NcRdBufOps;
 		return;
 	}
 
@@ -262,8 +264,10 @@ static void Peerindex_OpenMrtDump(const char *filename)
 
 	} else {
 		// Assume uncompressed file
-		S.inf    = STM_FILDES(fh);
+		Bufio_RdInit(&S.infBuf, STM_FILDES(fh), Stm_FildesOps);
-		S.infOps = Stm_FildesOps;
+
+		S.inf    = &S.infBuf;
+		S.infOps = Stm_RdBufOps;
 	}
 }
 
@@ -288,7 +292,7 @@ static void Peerindex_MarkPeerRefs(void)
 static void Peerindex_FlushPeerIndexTable(void)
 {
 	char buf[IPV6_STRLEN + 1];
-	Stmbuf sb;
+	Stmwrbuf sb;
 
 	Ipadr adr;
 
@@ -300,7 +304,7 @@ static void Peerindex_FlushPeerIndexTable(void)
 
 	Uint16 idx = 0;
 
-	Bufio_Init(&sb, S.outf, S.outfOps);
+	Bufio_WrInit(&sb, S.outf, S.outfOps);
 
 	Bgp_StartMrtPeersv2(&it, &S.peerIndex);
 	while ((peer = Bgp_NextMrtPeerv2(&it)) != NULL) {

tools/peerindex/peerindex_local.h

@@ -13,6 +13,7 @@
 #define DF_PEERINDEX_LOCAL_H_
 
 #include "bgp/mrt.h"
+#include "bufio.h"
 
 #include <setjmp.h>
 
@@ -39,6 +40,7 @@ typedef struct {
 	const char   *filename;
 	void         *inf;
 	const StmOps *infOps;
+	Stmrdbuf      infBuf;
 
 	// Miscellaneous global flags and data
 	Boolean8    hasPeerIndex;