--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP version 4.0 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.02 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available at through the world-wide-web at |
+ | http://www.php.net/license/2_02.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: Adam Dickmeiss <adam@indexdata.dk> |
+ +----------------------------------------------------------------------+
+ */
+
+/* $Id$ */
+
+#include "php.h"
+
+#if HAVE_YAZ
+#include "php_yaz.h"
+
+#include <yaz/proto.h>
+#include <yaz/tcpip.h>
+#include <yaz/pquery.h>
+#include <yaz/diagbib1.h>
+#include <yaz/otherinfo.h>
+#include <yaz/marcdisp.h>
+#include <yaz/yaz-util.h>
+
+#define MAX_ASSOC 100
+
+#define PHP_YAZ_DEBUG 1
+
+typedef struct Yaz_ResultSetInfo *Yaz_ResultSet;
+typedef struct Yaz_AssociationInfo *Yaz_Association;
+typedef struct Yaz_RecordCacheInfo *Yaz_RecordCache;
+
+struct Yaz_RecordCacheInfo {
+ Z_NamePlusRecordList recordList;
+ Yaz_RecordCache next;
+};
+
+struct Yaz_ResultSetInfo {
+ Z_Query *query;
+ Z_ReferenceId *referenceId;
+ ODR odr;
+ int resultCount;
+ Yaz_ResultSet next;
+ Z_NamePlusRecordList *recordList;
+};
+
+#define PHP_YAZ_SELECT_READ 1
+#define PHP_YAZ_SELECT_WRITE 2
+#define PHP_YAZ_STATE_CONNECTING 1
+#define PHP_YAZ_STATE_ESTABLISHED 2
+#define PHP_YAZ_STATE_CLOSED 3
+
+#define PHP_YAZ_ERROR_CONNECTION_LOST (-1)
+#define PHP_YAZ_ERROR_DECODE (-2)
+#define PHP_YAZ_ERROR_ENCODE (-3)
+#define PHP_YAZ_ERROR_CONNECT (-4)
+#define PHP_YAZ_ERROR_INIT (-5)
+#define PHP_YAZ_ERROR_TIMEOUT (-6)
+
+struct Yaz_AssociationInfo {
+ char *host_port;
+ int num_databaseNames;
+ char **databaseNames;
+ COMSTACK cs;
+ char *cookie;
+ char *proxy;
+ char *auth_open;
+ char *user;
+ char *group;
+ char *pass;
+ int error;
+ char *addinfo;
+ Yaz_ResultSet resultSets;
+ int order;
+ int state;
+ int mask_select;
+ int reconnect_flag;
+ ODR odr_in;
+ ODR odr_out;
+ char *buf_out;
+ int len_out;
+ char *buf_in;
+ int len_in;
+ int (*action)(Yaz_Association t);
+ int resultSetStartPoint;
+ int numberOfRecordsRequested;
+ char *elementSetNames;
+ char *preferredRecordSyntax;
+};
+
+static Yaz_Association yaz_association_mk ()
+{
+ Yaz_Association p = xmalloc (sizeof(*p));
+ p->host_port = 0;
+ p->num_databaseNames = 0;
+ p->databaseNames = 0;
+ p->cs = 0;
+ p->cookie = 0;
+ p->proxy = 0;
+ p->auth_open = 0;
+ p->user = 0;
+ p->group = 0;
+ p->pass = 0;
+ p->error = 0;
+ p->addinfo = 0;
+ p->resultSets = 0;
+ p->order = 0;
+ p->state = PHP_YAZ_STATE_CLOSED;
+ p->mask_select = 0;
+ p->reconnect_flag = 0;
+ p->odr_in = odr_createmem (ODR_DECODE);
+ p->odr_out = odr_createmem (ODR_ENCODE);
+ p->buf_out = 0;
+ p->len_out = 0;
+ p->buf_in = 0;
+ p->len_in = 0;
+ p->action = 0;
+ p->resultSetStartPoint = 1;
+ p->numberOfRecordsRequested = 10;
+ p->elementSetNames = 0;
+ p->preferredRecordSyntax = 0;
+ return p;
+}
+
+static void yaz_association_destroy (Yaz_Association p)
+{
+ int i;
+ if (!p)
+ return ;
+ xfree (p->host_port);
+ for (i = 0; i<p->num_databaseNames; i++)
+ xfree (p->databaseNames[i]);
+ xfree (p->databaseNames);
+ if (p->cs)
+ cs_close (p->cs);
+ xfree (p->cookie);
+ xfree (p->proxy);
+ xfree (p->auth_open);
+ xfree (p->user);
+ xfree (p->group);
+ xfree (p->pass);
+ xfree (p->addinfo);
+ odr_destroy (p->odr_in);
+ odr_destroy (p->odr_out);
+ /* buf_out */
+ /* buf_in */
+ /* action */
+ xfree (p->elementSetNames);
+ xfree (p->preferredRecordSyntax);
+}
+
+static Yaz_ResultSet yaz_resultset_mk()
+{
+ ODR odr = odr_createmem (ODR_ENCODE);
+ Yaz_ResultSet p = odr_malloc (odr, sizeof(*p));
+
+ p->query = 0;
+ p->referenceId = 0;
+ p->odr = odr;
+ p->resultCount = 0;
+ p->next = 0;
+ p->recordList = 0;
+ return p;
+}
+
+static void yaz_resultset_destroy (Yaz_ResultSet p)
+{
+ if (!p)
+ return;
+ if (p->odr)
+ odr_destroy (p->odr);
+}
+
+static Yaz_Association *shared_associations;
+static int order_associations;
+
+/*
+ when id = 0, it means all targes...
+ id = yaz_connect(zurl, user,group, pass);
+ yaz_set_db(id, db)
+ yaz_error(id)
+ yaz_errno(id)
+ yaz_addinfo(id)
+
+ yaz_wait()
+ yaz_range(id, from, to, syntax, elementset)
+ yaz_search(id, type, query)
+ yaz_hits(id)
+ yaz_record(id, pos)
+
+ yaz_scan(id)
+ yaz_scan_point(id, scanterm, before, after)
+ yaz_scan_result(id, pos)
+
+ yaz_close(id)
+*/
+
+function_entry yaz_functions [] = {
+ PHP_FE(yaz_connect, NULL)
+ PHP_FE(yaz_close, NULL)
+ PHP_FE(yaz_search, NULL)
+ PHP_FE(yaz_wait, NULL)
+ PHP_FE(yaz_errno, NULL)
+ PHP_FE(yaz_error, NULL)
+ PHP_FE(yaz_addinfo, NULL)
+ PHP_FE(yaz_hits, NULL)
+ PHP_FE(yaz_record, NULL)
+ PHP_FE(yaz_syntax, NULL)
+ PHP_FE(yaz_element, NULL)
+ PHP_FE(yaz_range, NULL)
+ {NULL, NULL, NULL}
+};
+
+static Yaz_Association get_assoc (pval **id)
+{
+ int i;
+ convert_to_long_ex(id);
+ i = (*id)->value.lval;
+
+ if (i < 1 || i > MAX_ASSOC)
+ return 0;
+ return shared_associations[i-1];
+}
+
+
+static void do_close (Yaz_Association p)
+{
+ p->mask_select = 0;
+ p->state = PHP_YAZ_STATE_CLOSED;
+ if (p->cs)
+ {
+ cs_close (p->cs);
+ p->cs = 0;
+ }
+}
+
+static void do_connect (Yaz_Association p)
+{
+ void *addr;
+
+ p->reconnect_flag = 0;
+ p->cs = cs_create (tcpip_type, 0, PROTO_Z3950);
+ addr = tcpip_strtoaddr (p->host_port);
+ if (!addr)
+ {
+ do_close(p);
+ p->error = PHP_YAZ_ERROR_CONNECT;
+ return;
+ }
+ cs_connect (p->cs, addr);
+ p->state = PHP_YAZ_STATE_CONNECTING;
+ p->mask_select = PHP_YAZ_SELECT_READ | PHP_YAZ_SELECT_WRITE;
+}
+
+static void response_diag (Yaz_Association t, Z_DiagRec *p)
+{
+ Z_DefaultDiagFormat *r;
+ char *addinfo = 0;
+
+ xfree (t->addinfo);
+ t->addinfo = 0;
+ if (p->which != Z_DiagRec_defaultFormat)
+ {
+ t->error = PHP_YAZ_ERROR_DECODE;
+ return;
+ }
+ r = p->u.defaultFormat;
+#ifdef ASN_COMPILED
+ switch (r->which)
+ {
+ case Z_DefaultDiagFormat_v2Addinfo:
+ addinfo = r->u.v2Addinfo;
+ break;
+ case Z_DefaultDiagFormat_v3Addinfo:
+ addinfo = r->u.v3Addinfo;
+ break;
+ }
+#else
+ addinfo = r->addinfo;
+#endif
+ if (addinfo)
+ t->addinfo = xstrdup (addinfo);
+ t->error = *r->condition;
+}
+
+static int send_present (Yaz_Association t);
+
+void handle_records (Yaz_Association t, Z_Records *sr)
+{
+ if (sr && sr->which == Z_Records_NSD)
+ {
+#ifdef ASN_COMPILED
+ Z_DiagRec dr, *dr_p = &dr;
+ dr.which = Z_DiagRec_defaultFormat;
+ dr.u.defaultFormat = sr->u.nonSurrogateDiagnostic;
+
+ response_diag (t, dr_p);
+#else
+ response_diag (t, sr->u.nonSurrogateDiagnostic);
+#endif
+ }
+ else if (sr && sr->which == Z_Records_multipleNSD)
+ {
+ if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
+ response_diag(t, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
+ else
+ t->error = PHP_YAZ_ERROR_DECODE;
+ }
+ else
+ {
+ if (t->numberOfRecordsRequested > 0 && !t->resultSets->recordList)
+ {
+ int i;
+
+ t->resultSets->recordList =
+ odr_malloc (t->resultSets->odr,
+ sizeof(*t->resultSets->recordList));
+ t->resultSets->recordList->records =
+ odr_malloc (t->resultSets->odr, t->numberOfRecordsRequested
+ * sizeof(*t->resultSets->recordList->records));
+ for (i = 0; i < t->numberOfRecordsRequested; i++)
+ t->resultSets->recordList->records[i] = 0;
+ if (t->numberOfRecordsRequested + t->resultSetStartPoint-1 >
+ t->resultSets->resultCount)
+ t->numberOfRecordsRequested = t->resultSets->resultCount -
+ t->resultSetStartPoint + 1;
+ t->resultSets->recordList->num_records =
+ t->numberOfRecordsRequested;
+ }
+ if (sr && sr->which == Z_Records_DBOSD)
+ {
+ int j, i;
+ Z_NamePlusRecordList *p =
+ sr->u.databaseOrSurDiagnostics;
+ for (j = 0; j < t->resultSets->recordList->num_records; j++)
+ if (!t->resultSets->recordList->records[j])
+ break;
+ for (i = 0; i<p->num_records; i++)
+ t->resultSets->recordList->records[i+j] = p->records[i];
+ /* transfer our response to search_nmem .. we need it later */
+ nmem_transfer (t->resultSets->odr->mem, odr_extract_mem (t->odr_in));
+ }
+ }
+}
+
+static void search_response (Yaz_Association t, Z_SearchResponse *sr)
+{
+ t->resultSets->resultCount = *sr->resultCount;
+ handle_records (t, sr->records);
+}
+
+static void present_response (Yaz_Association t, Z_PresentResponse *pr)
+{
+ handle_records (t, pr->records);
+}
+
+static void handle_apdu (Yaz_Association t, Z_APDU *apdu)
+{
+ Z_InitResponse *initrs;
+
+ t->mask_select = 0;
+
+ switch(apdu->which)
+ {
+ case Z_APDU_initResponse:
+ initrs = apdu->u.initResponse;
+ if (!*initrs->result)
+ {
+ t->error = PHP_YAZ_ERROR_INIT;
+ }
+ else
+ {
+ char *cookie =
+ yaz_oi_get_string_oidval (&apdu->u.initResponse->otherInfo,
+ VAL_COOKIE, 1, 0);
+ if (cookie)
+ {
+ xfree(t->cookie);
+ t->cookie = xstrdup(cookie);
+ }
+ (*t->action) (t);
+ }
+ break;
+ case Z_APDU_searchResponse:
+ search_response (t, apdu->u.searchResponse);
+ send_present (t);
+ break;
+ case Z_APDU_presentResponse:
+ present_response (t, apdu->u.presentResponse);
+ send_present (t);
+ break;
+#if 0
+ case Z_APDU_scanResponse:
+ zlog (req, t->name, " scan response");
+ scanResponse (req, t, apdu->u.scanResponse);
+ break;
+#endif
+#if USE_ES
+ case Z_APDU_extendedServicesResponse:
+ zlog (req, t->name, " ES response");
+ esResponse (req, t, apdu->u.extendedServicesResponse);
+ break;
+#endif
+ case Z_APDU_close:
+ do_close(t);
+ if (t->reconnect_flag)
+ do_connect (t);
+ else
+ t->error = PHP_YAZ_ERROR_CONNECTION_LOST;
+ break;
+ default:
+ do_close (t);
+ t->error = PHP_YAZ_ERROR_DECODE;
+ break;
+ }
+}
+
+static int do_read (Yaz_Association t)
+{
+ int r;
+ Z_APDU *apdu;
+
+ r = cs_get (t->cs, &t->buf_in, &t->len_in);
+ if (r == 1)
+ return 0;
+ if (r <= 0)
+ {
+ do_close (t);
+ if (t->reconnect_flag)
+ {
+ do_connect (t);
+ }
+ else
+ {
+ do_close (t);
+ t->error = PHP_YAZ_ERROR_CONNECTION_LOST;
+ }
+ }
+ else
+ {
+ odr_reset (t->odr_in);
+ odr_setbuf (t->odr_in, t->buf_in, r, 0);
+ if (!z_APDU (t->odr_in, &apdu, 0, 0))
+ {
+ do_close (t);
+ t->error = PHP_YAZ_ERROR_DECODE;
+ }
+ else
+ {
+ /* apdu_log(req, t->odr_print, apdu); */
+ handle_apdu (t, apdu);
+ }
+ }
+ return 1;
+}
+
+static int do_write (Yaz_Association t)
+{
+ int r;
+
+ if ((r=cs_put (t->cs, t->buf_out, t->len_out)) < 0)
+ {
+ if (t->reconnect_flag)
+ {
+ do_close (t);
+ do_connect (t);
+ }
+ else
+ {
+ if (t->state == PHP_YAZ_STATE_CONNECTING)
+ t->error = PHP_YAZ_ERROR_CONNECT;
+ else
+ t->error = PHP_YAZ_ERROR_CONNECTION_LOST;
+ do_close (t);
+ return 1;
+ }
+ }
+ else if (r == 1)
+ {
+ t->state = PHP_YAZ_STATE_ESTABLISHED;
+ t->mask_select = PHP_YAZ_SELECT_READ|PHP_YAZ_SELECT_WRITE;
+ }
+ else
+ {
+ t->state = PHP_YAZ_STATE_ESTABLISHED;
+ t->mask_select = PHP_YAZ_SELECT_READ;
+ }
+ return 0;
+}
+
+
+static int send_APDU (Yaz_Association t, Z_APDU *a)
+{
+ if (t->cookie)
+ {
+ Z_OtherInformation **oi;
+ yaz_oi_APDU(a, &oi);
+ yaz_oi_set_string_oidval(oi, t->odr_out, VAL_COOKIE, 1, t->cookie);
+ }
+/* from ZAP */
+#if 0
+ if (req->request->connection)
+ {
+ Z_OtherInformation **oi;
+ zlog (req, t->name, " encoding client_ip");
+ yaz_oi_APDU(a, &oi);
+ yaz_oi_set_string_oidval(oi, t->odr_out, VAL_CLIENT_IP, 1,
+ req->request->connection->remote_ip);
+ }
+#endif
+ if (!z_APDU(t->odr_out, &a, 0, 0))
+ {
+ do_close (t);
+ t->error = PHP_YAZ_ERROR_ENCODE;
+ return -1;
+ }
+ /* apdu_log(req, t->odr_print, a); */
+ t->buf_out = odr_getbuf(t->odr_out, &t->len_out, 0);
+ odr_reset(t->odr_out);
+ do_write (t);
+ return 0;
+}
+
+static char **set_DatabaseNames (Yaz_Association t, int *num)
+{
+ char **databaseNames;
+ char *c, *cp = strchr (t->host_port, '/');
+ int no = 2;
+
+ if (cp)
+ {
+ c = cp;
+ while ((c = strchr(c, '+')))
+ {
+ c++;
+ no++;
+ }
+ }
+ else
+ cp = "/Default";
+ databaseNames = odr_malloc (t->odr_out, no * sizeof(*databaseNames));
+ no = 0;
+ while (*cp)
+ {
+ c = ++cp;
+ c = strchr (c, '+');
+ if (!c)
+ c = cp + strlen(cp);
+ else if (c == cp)
+ continue;
+ /* cp ptr to first char of db name, c is char following db name */
+ databaseNames[no] = odr_malloc (t->odr_out, 1+c-cp);
+ memcpy (databaseNames[no], cp, c-cp);
+ databaseNames[no][c-cp] = '\0';
+ no++;
+ cp = c;
+ }
+ databaseNames[no] = NULL;
+ *num = no;
+ return databaseNames;
+}
+
+static int send_search (Yaz_Association t)
+{
+ Yaz_ResultSet r = t->resultSets;
+ Z_APDU *apdu = zget_APDU(t->odr_out, Z_APDU_searchRequest);
+ Z_SearchRequest *sreq = apdu->u.searchRequest;
+
+ /* resultSetPrepare (req, t, req->cur_pa); */
+ if (t->resultSetStartPoint == 1)
+ {
+ sreq->largeSetLowerBound = odr_malloc (t->odr_out, sizeof(int));
+ *sreq->largeSetLowerBound = 999999;
+ sreq->smallSetUpperBound = &t->numberOfRecordsRequested;
+ sreq->mediumSetPresentNumber = &t->numberOfRecordsRequested;
+ if (t->elementSetNames && *t->elementSetNames)
+ {
+ Z_ElementSetNames *esn = odr_malloc (t->odr_out, sizeof(*esn));
+
+ esn->which = Z_ElementSetNames_generic;
+ esn->u.generic = t->elementSetNames;
+ sreq->mediumSetElementSetNames = esn;
+ sreq->smallSetElementSetNames = esn;
+ }
+ }
+ else
+ {
+ sreq->smallSetUpperBound = odr_malloc (t->odr_out, sizeof(int));
+ *sreq->smallSetUpperBound = 0;
+ sreq->largeSetLowerBound = odr_malloc (t->odr_out, sizeof(int));
+ *sreq->largeSetLowerBound = 1;
+ sreq->mediumSetPresentNumber = odr_malloc (t->odr_out, sizeof(int));
+ *sreq->mediumSetPresentNumber = 0;
+ }
+ sreq->query = r->query;
+ if (t->preferredRecordSyntax && *t->preferredRecordSyntax)
+ {
+ struct oident ident;
+
+ ident.proto = PROTO_Z3950;
+ ident.oclass = CLASS_RECSYN;
+ ident.value = oid_getvalbyname (t->preferredRecordSyntax);
+ sreq->preferredRecordSyntax =
+ odr_oiddup (t->odr_out, oid_getoidbyent (&ident));
+ }
+ sreq->databaseNames = set_DatabaseNames (t, &sreq->num_databaseNames);
+
+ send_APDU (t, apdu);
+ return 1;
+}
+
+static int send_present (Yaz_Association t)
+{
+ Z_APDU *apdu = zget_APDU(t->odr_out, Z_APDU_presentRequest);
+ Z_PresentRequest *req = apdu->u.presentRequest;
+ int i = 0;
+
+ if (!t->resultSets->recordList) /* no records to retrieve at all .. */
+ {
+#if PHP_YAZ_DEBUG
+ php_log_err("No records to retrieve...");
+#endif
+ return 0;
+ }
+
+ while (1)
+ {
+ if (i >= t->resultSets->recordList->num_records)
+ { /* got all records ... */
+ /* searchHits (zreq, t); */
+ return 0;
+ }
+ if (!t->resultSets->recordList->records[i])
+ break;
+ i++;
+ }
+ /* got record(s) to retrieve */
+
+ req->resultSetStartPoint = odr_malloc (t->odr_out, sizeof(int));
+ *req->resultSetStartPoint = t->resultSetStartPoint + i;
+
+ req->numberOfRecordsRequested = odr_malloc (t->odr_out, sizeof(int));
+ *req->numberOfRecordsRequested = t->resultSets->recordList->num_records - i;
+
+ if (t->preferredRecordSyntax && *t->preferredRecordSyntax)
+ {
+ struct oident ident;
+
+ ident.proto = PROTO_Z3950;
+ ident.oclass = CLASS_RECSYN;
+ ident.value = oid_getvalbyname (t->preferredRecordSyntax);
+ req->preferredRecordSyntax =
+ odr_oiddup (t->odr_out, oid_getoidbyent (&ident));
+ }
+
+ if (t->elementSetNames && *t->elementSetNames)
+ {
+ Z_ElementSetNames *esn = odr_malloc (t->odr_out, sizeof(*esn));
+ Z_RecordComposition *compo = odr_malloc (t->odr_out, sizeof(*compo));
+
+ esn->which = Z_ElementSetNames_generic;
+ esn->u.generic = t->elementSetNames;
+ compo->which = Z_RecordComp_simple;
+ compo->u.simple = esn;
+ req->recordComposition = compo;
+ }
+ send_APDU (t, apdu);
+ return 1;
+}
+
+static void send_init(Yaz_Association t)
+{
+ int i = 0;
+ Z_APDU *apdu = zget_APDU(t->odr_out, Z_APDU_initRequest);
+ Z_InitRequest *ireq = apdu->u.initRequest;
+ Z_IdPass *pass = odr_malloc(t->odr_out, sizeof(*pass));
+ Z_IdAuthentication *auth = odr_malloc(t->odr_out, sizeof(*auth));
+ const char *auth_open = t->auth_open;
+ const char *auth_groupId = t->group;
+ const char *auth_userId = t->user;
+ const char *auth_password = t->pass;
+
+ ODR_MASK_SET(ireq->options, Z_Options_search);
+ ODR_MASK_SET(ireq->options, Z_Options_present);
+ ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
+ ODR_MASK_SET(ireq->options, Z_Options_scan);
+
+ ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
+ ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
+ ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
+
+ ireq->implementationName = "PHP/YAZ";
+
+ *ireq->maximumRecordSize = 1024*1024;
+ *ireq->preferredMessageSize = 1024*1024;
+
+ if (auth_open && *auth_open)
+ {
+ auth->which = Z_IdAuthentication_open;
+ auth->u.open = odr_malloc(t->odr_out, strlen(auth_open)+1);
+ strcpy(auth->u.open, auth_open);
+ ireq->idAuthentication = auth;
+ }
+ pass->groupId = 0;
+ if (auth_groupId && *auth_groupId)
+ {
+ pass->groupId = odr_malloc(t->odr_out, strlen(auth_groupId)+1);
+ strcpy(pass->groupId, auth_groupId);
+ i++;
+ }
+ pass->userId = 0;
+ if (auth_userId && *auth_userId)
+ {
+ pass->userId = odr_malloc(t->odr_out, strlen(auth_userId)+1);
+ strcpy(pass->userId, auth_userId);
+ i++;
+ }
+ pass->password = 0;
+ if (auth_password && *auth_password)
+ {
+ pass->password = odr_malloc(t->odr_out, strlen(auth_password)+1);
+ strcpy(pass->password, auth_password);
+ i++;
+ }
+ if(i)
+ {
+ auth->which = Z_IdAuthentication_idPass;
+ auth->u.idPass = pass;
+ ireq->idAuthentication = auth;
+ }
+ if (t->proxy)
+ yaz_oi_set_string_oidval(&ireq->otherInfo, t->odr_out,
+ VAL_PROXY, 1, t->host_port);
+ send_APDU (t, apdu);
+}
+
+static int do_event (int *id)
+{
+ fd_set input, output;
+ int i;
+ int no = 0;
+ int max_fd = 0;
+ struct timeval tv;
+
+ tv.tv_sec = 15;
+ tv.tv_usec = 0;
+
+ FD_ZERO (&input);
+ FD_ZERO (&output);
+ for (i = 0; i < MAX_ASSOC; i++)
+ {
+ Yaz_Association p = shared_associations[i];
+ int fd;
+ if (!p || p->order != order_associations || !p->cs)
+ continue;
+ fd = cs_fileno (p->cs);
+ if (max_fd < fd)
+ max_fd = fd;
+ if (p->mask_select & PHP_YAZ_SELECT_READ)
+ {
+ FD_SET (fd, &input);
+ no++;
+ }
+ if (p->mask_select & PHP_YAZ_SELECT_WRITE)
+ {
+ FD_SET (fd, &output);
+ no++;
+ }
+ }
+ if (!no)
+ return 0;
+ no = select (max_fd+1, &input, &output, 0, &tv);
+ for (i = 0; i<MAX_ASSOC; i++)
+ {
+ int fd;
+ Yaz_Association p = shared_associations[i];
+ if (!p || p->order != order_associations || !p->cs)
+ continue;
+ *id = i+1;
+ fd =cs_fileno(p->cs);
+ if (no <= 0)
+ {
+ if (p->mask_select) /* only mark for those still pending */
+ {
+ if (p->state == PHP_YAZ_STATE_CONNECTING)
+ p->error = PHP_YAZ_ERROR_CONNECT;
+ else
+ p->error = PHP_YAZ_ERROR_TIMEOUT;
+ do_close (p);
+ }
+ }
+ else if (p->state == PHP_YAZ_STATE_CONNECTING)
+ {
+ if (FD_ISSET (fd, &input))
+ {
+ do_close(p);
+ p->error = PHP_YAZ_ERROR_CONNECT;
+ return 2;
+ }
+ else if (FD_ISSET (fd, &output))
+ {
+ send_init(p);
+ }
+ }
+ else if (p->state == PHP_YAZ_STATE_ESTABLISHED)
+ {
+ if (FD_ISSET (fd, &input))
+ do_read (p);
+ if (p->cs && FD_ISSET (fd, &output))
+ do_write (p);
+ }
+ else
+ {
+ do_close (p);
+ p->error = PHP_YAZ_ERROR_CONNECTION_LOST;
+ }
+ }
+ return no;
+}
+
+/* {{{ proto int yaz_connect(string zurl)
+ Create target with given zurl. Returns positive id if succesful. */
+PHP_FUNCTION(yaz_connect)
+{
+ int i;
+ char *cp;
+ char *zurl_str;
+ pval **zurl;
+ if (ARG_COUNT(ht) < 1 || zend_get_parameters_ex (1, &zurl) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_string_ex (zurl);
+ zurl_str = (*zurl)->value.str.val;
+ for (cp = zurl_str; *cp && strchr("\t\n ", *cp); cp++)
+ ;
+ if (!*cp)
+ RETURN_LONG(0);
+
+ /* see if we have it already ... */
+ for (i = 0; i<MAX_ASSOC; i++)
+ if (shared_associations[i] && shared_associations[i]->host_port &&
+ shared_associations[i]->order != order_associations &&
+ !strcmp (shared_associations[i]->host_port, zurl_str))
+ break;
+ if (i == MAX_ASSOC)
+ {
+ /* we didn't have it (or already in use) */
+ int i0 = -1;
+ int min_order = 2000000000;
+ /* find completely free slot or the oldest one */
+ for (i = 0; i<MAX_ASSOC && shared_associations[i]; i++)
+ if (shared_associations[i]->order < min_order
+ && shared_associations[i]->order != order_associations)
+ {
+ min_order = shared_associations[i]->order;
+ i0 = i;
+ }
+ if (i == MAX_ASSOC)
+ {
+ i = i0;
+ if (i == -1)
+ {
+ RETURN_LONG(0); /* no free slot */
+ }
+ else /* "best" free slot */
+ yaz_association_destroy(shared_associations[i]);
+ }
+ shared_associations[i] = yaz_association_mk ();
+ shared_associations[i]->host_port = xstrdup (zurl_str);
+ }
+ shared_associations[i]->order = order_associations;
+ shared_associations[i]->error = 0;
+ shared_associations[i]->numberOfRecordsRequested = 10;
+ shared_associations[i]->resultSetStartPoint = 1;
+ RETURN_LONG(i+1);
+}
+/* }}} */
+
+/* {{{ proto int yaz_close(int id)
+ Destory and close target */
+PHP_FUNCTION(yaz_close)
+{
+ pval **id;
+ int i;
+ if (ARG_COUNT(ht) != 1)
+ WRONG_PARAM_COUNT;
+ if (zend_get_parameters_ex (1, &id) == FAILURE)
+ RETURN_FALSE;
+ convert_to_long_ex (id);
+ i = (*id)->value.lval -1;
+ if (i < 0 || i >= MAX_ASSOC || !shared_associations[i])
+ RETURN_FALSE;
+ yaz_association_destroy (shared_associations[i]);
+ shared_associations[i] = 0;
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int yaz_search(int id, string type, string query)
+ Specify query of type for search - returns true if successful */
+PHP_FUNCTION(yaz_search)
+{
+ char *query_str, *type_str;
+ pval **id, **type, **query;
+ Yaz_Association p;
+ Yaz_ResultSet r;
+ if (ARG_COUNT(ht) != 3)
+ WRONG_PARAM_COUNT;
+ if (zend_get_parameters_ex(3, &id, &type, &query) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (id);
+ if (!p)
+ {
+#if PHP_YAZ_DEBUG
+ php_log_err ("get_assoc failed");
+#endif
+ RETURN_FALSE;
+ }
+ convert_to_string_ex (type);
+ type_str = (*type)->value.str.val;
+ convert_to_string_ex (query);
+ query_str = (*query)->value.str.val;
+ yaz_resultset_destroy (p->resultSets);
+ r = p->resultSets = yaz_resultset_mk();
+ r->query = odr_malloc (r->odr, sizeof(*r->query));
+ if (!strcmp (type_str, "rpn"))
+ {
+ r->query->which = Z_Query_type_1;
+ r->query->u.type_1 = p_query_rpn (r->odr, PROTO_Z3950, query_str);
+ if (!r->query->u.type_1)
+ {
+ yaz_resultset_destroy(r);
+ p->resultSets = 0;
+#if PHP_YAZ_DEBUG
+ php_log_err ("bad rpn");
+#endif
+ RETURN_FALSE;
+ }
+ }
+ else
+ {
+ yaz_resultset_destroy(r);
+ p->resultSets = 0;
+#if PHP_YAZ_DEBUG
+ php_log_err ("bad query type");
+#endif
+ RETURN_FALSE;
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int yaz_wait()
+ Process all outstanding events. */
+PHP_FUNCTION(yaz_wait)
+{
+ int i;
+ int id;
+ for (i = 0; i<MAX_ASSOC; i++)
+ {
+ Yaz_Association p = shared_associations[i];
+ if (!p || p->order != order_associations || !p->resultSets)
+ continue;
+ p->action = send_search;
+ if (!p->cs)
+ {
+ do_connect (p);
+ }
+ else
+ {
+ p->reconnect_flag = 1;
+ send_search (p);
+ }
+ }
+ while (do_event(&id))
+ ;
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int yaz_errno(int id)
+ Return last error number (>0 for bib-1 diagnostic, <0 for other error, 0 for no error */
+PHP_FUNCTION(yaz_errno)
+{
+ pval **id;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 1 || zend_get_parameters_ex(1, &id) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (id);
+ if (!p)
+ {
+ RETURN_LONG(0);
+ }
+ RETURN_LONG(p->error);
+}
+/* }}} */
+
+/* {{{ proto string yaz_error(int id)
+ Return last error message */
+PHP_FUNCTION(yaz_error)
+{
+ pval **id;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 1 || zend_get_parameters_ex(1, &id) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (id);
+ if (p && p->error)
+ {
+ const char *msg = 0;
+ if (p->error < 0)
+ {
+ switch (p->error)
+ {
+ case PHP_YAZ_ERROR_CONNECTION_LOST:
+ msg = "connection lost";
+ break;
+ case PHP_YAZ_ERROR_DECODE:
+ msg = "decoding failure";
+ break;
+ case PHP_YAZ_ERROR_ENCODE:
+ msg = "encoding failure";
+ break;
+ case PHP_YAZ_ERROR_CONNECT:
+ msg = "connect failed";
+ break;
+ case PHP_YAZ_ERROR_INIT:
+ msg = "initialization failed";
+ break;
+ case PHP_YAZ_ERROR_TIMEOUT:
+ msg = "timeout failure";
+ break;
+ default:
+ msg = "unknown failure";
+ break;
+ }
+ }
+ else
+ {
+ msg = diagbib1_str (p->error);
+ if (!msg)
+ msg = "unknown diagnostic";
+ }
+ /* Not macro using because RETURN_STRING throws away const */
+ return_value->value.str.len = strlen(msg);
+ return_value->value.str.val =
+ estrndup(msg, return_value->value.str.len);
+ return_value->type = IS_STRING;
+ }
+}
+/* }}} */
+
+/* {{{ proto string yaz_addinfo(int id)
+ Return additional info for last error (empty string if none) */
+PHP_FUNCTION(yaz_addinfo)
+{
+ pval **id;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 1 || zend_get_parameters_ex(1, &id) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (id);
+ if (p && p->error > 0 && p->addinfo && *p->addinfo)
+ {
+ RETURN_STRING(p->addinfo, 1);
+ }
+}
+/* }}} */
+
+/* {{{ proto int yaz_hits(int id)
+ Return number of hits (result count) for last search */
+PHP_FUNCTION(yaz_hits)
+{
+ pval **id;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 1 || zend_get_parameters_ex(1, &id) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (id);
+ if (!p || !p->resultSets)
+ {
+ RETURN_LONG(0);
+ }
+ RETURN_LONG(p->resultSets->resultCount);
+}
+/* }}} */
+
+Z_GenericRecord *marc_to_grs1(const char *buf, ODR o, Odr_oid *oid)
+{
+ int entry_p;
+ int record_length;
+ int indicator_length;
+ int identifier_length;
+ int base_address;
+ int length_data_entry;
+ int length_starting;
+ int length_implementation;
+ int max_elements = 256;
+ Z_GenericRecord *r = odr_malloc (o, sizeof(*r));
+ r->elements = odr_malloc (o, sizeof(*r->elements) * max_elements);
+ r->num_elements = 0;
+
+ record_length = atoi_n (buf, 5);
+ if (record_length < 25)
+ return 0;
+ indicator_length = atoi_n (buf+10, 1);
+ identifier_length = atoi_n (buf+11, 1);
+ base_address = atoi_n (buf+12, 4);
+
+ length_data_entry = atoi_n (buf+20, 1);
+ length_starting = atoi_n (buf+21, 1);
+ length_implementation = atoi_n (buf+22, 1);
+
+ for (entry_p = 24; buf[entry_p] != ISO2709_FS; )
+ {
+ entry_p += 3+length_data_entry+length_starting;
+ if (entry_p >= record_length)
+ return 0;
+ }
+ base_address = entry_p+1;
+ for (entry_p = 24; buf[entry_p] != ISO2709_FS; )
+ {
+ Z_TaggedElement *tag;
+ int data_length;
+ int data_offset;
+ int end_offset;
+ int i;
+ char tag_str[4];
+
+ memcpy (tag_str, buf+entry_p, 3);
+ entry_p += 3;
+ tag_str[3] = '\0';
+
+ if ((r->num_elements + 1) >= max_elements)
+ {
+ Z_TaggedElement **tmp = r->elements;
+
+ /* double array space, throw away old buffer (nibble memory) */
+ r->elements = odr_malloc(o, sizeof(*r->elements) *
+ (max_elements *= 2));
+ memcpy(r->elements, tmp, r->num_elements * sizeof(*tmp));
+ }
+ tag = r->elements[r->num_elements++] = odr_malloc (o, sizeof(*tag));
+ tag->tagType = odr_malloc(o, sizeof(*tag->tagType));
+ *tag->tagType = 3;
+ tag->tagOccurrence = 0;
+ tag->metaData = 0;
+ tag->appliedVariant = 0;
+ tag->tagValue = odr_malloc (o, sizeof(*tag->tagValue));
+ tag->tagValue->which = Z_StringOrNumeric_string;
+ tag->tagValue->u.string = odr_strdup(o, tag_str);
+
+ tag->content = odr_malloc(o, sizeof(*tag->content));
+ tag->content->which = Z_ElementData_subtree;
+
+ tag->content->u.subtree =
+ odr_malloc (o, sizeof(*tag->content->u.subtree));
+ tag->content->u.subtree->elements = odr_malloc (o, sizeof(*r->elements));
+ tag->content->u.subtree->num_elements = 1;
+
+ tag = tag->content->u.subtree->elements[0] =
+ odr_malloc (o, sizeof(**tag->content->u.subtree->elements));
+
+ tag->tagType = odr_malloc(o, sizeof(*tag->tagType));
+ *tag->tagType = 3;
+ tag->tagOccurrence = 0;
+ tag->metaData = 0;
+ tag->appliedVariant = 0;
+ tag->tagValue = odr_malloc (o, sizeof(*tag->tagValue));
+ tag->tagValue->which = Z_StringOrNumeric_string;
+ tag->content = odr_malloc(o, sizeof(*tag->content));
+
+ data_length = atoi_n (buf+entry_p, length_data_entry);
+ entry_p += length_data_entry;
+ data_offset = atoi_n (buf+entry_p, length_starting);
+ entry_p += length_starting;
+ i = data_offset + base_address;
+ end_offset = i+data_length-1;
+
+ if (memcmp (tag_str, "00", 2) && indicator_length)
+ {
+ /* indicator */
+ tag->tagValue->u.string = odr_malloc(o, indicator_length+1);
+ memcpy (tag->tagValue->u.string, buf + i, indicator_length);
+ tag->tagValue->u.string[indicator_length] = '\0';
+ i += indicator_length;
+
+ tag->content->which = Z_ElementData_subtree;
+
+ tag->content->u.subtree =
+ odr_malloc (o, sizeof(*tag->content->u.subtree));
+ tag->content->u.subtree->elements =
+ odr_malloc (o, 256 * sizeof(*r->elements));
+ tag->content->u.subtree->num_elements = 0;
+
+ while (buf[i] != ISO2709_RS && buf[i] != ISO2709_FS
+ && i < end_offset)
+ {
+ int i0;
+ /* prepare tag */
+ Z_TaggedElement *parent_tag = tag;
+ Z_TaggedElement *tag = odr_malloc (o, sizeof(*tag));
+
+ if (parent_tag->content->u.subtree->num_elements < 256)
+ parent_tag->content->u.subtree->elements[
+ parent_tag->content->u.subtree->num_elements++] = tag;
+
+ tag->tagType = odr_malloc(o, sizeof(*tag->tagType));
+ *tag->tagType = 3;
+ tag->tagOccurrence = 0;
+ tag->metaData = 0;
+ tag->appliedVariant = 0;
+ tag->tagValue = odr_malloc (o, sizeof(*tag->tagValue));
+ tag->tagValue->which = Z_StringOrNumeric_string;
+
+ /* sub field */
+ tag->tagValue->u.string = odr_malloc (o, identifier_length);
+ memcpy (tag->tagValue->u.string, buf+i+1, identifier_length-1);
+ tag->tagValue->u.string[identifier_length-1] = '\0';
+ i += identifier_length;
+
+ /* data ... */
+ tag->content = odr_malloc(o, sizeof(*tag->content));
+ tag->content->which = Z_ElementData_string;
+
+ i0 = i;
+ while (buf[i] != ISO2709_RS && buf[i] != ISO2709_IDFS &&
+ buf[i] != ISO2709_FS && i < end_offset)
+ i++;
+
+ tag->content->u.string = odr_malloc (o, i - i0 + 1);
+ memcpy (tag->content->u.string, buf + i0, i - i0);
+ tag->content->u.string[i - i0] = '\0';
+ }
+ }
+ else
+ {
+ int i0 = i;
+
+ tag->tagValue->u.string = "@";
+ tag->content->which = Z_ElementData_string;
+
+ while (buf[i] != ISO2709_RS && buf[i] != ISO2709_FS &&
+ i < end_offset)
+ i++;
+ tag->content->u.string = odr_malloc (o, i - i0 +1);
+ memcpy (tag->content->u.string, buf+i0, i - i0);
+ tag->content->u.string[i-i0] = '\0';
+ }
+ }
+ return r;
+}
+
+static void retval_grs1 (zval *return_value, Z_GenericRecord *p)
+{
+ Z_GenericRecord *grs[20];
+ int eno[20];
+ int level = 0;
+
+ if (array_init(return_value) == FAILURE)
+ {
+ RETURN_FALSE;
+ }
+ eno[level] = 0;
+ grs[level] = p;
+ while (level >= 0)
+ {
+ zval *my_zval;
+ Z_TaggedElement *e = 0;
+ Z_GenericRecord *p = grs[level];
+ int i;
+ char tag[256];
+ int taglen = 0;
+
+ if (eno[level] >= p->num_elements)
+ {
+ --level;
+ if (level >= 0)
+ eno[level]++;
+ continue;
+ }
+ // eno[level]++;
+
+ *tag = '\0';
+ for (i = 0; i<=level; i++)
+ {
+ int tag_type = 3;
+ e = grs[i]->elements[eno[i]];
+
+ if (e->tagType)
+ tag_type = *e->tagType;
+
+ taglen = strlen(tag);
+ sprintf (tag+taglen, "(%d,", tag_type);
+ taglen = strlen(tag);
+
+ if (e->tagValue->which == Z_StringOrNumeric_string)
+ {
+ int len = strlen(e->tagValue->u.string);
+ memcpy (tag + taglen, e->tagValue->u.string, len);
+ tag[taglen+len] = '\0';
+ }
+ else if (e->tagValue->which == Z_StringOrNumeric_numeric)
+ {
+ sprintf (tag + taglen, "%d", *e->tagValue->u.numeric);
+ }
+ taglen = strlen(tag);
+ strcpy (tag + taglen, ")");
+ }
+ ALLOC_ZVAL(my_zval);
+ array_init(my_zval);
+ INIT_PZVAL(my_zval);
+
+ add_next_index_string(my_zval, tag, 1);
+
+ switch (e->content->which)
+ {
+ case Z_ElementData_string:
+ add_next_index_string (my_zval, e->content->u.string, 1);
+ break;
+ case Z_ElementData_numeric:
+ add_next_index_long (my_zval, *e->content->u.numeric);
+ break;
+ case Z_ElementData_trueOrFalse:
+ add_next_index_long (my_zval, *e->content->u.trueOrFalse);
+ break;
+ case Z_ElementData_subtree:
+ level++;
+ grs[level] = e->content->u.subtree;
+ eno[level] = -1;
+ default:
+ }
+ zend_hash_next_index_insert (return_value->value.ht,
+ (void *) &my_zval, sizeof(zval *), NULL);
+ eno[level]++;
+ }
+}
+
+
+/* {{{ proto string yaz_record(int id, int pos, string type)
+ Return record information at given result set position */
+PHP_FUNCTION(yaz_record)
+{
+ pval **pval_id, **pval_pos, **pval_type;
+ Yaz_Association p;
+ int pos;
+ char *type;
+
+ if (ARG_COUNT(ht) != 3)
+ WRONG_PARAM_COUNT;
+ if (zend_get_parameters_ex(3, &pval_id, &pval_pos, &pval_type) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (pval_id);
+
+ convert_to_long_ex(pval_pos);
+ pos = (*pval_pos)->value.lval;
+
+ convert_to_string_ex(pval_type);
+ type = (*pval_type)->value.str.val;
+
+ if (p && p->resultSets && p->resultSets->recordList &&
+ pos >= p->resultSetStartPoint &&
+ pos < p->resultSetStartPoint + p->resultSets->recordList->num_records)
+ {
+ Z_NamePlusRecord *npr =
+ p->resultSets->recordList->records[pos - p->resultSetStartPoint];
+ if (npr->which == Z_NamePlusRecord_databaseRecord)
+ {
+ Z_External *r = (Z_External *) npr->u.databaseRecord;
+ oident *ent = oid_getentbyoid(r->direct_reference);
+
+ if (!strcmp (type, "syntax"))
+ {
+ if (ent && ent->desc)
+ RETVAL_STRING(ent->desc, 1);
+ }
+ else if (!strcmp (type, "string"))
+ {
+ if (r->which == Z_External_sutrs && ent->value == VAL_SUTRS)
+ {
+ RETVAL_STRINGL(r->u.sutrs->buf, r->u.sutrs->len, 1);
+ }
+ else if (r->which == Z_External_octet)
+ {
+ char *buf = (char *) (r->u.octet_aligned->buf);
+ int len = r->u.octet_aligned->len;
+
+ switch (ent->value)
+ {
+ case VAL_SOIF:
+ case VAL_HTML:
+ break;
+ case VAL_TEXT_XML:
+ case VAL_APPLICATION_XML:
+ break;
+ default:
+ }
+ RETVAL_STRINGL(buf, len, 1);
+ }
+ }
+ else if (!strcmp (type, "array"))
+ {
+ if (r->which == Z_External_grs1 && ent->value == VAL_GRS1)
+ {
+ retval_grs1 (return_value, r->u.grs1);
+ }
+ else if (r->which == Z_External_octet)
+ {
+ char *buf = (char *) (r->u.octet_aligned->buf);
+ ODR odr = odr_createmem (ODR_DECODE);
+ Z_GenericRecord *rec = 0;
+
+ switch (ent->value)
+ {
+ case VAL_SOIF:
+ case VAL_HTML:
+ break;
+ case VAL_TEXT_XML:
+ case VAL_APPLICATION_XML:
+ /* text2grs1 (&buf, &len, t->odr_in, 0, 0); */
+ break;
+ default:
+ rec = marc_to_grs1 (buf, odr, r->direct_reference);
+ }
+ if (rec)
+ retval_grs1 (return_value, rec);
+ odr_destroy (odr);
+ }
+ }
+ }
+ }
+}
+/* }}} */
+
+
+/* {{{ proto int yaz_syntax(int id, string syntax)
+ Set record syntax for retrieval */
+PHP_FUNCTION(yaz_syntax)
+{
+ pval **pval_id, **pval_syntax;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 2 ||
+ zend_get_parameters_ex(2, &pval_id, &pval_syntax) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (pval_id);
+ if (p)
+ {
+ convert_to_string_ex (pval_syntax);
+ xfree (p->preferredRecordSyntax);
+ p->preferredRecordSyntax = xstrdup ((*pval_syntax)->value.str.val);
+ }
+}
+/* }}} */
+
+/* {{{ proto int yaz_element(int id, string elementsetname)
+ Set Element-Set-Name for retrieval */
+PHP_FUNCTION(yaz_element)
+{
+ pval **pval_id, **pval_element;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 2 ||
+ zend_get_parameters_ex(2, &pval_id, &pval_element) == FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (pval_id);
+ if (p)
+ {
+ convert_to_string_ex (pval_element);
+ xfree (p->elementSetNames);
+ p->elementSetNames = xstrdup ((*pval_element)->value.str.val);
+ }
+}
+/* }}} */
+
+/* {{{ proto int yaz_range(int id, int start, int number)
+ Set result set start point and number of records to request */
+
+PHP_FUNCTION(yaz_range)
+{
+ pval **pval_id, **pval_start, **pval_number;
+ Yaz_Association p;
+ if (ARG_COUNT(ht) != 3 ||
+ zend_get_parameters_ex(3, &pval_id, &pval_start, &pval_number) ==
+ FAILURE)
+ {
+ WRONG_PARAM_COUNT;
+ }
+ p = get_assoc (pval_id);
+ if (p)
+ {
+ convert_to_long_ex (pval_start);
+ p->resultSetStartPoint = (*pval_start)->value.lval;
+ convert_to_long_ex (pval_number);
+ p->numberOfRecordsRequested = (*pval_number)->value.lval;
+ }
+}
+/* }}} */
+
+PHP_MINIT_FUNCTION(yaz)
+{
+ int i;
+#if PHP_YAZ_DEBUG
+ php_log_err ("PHP_MINIT_FUNCTION yaz");
+#endif
+ nmem_init();
+ order_associations = 1;
+ shared_associations = xmalloc (sizeof(*shared_associations) * MAX_ASSOC);
+ for (i = 0; i<MAX_ASSOC; i++)
+ shared_associations[i] = 0;
+ return SUCCESS;
+}
+
+PHP_MSHUTDOWN_FUNCTION(yaz)
+{
+ int i;
+
+#if PHP_YAZ_DEBUG
+ php_log_err ("PHP_MSHUTDOWN_FUNCTION yaz");
+#endif
+ if (!shared_associations)
+ return SUCCESS;
+ for (i = 0; i<MAX_ASSOC; i++)
+ yaz_association_destroy (shared_associations[i]);
+ xfree (shared_associations);
+ shared_associations = 0;
+ nmem_exit();
+ return SUCCESS;
+}
+
+PHP_MINFO_FUNCTION(yaz)
+{
+#if PHP_YAZ_DEBUG
+ php_log_err ("PHP_MINFO_FUNCTION yaz");
+#endif
+}
+
+PHP_RSHUTDOWN_FUNCTION(yaz)
+{
+#if PHP_YAZ_DEBUG
+ php_log_err ("PHP_RSHUTDOWN yaz");
+#endif
+ return SUCCESS;
+}
+
+PHP_RINIT_FUNCTION(yaz)
+{
+ order_associations++;
+#if PHP_YAZ_DEBUG
+ php_log_err ("PHP_RINIT yaz");
+#endif
+ return SUCCESS;
+}
+
+zend_module_entry yaz_module_entry = {
+ "YAZ",
+ yaz_functions,
+ PHP_MINIT(yaz),
+ PHP_MSHUTDOWN(yaz),
+ PHP_RINIT(yaz),
+ PHP_RSHUTDOWN(yaz),
+ PHP_MINFO(yaz),
+ STANDARD_MODULE_PROPERTIES
+};
+
+#if COMPILE_DL
+DLEXPORT zend_module_entry *get_module(void) { return &yaz_module_entry; }
+#endif
+
+
+#endif
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
projects / php / commitdiff