public void Equals_Negative()
{
var a = new RouteHeader()
{
Name = "foo",
Mode = HeaderMatchMode.Exists,
Values = new[] { "v1", "v2" },
IsCaseSensitive = true,
};
var b = a with {
Name = "bar"
};
var c = a with {
Mode = HeaderMatchMode.ExactHeader
};
var d = a with {
Values = new[] { "v1", "v3" }
};
var e = a with {
IsCaseSensitive = false
};
Assert.False(a.Equals(b));
Assert.False(a.Equals(c));
Assert.False(a.Equals(d));
Assert.False(a.Equals(e));
}
async void Tick()
{
byte[] tick = new RouteHeader()
{
header = Header.TICK
}.ToByteArray();
while (true)
{
try
{
//if (!isRunTick)
//{
// await Task.Delay(10);
// continue;
//}
//Console.WriteLine("send tick");
socket.Send(tick, 0, tick.Length, remoteEnd);
await Task.Delay(100);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
public async Task Rejects_InvalidRouteHeader(string name, string value, HeaderMatchMode mode, string error)
{
var routeHeader = new RouteHeader()
{
Name = name,
Mode = mode,
};
if (value != null)
{
routeHeader.Values = new[] { value };
}
var route = new ProxyRoute
{
RouteId = "route1",
Match =
{
Path = "/",
Headers = new[] { routeHeader },
},
ClusterId = "cluster1",
};
var services = CreateServices();
var validator = services.GetRequiredService <IConfigValidator>();
var result = await validator.ValidateRouteAsync(route);
var ex = Assert.Single(result);
Assert.Contains(error, ex.Message);
}
public static RouteHeader CreateRouteHeader(string dataAreaId, string routeId)
{
RouteHeader routeHeader = new RouteHeader();
routeHeader.dataAreaId = dataAreaId;
routeHeader.RouteId = routeId;
return(routeHeader);
}
private static RouteHeader CreateRouteHeader(IConfigurationSection section)
{
var routeHeader = new RouteHeader()
{
Name = section[nameof(RouteHeader.Name)],
Values = section.GetSection(nameof(RouteHeader.Values)).ReadStringArray(),
Mode = section.ReadEnum <HeaderMatchMode>(nameof(RouteHeader.Mode)) ?? HeaderMatchMode.ExactHeader,
IsCaseSensitive = section.ReadBool(nameof(RouteHeader.IsCaseSensitive)) ?? false,
};
return(routeHeader);
}
private static RouteHeader Convert(RouteHeaderData data)
{
var routeHeader = new RouteHeader()
{
Name = data.Name,
Values = data.Values,
Mode = data.Mode,
IsCaseSensitive = data.IsCaseSensitive,
};
return(routeHeader);
}
public void DeepClone_Nulls_Works()
{
var sut = new RouteHeader();
var clone = sut.DeepClone();
Assert.NotSame(sut, clone);
Assert.Null(clone.Name);
Assert.Null(clone.Values);
Assert.Equal(HeaderMatchMode.ExactHeader, clone.Mode);
Assert.False(clone.IsCaseSensitive);
Assert.True(RouteHeader.Equals(sut, clone));
}
private void CreateCommonHeaders(SipUser sipUser, LocalSipUserAgentServer localSipUas, SipTransportManager sipTransportManager)
{
this.viaHeader = new ViaHeader(localSipUas, sipTransportManager.SipProtocol, sipTransportManager.SipTransport);
this.fromHeader = new FromHeader(sipUser, localSipUas, sipTransportManager.SipProtocol);
this.toHeader = new ToHeader(localSipUas, sipTransportManager.SipProtocol);
this.callIdHeader = new CallIdHeader();
this.contactHeader = new ContactHeader(localSipUas, sipTransportManager.SipProtocol);
this.routeHeader = new RouteHeader(localSipUas, sipTransportManager.SipProtocol);
this.userAgent = new UserAgentHeader();
this.expiresHeader = new ExpiresHeader();
this.maxForwards = new MaxForwardsHeader();
this.allowHeader = new AllowHeader();
this.contentLength = new ContentLength(body);
}
public void DeepClone_Works()
{
var sut = new RouteHeader
{
Name = "header1",
Values = new[] { "value1", "value2" },
Mode = HeaderMatchMode.HeaderPrefix,
IsCaseSensitive = true,
};
var clone = sut.DeepClone();
Assert.NotSame(sut, clone);
Assert.Equal(sut.Name, clone.Name);
Assert.NotSame(sut.Values, clone.Values);
Assert.Equal(sut.Values, clone.Values);
Assert.Equal(sut.Mode, clone.Mode);
Assert.Equal(sut.IsCaseSensitive, clone.IsCaseSensitive);
Assert.True(RouteHeader.Equals(sut, clone));
}
public void Equals_Positive()
{
var a = new RouteHeader()
{
Name = "foo",
Mode = HeaderMatchMode.Exists,
Values = new[] { "v1", "v2" },
IsCaseSensitive = true,
};
var b = new RouteHeader()
{
Name = "foo",
Mode = HeaderMatchMode.Exists,
Values = new[] { "v1", "v2" },
IsCaseSensitive = true,
};
var c = a with {
}; // Clone
Assert.True(a.Equals(b));
Assert.True(a.Equals(c));
}
public async void Recv()
{
if (isRun)
{
try
{
await Task.Factory.StartNew(() =>
{
if (socket.Available <= 0)
{
Thread.Sleep(1);
Recv();
return;
}
byte[] buffer = new byte[1024 * 16];
int n = socket.Recv(buffer, headOffset, buffer.Length - headOffset, out var endp);
Recv();
//Console.WriteLine($"RouteServer:: Recv { Encoding.ASCII.GetString(buffer, 0, n)} remote = {endp} ");
if (endp.eq(serverPoint))
{
int idx = headOffset;
if (buffer.TryGet(ref idx, out RouteHeader header))
{
//Console.WriteLine("header " + header.header.opcode);
if (Header.TICK == header.header)
{
tickCount = 0;
//Interlocked.Exchange(ref tickCount, 0);
}
else if (Header.MSG == header.header)
{
tickCount = 0;
// Interlocked.Exchange(ref tickCount, 0);
if (id2client.TryGetValue(header.cid, out var point))
{
socket.Send(buffer, idx, n - headOffset, point);
}
}
}
}
else
{
if (!client2id.TryGetValue(endp, out var cid))
{
cid = seed++;
client2id.Add(endp, cid);
id2client.Add(cid, endp);
}
//Console.WriteLine($"RouteServer orgion:: {buffer.ToHexStr(0, n)}");
var header = new RouteHeader()
{
header = Header.MSG, cid = cid
};
int id = 0;
buffer.TrySet(ref id, header);
//Console.WriteLine($"RouteServer after:: {buffer.ToHexStr(0, n)}");
socket.Send(buffer, 0, n + headOffset, serverPoint);
}
}).ConfigureAwait(false);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.ConnectionReset)
{
//continue;
}
if (se.SocketErrorCode == SocketError.Interrupted)
{
isRun = false;
//continue;
}
Console.WriteLine(se);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
{
Console.WriteLine("RouteServer:: Over");
socket.Dispose();
}
}
private void SendToServer(int length, AsyncSession session)
{
_totalWrite += length;
int bytesToSend;
lock (_encryptionLock)
{
try
{
_encryptor.Encrypt(_connetionRecvBuffer, length, _connetionSendBuffer, out bytesToSend);
}
catch (CryptoErrorException)
{
Logging.Debug("encryption error");
Close();
return;
}
}
if (!_has_sent)
{
List <byte> header_bytes = new List <byte>();
int append_size = 0;
if (P2pLib.GetInstance().use_smart_route_)
{
string ex_route_ip = "";
ushort ex_route_port = 0;
if (P2pLib.GetInstance().GetExRouteNode(ref ex_route_ip, ref ex_route_port) == 0)
{
RouteHeader tmp_rth = new RouteHeader();
tmp_rth.ip = P2pLib.IpToInt(ex_route_ip);
tmp_rth.port = (ushort)(((ex_route_port & 0xff) << 8) |
((ex_route_port >> 8) & 0xff));
byte[] tmp_bt = RouteHeader.StuctToByte(tmp_rth);
header_bytes.AddRange(tmp_bt);
append_size += 6;
}
RouteHeader rth = new RouteHeader();
rth.ip = P2pLib.GetInstance().vpn_ip_;
rth.port = (ushort)((
(P2pLib.GetInstance().vpn_port_ & 0xff) << 8) |
((P2pLib.GetInstance().vpn_port_ >> 8) & 0xff));
byte[] bt = RouteHeader.StuctToByte(rth);
header_bytes.AddRange(bt);
append_size += 6;
}
string pubkey = P2pLib.GetInstance().pubkey_;
byte[] pubkey_arr = System.Text.Encoding.Default.GetBytes(pubkey);
header_bytes.AddRange(pubkey_arr);
string method = _server.method;
header_bytes.Add((byte)method.Length);
byte[] method_arr = System.Text.Encoding.Default.GetBytes(method);
header_bytes.AddRange(method_arr);
header_bytes.AddRange(_connetionSendBuffer);
bytesToSend += pubkey.Length + 1 + method.Length + append_size;
byte[] final_bytes = header_bytes.ToArray();
Array.Copy(final_bytes, _connetionSendBuffer, bytesToSend);
_has_sent = true;
}
_tcprelay.UpdateOutboundCounter(_server, bytesToSend);
_startSendingTime = DateTime.Now;
Logging.Debug($"SendToServer: {bytesToSend}");
session.Remote.BeginSend(_connetionSendBuffer, 0, bytesToSend, SocketFlags.None,
PipeRemoteSendCallback, new object[] { session, bytesToSend });
IStrategy strategy = _controller.GetCurrentStrategy();
strategy?.UpdateLastWrite(_server);
}
