Exception throwing added,

Tested:
mysql_server <-> tcp_socket <-> xerxes <-> unix_socket <-> xerxes <-> tcp_socket <-> mysql/netcat

epoll.cxx

@@ -40,9 +40,9 @@ namespace xerxes
     events[target.fd]->data.fd = source.fd;
     
     if(0 != epoll_ctl(fd, EPOLL_CTL_ADD, source.fd, events[source.fd].get()))
-      throw EpollAddErr(); 
+      throw EpollAddErr(EPOLL_ADD_ERR_SOURCE); 
     if(0 != epoll_ctl(fd, EPOLL_CTL_ADD, target.fd, events[target.fd].get()))
-      throw EpollAddErr();
+      throw EpollAddErr(EPOLL_ADD_ERR_TARGET);
   }
 
   void
@@ -63,5 +63,26 @@ namespace xerxes
       throw EpollAddErr();
     events.erase(socket.fd);
   }
+
+  EpollErr::EpollErr()
+  {
+    EpollErr("unknown");
+  }
+
+  EpollErr::EpollErr(std::string err)
+  {
+    std::cerr << "Epoll Error: " << err << std::endl;
+    perror("ERRNO");
+  }
+  EpollAddErr::EpollAddErr()
+    {
+      EpollAddErr(ADD_ERR_SINGLE);
+    }
+  EpollAddErr::EpollAddErr(epoll_add_err_type t)
+    :EpollErr("could not add fd to epoll!"), type(t)
+  {
+    
+  }
+
   
 }

epoll.hxx

@@ -42,23 +42,32 @@ namespace xerxes
     std::map<int, event_t> events;
   };
 
-  enum epoll_add_err_type{
-    ADD_ERR_SINGLE,
-    ADD_ERR_SOURCE,
-    ADD_ERR_TARGET
+  enum epoll_add_err_type
+  {
+    EPOLL_ADD_ERR_SINGLE,
+    EPOLL_ADD_ERR_SOURCE,
+    EPOLL_ADD_ERR_TARGET
   };
 
-  class EpollErr{};
+  class EpollErr
+  {
+    public:
+    EpollErr();
+    EpollErr(std::string err);
+  };
   class EpollAddErr : public EpollErr {
     public:
-    EpollAddErr(){
-      EpollAddErr(ADD_ERR_SINGLE);
-    };
-    EpollAddErr(epoll_add_err_type t)
-      :type(t){};
+    EpollAddErr();
+    EpollAddErr(epoll_add_err_type t);
     epoll_add_err_type type;
   };
-  class EpollDelErr : public EpollErr {};
-  class EpollCreateErr : public EpollErr {};
+  class EpollDelErr : public EpollErr {
+    public:
+    EpollDelErr() : EpollErr("could not delete fd from epoll"){};
+  };
+  class EpollCreateErr : public EpollErr {
+    public:
+    EpollCreateErr() : EpollErr("could not create Epoll"){};
+  };
 }
 #endif

socket.cxx

@@ -20,7 +20,6 @@ namespace xerxes
 		int domain)
     : fd(socket(protocol, type, domain))
   {
-    std::cerr << "new socket" << std::endl;
     if(fd < 0)
       {
 	throw ConnCreateErr();
@@ -263,6 +262,6 @@ namespace xerxes
   }
   SocketErr::SocketErr(std::string err){
     std::cerr << "Socket Exception: " << err << std::endl;
-    perror("ERROR:");
+    perror("ERRNO");
   }
 }

xerxes.cxx

@@ -30,14 +30,9 @@ main(int argc, char* argv[])
   namespace po = boost::program_options;
   using namespace std;
   using namespace xerxes;
-  cout << "Hello, World!" << endl
-       << "ich kanns auch lassen, hier `Hello, World!' zu schreiben..." 
-       << endl;
-
 
   signal(SIGPIPE, SIG_IGN);
 
-  // Declare the supported options.
   po::options_description desc("Allowed options");
   desc.add_options()
     ("help", "produce help message")
@@ -60,6 +55,7 @@ main(int argc, char* argv[])
     {
       SocketOption sock = vm["src"].as<SocketOption>();
     }
+
   if (vm.count("dst")) 
     {
       SocketOption sock = vm["dst"].as<SocketOption>();
@@ -80,6 +76,7 @@ main(int argc, char* argv[])
 
   SocketOption src = vm["src"].as<SocketOption>();
   Socket &lstn =  *(src.gen_socket());
+
   if(src.type == TCP)
     {
       cout << "TCP Source is " << src.hostname << "," << src.port << ".\n";
@@ -91,11 +88,7 @@ main(int argc, char* argv[])
       bind_unix(lstn, src);
     }
 
-  int ret = listen(lstn, 3);
-  if( ret != 0)
-    {
-      exit(1);
-    }
+  listen(lstn, 3);
 
   EPoll epoll;
   epoll.add(lstn);
@@ -117,10 +110,17 @@ main(int argc, char* argv[])
 	    {
 	      SocketOption dst = vm["dst"].as<SocketOption>();
               boost::shared_ptr<Socket> target(dst.gen_socket());
-              connect_inet(*target, dst);
+	      if (dst.type == TCP)
+	        {
+                  connect_inet(*target, dst);
+		}
+              else
+	        {
+		  connect_unix(*target, dst);
+		}
 	      sockets[target->fd] = target;
 
-              cerr << "accept!" << endl;
+//              cerr << "accept!" << endl;
 	      boost::shared_ptr<Socket> source(accept(lstn, 0, 0));
 
 	      sockets[source->fd] = source;
@@ -131,7 +131,7 @@ main(int argc, char* argv[])
 	    {
 	      if(sockets[events[i].data.fd] == 0) 
 	        {
-		  cerr << "already closed, ignore" << endl;
+//		  cerr << "already closed, ignore" << endl;
 		  continue;
 		}
 	      //lookup
@@ -152,12 +152,12 @@ main(int argc, char* argv[])
 		  catch (SocketErr e)
 		    {
 		      // hangup
-		      cout << "Socket Error, closing " <<  target->fd << " and " << source->fd << endl;
+//		      cout << "Socket Error, closing " <<  target->fd << " and " << source->fd << endl;
 		      epoll.del(target->fd);
 		      epoll.del(source->fd);
 		      sockets.erase(target->fd);
 		      sockets.erase(source->fd);
-		      cerr << "closed" << endl;
+//		      cerr << "closed" << endl;
                       continue;
 		    }
 		}
@@ -165,7 +165,7 @@ main(int argc, char* argv[])
 	         || (events[i].events & EPOLLHUP))
 		{
 		  // hangup
-		  cout << target->fd << " closed by " << source->fd << endl;
+//		  cout << target->fd << " closed by " << source->fd << endl;
 		  epoll.del(target->fd);
 		  epoll.del(source->fd);
 		  sockets.erase(target->fd);