char* TRI_StringInt32 (int32_t attr) {
char buffer[12];
char* p;
if (attr == INT32_MIN) {
return TRI_DuplicateString("-2147483648");
}
p = buffer;
if (attr < 0) {
*p++ = '-';
attr = -attr;
}
if (1000000000L <= attr) { *p++ = (char)((attr / 1000000000L) % 10 + '0'); }
if ( 100000000L <= attr) { *p++ = (char)((attr / 100000000L) % 10 + '0'); }
if ( 10000000L <= attr) { *p++ = (char)((attr / 10000000L) % 10 + '0'); }
if ( 1000000L <= attr) { *p++ = (char)((attr / 1000000L) % 10 + '0'); }
if ( 100000L <= attr) { *p++ = (char)((attr / 100000L) % 10 + '0'); }
if ( 10000L <= attr) { *p++ = (char)((attr / 10000L) % 10 + '0'); }
if ( 1000L <= attr) { *p++ = (char)((attr / 1000L) % 10 + '0'); }
if ( 100L <= attr) { *p++ = (char)((attr / 100L) % 10 + '0'); }
if ( 10L <= attr) { *p++ = (char)((attr / 10L) % 10 + '0'); }
*p++ = (char)(attr % 10 + '0');
*p = '\0';
return TRI_DuplicateString(buffer);
}
bool TRI_StartThread (TRI_thread_t* thread,
TRI_tid_t* threadId,
char const* name,
void (*starter)(void*),
void* data) {
thread_data_t* d = static_cast<thread_data_t*>(TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(thread_data_t), false));
d->starter = starter;
d->_data = data;
d->_name = TRI_DuplicateString(name);
int rc = pthread_create(thread, 0, &ThreadStarter, d);
if (rc != 0) {
TRI_set_errno(TRI_ERROR_SYS_ERROR);
LOG_ERROR("could not start thread: %s", strerror(errno));
TRI_Free(TRI_CORE_MEM_ZONE, d);
return false;
}
if (threadId != nullptr) {
*threadId = (TRI_tid_t) *thread;
}
return true;
}
bool TRI_StartThread (TRI_thread_t* thread, const char* name, void (*starter)(void*), void* data) {
DWORD threadId;
thread_data_t* d;
d = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(thread_data_t), false);
d->starter = starter;
d->_data = data;
d->_name = TRI_DuplicateString(name);
*thread = CreateThread(0, // default security attributes
0, // use default stack size
ThreadStarter, // thread function name
d, // argument to thread function
0, // use default creation flags
&threadId); // returns the thread identifier
if (*thread == 0) {
TRI_Free(TRI_CORE_MEM_ZONE, d);
LOG_ERROR("could not start thread: %s ", strerror(errno));
return false;
}
return true;
}
TRI_select_datapart_t* TRI_CreateDataPart(const char* alias,
const TRI_doc_collection_t* collection,
const TRI_select_part_e type,
const size_t extraDataSize) {
TRI_select_datapart_t* datapart;
if (extraDataSize) {
assert(!collection);
}
if (collection) {
assert(extraDataSize == 0);
}
datapart = (TRI_select_datapart_t*) TRI_Allocate(sizeof(TRI_select_datapart_t));
if (!datapart) {
return NULL;
}
datapart->_alias = TRI_DuplicateString(alias);
datapart->_collection = (TRI_doc_collection_t*) collection;
datapart->_type = type;
datapart->_extraDataSize = extraDataSize;
datapart->free = FreeDataPart;
return datapart;
}
static TRI_aql_bind_parameter_t* CreateParameter (const char* const name,
const TRI_json_t* const value) {
TRI_aql_bind_parameter_t* parameter;
assert(name);
assert(value);
parameter = (TRI_aql_bind_parameter_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_bind_parameter_t), false);
if (!parameter) {
return NULL;
}
parameter->_name = TRI_DuplicateString(name);
if (!parameter->_name) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, parameter);
return NULL;
}
parameter->_value = TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, (TRI_json_t*) value);
if (!parameter->_value) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, parameter->_name);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, parameter);
return NULL;
}
return parameter;
}
char* TRI_StringUInt64 (uint64_t attr) {
char buffer[21];
char* p = buffer;
if (10000000000000000000ULL <= attr) { *p++ = (char)((attr / 10000000000000000000ULL) % 10 + '0'); }
if ( 1000000000000000000ULL <= attr) { *p++ = (char)((attr / 1000000000000000000ULL) % 10 + '0'); }
if ( 100000000000000000ULL <= attr) { *p++ = (char)((attr / 100000000000000000ULL) % 10 + '0'); }
if ( 10000000000000000ULL <= attr) { *p++ = (char)((attr / 10000000000000000ULL) % 10 + '0'); }
if ( 1000000000000000ULL <= attr) { *p++ = (char)((attr / 1000000000000000ULL) % 10 + '0'); }
if ( 100000000000000ULL <= attr) { *p++ = (char)((attr / 100000000000000ULL) % 10 + '0'); }
if ( 10000000000000ULL <= attr) { *p++ = (char)((attr / 10000000000000ULL) % 10 + '0'); }
if ( 1000000000000ULL <= attr) { *p++ = (char)((attr / 1000000000000ULL) % 10 + '0'); }
if ( 100000000000ULL <= attr) { *p++ = (char)((attr / 100000000000ULL) % 10 + '0'); }
if ( 10000000000ULL <= attr) { *p++ = (char)((attr / 10000000000ULL) % 10 + '0'); }
if ( 1000000000ULL <= attr) { *p++ = (char)((attr / 1000000000ULL) % 10 + '0'); }
if ( 100000000ULL <= attr) { *p++ = (char)((attr / 100000000ULL) % 10 + '0'); }
if ( 10000000ULL <= attr) { *p++ = (char)((attr / 10000000ULL) % 10 + '0'); }
if ( 1000000ULL <= attr) { *p++ = (char)((attr / 1000000ULL) % 10 + '0'); }
if ( 100000ULL <= attr) { *p++ = (char)((attr / 100000ULL) % 10 + '0'); }
if ( 10000ULL <= attr) { *p++ = (char)((attr / 10000ULL) % 10 + '0'); }
if ( 1000ULL <= attr) { *p++ = (char)((attr / 1000ULL) % 10 + '0'); }
if ( 100ULL <= attr) { *p++ = (char)((attr / 100ULL) % 10 + '0'); }
if ( 10ULL <= attr) { *p++ = (char)((attr / 10ULL) % 10 + '0'); }
*p++ = (char)(attr % 10 + '0');
*p = '\0';
return TRI_DuplicateString(buffer);
}
char* TRI_ParseQueryAllocString (TRI_query_template_t* const template_,
const char* string) {
// do string duplication
char* copy = TRI_DuplicateString(string);
// store pointer to copy
return TRI_ParseQueryRegisterString(template_, copy);
}
bool TRI_RegisterMimetype (const char* extension,
const char* mimetype,
bool appendCharset) {
mimetype_t* entry = static_cast<mimetype_t*>(TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(mimetype_t), false));
entry->_extension = TRI_DuplicateString(extension);
entry->_appendCharset = appendCharset;
if (appendCharset) {
entry->_mimetype = TRI_Concatenate2String(mimetype, "; charset=utf-8");
}
else {
entry->_mimetype = TRI_DuplicateString(mimetype);
}
void* found = TRI_InsertKeyAssociativePointer(&Mimetypes, extension, entry, false);
return (found != nullptr);
}
void TRI_CreateExternalProcess (const char* executable,
const char** arguments,
size_t n,
bool usePipes,
TRI_external_id_t* pid) {
// create the external structure
TRI_external_t* external = static_cast<TRI_external_t*>(TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_external_t), true));
external->_executable = TRI_DuplicateString(executable);
external->_numberArguments = n + 1;
external->_arguments = static_cast<char**>(TRI_Allocate(TRI_CORE_MEM_ZONE, (n + 2) * sizeof(char*), true));
external->_arguments[0] = TRI_DuplicateString(executable);
for (size_t i = 0; i < n; ++i) {
external->_arguments[i + 1] = TRI_DuplicateString(arguments[i]);
}
external->_arguments[n + 1] = nullptr;
external->_status = TRI_EXT_NOT_STARTED;
StartExternalProcess(external, usePipes);
if (external->_status != TRI_EXT_RUNNING) {
pid->_pid = TRI_INVALID_PROCESS_ID;
FreeExternal(external);
return;
}
LOG_DEBUG("adding process %d to list", (int) external->_pid);
TRI_LockMutex(&ExternalProcessesLock);
TRI_PushBackVectorPointer(&ExternalProcesses, external);
// Note that the following deals with different types under windows,
// however, this code here can be written in a platform-independent
// way:
pid->_pid = external->_pid;
pid->_readPipe = external->_readPipe;
pid->_writePipe = external->_writePipe;
TRI_UnlockMutex(&ExternalProcessesLock);
}
void TRI_InitializeProcess (int argc, char* argv[]) {
TRI_PhysicalMemory = GetPhysicalMemory();
if (ProcessName != nullptr) {
return;
}
ProcessName = TRI_DuplicateString(argv[0]);
ARGC = argc;
ARGV = argv;
TRI_InitVectorPointer(&ExternalProcesses, TRI_CORE_MEM_ZONE);
TRI_InitMutex(&ExternalProcessesLock);
}
char* TRI_StringInt64 (int64_t attr) {
char buffer[21];
char* p = buffer;
if (attr == INT64_MIN) {
return TRI_DuplicateString("-9223372036854775808");
}
if (attr < 0) {
*p++ = '-';
attr = -attr;
}
if (1000000000000000000LL <= attr) { *p++ = (char)((attr / 1000000000000000000LL) % 10 + '0'); }
if ( 100000000000000000LL <= attr) { *p++ = (char)((attr / 100000000000000000LL) % 10 + '0'); }
if ( 10000000000000000LL <= attr) { *p++ = (char)((attr / 10000000000000000LL) % 10 + '0'); }
if ( 1000000000000000LL <= attr) { *p++ = (char)((attr / 1000000000000000LL) % 10 + '0'); }
if ( 100000000000000LL <= attr) { *p++ = (char)((attr / 100000000000000LL) % 10 + '0'); }
if ( 10000000000000LL <= attr) { *p++ = (char)((attr / 10000000000000LL) % 10 + '0'); }
if ( 1000000000000LL <= attr) { *p++ = (char)((attr / 1000000000000LL) % 10 + '0'); }
if ( 100000000000LL <= attr) { *p++ = (char)((attr / 100000000000LL) % 10 + '0'); }
if ( 10000000000LL <= attr) { *p++ = (char)((attr / 10000000000LL) % 10 + '0'); }
if ( 1000000000LL <= attr) { *p++ = (char)((attr / 1000000000LL) % 10 + '0'); }
if ( 100000000LL <= attr) { *p++ = (char)((attr / 100000000LL) % 10 + '0'); }
if ( 10000000LL <= attr) { *p++ = (char)((attr / 10000000LL) % 10 + '0'); }
if ( 1000000LL <= attr) { *p++ = (char)((attr / 1000000LL) % 10 + '0'); }
if ( 100000LL <= attr) { *p++ = (char)((attr / 100000LL) % 10 + '0'); }
if ( 10000LL <= attr) { *p++ = (char)((attr / 10000LL) % 10 + '0'); }
if ( 1000LL <= attr) { *p++ = (char)((attr / 1000LL) % 10 + '0'); }
if ( 100LL <= attr) { *p++ = (char)((attr / 100LL) % 10 + '0'); }
if ( 10LL <= attr) { *p++ = (char)((attr / 10LL) % 10 + '0'); }
*p++ = (char)(attr % 10 + '0');
*p = '\0';
return TRI_DuplicateString(buffer);
}
bool TRI_RegisterFunctionAql (TRI_associative_pointer_t* functions,
const char* const externalName,
const char* const internalName,
const bool isDeterministic,
const bool isGroup,
const char* const argPattern) {
TRI_aql_function_t* function;
function = (TRI_aql_function_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_function_t), false);
if (!function) {
return false;
}
function->_externalName = TRI_DuplicateString(externalName);
if (!function->_externalName) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function);
return false;
}
// normalize name by upper-casing it
function->_internalName = TRI_UpperAsciiString(internalName);
if (!function->_internalName) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function->_externalName);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function);
return false;
}
if (TRI_InsertKeyAssociativePointer(functions, externalName, function, false)) {
// function already registered
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function->_externalName);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function->_internalName);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, function);
return false;
}
function->_isDeterministic = isDeterministic;
function->_isGroup = isGroup;
function->_argPattern = argPattern;
// set minArgs and maxArgs
SetArgumentCount(function);
return true;
}
static int RemoveCompactor (TRI_document_collection_t* document,
TRI_datafile_t* compactor) {
TRI_primary_collection_t* primary;
size_t i;
primary = &document->base;
LOG_TRACE("removing empty compaction file '%s'", compactor->getName(compactor));
// remove the datafile from the list of datafiles
TRI_WRITE_LOCK_DATAFILES_DOC_COLLECTION(primary);
// remove the compactor from the list of compactors
if (! LocateDatafile(&primary->base._compactors, compactor->_fid, &i)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error: could not locate compactor");
return TRI_ERROR_INTERNAL;
}
TRI_RemoveVectorPointer(&primary->base._compactors, i);
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
// close the file & remove it
if (compactor->isPhysical(compactor)) {
char* filename;
filename = TRI_DuplicateString(compactor->getName(compactor));
TRI_CloseDatafile(compactor);
TRI_FreeDatafile(compactor);
TRI_UnlinkFile(filename);
TRI_Free(TRI_CORE_MEM_ZONE, filename);
}
else {
TRI_CloseDatafile(compactor);
TRI_FreeDatafile(compactor);
}
return TRI_ERROR_NO_ERROR;
}
char* TRI_GetFunctionCodeQueryJavascript (const TRI_query_node_t* const node,
TRI_associative_pointer_t* bindParameters) {
TRI_query_javascript_converter_t* js;
char* function = NULL;
assert(node);
js = TRI_InitQueryJavascript();
if (js) {
TRI_AppendStringStringBuffer(js->_buffer, "(function($) { return ");
TRI_ConvertQueryJavascript(js, node, bindParameters);
TRI_AppendStringStringBuffer(js->_buffer, " })");
function = TRI_DuplicateString(js->_buffer->_buffer);
TRI_FreeQueryJavascript(js);
}
return function;
}
static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
TRI_col_type_t type,
char const* name,
TRI_voc_cid_t cid,
char const* path) {
void const* found;
TRI_vocbase_col_t* col;
// create a new proxy
col = TRI_Allocate(sizeof(TRI_vocbase_col_t));
col->_vocbase = vocbase;
col->_type = type;
TRI_CopyString(col->_name, name, sizeof(col->_name));
col->_path = (path == NULL ? NULL : TRI_DuplicateString(path));
col->_collection = NULL;
col->_newBorn = 0;
col->_loaded = 0;
col->_corrupted = 0;
col->_cid = cid;
// check name
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsByName, name, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for name '%s'", name);
return NULL;
}
// check collection identifier
if (cid != 0) {
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsById, &cid, col, false);
if (found != NULL) {
TRI_Free(col);
LOG_ERROR("duplicate entry for identifier '%s'", cid);
return NULL;
}
}
TRI_PushBackVectorPointer(&vocbase->_collections, col);
return col;
}
TRI_aql_variable_t* TRI_CreateVariableAql (const char* const name,
TRI_aql_node_t* const definingNode) {
TRI_aql_variable_t* variable;
variable = (TRI_aql_variable_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_variable_t), false);
if (variable == NULL) {
return NULL;
}
variable->_name = TRI_DuplicateString(name);
if (variable->_name == NULL) {
TRI_FreeVariableAql(variable);
return NULL;
}
variable->_definingNode = definingNode;
assert(definingNode);
return variable;
}
static void RenameDatafileCallback (TRI_datafile_t* datafile,
void* data) {
compaction_context_t* context;
TRI_datafile_t* compactor;
TRI_primary_collection_t* primary;
bool ok;
context = data;
compactor = context->_compactor;
primary = &context->_document->base;
ok = false;
assert(datafile->_fid == compactor->_fid);
if (datafile->isPhysical(datafile)) {
char* number;
char* jname;
char* tempFilename;
char* realName;
realName = TRI_DuplicateString(datafile->_filename);
// construct a suitable tempname
number = TRI_StringUInt64(datafile->_fid);
jname = TRI_Concatenate3String("temp-", number, ".db");
tempFilename = TRI_Concatenate2File(primary->base._directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
if (! TRI_RenameDatafile(datafile, tempFilename)) {
LOG_ERROR("unable to rename datafile '%s' to '%s'", datafile->getName(datafile), tempFilename);
}
else {
if (! TRI_RenameDatafile(compactor, realName)) {
LOG_ERROR("unable to rename compaction file '%s' to '%s'", compactor->getName(compactor), realName);
}
else {
ok = true;
}
}
TRI_FreeString(TRI_CORE_MEM_ZONE, tempFilename);
TRI_FreeString(TRI_CORE_MEM_ZONE, realName);
}
else {
ok = true;
}
if (ok) {
TRI_doc_datafile_info_t* dfi;
size_t i;
// must acquire a write-lock as we're about to change the datafiles vector
TRI_WRITE_LOCK_DATAFILES_DOC_COLLECTION(primary);
if (! LocateDatafile(&primary->base._datafiles, datafile->_fid, &i)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error: could not locate datafile");
return;
}
// put the compactor in place of the datafile
primary->base._datafiles._buffer[i] = compactor;
// update dfi
dfi = TRI_FindDatafileInfoPrimaryCollection(primary, compactor->_fid, false);
if (dfi != NULL) {
memcpy(dfi, &context->_dfi, sizeof(TRI_doc_datafile_info_t));
}
else {
LOG_ERROR("logic error: could not find compactor file information");
}
if (! LocateDatafile(&primary->base._compactors, compactor->_fid, &i)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error: could not locate compactor");
return;
}
// remove the compactor from the list of compactors
TRI_RemoveVectorPointer(&primary->base._compactors, i);
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
DropDatafileCallback(datafile, primary);
}
TRI_Free(TRI_CORE_MEM_ZONE, context);
}
int TRI_ZipFile (const char* filename,
const char* dir,
TRI_vector_string_t const* files,
const char* password) {
void* buffer;
size_t bufferSize;
zipFile zf;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
size_t i, n;
int res;
if (TRI_ExistsFile(filename)) {
return TRI_ERROR_CANNOT_OVERWRITE_FILE;
}
bufferSize = 16384;
buffer = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, bufferSize, false);
if (buffer == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(filename, 0, NULL, &ffunc);
#else
zf = zipOpen64(filename, 0);
#endif
if (zf == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return ZIP_ERRNO;
}
res = TRI_ERROR_NO_ERROR;
n = files->_length;
for (i = 0; i < n; ++i) {
FILE* fin;
char* file;
char* fullfile;
char* saveName;
zip_fileinfo zi;
uint32_t crc;
int isLarge;
file = TRI_AtVectorString(files, i);
if (*dir == '\0') {
fullfile = TRI_DuplicateString(file);
}
else {
fullfile = TRI_Concatenate2File(dir, file);
}
memset(&zi, 0, sizeof(zi));
res = TRI_Crc32File(fullfile, &crc);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
isLarge = (TRI_SizeFile(file) > 0xFFFFFFFFLL);
saveName = file;
while (*saveName == '\\' || *saveName == '/') {
++saveName;
}
if (zipOpenNewFileInZip3_64(zf,
saveName,
&zi,
NULL,
0,
NULL,
0,
NULL, /* comment*/
Z_DEFLATED,
Z_DEFAULT_COMPRESSION,
0,
-MAX_WBITS,
DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY,
password,
(unsigned long) crc,
isLarge) != ZIP_OK) {
}
fin = fopen(fullfile, "rb");
TRI_FreeString(TRI_CORE_MEM_ZONE, fullfile);
if (fin == NULL) {
break;
}
while (true) {
int sizeRead;
sizeRead = (int) fread(buffer, 1, bufferSize, fin);
if (sizeRead < bufferSize) {
if (feof(fin) == 0) {
res = TRI_set_errno(TRI_ERROR_SYS_ERROR);
break;
}
}
if (sizeRead > 0) {
res = zipWriteInFileInZip(zf, buffer, sizeRead);
if (res != 0) {
break;
}
}
else if (sizeRead <= 0) {
break;
}
}
fclose(fin);
zipCloseFileInZip(zf);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
}
zipClose(zf, NULL);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return res;
}
