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