int getlnmaxsep (buffer_ref b, char *d, unsigned int max, unsigned int *w, char const *sep, unsigned int seplen)
{
register int ok = 1 ;
if (max < *w) return (errno = EINVAL, -1) ;
for (;;)
{
unsigned int len = (*w + buffer_len(b) > max) ? max - *w : buffer_len(b) ;
unsigned int pos = byte_in(buffer_PEEK(b), len, sep, seplen) ;
byte_copy(d + *w, pos, buffer_PEEK(b)) ;
*w += pos ;
buffer_SEEK(b, pos) ;
if (*w >= max) return (errno = ERANGE, -1) ;
if (pos < len)
{
d[(*w)++] = *buffer_PEEK(b) ;
buffer_SEEK(b, 1) ;
return ok ;
}
{
register int r = buffer_fill(b) ;
if (r <= 0) return r ;
}
ok = 2 ;
}
}
int buffer_copyline(buffer *out,buffer *in,char eol)
{
int n;
char *x;
int i;
for (;;) {
n = buffer_feed(in);
if (n < 0) return -2;
if (!n) break;
x = buffer_PEEK(in);
i = byte_chr(x,n,eol);
if (buffer_put(out,x,i) < 0) return -3;
buffer_SEEK(in,i);
if (i < in->p) {
buffer_PUTC(out,eol);
buffer_SEEK(in,1);
break;
}
}
return 0;
}
int skagetln (buffer_ref b, stralloc *sa, int sep)
{
unsigned int start = sa->len ;
int ok = 1 ;
for (;;)
{
char *s = buffer_PEEK(b) ;
unsigned int pos = byte_chr(s, buffer_len(b), sep) ;
int r = (pos < buffer_len(b)) ;
if (!stralloc_catb(sa, s, pos)) return -1 ;
buffer_SEEK(b, pos) ;
if (r)
{
if (!stralloc_catb(sa, buffer_PEEK(b), 1)) return -1 ;
buffer_SEEK(b, 1) ;
return ok ;
}
r = buffer_fill(b) ;
if (r == -1) return -1 ;
if (!r) return (sa->s && (sa->len > start)) ? (errno = EPIPE, -1) : 0 ;
ok = 2 ;
}
}
int timed_getln (buffer_ref b, stralloc *sa, int sep, struct taia const *deadline, struct taia *stamp)
{
unsigned int len = sa->len ;
int ok = 1 ;
for (;;)
{
char *s = buffer_PEEK(b) ;
unsigned int pos = byte_chr(s, buffer_len(b), sep) ;
int r = (pos < buffer_len(b)) ;
if (!stralloc_catb(sa, s, pos)) return -1 ;
buffer_SEEK(b, pos) ;
if (r)
{
if (!stralloc_catb(sa, buffer_PEEK(b), 1)) return -1 ;
buffer_SEEK(b, 1) ;
return ok ;
}
r = timed_buffer_fill(b, deadline, stamp) ;
if (r == -1) return -1 ;
if (!r) return (sa->len > len) ? (errno = EPIPE, -1) : 0 ;
ok = 2 ;
}
}
main()
{
register int n;
register char *x;
char ch;
for (;;) {
n = buffer_feed(buffer_0);
if (n < 0) _exit(111);
if (!n) _exit(0);
x = buffer_PEEK(buffer_0);
buffer_SEEK(buffer_0,n);
while (n > 0) {
ch = *x++; --n;
if (ch == '\n') buffer_PUTC(buffer_1,"\r"[0]);
buffer_PUTC(buffer_1,ch);
}
}
}
int getln2(buffer *ss,stralloc *sa,char **cont,unsigned int *clen,int sep)
{
register char *x;
register unsigned int i;
int n;
if (!stralloc_ready(sa,0)) return -1;
sa->len = 0;
for (;;) {
n = buffer_feed(ss);
if (n < 0) return -1;
if (n == 0) { *clen = 0; return 0; }
x = buffer_PEEK(ss);
i = byte_chr(x,n,sep);
if (i < n) { buffer_SEEK(ss,*clen = i + 1); *cont = x; return 0; }
if (!stralloc_readyplus(sa,n)) return -1;
i = sa->len;
sa->len = i + buffer_get(ss,sa->s + i,n);
}
}
int getln2(buffer *buf,stralloc *sa,
/*@out@*/char **cont,/*@out@*/unsigned int *clen,int sep)
{
char *x;
unsigned int i;
int n;
if (!stralloc_ready(sa,0)) return -1;
sa->len = 0;
for (;;) {
n = buffer_feed(buf);
if (n < 0) return -1;
if (n == 0) { *clen = 0; return 0; }
x = buffer_PEEK(buf);
i = byte_chr(x,n,sep);
if (i < n) { buffer_SEEK(buf,*clen = i + 1); *cont = x; return 0; }
if (!stralloc_readyplus(sa,n)) return -1;
i = sa->len;
sa->len = i + buffer_get(buf,sa->s + i,n);
}
}
int netstring_get (buffer_ref b, stralloc *sa, unsigned int *unread)
{
unsigned int written ;
int ok = 1 ;
int r ;
if (!sa->s || (!sa->len && !*unread))
{
char *x ;
unsigned int n ;
unsigned int len ;
for (;;)
{
x = buffer_PEEK(b) ;
n = byte_chr(x, buffer_len(b), ':') ; /* XXX: accepts :, as a valid netstring */
if (n >= ULONG_FMT) return (errno = EINVAL, -1) ; /* XXX: breaks on too many leading '0's */
if (n < buffer_len(b)) break ;
r = buffer_fill(b) ;
if (r == -1) return -1 ;
if (!r) return (buffer_isempty(b) ? 0 : (errno = EPIPE, -1)) ;
ok = 2 ;
}
if (n != uint_scan(x, &len)) return (errno = EINVAL, -1) ;
if (!stralloc_readyplus(sa, len+1)) return -1 ;
buffer_SEEK(b, n+1) ;
*unread = len + 1 ;
}
written = sa->len ;
r = buffer_getall(b, sa->s + sa->len, sa->len + *unread, &written) ;
if (r <= 0)
{
*unread -= written - sa->len ;
sa->len = written ;
return r ? r : (errno = EINVAL, -1) ;
}
if (r == 2) ok = 2 ;
sa->len += *unread ;
*unread = 0 ;
return (sa->s[--sa->len] == ',') ? ok : (errno = EINVAL, -1) ;
}
