Classes
class	ColorAttribute

Enumerations
enum	Color { GREEN, YELLOW, RED }

Functions
double	parseInformationRate (const char attrValue, const char attrName, IInterfaceTable *ift, cSimpleModule &owner, int defaultValue)
	Parses the information rate parameter (bits/sec). More...

int	parseIntAttribute (const char attrValue, const char attrName, bool isOptional=true)
	Parses an integer attribute. More...

int	parseProtocol (const char attrValue, const char attrName)
	Parses an IP protocol number. More...

int	parseDSCP (const char attrValue, const char attrName)
	Parses a Diffserv code point. More...

void	parseDSCPs (const char attrValue, const char attrName, std::vector< int > &result)
	Parses a space separated list of DSCP values and puts them into the result vector. More...

std::string	dscpToString (int dscp)
	Returns the string representation of the given DSCP value. More...

std::string	colorToString (int color)
	Returns the string representation of the given color. More...

double	getInterfaceDatarate (IInterfaceTable ift, cSimpleModule interfaceModule)
	Returns the datarate of the interface containing the given module. More...

int	getColor (cPacket *packet)
	Returns the color of the packet. More...

void	setColor (cPacket *packet, int color)
	Sets the color of the packet. More...

Variables
cEnum *	dscpEnum = nullptr

cEnum *	protocolEnum = nullptr

Enumeration Type Documentation

◆ Color

enum inet::DiffservUtil::Color

Enumerator
GREEN
YELLOW
RED

17 { GREEN, YELLOW, RED };

Function Documentation

◆ colorToString()

std::string inet::DiffservUtil::colorToString ( int color )

Returns the string representation of the given color.

For values defined in IMeter.h it returns their name, other values are returned as decimal constants.

 {
     switch (color) {
         case GREEN:
             return "green";
  
         case YELLOW:
             return "yellow";
  
         case RED:
             return "red";
  
         default:
             return ltostr(color);
     }
 }

Referenced by inet::DiffservUtil::ColorAttribute::str().

◆ dscpToString()

std::string inet::DiffservUtil::dscpToString ( int dscp )

Returns the string representation of the given DSCP value.

Values defined in DSCP.msg are returned as "BE", "AF11", etc., others are returned as a decimal number.

 {
     if (!dscpEnum)
         dscpEnum = cEnum::get("inet::Dscp");
     const char *name = dscpEnum->getStringFor(dscp);
     if (name) {
         if (!strncmp(name, "DSCP_", 5))
             name += 5;
         return name;
     }
     else
         return ltostr(dscp);
 }

Referenced by inet::DscpMarker::markPacket().

◆ getColor()

int inet::DiffservUtil::getColor ( cPacket * packet )

Returns the color of the packet.

The color was set by a previous meter component. Returns -1, if the color was not set.

 {
     ColorAttribute *attr = dynamic_cast<ColorAttribute *>(packet->getParList().get("dscolor"));
     return attr ? attr->color : -1;
 }

Referenced by inet::TokenBucketMeter::meterPacket(), inet::SingleRateThreeColorMeter::meterPacket(), and inet::TwoRateThreeColorMeter::meterPacket().

◆ getInterfaceDatarate()

double inet::DiffservUtil::getInterfaceDatarate	(	IInterfaceTable *	ift,
		cSimpleModule *	interfaceModule
	)

Returns the datarate of the interface containing the given module.

Returns -1, if the interface entry not found.

 {
     NetworkInterface *ie = ift ? ift->findInterfaceByInterfaceModule(interfaceModule) : nullptr;
     return ie ? ie->getDatarate() : -1;
 }

Referenced by parseInformationRate().

◆ parseDSCP()

int inet::DiffservUtil::parseDSCP	(	const char *	attrValue,
		const char *	attrName
	)

Parses a Diffserv code point.

Recognizes the names defined in Dscp.msg (e.g. "BE", "AF11"), and accepts decimal/octal/hex/binary numbers.

 {
     if (opp_isempty(attrValue))
         throw cRuntimeError("missing %s attribute", attrName);
     if (isdigit(*attrValue)) {
         int dscp = parseIntAttribute(attrValue, attrName);
         if (dscp < 0 || dscp >= DSCP_MAX)
             throw cRuntimeError("value of %s attribute is out of range [0,%d)", attrName, DSCP_MAX);
         return dscp;
     }
     if (!dscpEnum)
         dscpEnum = cEnum::get("inet::Dscp");
     char name[20];
     strcpy(name, "DSCP_");
     const char *src;
     char *dest;
     for (src = attrValue, dest = name + 5; *src; ++src, ++dest)
         *dest = toupper(*src);
     *dest = '\0';
  
     int dscp = dscpEnum->lookup(name);
     if (dscp < 0)
         throw cRuntimeError("malformed %s attribute", attrName);
     return dscp;
 }

Referenced by parseDSCPs().

◆ parseDSCPs()

void inet::DiffservUtil::parseDSCPs	(	const char *	attrValue,
		const char *	attrName,
		std::vector< int > &	result
	)

Parses a space separated list of DSCP values and puts them into the result vector.

"*" is interpreted as all possible DSCP values (i.e. the 0..63 range).

 {
     if (opp_isempty(attrValue))
         return;
     if (*attrValue == '*' && *(attrValue + 1) == '\0') {
         for (int dscp = 0; dscp < DSCP_MAX; ++dscp)
             result.push_back(dscp);
     }
     else {
         cStringTokenizer tokens(attrValue);
         while (tokens.hasMoreTokens())
             result.push_back(parseDSCP(tokens.nextToken(), attrName));
     }
 }

Referenced by inet::DscpMarker::initialize(), and inet::BehaviorAggregateClassifier::initialize().

◆ parseInformationRate()

double inet::DiffservUtil::parseInformationRate	(	const char *	attrValue,
		const char *	attrName,
		IInterfaceTable *	ift,
		cSimpleModule &	owner,
		int	defaultValue
	)

Parses the information rate parameter (bits/sec).

Supported formats:

absolute (e.g. 10Mbps)
relative to the datarate of the interface (e.g. 10%)

 {
     if (opp_isempty(attrValue))
         return defaultValue;
  
     const char *percentPtr = strchr(attrValue, '%');
     if (percentPtr) {
         char *e;
         double percent = strtod(attrValue, &e);
         if (e != percentPtr)
             throw cRuntimeError("malformed %s attribute: %s", attrName, attrValue);
         if (percent < 0.0 || percent > 100.0)
             throw cRuntimeError("%s must be between 0%% and 100%%, found: %s", attrName, attrValue);
  
         double datarate = getInterfaceDatarate(ift, &owner);
         if (datarate < 0.0)
             throw cRuntimeError("cannot determine datarate for module %s, (no interface table in the node?)", owner.getFullPath().c_str());
  
         return (percent / 100.0) * datarate;
     }
     else {
         char *unit;
         double datarate = strtod(attrValue, &unit);
         return cNEDValue::convertUnit(datarate, unit, "bps");
     }
 }

Referenced by inet::TokenBucketMeter::initialize(), inet::SingleRateThreeColorMeter::initialize(), and inet::TwoRateThreeColorMeter::initialize().

◆ parseIntAttribute()

int inet::DiffservUtil::parseIntAttribute	(	const char *	attrValue,
		const char *	attrName,
		bool	isOptional = `true`
	)

Parses an integer attribute.

Supports decimal, octal ("0" prefix), hexadecimal ("0x" prefix), and binary ("0b" prefix) bases.

 {
     if (opp_isempty(attrValue)) {
         if (isOptional)
             return -1;
         else
             throw cRuntimeError("missing %s attribute", attrName);
     }
  
     unsigned long num;
     char *endp;
     if (*attrValue == '0' && *(attrValue + 1) == 'b') // 0b prefix for binary
         num = strtoul(attrValue + 2, &endp, 2);
     else
         num = strtoul(attrValue, &endp, 0); // will handle hex/octal/decimal
  
     if (*endp != '\0')
         throw cRuntimeError("malformed %s attribute: %s", attrName, attrValue);
  
     if (num > INT_MAX)
         throw cRuntimeError("attribute %s is too large: %s", attrName, attrValue);
  
     return (int)num;
 }

Referenced by inet::MultiFieldClassifier::configureFilters(), parseDSCP(), and parseProtocol().

◆ parseProtocol()

int inet::DiffservUtil::parseProtocol	(	const char *	attrValue,
		const char *	attrName
	)

Parses an IP protocol number.

Recognizes the names defined in IpProtocolId.msg (e.g. "Udp", "udp", "Tcp"), and accepts decimal/octal/hex/binary numbers.

 {
     if (opp_isempty(attrValue))
         return -1;
     if (isdigit(*attrValue))
         return parseIntAttribute(attrValue, attrName);
     if (!protocolEnum)
         protocolEnum = cEnum::get("inet::IpProtocolId");
     char name[20];
     strcpy(name, "IP_PROT_");
     char *dest;
     for (dest = name + 8; *attrValue; ++dest, ++attrValue)
         *dest = toupper(*attrValue);
     *dest = '\0';
  
     return protocolEnum->lookup(name);
 }

Referenced by inet::MultiFieldClassifier::configureFilters().

◆ setColor()

void inet::DiffservUtil::setColor	(	cPacket *	packet,
		int	color
	)

Sets the color of the packet.

The color is stored in the parlist of the cPacket object.

 {
     ColorAttribute *attr = dynamic_cast<ColorAttribute *>(packet->getParList().get("dscolor"));
     if (attr)
         attr->color = color;
     else
         packet->addObject(new ColorAttribute(color));
 }

Referenced by inet::TokenBucketMeter::meterPacket(), inet::SingleRateThreeColorMeter::meterPacket(), and inet::TwoRateThreeColorMeter::meterPacket().

Variable Documentation

◆ dscpEnum

cEnum* inet::DiffservUtil::dscpEnum = nullptr

Referenced by dscpToString(), and parseDSCP().

◆ protocolEnum

cEnum* inet::DiffservUtil::protocolEnum = nullptr

Referenced by parseProtocol().

Classes

Enumerations

Functions

Variables