{"id":2466,"date":"2016-01-11T07:23:47","date_gmt":"2016-01-11T13:23:47","guid":{"rendered":"http:\/\/dev.iachieved.it\/iachievedit\/?p=2466"},"modified":"2020-07-11T18:16:08","modified_gmt":"2020-07-11T23:16:08","slug":"trapping-signals-with-swift-on-linux","status":"publish","type":"post","link":"https:\/\/dev.iachieved.it\/iachievedit\/trapping-signals-with-swift-on-linux\/","title":{"rendered":"Trapping Signals with Swift on Linux"},"content":{"rendered":"

Update:<\/b> Folks have figured out how to use sigaction<\/code> which is the preferred way of catching a signal. Jump down to read all about it, both signal<\/code> and sigaction<\/code> methods work!<\/p>\n

Unix applications frequently have a need to catch, or trap, signals<\/a>. For example, many daemons will reread their configuration file upon receipt of the SIGHUP<\/code> signal. A client interface may catch CTRL-C and print Are you sure you want to quit? [yN]<\/code>.<\/p>\n

This can be accomplished in Swift on Linux as well by using the signal<\/code><\/a> function from Glibc<\/code>. The code, which is a play on Adam Sharp’s gist<\/a>:<\/p>\n

\nimport Glibc\n\nenum Signal:Int32 {\n  case HUP    = 1\n  case INT    = 2\n  case QUIT   = 3\n  case ABRT   = 6\n  case KILL   = 9\n  case ALRM   = 14\n  case TERM   = 15\n}\n\ntypealias SignalHandler = __sighandler_t\n\nfunc trap(signum:Signal, action:SignalHandler) {\n  signal(signum.rawValue, action)\n}\n\ntrap(.INT) { signal in\n  print(\"Intercepted signal:  \\(signal)\")\n}\n\nselect(0, nil, nil, nil, nil) \/\/ Wait around for CTRL-C\n<\/pre>\n
Run with swift<\/code> or compile and execute using swiftc<\/code>.  The application will wait at the select<\/code> statement.  Pressing CTRL-C will generate a SIGINT<\/code> and the trap routine will execute (and end the application).<\/p>\n
To be clear, the application did not exit because the trap closure was executed.  The exit occurred because flow of control transferred from the closure to after<\/i> the select<\/code>.  Think of the line after the select<\/code> as an implicit exit(0)<\/code>.  If you rewrite this as<\/p>\n
\nwhile true {\n  select(0, nil, nil, nil, nil)\n}\n<\/pre>\n
then the application will not exit after the signal handler executes.<\/p>\n
Note:<\/b>  The Signal<\/code> enumeration is but a small subset of the various signals.  Check out man 7 signal<\/code><\/a> for a complete list.<\/p>\n
Pretty Printing<\/h3>\n
There’s no need to add another integer-to-string translation table to get the type of signal received.  strsignal<\/code> is a handy function to get a human-friendly string name for the signal:<\/p>\n
\ntrap(.INT) { signal in\n  if let signalName = String.fromCString(strsignal(signal)) {\n    print(\"Intercepted signal:  \\(signalName)\")\n  } else {\n    print(\"Intercepted signal:  \\(signal)\")\n  }\n}\n<\/pre>\n
Trailing Closures<\/h3>\n
Trailing closures<\/i> are one of those syntactical goodies that make Swift a joy to program in.  Your first exposure to them is probably<\/i> implementing a callback function to an HTTP GET request:<\/p>\n
\nlet request = HTTPRequest(.GET, url:\"http:\/\/someappserver\/somerestapi\/somerestresource\"){\n  response, error in \n  \/\/ do some stuff with the response\n}\nrequest.request()\n<\/pre>\n
The code between the braces is actually<\/i> the last<\/i> parameter to the HTTPRequest<\/code> class initializer.  The parameter signature is likely to be (HTTPResponse, NSError) -> Void<\/code>.  Nothing requires you to code this in the form of the trailing closure, but it’s frequently nice to.  Just remember that a trailing closure can only be used when the function to be called is the last<\/i> parameter in the function signature.  Those are the rules.<\/p>\n
We of course use this feature in our routine:<\/p>\n
\ntypealias SignalHandler = __sighandler_t\n\nfunc trap(signum:Signal, action:SignalHandler) {\n  signal(signum.rawValue, action)\n}\n\ntrap(.INT) { signal in\n  print(\"Intercepted signal:  \\(signal)\")\n}\n<\/pre>\n
The trailing closure syntax is used to specify the signal handler which must adhere to the __signalhanlder_t<\/code> function signature.  This signature is simply (Int32) -> Void<\/code>, which is what our trailing closure is.<\/p>\n
What about `sigaction`?<\/h3>\n
Truth be told, we ought to be using sigaction<\/code><\/a> rather than signal<\/code>.  The man page says so, and everyone knows better than to argue with a man page.<\/p>\n
\nThe behavior of signal() varies across UNIX versions, and has also varied historically across different versions of Linux.   Avoid  its  use:  use sigaction(2) instead.\n<\/pre>\n
Unfortunately I haven’t figured out how<\/i> to use sigaction<\/code> with Swift on Linux.  There are two sigaction<\/code> definitions in Glibc.  One is for the sigaction<\/code> structure (struct sigaction<\/code>) and the other is for the sigaction<\/code> function.  Swift can’t seem to distinguish between the two, and only the function is surfaced.  Without the structure definition its difficult to call sigaction<\/code>.  Perhaps it is possible to write our own struct sigaction<\/code> definition and somehow trick Swift into thinking it can be passed into the sigaction<\/code> function.  I haven’t tried, but if someone out there figures it out, leave a comment!<\/p>\n
Hold the phone!<\/b>  An update on sigaction<\/code> from Robert (see comments) allows us to use sigaction<\/code>!  We’ve taken his code (thanks Robert) and updated it a bit:<\/p>\n
\nimport Glibc\n\nenum Signal:Int32 {\ncase HUP    = 1\ncase INT    = 2\ncase QUIT   = 3\ncase ABRT   = 6\ncase KILL   = 9\ncase ALRM   = 14\ncase TERM   = 15\n}\n\ntypealias SigactionHandler = @convention(c)(Int32) -> Void\n               \nlet hupHandler:SigactionHandler = { signal in\n  print(\"Received HUP signal, reread config file\")\n}\n                  \nfunc trap(signum:Signal, action:SigactionHandler) {\n  var sigAction = sigaction()  \n                    \n  sigAction.__sigaction_handler = unsafeBitCast(action, sigaction.__Unnamed_union___sigaction_handler.self)\n                    \n  sigaction(signum.rawValue, &sigAction, nil)\n}\n                  \n\/\/ This method works\ntrap(.INT) { signal in\n  print(\"Received INT signal\")\n  exit(0)\n}\n\n\/\/ And this works of course\ntrap(.HUP, action:hupHandler)\n\nwhile true {\n  select(0, nil, nil, nil, nil)\n}\n<\/pre>\n
Try it out!<\/p>\n
One Last Example<\/h3>\n
I mentioned above that the trailing closure didn’t have<\/i> to be used to provide the signal handler routine.  In this code we declare a single function sighandler<\/code> with a (Int32) -> Void<\/code> signature and then use it to trap SIGINT<\/code>, SIGHUP<\/code>, and SIGUSR1<\/code>.<\/p>\n
\nfunc sighandler(signal:Int32) {\n  if let signalName = String.fromCString(strsignal(signal)) {\n    print(\"Intercepted signal:  \\(signalName)\")\n  } else {\n    print(\"Intercepted signal:  \\(signal)\")\n  }\n}\n\ntrap(.INT,  action:sighandler)\ntrap(.USR1, action:sighandler)\ntrap(.HUP,  action:sighandler)\n<\/pre>\n
\"Handling<\/a>
Handling Signals<\/figcaption><\/figure>\n","protected":false},"excerpt":{"rendered":"
Update: Folks have figured out how to use sigaction which is the preferred way of catching a signal. Jump down to read all about it, both signal and sigaction methods work! Unix applications frequently have a need to catch, or trap, signals. For example, many daemons will reread their configuration file upon receipt of the […]<\/p>\n","protected":false},"author":1,"featured_media":3108,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[19,5],"tags":[],"class_list":["post-2466","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux","category-swift"],"_links":{"self":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2466"}],"collection":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/comments?post=2466"}],"version-history":[{"count":19,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2466\/revisions"}],"predecessor-version":[{"id":4169,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2466\/revisions\/4169"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/media\/3108"}],"wp:attachment":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/media?parent=2466"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/categories?post=2466"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/tags?post=2466"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}