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