Add possibility to update original sigaction for unsigactioned delaying

Author: Frizlab

Sources/SignalHandling/CStructsInSwift/Sigaction.swift

@@ -97,22 +97,30 @@ public struct Sigaction : Equatable, RawRepresentable {
 
 	It is impossible for a sigaction handler to be `nil`. If the method returns
 	`nil`, the previous handler was exactly the same as the one you installed.
-	Note however the sigaction function is always called in this method. */
+	Note however the sigaction function is always called in this method.
+	
+	If `updateUnsigRegistrations` is true (default), If there are delayed
+	sigactions registered with `SigactionDelayer_Unsig`, these registrations will
+	be updated and `sigaction` will not be called. */
 	@discardableResult
-	public func install(on signal: Signal, revertIfIgnored: Bool = true) throws -> Sigaction? {
+	public func install(on signal: Signal, revertIfIgnored: Bool = true, updateUnsigRegistrations: Bool = true) throws -> Sigaction? {
+		if updateUnsigRegistrations, let oldSigaction = SigactionDelayer_Unsig.updateOriginalSigaction(for: signal, to: self) {
+			return (oldSigaction != self ? oldSigaction : nil)
+		}
+		
 		var oldCAction = sigaction()
 		var newCAction = self.rawValue
 		guard sigaction(signal.rawValue, &newCAction, &oldCAction) == 0 else {
 			throw SignalHandlingError.nonDestructiveSystemError(Errno(rawValue: errno))
 		}
 		let oldSigaction = Sigaction(rawValue: oldCAction)
 		if revertIfIgnored && oldSigaction == .ignoreAction {
-			guard sigaction(signal.rawValue, &newCAction, &oldCAction) == 0 else {
+			guard sigaction(signal.rawValue, &oldCAction, nil) == 0 else {
 				throw SignalHandlingError.destructiveSystemError(Errno(rawValue: errno))
 			}
+			return nil
 		}
-		if oldSigaction != self {return oldSigaction}
-		else                    {return nil}
+		return (oldSigaction != self ? oldSigaction : nil)
 	}
 
 }

Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift

@@ -368,13 +368,13 @@ public enum SigactionDelayer_Block {
 						}
 						sigdelset(&sigset, signal.rawValue)
 
-						let oldAction = try Sigaction.ignoreAction.install(on: signal, revertIfIgnored: false)
+						let oldAction = try Sigaction.ignoreAction.install(on: signal, revertIfIgnored: false, updateUnsigRegistrations: false)
 						/* Will not hurt, the signal is ignore anyway (yes, there is a
 						 * race condition, I know). */
 						pthread_kill(pthread_self(), signal.rawValue)
 						/* No sigsuspend. Would block because signal is ignored. */
 						if let oldAction = oldAction {
-							do {try oldAction.install(on: signal, revertIfIgnored: false)}
+							do {try oldAction.install(on: signal, revertIfIgnored: false, updateUnsigRegistrations: false)}
 							catch let error as SignalHandlingError {
 								throw error.upgradeToDestructive()
 							}

Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift

@@ -64,6 +64,21 @@ public enum SigactionDelayer_Unsig {
 		}
 	}
 
+	/**
+	Change the original sigaction of the given signal if it was registered for an
+	unsigaction. This is useful if you want to change the sigaction handler after
+	having registered an unsigaction.
+	
+	Returns the previous sigaction if there was an unsigaction registered for the
+	given signal, `nil` otherwise. */
+	public static func updateOriginalSigaction(for signal: Signal, to sigaction: Sigaction) -> Sigaction? {
+		return signalProcessingQueue.sync{
+			let previous = unsigactionedSignals[signal]?.originalSigaction
+			unsigactionedSignals[signal]?.originalSigaction = sigaction
+			return previous
+		}
+	}
+	
 	/* ***************
 	   MARK: - Private
 	   *************** */
@@ -150,7 +165,7 @@ public enum SigactionDelayer_Unsig {
 	private static func registerDelayedSigactionOnQueue(_ signal: Signal, handler: @escaping DelayedSigactionHandler) throws -> DelayedSigaction {
 		/* Whether the signal was retained before or not, we re-install the ignore
 		 * handler on the given signal. */
-		let oldSigaction = try Sigaction.ignoreAction.install(on: signal, revertIfIgnored: false)
+		let oldSigaction = try Sigaction.ignoreAction.install(on: signal, revertIfIgnored: false, updateUnsigRegistrations: false)
 
 		let delayedSigaction = DelayedSigaction(signal: signal)
 
@@ -212,7 +227,7 @@ public enum SigactionDelayer_Unsig {
 
 		/* Now we have removed **all** unsigactions on the given signal. Let’s
 		 * restore the signal to the state before unsigactions. */
-		try unsigactionedSignal.originalSigaction.install(on: id.signal, revertIfIgnored: false)
+		try unsigactionedSignal.originalSigaction.install(on: id.signal, revertIfIgnored: false, updateUnsigRegistrations: false)
 		unsigactionedSignal.dispatchSource.cancel()
 
 		/* Finally, once the sigaction has been restored to the original value, we
@@ -315,7 +330,7 @@ public enum SigactionDelayer_Unsig {
 						/* Install the original sigaction temporarily. In case of
 						 * failure we do not even send the signal to ourselves, it’d
 						 * be useless. */
-						let previousSigaction = try sigaction.install(on: signal, revertIfIgnored: false)
+						let previousSigaction = try sigaction.install(on: signal, revertIfIgnored: false, updateUnsigRegistrations: false)
 
 						/* We send the signal to the thread directly. libdispatch uses
 						 * kqueue (on BSD, signalfd on Linux) and thus signals sent to
@@ -352,7 +367,7 @@ public enum SigactionDelayer_Unsig {
 						 * This is the only way I can think of. */
 //						sleep(3)
 						if let previousSigaction = previousSigaction {
-							do    {try previousSigaction.install(on: signal, revertIfIgnored: false)}
+							do {try previousSigaction.install(on: signal, revertIfIgnored: false, updateUnsigRegistrations: false)}
 							catch let error as SignalHandlingError {
 								throw error.upgradeToDestructive()
 							}