added support for gcc precompiled headers

[wxWidgets.git] / src / unix / snglinst.cpp

diff --git a/src/unix/snglinst.cpp b/src/unix/snglinst.cpp
index 8b569946b165579cd9332fea966fc06ad57a2678..24ba3328dab250509815a6975d17f8daf1d1479d 100644 (file)
--- a/src/unix/snglinst.cpp
+++ b/src/unix/snglinst.cpp
@@ -7,7 +7,7 @@
 // Created:     09.06.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// License:     wxWindows license
+// License:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -35,17 +35,18 @@
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
-    #include "wx/file.h"
 #endif //WX_PRECOMP
 
+#include "wx/file.h"
 #include "wx/utils.h"           // wxGetHomeDir()
 
 #include "wx/snglinst.h"
 
 #include <unistd.h>
 #include <sys/types.h>
-#include <sys/stat.h>
+#include <sys/stat.h>           // for S_I[RW]USR
 #include <signal.h>             // for kill()
+#include <errno.h>
 
 #ifdef HAVE_FCNTL
     #include <fcntl.h>
@@ -57,15 +58,28 @@
 #endif // fcntl()/flock()
 
 // ----------------------------------------------------------------------------
-// private functions: (exclusively) lock/unlock the file
+// constants
 // ----------------------------------------------------------------------------
 
+// argument of wxLockFile()
 enum LockOperation
 {
     LOCK,
     UNLOCK
 };
 
+// return value of CreateLockFile()
+enum LockResult
+{
+    LOCK_ERROR = -1,
+    LOCK_EXISTS,
+    LOCK_CREATED
+};
+
+// ----------------------------------------------------------------------------
+// private functions: (exclusively) lock/unlock the file
+// ----------------------------------------------------------------------------
+
 #ifdef HAVE_FCNTL
 
 static int wxLockFile(int fd, LockOperation lock)
@@ -115,7 +129,7 @@ public:
 
 private:
     // try to create and lock the file
-    bool CreateLockFile();
+    LockResult CreateLockFile();
 
     // unlock and remove the lock file
     void Unlock();
@@ -134,12 +148,12 @@ private:
 // wxSingleInstanceCheckerImpl implementation
 // ============================================================================
 
-bool wxSingleInstanceCheckerImpl::CreateLockFile()
+LockResult wxSingleInstanceCheckerImpl::CreateLockFile()
 {
     // try to open the file
-    m_fdLock = open(m_nameLock,
+    m_fdLock = open(m_nameLock.fn_str(),
                     O_WRONLY | O_CREAT | O_EXCL,
-                    S_IREAD | S_IWRITE);
+                    S_IRUSR | S_IWUSR);
 
     if ( m_fdLock != -1 )
     {
@@ -152,7 +166,7 @@ bool wxSingleInstanceCheckerImpl::CreateLockFile()
 
             // use char here, not wxChar!
             char buf[256]; // enough for any PID size
-            int len = sprintf(buf, "%d", m_pidLocker) + 1;
+            int len = sprintf(buf, "%d", (int)m_pidLocker) + 1;
 
             if ( write(m_fdLock, buf, len) != len )
             {
@@ -161,33 +175,55 @@ bool wxSingleInstanceCheckerImpl::CreateLockFile()
 
                 Unlock();
 
-                return FALSE;
+                return LOCK_ERROR;
             }
 
             fsync(m_fdLock);
 
-            return TRUE;
+            return LOCK_CREATED;
         }
+        else // failure: see what exactly happened
+        {
+            close(m_fdLock);
+            m_fdLock = -1;
 
-        // couldn't lock: this might have happened because of a race
-        // condition: maybe another instance opened and locked the file
-        // between our calls to open() and flock()
-        close(m_fdLock);
-        m_fdLock = -1;
+            if ( errno != EACCES && errno != EAGAIN )
+            {
+                wxLogSysError(_("Failed to lock the lock file '%s'"),
+                              m_nameLock.c_str());
+
+                unlink(m_nameLock.fn_str());
+
+                return LOCK_ERROR;
+            }
+            //else: couldn't lock because the lock is held by another process:
+            //      this might have happened because of a race condition:
+            //      maybe another instance opened and locked the file between
+            //      our calls to open() and flock(), so don't give an error
+        }
     }
 
     // we didn't create and lock the file
-    return FALSE;
+    return LOCK_EXISTS;
 }
 
 bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
 {
     m_nameLock = name;
 
-    if ( CreateLockFile() )
+    switch ( CreateLockFile() )
     {
-        // nothing more to do
-        return TRUE;
+        case LOCK_EXISTS:
+            // there is a lock file, check below if it is still valid
+            break;
+
+        case LOCK_CREATED:
+            // nothing more to do
+            return TRUE;
+
+        case LOCK_ERROR:
+            // oops...
+            return FALSE;
     }
 
     // try to open the file for reading and get the PID of the process
@@ -217,11 +253,11 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
     }
     else
     {
-        if ( sscanf(buf, "%d", &m_pidLocker) == 1 )
+        if ( sscanf(buf, "%d", (int *)&m_pidLocker) == 1 )
         {
             if ( kill(m_pidLocker, 0) != 0 )
             {
-                if ( unlink(name) != 0 )
+                if ( unlink(name.fn_str()) != 0 )
                 {
                     wxLogError(_("Failed to remove stale lock file '%s'."),
                                name.c_str());
@@ -241,7 +277,7 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
         }
         else
         {
-            wxLogWarning(_("Invalid lock file '%s'."));
+            wxLogWarning(_("Invalid lock file '%s'."), name.c_str());
         }
     }
 
@@ -255,7 +291,7 @@ void wxSingleInstanceCheckerImpl::Unlock()
 {
     if ( m_fdLock != -1 )
     {
-        if ( unlink(m_nameLock) != 0 )
+        if ( unlink(m_nameLock.fn_str()) != 0 )
         {
             wxLogSysError(_("Failed to remove lock file '%s'"),
                           m_nameLock.c_str());
@@ -295,7 +331,12 @@ bool wxSingleInstanceChecker::Create(const wxString& name,
     wxString fullname = path;
     if ( fullname.empty() )
     {
-        fullname << wxGetHomeDir() << _T('/');
+        fullname = wxGetHomeDir();
+    }
+
+    if ( fullname.Last() != _T('/') )
+    {
+        fullname += _T('/');
     }
 
     fullname << name;