RIC-E2-TERMINATION/3rdparty/oranE2SM/RANfunction-Name.c

   1 /*
   2  *
   3  * Copyright 2020 AT&T Intellectual Property
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 /*
  20  * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  21  * From ASN.1 module "E2SM-gNB-NRT-IEs"
  22  *      found in "../asnTextFiles/e2sm-gNB-NRT-v401.asn"
  23  *      `asn1c -fcompound-names -fincludes-quoted -fno-include-deps -findirect-choice -gen-PER -no-gen-OER -D.`
  24  */
  25
  26 #include "RANfunction-Name.h"
  27
  28 static const int permitted_alphabet_table_2[256] = {
  29  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  30  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  31  1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,        /* .      '() +,-./ */
  32 10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,        /* 0123456789:  = ? */
  33  0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,        /*  ABCDEFGHIJKLMNO */
  34 38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,        /* PQRSTUVWXYZ      */
  35  0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,        /*  abcdefghijklmno */
  36 64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,        /* pqrstuvwxyz      */
  37 };
  38 static const int permitted_alphabet_code2value_2[74] = {
  39 32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
  40 55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
  41 75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
  42 97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
  43 113,114,115,116,117,118,119,120,121,122,};
  44
  45
  46 static int check_permitted_alphabet_2(const void *sptr) {
  47         const int *table = permitted_alphabet_table_2;
  48         /* The underlying type is PrintableString */
  49         const PrintableString_t *st = (const PrintableString_t *)sptr;
  50         const uint8_t *ch = st->buf;
  51         const uint8_t *end = ch + st->size;
  52
  53         for(; ch < end; ch++) {
  54                 uint8_t cv = *ch;
  55                 if(!table[cv]) return -1;
  56         }
  57         return 0;
  58 }
  59
  60 static const int permitted_alphabet_table_3[256] = {
  61  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  62  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  63  1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,        /* .      '() +,-./ */
  64 10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,        /* 0123456789:  = ? */
  65  0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,        /*  ABCDEFGHIJKLMNO */
  66 38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,        /* PQRSTUVWXYZ      */
  67  0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,        /*  abcdefghijklmno */
  68 64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,        /* pqrstuvwxyz      */
  69 };
  70 static const int permitted_alphabet_code2value_3[74] = {
  71 32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
  72 55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
  73 75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
  74 97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
  75 113,114,115,116,117,118,119,120,121,122,};
  76
  77
  78 static int check_permitted_alphabet_3(const void *sptr) {
  79         const int *table = permitted_alphabet_table_3;
  80         /* The underlying type is PrintableString */
  81         const PrintableString_t *st = (const PrintableString_t *)sptr;
  82         const uint8_t *ch = st->buf;
  83         const uint8_t *end = ch + st->size;
  84
  85         for(; ch < end; ch++) {
  86                 uint8_t cv = *ch;
  87                 if(!table[cv]) return -1;
  88         }
  89         return 0;
  90 }
  91
  92 static const int permitted_alphabet_table_4[256] = {
  93  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  94  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
  95  1, 0, 0, 0, 0, 0, 0, 2, 3, 4, 0, 5, 6, 7, 8, 9,        /* .      '() +,-./ */
  96 10,11,12,13,14,15,16,17,18,19,20, 0, 0,21, 0,22,        /* 0123456789:  = ? */
  97  0,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,        /*  ABCDEFGHIJKLMNO */
  98 38,39,40,41,42,43,44,45,46,47,48, 0, 0, 0, 0, 0,        /* PQRSTUVWXYZ      */
  99  0,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,        /*  abcdefghijklmno */
 100 64,65,66,67,68,69,70,71,72,73,74, 0, 0, 0, 0, 0,        /* pqrstuvwxyz      */
 101 };
 102 static const int permitted_alphabet_code2value_4[74] = {
 103 32,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,
 104 55,56,57,58,61,63,65,66,67,68,69,70,71,72,73,74,
 105 75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,
 106 97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
 107 113,114,115,116,117,118,119,120,121,122,};
 108
 109
 110 static int check_permitted_alphabet_4(const void *sptr) {
 111         const int *table = permitted_alphabet_table_4;
 112         /* The underlying type is PrintableString */
 113         const PrintableString_t *st = (const PrintableString_t *)sptr;
 114         const uint8_t *ch = st->buf;
 115         const uint8_t *end = ch + st->size;
 116
 117         for(; ch < end; ch++) {
 118                 uint8_t cv = *ch;
 119                 if(!table[cv]) return -1;
 120         }
 121         return 0;
 122 }
 123
 124 static int
 125 memb_ranFunction_ShortName_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 126                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 127         const PrintableString_t *st = (const PrintableString_t *)sptr;
 128         size_t size;
 129
 130         if(!sptr) {
 131                 ASN__CTFAIL(app_key, td, sptr,
 132                         "%s: value not given (%s:%d)",
 133                         td->name, __FILE__, __LINE__);
 134                 return -1;
 135         }
 136
 137         size = st->size;
 138
 139         if((size >= 1 && size <= 150)
 140                  && !check_permitted_alphabet_2(st)) {
 141                 /* Constraint check succeeded */
 142                 return 0;
 143         } else {
 144                 ASN__CTFAIL(app_key, td, sptr,
 145                         "%s: constraint failed (%s:%d)",
 146                         td->name, __FILE__, __LINE__);
 147                 return -1;
 148         }
 149 }
 150
 151 static int asn_PER_MAP_ranFunction_ShortName_2_v2c(unsigned int value) {
 152         if(value >= sizeof(permitted_alphabet_table_2)/sizeof(permitted_alphabet_table_2[0]))
 153                 return -1;
 154         return permitted_alphabet_table_2[value] - 1;
 155 }
 156 static int asn_PER_MAP_ranFunction_ShortName_2_c2v(unsigned int code) {
 157         if(code >= sizeof(permitted_alphabet_code2value_2)/sizeof(permitted_alphabet_code2value_2[0]))
 158                 return -1;
 159         return permitted_alphabet_code2value_2[code];
 160 }
 161 static int
 162 memb_ranFunction_E2SM_OID_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 163                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 164         const PrintableString_t *st = (const PrintableString_t *)sptr;
 165         size_t size;
 166
 167         if(!sptr) {
 168                 ASN__CTFAIL(app_key, td, sptr,
 169                         "%s: value not given (%s:%d)",
 170                         td->name, __FILE__, __LINE__);
 171                 return -1;
 172         }
 173
 174         size = st->size;
 175
 176         if((size >= 1 && size <= 1000)
 177                  && !check_permitted_alphabet_3(st)) {
 178                 /* Constraint check succeeded */
 179                 return 0;
 180         } else {
 181                 ASN__CTFAIL(app_key, td, sptr,
 182                         "%s: constraint failed (%s:%d)",
 183                         td->name, __FILE__, __LINE__);
 184                 return -1;
 185         }
 186 }
 187
 188 static int asn_PER_MAP_ranFunction_E2SM_OID_3_v2c(unsigned int value) {
 189         if(value >= sizeof(permitted_alphabet_table_3)/sizeof(permitted_alphabet_table_3[0]))
 190                 return -1;
 191         return permitted_alphabet_table_3[value] - 1;
 192 }
 193 static int asn_PER_MAP_ranFunction_E2SM_OID_3_c2v(unsigned int code) {
 194         if(code >= sizeof(permitted_alphabet_code2value_3)/sizeof(permitted_alphabet_code2value_3[0]))
 195                 return -1;
 196         return permitted_alphabet_code2value_3[code];
 197 }
 198 static int
 199 memb_ranFunction_Description_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 200                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 201         const PrintableString_t *st = (const PrintableString_t *)sptr;
 202         size_t size;
 203
 204         if(!sptr) {
 205                 ASN__CTFAIL(app_key, td, sptr,
 206                         "%s: value not given (%s:%d)",
 207                         td->name, __FILE__, __LINE__);
 208                 return -1;
 209         }
 210
 211         size = st->size;
 212
 213         if((size >= 1 && size <= 150)
 214                  && !check_permitted_alphabet_4(st)) {
 215                 /* Constraint check succeeded */
 216                 return 0;
 217         } else {
 218                 ASN__CTFAIL(app_key, td, sptr,
 219                         "%s: constraint failed (%s:%d)",
 220                         td->name, __FILE__, __LINE__);
 221                 return -1;
 222         }
 223 }
 224
 225 static int asn_PER_MAP_ranFunction_Description_4_v2c(unsigned int value) {
 226         if(value >= sizeof(permitted_alphabet_table_4)/sizeof(permitted_alphabet_table_4[0]))
 227                 return -1;
 228         return permitted_alphabet_table_4[value] - 1;
 229 }
 230 static int asn_PER_MAP_ranFunction_Description_4_c2v(unsigned int code) {
 231         if(code >= sizeof(permitted_alphabet_code2value_4)/sizeof(permitted_alphabet_code2value_4[0]))
 232                 return -1;
 233         return permitted_alphabet_code2value_4[code];
 234 }
 235 static asn_per_constraints_t asn_PER_memb_ranFunction_ShortName_constr_2 CC_NOTUSED = {
 236         { APC_CONSTRAINED,       7,  7,  32,  122 }     /* (32..122) */,
 237         { APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }  /* (SIZE(1..150,...)) */,
 238         asn_PER_MAP_ranFunction_ShortName_2_v2c,        /* Value to PER code map */
 239         asn_PER_MAP_ranFunction_ShortName_2_c2v /* PER code to value map */
 240 };
 241 static asn_per_constraints_t asn_PER_memb_ranFunction_E2SM_OID_constr_3 CC_NOTUSED = {
 242         { APC_CONSTRAINED,       7,  7,  32,  122 }     /* (32..122) */,
 243         { APC_CONSTRAINED | APC_EXTENSIBLE,  10,  10,  1,  1000 }       /* (SIZE(1..1000,...)) */,
 244         asn_PER_MAP_ranFunction_E2SM_OID_3_v2c, /* Value to PER code map */
 245         asn_PER_MAP_ranFunction_E2SM_OID_3_c2v  /* PER code to value map */
 246 };
 247 static asn_per_constraints_t asn_PER_memb_ranFunction_Description_constr_4 CC_NOTUSED = {
 248         { APC_CONSTRAINED,       7,  7,  32,  122 }     /* (32..122) */,
 249         { APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  150 }  /* (SIZE(1..150,...)) */,
 250         asn_PER_MAP_ranFunction_Description_4_v2c,      /* Value to PER code map */
 251         asn_PER_MAP_ranFunction_Description_4_c2v       /* PER code to value map */
 252 };
 253 asn_TYPE_member_t asn_MBR_RANfunction_Name_1[] = {
 254         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_ShortName),
 255                 (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 256                 -1,     /* IMPLICIT tag at current level */
 257                 &asn_DEF_PrintableString,
 258                 0,
 259                 { 0, &asn_PER_memb_ranFunction_ShortName_constr_2,  memb_ranFunction_ShortName_constraint_1 },
 260                 0, 0, /* No default value */
 261                 "ranFunction-ShortName"
 262                 },
 263         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_E2SM_OID),
 264                 (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 265                 -1,     /* IMPLICIT tag at current level */
 266                 &asn_DEF_PrintableString,
 267                 0,
 268                 { 0, &asn_PER_memb_ranFunction_E2SM_OID_constr_3,  memb_ranFunction_E2SM_OID_constraint_1 },
 269                 0, 0, /* No default value */
 270                 "ranFunction-E2SM-OID"
 271                 },
 272         { ATF_NOFLAGS, 0, offsetof(struct RANfunction_Name, ranFunction_Description),
 273                 (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 274                 -1,     /* IMPLICIT tag at current level */
 275                 &asn_DEF_PrintableString,
 276                 0,
 277                 { 0, &asn_PER_memb_ranFunction_Description_constr_4,  memb_ranFunction_Description_constraint_1 },
 278                 0, 0, /* No default value */
 279                 "ranFunction-Description"
 280                 },
 281         { ATF_POINTER, 1, offsetof(struct RANfunction_Name, ranFunction_Instance),
 282                 (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 283                 -1,     /* IMPLICIT tag at current level */
 284                 &asn_DEF_NativeInteger,
 285                 0,
 286                 { 0, 0, 0 },
 287                 0, 0, /* No default value */
 288                 "ranFunction-Instance"
 289                 },
 290 };
 291 static const int asn_MAP_RANfunction_Name_oms_1[] = { 3 };
 292 static const ber_tlv_tag_t asn_DEF_RANfunction_Name_tags_1[] = {
 293         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 294 };
 295 static const asn_TYPE_tag2member_t asn_MAP_RANfunction_Name_tag2el_1[] = {
 296     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ranFunction-ShortName */
 297     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ranFunction-E2SM-OID */
 298     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ranFunction-Description */
 299     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* ranFunction-Instance */
 300 };
 301 asn_SEQUENCE_specifics_t asn_SPC_RANfunction_Name_specs_1 = {
 302         sizeof(struct RANfunction_Name),
 303         offsetof(struct RANfunction_Name, _asn_ctx),
 304         asn_MAP_RANfunction_Name_tag2el_1,
 305         4,      /* Count of tags in the map */
 306         asn_MAP_RANfunction_Name_oms_1, /* Optional members */
 307         1, 0,   /* Root/Additions */
 308         4,      /* First extension addition */
 309 };
 310 asn_TYPE_descriptor_t asn_DEF_RANfunction_Name = {
 311         "RANfunction-Name",
 312         "RANfunction-Name",
 313         &asn_OP_SEQUENCE,
 314         asn_DEF_RANfunction_Name_tags_1,
 315         sizeof(asn_DEF_RANfunction_Name_tags_1)
 316                 /sizeof(asn_DEF_RANfunction_Name_tags_1[0]), /* 1 */
 317         asn_DEF_RANfunction_Name_tags_1,        /* Same as above */
 318         sizeof(asn_DEF_RANfunction_Name_tags_1)
 319                 /sizeof(asn_DEF_RANfunction_Name_tags_1[0]), /* 1 */
 320         { 0, 0, SEQUENCE_constraint },
 321         asn_MBR_RANfunction_Name_1,
 322         4,      /* Elements count */
 323         &asn_SPC_RANfunction_Name_specs_1       /* Additional specs */
 324 };
 325