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