/*
- * $Id: zoom-c.c,v 1.3 2001-11-06 17:05:19 adam Exp $
+ * $Id: zoom-c.c,v 1.9 2001-11-16 09:52:39 adam Exp $
*
* ZOOM layer for C, connections, result sets, queries.
*/
#include "zoom-p.h"
-static Z3950_record record_cache_lookup (Z3950_resultset r,
- int pos,
- const char *elementSetName);
+#if HAVE_SYS_POLL_H
+#include <sys/poll.h>
+#endif
+
+static Z3950_Event Z3950_Event_create (int kind)
+{
+ Z3950_Event event = xmalloc (sizeof(*event));
+ event->kind = kind;
+ event->next = 0;
+ event->prev = 0;
+ return event;
+}
+
+static void Z3950_Event_destroy (Z3950_Event event)
+{
+ xfree (event);
+}
+
+static void Z3950_connection_put_event (Z3950_connection c, Z3950_Event event)
+{
+ // put in back of queue
+ if (c->m_queue_back)
+ {
+ c->m_queue_back->prev = event;
+ assert (c->m_queue_front);
+ }
+ else
+ {
+ assert (!c->m_queue_front);
+ c->m_queue_front = event;
+ }
+ event->next = c->m_queue_back;
+ event->prev = 0;
+ c->m_queue_back = event;
+}
+
+static Z3950_Event Z3950_connection_get_event(Z3950_connection c)
+{
+ // get from front of queue
+ Z3950_Event event = c->m_queue_front;
+ if (!event)
+ return 0;
+ assert (c->m_queue_back);
+ c->m_queue_front = event->prev;
+ if (c->m_queue_front)
+ {
+ assert (c->m_queue_back);
+ c->m_queue_front->next = 0;
+ }
+ else
+ c->m_queue_back = 0;
+ return event;
+}
static void clear_error (Z3950_connection c)
{
c->addinfo = 0;
}
+Z3950_task Z3950_connection_add_task (Z3950_connection c, int which)
+{
+ Z3950_task *taskp = &c->tasks;
+ while (*taskp)
+ taskp = &(*taskp)->next;
+ *taskp = xmalloc (sizeof(**taskp));
+ (*taskp)->running = 0;
+ (*taskp)->which = which;
+ (*taskp)->u.resultset = 0; /* one null pointer there at least */
+ (*taskp)->next = 0;
+ clear_error (c);
+ return *taskp;
+}
+
+void Z3950_connection_remove_task (Z3950_connection c)
+{
+ Z3950_task task = c->tasks;
+
+ if (task)
+ {
+ c->tasks = task->next;
+ switch (task->which)
+ {
+ case Z3950_TASK_SEARCH:
+ Z3950_resultset_destroy (task->u.resultset);
+ break;
+ case Z3950_TASK_RETRIEVE:
+ Z3950_resultset_destroy (task->u.resultset);
+ break;
+ case Z3950_TASK_CONNECT:
+ break;
+ default:
+ assert (0);
+ }
+ xfree (task);
+ }
+}
+
+void Z3950_connection_remove_tasks (Z3950_connection c)
+{
+ while (c->tasks)
+ Z3950_connection_remove_task(c);
+}
+
+static Z3950_record record_cache_lookup (Z3950_resultset r,
+ int pos,
+ const char *elementSetName);
+
Z3950_connection Z3950_connection_create (Z3950_options options)
{
Z3950_connection c = xmalloc (sizeof(*c));
- c->event_pending = 0;
c->cs = 0;
c->mask = 0;
c->state = STATE_IDLE;
c->odr_out = odr_createmem (ODR_ENCODE);
c->async = 0;
+
+ c->m_queue_front = 0;
+ c->m_queue_back = 0;
return c;
}
const char *host, int portnum)
{
const char *val;
+ Z3950_task task;
val = Z3950_options_get (c->options, "proxy");
if (val && *val)
else
c->host_port = xstrdup(host);
+ Z3950_options_set(c->options, "host", c->host_port);
+
c->async = Z3950_options_get_bool (c->options, "async", 0);
+ task = Z3950_connection_add_task (c, Z3950_TASK_CONNECT);
+
if (!c->async)
{
while (Z3950_event (1, &c))
return s;
}
-const char *Z3950_connection_host (Z3950_connection c)
-{
- return c->host_port;
-}
-
void Z3950_query_destroy(Z3950_query s)
{
if (!s)
static int do_write(Z3950_connection c);
-
-Z3950_task Z3950_connection_add_task (Z3950_connection c, int which)
-{
- Z3950_task *taskp = &c->tasks;
- while (*taskp)
- taskp = &(*taskp)->next;
- *taskp = xmalloc (sizeof(**taskp));
- (*taskp)->running = 0;
- (*taskp)->which = which;
- (*taskp)->u.resultset = 0; /* one null pointer there at least */
- (*taskp)->next = 0;
- clear_error (c);
- return *taskp;
-}
-
-void Z3950_connection_remove_task (Z3950_connection c)
-{
- Z3950_task task = c->tasks;
-
- if (task)
- {
- c->tasks = task->next;
- switch (task->which)
- {
- case Z3950_TASK_SEARCH:
- Z3950_resultset_destroy (task->u.resultset);
- break;
- case Z3950_TASK_RETRIEVE:
- Z3950_resultset_destroy (task->u.resultset);
- break;
- default:
- assert (0);
- }
- xfree (task);
- }
-}
-
-void Z3950_connection_remove_tasks (Z3950_connection c)
-{
- while (c->tasks)
- Z3950_connection_remove_task(c);
-}
-
void Z3950_connection_destroy(Z3950_connection c)
{
Z3950_resultset r;
}
}
-int Z3950_resultset_size (Z3950_resultset r)
+size_t Z3950_resultset_size (Z3950_resultset r)
{
return r->size;
}
c = r->connection;
if (!c)
return;
+ if (start >= r->size)
+ return;
+
+ if (start + count > r->size)
+ count = r->size - start;
+
task = Z3950_connection_add_task (c, Z3950_TASK_RETRIEVE);
task->u.resultset = r;
Z3950_resultset_addref (r);
}
}
-static void do_connect (Z3950_connection c)
+static int do_connect (Z3950_connection c)
{
void *add;
const char *effective_host;
if (ret >= 0)
{
c->state = STATE_CONNECTING;
- c->mask = Z3950_SELECT_READ | Z3950_SELECT_WRITE | Z3950_SELECT_EXCEPT;
- return;
+ c->mask = Z3950_SELECT_READ | Z3950_SELECT_WRITE |
+ Z3950_SELECT_EXCEPT;
+ return 1;
}
}
- c->event_pending = 1;
c->state = STATE_IDLE;
c->error = Z3950_ERROR_CONNECT;
+ return 0;
}
int z3950_connection_socket(Z3950_connection c)
c->error = *r->condition;
}
-Z3950_record Z3950_record_dup (Z3950_record srec)
+Z3950_record Z3950_record_dup (const Z3950_record srec)
{
char *buf;
int size;
Z3950_record Z3950_resultset_record_immediate (Z3950_resultset s,size_t pos)
{
- Z3950_record rec = record_cache_lookup (s, pos, 0);
- if (!rec)
- return 0;
- return Z3950_record_dup (rec);
+ return record_cache_lookup (s, pos, 0);
}
Z3950_record Z3950_resultset_record (Z3950_resultset r, size_t pos)
}
return 0;
}
+ else if (!strcmp (type, "raw"))
+ {
+ if (npr->which == Z_NamePlusRecord_databaseRecord)
+ {
+ *len = -1;
+ return (Z_External *) npr->u.databaseRecord;
+ }
+ return 0;
+ }
return 0;
}
-void *Z3950_resultset_get (Z3950_resultset s, size_t pos, const char *type,
- size_t *len)
-{
- Z3950_record rec = record_cache_lookup (s, pos, 0);
- return Z3950_record_get (rec, type, len);
-}
-
static void record_cache_add (Z3950_resultset r,
Z_NamePlusRecord *npr,
int pos,
{
Z3950_task task = c->tasks;
- yaz_log (LOG_DEBUG, "Z3950_connection_exec_task");
+ yaz_log (LOG_LOG, "Z3950_connection_exec_task");
if (!task)
return 0;
- if (c->error != Z3950_ERROR_NONE || !c->cs)
+ if (c->error != Z3950_ERROR_NONE ||
+ (!c->cs && task->which != Z3950_TASK_CONNECT))
{
Z3950_connection_remove_tasks (c);
return 0;
if (send_present (c))
return 1;
break;
+ case Z3950_TASK_CONNECT:
+ if (do_connect(c))
+ return 1;
}
Z3950_connection_remove_task (c);
return 0;
c->cookie_in = 0;
if (cookie)
c->cookie_in = xstrdup(cookie);
+ if (c->tasks)
+ {
+ assert (c->tasks->which == Z3950_TASK_CONNECT);
+ Z3950_connection_remove_task (c);
+ }
Z3950_connection_exec_task (c);
}
break;
else if (r == 1)
{
c->state = STATE_ESTABLISHED;
- c->mask = Z3950_SELECT_READ|Z3950_SELECT_WRITE;
+ c->mask = Z3950_SELECT_READ|Z3950_SELECT_WRITE|Z3950_SELECT_EXCEPT;
}
else
{
c->state = STATE_ESTABLISHED;
- c->mask = Z3950_SELECT_READ;
+ c->mask = Z3950_SELECT_READ|Z3950_SELECT_EXCEPT;
}
return 0;
}
return do_write_ex (c, c->buf_out, c->len_out);
}
-const char *Z3950_connection_option (Z3950_connection c, const char *key,
- const char *val)
+
+const char *Z3950_connection_option_get (Z3950_connection c, const char *key)
{
- const char *old_val = Z3950_options_get (c->options, key);
- if (val)
- {
- Z3950_options_set (c->options, key, val);
- }
- return old_val;
+ return Z3950_options_get (c->options, key);
}
-const char *Z3950_resultset_option (Z3950_resultset r, const char *key,
- const char *val)
+void Z3950_connection_option_set (Z3950_connection c, const char *key,
+ const char *val)
{
- const char *old_val = Z3950_options_get (r->options, key);
- if (val)
- {
- Z3950_options_set (r->options, key, val);
- }
- return old_val;
+ Z3950_options_set (c->options, key, val);
+}
+
+const char *Z3950_resultset_option_get (Z3950_resultset r, const char *key)
+{
+ return Z3950_options_get (r->options, key);
+}
+
+void Z3950_resultset_option_set (Z3950_resultset r, const char *key,
+ const char *val)
+{
+ Z3950_options_set (r->options, key, val);
}
int Z3950_connection_do_io(Z3950_connection c, int mask)
{
+ Z3950_Event event;
#if 0
int r = cs_look(c->cs);
- yaz_log (LOG_DEBUG, "Z3950_connection_do_io c=%p mask=%d cs_look=%d",
+ yaz_log (LOG_LOG, "Z3950_connection_do_io c=%p mask=%d cs_look=%d",
c, mask, r);
if (r == CS_NONE)
}
else if (r == CS_CONNECT)
{
- yaz_log (LOG_DEBUG, "calling rcvconnect");
+ yaz_log (LOG_LOG, "calling rcvconnect");
if (cs_rcvconnect (c->cs) < 0)
{
c->error = Z3950_ERROR_CONNECT;
do_close (c);
}
#endif
- c->event_pending = 1;
+ event = Z3950_Event_create (1);
+ Z3950_connection_put_event (c, event);
return 1;
}
+
int Z3950_event (int no, Z3950_connection *cs)
{
+#if HAVE_SYS_POLL_H
+ struct pollfd pollfds[1024];
+ Z3950_connection poll_cs[1024];
+#else
struct timeval tv;
fd_set input, output, except;
- int i, r;
+#endif
+ int i, r, nfds;
int max_fd = 0;
for (i = 0; i<no; i++)
{
Z3950_connection c = cs[i];
- if (c && c->event_pending)
- {
- c->event_pending = 0;
+ Z3950_Event event;
+ if (c && (event = Z3950_connection_get_event(c)))
+ {
+ Z3950_Event_destroy (event);
return i+1;
- }
+ }
+ }
+ for (i = 0; i<no; i++)
+ {
+ Z3950_connection c = cs[i];
+ if (c && Z3950_connection_exec_task (c))
+ return i+1;
}
+#if HAVE_SYS_POLL_H
+#else
tv.tv_sec = 15;
tv.tv_usec = 0;
FD_ZERO (&input);
FD_ZERO (&output);
FD_ZERO (&except);
- r = 0;
+#endif
+ nfds = 0;
for (i = 0; i<no; i++)
{
Z3950_connection c = cs[i];
continue;
if (max_fd < fd)
max_fd = fd;
+
+#if HAVE_SYS_POLL_H
+ if (mask)
+ {
+ short poll_events = 0;
+
+ if (mask & Z3950_SELECT_READ)
+ poll_events += POLLIN;
+ if (mask & Z3950_SELECT_WRITE)
+ poll_events += POLLOUT;
+ if (mask & Z3950_SELECT_EXCEPT)
+ poll_events += POLLERR;
+ pollfds[nfds].fd = fd;
+ pollfds[nfds].events = poll_events;
+ pollfds[nfds].revents = 0;
+ poll_cs[nfds] = c;
+ nfds++;
+ }
+#else
if (mask & Z3950_SELECT_READ)
{
FD_SET (fd, &input);
- r++;
+ nfds++;
}
if (mask & Z3950_SELECT_WRITE)
{
FD_SET (fd, &output);
- r++;
+ nfds++;
}
if (mask & Z3950_SELECT_EXCEPT)
{
FD_SET (fd, &except);
- r++;
+ nfds++;
}
+#endif
}
- if (!r)
+ if (!nfds)
+ return 0;
+#if HAVE_SYS_POLL_H
+ yaz_log (LOG_LOG, "poll start");
+ r = poll (pollfds, nfds, 15000);
+ yaz_log (LOG_LOG, "poll stop, returned r=%d", r);
+ for (i = 0; i<nfds; i++)
{
- for (i = 0; i<no; i++)
- {
- Z3950_connection c = cs[i];
- if (!c)
- continue;
- if (!c->cs && c->host_port && c->error == Z3950_ERROR_NONE)
- {
- do_connect (c);
- return i+1;
- }
- else
- {
- if (Z3950_connection_exec_task (c))
- return i+1;
- }
- }
- yaz_log (LOG_DEBUG, "no more events");
- return 0;
+ Z3950_connection c = poll_cs[i];
+ if (r && c->mask)
+ {
+ int mask = 0;
+ if (pollfds[i].revents & POLLIN)
+ mask += Z3950_SELECT_READ;
+ if (pollfds[i].revents & POLLOUT)
+ mask += Z3950_SELECT_WRITE;
+ if (pollfds[i].revents & POLLERR)
+ mask += Z3950_SELECT_EXCEPT;
+ if (mask)
+ Z3950_connection_do_io(c, mask);
+ }
+ else if (r == 0 && c->mask)
+ {
+ Z3950_Event event = Z3950_Event_create(0);
+ /* timeout and this connection was waiting */
+ c->error = Z3950_ERROR_TIMEOUT;
+ do_close (c);
+ Z3950_connection_put_event(c, event);
+ }
}
+#else
yaz_log (LOG_DEBUG, "select start");
r = select (max_fd+1, &input, &output, &except, &tv);
yaz_log (LOG_DEBUG, "select stop, returned r=%d", r);
-
for (i = 0; i<no; i++)
{
Z3950_connection c = cs[i];
}
if (r == 0 && c->mask)
{
+ Z3950_Event event = Z3950_Event_create(0);
/* timeout and this connection was waiting */
c->error = Z3950_ERROR_TIMEOUT;
- c->event_pending = 1;
+ do_close (c);
+ yaz_log (LOG_LOG, "timeout");
+ Z3950_connection_put_event(c, event);
}
}
+#endif
for (i = 0; i<no; i++)
{
Z3950_connection c = cs[i];
- if (!c)
- continue;
- if (c->event_pending)
- {
- c->event_pending = 0;
+ Z3950_Event event;
+ if (c && (event = Z3950_connection_get_event(c)))
+ {
+ Z3950_Event_destroy (event);
return i+1;
- }
+ }
}
return 0;
}
projects / yaz-moved-to-github.git / blobdiff