internal unsafe QuicSession(IQuicInteropApi nativeApi, QuicRegistration registration, byte[][] apln)
{
m_nativeApi = nativeApi;
QuicHandle *handle = null;
QuicNativeBuffer *buffers = stackalloc QuicNativeBuffer[apln.Length];
try
{
for (int i = 0; i < apln.Length; i++)
{
byte *allocated = (byte *)Marshal.AllocHGlobal((IntPtr)apln[i].Length);
buffers[i].Buffer = allocated;
buffers[i].Length = (uint)apln[i].Length;
apln[i].AsSpan().CopyTo(new Span <byte>(allocated, apln[i].Length));
}
m_nativeApi.SessionOpen(registration.m_handle, buffers, (uint)apln.Length, null, &handle);
m_handle = handle;
}
finally
{
for (int i = 0; i < apln.Length; i++)
{
Marshal.FreeHGlobal((IntPtr)buffers[i].Buffer);
}
}
}
internal unsafe QuicRegistration(QuicRegistrationConfig config, IQuicInteropApi nativeApi)
{
m_nativeApi = nativeApi;
QuicHandle *handle = null;
QuicNativeRegistrationConfig nativeRegConfig = new QuicNativeRegistrationConfig
{
AppName = null,
ExecutionProfile = config.ExecutionProfile
};
if (config.AppName != null)
{
int appNameLength = config.AppName.Length;
int maxAppNameLength = Encoding.UTF8.GetMaxByteCount(appNameLength);
Span <byte> appNameSpan = appNameLength < 256 ? stackalloc byte[256] : new byte[maxAppNameLength];
fixed(byte *appNamePtr = appNameSpan)
{
fixed(char *strNamePtr = config.AppName)
{
int actualLength = Encoding.UTF8.GetBytes(strNamePtr, appNameLength, appNamePtr, maxAppNameLength);
appNameSpan[actualLength] = 0; // null terminator
}
nativeRegConfig.AppName = appNamePtr;
m_nativeApi.RegistrationOpen(&nativeRegConfig, &handle);
}
}
else
{
m_nativeApi.RegistrationOpen(&nativeRegConfig, &handle);
}
m_handle = handle;
}
internal unsafe QuicRegistration(IQuicInteropApi nativeApi)
{
m_nativeApi = nativeApi;
QuicHandle *handle = null;
m_nativeApi.RegistrationOpen(null, &handle);
m_handle = handle;
}
internal unsafe QuicConnection(IQuicInteropApi api, QuicSession session)
{
m_nativeApi = api;
QuicHandle *handle = null;
api.ConnectionOpen(session.m_handle, null, null, &handle);
m_handle = handle;
}
public unsafe QuicApi()
{
NativeQuicApi *nativeApi = null;
int status = QuicNativeMethods.MsQuicOpen(&nativeApi);
if (status != 0)
{
Marshal.ThrowExceptionForHR(status);
m_nativeApi = null !;
return;
}
m_nativeApi = ApiGenerator.CreateApiImplementation(nativeApi, QuicNativeMethods.MsQuicClose);
}
internal unsafe QuicListener(IQuicInteropApi nativeApi, QuicSession session)
{
m_nativeApi = nativeApi;
m_session = session;
connectionQueue = Channel.CreateBounded <QuicConnection>(new BoundedChannelOptions(128)
{
SingleWriter = true,
SingleReader = true,
});
m_gcHandle = GCHandle.Alloc(this);
QuicHandle *handle = null;
m_nativeApi.ListenerOpen(session.m_handle, m_nativeListenerCallback, (void *)GCHandle.ToIntPtr(m_gcHandle), &handle);
m_handle = handle;
}
internal static async Task <QuicSecurityConfiguration> CreateQuicSecurityConfig(IQuicInteropApi api, QuicRegistration registration, QuicNativeCertificateHashStore certHashStore, string?principal, bool enableOcsp)
{
var flags = QuicSecConfigFlags.CertificateHashStore;
if (enableOcsp)
{
flags |= QuicSecConfigFlags.EnableOcsp;
}
var completionSource = new TaskCompletionSource <QuicSecurityConfiguration>(TaskCreationOptions.RunContinuationsAsynchronously);
unsafe QuicSecConfigCreateComplete RunSecConfig()
{
QuicSecConfigCreateComplete configComplete = (void *context, int status, QuicNativeSecConfig *config) =>
{
completionSource.SetResult(new QuicSecurityConfiguration(api, config));
};
var callback = Marshal.GetFunctionPointerForDelegate(configComplete);
var certHashCopy = certHashStore;
if (principal == null)
{
api.SecConfigCreate(registration.m_handle, flags, &certHashCopy, null, null, (void *)callback);
}
else
{
int maxPrincipalLength = Encoding.UTF8.GetMaxByteCount(principal.Length);
Span <byte> principalSpan = maxPrincipalLength < 256 ? stackalloc byte[maxPrincipalLength] : new byte[maxPrincipalLength];
fixed(byte *principalBytePtr = principalSpan)
{
fixed(char *principalStrPtr = principal)
{
int actualLength = Encoding.UTF8.GetBytes(principalStrPtr, principal.Length, principalBytePtr, principalSpan.Length);
principalSpan[actualLength] = 0;
}
api.SecConfigCreate(registration.m_handle, flags, &certHashCopy, principalBytePtr, null, (void *)callback);
}
}
return(configComplete);
}
var configCompleteDelegate = RunSecConfig();
var secConfig = await completionSource.Task.ConfigureAwait(false);
GC.KeepAlive(configCompleteDelegate);
return(secConfig);
}
internal unsafe QuicSecurityConfiguration(IQuicInteropApi api, QuicNativeSecConfig *secConfig)
{
m_nativeApi = api;
m_secConfig = secConfig;
}
internal static async Task <QuicSecurityConfiguration> CreateQuicSecurityConfig(IQuicInteropApi api, QuicRegistration registration, string certFile, string keyFile, bool enableOcsp)
{
var flags = QuicSecConfigFlags.CertificateFile;
if (enableOcsp)
{
flags |= QuicSecConfigFlags.EnableOcsp;
}
var completionSource = new TaskCompletionSource <QuicSecurityConfiguration>(TaskCreationOptions.RunContinuationsAsynchronously);
unsafe QuicSecConfigCreateComplete RunSecConfig()
{
QuicSecConfigCreateComplete configComplete = (void *context, int status, QuicNativeSecConfig *config) =>
{
completionSource.SetResult(new QuicSecurityConfiguration(api, config));
};
var callback = Marshal.GetFunctionPointerForDelegate(configComplete);
int maxCertFileLength = Encoding.UTF8.GetMaxByteCount(certFile.Length);
Span <byte> maxCertFileSpan = maxCertFileLength < 256 ? stackalloc byte[maxCertFileLength] : new byte[maxCertFileLength];
int maxKeyFileLength = Encoding.UTF8.GetMaxByteCount(keyFile.Length);
Span <byte> maxKeyFileSpan = maxKeyFileLength < 256 ? stackalloc byte[maxKeyFileLength] : new byte[maxKeyFileLength];
fixed(byte *certFileBytePtr = maxCertFileSpan)
fixed(byte *keyFileBytePtr = maxKeyFileSpan)
{
fixed(char *certFileStrPtr = certFile)
{
int actualLength = Encoding.UTF8.GetBytes(certFileStrPtr, certFile.Length, certFileBytePtr, maxCertFileSpan.Length);
maxCertFileSpan[actualLength] = 0;
}
fixed(char *keyFileStrPtr = keyFile)
{
int actualLength = Encoding.UTF8.GetBytes(keyFileStrPtr, keyFile.Length, keyFileBytePtr, maxKeyFileSpan.Length);
maxKeyFileSpan[actualLength] = 0;
}
var file = new QuicNativeCertificateFile();
file.CertificateFile = certFileBytePtr;
file.PrivateKeyFile = keyFileBytePtr;
api.SecConfigCreate(registration.m_handle, flags, &file, null, null, (void *)callback);
}
return(configComplete);
}
var configCompleteDelegate = RunSecConfig();
var secConfig = await completionSource.Task.ConfigureAwait(false);
GC.KeepAlive(configCompleteDelegate);
return(secConfig);
}
internal static async Task <QuicSecurityConfiguration> CreateQuicSecurityConfig(IQuicInteropApi api, QuicRegistration registration)
{
var completionSource = new TaskCompletionSource <QuicSecurityConfiguration>(TaskCreationOptions.RunContinuationsAsynchronously);
unsafe QuicSecConfigCreateComplete RunSecConfig()
{
QuicSecConfigCreateComplete configComplete = (void *context, int status, QuicNativeSecConfig *config) =>
{
completionSource.SetResult(new QuicSecurityConfiguration(api, config));
};
var callback = Marshal.GetFunctionPointerForDelegate(configComplete);
api.SecConfigCreate(registration.m_handle, QuicSecConfigFlags.None, null, null, null, (void *)callback);
return(configComplete);
}
var configCompleteDelegate = RunSecConfig();
var secConfig = await completionSource.Task.ConfigureAwait(false);
GC.KeepAlive(configCompleteDelegate);
return(secConfig);
}
internal unsafe QuicConnection(IQuicInteropApi api, QuicNativeListenerEvent.QuicListenerEventNewConnection *newConnection)
{
m_nativeApi = api;
}
