Fix memory leak for MARC record management.

[yaz-moved-to-github.git] / zoom / zoom-c.c

diff --git a/zoom/zoom-c.c b/zoom/zoom-c.c
index c87a035..96321be 100644 (file)
--- a/zoom/zoom-c.c
+++ b/zoom/zoom-c.c
@@ -1,5 +1,5 @@
 /*
- * $Id: zoom-c.c,v 1.17 2002-01-03 10:23:46 adam Exp $
+ * $Id: zoom-c.c,v 1.22 2002-01-24 19:33:09 adam Exp $
  *
  * ZOOM layer for C, connections, result sets, queries.
  */
@@ -32,7 +32,6 @@ static void ZOOM_Event_destroy (ZOOM_Event event)
 
 static void ZOOM_connection_put_event (ZOOM_connection c, ZOOM_Event event)
 {
-    // put in back of queue
     if (c->m_queue_back)
     {
        c->m_queue_back->prev = event;
@@ -50,7 +49,6 @@ static void ZOOM_connection_put_event (ZOOM_connection c, ZOOM_Event event)
 
 static ZOOM_Event ZOOM_connection_get_event(ZOOM_connection c)
 {
-    // get from front of queue
     ZOOM_Event event = c->m_queue_front;
     if (!event)
        return 0;
@@ -69,9 +67,21 @@ static ZOOM_Event ZOOM_connection_get_event(ZOOM_connection c)
 
 static void clear_error (ZOOM_connection c)
 {
-    c->error = ZOOM_ERROR_NONE;
-    xfree (c->addinfo);
-    c->addinfo = 0;
+
+    switch (c->error)
+    {
+    case ZOOM_ERROR_CONNECT:
+    case ZOOM_ERROR_MEMORY:
+    case ZOOM_ERROR_DECODE:
+    case ZOOM_ERROR_CONNECTION_LOST:
+    case ZOOM_ERROR_INIT:
+    case ZOOM_ERROR_INTERNAL:
+        break;
+    default:
+        c->error = ZOOM_ERROR_NONE;
+        xfree (c->addinfo);
+        c->addinfo = 0;
+    }
 }
 
 ZOOM_task ZOOM_connection_add_task (ZOOM_connection c, int which)
@@ -245,7 +255,9 @@ void ZOOM_connection_connect(ZOOM_connection c,
     ZOOM_options_set(c->options, "host", c->host_port);
 
     c->async = ZOOM_options_get_bool (c->options, "async", 0);
-    
+ 
+    c->error = ZOOM_ERROR_NONE;
+
     task = ZOOM_connection_add_task (c, ZOOM_TASK_CONNECT);
 
     if (!c->async)
@@ -404,6 +416,11 @@ void ZOOM_resultset_destroy(ZOOM_resultset r)
     yaz_log (LOG_DEBUG, "destroy r = %p count=%d", r, r->refcount);
     if (r->refcount == 0)
     {
+        ZOOM_record_cache rc;
+
+        for (rc = r->record_cache; rc; rc = rc->next)
+            if (rc->rec.wrbuf_marc)
+                wrbuf_free (rc->rec.wrbuf_marc, 1);
        if (r->connection)
        {
            /* remove ourselves from the resultsets in connection */
@@ -504,8 +521,11 @@ static int do_connect (ZOOM_connection c)
        if (ret >= 0)
        {
            c->state = STATE_CONNECTING; 
-           c->mask = ZOOM_SELECT_READ | ZOOM_SELECT_WRITE | 
-                ZOOM_SELECT_EXCEPT;
+            c->mask = ZOOM_SELECT_EXCEPT;
+            if (c->cs->io_pending & CS_WANT_WRITE)
+                c->mask += ZOOM_SELECT_WRITE;
+            if (c->cs->io_pending & CS_WANT_READ)
+                c->mask += ZOOM_SELECT_READ;
            return 1;
        }
     }
@@ -900,6 +920,7 @@ void *ZOOM_record_get (ZOOM_record rec, const char *type, size_t *len)
                default:
                    if (!rec->wrbuf_marc)
                        rec->wrbuf_marc = wrbuf_alloc();
+                    wrbuf_rewind (rec->wrbuf_marc);
                    if (marc_display_wrbuf (r->u.octet_aligned->buf,
                                        rec->wrbuf_marc, 0,
                                            r->u.octet_aligned->len) > 0)
@@ -923,8 +944,23 @@ void *ZOOM_record_get (ZOOM_record rec, const char *type, size_t *len)
     {
        if (npr->which == Z_NamePlusRecord_databaseRecord)
        {
-            *len = -1;
-           return (Z_External *) npr->u.databaseRecord;
+           Z_External *r = (Z_External *) npr->u.databaseRecord;
+           
+           if (r->which == Z_External_sutrs)
+           {
+               *len = r->u.sutrs->len;
+               return r->u.sutrs->buf;
+           }
+           else if (r->which == Z_External_octet)
+           {
+               *len = r->u.octet_aligned->len;
+               return r->u.octet_aligned->buf;
+           }
+           else /* grs-1, explain, ... */
+           {
+               *len = -1;
+                return (Z_External *) npr->u.databaseRecord;
+           }
        }
        return 0;
     }
@@ -952,7 +988,6 @@ static void record_cache_add (ZOOM_resultset r,
                return;
            }
        }
-
     }
     rc = odr_malloc (r->odr, sizeof(*rc));
     rc->rec.npr = npr; 
@@ -1092,6 +1127,15 @@ static int scan_response (ZOOM_connection c, Z_ScanResponse *res)
         response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
     scan->scan_response = res;
     nmem_transfer (scan->odr->mem, nmem);
+    if (res->stepSize)
+        ZOOM_options_set_int (scan->options, "stepSize", *res->stepSize);
+    if (res->positionOfTerm)
+        ZOOM_options_set_int (scan->options, "position", *res->positionOfTerm);
+    if (res->scanStatus)
+        ZOOM_options_set_int (scan->options, "scanStatus", *res->scanStatus);
+    if (res->numberOfEntriesReturned)
+        ZOOM_options_set_int (scan->options, "number",
+                              *res->numberOfEntriesReturned);
     nmem_destroy (nmem);
     return 1;
 }
@@ -1350,6 +1394,17 @@ const char *ZOOM_scanset_term (ZOOM_scanset scan, size_t pos,
     return term;
 }
 
+const char *ZOOM_scanset_option_get (ZOOM_scanset scan, const char *key)
+{
+    return ZOOM_options_get (scan->options, key);
+}
+
+void ZOOM_scanset_option_set (ZOOM_scanset scan, const char *key,
+                              const char *val)
+{
+    ZOOM_options_set (scan->options, key, val);
+}
+
 static int ZOOM_connection_exec_task (ZOOM_connection c)
 {
     ZOOM_task task = c->tasks;
@@ -1508,14 +1563,18 @@ static int do_write_ex (ZOOM_connection c, char *buf_out, int len_out)
        return 1;
     }
     else if (r == 1)
-    {
-       c->state = STATE_ESTABLISHED;
-       c->mask = ZOOM_SELECT_READ|ZOOM_SELECT_WRITE|ZOOM_SELECT_EXCEPT;
+    {    
+        c->mask = ZOOM_SELECT_EXCEPT;
+        if (c->cs->io_pending & CS_WANT_WRITE)
+            c->mask += ZOOM_SELECT_WRITE;
+        if (c->cs->io_pending & CS_WANT_READ)
+            c->mask += ZOOM_SELECT_READ;
+        yaz_log (LOG_DEBUG, "do_write_ex 1 mask=%d", c->mask);
     }
     else
     {
-       c->state = STATE_ESTABLISHED;
-       c->mask = ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT;
+        c->mask = ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT;
+        yaz_log (LOG_DEBUG, "do_write_ex 2 mask=%d", c->mask);
     }
     return 0;
 }
@@ -1611,73 +1670,53 @@ int ZOOM_connection_error (ZOOM_connection c, const char **cp,
 int ZOOM_connection_do_io(ZOOM_connection c, int mask)
 {
     ZOOM_Event event = 0;
-#if 0
     int r = cs_look(c->cs);
-    yaz_log (LOG_LOG, "ZOOM_connection_do_io c=%p mask=%d cs_look=%d",
+    yaz_log (LOG_DEBUG, "ZOOM_connection_do_io c=%p mask=%d cs_look=%d",
             c, mask, r);
     
     if (r == CS_NONE)
     {
-        event = ZOOM_Event_create (ZOOM_EVENT_IO_CONNECT);
+        event = ZOOM_Event_create (ZOOM_EVENT_CONNECT);
        c->error = ZOOM_ERROR_CONNECT;
        do_close (c);
         ZOOM_connection_put_event (c, event);
     }
     else if (r == CS_CONNECT)
     {
-        event = ZOOM_Event_create (ZOOM_EVENT_IO_CONNECT);
-       yaz_log (LOG_LOG, "calling rcvconnect");
-       if (cs_rcvconnect (c->cs) < 0)
-       {
-           c->error = ZOOM_ERROR_CONNECT;
-           do_close (c);
-            ZOOM_connection_put_event (c, event);
-       }
-       else
+        int ret;
+        event = ZOOM_Event_create (ZOOM_EVENT_CONNECT);
+
+        ret = cs_rcvconnect (c->cs);
+        yaz_log (LOG_DEBUG, "cs_rcvconnect returned %d", ret);
+        if (ret == 1)
         {
+            c->mask = ZOOM_SELECT_EXCEPT;
+            if (c->cs->io_pending & CS_WANT_WRITE)
+                c->mask += ZOOM_SELECT_WRITE;
+            if (c->cs->io_pending & CS_WANT_READ)
+                c->mask += ZOOM_SELECT_READ;
             ZOOM_connection_put_event (c, event);
-           ZOOM_connection_send_init (c);
         }
-    }
-    else
-    {
-       if (mask & ZOOM_SELECT_READ)
-           do_read (c);
-       if (c->cs && (mask & ZOOM_SELECT_WRITE))
-           do_write (c);
-    }  
-#else
-    yaz_log (LOG_DEBUG, "ZOOM_connection_do_io c=%p mask=%d", c, mask);
-    if (c->state == STATE_CONNECTING)
-    {
-        event = ZOOM_Event_create (ZOOM_EVENT_CONNECT);
-       if (mask & ZOOM_SELECT_WRITE)
+        else if (ret == 0)
         {
             ZOOM_connection_put_event (c, event);
-           ZOOM_connection_send_init (c);
+            ZOOM_connection_send_init (c);
+            c->state = STATE_ESTABLISHED;
         }
-       else
-       {
-           c->error = ZOOM_ERROR_CONNECT;
-           do_close (c);
+        else
+        {
+            c->error = ZOOM_ERROR_CONNECT;
+            do_close (c);
             ZOOM_connection_put_event (c, event);
-       }
-    }
-    else if (c->state == STATE_ESTABLISHED)
-    {
-       if (mask & ZOOM_SELECT_READ)
-           do_read (c);
-       if (c->cs && (mask & ZOOM_SELECT_WRITE))
-           do_write (c);
+        }
     }
     else
     {
-        event = ZOOM_Event_create (ZOOM_EVENT_UNKNOWN);
-        ZOOM_connection_put_event (c, event);
-       c->error = ZOOM_ERROR_INTERNAL;
-       do_close (c);
+        if (mask & ZOOM_SELECT_READ)
+            do_read (c);
+        if (c->cs && (mask & ZOOM_SELECT_WRITE))
+            do_write (c);
     }
-#endif
     return 1;
 }
 
@@ -1787,9 +1826,7 @@ int ZOOM_event (int no, ZOOM_connection *cs)
     if (!nfds)
         return 0;
 #if HAVE_SYS_POLL_H
-    yaz_log (LOG_DEBUG, "poll start");
     r = poll (pollfds, nfds, 15000);
-    yaz_log (LOG_DEBUG, "poll stop, returned r=%d", r);
     for (i = 0; i<nfds; i++)
     {
         ZOOM_connection c = poll_cs[i];