src/yaz-pdu-assoc.cpp

   1 /*
   2  * Copyright (c) 1998-2003, Index Data.
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: yaz-pdu-assoc.cpp,v 1.37 2003-10-23 11:45:08 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 <yaz++/pdu-assoc.h>
  14
  15
  16 void Yaz_PDU_Assoc::init(IYazSocketObservable *socketObservable)
  17 {
  18     m_state = Closed;
  19     m_cs = 0;
  20     m_socketObservable = socketObservable;
  21     m_PDU_Observer = 0;
  22     m_queue_out = 0;
  23     m_queue_in = 0;
  24     m_input_buf = 0;
  25     m_input_len = 0;
  26     m_children = 0;
  27     m_parent = 0;
  28     m_next = 0;
  29     m_destroyed = 0;
  30     m_idleTime = 0;
  31     m_log = LOG_DEBUG;
  32 }
  33
  34 Yaz_PDU_Assoc::Yaz_PDU_Assoc(IYazSocketObservable *socketObservable)
  35 {
  36     init (socketObservable);
  37 }
  38
  39 Yaz_PDU_Assoc::Yaz_PDU_Assoc(IYazSocketObservable *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 |= YAZ_SOCKET_OBSERVE_WRITE;
  47     if (cs->io_pending & CS_WANT_READ)
  48         mask |= YAZ_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 |YAZ_SOCKET_OBSERVE_EXCEPT);
  65     }
  66 }
  67
  68
  69 IYaz_PDU_Observable *Yaz_PDU_Assoc::clone()
  70 {
  71     Yaz_PDU_Assoc *copy = new Yaz_PDU_Assoc(m_socketObservable);
  72     return copy;
  73 }
  74
  75 void Yaz_PDU_Assoc::socketNotify(int event)
  76 {
  77     yaz_log (m_log, "Yaz_PDU_Assoc::socketNotify p=%p state=%d event = %d",
  78           this, m_state, event);
  79     if (event & YAZ_SOCKET_OBSERVE_EXCEPT)
  80     {
  81         close();
  82         m_PDU_Observer->failNotify();
  83         return;
  84     }
  85     else if (event & YAZ_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, "Yaz_PDU_Assoc::cs_accept failed");
  96             m_cs = 0;
  97             close();
  98             m_PDU_Observer->failNotify();
  99         }
 100         else
 101         {
 102             unsigned mask = 0;
 103             if (m_cs->io_pending & CS_WANT_WRITE)
 104                 mask |= YAZ_SOCKET_OBSERVE_WRITE;
 105             if (m_cs->io_pending & CS_WANT_READ)
 106                 mask |= YAZ_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|YAZ_SOCKET_OBSERVE_EXCEPT);
 117             }
 118         }
 119         break;
 120     case Connecting:
 121         if (event & YAZ_SOCKET_OBSERVE_READ &&
 122             event & YAZ_SOCKET_OBSERVE_WRITE)
 123         {
 124             // For Unix: if both read and write is set, then connect failed.
 125             close();
 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 = YAZ_SOCKET_OBSERVE_EXCEPT;
 135                 if (m_cs->io_pending & CS_WANT_WRITE)
 136                     mask |= YAZ_SOCKET_OBSERVE_WRITE;
 137                 if (m_cs->io_pending & CS_WANT_READ)
 138                     mask |= YAZ_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 & YAZ_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(LOG_FATAL|LOG_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 & (YAZ_SOCKET_OBSERVE_READ|YAZ_SOCKET_OBSERVE_WRITE))
 179             flush_PDU();
 180         break;
 181     case Ready:
 182         if (event & (YAZ_SOCKET_OBSERVE_READ|YAZ_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 = YAZ_SOCKET_OBSERVE_EXCEPT;
 190                     if (m_cs->io_pending & CS_WANT_WRITE)
 191                         mask |= YAZ_SOCKET_OBSERVE_WRITE;
 192                     if (m_cs->io_pending & CS_WANT_READ)
 193                         mask |= YAZ_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, "Yaz_PDU_Assoc::Connection closed by peer");
 201                     close();
 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                                                  YAZ_SOCKET_OBSERVE_EXCEPT|
 230                                                  YAZ_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         close();
 237         m_PDU_Observer->failNotify();
 238         break;
 239     default:
 240         yaz_log (m_log, "Unknown state=%d event was %d", m_state, event);
 241         close();
 242         m_PDU_Observer->failNotify();
 243     }
 244 }
 245
 246 void Yaz_PDU_Assoc::close()
 247 {
 248     Yaz_PDU_Assoc *ch;
 249     for (ch = m_children; ch; ch = ch->m_next)
 250         ch->close();
 251
 252     m_socketObservable->deleteObserver(this);
 253     m_state = Closed;
 254     if (m_cs)
 255     {
 256         yaz_log (m_log, "Yaz_PDU_Assoc::close fd=%d", cs_fileno(m_cs));
 257         cs_close (m_cs);
 258     }
 259     m_cs = 0;
 260     while (m_queue_out)
 261     {
 262         PDU_Queue *q_this = m_queue_out;
 263         m_queue_out = m_queue_out->m_next;
 264         delete q_this;
 265     }
 266     xfree (m_input_buf);
 267     m_input_buf = 0;
 268     m_input_len = 0;
 269 }
 270
 271 void Yaz_PDU_Assoc::destroy()
 272 {
 273     close();
 274
 275     if (m_destroyed)
 276         *m_destroyed = 1;
 277     Yaz_PDU_Assoc **c;
 278
 279     // delete from parent's child list (if any)
 280     if (m_parent)
 281     {
 282         c = &m_parent->m_children;
 283         while (*c != this)
 284         {
 285             assert (*c);
 286             c = &(*c)->m_next;
 287         }
 288         *c = (*c)->m_next;
 289     }
 290     // delete all children ...
 291     c = &m_children;
 292     while (*c)
 293     {
 294         Yaz_PDU_Assoc *here = *c;
 295         *c = (*c)->m_next;
 296         here->m_parent = 0;
 297         delete here;
 298     }
 299     yaz_log (m_log, "Yaz_PDU_Assoc::destroy this=%p", this);
 300 }
 301
 302 Yaz_PDU_Assoc::PDU_Queue::PDU_Queue(const char *buf, int len)
 303 {
 304     m_buf = (char *) xmalloc (len);
 305     memcpy (m_buf, buf, len);
 306     m_len = len;
 307     m_next = 0;
 308 }
 309
 310 Yaz_PDU_Assoc::PDU_Queue::~PDU_Queue()
 311 {
 312     xfree (m_buf);
 313 }
 314
 315 int Yaz_PDU_Assoc::flush_PDU()
 316 {
 317     int r;
 318
 319     if (m_state != Ready && m_state != Writing)
 320     {
 321         yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU, not ready");
 322         return 1;
 323     }
 324     PDU_Queue *q = m_queue_out;
 325     if (!q)
 326     {
 327         m_state = Ready;
 328         yaz_log (m_log, "YAZ_PDU_Assoc::flush_PDU queue empty");
 329         yaz_log(m_log, "maskObserver 6");
 330         m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
 331                                          YAZ_SOCKET_OBSERVE_WRITE|
 332                                          YAZ_SOCKET_OBSERVE_EXCEPT);
 333         return 0;
 334     }
 335     r = cs_put (m_cs, q->m_buf, q->m_len);
 336     if (r < 0)
 337     {
 338         yaz_log (m_log, "Yaz_PDU_Assoc::flush_PDU cs_put failed");
 339         close();
 340         m_PDU_Observer->failNotify();
 341         return r;
 342     }
 343     if (r == 1)
 344     {
 345         unsigned mask = YAZ_SOCKET_OBSERVE_EXCEPT;
 346         m_state = Writing;
 347         if (m_cs->io_pending & CS_WANT_WRITE)
 348             mask |= YAZ_SOCKET_OBSERVE_WRITE;
 349         if (m_cs->io_pending & CS_WANT_READ)
 350             mask |= YAZ_SOCKET_OBSERVE_READ;
 351
 352         mask |= YAZ_SOCKET_OBSERVE_WRITE;
 353         yaz_log(m_log, "maskObserver 7");
 354         m_socketObservable->maskObserver(this, mask);
 355         yaz_log (m_log, "Yaz_PDU_Assoc::flush_PDU cs_put %d bytes fd=%d (inc)",
 356                  q->m_len, cs_fileno(m_cs));
 357         return r;
 358     }
 359     yaz_log (m_log, "Yaz_PDU_Assoc::flush_PDU cs_put %d bytes", q->m_len);
 360     // whole packet sent... delete this and proceed to next ...
 361     m_queue_out = q->m_next;
 362     delete q;
 363     // don't select on write if queue is empty ...
 364     if (!m_queue_out)
 365     {
 366         m_state = Ready;
 367         yaz_log(m_log, "maskObserver 8");
 368         m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_READ|
 369                                          YAZ_SOCKET_OBSERVE_EXCEPT);
 370     }
 371     return r;
 372 }
 373
 374 int Yaz_PDU_Assoc::send_PDU(const char *buf, int len)
 375 {
 376     yaz_log (m_log, "Yaz_PDU_Assoc::send_PDU");
 377     PDU_Queue **pq = &m_queue_out;
 378     int is_idle = (*pq ? 0 : 1);
 379
 380     if (!m_cs)
 381     {
 382         yaz_log (m_log, "Yaz_PDU_Assoc::send_PDU failed, m_cs == 0");
 383         return -1;
 384     }
 385     while (*pq)
 386         pq = &(*pq)->m_next;
 387     *pq = new PDU_Queue(buf, len);
 388     if (is_idle)
 389         return flush_PDU ();
 390     else
 391         yaz_log (m_log, "Yaz_PDU_Assoc::cannot send_PDU fd=%d",
 392                  cs_fileno(m_cs));
 393     return 0;
 394 }
 395
 396 COMSTACK Yaz_PDU_Assoc::comstack(const char *type_and_host, void **vp)
 397 {
 398     return cs_create_host(type_and_host, 2, vp);
 399 }
 400
 401 int Yaz_PDU_Assoc::listen(IYaz_PDU_Observer *observer,
 402                           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, YAZ_SOCKET_OBSERVE_READ|
 417                                      YAZ_SOCKET_OBSERVE_EXCEPT);
 418     yaz_log (m_log, "Yaz_PDU_Assoc::listen ok fd=%d", cs_fileno(m_cs));
 419     m_state = Listen;
 420     return 0;
 421 }
 422
 423 void Yaz_PDU_Assoc::idleTime(int idleTime)
 424 {
 425     m_idleTime = idleTime;
 426     yaz_log (m_log, "Yaz_PDU_Assoc::idleTime(%d)", idleTime);
 427     m_socketObservable->timeoutObserver(this, m_idleTime);
 428 }
 429
 430 int Yaz_PDU_Assoc::connect(IYaz_PDU_Observer *observer,
 431                             const char *addr)
 432 {
 433     yaz_log (m_log, "Yaz_PDU_Assoc::connect %s", addr);
 434     close();
 435     m_PDU_Observer = observer;
 436     void *ap;
 437     m_cs = comstack(addr, &ap);
 438     if (!m_cs)
 439         return -1;
 440     int res = cs_connect (m_cs, ap);
 441     yaz_log (m_log, "Yaz_PDU_Assoc::connect fd=%d res=%d", cs_fileno(m_cs),
 442              res);
 443     m_socketObservable->addObserver(cs_fileno(m_cs), this);
 444
 445     if (res == 0)
 446     {   // Connect complete
 447         m_state = Connecting;
 448         unsigned mask = YAZ_SOCKET_OBSERVE_EXCEPT;
 449         mask |= YAZ_SOCKET_OBSERVE_WRITE;
 450         mask |= YAZ_SOCKET_OBSERVE_READ;
 451         yaz_log(m_log, "maskObserver 11");
 452         m_socketObservable->maskObserver(this, mask);
 453     }
 454     else if (res > 0)
 455     {   // Connect pending
 456         m_state = Connecting;
 457         unsigned mask = YAZ_SOCKET_OBSERVE_EXCEPT;
 458         if (m_cs->io_pending & CS_WANT_WRITE)
 459             mask |= YAZ_SOCKET_OBSERVE_WRITE;
 460         if (m_cs->io_pending & CS_WANT_READ)
 461             mask |= YAZ_SOCKET_OBSERVE_READ;
 462         yaz_log(m_log, "maskObserver 11");
 463         m_socketObservable->maskObserver(this, mask);
 464     }
 465     else
 466     {   // Connect failed immediately
 467         // Since m_state is Closed we can distinguish this case from
 468         // normal connect in socketNotify handler
 469         yaz_log(m_log, "maskObserver 12");
 470         m_socketObservable->maskObserver(this, YAZ_SOCKET_OBSERVE_WRITE|
 471                                          YAZ_SOCKET_OBSERVE_EXCEPT);
 472     }
 473     return 0;
 474 }
 475
 476 // Single-threaded... Only useful for non-blocking handlers
 477 void Yaz_PDU_Assoc::childNotify(COMSTACK cs)
 478 {
 479     Yaz_PDU_Assoc *new_observable =
 480         new Yaz_PDU_Assoc (m_socketObservable, cs);
 481
 482     new_observable->m_next = m_children;
 483     m_children = new_observable;
 484     new_observable->m_parent = this;
 485
 486     // Clone PDU Observer
 487     new_observable->m_PDU_Observer = m_PDU_Observer->sessionNotify
 488         (new_observable, cs_fileno(cs));
 489 }
 490
 491 const char*Yaz_PDU_Assoc::getpeername()
 492 {
 493     return cs_addrstr(m_cs);
 494 }