int conv_configure_test(const char *xmlstring, const char *expect_error,
yaz_record_conv_t *pt)
{
WRBUF w = wrbuf_alloc();
int ret;
yaz_record_conv_t p = conv_configure(xmlstring, w);
if (!p)
{
if (expect_error && !strcmp(wrbuf_cstr(w), expect_error))
ret = 1;
else
{
ret = 0;
printf("%s\n", wrbuf_cstr(w));
}
}
else
{
if (expect_error)
ret = 0;
else
ret = 1;
}
if (pt)
*pt = p;
else
if (p)
yaz_record_conv_destroy(p);
wrbuf_destroy(w);
return ret;
}
static int compare(cql_transform_t ct, const char *pqf, const char *cql)
{
int ret = 0;
ODR odr = odr_createmem(ODR_ENCODE);
WRBUF w = wrbuf_alloc();
Z_RPNQuery *q = p_query_rpn(odr, pqf);
if (q)
{
int r = cql_transform_rpn2cql_wrbuf(ct, w, q);
if (r != 0)
{
/* transform error */
yaz_log(YLOG_LOG, "%s -> Error %d", pqf, r);
if (!cql) /* also expected error? */
ret = 1;
}
else if (r == 0)
{
yaz_log(YLOG_LOG, "%s -> %s", pqf, wrbuf_cstr(w));
if (cql && !strcmp(wrbuf_cstr(w), cql))
{
ret = 1;
}
}
}
wrbuf_destroy(w);
odr_destroy(odr);
return ret;
}
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);
}
void add_marc_datafield_turbo_xml(yaz_marc_t mt, struct yaz_marc_node *n,
xmlNode *record_ptr,
xmlNsPtr ns_record, WRBUF wr_cdata,
int identifier_length)
{
xmlNode *ptr;
struct yaz_marc_subfield *s;
WRBUF subfield_name = wrbuf_alloc();
/* TODO consider if safe */
char field[10];
field[0] = 'd';
strncpy(field + 1, n->u.datafield.tag, 3);
field[4] = '\0';
ptr = xmlNewChild(record_ptr, ns_record, BAD_CAST field, 0);
if (n->u.datafield.indicator)
{
int i;
for (i = 0; n->u.datafield.indicator[i]; i++)
{
char ind_str[6];
char ind_val[2];
ind_val[0] = n->u.datafield.indicator[i];
ind_val[1] = '\0';
sprintf(ind_str, "%s%d", indicator_name[1], i+1);
xmlNewProp(ptr, BAD_CAST ind_str, BAD_CAST ind_val);
}
}
for (s = n->u.datafield.subfields; s; s = s->next)
{
int not_written;
xmlNode *ptr_subfield;
size_t using_code_len = get_subfield_len(mt, s->code_data,
identifier_length);
wrbuf_rewind(wr_cdata);
wrbuf_iconv_puts(wr_cdata, mt->iconv_cd, s->code_data + using_code_len);
marc_iconv_reset(mt, wr_cdata);
wrbuf_rewind(subfield_name);
wrbuf_puts(subfield_name, "s");
not_written = element_name_append_attribute_value(mt, subfield_name, 0, s->code_data, using_code_len) != 0;
ptr_subfield = xmlNewTextChild(ptr, ns_record,
BAD_CAST wrbuf_cstr(subfield_name),
BAD_CAST wrbuf_cstr(wr_cdata));
if (not_written)
{
/* Generate code attribute value and add */
wrbuf_rewind(wr_cdata);
wrbuf_iconv_write(wr_cdata, mt->iconv_cd,s->code_data, using_code_len);
xmlNewProp(ptr_subfield, BAD_CAST "code", BAD_CAST wrbuf_cstr(wr_cdata));
}
}
wrbuf_destroy(subfield_name);
}
static int conv_convert_test(yaz_record_conv_t p,
const char *input_record,
const char *output_expect_record)
{
int ret = 0;
if (!p)
{
YAZ_CHECK(ret);
}
else
{
WRBUF output_record = wrbuf_alloc();
int r = yaz_record_conv_record(p, input_record, strlen(input_record),
output_record);
if (r)
{
if (output_expect_record)
{
printf("yaz_record_conv error=%s\n",
yaz_record_conv_get_error(p));
ret = 0;
}
else
ret = 1;
}
else
{
if (!output_expect_record)
{
ret = 0;
}
else if (strcmp(output_expect_record, wrbuf_cstr(output_record)))
{
ret = 0;
printf("got-output_record len=%ld: %s\n",
(long) wrbuf_len(output_record),
wrbuf_cstr(output_record));
printf("output_expect_record len=%ld %s\n",
(long) strlen(output_expect_record),
output_expect_record);
}
else
{
ret = 1;
}
}
wrbuf_destroy(output_record);
}
return ret;
}
static int compare2(cql_transform_t ct, const char *pqf, const char *cql,
int expected_error)
{
int ret = 0;
ODR odr = odr_createmem(ODR_ENCODE);
WRBUF w = wrbuf_alloc();
Z_RPNQuery *q = p_query_rpn(odr, pqf);
if (q)
{
int r = cql_transform_rpn2cql_wrbuf(ct, w, q);
if (r != 0)
{
const char *addinfo = 0;
int err = cql_transform_error(ct, &addinfo);
/* transform error */
yaz_log(YLOG_LOG, "%s -> Error %d", pqf, r);
if (err == 0)
;
else if (err == expected_error)
{
if (addinfo && cql && !strcmp(addinfo, cql))
ret = 1;
else if (!addinfo && !cql)
ret = 1;
}
}
else if (r == 0)
{
yaz_log(YLOG_LOG, "%s -> %s", pqf, wrbuf_cstr(w));
if (!expected_error)
ret = 1;
else if (cql && !strcmp(wrbuf_cstr(w), cql))
{
ret = 1;
}
else
{
yaz_log(YLOG_WARN, " expected: %s", cql ? cql : "null");
yaz_log(YLOG_WARN, " got: %s", wrbuf_cstr(w));
}
}
}
wrbuf_destroy(w);
odr_destroy(odr);
return ret;
}
// 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);
}
int main(int argc, char **argv)
{
struct json_node *n;
int print = 0;
int ret;
char *arg;
while ((ret = options("p", argv, argc, &arg)) != YAZ_OPTIONS_EOF)
{
switch (ret)
{
case 'p':
print++;
break;
default:
usage(argv[0]);
}
}
n = do_parse_from_stdin();
if (!n)
exit(1);
if (print)
{
WRBUF result = wrbuf_alloc();
if (print > 1)
json_write_wrbuf_pretty(n, result);
else
json_write_wrbuf(n, result);
puts(wrbuf_cstr(result));
wrbuf_destroy(result);
}
json_remove_node(n);
return 0;
}
/* original tokenizer with our tokenize interface, but we
add +1 to ensure no '\0' are in our string (except for EOF)
*/
static const char *pp2_charset_token_a_to_z(pp2_charset_token_t prt)
{
const char *cp = prt->cp;
int c;
/* skip white space */
while (*cp && (c = raw_char(tolower(*(const unsigned char *)cp))) < 0)
cp++;
if (*cp == '\0')
{
prt->cp = cp;
prt->last_cp = 0;
return 0;
}
/* now read the term itself */
prt->last_cp = cp;
wrbuf_rewind(prt->norm_str);
while (*cp && (c = raw_char(tolower(*cp))) >= 0)
{
wrbuf_putc(prt->norm_str, c);
cp++;
}
prt->cp = cp;
return wrbuf_cstr(prt->norm_str);
}
static void tst2(void)
{
WRBUF w = wrbuf_alloc();
cql_transform_t ct = 0;
const char *srcdir = getenv("srcdir");
if (srcdir)
{
wrbuf_puts(w, srcdir);
wrbuf_puts(w, "/");
}
wrbuf_puts(w, "../etc/pqf.properties");
ct = cql_transform_open_fname(wrbuf_cstr(w));
YAZ_CHECK(compare(ct, "@attr 1=4 abc", "dc.title=abc"));
YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=108 abc", "dc.title=/exact abc"));
YAZ_CHECK(compare(ct, "@attr 1=4 @attr 3=1 @attr 6=1 abc", "dc.title=abc"));
YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=1 @attr 6=1 abc",
"dc.title=abc"));
YAZ_CHECK(compare(ct, "@attr 1=1016 abc", "abc"));
YAZ_CHECK(compare(ct, "@attr 2=1 @attr 1=30 1980", "dc.date<1980"));
YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=3 1980", "dc.date=1980"));
YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=5 1980", "dc.date>1980"));
YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=2 1980", "dc.date<=1980"));
YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=4 1980", "dc.date>=1980"));
YAZ_CHECK(compare(ct, "@attr 2=103 @attr 1=_ALLRECORDS 1", "cql.allRecords=1"));
YAZ_CHECK(compare(ct, "@attr 1=500 abc", 0));
cql_transform_close(ct);
wrbuf_destroy(w);
}
static void response_close(struct http_channel *c, const char *command)
{
struct http_response *rs = c->response;
wrbuf_printf(c->wrbuf, "</%s>", command);
rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(c->wrbuf));
http_send_response(c);
}
static const char *pp2_get_display_ascii(pp2_charset_token_t prt)
{
if (prt->last_cp == 0)
return 0;
else
{
return wrbuf_cstr(prt->norm_str);
}
}
int relevance_snippet(struct relevance *r,
const char *words, const char *name,
WRBUF w_snippet)
{
int no = 0;
const char *norm_str;
int highlight = 0;
pp2_charset_token_first(r->prt, words, 0);
while ((norm_str = pp2_charset_token_next(r->prt)))
{
size_t org_start, org_len;
struct word_entry *entries = r->entries;
int i;
pp2_get_org(r->prt, &org_start, &org_len);
for (; entries; entries = entries->next, i++)
{
if (*norm_str && !strcmp(norm_str, entries->norm_str))
{
break;
if (!highlight)
{
highlight = 1;
wrbuf_puts(w_snippet, "<match>");
}
break;
}
}
if (entries)
{
if (!highlight)
{
highlight = 1;
wrbuf_puts(w_snippet, "<match>");
no++;
}
}
else
{
if (highlight)
{
highlight = 0;
wrbuf_puts(w_snippet, "</match>");
}
}
wrbuf_xmlputs_n(w_snippet, words + org_start, org_len);
}
if (highlight)
wrbuf_puts(w_snippet, "</match>");
if (no)
{
yaz_log(YLOG_DEBUG, "SNIPPET match: %s", wrbuf_cstr(w_snippet));
}
return no;
}
int solr_transform_rpn2solr_stream(solr_transform_t ct,
void (*pr)(const char *buf, void *client_data),
void *client_data,
Z_RPNQuery *q)
{
WRBUF w = wrbuf_alloc();
int r = solr_transform_rpn2solr_stream_r(ct, w, pr, client_data, q);
if (r)
solr_transform_set_error(ct, r, wrbuf_len(w) ? wrbuf_cstr(w) : 0);
wrbuf_destroy(w);
return r;
}
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);
}
int yaz_marc_decode_buf (yaz_marc_t mt, const char *buf, int bsize,
const char **result, size_t *rsize)
{
int r;
wrbuf_rewind(mt->m_wr);
r = yaz_marc_decode_wrbuf(mt, buf, bsize, mt->m_wr);
if (result)
*result = wrbuf_cstr(mt->m_wr);
if (rsize)
*rsize = wrbuf_len(mt->m_wr);
return r;
}
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);
}
Z_RPNQuery *ccl_rpn_query (ODR o, struct ccl_rpn_node *p)
{
YAZ_PQF_Parser parser = yaz_pqf_create();
WRBUF wr = wrbuf_alloc();
Z_RPNQuery *q;
ccl_pquery(wr, p);
q = yaz_pqf_parse(parser, o, wrbuf_cstr(wr));
wrbuf_destroy(wr);
yaz_pqf_destroy(parser);
return q;
}
Z_AttributesPlusTerm *ccl_scan_query (ODR o, struct ccl_rpn_node *p)
{
YAZ_PQF_Parser parser = yaz_pqf_create();
WRBUF wr = wrbuf_alloc();
Z_AttributesPlusTerm *q;
Odr_oid *setp;
ccl_pquery(wr, p);
q = yaz_pqf_scan(parser, o, &setp, wrbuf_cstr(wr));
wrbuf_destroy(wr);
yaz_pqf_destroy(parser);
return q;
}
static const char *pp2_get_sort_ascii(pp2_charset_token_t prt)
{
if (prt->last_cp == 0)
return 0;
else
{
char *tmp = xstrdup(prt->last_cp);
char *result = 0;
result = normalize7bit_mergekey(tmp);
wrbuf_rewind(prt->sort_str);
wrbuf_puts(prt->sort_str, result);
xfree(tmp);
return wrbuf_cstr(prt->sort_str);
}
}
void xmlquerytopqf(const char *xmlstr)
{
xmlDocPtr doc;
doc = xmlParseMemory(xmlstr, strlen(xmlstr));
if (!doc)
{
fprintf(stderr, "%s: xml parse error for XML:\n%s\n", prog, xmlstr);
exit(1);
}
else
{
int error_code = 0;
const char *addinfo = 0;
Z_Query *query = 0;
ODR odr = odr_createmem(ODR_ENCODE);
const xmlNode *root_element = xmlDocGetRootElement(doc);
yaz_xml2query(root_element, &query, odr, &error_code, &addinfo);
if (error_code)
{
fprintf(stderr, "%s: yaz_xml2query failed code=%d addinfo=%s\n",
prog, error_code, addinfo);
exit(1);
}
else if (!query)
{
fprintf(stderr, "%s: yaz_xml2query no query result\n",
prog);
exit(1);
}
else
{
WRBUF w = wrbuf_alloc();
yaz_query_to_wrbuf(w, query);
printf("%s\n", wrbuf_cstr(w));
wrbuf_destroy(w);
}
odr_destroy(odr);
xmlFreeDoc(doc);
}
}
static void marcdump_read_line(yaz_marc_t mt, const char *fname)
{
FILE *inf = fopen(fname, "rb");
if (!inf)
{
fprintf(stderr, "%s: cannot open %s:%s\n",
prog, fname, strerror(errno));
exit(1);
}
while (yaz_marc_read_line(mt, getbyte_stream,
ungetbyte_stream, inf) == 0)
{
WRBUF wrbuf = wrbuf_alloc();
yaz_marc_write_mode(mt, wrbuf);
fputs(wrbuf_cstr(wrbuf), stdout);
wrbuf_destroy(wrbuf);
}
fclose(inf);
}
int expect_pqf(const char *pqf, const char *expect_pqf, int expect_error)
{
YAZ_PQF_Parser parser = yaz_pqf_create();
int res = 0;
ODR odr = odr_createmem(ODR_ENCODE);
Z_RPNQuery *rpn;
if (!parser)
return 0;
if (!odr)
return 0;
rpn = yaz_pqf_parse(parser, odr, pqf);
if (!rpn)
{
const char *msg;
size_t offset;
int got_error = yaz_pqf_error (parser, &msg, &offset);
if (expect_error == got_error)
res = 1;
}
else if (expect_error == YAZ_PQF_ERROR_NONE)
{
WRBUF wrbuf = wrbuf_alloc();
if (wrbuf)
{
yaz_rpnquery_to_wrbuf(wrbuf, rpn);
if (!strcmp(wrbuf_cstr(wrbuf), expect_pqf))
res = 1;
wrbuf_destroy(wrbuf);
}
}
yaz_pqf_destroy(parser);
odr_destroy(odr);
return res;
}
static struct json_node *do_parse_from_stdin(void)
{
FILE *f = stdin;
WRBUF w = wrbuf_alloc();
struct json_node *n;
size_t pos;
const char *json_str;
const char *err_msg;
int c;
while ((c = getc(f)) != EOF)
wrbuf_putc(w, c);
json_str = wrbuf_cstr(w);
n = json_parse2(json_str, &err_msg, &pos);
if (!n)
{
fprintf(stderr, "JSON parse error: %s\nLeading text was:\n", err_msg);
fwrite(json_str, 1, pos, stderr);
fprintf(stderr, "^\n");
}
wrbuf_destroy(w);
return n;
}
static void error(struct http_response *rs,
enum pazpar2_error_code code,
const char *addinfo)
{
struct http_channel *c = rs->channel;
WRBUF text = wrbuf_alloc();
const char *http_status = "417";
const char *msg = get_msg(code);
rs->msg = nmem_strdup(c->nmem, msg);
strcpy(rs->code, http_status);
wrbuf_printf(text, HTTP_COMMAND_RESPONSE_PREFIX "<error code=\"%d\" msg=\"%s\">", (int) code,
msg);
if (addinfo)
wrbuf_xmlputs(text, addinfo);
wrbuf_puts(text, "</error>");
yaz_log(YLOG_WARN, "HTTP %s %s%s%s", http_status,
msg, addinfo ? ": " : "" , addinfo ? addinfo : "");
rs->payload = nmem_strdup(c->nmem, wrbuf_cstr(text));
wrbuf_destroy(text);
http_send_response(c);
}
static int yaz_marc_write_xml_turbo_xml(yaz_marc_t mt, xmlNode **root_ptr,
const char *ns,
const char *format,
const char *type)
{
struct yaz_marc_node *n;
int identifier_length;
const char *leader = 0;
xmlNode *record_ptr;
xmlNsPtr ns_record;
WRBUF wr_cdata = 0;
for (n = mt->nodes; n; n = n->next)
if (n->which == YAZ_MARC_LEADER)
{
leader = n->u.leader;
break;
}
if (!leader)
return -1;
if (!atoi_n_check(leader+11, 1, &identifier_length))
return -1;
wr_cdata = wrbuf_alloc();
record_ptr = xmlNewNode(0, BAD_CAST "r");
*root_ptr = record_ptr;
ns_record = xmlNewNs(record_ptr, BAD_CAST ns, 0);
xmlSetNs(record_ptr, ns_record);
if (format)
xmlNewProp(record_ptr, BAD_CAST "format", BAD_CAST format);
if (type)
xmlNewProp(record_ptr, BAD_CAST "type", BAD_CAST type);
for (n = mt->nodes; n; n = n->next)
{
xmlNode *ptr;
char field[10];
field[0] = 'c';
field[4] = '\0';
switch(n->which)
{
case YAZ_MARC_DATAFIELD:
add_marc_datafield_turbo_xml(mt, n, record_ptr, ns_record, wr_cdata, identifier_length);
break;
case YAZ_MARC_CONTROLFIELD:
wrbuf_rewind(wr_cdata);
wrbuf_iconv_puts(wr_cdata, mt->iconv_cd, n->u.controlfield.data);
marc_iconv_reset(mt, wr_cdata);
strncpy(field + 1, n->u.controlfield.tag, 3);
ptr = xmlNewTextChild(record_ptr, ns_record,
BAD_CAST field,
BAD_CAST wrbuf_cstr(wr_cdata));
break;
case YAZ_MARC_COMMENT:
ptr = xmlNewComment(BAD_CAST n->u.comment);
xmlAddChild(record_ptr, ptr);
break;
case YAZ_MARC_LEADER:
xmlNewTextChild(record_ptr, ns_record, BAD_CAST "l",
BAD_CAST n->u.leader);
break;
}
}
wrbuf_destroy(wr_cdata);
return 0;
}
int yaz_marc_write_xml(yaz_marc_t mt, xmlNode **root_ptr,
const char *ns,
const char *format,
const char *type)
{
struct yaz_marc_node *n;
int identifier_length;
const char *leader = 0;
xmlNode *record_ptr;
xmlNsPtr ns_record;
WRBUF wr_cdata = 0;
for (n = mt->nodes; n; n = n->next)
if (n->which == YAZ_MARC_LEADER)
{
leader = n->u.leader;
break;
}
if (!leader)
return -1;
if (!atoi_n_check(leader+11, 1, &identifier_length))
return -1;
wr_cdata = wrbuf_alloc();
record_ptr = xmlNewNode(0, BAD_CAST "record");
*root_ptr = record_ptr;
ns_record = xmlNewNs(record_ptr, BAD_CAST ns, 0);
xmlSetNs(record_ptr, ns_record);
if (format)
xmlNewProp(record_ptr, BAD_CAST "format", BAD_CAST format);
if (type)
xmlNewProp(record_ptr, BAD_CAST "type", BAD_CAST type);
for (n = mt->nodes; n; n = n->next)
{
struct yaz_marc_subfield *s;
xmlNode *ptr;
switch(n->which)
{
case YAZ_MARC_DATAFIELD:
ptr = xmlNewChild(record_ptr, ns_record, BAD_CAST "datafield", 0);
xmlNewProp(ptr, BAD_CAST "tag", BAD_CAST n->u.datafield.tag);
if (n->u.datafield.indicator)
{
int i;
for (i = 0; n->u.datafield.indicator[i]; i++)
{
char ind_str[6];
char ind_val[2];
sprintf(ind_str, "ind%d", i+1);
ind_val[0] = n->u.datafield.indicator[i];
ind_val[1] = '\0';
xmlNewProp(ptr, BAD_CAST ind_str, BAD_CAST ind_val);
}
}
for (s = n->u.datafield.subfields; s; s = s->next)
{
xmlNode *ptr_subfield;
size_t using_code_len = get_subfield_len(mt, s->code_data,
identifier_length);
wrbuf_rewind(wr_cdata);
wrbuf_iconv_puts(wr_cdata, mt->iconv_cd,
s->code_data + using_code_len);
marc_iconv_reset(mt, wr_cdata);
ptr_subfield = xmlNewTextChild(
ptr, ns_record,
BAD_CAST "subfield", BAD_CAST wrbuf_cstr(wr_cdata));
wrbuf_rewind(wr_cdata);
wrbuf_iconv_write(wr_cdata, mt->iconv_cd,
s->code_data, using_code_len);
xmlNewProp(ptr_subfield, BAD_CAST "code",
BAD_CAST wrbuf_cstr(wr_cdata));
}
break;
case YAZ_MARC_CONTROLFIELD:
wrbuf_rewind(wr_cdata);
wrbuf_iconv_puts(wr_cdata, mt->iconv_cd, n->u.controlfield.data);
marc_iconv_reset(mt, wr_cdata);
ptr = xmlNewTextChild(record_ptr, ns_record,
BAD_CAST "controlfield",
BAD_CAST wrbuf_cstr(wr_cdata));
xmlNewProp(ptr, BAD_CAST "tag", BAD_CAST n->u.controlfield.tag);
break;
case YAZ_MARC_COMMENT:
ptr = xmlNewComment(BAD_CAST n->u.comment);
xmlAddChild(record_ptr, ptr);
break;
case YAZ_MARC_LEADER:
xmlNewTextChild(record_ptr, ns_record, BAD_CAST "leader",
BAD_CAST n->u.leader);
break;
}
}
wrbuf_destroy(wr_cdata);
return 0;
}
int yaz_marc_read_line(yaz_marc_t mt,
int (*getbyte)(void *client_data),
void (*ungetbyte)(int b, void *client_data),
void *client_data)
{
int indicator_length;
int identifier_length;
int base_address;
int length_data_entry;
int length_starting;
int length_implementation;
int marker_ch = 0;
int marker_skip = 0;
int header_created = 0;
WRBUF wrbuf_line = wrbuf_alloc();
yaz_marc_reset(mt);
while (yaz_marc_line_gets(getbyte, ungetbyte, client_data, wrbuf_line))
{
const char *line = wrbuf_cstr(wrbuf_line);
int val;
size_t line_len = strlen(line);
if (line_len == 0) /* empty line indicates end of record */
{
if (header_created)
break;
}
else if (line[0] == '$') /* indicates beginning/end of record */
{
if (header_created)
break;
}
else if (line[0] == '(') /* annotation, skip it */
;
else if (line_len == 24 && atoi_n_check(line, 5, &val))
{
/* deal with header lines: 00366nam 22001698a 4500
*/
if (header_created)
break;
yaz_marc_set_leader(mt, line,
&indicator_length,
&identifier_length,
&base_address,
&length_data_entry,
&length_starting,
&length_implementation);
header_created = 1;
}
else if (line_len > 4 && line[0] != ' ' && line[1] != ' '
&& line[2] != ' ' && line[3] == ' ' )
{
/* deal with data/control lines: 245 12 ........ */
char tag[4];
const char *datafield_start = line+6;
marker_ch = 0;
marker_skip = 0;
memcpy(tag, line, 3);
tag[3] = '\0';
if (line_len >= 8) /* control - or datafield ? */
{
if (*datafield_start == ' ')
datafield_start++; /* skip blank after indicator */
if (strchr("$_*", *datafield_start))
{
marker_ch = *datafield_start;
if (datafield_start[2] == ' ')
marker_skip = 1; /* subfields has blank before data */
}
}
if (!header_created)
{
const char *leader = "01000cam 2200265 i 4500";
yaz_marc_set_leader(mt, leader,
&indicator_length,
&identifier_length,
&base_address,
&length_data_entry,
&length_starting,
&length_implementation);
header_created = 1;
}
if (marker_ch == 0)
{ /* control field */
yaz_marc_add_controlfield(mt, tag, line+4, strlen(line+4));
}
else
{ /* data field */
const char *indicator = line+4;
int indicator_len = 2;
const char *cp = datafield_start;
yaz_marc_add_datafield(mt, tag, indicator, indicator_len);
for (;;)
{
const char *next;
size_t len;
assert(cp[0] == marker_ch);
cp++;
next = cp;
while ((next = strchr(next, marker_ch)))
{
if ((next[1] >= 'A' && next[1] <= 'Z')
||(next[1] >= 'a' && next[1] <= 'z')
||(next[1] >= '0' && next[1] <= '9'))
{
if (!marker_skip)
break;
else if (next[2] == ' ')
break;
}
next++;
}
len = strlen(cp);
if (next)
len = next - cp - marker_skip;
if (marker_skip)
{
/* remove ' ' after subfield marker */
char *cp_blank = strchr(cp, ' ');
if (cp_blank)
{
len--;
while (cp_blank != cp)
{
cp_blank[0] = cp_blank[-1];
cp_blank--;
}
cp++;
}
}
yaz_marc_add_subfield(mt, cp, len);
if (!next)
break;
cp = next;
}
}
}
else
{
yaz_marc_cprintf(mt, "Ignoring line: %s", line);
}
}
wrbuf_destroy(wrbuf_line);
if (!header_created)
return -1;
return 0;
}
const char *yaz_record_conv_get_error(yaz_record_conv_t p)
{
return wrbuf_cstr(p->wr_error);
}
normalize_record_t normalize_record_create(struct conf_service *service,
const char *spec)
{
NMEM nmem = nmem_create();
normalize_record_t nt = nmem_malloc(nmem, sizeof(*nt));
struct normalize_step **m = &nt->steps;
int no_errors = 0;
int embed = 0;
if (*spec == '<')
embed = 1;
nt->nmem = nmem;
if (embed)
{
xmlDoc *xsp_doc = xmlParseMemory(spec, strlen(spec));
if (!xsp_doc)
no_errors++;
{
*m = nmem_malloc(nt->nmem, sizeof(**m));
(*m)->marcmap = NULL;
(*m)->stylesheet = NULL;
(*m)->stylesheet2 = NULL;
(*m)->stylesheet = xsltParseStylesheetDoc(xsp_doc);
if (!(*m)->stylesheet)
no_errors++;
m = &(*m)->next;
}
}
else
{
struct conf_config *conf = service->server->config;
int i, num;
char **stylesheets;
nmem_strsplit(nt->nmem, ",", spec, &stylesheets, &num);
for (i = 0; i < num; i++)
{
WRBUF fname = conf_get_fname(conf, stylesheets[i]);
*m = nmem_malloc(nt->nmem, sizeof(**m));
(*m)->marcmap = NULL;
(*m)->stylesheet = NULL;
(*m)->stylesheet2 = service_xslt_get(service, stylesheets[i]);
if ((*m)->stylesheet2)
;
else if (!strcmp(&stylesheets[i][strlen(stylesheets[i])-4], ".xsl"))
{
if (!((*m)->stylesheet =
xsltParseStylesheetFile((xmlChar *) wrbuf_cstr(fname))))
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "Unable to load stylesheet: %s",
stylesheets[i]);
no_errors++;
}
}
else if (!strcmp(&stylesheets[i][strlen(stylesheets[i])-5], ".mmap"))
{
if (!((*m)->marcmap = marcmap_load(wrbuf_cstr(fname), nt->nmem)))
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "Unable to load marcmap: %s",
stylesheets[i]);
no_errors++;
}
}
else
{
yaz_log(YLOG_FATAL, "Cannot handle stylesheet: %s", stylesheets[i]);
no_errors++;
}
wrbuf_destroy(fname);
m = &(*m)->next;
}
}
*m = 0; /* terminate list of steps */
if (no_errors)
{
normalize_record_destroy(nt);
nt = 0;
}
return nt;
}
