void yaz_query_to_wrbuf(WRBUF b, const Z_Query *q)
{
assert(q);
assert(b);
switch (q->which)
{
case Z_Query_type_1:
case Z_Query_type_101:
wrbuf_puts(b,"RPN ");
yaz_rpnquery_to_wrbuf(b, q->u.type_1);
break;
case Z_Query_type_2:
wrbuf_puts(b, "CCL ");
wrbuf_write(b, (const char *) q->u.type_2->buf, q->u.type_2->len);
break;
case Z_Query_type_100:
wrbuf_puts(b, "Z39.58 ");
wrbuf_write(b, (const char *) q->u.type_100->buf, q->u.type_100->len);
break;
case Z_Query_type_104:
if (q->u.type_104->which == Z_External_CQL)
{
wrbuf_puts(b, "CQL ");
wrbuf_puts(b, q->u.type_104->u.cql);
}
else
wrbuf_printf(b,"UNKNOWN type 104 query %d", q->u.type_104->which);
}
}
void http_set_proxyaddr(const char *host, struct conf_server *server)
{
const char *p;
short port;
struct hostent *he;
WRBUF w = wrbuf_alloc();
yaz_log(YLOG_LOG, "HTTP backend %s", host);
p = strchr(host, ':');
if (p)
{
port = atoi(p + 1);
wrbuf_write(w, host, p - host);
wrbuf_puts(w, "");
}
else
{
port = 80;
wrbuf_puts(w, host);
}
if (!(he = gethostbyname(wrbuf_cstr(w))))
{
fprintf(stderr, "Failed to lookup '%s'\n", wrbuf_cstr(w));
exit(1);
}
wrbuf_destroy(w);
server->http_server->proxy_addr = xmalloc(sizeof(struct sockaddr_in));
server->http_server->proxy_addr->sin_family = he->h_addrtype;
memcpy(&server->http_server->proxy_addr->sin_addr.s_addr,
he->h_addr_list[0], he->h_length);
server->http_server->proxy_addr->sin_port = htons(port);
}
// Serialize a HTTP request
static struct http_buf *http_serialize_request(struct http_request *r)
{
struct http_channel *c = r->channel;
struct http_header *h;
wrbuf_rewind(c->wrbuf);
wrbuf_printf(c->wrbuf, "%s %s%s%s", r->method, r->path,
*r->search ? "?" : "", r->search);
wrbuf_printf(c->wrbuf, " HTTP/%s\r\n", r->http_version);
for (h = r->headers; h; h = h->next)
wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
wrbuf_puts(c->wrbuf, "\r\n");
if (r->content_buf)
wrbuf_write(c->wrbuf, r->content_buf, r->content_len);
#if 0
yaz_log(YLOG_LOG, "WRITING TO PROXY:\n%s\n----",
wrbuf_cstr(c->wrbuf));
#endif
return http_buf_bywrbuf(c->http_server, c->wrbuf);
}
static void show_raw_record_ok(void *data, const char *buf, size_t sz)
{
http_channel_observer_t obs = data;
struct http_channel *c = http_channel_observer_chan(obs);
struct http_response *rs = c->response;
http_remove_observer(obs);
wrbuf_write(c->wrbuf, buf, sz);
rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
http_send_response(c);
}
static int convert_xslt(void *vinfo, WRBUF record, WRBUF wr_error)
{
int ret = 0;
struct xslt_info *info = vinfo;
xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
wrbuf_len(record));
if (!doc)
{
wrbuf_printf(wr_error, "xmlParseMemory failed");
ret = -1;
}
else
{
xmlDocPtr xsp_doc = xmlCopyDoc(info->xsp_doc, 1);
xsltStylesheetPtr xsp = xsltParseStylesheetDoc(xsp_doc);
xmlDocPtr res = xsltApplyStylesheet(xsp, doc, info->xsl_parms);
if (res)
{
xmlChar *out_buf = 0;
int out_len;
#if HAVE_XSLTSAVERESULTTOSTRING
xsltSaveResultToString(&out_buf, &out_len, res, xsp);
#else
xmlDocDumpFormatMemory (res, &out_buf, &out_len, 1);
#endif
if (!out_buf)
{
wrbuf_printf(wr_error,
"xsltSaveResultToString failed");
ret = -1;
}
else
{
wrbuf_rewind(record);
wrbuf_write(record, (const char *) out_buf, out_len);
xmlFree(out_buf);
}
xmlFreeDoc(res);
}
else
{
wrbuf_printf(wr_error, "xsltApplyStylesheet failed");
ret = -1;
}
xmlFreeDoc(doc);
xsltFreeStylesheet(xsp); /* frees xsp_doc too */
}
return ret;
}
static void show_raw_record_ok_binary(void *data, const char *buf, size_t sz)
{
http_channel_observer_t obs = data;
struct http_channel *c = http_channel_observer_chan(obs);
struct http_response *rs = c->response;
http_remove_observer(obs);
wrbuf_write(c->wrbuf, buf, sz);
rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
rs->content_type = "application/octet-stream";
http_send_response(c);
}
static int yaz_record_conv_record_rule(yaz_record_conv_t p,
struct yaz_record_conv_rule *r,
const char *input_record_buf,
size_t input_record_len,
WRBUF output_record)
{
int ret = 0;
WRBUF record = output_record; /* pointer transfer */
wrbuf_rewind(p->wr_error);
wrbuf_write(record, input_record_buf, input_record_len);
for (; ret == 0 && r; r = r->next)
ret = r->type->convert(r->info, record, p->wr_error);
return ret;
}
static int convert_solrmarc(void *info, WRBUF record, WRBUF wr_error)
{
WRBUF w = wrbuf_alloc();
const char *buf = wrbuf_buf(record);
size_t i, sz = wrbuf_len(record);
for (i = 0; i < sz; i++)
{
int ch;
if (buf[i] == '#' && i < sz - 3 && buf[i+3] == ';'
&& atoi_n_check(buf+i+1, 2, &ch))
i += 3;
else
ch = buf[i];
wrbuf_putc(w, ch);
}
wrbuf_rewind(record);
wrbuf_write(record, wrbuf_buf(w), wrbuf_len(w));
wrbuf_destroy(w);
return 0;
}
static int yaz_marc_write_marcxml_ns(yaz_marc_t mt, WRBUF wr,
const char *ns,
const char *format,
const char *type,
int turbo)
{
if (mt->write_using_libxml2)
{
#if YAZ_HAVE_XML2
int ret;
xmlNode *root_ptr;
if (!turbo)
ret = yaz_marc_write_xml(mt, &root_ptr, ns, format, type);
else
ret = yaz_marc_write_xml_turbo_xml(mt, &root_ptr, ns, format, type);
if (ret == 0)
{
xmlChar *buf_out;
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
int len_out;
xmlDocSetRootElement(doc, root_ptr);
xmlDocDumpMemory(doc, &buf_out, &len_out);
wrbuf_write(wr, (const char *) buf_out, len_out);
wrbuf_puts(wr, "");
xmlFree(buf_out);
xmlFreeDoc(doc);
}
return ret;
#else
return -1;
#endif
}
else
return yaz_marc_write_marcxml_wrbuf(mt, wr, ns, format, type, turbo);
}
int yaz_marc_write_iso2709(yaz_marc_t mt, WRBUF wr)
{
struct yaz_marc_node *n;
int indicator_length;
int identifier_length;
int length_data_entry;
int length_starting;
int length_implementation;
int data_offset = 0;
const char *leader = 0;
WRBUF wr_dir, wr_head, wr_data_tmp;
int base_address;
for (n = mt->nodes; n; n = n->next)
if (n->which == YAZ_MARC_LEADER)
leader = n->u.leader;
if (!leader)
return -1;
if (!atoi_n_check(leader+10, 1, &indicator_length))
return -1;
if (!atoi_n_check(leader+11, 1, &identifier_length))
return -1;
if (!atoi_n_check(leader+20, 1, &length_data_entry))
return -1;
if (!atoi_n_check(leader+21, 1, &length_starting))
return -1;
if (!atoi_n_check(leader+22, 1, &length_implementation))
return -1;
wr_data_tmp = wrbuf_alloc();
wr_dir = wrbuf_alloc();
for (n = mt->nodes; n; n = n->next)
{
int data_length = 0;
struct yaz_marc_subfield *s;
switch(n->which)
{
case YAZ_MARC_DATAFIELD:
wrbuf_printf(wr_dir, "%.3s", n->u.datafield.tag);
data_length += indicator_length;
wrbuf_rewind(wr_data_tmp);
for (s = n->u.datafield.subfields; s; s = s->next)
{
/* write dummy IDFS + content */
wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' ');
wrbuf_iconv_puts(wr_data_tmp, mt->iconv_cd, s->code_data);
marc_iconv_reset(mt, wr_data_tmp);
}
/* write dummy FS (makes MARC-8 to become ASCII) */
wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' ');
marc_iconv_reset(mt, wr_data_tmp);
data_length += wrbuf_len(wr_data_tmp);
break;
case YAZ_MARC_CONTROLFIELD:
wrbuf_printf(wr_dir, "%.3s", n->u.controlfield.tag);
wrbuf_rewind(wr_data_tmp);
wrbuf_iconv_puts(wr_data_tmp, mt->iconv_cd,
n->u.controlfield.data);
marc_iconv_reset(mt, wr_data_tmp);
wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' ');/* field sep */
marc_iconv_reset(mt, wr_data_tmp);
data_length += wrbuf_len(wr_data_tmp);
break;
case YAZ_MARC_COMMENT:
break;
case YAZ_MARC_LEADER:
break;
}
if (data_length)
{
wrbuf_printf(wr_dir, "%0*d", length_data_entry, data_length);
wrbuf_printf(wr_dir, "%0*d", length_starting, data_offset);
data_offset += data_length;
}
}
/* mark end of directory */
wrbuf_putc(wr_dir, ISO2709_FS);
/* base address of data (comes after leader+directory) */
base_address = 24 + wrbuf_len(wr_dir);
wr_head = wrbuf_alloc();
/* write record length */
wrbuf_printf(wr_head, "%05d", base_address + data_offset + 1);
/* from "original" leader */
wrbuf_write(wr_head, leader+5, 7);
/* base address of data */
wrbuf_printf(wr_head, "%05d", base_address);
/* from "original" leader */
wrbuf_write(wr_head, leader+17, 7);
wrbuf_write(wr, wrbuf_buf(wr_head), 24);
wrbuf_write(wr, wrbuf_buf(wr_dir), wrbuf_len(wr_dir));
wrbuf_destroy(wr_head);
wrbuf_destroy(wr_dir);
wrbuf_destroy(wr_data_tmp);
for (n = mt->nodes; n; n = n->next)
{
struct yaz_marc_subfield *s;
switch(n->which)
{
case YAZ_MARC_DATAFIELD:
wrbuf_write(wr, n->u.datafield.indicator, indicator_length);
for (s = n->u.datafield.subfields; s; s = s->next)
{
wrbuf_putc(wr, ISO2709_IDFS);
wrbuf_iconv_puts(wr, mt->iconv_cd, s->code_data);
marc_iconv_reset(mt, wr);
}
wrbuf_putc(wr, ISO2709_FS);
break;
case YAZ_MARC_CONTROLFIELD:
wrbuf_iconv_puts(wr, mt->iconv_cd, n->u.controlfield.data);
marc_iconv_reset(mt, wr);
wrbuf_putc(wr, ISO2709_FS);
break;
case YAZ_MARC_COMMENT:
break;
case YAZ_MARC_LEADER:
break;
}
}
wrbuf_printf(wr, "%c", ISO2709_RS);
return 0;
}
/* Create a http-channel listener, syntax [host:]port */
int http_init(const char *addr, struct conf_server *server,
const char *record_fname)
{
IOCHAN c;
int l;
struct protoent *p;
struct sockaddr_in myaddr;
int one = 1;
const char *pp;
short port;
FILE *record_file = 0;
yaz_log(YLOG_LOG, "HTTP listener %s", addr);
if (record_fname)
{
record_file = fopen(record_fname, "wb");
if (!record_file)
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "fopen %s", record_fname);
return 1;
}
}
memset(&myaddr, 0, sizeof myaddr);
myaddr.sin_family = AF_INET;
pp = strchr(addr, ':');
if (pp)
{
WRBUF w = wrbuf_alloc();
struct hostent *he;
wrbuf_write(w, addr, pp - addr);
wrbuf_puts(w, "");
he = gethostbyname(wrbuf_cstr(w));
wrbuf_destroy(w);
if (!he)
{
yaz_log(YLOG_FATAL, "Unable to resolve '%s'", addr);
return 1;
}
memcpy(&myaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
port = atoi(pp + 1);
}
else
{
port = atoi(addr);
myaddr.sin_addr.s_addr = INADDR_ANY;
}
myaddr.sin_port = htons(port);
if (!(p = getprotobyname("tcp"))) {
return 1;
}
if ((l = socket(PF_INET, SOCK_STREAM, p->p_proto)) < 0)
yaz_log(YLOG_FATAL|YLOG_ERRNO, "socket");
if (setsockopt(l, SOL_SOCKET, SO_REUSEADDR, (char*)
&one, sizeof(one)) < 0)
return 1;
if (bind(l, (struct sockaddr *) &myaddr, sizeof myaddr) < 0)
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "bind");
return 1;
}
if (listen(l, SOMAXCONN) < 0)
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "listen");
return 1;
}
server->http_server = http_server_create();
server->http_server->record_file = record_file;
server->http_server->listener_socket = l;
c = iochan_create(l, http_accept, EVENT_INPUT | EVENT_EXCEPT, "http_server");
iochan_setdata(c, server);
iochan_add(server->iochan_man, c);
return 0;
}
static void wrbuf_vputs(const char *buf, void *client_data)
{
wrbuf_write((WRBUF) client_data, buf, strlen(buf));
}
static int tst_convert_x(yaz_iconv_t cd, const char *buf, const char *cmpbuf,
int expect_error)
{
int ret = 1;
WRBUF b = wrbuf_alloc();
char outbuf[16];
size_t inbytesleft = strlen(buf);
const char *inp = buf;
int rounds = 0;
for (rounds = 0; inbytesleft && rounds < (int) sizeof(outbuf); rounds++)
{
size_t outbytesleft = sizeof(outbuf);
char *outp = outbuf;
size_t r = yaz_iconv(cd, (char**) &inp, &inbytesleft,
&outp, &outbytesleft);
wrbuf_write(b, outbuf, outp - outbuf);
if (r == (size_t) (-1))
{
int e = yaz_iconv_error(cd);
if (e != YAZ_ICONV_E2BIG)
{
if (expect_error != -1)
if (e != expect_error)
ret = 0;
break;
}
}
else
{
size_t outbytesleft = sizeof(outbuf);
char *outp = outbuf;
r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
wrbuf_write(b, outbuf, outp - outbuf);
if (expect_error != -1)
if (expect_error)
ret = 0;
break;
}
}
if (wrbuf_len(b) == strlen(cmpbuf)
&& !memcmp(cmpbuf, wrbuf_buf(b), wrbuf_len(b)))
;
else
{
WRBUF w = wrbuf_alloc();
ret = 0;
wrbuf_rewind(w);
wrbuf_puts_escaped(w, buf);
yaz_log(YLOG_LOG, "input %s", wrbuf_cstr(w));
wrbuf_rewind(w);
wrbuf_write_escaped(w, wrbuf_buf(b), wrbuf_len(b));
yaz_log(YLOG_LOG, "got %s", wrbuf_cstr(w));
wrbuf_rewind(w);
wrbuf_puts_escaped(w, cmpbuf);
yaz_log(YLOG_LOG, "exp %s", wrbuf_cstr(w));
wrbuf_destroy(w);
}
wrbuf_destroy(b);
return ret;
}
