uchar zero[64];

#include "vnc.h"

#define SHORT(p) (((p)[0]<<8)|((p)[1]))
#define LONG(p) ((SHORT(p)<<16)|SHORT(p+2))

uchar zero[64];

Vnc*
vncinit(int fd, int cfd, Vnc *v)
{
if(v == nil)
v = mallocz(sizeof(*v), 1);
Binit(&v->in, fd, OREAD);
Binit(&v->out, fd, OWRITE);
v->datafd = fd;
v->ctlfd = cfd;
return v;
}

void
vncterm(Vnc *v)
{
Bterm(&v->out);
Bterm(&v->in);
}

void
vncflush(Vnc *v)
{
if(Bflush(&v->out) < 0){
if(verbose > 1)
fprint(2, "hungup while sending flush: %r\n");
vnchungup(v);
}
}

uchar
vncrdchar(Vnc *v)
{
uchar buf[1];

vncrdbytes(v, buf, 1);
return buf[0];
}

ushort
vncrdshort(Vnc *v)
{
uchar buf[2];

vncrdbytes(v, buf, 2);
return SHORT(buf);
}

ulong
vncrdlong(Vnc *v)
{
uchar buf[4];

vncrdbytes(v, buf, 4);
return LONG(buf);
}

Point
vncrdpoint(Vnc *v)
{
Point p;

p.x = vncrdshort(v);
p.y = vncrdshort(v);
return p;
}

Rectangle
vncrdrect(Vnc *v)
{
Rectangle r;

r.min.x = vncrdshort(v);
r.min.y = vncrdshort(v);
r.max.x = r.min.x + vncrdshort(v);
r.max.y = r.min.y + vncrdshort(v);
return r;
}

Rectangle
vncrdcorect(Vnc *v)
{
Rectangle r;

r.min.x = vncrdchar(v);
r.min.y = vncrdchar(v);
r.max.x = r.min.x + vncrdchar(v);
r.max.y = r.min.y + vncrdchar(v);
return r;
}

void
vncrdbytes(Vnc *v, void *a, int n)
{
if(Bread(&v->in, a, n) != n){
if(verbose > 1)
fprint(2, "hungup while reading\n");
vnchungup(v);
}
}

Pixfmt
vncrdpixfmt(Vnc *v)
{
Pixfmt fmt;
uchar pad[3];

fmt.bpp = vncrdchar(v);
fmt.depth = vncrdchar(v);
fmt.bigendian = vncrdchar(v);
fmt.truecolor = vncrdchar(v);
fmt.red.max = vncrdshort(v);
fmt.green.max = vncrdshort(v);
fmt.blue.max = vncrdshort(v);
fmt.red.shift = vncrdchar(v);
fmt.green.shift = vncrdchar(v);
fmt.blue.shift = vncrdchar(v);
vncrdbytes(v, pad, 3);
return fmt;
}

char*
vncrdstring(Vnc *v)
{
ulong len;
char *s;

len = vncrdlong(v);
s = malloc(len+1);
assert(s != nil);

vncrdbytes(v, s, len);
s[len] = '\0';
return s;
}

/*
* on the server side of the negotiation protocol, we read
* the client response and then run the negotiated function.
* in some cases (e.g., TLS) the negotiated function needs to
* use v->datafd directly and be sure that no data has been
* buffered away in the Bio. since we know the client is waiting
* for our response, it won't have sent any until we respond.
* thus we read the response with vncrdstringx, which goes
* behind bio's back.
*/
char*
vncrdstringx(Vnc *v)
{
char tmp[4];
char *s;
ulong len;

assert(Bbuffered(&v->in) == 0);
if(readn(v->datafd, tmp, 4) != 4){
fprint(2, "cannot rdstringx: %r");
vnchungup(v);
}
len = LONG(tmp);
s = malloc(len+1);
assert(s != nil);
if(readn(v->datafd, s, len) != len){
fprint(2, "cannot rdstringx len %lud: %r", len);
vnchungup(v);
}
s[len] = '\0';
return s;
}

void
vncwrstring(Vnc *v, char *s)
{
ulong len;

len = strlen(s);
vncwrlong(v, len);
vncwrbytes(v, s, len);
}

void
vncwrbytes(Vnc *v, void *a, int n)
{
if(Bwrite(&v->out, a, n) < 0){
if(verbose > 1)
fprint(2, "hungup while writing bytes\n");
vnchungup(v);
}
}

void
vncwrlong(Vnc *v, ulong u)
{
uchar buf[4];

buf[0] = u>>24;
buf[1] = u>>16;
buf[2] = u>>8;
buf[3] = u;
vncwrbytes(v, buf, 4);
}

void
vncwrshort(Vnc *v, ushort u)
{
uchar buf[2];

buf[0] = u>>8;
buf[1] = u;
vncwrbytes(v, buf, 2);
}

void
vncwrchar(Vnc *v, uchar c)
{
vncwrbytes(v, &c, 1);
}

void
vncwrpixfmt(Vnc *v, Pixfmt *fmt)
{
vncwrchar(v, fmt->bpp);
vncwrchar(v, fmt->depth);
vncwrchar(v, fmt->bigendian);
vncwrchar(v, fmt->truecolor);
vncwrshort(v, fmt->red.max);
vncwrshort(v, fmt->green.max);
vncwrshort(v, fmt->blue.max);
vncwrchar(v, fmt->red.shift);
vncwrchar(v, fmt->green.shift);
vncwrchar(v, fmt->blue.shift);
vncwrbytes(v, zero, 3);
}

void
vncwrrect(Vnc *v, Rectangle r)
{
vncwrshort(v, r.min.x);
vncwrshort(v, r.min.y);
vncwrshort(v, r.max.x-r.min.x);
vncwrshort(v, r.max.y-r.min.y);
}

void
vncwrpoint(Vnc *v, Point p)
{
vncwrshort(v, p.x);
vncwrshort(v, p.y);
}

void
vnclock(Vnc *v)
{
qlock(v);
}

void
vncunlock(Vnc *v)
{
qunlock(v);
}

void
hexdump(void *a, int n)
{
uchar *p, *ep;

p = a;
ep = p+n;

for(; p<ep; p++)
print("%.2ux ", *p);
print("\n");
}

void
vncgobble(Vnc *v, long n)
{
uchar buf[8192];
long m;

while(n > 0){
m = n;
if(m > sizeof(buf))
m = sizeof(buf);
vncrdbytes(v, buf, m);
n -= m;
}
}