using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using TinyRadius.Net.Dictionaries;
using TinyRadius.Net.Util;
namespace TinyRadius.Net.Attributes
{
/// <summary>
/// This class represents a "Vendor-Specific" attribute.
/// </summary>
public class VendorSpecificAttribute : RadiusAttribute
{
/// <summary>
/// Radius attribute type code for Vendor-Specific
/// </summary>
public static readonly int VENDOR_SPECIFIC = 26;
/// <summary>
/// Sub attributes. Only set if isRawData == false.
/// </summary>
private List<RadiusAttribute> subAttributes = new List<RadiusAttribute>();
/// <summary>
/// Constructs an empty Vendor-Specific attribute that can be read from a
/// Radius packet.
/// </summary>
public VendorSpecificAttribute()
{
}
/// <summary>
/// Constructs a new Vendor-Specific attribute to be sent.
/// @param vendorId vendor ID of the sub-attributes
/// </summary>
public VendorSpecificAttribute(int vendorId)
{
Type = VENDOR_SPECIFIC;
ChildVendorId = vendorId;
}
/// <summary>
/// Gets or sets the vendor ID of the child attributes.
/// @param childVendorId
/// </summary>
public int ChildVendorId { get; set; }
public override IWritableDictionary Dictionary
{
get { return base.Dictionary; }
set
{
base.Dictionary = value;
foreach (RadiusAttribute a in subAttributes)
{
a.Dictionary = value;
}
}
}
/// <summary>
/// Returns the list of sub-attributes.
/// @return ArrayList of RadiusAttribute objects
/// </summary>
public List<RadiusAttribute> SubAttributes
{
get { return subAttributes; }
}
/// <summary>
/// Adds a sub-attribute to this attribute.
/// @param attribute sub-attribute to add
/// </summary>
public void AddSubAttribute(RadiusAttribute attribute)
{
if (attribute.VendorId != ChildVendorId)
throw new ArgumentException(
"sub attribut has incorrect vendor ID");
subAttributes.Add(attribute);
}
/// <summary>
/// Adds a sub-attribute with the specified name to this attribute.
/// @param name name of the sub-attribute
/// @param value value of the sub-attribute
/// @exception ArgumentException invalid sub-attribute name or value
/// </summary>
public void AddSubAttribute(String name, String value)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentException("type name is empty");
if (string.IsNullOrEmpty(value))
throw new ArgumentException("value is empty");
AttributeType type = Dictionary.GetAttributeTypeByName(name);
if (type == null)
throw new ArgumentException("unknown attribute type '"
+ name + "'");
if (type.VendorId == -1)
throw new ArgumentException("attribute type '" + name
+ "' is not a Vendor-Specific sub-attribute");
if (type.VendorId != ChildVendorId)
throw new ArgumentException("attribute type '" + name
+ "' does not belong to vendor ID " + ChildVendorId);
RadiusAttribute attribute = CreateRadiusAttribute(Dictionary,
ChildVendorId, type.TypeCode);
attribute.Value = value;
AddSubAttribute(attribute);
}
/// <summary>
/// Removes the specified sub-attribute from this attribute.
/// @param attribute RadiusAttribute to remove
/// </summary>
public void RemoveSubAttribute(RadiusAttribute attribute)
{
if (!subAttributes.Remove(attribute))
throw new ArgumentException("no such attribute");
}
/// <summary>
/// Returns all sub-attributes of this attribut which have the given type.
/// @param attributeType type of sub-attributes to get
/// @return list of RadiusAttribute objects, does not return null
/// </summary>
public List<RadiusAttribute> GetSubAttributes(int attributeType)
{
if (attributeType < 1 || attributeType > 255)
throw new ArgumentException(
"sub-attribute type out of bounds");
var result = new List<RadiusAttribute>();
foreach (RadiusAttribute a in subAttributes)
{
if (attributeType == a.Type)
result.Add(a);
}
return result;
}
/// <summary>
/// Returns a sub-attribute of the given type which may only occur once in
/// this attribute.
/// @param type sub-attribute type
/// @return RadiusAttribute object or null if there is no such sub-attribute
/// @throws NotImplementedException if there are multiple occurences of the
/// requested sub-attribute type
/// </summary>
public RadiusAttribute GetSubAttribute(int type)
{
List<RadiusAttribute> attrs = GetSubAttributes(type);
if (attrs.Count > 1)
throw new NotImplementedException(
"multiple sub-attributes of requested type " + type);
else if (attrs.Count == 0)
return null;
else
return attrs[0];
}
/// <summary>
/// Returns a single sub-attribute of the given type name.
/// @param type attribute type name
/// @return RadiusAttribute object or null if there is no such attribute
/// @throws NotImplementedException if the attribute occurs multiple times
/// </summary>
public RadiusAttribute GetSubAttribute(String type)
{
if (string.IsNullOrEmpty(type))
throw new ArgumentException("type name is empty");
AttributeType t = Dictionary.GetAttributeTypeByName(type);
if (t == null)
throw new ArgumentException("unknown attribute type name '"
+ type + "'");
if (t.VendorId != ChildVendorId)
throw new ArgumentException("vendor ID mismatch");
return GetSubAttribute(t.TypeCode);
}
/// <summary>
/// Returns the value of the Radius attribute of the given type or null if
/// there is no such attribute.
/// @param type attribute type name
/// @return value of the attribute as a string or null if there is no such
/// attribute
/// @throws ArgumentException if the type name is unknown
/// @throws NotImplementedException attribute occurs multiple times
/// </summary>
public String GetSubAttributeValue(String type)
{
RadiusAttribute attr = GetSubAttribute(type);
if (attr == null)
return null;
else
return attr.Value;
}
/// <summary>
/// Renders this attribute as a byte array.
/// @see TinyRadius.attribute.RadiusAttribute#writeAttribute()
/// </summary>
public override byte[] WriteAttribute()
{
// write vendor ID
var bos = new MemoryStream(255);
bos.WriteByte(Convert.ToByte(ChildVendorId >> 24 & 0x0ff));
bos.WriteByte(Convert.ToByte(ChildVendorId >> 16 & 0x0ff));
bos.WriteByte(Convert.ToByte(ChildVendorId >> 8 & 0x0ff));
bos.WriteByte(Convert.ToByte(ChildVendorId & 0x0ff));
// write sub-attributes
try
{
foreach (RadiusAttribute a in subAttributes)
{
byte[] c = a.WriteAttribute();
bos.Write(c, 0, c.Length);
}
}
catch (IOException ioe)
{
// occurs never
throw new NotImplementedException("error writing data", ioe);
}
// check data Length
byte[] attrData = bos.ToArray();
int len = attrData.Length;
if (len > 253)
throw new NotImplementedException("Vendor-Specific attribute too long: "
+ len);
// compose attribute
var attr = new byte[len + 2];
attr[0] = Convert.ToByte(VENDOR_SPECIFIC); // code
attr[1] = (byte) (len + 2); // Length
Array.Copy(attrData, 0, attr, 2, len);
return attr;
}
/// <summary>
/// Reads a Vendor-Specific attribute and decodes the internal sub-attribute
/// structure.
/// @see TinyRadius.attribute.RadiusAttribute#readAttribute(byte[], int,
/// int)
/// </summary>
public override void ReadAttribute(byte[] data, int offset, int length)
{
// check Length
if (length < 6)
throw new RadiusException("Vendor-Specific attribute too short: "
+ length);
int vsaCode = data[offset];
int vsaLen = (data[offset + 1] & 0x000000ff) - 6;
if (vsaCode != VENDOR_SPECIFIC)
throw new RadiusException("not a Vendor-Specific attribute");
// read vendor ID and vendor data
/*
* int vendorId = (data[offset + 2] << 24 | data[offset + 3] << 16 |
* data[offset + 4] << 8 | ((int)data[offset + 5] & 0x000000ff));
*/
int vendorId = (UnsignedByteToInt(data[offset + 2]) << 24
| UnsignedByteToInt(data[offset + 3]) << 16
| UnsignedByteToInt(data[offset + 4]) << 8 | UnsignedByteToInt(data[offset + 5]));
ChildVendorId = vendorId;
// validate sub-attribute structure
int pos = 0;
int count = 0;
while (pos < vsaLen)
{
if (pos + 1 >= vsaLen)
throw new RadiusException("Vendor-Specific attribute malformed");
// int vsaSubType = data[(offset + 6) + pos] & 0x0ff;
int vsaSubLen = data[(offset + 6) + pos + 1] & 0x0ff;
pos += vsaSubLen;
count++;
}
if (pos != vsaLen)
throw new RadiusException("Vendor-Specific attribute malformed");
subAttributes = new List<RadiusAttribute>(count);
pos = 0;
while (pos < vsaLen)
{
int subtype = data[(offset + 6) + pos] & 0x0ff;
int sublength = data[(offset + 6) + pos + 1] & 0x0ff;
RadiusAttribute a = CreateRadiusAttribute(Dictionary,
vendorId, subtype);
a.ReadAttribute(data, (offset + 6) + pos, sublength);
subAttributes.Add(a);
pos += sublength;
}
}
private static int UnsignedByteToInt(byte b)
{
return b & 0xFF;
}
/// <summary>
/// Returns a string representation for debugging.
/// @see TinyRadius.attribute.RadiusAttribute#toString()
/// </summary>
public override String ToString()
{
var sb = new StringBuilder();
sb.Append("Vendor-Specific: ");
int vendorId = ChildVendorId;
String vendorName = Dictionary.GetVendorName(vendorId);
if (vendorName != null)
{
sb.Append(vendorName)
.Append(" (")
.Append(vendorId)
.Append(")");
}
else
{
sb.Append("vendor ID ");
sb.Append(vendorId);
}
foreach (RadiusAttribute attr in SubAttributes)
{
sb.Append("\n");
sb.Append(attr.ToString());
}
return sb.ToString();
}
}
}