src/yaz-pdu-assoc.cpp

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