src/util.cpp

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