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