ztest/ztest.c

   1 /*
   2  * Copyright (c) 1995-2002, Index Data.
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: ztest.c,v 1.53 2002-07-31 14:06:29 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
  16 #include <yaz/backend.h>
  17 #include <yaz/log.h>
  18
  19 #include <yaz/ill.h>
  20
  21 Z_GenericRecord *dummy_grs_record (int num, ODR o);
  22 char *dummy_marc_record (int num, ODR odr);
  23 char *dummy_xml_record (int num, ODR odr);
  24
  25 int ztest_search (void *handle, bend_search_rr *rr);
  26 int ztest_sort (void *handle, bend_sort_rr *rr);
  27 int ztest_present (void *handle, bend_present_rr *rr);
  28 int ztest_esrequest (void *handle, bend_esrequest_rr *rr);
  29 int ztest_delete (void *handle, bend_delete_rr *rr);
  30
  31 int ztest_search (void *handle, bend_search_rr *rr)
  32 {
  33     if (rr->num_bases != 1)
  34     {
  35         rr->errcode = 23;
  36         return 0;
  37     }
  38     if (strcmp (rr->basenames[0], "Default"))
  39     {
  40         rr->errcode = 109;
  41         rr->errstring = rr->basenames[0];
  42         return 0;
  43     }
  44     rr->hits = rand() % 24;
  45     return 0;
  46 }
  47
  48
  49 /* this huge function handles extended services */
  50 int ztest_esrequest (void *handle, bend_esrequest_rr *rr)
  51 {
  52     /* user-defined handle - created in bend_init */
  53     int *counter = (int*) handle;
  54
  55     yaz_log(LOG_LOG, "ESRequest no %d", *counter);
  56
  57     (*counter)++;
  58
  59     if (rr->esr->packageName)
  60         yaz_log(LOG_LOG, "packagename: %s", rr->esr->packageName);
  61     yaz_log(LOG_LOG, "Waitaction: %d", *rr->esr->waitAction);
  62
  63
  64     yaz_log(LOG_LOG, "function: %d", *rr->esr->function);
  65
  66     if (!rr->esr->taskSpecificParameters)
  67     {
  68         yaz_log (LOG_WARN, "No task specific parameters");
  69     }
  70     else if (rr->esr->taskSpecificParameters->which == Z_External_itemOrder)
  71     {
  72         Z_ItemOrder *it = rr->esr->taskSpecificParameters->u.itemOrder;
  73         yaz_log (LOG_LOG, "Received ItemOrder");
  74         if (it->which == Z_IOItemOrder_esRequest)
  75         {
  76             Z_IORequest *ir = it->u.esRequest;
  77             Z_IOOriginPartToKeep *k = ir->toKeep;
  78             Z_IOOriginPartNotToKeep *n = ir->notToKeep;
  79
  80             if (k && k->contact)
  81             {
  82                 if (k->contact->name)
  83                     yaz_log(LOG_LOG, "contact name %s", k->contact->name);
  84                 if (k->contact->phone)
  85                     yaz_log(LOG_LOG, "contact phone %s", k->contact->phone);
  86                 if (k->contact->email)
  87                     yaz_log(LOG_LOG, "contact email %s", k->contact->email);
  88             }
  89             if (k->addlBilling)
  90             {
  91                 yaz_log(LOG_LOG, "Billing info (not shown)");
  92             }
  93
  94             if (n->resultSetItem)
  95             {
  96                 yaz_log(LOG_LOG, "resultsetItem");
  97                 yaz_log(LOG_LOG, "setId: %s", n->resultSetItem->resultSetId);
  98                 yaz_log(LOG_LOG, "item: %d", *n->resultSetItem->item);
  99             }
 100             if (n->itemRequest)
 101             {
 102                 Z_External *r = (Z_External*) n->itemRequest;
 103                 ILL_ItemRequest *item_req = 0;
 104                 ILL_APDU *ill_apdu = 0;
 105                 if (r->direct_reference)
 106                 {
 107                     oident *ent = oid_getentbyoid(r->direct_reference);
 108                     if (ent)
 109                         yaz_log(LOG_LOG, "OID %s", ent->desc);
 110                     if (ent && ent->value == VAL_TEXT_XML)
 111                     {
 112                         yaz_log (LOG_LOG, "ILL XML request");
 113                         if (r->which == Z_External_octet)
 114                             yaz_log (LOG_LOG, "%.*s", r->u.octet_aligned->len,
 115                                      r->u.octet_aligned->buf);
 116                     }
 117                     if (ent && ent->value == VAL_ISO_ILL_1)
 118                     {
 119                         yaz_log (LOG_LOG, "Decode ItemRequest begin");
 120                         if (r->which == ODR_EXTERNAL_single)
 121                         {
 122                             odr_setbuf(rr->decode,
 123                                        (char *) r->u.single_ASN1_type->buf,
 124                                        r->u.single_ASN1_type->len, 0);
 125
 126                             if (!ill_ItemRequest (rr->decode, &item_req, 0, 0))
 127                             {
 128                                 yaz_log (LOG_LOG,
 129                                     "Couldn't decode ItemRequest %s near %d",
 130                                        odr_errmsg(odr_geterror(rr->decode)),
 131                                        odr_offset(rr->decode));
 132                             }
 133                             else
 134                                 yaz_log(LOG_LOG, "Decode ItemRequest OK");
 135                             if (rr->print)
 136                             {
 137                                 ill_ItemRequest (rr->print, &item_req, 0,
 138                                     "ItemRequest");
 139                                 odr_reset (rr->print);
 140                             }
 141                         }
 142                         if (!item_req && r->which == ODR_EXTERNAL_single)
 143                         {
 144                             yaz_log (LOG_LOG, "Decode ILL APDU begin");
 145                             odr_setbuf(rr->decode,
 146                                        (char*) r->u.single_ASN1_type->buf,
 147                                        r->u.single_ASN1_type->len, 0);
 148
 149                             if (!ill_APDU (rr->decode, &ill_apdu, 0, 0))
 150                             {
 151                                 yaz_log (LOG_LOG,
 152                                     "Couldn't decode ILL APDU %s near %d",
 153                                        odr_errmsg(odr_geterror(rr->decode)),
 154                                        odr_offset(rr->decode));
 155                                 yaz_log(LOG_LOG, "PDU dump:");
 156                                 odr_dumpBER(yaz_log_file(),
 157                                      (char *) r->u.single_ASN1_type->buf,
 158                                      r->u.single_ASN1_type->len);
 159                             }
 160                             else
 161                                 yaz_log(LOG_LOG, "Decode ILL APDU OK");
 162                             if (rr->print)
 163                             {
 164                                 ill_APDU (rr->print, &ill_apdu, 0,
 165                                     "ILL APDU");
 166                                 odr_reset (rr->print);
 167                             }
 168                         }
 169                     }
 170                 }
 171                 if (item_req)
 172                 {
 173                     yaz_log (LOG_LOG, "ILL protocol version = %d",
 174                              *item_req->protocol_version_num);
 175                 }
 176             }
 177             if (k)
 178             {
 179
 180                 Z_External *ext = (Z_External *)
 181                     odr_malloc (rr->stream, sizeof(*ext));
 182                 Z_IUOriginPartToKeep *keep = (Z_IUOriginPartToKeep *)
 183                     odr_malloc (rr->stream, sizeof(*keep));
 184                 Z_IOTargetPart *targetPart = (Z_IOTargetPart *)
 185                     odr_malloc (rr->stream, sizeof(*targetPart));
 186
 187                 rr->taskPackage = (Z_TaskPackage *)
 188                     odr_malloc (rr->stream, sizeof(*rr->taskPackage));
 189                 rr->taskPackage->packageType =
 190                     odr_oiddup (rr->stream, rr->esr->packageType);
 191                 rr->taskPackage->packageName = 0;
 192                 rr->taskPackage->userId = 0;
 193                 rr->taskPackage->retentionTime = 0;
 194                 rr->taskPackage->permissions = 0;
 195                 rr->taskPackage->description = 0;
 196                 rr->taskPackage->targetReference = (Odr_oct *)
 197                     odr_malloc (rr->stream, sizeof(Odr_oct));
 198                 rr->taskPackage->targetReference->buf =
 199                     (unsigned char *) odr_strdup (rr->stream, "911");
 200                 rr->taskPackage->targetReference->len =
 201                     rr->taskPackage->targetReference->size =
 202                     strlen((char *) (rr->taskPackage->targetReference->buf));
 203                 rr->taskPackage->creationDateTime = 0;
 204                 rr->taskPackage->taskStatus = odr_intdup(rr->stream, 0);
 205                 rr->taskPackage->packageDiagnostics = 0;
 206                 rr->taskPackage->taskSpecificParameters = ext;
 207
 208                 ext->direct_reference =
 209                     odr_oiddup (rr->stream, rr->esr->packageType);
 210                 ext->indirect_reference = 0;
 211                 ext->descriptor = 0;
 212                 ext->which = Z_External_itemOrder;
 213                 ext->u.itemOrder = (Z_ItemOrder *)
 214                     odr_malloc (rr->stream, sizeof(*ext->u.update));
 215                 ext->u.itemOrder->which = Z_IOItemOrder_taskPackage;
 216                 ext->u.itemOrder->u.taskPackage =  (Z_IOTaskPackage *)
 217                     odr_malloc (rr->stream, sizeof(Z_IOTaskPackage));
 218                 ext->u.itemOrder->u.taskPackage->originPart = k;
 219                 ext->u.itemOrder->u.taskPackage->targetPart = targetPart;
 220
 221                 targetPart->itemRequest = 0;
 222                 targetPart->statusOrErrorReport = 0;
 223                 targetPart->auxiliaryStatus = 0;
 224             }
 225         }
 226     }
 227     else if (rr->esr->taskSpecificParameters->which == Z_External_update)
 228     {
 229         Z_IUUpdate *up = rr->esr->taskSpecificParameters->u.update;
 230         yaz_log (LOG_LOG, "Received DB Update");
 231         if (up->which == Z_IUUpdate_esRequest)
 232         {
 233             Z_IUUpdateEsRequest *esRequest = up->u.esRequest;
 234             Z_IUOriginPartToKeep *toKeep = esRequest->toKeep;
 235             Z_IUSuppliedRecords *notToKeep = esRequest->notToKeep;
 236
 237             yaz_log (LOG_LOG, "action");
 238             if (toKeep->action)
 239             {
 240                 switch (*toKeep->action)
 241                 {
 242                 case Z_IUOriginPartToKeep_recordInsert:
 243                     yaz_log (LOG_LOG, " recordInsert");
 244                     break;
 245                 case Z_IUOriginPartToKeep_recordReplace:
 246                     yaz_log (LOG_LOG, " recordReplace");
 247                     break;
 248                 case Z_IUOriginPartToKeep_recordDelete:
 249                     yaz_log (LOG_LOG, " recordDelete");
 250                     break;
 251                 case Z_IUOriginPartToKeep_elementUpdate:
 252                     yaz_log (LOG_LOG, " elementUpdate");
 253                     break;
 254                 case Z_IUOriginPartToKeep_specialUpdate:
 255                     yaz_log (LOG_LOG, " specialUpdate");
 256                     break;
 257                 default:
 258                     yaz_log (LOG_LOG, " unknown (%d)", *toKeep->action);
 259                 }
 260             }
 261             if (toKeep->databaseName)
 262             {
 263                 yaz_log (LOG_LOG, "database: %s", toKeep->databaseName);
 264                 if (!strcmp(toKeep->databaseName, "fault"))
 265                 {
 266                     rr->errcode = 109;
 267                     rr->errstring = toKeep->databaseName;
 268                 }
 269                 if (!strcmp(toKeep->databaseName, "accept"))
 270                     rr->errcode = -1;
 271             }
 272             if (toKeep)
 273             {
 274                 Z_External *ext = (Z_External *)
 275                     odr_malloc (rr->stream, sizeof(*ext));
 276                 Z_IUOriginPartToKeep *keep = (Z_IUOriginPartToKeep *)
 277                     odr_malloc (rr->stream, sizeof(*keep));
 278                 Z_IUTargetPart *targetPart = (Z_IUTargetPart *)
 279                     odr_malloc (rr->stream, sizeof(*targetPart));
 280
 281                 rr->taskPackage = (Z_TaskPackage *)
 282                     odr_malloc (rr->stream, sizeof(*rr->taskPackage));
 283                 rr->taskPackage->packageType =
 284                     odr_oiddup (rr->stream, rr->esr->packageType);
 285                 rr->taskPackage->packageName = 0;
 286                 rr->taskPackage->userId = 0;
 287                 rr->taskPackage->retentionTime = 0;
 288                 rr->taskPackage->permissions = 0;
 289                 rr->taskPackage->description = 0;
 290                 rr->taskPackage->targetReference = (Odr_oct *)
 291                     odr_malloc (rr->stream, sizeof(Odr_oct));
 292                 rr->taskPackage->targetReference->buf =
 293                     (unsigned char *) odr_strdup (rr->stream, "123");
 294                 rr->taskPackage->targetReference->len =
 295                     rr->taskPackage->targetReference->size =
 296                     strlen((char *) (rr->taskPackage->targetReference->buf));
 297                 rr->taskPackage->creationDateTime = 0;
 298                 rr->taskPackage->taskStatus = odr_intdup(rr->stream, 0);
 299                 rr->taskPackage->packageDiagnostics = 0;
 300                 rr->taskPackage->taskSpecificParameters = ext;
 301
 302                 ext->direct_reference =
 303                     odr_oiddup (rr->stream, rr->esr->packageType);
 304                 ext->indirect_reference = 0;
 305                 ext->descriptor = 0;
 306                 ext->which = Z_External_update;
 307                 ext->u.update = (Z_IUUpdate *)
 308                     odr_malloc (rr->stream, sizeof(*ext->u.update));
 309                 ext->u.update->which = Z_IUUpdate_taskPackage;
 310                 ext->u.update->u.taskPackage =  (Z_IUUpdateTaskPackage *)
 311                     odr_malloc (rr->stream, sizeof(Z_IUUpdateTaskPackage));
 312                 ext->u.update->u.taskPackage->originPart = keep;
 313                 ext->u.update->u.taskPackage->targetPart = targetPart;
 314
 315                 keep->action = (int *) odr_malloc (rr->stream, sizeof(int));
 316                 *keep->action = *toKeep->action;
 317                 keep->databaseName =
 318                     odr_strdup (rr->stream, toKeep->databaseName);
 319                 keep->schema = 0;
 320                 keep->elementSetName = 0;
 321                 keep->actionQualifier = 0;
 322
 323                 targetPart->updateStatus = odr_intdup (rr->stream, 1);
 324                 targetPart->num_globalDiagnostics = 0;
 325                 targetPart->globalDiagnostics = (Z_DiagRec **) odr_nullval();
 326                 targetPart->num_taskPackageRecords = 1;
 327                 targetPart->taskPackageRecords =
 328                     (Z_IUTaskPackageRecordStructure **)
 329                     odr_malloc (rr->stream,
 330                                 sizeof(Z_IUTaskPackageRecordStructure *));
 331                 targetPart->taskPackageRecords[0] =
 332                     (Z_IUTaskPackageRecordStructure *)
 333                     odr_malloc (rr->stream,
 334                                 sizeof(Z_IUTaskPackageRecordStructure));
 335
 336                 targetPart->taskPackageRecords[0]->which =
 337                     Z_IUTaskPackageRecordStructure_record;
 338                 targetPart->taskPackageRecords[0]->u.record =
 339                     z_ext_record (rr->stream, VAL_SUTRS, "test", 4);
 340                 targetPart->taskPackageRecords[0]->correlationInfo = 0;
 341                 targetPart->taskPackageRecords[0]->recordStatus =
 342                     odr_intdup (rr->stream,
 343                                 Z_IUTaskPackageRecordStructure_success);
 344                 targetPart->taskPackageRecords[0]->num_supplementalDiagnostics
 345                     = 0;
 346
 347                 targetPart->taskPackageRecords[0]->supplementalDiagnostics = 0;
 348             }
 349             if (notToKeep)
 350             {
 351                 int i;
 352                 for (i = 0; i < notToKeep->num; i++)
 353                 {
 354                     Z_External *rec = notToKeep->elements[i]->record;
 355
 356                     if (rec->direct_reference)
 357                     {
 358                         struct oident *oident;
 359                         oident = oid_getentbyoid(rec->direct_reference);
 360                         if (oident)
 361                             yaz_log (LOG_LOG, "record %d type %s", i,
 362                                      oident->desc);
 363                     }
 364                     switch (rec->which)
 365                     {
 366                     case Z_External_sutrs:
 367                         if (rec->u.octet_aligned->len > 170)
 368                             yaz_log (LOG_LOG, "%d bytes:\n%.168s ...",
 369                                      rec->u.sutrs->len,
 370                                      rec->u.sutrs->buf);
 371                         else
 372                             yaz_log (LOG_LOG, "%d bytes:\n%s",
 373                                      rec->u.sutrs->len,
 374                                      rec->u.sutrs->buf);
 375                         break;
 376                     case Z_External_octet        :
 377                         if (rec->u.octet_aligned->len > 170)
 378                             yaz_log (LOG_LOG, "%d bytes:\n%.168s ...",
 379                                      rec->u.octet_aligned->len,
 380                                      rec->u.octet_aligned->buf);
 381                         else
 382                             yaz_log (LOG_LOG, "%d bytes\n%s",
 383                                      rec->u.octet_aligned->len,
 384                                      rec->u.octet_aligned->buf);
 385                     }
 386                 }
 387             }
 388         }
 389     }
 390     else
 391     {
 392         yaz_log (LOG_WARN, "Unknown Extended Service(%d)",
 393                  rr->esr->taskSpecificParameters->which);
 394
 395     }
 396     return 0;
 397 }
 398
 399 /* result set delete */
 400 int ztest_delete (void *handle, bend_delete_rr *rr)
 401 {
 402     if (rr->num_setnames == 1 && !strcmp (rr->setnames[0], "1"))
 403         rr->delete_status = Z_DeleteStatus_success;
 404     else
 405         rr->delete_status = Z_DeleteStatus_resultSetDidNotExist;
 406     return 0;
 407 }
 408
 409 /* Our sort handler really doesn't sort... */
 410 int ztest_sort (void *handle, bend_sort_rr *rr)
 411 {
 412     rr->errcode = 0;
 413     rr->sort_status = Z_SortStatus_success;
 414     return 0;
 415 }
 416
 417
 418 /* present request handler */
 419 int ztest_present (void *handle, bend_present_rr *rr)
 420 {
 421     return 0;
 422 }
 423
 424 /* retrieval of a single record (present, and piggy back search) */
 425 int ztest_fetch(void *handle, bend_fetch_rr *r)
 426 {
 427     char *cp;
 428     r->errstring = 0;
 429     r->last_in_set = 0;
 430     r->basename = "Default";
 431     r->output_format = r->request_format;
 432     if (r->request_format == VAL_SUTRS)
 433     {
 434         /* this section returns a small record */
 435         char buf[100];
 436
 437         sprintf(buf, "This is dummy SUTRS record number %d\n", r->number);
 438
 439         r->len = strlen(buf);
 440         r->record = (char *) odr_malloc (r->stream, r->len+1);
 441         strcpy(r->record, buf);
 442     }
 443     else if (r->request_format == VAL_GRS1)
 444     {
 445         r->len = -1;
 446         r->record = (char*) dummy_grs_record(r->number, r->stream);
 447         if (!r->record)
 448         {
 449             r->errcode = 13;
 450             return 0;
 451         }
 452     }
 453     else if (r->request_format == VAL_POSTSCRIPT)
 454     {
 455         char fname[20];
 456         FILE *f;
 457         long size;
 458
 459         sprintf (fname, "part.%d.ps", r->number);
 460         f = fopen(fname, "rb");
 461         if (!f)
 462         {
 463             r->errcode = 13;
 464             return 0;
 465         }
 466         fseek (f, 0L, SEEK_END);
 467         size = ftell (f);
 468         if (size <= 0 || size >= 5000000)
 469         {
 470             r->errcode = 14;
 471             return 0;
 472         }
 473         fseek (f, 0L, SEEK_SET);
 474         r->record = (char*) odr_malloc (r->stream, size);
 475         r->len = size;
 476         r->output_format = VAL_POSTSCRIPT;
 477         fread (r->record, size, 1, f);
 478         fclose (f);
 479     }
 480     else if (r->request_format == VAL_TEXT_XML &&
 481              (cp = dummy_xml_record (r->number, r->stream)))
 482     {
 483         r->len = strlen(cp);
 484         r->record = cp;
 485         r->output_format = VAL_TEXT_XML;
 486     }
 487     else if ((cp = dummy_marc_record(r->number, r->stream)))
 488     {
 489         r->len = strlen(cp);
 490         r->record = cp;
 491         r->output_format = VAL_USMARC;
 492     }
 493     else
 494     {
 495         r->errcode = 13;
 496         return 0;
 497     }
 498     r->errcode = 0;
 499     return 0;
 500 }
 501
 502 /*
 503  * silly dummy-scan what reads words from a file.
 504  */
 505 int ztest_scan(void *handle, bend_scan_rr *q)
 506 {
 507     static FILE *f = 0;
 508     static struct scan_entry list[200];
 509     static char entries[200][80];
 510     int hits[200];
 511     char term[80], *p;
 512     int i, pos;
 513     int term_position_req = q->term_position;
 514     int num_entries_req = q->num_entries;
 515
 516     q->errcode = 0;
 517     q->errstring = 0;
 518     q->entries = list;
 519     q->status = BEND_SCAN_SUCCESS;
 520     if (!f && !(f = fopen("dummy-words", "r")))
 521     {
 522         perror("dummy-words");
 523         exit(1);
 524     }
 525     if (q->term->term->which != Z_Term_general)
 526     {
 527         q->errcode = 229; /* unsupported term type */
 528         return 0;
 529     }
 530     if (*q->step_size != 0)
 531     {
 532         q->errcode = 205; /*Only zero step size supported for Scan */
 533         return 0;
 534     }
 535     if (q->term->term->u.general->len >= 80)
 536     {
 537         q->errcode = 11; /* term too long */
 538         return 0;
 539     }
 540     if (q->num_entries > 200)
 541     {
 542         q->errcode = 31;
 543         return 0;
 544     }
 545     memcpy(term, q->term->term->u.general->buf, q->term->term->u.general->len);
 546     term[q->term->term->u.general->len] = '\0';
 547     for (p = term; *p; p++)
 548         if (islower(*p))
 549             *p = toupper(*p);
 550
 551     fseek(f, 0, SEEK_SET);
 552     q->num_entries = 0;
 553
 554     for (i = 0, pos = 0; fscanf(f, " %79[^:]:%d", entries[pos], &hits[pos]) == 2;
 555         i++, pos < 199 ? pos++ : (pos = 0))
 556     {
 557         if (!q->num_entries && strcmp(entries[pos], term) >= 0) /* s-point fnd */
 558         {
 559             if ((q->term_position = term_position_req) > i + 1)
 560             {
 561                 q->term_position = i + 1;
 562                 q->status = BEND_SCAN_PARTIAL;
 563             }
 564             for (; q->num_entries < q->term_position; q->num_entries++)
 565             {
 566                 int po;
 567
 568                 po = pos - q->term_position + q->num_entries+1; /* find pos */
 569                 if (po < 0)
 570                     po += 200;
 571
 572                 if (!strcmp (term, "SD") && q->num_entries == 2)
 573                 {
 574                     list[q->num_entries].term = entries[pos];
 575                     list[q->num_entries].occurrences = -1;
 576                     list[q->num_entries].errcode = 233;
 577                     list[q->num_entries].errstring = "SD for Scan Term";
 578                 }
 579                 else
 580                 {
 581                     list[q->num_entries].term = entries[po];
 582                     list[q->num_entries].occurrences = hits[po];
 583                 }
 584             }
 585         }
 586         else if (q->num_entries)
 587         {
 588             list[q->num_entries].term = entries[pos];
 589             list[q->num_entries].occurrences = hits[pos];
 590             q->num_entries++;
 591         }
 592         if (q->num_entries >= num_entries_req)
 593             break;
 594     }
 595     if (feof(f))
 596         q->status = BEND_SCAN_PARTIAL;
 597     return 0;
 598 }
 599
 600 bend_initresult *bend_init(bend_initrequest *q)
 601 {
 602     bend_initresult *r = (bend_initresult *) odr_malloc (q->stream, sizeof(*r));
 603     int *counter = (int *) xmalloc (sizeof(int));
 604
 605     *counter = 0;
 606     r->errcode = 0;
 607     r->errstring = 0;
 608     r->handle = counter;         /* user handle, in this case a simple int */
 609     q->bend_sort = ztest_sort;              /* register sort handler */
 610     q->bend_search = ztest_search;          /* register search handler */
 611     q->bend_present = ztest_present;        /* register present handle */
 612     q->bend_esrequest = ztest_esrequest;
 613     q->bend_delete = ztest_delete;
 614     q->bend_fetch = ztest_fetch;
 615     q->bend_scan = ztest_scan;
 616     return r;
 617 }
 618
 619 void bend_close(void *handle)
 620 {
 621     xfree (handle);              /* release our user-defined handle */
 622     return;
 623 }
 624
 625 int main(int argc, char **argv)
 626 {
 627     return statserv_main(argc, argv, bend_init, bend_close);
 628 }