src/yaz-ir-assoc.cpp

   1 /*
   2  * Copyright (c) 1998-1999, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: yaz-ir-assoc.cpp,v $
   7  * Revision 1.9  1999-04-28 13:29:14  adam
   8  * Yet another fix regarding database settings.
   9  *
  10  * Revision 1.8  1999/04/28 13:04:03  adam
  11  * Fixed setting of proxy otherInfo so that database(s) are removed.
  12  *
  13  * Revision 1.7  1999/04/21 12:09:01  adam
  14  * Many improvements. Modified to proxy server to work with "sessions"
  15  * based on cookies.
  16  *
  17  * Revision 1.6  1999/04/20 10:30:05  adam
  18  * Implemented various stuff for client and proxy. Updated calls
  19  * to ODR to reflect new name parameter.
  20  *
  21  * Revision 1.5  1999/04/09 11:46:57  adam
  22  * Added object Yaz_Z_Assoc. Much more functional client.
  23  */
  24
  25 #include <assert.h>
  26
  27 #include <log.h>
  28 #include <yaz-ir-assoc.h>
  29
  30 Yaz_IR_Assoc::Yaz_IR_Assoc(IYaz_PDU_Observable *the_PDU_Observable)
  31     : Yaz_Z_Assoc(the_PDU_Observable)
  32 {
  33     m_num_databaseNames = 0;
  34     m_databaseNames = 0;
  35     m_preferredRecordSyntax = VAL_NONE;
  36     m_elementSetNames = 0;
  37     m_lastReceived = 0;
  38     m_host = 0;
  39     m_proxy = 0;
  40     m_cookie = 0;
  41     const char *db = "Default";
  42     set_databaseNames(1, &db);
  43 }
  44
  45 Yaz_IR_Assoc::~Yaz_IR_Assoc()
  46 {
  47     if (m_elementSetNames)
  48         delete [] m_elementSetNames->u.generic;
  49     delete [] m_elementSetNames;
  50     delete [] m_host;
  51     delete [] m_proxy;
  52     delete [] m_cookie;
  53 }
  54
  55 void Yaz_IR_Assoc::get_databaseNames (int *num, char ***list)
  56 {
  57     *num = m_num_databaseNames;
  58     *list = m_databaseNames;
  59 }
  60
  61 void Yaz_IR_Assoc::set_databaseNames (int num, const char **list)
  62 {
  63     int i;
  64     logf (LOG_LOG, "Yaz_IR_Assoc::set_databaseNames num=%d", num);
  65     for (i = 0; i<m_num_databaseNames; i++)
  66         delete [] m_databaseNames[i];
  67     delete [] m_databaseNames;
  68     m_num_databaseNames = num;
  69     m_databaseNames = new (char*) [num];
  70     for (i = 0; i<m_num_databaseNames; i++)
  71     {
  72         m_databaseNames[i] = new char[strlen(list[i])+1];
  73         strcpy(m_databaseNames[i], list[i]);
  74     }
  75 }
  76
  77 void Yaz_IR_Assoc::set_databaseNames(const char *dblist, const char *sep)
  78 {
  79     const char **list = new (const char*) [strlen(dblist)];
  80     char *dbtmp = new char[strlen(dblist)+1];
  81     strcpy(dbtmp, dblist);
  82     int num = 0;
  83     int len = 0;
  84     for (char *cp = dbtmp; ; cp++)
  85         if (*cp && !strchr(sep, *cp))
  86             len++;
  87         else
  88         {
  89             if (len)
  90             {
  91                 list[num] = cp - len;
  92                 num++;
  93             }
  94             if (!*cp)
  95                 break;
  96             *cp = '\0';
  97             len = 0;
  98         }
  99     set_databaseNames (num, list);
 100     delete [] dbtmp;
 101     delete [] list;
 102 }
 103
 104 void Yaz_IR_Assoc::set_preferredRecordSyntax (int value)
 105 {
 106     m_preferredRecordSyntax = value;
 107 }
 108
 109 void Yaz_IR_Assoc::set_preferredRecordSyntax (const char *syntax)
 110 {
 111     m_preferredRecordSyntax = VAL_NONE;
 112     if (syntax && *syntax)
 113         m_preferredRecordSyntax = oid_getvalbyname (syntax);
 114 }
 115
 116 void Yaz_IR_Assoc::get_preferredRecordSyntax (int *value)
 117 {
 118     *value = m_preferredRecordSyntax;
 119 }
 120
 121 void Yaz_IR_Assoc::get_preferredRecordSyntax (const char **dst)
 122 {
 123     struct oident ent;
 124     ent.proto = PROTO_Z3950;
 125     ent.oclass = CLASS_RECSYN;
 126     ent.value = (enum oid_value) m_preferredRecordSyntax;
 127
 128     int oid[OID_SIZE];
 129     oid_ent_to_oid (&ent, oid);
 130     struct oident *entp = oid_getentbyoid (oid);
 131
 132     *dst = entp ? entp->desc : "";
 133 }
 134
 135 void Yaz_IR_Assoc::set_elementSetName (const char *elementSetName)
 136 {
 137     if (m_elementSetNames)
 138         delete [] m_elementSetNames->u.generic;
 139     delete m_elementSetNames;
 140     m_elementSetNames = 0;
 141     if (elementSetName && *elementSetName)
 142     {
 143         m_elementSetNames = new Z_ElementSetNames;
 144         m_elementSetNames->which = Z_ElementSetNames_generic;
 145         m_elementSetNames->u.generic = new char[strlen(elementSetName)+1];
 146         strcpy (m_elementSetNames->u.generic, elementSetName);
 147     }
 148 }
 149
 150 void Yaz_IR_Assoc::get_elementSetName (Z_ElementSetNames **elementSetNames)
 151 {
 152     *elementSetNames = m_elementSetNames;
 153 }
 154
 155 void Yaz_IR_Assoc::get_elementSetName (const char **elementSetName)
 156 {
 157     if (!m_elementSetNames ||
 158         m_elementSetNames->which != Z_ElementSetNames_generic)
 159     {
 160         *elementSetName = 0;
 161         return;
 162     }
 163     *elementSetName = m_elementSetNames->u.generic;
 164 }
 165
 166 void Yaz_IR_Assoc::recv_Z_PDU(Z_APDU *apdu)
 167 {
 168     logf (LOG_LOG, "recv_Z_PDU");
 169     m_lastReceived = apdu->which;
 170     switch (apdu->which)
 171     {
 172     case Z_APDU_initResponse:
 173         logf (LOG_LOG, "recv InitResponse");
 174         recv_initResponse(apdu->u.initResponse);
 175         break;
 176     case Z_APDU_initRequest:
 177         logf (LOG_LOG, "recv InitRequest");
 178         recv_initRequest(apdu->u.initRequest);
 179         break;
 180     case Z_APDU_searchRequest:
 181         logf (LOG_LOG, "recv searchRequest");
 182         recv_searchRequest(apdu->u.searchRequest);
 183         break;
 184     case Z_APDU_searchResponse:
 185         logf (LOG_LOG, "recv searchResponse");
 186         recv_searchResponse(apdu->u.searchResponse);
 187         break;
 188     case Z_APDU_presentRequest:
 189         logf (LOG_LOG, "recv presentRequest");
 190         recv_presentRequest(apdu->u.presentRequest);
 191         break;
 192     case Z_APDU_presentResponse:
 193         logf (LOG_LOG, "recv presentResponse");
 194         recv_presentResponse(apdu->u.presentResponse);
 195         break;
 196     }
 197 }
 198
 199 int Yaz_IR_Assoc::send_searchRequest(Yaz_Z_Query *query)
 200 {
 201     Z_APDU *apdu = create_Z_PDU(Z_APDU_searchRequest);
 202     Z_SearchRequest *req = apdu->u.searchRequest;
 203     int recordSyntax;
 204
 205     req->query = query->get_Z_Query();
 206     if (!req->query)
 207         return -1;
 208     get_databaseNames (&req->num_databaseNames, &req->databaseNames);
 209     int oid_syntax[OID_SIZE];
 210     oident prefsyn;
 211     get_preferredRecordSyntax(&recordSyntax);
 212     if (recordSyntax != VAL_NONE)
 213     {
 214         prefsyn.proto = PROTO_Z3950;
 215         prefsyn.oclass = CLASS_RECSYN;
 216         prefsyn.value = (enum oid_value) recordSyntax;
 217         oid_ent_to_oid(&prefsyn, oid_syntax);
 218         req->preferredRecordSyntax = oid_syntax;
 219     }
 220     logf (LOG_LOG, "send_searchRequest");
 221     assert (req->otherInfo == 0);
 222     if (m_cookie)
 223     {
 224         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
 225         assert (req->otherInfo);
 226     }
 227     return send_Z_PDU(apdu);
 228 }
 229
 230 int Yaz_IR_Assoc::send_presentRequest(int start, int number)
 231 {
 232     Z_APDU *apdu = create_Z_PDU(Z_APDU_presentRequest);
 233     Z_PresentRequest *req = apdu->u.presentRequest;
 234
 235     req->resultSetStartPoint = &start;
 236     req->numberOfRecordsRequested = &number;
 237
 238     int oid_syntax[OID_SIZE];
 239     oident prefsyn;
 240     int recordSyntax;
 241     get_preferredRecordSyntax (&recordSyntax);
 242     if (recordSyntax != VAL_NONE)
 243     {
 244         prefsyn.proto = PROTO_Z3950;
 245         prefsyn.oclass = CLASS_RECSYN;
 246         prefsyn.value = (enum oid_value) recordSyntax;
 247         oid_ent_to_oid(&prefsyn, oid_syntax);
 248         req->preferredRecordSyntax = oid_syntax;
 249     }
 250     Z_RecordComposition compo;
 251     Z_ElementSetNames *elementSetNames;
 252     get_elementSetName (&elementSetNames);
 253     if (elementSetNames)
 254     {
 255         req->recordComposition = &compo;
 256         compo.which = Z_RecordComp_simple;
 257         compo.u.simple = elementSetNames;
 258     }
 259     if (m_cookie)
 260         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
 261     return send_Z_PDU(apdu);
 262 }
 263
 264 void Yaz_IR_Assoc::set_proxy(const char *str)
 265 {
 266     delete [] m_proxy;
 267     m_proxy = 0;
 268     if (str)
 269     {
 270         m_proxy = new char[strlen(str)+1];
 271         strcpy (m_proxy, str);
 272     }
 273 }
 274
 275 void Yaz_IR_Assoc::set_cookie(const char *str)
 276 {
 277     delete [] m_cookie;
 278     m_cookie = 0;
 279     if (str)
 280     {
 281         m_cookie = new char[strlen(str)+1];
 282         strcpy(m_cookie, str);
 283     }
 284 }
 285
 286 const char *Yaz_IR_Assoc::get_cookie()
 287 {
 288     return m_cookie;
 289 }
 290
 291 void Yaz_IR_Assoc::client(const char *addr)
 292 {
 293     delete [] m_host;
 294     m_host = new char[strlen(addr)+1];
 295     strcpy(m_host, addr);
 296     const char *zurl_p = (m_proxy ? m_proxy : m_host);
 297     char *zurl = new char[strlen(zurl_p)+1];
 298     strcpy(zurl, zurl_p);
 299     char *dbpart = strchr(zurl, '/');
 300     if (dbpart)
 301     {
 302         set_databaseNames (dbpart+1, "+ ");
 303         *dbpart = '\0';
 304     }
 305     Yaz_Z_Assoc::client(zurl);
 306     delete [] zurl;
 307 }
 308
 309 const char *Yaz_IR_Assoc::get_proxy()
 310 {
 311     return m_proxy;
 312 }
 313
 314 const char *Yaz_IR_Assoc::get_host()
 315 {
 316     return m_host;
 317 }
 318
 319 void Yaz_IR_Assoc::recv_searchRequest(Z_SearchRequest *searchRequest)
 320 {
 321     Z_APDU *apdu = create_Z_PDU(Z_APDU_searchResponse);
 322     send_Z_PDU(apdu);
 323 }
 324
 325 void Yaz_IR_Assoc::recv_presentRequest(Z_PresentRequest *presentRequest)
 326 {
 327     Z_APDU *apdu = create_Z_PDU(Z_APDU_presentResponse);
 328     send_Z_PDU(apdu);
 329 }
 330
 331 void Yaz_IR_Assoc::recv_initRequest(Z_InitRequest *initRequest)
 332 {
 333     Z_APDU *apdu = create_Z_PDU(Z_APDU_initResponse);
 334     send_Z_PDU(apdu);
 335 }
 336
 337 void Yaz_IR_Assoc::recv_searchResponse (Z_SearchResponse *searchResponse)
 338 {
 339 }
 340
 341 void Yaz_IR_Assoc::recv_presentResponse (Z_PresentResponse *presentResponse)
 342 {
 343 }
 344
 345 void Yaz_IR_Assoc::recv_initResponse(Z_InitResponse *initResponse)
 346 {
 347 }
 348
 349 int Yaz_IR_Assoc::get_lastReceived()
 350 {
 351     return m_lastReceived;
 352 }
 353
 354 void Yaz_IR_Assoc::set_lastReceived(int lastReceived)
 355 {
 356     m_lastReceived = lastReceived;
 357 }
 358
 359 int Yaz_IR_Assoc::send_initRequest()
 360 {
 361     Z_APDU *apdu = create_Z_PDU(Z_APDU_initRequest);
 362     Z_InitRequest *req = apdu->u.initRequest;
 363
 364     ODR_MASK_SET(req->options, Z_Options_search);
 365     ODR_MASK_SET(req->options, Z_Options_present);
 366     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 367     ODR_MASK_SET(req->options, Z_Options_triggerResourceCtrl);
 368     ODR_MASK_SET(req->options, Z_Options_scan);
 369     ODR_MASK_SET(req->options, Z_Options_sort);
 370     ODR_MASK_SET(req->options, Z_Options_extendedServices);
 371     ODR_MASK_SET(req->options, Z_Options_delSet);
 372
 373     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 374     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 375     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 376
 377     if (m_proxy && m_host)
 378     {
 379         char *rawhost = new char[strlen(m_host)+1];
 380         strcpy(rawhost, m_host);
 381         char *dbpart = strchr(rawhost, '/');
 382         if (dbpart)
 383         {
 384             set_databaseNames (dbpart+1, "+ ");
 385             *dbpart = '\0';
 386         }
 387         set_otherInformationString(&req->otherInfo, VAL_PROXY, 1, rawhost);
 388         delete [] rawhost;
 389     }
 390     if (m_cookie)
 391         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
 392     return send_Z_PDU(apdu);
 393 }
 394