src/util.cpp

   1 /* $Id: util.cpp,v 1.17 2006-06-10 14:29:13 adam Exp $
   2    Copyright (c) 2005-2006, Index Data.
   3
   4    See the LICENSE file for details
   5  */
   6
   7 #include "config.hpp"
   8
   9 #include <yaz/odr.h>
  10 #include <yaz/pquery.h>
  11 #include <yaz/otherinfo.h>
  12 #include <yaz/querytowrbuf.h> // for yaz_query_to_wrbuf()
  13 #include "util.hpp"
  14
  15 //#include <iostream>
  16
  17 namespace mp = metaproxy_1;
  18
  19 // Doxygen doesn't like mp::util, so we use this instead
  20 namespace mp_util = metaproxy_1::util;
  21
  22 int mp_util::memcmp2(const void *buf1, int len1,
  23                      const void *buf2, int len2)
  24 {
  25     int d = len1 - len2;
  26
  27     // compare buffer (common length)
  28     int c = memcmp(buf1, buf2, d > 0 ? len2 : len1);
  29     if (c > 0)
  30         return 1;
  31     else if (c < 0)
  32         return -1;
  33
  34     // compare (remaining bytes)
  35     if (d > 0)
  36         return 1;
  37     else if (d < 0)
  38         return -1;
  39     return 0;
  40 }
  41
  42
  43 std::string mp_util::database_name_normalize(const std::string &s)
  44 {
  45     std::string r = s;
  46     size_t i;
  47     for (i = 0; i < r.length(); i++)
  48     {
  49         int ch = r[i];
  50         if (ch >= 'A' && ch <= 'Z')
  51             r[i] = ch + 'a' - 'A';
  52     }
  53     return r;
  54
  55 }
  56
  57 void mp_util::piggyback(int smallSetUpperBound,
  58                                   int largeSetLowerBound,
  59                                   int mediumSetPresentNumber,
  60                                   int result_set_size,
  61                                   int &number_to_present)
  62 {
  63     // deal with piggyback
  64
  65     if (result_set_size < smallSetUpperBound)
  66     {
  67         // small set . Return all records in set
  68         number_to_present = result_set_size;
  69     }
  70     else if (result_set_size > largeSetLowerBound)
  71     {
  72         // large set . Return no records
  73         number_to_present = 0;
  74     }
  75     else
  76     {
  77         // medium set . Return mediumSetPresentNumber records
  78         number_to_present = mediumSetPresentNumber;
  79         if (number_to_present > result_set_size)
  80             number_to_present = result_set_size;
  81     }
  82 }
  83
  84
  85 bool mp_util::pqf(ODR odr, Z_APDU *apdu, const std::string &q)
  86 {
  87     YAZ_PQF_Parser pqf_parser = yaz_pqf_create();
  88
  89     Z_RPNQuery *rpn = yaz_pqf_parse(pqf_parser, odr, q.c_str());
  90     if (!rpn)
  91     {
  92         yaz_pqf_destroy(pqf_parser);
  93         return false;
  94     }
  95     yaz_pqf_destroy(pqf_parser);
  96     Z_Query *query = (Z_Query *) odr_malloc(odr, sizeof(Z_Query));
  97     query->which = Z_Query_type_1;
  98     query->u.type_1 = rpn;
  99
 100     apdu->u.searchRequest->query = query;
 101     return true;
 102 }
 103
 104
 105 std::string mp_util::zQueryToString(Z_Query *query)
 106 {
 107     std::string query_str = "";
 108
 109     if (query && query->which == Z_Query_type_1){
 110         Z_RPNQuery *rpn = query->u.type_1;
 111
 112         if (rpn){
 113
 114             // allocate wrbuf (strings in YAZ!)
 115             WRBUF w = wrbuf_alloc();
 116
 117             // put query in w
 118             yaz_rpnquery_to_wrbuf(w, rpn);
 119
 120             // from w to std::string
 121             query_str = std::string(wrbuf_buf(w), wrbuf_len(w));
 122
 123             // destroy wrbuf
 124             wrbuf_free(w, 1);
 125         }
 126     }
 127
 128 #if 0
 129     if (query && query->which == Z_Query_type_1){
 130
 131         // allocate wrbuf (strings in YAZ!)
 132         WRBUF w = wrbuf_alloc();
 133
 134         // put query in w
 135         yaz_query_to_wrbuf(w, query);
 136
 137         // from w to std::string
 138         query_str = std::string(wrbuf_buf(w), wrbuf_len(w));
 139
 140         // destroy wrbuf
 141         wrbuf_free(w, 1);
 142     }
 143 #endif
 144     return query_str;
 145 }
 146
 147 void mp_util::get_default_diag(Z_DefaultDiagFormat *r,
 148                                          int &error_code, std::string &addinfo)
 149 {
 150     error_code = *r->condition;
 151     switch (r->which)
 152     {
 153     case Z_DefaultDiagFormat_v2Addinfo:
 154         addinfo = std::string(r->u.v2Addinfo);
 155         break;
 156     case Z_DefaultDiagFormat_v3Addinfo:
 157         addinfo = r->u.v3Addinfo;
 158         break;
 159     }
 160 }
 161
 162 void mp_util::get_init_diagnostics(
 163     Z_InitResponse *initrs, int &error_code, std::string &addinfo)
 164 {
 165     Z_External *uif = initrs->userInformationField;
 166
 167     if (uif && uif->which == Z_External_userInfo1)
 168     {
 169         Z_OtherInformation *ui = uif->u.userInfo1;
 170         int i;
 171         for (i = 0; i < ui->num_elements; i++)
 172         {
 173             Z_OtherInformationUnit *unit = ui->list[i];
 174             if (unit->which == Z_OtherInfo_externallyDefinedInfo &&
 175                 unit->information.externallyDefinedInfo &&
 176                 unit->information.externallyDefinedInfo->which ==
 177                 Z_External_diag1)
 178             {
 179                 Z_DiagnosticFormat *diag =
 180                     unit->information.externallyDefinedInfo->u.diag1;
 181
 182                 if (diag->num > 0)
 183                 {
 184                     Z_DiagnosticFormat_s *ds = diag->elements[0];
 185                     if (ds->which == Z_DiagnosticFormat_s_defaultDiagRec)
 186                         mp::util::get_default_diag(ds->u.defaultDiagRec,
 187                                                     error_code, addinfo);
 188                 }
 189             }
 190         }
 191     }
 192 }
 193
 194 int mp_util::get_vhost_otherinfo(
 195     Z_OtherInformation **otherInformation,
 196     bool remove_flag,
 197     std::list<std::string> &vhosts)
 198 {
 199     int cat;
 200     for (cat = 1; ; cat++)
 201     {
 202         // check virtual host
 203         const char *vhost =
 204             yaz_oi_get_string_oidval(otherInformation,
 205                                      VAL_PROXY,
 206                                      cat /* categoryValue */,
 207                                      remove_flag /* delete flag */);
 208         if (!vhost)
 209             break;
 210         vhosts.push_back(std::string(vhost));
 211     }
 212     --cat;
 213     return cat;
 214 }
 215
 216 void mp_util::set_vhost_otherinfo(
 217     Z_OtherInformation **otherInformation, ODR odr,
 218     const std::list<std::string> &vhosts)
 219 {
 220     int cat;
 221     std::list<std::string>::const_iterator it = vhosts.begin();
 222     for (cat = 1; it != vhosts.end() ; cat++, it++)
 223     {
 224         yaz_oi_set_string_oidval(otherInformation, odr,
 225                                  VAL_PROXY, cat, it->c_str());
 226     }
 227 }
 228
 229 void mp_util::split_zurl(std::string zurl, std::string &host,
 230                                    std::list<std::string> &db)
 231 {
 232     const char *zurl_cstr = zurl.c_str();
 233     const char *sep = strchr(zurl_cstr, '/');
 234
 235     if (sep)
 236     {
 237         host = std::string(zurl_cstr, sep - zurl_cstr);
 238
 239         const char *cp1 = sep+1;
 240         while(1)
 241         {
 242             const char *cp2 = strchr(cp1, '+');
 243             if (cp2)
 244                 db.push_back(std::string(cp1, cp2 - cp1));
 245             else
 246             {
 247                 db.push_back(std::string(cp1));
 248                 break;
 249             }
 250             cp1 = cp2+1;
 251         }
 252     }
 253     else
 254     {
 255         host = zurl;
 256     }
 257 }
 258
 259 bool mp_util::set_databases_from_zurl(
 260     ODR odr, std::string zurl,
 261     int *db_num, char ***db_strings)
 262 {
 263     std::string host;
 264     std::list<std::string> dblist;
 265
 266     split_zurl(zurl, host, dblist);
 267
 268     if (dblist.size() == 0)
 269         return false;
 270     *db_num = dblist.size();
 271     *db_strings = (char **) odr_malloc(odr, sizeof(char*) * (*db_num));
 272
 273     std::list<std::string>::const_iterator it = dblist.begin();
 274     for (int i = 0; it != dblist.end(); it++, i++)
 275         (*db_strings)[i] = odr_strdup(odr, it->c_str());
 276     return true;
 277 }
 278
 279 mp::odr::odr(int type)
 280 {
 281     m_odr = odr_createmem(type);
 282 }
 283
 284 mp::odr::odr()
 285 {
 286     m_odr = odr_createmem(ODR_ENCODE);
 287 }
 288
 289 mp::odr::~odr()
 290 {
 291     odr_destroy(m_odr);
 292 }
 293
 294 mp::odr::operator ODR() const
 295 {
 296     return m_odr;
 297 }
 298
 299 Z_APDU *mp::odr::create_close(Z_APDU *in_apdu,
 300                                int reason, const char *addinfo)
 301 {
 302     Z_APDU *apdu = create_APDU(Z_APDU_close, in_apdu);
 303
 304     *apdu->u.close->closeReason = reason;
 305     if (addinfo)
 306         apdu->u.close->diagnosticInformation = odr_strdup(m_odr, addinfo);
 307     return apdu;
 308 }
 309
 310 Z_APDU *mp::odr::create_APDU(int type, Z_APDU *in_apdu)
 311 {
 312     return mp::util::create_APDU(m_odr, type, in_apdu);
 313 }
 314
 315 Z_APDU *mp_util::create_APDU(ODR odr, int type, Z_APDU *in_apdu)
 316 {
 317     Z_APDU *out_apdu = zget_APDU(odr, type);
 318
 319     Z_ReferenceId **id_to = mp::util::get_referenceId(out_apdu);
 320     *id_to = 0;
 321     if (in_apdu)
 322     {
 323         Z_ReferenceId **id_from = mp::util::get_referenceId(in_apdu);
 324         if (id_from && *id_from && id_to)
 325         {
 326             *id_to = (Z_ReferenceId*) odr_malloc (odr, sizeof(**id_to));
 327             (*id_to)->size = (*id_to)->len = (*id_from)->len;
 328             (*id_to)->buf = (unsigned char*) odr_malloc(odr, (*id_to)->len);
 329             memcpy((*id_to)->buf, (*id_from)->buf, (*id_to)->len);
 330         }
 331         else if (id_to)
 332             *id_to = 0;
 333     }
 334     return out_apdu;
 335 }
 336
 337 Z_APDU *mp::odr::create_initResponse(Z_APDU *in_apdu,
 338                                       int error, const char *addinfo)
 339 {
 340     Z_APDU *apdu = create_APDU(Z_APDU_initResponse, in_apdu);
 341     if (error)
 342     {
 343         apdu->u.initResponse->userInformationField =
 344             zget_init_diagnostics(m_odr, error, addinfo);
 345         *apdu->u.initResponse->result = 0;
 346     }
 347     return apdu;
 348 }
 349
 350 Z_APDU *mp::odr::create_searchResponse(Z_APDU *in_apdu,
 351                                         int error, const char *addinfo)
 352 {
 353     Z_APDU *apdu = create_APDU(Z_APDU_searchResponse, in_apdu);
 354     if (error)
 355     {
 356         Z_Records *rec = (Z_Records *) odr_malloc(m_odr, sizeof(Z_Records));
 357         *apdu->u.searchResponse->searchStatus = 0;
 358         apdu->u.searchResponse->records = rec;
 359         rec->which = Z_Records_NSD;
 360         rec->u.nonSurrogateDiagnostic =
 361             zget_DefaultDiagFormat(m_odr, error, addinfo);
 362
 363     }
 364     return apdu;
 365 }
 366
 367 Z_APDU *mp::odr::create_presentResponse(Z_APDU *in_apdu,
 368                                          int error, const char *addinfo)
 369 {
 370     Z_APDU *apdu = create_APDU(Z_APDU_presentResponse, in_apdu);
 371     if (error)
 372     {
 373         Z_Records *rec = (Z_Records *) odr_malloc(m_odr, sizeof(Z_Records));
 374         apdu->u.presentResponse->records = rec;
 375
 376         rec->which = Z_Records_NSD;
 377         rec->u.nonSurrogateDiagnostic =
 378             zget_DefaultDiagFormat(m_odr, error, addinfo);
 379         *apdu->u.presentResponse->presentStatus = Z_PresentStatus_failure;
 380     }
 381     return apdu;
 382 }
 383
 384 Z_APDU *mp::odr::create_scanResponse(Z_APDU *in_apdu,
 385                                       int error, const char *addinfo)
 386 {
 387     Z_APDU *apdu = create_APDU(Z_APDU_scanResponse, in_apdu);
 388     Z_ScanResponse *res = apdu->u.scanResponse;
 389     res->entries = (Z_ListEntries *) odr_malloc(m_odr, sizeof(*res->entries));
 390     res->entries->num_entries = 0;
 391     res->entries->entries = 0;
 392
 393     if (error)
 394     {
 395         *res->scanStatus = Z_Scan_failure;
 396
 397         res->entries->num_nonsurrogateDiagnostics = 1;
 398         res->entries->nonsurrogateDiagnostics = (Z_DiagRec **)
 399             odr_malloc(m_odr, sizeof(Z_DiagRec *));
 400         res->entries->nonsurrogateDiagnostics[0] =
 401             zget_DiagRec(m_odr, error, addinfo);
 402     }
 403     else
 404     {
 405         res->entries->num_nonsurrogateDiagnostics = 0;
 406         res->entries->nonsurrogateDiagnostics = 0;
 407     }
 408     return apdu;
 409 }
 410
 411 Z_GDU *mp::odr::create_HTTP_Response(mp::Session &session,
 412                                       Z_HTTP_Request *hreq, int code)
 413 {
 414     const char *response_version = "1.0";
 415     bool keepalive = false;
 416     if (!strcmp(hreq->version, "1.0"))
 417     {
 418         const char *v = z_HTTP_header_lookup(hreq->headers, "Connection");
 419         if (v && !strcmp(v, "Keep-Alive"))
 420             keepalive = true;
 421         else
 422             session.close();
 423         response_version = "1.0";
 424     }
 425     else
 426     {
 427         const char *v = z_HTTP_header_lookup(hreq->headers, "Connection");
 428         if (v && !strcmp(v, "close"))
 429             session.close();
 430         else
 431             keepalive = true;
 432         response_version = "1.1";
 433     }
 434
 435     Z_GDU *gdu = z_get_HTTP_Response(m_odr, code);
 436     Z_HTTP_Response *hres = gdu->u.HTTP_Response;
 437     hres->version = odr_strdup(m_odr, response_version);
 438     if (keepalive)
 439         z_HTTP_header_add(m_odr, &hres->headers, "Connection", "Keep-Alive");
 440
 441     return gdu;
 442 }
 443
 444 Z_ReferenceId **mp_util::get_referenceId(Z_APDU *apdu)
 445 {
 446     switch (apdu->which)
 447     {
 448     case  Z_APDU_initRequest:
 449         return &apdu->u.initRequest->referenceId;
 450     case  Z_APDU_initResponse:
 451         return &apdu->u.initResponse->referenceId;
 452     case  Z_APDU_searchRequest:
 453         return &apdu->u.searchRequest->referenceId;
 454     case  Z_APDU_searchResponse:
 455         return &apdu->u.searchResponse->referenceId;
 456     case  Z_APDU_presentRequest:
 457         return &apdu->u.presentRequest->referenceId;
 458     case  Z_APDU_presentResponse:
 459         return &apdu->u.presentResponse->referenceId;
 460     case  Z_APDU_deleteResultSetRequest:
 461         return &apdu->u.deleteResultSetRequest->referenceId;
 462     case  Z_APDU_deleteResultSetResponse:
 463         return &apdu->u.deleteResultSetResponse->referenceId;
 464     case  Z_APDU_accessControlRequest:
 465         return &apdu->u.accessControlRequest->referenceId;
 466     case  Z_APDU_accessControlResponse:
 467         return &apdu->u.accessControlResponse->referenceId;
 468     case  Z_APDU_resourceControlRequest:
 469         return &apdu->u.resourceControlRequest->referenceId;
 470     case  Z_APDU_resourceControlResponse:
 471         return &apdu->u.resourceControlResponse->referenceId;
 472     case  Z_APDU_triggerResourceControlRequest:
 473         return &apdu->u.triggerResourceControlRequest->referenceId;
 474     case  Z_APDU_resourceReportRequest:
 475         return &apdu->u.resourceReportRequest->referenceId;
 476     case  Z_APDU_resourceReportResponse:
 477         return &apdu->u.resourceReportResponse->referenceId;
 478     case  Z_APDU_scanRequest:
 479         return &apdu->u.scanRequest->referenceId;
 480     case  Z_APDU_scanResponse:
 481         return &apdu->u.scanResponse->referenceId;
 482     case  Z_APDU_sortRequest:
 483         return &apdu->u.sortRequest->referenceId;
 484     case  Z_APDU_sortResponse:
 485         return &apdu->u.sortResponse->referenceId;
 486     case  Z_APDU_segmentRequest:
 487         return &apdu->u.segmentRequest->referenceId;
 488     case  Z_APDU_extendedServicesRequest:
 489         return &apdu->u.extendedServicesRequest->referenceId;
 490     case  Z_APDU_extendedServicesResponse:
 491         return &apdu->u.extendedServicesResponse->referenceId;
 492     case  Z_APDU_close:
 493         return &apdu->u.close->referenceId;
 494     }
 495     return 0;
 496 }
 497
 498
 499 /*
 500  * Local variables:
 501  * c-basic-offset: 4
 502  * indent-tabs-mode: nil
 503  * c-file-style: "stroustrup"
 504  * End:
 505  * vim: shiftwidth=4 tabstop=8 expandtab
 506  */