4fd23f1d7a4d2088ace16e257220b8b1801766ac
[yaz-moved-to-github.git] / src / srwutil.c
1 /*
2  * Copyright (C) 1995-2005, Index Data ApS
3  * See the file LICENSE for details.
4  *
5  * $Id: srwutil.c,v 1.33 2005-11-09 17:48:11 adam Exp $
6  */
7 /**
8  * \file srwutil.c
9  * \brief Implements SRW/SRU utilities.
10  */
11
12 #include <stdlib.h>
13 #include <yaz/srw.h>
14 #include <yaz/yaz-iconv.h>
15
16 static int hex_digit (int ch)
17 {
18     if (ch >= '0' && ch <= '9')
19         return ch - '0';
20     else if (ch >= 'a' && ch <= 'f')
21         return ch - 'a'+10;
22     else if (ch >= 'A' && ch <= 'F')
23         return ch - 'A'+10;
24     return 0;
25 }
26
27 int yaz_uri_array(const char *path, ODR o, char ***name, char ***val)
28 {
29     int no = 2;
30     const char *cp;
31     *name = 0;
32     if (*path == '?')
33         path++;
34     if (!*path)
35         return no;
36     cp = path;
37     while ((cp = strchr(cp, '&')))
38     {
39         cp++;
40         no++;
41     }
42     *name = odr_malloc(o, no * sizeof(char*));
43     *val = odr_malloc(o, no * sizeof(char*));
44
45     for (no = 0; *path; no++)
46     {
47         const char *p1 = strchr(path, '=');
48         size_t i = 0;
49         char *ret;
50         if (!p1)
51             break;
52
53         (*name)[no] = odr_malloc(o, (p1-path)+1);
54         memcpy((*name)[no], path, p1-path);
55         (*name)[no][p1-path] = '\0';
56
57         path = p1 + 1;
58         p1 = strchr(path, '&');
59         if (!p1)
60             p1 = strlen(path) + path;
61         (*val)[no] = ret = odr_malloc(o, p1 - path + 1);
62         while (*path && *path != '&')
63         {
64             if (*path == '+')
65             {
66                 ret[i++] = ' ';
67                 path++;
68             }
69             else if (*path == '%' && path[1] && path[2])
70             {
71                 ret[i++] = hex_digit (path[1])*16 + hex_digit (path[2]);
72                 path = path + 3;
73             }
74             else
75                 ret[i++] = *path++;
76         }
77         ret[i] = '\0';
78
79         if (*path)
80             path++;
81     }
82     (*name)[no] = 0;
83     (*val)[no] = 0;
84     return no;
85 }
86
87 char *yaz_uri_val(const char *path, const char *name, ODR o)
88 {
89     size_t nlen = strlen(name);
90     if (*path != '?')
91         return 0;
92     path++;
93     while (path && *path)
94     {
95         const char *p1 = strchr(path, '=');
96         if (!p1)
97             break;
98         if ((size_t)(p1 - path) == nlen && !memcmp(path, name, nlen))
99         {
100             size_t i = 0;
101             char *ret;
102             
103             path = p1 + 1;
104             p1 = strchr(path, '&');
105             if (!p1)
106                 p1 = strlen(path) + path;
107             ret = (char *) odr_malloc(o, p1 - path + 1);
108             while (*path && *path != '&')
109             {
110                 if (*path == '+')
111                 {
112                     ret[i++] = ' ';
113                     path++;
114                 }
115                 else if (*path == '%' && path[1] && path[2])
116                 {
117                     ret[i++] = hex_digit (path[1])*16 + hex_digit (path[2]);
118                     path = path + 3;
119                 }
120                 else
121                     ret[i++] = *path++;
122             }
123             ret[i] = '\0';
124             return ret;
125         }
126         path = strchr(p1, '&');
127         if (path)
128             path++;
129     }
130     return 0;
131 }
132
133 void yaz_uri_val_int(const char *path, const char *name, ODR o, int **intp)
134 {
135     const char *v = yaz_uri_val(path, name, o);
136     if (v)
137         *intp = odr_intdup(o, atoi(v));
138 }
139
140 void yaz_mk_std_diagnostic(ODR o, Z_SRW_diagnostic *d, 
141                            int code, const char *details)
142 {
143     d->uri = (char *) odr_malloc(o, 50);
144     sprintf(d->uri, "info:srw/diagnostic/1/%d", code);
145     d->message = 0;
146     if (details)
147         d->details = odr_strdup(o, details);
148     else
149         d->details = 0;
150 }
151
152 void yaz_add_srw_diagnostic(ODR o, Z_SRW_diagnostic **d,
153                             int *num, int code, const char *addinfo)
154 {
155     Z_SRW_diagnostic *d_new;
156     d_new = (Z_SRW_diagnostic *) odr_malloc (o, (*num + 1)* sizeof(**d));
157     if (*num)
158         memcpy (d_new, *d, *num *sizeof(**d));
159     *d = d_new;
160
161     yaz_mk_std_diagnostic(o, *d + *num, code, addinfo);
162     (*num)++;
163 }
164
165 int yaz_srw_decode(Z_HTTP_Request *hreq, Z_SRW_PDU **srw_pdu,
166                    Z_SOAP **soap_package, ODR decode, char **charset)
167 {
168     if (!strcmp(hreq->method, "POST"))
169     {
170         const char *content_type = z_HTTP_header_lookup(hreq->headers,
171                                                         "Content-Type");
172         if (content_type && 
173             (!yaz_strcmp_del("text/xml", content_type, "; ") ||
174              !yaz_strcmp_del("text/plain", content_type, "; ")))
175         {
176             char *db = "Default";
177             const char *p0 = hreq->path, *p1;
178             int ret = -1;
179             const char *charset_p = 0;
180             
181             static Z_SOAP_Handler soap_handlers[4] = {
182 #if HAVE_XML2
183                 {"http://www.loc.gov/zing/srw/", 0,
184                  (Z_SOAP_fun) yaz_srw_codec},
185                 {"http://www.loc.gov/zing/srw/v1.0/", 0,
186                  (Z_SOAP_fun) yaz_srw_codec},
187                 {"http://www.loc.gov/zing/srw/update/", 0,
188                  (Z_SOAP_fun) yaz_ucp_codec},
189 #endif
190                 {0, 0, 0}
191             };
192             
193             if (*p0 == '/')
194                 p0++;
195             p1 = strchr(p0, '?');
196             if (!p1)
197                 p1 = p0 + strlen(p0);
198             if (p1 != p0)
199             {
200                 db = (char*) odr_malloc(decode, p1 - p0 + 1);
201                 memcpy (db, p0, p1 - p0);
202                 db[p1 - p0] = '\0';
203             }
204
205             if (charset && (charset_p = strstr(content_type, "; charset=")))
206             {
207                 int i = 0;
208                 charset_p += 10;
209                 while (i < 20 && charset_p[i] &&
210                        !strchr("; \n\r", charset_p[i]))
211                     i++;
212                 *charset = (char*) odr_malloc(decode, i+1);
213                 memcpy(*charset, charset_p, i);
214                 (*charset)[i] = '\0';
215             }
216             ret = z_soap_codec(decode, soap_package, 
217                                &hreq->content_buf, &hreq->content_len,
218                                soap_handlers);
219             if (ret == 0 && (*soap_package)->which == Z_SOAP_generic)
220             {
221                 *srw_pdu = (Z_SRW_PDU*) (*soap_package)->u.generic->p;
222                 
223                 if ((*srw_pdu)->which == Z_SRW_searchRetrieve_request &&
224                     (*srw_pdu)->u.request->database == 0)
225                     (*srw_pdu)->u.request->database = db;
226
227                 if ((*srw_pdu)->which == Z_SRW_explain_request &&
228                     (*srw_pdu)->u.explain_request->database == 0)
229                     (*srw_pdu)->u.explain_request->database = db;
230
231                 if ((*srw_pdu)->which == Z_SRW_scan_request &&
232                     (*srw_pdu)->u.scan_request->database == 0)
233                     (*srw_pdu)->u.scan_request->database = db;
234
235                 if ((*srw_pdu)->which == Z_SRW_update_request &&
236                     (*srw_pdu)->u.update_request->database == 0)
237                     (*srw_pdu)->u.update_request->database = db;
238
239                 return 0;
240             }
241             return 1;
242         }
243     }
244     return 2;
245 }
246
247 /**
248   http://www.loc.gov/z3950/agency/zing/srw/service.html
249 */ 
250 int yaz_sru_decode(Z_HTTP_Request *hreq, Z_SRW_PDU **srw_pdu,
251                    Z_SOAP **soap_package, ODR decode, char **charset,
252                    Z_SRW_diagnostic **diag, int *num_diag)
253 {
254 #if HAVE_XML2
255     static Z_SOAP_Handler soap_handlers[2] = {
256         {"http://www.loc.gov/zing/srw/", 0,
257          (Z_SOAP_fun) yaz_srw_codec},
258         {0, 0, 0}
259     };
260 #endif
261     const char *content_type = z_HTTP_header_lookup(hreq->headers,
262                                                     "Content-Type");
263     /*
264       SRU GET: allow any content type.
265       SRU POST: we support "application/x-www-form-urlencoded";
266       not  "multipart/form-data" .
267     */
268     if (!strcmp(hreq->method, "GET") 
269         ||
270         (!strcmp(hreq->method, "POST") 
271          && content_type &&
272          !yaz_strcmp_del("application/x-www-form-urlencoded",
273                          content_type, "; ")
274             )
275         )
276     {
277         char *db = "Default";
278         const char *p0 = hreq->path, *p1;
279 #if HAVE_XML2
280         const char *operation = 0;
281         char *version = 0;
282         char *query = 0;
283         char *pQuery = 0;
284         char *sortKeys = 0;
285         char *stylesheet = 0;
286         char *scanClause = 0;
287         char *pScanClause = 0;
288         char *recordXPath = 0;
289         char *recordSchema = 0;
290         char *recordPacking = "xml";  /* xml packing is default for SRU */
291         char *maximumRecords = 0;
292         char *startRecord = 0;
293         char *maximumTerms = 0;
294         char *responsePosition = 0;
295         char *extraRequestData = 0;
296 #endif
297         char **uri_name;
298         char **uri_val;
299
300         if (charset)
301             *charset = 0;
302         if (*p0 == '/')
303             p0++;
304         p1 = strchr(p0, '?');
305         if (!p1)
306             p1 = p0 + strlen(p0);
307         if (p1 != p0)
308         {
309             db = (char*) odr_malloc(decode, p1 - p0 + 1);
310             memcpy (db, p0, p1 - p0);
311             db[p1 - p0] = '\0';
312         }
313         if (!strcmp(hreq->method, "POST"))
314             p1 = hreq->content_buf;
315         yaz_uri_array(p1, decode, &uri_name, &uri_val);
316 #if HAVE_XML2
317         if (uri_name)
318         {
319             int i;
320             for (i = 0; uri_name[i]; i++)
321             {
322                 char *n = uri_name[i];
323                 char *v = uri_val[i];
324                 if (!strcmp(n, "query"))
325                     query = v;
326                 else if (!strcmp(n, "x-pquery"))
327                     pQuery = v;
328                 else if (!strcmp(n, "operation"))
329                     operation = v;
330                 else if (!strcmp(n, "stylesheet"))
331                     stylesheet = v;
332                 else if (!strcmp(n, "sortKeys"))
333                     sortKeys = v;
334                 else if (!strcmp(n, "recordXPath"))
335                     recordXPath = v;
336                 else if (!strcmp(n, "recordSchema"))
337                     recordSchema = v;
338                 else if (!strcmp(n, "recordPacking"))
339                     recordPacking = v;
340                 else if (!strcmp(n, "version"))
341                     version = v;
342                 else if (!strcmp(n, "scanClause"))
343                     scanClause = v;
344                 else if (!strcmp(n, "x-pScanClause"))
345                     pScanClause = v;
346                 else if (!strcmp(n, "maximumRecords"))
347                     maximumRecords = v;
348                 else if (!strcmp(n, "startRecord"))
349                     startRecord = v;
350                 else if (!strcmp(n, "maximumTerms"))
351                     maximumTerms = v;
352                 else if (!strcmp(n, "responsePosition"))
353                     responsePosition = v;
354                 else if (!strcmp(n, "extraRequestData"))
355                     extraRequestData = v;
356                 else
357                     yaz_add_srw_diagnostic(decode, diag, num_diag, 8, n);
358             }
359         }
360         if (!version)
361         {
362             if (uri_name)
363                 yaz_add_srw_diagnostic(decode, diag, num_diag, 7, "version");
364             version = "1.1";
365         }
366         if (strcmp(version, "1.1"))
367             yaz_add_srw_diagnostic(decode, diag, num_diag, 5, "1.1");
368         if (!operation)
369         {
370             if (uri_name)
371                 yaz_add_srw_diagnostic(decode, diag, num_diag, 7, "operation");
372             operation = "explain";
373         }
374         if (!strcmp(operation, "searchRetrieve"))
375         {
376             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_searchRetrieve_request);
377
378             sr->srw_version = version;
379             *srw_pdu = sr;
380             if (query)
381             {
382                 sr->u.request->query_type = Z_SRW_query_type_cql;
383                 sr->u.request->query.cql = query;
384             }
385             else if (pQuery)
386             {
387                 sr->u.request->query_type = Z_SRW_query_type_pqf;
388                 sr->u.request->query.pqf = pQuery;
389             }
390             else
391                 yaz_add_srw_diagnostic(decode, diag, num_diag, 7, "query");
392
393             if (sortKeys)
394             {
395                 sr->u.request->sort_type = Z_SRW_sort_type_sort;
396                 sr->u.request->sort.sortKeys = sortKeys;
397             }
398             sr->u.request->recordXPath = recordXPath;
399             sr->u.request->recordSchema = recordSchema;
400             sr->u.request->recordPacking = recordPacking;
401             sr->u.request->stylesheet = stylesheet;
402
403             if (maximumRecords)
404                 sr->u.request->maximumRecords =
405                     odr_intdup(decode, atoi(maximumRecords));
406             if (startRecord)
407                 sr->u.request->startRecord =
408                     odr_intdup(decode, atoi(startRecord));
409
410             sr->u.request->database = db;
411
412             (*soap_package) = odr_malloc(decode, sizeof(**soap_package));
413             (*soap_package)->which = Z_SOAP_generic;
414             
415             (*soap_package)->u.generic =
416                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
417             
418             (*soap_package)->u.generic->p = sr;
419             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
420             (*soap_package)->u.generic->no = 0;
421             
422             (*soap_package)->ns = "SRU";
423
424             return 0;
425         }
426         else if (!strcmp(operation, "explain"))
427         {
428             /* Transfer SRU explain parameters to common struct */
429             /* http://www.loc.gov/z3950/agency/zing/srw/explain.html */
430             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_explain_request);
431
432             sr->srw_version = version;
433             *srw_pdu = sr;
434             sr->u.explain_request->recordPacking = recordPacking;
435             sr->u.explain_request->database = db;
436
437             sr->u.explain_request->stylesheet = stylesheet;
438
439             (*soap_package) = odr_malloc(decode, sizeof(**soap_package));
440             (*soap_package)->which = Z_SOAP_generic;
441             
442             (*soap_package)->u.generic =
443                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
444             
445             (*soap_package)->u.generic->p = sr;
446             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
447             (*soap_package)->u.generic->no = 0;
448             
449             (*soap_package)->ns = "SRU";
450
451             return 0;
452         }
453         else if (!strcmp(operation, "scan"))
454         {
455             /* Transfer SRU scan parameters to common struct */
456             /* http://www.loc.gov/z3950/agency/zing/srw/scan.html */
457             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_scan_request);
458
459             sr->srw_version = version;
460             *srw_pdu = sr;
461
462             if (scanClause)
463             {
464                 sr->u.scan_request->query_type = Z_SRW_query_type_cql;
465                 sr->u.scan_request->scanClause.cql = scanClause;
466             }
467             else if (pScanClause)
468             {
469                 sr->u.scan_request->query_type = Z_SRW_query_type_pqf;
470                 sr->u.scan_request->scanClause.pqf = pScanClause;
471             }
472             else
473                 yaz_add_srw_diagnostic(decode, diag, num_diag, 7,
474                                        "scanClause");
475             sr->u.scan_request->database = db;
476
477             if (maximumTerms)
478                 sr->u.scan_request->maximumTerms =
479                     odr_intdup(decode, atoi(maximumTerms));
480             if (responsePosition)
481                 sr->u.scan_request->responsePosition =
482                     odr_intdup(decode, atoi(responsePosition));
483
484             sr->u.scan_request->stylesheet = stylesheet;
485
486             (*soap_package) = odr_malloc(decode, sizeof(**soap_package));
487             (*soap_package)->which = Z_SOAP_generic;
488             
489             (*soap_package)->u.generic =
490                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
491             
492             (*soap_package)->u.generic->p = sr;
493             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
494             (*soap_package)->u.generic->no = 0;
495             
496             (*soap_package)->ns = "SRU";
497
498             return 0;
499         }
500         else
501         {
502             /* unsupported operation ... */
503             /* Act as if we received a explain request and throw diagnostic. */
504
505             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_explain_request);
506
507             sr->srw_version = version;
508             *srw_pdu = sr;
509             sr->u.explain_request->recordPacking = recordPacking;
510             sr->u.explain_request->database = db;
511
512             sr->u.explain_request->stylesheet = stylesheet;
513
514             (*soap_package) = odr_malloc(decode, sizeof(**soap_package));
515             (*soap_package)->which = Z_SOAP_generic;
516             
517             (*soap_package)->u.generic =
518                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
519             
520             (*soap_package)->u.generic->p = sr;
521             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
522             (*soap_package)->u.generic->no = 0;
523             
524             (*soap_package)->ns = "SRU";
525
526             yaz_add_srw_diagnostic(decode, diag, num_diag, 4, operation);
527             return 0;
528         }
529 #endif
530         return 1;
531     }
532     return 2;
533 }
534
535 Z_SRW_extra_record *yaz_srw_get_extra_record(ODR o)
536 {
537     Z_SRW_extra_record *res = (Z_SRW_extra_record *)
538         odr_malloc(o, sizeof(*res));
539     res->type = 1;
540     res->recordReviewCode = 0;
541     res->recordReviewNote = 0;
542     res->recordId = 0;
543     res->nonDupRecordId = 0;
544     res->recordLockStatus = 0;
545     res->recordOldVersion = 0;
546     return res;
547 }
548
549 Z_SRW_PDU *yaz_srw_get(ODR o, int which)
550 {
551     Z_SRW_PDU *sr = (Z_SRW_PDU *) odr_malloc(o, sizeof(*o));
552
553     sr->srw_version = odr_strdup(o, "1.1");
554     sr->which = which;
555     switch(which)
556     {
557     case Z_SRW_searchRetrieve_request:
558         sr->u.request = (Z_SRW_searchRetrieveRequest *)
559             odr_malloc(o, sizeof(*sr->u.request));
560         sr->u.request->query_type = Z_SRW_query_type_cql;
561         sr->u.request->query.cql = 0;
562         sr->u.request->sort_type = Z_SRW_sort_type_none;
563         sr->u.request->sort.none = 0;
564         sr->u.request->startRecord = 0;
565         sr->u.request->maximumRecords = 0;
566         sr->u.request->recordSchema = 0;
567         sr->u.request->recordPacking = 0;
568         sr->u.request->recordXPath = 0;
569         sr->u.request->database = 0;
570         sr->u.request->resultSetTTL = 0;
571         sr->u.request->stylesheet = 0;
572         break;
573     case Z_SRW_searchRetrieve_response:
574         sr->u.response = (Z_SRW_searchRetrieveResponse *)
575             odr_malloc(o, sizeof(*sr->u.response));
576         sr->u.response->numberOfRecords = 0;
577         sr->u.response->resultSetId = 0;
578         sr->u.response->resultSetIdleTime = 0;
579         sr->u.response->records = 0;
580         sr->u.response->num_records = 0;
581         sr->u.response->diagnostics = 0;
582         sr->u.response->num_diagnostics = 0;
583         sr->u.response->nextRecordPosition = 0;
584         sr->u.response->extra_records = 0;
585         break;
586     case Z_SRW_explain_request:
587         sr->u.explain_request = (Z_SRW_explainRequest *)
588             odr_malloc(o, sizeof(*sr->u.explain_request));
589         sr->u.explain_request->recordPacking = 0;
590         sr->u.explain_request->database = 0;
591         sr->u.explain_request->stylesheet = 0;
592         break;
593     case Z_SRW_explain_response:
594         sr->u.explain_response = (Z_SRW_explainResponse *)
595             odr_malloc(o, sizeof(*sr->u.explain_response));
596         sr->u.explain_response->record.recordData_buf = 0;
597         sr->u.explain_response->record.recordData_len = 0;
598         sr->u.explain_response->record.recordSchema = 0;
599         sr->u.explain_response->record.recordPosition = 0;
600         sr->u.explain_response->record.recordPacking =
601             Z_SRW_recordPacking_string;
602         sr->u.explain_response->diagnostics = 0;
603         sr->u.explain_response->num_diagnostics = 0;
604         sr->u.explain_response->extra_record = 0;
605         break;
606     case Z_SRW_scan_request:
607         sr->u.scan_request = (Z_SRW_scanRequest *)
608             odr_malloc(o, sizeof(*sr->u.scan_request));
609         sr->u.scan_request->database = 0;
610         sr->u.scan_request->stylesheet = 0;
611         sr->u.scan_request->maximumTerms = 0;
612         sr->u.scan_request->responsePosition = 0;
613         sr->u.scan_request->query_type = Z_SRW_query_type_cql;
614         sr->u.scan_request->scanClause.cql = 0;
615         break;
616     case Z_SRW_scan_response:
617         sr->u.scan_response = (Z_SRW_scanResponse *)
618             odr_malloc(o, sizeof(*sr->u.scan_response));
619         sr->u.scan_response->terms = 0;
620         sr->u.scan_response->num_terms = 0;
621         sr->u.scan_response->diagnostics = 0;
622         sr->u.scan_response->num_diagnostics = 0;
623     case Z_SRW_update_request:
624         sr->u.update_request = (Z_SRW_updateRequest *)
625             odr_malloc(o, sizeof(*sr->u.update_request));
626         sr->u.update_request->database = 0;
627         sr->u.update_request->stylesheet = 0;
628         sr->u.update_request->record.recordSchema = 0;
629         sr->u.update_request->record.recordPacking = Z_SRW_recordPacking_XML;
630         sr->u.update_request->recordId = 0;
631         sr->u.update_request->recordVersion = 0;
632         sr->u.update_request->recordOldVersion = 0;
633         sr->u.update_request->record.recordData_buf = 0;
634         sr->u.update_request->record.recordData_len = 0;
635         sr->u.update_request->extra_record = 0;
636         sr->u.update_request->extraRequestData = 0;
637         sr->u.request->database = 0;
638         break;
639     case Z_SRW_update_response:
640         sr->u.update_response = (Z_SRW_updateResponse *)
641             odr_malloc(o, sizeof(*sr->u.update_response));
642         sr->u.update_response->operationStatus = 0;
643         sr->u.update_response->recordId = 0;
644         sr->u.update_response->recordVersion = 0;
645         sr->u.update_response->recordChecksum = 0;
646         sr->u.update_response->record.recordData_buf = 0;
647         sr->u.update_response->record.recordData_len = 0;
648         sr->u.update_response->record.recordSchema = 0;
649         sr->u.update_response->record.recordPacking =
650             Z_SRW_recordPacking_XML;
651         sr->u.update_response->extra_record = 0;
652         sr->u.update_response->extraResponseData = 0;
653         sr->u.update_response->diagnostics = 0;
654         sr->u.update_response->num_diagnostics = 0;
655     }
656     return sr;
657 }
658
659 /* bib1:srw */
660 static int srw_bib1_map[] = {
661     1, 1,
662     2, 2,
663     3, 11,
664     4, 35,
665     5, 12,
666     6, 38,
667     7, 30,
668     8, 32,
669     9, 29,
670     108, 10,  /* Malformed query : Syntax error */
671     10, 10,
672     11, 12,
673     11, 23,
674     12, 60,
675     13, 61,
676     13, 62,
677     14, 63,
678     14, 64,
679     14, 65,
680     15, 68,
681     15, 69,
682     16, 70,
683     17, 70,
684     18, 50,
685     19, 55,
686     20, 56, 
687     21, 52,
688     22, 50,
689     23, 3,
690     24, 66,
691     25, 66,
692     26, 66,
693     27, 51,
694     28, 52,
695     29, 52,
696     30, 51,
697     31, 57,
698     32, 58,
699     33, 59,
700     100, 1, /* bad map */
701     101, 3,
702     102, 3,
703     103, 3,
704     104, 3,
705     105, 3, 
706     106, 66,
707     107, 11,
708     108, 13,
709     108, 14,
710     108, 25,
711     108, 26,
712     108, 27,
713     108, 45,
714         
715     109, 2,
716     110, 37,
717     111, 1,
718     112, 58,
719     113, 10,
720     114, 16,
721     115, 16,
722     116, 16,
723     117, 19,
724     117, 20,
725     118, 22,
726     119, 32,
727     119, 31,
728     120, 28,
729     121, 15,
730     122, 32,
731     123, 22,
732     123, 17,
733     123, 18,
734     124, 24,
735     125, 36,
736     126, 36, 
737     127, 36,
738     128, 51,
739     129, 39,
740     130, 43,
741     131, 40,
742     132, 42,
743     201, 44,
744     201, 33,
745     201, 34,
746     202, 41,
747     203, 43,
748     205, 1,  /* bad map */
749     206, 1,  /* bad map */
750     207, 89,
751     208, 1,  /* bad map */
752     209, 80,
753     210, 80,
754     210, 81,
755     211, 84,
756     212, 85,
757     213, 92,
758     214, 90,
759     215, 91,
760     216, 92,
761     217, 63,
762     218, 1,  /* bad map */
763     219, 1,  /* bad map */
764     220, 1,  /* bad map */
765     221, 1,  /* bad map */
766     222, 3,
767     223, 1,  /* bad map */
768     224, 1,  /* bad map */
769     225, 1,  /* bad map */
770     226, 1,  /* bad map */
771     227, 66,
772     228, 1,  /* bad map */
773     229, 36,
774     230, 83,
775     231, 89,
776     232, 1,
777     233, 1, /* bad map */
778     234, 1, /* bad map */
779     235, 2,
780     236, 3, 
781     237, 82,
782     238, 67,
783     239, 66,
784     240, 1, /* bad map */
785     241, 1, /* bad map */
786     242, 70,
787     243, 1, /* bad map */
788     244, 66,
789     245, 10,
790     246, 10,
791     247, 10,
792     1001, 1, /* bad map */
793     1002, 1, /* bad map */
794     1003, 1, /* bad map */
795     1004, 1, /* bad map */
796     1005, 1, /* bad map */
797     1006, 1, /* bad map */
798     1007, 100,
799     1008, 1, 
800     1009, 1,
801     1010, 3,
802     1011, 3,
803     1012, 3,
804     1013, 3,
805     1014, 3,
806     1015, 3,
807     1015, 3,
808     1016, 3,
809     1017, 3,
810     1018, 2,
811     1019, 2,
812     1020, 2,
813     1021, 3,
814     1022, 3,
815     1023, 3,
816     1024, 16,
817     1025, 3,
818     1026, 64,
819     1027, 1,
820     1028, 65,
821     1029, 1,
822     1040, 1,
823     /* 1041-1065 */
824     1066, 66,
825     1066, 67,
826     0
827 };
828
829 int yaz_diag_bib1_to_srw (int code)
830 {
831     const int *p = srw_bib1_map;
832     while (*p)
833     {
834         if (code == p[0])
835             return p[1];
836         p += 2;
837     }
838     return 1;
839 }
840
841 int yaz_diag_srw_to_bib1(int code)
842 {
843     const int *p = srw_bib1_map;
844     while (*p)
845     {
846         if (code == p[1])
847             return p[0];
848         p += 2;
849     }
850     return 1;
851 }
852
853 /*
854  * Local variables:
855  * c-basic-offset: 4
856  * indent-tabs-mode: nil
857  * End:
858  * vim: shiftwidth=4 tabstop=8 expandtab
859  */
860