-/* $Id: util.cpp,v 1.13 2006-01-20 22:38:12 marc Exp $
- Copyright (c) 2005, Index Data.
+/* $Id: util.cpp,v 1.23 2006-10-04 14:04:00 marc Exp $
+ Copyright (c) 2005-2006, Index Data.
-%LICENSE%
+ See the LICENSE file for details
*/
#include "config.hpp"
+#include "util.hpp"
#include <yaz/odr.h>
#include <yaz/pquery.h>
#include <yaz/otherinfo.h>
#include <yaz/querytowrbuf.h> // for yaz_query_to_wrbuf()
-#include "util.hpp"
-//#include <iostream>
+#include <iostream>
+
+namespace mp = metaproxy_1;
+
+// Doxygen doesn't like mp::util, so we use this instead
+namespace mp_util = metaproxy_1::util;
-void yp2::util::piggyback(int smallSetUpperBound,
- int largeSetLowerBound,
- int mediumSetPresentNumber,
- int result_set_size,
- int &number_to_present)
+const char *
+mp_util::record_composition_to_esn(Z_RecordComposition *comp)
+{
+ if (comp && comp->which == Z_RecordComp_complex)
+ {
+ if (comp->u.complex->generic
+ && comp->u.complex->generic->elementSpec
+ && (comp->u.complex->generic->elementSpec->which ==
+ Z_ElementSpec_elementSetName))
+ return comp->u.complex->generic->elementSpec->u.elementSetName;
+ }
+ else if (comp && comp->which == Z_RecordComp_simple &&
+ comp->u.simple->which == Z_ElementSetNames_generic)
+ return comp->u.simple->u.generic;
+ return 0;
+}
+
+
+
+std::string mp_util::http_header_value(const Z_HTTP_Header* header,
+ const std::string name)
+{
+ while (header && header->name
+ && std::string(header->name) != name)
+ header = header->next;
+
+ if (header && header->name && std::string(header->name) == name
+ && header->value)
+ return std::string(header->value);
+
+ return std::string();
+}
+
+std::string mp_util::http_headers_debug(const Z_HTTP_Request &http_req)
+{
+ std::string message("<html>\n<body>\n<h1>"
+ "Metaproxy SRUtoZ3950 filter"
+ "</h1>\n");
+
+ message += "<h3>HTTP Info</h3><br/>\n";
+ message += "<p>\n";
+ message += "<b>Method: </b> " + std::string(http_req.method) + "<br/>\n";
+ message += "<b>Version:</b> " + std::string(http_req.version) + "<br/>\n";
+ message += "<b>Path: </b> " + std::string(http_req.path) + "<br/>\n";
+
+ message += "<b>Content-Type:</b>"
+ + mp_util::http_header_value(http_req.headers, "Content-Type")
+ + "<br/>\n";
+ message += "<b>Content-Length:</b>"
+ + mp_util::http_header_value(http_req.headers, "Content-Length")
+ + "<br/>\n";
+ message += "</p>\n";
+
+ message += "<h3>Headers</h3><br/>\n";
+ message += "<p>\n";
+ Z_HTTP_Header* header = http_req.headers;
+ while (header){
+ message += "<b>Header: </b> <i>"
+ + std::string(header->name) + ":</i> "
+ + std::string(header->value) + "<br/>\n";
+ header = header->next;
+ }
+ message += "</p>\n";
+ message += "</body>\n</html>\n";
+ return message;
+}
+
+
+void mp_util::http_response(metaproxy_1::Package &package,
+ const std::string &content,
+ int http_code)
+{
+
+ Z_GDU *zgdu_req = package.request().get();
+ Z_GDU *zgdu_res = 0;
+ mp::odr odr;
+ zgdu_res
+ = odr.create_HTTP_Response(package.session(),
+ zgdu_req->u.HTTP_Request,
+ http_code);
+
+ zgdu_res->u.HTTP_Response->content_len = content.size();
+ zgdu_res->u.HTTP_Response->content_buf
+ = (char*) odr_malloc(odr, zgdu_res->u.HTTP_Response->content_len);
+
+ strncpy(zgdu_res->u.HTTP_Response->content_buf,
+ content.c_str(), zgdu_res->u.HTTP_Response->content_len);
+
+ //z_HTTP_header_add(odr, &hres->headers,
+ // "Content-Type", content_type.c_str());
+ package.response() = zgdu_res;
+}
+
+
+int mp_util::memcmp2(const void *buf1, int len1,
+ const void *buf2, int len2)
+{
+ int d = len1 - len2;
+
+ // compare buffer (common length)
+ int c = memcmp(buf1, buf2, d > 0 ? len2 : len1);
+ if (c > 0)
+ return 1;
+ else if (c < 0)
+ return -1;
+
+ // compare (remaining bytes)
+ if (d > 0)
+ return 1;
+ else if (d < 0)
+ return -1;
+ return 0;
+}
+
+
+std::string mp_util::database_name_normalize(const std::string &s)
+{
+ std::string r = s;
+ size_t i;
+ for (i = 0; i < r.length(); i++)
+ {
+ int ch = r[i];
+ if (ch >= 'A' && ch <= 'Z')
+ r[i] = ch + 'a' - 'A';
+ }
+ return r;
+
+}
+
+void mp_util::piggyback(int smallSetUpperBound,
+ int largeSetLowerBound,
+ int mediumSetPresentNumber,
+ int result_set_size,
+ int &number_to_present)
{
// deal with piggyback
}
-bool yp2::util::pqf(ODR odr, Z_APDU *apdu, const std::string &q) {
+bool mp_util::pqf(ODR odr, Z_APDU *apdu, const std::string &q)
+{
YAZ_PQF_Parser pqf_parser = yaz_pqf_create();
Z_RPNQuery *rpn = yaz_pqf_parse(pqf_parser, odr, q.c_str());
}
-std::string yp2::util::zQueryToString(Z_Query *query)
+std::string mp_util::zQueryToString(Z_Query *query)
{
std::string query_str = "";
return query_str;
}
-void yp2::util::get_default_diag(Z_DefaultDiagFormat *r,
- int &error_code, std::string &addinfo)
+void mp_util::get_default_diag(Z_DefaultDiagFormat *r,
+ int &error_code, std::string &addinfo)
{
error_code = *r->condition;
switch (r->which)
}
}
-void yp2::util::get_init_diagnostics(Z_InitResponse *initrs,
- int &error_code, std::string &addinfo)
+void mp_util::get_init_diagnostics(
+ Z_InitResponse *initrs, int &error_code, std::string &addinfo)
{
Z_External *uif = initrs->userInformationField;
{
Z_DiagnosticFormat_s *ds = diag->elements[0];
if (ds->which == Z_DiagnosticFormat_s_defaultDiagRec)
- yp2::util::get_default_diag(ds->u.defaultDiagRec,
+ mp::util::get_default_diag(ds->u.defaultDiagRec,
error_code, addinfo);
}
}
}
}
-int yp2::util::get_vhost_otherinfo(Z_OtherInformation **otherInformation,
- bool remove_flag,
- std::list<std::string> &vhosts)
+int mp_util::get_or_remove_vhost_otherinfo(
+ Z_OtherInformation **otherInformation,
+ bool remove_flag,
+ std::list<std::string> &vhosts)
{
int cat;
for (cat = 1; ; cat++)
return cat;
}
-void yp2::util::set_vhost_otherinfo(Z_OtherInformation **otherInformation,
- ODR odr,
- const std::list<std::string> &vhosts)
+void mp_util::get_vhost_otherinfo(
+ Z_OtherInformation *otherInformation,
+ std::list<std::string> &vhosts)
+{
+ get_or_remove_vhost_otherinfo(&otherInformation, false, vhosts);
+}
+
+int mp_util::remove_vhost_otherinfo(
+ Z_OtherInformation **otherInformation,
+ std::list<std::string> &vhosts)
+{
+ return get_or_remove_vhost_otherinfo(otherInformation, true, vhosts);
+}
+
+void mp_util::set_vhost_otherinfo(
+ Z_OtherInformation **otherInformation, ODR odr,
+ const std::list<std::string> &vhosts)
{
int cat;
std::list<std::string>::const_iterator it = vhosts.begin();
}
}
-void yp2::util::split_zurl(std::string zurl, std::string &host,
- std::list<std::string> &db)
+void mp_util::split_zurl(std::string zurl, std::string &host,
+ std::list<std::string> &db)
{
const char *zurl_cstr = zurl.c_str();
const char *sep = strchr(zurl_cstr, '/');
}
}
-bool yp2::util::set_databases_from_zurl(ODR odr, std::string zurl,
- int *db_num, char ***db_strings)
+bool mp_util::set_databases_from_zurl(
+ ODR odr, std::string zurl,
+ int *db_num, char ***db_strings)
{
std::string host;
std::list<std::string> dblist;
return true;
}
-yp2::odr::odr(int type)
+mp::odr::odr(int type)
{
m_odr = odr_createmem(type);
}
-yp2::odr::odr()
+mp::odr::odr()
{
m_odr = odr_createmem(ODR_ENCODE);
}
-yp2::odr::~odr()
+mp::odr::~odr()
{
odr_destroy(m_odr);
}
-yp2::odr::operator ODR() const
+mp::odr::operator ODR() const
{
return m_odr;
}
-Z_APDU *yp2::odr::create_close(Z_APDU *in_apdu,
- int reason, const char *addinfo)
+Z_APDU *mp::odr::create_close(const Z_APDU *in_apdu,
+ int reason, const char *addinfo)
{
Z_APDU *apdu = create_APDU(Z_APDU_close, in_apdu);
return apdu;
}
-Z_APDU *yp2::odr::create_APDU(int type, Z_APDU *in_apdu)
+Z_APDU *mp::odr::create_APDU(int type, const Z_APDU *in_apdu)
{
- return yp2::util::create_APDU(m_odr, type, in_apdu);
+ return mp::util::create_APDU(m_odr, type, in_apdu);
}
-Z_APDU *yp2::util::create_APDU(ODR odr, int type, Z_APDU *in_apdu)
+Z_APDU *mp_util::create_APDU(ODR odr, int type, const Z_APDU *in_apdu)
{
Z_APDU *out_apdu = zget_APDU(odr, type);
+ transfer_referenceId(odr, in_apdu, out_apdu);
+ return out_apdu;
+}
- Z_ReferenceId **id_to = yp2::util::get_referenceId(out_apdu);
+void mp_util::transfer_referenceId(ODR odr, const Z_APDU *src, Z_APDU *dst)
+{
+ Z_ReferenceId **id_to = mp::util::get_referenceId(dst);
*id_to = 0;
- if (in_apdu)
+ if (src)
{
- Z_ReferenceId **id_from = yp2::util::get_referenceId(in_apdu);
+ Z_ReferenceId **id_from = mp::util::get_referenceId(src);
if (id_from && *id_from && id_to)
{
*id_to = (Z_ReferenceId*) odr_malloc (odr, sizeof(**id_to));
else if (id_to)
*id_to = 0;
}
- return out_apdu;
}
-Z_APDU *yp2::odr::create_initResponse(Z_APDU *in_apdu,
- int error, const char *addinfo)
+Z_APDU *mp::odr::create_initResponse(const Z_APDU *in_apdu,
+ int error, const char *addinfo)
{
Z_APDU *apdu = create_APDU(Z_APDU_initResponse, in_apdu);
if (error)
return apdu;
}
-Z_APDU *yp2::odr::create_searchResponse(Z_APDU *in_apdu,
- int error, const char *addinfo)
+Z_APDU *mp::odr::create_searchResponse(const Z_APDU *in_apdu,
+ int error, const char *addinfo)
{
Z_APDU *apdu = create_APDU(Z_APDU_searchResponse, in_apdu);
if (error)
return apdu;
}
-Z_APDU *yp2::odr::create_presentResponse(Z_APDU *in_apdu,
- int error, const char *addinfo)
+Z_APDU *mp::odr::create_presentResponse(const Z_APDU *in_apdu,
+ int error, const char *addinfo)
{
Z_APDU *apdu = create_APDU(Z_APDU_presentResponse, in_apdu);
if (error)
return apdu;
}
-Z_APDU *yp2::odr::create_scanResponse(Z_APDU *in_apdu,
- int error, const char *addinfo)
+Z_APDU *mp::odr::create_scanResponse(const Z_APDU *in_apdu,
+ int error, const char *addinfo)
{
Z_APDU *apdu = create_APDU(Z_APDU_scanResponse, in_apdu);
Z_ScanResponse *res = apdu->u.scanResponse;
return apdu;
}
-Z_GDU *yp2::odr::create_HTTP_Response(yp2::Session &session,
- Z_HTTP_Request *hreq, int code)
+Z_GDU *mp::odr::create_HTTP_Response(mp::Session &session,
+ Z_HTTP_Request *hreq, int code)
{
const char *response_version = "1.0";
bool keepalive = false;
return gdu;
}
-Z_ReferenceId **yp2::util::get_referenceId(Z_APDU *apdu)
+Z_ReferenceId **mp_util::get_referenceId(const Z_APDU *apdu)
{
switch (apdu->which)
{