Untitled

SUBMITTED BY: Guest

DATE: Dec. 2, 2013, 12:07 p.m.

FORMAT: Text only

SIZE: 26.7 kB

Raw Download

HITS: 681

Report
  1. /************************************************************************/
  2. /* SISCO SOFTWARE MODULE HEADER *****************************************/
  3. /************************************************************************/
  4. /* (c) Copyright Systems Integration Specialists Company, Inc., */
  5. /* 1999-2002, All Rights Reserved. */
  6. /* */
  7. /* PROPRIETARY AND CONFIDENTIAL */
  8. /* */
  9. /* MODULE NAME : goose.c */
  10. /* PRODUCT(S) : ASN1DE */
  11. /* */
  12. /* MODULE DESCRIPTION : */
  13. /* */
  14. /* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
  15. /* */
  16. /* MODIFICATION LOG : */
  17. /* Date Who Rev Comments */
  18. /* -------- --- ------ ------------------------------------------- */
  19. /* 12/12/03 JRB 09 u_a_unit_data_ind: memset GOOSE_INFO struct */
  20. /* to all 0 at start of decode. */
  21. /* 03/31/03 JRB 08 asn1r_get_bitstr: add max_bits arg. */
  22. /* 12/11/02 JRB 07 Del mvl_acse.h include. */
  23. /* 03/05/02 JRB 06 Del unused proto. Add braces when initializing*/
  24. /* ASN1R_TAG_CTRL_1 structs. */
  25. /* 01/10/02 JRB 05 No longer need bind_id. */
  26. /* Chg args to _goose_decode_mms. */
  27. /* Add gse_uca_decode */
  28. /* 07/25/00 RKR 04 Reconciled changes from BSD */
  29. /* 12/10/99 JRB 03 Fix mmsl_send_goose & _goose_tx_audt_apdu */
  30. /* to properly check return codes. */
  31. /* 09/10/99 JRB 02 Use asn1r_get_u32 for decoding of SqNum, */
  32. /* StNum, HoldTim, & BackTim (encode is OK). */
  33. /* 06/25/99 MDE 01 Created */
  34. /************************************************************************/
  36. #include "glbtypes.h"
  37. #include "sysincs.h"
  38. #include "asn1r.h"
  39. #include "clnp_usr.h"
  40. #include "clnp_sne.h"
  41. #include "clnp.h" /* for clnpl_decode */
  42. #include "goose.h"
  44. /* For loopback testing use this define */
  45. /* #define GOOSE_TEST */
  47. /************************************************************************/
  48. /************************************************************************/
  49. /* Static functions */
  51. static ST_RET _goose_tx_audt_apdu (GOOSE_INFO *gi, ST_UCHAR *goose_mms_pdu,
  52. ST_INT goose_mms_pdu_len);
  54. static ST_RET _goose_encode_mms (ST_UCHAR *asn1_buf, ST_INT asn1_buf_size,
  55. ST_UCHAR **goose_asn1_out, ST_INT *goose_asn1_len_out,
  56. GOOSE_INFO *gi);
  58. static ST_RET _goose_decode_mms (AUDT_APDU *audt_apdu, GOOSE_INFO *gi);
  60. static ST_VOID _goose_unconf_req (ASN1_DEC_CTXT *ac);
  61. static ST_VOID _goose_info_rpt (ASN1_DEC_CTXT *ac);
  62. static ST_VOID _goose_list_of_var (ASN1_DEC_CTXT *ac);
  63. static ST_VOID _goose_seq_of_varspec (ASN1_DEC_CTXT *ac);
  64. static ST_VOID _goose_named (ASN1_DEC_CTXT *ac);
  65. static ST_VOID _goose_vmd_spec (ASN1_DEC_CTXT *ac);
  66. static ST_VOID _goose_named_done (ASN1_DEC_CTXT *ac);
  67. static ST_VOID _goose_seq_of_varspec_done (ASN1_DEC_CTXT *ac);
  68. static ST_VOID _goose_list_of_var_done (ASN1_DEC_CTXT *ac);
  69. static ST_VOID _goose_list_acc_rslt (ASN1_DEC_CTXT *ac);
  70. static ST_VOID _goose_struct (ASN1_DEC_CTXT *ac);
  71. static ST_VOID _goose_get_app_id (ASN1_DEC_CTXT *ac);
  72. static ST_VOID _goose_get_sent_time (ASN1_DEC_CTXT *ac);
  73. static ST_VOID _goose_get_seqnum (ASN1_DEC_CTXT *ac);
  74. static ST_VOID _goose_get_sub_seq (ASN1_DEC_CTXT *ac);
  75. static ST_VOID _goose_get_hold_time (ASN1_DEC_CTXT *ac);
  76. static ST_VOID _goose_get_back_time (ASN1_DEC_CTXT *ac);
  77. static ST_VOID _goose_get_phsid (ASN1_DEC_CTXT *ac);
  78. static ST_VOID _goose_get_dnabits (ASN1_DEC_CTXT *ac);
  79. static ST_VOID _goose_get_usrbits (ASN1_DEC_CTXT *ac);
  80. static ST_VOID _goose_struct_done (ASN1_DEC_CTXT *ac);
  81. static ST_VOID _goose_list_acc_rslt_done (ASN1_DEC_CTXT *ac);
  82. static ST_VOID _goose_info_rpt_done (ASN1_DEC_CTXT *ac);
  83. static ST_VOID _goose_unconf_req_done (ASN1_DEC_CTXT *ac);
  84. static ST_VOID _goose_done_ok (ASN1_DEC_CTXT *ac);
  85. static ST_VOID _goose_done_error (ASN1_DEC_CTXT *ac);
  86. static ST_VOID _goose_error (ASN1_DEC_CTXT *ac, ST_RET err);
  88. /************************************************************************/
  89. /************************************************************************/
  90. /* mmsl_send_goose */
  91. /************************************************************************/
  93. ST_RET mmsl_send_goose (GOOSE_INFO *gi)
  94. {
  95. ST_UCHAR asn1_buf[GOOSE_MAX_PDU_SIZE];
  96. ST_UCHAR *goose_mms_pdu;
  97. ST_INT goose_mms_pdu_len;
  98. ST_RET rc;
  99. #ifdef GOOSE_TEST
  100. GOOSE_INFO goose_rx_info;
  101. #endif
  103. /* Encode the MMS PDU, given the user GOOSE information */
  104. rc = _goose_encode_mms (asn1_buf, GOOSE_MAX_PDU_SIZE,
  105. &goose_mms_pdu, &goose_mms_pdu_len, gi);
  107. /* Finish the a-unit data encoding and transmit the PDU */
  108. if (rc == SD_SUCCESS)
  109. rc = _goose_tx_audt_apdu (gi, goose_mms_pdu, goose_mms_pdu_len);
  111. #ifdef GOOSE_TEST
  112. /* For test, pretend we received it too! */
  113. memset(&goose_rx_info, 0, sizeof (GOOSE_INFO));
  114. memcpy(&goose_rx_info.audtApdu, &gi->audtApdu, sizeof (AUDT_APDU));
  116. rc = _goose_decode_mms (&gi->audtApdu, &goose_rx_info);
  117. if (rc != 0)
  118. printf ("\n Whooops!");
  119. rc = memcmp (gi, &goose_rx_info, sizeof (GOOSE_INFO));
  120. if (rc != 0)
  121. printf ("\n Whoa!");
  122. else
  123. u_mmsl_goose_received (&goose_rx_info);
  124. #endif
  126. return (rc);
  127. }
  129. /************************************************************************/
  130. /* _goose_encode_mms */
  131. /************************************************************************/
  133. static ST_RET _goose_encode_mms (ST_UCHAR *asn1_buf, ST_INT asn1_buf_size,
  134. ST_UCHAR **goose_mms_pdu_out, ST_INT *goose_mms_pdu_len_out,
  135. GOOSE_INFO *gi)
  136. {
  137. ASN1_ENC_CTXT ac;
  138. ST_UCHAR *pdu_start; /* 000725 BSD - Changed from ST_CHAR* to ST_UCHAR* */
  139. ST_INT pdu_len;
  141. asn1r_strt_asn1_bld (&ac, asn1_buf, asn1_buf_size);
  142. asn1r_strt_constr (&ac); /* unconfirmed requests */
  143. asn1r_strt_constr (&ac); /* information report body */
  144. asn1r_strt_constr (&ac); /* access result */
  145. asn1r_strt_constr (&ac); /* GOOSE data is a structure */
  147. asn1r_wr_bitstr (&ac, gi->UserSt, gi->num_usr_bits);
  148. asn1r_fin_prim (&ac, 4, CTX);
  149. asn1r_wr_bitstr (&ac, gi->DNA, gi->num_dna_bits);
  150. asn1r_fin_prim (&ac, 4, CTX);
  151. asn1r_wr_u16 (&ac, gi->PhsID);
  152. asn1r_fin_prim (&ac, 6, CTX);
  153. asn1r_wr_u32 (&ac, gi->BackTim);
  154. asn1r_fin_prim (&ac, 6, CTX);
  155. asn1r_wr_u32 (&ac, gi->HoldTim);
  156. asn1r_fin_prim (&ac, 6, CTX);
  157. asn1r_wr_u32 (&ac, gi->StNum);
  158. asn1r_fin_prim (&ac, 6, CTX);
  159. asn1r_wr_u32 (&ac, gi->SqNum);
  160. asn1r_fin_prim (&ac, 6, CTX);
  161. asn1r_wr_btod (&ac, &gi->t);
  162. asn1r_fin_prim (&ac, 12, CTX);
  163. asn1r_wr_vstr (&ac, gi->SendingIED);
  164. asn1r_fin_prim (&ac, 10, CTX);
  165. asn1r_fin_constr (&ac, 2, CTX, DEF); /* end of GOOSE data struct */
  166. asn1r_fin_constr (&ac, 0, CTX, DEF); /* access result being finished */
  168. asn1r_strt_constr (&ac);
  169. asn1r_strt_constr (&ac); /* variable access specification */
  170. asn1r_strt_constr (&ac); /* object name start */
  171. asn1r_wr_vstr (&ac, "GOOSE");
  172. asn1r_fin_prim (&ac, 0, CTX); /* VMD Specific Name */
  173. asn1r_fin_constr (&ac, 0, CTX, DEF);
  174. asn1r_fin_constr (&ac, SEQ_CODE, UNI, DEF);/* end variable access specification */
  175. asn1r_fin_constr (&ac, 0, CTX, DEF); /* end of information report body */
  176. asn1r_fin_constr (&ac, 0, CTX, DEF);
  177. asn1r_fin_constr (&ac, 3, CTX, DEF); /* end of unconfirmed service */
  179. if (ac.asn1r_encode_overrun) /* Check for encode overrun */
  180. return (SD_FAILURE);
  182. pdu_start = ac.asn1r_field_ptr + 1;
  183. pdu_len = (asn1_buf + asn1_buf_size) - pdu_start;
  185. *goose_mms_pdu_out = pdu_start;
  186. *goose_mms_pdu_len_out = pdu_len;
  187. return (SD_SUCCESS);
  188. }
  190. /************************************************************************/
  191. /* _goose_tx_audt_apdu */
  192. /************************************************************************/
  194. static ST_RET _goose_tx_audt_apdu (GOOSE_INFO *gi, ST_UCHAR *goose_mms_pdu,
  195. ST_INT goose_mms_pdu_len)
  196. {
  197. ST_RET ret;
  198. gi->audtApdu.user_info.ptr = goose_mms_pdu;
  199. gi->audtApdu.user_info.len = goose_mms_pdu_len;
  200. ret = a_unit_data_req (&gi->audtApdu);
  201. return (ret);
  202. }
  205. /************************************************************************/
  206. /************************************************************************/
  207. /* u_a_unit_data_ind */
  208. /* This "user" function processes the A-UNIT-DATA.ind. It is customized */
  209. /* to handle only GOOSE packets. It decodes the GOOSE packet, and then */
  210. /* passes the decoded info to the user by calling "u_mmsl_goose_received.*/
  211. /* If the packet is not a GOOSE, or it can't be decoded, it is ignored. */
  212. /************************************************************************/
  213. ST_VOID u_a_unit_data_ind (AUDT_APDU *audt_apdu)
  214. {
  215. ST_RET rc;
  216. GOOSE_INFO goose_info; /* for u_a_unit_data_ind */
  218. /* Start with clean structure. */
  219. memset (&goose_info, 0, sizeof (goose_info));
  221. /* Decode GOOSE PDU. */
  222. rc = _goose_decode_mms (audt_apdu, &goose_info);
  224. /* Tell the user about the received GOOSE message */
  225. if (rc == SD_SUCCESS)
  226. u_mmsl_goose_received (&goose_info);
  227. else
  228. {
  229. /* SLOGALWAYS0 ("A-UNIT-DATA.ind is not a GOOSE. Ignoring it."); */
  230. }
  231. }
  233. /************************************************************************/
  234. /* _goose_decode_mms */
  235. /************************************************************************/
  238. static ST_RET _goose_decode_mms (AUDT_APDU *audt_apdu, GOOSE_INFO *gi)
  239. {
  240. ASN1_DEC_CTXT asn1_ctxt;
  241. ASN1_DEC_CTXT *ac;
  242. static ASN1R_TAG_CTRL_1 asn1r_tags =
  243. {1, {{ASN1R_TAG_VAL (CTX | CONSTR, 3), _goose_unconf_req}}};
  245. /* Copy AUDT struct to goose_info so user can access all addressing info.*/
  246. memcpy (&gi->audtApdu, audt_apdu, sizeof (AUDT_APDU));
  248. ac = &asn1_ctxt;
  249. memset (ac, 0, sizeof (ASN1_DEC_CTXT));
  250. ac->usr_info[0] = gi;
  251. ac->asn1r_err_fun = _goose_error;
  252. ac->asn1r_decode_done_fun = _goose_done_error;
  253. ac->asn1r_decode_method = ASN1_TABLE_METHOD;
  254. ac->asn1r_tag_table = &asn1r_tags;
  255. asn1r_decode_asn1 (ac, audt_apdu->user_info.ptr, audt_apdu->user_info.len);
  256. if (ac->asn1r_pdu_dec_err != NO_DECODE_ERR)
  257. return (SD_FAILURE);
  259. return (SD_SUCCESS);
  260. }
  262. /************************************************************************/
  263. /* _goose_unconf_req */
  264. /************************************************************************/
  266. static ST_VOID _goose_unconf_req (ASN1_DEC_CTXT *ac)
  267. {
  268. static ASN1R_TAG_CTRL_1 asn1r_tags =
  269. {1, {{ASN1R_TAG_VAL(CTX | CONSTR, 0), _goose_info_rpt}}};
  271. ac->asn1r_tag_table = &asn1r_tags;
  272. }
  274. /************************************************************************/
  275. /* _goose_info_rpt */
  276. /************************************************************************/
  278. static ST_VOID _goose_info_rpt (ASN1_DEC_CTXT *ac)
  279. {
  280. static ASN1R_TAG_CTRL_1 asn1r_tags =
  281. {1, {{ASN1R_TAG_VAL (CTX | CONSTR, 0), _goose_list_of_var}}};
  283. ac->asn1r_tag_table = &asn1r_tags;
  284. }
  286. /************************************************************************/
  287. /* _goose_list_of_var */
  288. /************************************************************************/
  290. static ST_VOID _goose_list_of_var (ASN1_DEC_CTXT *ac)
  291. {
  292. static ASN1R_TAG_CTRL_1 asn1r_tags =
  293. {1, {{ASN1R_TAG_VAL (UNI | CONSTR, SEQ_CODE), _goose_seq_of_varspec}}};
  295. ac->asn1r_tag_table = &asn1r_tags;
  296. }
  298. /************************************************************************/
  299. /* _goose_seq_of_varspec */
  300. /************************************************************************/
  302. static ST_VOID _goose_seq_of_varspec (ASN1_DEC_CTXT *ac)
  303. {
  304. static ASN1R_TAG_CTRL_1 asn1r_tags =
  305. {1, {{ASN1R_TAG_VAL (CTX | CONSTR, 0), _goose_named}}};
  307. ac->asn1r_tag_table = &asn1r_tags;
  308. }
  310. /************************************************************************/
  311. /* _goose_named */
  312. /************************************************************************/
  314. static ST_VOID _goose_named (ASN1_DEC_CTXT *ac)
  315. {
  316. static ASN1R_TAG_CTRL_1 asn1r_tags =
  317. {1, {{ASN1R_TAG_VAL (CTX, 0), _goose_vmd_spec}}};
  319. ac->asn1r_tag_table = &asn1r_tags;
  320. }
  322. /************************************************************************/
  323. /* _goose_vmd_spec */
  324. /************************************************************************/
  326. static ST_VOID _goose_vmd_spec (ASN1_DEC_CTXT *ac)
  327. {
  328. ST_CHAR *data_ptr;
  330. data_ptr = (ST_CHAR *) ac->asn1r_field_ptr-1;
  331. asn1r_get_vstr (ac, data_ptr);
  332. if (strcmp (data_ptr, "GOOSE") != 0)
  333. asn1r_set_dec_err (ac, GOOSE_NAME_MISMATCH);
  334. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_named_done;
  335. }
  337. /************************************************************************/
  338. /* _goose_named_done */
  339. /************************************************************************/
  341. static ST_VOID _goose_named_done (ASN1_DEC_CTXT *ac)
  342. {
  343. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_seq_of_varspec_done;
  344. }
  346. /************************************************************************/
  347. /* _goose_seq_of_varspec_done */
  348. /************************************************************************/
  350. static ST_VOID _goose_seq_of_varspec_done (ASN1_DEC_CTXT *ac)
  351. {
  352. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_list_of_var_done;
  353. }
  355. /************************************************************************/
  356. /* _goose_list_of_var_done */
  357. /************************************************************************/
  359. static ST_VOID _goose_list_of_var_done (ASN1_DEC_CTXT *ac)
  360. {
  361. static ASN1R_TAG_CTRL_1 asn1r_tags =
  362. {1, {{ASN1R_TAG_VAL (CTX | CONSTR, 0), _goose_list_acc_rslt}}};
  364. ac->asn1r_tag_table = &asn1r_tags;
  365. }
  367. /************************************************************************/
  368. /* _goose_list_acc_rslt */
  369. /************************************************************************/
  371. static ST_VOID _goose_list_acc_rslt (ASN1_DEC_CTXT *ac)
  372. {
  373. static ASN1R_TAG_CTRL_1 asn1r_tags =
  374. {1, {{ASN1R_TAG_VAL (CTX | CONSTR, 2), _goose_struct}}};
  376. ac->asn1r_tag_table = &asn1r_tags;
  377. }
  379. /************************************************************************/
  380. /* _goose_struct */
  381. /************************************************************************/
  383. static ST_VOID _goose_struct (ASN1_DEC_CTXT *ac)
  384. {
  385. static ASN1R_TAG_CTRL_1 asn1r_tags =
  386. {1, {{ASN1R_TAG_VAL (CTX, 10), _goose_get_app_id}}};
  388. ac->asn1r_tag_table = &asn1r_tags;
  389. }
  391. /************************************************************************/
  392. /* _goose_get_app_id */
  393. /************************************************************************/
  395. static ST_VOID _goose_get_app_id (ASN1_DEC_CTXT *ac)
  396. {
  397. GOOSE_INFO *_goose_dec_info;
  398. static ASN1R_TAG_CTRL_1 asn1r_tags =
  399. {1, {{ASN1R_TAG_VAL (CTX, 12), _goose_get_sent_time}}};
  401. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  403. asn1r_get_vstr (ac, _goose_dec_info->SendingIED);
  404. ac->asn1r_tag_table = &asn1r_tags;
  405. }
  407. /************************************************************************/
  408. /* _goose_get_sent_time */
  409. /************************************************************************/
  411. static ST_VOID _goose_get_sent_time (ASN1_DEC_CTXT *ac)
  412. {
  413. GOOSE_INFO *_goose_dec_info;
  414. static ASN1R_TAG_CTRL_1 asn1r_tags =
  415. {1, {{ASN1R_TAG_VAL (CTX, 6), _goose_get_seqnum}}};
  417. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  418. asn1r_get_btod (ac, &_goose_dec_info->t);
  419. ac->asn1r_tag_table = &asn1r_tags;
  420. }
  422. /************************************************************************/
  423. /* _goose_get_seqnum */
  424. /************************************************************************/
  426. static ST_VOID _goose_get_seqnum (ASN1_DEC_CTXT *ac)
  427. {
  428. GOOSE_INFO *_goose_dec_info;
  429. static ASN1R_TAG_CTRL_1 asn1r_tags =
  430. {1, {{ASN1R_TAG_VAL (CTX, 6), _goose_get_sub_seq}}};
  432. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  433. asn1r_get_u32 (ac, &_goose_dec_info->SqNum);
  434. ac->asn1r_tag_table = &asn1r_tags;
  435. }
  437. /************************************************************************/
  438. /* _goose_get_sub_seq */
  439. /************************************************************************/
  441. static ST_VOID _goose_get_sub_seq (ASN1_DEC_CTXT *ac)
  442. {
  443. GOOSE_INFO *_goose_dec_info;
  444. static ASN1R_TAG_CTRL_1 asn1r_tags =
  445. {1, {{ASN1R_TAG_VAL (CTX, 6), _goose_get_hold_time}}};
  447. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  448. asn1r_get_u32 (ac, &_goose_dec_info->StNum);
  449. ac->asn1r_tag_table = &asn1r_tags;
  450. }
  452. /************************************************************************/
  453. /* _goose_get_hold_time */
  454. /************************************************************************/
  456. static ST_VOID _goose_get_hold_time (ASN1_DEC_CTXT *ac)
  457. {
  458. GOOSE_INFO *_goose_dec_info;
  459. static ASN1R_TAG_CTRL_1 asn1r_tags =
  460. {1, {{ASN1R_TAG_VAL (CTX, 6), _goose_get_back_time}}};
  462. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  463. asn1r_get_u32 (ac, &_goose_dec_info->HoldTim);
  464. ac->asn1r_tag_table = &asn1r_tags;
  465. }
  467. /************************************************************************/
  468. /* _goose_get_back_time */
  469. /************************************************************************/
  471. static ST_VOID _goose_get_back_time (ASN1_DEC_CTXT *ac)
  472. {
  473. GOOSE_INFO *_goose_dec_info;
  474. static ASN1R_TAG_CTRL_1 asn1r_tags =
  475. {1, {{ASN1R_TAG_VAL (CTX, 6), _goose_get_phsid}}};
  477. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  478. asn1r_get_u32 (ac, &_goose_dec_info->BackTim);
  479. ac->asn1r_tag_table = &asn1r_tags;
  480. }
  482. /************************************************************************/
  483. /* _goose_get_phsid */
  484. /************************************************************************/
  486. static ST_VOID _goose_get_phsid (ASN1_DEC_CTXT *ac)
  487. {
  488. GOOSE_INFO *_goose_dec_info;
  489. static ASN1R_TAG_CTRL_1 asn1r_tags =
  490. {1, {{ASN1R_TAG_VAL (CTX, 4), _goose_get_dnabits}}};
  492. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  493. asn1r_get_u16 (ac, &_goose_dec_info->PhsID);
  494. ac->asn1r_tag_table = &asn1r_tags;
  495. }
  497. /************************************************************************/
  498. /* _goose_get_dnabits */
  499. /************************************************************************/
  501. static ST_VOID _goose_get_dnabits (ASN1_DEC_CTXT *ac)
  502. {
  503. GOOSE_INFO *_goose_dec_info;
  504. static ASN1R_TAG_CTRL_1 asn1r_tags =
  505. {1, {{ASN1R_TAG_VAL (CTX, 4), _goose_get_usrbits}}};
  507. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  508. asn1r_get_bitstr (ac, _goose_dec_info->DNA, GOOSE_MAX_NUM_DNA_BITS);
  509. _goose_dec_info->num_dna_bits = ac->asn1r_bitcount;
  510. ac->asn1r_tag_table = &asn1r_tags;
  511. }
  513. /************************************************************************/
  514. /* _goose_get_usrbits */
  515. /************************************************************************/
  517. static ST_VOID _goose_get_usrbits (ASN1_DEC_CTXT *ac)
  518. {
  519. GOOSE_INFO *_goose_dec_info;
  521. _goose_dec_info = (GOOSE_INFO *) ac->usr_info[0];
  523. asn1r_get_bitstr (ac, _goose_dec_info->UserSt, GOOSE_MAX_NUM_USR_BITS);
  524. _goose_dec_info->num_usr_bits = ac->asn1r_bitcount;
  525. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_struct_done;
  526. }
  528. /************************************************************************/
  529. /* _goose_struct_done */
  530. /************************************************************************/
  532. static ST_VOID _goose_struct_done (ASN1_DEC_CTXT *ac)
  533. {
  534. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_list_acc_rslt_done;
  535. }
  537. /************************************************************************/
  538. /* _goose_list_acc_rslt_done */
  539. /************************************************************************/
  541. static ST_VOID _goose_list_acc_rslt_done (ASN1_DEC_CTXT *ac)
  542. {
  543. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_info_rpt_done;
  544. }
  546. /************************************************************************/
  547. /* _goose_info_rpt_done */
  548. /************************************************************************/
  550. static ST_VOID _goose_info_rpt_done (ASN1_DEC_CTXT *ac)
  551. {
  552. ac->asn1r_c_done_fun [ac->asn1r_msg_level] = _goose_unconf_req_done;
  553. }
  555. /************************************************************************/
  556. /* _goose_unconf_req_done */
  557. /************************************************************************/
  559. static ST_VOID _goose_unconf_req_done (ASN1_DEC_CTXT *ac)
  560. {
  561. ac->asn1r_decode_done_fun = _goose_done_ok;
  562. ac->asn1r_decode_done = SD_TRUE;
  563. }
  565. /************************************************************************/
  566. /* _goose_done_ok */
  567. /************************************************************************/
  569. static ST_VOID _goose_done_ok (ASN1_DEC_CTXT *ac)
  570. {
  571. }
  573. /************************************************************************/
  574. /* _goose_done_error */
  575. /************************************************************************/
  577. static ST_VOID _goose_done_error (ASN1_DEC_CTXT *ac)
  578. {
  579. asn1r_set_dec_err (ac, GOOSE_DONE_TOO_SOON);
  580. }
  582. /************************************************************************/
  583. /* _goose_error */
  584. /************************************************************************/
  586. static ST_VOID _goose_error (ASN1_DEC_CTXT *ac, ST_RET err)
  587. {
  588. }
  590. /************************************************************************/
  591. /* gse_uca_decode */
  592. /* This function decodes the subnet packet (sn_udt), and puts the */
  593. /* results in the user structure (goose_info). */
  594. /* First it decodes from SN_UNITDATA to N_UNITDATA. */
  595. /* Then it decodes from N_UNITDATA to AUDT_APDU. */
  596. /* Then it decodes from AUDT_APDU to GOOSE_INFO. */
  597. /************************************************************************/
  598. ST_RET gse_uca_decode (SN_UNITDATA *sn_udt, /* input subnet packet */
  599. GOOSE_INFO *goose_info) /* output GOOSE data */
  600. {
  601. ST_RET rc;
  602. N_UNITDATA *pNudt = NULL; /* intermediate decode result */
  603. AUDT_APDU audt; /* intermediate decode result */
  605. /* Decode from SN_UNITDATA to N_UNITDATA. */
  606. /* clnpl_decode allocs a N_UNITDATA structure if this is a N-Unitdata */
  607. /* packet, and changes the value of pNudt to point to it. */
  608. if ((rc = clnpl_decode (sn_udt, &pNudt)) != SD_SUCCESS)
  609. return (rc);
  610. if (pNudt==NULL)
  611. return (SD_FAILURE); /* does this ever happen? */
  613. /* Decode from N_UNITDATA to AUDT_APDU. */
  614. if ((rc = cltp_decode_nsdu_2 (pNudt, &audt)) != SD_SUCCESS)
  615. return (rc);
  616. /* CRITICAL: DON't free N_UNITDATA here, because AUDT_APDU has pointer into it. */
  618. /* Decode from AUDT_APDU to GOOSE_INFO. */
  619. rc = _goose_decode_mms (&audt, goose_info);
  621. /* Now it is safe to free N_UNITDATA. All data in GOOSE_INFO now. */
  622. clnp_free (pNudt);
  623. return (rc);
  624. }
comments powered by Disqus