gecko-dev/profile/dirserviceprovider/src/nsProfileLock.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Conrad Carlen <ccarlen@netscape.com>
 *   Brendan Eich <brendan@mozilla.org>
 *   Colin Blake <colin@theblakes.com>
 *   Javier Pedemonte <pedemont@us.ibm.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsProfileLock.h"
#include "nsLiteralString.h"
#include "nsString.h"

#if defined(XP_MAC) || defined(XP_MACOSX)
#include <Processes.h>
#include <CFBundle.h>
#endif

#ifdef XP_UNIX
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include "prnetdb.h"
#include "prsystem.h"
#include "prprf.h"
#endif

#ifdef VMS
#include <rmsdef.h>
#endif

#if defined(XP_UNIX) && !defined(XP_MACOSX)   /* Don't use symlink-based locking on OS X */
#define USE_SYMLINK_LOCKING
#endif

// **********************************************************************
// class nsProfileLock
// **********************************************************************

#if defined (XP_MAC) && TARGET_CARBON

// The following functions and definitions are used in order to allow
// a CFM build to use the same locking scheme as a Mach-0 build.

static CFBundleRef getBundle(CFStringRef frameworkPath)
{
   CFBundleRef bundle = NULL;
    
   //  Make a CFURLRef from the CFString representation of the bundle's path.
   //  See the Core Foundation URL Services chapter for details.
   CFURLRef bundleURL = CFURLCreateWithFileSystemPath(NULL, frameworkPath, kCFURLPOSIXPathStyle, true);
   if (bundleURL != NULL) {
        bundle = CFBundleCreate(NULL, bundleURL);
        if (bundle != NULL)
           CFBundleLoadExecutable(bundle);
        CFRelease(bundleURL);
   }
   
   return bundle;
}

static void* getSystemFunction(CFStringRef functionName)
{
  static CFBundleRef systemBundle = getBundle(CFSTR("/System/Library/Frameworks/System.framework"));
  if (systemBundle) return CFBundleGetFunctionPointerForName(systemBundle, functionName);
  return NULL;
}

// From <sys/types.h>
typedef    int64_t     off_t;      /* file offset */
typedef    int32_t     pid_t;      /* process id */

// From <sys/errno.h>
#define    EAGAIN      35          /* Resource temporarily unavailable */
#define    EACCES      13          /* Permission denied */

// From <sys/fcntl.h>
#define    O_RDONLY    0x0000      /* open for reading only */
#define    O_WRONLY    0x0001      /* open for writing only */
#define    O_RDWR      0x0002      /* open for reading and writing */

#define    O_CREAT     0x0200      /* create if nonexistant */
#define    O_TRUNC     0x0400      /* truncate to zero length */
#define    O_EXCL      0x0800      /* error if already exists */

#define    F_RDLCK     1       /* shared or read lock */
#define    F_UNLCK     2       /* unlock */
#define    F_WRLCK     3       /* exclusive or write lock */

#define    F_SETLK     8       /* set record locking information */

struct flock {
   off_t   l_start;    /* starting offset */
   off_t   l_len;      /* len = 0 means until end of file */
   pid_t   l_pid;      /* lock owner */
   short   l_type;     /* lock type: read/write, etc. */
   short   l_whence;   /* type of l_start */
};

// Proc ptr types of the procs we import from System framework
typedef int (*open_proc_ptr) (const char *, int, ...);
typedef int (*close_proc_ptr) (int);
typedef int (*fcntl_proc_ptr) (int, int, ...);
typedef int* (*error_proc_ptr) ();

static open_proc_ptr bsd_open = (open_proc_ptr) getSystemFunction(CFSTR("open"));
static close_proc_ptr bsd_close = (close_proc_ptr) getSystemFunction(CFSTR("close"));
static fcntl_proc_ptr bsd_fcntl = (fcntl_proc_ptr) getSystemFunction(CFSTR("fcntl"));
static error_proc_ptr bsd_error = (error_proc_ptr) getSystemFunction(CFSTR("__error"));

#endif /* XP_MAC && TARGET_CARBON */

nsProfileLock::nsProfileLock() :
    mHaveLock(PR_FALSE)
#if defined (XP_MAC) && TARGET_CARBON
    ,mLockFileDesc(-1)    
#elif defined (XP_WIN)
    ,mLockFileHandle(INVALID_HANDLE_VALUE)
#elif defined (XP_OS2)
    ,mLockFileHandle(-1)
#elif defined (XP_UNIX)
    ,mPidLockFileName(nsnull)
    ,mLockFileDesc(-1)
#endif
{
#if defined (XP_UNIX)
    next = prev = this;
#endif
}


nsProfileLock::nsProfileLock(nsProfileLock& src)
{
    *this = src;
}


nsProfileLock& nsProfileLock::operator=(nsProfileLock& rhs)
{
    Unlock();

    mHaveLock = rhs.mHaveLock;
    rhs.mHaveLock = PR_FALSE;

#if defined (XP_MAC)
    mLockFile = rhs.mLockFile;
    rhs.mLockFile = nsnull;
  #if TARGET_CARBON
    mLockFileDesc = rhs.mLockFileDesc;
    rhs.mLockFileDesc = -1;
  #endif
#elif defined (XP_WIN)
    mLockFileHandle = rhs.mLockFileHandle;
    rhs.mLockFileHandle = INVALID_HANDLE_VALUE;
#elif defined (XP_OS2)
    mLockFileHandle = rhs.mLockFileHandle;
    rhs.mLockFileHandle = -1;
#elif defined (XP_UNIX)
    mLockFileDesc = rhs.mLockFileDesc;
    rhs.mLockFileDesc = -1;
    mPidLockFileName = rhs.mPidLockFileName;
    rhs.mPidLockFileName = nsnull;
    if (mPidLockFileName)
    {
        // rhs had a symlink lock, therefore it was on the list.
        PR_REMOVE_LINK(&rhs);
        PR_APPEND_LINK(this, &mPidLockList);
    }
#endif

    return *this;
}


nsProfileLock::~nsProfileLock()
{
    Unlock();
}


#if defined (XP_UNIX)

static int setupPidLockCleanup;

PRCList nsProfileLock::mPidLockList =
    PR_INIT_STATIC_CLIST(&nsProfileLock::mPidLockList);

void nsProfileLock::RemovePidLockFiles()
{
    while (!PR_CLIST_IS_EMPTY(&mPidLockList))
    {
        nsProfileLock *lock = NS_STATIC_CAST(nsProfileLock*, mPidLockList.next);
        lock->Unlock();
    }
}

static struct sigaction SIGHUP_oldact;
static struct sigaction SIGINT_oldact;
static struct sigaction SIGQUIT_oldact;
static struct sigaction SIGILL_oldact;
static struct sigaction SIGABRT_oldact;
static struct sigaction SIGSEGV_oldact;
static struct sigaction SIGTERM_oldact;

void nsProfileLock::FatalSignalHandler(int signo)
{
    // Remove any locks still held.
    RemovePidLockFiles();

    // Chain to the old handler, which may exit.
    struct sigaction *oldact = nsnull;

    switch (signo) {
      case SIGHUP:
        oldact = &SIGHUP_oldact;
        break;
      case SIGINT:
        oldact = &SIGINT_oldact;
        break;
      case SIGQUIT:
        oldact = &SIGQUIT_oldact;
        break;
      case SIGILL:
        oldact = &SIGILL_oldact;
        break;
      case SIGABRT:
        oldact = &SIGABRT_oldact;
        break;
      case SIGSEGV:
        oldact = &SIGSEGV_oldact;
        break;
      case SIGTERM:
        oldact = &SIGTERM_oldact;
        break;
      default:
        NS_NOTREACHED("bad signo");
        break;
    }

    if (oldact &&
        oldact->sa_handler &&
        oldact->sa_handler != SIG_DFL &&
        oldact->sa_handler != SIG_IGN)
    {
        oldact->sa_handler(signo);
    }

    // Backstop exit call, just in case.
    _exit(signo);
}

#endif /* XP_UNIX */

nsresult nsProfileLock::Lock(nsILocalFile* aFile)
{
#if defined (XP_MAC) || defined (XP_MACOSX)
    NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, ".parentlock");
    NS_NAMED_LITERAL_STRING(OLD_LOCKFILE_NAME, "parent.lock");
#elif defined (XP_UNIX)
    NS_NAMED_LITERAL_STRING(OLD_LOCKFILE_NAME, "lock");
    NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, ".parentlock");
#else
    NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, "parent.lock");
#endif

    nsresult rv;
    NS_ENSURE_STATE(!mHaveLock);

    PRBool isDir;
    rv = aFile->IsDirectory(&isDir);
    if (NS_FAILED(rv))
        return rv;
    if (!isDir)
        return NS_ERROR_FILE_NOT_DIRECTORY;

    nsCOMPtr<nsILocalFile> lockFile;
    rv = aFile->Clone((nsIFile **)((void **)getter_AddRefs(lockFile)));
    if (NS_FAILED(rv))
        return rv;

    rv = lockFile->Append(LOCKFILE_NAME);
    if (NS_FAILED(rv))
        return rv;

#if defined(XP_MAC) || defined(XP_MACOSX)
  #if defined(XP_MACOSX)
    nsCAutoString filePath;
    rv = lockFile->GetNativePath(filePath);
    if (NS_FAILED(rv))
        return rv;

    mLockFileDesc = open(filePath.get(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (mLockFileDesc == -1)
    {
        NS_ERROR("Failed to open lock file.");
        return NS_ERROR_FAILURE;
    }
    struct flock lock;
    lock.l_start = 0;
    lock.l_len = 0; // len = 0 means entire file
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    if (fcntl(mLockFileDesc, F_SETLK, &lock) == -1)
    {
        if (errno == EAGAIN || errno == EACCES)
            return NS_ERROR_FILE_ACCESS_DENIED;
        return NS_ERROR_FAILURE;
    }
    mHaveLock = PR_TRUE;
  #elif TARGET_CARBON
    if (bsd_open && bsd_close && bsd_fcntl && bsd_error) // FALSE for TARGET_CARBON on OS9
    {
        // We need a UTF-8 Posix path to pass to open.
        CFURLRef lockFileCFURL;
        nsCOMPtr<nsILocalFileMac> lockMacFile(do_QueryInterface(lockFile));
        if (!lockMacFile)
            return NS_ERROR_FAILURE;
        rv = lockMacFile->GetCFURL(&lockFileCFURL);       
        if (NS_FAILED(rv))
            return rv;

        // On OSX, even if we're a CFM app, this will return a UTF-8 Posix path.
        Boolean gotPath;    
        UInt8 pathBuf[1024];        
        gotPath = ::CFURLGetFileSystemRepresentation(lockFileCFURL, false, pathBuf, sizeof(pathBuf));
        ::CFRelease(lockFileCFURL);
        if (!gotPath)
            return NS_ERROR_FAILURE;

        mLockFileDesc = bsd_open((char *)pathBuf, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if (mLockFileDesc == -1)
        {
            NS_ERROR("Failed to open lock file.");
            return NS_ERROR_FAILURE;
        }
        struct flock lock;
        lock.l_start = 0;
        lock.l_len = 0; // len = 0 means entire file
        lock.l_type = F_WRLCK;
        lock.l_whence = SEEK_SET;  

        if (bsd_fcntl(mLockFileDesc, F_SETLK, &lock) == -1)
        {
            int *errno_ptr = bsd_error();
            if (*errno_ptr == EAGAIN || *errno_ptr == EACCES)
                return NS_ERROR_FILE_ACCESS_DENIED;
            return NS_ERROR_FAILURE;
        }
        mHaveLock = PR_TRUE;
    }
  #endif /* TARGET_CARBON */
  
    // Even if we're using fcntl locking, check for the old-style lock.
    struct LockProcessInfo
    {
        ProcessSerialNumber psn;
        unsigned long launchDate;
    };

    PRFileDesc *fd = nsnull;
    PRInt32 ioBytes;
    ProcessInfoRec processInfo;
    LockProcessInfo lockProcessInfo;

    rv = lockFile->SetLeafName(OLD_LOCKFILE_NAME);
    if (NS_FAILED(rv))
        return rv;
    rv = lockFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
    if (NS_SUCCEEDED(rv))
    {
        ioBytes = PR_Read(fd, &lockProcessInfo, sizeof(LockProcessInfo));
        PR_Close(fd);

        if (ioBytes == sizeof(LockProcessInfo))
        {
            processInfo.processAppSpec = nsnull;
            processInfo.processName = nsnull;
            processInfo.processInfoLength = sizeof(ProcessInfoRec);
            if (::GetProcessInformation(&lockProcessInfo.psn, &processInfo) == noErr &&
                processInfo.processLaunchDate == lockProcessInfo.launchDate)
            {
                return NS_ERROR_FILE_ACCESS_DENIED;
            }
        }
        else
        {
            NS_WARNING("Could not read lock file - ignoring lock");
        }
    }
    rv = NS_OK; // Don't propagate error from OpenNSPRFileDesc.

  #if !TARGET_CARBON
    rv = lockFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0, &fd);
    if (NS_FAILED(rv))
        return rv;

    static LockProcessInfo sSelfInfo;
    static PRBool sSelfInfoInited;

    if (!sSelfInfoInited)
    {
        ProcessSerialNumber psn;
        if (::GetCurrentProcess(&psn) == noErr)
        {
            processInfo.processAppSpec = nsnull;
            processInfo.processName = nsnull;
            processInfo.processInfoLength = sizeof(ProcessInfoRec);
            if (::GetProcessInformation(&psn, &processInfo) == noErr)
            {
                sSelfInfo.psn = processInfo.processNumber;
                sSelfInfo.launchDate = processInfo.processLaunchDate;
                sSelfInfoInited = PR_TRUE;
            }
        }
    }
    if (!sSelfInfoInited)
    {
        PR_Close(fd);
        return NS_ERROR_FAILURE;
    }

    ioBytes = PR_Write(fd, &sSelfInfo, sizeof(LockProcessInfo));
    PR_Close(fd);
    if (ioBytes != sizeof(LockProcessInfo))
        return NS_ERROR_FAILURE;
    mLockFile = lockFile;
  #endif /* !TARGET_CARBON */
#elif defined(XP_WIN)
    nsCAutoString filePath;
    rv = lockFile->GetNativePath(filePath);
    if (NS_FAILED(rv))
        return rv;
    mLockFileHandle = CreateFile(filePath.get(),
                                 GENERIC_READ | GENERIC_WRITE,
                                 0, // no sharing - of course
                                 nsnull,
                                 OPEN_ALWAYS,
                                 FILE_FLAG_DELETE_ON_CLOSE,
                                 nsnull);
    if (mLockFileHandle == INVALID_HANDLE_VALUE)
        return NS_ERROR_FILE_ACCESS_DENIED;
#elif defined(XP_OS2)
    nsCAutoString filePath;
    rv = lockFile->GetNativePath(filePath);
    if (NS_FAILED(rv))
        return rv;

    ULONG   ulAction = 0;
    APIRET  rc;
    rc = DosOpen(filePath.get(),
                  &mLockFileHandle,
                  &ulAction,
                  0,
                  FILE_NORMAL,
                  OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
                  OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE | OPEN_FLAGS_NOINHERIT,
                  0 );
    if (rc != NO_ERROR)
    {
        mLockFileHandle = -1;
        return NS_ERROR_FILE_ACCESS_DENIED;
    }
#elif defined(VMS)
    nsCAutoString filePath;
    rv = lockFile->GetNativePath(filePath);
    if (NS_FAILED(rv))
        return rv;

    mLockFileDesc = open_noshr(filePath.get(), O_CREAT, 0666);
    if (mLockFileDesc == -1)
    {
	if ((errno == EVMSERR) && (vaxc$errno == RMS$_FLK))
	{
	    return NS_ERROR_FILE_ACCESS_DENIED;
	}
	else
	{
	    NS_ERROR("Failed to open lock file.");
	    return NS_ERROR_FAILURE;
	}
    }
#elif defined(XP_UNIX)
#ifdef USE_SYMLINK_LOCKING
    nsCOMPtr<nsILocalFile> oldLockFile;
    rv = aFile->Clone((nsIFile **)((void **)getter_AddRefs(oldLockFile)));
    if (NS_FAILED(rv))
        return rv;

    rv = oldLockFile->Append(OLD_LOCKFILE_NAME);
    if (NS_FAILED(rv))
        return rv;
    nsCAutoString oldFilePath;
    rv = oldLockFile->GetNativePath(oldFilePath);
    if (NS_FAILED(rv))
        return rv;

    // First, try the 4.x-compatible symlink technique, which works with NFS
    // without depending on (broken or missing, too often) lockd.
    struct in_addr inaddr;
    inaddr.s_addr = INADDR_LOOPBACK;

    char hostname[256];
    PRStatus status = PR_GetSystemInfo(PR_SI_HOSTNAME, hostname, sizeof hostname);
    if (status == PR_SUCCESS)
    {
        char netdbbuf[PR_NETDB_BUF_SIZE];
        PRHostEnt hostent;
        status = PR_GetHostByName(hostname, netdbbuf, sizeof netdbbuf, &hostent);
        if (status == PR_SUCCESS)
            memcpy(&inaddr, hostent.h_addr, sizeof inaddr);
    }

    char *signature =
        PR_smprintf("%s:%lu", inet_ntoa(inaddr), (unsigned long)getpid());
    const char *oldFileName = oldFilePath.get();
    int symlink_rv, symlink_errno, tries = 0;

    // use ns4.x-compatible symlinks if the FS supports them
    while ((symlink_rv = symlink(signature, oldFileName)) < 0)
    {
        symlink_errno = errno;
        if (symlink_errno != EEXIST)
            break;

        // the link exists; see if it's from this machine, and if
        // so if the process is still active
        char buf[1024];
        int len = readlink(oldFileName, buf, sizeof buf - 1);
        if (len > 0)
        {
            buf[len] = '\0';
            char *colon = strchr(buf, ':');
            if (colon)
            {
                *colon++ = '\0';
                unsigned long addr = inet_addr(buf);
                if (addr != (unsigned long) -1)
                {
                    char *after = nsnull;
                    pid_t pid = strtol(colon, &after, 0);
                    if (pid != 0 && *after == '\0')
                    {
                        if (addr != inaddr.s_addr)
                        {
                            // Remote lock: give up even if stuck.
                            break;
                        }

                        // kill(pid,0) is a neat trick to check if a
                        // process exists
                        if (kill(pid, 0) == 0 || errno != ESRCH)
                        {
                            // Local process appears to be alive, ass-u-me it
                            // is another Mozilla instance, or a compatible
                            // derivative, that's currently using the profile.
                            // XXX need an "are you Mozilla?" protocol
                            break;
                        }
                    }
                }
            }
        }

        // Lock seems to be bogus: try to claim it.  Give up after a large
        // number of attempts (100 comes from the 4.x codebase).
        (void) unlink(oldFileName);
        if (++tries > 100)
            break;
    }

    PR_smprintf_free(signature);
    signature = nsnull;

    if (symlink_rv == 0)
    {
        // We exclusively created the symlink: record its name for eventual
        // unlock-via-unlink.
        mPidLockFileName = strdup(oldFileName);
        if (mPidLockFileName)
        {
            PR_APPEND_LINK(this, &mPidLockList);
            if (!setupPidLockCleanup++)
            {
                // Clean up on normal termination.
                atexit(RemovePidLockFiles);

                // Clean up on abnormal termination, using POSIX sigaction.
                // Don't arm a handler if the signal is being ignored, e.g.,
                // because mozilla is run via nohup.
                struct sigaction act, oldact;
                act.sa_handler = FatalSignalHandler;
                act.sa_flags = 0;
                sigfillset(&act.sa_mask);

#define CATCH_SIGNAL(signame)                                                 \
    PR_BEGIN_MACRO                                                            \
        if (sigaction(signame, NULL, &oldact) == 0 &&                         \
            oldact.sa_handler != SIG_IGN)                                     \
        {                                                                     \
            sigaction(signame, &act, &signame##_oldact);                      \
        }                                                                     \
    PR_END_MACRO

                CATCH_SIGNAL(SIGHUP);
                CATCH_SIGNAL(SIGINT);
                CATCH_SIGNAL(SIGQUIT);
                CATCH_SIGNAL(SIGILL);
                CATCH_SIGNAL(SIGABRT);
                CATCH_SIGNAL(SIGSEGV);
                CATCH_SIGNAL(SIGTERM);

#undef CATCH_SIGNAL
            }
        }
    }
    else if (symlink_errno != EEXIST)
#endif /* USE_SYMLINK_LOCKING */
    {
        // Symlinks aren't supported (for example, on Win32 SAMBA servers).
        // F_SETLK is not well supported on all NFS servers, which is why we
        // try symlinks first.
        nsCAutoString filePath;
        rv = lockFile->GetNativePath(filePath);
        if (NS_FAILED(rv))
            return rv;

        mLockFileDesc = open(filePath.get(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if (mLockFileDesc == -1)
        {
            NS_ERROR("Failed to open lock file.");
            return NS_ERROR_FAILURE;
        }
        struct flock lock;
        lock.l_start = 0;
        lock.l_len = 0; // len = 0 means entire file
        lock.l_type = F_WRLCK;
        lock.l_whence = SEEK_SET;
        if (fcntl(mLockFileDesc, F_SETLK, &lock) == -1)
        {
            if (errno == EAGAIN || errno == EACCES)
                return NS_ERROR_FILE_ACCESS_DENIED;
            return NS_ERROR_FAILURE;
        }
    }
#ifdef USE_SYMLINK_LOCKING
    else
    {
        // Couldn't create the symlink (but symlink(2) is supported).
        // This error code will cause the right dialog to be displayed.
        return NS_ERROR_FILE_ACCESS_DENIED;
    }
#endif /* USE_SYMLINK_LOCKING */
#endif /* XP_UNIX */

    mHaveLock = PR_TRUE;

    return rv;
}


nsresult nsProfileLock::Unlock()
{
    nsresult rv = NS_OK;

    if (mHaveLock)
    {
#if defined (XP_MAC)
        if (mLockFile)
            rv = mLockFile->Remove(PR_FALSE);
  #if TARGET_CARBON
        if (mLockFileDesc != -1)
        {
            bsd_close(mLockFileDesc);
            mLockFileDesc = -1;        
        }
  #endif
#elif defined (XP_WIN)
        if (mLockFileHandle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(mLockFileHandle);
            mLockFileHandle = INVALID_HANDLE_VALUE;
        }
#elif defined (XP_OS2)
        if (mLockFileHandle != -1)
        {
            DosClose(mLockFileHandle);
            mLockFileHandle = -1;
        }
#elif defined (XP_UNIX)
        if (mPidLockFileName)
        {
            PR_REMOVE_LINK(this);
            (void) unlink(mPidLockFileName);
            free(mPidLockFileName);
            mPidLockFileName = nsnull;
        }
        else if (mLockFileDesc != -1)
        {
            close(mLockFileDesc);
            mLockFileDesc = -1;
            // Don't remove it
        }
#endif

        mHaveLock = PR_FALSE;
    }

    return rv;
}