/** NOTE: both IP address and port are in host byte order */
STATIC File * SocketOpen2(IPaddr addr, Port port)
{
Socket sock = INVALID_SOCKET;
if (SOCKET_GetTcp(0,&sock)) {
if (SOCKET_Connect(sock, addr, port)) {
SocketFile * s = MEM_New(SocketFile);
if (s) {
Bool ok;
StrBuf32 nameBuf;
STRBUF_InitBufXXX(&nameBuf);
STRBUF_Format(&nameBuf.sb, TEXT(IPADDR_FORMAT)TEXT_(":%hu"),
HOST_IPADDR_FORMAT_ARG(addr),port);
memset(s, 0, sizeof(*s));
ok = FILE_Init(&s->file, nameBuf.sb.s, False, &SocketIO);
STRBUF_Destroy(&nameBuf.sb);
if (ok) {
s->sock = sock;
s->eof = False;
return &s->file;
}
}
shutdown(sock, SHUT_RDWR);
}
closesocket(sock);
}
return NULL;
}
/**
* Calls a callback on each entry in the directory.
* Returns number of directory entries read, 0 if directory
* was empty, -1 if error occurs of callback function returns False.
* The current and parent directories ("." and "..") are not included
* in the count, and callback is not invoked on those directory entries
* because these are always valid file names in any directory.
*/
int FILE_List(Str dir, FileListCB cb, void * ctx)
{
int n = -1;
StrBuf64 pattern;
STRBUF_InitBufXXX(&pattern);
if (!dir || !dir[0]) dir = TEXT(".");
if (STRBUF_Copy(&pattern.sb, dir) &&
STRBUF_Append(&pattern.sb, TEXT("\\*.*"))) {
WIN32_FIND_DATA data;
HANDLE hfind = FindFirstFile(pattern.sb.s, &data);
if (hfind != INVALID_HANDLE_VALUE) {
Str fname = data.cFileName;
n = 0;
do {
if (StrCmp(fname, TEXT(".")) &&
StrCmp(fname, TEXT(".."))) {
if (cb && !(*cb)(dir, fname, ctx)) {
n = -1;
break;
}
n++;
}
} while (FindNextFile(hfind, &data));
FindClose(hfind);
}
}
STRBUF_Destroy(&pattern.sb);
return n;
}
/**
* 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);
}
/**
* Creates a directory hierarhy.
*/
Bool FILE_MkDir(Str dir)
{
Bool ok = False;
StrBuf64 entry;
StrBuf* sb = &entry.sb;
STRBUF_InitBufXXX(&entry);
if (STRBUF_Copy(sb, dir)) {
while (sb->len > 0 && FILE_IsFileSeparator(STRBUF_LastChar(sb))) {
STRBUF_SetLength(sb, sb->len-1);
}
/* check if the directory already exists */
if (FILE_IsDir(STRBUF_Text(sb)) ||
FILE_CreateDir(STRBUF_Text(sb))) {
ok = True;
} else {
/* directory does not exists, walk the hierarhy */
int pos = 0;
int next = 0;
while ((next = FILE_FindSeparator(dir+pos)) >= 0) {
STRBUF_Clear(sb);
if (next == 0) {
pos++;
continue;
} else {
if (!STRBUF_CopyN(sb,dir,pos+next) ||
!FILE_CreateDir(STRBUF_Text(sb))) {
break;
}
pos += next + 1;
}
}
/* final test */
if (STRBUF_Copy(sb, dir)) {
while (sb->len && FILE_IsFileSeparator(STRBUF_LastChar(sb))) {
STRBUF_SetLength(sb, sb->len-1);
}
if (FILE_IsDir(STRBUF_Text(sb)) ||
FILE_CreateDir(STRBUF_Text(sb))) {
ok = True;
}
}
}
}
STRBUF_Destroy(sb);
return ok;
}
/**
* 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;
}
/**
* This routine runs EXPAT parser
*/
Bool XML_ParseStream(File * f, const XMLCallbacks * cb, void * ctx)
{
XML_Parser parser;
Bool ok = False;
/* set up memory management functions */
XML_Memory_Handling_Suite mem;
memset(&mem, 0, sizeof(mem));
mem.malloc_fcn = MEM_Alloc;
mem.realloc_fcn = MEM_Realloc;
mem.free_fcn = MEM_Free;
/* create parser */
parser = XML_ParserCreate_MM(NULL,&mem,NULL);
if (parser) {
int bufsize = 4096;
void * buf = NULL;
Bool done = False;
/* initialize EXPAT */
ExpatContext expat;
expat.ctx = ctx;
expat.cb = (*cb);
STRBUF_Init(&expat.sb);
BUFFER_Init(&expat.buf);
VECTOR_Init(&expat.atts, 0, NULL, NULL);
/* initialize the parser */
XML_SetElementHandler(parser, EXPAT_StartElement, EXPAT_EndElement);
XML_SetCharacterDataHandler(parser, EXPAT_Characters);
XML_SetUserData(parser, &expat);
/*
* By obtaining the buffer from Expat with the XML_GetBuffer,
* we can avoid double copying of the input.
*/
ok = True;
while (ok && !done && (buf = XML_GetBuffer(parser,bufsize)) != NULL) {
int len = -1;
if (!FILE_Eof(f)) {
len = FILE_Read(f, buf, bufsize);
}
if (len <= 0) {
done = True;
len = 0;
}
ok = XML_ParseBuffer(parser, len, done);
}
#if DEBUG
if (!ok) {
enum XML_Error code = XML_GetErrorCode(parser);
int l = XML_GetCurrentLineNumber(parser);
int c = XML_GetCurrentColumnNumber(parser);
Str fname = FILE_Name(f);
const char * msg = XML_ErrorString(code);
if (!fname) fname = TEXT("<noname>");
if (!msg) msg = "<no message>";
# ifdef _WIN32
TRACE4("EXPAT: %s: line %d, column %d: %hs\n",fname,l,c,msg);
# else /* _WIN32 */
TRACE4("EXPAT: %s: line %d, column %d: %s\n",fname,l,c,msg);
# endif /* _WIN32 */
}
#endif /* DEBUG */
if (!buf) ok = False;
/* deallocate parser */
XML_ParserFree(parser);
STRBUF_Destroy(&expat.sb);
BUFFER_Destroy(&expat.buf);
VECTOR_Destroy(&expat.atts);
}
return (ok);
}
/**
* 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;
}
void DIR_ItrDestroy(DirIterator * di)
{
STRBUF_Destroy(&di->dirName);
STRBUF_Destroy(&di->fileName);
}
