wtlsdef.h

是一个手机功能的模拟程序

INT16
wtls_cvt_parameter_specifier (wap_cvt_t *obj, ParameterSpecifier *p);

INT16
wtls_cvt_public_key (wap_cvt_t *obj,
                     KeyExchangeSuite kes, PublicKey *p);

INT16
wtls_cvt_key_exchange_id (wap_cvt_t *obj, wtls_key_exchange_id *p);

INT16
wtls_cvt_client_hello (wap_cvt_t *obj, wtls_client_hello *p);

INT16
wtls_cvt_server_hello (wap_cvt_t *obj, wtls_server_hello *p);

INT16
wtls_cvt_server_certificate (wap_cvt_t *obj,
                             wtls_server_certificate *p);

INT16
wtls_cvt_server_key_exchange (wap_cvt_t *obj, KeyExchangeSuite kes,
                              wtls_server_key_exchange *p);

INT16
wtls_cvt_certificate_request (wap_cvt_t *obj,
                              wtls_certificate_request *p);

INT16
wtls_cvt_server_hello_done (wap_cvt_t *obj, wtls_server_hello_done *p);

INT16
wtls_cvt_client_certificate (wap_cvt_t *obj, wtls_client_certificate *p);

INT16
wtls_cvt_client_key_exchange (wap_cvt_t *obj, KeyExchangeSuite kes,
                              wtls_client_key_exchange *p);

INT16
wtls_cvt_certificate_verify (wap_cvt_t *obj, wtls_certificate_verify *p);

INT16
wtls_cvt_finished (wap_cvt_t *obj, wtls_finished *p);

INT16
wtls_cvt_record (wap_cvt_t *obj, wtls_record_t *p);


/*
 * Functions from Alert.c
 */
UINT32
wtls_alert_compute_checksum (BYTE *msg, UINT16 msglen);


/*
 * Functions from Connectn.c
 */
void
wtls_connection_free (void *connptr);

INT16
wtls_connection_state_init (wtls_connection_state *cstate);

INT16
wtls_pending_state_init (wtls_pending_state *pstate);

INT16
wtls_pending_state_install (wtls_connection_state *cstate,
                            wtls_pending_state *pstate);


/*
 * Functions from ConnMgr.c
 */
void *
wtls_cm_init (SDL_PId cm_proc, SDL_PId rec_proc,
              AddressType src_addr, AddressType dst_addr);

void
wtls_cm_terminate (void *connptr, SDL_Boolean established);

void
wtls_cm_get_connection_parameters (SDL_Octet bearer,
                                   SDL_Integer *maxRetransmissions,
                                   SDL_Integer *retryInterval);
SDL_Integer
wtls_cm_handshake_init (void *connptr, SDL_Boolean established);

INT16
wtls_cm_session_fetch1 (void *connptr, SDL_Integer result,
                        SDL_Octet session_options,
                        void *session_id, SDL_Octet session_length,
                        SDL_Octet mac_alg, SDL_Octet cipher_alg,
                        SDL_Octet compression_alg, void *private_key_id,
                        SDL_Natural creation_time);

INT16
wtls_cm_session_fetch2 (void *connptr, SDL_Integer result,
                        SDL_Octet master_secret_id);

INT16
wtls_cm_session_fetch3 (void *connptr, SDL_Integer result,
                        SDL_Octet session_options,
                        void *session_id, SDL_Octet session_length,
                        SDL_Octet mac_alg, SDL_Octet cipher_alg,
                        SDL_Octet compression_alg, void *private_key_id,
                        SDL_Natural creation_time);

SDL_Integer
wtls_cm_create_client_hello (void *connptr);

SDL_Integer
wtls_cm_continue_create_client_hello (void *connptr, SDL_Integer result,
                                      void *cmptr, SDL_Natural cmlen,
                                      void *kxptr, SDL_Natural kxlen,
                                      void *tkptr, SDL_Natural tklen,
                                      void **pbufptr, SDL_Natural *pbuflen);

SDL_Integer
wtls_cm_process_server_hello (void *connptr, void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_process_server_certificate (void *connptr,
                                    void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_process_server_key_exchange (void *connptr,
                                     void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_process_certificate_request (void *connptr,
                                     void *bufptr, SDL_Natural buflen);

INT16
wtls_cm_process_server_hello_done (void *connptr,
                                   void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_create_client_certificate_msg (void *connptr);

SDL_Integer
wtls_cm_continue_create_client_certificate_msg (void *connptr);

SDL_Integer
wtls_cm_process_client_certificate_response (void *connptr,
                                             SDL_Natural result,
                                             void *key_id,
                                             SDL_Natural key_idlen,
                                             void **pbufptr,
                                             SDL_Natural *pbuflen);
SDL_Integer
wtls_cm_create_client_key_exchange (void *connptr,
                                    void **pbufptr, SDL_Natural *pbuflen);

SDL_Integer
wtls_cm_create_certificate_verify_msg (void *connptr);

SDL_Integer
wtls_cm_process_compute_signature_response (void *connptr,
                                            SDL_Natural result,
                                            void **pbufptr,
                                            SDL_Natural *pbuflen);
SDL_Integer
wtls_cm_verify_cert (void *connptr);

SDL_Integer
wtls_cm_process_verify_cert_result (SDL_Integer res);

SDL_Integer
wtls_cm_create_verify_data (void *connptr);

SDL_Integer
wtls_cm_create_finished (void *connptr, void **pbufptr, SDL_Natural *pbuflen);

SDL_Integer
wtls_cm_process_finished (void *connptr, void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_check_server_finished (void *connptr, SDL_Integer result,
                               void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_get_handshake_type (void *bufptr, SDL_Natural buflen);

SDL_Integer
wtls_cm_process_data_msg (void *connptr,
                          void *bufptr, SDL_Natural buflen,
                          TDUnitdataIndType *data_ind);

SDL_Integer
wtls_cm_opening_msg_ind (void *connptr, SDL_Natural msg_type,
                         void *bufptr, SDL_Natural buflen,
                         TDUnitdataIndType *data_ind);

SDL_Integer
wtls_cm_get_next_outbound_message (void *connptr,
                                   void **precptr);

void
wtls_cm_handshake_finished (void *connptr);

void
wtls_cm_delete_connections_session (void *connptr);

SDL_Boolean
wtls_cm_can_abort_handshake (void *connptr);

void
wtls_cm_abort_handshake (void *connptr);

/*
 * Functions from Crypto.c
 */
INT16
wtls_crypto_init (wtls_crypto_t *cobj,
                  BulkCipherAlgorithm bulk_cipher_alg,
                  wtls_MAC_algorithm mac_alg,
                  UINT8 compression_alg);

HashAlgorithm
wtls_crypto_MAC_to_hash_alg (wtls_MAC_algorithm alg);

INT16
wtls_crypto_encrypt (wtls_crypto_t *cobj,
                     BYTE *key, BYTE *iv,
                     BYTE *buf, UINT16 buflen,
                     BYTE *outbuf);

INT16
wtls_crypto_decrypt (wtls_crypto_t *cobj,
                     BYTE *key, BYTE *iv,
                     BYTE *buf, UINT16 buflen,
                     BYTE *outbuf);
INT16
wtls_crypto_hash (wtls_crypto_t *cobj, BYTE *buf, UINT16 buflen, BYTE *digest);

INT16
wtls_crypto_hash_init (wtls_crypto_t *cobj);

INT16
wtls_crypto_hash_update (wtls_crypto_t *cobj, BYTE *buf, UINT16 buflen);

INT16
wtls_crypto_hash_final (wtls_crypto_t *cobj, BYTE *digest);

INT16
wtls_crypto_HMAC_init (wtls_crypto_t *cobj, BYTE *key, UINT16 keylen);

INT16
wtls_crypto_HMAC_update (wtls_crypto_t *cobj, BYTE *data, UINT16 datalen);

INT16
wtls_crypto_HMAC_final (wtls_crypto_t *cobj,
                        BYTE *key, UINT16 keylen, BYTE *result);

INT16
wtls_crypto_MAC (wtls_crypto_t *cobj, BYTE *mac_secret,
                 BYTE *buf, UINT16 buflen,
                 UINT16 seqnum, UINT8 rec_type,
                 BYTE *mac);

INT16
wtls_crypto_key_refresh1 (void *connptr, SDL_Natural state);

INT16
wtls_crypto_key_refresh2 (void *connptr, SDL_Natural state,
                          void *buf, SDL_Natural buflen);

INT16
wtls_crypto_key_refresh3 (void *connptr, SDL_Natural state);

INT16
wtls_crypto_key_refresh4 (void *connptr, SDL_Natural state, void *buf,
                          SDL_Natural buflen);

INT16
wtls_crypto_key_refresh5 (void *connptr, SDL_Natural state,
                          void *buf, SDL_Natural buflen);


/*
 * Functions from Handshake.c
 */
wtls_handshake_state *
wtls_handshake_state_new (void);

INT16
wtls_handshake_state_free (wtls_handshake_state *hs);

INT16
wtls_handshake_get_msg_type (BYTE *buf, UINT16 buflen);


/*
 * Functions from KeyExchange.c
 */
SDL_Integer
wtls_key_exchange_init (void *connptr);

SDL_Integer
wtls_key_exchange_continue (void *connptr,
                            SDL_Integer result, SDL_Octet master_secret_id,
                            void *public_value,
                            SDL_Natural public_valuelen);


/*
 * Functions from MgtEnt.c
 */
void
wtls_me_init (void);

void
wtls_me_terminate (void);


/*
 * Functions from Record.c
 */
void
wtls_rec_init (void);

INT16
wtls_rec_encrypt_record (void *connptr, void *recptr);

INT16
wtls_rec_decrypt_record (wtls_connection_state *cstate, wtls_record_t *rec);

INT16
wtls_rec_create_SDU (void *connptr, void *recptr, TDUnitdataReqType *data_req);

void
wtls_rec_append_record (void *connptr, void *recptr);

SDL_Integer
wtls_rec_create_handshake_record (void *connptr,
                                  void *buf, SDL_Natural buflen,
                                  void **pprec);

INT16
wtls_rec_create_CCS_record (void *connptr, void **pprec);

INT16
wtls_rec_create_alert_record (void *connptr,
                              SDL_Integer alert_level, SDL_Integer alert_desc,
                              void **pprec);

SDL_Integer
wtls_rec_prepare_data_record (void *connptr, void *recptr);

SDL_Integer
wtls_rec_create_data_and_buffer_SDU (void *connptr,
                                     void *recptr,
                                     TDUnitdataReqType *data_req);

INT16
wtls_rec_create_buffer_SDU (void *connptr, TDUnitdataReqType *data_req);

void
wtls_rec_clear_buffer (void *connptr);

void
wtls_rec_list_append (wtls_record_t *rec, wtls_record_t **rec_list);

void
wtls_rec_list_delete (wtls_record_t **rlist);

wtls_record_t *
wtls_rec_list_pop (wtls_record_t **rec_list);

void
wtls_rec_delete_record (wtls_record_t *rec);

INT16
wtls_rec_next_msg (void *connptr, void **pprec, SDL_Boolean same_SDU);

INT16
wtls_rec_continue_next_msg (void *connptr, void *recptr,
                            SDL_Natural *pmsg_type,
                            void **pbuf, SDL_Natural *pbuflen,
                            SDL_Natural *alert_level,
                            SDL_Natural *alert_desc);

INT16
wtls_rec_install_pending_read (void *connptr);

INT16
wtls_rec_install_pending_write (void *connptr);


/*
 * Functions from WTLSMain.c
 */
void
wtls_main_init (void);

void
wtls_main_terminate (void);

SDL_Integer
wtls_main_new_connection (SDL_PId cm_proc, SDL_PId rec_proc,
                          AddressType *src_addr, AddressType *dst_addr);

SDL_Integer
wtls_main_delete_connection (SDL_PId cm_proc);

SDL_PId
wtls_main_pop_connection (void);

SDL_PId
wtls_main_find_connection (AddressType *src_addr, AddressType *dst_addr,
                           SDL_PId *rec_proc);

SDL_PId
wtls_main_find_connection_by_port (SDL_Natural portnum);

SDL_Integer
wtls_main_append_message (SDL_PId cm_proc, pdubuf *msg);

SDL_Integer
wtls_main_check_pid (SDL_PId pid);

INT16
wtls_main_is_cleartext_alert (pdubuf *data);

SDL_Integer
wtls_main_create_no_connection_alert (TDUnitdataIndType *dataInd,
                                      TDUnitdataReqType *dataReq);

void
wtls_main_set_connection_pointer (SDL_PId pid, void *connptr);

void *
wtls_main_get_connection_pointer (SDL_PId pid);

wtls_record_t *
wtls_main_pop_incoming_message (SDL_PId pid);

wtls_record_t *
wtls_main_peek_incoming_message (SDL_PId pid);

wtls_record_t *
wtls_main_pop_outbound_message (SDL_PId pid);

INT16
wtls_main_clear_message_queue (SDL_PId pid);

SDL_Integer
wtls_main_split_SDU (SDL_PId cm_proc, pdubuf *SDU);

SDL_Integer
wtls_main_check_hello_request (pdubuf *pdu);

void
wtls_main_set_close_on_done (SDL_PId cm_proc,
                             SDL_Natural portnum,
                             SDL_Integer path);

SDL_Boolean
wtls_main_get_close_on_done (SDL_PId cm_proc,
                             SDL_Natural *portnum,
                             SDL_Integer *path);

/*
 * Functions from WTLSerr.c
 */
void
wtls_err_set (SDL_Integer errtype, SDL_Integer errcode,
              SDL_Integer sendAlert,
              SDL_Integer alertLevel, SDL_Integer alertDesc);

void
wtls_err_get (SDL_Integer *errtype, SDL_Integer *errcode,
              SDL_Integer *sendAlert,
              SDL_Integer *alertLevel, SDL_Integer *alertDesc);

void
wtls_err_check (SDL_Integer *errtype, SDL_Integer *errcode,
                SDL_Integer *sendAlert,
                SDL_Integer *alertLevel, SDL_Integer *alertDesc);

void
wtls_err_clear (void);

#ifdef LOG_WTLS
#include "logging.h"
#endif

#endif