private static int GetLength(byte[] buffer, int size, ref int pos)
{
var result = (int)IscHelper.VaxInteger(buffer, pos, size);
pos += size;
return(result);
}
private static FbDatabasesInfo ParseDatabasesInfo(byte[] buffer, ref int pos)
{
FbDatabasesInfo dbInfo = new FbDatabasesInfo();
int type = 0;
int length = 0;
pos = 1;
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
switch (type)
{
case IscCodes.isc_spb_num_att:
dbInfo.ConnectionCount = IscHelper.VaxInteger(buffer, pos, 4);
pos += 4;
break;
case IscCodes.isc_spb_num_db:
pos += 4;
break;
case IscCodes.isc_spb_dbname:
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
dbInfo.Databases.Add(Encoding.Default.GetString(buffer, pos, length));
pos += length;
break;
}
}
pos--;
return(dbInfo);
}
public virtual List <object> GetDatabaseInfo(byte[] items, int bufferLength)
{
var buffer = new byte[bufferLength];
DatabaseInfo(items, buffer, buffer.Length);
return(IscHelper.ParseDatabaseInfo(buffer));
}
private static FbUserData[] ParseUserData(byte[] buffer, ref int pos)
{
List <FbUserData> users = new List <FbUserData>();
FbUserData currentUser = null;
int type = 0;
int length = 0;
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
switch (type)
{
case IscCodes.isc_spb_sec_username:
{
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
currentUser = new FbUserData();
currentUser.UserName = Encoding.Default.GetString(buffer, pos, length);
pos += length;
users.Add(currentUser);
}
break;
case IscCodes.isc_spb_sec_firstname:
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
currentUser.FirstName = Encoding.Default.GetString(buffer, pos, length);
pos += length;
break;
case IscCodes.isc_spb_sec_middlename:
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
currentUser.MiddleName = Encoding.Default.GetString(buffer, pos, length);
pos += length;
break;
case IscCodes.isc_spb_sec_lastname:
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
currentUser.LastName = Encoding.Default.GetString(buffer, pos, length);
pos += length;
break;
case IscCodes.isc_spb_sec_userid:
currentUser.UserID = IscHelper.VaxInteger(buffer, pos, 4);
pos += 4;
break;
case IscCodes.isc_spb_sec_groupid:
currentUser.GroupID = IscHelper.VaxInteger(buffer, pos, 4);
pos += 4;
break;
}
}
pos--;
return(users.ToArray());
}
protected DbStatementType ProcessStatementTypeInfoBuffer(byte[] buffer)
{
var stmtType = DbStatementType.None;
var pos = 0;
var length = 0;
var type = 0;
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
length = (int)IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
switch (type)
{
case IscCodes.isc_info_sql_stmt_type:
stmtType = (DbStatementType)IscHelper.VaxInteger(buffer, pos, length);
pos += length;
break;
default:
pos += length;
break;
}
}
return(stmtType);
}
protected override byte[] GetSegment()
{
int requested = SegmentSize;
lock (_database.SyncObject)
{
try
{
_database.XdrStream.Write(IscCodes.op_get_segment);
_database.XdrStream.Write(_blobHandle);
_database.XdrStream.Write((requested + 2 < short.MaxValue) ? requested + 2 : short.MaxValue);
_database.XdrStream.Write(0); // Data segment
_database.XdrStream.Flush();
GenericResponse response = _database.ReadGenericResponse();
RblRemoveValue(IscCodes.RBL_segment);
if (response.ObjectHandle == 1)
{
RblAddValue(IscCodes.RBL_segment);
}
else if (response.ObjectHandle == 2)
{
RblAddValue(IscCodes.RBL_eof_pending);
}
byte[] buffer = response.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return(buffer);
}
int len = 0;
int srcpos = 0;
int destpos = 0;
while (srcpos < buffer.Length)
{
len = IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
Buffer.BlockCopy(buffer, srcpos, buffer, destpos, len);
srcpos += len;
destpos += len;
}
byte[] result = new byte[destpos];
Buffer.BlockCopy(buffer, 0, result, 0, destpos);
return(result);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public override async Task <List <object> > GetDatabaseInfo(byte[] items, int bufferLength, AsyncWrappingCommonArgs async)
{
var buffer = new byte[bufferLength];
await DatabaseInfo(items, buffer, buffer.Length, async).ConfigureAwait(false);
return(IscHelper.ParseDatabaseInfo(buffer));
}
public override ValueTask <List <object> > GetDatabaseInfoAsync(byte[] items, int bufferLength, CancellationToken cancellationToken = default)
{
var buffer = new byte[bufferLength];
DatabaseInfo(items, buffer, buffer.Length);
return(ValueTask2.FromResult(IscHelper.ParseDatabaseInfo(buffer)));
}
public override async ValueTask <List <object> > GetDatabaseInfoAsync(byte[] items, int bufferLength, CancellationToken cancellationToken = default)
{
var buffer = new byte[bufferLength];
await DatabaseInfoAsync(items, buffer, buffer.Length, cancellationToken).ConfigureAwait(false);
return(IscHelper.ParseDatabaseInfo(buffer));
}
public ArrayList GetDatabaseInfo(byte[] items, int bufferLength)
{
byte[] buffer = new byte[bufferLength];
DatabaseInfo(items, buffer, buffer.Length);
return(IscHelper.ParseDatabaseInfo(buffer));
}
public override Task <List <object> > GetDatabaseInfo(byte[] items, int bufferLength, AsyncWrappingCommonArgs async)
{
var buffer = new byte[bufferLength];
DatabaseInfo(items, buffer, buffer.Length);
return(Task.FromResult(IscHelper.ParseDatabaseInfo(buffer)));
}
protected override byte[] GetSegment()
{
int requested = this.SegmentSize;
lock (this.db)
{
try
{
this.db.Send.Write(IscCodes.op_get_segment);
this.db.Send.Write(this.blobHandle);
this.db.Send.Write((requested + 2 < short.MaxValue) ? requested + 2 : short.MaxValue);
this.db.Send.Write((int)0); // Data segment
this.db.Send.Flush();
GdsResponse r = this.db.ReadGenericResponse();
this.RblRemoveValue(IscCodes.RBL_segment);
if (r.ObjectHandle == 1)
{
this.RblAddValue(IscCodes.RBL_segment);
}
else if (r.ObjectHandle == 2)
{
this.RblAddValue(IscCodes.RBL_eof_pending);
}
byte[] buffer = r.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return(buffer);
}
int len = 0;
int srcpos = 0;
int destpos = 0;
while (srcpos < buffer.Length)
{
len = IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
Buffer.BlockCopy(buffer, srcpos, buffer, destpos, len);
srcpos += len;
destpos += len;
}
byte[] result = new byte[destpos];
Buffer.BlockCopy(buffer, 0, result, 0, destpos);
return(result);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
protected override byte[] GetSegment()
{
var requested = SegmentSize;
try
{
_database.Xdr.Write(IscCodes.op_get_segment);
_database.Xdr.Write(_blobHandle);
_database.Xdr.Write(requested < short.MaxValue - 12 ? requested : short.MaxValue - 12);
_database.Xdr.Write(DataSegment);
_database.Xdr.Flush();
var response = _database.ReadResponse <GenericResponse>();
RblRemoveValue(IscCodes.RBL_segment);
if (response.ObjectHandle == 1)
{
RblAddValue(IscCodes.RBL_segment);
}
else if (response.ObjectHandle == 2)
{
RblAddValue(IscCodes.RBL_eof_pending);
}
var buffer = response.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return(buffer);
}
var len = 0;
var srcpos = 0;
var destpos = 0;
while (srcpos < buffer.Length)
{
len = (int)IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
Buffer.BlockCopy(buffer, srcpos, buffer, destpos, len);
srcpos += len;
destpos += len;
}
var result = new byte[destpos];
Buffer.BlockCopy(buffer, 0, result, 0, destpos);
return(result);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected ArrayList ParseQueryInfo(byte[] buffer)
{
int pos = 0;
int length = 0;
int type = 0;
ArrayList items = new ArrayList();
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
length = IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
if (length != 0)
{
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:
items.Add(IscHelper.VaxInteger(buffer, pos, 4));
pos += length;
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:
case IscCodes.isc_info_svc_to_eof:
items.Add(Encoding.Default.GetString(buffer, pos, length));
pos += length;
break;
case IscCodes.isc_info_svc_svr_db_info:
items.Add(ParseDatabasesInfo(buffer, ref pos));
break;
case IscCodes.isc_info_svc_get_users:
items.Add(ParseUserData(buffer, ref pos));
break;
case IscCodes.isc_info_svc_get_config:
items.Add(ParseServerConfig(buffer, ref pos));
break;
}
}
}
return(items);
}
protected override async Task GetSegment(Stream stream, AsyncWrappingCommonArgs async)
{
var requested = SegmentSize;
try
{
await _database.Xdr.Write(IscCodes.op_get_segment, async).ConfigureAwait(false);
await _database.Xdr.Write(_blobHandle, async).ConfigureAwait(false);
await _database.Xdr.Write(requested < short.MaxValue - 12?requested : short.MaxValue - 12, async).ConfigureAwait(false);
await _database.Xdr.Write(DataSegment, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
RblRemoveValue(IscCodes.RBL_segment);
if (response.ObjectHandle == 1)
{
RblAddValue(IscCodes.RBL_segment);
}
else if (response.ObjectHandle == 2)
{
RblAddValue(IscCodes.RBL_eof_pending);
}
var buffer = response.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return;
}
var len = 0;
var srcpos = 0;
while (srcpos < buffer.Length)
{
len = (int)IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
stream.Write(buffer, srcpos, len);
srcpos += len;
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override async ValueTask GetSegmentAsync(Stream stream, CancellationToken cancellationToken = default)
{
var requested = SegmentSize;
try
{
await _database.Xdr.WriteAsync(IscCodes.op_get_segment, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_blobHandle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(requested < short.MaxValue - 12?requested : short.MaxValue - 12, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(DataSegment, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
RblRemoveValue(IscCodes.RBL_segment);
if (response.ObjectHandle == 1)
{
RblAddValue(IscCodes.RBL_segment);
}
else if (response.ObjectHandle == 2)
{
RblAddValue(IscCodes.RBL_eof_pending);
}
var buffer = response.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return;
}
var len = 0;
var srcpos = 0;
while (srcpos < buffer.Length)
{
len = (int)IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
stream.Write(buffer, srcpos, len);
srcpos += len;
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected int ProcessRecordsAffectedBuffer(byte[] buffer)
{
var insertCount = 0;
var updateCount = 0;
var deleteCount = 0;
var selectCount = 0;
var pos = 0;
int type;
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
var length = (int)IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
switch (type)
{
case IscCodes.isc_info_sql_records:
int t;
while ((t = buffer[pos++]) != IscCodes.isc_info_end)
{
var l = (int)IscHelper.VaxInteger(buffer, pos, 2);
pos += 2;
switch (t)
{
case IscCodes.isc_info_req_insert_count:
insertCount = (int)IscHelper.VaxInteger(buffer, pos, l);
break;
case IscCodes.isc_info_req_update_count:
updateCount = (int)IscHelper.VaxInteger(buffer, pos, l);
break;
case IscCodes.isc_info_req_delete_count:
deleteCount = (int)IscHelper.VaxInteger(buffer, pos, l);
break;
case IscCodes.isc_info_req_select_count:
selectCount = (int)IscHelper.VaxInteger(buffer, pos, l);
break;
}
pos += l;
}
break;
default:
pos += length;
break;
}
}
return(insertCount + updateCount + deleteCount);
}
protected override void GetSegment(Stream stream)
{
var requested = SegmentSize;
try
{
_database.Xdr.Write(IscCodes.op_get_segment);
_database.Xdr.Write(_blobHandle);
_database.Xdr.Write(requested < short.MaxValue - 12 ? requested : short.MaxValue - 12);
_database.Xdr.Write(DataSegment);
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
RblRemoveValue(IscCodes.RBL_segment);
if (response.ObjectHandle == 1)
{
RblAddValue(IscCodes.RBL_segment);
}
else if (response.ObjectHandle == 2)
{
RblAddValue(IscCodes.RBL_eof_pending);
}
var buffer = response.Data;
if (buffer.Length == 0)
{
// previous segment was last, this has no data
return;
}
var len = 0;
var srcpos = 0;
while (srcpos < buffer.Length)
{
len = (int)IscHelper.VaxInteger(buffer, srcpos, 2);
srcpos += 2;
stream.Write(buffer, srcpos, len);
srcpos += len;
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public void ConnectionRequest(out int auxHandle, out string ipAddress, out int portNumber)
{
lock (this)
{
try
{
this.Send.Write(IscCodes.op_connect_request);
this.Send.Write(IscCodes.P_REQ_async); // Connection type
this.Send.Write(this.handle); // Related object
this.Send.Write(0); // Partner identification
this.Send.Flush();
this.ReadOperation();
auxHandle = this.Receive.ReadInt32();
// socketaddr_in (non XDR encoded)
// sin_port
portNumber = IscHelper.VaxInteger(this.Receive.ReadBytes(2), 0, 2);
// sin_Family
this.Receive.ReadBytes(2);
// sin_addr
byte[] buffer = this.Receive.ReadBytes(4);
ipAddress = String.Format(
CultureInfo.InvariantCulture,
"{0}.{1}.{2}.{3}",
buffer[3], buffer[2], buffer[1], buffer[0]);
// sin_zero + garbage
this.Receive.ReadBytes(12);
// Read Status Vector
this.connection.ReadStatusVector();
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
private static FbServerConfig ParseServerConfig(byte[] buffer, ref int pos)
{
FbServerConfig config = new FbServerConfig();
pos = 1;
while (buffer[pos] != IscCodes.isc_info_flag_end)
{
pos++;
int key = buffer[pos - 1];
int keyValue = IscHelper.VaxInteger(buffer, pos, 4);
pos += 4;
switch (key)
{
case IscCodes.ISCCFG_LOCKMEM_KEY:
config.LockMemSize = keyValue;
break;
case IscCodes.ISCCFG_LOCKSEM_KEY:
config.LockSemCount = keyValue;
break;
case IscCodes.ISCCFG_LOCKSIG_KEY:
config.LockSignal = keyValue;
break;
case IscCodes.ISCCFG_EVNTMEM_KEY:
config.EventMemorySize = keyValue;
break;
case IscCodes.ISCCFG_PRIORITY_KEY:
config.PrioritySwitchDelay = keyValue;
break;
case IscCodes.ISCCFG_MEMMIN_KEY:
config.MinMemory = keyValue;
break;
case IscCodes.ISCCFG_MEMMAX_KEY:
config.MaxMemory = keyValue;
break;
case IscCodes.ISCCFG_LOCKORDER_KEY:
config.LockGrantOrder = keyValue;
break;
case IscCodes.ISCCFG_ANYLOCKMEM_KEY:
config.AnyLockMemory = keyValue;
break;
case IscCodes.ISCCFG_ANYLOCKSEM_KEY:
config.AnyLockSemaphore = keyValue;
break;
case IscCodes.ISCCFG_ANYLOCKSIG_KEY:
config.AnyLockSignal = keyValue;
break;
case IscCodes.ISCCFG_ANYEVNTMEM_KEY:
config.AnyEventMemory = keyValue;
break;
case IscCodes.ISCCFG_LOCKHASH_KEY:
config.LockHashSlots = keyValue;
break;
case IscCodes.ISCCFG_DEADLOCK_KEY:
config.DeadlockTimeout = keyValue;
break;
case IscCodes.ISCCFG_LOCKSPIN_KEY:
config.LockRequireSpins = keyValue;
break;
case IscCodes.ISCCFG_CONN_TIMEOUT_KEY:
config.ConnectionTimeout = keyValue;
break;
case IscCodes.ISCCFG_DUMMY_INTRVL_KEY:
config.DummyPacketInterval = keyValue;
break;
case IscCodes.ISCCFG_IPCMAP_KEY:
config.IpcMapSize = keyValue;
break;
case IscCodes.ISCCFG_DBCACHE_KEY:
config.DefaultDbCachePages = keyValue;
break;
}
}
pos++;
return(config);
}
protected void ParseTruncSqlInfo(byte[] info, byte[] items, ref Descriptor[] rowDescs)
{
int currentPosition = 0;
int currentDescriptorIndex = -1;
int currentItemIndex = 0;
while (info[currentPosition] != IscCodes.isc_info_end)
{
byte item;
while ((item = info[currentPosition++]) != IscCodes.isc_info_sql_describe_end)
{
switch (item)
{
case IscCodes.isc_info_truncated:
currentItemIndex--;
List <byte> newItems = new List <byte>(items.Length);
int part = 0;
int chock = 0;
for (int i = 0; i < items.Length; i++)
{
if (items[i] == IscCodes.isc_info_sql_describe_end)
{
newItems.Insert(chock, IscCodes.isc_info_sql_sqlda_start);
newItems.Insert(chock + 1, 2);
short processedItems = (rowDescs[part] != null ? rowDescs[part].Count : (short)0);
newItems.Insert(chock + 2, (byte)((part == currentDescriptorIndex ? currentItemIndex : processedItems) & 255));
newItems.Insert(chock + 3, (byte)((part == currentDescriptorIndex ? currentItemIndex : processedItems) >> 8));
part++;
chock = i + 4 + 1;
}
newItems.Add(items[i]);
}
info = GetSqlInfo(newItems.ToArray(), info.Length);
currentPosition = 0;
currentDescriptorIndex = -1;
goto Break;
case IscCodes.isc_info_sql_select:
case IscCodes.isc_info_sql_bind:
currentDescriptorIndex++;
if (info[currentPosition] == IscCodes.isc_info_truncated)
{
break;
}
currentPosition++;
int len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
if (rowDescs[currentDescriptorIndex] == null)
{
int n = IscHelper.VaxInteger(info, currentPosition, len);
rowDescs[currentDescriptorIndex] = new Descriptor((short)n);
if (n == 0)
{
currentPosition += len;
goto Break;
}
}
currentPosition += len;
break;
case IscCodes.isc_info_sql_sqlda_seq:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
currentItemIndex = IscHelper.VaxInteger(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_type:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].DataType = (short)IscHelper.VaxInteger(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_sub_type:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].SubType = (short)IscHelper.VaxInteger(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_scale:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].NumericScale = (short)IscHelper.VaxInteger(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_length:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].Length = (short)IscHelper.VaxInteger(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_field:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].Name = _database.Charset.GetString(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_relation:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].Relation = _database.Charset.GetString(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_owner:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].Owner = _database.Charset.GetString(info, currentPosition, len);
currentPosition += len;
break;
case IscCodes.isc_info_sql_alias:
len = IscHelper.VaxInteger(info, currentPosition, 2);
currentPosition += 2;
rowDescs[currentDescriptorIndex][currentItemIndex - 1].Alias = _database.Charset.GetString(info, currentPosition, len);
currentPosition += len;
break;
default:
throw IscException.ForErrorCode(IscCodes.isc_dsql_sqlda_err);
}
}
// just to get out of the loop
Break:
{ }
}
}
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;
}
}
}
}
private void ProcessQuery(byte[] items, Action <bool, object> queryResponseAction)
{
var pos = 0;
var truncated = false;
var type = default(int);
var buffer = QueryService(items);
while ((type = buffer[pos++]) != IscCodes.isc_info_end)
{
if (type == IscCodes.isc_info_truncated)
{
buffer = QueryService(items);
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;
}
queryResponseAction(truncated, IscHelper.VaxInteger(buffer, pos, 4));
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;
}
queryResponseAction(truncated, Encoding.Default.GetString(buffer, pos, length));
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);
queryResponseAction(truncated, block);
pos += length;
truncated = false;
break;
}
case IscCodes.isc_info_svc_svr_db_info:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
queryResponseAction(truncated, ParseDatabasesInfo(buffer, ref pos));
truncated = false;
break;
}
case IscCodes.isc_info_svc_get_users:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
queryResponseAction(truncated, ParseUserData(buffer, ref pos));
truncated = false;
break;
}
case IscCodes.isc_info_svc_get_config:
{
var length = GetLength(buffer, 2, ref pos);
if (length == 0)
{
continue;
}
queryResponseAction(truncated, ParseServerConfig(buffer, ref pos));
truncated = false;
break;
}
case IscCodes.isc_info_svc_stdin:
{
var length = GetLength(buffer, 4, ref pos);
queryResponseAction(truncated, length);
break;
}
}
}
}
private int ParseTruncSqlInfo(byte[] info, ref Descriptor rowDesc, int lastindex)
{
byte item = 0;
int index = 0;
int i = 2;
int len = IscHelper.VaxInteger(info, i, 2);
i += 2;
int n = IscHelper.VaxInteger(info, i, len);
i += len;
if (rowDesc == null)
{
rowDesc = new Descriptor((short)n);
}
while (info[i] != IscCodes.isc_info_end)
{
while ((item = info[i++]) != IscCodes.isc_info_sql_describe_end)
{
switch (item)
{
case IscCodes.isc_info_sql_sqlda_seq:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
index = IscHelper.VaxInteger(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_type:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].DataType = (short)IscHelper.VaxInteger(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_sub_type:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].SubType = (short)IscHelper.VaxInteger(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_scale:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].NumericScale = (short)IscHelper.VaxInteger(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_length:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].Length = (short)IscHelper.VaxInteger(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_field:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].Name = this.db.Charset.GetString(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_relation:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].Relation = this.db.Charset.GetString(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_owner:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].Owner = this.db.Charset.GetString(info, i, len);
i += len;
break;
case IscCodes.isc_info_sql_alias:
len = IscHelper.VaxInteger(info, i, 2);
i += 2;
rowDesc[index - 1].Alias = this.db.Charset.GetString(info, i, len);
i += len;
break;
case IscCodes.isc_info_truncated:
return(lastindex);
default:
throw new IscException(IscCodes.isc_dsql_sqlda_err);
}
}
lastindex = index;
}
return(0);
}
