src/util.cpp

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