merged trac #358 (various cleanups to the DNS message class)

(svn merge didn't work well, probably because the branch was too old, so I chose to apply the diff by hand)


git-svn-id: svn://bind10.isc.org/svn/bind10/trunk@3439 e5f2f494-b856-4b98-b285-d166d9295462

src/bin/auth/auth_srv.cc

@@ -152,8 +152,8 @@ makeErrorMessage(Message& message, MessageRenderer& renderer,
     // XXX: with the current implementation, it's not easy to set EDNS0
     // depending on whether the query had it.  So we'll simply omit it.
     const qid_t qid = message.getQid();
-    const bool rd = message.getHeaderFlag(MessageFlag::RD());
-    const bool cd = message.getHeaderFlag(MessageFlag::CD());
+    const bool rd = message.getHeaderFlag(Message::HEADERFLAG_RD);
+    const bool cd = message.getHeaderFlag(Message::HEADERFLAG_CD);
     const Opcode& opcode = message.getOpcode();
     vector<QuestionPtr> questions;
 
@@ -166,12 +166,12 @@ makeErrorMessage(Message& message, MessageRenderer& renderer,
     message.clear(Message::RENDER);
     message.setQid(qid);
     message.setOpcode(opcode);
-    message.setHeaderFlag(MessageFlag::QR());
+    message.setHeaderFlag(Message::HEADERFLAG_QR);
     if (rd) {
-        message.setHeaderFlag(MessageFlag::RD());
+        message.setHeaderFlag(Message::HEADERFLAG_RD);
     }
     if (cd) {
-        message.setHeaderFlag(MessageFlag::CD());
+        message.setHeaderFlag(Message::HEADERFLAG_CD);
     }
     for_each(questions.begin(), questions.end(), QuestionInserter(&message));
     message.setRcode(rcode);
@@ -231,7 +231,7 @@ AuthSrv::processMessage(const IOMessage& io_message, Message& message,
         message.parseHeader(request_buffer);
 
         // Ignore all responses.
-        if (message.getHeaderFlag(MessageFlag::QR())) {
+        if (message.getHeaderFlag(Message::HEADERFLAG_QR)) {
             if (impl_->verbose_mode_) {
                 cerr << "[b10-auth] received unexpected response, ignoring"
                      << endl;
@@ -279,7 +279,7 @@ AuthSrv::processMessage(const IOMessage& io_message, Message& message,
         return (true);
     }
 
-    if (message.getRRCount(Section::QUESTION()) != 1) {
+    if (message.getRRCount(Message::SECTION_QUESTION) != 1) {
         makeErrorMessage(message, response_renderer, Rcode::FORMERR(),
                          impl_->verbose_mode_);
         return (true);
@@ -310,7 +310,7 @@ AuthSrvImpl::processNormalQuery(const IOMessage& io_message, Message& message,
         Message::DEFAULT_MAX_UDPSIZE; 
 
     message.makeResponse();
-    message.setHeaderFlag(MessageFlag::AA());
+    message.setHeaderFlag(Message::HEADERFLAG_AA);
     message.setRcode(Rcode::NOERROR());
 
     if (remote_edns) {
@@ -397,10 +397,10 @@ AuthSrvImpl::processNotify(const IOMessage& io_message, Message& message,
 {
     // The incoming notify must contain exactly one question for SOA of the
     // zone name.
-    if (message.getRRCount(Section::QUESTION()) != 1) {
+    if (message.getRRCount(Message::SECTION_QUESTION) != 1) {
         if (verbose_mode_) {
                 cerr << "[b10-auth] invalid number of questions in notify: "
-                     << message.getRRCount(Section::QUESTION()) << endl;
+                     << message.getRRCount(Message::SECTION_QUESTION) << endl;
         }
         makeErrorMessage(message, response_renderer, Rcode::FORMERR(),
                          verbose_mode_);
@@ -472,7 +472,7 @@ AuthSrvImpl::processNotify(const IOMessage& io_message, Message& message,
     }
 
     message.makeResponse();
-    message.setHeaderFlag(MessageFlag::AA());
+    message.setHeaderFlag(Message::HEADERFLAG_AA);
     message.setRcode(Rcode::NOERROR());
     message.toWire(response_renderer);
     return (true);

src/bin/auth/tests/auth_srv_unittest.cc

@@ -321,18 +321,25 @@ headerCheck(const Message& message, const qid_t qid, const Rcode& rcode,
     EXPECT_EQ(qid, message.getQid());
     EXPECT_EQ(rcode, message.getRcode());
     EXPECT_EQ(opcodeval, message.getOpcode().getCode());
-    EXPECT_EQ((flags & QR_FLAG) != 0, message.getHeaderFlag(MessageFlag::QR()));
-    EXPECT_EQ((flags & AA_FLAG) != 0, message.getHeaderFlag(MessageFlag::AA()));
-    EXPECT_EQ((flags & TC_FLAG) != 0, message.getHeaderFlag(MessageFlag::TC()));
-    EXPECT_EQ((flags & RA_FLAG) != 0, message.getHeaderFlag(MessageFlag::RA()));
-    EXPECT_EQ((flags & RD_FLAG) != 0, message.getHeaderFlag(MessageFlag::RD()));
-    EXPECT_EQ((flags & AD_FLAG) != 0, message.getHeaderFlag(MessageFlag::AD()));
-    EXPECT_EQ((flags & CD_FLAG) != 0, message.getHeaderFlag(MessageFlag::CD()));
-
-    EXPECT_EQ(qdcount, message.getRRCount(Section::QUESTION()));
-    EXPECT_EQ(ancount, message.getRRCount(Section::ANSWER()));
-    EXPECT_EQ(nscount, message.getRRCount(Section::AUTHORITY()));
-    EXPECT_EQ(arcount, message.getRRCount(Section::ADDITIONAL()));
+    EXPECT_EQ((flags & QR_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_EQ((flags & AA_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_AA));
+    EXPECT_EQ((flags & TC_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_TC));
+    EXPECT_EQ((flags & RA_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_RA));
+    EXPECT_EQ((flags & RD_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_RD));
+    EXPECT_EQ((flags & AD_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_AD));
+    EXPECT_EQ((flags & CD_FLAG) != 0,
+              message.getHeaderFlag(Message::HEADERFLAG_CD));
+
+    EXPECT_EQ(qdcount, message.getRRCount(Message::SECTION_QUESTION));
+    EXPECT_EQ(ancount, message.getRRCount(Message::SECTION_ANSWER));
+    EXPECT_EQ(nscount, message.getRRCount(Message::SECTION_AUTHORITY));
+    EXPECT_EQ(arcount, message.getRRCount(Message::SECTION_ADDITIONAL));
 }
 
 // Unsupported requests.  Should result in NOTIMP.
@@ -540,7 +547,7 @@ TEST_F(AuthSrvTest, AXFRDisconnectFail) {
 TEST_F(AuthSrvTest, notify) {
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_TRUE(server.processMessage(*io_message, parse_message,
                                       response_renderer));
@@ -572,7 +579,7 @@ TEST_F(AuthSrvTest, notifyForCHClass) {
     // Same as the previous test, but for the CH RRClass.
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::CH(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_TRUE(server.processMessage(*io_message, parse_message,
                                       response_renderer));
@@ -588,7 +595,7 @@ TEST_F(AuthSrvTest, notifyEmptyQuestion) {
     request_message.clear(Message::RENDER);
     request_message.setOpcode(Opcode::NOTIFY());
     request_message.setRcode(Rcode::NOERROR());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     request_message.setQid(default_qid);
     request_message.toWire(request_renderer);
     createRequestPacket(IPPROTO_UDP);
@@ -604,7 +611,7 @@ TEST_F(AuthSrvTest, notifyMultiQuestions) {
     // add one more SOA question
     request_message.addQuestion(Question(Name("example.com"), RRClass::IN(),
                                          RRType::SOA()));
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_TRUE(server.processMessage(*io_message, parse_message,
                                       response_renderer));
@@ -615,7 +622,7 @@ TEST_F(AuthSrvTest, notifyMultiQuestions) {
 TEST_F(AuthSrvTest, notifyNonSOAQuestion) {
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::NS());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_TRUE(server.processMessage(*io_message, parse_message,
                                       response_renderer));
@@ -636,7 +643,7 @@ TEST_F(AuthSrvTest, notifyWithoutAA) {
 TEST_F(AuthSrvTest, notifyWithErrorRcode) {
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     request_message.setRcode(Rcode::SERVFAIL());
     createRequestPacket(IPPROTO_UDP);
     EXPECT_TRUE(server.processMessage(*io_message, parse_message,
@@ -650,7 +657,7 @@ TEST_F(AuthSrvTest, notifyWithoutSession) {
 
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
 
     // we simply ignore the notify and let it be resent if an internal error
@@ -664,7 +671,7 @@ TEST_F(AuthSrvTest, notifySendFail) {
 
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
 
     EXPECT_FALSE(server.processMessage(*io_message, parse_message,
@@ -676,7 +683,7 @@ TEST_F(AuthSrvTest, notifyReceiveFail) {
 
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_FALSE(server.processMessage(*io_message, parse_message,
                                        response_renderer));
@@ -687,7 +694,7 @@ TEST_F(AuthSrvTest, notifyWithBogusSessionMessage) {
 
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_FALSE(server.processMessage(*io_message, parse_message,
                                        response_renderer));
@@ -699,7 +706,7 @@ TEST_F(AuthSrvTest, notifyWithSessionMessageError) {
 
     createRequestMessage(Opcode::NOTIFY(), Name("example.com"), RRClass::IN(),
                         RRType::SOA());
-    request_message.setHeaderFlag(MessageFlag::AA());
+    request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(IPPROTO_UDP);
     EXPECT_FALSE(server.processMessage(*io_message, parse_message,
                                        response_renderer));

src/bin/host/host.cc

@@ -58,7 +58,7 @@ host_lookup(const char* const name, const char* const type) {
     msg.setOpcode(Opcode::QUERY());
     msg.setRcode(Rcode::NOERROR());
     if (recursive_bit) {
-        msg.setHeaderFlag(MessageFlag::RD());    // set recursive bit
+        msg.setHeaderFlag(Message::HEADERFLAG_RD); // set recursive bit
     }
 
     msg.addQuestion(Question(Name(name),
@@ -122,9 +122,10 @@ host_lookup(const char* const name, const char* const type) {
 
             rmsg.fromWire(ibuffer);
             if (!verbose) {
-                  for (RRsetIterator it = rmsg.beginSection(Section::ANSWER());
-                       it != rmsg.endSection(Section::ANSWER());
-                       ++it) {
+                for (RRsetIterator it =
+                         rmsg.beginSection(Message::SECTION_ANSWER);
+                     it != rmsg.endSection(Message::SECTION_ANSWER);
+                     ++it) {
                       if ((*it)->getType() != RRType::A()) {
                           continue;
                       }

src/bin/xfrin/tests/xfrin_test.py

@@ -135,9 +135,9 @@ class MockXfrinConnection(XfrinConnection):
         resp.set_opcode(Opcode.QUERY())
         resp.set_rcode(rcode)
         if response:
-            resp.set_header_flag(MessageFlag.QR())
+            resp.set_header_flag(Message.HEADERFLAG_QR)
         [resp.add_question(q) for q in questions]
-        [resp.add_rrset(Section.ANSWER(), a) for a in answers]
+        [resp.add_rrset(Message.SECTION_ANSWER, a) for a in answers]
 
         renderer = MessageRenderer()
         resp.to_wire(renderer)

src/bin/xfrin/xfrin.py.in

@@ -240,7 +240,7 @@ class XfrinConnection(asyncore.dispatcher):
         if msg_rcode != Rcode.NOERROR():
             raise XfrinException('error response: %s' % msg_rcode.to_text())
 
-        if not msg.get_header_flag(MessageFlag.QR()):
+        if not msg.get_header_flag(Message.HEADERFLAG_QR):
             raise XfrinException('response is not a response ')
 
         if msg.get_qid() != self._query_id:
@@ -251,10 +251,10 @@ class XfrinConnection(asyncore.dispatcher):
 
         self._check_response_header(msg)
 
-        if msg.get_rr_count(Section.ANSWER()) == 0:
+        if msg.get_rr_count(Message.SECTION_ANSWER) == 0:
             raise XfrinException('answer section is empty')
 
-        if msg.get_rr_count(Section.QUESTION()) > 1:
+        if msg.get_rr_count(Message.SECTION_QUESTION) > 1:
             raise XfrinException('query section count greater than 1')
 
     def _handle_answer_section(self, answer_section):
@@ -294,7 +294,7 @@ class XfrinConnection(asyncore.dispatcher):
             msg.from_wire(recvdata)
             self._check_response_status(msg)
             
-            answer_section = msg.get_section(Section.ANSWER())
+            answer_section = msg.get_section(Message.SECTION_ANSWER)
             for rr in self._handle_answer_section(answer_section):
                 yield rr
 

src/bin/xfrout/tests/xfrout_test.py

@@ -115,7 +115,7 @@ class TestXfroutSession(unittest.TestCase):
         self.assertEqual(msg.get_qid(), qid)
         self.assertEqual(msg.get_opcode(), opcode)
         self.assertEqual(msg.get_rcode(), rcode)
-        self.assertTrue(msg.get_header_flag(MessageFlag.AA()))
+        self.assertTrue(msg.get_header_flag(Message.HEADERFLAG_AA))
 
     def test_reply_query_with_format_error(self):
          
@@ -140,12 +140,12 @@ class TestXfroutSession(unittest.TestCase):
         self.xfrsess._send_message_with_last_soa(msg, self.sock, rrset_soa, 0)
         get_msg = self.sock.read_msg()
 
-        self.assertEqual(get_msg.get_rr_count(Section.QUESTION()), 1)
-        self.assertEqual(get_msg.get_rr_count(Section.ANSWER()), 1)
-        self.assertEqual(get_msg.get_rr_count(Section.AUTHORITY()), 0)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_QUESTION), 1)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_ANSWER), 1)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_AUTHORITY), 0)
 
         #answer_rrset_iter = section_iter(get_msg, section.ANSWER())
-        answer = get_msg.get_section(Section.ANSWER())[0]#answer_rrset_iter.get_rrset()
+        answer = get_msg.get_section(Message.SECTION_ANSWER)[0]#answer_rrset_iter.get_rrset()
         self.assertEqual(answer.get_name().to_text(), "example.com.")
         self.assertEqual(answer.get_class(), RRClass("IN"))
         self.assertEqual(answer.get_type().to_text(), "SOA")
@@ -160,7 +160,7 @@ class TestXfroutSession(unittest.TestCase):
         msg = self.getmsg()
         msg.make_response()
 
-        msg.add_rrset(Section.ANSWER(), rrset_a)
+        msg.add_rrset(Message.SECTION_ANSWER, rrset_a)
         # give the function a value that is larger than MAX-len(rrset)
         self.xfrsess._send_message_with_last_soa(msg, self.sock, rrset_soa, 65520)
 
@@ -168,11 +168,11 @@ class TestXfroutSession(unittest.TestCase):
         # (1 with the rrset we added manually, and 1 that triggered
         # the sending in _with_last_soa)
         get_msg = self.sock.read_msg()
-        self.assertEqual(get_msg.get_rr_count(Section.QUESTION()), 1)
-        self.assertEqual(get_msg.get_rr_count(Section.ANSWER()), 1)
-        self.assertEqual(get_msg.get_rr_count(Section.AUTHORITY()), 0)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_QUESTION), 1)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_ANSWER), 1)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_AUTHORITY), 0)
 
-        answer = get_msg.get_section(Section.ANSWER())[0]
+        answer = get_msg.get_section(Message.SECTION_ANSWER)[0]
         self.assertEqual(answer.get_name().to_text(), "example.com.")
         self.assertEqual(answer.get_class(), RRClass("IN"))
         self.assertEqual(answer.get_type().to_text(), "A")
@@ -180,12 +180,12 @@ class TestXfroutSession(unittest.TestCase):
         self.assertEqual(rdata[0].to_text(), "192.0.2.1")
 
         get_msg = self.sock.read_msg()
-        self.assertEqual(get_msg.get_rr_count(Section.QUESTION()), 0)
-        self.assertEqual(get_msg.get_rr_count(Section.ANSWER()), 1)
-        self.assertEqual(get_msg.get_rr_count(Section.AUTHORITY()), 0)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_QUESTION), 0)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_ANSWER), 1)
+        self.assertEqual(get_msg.get_rr_count(Message.SECTION_AUTHORITY), 0)
 
-        #answer_rrset_iter = section_iter(get_msg, section.ANSWER())
-        answer = get_msg.get_section(Section.ANSWER())[0]
+        #answer_rrset_iter = section_iter(get_msg, Message.SECTION_ANSWER)
+        answer = get_msg.get_section(Message.SECTION_ANSWER)[0]
         self.assertEqual(answer.get_name().to_text(), "example.com.")
         self.assertEqual(answer.get_class(), RRClass("IN"))
         self.assertEqual(answer.get_type().to_text(), "SOA")
@@ -281,7 +281,7 @@ class TestXfroutSession(unittest.TestCase):
         sqlite3_ds.get_zone_datas = get_zone_datas
         self.xfrsess._reply_xfrout_query(self.getmsg(), self.sock, "example.com.")
         reply_msg = self.sock.read_msg()
-        self.assertEqual(reply_msg.get_rr_count(Section.ANSWER()), 2)
+        self.assertEqual(reply_msg.get_rr_count(Message.SECTION_ANSWER), 2)
 
 class MyCCSession():
     def __init__(self):

src/bin/xfrout/xfrout.py.in

@@ -226,8 +226,8 @@ class XfroutSession(BaseRequestHandler):
         msg.set_qid(qid)
         msg.set_opcode(opcode)
         msg.set_rcode(rcode)
-        msg.set_header_flag(MessageFlag.AA())
-        msg.set_header_flag(MessageFlag.QR())
+        msg.set_header_flag(Message.HEADERFLAG_AA)
+        msg.set_header_flag(Message.HEADERFLAG_QR)
         return msg
 
     def _create_rrset_from_db_record(self, record):
@@ -247,11 +247,11 @@ class XfroutSession(BaseRequestHandler):
         rrset_len = get_rrset_len(rrset_soa)
 
         if message_upper_len + rrset_len < XFROUT_MAX_MESSAGE_SIZE:
-            msg.add_rrset(Section.ANSWER(), rrset_soa)
+            msg.add_rrset(Message.SECTION_ANSWER, rrset_soa)
         else:
             self._send_message(sock, msg)
             msg = self._clear_message(msg)
-            msg.add_rrset(Section.ANSWER(), rrset_soa)
+            msg.add_rrset(Message.SECTION_ANSWER, rrset_soa)
 
         self._send_message(sock, msg)
 
@@ -259,10 +259,10 @@ class XfroutSession(BaseRequestHandler):
     def _reply_xfrout_query(self, msg, sock, zone_name):
         #TODO, there should be a better way to insert rrset.
         msg.make_response()
-        msg.set_header_flag(MessageFlag.AA())
+        msg.set_header_flag(Message.HEADERFLAG_AA)
         soa_record = sqlite3_ds.get_zone_soa(zone_name, self.server.get_db_file())
         rrset_soa = self._create_rrset_from_db_record(soa_record)
-        msg.add_rrset(Section.ANSWER(), rrset_soa)
+        msg.add_rrset(Message.SECTION_ANSWER, rrset_soa)
 
         message_upper_len = get_rrset_len(rrset_soa)
 
@@ -282,13 +282,13 @@ class XfroutSession(BaseRequestHandler):
             # may have reached the limit
             rrset_len = get_rrset_len(rrset_)
             if message_upper_len + rrset_len < XFROUT_MAX_MESSAGE_SIZE:
-                msg.add_rrset(Section.ANSWER(), rrset_)
+                msg.add_rrset(Message.SECTION_ANSWER, rrset_)
                 message_upper_len += rrset_len
                 continue
 
             self._send_message(sock, msg)
             msg = self._clear_message(msg)
-            msg.add_rrset(Section.ANSWER(), rrset_) # Add the rrset to the new message
+            msg.add_rrset(Message.SECTION_ANSWER, rrset_) # Add the rrset to the new message
             message_upper_len = rrset_len
 
         self._send_message_with_last_soa(msg, sock, rrset_soa, message_upper_len)

src/lib/bench/tests/loadquery_unittest.cc

@@ -82,12 +82,12 @@ public:
         EXPECT_EQ(0, message.getQid());
         EXPECT_EQ(Opcode::QUERY(), message.getOpcode());
         EXPECT_EQ(Rcode::NOERROR(), message.getRcode());
-        EXPECT_FALSE(message.getHeaderFlag(MessageFlag::QR()));
-        EXPECT_FALSE(message.getHeaderFlag(MessageFlag::AA()));
-        EXPECT_EQ(1, message.getRRCount(Section::QUESTION()));
-        EXPECT_EQ(0, message.getRRCount(Section::ANSWER()));
-        EXPECT_EQ(0, message.getRRCount(Section::AUTHORITY()));
-        EXPECT_EQ(0, message.getRRCount(Section::ADDITIONAL()));
+        EXPECT_FALSE(message.getHeaderFlag(Message::HEADERFLAG_QR));
+        EXPECT_FALSE(message.getHeaderFlag(Message::HEADERFLAG_AA));
+        EXPECT_EQ(1, message.getRRCount(Message::SECTION_QUESTION));
+        EXPECT_EQ(0, message.getRRCount(Message::SECTION_ANSWER));
+        EXPECT_EQ(0, message.getRRCount(Message::SECTION_AUTHORITY));
+        EXPECT_EQ(0, message.getRRCount(Message::SECTION_ADDITIONAL));
 
         // Check if the question matches our original data, if the expected
         // data is given.

src/lib/datasrc/data_source.cc

@@ -101,14 +101,14 @@ getAdditional(Query& q, ConstRRsetPtr rrset) {
             const generic::NS& ns = dynamic_cast<const generic::NS&>(rd);
             q.tasks().push(QueryTaskPtr(
                                new QueryTask(q, ns.getNSName(),
-                                             Section::ADDITIONAL(),
+                                             Message::SECTION_ADDITIONAL,
                                              QueryTask::GLUE_QUERY,
                                              QueryTask::GETADDITIONAL))); 
         } else if (rrset->getType() == RRType::MX()) {
             const generic::MX& mx = dynamic_cast<const generic::MX&>(rd);
             q.tasks().push(QueryTaskPtr(
                                new QueryTask(q, mx.getMXName(),
-                                             Section::ADDITIONAL(),
+                                             Message::SECTION_ADDITIONAL,
                                              QueryTask::NOGLUE_QUERY,
                                              QueryTask::GETADDITIONAL))); 
         }
@@ -165,7 +165,7 @@ chaseCname(Query& q, QueryTaskPtr task, RRsetPtr rrset) {
     q.tasks().push(QueryTaskPtr(
                        new QueryTask(q, dynamic_cast<const generic::CNAME&>
                                      (it->getCurrent()).getCname(),
-                                     task->qtype, Section::ANSWER(),
+                                     task->qtype, Message::SECTION_ANSWER,
                                      QueryTask::FOLLOWCNAME)));
 }
 
@@ -473,16 +473,19 @@ doQueryTask(QueryTask& task, ZoneInfo& zoneinfo, RRsetList& target) {
 // checking first to ensure that there isn't already an RRset with
 // the same name and type.
 inline void
-addToMessage(Query& q, const Section& sect, RRsetPtr rrset,
+addToMessage(Query& q, const Message::Section sect, RRsetPtr rrset,
              bool no_dnssec = false)
 {
     Message& m = q.message();
     if (no_dnssec) {
-        if (rrset->getType() == RRType::RRSIG() || !m.hasRRset(sect, rrset)) {
+        if (rrset->getType() == RRType::RRSIG() ||
+            !m.hasRRset(sect, rrset->getName(), rrset->getClass(),
+                        rrset->getType())) {
             m.addRRset(sect, rrset, false);
         }
     } else {
-        if (!m.hasRRset(sect, rrset)) {
+        if (!m.hasRRset(sect, rrset->getName(), rrset->getClass(),
+                        rrset->getType())) {
             m.addRRset(sect, rrset, q.wantDnssec());
         }
     }
@@ -498,7 +501,7 @@ copyAuth(Query& q, RRsetList& auth) {
         if (rrset->getType() == RRType::DS() && !q.wantDnssec()) {
             continue;
         }
-        addToMessage(q, Section::AUTHORITY(), rrset);
+        addToMessage(q, Message::SECTION_AUTHORITY, rrset);
         getAdditional(q, rrset);
     }
 }
@@ -560,11 +563,11 @@ hasDelegation(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo) {
             RRsetPtr r = ref.findRRset(RRType::DNAME(), q.qclass());
             if (r != NULL) {
                 RRsetList syn;
-                addToMessage(q, Section::ANSWER(), r);
-                q.message().setHeaderFlag(MessageFlag::AA());
+                addToMessage(q, Message::SECTION_ANSWER, r);
+                q.message().setHeaderFlag(Message::HEADERFLAG_AA);
                 synthesizeCname(task, r, syn);
                 if (syn.size() == 1) {
-                    addToMessage(q, Section::ANSWER(),
+                    addToMessage(q, Message::SECTION_ANSWER,
                                  syn.findRRset(RRType::CNAME(), q.qclass()));
                     chaseCname(q, task, syn.findRRset(RRType::CNAME(),
                                                       q.qclass()));
@@ -582,7 +585,7 @@ hasDelegation(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo) {
     // at the actual qname node.)
     if (task->op == QueryTask::AUTH_QUERY &&
         task->state == QueryTask::GETANSWER) {
-        q.message().setHeaderFlag(MessageFlag::AA());
+        q.message().setHeaderFlag(Message::HEADERFLAG_AA);
     }
 
     return (false);
@@ -599,7 +602,7 @@ addSOA(Query& q, ZoneInfo& zoneinfo) {
         return (DataSrc::ERROR);
     }
 
-    addToMessage(q, Section::AUTHORITY(),
+    addToMessage(q, Message::SECTION_AUTHORITY,
                  soa.findRRset(RRType::SOA(), q.qclass()));
     return (DataSrc::SUCCESS);
 }
@@ -611,7 +614,7 @@ addNSEC(Query& q, const Name& name, ZoneInfo& zoneinfo) {
     QueryTask newtask(q, name, RRType::NSEC(), QueryTask::SIMPLE_QUERY); 
     RETERR(doQueryTask(newtask, zoneinfo, nsec));
     if (newtask.flags == 0) {
-        addToMessage(q, Section::AUTHORITY(),
+        addToMessage(q, Message::SECTION_AUTHORITY,
                      nsec.findRRset(RRType::NSEC(), q.qclass()));
     }
 
@@ -680,7 +683,7 @@ proveNX(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo, const bool wildcard) {
         RRsetPtr rrset;
         string hash1(nsec3->getHash(task->qname));
         RETERR(getNsec3(q, zoneinfo, hash1, rrset));
-        addToMessage(q, Section::AUTHORITY(), rrset);
+        addToMessage(q, Message::SECTION_AUTHORITY, rrset);
 
         // If this is an NXRRSET or NOERROR/NODATA, we're done
         if ((task->flags & DataSrc::TYPE_NOT_FOUND) != 0) {
@@ -705,7 +708,7 @@ proveNX(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo, const bool wildcard) {
             // we don't want to use one until we find an exact match
             RETERR(getNsec3(q, zoneinfo, hash2, rrset));
             if (hash2 == nodehash) {
-                addToMessage(q, Section::AUTHORITY(), rrset);
+                addToMessage(q, Message::SECTION_AUTHORITY, rrset);
                 break;
             }
         }
@@ -720,7 +723,7 @@ proveNX(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo, const bool wildcard) {
         string hash3(nsec3->getHash(Name("*").concatenate(enclosure)));
         RETERR(getNsec3(q, zoneinfo, hash3, rrset));
         if (hash3 != hash1 && hash3 != hash2) {
-            addToMessage(q, Section::AUTHORITY(), rrset);
+            addToMessage(q, Message::SECTION_AUTHORITY, rrset);
         }
     } else {
         Name nsecname(task->qname);
@@ -778,7 +781,7 @@ tryWildcard(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo, bool& found) {
 
     for (int i = 1; i <= diff; ++i) {
         const Name& wname(star.concatenate(task->qname.split(i)));
-        QueryTask newtask(q, wname, task->qtype, Section::ANSWER(),
+        QueryTask newtask(q, wname, task->qtype, Message::SECTION_ANSWER,
                           QueryTask::AUTH_QUERY); 
         result = doQueryTask(newtask, zoneinfo, wild);
         if (result == DataSrc::SUCCESS) {
@@ -820,13 +823,13 @@ tryWildcard(Query& q, QueryTaskPtr task, ZoneInfo& zoneinfo, bool& found) {
             RRsetPtr rrset = wild.findRRset(RRType::CNAME(), q.qclass());
             if (rrset != NULL) {
                 rrset->setName(task->qname);
-                addToMessage(q, Section::ANSWER(), rrset);
+                addToMessage(q, Message::SECTION_ANSWER, rrset);
                 chaseCname(q, task, rrset);
             }
         } else {
             BOOST_FOREACH (RRsetPtr rrset, wild) {
                 rrset->setName(task->qname);
-                addToMessage(q, Section::ANSWER(), rrset);
+                addToMessage(q, Message::SECTION_ANSWER, rrset);
             }
 
             RRsetList auth;
@@ -855,7 +858,7 @@ DataSrc::doQuery(Query& q) {
 
     // Process the query task queue.  (The queue is initialized
     // and the first task placed on it by the Query constructor.)
-    m.clearHeaderFlag(MessageFlag::AA());
+    m.setHeaderFlag(Message::HEADERFLAG_AA, false);
     while (!q.tasks().empty()) {
         QueryTaskPtr task = q.tasks().front();
         q.tasks().pop();
@@ -982,19 +985,19 @@ DataSrc::doQuery(Query& q) {
             // The qname node contains an out-of-zone referral.
             if (task->state == QueryTask::GETANSWER) {
                 RRsetList auth;
-                m.clearHeaderFlag(MessageFlag::AA());
+                m.setHeaderFlag(Message::HEADERFLAG_AA, false);
                 if (!refQuery(q, task->qname, zoneinfo, auth)) {
                     m.setRcode(Rcode::SERVFAIL());
                     return;
                 }
                 BOOST_FOREACH (RRsetPtr rrset, auth) {
                     if (rrset->getType() == RRType::NS()) {
-                        addToMessage(q, Section::AUTHORITY(), rrset);
+                        addToMessage(q, Message::SECTION_AUTHORITY, rrset);
                     } else if (rrset->getType() == task->qtype) {
-                        addToMessage(q, Section::ANSWER(), rrset);
+                        addToMessage(q, Message::SECTION_ANSWER, rrset);
                     } else if (rrset->getType() == RRType::DS() &&
                                q.wantDnssec()) {
-                        addToMessage(q, Section::AUTHORITY(), rrset);
+                        addToMessage(q, Message::SECTION_AUTHORITY, rrset);
                     }
                     getAdditional(q, rrset);
                 }
@@ -1063,13 +1066,14 @@ DataSrc::doQuery(Query& q) {
     // space, signatures in additional section are
     // optional.)
     BOOST_FOREACH(RRsetPtr rrset, additional) {
-        addToMessage(q, Section::ADDITIONAL(), rrset, true);
+        addToMessage(q, Message::SECTION_ADDITIONAL, rrset, true);
     }
 
     if (q.wantDnssec()) {
         BOOST_FOREACH(RRsetPtr rrset, additional) {
             if (rrset->getRRsig()) {
-                addToMessage(q, Section::ADDITIONAL(), rrset->getRRsig(), true);
+                addToMessage(q, Message::SECTION_ADDITIONAL, rrset->getRRsig(),
+                             true);
             }
         }
     }

src/lib/datasrc/query.cc

@@ -29,27 +29,31 @@ namespace isc {
 namespace datasrc {
 
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
-                     const isc::dns::RRType& t, const isc::dns::Section& sect) :
+                     const isc::dns::RRType& t,
+                     const isc::dns::Message::Section sect) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(t), section(sect),
     op(AUTH_QUERY), state(GETANSWER), flags(0)
 {}
 
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n, 
-                     const isc::dns::RRType& t, const isc::dns::Section& sect,
+                     const isc::dns::RRType& t,
+                     const isc::dns::Message::Section sect,
                      const Op o) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(t), section(sect), op(o),
     state(GETANSWER), flags(0)
 {}
 
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
-                     const isc::dns::RRType& t, const isc::dns::Section& sect,
+                     const isc::dns::RRType& t,
+                     const isc::dns::Message::Section sect,
                      const State st) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(t), section(sect),
     op(AUTH_QUERY), state(st), flags(0)
 {}
 
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
-                     const isc::dns::RRType& t, const isc::dns::Section& sect,
+                     const isc::dns::RRType& t,
+                     const isc::dns::Message::Section sect,
                      const Op o, const State st) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(t), section(sect), op(o),
     state(st), flags(0) 
@@ -58,7 +62,7 @@ QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n, 
                      const isc::dns::RRType& t, const Op o) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(t),
-    section(Section::ANSWER()), op(o), state(GETANSWER), flags(0)
+    section(Message::SECTION_ANSWER), op(o), state(GETANSWER), flags(0)
 {
     if (op != SIMPLE_QUERY) {
         isc_throw(Unexpected, "invalid constructor for this task operation");
@@ -68,7 +72,7 @@ QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
 // A referral query doesn't need to specify section, state, or type.
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n, const Op o) :
     q(qry), qname(n), qclass(qry.qclass()), qtype(RRType::ANY()),
-    section(Section::ANSWER()), op(o), state(GETANSWER), flags(0)
+    section(Message::SECTION_ANSWER), op(o), state(GETANSWER), flags(0)
 {
     if (op != REF_QUERY) {
         isc_throw(Unexpected, "invalid constructor for this task operation");
@@ -76,7 +80,7 @@ QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n, const Op o) :
 }
 
 QueryTask::QueryTask(const Query& qry, const isc::dns::Name& n,
-                     const isc::dns::Section& sect, const Op o,
+                     const isc::dns::Message::Section sect, const Op o,
                      const State st) :
         q(qry), qname(n), qclass(qry.qclass()), qtype(RRType::ANY()),
         section(sect), op(o), state(st), flags(0)
@@ -93,7 +97,7 @@ Query::Query(Message& m, HotCache& c, bool dnssec) :
     cache_(&c), message_(&m), want_additional_(true), want_dnssec_(dnssec)
 {
     // Check message formatting
-    if (message_->getRRCount(Section::QUESTION()) != 1) {
+    if (message_->getRRCount(Message::SECTION_QUESTION) != 1) {
         isc_throw(Unexpected, "malformed message: too many questions");
     }
 
@@ -105,7 +109,7 @@ Query::Query(Message& m, HotCache& c, bool dnssec) :
     restarts_ = 0;
 
     querytasks_.push(QueryTaskPtr(new QueryTask(*this, *qname_, *qtype_,
-                                                Section::ANSWER())));
+                                                Message::SECTION_ANSWER)));
 }
 
 Query::~Query() {}

src/lib/datasrc/query.h

@@ -57,7 +57,7 @@ public:
 
     // The section of the reply into which the data should be
     // written after it has been fetched from the data source.
-    const isc::dns::Section section;
+    const isc::dns::Message::Section section;
 
     // The op field indicates the operation to be carried out by
     // this query task:
@@ -127,14 +127,18 @@ public:
 
     // Constructors
     QueryTask(const Query& q, const isc::dns::Name& n,
-              const isc::dns::RRType& t, const isc::dns::Section& sect);
+              const isc::dns::RRType& t,
+              const isc::dns::Message::Section sect);
     QueryTask(const Query& q, const isc::dns::Name& n,
-              const isc::dns::RRType& t, const isc::dns::Section& sect, Op o);
+              const isc::dns::RRType& t,
+              const isc::dns::Message::Section sect, Op o);
     QueryTask(const Query& q, const isc::dns::Name& n,
-              const isc::dns::RRType& t, const isc::dns::Section& sect,
+              const isc::dns::RRType& t,
+              const isc::dns::Message::Section sect,
               const State st);
     QueryTask(const Query& q, const isc::dns::Name& n,
-              const isc::dns::RRType& t, const isc::dns::Section& sect,
+              const isc::dns::RRType& t,
+              const isc::dns::Message::Section sect,
               Op o, State st);
 
     // These are special constructors for particular query task types,
@@ -147,7 +151,7 @@ public:
     QueryTask(const Query& q, const isc::dns::Name& n, Op o);
     // A glue (or noglue) query doesn't need to specify type.
     QueryTask(const Query& q, const isc::dns::Name& n,
-              const isc::dns::Section& sect, Op o, State st);
+              const isc::dns::Message::Section sect, Op o, State st);
 
     ~QueryTask();
 };

src/lib/datasrc/tests/datasrc_unittest.cc

@@ -79,7 +79,7 @@ protected:
 
 void
 performQuery(DataSrc& data_source, HotCache& cache, Message& message) {
-    message.setHeaderFlag(MessageFlag::AA());
+    message.setHeaderFlag(Message::HEADERFLAG_AA);
     message.setRcode(Rcode::NOERROR());
     Query q(message, cache, true);
     data_source.doQuery(q);
@@ -92,7 +92,7 @@ DataSrcTest::createAndProcessQuery(const Name& qname, const RRClass& qclass,
     msg.makeResponse();
     msg.setOpcode(Opcode::QUERY());
     msg.addQuestion(Question(qname, qclass, qtype));
-    msg.setHeaderFlag(MessageFlag::RD());
+    msg.setHeaderFlag(Message::HEADERFLAG_RD);
     performQuery(meta_source, cache, msg);
 }
 
@@ -102,13 +102,13 @@ headerCheck(const Message& message, const Rcode& rcode, const bool qrflag,
             const unsigned int nscount, const unsigned int arcount)
 {
     EXPECT_EQ(rcode, message.getRcode());
-    EXPECT_EQ(qrflag, message.getHeaderFlag(MessageFlag::QR()));
-    EXPECT_EQ(aaflag, message.getHeaderFlag(MessageFlag::AA()));
-    EXPECT_EQ(rdflag, message.getHeaderFlag(MessageFlag::RD()));
+    EXPECT_EQ(qrflag, message.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_EQ(aaflag, message.getHeaderFlag(Message::HEADERFLAG_AA));
+    EXPECT_EQ(rdflag, message.getHeaderFlag(Message::HEADERFLAG_RD));
 
-    EXPECT_EQ(ancount, message.getRRCount(Section::ANSWER()));
-    EXPECT_EQ(nscount, message.getRRCount(Section::AUTHORITY()));
-    EXPECT_EQ(arcount, message.getRRCount(Section::ADDITIONAL()));
+    EXPECT_EQ(ancount, message.getRRCount(Message::SECTION_ANSWER));
+    EXPECT_EQ(nscount, message.getRRCount(Message::SECTION_AUTHORITY));
+    EXPECT_EQ(arcount, message.getRRCount(Message::SECTION_ADDITIONAL));
 }
 
 void
@@ -117,7 +117,7 @@ DataSrcTest::QueryCommon(const RRClass& qclass) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -131,7 +131,7 @@ DataSrcTest::QueryCommon(const RRClass& qclass) {
 
     // XXX: also check ANSWER RRSIG
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -147,7 +147,7 @@ DataSrcTest::QueryCommon(const RRClass& qclass) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("dns01.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -171,9 +171,9 @@ TEST_F(DataSrcTest, QueryClassMismatch) {
     headerCheck(msg, Rcode::REFUSED(), true, false, true, 0, 0, 0);
 
     EXPECT_EQ(Rcode::REFUSED(), msg.getRcode());
-    EXPECT_TRUE(msg.getHeaderFlag(MessageFlag::QR()));
-    EXPECT_FALSE(msg.getHeaderFlag(MessageFlag::AA()));
-    EXPECT_TRUE(msg.getHeaderFlag(MessageFlag::RD()));
+    EXPECT_TRUE(msg.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_FALSE(msg.getHeaderFlag(Message::HEADERFLAG_AA));
+    EXPECT_TRUE(msg.getHeaderFlag(Message::HEADERFLAG_RD));
 }
 
 // Query class of any should match the first data source.
@@ -186,7 +186,7 @@ TEST_F(DataSrcTest, NSQuery) {
                           RRType::NS());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 0, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -209,7 +209,7 @@ TEST_F(DataSrcTest, DuplicateQuery) {
                           RRType::NS());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 0, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -230,7 +230,7 @@ TEST_F(DataSrcTest, DuplicateQuery) {
                           RRType::NS());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 0, 6);
 
-    rit = msg.beginSection(Section::ANSWER());
+    rit = msg.beginSection(Message::SECTION_ANSWER);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -252,7 +252,7 @@ TEST_F(DataSrcTest, DNSKEYQuery) {
                           RRType::DNSKEY());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::DNSKEY(), rrset->getType());
@@ -267,7 +267,7 @@ TEST_F(DataSrcTest, DNSKEYDuplicateQuery) {
                           RRType::DNSKEY());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::DNSKEY(), rrset->getType());
@@ -276,7 +276,7 @@ TEST_F(DataSrcTest, DNSKEYDuplicateQuery) {
     msg.clear(Message::PARSE);
     createAndProcessQuery(Name("example.com"), RRClass::IN(),
                           RRType::DNSKEY());
-    rit = msg.beginSection(Section::ANSWER());
+    rit = msg.beginSection(Message::SECTION_ANSWER);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::DNSKEY(), rrset->getType());
@@ -289,7 +289,7 @@ TEST_F(DataSrcTest, NxRRset) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 0, 4, 0);
 
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::SOA(), rrset->getType());
@@ -301,7 +301,7 @@ TEST_F(DataSrcTest, Nxdomain) {
 
     headerCheck(msg, Rcode::NXDOMAIN(), true, true, true, 0, 6, 0);
 
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::SOA(), rrset->getType());
@@ -316,9 +316,9 @@ TEST_F(DataSrcTest, NxZone) {
     headerCheck(msg, Rcode::REFUSED(), true, false, true, 0, 0, 0);
 
     EXPECT_EQ(Rcode::REFUSED(), msg.getRcode());
-    EXPECT_TRUE(msg.getHeaderFlag(MessageFlag::QR()));
-    EXPECT_FALSE(msg.getHeaderFlag(MessageFlag::AA()));
-    EXPECT_TRUE(msg.getHeaderFlag(MessageFlag::RD()));
+    EXPECT_TRUE(msg.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_FALSE(msg.getHeaderFlag(Message::HEADERFLAG_AA));
+    EXPECT_TRUE(msg.getHeaderFlag(Message::HEADERFLAG_RD));
 }
 
 TEST_F(DataSrcTest, Wildcard) {
@@ -327,7 +327,7 @@ TEST_F(DataSrcTest, Wildcard) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 6, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.wild.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -339,7 +339,7 @@ TEST_F(DataSrcTest, Wildcard) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("*.wild.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NSEC(), rrset->getType());
@@ -362,7 +362,7 @@ TEST_F(DataSrcTest, Wildcard) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("dns01.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -399,7 +399,7 @@ TEST_F(DataSrcTest, WildcardCname) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 6, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.wild2.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -424,7 +424,7 @@ TEST_F(DataSrcTest, WildcardCname) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("*.wild2.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NSEC(), rrset->getType());
@@ -447,7 +447,7 @@ TEST_F(DataSrcTest, WildcardCname) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("dns01.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -467,7 +467,7 @@ TEST_F(DataSrcTest, WildcardCnameNodata) {
                           RRType::AAAA());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 4, 0);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.wild2.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -479,7 +479,7 @@ TEST_F(DataSrcTest, WildcardCnameNodata) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("*.wild2.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NSEC(), rrset->getType());
@@ -499,7 +499,7 @@ TEST_F(DataSrcTest, WildcardCnameNxdomain) {
                           RRType::A());
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 6, 0);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.wild3.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -511,7 +511,7 @@ TEST_F(DataSrcTest, WildcardCnameNxdomain) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("*.wild3.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NSEC(), rrset->getType());
@@ -537,7 +537,7 @@ TEST_F(DataSrcTest, AuthDelegation) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("www.sql1.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -549,7 +549,7 @@ TEST_F(DataSrcTest, AuthDelegation) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("sql1.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -565,7 +565,7 @@ TEST_F(DataSrcTest, AuthDelegation) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("dns01.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -584,7 +584,7 @@ TEST_F(DataSrcTest, Dname) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 5, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("dname.example.com"), rrset->getName());
     EXPECT_EQ(RRType::DNAME(), rrset->getType());
@@ -598,7 +598,7 @@ TEST_F(DataSrcTest, Dname) {
 
     // XXX: check CNAME and A record too
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("sql1.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -614,7 +614,7 @@ TEST_F(DataSrcTest, Dname) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("dns01.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -642,7 +642,7 @@ TEST_F(DataSrcTest, Cname) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 0, 0);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("foo.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -661,7 +661,7 @@ TEST_F(DataSrcTest, CnameInt) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("cname-int.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -675,7 +675,7 @@ TEST_F(DataSrcTest, CnameInt) {
 
     // XXX: check a record as well
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -688,7 +688,7 @@ TEST_F(DataSrcTest, CnameExt) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 4, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("cname-ext.example.com"), rrset->getName());
     EXPECT_EQ(RRType::CNAME(), rrset->getType());
@@ -700,7 +700,7 @@ TEST_F(DataSrcTest, CnameExt) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("sql1.example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -713,7 +713,7 @@ TEST_F(DataSrcTest, Delegation) {
 
     headerCheck(msg, Rcode::NOERROR(), true, false, true, 0, 5, 2);
 
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("subzone.example.com."), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -725,7 +725,7 @@ TEST_F(DataSrcTest, Delegation) {
     it->next();
     EXPECT_FALSE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("ns1.subzone.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -744,7 +744,7 @@ TEST_F(DataSrcTest, NSDelegation) {
 
     headerCheck(msg, Rcode::NOERROR(), true, false, true, 0, 5, 2);
 
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("subzone.example.com."), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -756,7 +756,7 @@ TEST_F(DataSrcTest, NSDelegation) {
     it->next();
     EXPECT_FALSE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("ns1.subzone.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -782,13 +782,13 @@ TEST_F(DataSrcTest, NSECZonecut) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 2, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("subzone.example.com."), rrset->getName());
     EXPECT_EQ(RRType::NSEC(), rrset->getType());
     EXPECT_EQ(RRClass::IN(), rrset->getClass());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -810,7 +810,7 @@ TEST_F(DataSrcTest, DNAMEZonecut) {
                           RRType::DNAME());
 
     headerCheck(msg, Rcode::NOERROR(), true, false, true, 0, 5, 2);
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("subzone.example.com."), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -822,7 +822,7 @@ TEST_F(DataSrcTest, DNAMEZonecut) {
     it->next();
     EXPECT_FALSE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("ns1.subzone.example.com"), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -841,13 +841,13 @@ TEST_F(DataSrcTest, DS) {
 
     headerCheck(msg, Rcode::NOERROR(), true, true, true, 3, 4, 6);
 
-    RRsetIterator rit = msg.beginSection(Section::ANSWER());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_ANSWER);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("subzone.example.com."), rrset->getName());
     EXPECT_EQ(RRType::DS(), rrset->getType());
     EXPECT_EQ(RRClass::IN(), rrset->getClass());
 
-    rit = msg.beginSection(Section::AUTHORITY());
+    rit = msg.beginSection(Message::SECTION_AUTHORITY);
     rrset = *rit;
     EXPECT_EQ(Name("example.com"), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -872,7 +872,7 @@ TEST_F(DataSrcTest, CNAMELoop) {
     // one.loop.example points to two.loop.example, which points back
     // to one.loop.example, so there should be exactly two CNAME records
     // in the answer.
-    EXPECT_EQ(2, msg.getRRCount(Section::ANSWER()));
+    EXPECT_EQ(2, msg.getRRCount(Message::SECTION_ANSWER));
 }
 
 // NSEC query for the name of a zone cut for non-secure delegation.
@@ -883,7 +883,7 @@ TEST_F(DataSrcTest, NSECZonecutOfNonsecureZone) {
 
     headerCheck(msg, Rcode::NOERROR(), true, false, true, 0, 1, 1);
 
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     ConstRRsetPtr rrset = *rit;
     EXPECT_EQ(Name("sub.example.org."), rrset->getName());
     EXPECT_EQ(RRType::NS(), rrset->getType());
@@ -897,7 +897,7 @@ TEST_F(DataSrcTest, NSECZonecutOfNonsecureZone) {
     it->next();
     EXPECT_TRUE(it->isLast());
 
-    rit = msg.beginSection(Section::ADDITIONAL());
+    rit = msg.beginSection(Message::SECTION_ADDITIONAL);
     rrset = *rit;
     EXPECT_EQ(Name("ns.sub.example.org."), rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
@@ -942,7 +942,7 @@ TEST_F(DataSrcTest, StaticNxDomain) {
     createAndProcessQuery(Name("www.version.bind"), RRClass::CH(),
                           RRType::TXT());
     headerCheck(msg, Rcode::NXDOMAIN(), true, true, true, 0, 1, 0);
-    RRsetIterator rit = msg.beginSection(Section::AUTHORITY());
+    RRsetIterator rit = msg.beginSection(Message::SECTION_AUTHORITY);
     RRsetPtr rrset = *rit;
     EXPECT_EQ(Name("version.bind"), rrset->getName());
     EXPECT_EQ(RRType::SOA(), rrset->getType());

src/lib/datasrc/tests/query_unittest.cc

@@ -38,7 +38,7 @@ createQuery(Message& m, const Name& qname, const RRClass& qclass,
             const RRType& qtype)
 {
     m.setOpcode(Opcode::QUERY());
-    m.setHeaderFlag(MessageFlag::RD());
+    m.setHeaderFlag(Message::HEADERFLAG_RD);
     m.addQuestion(Question(qname, qclass, qtype));
 }
 

src/lib/dns/message.cc

@@ -44,32 +44,42 @@
 
 using namespace std;
 using namespace boost;
-using namespace isc::dns;
 using namespace isc::dns::rdata;
 
 namespace isc {
 namespace dns {
 
 namespace {
-typedef uint16_t flags_t;
-
 // protocol constants
 const size_t HEADERLEN = 12;
 
-const flags_t FLAG_QR = 0x8000;
-const flags_t FLAG_AA = 0x0400;
-const flags_t FLAG_TC = 0x0200;
-const flags_t FLAG_RD = 0x0100;
-const flags_t FLAG_RA = 0x0080;
-const flags_t FLAG_AD = 0x0020;
-const flags_t FLAG_CD = 0x0010;
-
 const unsigned int OPCODE_MASK = 0x7800;
 const unsigned int OPCODE_SHIFT = 11;
 const unsigned int RCODE_MASK = 0x000f;
-const unsigned int FLAG_MASK = 0x8ff0;
 
-const unsigned int MESSAGE_REPLYPRESERVE = (FLAG_RD | FLAG_CD);
+// This diagram shows the wire-format representation of the 2nd 16 bits of
+// the DNS header section, which contain all defined flag bits.
+//
+//    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//    |QR|   Opcode  |AA|TC|RD|RA|  |AD|CD|   RCODE   |
+//    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//      1  0  0  0| 0  1  1  1| 1  0  1  1| 0  0  0  0|
+//         0x8         0x7         0xb         0x0
+//
+// This mask covers all the flag bits, and those bits only.
+// Note: we reject a "flag" the is not covered by this mask in some of the
+// public methods.  This means our current definition is not fully extendable;
+// applications cannot introduce a new flag bit temporarily without modifying
+// the source code.
+const unsigned int HEADERFLAG_MASK = 0x87b0;
+
+// This is a set of flag bits that should be preserved when building a reply
+// from a request.
+// Note: we assume the specific definition of HEADERFLAG_xx.  We may change
+// the definition in future, in which case we need to adjust this definition,
+// too (see also the description about the Message::HeaderFlag type).
+const uint16_t MESSAGE_REPLYPRESERVE = (Message::HEADERFLAG_RD |
+                                        Message::HEADERFLAG_CD);
 
 const char *sectiontext[] = {
     "QUESTION",
@@ -79,15 +89,6 @@ const char *sectiontext[] = {
 };
 }
 
-namespace {
-inline unsigned int
-sectionCodeToId(const Section& section) {
-    unsigned int code = section.getCode();
-    assert(code > 0);
-    return (section.getCode() - 1);
-}
-}
-
 class MessageImpl {
 public:
     MessageImpl(Message::Mode mode);
@@ -105,13 +106,13 @@ public:
     const Opcode* opcode_;
     Opcode opcode_placeholder_;
 
-    flags_t flags_;
+    uint16_t flags_;            // wire-format representation of header flags.
 
     bool header_parsed_;
-    static const unsigned int SECTION_MAX = 4; // TODO: revisit this design
-    int counts_[SECTION_MAX];   // TODO: revisit this definition
+    static const unsigned int NUM_SECTIONS = 4; // TODO: revisit this design
+    int counts_[NUM_SECTIONS];   // TODO: revisit this definition
     vector<QuestionPtr> questions_;
-    vector<RRsetPtr> rrsets_[SECTION_MAX];
+    vector<RRsetPtr> rrsets_[NUM_SECTIONS];
     ConstEDNSPtr edns_;
 
 #ifdef notyet
@@ -123,7 +124,7 @@ public:
     void setOpcode(const Opcode& opcode);
     void setRcode(const Rcode& rcode);
     int parseQuestion(InputBuffer& buffer);
-    int parseSection(const Section& section, InputBuffer& buffer);
+    int parseSection(const Message::Section section, InputBuffer& buffer);
 };
 
 MessageImpl::MessageImpl(Message::Mode mode) :
@@ -142,15 +143,15 @@ MessageImpl::init() {
     opcode_ = NULL;
     edns_ = EDNSPtr();
 
-    for (int i = 0; i < SECTION_MAX; ++i) {
+    for (int i = 0; i < NUM_SECTIONS; ++i) {
         counts_[i] = 0;
     }
 
     header_parsed_ = false;
     questions_.clear();
-    rrsets_[sectionCodeToId(Section::ANSWER())].clear();
-    rrsets_[sectionCodeToId(Section::AUTHORITY())].clear();
-    rrsets_[sectionCodeToId(Section::ADDITIONAL())].clear();
+    rrsets_[Message::SECTION_ANSWER].clear();
+    rrsets_[Message::SECTION_AUTHORITY].clear();
+    rrsets_[Message::SECTION_ADDITIONAL].clear();
 }
 
 void
@@ -174,26 +175,31 @@ Message::~Message() {
 }
 
 bool
-Message::getHeaderFlag(const MessageFlag& flag) const {
-    return ((impl_->flags_ & flag.getBit()) != 0);
+Message::getHeaderFlag(const HeaderFlag flag) const {
+    if (flag == 0 || (flag & ~HEADERFLAG_MASK) != 0) {
+        isc_throw(InvalidParameter,
+                  "Message::getHeaderFlag:: Invalid flag is specified: " <<
+                  flag);
+    }
+    return ((impl_->flags_ & flag) != 0);
 }
 
 void
-Message::setHeaderFlag(const MessageFlag& flag) {
+Message::setHeaderFlag(const HeaderFlag flag, const bool on) {
     if (impl_->mode_ != Message::RENDER) {
         isc_throw(InvalidMessageOperation,
                   "setHeaderFlag performed in non-render mode");
     }
-    impl_->flags_ |= flag.getBit();
-}
-
-void
-Message::clearHeaderFlag(const MessageFlag& flag) {
-    if (impl_->mode_ != Message::RENDER) {
-        isc_throw(InvalidMessageOperation,
-                  "clearHeaderFlag performed in non-render mode");
+    if (flag == 0 || (flag & ~HEADERFLAG_MASK) != 0) {
+        isc_throw(InvalidParameter,
+                  "Message::getHeaderFlag:: Invalid flag is specified: " <<
+                  flag);
+    }
+    if (on) {
+        impl_->flags_ |= flag;
+    } else {
+        impl_->flags_ &= ~flag;
     }
-    impl_->flags_ &= ~flag.getBit();
 }
 
 qid_t
@@ -259,35 +265,46 @@ Message::setEDNS(ConstEDNSPtr edns) {
 }
 
 unsigned int
-Message::getRRCount(const Section& section) const {
-    return (impl_->counts_[section.getCode()]);
+Message::getRRCount(const Section section) const {
+    if (section >= MessageImpl::NUM_SECTIONS) {
+        isc_throw(OutOfRange, "Invalid message section: " << section);
+    }
+    return (impl_->counts_[section]);
 }
 
 void
-Message::addRRset(const Section& section, RRsetPtr rrset, const bool sign) {
+Message::addRRset(const Section section, RRsetPtr rrset, const bool sign) {
     if (impl_->mode_ != Message::RENDER) {
         isc_throw(InvalidMessageOperation,
                   "addRRset performed in non-render mode");
     }
+    if (section >= MessageImpl::NUM_SECTIONS) {
+        isc_throw(OutOfRange, "Invalid message section: " << section);
+    }
 
-    impl_->rrsets_[sectionCodeToId(section)].push_back(rrset);
-    impl_->counts_[section.getCode()] += rrset->getRdataCount();
+    impl_->rrsets_[section].push_back(rrset);
+    impl_->counts_[section] += rrset->getRdataCount();
 
     RRsetPtr sp = rrset->getRRsig();
     if (sign && sp != NULL) {
-        impl_->rrsets_[sectionCodeToId(section)].push_back(sp);
-        impl_->counts_[section.getCode()] += sp->getRdataCount();
+        impl_->rrsets_[section].push_back(sp);
+        impl_->counts_[section] += sp->getRdataCount();
     }
 }
 
 bool
-Message::hasRRset(const Section& section, RRsetPtr rrset) {
-    BOOST_FOREACH(RRsetPtr r, impl_->rrsets_[sectionCodeToId(section)]) {
-        if (r->getType() == rrset->getType() &&
-            r->getName() == rrset->getName())
-        {
-            return (true);
+Message::hasRRset(const Section section, const Name& name,
+                  const RRClass& rrclass, const RRType& rrtype)
+{
+    if (section >= MessageImpl::NUM_SECTIONS) {
+        isc_throw(OutOfRange, "Invalid message section: " << section);
+    }
 
+    BOOST_FOREACH(ConstRRsetPtr r, impl_->rrsets_[section]) {
+        if (r->getClass() == rrclass &&
+            r->getType() == rrtype &&
+            r->getName() == name) {
+            return (true);
         }
     }
 
@@ -302,7 +319,7 @@ Message::addQuestion(const QuestionPtr question) {
     }
 
     impl_->questions_.push_back(question);
-    ++impl_->counts_[Section::QUESTION().getCode()];
+    ++impl_->counts_[SECTION_QUESTION];
 }
 
 void
@@ -366,24 +383,24 @@ Message::toWire(MessageRenderer& renderer) {
     uint16_t ancount = 0;
     if (!renderer.isTruncated()) {
         ancount =
-            for_each(impl_->rrsets_[sectionCodeToId(Section::ANSWER())].begin(),
-                     impl_->rrsets_[sectionCodeToId(Section::ANSWER())].end(),
+            for_each(impl_->rrsets_[SECTION_ANSWER].begin(),
+                     impl_->rrsets_[SECTION_ANSWER].end(),
                      RenderSection<RRsetPtr>(renderer, true)).getTotalCount();
     }
     uint16_t nscount = 0;
     if (!renderer.isTruncated()) {
         nscount =
-            for_each(impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].begin(),
-                     impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].end(),
+            for_each(impl_->rrsets_[SECTION_AUTHORITY].begin(),
+                     impl_->rrsets_[SECTION_AUTHORITY].end(),
                      RenderSection<RRsetPtr>(renderer, true)).getTotalCount();
     }
     uint16_t arcount = 0;
     if (renderer.isTruncated()) {
-        setHeaderFlag(MessageFlag::TC());
+        setHeaderFlag(HEADERFLAG_TC, true);
     } else {
         arcount =
-            for_each(impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].begin(),
-                     impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].end(),
+            for_each(impl_->rrsets_[SECTION_ADDITIONAL].begin(),
+                     impl_->rrsets_[SECTION_ADDITIONAL].end(),
                      RenderSection<RRsetPtr>(renderer, false)).getTotalCount();
     }
 
@@ -406,10 +423,10 @@ Message::toWire(MessageRenderer& renderer) {
     // in rrsets_[] or questions_ if truncation occurred or an EDNS OPT RR
     // was inserted.  This is not good, and we should revisit the entire
     // design.
-    impl_->counts_[Section::QUESTION().getCode()] = qdcount;
-    impl_->counts_[Section::ANSWER().getCode()] = ancount;
-    impl_->counts_[Section::AUTHORITY().getCode()] = nscount;
-    impl_->counts_[Section::ADDITIONAL().getCode()] = arcount;
+    impl_->counts_[SECTION_QUESTION] = qdcount;
+    impl_->counts_[SECTION_ANSWER] = ancount;
+    impl_->counts_[SECTION_AUTHORITY] = nscount;
+    impl_->counts_[SECTION_ADDITIONAL] = arcount;
 
     // TBD: TSIG, SIG(0) etc.
 
@@ -421,7 +438,7 @@ Message::toWire(MessageRenderer& renderer) {
     uint16_t codes_and_flags =
         (impl_->opcode_->getCode() << OPCODE_SHIFT) & OPCODE_MASK;
     codes_and_flags |= (impl_->rcode_->getCode() & RCODE_MASK);
-    codes_and_flags |= (impl_->flags_ & FLAG_MASK);
+    codes_and_flags |= (impl_->flags_ & HEADERFLAG_MASK);
     renderer.writeUint16At(codes_and_flags, header_pos);
     header_pos += sizeof(uint16_t);
     // XXX: should avoid repeated pattern (TODO)
@@ -451,11 +468,11 @@ Message::parseHeader(InputBuffer& buffer) {
     const uint16_t codes_and_flags = buffer.readUint16();
     impl_->setOpcode(Opcode((codes_and_flags & OPCODE_MASK) >> OPCODE_SHIFT));
     impl_->setRcode(Rcode(codes_and_flags & RCODE_MASK));
-    impl_->flags_ = (codes_and_flags & FLAG_MASK);
-    impl_->counts_[Section::QUESTION().getCode()] = buffer.readUint16();
-    impl_->counts_[Section::ANSWER().getCode()] = buffer.readUint16();
-    impl_->counts_[Section::AUTHORITY().getCode()] = buffer.readUint16();
-    impl_->counts_[Section::ADDITIONAL().getCode()] = buffer.readUint16();
+    impl_->flags_ = (codes_and_flags & HEADERFLAG_MASK);
+    impl_->counts_[SECTION_QUESTION] = buffer.readUint16();
+    impl_->counts_[SECTION_ANSWER] = buffer.readUint16();
+    impl_->counts_[SECTION_AUTHORITY] = buffer.readUint16();
+    impl_->counts_[SECTION_ADDITIONAL] = buffer.readUint16();
 
     impl_->header_parsed_ = true;
 }
@@ -471,14 +488,13 @@ Message::fromWire(InputBuffer& buffer) {
         parseHeader(buffer);
     }
 
-    impl_->counts_[Section::QUESTION().getCode()] =
-        impl_->parseQuestion(buffer);
-    impl_->counts_[Section::ANSWER().getCode()] =
-        impl_->parseSection(Section::ANSWER(), buffer);
-    impl_->counts_[Section::AUTHORITY().getCode()] =
-        impl_->parseSection(Section::AUTHORITY(), buffer);
-    impl_->counts_[Section::ADDITIONAL().getCode()] =
-        impl_->parseSection(Section::ADDITIONAL(), buffer);
+    impl_->counts_[SECTION_QUESTION] = impl_->parseQuestion(buffer);
+    impl_->counts_[SECTION_ANSWER] =
+        impl_->parseSection(SECTION_ANSWER, buffer);
+    impl_->counts_[SECTION_AUTHORITY] =
+        impl_->parseSection(SECTION_AUTHORITY, buffer);
+    impl_->counts_[SECTION_ADDITIONAL] =
+        impl_->parseSection(SECTION_ADDITIONAL, buffer);
 }
 
 int
@@ -486,7 +502,7 @@ MessageImpl::parseQuestion(InputBuffer& buffer) {
     unsigned int added = 0;
 
     for (unsigned int count = 0;
-         count < counts_[Section::QUESTION().getCode()];
+         count < counts_[Message::SECTION_QUESTION];
          ++count) {
         const Name name(buffer);
 
@@ -498,9 +514,9 @@ MessageImpl::parseQuestion(InputBuffer& buffer) {
         const RRType rrtype(buffer.readUint16());
         const RRClass rrclass(buffer.readUint16());
 
-        // XXX: need a duplicate check.  We might also want to have an optimized
-        // algorithm that requires the question section contain exactly one
-        // RR.
+        // XXX: need a duplicate check.  We might also want to have an
+        // optimized algorithm that requires the question section contain
+        // exactly one RR.
 
         questions_.push_back(QuestionPtr(new Question(name, rrclass, rrtype)));
         ++added;
@@ -553,16 +569,20 @@ struct MatchRR : public unary_function<RRsetPtr, bool> {
 // logic to that class; processing logic dependent on parse context
 // is hardcoded here.
 int
-MessageImpl::parseSection(const Section& section, InputBuffer& buffer) {
+MessageImpl::parseSection(const Message::Section section,
+                          InputBuffer& buffer)
+{
+    assert(section < MessageImpl::NUM_SECTIONS);
+
     unsigned int added = 0;
 
-    for (unsigned int count = 0; count < counts_[section.getCode()]; ++count) {
+    for (unsigned int count = 0; count < counts_[section]; ++count) {
         const Name name(buffer);
 
         // buffer must store at least RR TYPE, RR CLASS, TTL, and RDLEN.
         if ((buffer.getLength() - buffer.getPosition()) <
             3 * sizeof(uint16_t) + sizeof(uint32_t)) {
-            isc_throw(DNSMessageFORMERR, sectiontext[section.getCode()] <<
+            isc_throw(DNSMessageFORMERR, sectiontext[section] <<
                       " section too short: " <<
                       (buffer.getLength() - buffer.getPosition()) << " bytes");
         }
@@ -574,7 +594,7 @@ MessageImpl::parseSection(const Section& section, InputBuffer& buffer) {
         ConstRdataPtr rdata = createRdata(rrtype, rrclass, buffer, rdlen);
 
         if (rrtype == RRType::OPT()) {
-            if (section != Section::ADDITIONAL()) {
+            if (section != Message::SECTION_ADDITIONAL) {
                 isc_throw(DNSMessageFORMERR,
                           "EDNS OPT RR found in an invalid section");
             }
@@ -589,17 +609,16 @@ MessageImpl::parseSection(const Section& section, InputBuffer& buffer) {
             continue;
         } else {
             vector<RRsetPtr>::iterator it =
-                find_if(rrsets_[sectionCodeToId(section)].begin(),
-                        rrsets_[sectionCodeToId(section)].end(),
+                find_if(rrsets_[section].begin(), rrsets_[section].end(),
                         MatchRR(name, rrtype, rrclass));
-            if (it != rrsets_[sectionCodeToId(section)].end()) {
+            if (it != rrsets_[section].end()) {
                 (*it)->setTTL(min((*it)->getTTL(), ttl));
                 (*it)->addRdata(rdata);
             } else {
                 RRsetPtr rrset =
                     RRsetPtr(new RRset(name, rrclass, rrtype, ttl)); 
                 rrset->addRdata(rdata);
-                rrsets_[sectionCodeToId(section)].push_back(rrset);
+                rrsets_[section].push_back(rrset);
             }
             ++added;
         }
@@ -611,15 +630,15 @@ MessageImpl::parseSection(const Section& section, InputBuffer& buffer) {
 namespace {
 template <typename T>
 struct SectionFormatter {
-    SectionFormatter(const Section& section, string& output) :
+    SectionFormatter(const Message::Section section, string& output) :
         section_(section), output_(output) {}
     void operator()(const T& entry) {
-        if (section_ == Section::QUESTION()) {
+        if (section_ == Message::SECTION_QUESTION) {
             output_ += ";";
         }
         output_ += entry->toText();
     }
-    const Section& section_;
+    const Message::Section section_;
     string& output_;
 };
 }
@@ -642,30 +661,37 @@ Message::toText() const {
     s += ", status: " + impl_->rcode_->toText();
     s += ", id: " + boost::lexical_cast<string>(impl_->qid_);
     s += "\n;; flags: ";
-    if (getHeaderFlag(MessageFlag::QR()))
+    if (getHeaderFlag(HEADERFLAG_QR)) {
         s += "qr ";
-    if (getHeaderFlag(MessageFlag::AA()))
+    }
+    if (getHeaderFlag(HEADERFLAG_AA)) {
         s += "aa ";
-    if (getHeaderFlag(MessageFlag::TC()))
+    }
+    if (getHeaderFlag(HEADERFLAG_TC)) {
         s += "tc ";
-    if (getHeaderFlag(MessageFlag::RD()))
+    }
+    if (getHeaderFlag(HEADERFLAG_RD)) {
         s += "rd ";
-    if (getHeaderFlag(MessageFlag::RA()))
+    }
+    if (getHeaderFlag(HEADERFLAG_RA)) {
         s += "ra ";
-    if (getHeaderFlag(MessageFlag::AD()))
+    }
+    if (getHeaderFlag(HEADERFLAG_AD)) {
         s += "ad ";
-    if (getHeaderFlag(MessageFlag::CD()))
+    }
+    if (getHeaderFlag(HEADERFLAG_CD)) {
         s += "cd ";
+    }
 
     // for simplicity, don't consider the update case for now
     s += "; QUESTION: " +
-        lexical_cast<string>(impl_->counts_[Section::QUESTION().getCode()]);
+        lexical_cast<string>(impl_->counts_[SECTION_QUESTION]);
     s += ", ANSWER: " +
-        lexical_cast<string>(impl_->counts_[Section::ANSWER().getCode()]);
+        lexical_cast<string>(impl_->counts_[SECTION_ANSWER]);
     s += ", AUTHORITY: " +
-        lexical_cast<string>(impl_->counts_[Section::AUTHORITY().getCode()]);
+        lexical_cast<string>(impl_->counts_[SECTION_AUTHORITY]);
 
-    unsigned int arcount = impl_->counts_[Section::ADDITIONAL().getCode()];
+    unsigned int arcount = impl_->counts_[SECTION_ADDITIONAL];
     if (impl_->edns_ != NULL) {
         ++arcount;
     }
@@ -678,31 +704,31 @@ Message::toText() const {
 
     if (!impl_->questions_.empty()) {
         s += "\n;; " +
-            string(sectiontext[Section::QUESTION().getCode()]) + " SECTION:\n";
+            string(sectiontext[SECTION_QUESTION]) + " SECTION:\n";
         for_each(impl_->questions_.begin(), impl_->questions_.end(),
-                 SectionFormatter<QuestionPtr>(Section::QUESTION(), s));
+                 SectionFormatter<QuestionPtr>(SECTION_QUESTION, s));
     }
-    if (!impl_->rrsets_[sectionCodeToId(Section::ANSWER())].empty()) {
+    if (!impl_->rrsets_[SECTION_ANSWER].empty()) {
         s += "\n;; " +
-            string(sectiontext[Section::ANSWER().getCode()]) + " SECTION:\n";
-        for_each(impl_->rrsets_[sectionCodeToId(Section::ANSWER())].begin(),
-                 impl_->rrsets_[sectionCodeToId(Section::ANSWER())].end(),
-                 SectionFormatter<RRsetPtr>(Section::ANSWER(), s));
+            string(sectiontext[SECTION_ANSWER]) + " SECTION:\n";
+        for_each(impl_->rrsets_[SECTION_ANSWER].begin(),
+                 impl_->rrsets_[SECTION_ANSWER].end(),
+                 SectionFormatter<RRsetPtr>(SECTION_ANSWER, s));
     }
-    if (!impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].empty()) {
+    if (!impl_->rrsets_[SECTION_AUTHORITY].empty()) {
         s += "\n;; " +
-            string(sectiontext[Section::AUTHORITY().getCode()]) + " SECTION:\n";
-        for_each(impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].begin(),
-                 impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].end(),
-                 SectionFormatter<RRsetPtr>(Section::AUTHORITY(), s));
+            string(sectiontext[SECTION_AUTHORITY]) + " SECTION:\n";
+        for_each(impl_->rrsets_[SECTION_AUTHORITY].begin(),
+                 impl_->rrsets_[SECTION_AUTHORITY].end(),
+                 SectionFormatter<RRsetPtr>(SECTION_AUTHORITY, s));
     }
-    if (!impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].empty()) {
+    if (!impl_->rrsets_[SECTION_ADDITIONAL].empty()) {
         s += "\n;; " +
-            string(sectiontext[Section::ADDITIONAL().getCode()]) +
+            string(sectiontext[SECTION_ADDITIONAL]) +
             " SECTION:\n";
-        for_each(impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].begin(),
-                 impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].end(),
-                 SectionFormatter<RRsetPtr>(Section::ADDITIONAL(), s));
+        for_each(impl_->rrsets_[SECTION_ADDITIONAL].begin(),
+                 impl_->rrsets_[SECTION_ADDITIONAL].end(),
+                 SectionFormatter<RRsetPtr>(SECTION_ADDITIONAL, s));
     }
 
     return (s);
@@ -725,14 +751,14 @@ Message::makeResponse() {
 
     impl_->edns_ = EDNSPtr();
     impl_->flags_ &= MESSAGE_REPLYPRESERVE;
-    setHeaderFlag(MessageFlag::QR());
+    setHeaderFlag(HEADERFLAG_QR, true);
 
-    impl_->rrsets_[sectionCodeToId(Section::ANSWER())].clear();
-    impl_->counts_[Section::ANSWER().getCode()] = 0;
-    impl_->rrsets_[sectionCodeToId(Section::AUTHORITY())].clear();
-    impl_->counts_[Section::AUTHORITY().getCode()] = 0;
-    impl_->rrsets_[sectionCodeToId(Section::ADDITIONAL())].clear();
-    impl_->counts_[Section::ADDITIONAL().getCode()] = 0;
+    impl_->rrsets_[SECTION_ANSWER].clear();
+    impl_->counts_[SECTION_ANSWER] = 0;
+    impl_->rrsets_[SECTION_AUTHORITY].clear();
+    impl_->counts_[SECTION_AUTHORITY] = 0;
+    impl_->rrsets_[SECTION_ADDITIONAL].clear();
+    impl_->counts_[SECTION_ADDITIONAL] = 0;
 }
 
 ///
@@ -840,33 +866,34 @@ Message::endQuestion() const {
 /// RRsets iterators
 ///
 const SectionIterator<RRsetPtr>
-Message::beginSection(const Section& section) const {
-    if (section == Section::QUESTION()) {
+Message::beginSection(const Section section) const {
+    if (section >= MessageImpl::NUM_SECTIONS) {
+        isc_throw(OutOfRange, "Invalid message section: " << section);
+    }
+    if (section == SECTION_QUESTION) {
         isc_throw(InvalidMessageSection,
                   "RRset iterator is requested for question");
     }
 
-    return (RRsetIterator(
-                RRsetIteratorImpl(
-                    impl_->rrsets_[sectionCodeToId(section)].begin())));
+    return (RRsetIterator(RRsetIteratorImpl(impl_->rrsets_[section].begin())));
 }
 
 const SectionIterator<RRsetPtr>
-Message::endSection(const Section& section) const {
-    if (section == Section::QUESTION()) {
+Message::endSection(const Section section) const {
+    if (section >= MessageImpl::NUM_SECTIONS) {
+        isc_throw(OutOfRange, "Invalid message section: " << section);
+    }
+    if (section == SECTION_QUESTION) {
         isc_throw(InvalidMessageSection,
                   "RRset iterator is requested for question");
     }
 
-    return (RRsetIterator(
-                RRsetIteratorImpl(
-                    impl_->rrsets_[sectionCodeToId(section)].end())));
+    return (RRsetIterator(RRsetIteratorImpl(impl_->rrsets_[section].end())));
 }
 
 ostream&
 operator<<(ostream& os, const Message& message) {
     return (os << message.toText());
 }
-
 } // end of namespace dns
 } // end of namespace isc

src/lib/dns/message.h

@@ -88,133 +88,6 @@ class Rcode;
 template <typename T>
 struct SectionIteratorImpl;
 
-/// \brief The \c MessageFlag class objects represent standard flag bits
-/// of the header section of DNS messages.
-///
-/// Constant objects are defined for standard flags.
-class MessageFlag {
-public:
-    /// \brief Returns the corresponding bit of the MessageFlag.
-    ///
-    /// Note: this value is intended to be used for rendering or parsing
-    /// low level wire-format data.  Applications should use abstract
-    /// interfaces.  This also means the interface is not well sophisticated,
-    /// and we should revisit the design.
-    uint16_t getBit() const { return (flagbit_); }
-    static const MessageFlag& QR();
-    static const MessageFlag& AA();
-    static const MessageFlag& TC();
-    static const MessageFlag& RD();
-    static const MessageFlag& RA();
-    static const MessageFlag& AD();
-    static const MessageFlag& CD();
-private:
-    MessageFlag(uint16_t flagbit) : flagbit_(flagbit) {}
-    uint16_t flagbit_;
-};
-
-inline const MessageFlag&
-MessageFlag::QR() {
-    static MessageFlag f(0x8000);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::AA() {
-    static MessageFlag f(0x0400);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::TC() {
-    static MessageFlag f(0x0200);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::RD() {
-    static MessageFlag f(0x0100);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::RA() {
-    static MessageFlag f(0x0080);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::AD() {
-    static MessageFlag f(0x0020);
-    return (f);
-}
-
-inline const MessageFlag&
-MessageFlag::CD() {
-    static MessageFlag f(0x0010);
-    return (f);
-}
-
-/// \brief The \c Section class objects represent DNS message sections such
-/// as the header, question, or answer.
-///
-/// Note: this class doesn't seem to be very useful.  We should probably
-/// revisit this design.
-///
-/// Note: whether or not it's represented as a class, we'll need a way
-/// to represent more advanced sections such as those used in dynamic updates.
-/// This is a TODO item.
-///
-/// Constant objects are defined for standard flags.
-class Section {
-public:
-    /// \brief Returns the relative position of the \c Section in DNS messages.
-    unsigned int getCode() const { return (code_); }
-    bool operator==(const Section& other) const
-        { return (code_ == other.code_); }
-    bool operator!=(const Section& other) const
-        { return (code_ != other.code_); }
-
-    static const Section& QUESTION();
-    static const Section& ANSWER();
-    static const Section& AUTHORITY();
-    static const Section& ADDITIONAL();
-private:
-    enum {
-        SECTION_QUESTION = 0,
-        SECTION_ANSWER = 1,
-        SECTION_AUTHORITY = 2,
-        SECTION_ADDITIONAL = 3
-    };
-
-    Section(int code) : code_(code) {}
-    unsigned int code_;
-};
-
-inline const Section&
-Section::QUESTION() {
-    static Section s(SECTION_QUESTION);
-    return (s);
-}
-
-inline const Section&
-Section::ANSWER() {
-    static Section s(SECTION_ANSWER);
-    return (s);
-}
-
-inline const Section&
-Section::AUTHORITY() {
-    static Section s(SECTION_AUTHORITY);
-    return (s);
-}
-
-inline const Section&
-Section::ADDITIONAL() {
-    static Section s(SECTION_ADDITIONAL);
-    return (s);
-}
-
 /// \c SectionIterator is a templated class to provide standard-compatible
 /// iterators for Questions and RRsets for a given DNS message section.
 /// The template parameter is either \c QuestionPtr (for the question section)
@@ -274,19 +147,109 @@ typedef SectionIterator<RRsetPtr> RRsetIterator;
 ///   of RR in the message.
 class Message {
 public:
+    /// Constants to specify the operation mode of the \c Message.
     enum Mode {
-        PARSE = 0,
-        RENDER = 1
+        PARSE = 0,              ///< Parse mode (handling an incoming message)
+        RENDER = 1              ///< Render mode (building an outgoing message)
+    };
+
+    /// \brief Constants for flag bit fields of a DNS message header.
+    ///
+    /// Only the defined constants are valid where a header flag is required
+    /// in this library (e.g., in \c Message::setHeaderFlag()).
+    /// Since these are enum constants, however, invalid value could be passed
+    /// via casting without an error at compilation time.
+    /// It is generally the callee's responsibility to check and reject invalid
+    /// values.
+    /// Of course, applications shouldn't pass invalid values even if the
+    /// callee does not perform proper validation; the result in such usage
+    /// is undefined.
+    ///
+    /// In the current implementation, the defined values happen to be
+    /// a 16-bit integer with one bit being set corresponding to the
+    /// specified flag in the second 16 bits of the DNS Header section
+    /// in order to make the internal implementation simpler.
+    /// For example, \c HEADERFLAG_QR is defined to be 0x8000 as the QR
+    /// bit is the most significant bit of the 2nd 16 bits of the header.
+    /// However, applications should not assume this coincidence and
+    /// must solely use the enum representations.
+    /// Any usage based on the assumption of the underlying values is invalid
+    /// and the result is undefined.
+    ///
+    /// Likewise, bit wise operations such as AND or OR on the flag values
+    /// are invalid and are not guaranteed to work, even if it could compile
+    /// with casting.
+    /// For example, the following code will compile:
+    /// \code const uint16_t combined_flags =
+    ///           static_cast<uint16_t>(Message::HEADERFLAG_AA) |
+    ///           static_cast<uint16_t>(Message::HEADERFLAG_CD);
+    /// message->setHeaderFlag(static_cast<Message::HeaderFlag>(combined_flags));
+    /// \endcode
+    /// and (with the current definition) happens to work as if it were
+    /// validly written as follows:
+    /// \code message->setHeaderFlag(Message::HEADERFLAG_AA);
+    /// message->setHeaderFlag(Message::HEADERFLAG_CD);
+    /// \endcode
+    /// But the former notation is invalid and may not work in future versions.
+    /// We did not try to prohibit such usage at compilation time, e.g., by
+    /// introducing a separately defined class considering the balance
+    /// between the complexity and advantage, but hopefully the cast notation
+    /// is sufficiently ugly to prevent proliferation of the usage.
+    enum HeaderFlag {
+        HEADERFLAG_QR = 0x8000, ///< Query (if cleared) or response (if set)
+        HEADERFLAG_AA = 0x0400, ///< Authoritative answer
+        HEADERFLAG_TC = 0x0200, ///< Truncation
+        HEADERFLAG_RD = 0x0100, ///< Recursion desired
+        HEADERFLAG_RA = 0x0080, ///< Recursion available
+        HEADERFLAG_AD = 0x0020, ///< DNSSEC checking disabled (RFC4035)
+        HEADERFLAG_CD = 0x0010  ///< Authentic %data (RFC4035)
+    };
+
+    /// \brief Constants to specify sections of a DNS message.
+    ///
+    /// The sections are those defined in RFC 1035 excluding the Header
+    /// section; the fields of the Header section are accessed via specific
+    /// methods of the \c Message class (e.g., \c getQid()).
+    ///
+    /// <b>Open Design Issue:</b>
+    /// In the current implementation the values for the constants are
+    /// sorted in the order of appearance in DNS messages, i.e.,
+    /// from %Question to Additional.
+    /// So, for example,
+    /// code <code>section >= Message::SECTION_AUTHORITY</code> can be
+    /// used to do something in or after the Authority section.
+    /// This would be convenient, but it is not clear if it's really a good
+    /// idea to rely on relationship between the underlying values of enum
+    /// constants.  At the moment, applications are discouraged to rely on
+    /// this implementation detail.  We will see if such usage is sufficiently
+    /// common to officially support it.
+    ///
+    /// Note also that since we don't define \c operator++ for this enum,
+    /// the following code intending to iterate over all sections will
+    /// \b not compile:
+    /// \code for (Section s; s <= SECTION_ADDITIONAL; ++s) { // ++s undefined
+    ///     // do something
+    /// } \endcode
+    /// This is intentional at this moment, and we'll see if we need to allow
+    /// that as we have more experiences with this library.
+    ///
+    /// <b>Future Extension:</b> We'll probably also define constants for
+    /// the section names used in dynamic updates in future versions.
+    enum Section {
+        SECTION_QUESTION = 0,   ///< %Question section
+        SECTION_ANSWER = 1,     ///< Answer section
+        SECTION_AUTHORITY = 2,  ///< Authority section
+        SECTION_ADDITIONAL = 3  ///< Additional section
     };
 
     ///
     /// \name Constructors and Destructor
     ///
-    /// Note: The copy constructor and the assignment operator are intentionally
-    /// defined as private.  The intended use case wouldn't require copies of
-    /// a \c Message object; once created, it would normally be expected to
-    /// be reused, changing the mode from \c PARSE to \c RENDER, and vice
-    /// versa.
+    /// Note: The copy constructor and the assignment operator are
+    /// intentionally defined as private.
+    /// The intended use case wouldn't require copies of a \c Message object;
+    /// once created, it would normally be expected to be reused, changing the
+    /// mode from \c PARSE to \c RENDER, and vice versa.
     //@{
 public:
     /// \brief The constructor.
@@ -301,26 +264,51 @@ private:
 public:
     /// \brief Return whether the specified header flag bit is set in the
     /// header section.
-    bool getHeaderFlag(const MessageFlag& flag) const;
-
-    /// \brief Set the specified header flag bit is set in the header section.
     ///
-    /// Only allowed in the \c RENDER mode.
-    void setHeaderFlag(const MessageFlag& flag);
+    /// This method is basically exception free, but if
+    /// \c flag is not a valid constant of the \c HeaderFlag type,
+    /// an exception of class \c InvalidParameter will be thrown.
+    ///
+    /// \param flag The header flag constant to test.
+    /// \return \c true if the specified flag is set; otherwise \c false.
+    bool getHeaderFlag(const HeaderFlag flag) const;
 
-    /// \brief Clear the specified header flag bit is set in the header section.
+    /// \brief Set or clear the specified header flag bit in the header
+    /// section.
+    ///
+    /// The optional parameter \c on indicates the operation mode,
+    /// set or clear; if it's \c true the corresponding flag will be set;
+    /// otherwise the flag will be cleared.
+    /// In either case the original state of the flag does not affect the
+    /// operation; for example, if a flag is already set and the "set"
+    /// operation is attempted, it effectively results in no operation.
+    ///
+    /// The parameter \c on can be omitted, in which case a value of \c true
+    /// (i.e., set operation) will be assumed.
+    /// This is based on the observation that the flag would have to be set
+    /// in the vast majority of the cases where an application needs to
+    /// use this method.
+    ///
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     ///
-    /// Only allowed in the \c RENDER mode.
-    /// Note: it may make more sense to integrate this method into \c
-    /// \c setHeaderFlag() with an additional argument.
-    void clearHeaderFlag(const MessageFlag& flag);
+    /// If \c flag is not a valid constant of the \c HeaderFlag type,
+    /// an exception of class \c InvalidParameter will be thrown.
+    ///
+    /// \param flag The header flag constant to set or clear.
+    /// \param on If \c true the flag will be set; otherwise the flag will be
+    /// cleared.
+    void setHeaderFlag(const HeaderFlag flag, const bool on = true);
 
     /// \brief Return the query ID given in the header section of the message.
     qid_t getQid() const;
 
     /// \brief Set the query ID of the header section of the message.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     void setQid(qid_t qid);
 
     /// \brief Return the Response Code of the message.
@@ -338,7 +326,9 @@ public:
 
     /// \brief Set the Response Code of the message.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     ///
     /// If the specified code is an EDNS extended RCODE, an EDNS OPT RR will be
     /// included in the message.
@@ -354,7 +344,9 @@ public:
 
     /// \brief Set the OPCODE of the header section of the message.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     void setOpcode(const Opcode& opcode);
 
     /// \brief Return, if any, the EDNS associated with the message.
@@ -367,15 +359,38 @@ public:
 
     /// \brief Set EDNS for the message.
     ///
-    /// Only allowed in the \c RENDER mode; otherwise an exception of class
-    /// \c InvalidMessageOperation will be thrown.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     ///
     /// \param edns A shared pointer to an \c EDNS object to be set in
     /// \c Message.
     void setEDNS(ConstEDNSPtr edns);
 
     /// \brief Returns the number of RRs contained in the given section.
-    unsigned int getRRCount(const Section& section) const;
+    ///
+    /// In the \c PARSE mode, the returned value may not be identical to
+    /// the actual number of RRs of the incoming message that is parsed.
+    /// The \c Message class handles some "meta" RRs such as EDNS OPT RR
+    /// separately.  This method doesn't include such RRs.
+    /// Also, a future version of the parser will detect and unify duplicate
+    /// RRs (which should be rare in practice though), in which case
+    /// the stored RRs in the \c Message object will be fewer than the RRs
+    /// originally contained in the incoming message.
+    ///
+    /// Likewise, in the \c RENDER mode, even if \c EDNS is set in the
+    /// \c Message, this method doesn't count the corresponding OPT RR
+    /// in the Additional section.
+    ///
+    /// This method is basically exception free, but if
+    /// \c section is not a valid constant of the \c Section type,
+    /// an exception of class \c OutOfRange will be thrown.
+    ///
+    /// \param section The section in the message where RRs should be
+    /// counted.
+    /// \return The number of RRs stored in the specified section of the
+    /// message.
+    unsigned int getRRCount(const Section section) const;
 
     /// \brief Return an iterator corresponding to the beginning of the
     /// Question section of the message.
@@ -387,15 +402,23 @@ public:
 
     /// \brief Return an iterator corresponding to the beginning of the
     /// given section (other than Question) of the message.
-    const RRsetIterator beginSection(const Section& section) const;
+    ///
+    /// \c section must be a valid constant of the \c Section type;
+    /// otherwise, an exception of class \c OutOfRange will be thrown.
+    const RRsetIterator beginSection(const Section section) const;
 
     /// \brief Return an iterator corresponding to the end of the
     /// given section (other than Question) of the message.
-    const RRsetIterator endSection(const Section& section) const;
+    ///
+    /// \c section must be a valid constant of the \c Section type;
+    /// otherwise, an exception of class \c OutOfRange will be thrown.
+    const RRsetIterator endSection(const Section section) const;
 
     /// \brief Add a (pointer like object of) Question to the message.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     void addQuestion(QuestionPtr question);
 
     /// \brief Add a (pointer like object of) Question to the message.
@@ -406,7 +429,9 @@ public:
     /// form may be more intuitive and may make more sense for performance
     /// insensitive applications.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
     void addQuestion(const Question& question);
 
     /// \brief Add a (pointer like object of) RRset to the given section
@@ -415,23 +440,34 @@ public:
     /// This interface takes into account the RRSIG possibly attached to
     /// \c rrset.  This interface design needs to be revisited later.
     ///
-    /// Only allowed in the \c RENDER mode.
+    /// This method is only allowed in the \c RENDER mode;
+    /// if the \c Message is in other mode, an exception of class
+    /// InvalidMessageOperation will be thrown.
+    /// \c section must be a valid constant of the \c Section type;
+    /// otherwise, an exception of class \c OutOfRange will be thrown.
     ///
-    /// Note that addRRset() does not currently check for duplicate
+    /// Note that \c addRRset() does not currently check for duplicate
     /// data before inserting RRsets.  The caller is responsible for
-    /// checking for these (see hasRRset() below).
-    void addRRset(const Section& section, RRsetPtr rrset, bool sign = false);
+    /// checking for these (see \c hasRRset() below).
+    void addRRset(const Section section, RRsetPtr rrset, bool sign = false);
 
     /// \brief Determine whether the given section already has an RRset
-    /// matching the name and type of this one
-    bool hasRRset(const Section& section, RRsetPtr rrset);
+    /// matching the given name, RR class and RR type.
+    ///
+    /// \c section must be a valid constant of the \c Section type;
+    /// otherwise, an exception of class \c OutOfRange will be thrown.
+    ///
+    /// This should probably be extended to be a "find" method that returns
+    /// a matching RRset if found.
+    bool hasRRset(const Section section, const Name& name,
+                  const RRClass& rrclass, const RRType& rrtype);
 
     // The following methods are not currently implemented.
     //void removeQuestion(QuestionPtr question);
-    //void removeRRset(const Section& section, RRsetPtr rrset);
+    //void removeRRset(const Section section, RRsetPtr rrset);
     // notyet:
-    //void addRR(const Section& section, const RR& rr);
-    //void removeRR(const Section& section, const RR& rr);
+    //void addRR(const Section section, const RR& rr);
+    //void removeRR(const Section section, const RR& rr);
 
     /// \brief Clear the message content (if any) and reinitialize it in the
     /// specified mode.
@@ -475,9 +511,6 @@ public:
     ///
     /// With EDNS the maximum size can be increased per message.
     static const uint16_t DEFAULT_MAX_UDPSIZE = 512;
-
-    /// \brief The highest EDNS version this implementation supports.
-    static const uint8_t EDNS_SUPPORTED_VERSION = 0;
     //@}
 
 private:

src/lib/dns/python/message_python.cc

@@ -14,6 +14,7 @@
 
 // $Id$
 
+#include <exceptions/exceptions.h>
 #include <dns/message.h>
 using namespace isc::dns;
 
@@ -35,341 +36,10 @@ static PyObject* po_InvalidMessageUDPSize;
 // and static wrappers around the methods we export), a list of methods,
 // and a type description
 
-
-//
-// MessageFlag
-//
-class s_MessageFlag : public PyObject {
-public:
-    const MessageFlag* messageflag;
-};
-
-static int MessageFlag_init(s_MessageFlag* self, PyObject* args);
-static void MessageFlag_destroy(s_MessageFlag* self);
-
-static PyObject* MessageFlag_getBit(s_MessageFlag* self);
-static PyObject* MessageFlag_QR(s_MessageFlag* self);
-static PyObject* MessageFlag_AA(s_MessageFlag* self);
-static PyObject* MessageFlag_TC(s_MessageFlag* self);
-static PyObject* MessageFlag_RD(s_MessageFlag* self);
-static PyObject* MessageFlag_RA(s_MessageFlag* self);
-static PyObject* MessageFlag_AD(s_MessageFlag* self);
-static PyObject* MessageFlag_CD(s_MessageFlag* self);
-
-static PyMethodDef MessageFlag_methods[] = {
-    { "get_bit", reinterpret_cast<PyCFunction>(MessageFlag_getBit), METH_NOARGS, "Returns the flag bit" },
-    { "QR", reinterpret_cast<PyCFunction>(MessageFlag_QR), METH_NOARGS | METH_STATIC, "Creates a QR MessageFlag" },
-    { "AA", reinterpret_cast<PyCFunction>(MessageFlag_AA), METH_NOARGS | METH_STATIC, "Creates a AA MessageFlag" },
-    { "TC", reinterpret_cast<PyCFunction>(MessageFlag_TC), METH_NOARGS | METH_STATIC, "Creates a TC MessageFlag" },
-    { "RD", reinterpret_cast<PyCFunction>(MessageFlag_RD), METH_NOARGS | METH_STATIC, "Creates a RD MessageFlag" },
-    { "RA", reinterpret_cast<PyCFunction>(MessageFlag_RA), METH_NOARGS | METH_STATIC, "Creates a RA MessageFlag" },
-    { "AD", reinterpret_cast<PyCFunction>(MessageFlag_AD), METH_NOARGS | METH_STATIC, "Creates a AD MessageFlag" },
-    { "CD", reinterpret_cast<PyCFunction>(MessageFlag_CD), METH_NOARGS | METH_STATIC, "Creates a CD MessageFlag" },
-    { NULL, NULL, 0, NULL }
-};
-
-static PyTypeObject messageflag_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "pydnspp.MessageFlag",
-    sizeof(s_MessageFlag),              // tp_basicsize
-    0,                                  // tp_itemsize
-    (destructor)MessageFlag_destroy,    // tp_dealloc
-    NULL,                               // tp_print
-    NULL,                               // tp_getattr
-    NULL,                               // tp_setattr
-    NULL,                               // tp_reserved
-    NULL,                               // tp_repr
-    NULL,                               // tp_as_number
-    NULL,                               // tp_as_sequence
-    NULL,                               // tp_as_mapping
-    NULL,                               // tp_hash 
-    NULL,                               // tp_call
-    NULL,                               // tp_str
-    NULL,                               // tp_getattro
-    NULL,                               // tp_setattro
-    NULL,                               // tp_as_buffer
-    Py_TPFLAGS_DEFAULT,                 // tp_flags
-    "The MessageFlag class objects represent standard "
-    "flag bits of the header section of DNS messages.",
-    NULL,                               // tp_traverse
-    NULL,                               // tp_clear
-    NULL,                               // tp_richcompare
-    0,                                  // tp_weaklistoffset
-    NULL,                               // tp_iter
-    NULL,                               // tp_iternext
-    MessageFlag_methods,                // tp_methods
-    NULL,                               // tp_members
-    NULL,                               // tp_getset
-    NULL,                               // tp_base
-    NULL,                               // tp_dict
-    NULL,                               // tp_descr_get
-    NULL,                               // tp_descr_set
-    0,                                  // tp_dictoffset
-    (initproc)MessageFlag_init,         // tp_init
-    NULL,                               // tp_alloc
-    PyType_GenericNew,                  // tp_new
-    NULL,                               // tp_free
-    NULL,                               // tp_is_gc
-    NULL,                               // tp_bases
-    NULL,                               // tp_mro
-    NULL,                               // tp_cache
-    NULL,                               // tp_subclasses
-    NULL,                               // tp_weaklist
-    NULL,                               // tp_del
-    0                                   // tp_version_tag
-};
-
-static int
-MessageFlag_init(s_MessageFlag* self UNUSED_PARAM,
-                 PyObject* args UNUSED_PARAM)
-{
-    PyErr_SetString(PyExc_NotImplementedError,
-                    "MessageFlag can't be built directly");
-    return (-1);
-}
-
-static void
-MessageFlag_destroy(s_MessageFlag* self) {
-    // We only use the consts from MessageFlag, so don't
-    // delete self->messageflag here
-    self->messageflag = NULL;
-    Py_TYPE(self)->tp_free(self);
-}
-
-static PyObject*
-MessageFlag_getBit(s_MessageFlag* self) {
-    return (Py_BuildValue("I", self->messageflag->getBit()));
-}
-
-static PyObject*
-MessageFlag_createStatic(const MessageFlag& flag) {
-    s_MessageFlag* ret = PyObject_New(s_MessageFlag, &messageflag_type);
-    if (ret != NULL) {
-        ret->messageflag = &flag;
-    }
-    return (ret);
-}
-
-static PyObject*
-MessageFlag_QR(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::QR()));
-}
-
-static PyObject*
-MessageFlag_AA(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::AA()));
-}
-
-static PyObject*
-MessageFlag_TC(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::TC()));
-}
-
-static PyObject*
-MessageFlag_RD(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::RD()));
-}
-
-static PyObject*
-MessageFlag_RA(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::RA()));
-}
-
-static PyObject*
-MessageFlag_AD(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::AD()));
-}
-
-static PyObject*
-MessageFlag_CD(s_MessageFlag* self UNUSED_PARAM) {
-    return (MessageFlag_createStatic(MessageFlag::CD()));
-}
-
-//
-// End of MessageFlag wrapper
-//
-
 //
 // Section
 //
 
-// TODO: iterator?
-
-class s_Section : public PyObject {
-public:
-    const Section* section;
-};
-
-static int Section_init(s_Section* self, PyObject* args);
-static void Section_destroy(s_Section* self);
-
-static PyObject* Section_getCode(s_Section* self);
-static PyObject* Section_QUESTION(s_Section* self);
-static PyObject* Section_ANSWER(s_Section* self);
-static PyObject* Section_AUTHORITY(s_Section* self);
-static PyObject* Section_ADDITIONAL(s_Section* self);
-static PyObject* Section_richcmp(s_Section* self, s_Section* other, int op);
-
-static PyMethodDef Section_methods[] = {
-    { "get_code", reinterpret_cast<PyCFunction>(Section_getCode), METH_NOARGS, "Returns the code value" },
-    { "QUESTION", reinterpret_cast<PyCFunction>(Section_QUESTION), METH_NOARGS | METH_STATIC, "Creates a QUESTION Section" },
-    { "ANSWER", reinterpret_cast<PyCFunction>(Section_ANSWER), METH_NOARGS | METH_STATIC, "Creates an ANSWER Section" },
-    { "AUTHORITY", reinterpret_cast<PyCFunction>(Section_AUTHORITY), METH_NOARGS | METH_STATIC, "Creates an AUTHORITY Section" },
-    { "ADDITIONAL", reinterpret_cast<PyCFunction>(Section_ADDITIONAL), METH_NOARGS | METH_STATIC, "Creates an ADDITIONAL Section" },
-    { NULL, NULL, 0, NULL }
-};
-
-static PyTypeObject section_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "pydnspp.Section",
-    sizeof(s_Section),                  // tp_basicsize
-    0,                                  // tp_itemsize
-    (destructor)Section_destroy,        // tp_dealloc
-    NULL,                               // tp_print
-    NULL,                               // tp_getattr
-    NULL,                               // tp_setattr
-    NULL,                               // tp_reserved
-    NULL,                               // tp_repr
-    NULL,                               // tp_as_number
-    NULL,                               // tp_as_sequence
-    NULL,                               // tp_as_mapping
-    NULL,                               // tp_hash 
-    NULL,                               // tp_call
-    NULL,                               // tp_str
-    NULL,                               // tp_getattro
-    NULL,                               // tp_setattro
-    NULL,                               // tp_as_buffer
-    Py_TPFLAGS_DEFAULT,                 // tp_flags
-    "The Section class objects represent DNS message sections such "
-    "as the header, question, or answer.",
-    NULL,                               // tp_traverse
-    NULL,                               // tp_clear
-    (richcmpfunc)Section_richcmp,       // tp_richcompare
-    0,                                  // tp_weaklistoffset
-    NULL,                               // tp_iter
-    NULL,                               // tp_iternext
-    Section_methods,                    // tp_methods
-    NULL,                               // tp_members
-    NULL,                               // tp_getset
-    NULL,                               // tp_base
-    NULL,                               // tp_dict
-    NULL,                               // tp_descr_get
-    NULL,                               // tp_descr_set
-    0,                                  // tp_dictoffset
-    (initproc)Section_init,             // tp_init
-    NULL,                               // tp_alloc
-    PyType_GenericNew,                  // tp_new
-    NULL,                               // tp_free
-    NULL,                               // tp_is_gc
-    NULL,                               // tp_bases
-    NULL,                               // tp_mro
-    NULL,                               // tp_cache
-    NULL,                               // tp_subclasses
-    NULL,                               // tp_weaklist
-    NULL,                               // tp_del
-    0                                   // tp_version_tag
-};
-
-
-static int
-Section_init(s_Section* self UNUSED_PARAM,
-             PyObject* args UNUSED_PARAM)
-{
-    PyErr_SetString(PyExc_NotImplementedError,
-                    "Section can't be built directly");
-    return (-1);
-}
-
-static void
-Section_destroy(s_Section* self) {
-    // We only use the consts from Section, so don't
-    // delete self->section here
-    self->section = NULL;
-    Py_TYPE(self)->tp_free(self);
-}
-
-static PyObject*
-Section_getCode(s_Section* self) {
-    return (Py_BuildValue("I", self->section->getCode()));
-}
-
-static PyObject*
-Section_createStatic(const Section& section) {
-    s_Section* ret = PyObject_New(s_Section, &section_type);
-    if (ret != NULL) {
-        ret->section = &section;
-    }
-    return (ret);
-}
-
-
-static PyObject*
-Section_QUESTION(s_Section* self UNUSED_PARAM) {
-    return (Section_createStatic(Section::QUESTION()));
-}
-
-static PyObject*
-Section_ANSWER(s_Section* self UNUSED_PARAM) {
-    return (Section_createStatic(Section::ANSWER()));
-}
-
-static PyObject*
-Section_AUTHORITY(s_Section* self UNUSED_PARAM) {
-    return (Section_createStatic(Section::AUTHORITY()));
-}
-
-static PyObject*
-Section_ADDITIONAL(s_Section* self UNUSED_PARAM) {
-    return (Section_createStatic(Section::ADDITIONAL()));
-}
-
-static PyObject* 
-Section_richcmp(s_Section* self, s_Section* other, int op) {
-    bool c = false;
-
-    // Check for null and if the types match. If different type,
-    // simply return False
-    if (!other || (self->ob_type != other->ob_type)) {
-        Py_RETURN_FALSE;
-    }
-
-    // Only equals and not equals here, unorderable type
-    switch (op) {
-    case Py_LT:
-        PyErr_SetString(PyExc_TypeError, "Unorderable type; Section");
-        return (NULL);
-        break;
-    case Py_LE:
-        PyErr_SetString(PyExc_TypeError, "Unorderable type; Section");
-        return (NULL);
-        break;
-    case Py_EQ:
-        c = (*self->section == *other->section);
-        break;
-    case Py_NE:
-        c = (*self->section != *other->section);
-        break;
-    case Py_GT:
-        PyErr_SetString(PyExc_TypeError, "Unorderable type; Section");
-        return (NULL);
-        break;
-    case Py_GE:
-        PyErr_SetString(PyExc_TypeError, "Unorderable type; Section");
-        return (NULL);
-        break;
-    }
-    if (c)
-        Py_RETURN_TRUE;
-    else
-        Py_RETURN_FALSE;
-}
-
-//
-// End of Section wrapper
-//
-
-
-
 //
 // Message
 //
@@ -391,7 +61,6 @@ static void Message_destroy(s_Message* self);
 
 static PyObject* Message_getHeaderFlag(s_Message* self, PyObject* args);
 static PyObject* Message_setHeaderFlag(s_Message* self, PyObject* args);
-static PyObject* Message_clearHeaderFlag(s_Message* self, PyObject* args);
 static PyObject* Message_getQid(s_Message* self);
 static PyObject* Message_setQid(s_Message* self, PyObject* args);
 static PyObject* Message_getRcode(s_Message* self);
@@ -425,17 +94,15 @@ static PyObject* Message_fromWire(s_Message* self, PyObject* args);
 // 3. Argument type
 // 4. Documentation
 static PyMethodDef Message_methods[] = {
-    { "get_header_flag", reinterpret_cast<PyCFunction>(Message_getHeaderFlag), METH_VARARGS,
+    { "get_header_flag", reinterpret_cast<PyCFunction>(Message_getHeaderFlag),
+      METH_VARARGS,
       "Return whether the specified header flag bit is set in the "
       "header section. Takes a MessageFlag object as the only argument." },
-    { "set_header_flag", reinterpret_cast<PyCFunction>(Message_setHeaderFlag), METH_VARARGS,
+    { "set_header_flag",
+      reinterpret_cast<PyCFunction>(Message_setHeaderFlag), METH_VARARGS,
       "Sets the specified header flag bit to 1. The message must be in "
       "RENDER mode. If not, an InvalidMessageOperation is raised. "
       "Takes a MessageFlag object as the only argument." },
-    { "clear_header_flag", reinterpret_cast<PyCFunction>(Message_clearHeaderFlag), METH_VARARGS, 
-      "Sets the specified header flag bit to 0. The message must be in "
-      "RENDER mode. If not, an InvalidMessageOperation is raised. "
-      "Takes a MessageFlag object as the only argument." },
     { "get_qid", reinterpret_cast<PyCFunction>(Message_getQid), METH_NOARGS,
       "Returns the query id" },
     { "set_qid", reinterpret_cast<PyCFunction>(Message_setQid), METH_VARARGS,
@@ -562,8 +229,6 @@ static PyTypeObject message_type = {
 static int
 Message_init(s_Message* self, PyObject* args) {
     unsigned int i;
-    // The constructor argument can be a string ("IN"), an integer (1),
-    // or a sequence of numbers between 0 and 255 (wire code)
     
     if (PyArg_ParseTuple(args, "I", &i)) {
         PyErr_Clear();
@@ -593,12 +258,16 @@ Message_destroy(s_Message* self) {
 
 static PyObject*
 Message_getHeaderFlag(s_Message* self, PyObject* args) {
-    s_MessageFlag* messageflag;
-    if (!PyArg_ParseTuple(args, "O!", &messageflag_type, &messageflag)) {
+    unsigned int messageflag;
+    if (!PyArg_ParseTuple(args, "I", &messageflag)) {
+        PyErr_Clear();
+        PyErr_SetString(PyExc_TypeError,
+                        "no valid type in get_header_flag argument");
         return (NULL);
     }
-    
-    if (self->message->getHeaderFlag(*messageflag->messageflag)) {
+
+    if (self->message->getHeaderFlag(
+            static_cast<Message::HeaderFlag>(messageflag))) {
         Py_RETURN_TRUE;
     } else {
         Py_RETURN_FALSE;
@@ -607,38 +276,33 @@ Message_getHeaderFlag(s_Message* self, PyObject* args) {
 
 static PyObject*
 Message_setHeaderFlag(s_Message* self, PyObject* args) {
-    s_MessageFlag* messageflag;
-    if (!PyArg_ParseTuple(args, "O!", &messageflag_type, &messageflag)) {
-        return (NULL);
-    }
+    int messageflag;
+    PyObject *on = Py_True;
 
-    try {
-        self->message->setHeaderFlag(*messageflag->messageflag);
-        Py_RETURN_NONE;
-    } catch (const InvalidMessageOperation& imo) {
+    if (!PyArg_ParseTuple(args, "i|O!", &messageflag, &PyBool_Type, &on)) {
         PyErr_Clear();
-        PyErr_SetString(po_InvalidMessageOperation, imo.what());
+        PyErr_SetString(PyExc_TypeError,
+                        "no valid type in set_header_flag argument");
         return (NULL);
     }
-}
-
-static PyObject*
-Message_clearHeaderFlag(s_Message* self, PyObject* args) {
-    s_MessageFlag* messageflag;
-    if (!PyArg_ParseTuple(args, "O!", &messageflag_type, &messageflag)) {
+    if (messageflag < 0) {
+        PyErr_SetString(PyExc_TypeError, "invalid Message header flag");
         return (NULL);
     }
 
     try {
-        self->message->clearHeaderFlag(*messageflag->messageflag);
+        self->message->setHeaderFlag(
+            static_cast<Message::HeaderFlag>(messageflag), on == Py_True);
         Py_RETURN_NONE;
     } catch (const InvalidMessageOperation& imo) {
         PyErr_Clear();
         PyErr_SetString(po_InvalidMessageOperation, imo.what());
         return (NULL);
+    } catch (const isc::InvalidParameter& ip) {
+        PyErr_Clear();
+        PyErr_SetString(po_InvalidParameter, ip.what());
+        return (NULL);
     }
-
-    Py_RETURN_NONE;
 }
 
 static PyObject*
@@ -774,58 +438,107 @@ Message_setEDNS(s_Message* self, PyObject* args) {
 
 static PyObject*
 Message_getRRCount(s_Message* self, PyObject* args) {
-    s_Section *section;
-    if (!PyArg_ParseTuple(args, "O!", &section_type, &section)) {
+    unsigned int section;
+    if (!PyArg_ParseTuple(args, "I", &section)) {
+        PyErr_Clear();
+        PyErr_SetString(PyExc_TypeError,
+                        "no valid type in get_rr_count argument");
+        return (NULL);
+    }
+    try {
+        return (Py_BuildValue("I", self->message->getRRCount(
+                                  static_cast<Message::Section>(section))));
+    } catch (const isc::OutOfRange& ex) {
+        PyErr_SetString(PyExc_OverflowError, ex.what());
         return (NULL);
     }
-    return (Py_BuildValue("I", self->message->getRRCount(*section->section)));
 }
 
 // TODO use direct iterators for these? (or simply lists for now?)
 static PyObject*
 Message_getQuestion(s_Message* self) {
+    QuestionIterator qi, qi_end;
+    try {
+        qi = self->message->beginQuestion();
+        qi_end = self->message->endQuestion();
+    } catch (const InvalidMessageSection& ex) {
+        PyErr_SetString(po_InvalidMessageSection, ex.what());
+        return (NULL);
+    } catch (...) {
+        PyErr_SetString(po_IscException,
+                        "Unexpected exception in getting section iterators");
+        return (NULL);
+    }
+
     PyObject* list = PyList_New(0);
-    
-    for (QuestionIterator qi = self->message->beginQuestion();
-         qi != self->message->endQuestion();
-         ++qi) {
-        s_Question *question = static_cast<s_Question*>(question_type.tp_alloc(&question_type, 0));
-        if (question != NULL) {
-            question->question = *qi;
-            if (question->question == NULL)
-              {
-                Py_DECREF(question);
-                return (NULL);
-              }
+    if (list == NULL) {
+        return (NULL);
+    }
+
+    for (; qi != qi_end; ++qi) {
+        s_Question *question = static_cast<s_Question*>(
+            question_type.tp_alloc(&question_type, 0));
+        if (question == NULL) {
+            Py_DECREF(question);
+            Py_DECREF(list);
+            return (NULL);
+        }
+        question->question = *qi;
+        if (PyList_Append(list, question) == -1) {
+            Py_DECREF(question);
+            Py_DECREF(list);
+            return (NULL);
         }
-        PyList_Append(list, question);
+        Py_DECREF(question);
     }
     return (list);
 }
 
 static PyObject*
 Message_getSection(s_Message* self, PyObject* args) {
-    s_Section *section;
-    if (!PyArg_ParseTuple(args, "O!", &section_type, &section)) {
+    unsigned int section;
+    if (!PyArg_ParseTuple(args, "I", &section)) {
+        PyErr_Clear();
+        PyErr_SetString(PyExc_TypeError,
+                        "no valid type in get_section argument");
+        return (NULL);
+    }
+    RRsetIterator rrsi, rrsi_end;
+    try {
+        rrsi = self->message->beginSection(
+            static_cast<Message::Section>(section));
+        rrsi_end = self->message->endSection(
+            static_cast<Message::Section>(section));
+    } catch (const isc::OutOfRange& ex) {
+        PyErr_SetString(PyExc_OverflowError, ex.what());
+        return (NULL);
+    } catch (const InvalidMessageSection& ex) {
+        PyErr_SetString(po_InvalidMessageSection, ex.what());
+        return (NULL);
+    } catch (...) {
+        PyErr_SetString(po_IscException,
+                        "Unexpected exception in getting section iterators");
         return (NULL);
     }
-    PyObject* list = PyList_New(0);
-    
-    for (RRsetIterator rrsi = self->message->beginSection(*section->section);
-         rrsi != self->message->endSection(*section->section);
-         ++rrsi) {
 
-        s_RRset *rrset = static_cast<s_RRset*>(rrset_type.tp_alloc(&rrset_type, 0));
-        if (rrset != NULL) {
-            rrset->rrset = *rrsi;
-            if (rrset->rrset == NULL)
-              {
+    PyObject* list = PyList_New(0);
+    if (list == NULL) {
+        return (NULL);
+    }
+    for (; rrsi != rrsi_end; ++rrsi) {
+        s_RRset *rrset = static_cast<s_RRset*>(
+            rrset_type.tp_alloc(&rrset_type, 0));
+        if (rrset == NULL) {
+                Py_DECREF(rrset);
+                Py_DECREF(list);
+                return (NULL);
+        }
+        rrset->rrset = *rrsi;
+        if (PyList_Append(list, rrset) == -1) {
                 Py_DECREF(rrset);
                 Py_DECREF(list);
                 return (NULL);
-              }
         }
-        PyList_Append(list, rrset);
         // PyList_Append increases refcount, so we remove ours since
         // we don't need it anymore
         Py_DECREF(rrset);
@@ -854,33 +567,33 @@ Message_addQuestion(s_Message* self, PyObject* args) {
 static PyObject*
 Message_addRRset(s_Message* self, PyObject* args) {
     PyObject *sign = Py_False;
-    s_Section* section;
+    unsigned int section;
     s_RRset* rrset;
-    if (!PyArg_ParseTuple(args, "O!O!|O!", &section_type, &section,
-                                           &rrset_type, &rrset,
-                                           &PyBool_Type, &sign)) {
+    if (!PyArg_ParseTuple(args, "IO!|O!", &section, &rrset_type, &rrset,
+                          &PyBool_Type, &sign)) {
         return (NULL);
     }
 
     try {
-        if (sign == Py_True) {
-            self->message->addRRset(*section->section, rrset->rrset, true);
-        } else {
-            self->message->addRRset(*section->section, rrset->rrset, false);
-        }
+        self->message->addRRset(static_cast<Message::Section>(section),
+                                rrset->rrset, sign == Py_True);
         Py_RETURN_NONE;
     } catch (const InvalidMessageOperation& imo) {
         PyErr_SetString(po_InvalidMessageOperation, imo.what());
         return (NULL);
+    } catch (const isc::OutOfRange& ex) {
+        PyErr_SetString(PyExc_OverflowError, ex.what());
+        return (NULL);
+    } catch (...) {
+        PyErr_SetString(po_IscException,
+                        "Unexpected exception in adding RRset");
+        return (NULL);
     }
 }
 
 static PyObject*
 Message_clear(s_Message* self, PyObject* args) {
     unsigned int i;
-    // The constructor argument can be a string ("IN"), an integer (1),
-    // or a sequence of numbers between 0 and 255 (wire code)
-
     if (PyArg_ParseTuple(args, "I", &i)) {
         PyErr_Clear();
         if (i == Message::PARSE) {
@@ -890,7 +603,8 @@ Message_clear(s_Message* self, PyObject* args) {
             self->message->clear(Message::RENDER);
             Py_RETURN_NONE;
         } else {
-            PyErr_SetString(PyExc_TypeError, "Message mode must be Message.PARSE or Message.RENDER");
+            PyErr_SetString(PyExc_TypeError,
+                            "Message mode must be Message.PARSE or Message.RENDER");
             return (NULL);
         }
     } else {
@@ -979,62 +693,64 @@ Message_fromWire(s_Message* self, PyObject* args) {
 // Module Initialization, all statics are initialized here
 bool
 initModulePart_Message(PyObject* mod) {
-    
-    // add methods to class
-    if (PyType_Ready(&messageflag_type) < 0) {
-        return (false);
-    }
-    Py_INCREF(&messageflag_type);
-    PyModule_AddObject(mod, "MessageFlag",
-                       reinterpret_cast<PyObject*>(&messageflag_type));
-
-    
-    if (PyType_Ready(&opcode_type) < 0) {
-        return (false);
-    }
-    Py_INCREF(&opcode_type);
-    PyModule_AddObject(mod, "Opcode",
-                       reinterpret_cast<PyObject*>(&opcode_type));
-
-    if (PyType_Ready(&rcode_type) < 0) {
-        return (false);
-    }
-    Py_INCREF(&rcode_type);
-    PyModule_AddObject(mod, "Rcode",
-                       reinterpret_cast<PyObject*>(&rcode_type));
-
-    if (PyType_Ready(&section_type) < 0) {
-        return (false);
-    }
-    Py_INCREF(&section_type);
-    PyModule_AddObject(mod, "Section",
-                       reinterpret_cast<PyObject*>(&section_type));
-
-    
     if (PyType_Ready(&message_type) < 0) {
         return (false);
     }
+    Py_INCREF(&message_type);
     
     // Class variables
     // These are added to the tp_dict of the type object
     //
-    addClassVariable(message_type, "PARSE", Py_BuildValue("I", Message::PARSE));
-    addClassVariable(message_type, "RENDER", Py_BuildValue("I", Message::RENDER));
-    addClassVariable(message_type, "DEFAULT_MAX_UDPSIZE", Py_BuildValue("I", Message::DEFAULT_MAX_UDPSIZE));
+    addClassVariable(message_type, "PARSE",
+                     Py_BuildValue("I", Message::PARSE));
+    addClassVariable(message_type, "RENDER",
+                     Py_BuildValue("I", Message::RENDER));
+
+    addClassVariable(message_type, "HEADERFLAG_QR",
+                     Py_BuildValue("I", Message::HEADERFLAG_QR));
+    addClassVariable(message_type, "HEADERFLAG_AA",
+                     Py_BuildValue("I", Message::HEADERFLAG_AA));
+    addClassVariable(message_type, "HEADERFLAG_TC",
+                     Py_BuildValue("I", Message::HEADERFLAG_TC));
+    addClassVariable(message_type, "HEADERFLAG_RD",
+                     Py_BuildValue("I", Message::HEADERFLAG_RD));
+    addClassVariable(message_type, "HEADERFLAG_RA",
+                     Py_BuildValue("I", Message::HEADERFLAG_RA));
+    addClassVariable(message_type, "HEADERFLAG_AD",
+                     Py_BuildValue("I", Message::HEADERFLAG_AD));
+    addClassVariable(message_type, "HEADERFLAG_CD",
+                     Py_BuildValue("I", Message::HEADERFLAG_CD));
+
+    addClassVariable(message_type, "SECTION_QUESTION",
+                     Py_BuildValue("I", Message::SECTION_QUESTION));
+    addClassVariable(message_type, "SECTION_ANSWER",
+                     Py_BuildValue("I", Message::SECTION_ANSWER));
+    addClassVariable(message_type, "SECTION_AUTHORITY",
+                     Py_BuildValue("I", Message::SECTION_AUTHORITY));
+    addClassVariable(message_type, "SECTION_ADDITIONAL",
+                     Py_BuildValue("I", Message::SECTION_ADDITIONAL));
+
+    addClassVariable(message_type, "DEFAULT_MAX_UDPSIZE",
+                     Py_BuildValue("I", Message::DEFAULT_MAX_UDPSIZE));
 
     /* Class-specific exceptions */
-    po_MessageTooShort = PyErr_NewException("pydnspp.MessageTooShort", NULL, NULL);
+    po_MessageTooShort = PyErr_NewException("pydnspp.MessageTooShort", NULL,
+                                            NULL);
     PyModule_AddObject(mod, "MessageTooShort", po_MessageTooShort);
-    po_InvalidMessageSection = PyErr_NewException("pydnspp.InvalidMessageSection", NULL, NULL);
+    po_InvalidMessageSection =
+        PyErr_NewException("pydnspp.InvalidMessageSection", NULL, NULL);
     PyModule_AddObject(mod, "InvalidMessageSection", po_InvalidMessageSection);
-    po_InvalidMessageOperation = PyErr_NewException("pydnspp.InvalidMessageOperation", NULL, NULL);
-    PyModule_AddObject(mod, "InvalidMessageOperation", po_InvalidMessageOperation);
-    po_InvalidMessageUDPSize = PyErr_NewException("pydnspp.InvalidMessageUDPSize", NULL, NULL);
+    po_InvalidMessageOperation =
+        PyErr_NewException("pydnspp.InvalidMessageOperation", NULL, NULL);
+    PyModule_AddObject(mod, "InvalidMessageOperation",
+                       po_InvalidMessageOperation);
+    po_InvalidMessageUDPSize =
+        PyErr_NewException("pydnspp.InvalidMessageUDPSize", NULL, NULL);
     PyModule_AddObject(mod, "InvalidMessageUDPSize", po_InvalidMessageUDPSize);
-    po_DNSMessageBADVERS = PyErr_NewException("pydnspp.DNSMessageBADVERS", NULL, NULL);
+    po_DNSMessageBADVERS = PyErr_NewException("pydnspp.DNSMessageBADVERS",
+                                              NULL, NULL);
     PyModule_AddObject(mod, "DNSMessageBADVERS", po_DNSMessageBADVERS);
 
-    Py_INCREF(&message_type);
     PyModule_AddObject(mod, "Message",
                        reinterpret_cast<PyObject*>(&message_type));
 

src/lib/dns/python/tests/message_python_test.py

@@ -22,61 +22,6 @@ import os
 from pydnspp import *
 from testutil import *
 
-class MessageFlagTest(unittest.TestCase):
-    def test_init(self):
-        self.assertRaises(NotImplementedError, MessageFlag)
-
-    def test_get_bit(self):
-        self.assertEqual(0x8000, MessageFlag.QR().get_bit())
-        self.assertEqual(0x0400, MessageFlag.AA().get_bit())
-        self.assertEqual(0x0200, MessageFlag.TC().get_bit())
-        self.assertEqual(0x0100, MessageFlag.RD().get_bit())
-        self.assertEqual(0x0080, MessageFlag.RA().get_bit())
-        self.assertEqual(0x0020, MessageFlag.AD().get_bit())
-        self.assertEqual(0x0010, MessageFlag.CD().get_bit())
-
-class SectionTest(unittest.TestCase):
-
-    def test_init(self):
-        self.assertRaises(NotImplementedError, Section)
-
-    def test_get_code(self):
-        self.assertEqual(0, Section.QUESTION().get_code())
-        self.assertEqual(1, Section.ANSWER().get_code())
-        self.assertEqual(2, Section.AUTHORITY().get_code())
-        self.assertEqual(3, Section.ADDITIONAL().get_code())
-
-    def test_richcmp(self):
-        s1 = Section.QUESTION()
-        s2 = Section.ANSWER()
-        s3 = Section.ANSWER()
-        self.assertTrue(s2 == s3)
-        self.assertTrue(s1 != s2)
-        self.assertFalse(s1 == s2)
-        self.assertFalse(s1 == 1)
-        # can't use assertRaises here...
-        try:
-            s1 < s2
-            self.fail("operation that should have raised an error unexpectedly succeeded")
-        except Exception as err:
-            self.assertEqual(TypeError, type(err))
-        try:
-            s1 <= s2
-            self.fail("operation that should have raised an error unexpectedly succeeded")
-        except Exception as err:
-            self.assertEqual(TypeError, type(err))
-        try:
-            s1 > s2
-            self.fail("operation that should have raised an error unexpectedly succeeded")
-        except Exception as err:
-            self.assertEqual(TypeError, type(err))
-        try:
-            s1 >= s2
-            self.fail("operation that should have raised an error unexpectedly succeeded")
-        except Exception as err:
-            self.assertEqual(TypeError, type(err))
-        
-
 # helper functions for tests taken from c++ unittests
 if "TESTDATA_PATH" in os.environ:
     testdata_path = os.environ["TESTDATA_PATH"]
@@ -105,15 +50,16 @@ def create_message():
     message_render.set_qid(0x1035)
     message_render.set_opcode(Opcode.QUERY())
     message_render.set_rcode(Rcode.NOERROR())
-    message_render.set_header_flag(MessageFlag.QR())
-    message_render.set_header_flag(MessageFlag.RD())
-    message_render.set_header_flag(MessageFlag.AA())
-    message_render.add_question(Question(Name("test.example.com"), RRClass("IN"), RRType("A")))
+    message_render.set_header_flag(Message.HEADERFLAG_QR)
+    message_render.set_header_flag(Message.HEADERFLAG_RD)
+    message_render.set_header_flag(Message.HEADERFLAG_AA)
+    message_render.add_question(Question(Name("test.example.com"),
+                                         RRClass("IN"), RRType("A")))
     rrset = RRset(Name("test.example.com"), RRClass("IN"),
                                         RRType("A"), RRTTL(3600))
     rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
     rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
-    message_render.add_rrset(Section.ANSWER(), rrset)
+    message_render.add_rrset(Message.SECTION_ANSWER, rrset)
     return message_render
 
 
@@ -122,29 +68,56 @@ class MessageTest(unittest.TestCase):
     def setUp(self):
         self.p = Message(Message.PARSE)
         self.r = Message(Message.RENDER)
-        
+
+        self.rrset_a = RRset(Name("example.com"), RRClass("IN"), RRType("A"),
+                             RRTTL(3600))
+        self.rrset_a.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
+        self.rrset_a.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
+
+        self.rrset_aaaa = RRset(Name("example.com"), RRClass("IN"),
+                                RRType("AAAA"), RRTTL(3600))
+        self.rrset_aaaa.add_rdata(Rdata(RRType("AAAA"), RRClass("IN"),
+                                        "2001:db8::134"))
+
+        self.bogus_section = Message.SECTION_ADDITIONAL + 1
+
     def test_init(self):
         self.assertRaises(TypeError, Message, 3)
         self.assertRaises(TypeError, Message, "wrong")
 
-    def test_get_header_flag(self):
+    def test_header_flag(self): # set and get methods
         self.assertRaises(TypeError, self.p.get_header_flag, "wrong")
-        self.assertFalse(self.p.get_header_flag(MessageFlag.AA()))
-
-    def test_set_clear_header_flag(self):
         self.assertRaises(TypeError, self.r.set_header_flag, "wrong")
-        self.assertRaises(TypeError, self.r.clear_header_flag, "wrong")
 
-        self.assertFalse(self.r.get_header_flag(MessageFlag.AA()))
-        self.r.set_header_flag(MessageFlag.AA())
-        self.assertTrue(self.r.get_header_flag(MessageFlag.AA()))
-        self.r.clear_header_flag(MessageFlag.AA())
-        self.assertFalse(self.r.get_header_flag(MessageFlag.AA()))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_QR))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AA))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_TC))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_RD))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_RA))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AD))
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_CD))
+
+        self.r.set_header_flag(Message.HEADERFLAG_QR)
+        self.assertTrue(self.r.get_header_flag(Message.HEADERFLAG_QR))
+
+        self.r.set_header_flag(Message.HEADERFLAG_AA, True)
+        self.assertTrue(self.r.get_header_flag(Message.HEADERFLAG_AA))
+
+        self.r.set_header_flag(Message.HEADERFLAG_AA, False)
+        self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AA))
+
+        self.assertRaises(InvalidParameter, self.r.set_header_flag, 0)
+        self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x7000)
+        self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x0800)
+        self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x10000)
+        self.assertRaises(TypeError, self.r.set_header_flag, 0x80000000)
+        # this would cause overflow and result in a "valid" flag
+        self.assertRaises(TypeError, self.r.set_header_flag,
+                          Message.HEADERFLAG_AA | 0x100000000)
+        self.assertRaises(TypeError, self.r.set_header_flag, -1)
 
         self.assertRaises(InvalidMessageOperation,
-                          self.p.set_header_flag, MessageFlag.AA())
-        self.assertRaises(InvalidMessageOperation,
-                          self.p.clear_header_flag, MessageFlag.AA())
+                          self.p.set_header_flag, Message.HEADERFLAG_AA)
 
     def test_set_qid(self):
         self.assertRaises(TypeError, self.r.set_qid, "wrong")
@@ -195,52 +168,77 @@ class MessageTest(unittest.TestCase):
         self.r.set_edns(edns)
         self.assertEqual(1024, self.r.get_edns().get_udp_size())
 
+    def test_get_rr_count(self):
+        # counts also tested in add_section
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_QUESTION))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ANSWER))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_AUTHORITY))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
+
+        self.r.add_question(Question(Name("example.com"), RRClass("IN"),
+                                     RRType("A")))
+        self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
+
+        self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
+        self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
+
+        factoryFromFile(self.p, "message_fromWire11.wire")
+        self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
+
+        self.assertRaises(OverflowError, self.r.get_rr_count,
+                          self.bogus_section)
+        self.assertRaises(TypeError, self.r.get_rr_count, "wrong")
+
     def test_get_section(self):
         self.assertRaises(TypeError, self.r.get_section, "wrong")
 
-        rrset = RRset(Name("example.com"), RRClass("IN"), RRType("A"), RRTTL(3600))
-        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
-        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
-        section_rrset = [rrset]
+        section_rrset = [self.rrset_a]
 
         self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
-                          Section.ANSWER(), rrset)
+                          Message.SECTION_ANSWER, self.rrset_a)
         
-        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.ANSWER())))
-        self.assertEqual(0, self.r.get_rr_count(Section.ANSWER()))
-        self.r.add_rrset(Section.ANSWER(), rrset)
-        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.ANSWER())))
-        self.assertEqual(2, self.r.get_rr_count(Section.ANSWER()))
-
-        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.AUTHORITY())))
-        self.assertEqual(0, self.r.get_rr_count(Section.AUTHORITY()))
-        self.r.add_rrset(Section.AUTHORITY(), rrset)
-        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.AUTHORITY())))
-        self.assertEqual(2, self.r.get_rr_count(Section.AUTHORITY()))
-
-        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.ADDITIONAL())))
-        self.assertEqual(0, self.r.get_rr_count(Section.ADDITIONAL()))
-        self.r.add_rrset(Section.ADDITIONAL(), rrset)
-        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.ADDITIONAL())))
-        self.assertEqual(2, self.r.get_rr_count(Section.ADDITIONAL()))
-
-    def test_get_rr_count(self):
-        self.assertRaises(TypeError, self.r.get_rr_count, "wrong")
-        # counts also tested in add_section
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ANSWER)))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ANSWER))
+        self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ANSWER)))
+        self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
+
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_AUTHORITY)))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_AUTHORITY))
+        self.r.add_rrset(Message.SECTION_AUTHORITY, self.rrset_a)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_AUTHORITY)))
+        self.assertEqual(2, self.r.get_rr_count(Message.SECTION_AUTHORITY))
+
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ADDITIONAL)))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
+        self.r.add_rrset(Message.SECTION_ADDITIONAL, self.rrset_a)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ADDITIONAL)))
+        self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
 
     def test_add_question(self):
         self.assertRaises(TypeError, self.r.add_question, "wrong", "wrong")
         q = Question(Name("example.com"), RRClass("IN"), RRType("A"))
         qs = [q]
         self.assertFalse(compare_rrset_list(qs, self.r.get_question()))
-        self.assertEqual(0, self.r.get_rr_count(Section.QUESTION()))
+        self.assertEqual(0, self.r.get_rr_count(Message.SECTION_QUESTION))
         self.r.add_question(q)
         self.assertTrue(compare_rrset_list(qs, self.r.get_question()))
-        self.assertEqual(1, self.r.get_rr_count(Section.QUESTION()))
+        self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
 
     def test_add_rrset(self):
         self.assertRaises(TypeError, self.r.add_rrset, "wrong")
-        # actual addition already tested in get_section
+        self.assertRaises(TypeError, self.r.add_rrset)
+
+        # we can currently only test the no-sign case.
+        self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
+        self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
+
+    def test_bad_add_rrset(self):
+        self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
+                          Message.SECTION_ANSWER, self.rrset_a)
+        self.assertRaises(OverflowError, self.r.add_rrset,
+                          self.bogus_section, self.rrset_a)
 
     def test_clear(self):
         self.assertEqual(None, self.r.clear(Message.PARSE))
@@ -308,22 +306,22 @@ test.example.com. 3600 IN A 192.0.2.2
         self.assertEqual(0x1035, message_parse.get_qid())
         self.assertEqual(Opcode.QUERY(), message_parse.get_opcode())
         self.assertEqual(Rcode.NOERROR(), message_parse.get_rcode())
-        self.assertTrue(message_parse.get_header_flag(MessageFlag.QR()))
-        self.assertTrue(message_parse.get_header_flag(MessageFlag.RD()))
-        self.assertTrue(message_parse.get_header_flag(MessageFlag.AA()))
+        self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_QR))
+        self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_RD))
+        self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_AA))
     
         #QuestionPtr q = *message_parse.beginQuestion()
         q = message_parse.get_question()[0]
         self.assertEqual(test_name, q.get_name())
         self.assertEqual(RRType("A"), q.get_type())
         self.assertEqual(RRClass("IN"), q.get_class())
-        self.assertEqual(1, message_parse.get_rr_count(Section.QUESTION()))
-        self.assertEqual(2, message_parse.get_rr_count(Section.ANSWER()))
-        self.assertEqual(0, message_parse.get_rr_count(Section.AUTHORITY()))
-        self.assertEqual(0, message_parse.get_rr_count(Section.ADDITIONAL()))
+        self.assertEqual(1, message_parse.get_rr_count(Message.SECTION_QUESTION))
+        self.assertEqual(2, message_parse.get_rr_count(Message.SECTION_ANSWER))
+        self.assertEqual(0, message_parse.get_rr_count(Message.SECTION_AUTHORITY))
+        self.assertEqual(0, message_parse.get_rr_count(Message.SECTION_ADDITIONAL))
     
-        #RRsetPtr rrset = *message_parse.beginSection(Section.ANSWER())
-        rrset = message_parse.get_section(Section.ANSWER())[0]
+        #RRsetPtr rrset = *message_parse.beginSection(Message.SECTION_ANSWER)
+        rrset = message_parse.get_section(Message.SECTION_ANSWER)[0]
         self.assertEqual(test_name, rrset.get_name())
         self.assertEqual(RRType("A"), rrset.get_type())
         self.assertEqual(RRClass("IN"), rrset.get_class())

src/lib/dns/python/tests/messagerenderer_python_test.py

@@ -38,15 +38,15 @@ class MessageRendererTest(unittest.TestCase):
         self.message1 = message
         message = Message(Message.RENDER)
         message.set_qid(123)
-        message.set_header_flag(MessageFlag.AA())
-        message.set_header_flag(MessageFlag.QR())
+        message.set_header_flag(Message.HEADERFLAG_AA, True)
+        message.set_header_flag(Message.HEADERFLAG_QR, True)
         message.set_opcode(Opcode.QUERY())
         message.set_rcode(Rcode.NOERROR())
         message.add_question(Question(name, c, t))
         rrset = RRset(name, c, t, ttl)
         rrset.add_rdata(Rdata(t, c, "192.0.2.98"))
         rrset.add_rdata(Rdata(t, c, "192.0.2.99"))
-        message.add_rrset(Section.AUTHORITY(), rrset)
+        message.add_rrset(Message.SECTION_AUTHORITY, rrset)
         self.message2 = message
 
         self.renderer1 = MessageRenderer()

src/lib/dns/tests/message_unittest.cc

@@ -35,6 +35,7 @@
 
 using isc::UnitTestUtil;
 using namespace std;
+using namespace isc;
 using namespace isc::dns;
 using namespace isc::dns::rdata;
 
@@ -51,25 +52,46 @@ using namespace isc::dns::rdata;
 //
 
 const uint16_t Message::DEFAULT_MAX_UDPSIZE;
+const Name test_name("test.example.com");
 
 namespace {
 class MessageTest : public ::testing::Test {
 protected:
     MessageTest() : obuffer(0), renderer(obuffer),
                     message_parse(Message::PARSE),
-                    message_render(Message::RENDER)
-    {}
+                    message_render(Message::RENDER),
+                    bogus_section(static_cast<Message::Section>(
+                                      Message::SECTION_ADDITIONAL + 1))
+    {
+        rrset_a = RRsetPtr(new RRset(test_name, RRClass::IN(),
+                                     RRType::A(), RRTTL(3600)));
+        rrset_a->addRdata(in::A("192.0.2.1"));
+        rrset_a->addRdata(in::A("192.0.2.2"));
+
+        rrset_aaaa = RRsetPtr(new RRset(test_name, RRClass::IN(),
+                                        RRType::AAAA(), RRTTL(3600)));
+        rrset_aaaa->addRdata(in::AAAA("2001:db8::1234"));
+
+        rrset_rrsig = RRsetPtr(new RRset(test_name, RRClass::IN(),
+                                        RRType::RRSIG(), RRTTL(3600)));
+        rrset_rrsig->addRdata(generic::RRSIG("AAAA 5 3 7200 20100322084538 "
+                                             "20100220084538 1 example.com "
+                                             "FAKEFAKEFAKEFAKE"));
+        rrset_aaaa->addRRsig(rrset_rrsig);
+    }
     
     static Question factoryFromFile(const char* datafile);
     OutputBuffer obuffer;
     MessageRenderer renderer;
     Message message_parse;
     Message message_render;
+    const Message::Section bogus_section;
+    RRsetPtr rrset_a;           // A RRset with two RDATAs
+    RRsetPtr rrset_aaaa;        // AAAA RRset with one RDATA with RRSIG
+    RRsetPtr rrset_rrsig;       // RRSIG for the AAAA RRset
     static void factoryFromFile(Message& message, const char* datafile);
 };
 
-const Name test_name("test.example.com");
-
 void
 MessageTest::factoryFromFile(Message& message, const char* datafile) {
     std::vector<unsigned char> data;
@@ -79,6 +101,52 @@ MessageTest::factoryFromFile(Message& message, const char* datafile) {
     message.fromWire(buffer);
 }
 
+TEST_F(MessageTest, headerFlag) {
+    // by default no flag is set
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_AA));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_TC));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_RD));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_RA));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_AD));
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_CD));
+
+    // set operation: by default it will be on
+    message_render.setHeaderFlag(Message::HEADERFLAG_QR);
+    EXPECT_TRUE(message_render.getHeaderFlag(Message::HEADERFLAG_QR));
+
+    // it can be set to on explicitly, too
+    message_render.setHeaderFlag(Message::HEADERFLAG_AA, true);
+    EXPECT_TRUE(message_render.getHeaderFlag(Message::HEADERFLAG_AA));
+
+    // the bit can also be cleared
+    message_render.setHeaderFlag(Message::HEADERFLAG_AA, false);
+    EXPECT_FALSE(message_render.getHeaderFlag(Message::HEADERFLAG_AA));
+
+    // Invalid flag values
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0)), InvalidParameter);
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0x7000)),
+                 InvalidParameter);
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0x0800)),
+                 InvalidParameter);
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0x0040)),
+                 InvalidParameter);
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0x10000)),
+                 InvalidParameter);
+    EXPECT_THROW(message_render.setHeaderFlag(
+                     static_cast<Message::HeaderFlag>(0x80000000)),
+                 InvalidParameter);
+
+    // set operation isn't allowed in the parse mode.
+    EXPECT_THROW(message_parse.setHeaderFlag(Message::HEADERFLAG_QR),
+                 InvalidMessageOperation);
+}
+
 TEST_F(MessageTest, getEDNS) {
     EXPECT_FALSE(message_parse.getEDNS()); // by default EDNS isn't set
 
@@ -99,25 +167,126 @@ TEST_F(MessageTest, setEDNS) {
     EXPECT_EQ(edns, message_render.getEDNS());
 }
 
+TEST_F(MessageTest, getRRCount) {
+    // by default all counters should be 0
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_QUESTION));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_ANSWER));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_AUTHORITY));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_ADDITIONAL));
+
+    message_render.addQuestion(Question(Name("test.example.com"),
+                                        RRClass::IN(), RRType::A()));
+    EXPECT_EQ(1, message_render.getRRCount(Message::SECTION_QUESTION));
+
+    // rrset_a contains two RRs
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_a);
+    EXPECT_EQ(2, message_render.getRRCount(Message::SECTION_ANSWER));
+
+    // parse a message containing a Question and EDNS OPT RR.
+    // OPT shouldn't be counted as normal RR, so result of getRRCount
+    // shouldn't change.
+    factoryFromFile(message_parse, "message_fromWire11.wire");
+    EXPECT_EQ(1, message_render.getRRCount(Message::SECTION_QUESTION));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_ADDITIONAL));
+
+    // out-of-band section ID
+    EXPECT_THROW(message_parse.getRRCount(bogus_section), OutOfRange);
+}
+
+TEST_F(MessageTest, addRRset) {
+    // default case
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_a);
+    EXPECT_EQ(rrset_a,
+              *message_render.beginSection(Message::SECTION_ANSWER));
+    EXPECT_EQ(2, message_render.getRRCount(Message::SECTION_ANSWER));
+
+    // signed RRset, default case
+    message_render.clear(Message::RENDER);
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_aaaa);
+    EXPECT_EQ(rrset_aaaa,
+              *message_render.beginSection(Message::SECTION_ANSWER));
+    EXPECT_EQ(1, message_render.getRRCount(Message::SECTION_ANSWER));
+
+    // signed RRset, add with the RRSIG.  getRRCount() should return 2
+    message_render.clear(Message::RENDER);
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_aaaa, true);
+    EXPECT_EQ(rrset_aaaa,
+              *message_render.beginSection(Message::SECTION_ANSWER));
+    EXPECT_EQ(2, message_render.getRRCount(Message::SECTION_ANSWER));
+
+    // signed RRset, add explicitly without RRSIG.
+    message_render.clear(Message::RENDER);
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_aaaa, false);
+    EXPECT_EQ(rrset_aaaa,
+              *message_render.beginSection(Message::SECTION_ANSWER));
+    EXPECT_EQ(1, message_render.getRRCount(Message::SECTION_ANSWER));
+}
+
+TEST_F(MessageTest, badAddRRset) {
+    // addRRset() isn't allowed in the parse mode.
+    EXPECT_THROW(message_parse.addRRset(Message::SECTION_ANSWER,
+                                        rrset_a), InvalidMessageOperation);
+    // out-of-band section ID
+    EXPECT_THROW(message_render.addRRset(bogus_section, rrset_a), OutOfRange);
+}
+
+TEST_F(MessageTest, hasRRset) {
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_a);
+    EXPECT_TRUE(message_render.hasRRset(Message::SECTION_ANSWER, test_name,
+                                        RRClass::IN(), RRType::A()));
+    // section doesn't match
+    EXPECT_FALSE(message_render.hasRRset(Message::SECTION_ADDITIONAL, test_name,
+                                         RRClass::IN(), RRType::A()));
+    // name doesn't match
+    EXPECT_FALSE(message_render.hasRRset(Message::SECTION_ANSWER,
+                                         Name("nomatch.example"),
+                                         RRClass::IN(), RRType::A()));
+    // RR class doesn't match
+    EXPECT_FALSE(message_render.hasRRset(Message::SECTION_ANSWER, test_name,
+                                        RRClass::CH(), RRType::A()));
+    // RR type doesn't match
+    EXPECT_FALSE(message_render.hasRRset(Message::SECTION_ANSWER, test_name,
+                                        RRClass::IN(), RRType::AAAA()));
+
+    // out-of-band section ID
+    EXPECT_THROW(message_render.hasRRset(bogus_section, test_name,
+                                         RRClass::IN(), RRType::A()),
+                 OutOfRange);
+}
+
+TEST_F(MessageTest, badBeginSection) {
+    // valid cases are tested via other tests
+    EXPECT_THROW(message_render.beginSection(Message::SECTION_QUESTION),
+                 InvalidMessageSection);
+    EXPECT_THROW(message_render.beginSection(bogus_section), OutOfRange);
+}
+
+TEST_F(MessageTest, badEndSection) {
+    // valid cases are tested via other tests
+    EXPECT_THROW(message_render.endSection(Message::SECTION_QUESTION),
+                 InvalidMessageSection);
+    EXPECT_THROW(message_render.endSection(bogus_section), OutOfRange);
+}
+
 TEST_F(MessageTest, fromWire) {
     factoryFromFile(message_parse, "message_fromWire1");
     EXPECT_EQ(0x1035, message_parse.getQid());
     EXPECT_EQ(Opcode::QUERY(), message_parse.getOpcode());
     EXPECT_EQ(Rcode::NOERROR(), message_parse.getRcode());
-    EXPECT_TRUE(message_parse.getHeaderFlag(MessageFlag::QR()));
-    EXPECT_TRUE(message_parse.getHeaderFlag(MessageFlag::RD()));
-    EXPECT_TRUE(message_parse.getHeaderFlag(MessageFlag::AA()));
+    EXPECT_TRUE(message_parse.getHeaderFlag(Message::HEADERFLAG_QR));
+    EXPECT_TRUE(message_parse.getHeaderFlag(Message::HEADERFLAG_RD));
+    EXPECT_TRUE(message_parse.getHeaderFlag(Message::HEADERFLAG_AA));
 
     QuestionPtr q = *message_parse.beginQuestion();
     EXPECT_EQ(test_name, q->getName());
     EXPECT_EQ(RRType::A(), q->getType());
     EXPECT_EQ(RRClass::IN(), q->getClass());
-    EXPECT_EQ(1, message_parse.getRRCount(Section::QUESTION()));
-    EXPECT_EQ(2, message_parse.getRRCount(Section::ANSWER()));
-    EXPECT_EQ(0, message_parse.getRRCount(Section::AUTHORITY()));
-    EXPECT_EQ(0, message_parse.getRRCount(Section::ADDITIONAL()));
+    EXPECT_EQ(1, message_parse.getRRCount(Message::SECTION_QUESTION));
+    EXPECT_EQ(2, message_parse.getRRCount(Message::SECTION_ANSWER));
+    EXPECT_EQ(0, message_parse.getRRCount(Message::SECTION_AUTHORITY));
+    EXPECT_EQ(0, message_parse.getRRCount(Message::SECTION_ADDITIONAL));
 
-    RRsetPtr rrset = *message_parse.beginSection(Section::ANSWER());
+    RRsetPtr rrset = *message_parse.beginSection(Message::SECTION_ANSWER);
     EXPECT_EQ(test_name, rrset->getName());
     EXPECT_EQ(RRType::A(), rrset->getType());
     EXPECT_EQ(RRClass::IN(), rrset->getClass());
@@ -157,21 +326,17 @@ TEST_F(MessageTest, toWire) {
     message_render.setQid(0x1035);
     message_render.setOpcode(Opcode::QUERY());
     message_render.setRcode(Rcode::NOERROR());
-    message_render.setHeaderFlag(MessageFlag::QR());
-    message_render.setHeaderFlag(MessageFlag::RD());
-    message_render.setHeaderFlag(MessageFlag::AA());
+    message_render.setHeaderFlag(Message::HEADERFLAG_QR, true);
+    message_render.setHeaderFlag(Message::HEADERFLAG_RD, true);
+    message_render.setHeaderFlag(Message::HEADERFLAG_AA, true);
     message_render.addQuestion(Question(Name("test.example.com"), RRClass::IN(),
                                         RRType::A()));
-    RRsetPtr rrset = RRsetPtr(new RRset(Name("test.example.com"), RRClass::IN(),
-                                        RRType::A(), RRTTL(3600)));
-    rrset->addRdata(in::A("192.0.2.1"));
-    rrset->addRdata(in::A("192.0.2.2"));
-    message_render.addRRset(Section::ANSWER(), rrset);
-
-    EXPECT_EQ(1, message_render.getRRCount(Section::QUESTION()));
-    EXPECT_EQ(2, message_render.getRRCount(Section::ANSWER()));
-    EXPECT_EQ(0, message_render.getRRCount(Section::AUTHORITY()));
-    EXPECT_EQ(0, message_render.getRRCount(Section::ADDITIONAL()));
+    message_render.addRRset(Message::SECTION_ANSWER, rrset_a);
+
+    EXPECT_EQ(1, message_render.getRRCount(Message::SECTION_QUESTION));
+    EXPECT_EQ(2, message_render.getRRCount(Message::SECTION_ANSWER));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_AUTHORITY));
+    EXPECT_EQ(0, message_render.getRRCount(Message::SECTION_ADDITIONAL));
 
     message_render.toWire(renderer);
     vector<unsigned char> data;

src/lib/python/isc/notify/notify_out.py

@@ -402,13 +402,13 @@ class NotifyOut:
         msg.set_qid(qid)
         msg.set_opcode(Opcode.NOTIFY())
         msg.set_rcode(Rcode.NOERROR())
-        msg.set_header_flag(MessageFlag.AA())
+        msg.set_header_flag(Message.HEADERFLAG_AA)
         question = Question(Name(zone_name), RRClass(zone_class), RRType('SOA'))
         msg.add_question(question)
         # Add soa record to answer section
         soa_record = sqlite3_ds.get_zone_rrset(zone_name, zone_name, 'SOA', self._db_file) 
         rrset_soa = self._create_rrset_from_db_record(soa_record[0], zone_class)
-        msg.add_rrset(Section.ANSWER(), rrset_soa)
+        msg.add_rrset(Message.SECTION_ANSWER, rrset_soa)
         return msg, qid
 
     def _handle_notify_reply(self, zone_notify_info, msg_data):
@@ -420,7 +420,7 @@ class NotifyOut:
         try:
             errstr = 'notify reply error: '
             msg.from_wire(msg_data)
-            if not msg.get_header_flag(MessageFlag.QR()):
+            if not msg.get_header_flag(Message.HEADERFLAG_QR):
                 self._log_msg('error', errstr + 'bad flags')
                 return _BAD_QR