-/*
- * Copyright (c) 1998-2000, Index Data.
+/* This file is part of the yazpp toolkit.
+ * Copyright (C) Index Data
* See the file LICENSE for details.
- *
- * $Log: yaz-pdu-assoc.cpp,v $
- * Revision 1.21 2000-11-20 14:17:36 adam
- * Yet another WIN32 fix for connect notify.
- *
- * Revision 1.20 2000/11/20 11:27:33 adam
- * Fixes for connect operation (timeout and notify fix).
- *
- * Revision 1.19 2000/11/01 14:22:59 adam
- * Added fd parameter for method IYaz_PDU_Observer::clone.
- *
- * Revision 1.18 2000/10/24 12:29:57 adam
- * Fixed bug in proxy where a Yaz_ProxyClient could be owned by
- * two Yaz_Proxy's (fatal).
- *
- * Revision 1.17 2000/10/11 11:58:16 adam
- * Moved header files to include/yaz++. Switched to libtool and automake.
- * Configure script creates yaz++-config script.
- *
- * Revision 1.16 2000/09/22 09:54:11 heikki
- * minor
- *
- * Revision 1.15 2000/09/21 21:43:20 adam
- * Better high-level server API.
- *
- * Revision 1.14 2000/09/12 12:09:53 adam
- * More work on high-level server.
- *
- * Revision 1.13 2000/09/08 10:23:42 adam
- * Added skeleton of yaz-z-server.
- *
- * Revision 1.12 2000/09/06 14:23:45 adam
- * WIN32 updates.
- *
- * Revision 1.11 2000/09/04 08:29:22 adam
- * Fixed memory leak(s). Added re-use of associations, rather than
- * re-init, when maximum number of targets are in use.
- *
- * Revision 1.10 2000/08/10 08:42:42 adam
- * Fixes for {set,get}_APDU_log.
- *
- * Revision 1.9 1999/12/06 13:52:45 adam
- * Modified for new location of YAZ header files. Experimental threaded
- * operation.
- *
- * Revision 1.8 1999/04/28 13:04:03 adam
- * Fixed setting of proxy otherInfo so that database(s) are removed.
- *
- * Revision 1.7 1999/04/21 12:09:01 adam
- * Many improvements. Modified to proxy server to work with "sessions"
- * based on cookies.
- *
- * Revision 1.6 1999/04/20 10:30:05 adam
- * Implemented various stuff for client and proxy. Updated calls
- * to ODR to reflect new name parameter.
- *g
- * Revision 1.5 1999/04/09 11:46:57 adam
- * Added object Yaz_Z_Assoc. Much more functional client.
- *
- * Revision 1.4 1999/03/23 14:17:57 adam
- * More work on timeout handling. Work on yaz-client.
- *
- * Revision 1.3 1999/02/02 14:01:20 adam
- * First WIN32 port of YAZ++.
- *
- * Revision 1.2 1999/01/28 13:08:44 adam
- * Yaz_PDU_Assoc better encapsulated. Memory leak fix in
- * yaz-socket-manager.cc.
- *
- * Revision 1.1.1.1 1999/01/28 09:41:07 adam
- * First implementation of YAZ++.
- *
*/
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <assert.h>
-
-#include <yaz++/yaz-pdu-assoc.h>
-
+#include <string.h>
#include <yaz/log.h>
#include <yaz/tcpip.h>
-Yaz_PDU_Assoc::Yaz_PDU_Assoc(IYazSocketObservable *socketObservable)
+#include <yazpp/pdu-assoc.h>
+
+#if HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+using namespace yazpp_1;
+
+namespace yazpp_1 {
+ class PDU_Assoc_priv {
+ friend class PDU_Assoc;
+ private:
+ enum {
+ Connecting,
+ Listen,
+ Ready,
+ Closed,
+ Writing,
+ Accepting
+ } state;
+ class PDU_Queue {
+ public:
+ PDU_Queue(const char *buf, int len);
+ ~PDU_Queue();
+ char *m_buf;
+ int m_len;
+ PDU_Queue *m_next;
+ };
+ PDU_Assoc *pdu_parent;
+ PDU_Assoc *pdu_children;
+ PDU_Assoc *pdu_next;
+ COMSTACK cs;
+ yazpp_1::ISocketObservable *m_socketObservable;
+ char *input_buf;
+ int input_len;
+ PDU_Queue *queue_out;
+ PDU_Queue *queue_in;
+ int *destroyed;
+ int idleTime;
+ int log;
+ void init(yazpp_1::ISocketObservable *socketObservable);
+ COMSTACK comstack(const char *type_and_host, void **vp);
+ bool m_session_is_dead;
+ char *cert_fname;
+ };
+}
+
+void PDU_Assoc_priv::init(ISocketObservable *socketObservable)
{
- m_state = Closed;
- m_cs = 0;
+ state = Closed;
+ cs = 0;
m_socketObservable = socketObservable;
+ queue_out = 0;
+ queue_in = 0;
+ input_buf = 0;
+ input_len = 0;
+ pdu_children = 0;
+ pdu_parent = 0;
+ pdu_next = 0;
+ destroyed = 0;
+ idleTime = 0;
+ log = YLOG_DEBUG;
+ m_session_is_dead = false;
+ cert_fname = 0;
+}
+
+PDU_Assoc::~PDU_Assoc()
+{
+ xfree(m_p->cert_fname);
+ delete m_p;
+}
+
+PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable)
+{
m_PDU_Observer = 0;
- m_queue_out = 0;
- m_input_buf = 0;
- m_input_len = 0;
- m_children = 0;
- m_parent = 0;
- m_next = 0;
- m_destroyed = 0;
- m_idleTime = 0;
- m_log = LOG_DEBUG;
+ m_p = new PDU_Assoc_priv;
+ m_p->init(socketObservable);
+}
+
+PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable,
+ COMSTACK cs)
+{
+ m_PDU_Observer = 0;
+ m_p = new PDU_Assoc_priv;
+ m_p->init(socketObservable);
+ m_p->cs = cs;
+ unsigned mask = 0;
+ if (cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+ m_p->m_socketObservable->addObserver(cs_fileno(cs), this);
+ if (!mask)
+ {
+ yaz_log(m_p->log, "new PDU_Assoc. Ready");
+ m_p->state = PDU_Assoc_priv::Ready;
+ flush_PDU();
+ }
+ else
+ {
+ yaz_log(m_p->log, "new PDU_Assoc. Accepting");
+ // assume comstack is accepting...
+ m_p->state = PDU_Assoc_priv::Accepting;
+ m_p->m_socketObservable->addObserver(cs_fileno(cs), this);
+ yaz_log(m_p->log, "maskObserver 1");
+ m_p->m_socketObservable->maskObserver(this,
+ mask|SOCKET_OBSERVE_EXCEPT);
+ }
}
-IYaz_PDU_Observable *Yaz_PDU_Assoc::clone()
+
+IPDU_Observable *PDU_Assoc::clone()
{
- Yaz_PDU_Assoc *copy = new Yaz_PDU_Assoc(m_socketObservable);
+ PDU_Assoc *copy = new PDU_Assoc(m_p->m_socketObservable);
return copy;
}
-void Yaz_PDU_Assoc::socketNotify(int event)
+void PDU_Assoc::socketNotify(int event)
{
- logf (m_log, "Yaz_PDU_Assoc::socketNotify p=%p event = %d", this, event);
- switch (m_state)
+ yaz_log(m_p->log, "PDU_Assoc::socketNotify p=%p state=%d event = %d",
+ this, m_p->state, event);
+ if (event & SOCKET_OBSERVE_EXCEPT)
+ {
+ shutdown();
+ m_PDU_Observer->failNotify();
+ return;
+ }
+ else if (event & SOCKET_OBSERVE_TIMEOUT)
{
- case Connecting:
- if (event & (YAZ_SOCKET_OBSERVE_READ|YAZ_SOCKET_OBSERVE_EXCEPT))
- {
- close();
- m_PDU_Observer->failNotify();
- }
- else if (event & YAZ_SOCKET_OBSERVE_TIMEOUT)
+ m_PDU_Observer->timeoutNotify();
+ return;
+ }
+ switch (m_p->state)
+ {
+ case PDU_Assoc_priv::Accepting:
+ if (!cs_accept(m_p->cs))
+ {
+ yaz_log(m_p->log, "PDU_Assoc::cs_accept failed");
+ m_p->cs = 0;
+ shutdown();
+ m_PDU_Observer->failNotify();
+ }
+ else
{
- m_PDU_Observer->timeoutNotify();
+ unsigned mask = 0;
+ if (m_p->cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (m_p->cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+ if (!mask)
+ { // accept is complete. turn to ready state and write if needed
+ m_p->state = PDU_Assoc_priv::Ready;
+ flush_PDU();
+ }
+ else
+ { // accept still incomplete.
+ yaz_log(m_p->log, "maskObserver 2");
+ m_p->m_socketObservable->maskObserver(this,
+ mask|SOCKET_OBSERVE_EXCEPT);
+ }
+ }
+ break;
+ case PDU_Assoc_priv::Connecting:
+ 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
- {
- m_state = Ready;
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT);
- m_PDU_Observer->connectNotify();
- flush_PDU();
- }
- break;
- case Listen:
- if (event & YAZ_SOCKET_OBSERVE_READ)
- {
- int res;
- COMSTACK new_line;
-
- if ((res = cs_listen(m_cs, 0, 0)) == 1)
- return;
- if (res < 0)
- {
- logf(LOG_FATAL|LOG_ERRNO, "cs_listen failed");
- return;
- }
- if (!(new_line = cs_accept(m_cs)))
- return;
- /* 1. create socket-manager
+ {
+ yaz_log(m_p->log, "cs_rcvconnect");
+ int res = cs_rcvconnect(m_p->cs);
+ if (res == 1)
+ {
+ unsigned mask = SOCKET_OBSERVE_EXCEPT;
+ if (m_p->cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (m_p->cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+ yaz_log(m_p->log, "maskObserver 3");
+ m_p->m_socketObservable->maskObserver(this, mask);
+ }
+ else
+ {
+ m_p->state = PDU_Assoc_priv::Ready;
+ if (m_PDU_Observer)
+ m_PDU_Observer->connectNotify();
+ flush_PDU();
+ }
+ }
+ break;
+ case PDU_Assoc_priv::Listen:
+ if (event & SOCKET_OBSERVE_READ)
+ {
+ int res;
+ COMSTACK new_line;
+
+ if ((res = cs_listen(m_p->cs, 0, 0)) == 1)
+ return;
+ if (res < 0)
+ {
+ yaz_log(YLOG_FATAL|YLOG_ERRNO, "cs_listen failed");
+ return;
+ }
+ if (!(new_line = cs_accept(m_p->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
- */
- int fd = cs_fileno(new_line);
- logf (m_log, "accept ok fd = %d", fd);
- cs_fileno(new_line) = -1;
- cs_close (new_line);
- childNotify(fd);
- }
- break;
- case Ready:
- if (event & YAZ_SOCKET_OBSERVE_WRITE)
- {
- flush_PDU();
- }
- if (event & YAZ_SOCKET_OBSERVE_READ)
- {
- do
- {
- int res = cs_get (m_cs, &m_input_buf, &m_input_len);
- if (res == 1)
- return;
- else if (res <= 0)
- {
- logf (m_log, "Connection closed by peer");
- close();
- m_PDU_Observer->failNotify(); // problem here..
- return;
- }
- // lock it, so we know if recv_PDU deletes it.
- int destroyed = 0;
- m_destroyed = &destroyed;
-
- m_PDU_Observer->recv_PDU(m_input_buf, res);
- m_destroyed = 0;
- if (destroyed) // it really was destroyed, return now.
- return;
- } while (m_cs && cs_more (m_cs));
- }
- if (event & YAZ_SOCKET_OBSERVE_TIMEOUT)
- {
- m_PDU_Observer->timeoutNotify();
- }
- break;
- case Closed:
- logf (m_log, "CLOSING state=%d event was %d", m_state, event);
- close();
- m_PDU_Observer->failNotify();
- break;
+ */
+ yaz_log(m_p->log, "new session: parent fd=%d child fd=%d",
+ cs_fileno(m_p->cs), cs_fileno(new_line));
+ childNotify(new_line);
+ }
+ break;
+ case PDU_Assoc_priv::Writing:
+ if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
+ flush_PDU();
+ break;
+ case PDU_Assoc_priv::Ready:
+ if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
+ {
+ do
+ {
+ int res = cs_get(m_p->cs, &m_p->input_buf, &m_p->input_len);
+ if (res == 1)
+ {
+ unsigned mask = SOCKET_OBSERVE_EXCEPT;
+ if (m_p->cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (m_p->cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+ yaz_log(m_p->log, "maskObserver 4");
+ m_p->m_socketObservable->maskObserver(this, mask);
+ return;
+ }
+ else if (res <= 0)
+ {
+ yaz_log(m_p->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_p->destroyed = &destroyed;
+
+ if (!m_PDU_Observer)
+ return;
+#if 0
+ PDU_Assoc_priv::PDU_Queue **pq = &m_p->m_queue_in;
+ while (*pq)
+ pq = &(*pq)->m_next;
+
+ *pq = new PDU_Assoc_priv::PDU_Queue(m_p->m_input_buf, res);
+#else
+ m_PDU_Observer->recv_PDU(m_p->input_buf, res);
+#endif
+ if (destroyed) // it really was destroyed, return now.
+ return;
+ m_p->destroyed = 0;
+ } while (m_p->cs && cs_more(m_p->cs));
+ if (m_p->cs && m_p->state == PDU_Assoc_priv::Ready)
+ {
+ yaz_log(m_p->log, "maskObserver 5");
+ m_p->m_socketObservable->maskObserver(this,
+ SOCKET_OBSERVE_EXCEPT|
+ SOCKET_OBSERVE_READ);
+ }
+ }
+ break;
+ case PDU_Assoc_priv::Closed:
+ yaz_log(m_p->log, "CLOSING state=%d event was %d", m_p->state,
+ event);
+ shutdown();
+ m_PDU_Observer->failNotify();
+ break;
default:
- logf (m_log, "Unknown state=%d event was %d", m_state, event);
- close();
- m_PDU_Observer->failNotify();
+ yaz_log(m_p->log, "Unknown state=%d event was %d", m_p->state, event);
+ shutdown();
+ m_PDU_Observer->failNotify();
+ }
+}
+
+void PDU_Assoc::close_session()
+{
+ m_p->m_session_is_dead = true;
+ if (!m_p->queue_out)
+ {
+ shutdown();
+ m_PDU_Observer->failNotify();
}
}
-void Yaz_PDU_Assoc::close()
+void PDU_Assoc::shutdown()
{
- m_socketObservable->deleteObserver(this);
- m_state = Closed;
- if (m_cs)
+ PDU_Assoc *ch;
+ for (ch = m_p->pdu_children; ch; ch = ch->m_p->pdu_next)
+ ch->shutdown();
+
+ m_p->m_socketObservable->deleteObserver(this);
+ m_p->state = PDU_Assoc_priv::Closed;
+ if (m_p->cs)
{
- logf (m_log, "Yaz_PDU_Assoc::close fd=%d", cs_fileno(m_cs));
- cs_close (m_cs);
+ yaz_log(m_p->log, "PDU_Assoc::close fd=%d", cs_fileno(m_p->cs));
+ cs_close(m_p->cs);
}
- m_cs = 0;
- while (m_queue_out)
+ m_p->cs = 0;
+ while (m_p->queue_out)
{
- PDU_Queue *q_this = m_queue_out;
- m_queue_out = m_queue_out->m_next;
- delete q_this;
+ PDU_Assoc_priv::PDU_Queue *q_this = m_p->queue_out;
+ m_p->queue_out = m_p->queue_out->m_next;
+ delete q_this;
}
- xfree (m_input_buf);
- m_input_buf = 0;
- m_input_len = 0;
+ xfree(m_p->input_buf);
+ m_p->input_buf = 0;
+ m_p->input_len = 0;
}
-void Yaz_PDU_Assoc::destroy()
+void PDU_Assoc::destroy()
{
- close();
- if (m_destroyed)
- *m_destroyed = 1;
- Yaz_PDU_Assoc **c;
+ shutdown();
+
+ if (m_p->destroyed)
+ *m_p->destroyed = 1;
+ PDU_Assoc **c;
// delete from parent's child list (if any)
- if (m_parent)
+ if (m_p->pdu_parent)
{
- c = &m_parent->m_children;
- while (*c != this)
- {
- assert (*c);
- c = &(*c)->m_next;
- }
- *c = (*c)->m_next;
+ c = &m_p->pdu_parent->m_p->pdu_children;
+ while (*c != this)
+ {
+ assert (*c);
+ c = &(*c)->m_p->pdu_next;
+ }
+ *c = (*c)->m_p->pdu_next;
}
// delete all children ...
- c = &m_children;
+ c = &m_p->pdu_children;
while (*c)
{
- Yaz_PDU_Assoc *here = *c;
- *c = (*c)->m_next;
- here->m_parent = 0;
- delete here;
+ PDU_Assoc *here = *c;
+ *c = (*c)->m_p->pdu_next;
+ here->m_p->pdu_parent = 0;
+ delete here;
}
+ yaz_log(m_p->log, "PDU_Assoc::destroy this=%p", this);
}
-Yaz_PDU_Assoc::PDU_Queue::PDU_Queue(const char *buf, int len)
+PDU_Assoc_priv::PDU_Queue::PDU_Queue(const char *buf, int len)
{
- m_buf = (char *) malloc (len);
- memcpy (m_buf, buf, len);
+ m_buf = (char *) xmalloc(len);
+ memcpy(m_buf, buf, len);
m_len = len;
m_next = 0;
}
-Yaz_PDU_Assoc::PDU_Queue::~PDU_Queue()
+PDU_Assoc_priv::PDU_Queue::~PDU_Queue()
{
- free (m_buf);
+ xfree(m_buf);
}
-int Yaz_PDU_Assoc::flush_PDU()
+int PDU_Assoc::flush_PDU()
{
int r;
-
- logf (m_log, "Yaz_PDU_Assoc::flush_PDU");
- if (m_state != Ready)
+
+ if (m_p->state != PDU_Assoc_priv::Ready && m_p->state != PDU_Assoc_priv::Writing)
{
- logf (m_log, "YAZ_PDU_Assoc::flush_PDU, not ready");
- return 1;
+ yaz_log(m_p->log, "YAZ_PDU_Assoc::flush_PDU, not ready");
+ return 1;
}
- PDU_Queue *q = m_queue_out;
+ PDU_Assoc_priv::PDU_Queue *q = m_p->queue_out;
if (!q)
{
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT);
+ m_p->state = PDU_Assoc_priv::Ready;
+ yaz_log(m_p->log, "YAZ_PDU_Assoc::flush_PDU queue empty");
+ yaz_log(m_p->log, "maskObserver 6");
+ m_p->m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
+ SOCKET_OBSERVE_WRITE|
+ SOCKET_OBSERVE_EXCEPT);
+ if (m_p->m_session_is_dead)
+ {
+ shutdown();
+ m_PDU_Observer->failNotify();
+ }
return 0;
}
- r = cs_put (m_cs, q->m_buf, q->m_len);
+ r = cs_put(m_p->cs, q->m_buf, q->m_len);
if (r < 0)
{
- close();
- m_PDU_Observer->failNotify();
+ yaz_log(m_p->log, "PDU_Assoc::flush_PDU cs_put failed");
+ shutdown();
+ m_PDU_Observer->failNotify();
return r;
}
if (r == 1)
{
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT|
- YAZ_SOCKET_OBSERVE_WRITE);
- logf (m_log, "Yaz_PDU_Assoc::flush_PDU put %d bytes (incomplete)",
- q->m_len);
+ unsigned mask = SOCKET_OBSERVE_EXCEPT;
+ m_p->state = PDU_Assoc_priv::Writing;
+ if (m_p->cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (m_p->cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+
+ mask |= SOCKET_OBSERVE_WRITE;
+ yaz_log(m_p->log, "maskObserver 7");
+ m_p->m_socketObservable->maskObserver(this, mask);
+ yaz_log(m_p->log, "PDU_Assoc::flush_PDU cs_put %d bytes fd=%d (inc)",
+ q->m_len, cs_fileno(m_p->cs));
return r;
}
- logf (m_log, "Yaz_PDU_Assoc::flush_PDU put %d bytes", q->m_len);
+ yaz_log(m_p->log, "PDU_Assoc::flush_PDU cs_put %d bytes", q->m_len);
// whole packet sent... delete this and proceed to next ...
- m_queue_out = q->m_next;
+ m_p->queue_out = q->m_next;
delete q;
// don't select on write if queue is empty ...
- if (!m_queue_out)
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT);
+ if (!m_p->queue_out)
+ {
+ m_p->state = PDU_Assoc_priv::Ready;
+ yaz_log(m_p->log, "maskObserver 8");
+ m_p->m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
+ SOCKET_OBSERVE_EXCEPT);
+ if (m_p->m_session_is_dead)
+ shutdown();
+ }
return r;
}
-int Yaz_PDU_Assoc::send_PDU(const char *buf, int len)
+int PDU_Assoc::send_PDU(const char *buf, int len)
{
- logf (m_log, "Yaz_PDU_Assoc::send_PDU");
- PDU_Queue **pq = &m_queue_out;
+ yaz_log(m_p->log, "PDU_Assoc::send_PDU");
+ PDU_Assoc_priv::PDU_Queue **pq = &m_p->queue_out;
int is_idle = (*pq ? 0 : 1);
-
- if (!m_cs)
+
+ if (!m_p->cs)
{
- logf (m_log, "Yaz_PDU_Assoc::send_PDU failed, m_cs == 0");
+ yaz_log(m_p->log, "PDU_Assoc::send_PDU failed, cs == 0");
return -1;
}
while (*pq)
pq = &(*pq)->m_next;
- *pq = new PDU_Queue(buf, len);
+ *pq = new PDU_Assoc_priv::PDU_Queue(buf, len);
if (is_idle)
- return flush_PDU ();
+ return flush_PDU();
else
- logf (m_log, "Yaz_PDU_Assoc::cannot send_PDU fd=%d",
- cs_fileno(m_cs));
+ yaz_log(m_p->log, "PDU_Assoc::cannot send_PDU fd=%d",
+ cs_fileno(m_p->cs));
return 0;
}
-COMSTACK Yaz_PDU_Assoc::comstack()
+COMSTACK PDU_Assoc_priv::comstack(const char *type_and_host, void **vp)
{
- if (!m_cs)
- {
- CS_TYPE cs_type = tcpip_type;
- m_cs = cs_create (cs_type, 0, PROTO_Z3950);
- }
- return m_cs;
+ return cs_create_host(type_and_host, 2, vp);
}
-void Yaz_PDU_Assoc::listen(IYaz_PDU_Observer *observer,
- const char *addr)
+int PDU_Assoc::listen(IPDU_Observer *observer, const char *addr)
{
- close();
- void *ap;
- COMSTACK cs = comstack();
+ if (*addr == '\0')
+ {
+ m_p->m_socketObservable->deleteObserver(this);
+ m_p->state = PDU_Assoc_priv::Closed;
+ if (m_p->cs)
+ {
+ yaz_log(m_p->log, "PDU_Assoc::close fd=%d", cs_fileno(m_p->cs));
+ cs_close(m_p->cs);
+ }
+ m_p->cs = 0;
+ while (m_p->queue_out)
+ {
+ PDU_Assoc_priv::PDU_Queue *q_this = m_p->queue_out;
+ m_p->queue_out = m_p->queue_out->m_next;
+ delete q_this;
+ }
+ xfree(m_p->input_buf);
+ m_p->input_buf = 0;
+ m_p->input_len = 0;
+
+ return 0;
+ }
+
+ shutdown();
- logf (m_log, "Yaz_PDU_Assoc::listen %s", addr);
m_PDU_Observer = observer;
- if (!cs)
- return;
- ap = cs_straddr (cs, addr);
- if (!ap)
- return;
- if (cs_bind(cs, ap, CS_SERVER) < 0)
- return;
- m_socketObservable->addObserver(cs_fileno(cs), this);
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT);
- logf (m_log, "Yaz_PDU_Assoc::listen ok fd=%d", cs_fileno(cs));
- m_state = Listen;
+ void *ap;
+ m_p->cs = m_p->comstack(addr, &ap);
+
+ if (!m_p->cs)
+ return -1;
+
+ if (m_p->cert_fname)
+ cs_set_ssl_certificate_file(m_p->cs, m_p->cert_fname);
+
+ if (cs_bind(m_p->cs, ap, CS_SERVER) < 0)
+ return -2;
+
+ int fd = cs_fileno(m_p->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_p->m_socketObservable->addObserver(fd, this);
+ yaz_log(m_p->log, "maskObserver 9");
+ m_p->m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
+ SOCKET_OBSERVE_EXCEPT);
+ yaz_log(m_p->log, "PDU_Assoc::listen ok fd=%d", fd);
+ m_p->state = PDU_Assoc_priv::Listen;
+ return 0;
}
-void Yaz_PDU_Assoc::idleTime(int idleTime)
+COMSTACK PDU_Assoc::get_comstack()
{
- m_idleTime = idleTime;
- logf (m_log, "Yaz_PDU_Assoc::idleTime(%d)", idleTime);
- m_socketObservable->timeoutObserver(this, m_idleTime);
+ return m_p->cs;
}
-void Yaz_PDU_Assoc::connect(IYaz_PDU_Observer *observer,
- const char *addr)
+void PDU_Assoc::idleTime(int idleTime)
{
- logf (m_log, "Yaz_PDU_Assoc::connect %s", addr);
- close();
- m_PDU_Observer = observer;
- COMSTACK cs = comstack();
- void *ap = cs_straddr (cs, addr);
- if (!ap)
- {
- logf (m_log, "cs_straddr failed");
- return;
- }
- int res = cs_connect (cs, ap);
- logf (m_log, "Yaz_PDU_Assoc::connect fd=%d res=%d", cs_fileno(cs), res);
- m_socketObservable->addObserver(cs_fileno(cs), this);
- m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT|
- YAZ_SOCKET_OBSERVE_WRITE);
- if (res >= 0)
- m_state = Connecting;
- // if res < 0, then cs_connect failed immediately -> m_state is Closed..
+ m_p->idleTime = idleTime;
+ yaz_log(m_p->log, "PDU_Assoc::idleTime(%d)", idleTime);
+ m_p->m_socketObservable->timeoutObserver(this, m_p->idleTime);
}
-void Yaz_PDU_Assoc::socket(IYaz_PDU_Observer *observer, int fd)
+int PDU_Assoc::connect(IPDU_Observer *observer, const char *addr)
{
- close();
+ yaz_log(m_p->log, "PDU_Assoc::connect %s", addr);
+ shutdown();
m_PDU_Observer = observer;
- if (fd >= 0)
- {
- CS_TYPE cs_type = tcpip_type;
- m_cs = cs_createbysocket(fd, cs_type, 0, PROTO_Z3950);
- m_state = Ready;
- m_socketObservable->addObserver(fd, this);
- m_socketObservable->maskObserver(this,
- YAZ_SOCKET_OBSERVE_READ|
- YAZ_SOCKET_OBSERVE_EXCEPT);
- m_socketObservable->timeoutObserver(this, m_idleTime);
+ void *ap;
+ m_p->cs = m_p->comstack(addr, &ap);
+ if (!m_p->cs)
+ return -1;
+ int res = cs_connect(m_p->cs, ap);
+ yaz_log(m_p->log, "PDU_Assoc::connect fd=%d res=%d", cs_fileno(m_p->cs),
+ res);
+ m_p->m_socketObservable->addObserver(cs_fileno(m_p->cs), this);
+
+ if (res == 0)
+ { // Connect complete
+ m_p->state = PDU_Assoc_priv::Connecting;
+ unsigned mask = SOCKET_OBSERVE_EXCEPT;
+ mask |= SOCKET_OBSERVE_WRITE;
+ mask |= SOCKET_OBSERVE_READ;
+ yaz_log(m_p->log, "maskObserver 11");
+ m_p->m_socketObservable->maskObserver(this, mask);
+ }
+ else if (res > 0)
+ { // Connect pending
+ m_p->state = PDU_Assoc_priv::Connecting;
+ unsigned mask = SOCKET_OBSERVE_EXCEPT;
+ if (m_p->cs->io_pending & CS_WANT_WRITE)
+ mask |= SOCKET_OBSERVE_WRITE;
+ if (m_p->cs->io_pending & CS_WANT_READ)
+ mask |= SOCKET_OBSERVE_READ;
+ yaz_log(m_p->log, "maskObserver 11");
+ m_p->m_socketObservable->maskObserver(this, mask);
+ }
+ else
+ { // Connect failed immediately
+ // Since m_state is Closed we can distinguish this case from
+ // normal connect in socketNotify handler
+ yaz_log(m_p->log, "maskObserver 12");
+ m_p->m_socketObservable->maskObserver(this, SOCKET_OBSERVE_WRITE|
+ SOCKET_OBSERVE_EXCEPT);
}
+ return 0;
}
-#if 1
- // 1 = single-threaded
- // 0 = multi-threaded
-
// Single-threaded... Only useful for non-blocking handlers
-void Yaz_PDU_Assoc::childNotify(int fd)
+void PDU_Assoc::childNotify(COMSTACK cs)
{
- // Clone PDU Observable (keep socket manager)
- IYaz_PDU_Observable *new_observable = clone();
+ PDU_Assoc *new_observable =
+ new PDU_Assoc(m_p->m_socketObservable, cs);
// Clone PDU Observer
- IYaz_PDU_Observer *observer = m_PDU_Observer->clone(new_observable, fd);
+ new_observable->m_PDU_Observer = m_PDU_Observer->sessionNotify
+ (new_observable, cs_fileno(cs));
- // Attach new socket to it
- new_observable->socket(observer, fd);
+ if (!new_observable->m_PDU_Observer)
+ {
+ new_observable->shutdown();
+ delete new_observable;
+ return;
+ }
+ new_observable->m_p->pdu_next = m_p->pdu_children;
+ m_p->pdu_children = new_observable;
+ new_observable->m_p->pdu_parent = this;
}
-#else
-
-#include <yaz++/yaz-socket-manager.h>
-#ifdef WIN32
-#include <process.h>
-#else
-#include <pthread.h>
-#endif
-
-#ifdef WIN32
-void __cdecl
-#else
-void *
-#endif
- events(void *p)
+const char*PDU_Assoc::getpeername()
{
- Yaz_SocketManager *s = (Yaz_SocketManager *) p;
-
- logf (LOG_LOG, "thread started");
- while (s->processEvent() > 0)
- ;
- logf (LOG_LOG, "thread finished");
-#ifdef WIN32
-#else
- return 0;
-#endif
+ if (!m_p->cs)
+ return 0;
+ return cs_addrstr(m_p->cs);
}
-void Yaz_PDU_Assoc::childNotify(int fd)
+void PDU_Assoc::set_cert_fname(const char *fname)
{
- Yaz_SocketManager *socket_observable = new Yaz_SocketManager;
- Yaz_PDU_Assoc *new_observable = new Yaz_PDU_Assoc (socket_observable);
-
- /// Clone PDU Observer
- IYaz_PDU_Observer *observer = m_PDU_Observer->clone(new_observable, fd);
-
- /// Attach new socket to it
- new_observable->socket(observer, fd);
-
-#ifdef WIN32
- long t_id;
- t_id = _beginthread (events, 0, socket_observable);
- if (t_id == -1)
- {
- logf (LOG_FATAL|LOG_ERRNO, "_beginthread failed");
- exit (1);
- }
-#else
- pthread_t type;
-
- int id = pthread_create (&type, 0, events, socket_observable);
- logf (LOG_LOG, "pthread_create returned id=%d", id);
-#endif
+ xfree(m_p->cert_fname);
+ m_p->cert_fname = 0;
+ if (fname)
+ m_p->cert_fname = xstrdup(fname);
}
-// Threads end
-#endif
+
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+
projects / yazpp-moved-to-github.git / blobdiff