using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Xml.Serialization;
using NewLife.Messaging;
using NewLife.Reflection;
using NewLife.Serialization;
namespace NewLife.Net.Dhcp
{
/// <summary>DHCP实体</summary>
public class DhcpEntity : Message<DhcpEntity>
{
#region 属性
private Byte _MessageType = 1;
/// <summary>消息类型。若是client送给server的封包,设为1,反向为2</summary>
public Byte MessageType { get { return _MessageType; } set { _MessageType = value; } }
private Byte _HardwareType = 1;
/// <summary>硬件类型</summary>
public Byte HardwareType { get { return _HardwareType; } set { _HardwareType = value; } }
private Byte _HardwareAddressLength = 6;
/// <summary>硬件地址长度</summary>
public Byte HardAddrLength { get { return _HardwareAddressLength; } set { _HardwareAddressLength = value; } }
private Byte _Hops;
/// <summary>属性说明</summary>
public Byte Hops { get { return _Hops; } set { _Hops = value; } }
private Int32 _TransactionID;
/// <summary>会话编号</summary>
public Int32 TransactionID { get { return _TransactionID; } set { _TransactionID = value; } }
private Int16 _Seconds;
/// <summary>秒数</summary>
public Int16 Seconds { get { return _Seconds; } set { _Seconds = value; } }
private UInt16 _BootpFlags = 0x8000;
/// <summary>属性说明</summary>
public UInt16 BootpFlags { get { return _BootpFlags; } set { _BootpFlags = value; } }
[FieldSize(4)]
private Byte[] _ClientIPAddress;
/// <summary>客户端IP地址</summary>
public Byte[] ClientIP { get { return _ClientIPAddress; } set { _ClientIPAddress = value; } }
[FieldSize(4)]
private Byte[] _YourIPAddress;
/// <summary>属性说明</summary>
public Byte[] YourIP { get { return _YourIPAddress; } set { _YourIPAddress = value; } }
[FieldSize(4)]
private Byte[] _NextServerIPAddress;
/// <summary>属性说明</summary>
public Byte[] NextServerIP { get { return _NextServerIPAddress; } set { _NextServerIPAddress = value; } }
[FieldSize(4)]
private Byte[] _RelayAgentIPAddress;
/// <summary>属性说明</summary>
public Byte[] RelayAgentIP { get { return _RelayAgentIPAddress; } set { _RelayAgentIPAddress = value; } }
[FieldSize(16)]
private Byte[] _ClientMACAddress;
/// <summary>客户端MAC地址。占用16字节,实际内存长度由_HardwareAddressLength决定</summary>
public Byte[] ClientMac { get { return _ClientMACAddress; } set { _ClientMACAddress = value; } }
[FieldSize(64)]
private String _ServerName;
/// <summary>服务器名</summary>
public String ServerName { get { return _ServerName; } set { _ServerName = value; } }
[FieldSize(128)]
private String _BootFileName;
/// <summary>启动文件名</summary>
public String BootFileName { get { return _BootFileName; } set { _BootFileName = value; } }
private Int32 _Magic = 0x63825363;
/// <summary>幻数</summary>
public Int32 Magic { get { return _Magic; } set { _Magic = value; } }
#endregion
#region 扩展属性
[NonSerialized]
private List<DhcpOption> _Options = new List<DhcpOption>();
/// <summary>可选项</summary>
public List<DhcpOption> Options { get { return _Options; } set { _Options = value; } }
/// <summary>获取可选项</summary>
/// <param name="type"></param>
/// <param name="add"></param>
/// <returns></returns>
public DhcpOption Get(DhcpOptions type, Boolean add = false)
{
var opt = Options.FirstOrDefault(e => e.Option == type);
if (opt == null && add)
{
opt = new DhcpOption();
Options.Add(opt);
}
return opt;
}
/// <summary>消息种类</summary>
[XmlIgnore]
public Dhcp.DhcpMessageType Kind
{
get
{
var opt = Get(DhcpOptions.MessageType);
var b = opt != null ? opt.Data[0] : 0;
return (DhcpMessageType)b;
}
set
{
var opt = Get(DhcpOptions.MessageType, true);
opt.SetType(value);
}
}
#endregion
#region 读写核心
/// <summary>读取扩展属性</summary>
/// <param name="stream"></param>
/// <param name="context"></param>
/// <returns></returns>
public override Boolean Read(Stream stream, Object context)
{
if (!base.Read(stream, context)) return false;
// 读取扩展可选项
if (stream.Position < stream.Length)
{
var fm = CreateFormatter(true);
fm.Stream = stream;
while (stream.Position < stream.Length)
{
if (stream.ReadByte() == 0xFF) break;
stream.Position--;
var opt = fm.Read<DhcpOption>();
Options.Add(opt);
if (opt.Option == DhcpOptions.End) break;
}
}
return true;
}
/// <summary>写入可选项</summary>
/// <param name="stream"></param>
/// <param name="context"></param>
public override void Write(Stream stream, Object context)
{
base.Write(stream, context);
var binary = CreateFormatter(true) as Binary;
binary.Stream = stream;
foreach (var opt in Options)
{
if (opt.Option == DhcpOptions.End) break;
binary.Write(opt);
}
// 写入可选项结束符
stream.Write(0xFF);
}
/// <summary>使用字段大小</summary>
/// <param name="isRead"></param>
/// <returns></returns>
protected override IFormatterX CreateFormatter(Boolean isRead)
{
var fm = base.CreateFormatter(isRead) as Binary;
fm.UseFieldSize = true;
//fm.Log = XTrace.Log;
return fm;
}
#endregion
#region 辅助
/// <summary>显示扩展属性</summary>
/// <param name="pi"></param>
/// <param name="len"></param>
/// <param name="sb"></param>
protected override void GetMember(PropertyInfo pi, Int32 len, StringBuilder sb)
{
if (pi.Name == "Options")
{
foreach (var opt in Options)
{
if (sb.Length > 0) sb.AppendLine();
sb.AppendFormat("{0," + len + "}: {1}", opt.Option, opt.ToStr());
}
return;
}
base.GetMember(pi, len, sb);
}
/// <summary>获取用于输出的成员值</summary>
/// <param name="pi"></param>
/// <returns></returns>
protected override Object GetMemberValue(PropertyInfo pi)
{
var v = base.GetMemberValue(pi);
var type = pi.PropertyType;
if (type.IsEnum) return v;
if (pi.Name.Contains("IP")) return new IPAddress(v.ToInt());
if (pi.Name.Contains("Mac"))
{
var buf = (Byte[])this.GetValue(pi);
if (buf == null) return null;
return buf.ReadBytes(0, HardAddrLength).ToHex(":");
}
var code = Type.GetTypeCode(type);
switch (code)
{
case TypeCode.Byte:
return "0x{0:X2}".F(v.ToInt());
case TypeCode.DateTime:
return "{0}".F(v);
case TypeCode.Int16:
case TypeCode.UInt16:
return "0x{0:X4}".F(v);
case TypeCode.Int32:
case TypeCode.UInt32:
return "0x{0:X8}".F(v);
case TypeCode.Int64:
case TypeCode.UInt64:
return "0x{0:X16}".F(v);
}
return v;
}
#endregion
}
}
|