src/util.cpp

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