void CPartFileConvert::StartThread()
{
if (!s_convertPfThread) {
s_convertPfThread = new CPartFileConvert();
switch ( s_convertPfThread->Create() ) {
case wxTHREAD_NO_ERROR:
AddDebugLogLineN( logPfConvert, wxT("A new thread has been created.") );
break;
case wxTHREAD_RUNNING:
AddDebugLogLineC( logPfConvert, wxT("Error, attempt to create an already running thread!") );
break;
case wxTHREAD_NO_RESOURCE:
AddDebugLogLineC( logPfConvert, wxT("Error, attempt to create a thread without resources!") );
break;
default:
AddDebugLogLineC( logPfConvert, wxT("Error, unknown error attempting to create a thread!") );
}
// The thread shouldn't hog the CPU, as it will already be hogging the HD
s_convertPfThread->SetPriority(WXTHREAD_MIN_PRIORITY);
s_convertPfThread->Run();
}
}
void CFriendList::LoadList()
{
CPath metfile = CPath(theApp->ConfigDir + wxT("emfriends.met"));
if (!metfile.FileExists()) {
return;
}
CFile file;
try {
if ( file.Open(metfile) ) {
if ( file.ReadUInt8() /*header*/ == MET_HEADER ) {
uint32 nRecordsNumber = file.ReadUInt32();
for (uint32 i = 0; i < nRecordsNumber; i++) {
CFriend* Record = new CFriend();
Record->LoadFromFile(&file);
m_FriendList.push_back(Record);
Notify_ChatUpdateFriend(Record);
}
}
} else {
AddLogLineN(_("Failed to open friend list file 'emfriends.met' for reading!"));
}
} catch (const CInvalidPacket& e) {
AddDebugLogLineC(logGeneral, wxT("Invalid entry in friend list, file may be corrupt: ") + e.what());
} catch (const CSafeIOException& e) {
AddDebugLogLineC(logGeneral, wxT("IO error while reading 'emfriends.met': ") + e.what());
}
}
int CamuleDaemonApp::OnExit()
{
#ifdef AMULED28
/*
* Stop all socket threads before entering
* shutdown sequence.
*/
delete listensocket;
listensocket = 0;
if (clientudp) {
delete clientudp;
clientudp = NULL;
}
#endif
ShutDown();
#ifndef __WXMSW__
int ret = sigaction(SIGCHLD, &m_oldSignalChildAction, NULL);
if (ret == -1) {
AddDebugLogLineC(logStandard, CFormat(wxT("CamuleDaemonApp::OnRun(): second sigaction() failed: %m.")));
} else {
AddDebugLogLineN(logGeneral, wxT("CamuleDaemonApp::OnRun(): Uninstallation of SIGCHLD callback with sigaction() succeeded."));
}
#endif // __WXMSW__
// lfroen: delete socket threads
if (ECServerHandler) {
ECServerHandler = 0;
}
delete core_timer;
return CamuleApp::OnExit();
}
// This function is used to check if a syscall failed, in that case
// log an appropriate message containing the errno string.
inline void syscall_check(
bool check,
const CPath& filePath,
const wxString& what)
{
if (!check) {
AddDebugLogLineC(logCFile,
CFormat(wxT("Error when %s (%s): %s"))
% what % filePath % wxSysErrorMsg());
}
}
int CamuleDaemonApp::OnRun()
{
if (!thePrefs::AcceptExternalConnections()) {
AddLogLineCS(_("ERROR: aMule daemon cannot be used when external connections are disabled. To enable External Connections, use either a normal aMule, start amuled with the option --ec-config or set the key \"AcceptExternalConnections\" to 1 in the file ~/.aMule/amule.conf"));
return 0;
} else if (thePrefs::ECPassword().IsEmpty()) {
AddLogLineCS(_("ERROR: A valid password is required to use external connections, and aMule daemon cannot be used without external connections. To run aMule deamon, you must set the \"ECPassword\" field in the file ~/.aMule/amule.conf with an appropriate value. Execute amuled with the flag --ec-config to set the password. More information can be found at http://wiki.amule.org"));
return 0;
}
#ifndef __WXMSW__
// Process the return code of dead children so that we do not create
// zombies. wxBase does not implement wxProcess callbacks, so no one
// actualy calls wxHandleProcessTermination() in console applications.
// We do our best here.
int ret = 0;
ret = sigaction(SIGCHLD, NULL, &m_oldSignalChildAction);
m_newSignalChildAction = m_oldSignalChildAction;
m_newSignalChildAction.sa_sigaction = OnSignalChildHandler;
m_newSignalChildAction.sa_flags |= SA_SIGINFO;
m_newSignalChildAction.sa_flags &= ~SA_RESETHAND;
ret = sigaction(SIGCHLD, &m_newSignalChildAction, NULL);
if (ret == -1) {
AddDebugLogLineC(logStandard, CFormat(wxT("CamuleDaemonApp::OnRun(): Installation of SIGCHLD callback with sigaction() failed: %m.")));
} else {
AddDebugLogLineN(logGeneral, wxT("CamuleDaemonApp::OnRun(): Installation of SIGCHLD callback with sigaction() succeeded."));
}
#endif // __WXMSW__
#ifdef AMULED28
while ( !m_Exit ) {
m_table->RunSelect();
ProcessPendingEvents();
((CDaemonAppTraits *)GetTraits())->DeletePending();
}
// ShutDown is beeing called twice. Once here and again in OnExit().
ShutDown();
return 0;
#else
#ifdef AMULED_DUMMY
return 0;
#else
return wxApp::OnRun();
#endif
#endif
}
void CMuleUDPSocket::OnDisconnected(int WXUNUSED(errorCode))
{
/* Due to bugs in wxWidgets, UDP sockets will sometimes
* be closed. This is caused by the fact that wx treats
* zero-length datagrams as EOF, which is only the case
* when dealing with streaming sockets.
*
* This has been reported as patch #1885472:
* http://sourceforge.net/tracker/index.php?func=detail&aid=1885472&group_id=9863&atid=309863
*/
AddDebugLogLineC(logMuleUDP, m_name + wxT("Socket died, recreating."));
DestroySocket();
CreateSocket();
}
void CThreadScheduler::CreateSchedulerThread()
{
if ((m_thread && m_thread->IsAlive()) || m_tasks.empty()) {
return;
}
// A thread can only be run once, so the old one must be safely disposed of
if (m_thread) {
AddDebugLogLineN(logThreads, wxT("CreateSchedulerThread: Disposing of old thread."));
m_thread->Stop();
delete m_thread;
}
m_thread = new CTaskThread(this);
wxThreadError err = m_thread->Create();
if (err == wxTHREAD_NO_ERROR) {
// Try to avoid reducing the latency of the main thread
m_thread->SetPriority(WXTHREAD_MIN_PRIORITY);
err = m_thread->Run();
if (err == wxTHREAD_NO_ERROR) {
AddDebugLogLineN(logThreads, wxT("Scheduler thread started"));
return;
} else {
AddDebugLogLineC(logThreads, wxT("Error while starting scheduler thread: ") + GetErrMsg(err));
}
} else {
AddDebugLogLineC(logThreads, wxT("Error while creating scheduler thread: ") + GetErrMsg(err));
}
// Creation or running failed.
m_thread->Stop();
delete m_thread;
m_thread = NULL;
}
bool CClientList::SendChatMessage(uint64 client_id, const wxString& message)
{
CUpDownClient* client = FindClientByIP(IP_FROM_GUI_ID(client_id), PORT_FROM_GUI_ID(client_id));
AddDebugLogLineN( logClient, wxT("Trying to Send Message.") );
if (client) {
AddDebugLogLineN( logClient, wxT("Sending.") );
} else {
AddDebugLogLineC( logClient,
CFormat( wxT("No client (GUI_ID %lli [%s:%llu]) found in CClientList::SendChatMessage(). Creating") )
% client_id
% Uint32toStringIP(IP_FROM_GUI_ID(client_id))
% PORT_FROM_GUI_ID(client_id) );
client = new CUpDownClient(PORT_FROM_GUI_ID(client_id),IP_FROM_GUI_ID(client_id),0,0,NULL, true, true);
AddClient(client);
}
return client->SendChatMessage(message);
}
void CMuleUDPSocket::CreateSocket()
{
wxCHECK_RET(!m_socket, wxT("Socket already opened."));
m_socket = new CEncryptedDatagramSocket(m_addr, wxSOCKET_NOWAIT, m_proxy);
m_socket->SetClientData(this);
m_socket->SetEventHandler(*theApp, m_id);
m_socket->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_LOST_FLAG);
m_socket->Notify(true);
if (!m_socket->IsOk()) {
AddDebugLogLineC(logMuleUDP, wxT("Failed to create valid ") + m_name);
DestroySocket();
} else {
AddLogLineN(wxString(wxT("Created ")) << m_name << wxT(" at port ") << m_addr.Service());
}
}
void CDownloadQueue::AddSearchToDownload(CSearchFile* toadd, uint8 category)
{
if ( IsFileExisting(toadd->GetFileHash()) ) {
return;
}
if (toadd->GetFileSize() > OLD_MAX_FILE_SIZE) {
if (!PlatformSpecific::CanFSHandleLargeFiles(thePrefs::GetTempDir())) {
AddLogLineC(_("Filesystem for Temp directory cannot handle large files."));
return;
} else if (!PlatformSpecific::CanFSHandleLargeFiles(theApp->glob_prefs->GetCatPath(category))) {
AddLogLineC(_("Filesystem for Incoming directory cannot handle large files."));
return;
}
}
CPartFile* newfile = NULL;
try {
newfile = new CPartFile(toadd);
} catch (const CInvalidPacket& WXUNUSED(e)) {
AddDebugLogLineC(logDownloadQueue, wxT("Search-result contained invalid tags, could not add"));
}
if ( newfile && newfile->GetStatus() != PS_ERROR ) {
AddDownload( newfile, thePrefs::AddNewFilesPaused(), category );
// Add any possible sources
if (toadd->GetClientID() && toadd->GetClientPort()) {
CMemFile sources(1+4+2);
sources.WriteUInt8(1);
sources.WriteUInt32(toadd->GetClientID());
sources.WriteUInt16(toadd->GetClientPort());
sources.Reset();
newfile->AddSources(sources, toadd->GetClientServerIP(), toadd->GetClientServerPort(), SF_SEARCH_RESULT, false);
}
for (std::list<CSearchFile::ClientStruct>::const_iterator it = toadd->GetClients().begin(); it != toadd->GetClients().end(); ++it) {
CMemFile sources(1+4+2);
sources.WriteUInt8(1);
sources.WriteUInt32(it->m_ip);
sources.WriteUInt16(it->m_port);
sources.Reset();
newfile->AddSources(sources, it->m_serverIP, it->m_serverPort, SF_SEARCH_RESULT, false);
}
} else {
delete newfile;
}
}
void CFriendList::SaveList()
{
CFile file;
if (file.Create(theApp->ConfigDir + wxT("emfriends.met"), true)) {
try {
file.WriteUInt8(MET_HEADER);
file.WriteUInt32(m_FriendList.size());
for (FriendList::iterator it = m_FriendList.begin(); it != m_FriendList.end(); ++it) {
(*it)->WriteToFile(&file);
}
} catch (const CIOFailureException& e) {
AddDebugLogLineC(logGeneral, wxT("IO failure while saving 'emfriends.met': ") + e.what());
}
} else {
AddLogLineN(_("Failed to open friend list file 'emfriends.met' for writing!"));
}
}
bool CAICHHashSet::LoadHashSet()
{
if (m_eStatus != AICH_HASHSETCOMPLETE) {
wxFAIL;
return false;
}
if ( !m_pHashTree.m_bHashValid || m_pHashTree.m_nDataSize != m_pOwner->GetFileSize() || m_pHashTree.m_nDataSize == 0) {
wxFAIL;
return false;
}
wxString fullpath = theApp->ConfigDir + KNOWN2_MET_FILENAME;
CFile file(fullpath, CFile::read);
if (!file.IsOpened()) {
if (wxFileExists(fullpath)) {
wxString strError(wxT("Failed to load ") KNOWN2_MET_FILENAME wxT(" file"));
AddDebugLogLineC(logSHAHashSet, strError);
}
return false;
}
try {
uint8 header = file.ReadUInt8();
if (header != KNOWN2_MET_VERSION) {
AddDebugLogLineC(logSHAHashSet, wxT("Loading failed: Current file is not a met-file!"));
return false;
}
CAICHHash CurrentHash;
uint64 nExistingSize = file.GetLength();
uint32 nHashCount;
while (file.GetPosition() < nExistingSize) {
CurrentHash.Read(&file);
if (m_pHashTree.m_Hash == CurrentHash) {
// found Hashset
uint32 nExpectedCount = (PARTSIZE/EMBLOCKSIZE + ((PARTSIZE % EMBLOCKSIZE != 0)? 1 : 0)) * (m_pHashTree.m_nDataSize/PARTSIZE);
if (m_pHashTree.m_nDataSize % PARTSIZE != 0) {
nExpectedCount += (m_pHashTree.m_nDataSize % PARTSIZE)/EMBLOCKSIZE + (((m_pHashTree.m_nDataSize % PARTSIZE) % EMBLOCKSIZE != 0)? 1 : 0);
}
nHashCount = file.ReadUInt32();
if (nHashCount != nExpectedCount) {
AddDebugLogLineC(logSHAHashSet, wxT("Failed to load HashSet: Available Hashs and expected hashcount differ!"));
return false;
}
if (!m_pHashTree.LoadLowestLevelHashs(&file)) {
AddDebugLogLineC(logSHAHashSet, wxT("Failed to load HashSet: LoadLowestLevelHashs failed!"));
return false;
}
if (!ReCalculateHash(false)) {
AddDebugLogLineC(logSHAHashSet, wxT("Failed to load HashSet: Calculating loaded hashs failed!"));
return false;
}
if (CurrentHash != m_pHashTree.m_Hash) {
AddDebugLogLineC(logSHAHashSet, wxT("Failed to load HashSet: Calculated Masterhash differs from given Masterhash - hashset corrupt!"));
return false;
}
return true;
}
nHashCount = file.ReadUInt32();
if (file.GetPosition() + nHashCount*HASHSIZE > nExistingSize) {
AddDebugLogLineC(logSHAHashSet, wxT("Saving failed: File contains fewer entries than specified!"));
return false;
}
// skip the rest of this hashset
file.Seek(nHashCount*HASHSIZE, wxFromCurrent);
}
AddDebugLogLineC(logSHAHashSet, wxT("Failed to load HashSet: HashSet not found!"));
} catch (const CSafeIOException& e) {
AddDebugLogLineC(logSHAHashSet, wxT("IO error while loading AICH HashSet: ") + e.what());
}
return false;
}
/**
* Try to put queued up data on the socket.
*
* Control packets have higher priority, and will be sent first, if possible.
* Standard packets can be split up in several package containers. In that case
* all the parts of a split package must be sent in a row, without any control packet
* in between.
*
* @param maxNumberOfBytesToSend This is the maximum number of bytes that is allowed to be put on the socket
* this call. The actual number of sent bytes will be returned from the method.
*
* @param onlyAllowedToSendControlPacket This call we only try to put control packets on the sockets.
* If there's a standard packet "in the way", and we think that this socket
* is no longer an upload slot, then it is ok to send the standard packet to
* get it out of the way. But it is not allowed to pick a new standard packet
* from the queue during this call. Several split packets are counted as one
* standard packet though, so it is ok to finish them all off if necessary.
*
* @return the actual number of bytes that were put on the socket.
*/
SocketSentBytes CEMSocket::Send(uint32 maxNumberOfBytesToSend, uint32 minFragSize, bool onlyAllowedToSendControlPacket)
{
wxMutexLocker lock(m_sendLocker);
//printf("* Attempt to send a packet on socket %p\n", this);
if (byConnected == ES_DISCONNECTED) {
//printf("* Disconnected socket %p\n", this);
SocketSentBytes returnVal = { false, 0, 0 };
return returnVal;
} else if (m_bBusy && onlyAllowedToSendControlPacket) {
//printf("* Busy socket %p\n", this);
SocketSentBytes returnVal = { true, 0, 0 };
return returnVal;
}
bool anErrorHasOccured = false;
uint32 sentStandardPacketBytesThisCall = 0;
uint32 sentControlPacketBytesThisCall = 0;
if (byConnected == ES_CONNECTED && IsEncryptionLayerReady() && (!m_bBusy || onlyAllowedToSendControlPacket)) {
//printf("* Internal attemptto send on %p\n", this);
if(minFragSize < 1) {
minFragSize = 1;
}
maxNumberOfBytesToSend = GetNextFragSize(maxNumberOfBytesToSend, minFragSize);
bool bWasLongTimeSinceSend = (::GetTickCount() - lastSent) > 1000;
lastCalledSend = ::GetTickCount();
while(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall < maxNumberOfBytesToSend && anErrorHasOccured == false && // don't send more than allowed. Also, there should have been no error in earlier loop
(!m_control_queue.empty() || !m_standard_queue.empty() || sendbuffer != NULL) && // there must exist something to send
(onlyAllowedToSendControlPacket == false || // this means we are allowed to send both types of packets, so proceed
(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall > 0 && (sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall) % minFragSize != 0) ||
(sendbuffer == NULL && !m_control_queue.empty()) || // There's a control packet in queue, and we are not currently sending anything, so we will handle the control packet next
(sendbuffer != NULL && m_currentPacket_is_controlpacket == true) || // We are in the progress of sending a control packet. We are always allowed to send those
(sendbuffer != NULL && m_currentPacket_is_controlpacket == false && bWasLongTimeSinceSend && !m_control_queue.empty() && m_standard_queue.empty() && (sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall) < minFragSize) // We have waited to long to clean the current packet (which may be a standard packet that is in the way). Proceed no matter what the value of onlyAllowedToSendControlPacket.
)
) {
// If we are currently not in the progress of sending a packet, we will need to find the next one to send
if(sendbuffer == NULL) {
CPacket* curPacket = NULL;
if(!m_control_queue.empty()) {
// There's a control packet to send
m_currentPacket_is_controlpacket = true;
curPacket = m_control_queue.front();
m_control_queue.pop_front();
} else if(!m_standard_queue.empty() /*&& onlyAllowedToSendControlPacket == false*/) {
// There's a standard packet to send
m_currentPacket_is_controlpacket = false;
StandardPacketQueueEntry queueEntry = m_standard_queue.front();
m_standard_queue.pop_front();
curPacket = queueEntry.packet;
m_actualPayloadSize = queueEntry.actualPayloadSize;
// remember this for statistics purposes.
m_currentPackageIsFromPartFile = curPacket->IsFromPF();
} else {
// Just to be safe. Shouldn't happen?
// if we reach this point, then there's something wrong with the while condition above!
wxFAIL;
AddDebugLogLineC(logGeneral, wxT("EMSocket: Couldn't get a new packet! There's an error in the first while condition in EMSocket::Send()"));
SocketSentBytes returnVal = { true, sentStandardPacketBytesThisCall, sentControlPacketBytesThisCall };
return returnVal;
}
// We found a packet to send. Get the data to send from the
// package container and dispose of the container.
sendblen = curPacket->GetRealPacketSize();
sendbuffer = curPacket->DetachPacket();
sent = 0;
delete curPacket;
CryptPrepareSendData((byte*)sendbuffer, sendblen);
}
// At this point we've got a packet to send in sendbuffer. Try to send it. Loop until entire packet
// is sent, or until we reach maximum bytes to send for this call, or until we get an error.
// NOTE! If send would block (returns WOULDBLOCK), we will return from this method INSIDE this loop.
while (sent < sendblen &&
sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall < maxNumberOfBytesToSend &&
(
onlyAllowedToSendControlPacket == false || // this means we are allowed to send both types of packets, so proceed
m_currentPacket_is_controlpacket ||
(bWasLongTimeSinceSend && (sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall) < minFragSize) ||
(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall) % minFragSize != 0
) &&
anErrorHasOccured == false) {
uint32 tosend = sendblen-sent;
if(!onlyAllowedToSendControlPacket || m_currentPacket_is_controlpacket) {
if (maxNumberOfBytesToSend >= sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall && tosend > maxNumberOfBytesToSend-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall))
tosend = maxNumberOfBytesToSend-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall);
} else if(bWasLongTimeSinceSend && (sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall) < minFragSize) {
if (minFragSize >= sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall && tosend > minFragSize-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall))
tosend = minFragSize-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall);
} else {
uint32 nextFragMaxBytesToSent = GetNextFragSize(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall, minFragSize);
if (nextFragMaxBytesToSent >= sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall && tosend > nextFragMaxBytesToSent-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall))
tosend = nextFragMaxBytesToSent-(sentStandardPacketBytesThisCall + sentControlPacketBytesThisCall);
}
wxASSERT(tosend != 0 && tosend <= sendblen-sent);
//DWORD tempStartSendTick = ::GetTickCount();
lastSent = ::GetTickCount();
uint32 result = CEncryptedStreamSocket::Write(sendbuffer+sent,tosend);
if (Error()){
uint32 error = LastError();
if (error == wxSOCKET_WOULDBLOCK){
m_bBusy = true;
SocketSentBytes returnVal = { true, sentStandardPacketBytesThisCall, sentControlPacketBytesThisCall };
return returnVal; // Send() blocked, onsend will be called when ready to send again
} else{
// Send() gave an error
anErrorHasOccured = true;
}
} else {
// we managed to send some bytes. Perform bookkeeping.
m_bBusy = false;
m_hasSent = true;
sent += result;
// Log send bytes in correct class
if(m_currentPacket_is_controlpacket == false) {
sentStandardPacketBytesThisCall += result;
if(m_currentPackageIsFromPartFile == true) {
m_numberOfSentBytesPartFile += result;
} else {
m_numberOfSentBytesCompleteFile += result;
}
} else {
sentControlPacketBytesThisCall += result;
m_numberOfSentBytesControlPacket += result;
}
}
}
if (sent == sendblen){
// we are done sending the current packet. Delete it and set
// sendbuffer to NULL so a new packet can be fetched.
delete[] sendbuffer;
sendbuffer = NULL;
sendblen = 0;
if(!m_currentPacket_is_controlpacket) {
m_actualPayloadSizeSent += m_actualPayloadSize;
m_actualPayloadSize = 0;
lastFinishedStandard = ::GetTickCount(); // reset timeout
m_bAccelerateUpload = false; // Safe until told otherwise
}
sent = 0;
}
}
}
if(onlyAllowedToSendControlPacket && (!m_control_queue.empty() || (sendbuffer != NULL && m_currentPacket_is_controlpacket))) {
// enter control packet send queue
// we might enter control packet queue several times for the same package,
// but that costs very little overhead. Less overhead than trying to make sure
// that we only enter the queue once.
//printf("* Requeueing control packet on %p\n", this);
theApp->uploadBandwidthThrottler->QueueForSendingControlPacket(this, HasSent());
}
//printf("* Finishing send debug on %p\n",this);
SocketSentBytes returnVal = { !anErrorHasOccured, sentStandardPacketBytesThisCall, sentControlPacketBytesThisCall };
return returnVal;
}
CUPnPService::CUPnPService(
const CUPnPControlPoint &upnpControlPoint,
CUPnPLib &upnpLib,
IXML_Element *service,
const std::string &URLBase)
:
m_UPnPControlPoint(upnpControlPoint),
m_upnpLib(upnpLib),
m_serviceType(upnpLib.Element_GetChildValueByTag(service, "serviceType")),
m_serviceId (upnpLib.Element_GetChildValueByTag(service, "serviceId")),
m_SCPDURL (upnpLib.Element_GetChildValueByTag(service, "SCPDURL")),
m_controlURL (upnpLib.Element_GetChildValueByTag(service, "controlURL")),
m_eventSubURL(upnpLib.Element_GetChildValueByTag(service, "eventSubURL")),
m_timeout(1801),
m_SCPD(NULL)
{
std::ostringstream msg;
int errcode;
std::vector<char> vscpdURL(URLBase.length() + m_SCPDURL.length() + 1);
char *scpdURL = &vscpdURL[0];
errcode = UpnpResolveURL(
URLBase.c_str(),
m_SCPDURL.c_str(),
scpdURL);
if( errcode != UPNP_E_SUCCESS ) {
msg << "Error generating scpdURL from " <<
"|" << URLBase << "|" <<
m_SCPDURL << "|.";
AddDebugLogLineN(logUPnP, msg);
} else {
m_absSCPDURL = scpdURL;
}
std::vector<char> vcontrolURL(
URLBase.length() + m_controlURL.length() + 1);
char *controlURL = &vcontrolURL[0];
errcode = UpnpResolveURL(
URLBase.c_str(),
m_controlURL.c_str(),
controlURL);
if( errcode != UPNP_E_SUCCESS ) {
msg << "Error generating controlURL from " <<
"|" << URLBase << "|" <<
m_controlURL << "|.";
AddDebugLogLineN(logUPnP, msg);
} else {
m_absControlURL = controlURL;
}
std::vector<char> veventURL(
URLBase.length() + m_eventSubURL.length() + 1);
char *eventURL = &veventURL[0];
errcode = UpnpResolveURL(
URLBase.c_str(),
m_eventSubURL.c_str(),
eventURL);
if( errcode != UPNP_E_SUCCESS ) {
msg << "Error generating eventURL from " <<
"|" << URLBase << "|" <<
m_eventSubURL << "|.";
AddDebugLogLineN(logUPnP, msg);
} else {
m_absEventSubURL = eventURL;
}
msg << "\n Service:" <<
"\n serviceType: " << m_serviceType <<
"\n serviceId: " << m_serviceId <<
"\n SCPDURL: " << m_SCPDURL <<
"\n absSCPDURL: " << m_absSCPDURL <<
"\n controlURL: " << m_controlURL <<
"\n absControlURL: " << m_absControlURL <<
"\n eventSubURL: " << m_eventSubURL <<
"\n absEventSubURL: " << m_absEventSubURL;
AddDebugLogLineN(logUPnP, msg);
if (m_serviceType == upnpLib.UPNP_SERVICE_WAN_IP_CONNECTION ||
m_serviceType == upnpLib.UPNP_SERVICE_WAN_PPP_CONNECTION) {
#if 0
m_serviceType == upnpLib.UPNP_SERVICE_WAN_PPP_CONNECTION ||
m_serviceType == upnpLib.UPNP_SERVICE_WAN_COMMON_INTERFACE_CONFIG ||
m_serviceType == upnpLib.UPNP_SERVICE_LAYER3_FORWARDING) {
#endif
#if 0
//#warning Delete this code on release.
if (!upnpLib.m_ctrlPoint.WanServiceDetected()) {
// This condition can be used to suspend the parse
// of the XML tree.
#endif
//#warning Delete this code when m_WanService is no longer used.
upnpLib.m_ctrlPoint.SetWanService(this);
// Log it
msg.str("");
msg << "WAN Service Detected: '" <<
m_serviceType << "'.";
AddDebugLogLineC(logUPnP, msg);
// Subscribe
upnpLib.m_ctrlPoint.Subscribe(*this);
#if 0
//#warning Delete this code on release.
} else {
msg.str("");
msg << "WAN service detected again: '" <<
m_serviceType <<
"'. Will only use the first instance.";
AddDebugLogLineC(logUPnP, msg);
}
#endif
} else {
void CSearchDlg::StartNewSearch()
{
static uint32 m_nSearchID = 0;
m_nSearchID++;
FindWindow(IDC_STARTS)->Disable();
FindWindow(IDC_SDOWNLOAD)->Disable();
FindWindow(IDC_CANCELS)->Enable();
CSearchList::CSearchParams params;
params.searchString = CastChild( IDC_SEARCHNAME, wxTextCtrl )->GetValue();
params.searchString.Trim(true);
params.searchString.Trim(false);
if (params.searchString.IsEmpty()) {
return;
}
if (CastChild(IDC_EXTENDEDSEARCHCHECK, wxCheckBox)->GetValue()) {
params.extension = CastChild( IDC_EDITSEARCHEXTENSION, wxTextCtrl )->GetValue();
uint32 sizemin = GetTypeSize( (uint8) CastChild( IDC_SEARCHMINSIZE, wxChoice )->GetSelection() );
uint32 sizemax = GetTypeSize( (uint8) CastChild( IDC_SEARCHMAXSIZE, wxChoice )->GetSelection() );
// Parameter Minimum Size
params.minSize = (uint64_t)(CastChild( IDC_SPINSEARCHMIN, wxSpinCtrl )->GetValue()) * (uint64_t)sizemin;
// Parameter Maximum Size
params.maxSize = (uint64_t)(CastChild( IDC_SPINSEARCHMAX, wxSpinCtrl )->GetValue()) * (uint64_t)sizemax;
if ((params.maxSize < params.minSize) && (params.maxSize)) {
wxMessageDialog dlg(this,
_("Min size must be smaller than max size. Max size ignored."),
_("Search warning"), wxOK|wxCENTRE|wxICON_INFORMATION);
dlg.ShowModal();
params.maxSize = 0;
}
// Parameter Availability
params.availability = CastChild( IDC_SPINSEARCHAVAIBILITY, wxSpinCtrl )->GetValue();
switch ( CastChild( IDC_TypeSearch, wxChoice )->GetSelection() ) {
case 0: params.typeText.Clear(); break;
case 1: params.typeText = ED2KFTSTR_ARCHIVE; break;
case 2: params.typeText = ED2KFTSTR_AUDIO; break;
case 3: params.typeText = ED2KFTSTR_CDIMAGE; break;
case 4: params.typeText = ED2KFTSTR_IMAGE; break;
case 5: params.typeText = ED2KFTSTR_PROGRAM; break;
case 6: params.typeText = ED2KFTSTR_DOCUMENT; break;
case 7: params.typeText = ED2KFTSTR_VIDEO; break;
default:
AddDebugLogLineC( logGeneral,
CFormat( wxT("Warning! Unknown search-category (%s) selected!") )
% params.typeText
);
break;
}
}
SearchType search_type = KadSearch;
int selection = CastChild( ID_SEARCHTYPE, wxChoice )->GetSelection();
if (!thePrefs::GetNetworkED2K()) {
selection += 2;
}
if (!thePrefs::GetNetworkKademlia()) {
selection += 1;
}
switch (selection) {
case 0: // Local Search
search_type = LocalSearch;
break;
case 1: // Global Search
search_type = GlobalSearch;
break;
case 2: // Kad search
search_type = KadSearch;
break;
default:
// Should never happen
wxFAIL;
break;
}
uint32 real_id = m_nSearchID;
wxString error = theApp->searchlist->StartNewSearch(&real_id, search_type, params);
if (!error.IsEmpty()) {
// Search failed / Remote in progress
wxMessageBox(error, _("Search warning"),
wxOK | wxCENTRE | wxICON_INFORMATION, this);
FindWindow(IDC_STARTS)->Enable();
FindWindow(IDC_SDOWNLOAD)->Disable();
FindWindow(IDC_CANCELS)->Disable();
} else {
CreateNewTab(
((search_type == KadSearch) ? wxT("!") : wxEmptyString) +
params.searchString + wxT(" (0)"),
real_id);
}
}
ConvStatus CPartFileConvert::performConvertToeMule(const CPath& fileName)
{
wxString filepartindex;
CPath folder = fileName.GetPath();
CPath partfile = fileName.GetFullName();
CPath newfilename;
CDirIterator finder(folder);
Notify_ConvertUpdateProgressFull(0, _("Reading temp folder"), s_pfconverting->folder.GetPrintable());
filepartindex = partfile.RemoveAllExt().GetRaw();
Notify_ConvertUpdateProgress(4, _("Retrieving basic information from download info file"));
CPartFile* file = new CPartFile();
s_pfconverting->partmettype = file->LoadPartFile(folder, partfile, false, true);
switch (s_pfconverting->partmettype) {
case PMT_UNKNOWN:
case PMT_BADFORMAT:
delete file;
return CONV_BADFORMAT;
}
CPath oldfile = folder.JoinPaths(partfile.RemoveExt());
{
wxMutexLocker lock(s_mutex);
s_pfconverting->size = file->GetFileSize();
s_pfconverting->filename = file->GetFileName();
s_pfconverting->filehash = file->GetFileHash().Encode();
}
Notify_ConvertUpdateJobInfo(s_pfconverting);
if (theApp->downloadqueue->GetFileByID(file->GetFileHash())) {
delete file;
return CONV_ALREADYEXISTS;
}
if (s_pfconverting->partmettype == PMT_SPLITTED) {
unsigned fileindex;
char *ba = new char [PARTSIZE];
try {
CFile inputfile;
// just count
unsigned maxindex = 0;
unsigned partfilecount = 0;
CPath filePath = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*.part"));
while (filePath.IsOk()) {
long l;
++partfilecount;
filePath.GetFullName().RemoveExt().GetExt().ToLong(&l);
fileindex = (unsigned)l;
filePath = finder.GetNextFile();
if (fileindex > maxindex) maxindex = fileindex;
}
float stepperpart;
{
wxMutexLocker lock(s_mutex);
if (partfilecount > 0) {
stepperpart = (80.0f / partfilecount);
if (maxindex * PARTSIZE <= s_pfconverting->size) {
s_pfconverting->spaceneeded = maxindex * PARTSIZE;
} else {
s_pfconverting->spaceneeded = s_pfconverting->size;
}
} else {
stepperpart = 80.0f;
s_pfconverting->spaceneeded = 0;
}
}
Notify_ConvertUpdateJobInfo(s_pfconverting);
sint64 freespace = CPath::GetFreeSpaceAt(thePrefs::GetTempDir());
if (freespace != wxInvalidOffset) {
if (static_cast<uint64>(freespace) < maxindex * PARTSIZE) {
delete file;
delete [] ba;
return CONV_OUTOFDISKSPACE;
}
}
// create new partmetfile, and remember the new name
file->CreatePartFile();
newfilename = file->GetFullName();
Notify_ConvertUpdateProgress(8, _("Creating destination file"));
file->m_hpartfile.SetLength( s_pfconverting->spaceneeded );
unsigned curindex = 0;
CPath filename = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*.part"));
while (filename.IsOk()) {
// stats
++curindex;
Notify_ConvertUpdateProgress(10 + (curindex * stepperpart), CFormat(_("Loading data from old download file (%u of %u)")) % curindex % partfilecount);
long l;
filename.GetFullName().RemoveExt().GetExt().ToLong(&l);
fileindex = (unsigned)l;
if (fileindex == 0) {
filename = finder.GetNextFile();
continue;
}
uint32 chunkstart = (fileindex - 1) * PARTSIZE;
// open, read data of the part-part-file into buffer, close file
inputfile.Open(filename, CFile::read);
uint64 toReadWrite = std::min<uint64>(PARTSIZE, inputfile.GetLength());
inputfile.Read(ba, toReadWrite);
inputfile.Close();
Notify_ConvertUpdateProgress(10 + (curindex * stepperpart), CFormat(_("Saving data block into new single download file (%u of %u)")) % curindex % partfilecount);
// write the buffered data
file->m_hpartfile.WriteAt(ba, chunkstart, toReadWrite);
filename = finder.GetNextFile();
}
delete[] ba;
} catch (const CSafeIOException& e) {
AddDebugLogLineC(logPfConvert, wxT("IO error while converting partfiles: ") + e.what());
delete[] ba;
file->Delete();
return CONV_IOERROR;
}
file->m_hpartfile.Close();
}
// import an external common format partdownload
else //if (pfconverting->partmettype==PMT_DEFAULTOLD || pfconverting->partmettype==PMT_NEWOLD || Shareaza )
{
if (!s_pfconverting->removeSource) {
wxMutexLocker lock(s_mutex);
s_pfconverting->spaceneeded = oldfile.GetFileSize();
}
Notify_ConvertUpdateJobInfo(s_pfconverting);
sint64 freespace = CPath::GetFreeSpaceAt(thePrefs::GetTempDir());
if (freespace == wxInvalidOffset) {
delete file;
return CONV_IOERROR;
} else if (freespace < s_pfconverting->spaceneeded) {
delete file;
return CONV_OUTOFDISKSPACE;
}
file->CreatePartFile();
newfilename = file->GetFullName();
file->m_hpartfile.Close();
bool ret = false;
Notify_ConvertUpdateProgress(92, _("Copy"));
CPath::RemoveFile(newfilename.RemoveExt());
if (!oldfile.FileExists()) {
// data file does not exist. well, then create a 0 byte big one
CFile datafile;
ret = datafile.Create(newfilename.RemoveExt());
} else if (s_pfconverting->removeSource) {
ret = CPath::RenameFile(oldfile, newfilename.RemoveExt());
} else {
ret = CPath::CloneFile(oldfile, newfilename.RemoveExt(), false);
}
if (!ret) {
file->Delete();
//delete file;
return CONV_FAILED;
}
}
Notify_ConvertUpdateProgress(94, _("Retrieving source downloadfile information"));
CPath::RemoveFile(newfilename);
if (s_pfconverting->removeSource) {
CPath::RenameFile(folder.JoinPaths(partfile), newfilename);
} else {
CPath::CloneFile(folder.JoinPaths(partfile), newfilename, false);
}
file->m_hashlist.clear();
if (!file->LoadPartFile(thePrefs::GetTempDir(), file->GetPartMetFileName(), false)) {
//delete file;
file->Delete();
return CONV_BADFORMAT;
}
if (s_pfconverting->partmettype == PMT_NEWOLD || s_pfconverting->partmettype == PMT_SPLITTED) {
file->SetCompletedSize(file->transferred);
file->m_iGainDueToCompression = 0;
file->m_iLostDueToCorruption = 0;
}
Notify_ConvertUpdateProgress(100, _("Adding download and saving new partfile"));
theApp->downloadqueue->AddDownload(file, thePrefs::AddNewFilesPaused(), 0);
file->SavePartFile();
if (file->GetStatus(true) == PS_READY) {
theApp->sharedfiles->SafeAddKFile(file); // part files are always shared files
}
if (s_pfconverting->removeSource) {
CPath oldFile = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*"));
while (oldFile.IsOk()) {
CPath::RemoveFile(folder.JoinPaths(oldFile));
oldFile = finder.GetNextFile();
}
if (s_pfconverting->partmettype == PMT_SPLITTED) {
CPath::RemoveDir(folder);
}
}
return CONV_OK;
}
// this function is only allowed to be called right after successfully calculating the hashset (!)
// will delete the hashset, after saving to free the memory
bool CAICHHashSet::SaveHashSet()
{
if (m_eStatus != AICH_HASHSETCOMPLETE) {
wxFAIL;
return false;
}
if ( !m_pHashTree.m_bHashValid || m_pHashTree.m_nDataSize != m_pOwner->GetFileSize()) {
wxFAIL;
return false;
}
try {
const wxString fullpath = theApp->ConfigDir + KNOWN2_MET_FILENAME;
const bool exists = wxFile::Exists(fullpath);
CFile file(fullpath, exists ? CFile::read_write : CFile::write);
if (!file.IsOpened()) {
AddDebugLogLineC(logSHAHashSet, wxT("Failed to save HashSet: opening met file failed!"));
return false;
}
uint64 nExistingSize = file.GetLength();
if (nExistingSize) {
uint8 header = file.ReadUInt8();
if (header != KNOWN2_MET_VERSION) {
AddDebugLogLineC(logSHAHashSet, wxT("Saving failed: Current file is not a met-file!"));
return false;
}
AddDebugLogLineN(logSHAHashSet, CFormat(wxT("Met file is version 0x%2.2x.")) % header);
} else {
file.WriteUInt8(KNOWN2_MET_VERSION);
// Update the recorded size, in order for the sanity check below to work.
nExistingSize += 1;
}
// first we check if the hashset we want to write is already stored
CAICHHash CurrentHash;
while (file.GetPosition() < nExistingSize) {
CurrentHash.Read(&file);
if (m_pHashTree.m_Hash == CurrentHash) {
// this hashset if already available, no need to save it again
return true;
}
uint32 nHashCount = file.ReadUInt32();
if (file.GetPosition() + nHashCount*HASHSIZE > nExistingSize) {
AddDebugLogLineC(logSHAHashSet, wxT("Saving failed: File contains fewer entries than specified!"));
return false;
}
// skip the rest of this hashset
file.Seek(nHashCount*HASHSIZE, wxFromCurrent);
}
// write hashset
m_pHashTree.m_Hash.Write(&file);
uint32 nHashCount = (PARTSIZE/EMBLOCKSIZE + ((PARTSIZE % EMBLOCKSIZE != 0)? 1 : 0)) * (m_pHashTree.m_nDataSize/PARTSIZE);
if (m_pHashTree.m_nDataSize % PARTSIZE != 0) {
nHashCount += (m_pHashTree.m_nDataSize % PARTSIZE)/EMBLOCKSIZE + (((m_pHashTree.m_nDataSize % PARTSIZE) % EMBLOCKSIZE != 0)? 1 : 0);
}
file.WriteUInt32(nHashCount);
if (!m_pHashTree.WriteLowestLevelHashs(&file, 0, true, true)) {
// thats bad... really
file.SetLength(nExistingSize);
AddDebugLogLineC(logSHAHashSet, wxT("Failed to save HashSet: WriteLowestLevelHashs() failed!"));
return false;
}
if (file.GetLength() != nExistingSize + (nHashCount+1)*HASHSIZE + 4) {
// thats even worse
file.SetLength(nExistingSize);
AddDebugLogLineC(logSHAHashSet, wxT("Failed to save HashSet: Calculated and real size of hashset differ!"));
return false;
}
AddDebugLogLineN(logSHAHashSet, CFormat(wxT("Successfully saved eMuleAC Hashset, %u Hashs + 1 Masterhash written")) % nHashCount);
} catch (const CSafeIOException& e) {
AddDebugLogLineC(logSHAHashSet, wxT("IO error while saving AICH HashSet: ") + e.what());
return false;
}
FreeHashSet();
return true;
}
