ztest/ztest.c

   1 /*
   2  * Copyright (C) 1995-2007, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: ztest.c,v 1.95 2007-08-14 12:22:51 adam Exp $
   6  */
   7
   8 /*
   9  * Demonstration of simple server
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <ctype.h>
  15 #if HAVE_UNISTD_H
  16 #include <unistd.h>
  17 #endif
  18
  19 #include <yaz/log.h>
  20 #include <yaz/backend.h>
  21 #include <yaz/ill.h>
  22
  23 static int log_level=0;
  24 static int log_level_set=0;
  25
  26 Z_GenericRecord *dummy_grs_record (int num, ODR o);
  27 char *dummy_marc_record (int num, ODR odr);
  28 char *dummy_xml_record (int num, ODR odr);
  29
  30 int ztest_search(void *handle, bend_search_rr *rr);
  31 int ztest_sort(void *handle, bend_sort_rr *rr);
  32 int ztest_present(void *handle, bend_present_rr *rr);
  33 int ztest_esrequest(void *handle, bend_esrequest_rr *rr);
  34 int ztest_delete(void *handle, bend_delete_rr *rr);
  35
  36 /** \fn get_term_hit
  37     \brief use term value as hit count
  38
  39     Traverse RPN tree 'in order' and use term value as hit count.
  40     Only terms  that looks a numeric is used.. Returns -1 if
  41     no sub tree has a hit count term
  42 */
  43 static int get_term_hit(Z_RPNStructure *s)
  44 {
  45     int h = -1;
  46     switch(s->which)
  47     {
  48     case Z_RPNStructure_simple:
  49         if (s->u.simple->which == Z_Operand_APT)
  50         {
  51             Z_AttributesPlusTerm *apt = s->u.simple->u.attributesPlusTerm;
  52             if (apt->term->which == Z_Term_general)
  53             {
  54                 Odr_oct *oct = apt->term->u.general;
  55                 if (oct->len > 0 && oct->buf[0] >= '0' && oct->buf[0] <= '9')
  56                     h = atoi_n((const char *) oct->buf, oct->len);
  57             }
  58         }
  59         break;
  60     case Z_RPNStructure_complex:
  61         h = get_term_hit(s->u.complex->s1);
  62         if (h == -1)
  63             h = get_term_hit(s->u.complex->s2);
  64         break;
  65     }
  66     return h;
  67 }
  68
  69 /** \fn get_hit_count
  70     \brief gets hit count for numeric terms in RPN queries
  71
  72     This is just for testing.. A real database of course uses
  73     the content of a database to establish a value.. In our case, we
  74     have a way to trigger a certain hit count. Good for testing of
  75     client applications etc
  76 */
  77 static int get_hit_count(Z_Query *q)
  78 {
  79     int h = -1;
  80     if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
  81         h = get_term_hit(q->u.type_1->RPNStructure);
  82     if (h == -1)
  83         h = rand() % 24;
  84     return h;
  85 }
  86
  87 int ztest_search(void *handle, bend_search_rr *rr)
  88 {
  89     if (rr->num_bases != 1)
  90     {
  91         rr->errcode = 23;
  92         return 0;
  93     }
  94     /* Throw Database unavailable if other than Default or Slow */
  95     if (!yaz_matchstr (rr->basenames[0], "Default"))
  96         ;  /* Default is OK in our test */
  97     else if(!yaz_matchstr (rr->basenames[0], "Slow"))
  98     {
  99 #if HAVE_UNISTD_H
 100         /* wait up to 3 seconds and check if connection is still alive */
 101         int i;
 102         for (i = 0; i<3; i++)
 103         {
 104             if (!bend_assoc_is_alive(rr->association))
 105             {
 106                 yaz_log(YLOG_LOG, "search aborted");
 107                 break;
 108             }
 109             sleep(1);
 110         }
 111 #endif
 112         rr->estimated_hit_count = 1;
 113     }
 114     else
 115     {
 116         rr->errcode = 109;
 117         rr->errstring = rr->basenames[0];
 118         return 0;
 119     }
 120
 121     rr->hits = get_hit_count(rr->query);
 122     return 0;
 123 }
 124
 125
 126 /* this huge function handles extended services */
 127 int ztest_esrequest (void *handle, bend_esrequest_rr *rr)
 128 {
 129     /* user-defined handle - created in bend_init */
 130     int *counter = (int*) handle;
 131
 132     yaz_log(log_level, "ESRequest no %d", *counter);
 133
 134     (*counter)++;
 135
 136     if (rr->esr->packageName)
 137         yaz_log(log_level, "packagename: %s", rr->esr->packageName);
 138     yaz_log(log_level, "Waitaction: %d", *rr->esr->waitAction);
 139
 140
 141     yaz_log(log_level, "function: %d", *rr->esr->function);
 142
 143     if (!rr->esr->taskSpecificParameters)
 144     {
 145         yaz_log (log_level, "No task specific parameters");
 146     }
 147     else if (rr->esr->taskSpecificParameters->which == Z_External_itemOrder)
 148     {
 149         Z_ItemOrder *it = rr->esr->taskSpecificParameters->u.itemOrder;
 150         yaz_log (log_level, "Received ItemOrder");
 151         if (it->which == Z_IOItemOrder_esRequest)
 152         {
 153             Z_IORequest *ir = it->u.esRequest;
 154             Z_IOOriginPartToKeep *k = ir->toKeep;
 155             Z_IOOriginPartNotToKeep *n = ir->notToKeep;
 156             const char *xml_in_response = 0;
 157
 158             if (k && k->contact)
 159             {
 160                 if (k->contact->name)
 161                     yaz_log(log_level, "contact name %s", k->contact->name);
 162                 if (k->contact->phone)
 163                     yaz_log(log_level, "contact phone %s", k->contact->phone);
 164                 if (k->contact->email)
 165                     yaz_log(log_level, "contact email %s", k->contact->email);
 166             }
 167             if (k->addlBilling)
 168             {
 169                 yaz_log(log_level, "Billing info (not shown)");
 170             }
 171
 172             if (n->resultSetItem)
 173             {
 174                 yaz_log(log_level, "resultsetItem");
 175                 yaz_log(log_level, "setId: %s", n->resultSetItem->resultSetId);
 176                 yaz_log(log_level, "item: %d", *n->resultSetItem->item);
 177             }
 178             if (n->itemRequest)
 179             {
 180                 Z_External *r = (Z_External*) n->itemRequest;
 181                 ILL_ItemRequest *item_req = 0;
 182                 ILL_APDU *ill_apdu = 0;
 183                 if (r->direct_reference)
 184                 {
 185                     char oid_name_str[OID_STR_MAX];
 186                     oid_class oclass;
 187                     const char *oid_name =
 188                         yaz_oid_to_string_buf(r->direct_reference,
 189                                           &oclass, oid_name_str);
 190                     if (oid_name)
 191                         yaz_log(log_level, "OID %s", oid_name);
 192                     if (!oid_oidcmp(r->direct_reference, yaz_oid_recsyn_xml))
 193                     {
 194                         yaz_log (log_level, "ILL XML request");
 195                         if (r->which == Z_External_octet)
 196                             yaz_log (log_level, "%.*s",
 197                                      r->u.octet_aligned->len,
 198                                      r->u.octet_aligned->buf);
 199                         xml_in_response = "<dummy>x</dummy>";
 200                     }
 201                     if (!oid_oidcmp(r->direct_reference,
 202                                     yaz_oid_general_isoill_1))
 203                     {
 204                         yaz_log (log_level, "Decode ItemRequest begin");
 205                         if (r->which == ODR_EXTERNAL_single)
 206                         {
 207                             odr_setbuf(rr->decode,
 208                                        (char *) r->u.single_ASN1_type->buf,
 209                                        r->u.single_ASN1_type->len, 0);
 210
 211                             if (!ill_ItemRequest (rr->decode, &item_req, 0, 0))
 212                             {
 213                                 yaz_log (log_level,
 214                                     "Couldn't decode ItemRequest %s near %ld",
 215                                        odr_errmsg(odr_geterror(rr->decode)),
 216                                        (long) odr_offset(rr->decode));
 217                             }
 218                             else
 219                                 yaz_log(log_level, "Decode ItemRequest OK");
 220                             if (rr->print)
 221                             {
 222                                 ill_ItemRequest (rr->print, &item_req, 0,
 223                                     "ItemRequest");
 224                                 odr_reset (rr->print);
 225                             }
 226                         }
 227                         if (!item_req && r->which == ODR_EXTERNAL_single)
 228                         {
 229                             yaz_log (log_level, "Decode ILL APDU begin");
 230                             odr_setbuf(rr->decode,
 231                                        (char*) r->u.single_ASN1_type->buf,
 232                                        r->u.single_ASN1_type->len, 0);
 233
 234                             if (!ill_APDU (rr->decode, &ill_apdu, 0, 0))
 235                             {
 236                                 yaz_log (log_level,
 237                                     "Couldn't decode ILL APDU %s near %ld",
 238                                        odr_errmsg(odr_geterror(rr->decode)),
 239                                        (long) odr_offset(rr->decode));
 240                                 yaz_log(log_level, "PDU dump:");
 241                                 odr_dumpBER(yaz_log_file(),
 242                                      (char *) r->u.single_ASN1_type->buf,
 243                                      r->u.single_ASN1_type->len);
 244                             }
 245                             else
 246                                 yaz_log(log_level, "Decode ILL APDU OK");
 247                             if (rr->print)
 248                             {
 249                                 ill_APDU (rr->print, &ill_apdu, 0,
 250                                     "ILL APDU");
 251                                 odr_reset (rr->print);
 252                             }
 253                         }
 254                     }
 255                 }
 256                 if (item_req)
 257                 {
 258                     yaz_log (log_level, "ILL protocol version = %d",
 259                              *item_req->protocol_version_num);
 260                 }
 261             }
 262             if (k)
 263             {
 264
 265                 Z_External *ext = (Z_External *)
 266                     odr_malloc (rr->stream, sizeof(*ext));
 267                 Z_IUOriginPartToKeep *keep = (Z_IUOriginPartToKeep *)
 268                     odr_malloc (rr->stream, sizeof(*keep));
 269                 Z_IOTargetPart *targetPart = (Z_IOTargetPart *)
 270                     odr_malloc (rr->stream, sizeof(*targetPart));
 271
 272                 rr->taskPackage = (Z_TaskPackage *)
 273                     odr_malloc (rr->stream, sizeof(*rr->taskPackage));
 274                 rr->taskPackage->packageType =
 275                     odr_oiddup (rr->stream, rr->esr->packageType);
 276                 rr->taskPackage->packageName = 0;
 277                 rr->taskPackage->userId = 0;
 278                 rr->taskPackage->retentionTime = 0;
 279                 rr->taskPackage->permissions = 0;
 280                 rr->taskPackage->description = 0;
 281                 rr->taskPackage->targetReference = (Odr_oct *)
 282                     odr_malloc (rr->stream, sizeof(Odr_oct));
 283                 rr->taskPackage->targetReference->buf =
 284                     (unsigned char *) odr_strdup (rr->stream, "911");
 285                 rr->taskPackage->targetReference->len =
 286                     rr->taskPackage->targetReference->size =
 287                     strlen((char *) (rr->taskPackage->targetReference->buf));
 288                 rr->taskPackage->creationDateTime = 0;
 289                 rr->taskPackage->taskStatus = odr_intdup(rr->stream, 0);
 290                 rr->taskPackage->packageDiagnostics = 0;
 291                 rr->taskPackage->taskSpecificParameters = ext;
 292
 293                 ext->direct_reference =
 294                     odr_oiddup (rr->stream, rr->esr->packageType);
 295                 ext->indirect_reference = 0;
 296                 ext->descriptor = 0;
 297                 ext->which = Z_External_itemOrder;
 298                 ext->u.itemOrder = (Z_ItemOrder *)
 299                     odr_malloc (rr->stream, sizeof(*ext->u.update));
 300                 ext->u.itemOrder->which = Z_IOItemOrder_taskPackage;
 301                 ext->u.itemOrder->u.taskPackage =  (Z_IOTaskPackage *)
 302                     odr_malloc (rr->stream, sizeof(Z_IOTaskPackage));
 303                 ext->u.itemOrder->u.taskPackage->originPart = k;
 304                 ext->u.itemOrder->u.taskPackage->targetPart = targetPart;
 305
 306                 if (xml_in_response)
 307                     targetPart->itemRequest =
 308                         z_ext_record_xml(rr->stream, xml_in_response,
 309                                          strlen(xml_in_response));
 310                 else
 311                     targetPart->itemRequest = 0;
 312
 313                 targetPart->statusOrErrorReport = 0;
 314                 targetPart->auxiliaryStatus = 0;
 315             }
 316         }
 317     }
 318     else if (rr->esr->taskSpecificParameters->which == Z_External_update)
 319     {
 320         Z_IUUpdate *up = rr->esr->taskSpecificParameters->u.update;
 321         yaz_log (log_level, "Received DB Update");
 322         if (up->which == Z_IUUpdate_esRequest)
 323         {
 324             Z_IUUpdateEsRequest *esRequest = up->u.esRequest;
 325             Z_IUOriginPartToKeep *toKeep = esRequest->toKeep;
 326             Z_IUSuppliedRecords *notToKeep = esRequest->notToKeep;
 327
 328             yaz_log (log_level, "action");
 329             if (toKeep->action)
 330             {
 331                 switch (*toKeep->action)
 332                 {
 333                 case Z_IUOriginPartToKeep_recordInsert:
 334                     yaz_log (log_level, " recordInsert");
 335                     break;
 336                 case Z_IUOriginPartToKeep_recordReplace:
 337                     yaz_log (log_level, " recordReplace");
 338                     break;
 339                 case Z_IUOriginPartToKeep_recordDelete:
 340                     yaz_log (log_level, " recordDelete");
 341                     break;
 342                 case Z_IUOriginPartToKeep_elementUpdate:
 343                     yaz_log (log_level, " elementUpdate");
 344                     break;
 345                 case Z_IUOriginPartToKeep_specialUpdate:
 346                     yaz_log (log_level, " specialUpdate");
 347                     break;
 348                 default:
 349                     yaz_log (log_level, " unknown (%d)", *toKeep->action);
 350                 }
 351             }
 352             if (toKeep->databaseName)
 353             {
 354                 yaz_log (log_level, "database: %s", toKeep->databaseName);
 355                 if (!strcmp(toKeep->databaseName, "fault"))
 356                 {
 357                     rr->errcode = 109;
 358                     rr->errstring = toKeep->databaseName;
 359                 }
 360                 if (!strcmp(toKeep->databaseName, "accept"))
 361                     rr->errcode = -1;
 362             }
 363             if (toKeep)
 364             {
 365                 Z_External *ext = (Z_External *)
 366                     odr_malloc (rr->stream, sizeof(*ext));
 367                 Z_IUOriginPartToKeep *keep = (Z_IUOriginPartToKeep *)
 368                     odr_malloc (rr->stream, sizeof(*keep));
 369                 Z_IUTargetPart *targetPart = (Z_IUTargetPart *)
 370                     odr_malloc (rr->stream, sizeof(*targetPart));
 371
 372                 rr->taskPackage = (Z_TaskPackage *)
 373                     odr_malloc (rr->stream, sizeof(*rr->taskPackage));
 374                 rr->taskPackage->packageType =
 375                     odr_oiddup (rr->stream, rr->esr->packageType);
 376                 rr->taskPackage->packageName = 0;
 377                 rr->taskPackage->userId = 0;
 378                 rr->taskPackage->retentionTime = 0;
 379                 rr->taskPackage->permissions = 0;
 380                 rr->taskPackage->description = 0;
 381                 rr->taskPackage->targetReference = (Odr_oct *)
 382                     odr_malloc (rr->stream, sizeof(Odr_oct));
 383                 rr->taskPackage->targetReference->buf =
 384                     (unsigned char *) odr_strdup (rr->stream, "123");
 385                 rr->taskPackage->targetReference->len =
 386                     rr->taskPackage->targetReference->size =
 387                     strlen((char *) (rr->taskPackage->targetReference->buf));
 388                 rr->taskPackage->creationDateTime = 0;
 389                 rr->taskPackage->taskStatus = odr_intdup(rr->stream, 0);
 390                 rr->taskPackage->packageDiagnostics = 0;
 391                 rr->taskPackage->taskSpecificParameters = ext;
 392
 393                 ext->direct_reference =
 394                     odr_oiddup (rr->stream, rr->esr->packageType);
 395                 ext->indirect_reference = 0;
 396                 ext->descriptor = 0;
 397                 ext->which = Z_External_update;
 398                 ext->u.update = (Z_IUUpdate *)
 399                     odr_malloc (rr->stream, sizeof(*ext->u.update));
 400                 ext->u.update->which = Z_IUUpdate_taskPackage;
 401                 ext->u.update->u.taskPackage =  (Z_IUUpdateTaskPackage *)
 402                     odr_malloc (rr->stream, sizeof(Z_IUUpdateTaskPackage));
 403                 ext->u.update->u.taskPackage->originPart = keep;
 404                 ext->u.update->u.taskPackage->targetPart = targetPart;
 405
 406                 keep->action = (int *) odr_malloc (rr->stream, sizeof(int));
 407                 *keep->action = *toKeep->action;
 408                 keep->databaseName =
 409                     odr_strdup (rr->stream, toKeep->databaseName);
 410                 keep->schema = 0;
 411                 keep->elementSetName = 0;
 412                 keep->actionQualifier = 0;
 413
 414                 targetPart->updateStatus = odr_intdup (rr->stream, 1);
 415                 targetPart->num_globalDiagnostics = 0;
 416                 targetPart->globalDiagnostics = (Z_DiagRec **) odr_nullval();
 417                 targetPart->num_taskPackageRecords = 1;
 418                 targetPart->taskPackageRecords =
 419                     (Z_IUTaskPackageRecordStructure **)
 420                     odr_malloc (rr->stream,
 421                                 sizeof(Z_IUTaskPackageRecordStructure *));
 422                 targetPart->taskPackageRecords[0] =
 423                     (Z_IUTaskPackageRecordStructure *)
 424                     odr_malloc (rr->stream,
 425                                 sizeof(Z_IUTaskPackageRecordStructure));
 426
 427                 targetPart->taskPackageRecords[0]->which =
 428                     Z_IUTaskPackageRecordStructure_record;
 429                 targetPart->taskPackageRecords[0]->u.record =
 430                     z_ext_record_sutrs(rr->stream, "test", 4);
 431                 targetPart->taskPackageRecords[0]->correlationInfo = 0;
 432                 targetPart->taskPackageRecords[0]->recordStatus =
 433                     odr_intdup (rr->stream,
 434                                 Z_IUTaskPackageRecordStructure_success);
 435                 targetPart->taskPackageRecords[0]->num_supplementalDiagnostics
 436                     = 0;
 437
 438                 targetPart->taskPackageRecords[0]->supplementalDiagnostics = 0;
 439             }
 440             if (notToKeep)
 441             {
 442                 int i;
 443                 for (i = 0; i < notToKeep->num; i++)
 444                 {
 445                     Z_External *rec = notToKeep->elements[i]->record;
 446
 447                     if (rec->direct_reference)
 448                     {
 449                         char oid_name_str[OID_STR_MAX];
 450                         const char *oid_name
 451                             = oid_name = yaz_oid_to_string_buf(
 452                                 rec->direct_reference, 0,
 453                                 oid_name_str);
 454                         if (oid_name)
 455                             yaz_log (log_level, "record %d type %s", i,
 456                                      oid_name);
 457                     }
 458                     switch (rec->which)
 459                     {
 460                     case Z_External_sutrs:
 461                         if (rec->u.octet_aligned->len > 170)
 462                             yaz_log (log_level, "%d bytes:\n%.168s ...",
 463                                      rec->u.sutrs->len,
 464                                      rec->u.sutrs->buf);
 465                         else
 466                             yaz_log (log_level, "%d bytes:\n%s",
 467                                      rec->u.sutrs->len,
 468                                      rec->u.sutrs->buf);
 469                         break;
 470                     case Z_External_octet        :
 471                         if (rec->u.octet_aligned->len > 170)
 472                             yaz_log (log_level, "%d bytes:\n%.168s ...",
 473                                      rec->u.octet_aligned->len,
 474                                      rec->u.octet_aligned->buf);
 475                         else
 476                             yaz_log (log_level, "%d bytes\n%s",
 477                                      rec->u.octet_aligned->len,
 478                                      rec->u.octet_aligned->buf);
 479                     }
 480                 }
 481             }
 482         }
 483     }
 484     return 0;
 485 }
 486
 487 /* result set delete */
 488 int ztest_delete (void *handle, bend_delete_rr *rr)
 489 {
 490     if (rr->num_setnames == 1 && !strcmp (rr->setnames[0], "1"))
 491         rr->delete_status = Z_DeleteStatus_success;
 492     else
 493         rr->delete_status = Z_DeleteStatus_resultSetDidNotExist;
 494     return 0;
 495 }
 496
 497 /* Our sort handler really doesn't sort... */
 498 int ztest_sort (void *handle, bend_sort_rr *rr)
 499 {
 500     rr->errcode = 0;
 501     rr->sort_status = Z_SortResponse_success;
 502     return 0;
 503 }
 504
 505
 506 /* present request handler */
 507 int ztest_present (void *handle, bend_present_rr *rr)
 508 {
 509     return 0;
 510 }
 511
 512 /* retrieval of a single record (present, and piggy back search) */
 513 int ztest_fetch(void *handle, bend_fetch_rr *r)
 514 {
 515     char *cp;
 516     const Odr_oid *oid = r->request_format;
 517
 518     r->last_in_set = 0;
 519     r->basename = "Default";
 520     r->output_format = r->request_format;
 521
 522     if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_sutrs))
 523     {
 524         /* this section returns a small record */
 525         char buf[100];
 526
 527         sprintf(buf, "This is dummy SUTRS record number %d\n", r->number);
 528
 529         r->len = strlen(buf);
 530         r->record = (char *) odr_malloc (r->stream, r->len+1);
 531         strcpy(r->record, buf);
 532     }
 533     else if (oid &&  !oid_oidcmp(oid, yaz_oid_recsyn_grs_1))
 534     {
 535         r->len = -1;
 536         r->record = (char*) dummy_grs_record(r->number, r->stream);
 537         if (!r->record)
 538         {
 539             r->errcode = 13;
 540             return 0;
 541         }
 542     }
 543     else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_postscript))
 544     {
 545         char fname[20];
 546         FILE *f;
 547         long size;
 548
 549         sprintf (fname, "part.%d.ps", r->number);
 550         f = fopen(fname, "rb");
 551         if (!f)
 552         {
 553             r->errcode = 13;
 554             return 0;
 555         }
 556         fseek (f, 0L, SEEK_END);
 557         size = ftell (f);
 558         if (size <= 0 || size >= 5000000)
 559         {
 560             r->errcode = 14;
 561             return 0;
 562         }
 563         fseek (f, 0L, SEEK_SET);
 564         r->record = (char*) odr_malloc (r->stream, size);
 565         r->len = size;
 566         fread (r->record, size, 1, f);
 567         fclose (f);
 568     }
 569     else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_xml))
 570     {
 571         if ((cp = dummy_xml_record (r->number, r->stream)))
 572         {
 573             r->len = strlen(cp);
 574             r->record = cp;
 575         }
 576         else
 577         {
 578             r->errcode = 14;
 579             r->surrogate_flag = 1;
 580             return 0;
 581         }
 582     }
 583     else if ((cp = dummy_marc_record(r->number, r->stream)))
 584     {
 585         r->len = strlen(cp);
 586         r->record = cp;
 587         r->output_format = odr_oiddup(r->stream, yaz_oid_recsyn_usmarc);
 588     }
 589     else
 590     {
 591         r->errcode = 13;
 592         return 0;
 593     }
 594     r->errcode = 0;
 595     return 0;
 596 }
 597
 598 /*
 599  * silly dummy-scan what reads words from a file.
 600  */
 601 int ztest_scan(void *handle, bend_scan_rr *q)
 602 {
 603     static FILE *f = 0;
 604     static struct scan_entry list[200];
 605     static char entries[200][80];
 606     int hits[200];
 607     char term[80], *p;
 608     int i, pos;
 609     int term_position_req = q->term_position;
 610     int num_entries_req = q->num_entries;
 611
 612     /* Throw Database unavailable if other than Default or Slow */
 613     if (!yaz_matchstr (q->basenames[0], "Default"))
 614         ;  /* Default is OK in our test */
 615     else if(!yaz_matchstr (q->basenames[0], "Slow"))
 616     {
 617 #if HAVE_UNISTD_H
 618         sleep(3);
 619 #endif
 620         ;
 621     }
 622     else
 623     {
 624         q->errcode = 109;
 625         q->errstring = q->basenames[0];
 626         return 0;
 627     }
 628
 629     q->errcode = 0;
 630     q->errstring = 0;
 631     q->entries = list;
 632     q->status = BEND_SCAN_SUCCESS;
 633     if (!f && !(f = fopen("dummy-words", "r")))
 634     {
 635         perror("dummy-words");
 636         exit(1);
 637     }
 638     if (q->num_entries > 200)
 639     {
 640         q->errcode = 31;
 641         return 0;
 642     }
 643     if (q->term)
 644     {
 645         int len;
 646         if (q->term->term->which != Z_Term_general)
 647         {
 648             q->errcode = 229; /* unsupported term type */
 649             return 0;
 650         }
 651         if (*q->step_size != 0)
 652         {
 653             q->errcode = 205; /*Only zero step size supported for Scan */
 654             return 0;
 655         }
 656         len = q->term->term->u.general->len;
 657         if (len >= sizeof(term))
 658             len = sizeof(term)-1;
 659         memcpy(term, q->term->term->u.general->buf, len);
 660         term[len] = '\0';
 661     }
 662     else if (q->scanClause)
 663     {
 664         strncpy(term, q->scanClause, sizeof(term)-1);
 665         term[sizeof(term)-1] = '\0';
 666     }
 667     else
 668         strcpy(term, "0");
 669
 670     for (p = term; *p; p++)
 671         if (islower(*(unsigned char *) p))
 672             *p = toupper(*p);
 673
 674     fseek(f, 0, SEEK_SET);
 675     q->num_entries = 0;
 676
 677     for (i = 0, pos = 0; fscanf(f, " %79[^:]:%d", entries[pos], &hits[pos]) == 2;
 678         i++, pos < 199 ? pos++ : (pos = 0))
 679     {
 680         if (!q->num_entries && strcmp(entries[pos], term) >= 0) /* s-point fnd */
 681         {
 682             if ((q->term_position = term_position_req) > i + 1)
 683             {
 684                 q->term_position = i + 1;
 685                 q->status = BEND_SCAN_PARTIAL;
 686             }
 687             for (; q->num_entries < q->term_position; q->num_entries++)
 688             {
 689                 int po;
 690
 691                 po = pos - q->term_position + q->num_entries+1; /* find pos */
 692                 if (po < 0)
 693                     po += 200;
 694
 695                 if (!strcmp (term, "SD") && q->num_entries == 2)
 696                 {
 697                     list[q->num_entries].term = entries[pos];
 698                     list[q->num_entries].occurrences = -1;
 699                     list[q->num_entries].errcode = 233;
 700                     list[q->num_entries].errstring = "SD for Scan Term";
 701                 }
 702                 else
 703                 {
 704                     list[q->num_entries].term = entries[po];
 705                     list[q->num_entries].occurrences = hits[po];
 706                 }
 707             }
 708         }
 709         else if (q->num_entries)
 710         {
 711             list[q->num_entries].term = entries[pos];
 712             list[q->num_entries].occurrences = hits[pos];
 713             q->num_entries++;
 714         }
 715         if (q->num_entries >= num_entries_req)
 716             break;
 717     }
 718     if (feof(f))
 719         q->status = BEND_SCAN_PARTIAL;
 720     return 0;
 721 }
 722
 723 int ztest_explain(void *handle, bend_explain_rr *rr)
 724 {
 725     if (rr->database && !strcmp(rr->database, "Default"))
 726     {
 727         rr->explain_buf = "<explain>\n"
 728             "\t<serverInfo>\n"
 729             "\t\t<host>localhost</host>\n"
 730             "\t\t<port>210</port>\n"
 731             "\t</serverInfo>\n"
 732             "</explain>\n";
 733     }
 734     return 0;
 735 }
 736
 737 int ztest_update(void *handle, bend_update_rr *rr)
 738 {
 739     rr->operation_status = "success";
 740     return 0;
 741 }
 742
 743 bend_initresult *bend_init(bend_initrequest *q)
 744 {
 745     bend_initresult *r = (bend_initresult *)
 746         odr_malloc (q->stream, sizeof(*r));
 747     int *counter = (int *) xmalloc (sizeof(int));
 748
 749     if (!log_level_set)
 750     {
 751         log_level=yaz_log_module_level("ztest");
 752         log_level_set=1;
 753     }
 754
 755     *counter = 0;
 756     r->errcode = 0;
 757     r->errstring = 0;
 758     r->handle = counter;         /* user handle, in this case a simple int */
 759     q->bend_sort = ztest_sort;              /* register sort handler */
 760     q->bend_search = ztest_search;          /* register search handler */
 761     q->bend_present = ztest_present;        /* register present handle */
 762     q->bend_esrequest = ztest_esrequest;
 763     q->bend_delete = ztest_delete;
 764     q->bend_fetch = ztest_fetch;
 765     q->bend_scan = ztest_scan;
 766 #if 0
 767     q->bend_explain = ztest_explain;
 768 #endif
 769     q->bend_srw_scan = ztest_scan;
 770     q->bend_srw_update = ztest_update;
 771
 772     q->query_charset = "ISO-8859-1";
 773     q->records_in_same_charset = 0;
 774
 775     return r;
 776 }
 777
 778 void bend_close(void *handle)
 779 {
 780     xfree (handle);              /* release our user-defined handle */
 781     return;
 782 }
 783
 784 int main(int argc, char **argv)
 785 {
 786     return statserv_main(argc, argv, bend_init, bend_close);
 787 }
 788 /*
 789  * Local variables:
 790  * c-basic-offset: 4
 791  * indent-tabs-mode: nil
 792  * End:
 793  * vim: shiftwidth=4 tabstop=8 expandtab
 794  */
 795