index/zebrash.c

   1 /* zebrash.c - command-line interface to zebra API
   2  *  $Id: zebrash.c,v 1.8 2003-06-02 13:13:59 adam Exp $
   3  *
   4  * Copyrigth 2003 Index Data Aps
   5  *
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <ctype.h>
  12
  13 #if HAVE_READLINE_READLINE_H
  14 #include <readline/readline.h>
  15 #endif
  16 #if HAVE_READLINE_HISTORY_H
  17 #include <readline/history.h>
  18 #endif
  19
  20 #include "zebraapi.h"
  21 #include <yaz/log.h>
  22
  23 #define MAX_NO_ARGS 32
  24 #define MAX_OUT_BUFF 4096
  25 #define MAX_ARG_LEN 1024
  26 #define PROMPT "ZebraSh>"
  27 #define DEFAULTCONFIG "./zebra.cfg"
  28
  29 /**************************************
  30  * Global variables (yuck!)
  31  */
  32
  33 ZebraService zs=0;  /* our global handle to zebra */
  34 ZebraHandle  zh=0;  /* the current session */
  35 /* time being, only one session works */
  36
  37 /**************************************
  38  * Help functions
  39  */
  40
  41
  42 static int split_args( char *line, char** args )
  43 { /* splits line into individual null-terminated strings,
  44    * returns pointers to them in args */
  45   /* FIXME - do we need to handle quoted args ?? */
  46     char *p=line;
  47     int i=0;
  48     int n=0;
  49     args[0]=0; /* by default */
  50     while (*p==' ' || *p=='\t' || *p=='\n')
  51         p++;
  52     while (*p)
  53     {
  54         while (*p==' ' || *p=='\t' || *p=='\n')
  55             p++;
  56         if (*p=='#')  /* skip comments */
  57             break;
  58         args[i++]=p;
  59         args[i]=0;
  60         while (*p && *p!=' ' && *p!='\t' && *p!='\n' && *p!='#')
  61             p++;
  62         *p++='\0';
  63     }
  64     n=i;
  65     while (n<MAX_NO_ARGS)
  66         args[n++]=0;
  67     return i;
  68 }
  69
  70 static char *defarg( char *arg, char *def )
  71 {
  72     if (!arg)
  73         return def;
  74     if (!*arg)
  75         return def;
  76     return arg;
  77 }
  78 static int defargint( char *arg, int def )
  79 {
  80     int v=def;
  81     char *a=defarg(arg,0);
  82     if (a)
  83         sscanf(a," %i", &v);
  84     return v;
  85 }
  86
  87 int onecommand( char *line, char *outbuff);
  88
  89 /**************************************
  90  * Simple support commands
  91  */
  92
  93 int cmd_echo( char *args[], char *outbuff)
  94 {
  95     strcpy(outbuff, args[0]);
  96     return 0;
  97 }
  98
  99 int cmd_quit( char *args[], char *outbuff)
 100 {
 101     strcpy(outbuff, "bye");
 102     return -99; /* special stop signal */
 103 }
 104
 105 /**************************************
 106  * Tests for starting and stopping zebra, etc
 107  */
 108
 109 static int cmd_help( char *args[], char *outbuff);
 110
 111 static int cmd_zebra_start( char *args[], char *outbuff)
 112 {
 113     char *conf=args[1];
 114     if (!conf || !*conf) {
 115         strcat(outbuff,"no config file specified, using "
 116                DEFAULTCONFIG "\n" );
 117         conf=DEFAULTCONFIG;
 118     }
 119     zs=zebra_start(conf);
 120     if (!zs) {
 121         strcpy(outbuff, "zebra_start failed" );
 122         return 2;
 123     }
 124     return 0; /* ok */
 125 }
 126
 127 static int cmd_zebra_stop( char *args[], char *outbuff)
 128 {
 129     if (!zs)
 130         strcat(outbuff,"zebra seems not to have been started, "
 131                "stopping anyway\n");
 132     zebra_stop(zs);
 133     zs=0;
 134     return 0; /* ok */
 135 }
 136
 137 static int cmd_zebra_open( char *args[], char *outbuff)
 138 {
 139     if (!zs)
 140         strcat(outbuff,"zebra seems not to have been started, "
 141                "trying anyway\n");
 142     zh=zebra_open(zs);
 143     return 0; /* ok */
 144 }
 145
 146 static int cmd_zebra_close( char *args[], char *outbuff)
 147 {
 148     if (!zh)
 149         strcat(outbuff,"Seems like you have not called zebra_open,"
 150                "trying anyway\n");
 151     zebra_close(zh);
 152     return 0; /* ok */
 153 }
 154
 155 static int cmd_quickstart( char *args[], char *outbuff)
 156 {
 157     char tmp[128];
 158     onecommand("yaz_log_file zebrash.log",outbuff);
 159     onecommand("yaz_log_prefix ZebraSh", outbuff);
 160     sprintf(tmp, "yaz_log_level 0x%x", LOG_DEFAULT_LEVEL | LOG_APP);
 161     onecommand(tmp,outbuff);
 162     logf(LOG_APP,"quickstart");
 163     onecommand("zebra_start",outbuff);
 164     onecommand("zebra_open",outbuff);
 165     onecommand("select_database Default",outbuff);
 166     strcat(outbuff,"ok\n");
 167     return 0;
 168 }
 169
 170 /**************************************
 171  * Log file handling
 172  */
 173
 174 static int cmd_yaz_log_file( char *args[], char *outbuff)
 175 {
 176     char *fn = defarg(args[1],0);
 177     char tmp[255];
 178     sprintf(tmp, "sending yaz-log to %s\n",fn);
 179     strcat(outbuff, tmp);
 180     yaz_log_init_file(fn);
 181     return 0; /* ok */
 182 }
 183
 184 static int cmd_yaz_log_level( char *args[], char *outbuff)
 185 {
 186     int  lev = defargint(args[1],LOG_DEFAULT_LEVEL);
 187     char tmp[255];
 188     sprintf(tmp, "setting yaz-log to level %d (ox%x)\n",lev,lev);
 189     strcat(outbuff, tmp);
 190     yaz_log_init_level(lev);
 191     return 0; /* ok */
 192 }
 193
 194 static int cmd_yaz_log_prefix( char *args[], char *outbuff)
 195 {
 196     char *pref = defarg(args[1],"ZebraSh");
 197     char tmp[255];
 198     sprintf(tmp, "setting yaz-log prefix to %s\n",pref);
 199     strcat(outbuff, tmp);
 200     yaz_log_init_prefix(pref);
 201     return 0; /* ok */
 202 }
 203
 204 static int cmd_logf( char *args[], char *outbuff)
 205 {
 206     int lev = defargint(args[1],0);
 207     char tmp[MAX_OUT_BUFF]="";
 208     int i=1;
 209     if (lev)
 210         i=2;
 211     else
 212         lev=LOG_LOG; /* this is in the default set!*/
 213     while (args[i])
 214     {
 215         strcat(tmp, args[i++]);
 216         strcat(tmp, " ");
 217     }
 218     logf(lev,tmp);
 219     return 0; /* ok */
 220 }
 221
 222 /****************
 223  * Error handling
 224  */
 225 static int cmd_err ( char *args[], char *outbuff)
 226 {
 227     char tmp[MAX_OUT_BUFF];
 228     sprintf(tmp, "errCode: %d \nerrStr:  %s\nerrAdd:  %s \n",
 229             zebra_errCode (zh),
 230             zebra_errString (zh),
 231             zebra_errAdd (zh) );
 232     strcat(outbuff, tmp);
 233     return 0; /* ok */
 234 }
 235 static int cmd_errcode ( char *args[], char *outbuff)
 236 {
 237     char tmp[MAX_OUT_BUFF];
 238     sprintf(tmp, "errCode: %d \n",
 239             zebra_errCode (zh));
 240     strcat(outbuff, tmp);
 241     return 0; /* ok */
 242 }
 243 static int cmd_errstr ( char *args[], char *outbuff)
 244 {
 245     char tmp[MAX_OUT_BUFF];
 246     sprintf(tmp, "errStr:  %s\n",
 247             zebra_errString (zh));
 248     strcat(outbuff, tmp);
 249     return 0; /* ok */
 250 }
 251 static int cmd_erradd ( char *args[], char *outbuff)
 252 {
 253     char tmp[MAX_OUT_BUFF];
 254     sprintf(tmp, "errAdd:  %s \n",
 255             zebra_errAdd (zh) );
 256     strcat(outbuff, tmp);
 257     return 0; /* ok */
 258 }
 259
 260 /**************************************
 261  * Admin commands
 262  */
 263
 264 static int cmd_init ( char *args[], char *outbuff)
 265 {
 266     zebra_init(zh);
 267     return 0; /* ok */
 268 }
 269
 270 static int cmd_select_database ( char *args[], char *outbuff)
 271 {
 272     char *db=args[1];
 273     if (!db)
 274         db="Default";
 275     return zebra_select_database(zh, args[1]);
 276 }
 277
 278 /**************************************
 279  * Command table, parser, and help
 280  */
 281
 282 struct cmdstruct
 283 {
 284     char * cmd;
 285     char * args;
 286     char * explanation;
 287     int (*testfunc)(char *args[], char *outbuff);
 288 } ;
 289
 290
 291 struct cmdstruct cmds[] = {
 292     /* special cases:
 293      *   if text is 0, does not list the command
 294      *   if cmd is "", adds the args (and newline) in command listing
 295      */
 296     { "", "Starting and stopping:", "", 0 },
 297     { "zebra_start",
 298       "[configfile]",
 299       "starts the zebra service. You need to call this first\n"
 300       "if no configfile is given, assumes " DEFAULTCONFIG,
 301       cmd_zebra_start },
 302     { "zebra_stop",   "",
 303       "stops the zebra service",
 304       cmd_zebra_stop },
 305     { "zebra_open", "",
 306       "starts a zebra session. Once you have called zebra_start\n"
 307       "you can call zebra_open to start working",
 308       cmd_zebra_open },
 309     { "zebra_close", "",
 310       "closes a zebra session",
 311       cmd_zebra_close },
 312     { "quickstart", "[configfile]",
 313       "Does a zebra_start, zebra_open, and sets up the log",
 314       cmd_quickstart },
 315
 316     { "", "Log file:","", 0},
 317     { "yaz_log_file",
 318       "[filename]",
 319       "Directs the log to filename (or stderr)",
 320       cmd_yaz_log_file },
 321     { "yaz_log_level",
 322       "[level]",
 323       "Sets the logging level (or returns to default)",
 324       cmd_yaz_log_level },
 325     { "yaz_log_prefix",
 326       "[prefix]",
 327       "Sets the log prefix",
 328       cmd_yaz_log_prefix},
 329     { "logf",
 330       "[level] text...",
 331       "writes an entry in the log",
 332       cmd_logf},
 333
 334     { "", "Error handling:","", 0},
 335     { "err",  "",
 336       "Displays zebra's error status (code, str, add)",
 337       cmd_err},
 338     { "errcode",  "",
 339       "Displays zebra's error code",
 340       cmd_errcode},
 341     { "errstr",  "",
 342       "Displays zebra's error string",
 343       cmd_errstr},
 344     { "erradd",  "",
 345       "Displays zebra's additional error message",
 346       cmd_erradd},
 347
 348     { "", "Admin:","", 0},
 349     { "init",  "",
 350       "Initializes the zebra database, destroying all data in it",
 351       cmd_init},
 352     { "select_database",  "basename",
 353       "Selects a database",
 354       cmd_select_database},
 355
 356     { "", "Misc:","", 0},
 357     { "echo", "string",
 358       "ouputs the string",
 359       cmd_echo },
 360     { "quit", "",
 361       "exits the program",
 362       cmd_quit },
 363     { "help", "[command]",
 364       "Gives help on command, or lists them all",
 365       cmd_help },
 366     { "", "help [command] gives more info on command", "",0 },
 367
 368     {0,0,0,0} /* end marker */
 369 };
 370
 371 int onecommand( char *line, char *outbuff)
 372 {
 373     int i;
 374     char *args[MAX_NO_ARGS];
 375     int n;
 376     char argbuf[MAX_ARG_LEN];
 377     logf(LOG_APP,"%s",line);
 378     strncpy(argbuf,line, MAX_ARG_LEN-1);
 379     argbuf[MAX_ARG_LEN-1]='\0'; /* just to be sure */
 380     n=split_args(argbuf, args);
 381     if (0==n)
 382         return -1; /* no command on line, too bad */
 383     for (i=0;cmds[i].cmd;i++)
 384         if (0==strcmp(cmds[i].cmd, args[0]))
 385         {
 386             if (n>1)
 387                 args[0]= line + (args[1]-argbuf); /* rest of the line */
 388             else
 389                 args[0]="";
 390             return ((cmds[i].testfunc)(args,outbuff));
 391         }
 392     strcat(outbuff, "Unknown command '");
 393     strcat(outbuff,args[0] );
 394     strcat(outbuff,"'. Try help");
 395     logf(LOG_APP,"Unknown command");
 396     return -2;
 397 }
 398
 399 static int cmd_help( char *args[], char *outbuff)
 400 {
 401     int i;
 402     char tmp[MAX_ARG_LEN];
 403     if (args[1])
 404     { /* help for a single command */
 405         for (i=0;cmds[i].cmd;i++)
 406             if (0==strcmp(cmds[i].cmd, args[1]))
 407             {
 408                 strcat(outbuff,cmds[i].cmd);
 409                 strcat(outbuff,"  ");
 410                 strcat(outbuff,cmds[i].args);
 411                 strcat(outbuff,"\n");
 412                 strcat(outbuff,cmds[i].explanation);
 413                 strcat(outbuff,"\n");
 414                 return 0;
 415             }
 416         strcat(outbuff, "Unknown command ");
 417         strcat(outbuff, args[1] );
 418     }
 419     else
 420     { /* list all commands */
 421         strcpy(tmp,"    ");
 422         for (i=0;cmds[i].cmd;i++)
 423             if (cmds[i].explanation)
 424             {
 425                 /* sprintf(tmp, "%s %s %s\n",
 426                    cmds[i].cmd, cmds[i].args, cmds[i].explanation);
 427                 */
 428                 strcat(tmp, cmds[i].cmd);
 429                 strcat(tmp,"  ");
 430                 if (!*cmds[i].cmd)
 431                 {
 432                     strcat(outbuff, tmp);
 433                     strcat(outbuff,"\n");
 434                     strcpy(tmp,"    ");
 435                     if (*cmds[i].args)
 436                     {
 437                         strcat(outbuff, cmds[i].args);
 438                         strcat(outbuff,"\n");
 439                     }
 440                 }
 441                 if (strlen(tmp)>50)
 442                 {
 443                     strcat(outbuff,tmp);
 444                     strcat(outbuff,"\n");
 445                     strcpy(tmp,"    ");
 446                 }
 447             }
 448         strcat(outbuff,tmp);
 449     }
 450     return 0;
 451 }
 452
 453 /* If Zebra reports an error after an operation,
 454  * append it to the outbuff and log it */
 455 static void Zerrors ( char *outbuff)
 456 {
 457     int ec;
 458     char tmp[MAX_OUT_BUFF];
 459     if (!zh)
 460         return ;
 461     ec=zebra_errCode (zh);
 462     if (ec)
 463     {
 464         sprintf(tmp, "Zebra error %d: %s, (%s)",
 465                 ec, zebra_errString (zh),
 466                 zebra_errAdd (zh) );
 467         strcat(outbuff, tmp);
 468         strcat(outbuff, "\n");
 469         logf(LOG_APP, tmp);
 470     }
 471 }
 472
 473 /**************************************
 474  * The shell
 475  */
 476
 477 void shell()
 478 {
 479     int rc=0;
 480     char tmp[MAX_ARG_LEN];
 481     while (rc!=-99)
 482     {
 483         char buf[MAX_ARG_LEN];
 484         char outbuff[MAX_OUT_BUFF];
 485 #if HAVE_READLINE_READLINE_H
 486         char* line_in;
 487         line_in=readline(PROMPT);
 488         if (!line_in)
 489             break;
 490 #if HAVE_READLINE_HISTORY_H
 491         if (*line_in)
 492             add_history(line_in);
 493 #endif
 494         if(strlen(line_in) > MAX_ARG_LEN-1) {
 495             fprintf(stderr,"Input line too long\n");
 496             break;
 497         };
 498         strcpy(buf,line_in);
 499         free (line_in);
 500 #else
 501         printf (PROMPT);
 502         fflush (stdout);
 503         if (!fgets (buf, MAX_ARG_LEN-1, stdin))
 504             break;
 505 #endif
 506         outbuff[0]='\0';
 507         rc=onecommand(buf, outbuff);
 508         if (rc==0)
 509         {
 510             strcat(outbuff, "OK\n");
 511             logf(LOG_APP, "OK");
 512         }
 513         else if (rc > 0)
 514         {
 515             sprintf(tmp, "command returned %d\n",rc);
 516             strcat(outbuff,tmp);
 517         }
 518         Zerrors(outbuff);
 519         printf("%s\n", outbuff);
 520     } /* while */
 521 } /* shell() */
 522
 523
 524 /**************************************
 525  * Main
 526  */
 527
 528 int main (int argc, char ** args)
 529 {
 530     shell();
 531     return 0;
 532 } /* main */