4ca648edf1fc101132c446b7343045b01ff39c54
[pazpar2-moved-to-github.git] / src / connection.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2010 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 "session.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 *zproxy;
59     enum {
60         Conn_Resolving,
61         Conn_Connecting,
62         Conn_Open
63     } state;
64     int operation_timeout;
65     int session_timeout;
66     struct connection *next; // next for same host or next in free list
67 };
68
69 static int connection_connect(struct connection *con, iochan_man_t iochan_man);
70
71 static int connection_is_idle(struct connection *co)
72 {
73     ZOOM_connection link = co->link;
74     int event;
75
76     if (co->state != Conn_Open || !link)
77         return 0;
78
79     if (!ZOOM_connection_is_idle(link))
80         return 0;
81     event = ZOOM_connection_peek_event(link);
82     if (event == ZOOM_EVENT_NONE)
83         return 1;
84     else
85         return 0;
86 }
87
88 ZOOM_connection connection_get_link(struct connection *co)
89 {
90     return co->link;
91 }
92
93 static void remove_connection_from_host(struct connection *con)
94 {
95     struct connection **conp = &con->host->connections;
96     assert(con);
97     while (*conp)
98     {
99         if (*conp == con)
100         {
101             *conp = (*conp)->next;
102             break;
103         }
104         conp = &(*conp)->next;
105     }
106 }
107
108 // Close connection and recycle structure
109 static void connection_destroy(struct connection *co)
110 {
111     if (co->link)
112     {
113         ZOOM_connection_destroy(co->link);
114         iochan_destroy(co->iochan);
115     }
116     yaz_log(YLOG_DEBUG, "Connection destroy %s", co->host->hostport);
117
118     if (co->client)
119     {
120         client_disconnect(co->client);
121     }
122
123     remove_connection_from_host(co);
124     xfree(co->zproxy);
125     xfree(co);
126 }
127
128 // Creates a new connection for client, associated with the host of 
129 // client's database
130 static struct connection *connection_create(struct client *cl,
131                                             int operation_timeout,
132                                             int session_timeout,
133                                             iochan_man_t iochan_man)
134 {
135     struct connection *co;
136     struct host *host = client_get_host(cl);
137
138     co = xmalloc(sizeof(*co));
139     co->host = host;
140
141     co->client = cl;
142     co->zproxy = 0;
143     client_set_connection(cl, co);
144     co->link = 0;
145     co->state = Conn_Resolving;
146     co->operation_timeout = operation_timeout;
147     co->session_timeout = session_timeout;
148     if (host->ipport)
149         connection_connect(co, iochan_man);
150
151     yaz_mutex_enter(host->mutex);
152     co->next = co->host->connections;
153     co->host->connections = co;
154     yaz_mutex_leave(host->mutex);
155
156     return co;
157 }
158
159 static void non_block_events(struct connection *co)
160 {
161     int got_records = 0;
162     IOCHAN iochan = co->iochan;
163     ZOOM_connection link = co->link;
164     while (1)
165     {
166         struct client *cl = co->client;
167         int ev;
168         int r = ZOOM_event_nonblock(1, &link);
169         if (!r)
170             break;
171         if (!cl)
172             continue;
173         ev = ZOOM_connection_last_event(link);
174         
175 #if 0
176         yaz_log(YLOG_LOG, "ZOOM_EVENT_%s", ZOOM_get_event_str(ev));
177 #endif
178         switch (ev) 
179         {
180         case ZOOM_EVENT_END:
181             {
182                 const char *error, *addinfo;
183                 int err;
184                 if ((err = ZOOM_connection_error(link, &error, &addinfo)))
185                 {
186                     yaz_log(YLOG_LOG, "Error %s from %s",
187                             error, client_get_url(cl));
188                 }
189                 iochan_settimeout(iochan, co->session_timeout);
190                 client_set_diagnostic(cl, err);
191                 client_set_state(cl, Client_Idle);
192             }
193             break;
194         case ZOOM_EVENT_SEND_DATA:
195             break;
196         case ZOOM_EVENT_RECV_DATA:
197             break;
198         case ZOOM_EVENT_UNKNOWN:
199             break;
200         case ZOOM_EVENT_SEND_APDU:
201             client_set_state(co->client, Client_Working);
202             iochan_settimeout(iochan, co->operation_timeout);
203             break;
204         case ZOOM_EVENT_RECV_APDU:
205             break;
206         case ZOOM_EVENT_CONNECT:
207             yaz_log(YLOG_LOG, "Connected to %s", client_get_url(cl));
208             co->state = Conn_Open;
209             break;
210         case ZOOM_EVENT_RECV_SEARCH:
211             client_search_response(cl);
212             break;
213         case ZOOM_EVENT_RECV_RECORD:
214             client_record_response(cl);
215             got_records = 1;
216             break;
217         default:
218             yaz_log(YLOG_LOG, "Unhandled event (%d) from %s",
219                     ev, client_get_url(cl));
220         }
221     }
222     if (got_records)
223     {
224         struct client *cl = co->client;
225         if (cl)
226         {
227             client_got_records(cl);
228         }
229     }
230 }
231
232 void connection_continue(struct connection *co)
233 {
234     int r = ZOOM_connection_exec_task(co->link);
235     if (!r)
236         yaz_log(YLOG_WARN, "No task was executed for connection");
237 }
238
239 static void connection_handler(IOCHAN iochan, int event)
240 {
241     struct connection *co = iochan_getdata(iochan);
242     struct client *cl;
243     struct host *host = co->host;
244
245     yaz_mutex_enter(host->mutex);
246     cl = co->client;
247     if (!cl) 
248     {
249         /* no client associated with it.. We are probably getting
250            a closed connection from the target.. Or, perhaps, an unexpected
251            package.. We will just close the connection */
252         yaz_log(YLOG_LOG, "timeout connection %p event=%d", co, event);
253         connection_destroy(co);
254         yaz_mutex_leave(host->mutex);
255     }
256     else if (event & EVENT_TIMEOUT)
257     {
258         if (co->state == Conn_Connecting)
259         {
260             yaz_log(YLOG_WARN,  "connect timeout %s", client_get_url(cl));
261
262             client_set_state(cl, Client_Error);
263             connection_destroy(co);
264         }
265         else if (client_get_state(co->client) == Client_Idle)
266         {
267             yaz_log(YLOG_LOG,  "idle timeout %s", client_get_url(cl));
268             connection_destroy(co);
269         }
270         else
271         {
272             yaz_log(YLOG_LOG,  "ignore timeout %s", client_get_url(cl));
273         }
274         yaz_mutex_leave(host->mutex);
275     }
276     else
277     {
278         yaz_mutex_leave(host->mutex);
279
280         client_lock(cl);
281         non_block_events(co);
282
283         ZOOM_connection_fire_event_socket(co->link, event);
284         
285         non_block_events(co);
286         client_unlock(cl);
287     }
288 }
289
290
291 // Disassociate connection from client
292 static void connection_release(struct connection *co)
293 {
294     struct client *cl = co->client;
295
296     if (!cl)
297         return;
298     client_set_connection(cl, 0);
299     co->client = 0;
300 }
301
302 void connect_resolver_host(struct host *host, iochan_man_t iochan_man)
303 {
304     struct connection *con;
305
306 start:
307     yaz_mutex_enter(host->mutex);
308     con = host->connections;
309     while (con)
310     {
311         if (con->state == Conn_Resolving)
312         {
313             if (!host->ipport) /* unresolved */
314             {
315                 yaz_mutex_leave(host->mutex);
316                 connection_destroy(con);
317                 goto start;
318                 /* start all over .. at some point it will be NULL */
319             }
320             else if (!con->client)
321             {
322                 yaz_mutex_leave(host->mutex);
323                 connection_destroy(con);
324                 /* start all over .. at some point it will be NULL */
325                 goto start;
326             }
327             else
328             {
329                 yaz_mutex_leave(host->mutex);
330                 connection_connect(con, iochan_man);
331                 client_start_search(con->client);
332                 goto start;
333             }
334         }
335         else
336         {
337             yaz_log(YLOG_LOG, "connect_resolver_host: state=%d", con->state);
338             con = con->next;
339         }
340     }
341     yaz_mutex_leave(host->mutex);
342 }
343
344 static struct host *connection_get_host(struct connection *con)
345 {
346     return con->host;
347 }
348
349 // Callback for use by event loop
350 // We do this because ZOOM connections don't always have (the same) sockets
351 static int socketfun(IOCHAN c)
352 {
353     struct connection *co = iochan_getdata(c);
354     if (!co->link)
355         return -1;
356     return ZOOM_connection_get_socket(co->link);
357 }
358
359 // Because ZOOM always knows what events it is interested in; we may not
360 static int maskfun(IOCHAN c)
361 {
362     struct connection *co = iochan_getdata(c);
363     if (!co->link)
364         return 0;
365
366     // This is cheating a little, and assuming that eventl mask IDs are always
367     // the same as ZOOM-C's.
368     return ZOOM_connection_get_mask(co->link);
369 }
370
371 static int connection_connect(struct connection *con, iochan_man_t iochan_man)
372 {
373     ZOOM_connection link = 0;
374     struct host *host = connection_get_host(con);
375     ZOOM_options zoptions = ZOOM_options_create();
376     const char *auth;
377     const char *charset;
378     const char *sru;
379     const char *sru_version = 0;
380
381     struct session_database *sdb = client_get_database(con->client);
382     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
383     const char *apdulog = session_setting_oneval(sdb, PZ_APDULOG);
384
385     assert(host->ipport);
386     assert(con);
387
388     ZOOM_options_set(zoptions, "async", "1");
389     ZOOM_options_set(zoptions, "implementationName", PACKAGE_NAME);
390     ZOOM_options_set(zoptions, "implementationVersion", VERSION);
391         
392     if ((charset = session_setting_oneval(sdb, PZ_NEGOTIATION_CHARSET)))
393         ZOOM_options_set(zoptions, "charset", charset);
394     
395     if (zproxy && *zproxy)
396     {
397         con->zproxy = xstrdup(zproxy);
398         ZOOM_options_set(zoptions, "proxy", zproxy);
399     }
400     if (apdulog && *apdulog)
401         ZOOM_options_set(zoptions, "apdulog", apdulog);
402
403     if ((auth = session_setting_oneval(sdb, PZ_AUTHENTICATION)))
404         ZOOM_options_set(zoptions, "user", auth);
405     if ((sru = session_setting_oneval(sdb, PZ_SRU)) && *sru)
406         ZOOM_options_set(zoptions, "sru", sru);
407     if ((sru_version = session_setting_oneval(sdb, PZ_SRU_VERSION)) 
408         && *sru_version)
409         ZOOM_options_set(zoptions, "sru_version", sru_version);
410
411     if (!(link = ZOOM_connection_create(zoptions)))
412     {
413         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create ZOOM Connection");
414         ZOOM_options_destroy(zoptions);
415         return -1;
416     }
417
418     if (sru && *sru)
419     {
420         char http_hostport[512];
421         strcpy(http_hostport, "http://");
422         strcat(http_hostport, host->hostport);
423         ZOOM_connection_connect(link, http_hostport, 0);
424     }
425     else
426         ZOOM_connection_connect(link, host->ipport, 0);
427     
428     con->link = link;
429     con->iochan = iochan_create(0, connection_handler, 0, "connection_socket");
430     con->state = Conn_Connecting;
431     iochan_settimeout(con->iochan, con->operation_timeout);
432     iochan_setdata(con->iochan, con);
433     iochan_setsocketfun(con->iochan, socketfun);
434     iochan_setmaskfun(con->iochan, maskfun);
435     iochan_add(iochan_man, con->iochan);
436
437     /* this fragment is bad DRY: from client_prep_connection */
438     client_set_state(con->client, Client_Connecting);
439     ZOOM_options_destroy(zoptions);
440     return 0;
441 }
442
443 // Ensure that client has a connection associated
444 int client_prep_connection(struct client *cl,
445                            int operation_timeout, int session_timeout,
446                            iochan_man_t iochan_man)
447 {
448     struct connection *co;
449     struct host *host = client_get_host(cl);
450     struct session_database *sdb = client_get_database(cl);
451     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
452
453     if (zproxy && zproxy[0] == '\0')
454         zproxy = 0;
455
456     if (!host)
457         return 0;
458
459     co = client_get_connection(cl);
460
461     yaz_log(YLOG_DEBUG, "Client prep %s", client_get_url(cl));
462
463     if (!co)
464     {
465         // See if someone else has an idle connection
466         // We should look at timestamps here to select the longest-idle connection
467         yaz_mutex_enter(host->mutex);
468         for (co = host->connections; co; co = co->next)
469             if (connection_is_idle(co) &&
470                 (!co->client || client_get_state(co->client) == Client_Idle) &&
471                 !strcmp(ZOOM_connection_option_get(co->link, "user"),
472                         session_setting_oneval(client_get_database(cl),
473                                                PZ_AUTHENTICATION)))
474             {
475                 if (zproxy == 0 && co->zproxy == 0)
476                     break;
477                 if (zproxy && co->zproxy && !strcmp(zproxy, co->zproxy))
478                     break;
479             }
480         if (co)
481         {
482             connection_release(co);
483             client_set_connection(cl, co);
484             co->client = cl;
485             /* ensure that connection is only assigned to this client
486                by marking the client non Idle */
487             client_set_state(cl, Client_Working);
488             yaz_mutex_leave(host->mutex);
489             co->operation_timeout = operation_timeout;
490             co->session_timeout = session_timeout;
491             /* tells ZOOM to reconnect if necessary. Disabled becuase
492                the ZOOM_connection_connect flushes the task queue */
493             ZOOM_connection_connect(co->link, 0, 0);
494         }
495         else
496         {
497             yaz_mutex_leave(host->mutex);
498             co = connection_create(cl, operation_timeout, session_timeout,
499                                    iochan_man);
500         }
501     }
502
503     if (co && co->link)
504         return 1;
505     else
506         return 0;
507 }
508
509 /*
510  * Local variables:
511  * c-basic-offset: 4
512  * c-file-style: "Stroustrup"
513  * indent-tabs-mode: nil
514  * End:
515  * vim: shiftwidth=4 tabstop=8 expandtab
516  */
517