radius_parser.cxx

Diameter协议栈

                                AAAMessageBlock &buf) 
{
   try {
       RADIUS_DictAttribute &dict = RADIUS_DICT_ATTR(attr->Type());
       RADIUS_FORWARD_PARSER_MAP(dict.DataType(), attr, buf);
   }
   catch (...) {
   	   std::string errMsg
   	       ("Parsing error, AVP not found in dictionary, avp is " + attr->Type());
       throw RADIUS_Exception(RADIUS_UNKNOWN_AVP, errMsg);
   }
}

void RADIUS_AttrParser::reverse(RADIUS_AttrBase *&attr, 
                                AAAMessageBlock &buf) 
{
   RADIUS_OCTET *type = (RADIUS_OCTET*)buf.rd_ptr();
   RADIUS_OCTET *length = (RADIUS_OCTET*)type + sizeof(RADIUS_OCTET);
   size_t readSpace = m_TotalLength - (buf.rd_ptr() - buf.base());

   if (*length > readSpace) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
                 "AVP has length exceeding packet");
   }
   else if (*length <= 0) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
                 "AVP has length of zero");
   }
   	   
   try {
       RADIUS_DictAttribute &dict = RADIUS_DICT_ATTR(*type);
       RADIUS_REVERSE_PARSER_MAP(dict.DataType(), attr, buf);
   }
   catch (...) {
   	   std::string errMsg
   	       ("Parsing error, AVP not found in dictionary, avp is " + *type);
       throw RADIUS_Exception(RADIUS_UNKNOWN_AVP, errMsg);
   }
}

void RADIUS_AttrListParser::forward(RADIUS_Packet &pkt, 
                                    AAAMessageBlock &buf)
{
   RADIUS_PARSER_DEBUG_LOG(("PARSER: Attribute forward parsing\n"));
   
   RADIUS_AttrParser attrParser;
   RADIUS_AttrListIter i = pkt.Attributes().begin();
   for (; i != pkt.Attributes().end(); i ++) {
   	  attrParser.forward((*i), buf);
   }
}

void RADIUS_AttrListParser::reverse(RADIUS_Packet &pkt, 
                                    AAAMessageBlock &buf)
{
   RADIUS_PARSER_DEBUG_LOG(("PARSER: Attribute reverse parsing\n"));
   
   RADIUS_AttrBase *attr = NULL;
   RADIUS_AttrParser attrParser(buf.length() + RADIUS_PKT_MIN_SIZE);
   while ((buf.rd_ptr() - buf.base()) < pkt.Length()) {
   	  attrParser.reverse(attr, buf);
   	  pkt.Attributes().Add(attr);
   }
}

void RADIUS_HeaderParser::reverse(RADIUS_Packet &pkt, 
                                  AAAMessageBlock &buf)
{
   if (buf.size() < RADIUS_PKT_MIN_SIZE) {
       std::string errMsg
  	           ("Parsing error, no more space left on buf for msg ");
       errMsg += pkt.Code();
       throw RADIUS_Exception(RADIUS_BUF_TO_SMALL, errMsg);
   }
   
   RADIUS_OCTET *p = (RADIUS_OCTET*)buf.rd_ptr();

   pkt.Code() = *p; p++;
   pkt.Id() = *p; p++;
   pkt.Length() = ACE_NTOHS(*((RADIUS_SHORT*)p)); p += 2;
   ACE_OS::memcpy(pkt.Authenticator(), p, 
                  sizeof(RADIUS_OCTET)*
                  RADIUS_PktHeader::AuthenticatorLen);
   
   p += sizeof(RADIUS_OCTET)*RADIUS_PktHeader::AuthenticatorLen;
   
   if (pkt.Length() > RADIUS_PKT_MAX_SIZE) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
  	                          "Parsing error, packet length greater than allowed");
   }
   else if (pkt.Length() < RADIUS_PKT_MIN_SIZE) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
  	                          "Parsing error, packet less than allowed radius header");
   }
   else if (! ValidateCode(pkt)) {
       throw RADIUS_Exception(RADIUS_UNKNOWN_CODE, 
  	                          "Parsing error, packet has unknown msg code");
   }
   
   buf.rd_ptr((char*)p);
   
   RADIUS_PARSER_DEBUG_LOG(("PARSER: message header reverse, [%d, %d, %d], Auth[%d,%d,%d,%d]\n",
       pkt.Code(), pkt.Id(), pkt.Length(), 
       ((int*)pkt.Authenticator())[0],
       ((int*)pkt.Authenticator())[1],
       ((int*)pkt.Authenticator())[2],
       ((int*)pkt.Authenticator())[3]));
}

void RADIUS_HeaderParser::forward(RADIUS_Packet &pkt, 
                                  AAAMessageBlock &buf)
{
   if (buf.size() < RADIUS_PKT_MIN_SIZE) {
       std::string errMsg
  	           ("Parsing error, raw buffer less than header size for msg ");
       errMsg += pkt.Code();
       throw RADIUS_Exception(RADIUS_BUF_TO_SMALL, errMsg);
   }
   else if (! ValidateCode(pkt)) {
       throw RADIUS_Exception(RADIUS_UNKNOWN_CODE, 
  	                          "Parsing error, packet has unknown msg code");
   }
   
   buf.wr_ptr(buf.base());

   RADIUS_OCTET *p = (RADIUS_OCTET*)buf.base();

   *(p) = pkt.Code();
   *(++p) = pkt.Id();
   *((RADIUS_SHORT*)(++p)) = ACE_HTONS(pkt.Length());
   p += 2;
   ACE_OS::memcpy(p, pkt.Authenticator(),
                  sizeof(RADIUS_OCTET)*
                  RADIUS_PktHeader::AuthenticatorLen);

   p += sizeof(RADIUS_OCTET)*RADIUS_PktHeader::AuthenticatorLen;
   buf.wr_ptr((char*)p);
   
   RADIUS_PARSER_DEBUG_LOG(("PARSER: message header forward, [%d, %d, %d], Auth[%d,%d,%d,%d]\n",
       pkt.Code(), pkt.Id(), pkt.Length(), 
       ((int*)pkt.Authenticator())[0],
       ((int*)pkt.Authenticator())[1],
       ((int*)pkt.Authenticator())[2],
       ((int*)pkt.Authenticator())[3]));
}

void RADIUS_PacketParser::forward(RADIUS_Packet &pkt, 
                                  AAAMessageBlock &buf)
{
   buf.rd_ptr(buf.base());
   buf.wr_ptr(buf.base() + RADIUS_PKT_MIN_SIZE);
   
   RADIUS_AttrListParser attrParser;
   attrParser.forward(pkt, buf);
   
   pkt.Length() = RADIUS_PKT_MIN_SIZE;
   RADIUS_AttrListIter i = pkt.Attributes().begin();
   for (; i != pkt.Attributes().end(); i ++) {
   	  pkt.Length() += (*i)->Length();
   }   
   
   buf.wr_ptr(buf.base());
   RADIUS_HeaderParser hdrParser;
   hdrParser.forward(pkt, buf);   
   buf.wr_ptr(buf.base() + pkt.Length());
}

void RADIUS_PacketParser::reverse(RADIUS_Packet &pkt, 
                                  AAAMessageBlock &buf)
{
   if (buf.length() > RADIUS_PKT_MAX_SIZE) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
  	                          "Parsing error, udp packet length greater than allowed");
   }
   else if (buf.size() < RADIUS_PKT_MIN_SIZE) {
       throw RADIUS_Exception(RADIUS_MALFORMED_PACKET, 
  	                          "Parsing error, udp packet less than allowed radius header");
   }

   buf.rd_ptr(buf.base());
   
   RADIUS_HeaderParser hdrParser;
   hdrParser.reverse(pkt, buf);
   
   RADIUS_AttrListParser attrParser;
   attrParser.reverse(pkt, buf);
}

void RADIUS_PacketDump::Dump(RADIUS_Packet &pkt)
{
	std::cout << "*** packet dump ***"        << std::endl;
	std::cout << "Code   : " << (int)pkt.Code()    << std::endl;
	std::cout << "Id     : " << (int)pkt.Id()      << std::endl;
	std::cout << "Length : " << (int)pkt.Length()  << std::endl;
    std::cout << "Auth   : " << std::endl;
	for (int i = 0; i < RADIUS_PktHeader::AuthenticatorLen; i++) {
        std::cout << pkt.Authenticator()[i] << std::endl;
	}
	
    RADIUS_AttrListIter i = pkt.Attributes().begin();
    for (; i != pkt.Attributes().end(); i ++) {
        std::cout << "  AVP  :" << (int)(*i)->Type();
        std::cout << ", Length :" << (int)(*i)->Length() << std::endl;	
    }	
}