Use fcntl() instead of flock() for locking the config file

fcntl() is more portable than flock() so this makes znc run on more systems
(everyone smile and say hi to solaris). The downside is that fcntl() locks are
lost if *any* fd referring to that file is closed (luckily we don't do that).

The big downside is that the child process after fork() does not inherit the
lock. To work around this, when znc forks into the background, the child process
immediately blocks and tries to get the lock on the config file. Once the parent
releases the lock by exiting, the child will get it.

This shouldn't cause races with other ZNCs, because in every other place we
don't block waiting for a lock but instead abort immediately if the file is
already locked.

Thanks to LeftWing aka Joshua M. Clulow for making znc work on solaris (and
automatically fixing some issues with NFS in the process).


git-svn-id: https://znc.svn.sourceforge.net/svnroot/znc/trunk@2065 726aef4b-f618-498e-8847-2d620e286838

FileUtils.cpp

@@ -12,6 +12,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <fcntl.h>
 
 #ifndef HAVE_LSTAT
 #  define lstat(a, b)	stat(a, b)
@@ -388,23 +389,33 @@ bool CFile::TryExLock(const CString& sLockFile, int iFlags) {
 }
 
 bool CFile::TryExLock() {
-	return Lock(LOCK_EX|LOCK_NB);
+	return Lock(F_WRLCK, false);
+}
+
+bool CFile::ExLock() {
+	return Lock(F_WRLCK, true);
 }
 
 bool CFile::UnLock() {
-	return Lock(LOCK_UN);
+	return Lock(F_UNLCK, true);
 }
 
-bool CFile::Lock(int iOperation) {
+bool CFile::Lock(int iType, bool bBlocking) {
+	struct flock fl;
+
 	if (m_iFD == -1) {
 		return false;
 	}
 
-	if (flock(m_iFD, iOperation) != 0) {
+	fl.l_type   = iType;
+	fl.l_whence = SEEK_SET;
+	fl.l_start  = 0;
+	fl.l_len    = 0;
+	if (fcntl(m_iFD, (bBlocking ? F_SETLKW : F_SETLK), &fl) == -1) {
 		return false;
+	} else {
+		return true;
 	}
-
-	return true;
 }
 
 bool CFile::IsOpen() const { return (m_iFD != -1); }

FileUtils.h

@@ -111,6 +111,7 @@ public:
 
 	bool TryExLock(const CString& sLockFile, int iFlags = O_RDONLY | O_CREAT);
 	bool TryExLock();
+	bool ExLock();
 	bool UnLock();
 
 	bool IsOpen() const;
@@ -119,8 +120,8 @@ public:
 	CString GetDir() const;
 
 private:
-	// flock() wrapper
-	bool Lock(int iOperation);
+	// fcntl() locking wrapper
+	bool Lock(int iType, bool bBlocking);
 
 	CString m_sBuffer;
 	int     m_iFD;

main.cpp

@@ -254,6 +254,16 @@ int main(int argc, char** argv) {
 			return 0;
 		}
 
+		/* fcntl() locks don't necessarily propagate to forked()
+		 *   children.  Reacquire the lock here.  Use the blocking
+		 *   call to avoid race condition with parent exiting.
+		 */
+		if (!pZNC->WaitForChildLock()) {
+			CUtils::PrintError("Child was unable to obtain lock on config file.");
+			delete pZNC;
+			return 1;
+		}
+
 		// Redirect std in/out/err to /dev/null
 		close(0); open("/dev/null", O_RDONLY);
 		close(1); open("/dev/null", O_WRONLY);

znc.cpp

@@ -1058,7 +1058,9 @@ bool CZNC::DoRehash(CString& sError)
 	if (m_LockFile.IsOpen())
 		m_LockFile.Close();
 
-	if (!m_LockFile.Open(m_sConfigFile)) {
+	// need to open the config file Read/Write for fcntl()
+	// exclusive locking to work properly!
+	if (!m_LockFile.Open(m_sConfigFile, O_RDWR)) {
 		sError = "Can not open config file";
 		CUtils::PrintStatus(false, sError);
 		return false;
@@ -2071,3 +2073,7 @@ void CZNC::LeakConnectUser(CConnectUserTimer *pTimer) {
 	if (m_pConnectUserTimer == pTimer)
 		m_pConnectUserTimer = NULL;
 }
+
+bool CZNC::WaitForChildLock() {
+	return m_LockFile.ExLock();
+}

znc.h

@@ -38,6 +38,7 @@ public:
 	void ReleaseISpoof();
 	bool WritePidFile(int iPid);
 	bool DeletePidFile();
+	bool WaitForChildLock();
 	Csock* FindSockByName(const CString& sSockName);
 	bool IsHostAllowed(const CString& sHostMask) const;
 	// This returns false if there are too many anonymous connections from this ip