zoom/zoomsh.c

   1 /*
   2  * $Id: zoomsh.c,v 1.16 2003-02-23 15:24:27 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     ZOOM_options_set (options, "count", "0");
 189     ZOOM_options_set (options, "start", "0");
 190 }
 191
 192 static void cmd_ext (ZOOM_connection *c, ZOOM_resultset *r,
 193                      ZOOM_options options,
 194                      const char **args)
 195 {
 196     ZOOM_package p[MAX_CON];
 197
 198     int i;
 199
 200     for (i = 0; i<MAX_CON; i++)
 201     {
 202         if (c[i])
 203         {
 204             p[i] = ZOOM_connection_package (c[i], 0);
 205             ZOOM_package_send(p[i], "itemorder");
 206         }
 207         else
 208             p[i] = 0;
 209     }
 210
 211     while (ZOOM_event (MAX_CON, c))
 212         ;
 213
 214     for (i = 0; i<MAX_CON; i++)
 215     {
 216         int error;
 217         const char *errmsg, *addinfo, *dset;
 218         /* display errors if any */
 219         if (!p[i])
 220             continue;
 221         if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
 222             printf ("%s error: %s (%s:%d) %s\n",
 223                      ZOOM_connection_option_get(c[i], "host"), errmsg,
 224                      dset, error, addinfo);
 225         else if (p[i])
 226         {
 227             printf ("ok\n");
 228         }
 229         ZOOM_package_destroy (p[i]);
 230     }
 231 }
 232
 233 static void cmd_debug (ZOOM_connection *c, ZOOM_resultset *r,
 234                        ZOOM_options options,
 235                        const char **args)
 236 {
 237     yaz_log_init_level(LOG_ALL);
 238 }
 239
 240 static void cmd_search (ZOOM_connection *c, ZOOM_resultset *r,
 241                         ZOOM_options options,
 242                         const char **args)
 243 {
 244     ZOOM_query s;
 245     const char *query_str = *args;
 246     int i;
 247
 248     s = ZOOM_query_create ();
 249     while (*query_str == ' ')
 250         query_str++;
 251     if (memcmp(query_str, "cql:", 4) == 0)
 252     {
 253         ZOOM_query_cql (s, query_str + 4);
 254     }
 255     else if (ZOOM_query_prefix (s, query_str))
 256     {
 257         printf ("Bad PQF: %s\n", query_str);
 258         return;
 259     }
 260     for (i = 0; i<MAX_CON; i++)
 261     {
 262         if (c[i])
 263         {
 264             ZOOM_resultset_destroy (r[i]);
 265             r[i] = 0;
 266         }
 267         if (c[i])
 268             r[i] = ZOOM_connection_search (c[i], s);
 269     }
 270
 271     while (ZOOM_event (MAX_CON, c))
 272         ;
 273
 274     for (i = 0; i<MAX_CON; i++)
 275     {
 276         int error;
 277         const char *errmsg, *addinfo, *dset;
 278         /* display errors if any */
 279         if (!c[i])
 280             continue;
 281         if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
 282             printf ("%s error: %s (%s:%d) %s\n",
 283                     ZOOM_connection_option_get(c[i], "host"), errmsg,
 284                     dset, error, addinfo);
 285         else if (r[i])
 286         {
 287             /* OK, no major errors. Look at the result count */
 288             int start = ZOOM_options_get_int (options, "start", 0);
 289             int count = ZOOM_options_get_int (options, "count", 0);
 290
 291             printf ("%s: %d hits\n", ZOOM_connection_option_get(c[i], "host"),
 292                     ZOOM_resultset_size(r[i]));
 293             /* and display */
 294             display_records (c[i], r[i], start, count);
 295         }
 296     }
 297     ZOOM_query_destroy (s);
 298 }
 299
 300 static void cmd_help (ZOOM_connection *c, ZOOM_resultset *r,
 301                       ZOOM_options options,
 302                       const char **args)
 303 {
 304     printf ("connect <zurl>\n");
 305     printf ("search <pqf>\n");
 306     printf ("show [<start> [<count>]\n");
 307     printf ("quit\n");
 308     printf ("close <zurl>\n");
 309     printf ("set <option> [<value>]\n");
 310     printf ("get <option>\n");
 311     printf ("\n");
 312     printf ("options:\n");
 313     printf (" start\n");
 314     printf (" count\n");
 315     printf (" databaseName\n");
 316     printf (" preferredRecordSyntax\n");
 317     printf (" proxy\n");
 318     printf (" elementSetName\n");
 319     printf (" maximumRecordSize\n");
 320     printf (" preferredRecordSize\n");
 321     printf (" async\n");
 322     printf (" piggyback\n");
 323     printf (" group\n");
 324     printf (" user\n");
 325     printf (" pass\n");
 326     printf (" implementationName\n");
 327     printf (" charset\n");
 328     printf (" lang\n");
 329 }
 330
 331 static void cmd_connect (ZOOM_connection *c, ZOOM_resultset *r,
 332                          ZOOM_options options,
 333                          const char **args)
 334 {
 335     int error;
 336     const char *errmsg, *addinfo, *dset;
 337     char host[60];
 338     int j, i;
 339     if (!next_token_copy (args, host, sizeof(host)))
 340     {
 341         printf ("missing host after connect\n");
 342         return ;
 343     }
 344     for (j = -1, i = 0; i<MAX_CON; i++)
 345     {
 346         const char *h;
 347         if (c[i] && (h = ZOOM_connection_option_get(c[i], "host")) &&
 348             !strcmp (h, host))
 349         {
 350             ZOOM_connection_destroy (c[i]);
 351             break;
 352         }
 353         else if (c[i] == 0 && j == -1)
 354             j = i;
 355     }
 356     if (i == MAX_CON)  /* no match .. */
 357     {
 358         if (j == -1)
 359         {
 360             printf ("no more connection available\n");
 361             return;
 362         }
 363         i = j;   /* OK, use this one is available */
 364     }
 365     c[i] = ZOOM_connection_create (options);
 366     ZOOM_connection_connect (c[i], host, 0);
 367
 368     if ((error = ZOOM_connection_error_x(c[i], &errmsg, &addinfo, &dset)))
 369        printf ("%s error: %s (%s:%d) %s\n",
 370             ZOOM_connection_option_get(c[i], "host"), errmsg,
 371             dset, error, addinfo);
 372 }
 373
 374 static int cmd_parse (ZOOM_connection *c, ZOOM_resultset *r,
 375                       ZOOM_options options,
 376                       const char **buf)
 377 {
 378     int cmd_len;
 379     const char *cmd_str;
 380
 381     cmd_len = next_token (buf, &cmd_str);
 382     if (!cmd_len)
 383         return 1;
 384     if (is_command ("quit", cmd_str, cmd_len))
 385         return 0;
 386     else if (is_command ("set", cmd_str, cmd_len))
 387         cmd_set (c, r, options, buf);
 388     else if (is_command ("get", cmd_str, cmd_len))
 389         cmd_get (c, r, options, buf);
 390     else if (is_command ("connect", cmd_str, cmd_len))
 391         cmd_connect (c, r, options, buf);
 392     else if (is_command ("open", cmd_str, cmd_len))
 393         cmd_connect (c, r, options, buf);
 394     else if (is_command ("search", cmd_str, cmd_len))
 395         cmd_search (c, r, options, buf);
 396     else if (is_command ("find", cmd_str, cmd_len))
 397         cmd_search (c, r, options, buf);
 398     else if (is_command ("show", cmd_str, cmd_len))
 399         cmd_show (c, r, options, buf);
 400     else if (is_command ("close", cmd_str, cmd_len))
 401         cmd_close (c, r, options, buf);
 402     else if (is_command ("help", cmd_str, cmd_len))
 403         cmd_help(c, r, options, buf);
 404     else if (is_command ("ext", cmd_str, cmd_len))
 405         cmd_ext(c, r, options, buf);
 406     else if (is_command ("debug", cmd_str, cmd_len))
 407         cmd_debug(c, r, options, buf);
 408     else
 409         printf ("unknown command %.*s\n", cmd_len, cmd_str);
 410     return 2;
 411 }
 412
 413 void shell(ZOOM_connection *c, ZOOM_resultset *r,
 414            ZOOM_options options)
 415 {
 416     while (1)
 417     {
 418         char buf[1000];
 419         char *cp;
 420         const char *bp = buf;
 421 #if HAVE_READLINE_READLINE_H
 422         char* line_in;
 423         line_in=readline("ZOOM>");
 424         if (!line_in)
 425             break;
 426 #if HAVE_READLINE_HISTORY_H
 427         if (*line_in)
 428             add_history(line_in);
 429 #endif
 430         if(strlen(line_in) > 999) {
 431             printf("Input line too long\n");
 432             break;
 433         };
 434         strcpy(buf,line_in);
 435         free (line_in);
 436 #else
 437         printf ("ZOOM>"); fflush (stdout);
 438         if (!fgets (buf, 999, stdin))
 439             break;
 440 #endif
 441         if ((cp = strchr(buf, '\n')))
 442             *cp = '\0';
 443         if (!cmd_parse (c, r, options, &bp))
 444             break;
 445     }
 446 }
 447
 448 int main (int argc, char **argv)
 449 {
 450     ZOOM_options options = ZOOM_options_create();
 451     int i, res;
 452     ZOOM_connection z39_con[MAX_CON];
 453     ZOOM_resultset  z39_res[MAX_CON];
 454
 455     nmem_init();
 456     for (i = 0; i<MAX_CON; i++)
 457     {
 458         z39_con[i] = 0;
 459         z39_res[i] = 0;
 460     }
 461
 462     for (i = 0; i<MAX_CON; i++)
 463         z39_con[i] = 0;
 464
 465     res = 1;
 466     for (i = 1; i<argc; i++)
 467     {
 468         const char *bp = argv[i];
 469         res = cmd_parse(z39_con, z39_res, options, &bp);
 470         if (res == 0)  /* received quit */
 471             break;
 472     }
 473     if (res)  /* do cmdline shell only if not quitting */
 474         shell(z39_con, z39_res, options);
 475     ZOOM_options_destroy(options);
 476
 477     for (i = 0; i<MAX_CON; i++)
 478     {
 479         ZOOM_connection_destroy(z39_con[i]);
 480         ZOOM_resultset_destroy(z39_res[i]);
 481     }
 482     nmem_exit();
 483     exit (0);
 484 }