SimpleServer.c

   1 /*
   2  * This file was generated automatically by xsubpp version 1.9507 from the
   3  * contents of SimpleServer.xs. Do not edit this file, edit SimpleServer.xs instead.
   4  *
   5  *      ANY CHANGES MADE HERE WILL BE LOST!
   6  *
   7  */
   8
   9 #line 1 "SimpleServer.xs"
  10 /*
  11  * Copyright (c) 2000, Index Data.
  12  *
  13  * Permission to use, copy, modify, distribute, and sell this software and
  14  * its documentation, in whole or in part, for any purpose, is hereby granted,
  15  * provided that:
  16  *
  17  * 1. This copyright and permission notice appear in all copies of the
  18  * software and its documentation. Notices of copyright or attribution
  19  * which appear at the beginning of any file must remain unchanged.
  20  *
  21  * 2. The name of Index Data or the individual authors may not be used to
  22  * endorse or promote products derived from this software without specific
  23  * prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  27  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  28  * IN NO EVENT SHALL INDEX DATA BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  29  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES
  30  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR
  31  * NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  32  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  33  * OF THIS SOFTWARE.
  34  */
  35
  36
  37 #include "EXTERN.h"
  38 #include "perl.h"
  39 #include "XSUB.h"
  40 #include <yaz/backend.h>
  41 #include <yaz/log.h>
  42 #include <yaz/wrbuf.h>
  43 #include <stdio.h>
  44 #include <unistd.h>
  45 #include <stdlib.h>
  46 #include <ctype.h>
  47 #define GRS_MAX_FIELDS 50
  48 #ifdef ASN_COMPILED
  49 #include <yaz/ill.h>
  50 #endif
  51 #ifndef sv_undef                /* To fix the problem with Perl 5.6.0 */
  52 #define sv_undef PL_sv_undef
  53 #endif
  54
  55 typedef struct {
  56         SV *handle;
  57
  58         SV *init_ref;
  59         SV *close_ref;
  60         SV *sort_ref;
  61         SV *search_ref;
  62         SV *fetch_ref;
  63         SV *present_ref;
  64         SV *esrequest_ref;
  65         SV *delete_ref;
  66         SV *scan_ref;
  67 } Zfront_handle;
  68
  69 SV *init_ref = NULL;
  70 SV *close_ref = NULL;
  71 SV *sort_ref = NULL;
  72 SV *search_ref = NULL;
  73 SV *fetch_ref = NULL;
  74 SV *present_ref = NULL;
  75 SV *esrequest_ref = NULL;
  76 SV *delete_ref = NULL;
  77 SV *scan_ref = NULL;
  78 int MAX_OID = 15;
  79
  80
  81 Z_GenericRecord *read_grs1(char *str, ODR o)
  82 {
  83         int type, ivalue;
  84         char line[512], *buf, *ptr, *original;
  85         char value[512];
  86         Z_GenericRecord *r = 0;
  87
  88         original = str;
  89         for (;;)
  90         {
  91                 Z_TaggedElement *t;
  92                 Z_ElementData *c;
  93
  94                 ptr = strchr(str, '\n');
  95                 if (!ptr) {
  96                         return r;
  97                 }
  98                 strncpy(line, str, ptr - str);
  99                 line[ptr - str] = 0;
 100                 buf = line;
 101                 str = ptr + 1;
 102                 while (*buf && isspace(*buf))
 103                         buf++;
 104                 if (*buf == '}') {
 105                         memmove(original, str, strlen(str));
 106                         return r;
 107                 }
 108                 if (sscanf(buf, "(%d,%[^)])", &type, value) != 2)
 109                 {
 110                         yaz_log(LOG_WARN, "Bad data in '%s'", buf);
 111                         return 0;
 112                 }
 113                 if (!type && *value == '0')
 114                         return r;
 115                 if (!(buf = strchr(buf, ')')))
 116                         return 0;
 117                 buf++;
 118                 while (*buf && isspace(*buf))
 119                         buf++;
 120                 if (!*buf)
 121                         return 0;
 122                 if (!r)
 123                 {
 124                         r = (Z_GenericRecord *)odr_malloc(o, sizeof(*r));
 125                         r->elements = (Z_TaggedElement **)
 126                         odr_malloc(o, sizeof(Z_TaggedElement*) * GRS_MAX_FIELDS);
 127                         r->num_elements = 0;
 128                 }
 129                 r->elements[r->num_elements] = t = (Z_TaggedElement *) odr_malloc(o, sizeof(Z_TaggedElement));
 130                 t->tagType = (int *)odr_malloc(o, sizeof(int));
 131                 *t->tagType = type;
 132                 t->tagValue = (Z_StringOrNumeric *)
 133                         odr_malloc(o, sizeof(Z_StringOrNumeric));
 134                 if ((ivalue = atoi(value)))
 135                 {
 136                         t->tagValue->which = Z_StringOrNumeric_numeric;
 137                         t->tagValue->u.numeric = (int *)odr_malloc(o, sizeof(int));
 138                         *t->tagValue->u.numeric = ivalue;
 139                 }
 140                 else
 141                 {
 142                         t->tagValue->which = Z_StringOrNumeric_string;
 143                         t->tagValue->u.string = (char *)odr_malloc(o, strlen(value)+1);
 144                         strcpy(t->tagValue->u.string, value);
 145                 }
 146                 t->tagOccurrence = 0;
 147                 t->metaData = 0;
 148                 t->appliedVariant = 0;
 149                 t->content = c = (Z_ElementData *)odr_malloc(o, sizeof(Z_ElementData));
 150                 if (*buf == '{')
 151                 {
 152                         c->which = Z_ElementData_subtree;
 153                         c->u.subtree = read_grs1(str, o);
 154                 }
 155                 else
 156                 {
 157                         c->which = Z_ElementData_string;
 158 /*                      buf[strlen(buf)-1] = '\0';*/
 159                         buf[strlen(buf)] = '\0';
 160                         c->u.string = odr_strdup(o, buf);
 161                 }
 162                 r->num_elements++;
 163         }
 164 }
 165
 166
 167
 168
 169 static void oid2str(Odr_oid *o, WRBUF buf)
 170 {
 171     for (; *o >= 0; o++) {
 172         char ibuf[16];
 173         sprintf(ibuf, "%d", *o);
 174         wrbuf_puts(buf, ibuf);
 175         if (o[1] > 0)
 176             wrbuf_putc(buf, '.');
 177     }
 178 }
 179
 180
 181 static int rpn2pquery(Z_RPNStructure *s, WRBUF buf)
 182 {
 183     switch (s->which) {
 184         case Z_RPNStructure_simple: {
 185             Z_Operand *o = s->u.simple;
 186
 187             switch (o->which) {
 188                 case Z_Operand_APT: {
 189                     Z_AttributesPlusTerm *at = o->u.attributesPlusTerm;
 190
 191                     if (at->attributes) {
 192                         int i;
 193                         char ibuf[16];
 194
 195                         for (i = 0; i < at->attributes->num_attributes; i++) {
 196                             wrbuf_puts(buf, "@attr ");
 197                             if (at->attributes->attributes[i]->attributeSet) {
 198                                 oid2str(at->attributes->attributes[i]->attributeSet, buf);
 199                                 wrbuf_putc(buf, ' ');
 200                             }
 201                             sprintf(ibuf, "%d=", *at->attributes->attributes[i]->attributeType);
 202                             assert(at->attributes->attributes[i]->which == Z_AttributeValue_numeric);
 203                             wrbuf_puts(buf, ibuf);
 204                             sprintf(ibuf, "%d ", *at->attributes->attributes[i]->value.numeric);
 205                             wrbuf_puts(buf, ibuf);
 206                         }
 207                     }
 208                     switch (at->term->which) {
 209                         case Z_Term_general: {
 210                             wrbuf_putc(buf, '"');
 211                             wrbuf_write(buf, (char*) at->term->u.general->buf, at->term->u.general->len);
 212                             wrbuf_puts(buf, "\" ");
 213                             break;
 214                         }
 215                         default: abort();
 216                     }
 217                     break;
 218                 }
 219                 default: abort();
 220             }
 221             break;
 222         }
 223         case Z_RPNStructure_complex: {
 224             Z_Complex *c = s->u.complex;
 225
 226             switch (c->roperator->which) {
 227                 case Z_Operator_and: wrbuf_puts(buf, "@and "); break;
 228                 case Z_Operator_or: wrbuf_puts(buf, "@or "); break;
 229                 case Z_Operator_and_not: wrbuf_puts(buf, "@not "); break;
 230                 case Z_Operator_prox: abort();
 231                 default: abort();
 232             }
 233             if (!rpn2pquery(c->s1, buf))
 234                 return 0;
 235             if (!rpn2pquery(c->s2, buf))
 236                 return 0;
 237             break;
 238         }
 239         default: abort();
 240     }
 241     return 1;
 242 }
 243
 244
 245 WRBUF zquery2pquery(Z_Query *q)
 246 {
 247     WRBUF buf = wrbuf_alloc();
 248
 249     if (q->which != Z_Query_type_1 && q->which != Z_Query_type_101)
 250         return 0;
 251     if (q->u.type_1->attributeSetId) {
 252         /* Output attribute set ID */
 253         wrbuf_puts(buf, "@attrset ");
 254         oid2str(q->u.type_1->attributeSetId, buf);
 255         wrbuf_putc(buf, ' ');
 256     }
 257     return rpn2pquery(q->u.type_1->RPNStructure, buf) ? buf : 0;
 258 }
 259
 260
 261 int bend_sort(void *handle, bend_sort_rr *rr)
 262 {
 263         HV *href;
 264         AV *aref;
 265         SV **temp;
 266         SV *err_code;
 267         SV *err_str;
 268         SV *status;
 269         STRLEN len;
 270         char *ptr;
 271         char *ODR_err_str;
 272         char **input_setnames;
 273         Zfront_handle *zhandle = (Zfront_handle *)handle;
 274         int i;
 275
 276         dSP;
 277         ENTER;
 278         SAVETMPS;
 279
 280         aref = newAV();
 281         input_setnames = rr->input_setnames;
 282         for (i = 0; i < rr->num_input_setnames; i++)
 283         {
 284                 av_push(aref, newSVpv(*input_setnames++, 0));
 285         }
 286         href = newHV();
 287         hv_store(href, "INPUT", 5, newRV( (SV*) aref), 0);
 288         hv_store(href, "OUTPUT", 6, newSVpv(rr->output_setname, 0), 0);
 289         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 290         hv_store(href, "STATUS", 6, newSViv(0), 0);
 291
 292         PUSHMARK(sp);
 293
 294         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 295
 296         PUTBACK;
 297
 298         perl_call_sv(sort_ref, G_SCALAR | G_DISCARD);
 299
 300         SPAGAIN;
 301
 302         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 303         err_code = newSVsv(*temp);
 304
 305         temp = hv_fetch(href, "ERR_STR", 7, 1);
 306         err_str = newSVsv(*temp);
 307
 308         temp = hv_fetch(href, "STATUS", 6, 1);
 309         status = newSVsv(*temp);
 310
 311
 312
 313
 314         PUTBACK;
 315         FREETMPS;
 316         LEAVE;
 317
 318         hv_undef(href),
 319         av_undef(aref);
 320         rr->errcode = SvIV(err_code);
 321         rr->sort_status = SvIV(status);
 322         ptr = SvPV(err_str, len);
 323         ODR_err_str = (char *)odr_malloc(rr->stream, len + 1);
 324         strcpy(ODR_err_str, ptr);
 325         rr->errstring = ODR_err_str;
 326
 327         sv_free(err_code);
 328         sv_free(err_str);
 329         sv_free(status);
 330
 331         return 0;
 332 }
 333
 334
 335 int bend_search(void *handle, bend_search_rr *rr)
 336 {
 337         HV *href;
 338         AV *aref;
 339         SV **temp;
 340         SV *hits;
 341         SV *err_code;
 342         SV *err_str;
 343         char *ODR_errstr;
 344         STRLEN len;
 345         int i;
 346         char **basenames;
 347         int n;
 348         WRBUF query;
 349         char *ptr;
 350         SV *point;
 351         SV *ODR_point;
 352         Zfront_handle *zhandle = (Zfront_handle *)handle;
 353
 354         dSP;
 355         ENTER;
 356         SAVETMPS;
 357
 358         aref = newAV();
 359         basenames = rr->basenames;
 360         for (i = 0; i < rr->num_bases; i++)
 361         {
 362                 av_push(aref, newSVpv(*basenames++, 0));
 363         }
 364         href = newHV();
 365         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 366         hv_store(href, "REPL_SET", 8, newSViv(rr->replace_set), 0);
 367         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 368         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 369         hv_store(href, "HITS", 4, newSViv(0), 0);
 370         hv_store(href, "DATABASES", 9, newRV( (SV*) aref), 0);
 371         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 372         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 373         query = zquery2pquery(rr->query);
 374         if (query)
 375         {
 376                 hv_store(href, "QUERY", 5, newSVpv((char *)query->buf, query->pos), 0);
 377         }
 378         else
 379         {
 380                 rr->errcode = 108;
 381         }
 382         PUSHMARK(sp);
 383
 384         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 385
 386         PUTBACK;
 387
 388         n = perl_call_sv(search_ref, G_SCALAR | G_DISCARD);
 389
 390         SPAGAIN;
 391
 392         temp = hv_fetch(href, "HITS", 4, 1);
 393         hits = newSVsv(*temp);
 394
 395         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 396         err_code = newSVsv(*temp);
 397
 398         temp = hv_fetch(href, "ERR_STR", 7, 1);
 399         err_str = newSVsv(*temp);
 400
 401         temp = hv_fetch(href, "HANDLE", 6, 1);
 402         point = newSVsv(*temp);
 403
 404         PUTBACK;
 405         FREETMPS;
 406         LEAVE;
 407
 408         hv_undef(href);
 409         av_undef(aref);
 410         rr->hits = SvIV(hits);
 411         rr->errcode = SvIV(err_code);
 412         ptr = SvPV(err_str, len);
 413         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 414         strcpy(ODR_errstr, ptr);
 415         rr->errstring = ODR_errstr;
 416 /*      ODR_point = (SV *)odr_malloc(rr->stream, sizeof(*point));
 417         memcpy(ODR_point, point, sizeof(*point));
 418         zhandle->handle = ODR_point;*/
 419         zhandle->handle = point;
 420         handle = zhandle;
 421         sv_free(hits);
 422         sv_free(err_code);
 423         sv_free(err_str);
 424         sv_free( (SV*) aref);
 425         sv_free( (SV*) href);
 426         /*sv_free(point);*/
 427         wrbuf_free(query, 1);
 428         return 0;
 429 }
 430
 431
 432 WRBUF oid2dotted(int *oid)
 433 {
 434
 435         WRBUF buf = wrbuf_alloc();
 436         int dot = 0;
 437
 438         for (; *oid != -1 ; oid++)
 439         {
 440                 char ibuf[16];
 441                 if (dot)
 442                 {
 443                         wrbuf_putc(buf, '.');
 444                 }
 445                 else
 446                 {
 447                         dot = 1;
 448                 }
 449                 sprintf(ibuf, "%d", *oid);
 450                 wrbuf_puts(buf, ibuf);
 451         }
 452         return buf;
 453 }
 454
 455
 456 int dotted2oid(char *dotted, int *buffer)
 457 {
 458         int *oid;
 459         char ibuf[16];
 460         char *ptr;
 461         int n = 0;
 462
 463         ptr = ibuf;
 464         oid = buffer;
 465         while (*dotted)
 466         {
 467                 if (*dotted == '.')
 468                 {
 469                         n++;
 470                         if (n == MAX_OID)  /* Terminate if more than MAX_OID entries */
 471                         {
 472                                 *oid = -1;
 473                                 return -1;
 474                         }
 475                         *ptr = 0;
 476                         sscanf(ibuf, "%d", oid++);
 477                         ptr = ibuf;
 478                         dotted++;
 479
 480                 }
 481                 else
 482                 {
 483                         *ptr++ = *dotted++;
 484                 }
 485         }
 486         if (n < MAX_OID)
 487         {
 488                 *ptr = 0;
 489                 sscanf(ibuf, "%d", oid++);
 490         }
 491         *oid = -1;
 492         return 0;
 493 }
 494
 495
 496 int bend_fetch(void *handle, bend_fetch_rr *rr)
 497 {
 498         HV *href;
 499         SV **temp;
 500         SV *basename;
 501         SV *record;
 502         SV *last;
 503         SV *err_code;
 504         SV *err_string;
 505         SV *sur_flag;
 506         SV *point;
 507         SV *rep_form;
 508         char *ptr;
 509         char *ODR_record;
 510         char *ODR_basename;
 511         char *ODR_errstr;
 512         int *ODR_oid_buf;
 513         oident *oid;
 514         WRBUF oid_dotted;
 515         Zfront_handle *zhandle = (Zfront_handle *)handle;
 516
 517         Z_RecordComposition *composition;
 518         Z_ElementSetNames *simple;
 519         STRLEN length;
 520
 521         dSP;
 522         ENTER;
 523         SAVETMPS;
 524
 525         rr->errcode = 0;
 526         href = newHV();
 527         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 528         temp = hv_store(href, "OFFSET", 6, newSViv(rr->number), 0);
 529         oid_dotted = oid2dotted(rr->request_format_raw);
 530         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 531         hv_store(href, "REP_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 532         hv_store(href, "BASENAME", 8, newSVpv("", 0), 0);
 533         hv_store(href, "RECORD", 6, newSVpv("", 0), 0);
 534         hv_store(href, "LAST", 4, newSViv(0), 0);
 535         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 536         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 537         hv_store(href, "SUR_FLAG", 8, newSViv(0), 0);
 538         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 539         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 540         if (rr->comp)
 541         {
 542                 composition = rr->comp;
 543                 if (composition->which == Z_RecordComp_simple)
 544                 {
 545                         simple = composition->u.simple;
 546                         if (simple->which == Z_ElementSetNames_generic)
 547                         {
 548                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 549                         }
 550                         else
 551                         {
 552                                 rr->errcode = 26;
 553                         }
 554                 }
 555                 else
 556                 {
 557                         rr->errcode = 26;
 558                 }
 559         }
 560
 561         PUSHMARK(sp);
 562
 563         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 564
 565         PUTBACK;
 566
 567         perl_call_sv(fetch_ref, G_SCALAR | G_DISCARD);
 568
 569         SPAGAIN;
 570
 571         temp = hv_fetch(href, "BASENAME", 8, 1);
 572         basename = newSVsv(*temp);
 573
 574         temp = hv_fetch(href, "RECORD", 6, 1);
 575         record = newSVsv(*temp);
 576
 577         temp = hv_fetch(href, "LAST", 4, 1);
 578         last = newSVsv(*temp);
 579
 580         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 581         err_code = newSVsv(*temp);
 582
 583         temp = hv_fetch(href, "ERR_STR", 7, 1),
 584         err_string = newSVsv(*temp);
 585
 586         temp = hv_fetch(href, "SUR_FLAG", 8, 1);
 587         sur_flag = newSVsv(*temp);
 588
 589         temp = hv_fetch(href, "REP_FORM", 8, 1);
 590         rep_form = newSVsv(*temp);
 591
 592         temp = hv_fetch(href, "HANDLE", 6, 1);
 593         point = newSVsv(*temp);
 594
 595         PUTBACK;
 596         FREETMPS;
 597         LEAVE;
 598
 599         hv_undef(href);
 600
 601         ptr = SvPV(basename, length);
 602         ODR_basename = (char *)odr_malloc(rr->stream, length + 1);
 603         strcpy(ODR_basename, ptr);
 604         rr->basename = ODR_basename;
 605
 606         ptr = SvPV(rep_form, length);
 607         ODR_oid_buf = (int *)odr_malloc(rr->stream, (MAX_OID + 1) * sizeof(int));
 608         if (dotted2oid(ptr, ODR_oid_buf) == -1)         /* Maximum number of OID elements exceeded */
 609         {
 610                 printf("Net::Z3950::SimpleServer: WARNING: OID structure too long, max length is %d\n", MAX_OID);
 611         }
 612         rr->output_format_raw = ODR_oid_buf;
 613
 614         ptr = SvPV(record, length);
 615         oid = oid_getentbyoid(ODR_oid_buf);
 616         if (oid->value == VAL_GRS1)             /* Treat GRS-1 records separately */
 617         {
 618                 rr->record = (char *) read_grs1(ptr, rr->stream);
 619                 rr->len = -1;
 620         }
 621         else
 622         {
 623                 ODR_record = (char *)odr_malloc(rr->stream, length + 1);
 624                 strcpy(ODR_record, ptr);
 625                 rr->record = ODR_record;
 626                 rr->len = length;
 627         }
 628         zhandle->handle = point;
 629         handle = zhandle;
 630         rr->last_in_set = SvIV(last);
 631
 632         if (!(rr->errcode))
 633         {
 634                 rr->errcode = SvIV(err_code);
 635                 ptr = SvPV(err_string, length);
 636                 ODR_errstr = (char *)odr_malloc(rr->stream, length + 1);
 637                 strcpy(ODR_errstr, ptr);
 638                 rr->errstring = ODR_errstr;
 639         }
 640         rr->surrogate_flag = SvIV(sur_flag);
 641
 642         wrbuf_free(oid_dotted, 1);
 643         sv_free((SV*) href);
 644         sv_free(basename);
 645         sv_free(record);
 646         sv_free(last);
 647         sv_free(err_string);
 648         sv_free(err_code),
 649         sv_free(sur_flag);
 650         sv_free(rep_form);
 651
 652         return 0;
 653 }
 654
 655
 656 int bend_present(void *handle, bend_present_rr *rr)
 657 {
 658
 659         HV *href;
 660         SV **temp;
 661         SV *err_code;
 662         SV *err_string;
 663         SV *hits;
 664         SV *point;
 665         STRLEN len;
 666         Z_RecordComposition *composition;
 667         Z_ElementSetNames *simple;
 668         char *ODR_errstr;
 669         char *ptr;
 670         Zfront_handle *zhandle = (Zfront_handle *)handle;
 671
 672 /*      WRBUF oid_dotted; */
 673
 674         dSP;
 675         ENTER;
 676         SAVETMPS;
 677
 678         href = newHV();
 679         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 680         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 681         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 682         hv_store(href, "START", 5, newSViv(rr->start), 0);
 683         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 684         hv_store(href, "NUMBER", 6, newSViv(rr->number), 0);
 685         /*oid_dotted = oid2dotted(rr->request_format_raw);
 686         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);*/
 687         hv_store(href, "HITS", 4, newSViv(0), 0);
 688         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 689         if (rr->comp)
 690         {
 691                 composition = rr->comp;
 692                 if (composition->which == Z_RecordComp_simple)
 693                 {
 694                         simple = composition->u.simple;
 695                         if (simple->which == Z_ElementSetNames_generic)
 696                         {
 697                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 698                         }
 699                         else
 700                         {
 701                                 rr->errcode = 26;
 702                                 return 0;
 703                         }
 704                 }
 705                 else
 706                 {
 707                         rr->errcode = 26;
 708                         return 0;
 709                 }
 710         }
 711
 712         PUSHMARK(sp);
 713
 714         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 715
 716         PUTBACK;
 717
 718         perl_call_sv(present_ref, G_SCALAR | G_DISCARD);
 719
 720         SPAGAIN;
 721
 722         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 723         err_code = newSVsv(*temp);
 724
 725         temp = hv_fetch(href, "ERR_STR", 7, 1);
 726         err_string = newSVsv(*temp);
 727
 728         temp = hv_fetch(href, "HITS", 4, 1);
 729         hits = newSVsv(*temp);
 730
 731         temp = hv_fetch(href, "HANDLE", 6, 1);
 732         point = newSVsv(*temp);
 733
 734         PUTBACK;
 735         FREETMPS;
 736         LEAVE;
 737
 738         hv_undef(href);
 739         rr->errcode = SvIV(err_code);
 740         rr->hits = SvIV(hits);
 741
 742         ptr = SvPV(err_string, len);
 743         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 744         strcpy(ODR_errstr, ptr);
 745         rr->errstring = ODR_errstr;
 746 /*      wrbuf_free(oid_dotted, 1);*/
 747         zhandle->handle = point;
 748         handle = zhandle;
 749         sv_free(err_code);
 750         sv_free(err_string);
 751         sv_free(hits);
 752         sv_free( (SV*) href);
 753
 754         return 0;
 755 }
 756
 757
 758 int bend_esrequest(void *handle, bend_esrequest_rr *rr)
 759 {
 760         perl_call_sv(esrequest_ref, G_VOID | G_DISCARD | G_NOARGS);
 761         return 0;
 762 }
 763
 764
 765 int bend_delete(void *handle, bend_delete_rr *rr)
 766 {
 767         perl_call_sv(delete_ref, G_VOID | G_DISCARD | G_NOARGS);
 768         return 0;
 769 }
 770
 771
 772 int bend_scan(void *handle, bend_scan_rr *rr)
 773 {
 774         perl_call_sv(scan_ref, G_VOID | G_DISCARD | G_NOARGS);
 775         return 0;
 776 }
 777
 778
 779 bend_initresult *bend_init(bend_initrequest *q)
 780 {
 781         bend_initresult *r = (bend_initresult *) odr_malloc (q->stream, sizeof(*r));
 782         HV *href;
 783         SV **temp;
 784         SV *name;
 785         SV *ver;
 786         SV *err_str;
 787         SV *status;
 788         Zfront_handle *zhandle =  (Zfront_handle *) xmalloc (sizeof(*zhandle));
 789         STRLEN len;
 790         int n;
 791         SV *handle;
 792         /*char *name_ptr;
 793         char *ver_ptr;*/
 794         char *ptr;
 795
 796         dSP;
 797         ENTER;
 798         SAVETMPS;
 799
 800         /*q->bend_sort = bend_sort;*/
 801         if (search_ref)
 802         {
 803                 q->bend_search = bend_search;
 804         }
 805         if (present_ref)
 806         {
 807                 q->bend_present = bend_present;
 808         }
 809         /*q->bend_esrequest = bend_esrequest;*/
 810         /*q->bend_delete = bend_delete;*/
 811         if (fetch_ref)
 812         {
 813                 q->bend_fetch = bend_fetch;
 814         }
 815         /*q->bend_scan = bend_scan;*/
 816         href = newHV();
 817         hv_store(href, "IMP_NAME", 8, newSVpv("", 0), 0);
 818         hv_store(href, "IMP_VER", 7, newSVpv("", 0), 0);
 819         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 820         hv_store(href, "PEER_NAME", 9, newSVpv(q->peer_name, 0), 0);
 821         hv_store(href, "HANDLE", 6, newSVsv(&sv_undef), 0);
 822         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 823
 824         PUSHMARK(sp);
 825
 826         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 827
 828         PUTBACK;
 829
 830         if (init_ref != NULL)
 831         {
 832                 perl_call_sv(init_ref, G_SCALAR | G_DISCARD);
 833         }
 834
 835         SPAGAIN;
 836
 837         temp = hv_fetch(href, "IMP_NAME", 8, 1);
 838         name = newSVsv(*temp);
 839
 840         temp = hv_fetch(href, "IMP_VER", 7, 1);
 841         ver = newSVsv(*temp);
 842
 843         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 844         status = newSVsv(*temp);
 845
 846         temp = hv_fetch(href, "HANDLE", 6, 1);
 847         handle= newSVsv(*temp);
 848
 849         hv_undef(href);
 850         PUTBACK;
 851         FREETMPS;
 852         LEAVE;
 853         zhandle->handle = handle;
 854         r->errcode = SvIV(status);
 855         r->handle = zhandle;
 856         ptr = SvPV(name, len);
 857         q->implementation_name = (char *)xmalloc(len + 1);
 858         strcpy(q->implementation_name, ptr);
 859 /*      q->implementation_name = SvPV(name, len);*/
 860         ptr = SvPV(ver, len);
 861         q->implementation_version = (char *)xmalloc(len + 1);
 862         strcpy(q->implementation_version, ptr);
 863
 864         return r;
 865 }
 866
 867
 868 void bend_close(void *handle)
 869 {
 870         HV *href;
 871         Zfront_handle *zhandle = (Zfront_handle *)handle;
 872         SV **temp;
 873
 874         dSP;
 875         ENTER;
 876         SAVETMPS;
 877
 878         if (close_ref == NULL)
 879         {
 880                 return;
 881         }
 882
 883         href = newHV();
 884         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 885
 886         PUSHMARK(sp);
 887
 888         XPUSHs(sv_2mortal(newRV((SV *)href)));
 889
 890         PUTBACK;
 891
 892         perl_call_sv(close_ref, G_SCALAR | G_DISCARD);
 893
 894         SPAGAIN;
 895
 896         PUTBACK;
 897         FREETMPS;
 898         LEAVE;
 899
 900         xfree(handle);
 901
 902         return;
 903 }
 904
 905
 906 #line 907 "SimpleServer.c"
 907 XS(XS_Net__Z3950__SimpleServer_set_init_handler)
 908 {
 909     dXSARGS;
 910     if (items != 1)
 911         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_init_handler(arg)");
 912     {
 913         SV *    arg = ST(0);
 914 #line 903 "SimpleServer.xs"
 915                 init_ref = newSVsv(arg);
 916 #line 917 "SimpleServer.c"
 917     }
 918     XSRETURN_EMPTY;
 919 }
 920
 921 XS(XS_Net__Z3950__SimpleServer_set_close_handler)
 922 {
 923     dXSARGS;
 924     if (items != 1)
 925         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_close_handler(arg)");
 926     {
 927         SV *    arg = ST(0);
 928 #line 910 "SimpleServer.xs"
 929                 close_ref = newSVsv(arg);
 930 #line 931 "SimpleServer.c"
 931     }
 932     XSRETURN_EMPTY;
 933 }
 934
 935 XS(XS_Net__Z3950__SimpleServer_set_sort_handler)
 936 {
 937     dXSARGS;
 938     if (items != 1)
 939         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_sort_handler(arg)");
 940     {
 941         SV *    arg = ST(0);
 942 #line 917 "SimpleServer.xs"
 943                 sort_ref = newSVsv(arg);
 944 #line 945 "SimpleServer.c"
 945     }
 946     XSRETURN_EMPTY;
 947 }
 948
 949 XS(XS_Net__Z3950__SimpleServer_set_search_handler)
 950 {
 951     dXSARGS;
 952     if (items != 1)
 953         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_search_handler(arg)");
 954     {
 955         SV *    arg = ST(0);
 956 #line 923 "SimpleServer.xs"
 957                 search_ref = newSVsv(arg);
 958 #line 959 "SimpleServer.c"
 959     }
 960     XSRETURN_EMPTY;
 961 }
 962
 963 XS(XS_Net__Z3950__SimpleServer_set_fetch_handler)
 964 {
 965     dXSARGS;
 966     if (items != 1)
 967         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_fetch_handler(arg)");
 968     {
 969         SV *    arg = ST(0);
 970 #line 930 "SimpleServer.xs"
 971                 fetch_ref = newSVsv(arg);
 972 #line 973 "SimpleServer.c"
 973     }
 974     XSRETURN_EMPTY;
 975 }
 976
 977 XS(XS_Net__Z3950__SimpleServer_set_present_handler)
 978 {
 979     dXSARGS;
 980     if (items != 1)
 981         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_present_handler(arg)");
 982     {
 983         SV *    arg = ST(0);
 984 #line 937 "SimpleServer.xs"
 985                 present_ref = newSVsv(arg);
 986 #line 987 "SimpleServer.c"
 987     }
 988     XSRETURN_EMPTY;
 989 }
 990
 991 XS(XS_Net__Z3950__SimpleServer_set_esrequest_handler)
 992 {
 993     dXSARGS;
 994     if (items != 1)
 995         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_esrequest_handler(arg)");
 996     {
 997         SV *    arg = ST(0);
 998 #line 944 "SimpleServer.xs"
 999                 esrequest_ref = newSVsv(arg);
1000 #line 1001 "SimpleServer.c"
1001     }
1002     XSRETURN_EMPTY;
1003 }
1004
1005 XS(XS_Net__Z3950__SimpleServer_set_delete_handler)
1006 {
1007     dXSARGS;
1008     if (items != 1)
1009         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_delete_handler(arg)");
1010     {
1011         SV *    arg = ST(0);
1012 #line 951 "SimpleServer.xs"
1013                 delete_ref = newSVsv(arg);
1014 #line 1015 "SimpleServer.c"
1015     }
1016     XSRETURN_EMPTY;
1017 }
1018
1019 XS(XS_Net__Z3950__SimpleServer_set_scan_handler)
1020 {
1021     dXSARGS;
1022     if (items != 1)
1023         Perl_croak(aTHX_ "Usage: Net::Z3950::SimpleServer::set_scan_handler(arg)");
1024     {
1025         SV *    arg = ST(0);
1026 #line 958 "SimpleServer.xs"
1027                 scan_ref = newSVsv(arg);
1028 #line 1029 "SimpleServer.c"
1029     }
1030     XSRETURN_EMPTY;
1031 }
1032
1033 XS(XS_Net__Z3950__SimpleServer_start_server)
1034 {
1035     dXSARGS;
1036     {
1037 #line 964 "SimpleServer.xs"
1038                 char **argv;
1039                 char **argv_buf;
1040                 char *ptr;
1041                 int i;
1042                 STRLEN len;
1043 #line 1044 "SimpleServer.c"
1044         int     RETVAL;
1045         dXSTARG;
1046 #line 970 "SimpleServer.xs"
1047                 argv_buf = (char **)xmalloc((items + 1) * sizeof(char *));
1048                 argv = argv_buf;
1049                 for (i = 0; i < items; i++)
1050                 {
1051                         ptr = SvPV(ST(i), len);
1052                         *argv_buf = (char *)xmalloc(len + 1);
1053                         strcpy(*argv_buf++, ptr);
1054                 }
1055                 *argv_buf = NULL;
1056
1057                 RETVAL = statserv_main(items, argv, bend_init, bend_close);
1058 #line 1059 "SimpleServer.c"
1059         XSprePUSH; PUSHi((IV)RETVAL);
1060     }
1061     XSRETURN(1);
1062 }
1063
1064 #ifdef __cplusplus
1065 extern "C"
1066 #endif
1067 XS(boot_Net__Z3950__SimpleServer)
1068 {
1069     dXSARGS;
1070     char* file = __FILE__;
1071
1072     XS_VERSION_BOOTCHECK ;
1073
1074         newXS("Net::Z3950::SimpleServer::set_init_handler", XS_Net__Z3950__SimpleServer_set_init_handler, file);
1075         newXS("Net::Z3950::SimpleServer::set_close_handler", XS_Net__Z3950__SimpleServer_set_close_handler, file);
1076         newXS("Net::Z3950::SimpleServer::set_sort_handler", XS_Net__Z3950__SimpleServer_set_sort_handler, file);
1077         newXS("Net::Z3950::SimpleServer::set_search_handler", XS_Net__Z3950__SimpleServer_set_search_handler, file);
1078         newXS("Net::Z3950::SimpleServer::set_fetch_handler", XS_Net__Z3950__SimpleServer_set_fetch_handler, file);
1079         newXS("Net::Z3950::SimpleServer::set_present_handler", XS_Net__Z3950__SimpleServer_set_present_handler, file);
1080         newXS("Net::Z3950::SimpleServer::set_esrequest_handler", XS_Net__Z3950__SimpleServer_set_esrequest_handler, file);
1081         newXS("Net::Z3950::SimpleServer::set_delete_handler", XS_Net__Z3950__SimpleServer_set_delete_handler, file);
1082         newXS("Net::Z3950::SimpleServer::set_scan_handler", XS_Net__Z3950__SimpleServer_set_scan_handler, file);
1083         newXS("Net::Z3950::SimpleServer::start_server", XS_Net__Z3950__SimpleServer_start_server, file);
1084     XSRETURN_YES;
1085 }
1086