introduce throwable_exit for nicer stack unwinding

yes, I enjoy abusing features

Signed-off-by: Michael Krelin <hacker@klever.net>

4 files changed, 12 insertions, 2 deletions

diff --git a/src/eyefiworker.cc b/src/eyefiworker.cc
index ac75fc1..1979b46 100644
--- a/src/eyefiworker.cc
+++ b/src/eyefiworker.cc
@@ -2,90 +2,92 @@
 #ifndef NDEBUG
 # include <sys/resource.h>
 #endif
 #include <syslog.h>
 #include <cassert>
 #include <iostream>
 #include <fstream>
 #include <stdexcept>
 #include <iterator>
 #include <algorithm>
 #include <sys/wait.h>
 #include <autosprintf.h>
 #include "eyekinfig.h"
 #include "eyetil.h"
 #include "eyefiworker.h"
 #ifdef HAVE_SQLITE
 # include "iiidb.h"
 #endif
 
 eyefiworker::eyefiworker()
     : eyefiService(SOAP_IO_STORE|SOAP_IO_KEEPALIVE) {
 	bind_flags = SO_REUSEADDR; max_keep_alive = 0;
 	socket_flags =
 #if defined(MSG_NOSIGNAL)
 	    MSG_NOSIGNAL
 #elif defined(SO_NOSIGPIPE)
 	    SO_NOSIGPIPE
 #else
 #error Something is wrong with sigpipe prevention on the platform
 #endif
 	    ;
     }
+eyefiworker::~eyefiworker() {
+}
 
 int eyefiworker::run(int bindport) {
 #ifdef HAVE_SQLITE
     sqlite3_initialize();
 #endif
     if(!soap_valid_socket(bind(0,bindport,64)))
 	throw std::runtime_error("failed to bind()");
     signal(SIGCHLD,SIG_IGN);
     while(true) {
 	if(!soap_valid_socket(accept()))
 	    throw std::runtime_error("failed to accept()");
 	pid_t p = fork();
 	if(p<0) throw std::runtime_error("failed to fork()");
 	if(!p) {
 	    recv_timeout = 600; send_timeout = 120;
 	    (void)serve();
 	    soap_destroy(this); soap_end(this); soap_done(this);
 #ifndef NDEBUG
 	    struct rusage ru;
 	    if(getrusage(RUSAGE_SELF,&ru)) {
 		syslog(LOG_NOTICE,"Failed to getrusage(): %d",errno);
 	    }else{
 		syslog(LOG_INFO,"maxrss: %ld\n",ru.ru_maxrss);
 	    }
 #endif /* NDEBUG */
-	    _exit(0);
+	    throw throwable_exit(0);
 	}
 	close(socket); socket = SOAP_INVALID_SOCKET;
     }
 }
 
 static binary_t session_nonce;
 #ifdef HAVE_SQLITE
     static struct {
 	std::string filesignature;
 	long filesize;
 	std::string filename;
 	inline void reset() { filesignature.erase(); filename.erase(); filesize=0; }
 	inline void set(const std::string n,const std::string sig,long siz) {
 	    filename = n; filesignature = sig; filesize = siz;
 	}
 	inline bool is(const std::string n,const std::string sig,long siz) {
 	    return filesize==siz && filename==n && filesignature==sig;
 	}
     }   already;
 #endif /* HAVE_SQLITE */
 
 static bool detached_child() {
     pid_t p = fork();
     if(p<0) {
 	syslog(LOG_ERR,"Failed to fork away for hook execution");
 	_exit(-1);
     }
     if(!p) {
 	setsid();
 	for(int i=getdtablesize();i>=0;--i) close(i);
 	int i=open("/dev/null",O_RDWR); assert(i==0);
 	i = dup(i); assert(i==1);
diff --git a/src/eyefiworker.h b/src/eyefiworker.h
index 6d4082c..6cdecff 100644
--- a/src/eyefiworker.h
+++ b/src/eyefiworker.h
@@ -1,29 +1,30 @@
 #ifndef __EYEFIWORKER_H
 #define __EYEFIWORKER_H
 
 #include "soapeyefiService.h"
 
 class eyefiworker : public eyefiService {
     public:
 
 	eyefiworker();
+	~eyefiworker();
 
 	int run(int port) __attribute__ ((noreturn));
 
 	int StartSession(std::string macaddress, std::string cnonce,
 		int transfermode, long transfermodetimestamp,
 		struct rns__StartSessionResponse &r);
 	int GetPhotoStatus(std::string credential, std::string macaddress,
 		std::string filename, long filesize, std::string filesignature, int flags,
 		struct rns__GetPhotoStatusResponse &r);
 	int MarkLastPhotoInRoll(std::string macaddress, int mergedelta,
 		struct rns__MarkLastPhotoInRollResponse &r);
 	int UploadPhoto(int fileid, std::string macaddress,
 		std::string filename, long filesize, std::string filesignature,
 		std::string encryption, int flags,
 		struct rns__UploadPhotoResponse &r);
 
 	eyefiService *copy() { throw std::logic_error("Not meant to be called"); }
 };
 
 #endif /* __EYEFIWORKER_H */
diff --git a/src/eyetil.h b/src/eyetil.h
index eff2c43..03b9ba8 100644
--- a/src/eyetil.h
+++ b/src/eyetil.h
@@ -1,41 +1,46 @@
 #ifndef __EYETIL_H
 #define __EYETIL_H
 
 #include <vector>
 #include <string>
 #include <archive.h>
 #include <archive_entry.h>
 #include "openssl/md5.h"
 
+struct throwable_exit {
+    int rc;
+    throwable_exit(int rc_) : rc(rc_) { }
+};
+
 class binary_t : public std::vector<unsigned char> {
     public:
 	binary_t() { }
 	binary_t(size_type  n) : std::vector<unsigned char>(n) { }
 	binary_t(const std::string& h) { from_hex(h); }
 	binary_t(const void *d,size_t s) { from_data(d,s); }
 
 	binary_t& from_hex(const std::string& h);
 	binary_t& from_data(const void *d,size_t s);
 	binary_t& make_nonce();
 
 	std::string hex() const;
 	binary_t md5() const;
 };
 
 struct md5_digester {
     MD5_CTX ctx;
     md5_digester() { init(); }
 
     void init();
     void update(const void *d,size_t l);
     binary_t final();
 
     template<typename T>
     void update(const T& x) { update(&x,sizeof(x)); }
 
     template<typename T>
     struct update_iterator : public std::iterator<std::output_iterator_tag,T,void,T*,T&> {
 	md5_digester *d;
 	update_iterator(md5_digester *d_) : d(d_) { }
 	update_iterator(const update_iterator& x) : d(x.d) { }
 
diff --git a/src/iiid.cc b/src/iiid.cc
index d655fe3..b3dd3bf 100644
--- a/src/iiid.cc
+++ b/src/iiid.cc
@@ -60,38 +60,40 @@ int main(int argc,char **argv) try {
 		    std::cerr << "Failed to parse port number" << std::endl;
 		    exit(1);
 		}
 		break;
 	    default:
 		std::cerr << "Huh?" << std::endl;
 		exit(1);
 		break;
 	}
     }
 
     const char *ident = rindex(*argv,'/');
     if(ident)
 	++ident;
     else
 	ident = *argv;
     openlog(ident,LOG_PERROR|LOG_PID,LOG_DAEMON);
     syslog(LOG_INFO,"Starting iii eye-fi manager");
 
     struct stat st;
     if(stat(EYEKIN_CONF_DIR,&st) || !S_ISDIR(st.st_mode))
 	syslog(LOG_WARNING,"configuration directory '%s' does not exist or is not a directory",EYEKIN_CONF_DIR);
     glob_t g; int rg = glob(EYEKIN_CONF_DIR"/????????????.conf",GLOB_NOSORT,NULL,&g);
     if(rg || !g.gl_pathc)
 	syslog(LOG_WARNING,"I see nothing resembling a card config in '%s'",EYEKIN_CONF_DIR);
     else
 	globfree(&g);
 
     eyefiworker().run(port);
 
     closelog();
     return 0;
-} catch(std::exception& e) {
+} catch(const throwable_exit& e) {
+    return e.rc;
+} catch(const std::exception& e) {
     syslog(LOG_CRIT,"Exiting iii daemon, because of error condition");
     syslog(LOG_CRIT,"Exception: %s",e.what());
     return 1;
 }