public override async ValueTask StartAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(IscCodes.op_service_start, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(spb.ToArray(), spb.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
try
{
await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
}
catch (IscException)
{
throw;
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected virtual void SendAttachToBuffer(ServiceParameterBufferBase spb, string service)
{
_database.Xdr.Write(IscCodes.op_service_attach);
_database.Xdr.Write(0);
_database.Xdr.Write(service);
_database.Xdr.WriteBuffer(spb.ToArray());
}
public override async ValueTask QueryAsync(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer, CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(IscCodes.op_service_info, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(GdsDatabase.Incarnation, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(spb.ToArray(), spb.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(requestBuffer, requestLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(bufferLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void Query(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer)
{
try
{
_database.Xdr.Write(IscCodes.op_service_info);
_database.Xdr.Write(Handle);
_database.Xdr.Write(GdsDatabase.Incarnation);
_database.Xdr.WriteBuffer(spb.ToArray(), spb.Length);
_database.Xdr.WriteBuffer(requestBuffer, requestLength);
_database.Xdr.Write(bufferLength);
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
private async Task <byte[]> QueryServiceAsync(byte[] items, ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
var shouldClose = false;
if (State == FbServiceState.Closed)
{
await OpenAsync(cancellationToken).ConfigureAwait(false);
shouldClose = true;
}
try
{
var buffer = new byte[QueryBufferSize];
await _svc.QueryAsync(spb, items.Length, items, buffer.Length, buffer, cancellationToken).ConfigureAwait(false);
return(buffer);
}
finally
{
if (shouldClose)
{
await CloseAsync(cancellationToken).ConfigureAwait(false);
}
}
}
public override async ValueTask AttachAsync(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey, CancellationToken cancellationToken = default)
{
try
{
await SendAttachToBufferAsync(spb, service, cancellationToken).ConfigureAwait(false);
await Database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = await Database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
if (response is ContAuthResponse)
{
while (response is ContAuthResponse contAuthResponse)
{
Connection.AuthBlock.Start(contAuthResponse.ServerData, contAuthResponse.AcceptPluginName, contAuthResponse.IsAuthenticated, contAuthResponse.ServerKeys);
await Connection.AuthBlock.SendContAuthToBufferAsync(Database.Xdr, cancellationToken).ConfigureAwait(false);
await Database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
response = await Connection.AuthBlock.ProcessContAuthResponseAsync(Database.Xdr, cancellationToken).ConfigureAwait(false);
response = await(Database as GdsDatabase).ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
}
var genericResponse = (GenericResponse)response;
await base.ProcessAttachResponseAsync(genericResponse, cancellationToken).ConfigureAwait(false);
if (genericResponse.Data.Any())
{
await Database.AuthBlock.SendWireCryptToBufferAsync(Database.Xdr, cancellationToken).ConfigureAwait(false);
await Database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await Database.AuthBlock.ProcessWireCryptResponseAsync(Database.Xdr, Connection, cancellationToken).ConfigureAwait(false);
}
}
else
{
response = await(Database as GdsDatabase).ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
await ProcessAttachResponseAsync((GenericResponse)response, cancellationToken).ConfigureAwait(false);
Database.AuthBlock.Complete();
}
}
catch (IscException)
{
await Database.SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw;
}
catch (IOException ex)
{
await Database.SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw IscException.ForIOException(ex);
}
}
private protected void ProcessServiceOutput(ServiceParameterBufferBase spb)
{
string line;
while ((line = GetNextLine(spb)) != null)
{
OnServiceOutput(line);
}
}
private protected async Task ProcessServiceOutputAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
string line;
while ((line = await GetNextLineAsync(spb, cancellationToken).ConfigureAwait(false)) != null)
{
OnServiceOutput(line);
}
}
protected virtual async ValueTask SendAttachToBufferAsync(ServiceParameterBufferBase spb, string service, CancellationToken cancellationToken = default)
{
await _database.Xdr.WriteAsync(IscCodes.op_service_attach, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(service, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(spb.ToArray(), cancellationToken).ConfigureAwait(false);
}
private protected string GetNextLine(ServiceParameterBufferBase spb)
{
var info = Query(new byte[] { IscCodes.isc_info_svc_line }, spb);
if (info.Count == 0)
{
return(null);
}
return(info[0] as string);
}
private protected async Task <string> GetNextLineAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
var info = await QueryAsync(new byte[] { IscCodes.isc_info_svc_line }, spb, cancellationToken).ConfigureAwait(false);
if (info.Count == 0)
{
return(null);
}
return(info[0] as string);
}
public override void Attach(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey)
{
try
{
SendAttachToBuffer(spb, service);
_database.Xdr.Flush();
ProcessAttachResponse((GenericResponse)_database.ReadResponse());
}
catch (IOException ex)
{
_database.Detach();
throw IscException.ForIOException(ex);
}
}
public override async ValueTask AttachAsync(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey, CancellationToken cancellationToken = default)
{
try
{
await SendAttachToBufferAsync(spb, service, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await ProcessAttachResponseAsync((GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
}
catch (IOException ex)
{
await _database.DetachAsync(cancellationToken).ConfigureAwait(false);
throw IscException.ForIOException(ex);
}
}
private protected async Task StartTaskAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
if (State == FbServiceState.Closed)
{
throw new InvalidOperationException("Service is Closed.");
}
try
{
await _svc.StartAsync(spb, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
}
public override void Start(ServiceParameterBufferBase spb)
{
ClearStatusVector();
var svcHandle = Handle;
var reserved = 0;
_fbClient.isc_service_start(
_statusVector,
ref svcHandle,
ref reserved,
spb.Length,
spb.ToArray());
ProcessStatusVector(_statusVector);
}
private protected void StartTask(ServiceParameterBufferBase spb)
{
if (State == FbServiceState.Closed)
{
throw new InvalidOperationException("Service is Closed.");
}
try
{
_svc.Start(spb);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
}
public override void Attach(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey)
{
try
{
SendAttachToBuffer(spb, service);
Database.Xdr.Flush();
var response = Database.ReadResponse();
if (response is ContAuthResponse)
{
while (response is ContAuthResponse contAuthResponse)
{
Connection.AuthBlock.Start(contAuthResponse.ServerData, contAuthResponse.AcceptPluginName, contAuthResponse.IsAuthenticated, contAuthResponse.ServerKeys);
Connection.AuthBlock.SendContAuthToBuffer(Database.Xdr);
Database.Xdr.Flush();
response = Connection.AuthBlock.ProcessContAuthResponse(Database.Xdr);
response = (Database as GdsDatabase).ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
}
var genericResponse = (GenericResponse)response;
base.ProcessAttachResponse(genericResponse);
if (genericResponse.Data.Any())
{
Database.AuthBlock.SendWireCryptToBuffer(Database.Xdr);
Database.Xdr.Flush();
Database.AuthBlock.ProcessWireCryptResponse(Database.Xdr, Connection);
}
}
else
{
response = (Database as GdsDatabase).ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
ProcessAttachResponse((GenericResponse)response);
Database.AuthBlock.Complete();
}
}
catch (IscException)
{
Database.SafelyDetach();
throw;
}
catch (IOException ex)
{
Database.SafelyDetach();
throw IscException.ForIOException(ex);
}
}
public override ValueTask StartAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
ClearStatusVector();
var svcHandle = Handle;
var reserved = 0;
_fbClient.isc_service_start(
_statusVector,
ref svcHandle,
ref reserved,
spb.Length,
spb.ToArray());
ProcessStatusVector(_statusVector);
return(ValueTask2.CompletedTask);
}
private protected async Task <List <object> > QueryAsync(byte[] items, ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
var result = new List <object>();
await QueryAsync(items, spb, (truncated, item) =>
{
if (item is string stringItem)
{
if (!truncated)
{
result.Add(stringItem);
}
else
{
var lastValue = result[result.Count - 1] as string;
result[result.Count - 1] = lastValue + stringItem;
}
return(Task.CompletedTask);
}
if (item is byte[] byteArrayItem)
{
if (!truncated)
{
result.Add(byteArrayItem);
}
else
{
var lastValue = result[result.Count - 1] as byte[];
var lastValueLength = lastValue.Length;
Array.Resize(ref lastValue, lastValue.Length + byteArrayItem.Length);
Array.Copy(byteArrayItem, 0, lastValue, lastValueLength, byteArrayItem.Length);
}
return(Task.CompletedTask);
}
result.Add(item);
return(Task.CompletedTask);
}, cancellationToken).ConfigureAwait(false);
return(result);
}
public override void Attach(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey)
{
FesDatabase.CheckCryptKeyForSupport(cryptKey);
ClearStatusVector();
var svcHandle = Handle;
_fbClient.isc_service_attach(
_statusVector,
(short)service.Length,
service,
ref svcHandle,
spb.Length,
spb.ToArray());
ProcessStatusVector(_statusVector);
Handle = svcHandle;
}
public override void Query(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer)
{
ClearStatusVector();
var svcHandle = Handle;
var reserved = 0;
_fbClient.isc_service_query(
_statusVector,
ref svcHandle,
ref reserved,
spb.Length,
spb.ToArray(),
(short)requestLength,
requestBuffer,
(short)buffer.Length,
buffer);
ProcessStatusVector(_statusVector);
}
private protected List <object> Query(byte[] items, ServiceParameterBufferBase spb)
{
var result = new List <object>();
Query(items, spb, (truncated, item) =>
{
if (item is string stringItem)
{
if (!truncated)
{
result.Add(stringItem);
}
else
{
var lastValue = result[result.Count - 1] as string;
result[result.Count - 1] = lastValue + stringItem;
}
return;
}
if (item is byte[] byteArrayItem)
{
if (!truncated)
{
result.Add(byteArrayItem);
}
else
{
var lastValue = result[result.Count - 1] as byte[];
var lastValueLength = lastValue.Length;
Array.Resize(ref lastValue, lastValue.Length + byteArrayItem.Length);
Array.Copy(byteArrayItem, 0, lastValue, lastValueLength, byteArrayItem.Length);
}
return;
}
result.Add(item);
});
return(result);
}
public override ValueTask QueryAsync(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer, CancellationToken cancellationToken = default)
{
ClearStatusVector();
var svcHandle = Handle;
var reserved = 0;
_fbClient.isc_service_query(
_statusVector,
ref svcHandle,
ref reserved,
spb.Length,
spb.ToArray(),
(short)requestLength,
requestBuffer,
(short)buffer.Length,
buffer);
ProcessStatusVector(_statusVector);
return(ValueTask2.CompletedTask);
}
public override ValueTask AttachAsync(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey, CancellationToken cancellationToken = default)
{
FesDatabase.CheckCryptKeyForSupport(cryptKey);
ClearStatusVector();
var svcHandle = Handle;
_fbClient.isc_service_attach(
_statusVector,
(short)service.Length,
service,
ref svcHandle,
spb.Length,
spb.ToArray());
ProcessStatusVector(_statusVector);
Handle = svcHandle;
return(ValueTask2.CompletedTask);
}
private byte[] QueryService(byte[] items, ServiceParameterBufferBase spb)
{
var shouldClose = false;
if (State == FbServiceState.Closed)
{
Open();
shouldClose = true;
}
try
{
var buffer = new byte[QueryBufferSize];
_svc.Query(spb, items.Length, items, buffer.Length, buffer);
return(buffer);
}
finally
{
if (shouldClose)
{
Close();
}
}
}
public override void Start(ServiceParameterBufferBase spb)
{
try
{
_database.Xdr.Write(IscCodes.op_service_start);
_database.Xdr.Write(Handle);
_database.Xdr.Write(0);
_database.Xdr.WriteBuffer(spb.ToArray(), spb.Length);
_database.Xdr.Flush();
try
{
_database.ReadResponse();
}
catch (IscException)
{
throw;
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public abstract void Query(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer);
public abstract ValueTask StartAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default);
private protected async Task QueryAsync(byte[] items, ServiceParameterBufferBase spb, Func <bool, object, Task> queryResponseAction, CancellationToken cancellationToken = default)
{
var pos = 0;
var truncated = false;
var type = default(int);
var buffer = await QueryServiceAsync(items, spb, cancellationToken).ConfigureAwait(false);
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
if (type == IscCodes.isc_info_truncated)
{
buffer = await QueryServiceAsync(items, spb, cancellationToken).ConfigureAwait(false);
pos = 0;
truncated = true;
continue;
}
switch (type)
{
case IscCodes.isc_info_svc_version:
case IscCodes.isc_info_svc_get_license_mask:
case IscCodes.isc_info_svc_capabilities:
case IscCodes.isc_info_svc_get_licensed_users:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
await queryResponseAction(truncated, (int)IscHelper.VaxInteger(buffer, pos, 4)).ConfigureAwait(false);
pos += length;
truncated = false;
break;
}
case IscCodes.isc_info_svc_server_version:
case IscCodes.isc_info_svc_implementation:
case IscCodes.isc_info_svc_get_env:
case IscCodes.isc_info_svc_get_env_lock:
case IscCodes.isc_info_svc_get_env_msg:
case IscCodes.isc_info_svc_user_dbpath:
case IscCodes.isc_info_svc_line:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
await queryResponseAction(truncated, Encoding2.Default.GetString(buffer, pos, length)).ConfigureAwait(false);
pos += length;
truncated = false;
break;
}
case IscCodes.isc_info_svc_to_eof:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
var block = new byte[length];
Array.Copy(buffer, pos, block, 0, length);
await queryResponseAction(truncated, block).ConfigureAwait(false);
pos += length;
truncated = false;
break;
}
case IscCodes.isc_info_svc_svr_db_info:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
await queryResponseAction(truncated, ParseDatabasesInfo(buffer, ref pos)).ConfigureAwait(false);
truncated = false;
break;
}
case IscCodes.isc_info_svc_get_users:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
await queryResponseAction(truncated, ParseUserData(buffer, ref pos)).ConfigureAwait(false);
truncated = false;
break;
}
case IscCodes.isc_info_svc_get_config:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
await queryResponseAction(truncated, ParseServerConfig(buffer, ref pos)).ConfigureAwait(false);
truncated = false;
break;
}
case IscCodes.isc_info_svc_stdin:
{
var length = GetLength(buffer, 4, ref pos);
await queryResponseAction(truncated, length).ConfigureAwait(false);
truncated = false;
break;
}
case IscCodes.isc_info_data_not_ready:
{
await queryResponseAction(truncated, typeof(void)).ConfigureAwait(false);
truncated = false;
break;
}
}
}
}
public abstract ValueTask QueryAsync(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer, CancellationToken cancellationToken = default);
