public override async Task Attach(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
try
{
await SendAttachToBuffer(dpb, database, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = await ReadResponse(async).ConfigureAwait(false);
response = await ProcessCryptCallbackResponseIfNeeded(response, cryptKey, async).ConfigureAwait(false);
await ProcessAttachResponse((GenericResponse)response, async).ConfigureAwait(false);
}
catch (IscException)
{
await SafelyDetach(async).ConfigureAwait(false);
throw;
}
catch (IOException ex)
{
await SafelyDetach(async).ConfigureAwait(false);
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
await AfterAttachActions(async).ConfigureAwait(false);
}
public override void AttachWithTrustedAuth(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey)
{
try
{
using (var sspiHelper = new SspiHelper())
{
var authData = sspiHelper.InitializeClientSecurity();
SendTrustedAuthToBuffer(dpb, authData);
SendAttachToBuffer(dpb, database);
Xdr.Flush();
var response = ReadResponse();
ProcessTrustedAuthResponse(sspiHelper, ref response);
ProcessAttachResponse((GenericResponse)response);
}
}
catch (IscException)
{
SafelyDetach();
throw;
}
catch (IOException ex)
{
SafelyDetach();
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
AfterAttachActions();
}
public override async Task AttachWithTrustedAuth(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
try
{
using (var sspiHelper = new SspiHelper())
{
var authData = sspiHelper.InitializeClientSecurity();
await SendTrustedAuthToBuffer(dpb, authData, async).ConfigureAwait(false);
await SendAttachToBuffer(dpb, database, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = await ReadResponse(async).ConfigureAwait(false);
response = await ProcessTrustedAuthResponse(sspiHelper, response, async).ConfigureAwait(false);
await ProcessAttachResponse((GenericResponse)response, async).ConfigureAwait(false);
}
}
catch (IscException)
{
await SafelyDetach(async).ConfigureAwait(false);
throw;
}
catch (IOException ex)
{
await SafelyDetach(async).ConfigureAwait(false);
throw IscException.ForIOException(ex);
}
await AfterAttachActions(async).ConfigureAwait(false);
}
public override async ValueTask AttachAsync(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey, CancellationToken cancellationToken = default)
{
try
{
await SendAttachToBufferAsync(dpb, database, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
if (response is ContAuthResponse)
{
while (response is ContAuthResponse contAuthResponse)
{
AuthBlock.Start(contAuthResponse.ServerData, contAuthResponse.AcceptPluginName, contAuthResponse.IsAuthenticated, contAuthResponse.ServerKeys);
await AuthBlock.SendContAuthToBufferAsync(Xdr, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
response = await AuthBlock.ProcessContAuthResponseAsync(Xdr, cancellationToken).ConfigureAwait(false);
response = await ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
}
var genericResponse = (GenericResponse)response;
await ProcessAttachResponseAsync(genericResponse, cancellationToken).ConfigureAwait(false);
if (genericResponse.Data.Any())
{
await AuthBlock.SendWireCryptToBufferAsync(Xdr, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await AuthBlock.ProcessWireCryptResponseAsync(Xdr, _connection, cancellationToken).ConfigureAwait(false);
}
}
else
{
response = await ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
await ProcessAttachResponseAsync((GenericResponse)response, cancellationToken).ConfigureAwait(false);
AuthBlock.Complete();
}
AuthBlock.WireCryptValidate(IscCodes.PROTOCOL_VERSION13);
}
catch (IscException)
{
await SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw;
}
catch (IOException ex)
{
await SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw IscException.ForIOException(ex);
}
await AfterAttachActionsAsync(cancellationToken).ConfigureAwait(false);
}
protected virtual void SendAttachToBuffer(DatabaseParameterBufferBase dpb, string database)
{
Xdr.Write(IscCodes.op_attach);
Xdr.Write(0);
if (!string.IsNullOrEmpty(Password))
{
dpb.Append(IscCodes.isc_dpb_password, Password);
}
Xdr.WriteBuffer(Encoding.Default.GetBytes(database));
Xdr.WriteBuffer(dpb.ToArray());
}
protected virtual void SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database)
{
Xdr.Write(IscCodes.op_create);
Xdr.Write(DatabaseObjectId);
if (!string.IsNullOrEmpty(AuthBlock.Password))
{
dpb.Append(IscCodes.isc_dpb_password, AuthBlock.Password);
}
Xdr.WriteBuffer(Encoding2.Default.GetBytes(database));
Xdr.WriteBuffer(dpb.ToArray());
}
protected override void SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database)
{
Xdr.Write(IscCodes.op_create);
Xdr.Write(0);
if (AuthData != null)
{
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthData);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database));
Xdr.WriteBuffer(dpb.ToArray());
}
protected override void SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database)
{
Xdr.Write(IscCodes.op_create);
Xdr.Write(0);
if (!string.IsNullOrEmpty(AuthBlock.Password))
{
dpb.Append(IscCodes.isc_dpb_password, AuthBlock.Password);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database));
Xdr.WriteBuffer(dpb.ToArray());
}
public override void CreateDatabase(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey)
{
try
{
SendCreateToBuffer(dpb, database);
Xdr.Flush();
ProcessCreateResponse((GenericResponse)ReadResponse());
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public virtual void CreateDatabase(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey)
{
try
{
SendCreateToBuffer(dpb, database);
Xdr.Flush();
ProcessCreateResponse(ReadResponse <GenericResponse>());
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override async ValueTask CreateDatabaseAsync(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey, CancellationToken cancellationToken = default)
{
try
{
await SendCreateToBufferAsync(dpb, database, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await ProcessCreateResponseAsync((GenericResponse)await ReadResponseAsync(cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected virtual async Task SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database, AsyncWrappingCommonArgs async)
{
await Xdr.Write(IscCodes.op_create, async).ConfigureAwait(false);
await Xdr.Write(DatabaseObjectId, async).ConfigureAwait(false);
if (!string.IsNullOrEmpty(Password))
{
dpb.Append(IscCodes.isc_dpb_password, Password);
}
await Xdr.WriteBuffer(Encoding.Default.GetBytes(database), async).ConfigureAwait(false);
await Xdr.WriteBuffer(dpb.ToArray(), async).ConfigureAwait(false);
}
public override void CreateDatabaseWithTrustedAuth(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey)
{
using (var sspiHelper = new SspiHelper())
{
var authData = sspiHelper.InitializeClientSecurity();
SendTrustedAuthToBuffer(dpb, authData);
SendCreateToBuffer(dpb, database);
Xdr.Flush();
var response = ReadResponse();
ProcessTrustedAuthResponse(sspiHelper, ref response);
ProcessCreateResponse((GenericResponse)response);
}
}
public override async Task CreateDatabase(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
try
{
await SendCreateToBuffer(dpb, database, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ProcessCreateResponse((GenericResponse)await ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected virtual async ValueTask SendCreateToBufferAsync(DatabaseParameterBufferBase dpb, string database, CancellationToken cancellationToken = default)
{
await Xdr.WriteAsync(IscCodes.op_create, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(DatabaseObjectId, cancellationToken).ConfigureAwait(false);
if (!string.IsNullOrEmpty(AuthBlock.Password))
{
dpb.Append(IscCodes.isc_dpb_password, AuthBlock.Password);
}
await Xdr.WriteBufferAsync(Encoding2.Default.GetBytes(database), cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(dpb.ToArray(), cancellationToken).ConfigureAwait(false);
}
public override void Attach(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey)
{
try
{
SendAttachToBuffer(dpb, database);
Xdr.Flush();
var response = ReadResponse();
if (response is ContAuthResponse)
{
while (response is ContAuthResponse contAuthResponse)
{
AuthBlock.Start(contAuthResponse.ServerData, contAuthResponse.AcceptPluginName, contAuthResponse.IsAuthenticated, contAuthResponse.ServerKeys);
AuthBlock.SendContAuthToBuffer(Xdr);
Xdr.Flush();
response = AuthBlock.ProcessContAuthResponse(Xdr);
response = ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
}
var genericResponse = (GenericResponse)response;
ProcessAttachResponse(genericResponse);
if (genericResponse.Data.Any())
{
AuthBlock.SendWireCryptToBuffer(Xdr);
Xdr.Flush();
AuthBlock.ProcessWireCryptResponse(Xdr, _connection);
}
}
else
{
response = ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
ProcessAttachResponse((GenericResponse)response);
AuthBlock.Complete();
}
AuthBlock.WireCryptValidate(IscCodes.PROTOCOL_VERSION13);
}
catch (IscException)
{
SafelyDetach();
throw;
}
catch (IOException ex)
{
SafelyDetach();
throw IscException.ForIOException(ex);
}
AfterAttachActions();
}
protected override async Task SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database, AsyncWrappingCommonArgs async)
{
await Xdr.Write(IscCodes.op_create, async).ConfigureAwait(false);
await Xdr.Write(0, async).ConfigureAwait(false);
if (AuthData != null)
{
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthData);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
await Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database), async).ConfigureAwait(false);
await Xdr.WriteBuffer(dpb.ToArray(), async).ConfigureAwait(false);
}
public override void CreateDatabase(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey)
{
try
{
SendCreateToBuffer(dpb, database);
Xdr.Flush();
var response = ReadResponse();
response = ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
ProcessCreateResponse(response as GenericResponse);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override async Task SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database, AsyncWrappingCommonArgs async)
{
await Xdr.Write(IscCodes.op_create, async).ConfigureAwait(false);
await Xdr.Write(0, async).ConfigureAwait(false);
if (!string.IsNullOrEmpty(Password))
{
dpb.Append(IscCodes.isc_dpb_password, Password);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
await Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database), async).ConfigureAwait(false);
await Xdr.WriteBuffer(dpb.ToArray(), async).ConfigureAwait(false);
}
protected override async ValueTask SendAttachToBufferAsync(DatabaseParameterBufferBase dpb, string database, CancellationToken cancellationToken = default)
{
await Xdr.WriteAsync(IscCodes.op_attach, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
if (!string.IsNullOrEmpty(AuthBlock.Password))
{
dpb.Append(IscCodes.isc_dpb_password, AuthBlock.Password);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
await Xdr.WriteBufferAsync(Encoding.UTF8.GetBytes(database), cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(dpb.ToArray(), cancellationToken).ConfigureAwait(false);
}
public override async Task CreateDatabaseWithTrustedAuth(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
using (var sspiHelper = new SspiHelper())
{
var authData = sspiHelper.InitializeClientSecurity();
await SendTrustedAuthToBuffer(dpb, authData, async).ConfigureAwait(false);
await SendCreateToBuffer(dpb, database, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = await ReadResponse(async).ConfigureAwait(false);
response = await ProcessTrustedAuthResponse(sspiHelper, response, async).ConfigureAwait(false);
await ProcessCreateResponse((GenericResponse)response, async).ConfigureAwait(false);
}
}
protected override void SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database)
{
Xdr.Write(IscCodes.op_create);
Xdr.Write(0);
if (!AuthBlock.HasClientData)
{
dpb.Append(IscCodes.isc_dpb_auth_plugin_name, AuthBlock.AcceptPluginName);
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthBlock.PublicClientData);
}
else
{
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthBlock.ClientData);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database));
Xdr.WriteBuffer(dpb.ToArray());
}
public override void CreateDatabase(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding2.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_create_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray(),
0);
ProcessStatusVector(_statusVector);
}
public override async Task Attach(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_attach_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray());
ProcessStatusVector(_statusVector);
ServerVersion = await GetServerVersion(async).ConfigureAwait(false);
}
public void Attach(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_attach_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray());
ProcessStatusVector(_statusVector);
_serverVersion = GetServerVersion();
}
public override async ValueTask AttachAsync(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey, CancellationToken cancellationToken = default)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding2.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_attach_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray());
ProcessStatusVector(_statusVector);
ServerVersion = await GetServerVersionAsync(cancellationToken).ConfigureAwait(false);
}
protected override async ValueTask SendCreateToBufferAsync(DatabaseParameterBufferBase dpb, string database, CancellationToken cancellationToken = default)
{
await Xdr.WriteAsync(IscCodes.op_create, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
if (!AuthBlock.HasClientData)
{
dpb.Append(IscCodes.isc_dpb_auth_plugin_name, AuthBlock.AcceptPluginName);
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthBlock.PublicClientData);
}
else
{
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthBlock.ClientData);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
await Xdr.WriteBufferAsync(Encoding.UTF8.GetBytes(database), cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(dpb.ToArray(), cancellationToken).ConfigureAwait(false);
}
public override Task CreateDatabase(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_create_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray(),
0);
ProcessStatusVector(_statusVector);
return(Task.CompletedTask);
}
public override ValueTask CreateDatabaseAsync(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey, CancellationToken cancellationToken = default)
{
CheckCryptKeyForSupport(cryptKey);
var databaseBuffer = Encoding2.Default.GetBytes(database);
ClearStatusVector();
_fbClient.isc_create_database(
_statusVector,
(short)databaseBuffer.Length,
databaseBuffer,
ref _handle,
dpb.Length,
dpb.ToArray(),
0);
ProcessStatusVector(_statusVector);
return(ValueTask2.CompletedTask);
}
public override void Attach(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey)
{
try
{
SendAttachToBuffer(dpb, database);
Xdr.Flush();
ProcessAttachResponse((GenericResponse)ReadResponse());
}
catch (IscException)
{
SafelyDetach();
throw;
}
catch (IOException ex)
{
SafelyDetach();
throw IscException.ForIOException(ex);
}
AfterAttachActions();
}
