[lonetic/bufio,lonetix/bgp,tools/bgpgrep,tools/peerindex] Add support for buffered input
This commit is contained in:
Lorenzo Cogotti
parent
3b5b41bf54
commit
631ee335d8
|
|
@ -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;
|
||||
|
|
|
|||
127
lonetix/bufio.c
127
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) {
|
||||
Sint64 n = sb->ops->Write(sb->streamp, sb->buf, sb->len);
|
||||
while (sb->availOut > 0) {
|
||||
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);
|
||||
sb->len -= n;
|
||||
sb->total += n;
|
||||
memmove(sb->buf, sb->buf + n, sb->availOut - n);
|
||||
sb->availOut -= 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);
|
||||
sb->len += nbytes;
|
||||
memcpy(sb->buf + sb->availOut, s, 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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
Uint32 len; ///< Bytes currently buffered
|
||||
Sint64 totalOut; ///< Total bytes flushed to output
|
||||
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()`,
|
||||
* that is the value stored inside `sb->total` field after the flush
|
||||
* stream since last call to `Bufio_WrInit()`,
|
||||
* 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->len = 0;
|
||||
sb->totalOut = 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_Putx(Stmbuf *, unsigned long long)
|
||||
* \fn Sint64 Bufio_Puti(Stmbuf *, long long)
|
||||
* \fn Sint64 Bufio_Putf(Stmbuf *, double)
|
||||
* \fn Sint64 Bufio_Putu(Stmwrbuf *, unsigned long long)
|
||||
* \fn Sint64 Bufio_Putx(Stmwrbuf *, unsigned long long)
|
||||
* \fn Sint64 Bufio_Puti(Stmwrbuf *, long long)
|
||||
* \fn Sint64 Bufio_Putf(Stmwrbuf *, double)
|
||||
* @}
|
||||
*/
|
||||
Sint64 Bufio_Putu(Stmbuf *sb, unsigned long long val);
|
||||
Sint64 Bufio_Putx(Stmbuf *sb, unsigned long long val);
|
||||
Sint64 Bufio_Puti(Stmbuf *sb, long long val);
|
||||
Sint64 Bufio_Putf(Stmbuf *sb, double val);
|
||||
Sint64 Bufio_Putu(Stmwrbuf *sb, unsigned long long val);
|
||||
Sint64 Bufio_Putx(Stmwrbuf *sb, unsigned long long val);
|
||||
Sint64 Bufio_Puti(Stmwrbuf *sb, long long 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_Vprintf(Stmbuf *, const char *, va_list)
|
||||
* \fn Sint64 Bufio_Printf(Stmwrbuf *, const char *, ...)
|
||||
* \fn Sint64 Bufio_Vprintf(Stmwrbuf *, const char *, va_list)
|
||||
* @}
|
||||
*/
|
||||
CHECK_PRINTF(2, 3) Sint64 Bufio_Printf(Stmbuf *, const char *, ...);
|
||||
CHECK_PRINTF(2, 0) Sint64 Bufio_Vprintf(Stmbuf *, const char *, va_list);
|
||||
CHECK_PRINTF(2, 3) Sint64 Bufio_Printf(Stmwrbuf *, const char *, ...);
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
S.infOps = Stm_NcFildesOps;
|
||||
Bufio_RdInit(&S.infBuf, STM_FILDES(CON_FILDES(STDIN)), 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);
|
||||
S.infOps = Stm_FildesOps;
|
||||
Bufio_RdInit(&S.infBuf, STM_FILDES(fh), Stm_FildesOps);
|
||||
|
||||
S.inf = &S.infBuf;
|
||||
S.infOps = Stm_RdBufOps;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
S.infOps = Stm_NcFildesOps;
|
||||
Bufio_RdInit(&S.infBuf, STM_FILDES(CON_FILDES(STDIN)), 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);
|
||||
S.infOps = Stm_FildesOps;
|
||||
Bufio_RdInit(&S.infBuf, STM_FILDES(fh), 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) {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Reference in New Issue