void appendLauncher(const BOOL setProcName, char* exePath, const int pathLen, char* cmd) { if (setProcName) { char tmpspec[_MAX_PATH]; char tmpfile[_MAX_PATH]; strcpy(tmpspec, cmd); strcat(tmpspec, LAUNCH4J_TMP_DIR); tmpspec[strlen(tmpspec) - 1] = 0; if (_stat(tmpspec, &statBuf) == 0) { // Remove temp launchers and manifests struct _finddata_t c_file; long hFile; appendPath(tmpspec, "*.exe"); strcpy(tmpfile, cmd); strcat(tmpfile, LAUNCH4J_TMP_DIR); char* filename = tmpfile + strlen(tmpfile); if ((hFile = _findfirst(tmpspec, &c_file)) != -1L) { do { strcpy(filename, c_file.name); debug("Unlink:\t\t%s\n", tmpfile); _unlink(tmpfile); strcat(tmpfile, MANIFEST); debug("Unlink:\t\t%s\n", tmpfile); _unlink(tmpfile); } while (_findnext(hFile, &c_file) == 0); } _findclose(hFile); } else { if (_mkdir(tmpspec) != 0) { debug("Mkdir failed:\t%s\n", tmpspec); appendJavaw(cmd); return; } } char javaw[_MAX_PATH]; strcpy(javaw, cmd); appendJavaw(javaw); strcpy(tmpfile, cmd); strcat(tmpfile, LAUNCH4J_TMP_DIR); char* tmpfilename = tmpfile + strlen(tmpfile); char* exeFilePart = exePath + pathLen + 1; // Copy manifest char manifest[_MAX_PATH] = {0}; strcpy(manifest, exePath); strcat(manifest, MANIFEST); if (_stat(manifest, &statBuf) == 0) { strcat(tmpfile, exeFilePart); strcat(tmpfile, MANIFEST); debug("Copy:\t\t%s -> %s\n", manifest, tmpfile); CopyFile(manifest, tmpfile, FALSE); } // Copy launcher strcpy(tmpfilename, exeFilePart); debug("Copy:\t\t%s -> %s\n", javaw, tmpfile); if (CopyFile(javaw, tmpfile, FALSE)) { strcpy(cmd, tmpfile); return; } else if (_stat(javaw, &statBuf) == 0) { long fs = statBuf.st_size; if (_stat(tmpfile, &statBuf) == 0 && fs == statBuf.st_size) { debug("Reusing:\t\t%s\n", tmpfile); strcpy(cmd, tmpfile); return; } } } appendJavaw(cmd); }
void PathListEditor::slotAdd() { const QString dir = QFileDialog::getExistingDirectory(this, d->fileDialogTitle); if (!dir.isEmpty()) appendPath(QDir::toNativeSeparators(dir)); }
void BlockDataManagerConfig::parseArgs(int argc, char* argv[]) { /*** --testnet: run db against testnet bitcoin network --regtest: run db against regression test network --rescan: delete all processed history data and rescan blockchain from the first block --rebuild: delete all DB data and build and scan from scratch --rescanSSH: delete balance and txcount data and rescan it. Much faster than rescan or rebuild. --datadir: path to the operation folder --dbdir: path to folder containing the database files. If empty, a new db will be created there --satoshi-datadir: path to blockchain data folder (blkXXXXX.dat files) --ram_usage: defines the ram use during scan operations. 1 level averages 128MB of ram (without accounting the base amount, ~400MB). Defaults at 4. Can't be lower than 1. Can be changed in between processes --thread-count: defines how many processing threads can be used during db builds and scans. Defaults to maximum available CPU threads. Can't be lower than 1. Can be changed in between processes --zcthread-count: defines the maximum number on threads the zc parser can create for processing incoming transcations from the network node --db-type: sets the db type: DB_BARE: tracks wallet history only. Smallest DB. DB_FULL: tracks wallet history and resolves all relevant tx hashes. ~750MB DB at the time of 0.95 release. Default DB type. DB_SUPER: tracks all blockchain history. XXL DB (100GB+). Not implemented yet db type cannot be changed in between processes. Once a db has been built with a certain type, it will always function according to that type. Specifying another type will do nothing. Build a new db to change type. --cookie: create a cookie file holding a random authentication key to allow local clients to make use of elevated commands, like shutdown. --fcgi-port: sets the DB listening port. --clear-mempool: delete all zero confirmation transactions from the DB. ***/ try { //parse cli args map<string, string> args; for (int i = 1; i < argc; i++) { //check prefix if (strlen(argv[i]) < 2) throw DbErrorMsg("invalid CLI arg"); string prefix(argv[i], 2); if (prefix != "--") throw DbErrorMsg("invalid CLI arg"); //string prefix and tokenize string line(argv[i] + 2); auto&& argkeyval = getKeyValFromLine(line, '='); args.insert(make_pair( argkeyval.first, stripQuotes(argkeyval.second))); } processArgs(args, true); //figure out datadir auto argIter = args.find("datadir"); if (argIter != args.end()) { dataDir_ = argIter->second; args.erase(argIter); } else { if (!testnet_ && !regtest_) dataDir_ = defaultDataDir_; else if (!regtest_) dataDir_ = defaultTestnetDataDir_; else dataDir_ = defaultRegtestDataDir_; } expandPath(dataDir_); //get datadir auto configPath = dataDir_; appendPath(configPath, "armorydb.conf"); if (DBUtils::fileExists(configPath, 2)) { ConfigFile cf(configPath); auto mapIter = cf.keyvalMap_.find("datadir"); if (mapIter != cf.keyvalMap_.end()) throw DbErrorMsg("datadir is illegal in .conf file"); processArgs(cf.keyvalMap_, false); } processArgs(args, false); //figure out defaults bool autoDbDir = false; if (dbDir_.size() == 0) { dbDir_ = dataDir_; appendPath(dbDir_, dbDirExtention_); autoDbDir = true; } if (blkFileLocation_.size() == 0) { if (!testnet_) blkFileLocation_ = defaultBlkFileLocation_; else blkFileLocation_ = defaultTestnetBlkFileLocation_; } //expand paths if necessary expandPath(dbDir_); expandPath(blkFileLocation_); if (blkFileLocation_.size() < 6 || blkFileLocation_.substr(blkFileLocation_.length() - 6, 6) != "blocks") { appendPath(blkFileLocation_, "blocks"); } logFilePath_ = dataDir_; appendPath(logFilePath_, "dbLog.txt"); //test all paths auto testPath = [](const string& path, int mode) { if (!DBUtils::fileExists(path, mode)) { stringstream ss; ss << path << " is not a valid path"; cout << ss.str() << endl; throw DbErrorMsg(ss.str()); } }; testPath(dataDir_, 6); //create dbdir if was set automatically if (autoDbDir) { try { testPath(dbDir_, 0); } catch (DbErrorMsg&) { #ifdef _WIN32 CreateDirectory(dbDir_.c_str(), NULL); #else mkdir(dbDir_.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); #endif } } //now for the regular test, let it throw if it fails testPath(dbDir_, 6); testPath(blkFileLocation_, 2); //fcgi port if (useCookie_ && !customFcgiPort_) { //no custom fcgi port was provided and the db was spawned with a //cookie file, fcgi port will be randomized srand(time(0)); while (1) { auto port = rand() % 15000 + 49150; stringstream portss; portss << port; if (!testConnection("127.0.0.1", portss.str())) { fcgiPort_ = portss.str(); break; } } } } catch (...) { exceptionPtr_ = current_exception(); } }
String WinFileManager::resourceDirectory() { return appendPath(appDirectory(), "Resources"); }
int main(int argc, char **argv) { if (argc > 1 && !strcmp(argv[1], "--help")) { help(); } if (argc < 4) { usage(); exit(1); } const char *type = argv[1]; const char *dirname = argv[2]; const char *out = argv[3]; uint8_t g_type; if (!strcmp(type, "--grim")) { g_type = GT_GRIM; } else if (!strcmp(type, "--emi")) { g_type = GT_EMI; } else { usage(); exit(1); } DIR *dir = opendir(dirname); if (dir == 0) { printf("Can not open source dir: %s\n", dirname); exit(2); } lab_header head; head.num_entries = 0; head.string_table_size = 0; countFiles(&head, dir, dirname, 0); // printf("%d files, string table of size %d\n", head.num_entries, head.string_table_size); lab_entry *entries = (lab_entry *)malloc(head.num_entries * sizeof(lab_entry)); char *str_table = (char *)malloc(head.string_table_size); if (!str_table || !entries) { printf("Could not allocate memory\n"); exit(3); } rewinddir(dir); uint32_t offset = 16 + head.num_entries * sizeof(lab_entry) + head.string_table_size + 16; createEntries(dir, entries, str_table, dirname, offset); closedir(dir); // Open the output file after we've finished with the dir, so that we're sure // we don't include the lab into itself if it was asked to be created into the same dir. FILE *outfile = fopen(out, "wb"); if (!outfile) { printf("Could not open file %s for writing\n", out); exit(2); } fwrite("LABN", 1, 4, outfile); fwrite("\x00\x00\x01\x00", 1, 4, outfile); //version writeUint32(outfile, head.num_entries); writeUint32(outfile, head.string_table_size); if (g_type == GT_GRIM) { uint32_t s_offset = 0; // First entry of the table has offset 0 for Grim fwrite(&s_offset, 1, 4, outfile); fseek(outfile, -4, SEEK_CUR); } else { // EMI has an offset instead. writeUint32(outfile, 20 + head.num_entries * sizeof(lab_entry) + 0x13d0f); } fwrite(entries, 1, head.num_entries * sizeof(lab_entry), outfile); if (g_type == GT_GRIM) { fwrite(str_table, 1, head.string_table_size, outfile); } else { char *s = (char *)malloc(head.string_table_size); memset(s, 0, head.string_table_size); for (uint32_t j = 0; j < head.string_table_size; j++) { if (str_table[j] != 0) s[j] = str_table[j] ^ 0x96; } fwrite(s, 1, head.string_table_size, outfile); free(s); } uint32_t bufsize = 1024*1024; char *buf = (char *)malloc(bufsize); for (uint32_t i = 0; i < head.num_entries; ++i) { lab_entry &entry = entries[i]; const char *fname = str_table + READ_LE_UINT32(&entry.fname_offset); char *path = appendPath(fname, dirname); FILE *file = fopen(path, "rb"); free(path); uint32_t offset = READ_LE_UINT32(&entry.start); uint32_t size = READ_LE_UINT32(&entry.size); if (size > bufsize) { char *newbuf = (char *)realloc(buf, size); if (!newbuf) { free(buf); printf("Could not allocate memory\n"); exit(3); } bufsize = size; buf = newbuf; } // printf("writing file %s, at offset %d and of size %d\n", fname, offset, size); fread(buf, 1, size, file); fseek(outfile, offset, SEEK_SET); fwrite(buf, 1, size, outfile); fclose(file); } fclose(outfile); free(buf); free(entries); free(str_table); return 0; }
char* appendPath2( const char* file, char* buffer, bool insertBackslash ) { appendPath( file, buffer, insertBackslash ); return ( buffer ); }
GList<GURL> DjVuMessage::GetProfilePaths(void) { static bool first=true; static GList<GURL> realpaths; if(first) { first=false; GMap<GUTF8String,void *> pathsmap; GList<GURL> paths; GURL path; const GUTF8String envp(GOS::getenv(DjVuEnv)); if(envp.length()) appendPath(GURL::Filename::UTF8(envp),pathsmap,paths); #if defined(WIN32) || defined(UNIX) GURL mpath(GetModulePath()); if(!mpath.is_empty() && mpath.is_dir()) { #if defined(UNIX) && !defined(AUTOCONF) && !defined(NDEBUG) appendPath(GURL::UTF8(DebugModuleDjVuDir,mpath),pathsmap,paths); #endif appendPath(mpath,pathsmap,paths); mpath=mpath.base(); appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths); mpath=mpath.base(); appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths); } #endif #if defined(AUTOCONF) GURL dpath = GURL::Filename::UTF8(DjVuDataDir); appendPath(dpath,pathsmap,paths); #endif #ifdef WIN32 appendPath(RegOpenReadConfig(HKEY_CURRENT_USER),pathsmap,paths); appendPath(RegOpenReadConfig(HKEY_LOCAL_MACHINE),pathsmap,paths); #else GUTF8String home=GOS::getenv("HOME"); # if HAVE_GETPWUID if (! home.length()) { struct passwd *pw=0; if ((pw = getpwuid(getuid()))) home=GNativeString(pw->pw_dir); } # endif if (home.length()) { GURL hpath = GURL::UTF8(LocalDjVuDir,GURL::Filename::UTF8(home)); appendPath(hpath,pathsmap,paths); } #endif #ifdef LT_DEFAULT_PREFIX appendPath(GURL::Filename::UTF8(DjVuPrefixDir),pathsmap,paths); #endif appendPath(GURL::Filename::UTF8(RootDjVuDir),pathsmap,paths); pathsmap.empty(); GPosition pos; GList< GMap<GUTF8String,GP<lt_XMLTags> > > localemaps; for(pos=paths;pos;++pos) { path=GURL::UTF8(LanguageFile,paths[pos]); if(path.is_file()) { const GP<lt_XMLTags> xml(lt_XMLTags::create(ByteStream::create(path,"rb"))); const GPList<lt_XMLTags> Body(xml->get_Tags(bodystring)); GPosition pos=Body; if(!pos || (pos != Body.lastpos())) { G_THROW( ERR_MSG("XMLAnno.extra_body") ); } const GP<lt_XMLTags> GBody(Body[pos]); if(!GBody) { G_THROW( ERR_MSG("XMLAnno.no_body") ); } GMap<GUTF8String,GP<lt_XMLTags> > localemap; lt_XMLTags::get_Maps(languagestring,localestring,Body,localemap); localemaps.append(localemap); } } GList<GURL> localepaths; GList<GURL> osilocalepaths; // Need to do it the right way! GUTF8String defaultlocale = getenv("LANGUAGE"); if (! defaultlocale) { const GUTF8String oldlocale(setlocale(LC_MESSAGES,0)); defaultlocale = setlocale(LC_MESSAGES,""); setlocale(LC_MESSAGES,(const char *)oldlocale); } // Unfathomable search. for(int loop=0; loop<2; loop++) { static const char sepchars[]=" _.@"; const char *p=sepchars+sizeof(sepchars)-1; do { int sepcharpos=p[0]?defaultlocale.search(p[0]):defaultlocale.length(); if(sepcharpos > 0) { const GUTF8String sublocale(defaultlocale,sepcharpos); const GUTF8String downcasesublocale("downcase^"+sublocale.downcase()); for(pos=localemaps;pos;++pos) { const GMap<GUTF8String,GP<lt_XMLTags> > &localemap=localemaps[pos]; GPosition pos=localemap.contains(sublocale); if(!pos) pos=localemap.contains(downcasesublocale); if(pos) { const GMap<GUTF8String,GUTF8String>&args = localemap[pos]->get_args(); pos = args.contains(srcstring); if (pos) { const GUTF8String src(args[pos]); for(pos=paths;pos;++pos) { path=GURL::UTF8(src,paths[pos]); if(path.is_dir()) localepaths.append(path); path=GURL::UTF8(GUTF8String(opensourcedir)+"/"+src,paths[pos]); if(path.is_dir()) osilocalepaths.append(path); } } // We don't need to check anymore language files. p=sepchars; break; } } if(!pos) { for(pos=paths;pos;++pos) { path=GURL::UTF8(sublocale,paths[pos]); if(path.is_dir()) { localepaths.append(path); } path=GURL::UTF8(GUTF8String(opensourcedir)+"/"+sublocale,paths[pos]); if(path.is_dir()) { osilocalepaths.append(path); } } } } } while(p-- != sepchars); if((GPosition) localepaths) break; defaultlocale="C"; } for(pos=localepaths;pos;++pos) appendPath(localepaths[pos],pathsmap,realpaths); for(pos=paths;pos;++pos) appendPath(paths[pos],pathsmap,realpaths); for(pos=osilocalepaths;pos;++pos) appendPath(osilocalepaths[pos],pathsmap,realpaths); for(pos=paths;pos;++pos) { path=GURL::UTF8(opensourcedir,paths[pos]); appendPath(path,pathsmap,realpaths); } } return realpaths; }
int prepare(const char *lpCmdLine) { char tmp[MAX_ARGS] = {0}; hModule = GetModuleHandle(NULL); if (hModule == NULL) { return FALSE; } // Get executable path char exePath[_MAX_PATH] = {0}; int pathLen = getExePath(exePath); if (pathLen == -1) { return FALSE; } // Initialize logging if (strstr(lpCmdLine, "--l4j-debug") != NULL) { hLog = openLogFile(exePath, pathLen); if (hLog == NULL) { return FALSE; } debug("\n\nCmdLine:\t%s %s\n", exePath, lpCmdLine); } setWow64Flag(); // Set default error message, title and optional support web site url. loadString(SUPPORT_URL, errUrl); loadString(ERR_TITLE, errTitle); if (!loadString(STARTUP_ERR, errMsg)) { return FALSE; } // Single instance loadString(MUTEX_NAME, mutexName); if (*mutexName) { SECURITY_ATTRIBUTES security; security.nLength = sizeof(SECURITY_ATTRIBUTES); security.bInheritHandle = TRUE; security.lpSecurityDescriptor = NULL; CreateMutexA(&security, FALSE, mutexName); if (GetLastError() == ERROR_ALREADY_EXISTS) { debug("Instance already exists."); return ERROR_ALREADY_EXISTS; } } // Working dir char tmp_path[_MAX_PATH] = {0}; GetCurrentDirectory(_MAX_PATH, oldPwd); if (loadString(CHDIR, tmp_path)) { strncpy(workingDir, exePath, pathLen); appendPath(workingDir, tmp_path); _chdir(workingDir); debug("Working dir:\t%s\n", workingDir); } // Use bundled jre or find java if (loadString(JRE_PATH, tmp_path)) { char jrePath[MAX_ARGS] = {0}; expandVars(jrePath, tmp_path, exePath, pathLen); debug("Bundled JRE:\t%s\n", jrePath); if (jrePath[0] == '\\' || jrePath[1] == ':') { // Absolute strcpy(cmd, jrePath); } else { // Relative strncpy(cmd, exePath, pathLen); appendPath(cmd, jrePath); } } if (!isJrePathOk(cmd)) { if (!loadString(JAVA_MIN_VER, javaMinVer)) { loadString(BUNDLED_JRE_ERR, errMsg); return FALSE; } loadString(JAVA_MAX_VER, javaMaxVer); if (!findJavaHome(cmd, loadInt(JDK_PREFERENCE))) { loadString(JRE_VERSION_ERR, errMsg); strcat(errMsg, " "); strcat(errMsg, javaMinVer); if (*javaMaxVer) { strcat(errMsg, " - "); strcat(errMsg, javaMaxVer); } loadString(DOWNLOAD_URL, errUrl); return FALSE; } if (!isJrePathOk(cmd)) { loadString(LAUNCHER_ERR, errMsg); return FALSE; } } // Append a path to the Path environment variable char jreBinPath[_MAX_PATH]; strcpy(jreBinPath, cmd); strcat(jreBinPath, "\\bin"); if (!appendToPathVar(jreBinPath)) { return FALSE; } // Set environment variables char envVars[MAX_VAR_SIZE] = {0}; loadString(ENV_VARIABLES, envVars); char *var = strtok(envVars, "\t"); while (var != NULL) { char *varValue = strchr(var, '='); *varValue++ = 0; *tmp = 0; expandVars(tmp, varValue, exePath, pathLen); debug("Set var:\t%s = %s\n", var, tmp); SetEnvironmentVariable(var, tmp); var = strtok(NULL, "\t"); } *tmp = 0; // Process priority priority = loadInt(PRIORITY_CLASS); // Custom process name const BOOL setProcName = loadBool(SET_PROC_NAME) && strstr(lpCmdLine, "--l4j-default-proc") == NULL; const BOOL wrapper = loadBool(WRAPPER); appendLauncher(setProcName, exePath, pathLen, cmd); // Heap sizes appendHeapSizes(args); // JVM options if (loadString(JVM_OPTIONS, tmp)) { strcat(tmp, " "); } else { *tmp = 0; } /* * Load additional JVM options from .l4j.ini file * Options are separated by spaces or CRLF * # starts an inline comment */ strncpy(tmp_path, exePath, strlen(exePath) - 3); strcat(tmp_path, "l4j.ini"); long hFile; if ((hFile = _open(tmp_path, _O_RDONLY)) != -1) { const int jvmOptLen = strlen(tmp); char* src = tmp + jvmOptLen; char* dst = src; const int len = _read(hFile, src, MAX_ARGS - jvmOptLen - BIG_STR); BOOL copy = TRUE; int i; for (i = 0; i < len; i++, src++) { if (*src == '#') { copy = FALSE; } else if (*src == 13 || *src == 10) { copy = TRUE; if (dst > tmp && *(dst - 1) != ' ') { *dst++ = ' '; } } else if (copy) { *dst++ = *src; } } *dst = 0; if (len > 0 && *(dst - 1) != ' ') { strcat(tmp, " "); } _close(hFile); } // Expand environment %variables% expandVars(args, tmp, exePath, pathLen); // MainClass + Classpath or Jar char mainClass[STR] = {0}; char jar[_MAX_PATH] = {0}; loadString(JAR, jar); if (loadString(MAIN_CLASS, mainClass)) { if (!loadString(CLASSPATH, tmp)) { return FALSE; } char exp[MAX_ARGS] = {0}; expandVars(exp, tmp, exePath, pathLen); strcat(args, "-classpath \""); if (wrapper) { appendAppClasspath(args, exePath, exp); } else if (*jar) { appendAppClasspath(args, jar, exp); } // Deal with wildcards or >> strcat(args, exp); << char* cp = strtok(exp, ";"); while(cp != NULL) { debug("Add classpath:\t%s\n", cp); if (strpbrk(cp, "*?") != NULL) { int len = strrchr(cp, '\\') - cp + 1; strncpy(tmp_path, cp, len); char* filename = tmp_path + len; *filename = 0; struct _finddata_t c_file; long hFile; if ((hFile = _findfirst(cp, &c_file)) != -1L) { do { strcpy(filename, c_file.name); strcat(args, tmp_path); strcat(args, ";"); debug(" \" :\t%s\n", tmp_path); } while (_findnext(hFile, &c_file) == 0); } _findclose(hFile); } else { strcat(args, cp); strcat(args, ";"); } cp = strtok(NULL, ";"); } *(args + strlen(args) - 1) = 0; strcat(args, "\" "); strcat(args, mainClass); } else if (wrapper) { strcat(args, "-jar \""); strcat(args, exePath); strcat(args, "\""); } else { strcat(args, "-jar \""); strncat(args, exePath, pathLen); appendPath(args, jar); strcat(args, "\""); } // Constant command line args if (loadString(CMD_LINE, tmp)) { strcat(args, " "); strcat(args, tmp); } // Command line args if (*lpCmdLine) { strcpy(tmp, lpCmdLine); char* dst; while ((dst = strstr(tmp, "--l4j-")) != NULL) { char* src = strchr(dst, ' '); if (src == NULL || *(src + 1) == 0) { *dst = 0; } else { strcpy(dst, src + 1); } } if (*tmp) { strcat(args, " "); strcat(args, tmp); } } debug("Launcher:\t%s\n", cmd); debug("Launcher args:\t%s\n", args); debug("Args length:\t%d/32768 chars\n", strlen(args)); return TRUE; }
libfreehand::FHPath::FHPath(const libfreehand::FHPath &path) : m_elements(), m_isClosed(path.m_isClosed), m_xFormId(path.m_xFormId), m_graphicStyleId(path.m_graphicStyleId), m_evenOdd(path.m_evenOdd) { appendPath(path); }
String AbstractFileManager::appendPathComponent(const String& path, const String& component) { return appendPath(path, component); }
// Return file real path QString FtpFileSystem::getFileFullPath(const QString& filename) { return appendPath(mBaseDir,appendPath(mCurDir,filename)); }
QUrl MultiColorImageStackNode::getPathToLsmFilePathsFile() { return appendPath(imageDir, "lsmFilePaths.txt"); }
static const char * cygterm_init(void *frontend_handle, void **backend_handle, Conf *conf, char *unused_host, int unused_port, char **realhost, int nodelay, int keepalive) { /* XXX: I'm not sure if it is OK to overload Plug like this. * cygterm_accepting should only be used for the listening socket * (local->a) while the cygterm_closing, cygterm_receive, and cygterm_sent * should be used only for the actual connection (local->s). */ static const struct plug_function_table fn_table = { cygterm_log, cygterm_closing, cygterm_receive, cygterm_sent, cygterm_accepting }; Local local; const char *command; char cmdline[2 * MAX_PATH]; int cport; const char *err; int cmdlinelen; cygterm_debug("top"); local = snew(struct cygterm_backend_data); local->fn = &fn_table; local->a = NULL; local->s = NULL; local->conf = conf; local->editing = 0; local->echoing = 0; local->exitcode = 0; *backend_handle = local; local->frontend = frontend_handle; /* set up listen socket for communication with child */ cygterm_debug("setupCygTerm"); /* let sk use INADDR_LOOPBACK and let WinSock choose a port */ local->a = sk_newlistener(0, 0, (Plug)local, 1, ADDRTYPE_IPV4); if ((err = sk_socket_error(local->a)) != NULL) goto fail_free; /* now, get the port that WinSock chose */ /* XXX: Is there another function in PuTTY to do this? */ cygterm_debug("getting port"); cport = sk_getport(local->a); if (cport == -1) { err = "Failed to get port number for cthelper"; goto fail_close; } if (strchr(conf_get_str(local->conf, CONF_termtype), ' ')) { err = "term type contains spaces"; goto fail_close; } /* Build cthelper command line */ if(conf_get_int(conf, CONF_cygterm64)) { cmdlinelen = sprintf(cmdline, CTHELPER64" %u %s ", cport, conf_get_str(local->conf, CONF_termtype)); } else { cmdlinelen = sprintf(cmdline, CTHELPER" %u %s ", cport, conf_get_str(local->conf, CONF_termtype)); } cmdlinelen += makeAttributes(cmdline + cmdlinelen, conf); command = conf_get_str(conf, CONF_cygcmd); cygterm_debug("command is :%s:", command); /* A command of "." or "-" tells us to pass no command arguments to * cthelper which will then run the user's shell under Cygwin. */ if ((command[0]=='-'||command[0]=='.') && command[1]=='\0') ; else if (cmdlinelen + strlen(command) + 2 > sizeof cmdline) { err = "command is too long"; goto fail_close; } else { cmdlinelen += sprintf(cmdline + cmdlinelen, " %s", command); } /* Add the Cygwin /bin path to the PATH. */ if (conf_get_int(conf, CONF_cygautopath)) { char *cygwinBinPath = getCygwinBin(conf_get_int(conf, CONF_cygterm64)); if (!cygwinBinPath) { /* we'll try anyway */ cygterm_debug("cygwin bin directory not found"); } else { cygterm_debug("found cygwin directory: %s", cygwinBinPath); appendPath(cygwinBinPath); sfree(cygwinBinPath); } } cygterm_debug("starting cthelper: %s", cmdline); if ((err = spawnChild(cmdline, &local->pi, &local->ctl))) goto fail_close; /* This should be set to the local hostname, Apparently, realhost is used * only to set the window title. */ strcpy(*realhost = smalloc(sizeof CYGTERM_NAME), CYGTERM_NAME); cygterm_debug("OK"); return 0; fail_close: sk_close(local->a); fail_free: sfree(local); return err; }
int prepare(const char *lpCmdLine) { char tmp[MAX_ARGS] = {0}; hModule = GetModuleHandle(NULL); if (hModule == NULL) { return FALSE; } // Get executable path char exePath[_MAX_PATH] = {0}; int pathLen = getExePath(exePath); if (pathLen == -1) { return FALSE; } if (!initializeLogging(lpCmdLine, exePath, pathLen)) { return FALSE; } debug("\n\nVersion:\t%s\n", VERSION); debug("CmdLine:\t%s %s\n", exePath, lpCmdLine); setWow64Flag(); // Set default error message, title and optional support web site url. loadString(SUPPORT_URL, errUrl); loadString(ERR_TITLE, errTitle); if (!loadString(STARTUP_ERR, errMsg)) { debug(ERROR_FORMAT, "Startup error message not defined."); return FALSE; } // Single instance loadString(MUTEX_NAME, mutexName); if (*mutexName) { SECURITY_ATTRIBUTES security; security.nLength = sizeof(SECURITY_ATTRIBUTES); security.bInheritHandle = TRUE; security.lpSecurityDescriptor = NULL; CreateMutexA(&security, FALSE, mutexName); if (GetLastError() == ERROR_ALREADY_EXISTS) { debug(ERROR_FORMAT, "Instance already exists."); return ERROR_ALREADY_EXISTS; } } // Working dir char tmp_path[_MAX_PATH] = {0}; GetCurrentDirectory(_MAX_PATH, oldPwd); if (loadString(CHDIR, tmp_path)) { strncpy(workingDir, exePath, pathLen); appendPath(workingDir, tmp_path); _chdir(workingDir); debug("Working dir:\t%s\n", workingDir); } // Use bundled jre or find java if (loadString(JRE_PATH, tmp_path)) { char jrePath[MAX_ARGS] = {0}; expandVars(jrePath, tmp_path, exePath, pathLen); debug("Bundled JRE:\t%s\n", jrePath); if (jrePath[0] == '\\' || jrePath[1] == ':') { // Absolute strcpy(cmd, jrePath); } else { // Relative strncpy(cmd, exePath, pathLen); appendPath(cmd, jrePath); } if (isLauncherPathValid(cmd)) { foundJava = (wow64 && loadBool(BUNDLED_JRE_64_BIT)) ? FOUND_BUNDLED | KEY_WOW64_64KEY : FOUND_BUNDLED; } } if (foundJava == NO_JAVA_FOUND) { if (!loadString(JAVA_MIN_VER, javaMinVer)) { loadString(BUNDLED_JRE_ERR, errMsg); return FALSE; } loadString(JAVA_MAX_VER, javaMaxVer); if (!findJavaHome(cmd, loadInt(JDK_PREFERENCE))) { loadString(JRE_VERSION_ERR, errMsg); strcat(errMsg, " "); strcat(errMsg, javaMinVer); if (*javaMaxVer) { strcat(errMsg, " - "); strcat(errMsg, javaMaxVer); } if (runtimeBits == USE_64_BIT_RUNTIME || runtimeBits == USE_32_BIT_RUNTIME) { strcat(errMsg, " ("); strcat(errMsg, runtimeBits == USE_64_BIT_RUNTIME ? "64" : "32"); strcat(errMsg, "-bit)"); } if (corruptedJreFound) { char launcherErrMsg[BIG_STR] = {0}; if (loadString(LAUNCHER_ERR, launcherErrMsg)) { strcat(errMsg, "\n"); strcat(errMsg, launcherErrMsg); } } loadString(DOWNLOAD_URL, errUrl); return FALSE; } } // Store the JRE Home Dir strcpy(jreHomeDir, cmd); // Append a path to the Path environment variable char jreBinPath[_MAX_PATH] = {0}; strcpy(jreBinPath, cmd); strcat(jreBinPath, "\\bin"); if (!appendToPathVar(jreBinPath)) { debug(ERROR_FORMAT, "appendToPathVar failed."); return FALSE; } // Set environment variables char envVars[MAX_VAR_SIZE] = {0}; loadString(ENV_VARIABLES, envVars); char *var = strtok(envVars, "\t"); while (var != NULL) { char *varValue = strchr(var, '='); *varValue++ = 0; *tmp = 0; expandVars(tmp, varValue, exePath, pathLen); debug("Set var:\t%s = %s\n", var, tmp); SetEnvironmentVariable(var, tmp); var = strtok(NULL, "\t"); } *tmp = 0; // Process priority priority = loadInt(PRIORITY_CLASS); // Launcher appendJavaw(cmd); // Heap sizes appendHeapSizes(args); // JVM options char jvmOptions[MAX_ARGS] = {0}; setJvmOptions(jvmOptions, exePath); // Expand environment %variables% expandVars(args, jvmOptions, exePath, pathLen); // MainClass + Classpath or Jar char mainClass[STR] = {0}; char jar[_MAX_PATH] = {0}; const BOOL wrapper = loadBool(WRAPPER); loadString(JAR, jar); if (loadString(MAIN_CLASS, mainClass)) { if (!loadString(CLASSPATH, tmp)) { debug("Info:\t\tClasspath not defined.\n"); } char exp[MAX_ARGS] = {0}; expandVars(exp, tmp, exePath, pathLen); strcat(args, "-classpath \""); if (wrapper) { appendAppClasspath(args, exePath); } else if (*jar) { appendAppClasspath(args, jar); } // Deal with wildcards or >> strcat(args, exp); << char* cp = strtok(exp, ";"); while(cp != NULL) { debug("Add classpath:\t%s\n", cp); if (strpbrk(cp, "*?") != NULL) { int len = strrchr(cp, '\\') - cp + 1; strncpy(tmp_path, cp, len); char* filename = tmp_path + len; *filename = 0; struct _finddata_t c_file; long hFile; if ((hFile = _findfirst(cp, &c_file)) != -1L) { do { strcpy(filename, c_file.name); appendAppClasspath(args, tmp_path); debug(" \" :\t%s\n", tmp_path); } while (_findnext(hFile, &c_file) == 0); } _findclose(hFile); } else { appendAppClasspath(args, cp); } cp = strtok(NULL, ";"); } *(args + strlen(args) - 1) = 0; strcat(args, "\" "); strcat(args, mainClass); } else if (wrapper) { strcat(args, "-jar \""); strcat(args, exePath); strcat(args, "\""); } else { strcat(args, "-jar \""); strncat(args, exePath, pathLen); appendPath(args, jar); strcat(args, "\""); } // Constant command line args if (loadString(CMD_LINE, tmp)) { strcat(args, " "); strcat(args, tmp); } // Command line args if (*lpCmdLine) { strcpy(tmp, lpCmdLine); char* dst; while ((dst = strstr(tmp, "--l4j-")) != NULL) { char* src = strchr(dst, ' '); if (src == NULL || *(src + 1) == 0) { *dst = 0; } else { strcpy(dst, src + 1); } } if (*tmp) { strcat(args, " "); strcat(args, tmp); } } debug("Launcher:\t%s\n", cmd); debug("Launcher args:\t%s\n", args); debug("Args length:\t%d/32768 chars\n", strlen(args)); return TRUE; }