inline void savestatus() { xmlNodePtr root = NULL; xmlNodePtr node = NULL; xmlChar* tmp = NULL; if ((strlen(statname) > 0) && (status != NULL)) { root = xmlDocGetRootElement(status); if (root) { xmlMutexLock(finishedMutex); for (node = root->children; node; node = node->next) { if (xmlStrcmp(node->name, "current") == 0) { xmlMutexLock(pwdMutex); tmp = xmlEncodeEntitiesReentrant(status, (const xmlChar*) &password); xmlMutexUnlock(pwdMutex); if (node->children) { if (password[0] == '\0') xmlNodeSetContent(node->children, getfirstpassword()); else xmlNodeSetContent(node->children, tmp); } xmlFree(tmp); } else if ((finished == 1) && (xmlStrcmp(node->name,"good_password") == 0)) { tmp = xmlEncodeEntitiesReentrant(status, (const xmlChar*) &password_good); if (node->children) xmlNodeSetContent(node->children, tmp); xmlFree(tmp); } } xmlMutexUnlock(finishedMutex); } xmlSaveFormatFileEnc(statname, status, "UTF-8", 1); } return; }
void * crack_thread() { char * current; char ret[200]; char cmd[400]; FILE * Pipe; while (1) { current = nextpass(); sprintf((char*)&cmd, finalcmd, current, filename); Pipe = popen(cmd, "r"); while (!feof(Pipe)) { fgets((char*)&ret, 200, Pipe); if (strcasestr(ret, "ok") != NULL) { strcpy(password_good, current); xmlMutexLock(finishedMutex); finished = 1; printf("GOOD: password cracked: '%s'\n", current); xmlMutexUnlock(finishedMutex); savestatus(); break; } } pclose(Pipe); xmlMutexLock(finishedMutex); counter++; if (finished != 0) { xmlMutexUnlock(finishedMutex); break; } xmlMutexUnlock(finishedMutex); free(current); } }
void xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) { xmlMutexLock(xmlThrDefMutex); xmlGenericErrorContextThrDef = ctx; xmlStructuredErrorThrDef = handler; xmlMutexUnlock(xmlThrDefMutex); }
int xmlThrDefDoValidityCheckingDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlDoValidityCheckingDefaultValueThrDef; xmlDoValidityCheckingDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefLoadExtDtdDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlLoadExtDtdDefaultValueThrDef; xmlLoadExtDtdDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefDefaultBufferSize(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlDefaultBufferSizeThrDef; xmlDefaultBufferSizeThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) { xmlBufferAllocationScheme ret; xmlMutexLock(xmlThrDefMutex); ret = xmlBufferAllocSchemeThrDef; xmlBufferAllocSchemeThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefGetWarningsDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlGetWarningsDefaultValueThrDef; xmlGetWarningsDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefSubstituteEntitiesDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlSubstituteEntitiesDefaultValueThrDef; xmlSubstituteEntitiesDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
const char * xmlThrDefTreeIndentString(const char * v) { const char * ret; xmlMutexLock(xmlThrDefMutex); ret = xmlTreeIndentStringThrDef; xmlTreeIndentStringThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
void * status_thread() { int pwds; const short status_sleep = 3; while(1) { sleep(status_sleep); xmlMutexLock(finishedMutex); pwds = counter / status_sleep; counter = 0; if (finished != 0) break; xmlMutexUnlock(finishedMutex); xmlMutexLock(pwdMutex); printf("Probing: '%s' [%d pwds/sec]\n", password, pwds); xmlMutexUnlock(pwdMutex); savestatus(); //FIXME: this is wrong, when probing current password(s) is(are) not finished yet, and the program is exiting } }
inline char* nextpass() { //IMPORTANT: the returned string must be freed char *ok = malloc(sizeof(char)*(PWD_LEN+1)); xmlMutexLock(pwdMutex); strcpy(ok, password); nextpass2((char*) &password, curr_len - 1); xmlMutexUnlock(pwdMutex); return ok; }
int xmlThrDefKeepBlanksDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlKeepBlanksDefaultValueThrDef; xmlKeepBlanksDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefLineNumbersDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlLineNumbersDefaultValueThrDef; xmlLineNumbersDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefPedanticParserDefaultValue(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlPedanticParserDefaultValueThrDef; xmlPedanticParserDefaultValueThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefIndentTreeOutput(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlIndentTreeOutputThrDef; xmlIndentTreeOutputThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefSaveNoEmptyTags(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlSaveNoEmptyTagsThrDef; xmlSaveNoEmptyTagsThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
int xmlThrDefParserDebugEntities(int v) { int ret; xmlMutexLock(xmlThrDefMutex); ret = xmlParserDebugEntitiesThrDef; xmlParserDebugEntitiesThrDef = v; xmlMutexUnlock(xmlThrDefMutex); return ret; }
void * xmlMallocAtomicLoc(size_t size, const char * file, int line) { MEMHDR *p; void *ret; if (!xmlMemInitialized) xmlInitMemory(); #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, "Malloc(%d)\n",size); #endif TEST_POINT p = (MEMHDR *) malloc(RESERVE_SIZE+size); if (!p) { xmlGenericError(xmlGenericErrorContext, "xmlMallocLoc : Out of free space\n"); xmlMemoryDump(); return(NULL); } p->mh_tag = MEMTAG; p->mh_size = size; p->mh_type = MALLOC_ATOMIC_TYPE; p->mh_file = file; p->mh_line = line; xmlMutexLock(xmlMemMutex); p->mh_number = ++block; debugMemSize += size; debugMemBlocks++; if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize; #ifdef MEM_LIST debugmem_list_add(p); #endif xmlMutexUnlock(xmlMemMutex); #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, "Malloc(%d) Ok\n",size); #endif if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint(); ret = HDR_2_CLIENT(p); if (xmlMemTraceBlockAt == ret) { xmlGenericError(xmlGenericErrorContext, "%p : Malloc(%ld) Ok\n", xmlMemTraceBlockAt, (long)size); xmlMallocBreakpoint(); } TEST_POINT return(ret); }
int xmlMemBlocks(void) { int res; xmlMutexLock(xmlMemMutex); res = debugMemBlocks; xmlMutexUnlock(xmlMemMutex); return(res); }
int xmlMemUsed(void) { int res; xmlMutexLock(xmlMemMutex); res = debugMemSize; xmlMutexUnlock(xmlMemMutex); return(res); }
bool House::save() { xmlDocPtr doc; xmlNodePtr root, tmp; xmlMutexLock(xmlmutex); doc = xmlNewDoc((const xmlChar*)"1.0"); doc->children = xmlNewDocNode(doc, NULL, (const xmlChar*)"house", NULL); root = doc->children; std::stringstream sb; tmp = xmlNewNode(NULL, (const xmlChar*)"frontdoor"); sb << frontDoor.x; xmlSetProp(tmp, (const xmlChar*) "x", (const xmlChar*)sb.str().c_str()); sb.str(""); sb << frontDoor.y; xmlSetProp(tmp, (const xmlChar*) "y", (const xmlChar*)sb.str().c_str()); sb.str(""); sb << frontDoor.z; xmlSetProp(tmp, (const xmlChar*) "z", (const xmlChar*)sb.str().c_str()); sb.str(""); xmlAddChild(root, tmp); tmp = xmlNewNode(NULL, (const xmlChar*)"owner"); xmlSetProp(tmp, (const xmlChar*)"name", (const xmlChar*)owner.c_str()); xmlAddChild(root, tmp); for (size_t i = 0; i < subOwners.size(); i++) { tmp = xmlNewNode(NULL, (const xmlChar*)"subowner"); xmlSetProp(tmp, (const xmlChar*)"name", (const xmlChar*)subOwners[i].c_str()); xmlAddChild(root, tmp); } for (size_t i = 0; i < guests.size(); i++) { tmp = xmlNewNode(NULL, (const xmlChar*)"guest"); xmlSetProp(tmp, (const xmlChar*)"name", (const xmlChar*)guests[i].c_str()); xmlAddChild(root, tmp); } DoorOwnersMap::const_iterator iter = doorOwners.begin(); while (iter != doorOwners.end()) { Position pos = iter->first; for (size_t i = 0; i < iter->second.size(); i++) { tmp = xmlNewNode(NULL, (const xmlChar*)"doorowner"); // TODO: optimize sb << pos.x; xmlSetProp(tmp, (const xmlChar*) "x", (const xmlChar*)sb.str().c_str()); sb.str(""); sb << pos.y; xmlSetProp(tmp, (const xmlChar*) "y", (const xmlChar*)sb.str().c_str()); sb.str(""); sb << pos.z; xmlSetProp(tmp, (const xmlChar*) "z", (const xmlChar*)sb.str().c_str()); sb.str(""); xmlSetProp(tmp, (const xmlChar*)"name", (const xmlChar*)iter->second[i].c_str()); xmlAddChild(root, tmp); } ++iter; } xmlSaveFile(file.c_str(), doc); xmlFreeDoc(doc); xmlMutexUnlock(xmlmutex); return true; }
void xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) { xmlMutexLock(xmlThrDefMutex); xmlGenericErrorContextThrDef = ctx; if (handler != NULL) xmlGenericErrorThrDef = handler; else xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc; xmlMutexUnlock(xmlThrDefMutex); }
void xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED) { #ifdef MEM_LIST MEMHDR *p; #endif if (fp != NULL) fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n", debugMemSize, debugMaxMemSize); #ifdef MEM_LIST xmlMutexLock(xmlMemMutex); if (nr > 0) { fprintf(fp,"NUMBER SIZE TYPE WHERE\n"); p = memlist; while ((p) && nr > 0) { fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size); switch (p->mh_type) { case STRDUP_TYPE: fprintf(fp,"strdup() in "); break; case MALLOC_TYPE: fprintf(fp,"malloc() in "); break; case MALLOC_ATOMIC_TYPE: fprintf(fp,"atomicmalloc() in "); break; case REALLOC_TYPE: fprintf(fp,"realloc() in "); break; case REALLOC_ATOMIC_TYPE: fprintf(fp,"atomicrealloc() in "); break; default: fprintf(fp," ??? in "); break; } if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line); if (p->mh_tag != MEMTAG) fprintf(fp," INVALID"); xmlMemContentShow(fp, p); fprintf(fp,"\n"); nr--; p = p->mh_next; } } xmlMutexUnlock(xmlMemMutex); #endif /* MEM_LIST */ }
char * xmlMemStrdupLoc(const char *str, const char *file, int line) { char *s; size_t size = strlen(str) + 1; MEMHDR *p; if (!xmlMemInitialized) xmlInitMemory(); TEST_POINT p = (MEMHDR *) malloc(RESERVE_SIZE+size); if (!p) { goto error; } p->mh_tag = MEMTAG; p->mh_size = size; p->mh_type = STRDUP_TYPE; p->mh_file = file; p->mh_line = line; xmlMutexLock(xmlMemMutex); p->mh_number = ++block; debugMemSize += size; debugMemBlocks++; if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize; #ifdef MEM_LIST debugmem_list_add(p); #endif xmlMutexUnlock(xmlMemMutex); s = (char *) HDR_2_CLIENT(p); if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint(); if (s != NULL) strcpy(s,str); else goto error; TEST_POINT if (xmlMemTraceBlockAt == s) { xmlGenericError(xmlGenericErrorContext, "%p : Strdup() Ok\n", xmlMemTraceBlockAt); xmlMallocBreakpoint(); } return(s); error: return(NULL); }
xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func) { xmlDeregisterNodeFunc old; xmlMutexLock(xmlThrDefMutex); old = xmlDeregisterNodeDefaultValueThrDef; __xmlRegisterCallbacks = 1; xmlDeregisterNodeDefaultValueThrDef = func; xmlMutexUnlock(xmlThrDefMutex); return(old); }
xmlParserInputBufferCreateFilenameFunc xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func) { xmlParserInputBufferCreateFilenameFunc old; xmlMutexLock(xmlThrDefMutex); old = xmlParserInputBufferCreateFilenameValueThrDef; if (old == NULL) { old = __xmlParserInputBufferCreateFilename; } xmlParserInputBufferCreateFilenameValueThrDef = func; xmlMutexUnlock(xmlThrDefMutex); return(old); }
xmlOutputBufferCreateFilenameFunc xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func) { xmlOutputBufferCreateFilenameFunc old; xmlMutexLock(xmlThrDefMutex); old = xmlOutputBufferCreateFilenameValueThrDef; #ifdef LIBXML_OUTPUT_ENABLED if (old == NULL) { old = __xmlOutputBufferCreateFilename; } #endif xmlOutputBufferCreateFilenameValueThrDef = func; xmlMutexUnlock(xmlThrDefMutex); return(old); }
void xmlMemDisplay(FILE *fp) { #ifdef MEM_LIST MEMHDR *p; unsigned idx; int nb = 0; #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME) time_t currentTime; char buf[500]; struct tm * tstruct; #endif #endif FILE *old_fp = fp; if (fp == NULL) { fp = fopen(".memorylist", "w"); if (fp == NULL) return; } #ifdef MEM_LIST #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME) currentTime = time(NULL); tstruct = localtime(¤tTime); strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct); fprintf(fp," %s\n\n", buf); #endif fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n", debugMemSize, debugMaxMemSize); fprintf(fp,"BLOCK NUMBER SIZE TYPE\n"); idx = 0; xmlMutexLock(xmlMemMutex); p = memlist; while (p) { fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number, (unsigned long)p->mh_size); switch (p->mh_type) { case STRDUP_TYPE:fprintf(fp,"strdup() in ");break; case MALLOC_TYPE:fprintf(fp,"malloc() in ");break; case REALLOC_TYPE:fprintf(fp,"realloc() in ");break; case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc() in ");break; case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break; default: fprintf(fp,"Unknown memory block, may be corrupted"); xmlMutexUnlock(xmlMemMutex); if (old_fp == NULL) fclose(fp); return; } if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line); if (p->mh_tag != MEMTAG) fprintf(fp," INVALID"); nb++; if (nb < 100) xmlMemContentShow(fp, p); else fprintf(fp," skip"); fprintf(fp,"\n"); p = p->mh_next; } xmlMutexUnlock(xmlMemMutex); #else fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n"); #endif if (old_fp == NULL) fclose(fp); }
/** * xmlMemFree: * @ptr: the memory block pointer * * a free() equivalent, with error checking. */ void xmlMemFree(void *ptr) { MEMHDR *p; char *target; #ifdef DEBUG_MEMORY size_t size; #endif if (ptr == (void *) -1) { xmlGenericError(xmlGenericErrorContext, "trying to free pointer from freed area\n"); goto error; } if (xmlMemTraceBlockAt == ptr) { xmlGenericError(xmlGenericErrorContext, "%p : Freed()\n", xmlMemTraceBlockAt); xmlMallocBreakpoint(); } TEST_POINT target = (char *) ptr; p = CLIENT_2_HDR(ptr); if (p->mh_tag != MEMTAG) { Mem_Tag_Err(p); goto error; } if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint(); p->mh_tag = ~MEMTAG; memset(target, -1, p->mh_size); xmlMutexLock(xmlMemMutex); debugMemSize -= p->mh_size; debugMemBlocks--; #ifdef DEBUG_MEMORY size = p->mh_size; #endif #ifdef MEM_LIST debugmem_list_delete(p); #endif xmlMutexUnlock(xmlMemMutex); free(p); TEST_POINT #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, "Freed(%d) Ok\n", size); #endif return; error: xmlGenericError(xmlGenericErrorContext, "xmlMemFree(%lX) error\n", (unsigned long) ptr); xmlMallocBreakpoint(); return; }