Introduce Z39.50/SRU operation timeout.
[pazpar2-moved-to-github.git] / src / connection.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2009 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 /** \file connection.c
21     \brief Z39.50 connection (low-level client)
22 */
23
24 #if HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #if HAVE_SYS_TIME_H
32 #include <sys/time.h>
33 #endif
34 #if HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #include <signal.h>
39 #include <assert.h>
40
41 #include <yaz/log.h>
42 #include <yaz/comstack.h>
43 #include <yaz/tcpip.h>
44 #include "connection.h"
45 #include "pazpar2.h"
46 #include "host.h"
47 #include "client.h"
48 #include "settings.h"
49
50
51 /** \brief Represents a physical, reusable  connection to a remote Z39.50 host
52  */
53 struct connection {
54     IOCHAN iochan;
55     ZOOM_connection link;
56     struct host *host;
57     struct client *client;
58     char *ibuf;
59     int ibufsize;
60     char *zproxy;
61     enum {
62         Conn_Resolving,
63         Conn_Connecting,
64         Conn_Open
65     } state;
66     int operation_timeout;
67     int session_timeout;
68     struct connection *next; // next for same host or next in free list
69 };
70
71 static struct connection *connection_freelist = 0;
72
73 static int connection_connect(struct connection *con);
74
75 static int connection_is_idle(struct connection *co)
76 {
77     ZOOM_connection link = co->link;
78     int event;
79
80     if (co->state != Conn_Open || !link)
81         return 0;
82
83     if (!ZOOM_connection_is_idle(link))
84         return 0;
85     event = ZOOM_connection_peek_event(link);
86     if (event == ZOOM_EVENT_NONE || event == ZOOM_EVENT_END)
87         return 1;
88     else
89         return 0;
90 }
91
92 ZOOM_connection connection_get_link(struct connection *co)
93 {
94     return co->link;
95 }
96
97 static void remove_connection_from_host(struct connection *con)
98 {
99     struct connection **conp = &con->host->connections;
100     assert(con);
101     while (*conp)
102     {
103         if (*conp == con)
104         {
105             *conp = (*conp)->next;
106             return;
107         }
108         conp = &(*conp)->next;
109     }
110     assert(*conp == 0);
111 }
112
113 // Close connection and recycle structure
114 void connection_destroy(struct connection *co)
115 {
116     if (co->link)
117     {
118         ZOOM_connection_destroy(co->link);
119         iochan_destroy(co->iochan);
120     }
121     yaz_log(YLOG_DEBUG, "Connection destroy %s", co->host->hostport);
122
123     remove_connection_from_host(co);
124     if (co->client)
125     {
126         client_disconnect(co->client);
127     }
128     xfree(co->zproxy);
129     co->zproxy = 0;
130     co->next = connection_freelist;
131     connection_freelist = co;
132 }
133
134 // Creates a new connection for client, associated with the host of 
135 // client's database
136 static struct connection *connection_create(struct client *cl,
137                                             int operation_timeout,
138                                             int session_timeout)
139 {
140     struct connection *new;
141     struct host *host = client_get_host(cl);
142
143     if ((new = connection_freelist))
144         connection_freelist = new->next;
145     else
146     {
147         new = xmalloc(sizeof (struct connection));
148         new->ibuf = 0;
149         new->ibufsize = 0;
150     }
151     new->host = host;
152     new->next = new->host->connections;
153     new->host->connections = new;
154     new->client = cl;
155     new->zproxy = 0;
156     client_set_connection(cl, new);
157     new->link = 0;
158     new->state = Conn_Resolving;
159     new->operation_timeout = operation_timeout;
160     new->session_timeout = session_timeout;
161     if (host->ipport)
162         connection_connect(new);
163     return new;
164 }
165
166 static void non_block_events(struct connection *co)
167 {
168     struct client *cl = co->client;
169     IOCHAN iochan = co->iochan;
170     ZOOM_connection link = co->link;
171     while (1)
172     {
173         int ev;
174         int r = ZOOM_event_nonblock(1, &link);
175         if (!r)
176             break;
177         ev = ZOOM_connection_last_event(link);
178 #if 0
179         yaz_log(YLOG_LOG, "ZOOM_EVENT_%s", ZOOM_get_event_str(ev));
180 #endif
181         switch (ev) 
182         {
183         case ZOOM_EVENT_END:
184             {
185                 const char *error, *addinfo;
186                 if (ZOOM_connection_error(link, &error, &addinfo))
187                 {
188                     yaz_log(YLOG_LOG, "Error %s from %s",
189                             error, client_get_url(cl));
190                 }
191                 iochan_settimeout(iochan, co->session_timeout);
192                 client_set_state(cl, Client_Idle);
193             }
194             break;
195         case ZOOM_EVENT_SEND_DATA:
196             break;
197         case ZOOM_EVENT_RECV_DATA:
198             break;
199         case ZOOM_EVENT_UNKNOWN:
200             break;
201         case ZOOM_EVENT_SEND_APDU:
202             client_set_state(co->client, Client_Working);
203             iochan_settimeout(iochan, co->operation_timeout);
204             break;
205         case ZOOM_EVENT_RECV_APDU:
206             break;
207         case ZOOM_EVENT_CONNECT:
208             yaz_log(YLOG_LOG, "Connected to %s", client_get_url(cl));
209             co->state = Conn_Open;
210             break;
211         case ZOOM_EVENT_RECV_SEARCH:
212             client_search_response(cl);
213             break;
214         case ZOOM_EVENT_RECV_RECORD:
215             client_record_response(cl);
216             break;
217         default:
218             yaz_log(YLOG_LOG, "Unhandled event (%d) from %s",
219                     ev, client_get_url(cl));
220         }
221     }
222 }
223
224 void connection_continue(struct connection *co)
225 {
226     non_block_events(co);
227 }
228
229 static void connection_handler(IOCHAN iochan, int event)
230 {
231     struct connection *co = iochan_getdata(iochan);
232     struct client *cl = co->client;
233     struct session *se = 0;
234
235     if (cl)
236         se = client_get_session(cl);
237     else
238     {
239         connection_destroy(co);
240         return;
241     }
242
243     if (event & EVENT_TIMEOUT)
244     {
245         if (co->state == Conn_Connecting)
246         {
247             yaz_log(YLOG_WARN,  "connect timeout %s", client_get_url(cl));
248             client_fatal(cl);
249         }
250         else
251         {
252             yaz_log(YLOG_LOG,  "idle timeout %s", client_get_url(cl));
253             connection_destroy(co);
254         }
255     }
256     else
257     {
258         non_block_events(co);
259
260         ZOOM_connection_fire_event_socket(co->link, event);
261         
262         non_block_events(co);
263     }
264 }
265
266
267 // Disassociate connection from client
268 void connection_release(struct connection *co)
269 {
270     struct client *cl = co->client;
271
272     yaz_log(YLOG_DEBUG, "Connection release %s", co->host->hostport);
273     if (!cl)
274         return;
275     client_set_connection(cl, 0);
276     co->client = 0;
277 }
278
279 void connect_resolver_host(struct host *host)
280 {
281     struct connection *con = host->connections;
282     while (con)
283     {
284         if (con->state == Conn_Resolving)
285         {
286             if (!host->ipport) /* unresolved */
287             {
288                 connection_destroy(con);
289                 /* start all over .. at some point it will be NULL */
290                 con = host->connections;
291                 continue;
292             }
293             else if (!con->client)
294             {
295                 connection_destroy(con);
296                 /* start all over .. at some point it will be NULL */
297                 con = host->connections;
298                 continue;
299             }
300             else
301             {
302                 connection_connect(con);
303                 client_start_search(con->client);
304             }
305         }
306         else
307         {
308             yaz_log(YLOG_LOG, "connect_resolver_host: state=%d", con->state);
309         }
310         con = con->next;
311     }
312 }
313
314 static struct host *connection_get_host(struct connection *con)
315 {
316     return con->host;
317 }
318
319 // Callback for use by event loop
320 // We do this because ZOOM connections don't always have (the same) sockets
321 static int socketfun(IOCHAN c)
322 {
323     struct connection *co = iochan_getdata(c);
324     if (!co->link)
325         return -1;
326     return ZOOM_connection_get_socket(co->link);
327 }
328
329 // Because ZOOM always knows what events it is interested in; we may not
330 static int maskfun(IOCHAN c)
331 {
332     struct connection *co = iochan_getdata(c);
333     if (!co->link)
334         return 0;
335
336     // This is cheating a little, and assuming that eventl mask IDs are always
337     // the same as ZOOM-C's.
338     return ZOOM_connection_get_mask(co->link);
339 }
340
341 static int connection_connect(struct connection *con)
342 {
343     ZOOM_connection link = 0;
344     struct host *host = connection_get_host(con);
345     ZOOM_options zoptions = ZOOM_options_create();
346     const char *auth;
347     const char *sru;
348     const char *sru_version = 0;
349     char ipport[512] = "";
350
351     struct session_database *sdb = client_get_database(con->client);
352     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
353     const char *apdulog = session_setting_oneval(sdb, PZ_APDULOG);
354
355     assert(host->ipport);
356     assert(con);
357
358     ZOOM_options_set(zoptions, "async", "1");
359     ZOOM_options_set(zoptions, "implementationName", PACKAGE_NAME);
360     ZOOM_options_set(zoptions, "implementationVersion", VERSION);
361     if (zproxy && *zproxy)
362     {
363         con->zproxy = xstrdup(zproxy);
364         ZOOM_options_set(zoptions, "proxy", zproxy);
365     }
366     if (apdulog && *apdulog)
367         ZOOM_options_set(zoptions, "apdulog", apdulog);
368
369     if ((auth = session_setting_oneval(sdb, PZ_AUTHENTICATION)))
370         ZOOM_options_set(zoptions, "user", auth);
371     if ((sru = session_setting_oneval(sdb, PZ_SRU)) && *sru)
372         ZOOM_options_set(zoptions, "sru", sru);
373     if ((sru_version = session_setting_oneval(sdb, PZ_SRU_VERSION)) 
374         && *sru_version)
375         ZOOM_options_set(zoptions, "sru_version", sru_version);
376
377     if (!(link = ZOOM_connection_create(zoptions)))
378     {
379         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create ZOOM Connection");
380         ZOOM_options_destroy(zoptions);
381         return -1;
382     }
383
384     if (sru && *sru)
385         strcpy(ipport, "http://");
386     strcat(ipport, host->ipport);
387
388     ZOOM_connection_connect(link, ipport, 0);
389     
390     con->link = link;
391     con->iochan = iochan_create(0, connection_handler, 0);
392     con->state = Conn_Connecting;
393     iochan_settimeout(con->iochan, con->operation_timeout);
394     iochan_setdata(con->iochan, con);
395     iochan_setsocketfun(con->iochan, socketfun);
396     iochan_setmaskfun(con->iochan, maskfun);
397     pazpar2_add_channel(con->iochan);
398
399     /* this fragment is bad DRY: from client_prep_connection */
400     client_set_state(con->client, Client_Connecting);
401     ZOOM_options_destroy(zoptions);
402     return 0;
403 }
404
405 const char *connection_get_url(struct connection *co)
406 {
407     return client_get_url(co->client);
408 }
409
410 // Ensure that client has a connection associated
411 int client_prep_connection(struct client *cl,
412                            int operation_timeout, int session_timeout)
413 {
414     struct connection *co;
415     struct session *se = client_get_session(cl);
416     struct host *host = client_get_host(cl);
417     struct session_database *sdb = client_get_database(cl);
418     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
419
420     if (zproxy && zproxy[0] == '\0')
421         zproxy = 0;
422
423     co = client_get_connection(cl);
424
425     yaz_log(YLOG_DEBUG, "Client prep %s", client_get_url(cl));
426
427     if (!co)
428     {
429         // See if someone else has an idle connection
430         // We should look at timestamps here to select the longest-idle connection
431         for (co = host->connections; co; co = co->next)
432             if (connection_is_idle(co) &&
433                 (!co->client || client_get_session(co->client) != se) &&
434                 !strcmp(ZOOM_connection_option_get(co->link, "user"),
435                         session_setting_oneval(client_get_database(cl),
436                                                PZ_AUTHENTICATION)))
437             {
438                 if (zproxy == 0 && co->zproxy == 0)
439                     break;
440                 if (zproxy && co->zproxy && !strcmp(zproxy, co->zproxy))
441                     break;
442             }
443         if (co)
444         {
445             connection_release(co);
446             client_set_connection(cl, co);
447             co->client = cl;
448             co->operation_timeout = operation_timeout;
449             co->session_timeout = session_timeout;
450             /* tells ZOOM to reconnect if necessary. Disabled becuase
451                the ZOOM_connection_connect flushes the task queue */
452             ZOOM_connection_connect(co->link, 0, 0);
453         }
454         else
455         {
456             co = connection_create(cl, operation_timeout, session_timeout);
457         }
458     }
459
460     if (co && co->link)
461         return 1;
462     else
463         return 0;
464 }
465
466 /*
467  * Local variables:
468  * c-basic-offset: 4
469  * c-file-style: "Stroustrup"
470  * indent-tabs-mode: nil
471  * End:
472  * vim: shiftwidth=4 tabstop=8 expandtab
473  */
474