X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=zoom%2Fzoom-c.c;h=cbcb0289f0c528bd208c81837acc883d3eab4f87;hb=c3b984a6d1cf19b1731b7e783ae2c0fd539277ac;hp=41ec33bd02e0b7cc3151b3b6dd5ae6e82cdd8f43;hpb=08e079756cdb1cd5da5779e1833b6065d07292d3;p=yaz-moved-to-github.git

diff --git a/zoom/zoom-c.c b/zoom/zoom-c.c
index 41ec33b..cbcb028 100644
--- a/zoom/zoom-c.c
+++ b/zoom/zoom-c.c
@@ -1,5 +1,5 @@
 /*
- * $Id: zoom-c.c,v 1.23 2002-01-28 09:27:48 adam Exp $
+ * $Id: zoom-c.c,v 1.35 2002-07-03 13:36:55 adam Exp $
  *
  * ZOOM layer for C, connections, result sets, queries.
  */
@@ -9,6 +9,8 @@
 #include <yaz/log.h>
 #include <yaz/pquery.h>
 #include <yaz/diagbib1.h>
+#include <yaz/charneg.h>
+#include <yaz/ill.h>
 
 #include "zoom-p.h"
 
@@ -16,6 +18,9 @@
 #include <sys/poll.h>
 #endif
 
+static int ZOOM_connection_send_init (ZOOM_connection c);
+static int do_write_ex (ZOOM_connection c, char *buf_out, int len_out);
+
 static ZOOM_Event ZOOM_Event_create (int kind)
 {
     ZOOM_Event event = (ZOOM_Event) xmalloc (sizeof(*event));
@@ -97,6 +102,19 @@ ZOOM_task ZOOM_connection_add_task (ZOOM_connection c, int which)
     return *taskp;
 }
 
+ZOOM_task ZOOM_connection_insert_task (ZOOM_connection c, int which)
+{
+    ZOOM_task task = (ZOOM_task) xmalloc (sizeof(*task));
+
+    task->next = c->tasks;
+    c->tasks = task;
+
+    task->running = 0;
+    task->which = which;
+    clear_error (c);
+    return task;
+}
+
 void ZOOM_connection_remove_task (ZOOM_connection c)
 {
     ZOOM_task task = c->tasks;
@@ -117,6 +135,9 @@ void ZOOM_connection_remove_task (ZOOM_connection c)
         case ZOOM_TASK_SCAN:
             ZOOM_scanset_destroy (task->u.scan.scan);
             break;
+        case ZOOM_TASK_PACKAGE:
+            ZOOM_package_destroy (task->u.package);
+            break;
 	default:
 	    assert (0);
 	}
@@ -134,12 +155,14 @@ static ZOOM_record record_cache_lookup (ZOOM_resultset r,
 					 int pos,
 					 const char *elementSetName);
 
-ZOOM_connection ZOOM_connection_create (ZOOM_options options)
+ZOOM_API(ZOOM_connection)
+ZOOM_connection_create (ZOOM_options options)
 {
     ZOOM_connection c = (ZOOM_connection) xmalloc (sizeof(*c));
 
     c->cs = 0;
     c->mask = 0;
+    c->reconnect_ok = 0;
     c->state = STATE_IDLE;
     c->error = ZOOM_ERROR_NONE;
     c->addinfo = 0;
@@ -153,9 +176,12 @@ ZOOM_connection ZOOM_connection_create (ZOOM_options options)
 
     c->host_port = 0;
     c->proxy = 0;
+    
+    c->charset = c->lang = 0;
 
     c->cookie_out = 0;
     c->cookie_in = 0;
+    c->client_IP = 0;
     c->tasks = 0;
 
     c->odr_in = odr_createmem (ODR_DECODE);
@@ -182,10 +208,13 @@ static char **set_DatabaseNames (ZOOM_connection con, ZOOM_options options,
     
     if (!cp || !*cp)
     {
-	cp = strchr (con->host_port, '/');
+        if (strncmp (con->host_port, "unix:", 5) == 0)
+	    cp = strchr (con->host_port+5, ':');
+	else
+	    cp = strchr (con->host_port, '/');
 	if (cp)
 	    cp++;
-	}
+    }
     if (cp)
     {
 	c = cp;
@@ -224,7 +253,8 @@ static char **set_DatabaseNames (ZOOM_connection con, ZOOM_options options,
     return databaseNames;
 }
 
-ZOOM_connection ZOOM_connection_new (const char *host, int portnum)
+ZOOM_API(ZOOM_connection)
+ZOOM_connection_new (const char *host, int portnum)
 {
     ZOOM_connection c = ZOOM_connection_create (0);
 
@@ -232,18 +262,42 @@ ZOOM_connection ZOOM_connection_new (const char *host, int portnum)
     return c;
 }
 
-void ZOOM_connection_connect(ZOOM_connection c,
-			      const char *host, int portnum)
+ZOOM_API(void)
+ZOOM_connection_connect(ZOOM_connection c,
+                        const char *host, int portnum)
 {
     const char *val;
     ZOOM_task task;
 
+    if (c->cs)
+    {
+        yaz_log (LOG_DEBUG, "reconnect");
+        c->reconnect_ok = 1;
+        return;
+    }
+    yaz_log(LOG_DEBUG, "connect");
+    xfree (c->proxy);
     val = ZOOM_options_get (c->options, "proxy");
     if (val && *val)
 	c->proxy = xstrdup (val);
     else
 	c->proxy = 0;
 
+    xfree (c->charset);
+    val = ZOOM_options_get (c->options, "charset");
+    if (val && *val)
+	c->charset = xstrdup (val);
+    else
+	c->charset = 0;
+
+    xfree (c->lang);
+    val = ZOOM_options_get (c->options, "lang");
+    if (val && *val)
+	c->lang = xstrdup (val);
+    else
+	c->lang = 0;
+
+    xfree (c->host_port);
     if (portnum)
     {
 	char hostn[128];
@@ -255,6 +309,14 @@ void ZOOM_connection_connect(ZOOM_connection c,
 
     ZOOM_options_set(c->options, "host", c->host_port);
 
+    val = ZOOM_options_get (c->options, "cookie");
+    if (val && *val)
+        c->cookie_out = xstrdup (val);
+
+    val = ZOOM_options_get (c->options, "clientIP");
+    if (val && *val)
+        c->client_IP = xstrdup (val);
+
     c->async = ZOOM_options_get_bool (c->options, "async", 0);
  
     c->error = ZOOM_ERROR_NONE;
@@ -268,7 +330,8 @@ void ZOOM_connection_connect(ZOOM_connection c,
     }
 }
 
-ZOOM_query ZOOM_query_create(void)
+ZOOM_API(ZOOM_query)
+ZOOM_query_create(void)
 {
     ZOOM_query s = (ZOOM_query) xmalloc (sizeof(*s));
 
@@ -280,7 +343,8 @@ ZOOM_query ZOOM_query_create(void)
     return s;
 }
 
-void ZOOM_query_destroy(ZOOM_query s)
+ZOOM_API(void)
+ZOOM_query_destroy(ZOOM_query s)
 {
     if (!s)
 	return;
@@ -294,7 +358,8 @@ void ZOOM_query_destroy(ZOOM_query s)
     }
 }
 
-int ZOOM_query_prefix(ZOOM_query s, const char *str)
+ZOOM_API(int)
+ZOOM_query_prefix(ZOOM_query s, const char *str)
 {
     s->query = (Z_Query *) odr_malloc (s->odr, sizeof(*s->query));
     s->query->which = Z_Query_type_1;
@@ -304,7 +369,8 @@ int ZOOM_query_prefix(ZOOM_query s, const char *str)
     return 0;
 }
 
-int ZOOM_query_sortby(ZOOM_query s, const char *criteria)
+ZOOM_API(int)
+ZOOM_query_sortby(ZOOM_query s, const char *criteria)
 {
     s->sort_spec = yaz_sort_spec (s->odr, criteria);
     if (!s->sort_spec)
@@ -314,7 +380,8 @@ int ZOOM_query_sortby(ZOOM_query s, const char *criteria)
 
 static int do_write(ZOOM_connection c);
 
-void ZOOM_connection_destroy(ZOOM_connection c)
+ZOOM_API(void)
+ZOOM_connection_destroy(ZOOM_connection c)
 {
     ZOOM_resultset r;
     if (!c)
@@ -331,6 +398,12 @@ void ZOOM_connection_destroy(ZOOM_connection c)
     ZOOM_options_destroy (c->options);
     ZOOM_connection_remove_tasks (c);
     xfree (c->host_port);
+    xfree (c->proxy);
+    xfree (c->charset);
+    xfree (c->lang);
+    xfree (c->cookie_out);
+    xfree (c->cookie_in);
+    xfree (c->client_IP);
     xfree (c);
 }
 
@@ -359,7 +432,8 @@ ZOOM_resultset ZOOM_resultset_create ()
     return r;
 }
 
-ZOOM_resultset ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
+ZOOM_API(ZOOM_resultset)
+ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
 {
     ZOOM_resultset r;
     ZOOM_query s = ZOOM_query_create();
@@ -371,7 +445,8 @@ ZOOM_resultset ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
     return r;
 }
 
-ZOOM_resultset ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
+ZOOM_API(ZOOM_resultset)
+ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
 {
     ZOOM_resultset r = ZOOM_resultset_create ();
     ZOOM_task task;
@@ -409,7 +484,8 @@ ZOOM_resultset ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
     return r;
 }
 
-void ZOOM_resultset_destroy(ZOOM_resultset r)
+ZOOM_API(void)
+ZOOM_resultset_destroy(ZOOM_resultset r)
 {
     if (!r)
         return;
@@ -445,7 +521,8 @@ void ZOOM_resultset_destroy(ZOOM_resultset r)
     }
 }
 
-size_t ZOOM_resultset_size (ZOOM_resultset r)
+ZOOM_API(size_t)
+ZOOM_resultset_size (ZOOM_resultset r)
 {
     return r->size;
 }
@@ -460,7 +537,7 @@ static void do_close (ZOOM_connection c)
 }
 
 static void ZOOM_resultset_retrieve (ZOOM_resultset r,
-				      int force_sync, int start, int count)
+                                     int force_sync, int start, int count)
 {
     ZOOM_task task;
     ZOOM_connection c;
@@ -482,8 +559,9 @@ static void ZOOM_resultset_retrieve (ZOOM_resultset r,
 	    ;
 }
 
-void ZOOM_resultset_records (ZOOM_resultset r, ZOOM_record *recs,
-			      size_t start, size_t count)
+ZOOM_API(void)
+ZOOM_resultset_records (ZOOM_resultset r, ZOOM_record *recs,
+                        size_t start, size_t count)
 {
     int force_present = 0;
 
@@ -518,8 +596,15 @@ static int do_connect (ZOOM_connection c)
     if (c->cs)
     {
 	int ret = cs_connect (c->cs, add);
-	yaz_log (LOG_DEBUG, "cs_connect returned %d", ret);
-	if (ret >= 0)
+        if (ret == 0)
+        {
+            ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
+            ZOOM_connection_put_event(c, event);
+            ZOOM_connection_send_init(c);
+            c->state = STATE_ESTABLISHED;
+            return 1;
+        }
+        else if (ret > 0)
 	{
 	    c->state = STATE_CONNECTING; 
             c->mask = ZOOM_SELECT_EXCEPT;
@@ -551,27 +636,29 @@ int z3950_connection_mask(ZOOM_connection c)
 
 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
 {
-    char str[120];
-
     assert (a);
-    sprintf (str, "send_APDU t=%p type=%d", c, a->which);
     if (c->cookie_out)
     {
 	Z_OtherInformation **oi;
 	yaz_oi_APDU(a, &oi);
 	yaz_oi_set_string_oidval(oi, out, VAL_COOKIE, 1, c->cookie_out);
     }
+    if (c->client_IP)
+    {
+	Z_OtherInformation **oi;
+	yaz_oi_APDU(a, &oi);
+	yaz_oi_set_string_oidval(oi, out, VAL_CLIENT_IP, 1, c->client_IP);
+    }
     if (!z_APDU(out, &a, 0, 0))
     {
-	FILE *outf = fopen("/tmp/apdu.txt", "w");
-	if (outf)
+	FILE *outf = fopen("/tmp/apdu.txt", "a");
+	if (a && outf)
 	{
 	    ODR odr_pr = odr_createmem(ODR_PRINT);
 	    fprintf (outf, "a=%p\n", a);
 	    odr_setprint(odr_pr, outf);
 	    z_APDU(odr_pr, &a, 0, 0);
 	    odr_destroy(odr_pr);
-	    fclose (outf);
 	}
 	c->error = ZOOM_ERROR_ENCODE;
 	do_close (c);
@@ -592,7 +679,7 @@ static int send_APDU (ZOOM_connection c, Z_APDU *a)
     ZOOM_connection_put_event (c, event);
     odr_reset(c->odr_out);
     do_write (c);
-    return 0;	
+    return 0;
 }
 
 static int ZOOM_connection_send_init (ZOOM_connection c)
@@ -679,6 +766,24 @@ static int ZOOM_connection_send_init (ZOOM_connection c)
     if (c->proxy)
 	yaz_oi_set_string_oidval(&ireq->otherInfo, c->odr_out,
 				 VAL_PROXY, 1, c->host_port);
+    if (c->charset||c->lang)
+    {
+    	Z_OtherInformation **oi;
+    	Z_OtherInformationUnit *oi_unit;
+    	
+    	yaz_oi_APDU(apdu, &oi);
+    	
+    	if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
+    	{
+    		ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
+    		
+    		oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
+    		oi_unit->information.externallyDefinedInfo =
+    			yaz_set_proposal_charneg(c->odr_out,
+    				(const char **)&c->charset, (c->charset) ? 1:0,
+    				(const char **)&c->lang, (c->lang) ? 1:0, 1);
+    	}
+    }
     assert (apdu);
     send_APDU (c, apdu);
     
@@ -805,7 +910,6 @@ static int ZOOM_connection_send_search (ZOOM_connection c)
     search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
     /* send search request */
     send_APDU (c, apdu);
-    r->r_query = 0;
     return 1;
 }
 
@@ -836,7 +940,8 @@ static void response_diag (ZOOM_connection c, Z_DiagRec *p)
     c->error = *r->condition;
 }
 
-ZOOM_record ZOOM_record_clone (ZOOM_record srec)
+ZOOM_API(ZOOM_record)
+ZOOM_record_clone (ZOOM_record srec)
 {
     char *buf;
     int size;
@@ -858,18 +963,21 @@ ZOOM_record ZOOM_record_clone (ZOOM_record srec)
     return nrec;
 }
 
-ZOOM_record ZOOM_resultset_record_immediate (ZOOM_resultset s,size_t pos)
+ZOOM_API(ZOOM_record)
+ZOOM_resultset_record_immediate (ZOOM_resultset s,size_t pos)
 {
     return record_cache_lookup (s, pos, 0);
 }
 
-ZOOM_record ZOOM_resultset_record (ZOOM_resultset r, size_t pos)
+ZOOM_API(ZOOM_record)
+ZOOM_resultset_record (ZOOM_resultset r, size_t pos)
 {
     ZOOM_resultset_retrieve (r, 1, pos, 1);
     return ZOOM_resultset_record_immediate (r, pos);
 }
 
-void ZOOM_record_destroy (ZOOM_record rec)
+ZOOM_API(void)
+ZOOM_record_destroy (ZOOM_record rec)
 {
     if (!rec)
 	return;
@@ -879,9 +987,14 @@ void ZOOM_record_destroy (ZOOM_record rec)
     xfree (rec);
 }
 
-const char *ZOOM_record_get (ZOOM_record rec, const char *type, int *len)
+ZOOM_API(const char *)
+ZOOM_record_get (ZOOM_record rec, const char *type, int *len)
 {
     Z_NamePlusRecord *npr;
+    
+    if (len)
+    	*len = 0; /* default return */
+    	
     if (!rec)
 	return 0;
     npr = rec->npr;
@@ -889,6 +1002,8 @@ const char *ZOOM_record_get (ZOOM_record rec, const char *type, int *len)
 	return 0;
     if (!strcmp (type, "database"))
     {
+    	if (len)
+            *len = strlen(npr->databaseName);
 	return npr->databaseName;
     }
     else if (!strcmp (type, "syntax"))
@@ -898,79 +1013,110 @@ const char *ZOOM_record_get (ZOOM_record rec, const char *type, int *len)
 	    Z_External *r = (Z_External *) npr->u.databaseRecord;
 	    oident *ent = oid_getentbyoid(r->direct_reference);
 	    if (ent)
+	    {
+	    	if (len)
+                    *len = strlen(ent->desc);
 		return ent->desc;
+	    }
 	}
 	return "none";
     }
-    else if (!strcmp (type, "render"))
+    else if (!strcmp (type, "render") && 
+             npr->which == Z_NamePlusRecord_databaseRecord)
     {
-	if (npr->which == Z_NamePlusRecord_databaseRecord)
-	{
-	    Z_External *r = (Z_External *) npr->u.databaseRecord;
-	    oident *ent = oid_getentbyoid(r->direct_reference);
-	    
-	    if (r->which == Z_External_sutrs)
-	    {
-		*len = r->u.sutrs->len;
-		return (const char *) r->u.sutrs->buf;
-	    }
-	    else if (r->which == Z_External_octet)
-	    {
-		switch (ent->value)
-		{
-		case VAL_SOIF:
-		case VAL_HTML:
-		case VAL_SUTRS:
-		    break;
-		case VAL_TEXT_XML:
-		case VAL_APPLICATION_XML:
-		    break;
-		default:
-		    if (!rec->wrbuf_marc)
-			rec->wrbuf_marc = wrbuf_alloc();
-                    wrbuf_rewind (rec->wrbuf_marc);
-		    if (marc_display_wrbuf ((const char *)
-                                            r->u.octet_aligned->buf,
-                                            rec->wrbuf_marc, 0,
-					    r->u.octet_aligned->len) > 0)
-		    {
-			*len = wrbuf_len(rec->wrbuf_marc);
-			return wrbuf_buf(rec->wrbuf_marc);
-		    }
-		}
-		*len = r->u.octet_aligned->len;
-		return (const char *) r->u.octet_aligned->buf;
-	    }
-	    else if (r->which == Z_External_grs1)
-	    {
-		*len = 5;
-		return "GRS-1";
-	    }
-	}
+        Z_External *r = (Z_External *) npr->u.databaseRecord;
+        oident *ent = oid_getentbyoid(r->direct_reference);
+        
+        if (r->which == Z_External_sutrs)
+        {
+            if (len) *len = r->u.sutrs->len;
+            return (const char *) r->u.sutrs->buf;
+        }
+        else if (r->which == Z_External_octet)
+        {
+            switch (ent->value)
+            {
+            case VAL_SOIF:
+            case VAL_HTML:
+            case VAL_SUTRS:
+                break;
+            case VAL_TEXT_XML:
+            case VAL_APPLICATION_XML:
+                break;
+            default:
+                if (!rec->wrbuf_marc)
+                    rec->wrbuf_marc = wrbuf_alloc();
+                wrbuf_rewind (rec->wrbuf_marc);
+                if (yaz_marc_decode ((const char *)
+                                     r->u.octet_aligned->buf,
+                                     rec->wrbuf_marc, 0,
+                                     r->u.octet_aligned->len,
+                                     0) > 0)
+                {
+                    if (len) *len = wrbuf_len(rec->wrbuf_marc);
+                    return wrbuf_buf(rec->wrbuf_marc);
+                }
+            }
+            if (len) *len = r->u.octet_aligned->len;
+            return (const char *) r->u.octet_aligned->buf;
+        }
+        else if (r->which == Z_External_grs1)
+        {
+            if (len) *len = 5;
+            return "GRS-1";
+        }
+	return 0;
+    }
+    else if (!strcmp (type, "xml") && 
+             npr->which == Z_NamePlusRecord_databaseRecord)
+    {
+        Z_External *r = (Z_External *) npr->u.databaseRecord;
+        oident *ent = oid_getentbyoid(r->direct_reference);
+        
+        if (r->which == Z_External_sutrs)
+        {
+            if (len) *len = r->u.sutrs->len;
+            return (const char *) r->u.sutrs->buf;
+        }
+        else if (r->which == Z_External_octet)
+        {
+            switch (ent->value)
+            {
+            case VAL_SOIF:
+            case VAL_HTML:
+            case VAL_SUTRS:
+                break;
+            case VAL_TEXT_XML:
+            case VAL_APPLICATION_XML:
+                break;
+            default:
+                if (!rec->wrbuf_marc)
+                    rec->wrbuf_marc = wrbuf_alloc();
+                wrbuf_rewind (rec->wrbuf_marc);
+                if (yaz_marc_decode ((const char *)
+                                     r->u.octet_aligned->buf,
+                                     rec->wrbuf_marc, 0,
+                                     r->u.octet_aligned->len,
+                                     1) > 0)
+                {
+                    if (len) *len = wrbuf_len(rec->wrbuf_marc);
+                    return wrbuf_buf(rec->wrbuf_marc);
+                }
+            }
+            if (len) *len = r->u.octet_aligned->len;
+            return (const char *) r->u.octet_aligned->buf;
+        }
+        else if (r->which == Z_External_grs1)
+        {
+            if (len) *len = 5;
+            return "GRS-1";
+        }
 	return 0;
     }
     else if (!strcmp (type, "raw"))
     {
 	if (npr->which == Z_NamePlusRecord_databaseRecord)
-	{
-	    Z_External *r = (Z_External *) npr->u.databaseRecord;
-	    
-	    if (r->which == Z_External_sutrs)
-	    {
-		*len = r->u.sutrs->len;
-		return (const char *) r->u.sutrs->buf;
-	    }
-	    else if (r->which == Z_External_octet)
-	    {
-		*len = r->u.octet_aligned->len;
-		return (const char *) r->u.octet_aligned->buf;
-	    }
-	    else /* grs-1, explain, ... */
-	    {
-		*len = -1;
-                return (const char *) npr->u.databaseRecord;
-	    }
-	}
+            return (const char *) npr->u.databaseRecord;
 	return 0;
     }
     return 0;
@@ -1301,7 +1447,8 @@ static int send_present (ZOOM_connection c)
     return 1;
 }
 
-ZOOM_scanset ZOOM_connection_scan (ZOOM_connection c, const char *start)
+ZOOM_API(ZOOM_scanset)
+ZOOM_connection_scan (ZOOM_connection c, const char *start)
 {
     ZOOM_scanset scan = (ZOOM_scanset) xmalloc (sizeof(*scan));
 
@@ -1328,7 +1475,8 @@ ZOOM_scanset ZOOM_connection_scan (ZOOM_connection c, const char *start)
     return scan;
 }
 
-void ZOOM_scanset_destroy (ZOOM_scanset scan)
+ZOOM_API(void)
+ZOOM_scanset_destroy (ZOOM_scanset scan)
 {
     if (!scan)
         return;
@@ -1342,7 +1490,22 @@ void ZOOM_scanset_destroy (ZOOM_scanset scan)
     }
 }
 
-int send_scan (ZOOM_connection c)
+static int send_package (ZOOM_connection c)
+{
+    ZOOM_Event event;
+    if (!c->tasks)
+        return 0;
+    assert (c->tasks->which == ZOOM_TASK_PACKAGE);
+
+    event = ZOOM_Event_create (ZOOM_EVENT_SEND_APDU);
+    ZOOM_connection_put_event (c, event);
+
+    do_write_ex (c, c->tasks->u.package->buf_out,
+                 c->tasks->u.package->len_out);
+    return 1;
+}
+
+static int send_scan (ZOOM_connection c)
 {
     ZOOM_scanset scan;
     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
@@ -1374,14 +1537,16 @@ int send_scan (ZOOM_connection c)
     return 1;
 }
 
-size_t ZOOM_scanset_size (ZOOM_scanset scan)
+ZOOM_API(size_t)
+ZOOM_scanset_size (ZOOM_scanset scan)
 {
     if (!scan || !scan->scan_response || !scan->scan_response->entries)
         return 0;
     return scan->scan_response->entries->num_entries;
 }
 
-const char *ZOOM_scanset_term (ZOOM_scanset scan, size_t pos,
+ZOOM_API(const char *)
+ZOOM_scanset_term (ZOOM_scanset scan, size_t pos,
                                int *occ, int *len)
 {
     const char *term = 0;
@@ -1406,17 +1571,255 @@ 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)
+ZOOM_API(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,
+ZOOM_API(void)
+ZOOM_scanset_option_set (ZOOM_scanset scan, const char *key,
                               const char *val)
 {
     ZOOM_options_set (scan->options, key, val);
 }
 
+
+
+static Z_APDU *create_es_package (ZOOM_package p, int type)
+{
+    const char *str;
+    Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
+    Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
+    
+    *req->function = Z_ExtendedServicesRequest_create;
+    
+    str = ZOOM_options_get(p->options, "package-name");
+    if (str && *str)
+        req->packageName = nmem_strdup (p->odr_out->mem, str);
+    
+    str = ZOOM_options_get(p->options, "user-id");
+    if (str)
+        req->userId = nmem_strdup (p->odr_out->mem, str);
+    
+    req->packageType = yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
+                                              type);
+
+    str = ZOOM_options_get(p->options, "function");
+    if (str)
+    {
+        if (!strcmp (str, "create"))
+            *req->function = 1;
+        if (!strcmp (str, "delete"))
+            *req->function = 2;
+        if (!strcmp (str, "modify"))
+            *req->function = 3;
+    }
+    return apdu;
+}
+
+static const char *ill_array_lookup (void *clientData, const char *idx)
+{
+    ZOOM_package p = (ZOOM_package) clientData;
+    return ZOOM_options_get (p->options, idx+4);
+}
+
+static Z_External *encode_ill_request (ZOOM_package p)
+{
+    ODR out = p->odr_out;
+    ILL_Request *req;
+    Z_External *r = 0;
+    struct ill_get_ctl ctl;
+	
+    ctl.odr = p->odr_out;
+    ctl.clientData = p;
+    ctl.f = ill_array_lookup;
+	
+    req = ill_get_ILLRequest(&ctl, "ill", 0);
+	
+    if (!ill_Request (out, &req, 0, 0))
+    {
+        int ill_request_size;
+        char *ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
+        if (ill_request_buf)
+            odr_setbuf (out, ill_request_buf, ill_request_size, 1);
+        return 0;
+    }
+    else
+    {
+        oident oid;
+        int illRequest_size = 0;
+        char *illRequest_buf = odr_getbuf (out, &illRequest_size, 0);
+		
+        oid.proto = PROTO_GENERAL;
+        oid.oclass = CLASS_GENERAL;
+        oid.value = VAL_ISO_ILL_1;
+		
+        r = (Z_External *) odr_malloc (out, sizeof(*r));
+        r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid)); 
+        r->indirect_reference = 0;
+        r->descriptor = 0;
+        r->which = Z_External_single;
+		
+        r->u.single_ASN1_type = (Odr_oct *)
+            odr_malloc (out, sizeof(*r->u.single_ASN1_type));
+        r->u.single_ASN1_type->buf = odr_malloc (out, illRequest_size);
+        r->u.single_ASN1_type->len = illRequest_size;
+        r->u.single_ASN1_type->size = illRequest_size;
+        memcpy (r->u.single_ASN1_type->buf, illRequest_buf, illRequest_size);
+    }
+    return r;
+}
+
+static Z_ItemOrder *encode_item_order(ZOOM_package p)
+{
+    Z_ItemOrder *req = odr_malloc (p->odr_out, sizeof(*req));
+    const char *str;
+    
+    req->which=Z_IOItemOrder_esRequest;
+    req->u.esRequest = (Z_IORequest *) 
+        odr_malloc(p->odr_out,sizeof(Z_IORequest));
+
+    /* to keep part ... */
+    req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
+	odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
+    req->u.esRequest->toKeep->supplDescription = 0;
+    req->u.esRequest->toKeep->contact =
+        odr_malloc (p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
+	
+    str = ZOOM_options_get(p->options, "contact-name");
+    req->u.esRequest->toKeep->contact->name = str ?
+        nmem_strdup (p->odr_out->mem, str) : 0;
+	
+    str = ZOOM_options_get(p->options, "contact-phone");
+    req->u.esRequest->toKeep->contact->phone = str ?
+        nmem_strdup (p->odr_out->mem, str) : 0;
+	
+    str = ZOOM_options_get(p->options, "contact-email");
+    req->u.esRequest->toKeep->contact->email = str ?
+        nmem_strdup (p->odr_out->mem, str) : 0;
+	
+    req->u.esRequest->toKeep->addlBilling = 0;
+	
+    /* not to keep part ... */
+    req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
+        odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
+	
+    req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
+        odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
+
+    str = ZOOM_options_get(p->options, "itemorder-setname");
+    if (!str)
+        str = "default";
+    req->u.esRequest->notToKeep->resultSetItem->resultSetId =
+        nmem_strdup (p->odr_out->mem, str);
+    req->u.esRequest->notToKeep->resultSetItem->item =
+        (int *) odr_malloc(p->odr_out, sizeof(int));
+	
+    str = ZOOM_options_get(p->options, "itemorder-item");
+    *req->u.esRequest->notToKeep->resultSetItem->item =
+        (str ? atoi(str) : 1);
+    
+    req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
+    
+    return req;
+}
+
+ZOOM_API(void)
+    ZOOM_package_send (ZOOM_package p, const char *type)
+{
+    Z_APDU *apdu = 0;
+    ZOOM_connection c;
+    if (!p)
+        return;
+    c = p->connection;
+    odr_reset (p->odr_out);
+    xfree (p->buf_out);
+    p->buf_out = 0;
+    if (!strcmp(type, "itemorder"))
+    {
+        Z_External *r;
+        apdu = create_es_package (p, VAL_ITEMORDER);
+        if (apdu)
+        {
+            r = odr_malloc (p->odr_out, sizeof(*r));
+            
+            r->direct_reference =
+                yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
+                                       VAL_ITEMORDER);
+            r->descriptor = 0;
+            r->which = Z_External_itemOrder;
+            r->indirect_reference = 0;
+            r->u.itemOrder = encode_item_order (p);
+
+            apdu->u.extendedServicesRequest->taskSpecificParameters = r;
+        }
+    }
+    if (apdu)
+    {
+        if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
+        {
+            char *buf;
+
+            ZOOM_task task = ZOOM_connection_add_task (c, ZOOM_TASK_PACKAGE);
+            task->u.package = p;
+            buf = odr_getbuf(p->odr_out, &p->len_out, 0);
+            p->buf_out = xmalloc (p->len_out);
+            memcpy (p->buf_out, buf, p->len_out);
+            
+            (p->refcount)++;
+            if (!c->async)
+            {
+                while (ZOOM_event (1, &c))
+                    ;
+            }
+        }
+    }
+}
+
+ZOOM_API(ZOOM_package)
+    ZOOM_connection_package (ZOOM_connection c, ZOOM_options options)
+{
+    ZOOM_package p = (ZOOM_package) xmalloc (sizeof(*p));
+
+    p->connection = c;
+    p->odr_out = odr_createmem (ODR_ENCODE);
+    p->options = ZOOM_options_create_with_parent2 (options, c->options);
+    p->refcount = 1;
+    p->buf_out = 0;
+    p->len_out = 0;
+    return p;
+}
+
+ZOOM_API(void)
+    ZOOM_package_destroy(ZOOM_package p)
+{
+    if (!p)
+        return;
+    (p->refcount)--;
+    if (p->refcount == 0)
+    {
+        odr_destroy (p->odr_out);
+        xfree (p->buf_out);
+        
+        ZOOM_options_destroy (p->options);
+        xfree (p);
+    }
+}
+
+ZOOM_API(const char *)
+ZOOM_package_option_get (ZOOM_package p, const char *key)
+{
+    return ZOOM_options_get (p->options, key);
+}
+
+ZOOM_API(void)
+ZOOM_package_option_set (ZOOM_package p, const char *key,
+                              const char *val)
+{
+    ZOOM_options_set (p->options, key, val);
+}
+
 static int ZOOM_connection_exec_task (ZOOM_connection c)
 {
     ZOOM_task task = c->tasks;
@@ -1430,7 +1833,8 @@ static int ZOOM_connection_exec_task (ZOOM_connection c)
 	ZOOM_connection_remove_tasks (c);
 	return 0;
     }
-    yaz_log (LOG_DEBUG, "ZOOM_connection_exec_task type=%d", task->which);
+    yaz_log (LOG_DEBUG, "ZOOM_connection_exec_task type=%d run=%d",
+             task->which, task->running);
     if (task->running)
 	return 0;
     task->running = 1;
@@ -1452,6 +1856,10 @@ static int ZOOM_connection_exec_task (ZOOM_connection c)
     case ZOOM_TASK_SCAN:
         if (send_scan(c))
             return 1;
+        break;
+    case ZOOM_TASK_PACKAGE:
+        if (send_package(c))
+            return 1;
     }
     ZOOM_connection_remove_task (c);
     return 0;
@@ -1465,12 +1873,33 @@ static int send_sort_present (ZOOM_connection c)
     return r;
 }
 
+static int es_response (ZOOM_connection c,
+                        Z_ExtendedServicesResponse *res)
+{
+    if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
+        return 0;
+    if (res->diagnostics && res->num_diagnostics > 0)
+        response_diag(c, res->diagnostics[0]);
+    if (res->taskPackage &&
+        res->taskPackage->which == Z_External_extendedService)
+    {
+        Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
+        Odr_oct *id = taskPackage->targetReference;
+        
+        if (id)
+            ZOOM_options_setl (c->tasks->u.package->options,
+                               "targetReference", id->buf, id->len);
+    }
+    return 1;
+}
+
+
 static void handle_apdu (ZOOM_connection c, Z_APDU *apdu)
 {
     Z_InitResponse *initrs;
     
-    yaz_log (LOG_DEBUG, "hande_apdu type=%d", apdu->which);
     c->mask = 0;
+    yaz_log (LOG_DEBUG, "hande_apdu type=%d", apdu->which);
     switch(apdu->which)
     {
     case Z_APDU_initResponse:
@@ -1498,6 +1927,25 @@ static void handle_apdu (ZOOM_connection c, Z_APDU *apdu)
             }
 	    ZOOM_connection_exec_task (c);
 	}
+	if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
+	{
+            NMEM tmpmem = nmem_create();
+            Z_CharSetandLanguageNegotiation *p =
+                yaz_get_charneg_record(initrs->otherInfo);
+            
+            if (p)
+            {
+                char *charset=NULL, *lang=NULL;
+                int selected;
+                
+                yaz_get_response_charneg(tmpmem, p, &charset, &lang, &selected);
+                yaz_log(LOG_DEBUG, "Target accepted: charset - %s,"
+                        "language - %s, select - %d",
+                        charset, lang, selected);
+                
+                nmem_destroy(tmpmem);
+            }
+	}	
 	break;
     case Z_APDU_searchResponse:
 	handle_search_response (c, apdu->u.searchResponse);
@@ -1517,6 +1965,27 @@ static void handle_apdu (ZOOM_connection c, Z_APDU *apdu)
     case Z_APDU_scanResponse:
         scan_response (c, apdu->u.scanResponse);
         ZOOM_connection_remove_task (c);
+        break;
+    case Z_APDU_extendedServicesResponse:
+        es_response (c, apdu->u.extendedServicesResponse);
+        ZOOM_connection_remove_task (c);
+        break;
+    case Z_APDU_close:
+        if (c->reconnect_ok)
+        {
+            do_close(c);
+            c->tasks->running = 0;
+            ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
+        }
+        else
+        {
+            c->error = ZOOM_ERROR_CONNECTION_LOST;
+            do_close(c);
+        }
+        break;
+    default:
+        c->error = ZOOM_ERROR_DECODE;
+        do_close(c);
     }
 }
 
@@ -1529,13 +1998,26 @@ static int do_read (ZOOM_connection c)
     event = ZOOM_Event_create (ZOOM_EVENT_RECV_DATA);
     ZOOM_connection_put_event (c, event);
     
+    yaz_log (LOG_DEBUG, "do_read len=%d", c->len_in);
+
     r = cs_get (c->cs, &c->buf_in, &c->len_in);
     if (r == 1)
 	return 0;
     if (r <= 0)
     {
-	c->error= ZOOM_ERROR_CONNECTION_LOST;
-	do_close (c);
+        if (c->reconnect_ok)
+        {
+            do_close (c);
+            c->reconnect_ok = 0;
+            yaz_log (LOG_DEBUG, "reconnect read");
+            c->tasks->running = 0;
+            ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
+        }
+        else
+        {
+            c->error= ZOOM_ERROR_CONNECTION_LOST;
+            do_close (c);
+        }
     }
     else
     {
@@ -1550,9 +2032,8 @@ static int do_read (ZOOM_connection c)
 	    do_close (c);
 	}
 	else
-	{
 	    handle_apdu (c, apdu);
-	}
+        c->reconnect_ok = 0;
     }
     return 1;
 }
@@ -1565,8 +2046,18 @@ static int do_write_ex (ZOOM_connection c, char *buf_out, int len_out)
     event = ZOOM_Event_create(ZOOM_EVENT_SEND_DATA);
     ZOOM_connection_put_event (c, event);
 
+    yaz_log (LOG_DEBUG, "do_write_ex len=%d", len_out);
     if ((r=cs_put (c->cs, buf_out, len_out)) < 0)
     {
+        if (c->reconnect_ok)
+        {
+            do_close (c);
+            c->reconnect_ok = 0;
+            yaz_log (LOG_DEBUG, "reconnect write");
+            c->tasks->running = 0;
+            ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
+            return 0;
+        }
 	if (c->state == STATE_CONNECTING)
 	    c->error = ZOOM_ERROR_CONNECT;
 	else
@@ -1585,6 +2076,7 @@ static int do_write_ex (ZOOM_connection c, char *buf_out, int len_out)
     }
     else
     {
+        // c->reconnect_ok = 0;
         c->mask = ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT;
         yaz_log (LOG_DEBUG, "do_write_ex 2 mask=%d", c->mask);
     }
@@ -1597,49 +2089,57 @@ static int do_write(ZOOM_connection c)
 }
 
 
-const char *ZOOM_connection_option_get (ZOOM_connection c, const char *key)
+ZOOM_API(const char *)
+ZOOM_connection_option_get (ZOOM_connection c, const char *key)
 {
     return ZOOM_options_get (c->options, key);
 }
 
-void ZOOM_connection_option_set (ZOOM_connection c, const char *key,
+ZOOM_API(void)
+ZOOM_connection_option_set (ZOOM_connection c, const char *key,
                                   const char *val)
 {
     ZOOM_options_set (c->options, key, val);
 }
 
-const char *ZOOM_resultset_option_get (ZOOM_resultset r, const char *key)
+ZOOM_API(const char *)
+ZOOM_resultset_option_get (ZOOM_resultset r, const char *key)
 {
     return ZOOM_options_get (r->options, key);
 }
 
-void ZOOM_resultset_option_set (ZOOM_resultset r, const char *key,
+ZOOM_API(void)
+ZOOM_resultset_option_set (ZOOM_resultset r, const char *key,
                                   const char *val)
 {
     ZOOM_options_set (r->options, key, val);
 }
 
 
-int ZOOM_connection_errcode (ZOOM_connection c)
+ZOOM_API(int)
+ZOOM_connection_errcode (ZOOM_connection c)
 {
     return ZOOM_connection_error (c, 0, 0);
 }
 
-const char *ZOOM_connection_errmsg (ZOOM_connection c)
+ZOOM_API(const char *)
+ZOOM_connection_errmsg (ZOOM_connection c)
 {
     const char *msg;
     ZOOM_connection_error (c, &msg, 0);
     return msg;
 }
 
-const char *ZOOM_connection_addinfo (ZOOM_connection c)
+ZOOM_API(const char *)
+ZOOM_connection_addinfo (ZOOM_connection c)
 {
     const char *addinfo;
     ZOOM_connection_error (c, 0, &addinfo);
     return addinfo;
 }
 
-int ZOOM_connection_error (ZOOM_connection c, const char **cp,
+ZOOM_API(int)
+ZOOM_connection_error (ZOOM_connection c, const char **cp,
 			    const char **addinfo)
 {
     int error = c->error;
@@ -1679,7 +2179,7 @@ int ZOOM_connection_error (ZOOM_connection c, const char **cp,
     return c->error;
 }
 
-int ZOOM_connection_do_io(ZOOM_connection c, int mask)
+static int ZOOM_connection_do_io(ZOOM_connection c, int mask)
 {
     ZOOM_Event event = 0;
     int r = cs_look(c->cs);
@@ -1732,14 +2232,16 @@ int ZOOM_connection_do_io(ZOOM_connection c, int mask)
     return 1;
 }
 
-int ZOOM_connection_last_event(ZOOM_connection cs)
+ZOOM_API(int)
+ZOOM_connection_last_event(ZOOM_connection cs)
 {
     if (!cs)
         return ZOOM_EVENT_NONE;
     return cs->last_event;
 }
 
-int ZOOM_event (int no, ZOOM_connection *cs)
+ZOOM_API(int)
+ZOOM_event (int no, ZOOM_connection *cs)
 {
 #if HAVE_SYS_POLL_H
     struct pollfd pollfds[1024];