public override void ProcessEvent(Node node, Event e)
{
PrivacyReader reader = (PrivacyReader)node;
switch (e.Type)
{
case EventType.K_ANONY:
reader.JoinAnonyGroup(e.Obj);
break;
case EventType.CHK_SUBTREE:
reader.CheckSubTree(e.Obj);
break;
/*
case EventType.CHK_NEWGROUP:
reader.CheckNewGroup(e.Obj);
break;
*/
case EventType.CHK_NATGROUP:
reader.CheckNativeGroupResponse(e.Obj);
break;
case EventType.CHK_NATGROUP1:
reader.CheckNativeLargeGroupResponse(e.Obj);
break;
default:
base.ProcessEvent(node, e);
break;
}
}
public override void ProcessEvent(Node node, Event e)
{
if (node.type == NodeType.READER)
{
IOTReader reader = (IOTReader)node;
switch (e.Type)
{
case EventType.CHK_RT_TIMEOUT:
reader.CheckRoutine();
break;
case EventType.CHK_EVENT_TIMEOUT:
reader.CheckEvents();
break;
default:
base.ProcessEvent(node, e);
break;
}
return;
}
else if (node.type == NodeType.ORG)
{
IOTOrganization org = (IOTOrganization)node;
switch (e.Type)
{
case EventType.CHK_RT_TIMEOUT:
org.CheckRoutine();
break;
default:
base.ProcessEvent(node, e);
break;
}
}
else if (node.type == NodeType.OBJECT)
{
IOTObjectNode obj = (IOTObjectNode)node;
switch (e.Type)
{
default:
base.ProcessEvent(node, e);
break;
}
}
else if (node.type == NodeType.TRUST_MANAGER)
{
IOTTrustManager tm = (IOTTrustManager)node;
switch (e.Type)
{
case EventType.CHK_RT_TIMEOUT:
tm.CheckRoutine();
break;
default:
base.ProcessEvent(node, e);
break;
}
}
else
{
base.ProcessEvent(node, e);
}
}
public Event(float time, EventType type, Node node, object obj)
{
this.Time = time;
this.Type = type;
this.Node = node;
this.Obj = obj;
}
public override void ProcessEvent(Node node, Event e)
{
switch (e.Type)
{
case EventType.CHK_CERT:
((VANETReader)node).CheckCertificate((CertificateArg)e.Obj);
break;
default:
base.ProcessEvent(node, e);
break;
}
}
public override void ProcessEvent(Node node, Event e)
{
MODReader reader = (MODReader)node;
switch (e.Type)
{
case EventType.CHK_RT_TIMEOUT:
reader.CheckRoutine();
break;
case EventType.CHK_RECV_PKT:
reader.CheckReceivedPacket((MODPhenomemon)e.Obj);
break;
case EventType.DEDUCE_EVENT:
reader.DeduceEventType((string)e.Obj);
break;
case EventType.FWD_EVENT_REPORT:
reader.ForwardEventReport((string)e.Obj);
break;
default:
base.ProcessEvent(node, e);
break;
}
}
public MODEventTrustResult(int node, Node reportNode, string pkgIdent, MODEventCategoryType category, DSClass ds)
{
this.nodeId = node;
this.reportNodeId = reportNode.Id;
this.ds = ds;
this.eventIdent = pkgIdent;
//TODO app
confirmBeliefThrehold = new Dictionary<MODEventType, double>();
confirmBeliefThrehold[MODEventType.DropPacketMaliciously] = 0.3;
this.timeStamp = Scheduler.getInstance().currentTime;
}
public static MODEventTrustResult MergeMaliciousEventTrustResult(int node, Node reportNode, List<MODEventTrustResult> reports,
string pkgIdent, MODEventCategoryType category)
{
double b0 = 0.0;
double b1 = 0.0;
double b2 = 0.0;
double b3 = 0.0;
//各个b的方差
double x0 = 0, x1 = 0, x2 = 0, x3 = 0;
DSClass ds = new DSClass(pow(MODDropPacketEventType.END));
//TODO，确认下面是否是正确的
for (int i = 0; i < reports.Count; i++)
{
b0 += reports[i].ds.b[pow(MODDropPacketEventType.NotDropPacket)];
b1 += reports[i].ds.b[pow(MODDropPacketEventType.NotDropPacketButNotReceivePacket)];
b2 += reports[i].ds.b[pow(MODDropPacketEventType.DropPacketDueToBandwith)];
b3 += reports[i].ds.b[pow(MODDropPacketEventType.DropPacketMaliciously)];
}
b0 = b0 / reports.Count;
b1 = b1 / reports.Count;
b2 = b2 / reports.Count;
b3 = b3 / reports.Count;
ds.SetM(pow(MODDropPacketEventType.NotDropPacket), b0);
ds.SetM(pow(MODDropPacketEventType.NotDropPacketButNotReceivePacket), b1);
ds.SetM(pow(MODDropPacketEventType.DropPacketDueToBandwith), b2);
ds.SetM(pow(MODDropPacketEventType.DropPacketMaliciously), b3);
ds.SetM(pow(MODDropPacketEventType.END) - 1, 1 - b0 - b1 - b2 - b3);
ds.Cal();
//计算方差，即一致度
//TODO，确认下面是否是正确的
for (int i = 0; i < reports.Count; i++)
{
x0 += Math.Pow(b0 - reports[i].ds.b[pow(MODDropPacketEventType.NotDropPacket)], 2);
x1 += Math.Pow(b1 - reports[i].ds.b[pow(MODDropPacketEventType.NotDropPacketButNotReceivePacket)], 2);
x2 += Math.Pow(b2 - reports[i].ds.b[pow(MODDropPacketEventType.DropPacketDueToBandwith)], 2);
x3 += Math.Pow(b3 - reports[i].ds.b[pow(MODDropPacketEventType.DropPacketMaliciously)], 2);
}
MODEventTrustResult result = new MODEventTrustResult(node, reportNode, pkgIdent, category, ds);
result.variance = x0 + x1 + x2 + x3;
if (result.ds.b[pow(MODEventType.NotDropPacket) + pow(MODEventType.NotDropPacketButNotReceivePacket)] < global.NormalBelief
&& result.ds.p[pow(MODEventType.NotDropPacket) + pow(MODEventType.NotDropPacketButNotReceivePacket)] < global.NormalPlausibility)//确实是攻击,恶意事件的信念大于正常事件，或恶意事件的信念大于某一个阈值
result.supportDroppingMalicious = 1;
else
result.supportDroppingMalicious = -1;
return result;
}
public Deduce2Result DeduceA2(Node[] reportNodes, bool isDeduceStep2, int suspectedNodeId, Dictionary<Node, MODEventTrustResult> cachedresults,
int deduceNodeId, double pDrop, Dictionary<Node, double> pNormal, Dictionary<Node, double> localNodeTrustWeights,
Dictionary<Node, double> localNodeTrustWeightsLastUpdate, List<IteratorType> iteractions)
{
string pkgIdent = cachedresults.First().Value.eventIdent;
foreach (Node node in reportNodes)
{
if (!localNodeTrustWeights.ContainsKey(node))//如果没有记录，则设其初始权重为1
{
localNodeTrustWeights.Add(node, 1f);
localNodeTrustWeightsLastUpdate.Add(node, scheduler.currentTime);
}
Organization org = global.orgs[((Reader)node).OrgId];
if (!localNodeTrustWeights.ContainsKey(org))
{
localNodeTrustWeights.Add(org, 1f);
localNodeTrustWeightsLastUpdate.Add(org, scheduler.currentTime);
}
}
foreach (Organization org in global.orgs)
{
if (!localNodeTrustWeights.ContainsKey(org))
{
localNodeTrustWeights.Add(org, 1f);
localNodeTrustWeightsLastUpdate.Add(org, scheduler.currentTime);
}
}
double supportMWeight = 0, nonsupportMWeight = 0;
double supportMNodes = 0, nonsupportMNodes = 0;
bool isReportSupportM = false;
//计算报告是support还是nonsupport
foreach (KeyValuePair<Node, MODEventTrustResult> k in cachedresults)
{
Node node = k.Key;
MODEventTrustResult result = k.Value;
if (MODEventTrust.getDist(result.ds) < global.ReportMinDist)
continue;
Organization org = global.orgs[((Reader)node).OrgId];
if (result.supportDroppingMalicious > 0)
{
supportMWeight += localNodeTrustWeights[node] * localNodeTrustWeights[org];
supportMNodes++;
}
else
{
nonsupportMWeight += localNodeTrustWeights[node] * localNodeTrustWeights[org];
nonsupportMNodes++;
}
}
if (supportMWeight > nonsupportMWeight)
isReportSupportM = true;
else
isReportSupportM = false;
//double pGroupNormalBySupportM = 0, pGroupMaliciousBySupportM = 0;
//double pGroupNormalByNonsupportM = 0, pGroupMaliciousByNonsupportM = 0;
double pGroupNormal = 0;
Combination c = new Combination();
//只计算占优势的一方,temp是优势方
//for (int m = reportNodes.Length / 2 + 1; m < reportNodes.Length; m++)
for (int m = 0; m <= reportNodes.Length; m++)
{
List<Node[]> lists = c.combination(reportNodes, m);
//求pGroupNormal
for (int i = 0; i < lists.Count; i++)
{
Node[] list = (Node[])lists[i];
double w1 = 0, w2 = 0;
HashSet<Node> set1 = new HashSet<Node>();
HashSet<Node> set2 = new HashSet<Node>();
foreach (Node node in list)
{
Organization org = global.orgs[((Reader)node).OrgId];
set1.Add(node);
w1 += localNodeTrustWeights[node]*localNodeTrustWeights[org];
}
foreach (Node node in reportNodes)//找出相反的节点
{
if (set1.Contains(node))
continue;
Organization org = global.orgs[((Reader)node).OrgId];
set2.Add(node);
w2 += localNodeTrustWeights[node] * localNodeTrustWeights[org];
}
if (w1 < w2)//如果权重和不够，则skip
continue;
//剩下的都是set1权值大于set2的情况
double p1 = 1;
foreach (Node node in set1)
{
p1 = p1 * pNormal[node];
}
foreach (Node node in set2)//找出相反的节点
{
double pMalicious = 1 - pNormal[node];
p1 = p1 * pMalicious;
}
pGroupNormal += p1;
}
}
double aAccept = 0, aReject = 0;
bool isAccept = false;
double pFwrd = 1 - pDrop;
double pGroupMalicious = 1 - pGroupNormal;
double pSupportMByDropAndGroupNormal= 0, pSupportMByFwrdAndGroupNormal = 0, pSupportMByDropAndGroupMalicious = 0,
pSupportMByFwrdAndGroupMalicious = 0, pNonsupportMByDropAndGroupNormal = 0, pNonsupportMByFwrdAndGroupNormal = 0,
pNonsupportMByDropAndGroupMalicious = 0, pNonsupportMByFwrdAndGroupMalicious = 0;
CalculateBelief(ref pSupportMByDropAndGroupNormal, ref pSupportMByFwrdAndGroupNormal,
ref pSupportMByDropAndGroupMalicious, ref pSupportMByFwrdAndGroupMalicious,
ref pNonsupportMByDropAndGroupNormal, ref pNonsupportMByFwrdAndGroupNormal,
ref pNonsupportMByDropAndGroupMalicious, ref pNonsupportMByFwrdAndGroupMalicious, iteractions);
double uA2DropAndNormalAndSupportMDAndAccept = global.uA2DropAndNormalAndSupportMDAndAccept;
double uA2FwrdAndNormalAndSupportMDAndAccept = global.uA2FwrdAndNormalAndSupportMDAndAccept;
double uA2DropAndMaliciousAndSupportMDAndAccept = global.uA2DropAndMaliciousAndSupportMDAndAccept;
double uA2FwrdAndMaliciousAndSupportMDAndAccept = global.uA2FwrdAndMaliciousAndSupportMDAndAccept;
double uA2DropAndNormalAndSupportMDAndReject = global.uA2DropAndNormalAndSupportMDAndReject;
double uA2FwrdAndNormalAndSupportMDAndReject = global.uA2FwrdAndNormalAndSupportMDAndReject;
double uA2DropAndMaliciousAndSupportMDAndReject = global.uA2DropAndMaliciousAndSupportMDAndReject;
double uA2FwrdAndMaliciousAndSupportMDAndReject = global.uA2FwrdAndMaliciousAndSupportMDAndReject;
double uA2DropAndNormalAndNonsupportMDAndAccept = global.uA2DropAndNormalAndNonsupportMDAndAccept;
double uA2FwrdAndNormalAndNonsupportMDAndAccept = global.uA2FwrdAndNormalAndNonsupportMDAndAccept;
double uA2DropAndMaliciousAndNonsupportMDAndAccept = global.uA2DropAndMaliciousAndNonsupportMDAndAccept;
double uA2FwrdAndMaliciousAndNonsupportMDAndAccept = global.uA2FwrdAndMaliciousAndNonsupportMDAndAccept;
double uA2DropAndNormalAndNonsupportMDAndReject = global.uA2DropAndNormalAndNonsupportMDAndReject;
double uA2FwrdAndNormalAndNonsupportMDAndReject = global.uA2FwrdAndNormalAndNonsupportMDAndReject;
double uA2DropAndMaliciousAndNonsupportMDAndReject = global.uA2DropAndMaliciousAndNonsupportMDAndReject;
double uA2FwrdAndMaliciousAndNonsupportMDAndReject = global.uA2FwrdAndMaliciousAndNonsupportMDAndReject;
Reader deduceNode = global.readers[deduceNodeId];
UpdateAwardFunction(cachedresults[deduceNode].supportDroppingMalicious > 0, isReportSupportM,
ref uA2DropAndNormalAndSupportMDAndAccept, ref uA2FwrdAndNormalAndSupportMDAndAccept,
ref uA2DropAndMaliciousAndSupportMDAndAccept, ref uA2FwrdAndMaliciousAndSupportMDAndAccept,
ref uA2DropAndNormalAndSupportMDAndReject, ref uA2FwrdAndNormalAndSupportMDAndReject,
ref uA2DropAndMaliciousAndSupportMDAndReject, ref uA2FwrdAndMaliciousAndSupportMDAndReject,
ref uA2DropAndNormalAndNonsupportMDAndAccept, ref uA2FwrdAndNormalAndNonsupportMDAndAccept,
ref uA2DropAndMaliciousAndNonsupportMDAndAccept, ref uA2FwrdAndMaliciousAndNonsupportMDAndAccept,
ref uA2DropAndNormalAndNonsupportMDAndReject, ref uA2FwrdAndNormalAndNonsupportMDAndReject,
ref uA2DropAndMaliciousAndNonsupportMDAndReject, ref uA2FwrdAndMaliciousAndNonsupportMDAndReject
);
if (isReportSupportM)
{
double pSupportM = pSupportMByDropAndGroupNormal * pDrop * pGroupNormal
+ pSupportMByFwrdAndGroupNormal * pFwrd * pGroupNormal
+ pSupportMByDropAndGroupMalicious * pDrop * pGroupMalicious
+ pSupportMByFwrdAndGroupMalicious * pFwrd * pGroupMalicious;
double pDropAndGroupNormalBySupportM = pSupportMByDropAndGroupNormal * pDrop * pGroupNormal/pSupportM;
double pFwrdAndGroupNormalBySupportM = pSupportMByFwrdAndGroupNormal * pFwrd * pGroupNormal / pSupportM;
double pDropAndGroupMaliciousBySupportM = pSupportMByDropAndGroupMalicious * pDrop * pGroupMalicious / pSupportM;
double pFwrdAndGroupMaliciousBySupportM = pSupportMByFwrdAndGroupMalicious * pFwrd * pGroupMalicious / pSupportM;
//计算效用函数与后验概率的乘积
double aNormalAndSupportMDAndAccept = pDropAndGroupNormalBySupportM * uA2DropAndNormalAndSupportMDAndAccept
+ pFwrdAndGroupNormalBySupportM * uA2FwrdAndNormalAndSupportMDAndAccept;
double aMaliciousAndSupportMDAndAccept = pDropAndGroupMaliciousBySupportM * uA2DropAndMaliciousAndSupportMDAndAccept
+ pFwrdAndGroupMaliciousBySupportM * uA2FwrdAndMaliciousAndSupportMDAndAccept;
double aNormalAndSupportMDAndReject = pDropAndGroupNormalBySupportM * uA2DropAndNormalAndSupportMDAndReject
+ pFwrdAndGroupNormalBySupportM * uA2FwrdAndNormalAndSupportMDAndReject;
double aMaliciousAndSupportMDAndReject = pDropAndGroupMaliciousBySupportM * uA2DropAndMaliciousAndSupportMDAndReject
+ pFwrdAndGroupMaliciousBySupportM * uA2FwrdAndMaliciousAndSupportMDAndReject;
aAccept = aNormalAndSupportMDAndAccept + aMaliciousAndSupportMDAndAccept;
aReject = aNormalAndSupportMDAndReject + aMaliciousAndSupportMDAndReject;
isAccept = (aAccept > aReject);
//Console.WriteLine("pGroupNormalBySupportM:{0}, pDropBySupportM:{1}", pGroupNormalBySupportM, pDrop);
//Console.WriteLine("pGroupMaliciousBySupportM:{0}, (1-pDropBySupportM):{1}", pGroupMaliciousBySupportM, (1 - pDrop));
}
else //NonsupportM 报告说事件是正常的
{
double pNonsupportM = pNonsupportMByDropAndGroupNormal * pDrop * pGroupNormal
+ pNonsupportMByFwrdAndGroupNormal * pFwrd * pGroupNormal
+ pNonsupportMByDropAndGroupMalicious * pDrop * pGroupMalicious
+ pNonsupportMByFwrdAndGroupMalicious * pFwrd * pGroupMalicious;
double pGroupDropAndNormalByNonsupportM = pNonsupportMByDropAndGroupNormal * pDrop * pGroupNormal / pNonsupportM;
double pGroupFwrdAndNormalByNonsupportM = pNonsupportMByFwrdAndGroupNormal * pFwrd * pGroupNormal / pNonsupportM;
double pGroupDropAndMaliciousByNonsupportM = pNonsupportMByDropAndGroupMalicious * pDrop * pGroupMalicious / pNonsupportM;
double pGroupFwrdAndMaliciousByNonsupportM = pNonsupportMByFwrdAndGroupMalicious * pFwrd * pGroupMalicious / pNonsupportM;
double aNormalAndNonsupportMDAndAccept = pGroupDropAndNormalByNonsupportM * uA2DropAndNormalAndNonsupportMDAndAccept
+ pGroupFwrdAndNormalByNonsupportM * uA2FwrdAndNormalAndNonsupportMDAndAccept;
double aMaliciousAndNonsupportMDAndAccept = pGroupDropAndMaliciousByNonsupportM * uA2DropAndMaliciousAndNonsupportMDAndAccept
+ pGroupFwrdAndMaliciousByNonsupportM * uA2FwrdAndMaliciousAndNonsupportMDAndAccept;
double aNormalAndNonsupportMDAndReject = pGroupDropAndNormalByNonsupportM * uA2DropAndNormalAndNonsupportMDAndReject
+ pGroupFwrdAndNormalByNonsupportM * uA2FwrdAndNormalAndNonsupportMDAndReject;
double aMaliciousAndNonsupportMDAndReject = pGroupDropAndMaliciousByNonsupportM * uA2DropAndMaliciousAndNonsupportMDAndReject
+ pGroupFwrdAndMaliciousByNonsupportM * uA2FwrdAndMaliciousAndNonsupportMDAndReject;
aAccept = aNormalAndNonsupportMDAndAccept + aMaliciousAndNonsupportMDAndAccept;
aReject = aNormalAndNonsupportMDAndReject + aMaliciousAndNonsupportMDAndReject;
isAccept = (aAccept > aReject);
//Console.WriteLine("pGroupNormalByNonsupportM:{0}, pDropByNonsupportM:{1}", pGroupNormal, pDropByNonsupportM);
//Console.WriteLine("pGroupMaliciousByNonsupportM:{0}, (1-pDropByNonsupportM):{1}", pGroupMalicious, (1 - pDropByNonsupportM));
}
bool isDuduceNormalEvent= (isReportSupportM ^ isAccept);
string deductionStep = "";
if(isDeduceStep2 == false)
deductionStep = "DEDUCTION1-1";
else if(deduceNode.Neighbors.ContainsKey(suspectedNodeId))//是第二步
deductionStep = "DEDUCTION1-2";
else
deductionStep = "DEDUCTION1-3";
string sAccept = (isAccept == true) ? "accept" : "reject";
string sSupport = (isReportSupportM == true) ? "supporting" : "nonsupporting";
//这里由于真实事件都是正常的，所以直接用true代替,ps:DropData代表正常场景下丢包
string sResult = (isDuduceNormalEvent != global.DropData) ? "Succ" : "Fail";
sResult = (isDeduceStep2 == true) ? sResult : "None";
//尽管在第一步中，deduction是deduceNode做的，但是我们这里写是this做的
Console.WriteLine("{0:F4} [{1}] {2}{3} deduces {4} {5}{6} is {7} by {8}. [{9}:{10}]\t[{11}:{12}]\t[{13}:{14}]-${15}$:{16}",
scheduler.currentTime, deductionStep, this.type, this.Id, sSupport, NodeType.READER, suspectedNodeId, sAccept, deduceNodeId,
aAccept, aReject, supportMWeight, nonsupportMWeight, supportMNodes, nonsupportMNodes, pkgIdent, sResult);
if (isDeduceStep2 == true)
{
Console.Write("{0:F4} [ORG_TRUST] {1}{2}:\t", scheduler.currentTime, this.type, this.Id);
for (int i = 0; i < global.orgNum; i++)
{
Console.Write("{0}-", localNodeTrustWeights[global.orgs[i]]);
}
Console.WriteLine();
}
//比较各个节点的报告与整体报告的差别，如果我接受整体报告，则惩罚与整体报告不同的节点(即与supportReport相反的节点)，反之亦然
if (isDeduceStep2 == true)
{
PunishMaliciousNodes(isDuduceNormalEvent, cachedresults);
if (this.Neighbors.ContainsKey(suspectedNodeId))
UpdateNodeBelieves(isDuduceNormalEvent, pGroupNormal > 0.5, isReportSupportM, iteractions, isDeduceStep2);
}
Deduce2Result d2r = new Deduce2Result();
d2r.IsAccept = isAccept;
d2r.IsTotalReportSupport = isReportSupportM;
return d2r;
}
public void GenerateSendEvents(bool clear, bool reload, Node[] froms, Node[] tos, string cmd, double mindist, int tagNum, int generateMode)
{
}
// 根据辅助数组和原始数组生成结果数组
public Node[] createResult(Node[] a, int[] temp, int m)
{
Node[] result = new Node[m];
int j = 0;
for (int i = 0; i < a.Length; i++)
{
if (temp[i] == 1)
{
result[j] = a[i];
//Console.WriteLine("result[" + j + "]:" + result[j]);
j++;
}
}
return result;
}
public void SendNewGroupResponse(int rootId, int k, int origId, HashSet<int> result, Node to)
{
//Console.WriteLine("debug: list:{0}, ++reader{1}", Utility.DumpHashIntSet(result), this.id);
this.retryOnSendingFailture = true;
Packet pkg = new Packet(this, to, PacketType.NEW_GROUP_RESPONSE);
pkg.TTL = global.longTTL;
pkg.NewGroupResponse = new NewGroupResponseField(rootId, k, origId, result);
SendData(pkg);
this.retryOnSendingFailture = false;
}
public Packet(Node src, Node dst, PacketType type, float time)
: this(src, dst, type)
{
this.beginSentTime = time;
}
public Packet(Node src, Node dst, PacketType type)
{
this.Src = this.Prev = src.Id;
this.Dst = this.Next = dst.Id;
this.SrcType = this.PrevType = src.type;
this.DstType = this.NextType = dst.type;
this.Type = type;
this.TTL = Global.getInstance().TTL;
this.DelPacketNode = this.Dst;
this.beginSentTime = Scheduler.getInstance().currentTime;
this.SrcSenderSeq = -1; //SrcSenderSeq和PrevSenderSeq初始值为负，表明该数据包的id未定
this.PrevSenderSeq = -1;
}
//send events. the cmd is SND_DATA or SND_CMD
public virtual void GenerateSendEvents(bool append, bool reload, Node[] froms, Node[] tos, string cmd)
{
Global global = Global.getInstance();
string line = null;
StreamWriter sw = null;
sw = new StreamWriter(global.eventsFileName, append);
sw.WriteLine();
double t = (global.endTime - global.startTime) / global.SendEventNum;
double current = 0;
for (int i = 0; i < global.SendEventNum; i++)
{
Node snode = froms[Utility.Rand(froms.Length)];
Node dnode = snode;
if (snode.type == NodeType.OBJECT && tos[0].type == NodeType.ORG)
dnode = global.orgs[((ObjectNode)snode).OrgId];
else
{
while (dnode == snode)
dnode = tos[Utility.Rand(tos.Length)];
}
double time = Utility.P_Rand(t);
current += time;
if (current >= global.endTime)//End
break;
double end = Utility.U_Rand(current, global.endTime);
double freq = 0.5;
line = cmd + "\t" + snode + "\t" + dnode + "\t" + (int)current + "\t" + (int)end + "\t" + freq;
sw.WriteLine(line);
}
if (sw != null)
sw.Close();
if (reload == true)
Event.LoadEvents();
}
public override void ProcessEvent(Node node, Event e)
{
HFReader reader = (HFReader)node;
switch (e.Type)
{
case EventType.CHK_SW_NB:
((SWReader)reader).CheckSmallWorldNeighbors(e.Obj);
break;
case EventType.SND_DATA:
Packet pkg = (Packet)e.Obj;
HFGlobal global = (HFGlobal)Global.getInstance();
global.currentSendingTags = pkg.Tags;
if (pkg.inited == false && pkg.Src == node.Id && pkg.Type == PacketType.DATA)
{
double distance = Utility.Distance((MobileNode)node, (MobileNode)Node.getNode(pkg.Dst, NodeType.READER));
double mindist = global.minSrcDstDist;
//为了控制在mindist左右，设置了距离上限
int count = 0;
while (distance < mindist || distance >mindist+100 && count++ < 20)
{
int orgId = ((Reader)node).OrgId;
Organization org = (Organization)Node.getNode(orgId, NodeType.ORG);
HashSet<MobileNode> candidateDstNodes = new HashSet<MobileNode>();
List<MobileNode> allAllowNodes = new List<MobileNode>();
//找出[mindist-100, mindist+100]的节点
List<NodeDist> tmpDists = new List<NodeDist>();
foreach (MobileNode node1 in global.readers)
{
double dist = Utility.Distance((MobileNode)node, (MobileNode)node1);
if (dist > mindist && dist < mindist + 100 && node.Id != node1.Id)
{
candidateDstNodes.Add(node1);
tmpDists.Add(new NodeDist(node1, dist, ((HFReader)node1).IsAllowedTags(pkg.Tags)));
}
}
if (candidateDstNodes.Count == 0)
{
Console.WriteLine("[WARNING] reader{0} has no far enough nodes, retry", this);
node = global.readers[(int)Utility.U_Rand(global.readerNum)];
pkg.Src = node.Id;
pkg.Prev = node.Id;
distance = Utility.Distance((MobileNode)node, (MobileNode)Node.getNode(pkg.Dst, NodeType.READER));
Console.WriteLine("src is changed to {0}", pkg.Src);
continue;
}
NodeDist[] tmpDist1 = (NodeDist[])tmpDists.ToArray();
Array.Sort(tmpDist1);
//allAllowNodes中的元素顺序为：源节点(1)，候选终结点，中间节点
allAllowNodes.Add((MobileNode)node);
foreach (NodeDist d in tmpDist1)
{
allAllowNodes.Add(d.node);
}
foreach (HFReader node1 in global.readers)
{
if (!candidateDstNodes.Contains(node1) && node1.IsAllowedTags(pkg.Tags))
allAllowNodes.Add(node1);
}
Dijkstra di = new Dijkstra(allAllowNodes);
int[] allAllowNodePathDist = di.GetAllShortedPaths(0);
MobileNode dstNode = null;
for (int candidateDstIndex = 1; candidateDstIndex < candidateDstNodes.Count + 1; candidateDstIndex++)
{
if (allAllowNodePathDist[candidateDstIndex] == Dijkstra.noPath)
continue;
dstNode = allAllowNodes[candidateDstIndex];
for (int u = 0; u < allAllowNodes.Count; u++)
{
if (di.shortestPaths[candidateDstIndex, u] == Dijkstra.noPath)
break;
int x = di.shortestPaths[candidateDstIndex, u];
//如果不是最后一个节点，且该中间节点为其他终结点，则放弃，（取其他的节点即可）
//if (x != dstNode.Id && candidateDstNodes.Contains(global.readers[x]))
/*if(u>9)
{
Console.WriteLine();
dstNode = null;
break;
}*/
Console.Write(allAllowNodes[x] + "->");
}
if (dstNode != null)
{
pkg.Dst = dstNode.Id;
Console.WriteLine("\ndst is changed to {0}", pkg.Dst);
break;
}
}
if (dstNode == null)
{
Console.WriteLine("No suitable nodes, retry.");
node = global.readers[(int)Utility.U_Rand(global.readerNum)];
pkg.Src = node.Id;
pkg.Prev = node.Id;
distance = Utility.Distance((MobileNode)node, (MobileNode)Node.getNode(pkg.Dst, NodeType.READER));
Console.WriteLine("\nsrc is changed to {0}", pkg.Src);
}
else
break;
}
distance = Utility.Distance((MobileNode)node, (MobileNode)Node.getNode(pkg.Dst, NodeType.READER));
Console.WriteLine("{0:F4} [SND_DATA] READER{1} sends data to READER{2} with tags {3}, distance: {4}", currentTime, pkg.Src, pkg.Dst, Convert.ToString(pkg.Tags, 2), distance);
}
node.SendData(pkg);
break;
default:
base.ProcessEvent(node, e);
break;
}
}
public List<Node[]> combination(Node[] a, int m)
{
Combination c = new Combination();
List<Node[]> list = new List<Node[]>();
int n = a.Length;
if (m == 0)
{
list.Add(new Node[] { });
return list;
}
else if (m == n)
{
Node[] temp = new Node[a.Length];
a.CopyTo(temp, 0);
list.Add(a);
return list;
}
bool end = false; // 是否是最后一种组合的标记
// 生成辅助数组。首先初始化，将数组前n个元素置1，表示第一个组合为前n个数。
int[] tempNum = new int[n];
for (int i = 0; i < n; i++)
{
if (i < m)
{
tempNum[i] = 1;
}
else
{
tempNum[i] = 0;
}
}
//printVir(tempNum);// 打印首个辅助数组
list.Add(c.createResult(a, tempNum, m));// 打印第一种默认组合
int k = 0;//标记位
while (!end)
{
bool findFirst = false;
bool swap = false;
// 然后从左到右扫描数组元素值的"10"组合，找到第一个"10"组合后将其变为"01"
for (int i = 0; i < n; i++)
{
int l = 0;
if (!findFirst && tempNum[i] == 1)
{
k = i;
findFirst = true;
}
if (tempNum[i] == 1 && tempNum[i + 1] == 0)
{
tempNum[i] = 0;
tempNum[i + 1] = 1;
swap = true;
for (l = 0; l < i - k; l++)
{ // 同时将其左边的所有"1"全部移动到数组的最左端。
tempNum[l] = tempNum[k + l];
}
for (l = i - k; l < i; l++)
{
tempNum[l] = 0;
}
if (k == i && i + 1 == n - m)
{//假如第一个"1"刚刚移动到第n-m+1个位置,则终止整个寻找
end = true;
}
}
if (swap)
{
break;
}
}
//printVir(tempNum);// 打印辅助数组
list.Add(c.createResult(a, tempNum, m));// 添加下一种默认组合
}
return list;
}
public void SendSubTreeInfo(int rootId, List<int> list, SubNodeStatus status, int cn, Node parent)
{
Packet pkg = new Packet(this, parent, PacketType.SUBTREE_INFO);
pkg.SubTreeInfo = new SubTreeInfoField(list, (int)status, cn, rootId);
SendData(pkg);
//debug
Console.WriteLine("debug: status:{0} cn:{1} list:{2}", status, cn, Utility.DumpListIntSet(list));
}
//srcCachedTime是指目的节点在源节点路由表缓存中的最新更新时间，如果没有该项，则该值为-1
public void SendAODVRequest(Node node, int src, int dst, int hops, double srcCachedTime, bool forceDiscovery)
{
Packet pkg = new Packet(this, node, PacketType.AODV_REQUEST);
pkg.Data = new AODVRequest(src, dst, hops, srcCachedTime);
pkg.forceDiscovery = forceDiscovery;
pkg.TTL = 1;
SendPacketDirectly(scheduler.currentTime, pkg);
}
public void GenerateSendEvents(bool clear, bool reload, Node[] froms, Node[] tos, string cmd, double mindist, int tagNum, int generateMode)
{
HFGlobal global = (HFGlobal)Global.getInstance();
string line = null;
string tempfile = ".tmp";
if (File.Exists(tempfile))
File.Delete(tempfile);
File.Copy(global.eventsFileName, tempfile);
StreamReader sr = new StreamReader(tempfile);
StreamWriter sw = new StreamWriter(global.eventsFileName, false);
List<string> tempList = new List<string>();
//先复制到文件
while ((line = sr.ReadLine()) != null)
{
if (line.IndexOf(cmd) >= 0 && line[0] != '#')
{
tempList.Add(line);
if (clear == true)
continue;
}
sw.WriteLine(line);
}
sw.WriteLine();
sw.WriteLine("#SND_DATA src dst begin end interval tag t1_t2_t3");
if (generateMode == 1)// overwrite sending
{
foreach (string c in tempList)
{
string[] array = c.Split(new string[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
Node snode = Node.getNode(array[1]);
Node dnode = Node.getNode(array[2]);
float starttime = float.Parse(array[3]);
float endtime = float.Parse(array[4]);
float interval = float.Parse(array[5]); ;
//这里需要找到与src同在一个机构的节点，tag一致
if (dnode == BroadcastNode.Node)
{
int orgId = ((Reader)snode).OrgId;
Organization org = (Organization)Node.getNode(orgId, NodeType.ORG);
List<Node> tmpNodes = new List<Node>();
foreach (Node node in org.nodes)
{
if (Utility.Distance((MobileNode)snode, (MobileNode)node) > mindist)
tmpNodes.Add(node);
}
if (tmpNodes.Count == 0)
{
foreach (Node node in global.readers)
{
if (Utility.Distance((MobileNode)snode, (MobileNode)node) > mindist)
tmpNodes.Add(node);
}
if (tmpNodes.Count == 0)
{
Console.WriteLine("[WARNING] reader{0} has no far enough nodes", snode);
sw.WriteLine(line);
continue;
}
}
int n = (int)Utility.U_Rand(tmpNodes.Count);
dnode = org.nodes[n];
}
HashSet<int> tmpTags = new HashSet<int>();
while (tmpTags.Count < tagNum)
{
int t = (int)Utility.U_Rand(global.tagNameNum);
if (((SWReader)snode).IsAllowedTags((uint)1 << t) && !tmpTags.Contains(t))
tmpTags.Add(t);
}
//uint tags = 0;
string tags = "";
foreach (int t in tmpTags)
{
//tags = tags | (uint)1 << t;
tags += (t + "_");
}
tags = tags.Substring(0, tags.Length - 1);
line = cmd + "\t" + snode + "\t" + dnode + "\t" + starttime + "\t" + endtime + "\t" + interval + "\ttag\t" + tags;
sw.WriteLine(line);
}
}
else //generate new sending
{
double current = 0;
double currentSendSeg = 0;
double sendSeg = (global.endTime - global.startTime) / global.SendEventNum;
//开始有warming，skip
currentSendSeg += 2 * sendSeg;
for (int i = 0; i < global.SendEventNum; i++)
{
Node snode = null;
do
{
snode = froms[Utility.Rand(froms.Length)];
} while (((SWReader)snode).IsAllowedAllTags());
Node dnode = snode;
int orgId = ((Reader)snode).OrgId;
Organization org = (Organization)Node.getNode(orgId, NodeType.ORG);
List<Node> tmpNodes = new List<Node>();
foreach (Node node in org.nodes)
{
if (Utility.Distance((MobileNode)snode, (MobileNode)node) > mindist && snode.Id != node.Id)
tmpNodes.Add(node);
}
if (tmpNodes.Count == 0)
{
foreach (Node node in global.readers)
{
if (Utility.Distance((MobileNode)snode, (MobileNode)node) > mindist)
tmpNodes.Add(node);
}
if (tmpNodes.Count == 0)
{
Console.WriteLine("[WARNING] reader{0} has no far enough nodes", snode);
continue;
}
}
dnode = tmpNodes[(int)Utility.U_Rand(tmpNodes.Count)];
//持续发送时间
double sendDuration = 0;
//发送的结束时间
double endtime = 0;
//发送间隔
double sendInterval = 0;
current = currentSendSeg + Utility.U_Rand(0, sendSeg);
if (global.SendEventDuration > 0)
{
sendDuration = global.SendEventDuration;
endtime = current + sendDuration;
sendInterval = global.SendEventInterval;
}
else
{
sendDuration = Utility.P_Rand(sendSeg);
endtime = Utility.U_Rand(current, global.endTime);
sendInterval = global.SendEventInterval;
current += sendDuration;
}
if (current >= global.endTime)//End
break;
int num = global.SendEventMinTagNum +
Utility.Rand(global.SendEventMaxTagNum - global.SendEventMinTagNum); //>=1
//set中是发送数据包的标签集合，最多有num个标签
HashSet<int> tmpTags = new HashSet<int>();
while (tmpTags.Count < num)
{
int t = Utility.Rand(global.tagNameNum);
if (((SWReader)snode).IsAllowedTags((uint)1 << t) && !tmpTags.Contains(t))
tmpTags.Add(t);
}
string tags = "";
foreach (int t in tmpTags)
{
tags += (t + "_");
}
tags = tags.Substring(0, tags.Length - 1);
line = cmd + "\t" + snode + "\t" + dnode + "\t" + current + "\t" + endtime + "\t" + sendInterval + "\ttag\t"
+ tags;
sw.WriteLine(line);
Console.WriteLine("{0}---{1}", line, Utility.Distance((MobileNode)snode, (MobileNode)dnode));
currentSendSeg += sendSeg;
}
}
if (sw != null)
sw.Close();
if (sr != null)
sr.Close();
if (reload == true)
Event.LoadEvents();
}
private void AddNeighborReports(Node minNode, MODEventTrustResult realr, int suspectedNodeId, string pkgIdent, Dictionary<Node, MODEventTrustResult> reports)
{
{
MODReader nbNode = (MODReader)minNode;
//如果已经保存，则继续
if (!reports.ContainsKey(nbNode))
{
MODEventTrustResult r = null;
//恶意节点
if (nbNode.IsMalicious() && realr.supportDroppingMalicious <= 0)
{
//如果事件是正常的，那么伪造恶意事件
r = MODEventTrust.ForgeMaliciousEventTrustResult(suspectedNodeId, nbNode.Id, pkgIdent, MODEventCategoryType.DropPacket);
r.supportDroppingMalicious = 1;
}
else if (nbNode.IsMalicious() && realr.supportDroppingMalicious > 0)
{
//如果事件是恶意的，那么伪造正常事件
r = MODEventTrust.ForgeNormalEventTrustResult(suspectedNodeId, nbNode.Id, pkgIdent, MODEventCategoryType.DropPacket);
r.supportDroppingMalicious = -1;
}
else
{
r = new MODEventTrustResult(suspectedNodeId, nbNode.Id, pkgIdent, MODEventCategoryType.DropPacket, realr.ds);
r.supportDroppingMalicious = realr.supportDroppingMalicious;
}
reports.Add(nbNode, r);
}
}
foreach (int nbId in this.Neighbors.Keys)
{
if (nbId == minNode.Id)
continue;
MODReader nbNode = (MODReader)global.readers[nbId];
//如果已经保存，则继续
if (!reports.ContainsKey(nbNode))
{
if (reports.Count >= global.MaxReportCount)
break;
MODEventTrustResult r = null;
//恶意节点
if (nbNode.IsMalicious() && realr.supportDroppingMalicious <= 0)
{
//如果事件是正常的，那么伪造恶意事件
r = MODEventTrust.ForgeMaliciousEventTrustResult(suspectedNodeId, nbNode.Id, pkgIdent, MODEventCategoryType.DropPacket);
r.supportDroppingMalicious = 1;
}
else if (nbNode.IsMalicious() && realr.supportDroppingMalicious > 0)
{
//如果事件是恶意的，那么伪造正常事件
r = MODEventTrust.ForgeNormalEventTrustResult(suspectedNodeId, nbNode.Id, pkgIdent, MODEventCategoryType.DropPacket);
r.supportDroppingMalicious = -1;
}
else
{
r = new MODEventTrustResult(suspectedNodeId, nbId, pkgIdent, MODEventCategoryType.DropPacket, realr.ds);
r.supportDroppingMalicious = realr.supportDroppingMalicious;
}
reports.Add(nbNode, r);
}
}
}
public virtual void ProcessEvent(Node node, Event e)
{
switch (e.Type)
{
case EventType.RECV:
node.Recv((Packet)e.Obj);
break;
case EventType.SND_BCN:
((Reader)node).SendBeacon(currentTime);
break;
case EventType.SND_DATA:
Packet pkg = (Packet)e.Obj;
if (pkg.SrcSenderSeq < 0 && node.type == NodeType.READER)//未定该数据包的id
((Reader)node).InitPacketSeq(pkg);
node.SendData(pkg);
break;
case EventType.CHK_NB:
((Reader)node).CheckNeighbors();
break;
case EventType.CHK_NEAR_OBJ:
((Reader)node).CheckNearObjects();
break;
case EventType.CHK_PEND_PKT:
((Reader)node).CheckPendingPackets();
break;
case EventType.QRY_LOCATION:
((Querier)node).SendQueryRequest((int)e.Obj);
break;
default:
throw new Exception("Unknown event type: " + e.Type);
}
}
