// returning EINTR.
//
-size_t FdInStream::readFd(void* buf, size_t len)
+size_t FdInStream::readFd(uint8_t* buf, size_t len)
{
int n;
do {
private:
virtual bool fillBuffer();
- size_t readFd(void* buf, size_t len);
+ size_t readFd(uint8_t* buf, size_t len);
int fd;
bool closeWhenDone;
bool FdOutStream::flushBuffer()
{
- size_t n = writeFd((const void*) sentUpTo, ptr - sentUpTo);
+ size_t n = writeFd(sentUpTo, ptr - sentUpTo);
if (n == 0)
return false;
// returning EINTR.
//
-size_t FdOutStream::writeFd(const void* data, size_t length)
+size_t FdOutStream::writeFd(const uint8_t* data, size_t length)
{
int n;
private:
virtual bool flushBuffer();
- size_t writeFd(const void* data, size_t length);
+ size_t writeFd(const uint8_t* data, size_t length);
int fd;
struct timeval lastWrite;
};
// readBytes() reads an exact number of bytes.
- void readBytes(void* data, size_t length) {
+ void readBytes(uint8_t* data, size_t length) {
check(length);
memcpy(data, ptr, length);
ptr += length;
public:
- MemInStream(const void* data, size_t len, bool deleteWhenDone_=false)
- : start((const uint8_t*)data), deleteWhenDone(deleteWhenDone_)
+ MemInStream(const uint8_t* data, size_t len, bool deleteWhenDone_=false)
+ : start(data), deleteWhenDone(deleteWhenDone_)
{
ptr = start;
end = start + len;
// data() returns a pointer to the buffer.
- const void* data() { return (const void*)start; }
+ const uint8_t* data() { return start; }
protected:
// writeBytes() writes an exact number of bytes.
- void writeBytes(const void* data, size_t length) {
+ void writeBytes(const uint8_t* data, size_t length) {
while (length > 0) {
check(1);
size_t n = length;
if (in->avail() < size)
size = in->avail();
- in->readBytes(data, size);
+ in->readBytes((uint8_t*)data, size);
} catch (EndOfStream&) {
return 0;
} catch (SystemException &e) {
self->saved_exception = NULL;
try {
- out->writeBytes(data, size);
+ out->writeBytes((const uint8_t*)data, size);
out->flush();
} catch (SystemException &e) {
vlog.error("Failure sending TLS data: %s", e.str());
if (!is->hasData(12))
return false;
- is->readBytes(verStr, 12);
+ is->readBytes((uint8_t*)verStr, 12);
verStr[12] = '\0';
if (sscanf(verStr, "RFB %03d.%03d\n",
sprintf(verStr, "RFB %03d.%03d\n",
server.majorVersion, server.minorVersion);
- os->writeBytes(verStr, 12);
+ os->writeBytes((const uint8_t*)verStr, 12);
os->flush();
state_ = RFBSTATE_SECURITY_TYPES;
is->clearRestorePoint();
std::vector<char> reason(len + 1);
- is->readBytes(reason.data(), len);
+ is->readBytes((uint8_t*)reason.data(), len);
reason[len] = '\0';
state_ = RFBSTATE_INVALID;
formatChange = true;
}
-void CConnection::fence(uint32_t flags, unsigned len, const char data[])
+void CConnection::fence(uint32_t flags, unsigned len, const uint8_t data[])
{
CMsgHandler::fence(flags, len, data);
// responds to requests, stating no support for synchronisation.
// When overriding, call CMsgHandler::fence() directly in order to
// state correct support for fence flags.
- virtual void fence(uint32_t flags, unsigned len, const char data[]);
+ virtual void fence(uint32_t flags, unsigned len, const uint8_t data[]);
private:
bool processVersionMsg();
}
void CMsgHandler::fence(uint32_t /*flags*/, unsigned /*len*/,
- const char /*data*/ [])
+ const uint8_t /*data*/ [])
{
server.supportsFence = true;
}
virtual void setCursorPos(const Point& pos) = 0;
virtual void setPixelFormat(const PixelFormat& pf);
virtual void setName(const char* name);
- virtual void fence(uint32_t flags, unsigned len, const char data[]);
+ virtual void fence(uint32_t flags, unsigned len, const uint8_t data[]);
virtual void endOfContinuousUpdates();
virtual void supportsQEMUKeyEvent();
virtual void serverInit(int width, int height,
return false;
is->clearRestorePoint();
std::vector<char> name(len + 1);
- is->readBytes(name.data(), len);
+ is->readBytes((uint8_t*)name.data(), len);
name[len] = '\0';
handler->serverInit(width, height, pf, name.data());
return true;
}
std::vector<char> ca(len);
- is->readBytes(ca.data(), len);
+ is->readBytes((uint8_t*)ca.data(), len);
std::string filtered(convertLF(ca.data(), len));
handler->serverCutText(filtered.c_str());
{
uint32_t flags;
uint8_t len;
- char data[64];
+ uint8_t data[64];
if (!is->hasData(3 + 4 + 1))
return false;
is->clearRestorePoint();
std::vector<char> name(len + 1);
- is->readBytes(name.data(), len);
+ is->readBytes((uint8_t*)name.data(), len);
name[len] = '\0';
if (x || y || w || h) {
endMsg();
}
-void CMsgWriter::writeFence(uint32_t flags, unsigned len, const char data[])
+void CMsgWriter::writeFence(uint32_t flags, unsigned len, const uint8_t data[])
{
if (!server->supportsFence)
throw Exception("Server does not support fences");
startMsg(msgTypeClientCutText);
os->pad(3);
os->writeU32(len);
- os->writeBytes(str, len);
+ os->writeBytes((const uint8_t*)str, len);
endMsg();
}
void writeFramebufferUpdateRequest(const Rect& r,bool incremental);
void writeEnableContinuousUpdates(bool enable, int x, int y, int w, int h);
- void writeFence(uint32_t flags, unsigned len, const char data[]);
+ void writeFence(uint32_t flags, unsigned len, const uint8_t data[]);
void writeKeyEvent(uint32_t keysym, uint32_t keycode, bool down);
void writePointerEvent(const Point& pos, int buttonMask);
struct aes128_ctx aesCtx;
aes128_set_encrypt_key(&aesCtx, key);
- char buf[128];
+ uint8_t buf[128];
if (!rs.hasData(128))
throw ConnFailedException("failed to generate random padding");
rs.readBytes(buf, 128);
if (password.size() >= 64)
throw AuthFailureException("password is too long");
memcpy(buf + 64, password.c_str(), password.size() + 1);
- aes128_encrypt(&aesCtx, 128, (uint8_t *)buf, (uint8_t *)buf);
+ aes128_encrypt(&aesCtx, 128, buf, buf);
rdr::OutStream* os = cc->getOutStream();
os->writeBytes(buf, 128);
// Return the response to the server
os->writeU32(username.size());
os->writeU32(password.size());
- os->writeBytes(username.data(), username.size());
- os->writeBytes(password.data(), password.size());
+ os->writeBytes((const uint8_t*)username.data(), username.size());
+ os->writeBytes((const uint8_t*)password.data(), password.size());
os->flush();
return true;
}
if (username.size() > 255)
throw AuthFailureException("username is too long");
raos->writeU8(username.size());
- raos->writeBytes(username.data(), username.size());
+ raos->writeBytes((const uint8_t*)username.data(), username.size());
} else {
raos->writeU8(0);
}
if (password.size() > 255)
throw AuthFailureException("password is too long");
raos->writeU8(password.size());
- raos->writeBytes(password.data(), password.size());
+ raos->writeBytes((const uint8_t*)password.data(), password.size());
raos->flush();
}
void CopyRectDecoder::getAffectedRegion(const Rect& rect,
- const void* buffer,
+ const uint8_t* buffer,
size_t buflen,
const ServerParams& server,
Region* region)
srcY-rect.tl.y))));
}
-void CopyRectDecoder::decodeRect(const Rect& r, const void* buffer,
+void CopyRectDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen,
const ServerParams& /*server*/,
ModifiablePixelBuffer* pb)
virtual ~CopyRectDecoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void getAffectedRegion(const Rect& rect, const void* buffer,
+ virtual void getAffectedRegion(const Rect& rect, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
Region* region);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
};
}
void Decoder::getAffectedRegion(const Rect& rect,
- const void* /*buffer*/,
+ const uint8_t* /*buffer*/,
size_t /*buflen*/,
const ServerParams& /*server*/,
Region* region)
}
bool Decoder::doRectsConflict(const Rect& /*rectA*/,
- const void* /*bufferA*/,
+ const uint8_t* /*bufferA*/,
size_t /*buflenA*/,
const Rect& /*rectB*/,
- const void* /*bufferB*/,
+ const uint8_t* /*bufferB*/,
size_t /*buflenB*/,
const ServerParams& /*server*/)
{
#ifndef __RFB_DECODER_H__
#define __RFB_DECODER_H__
+#include <stdint.h>
+
namespace rdr {
class InStream;
class OutStream;
// getAffectedRegion() returns the parts of the frame buffer will
// be either read from or written do when decoding this rect. The
// default implementation simply returns the given rectangle.
- virtual void getAffectedRegion(const Rect& rect, const void* buffer,
+ virtual void getAffectedRegion(const Rect& rect, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
Region* region);
// in the order they were received. This will only be called if the
// DecoderPartiallyOrdered flag has been set.
virtual bool doRectsConflict(const Rect& rectA,
- const void* bufferA,
+ const uint8_t* bufferA,
size_t buflenA,
const Rect& rectB,
- const void* bufferB,
+ const uint8_t* bufferB,
size_t buflenB,
const ServerParams& server);
// given buffer, onto the ModifiablePixelBuffer. The PixelFormat of
// the PixelBuffer might not match the ConnParams and it is up to
// the decoder to do any necessary conversion.
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)=0;
return true;
}
-void H264Decoder::decodeRect(const Rect& r, const void* buffer,
+void H264Decoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen,
const ServerParams& /*server*/,
ModifiablePixelBuffer* pb)
virtual ~H264Decoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
return true;
}
-void HextileDecoder::decodeRect(const Rect& r, const void* buffer,
+void HextileDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)
{
int tileType = is->readU8();
if (tileType & hextileRaw) {
- is->readBytes(buf, t.area() * sizeof(T));
+ is->readBytes((uint8_t*)buf, t.area() * sizeof(T));
pb->imageRect(pf, t, buf);
continue;
}
virtual ~HextileDecoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
private:
if (encodedLen < 0) {
pb->getImage(buf, t);
os->writeU8(hextileRaw);
- os->writeBytes(buf, t.width() * t.height() * sizeof(T));
+ os->writeBytes((const uint8_t*)buf,
+ t.width() * t.height() * sizeof(T));
oldBgValid = oldFgValid = false;
continue;
}
if ( (tileType & hextileRaw) != 0 ||
encodedLen >= t.width() * t.height() * sizeof(T)) {
os->writeU8(hextileRaw);
- os->writeBytes(buf, t.width() * t.height() * sizeof(T));
+ os->writeBytes((const uint8_t*)buf,
+ t.width() * t.height() * sizeof(T));
oldBgValid = oldFgValid = false;
continue;
}
delete[] rowPointer;
}
-void JpegCompressor::writeBytes(const void* /*data*/, int /*length*/)
+void JpegCompressor::writeBytes(const uint8_t* /*data*/, int /*length*/)
{
throw rdr::Exception("writeBytes() is not valid with a JpegCompressor instance. Use compress() instead.");
}
void compress(const uint8_t *, int, const Rect&, const PixelFormat&, int, int);
- void writeBytes(const void*, int);
+ void writeBytes(const uint8_t*, int);
private:
return true;
}
-void RREDecoder::decodeRect(const Rect& r, const void* buffer,
+void RREDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)
{
virtual ~RREDecoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
private:
return true;
}
-void RawDecoder::decodeRect(const Rect& r, const void* buffer,
+void RawDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)
{
virtual ~RawDecoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
};
char str[13];
sprintf(str, "RFB %03d.%03d\n", defaultMajorVersion, defaultMinorVersion);
- os->writeBytes(str, 12);
+ os->writeBytes((const uint8_t*)str, 12);
os->flush();
state_ = RFBSTATE_PROTOCOL_VERSION;
if (!is->hasData(12))
return false;
- is->readBytes(verStr, 12);
+ is->readBytes((uint8_t*)verStr, 12);
verStr[12] = '\0';
if (sscanf(verStr, "RFB %03d.%03d\n",
os->writeU32(secResultFailed);
if (!client.beforeVersion(3,8)) { // 3.8 onwards have failure message
os->writeU32(authFailureMsg.size());
- os->writeBytes(authFailureMsg.data(), authFailureMsg.size());
+ os->writeBytes((const uint8_t*)authFailureMsg.data(),
+ authFailureMsg.size());
}
os->flush();
} catch (rdr::Exception& e) {
if (client.majorVersion == 3 && client.minorVersion == 3) {
os->writeU32(0);
os->writeU32(strlen(str));
- os->writeBytes(str, strlen(str));
+ os->writeBytes((const uint8_t*)str, strlen(str));
os->flush();
} else {
os->writeU8(0);
os->writeU32(strlen(str));
- os->writeBytes(str, strlen(str));
+ os->writeBytes((const uint8_t*)str, strlen(str));
os->flush();
}
}
if (!reason)
reason = "Authentication failure";
os->writeU32(strlen(reason));
- os->writeBytes(reason, strlen(reason));
+ os->writeBytes((const uint8_t*)reason, strlen(reason));
}
}
os->flush();
}
}
-void SConnection::fence(uint32_t flags, unsigned len, const char data[])
+void SConnection::fence(uint32_t flags, unsigned len,
+ const uint8_t data[])
{
if (!(flags & fenceFlagRequest))
return;
// it responds directly to requests (stating it doesn't support any
// synchronisation) and drops responses. Override to implement more proper
// support.
- virtual void fence(uint32_t flags, unsigned len, const char data[]);
+ virtual void fence(uint32_t flags, unsigned len, const uint8_t data[]);
// enableContinuousUpdates() is called when the client wants to enable
// or disable continuous updates, or change the active area.
virtual void framebufferUpdateRequest(const Rect& r, bool incremental) = 0;
virtual void setDesktopSize(int fb_width, int fb_height,
const ScreenSet& layout) = 0;
- virtual void fence(uint32_t flags, unsigned len, const char data[]) = 0;
+ virtual void fence(uint32_t flags, unsigned len, const uint8_t data[]) = 0;
virtual void enableContinuousUpdates(bool enable,
int x, int y, int w, int h) = 0;
{
uint32_t flags;
uint8_t len;
- char data[64];
+ uint8_t data[64];
if (!is->hasData(3 + 4 + 1))
return false;
}
std::vector<char> ca(len);
- is->readBytes(ca.data(), len);
+ is->readBytes((uint8_t*)ca.data(), len);
std::string filtered(convertLF(ca.data(), len));
handler->clientCutText(filtered.c_str());
os->writeU16(height);
pf.write(os);
os->writeU32(strlen(name));
- os->writeBytes(name, strlen(name));
+ os->writeBytes((const uint8_t*)name, strlen(name));
endMsg();
}
startMsg(msgTypeServerCutText);
os->pad(3);
os->writeU32(len);
- os->writeBytes(str, len);
+ os->writeBytes((const uint8_t*)str, len);
endMsg();
}
endMsg();
}
-void SMsgWriter::writeFence(uint32_t flags, unsigned len, const char data[])
+void SMsgWriter::writeFence(uint32_t flags, unsigned len,
+ const uint8_t data[])
{
if (!client->supportsEncoding(pseudoEncodingFence))
throw Exception("Client does not support fences");
os->writeU16(0);
os->writeU32(pseudoEncodingDesktopName);
os->writeU32(strlen(name));
- os->writeBytes(name, strlen(name));
+ os->writeBytes((const uint8_t*)name, strlen(name));
}
void SMsgWriter::writeSetCursorRect(int width, int height,
int hotspotX, int hotspotY,
- const void* data, const void* mask)
+ const uint8_t* data,
+ const uint8_t* mask)
{
if (!client->supportsEncoding(pseudoEncodingCursor))
throw Exception("Client does not support local cursors");
void SMsgWriter::writeSetXCursorRect(int width, int height,
int hotspotX, int hotspotY,
- const void* data, const void* mask)
+ const uint8_t* data,
+ const uint8_t* mask)
{
if (!client->supportsEncoding(pseudoEncodingXCursor))
throw Exception("Client does not support local cursors");
const uint8_t* const* data);
// writeFence() sends a new fence request or response to the client.
- void writeFence(uint32_t flags, unsigned len, const char data[]);
+ void writeFence(uint32_t flags, unsigned len, const uint8_t data[]);
// writeEndOfContinuousUpdates() indicates that we have left continuous
// updates mode.
void writeSetDesktopNameRect(const char *name);
void writeSetCursorRect(int width, int height,
int hotspotX, int hotspotY,
- const void* data, const void* mask);
+ const uint8_t* data, const uint8_t* mask);
void writeSetXCursorRect(int width, int height,
int hotspotX, int hotspotY,
- const void* data, const void* mask);
+ const uint8_t* data, const uint8_t* mask);
void writeSetCursorWithAlphaRect(int width, int height,
int hotspotX, int hotspotY,
const uint8_t* data);
if (!is->hasData(ulen + plen))
return false;
state = 2;
- is->readBytes(username, ulen);
- is->readBytes(password, plen);
+ is->readBytes((uint8_t*)username, ulen);
+ is->readBytes((uint8_t*)password, plen);
password[plen] = 0;
username[ulen] = 0;
plen = 0;
uint8_t lenUsername = rais->readU8();
if (!rais->hasDataOrRestore(lenUsername + 1))
return false;
- rais->readBytes(username, lenUsername);
+ rais->readBytes((uint8_t*)username, lenUsername);
username[lenUsername] = 0;
uint8_t lenPassword = rais->readU8();
if (!rais->hasDataOrRestore(lenPassword))
return false;
- rais->readBytes(password, lenPassword);
+ rais->readBytes((uint8_t*)password, lenPassword);
password[lenPassword] = 0;
rais->clearRestorePoint();
return true;
}
bool TightDecoder::doRectsConflict(const Rect& /*rectA*/,
- const void* bufferA,
+ const uint8_t* bufferA,
size_t buflenA,
const Rect& /*rectB*/,
- const void* bufferB,
+ const uint8_t* bufferB,
size_t buflenB,
const ServerParams& /*server*/)
{
return false;
}
-void TightDecoder::decodeRect(const Rect& r, const void* buffer,
+void TightDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)
{
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
virtual bool doRectsConflict(const Rect& rectA,
- const void* bufferA,
+ const uint8_t* bufferA,
size_t buflenA,
const Rect& rectB,
- const void* bufferB,
+ const uint8_t* bufferB,
size_t buflenB,
const ServerParams& server);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
writer()->writeDesktopSize(reasonClient, result);
}
-void VNCSConnectionST::fence(uint32_t flags, unsigned len, const char data[])
+void VNCSConnectionST::fence(uint32_t flags, unsigned len, const uint8_t data[])
{
uint8_t type;
delete [] fenceData;
fenceData = NULL;
if (len > 0) {
- fenceData = new char[len];
+ fenceData = new uint8_t[len];
memcpy(fenceData, data, len);
}
void VNCSConnectionST::supportsFence()
{
- char type = 0;
+ uint8_t type = 0;
writer()->writeFence(fenceFlagRequest, sizeof(type), &type);
}
void VNCSConnectionST::writeRTTPing()
{
- char type;
+ uint8_t type;
if (!client.supportsFence())
return;
virtual void framebufferUpdateRequest(const Rect& r, bool incremental);
virtual void setDesktopSize(int fb_width, int fb_height,
const ScreenSet& layout);
- virtual void fence(uint32_t flags, unsigned len, const char data[]);
+ virtual void fence(uint32_t flags, unsigned len, const uint8_t data[]);
virtual void enableContinuousUpdates(bool enable,
int x, int y, int w, int h);
virtual void handleClipboardRequest();
bool pendingSyncFence, syncFence;
uint32_t fenceFlags;
unsigned fenceDataLen;
- char *fenceData;
+ uint8_t *fenceData;
Congestion congestion;
Timer congestionTimer;
rdr::OutStream& os = sock->outStream();
// Shortest possible way to tell a client it is not welcome
- os.writeBytes("RFB 003.003\n", 12);
+ os.writeBytes((const uint8_t*)"RFB 003.003\n", 12);
os.writeU32(0);
const char* reason = "Too many security failures";
os.writeU32(strlen(reason));
- os.writeBytes(reason, strlen(reason));
+ os.writeBytes((const uint8_t*)reason, strlen(reason));
os.flush();
} catch (rdr::Exception&) {
}
return true;
}
-void ZRLEDecoder::decodeRect(const Rect& r, const void* buffer,
+void ZRLEDecoder::decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb)
{
*ptr = readOpaque24B(zis);
}
} else {
- zis->readBytes(buf, t.area() * sizeof(T));
+ zis->readBytes((uint8_t*)buf, t.area() * sizeof(T));
}
} else {
virtual ~ZRLEDecoder();
virtual bool readRect(const Rect& r, rdr::InStream* is,
const ServerParams& server, rdr::OutStream* os);
- virtual void decodeRect(const Rect& r, const void* buffer,
+ virtual void decodeRect(const Rect& r, const uint8_t* buffer,
size_t buflen, const ServerParams& server,
ModifiablePixelBuffer* pb);
desktop->setCursorPos(pos);
}
-void CConn::fence(uint32_t flags, unsigned len, const char data[])
+void CConn::fence(uint32_t flags, unsigned len, const uint8_t data[])
{
CMsgHandler::fence(flags, len, data);
const uint8_t* data);
void setCursorPos(const rfb::Point& pos);
- void fence(uint32_t flags, unsigned len, const char data[]);
+ void fence(uint32_t flags, unsigned len, const uint8_t data[]);
void setLEDState(unsigned int state);
projects / tigervnc.git / commitdiff