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