public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCMoveBy;
if (ret == null)
{
return null;
}
base.Copy(zone);
ret.InitWithDuration(m_fDuration, m_delta);
return ret;
}
else
{
return new CCMoveBy(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCRepeatForever;
if (ret == null)
{
return null;
}
base.Copy(zone);
var param = m_pInnerAction.Copy() as CCActionInterval;
if (param == null)
{
return null;
}
ret.InitWithAction(param);
return ret;
}
else
{
return new CCRepeatForever(this);
}
}
public override object Copy(ICopyable zone)
{
ICopyable tmpZone = zone;
CCSequence ret;
if (tmpZone != null && tmpZone != null)
{
ret = tmpZone as CCSequence;
if (ret == null)
{
return null;
}
base.Copy(tmpZone);
var param1 = m_pActions[0].Copy() as CCFiniteTimeAction;
var param2 = m_pActions[1].Copy() as CCFiniteTimeAction;
if (param1 == null || param2 == null)
{
return null;
}
ret.InitOneTwo(param1, param2);
return ret;
}
else
{
return new CCSequence(this);
}
}
/// <summary>This methods send some ICopyable data to the remote address.
/// </summary>
/// <param name="remote_addr">Remote Nodes are referenced by their P2P
/// Address, typically of type AHAddress.</param>
/// <param name="data">This is an ICopyable object which contains the data
/// to send.</param>
public void SendMessage(Address remote_addr, ICopyable data) {
// This instantiates a multi-use method to sending to the remote node,
// though we will only use it once. It is VERY similar to UDP.
AHExactSender sender = new AHExactSender(_app_node.Node, remote_addr);
// This is the process of actually sending the data.
sender.Send(new CopyList(HW, data));
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCSpawn;
if (ret == null)
{
return null;
}
base.Copy(zone);
var param1 = m_pOne.Copy() as CCFiniteTimeAction;
var param2 = m_pTwo.Copy() as CCFiniteTimeAction;
if (param1 == null || param2 == null)
{
return null;
}
ret.InitOneTwo(param1, param2);
return ret;
}
else
{
return new CCSpawn(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCRepeat;
if (ret == null)
{
return null;
}
base.Copy(zone);
var param = m_pInnerAction.Copy() as CCFiniteTimeAction;
if (param == null)
{
return null;
}
ret.InitWithAction(param, m_uTimes);
return ret;
}
else
{
return new CCRepeat(this);
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
if (obj is IGeographicLocation)
{
IGeographicLocation g = (IGeographicLocation)obj;
Latitude = g.Latitude;
Longitude = g.Longitude;
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
if (obj is IStatusCode)
{
IStatusCode sc = (IStatusCode)obj;
Parts = new int[sc.Parts.Length];
sc.Parts.CopyTo(Parts, 0);
}
}
///<summary>Pushes the data to the SecurityAssociation who will send it
///over the underlying edge.</summary>
public override void Send(ICopyable data) {
if(_closed == 1) {
throw new EdgeClosedException("SecureEdge has been closed.");
}
try {
SA.Send(data);
} catch(Exception e) {
throw new EdgeException(_closed == 1, "Unable to send on SE", e);
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
IOrganizer o = obj as IOrganizer;
if (o != null)
{
Value = o.Value;
}
}
public DataPacket(ICopyable packet) {
_update_icpacket = false;
_update_packet = false;
_icpacket = packet;
_packet = packet as MemBlock;
if(_packet == null) {
_update_packet = true;
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
IFreeBusyEntry fb = obj as IFreeBusyEntry;
if (fb != null)
{
Status = fb.Status;
}
}
public void Send(ICopyable Data) {
byte[] data = new byte[Data.Length];
Data.CopyTo(data, 0);
MemBlock mdata = MemBlock.Reference(data);
for(int i = 0; i < _remove_n_ptypes; i++) {
MemBlock payload = mdata;
PType.Parse(mdata, out payload);
mdata = payload;
}
Receiver.HandleData(mdata, ReturnPath, State);
}
public override void CopyFrom(ICopyable c)
{
base.CopyFrom(c);
ICalendarParameter p = c as ICalendarParameter;
if (p != null)
{
if (p.Values != null)
_Values = new List<string>(p.Values);
}
}
public virtual object Copy(ICopyable zone)
{
if (zone != null)
{
((CCAction) zone).m_nTag = m_nTag;
return zone;
}
else
{
return new CCAction(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCScaleBy;
base.Copy(zone); // Handles all data copying.
return ret;
}
else
{
return new CCScaleBy(this);
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
IPeriod p = obj as IPeriod;
if (p != null)
{
StartTime = p.StartTime;
EndTime = p.EndTime;
Duration = p.Duration;
MatchesDateOnly = p.MatchesDateOnly;
}
}
public override object Copy(ICopyable pZone)
{
if (pZone != null)
{
//in case of being called at sub class
var pCopy = (CCFadeOut) (pZone);
base.Copy(pZone);
return pCopy;
}
else
{
return new CCFadeOut(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = (CCFollow) zone;
base.Copy(zone);
ret.m_nTag = m_nTag;
return ret;
}
else
{
return new CCFollow(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCReverseTime;
base.Copy(zone);
m_pOther = (CCFiniteTimeAction)ret.m_pOther; // .Copy() was in here before
return ret;
}
else
{
return new CCReverseTime(this);
}
}
public override void CopyFrom(ICopyable c)
{
base.CopyFrom(c);
ICalendarParameter p = c as ICalendarParameter;
if (p != null)
{
if (p.Values != null)
{
Values = new string[p.Values.Length];
Array.Copy(p.Values, Values, p.Values.Length);
}
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCOrbitCamera;
base.Copy(zone);
Init(ret.m_fRadius, ret.m_fDeltaRadius, ret.m_fAngleZ, ret.m_fDeltaAngleZ, ret.m_fAngleX, ret.m_fDeltaAngleX);
return ret;
}
else
{
return new CCOrbitCamera(this);
}
}
public AHHeader(short hops, short ttl, Address source, Address dest, ushort options) {
//Make the header part:
byte[] header = new byte[ AHPacket.HeaderLength ];
int offset = 0;
//Write hops:
NumberSerializer.WriteShort(hops, header, offset);
offset += 2;
NumberSerializer.WriteShort(ttl, header, offset);
offset += 2;
offset += source.CopyTo(header, offset);
offset += dest.CopyTo(header, offset);
NumberSerializer.WriteShort((short)options, header, offset);
offset += 2;
_data = MemBlock.Reference(header, 0, offset);
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCScaleTo;
base.Copy(zone);
m_fEndScaleX = ret.m_fEndScaleX;
m_fEndScaleY = ret.m_fEndScaleY;
return ret;
}
else
{
return new CCScaleTo(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
//in case of being called at sub class
var pRet = (CCCallFuncND) (zone);
base.Copy(zone);
pRet.InitWithTarget(m_pCallFuncND, m_pData);
return pRet;
}
else
{
return new CCCallFuncND(this);
}
}
/**
<summary>Creates a Udp Packet given the source port, destination port
and the payload.</summary>
<param name="SourcePort">The packets originating port</param>
<param name="DestinationPort">The packets destination port</param>
<param name="Payload">The data for the packet.</param>
*/
public UdpPacket(int SourcePort, int DestinationPort, ICopyable Payload) {
byte[] header = new byte[8];
header[0] = (byte) ((SourcePort >> 8) & 0xFF);
header[1] = (byte) (SourcePort & 0xFF);
header[2] = (byte) ((DestinationPort >> 8) & 0xFF);
header[3] = (byte) (DestinationPort & 0xFF);
int length = Payload.Length + 8;
header[4] = (byte) ((length >> 8) & 0xFF);
header[5] = (byte) (length & 0xFF);
// Checksums are disabled!
header[6] = (byte) 0;
header[7] = (byte) 0;
_icpacket = new CopyList(MemBlock.Reference(header), Payload);
_icpayload = Payload;
}
public override object Copy(ICopyable pZone)
{
if (pZone != null)
{
//in case of being called at sub class
var pCopy = pZone as CCEaseBounceIn;
pCopy.InitWithAction((CCActionInterval) (m_pOther.Copy()));
return pCopy;
}
else
{
return new CCEaseBounceIn(this);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = (CCMoveTo) zone;
base.Copy(zone);
ret.InitWithDuration(m_fDuration, m_endPosition);
return ret;
}
else
{
return new CCMoveTo(this);
}
}
public override object Copy(ICopyable pZone)
{
if (pZone != null) //in case of being called at sub class
{
var pRet = (CCTargetedAction) (pZone);
base.Copy(pZone);
// win32 : use the m_pOther's copy object.
pRet.InitWithTarget(m_pTarget, (CCFiniteTimeAction) m_pAction.Copy());
return pRet;
}
else
{
return new CCTargetedAction(this);
}
}
/// <summary>Used to send data over the tunnel via forwarding senders
/// using a randomly selected peer from our overlap list.</summary>
public void HandleEdgeSend(Edge from, ICopyable data)
{
RelayEdge te = from as RelayEdge;
Connection forwarder = te.NextForwarder;
if (te.RemoteID == -1)
{
Address target = (te.RemoteTA as RelayTransportAddress).Target;
ISender sender = new ForwardingSender(_node, forwarder.Address, target);
sender.Send(new CopyList(PType.Protocol.Relaying, te.MId, data));
}
else
{
try {
forwarder.State.Edge.Send(new CopyList(te.Header, te.MId, data));
} catch {
// We could be sending aon a closed edge... we could deal with this
// better, but let's just let the system take its natural course.
}
}
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
if (obj is IAttachment)
{
IAttachment a = (IAttachment)obj;
ValueEncoding = a.ValueEncoding;
if (a.Data != null)
{
Data = new byte[a.Data.Length];
a.Data.CopyTo(Data, 0);
}
else
{
Data = null;
}
Uri = a.Uri;
}
}
/**
* <summary>Sends the data over the unicast socket.</summary>
* <param name="data">The data to send.</summary>
*/
public virtual void Send(ICopyable data)
{
// Silly users can trigger a handful of exceptions here...
try {
data = new CopyList(IPHandler.MagicCookie, data);
byte[] buffer = new byte[data.Length];
int length = data.CopyTo(buffer, 0);
_s.SendTo(buffer, 0, length, 0, EndPoint);
}
catch (System.Net.Sockets.SocketException sx) {
throw new SendException(true, "SocketException", sx);
}
catch (ObjectDisposedException odx) {
throw new SendException(false, "Socket appears to be disposed", odx);
}
catch (Exception e) {
ProtocolLog.WriteIf(ProtocolLog.Exceptions, "ERROR: " + e);
throw new SendException(true, "Socket appears to be disposed", e);
}
}
/*
* public ICopyable GetEnemy(EnemyType enemyType)
* {
* switch (enemyType)
* {
* case EnemyType.Drone:
* return Instantiate(Resources.Load("Drone", typeof(Enemy)) as Enemy);;
* case EnemyType.Sniper:
* return Instantiate(Resources.Load("Sniper", typeof(Enemy)) as Enemy);
* }
* return null;
* }
*/
public ICopyable GetEnemy(Enemy enemy, bool usePrefab = true)
{
copyable = null;
if (usePrefab)
{
if (enemy.GetType() == typeof(Drone))
{
copyable = enemy.Copy("Drone");
}
else if (enemy.GetType() == typeof(Sniper))
{
copyable = enemy.Copy("Sniper");
}
}
else
{
copyable = enemy.Copy();
}
return(copyable as Enemy);
}
public void Send(ICopyable data)
{
if (0 == Interlocked.Exchange(ref have_sent, 1))
{
//Make the header:
byte[] header = new byte[5];
header[0] = (byte)ReqrepType.Reply;
NumberSerializer.WriteInt(RequestID, header, 1);
MemBlock mb_header = MemBlock.Reference(header);
Reply = new CopyList(_prefix, mb_header, data);
Resend();
}
else
{
/*
* Something goofy is going on here. Multiple
* sends for one request. we are ignoring it for
* now
*/
}
}
/**
<summary>Sends the data over the multicast socket.</summary>
<param name="data">The data to send.</summary>
*/
public override void Send(ICopyable data) {
IPAddress[] ips = LocalIPAddresses;
if(ips == null) {
ips = IPHandler.GetLocalIPAddresses();
}
// Silly users can trigger a handful of exceptions here...
try {
data = new CopyList(IPHandler.MagicCookie, data);
byte[] buffer = new byte[data.Length];
int length = data.CopyTo(buffer, 0);
// I REALLY HATE THIS but we can't be setting this option in more than one thread!
lock(_s) {
foreach(IPAddress ip in ips) {
/*
* This can throw an exception on an invalid address, we need to skip it and move on!
* Never showed to be an issue in Linux, but Windows does some weird things.
*/
try {
_s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface,
IPHandler.IPAddressToInt(ip));
}
catch {
continue;
}
_s.SendTo(buffer, 0, length, 0, EndPoint);
}
}
}
catch(System.Net.Sockets.SocketException sx) {
throw new SendException(true, "SocketException", sx);
}
// Can't pass the fact that the IPHandler is not running :-/
catch (ObjectDisposedException odx) {
throw new SendException(false, "Socket appears to be disposed", odx);
}
catch (Exception e) {
ProtocolLog.WriteIf(ProtocolLog.Exceptions, "ERROR: " + e);
throw new SendException(true, "Socket appears to be disposed", e);
}
}
public static bool Draw(ILoadable loadable, IUndoable undoable, ICopyable copyable, ICompilable compilable)
{
try
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("File", EditorStyles.toolbarButton, GUILayout.Width(35)))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("New: Ctrl+Alt+N "), false, OnNew, loadable);
menu.AddItem(new GUIContent("Load: Ctrl+Alt+L"), false, OnLoad, loadable);
menu.AddItem(new GUIContent("Save: Ctrl+Alt+S"), false, OnSave, loadable);
menu.AddItem(new GUIContent("Export as constellation file"), false, OnExportAsCL, loadable);
menu.ShowAsContext();
return(true);
}
if (GUILayout.Button("Edit", EditorStyles.toolbarButton, GUILayout.Width(35)))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Undo: Ctrl+Alt+Z"), false, OnUndo, undoable);
menu.AddItem(new GUIContent("Redo: Ctrl+Alt+Y"), false, OnRedo, undoable);
menu.AddItem(new GUIContent("Copy: Ctrl+Alt+C"), false, Copy, copyable);
menu.AddItem(new GUIContent("Past: Ctrl+Alt+V"), false, Paste, copyable);
menu.ShowAsContext();
return(true);
}
if (GUILayout.Button("Refresh", EditorStyles.toolbarButton, GUILayout.Width(70)))
{
compilable.ParseScript();
return(true);
}
GUILayout.Label("", EditorStyles.toolbarButton);
EditorGUILayout.EndHorizontal();
}catch
{
}
return(false);
}
///<summary>All outgoing data filters through here.</summary>
public void Send(ICopyable data)
{
if (!_active)
{
if (_closed == 1)
{
throw new SendException(false, "SA closed, unable to send!");
}
UpdateSH(null, null);
return;
}
// prepare the packet
SecurityDataMessage sdm = new SecurityDataMessage();
sdm.SPI = _spi;
sdm.Data = data as MemBlock;
if (sdm.Data == null)
{
byte[] b = new byte[data.Length];
data.CopyTo(b, 0);
sdm.Data = MemBlock.Reference(b);
}
// Encrypt it!
lock (_sync) {
_current_sh.SignAndEncrypt(sdm);
}
// Prepare for sending and send over the underlying ISender!
data = new CopyList(SecurityOverlord.Security, SecurityOverlord.SecureData, sdm.ICPacket);
try {
_sender.Send(data);
_running = true;
} catch (Exception e) {
Close("Failed on sending");
throw new SendException(false, "Failed on sending closing...", e);
}
}
public override object Copy(ICopyable zone)
{
if (zone != null)
{
var ret = zone as CCMoveBy;
if (ret == null)
{
return(null);
}
base.Copy(zone);
ret.InitWithDuration(m_fDuration, m_delta);
return(ret);
}
else
{
return(new CCMoveBy(this));
}
}
public virtual void Send(ICopyable data)
{
if (_rand.NextDouble() < _drop_rate)
{
return;
}
MemBlock mdata = data as MemBlock;
if (mdata == null)
{
mdata = MemBlock.Copy(data);
}
for (int i = 0; i < _remove_n_ptypes; i++)
{
MemBlock payload = mdata;
PType.Parse(mdata, out payload);
mdata = payload;
}
Receiver.HandleData(mdata, ReturnPath, State);
}
/**
* <summary>Takes in the IP Header fields and a payload to create an IP
* Packet. Unlisted fields are generated by this constructor automatically.
* </summary>
* <param name="Protocol">The type of payload</param>
* <param name="SourceIP">The packets originating ip address</param>
* <param name="DestinationIP">The destination for the packet</param>
* <param name="hdr">The original header of the IPPacket</param>
* <param name="Payload">The data stored in the IP Packet</param>
*/
public IPPacket(Protocols Protocol, MemBlock SourceIP,
MemBlock DestinationIP, MemBlock hdr, ICopyable Payload)
{
byte[] header = new byte[20];
// Version | IHL
header[0] = hdr[0];
// Just a routine header!
header[1] = hdr[1];
int length = header.Length + Payload.Length;
header[2] = (byte)((length >> 8) & 0xFF);
header[3] = (byte)(length & 0xFF);
// Fragment crap
header[4] = hdr[4];
header[5] = hdr[5];
header[6] = hdr[6];
header[7] = hdr[7];
// Ttl
header[8] = hdr[8];
header[9] = hdr[9];
for (int i = 0; i < 4; i++)
{
header[12 + i] = SourceIP[i];
header[16 + i] = DestinationIP[i];
}
int checksum = GenerateChecksum(MemBlock.Reference(header));
header[10] = (byte)((checksum >> 8) & 0xFF);
header[11] = (byte)(checksum & 0xFF);
MemBlock Header = MemBlock.Reference(header);
_icpacket = new CopyList(Header, Payload);
this.Protocol = Protocol;
this.SourceIP = SourceIP;
this.DestinationIP = DestinationIP;
_icpayload = Payload;
}
public override void CopyFrom(ICopyable c)
{
var obj = c as ICalendarObject;
if (obj == null)
{
return;
}
// Copy the name and basic information
Name = obj.Name;
Parent = obj.Parent;
Line = obj.Line;
Column = obj.Column;
// Add each child
Children.Clear();
foreach (var child in obj.Children)
{
this.AddChild(child);
}
}
/// <summary>
/// Makea full copy of this object and does not make any reference copies.
/// </summary>
/// <param name="zone"></param>
/// <returns></returns>
public override object Copy(ICopyable zone)
{
ICopyable tmpZone = zone;
CCParallel ret;
if (tmpZone != null && tmpZone != null)
{
ret = tmpZone as CCParallel;
base.Copy(tmpZone);
CCFiniteTimeAction[] cp = new CCFiniteTimeAction[m_pActions.Length];
for (int i = 0; i < m_pActions.Length; i++)
{
cp[i] = m_pActions[i].Copy() as CCFiniteTimeAction;
}
ret.m_pActions = cp;
return(ret);
}
else
{
return(new CCParallel(this));
}
}
public void HandleEdgeSend(Edge from, ICopyable p)
{
TcpEdge sender = (TcpEdge)from;
try {
bool flushed = true;
lock ( sender ) {
//Try to fill up the buffer:
sender.WriteToBuffer(p);
//Okay, we loaded the whole packet into the TcpEdge's buffer
//now it is time to try to flush the buffer:
flushed = sender.Flush();
}
if (!flushed)
{
/*
* We should remember to try again when the socket is
* writable
*/
ActionQueue.Enqueue(new SendWaitAction(sender.Socket));
}
}
catch (EdgeException ex) {
if (false == ex.IsTransient)
{
//Go ahead and forget about this socket.
RequestClose(from);
ActionQueue.Enqueue(new CloseAction(sender, null));
}
//Rethrow the exception
throw;
}
catch (Exception x) {
//Assume any other error is transient:
throw new EdgeException(true, String.Format("Could not send on: {0}", from), x);
}
}
/// <summary>
/// Copies all relevant fields/properties from
/// the target object to the current one.
/// </summary>
/// <param name="obj"></param>
public override sealed void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
var p = obj as ICalendarProperty;
if (p != null)
{
// Copy/clone the object if possible (deep copy)
var copyable = p.Values as ICopyable;
if (copyable != null)
{
SetValue(copyable.Copy <object>( ));
}
else
{
var cloneable = p.Values as ICloneable;
if (cloneable != null)
{
SetValue(cloneable.Clone( ));
}
else
{
SetValue(p.Values);
}
}
// Copy parameters
foreach (ICalendarParameter parm in p.Parameters)
{
AddParameter(parm.Copy <ICalendarParameter>( ));
}
}
}
/// <summary>
/// Copies values from the target object to the
/// current object.
/// </summary>
/// <param name="obj"></param>
public override sealed void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
var attachment = obj as IAttachment;
if (attachment != null)
{
IAttachment a = attachment;
ValueEncoding = a.ValueEncoding;
if (a.Data != null)
{
Data = new byte[a.Data.Length];
a.Data.CopyTo(Data, 0);
}
else
{
Data = null;
}
Uri = a.Uri;
}
}
void Awake()
{
movingObject = false;
baseMesh = gameObject.GetComponent <MeshFilter>().mesh;
stimulus = GetComponent <Stimulus>();
gameObjects = UnityEngine.Object.FindObjectsOfType <GameObject>();
foreach (GameObject obj in gameObjects)
{
ICopyable test_ICopyable = obj.GetComponent <ICopyable>();
if (test_ICopyable != null)
{
Copyables.Add(test_ICopyable);
}
Humanoid test_h = obj.GetComponent <Humanoid>();
if (test_h != null)
{
humanoids.Add(test_h);
}
}
StartCoroutine("UpdateForm");
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
ICalendarProperty p = obj as ICalendarProperty;
if (p != null)
{
if (p.Value is ICopyable)
{
Value = ((ICopyable)p.Value).Copy <object>();
}
else
{
Value = p.Value;
}
// Copy parameters
foreach (ICalendarParameter parm in p.Parameters)
{
AddChild(parm.Copy <ICalendarParameter>());
}
}
}
public Body SpawnNewBody()
{
mCopy = newBod.Copy();
return((Body)mCopy);
}
/// <summary>Look up a hostname given a Dns request in the form of IPPacket
/// </summary>
/// <param name="in_ip">An IPPacket containing the Dns request</param>
/// <returns>An IPPacket containing the results</returns>
public virtual IPPacket LookUp(IPPacket in_ip)
{
UdpPacket in_udp = new UdpPacket(in_ip.Payload);
DnsPacket in_dns = new DnsPacket(in_udp.Payload);
ICopyable out_dns = null;
string qname = string.Empty;
bool invalid_qtype = false;
try {
string qname_response = String.Empty;
qname = in_dns.Questions[0].QName;
DnsPacket.Types type = in_dns.Questions[0].QType;
if (type == DnsPacket.Types.A || type == DnsPacket.Types.AAAA)
{
qname_response = AddressLookUp(qname);
}
else if (type == DnsPacket.Types.Ptr)
{
qname_response = NameLookUp(qname);
}
else
{
invalid_qtype = true;
}
if (qname_response == null)
{
throw new Exception("Unable to resolve");
}
Response response = new Response(qname, in_dns.Questions[0].QType,
in_dns.Questions[0].QClass, 1800, qname_response);
//Host resolver will not accept if recursive is not available
//when it is desired
DnsPacket res_packet = new DnsPacket(in_dns.ID, false,
in_dns.Opcode, true, in_dns.RD, in_dns.RD,
in_dns.Questions, new Response[] { response }, null, null);
out_dns = res_packet.ICPacket;
} catch (Exception e) {
bool failed_resolve = false;
// The above resolver failed, let's see if another resolver works
if (_forward_queries)
{
try {
out_dns = Resolve(_name_server, (byte[])in_dns.Packet);
} catch (Exception ex) {
e = ex;
failed_resolve = true;
}
}
if (!_forward_queries || failed_resolve)
{
ProtocolLog.WriteIf(IpopLog.Dns, "Failed to resolve: " + qname + "\n\t" + e.Message);
out_dns = DnsPacket.BuildFailedReplyPacket(in_dns, !invalid_qtype);
}
}
UdpPacket out_udp = new UdpPacket(in_udp.DestinationPort,
in_udp.SourcePort, out_dns);
return(new IPPacket(IPPacket.Protocols.Udp, in_ip.DestinationIP,
in_ip.SourceIP,
out_udp.ICPacket));
}
//ToDo: See if this can be deleted
public override void CopyFrom(ICopyable obj)
{
}
/// <summary>
/// Copies values from the target object to the
/// current object.
/// </summary>
public virtual void CopyFrom(ICopyable c)
{
}
public bool Update <TDbContext, TEntity>(BaseDataAccessService <TDbContext, TEntity> dataService, int entityId, ICopyable <TEntity> copyImpl, string popUpText, bool popUpConfirm)
where TDbContext : DbContext
where TEntity : class
{
var vm = ServiceLocator.Current.GetInstance <IViewModelGetSelectedView>().GetSelectedView();
if (popUpConfirm)
{
string hintText = TranslationService.Translate("View_Messagebox_ConfirmToUpdate") + ": \n" + popUpText;
if (ServiceLocator.Current.GetInstance <IViewModelConfirmWindow>().ConfirmWindow(vm, hintText) == false)
{
return(false);
}
}
var rc = false;
var tuple = dataService.LoadSingleTuple(entityId);
if (tuple == null)
{
string hintText = popUpText + "\n" + TranslationService.Translate("View_Messagebox_DeleteAlready");
}
else
{
copyImpl.CopyTo(tuple);
var result = dataService.Modify(tuple);
if (result.ResultCode != ResultCodeOption.Ok)
{
string hintText =
TranslationService.Translate("View_Messagebox_CannotUpdate") + ": \n" +
popUpText + "\n" +
TranslationService.Translate("View_Messagebox_Reason") + ": " + result.Message;
ServiceLocator.Current.GetInstance <IViewModelErrorWindow>().ErrorWindow(vm, hintText);
rc = false;
}
else
{
ServiceLocator.Current.GetInstance <IViewModelHintWindow>().HintWindow(
vm,
TranslationService.Translate("View_Messagebox_Success") + "!");
rc = true;
}
}
return(rc);
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
if (obj is IRecurrencePattern)
{
IRecurrencePattern r = (IRecurrencePattern)obj;
_Frequency = r.Frequency;
_Until = r.Until;
_Count = r.Count;
_Interval = r.Interval;
if (r.BySecond != null)
{
_BySecond = new List <int>(r.BySecond);
}
else
{
_BySecond = null;
}
if (r.ByMinute != null)
{
_ByMinute = new List <int>(r.ByMinute);
}
else
{
_ByMinute = null;
}
if (r.ByHour != null)
{
_ByHour = new List <int>(r.ByHour);
}
else
{
_ByHour = null;
}
if (r.ByDay != null)
{
_ByDay = new List <IWeekDay>(r.ByDay);
}
else
{
_ByDay = null;
}
if (r.ByMonthDay != null)
{
_ByMonthDay = new List <int>(r.ByMonthDay);
}
else
{
_ByMonthDay = null;
}
if (r.ByYearDay != null)
{
_ByYearDay = new List <int>(r.ByYearDay);
}
else
{
_ByYearDay = null;
}
if (r.ByWeekNo != null)
{
_ByWeekNo = new List <int>(r.ByWeekNo);
}
else
{
_ByWeekNo = null;
}
if (r.ByMonth != null)
{
_ByMonth = new List <int>(r.ByMonth);
}
else
{
_ByMonth = null;
}
if (r.BySetPosition != null)
{
_BySetPosition = new List <int>(r.BySetPosition);
}
else
{
_BySetPosition = null;
}
_FirstDayOfWeek = r.FirstDayOfWeek;
_RestrictionType = r.RestrictionType;
_EvaluationMode = r.EvaluationMode;
}
}
/// <summary>
/// Constructor.
/// </summary>
public DetailDesignator(Ownership <IdeaDefinition, Idea> Owner, string Name, string TechName, string Summary = "", ICopyable Initializer = null, ImageSource Pictogram = null)
: base(Name, TechName, Summary, Pictogram)
{
this.Owner = Owner;
this.Initializer = Initializer;
}
public Enemy SpawnEnemy(Enemy prototype)
{
copy = prototype.Copy();
return((Enemy)copy);
}
///<summary>Sends the data over the underlying edge.</summary>
public override void Send(ICopyable p)
{
_edge.Send(p);
}
/// <summary>
/// Constructor.
/// </summary>
public LinkDetailDesignator(Ownership <IdeaDefinition, Idea> Owner,
string Name, string TechName, string Summary = "", ICopyable Initializer = null, ImageSource Pictogram = null)
: base(Owner, Name, TechName, Summary, Initializer, Pictogram)
{
this.DeclaringLinkType = (Initializer is MModelPropertyDefinitor
? InternalLinkType.InternalTypeAny
: LinkDataType.GenericLink);
this.LinkLook = new LinkAppearance();
}
public override void Send(ICopyable data)
{
_queue.Enqueue(data);
}
/*
* Send a packet by forwarding it first.
*/
public void Send(ICopyable d)
{
_sender.Send(new CopyList(_header, d));
}
public override void CopyFrom(ICopyable obj)
{
base.CopyFrom(obj);
if (obj is IRequestStatus)
{
IRequestStatus rs = (IRequestStatus)obj;
if (rs.StatusCode != null)
StatusCode = rs.StatusCode.Copy<IStatusCode>();
Description = rs.Description;
rs.ExtraData = rs.ExtraData;
}
}
