zlayer-yaz/zaccess.c

   1 /*
   2  * Copyright (c) 1995, the EUROPAGATE consortium (see below).
   3  *
   4  * The EUROPAGATE consortium members are:
   5  *
   6  *    University College Dublin
   7  *    Danmarks Teknologiske Videnscenter
   8  *    An Chomhairle Leabharlanna
   9  *    Consejo Superior de Investigaciones Cientificas
  10  *
  11  * Permission to use, copy, modify, distribute, and sell this software and
  12  * its documentation, in whole or in part, for any purpose, is hereby granted,
  13  * provided that:
  14  *
  15  * 1. This copyright and permission notice appear in all copies of the
  16  * software and its documentation. Notices of copyright or attribution
  17  * which appear at the beginning of any file must remain unchanged.
  18  *
  19  * 2. The names of EUROPAGATE or the project partners may not be used to
  20  * endorse or promote products derived from this software without specific
  21  * prior written permission.
  22  *
  23  * 3. Users of this software (implementors and gateway operators) agree to
  24  * inform the EUROPAGATE consortium of their use of the software. This
  25  * information will be used to evaluate the EUROPAGATE project and the
  26  * software, and to plan further developments. The consortium may use
  27  * the information in later publications.
  28  *
  29  * 4. Users of this software agree to make their best efforts, when
  30  * documenting their use of the software, to acknowledge the EUROPAGATE
  31  * consortium, and the role played by the software in their work.
  32  *
  33  * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
  34  * EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  35  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  36  * IN NO EVENT SHALL THE EUROPAGATE CONSORTIUM OR ITS MEMBERS BE LIABLE
  37  * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF
  38  * ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
  39  * OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND
  40  * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  41  * USE OR PERFORMANCE OF THIS SOFTWARE.
  42  *
  43  */
  44 /*
  45  * Europagate, 1995
  46  *
  47  * Z39.50 API for the Email gateway - YAZ version
  48  *
  49  * $Log: zaccess.c,v $
  50  * Revision 1.6  2001/02/26 14:32:36  adam
  51  * Updated for YAZ 1.7. HTML output tidy up. Added LOC target.
  52  *
  53  * Revision 1.5  1996/01/03 08:58:12  adam
  54  * Updated to use new version of Yaz (some names changed to avoid C++ conflict).
  55  *
  56  * Revision 1.4  1995/07/28  10:51:34  adam
  57  * Bug fix: multiple databases weren't specified correctly.
  58  *
  59  * Revision 1.3  1995/07/20  08:18:15  adam
  60  * Bug fix: Multiple databases are separated by commas and NOT by space.
  61  *
  62  * Revision 1.2  1995/07/05  11:08:33  adam
  63  * Bug fix in init request.
  64  *
  65  * Revision 1.1  1995/07/03  08:21:31  adam
  66  * Yaz layer moved to new sub directory. zaccess aligned with new
  67  * YAZ version (1.0b).
  68  *
  69  * Revision 1.10  1995/05/16  09:41:46  adam
  70  * LICENSE. Uses new versions of odr_{set,get}buf.
  71  *
  72  * Revision 1.9  1995/05/03  10:15:43  quinn
  73  * Fixed bug in the get_record loop - crashed when diagrec was received.
  74  *
  75  * Revision 1.8  1995/04/28  14:18:38  quinn
  76  * *** empty log message ***
  77  *
  78  * Revision 1.7  1995/04/21  16:29:32  quinn
  79  * Fixed bugs.
  80  *
  81  * Revision 1.6  1995/04/21  12:58:36  adam
  82  * Bug fix.
  83  *
  84  * Revision 1.5  1995/04/20  15:25:32  quinn
  85  * Asynch. API
  86  *
  87  * Revision 1.4  1995/04/19  16:02:28  adam
  88  * Record type hack.
  89  *
  90  * Revision 1.3  1995/04/19  12:55:15  quinn
  91  * Added auth.
  92  *
  93  * Revision 1.2  1995/04/19  09:24:02  quinn
  94  * Fixed bug in zass_open - variable initialized after use
  95  *
  96  * Revision 1.1  1995/04/17  11:26:53  quinn
  97  * Added YAZ version of zaccess
  98  *
  99  */
 100
 101 /*
 102  * Interface to the YAZ Z39.50 toolkit.
 103  */
 104
 105 #include <stdlib.h>
 106 #include <assert.h>
 107 #include <ctype.h>
 108
 109 #include <gw-log.h>
 110 #include <yaz/proto.h>
 111 #include <yaz/comstack.h>
 112 #include <yaz/tcpip.h>
 113 #ifdef USE_XTIMOSI
 114 #include <xmosi.h>
 115 #endif
 116 #include <yaz/oid.h>
 117
 118 #include <ccl.h>
 119 #include <zaccess.h>
 120
 121 struct zass    /* Z-assoc */
 122 {
 123     COMSTACK ass;              /* comstack association handle */
 124     ODR encode;
 125     ODR decode;
 126     int fd;                         /* low-level socket (for select only) */
 127     int nonblocking;
 128     int maxrecordsize;
 129     int preferredmessagesize;
 130     char *inbuf;
 131     int inbuflen;
 132 };
 133
 134 static Z_APDU *get_apdu(struct zass *z, int *complete)
 135 {
 136     int res;
 137     Z_APDU *ap;
 138
 139     if ((res = cs_get(z->ass, &z->inbuf, &z->inbuflen)) <= 0)
 140     {
 141         gw_log(GW_LOG_WARN, ZASS_TYPE, "cs_get failed");
 142         if (complete)
 143             *complete = 1;
 144         return 0;
 145     }
 146     else if (res == 1)
 147     {
 148         if (complete)
 149             *complete = 0;
 150         return 0;
 151     }
 152     odr_reset(z->decode);
 153     odr_setbuf(z->decode, z->inbuf, res, 0);
 154     if (!z_APDU(z->decode, &ap, 0, 0))
 155     {
 156         gw_log(GW_LOG_WARN, ZASS_TYPE, "decode: %s",
 157             odr_errlist[odr_geterror(z->decode)]);
 158         if (complete)
 159             *complete = 0;
 160         return 0;
 161     }
 162     if (complete)
 163         *complete = 1;
 164     return ap;
 165 }
 166
 167 static int send_apdu(struct zass *z, Z_APDU *a)
 168 {
 169     char *buf;
 170     int len;
 171
 172     if (!z_APDU(z->encode, &a, 0, 0))
 173     {
 174         gw_log(GW_LOG_FATAL, ZASS_TYPE, "encoding initreq");
 175         return -1;
 176     }
 177     buf = odr_getbuf(z->encode, &len, NULL);
 178     if (cs_put(z->ass, buf, len) < 0)
 179     {
 180         gw_log(GW_LOG_FATAL, ZASS_TYPE, "cs_put");
 181         return -1;
 182     }
 183     odr_reset(z->encode);  /* release odr_allocated structures */
 184     return 0;
 185 }
 186
 187 static int send_initreq(struct zass *p, char *auth)
 188 {
 189     Z_APDU *apdu;
 190     Z_InitRequest *req;
 191     char name[512];
 192     Z_IdAuthentication idauth;
 193
 194     apdu = zget_APDU (p->encode, Z_APDU_initRequest);
 195     req = apdu->u.initRequest;
 196     req->preferredMessageSize = &p->preferredmessagesize;
 197     req->maximumRecordSize = &p->maxrecordsize;
 198
 199     ODR_MASK_SET(req->options, Z_Options_search);
 200     ODR_MASK_SET(req->options, Z_Options_present);
 201     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 202
 203     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 204     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 205
 206     if (auth)
 207     {
 208         req->idAuthentication = &idauth;
 209         idauth.which = Z_IdAuthentication_open;
 210         idauth.u.open = auth;
 211     }
 212     else
 213         req->idAuthentication = 0;
 214     sprintf(name, "%s (YAZ protocol layer)", ZASS_NAME);
 215     req->implementationName = name;
 216     req->implementationVersion = ZASS_VERSION;
 217     if (send_apdu(p, apdu) < 0)
 218         return -1;
 219     return 0;
 220 }
 221
 222 int zass_fileno(ZASS a)
 223 {
 224     return a->fd;
 225 }
 226
 227 int zass_openresult(ZASS p, int *complete)
 228 {
 229     Z_APDU *ap;
 230     Z_InitResponse *res;
 231
 232     if (!(ap = get_apdu(p, complete)))
 233         return -1;
 234     if (ap->which != Z_APDU_initResponse)
 235     {
 236         gw_log(GW_LOG_WARN, ZASS_TYPE, "bad APDU");
 237         return -1;
 238     }
 239     res = ap->u.initResponse;
 240     if (!*res->result)
 241     {
 242         gw_log(GW_LOG_WARN, ZASS_TYPE, "Negative result on initres");
 243         return -1;
 244     }
 245     p->preferredmessagesize = *res->preferredMessageSize;
 246     p->maxrecordsize = *res->maximumRecordSize;
 247     if (res->implementationId)
 248         gw_log(GW_LOG_NOTICE, ZASS_TYPE, "imp. ID  : %s",
 249             res->implementationId);
 250     if (res->implementationName)
 251         gw_log(GW_LOG_NOTICE, ZASS_TYPE, "imp. ID  : %s",
 252             res->implementationName);
 253     if (res->implementationVersion)
 254         gw_log(GW_LOG_NOTICE, ZASS_TYPE, "imp. ID  : %s",
 255             res->implementationVersion);
 256     gw_log(ZASS_DEBUG, ZASS_TYPE, "Initialized ok");
 257     return 0;
 258 }
 259
 260 ZASS zass_open(char *host, int port, int *complete, char *auth)
 261 {
 262     struct zass *p;
 263     char addstr[512];
 264     void *address;
 265
 266     if (!(p = malloc(sizeof(*p))))
 267     {
 268         gw_log(GW_LOG_FATAL|GW_LOG_ERRNO, ZASS_TYPE, "malloc");
 269         return 0;
 270     }
 271     if (complete)
 272     {
 273         *complete = 1;
 274         p->nonblocking = 1;
 275     }
 276     else
 277         p->nonblocking = 0;
 278     if (!(p->encode = odr_createmem(ODR_ENCODE)) ||
 279         !(p->decode = odr_createmem(ODR_DECODE)))
 280     {
 281         gw_log(GW_LOG_FATAL|GW_LOG_ERRNO, ZASS_TYPE, "odr_createmem");
 282         return 0;
 283     }
 284     p->maxrecordsize = ZASS_MAXRECORDSIZE;
 285     p->preferredmessagesize = ZASS_PREFERREDMESSAGESIZE;
 286     if (!(p->ass = cs_create(tcpip_type, 1, CS_Z3950)))
 287     {
 288         gw_log(GW_LOG_FATAL|GW_LOG_ERRNO, ZASS_TYPE, "cs_create");
 289         return 0;
 290     }
 291     p->inbuf = 0;
 292     p->inbuflen = 0;
 293     sprintf(addstr, "%s:%d", host, port);
 294     if (!(address = tcpip_strtoaddr(addstr)))
 295     {
 296         gw_log(GW_LOG_FATAL, ZASS_TYPE, "failed to resolve %s", addstr);
 297         return 0;
 298     }
 299     p->fd = cs_fileno(p->ass);
 300     gw_log(ZASS_DEBUG, ZASS_TYPE, "Connecting to %s", addstr);
 301     if (cs_connect(p->ass, address) < 0)
 302     {
 303         gw_log(GW_LOG_FATAL, ZASS_TYPE, "Failed to connect to %s", addstr);
 304         return 0;
 305     }
 306     gw_log(ZASS_DEBUG, ZASS_TYPE, "connected ok... initializing");
 307     if (send_initreq(p, auth) < 0)
 308     {
 309         gw_log(GW_LOG_FATAL, ZASS_TYPE, "Failed to send init");
 310         return 0;
 311     }
 312     if (p->nonblocking)
 313     {
 314         *complete = 0;
 315         return p;
 316     }
 317     if (zass_openresult(p, complete) < 0)
 318         return 0;
 319     return p; /* all done */
 320 }
 321
 322 /*
 323  * Convert the egate (ccl2rpn) version of RPN to YAZ RPN.
 324  */
 325 static Z_RPNStructure *rpn2rpn(ODR o, struct ccl_rpn_node *q)
 326 {
 327     Z_RPNStructure *r = odr_malloc(o, sizeof(*r));
 328     Z_AttributesPlusTerm *t;
 329     struct ccl_rpn_attr *i;
 330     int len;
 331     static int op[] = { Z_Operator_and, Z_Operator_or, Z_Operator_and_not };
 332     Z_AttributeElement **elements;
 333     int num_attributes = 0;
 334
 335     switch (q->kind)
 336     {
 337     case CCL_RPN_TERM:
 338         r->which = Z_RPNStructure_simple;
 339         r->u.simple = odr_malloc(o, sizeof(Z_Operand));
 340         r->u.simple->which = Z_Operand_APT;
 341         r->u.simple->u.attributesPlusTerm = t = odr_malloc(o, sizeof(*t));
 342         t->term = odr_malloc(o, sizeof(Z_Term));
 343         t->term->which = Z_Term_general;
 344         t->term->u.general = odr_malloc(o, sizeof(Odr_oct));
 345         t->term->u.general->len = t->term->u.general->size =
 346             strlen(q->u.t.term);
 347         t->term->u.general->buf = odr_malloc(o, t->term->u.general->size);
 348         memcpy(t->term->u.general->buf, q->u.t.term,
 349                t->term->u.general->len);
 350         elements = odr_malloc(o, sizeof(Z_AttributeElement*) * 100);
 351 #ifdef ASN_COMPILED
 352         t->attributes = (Z_AttributeList *)
 353             odr_malloc (o, sizeof(*t->attributes));
 354         t->attributes->attributes = elements;
 355 #else
 356         t->attributeList = elements;
 357 #endif
 358         for (i = q->u.t.attr_list; i && num_attributes < 100; i = i->next)
 359         {
 360             Z_AttributeElement *a;
 361
 362             elements[num_attributes++] = a =
 363                 odr_malloc(o, sizeof(*a));
 364             a->attributeType = odr_malloc(o, sizeof(int));
 365             *a->attributeType = i->type;
 366             a->attributeSet = 0;
 367             a->which = Z_AttributeValue_numeric;
 368             a->value.numeric = odr_malloc(o, sizeof(*a->value.numeric));
 369             *a->value.numeric = i->value;
 370         }
 371 #ifdef ASN_COMPILED
 372         t->attributes->num_attributes = num_attributes;
 373 #else
 374         t->num_attributes = num_attributes;
 375 #endif
 376         return r;
 377     case CCL_RPN_SET:
 378         r->which = Z_RPNStructure_simple;
 379         r->u.simple = odr_malloc(o, sizeof(Z_Operand));
 380         r->u.simple->which = Z_Operand_resultSetId;
 381         r->u.simple->u.resultSetId = odr_malloc(o, len =
 382                                                 strlen(q->u.setname) + 1);
 383         memcpy(r->u.simple->u.resultSetId, q->u.setname, len);
 384         return r;
 385     case CCL_RPN_AND: case CCL_RPN_OR: case CCL_RPN_NOT:
 386         r->which = Z_RPNStructure_complex;
 387         r->u.complex = odr_malloc(o, sizeof(Z_Complex));
 388         if (!(r->u.complex->s1 = rpn2rpn(o, q->u.p[0])) ||
 389             !(r->u.complex->s2 = rpn2rpn(o, q->u.p[1])))
 390             return 0;
 391         r->u.complex->roperator = odr_malloc(o, sizeof(Z_Operator));
 392         r->u.complex->roperator->which = op[q->kind];
 393         r->u.complex->roperator->u.op_and = "";
 394         return r;
 395     default:
 396         gw_log(GW_LOG_FATAL, ZASS_TYPE, "Bad operator in RPN");
 397         return 0;
 398     }
 399 }
 400
 401 const struct zass_searchent *zass_searchresult(ZASS a, int *complete)
 402 {
 403     static struct zass_searchent r;
 404     Z_APDU *apdu;
 405     Z_SearchResponse *res;
 406
 407     if (!(apdu = get_apdu(a, complete)))
 408         return 0;
 409     if (apdu->which != Z_APDU_searchResponse)
 410     {
 411         gw_log(GW_LOG_FATAL, ZASS_TYPE, "Expected searchresponse, got #%d",
 412             apdu->which);
 413         return 0;
 414     }
 415     res = apdu->u.searchResponse;
 416     r.status = *res->searchStatus;
 417     r.num = *res->resultCount;
 418     r.status = res->resultSetStatus ? *res->resultSetStatus : 0;
 419     r.errcode = -1;
 420     *r.errstring = '\0';
 421     if (res->records)
 422     {
 423         if (res->records->which != Z_Records_NSD)
 424             gw_log(GW_LOG_WARN, ZASS_TYPE, "Unexpected record types in SchR");
 425         else
 426         {
 427             oident *id;
 428 #ifdef ASN_COMPILED
 429             Z_DiagRec dr_info;
 430             Z_DiagRec *dr = &dr_info;
 431             dr_info.which = Z_DiagRec_defaultFormat;
 432             dr_info.u.defaultFormat = res->records->u.nonSurrogateDiagnostic;
 433 #else
 434             Z_DiagRec *dr = res->records->u.nonSurrogateDiagnostic;
 435 #endif
 436             if (dr->which != Z_DiagRec_defaultFormat ||
 437                 !(id = oid_getentbyoid
 438                        (dr->u.defaultFormat->diagnosticSetId)) ||
 439                 id->oclass != CLASS_DIAGSET ||
 440                 id->value != VAL_BIB1)
 441                     gw_log(GW_LOG_WARN, ZASS_TYPE,
 442                         "Missing or unknown diagset - ignoring error!");
 443             else
 444             {
 445                 r.errcode = *dr->u.defaultFormat->condition;
 446 #ifdef ASN_COMPILED
 447                 switch (dr->u.defaultFormat->which)
 448                 {
 449                 case Z_DefaultDiagFormat_v2Addinfo:
 450                     strncpy(r.errstring, dr->u.defaultFormat->u.v2Addinfo,
 451                             512);
 452                     r.errstring[511] = '\0';
 453                     break;
 454                 case Z_DefaultDiagFormat_v3Addinfo:
 455                     strncpy(r.errstring, dr->u.defaultFormat->u.v3Addinfo,
 456                             512);
 457                     r.errstring[511] = '\0';
 458                     break;
 459                 }
 460 #else
 461                 if (dr->u.defaultFormat->addinfo)
 462                 {
 463                     strncpy(r.errstring, dr->u.defaultFormat->addinfo, 512);
 464                     r.errstring[511] = '\0';
 465                 }
 466 #endif
 467             }
 468         }
 469     }
 470     return &r;
 471 }
 472
 473 const struct zass_searchent *zass_search(ZASS a, struct ccl_rpn_node *query,
 474     char *resname, char *databases, int *complete)
 475 {
 476     Z_Query q;
 477     Z_RPNQuery rpnq;
 478     Z_APDU *apdu;
 479     Z_SearchRequest *req;
 480     oident bib1;
 481     int smallSetUpperBound = 0;
 482     int largeSetLowerBound = 1;
 483     int mediumSetPresentNumber = 0;
 484     int replaceIndicator = 1;
 485     char *datab[100];
 486
 487     apdu = zget_APDU (a->encode, Z_APDU_searchRequest);
 488     req = apdu->u.searchRequest;
 489
 490     req->smallSetUpperBound = &smallSetUpperBound;
 491     req->largeSetLowerBound = &largeSetLowerBound;
 492     req->mediumSetPresentNumber = &mediumSetPresentNumber;
 493     req->replaceIndicator = &replaceIndicator;
 494     req->resultSetName = resname;
 495     req->num_databaseNames = 0;
 496     req->databaseNames = datab;
 497     while (*databases && req->num_databaseNames < 100)
 498     {
 499         char *p = databases;
 500         int more;
 501
 502         while (*p && !isspace(*p) && *p != ',')
 503             p++;
 504         if (*p)
 505             more = 1;
 506         else
 507             more = 0;
 508         if (p - databases)
 509         {
 510             req->databaseNames[req->num_databaseNames] = odr_malloc(a->encode,
 511                 (p - databases) + 1);
 512             memcpy(req->databaseNames[req->num_databaseNames], databases,
 513                    p-databases);
 514             req->databaseNames[req->num_databaseNames++][p-databases] = '\0';
 515         }
 516         databases = p + more;
 517     }
 518     req->query = &q;
 519     q.which = Z_Query_type_1;
 520     q.u.type_1 = &rpnq;
 521     bib1.proto = PROTO_Z3950;
 522     bib1.oclass = CLASS_ATTSET;
 523     bib1.value = VAL_BIB1;
 524     rpnq.attributeSetId = oid_getoidbyent(&bib1);
 525
 526     if (complete)
 527         *complete = 1;
 528     if (!(rpnq.RPNStructure = rpn2rpn(a->encode, query)))
 529         return 0;
 530     if (send_apdu(a, apdu) < 0)
 531         return 0;
 532     if (complete)
 533     {
 534         *complete = 0;
 535         return 0;
 536     }
 537     else
 538         return zass_searchresult(a, complete);
 539 }
 540
 541 /*
 542  * Triple indirection - that's kinda heavy. We'll fix it later.
 543  * There are worse things around, though. Like ZDist.
 544  */
 545 void get_diagrecs(zass_record ***p, Z_DiagRec **r, int num)
 546 {
 547     **p = malloc(sizeof(***p));
 548     (**p)->next = 0;
 549
 550     (**p)->errstring[0] = '\0';
 551     if ((*r)->which == Z_DiagRec_defaultFormat)
 552     {
 553         (**p)->errcode = *(*r)->u.defaultFormat->condition;
 554 #ifdef ASN_COMPILED
 555         switch ((*r)->u.defaultFormat->which)
 556         {
 557         case Z_DefaultDiagFormat_v2Addinfo:
 558             strncpy((**p)->errstring, (*r)->u.defaultFormat->u.v2Addinfo, 200);
 559             (**p)->errstring[200] = 0;
 560             break;
 561         case Z_DefaultDiagFormat_v3Addinfo:
 562             strncpy((**p)->errstring, (*r)->u.defaultFormat->u.v3Addinfo, 200);
 563             (**p)->errstring[200] = 0;
 564             break;
 565         }
 566 #else
 567         if ((*r)->u.defaultFormat->addinfo)
 568         {
 569             strncpy((**p)->errstring, (*r)->u.defaultFormat->addinfo, 200);
 570             (**p)->errstring[200] = 0;
 571         }
 572 #endif
 573     }
 574     else
 575         (**p)->errcode = -1;
 576     (**p)->which = ZASS_REC_DIAG;
 577     *p = &(**p)->next;
 578 }
 579
 580 void get_responserecords(zass_record ***p, Z_NamePlusRecordList *recs)
 581 {
 582     int i;
 583
 584     for (i = 0; i < recs->num_records; i++)
 585     {
 586         Z_NamePlusRecord *record;
 587
 588         record = recs->records[i];
 589         if (record->which == Z_NamePlusRecord_surrogateDiagnostic)
 590             get_diagrecs(p, &record->u.surrogateDiagnostic, 1);
 591         else
 592         {
 593             Z_DatabaseRecord *r = record->u.databaseRecord;
 594             oident *recform;
 595
 596             **p = malloc(sizeof(***p));
 597             (**p)->next = 0;
 598
 599             if (!(recform = oid_getentbyoid(r->direct_reference)) ||
 600                  recform->oclass != CLASS_RECSYN)
 601             {
 602                 gw_log(GW_LOG_WARN, ZASS_TYPE, "Unknown or bad record syntax");
 603                 (**p)->which = ZASS_REC_UNKNOWN;
 604             }
 605             else
 606                 switch (recform->value)
 607                 {
 608                 case VAL_USMARC: (**p)->which = ZASS_REC_USMARC; break;
 609                 case VAL_DANMARC: (**p)->which = ZASS_REC_DANMARC; break;
 610                 default:
 611                     gw_log(GW_LOG_WARN, ZASS_TYPE, "Unknown recsyn");
 612                     (**p)->which = ZASS_REC_UNKNOWN;
 613                 }
 614             if (r->which != ODR_EXTERNAL_octet)
 615             {
 616                 gw_log(GW_LOG_WARN, ZASS_TYPE, "Record wasn't octet-aligned");
 617                 (**p)->record = 0;
 618             }
 619             else
 620             {
 621                 if (!((**p)->record = malloc(r->u.octet_aligned->len + 1)))
 622                 {
 623                     gw_log(GW_LOG_FATAL, ZASS_TYPE, "malloc");
 624                     return;
 625                 }
 626                 memcpy((**p)->record, r->u.octet_aligned->buf,
 627                     r->u.octet_aligned->len);
 628                 (**p)->record[r->u.octet_aligned->len] = '\0';
 629                 gw_log(ZASS_DEBUG, ZASS_TYPE, "Got a record of %d bytes",
 630                     r->u.octet_aligned->len);
 631             }
 632             (*p) = &(**p)->next;
 633         }
 634     }
 635 }
 636
 637 static void zass_records_free(zass_record *p)
 638 {
 639 }
 640
 641 static int send_present(ZASS a, char *name, int start, int num,
 642     enum oid_value form)
 643 {
 644     Z_APDU *apdu;
 645     Z_PresentRequest *req;
 646 #if 1
 647     oident recsyn;
 648 #endif
 649
 650     apdu = zget_APDU (a->encode, Z_APDU_presentRequest);
 651     req = apdu->u.presentRequest;
 652
 653     req->resultSetId = name;
 654     req->resultSetStartPoint = &start;
 655     req->numberOfRecordsRequested = &num;
 656 #if 1
 657     recsyn.proto = PROTO_Z3950;
 658     recsyn.oclass = CLASS_RECSYN;
 659     recsyn.value = form;
 660     req->preferredRecordSyntax = oid_getoidbyent(&recsyn);
 661 #else
 662     req->preferredRecordSyntax = 0;
 663 #endif
 664     return send_apdu(a, apdu);
 665 }
 666
 667 /*
 668  * Note that 1== first record.
 669  * TODO: make this baby operate in nonblocking mode, too.
 670  */
 671 const struct zass_presentent *zass_present(ZASS a, char *resname, int start,
 672     int num, int *complete)
 673 {
 674     static struct zass_presentent r;
 675     zass_record **rec = &r.records;
 676
 677     if (complete)
 678         *complete = 1;
 679     r.num = 0;
 680     if (r.records)
 681     {
 682         zass_records_free(r.records);
 683         r.records = 0;
 684     }
 685     do
 686     {
 687         Z_APDU *apdu;
 688         Z_PresentResponse *res;
 689 #ifdef ASN_COMPILED
 690         Z_DiagRec dr, *dr_p = &dr;
 691 #endif
 692
 693         gw_log(ZASS_DEBUG, ZASS_TYPE,
 694             "Fetching %d records from # %d", num - r.num, start);
 695         if (send_present(a, resname, start, num - r.num, VAL_USMARC) < 0)
 696             return 0;
 697         if (!(apdu = get_apdu(a, complete)))
 698         {
 699             if (complete)
 700                 *complete = 1;
 701             return 0;
 702         }
 703         if (apdu->which != Z_APDU_presentResponse)
 704         {
 705             gw_log(GW_LOG_FATAL, ZASS_TYPE, "Expected presentresponse, got #%d",
 706                 apdu->which);
 707             return 0;
 708         }
 709         res = apdu->u.presentResponse;
 710         r.presentstatus = *res->presentStatus;
 711         r.num += *res->numberOfRecordsReturned;
 712         if (*res->numberOfRecordsReturned == 0)
 713         {
 714             gw_log(GW_LOG_WARN, ZASS_TYPE, "Got 0 records from target");
 715             return 0;
 716         }
 717         r.nextpos = *res->nextResultSetPosition;
 718         start = r.nextpos;
 719         switch (res->records->which)
 720         {
 721         case Z_Records_DBOSD:
 722             get_responserecords(&rec,
 723                                 res->records->u.databaseOrSurDiagnostics);
 724             break;
 725         case Z_Records_NSD:
 726 #ifdef ASN_COMPILED
 727             dr.which = Z_DiagRec_defaultFormat;
 728             dr.u.defaultFormat = res->records->u.nonSurrogateDiagnostic;
 729             get_diagrecs(&rec, &dr_p, 1);
 730 #else
 731             get_diagrecs(&rec, &res->records->u.nonSurrogateDiagnostic, 1);
 732 #endif
 733             break;
 734         default:
 735             gw_log(GW_LOG_WARN, ZASS_TYPE, "Bad tag in response rec.");
 736             return 0;
 737         }
 738     }
 739     while (num - r.num && start);
 740     return &r;
 741 }
 742
 743 const struct zass_presentent *zass_presentresult(ZASS a, int *complete)
 744 {
 745     *complete = 1;
 746     return 0;
 747 }