src/amuled.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25
  26 #include "amule.h"                      // Interface declarations.
  27
  28 #include <include/common/EventIDs.h>
  29
  30 #ifdef HAVE_CONFIG_H
  31         #include "config.h"             // Needed for HAVE_SYS_RESOURCE_H
  32 #endif
  33
  34 #include <wx/utils.h>
  35
  36 #include "Preferences.h"                // Needed for CPreferences
  37 #include "PartFile.h"                   // Needed for CPartFile
  38 #include "Logger.h"
  39 #include <common/Format.h>
  40 #include "InternalEvents.h"             // Needed for wxEVT_*
  41 #include "ThreadTasks.h"
  42 #include "GuiEvents.h"                  // Needed for EVT_MULE_NOTIFY
  43 #include "Timer.h"                      // Needed for EVT_MULE_TIMER
  44
  45 #include "ClientUDPSocket.h"            // Do_not_auto_remove (forward declaration not enough)
  46 #include "ListenSocket.h"               // Do_not_auto_remove (forward declaration not enough)
  47
  48
  49 #include <errno.h>
  50 #ifdef HAVE_SYS_RESOURCE_H
  51 #include <sys/resource.h> // Do_not_auto_remove
  52 #endif
  53
  54 #ifndef __WXMSW__
  55         #ifdef  HAVE_SYS_WAIT_H
  56                 #include <sys/wait.h> // Do_not_auto_remove
  57         #endif
  58
  59         #include <wx/unix/execute.h>
  60 #endif
  61
  62 BEGIN_EVENT_TABLE(CamuleDaemonApp, wxAppConsole)
  63         //
  64         // Socket handlers
  65         //
  66
  67         // Listen Socket
  68         EVT_SOCKET(ID_LISTENSOCKET_EVENT, CamuleDaemonApp::ListenSocketHandler)
  69
  70         // UDP Socket (servers)
  71         EVT_SOCKET(ID_SERVERUDPSOCKET_EVENT, CamuleDaemonApp::UDPSocketHandler)
  72         // UDP Socket (clients)
  73         EVT_SOCKET(ID_CLIENTUDPSOCKET_EVENT, CamuleDaemonApp::UDPSocketHandler)
  74
  75         // Socket timer (TCP)
  76         EVT_MULE_TIMER(ID_SERVER_RETRY_TIMER_EVENT, CamuleDaemonApp::OnTCPTimer)
  77
  78         // Core timer
  79         EVT_MULE_TIMER(ID_CORE_TIMER_EVENT, CamuleDaemonApp::OnCoreTimer)
  80
  81         EVT_MULE_NOTIFY(CamuleDaemonApp::OnNotifyEvent)
  82         EVT_MULE_LOGGING(CamuleDaemonApp::OnLoggingEvent)
  83
  84         // Async dns handling
  85         EVT_MULE_INTERNAL(wxEVT_CORE_UDP_DNS_DONE, -1, CamuleDaemonApp::OnUDPDnsDone)
  86
  87         EVT_MULE_INTERNAL(wxEVT_CORE_SOURCE_DNS_DONE, -1, CamuleDaemonApp::OnSourceDnsDone)
  88
  89         EVT_MULE_INTERNAL(wxEVT_CORE_SERVER_DNS_DONE, -1, CamuleDaemonApp::OnServerDnsDone)
  90
  91         // Hash ended notifier
  92         EVT_MULE_HASHING(CamuleDaemonApp::OnFinishedHashing)
  93         EVT_MULE_AICH_HASHING(CamuleDaemonApp::OnFinishedAICHHashing)
  94
  95         // File completion ended notifier
  96         EVT_MULE_FILE_COMPLETED(CamuleDaemonApp::OnFinishedCompletion)
  97
  98         // HTTPDownload finished
  99         EVT_MULE_INTERNAL(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, -1, CamuleDaemonApp::OnFinishedHTTPDownload)
 100 END_EVENT_TABLE()
 101
 102 IMPLEMENT_APP(CamuleDaemonApp)
 103
 104 /*
 105  * Socket handling in wxBase
 106  *
 107  */
 108 class CSocketSet {
 109                 int m_count;
 110                 int m_fds[FD_SETSIZE], m_fd_idx[FD_SETSIZE];
 111                 GSocket *m_gsocks[FD_SETSIZE];
 112
 113                 fd_set m_set;
 114         public:
 115                 CSocketSet();
 116                 void AddSocket(GSocket *);
 117                 void RemoveSocket(GSocket *);
 118                 void FillSet(int &max_fd);
 119
 120                 void Detected(void (GSocket::*func)());
 121
 122                 fd_set *Set() { return &m_set; }
 123 };
 124
 125 CSocketSet::CSocketSet()
 126 {
 127         m_count = 0;
 128         for(int i = 0; i < FD_SETSIZE; i++) {
 129                 m_fds[i] = 0;
 130                 m_fd_idx[i] = 0xffff;
 131                 m_gsocks[i] = 0;
 132         }
 133 }
 134
 135 void CSocketSet::AddSocket(GSocket *socket)
 136 {
 137         wxASSERT(socket);
 138
 139         int fd = socket->m_fd;
 140
 141         if ( fd == -1 ) {
 142                 return;
 143         }
 144
 145         wxASSERT( (fd > 2) && (fd < FD_SETSIZE) );
 146
 147         if ( m_gsocks[fd] ) {
 148                 return;
 149         }
 150         m_fds[m_count] = fd;
 151         m_fd_idx[fd] = m_count;
 152         m_gsocks[fd] = socket;
 153         m_count++;
 154 }
 155
 156 void CSocketSet::RemoveSocket(GSocket *socket)
 157 {
 158         wxASSERT(socket);
 159
 160         int fd = socket->m_fd;
 161
 162         if ( fd == -1 ) {
 163                 return;
 164         }
 165
 166         wxASSERT( (fd > 2) && (fd < FD_SETSIZE) );
 167
 168         int i = m_fd_idx[fd];
 169         if ( i == 0xffff ) {
 170                 return;
 171         }
 172         wxASSERT(m_fds[i] == fd);
 173         m_fds[i] = m_fds[m_count-1];
 174         m_gsocks[fd] = 0;
 175         m_fds[m_count-1] = 0;
 176         m_fd_idx[fd] = 0xffff;
 177         m_fd_idx[m_fds[i]] = i;
 178         m_count--;
 179 }
 180
 181 void CSocketSet::FillSet(int &max_fd)
 182 {
 183         FD_ZERO(&m_set);
 184
 185         for(int i = 0; i < m_count; i++) {
 186             FD_SET(m_fds[i], &m_set);
 187             if ( m_fds[i] > max_fd ) {
 188                 max_fd = m_fds[i];
 189             }
 190         }
 191 }
 192
 193 void CSocketSet::Detected(void (GSocket::*func)())
 194 {
 195         for (int i = 0; i < m_count; i++) {
 196                 int fd = m_fds[i];
 197                 if ( FD_ISSET(fd, &m_set) ) {
 198                         GSocket *socket = m_gsocks[fd];
 199                         (*socket.*func)();
 200                 }
 201         }
 202 }
 203
 204 CAmuledGSocketFuncTable::CAmuledGSocketFuncTable() : m_lock(wxMUTEX_RECURSIVE)
 205 {
 206         m_in_set = new CSocketSet;
 207         m_out_set = new CSocketSet;
 208
 209         m_lock.Unlock();
 210 }
 211
 212 void CAmuledGSocketFuncTable::AddSocket(GSocket *socket, GSocketEvent event)
 213 {
 214         wxMutexLocker lock(m_lock);
 215
 216         if ( event == GSOCK_INPUT ) {
 217                 m_in_set->AddSocket(socket);
 218         } else {
 219                 m_out_set->AddSocket(socket);
 220         }
 221 }
 222
 223 void CAmuledGSocketFuncTable::RemoveSocket(GSocket *socket, GSocketEvent event)
 224 {
 225         wxMutexLocker lock(m_lock);
 226
 227         if ( event == GSOCK_INPUT ) {
 228                 m_in_set->RemoveSocket(socket);
 229         } else {
 230                 m_out_set->RemoveSocket(socket);
 231         }
 232 }
 233
 234 void CAmuledGSocketFuncTable::RunSelect()
 235 {
 236         wxMutexLocker lock(m_lock);
 237
 238         int max_fd = -1;
 239         m_in_set->FillSet(max_fd);
 240         m_out_set->FillSet(max_fd);
 241
 242         struct timeval tv;
 243         tv.tv_sec = 0;
 244         tv.tv_usec = 10000; // 10ms
 245
 246         int result = select(max_fd + 1, m_in_set->Set(), m_out_set->Set(), 0, &tv);
 247         if ( result > 0 ) {
 248                 m_in_set->Detected(&GSocket::Detected_Read);
 249                 m_out_set->Detected(&GSocket::Detected_Write);
 250         }
 251
 252 }
 253
 254 GSocketGUIFunctionsTable *CDaemonAppTraits::GetSocketGUIFunctionsTable()
 255 {
 256         return m_table;
 257 }
 258
 259 bool CAmuledGSocketFuncTable::OnInit()
 260 {
 261         return true;
 262 }
 263
 264 void CAmuledGSocketFuncTable::OnExit()
 265 {
 266 }
 267
 268 bool CAmuledGSocketFuncTable::CanUseEventLoop()
 269 {
 270         /*
 271          * FIXME: (lfroen) Not sure whether it's right.
 272          * I will review it later.
 273          */
 274         return false;
 275 }
 276
 277 bool CAmuledGSocketFuncTable::Init_Socket(GSocket *)
 278 {
 279         return true;
 280 }
 281
 282 void CAmuledGSocketFuncTable::Destroy_Socket(GSocket *)
 283 {
 284 }
 285
 286 void CAmuledGSocketFuncTable::Install_Callback(GSocket *sock, GSocketEvent e)
 287 {
 288         AddSocket(sock, e);
 289 }
 290
 291 void CAmuledGSocketFuncTable::Uninstall_Callback(GSocket *sock, GSocketEvent e)
 292 {
 293         RemoveSocket(sock, e);
 294 }
 295
 296 void CAmuledGSocketFuncTable::Enable_Events(GSocket *socket)
 297 {
 298         Install_Callback(socket, GSOCK_INPUT);
 299         Install_Callback(socket, GSOCK_OUTPUT);
 300 }
 301
 302 void CAmuledGSocketFuncTable::Disable_Events(GSocket *socket)
 303 {
 304         Uninstall_Callback(socket, GSOCK_INPUT);
 305         Uninstall_Callback(socket, GSOCK_OUTPUT);
 306 }
 307
 308
 309 CDaemonAppTraits::CDaemonAppTraits(CAmuledGSocketFuncTable *table)
 310 :
 311 wxConsoleAppTraits(),
 312 m_table(table),
 313 m_lock(wxMUTEX_RECURSIVE),
 314 m_sched_delete(),
 315 m_oldSignalChildAction(),
 316 m_newSignalChildAction()
 317 {
 318         m_lock.Unlock();
 319 }
 320
 321
 322 void CDaemonAppTraits::ScheduleForDestroy(wxObject *object)
 323 {
 324         wxMutexLocker lock(m_lock);
 325
 326         //delete object;
 327         m_sched_delete.push_back(object);
 328 }
 329
 330 void CDaemonAppTraits::RemoveFromPendingDelete(wxObject *object)
 331 {
 332         wxMutexLocker lock(m_lock);
 333
 334         for(std::list<wxObject *>::iterator i = m_sched_delete.begin();
 335                 i != m_sched_delete.end(); i++) {
 336                         if ( *i == object ) {
 337                                 m_sched_delete.erase(i);
 338                                 return;
 339                         }
 340                 }
 341 }
 342
 343 void CDaemonAppTraits::DeletePending()
 344 {
 345         wxMutexLocker lock(m_lock);
 346
 347         while ( !m_sched_delete.empty() ) {
 348                 std::list<wxObject *>::iterator i = m_sched_delete.begin();
 349                 wxObject *object = *i;
 350                 delete object;
 351         }
 352         //m_sched_delete.erase(m_sched_delete.begin(), m_sched_delete.end());
 353 }
 354
 355
 356 #ifdef __WXMAC__
 357 #include <wx/stdpaths.h> // Do_not_auto_remove (guess)
 358 static wxStandardPathsCF gs_stdPaths;
 359 wxStandardPathsBase& CDaemonAppTraits::GetStandardPaths()
 360 {
 361         return gs_stdPaths;
 362 }
 363 #endif
 364
 365
 366 CamuleDaemonApp::CamuleDaemonApp()
 367 :
 368 m_Exit(false),
 369 m_table(new CAmuledGSocketFuncTable())
 370 {
 371         wxPendingEventsLocker = new wxCriticalSection;
 372 }
 373
 374
 375 wxAppTraits *CamuleDaemonApp::CreateTraits()
 376 {
 377         return new CDaemonAppTraits(m_table);
 378 }
 379
 380
 381 #ifndef __WXMSW__
 382
 383
 384 static EndProcessDataMap endProcDataMap;
 385
 386
 387 int CDaemonAppTraits::WaitForChild(wxExecuteData &execData)
 388 {
 389         int status = 0;
 390         pid_t result = 0;
 391         // Build the log message
 392         wxString msg;
 393         msg << wxT("WaitForChild() has been called for child process with pid `") <<
 394                 execData.pid <<
 395                 wxT("'. ");
 396
 397         if (execData.flags & wxEXEC_SYNC) {
 398                 result = AmuleWaitPid(execData.pid, &status, 0, &msg);
 399                 if (result == -1 || (!WIFEXITED(status) && !WIFSIGNALED(status))) {
 400                         msg << wxT(" Waiting for subprocess termination failed.");
 401                         AddDebugLogLineM(false, logGeneral, msg);
 402                 }
 403         } else {
 404                 /** wxEXEC_ASYNC */
 405                 // Give the process a chance to start or forked child to exit
 406                 // 1 second is enough time to fail on "path not found"
 407                 wxSleep(1);
 408                 result = AmuleWaitPid(execData.pid, &status, WNOHANG, &msg);
 409                 if (result == 0) {
 410                         // Add a WxEndProcessData entry to the map, so that we can
 411                         // support process termination
 412                         wxEndProcessData *endProcData = new wxEndProcessData();
 413                         endProcData->pid = execData.pid;
 414                         endProcData->process = execData.process;
 415                         endProcData->tag = 0;
 416                         endProcDataMap[execData.pid] = endProcData;
 417
 418                         status = execData.pid;
 419                 } else {
 420                         // if result != 0, then either waitpid() failed (result == -1)
 421                         // and there is nothing we can do, or the child has changed
 422                         // status, which means it is probably dead.
 423                         status = 0;
 424                 }
 425         }
 426
 427         // Log our passage here
 428         AddDebugLogLineM(false, logGeneral, msg);
 429
 430         return status;
 431 }
 432
 433
 434 void OnSignalChildHandler(int /*signal*/, siginfo_t *siginfo, void * /*ucontext*/)
 435 {
 436         // Build the log message
 437         wxString msg;
 438         msg << wxT("OnSignalChildHandler() has been called for child process with pid `") <<
 439                 siginfo->si_pid <<
 440                 wxT("'. ");
 441         // Make sure we leave no zombies by calling waitpid()
 442         int status = 0;
 443         pid_t result = AmuleWaitPid(siginfo->si_pid, &status, WNOHANG, &msg);
 444         if (result != 1 && result != 0 && (WIFEXITED(status) || WIFSIGNALED(status))) {
 445                 // Fetch the wxEndProcessData structure corresponding to this pid
 446                 EndProcessDataMap::iterator it = endProcDataMap.find(siginfo->si_pid);
 447                 if (it != endProcDataMap.end()) {
 448                         wxEndProcessData *endProcData = it->second;
 449                         // Remove this entry from the process map
 450                         endProcDataMap.erase(siginfo->si_pid);
 451                         // Save the exit code for the wxProcess object to read later
 452                         endProcData->exitcode = result != -1 && WIFEXITED(status) ?
 453                                 WEXITSTATUS(status) : -1;
 454                         // Make things work as in wxGUI
 455                         wxHandleProcessTermination(endProcData);
 456
 457                         // wxHandleProcessTermination() will "delete endProcData;"
 458                         // So we do not delete it again, ok? Do not uncomment this line.
 459                         //delete endProcData;
 460                 } else {
 461                         msg << wxT(" Error: the child process pid is not on the pid map.");
 462                 }
 463         }
 464
 465         // Log our passage here
 466         AddDebugLogLineM(false, logGeneral, msg);
 467 }
 468
 469
 470 pid_t AmuleWaitPid(pid_t pid, int *status, int options, wxString *msg)
 471 {
 472         // strerror_r() buffer
 473         const int ERROR_BUFFER_LEN = 256;
 474         char errorBuffer[ERROR_BUFFER_LEN];
 475
 476         *status = 0;
 477         pid_t result = waitpid(pid, status, options);
 478         if (result == -1) {
 479                 strerror_r(errno, errorBuffer, ERROR_BUFFER_LEN);
 480                 *msg << wxT("Error: waitpid() call failed: ") <<
 481                         char2unicode(errorBuffer) <<
 482                         wxT(".");
 483         } else if (result == 0) {
 484                 if (options & WNOHANG)  {
 485                         *msg << wxT("The child is alive.");
 486                 } else {
 487                         *msg << wxT("Error: waitpid() call returned 0 but "
 488                                 "WNOHANG was not specified in options.");
 489                 }
 490         } else {
 491                 if (WIFEXITED(*status)) {
 492                         *msg << wxT("Child has terminated with status code `") <<
 493                                 WEXITSTATUS(*status) <<
 494                                 wxT("'.");
 495                 } else if (WIFSIGNALED(*status)) {
 496                         *msg << wxT("Child was killed by signal `") <<
 497                                 WTERMSIG(*status) <<
 498                                 wxT("'.");
 499                         if (WCOREDUMP(*status)) {
 500                                 *msg << wxT(" A core file has been dumped.");
 501                         }
 502                 } else if (WIFSTOPPED(*status)) {
 503                         *msg << wxT("Child has been stopped by signal `") <<
 504                                 WSTOPSIG(*status) <<
 505                                 wxT("'.");
 506 #ifdef WIFCONTINUED /* Only found in recent kernels. */
 507                 } else if (WIFCONTINUED(*status)) {
 508                         *msg << wxT("Child has received `SIGCONT' and has continued execution.");
 509 #endif
 510                 } else {
 511                         *msg << wxT("The program was not able to determine why the child has signaled.");
 512                 }
 513         }
 514
 515         return result;
 516 }
 517
 518
 519 #endif // __WXMSW__
 520
 521
 522 int CamuleDaemonApp::OnRun()
 523 {
 524         if (!thePrefs::AcceptExternalConnections()) {
 525                 wxString warning = _("ERROR: aMule daemon cannot be used when external connections are disabled. "
 526                         "To enable External Connections, use either a normal aMule, start amuled with the option --ec-config or set the key"
 527                         "\"AcceptExternalConnections\" to 1 in the file ~/.aMule/amule.conf");
 528
 529                 AddLogLineM(true, warning);
 530                 printf("\n%s\n\n", (const char*)unicode2char(warning));
 531
 532                 return 0;
 533         } else if (thePrefs::ECPassword().IsEmpty()) {
 534                 wxString warning = wxT("ERROR: A valid password is required to use "
 535                         "external connections, and aMule daemon cannot be used without "
 536                         "external connections. To run aMule deamon, you must set the "
 537                         "\"ECPassword\" field in the file ~/.aMule/amule.conf with an "
 538                         "appropriate value. Execute amuled with the flag --ec-config to set the password. More information can be found at "
 539                         "http://wiki.amule.org");
 540
 541                 AddLogLineM(true, warning);
 542                 printf("\n%s\n\n", (const char*)unicode2char(warning));
 543
 544                 return 0;
 545         }
 546
 547 #ifndef __WXMSW__
 548         // strerror_r() buffer
 549         const int ERROR_BUFFER_LEN = 256;
 550         char errorBuffer[ERROR_BUFFER_LEN];
 551         wxString msg;
 552
 553         // Process the return code of dead children so that we do not create
 554         // zombies. wxBase does not implement wxProcess callbacks, so no one
 555         // actualy calls wxHandleProcessTermination() in console applications.
 556         // We do our best here.
 557         int ret = 0;
 558         ret = sigaction(SIGCHLD, NULL, &m_oldSignalChildAction);
 559         m_newSignalChildAction = m_oldSignalChildAction;
 560         m_newSignalChildAction.sa_sigaction = OnSignalChildHandler;
 561         m_newSignalChildAction.sa_flags |=  SA_SIGINFO;
 562         m_newSignalChildAction.sa_flags &= ~SA_RESETHAND;
 563         ret = sigaction(SIGCHLD, &m_newSignalChildAction, NULL);
 564         if (ret == -1) {
 565                 strerror_r(errno, errorBuffer, ERROR_BUFFER_LEN);
 566                 msg << wxT("CamuleDaemonApp::OnRun(): "
 567                         "Installation of SIGCHLD callback with sigaction() failed: ") <<
 568                         char2unicode(errorBuffer) <<
 569                         wxT(".");
 570                 AddLogLineM(true, msg);
 571         } else {
 572                 msg << wxT("CamuleDaemonApp::OnRun(): Installation of SIGCHLD "
 573                         "callback with sigaction() succeeded.");
 574                 AddDebugLogLineM(false, logGeneral, msg);
 575         }
 576 #endif // __WXMSW__
 577
 578         while ( !m_Exit ) {
 579                 m_table->RunSelect();
 580                 ProcessPendingEvents();
 581                 ((CDaemonAppTraits *)GetTraits())->DeletePending();
 582         }
 583
 584         // ShutDown is beeing called twice. Once here and again in OnExit().
 585         ShutDown();
 586
 587 #ifndef __WXMSW__
 588         msg.Empty();
 589         ret = sigaction(SIGCHLD, &m_oldSignalChildAction, NULL);
 590         if (ret == -1) {
 591                 strerror_r(errno, errorBuffer, ERROR_BUFFER_LEN);
 592                 msg << wxT("CamuleDaemonApp::OnRun(): second sigaction() failed: ") <<
 593                         char2unicode(errorBuffer) <<
 594                         wxT(".");
 595                 AddLogLineM(true, msg);
 596         } else {
 597                 msg << wxT("CamuleDaemonApp::OnRun(): Uninstallation of SIGCHLD "
 598                         "callback with sigaction() succeeded.");
 599                 AddDebugLogLineM(false, logGeneral, msg);
 600         }
 601 #endif // __WXMSW__
 602
 603         return 0;
 604 }
 605
 606 bool CamuleDaemonApp::OnInit()
 607 {
 608         printf("amuled: OnInit - starting timer\n");
 609         if ( !CamuleApp::OnInit() ) {
 610                 return false;
 611         }
 612         core_timer = new CTimer(this,ID_CORE_TIMER_EVENT);
 613         core_timer->Start(300);
 614         glob_prefs->GetCategory(0)->title = GetCatTitle(thePrefs::GetAllcatType());
 615         glob_prefs->GetCategory(0)->path = thePrefs::GetIncomingDir();
 616
 617         return true;
 618 }
 619
 620 int CamuleDaemonApp::InitGui(bool ,wxString &)
 621 {
 622 #ifndef __WXMSW__
 623         if ( !enable_daemon_fork ) {
 624                 return 0;
 625         }
 626         printf("amuled: forking to background - see you\n");
 627         //
 628         // fork to background and detouch from controlling tty
 629         // while redirecting stdout to /dev/null
 630         //
 631         for(int i_fd = 0;i_fd < 3; i_fd++) {
 632                 close(i_fd);
 633         }
 634         int fd = open("/dev/null",O_RDWR);
 635         dup(fd);
 636         dup(fd);
 637         int pid = fork();
 638
 639         wxASSERT(pid != -1);
 640
 641         if ( pid ) {
 642                 exit(0);
 643         } else {
 644                 setsid();
 645         }
 646
 647 #endif
 648         return 0;
 649 }
 650
 651
 652 int CamuleDaemonApp::OnExit()
 653 {
 654         /*
 655          * Stop all socket threads before entering
 656          * shutdown sequence.
 657          */
 658         delete listensocket;
 659         listensocket = 0;
 660         if (clientudp) {
 661                 delete clientudp;
 662                 clientudp = NULL;
 663         }
 664
 665         ShutDown();
 666
 667         // lfroen: delete socket threads
 668         if (ECServerHandler) {
 669                 ECServerHandler = 0;
 670         }
 671
 672         delete core_timer;
 673
 674         return CamuleApp::OnExit();
 675 }
 676
 677
 678 void CamuleDaemonApp::ShowAlert(wxString msg, wxString title, int flags)
 679 {
 680         if ( flags | wxICON_ERROR ) {
 681                 title = CFormat(_("ERROR: %s")) % title;
 682         }
 683
 684         // Ensure that alerts are always visible on the console (when possible).
 685         if ((not enable_stdout_log) and (not enable_daemon_fork)) {
 686                 printf("%s\n", unicode2UTF8(title + wxT(" ") + msg).data());
 687         }
 688
 689         AddLogLineM(true, title + wxT(" ") + msg);
 690 }
 691
 692
 693 void CamuleDaemonApp::OnLoggingEvent(CLoggingEvent& evt)
 694 {
 695         CamuleApp::AddLogLine(evt.Message());
 696 }
 697
 698 // File_checked_for_headers