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 /*$Log: SimpleServer.c,v $
  37 /*Revision 1.14  2001-08-30 14:02:10  sondberg
  38 /*Small changes.
  39 /*
  40 /*Revision 1.11  2001/08/30 13:15:11  sondberg
  41 /*Corrected a memory leak, one more to go.
  42 /*
  43 /*Revision 1.10  2001/08/29 11:48:36  sondberg
  44 /*Added routines
  45 /*
  46 /*      Net::Z3950::SimpleServer::ScanSuccess
  47 /*      Net::Z3950::SimpleServer::ScanPartial
  48 /*
  49 /*and a bit of documentation.
  50 /*
  51 /*Revision 1.9  2001/08/24 14:00:20  sondberg
  52 /*Added support for scan.
  53 /*
  54 /*Revision 1.8  2001/05/21 11:07:02  sondberg
  55 /*Extended maximum numbers of GRS-1 elements. Should be done dynamically.
  56 /*
  57 /*Revision 1.7  2001/03/13 14:17:15  sondberg
  58 /*Added support for GRS-1.
  59 /**/
  60
  61
  62 #include "EXTERN.h"
  63 #include "perl.h"
  64 #include "XSUB.h"
  65 #include <yaz/backend.h>
  66 #include <yaz/log.h>
  67 #include <yaz/wrbuf.h>
  68 #include <stdio.h>
  69 #include <unistd.h>
  70 #include <stdlib.h>
  71 #include <ctype.h>
  72 #define GRS_MAX_FIELDS 500
  73 #ifdef ASN_COMPILED
  74 #include <yaz/ill.h>
  75 #endif
  76 #ifndef sv_undef                /* To fix the problem with Perl 5.6.0 */
  77 #define sv_undef PL_sv_undef
  78 #endif
  79
  80 typedef struct {
  81         SV *handle;
  82
  83         SV *init_ref;
  84         SV *close_ref;
  85         SV *sort_ref;
  86         SV *search_ref;
  87         SV *fetch_ref;
  88         SV *present_ref;
  89         SV *esrequest_ref;
  90         SV *delete_ref;
  91         SV *scan_ref;
  92 } Zfront_handle;
  93
  94 SV *init_ref = NULL;
  95 SV *close_ref = NULL;
  96 SV *sort_ref = NULL;
  97 SV *search_ref = NULL;
  98 SV *fetch_ref = NULL;
  99 SV *present_ref = NULL;
 100 SV *esrequest_ref = NULL;
 101 SV *delete_ref = NULL;
 102 SV *scan_ref = NULL;
 103 int MAX_OID = 15;
 104
 105
 106 Z_GenericRecord *read_grs1(char *str, ODR o)
 107 {
 108         int type, ivalue;
 109         char line[512], *buf, *ptr, *original;
 110         char value[512];
 111         Z_GenericRecord *r = 0;
 112
 113         original = str;
 114         for (;;)
 115         {
 116                 Z_TaggedElement *t;
 117                 Z_ElementData *c;
 118
 119                 ptr = strchr(str, '\n');
 120                 if (!ptr) {
 121                         return r;
 122                 }
 123                 strncpy(line, str, ptr - str);
 124                 line[ptr - str] = 0;
 125                 buf = line;
 126                 str = ptr + 1;
 127                 while (*buf && isspace(*buf))
 128                         buf++;
 129                 if (*buf == '}') {
 130                         memmove(original, str, strlen(str));
 131                         return r;
 132                 }
 133                 if (sscanf(buf, "(%d,%[^)])", &type, value) != 2)
 134                 {
 135                         yaz_log(LOG_WARN, "Bad data in '%s'", buf);
 136                         return 0;
 137                 }
 138                 if (!type && *value == '0')
 139                         return r;
 140                 if (!(buf = strchr(buf, ')')))
 141                         return 0;
 142                 buf++;
 143                 while (*buf && isspace(*buf))
 144                         buf++;
 145                 if (!*buf)
 146                         return 0;
 147                 if (!r)
 148                 {
 149                         r = (Z_GenericRecord *)odr_malloc(o, sizeof(*r));
 150                         r->elements = (Z_TaggedElement **)
 151                         odr_malloc(o, sizeof(Z_TaggedElement*) * GRS_MAX_FIELDS);
 152                         r->num_elements = 0;
 153                 }
 154                 if (r->num_elements > GRS_MAX_FIELDS)
 155                 {
 156                         yaz_log(LOG_WARN, "Max number of GRS-1 elements exceeded [GRS_MAX_FIELDS=%d]", GRS_MAX_FIELDS);
 157                         exit(0);
 158                 }
 159                 r->elements[r->num_elements] = t = (Z_TaggedElement *) odr_malloc(o, sizeof(Z_TaggedElement));
 160                 t->tagType = (int *)odr_malloc(o, sizeof(int));
 161                 *t->tagType = type;
 162                 t->tagValue = (Z_StringOrNumeric *)
 163                         odr_malloc(o, sizeof(Z_StringOrNumeric));
 164                 if ((ivalue = atoi(value)))
 165                 {
 166                         t->tagValue->which = Z_StringOrNumeric_numeric;
 167                         t->tagValue->u.numeric = (int *)odr_malloc(o, sizeof(int));
 168                         *t->tagValue->u.numeric = ivalue;
 169                 }
 170                 else
 171                 {
 172                         t->tagValue->which = Z_StringOrNumeric_string;
 173                         t->tagValue->u.string = (char *)odr_malloc(o, strlen(value)+1);
 174                         strcpy(t->tagValue->u.string, value);
 175                 }
 176                 t->tagOccurrence = 0;
 177                 t->metaData = 0;
 178                 t->appliedVariant = 0;
 179                 t->content = c = (Z_ElementData *)odr_malloc(o, sizeof(Z_ElementData));
 180                 if (*buf == '{')
 181                 {
 182                         c->which = Z_ElementData_subtree;
 183                         c->u.subtree = read_grs1(str, o);
 184                 }
 185                 else
 186                 {
 187                         c->which = Z_ElementData_string;
 188 /*                      buf[strlen(buf)-1] = '\0';*/
 189                         buf[strlen(buf)] = '\0';
 190                         c->u.string = odr_strdup(o, buf);
 191                 }
 192                 r->num_elements++;
 193         }
 194 }
 195
 196
 197
 198
 199 static void oid2str(Odr_oid *o, WRBUF buf)
 200 {
 201     for (; *o >= 0; o++) {
 202         char ibuf[16];
 203         sprintf(ibuf, "%d", *o);
 204         wrbuf_puts(buf, ibuf);
 205         if (o[1] > 0)
 206             wrbuf_putc(buf, '.');
 207     }
 208 }
 209
 210
 211 static int rpn2pquery(Z_RPNStructure *s, WRBUF buf)
 212 {
 213     switch (s->which) {
 214         case Z_RPNStructure_simple: {
 215             Z_Operand *o = s->u.simple;
 216
 217             switch (o->which) {
 218                 case Z_Operand_APT: {
 219                     Z_AttributesPlusTerm *at = o->u.attributesPlusTerm;
 220
 221                     if (at->attributes) {
 222                         int i;
 223                         char ibuf[16];
 224
 225                         for (i = 0; i < at->attributes->num_attributes; i++) {
 226                             wrbuf_puts(buf, "@attr ");
 227                             if (at->attributes->attributes[i]->attributeSet) {
 228                                 oid2str(at->attributes->attributes[i]->attributeSet, buf);
 229                                 wrbuf_putc(buf, ' ');
 230                             }
 231                             sprintf(ibuf, "%d=", *at->attributes->attributes[i]->attributeType);
 232                             assert(at->attributes->attributes[i]->which == Z_AttributeValue_numeric);
 233                             wrbuf_puts(buf, ibuf);
 234                             sprintf(ibuf, "%d ", *at->attributes->attributes[i]->value.numeric);
 235                             wrbuf_puts(buf, ibuf);
 236                         }
 237                     }
 238                     switch (at->term->which) {
 239                         case Z_Term_general: {
 240                             wrbuf_putc(buf, '"');
 241                             wrbuf_write(buf, (char*) at->term->u.general->buf, at->term->u.general->len);
 242                             wrbuf_puts(buf, "\" ");
 243                             break;
 244                         }
 245                         default: abort();
 246                     }
 247                     break;
 248                 }
 249                 default: abort();
 250             }
 251             break;
 252         }
 253         case Z_RPNStructure_complex: {
 254             Z_Complex *c = s->u.complex;
 255
 256             switch (c->roperator->which) {
 257                 case Z_Operator_and: wrbuf_puts(buf, "@and "); break;
 258                 case Z_Operator_or: wrbuf_puts(buf, "@or "); break;
 259                 case Z_Operator_and_not: wrbuf_puts(buf, "@not "); break;
 260                 case Z_Operator_prox: abort();
 261                 default: abort();
 262             }
 263             if (!rpn2pquery(c->s1, buf))
 264                 return 0;
 265             if (!rpn2pquery(c->s2, buf))
 266                 return 0;
 267             break;
 268         }
 269         default: abort();
 270     }
 271     return 1;
 272 }
 273
 274
 275 WRBUF zquery2pquery(Z_Query *q)
 276 {
 277     WRBUF buf = wrbuf_alloc();
 278
 279     if (q->which != Z_Query_type_1 && q->which != Z_Query_type_101)
 280         return 0;
 281     if (q->u.type_1->attributeSetId) {
 282         /* Output attribute set ID */
 283         wrbuf_puts(buf, "@attrset ");
 284         oid2str(q->u.type_1->attributeSetId, buf);
 285         wrbuf_putc(buf, ' ');
 286     }
 287     return rpn2pquery(q->u.type_1->RPNStructure, buf) ? buf : 0;
 288 }
 289
 290
 291 int bend_sort(void *handle, bend_sort_rr *rr)
 292 {
 293         HV *href;
 294         AV *aref;
 295         SV **temp;
 296         SV *err_code;
 297         SV *err_str;
 298         SV *status;
 299         STRLEN len;
 300         char *ptr;
 301         char *ODR_err_str;
 302         char **input_setnames;
 303         Zfront_handle *zhandle = (Zfront_handle *)handle;
 304         int i;
 305
 306         dSP;
 307         ENTER;
 308         SAVETMPS;
 309
 310         aref = newAV();
 311         input_setnames = rr->input_setnames;
 312         for (i = 0; i < rr->num_input_setnames; i++)
 313         {
 314                 av_push(aref, newSVpv(*input_setnames++, 0));
 315         }
 316         href = newHV();
 317         hv_store(href, "INPUT", 5, newRV( (SV*) aref), 0);
 318         hv_store(href, "OUTPUT", 6, newSVpv(rr->output_setname, 0), 0);
 319         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 320         hv_store(href, "STATUS", 6, newSViv(0), 0);
 321
 322         PUSHMARK(sp);
 323
 324         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 325
 326         PUTBACK;
 327
 328         perl_call_sv(sort_ref, G_SCALAR | G_DISCARD);
 329
 330         SPAGAIN;
 331
 332         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 333         err_code = newSVsv(*temp);
 334
 335         temp = hv_fetch(href, "ERR_STR", 7, 1);
 336         err_str = newSVsv(*temp);
 337
 338         temp = hv_fetch(href, "STATUS", 6, 1);
 339         status = newSVsv(*temp);
 340
 341
 342
 343
 344         PUTBACK;
 345         FREETMPS;
 346         LEAVE;
 347
 348         hv_undef(href),
 349         av_undef(aref);
 350         rr->errcode = SvIV(err_code);
 351         rr->sort_status = SvIV(status);
 352         ptr = SvPV(err_str, len);
 353         ODR_err_str = (char *)odr_malloc(rr->stream, len + 1);
 354         strcpy(ODR_err_str, ptr);
 355         rr->errstring = ODR_err_str;
 356
 357         sv_free(err_code);
 358         sv_free(err_str);
 359         sv_free(status);
 360
 361         return 0;
 362 }
 363
 364
 365 int bend_search(void *handle, bend_search_rr *rr)
 366 {
 367         HV *href;
 368         AV *aref;
 369         SV **temp;
 370         SV *hits;
 371         SV *err_code;
 372         SV *err_str;
 373         char *ODR_errstr;
 374         STRLEN len;
 375         int i;
 376         char **basenames;
 377         int n;
 378         WRBUF query;
 379         char *ptr;
 380         SV *point;
 381         SV *ODR_point;
 382         Zfront_handle *zhandle = (Zfront_handle *)handle;
 383
 384         dSP;
 385         ENTER;
 386         SAVETMPS;
 387
 388         aref = newAV();
 389         basenames = rr->basenames;
 390         for (i = 0; i < rr->num_bases; i++)
 391         {
 392                 av_push(aref, newSVpv(*basenames++, 0));
 393         }
 394         href = newHV();
 395         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 396         hv_store(href, "REPL_SET", 8, newSViv(rr->replace_set), 0);
 397         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 398         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 399         hv_store(href, "HITS", 4, newSViv(0), 0);
 400         hv_store(href, "DATABASES", 9, newRV( (SV*) aref), 0);
 401         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 402         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 403         query = zquery2pquery(rr->query);
 404         if (query)
 405         {
 406                 hv_store(href, "QUERY", 5, newSVpv((char *)query->buf, query->pos), 0);
 407         }
 408         else
 409         {
 410                 rr->errcode = 108;
 411         }
 412         PUSHMARK(sp);
 413
 414         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 415
 416         PUTBACK;
 417
 418         n = perl_call_sv(search_ref, G_SCALAR | G_DISCARD);
 419
 420         SPAGAIN;
 421
 422         temp = hv_fetch(href, "HITS", 4, 1);
 423         hits = newSVsv(*temp);
 424
 425         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 426         err_code = newSVsv(*temp);
 427
 428         temp = hv_fetch(href, "ERR_STR", 7, 1);
 429         err_str = newSVsv(*temp);
 430
 431         temp = hv_fetch(href, "HANDLE", 6, 1);
 432         point = newSVsv(*temp);
 433
 434         PUTBACK;
 435         FREETMPS;
 436         LEAVE;
 437
 438         hv_undef(href);
 439         av_undef(aref);
 440         rr->hits = SvIV(hits);
 441         rr->errcode = SvIV(err_code);
 442         ptr = SvPV(err_str, len);
 443         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 444         strcpy(ODR_errstr, ptr);
 445         rr->errstring = ODR_errstr;
 446 /*      ODR_point = (SV *)odr_malloc(rr->stream, sizeof(*point));
 447         memcpy(ODR_point, point, sizeof(*point));
 448         zhandle->handle = ODR_point;*/
 449         zhandle->handle = point;
 450         handle = zhandle;
 451         sv_free(hits);
 452         sv_free(err_code);
 453         sv_free(err_str);
 454         sv_free( (SV*) aref);
 455         sv_free( (SV*) href);
 456         /*sv_free(point);*/
 457         wrbuf_free(query, 1);
 458         return 0;
 459 }
 460
 461
 462 WRBUF oid2dotted(int *oid)
 463 {
 464
 465         WRBUF buf = wrbuf_alloc();
 466         int dot = 0;
 467
 468         for (; *oid != -1 ; oid++)
 469         {
 470                 char ibuf[16];
 471                 if (dot)
 472                 {
 473                         wrbuf_putc(buf, '.');
 474                 }
 475                 else
 476                 {
 477                         dot = 1;
 478                 }
 479                 sprintf(ibuf, "%d", *oid);
 480                 wrbuf_puts(buf, ibuf);
 481         }
 482         return buf;
 483 }
 484
 485
 486 int dotted2oid(char *dotted, int *buffer)
 487 {
 488         int *oid;
 489         char ibuf[16];
 490         char *ptr;
 491         int n = 0;
 492
 493         ptr = ibuf;
 494         oid = buffer;
 495         while (*dotted)
 496         {
 497                 if (*dotted == '.')
 498                 {
 499                         n++;
 500                         if (n == MAX_OID)  /* Terminate if more than MAX_OID entries */
 501                         {
 502                                 *oid = -1;
 503                                 return -1;
 504                         }
 505                         *ptr = 0;
 506                         sscanf(ibuf, "%d", oid++);
 507                         ptr = ibuf;
 508                         dotted++;
 509
 510                 }
 511                 else
 512                 {
 513                         *ptr++ = *dotted++;
 514                 }
 515         }
 516         if (n < MAX_OID)
 517         {
 518                 *ptr = 0;
 519                 sscanf(ibuf, "%d", oid++);
 520         }
 521         *oid = -1;
 522         return 0;
 523 }
 524
 525
 526 int bend_fetch(void *handle, bend_fetch_rr *rr)
 527 {
 528         HV *href;
 529         SV **temp;
 530         SV *basename;
 531         SV *record;
 532         SV *last;
 533         SV *err_code;
 534         SV *err_string;
 535         SV *sur_flag;
 536         SV *point;
 537         SV *rep_form;
 538         char *ptr;
 539         char *ODR_record;
 540         char *ODR_basename;
 541         char *ODR_errstr;
 542         int *ODR_oid_buf;
 543         oident *oid;
 544         WRBUF oid_dotted;
 545         Zfront_handle *zhandle = (Zfront_handle *)handle;
 546
 547         Z_RecordComposition *composition;
 548         Z_ElementSetNames *simple;
 549         STRLEN length;
 550
 551         dSP;
 552         ENTER;
 553         SAVETMPS;
 554
 555         rr->errcode = 0;
 556         href = newHV();
 557         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 558         temp = hv_store(href, "OFFSET", 6, newSViv(rr->number), 0);
 559         oid_dotted = oid2dotted(rr->request_format_raw);
 560         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 561         hv_store(href, "REP_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);
 562         hv_store(href, "BASENAME", 8, newSVpv("", 0), 0);
 563         hv_store(href, "RECORD", 6, newSVpv("", 0), 0);
 564         hv_store(href, "LAST", 4, newSViv(0), 0);
 565         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 566         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 567         hv_store(href, "SUR_FLAG", 8, newSViv(0), 0);
 568         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 569         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 570         if (rr->comp)
 571         {
 572                 composition = rr->comp;
 573                 if (composition->which == Z_RecordComp_simple)
 574                 {
 575                         simple = composition->u.simple;
 576                         if (simple->which == Z_ElementSetNames_generic)
 577                         {
 578                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 579                         }
 580                         else
 581                         {
 582                                 rr->errcode = 26;
 583                         }
 584                 }
 585                 else
 586                 {
 587                         rr->errcode = 26;
 588                 }
 589         }
 590
 591         PUSHMARK(sp);
 592
 593         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 594
 595         PUTBACK;
 596
 597         perl_call_sv(fetch_ref, G_SCALAR | G_DISCARD);
 598
 599         SPAGAIN;
 600
 601         temp = hv_fetch(href, "BASENAME", 8, 1);
 602         basename = newSVsv(*temp);
 603
 604         temp = hv_fetch(href, "RECORD", 6, 1);
 605         record = newSVsv(*temp);
 606
 607         temp = hv_fetch(href, "LAST", 4, 1);
 608         last = newSVsv(*temp);
 609
 610         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 611         err_code = newSVsv(*temp);
 612
 613         temp = hv_fetch(href, "ERR_STR", 7, 1),
 614         err_string = newSVsv(*temp);
 615
 616         temp = hv_fetch(href, "SUR_FLAG", 8, 1);
 617         sur_flag = newSVsv(*temp);
 618
 619         temp = hv_fetch(href, "REP_FORM", 8, 1);
 620         rep_form = newSVsv(*temp);
 621
 622         temp = hv_fetch(href, "HANDLE", 6, 1);
 623         point = newSVsv(*temp);
 624
 625         PUTBACK;
 626         FREETMPS;
 627         LEAVE;
 628
 629         hv_undef(href);
 630
 631         ptr = SvPV(basename, length);
 632         ODR_basename = (char *)odr_malloc(rr->stream, length + 1);
 633         strcpy(ODR_basename, ptr);
 634         rr->basename = ODR_basename;
 635
 636         ptr = SvPV(rep_form, length);
 637         ODR_oid_buf = (int *)odr_malloc(rr->stream, (MAX_OID + 1) * sizeof(int));
 638         if (dotted2oid(ptr, ODR_oid_buf) == -1)         /* Maximum number of OID elements exceeded */
 639         {
 640                 printf("Net::Z3950::SimpleServer: WARNING: OID structure too long, max length is %d\n", MAX_OID);
 641         }
 642         rr->output_format_raw = ODR_oid_buf;
 643
 644         ptr = SvPV(record, length);
 645         oid = oid_getentbyoid(ODR_oid_buf);
 646         if (oid->value == VAL_GRS1)             /* Treat GRS-1 records separately */
 647         {
 648                 rr->record = (char *) read_grs1(ptr, rr->stream);
 649                 rr->len = -1;
 650         }
 651         else
 652         {
 653                 ODR_record = (char *)odr_malloc(rr->stream, length + 1);
 654                 strcpy(ODR_record, ptr);
 655                 rr->record = ODR_record;
 656                 rr->len = length;
 657         }
 658         zhandle->handle = point;
 659         handle = zhandle;
 660         rr->last_in_set = SvIV(last);
 661
 662         if (!(rr->errcode))
 663         {
 664                 rr->errcode = SvIV(err_code);
 665                 ptr = SvPV(err_string, length);
 666                 ODR_errstr = (char *)odr_malloc(rr->stream, length + 1);
 667                 strcpy(ODR_errstr, ptr);
 668                 rr->errstring = ODR_errstr;
 669         }
 670         rr->surrogate_flag = SvIV(sur_flag);
 671
 672         wrbuf_free(oid_dotted, 1);
 673         sv_free((SV*) href);
 674         sv_free(basename);
 675         sv_free(record);
 676         sv_free(last);
 677         sv_free(err_string);
 678         sv_free(err_code),
 679         sv_free(sur_flag);
 680         sv_free(rep_form);
 681
 682         return 0;
 683 }
 684
 685
 686 int bend_present(void *handle, bend_present_rr *rr)
 687 {
 688
 689         HV *href;
 690         SV **temp;
 691         SV *err_code;
 692         SV *err_string;
 693         SV *hits;
 694         SV *point;
 695         STRLEN len;
 696         Z_RecordComposition *composition;
 697         Z_ElementSetNames *simple;
 698         char *ODR_errstr;
 699         char *ptr;
 700         Zfront_handle *zhandle = (Zfront_handle *)handle;
 701
 702 /*      WRBUF oid_dotted; */
 703
 704         dSP;
 705         ENTER;
 706         SAVETMPS;
 707
 708         href = newHV();
 709         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 710         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 711         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 712         hv_store(href, "START", 5, newSViv(rr->start), 0);
 713         hv_store(href, "SETNAME", 7, newSVpv(rr->setname, 0), 0);
 714         hv_store(href, "NUMBER", 6, newSViv(rr->number), 0);
 715         /*oid_dotted = oid2dotted(rr->request_format_raw);
 716         hv_store(href, "REQ_FORM", 8, newSVpv((char *)oid_dotted->buf, oid_dotted->pos), 0);*/
 717         hv_store(href, "HITS", 4, newSViv(0), 0);
 718         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 719         if (rr->comp)
 720         {
 721                 composition = rr->comp;
 722                 if (composition->which == Z_RecordComp_simple)
 723                 {
 724                         simple = composition->u.simple;
 725                         if (simple->which == Z_ElementSetNames_generic)
 726                         {
 727                                 hv_store(href, "COMP", 4, newSVpv(simple->u.generic, 0), 0);
 728                         }
 729                         else
 730                         {
 731                                 rr->errcode = 26;
 732                                 return 0;
 733                         }
 734                 }
 735                 else
 736                 {
 737                         rr->errcode = 26;
 738                         return 0;
 739                 }
 740         }
 741
 742         PUSHMARK(sp);
 743
 744         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 745
 746         PUTBACK;
 747
 748         perl_call_sv(present_ref, G_SCALAR | G_DISCARD);
 749
 750         SPAGAIN;
 751
 752         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 753         err_code = newSVsv(*temp);
 754
 755         temp = hv_fetch(href, "ERR_STR", 7, 1);
 756         err_string = newSVsv(*temp);
 757
 758         temp = hv_fetch(href, "HITS", 4, 1);
 759         hits = newSVsv(*temp);
 760
 761         temp = hv_fetch(href, "HANDLE", 6, 1);
 762         point = newSVsv(*temp);
 763
 764         PUTBACK;
 765         FREETMPS;
 766         LEAVE;
 767
 768         hv_undef(href);
 769         rr->errcode = SvIV(err_code);
 770         rr->hits = SvIV(hits);
 771
 772         ptr = SvPV(err_string, len);
 773         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 774         strcpy(ODR_errstr, ptr);
 775         rr->errstring = ODR_errstr;
 776 /*      wrbuf_free(oid_dotted, 1);*/
 777         zhandle->handle = point;
 778         handle = zhandle;
 779         sv_free(err_code);
 780         sv_free(err_string);
 781         sv_free(hits);
 782         sv_free( (SV*) href);
 783
 784         return 0;
 785 }
 786
 787
 788 int bend_esrequest(void *handle, bend_esrequest_rr *rr)
 789 {
 790         perl_call_sv(esrequest_ref, G_VOID | G_DISCARD | G_NOARGS);
 791         return 0;
 792 }
 793
 794
 795 int bend_delete(void *handle, bend_delete_rr *rr)
 796 {
 797         perl_call_sv(delete_ref, G_VOID | G_DISCARD | G_NOARGS);
 798         return 0;
 799 }
 800
 801
 802 int bend_scan(void *handle, bend_scan_rr *rr)
 803 {
 804         HV *href;
 805         AV *aref;
 806         AV *list;
 807         AV *entries;
 808         HV *scan_item;
 809         struct scan_entry *scan_list;
 810         struct scan_entry *buffer;
 811         int *step_size = rr->step_size;
 812         int i;
 813         char **basenames;
 814         SV **temp;
 815         SV *err_code = sv_newmortal();
 816         SV *err_str = sv_newmortal();
 817         SV *point = sv_newmortal();
 818         SV *status = sv_newmortal();
 819         SV *number = sv_newmortal();
 820         char *ptr;
 821         char *ODR_errstr;
 822         STRLEN len;
 823         int term_len;
 824         SV *term_tmp;
 825         SV *entries_ref;
 826
 827         Zfront_handle *zhandle = (Zfront_handle *)handle;
 828
 829         dSP;
 830         ENTER;
 831         SAVETMPS;
 832         href = newHV();
 833         list = newAV();
 834         if (rr->term->term->which == Z_Term_general)
 835         {
 836                 term_len = rr->term->term->u.general->len;
 837                 hv_store(href, "TERM", 4, newSVpv(rr->term->term->u.general->buf, term_len), 0);
 838         } else {
 839                 rr->errcode = 229;      /* Unsupported term type */
 840                 return 0;
 841         }
 842         hv_store(href, "STEP", 4, newSViv(*step_size), 0);
 843         hv_store(href, "NUMBER", 6, newSViv(rr->num_entries), 0);
 844         hv_store(href, "POS", 3, newSViv(rr->term_position), 0);
 845         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 846         hv_store(href, "ERR_STR", 7, newSVpv("", 0), 0);
 847         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
 848         hv_store(href, "STATUS", 6, newSViv(BEND_SCAN_SUCCESS), 0);
 849         hv_store(href, "ENTRIES", 7, newRV((SV *) list), 0);
 850         aref = newAV();
 851         basenames = rr->basenames;
 852         for (i = 0; i < rr->num_bases; i++)
 853         {
 854                 av_push(aref, newSVpv(*basenames++, 0));
 855         }
 856         hv_store(href, "DATABASES", 9, newRV( (SV*) aref), 0);
 857
 858         PUSHMARK(sp);
 859
 860         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 861
 862         PUTBACK;
 863
 864         perl_call_sv(scan_ref, G_SCALAR | G_DISCARD);
 865
 866         SPAGAIN;
 867
 868         temp = hv_fetch(href, "ERR_CODE", 8, 1);
 869         err_code = newSVsv(*temp);
 870
 871         temp = hv_fetch(href, "ERR_STR", 7, 1);
 872         err_str = newSVsv(*temp);
 873
 874         temp = hv_fetch(href, "HANDLE", 6, 1);
 875         point = newSVsv(*temp);
 876
 877         temp = hv_fetch(href, "STATUS", 6, 1);
 878         status = newSVsv(*temp);
 879
 880         temp = hv_fetch(href, "NUMBER", 6, 1);
 881         number = newSVsv(*temp);
 882
 883         temp = hv_fetch(href, "ENTRIES", 7, 1);
 884         entries_ref = newSVsv(*temp);
 885
 886         PUTBACK;
 887         FREETMPS;
 888         LEAVE;
 889
 890         ptr = SvPV(err_str, len);
 891         ODR_errstr = (char *)odr_malloc(rr->stream, len + 1);
 892         strcpy(ODR_errstr, ptr);
 893         rr->errstring = ODR_errstr;
 894         rr->errcode = SvIV(err_code);
 895         rr->num_entries = SvIV(number);
 896         rr->status = SvIV(status);
 897         scan_list = (struct scan_entry *) odr_malloc (rr->stream, rr->num_entries * sizeof(*scan_list));
 898         buffer = scan_list;
 899         entries = (AV *)SvRV(entries_ref);
 900         for (i = 0; i < rr->num_entries; i++)
 901         {
 902                 scan_item = (HV *)SvRV(sv_2mortal(av_shift(entries)));
 903                 temp = hv_fetch(scan_item, "TERM", 4, 1);
 904                 ptr = SvPV(*temp, len);
 905                 buffer->term = (char *) odr_malloc (rr->stream, len + 1);
 906                 strcpy(buffer->term, ptr);
 907                 temp = hv_fetch(scan_item, "OCCURRENCE", 10, 1);
 908                 buffer->occurrences = SvIV(*temp);
 909                 buffer++;
 910                 hv_undef(scan_item);
 911         }
 912         rr->entries = scan_list;
 913         zhandle->handle = point;
 914         handle = zhandle;
 915         sv_free(err_code);
 916         sv_free(err_str);
 917         sv_free(status);
 918         sv_free(number);
 919         hv_undef(href);
 920         sv_free((SV *)href);
 921         av_undef(aref);
 922         sv_free((SV *)aref);
 923         av_undef(list);
 924         sv_free((SV *)list);
 925         av_undef(entries);
 926         /*sv_free((SV *)entries);*/
 927         sv_free(entries_ref);
 928
 929         return 0;
 930 }
 931
 932
 933 bend_initresult *bend_init(bend_initrequest *q)
 934 {
 935         bend_initresult *r = (bend_initresult *) odr_malloc (q->stream, sizeof(*r));
 936         HV *href;
 937         SV **temp;
 938         SV *name;
 939         SV *ver;
 940         SV *err_str;
 941         SV *status;
 942         Zfront_handle *zhandle =  (Zfront_handle *) xmalloc (sizeof(*zhandle));
 943         STRLEN len;
 944         int n;
 945         SV *handle;
 946         /*char *name_ptr;
 947         char *ver_ptr;*/
 948         char *ptr;
 949
 950         dSP;
 951         ENTER;
 952         SAVETMPS;
 953
 954         /*q->bend_sort = bend_sort;*/
 955         if (search_ref)
 956         {
 957                 q->bend_search = bend_search;
 958         }
 959         if (present_ref)
 960         {
 961                 q->bend_present = bend_present;
 962         }
 963         /*q->bend_esrequest = bend_esrequest;*/
 964         /*q->bend_delete = bend_delete;*/
 965         if (fetch_ref)
 966         {
 967                 q->bend_fetch = bend_fetch;
 968         }
 969         if (scan_ref)
 970         {
 971                 q->bend_scan = bend_scan;
 972         }
 973         href = newHV();
 974         hv_store(href, "IMP_NAME", 8, newSVpv("", 0), 0);
 975         hv_store(href, "IMP_VER", 7, newSVpv("", 0), 0);
 976         hv_store(href, "ERR_CODE", 8, newSViv(0), 0);
 977         hv_store(href, "PEER_NAME", 9, newSVpv(q->peer_name, 0), 0);
 978         hv_store(href, "HANDLE", 6, newSVsv(&sv_undef), 0);
 979         hv_store(href, "PID", 3, newSViv(getpid()), 0);
 980
 981         PUSHMARK(sp);
 982
 983         XPUSHs(sv_2mortal(newRV( (SV*) href)));
 984
 985         PUTBACK;
 986
 987         if (init_ref != NULL)
 988         {
 989                 perl_call_sv(init_ref, G_SCALAR | G_DISCARD);
 990         }
 991
 992         SPAGAIN;
 993
 994         temp = hv_fetch(href, "IMP_NAME", 8, 1);
 995         name = newSVsv(*temp);
 996
 997         temp = hv_fetch(href, "IMP_VER", 7, 1);
 998         ver = newSVsv(*temp);
 999
1000         temp = hv_fetch(href, "ERR_CODE", 8, 1);
1001         status = newSVsv(*temp);
1002
1003         temp = hv_fetch(href, "HANDLE", 6, 1);
1004         handle= newSVsv(*temp);
1005
1006         hv_undef(href);
1007         PUTBACK;
1008         FREETMPS;
1009         LEAVE;
1010         zhandle->handle = handle;
1011         r->errcode = SvIV(status);
1012         r->handle = zhandle;
1013         ptr = SvPV(name, len);
1014         q->implementation_name = (char *)xmalloc(len + 1);
1015         strcpy(q->implementation_name, ptr);
1016 /*      q->implementation_name = SvPV(name, len);*/
1017         ptr = SvPV(ver, len);
1018         q->implementation_version = (char *)xmalloc(len + 1);
1019         strcpy(q->implementation_version, ptr);
1020
1021         return r;
1022 }
1023
1024
1025 void bend_close(void *handle)
1026 {
1027         HV *href;
1028         Zfront_handle *zhandle = (Zfront_handle *)handle;
1029         SV **temp;
1030
1031         dSP;
1032         ENTER;
1033         SAVETMPS;
1034
1035         if (close_ref == NULL)
1036         {
1037                 return;
1038         }
1039
1040         href = newHV();
1041         hv_store(href, "HANDLE", 6, zhandle->handle, 0);
1042
1043         PUSHMARK(sp);
1044
1045         XPUSHs(sv_2mortal(newRV((SV *)href)));
1046
1047         PUTBACK;
1048
1049         perl_call_sv(close_ref, G_SCALAR | G_DISCARD);
1050
1051         SPAGAIN;
1052
1053         PUTBACK;
1054         FREETMPS;
1055         LEAVE;
1056
1057         xfree(handle);
1058
1059         return;
1060 }
1061
1062
1063 #line 1061 "SimpleServer.c"
1064 XS(XS_Net__Z3950__SimpleServer_set_init_handler)
1065 {
1066     dXSARGS;
1067     if (items != 1)
1068         croak("Usage: Net::Z3950::SimpleServer::set_init_handler(arg)");
1069     {
1070         SV *    arg = ST(0);
1071 #line 1057 "SimpleServer.xs"
1072                 init_ref = newSVsv(arg);
1073 #line 1071 "SimpleServer.c"
1074     }
1075     XSRETURN_EMPTY;
1076 }
1077
1078 XS(XS_Net__Z3950__SimpleServer_set_close_handler)
1079 {
1080     dXSARGS;
1081     if (items != 1)
1082         croak("Usage: Net::Z3950::SimpleServer::set_close_handler(arg)");
1083     {
1084         SV *    arg = ST(0);
1085 #line 1064 "SimpleServer.xs"
1086                 close_ref = newSVsv(arg);
1087 #line 1085 "SimpleServer.c"
1088     }
1089     XSRETURN_EMPTY;
1090 }
1091
1092 XS(XS_Net__Z3950__SimpleServer_set_sort_handler)
1093 {
1094     dXSARGS;
1095     if (items != 1)
1096         croak("Usage: Net::Z3950::SimpleServer::set_sort_handler(arg)");
1097     {
1098         SV *    arg = ST(0);
1099 #line 1071 "SimpleServer.xs"
1100                 sort_ref = newSVsv(arg);
1101 #line 1099 "SimpleServer.c"
1102     }
1103     XSRETURN_EMPTY;
1104 }
1105
1106 XS(XS_Net__Z3950__SimpleServer_set_search_handler)
1107 {
1108     dXSARGS;
1109     if (items != 1)
1110         croak("Usage: Net::Z3950::SimpleServer::set_search_handler(arg)");
1111     {
1112         SV *    arg = ST(0);
1113 #line 1077 "SimpleServer.xs"
1114                 search_ref = newSVsv(arg);
1115 #line 1113 "SimpleServer.c"
1116     }
1117     XSRETURN_EMPTY;
1118 }
1119
1120 XS(XS_Net__Z3950__SimpleServer_set_fetch_handler)
1121 {
1122     dXSARGS;
1123     if (items != 1)
1124         croak("Usage: Net::Z3950::SimpleServer::set_fetch_handler(arg)");
1125     {
1126         SV *    arg = ST(0);
1127 #line 1084 "SimpleServer.xs"
1128                 fetch_ref = newSVsv(arg);
1129 #line 1127 "SimpleServer.c"
1130     }
1131     XSRETURN_EMPTY;
1132 }
1133
1134 XS(XS_Net__Z3950__SimpleServer_set_present_handler)
1135 {
1136     dXSARGS;
1137     if (items != 1)
1138         croak("Usage: Net::Z3950::SimpleServer::set_present_handler(arg)");
1139     {
1140         SV *    arg = ST(0);
1141 #line 1091 "SimpleServer.xs"
1142                 present_ref = newSVsv(arg);
1143 #line 1141 "SimpleServer.c"
1144     }
1145     XSRETURN_EMPTY;
1146 }
1147
1148 XS(XS_Net__Z3950__SimpleServer_set_esrequest_handler)
1149 {
1150     dXSARGS;
1151     if (items != 1)
1152         croak("Usage: Net::Z3950::SimpleServer::set_esrequest_handler(arg)");
1153     {
1154         SV *    arg = ST(0);
1155 #line 1098 "SimpleServer.xs"
1156                 esrequest_ref = newSVsv(arg);
1157 #line 1155 "SimpleServer.c"
1158     }
1159     XSRETURN_EMPTY;
1160 }
1161
1162 XS(XS_Net__Z3950__SimpleServer_set_delete_handler)
1163 {
1164     dXSARGS;
1165     if (items != 1)
1166         croak("Usage: Net::Z3950::SimpleServer::set_delete_handler(arg)");
1167     {
1168         SV *    arg = ST(0);
1169 #line 1105 "SimpleServer.xs"
1170                 delete_ref = newSVsv(arg);
1171 #line 1169 "SimpleServer.c"
1172     }
1173     XSRETURN_EMPTY;
1174 }
1175
1176 XS(XS_Net__Z3950__SimpleServer_set_scan_handler)
1177 {
1178     dXSARGS;
1179     if (items != 1)
1180         croak("Usage: Net::Z3950::SimpleServer::set_scan_handler(arg)");
1181     {
1182         SV *    arg = ST(0);
1183 #line 1112 "SimpleServer.xs"
1184                 scan_ref = newSVsv(arg);
1185 #line 1183 "SimpleServer.c"
1186     }
1187     XSRETURN_EMPTY;
1188 }
1189
1190 XS(XS_Net__Z3950__SimpleServer_start_server)
1191 {
1192     dXSARGS;
1193     {
1194 #line 1118 "SimpleServer.xs"
1195                 char **argv;
1196                 char **argv_buf;
1197                 char *ptr;
1198                 int i;
1199                 STRLEN len;
1200 #line 1198 "SimpleServer.c"
1201         int     RETVAL;
1202 #line 1124 "SimpleServer.xs"
1203                 argv_buf = (char **)xmalloc((items + 1) * sizeof(char *));
1204                 argv = argv_buf;
1205                 for (i = 0; i < items; i++)
1206                 {
1207                         ptr = SvPV(ST(i), len);
1208                         *argv_buf = (char *)xmalloc(len + 1);
1209                         strcpy(*argv_buf++, ptr);
1210                 }
1211                 *argv_buf = NULL;
1212
1213                 RETVAL = statserv_main(items, argv, bend_init, bend_close);
1214 #line 1212 "SimpleServer.c"
1215         ST(0) = sv_newmortal();
1216         sv_setiv(ST(0), (IV)RETVAL);
1217     }
1218     XSRETURN(1);
1219 }
1220
1221 XS(XS_Net__Z3950__SimpleServer_ScanSuccess)
1222 {
1223     dXSARGS;
1224     if (items != 0)
1225         croak("Usage: Net::Z3950::SimpleServer::ScanSuccess()");
1226     {
1227         int     RETVAL;
1228 #line 1142 "SimpleServer.xs"
1229                 RETVAL = BEND_SCAN_SUCCESS;
1230 #line 1228 "SimpleServer.c"
1231         ST(0) = sv_newmortal();
1232         sv_setiv(ST(0), (IV)RETVAL);
1233     }
1234     XSRETURN(1);
1235 }
1236
1237 XS(XS_Net__Z3950__SimpleServer_ScanPartial)
1238 {
1239     dXSARGS;
1240     if (items != 0)
1241         croak("Usage: Net::Z3950::SimpleServer::ScanPartial()");
1242     {
1243         int     RETVAL;
1244 #line 1149 "SimpleServer.xs"
1245                 RETVAL = BEND_SCAN_PARTIAL;
1246 #line 1244 "SimpleServer.c"
1247         ST(0) = sv_newmortal();
1248         sv_setiv(ST(0), (IV)RETVAL);
1249     }
1250     XSRETURN(1);
1251 }
1252
1253 #ifdef __cplusplus
1254 extern "C"
1255 #endif
1256 XS(boot_Net__Z3950__SimpleServer)
1257 {
1258     dXSARGS;
1259     char* file = __FILE__;
1260
1261     XS_VERSION_BOOTCHECK ;
1262
1263         newXS("Net::Z3950::SimpleServer::set_init_handler", XS_Net__Z3950__SimpleServer_set_init_handler, file);
1264         newXS("Net::Z3950::SimpleServer::set_close_handler", XS_Net__Z3950__SimpleServer_set_close_handler, file);
1265         newXS("Net::Z3950::SimpleServer::set_sort_handler", XS_Net__Z3950__SimpleServer_set_sort_handler, file);
1266         newXS("Net::Z3950::SimpleServer::set_search_handler", XS_Net__Z3950__SimpleServer_set_search_handler, file);
1267         newXS("Net::Z3950::SimpleServer::set_fetch_handler", XS_Net__Z3950__SimpleServer_set_fetch_handler, file);
1268         newXS("Net::Z3950::SimpleServer::set_present_handler", XS_Net__Z3950__SimpleServer_set_present_handler, file);
1269         newXS("Net::Z3950::SimpleServer::set_esrequest_handler", XS_Net__Z3950__SimpleServer_set_esrequest_handler, file);
1270         newXS("Net::Z3950::SimpleServer::set_delete_handler", XS_Net__Z3950__SimpleServer_set_delete_handler, file);
1271         newXS("Net::Z3950::SimpleServer::set_scan_handler", XS_Net__Z3950__SimpleServer_set_scan_handler, file);
1272         newXS("Net::Z3950::SimpleServer::start_server", XS_Net__Z3950__SimpleServer_start_server, file);
1273         newXS("Net::Z3950::SimpleServer::ScanSuccess", XS_Net__Z3950__SimpleServer_ScanSuccess, file);
1274         newXS("Net::Z3950::SimpleServer::ScanPartial", XS_Net__Z3950__SimpleServer_ScanPartial, file);
1275     XSRETURN_YES;
1276 }
1277