src/util.cpp

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