/** * Parses Java version string. Also returns the number of digits in the * version string that have been successfully parsed. All non-parsed digits * are filled with zeros. The ndigits pointer may be NULL. */ Bool JVM_ParseVersion2(Str strVersion, JavaVersion * version, int* ndigits) { int i; Str p = strVersion; StrBuf16 buf; STRBUF_InitBufXXX(&buf); memset(version, 0, sizeof(*version)); for (i=0; i<JAVA_VERSION_SIZE; i++) { STRBUF_Clear(&buf.sb); while (*p && !IsDigit(*p)) p++; if (*p) { while (IsDigit(*p)) STRBUF_AppendChar(&buf.sb, *p++); if (STRBUF_Length(&buf.sb) > 0) { if (PARSE_Int(STRBUF_Text(&buf.sb),&(version->v[i]),10)) { continue; } } } break; } if (ndigits) *ndigits = i; STRBUF_Destroy(&buf.sb); return (i >= 2); }
Bool DIR_ItrRemove(Iterator * itr) { Bool ok = False; DirIterator * di = CAST(itr,DirIterator,itr); DirType type = di->entry.type; size_t dirlen = STRBUF_Length(&di->dirName); if (STRBUF_Alloc(&di->dirName, dirlen+STRBUF_Length(&di->fileName)+1)) { Str fullName; Bool isDir; STRBUF_AppendChar(&di->dirName, FILE_SEPARATOR_CHAR); STRBUF_AppendBuf(&di->dirName, &di->fileName); fullName = STRBUF_Text(&di->dirName); if (type == DTypeUnknown) { isDir = FILE_IsDir(fullName); } else { isDir = BoolValue(type == DTypeDir); } if (isDir) { ok = FILE_RmDir(fullName, True); } else { ok = FILE_Delete(fullName); } STRBUF_SetLength(&di->dirName, dirlen); di->entry.dir = STRBUF_Text(&di->dirName); } return ok; }
STATIC void EXPAT_ConvertTag(StrBuf * sb, XML_Str tag) { XML_Str ptr; STRBUF_Clear(sb); for (ptr = tag; *ptr; ptr++) { STRBUF_AppendChar(sb, (Char)*ptr); } }
/** * FILE_RmDir callback. Recursively destroys the directory contents */ STATIC Bool RmDirCB(Str dir, Str fname, void * ctx) { Bool ok = False; StrBuf64 path; UNREF(ctx); STRBUF_InitBufXXX(&path); if (STRBUF_Copy(&path.sb, dir) && STRBUF_AppendChar(&path.sb, FILE_SEPARATOR_CHAR) && STRBUF_Append(&path.sb, fname)) { ok = True; if (FILE_IsDir(path.sb.s)) { FILE_RmDir(path.sb.s, True); } else { FILE_Delete(path.sb.s); } } STRBUF_Destroy(&path.sb); return ok; }
/** * The same as BASE64_Encode but stores encoded data into a string buffer. * Does not destroy the original contents of the string buffer. The * Base64 string is appended to it. Returns pointer to string buffer * data, NULL on memory allocation failure */ Str BASE64_EncodeStr(const void * data, size_t size, StrBuf * sb, int flags) { const char* encodeMap = ((flags & BASE64_URLSAFE) ? base64_safeEncodeMap : base64_encodeMap); size_t alloc = ((size+2)/3)*4; if (STRBUF_Alloc(sb, STRBUF_Length(sb)+alloc)) { const char * buf = (const char *)data; size_t off; /* encode the bulk of the data */ for (off=0; (off+3)<=size; off+=3) { STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_3(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_4(buf,off)]); } /* manage last one or two bytes */ switch (size%3) { case 0: break; case 1: STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2_1(buf,off)]); if (flags & BASE64_PAD) { STRBUF_AppendChar(sb,'='); STRBUF_AppendChar(sb,'='); } break; case 2: STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_3_1(buf,off)]); if (flags & BASE64_PAD) STRBUF_AppendChar(sb,'='); break; } return STRBUF_Text(sb); } /* could not allocate memory */ return NULL; }
/** * Discovers all available JVMs. If no JVMs are discovered, returns NULL. * In addition to the standard directories, also looks in the additional * directories specified by the dirs array. Note that this directory list * replaces the default list ("jre","../jre") used by JVM_Find, it does not * adds new directories to the list. */ JVMSet * JVM_Find2(const Str dirs[], int n) { JVMSet * jvms = MEM_New(JVMSet); if (jvms) { memset(jvms, 0, sizeof(*jvms)); if (VECTOR_Init(&jvms->found, 0, JVM_VectorEquals, JVM_VectorFree)) { /* Look for JVMs in the Windows registry */ JVM_Discover(jvms); /* Look for JVMs in the additional directories */ if (n > 0) { int i; StrBuf sb,sb2; Char* baseDir = NULL; STRBUF_Init(&sb); STRBUF_Init(&sb2); TRACE("JNILIB: checking special directories\n"); for (i=0; i<n; i++) { Str javaHome = NULL; JvmPathType pathType = JVM_GetPathType(dirs[i]); if (pathType == JvmPathRelative) { LPTSTR filePath; TRACE1("JNILIB: relative path: %s\n",dirs[i]); if (baseDir) { STRBUF_Copy(&sb, baseDir); } else { int separator; JVM_GetModuleFileName(NULL,&sb); STRBUF_Replace(&sb, '/', '\\'); separator = STRBUF_LastIndexOf(&sb,'\\'); STRBUF_SetLength(&sb,separator+1); baseDir = STRBUF_Dup(&sb); if (!baseDir) continue; TRACE1("JNILIB: base dir: %s\n",baseDir); } STRBUF_Append(&sb, dirs[i]); STRBUF_Replace(&sb, '/', '\\'); STRBUF_Alloc(&sb2, STRBUF_Length(&sb)); sb2.len = GetFullPathName(STRBUF_Text(&sb), sb2.alloc, sb2.s, &filePath); ASSERT(sb2.len && sb2.s[0]); javaHome = STRBUF_Text(&sb2); } else if (pathType == JvmPathAbsolute) { TRACE1("JNILIB: absolute path: %s\n",dirs[i]); javaHome = dirs[i]; } else if (pathType == JvmPathSystem) { /* directory on the system drive */ TRACE1("JNILIB: system path: %s\n",dirs[i]); STRBUF_Alloc(&sb,GetSystemDirectory(NULL,0)+1); STRBUF_SetLength(&sb,GetSystemDirectory(sb.s,sb.alloc)); STRBUF_Clear(&sb2); STRBUF_AppendChar(&sb2,STRBUF_CharAt(&sb,0)); STRBUF_AppendChar(&sb2,':'); STRBUF_Append(&sb2, dirs[i]); javaHome = STRBUF_Text(&sb2); } else { TRACE1("JNILIB: invalid path: %s\n",dirs[i]); continue; } if (javaHome) { TRACE1("JNILIB: Java home: %s\n",javaHome); if (FILE_IsDir(javaHome)) { JVM* jvm = JVM_CreateDirContext(javaHome); if (jvm) { jvm->flags |= JVM_FLAG_SPECIAL; if (JVM_Add(jvms, jvm) && !jvms->specialVM) { jvms->specialVM = jvm; } } } else { TRACE1("JNILIB: no such directory: %s\n",javaHome); } } } MEM_Free(baseDir); STRBUF_Destroy(&sb); STRBUF_Destroy(&sb2); } /* Did we find anything? */ if (!VECTOR_IsEmpty(&jvms->found)) { JVM_Sort(jvms, JVM_DefaultSort); TRACE1("JNILIB: found %d JVM(s)\n",VECTOR_Size(&jvms->found)); return jvms; } TRACE("JNILIB: found no JVMs\n, sorry"); VECTOR_Destroy(&jvms->found); } MEM_Free(jvms); } return NULL; }
/** * The same as BASE32_Encode but stores encoded data into a string buffer. * Does not destroy the original contents of the string buffer. The * Base32 string is appended to it. Returns pointer to string buffer * data, NULL on memory allocation failure */ Str BASE32_EncodeStr(const void * data, int n, StrBuf * sb, int flags) { const char* encodeMap = ((flags & BASE32_LOWERCASE) ? base32_lowerCaseEncodeMap : base32_upperCaseEncodeMap); int alloc = (n/ENCODE_CHUNK_SIZE+((n%ENCODE_CHUNK_SIZE)?1:0))* DECODE_CHUNK_SIZE+1; /* * +--- octet 0 ---+--- octet 1 ---+--- octet 2 ---+ * |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| * +---------+-----+---+---------+-+-------+-------+ * |4 3 2 1 0|4 3 2 1 0|4 3 2 1 0|4 3 2 1 0|4 3 2 1 * +-0.index-+-1.index-+-2.index-+-3.index-+-4.index * * +--- octet 3 ---+--- octet 4 ---+ * |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| * +-+---------+---+-----+---------+ * 0|4 3 2 1 0|4 3 2 1 0|4 3 2 1 0| * --+-5.index-+-6.index-+-7.index-+ */ if (STRBUF_Alloc(sb, STRBUF_Length(sb)+alloc)) { const char * buf = (const char *)data; int off; /* encode the bulk of the data */ for (off=0; (off+ENCODE_CHUNK_SIZE)<=n; off+=ENCODE_CHUNK_SIZE) { STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_6(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_7(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_8(buf,off)]); } /* manage the last few bytes */ switch (n % ENCODE_CHUNK_SIZE) { case 0: break; case 1: STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2_1(buf,off)]); break; case 2: STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4_1(buf,off)]); break; case 3: STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5_1(buf,off)]); break; case 4: STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_6(buf,off)]); STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_7_1(buf,off)]); break; } /* append padding characters */ if (flags & BASE32_PAD) { STRBUF_Append(sb, base32_pad[n % ENCODE_CHUNK_SIZE]); } return STRBUF_Text(sb); } /* could not allocate memory */ return NULL; }