src/util.cpp

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