/*接收一个分组*/
/*返回值说明:
* 1.如果正常接收,返回读取数据的长度
* 2.如果接收超时,返回-1 //此句已经无效
* 3.如果接收到本分组的分组头,返回-2
* 4.如果接收到新的发送完毕包,返回-3
* 5.如果接收到上次的发送完毕包,返回-4
* 6.其他情况,返回-5
*/
//此函数只用于接收,不发送任何信息.遇到错误,只是将错误标识返回.
//如果接收到的是分组包,将其存入buffer中相应位置,返回数据的长度
public int GetDatagramData(int numberRandom, int random, byte[] buffer, bool[] receiveTip, int[] startTip)
{
//设置不接收超时
//try
//{
// socket.setSoTimeout(0);
//}
//catch (SocketException ex)
//{
// // Logger.getLogger(ReceiveLittle.class.getName()).log(Level.SEVERE, null, ex);
// logger.error("{}", ex);
//}
udpReceiveClient.Client.ReceiveTimeout = 0;
byte[] receiveBuffer = new byte[DataTip[0]];
//DatagramPacket packet = new DatagramPacket(receiveBuffer, receiveBuffer.length);
try
{
ByteChange.CleanByte(receiveBuffer);
//socket.receive(packet);
receiveBuffer = udpReceiveClient.Receive(ref host);
//receiveState.addHaveReceiveBytes(packet.getLength());
//就算收到未接收请求重发包,有意义的随机数也应该是与本分组随机数相同的
//次随机数
if (ByteChange.ByteToInt(receiveBuffer, DataTip[2]) != numberRandom)
{
return(-5);
}
//所以,先判断块随机数
int r = ByteChange.ByteToInt(receiveBuffer, DataTip[3]);
if (r != random)
{
return(-5);
}
//判断分组标识
//String s = new String(receiveBuffer, DataTip[1], 4);
String s = Encoding.Default.GetString(receiveBuffer, DataTip[1], 4);
//if (!s.equals(datagramData))
if (!datagramData.Equals(s))
{
//如果此包不是分组包
//判断其是否是本分组的分组头.由于随机数已经匹配,所以,只需要判断标识
//if (s.equals(datagramHead))
if (datagramHead.Equals(s))
{
return(-2);
}
//再判断其是否是发送完毕包
//if (s.equals(datagramFinish))
if (datagramFinish.Equals(s))
{
//先判断,是否是新的发送完毕包
r = ByteChange.ByteToInt(receiveBuffer, FinishTip[4]);
if (!littleRandomStack.InIt(r))
{
littleRandomStack.Add(r);
return(-3);
}
//如果是上次的发送完毕包
int r2 = littleRandomStack.GetLast();
if (r2 != -1 && r2 == r)
{
return(-4);
}
}
//否则,返回-5
return(-5);
}
//至此已经是分组包了,先判断一下包的完整性
//因为,如果包是不完整的,它的数据就是有问题的,是不能接收的
//s = new String(receiveBuffer, DataTip[7], 4);
s = Encoding.Default.GetString(receiveBuffer, DataTip[7], 4);
//if (!s.equals(datagramTail))
if (!datagramTail.Equals(s))
{
return(-5);
}
//包是完整的,获取包的序号
int serial = ByteChange.ByteToShort(receiveBuffer, DataTip[4]);
int number = ByteChange.ByteToShort(receiveBuffer, DataTip[5]);
//如果该序列的包未被正确接收
if (!receiveTip[serial])
{
receiveTip[serial] = true;
for (int i = 0; i < number; i++)
{
buffer[i + startTip[serial]] = receiveBuffer[i + DataTip[6]];
}
return(number);
}
//如果已经被正确接收了,则丢弃该包
else
{
return(-5);
}
}
catch (Exception ex)
{
//Logger.getLogger(Receive.class.getName()).log(Level.SEVERE, null, ex);
if (ex is TimeoutException)
{
return(-1);
}
if (ex is SocketException)
{
return(-1);
}
return(-5);
}
}
/* 接收请求重发包 */
/* 返回接收方是否接收完毕 */
public bool GetDatagramReq(int numberRandom, int blockRandom, int littleRandom, bool[] sendTip)
{
//log.Info("GetDatagramReq进入");
// 首先,设置接收超时5ms
//DatagramPacket packetReq = null;
// 由于请求重发包发送的是需要重发的分组
// 所以,先将成功发送标记全部置true,再根据
for (int i = 0; i < sendTip.Length; i++)
{
sendTip[i] = true;
}
// 请求重发包将发送失败的置false
byte[] buffer = new byte[ReqAgainTip[0]];
bool canSendFinish = true;
while (true)
{
try
{
if (canSendFinish)
{
udpSendClient.Client.ReceiveTimeout = sendState.WaitTime;
SendFinish(numberRandom, blockRandom, littleRandom);
}
ByteChange.CleanByte(buffer);
buffer = udpSendClient.Receive(ref host);
// 如果接收到数据包,不管是否正确,下一轮都不能发未接收请求重发包
canSendFinish = false;
// 对接收到的请法求重发包进行解析
// 检证是不是请求重发包
String s = Encoding.Default.GetString(buffer, ReqAgainTip[1], 4);
if (!datagramReqAgain.Equals(s))
{
continue;
}
// 匹配次随机数
int r = ByteChange.ByteToInt(buffer, ReqAgainTip[2]);
if (r != numberRandom)
{
continue;
}
// 匹配块随机数
r = ByteChange.ByteToInt(buffer, ReqAgainTip[3]);
if (r != blockRandom)
{
continue;
}
// //验证该包是否完整
// s=new String(buffer,1014,4);
// if(!s.equals(datagramTail)){
// continue;
// }
// 验证此请求重发包的小随机数是否与本次发送的"发送完毕包"相同
r = ByteChange.ByteToInt(buffer, ReqAgainTip[4]);
if (r != littleRandom)
{
continue;
}
// 验证完毕,提取请求重发的分组
// 提取数据长度
int length = ByteChange.ByteToShort(buffer, ReqAgainTip[5]);
// 如果数据长度是0,验证一下数据完整性,如果完整,则返回数据接收完毕
if (length == 0)
{
//s = new String(buffer, ReqAgainTip[5] + 2, 4);
s = Encoding.Default.GetString(buffer, ReqAgainTip[5] + 2, 4);
//if (s.equals(datagramTail))
if (datagramTail.Equals(s))
{
// 数据完整,返回
//log.Info("GetDatagramReq退出true");
return(true);
}
else
{
// 数据不完整,此包无效,继续循环
continue;
}
}
else
{
sendState.NumResendPackets = 0;
for (int i = 0; i < length; i++)
{
int tip = ByteChange.ByteToShort(buffer, i * 2 + ReqAgainTip[6]);
sendTip[tip] = false;
sendState.AddNumResendPackets();
}
//log.Info("GetDatagramReq退出");
break;
}
}
catch (SocketException ex)
{
// Logger.getLogger(Send.class.getName()).log(Level.SEVERE,null, ex);
// 如果是接收超时,那么下一次循环就应该发送"发送完毕包"
if (ex.ErrorCode == 10060)
{
canSendFinish = true;
int time = sendState.WaitTime;
if (time <= 1800 && time > 0)
{
sendState.WaitTime = (time + 10);//延迟时间+10
}
}
}
}
return(false);
}
/*接收分组头*/
//1.不接收超时. 2.接收成功,会调用发送分组头确认包
public Rdh_return ReceiveDatagramHead(int numberRandom)
{
byte[] buffer = new byte[FilePropertyTip[0]];
//DatagramPacket packet = null;
Rdh_return rdh = new Rdh_return();
//设置不接收超时
udpReceiveClient.Client.ReceiveTimeout = 0;
while (true)
{
try
{
//packet = new DatagramPacket(buffer, buffer.length);//,InetAddress.getByName(yourAddress),yourPort
ByteChange.CleanByte(buffer);
//socket.receive(packet);
//receiveState.addHaveReceiveBytes(packet.getLength());
buffer = udpReceiveClient.Receive(ref host);
//检查分组头标识
//String str = new String(buffer, HeadTip[1], 4);
String str = Encoding.Default.GetString(buffer, HeadTip[1], 4);
//if (!str.equals(datagramHead))
if (!datagramHead.Equals(str))
{
/*既然不是分组头,重新接收是肯定的.只不过,有些情况,需要处理一下再重新接收*/
//如果是开始传输包
//if (str.equals(datagramStart))
if (datagramStart.Equals(str))
{
int num = ByteChange.ByteToInt(buffer, StartTip[2]);
if (num == numberRandom)
{
SendStartAck(numberRandom);
// System.out.println("在分组头中接收到开始传输包");
continue;
}
}
//如果是发送完毕包
//if (str.equals(datagramFinish))
if (datagramFinish.Equals(str))
{
//先检其次随机数
if (ByteChange.ByteToInt(buffer, FinishTip[2]) == numberRandom)
{
//检验是不是上一次的发送完毕包
//如果是的,说明上次发的0请求重发包没发成功
//先检查其块随机数是不是上一次的
if (randomStack.GetLast() != -1 && ByteChange.ByteToInt(buffer, FinishTip[3]) == randomStack.GetLast())
{
//再检查其小随机数,是不是上次的(即最后一次发过来的)
if (littleRandomStack != null)
{
//如果littelRandomStack是null,说明这是第一次接收分组头,当然不可能要重发
if (littleRandomStack.GetLast() == ByteChange.ByteToInt(buffer, FinishTip[4]))
{
//如果小随机数也匹配,则发送上次的0请求重发包
if (lastReqAgainBuffer != null)
{
//socket.send(lastReqAgain);
udpReceiveClient.Send(lastReqAgainBuffer.ToArray(), lastReqAgainBuffer.Count, host);
}
}
}
}
}
}
//如果是传输结束包,则将0分组数量填充入rdh,然后返回
//if (str.equals(datagramStop))
if (datagramStop.Equals(str))
{
rdh.Number = 0;
return(rdh);
}
continue;
}
//检查该包是否完整
//str = new String(buffer, HeadTip[5], 4);
str = Encoding.Default.GetString(buffer, HeadTip[5], 4);
//if (!str.equals(datagramTail))
if (!datagramTail.Equals(str))
{
continue;
}
//检查完毕,获取随机数
rdh.Random = ByteChange.ByteToInt(buffer, HeadTip[3]);
//获取分组数量
rdh.Number = ByteChange.ByteToShort(buffer, HeadTip[4]);
SendDatagramHeadAck(numberRandom, rdh.Random);
break;
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString());
// Logger.getLogger(ReceiveLittle.class.getName()).log(Level.SEVERE, null, ex);
//logger.error("{}", ex);
}
}
return(rdh);
}
