if PDU_Assoc::sessionNotify returns 0; the accept will fail neatly
[yazpp-moved-to-github.git] / src / yaz-pdu-assoc.cpp
1 /*
2  * Copyright (c) 1998-2004, Index Data.
3  * See the file LICENSE for details.
4  * 
5  * $Id: yaz-pdu-assoc.cpp,v 1.46 2006-03-30 11:58:00 adam Exp $
6  */
7
8 #include <assert.h>
9 #include <string.h>
10 #include <yaz/log.h>
11 #include <yaz/tcpip.h>
12
13 #include <yazpp/pdu-assoc.h>
14
15 using namespace yazpp_1;
16
17 void PDU_Assoc::init(ISocketObservable *socketObservable)
18 {
19     m_state = Closed;
20     m_cs = 0;
21     m_socketObservable = socketObservable;
22     m_PDU_Observer = 0;
23     m_queue_out = 0;
24     m_queue_in = 0;
25     m_input_buf = 0;
26     m_input_len = 0;
27     m_children = 0;
28     m_parent = 0;
29     m_next = 0;
30     m_destroyed = 0;
31     m_idleTime = 0;
32     m_log = YLOG_DEBUG;
33 }
34
35 PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable)
36 {
37     init (socketObservable);
38 }
39
40 PDU_Assoc::PDU_Assoc(ISocketObservable *socketObservable,
41                      COMSTACK cs)
42 {
43     init(socketObservable);
44     m_cs = cs;
45     unsigned mask = 0;
46     if (cs->io_pending & CS_WANT_WRITE)
47         mask |= SOCKET_OBSERVE_WRITE;
48     if (cs->io_pending & CS_WANT_READ)
49         mask |= SOCKET_OBSERVE_READ;
50     m_socketObservable->addObserver(cs_fileno(cs), this);
51     if (!mask)
52     {
53         yaz_log (m_log, "new PDU_Assoc. Ready");
54         m_state = Ready;
55         flush_PDU();
56     }
57     else
58     {
59         yaz_log (m_log, "new PDU_Assoc. Accepting");
60         // assume comstack is accepting...
61         m_state = Accepting;
62         m_socketObservable->addObserver(cs_fileno(cs), this);
63         yaz_log(m_log, "maskObserver 1");
64         m_socketObservable->maskObserver(this,
65                                          mask |SOCKET_OBSERVE_EXCEPT);
66     }
67 }
68
69
70 IPDU_Observable *PDU_Assoc::clone()
71 {
72     PDU_Assoc *copy = new PDU_Assoc(m_socketObservable);
73     return copy;
74 }
75
76 void PDU_Assoc::socketNotify(int event)
77 {
78     yaz_log (m_log, "PDU_Assoc::socketNotify p=%p state=%d event = %d",
79           this, m_state, event);
80     if (event & SOCKET_OBSERVE_EXCEPT)
81     {
82         close();
83         m_PDU_Observer->failNotify();
84         return;
85     }
86     else if (event & SOCKET_OBSERVE_TIMEOUT)
87     {
88         m_PDU_Observer->timeoutNotify();
89         return;
90     }
91     switch (m_state)
92     {
93     case Accepting:
94         if (!cs_accept (m_cs))
95         {
96             yaz_log (m_log, "PDU_Assoc::cs_accept failed");
97             m_cs = 0;
98             close();
99             m_PDU_Observer->failNotify();
100         }
101         else
102         {
103             unsigned mask = 0;
104             if (m_cs->io_pending & CS_WANT_WRITE)
105                 mask |= SOCKET_OBSERVE_WRITE;
106             if (m_cs->io_pending & CS_WANT_READ)
107                 mask |= SOCKET_OBSERVE_READ;
108             if (!mask)
109             {   // accept is complete. turn to ready state and write if needed
110                 m_state = Ready;
111                 flush_PDU();
112             }
113             else  
114             {   // accept still incomplete.
115                 yaz_log(m_log, "maskObserver 2");
116                 m_socketObservable->maskObserver(this,
117                                              mask|SOCKET_OBSERVE_EXCEPT);
118             }
119         }
120         break;
121     case Connecting:
122         if (event & SOCKET_OBSERVE_READ && 
123             event & SOCKET_OBSERVE_WRITE)
124         {
125             // For Unix: if both read and write is set, then connect failed.
126             close();
127             m_PDU_Observer->failNotify();
128         }
129         else
130         {
131             yaz_log (m_log, "cs_rcvconnect");
132             int res = cs_rcvconnect (m_cs);
133             if (res == 1)
134             {
135                 unsigned mask = SOCKET_OBSERVE_EXCEPT;
136                 if (m_cs->io_pending & CS_WANT_WRITE)
137                     mask |= SOCKET_OBSERVE_WRITE;
138                 if (m_cs->io_pending & CS_WANT_READ)
139                     mask |= SOCKET_OBSERVE_READ;
140                 yaz_log(m_log, "maskObserver 3");
141                 m_socketObservable->maskObserver(this, mask);
142             }
143             else
144             {
145                 m_state = Ready;
146                 if (m_PDU_Observer)
147                     m_PDU_Observer->connectNotify();
148                 flush_PDU();
149             }
150         }
151         break;
152     case Listen:
153         if (event & SOCKET_OBSERVE_READ)
154         {
155             int res;
156             COMSTACK new_line;
157             
158             if ((res = cs_listen(m_cs, 0, 0)) == 1)
159                 return;
160             if (res < 0)
161             {
162                 yaz_log(YLOG_FATAL|YLOG_ERRNO, "cs_listen failed");
163                 return;
164             }
165             if (!(new_line = cs_accept(m_cs)))
166                 return;
167             /* 1. create socket-manager 
168                2. create pdu-assoc
169                3. create top-level object
170                     setup observer for child fileid in pdu-assoc
171                4. start thread
172             */
173             yaz_log (m_log, "new session: parent fd=%d child fd=%d",
174                      cs_fileno(m_cs), cs_fileno(new_line));
175             childNotify (new_line);
176         }
177         break;
178     case Writing:
179         if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
180             flush_PDU();
181         break;
182     case Ready:
183         if (event & (SOCKET_OBSERVE_READ|SOCKET_OBSERVE_WRITE))
184         {
185             do
186             {
187                 int res = cs_get (m_cs, &m_input_buf, &m_input_len);
188                 if (res == 1)
189                 {
190                     unsigned mask = SOCKET_OBSERVE_EXCEPT;
191                     if (m_cs->io_pending & CS_WANT_WRITE)
192                         mask |= SOCKET_OBSERVE_WRITE;
193                     if (m_cs->io_pending & CS_WANT_READ)
194                         mask |= SOCKET_OBSERVE_READ;
195                     yaz_log(m_log, "maskObserver 4");
196                     m_socketObservable->maskObserver(this, mask);
197                     return;
198                 }
199                 else if (res <= 0)
200                 {
201                     yaz_log (m_log, "PDU_Assoc::Connection closed by peer");
202                     close();
203                     if (m_PDU_Observer)
204                         m_PDU_Observer->failNotify(); // problem here..
205                     return;
206                 }
207                 // lock it, so we know if recv_PDU deletes it.
208                 int destroyed = 0;
209                 m_destroyed = &destroyed;
210
211                 if (!m_PDU_Observer)
212                     return;
213 #if 0
214                 PDU_Queue **pq = &m_queue_in;
215                 while (*pq)
216                     pq = &(*pq)->m_next;
217                 
218                 *pq = new PDU_Queue(m_input_buf, res);
219 #else
220                 m_PDU_Observer->recv_PDU(m_input_buf, res);
221 #endif
222                 if (destroyed)   // it really was destroyed, return now.
223                     return;
224                 m_destroyed = 0;
225             } while (m_cs && cs_more (m_cs));
226             if (m_cs && m_state == Ready)
227             {
228                 yaz_log(m_log, "maskObserver 5");
229                 m_socketObservable->maskObserver(this,
230                                                  SOCKET_OBSERVE_EXCEPT|
231                                                  SOCKET_OBSERVE_READ);
232             }
233         }
234         break;
235     case Closed:
236         yaz_log (m_log, "CLOSING state=%d event was %d", m_state, event);
237         close();
238         m_PDU_Observer->failNotify();
239         break;
240     default:
241         yaz_log (m_log, "Unknown state=%d event was %d", m_state, event);
242         close();
243         m_PDU_Observer->failNotify();
244     }
245 }
246
247 void PDU_Assoc::close()
248 {
249     PDU_Assoc *ch;
250     for (ch = m_children; ch; ch = ch->m_next)
251         ch->close();
252
253     m_socketObservable->deleteObserver(this);
254     m_state = Closed;
255     if (m_cs)
256     {
257         yaz_log (m_log, "PDU_Assoc::close fd=%d", cs_fileno(m_cs));
258         cs_close (m_cs);
259     }
260     m_cs = 0;
261     while (m_queue_out)
262     {
263         PDU_Queue *q_this = m_queue_out;
264         m_queue_out = m_queue_out->m_next;
265         delete q_this;
266     }
267     xfree (m_input_buf);
268     m_input_buf = 0;
269     m_input_len = 0;
270 }
271
272 void PDU_Assoc::destroy()
273 {
274     close();
275
276     if (m_destroyed)
277         *m_destroyed = 1;
278     PDU_Assoc **c;
279
280     // delete from parent's child list (if any)
281     if (m_parent)
282     {
283         c = &m_parent->m_children;
284         while (*c != this)
285         {
286             assert (*c);
287             c = &(*c)->m_next;
288         }
289         *c = (*c)->m_next;
290     }
291     // delete all children ...
292     c = &m_children;
293     while (*c)
294     {
295         PDU_Assoc *here = *c;
296         *c = (*c)->m_next;
297         here->m_parent = 0;
298         delete here;
299     }
300     yaz_log (m_log, "PDU_Assoc::destroy this=%p", this);
301 }
302
303 PDU_Assoc::PDU_Queue::PDU_Queue(const char *buf, int len)
304 {
305     m_buf = (char *) xmalloc (len);
306     memcpy (m_buf, buf, len);
307     m_len = len;
308     m_next = 0;
309 }
310
311 PDU_Assoc::PDU_Queue::~PDU_Queue()
312 {
313     xfree (m_buf);
314 }
315
316 int PDU_Assoc::flush_PDU()
317 {
318     int r;
319     
320     if (m_state != Ready && m_state != Writing)
321     {
322         yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU, not ready");
323         return 1;
324     }
325     PDU_Queue *q = m_queue_out;
326     if (!q)
327     {
328         m_state = Ready;
329         yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU queue empty");
330         yaz_log(m_log, "maskObserver 6");
331         m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
332                                          SOCKET_OBSERVE_WRITE|
333                                          SOCKET_OBSERVE_EXCEPT);
334         return 0;
335     }
336     r = cs_put (m_cs, q->m_buf, q->m_len);
337     if (r < 0)
338     {
339         yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put failed");
340         close();
341         m_PDU_Observer->failNotify();
342         return r;
343     }
344     if (r == 1)
345     {
346         unsigned mask = SOCKET_OBSERVE_EXCEPT;
347         m_state = Writing;
348         if (m_cs->io_pending & CS_WANT_WRITE)
349             mask |= SOCKET_OBSERVE_WRITE;
350         if (m_cs->io_pending & CS_WANT_READ)
351             mask |= SOCKET_OBSERVE_READ;
352
353         mask |= SOCKET_OBSERVE_WRITE;
354         yaz_log(m_log, "maskObserver 7");
355         m_socketObservable->maskObserver(this, mask);
356         yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put %d bytes fd=%d (inc)",
357                  q->m_len, cs_fileno(m_cs));
358         return r;
359     } 
360     yaz_log (m_log, "PDU_Assoc::flush_PDU cs_put %d bytes", q->m_len);
361     // whole packet sent... delete this and proceed to next ...
362     m_queue_out = q->m_next;
363     delete q;
364     // don't select on write if queue is empty ...
365     if (!m_queue_out)
366     {
367         m_state = Ready;
368         yaz_log(m_log, "maskObserver 8");
369         m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
370                                          SOCKET_OBSERVE_EXCEPT);
371     }
372     return r;
373 }
374
375 int PDU_Assoc::send_PDU(const char *buf, int len)
376 {
377     yaz_log (m_log, "PDU_Assoc::send_PDU");
378     PDU_Queue **pq = &m_queue_out;
379     int is_idle = (*pq ? 0 : 1);
380     
381     if (!m_cs)
382     {
383         yaz_log (m_log, "PDU_Assoc::send_PDU failed, m_cs == 0");
384         return -1;
385     }
386     while (*pq)
387         pq = &(*pq)->m_next;
388     *pq = new PDU_Queue(buf, len);
389     if (is_idle)
390         return flush_PDU ();
391     else
392         yaz_log (m_log, "PDU_Assoc::cannot send_PDU fd=%d",
393                  cs_fileno(m_cs));
394     return 0;
395 }
396
397 COMSTACK PDU_Assoc::comstack(const char *type_and_host, void **vp)
398 {
399     return cs_create_host(type_and_host, 2, vp);
400 }
401
402 int PDU_Assoc::listen(IPDU_Observer *observer, const char *addr)
403 {
404     close();
405
406     m_PDU_Observer = observer;
407     void *ap;
408     m_cs = comstack(addr, &ap);
409
410     if (!m_cs)
411         return -1;
412     if (cs_bind(m_cs, ap, CS_SERVER) < 0)
413         return -2;
414     m_socketObservable->addObserver(cs_fileno(m_cs), this);
415     yaz_log(m_log, "maskObserver 9");
416     m_socketObservable->maskObserver(this, SOCKET_OBSERVE_READ|
417                                      SOCKET_OBSERVE_EXCEPT);
418     yaz_log (m_log, "PDU_Assoc::listen ok fd=%d", cs_fileno(m_cs));
419     m_state = Listen;
420     return 0;
421 }
422
423 void PDU_Assoc::idleTime(int idleTime)
424 {
425     m_idleTime = idleTime;
426     yaz_log (m_log, "PDU_Assoc::idleTime(%d)", idleTime);
427     m_socketObservable->timeoutObserver(this, m_idleTime);
428 }
429
430 int PDU_Assoc::connect(IPDU_Observer *observer, const char *addr)
431 {
432     yaz_log (m_log, "PDU_Assoc::connect %s", addr);
433     close();
434     m_PDU_Observer = observer;
435     void *ap;
436     m_cs = comstack(addr, &ap);
437     if (!m_cs)
438         return -1;
439     int res = cs_connect (m_cs, ap);
440     yaz_log (m_log, "PDU_Assoc::connect fd=%d res=%d", cs_fileno(m_cs),
441              res);
442     m_socketObservable->addObserver(cs_fileno(m_cs), this);
443
444     if (res == 0)
445     {   // Connect complete
446         m_state = Connecting;
447         unsigned mask = SOCKET_OBSERVE_EXCEPT;
448         mask |= SOCKET_OBSERVE_WRITE;
449         mask |= SOCKET_OBSERVE_READ;
450         yaz_log(m_log, "maskObserver 11");
451         m_socketObservable->maskObserver(this, mask);
452     }
453     else if (res > 0)
454     {   // Connect pending
455         m_state = Connecting;
456         unsigned mask = SOCKET_OBSERVE_EXCEPT;
457         if (m_cs->io_pending & CS_WANT_WRITE)
458             mask |= SOCKET_OBSERVE_WRITE;
459         if (m_cs->io_pending & CS_WANT_READ)
460             mask |= SOCKET_OBSERVE_READ;
461         yaz_log(m_log, "maskObserver 11");
462         m_socketObservable->maskObserver(this, mask);
463     }
464     else
465     {   // Connect failed immediately
466         // Since m_state is Closed we can distinguish this case from
467         // normal connect in socketNotify handler
468         yaz_log(m_log, "maskObserver 12");
469         m_socketObservable->maskObserver(this, SOCKET_OBSERVE_WRITE|
470                                          SOCKET_OBSERVE_EXCEPT);
471     }
472     return 0;
473 }
474
475 // Single-threaded... Only useful for non-blocking handlers
476 void PDU_Assoc::childNotify(COMSTACK cs)
477 {
478     PDU_Assoc *new_observable =
479         new PDU_Assoc (m_socketObservable, cs);
480     
481     // Clone PDU Observer
482     new_observable->m_PDU_Observer = m_PDU_Observer->sessionNotify
483         (new_observable, cs_fileno(cs));
484
485     if (!new_observable->m_PDU_Observer)
486     {
487         new_observable->close();
488         delete new_observable;
489         return;
490     }
491     new_observable->m_next = m_children;
492     m_children = new_observable;
493     new_observable->m_parent = this;
494 }
495
496 const char*PDU_Assoc::getpeername()
497 {
498     if (!m_cs)
499         return 0;
500     return cs_addrstr(m_cs);
501 }
502 /*
503  * Local variables:
504  * c-basic-offset: 4
505  * indent-tabs-mode: nil
506  * End:
507  * vim: shiftwidth=4 tabstop=8 expandtab
508  */
509