ffe6b6d853fedbf3ccdffe737e2cc54f3ead3563
[pazpar2-moved-to-github.git] / src / http_command.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2011 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 #if HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <sys/types.h>
25 #if HAVE_UNISTD_H
26 #include <unistd.h>
27 #endif
28 #include <stdlib.h>
29 #include <string.h>
30 #if HAVE_SYS_TIME_H
31 #include <sys/time.h>
32 #endif
33 #include <yaz/snprintf.h>
34 #include <yaz/yaz-util.h>
35
36 #include "ppmutex.h"
37 #include "eventl.h"
38 #include "parameters.h"
39 #include "session.h"
40 #include "http.h"
41 #include "settings.h"
42 #include "client.h"
43
44 #ifdef HAVE_MALLINFO
45 #include <malloc.h>
46
47 void print_meminfo(WRBUF wrbuf)
48 {
49     struct mallinfo minfo;
50     minfo = mallinfo();
51     wrbuf_printf(wrbuf, "  <memory>\n"
52                         "   <arena>%d</arena>\n" 
53                         "   <uordblks>%d</uordblks>\n"
54                         "   <fordblks>%d</fordblks>\n"
55                         "   <ordblks>%d</ordblks>\n"
56                         "   <keepcost>%d</keepcost>\n"
57                         "   <hblks>%d</hblks>\n" 
58                         "   <hblkhd>%d</hblkhd>\n"
59                         "   <virt>%d</virt>\n"
60                         "   <virtuse>%d</virtuse>\n"
61                         "  </memory>\n", 
62                  minfo.arena, minfo.uordblks, minfo.fordblks,minfo.ordblks, minfo.keepcost, minfo.hblks, minfo.hblkhd, minfo.arena + minfo.hblkhd, minfo.uordblks + minfo.hblkhd);
63
64 }
65 #else
66 #define print_meminfo(x)
67 #endif
68
69
70 // Update this when the protocol changes
71 #define PAZPAR2_PROTOCOL_VERSION "1"
72
73 #define HTTP_COMMAND_RESPONSE_PREFIX "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
74
75 struct http_session {
76     IOCHAN timeout_iochan;     // NOTE: This is NOT associated with a socket
77     struct session *psession;
78     unsigned int session_id;
79     int timestamp;
80     int destroy_counter;
81     int activity_counter;
82     NMEM nmem;
83     http_sessions_t http_sessions;
84     struct http_session *next;
85 };
86
87 struct http_sessions {
88     struct http_session *session_list;
89     YAZ_MUTEX mutex;
90     int log_level;
91 };
92
93 static YAZ_MUTEX g_http_session_mutex = 0;
94 static int g_http_sessions = 0;
95
96 int http_session_use(int delta)
97 {
98     int sessions;
99     if (!g_http_session_mutex)
100         yaz_mutex_create(&g_http_session_mutex);
101     yaz_mutex_enter(g_http_session_mutex);
102     g_http_sessions += delta;
103     sessions = g_http_sessions;
104     yaz_mutex_leave(g_http_session_mutex);
105     yaz_log(YLOG_DEBUG, "%s sessions=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), sessions);
106     return sessions;
107
108 }
109
110 http_sessions_t http_sessions_create(void)
111 {
112     http_sessions_t hs = xmalloc(sizeof(*hs));
113     hs->session_list = 0;
114     hs->mutex = 0;
115     pazpar2_mutex_create(&hs->mutex, "http_sessions");
116     hs->log_level = yaz_log_module_level("HTTP");
117     return hs;
118 }
119
120 void http_sessions_destroy(http_sessions_t hs)
121 {
122     if (hs)
123     {
124         struct http_session *s = hs->session_list;
125         while (s)
126         {
127             struct http_session *s_next = s->next;
128             iochan_destroy(s->timeout_iochan);
129             session_destroy(s->psession);
130             nmem_destroy(s->nmem);
131             s = s_next;
132         }
133         yaz_mutex_destroy(&hs->mutex);
134         xfree(hs);
135     }
136 }
137
138 void http_session_destroy(struct http_session *s);
139
140 static void session_timeout(IOCHAN i, int event)
141 {
142     struct http_session *s = iochan_getdata(i);
143     http_session_destroy(s);
144 }
145
146 struct http_session *http_session_create(struct conf_service *service,
147                                          http_sessions_t http_sessions,
148                                          unsigned int sesid)
149 {
150     NMEM nmem = nmem_create();
151     struct http_session *r = nmem_malloc(nmem, sizeof(*r));
152     char tmp_str[50];
153
154     sprintf(tmp_str, "session#%u", sesid);
155     r->psession = new_session(nmem, service, sesid);
156     r->session_id = sesid;
157     r->timestamp = 0;
158     r->nmem = nmem;
159     r->destroy_counter = r->activity_counter = 0;
160     r->http_sessions = http_sessions;
161
162     yaz_mutex_enter(http_sessions->mutex);
163     r->next = http_sessions->session_list;
164     http_sessions->session_list = r;
165     yaz_mutex_leave(http_sessions->mutex);
166
167     r->timeout_iochan = iochan_create(-1, session_timeout, 0, "http_session_timeout");
168     iochan_setdata(r->timeout_iochan, r);
169     yaz_log(http_sessions->log_level, "%p Session %u created. timeout chan=%p timeout=%d", r, sesid, r->timeout_iochan, service->session_timeout);
170     iochan_settimeout(r->timeout_iochan, service->session_timeout);
171
172     iochan_add(service->server->iochan_man, r->timeout_iochan);
173     http_session_use(1);
174     return r;
175 }
176
177 void http_session_destroy(struct http_session *s)
178 {
179     int must_destroy = 0;
180
181     http_sessions_t http_sessions = s->http_sessions;
182
183     yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed", s, s->session_id);
184     yaz_mutex_enter(http_sessions->mutex);
185     /* only if http_session has no active http sessions on it can be destroyed */
186     if (s->destroy_counter == s->activity_counter)
187     {
188         struct http_session **p = 0;
189         must_destroy = 1;
190         for (p = &http_sessions->session_list; *p; p = &(*p)->next)
191             if (*p == s)
192             {
193                 *p = (*p)->next;
194                 break;
195             }
196     }
197     yaz_mutex_leave(http_sessions->mutex);
198     if (must_destroy)
199     {   /* destroying for real */
200         yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed", s, s->session_id);
201         iochan_destroy(s->timeout_iochan);
202         session_destroy(s->psession);
203         http_session_use(-1);
204         nmem_destroy(s->nmem);
205     }
206     else {
207         yaz_log(http_sessions->log_level, "%p HTTP Session %u destroyed delayed. Active clients (%d-%d). Waiting for new timeout.",
208                 s, s->session_id, s->activity_counter, s->destroy_counter);
209     }
210
211 }
212
213 static const char *get_msg(enum pazpar2_error_code code)
214 {
215     struct pazpar2_error_msg {
216         enum pazpar2_error_code code;
217         const char *msg;
218     };
219     static const struct pazpar2_error_msg ar[] = {
220         { PAZPAR2_NO_SESSION, "Session does not exist or it has expired"},
221         { PAZPAR2_MISSING_PARAMETER, "Missing parameter"},
222         { PAZPAR2_MALFORMED_PARAMETER_VALUE, "Malformed parameter value"},
223         { PAZPAR2_MALFORMED_PARAMETER_ENCODING, "Malformed parameter encoding"},
224         { PAZPAR2_MALFORMED_SETTING, "Malformed setting argument"},
225         { PAZPAR2_HITCOUNTS_FAILED, "Failed to retrieve hitcounts"},
226         { PAZPAR2_RECORD_MISSING, "Record missing"},
227         { PAZPAR2_NO_TARGETS, "No targets"},
228         { PAZPAR2_CONFIG_TARGET, "Target cannot be configured"},
229         { PAZPAR2_RECORD_FAIL, "Record command failed"},
230         { PAZPAR2_NOT_IMPLEMENTED, "Not implemented"},
231         { PAZPAR2_NO_SERVICE, "No service"},
232         { PAZPAR2_ALREADY_BLOCKED, "Already blocked in session on: "},
233         { PAZPAR2_LAST_ERROR, "Last error"},
234         { 0, 0 }
235     };
236     int i = 0;
237     while (ar[i].msg)
238     {
239         if (code == ar[i].code)
240             return ar[i].msg;
241         i++;
242     }
243     return "No error";
244 }
245
246 static void error(struct http_response *rs, 
247                   enum pazpar2_error_code code,
248                   const char *addinfo)
249 {
250     struct http_channel *c = rs->channel;
251     WRBUF text = wrbuf_alloc();
252     const char *http_status = "417";
253     const char *msg = get_msg(code);
254     
255     rs->msg = nmem_strdup(c->nmem, msg);
256     strcpy(rs->code, http_status);
257
258     wrbuf_printf(text, HTTP_COMMAND_RESPONSE_PREFIX "<error code=\"%d\" msg=\"%s\">", (int) code,
259                msg);
260     if (addinfo)
261         wrbuf_xmlputs(text, addinfo);
262     wrbuf_puts(text, "</error>");
263
264     yaz_log(YLOG_WARN, "HTTP %s %s%s%s", http_status,
265             msg, addinfo ? ": " : "" , addinfo ? addinfo : "");
266     rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(text));
267     wrbuf_destroy(text);
268     http_send_response(c);
269 }
270
271 static void response_open_no_status(struct http_channel *c, const char *command)
272 {
273     wrbuf_rewind(c->wrbuf);
274     wrbuf_printf(c->wrbuf, "%s<%s>",
275                  HTTP_COMMAND_RESPONSE_PREFIX, command);
276 }
277
278 static void response_open(struct http_channel *c, const char *command)
279 {
280     response_open_no_status(c, command);
281     wrbuf_puts(c->wrbuf, "<status>OK</status>");
282 }
283
284 static void response_close(struct http_channel *c, const char *command)
285 {
286     struct http_response *rs = c->response;
287
288     wrbuf_printf(c->wrbuf, "</%s>", command);
289     rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
290     http_send_response(c);
291 }
292
293 unsigned int make_sessionid(void)
294 {
295     static int seq = 0; /* thread pr */
296     unsigned int res;
297
298     seq++;
299     if (global_parameters.predictable_sessions)
300         res = seq;
301     else
302     {
303 #ifdef WIN32
304         res = seq;
305 #else
306         struct timeval t;
307
308         if (gettimeofday(&t, 0) < 0)
309         {
310             yaz_log(YLOG_WARN|YLOG_ERRNO, "gettimeofday");
311             exit(1);
312         }
313         /* at most 256 sessions per second .. 
314            (long long would be more appropriate)*/
315         res = t.tv_sec;
316         res = ((res << 8) | (seq & 0xff)) & ((1U << 31) - 1);
317 #endif
318     }
319     return res;
320 }
321
322 static struct http_session *locate_session(struct http_channel *c)
323 {
324     struct http_request *rq = c->request;
325     struct http_response *rs = c->response;
326     struct http_session *p;
327     const char *session = http_argbyname(rq, "session");
328     http_sessions_t http_sessions = c->http_sessions;
329     unsigned int id;
330
331     if (!session)
332     {
333         error(rs, PAZPAR2_MISSING_PARAMETER, "session");
334         return 0;
335     }
336     id = atoi(session);
337     yaz_mutex_enter(http_sessions->mutex);
338     for (p = http_sessions->session_list; p; p = p->next)
339         if (id == p->session_id)
340             break;
341     if (p)
342         p->activity_counter++;
343     yaz_mutex_leave(http_sessions->mutex);
344     if (p)
345         iochan_activity(p->timeout_iochan);
346     else
347         error(rs, PAZPAR2_NO_SESSION, session);
348     return p;
349 }
350
351 // Call after use of locate_session, in order to increment the destroy_counter
352 static void release_session(struct http_channel *c,
353                             struct http_session *session)
354 {
355     http_sessions_t http_sessions = c->http_sessions;
356     yaz_mutex_enter(http_sessions->mutex);
357     if (session)
358         session->destroy_counter++;
359     yaz_mutex_leave(http_sessions->mutex);
360 }
361
362 // Decode settings parameters and apply to session
363 // Syntax: setting[target]=value
364 static int process_settings(struct session *se, struct http_request *rq,
365                             struct http_response *rs)
366 {
367     struct http_argument *a;
368
369     for (a = rq->arguments; a; a = a->next)
370         if (strchr(a->name, '['))
371         {
372             char **res;
373             int num;
374             char *dbname;
375             char *setting;
376
377             // Nmem_strsplit *rules*!!!
378             nmem_strsplit(se->session_nmem, "[]", a->name, &res, &num);
379             if (num != 2)
380             {
381                 error(rs, PAZPAR2_MALFORMED_SETTING, a->name);
382                 return -1;
383             }
384             setting = res[0];
385             dbname = res[1];
386             session_apply_setting(se, dbname, setting,
387                     nmem_strdup(se->session_nmem, a->value));
388         }
389     return 0;
390 }
391
392 static void cmd_exit(struct http_channel *c)
393 {
394     yaz_log(YLOG_WARN, "exit");
395
396     response_open(c, "exit");
397     response_close(c, "exit");
398     http_close_server(c->server);
399 }
400
401 static void cmd_init(struct http_channel *c)
402 {
403     struct http_request *r = c->request;
404     const char *clear = http_argbyname(r, "clear");
405     const char *content_type = http_lookup_header(r->headers, "Content-Type");
406     unsigned int sesid;
407     struct http_session *s;
408     struct http_response *rs = c->response;
409     struct conf_service *service = 0; /* no service (yet) */
410     
411     if (r->content_len && content_type && 
412         !yaz_strcmp_del("text/xml", content_type, "; "))
413     {
414         xmlDoc *doc = xmlParseMemory(r->content_buf, r->content_len);
415         xmlNode *root_n;
416         if (!doc)
417         {
418             error(rs, PAZPAR2_MALFORMED_SETTING, 0);
419             return;
420         }
421         root_n = xmlDocGetRootElement(doc);
422         service = service_create(c->server, root_n);
423         xmlFreeDoc(doc);
424         if (!service)
425         {
426             error(rs, PAZPAR2_MALFORMED_SETTING, 0);
427             return;
428         }
429     }
430     
431     if (!service)
432     {
433         const char *service_name = http_argbyname(c->request, "service");
434         service = locate_service(c->server, service_name);
435         if (!service)
436         {
437             error(rs, PAZPAR2_NO_SERVICE, service_name ? service_name : "unnamed");
438             return;
439         }
440     }
441     sesid = make_sessionid();
442     s = http_session_create(service, c->http_sessions, sesid);
443     
444     yaz_log(c->http_sessions->log_level, "%p Session init %u ", s, sesid);
445     if (!clear || *clear == '0')
446         session_init_databases(s->psession);
447     else
448         yaz_log(YLOG_LOG, "HTTP Session %u init: No databases preloaded", sesid);
449     
450     if (process_settings(s->psession, c->request, c->response) < 0)
451         return;
452
453     response_open(c, "init");
454     wrbuf_printf(c->wrbuf, "<session>%d", sesid);
455     if (c->server->server_id)
456     {
457         wrbuf_puts(c->wrbuf, ".");
458         wrbuf_puts(c->wrbuf, c->server->server_id);
459     }
460     wrbuf_puts(c->wrbuf, "</session>"
461                "<protocol>" PAZPAR2_PROTOCOL_VERSION "</protocol>");
462     
463     response_close(c, "init");
464 }
465
466 static void apply_local_setting(void *client_data,
467                                 struct setting *set)
468 {
469     struct session *se =  (struct session *) client_data;
470
471     session_apply_setting(se, nmem_strdup(se->session_nmem, set->target),
472                           nmem_strdup(se->session_nmem, set->name),
473                           nmem_strdup(se->session_nmem, set->value));
474 }
475
476 static void cmd_settings(struct http_channel *c)
477 {
478     struct http_response *rs = c->response;
479     struct http_request *rq = c->request;
480     struct http_session *s = locate_session(c);
481     const char *content_type = http_lookup_header(rq->headers, "Content-Type");
482
483     if (!s)
484         return;
485
486     if (rq->content_len && content_type && 
487         !yaz_strcmp_del("text/xml", content_type, "; "))
488     {
489         xmlDoc *doc = xmlParseMemory(rq->content_buf, rq->content_len);
490         xmlNode *root_n;
491         if (!doc)
492         {
493             error(rs, PAZPAR2_MALFORMED_SETTING, 0);
494             return;
495         }
496         root_n = xmlDocGetRootElement(doc);
497
498         settings_read_node_x(root_n, s->psession, apply_local_setting);
499
500         xmlFreeDoc(doc);
501     }
502     if (process_settings(s->psession, rq, rs) < 0)
503     {
504         release_session(c, s);
505         return;
506     }
507     response_open(c, "settings");
508     response_close(c, "settings");
509     release_session(c, s);
510 }
511
512 static void termlist_response(struct http_channel *c)
513 {
514     struct http_request *rq = c->request;
515     struct http_session *s = locate_session(c);
516     const char *name = http_argbyname(rq, "name");
517     const char *nums = http_argbyname(rq, "num");
518     int num = 15;
519     int status;
520
521     if (nums)
522         num = atoi(nums);
523
524     status = session_active_clients(s->psession);
525
526     response_open_no_status(c, "termlist");
527     wrbuf_printf(c->wrbuf, "<activeclients>%d</activeclients>\n", status);
528
529     perform_termlist(c, s->psession, name, num);
530
531     response_close(c, "termlist");
532     release_session(c, s);
533 }
534
535 static void termlist_result_ready(void *data)
536 {
537     struct http_channel *c = (struct http_channel *) data;
538     yaz_log(c->http_sessions->log_level, "termlist watch released");
539     termlist_response(c);
540 }
541
542 static void cmd_termlist(struct http_channel *c)
543 {
544     struct http_request *rq = c->request;
545     struct http_response *rs = c->response;
546     struct http_session *s = locate_session(c);
547     const char *block = http_argbyname(rq, "block");
548     int active_clients;
549     if (!s)
550         return;
551
552     active_clients = session_active_clients(s->psession);
553
554     if (block && !strcmp("1", block) && active_clients)
555     {
556         // if there is already a watch/block. we do not block this one
557         if (session_set_watch(s->psession, SESSION_WATCH_TERMLIST,
558                               termlist_result_ready, c, c) != 0)
559         {
560             yaz_log(YLOG_WARN, "Attempt to block multiple times on termlist block. Not supported!");
561             error(rs, PAZPAR2_ALREADY_BLOCKED, "termlist");
562         }
563         else
564         {
565             yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command termlist", s, s->session_id);
566         }
567         release_session(c, s);
568         return;
569     }
570
571     termlist_response(c);
572     release_session(c, s);
573 }
574
575 size_t session_get_memory_status(struct session *session);
576
577 static void session_status(struct http_channel *c, struct http_session *s)
578 {
579     size_t session_nmem;
580     wrbuf_printf(c->wrbuf, "<http_count>%u</http_count>\n", s->activity_counter);
581     wrbuf_printf(c->wrbuf, "<http_nmem>%zu</http_nmem>\n", nmem_total(s->nmem) );
582     session_nmem = session_get_memory_status(s->psession);
583     wrbuf_printf(c->wrbuf, "<session_nmem>%zu</session_nmem>\n", session_nmem);
584 }
585
586 static void cmd_session_status(struct http_channel *c)
587 {
588     struct http_session *s = locate_session(c);
589     if (!s)
590         return;
591
592     response_open(c, "session-status");
593     session_status(c, s);
594     response_close(c, "session-status");
595     release_session(c, s);
596 }
597
598 int sessions_count(void);
599 int clients_count(void);
600 #ifdef HAVE_RESULTSETS_COUNT
601 int resultsets_count(void);
602 #else
603 #define resultsets_count()      0
604 #endif
605
606 static void cmd_server_status(struct http_channel *c)
607 {
608     int sessions   = sessions_count();
609     int clients    = clients_count();
610     int resultsets = resultsets_count();
611
612     response_open(c, "server-status");
613     wrbuf_printf(c->wrbuf, "\n  <sessions>%u</sessions>\n", sessions);
614     wrbuf_printf(c->wrbuf, "  <clients>%u</clients>\n",   clients);
615     /* Only works if yaz has been compiled with enabling of this */
616     wrbuf_printf(c->wrbuf, "  <resultsets>%u</resultsets>\n",resultsets);
617     print_meminfo(c->wrbuf);
618
619 /* TODO add all sessions status                         */
620 /*    http_sessions_t http_sessions = c->http_sessions; */
621 /*    struct http_session *p;                           */
622 /*
623     yaz_mutex_enter(http_sessions->mutex);
624     for (p = http_sessions->session_list; p; p = p->next)
625     {
626         p->activity_counter++;
627         wrbuf_puts(c->wrbuf, "<session-status>\n");
628         wrbuf_printf(c->wrbuf, "<id>%s</id>\n", p->session_id);
629         yaz_mutex_leave(http_sessions->mutex);
630         session_status(c, p);
631         wrbuf_puts(c->wrbuf, "</session-status>\n");
632         yaz_mutex_enter(http_sessions->mutex);
633         p->activity_counter--;
634     }
635     yaz_mutex_leave(http_sessions->mutex);
636 */
637     response_close(c, "server-status");
638     xmalloc_trav(0);
639 }
640
641 static void bytarget_response(struct http_channel *c) {
642     int count, i;
643     struct hitsbytarget *ht;
644     struct http_request *rq = c->request;
645     const char *settings = http_argbyname(rq, "settings");
646     struct http_session *s = locate_session(c);
647
648     ht = get_hitsbytarget(s->psession, &count, c->nmem);
649     response_open(c, "bytarget");
650     if (count == 0)
651         yaz_log(YLOG_WARN, "Empty bytarget Response. No targets found!");
652     for (i = 0; i < count; i++)
653     {
654         wrbuf_puts(c->wrbuf, "\n<target>");
655
656         wrbuf_puts(c->wrbuf, "<id>");
657         wrbuf_xmlputs(c->wrbuf, ht[i].id);
658         wrbuf_puts(c->wrbuf, "</id>\n");
659
660         if (ht[i].name && ht[i].name[0]) 
661         {
662             wrbuf_puts(c->wrbuf, "<name>");
663             wrbuf_xmlputs(c->wrbuf, ht[i].name);
664             wrbuf_puts(c->wrbuf, "</name>\n");
665         }
666
667         wrbuf_printf(c->wrbuf, "<hits>" ODR_INT_PRINTF "</hits>\n", ht[i].hits);
668         wrbuf_printf(c->wrbuf, "<diagnostic>%d</diagnostic>\n", ht[i].diagnostic);
669         wrbuf_printf(c->wrbuf, "<records>%d</records>\n", ht[i].records);
670
671         wrbuf_puts(c->wrbuf, "<state>");
672         wrbuf_xmlputs(c->wrbuf, ht[i].state);
673         wrbuf_puts(c->wrbuf, "</state>\n");
674         if (settings && *settings == '1')
675         {
676             wrbuf_puts(c->wrbuf, "<settings>\n");
677             wrbuf_puts(c->wrbuf, ht[i].settings_xml);
678             wrbuf_puts(c->wrbuf, "</settings>\n");
679         }
680         if (ht[i].suggestions_xml && ht[i].suggestions_xml[0]) {
681             wrbuf_puts(c->wrbuf, "<suggestions>");
682             wrbuf_puts(c->wrbuf, ht[i].suggestions_xml);
683             wrbuf_puts(c->wrbuf, "</suggestions>");
684         }
685         wrbuf_puts(c->wrbuf, "</target>");
686     }
687     response_close(c, "bytarget");
688     release_session(c, s);
689 }
690
691 static void bytarget_result_ready(void *data)
692 {
693     struct http_channel *c = (struct http_channel *) data;
694     yaz_log(c->http_sessions->log_level, "bytarget watch released");
695     bytarget_response(c);
696 }
697
698
699 static void cmd_bytarget(struct http_channel *c)
700 {
701     struct http_request *rq = c->request;
702     struct http_response *rs = c->response;
703     struct http_session *s = locate_session(c);
704     const char *block = http_argbyname(rq, "block");
705     int no_active;
706
707     if (!s)
708         return;
709
710     no_active = session_active_clients(s->psession);
711
712     if (block && !strcmp("1",block) && no_active)
713     {
714         // if there is already a watch/block. we do not block this one
715         if (session_set_watch(s->psession, SESSION_WATCH_BYTARGET,
716                               bytarget_result_ready, c, c) != 0)
717         {
718             yaz_log(YLOG_WARN, "Attempt to block multiple times on bytarget block. Not supported!");
719             error(rs, PAZPAR2_ALREADY_BLOCKED, "bytarget"); 
720         }
721         else
722         {
723             yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command bytarget", s, s->session_id);
724         }
725         release_session(c, s);
726         return;
727     }
728     bytarget_response(c);
729     release_session(c, s);
730 }
731
732 static void write_metadata(WRBUF w, struct conf_service *service,
733         struct record_metadata **ml, int full)
734 {
735     int imeta;
736
737     for (imeta = 0; imeta < service->num_metadata; imeta++)
738     {
739         struct conf_metadata *cmd = &service->metadata[imeta];
740         struct record_metadata *md;
741         if (!cmd->brief && !full)
742             continue;
743         for (md = ml[imeta]; md; md = md->next)
744         {
745             struct record_metadata_attr *attr = md->attributes;
746             wrbuf_printf(w, "\n<md-%s", cmd->name);
747
748             for (; attr; attr = attr->next)
749             {
750                 wrbuf_printf(w, " %s=\"", attr->name);
751                 wrbuf_xmlputs(w, attr->value);
752                 wrbuf_puts(w, "\"");
753             }
754             wrbuf_puts(w, ">");
755             switch (cmd->type)
756             {
757                 case Metadata_type_generic:
758                     wrbuf_xmlputs(w, md->data.text.disp);
759                     break;
760                 case Metadata_type_year:
761                     wrbuf_printf(w, "%d", md->data.number.min);
762                     if (md->data.number.min != md->data.number.max)
763                         wrbuf_printf(w, "-%d", md->data.number.max);
764                     break;
765                 default:
766                     wrbuf_puts(w, "[can't represent]");
767             }
768             wrbuf_printf(w, "</md-%s>", cmd->name);
769         }
770     }
771 }
772
773 static void write_subrecord(struct record *r, WRBUF w,
774         struct conf_service *service, int show_details)
775 {
776     const char *name = session_setting_oneval(
777         client_get_database(r->client), PZ_NAME);
778
779     wrbuf_puts(w, "<location id=\"");
780     wrbuf_xmlputs(w, client_get_id(r->client));
781     wrbuf_puts(w, "\" ");
782
783     wrbuf_puts(w, "name=\"");
784     wrbuf_xmlputs(w,  *name ? name : "Unknown");
785     wrbuf_puts(w, "\">");
786
787     write_metadata(w, service, r->metadata, show_details);
788     wrbuf_puts(w, "</location>\n");
789 }
790
791 static void show_raw_record_error(void *data, const char *addinfo)
792 {
793     http_channel_observer_t obs = data;
794     struct http_channel *c = http_channel_observer_chan(obs);
795     struct http_response *rs = c->response;
796
797     http_remove_observer(obs);
798
799     error(rs, PAZPAR2_RECORD_FAIL, addinfo);
800 }
801
802 static void show_raw_record_ok(void *data, const char *buf, size_t sz)
803 {
804     http_channel_observer_t obs = data;
805     struct http_channel *c = http_channel_observer_chan(obs);
806     struct http_response *rs = c->response;
807
808     http_remove_observer(obs);
809
810     wrbuf_write(c->wrbuf, buf, sz);
811     rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
812     http_send_response(c);
813 }
814
815
816 static void show_raw_record_ok_binary(void *data, const char *buf, size_t sz)
817 {
818     http_channel_observer_t obs = data;
819     struct http_channel *c = http_channel_observer_chan(obs);
820     struct http_response *rs = c->response;
821
822     http_remove_observer(obs);
823
824     wrbuf_write(c->wrbuf, buf, sz);
825     rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
826
827     rs->content_type = "application/octet-stream";
828     http_send_response(c);
829 }
830
831
832 void show_raw_reset(void *data, struct http_channel *c, void *data2)
833 {
834     //struct client *client = data;
835     //client_show_raw_remove(client, data2);
836 }
837
838 static void cmd_record_ready(void *data);
839
840 static void cmd_record(struct http_channel *c)
841 {
842     struct http_response *rs = c->response;
843     struct http_request *rq = c->request;
844     struct http_session *s = locate_session(c);
845     struct record_cluster *rec, *prev_r, *next_r;
846     struct record *r;
847     struct conf_service *service;
848     const char *idstr = http_argbyname(rq, "id");
849     const char *offsetstr = http_argbyname(rq, "offset");
850     const char *binarystr = http_argbyname(rq, "binary");
851     
852     if (!s)
853         return;
854     service = s->psession->service;
855     if (!idstr)
856     {
857         error(rs, PAZPAR2_MISSING_PARAMETER, "id");
858         return;
859     }
860     wrbuf_rewind(c->wrbuf);
861     if (!(rec = show_single_start(s->psession, idstr, &prev_r, &next_r)))
862     {
863         if (session_active_clients(s->psession) == 0)
864         {
865             error(rs, PAZPAR2_RECORD_MISSING, idstr);
866         }
867         else if (session_set_watch(s->psession, SESSION_WATCH_RECORD,
868                               cmd_record_ready, c, c) != 0)
869         {
870             error(rs, PAZPAR2_RECORD_MISSING, idstr);
871         }
872         release_session(c, s);
873         return;
874     }
875     if (offsetstr)
876     {
877         int offset = atoi(offsetstr);
878         const char *syntax = http_argbyname(rq, "syntax");
879         const char *esn = http_argbyname(rq, "esn");
880         int i;
881         struct record*r = rec->records;
882         int binary = 0;
883
884         if (binarystr && *binarystr != '0')
885             binary = 1;
886
887         for (i = 0; i < offset && r; r = r->next, i++)
888             ;
889         if (!r)
890         {
891             error(rs, PAZPAR2_RECORD_FAIL, "no record at offset given");
892         }
893         else
894         {
895             http_channel_observer_t obs =
896                 http_add_observer(c, r->client, show_raw_reset);
897             int ret = client_show_raw_begin(r->client, r->position,
898                                         syntax, esn, 
899                                         obs /* data */,
900                                         show_raw_record_error,
901                                         (binary ? 
902                                          show_raw_record_ok_binary : 
903                                          show_raw_record_ok),
904                                         (binary ? 1 : 0));
905             if (ret == -1)
906             {
907                 http_remove_observer(obs);
908                 error(rs, PAZPAR2_NO_SESSION, 0);
909             }
910         }
911     }
912     else
913     {
914         response_open_no_status(c, "record");
915         wrbuf_puts(c->wrbuf, "\n<recid>");
916         wrbuf_xmlputs(c->wrbuf, rec->recid);
917         wrbuf_puts(c->wrbuf, "</recid>\n");
918         if (prev_r)
919         {
920             wrbuf_puts(c->wrbuf, "<prevrecid>");
921             wrbuf_xmlputs(c->wrbuf, prev_r->recid);
922             wrbuf_puts(c->wrbuf, "</prevrecid>\n");
923         }
924         if (next_r)
925         {
926             wrbuf_puts(c->wrbuf, "<nextrecid>");
927             wrbuf_xmlputs(c->wrbuf, next_r->recid);
928             wrbuf_puts(c->wrbuf, "</nextrecid>\n");
929         }
930         wrbuf_printf(c->wrbuf, "<activeclients>%d</activeclients>\n", 
931                      session_active_clients(s->psession));
932         write_metadata(c->wrbuf, service, rec->metadata, 1);
933         for (r = rec->records; r; r = r->next)
934             write_subrecord(r, c->wrbuf, service, 1);
935         response_close(c, "record");
936     }
937     show_single_stop(s->psession, rec);
938     release_session(c, s);
939 }
940
941 static void cmd_record_ready(void *data)
942 {
943     struct http_channel *c = (struct http_channel *) data;
944     yaz_log(c->http_sessions->log_level, "record watch released");
945     cmd_record(c);
946 }
947
948 static void show_records(struct http_channel *c, int active)
949 {
950     struct http_request *rq = c->request;
951     struct http_response *rs = c->response;
952     struct http_session *s = locate_session(c);
953     struct record_cluster **rl;
954     struct reclist_sortparms *sp;
955     const char *start = http_argbyname(rq, "start");
956     const char *num = http_argbyname(rq, "num");
957     const char *sort = http_argbyname(rq, "sort");
958     int startn = 0;
959     int numn = 20;
960     int total;
961     Odr_int total_hits;
962     int i;
963
964     if (!s)
965         return;
966
967     // We haven't counted clients yet if we're called on a block release
968     if (active < 0)
969         active = session_active_clients(s->psession);
970
971     if (start)
972         startn = atoi(start);
973     if (num)
974         numn = atoi(num);
975     if (!sort)
976         sort = "relevance";
977     if (!(sp = reclist_parse_sortparms(c->nmem, sort, s->psession->service)))
978     {
979         error(rs, PAZPAR2_MALFORMED_PARAMETER_VALUE, "sort");
980         release_session(c, s);
981         return;
982
983     }
984
985     
986     rl = show_range_start(s->psession, sp, startn, &numn, &total, &total_hits);
987
988     response_open(c, "show");
989     wrbuf_printf(c->wrbuf, "\n<activeclients>%d</activeclients>\n", active);
990     wrbuf_printf(c->wrbuf, "<merged>%d</merged>\n", total);
991     wrbuf_printf(c->wrbuf, "<total>" ODR_INT_PRINTF "</total>\n", total_hits);
992     wrbuf_printf(c->wrbuf, "<start>%d</start>\n", startn);
993     wrbuf_printf(c->wrbuf, "<num>%d</num>\n", numn);
994
995     for (i = 0; i < numn; i++)
996     {
997         int ccount;
998         struct record *p;
999         struct record_cluster *rec = rl[i];
1000         struct conf_service *service = s->psession->service;
1001
1002         wrbuf_puts(c->wrbuf, "<hit>\n");
1003         write_metadata(c->wrbuf, service, rec->metadata, 0);
1004         for (ccount = 0, p = rl[i]->records; p;  p = p->next, ccount++)
1005             write_subrecord(p, c->wrbuf, service, 0); // subrecs w/o details
1006         if (ccount > 1)
1007             wrbuf_printf(c->wrbuf, "<count>%d</count>\n", ccount);
1008         if (strstr(sort, "relevance"))
1009             wrbuf_printf(c->wrbuf, "<relevance>%d</relevance>\n",
1010                          rec->relevance_score);
1011         wrbuf_puts(c->wrbuf, "<recid>");
1012         wrbuf_xmlputs(c->wrbuf, rec->recid);
1013         wrbuf_puts(c->wrbuf, "</recid>\n");
1014         wrbuf_puts(c->wrbuf, "</hit>\n");
1015     }
1016
1017     show_range_stop(s->psession, rl);
1018
1019     response_close(c, "show");
1020     release_session(c, s);
1021 }
1022
1023 static void show_records_ready(void *data)
1024 {
1025     struct http_channel *c = (struct http_channel *) data;
1026     yaz_log(c->http_sessions->log_level, "show watch released");
1027     show_records(c, -1);
1028 }
1029
1030 static void cmd_show(struct http_channel *c)
1031 {
1032     struct http_request  *rq = c->request;
1033     struct http_response *rs = c->response;
1034     struct http_session *s = locate_session(c);
1035     const char *block = http_argbyname(rq, "block");
1036     const char *sort = http_argbyname(rq, "sort");
1037     struct reclist_sortparms *sp;
1038     int status;
1039
1040     if (!s)
1041         return;
1042
1043     if (!sort)
1044         sort = "relevance";
1045     
1046     if (!(sp = reclist_parse_sortparms(c->nmem, sort, s->psession->service)))
1047     {
1048         error(c->response, PAZPAR2_MALFORMED_PARAMETER_VALUE, "sort");
1049         release_session(c, s);
1050         return;
1051     }
1052     session_sort(s->psession, sp->name, sp->increasing);
1053
1054     status = session_active_clients(s->psession);
1055
1056     if (block)
1057     {
1058         if (!strcmp(block, "preferred") && !session_is_preferred_clients_ready(s->psession) && reclist_get_num_records(s->psession->reclist) == 0)
1059         {
1060             // if there is already a watch/block. we do not block this one
1061             if (session_set_watch(s->psession, SESSION_WATCH_SHOW_PREF,
1062                                   show_records_ready, c, c) == 0)
1063             {
1064                 yaz_log(c->http_sessions->log_level,
1065                         "%p Session %u: Blocking on command show (preferred targets)", s, s->session_id);
1066             }
1067             else
1068             {
1069                 yaz_log(YLOG_WARN, "Attempt to block multiple times on show (preferred targets) block. Not supported!");
1070                 error(rs, PAZPAR2_ALREADY_BLOCKED, "show (preferred targets)"); 
1071             }
1072             release_session(c, s);
1073             return;
1074
1075         }
1076         else if (status)
1077         {
1078             // if there is already a watch/block. we do not block this one
1079             if (session_set_watch(s->psession, SESSION_WATCH_SHOW,
1080                                   show_records_ready, c, c) != 0)
1081             {
1082                 yaz_log(YLOG_WARN, "Attempt to block multiple times on show block. Not supported!");
1083                 error(rs, PAZPAR2_ALREADY_BLOCKED, "show"); 
1084             }
1085             else
1086             {
1087                 yaz_log(c->http_sessions->log_level, "%p Session %u: Blocking on command show", s, s->session_id);
1088             }
1089             release_session(c, s);
1090             return;
1091         }
1092     }
1093     show_records(c, status);
1094     release_session(c, s);
1095 }
1096
1097 static void cmd_ping(struct http_channel *c)
1098 {
1099     struct http_session *s = locate_session(c);
1100     if (!s)
1101         return;
1102     response_open(c, "ping");
1103     response_close(c, "ping");
1104     release_session(c, s);
1105 }
1106
1107 static void cmd_search(struct http_channel *c)
1108 {
1109     struct http_request *rq = c->request;
1110     struct http_response *rs = c->response;
1111     struct http_session *s = locate_session(c);
1112     const char *query = http_argbyname(rq, "query");
1113     const char *filter = http_argbyname(rq, "filter");
1114     const char *maxrecs = http_argbyname(rq, "maxrecs");
1115     const char *startrecs = http_argbyname(rq, "startrecs");
1116     const char *limit = http_argbyname(rq, "limit");
1117     enum pazpar2_error_code code;
1118     const char *addinfo = 0;
1119
1120     if (!s)
1121         return;
1122     if (!query)
1123     {
1124         error(rs, PAZPAR2_MISSING_PARAMETER, "query");
1125         release_session(c, s);
1126         return;
1127     }
1128     if (!yaz_utf8_check(query))
1129     {
1130         error(rs, PAZPAR2_MALFORMED_PARAMETER_ENCODING, "query");
1131         release_session(c, s);
1132         return;
1133     }
1134     code = session_search(s->psession, query, startrecs, maxrecs, filter, limit,
1135                           &addinfo, "relevance", 0);
1136     if (code)
1137     {
1138         error(rs, code, addinfo);
1139         release_session(c, s);
1140         return;
1141     }
1142     response_open(c, "search");
1143     response_close(c, "search");
1144     release_session(c, s);
1145 }
1146
1147
1148 static void cmd_stat(struct http_channel *c)
1149 {
1150     struct http_session *s = locate_session(c);
1151     struct statistics stat;
1152     int clients;
1153
1154     float progress = 0;
1155
1156     if (!s)
1157         return;
1158
1159     clients = session_active_clients(s->psession);
1160     statistics(s->psession, &stat);
1161
1162     if (stat.num_clients > 0)
1163     {
1164         progress = (stat.num_clients  - clients) / (float)stat.num_clients;
1165     }
1166
1167     response_open_no_status(c, "stat");
1168     wrbuf_printf(c->wrbuf, "<activeclients>%d</activeclients>\n", clients);
1169     wrbuf_printf(c->wrbuf, "<hits>" ODR_INT_PRINTF "</hits>\n", stat.num_hits);
1170     wrbuf_printf(c->wrbuf, "<records>%d</records>\n", stat.num_records);
1171     wrbuf_printf(c->wrbuf, "<clients>%d</clients>\n", stat.num_clients);
1172     wrbuf_printf(c->wrbuf, "<unconnected>%d</unconnected>\n", stat.num_no_connection);
1173     wrbuf_printf(c->wrbuf, "<connecting>%d</connecting>\n", stat.num_connecting);
1174     wrbuf_printf(c->wrbuf, "<working>%d</working>\n", stat.num_working);
1175     wrbuf_printf(c->wrbuf, "<idle>%d</idle>\n", stat.num_idle);
1176     wrbuf_printf(c->wrbuf, "<failed>%d</failed>\n", stat.num_failed);
1177     wrbuf_printf(c->wrbuf, "<error>%d</error>\n", stat.num_error);
1178     wrbuf_printf(c->wrbuf, "<progress>%.2f</progress>\n", progress);
1179     response_close(c, "stat");
1180     release_session(c, s);
1181 }
1182
1183 static void cmd_info(struct http_channel *c)
1184 {
1185     char yaz_version_str[20];
1186
1187     response_open_no_status(c, "info");
1188     wrbuf_puts(c->wrbuf, " <version>\n");
1189     wrbuf_puts(c->wrbuf, "  <pazpar2");
1190 #ifdef PAZPAR2_VERSION_SHA1
1191     wrbuf_printf(c->wrbuf, " sha1=\"%s\"", PAZPAR2_VERSION_SHA1);
1192 #endif
1193     wrbuf_puts(c->wrbuf, ">");
1194     wrbuf_xmlputs(c->wrbuf, VERSION);
1195     wrbuf_puts(c->wrbuf, "</pazpar2>");
1196
1197     yaz_version(yaz_version_str, 0);
1198     wrbuf_puts(c->wrbuf, "  <yaz compiled=\"");
1199     wrbuf_xmlputs(c->wrbuf, YAZ_VERSION);
1200     wrbuf_puts(c->wrbuf, "\">");
1201     wrbuf_xmlputs(c->wrbuf, yaz_version_str);
1202     wrbuf_puts(c->wrbuf, "</yaz>\n");
1203
1204     wrbuf_puts(c->wrbuf, " </version>\n");
1205     
1206     info_services(c->server, c->wrbuf);
1207
1208     response_close(c, "info");
1209 }
1210
1211 struct {
1212     char *name;
1213     void (*fun)(struct http_channel *c);
1214 } commands[] = {
1215     { "init", cmd_init },
1216     { "settings", cmd_settings },
1217     { "stat", cmd_stat },
1218     { "bytarget", cmd_bytarget },
1219     { "show", cmd_show },
1220     { "search", cmd_search },
1221     { "termlist", cmd_termlist },
1222     { "exit", cmd_exit },
1223     { "session-status", cmd_session_status },
1224     { "server-status", cmd_server_status },
1225     { "ping", cmd_ping },
1226     { "record", cmd_record },
1227     { "info", cmd_info },
1228     {0,0}
1229 };
1230
1231 void http_command(struct http_channel *c)
1232 {
1233     const char *command = http_argbyname(c->request, "command");
1234     struct http_response *rs = http_create_response(c);
1235     int i;
1236
1237     c->response = rs;
1238
1239     http_addheader(rs, "Expires", "Thu, 19 Nov 1981 08:52:00 GMT");
1240     http_addheader(rs, "Cache-Control", "no-store, no-cache, must-revalidate, post-check=0, pre-check=0");
1241
1242     if (!command)
1243     {
1244         error(rs, PAZPAR2_MISSING_PARAMETER, "command");
1245         return;
1246     }
1247     for (i = 0; commands[i].name; i++)
1248         if (!strcmp(commands[i].name, command))
1249         {
1250             (*commands[i].fun)(c);
1251             break;
1252         }
1253     if (!commands[i].name)
1254         error(rs, PAZPAR2_MALFORMED_PARAMETER_VALUE, "command");
1255
1256     return;
1257 }
1258
1259 /*
1260  * Local variables:
1261  * c-basic-offset: 4
1262  * c-file-style: "Stroustrup"
1263  * indent-tabs-mode: nil
1264  * End:
1265  * vim: shiftwidth=4 tabstop=8 expandtab
1266  */
1267