public override SyncInfo Initialize(DatabaseInfo info)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
var details = info.Details;
string id;
_client = SkyDriveClient
.ParsePath(details.Url, out id);
_info = new SyncInfo
{
Path = id,
Modified = details.Modified,
HasLocalChanges = details.HasLocalChanges,
};
info.OpenDatabaseFile(x =>
{
using (var buffer = new MemoryStream())
{
BufferEx.CopyStream(x, buffer);
_info.Database = buffer.ToArray();
}
});
return(_info);
}
/// <summary>
/// Sets the database.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="details">The details.</param>
public void SetDatabase(Stream data, DatabaseDetails details)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (details == null)
{
throw new ArgumentNullException("details");
}
using (var store = IsolatedStorageFile
.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Folder))
{
store.CreateDirectory(Folder);
}
// Clear password if it was not marked as "save"
var p = GetSavedPassword(store);
if (p.MasterKey == null || p.MasterKey.Length == 0)
{
ClearPassword(store);
}
Details = details;
SaveDetails(store);
using (var fs = store.CreateFile(DatabasePath))
BufferEx.CopyStream(data, fs);
}
}
static void profile_initialize()
{
Console.Write("initializing\n");
netcode.init();
netcode.random_bytes(private_key, netcode.KEY_BYTES);
int i;
for (i = 0; i < netcode.MAX_PACKET_SIZE; ++i)
{
packet_data[i] = (byte)i;
}
netcode.default_server_config(out var server_config);
server_config.protocol_id = PROTOCOL_ID;
BufferEx.Copy(server_config.private_key, private_key, netcode.KEY_BYTES);
for (i = 0; i < MAX_SERVERS; ++i)
{
var server_address = $"127.0.0.1:{SERVER_BASE_PORT + i}";
server[i] = netcode.server_create(server_address, server_config, 0.0);
}
netcode.default_client_config(out var client_config);
for (i = 0; i < MAX_CLIENTS; ++i)
{
client[i] = netcode.client_create("0.0.0.0", client_config, 0.0);
}
}
internal static Stream Encrypt(Stream source,
Headers headers, byte[] masterKey)
{
byte[] easKey;
using (var buffer = new MemoryStream())
{
var masterSeed = headers.MasterSeed;
buffer.Write(masterSeed, 0, masterSeed.Length);
buffer.Write(masterKey, 0, masterKey.Length);
easKey = BufferEx.GetHash(buffer.ToArray());
}
var eas = new AesManaged
{
KeySize = 256,
Key = BufferEx.Clone(easKey),
IV = BufferEx.Clone(headers.EncryptionIV)
};
Stream stream = new CryptoStream(source,
eas.CreateEncryptor(),
CryptoStreamMode.Write);
stream.Write(headers.StreamStartBytes, 0,
headers.StreamStartBytes.Length);
stream = new HashedBlockStream(stream, false);
return(headers.Compression == Compressions.GZip
? new GZipOutputStream(stream) : stream);
}
private void SetPassword()
{
AppSettings.Instance.Password =
BufferEx.GetHash(txtPass.Password);
NavigationService.GoBack();
}
public override SyncInfo Initialize(DatabaseInfo info)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
var details = info.Details;
var url = new Uri(details.Url);
_client = CreateClient(url.UserInfo);
_info = new SyncInfo
{
Path = url.LocalPath,
Modified = details.Modified,
HasLocalChanges = details.HasLocalChanges,
};
info.OpenDatabaseFile(x =>
{
using (var buffer = new MemoryStream())
{
BufferEx.CopyStream(x, buffer);
_info.Database = buffer.ToArray();
}
});
return(_info);
}
private static DbPersistentData ReadDatabase(
Stream stream, Headers headers, byte[] masterKey)
{
var decrypted = FileFormat.Decrypt(
stream, headers, masterKey);
if (decrypted == null)
{
return(null);
}
using (decrypted)
using (var buffer = new MemoryStream())
{
BufferEx.CopyStream(decrypted, buffer);
return(new DbPersistentData
{
MasterKey = masterKey,
Xml = buffer.ToArray(),
Protection = CryptoSerializer
.Serialize(headers),
});
}
}
/// <summary>
/// Sets the database.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="details">The details.</param>
public void SetDatabase(Stream data, DatabaseDetails details)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (details == null)
{
throw new ArgumentNullException("details");
}
using (var store = IsolatedStorageFile
.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Folder))
{
store.CreateDirectory(Folder);
}
ClearPassword(store);
Details = details;
SaveDetails(store);
using (var fs = store.CreateFile(DatabasePath))
BufferEx.CopyStream(data, fs);
}
}
public override SyncInfo Initialize(DatabaseInfo info)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
var details = info.Details;
var parts = details.Url.Split('\n');
_client = new WebDavClient(
parts[1], parts[2]);
_info = new SyncInfo
{
Path = parts[0],
Modified = details.Modified,
HasLocalChanges = details.HasLocalChanges,
};
info.OpenDatabaseFile(x =>
{
using (var buffer = new MemoryStream())
{
BufferEx.CopyStream(x, buffer);
_info.Database = buffer.ToArray();
}
});
return(_info);
}
/// <summary>
/// Gets the saved password.
/// </summary>
/// <returns></returns>
private static DbPersistentData GetSavedPassword(
IsolatedStorageFile store, string protectPath,
string parsedXmlPath, string masterPassPath)
{
var result = new DbPersistentData();
using (var fs = store.OpenFile(protectPath, FileMode.Open))
using (var buffer = new MemoryStream((int)fs.Length))
{
BufferEx.CopyStream(fs, buffer);
result.Protection = buffer.ToArray();
}
using (var fs = store.OpenFile(parsedXmlPath, FileMode.Open))
using (var buffer = new MemoryStream((int)fs.Length))
{
BufferEx.CopyStream(fs, buffer);
result.Xml = buffer.ToArray();
}
using (var fs = store.OpenFile(masterPassPath, FileMode.Open))
using (var buffer = new MemoryStream((int)fs.Length))
{
BufferEx.CopyStream(fs, buffer);
result.MasterKey = buffer.ToArray();
}
return(result);
}
public void Complete(HttpStatusCode status, Stream response)
{
using (var buffer = new MemoryStream())
{
BufferEx.CopyStream(response, buffer);
_complete(buffer.ToArray());
}
}
static int random_int(int a, int b)
{
Debug.Assert(a < b);
var result = a + BufferEx.Rand() % (b - a + 1);
Debug.Assert(result >= a);
Debug.Assert(result <= b);
return(result);
}
static float random_float(float a, float b)
{
Debug.Assert(a < b);
var random = BufferEx.Rand() / (float)BufferEx.RAND_MAX;
var diff = b - a;
var r = random * diff;
return(a + r);
}
public void SetDatabase(Action <Stream> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
using (var store = IsolatedStorageFile
.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Folder))
{
store.CreateDirectory(Folder);
}
var dbPath = DatabasePath;
var backupPath = Path.Combine(Folder, "backup.kdbx");
using (var source = store.OpenFile(dbPath, FileMode.Open))
using (var target = store.OpenFile(backupPath, FileMode.Create))
{
BufferEx.CopyStream(source, target);
}
store.DeleteFile(dbPath);
try
{
using (var fs = store.OpenFile(dbPath, FileMode.Create))
action(fs);
}
catch
{
// Restore original database
using (var source = store.OpenFile(backupPath, FileMode.Open))
using (var target = store.OpenFile(dbPath, FileMode.Create))
{
BufferEx.CopyStream(source, target);
}
throw;
}
store.DeleteFile(backupPath);
Details.HasLocalChanges = true;
SaveDetails(store);
if (HasPassword)
{
UpdateSavedPassword(store);
}
}
}
public void SendEx(IocpUserToken token, byte[] buffer)
{
byte[] encrypted = AESEx.AESEncrypt(buffer, CommonConfig.key, CommonConfig.iv);
MemoryStream st = new MemoryStream();
BinaryWriter bw = new BinaryWriter(st);
bw.Write(encrypted.Length + sizeof(int) + sizeof(ushort));
bw.Write(Shared.PackageSignature);
bw.Write(encrypted);
RealSend(token, BufferEx.MemoryStreamToBytes(st));
}
/// <summary>
/// Verifies if the specified global password is correct.
/// </summary>
/// <param name="password">The global password.</param>
/// <returns></returns>
public bool Verify(string password)
{
var hash = BufferEx.GetHash(password);
if (hash != _settings.Password)
{
return(false);
}
_globalPassEntered = true;
return(true);
}
public bool Send(byte[] buffer)
{
byte[] encrypted = AESEx.AESEncrypt(buffer, CommonConfig.key, CommonConfig.iv);
MemoryStream st = new MemoryStream();
BinaryWriter bw = new BinaryWriter(st);
bw.Write(encrypted.Length + sizeof(int) + sizeof(ushort));
bw.Write(Shared.PackageSignature);
bw.Write(encrypted);
return(RealSend(BufferEx.MemoryStreamToBytes(st)));
}
// [TestMethod, Timeout(60000)]
public unsafe void BufferEx_Check_Read_Inlined()
{
// to see results, enable DumpStack in MemoryAccess.il
var bytes = new byte[16];
BufferEx.Read <int>(bytes, 0);
var array = new UnmanagedArray <int>(10);
array.GetRef(0);
array.UncheckedGet(0);
array.UncheckedSet(0, 0);
var x = array[0];
array[0] = x; // this does not get inlined
}
public void BufferEx_BulkCopy()
{
var bytes = new byte[256];
var rgbs = Enumerable.Range(0, 16).Select(i => new RGB {
R = i, B = i * 10, G = i * 100
}).ToArray();
BufferEx.Copy(rgbs, 0, bytes, 0, rgbs.Length);
var rgbs2 = new RGB[rgbs.Length];
BufferEx.Copy(bytes, 0, rgbs2, 0, rgbs.Length);
for (int i = 0; i < 16; i++)
{
Assert.AreEqual(rgbs[i], rgbs2[i]);
}
}
static void fuzz_iteration(double time)
{
Console.Write(".");
Console.Out.Flush();
var packet_data = new byte[MAX_PACKET_BYTES];
var packet_bytes = random_int(1, MAX_PACKET_BYTES);
int i;
for (i = 0; i < packet_bytes; ++i)
{
packet_data[i] = (byte)(BufferEx.Rand() % 256);
}
reliable.endpoint_receive_packet(endpoint, packet_data, packet_bytes);
reliable.endpoint_update(endpoint, time);
reliable.endpoint_clear_acks(endpoint);
}
public void BufferEx_ReadWrite()
{
var bytes = new byte[256];
Assert.AreEqual(BufferEx.SizeOf <int>(), sizeof(int));
Assert.AreEqual(BufferEx.SizeOf <RGB>(), sizeof(RGB));
uint value = 0x8A00AF01;
RGB rgb = new RGB {
R = 16, B = 32, G = 64
};
BufferEx.Write(value, bytes, 0);
BufferEx.Write(rgb, bytes, 4);
var newValue = BufferEx.Read <uint>(bytes, 0);
var newRGB = BufferEx.Read <RGB>(bytes, 4);
Assert.AreEqual(value, newValue);
Assert.AreEqual(rgb, newRGB);
}
/// <summary>
/// 当这个被调用时，代表一个异步接收操作完成。
/// 当远程主机关闭连接，这个Socket也将被关闭
/// 如果有数据接收，那么就会执行事件通知用户
/// </summary>
/// <param name="e">SocketAsyncEventArg表示一个已经完成的异步IO事件。</param>
private void OnClientIoReceive(SocketAsyncEventArgs e)
{
//获取与用户关联的Token结构
IocpUserToken token = e.UserToken as IocpUserToken;
//获取用户的套接字
Socket s = token.Connection;
// 检查是否是数据接收
// 是否非错误并且SOCKET是有效的
try
{
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success && s.Available == 0)
{
if (NotifyReceivedPackage != null)
{
MemoryStream TempBuffer = new MemoryStream();
new BinaryWriter(TempBuffer).Write(e.Buffer, 0, e.BytesTransferred);
NotifyReceivedPackage(this, new IocpPacketEventArgs(token, BufferEx.MemoryStreamToBytes(TempBuffer)));
}
//投递下一个接收函数
if (!s.ReceiveAsync(e))
{
// 如果投递失败,检查是否是成功接收
this.OnClientIoReceive(e);
}
}
else
{
throw new SocketException(10054); //WSAECONNRESET
}
}
catch (Exception)
{
this.CloseClientSocket(e);
}
}
/// <summary>
/// Saves user password.
/// </summary>
/// <param name="store">The store.</param>
/// <param name="xml">The XML.</param>
private void Save(IsolatedStorageFile store,
DbPersistentData xml)
{
if (!store.DirectoryExists(Folder))
{
store.CreateDirectory(Folder);
}
using (var fs = store.CreateFile(ProtectionPath))
{
var protect = xml.Protection;
fs.Write(protect, 0, protect.Length);
}
using (var fs = store.CreateFile(ParsedXmlPath))
using (var buffer = new MemoryStream(xml.Xml))
BufferEx.CopyStream(buffer, fs);
using (var fs = store.CreateFile(MasterPasswordPath))
{
var data = xml.MasterKey;
fs.Write(data, 0, data.Length);
}
}
/// <summary>
/// 当这个被调用时，代表一个异步接收操作完成。
/// 当远程主机关闭连接，这个Socket也将被关闭
/// 如果没有错误,那么就会执行事件通知用户发送的字节数以及数据
/// </summary>
/// <param name="e">SocketAsyncEventArg表示一个已经完成的异步IO事件。</param>
private void OnClientIoSend(SocketAsyncEventArgs e)
{
//获取与用户关联的Token结构
IocpUserToken token = e.UserToken as IocpUserToken;
//获取用户的套接字
Socket s = token.Connection;
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
if (NotifySendComplete != null)
{
MemoryStream TempBuffer = new MemoryStream();
new BinaryWriter(TempBuffer).Write(e.Buffer, 0, e.BytesTransferred);
NotifySendComplete(this, new IocpPacketEventArgs(token, BufferEx.MemoryStreamToBytes(TempBuffer)));
}
ReleaseSocketAsyncEventArgs(e);
}
else
{
this.CloseClientSocket(e);
}
}
static void soak_iteration(double time)
{
int i;
netcode.default_server_config(out var server_config);
server_config.protocol_id = PROTOCOL_ID;
BufferEx.Copy(server_config.private_key, private_key, netcode.KEY_BYTES);
for (i = 0; i < MAX_SERVERS; ++i)
{
if (server[i] == null && random_int(0, 10) == 0)
{
var server_address = $"127.0.0.1:{SERVER_BASE_PORT + i }";
server[i] = netcode.server_create(server_address, server_config, time);
Console.Write($"created server {server[i]}\n");
}
if (server[i] != null && netcode.server_num_connected_clients(server[i]) == netcode.server_max_clients(server[i]) && random_int(0, 10000) == 0)
{
Console.Write($"destroy server {server[i]}\n");
netcode.server_destroy(ref server[i]);
server[i] = null;
}
}
for (i = 0; i < MAX_CLIENTS; ++i)
{
if (client[i] == null && random_int(0, 10) == 0)
{
netcode.default_client_config(out var client_config);
client[i] = netcode.client_create("0.0.0.0", client_config, time);
Console.Write($"created client {client[i]}\n");
}
if (client[i] != null && random_int(0, 1000) == 0)
{
Console.Write($"destroy client {client[i]}\n");
netcode.client_destroy(ref client[i]);
client[i] = null;
}
}
for (i = 0; i < MAX_SERVERS; ++i)
{
if (server[i] != null)
{
if (random_int(0, 10) == 0 && !netcode.server_running(server[i]))
{
netcode.server_start(server[i], random_int(1, netcode.MAX_CLIENTS));
}
if (random_int(0, 1000) == 0 && netcode.server_num_connected_clients(server[i]) == netcode.server_max_clients(server[i]) && netcode.server_running(server[i]))
{
netcode.server_stop(server[i]);
}
if (netcode.server_running(server[i]))
{
var max_clients = netcode.server_max_clients(server[i]);
int client_index;
for (client_index = 0; client_index < max_clients; ++client_index)
{
if (netcode.server_client_connected(server[i], client_index))
{
netcode.server_send_packet(server[i], 0, packet_data, random_int(1, netcode.MAX_PACKET_SIZE));
}
}
for (client_index = 0; client_index < max_clients; ++client_index)
{
if (netcode.server_client_connected(server[i], client_index))
{
while (true)
{
var packet = netcode.server_receive_packet(server[i], client_index, out var packet_bytes, out var packet_sequence);
if (packet == null)
{
break;
}
Debug.Assert(BufferEx.Equal(packet, packet_data, (int)packet_bytes));
netcode.server_free_packet(server[i], ref packet);
}
}
}
}
netcode.server_update(server[i], time);
}
}
for (i = 0; i < MAX_CLIENTS; ++i)
{
if (client[i] != null)
{
if (random_int(0, 10) == 0 && netcode.client_state(client[i]) <= netcode.CLIENT_STATE_DISCONNECTED)
{
var client_id = 0UL;
netcode.random_bytes(ref client_id, 8);
var user_data = new byte[netcode.USER_DATA_BYTES];
netcode.random_bytes(user_data, netcode.USER_DATA_BYTES);
var connect_token = new byte[netcode.CONNECT_TOKEN_BYTES];
var num_server_addresses = 0;
var server_address = new string[netcode.MAX_SERVERS_PER_CONNECT];
int j;
for (j = 0; j < MAX_SERVERS; ++j)
{
if (num_server_addresses == netcode.MAX_SERVERS_PER_CONNECT)
{
break;
}
if (server[j] != null && netcode.server_running(server[j]))
{
server_address[num_server_addresses] = $"127.0.0.1:{SERVER_BASE_PORT + j}";
num_server_addresses++;
}
}
if (num_server_addresses > 0 && netcode.generate_connect_token(num_server_addresses, server_address, server_address, CONNECT_TOKEN_EXPIRY, CONNECT_TOKEN_TIMEOUT, client_id, PROTOCOL_ID, private_key, user_data, connect_token) == netcode.OK)
{
netcode.client_connect(client[i], connect_token);
}
for (j = 0; j < num_server_addresses; ++j)
{
server_address[j] = null;
}
}
if (random_int(0, 100) == 0 && netcode.client_state(client[i]) == netcode.CLIENT_STATE_CONNECTED)
{
netcode.client_disconnect(client[i]);
}
if (netcode.client_state(client[i]) == netcode.CLIENT_STATE_CONNECTED)
{
netcode.client_send_packet(client[i], packet_data, random_int(1, netcode.MAX_PACKET_SIZE));
while (true)
{
var packet = netcode.client_receive_packet(client[i], out var packet_bytes, out var packet_sequence);
if (packet == null)
{
break;
}
Debug.Assert(BufferEx.Equal(packet, packet_data, packet_bytes));
netcode.client_free_packet(client[i], ref packet);
}
}
netcode.client_update(client[i], time);
}
}
}
static int Main(string[] args)
{
if (netcode.init() != netcode.OK)
{
Console.Write("error: failed to initialize netcode.io\n");
return(1);
}
netcode.log_level(netcode.LOG_LEVEL_INFO);
var time = 0.0;
const double delta_time = 1.0 / 60.0;
Console.Write("[server]\n");
const ulong TEST_PROTOCOL_ID = 0x1122334455667788;
var server_address = "127.0.0.1:40000";
if (args.Length == 2)
{
server_address = args[1];
}
netcode.default_server_config(out var server_config);
server_config.protocol_id = TEST_PROTOCOL_ID;
BufferEx.Copy(server_config.private_key, private_key, netcode.KEY_BYTES);
var server = netcode.server_create(server_address, server_config, time);
if (server == null)
{
Console.Write("error: failed to create server\n");
return(1);
}
netcode.server_start(server, netcode.MAX_CLIENTS);
Console.CancelKeyPress += interrupt_handler;
var packet_data = new byte[netcode.MAX_PACKET_SIZE];
int i;
for (i = 0; i < netcode.MAX_PACKET_SIZE; ++i)
{
packet_data[i] = (byte)i;
}
while (!quit)
{
netcode.server_update(server, time);
if (netcode.server_client_connected(server, 0))
{
netcode.server_send_packet(server, 0, packet_data, netcode.MAX_PACKET_SIZE);
}
int client_index;
for (client_index = 0; client_index < netcode.MAX_CLIENTS; ++client_index)
{
while (true)
{
var packet = netcode.server_receive_packet(server, client_index, out var packet_bytes, out var packet_sequence);
if (packet == null)
{
break;
}
Debug.Assert(packet_bytes == netcode.MAX_PACKET_SIZE);
Debug.Assert(BufferEx.Equal(packet, packet_data, netcode.MAX_PACKET_SIZE));
netcode.server_free_packet(server, ref packet);
}
}
netcode.sleep(delta_time);
time += delta_time;
}
if (quit)
{
Console.Write("\nshutting down\n");
}
netcode.server_destroy(ref server);
netcode.term();
return(0);
}
public BinaryReader GetReader()
{
return(new BinaryReader(BufferEx.MemoryStreamToReaderStream(this.TotalBuffer)));
}
private void ResponseReady(HttpWebRequest request,
Func <HttpWebResponse> getResponse)
{
HttpWebResponse response;
var dispatcher = _page.Dispatcher;
try
{
try
{
response = getResponse();
}
catch (WebException ex)
{
var message = Resources.DownloadError +
ex.Message;
var certificate = DetectCertificateError(
request, ex);
if (!certificate)
{
dispatcher.BeginInvoke(() =>
MessageBox.Show(message,
Resources.DownloadTitle,
MessageBoxButton.OK));
}
else
{
message += Resources.InvalidCertificate;
dispatcher.BeginInvoke(() =>
{
var result = MessageBox.Show(message,
Resources.DownloadTitle,
MessageBoxButton.OKCancel);
if (result != MessageBoxResult.OK)
{
return;
}
try
{
new WebBrowserTask
{
Uri = new Uri(Resources
.InvalidCertificateUrl),
}.Show();
}
catch { }
});
}
return;
}
using (var stream = new MemoryStream())
{
using (var responseStream = response.GetResponseStream())
{
BufferEx.CopyStream(responseStream, stream);
stream.Position = 0;
}
if (string.IsNullOrEmpty(_folder))
{
VerifyAndSaveDb(request, dispatcher,
response, stream);
}
else
{
VerifyAndSaveKeyFile(request,
dispatcher, response, stream);
}
}
}
finally
{
dispatcher.BeginInvoke(() =>
OnCompleted(EventArgs.Empty));
}
}
static int Main(string[] args)
{
if (netcode.init() != netcode.OK)
{
Console.Write("error: failed to initialize netcode.io\n");
return(1);
}
netcode.log_level(netcode.LOG_LEVEL_INFO);
var time = 0.0;
const double delta_time = 1.0 / 60.0;
Console.Write("[client/server]\n");
netcode.default_client_config(out var client_config);
var client = netcode.client_create("::", client_config, time);
if (client == null)
{
Console.Write("error: failed to create client\n");
return(1);
}
netcode.default_server_config(out var server_config);
server_config.protocol_id = PROTOCOL_ID;
BufferEx.Copy(server_config.private_key, private_key, netcode.KEY_BYTES);
var server_address = "[::1]:40000";
var server = netcode.server_create(server_address, server_config, time);
if (server == null)
{
Console.Write("error: failed to create server\n");
return(1);
}
netcode.server_start(server, 1);
var connect_token = new byte[netcode.CONNECT_TOKEN_BYTES];
var client_id = 0UL;
netcode.random_bytes(ref client_id, 8);
Console.Write($"client id is {client_id,16}\n");
var user_data = new byte [netcode.USER_DATA_BYTES];
netcode.random_bytes(user_data, netcode.USER_DATA_BYTES);
if (netcode.generate_connect_token(1, new[] { server_address }, new[] { server_address }, CONNECT_TOKEN_EXPIRY, CONNECT_TOKEN_TIMEOUT, client_id, PROTOCOL_ID, private_key, user_data, connect_token) != netcode.OK)
{
Console.Write("error: failed to generate connect token\n");
return(1);
}
netcode.client_connect(client, connect_token);
Console.CancelKeyPress += interrupt_handler;
var server_num_packets_received = 0;
var client_num_packets_received = 0;
var packet_data = new byte[netcode.MAX_PACKET_SIZE];
int i;
for (i = 0; i < netcode.MAX_PACKET_SIZE; ++i)
{
packet_data[i] = (byte)i;
}
while (!quit)
{
netcode.client_update(client, time);
netcode.server_update(server, time);
if (netcode.client_state(client) == netcode.CLIENT_STATE_CONNECTED)
{
netcode.client_send_packet(client, packet_data, netcode.MAX_PACKET_SIZE);
}
if (netcode.server_client_connected(server, 0))
{
netcode.server_send_packet(server, 0, packet_data, netcode.MAX_PACKET_SIZE);
}
while (true)
{
var packet = netcode.client_receive_packet(client, out var packet_bytes, out var packet_sequence);
if (packet == null)
{
break;
}
Debug.Assert(packet_bytes == netcode.MAX_PACKET_SIZE);
Debug.Assert(BufferEx.Equal(packet, packet_data, netcode.MAX_PACKET_SIZE));
client_num_packets_received++;
netcode.client_free_packet(client, ref packet);
}
while (true)
{
var packet = netcode.server_receive_packet(server, 0, out var packet_bytes, out var packet_sequence);
if (packet == null)
{
break;
}
Debug.Assert(packet_bytes == netcode.MAX_PACKET_SIZE);
Debug.Assert(BufferEx.Equal(packet, packet_data, netcode.MAX_PACKET_SIZE));
server_num_packets_received++;
netcode.server_free_packet(server, ref packet);
}
if (client_num_packets_received >= 10 && server_num_packets_received >= 10)
{
if (netcode.server_client_connected(server, 0))
{
Console.Write("client and server successfully exchanged packets\n");
netcode.server_disconnect_client(server, 0);
}
}
if (netcode.client_state(client) <= netcode.CLIENT_STATE_DISCONNECTED)
{
break;
}
netcode.sleep(delta_time);
time += delta_time;
}
if (quit)
{
Console.Write("\nshutting down\n");
}
netcode.server_destroy(ref server);
netcode.client_destroy(ref client);
netcode.term();
return(0);
}
public unsafe void BufferEx_Read_Managed_Perf()
{
var iterations = 100000;
var count = 256;
var bytes = new byte[count * 16];
int value = 1;
// warm-up
BufferEx.SizeOf <int>();
value = BufferEx.Read <int>(bytes, 0);
var sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
value = BufferEx.Read <int>(bytes, j);
}
}
sw.Stop();
Console.WriteLine("Read " + sw.ElapsedTicks);
var items = new int[256];
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref value, items, j);
}
}
sw.Stop();
Console.WriteLine("Read T from T[] baseline " + sw.ElapsedTicks);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref value, bytes, j);
}
}
sw.Stop();
Console.WriteLine("Read int baseline " + sw.ElapsedTicks);
var ptr = System.Runtime.InteropServices.Marshal.AllocHGlobal(256 * 16);
BufferEx.Read <int>(ptr);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
BufferEx.Read <int>(ptr + j);
}
}
sw.Stop();
Console.WriteLine("Read* " + sw.ElapsedTicks);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref value, ptr, j);
}
}
sw.Stop();
Console.WriteLine("Read* int baseline " + sw.ElapsedTicks);
var rgbValue = default(RGB);
BufferEx.Read <RGB>(bytes, 0);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
rgbValue = BufferEx.Read <RGB>(bytes, j);
}
}
sw.Stop();
Console.WriteLine("Read rgb " + sw.ElapsedTicks);
BufferEx.Read <RGB>(bytes, 0);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
BufferEx.Read <RGB>(bytes, j);
}
}
sw.Stop();
Console.WriteLine("Read ret rgb " + sw.ElapsedTicks);
BufferEx.Read <RGB>(ptr);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
BufferEx.Read <RGB>(ptr + j);
}
}
sw.Stop();
Console.WriteLine("Read* rgb" + sw.ElapsedTicks);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref rgbValue, bytes, j);
}
}
sw.Stop();
Console.WriteLine("Read rgb baseline " + sw.ElapsedTicks);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref rgbValue, ptr, j);
}
}
sw.Stop();
Console.WriteLine("Read* rgb baseline " + sw.ElapsedTicks);
ReadBaseline(ref rgbValue, bytes, 0, p => *(RGB *)p);
sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
for (int j = 0; j < count; j++)
{
ReadBaseline(ref rgbValue, bytes, j, p => *(RGB *)p);
}
}
sw.Stop();
Console.WriteLine("Read rgb del baseline " + sw.ElapsedTicks);
}
