static ERR_VALUE _init_lookasides(const uint32_t KmerSize, PUTILS_LOOKASIDE *VA, PUTILS_LOOKASIDE *EA) { ERR_VALUE ret = ERR_SUCCESS; int threadIndex = omp_get_thread_num(); if (_vertexLAs[threadIndex] == NULL) { ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _vertexLAs + threadIndex); if (ret == ERR_SUCCESS) { ret = utils_lookaside_init(_vertexLAs[threadIndex], sizeof(KMER_VERTEX) + KmerSize, 3000); if (ret != ERR_SUCCESS) { utils_free(_vertexLAs[threadIndex]); _vertexLAs[threadIndex] = NULL; } } } if (ret == ERR_SUCCESS) { *VA = _vertexLAs[threadIndex]; if (_edgeLAs[threadIndex] == NULL) { ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _edgeLAs + threadIndex); if (ret == ERR_SUCCESS) { ret = utils_lookaside_init(_edgeLAs[threadIndex], sizeof(KMER_EDGE), 5000); if (ret != ERR_SUCCESS) { utils_free(_edgeLAs[threadIndex]); _edgeLAs[threadIndex] = NULL; } } } if (ret == ERR_SUCCESS) *EA = _edgeLAs[threadIndex]; } return ret; }
/* Convenience function. Free the three program name strings stored * by utils_remember_program_name(). This can safely be called * without really storing them, though there is probably no reason not * to do that in the first place. */ void utils_free_program_name_strings (void) { utils_free (full_program_name); utils_free (short_program_name); utils_free (program_directory); }
int xml_cleanup(void) { int i; for (i = 0; i < xml_numAttr; i++) { if (xattr[i].node != NULL) xattr[i].node = utils_free("xml.xml_cleanup.xattr[].node", xattr[i].node); if (xattr[i].name != NULL) xattr[i].name = utils_free("xml.xml_cleanup.xattr[].name", xattr[i].name); if (xattr[i].value != NULL) xattr[i].value = utils_free("xml.xml_cleanup.xattr[].value", xattr[i].value); if (xattr[i].filename != NULL) xattr[i].filename = utils_free("xml.xml_cleanup.xattr[].filename", xattr[i].filename); xattr[i].node = NULL; xattr[i].name = NULL; xattr[i].value = NULL; xattr[i].filename = NULL; } //xattr = utils_free("xml.xml_cleanup.xattr", xattr); return 0; }
void xml_free_all(char **ret, int num) { int i; for (i = 0; i < num; i++) ret[i] = utils_free("xml.xml_free_all.ret[]", ret[i]); ret = utils_free("xml.xml_free_all.ret", ret); }
void assembly_task_finit(PASSEMBLY_TASK Task) { if (Task->Allocated) { read_set_destroy((PONE_READ)Task->Reads, Task->ReadCount); utils_free((char *)Task->Alternate2); utils_free((char *)Task->Alternate1); utils_free((char *)Task->Reference); } return; }
ERR_VALUE read_copy(PONE_READ Dest, const ONE_READ *Source) { ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = ERR_SUCCESS; *Dest = *Source; if (Dest->CIGARLen > 0) ret = utils_copy_string(Source->CIGAR, &Dest->CIGAR); if (ret == ERR_SUCCESS) { if (Dest->TemplateNameLen > 0) ret = utils_copy_string(Source->TemplateName, &Dest->TemplateName); if (ret == ERR_SUCCESS) { if (Dest->ReadSequenceLen > 0) ret = utils_copy_string(Source->ReadSequence, &Dest->ReadSequence); if (ret == ERR_SUCCESS) { if (Dest->QualityLen > 0) { ret = utils_calloc(Dest->QualityLen + 1, sizeof(uint8_t), &Dest->Quality); if (ret == ERR_SUCCESS) { memcpy(Dest->Quality, Source->Quality, Dest->QualityLen);; Dest->Quality[Dest->QualityLen] = 0; } } if (ret == ERR_SUCCESS && Source->RNameLen > 0) ret = utils_copy_string(Source->RName, &Dest->RName); if (ret == ERR_SUCCESS && Source->RNextLen > 0) ret = utils_copy_string(Source->RNext, &Dest->RNext); if (ret != ERR_SUCCESS) { if (Dest->ReadSequenceLen > 0) utils_free(Dest->ReadSequence); } } if (ret != ERR_SUCCESS) { if (Dest->TemplateNameLen > 0) utils_free(Dest->TemplateName); } } if (ret != ERR_SUCCESS) { if (Dest->CIGARLen > 0) utils_free(Dest->CIGAR); } } return ret; }
ERR_VALUE read_set_generate_from_sequence(const char *Seq, const size_t SeqLen, const uint32_t ReadLength, const size_t ReadCount, PONE_READ *ReadSet) { PONE_READ r = NULL; PONE_READ tmpReadSet = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(ReadCount, sizeof(ONE_READ), &tmpReadSet); if (ret == ERR_SUCCESS) { r = tmpReadSet; for (size_t i = 0; i < ReadCount; ++i) { memset(r, 0, sizeof(ONE_READ)); r->Pos = utils_ranged_rand(0, SeqLen - ReadLength + 1); r->PosQuality = 254; r->ReadSequenceLen = ReadLength; ret = utils_calloc(r->ReadSequenceLen + 1, sizeof(char), &r->ReadSequence); if (ret == ERR_SUCCESS) { memcpy(r->ReadSequence, Seq + r->Pos, r->ReadSequenceLen*sizeof(char)); r->ReadSequence[r->ReadSequenceLen] = '\0'; r->QualityLen = r->ReadSequenceLen; ret = utils_calloc(r->QualityLen, sizeof(uint8_t), &r->Quality); if (ret == ERR_SUCCESS) memset(r->Quality, 254, r->QualityLen); if (ret != ERR_SUCCESS) utils_free(r->ReadSequence); } if (ret != ERR_SUCCESS) { --r; for (size_t j = 0; j < i; ++j) { _read_destroy_structure(r); --r; } break; } ++r; } if (ret == ERR_SUCCESS) *ReadSet = tmpReadSet; if (ret != ERR_SUCCESS) utils_free(tmpReadSet); } return ret; }
int process_data(xmlDocPtr doc, xmlNodePtr node, char *xpath, int level, char *fn) { char *newxpath = NULL; char *data = NULL; int size, i, found; node = node->xmlChildrenNode; while (node != NULL) { data = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1); if ((data != NULL) && ((strlen(data) == 0) || (data[0] == 10))) { size = strlen(xpath) + strlen((const char *)node->name) + 2; newxpath = (char *)utils_alloc( "xml.process_data.newxpath", size * sizeof(char) ); snprintf(newxpath, size, "%s/%s", xpath, node->name); process_recursive(doc, newxpath, level + 1, fn); newxpath = utils_free("xml.process_data.newxpath", newxpath); } else if (data != NULL) { found = 0; for (i = 0; i < xml_numAttr; i++) { if ((strcmp(xattr[i].name, (const char *)node->name) == 0) && ((strcmp(xattr[i].node, xpath) == 0)) && ((strcmp(xattr[i].value, data) == 0)) && ((strcmp(xattr[i].filename, fn) == 0))) found = 1; } if (!found) { if (xattr == NULL) xattr = (tAttr *)utils_alloc( "xml.process_data.xattr", sizeof(tAttr) ); else xattr = (tAttr *)realloc( xattr, (xml_numAttr + 1) * sizeof(tAttr) ); xattr[xml_numAttr].name = strdup( (const char *)node->name); xattr[xml_numAttr].node = strdup(xpath); xattr[xml_numAttr].value = strdup(data); xattr[xml_numAttr].filename = strdup(fn); xattr[xml_numAttr].numIter = xml_numIter; xml_numAttr++; } } data = utils_free("xml.process_data.data", data); node = node->next; } xml_numIter++; return 0; }
static ERR_VALUE _examine_read_coverage(const ONE_READ *Reads, const size_t ReadCount, const char *RefSeq, const size_t RefSeqLen, const char *Alternate) { uint32_t *c = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(RefSeqLen, sizeof(uint32_t), &c); if (ret == ERR_SUCCESS) { memset(c, 0, RefSeqLen*sizeof(uint32_t)); for (size_t i = 0; i < ReadCount; ++i) { for (size_t j = 0; j < Reads[i].ReadSequenceLen; ++j) c[Reads[i].Pos + j]++; } printf("Not covered: "); for (size_t i = 0; i < RefSeqLen; ++i) { if (c[i] == 0) { printf("%u ", i); if (RefSeq[i] != Alternate[i]) { printf("%u: The position has SNPs but is not covered in any read (%c %c)\n", i, RefSeq[i], Alternate[i]); ret = ERR_BAD_READ_COVERAGE; } } } printf("\n"); utils_free(c); } return ret; }
ERR_VALUE read_set_load(FILE *Stream, PONE_READ *ReadSet, size_t *Count) { uint32_t count32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; PONE_READ tmpReadSet = NULL; ret = utils_fread(&count32, sizeof(count32), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_calloc(count32, sizeof(ONE_READ), &tmpReadSet); if (ret == ERR_SUCCESS) { for (uint32_t i = 0; i < count32; ++i) { ret = read_load(Stream, tmpReadSet + i); if (ret != ERR_SUCCESS) { for (uint32_t j = 0; j < i; ++j) _read_destroy_structure(tmpReadSet + j); break; } } if (ret == ERR_SUCCESS) { *ReadSet = tmpReadSet; *Count = count32; } if (ret != ERR_SUCCESS) utils_free(tmpReadSet); } } return ret; }
void read_destroy(PONE_READ Read) { _read_destroy_structure(Read); utils_free(Read); return; }
ERR_VALUE kmer_table_create(const size_t KMerSize, const size_t Size, const KMER_TABLE_CALLBACKS *Callbacks, PKMER_TABLE *Table) { PKMER_TABLE tmpTable = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_malloc_KMER_TABLE(&tmpTable); if (ret == ERR_SUCCESS) { tmpTable->KHashTable = kh_init(vertexTable); if (tmpTable != NULL) { tmpTable->LastOrder = 0; tmpTable->KMerSize = KMerSize; if (Callbacks == NULL) { tmpTable->Callbacks.Context = NULL; tmpTable->Callbacks.OnInsert = _on_insert_dummy_callback; tmpTable->Callbacks.OnDelete = _on_delete_dummy_callback; tmpTable->Callbacks.OnCopy = _on_copy_dummy_callback; tmpTable->Callbacks.OnPrint = _on_print_dummy_callback; } else tmpTable->Callbacks = *Callbacks; *Table = tmpTable; ret = ERR_SUCCESS; } else ret = ERR_OUT_OF_MEMORY; if (ret != ERR_SUCCESS) utils_free(tmpTable); } else ret = ERR_OUT_OF_MEMORY; return ret; }
ERR_VALUE read_set_merge(PONE_READ *Target, const size_t TargetCount, struct _ONE_READ *Source, const size_t SourceCount) { PONE_READ tmp = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(TargetCount + SourceCount, sizeof(ONE_READ), &tmp); if (ret == ERR_SUCCESS) { memcpy(tmp, *Target, TargetCount*sizeof(ONE_READ)); memcpy(tmp + TargetCount, Source, SourceCount*sizeof(ONE_READ)); utils_free(Source); utils_free(*Target); *Target = tmp; } return ret; }
ERR_VALUE read_load(FILE *Stream, PONE_READ Read) { uint32_t rsLen32 = 0; uint32_t qLen32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; memset(Read, 0, sizeof(ONE_READ)); ret = utils_fread(&rsLen32, sizeof(rsLen32), 1, Stream); if (ret == ERR_SUCCESS) { Read->ReadSequenceLen = rsLen32; ret = utils_calloc(Read->ReadSequenceLen + 1, sizeof(char), &Read->ReadSequence); if (ret == ERR_SUCCESS) { Read->ReadSequence[Read->ReadSequenceLen] = '\0'; ret = utils_fread(Read->ReadSequence, sizeof(char), Read->ReadSequenceLen, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&qLen32, sizeof(qLen32), 1, Stream); if (ret == ERR_SUCCESS) { Read->QualityLen = qLen32; ret = utils_calloc(Read->QualityLen, sizeof(uint8_t), &Read->Quality); if (ret == ERR_SUCCESS) { ret = utils_fread(Read->Quality, sizeof(uint8_t), Read->QualityLen, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->Pos, sizeof(Read->Pos), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->PosQuality, sizeof(Read->PosQuality), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->Flags, sizeof(Read->Flags), 1, Stream); if (ret == ERR_SUCCESS) read_split(Read); } } } if (ret != ERR_SUCCESS) utils_free(Read->Quality); } } } if (ret != ERR_SUCCESS) utils_free(Read->ReadSequence); } } return ret; }
inline static void pop_condition_stack (void) { ConditionStackEntry *entry = condition_stack; condition_stack = entry->next; utils_free (entry); }
void configuration_set_string_value (char **configuration_variable, const char *string) { assert (configuration_variable); utils_free (*configuration_variable); *configuration_variable = utils_duplicate_string (string); }
void xmlrpc_process_param(xmlDocPtr doc, xmlNodePtr node, int ignore_check, int level) { char *data = NULL; while (node != NULL) { data = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1); if (data != NULL) { if ((!ignore_check) && (!is_valid_data_type((char *)node->name))) DPRINTF("WARNING: Invalid data in %s\n", node->name); else { if (!((_xlastElement != NULL) && (strcmp(data, _xlastElement) == 0))) xmlrpc_variable_add((char *)node->name, data); } } else if ((node->name != NULL) && (data == NULL)) { if ((strcmp((char *)node->name, "member") == 0)) { char *tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode->xmlChildrenNode, 1); if (tmp != NULL) { if (_xlastElement) xmlrpc_variable_add("struct", data); _xlastElement = utils_free("xmlrpc.xmlrpc_process_param._xlastElement", _xlastElement); _xlastElement = strdup(tmp); tmp = utils_free("xmlrpc.xmlrpc_process_param.tmp", tmp); } } xmlrpc_process_param(doc, node->xmlChildrenNode, (strcmp((char *)node->name, "member") == 0) ? 1 : 0, level + 1); if ((strcmp((char *)node->name, "value") == 0) || (_xlastElement != NULL)) { if (_xlastElement == NULL) _xIdParent = 0; _xlastElement = utils_free("xmlrpc.xmlrpc_process_param._xlastElement", _xlastElement); } } data = utils_free("xmlrpc.xmlrpc_process_param.data", data); node = node->next; } }
GtkWidget * gtk_utils_create_titled_page (GtkWidget *contents, const gchar *icon_stock_id, const gchar *title) { GtkWidget *image = NULL; GtkWidget *label = NULL; GtkWidget *title_widget; GtkWidget *hseparator; g_return_val_if_fail (GTK_IS_WIDGET (contents), NULL); g_return_val_if_fail (icon_stock_id || title, NULL); if (icon_stock_id) { image = gtk_image_new_from_stock (icon_stock_id, GTK_ICON_SIZE_LARGE_TOOLBAR); } if (title) { gchar *title_escaped = g_markup_escape_text (title, -1); char *marked_up_title = utils_cat_strings (NULL, "<span weight=\"bold\" size=\"x-large\">", title_escaped, "</span>", NULL); g_free (title_escaped); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), marked_up_title); utils_free (marked_up_title); } if (image && label) { title_widget = gtk_utils_pack_in_box (GTK_TYPE_HBOX, QUARRY_SPACING_SMALL, image, GTK_UTILS_FILL, label, 0, NULL); } else if (label) { gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); title_widget = label; } else title_widget = image; gtk_widget_show_all (title_widget); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); return gtk_utils_pack_in_box (GTK_TYPE_VBOX, QUARRY_SPACING_SMALL, title_widget, GTK_UTILS_FILL, hseparator, GTK_UTILS_FILL, contents, GTK_UTILS_PACK_DEFAULT, NULL); }
char * parse_multiline_string (char **line, const char *type, const char *line_separator, int null_allowed) { const char *string_chunk; char *string; string_chunk = parse_thing (null_allowed ? STRING_OR_NULL : STRING, line, type); if (!string_chunk) return NULL; string = utils_duplicate_string (string_chunk); if (*string != '"') return string; while (! **line) { *line = read_line (); if (! *line) { utils_free (string); return NULL; } if (**line == '"') { string_chunk = parse_thing (STRING, line, type); if (!string_chunk) { utils_free (string); return NULL; } string = utils_cat_strings (string, line_separator, string_chunk, NULL); } else { reuse_last_line (line); break; } } return string; }
void kmer_table_destroy(PKMER_TABLE Table) { for (khiter_t it = kh_begin(Table->KHashTable); it != kh_end(Table->KHashTable); ++it) { if (kh_exist(Table->KHashTable, it)) Table->Callbacks.OnDelete(Table, kh_val(Table->KHashTable, it), Table->Callbacks.Context); } kh_destroy(vertexTable, Table->KHashTable); utils_free(Table); return; }
void read_set_destroy(PONE_READ ReadSet, const size_t Count) { PONE_READ tmp = ReadSet; for (size_t i = 0; i < Count; ++i) { _read_destroy_structure(tmp); ++tmp; } utils_free(ReadSet); return; }
void cdvws_process() { char *v = NULL; v = variable_get_element_as_string("module_var", NULL); if (v != NULL) { DPRINTF("We have module var set to '%s'\n", v); variable_add("module_var", v, TYPE_MODULE, 0, TYPE_STRING); } else { DPRINTF("We don't have module var set, setting to \"unset\"\n"); variable_add("module_var", "unset", TYPE_MODULE, 0, TYPE_STRING); } v = utils_free("mod_test.v", v); }
void xmlrpc_variable_free_all(void) { int i; if (_xmlrpc_vars == NULL) return; for (i = 0; i < _xmlrpc_vars_num; i++) { _xmlrpc_vars[i].id = 0; _xmlrpc_vars[i].idParent = 0; _xmlrpc_vars[i].iValue = 0; _xmlrpc_vars[i].shValue = 0; _xmlrpc_vars[i].sValue = utils_free("xmlrpc.xmlrpc_variable_free_all", _xmlrpc_vars[i].sValue); _xmlrpc_vars[i].sValue = NULL; _xmlrpc_vars[i].dValue = 0; } _xmlrpc_vars_num = 0; }
static const char *_sam_read_string_field(const char *Start, char **String, size_t *Length) { char *tmpString = NULL; const char *end = NULL; size_t len = 0; end = _sam_read_field(Start); len = (end - Start); if (len > 0) { if (utils_malloc((len + 1)*sizeof(char), &tmpString) == ERR_SUCCESS) { memcpy(tmpString, Start, len*sizeof(char)); tmpString[len] = '\0'; if (String != NULL) { *String = tmpString; *Length = len; } else utils_free(tmpString); } else end = NULL; } else end = NULL; return end; }
ERR_VALUE read_create_from_test_line(const char *Line, const size_t Length, PONE_READ *Read) { PONE_READ tmpRead = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(1, sizeof(ONE_READ), &tmpRead); if (ret == ERR_SUCCESS) { memset(tmpRead, 0, sizeof(ONE_READ)); tmpRead->Pos = (uint64_t)-1; tmpRead->ReadSequenceLen = Length; ret = utils_calloc(Length + 1, sizeof(char), &tmpRead->ReadSequence); if (ret == ERR_SUCCESS) { memcpy(tmpRead->ReadSequence, Line, Length*sizeof(char)); tmpRead->ReadSequence[Length] = '\0'; *Read = tmpRead; } if (ret != ERR_SUCCESS) utils_free(tmpRead); } return ret; }
static void _on_delete_edge(const KMER_GRAPH *Graph, const KMER_EDGE *Edge, void *Context) { size_t i = 0; PGEN_ARRAY_KMER_EDGE_PAIR pairs = (PGEN_ARRAY_KMER_EDGE_PAIR)Context; PKMER_EDGE_PAIR p = pairs->Data; while (i < gen_array_size(pairs)) { if (p->U == Edge || p->V == Edge) { if (p->Edges != NULL) { utils_free(p->Edges); p->Edges = NULL; } dym_array_remove_fastKMER_EDGE_PAIR(pairs, i); continue; } ++p; ++i; } return; }
ERR_VALUE seq_load(FILE *Stream, char **RefSeq, size_t *Length) { char *tmpSeq = NULL; uint32_t length32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_fread(&length32, sizeof(length32), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_calloc(length32 + 1, sizeof(char), &tmpSeq); if (ret == ERR_SUCCESS) { tmpSeq[length32] = '\0'; ret = utils_fread(tmpSeq, sizeof(char), length32, Stream); if (ret == ERR_SUCCESS) { *RefSeq = tmpSeq; *Length = length32; } if (ret != ERR_SUCCESS) utils_free(tmpSeq); } } return ret; }
void _read_destroy_structure(PONE_READ Read) { if (Read->Quality != NULL) utils_free(Read->Quality); if (Read->ReadSequence != NULL) utils_free(Read->ReadSequence); if (Read->RNext != NULL) utils_free(Read->RNext); if (Read->CIGAR != NULL) utils_free(Read->CIGAR); if (Read->RName != NULL) utils_free(Read->RName); if (Read->TemplateName != NULL) utils_free(Read->TemplateName); return; }
int _script_builtin_function(char *var, char *fn, char *args) { int ret = 0; struct timespec ts; struct timespec tse; if (_perf_measure) ts = utils_get_time( TIME_CURRENT ); if (strcmp(fn, "set_all_variables_overwritable") == 0) { if (args != NULL) { int var = get_boolean(args); if ((var == 0) || (var == 1)) variable_allow_overwrite(NULL, var); else desc_printf(gIO, gFd, "Invalid value for %s(): %s\n", fn, args); } } else if (strcmp(fn, "get_all_variables_overwritable") == 0) { if (var != NULL) { char tmp[4] = { 0 }; snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(NULL)); variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT); } else desc_printf(gIO, gFd, "All variables overwritable: %s\n", (variable_get_overwrite(NULL) == 1) ? "true" : "false"); } else if (strcmp(fn, "set_variable_overwritable") == 0) { tTokenizer t; t = tokenize(args, ","); if (t.numTokens == 2) variable_allow_overwrite(trim(t.tokens[0]), get_boolean(t.tokens[1])); else desc_printf(gIO, gFd, "Syntax: set_variable_overwritable(variable, true|false)\n"); free_tokens(t); } else if (strcmp(fn, "get_variable_overwritable") == 0) { char tmp[4] = { 0 }; if ((args != NULL) && (strlen(args) > 0)) { snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(args)); if (var != NULL) variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT); else desc_printf(gIO, gFd, "Variable %s overwritable: %s\n", args, (strcmp(tmp, "1") == 0) ? "true" : ((strcmp(tmp, "0") == 0) ? "false" : "not found")); } else desc_printf(gIO, gFd, "Variable name is missing\n"); } else if (strcmp(fn, "enable_perf") == 0) { int enable = get_boolean(args); if ((enable == 0) || (enable == 1)) { DPRINTF("%sabling performance measuring\n", enable ? "En" : "Dis"); _perf_measure = enable; } else DPRINTF("Incorrect setting for performace measuring: %d\n", enable); if (_perf_measure) ts = utils_get_time( TIME_CURRENT ); } else if (strcmp(fn, "del") == 0) { variable_set_deleted(args, 1); } else if (strcmp(fn, "get") == 0) { char *val = variable_get_element_as_string(args, "get"); if (val != NULL) { DPRINTF("%s: Processing internal 'get' function for arguments: %s\n", __FUNCTION__, args); DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val); if (var != NULL) variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val)); } } else if (strcmp(fn, "dumpvars") == NULL) { desc_variable_dump(gIO, gFd, args); } else if (strcmp(fn, "post") == 0) { char *val = variable_get_element_as_string(args, "post"); if (val != NULL) { DPRINTF("%s: Processing internal 'post' function for arguments: %s\n", __FUNCTION__, args); DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val); if (var != NULL) variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val)); } } else if (strcmp(fn, "cookie") == 0) { char *val = variable_get_element_as_string(args, "cookie"); if (val != NULL) { DPRINTF("%s: Processing internal 'cookie' function for arguments: %s\n", __FUNCTION__, args); DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val); if (var != NULL) variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val)); } } else if (strcmp(fn, "sleep") == 0) { int num = atoi(args); DPRINTF("%s: Sleeping for %d seconds...\n", __FUNCTION__, num); sleep(num); } else if (strcmp(fn, "dumptype") == 0) { char *str = variable_get_type_string(args, "any"); desc_printf(gIO, gFd, "%s\n", str ? str : "<null>"); str = utils_free("scripting.dumptype.str", str); } else if (strcmp(fn, "print") == 0) { if (args != NULL) { if ((args[0] == '"') || (args[0] == '\'')) { *args++; args[strlen(args) - 1] = 0; args = replace(args, "\\n", "\n"); desc_printf(gIO, gFd, "%s", args); } else { char *var = variable_get_element_as_string(args, NULL); desc_printf(gIO, gFd, "%s", var ? var : ""); var = utils_free("scripting.print.var", var); } } } else if (strcmp(fn, "printf") == 0) { if ((args != NULL) && (strlen(args) > 0)) { int i; tTokenizer t; *args++; t = tokenize(args, "\""); if (t.numTokens == 1) { char *instr = NULL; instr = strdup(t.tokens[0]); while (strstr(instr, "\\n") != NULL) instr = replace(instr, "\\n", "\n"); desc_printf(gIO, gFd, "%s", instr); instr = utils_free("scripting.printf.instr", instr); } else if (t.numTokens == 2) { tTokenizer t2; char *instr = NULL; char *vars = NULL; instr = strdup( t.tokens[0] ); vars = strdup( t.tokens[1] + 1 ); t2 = tokenize(vars, ","); for (i = 0; i < t2.numTokens; i++) { DPRINTF("%s: Replacing variable %s\n", __FUNCTION__, trim(t2.tokens[i])); char *tmp = variable_get_element_as_string(trim(t2.tokens[i]), NULL); if (tmp != NULL) instr = replace(instr, "%s", tmp); else { instr = replace(instr, "%s", "NULL"); DPRINTF("%s: Variable \"%s\" not found\n", __FUNCTION__, trim(t2.tokens[i])); } } while (strstr(instr, "\\n") != NULL) instr = replace(instr, "\\n", "\n"); desc_printf(gIO, gFd, "%s", instr); free_tokens(t2); } else { free_tokens(t); ret = -EINVAL; goto cleanup; } free_tokens(t); } else { desc_printf(gIO, gFd, "Invalid syntax for printf()\n"); ret = -EINVAL; goto cleanup; } } else if (strcmp(fn, "idb_dump_query_set") == 0) { idb_results_show( gIO, gFd, idb_get_last_select_data() ); } else if (strcmp(fn, "idb_query") == 0) { char *filename = NULL; char *query = NULL; tTokenizer t; int i; t = tokenize(args, "\""); if (t.numTokens > 1) { int num = 0; for (i = 0; i < t.numTokens; i++) { if (strcmp(trim(t.tokens[i]), ",") != 0) { if (num == 0) filename = strdup(t.tokens[i]); else if (num == 1) query = strdup(t.tokens[i]); num++; } } } free_tokens(t); if (((filename == NULL) || (query == NULL)) && (args[0] == '@')) { *args++; DPRINTF("Reading query file '%s'\n", args); if (access(args, R_OK) == 0) { FILE *fp = NULL; char buf[BUFSIZE]; fp = fopen(args, "r"); if (fp != NULL) { int num = 0; while (!feof(fp)) { memset(buf, 0, sizeof(buf)); fgets(buf, sizeof(buf), fp); if ((strlen(buf) > 0) && (buf[strlen(buf) - 1] == '\n')) buf[strlen(buf) - 1] = 0; if (strlen(buf) > 0) { num++; int ret = idb_query(buf); desc_printf(gIO, gFd, "Query '%s' returned with code %d\n", buf, ret); } } desc_printf(gIO, gFd, "%d queries processed\n", num); fclose(fp); } else desc_printf(gIO, gFd, "Error: Cannot open file %s for reading\n", args); } else desc_printf(gIO, gFd, "Error: Cannot access file %s\n", t.tokens[1]); } else if ((filename != NULL) && (query != NULL)) { char tmp[4096] = { 0 }; snprintf(tmp, sizeof(tmp), "INIT %s", filename); ret = 0; if (idb_query(tmp) != 0) { DPRINTF("Error while trying to initialize file '%s'\n", filename); ret = -EIO; } if (idb_query(query) != 0) { DPRINTF("Error while running query '%s'\n", query); ret = -EIO; } else if ((strncmp(query, "SELECT", 6) == 0) || (strcmp(query, "SHOW TABLES") == 0)) idb_results_show( gIO, gFd, idb_get_last_select_data() ); idb_query("COMMIT"); idb_query("CLOSE"); } } else { ret = -EINVAL; goto cleanup; } cleanup: if (_perf_measure) { tse = utils_get_time( TIME_CURRENT ); desc_printf(gIO, gFd, "\nPERF: Function %s() was running for %.3f microseconds (%.3f ms)\n", fn, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.); } return ret; }
int script_process_line(char *buf) { int ret = -ENOTSUP; struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 }; struct timespec tse; if (_perf_measure) ts = utils_get_time( TIME_CURRENT ); /* Skip if it's a one line comment (more to be implemented) */ if (is_comment(buf) == 1) { DPRINTF("%s: Found comment, skipping\n", __FUNCTION__); ret = 0; goto cleanup; } else if (strcmp(buf, "else {") == 0) { /* Reverse the condition */ if ((_script_in_condition_and_met == 1) || (_script_in_condition_and_met == -10)) _script_in_condition_and_met = 0; else if ((_script_in_condition_and_met == 0) || (_script_in_condition_and_met == -20)) _script_in_condition_and_met = 1; else if (_script_in_condition_and_met != -1) { DPRINTF("%s: Invalid state for else statement\n", __FUNCTION__); ret = -EINVAL; goto cleanup; } ret = 0; goto cleanup; } else if (strcmp(buf, "}") == 0) { _script_in_condition_and_met = (_script_in_condition_and_met == 1) ? -10 : -20; ret = 0; goto cleanup; } if (_script_in_condition_and_met < -1) _script_in_condition_and_met = 1; if (_script_in_condition_and_met == 0) { ret = 0; goto cleanup; } /* Comparison with no ternary operator support... yet */ if (regex_match("if \\(([^(]*)([^)]*)\\)", buf)) { if (regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf)) { char **matches = NULL; int i, num_matches; matches = (char **)utils_alloc( "scripting.script_process_line.matches", sizeof(char *) ); _regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf, matches, &num_matches); if (num_matches >= 2) _script_in_condition_and_met = (valcmp(matches[0], matches[1]) == 0) ? 1 : 0; for (i = 0; i < num_matches; i++) matches[i] = utils_free("scripting.condition.matches[]", matches[i]); matches = utils_free("scripting.condition.matches", matches); } } else /* Definition */ if (strncmp(buf, "define ", 7) == 0) { tTokenizer t; t = tokenize(buf + 7, " "); if (t.numTokens != 2) { ret = -EINVAL; goto cleanup; } if (variable_create(trim(t.tokens[0]), trim(t.tokens[1])) != 1) { ret = -EIO; goto cleanup; } } else /* Operators */ if ((strstr(buf, "+=") != NULL) || (strstr(buf, "-=") != NULL) || (strstr(buf, "%=") != NULL) || (strstr(buf, "*=") != NULL) || (strstr(buf, "/=") != NULL)) { tTokenizer t; char *var; char *val; int op, vtype; t = tokenize(buf, "="); if (t.numTokens != 2) { ret = -EINVAL; goto cleanup; } var = trim(strdup(t.tokens[0])); val = trim(strdup(t.tokens[1])); op = var[ strlen(var) - 1]; var[ strlen(var) - 1] = 0; var = trim(var); if (val[strlen(val) - 1] == ';') val[strlen(val) - 1] = 0; val = trim(val); vtype = variable_get_type(var, NULL); if ((vtype == TYPE_INT) || (vtype == TYPE_LONG)) { char tmp[32] = { 0 }; long value = atol(variable_get_element_as_string(var, NULL)); if (op == '+') value += atol(val); else if (op == '-') value -= atol(val); else if (op == '*') value *= atol(val); else if (op == '%') value %= atol(val); else if (op == '/') value /= atol(val); snprintf(tmp, sizeof(tmp), "%ld", value); variable_set_deleted(var, 1); variable_add(var, tmp, TYPE_QSCRIPT, -1, vtype); ret = 0; } else ret = -EINVAL; var = utils_free("scripting.operators.var", var); val = utils_free("scripting.operators.val", val); free_tokens(t); return ret; } else /* Assignment */ if (is_assignment(buf)) { tTokenizer t; t = tokenize(buf, "="); char *val = strdup( trim(t.tokens[1]) ); if (val[strlen(val) - 1] == ';') { val[strlen(val) - 1] = 0; if (is_numeric(val) || is_string(val)) { if (is_string(val)) { *val++; val[strlen(val) - 1] = 0; } if (variable_add(trim(t.tokens[0]), val, TYPE_QSCRIPT, -1, gettype(val)) < 0) { desc_printf(gIO, gFd, "Cannot set new value to variable %s\n", trim(t.tokens[0])); ret = -EEXIST; } else ret = 0; } else if (regex_match("([^(]*)([^)]*)", val)) { tTokenizer t2; char *args = NULL; char *fn; t2 = tokenize(val, "("); if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ')') { ret = -EINVAL; goto cleanup; } t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0; fn = strdup(t2.tokens[0]); /* We need to make sure parenthesis won't break script line */ if (t2.numTokens > 1) { int i; char argstmp[8192] = { 0 }; for (i = 1; i < t2.numTokens; i++) { strcat(argstmp, t2.tokens[i]); if (i < t2.numTokens - 1) strcat(argstmp, "("); } args = strdup(argstmp); } if (args != NULL) { char args2[1024] = { 0 }; snprintf(args2, sizeof(args2), "%s", args + 1); args2[ strlen(args2) - 1] = 0; args = utils_free("scripting.function-call.args", args); args = strdup( args2 ); } free_tokens(t2); if (_script_builtin_function(trim(t.tokens[0]), fn, args) != 0) DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn); DPRINTF("%s: Should be a function with return value\n", __FUNCTION__); args = utils_free("scripting.function-call.args", args); fn = utils_free("scripting.function-call.fn", fn); ret = 0; } else ret = -EINVAL; } free_tokens(t); } else if (regex_match("([^(]*)([^)]*)", buf)) { tTokenizer t2; char *args = NULL; char *fn; t2 = tokenize(buf, "("); if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ';') { ret = -EINVAL; goto cleanup; } t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0; fn = strdup(t2.tokens[0]); /* We need to make sure parenthesis won't break script line */ if (t2.numTokens > 1) { int i; char argstmp[8192] = { 0 }; for (i = 1; i < t2.numTokens; i++) { strcat(argstmp, t2.tokens[i]); if (i < t2.numTokens - 1) strcat(argstmp, "("); } args = strdup(argstmp); } if (args != NULL) { if (args[strlen(args) - 1] == ')') args[strlen(args) - 1] = 0; } free_tokens(t2); if (_script_builtin_function(NULL, fn, args) != 0) DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn); args = utils_free("scripting.function-call.args", args); fn = utils_free("scripting.function-call.fn", fn); ret = 0; } else DPRINTF("%s: Not implemented yet\n", __FUNCTION__); cleanup: if ((_perf_measure) && ((ts.tv_nsec > 0) && (ts.tv_sec > 0)) && (_script_in_condition_and_met > 0)) { tse = utils_get_time( TIME_CURRENT ); desc_printf(gIO, gFd, "PERF: Line \"%s\" was being processed for %.3f microseconds (%.3f ms)\n\n", buf, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.); } return ret; } int run_script(char *filename) { FILE *fp; int opened = 0; char buf[4096] = { 0 }; struct timespec ts = utils_get_time( TIME_CURRENT ); struct timespec tse; if (access(filename, R_OK) != 0) return -ENOENT; _script_in_condition_and_met = -1; fp = fopen(filename, "r"); if (fp == NULL) return -EPERM; if (gHttpHandler) http_host_header(gIO, gFd, HTTP_CODE_OK, gHost, "text/html", NULL, myRealm, 0); while (!feof(fp)) { memset(buf, 0, sizeof(buf)); fgets(buf, sizeof(buf), fp); if ((strlen(buf) > 1) && (buf[strlen(buf) - 1] == '\n')) buf[strlen(buf) - 1] = 0; if ((strlen(buf) > 1) && (buf[0] != '\n')) { if (strcmp(buf, "<$") == 0) opened = 1; if (strcmp(buf, "$>") == 0) opened = 0; if ((opened) && (strcmp(buf, "<$") != 0)) script_process_line(trim(buf)); } } fclose(fp); idb_free_last_select_data(); if (_perf_measure) { tse = utils_get_time( TIME_CURRENT ); desc_printf(gIO, gFd, "PERF: File \"%s\" has been processed in %.3f microseconds (%.3f ms)\n\n", basename(filename), get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.); } variable_dump(); variable_free_all(); return 0; }