void CStatTreeItemMaxConnLimitReached::AddECValues(CECTag *tag) const
{
wxString result;
if (m_count) {
result = wxString::Format(wxT("%i : "), m_count) +
m_time.FormatISODate() +
wxT(" ") +
m_time.FormatISOTime();
} else {
result = wxTRANSLATE("Never");
}
CECTag value(EC_TAG_STAT_NODE_VALUE, result);
value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
tag->AddTag(value);
}
bool CECTag::ReadChildren(CECSocket& socket)
{
uint16 tmp_tagCount;
if (!socket.ReadNumber(&tmp_tagCount, sizeof(uint16))) {
return false;
}
m_tagList.clear();
for (int i = 0; i < tmp_tagCount; i++) {
m_tagList.push_back(CECTag());
CECTag& tag = m_tagList.back();
if (!tag.ReadFromSocket(socket)) {
return false;
}
}
return true;
}
/*
* Return hash of amule options.
* Key: option name
* Value: option value (string)
*/
void php_get_amule_options(PHP_VALUE_NODE *result)
{
cast_value_array(result);
CECPacket req(EC_OP_GET_PREFERENCES);
req.AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)0xffffffff));
const CECPacket *reply = CPhPLibContext::g_curr_context->WebServer()->webInterface->SendRecvMsg_v2(&req);
if ( !reply || !reply->HasChildTags()) {
return ;
}
const CECTag *cattag = 0;
PHP_VALUE_NODE intval;
intval.type = PHP_VAL_INT;
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_GENERAL)) != 0) {
PHP_VAR_NODE *key = array_get_by_str_key(result, "nick");
value_value_free(&key->value);
key->value.type = PHP_VAL_STRING;
key->value.str_val = strdup(unicode2UTF8(cattag->GetTagByNameSafe(EC_TAG_USER_NICK)->GetStringData()));
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_CONNECTIONS)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "connection");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_connection_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_FILES)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "files");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_file_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_REMOTECTRL)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "webserver");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_webserver_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_CORETWEAKS)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "coretweaks");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_coretweak_opt_defs, cat);
}
}
//
// Search request
//
CEC_Search_Tag::CEC_Search_Tag(const wxString &name, EC_SEARCH_TYPE search_type, const wxString &file_type,
const wxString &extension, uint32 avail, uint64 min_size, uint64 max_size) : CECTag(EC_TAG_SEARCH_TYPE, (uint32)search_type)
{
AddTag(CECTag(EC_TAG_SEARCH_NAME, name));
AddTag(CECTag(EC_TAG_SEARCH_FILE_TYPE, file_type));
if ( !extension.IsEmpty() ) {
AddTag(CECTag(EC_TAG_SEARCH_EXTENSION, extension));
}
if ( avail ) {
AddTag(CECTag(EC_TAG_SEARCH_AVAILABILITY, avail));
}
if ( min_size != 0 ) {
AddTag(CECTag(EC_TAG_SEARCH_MIN_SIZE, min_size));
}
if ( max_size != 0 ) {
AddTag(CECTag(EC_TAG_SEARCH_MAX_SIZE, max_size));
}
}
void CStatTreeItemReconnects::AddECValues(CECTag *tag) const
{
tag->AddTag(CECTag(EC_TAG_STAT_NODE_VALUE,
m_value ? (uint64)(m_value - 1) : (uint64)0));
}
void CStatTreeItemRatio::AddECValues(CECTag *tag) const
{
CECTag value(EC_TAG_STAT_NODE_VALUE, GetString());
value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_STRING));
tag->AddTag(value);
}
void CStatTreeItemCounterMax::AddECValues(CECTag *tag) const
{
tag->AddTag(CECTag(EC_TAG_STAT_NODE_VALUE, (uint64)m_value));
}
int CamulecmdApp::ProcessCommand(int CmdId)
{
wxString args = GetCmdArgs();
CECPacket *request = 0;
std::list<CECPacket *> request_list;
int tmp_int = 0;
EC_SEARCH_TYPE search_type = EC_SEARCH_KAD;
// Implementation of the deprecated command 'SetIPFilter'.
if (CmdId == CMD_ID_SET_IPFILTER) {
if ( ! args.IsEmpty() ) {
if (args.IsSameAs(wxT("ON"), false)) {
CmdId = CMD_ID_SET_IPFILTER_ON;
} else if (args.IsSameAs(wxT("OFF"), false)) {
CmdId = CMD_ID_SET_IPFILTER_OFF;
} else {
return CMD_ERR_INVALID_ARG;
}
} else {
CmdId = CMD_ID_GET_IPFILTER_STATE;
}
}
switch (CmdId) {
case CMD_ID_STATUS:
request_list.push_back(new CECPacket(EC_OP_STAT_REQ, EC_DETAIL_CMD));
break;
case CMD_ID_SHUTDOWN:
request_list.push_back(new CECPacket(EC_OP_SHUTDOWN));
break;
case CMD_ID_CONNECT:
if ( !args.IsEmpty() ) {
unsigned int ip[4];
unsigned int port;
// Not much we can do against this unicode2char.
int result = sscanf(unicode2char(args), "%3d.%3d.%3d.%3d:%5d", &ip[0], &ip[1], &ip[2], &ip[3], &port);
if (result != 5) {
// Try to resolve DNS -- good for dynamic IP servers
wxString serverName(args.BeforeFirst(wxT(':')));
long lPort;
bool ok = args.AfterFirst(wxT(':')).ToLong(&lPort);
port = (unsigned int)lPort;
amuleIPV4Address a;
a.Hostname(serverName);
a.Service(port);
result = sscanf(unicode2char(a.IPAddress()), "%3d.%3d.%3d.%3d", &ip[0], &ip[1], &ip[2], &ip[3]);
if (serverName.IsEmpty() || !ok || (result != 4)) {
Show(_("Invalid IP format. Use xxx.xxx.xxx.xxx:xxxx\n"));
return 0;
}
}
EC_IPv4_t addr;
addr.m_ip[0] = ip[0];
addr.m_ip[1] = ip[1];
addr.m_ip[2] = ip[2];
addr.m_ip[3] = ip[3];
addr.m_port = port;
request = new CECPacket(EC_OP_SERVER_CONNECT);
request->AddTag(CECTag(EC_TAG_SERVER, addr));
request_list.push_back(request);
} else {
request_list.push_back(new CECPacket(EC_OP_CONNECT));
}
break;
case CMD_ID_CONNECT_ED2K:
request_list.push_back(new CECPacket(EC_OP_SERVER_CONNECT));
break;
case CMD_ID_CONNECT_KAD:
request_list.push_back(new CECPacket(EC_OP_KAD_START));
break;
case CMD_ID_DISCONNECT:
request_list.push_back(new CECPacket(EC_OP_DISCONNECT));
break;
case CMD_ID_DISCONNECT_ED2K:
request_list.push_back(new CECPacket(EC_OP_SERVER_DISCONNECT));
break;
case CMD_ID_DISCONNECT_KAD:
request_list.push_back(new CECPacket(EC_OP_KAD_STOP));
break;
case CMD_ID_RELOAD_SHARED:
request_list.push_back(new CECPacket(EC_OP_SHAREDFILES_RELOAD));
break;
case CMD_ID_RELOAD_IPFILTER_LOCAL:
request_list.push_back(new CECPacket(EC_OP_IPFILTER_RELOAD));
break;
case CMD_ID_RELOAD_IPFILTER_NET:
request = new CECPacket(EC_OP_IPFILTER_UPDATE);
request->AddTag(EC_TAG_STRING, args);
request_list.push_back(request);
break;
case CMD_ID_SET_IPFILTER_ON:
case CMD_ID_SET_IPFILTER_CLIENTS_ON:
case CMD_ID_SET_IPFILTER_SERVERS_ON:
tmp_int = 1;
case CMD_ID_SET_IPFILTER_OFF:
case CMD_ID_SET_IPFILTER_CLIENTS_OFF:
case CMD_ID_SET_IPFILTER_SERVERS_OFF:
{
if (CmdId == CMD_ID_SET_IPFILTER_CLIENTS_ON || CmdId == CMD_ID_SET_IPFILTER_CLIENTS_OFF) {
CmdId = CMD_ID_GET_IPFILTER_STATE_CLIENTS;
} else if (CmdId == CMD_ID_SET_IPFILTER_SERVERS_ON || CmdId == CMD_ID_SET_IPFILTER_SERVERS_OFF) {
CmdId = CMD_ID_GET_IPFILTER_STATE_SERVERS;
} else {
CmdId = CMD_ID_GET_IPFILTER_STATE;
}
request = new CECPacket(EC_OP_SET_PREFERENCES);
CECEmptyTag prefs(EC_TAG_PREFS_SECURITY);
if (CmdId != CMD_ID_GET_IPFILTER_STATE_SERVERS) {
prefs.AddTag(CECTag(EC_TAG_IPFILTER_CLIENTS, (uint8)tmp_int));
}
if (CmdId != CMD_ID_GET_IPFILTER_STATE_CLIENTS) {
prefs.AddTag(CECTag(EC_TAG_IPFILTER_SERVERS, (uint8)tmp_int));
}
request->AddTag(prefs);
request_list.push_back(request);
}
case CMD_ID_GET_IPFILTER:
case CMD_ID_GET_IPFILTER_STATE:
case CMD_ID_GET_IPFILTER_STATE_CLIENTS:
case CMD_ID_GET_IPFILTER_STATE_SERVERS:
request = new CECPacket(EC_OP_GET_PREFERENCES);
request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_SECURITY));
request_list.push_back(request);
break;
case CMD_ID_SET_IPFILTER_LEVEL:
if (!args.IsEmpty()) // This 'if' must stay as long as we support the deprecated 'IPLevel' command.
{
unsigned long int level = 0;
if (args.ToULong(&level) == true && level < 256) {
request = new CECPacket(EC_OP_SET_PREFERENCES);
CECEmptyTag prefs(EC_TAG_PREFS_SECURITY);
prefs.AddTag(CECTag(EC_TAG_IPFILTER_LEVEL, (uint8)level));
request->AddTag(prefs);
request_list.push_back(request);
} else {
return CMD_ERR_INVALID_ARG;
}
}
CmdId = CMD_ID_GET_IPFILTER_LEVEL;
case CMD_ID_GET_IPFILTER_LEVEL:
request = new CECPacket(EC_OP_GET_PREFERENCES);
request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_SECURITY));
request_list.push_back(request);
break;
case CMD_ID_PAUSE:
case CMD_ID_CANCEL:
case CMD_ID_RESUME:
{
if ( args.IsEmpty() ) {
Show(_("This command requires an argument. Valid arguments: 'all', filename, or a number.\n"));
return 0;
} else {
wxStringTokenizer argsTokenizer(args);
wxString token;
CMD4Hash hash;
// Grab the entire dl queue right away
CECPacket request_all(EC_OP_GET_DLOAD_QUEUE, EC_DETAIL_CMD);
const CECPacket *reply_all = SendRecvMsg_v2(&request_all);
if (reply_all) {
switch(CmdId) {
case CMD_ID_PAUSE:
request = new CECPacket(EC_OP_PARTFILE_PAUSE); break;
case CMD_ID_CANCEL:
request = new CECPacket(EC_OP_PARTFILE_DELETE); break;
case CMD_ID_RESUME:
request = new CECPacket(EC_OP_PARTFILE_RESUME); break;
default: wxFAIL;
}
// We loop through all the arguments
while(argsTokenizer.HasMoreTokens()) {
token=argsTokenizer.GetNextToken();
// If the user requested all, then we select all files and exit the loop
// since there is little point to add anything more to "everything"
if( token == wxT("all") ) {
for (CECPacket::const_iterator it = reply_all->begin(); it != reply_all->end(); ++it) {
const CEC_PartFile_Tag *tag = static_cast<const CEC_PartFile_Tag *>(&*it);
request->AddTag(CECTag(EC_TAG_PARTFILE, tag->FileHash()));
}
break;
} else if ( hash.Decode(token.Trim(false).Trim(true)) ) {
if ( !hash.IsEmpty() ) {
Show(_("Processing by hash: "+token+wxT("\n")));
request->AddTag(CECTag(EC_TAG_PARTFILE, hash));
}
} else {
// Go through the dl queue and look at each filename
for (CECPacket::const_iterator it = reply_all->begin(); it != reply_all->end(); ++it) {
const CEC_PartFile_Tag *tag = static_cast<const CEC_PartFile_Tag *>(&*it);
wxString partmetname = tag->PartMetName();
// We check for filename, XXX.pat.met, XXX.part, XXX
if( tag->FileName() == token ||
partmetname == token ||
partmetname.Truncate(partmetname.Len()-4) == token ||
partmetname.Truncate(partmetname.Len()-5) == token) {
Show(_("Processing by filename: "+token+wxT("\n")));
request->AddTag(CECTag(EC_TAG_PARTFILE, tag->FileHash()));
}
}
} // End of filename check else
} // End of argument token loop
request_list.push_back(request);
delete reply_all;
} // End of dl queue processing
} // end of command processing
break;
}
case CMD_ID_PRIORITY_LOW:
case CMD_ID_PRIORITY_NORMAL:
case CMD_ID_PRIORITY_HIGH:
case CMD_ID_PRIORITY_AUTO:
if ( args.IsEmpty() ) {
Show(_("This command requires an argument. Valid arguments: a file hash.\n"));
return 0;
} else {
CMD4Hash hash;
if (hash.Decode(args.Trim(false).Trim(true))) {
if (!hash.IsEmpty()) {
request = new CECPacket(EC_OP_PARTFILE_PRIO_SET);
CECTag hashtag(EC_TAG_PARTFILE, hash);
switch(CmdId) {
case CMD_ID_PRIORITY_LOW:
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_LOW));
break;
case CMD_ID_PRIORITY_NORMAL:
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_NORMAL));
break;
case CMD_ID_PRIORITY_HIGH:
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_HIGH));
break;
case CMD_ID_PRIORITY_AUTO:
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_AUTO));
break;
default: wxFAIL;
}
request->AddTag(hashtag);
request_list.push_back(request);
} else {
Show(_("Not a valid number\n"));
return 0;
}
} else {
Show(_("Not a valid hash (length should be exactly 32 chars)\n"));
return 0;
}
}
break;
case CMD_ID_SHOW_UL:
request_list.push_back(new CECPacket(EC_OP_GET_ULOAD_QUEUE));
break;
case CMD_ID_SHOW_DL:
request_list.push_back(new CECPacket(EC_OP_GET_DLOAD_QUEUE));
break;
case CMD_ID_SHOW_LOG:
request_list.push_back(new CECPacket(EC_OP_GET_LOG));
break;
case CMD_ID_SHOW_SERVERS:
request_list.push_back(new CECPacket(EC_OP_GET_SERVER_LIST, EC_DETAIL_CMD));
break;
case CMD_ID_SHOW_SHARED:
request_list.push_back(new CECPacket(EC_OP_GET_SHARED_FILES));
break;
case CMD_ID_RESET_LOG:
request_list.push_back(new CECPacket(EC_OP_RESET_LOG));
break;
case CMD_ID_ADDLINK:
if (args.StartsWith(wxT("ed2k://"))) {
//aMule doesn't like AICH links without |/| in front of h=
if (args.Find(wxT("|h=")) > -1 && args.Find(wxT("|/|h=")) == -1) {
args.Replace(wxT("|h="),wxT("|/|h="));
}
// repair links where | is replaced with %7C (Firefox)
if (args.StartsWith(wxT("ed2k://%7C"))) {
args.Replace(wxT("%7C"),wxT("|"));
}
}
request = new CECPacket(EC_OP_ADD_LINK);
request->AddTag(CECTag(EC_TAG_STRING, args));
request_list.push_back(request);
break;
case CMD_ID_SET_BWLIMIT_UP:
tmp_int = EC_TAG_CONN_MAX_UL - EC_TAG_CONN_MAX_DL;
case CMD_ID_SET_BWLIMIT_DOWN:
tmp_int += EC_TAG_CONN_MAX_DL;
{
unsigned long int limit;
if (args.ToULong(&limit)) {
request = new CECPacket(EC_OP_SET_PREFERENCES);
CECEmptyTag prefs(EC_TAG_PREFS_CONNECTIONS);
prefs.AddTag(CECTag(tmp_int, (uint16)limit));
request->AddTag(prefs);
request_list.push_back(request);
} else {
return CMD_ERR_INVALID_ARG;
}
}
case CMD_ID_GET_BWLIMITS:
request = new CECPacket(EC_OP_GET_PREFERENCES);
request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_CONNECTIONS));
request_list.push_back(request);
break;
case CMD_ID_STATTREE:
request = new CECPacket(EC_OP_GET_STATSTREE);
if (!args.IsEmpty()) {
unsigned long int max_versions;
if (args.ToULong(&max_versions)) {
if (max_versions < 256) {
request->AddTag(CECTag(EC_TAG_STATTREE_CAPPING, (uint8)max_versions));
} else {
delete request;
return CMD_ERR_INVALID_ARG;
}
} else {
delete request;
return CMD_ERR_INVALID_ARG;
}
}
request_list.push_back(request);
break;
case CMD_ID_SEARCH_GLOBAL:
search_type = EC_SEARCH_GLOBAL;
case CMD_ID_SEARCH_LOCAL:
if (search_type != EC_SEARCH_GLOBAL){
search_type = EC_SEARCH_LOCAL;
}
case CMD_ID_SEARCH_KAD:
if (search_type != EC_SEARCH_GLOBAL && search_type != EC_SEARCH_LOCAL){
search_type = EC_SEARCH_KAD;
}
if (!args.IsEmpty())
{
wxString search = args;
wxString type;
wxString extention;
uint32 avail = 0;
uint32 min_size = 0;
uint32 max_size = 0;
request = new CECPacket(EC_OP_SEARCH_START);
request->AddTag(CEC_Search_Tag (search, search_type, type, extention, avail, min_size, max_size));
request_list.push_back(request);
}
break;
case CMD_ID_SEARCH:
/* TRANSLATORS:
'help search' is a command to the program, do not translate it. */
Show(_("No search type defined.\nType 'help search' to get more help.\n"));
break;
case CMD_ID_SEARCH_RESULTS:
request_list.push_back(new CECPacket(EC_OP_SEARCH_RESULTS, EC_DETAIL_FULL));
break;
case CMD_ID_SEARCH_PROGRESS:
request_list.push_back(new CECPacket(EC_OP_SEARCH_PROGRESS));
break;
case CMD_ID_DOWNLOAD:
if (!args.IsEmpty())
{
unsigned long int id = 0;
if (args.ToULong(&id) == true && id < m_Results_map.size()) {
SearchFile* file = m_Results_map[id];
Show(CFormat(_("Download File: %lu %s\n")) % id % file->sFileName);
request = new CECPacket(EC_OP_DOWNLOAD_SEARCH_RESULT);
// get with id the hash and category=0
uint32 category = 0;
CECTag hashtag(EC_TAG_PARTFILE, file->nHash);
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, category));
request->AddTag(hashtag);
request_list.push_back(request);
} else {
return CMD_ERR_INVALID_ARG;
}
}
break;
default:
return CMD_ERR_PROCESS_CMD;
}
m_last_cmd_id = CmdId;
if ( ! request_list.empty() ) {
std::list<CECPacket *>::iterator it = request_list.begin();
while ( it != request_list.end() ) {
CECPacket *curr = *it++;
if (curr->GetOpCode() == EC_OP_SHUTDOWN) {
SendPacket(curr);
delete curr;
return CMD_ID_QUIT;
}
const CECPacket *reply = SendRecvMsg_v2(curr);
delete curr;
if ( reply ) {
Process_Answer_v2(reply);
delete reply;
}
}
request_list.resize(0);
}
return CMD_OK;
}
// used for webserver, amulecmd
CEC_Server_Tag::CEC_Server_Tag(const CServer *server, EC_DETAIL_LEVEL detail_level) :
CECTag(EC_TAG_SERVER, EC_IPv4_t(server->GetIP(), server->GetPort()))
{
wxString tmpStr;
uint32 tmpInt;
uint8 tmpShort;
switch (detail_level) {
case EC_DETAIL_INC_UPDATE:
// should not get here
wxFAIL;
break;
case EC_DETAIL_UPDATE:
if ((tmpInt = server->GetPing()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_PING, tmpInt));
}
if ((tmpShort = (uint8)server->GetFailedCount()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_FAILED, tmpShort));
}
break;
case EC_DETAIL_WEB:
case EC_DETAIL_FULL:
if ((tmpInt = server->GetPing()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_PING, tmpInt));
}
if ((tmpShort = (uint8)server->GetPreferences()) != SRV_PR_NORMAL) {
AddTag(CECTag(EC_TAG_SERVER_PRIO, tmpShort));
}
if ((tmpShort = (uint8)server->GetFailedCount()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_FAILED, tmpShort));
}
if ((tmpShort = (server->IsStaticMember() ? 1 : 0)) != 0) {
AddTag(CECTag(EC_TAG_SERVER_STATIC, tmpShort));
}
if (!(tmpStr = server->GetVersion()).IsEmpty()) {
AddTag(CECTag(EC_TAG_SERVER_VERSION, tmpStr));
}
if (!(tmpStr = server->GetDescription()).IsEmpty()) {
AddTag(CECTag(EC_TAG_SERVER_DESC, tmpStr));
}
if ((tmpInt = server->GetUsers()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_USERS, tmpInt));
}
if ((tmpInt = server->GetMaxUsers()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_USERS_MAX, tmpInt));
}
if ((tmpInt = server->GetFiles()) != 0) {
AddTag(CECTag(EC_TAG_SERVER_FILES, tmpInt));
}
case EC_DETAIL_CMD:
if (!(tmpStr = server->GetListName()).IsEmpty()) {
AddTag(CECTag(EC_TAG_SERVER_NAME, tmpStr));
}
}
}
CEC_UpDownClient_Tag::CEC_UpDownClient_Tag(const CUpDownClient* client, EC_DETAIL_LEVEL detail_level, CValueMap *valuemap) :
CECTag(EC_TAG_CLIENT, client->ECID())
{
// General
AddTag(CECTag(EC_TAG_CLIENT_NAME, client->GetUserName()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_HASH, client->GetUserHash()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_USER_ID, client->GetUserIDHybrid()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SCORE, client->GetScore()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SOFTWARE, client->GetClientSoft()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SOFT_VER_STR, client->GetSoftVerStr()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_USER_IP, client->GetIP()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_USER_PORT, client->GetUserPort()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_FROM, (uint64)client->GetSourceFrom()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SERVER_IP, client->GetServerIP()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SERVER_PORT, client->GetServerPort()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_SERVER_NAME, client->GetServerName()), valuemap);
// Transfers to Client
AddTag(CECTag(EC_TAG_CLIENT_UP_SPEED, client->GetUploadDatarate()), valuemap);
if (client->GetDownloadState() == DS_DOWNLOADING || valuemap) {
AddTag(CECTag(EC_TAG_CLIENT_DOWN_SPEED, (double)(client->GetKBpsDown())), valuemap);
}
AddTag(CECTag(EC_TAG_CLIENT_UPLOAD_SESSION, client->GetSessionUp()), valuemap);
AddTag(CECTag(EC_TAG_PARTFILE_SIZE_XFER, client->GetTransferredDown()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_UPLOAD_TOTAL, client->GetUploadedTotal()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_DOWNLOAD_TOTAL, client->GetDownloadedTotal()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_UPLOAD_STATE, client->GetUploadState()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_DOWNLOAD_STATE, client->GetDownloadState()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_IDENT_STATE, (uint64) client->GetCurrentIdentState()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_EXT_PROTOCOL, client->ExtProtocolAvailable()), valuemap);
// These are not needed atm. Keep them for now, maybe columns get reintroduced in client view.
//AddTag(CECTag(EC_TAG_CLIENT_WAIT_TIME, client->GetWaitTime()), valuemap);
//AddTag(CECTag(EC_TAG_CLIENT_XFER_TIME, client->GetUpStartTimeDelay()), valuemap);
//AddTag(CECTag(EC_TAG_CLIENT_QUEUE_TIME, (uint64)(::GetTickCount() - client->GetWaitStartTime())), valuemap);
//AddTag(CECTag(EC_TAG_CLIENT_LAST_TIME, (uint64)(::GetTickCount() - client->GetLastUpRequest())), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_WAITING_POSITION, client->GetUploadQueueWaitingPosition()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_REMOTE_QUEUE_RANK, client->IsRemoteQueueFull() ? (uint16)0xffff : client->GetRemoteQueueRank()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_OLD_REMOTE_QUEUE_RANK, client->GetOldRemoteQueueRank()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_OBFUSCATION_STATUS, client->GetObfuscationStatus()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_KAD_PORT, client->GetKadPort()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_FRIEND_SLOT, client->GetFriendSlot()), valuemap);
if (detail_level == EC_DETAIL_UPDATE) {
return;
}
const CKnownFile* file = client->GetUploadFile();
if (file) {
AddTag(CECTag(EC_TAG_PARTFILE_NAME, file->GetFileName().GetPrintable()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_UPLOAD_FILE, file->ECID()), valuemap);
} else {
AddTag(CECIntTag(EC_TAG_CLIENT_UPLOAD_FILE, 0), valuemap);
}
const CPartFile* pfile = client->GetRequestFile();
AddTag(CECTag(EC_TAG_CLIENT_REQUEST_FILE, pfile ? pfile->ECID() : 0), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_REMOTE_FILENAME, client->GetClientFilename()), valuemap);
if (detail_level != EC_DETAIL_INC_UPDATE) {
return;
}
AddTag(CECTag(EC_TAG_CLIENT_DISABLE_VIEW_SHARED, client->HasDisabledSharedFiles()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_VERSION, client->GetVersion()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_MOD_VERSION, client->GetClientModString()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_OS_INFO, client->GetClientOSInfo()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_AVAILABLE_PARTS, client->GetAvailablePartCount()), valuemap);
if (pfile) {
const BitVector & partStatus = client->GetPartStatus();
if (partStatus.size() == pfile->GetPartCount()) {
if (partStatus.AllTrue()) {
// send just an empty tag for a full source
AddTag(CECEmptyTag(EC_TAG_CLIENT_PART_STATUS), valuemap);
} else {
AddTag(CECTag(EC_TAG_CLIENT_PART_STATUS, partStatus.SizeBuffer(), partStatus.GetBuffer()), valuemap);
}
}
AddTag(CECTag(EC_TAG_CLIENT_NEXT_REQUESTED_PART, client->GetNextRequestedPart()), valuemap);
AddTag(CECTag(EC_TAG_CLIENT_LAST_DOWNLOADING_PART, client->GetLastDownloadingPart()), valuemap);
}
if (file) {
const BitVector & upPartStatus = client->GetUpPartStatus();
if (upPartStatus.size() == file->GetPartCount()) {
AddTag(CECTag(EC_TAG_CLIENT_UPLOAD_PART_STATUS, upPartStatus.SizeBuffer(), upPartStatus.GetBuffer()), valuemap);
}
}
}
CEC_PartFile_Tag::CEC_PartFile_Tag(const CPartFile *file, EC_DETAIL_LEVEL detail_level, CValueMap *valuemap)
:
CEC_SharedFile_Tag(file, detail_level, valuemap, EC_TAG_PARTFILE)
{
AddTag(EC_TAG_PARTFILE_STATUS, file->GetStatus(), valuemap);
AddTag(EC_TAG_PARTFILE_STOPPED, file->IsStopped(), valuemap);
AddTag(EC_TAG_PARTFILE_SOURCE_COUNT, file->GetSourceCount(), valuemap);
AddTag(EC_TAG_PARTFILE_SOURCE_COUNT_NOT_CURRENT, file->GetNotCurrentSourcesCount(), valuemap);
AddTag(EC_TAG_PARTFILE_SOURCE_COUNT_XFER, file->GetTransferingSrcCount(), valuemap);
AddTag(EC_TAG_PARTFILE_SOURCE_COUNT_A4AF, file->GetSrcA4AFCount(), valuemap);
if ( (file->GetTransferingSrcCount() > 0) || (detail_level != EC_DETAIL_UPDATE) || valuemap) {
AddTag(EC_TAG_PARTFILE_SIZE_XFER, file->GetTransferred(), valuemap);
AddTag(EC_TAG_PARTFILE_SIZE_DONE, file->GetCompletedSize(), valuemap);
AddTag(EC_TAG_PARTFILE_SPEED, (uint64_t)(file->GetKBpsDown()*1024), valuemap);
}
AddTag(EC_TAG_PARTFILE_PRIO, (file->IsAutoDownPriority() ?
file->GetDownPriority() + 10 : file->GetDownPriority()), valuemap);
AddTag(EC_TAG_PARTFILE_CAT, file->GetCategory(), valuemap);
AddTag(EC_TAG_PARTFILE_LAST_SEEN_COMP, file->lastseencomplete, valuemap);
AddTag(EC_TAG_PARTFILE_LAST_RECV, file->GetLastChangeDatetime(), valuemap);
AddTag(EC_TAG_PARTFILE_DOWNLOAD_ACTIVE, file->GetDlActiveTime(), valuemap);
AddTag(EC_TAG_PARTFILE_AVAILABLE_PARTS, file->GetAvailablePartCount(), valuemap);
AddTag(EC_TAG_PARTFILE_LOST_CORRUPTION, file->GetLostDueToCorruption(), valuemap);
AddTag(EC_TAG_PARTFILE_GAINED_COMPRESSION, file->GetGainDueToCompression(), valuemap);
AddTag(EC_TAG_PARTFILE_SAVED_ICH, file->TotalPacketsSavedDueToICH(), valuemap);
AddTag(EC_TAG_PARTFILE_A4AFAUTO, file->IsA4AFAuto(), valuemap);
// Tag for comments
CECEmptyTag sc(EC_TAG_PARTFILE_COMMENTS);
FileRatingList list;
file->GetRatingAndComments(list);
for (FileRatingList::const_iterator it = list.begin(); it != list.end(); ++it) {
// Tag children are evaluated by index, not by name
sc.AddTag(CECTag(EC_TAG_PARTFILE_COMMENTS, it->UserName));
sc.AddTag(CECTag(EC_TAG_PARTFILE_COMMENTS, it->FileName));
sc.AddTag(CECTag(EC_TAG_PARTFILE_COMMENTS, (uint64) it->Rating));
sc.AddTag(CECTag(EC_TAG_PARTFILE_COMMENTS, it->Comment));
}
AddTag(sc, valuemap);
if (detail_level == EC_DETAIL_UPDATE) {
return;
}
AddTag(EC_TAG_PARTFILE_PARTMETID, file->GetPartMetNumber(), valuemap);
// A4AF sources
CECEmptyTag a4afTag(EC_TAG_PARTFILE_A4AF_SOURCES);
const CKnownFile::SourceSet& a4afSources = file->GetA4AFList();
for (CKnownFile::SourceSet::const_iterator it = a4afSources.begin(); it != a4afSources.end(); it++) {
a4afTag.AddTag(CECTag(EC_TAG_ECID, it->ECID()));
}
AddTag(a4afTag, valuemap);
}
CEC_Prefs_Packet::CEC_Prefs_Packet(uint32 selection, EC_DETAIL_LEVEL pref_details, EC_DETAIL_LEVEL cat_details) : CECPacket(EC_OP_SET_PREFERENCES, pref_details)
{
if (selection & EC_PREFS_CATEGORIES) {
if (theApp->glob_prefs->GetCatCount() > 1) {
CECEmptyTag cats(EC_TAG_PREFS_CATEGORIES);
for (unsigned int i = 0; i < theApp->glob_prefs->GetCatCount(); ++i) {
CEC_Category_Tag catTag(i, cat_details);
cats.AddTag(catTag);
}
AddTag(cats);
}
}
if (selection & EC_PREFS_GENERAL) {
CECEmptyTag user_prefs(EC_TAG_PREFS_GENERAL);
user_prefs.AddTag(CECTag(EC_TAG_USER_NICK, thePrefs::GetUserNick()));
user_prefs.AddTag(CECTag(EC_TAG_USER_HASH, thePrefs::GetUserHash()));
user_prefs.AddTag(CECTag(EC_TAG_USER_HOST, thePrefs::GetYourHostname()));
user_prefs.AddTag(CECTag(EC_TAG_GENERAL_CHECK_NEW_VERSION, thePrefs::GetCheckNewVersion()));
AddTag(user_prefs);
}
if (selection & EC_PREFS_CONNECTIONS) {
CECEmptyTag connPrefs(EC_TAG_PREFS_CONNECTIONS);
connPrefs.AddTag(CECTag(EC_TAG_CONN_UL_CAP, thePrefs::GetMaxGraphUploadRate()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_DL_CAP, thePrefs::GetMaxGraphDownloadRate()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_MAX_UL, thePrefs::GetMaxUpload()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_MAX_DL, thePrefs::GetMaxDownload()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_SLOT_ALLOCATION, thePrefs::GetSlotAllocation()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_TCP_PORT, thePrefs::GetPort()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_UDP_PORT, thePrefs::GetUDPPort()));
if (thePrefs::IsUDPDisabled()) {
connPrefs.AddTag(CECEmptyTag(EC_TAG_CONN_UDP_DISABLE));
}
connPrefs.AddTag(CECTag(EC_TAG_CONN_MAX_FILE_SOURCES, thePrefs::GetMaxSourcePerFile()));
connPrefs.AddTag(CECTag(EC_TAG_CONN_MAX_CONN, thePrefs::GetMaxConnections()));
if (thePrefs::DoAutoConnect()) {
connPrefs.AddTag(CECEmptyTag(EC_TAG_CONN_AUTOCONNECT));
}
if (thePrefs::Reconnect()) {
connPrefs.AddTag(CECEmptyTag(EC_TAG_CONN_RECONNECT));
}
if (thePrefs::GetNetworkED2K()) {
connPrefs.AddTag(CECEmptyTag(EC_TAG_NETWORK_ED2K));
}
if (thePrefs::GetNetworkKademlia()) {
connPrefs.AddTag(CECEmptyTag(EC_TAG_NETWORK_KADEMLIA));
}
AddTag(connPrefs);
}
if (selection & EC_PREFS_MESSAGEFILTER) {
CECEmptyTag msg_prefs(EC_TAG_PREFS_MESSAGEFILTER);
if (thePrefs::MustFilterMessages()) {
msg_prefs.AddTag(CECEmptyTag(EC_TAG_MSGFILTER_ENABLED));
}
if (thePrefs::IsFilterAllMessages()) {
msg_prefs.AddTag(CECEmptyTag(EC_TAG_MSGFILTER_ALL));
}
if (thePrefs::MsgOnlyFriends()) {
msg_prefs.AddTag(CECEmptyTag(EC_TAG_MSGFILTER_FRIENDS));
}
if (thePrefs::MsgOnlySecure()) {
msg_prefs.AddTag(CECEmptyTag(EC_TAG_MSGFILTER_SECURE));
}
if (thePrefs::IsFilterByKeywords()) {
msg_prefs.AddTag(CECEmptyTag(EC_TAG_MSGFILTER_BY_KEYWORD));
}
msg_prefs.AddTag(CECTag(EC_TAG_MSGFILTER_KEYWORDS, thePrefs::GetMessageFilterString()));
AddTag(msg_prefs);
}
if (selection & EC_PREFS_REMOTECONTROLS) {
CECEmptyTag rc_prefs(EC_TAG_PREFS_REMOTECTRL);
rc_prefs.AddTag(CECTag(EC_TAG_WEBSERVER_PORT, thePrefs::GetWSPort()));
if (thePrefs::GetWSIsEnabled()) {
rc_prefs.AddTag(CECEmptyTag(EC_TAG_WEBSERVER_AUTORUN));
}
if (!thePrefs::GetWSPass().IsEmpty()) {
CMD4Hash passhash;
wxCHECK2(passhash.Decode(thePrefs::GetWSPass()), /* Do nothing. */);
rc_prefs.AddTag(CECTag(EC_TAG_PASSWD_HASH, passhash));
}
