fb538f36c96526a2f670342b0c41b50e8d19d6d5
[yaz-moved-to-github.git] / zoom / zoomsh.c
1 /*
2  * $Id: zoomsh.c,v 1.15 2003-02-17 21:23:31 adam Exp $
3  *
4  * ZOOM-C Shell
5  */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <ctype.h>
11
12 #if HAVE_READLINE_READLINE_H
13 #include <readline/readline.h> 
14 #endif
15 #if HAVE_READLINE_HISTORY_H
16 #include <readline/history.h>
17 #endif
18
19 #include <yaz/xmalloc.h>
20
21 #include <yaz/log.h>
22 #include <yaz/zoom.h>
23
24 #define MAX_CON 100
25
26 static int next_token (const char **cpp, const char **t_start)
27 {
28     int len = 0;
29     const char *cp = *cpp;
30     while (*cp == ' ')
31         cp++;
32     *t_start = cp;
33     while (*cp && *cp != ' ' && *cp != '\r' && *cp != '\n')
34     {
35         cp++;
36         len++;
37     }
38     *cpp = cp;
39     return len;
40 }
41
42 static int next_token_copy (const char **cpp, char *buf_out, int buf_max)
43 {
44     const char *start;
45     int len = next_token (cpp, &start);
46     if (!len)
47     {
48         *buf_out = 0;
49         return 0;
50     }
51     if (len >= buf_max)
52         len = buf_max-1;
53     memcpy (buf_out, start, len);
54     buf_out[len] = '\0';
55     return len;
56 }
57
58 static int is_command (const char *cmd_str, const char *this_str, int this_len)
59 {
60     int cmd_len = strlen(cmd_str);
61     if (cmd_len != this_len)
62         return 0;
63     if (memcmp (cmd_str, this_str, cmd_len))
64         return 0;
65     return 1;
66 }
67
68 static void cmd_set (ZOOM_connection *c, ZOOM_resultset *r,
69                      ZOOM_options options,
70                      const char **args)
71 {
72     char key[40], val[80];
73
74     if (!next_token_copy (args, key, sizeof(key)))
75     {
76         printf ("missing argument for set\n");
77         return ;
78     }
79     if (!next_token_copy (args, val, sizeof(val)))
80         ZOOM_options_set(options, key, 0);
81     else
82         ZOOM_options_set(options, key, val);
83 }
84
85 static void cmd_get (ZOOM_connection *c, ZOOM_resultset *r,
86                      ZOOM_options options,
87                      const char **args)
88 {
89     char key[40];
90     if (!next_token_copy (args, key, sizeof(key)))
91     {
92         printf ("missing argument for get\n");
93     }
94     else
95     {
96         const char *val = ZOOM_options_get(options, key);
97         printf ("%s = %s\n", key, val ? val : "<null>");
98     }
99 }
100
101 static void cmd_close (ZOOM_connection *c, ZOOM_resultset *r,
102                        ZOOM_options options,
103                        const char **args)
104 {
105     char host[60];
106     int i;
107     next_token_copy (args, host, sizeof(host));
108     for (i = 0; i<MAX_CON; i++)
109     {
110         const char *h;
111         if (!c[i])
112             continue;
113         if ((h = ZOOM_connection_option_get(c[i], "host"))
114             && !strcmp (h, host))
115         {
116             ZOOM_connection_destroy (c[i]);
117             c[i] = 0;
118         }
119         else if (*host == '\0')
120         {
121             ZOOM_connection_destroy (c[i]);
122             c[i] = 0;
123         }
124     }
125 }
126
127 static void display_records (ZOOM_connection c,
128                              ZOOM_resultset r,
129                              int start, int count)
130 {
131     int i;
132     for (i = 0; i<count; i++)
133     {
134         int pos = i + start;
135         ZOOM_record rec = ZOOM_resultset_record (r, pos);
136         const char *db = ZOOM_record_get (rec, "database", 0);
137         int len;
138         const char *render = ZOOM_record_get (rec, "render", &len);
139         const char *syntax = ZOOM_record_get (rec, "syntax", 0);
140         /* if rec is non-null, we got a record for display */
141         if (rec)
142         {
143             printf ("%d %s %s\n", pos+1, (db ? db : "unknown"), syntax);
144             if (render)
145                 fwrite (render, 1, len, stdout);
146             printf ("\n");
147         }
148     }
149 }
150
151 static void cmd_show (ZOOM_connection *c, ZOOM_resultset *r,
152                       ZOOM_options options,
153                       const char **args)
154 {
155     int i;
156     char start_str[10], count_str[10];
157
158     if (next_token_copy (args, start_str, sizeof(start_str)))
159         ZOOM_options_set (options, "start", start_str);
160
161     if (next_token_copy (args, count_str, sizeof(count_str)))
162         ZOOM_options_set (options, "count", count_str);
163
164     for (i = 0; i<MAX_CON; i++)
165         ZOOM_resultset_records (r[i], 0, atoi(start_str), atoi(count_str));
166     while (ZOOM_event (MAX_CON, c))
167         ;
168
169     for (i = 0; i<MAX_CON; i++)
170     {
171         int error;
172         const char *errmsg, *addinfo, *dset;
173         /* display errors if any */
174         if (!c[i])
175             continue;
176         if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
177             printf ("%s error: %s (%s:%d) %s\n",
178                      ZOOM_connection_option_get(c[i], "host"), errmsg,
179                      dset, error, addinfo);
180         else if (r[i])
181         {
182             /* OK, no major errors. Display records... */
183             int start = ZOOM_options_get_int (options, "start", 0);
184             int count = ZOOM_options_get_int (options, "count", 0);
185             display_records (c[i], r[i], start, count);
186         }
187     }
188 }
189
190 static void cmd_ext (ZOOM_connection *c, ZOOM_resultset *r,
191                      ZOOM_options options,
192                      const char **args)
193 {
194     ZOOM_package p[MAX_CON];
195     
196     int i;
197     
198     for (i = 0; i<MAX_CON; i++)
199     {
200         if (c[i])
201         {
202             p[i] = ZOOM_connection_package (c[i], 0);
203             ZOOM_package_send(p[i], "itemorder");
204         }
205         else
206             p[i] = 0;
207     }
208
209     while (ZOOM_event (MAX_CON, c))
210         ;
211
212     for (i = 0; i<MAX_CON; i++)
213     {
214         int error;
215         const char *errmsg, *addinfo, *dset;
216         /* display errors if any */
217         if (!p[i])
218             continue;
219         if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
220             printf ("%s error: %s (%s:%d) %s\n",
221                      ZOOM_connection_option_get(c[i], "host"), errmsg,
222                      dset, error, addinfo);
223         else if (p[i])
224         {
225             printf ("ok\n");
226         }
227         ZOOM_package_destroy (p[i]);
228     }
229 }
230
231 static void cmd_debug (ZOOM_connection *c, ZOOM_resultset *r,
232                        ZOOM_options options,
233                        const char **args)
234 {
235     yaz_log_init_level(LOG_ALL);
236 }
237
238 static void cmd_search (ZOOM_connection *c, ZOOM_resultset *r,
239                         ZOOM_options options,
240                         const char **args)
241 {
242     ZOOM_query s;
243     const char *query_str = *args;
244     int i;
245     
246     s = ZOOM_query_create ();
247     while (*query_str == ' ')
248         query_str++;
249     if (memcmp(query_str, "cql:", 4) == 0)
250     {
251         ZOOM_query_cql (s, query_str + 4);
252     }
253     else if (ZOOM_query_prefix (s, query_str))
254     {
255         printf ("Bad PQF: %s\n", query_str);
256         return;
257     }
258     for (i = 0; i<MAX_CON; i++)
259     {
260         if (c[i])
261         {
262             ZOOM_resultset_destroy (r[i]);
263             r[i] = 0;
264         }
265         if (c[i])
266             r[i] = ZOOM_connection_search (c[i], s);
267     }
268
269     while (ZOOM_event (MAX_CON, c))
270         ;
271
272     for (i = 0; i<MAX_CON; i++)
273     {
274         int error;
275         const char *errmsg, *addinfo, *dset;
276         /* display errors if any */
277         if (!c[i])
278             continue;
279         if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
280             printf ("%s error: %s (%s:%d) %s\n",
281                     ZOOM_connection_option_get(c[i], "host"), errmsg,
282                     dset, error, addinfo);
283         else if (r[i])
284         {
285             /* OK, no major errors. Look at the result count */
286             int start = ZOOM_options_get_int (options, "start", 0);
287             int count = ZOOM_options_get_int (options, "count", 0);
288
289             printf ("%s: %d hits\n", ZOOM_connection_option_get(c[i], "host"),
290                     ZOOM_resultset_size(r[i]));
291             /* and display */
292             display_records (c[i], r[i], start, count);
293         }
294     }
295     ZOOM_query_destroy (s);
296 }
297
298 static void cmd_help (ZOOM_connection *c, ZOOM_resultset *r,
299                       ZOOM_options options,
300                       const char **args)
301 {
302     printf ("connect <zurl>\n");
303     printf ("search <pqf>\n");
304     printf ("show [<start> [<count>]\n");
305     printf ("quit\n");
306     printf ("close <zurl>\n");
307     printf ("set <option> [<value>]\n");
308     printf ("get <option>\n");
309     printf ("\n");
310     printf ("options:\n");
311     printf (" start\n");
312     printf (" count\n");
313     printf (" databaseName\n");
314     printf (" preferredRecordSyntax\n");
315     printf (" proxy\n");
316     printf (" elementSetName\n");
317     printf (" maximumRecordSize\n");
318     printf (" preferredRecordSize\n");
319     printf (" async\n");
320     printf (" piggyback\n");
321     printf (" group\n");
322     printf (" user\n");
323     printf (" pass\n");
324     printf (" implementationName\n");
325     printf (" charset\n");
326     printf (" lang\n");
327 }
328
329 static void cmd_connect (ZOOM_connection *c, ZOOM_resultset *r,
330                          ZOOM_options options,
331                          const char **args)
332 {
333     int error;
334     const char *errmsg, *addinfo, *dset;
335     char host[60];
336     int j, i;
337     if (!next_token_copy (args, host, sizeof(host)))
338     {
339         printf ("missing host after connect\n");
340         return ;
341     }
342     for (j = -1, i = 0; i<MAX_CON; i++)
343     {
344         const char *h;
345         if (c[i] && (h = ZOOM_connection_option_get(c[i], "host")) &&
346             !strcmp (h, host))
347         {
348             ZOOM_connection_destroy (c[i]);
349             break;
350         }
351         else if (c[i] == 0 && j == -1)
352             j = i;
353     }
354     if (i == MAX_CON)  /* no match .. */
355     {
356         if (j == -1)
357         {
358             printf ("no more connection available\n");
359             return;
360         }
361         i = j;   /* OK, use this one is available */
362     }
363     c[i] = ZOOM_connection_create (options);
364     ZOOM_connection_connect (c[i], host, 0);
365         
366     if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
367        printf ("%s error: %s (%s:%d) %s\n",
368             ZOOM_connection_option_get(c[i], "host"), errmsg,
369             dset, error, addinfo);
370 }
371
372 static int cmd_parse (ZOOM_connection *c, ZOOM_resultset *r,
373                       ZOOM_options options, 
374                       const char **buf)
375 {
376     int cmd_len;
377     const char *cmd_str;
378
379     cmd_len = next_token (buf, &cmd_str);
380     if (!cmd_len)
381         return 1;
382     if (is_command ("quit", cmd_str, cmd_len))
383         return 0;
384     else if (is_command ("set", cmd_str, cmd_len))
385         cmd_set (c, r, options, buf);
386     else if (is_command ("get", cmd_str, cmd_len))
387         cmd_get (c, r, options, buf);
388     else if (is_command ("connect", cmd_str, cmd_len))
389         cmd_connect (c, r, options, buf);
390     else if (is_command ("open", cmd_str, cmd_len))
391         cmd_connect (c, r, options, buf);
392     else if (is_command ("search", cmd_str, cmd_len))
393         cmd_search (c, r, options, buf);
394     else if (is_command ("find", cmd_str, cmd_len))
395         cmd_search (c, r, options, buf);
396     else if (is_command ("show", cmd_str, cmd_len))
397         cmd_show (c, r, options, buf);
398     else if (is_command ("close", cmd_str, cmd_len))
399         cmd_close (c, r, options, buf);
400     else if (is_command ("help", cmd_str, cmd_len))
401         cmd_help(c, r, options, buf);
402     else if (is_command ("ext", cmd_str, cmd_len))
403         cmd_ext(c, r, options, buf);
404     else if (is_command ("debug", cmd_str, cmd_len))
405         cmd_debug(c, r, options, buf);
406     else
407         printf ("unknown command %.*s\n", cmd_len, cmd_str);
408     return 2;
409 }
410
411 void shell(ZOOM_connection *c, ZOOM_resultset *r,
412            ZOOM_options options)
413 {
414     while (1)
415     {
416         char buf[1000];
417         char *cp;
418         const char *bp = buf;
419 #if HAVE_READLINE_READLINE_H
420         char* line_in;
421         line_in=readline("ZOOM>");
422         if (!line_in)
423             break;
424 #if HAVE_READLINE_HISTORY_H
425         if (*line_in)
426             add_history(line_in);
427 #endif
428         if(strlen(line_in) > 999) {
429             printf("Input line too long\n");
430             break;
431         };
432         strcpy(buf,line_in);
433         free (line_in);
434 #else    
435         printf ("ZOOM>"); fflush (stdout);
436         if (!fgets (buf, 999, stdin))
437             break;
438 #endif 
439         if ((cp = strchr(buf, '\n')))
440             *cp = '\0';
441         if (!cmd_parse (c, r, options, &bp))
442             break;
443     }
444 }
445
446 int main (int argc, char **argv)
447 {
448     ZOOM_options options = ZOOM_options_create();
449     int i, res;
450     ZOOM_connection z39_con[MAX_CON];
451     ZOOM_resultset  z39_res[MAX_CON];
452
453     nmem_init();
454     for (i = 0; i<MAX_CON; i++)
455     {
456         z39_con[i] = 0;
457         z39_res[i] = 0;
458     }
459
460     for (i = 0; i<MAX_CON; i++)
461         z39_con[i] = 0;
462
463     res = 1;
464     for (i = 1; i<argc; i++)
465     {
466         const char *bp = argv[i];
467         res = cmd_parse(z39_con, z39_res, options, &bp);
468         if (res == 0)  /* received quit */
469             break;
470     }
471     if (res)  /* do cmdline shell only if not quitting */
472         shell(z39_con, z39_res, options);
473     ZOOM_options_destroy(options);
474
475     for (i = 0; i<MAX_CON; i++)
476     {
477         ZOOM_connection_destroy(z39_con[i]);
478         ZOOM_resultset_destroy(z39_res[i]);
479     }
480     nmem_exit();
481     exit (0);
482 }