/*
* Copyright (C) 2003, 2004, 2005 Yokogawa Electric Corporation,
* INTAP(Interoperability Technology Association
* for Information Processing, Japan). All rights reserved.
*
* Redistribution and use of this software in source and binary forms, with
* or without modification, are permitted provided that the following
* conditions and disclaimer are agreed and accepted by the user:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the names of the copyrighters, the name of the project which
* is related to this software (hereinafter referred to as "project") nor
* the names of the contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* 4. No merchantable use may be permitted without prior written
* notification to the copyrighters. However, using this software for the
* purpose of testing or evaluating any products including merchantable
* products may be permitted without any notification to the copyrighters.
*
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHTERS, THE PROJECT AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING
* BUT NOT LIMITED THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHTERS, THE PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT,STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
* $TAHI: v6eval/lib/Pz/McDNS.h,v 1.5 2005/05/09 09:35:23 akisada Exp $
*/
#if !defined(__McDNS_h__)
#define __McDNS_h__ 1
#include "McSub.h"
#include "McUDP.h"
#include "MmObject.h"
#include "PvOctets.h"
// RFC 1035 - Domain Implementation and Specification
const int32_t TP_DNS_RR_A = 1;
const int32_t TP_DNS_RR_NS = 2;
const int32_t TP_DNS_RR_MD = 3;
const int32_t TP_DNS_RR_MF = 4;
const int32_t TP_DNS_RR_CNAME = 5;
const int32_t TP_DNS_RR_SOA = 6;
const int32_t TP_DNS_RR_MB = 7;
const int32_t TP_DNS_RR_MG = 8;
const int32_t TP_DNS_RR_MR = 9;
const int32_t TP_DNS_RR_NULL = 10;
const int32_t TP_DNS_RR_WKS = 11;
const int32_t TP_DNS_RR_PTR = 12;
const int32_t TP_DNS_RR_HINFO = 13;
const int32_t TP_DNS_RR_MINFO = 14;
const int32_t TP_DNS_RR_MX = 15;
const int32_t TP_DNS_RR_TXT = 16;
// RFC 1183 - New DNS RR Definitions
const int32_t TP_DNS_RR_RP = 17;
const int32_t TP_DNS_RR_AFSDB = 18;
const int32_t TP_DNS_RR_X25 = 19;
const int32_t TP_DNS_RR_ISDN = 20;
const int32_t TP_DNS_RR_RT = 21;
// RFC 1664 - Internet DNS for Mail Mapping Tables
const int32_t TP_DNS_RR_PX = 26;
// RFC 1886 - IPv6 DNS Extensions
const int32_t TP_DNS_RR_AAAA = 28;
// RFC 2782 - DNS SRV RR
const int32_t TP_DNS_RR_SRV = 33;
// RFC 2915 - NAPTR DNS RR
const int32_t TP_DNS_RR_NAPTR = 35;
////////////////////////////////////////////////////////////////
class RmQType: public RmObject {
public:
RmQType(RObject *, const MObject *, const ItPosition &, const ItPosition &, PvObject * = 0);
virtual ~RmQType();
virtual void printName(uint32_t, CSTR = 0) const;
virtual void logSelf(uint32_t, CSTR = 0) const;
void printQType(uint32_t) const;
};
////////////////////////////////////////////////////////////////
class MmQType: public MmUint {
public:
MmQType(CSTR, uint16_t, const PObject * = 0, const PObject * = 0, const ICVoverwriter * ow = 0, METH_HC_ForIPinfo meth = 0);
virtual ~MmQType();
virtual RObject *reverseRm(RControl &, RObject *, const ItPosition &, const ItPosition &, PvObject *) const;
};
////////////////////////////////////////////////////////////////
class PvDnsName: public PvOctets {
public:
PvDnsName();
PvDnsName(uint32_t, OCTSTR = 0, bool = false);
virtual ~PvDnsName();
virtual PvObject *shallowCopy() const;
virtual void print() const;
virtual void log(uint32_t=0) const;
};
////////////////////////////////////////////////////////////////
class PvDnsStr: public PvOctets {
public:
PvDnsStr();
PvDnsStr(uint32_t, OCTSTR = 0, bool = false);
virtual ~PvDnsStr();
virtual PvObject *shallowCopy() const;
virtual void print() const;
virtual void log(uint32_t=0) const;
};
////////////////////////////////////////////////////////////////
class LengthCtl {
uint32_t length_;
uint32_t rrlength_;
public:
LengthCtl(): length_(0), rrlength_(0) {};
virtual ~LengthCtl() {};
void set_length(uint32_t);
uint32_t get_length(void) const;
void set_rrlength(uint32_t);
uint32_t get_rrlength(void) const;
};
inline void LengthCtl::set_length(uint32_t d) {length_ = d; return;}
inline uint32_t LengthCtl::get_length(void) const {return(length_);}
inline void LengthCtl::set_rrlength(uint32_t d) {rrlength_ = d; return;}
inline uint32_t LengthCtl::get_rrlength(void) const {return(rrlength_);}
////////////////////////////////////////////////////////////////
class MmDNSName: public MmVarOctets {
LengthCtl *LengthCtl_;
public:
MmDNSName(CSTR, const PObject *, const PObject *);
virtual ~MmDNSName();
virtual ItPosition length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
virtual PvObject *reversePv(RControl &, const ItPosition &, const ItPosition &, const OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class MmDNSStr: public MmVarOctets {
LengthCtl *LengthCtl_;
public:
MmDNSStr(CSTR, const PObject *, const PObject *);
virtual ~MmDNSStr();
virtual ItPosition length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
virtual PvObject *reversePv(RControl &, const ItPosition &, const ItPosition &, const OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class CountMgr {
uint32_t generate_QD_;
uint32_t generate_AN_;
uint32_t generate_NS_;
uint32_t generate_AR_;
uint32_t reverse_QD_;
uint32_t reverse_AN_;
uint32_t reverse_NS_;
uint32_t reverse_AR_;
uint32_t current_QD_;
uint32_t current_AN_;
uint32_t current_NS_;
uint32_t current_AR_;
uint32_t length_QD_;
uint32_t length_AN_;
uint32_t length_NS_;
uint32_t length_AR_;
public:
CountMgr():
generate_QD_(0), generate_AN_(0), generate_NS_(0), generate_AR_(0),
reverse_QD_(0), reverse_AN_(0), reverse_NS_(0), reverse_AR_(0),
current_QD_(0), current_AN_(0), current_NS_(0), current_AR_(0),
length_QD_(0), length_AN_(0), length_NS_(0), length_AR_(0) {};
virtual ~CountMgr() {};
void increase_generate_QD(void);
void increase_generate_AN(void);
void increase_generate_NS(void);
void increase_generate_AR(void);
uint32_t get_generate_QD(void) const;
uint32_t get_generate_AN(void) const;
uint32_t get_generate_NS(void) const;
uint32_t get_generate_AR(void) const;
void set_reverse_QD(uint32_t);
void set_reverse_AN(uint32_t);
void set_reverse_NS(uint32_t);
void set_reverse_AR(uint32_t);
uint32_t get_reverse_QD(void) const;
uint32_t get_reverse_AN(void) const;
uint32_t get_reverse_NS(void) const;
uint32_t get_reverse_AR(void) const;
void init_current_QD(void);
void init_current_AN(void);
void init_current_NS(void);
void init_current_AR(void);
void increase_current_QD(void);
void increase_current_AN(void);
void increase_current_NS(void);
void increase_current_AR(void);
uint32_t get_current_QD(void) const;
uint32_t get_current_AN(void) const;
uint32_t get_current_NS(void) const;
uint32_t get_current_AR(void) const;
void set_length_QD(uint32_t);
void set_length_AN(uint32_t);
void set_length_NS(uint32_t);
void set_length_AR(uint32_t);
uint32_t get_length_QD(void) const;
uint32_t get_length_AN(void) const;
uint32_t get_length_NS(void) const;
uint32_t get_length_AR(void) const;
};
inline void CountMgr::increase_generate_QD(void) {generate_QD_ ++; return;}
inline void CountMgr::increase_generate_AN(void) {generate_AN_ ++; return;}
inline void CountMgr::increase_generate_NS(void) {generate_NS_ ++; return;}
inline void CountMgr::increase_generate_AR(void) {generate_AR_ ++; return;}
inline uint32_t CountMgr::get_generate_QD(void) const {return(generate_QD_);}
inline uint32_t CountMgr::get_generate_AN(void) const {return(generate_AN_);}
inline uint32_t CountMgr::get_generate_NS(void) const {return(generate_NS_);}
inline uint32_t CountMgr::get_generate_AR(void) const {return(generate_AR_);}
inline void CountMgr::set_reverse_QD(uint32_t d) {reverse_QD_ = d; return;}
inline void CountMgr::set_reverse_AN(uint32_t d) {reverse_AN_ = d; return;}
inline void CountMgr::set_reverse_NS(uint32_t d) {reverse_NS_ = d; return;}
inline void CountMgr::set_reverse_AR(uint32_t d) {reverse_AR_ = d; return;}
inline uint32_t CountMgr::get_reverse_QD(void) const {return(reverse_QD_);}
inline uint32_t CountMgr::get_reverse_AN(void) const {return(reverse_AN_);}
inline uint32_t CountMgr::get_reverse_NS(void) const {return(reverse_NS_);}
inline uint32_t CountMgr::get_reverse_AR(void) const {return(reverse_AR_);}
inline void CountMgr::init_current_QD(void) {current_QD_ = 0; return;}
inline void CountMgr::init_current_AN(void) {current_AN_ = 0; return;}
inline void CountMgr::init_current_NS(void) {current_NS_ = 0; return;}
inline void CountMgr::init_current_AR(void) {current_AR_ = 0; return;}
inline void CountMgr::increase_current_QD(void) {current_QD_ ++; return;}
inline void CountMgr::increase_current_AN(void) {current_AN_ ++; return;}
inline void CountMgr::increase_current_NS(void) {current_NS_ ++; return;}
inline void CountMgr::increase_current_AR(void) {current_AR_ ++; return;}
inline uint32_t CountMgr::get_current_QD(void) const {return(current_QD_);}
inline uint32_t CountMgr::get_current_AN(void) const {return(current_AN_);}
inline uint32_t CountMgr::get_current_NS(void) const {return(current_NS_);}
inline uint32_t CountMgr::get_current_AR(void) const {return(current_AR_);}
inline void CountMgr::set_length_QD(uint32_t d) {length_QD_ = d; return;}
inline void CountMgr::set_length_AN(uint32_t d) {length_AN_ = d; return;}
inline void CountMgr::set_length_NS(uint32_t d) {length_NS_ = d; return;}
inline void CountMgr::set_length_AR(uint32_t d) {length_AR_ = d; return;}
inline uint32_t CountMgr::get_length_QD(void) const {return(length_QD_);}
inline uint32_t CountMgr::get_length_AN(void) const {return(length_AN_);}
inline uint32_t CountMgr::get_length_NS(void) const {return(length_NS_);}
inline uint32_t CountMgr::get_length_AR(void) const {return(length_AR_);}
////////////////////////////////////////////////////////////////
class McUdp_DNS: public McHeader {
static McUdp_DNS *instance_;
CountMgr *CountMgr_;
McUdp_DNS(CSTR);
protected:
const MmUint *QDCount_;
const MmUint *ANCount_;
const MmUint *NSCount_;
const MmUint *ARCount_;
void QDCount_member(MmUint *meta) {QDCount_ = meta; member(meta); return;}
void ANCount_member(MmUint *meta) {ANCount_ = meta; member(meta); return;}
void NSCount_member(MmUint *meta) {NSCount_ = meta; member(meta); return;}
void ARCount_member(MmUint *meta) {ARCount_ = meta; member(meta); return;}
public:
virtual ~McUdp_DNS();
static McUdp_DNS *create(CSTR, CSTR, CSTR, CSTR, CSTR);
static McUdp_DNS *instance() {return instance_;}
int32_t upperPort() const {return(TP_Udp_DNS);}
int32_t token() const {
return(metaToken(tkn_dns_header_));
}
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
void set_CountMgr(RObject *) const;
CountMgr *get_CountMgr(void) const;
DEC_HCGENE(QDCount);
DEC_HCGENE(ANCount);
DEC_HCGENE(NSCount);
DEC_HCGENE(ARCount);
DEC_HCEVAL(QDCount);
DEC_HCEVAL(ANCount);
DEC_HCEVAL(NSCount);
DEC_HCEVAL(ARCount);
};
inline CountMgr *McUdp_DNS::get_CountMgr(void) const {return(CountMgr_);}
////////////////////////////////////////////////////////////////
class McDNS_Question: public McOption {
McUdp_DNS *McUdp_DNS_;
McDNS_Question(CSTR);
public:
virtual ~McDNS_Question();
static McDNS_Question *create(CSTR, McUdp_DNS *);
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class McDNS_Answer: public McOption {
McUdp_DNS *McUdp_DNS_;
McDNS_Answer(CSTR);
public:
virtual ~McDNS_Answer();
static McDNS_Answer *create(CSTR, McUdp_DNS *);
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class McDNS_Authority: public McOption {
McUdp_DNS *McUdp_DNS_;
McDNS_Authority(CSTR);
public:
virtual ~McDNS_Authority();
static McDNS_Authority *create(CSTR, McUdp_DNS *);
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class McDNS_Additional: public McOption {
McUdp_DNS *McUdp_DNS_;
McDNS_Additional(CSTR);
public:
virtual ~McDNS_Additional();
static McDNS_Additional *create(CSTR, McUdp_DNS *);
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class McDNS_QuestionEntry: public McOption {
LengthCtl *LengthCtl_;
McDNS_QuestionEntry(CSTR);
public:
virtual ~McDNS_QuestionEntry();
static McDNS_QuestionEntry *create(CSTR);
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class McDNS_RR: public McOption {
LengthCtl *LengthCtl_;
protected:
MmUint *type_;
MmUint *length_;
void type_member(MmUint *meta) {
type_ = meta;
member(meta);
}
void length_member(MmUint *meta) {
length_ = meta;
member(meta);
}
void common_member();
McDNS_RR(CSTR);
public:
virtual ~McDNS_RR();
virtual RObject *reverse(RControl &, RObject *, ItPosition &, OCTBUF &) const;
virtual uint32_t length_for_reverse(RControl &, ItPosition &, OCTBUF &) const;
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
DEC_HCGENE(Type);
DEC_HCEVAL(Type);
int32_t get_rrType(WObject *wmem) const;
DEC_HCGENE(Length);
};
////////////////////////////////////////////////////////////////
class McDNS_RR_ANY: public McDNS_RR {
public:
McDNS_RR_ANY(CSTR);
virtual ~McDNS_RR_ANY();
static McDNS_RR_ANY *create(CSTR);
};
////////////////////////////////////////////////////////////////
class McDNS_RR_A: public McDNS_RR {
public:
McDNS_RR_A(CSTR);
virtual ~McDNS_RR_A();
static McDNS_RR_A *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_A);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_NS: public McDNS_RR {
public:
McDNS_RR_NS(CSTR);
virtual ~McDNS_RR_NS();
static McDNS_RR_NS *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_NS);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MD: public McDNS_RR {
public:
McDNS_RR_MD(CSTR);
virtual ~McDNS_RR_MD();
static McDNS_RR_MD *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MD);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MF: public McDNS_RR {
public:
McDNS_RR_MF(CSTR);
virtual ~McDNS_RR_MF();
static McDNS_RR_MF *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MF);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_CNAME: public McDNS_RR {
public:
McDNS_RR_CNAME(CSTR);
virtual ~McDNS_RR_CNAME();
static McDNS_RR_CNAME *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_CNAME);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_SOA: public McDNS_RR {
public:
McDNS_RR_SOA(CSTR);
virtual ~McDNS_RR_SOA();
static McDNS_RR_SOA *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_SOA);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MB: public McDNS_RR {
public:
McDNS_RR_MB(CSTR);
virtual ~McDNS_RR_MB();
static McDNS_RR_MB *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MB);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MG: public McDNS_RR {
public:
McDNS_RR_MG(CSTR);
virtual ~McDNS_RR_MG();
static McDNS_RR_MG *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MG);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MR: public McDNS_RR {
public:
McDNS_RR_MR(CSTR);
virtual ~McDNS_RR_MR();
static McDNS_RR_MR *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MR);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_NULL: public McDNS_RR {
public:
McDNS_RR_NULL(CSTR);
virtual ~McDNS_RR_NULL();
static McDNS_RR_NULL *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_NULL);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_WKS: public McDNS_RR {
public:
McDNS_RR_WKS(CSTR);
virtual ~McDNS_RR_WKS();
static McDNS_RR_WKS *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_WKS);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_PTR: public McDNS_RR {
public:
McDNS_RR_PTR(CSTR);
virtual ~McDNS_RR_PTR();
static McDNS_RR_PTR *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_PTR);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_HINFO: public McDNS_RR {
public:
McDNS_RR_HINFO(CSTR);
virtual ~McDNS_RR_HINFO();
static McDNS_RR_HINFO *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_HINFO);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MINFO: public McDNS_RR {
public:
McDNS_RR_MINFO(CSTR);
virtual ~McDNS_RR_MINFO();
static McDNS_RR_MINFO *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MINFO);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_MX: public McDNS_RR {
public:
McDNS_RR_MX(CSTR);
virtual ~McDNS_RR_MX();
static McDNS_RR_MX *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_MX);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_TXT: public McDNS_RR {
public:
McDNS_RR_TXT(CSTR);
virtual ~McDNS_RR_TXT();
static McDNS_RR_TXT *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_TXT);
}
DEC_HC_MLC(TXT);
};
////////////////////////////////////////////////////////////////
class McDNS_RR_RP: public McDNS_RR {
public:
McDNS_RR_RP(CSTR);
virtual ~McDNS_RR_RP();
static McDNS_RR_RP *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_RP);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_AFSDB: public McDNS_RR {
public:
McDNS_RR_AFSDB(CSTR);
virtual ~McDNS_RR_AFSDB();
static McDNS_RR_AFSDB *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_AFSDB);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_X25: public McDNS_RR {
public:
McDNS_RR_X25(CSTR);
virtual ~McDNS_RR_X25();
static McDNS_RR_X25 *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_X25);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_ISDN: public McDNS_RR {
public:
McDNS_RR_ISDN(CSTR);
virtual ~McDNS_RR_ISDN();
static McDNS_RR_ISDN *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_ISDN);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_RT: public McDNS_RR {
public:
McDNS_RR_RT(CSTR);
virtual ~McDNS_RR_RT();
static McDNS_RR_RT *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_RT);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_PX: public McDNS_RR {
public:
McDNS_RR_PX(CSTR);
virtual ~McDNS_RR_PX();
static McDNS_RR_PX *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_PX);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_AAAA: public McDNS_RR {
public:
McDNS_RR_AAAA(CSTR);
virtual ~McDNS_RR_AAAA();
static McDNS_RR_AAAA *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_AAAA);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_SRV: public McDNS_RR {
public:
McDNS_RR_SRV(CSTR);
virtual ~McDNS_RR_SRV();
static McDNS_RR_SRV *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_SRV);
}
};
////////////////////////////////////////////////////////////////
class McDNS_RR_NAPTR: public McDNS_RR {
public:
McDNS_RR_NAPTR(CSTR);
virtual ~McDNS_RR_NAPTR();
static McDNS_RR_NAPTR *create(CSTR);
int32_t rrType() const {
return(TP_DNS_RR_NAPTR);
}
};
////////////////////////////////////////////////////////////////
class MmQuestion_onDNS: public MmReference_Less1 {
static TypevsMcDict dict_;
McUdp_DNS *McUdp_DNS_;
public:
MmQuestion_onDNS(CSTR, McUdp_DNS *);
virtual ~MmQuestion_onDNS();
int32_t token() const {
return(metaToken(tkn_dns_qestion_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add_other(McDNS_Question *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class MmAnswer_onDNS: public MmReference_Less1 {
static TypevsMcDict dict_;
McUdp_DNS *McUdp_DNS_;
public:
MmAnswer_onDNS(CSTR, McUdp_DNS *);
virtual ~MmAnswer_onDNS();
int32_t token() const {
return(metaToken(tkn_dns_answer_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add_other(McDNS_Answer *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class MmAuthority_onDNS: public MmReference_Less1 {
static TypevsMcDict dict_;
McUdp_DNS *McUdp_DNS_;
public:
MmAuthority_onDNS(CSTR, McUdp_DNS *);
virtual ~MmAuthority_onDNS();
int32_t token() const {
return(metaToken(tkn_dns_authority_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add_other(McDNS_Authority *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class MmAdditional_onDNS: public MmReference_Less1 {
static TypevsMcDict dict_;
McUdp_DNS *McUdp_DNS_;
public:
MmAdditional_onDNS(CSTR, McUdp_DNS *);
virtual ~MmAdditional_onDNS();
int32_t token() const {
return(metaToken(tkn_dns_additional_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add_other(McDNS_Additional *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
};
////////////////////////////////////////////////////////////////
class MmEntry_onQuestion: public MmReference_More0 {
static TypevsMcDict dict_;
const McUdp_DNS *McUdp_DNS_;
protected:
virtual void composeList(WControl &, WObject *, const PObjectList &) const;
public:
MmEntry_onQuestion(CSTR, McUdp_DNS *);
virtual ~MmEntry_onQuestion();
int32_t token() const {
return(metaToken(tkn_option_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add_other(McDNS_QuestionEntry *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
virtual WObject *compose(WControl &, WObject *, const PObject *) const;
};
////////////////////////////////////////////////////////////////
class MmRR_onAnswer: public MmReference_More0 {
static TypevsMcDict dict_;
const McUdp_DNS *McUdp_DNS_;
protected:
virtual void composeList(WControl &, WObject *, const PObjectList &) const;
public:
MmRR_onAnswer(CSTR, McUdp_DNS *);
virtual ~MmRR_onAnswer();
int32_t token() const {
return(metaToken(tkn_option_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add(McDNS_RR *mc);
static void add_other(McDNS_RR *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
virtual WObject *compose(WControl &, WObject *, const PObject *) const;
};
////////////////////////////////////////////////////////////////
class MmRR_onAuthority: public MmReference_More0 {
static TypevsMcDict dict_;
const McUdp_DNS *McUdp_DNS_;
protected:
virtual void composeList(WControl &, WObject *, const PObjectList &) const;
public:
MmRR_onAuthority(CSTR, McUdp_DNS *);
virtual ~MmRR_onAuthority();
int32_t token() const {
return(metaToken(tkn_option_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add(McDNS_RR *mc);
static void add_other(McDNS_RR *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
virtual WObject *compose(WControl &, WObject *, const PObject *) const;
};
////////////////////////////////////////////////////////////////
class MmRR_onAdditional: public MmReference_More0 {
static TypevsMcDict dict_;
const McUdp_DNS *McUdp_DNS_;
protected:
virtual void composeList(WControl &, WObject *, const PObjectList &) const;
public:
MmRR_onAdditional(CSTR, McUdp_DNS *);
virtual ~MmRR_onAdditional();
int32_t token() const {
return(metaToken(tkn_option_ref_));
}
const TypevsMcDict *get_dict() const {
return(&dict_);
}
static void add(McDNS_RR *mc);
static void add_other(McDNS_RR *mc);
bool overwrite_DictType(RControl &, ItPosition &, OCTBUF &) const;
virtual WObject *compose(WControl &, WObject *, const PObject *) const;
};
#endif
syntax highlighted by Code2HTML, v. 0.9.1