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