Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
hash_algorithms	[ DIR ]	drwxrwxrwx
includes	[ DIR ]	drwxrwxrwx
install	[ DIR ]	drwxrwxrwx
interface	[ DIR ]	drwxrwxrwx
misc	[ DIR ]	drwxrwxrwx
res	[ DIR ]	drwxrwxrwx
tinyxml	[ DIR ]	drwxrwxrwx
Accounts.cpp	12.2 KB	-rw-rw-rw-
Accounts.h	2.12 KB	-rw-rw-rw-
AdminInterface.cpp	3.1 KB	-rw-rw-rw-
AdminInterface.h	1.77 KB	-rw-rw-rw-
AdminListenSocket.cpp	1.64 KB	-rw-rw-rw-
AdminListenSocket.h	1.58 KB	-rw-rw-rw-
AdminSocket.cpp	9.85 KB	-rw-rw-rw-
AdminSocket.h	2.1 KB	-rw-rw-rw-
AsyncGssSocketLayer.cpp	30.35 KB	-rw-rw-rw-
AsyncGssSocketLayer.h	4.76 KB	-rw-rw-rw-
AsyncSocketEx.cpp	51.94 KB	-rw-rw-rw-
AsyncSocketEx.h	11.75 KB	-rw-rw-rw-
AsyncSocketExLayer.cpp	26.22 KB	-rw-rw-rw-
AsyncSocketExLayer.h	7 KB	-rw-rw-rw-
AsyncSslSocketLayer.cpp	60.12 KB	-rw-rw-rw-
AsyncSslSocketLayer.h	8.94 KB	-rw-rw-rw-
ControlSocket.cpp	96.33 KB	-rw-rw-rw-
ControlSocket.h	4.74 KB	-rw-rw-rw-
ExternalIpCheck.cpp	7.82 KB	-rw-rw-rw-
ExternalIpCheck.h	1.85 KB	-rw-rw-rw-
FileLogger.cpp	6.68 KB	-rw-rw-rw-
FileLogger.h	1.35 KB	-rw-rw-rw-
FileZilla server.rc	2.65 KB	-rw-rw-rw-
FileZilla server.sln	2.75 KB	-rw-rw-rw-
FileZilla server.vcproj	39.95 KB	-rw-rw-rw-
ListenSocket.cpp	4.23 KB	-rw-rw-rw-
ListenSocket.h	2.29 KB	-rw-rw-rw-
MFC64bitFix.cpp	2.56 KB	-rw-rw-rw-
MFC64bitFix.h	1.45 KB	-rw-rw-rw-
OptionLimits.h	1022 B	-rw-rw-rw-
OptionTypes.h	6.46 KB	-rw-rw-rw-
Options.cpp	31.81 KB	-rw-rw-rw-
Options.h	2.59 KB	-rw-rw-rw-
Permissions.cpp	61.53 KB	-rw-rw-rw-
Permissions.h	6.82 KB	-rw-rw-rw-
Server.cpp	42.34 KB	-rw-rw-rw-
Server.h	2.05 KB	-rw-rw-rw-
ServerThread.cpp	26.13 KB	-rw-rw-rw-
ServerThread.h	4.21 KB	-rw-rw-rw-
Service.cpp	15.23 KB	-rw-rw-rw-
SpeedLimit.cpp	6.87 KB	-rw-rw-rw-
SpeedLimit.h	1.96 KB	-rw-rw-rw-
StdAfx.cpp	4.41 KB	-rw-rw-rw-
StdAfx.h	4.93 KB	-rw-rw-rw-
Thread.cpp	2.85 KB	-rw-rw-rw-
Thread.h	1.87 KB	-rw-rw-rw-
TransferSocket.cpp	28.72 KB	-rw-rw-rw-
TransferSocket.h	3.62 KB	-rw-rw-rw-
autobanmanager.cpp	3.44 KB	-rw-rw-rw-
autobanmanager.h	1.46 KB	-rw-rw-rw-
config.h	1.52 KB	-rw-rw-rw-
conversion.cpp	1.95 KB	-rw-rw-rw-
conversion.h	435 B	-rw-rw-rw-
defs.h	1.03 KB	-rw-rw-rw-
hash_thread.cpp	4.79 KB	-rw-rw-rw-
hash_thread.h	930 B	-rw-rw-rw-
iputils.cpp	10.87 KB	-rw-rw-rw-
iputils.h	1.32 KB	-rw-rw-rw-
platform.h	1.43 KB	-rw-rw-rw-
resource.h	515 B	-rw-rw-rw-
version.cpp	4.32 KB	-rw-rw-rw-
version.h	881 B	-rw-rw-rw-
xml_utils.cpp	487 B	-rw-rw-rw-
xml_utils.h	236 B	-rw-rw-rw-

Code Editor : Accounts.cpp

#include "stdafx.h"
#include "accounts.h"
#include "iputils.h"

t_directory::t_directory()
{
	bAutoCreate = FALSE;
}

t_group::t_group()
{
	pOwner = NULL;

for (int i = 0; i < 2; i++)
	{
		nSpeedLimitType[i] = 0;
		nSpeedLimit[i] = 10;
		nBypassServerSpeedLimit[i] = 0;
	}
	nEnabled = 1;
	forceSsl = 0;
}

t_group& t_group::operator=(const t_group &a)
{
	group = a.group;
	nBypassUserLimit = a.nBypassUserLimit;
	nUserLimit = a.nUserLimit;
	nIpLimit = a.nIpLimit;
	permissions = a.permissions;
	nEnabled = a.nEnabled;
	disallowedIPs = a.disallowedIPs;
	allowedIPs = a.allowedIPs;
	comment = a.comment;
	forceSsl = a.forceSsl;

for (int i = 0; i < 2; i++)
	{
		nBypassServerSpeedLimit[i] = a.nBypassServerSpeedLimit[i];
		nSpeedLimit[i] = a.nSpeedLimit[i];
		nSpeedLimitType[i] = a.nSpeedLimitType[i];
		SpeedLimits[i] = a.SpeedLimits[i];
	}

return *this;
}

bool t_group::BypassUserLimit() const
{
	if (!nBypassUserLimit)
		return false;
	if (nBypassUserLimit == 2 && pOwner)
		return pOwner->BypassUserLimit();
	return true;
}

int t_group::GetIpLimit() const
{
	if (nIpLimit)
		return nIpLimit;
	if (pOwner)
		return pOwner->GetIpLimit();
	return 0;
}

int t_group::GetUserLimit() const
{
	if (nUserLimit)
		return nUserLimit;
	if (pOwner)
		return pOwner->GetUserLimit();
	return 0;
}

t_user::t_user()
{
}

t_user& t_user::operator=(const t_user &a)
{
	group = a.group;
	pOwner = a.pOwner;
	user=a.user;
	password=a.password;
	nBypassUserLimit = a.nBypassUserLimit;
	nUserLimit = a.nUserLimit;
	nIpLimit = a.nIpLimit;
	permissions = a.permissions;
	nEnabled = a.nEnabled;
	disallowedIPs = a.disallowedIPs;
	allowedIPs = a.allowedIPs;
	comment = a.comment;
	forceSsl = a.forceSsl;

return *this;
}

unsigned char * t_group::ParseBuffer(unsigned char *pBuffer, int length)
{
	unsigned char *p = pBuffer;
	unsigned char *endMarker = pBuffer + length;

if (!ParseString(endMarker, p, group))
		return 0;

if ((endMarker - p) < 11)
		return NULL;

memcpy(&nIpLimit, p, 4);
	p += 4;
	memcpy(&nUserLimit, p, 4);
	p += 4;

int options = *p++;

nBypassUserLimit	= options & 0x03;
	nEnabled			= (options >> 2) & 0x03;

// Parse IP filter rules.
	int numDisallowedIPs = (int(*p) << 8) + p[1];
	p += 2;
	while (numDisallowedIPs--)
	{
		CStdString ip;
		if (!ParseString(endMarker, p, ip))
			return 0;

if (IsValidAddressFilter(ip) || ip == _T("*"))
			disallowedIPs.push_back(ip);
	}

if ((endMarker - p) < 2)
		return NULL;

int numAllowedIPs = (int(*p) << 8) + p[1];
	p += 2;
	while (numAllowedIPs--)
	{
		CStdString ip;
		if (!ParseString(endMarker, p, ip))
			return 0;

if (IsValidAddressFilter(ip) || ip == _T("*"))
			allowedIPs.push_back(ip);
	}

if ((endMarker - p) < 2)
		return NULL;

int dircount = (int(*p) << 8) + p[1];
	p += 2;

BOOL bGotHome = FALSE;

for (int j = 0; j < dircount; j++)
	{
		t_directory dir;

CStdString str;
		if (!ParseString(endMarker, p, str))
			return 0;

str.TrimRight(_T("\\"));
		if (str == _T(""))
			return 0;

dir.dir = str;

// Get directory aliases.
		if ((endMarker - p) < 2)
			return NULL;

int aliascount = (int(*p) << 8) + p[1];
		p += 2;

for (int i = 0; i < aliascount; i++)
		{
			CStdString alias;
			if (!ParseString(endMarker, p, alias))
				return 0;

alias.TrimRight(_T("\\"));

if (alias == _T(""))
				return 0;

dir.aliases.push_back(alias);
		}

if ((endMarker - p) < 2)
			return NULL;

int rights = (int(*p) << 8) + p[1];
		p += 2;

dir.bDirCreate	= rights & 0x0001 ? 1:0;
		dir.bDirDelete	= rights & 0x0002 ? 1:0;
		dir.bDirList	= rights & 0x0004 ? 1:0;
		dir.bDirSubdirs	= rights & 0x0008 ? 1:0;
		dir.bFileAppend	= rights & 0x0010 ? 1:0;
		dir.bFileDelete	= rights & 0x0020 ? 1:0;
		dir.bFileRead	= rights & 0x0040 ? 1:0;
		dir.bFileWrite	= rights & 0x0080 ? 1:0;
		dir.bIsHome		= rights & 0x0100 ? 1:0;
		dir.bAutoCreate	= rights & 0x0200 ? 1:0;

// Avoid multiple home directories.
		if (dir.bIsHome)
			if (!bGotHome)
				bGotHome = TRUE;
			else
				dir.bIsHome = FALSE;

permissions.push_back(dir);
	}

for (int i = 0; i < 2; i++)
	{
		if ((endMarker - p) < 5)
			return NULL;

nSpeedLimitType[i] = *p & 3;
		nBypassServerSpeedLimit[i] = (*p++ >> 2) & 3;

nSpeedLimit[i] = int(*p++) << 8;
		nSpeedLimit[i] |= *p++;
	
		if (!nSpeedLimit[i])
			nSpeedLimit[i] = 10;

int num = (int(*p) << 8) + p[1];
		p += 2;
		while (num--)
		{
			CSpeedLimit sl;
			p = sl.ParseBuffer(p, length-(int)(p-pBuffer));
			if (!p)
				return NULL;
			SpeedLimits[i].push_back(sl);
		}
	}

if (!ParseString(endMarker, p, comment))
		return 0;

if (p >= endMarker)
		return 0;

forceSsl = *p++;

return p;
}

int t_group::GetRequiredStringBufferLen(const CStdString& str) const
{
	char* utf8 = ConvToNetwork(str);

if (!utf8)
		return 2;

int len = strlen(utf8);

delete [] utf8;

return len + 2;
}

void t_group::FillString(char *& p, const CStdString& str) const
{
	char* utf8 = ConvToNetwork(str);

if (!utf8)
	{
		*p++ = 0;
		*p++ = 0;
		return;
	}

int len = strlen(utf8);
	*p++ = (char)(len >> 8);
	*p++ = (char)(len & 0xff);

memcpy(p, utf8, len);
	p += len;

delete [] utf8;
}

char * t_group::FillBuffer(char *p) const
{
	FillString(p, group);
	
	memcpy(p, &nIpLimit, 4);
	p += 4;
	memcpy(p, &nUserLimit, 4);
	p += 4;

int options = nBypassUserLimit & 3;
	options |= (nEnabled & 3) << 2;

*p++ = options & 0xff;

std::list<CStdString>::const_iterator ipLimitIter;

*p++ = (char)(disallowedIPs.size() >> 8);
	*p++ = (char)(disallowedIPs.size() & 0xff);
	for (ipLimitIter = disallowedIPs.begin(); ipLimitIter != disallowedIPs.end(); ipLimitIter++)
		FillString(p, *ipLimitIter);

*p++ = (char)(allowedIPs.size() >> 8);
	*p++ = (char)(allowedIPs.size() & 0xff);
	for (ipLimitIter = allowedIPs.begin(); ipLimitIter != allowedIPs.end(); ipLimitIter++)
		FillString(p, *ipLimitIter);

*p++ = (char)(permissions.size() >> 8);
	*p++ = (char)(permissions.size() & 0xff);
	for (std::vector<t_directory>::const_iterator permissioniter = permissions.begin(); permissioniter!=permissions.end(); permissioniter++)
	{
		FillString(p, permissioniter->dir);

*p++ = (char)(permissioniter->aliases.size() >> 8);
		*p++ = (char)(permissioniter->aliases.size() & 0xff);
		for (std::list<CStdString>::const_iterator aliasiter = permissioniter->aliases.begin(); aliasiter != permissioniter->aliases.end(); aliasiter++)
			FillString(p, *aliasiter);

int rights = 0;
		rights |= permissioniter->bDirCreate	? 0x0001:0;
		rights |= permissioniter->bDirDelete	? 0x0002:0;
		rights |= permissioniter->bDirList		? 0x0004:0;
		rights |= permissioniter->bDirSubdirs	? 0x0008:0;
		rights |= permissioniter->bFileAppend	? 0x0010:0;
		rights |= permissioniter->bFileDelete	? 0x0020:0;
		rights |= permissioniter->bFileRead		? 0x0040:0;
		rights |= permissioniter->bFileWrite	? 0x0080:0;
		rights |= permissioniter->bIsHome		? 0x0100:0;
		rights |= permissioniter->bAutoCreate	? 0x0200:0;
		*p++ = (char)(rights >> 8);
		*p++ = (char)(rights & 0xff);
	}

for (int i = 0; i < 2; i++)
	{
		*p++ = (char)((nSpeedLimitType[i] & 3) + ((nBypassServerSpeedLimit[i] & 3) << 2));
		*p++ = (char)(nSpeedLimit[i] >> 8);
		*p++ = (char)(nSpeedLimit[i] & 0xff);

SPEEDLIMITSLIST::const_iterator iter;

*p++ = (char)(SpeedLimits[i].size() >> 8);
		*p++ = (char)(SpeedLimits[i].size() & 0xff);
		for (iter = SpeedLimits[i].begin(); (iter != SpeedLimits[i].end()) && p; iter++)
			p = iter->FillBuffer(p);
		if (!p)
			return NULL;
	}

FillString(p, comment);

*p++ = (char)forceSsl;

return p;
}

int t_group::GetRequiredBufferLen() const
{
	int len = 9;
	len += GetRequiredStringBufferLen(group);

len += 4;
	std::list<CStdString>::const_iterator ipLimitIter;
	for (ipLimitIter = disallowedIPs.begin(); ipLimitIter != disallowedIPs.end(); ipLimitIter++)
		len += GetRequiredStringBufferLen(*ipLimitIter);
	for (ipLimitIter = allowedIPs.begin(); ipLimitIter != allowedIPs.end(); ipLimitIter++)
		len += GetRequiredStringBufferLen(*ipLimitIter);

len += 2;
	for (std::vector<t_directory>::const_iterator permissioniter = permissions.begin(); permissioniter!=permissions.end(); permissioniter++)
	{
		t_directory directory = *permissioniter;
		len += 2;

len += GetRequiredStringBufferLen(directory.dir);

len += 2;
		for (std::list<CStdString>::const_iterator aliasiter = permissioniter->aliases.begin(); aliasiter != permissioniter->aliases.end(); aliasiter++)
			len += GetRequiredStringBufferLen(*aliasiter);
	}

// Speed limits.
	len += 6; // Basic limits.
	len += 4; // Number of rules.
	for (int i = 0; i < 2; i++)
	{
		SPEEDLIMITSLIST::const_iterator iter;
		for (iter = SpeedLimits[i].begin(); iter != SpeedLimits[i].end(); iter++)
			len += iter->GetRequiredBufferLen();
	}

len += GetRequiredStringBufferLen(comment);

len++; //forceSsl

return len;
}

int t_group::GetCurrentSpeedLimit(sltype type) const
{
	switch (nSpeedLimitType[type])
	{
	case 0:
		if (pOwner)
			return pOwner->GetCurrentSpeedLimit(type);
		else
			return 0;
	case 1:
		return 0;
	case 2:
		return nSpeedLimit[type];
	case 3:
		{
			SYSTEMTIME st;
			GetLocalTime(&st);
			for (SPEEDLIMITSLIST::const_iterator iter = SpeedLimits[type].begin(); iter != SpeedLimits[type].end(); iter++)
				if (iter->IsItActive(st))
					return iter->m_Speed;
		}
		if (pOwner)
			return pOwner->GetCurrentSpeedLimit(type);
		else
			return 0;
	}
	return 0;
}

bool t_group::BypassServerSpeedLimit(sltype type) const
{
	if (nBypassServerSpeedLimit[type] == 1)
		return true;
	else if (!nBypassServerSpeedLimit[type])
		return false;
	else if (pOwner)
		return pOwner->BypassServerSpeedLimit(type);
	else
		return false;
}

bool t_group::IsEnabled() const
{
	switch (nEnabled)
	{
	default:
	case 0:
		return false;
	case 1:
		return true;
	case 2:
		if (!pOwner)
			return false;

return pOwner->IsEnabled();
	}
}

bool t_group::AccessAllowed(const CStdString& ip) const
{
	bool disallowed = false;

std::list<CStdString>::const_iterator iter;
	for (iter = disallowedIPs.begin(); iter != disallowedIPs.end(); iter++)
	{
		if (disallowed = MatchesFilter(*iter, ip))
			break;
	}

if (!disallowed)
	{
		if (!pOwner)
			return true;

if (pOwner->AccessAllowed(ip))
			return true;
	}

for (iter = allowedIPs.begin(); iter != allowedIPs.end(); iter++)
	{
		if (MatchesFilter(*iter, ip))
			return true;
	}

if (pOwner && !disallowed)
		return pOwner->AccessAllowed(ip);

return false;
}

unsigned char * t_user::ParseBuffer(unsigned char *pBuffer, int length)
{
	unsigned char *p = pBuffer;
	unsigned char *endMarker = pBuffer + length;

p = t_group::ParseBuffer(p, length);
	if (!p)
		return NULL;

if (!ParseString(endMarker, p, user))
		return 0;

if (!ParseString(endMarker, p, password))
		return 0;

return p;
}

char * t_user::FillBuffer(char *p) const
{
	p = t_group::FillBuffer(p);
	if (!p)
		return NULL;

FillString(p, user);
	FillString(p, password);

return p;
}

int t_user::GetRequiredBufferLen() const
{
	int len = t_group::GetRequiredBufferLen();
	len += GetRequiredStringBufferLen(user);
	len += GetRequiredStringBufferLen(password);
	return len;
}

bool t_group::ParseString(const unsigned char* endMarker, unsigned char *&p, CStdString &string)
{
	if ((endMarker - p) < 2)
		return false;

int len = *p * 256 + p[1];
	p += 2;

if ((endMarker - p) < len)
		return false;
	char* tmp = new char[len + 1];
	tmp[len] = 0;
	memcpy(tmp, p, len);
	CStdStringW str = ConvFromNetwork((const char*)tmp);
	delete [] tmp;
	p += len;
#ifdef _UNICODE
	string = str;
#else
	string = ConvToLocal(str);
#endif
	
	return true;
}

bool t_group::ForceSsl() const
{
	switch (forceSsl)
	{
	default:
	case 0:
		return false;
	case 1:
		return true;
	case 2:
		if (!pOwner)
			return false;

return pOwner->ForceSsl();
	}
}

${this.title}

Code Editor : Accounts.cpp