// =========================================================================
// 函数功能：处理客户端对挑战信息的响应
// 输入参数：待交流的客户端cl
// 输出参数：
// 返回值 ：
// 说明 ：当响应消息失败时，3.7以上的版本会发送失败的原因，而3.7及其以下会直接
// 关闭客户端
// =========================================================================
void rfbAuthProcessClientMessage(rfbClientPtr cl)
{
char *passwd="123";
int n;
u8 response[CHALLENGESIZE];
u32 authResult;
if ((n = ReadExact(cl, (char *)response, CHALLENGESIZE)) <= 0) {
if (n != 0)
debug_printf("rfbAuthProcessClientMessage: read");
rfbCloseClient(cl);
return;
}
rfbEncryptBytes(cl->authChallenge, passwd);
if (memcmp(cl->authChallenge, response, CHALLENGESIZE) != 0) {
debug_printf("rfbAuthProcessClientMessage: authentication failed from %s\n",
cl->host);
authResult = Swap32IfLE(rfbVncAuthFailed);
if (WriteExact(cl, (char *)&authResult, 4) < 0) {
debug_printf("rfbAuthProcessClientMessage: write");
rfbClientSendString(cl,"challengdge failed\n");
}
rfbCloseClient(cl);
return;
}
else
{
debug_printf("challendge success ---cl=%s",cl->host);
}
authResult = Swap32IfLE(rfbVncAuthOK);
if (WriteExact(cl, (char *)&authResult, 4) < 0) {
debug_printf("rfbAuthProcessClientMessage: write");
rfbCloseClient(cl);
return;
}
cl->state = RFB_INITIALISATION;
}
/*
* rfbSendFence sends a fence message to a specific client
*/
Bool rfbSendFence(rfbClientPtr cl, CARD32 flags, unsigned len,
const char *data)
{
rfbFenceMsg f;
if (!cl->enableFence) {
rfbLog("ERROR in rfbSendFence: Client does not support fence extension\n");
return FALSE;
}
if (len > 64) {
rfbLog("ERROR in rfbSendFence: Fence payload is too large\n");
return FALSE;
}
if ((flags & ~rfbFenceFlagsSupported) != 0) {
rfbLog("ERROR in rfbSendFence: Unknown fence flags\n");
return FALSE;
}
f.type = rfbFence;
f.flags = Swap32IfLE(flags);
f.length = len;
if (WriteExact(cl, (char *)&f, sz_rfbFenceMsg) < 0) {
rfbLogPerror("rfbSendFence: write");
rfbCloseClient(cl);
return FALSE;
}
if (WriteExact(cl, (char *)data, len) < 0) {
rfbLogPerror("rfbSendFence: write");
rfbCloseClient(cl);
return FALSE;
}
return TRUE;
}
static int
SelectSecurityType(void)
{
CARD8 nSecTypes;
char *secTypeNames[] = {"None", "VncAuth"};
CARD8 knownSecTypes[] = {rfbSecTypeNone, rfbSecTypeVncAuth};
int nKnownSecTypes = sizeof(knownSecTypes);
CARD8 *secTypes;
CARD8 secType = rfbSecTypeInvalid;
int i, j;
/* Read the list of secutiry types. */
if (!ReadFromRFBServer((char *)&nSecTypes, sizeof(nSecTypes)))
return rfbSecTypeInvalid;
if (nSecTypes == 0) {
ReadConnFailedReason();
return rfbSecTypeInvalid;
}
secTypes = malloc(nSecTypes);
if (!ReadFromRFBServer((char *)secTypes, nSecTypes))
return rfbSecTypeInvalid;
/* Find out if the server supports TightVNC protocol extensions */
for (j = 0; j < (int)nSecTypes; j++) {
if (secTypes[j] == rfbSecTypeTight) {
free(secTypes);
secType = rfbSecTypeTight;
if (!WriteExact(rfbsock, (char *)&secType, sizeof(secType)))
return rfbSecTypeInvalid;
fprintf(stderr, "Enabling TightVNC protocol extensions\n");
return rfbSecTypeTight;
}
}
/* Find first supported security type */
for (j = 0; j < (int)nSecTypes; j++) {
for (i = 0; i < nKnownSecTypes; i++) {
if (secTypes[j] == knownSecTypes[i]) {
secType = secTypes[j];
if (!WriteExact(rfbsock, (char *)&secType, sizeof(secType))) {
free(secTypes);
return rfbSecTypeInvalid;
}
break;
}
}
if (secType != rfbSecTypeInvalid) break;
}
free(secTypes);
if (secType == rfbSecTypeInvalid)
fprintf(stderr, "Server did not offer supported security type\n");
return (int)secType;
}
Bool
SetFormatAndEncodings()
{
printf("--- SetFormatAndEncodings\n");
rfbSetPixelFormatMsg spf;
char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4];
rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf;
CARD32 *encs = (CARD32 *)(&buf[sz_rfbSetEncodingsMsg]);
int len = 0;
int i;
spf.type = rfbSetPixelFormat;
spf.format = myFormat;
spf.format.redMax = Swap16IfLE(spf.format.redMax);
spf.format.greenMax = Swap16IfLE(spf.format.greenMax);
spf.format.blueMax = Swap16IfLE(spf.format.blueMax);
spf.format.bigEndian = (*(char *)&endianTest ? 0 : 1);
if(!WriteExact(rfbsock, (char *)&spf, sz_rfbSetPixelFormatMsg))
return False;
se->type = rfbSetEncodings;
se->nEncodings = 0;
for(i = 0; i < nExplicitEncodings; i++)
{
encs[se->nEncodings++] = Swap32IfLE(explicitEncodings[i]);
}
if(SameMachine(rfbsock))
{
encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw);
}
if(addCopyRect)
encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect);
// if(addHextile)
// encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile);
// if(addCoRRE)
// encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCoRRE);
if(addRRE)
encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRRE);
if(addUseAlpha)
{
encs[se->nEncodings++] = Swap32IfLE(rfbEncSpecialUseAlpha);
printf("--- Set: rfbEncSpecialUseAlpha\n");
}
len = sz_rfbSetEncodingsMsg + se->nEncodings * 4;
se->nEncodings = Swap16IfLE(se->nEncodings);
if(!WriteExact(rfbsock, buf, len)) return False;
return True;
}
Bool
SendClientCutText(char *str, int len)
{
rfbClientCutTextMsg cct;
cct.type = rfbClientCutText;
cct.length = Swap32IfLE(len);
return(WriteExact(rfbsock, (char *)&cct, sz_rfbClientCutTextMsg) &&
WriteExact(rfbsock, str, len));
}
static Bool
PerformAuthenticationTight(void)
{
rfbAuthenticationCapsMsg caps;
CARD32 authScheme;
int i;
/* In the protocol version 3.7t, the server informs us about supported
authentication schemes. Here we read this information. */
if (!ReadFromRFBServer((char *)&caps, sz_rfbAuthenticationCapsMsg))
return False;
caps.nAuthTypes = Swap32IfLE(caps.nAuthTypes);
if (!caps.nAuthTypes) {
fprintf(stderr, "No authentication needed\n");
return True;
}
if (!ReadCapabilityList(authCaps, caps.nAuthTypes))
return False;
/* Prefer Unix login authentication if a user name was given. */
if (appData.userLogin && CapsIsEnabled(authCaps, rfbAuthUnixLogin)) {
authScheme = Swap32IfLE(rfbAuthUnixLogin);
if (!WriteExact(rfbsock, (char *)&authScheme, sizeof(authScheme)))
return False;
return AuthenticateUnixLogin();
}
/* Otherwise, try server's preferred authentication scheme. */
for (i = 0; i < CapsNumEnabled(authCaps); i++) {
authScheme = CapsGetByOrder(authCaps, i);
if (authScheme != rfbAuthUnixLogin && authScheme != rfbAuthVNC)
continue; /* unknown scheme - cannot use it */
authScheme = Swap32IfLE(authScheme);
if (!WriteExact(rfbsock, (char *)&authScheme, sizeof(authScheme)))
return False;
authScheme = Swap32IfLE(authScheme); /* convert it back */
if (authScheme == rfbAuthUnixLogin) {
return AuthenticateUnixLogin();
} else if (authScheme == rfbAuthVNC) {
return AuthenticateVNC();
} else {
/* Should never happen. */
fprintf(stderr, "Assertion failed: unknown authentication scheme\n");
return False;
}
}
fprintf(stderr, "No suitable authentication schemes offered by server\n");
return False;
}
static Bool
SetupTunneling(void)
{
rfbTunnelingCapsMsg caps;
CARD32 tunnelType;
/* In the protocol version 3.7t, the server informs us about
supported tunneling methods. Here we read this information. */
if (!ReadFromRFBServer((char *)&caps, sz_rfbTunnelingCapsMsg))
return False;
caps.nTunnelTypes = Swap32IfLE(caps.nTunnelTypes);
if (caps.nTunnelTypes) {
if (!ReadCapabilityList(tunnelCaps, caps.nTunnelTypes))
return False;
/* We cannot do tunneling anyway yet. */
tunnelType = Swap32IfLE(rfbNoTunneling);
if (!WriteExact(rfbsock, (char *)&tunnelType, sizeof(tunnelType)))
return False;
}
return True;
}
void NewClient(svcInfoPtr psvc, int sock)
{
int one=1;
if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&one, sizeof(one)) < 0) {
Err("setsockopt failed");
close(sock);
return;
}
psvc->sock = sock;
if (WriteExact(psvc, psvc->version, RUISVC_VERSION_LEN) < 0) {
Err("NewClient: write");
ExitClient(psvc);
return;
}
if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
Err("fcntl failed");
close(sock);
return;
}
//pthread_attr_t myattr;
//pthread_attr_init(&myattr);
pthread_create(&psvc->client_thread, NULL, clientInput, (void *)psvc);
void* rtn = 0;
pthread_join(psvc->client_thread, &rtn);
}
// adzm - 2010-07 - Extended clipboard
void ClientConnection::UpdateRemoteClipboardCaps(bool bSavePreferences)
{
omni_mutex_lock l(m_clipMutex);
if (!m_clipboard.settings.m_bSupportsEx) return;
ExtendedClipboardDataMessage extendedClipboardDataMessage;
if (m_opts.m_DisableClipboard || m_opts.m_ViewOnly) {
// messages and formats that we can handle
extendedClipboardDataMessage.m_pExtendedData->flags = Swap32IfLE(clipCaps | clipText | clipRTF | clipHTML | clipDIB);
// now include our limits in order of enum value
extendedClipboardDataMessage.AppendInt(0);
extendedClipboardDataMessage.AppendInt(0);
extendedClipboardDataMessage.AppendInt(0);
} else {
if (bSavePreferences) {
SaveClipboardPreferences();
}
m_clipboard.settings.PrepareCapsPacket(extendedClipboardDataMessage);
}
int actualLen = extendedClipboardDataMessage.GetDataLength();
rfbClientCutTextMsg message;
memset(&message, 0, sizeof(rfbClientCutTextMsg));
message.type = rfbClientCutText;
message.length = Swap32IfLE(-actualLen);
//adzm 2010-09
WriteExactQueue((char*)&message, sz_rfbClientCutTextMsg, rfbClientCutText);
WriteExact((char*)(extendedClipboardDataMessage.GetData()), extendedClipboardDataMessage.GetDataLength());
}
void CFileSender::DoSend()
{
m_bRun = true;
int nRead = 0;
m_bStopbyServer = false;
int nWriteCount = 100;
SendMessage(m_ParentHwnd, WM_SETSENDING, 1, 0);
SendMessage(m_ParentHwnd, WM_SETSTOPBYMYSEFLT, 0, 0);
while (nRead < m_pFile->GetLength())
{
if (m_bRun == false)
{
QueryStatus();
if (!PackAndSendRequest(CMD_PARAM_TRANSFILE_C2S_STOP))
{
SendMessage(m_ParentHwnd, WM_SETSENDING, 0, 0);
return;
}
break;
}
if (nWriteCount ++ >= 100)
{
nWriteCount = 0;
if (!QueryStatus())
{
SendMessage(m_ParentHwnd, WM_SETSENDING, 0, 0);
return ;
}
}
if (!PackAndSendRequest(CMD_PARAM_TRANSFILE_C2S_DATA))
{
SendMessage(m_ParentHwnd, WM_SETSENDING, 0, 0);
return;
}
FileData fileData;
int nCount = m_pFile->Read(fileData.Buf, 4096);
fileData.nLength = nCount;
if (!WriteExact(m_Socket, (char*)(&fileData), sizeof(fileData)))
{
MessageBox(m_ParentHwnd, "发送本地文件数据失败！", "提示", MB_OK | MB_ICONEXCLAMATION);
return;
}
nRead += nCount;
SendMessage(m_ParentHwnd, WM_FILE_SENDFILETOSERVER_PROGRESS_MESSAGE, (WPARAM)(nRead), 0);
}
}
Bool
SendKeyEvent(CARD32 key, Bool down)
{
rfbKeyEventMsg ke;
ke.type = rfbKeyEvent;
ke.down = down ? 1 : 0;
ke.key = Swap32IfLE(key);
return WriteExact(rfbsock, (char *)&ke, sz_rfbKeyEventMsg);
}
bool CFileSender::PackAndSendRequest(short nParam)
{
FilePackHeader header;
header.nType = FILE_REQUEST;
header.nParam = nParam;
if (!WriteExact(m_Socket, (char*)(&header), sizeof(header)))
{
return false;
}
return true;
}
Bool
SendPointerEvent(int x, int y, int buttonMask)
{
rfbPointerEventMsg pe;
pe.type = rfbPointerEvent;
pe.buttonMask = buttonMask;
if(x < 0) x = 0;
if(y < 0) y = 0;
pe.x = Swap16IfLE(x);
pe.y = Swap16IfLE(y);
return WriteExact(rfbsock, (char *)&pe, sz_rfbPointerEventMsg);
}
// =========================================================================
// 函数功能：处理客户端的安全类型信息
// 输入参数：待交流的客户端cl
// 输出参数：
// 返回值 ：
// 说明 ： 只有3.7及其以上版本的server才会让cl选择安全类型
// =========================================================================void
void rfbProcessClientSecurityType(rfbClientPtr cl)
{
int n;
u8 chosenType;
u32 authResult;
/* Read the security type. */
n = ReadExact(cl, (char *)&chosenType, 1);
if (n <= 0) {
if (n == 0)
debug_printf("rfbProcessClientSecurityType: client gone\n");
else
debug_printf("rfbProcessClientSecurityType: read");
rfbCloseClient(cl);
return;
}
/* Make sure it was present in the list sent by the server. */
switch (chosenType)
{
case rfbConnFailed:
debug_printf("The client %s connfailed!\n",cl->host);
cl->state = RFB_INITIALISATION;
break;
case rfbNoAuth:
debug_printf("The client %s need no auth!\n",cl->host);
//对于3.8版本仍然需要把结果返还回去
if((cl->protocolMajorVersion==3)&&(cl->protocolMinorVersion>7))
{
authResult = Swap32IfLE(rfbVncAuthOK);
if (WriteExact(cl, (char *)&authResult, 4) < 0) {
debug_printf("rfbAuthProcessClientMessage: write");
rfbCloseClient(cl);
break;
}
}
cl->state = RFB_INITIALISATION;
break;
case rfbVncAuth:
debug_printf("The client %s need vncauth!\n",cl->host);
rfbVncAuthSendChallenge(cl);//发送挑战信息
break;
default:
debug_printf("No supported security method--%d\n",chosenType);
rfbCloseClient(cl);
break;
}
return;
}
// =========================================================================
// 函数功能:处理连接失败的善后问题
// 输入参数:待连接的客户cl，连接失败的原因
// 输出参数：
// 返回值 :
// 说明 :当在协议版本协商或者是认证的时候失败，那么都会调用这个函数进行善后
// =========================================================================
void rfbClientConnFailed(rfbClientPtr cl,char *reason)
{
char *buf;
int len = strlen(reason);
buf = (char *)malloc(8 + len);
((u32 *)buf)[0] = Swap32IfLE(rfbConnFailed);
((u32 *)buf)[1] = Swap32IfLE(len);
memcpy(buf + 8, reason, len);
if (WriteExact(cl, buf, 8 + len) < 0)
debug_printf("rfbClientConnFailed: write");
free(buf);
rfbCloseClient(cl);
}
/*
* rfbSendEndOfCU sends an end of Continuous Updates message to a specific
* client
*/
void rfbSendEndOfCU(rfbClientPtr cl)
{
char type = rfbEndOfContinuousUpdates;
if (!cl->enableCU) {
rfbLog("ERROR in rfbSendEndOfCU: Client does not support Continuous Updates\n");
return;
}
if (WriteExact(cl, &type, 1) < 0) {
rfbLogPerror("rfbSendEndOfCU: write");
rfbCloseClient(cl);
return;
}
}
static void rfbProcessClientInitMessage(rfbClientPtr cl)
{
rfbClientInitMsg ci;
char buf[256];
rfbServerInitMsg *si = (rfbServerInitMsg *)buf;
int len, n;
if ((n = ReadExact(cl, (char *)&ci,sz_rfbClientInitMsg)) <= 0) {
if (n == 0)
debug_printf("rfbProcessClientInitMessage: client gone\n");
else
debug_printf("rfbProcessClientInitMessage: read");
rfbCloseClient(cl);
return;
}
si->framebufferWidth = Swap16IfLE(cl->screen->width);
si->framebufferHeight = Swap16IfLE(cl->screen->height);
debug_printf("width=%d hieght=%d\n",cl->screen->width,cl->screen->height);
si->format = cl->screen->rfbServerFormat;
si->format.redMax = Swap16IfLE(si->format.redMax);
si->format.greenMax = Swap16IfLE(si->format.greenMax);
si->format.blueMax = Swap16IfLE(si->format.blueMax);
if (strlen(cl->screen->desktopName) > 128) /* sanity check on desktop name len */
cl->screen->desktopName[128] = 0;
strcpy(buf + sz_rfbServerInitMsg, cl->screen->desktopName);
len = strlen(buf + sz_rfbServerInitMsg);
si->nameLength = Swap32IfLE(len);
if (WriteExact(cl, buf, sz_rfbServerInitMsg + len) < 0) {
debug_printf("rfbProcessClientInitMessage: write");
rfbCloseClient(cl);
return;
}
cl->state = RFB_NORMAL;
if(ci.shared)
{
debug_printf("The client permit share!\n");
}
else
{
debug_printf("The client refused share!\n");
}
//关于是否共享的问题，以后再谈
}
int
rfbSendSetColourMapEntries(rfbClientPtr cl,
int firstColour,
int nColours)
{
char buf[sz_rfbSetColourMapEntriesMsg + 256 * 3 * 2];
char *wbuf = buf;
rfbSetColourMapEntriesMsg *scme;
unsigned short *rgb;
int i, len;
if (nColours > 256) {
/* some rare hardware has, e.g., 4096 colors cells: PseudoColor:12 */
wbuf = (char *) malloc(sz_rfbSetColourMapEntriesMsg + nColours * 3 * 2);
}
scme = (rfbSetColourMapEntriesMsg *)wbuf;
rgb = (u16 *)(&wbuf[sz_rfbSetColourMapEntriesMsg]);
scme->type = rfbSetColourMapEntries;
scme->firstColour = Swap16IfLE(firstColour);
scme->nColours = Swap16IfLE(nColours);
len = sz_rfbSetColourMapEntriesMsg;
for (i = 0; i < nColours; i++) {
rgb[i*3] = Swap16IfLE(i);
rgb[i*3+1] = Swap16IfLE(i);
rgb[i*3+2] = Swap16IfLE(i);
}
len += nColours * 3 * 2;
if (WriteExact(cl, wbuf, len) < 0) {
debug_printf("rfbSendSetColourMapEntries: write");
rfbCloseClient(cl);
if (wbuf != buf)
free(wbuf);
return FALSE;
}
if (wbuf != buf) free(wbuf);
return TRUE;
}
static Bool
PerformAuthenticationTight(void)
{
rfbAuthenticationCapsMsg caps;
CARD32 authScheme;
int i;
/* In protocols 3.7t/3.8t, the server informs us about supported
authentication schemes. Here we read this information. */
if (!ReadFromRFBServer((char *)&caps, sz_rfbAuthenticationCapsMsg))
return False;
caps.nAuthTypes = Swap32IfLE(caps.nAuthTypes);
/* Special case - empty capability list stands for no authentication. */
if (!caps.nAuthTypes)
return AuthenticateNone();
if (!ReadCapabilityList(authCaps, caps.nAuthTypes))
return False;
/* Try server's preferred authentication scheme. */
for (i = 0; i < CapsNumEnabled(authCaps); i++) {
authScheme = CapsGetByOrder(authCaps, i);
if (authScheme != rfbAuthVNC && authScheme != rfbAuthNone)
continue; /* unknown scheme - cannot use it */
authScheme = Swap32IfLE(authScheme);
if (!WriteExact(rfbsock, (char *)&authScheme, sizeof(authScheme)))
return False;
authScheme = Swap32IfLE(authScheme); /* convert it back */
switch (authScheme) {
case rfbAuthNone:
return AuthenticateNone();
case rfbAuthVNC:
return AuthenticateVNC();
default: /* should never happen */
fprintf(stderr, "Internal error: Invalid authentication type\n");
return False;
}
}
fprintf(stderr, "No suitable authentication schemes offered by server\n");
return False;
}
Bool
SendFramebufferUpdateRequest(int x, int y, int w, int h, Bool incremental)
{
rfbFramebufferUpdateRequestMsg fur;
fur.type = rfbFramebufferUpdateRequest;
fur.incremental = incremental ? 1 : 0;
fur.x = Swap16IfLE(x);
fur.y = Swap16IfLE(y);
fur.w = Swap16IfLE(w);
fur.h = Swap16IfLE(h);
if (!WriteExact(rfbsock, (char *)&fur, sz_rfbFramebufferUpdateRequestMsg))
return False;
return True;
}
void RA::key_event(int key, int mode)
{
char buf[1024];
if( m_monkeysock == INVALID_SOCKET )
return;
if( mode == 0 )
sprintf_s(buf, "key up %d\n", key);
else if ( mode == 1 )
sprintf_s(buf, "key down %d\n", key);
else
sprintf_s(buf, "key down %d\nkey up %d\n", key, key);
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
void ClientConnection::RequestRemoteClipboard()
{
if (!m_clipboard.settings.m_bSupportsEx) return;
ExtendedClipboardDataMessage extendedClipboardDataMessage;
int actualLen = extendedClipboardDataMessage.GetDataLength();
extendedClipboardDataMessage.AddFlag(clipRequest | clipText | clipRTF | clipHTML | clipDIB);
rfbClientCutTextMsg message;
memset(&message, 0, sizeof(rfbClientCutTextMsg));
message.type = rfbClientCutText;
message.length = Swap32IfLE(-actualLen);
//adzm 2010-09
WriteExactQueue((char*)&message, sz_rfbClientCutTextMsg, rfbClientCutText);
WriteExact((char*)(extendedClipboardDataMessage.GetData()), extendedClipboardDataMessage.GetDataLength());
}
void RA::key_search(bool bDown)
{
#ifdef USE_UINPUT
raw_key(bDown, 217);
return;
#endif
//ta_log("TDC KEYCODE_SEARCH");
if( m_monkeysock == INVALID_SOCKET )
return;
char buf[1024];
//sprintf_s(buf, "press %d\n", AKEYCODE_SEARCH);
if( bDown )
sprintf_s(buf, "key down %d\n", AKEYCODE_SEARCH);
else
sprintf_s(buf, "key up %d\n", AKEYCODE_SEARCH);
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
void RA::key_power(bool bDown)
{
#ifdef USE_UINPUT
raw_key(bDown, 116);
return;
#endif
//ta_log("TDC sleep device");
if( m_monkeysock == INVALID_SOCKET )
return;
char buf[1024];
//sprintf_s(buf, "press %d\n", AKEYCODE_POWER);
if( bDown )
sprintf_s(buf, "key down %d\n", AKEYCODE_POWER);
else
sprintf_s(buf, "key up %d\n", AKEYCODE_POWER);
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
void RA::key_camera(bool bDown)
{
#ifdef USE_UINPUT
raw_key(bDown, 212);
return;
#endif
//ta_log("TDC KEYCODE_CAMERA");
if( m_monkeysock == INVALID_SOCKET )
return;
char buf[1024];
//sprintf_s(buf, "type abcdefg\n");
//sprintf_s(buf, "press %d\n", AKEYCODE_CAMERA);
if( bDown )
sprintf_s(buf, "key down %d\n", AKEYCODE_CAMERA);
else
sprintf_s(buf, "key up %d\n", AKEYCODE_CAMERA);
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
void RA::key_menu(bool bDown)
{
#ifdef USE_UINPUT
raw_key(bDown, 139);
return;
#endif
//tdc_getinstalledpkgname();
//ta_log("TDC KEYCODE_MENU");
if( m_monkeysock == INVALID_SOCKET )
return;
char buf[1024];
//sprintf_s(buf, "press %d\n", AKEYCODE_MENU);
if( bDown )
sprintf_s(buf, "key down %d\n", AKEYCODE_MENU);
else
sprintf_s(buf, "key up %d\n", AKEYCODE_MENU);
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
void RA::key_wake()
{
#ifdef USE_UINPUT
raw_key(1, 116); // power
raw_key(0, 116);
raw_key(1, 102); // home
raw_key(0, 102);
raw_key(1, 158); // back
raw_key(0, 158);
return;
#endif
//ta_log("TDC wake device");
if( m_monkeysock == INVALID_SOCKET )
return;
char buf[1024];
sprintf_s(buf, "wake\n");
//sprintf_s(buf, "press 187\n");
WriteExact(m_monkeysock, buf, strlen(buf));
key_checkok();
}
Bool
SetScaleFactor()
{
rfbSetScaleFactorMsg sf;
sf.type = rfbSetScaleFactor;
sf.scale = serverScaleFactor;
printf("Sending scale %d request to rfb server\n",serverScaleFactor);
if(!WriteExact(rfbsock, (char *)&sf, sz_rfbSetScaleFactorMsg))
return False;
else
{
/* printf("Waiting for answer\n");
rfbReSizeFrameBufferMsg sfb;
if(!ReadExact(rfbsock, (char *)&sfb, sz_rfbReSizeFrameBufferMsg)) return False;
// if(sfb.type!=rfbReSizeFrameBuffer)
printf("rfbReSizeFrameBuffer: %d/%d | %d/%d\n",sfb.buffer_w,sfb.buffer_h,sfb.desktop_w,sfb.desktop_h);
si.framebufferWidth = Swap16IfLE(sfb.buffer_w);
si.framebufferHeight = Swap16IfLE(sfb.buffer_h);*/
}
return True;
}
Bool
SendFramebufferUpdateRequest(int x, int y, int w, int h, Bool incremental)
{
dprintf("SendFramebufferUpdateRequest\n");
rfbFramebufferUpdateRequestMsg fur;
fur.type = rfbFramebufferUpdateRequest;
fur.incremental = incremental ? 1 : 0;
fur.x = Swap16IfLE(x);
fur.y = Swap16IfLE(y);
fur.w = Swap16IfLE(w);
fur.h = Swap16IfLE(h);
if(!WriteExact(rfbsock, (char *)&fur, sz_rfbFramebufferUpdateRequestMsg))
{
return False;
}
gettimeofday(&updateRequestTime, NULL);
sendUpdateRequest = False;
return True;
}
/*
* abcdefghijklmnopqrstuvwxyz
* e hi klmno q t u
* | || ||||| | | |
* | || ||||| | | +get screen (full res)
* | || ||||| | + touch(down,x,y)
* | || ||||| +quit client
* | || ||||+ftp_err
* | || |||+ftp_data
* | || ||+ftp_upload_req
* | || |+ftp_download_req
* | || +ftp_filelist_req
* | |+get screen info
* | +get screen (half req)
* +stop service
*/
static int ProcessClientMessage(svcInfoPtr psvc, FBCCMD* pmsg)
{
//FBCCMD msg;
//char msg;
int n = 0;
int nSize;
//if( (n = ReadExact(psvc, (char*)&msg, FBCCMD_HEADER)) <= 0 ) {
// Err("ProcessClientMessage : read(%d)\n", n);
// return false;
//}
pmsg->size = ntohl(pmsg->size);
pmsg->size -= FBCCMD_HEADER;
//Log("msg received(%c: size - %d)\n", pmsg->cmd, pmsg->size);
if( pmsg->size > 0) {
pmsg->data = (char*)malloc(pmsg->size);
if( (n = ReadExact(psvc, (char*)pmsg->data, pmsg->size)) <= 0 ) {
Err("ProcessClientMessage : read(%d)\n", n);
return false;
}
}
//Log("after alloc %02x %02x %02x %02x\n", msg.data[0],msg.data[1],msg.data[2],msg.data[3]);
unsigned int data;
#ifdef PERFORMANCE_REPORT
struct timeval tS, tE;
gettimeofday(&tS,NULL);
psvc->frame_client += ELAPSED(tLast, tS);
#endif
switch(pmsg->cmd) {
case 'i':
{
FBCCMD_SCRINFO res;
res.cmd = 'i';
res.size = htonl(sizeof(FBCCMD_SCRINFO));
res.width = htonl(g_fbinfo.width);
res.height = htonl(g_fbinfo.height);
res.bpp = htonl(g_fbinfo.bpp);
res.touchfd = htonl( (touchfd != -1 ) ? 1 : 0);
LOCK(psvc->output_mutex);
int rtn = WriteExact(psvc, (const char*)&res, sizeof(FBCCMD_SCRINFO));
UNLOCK(psvc->output_mutex);
//Log("response i %d to :%d\n", res.size, rtn);
}
break;
case 'u':
//Log("signal-u\n");
g_halfmode = 0;
//TSIGNAL(psvc->updateCond);
read_rgb_framebuffer_to_jpeg(psvc);
#ifdef PERFORMANCE_REPORT
gettimeofday(&tE,NULL);
psvc->frame_total += ELAPSED(tS, tE);
tS = tE;
#endif
break;
case 'h':
g_halfmode = 1;
//Log("signal-h\n");
//TSIGNAL(psvc->updateCond);
//g_halfmode = 0;
read_rgb_framebuffer_to_jpeg(psvc);
#ifdef PERFORMANCE_REPORT
gettimeofday(&tE,NULL);
psvc->frame_total += ELAPSED(tS, tE);
tS = tE;
#endif
break;
case 'e':
return false;
break;
case 'q':
ExitClient(psvc);
ShutdownSockets(psvc);
break;
// ftp
case 'k': // ftp filestlist req
onFilelistReq(psvc, pmsg);
break;
case 'l': // ftp filedownload req
onFileDownloadReq(psvc, pmsg);
break;
case 'm': // ftp fileupload req
onFileUploadReq(psvc, pmsg);
break;
case 'n': // ftp fileupload data
//Log("case n\n");
onFileMsg(psvc, pmsg);
break;
case 'o': // ftp fileerr
onFileErr(psvc, pmsg);
break;
case 't':
onTouch(psvc, pmsg);
break;
}
if( pmsg->size > 0) {
free(pmsg->data);
}
//if(( psvc->frame_sent++ % 5) == 0) {
// g_fbinfo.orientation = get_dev_rotation();
// //int isScreenOn = get_screen_on();
// //Log("isScreenOn(%d)\n",isScreenOn);
//}
#ifdef PERFORMANCE_REPORT
if( (psvc->frame_sent % 10) == 0)
{
double frame_total;
double frame_capture;
double frame_compress;
double frame_colorspace;
double frame_tx;
double frame_client;
double fps, fps_svr;
fps = (double)10 * 1000000 / (psvc->frame_total + psvc->frame_client);
fps_svr = (double)10 * 1000000 / psvc->frame_total;
frame_total = psvc->frame_total / 10000;
frame_capture = psvc->frame_capture / 10000;
frame_compress = psvc->frame_compress / 10000;
frame_colorspace = psvc->frame_colorspace / 10000;
frame_tx = psvc->frame_tx / 10000;
frame_client = psvc->frame_client / 10000;
if( psvc->frame_sent > 10 )
{
Log("FPS(%5.2f),SVR(%4.1f) TOT(%3.0f),CAP(%3.0f),ZIP(%3.0f),CNV(%2.0f),TX(%2.0f),CLI(%2.0f)\n",
//psvc->frame_sent-1,
fps, fps_svr,
frame_total, frame_capture, frame_compress, frame_colorspace, frame_tx,frame_client);
}
psvc->frame_total = 0;
psvc->frame_capture = 0;
psvc->frame_compress = 0;
psvc->frame_colorspace = 0;
psvc->frame_tx = 0;
psvc->frame_client = 0;
}
gettimeofday(&tLast,NULL);
#endif /* PERFORMANCE_REPORT */
// Log("end loop");
return true;
}
