The upgrade to automake 1.8/1.9 causes the product dist to be called
[yazpp-moved-to-github.git] / src / yaz-ir-assoc.cpp
1 /*
2  * Copyright (c) 1998-2003, Index Data.
3  * See the file LICENSE for details.
4  * 
5  * $Id: yaz-ir-assoc.cpp,v 1.27 2006-03-29 13:14:15 adam Exp $
6  */
7
8 #include <assert.h>
9
10 #include <yaz/log.h>
11 #include <yazpp/ir-assoc.h>
12
13 using namespace yazpp_1;
14
15 IR_Assoc::IR_Assoc(IPDU_Observable *the_PDU_Observable)
16     : Z_Assoc(the_PDU_Observable)
17 {
18     m_num_databaseNames = 0;
19     m_databaseNames = 0;
20     m_preferredRecordSyntax = VAL_NONE;
21     m_elementSetNames = 0;
22     m_lastReceived = 0;
23     m_host = 0;
24     m_proxy = 0;
25     m_cookie = 0;
26     m_log = YLOG_DEBUG;
27     const char *db = "Default";
28     set_databaseNames(1, &db);
29 }
30
31 IR_Assoc::~IR_Assoc()
32 {
33     if (m_elementSetNames)
34         delete [] m_elementSetNames->u.generic;
35     delete [] m_elementSetNames;
36     delete [] m_host;
37     delete [] m_proxy;
38     delete [] m_cookie;
39 }
40
41 void IR_Assoc::get_databaseNames (int *num, char ***list)
42 {
43     *num = m_num_databaseNames;
44     *list = m_databaseNames;
45 }
46
47 typedef char *charp;
48 void IR_Assoc::set_databaseNames (int num, const char **list)
49 {
50     int i;
51     yaz_log (m_log, "IR_Assoc::set_databaseNames num=%d", num);
52     for (i = 0; i<m_num_databaseNames; i++)
53         delete [] m_databaseNames[i];
54     delete [] m_databaseNames;
55     m_num_databaseNames = num;
56
57     m_databaseNames = new char *[num];
58     for (i = 0; i<m_num_databaseNames; i++)
59     {
60         m_databaseNames[i] = new char[strlen(list[i])+1];
61         strcpy(m_databaseNames[i], list[i]);
62     }
63 }
64
65 void IR_Assoc::set_databaseNames(const char *dblist, const char *sep)
66 {
67     const char **list = new const char* [strlen(dblist)];
68     char *dbtmp = new char[strlen(dblist)+1];
69     strcpy(dbtmp, dblist);
70     int num = 0;
71     int len = 0;
72     for (char *cp = dbtmp; ; cp++)
73         if (*cp && !strchr(sep, *cp))
74             len++;
75         else
76         {
77             if (len)
78             {
79                 list[num] = cp - len;
80                 num++;
81             }
82             if (!*cp)
83                 break;
84             *cp = '\0';
85             len = 0;
86         }
87     set_databaseNames (num, list);
88     delete [] dbtmp;
89     delete [] list;
90 }
91
92 void IR_Assoc::set_preferredRecordSyntax (int value)
93 {
94     m_preferredRecordSyntax = value;
95 }
96
97 void IR_Assoc::set_preferredRecordSyntax (const char *syntax)
98 {
99     m_preferredRecordSyntax = VAL_NONE;
100     if (syntax && *syntax)
101         m_preferredRecordSyntax = oid_getvalbyname (syntax);
102 }
103
104 void IR_Assoc::get_preferredRecordSyntax (int *value)
105 {
106     *value = m_preferredRecordSyntax;
107 }
108
109 void IR_Assoc::get_preferredRecordSyntax (const char **dst)
110 {
111     struct oident ent;
112     ent.proto = PROTO_Z3950;
113     ent.oclass = CLASS_RECSYN;
114     ent.value = (enum oid_value) m_preferredRecordSyntax;
115
116     int oid[OID_SIZE];
117     oid_ent_to_oid (&ent, oid);
118     struct oident *entp = oid_getentbyoid (oid);
119     
120     *dst = entp ? entp->desc : "";
121 }
122
123 void IR_Assoc::set_elementSetName (const char *elementSetName)
124 {
125     if (m_elementSetNames)
126         delete [] m_elementSetNames->u.generic;
127     delete m_elementSetNames;
128     m_elementSetNames = 0;
129     if (elementSetName && *elementSetName)
130     {
131         m_elementSetNames = new Z_ElementSetNames;
132         m_elementSetNames->which = Z_ElementSetNames_generic;
133         m_elementSetNames->u.generic = new char[strlen(elementSetName)+1];
134         strcpy (m_elementSetNames->u.generic, elementSetName);
135     }
136 }
137
138 void IR_Assoc::get_elementSetName (Z_ElementSetNames **elementSetNames)
139 {
140     *elementSetNames = m_elementSetNames;
141 }
142
143 void IR_Assoc::get_elementSetName (const char **elementSetName)
144 {
145     if (!m_elementSetNames ||
146         m_elementSetNames->which != Z_ElementSetNames_generic)
147     {
148         *elementSetName = 0;
149         return;
150     }
151     *elementSetName = m_elementSetNames->u.generic;
152 }
153
154
155 void IR_Assoc::recv_GDU(Z_GDU *apdu, int len)
156 {
157     if (apdu->which == Z_GDU_Z3950)
158             recv_Z_PDU(apdu->u.z3950, len);
159 }
160
161 void IR_Assoc::recv_Z_PDU(Z_APDU *apdu, int len)
162 {
163     yaz_log (m_log, "recv_Z_PDU %d bytes", len);
164     m_lastReceived = apdu->which;
165     switch (apdu->which)
166     {
167     case Z_APDU_initResponse:
168         yaz_log (m_log, "recv InitResponse");
169         recv_initResponse(apdu->u.initResponse);
170         break;
171     case Z_APDU_initRequest:
172         yaz_log (m_log, "recv InitRequest");
173         recv_initRequest(apdu->u.initRequest);
174         break;
175     case Z_APDU_searchRequest:
176         yaz_log (m_log, "recv searchRequest");
177         recv_searchRequest(apdu->u.searchRequest);
178         break;
179     case Z_APDU_searchResponse:
180         yaz_log (m_log, "recv searchResponse"); 
181         recv_searchResponse(apdu->u.searchResponse);
182         break;
183     case Z_APDU_presentRequest:
184         yaz_log (m_log, "recv presentRequest");
185         recv_presentRequest(apdu->u.presentRequest);
186         break;
187     case Z_APDU_presentResponse:
188         yaz_log (m_log, "recv presentResponse");
189         recv_presentResponse(apdu->u.presentResponse);
190         break;
191     case Z_APDU_extendedServicesResponse:
192         yaz_log (m_log, "recv extendedServiceResponse");
193         recv_extendedServicesResponse(apdu->u.extendedServicesResponse);
194         break;
195     }
196 }
197
198 int IR_Assoc::send_searchRequest(Yaz_Z_Query *query,
199                                      char* pResultSetId,
200                                      char* pRefId)
201 {
202     Z_APDU *apdu = create_Z_PDU(Z_APDU_searchRequest);
203     Z_SearchRequest *req = apdu->u.searchRequest;
204     int recordSyntax;
205
206     req->query = query->get_Z_Query();
207     if (!req->query)
208         return -1;
209     get_databaseNames (&req->num_databaseNames, &req->databaseNames);
210     int oid_syntax[OID_SIZE];
211     oident prefsyn;
212     get_preferredRecordSyntax(&recordSyntax);
213     if (recordSyntax != VAL_NONE)
214     {
215         prefsyn.proto = PROTO_Z3950;
216         prefsyn.oclass = CLASS_RECSYN;
217         prefsyn.value = (enum oid_value) recordSyntax;
218         oid_ent_to_oid(&prefsyn, oid_syntax);
219         req->preferredRecordSyntax = oid_syntax;
220     }
221     yaz_log (m_log, "send_searchRequest");
222     assert (req->otherInfo == 0);
223     if (m_cookie)
224     {
225         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
226         assert (req->otherInfo);
227     }
228
229     if ( pRefId )
230     {
231         req->referenceId = getRefID(pRefId);
232     }
233
234     if ( pResultSetId )
235     {
236         req->resultSetName = pResultSetId;
237     }
238
239     return send_Z_PDU(apdu, 0);
240 }
241
242 int IR_Assoc::send_presentRequest(int start, 
243                                       int number, 
244                                       char* pResultSetId,
245                                       char* pRefId)
246 {
247     Z_APDU *apdu = create_Z_PDU(Z_APDU_presentRequest);
248     Z_PresentRequest *req = apdu->u.presentRequest;
249
250     req->resultSetStartPoint = &start;
251     req->numberOfRecordsRequested = &number;
252
253     int oid_syntax[OID_SIZE];
254     oident prefsyn;
255     int recordSyntax;
256     get_preferredRecordSyntax (&recordSyntax);
257     if (recordSyntax != VAL_NONE)
258     {
259         prefsyn.proto = PROTO_Z3950;
260         prefsyn.oclass = CLASS_RECSYN;
261         prefsyn.value = (enum oid_value) recordSyntax;
262         oid_ent_to_oid(&prefsyn, oid_syntax);
263         req->preferredRecordSyntax = oid_syntax;
264     }
265     Z_RecordComposition compo;
266     Z_ElementSetNames *elementSetNames;
267     get_elementSetName (&elementSetNames);
268     if (elementSetNames)
269     {
270         req->recordComposition = &compo;
271         compo.which = Z_RecordComp_simple;
272         compo.u.simple = elementSetNames;
273     }
274
275     if (m_cookie)
276         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
277
278     if ( pRefId )
279     {
280         req->referenceId = getRefID(pRefId);
281     }
282
283     if ( pResultSetId )
284     {
285         req->resultSetId = pResultSetId;
286     }
287
288     return send_Z_PDU(apdu, 0);
289 }
290
291 void IR_Assoc::set_proxy(const char *str)
292 {
293     delete [] m_proxy;
294     m_proxy = 0;
295     if (str)
296     {
297         m_proxy = new char[strlen(str)+1];
298         strcpy (m_proxy, str);
299     }
300 }
301
302 void IR_Assoc::set_cookie(const char *str)
303 {
304     delete [] m_cookie;
305     m_cookie = 0;
306     if (str)
307     {
308         m_cookie = new char[strlen(str)+1];
309         strcpy(m_cookie, str);
310     }
311 }
312
313 const char *IR_Assoc::get_cookie()
314 {
315     return m_cookie;
316 }
317
318 void IR_Assoc::client(const char *addr)
319 {
320     delete [] m_host;
321     m_host = new char[strlen(addr)+1];
322     strcpy(m_host, addr);
323     const char *dbpart = strchr(m_host, '/');
324     if (dbpart)
325         set_databaseNames (dbpart+1, "+ ");
326     Z_Assoc::client(m_proxy ? m_proxy : m_host);
327 }
328
329 const char *IR_Assoc::get_proxy()
330 {
331     return m_proxy;
332 }
333
334 const char *IR_Assoc::get_host()
335 {
336     return m_host;
337 }
338
339 void IR_Assoc::recv_searchRequest(Z_SearchRequest *searchRequest)
340 {
341     Z_APDU *apdu = create_Z_PDU(Z_APDU_searchResponse);
342     send_Z_PDU(apdu, 0);
343 }
344
345 void IR_Assoc::recv_presentRequest(Z_PresentRequest *presentRequest)
346 {
347     Z_APDU *apdu = create_Z_PDU(Z_APDU_presentResponse);
348     send_Z_PDU(apdu, 0);
349 }
350
351 void IR_Assoc::recv_initRequest(Z_InitRequest *initRequest)
352 {
353     Z_APDU *apdu = create_Z_PDU(Z_APDU_initResponse);
354     send_Z_PDU(apdu, 0);
355 }
356
357 void IR_Assoc::recv_searchResponse (Z_SearchResponse *searchResponse)
358 {
359 }
360
361 void IR_Assoc::recv_presentResponse (Z_PresentResponse *presentResponse)
362 {
363 }
364
365 void IR_Assoc::recv_initResponse(Z_InitResponse *initResponse)
366 {
367 }
368
369 void IR_Assoc::recv_extendedServicesResponse(Z_ExtendedServicesResponse *ExtendedServicesResponse)
370 {
371 }
372
373 int IR_Assoc::get_lastReceived()
374 {
375     return m_lastReceived;
376 }
377
378 void IR_Assoc::set_lastReceived(int lastReceived)
379 {
380     m_lastReceived = lastReceived;
381 }
382
383 int IR_Assoc::send_initRequest(char* pRefId)
384 {
385     Z_APDU *apdu = create_Z_PDU(Z_APDU_initRequest);
386     Z_InitRequest *req = apdu->u.initRequest;
387     
388     ODR_MASK_SET(req->options, Z_Options_search);
389     ODR_MASK_SET(req->options, Z_Options_present);
390     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
391     ODR_MASK_SET(req->options, Z_Options_triggerResourceCtrl);
392     ODR_MASK_SET(req->options, Z_Options_scan);
393     ODR_MASK_SET(req->options, Z_Options_sort);
394     ODR_MASK_SET(req->options, Z_Options_extendedServices);
395     ODR_MASK_SET(req->options, Z_Options_delSet);
396
397     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
398     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
399     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
400
401     if ( pRefId )
402     {
403         req->referenceId = getRefID(pRefId);
404     }
405
406     if (m_proxy && m_host)
407         set_otherInformationString(&req->otherInfo, VAL_PROXY, 1, m_host);
408     if (m_cookie)
409         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
410     return send_Z_PDU(apdu, 0);
411 }
412
413 int IR_Assoc::send_deleteResultSetRequest(char* pResultSetId, char* pRefId)
414 {
415     char* ResultSetIds[1];
416
417     Z_APDU *apdu = create_Z_PDU(Z_APDU_deleteResultSetRequest);
418     Z_DeleteResultSetRequest *req = apdu->u.deleteResultSetRequest;
419
420     if ( pResultSetId )
421     {
422         *req->deleteFunction = Z_DeleteResultSetRequest_list;
423         req->num_resultSetList = 1;
424         ResultSetIds[0] = pResultSetId;
425         req->resultSetList = ResultSetIds;
426     }
427     else
428     {
429         *req->deleteFunction = Z_DeleteResultSetRequest_all;
430     }
431     
432     if ( pRefId )
433     {
434         req->referenceId = getRefID(pRefId);
435     }
436
437     if (m_proxy && m_host)
438         set_otherInformationString(&req->otherInfo, VAL_PROXY, 1, m_host);
439     if (m_cookie)
440         set_otherInformationString(&req->otherInfo, VAL_COOKIE, 1, m_cookie);
441
442     return send_Z_PDU(apdu, 0);
443 }
444
445
446 /*
447  * Local variables:
448  * c-basic-offset: 4
449  * indent-tabs-mode: nil
450  * End:
451  * vim: shiftwidth=4 tabstop=8 expandtab
452  */
453