X-Git-Url: http://git.indexdata.com/?p=yazpp-moved-to-github.git;a=blobdiff_plain;f=src%2Fyaz-pdu-assoc.cpp;h=8d6f577897060493b5e5deee8735a0c3a488798c;hp=b8e3416f4b283d091e2f0125185f620c9920f1a8;hb=0084c40d8bc6babaeb0b833b12d9cd625c807525;hpb=75f7c460d6d10961f3d2ed841b757d6d6b7725d7

diff --git a/src/yaz-pdu-assoc.cpp b/src/yaz-pdu-assoc.cpp
index b8e3416..8d6f577 100644
--- a/src/yaz-pdu-assoc.cpp
+++ b/src/yaz-pdu-assoc.cpp
@@ -1,16 +1,21 @@
-/*
- * Copyright (c) 1998-2004, Index Data.
+/* This file is part of the yazpp toolkit.
+ * Copyright (C) 1998-2012 Index Data and Mike Taylor
  * See the file LICENSE for details.
- * 
- * $Id: yaz-pdu-assoc.cpp,v 1.42 2005-06-21 21:30:24 adam Exp $
  */
 
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <assert.h>
 #include <string.h>
 #include <yaz/log.h>
 #include <yaz/tcpip.h>
 
-#include <yaz++/pdu-assoc.h>
+#include <yazpp/pdu-assoc.h>
+
+#if HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
 
 using namespace yazpp_1;
 
@@ -30,6 +35,7 @@ void PDU_Assoc::init(ISocketObservable *socketObservable)
     m_destroyed = 0;
     m_idleTime = 0;
     m_log = YLOG_DEBUG;
+    m_session_is_dead = false;
 }
 
 PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable)
@@ -38,31 +44,31 @@ PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable)
 }
 
 PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable,
-			     COMSTACK cs)
+                     COMSTACK cs)
 {
     init(socketObservable);
     m_cs = cs;
     unsigned mask = 0;
     if (cs->io_pending & CS_WANT_WRITE)
-	mask |= SOCKET_OBSERVE_WRITE;
+        mask |= SOCKET_OBSERVE_WRITE;
     if (cs->io_pending & CS_WANT_READ)
-	mask |= SOCKET_OBSERVE_READ;
+        mask |= SOCKET_OBSERVE_READ;
     m_socketObservable->addObserver(cs_fileno(cs), this);
     if (!mask)
     {
-	yaz_log (m_log, "new PDU_Assoc. Ready");
-	m_state = Ready;
-	flush_PDU();
+        yaz_log (m_log, "new PDU_Assoc. Ready");
+        m_state = Ready;
+        flush_PDU();
     }
     else
     {
-	yaz_log (m_log, "new PDU_Assoc. Accepting");
-	// assume comstack is accepting...
-	m_state = Accepting;
-	m_socketObservable->addObserver(cs_fileno(cs), this);
-	yaz_log(m_log, "maskObserver 1");
-	m_socketObservable->maskObserver(this,
-					 mask |SOCKET_OBSERVE_EXCEPT);
+        yaz_log (m_log, "new PDU_Assoc. Accepting");
+        // assume comstack is accepting...
+        m_state = Accepting;
+        m_socketObservable->addObserver(cs_fileno(cs), this);
+        yaz_log(m_log, "maskObserver 1");
+        m_socketObservable->maskObserver(this,
+                                         mask |SOCKET_OBSERVE_EXCEPT);
     }
 }
 
@@ -76,10 +82,10 @@ IPDU_Observable *PDU_Assoc::clone()
 void PDU_Assoc::socketNotify(int event)
 {
     yaz_log (m_log, "PDU_Assoc::socketNotify p=%p state=%d event = %d",
-	  this, m_state, event);
+          this, m_state, event);
     if (event & SOCKET_OBSERVE_EXCEPT)
     {
-        close();
+        shutdown();
         m_PDU_Observer->failNotify();
         return;
     }
@@ -91,178 +97,188 @@ void PDU_Assoc::socketNotify(int event)
     switch (m_state)
     {
     case Accepting:
-	if (!cs_accept (m_cs))
-	{
-	    yaz_log (m_log, "PDU_Assoc::cs_accept failed");
-	    m_cs = 0;
-	    close();
-	    m_PDU_Observer->failNotify();
-	}
-	else
-	{
-	    unsigned mask = 0;
-	    if (m_cs->io_pending & CS_WANT_WRITE)
-		mask |= SOCKET_OBSERVE_WRITE;
-	    if (m_cs->io_pending & CS_WANT_READ)
-		mask |= SOCKET_OBSERVE_READ;
-	    if (!mask)
-	    {   // accept is complete. turn to ready state and write if needed
-		m_state = Ready;
-		flush_PDU();
-	    }
-	    else  
-	    {   // accept still incomplete.
-	        yaz_log(m_log, "maskObserver 2");
-		m_socketObservable->maskObserver(this,
-					     mask|SOCKET_OBSERVE_EXCEPT);
-	    }
-	}
-	break;
+        if (!cs_accept (m_cs))
+        {
+            yaz_log (m_log, "PDU_Assoc::cs_accept failed");
+            m_cs = 0;
+            shutdown();
+            m_PDU_Observer->failNotify();
+        }
+        else
+        {
+            unsigned mask = 0;
+            if (m_cs->io_pending & CS_WANT_WRITE)
+                mask |= SOCKET_OBSERVE_WRITE;
+            if (m_cs->io_pending & CS_WANT_READ)
+                mask |= SOCKET_OBSERVE_READ;
+            if (!mask)
+            {   // accept is complete. turn to ready state and write if needed
+                m_state = Ready;
+                flush_PDU();
+            }
+            else  
+            {   // accept still incomplete.
+                yaz_log(m_log, "maskObserver 2");
+                m_socketObservable->maskObserver(this,
+                                             mask|SOCKET_OBSERVE_EXCEPT);
+            }
+        }
+        break;
     case Connecting:
-	if (event & SOCKET_OBSERVE_READ && 
-	    event & SOCKET_OBSERVE_WRITE)
-	{
-	    // For Unix: if both read and write is set, then connect failed.
-	    close();
-	    m_PDU_Observer->failNotify();
-	}
-	else
-	{
-	    yaz_log (m_log, "cs_rcvconnect");
-	    int res = cs_rcvconnect (m_cs);
-	    if (res == 1)
-	    {
-		unsigned mask = SOCKET_OBSERVE_EXCEPT;
-		if (m_cs->io_pending & CS_WANT_WRITE)
-		    mask |= SOCKET_OBSERVE_WRITE;
-		if (m_cs->io_pending & CS_WANT_READ)
-		    mask |= SOCKET_OBSERVE_READ;
-	        yaz_log(m_log, "maskObserver 3");
-		m_socketObservable->maskObserver(this, mask);
-	    }
-	    else
-	    {
-		m_state = Ready;
-		if (m_PDU_Observer)
-		    m_PDU_Observer->connectNotify();
-		flush_PDU();
-	    }
-	}
-	break;
+        if (event & SOCKET_OBSERVE_READ && 
+            event & SOCKET_OBSERVE_WRITE)
+        {
+            // For Unix: if both read and write is set, then connect failed.
+            shutdown();
+            m_PDU_Observer->failNotify();
+        }
+        else
+        {
+            yaz_log (m_log, "cs_rcvconnect");
+            int res = cs_rcvconnect (m_cs);
+            if (res == 1)
+            {
+                unsigned mask = SOCKET_OBSERVE_EXCEPT;
+                if (m_cs->io_pending & CS_WANT_WRITE)
+                    mask |= SOCKET_OBSERVE_WRITE;
+                if (m_cs->io_pending & CS_WANT_READ)
+                    mask |= SOCKET_OBSERVE_READ;
+                yaz_log(m_log, "maskObserver 3");
+                m_socketObservable->maskObserver(this, mask);
+            }
+            else
+            {
+                m_state = Ready;
+                if (m_PDU_Observer)
+                    m_PDU_Observer->connectNotify();
+                flush_PDU();
+            }
+        }
+        break;
     case Listen:
-	if (event & SOCKET_OBSERVE_READ)
-	{
-	    int res;
-	    COMSTACK new_line;
-	    
-	    if ((res = cs_listen(m_cs, 0, 0)) == 1)
-		return;
-	    if (res < 0)
-	    {
-		yaz_log(YLOG_FATAL|YLOG_ERRNO, "cs_listen failed");
-		return;
-	    }
-	    if (!(new_line = cs_accept(m_cs)))
-		return;
-	    /* 1. create socket-manager 
+        if (event & SOCKET_OBSERVE_READ)
+        {
+            int res;
+            COMSTACK new_line;
+            
+            if ((res = cs_listen(m_cs, 0, 0)) == 1)
+                return;
+            if (res < 0)
+            {
+                yaz_log(YLOG_FATAL|YLOG_ERRNO, "cs_listen failed");
+                return;
+            }
+            if (!(new_line = cs_accept(m_cs)))
+                return;
+            /* 1. create socket-manager 
                2. create pdu-assoc
                3. create top-level object
                     setup observer for child fileid in pdu-assoc
                4. start thread
-	    */
-	    yaz_log (m_log, "new session: parent fd=%d child fd=%d",
-		     cs_fileno(m_cs), cs_fileno(new_line));
-	    childNotify (new_line);
-	}
-	break;
+            */
+            yaz_log (m_log, "new session: parent fd=%d child fd=%d",
+                     cs_fileno(m_cs), cs_fileno(new_line));
+            childNotify (new_line);
+        }
+        break;
     case Writing:
         if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
             flush_PDU();
         break;
     case Ready:
-	if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
-	{
-	    do
-	    {
-		int res = cs_get (m_cs, &m_input_buf, &m_input_len);
-		if (res == 1)
+        if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
+        {
+            do
+            {
+                int res = cs_get (m_cs, &m_input_buf, &m_input_len);
+                if (res == 1)
                 {
                     unsigned mask = SOCKET_OBSERVE_EXCEPT;
                     if (m_cs->io_pending & CS_WANT_WRITE)
                         mask |= SOCKET_OBSERVE_WRITE;
                     if (m_cs->io_pending & CS_WANT_READ)
                         mask |= SOCKET_OBSERVE_READ;
-	            yaz_log(m_log, "maskObserver 4");
-		    m_socketObservable->maskObserver(this, mask);
-		    return;
+                    yaz_log(m_log, "maskObserver 4");
+                    m_socketObservable->maskObserver(this, mask);
+                    return;
                 }
-		else if (res <= 0)
-		{
-		    yaz_log (m_log, "PDU_Assoc::Connection closed by peer");
-		    close();
-		    if (m_PDU_Observer)
-			m_PDU_Observer->failNotify(); // problem here..
-		    return;
-		}
-		// lock it, so we know if recv_PDU deletes it.
-		int destroyed = 0;
-		m_destroyed = &destroyed;
-
-		if (!m_PDU_Observer)
-		    return;
+                else if (res <= 0)
+                {
+                    yaz_log (m_log, "PDU_Assoc::Connection closed by peer");
+                    shutdown();
+                    if (m_PDU_Observer)
+                        m_PDU_Observer->failNotify(); // problem here..
+                    return;
+                }
+                // lock it, so we know if recv_PDU deletes it.
+                int destroyed = 0;
+                m_destroyed = &destroyed;
+
+                if (!m_PDU_Observer)
+                    return;
 #if 0
-		PDU_Queue **pq = &m_queue_in;
-		while (*pq)
-		    pq = &(*pq)->m_next;
-		
-		*pq = new PDU_Queue(m_input_buf, res);
+                PDU_Queue **pq = &m_queue_in;
+                while (*pq)
+                    pq = &(*pq)->m_next;
+                
+                *pq = new PDU_Queue(m_input_buf, res);
 #else
-		m_PDU_Observer->recv_PDU(m_input_buf, res);
+                m_PDU_Observer->recv_PDU(m_input_buf, res);
 #endif
-		if (destroyed)   // it really was destroyed, return now.
-		    return;
+                if (destroyed)   // it really was destroyed, return now.
+                    return;
                 m_destroyed = 0;
-	    } while (m_cs && cs_more (m_cs));
-	    if (m_cs && m_state == Ready)
+            } while (m_cs && cs_more (m_cs));
+            if (m_cs && m_state == Ready)
             {
-	        yaz_log(m_log, "maskObserver 5");
-		m_socketObservable->maskObserver(this,
-						 SOCKET_OBSERVE_EXCEPT|
-						 SOCKET_OBSERVE_READ);
-	    }
-	}
-	break;
+                yaz_log(m_log, "maskObserver 5");
+                m_socketObservable->maskObserver(this,
+                                                 SOCKET_OBSERVE_EXCEPT|
+                                                 SOCKET_OBSERVE_READ);
+            }
+        }
+        break;
     case Closed:
-	yaz_log (m_log, "CLOSING state=%d event was %d", m_state, event);
-	close();
-	m_PDU_Observer->failNotify();
-	break;
+        yaz_log (m_log, "CLOSING state=%d event was %d", m_state, event);
+        shutdown();
+        m_PDU_Observer->failNotify();
+        break;
     default:
-	yaz_log (m_log, "Unknown state=%d event was %d", m_state, event);
-	close();
-	m_PDU_Observer->failNotify();
+        yaz_log (m_log, "Unknown state=%d event was %d", m_state, event);
+        shutdown();
+        m_PDU_Observer->failNotify();
+    }
+}
+
+void PDU_Assoc::close_session()
+{
+    m_session_is_dead = true;
+    if (!m_queue_out)
+    {
+        shutdown();
+        m_PDU_Observer->failNotify();
     }
 }
 
-void PDU_Assoc::close()
+void PDU_Assoc::shutdown()
 {
     PDU_Assoc *ch;
     for (ch = m_children; ch; ch = ch->m_next)
-	ch->close();
+        ch->shutdown();
 
     m_socketObservable->deleteObserver(this);
     m_state = Closed;
     if (m_cs)
     {
-	yaz_log (m_log, "PDU_Assoc::close fd=%d", cs_fileno(m_cs));
-	cs_close (m_cs);
+        yaz_log (m_log, "PDU_Assoc::close fd=%d", cs_fileno(m_cs));
+        cs_close (m_cs);
     }
     m_cs = 0;
     while (m_queue_out)
     {
-	PDU_Queue *q_this = m_queue_out;
-	m_queue_out = m_queue_out->m_next;
-	delete q_this;
+        PDU_Queue *q_this = m_queue_out;
+        m_queue_out = m_queue_out->m_next;
+        delete q_this;
     }
     xfree (m_input_buf);
     m_input_buf = 0;
@@ -271,31 +287,31 @@ void PDU_Assoc::close()
 
 void PDU_Assoc::destroy()
 {
-    close();
+    shutdown();
 
     if (m_destroyed)
-	*m_destroyed = 1;
+        *m_destroyed = 1;
     PDU_Assoc **c;
 
     // delete from parent's child list (if any)
     if (m_parent)
     {
-	c = &m_parent->m_children;
-	while (*c != this)
-	{
-	    assert (*c);
-	    c = &(*c)->m_next;
-	}
-	*c = (*c)->m_next;
+        c = &m_parent->m_children;
+        while (*c != this)
+        {
+            assert (*c);
+            c = &(*c)->m_next;
+        }
+        *c = (*c)->m_next;
     }
     // delete all children ...
     c = &m_children;
     while (*c)
     {
-	PDU_Assoc *here = *c;
-	*c = (*c)->m_next;
-	here->m_parent = 0;
-	delete here;
+        PDU_Assoc *here = *c;
+        *c = (*c)->m_next;
+        here->m_parent = 0;
+        delete here;
     }
     yaz_log (m_log, "PDU_Assoc::destroy this=%p", this);
 }
@@ -320,25 +336,30 @@ int PDU_Assoc::flush_PDU()
     if (m_state != Ready && m_state != Writing)
     {
         yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU, not ready");
-	return 1;
+        return 1;
     }
     PDU_Queue *q = m_queue_out;
     if (!q)
     {
-	m_state = Ready;
-	yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU queue empty");
-	yaz_log(m_log, "maskObserver 6");
-	m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
-					 SOCKET_OBSERVE_WRITE|
-					 SOCKET_OBSERVE_EXCEPT);
+        m_state = Ready;
+        yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU queue empty");
+        yaz_log(m_log, "maskObserver 6");
+        m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
+                                         SOCKET_OBSERVE_WRITE|
+                                         SOCKET_OBSERVE_EXCEPT);
+        if (m_session_is_dead)
+        {
+            shutdown();
+            m_PDU_Observer->failNotify();
+        }
         return 0;
     }
     r = cs_put (m_cs, q->m_buf, q->m_len);
     if (r < 0)
     {
         yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put failed");
-        close();
-	m_PDU_Observer->failNotify();
+        shutdown();
+        m_PDU_Observer->failNotify();
         return r;
     }
     if (r == 1)
@@ -350,11 +371,11 @@ int PDU_Assoc::flush_PDU()
         if (m_cs->io_pending & CS_WANT_READ)
             mask |= SOCKET_OBSERVE_READ;
 
-	mask |= SOCKET_OBSERVE_WRITE;
-	yaz_log(m_log, "maskObserver 7");
-	m_socketObservable->maskObserver(this, mask);
+        mask |= SOCKET_OBSERVE_WRITE;
+        yaz_log(m_log, "maskObserver 7");
+        m_socketObservable->maskObserver(this, mask);
         yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put %d bytes fd=%d (inc)",
-		 q->m_len, cs_fileno(m_cs));
+                 q->m_len, cs_fileno(m_cs));
         return r;
     } 
     yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put %d bytes", q->m_len);
@@ -365,9 +386,9 @@ int PDU_Assoc::flush_PDU()
     if (!m_queue_out)
     {
         m_state = Ready;
-	yaz_log(m_log, "maskObserver 8");
-	m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
-					 SOCKET_OBSERVE_EXCEPT);
+        yaz_log(m_log, "maskObserver 8");
+        m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
+                                         SOCKET_OBSERVE_EXCEPT);
     }
     return r;
 }
@@ -380,7 +401,7 @@ int PDU_Assoc::send_PDU(const char *buf, int len)
     
     if (!m_cs)
     {
-	yaz_log (m_log, "PDU_Assoc::send_PDU failed, m_cs == 0");
+        yaz_log (m_log, "PDU_Assoc::send_PDU failed, m_cs == 0");
         return -1;
     }
     while (*pq)
@@ -389,8 +410,8 @@ int PDU_Assoc::send_PDU(const char *buf, int len)
     if (is_idle)
         return flush_PDU ();
     else
-	yaz_log (m_log, "PDU_Assoc::cannot send_PDU fd=%d",
-		 cs_fileno(m_cs));
+        yaz_log (m_log, "PDU_Assoc::cannot send_PDU fd=%d",
+                 cs_fileno(m_cs));
     return 0;
 }
 
@@ -401,7 +422,7 @@ COMSTACK PDU_Assoc::comstack(const char *type_and_host, void **vp)
 
 int PDU_Assoc::listen(IPDU_Observer *observer, const char *addr)
 {
-    close();
+    shutdown();
 
     m_PDU_Observer = observer;
     void *ap;
@@ -411,11 +432,21 @@ int PDU_Assoc::listen(IPDU_Observer *observer, const char *addr)
         return -1;
     if (cs_bind(m_cs, ap, CS_SERVER) < 0)
         return -2;
-    m_socketObservable->addObserver(cs_fileno(m_cs), this);
+
+    int fd = cs_fileno(m_cs);
+#if HAVE_FCNTL_H
+    int oldflags = fcntl(fd, F_GETFD, 0);
+    if (oldflags >= 0)
+    {
+        oldflags |= FD_CLOEXEC;
+        fcntl(fd, F_SETFD, oldflags);
+    }
+#endif
+    m_socketObservable->addObserver(fd, this);
     yaz_log(m_log, "maskObserver 9");
     m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
-				     SOCKET_OBSERVE_EXCEPT);
-    yaz_log (m_log, "PDU_Assoc::listen ok fd=%d", cs_fileno(m_cs));
+                                     SOCKET_OBSERVE_EXCEPT);
+    yaz_log (m_log, "PDU_Assoc::listen ok fd=%d", fd);
     m_state = Listen;
     return 0;
 }
@@ -430,44 +461,44 @@ void PDU_Assoc::idleTime(int idleTime)
 int PDU_Assoc::connect(IPDU_Observer *observer, const char *addr)
 {
     yaz_log (m_log, "PDU_Assoc::connect %s", addr);
-    close();
+    shutdown();
     m_PDU_Observer = observer;
     void *ap;
     m_cs = comstack(addr, &ap);
     if (!m_cs)
-	return -1;
+        return -1;
     int res = cs_connect (m_cs, ap);
     yaz_log (m_log, "PDU_Assoc::connect fd=%d res=%d", cs_fileno(m_cs),
-	     res);
+             res);
     m_socketObservable->addObserver(cs_fileno(m_cs), this);
 
     if (res == 0)
     {   // Connect complete
-	m_state = Connecting;
-	unsigned mask = SOCKET_OBSERVE_EXCEPT;
-	mask |= SOCKET_OBSERVE_WRITE;
-	mask |= SOCKET_OBSERVE_READ;
-	yaz_log(m_log, "maskObserver 11");
-	m_socketObservable->maskObserver(this, mask);
+        m_state = Connecting;
+        unsigned mask = SOCKET_OBSERVE_EXCEPT;
+        mask |= SOCKET_OBSERVE_WRITE;
+        mask |= SOCKET_OBSERVE_READ;
+        yaz_log(m_log, "maskObserver 11");
+        m_socketObservable->maskObserver(this, mask);
     }
     else if (res > 0)
     {   // Connect pending
-	m_state = Connecting;
-	unsigned mask = SOCKET_OBSERVE_EXCEPT;
-	if (m_cs->io_pending & CS_WANT_WRITE)
-	    mask |= SOCKET_OBSERVE_WRITE;
-	if (m_cs->io_pending & CS_WANT_READ)
-	    mask |= SOCKET_OBSERVE_READ;
-	yaz_log(m_log, "maskObserver 11");
-	m_socketObservable->maskObserver(this, mask);
+        m_state = Connecting;
+        unsigned mask = SOCKET_OBSERVE_EXCEPT;
+        if (m_cs->io_pending & CS_WANT_WRITE)
+            mask |= SOCKET_OBSERVE_WRITE;
+        if (m_cs->io_pending & CS_WANT_READ)
+            mask |= SOCKET_OBSERVE_READ;
+        yaz_log(m_log, "maskObserver 11");
+        m_socketObservable->maskObserver(this, mask);
     }
     else
     {   // Connect failed immediately
-	// Since m_state is Closed we can distinguish this case from
+        // Since m_state is Closed we can distinguish this case from
         // normal connect in socketNotify handler
-	yaz_log(m_log, "maskObserver 12");
-	m_socketObservable->maskObserver(this, SOCKET_OBSERVE_WRITE|
-					 SOCKET_OBSERVE_EXCEPT);
+        yaz_log(m_log, "maskObserver 12");
+        m_socketObservable->maskObserver(this, SOCKET_OBSERVE_WRITE|
+                                         SOCKET_OBSERVE_EXCEPT);
     }
     return 0;
 }
@@ -476,20 +507,35 @@ int PDU_Assoc::connect(IPDU_Observer *observer, const char *addr)
 void PDU_Assoc::childNotify(COMSTACK cs)
 {
     PDU_Assoc *new_observable =
-	new PDU_Assoc (m_socketObservable, cs);
+        new PDU_Assoc (m_socketObservable, cs);
     
+    // Clone PDU Observer
+    new_observable->m_PDU_Observer = m_PDU_Observer->sessionNotify
+        (new_observable, cs_fileno(cs));
+
+    if (!new_observable->m_PDU_Observer)
+    {
+        new_observable->shutdown();
+        delete new_observable;
+        return;
+    }
     new_observable->m_next = m_children;
     m_children = new_observable;
     new_observable->m_parent = this;
-
-    // Clone PDU Observer
-    new_observable->m_PDU_Observer = m_PDU_Observer->sessionNotify
-	(new_observable, cs_fileno(cs));
 }
 
 const char*PDU_Assoc::getpeername()
 {
     if (!m_cs)
-	return 0;
+        return 0;
     return cs_addrstr(m_cs);
 }
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+