remote.cpp

/*
 * PROGRAM: JRD Remote Interface
 * MODULE: remote.cpp
 * DESCRIPTION: Common routines for remote interface/server
 *
 * The contents of this file are subject to the Interbase Public
 * License Version 1.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy
 * of the License at http://www.Inprise.com/IPL.html
 *
 * Software distributed under the License is distributed on an
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code was created by Inprise Corporation
 * and its predecessors. Portions created by Inprise Corporation are
 * Copyright (C) Inprise Corporation.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
*/

#include"firebird.h"
#include<string.h>
#include<stdlib.h>
#include"ibase.h"
#include"../remote/remote.h"
#include"../common/file_params.h"
#include"../common/gdsassert.h"
#include"../remote/proto_proto.h"
#include"../remote/remot_proto.h"
#include"../yvalve/gds_proto.h"
#include"../common/config/config.h"
#include"../common/classes/init.h"
#include"../common/db_alias.h"
#include"firebird/Interface.h"
#include"../common/os/mod_loader.h"
#include"../jrd/license.h"
#include"../common/classes/ImplementHelper.h"
#include"../common/utils_proto.h"

usingnamespaceFirebird;

#ifdef DEV_BUILD
AtomicCounter rem_port::portCounter;
#endif

#ifdef REMOTE_DEBUG
IMPLEMENT_TRACE_ROUTINE(remote_trace, "REMOTE")
#endif


const ParametersSet dpbParam =
{
 isc_dpb_dummy_packet_interval,
 isc_dpb_user_name,
 isc_dpb_auth_block,
 isc_dpb_password,
 isc_dpb_password_enc,
 isc_dpb_trusted_auth,
 isc_dpb_auth_plugin_name,
 isc_dpb_auth_plugin_list,
 isc_dpb_specific_auth_data,
 isc_dpb_address_path,
 isc_dpb_process_id,
 isc_dpb_process_name,
 isc_dpb_encrypt_key,
 isc_dpb_client_version,
 isc_dpb_remote_protocol,
 isc_dpb_host_name,
 isc_dpb_os_user,
 isc_dpb_config,
 isc_dpb_utf8_filename,
 isc_dpb_map_attach
};

const ParametersSet spbParam =
{
 isc_spb_dummy_packet_interval,
 isc_spb_user_name,
 isc_spb_auth_block,
 isc_spb_password,
 isc_spb_password_enc,
 isc_spb_trusted_auth,
 isc_spb_auth_plugin_name,
 isc_spb_auth_plugin_list,
 isc_spb_specific_auth_data,
 isc_spb_address_path,
 isc_spb_process_id,
 isc_spb_process_name,
0,
 isc_spb_client_version,
 isc_spb_remote_protocol,
 isc_spb_host_name,
 isc_spb_os_user,
 isc_spb_config,
 isc_spb_utf8_filename,
0
};

const ParametersSet connectParam =
{
0,
 CNCT_login,
0,
0,
0,
0,
 CNCT_plugin_name,
 CNCT_plugin_list,
 CNCT_specific_data,
0,
0,
0,
0,
0,
0,
 CNCT_host,
 CNCT_user,
0,
0,
0
};


const SLONG DUMMY_INTERVAL = 60; // seconds
constint ATTACH_FAILURE_SPACE = 16 * 1024; // bytes


voidREMOTE_cleanup_transaction( Rtr* transaction)
{
/**************************************
 *
 * R E M O T E _ c l e a n u p _ t r a n s a c t i o n
 *
 **************************************
 *
 * Functional description
 * A transaction is being committed or rolled back.
 * Purge any active messages in case the user calls
 * receive while we still have something cached.
 *
 **************************************/
for (Rrq* request = transaction->rtr_rdb->rdb_requests; request; request = request->rrq_next)
 {
if (request->rrq_rtr == transaction)
 {
REMOTE_reset_request(request, 0);
 request->rrq_rtr = NULL;
 }
for (Rrq* level = request->rrq_levels; level; level = level->rrq_next)
 {
if (level->rrq_rtr == transaction)
 {
REMOTE_reset_request(level, 0);
 level->rrq_rtr = NULL;
 }
 }
 }

for (Rsr* statement = transaction->rtr_rdb->rdb_sql_requests; statement;
 statement = statement->rsr_next)
 {
if (statement->rsr_rtr == transaction)
 {
REMOTE_reset_statement(statement);
 statement->rsr_flags.clear(Rsr::FETCHED);
 statement->rsr_rtr = NULL;
 }
 }
}


USHORT REMOTE_compute_batch_size(rem_port* port,
 USHORT buffer_used, P_OP op_code,
const rem_fmt* format)
{
/**************************************
 *
 * R E M O T E _ c o m p u t e _ b a t c h _ s i z e
 *
 **************************************
 *
 * Functional description
 *
 * When batches of records are returned, they are returned as
 * follows:
 * <op_fetch_response> <data_record 1>
 * <op_fetch_response> <data_record 2>
 * ...
 * <op_fetch_response> <data_record n-1>
 * <op_fetch_response> <data_record n>
 *
 * end-of-batch is indicated by setting p_sqldata_messages to
 * 0 in the op_fetch_response. End of cursor is indicated
 * by setting p_sqldata_status to a non-zero value. Note
 * that a fetch CAN be attempted after end of cursor, this
 * is sent to the server for the server to return the appropriate
 * error code.
 *
 * Each data block has one overhead packet
 * to indicate the data is present.
 *
 * (See also op_send in receive_msg() - which is a kissing cousin
 * to this routine)
 *
 * Here we make a guess for the optimal number of records to
 * send in each batch. This is important as we wait for the
 * whole batch to be received before we return the first item
 * to the client program. How many are cached on the client also
 * impacts client-side memory utilization.
 *
 * We optimize the number by how many can fit into a packet.
 * The client calculates this number (n from the list above)
 * and sends it to the server.
 *
 * The data size is either the XDR data representation, or the
 * actual message size (rounded up) if this is a symmetric
 * architecture connection.
 *
 **************************************/

const USHORT op_overhead = (USHORT) xdr_protocol_overhead(op_code);

#ifdef DEBUG
fprintf(stderr,
"port_buff_size = %d fmt_net_length = %d fmt_length = %d overhead = %d\n",
 port->port_buff_size, format->fmt_net_length,
 format->fmt_length, op_overhead);
#endif

const ULONG row_size = op_overhead +
 (port->port_flags & PORT_symmetric) ?
ROUNDUP(format->fmt_length, 4) : // Same architecture connection
ROUNDUP(format->fmt_net_length, 4); // Using XDR for data transfer

 ULONG result = (port->port_protocol >= PROTOCOL_VERSION13) ?
 MAX_ROWS_PER_BATCH : (MAX_PACKETS_PER_BATCH * port->port_buff_size - buffer_used) / row_size;

// Don't ask for more records than we can cache

 result = MIN(result, MAX_BATCH_CACHE_SIZE / format->fmt_length);

// Must always send some messages, even if message is larger than packet

 result = MAX(result, MIN_ROWS_PER_BATCH);

fb_assert(result <= MAX_USHORT);
returnstatic_cast<USHORT>(result);
}


Rrq* REMOTE_find_request(Rrq* request, USHORT level)
{
/**************************************
 *
 * R E M O T E _ f i n d _ r e q u e s t
 *
 **************************************
 *
 * Functional description
 * Find sub-request if level is non-zero.
 *
 **************************************/

// See if we already know about the request level

for (;;)
 {
if (request->rrq_level == level)
return request;
if (!request->rrq_levels)
break;
 request = request->rrq_levels;
 }

// This is a new level -- make up a new request block.

 request->rrq_levels = request->clone();
// FREE: REMOTE_remove_request()
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_find_request allocate request %x\n", request->rrq_levels);
#endif
 request = request->rrq_levels;
 request->rrq_level = level;
 request->rrq_levels = NULL;

// Allocate message block for known messages

 Rrq::rrq_repeat* tail = request->rrq_rpt.begin();
const Rrq::rrq_repeat* const end = tail + request->rrq_max_msg;
for (; tail <= end; tail++)
 {
const rem_fmt* format = tail->rrq_format;
if (!format)
continue;
 RMessage* msg = FB_NEW RMessage(format->fmt_length);
 tail->rrq_xdr = msg;
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_find_request allocate message %x\n", msg);
#endif
 msg->msg_next = msg;
 msg->msg_number = tail->rrq_message->msg_number;
 tail->rrq_message = msg;
 }

return request;
}


voidREMOTE_free_packet( rem_port* port, PACKET * packet, bool partial)
{
/**************************************
 *
 * R E M O T E _ f r e e _ p a c k e t
 *
 **************************************
 *
 * Functional description
 * Zero out a full packet block (partial == false) or
 * part of packet used in last operation (partial == true)
 **************************************/
 RemoteXdr xdr;
 USHORT n;

if (packet)
 {
 xdr.create(reinterpret_cast<char*>(packet), sizeof(PACKET), XDR_FREE);
 xdr.x_public = port;
 xdr.x_local = (port->port_type == rem_port::XNET);

if (partial) {
xdr_protocol(&xdr, packet);
 }
else
 {
for (n = (USHORT) op_connect; n < (USHORT) op_max; n++)
 {
 packet->p_operation = (P_OP) n;
xdr_protocol(&xdr, packet);
 }
 }
#ifdef DEBUG_XDR_MEMORY
// All packet memory allocations should now be voided.
// note: this code will may work properly if partial == true

for (n = 0; n < P_MALLOC_SIZE; n++)
fb_assert(packet->p_malloc[n].p_operation == op_void);
#endif
 packet->p_operation = op_void;
 }
}


voidREMOTE_get_timeout_params(rem_port* port, ClumpletReader* pb)
{
/**************************************
 *
 * R E M O T E _ g e t _ t i m e o u t _ p a r a m s
 *
 **************************************
 *
 * Functional description
 * Determine the connection timeout parameter values for this newly created
 * port. If the client did a specification in the DPB, use those values.
 * Otherwise, see if there is anything in the configuration file. The
 * configuration file management code will set the default values if there
 * is no other specification.
 *
 **************************************/
//bool got_dpb_connect_timeout = false;

fb_assert(isc_dpb_connect_timeout == isc_spb_connect_timeout);

 port->port_connect_timeout = pb && pb->find(isc_dpb_connect_timeout) ?
 pb->getInt() : port->getPortConfig()->getConnectionTimeout();

 port->port_flags |= PORT_dummy_pckt_set;
 port->port_dummy_packet_interval = port->getPortConfig()->getDummyPacketInterval();
if (port->port_dummy_packet_interval < 0)
 port->port_dummy_packet_interval = DUMMY_INTERVAL;

 port->port_dummy_timeout = port->port_dummy_packet_interval;

#ifdef DEBUG
printf("REMOTE_get_timeout dummy = %lu conn = %lu\n",
 port->port_dummy_packet_interval, port->port_connect_timeout);
fflush(stdout);
#endif
}


rem_str* REMOTE_make_string(const SCHAR* input)
{
/**************************************
 *
 * R E M O T E _ m a k e _ s t r i n g
 *
 **************************************
 *
 * Functional description
 * Copy a given string to a permanent location, returning
 * address of new string.
 *
 **************************************/
const USHORT length = static_cast<USHORT>(strlen(input));
 rem_str* string = FB_NEW_RPT(*getDefaultMemoryPool(), length) rem_str;
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_make_string allocate string %x\n", string);
#endif
strcpy(string->str_data, input);
 string->str_length = length;

return string;
}


voidREMOTE_release_messages( RMessage* messages)
{
/**************************************
 *
 * R E M O T E _ r e l e a s e _ m e s s a g e s
 *
 **************************************
 *
 * Functional description
 * Release a circular list of messages.
 *
 **************************************/
 RMessage* message = messages;
if (message)
 {
while (true)
 {
 RMessage* temp = message;
 message = message->msg_next;
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_release_messages free message %x\n", temp);
#endif
delete temp;
if (message == messages)
break;
 }
 }
}


voidREMOTE_release_request( Rrq* request)
{
/**************************************
 *
 * R E M O T E _ r e l e a s e _ r e q u e s t
 *
 **************************************
 *
 * Functional description
 * Release a request block and friends.
 *
 **************************************/
 Rdb* rdb = request->rrq_rdb;

for (Rrq** p = &rdb->rdb_requests; *p; p = &(*p)->rrq_next)
 {
if (*p == request)
 {
 *p = request->rrq_next;
break;
 }
 }

// Get rid of request and all levels

for (;;)
 {
 Rrq::rrq_repeat* tail = request->rrq_rpt.begin();
const Rrq::rrq_repeat* const end = tail + request->rrq_max_msg;
for (; tail <= end; tail++)
 {
 RMessage* message = tail->rrq_message;
if (message)
 {
if (!request->rrq_level)
 {
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_release_request free format %x\n", tail->rrq_format);
#endif
delete tail->rrq_format;
 }
REMOTE_release_messages(message);
 }
 }
 Rrq* next = request->rrq_levels;
#ifdef DEBUG_REMOTE_MEMORY
printf("REMOTE_release_request free request %x\n", request);
#endif
delete request;
if (!(request = next))
break;
 }
}


voidREMOTE_reset_request( Rrq* request, RMessage* active_message)
{
/**************************************
 *
 * R E M O T E _ r e s e t _ r e q u e s t
 *
 **************************************
 *
 * Functional description
 * Clean up a request in preparation to use it again. Since
 * there may be an active message (start_and_send), exercise
 * some care to avoid zapping that message.
 *
 **************************************/
 Rrq::rrq_repeat* tail = request->rrq_rpt.begin();
const Rrq::rrq_repeat* const end = tail + request->rrq_max_msg;
for (; tail <= end; tail++)
 {
 RMessage* message = tail->rrq_message;
if (message != NULL && message != active_message)
 {
 tail->rrq_xdr = message;
 tail->rrq_rows_pending = 0;
 tail->rrq_reorder_level = 0;
 tail->rrq_batch_count = 0;
while (true)
 {
 message->msg_address = NULL;
 message = message->msg_next;
if (message == tail->rrq_message)
break;
 }
 }
 }

// Initialize the request status to FB_SUCCESS

//request->rrq_status_vector[1] = 0;
 request->rrqStatus.clear();
}


voidREMOTE_reset_statement( Rsr* statement)
{
/**************************************
 *
 * R E M O T E _ r e s e t _ s t a t e m e n t
 *
 **************************************
 *
 * Functional description
 * Reset a statement by releasing all buffers except 1
 *
 **************************************/
 RMessage* message;

if (!statement || (!(message = statement->rsr_message)))
return;

// Reset all the pipeline counters

 statement->rsr_rows_pending = 0;
 statement->rsr_msgs_waiting = 0;
 statement->rsr_reorder_level = 0;
 statement->rsr_batch_count = 0;

// only one entry

if (message->msg_next == message)
return;

// find the entry before statement->rsr_message

 RMessage* temp = message->msg_next;
while (temp->msg_next != message)
 temp = temp->msg_next;

 temp->msg_next = message->msg_next;
 message->msg_next = message;

 statement->rsr_buffer = statement->rsr_message;

REMOTE_release_messages(temp);
}


// TMN: Beginning of C++ port - ugly but a start

voidrem_port::linkParent(rem_port* const parent)
{
fb_assert(parent);
fb_assert(this->port_parent == NULL);

this->port_parent = parent;
this->port_next = parent->port_clients;
this->port_server = parent->port_server;
this->port_server_flags = parent->port_server_flags;
this->port_config = parent->port_config;

 parent->port_clients = parent->port_next = this;
}

const RefPtr<const Config>& rem_port::getPortConfig() const
{
return port_config.hasData() ? port_config : Config::getDefaultConfig();
}

RefPtr<const Config> rem_port::getPortConfig()
{
return port_config.hasData() ? port_config : Config::getDefaultConfig();
}

voidrem_port::unlinkParent()
{
if (this->port_parent == NULL)
return;

#ifdef DEV_BUILD
bool found = false;
#endif

for (rem_port** ptr = &this->port_parent->port_clients; *ptr; ptr = &(*ptr)->port_next)
 {
if (*ptr == this)
 {
 *ptr = this->port_next;

if (ptr == &this->port_parent->port_clients)
 {
fb_assert(this->port_parent->port_next == this);

this->port_parent->port_next = *ptr;
 }

#ifdef DEV_BUILD
 found = true;
#endif
break;
 }
 } // for

fb_assert(found);

this->port_parent = NULL;
}

boolrem_port::accept(p_cnct* cnct)
{
return (*this->port_accept)(this, cnct);
}

voidrem_port::disconnect()
{
 (*this->port_disconnect)(this);
}

voidrem_port::force_close()
{
 (*this->port_force_close)(this);
}

rem_port* rem_port::receive(PACKET* pckt)
{
return (*this->port_receive_packet)(this, pckt);
}

boolrem_port::select_multi(UCHAR* buffer, SSHORT bufsize, SSHORT* length, RemPortPtr& port)
{
return (*this->port_select_multi)(this, buffer, bufsize, length, port);
}

voidrem_port::abort_aux_connection()
{
if (this->port_abort_aux_connection)
 {
 (*this->port_abort_aux_connection)(this);
 }
}

XDR_INT rem_port::send(PACKET* pckt)
{
return (*this->port_send_packet)(this, pckt);
}

XDR_INT rem_port::send_partial(PACKET* pckt)
{
return (*this->port_send_partial)(this, pckt);
}

rem_port* rem_port::connect(PACKET* pckt)
{
return (*this->port_connect)(this, pckt);
}

rem_port* rem_port::request(PACKET* pckt)
{
return (*this->port_request)(this, pckt);
}

voidrem_port::auxAcceptError(PACKET* packet)
{
if (port_protocol >= PROTOCOL_VERSION13)
 {
 packet->p_operation = op_abort_aux_connection;
// Ignore error return - we are already processing auxiliary connection error from the wire
send(packet);
 }
}

bool_tREMOTE_getbytes (RemoteXdr* xdrs, SCHAR* buff, unsigned bytecount)
{
/**************************************
 *
 * R E M O T E _ g e t b y t e s
 *
 **************************************
 *
 * Functional description
 * Get a bunch of bytes from a port buffer
 *
 **************************************/

while (bytecount > 0)
 {
if (xdrs->x_handy >= bytecount)
 {
memcpy(buff, xdrs->x_private, bytecount);
 xdrs->x_private += bytecount;
 xdrs->x_handy -= bytecount;
break;
 }

if (xdrs->x_handy > 0)
 {
memcpy(buff, xdrs->x_private, xdrs->x_handy);
 xdrs->x_private += xdrs->x_handy;
 buff += xdrs->x_handy;
 bytecount -= xdrs->x_handy;
 xdrs->x_handy = 0;
 }

 rem_port* port = xdrs->x_public;
 RefMutexEnsureUnlock queGuard(*port->port_que_sync, FB_FUNCTION);
 queGuard.enter();
if (port->port_qoffset >= port->port_queue.getCount())
 {
 queGuard.leave();

 port->port_partial_data = true;
returnFALSE;
 }

 xdrs->x_handy = port->port_queue[port->port_qoffset].getCount();
fb_assert(xdrs->x_handy <= port->port_buff_size);
memcpy(xdrs->x_base, port->port_queue[port->port_qoffset].begin(), xdrs->x_handy);
 ++port->port_qoffset;
 xdrs->x_private = xdrs->x_base;
 }

returnTRUE;
}

voidPortsCleanup::registerPort(rem_port* port)
{
 MutexLockGuard guard(m_mutex, FB_FUNCTION);

if (closing)
return;

if (!m_ports)
 {
 MemoryPool& pool = *getDefaultMemoryPool();
 m_ports = FB_NEW_POOL (pool) PortsArray(pool);
 }

 m_ports->add(port);
}

voidPortsCleanup::unRegisterPort(rem_port* port)
{
 MutexLockGuard guard(m_mutex, FB_FUNCTION);

if (closing)
return;

if (m_ports)
 {
 FB_SIZE_T i;
constbool found = m_ports->find(port, i);
//fb_assert(found);
if (found)
 m_ports->remove(i);
 }
}

voidPortsCleanup::closePorts()
{
if (m_ports)
delay();

 MutexLockGuard guard(m_mutex, FB_FUNCTION);
 AutoSetRestore cl(&closing, true);

 { // scope
 MutexUnlockGuard g2(m_mutex, FB_FUNCTION);
Thread::yield();
 }

if (m_ports)
 {
 rem_port* const* ptr = m_ports->begin();
const rem_port* const* end = m_ports->end();
for (; ptr < end; ptr++) {
closePort(*ptr);
 }

delete m_ports;
 m_ports = NULL;
 }
}

voidPortsCleanup::closePort(rem_port* port)
{
 port->force_close();
}

voidPortsCleanup::delay()
{
}

ServerAuthBase::~ServerAuthBase()
{
}

ServerCallbackBase::~ServerCallbackBase()
{
}

/*
void Rdb::set_async_vector(ISC_STATUS* userStatus) throw()
{
 rdb_async_status_vector = userStatus;
 rdb_async_thread_id = getThreadId();
}

void Rdb::reset_async_vector() throw()
{
 rdb_async_thread_id = 0;
 rdb_async_status_vector = NULL;
}

ISC_STATUS* Rdb::get_status_vector() throw()
{
 return rdb_async_thread_id == getThreadId() ? rdb_async_status_vector : rdb_status_vector;
}
*/


boolRBlobInfo::getLocalInfo(unsignedint itemsLength, constunsignedchar* items,
unsignedint bufferLength, unsignedchar* buffer)
{
if (!valid)
returnfalse;

unsignedchar* p = buffer;
constunsignedchar* const end = buffer + bufferLength;

for (auto item = items; p && (item < items + itemsLength); item++)
 {
if (*item == isc_info_end)
break;

switch (*item)
 {
case isc_info_blob_num_segments:
 p = fb_utils::putInfoItemInt(*item, num_segments, p, end);
break;

case isc_info_blob_max_segment:
 p = fb_utils::putInfoItemInt(*item, max_segment, p, end);
break;

case isc_info_blob_total_length:
 p = fb_utils::putInfoItemInt(*item, total_length, p, end);
break;

case isc_info_blob_type:
 p = fb_utils::putInfoItemInt(*item, blob_type, p, end);
break;

default:
// unknown info item, let remote server handle it
returnfalse;
 }
 }

if (p < end)
 *p++ = isc_info_end;

returntrue;
}


voidRBlobInfo::parseInfo(unsignedint bufferLength, constunsignedchar* buffer)
{
int c = 0;
 valid = false;

 ClumpletReader p(ClumpletReader::InfoResponse, buffer, bufferLength);
for (; !p.isEof(); p.moveNext())
 {
switch (p.getClumpTag())
 {
case isc_info_blob_num_segments:
 num_segments = p.getInt();
 c++;
break;
case isc_info_blob_max_segment:
 max_segment = p.getInt();
 c++;
break;
case isc_info_blob_total_length:
 total_length = p.getInt();
 c++;
break;
case isc_info_blob_type:
 blob_type = p.getInt();
 c++;
break;
case isc_info_end:
break;
default:
fb_assert(false);
break;
 }
 }
 valid = (c == 4);
}

voidRrq::saveStatus(const Exception& ex) throw()
{
if (rrqStatus.isSuccess())
 {
 LocalStatus ls;
 CheckStatusWrapper tmp(&ls);
 ex.stuffException(&tmp);
 rrqStatus.save(&tmp);
 }
}

voidRrq::saveStatus(IStatus* v) throw()
{
if (rrqStatus.isSuccess())
 {
 rrqStatus.save(v);
 }
}

voidRsr::saveException(const Exception& ex, bool overwrite)
{
if (!rsr_status) {
 rsr_status = FB_NEW StatusHolder();
 }

if (overwrite || !rsr_status->getError())
 {
 LocalStatus ls;
 CheckStatusWrapper temp(&ls);
 ex.stuffException(&temp);
 rsr_status->save(&temp);
 }
}

string rem_port::getRemoteId() const
{
fb_assert(port_protocol_id.hasData());
 string id = port_protocol_id;

if (port_address.hasData())
 id += string("/") + port_address;

return id;
}

LegacyPlugin REMOTE_legacy_auth(constchar* nm, int p)
{
constchar* legacyTrusted = "WIN_SSPI";
if (fb_utils::stricmp(legacyTrusted, nm) == 0 &&
 (p == PROTOCOL_VERSION11 || p == PROTOCOL_VERSION12))
 {
return PLUGIN_TRUSTED;
 }

constchar* legacyAuth = "LEGACY_AUTH";
if (fb_utils::stricmp(legacyAuth, nm) == 0 && p < PROTOCOL_VERSION13)
 {
return PLUGIN_LEGACY;