rogateway.cpp

teamviewer source code vc++

	//don't check for valid checksum any more - user should see that ID is invalid / mistyped
	//return id > 0 && (id%7 == 0 || id%7 == 1);	// is it a valid ClientID/temporary ClientID?
	return id > 0;
}

bool CroGateway::GatewayRunning()
{
	// m_installed has to be checked to detect if an old version might be running
	if (!m_installed || m_destroying)
		return false;

	/* Check if DynGate is running */
	HANDLE dyngatemutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"DynGateInstanceMutex");
	SetLastError(0);				// the error number is not needed, don't log it 

	if (!dyngatemutex)
		return false;	
	else
	{
		CloseHandle(dyngatemutex);
		return true;
	}
}


SOCKET CroGateway::NewSocket()
{
	if (m_destroying)
		return INVALID_SOCKET;

	SOCKET newsock;
	struct sockaddr_in thataddr;
	int res;
	
	newsock = socket(PF_INET, SOCK_STREAM, 0);
	if (newsock == INVALID_SOCKET) 
	{
		vnclog.Print(LL_INTERR,VNCLOG("DynGate NewSocket.NoSocket"));
		return INVALID_SOCKET;
	}

	thataddr.sin_addr.s_addr = inet_addr(GatewayListenHost());
	thataddr.sin_family = AF_INET;
	thataddr.sin_port = htons(GatewayListenPort());
	
	res = connect(newsock, (LPSOCKADDR) &thataddr, sizeof(thataddr));
	if (res == SOCKET_ERROR)
	{
		closesocket(newsock);
		vnclog.Print(LL_INTERR,VNCLOG("DynGate NewSocket ConnectError"));
		// DynGate might hang - kill the process and try again
		KillGateway();
		Sleep(500);
		StartGateway();
		Sleep(1000); // Wait a bit longer with the 2. try...
		return INVALID_SOCKET;
	}
	else
	{
		vnclog.Print(LL_INTINFO, VNCLOG("Connected to DynGate on port %s:%d"), 
			GatewayListenHost(), GatewayListenPort());
		// Immediately send MESSAGETYPE_LOGIN
		// Required by DynGate to detect new protocol version
		SendCommand(MESSAGETYPE_LOGIN, TEAMVIEWER_VERSION, newsock);
		return newsock;
	}
}

bool CroGateway::BeginWaitAtMaster(bool internet)
{
	if (!GatewayInstalled() || m_destroying)
		return false;

	// Already connecting?
	while (m_connecting && !m_destroying)
		Sleep(10);

	if (m_waitingatmaster)
		return true;
	if (m_destroying)
		return false;

	m_connecting = true;

	vnclog.Print(LL_INTINFO,VNCLOG("DynGate WaitAtMaster"));

	/* Check if DynGate is running, if not, startup */
	if (!GatewayRunning())
	{
		// Start DynGate
		StartGateway();
		Sleep(500);
	}

	if(m_sock != INVALID_SOCKET)
		closesocket(m_sock);
	m_sock = NewSocket();

	m_connecting = false;

	if (m_sock != INVALID_SOCKET && menu && menu->m_server)
	{
		m_waitingatmaster = true;
		stringstream ss;
		ss << VNCCONNECTPORT << ":" << menu->m_server->GetPort();
		string s = ss.str();
		SendCommand(MESSAGETYPE_SEND, s);
		vnclog.Print(LL_INTINFO, VNCLOG("BeginWaitAtMaster send %s"), s.c_str());
		return true;
	}
	else
		return false;
}

void CroGateway::EndWaitAtMaster(char *lor /*=NULL*/)
{
	vnclog.Print(LL_INTINFO,VNCLOG("DynGate EndWaitAtMaster"));

	if (m_waitingatmaster && m_sock != INVALID_SOCKET) 
	{
		// Send logout-reason so DynGate can decide what to do next
		SendCommand(MESSAGETYPE_LOGOUT, string(lor));
		Sleep(500);
		m_waitingatmaster = false;
		shutdown(m_sock, 2);
		closesocket(m_sock);
		m_sock = INVALID_SOCKET;
	}
}

SOCKET CroGateway::ConnectOverGateway(char *destClient)
{
	if (m_destroying)
		return INVALID_SOCKET;

	vnclog.Print(LL_INTINFO,VNCLOG("DynGate Connect to %s"),destClient);
	SOCKET newsock = NewSocket();
	//Sleep(500);
	if(newsock!=INVALID_SOCKET && SendCommand(MESSAGETYPE_CONNECT, string(destClient), newsock))
		return newsock;
	else
		return INVALID_SOCKET;	
}

void CroGateway::ShowFreeUpgradeDialog()
{
	SendCommand(MESSAGETYPE_DIALOG, "");
}

// Close DynGate
void CroGateway::Shutdown()
{
	if (IsServer() || IsVPN() || !GatewayRunning())			// Don't shut down servers
		return; 

	vnclog.Print(LL_INTINFO,VNCLOG("DynGate Shutdown"));

	HWND h=FindWindow(NULL,"DynGate");

	if (h)
		PostMessage(h,WM_COMMAND,4030,0); // CS: 4030 is ID_CLOSE in DynGate, which is a custom defined command
	m_waitingatmaster = false;
}

// Show dialogs
void CroGateway::ShowOptions()
{
	HWND h=FindWindow(NULL,"DynGate");

	if (h)
		PostMessage(h,WM_COMMAND,4027,0); 
}

void CroGateway::ShowActivateLicense()
{
	HWND h=FindWindow(NULL,"DynGate");

	if (h)
		PostMessage(h,WM_COMMAND,4035,0); 
}

void CroGateway::ShowConnectivity()
{
	HWND h=FindWindow(NULL,"DynGate");

	if (h)
		PostMessage(h,WM_COMMAND,4038,0); 
}

void CroGateway::PostServiceHelperMessage(long processId)
{
	HWND dynGate = FindWindow(NULL,"DynGate");
	const int WM_SERVICE_HELPER=4037;
	// Staudenmeyer this seems to have changed
	PostMessage(dynGate,WM_COMMAND,WM_SERVICE_HELPER,0);
}

void CroGateway::StartGateway()
{
	if (m_destroying || m_noRestart)
		return;

	vnclog.Print(LL_INTINFO,VNCLOG("DynGate Startup from %s"),m_installpath);

	if (!GatewayRunning())
	{
		// Start DynGate
		if (isQSCustom)
			int i = (int)ShellExecute(NULL, "open", m_installpath,"-qsc2",0,SW_SHOW); // v2: No registry required
		else if (isQuickSupport)
			int i = (int)ShellExecute(NULL, "open", m_installpath,"-qs2",0,SW_SHOW); // v2: No registry required
		else if (isNoSave) // TeamViewer Portable
			int i = (int)ShellExecute(NULL, "open", m_installpath,"-nosave",0,SW_SHOW);
		else
			int i = (int)ShellExecute(NULL, "open", m_installpath,0,0,SW_SHOW);
	}
}

// Kill DynGate (only required if process hangs)
void CroGateway::KillGateway(bool noRestart /*=false*/)
{
	vnclog.Print(LL_INTWARN,VNCLOG("DynGate KillGateway"));
	if (noRestart)
	{
		m_noRestart = true;
	}

	CKillProcess kp;
	// Get name of exe
	char name[100];
	char *pos = strrchr(m_installpath,'\\');
	if(pos)
	{
		strcpy(name, pos+1);
		kp.KillProcess(name);
	}
}

bool CroGateway::PollDynGate()
{
	if (m_polling || m_destroying)
		return false;

	if(!NumericID())
		vnclog.Print(LL_INTINFO, VNCLOG("PollDynGate()"));
	m_polling = true;

	TIMEVAL waitval;
	fd_set socks;
	int bytes, received, socketsready;
	_roGatewayData msg;
	char *buffer = NULL;

	memset(&waitval, 0, sizeof(waitval));
	//waitval.tv_sec  = 1;
	//waitval.tv_usec = 0;  // Mikrosekunden
	FD_ZERO(&socks);
	FD_SET(m_sock, &socks);
	
	string oldClientID = m_Variables[CLIENTID];
	string oldVersion = m_Variables[VERSION];
	string oldLicense = m_Variables[LICENSETYPE];

	while( (socketsready = select(0, &socks, 0, &socks, &waitval)) > 0)
	{
		bytes = sizeof(msg);
		received = recv(m_sock, (char*)&msg, bytes, 0);
		if(received == SOCKET_ERROR)
		{
			vnclog.Print(LL_SOCKERR, VNCLOG("1. recv() error DynGate"));
			goto reconnect;
		}
		if(received != bytes)
		{
			vnclog.Print(LL_SOCKERR, VNCLOG("1. recv() %d bytes received, %d expected"), received, bytes);
			goto reconnect;
		}

		if(msg.ParamLength == 0)
		{
			m_polling = false;
			return true;
		}

		// Win98: FD struct is reset, so set it again
		FD_ZERO(&socks);
		FD_SET(m_sock, &socks);
		if(select(0, &socks, 0, &socks, &waitval) == SOCKET_ERROR)
		{
			vnclog.Print(LL_SOCKERR, VNCLOG("2. select() DynGate"));
			goto reconnect;
		}

		bytes = msg.ParamLength;
		buffer = new char[bytes+1];
		buffer[bytes] = '\0';
		received = recv(m_sock, buffer, bytes, 0);
		if(received == SOCKET_ERROR)
		{
			vnclog.Print(LL_SOCKERR, VNCLOG("2. recv() error DynGate"));
			goto reconnect;
		}
		if(received != bytes)
		{
			vnclog.Print(LL_SOCKERR, VNCLOG("2. recv() %d bytes received, %d expected"), received, bytes);
			goto reconnect;
		}
		if(!NumericID())
			vnclog.Print(LL_INTINFO, VNCLOG("received %d bytes "), received);

		switch(msg.MessageType)
		{
			case MESSAGETYPE_SEND:
				char *pos = strchr(buffer, ':');
				if(!pos)
					break;
				string value = string(pos+1);
				*pos = '\0';
				string key = string(buffer);
				m_Variables[key] = value;
				break;
		}
		if(buffer)
		{
			delete []buffer;
			buffer = NULL;
		}

		// Win98: FD struct is reset, so set it again
		FD_ZERO(&socks);
		FD_SET(m_sock, &socks);
	}
	if(!NumericID())
		vnclog.Print(LL_INTINFO, VNCLOG("socketsready = %d"), socketsready);

	if(socketsready == SOCKET_ERROR)
	{
		vnclog.Print(LL_SOCKERR, VNCLOG("1. select() DynGate"));
		goto reconnect;
	}

	if(oldClientID != m_Variables[CLIENTID] ||
	   oldVersion != m_Variables[VERSION] ||
	   oldLicense != m_Variables[LICENSETYPE])
	{
		TeamviewerInfo::setLocalInfo(tvID, m_Variables[CLIENTID]);
		vnclog.Print(LL_INTINFO, VNCLOG("DynGate: ID=%s Version=%s License=%s"), 
			m_Variables[CLIENTID].data(), m_Variables[VERSION].data(), m_Variables[LICENSETYPE].data());
	}

	m_polling = false;
	return true;

reconnect:
	if(buffer)
		delete []buffer;
	Reconnect();
	m_polling = false;
	return false;
}

void CroGateway::Reconnect()
{
	m_waitingatmaster = false;
	shutdown(m_sock, 2);
	closesocket(m_sock);
	m_sock = INVALID_SOCKET;
	BeginWaitAtMaster(true);
}


bool CroGateway::SendCommand(int msgtype, string param, SOCKET sock /* =INVALID_SOCKET */)
{
	if (m_destroying)
		return false;

	if(sock == INVALID_SOCKET)
		sock = m_sock;

	if (sock == INVALID_SOCKET)
	{
		vnclog.Print(LL_SOCKERR, VNCLOG("SendCommand invalid socket"));
		return false;
	}

	_roGatewayData msg;
	msg.MessageType = msgtype;
	msg.ParamLength = param.length();
	
	int buflen = sizeof(msg) + msg.ParamLength;
	char *buffer = new char[buflen];
	memcpy(buffer, &msg, sizeof(msg));
	memcpy(buffer+sizeof(msg), param.data(), msg.ParamLength);
	int sent = send(sock, buffer, buflen, 0);

	delete []buffer;

	if(sent != buflen)
	{
		vnclog.Print(LL_SOCKERR, VNCLOG("send() result=%d, should be %d"), sent, buflen);
		Reconnect();
		return false;
	}
	return true;
}

std::string CroGateway::getLicenseName()
{
	return m_Variables[LICENSENAME];
}

bool CroGateway::QueryClientID()
{ 
	if(!NumericID())
		vnclog.Print(LL_INTINFO, VNCLOG("SendCommand(MESSAGETYPE_REQUESTSETTINGS)"));
	return SendCommand(MESSAGETYPE_REQUESTSETTINGS, "");
}

void CroGateway::HostMode(bool hostmode)
{
	if (hostmode)
		SendCommand(MESSAGETYPE_SEND, "HostMode:1");
	else
		SendCommand(MESSAGETYPE_SEND, "HostMode:0");
}