Use flock() instead of UUCP-style locking for serial devices

common/io/Serial.cpp

@@ -27,6 +27,7 @@
 #include <signal.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <sys/file.h>
 #ifdef _WIN32
 #define VC_EXTRALEAN
 #define WIN32_LEAN_AND_MEAN
@@ -57,6 +58,7 @@ using std::string;
 
 namespace {
 
+#ifdef UUCP_LOCKING
 string GetLockFile(const string &path) {
   const string base_name = ola::file::FilenameFromPath(path);
   return ola::file::JoinPaths(UUCP_LOCK_DIR, "LCK.." + base_name);
@@ -113,6 +115,7 @@ bool RemoveLockFile(const string &lock_file) {
   }
   return true;
 }
+#endif  // UUCP_LOCKING
 
 }  // namespace
 
@@ -140,7 +143,41 @@ bool UIntToSpeedT(uint32_t value, speed_t *output) {
   return false;
 }
 
+#ifdef HAVE_FLOCK
+bool OpenAndFlock(const std::string &path, int oflag, int *fd) {
+  // First, check if the path exists, there's no point trying to open it if not
+  if (!FileExists(path)) {
+    OLA_INFO << "Device " << path << " doesn't exist.";
+    return false;
+  }
+
+  // Now try to open the serial device.
+  if (!TryOpen(path, oflag, fd)) {
+    OLA_DEBUG << "Failed to open device " << path;
+    return false;
+  }
+
+  if (flock(*fd, LOCK_EX | LOCK_NB) == -1) {
+    OLA_INFO << "Failed to flock() device " << path;
+    close(*fd);
+    return false;
+  }
+
+#if HAVE_SYS_IOCTL_H
+  // As a final safety mechanism, use ioctl(TIOCEXCL) if available to prevent
+  // further opens.
+  if (ioctl(*fd, TIOCEXCL) == -1) {
+    OLA_WARN << "TIOCEXCL " << path << " failed: " << strerror(errno);
+    close(*fd);
+    return false;
+  }
+#endif  // HAVE_SYS_IOCTL_H
+  return true;
+}
+#endif // HAVE_FLOCK
 
+
+#ifdef UUCP_LOCKING
 bool AcquireUUCPLockAndOpen(const std::string &path, int oflag, int *fd) {
   // This is rather tricky since there is no real convention for LCK files.
   // If it was only a single process doing the locking we could use fnctl as
@@ -231,9 +268,11 @@ bool AcquireUUCPLockAndOpen(const std::string &path, int oflag, int *fd) {
 #endif  // HAVE_SYS_IOCTL_H
   return true;
 }
+#endif // UUCP_LOCKING
 
 
 void ReleaseUUCPLock(const std::string &path) {
+#ifdef UUCP_LOCKING
   const string lock_file = GetLockFile(path);
 
   pid_t locked_pid;
@@ -247,6 +286,16 @@ void ReleaseUUCPLock(const std::string &path) {
       OLA_INFO << "Released " << lock_file;
     }
   }
+#endif  /* else no action needed */
 }
+
+bool AcquireLockAndOpen(const std::string &path, int oflag, int *fd) {
+#ifdef UUCP_LOCKING
+	return AcquireUUCPLockAndOpen(path, oflag, fd);
+#else
+	return OpenAndFlock(path, oflag, fd);
+#endif
+}
+
 }  // namespace io
 }  // namespace ola

configure.ac

@@ -787,6 +787,22 @@ AC_ARG_ENABLE(
   [AS_HELP_STRING([--disable-doxygen-version],
   [Substitute the Doxygen version with latest, for the website])])
 
+# Use UUCP locking?
+AC_ARG_ENABLE(
+  [uucp-locking],
+  [AS_HELP_STRING([--enable-uucp-locking],
+  [Use UUCP locking instead of flock()])])
+
+AC_CHECK_FUNC([flock], [AC_DEFINE([HAVE_FLOCK], [1],
+                                  [Define if flock() is available])
+                        have_flock=yes], [])
+
+AS_IF([test "x$enable_uucp_locking" = xyes || test "x$have_flock" != xyes],
+      [AC_DEFINE([UUCP_LOCKING], [1],
+                 [Define if UUCP locking should be used instead of flock()])
+       SERIAL_LOCK_METHOD=UUCP],
+      [SERIAL_LOCK_METHOD=flock])
+
 # UUCP Lock directory
 AC_ARG_WITH([uucp-lock],
             [AS_HELP_STRING([--with-uucp-lock],
@@ -1022,6 +1038,7 @@ Enable HTTP Server: ${have_microhttpd}
 RDM Responder Tests: ${enable_rdm_tests}
 Ja Rule: ${BUILDING_JA_RULE}
 Enabled Plugins:${PLUGINS}
+Serial port locking: $SERIAL_LOCK_METHOD
 UUCP Lock Directory: $UUCPLOCK
 
 Now type 'make @<:@<target>@:>@'

include/ola/io/Serial.h

@@ -60,21 +60,27 @@ typedef enum {
 bool UIntToSpeedT(uint32_t value, speed_t *output);
 
 /**
- * @brief Try to open the path, respecting UUCP locking.
+ * @brief Try to open the path and obtain a lock to control access
  * @param path the path to open
  * @param oflag flags passed to open
  * @param[out] fd a pointer to the fd which is returned.
  * @returns true if the open succeeded, false otherwise.
  *
+ * Depending on the compile-time configuration, this will use either flock()
+ * (the default) or UUCP locking.  See: ./configure --enable-uucp-locking.
+ *
  * This fails-fast, it we can't get the lock immediately, we'll return false.
  */
-bool AcquireUUCPLockAndOpen(const std::string &path, int oflag, int *fd);
+bool AcquireLockAndOpen(const std::string &path, int oflag, int *fd);
 
 /**
  * @brief Remove a UUCP lock file for the device.
  * @param path The path to unlock.
  *
  * The lock is only removed if the PID matches.
+ *
+ * Does nothing if UUCP locking is not in use
+ * (see ./configure --enable-uucp-locking).
  */
 void ReleaseUUCPLock(const std::string &path);
 }  // namespace io

plugins/stageprofi/StageProfiDetector.cpp

@@ -164,9 +164,9 @@ ConnectedDescriptor* StageProfiDetector::ConnectToUSB(
   struct termios newtio;
 
   int fd;
-  if (!ola::io::AcquireUUCPLockAndOpen(widget_path,
-                                       O_RDWR | O_NONBLOCK | O_NOCTTY,
-                                       &fd)) {
+  if (!ola::io::AcquireLockAndOpen(widget_path,
+                                   O_RDWR | O_NONBLOCK | O_NOCTTY,
+                                   &fd)) {
     return NULL;
   }
 

plugins/usbpro/BaseUsbProWidget.cpp

@@ -129,8 +129,7 @@ ola::io::ConnectedDescriptor *BaseUsbProWidget::OpenDevice(
     const string &path) {
   struct termios newtio;
   int fd;
-  if (!ola::io::AcquireUUCPLockAndOpen(path, O_RDWR | O_NONBLOCK | O_NOCTTY,
-                                       &fd)) {
+  if (!ola::io::AcquireLockAndOpen(path, O_RDWR | O_NONBLOCK | O_NOCTTY, &fd)) {
     return NULL;
   }