-/* $Id: util.cpp,v 1.17 2006-06-10 14:29:13 adam Exp $
- Copyright (c) 2005-2006, Index Data.
+/* This file is part of Metaproxy.
+ Copyright (C) 2005-2009 Index Data
- See the LICENSE file for details
- */
+Metaproxy is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Metaproxy is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
#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 <yaz/querytowrbuf.h>
+#include <yaz/oid_db.h>
-//#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;
+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)
{
query_str = std::string(wrbuf_buf(w), wrbuf_len(w));
// destroy wrbuf
- wrbuf_free(w, 1);
+ wrbuf_destroy(w);
}
}
}
}
-int mp_util::get_vhost_otherinfo(
+int mp_util::get_or_remove_vhost_otherinfo(
Z_OtherInformation **otherInformation,
bool remove_flag,
std::list<std::string> &vhosts)
{
// check virtual host
const char *vhost =
- yaz_oi_get_string_oidval(otherInformation,
- VAL_PROXY,
- cat /* categoryValue */,
- remove_flag /* delete flag */);
+ yaz_oi_get_string_oid(otherInformation,
+ yaz_oid_userinfo_proxy,
+ cat /* categoryValue */,
+ remove_flag /* delete flag */);
if (!vhost)
break;
vhosts.push_back(std::string(vhost));
return cat;
}
+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();
+
for (cat = 1; it != vhosts.end() ; cat++, it++)
{
- yaz_oi_set_string_oidval(otherInformation, odr,
- VAL_PROXY, cat, it->c_str());
+ yaz_oi_set_string_oid(otherInformation, odr,
+ yaz_oid_userinfo_proxy, cat, it->c_str());
}
}
+void mp_util::set_vhost_otherinfo(
+ Z_OtherInformation **otherInformation, ODR odr,
+ const std::string vhost, const int cat)
+{
+ yaz_oi_set_string_oid(otherInformation, odr,
+ yaz_oid_userinfo_proxy, cat, vhost.c_str());
+}
+
void mp_util::split_zurl(std::string zurl, std::string &host,
- std::list<std::string> &db)
+ std::list<std::string> &db)
{
const char *zurl_cstr = zurl.c_str();
const char *sep = strchr(zurl_cstr, '/');
return m_odr;
}
-Z_APDU *mp::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 *mp::odr::create_APDU(int type, Z_APDU *in_apdu)
+Z_APDU *mp::odr::create_APDU(int type, const Z_APDU *in_apdu)
{
return mp::util::create_APDU(m_odr, type, in_apdu);
}
-Z_APDU *mp_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 = mp::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 = mp::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 *mp::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 *mp::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 *mp::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 *mp::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;
}
Z_GDU *mp::odr::create_HTTP_Response(mp::Session &session,
- Z_HTTP_Request *hreq, int code)
+ Z_HTTP_Request *hreq, int code)
{
const char *response_version = "1.0";
bool keepalive = false;
return gdu;
}
-Z_ReferenceId **mp_util::get_referenceId(Z_APDU *apdu)
+Z_ReferenceId **mp_util::get_referenceId(const Z_APDU *apdu)
{
switch (apdu->which)
{
/*
* Local variables:
* c-basic-offset: 4
+ * c-file-style: "Stroustrup"
* indent-tabs-mode: nil
- * c-file-style: "stroustrup"
* End:
* vim: shiftwidth=4 tabstop=8 expandtab
*/
+
projects / metaproxy-moved-to-github.git / blobdiff