/contrib/bind9/lib/dns/spnego_asn1.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 885 lines · 687 code · 114 blank · 84 comment · 97 complexity · e72898c0fb5d55f6fde5e8093c9803e2 MD5 · raw file

  1. /*
  2. * Copyright (C) 2006, 2007 Internet Systems Consortium, Inc. ("ISC")
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for any
  5. * purpose with or without fee is hereby granted, provided that the above
  6. * copyright notice and this permission notice appear in all copies.
  7. *
  8. * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  9. * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  10. * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  11. * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  12. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  13. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  14. * PERFORMANCE OF THIS SOFTWARE.
  15. */
  16. /* $Id: spnego_asn1.c,v 1.4 2007/06/19 23:47:16 tbox Exp $ */
  17. /*! \file
  18. * \brief Method routines generated from SPNEGO ASN.1 module.
  19. * See spnego_asn1.pl for details. Do not edit.
  20. */
  21. /* Generated from spnego.asn1 */
  22. /* Do not edit */
  23. #ifndef __asn1_h__
  24. #define __asn1_h__
  25. #ifndef __asn1_common_definitions__
  26. #define __asn1_common_definitions__
  27. typedef struct octet_string {
  28. size_t length;
  29. void *data;
  30. } octet_string;
  31. typedef char *general_string;
  32. typedef char *utf8_string;
  33. typedef struct oid {
  34. size_t length;
  35. unsigned *components;
  36. } oid;
  37. #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \
  38. do { \
  39. (BL) = length_##T((S)); \
  40. (B) = malloc((BL)); \
  41. if((B) == NULL) { \
  42. (R) = ENOMEM; \
  43. } else { \
  44. (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
  45. (S), (L)); \
  46. if((R) != 0) { \
  47. free((B)); \
  48. (B) = NULL; \
  49. } \
  50. } \
  51. } while (0)
  52. #endif
  53. /*
  54. * MechType ::= OBJECT IDENTIFIER
  55. */
  56. typedef oid MechType;
  57. static int encode_MechType(unsigned char *, size_t, const MechType *, size_t *);
  58. static int decode_MechType(const unsigned char *, size_t, MechType *, size_t *);
  59. static void free_MechType(MechType *);
  60. /* unused declaration: length_MechType */
  61. /* unused declaration: copy_MechType */
  62. /*
  63. * MechTypeList ::= SEQUENCE OF MechType
  64. */
  65. typedef struct MechTypeList {
  66. unsigned int len;
  67. MechType *val;
  68. } MechTypeList;
  69. static int encode_MechTypeList(unsigned char *, size_t, const MechTypeList *, size_t *);
  70. static int decode_MechTypeList(const unsigned char *, size_t, MechTypeList *, size_t *);
  71. static void free_MechTypeList(MechTypeList *);
  72. /* unused declaration: length_MechTypeList */
  73. /* unused declaration: copy_MechTypeList */
  74. /*
  75. * ContextFlags ::= BIT STRING { delegFlag(0), mutualFlag(1), replayFlag(2),
  76. * sequenceFlag(3), anonFlag(4), confFlag(5), integFlag(6) }
  77. */
  78. typedef struct ContextFlags {
  79. unsigned int delegFlag:1;
  80. unsigned int mutualFlag:1;
  81. unsigned int replayFlag:1;
  82. unsigned int sequenceFlag:1;
  83. unsigned int anonFlag:1;
  84. unsigned int confFlag:1;
  85. unsigned int integFlag:1;
  86. } ContextFlags;
  87. static int encode_ContextFlags(unsigned char *, size_t, const ContextFlags *, size_t *);
  88. static int decode_ContextFlags(const unsigned char *, size_t, ContextFlags *, size_t *);
  89. static void free_ContextFlags(ContextFlags *);
  90. /* unused declaration: length_ContextFlags */
  91. /* unused declaration: copy_ContextFlags */
  92. /* unused declaration: ContextFlags2int */
  93. /* unused declaration: int2ContextFlags */
  94. /* unused declaration: asn1_ContextFlags_units */
  95. /*
  96. * NegTokenInit ::= SEQUENCE { mechTypes[0] MechTypeList, reqFlags[1]
  97. * ContextFlags OPTIONAL, mechToken[2] OCTET STRING OPTIONAL,
  98. * mechListMIC[3] OCTET STRING OPTIONAL }
  99. */
  100. typedef struct NegTokenInit {
  101. MechTypeList mechTypes;
  102. ContextFlags *reqFlags;
  103. octet_string *mechToken;
  104. octet_string *mechListMIC;
  105. } NegTokenInit;
  106. static int encode_NegTokenInit(unsigned char *, size_t, const NegTokenInit *, size_t *);
  107. static int decode_NegTokenInit(const unsigned char *, size_t, NegTokenInit *, size_t *);
  108. static void free_NegTokenInit(NegTokenInit *);
  109. /* unused declaration: length_NegTokenInit */
  110. /* unused declaration: copy_NegTokenInit */
  111. /*
  112. * NegTokenResp ::= SEQUENCE { negState[0] ENUMERATED {
  113. * accept-completed(0), accept-incomplete(1), reject(2), request-mic(3) }
  114. * OPTIONAL, supportedMech[1] MechType OPTIONAL, responseToken[2] OCTET
  115. * STRING OPTIONAL, mechListMIC[3] OCTET STRING OPTIONAL }
  116. */
  117. typedef struct NegTokenResp {
  118. enum {
  119. accept_completed = 0,
  120. accept_incomplete = 1,
  121. reject = 2,
  122. request_mic = 3
  123. } *negState;
  124. MechType *supportedMech;
  125. octet_string *responseToken;
  126. octet_string *mechListMIC;
  127. } NegTokenResp;
  128. static int encode_NegTokenResp(unsigned char *, size_t, const NegTokenResp *, size_t *);
  129. static int decode_NegTokenResp(const unsigned char *, size_t, NegTokenResp *, size_t *);
  130. static void free_NegTokenResp(NegTokenResp *);
  131. /* unused declaration: length_NegTokenResp */
  132. /* unused declaration: copy_NegTokenResp */
  133. #endif /* __asn1_h__ */
  134. /* Generated from spnego.asn1 */
  135. /* Do not edit */
  136. #define BACK if (e) return e; p -= l; len -= l; ret += l
  137. static int
  138. encode_MechType(unsigned char *p, size_t len, const MechType * data, size_t * size)
  139. {
  140. size_t ret = 0;
  141. size_t l;
  142. int i, e;
  143. i = 0;
  144. e = encode_oid(p, len, data, &l);
  145. BACK;
  146. *size = ret;
  147. return 0;
  148. }
  149. #define FORW if(e) goto fail; p += l; len -= l; ret += l
  150. static int
  151. decode_MechType(const unsigned char *p, size_t len, MechType * data, size_t * size)
  152. {
  153. size_t ret = 0, reallen;
  154. size_t l;
  155. int e;
  156. memset(data, 0, sizeof(*data));
  157. reallen = 0;
  158. e = decode_oid(p, len, data, &l);
  159. FORW;
  160. if (size)
  161. *size = ret;
  162. return 0;
  163. fail:
  164. free_MechType(data);
  165. return e;
  166. }
  167. static void
  168. free_MechType(MechType * data)
  169. {
  170. free_oid(data);
  171. }
  172. /* unused function: length_MechType */
  173. /* unused function: copy_MechType */
  174. /* Generated from spnego.asn1 */
  175. /* Do not edit */
  176. #define BACK if (e) return e; p -= l; len -= l; ret += l
  177. static int
  178. encode_MechTypeList(unsigned char *p, size_t len, const MechTypeList * data, size_t * size)
  179. {
  180. size_t ret = 0;
  181. size_t l;
  182. int i, e;
  183. i = 0;
  184. for (i = (data)->len - 1; i >= 0; --i) {
  185. int oldret = ret;
  186. ret = 0;
  187. e = encode_MechType(p, len, &(data)->val[i], &l);
  188. BACK;
  189. ret += oldret;
  190. }
  191. e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
  192. BACK;
  193. *size = ret;
  194. return 0;
  195. }
  196. #define FORW if(e) goto fail; p += l; len -= l; ret += l
  197. static int
  198. decode_MechTypeList(const unsigned char *p, size_t len, MechTypeList * data, size_t * size)
  199. {
  200. size_t ret = 0, reallen;
  201. size_t l;
  202. int e;
  203. memset(data, 0, sizeof(*data));
  204. reallen = 0;
  205. e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
  206. FORW;
  207. if (len < reallen)
  208. return ASN1_OVERRUN;
  209. len = reallen;
  210. {
  211. size_t origlen = len;
  212. int oldret = ret;
  213. ret = 0;
  214. (data)->len = 0;
  215. (data)->val = NULL;
  216. while (ret < origlen) {
  217. (data)->len++;
  218. (data)->val = realloc((data)->val, sizeof(*((data)->val)) * (data)->len);
  219. e = decode_MechType(p, len, &(data)->val[(data)->len - 1], &l);
  220. FORW;
  221. len = origlen - ret;
  222. }
  223. ret += oldret;
  224. }
  225. if (size)
  226. *size = ret;
  227. return 0;
  228. fail:
  229. free_MechTypeList(data);
  230. return e;
  231. }
  232. static void
  233. free_MechTypeList(MechTypeList * data)
  234. {
  235. while ((data)->len) {
  236. free_MechType(&(data)->val[(data)->len - 1]);
  237. (data)->len--;
  238. }
  239. free((data)->val);
  240. (data)->val = NULL;
  241. }
  242. /* unused function: length_MechTypeList */
  243. /* unused function: copy_MechTypeList */
  244. /* Generated from spnego.asn1 */
  245. /* Do not edit */
  246. #define BACK if (e) return e; p -= l; len -= l; ret += l
  247. static int
  248. encode_ContextFlags(unsigned char *p, size_t len, const ContextFlags * data, size_t * size)
  249. {
  250. size_t ret = 0;
  251. size_t l;
  252. int i, e;
  253. i = 0;
  254. {
  255. unsigned char c = 0;
  256. *p-- = c;
  257. len--;
  258. ret++;
  259. c = 0;
  260. *p-- = c;
  261. len--;
  262. ret++;
  263. c = 0;
  264. *p-- = c;
  265. len--;
  266. ret++;
  267. c = 0;
  268. if (data->integFlag)
  269. c |= 1 << 1;
  270. if (data->confFlag)
  271. c |= 1 << 2;
  272. if (data->anonFlag)
  273. c |= 1 << 3;
  274. if (data->sequenceFlag)
  275. c |= 1 << 4;
  276. if (data->replayFlag)
  277. c |= 1 << 5;
  278. if (data->mutualFlag)
  279. c |= 1 << 6;
  280. if (data->delegFlag)
  281. c |= 1 << 7;
  282. *p-- = c;
  283. *p-- = 0;
  284. len -= 2;
  285. ret += 2;
  286. }
  287. e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
  288. BACK;
  289. *size = ret;
  290. return 0;
  291. }
  292. #define FORW if(e) goto fail; p += l; len -= l; ret += l
  293. static int
  294. decode_ContextFlags(const unsigned char *p, size_t len, ContextFlags * data, size_t * size)
  295. {
  296. size_t ret = 0, reallen;
  297. size_t l;
  298. int e;
  299. memset(data, 0, sizeof(*data));
  300. reallen = 0;
  301. e = der_match_tag_and_length(p, len, ASN1_C_UNIV, PRIM, UT_BitString, &reallen, &l);
  302. FORW;
  303. if (len < reallen)
  304. return ASN1_OVERRUN;
  305. p++;
  306. len--;
  307. reallen--;
  308. ret++;
  309. data->delegFlag = (*p >> 7) & 1;
  310. data->mutualFlag = (*p >> 6) & 1;
  311. data->replayFlag = (*p >> 5) & 1;
  312. data->sequenceFlag = (*p >> 4) & 1;
  313. data->anonFlag = (*p >> 3) & 1;
  314. data->confFlag = (*p >> 2) & 1;
  315. data->integFlag = (*p >> 1) & 1;
  316. p += reallen;
  317. len -= reallen;
  318. ret += reallen;
  319. if (size)
  320. *size = ret;
  321. return 0;
  322. fail:
  323. free_ContextFlags(data);
  324. return e;
  325. }
  326. static void
  327. free_ContextFlags(ContextFlags * data)
  328. {
  329. (void)data;
  330. }
  331. /* unused function: length_ContextFlags */
  332. /* unused function: copy_ContextFlags */
  333. /* unused function: ContextFlags2int */
  334. /* unused function: int2ContextFlags */
  335. /* unused variable: ContextFlags_units */
  336. /* unused function: asn1_ContextFlags_units */
  337. /* Generated from spnego.asn1 */
  338. /* Do not edit */
  339. #define BACK if (e) return e; p -= l; len -= l; ret += l
  340. static int
  341. encode_NegTokenInit(unsigned char *p, size_t len, const NegTokenInit * data, size_t * size)
  342. {
  343. size_t ret = 0;
  344. size_t l;
  345. int i, e;
  346. i = 0;
  347. if ((data)->mechListMIC) {
  348. int oldret = ret;
  349. ret = 0;
  350. e = encode_octet_string(p, len, (data)->mechListMIC, &l);
  351. BACK;
  352. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
  353. BACK;
  354. ret += oldret;
  355. }
  356. if ((data)->mechToken) {
  357. int oldret = ret;
  358. ret = 0;
  359. e = encode_octet_string(p, len, (data)->mechToken, &l);
  360. BACK;
  361. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
  362. BACK;
  363. ret += oldret;
  364. }
  365. if ((data)->reqFlags) {
  366. int oldret = ret;
  367. ret = 0;
  368. e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
  369. BACK;
  370. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
  371. BACK;
  372. ret += oldret;
  373. } {
  374. int oldret = ret;
  375. ret = 0;
  376. e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
  377. BACK;
  378. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
  379. BACK;
  380. ret += oldret;
  381. }
  382. e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
  383. BACK;
  384. *size = ret;
  385. return 0;
  386. }
  387. #define FORW if(e) goto fail; p += l; len -= l; ret += l
  388. static int
  389. decode_NegTokenInit(const unsigned char *p, size_t len, NegTokenInit * data, size_t * size)
  390. {
  391. size_t ret = 0, reallen;
  392. size_t l;
  393. int e;
  394. memset(data, 0, sizeof(*data));
  395. reallen = 0;
  396. e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
  397. FORW;
  398. {
  399. int dce_fix;
  400. if ((dce_fix = fix_dce(reallen, &len)) < 0)
  401. return ASN1_BAD_FORMAT;
  402. {
  403. size_t newlen, oldlen;
  404. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
  405. if (e)
  406. return e;
  407. else {
  408. p += l;
  409. len -= l;
  410. ret += l;
  411. e = der_get_length(p, len, &newlen, &l);
  412. FORW;
  413. {
  414. int dce_fix;
  415. oldlen = len;
  416. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  417. return ASN1_BAD_FORMAT;
  418. e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
  419. FORW;
  420. if (dce_fix) {
  421. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  422. FORW;
  423. } else
  424. len = oldlen - newlen;
  425. }
  426. }
  427. }
  428. {
  429. size_t newlen, oldlen;
  430. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
  431. if (e)
  432. (data)->reqFlags = NULL;
  433. else {
  434. p += l;
  435. len -= l;
  436. ret += l;
  437. e = der_get_length(p, len, &newlen, &l);
  438. FORW;
  439. {
  440. int dce_fix;
  441. oldlen = len;
  442. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  443. return ASN1_BAD_FORMAT;
  444. (data)->reqFlags = malloc(sizeof(*(data)->reqFlags));
  445. if ((data)->reqFlags == NULL)
  446. return ENOMEM;
  447. e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
  448. FORW;
  449. if (dce_fix) {
  450. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  451. FORW;
  452. } else
  453. len = oldlen - newlen;
  454. }
  455. }
  456. }
  457. {
  458. size_t newlen, oldlen;
  459. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
  460. if (e)
  461. (data)->mechToken = NULL;
  462. else {
  463. p += l;
  464. len -= l;
  465. ret += l;
  466. e = der_get_length(p, len, &newlen, &l);
  467. FORW;
  468. {
  469. int dce_fix;
  470. oldlen = len;
  471. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  472. return ASN1_BAD_FORMAT;
  473. (data)->mechToken = malloc(sizeof(*(data)->mechToken));
  474. if ((data)->mechToken == NULL)
  475. return ENOMEM;
  476. e = decode_octet_string(p, len, (data)->mechToken, &l);
  477. FORW;
  478. if (dce_fix) {
  479. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  480. FORW;
  481. } else
  482. len = oldlen - newlen;
  483. }
  484. }
  485. }
  486. {
  487. size_t newlen, oldlen;
  488. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
  489. if (e)
  490. (data)->mechListMIC = NULL;
  491. else {
  492. p += l;
  493. len -= l;
  494. ret += l;
  495. e = der_get_length(p, len, &newlen, &l);
  496. FORW;
  497. {
  498. int dce_fix;
  499. oldlen = len;
  500. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  501. return ASN1_BAD_FORMAT;
  502. (data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
  503. if ((data)->mechListMIC == NULL)
  504. return ENOMEM;
  505. e = decode_octet_string(p, len, (data)->mechListMIC, &l);
  506. FORW;
  507. if (dce_fix) {
  508. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  509. FORW;
  510. } else
  511. len = oldlen - newlen;
  512. }
  513. }
  514. }
  515. if (dce_fix) {
  516. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  517. FORW;
  518. }
  519. }
  520. if (size)
  521. *size = ret;
  522. return 0;
  523. fail:
  524. free_NegTokenInit(data);
  525. return e;
  526. }
  527. static void
  528. free_NegTokenInit(NegTokenInit * data)
  529. {
  530. free_MechTypeList(&(data)->mechTypes);
  531. if ((data)->reqFlags) {
  532. free_ContextFlags((data)->reqFlags);
  533. free((data)->reqFlags);
  534. (data)->reqFlags = NULL;
  535. }
  536. if ((data)->mechToken) {
  537. free_octet_string((data)->mechToken);
  538. free((data)->mechToken);
  539. (data)->mechToken = NULL;
  540. }
  541. if ((data)->mechListMIC) {
  542. free_octet_string((data)->mechListMIC);
  543. free((data)->mechListMIC);
  544. (data)->mechListMIC = NULL;
  545. }
  546. }
  547. /* unused function: length_NegTokenInit */
  548. /* unused function: copy_NegTokenInit */
  549. /* Generated from spnego.asn1 */
  550. /* Do not edit */
  551. #define BACK if (e) return e; p -= l; len -= l; ret += l
  552. static int
  553. encode_NegTokenResp(unsigned char *p, size_t len, const NegTokenResp * data, size_t * size)
  554. {
  555. size_t ret = 0;
  556. size_t l;
  557. int i, e;
  558. i = 0;
  559. if ((data)->mechListMIC) {
  560. int oldret = ret;
  561. ret = 0;
  562. e = encode_octet_string(p, len, (data)->mechListMIC, &l);
  563. BACK;
  564. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
  565. BACK;
  566. ret += oldret;
  567. }
  568. if ((data)->responseToken) {
  569. int oldret = ret;
  570. ret = 0;
  571. e = encode_octet_string(p, len, (data)->responseToken, &l);
  572. BACK;
  573. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
  574. BACK;
  575. ret += oldret;
  576. }
  577. if ((data)->supportedMech) {
  578. int oldret = ret;
  579. ret = 0;
  580. e = encode_MechType(p, len, (data)->supportedMech, &l);
  581. BACK;
  582. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
  583. BACK;
  584. ret += oldret;
  585. }
  586. if ((data)->negState) {
  587. int oldret = ret;
  588. ret = 0;
  589. e = encode_enumerated(p, len, (data)->negState, &l);
  590. BACK;
  591. e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
  592. BACK;
  593. ret += oldret;
  594. }
  595. e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
  596. BACK;
  597. *size = ret;
  598. return 0;
  599. }
  600. #define FORW if(e) goto fail; p += l; len -= l; ret += l
  601. static int
  602. decode_NegTokenResp(const unsigned char *p, size_t len, NegTokenResp * data, size_t * size)
  603. {
  604. size_t ret = 0, reallen;
  605. size_t l;
  606. int e;
  607. memset(data, 0, sizeof(*data));
  608. reallen = 0;
  609. e = der_match_tag_and_length(p, len, ASN1_C_UNIV, CONS, UT_Sequence, &reallen, &l);
  610. FORW;
  611. {
  612. int dce_fix;
  613. if ((dce_fix = fix_dce(reallen, &len)) < 0)
  614. return ASN1_BAD_FORMAT;
  615. {
  616. size_t newlen, oldlen;
  617. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, &l);
  618. if (e)
  619. (data)->negState = NULL;
  620. else {
  621. p += l;
  622. len -= l;
  623. ret += l;
  624. e = der_get_length(p, len, &newlen, &l);
  625. FORW;
  626. {
  627. int dce_fix;
  628. oldlen = len;
  629. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  630. return ASN1_BAD_FORMAT;
  631. (data)->negState = malloc(sizeof(*(data)->negState));
  632. if ((data)->negState == NULL)
  633. return ENOMEM;
  634. e = decode_enumerated(p, len, (data)->negState, &l);
  635. FORW;
  636. if (dce_fix) {
  637. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  638. FORW;
  639. } else
  640. len = oldlen - newlen;
  641. }
  642. }
  643. }
  644. {
  645. size_t newlen, oldlen;
  646. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, &l);
  647. if (e)
  648. (data)->supportedMech = NULL;
  649. else {
  650. p += l;
  651. len -= l;
  652. ret += l;
  653. e = der_get_length(p, len, &newlen, &l);
  654. FORW;
  655. {
  656. int dce_fix;
  657. oldlen = len;
  658. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  659. return ASN1_BAD_FORMAT;
  660. (data)->supportedMech = malloc(sizeof(*(data)->supportedMech));
  661. if ((data)->supportedMech == NULL)
  662. return ENOMEM;
  663. e = decode_MechType(p, len, (data)->supportedMech, &l);
  664. FORW;
  665. if (dce_fix) {
  666. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  667. FORW;
  668. } else
  669. len = oldlen - newlen;
  670. }
  671. }
  672. }
  673. {
  674. size_t newlen, oldlen;
  675. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 2, &l);
  676. if (e)
  677. (data)->responseToken = NULL;
  678. else {
  679. p += l;
  680. len -= l;
  681. ret += l;
  682. e = der_get_length(p, len, &newlen, &l);
  683. FORW;
  684. {
  685. int dce_fix;
  686. oldlen = len;
  687. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  688. return ASN1_BAD_FORMAT;
  689. (data)->responseToken = malloc(sizeof(*(data)->responseToken));
  690. if ((data)->responseToken == NULL)
  691. return ENOMEM;
  692. e = decode_octet_string(p, len, (data)->responseToken, &l);
  693. FORW;
  694. if (dce_fix) {
  695. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  696. FORW;
  697. } else
  698. len = oldlen - newlen;
  699. }
  700. }
  701. }
  702. {
  703. size_t newlen, oldlen;
  704. e = der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 3, &l);
  705. if (e)
  706. (data)->mechListMIC = NULL;
  707. else {
  708. p += l;
  709. len -= l;
  710. ret += l;
  711. e = der_get_length(p, len, &newlen, &l);
  712. FORW;
  713. {
  714. int dce_fix;
  715. oldlen = len;
  716. if ((dce_fix = fix_dce(newlen, &len)) < 0)
  717. return ASN1_BAD_FORMAT;
  718. (data)->mechListMIC = malloc(sizeof(*(data)->mechListMIC));
  719. if ((data)->mechListMIC == NULL)
  720. return ENOMEM;
  721. e = decode_octet_string(p, len, (data)->mechListMIC, &l);
  722. FORW;
  723. if (dce_fix) {
  724. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  725. FORW;
  726. } else
  727. len = oldlen - newlen;
  728. }
  729. }
  730. }
  731. if (dce_fix) {
  732. e = der_match_tag_and_length(p, len, (Der_class) 0, (Der_type) 0, 0, &reallen, &l);
  733. FORW;
  734. }
  735. }
  736. if (size)
  737. *size = ret;
  738. return 0;
  739. fail:
  740. free_NegTokenResp(data);
  741. return e;
  742. }
  743. static void
  744. free_NegTokenResp(NegTokenResp * data)
  745. {
  746. if ((data)->negState) {
  747. free((data)->negState);
  748. (data)->negState = NULL;
  749. }
  750. if ((data)->supportedMech) {
  751. free_MechType((data)->supportedMech);
  752. free((data)->supportedMech);
  753. (data)->supportedMech = NULL;
  754. }
  755. if ((data)->responseToken) {
  756. free_octet_string((data)->responseToken);
  757. free((data)->responseToken);
  758. (data)->responseToken = NULL;
  759. }
  760. if ((data)->mechListMIC) {
  761. free_octet_string((data)->mechListMIC);
  762. free((data)->mechListMIC);
  763. (data)->mechListMIC = NULL;
  764. }
  765. }
  766. /* unused function: length_NegTokenResp */
  767. /* unused function: copy_NegTokenResp */
  768. /* Generated from spnego.asn1 */
  769. /* Do not edit */
  770. /* CHOICE */
  771. /* unused variable: asn1_NegotiationToken_dummy_holder */