zutil/charneg.c

   1 /*
   2  $ $Id: charneg.c,v 1.3 2002-05-21 08:36:04 adam Exp $
   3  * Helper functions for Character Set and Language Negotiation - 3
   4  */
   5
   6 #include <stdio.h>
   7 #include <yaz/otherinfo.h>
   8 #include <yaz/z-charneg.h>
   9 #include <yaz/charneg.h>
  10
  11 static Z_External* z_ext_record2(ODR o, int oid_class, int oid_value,
  12         const char *buf, int len)
  13 {
  14         Z_External *p;
  15         oident oid;
  16
  17         if (!(p = (Z_External *)odr_malloc(o, sizeof(*p)))) return 0;
  18
  19         p->descriptor = 0;
  20         p->indirect_reference = 0;
  21
  22         oid.proto = PROTO_Z3950;
  23         oid.oclass = oid_class;
  24         oid.value = oid_value;
  25         p->direct_reference = odr_oiddup(o, oid_getoidbyent(&oid));
  26
  27         p->which = Z_External_octet;
  28         if (!(p->u.octet_aligned = (Odr_oct *)odr_malloc(o, sizeof(Odr_oct)))) {
  29                 return 0;
  30         }
  31         if (!(p->u.octet_aligned->buf = (unsigned char *)odr_malloc(o, len))) {
  32                 return 0;
  33         }
  34         p->u.octet_aligned->len = p->u.octet_aligned->size = len;
  35         memcpy(p->u.octet_aligned->buf, buf, len);
  36
  37         return p;
  38 }
  39 static Z_OriginProposal_0 *z_get_OriginProposal_0(ODR o, const char *charset)
  40 {
  41         Z_OriginProposal_0 *p0 =
  42                                 (Z_OriginProposal_0*)odr_malloc(o, sizeof(*p0));
  43         Z_PrivateCharacterSet *pc =
  44                                 (Z_PrivateCharacterSet *)odr_malloc(o, sizeof(*pc));
  45
  46         memset(p0, 0, sizeof(*p0));
  47         memset(pc, 0, sizeof(*pc));
  48
  49         p0->which = Z_OriginProposal_0_private;
  50         p0->u.zprivate = pc;
  51
  52         pc->which = Z_PrivateCharacterSet_externallySpecified;
  53         pc->u.externallySpecified =
  54                         z_ext_record2(o, CLASS_RECSYN, VAL_NOP, charset, (strlen(charset)+1));
  55
  56         return p0;
  57 }
  58 static Z_OriginProposal *z_get_OriginProposal(ODR o, const char **charsets,
  59         int num_charsets, const char **langs, int num_langs, int selected)
  60 {
  61         int i;
  62         Z_OriginProposal *p = (Z_OriginProposal *) odr_malloc(o, sizeof(*p));
  63
  64         memset(p, 0, sizeof(*p));
  65
  66         p->recordsInSelectedCharSets = (bool_t *)odr_malloc(o, sizeof(bool_t));
  67         *p->recordsInSelectedCharSets = (selected) ? 1:0;
  68
  69         if (charsets && num_charsets) {
  70
  71                 p->num_proposedCharSets = num_charsets;
  72                 p->proposedCharSets =
  73                         (Z_OriginProposal_0**) odr_malloc(o,
  74                                 num_charsets*sizeof(Z_OriginProposal_0*));
  75
  76                 for (i = 0; i<num_charsets; i++) {
  77
  78                         p->proposedCharSets[i] =
  79                                 z_get_OriginProposal_0(o, charsets[i]);
  80
  81                 }
  82         }
  83         if (langs && num_langs) {
  84
  85                 p->num_proposedlanguages = num_langs;
  86
  87                 p->proposedlanguages =
  88                         (char **) odr_malloc(o, num_langs*sizeof(char *));
  89
  90                 for (i = 0; i<num_langs; i++) {
  91
  92                         p->proposedlanguages[i] = (char *)langs[i];
  93
  94                 }
  95         }
  96         return p;
  97 }
  98 static Z_CharSetandLanguageNegotiation *z_get_CharSetandLanguageNegotiation(ODR o)
  99 {
 100         Z_CharSetandLanguageNegotiation *p =
 101                 (Z_CharSetandLanguageNegotiation *) odr_malloc(o, sizeof(*p));
 102
 103         memset(p, 0, sizeof(*p));
 104
 105         return p;
 106 }
 107 Z_External *yaz_set_proposal_charneg(ODR o, const char **charsets, int num_charsets,
 108         const char **langs, int num_langs, int selected)
 109 {
 110         Z_External *p = (Z_External *)odr_malloc(o, sizeof(*p));
 111         oident oid;
 112
 113         p->descriptor = 0;
 114         p->indirect_reference = 0;
 115
 116         oid.proto = PROTO_Z3950;
 117         oid.oclass = CLASS_NEGOT;
 118         oid.value = VAL_CHARNEG3;
 119         p->direct_reference = odr_oiddup(o, oid_getoidbyent(&oid));
 120
 121         p->which = Z_External_charSetandLanguageNegotiation;
 122         p->u.charNeg3 = z_get_CharSetandLanguageNegotiation(o);
 123         p->u.charNeg3->which = Z_CharSetandLanguageNegotiation_proposal;
 124         p->u.charNeg3->u.proposal =
 125                 z_get_OriginProposal(o, charsets, num_charsets,
 126                         langs, num_langs, selected);
 127
 128         return p;
 129 }
 130 static Z_TargetResponse *z_get_TargetResponse(ODR o, const char *charset,
 131         const char *lang, int selected)
 132 {
 133         Z_TargetResponse *p = (Z_TargetResponse *) odr_malloc(o, sizeof(*p));
 134         Z_PrivateCharacterSet *pc =
 135                                 (Z_PrivateCharacterSet *)odr_malloc(o, sizeof(*pc));
 136
 137         memset(p, 0, sizeof(*p));
 138         memset(pc, 0, sizeof(*pc));
 139
 140         p->recordsInSelectedCharSets = (bool_t *)odr_malloc(o, sizeof(bool_t));
 141         *p->recordsInSelectedCharSets = (selected) ? 1:0;
 142         p->selectedLanguage = (char *)odr_strdup(o, lang);
 143
 144         p->which = Z_TargetResponse_private;
 145         p->u.zprivate = pc;
 146
 147         pc->which = Z_PrivateCharacterSet_externallySpecified;
 148         pc->u.externallySpecified =
 149                         z_ext_record2(o, CLASS_RECSYN, VAL_NOP, charset, (strlen(charset)+1));
 150         return p;
 151 }
 152 Z_External *yaz_set_response_charneg(ODR o, const char *charset,
 153         const char *lang, int selected)
 154 {
 155         Z_External *p = (Z_External *)odr_malloc(o, sizeof(*p));
 156         oident oid;
 157
 158         p->descriptor = 0;
 159         p->indirect_reference = 0;
 160
 161         oid.proto = PROTO_Z3950;
 162         oid.oclass = CLASS_NEGOT;
 163         oid.value = VAL_CHARNEG3;
 164         p->direct_reference = odr_oiddup(o, oid_getoidbyent(&oid));
 165
 166         p->which = Z_External_charSetandLanguageNegotiation;
 167         p->u.charNeg3 = z_get_CharSetandLanguageNegotiation(o);
 168         p->u.charNeg3->which = Z_CharSetandLanguageNegotiation_response;
 169         p->u.charNeg3->u.response = z_get_TargetResponse(o, charset, lang, selected);
 170
 171         return p;
 172 }
 173 Z_CharSetandLanguageNegotiation *yaz_get_charneg_record(Z_OtherInformation *p)
 174 {
 175         Z_External *pext;
 176         int i;
 177
 178         if(!p)
 179                 return 0;
 180
 181         for (i=0; i<p->num_elements; i++) {
 182
 183                 if ((p->list[i]->which == Z_OtherInfo_externallyDefinedInfo) &&
 184                                         (pext = p->list[i]->information.externallyDefinedInfo)) {
 185
 186                         oident *ent = oid_getentbyoid(pext->direct_reference);
 187
 188                         if (ent && ent->value == VAL_CHARNEG3 && ent->oclass == CLASS_NEGOT &&
 189                                 pext->which == Z_External_charSetandLanguageNegotiation) {
 190
 191                                 return pext->u.charNeg3;
 192                         }
 193                 }
 194         }
 195
 196         return 0;
 197 }
 198 void yaz_get_proposal_charneg(NMEM mem, Z_CharSetandLanguageNegotiation *p, char **charsets,
 199         int *num_charsets, char **langs, int *num_langs, int *selected)
 200 {
 201         int i;
 202         Z_OriginProposal *pro = p->u.proposal;
 203
 204         if (pro->num_proposedCharSets && charsets && num_charsets) {
 205
 206                 *num_charsets = pro->num_proposedCharSets;
 207
 208                 charsets = (char **)nmem_malloc(mem, pro->num_proposedCharSets * sizeof(char *));
 209
 210                 for (i=0; i<pro->num_proposedCharSets; i++) {
 211
 212                         if (pro->proposedCharSets[i]->which == Z_OriginProposal_0_private &&
 213                                 pro->proposedCharSets[i]->u.zprivate->which == Z_PrivateCharacterSet_externallySpecified) {
 214
 215                                 Z_External *pext =
 216                                         pro->proposedCharSets[i]->u.zprivate->u.externallySpecified;
 217
 218                                 if (pext->which == Z_External_octet) {
 219
 220                                         charsets[i] = (char *)nmem_malloc(mem, pext->u.octet_aligned->len * sizeof(char));
 221
 222                                         memcpy (charsets[i], pext->u.octet_aligned->buf, pext->u.octet_aligned->len);
 223
 224                                 }
 225                         }
 226                 }
 227         }
 228
 229         if (pro->num_proposedlanguages && langs && num_langs) {
 230
 231                 *num_langs = pro->num_proposedlanguages;
 232
 233                 langs = (char **)nmem_malloc(mem, pro->num_proposedlanguages * sizeof(char *));
 234
 235                 for (i=0; i<pro->num_proposedlanguages; i++) {
 236
 237                         langs[i] = (char *)nmem_malloc(mem, strlen(pro->proposedlanguages[i])+1);
 238                         memcpy (langs[i], pro->proposedlanguages[i], strlen(pro->proposedlanguages[i])+1);
 239                 }
 240         }
 241
 242         if(pro->recordsInSelectedCharSets && selected) {
 243
 244                 *selected = *pro->recordsInSelectedCharSets;
 245
 246         }
 247 }
 248 void yaz_get_response_charneg(NMEM mem, Z_CharSetandLanguageNegotiation *p,
 249         char **charset, char **lang, int *selected)
 250 {
 251         Z_TargetResponse *res = p->u.response;
 252
 253         if (charset && res->which == Z_TargetResponse_private &&
 254                 res->u.zprivate->which == Z_PrivateCharacterSet_externallySpecified) {
 255
 256                 Z_External *pext = res->u.zprivate->u.externallySpecified;
 257
 258                 if (pext->which == Z_External_octet) {
 259
 260                         *charset = (char *)nmem_malloc(mem, pext->u.octet_aligned->len * sizeof(char));
 261                         memcpy (*charset, pext->u.octet_aligned->buf, pext->u.octet_aligned->len);
 262                 }
 263         }
 264
 265         if (lang && res->selectedLanguage) {
 266
 267                 *lang = (char *)nmem_malloc(mem, strlen(res->selectedLanguage)+1);
 268                 memcpy (*lang, res->selectedLanguage, strlen(res->selectedLanguage)+1);
 269
 270         }
 271
 272         if(selected && res->recordsInSelectedCharSets) {
 273
 274                 *selected = *res->recordsInSelectedCharSets;
 275
 276         }
 277 }