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