Subversion Repositories planix.SVN

#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;

	}

}