ODTONE_SCOPED(def)
ODTONE_COUNT_OF(array)
ODTONE_STATIC_ASSERT(exp, reason)
ODTONE_LIKELY(x)
ODTONE_UNLIKELY(x)
ODTONE_RETURN_ADDRESS
ODTONE_NORETURN_BEGIN
ODTONE_NORETURN_END
ODTONE_DEPRECATE
ODTONE_UNDEFINED_BOOL
ODTONE_UNDEFINED_BOOL_TRUE
ODTONE_UNDEFINED_BOOL_FALSE

namespace odtone {
  typedef signed char schar;
  typedef signed short sshort;
  typedef signed int sint;
  typedef signed long slong;
  typedef signed long long sllong;
  typedef unsigned char uchar;
  typedef unsigned short ushort;
  typedef unsigned int uint;
  typedef unsigned long ulong;
  typedef unsigned long long ullong;
  typedef boost::uint8_t uint8;
  typedef boost::uint16_t uint16;
  typedef boost::uint32_t uint32;
  typedef boost::uint64_t uint64;
  typedef boost::int8_t sint8;
  typedef boost::int16_t sint16;
  typedef boost::int32_t sint32;
  typedef boost::int64_t sint64;
  typedef boost::intmax_t sintmax;
  typedef boost::uintmax_t uintmax;
  template<typename MemberT, typename ParentT> 
    MemberT * member_of(ParentT * parent, MemberT ParentT::* Member);
  template<typename ParentT, typename MemberT> 
    ParentT * parent_of(MemberT * member, MemberT ParentT::* Member);
}

namespace odtone {
  namespace mih {
    struct null;

    template<size_t N, typename EnumT> class bitmap;
    class percentage;
    template<typename T> class enumeration;

    enum status_enum;
    typedef uint8 octet;
    typedef std::string octet_string;
    typedef enumeration< status_enum > status;
    std::ostream & operator<<(std::ostream &, const null &);
  }
}
template<typename EnumT> EnumT operator++(EnumT &, int);

namespace odtone {
  template<typename T> struct bind_rv_;
  template<typename T> bind_rv_< T > & bind_rv(T & rv);
}

namespace odtone {
  template<typename T> class buffer;
  template<typename T> class buffer_vla;
}

namespace odtone {
  struct bad_cast;
  struct bad_truncate_cast;
  template<typename T, typename U> T truncate_cast(U);
}

namespace odtone {
  namespace conf {
    template<typename T> class type_id_;

    struct property_class;

    class function;

    template<typename Iterator> struct skipper_grammar;
    template<typename Iterator> struct string_grammar;
    template<typename Iterator> struct ip4_grammar;
    template<typename Iterator> struct ip6_grammar;
    template<typename Iterator> struct parser_grammar;

    enum error_reason { invalid_syntax, invalid_command, invalid_arg_type, 
                        to_many_args, invalid_prop, invalid_prop_arg_type, 
                        to_many_prop_args, error_reason_size };

    typedef boost::variant< uint, sint, double, std::string, net::ip::address_v4, net::ip::address_v6 > arg_type;
    typedef std::vector< arg_type > args_type;
    typedef std::pair< std::string, args_type > prop_type;
    typedef std::map< std::string, args_type > pset_type;
    typedef std::map< std::string, function > functions;

    static char const *const error_reason_string;
    bool exec(std::string::const_iterator & begin, 
              std::string::const_iterator end, functions const & cm);
  }
}

ODTONE_SCOPED_CHECKPOINT(doing)
ODTONE_CHECKPOINT(doing)
ODTONE_BUG_ON(exp, reason)
ODTONE_NOT_IMPLEMENTED
ODTONE_ASSERT(exp)
ODTONE_DBG_SCOPED_CHECKPOINT(x)
ODTONE_DBG_CHECKPOINT(x)
ODTONE_NEVER_HERE

namespace odtone {
  struct crash_ctx;

  class checkpoint;

  enum bug;

  char const * k_bug_code_string;
  void setup_crash_handler();
  void crash(bug, const char *, const char *, uint, const char *);
  ODTONE_NORETURN_BEGIN void crash(const crash_ctx &);
}

namespace odtone {
  class dylib_error;
  class dylib;
}

namespace odtone {
  class exception;
  error_code system_error_code(int val);
}

namespace odtone {
  class list_node;
}

namespace odtone {
  class logger;
}

namespace odtone {
  namespace mih {
    struct iarchive_error;
    struct iarchive_eof_error;

    class archive;
    class iarchive;
    class oarchive;
    template<typename T> class is_iarchive;
    template<typename T> class is_oarchive;
  }
}

namespace odtone {
  namespace mih {
    class config;
  }
}

namespace odtone {
  namespace mih {
    class confirm;
  }
}

namespace odtone {
  namespace mih {
    struct service;
    struct operation;
    struct action;
    struct frame;

    typedef buffer_vla< frame > frame_vla;
    std::ostream & operator<<(std::ostream &, const frame &);
  }
}

namespace odtone {
  namespace dns {
    struct frame;

    typedef buffer_vla< frame > frame_vla;
  }
}

namespace odtone {
  namespace mih {
    class indication;
  }
}

namespace odtone {
  namespace mih {
    template<uint ServiceId, uint Opcode, uint ActionId> struct msg_id;

    class message;
    class message_helper;
    oarchive & operator<<(message &, const message_helper &);
    iarchive & operator>>(message &, const message_helper &);
  }
}

namespace odtone {
  namespace dns {
    class message;
  }
}

namespace odtone {
  namespace mih {
    class request;
  }
}

namespace odtone {
  namespace mih {
    class response;
  }
}

namespace odtone {
  namespace mih {
    struct bad_tlv;
    template<typename ValueT, ValueT Value> struct base_tlv_;
    template<uint8 Value> struct tlv_;
    template<uint32 Value> struct tlv4_;
    template<uint8 A, uint8 B, uint8 C> struct oui_;

    template<typename T, typename TLV> class tlv_type_;

    template<typename T, typename TLV> 
      class tlv_type_<boost::optional< T >, TLV>;

    template<typename T, typename TLV> class tlv_cast_;
    template<typename T> class is_tlv_type;
    template<typename T> 
      boost::enable_if< is_tlv_type< T >, iarchive & >::type 
      operator&(iarchive & ar, const T & val);
    template<typename T> 
      boost::enable_if< is_tlv_type< T >, oarchive & >::type 
      operator&(oarchive & ar, const T & val);
  }
}

namespace odtone {
  namespace dns {
    struct question;
    struct resource_record;
    struct a_record;
    struct aaaa_record;
    struct naptr_record;
    struct srv_record;
  }
}

namespace odtone {
  namespace mih {
    class transport_addr;
    class mac_addr;

    struct l2_3gpp_2g_cell_id;
    struct l2_3gpp_3g_cell_id;
    struct l2_3gpp_addr;
    struct l2_3gpp2_addr;
    struct other_l2_addr;

    class ip_addr;

    enum transport_type_enum;
    typedef uint32 cell_id;
    typedef uint16 lac;
    typedef uint16 ci;
    typedef enumeration< transport_type_enum > transport_type;
    typedef boost::variant< mac_addr, l2_3gpp_3g_cell_id, l2_3gpp_2g_cell_id, l2_3gpp_addr, l2_3gpp2_addr, other_l2_addr > link_addr;
    typedef std::vector< link_addr > link_addr_list;
    typedef ip_addr dhcp_serv;
    typedef ip_addr fn_agent;
    typedef ip_addr acc_rtr;
  }
}

namespace odtone {
  namespace mih {
    struct querier_loc;
    struct rpt_limit;
    struct iq_bin_data;

    enum net_type_inc_enum;
    typedef cost_curr curr_pref;
    typedef std::vector< network_id > netwk_inc;
    typedef uint32 nghb_radius;
    typedef uint32 ie_type;
    typedef std::vector< ie_type > rpt_templ;
    typedef bitmap< 32, net_type_inc_enum > net_type_inc;
    typedef std::vector< iq_bin_data > iq_bin_data_list;
  }
}

namespace odtone {
  namespace mih {
    class ir_bin_data;

    struct ir_bin_iarchive_error;

    class ir_bin_iarchive;
    class ir_bin_oarchive;
    typedef std::vector< ir_bin_data > ir_bin_data_list;
  }
}

namespace odtone {
  namespace mih {
    struct mbb_ho_supp;

    enum mih_evt_list_enum;
    enum mih_cmd_list_enum;
    enum iq_type_list_enum;
    enum transport_list_enum;
    typedef boost::variant< std::vector< link_det_cfg >, std::vector< link_cfg_param > > evt_cfg_info;
    typedef std::vector< evt_cfg_info > evt_cfg_info_list;
    typedef bitmap< 32, mih_evt_list_enum > mih_evt_list;
    typedef bitmap< 32, mih_cmd_list_enum > mih_cmd_list;
    typedef bitmap< 64, iq_type_list_enum > iq_type_list;
    typedef bitmap< 16, transport_list_enum > transport_list;
    typedef std::vector< mbb_ho_supp > mbb_ho_supp_list;
  }
}

namespace odtone {
  namespace mih {
    struct rq_result;
    struct tgt_net_info_1;
    struct rq_res_set;
    struct asgn_res_set;

    enum ho_status_enum;
    enum ho_result_enum;
    enum ho_cause_enum;
    typedef enumeration< ho_status_enum > ho_status;
    typedef enumeration< ho_result_enum > ho_result;
    typedef enumeration< ho_cause_enum > ho_cause;
    typedef std::vector< rq_result > rq_result_list;
    typedef boost::variant< tgt_net_info_1, link_addr > tgt_net_info;
    typedef std::vector< tgt_net_info > tgt_net_info_list;
    typedef sint8 predef_cfg_id;
    typedef octet_string tsp_carrier;
    typedef boost::variant< null, predef_cfg_id, tsp_carrier > tsp_container;
  }
}

namespace odtone {
  namespace mih {
    class id;
  }
}

namespace odtone {
  namespace mih {
    struct cost_curr;
    struct cost_value;
    struct cost;
    struct regu_domain;
    struct ch_range;
    struct gap;
    struct burst_prof;
    struct cdma_codes;
    struct dcd_udc;
    struct sib;
    struct sys_params;
    struct parameters;
    struct network_type;
    struct system_info;
    struct operator_id;
    struct net_type_addr;

    enum cost_unit_enum;
    enum netsubtype_enum;
    enum op_namespace_enum;
    enum supported_lcp_enum;
    typedef octet_string net_aux_id;
    typedef octet_string network_id;
    typedef uint8 band_class;
    typedef uint16 bandwidth;
    typedef uint16 base_id;
    typedef uint16 cntry_code;
    typedef sint64 du_ctr_freq;
    typedef sint8 eirp;
    typedef sint8 init_code;
    typedef sint8 ho_code;
    typedef sint16 fq_code_num;
    typedef sint16 pilot_pn;
    typedef sint16 freq_id;
    typedef bitmap< 256, uint8 > down_bp;
    typedef bitmap< 256, uint8 > up_bp;
    typedef enumeration< cost_unit_enum > cost_unit;
    typedef uint32 data_rate;
    typedef std::vector< uint32 > freq_bands;
    typedef bitmap< 64, netsubtype_enum > netsubtype;
    typedef octet_string type_ext;
    typedef octet_string op_name;
    typedef octet_string sp_id;
    typedef enumeration< op_namespace_enum > op_namespace;
    typedef std::vector< operator_id > roaming_ptns;
    typedef enumeration< supported_lcp_enum > supported_lcp;
    typedef boost::variant< ip4_addr, ip6_addr, fqdn > proxy_addr;
    typedef std::vector< net_type_addr > net_type_addr_list;
  }
}

namespace odtone {
  namespace mih {
    struct ie_poa_subnet_info_list;
    struct ie_poa_ip_addr_list;
    struct ie_container_poa;

    class ie_container_poa_list;

    struct ie_container_network;

    class ie_container_list_of_networks;
    typedef network_type ie_network_type;
    typedef operator_id ie_operator_id;
    typedef sp_id ie_service_provider_id;
    typedef cntry_code ie_country_code;
    typedef network_id ie_network_id;
    typedef net_aux_id ie_network_aux_id;
    typedef roaming_ptns ie_roaming_partners;
    typedef cost ie_cost;
    typedef qos_list ie_network_qos;
    typedef data_rate ie_network_data_rate;
    typedef regu_domain ie_net_regulat_domain;
    typedef freq_bands ie_net_frequency_bands;
    typedef ip_config ie_net_ip_cfg_methods;
    typedef net_caps ie_net_capabilities;
    typedef supported_lcp ie_net_supported_lcp;
    typedef ip_mob_mgmt ie_net_mob_mgmt_prot;
    typedef proxy_addr ie_net_emserv_proxy;
    typedef proxy_addr ie_net_ims_proxy_cscf;
    typedef bool ie_net_mobile_network;
    typedef link_addr ie_poa_link_addr;
    typedef location ie_poa_location;
    typedef ch_range ie_poa_channel_range;
    typedef system_info ie_poa_system_info;
    typedef ip_subnet_info ie_poa_subnet_info;
    typedef ip_addr ie_poa_ip_addr;

    static const tlv_cast_< ie_network_type, tlv4_< 0x10000000 > > tlv_ie_network_type;
    static const tlv_cast_< ie_operator_id, tlv4_< 0x10000001 > > tlv_ie_operator_id;
    static const tlv_cast_< ie_service_provider_id, tlv4_< 0x10000002 > > tlv_ie_service_provider_id;
    static const tlv_cast_< ie_country_code, tlv4_< 0x10000003 > > tlv_ie_country_code;
    static const tlv_cast_< ie_network_id, tlv4_< 0x10000100 > > tlv_ie_network_id;
    static const tlv_cast_< ie_network_aux_id, tlv4_< 0x10000101 > > tlv_ie_network_aux_id;
    static const tlv_cast_< ie_roaming_partners, tlv4_< 0x10000102 > > tlv_ie_roaming_partners;
    static const tlv_cast_< ie_cost, tlv4_< 0x10000103 > > tlv_ie_cost;
    static const tlv_cast_< ie_network_qos, tlv4_< 0x10000105 > > tlv_ie_network_qos;
    static const tlv_cast_< ie_network_data_rate, tlv4_< 0x10000106 > > tlv_ie_network_data_rate;
    static const tlv_cast_< ie_net_regulat_domain, tlv4_< 0x10000107 > > tlv_ie_net_regulat_domain;
    static const tlv_cast_< ie_net_frequency_bands, tlv4_< 0x10000108 > > tlv_ie_net_frequency_bands;
    static const tlv_cast_< ie_net_ip_cfg_methods, tlv4_< 0x10000109 > > tlv_ie_net_ip_cfg_methods;
    static const tlv_cast_< ie_net_capabilities, tlv4_< 0x1000010A > > tlv_ie_net_capabilities;
    static const tlv_cast_< ie_net_supported_lcp, tlv4_< 0x1000010B > > tlv_ie_net_supported_lcp;
    static const tlv_cast_< ie_net_mob_mgmt_prot, tlv4_< 0x1000010C > > tlv_ie_net_mob_mgmt_prot;
    static const tlv_cast_< ie_net_emserv_proxy, tlv4_< 0x1000010D > > tlv_ie_net_emserv_proxy;
    static const tlv_cast_< ie_net_ims_proxy_cscf, tlv4_< 0x1000010E > > tlv_ie_net_ims_proxy_cscf;
    static const tlv_cast_< ie_net_mobile_network, tlv4_< 0x1000010F > > tlv_ie_net_mobile_network;
    static const tlv_cast_< ie_poa_link_addr, tlv4_< 0x10000200 > > tlv_ie_poa_link_addr;
    static const tlv_cast_< ie_poa_location, tlv4_< 0x10000201 > > tlv_ie_poa_location;
    static const tlv_cast_< ie_poa_channel_range, tlv4_< 0x10000202 > > tlv_ie_poa_channel_range;
    static const tlv_cast_< ie_poa_system_info, tlv4_< 0x10000203 > > tlv_ie_poa_system_info;
    static const tlv_cast_< ie_poa_subnet_info, tlv4_< 0x10000204 > > tlv_ie_poa_subnet_info;
    static const tlv_cast_< ie_poa_ip_addr, tlv4_< 0x10000205 > > tlv_ie_poa_ip_addr;
    static const tlv_cast_< ie_container_poa, tlv4_< 0x10000302 > > tlv_ie_container_poa;
    static const tlv_cast_< ie_container_network, tlv4_< 0x10000301 > > tlv_ie_container_network;
    static const tlv_cast_< ie_container_list_of_networks, tlv4_< 0x10000300 > > tlv_ie_container_list_of_networks;
  }
}

namespace odtone {
  namespace mih {
    struct ip4_addr;
    struct ip6_addr;
    struct ip_config;
    struct ip_subnet_info;

    enum ip_cfg_methods_enum;
    enum ip_mob_mgmt_enum;
    typedef bitmap< 32, ip_cfg_methods_enum > ip_cfg_methods;
    typedef bitmap< 16, ip_mob_mgmt_enum > ip_mob_mgmt;
    typedef octet_string fqdn;
    typedef uint8 ip_prefix_len;
    typedef bool ip_renewal_flag;
  }
}

namespace odtone {
  namespace mih {
    struct threshold;
    struct link_action;
    struct link_id;

    class link_tuple_id;

    struct link_scan_rsp;
    struct link_action_req;
    struct link_action_rsp;
    struct link_det_cfg;
    struct link_status_req;
    struct link_param;
    struct link_param_report;
    struct link_cfg_param;
    struct link_cfg_status;
    struct link_det_info;
    struct link_poa_list;
    struct link_status_rsp;
    struct status_rsp;

    enum op_mode_enum;
    enum dev_states_req_enum;
    enum link_states_req_enum;
    enum link_ac_result_enum;
    enum link_ac_type_enum;
    enum link_ac_attr_enum;
    enum th_action_enum;
    enum link_type_enum;
    enum link_dn_reason_enum;
    enum link_gd_reason_enum;
    enum link_mihcap_flag_enum;
    enum link_param_gen_enum;
    enum link_param_gg_enum;
    enum link_param_edge_enum;
    enum link_param_eth_enum;
    enum link_param_802_11_enum;
    enum link_param_c2k_enum;
    enum link_param_ffd_enum;
    enum link_param_hrpd_enum;
    enum link_param_802_16_enum;
    enum link_param_802_20_enum;
    enum link_param_802_22_enum;
    enum link_evt_list_enum;
    enum link_cmd_list_enum;
    enum link_desc_req_enum;
    enum net_caps_enum;
    typedef uint8 batt_level;
    typedef uint8 num_cos;
    typedef uint8 num_queue;
    typedef uint16 channel_id;
    typedef bool config_status;
    typedef octet_string device_info;
    typedef uint16 link_ac_ex_time;
    typedef boost::variant< sint8, percentage > sig_strength;
    typedef bool link_res_status;
    typedef enumeration< op_mode_enum > op_mode;
    typedef boost::variant< op_mode, channel_id > link_states_rsp;
    typedef std::vector< link_states_rsp > link_states_rsp_list;
    typedef boost::variant< num_cos, num_queue > link_desc_rsp;
    typedef std::vector< link_desc_rsp > link_desc_rsp_list;
    typedef bitmap< 16, dev_states_req_enum > dev_states_req;
    typedef boost::variant< device_info, batt_level > dev_states_rsp;
    typedef std::vector< dev_states_rsp > dev_states_rsp_list;
    typedef bitmap< 16, link_states_req_enum > link_states_req;
    typedef std::vector< link_states_req > link_states_req_list;
    typedef enumeration< link_ac_result_enum > link_ac_result;
    typedef enumeration< link_ac_type_enum > link_ac_type;
    typedef bitmap< 8, link_ac_attr_enum > link_ac_attr;
    typedef enumeration< th_action_enum > th_action;
    typedef enumeration< link_type_enum > link_type;
    typedef enumeration< link_dn_reason_enum > link_dn_reason;
    typedef enumeration< link_gd_reason_enum > link_gd_reason;
    typedef bitmap< 8, link_mihcap_flag_enum > link_mihcap_flag;
    typedef enumeration< link_param_gen_enum > link_param_gen;
    typedef uint8 link_param_qos;
    typedef enumeration< link_param_gg_enum > link_param_gg;
    typedef enumeration< link_param_edge_enum > link_param_edge;
    typedef enumeration< link_param_eth_enum > link_param_eth;
    typedef enumeration< link_param_802_11_enum > link_param_802_11;
    typedef enumeration< link_param_c2k_enum > link_param_c2k;
    typedef enumeration< link_param_ffd_enum > link_param_ffd;
    typedef enumeration< link_param_hrpd_enum > link_param_hrpd;
    typedef enumeration< link_param_802_16_enum > link_param_802_16;
    typedef enumeration< link_param_802_20_enum > link_param_802_20;
    typedef enumeration< link_param_802_22_enum > link_param_802_22;
    typedef std::vector< link_id > link_id_list;
    typedef std::vector< link_scan_rsp > link_scan_rsp_list;
    typedef std::vector< link_action_req > link_action_list;
    typedef std::vector< link_action_rsp > link_action_rsp_list;
    typedef bitmap< 32, link_evt_list_enum > link_evt_list;
    typedef bitmap< 32, link_cmd_list_enum > link_cmd_list;
    typedef boost::variant< link_param_gen, link_param_qos, link_param_gg, link_param_edge, link_param_eth, link_param_802_11, link_param_c2k, link_param_ffd, link_param_hrpd, link_param_802_16, link_param_802_20, link_param_802_22 > link_param_type;
    typedef std::vector< link_param_type > link_param_type_list;
    typedef bitmap< 16, link_desc_req_enum > link_desc_req;
    typedef uint16 link_param_val;
    typedef std::vector< link_param > link_param_list;
    typedef std::vector< link_param_report > link_param_rpt_list;
    typedef std::vector< link_cfg_param > link_cfg_param_list;
    typedef std::vector< link_cfg_status > link_cfg_status_list;
    typedef bitmap< 32, net_caps_enum > net_caps;
    typedef std::vector< link_det_info > link_det_info_list;
    typedef std::vector< link_poa_list > list_of_link_poa_list;
    typedef std::vector< link_status_rsp > link_status_rsp_list;
    typedef std::vector< status_rsp > status_rsp_list;
  }
}

namespace odtone {
  namespace sap {
    class link;

    static const char *const kConf_MIH_SAP_id;
    static const char *const kConf_Port;
    static const char *const kConf_Tec;
    static const char *const kConf_Interface_Addr;
    static const char *const kConf_Evt_List;
    static const char *const kConf_Cmd_List;
    static const char *const kConf_MIHF_Id;
    static const char *const kConf_MIHF_Ip;
    static const char *const kConf_MIHF_Local_Port;
    static const char *const kConf_File;
    static const char *const kConf_Receive_Buffer_Len;
  }
}

namespace odtone {
  namespace mih {
    struct bin_civic_location;
    typedef octet_string xml_civic_location;
    typedef octet_string civic_addr;
    typedef boost::array< uint8, 16 > bin_geo_location;
    typedef octet_string xml_geo_location;
    typedef boost::variant< bin_civic_location, xml_civic_location > civic_location;
    typedef boost::variant< bin_geo_location, xml_geo_location > geo_location;
    typedef boost::variant< civic_location, geo_location, cell_id > location;
  }
}

namespace odtone {
  namespace mih {
    struct mos_info;
    struct mos_dscv;
  }
}

namespace odtone {
  namespace mih {
    struct pk_delay;
    struct min_pk_tx_delay;
    struct avg_pk_tx_delay;
    struct max_pk_tx_delay;
    struct pk_delay_jitter;
    struct pk_loss_rate;
    struct qos_list;
    typedef uint8 num_cos_types;
    typedef uint8 cos_id;
    typedef std::vector< min_pk_tx_delay > min_pk_tx_delay_list;
    typedef std::vector< avg_pk_tx_delay > avg_pk_tx_delay_list;
    typedef std::vector< max_pk_tx_delay > max_pk_tx_delay_list;
    typedef std::vector< pk_delay_jitter > pk_delay_jitter_list;
    typedef std::vector< pk_loss_rate > pk_loss_rate_list;
    typedef boost::variant< num_cos_types, min_pk_tx_delay_list, avg_pk_tx_delay_list, max_pk_tx_delay_list, pk_delay_jitter_list, pk_loss_rate_list > qos_param_val;
  }
}

namespace odtone {
  namespace mih {
    struct iq_rdf_data;
    typedef octet_string iq_rdf_schema;
    typedef std::vector< iq_rdf_schema > iq_rdf_schema_list;
    typedef std::vector< iq_rdf_data > iq_rdf_data_list;
  }
}

namespace odtone {
  namespace mih {
    struct ir_rdf_data;
    struct ir_rdf_schem;
    typedef octet_string ir_rdf_schem_url;
    typedef std::vector< ir_rdf_schem_url > ir_rdf_schem_url_list;
    typedef std::vector< ir_rdf_data > ir_rdf_data_list;
    typedef std::vector< ir_rdf_schem > ir_rdf_schem_list;
  }
}

namespace odtone {
  namespace mih {
    enum reg_request_code_enum;
    typedef enumeration< reg_request_code_enum > reg_request_code;
  }
}

namespace odtone {
  namespace mih {
    class vendor_ie;
    class vendor_ie_list;
    bool is_vendor_ie(uint32);
  }
}

DNS_PACKET_LEN
DNS_QUERY_TIMEOUT

namespace odtone {
  namespace dns {
    struct query;
    struct callback_info;

    class resolver;

    enum dns_query_type;
    enum dns_status;
    typedef boost::function< void(struct callback_info *)> dns_callback_t;
  }
}

namespace odtone {
  namespace dns {
    std::string parse_domain_name(const unsigned char *, int &);
    std::string parse_string(const unsigned char *, int &);
    uint16 parse_uint16(const unsigned char *, int &);
    uint32 parse_uint32(const unsigned char *, int &);
    std::vector< uint8 > parse_data(const unsigned char *, int &, int);
    a_record parse_a_record(const unsigned char *, int, int);
    aaaa_record parse_aaaa_record(const unsigned char *, int, int);
    naptr_record parse_naptr_record(const unsigned char *, int, int);
    srv_record parse_srv_record(const unsigned char *, int, int);
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      class checksum;
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      struct icmp;
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      class icmp6_ra_packet;
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      template<uint8 TypeValue> class opt_link_layer;
      class opt_prefix_info;
      class opt_mtu;
      class opt_rdns;

      typedef opt_link_layer< 1 > opt_source_link_layer;
      typedef opt_link_layer< 2 > opt_target_link_layer;
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      bool icmp_rs_parse(uchar * buffer, size_t length, 
                         link::address_mac & source_link_layer);
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      class option;
    }
  }
}

namespace odtone {
  namespace net {
    namespace ip {
      class prefix_v6;
      bool operator!=(const prefix_v6 & rhr, const prefix_v6 & lhr);
      bool operator<(const prefix_v6 & rhr, const prefix_v6 & lhr);
      bool operator<=(const prefix_v6 & rhr, const prefix_v6 & lhr);
      bool operator==(const prefix_v6 & rhr, const prefix_v6 & lhr);
      bool operator>(const prefix_v6 & rhr, const prefix_v6 & lhr);
      bool operator>=(const prefix_v6 & rhr, const prefix_v6 & lhr);
    }
  }
}

namespace odtone {
  namespace net {
    namespace link {
      class address_mac;
    }
  }
}

namespace odtone {
  namespace mih {
    sint8 srand8();
    sint16 srand16();
    sint32 srand32();
    sint64 srand64();
    uint8 rand8();
    uint16 rand16();
    uint32 rand32();
    uint64 rand64();
  }
}

namespace odtone {
  namespace sap {
    class sap;
  }
}

namespace odtone {
  namespace sap {
    class user;

    static const char *const kConf_File;
    static const char *const kConf_Port;
    static const char *const kConf_Receive_Buffer_Len;
    static const char *const kConf_MIH_SAP_id;
    static const char *const kConf_MIH_SAP_dest;
    static const char *const kConf_MIHF_Ip;
    static const char *const kConf_MIHF_Local_Port;
  }
}

namespace odtone {
  template<typename CharT> class basic_const_string_ref;

  typedef basic_const_string_ref< char > const_string_ref;
  typedef basic_const_string_ref< wchar_t > const_wstring_ref;
}

namespace odtone {
  std::string to_string_hex(const void *, size_t);
  template<typename T> std::string to_string_hex(const T &);
  uchar hex_to_int(uchar);
  char const * ustr(char const *);
  std::string const & ustr(std::string const &);
}