f17e5dab40bc15ab4568c31e93862a76fe8500e9
[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 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 *new;
136     struct host *host = client_get_host(cl);
137
138     new = xmalloc(sizeof(*new));
139     new->host = host;
140
141     new->client = cl;
142     new->zproxy = 0;
143     client_set_connection(cl, new);
144     new->link = 0;
145     new->state = Conn_Resolving;
146     new->operation_timeout = operation_timeout;
147     new->session_timeout = session_timeout;
148     if (host->ipport)
149         connection_connect(new, iochan_man);
150
151     yaz_mutex_enter(host->mutex);
152     new->next = new->host->connections;
153     new->host->connections = new;
154     yaz_mutex_leave(host->mutex);
155
156     return new;
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 = co->client;
243     struct host *host = co->host;
244
245     yaz_mutex_enter(host->mutex);
246     if (!cl) 
247     {
248         /* no client associated with it.. We are probably getting
249            a closed connection from the target.. Or, perhaps, an unexpected
250            package.. We will just close the connection */
251         yaz_log(YLOG_LOG, "timeout connection %p event=%d", co, event);
252         connection_destroy(co);
253     }
254     else if (event & EVENT_TIMEOUT)
255     {
256         if (co->state == Conn_Connecting)
257         {
258             yaz_log(YLOG_WARN,  "connect timeout %s", client_get_url(cl));
259             client_fatal(cl);
260         }
261         else if (client_get_state(co->client) == Client_Idle)
262         {
263             yaz_log(YLOG_LOG,  "idle timeout %s", client_get_url(cl));
264             connection_destroy(co);
265         }
266         else
267         {
268             yaz_log(YLOG_LOG,  "ignore timeout %s", client_get_url(cl));
269         }
270     }
271     else
272     {
273         non_block_events(co);
274
275         ZOOM_connection_fire_event_socket(co->link, event);
276         
277         non_block_events(co);
278     }
279     yaz_mutex_leave(host->mutex);
280 }
281
282
283 // Disassociate connection from client
284 void connection_release(struct connection *co)
285 {
286     struct client *cl = co->client;
287
288     if (!cl)
289         return;
290     client_set_connection(cl, 0);
291     co->client = 0;
292 }
293
294 void connect_resolver_host(struct host *host, iochan_man_t iochan_man)
295 {
296     struct connection *con;
297
298 start:
299     yaz_mutex_enter(host->mutex);
300     con = host->connections;
301     while (con)
302     {
303         if (con->state == Conn_Resolving)
304         {
305             if (!host->ipport) /* unresolved */
306             {
307                 yaz_mutex_leave(host->mutex);
308                 connection_destroy(con);
309                 goto start;
310                 /* start all over .. at some point it will be NULL */
311             }
312             else if (!con->client)
313             {
314                 yaz_mutex_leave(host->mutex);
315                 connection_destroy(con);
316                 /* start all over .. at some point it will be NULL */
317                 goto start;
318             }
319             else
320             {
321                 yaz_mutex_leave(host->mutex);
322                 connection_connect(con, iochan_man);
323                 client_start_search(con->client);
324                 goto start;
325             }
326         }
327         else
328         {
329             yaz_log(YLOG_LOG, "connect_resolver_host: state=%d", con->state);
330             con = con->next;
331         }
332     }
333     yaz_mutex_leave(host->mutex);
334 }
335
336 static struct host *connection_get_host(struct connection *con)
337 {
338     return con->host;
339 }
340
341 // Callback for use by event loop
342 // We do this because ZOOM connections don't always have (the same) sockets
343 static int socketfun(IOCHAN c)
344 {
345     struct connection *co = iochan_getdata(c);
346     if (!co->link)
347         return -1;
348     return ZOOM_connection_get_socket(co->link);
349 }
350
351 // Because ZOOM always knows what events it is interested in; we may not
352 static int maskfun(IOCHAN c)
353 {
354     struct connection *co = iochan_getdata(c);
355     if (!co->link)
356         return 0;
357
358     // This is cheating a little, and assuming that eventl mask IDs are always
359     // the same as ZOOM-C's.
360     return ZOOM_connection_get_mask(co->link);
361 }
362
363 static int connection_connect(struct connection *con, iochan_man_t iochan_man)
364 {
365     ZOOM_connection link = 0;
366     struct host *host = connection_get_host(con);
367     ZOOM_options zoptions = ZOOM_options_create();
368     const char *auth;
369     const char *charset;
370     const char *sru;
371     const char *sru_version = 0;
372
373     struct session_database *sdb = client_get_database(con->client);
374     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
375     const char *apdulog = session_setting_oneval(sdb, PZ_APDULOG);
376
377     assert(host->ipport);
378     assert(con);
379
380     ZOOM_options_set(zoptions, "async", "1");
381     ZOOM_options_set(zoptions, "implementationName", PACKAGE_NAME);
382     ZOOM_options_set(zoptions, "implementationVersion", VERSION);
383         
384     if ((charset = session_setting_oneval(sdb, PZ_NEGOTIATION_CHARSET)))
385         ZOOM_options_set(zoptions, "charset", charset);
386     
387     if (zproxy && *zproxy)
388     {
389         con->zproxy = xstrdup(zproxy);
390         ZOOM_options_set(zoptions, "proxy", zproxy);
391     }
392     if (apdulog && *apdulog)
393         ZOOM_options_set(zoptions, "apdulog", apdulog);
394
395     if ((auth = session_setting_oneval(sdb, PZ_AUTHENTICATION)))
396         ZOOM_options_set(zoptions, "user", auth);
397     if ((sru = session_setting_oneval(sdb, PZ_SRU)) && *sru)
398         ZOOM_options_set(zoptions, "sru", sru);
399     if ((sru_version = session_setting_oneval(sdb, PZ_SRU_VERSION)) 
400         && *sru_version)
401         ZOOM_options_set(zoptions, "sru_version", sru_version);
402
403     if (!(link = ZOOM_connection_create(zoptions)))
404     {
405         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create ZOOM Connection");
406         ZOOM_options_destroy(zoptions);
407         return -1;
408     }
409
410     if (sru && *sru)
411     {
412         char http_hostport[512];
413         strcpy(http_hostport, "http://");
414         strcat(http_hostport, host->hostport);
415         ZOOM_connection_connect(link, http_hostport, 0);
416     }
417     else
418         ZOOM_connection_connect(link, host->ipport, 0);
419     
420     con->link = link;
421     con->iochan = iochan_create(0, connection_handler, 0, "connection_socket");
422     con->state = Conn_Connecting;
423     iochan_settimeout(con->iochan, con->operation_timeout);
424     iochan_setdata(con->iochan, con);
425     iochan_setsocketfun(con->iochan, socketfun);
426     iochan_setmaskfun(con->iochan, maskfun);
427     iochan_add(iochan_man, con->iochan);
428
429     /* this fragment is bad DRY: from client_prep_connection */
430     client_set_state(con->client, Client_Connecting);
431     ZOOM_options_destroy(zoptions);
432     return 0;
433 }
434
435 const char *connection_get_url(struct connection *co)
436 {
437     return client_get_url(co->client);
438 }
439
440 // Ensure that client has a connection associated
441 int client_prep_connection(struct client *cl,
442                            int operation_timeout, int session_timeout,
443                            iochan_man_t iochan_man)
444 {
445     struct connection *co;
446     struct host *host = client_get_host(cl);
447     struct session_database *sdb = client_get_database(cl);
448     const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
449
450     if (zproxy && zproxy[0] == '\0')
451         zproxy = 0;
452
453     if (!host)
454         return 0;
455
456     co = client_get_connection(cl);
457
458     yaz_log(YLOG_DEBUG, "Client prep %s", client_get_url(cl));
459
460     if (!co)
461     {
462         // See if someone else has an idle connection
463         // We should look at timestamps here to select the longest-idle connection
464         yaz_mutex_enter(host->mutex);
465         for (co = host->connections; co; co = co->next)
466             if (connection_is_idle(co) &&
467                 (!co->client || client_get_state(co->client) == Client_Idle) &&
468                 !strcmp(ZOOM_connection_option_get(co->link, "user"),
469                         session_setting_oneval(client_get_database(cl),
470                                                PZ_AUTHENTICATION)))
471             {
472                 if (zproxy == 0 && co->zproxy == 0)
473                     break;
474                 if (zproxy && co->zproxy && !strcmp(zproxy, co->zproxy))
475                     break;
476             }
477         if (co)
478         {
479             connection_release(co);
480             client_set_connection(cl, co);
481             co->client = cl;
482             /* ensure that connection is only assigned to this client
483                by marking the client non Idle */
484             client_set_state(cl, Client_Working);
485             yaz_mutex_leave(host->mutex);
486             co->operation_timeout = operation_timeout;
487             co->session_timeout = session_timeout;
488             /* tells ZOOM to reconnect if necessary. Disabled becuase
489                the ZOOM_connection_connect flushes the task queue */
490             ZOOM_connection_connect(co->link, 0, 0);
491         }
492         else
493         {
494             yaz_mutex_leave(host->mutex);
495             co = connection_create(cl, operation_timeout, session_timeout,
496                                    iochan_man);
497         }
498     }
499
500     if (co && co->link)
501         return 1;
502     else
503         return 0;
504 }
505
506 /*
507  * Local variables:
508  * c-basic-offset: 4
509  * c-file-style: "Stroustrup"
510  * indent-tabs-mode: nil
511  * End:
512  * vim: shiftwidth=4 tabstop=8 expandtab
513  */
514