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 <stdlib.h>
  45 #include <ctype.h>
  46 #ifdef ASN_COMPILED
  47 #include <yaz/ill.h>
  48 #endif
  49
  50
  51 typedef struct {
  52         SV *handle;
  53
  54         SV *init_ref;
  55         SV *close_ref;
  56         SV *sort_ref;
  57         SV *search_ref;
  58         SV *fetch_ref;
  59         SV *present_ref;
  60         SV *esrequest_ref;
  61         SV *delete_ref;
  62         SV *scan_ref;
  63 } Zfront_handle;
  64
  65 SV *init_ref = NULL;
  66 SV *close_ref = NULL;
  67 SV *sort_ref = NULL;
  68 SV *search_ref = NULL;
  69 SV *fetch_ref = NULL;
  70 SV *present_ref = NULL;
  71 SV *esrequest_ref = NULL;
  72 SV *delete_ref = NULL;
  73 SV *scan_ref = NULL;
  74 int MAX_OID = 15;
  75
  76 static void oid2str(Odr_oid *o, WRBUF buf)
  77 {
  78     for (; *o >= 0; o++) {
  79         char ibuf[16];
  80         sprintf(ibuf, "%d", *o);
  81         wrbuf_puts(buf, ibuf);
  82         if (o[1] > 0)
  83             wrbuf_putc(buf, '.');
  84     }
  85 }
  86
  87
  88 static int rpn2pquery(Z_RPNStructure *s, WRBUF buf)
  89 {
  90     switch (s->which) {
  91         case Z_RPNStructure_simple: {
  92             Z_Operand *o = s->u.simple;
  93
  94             switch (o->which) {
  95                 case Z_Operand_APT: {
  96                     Z_AttributesPlusTerm *at = o->u.attributesPlusTerm;
  97
  98                     if (at->attributes) {
  99                         int i;
 100                         char ibuf[16];
 101
 102                         for (i = 0; i < at->attributes->num_attributes; i++) {
 103                             wrbuf_puts(buf, "@attr ");
 104                             if (at->attributes->attributes[i]->attributeSet) {
 105                                 oid2str(at->attributes->attributes[i]->attributeSet, buf);
 106                                 wrbuf_putc(buf, ' ');
 107                             }
 108                             sprintf(ibuf, "%d=", *at->attributes->attributes[i]->attributeType);
 109                             assert(at->attributes->attributes[i]->which == Z_AttributeValue_numeric);
 110                             wrbuf_puts(buf, ibuf);
 111                             sprintf(ibuf, "%d ", *at->attributes->attributes[i]->value.numeric);
 112                             wrbuf_puts(buf, ibuf);
 113                         }
 114                     }
 115                     switch (at->term->which) {
 116                         case Z_Term_general: {
 117                             wrbuf_putc(buf, '"');
 118                             wrbuf_write(buf, (char*) at->term->u.general->buf, at->term->u.general->len);
 119                             wrbuf_puts(buf, "\" ");
 120                             break;
 121                         }
 122                         default: abort();
 123                     }
 124                     break;
 125                 }
 126                 default: abort();
 127             }
 128             break;
 129         }
 130         case Z_RPNStructure_complex: {
 131             Z_Complex *c = s->u.complex;
 132
 133             switch (c->roperator->which) {
 134                 case Z_Operator_and: wrbuf_puts(buf, "@and "); break;
 135                 case Z_Operator_or: wrbuf_puts(buf, "@or "); break;
 136                 case Z_Operator_and_not: wrbuf_puts(buf, "@not "); break;
 137                 case Z_Operator_prox: abort();
 138                 default: abort();
 139             }
 140             if (!rpn2pquery(c->s1, buf))
 141                 return 0;
 142             if (!rpn2pquery(c->s2, buf))
 143                 return 0;
 144             break;
 145         }
 146         default: abort();
 147     }
 148     return 1;
 149 }
 150
 151
 152 WRBUF zquery2pquery(Z_Query *q)
 153 {
 154     WRBUF buf = wrbuf_alloc();
 155
 156     if (q->which != Z_Query_type_1 && q->which != Z_Query_type_101)
 157         return 0;
 158     if (q->u.type_1->attributeSetId) {
 159         /* Output attribute set ID */
 160         wrbuf_puts(buf, "@attrset ");
 161         oid2str(q->u.type_1->attributeSetId, buf);
 162         wrbuf_putc(buf, ' ');
 163     }
 164     return rpn2pquery(q->u.type_1->RPNStructure, buf) ? buf : 0;
 165 }
 166
 167
 168 int bend_sort(void *handle, bend_sort_rr *rr)
 169 {
 170         HV *href;
 171         AV *aref;
 172         SV **temp;
 173         SV *err_code;
 174         SV *err_str;
 175         SV *status;
 176         STRLEN len;
 177         char *ptr;
 178         char *ODR_err_str;
 179         char **input_setnames;
 180         Zfront_handle *zhandle = (Zfront_handle *)handle;
 181         int i;
 182
 183         dSP;
 184         ENTER;
 185         SAVETMPS;
 186
 187         aref = newAV();
 188         input_setnames = rr->input_setnames;
 189         for (i = 0; i < rr->num_input_setnames; i++)
 190         {
 191                 av_push(aref, newSVpv(*input_setnames++, 0));
 192         }
 193         href = newHV();
 194         hv_store(href, "INPUT", 5, newRV( (SV*) aref), 0);
 195         hv_store(href, "OUTPUT", 6, newSVpv(rr->output_setname, 0), 0);
 196         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 197         hv_store(href, "STATUS", 6, newSViv(0), 0);
 198
 199         PUSHMARK(sp);
 200
 201         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 202
 203         PUTBACK;
 204
 205         perl_call_sv(sort_ref, G_SCALAR | G_DISCARD);
 206
 207         SPAGAIN;
 208
 209         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 210         err_code = newSVsv(*temp);
 211
 212         temp = hv_fetch(href, "ERR_STR", 7, 1);
 213         err_str = newSVsv(*temp);
 214
 215         temp = hv_fetch(href, "STATUS", 6, 1);
 216         status = newSVsv(*temp);
 217
 218
 219
 220
 221         PUTBACK;
 222         FREETMPS;
 223         LEAVE;
 224
 225         hv_undef(href),
 226         av_undef(aref);
 227         rr->errcode = SvIV(err_code);
 228         rr->sort_status = SvIV(status);
 229         ptr = SvPV(err_str, len);
 230         ODR_err_str = (char *)odr_malloc(rr->stream, len + 1);
 231         strcpy(ODR_err_str, ptr);
 232         rr->errstring = ODR_err_str;
 233
 234         sv_free(err_code);
 235         sv_free(err_str);
 236         sv_free(status);
 237
 238         return 0;
 239 }
 240
 241
 242 int bend_search(void *handle, bend_search_rr *rr)
 243 {
 244         HV *href;
 245         AV *aref;
 246         SV **temp;
 247         SV *hits;
 248         SV *err_code;
 249         SV *err_str;
 250         char *ODR_errstr;
 251         STRLEN len;
 252         int i;
 253         char **basenames;
 254         int n;
 255         WRBUF query;
 256         char *ptr;
 257         SV *point;
 258         SV *ODR_point;
 259         Zfront_handle *zhandle = (Zfront_handle *)handle;
 260
 261         dSP;
 262         ENTER;
 263         SAVETMPS;
 264
 265         aref = newAV();
 266         basenames = rr->basenames;
 267         for (i = 0; i < rr->num_bases; i++)
 268         {
 269                 av_push(aref, newSVpv(*basenames++, 0));
 270         }
 271         href = newHV();
 272         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 273         hv_store(href, "REPL_SET", 8, newSViv(rr->replace_set), 0);
 274         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 275         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 276         hv_store(href, "HITS", 4, newSViv(0), 0);
 277         hv_store(href, "DATABASES", 9, newRV( (SV*) aref), 0);
 278         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 279         query = zquery2pquery(rr->query);
 280         if (query)
 281         {
 282                 hv_store(href, "QUERY", 5, newSVpv((char *)query->buf, query->pos), 0);
 283         }
 284         else
 285         {
 286                 rr->errcode = 108;
 287         }
 288         PUSHMARK(sp);
 289
 290         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 291
 292         PUTBACK;
 293
 294         n = perl_call_sv(search_ref, G_SCALAR | G_DISCARD);
 295
 296         SPAGAIN;
 297
 298         temp = hv_fetch(href, "HITS", 4, 1);
 299         hits = newSVsv(*temp);
 300
 301         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 302         err_code = newSVsv(*temp);
 303
 304         temp = hv_fetch(href, "ERR_STR", 7, 1);
 305         err_str = newSVsv(*temp);
 306
 307         temp = hv_fetch(href, "HANDLE", 6, 1);
 308         point = newSVsv(*temp);
 309
 310         PUTBACK;
 311         FREETMPS;
 312         LEAVE;
 313
 314         hv_undef(href);
 315         av_undef(aref);
 316         rr->hits = SvIV(hits);
 317         rr->errcode = SvIV(err_code);
 318         ptr = SvPV(err_str, len);
 319         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 320         strcpy(ODR_errstr, ptr);
 321         rr->errstring = ODR_errstr;
 322 /*      ODR_point = (SV *)odr_malloc(rr->stream, sizeof(*point));
 323         memcpy(ODR_point, point, sizeof(*point));
 324         zhandle->handle = ODR_point;*/
 325         zhandle->handle = point;
 326         handle = zhandle;
 327         sv_free(hits);
 328         sv_free(err_code);
 329         sv_free(err_str);
 330         sv_free( (SV*) aref);
 331         sv_free( (SV*) href);
 332         /*sv_free(point);*/
 333         wrbuf_free(query, 1);
 334         return 0;
 335 }
 336
 337
 338 WRBUF oid2dotted(int *oid)
 339 {
 340
 341         WRBUF buf = wrbuf_alloc();
 342         int dot = 0;
 343
 344         for (; *oid != -1 ; oid++)
 345         {
 346                 char ibuf[16];
 347                 if (dot)
 348                 {
 349                         wrbuf_putc(buf, '.');
 350                 }
 351                 else
 352                 {
 353                         dot = 1;
 354                 }
 355                 sprintf(ibuf, "%d", *oid);
 356                 wrbuf_puts(buf, ibuf);
 357         }
 358         return buf;
 359 }
 360
 361
 362 int dotted2oid(char *dotted, int *buffer)
 363 {
 364         int *oid;
 365         char ibuf[16];
 366         char *ptr;
 367         int n = 0;
 368
 369         ptr = ibuf;
 370         oid = buffer;
 371         while (*dotted)
 372         {
 373                 if (*dotted == '.')
 374                 {
 375                         n++;
 376                         if (n == MAX_OID)  /* Terminate if more than MAX_OID entries */
 377                         {
 378                                 *oid = -1;
 379                                 return -1;
 380                         }
 381                         *ptr = 0;
 382                         sscanf(ibuf, "%d", oid++);
 383                         ptr = ibuf;
 384                         dotted++;
 385
 386                 }
 387                 else
 388                 {
 389                         *ptr++ = *dotted++;
 390                 }
 391         }
 392         if (n < MAX_OID)
 393         {
 394                 *ptr = 0;
 395                 sscanf(ibuf, "%d", oid++);
 396         }
 397         *oid = -1;
 398         return 0;
 399 }
 400
 401
 402 int bend_fetch(void *handle, bend_fetch_rr *rr)
 403 {
 404         HV *href;
 405         SV **temp;
 406         SV *basename;
 407         SV *record;
 408         SV *last;
 409         SV *err_code;
 410         SV *err_string;
 411         SV *sur_flag;
 412         SV *point;
 413         SV *rep_form;
 414         char *ptr;
 415         char *ODR_record;
 416         char *ODR_basename;
 417         char *ODR_errstr;
 418         int *ODR_oid_buf;
 419         WRBUF oid_dotted;
 420         Zfront_handle *zhandle = (Zfront_handle *)handle;
 421
 422         Z_RecordComposition *composition;
 423         Z_ElementSetNames *simple;
 424         STRLEN length;
 425         int oid;
 426
 427         dSP;
 428         ENTER;
 429         SAVETMPS;
 430
 431         rr->errcode = 0;
 432         href = newHV();
 433         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 434         temp = hv_store(href, "OFFSET", 6, newSViv(rr->number), 0);
 435         oid_dotted = oid2dotted(rr->request_format_raw);
 436         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 437         hv_store(href, "REP_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 438         hv_store(href, "BASENAME", 8, newSVpv("", 0), 0);
 439         hv_store(href, "RECORD", 6, newSVpv("", 0), 0);
 440         hv_store(href, "LAST", 4, newSViv(0), 0);
 441         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 442         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 443         hv_store(href, "SUR_FLAG", 8, newSViv(0), 0);
 444         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 445         if (rr->comp)
 446         {
 447                 composition = rr->comp;
 448                 if (composition->which == Z_RecordComp_simple)
 449                 {
 450                         simple = composition->u.simple;
 451                         if (simple->which == Z_ElementSetNames_generic)
 452                         {
 453                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 454                         }
 455                         else
 456                         {
 457                                 rr->errcode = 26;
 458                         }
 459                 }
 460                 else
 461                 {
 462                         rr->errcode = 26;
 463                 }
 464         }
 465
 466         PUSHMARK(sp);
 467
 468         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 469
 470         PUTBACK;
 471
 472         perl_call_sv(fetch_ref, G_SCALAR | G_DISCARD);
 473
 474         SPAGAIN;
 475
 476         temp = hv_fetch(href, "BASENAME", 8, 1);
 477         basename = newSVsv(*temp);
 478
 479         temp = hv_fetch(href, "RECORD", 6, 1);
 480         record = newSVsv(*temp);
 481
 482         temp = hv_fetch(href, "LAST", 4, 1);
 483         last = newSVsv(*temp);
 484
 485         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 486         err_code = newSVsv(*temp);
 487
 488         temp = hv_fetch(href, "ERR_STR", 7, 1),
 489         err_string = newSVsv(*temp);
 490
 491         temp = hv_fetch(href, "SUR_FLAG", 8, 1);
 492         sur_flag = newSVsv(*temp);
 493
 494         temp = hv_fetch(href, "REP_FORM", 8, 1);
 495         rep_form = newSVsv(*temp);
 496
 497         temp = hv_fetch(href, "HANDLE", 6, 1);
 498         point = newSVsv(*temp);
 499
 500         PUTBACK;
 501         FREETMPS;
 502         LEAVE;
 503
 504         hv_undef(href);
 505
 506         ptr = SvPV(basename, length);
 507         ODR_basename = (char *)odr_malloc(rr->stream, length + 1);
 508         strcpy(ODR_basename, ptr);
 509         rr->basename = ODR_basename;
 510
 511         ptr = SvPV(rep_form, length);
 512         ODR_oid_buf = (int *)odr_malloc(rr->stream, (MAX_OID + 1) * sizeof(int));
 513         if (dotted2oid(ptr, ODR_oid_buf) == -1)         /* Maximum number of OID elements exceeded */
 514         {
 515                 printf("Net::Z3950::SimpleServer: WARNING: OID structure too long, max length is %d\n", MAX_OID);
 516         }
 517         rr->output_format_raw = ODR_oid_buf;
 518
 519         ptr = SvPV(record, length);
 520         ODR_record = (char *)odr_malloc(rr->stream, length + 1);
 521         strcpy(ODR_record, ptr);
 522         rr->record = ODR_record;
 523         rr->len = length;
 524
 525         zhandle->handle = point;
 526         handle = zhandle;
 527         rr->last_in_set = SvIV(last);
 528
 529         if (!(rr->errcode))
 530         {
 531                 rr->errcode = SvIV(err_code);
 532                 ptr = SvPV(err_string, length);
 533                 ODR_errstr = (char *)odr_malloc(rr->stream, length + 1);
 534                 strcpy(ODR_errstr, ptr);
 535                 rr->errstring = ODR_errstr;
 536         }
 537         rr->surrogate_flag = SvIV(sur_flag);
 538
 539         wrbuf_free(oid_dotted, 1);
 540         sv_free((SV*) href);
 541         sv_free(basename);
 542         sv_free(record);
 543         sv_free(last);
 544         sv_free(err_string);
 545         sv_free(err_code),
 546         sv_free(sur_flag);
 547         sv_free(rep_form);
 548
 549         return 0;
 550 }
 551
 552
 553 int bend_present(void *handle, bend_present_rr *rr)
 554 {
 555
 556         HV *href;
 557         SV **temp;
 558         SV *err_code;
 559         SV *err_string;
 560         SV *hits;
 561         SV *point;
 562         STRLEN len;
 563         Z_RecordComposition *composition;
 564         Z_ElementSetNames *simple;
 565         char *ODR_errstr;
 566         char *ptr;
 567         Zfront_handle *zhandle = (Zfront_handle *)handle;
 568
 569 /*      WRBUF oid_dotted; */
 570
 571         dSP;
 572         ENTER;
 573         SAVETMPS;
 574
 575         href = newHV();
 576         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 577         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 578         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 579         hv_store(href, "START", 5, newSViv(rr->start), 0);
 580         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 581         hv_store(href, "NUMBER", 6, newSViv(rr->number), 0);
 582         /*oid_dotted = oid2dotted(rr->request_format_raw);
 583         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);*/
 584         hv_store(href, "HITS", 4, newSViv(0), 0);
 585         if (rr->comp)
 586         {
 587                 composition = rr->comp;
 588                 if (composition->which == Z_RecordComp_simple)
 589                 {
 590                         simple = composition->u.simple;
 591                         if (simple->which == Z_ElementSetNames_generic)
 592                         {
 593                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 594                         }
 595                         else
 596                         {
 597                                 rr->errcode = 26;
 598                                 return 0;
 599                         }
 600                 }
 601                 else
 602                 {
 603                         rr->errcode = 26;
 604                         return 0;
 605                 }
 606         }
 607
 608         PUSHMARK(sp);
 609
 610         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 611
 612         PUTBACK;
 613
 614         perl_call_sv(present_ref, G_SCALAR | G_DISCARD);
 615
 616         SPAGAIN;
 617
 618         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 619         err_code = newSVsv(*temp);
 620
 621         temp = hv_fetch(href, "ERR_STR", 7, 1);
 622         err_string = newSVsv(*temp);
 623
 624         temp = hv_fetch(href, "HITS", 4, 1);
 625         hits = newSVsv(*temp);
 626
 627         temp = hv_fetch(href, "HANDLE", 6, 1);
 628         point = newSVsv(*temp);
 629
 630         PUTBACK;
 631         FREETMPS;
 632         LEAVE;
 633
 634         hv_undef(href);
 635         rr->errcode = SvIV(err_code);
 636         rr->hits = SvIV(hits);
 637
 638         ptr = SvPV(err_string, len);
 639         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 640         strcpy(ODR_errstr, ptr);
 641         rr->errstring = ODR_errstr;
 642 /*      wrbuf_free(oid_dotted, 1);*/
 643         zhandle->handle = point;
 644         handle = zhandle;
 645         sv_free(err_code);
 646         sv_free(err_string);
 647         sv_free(hits);
 648         sv_free( (SV*) href);
 649
 650         return 0;
 651 }
 652
 653
 654 int bend_esrequest(void *handle, bend_esrequest_rr *rr)
 655 {
 656         perl_call_sv(esrequest_ref, G_VOID | G_DISCARD | G_NOARGS);
 657         return 0;
 658 }
 659
 660
 661 int bend_delete(void *handle, bend_delete_rr *rr)
 662 {
 663         perl_call_sv(delete_ref, G_VOID | G_DISCARD | G_NOARGS);
 664         return 0;
 665 }
 666
 667
 668 int bend_scan(void *handle, bend_scan_rr *rr)
 669 {
 670         perl_call_sv(scan_ref, G_VOID | G_DISCARD | G_NOARGS);
 671         return 0;
 672 }
 673
 674
 675 bend_initresult *bend_init(bend_initrequest *q)
 676 {
 677         bend_initresult *r = (bend_initresult *) odr_malloc (q->stream, sizeof(*r));
 678         HV *href;
 679         SV **temp;
 680         SV *name;
 681         SV *ver;
 682         SV *err_str;
 683         SV *status;
 684         Zfront_handle *zhandle =  (Zfront_handle *) xmalloc (sizeof(*zhandle));
 685         STRLEN len;
 686         int n;
 687         SV *handle;
 688         /*char *name_ptr;
 689         char *ver_ptr;*/
 690         char *ptr;
 691
 692         dSP;
 693         ENTER;
 694         SAVETMPS;
 695
 696         /*q->bend_sort = bend_sort;*/
 697         if (search_ref)
 698         {
 699                 q->bend_search = bend_search;
 700         }
 701         if (present_ref)
 702         {
 703                 q->bend_present = bend_present;
 704         }
 705         /*q->bend_esrequest = bend_esrequest;*/
 706         /*q->bend_delete = bend_delete;*/
 707         if (fetch_ref)
 708         {
 709                 q->bend_fetch = bend_fetch;
 710         }
 711         /*q->bend_scan = bend_scan;*/
 712         href = newHV();
 713         hv_store(href, "IMP_NAME", 8, newSVpv("", 0), 0);
 714         hv_store(href, "IMP_VER", 7, newSVpv("", 0), 0);
 715         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 716         hv_store(href, "PEER_NAME", 9, newSVpv(q->peer_name, 0), 0);
 717         hv_store(href, "HANDLE", 6, newSVsv(&sv_undef), 0);
 718
 719         PUSHMARK(sp);
 720
 721         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 722
 723         PUTBACK;
 724
 725         if (init_ref != NULL)
 726         {
 727                 perl_call_sv(init_ref, G_SCALAR | G_DISCARD);
 728         }
 729
 730         SPAGAIN;
 731
 732         temp = hv_fetch(href, "IMP_NAME", 8, 1);
 733         name = newSVsv(*temp);
 734
 735         temp = hv_fetch(href, "IMP_VER", 7, 1);
 736         ver = newSVsv(*temp);
 737
 738         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 739         status = newSVsv(*temp);
 740
 741         temp = hv_fetch(href, "HANDLE", 6, 1);
 742         handle= newSVsv(*temp);
 743
 744         hv_undef(href);
 745         PUTBACK;
 746         FREETMPS;
 747         LEAVE;
 748         zhandle->handle = handle;
 749         r->errcode = SvIV(status);
 750         r->handle = zhandle;
 751         ptr = SvPV(name, len);
 752         q->implementation_name = (char *)xmalloc(len + 1);
 753         strcpy(q->implementation_name, ptr);
 754 /*      q->implementation_name = SvPV(name, len);*/
 755         ptr = SvPV(ver, len);
 756         q->implementation_version = (char *)xmalloc(len + 1);
 757         strcpy(q->implementation_version, ptr);
 758
 759         return r;
 760 }
 761
 762
 763 void bend_close(void *handle)
 764 {
 765         HV *href;
 766         Zfront_handle *zhandle = (Zfront_handle *)handle;
 767         SV **temp;
 768
 769         dSP;
 770         ENTER;
 771         SAVETMPS;
 772
 773         if (close_ref == NULL)
 774         {
 775                 return;
 776         }
 777
 778         href = newHV();
 779         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 780
 781         PUSHMARK(sp);
 782
 783         XPUSHs(sv_2mortal(newRV((SV *)href)));
 784
 785         PUTBACK;
 786
 787         perl_call_sv(close_ref, G_SCALAR | G_DISCARD);
 788
 789         SPAGAIN;
 790
 791         PUTBACK;
 792         FREETMPS;
 793         LEAVE;
 794
 795         xfree(handle);
 796
 797         return;
 798 }
 799
 800
 801 #line 802 "SimpleServer.c"
 802 XS(XS_Net__Z3950__SimpleServer_set_init_handler)
 803 {
 804     dXSARGS;
 805     if (items != 1)
 806         croak("Usage: Net::Z3950::SimpleServer::set_init_handler(arg)");
 807     {
 808         SV *    arg = ST(0);
 809 #line 798 "SimpleServer.xs"
 810                 init_ref = newSVsv(arg);
 811 #line 812 "SimpleServer.c"
 812     }
 813     XSRETURN_EMPTY;
 814 }
 815
 816 XS(XS_Net__Z3950__SimpleServer_set_close_handler)
 817 {
 818     dXSARGS;
 819     if (items != 1)
 820         croak("Usage: Net::Z3950::SimpleServer::set_close_handler(arg)");
 821     {
 822         SV *    arg = ST(0);
 823 #line 805 "SimpleServer.xs"
 824                 close_ref = newSVsv(arg);
 825 #line 826 "SimpleServer.c"
 826     }
 827     XSRETURN_EMPTY;
 828 }
 829
 830 XS(XS_Net__Z3950__SimpleServer_set_sort_handler)
 831 {
 832     dXSARGS;
 833     if (items != 1)
 834         croak("Usage: Net::Z3950::SimpleServer::set_sort_handler(arg)");
 835     {
 836         SV *    arg = ST(0);
 837 #line 812 "SimpleServer.xs"
 838                 sort_ref = newSVsv(arg);
 839 #line 840 "SimpleServer.c"
 840     }
 841     XSRETURN_EMPTY;
 842 }
 843
 844 XS(XS_Net__Z3950__SimpleServer_set_search_handler)
 845 {
 846     dXSARGS;
 847     if (items != 1)
 848         croak("Usage: Net::Z3950::SimpleServer::set_search_handler(arg)");
 849     {
 850         SV *    arg = ST(0);
 851 #line 818 "SimpleServer.xs"
 852                 search_ref = newSVsv(arg);
 853 #line 854 "SimpleServer.c"
 854     }
 855     XSRETURN_EMPTY;
 856 }
 857
 858 XS(XS_Net__Z3950__SimpleServer_set_fetch_handler)
 859 {
 860     dXSARGS;
 861     if (items != 1)
 862         croak("Usage: Net::Z3950::SimpleServer::set_fetch_handler(arg)");
 863     {
 864         SV *    arg = ST(0);
 865 #line 825 "SimpleServer.xs"
 866                 fetch_ref = newSVsv(arg);
 867 #line 868 "SimpleServer.c"
 868     }
 869     XSRETURN_EMPTY;
 870 }
 871
 872 XS(XS_Net__Z3950__SimpleServer_set_present_handler)
 873 {
 874     dXSARGS;
 875     if (items != 1)
 876         croak("Usage: Net::Z3950::SimpleServer::set_present_handler(arg)");
 877     {
 878         SV *    arg = ST(0);
 879 #line 832 "SimpleServer.xs"
 880                 present_ref = newSVsv(arg);
 881 #line 882 "SimpleServer.c"
 882     }
 883     XSRETURN_EMPTY;
 884 }
 885
 886 XS(XS_Net__Z3950__SimpleServer_set_esrequest_handler)
 887 {
 888     dXSARGS;
 889     if (items != 1)
 890         croak("Usage: Net::Z3950::SimpleServer::set_esrequest_handler(arg)");
 891     {
 892         SV *    arg = ST(0);
 893 #line 839 "SimpleServer.xs"
 894                 esrequest_ref = newSVsv(arg);
 895 #line 896 "SimpleServer.c"
 896     }
 897     XSRETURN_EMPTY;
 898 }
 899
 900 XS(XS_Net__Z3950__SimpleServer_set_delete_handler)
 901 {
 902     dXSARGS;
 903     if (items != 1)
 904         croak("Usage: Net::Z3950::SimpleServer::set_delete_handler(arg)");
 905     {
 906         SV *    arg = ST(0);
 907 #line 846 "SimpleServer.xs"
 908                 delete_ref = newSVsv(arg);
 909 #line 910 "SimpleServer.c"
 910     }
 911     XSRETURN_EMPTY;
 912 }
 913
 914 XS(XS_Net__Z3950__SimpleServer_set_scan_handler)
 915 {
 916     dXSARGS;
 917     if (items != 1)
 918         croak("Usage: Net::Z3950::SimpleServer::set_scan_handler(arg)");
 919     {
 920         SV *    arg = ST(0);
 921 #line 853 "SimpleServer.xs"
 922                 scan_ref = newSVsv(arg);
 923 #line 924 "SimpleServer.c"
 924     }
 925     XSRETURN_EMPTY;
 926 }
 927
 928 XS(XS_Net__Z3950__SimpleServer_start_server)
 929 {
 930     dXSARGS;
 931     {
 932 #line 859 "SimpleServer.xs"
 933                 char **argv;
 934                 char **argv_buf;
 935                 char *ptr;
 936                 int i;
 937                 STRLEN len;
 938 #line 939 "SimpleServer.c"
 939         int     RETVAL;
 940 #line 865 "SimpleServer.xs"
 941                 argv_buf = (char **)xmalloc((items + 1) * sizeof(char *));
 942                 argv = argv_buf;
 943                 for (i = 0; i < items; i++)
 944                 {
 945                         ptr = SvPV(ST(i), len);
 946                         *argv_buf = (char *)xmalloc(len + 1);
 947                         strcpy(*argv_buf++, ptr);
 948                 }
 949                 *argv_buf = NULL;
 950
 951                 RETVAL = statserv_main(items, argv, bend_init, bend_close);
 952 #line 953 "SimpleServer.c"
 953         ST(0) = sv_newmortal();
 954         sv_setiv(ST(0), (IV)RETVAL);
 955     }
 956     XSRETURN(1);
 957 }
 958
 959 #ifdef __cplusplus
 960 extern "C"
 961 #endif
 962 XS(boot_Net__Z3950__SimpleServer)
 963 {
 964     dXSARGS;
 965     char* file = __FILE__;
 966
 967     XS_VERSION_BOOTCHECK ;
 968
 969         newXS("Net::Z3950::SimpleServer::set_init_handler", XS_Net__Z3950__SimpleServer_set_init_handler, file);
 970         newXS("Net::Z3950::SimpleServer::set_close_handler", XS_Net__Z3950__SimpleServer_set_close_handler, file);
 971         newXS("Net::Z3950::SimpleServer::set_sort_handler", XS_Net__Z3950__SimpleServer_set_sort_handler, file);
 972         newXS("Net::Z3950::SimpleServer::set_search_handler", XS_Net__Z3950__SimpleServer_set_search_handler, file);
 973         newXS("Net::Z3950::SimpleServer::set_fetch_handler", XS_Net__Z3950__SimpleServer_set_fetch_handler, file);
 974         newXS("Net::Z3950::SimpleServer::set_present_handler", XS_Net__Z3950__SimpleServer_set_present_handler, file);
 975         newXS("Net::Z3950::SimpleServer::set_esrequest_handler", XS_Net__Z3950__SimpleServer_set_esrequest_handler, file);
 976         newXS("Net::Z3950::SimpleServer::set_delete_handler", XS_Net__Z3950__SimpleServer_set_delete_handler, file);
 977         newXS("Net::Z3950::SimpleServer::set_scan_handler", XS_Net__Z3950__SimpleServer_set_scan_handler, file);
 978         newXS("Net::Z3950::SimpleServer::start_server", XS_Net__Z3950__SimpleServer_start_server, file);
 979     XSRETURN_YES;
 980 }
 981