///////////////////////////////////////////////////////////////////////////////
-// Name: unix/snglinst.cpp
+// Name: src/unix/snglinst.cpp
// Purpose: implements wxSingleInstanceChecker class for Unix using
// lock files with fcntl(2) or flock(2)
// Author: Vadim Zeitlin
// Created: 09.06.01
// RCS-ID: $Id$
// Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// License: wxWindows license
+// License: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "snglinst.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/string.h"
#include "wx/log.h"
#include "wx/intl.h"
- #include "wx/file.h"
+ #include "wx/utils.h" // wxGetHomeDir()
#endif //WX_PRECOMP
-#include "wx/utils.h" // wxGetHomeDir()
+#include "wx/file.h"
#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>
#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)
fl.l_type = lock == LOCK ? F_WRLCK : F_UNLCK;
// lock the entire file
- fl.l_whence =
fl.l_start =
- fl.l_len = 0;
+ fl.l_len =
+ fl.l_whence = 0;
// is this needed?
fl.l_pid = getpid();
private:
// try to create and lock the file
- bool CreateLockFile();
+ LockResult CreateLockFile();
// unlock and remove the lock file
void Unlock();
// 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 )
{
// 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 )
{
Unlock();
- return FALSE;
+ return LOCK_ERROR;
}
fsync(m_fdLock);
- return TRUE;
+ // change file's permission so that only this user can access it:
+ if ( chmod(m_nameLock.fn_str(), S_IRUSR | S_IWUSR) != 0 )
+ {
+ wxLogSysError(_("Failed to set permissions on lock file '%s'"),
+ m_nameLock.c_str());
+
+ Unlock();
+
+ return LOCK_ERROR;
+ }
+
+ 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;
+ }
+
+ // Check if the file is owned by current user and has 0600 permissions.
+ // If it doesn't, it's a fake file, possibly meant as a DoS attack, and
+ // so we refuse to touch it:
+ wxStructStat stats;
+ if ( wxStat(name, &stats) != 0 )
+ {
+ wxLogSysError(_("Failed to inspect the lock file '%s'"), name.c_str());
+ return false;
+ }
+ if ( stats.st_uid != getuid() )
+ {
+ wxLogError(_("Lock file '%s' has incorrect owner."), name.c_str());
+ return false;
+ }
+ if ( stats.st_mode != (S_IFREG | S_IRUSR | S_IWUSR) )
+ {
+ wxLogError(_("Lock file '%s' has incorrect permissions."), name.c_str());
+ return false;
}
// try to open the file for reading and get the PID of the process
// rarely in practice that we don't care
wxLogError(_("Failed to access lock file."));
- return FALSE;
+ return false;
}
char buf[256];
- off_t count = file.Read(buf, WXSIZEOF(buf));
+ ssize_t count = file.Read(buf, WXSIZEOF(buf));
if ( count == wxInvalidOffset )
{
wxLogError(_("Failed to read PID from lock file."));
}
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());
- // return TRUE in this case for now...
+ // return true in this case for now...
}
else
{
}
else
{
- wxLogWarning(_("Invalid lock file '%s'."));
+ wxLogWarning(_("Invalid lock file '%s'."), name.c_str());
}
}
- // return TRUE if we could get the PID of the process owning the lock file
+ // return true if we could get the PID of the process owning the lock file
// (whether it is still running or not), FALSE otherwise as it is
// unexpected
return m_pidLocker != 0;
{
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());
const wxString& path)
{
wxASSERT_MSG( !m_impl,
- _T("calling wxSingleInstanceChecker::Create() twice?") );
+ wxT("calling wxSingleInstanceChecker::Create() twice?") );
// must have the file name to create a lock file
- wxASSERT_MSG( !name.empty(), _T("lock file name can't be empty") );
+ wxASSERT_MSG( !name.empty(), wxT("lock file name can't be empty") );
m_impl = new wxSingleInstanceCheckerImpl;
wxString fullname = path;
if ( fullname.empty() )
{
- fullname << wxGetHomeDir() << _T('/');
+ fullname = wxGetHomeDir();
+ }
+
+ if ( fullname.Last() != wxT('/') )
+ {
+ fullname += wxT('/');
}
fullname << name;
return m_impl->Create(fullname);
}
-bool wxSingleInstanceChecker::IsAnotherRunning() const
+bool wxSingleInstanceChecker::DoIsAnotherRunning() const
{
- wxCHECK_MSG( m_impl, FALSE, _T("must call Create() first") );
+ wxCHECK_MSG( m_impl, false, wxT("must call Create() first") );
+
+ const pid_t lockerPid = m_impl->GetLockerPID();
+
+ if ( !lockerPid )
+ {
+ // we failed to open the lock file, return false as we're definitely
+ // not sure that another our process is running and so it's better not
+ // to prevent this one from starting up
+ return false;
+ }
// if another instance is running, it must own the lock file - otherwise
// we have it and the locker PID is ours one
- return m_impl->GetLockerPID() != getpid();
+ return lockerPid != getpid();
}
wxSingleInstanceChecker::~wxSingleInstanceChecker()
}
#endif // wxUSE_SNGLINST_CHECKER
-
projects / wxWidgets.git / blobdiff