utils_proto.h

/*
 * The contents of this file are subject to the Initial
 * Developer's 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.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
 *
 * Software distributed under the License is distributed AS IS,
 * 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 Claudio Valderrama on 25-Dec-2003
 * for the Firebird Open Source RDBMS project.
 *
 * Copyright (c) 2003 Claudio Valderrama
 * and all contributors signed below.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
 *
 * Nickolay Samofatov <nickolay@broadviewsoftware.com>
*/


// =====================================
// Utility functions

#ifndef INCLUDE_UTILS_PROTO_H
#defineINCLUDE_UTILS_PROTO_H

#include<string.h>
#include<type_traits>

#include"../common/classes/fb_string.h"
#include"../common/classes/array.h"
#include"iberror.h"
#include"firebird/Interface.h"
#include"memory_routines.h"

#ifdef SFIO
#include<stdio.h>
#endif

namespacefb_utils
{
char* copy_terminate(char* dest, constchar* src, size_t bufsize);
char* exact_name(char* const name);
inlinevoidexact_name(Firebird::string& str)
 {
 str.rtrim();
 }
char* exact_name_limit(char* const name, size_t bufsize);
boolimplicit_domain(constchar* domain_name);
boolimplicit_integrity(constchar* integ_name);
boolimplicit_pk(constchar* pk_name);
intname_length(const TEXT* const name);
intname_length_limit(const TEXT* const name, size_t bufsize);
boolreadenv(constchar* env_name, Firebird::string& env_value);
boolreadenv(constchar* env_name, Firebird::PathName& env_value);
boolsetenv(constchar* name, constchar* value, bool overwrite);
intsnprintf(char* buffer, size_t count, constchar* format...);
char* cleanup_passwd(char* arg);
inlinechar* get_passwd(char* arg)
 {
returncleanup_passwd(arg);
 }
typedefchar* arg_string;

// Warning: Only wrappers:

// ********************
// s t r i c m p
// ********************
// Abstraction of incompatible routine names
// for case insensitive comparison.
inlineintstricmp(constchar* a, constchar* b)
 {
#if defined(HAVE_STRCASECMP)
return ::strcasecmp(a, b);
#elif defined(HAVE_STRICMP)
return ::stricmp(a, b);
#else
#error dont know how to compare strings case insensitive on this system
#endif
 }


// ********************
// s t r n i c m p
// ********************
// Abstraction of incompatible routine names
// for counted length and case insensitive comparison.
inlineintstrnicmp(constchar* a, constchar* b, size_t count)
 {
#if defined(HAVE_STRNCASECMP)
return ::strncasecmp(a, b, count);
#elif defined(HAVE_STRNICMP)
return ::strnicmp(a, b, count);
#else
#error dont know how to compare counted length strings case insensitive on this system
#endif
 }

#ifdef WIN_NT
boolprefix_kernel_object_name(char* name, size_t bufsize);
boolisGlobalKernelPrefix();
boolprivate_kernel_object_name(char* name, size_t bufsize);
boolprivateNameSpaceReady();
#endif

// Compare the absolute value of two SINT64 numbers.
// Return 0 if they are equal, <0 if n1 < n2 and >0 if n1 > n2.
inlineintabs64Compare(SINT64 n1, SINT64 n2)
 {
#ifndef FB_INT64_COMPARE_FAILED
#defineFB_INT64_COMPARE_FAILED1
#endif

#if FB_INT64_COMPARE_FAILED
// avoid compiler bug when comparing minimum INT64
const SINT64 MININT64 = 0x8000000000000000;
if (n1 == MININT64)
return n2 == MININT64 ? 0 : 2;
if (n2 == MININT64)
return -2;
#endif

 n1 = n1 > 0 ? -n1 : n1;
 n2 = n2 > 0 ? -n2 : n2;
return n1 == n2 ? 0 : n1 < n2 ? 1 : -1;
 }

 Firebird::PathName get_process_name();
 SLONG genUniqueId();
voidgetCwd(Firebird::PathName& pn);

voidinlineinitStatusTo(ISC_STATUS* status, ISC_STATUS to)
 {
 status[0] = isc_arg_gds;
 status[1] = to;
 status[2] = isc_arg_end;
 }

voidinlineinit_status(ISC_STATUS* status)
 {
initStatusTo(status, FB_SUCCESS);
 }

voidinlinestatusBadAlloc(ISC_STATUS* status)
 {
initStatusTo(status, isc_virmemexh);
 }

voidinlinestatusUnknown(ISC_STATUS* status)
 {
initStatusTo(status, isc_exception_sigill); // Any better ideas? New error code?
 }

voidinlineinit_status(Firebird::CheckStatusWrapper* status)
 {
 status->init();
 }

unsignedintcopyStatus(ISC_STATUS* const to, constunsignedint space,
const ISC_STATUS* const from, constunsignedint count) throw();
voidcopyStatus(Firebird::CheckStatusWrapper* to, const Firebird::IStatus* from) throw();
unsignedintmergeStatus(ISC_STATUS* const to, unsignedint space, const Firebird::IStatus* from) throw();
voidsetIStatus(Firebird::CheckStatusWrapper* to, const ISC_STATUS* from) throw();
unsignedintstatusLength(const ISC_STATUS* const status) throw();
unsignedintsubStatus(const ISC_STATUS* in, unsignedint cin,
const ISC_STATUS* sub, unsignedint csub) throw();
boolcmpStatus(unsignedint len, const ISC_STATUS* a, const ISC_STATUS* b) throw();
const ISC_STATUS* nextCode(const ISC_STATUS* v) throw();

inlineunsignednextArg(const ISC_STATUS v) throw()
 {
return v == isc_arg_cstring ? 3 : 2;
 }

inlineboolisStr(const ISC_STATUS v) throw()
 {
switch (v)
 {
case isc_arg_cstring:
case isc_arg_string:
case isc_arg_interpreted:
case isc_arg_sql_state:
returntrue;
 }

returnfalse;
 }

// Check does vector contain particular code or not
boolcontainsErrorCode(const ISC_STATUS* v, ISC_STATUS code);

enum FetchPassResult {
 FETCH_PASS_OK,
 FETCH_PASS_FILE_OPEN_ERROR,
 FETCH_PASS_FILE_READ_ERROR,
 FETCH_PASS_FILE_EMPTY
 };
 FetchPassResult fetchPassword(const Firebird::PathName& name, constchar*& password);

// Returns current value of performance counter
 SINT64 query_performance_counter();

// Returns frequency of performance counter in Hz
 SINT64 query_performance_frequency();

voidget_process_times(SINT64 &userTime, SINT64 &sysTime);

voidexactNumericToStr(SINT64 value, int scale, Firebird::string& target, bool append = false);

// Returns true if called from firebird build process (appr. environment is set)
boolbootBuild();

// Add appropriate file prefix.
 Firebird::PathName getPrefix(unsigned prefType, constchar* name);

// moves DB path information (from limbo transaction) to another buffer
voidgetDbPathInfo(unsignedint& itemsLength, constunsignedchar*& items,
unsignedint& bufferLength, unsignedchar*& buffer,
 Firebird::Array<unsignedchar>& newItemsBuffer, const Firebird::PathName& dbpath);

// returns true if passed info items work with running svc thread
boolisRunningCheck(const UCHAR* items, unsignedint length);

// converts bytes to BASE64 representation
voidbase64(Firebird::string& b64, const Firebird::UCharBuffer& bin);

// generate random string in BASE64 representation
voidrandom64(Firebird::string& randomValue, FB_SIZE_T length);

voidlogAndDie(constchar* text);

// On incorrect sqlType returns dsc_unknown
 UCHAR sqlTypeToDscType(SSHORT sqlType);

// Returns next offset value
unsignedsqlTypeToDsc(unsigned prevOffset, unsigned sqlType, unsigned sqlLength,
unsigned* dtype, unsigned* len, unsigned* offset, unsigned* nullOffset);

boolinlineisNetworkError(ISC_STATUS code)
 {
return code == isc_network_error ||
 code == isc_net_write_err ||
 code == isc_net_read_err ||
 code == isc_lost_db_connection;
 }

// Uppercase/strip string according to login rules
constchar* dpbItemUpper(constchar* s, FB_SIZE_T l, Firebird::string& buf);

// Uppercase/strip string according to login rules
template <typename STR>
voiddpbItemUpper(STR& name)
 {
 Firebird::string buf;
constchar* up = dpbItemUpper(name.c_str(), name.length(), buf);
if (up)
 name = up;
 }

// Frequently used actions with clumplets
boolisBpbSegmented(unsigned parLength, constunsignedchar* par);


// Workaround, to be removed with C++ 23
template <typename... T>
constexprbool fb_always_false_v = false;

// Put integer value into info buffer
template<typename T>
inlineunsignedchar* putInfoItemInt(constunsignedchar item, T value,
unsignedchar* ptr, constunsignedchar* end)
 {
static_assert(std::is_integral_v<T>, "Integral type expected");

constexprauto len = sizeof(T);

if (ptr + len + 1 + 2 > end)
 {
if (ptr < end)
 {
 *ptr++ = isc_info_truncated;
if (ptr < end)
 *ptr++ = isc_info_end;
 }
returnnullptr;
 }

 *ptr++ = item;
 *ptr++ = len;
 *ptr++ = 0;

ifconstexpr (len == sizeof(SINT64))
put_vax_int64(ptr, value);
elseifconstexpr (len == sizeof(SLONG))
put_vax_long(ptr, value);
elseifconstexpr (len == sizeof(SSHORT))
put_vax_short(ptr, value);
elseifconstexpr (len == sizeof(char))
 *ptr = value;
else
static_assert(fb_always_false_v<T>, "unknown data type");

 ptr += len;
return ptr;
 }


// RAII to call fb_shutdown() in utilities
classFbShutdown
 {
public:
FbShutdown(int r)
 : reason(r)
 { }

~FbShutdown();

private:
int reason;
 };
} // namespace fb_utils

#endif// INCLUDE_UTILS_PROTO_H