index/zebraapi.c

   1 /*
   2  * Copyright (C) 1995-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zebraapi.c,v $
   7  * Revision 1.18  1999-05-15 14:36:38  adam
   8  * Updated dictionary. Implemented "compression" of dictionary.
   9  *
  10  * Revision 1.17  1999/05/12 13:08:06  adam
  11  * First version of ISAMS.
  12  *
  13  * Revision 1.16  1999/02/19 10:38:30  adam
  14  * Implemented chdir-setting.
  15  *
  16  * Revision 1.15  1999/02/17 12:18:12  adam
  17  * Fixed zebra_close so that a NULL pointer is ignored.
  18  *
  19  * Revision 1.14  1999/02/02 14:51:11  adam
  20  * Updated WIN32 code specific sections. Changed header.
  21  *
  22  * Revision 1.13  1998/12/16 12:23:30  adam
  23  * Added facility for database name mapping using resource mapdb.
  24  *
  25  * Revision 1.12  1998/11/16 10:18:10  adam
  26  * Better error reporting for result sets.
  27  *
  28  * Revision 1.11  1998/10/16 08:14:34  adam
  29  * Updated record control system.
  30  *
  31  * Revision 1.10  1998/09/22 10:03:42  adam
  32  * Changed result sets to be persistent in the sense that they can
  33  * be re-searched if needed.
  34  * Fixed memory leak in rsm_or.
  35  *
  36  * Revision 1.9  1998/09/02 13:53:17  adam
  37  * Extra parameter decode added to search routines to implement
  38  * persistent queries.
  39  *
  40  * Revision 1.8  1998/08/24 17:29:23  adam
  41  * Minor changes.
  42  *
  43  * Revision 1.7  1998/06/24 12:16:13  adam
  44  * Support for relations on text operands. Open range support in
  45  * DFA module (i.e. [-j], [g-]).
  46  *
  47  * Revision 1.6  1998/06/22 11:36:47  adam
  48  * Added authentication check facility to zebra.
  49  *
  50  * Revision 1.5  1998/06/13 00:14:08  adam
  51  * Minor changes.
  52  *
  53  * Revision 1.4  1998/06/12 12:22:12  adam
  54  * Work on Zebra API.
  55  *
  56  * Revision 1.3  1998/05/27 16:57:44  adam
  57  * Zebra returns surrogate diagnostic for single records when
  58  * appropriate.
  59  *
  60  * Revision 1.2  1998/05/20 10:12:19  adam
  61  * Implemented automatic EXPLAIN database maintenance.
  62  * Modified Zebra to work with ASN.1 compiled version of YAZ.
  63  *
  64  * Revision 1.1  1998/03/05 08:45:13  adam
  65  * New result set model and modular ranking system. Moved towards
  66  * descent server API. System information stored as "SGML" records.
  67  *
  68  */
  69
  70 #include <stdio.h>
  71 #ifdef WIN32
  72 #include <io.h>
  73 #include <process.h>
  74 #include <direct.h>
  75 #else
  76 #include <unistd.h>
  77 #endif
  78
  79 #include <diagbib1.h>
  80 #include "zserver.h"
  81
  82 static void zebra_chdir (ZebraHandle zh)
  83 {
  84     const char *dir = res_get (zh->res, "chdir");
  85     if (!dir)
  86         return;
  87     logf (LOG_DEBUG, "chdir %s", dir);
  88 #ifdef WIN32
  89     _chdir(dir);
  90 #else
  91     chdir (dir);
  92 #endif
  93 }
  94 static int zebra_register_lock (ZebraHandle zh)
  95 {
  96     time_t lastChange;
  97     int state;
  98
  99     zebra_chdir (zh);
 100
 101     state = zebra_server_lock_get_state(zh, &lastChange);
 102
 103     switch (state)
 104     {
 105     case 'c':
 106         state = 1;
 107         break;
 108     default:
 109         state = 0;
 110     }
 111     zebra_server_lock (zh, state);
 112 #if USE_TIMES
 113     times (&zh->tms1);
 114 #endif
 115     if (zh->registerState == state)
 116     {
 117         if (zh->registerChange >= lastChange)
 118             return 0;
 119         logf (LOG_LOG, "Register completely updated since last access");
 120     }
 121     else if (zh->registerState == -1)
 122         logf (LOG_LOG, "Reading register using state %d pid=%ld", state,
 123               (long) getpid());
 124     else
 125         logf (LOG_LOG, "Register has changed state from %d to %d",
 126               zh->registerState, state);
 127     zh->registerChange = lastChange;
 128     if (zh->records)
 129     {
 130         zebraExplain_close (zh->zei, 0, 0);
 131         dict_close (zh->dict);
 132         sortIdx_close (zh->sortIdx);
 133         if (zh->isam)
 134             is_close (zh->isam);
 135         if (zh->isamc)
 136             isc_close (zh->isamc);
 137         rec_close (&zh->records);
 138     }
 139     bf_cache (zh->bfs, state ? res_get (zh->res, "shadow") : NULL);
 140     zh->registerState = state;
 141     zh->records = rec_open (zh->bfs, 0);
 142     if (!(zh->dict = dict_open (zh->bfs, FNAME_DICT, 40, 0, 0)))
 143     {
 144         logf (LOG_WARN, "dict_open");
 145         return -1;
 146     }
 147     if (!(zh->sortIdx = sortIdx_open (zh->bfs, 0)))
 148     {
 149         logf (LOG_WARN, "sortIdx_open");
 150         return -1;
 151     }
 152     zh->isam = NULL;
 153     zh->isamc = NULL;
 154     zh->isams = NULL;
 155     if (res_get_match (zh->res, "isam", "i", NULL))
 156     {
 157         if (!(zh->isam = is_open (zh->bfs, FNAME_ISAM, key_compare, 0,
 158                                   sizeof (struct it_key), zh->res)))
 159         {
 160             logf (LOG_WARN, "is_open");
 161             return -1;
 162         }
 163     }
 164     else if (res_get_match (zh->res, "isam", "s", NULL))
 165     {
 166         if (!(zh->isams = isams_open (zh->bfs, FNAME_ISAMS, 0,
 167                                       key_isams_m(zh->res))))
 168         {
 169             logf (LOG_WARN, "isams_open");
 170             return -1;
 171         }
 172     }
 173     else
 174     {
 175         if (!(zh->isamc = isc_open (zh->bfs, FNAME_ISAMC,
 176                                     0, key_isamc_m(zh->res))))
 177         {
 178             logf (LOG_WARN, "isc_open");
 179             return -1;
 180         }
 181     }
 182     zh->zei = zebraExplain_open (zh->records, zh->dh, zh->res, 0, 0, 0);
 183
 184     return 0;
 185 }
 186
 187 static void zebra_register_unlock (ZebraHandle zh)
 188 {
 189     static int waitSec = -1;
 190
 191 #if USE_TIMES
 192     times (&zh->tms2);
 193     logf (LOG_LOG, "user/system: %ld/%ld",
 194                         (long) (zh->tms2.tms_utime - zh->tms1.tms_utime),
 195                         (long) (zh->tms2.tms_stime - zh->tms1.tms_stime));
 196 #endif
 197     if (waitSec == -1)
 198     {
 199         char *s = res_get (zh->res, "debugRequestWait");
 200         if (s)
 201             waitSec = atoi (s);
 202         else
 203             waitSec = 0;
 204     }
 205 #ifdef WIN32
 206 #else
 207     if (waitSec > 0)
 208         sleep (waitSec);
 209 #endif
 210     if (zh->registerState != -1)
 211         zebra_server_unlock (zh, zh->registerState);
 212 }
 213
 214 ZebraHandle zebra_open (const char *configName)
 215 {
 216     ZebraHandle zh = xmalloc (sizeof(*zh));
 217
 218     if (!(zh->res = res_open (configName)))
 219     {
 220         logf (LOG_WARN, "Failed to read resources `%s'", configName);
 221         return NULL;
 222     }
 223     zebra_chdir (zh);
 224     zebra_server_lock_init (zh);
 225     zh->dh = data1_create ();
 226     zh->bfs = bfs_create (res_get (zh->res, "register"));
 227     bf_lockDir (zh->bfs, res_get (zh->res, "lockDir"));
 228     data1_set_tabpath (zh->dh, res_get(zh->res, "profilePath"));
 229     zh->sets = NULL;
 230     zh->registerState = -1;  /* trigger open of registers! */
 231     zh->registerChange = 0;
 232     zh->recTypes = recTypes_init (zh->dh);
 233     recTypes_default_handlers (zh->recTypes);
 234
 235     zh->records = NULL;
 236     zh->zebra_maps = zebra_maps_open (zh->res);
 237     zh->rank_classes = NULL;
 238     zh->errCode = 0;
 239     zh->errString = 0;
 240
 241     zebraRankInstall (zh, rank1_class);
 242
 243     if (!res_get (zh->res, "passwd"))
 244         zh->passwd_db = NULL;
 245     else
 246     {
 247         zh->passwd_db = passwd_db_open ();
 248         if (!zh->passwd_db)
 249             logf (LOG_WARN|LOG_ERRNO, "passwd_db_open failed");
 250         else
 251             passwd_db_file (zh->passwd_db, res_get (zh->res, "passwd"));
 252     }
 253     return zh;
 254 }
 255
 256 void zebra_close (ZebraHandle zh)
 257 {
 258     if (!zh)
 259         return;
 260     zebra_chdir (zh);
 261     if (zh->records)
 262     {
 263         resultSetDestroy (zh);
 264         zebraExplain_close (zh->zei, 0, 0);
 265         dict_close (zh->dict);
 266         sortIdx_close (zh->sortIdx);
 267         if (zh->isam)
 268             is_close (zh->isam);
 269         if (zh->isamc)
 270             isc_close (zh->isamc);
 271         if (zh->isams)
 272             isams_close (zh->isams);
 273         rec_close (&zh->records);
 274         zebra_register_unlock (zh);
 275     }
 276     recTypes_destroy (zh->recTypes);
 277     zebra_maps_close (zh->zebra_maps);
 278     zebraRankDestroy (zh);
 279     bfs_destroy (zh->bfs);
 280     data1_destroy (zh->dh);
 281     zebra_server_lock_destroy (zh);
 282
 283     if (zh->passwd_db)
 284         passwd_db_close (zh->passwd_db);
 285     res_close (zh->res);
 286     xfree (zh);
 287 }
 288
 289 struct map_baseinfo {
 290     ZebraHandle zh;
 291     NMEM mem;
 292     int num_bases;
 293     char **basenames;
 294     int new_num_bases;
 295     char **new_basenames;
 296     int new_num_max;
 297 };
 298
 299 void map_basenames_func (void *vp, const char *name, const char *value)
 300 {
 301     struct map_baseinfo *p = vp;
 302     int i, no;
 303     char fromdb[128], todb[8][128];
 304
 305     no =
 306         sscanf (value, "%127s %127s %127s %127s %127s %127s %127s %127s %127s",
 307                 fromdb, todb[0], todb[1], todb[2], todb[3], todb[4],
 308                 todb[5], todb[6], todb[7]);
 309     if (no < 2)
 310         return ;
 311     no--;
 312     for (i = 0; i<p->num_bases; i++)
 313         if (p->basenames[i] && !strcmp (p->basenames[i], fromdb))
 314         {
 315             p->basenames[i] = 0;
 316             for (i = 0; i < no; i++)
 317             {
 318                 if (p->new_num_bases == p->new_num_max)
 319                     return;
 320                 p->new_basenames[(p->new_num_bases)++] =
 321                     nmem_strdup (p->mem, todb[i]);
 322             }
 323             return;
 324         }
 325 }
 326
 327 void map_basenames (ZebraHandle zh, ODR stream,
 328                     int *num_bases, char ***basenames)
 329 {
 330     struct map_baseinfo info;
 331     struct map_baseinfo *p = &info;
 332     int i;
 333
 334     info.zh = zh;
 335     info.num_bases = *num_bases;
 336     info.basenames = *basenames;
 337     info.new_num_max = 128;
 338     info.new_num_bases = 0;
 339     info.new_basenames = (char **)
 340         odr_malloc (stream, sizeof(*info.new_basenames) * info.new_num_max);
 341     info.mem = stream->mem;
 342
 343     res_trav (zh->res, "mapdb", &info, map_basenames_func);
 344
 345     for (i = 0; i<p->num_bases; i++)
 346         if (p->basenames[i] && p->new_num_bases < p->new_num_max)
 347         {
 348             p->new_basenames[(p->new_num_bases)++] =
 349                 nmem_strdup (p->mem, p->basenames[i]);
 350         }
 351     *num_bases = info.new_num_bases;
 352     *basenames = info.new_basenames;
 353     for (i = 0; i<*num_bases; i++)
 354         logf (LOG_LOG, "base %s", (*basenames)[i]);
 355 }
 356
 357 void zebra_search_rpn (ZebraHandle zh, ODR stream, ODR decode,
 358                        Z_RPNQuery *query, int num_bases, char **basenames,
 359                        const char *setname)
 360 {
 361     zebra_register_lock (zh);
 362     zh->errCode = 0;
 363     zh->errString = NULL;
 364     zh->hits = 0;
 365
 366     map_basenames (zh, stream, &num_bases, &basenames);
 367     resultSetAddRPN (zh, stream, decode, query, num_bases, basenames, setname);
 368
 369     zebra_register_unlock (zh);
 370 }
 371
 372 void zebra_records_retrieve (ZebraHandle zh, ODR stream,
 373                              const char *setname, Z_RecordComposition *comp,
 374                              oid_value input_format, int num_recs,
 375                              ZebraRetrievalRecord *recs)
 376 {
 377     ZebraPosSet poset;
 378     int i, *pos_array;
 379
 380     zh->errCode = 0;
 381     zh->errString = NULL;
 382     pos_array = xmalloc (num_recs * sizeof(*pos_array));
 383     for (i = 0; i<num_recs; i++)
 384         pos_array[i] = recs[i].position;
 385
 386     zebra_register_lock (zh);
 387
 388     poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
 389     if (!poset)
 390     {
 391         logf (LOG_DEBUG, "zebraPosSetCreate error");
 392         zh->errCode = 30;
 393         zh->errString = nmem_strdup (stream->mem, setname);
 394     }
 395     else
 396     {
 397         for (i = 0; i<num_recs; i++)
 398         {
 399             if (!poset[i].sysno)
 400             {
 401                 char num_str[20];
 402
 403                 sprintf (num_str, "%d", pos_array[i]);
 404                 zh->errCode = 13;
 405                 zh->errString = nmem_strdup (stream->mem, num_str);
 406                 break;
 407             }
 408             else
 409             {
 410                 recs[i].errCode =
 411                     zebra_record_fetch (zh, poset[i].sysno, poset[i].score,
 412                                         stream, input_format, comp,
 413                                         &recs[i].format, &recs[i].buf,
 414                                         &recs[i].len,
 415                                         &recs[i].base);
 416                 recs[i].errString = NULL;
 417             }
 418         }
 419         zebraPosSetDestroy (zh, poset, num_recs);
 420     }
 421     zebra_register_unlock (zh);
 422     xfree (pos_array);
 423 }
 424
 425 void zebra_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
 426                  oid_value attributeset,
 427                  int num_bases, char **basenames,
 428                  int *position, int *num_entries, ZebraScanEntry **entries,
 429                  int *is_partial)
 430 {
 431     zh->errCode = 0;
 432     zh->errString = NULL;
 433     zebra_register_lock (zh);
 434     map_basenames (zh, stream, &num_bases, &basenames);
 435     rpn_scan (zh, stream, zapt, attributeset,
 436               num_bases, basenames, position,
 437               num_entries, entries, is_partial);
 438     zebra_register_unlock (zh);
 439 }
 440
 441 void zebra_sort (ZebraHandle zh, ODR stream,
 442                  int num_input_setnames, const char **input_setnames,
 443                  const char *output_setname, Z_SortKeySpecList *sort_sequence,
 444                  int *sort_status)
 445 {
 446     zh->errCode = 0;
 447     zh->errString = NULL;
 448     zebra_register_lock (zh);
 449     resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
 450                    output_setname, sort_sequence, sort_status);
 451     zebra_register_unlock (zh);
 452 }
 453
 454 int zebra_errCode (ZebraHandle zh)
 455 {
 456     return zh->errCode;
 457 }
 458
 459 const char *zebra_errString (ZebraHandle zh)
 460 {
 461     return diagbib1_str (zh->errCode);
 462 }
 463
 464 char *zebra_errAdd (ZebraHandle zh)
 465 {
 466     return zh->errString;
 467 }
 468
 469 int zebra_hits (ZebraHandle zh)
 470 {
 471     return zh->hits;
 472 }
 473
 474 int zebra_auth (ZebraHandle zh, const char *user, const char *pass)
 475 {
 476     if (!zh->passwd_db || !passwd_db_auth (zh->passwd_db, user, pass))
 477         return 0;
 478     return 1;
 479 }
 480
 481 void zebra_setDB (ZebraHandle zh, int num_bases, char **basenames)
 482 {
 483
 484 }
 485
 486 void zebra_setRecordType (ZebraHandle zh, const char *type)
 487 {
 488
 489 }
 490
 491 void zebra_setGroup (ZebraHandle zh, const char *group)
 492 {
 493
 494 }
 495
 496 void zebra_admin (ZebraHandle zh, const char *command)
 497 {
 498
 499 }