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