/* ** Create a temporary file name in zBuf. zBuf must be big enough to ** hold at pVfs->mxPathname characters. */ static int os2GetTempname( sqlite3_vfs *pVfs, int nBuf, char *zBuf ){ static const unsigned char zChars[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"; int i, j; PSZ zTempPath = ""; if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){ ULONG ulDriveNum = 0, ulDriveMap = 0; DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ); sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) ); } } } /* strip off a trailing slashes or backslashes, otherwise we would get * * multiple (back)slashes which causes DosOpen() to fail */ j = strlen(zTempPath); while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ) ){ j--; } zTempPath[j] = '\0'; assert( nBuf>=pVfs->mxPathname ); sqlite3_snprintf( pVfs->mxPathname-30, zBuf, "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath ); j = strlen( zBuf ); sqlite3Randomness( 20, &zBuf[j] ); for( i = 0; i < 20; i++, j++ ){ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; OSTRACE2( "TEMP FILENAME: %s\n", zBuf ); return SQLITE_OK; }
/* ** Create a temporary file name in zBuf. zBuf must be big enough to ** hold at least SQLITE_TEMPNAME_SIZE characters. */ int sqlite3Os2TempFileName( char *zBuf ){ static const unsigned char zChars[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"; int i, j; PSZ zTempPath = 0; if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){ ULONG ulDriveNum = 0, ulDriveMap = 0; DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ); sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) ); } } } for(;;){ sprintf( zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath ); j = strlen( zBuf ); sqlite3Randomness( 15, &zBuf[j] ); for( i = 0; i < 15; i++, j++ ){ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; if( !sqlite3OsFileExists( zBuf ) ) break; } OSTRACE2( "TEMP FILENAME: %s\n", zBuf ); return SQLITE_OK; }
/* ** Create a temporary file name in zBuf. zBuf must be big enough to ** hold at pVfs->mxPathname characters. */ static int getTempname(int nBuf, char *zBuf ){ static const unsigned char zChars[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"; int i, j; char zTempPathBuf[3]; PSZ zTempPath = (PSZ)&zTempPathBuf; if( sqlite3_temp_directory ){ zTempPath = sqlite3_temp_directory; }else{ if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){ ULONG ulDriveNum = 0, ulDriveMap = 0; DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ); sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) ); } } } } /* Strip off a trailing slashes or backslashes, otherwise we would get * * multiple (back)slashes which causes DosOpen() to fail. * * Trailing spaces are not allowed, either. */ j = sqlite3Strlen30(zTempPath); while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' || zTempPath[j-1] == ' ' ) ){ j--; } zTempPath[j] = '\0'; if( !sqlite3_temp_directory ){ char *zTempPathUTF = convertCpPathToUtf8( zTempPath ); sqlite3_snprintf( nBuf-30, zBuf, "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPathUTF ); free( zTempPathUTF ); }else{ sqlite3_snprintf( nBuf-30, zBuf, "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath ); } j = sqlite3Strlen30( zBuf ); sqlite3_randomness( 20, &zBuf[j] ); for( i = 0; i < 20; i++, j++ ){ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; OSTRACE2( "TEMP FILENAME: %s\n", zBuf ); return SQLITE_OK; }
char *xine_home(char *subdir) { PSZ root; size_t len; DosScanEnv("MMBASE",&root); strcpy(tmp_os2_path,root); len=strlen(tmp_os2_path); if (tmp_os2_path[len-1]==';') tmp_os2_path[len-1]='\0'; len=strlen(tmp_os2_path); strcpy(&(tmp_os2_path[len]),"/xine"); if (subdir!=NULL) { len=strlen(tmp_os2_path); if (tmp_os2_path[len-1]!='\\' && tmp_os2_path[len-1]!='/') { tmp_os2_path[len]='/'; tmp_os2_path[len+1]='\0'; } /* endif */ len=strlen(tmp_os2_path); strcpy(&(tmp_os2_path[len]),subdir); } len=strlen(tmp_os2_path); if (tmp_os2_path[len-1]=='\\' || tmp_os2_path[len-1]=='/') tmp_os2_path[len-1]='\0'; len=0; while (tmp_os2_path[len]) { if (tmp_os2_path[len]=='\\') tmp_os2_path[len]='/'; len++; } return tmp_os2_path; }
//------------------------------- CMD_DosScanEnv ------------------------------- void CMD_DosScanEnv(HFILE hFile,LXIOCPA_DMN_CMDPARMPACKET* pParam,char* pData) { PSZ pszVal; pParam->rc=DosScanEnv(pData,&pszVal); if(!pParam->rc) strcpy(pData,pszVal); }
static void LoadInterpreter( void ) { handle_type handle=(handle_type)NULL ; char *ptr; if ( DosScanEnv( "REXX_TRACEFILE", (PSZ *)&ptr ) ) ptr = NULL; if ( ptr != NULL ) { Trace = 1; strcpy( TraceFileName, ptr ); } handle = (handle_type)FindInterpreter( "REGINA" ); if ( handle == (handle_type)NULL ) { fprintf( stderr, "Could not find Regina DLL. Cannot continue.\n" ); exit( 11 ); } if ( Trace ) { TraceString( "----------- Initialisation Complete - Program Execution Begins -----------\n" ); } InterpreterIdx = 0; return; }
unsigned EnvLkup( const char *name, char *buff, unsigned buff_len ) { const char __far *env; unsigned len; int output = 0; char c; if( DosScanEnv( name, &env ) != 0 ) return( 0 ); if( buff_len != 0 && buff != NULL ) { --buff_len; output = 1; } for( len = 0; (c = *env++) != '\0'; ++len ) { if( output ) { if( len >= buff_len ) { break; } *buff++ = c; } } if( output ) { buff[len] = '\0'; } return( len ); }
char * _nl_getenv (const char *name) { unsigned char *value; if (DosScanEnv (name, &value)) return NULL; else return value; }
/* Replacement version of getenv(), because the one in the EMX 0.9c, fix03 dist appears to be busted when called from inside a DLL. (MJJ) */ char *getenv(const char *envar) { APIRET rc; unsigned char *envstring; /* just call the OS/2 function directly */ rc = DosScanEnv(envar, &envstring); if (rc) return NULL; else return envstring; }
/* ** Create a temporary file name in zBuf. zBuf must be big enough to ** hold at least SQLITE_TEMPNAME_SIZE characters. */ int sqlite3Os2TempFileName( char *zBuf ){ static const unsigned char zChars[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"; int i, j; PSZ zTempPath = 0; if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){ if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){ ULONG ulDriveNum = 0, ulDriveMap = 0; DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ); sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) ); } } } /* strip off a trailing slashes or backslashes, otherwise we would get * * multiple (back)slashes which causes DosOpen() to fail */ j = strlen(zTempPath); while( j > 0 && zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ){ j--; } zTempPath[j] = '\0'; for(;;){ sprintf( zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath ); j = strlen( zBuf ); sqlite3Randomness( 15, &zBuf[j] ); for( i = 0; i < 15; i++, j++ ){ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; if( !sqlite3OsFileExists( zBuf ) ) break; } OSTRACE2( "TEMP FILENAME: %s\n", zBuf ); return SQLITE_OK; }
static int archdep_search_path(const char *name, char *pBuf, int lBuf) { const int flags = SEARCH_CUR_DIRECTORY|SEARCH_IGNORENETERRS; char *path = ""; /* PATH environment variable */ char *pgmName = util_concat(name, ".exe", NULL); // Search the program in the path DosScanEnv("PATH", &path); if (DosSearchPath(flags, path, pgmName, pBuf, lBuf)) { return -1; } lib_free(pgmName); return 0; }
char * hb_getenv( const char * szName ) { char * pszBuffer = NULL; #if defined( HB_OS_WIN ) { LPTSTR lpName = HB_CHARDUP( szName ); DWORD size = GetEnvironmentVariable( lpName, NULL, 0 ); if( size != 0 ) { LPTSTR lpBuffer = ( LPTSTR ) hb_xgrab( size * sizeof( TCHAR ) ); GetEnvironmentVariable( lpName, lpBuffer, size ); pszBuffer = HB_OSSTRDUP( lpBuffer ); hb_xfree( lpBuffer ); } hb_xfree( lpName ); } #elif defined( HB_OS_OS2 ) { PSZ EnvValue = ( PSZ ) ""; char * pszNameFree = NULL; szName = hb_osEncodeCP( szName, &pszNameFree, NULL ); if( DosScanEnv( ( PCSZ ) szName, &EnvValue ) == NO_ERROR ) pszBuffer = hb_osStrDecode( ( char * ) EnvValue ); if( pszNameFree ) hb_xfree( pszNameFree ); } #else { char * pszTemp, * pszNameFree = NULL; szName = hb_osEncodeCP( szName, &pszNameFree, NULL ); pszTemp = getenv( szName ); if( pszNameFree ) hb_xfree( pszNameFree ); if( pszTemp != NULL ) pszBuffer = hb_osStrDecode( pszTemp ); } #endif return pszBuffer; }
int archdep_search_path(const char *name, char *pBuf, int lBuf) { const int flags = SEARCH_CUR_DIRECTORY|SEARCH_IGNORENETERRS; char *path = ""; /* PATH environment variable */ char *pgmName = util_concat(name, ".exe", NULL); // Search the program in the path if (DosScanEnv("PATH", &path)) { log_warning(archlog, "Environment variable PATH not found."); } if (DosSearchPath(flags, path, pgmName, pBuf, lBuf)) { log_error(archlog, "File \"%s\" not found.", pgmName); return -1; } lib_free(pgmName); return 0; }
BOOL ChangeWPS(PCHAR pszUserIni, PCHAR pszSystemIni) { PCHAR pcEnv; PRFPROFILE prfProfile; BOOL bSuccess; if (*pszSystemIni == '\0') prfProfile.pszSysName = pShareInitOS2->pszRootSystemIni; else prfProfile.pszSysName = pszSystemIni; if (*prfProfile.pszSysName == '\0') prfProfile.pszSysName = (DosScanEnv (ENV_SYSTEM_INI, &pcEnv) ? "" : pcEnv); if (*pszUserIni == '\0') { prfProfile.pszUserName = pShareInitOS2->pszRootUserIni; pShareInitOS2->ulFlag = pShareInitOS2->ulFlag_Root; // ulFlag f�r Rootdesktop } else prfProfile.pszUserName = pszUserIni; if (*prfProfile.pszUserName == '\0') prfProfile.pszUserName = (DosScanEnv (ENV_USER_INI, &pcEnv) ? "" : pcEnv); prfProfile.cchUserName = strlen(prfProfile.pszUserName); prfProfile.cchSysName = strlen(prfProfile.pszSysName); if (ulOldFlag & CLOSEAPPL) WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "WORKAREA=YES"); else WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "WORKAREA=NO"); WinPostMsg(WinQueryWindow(HWND_DESKTOP, QW_BOTTOM), WM_CLOSE, 0, 0); DebugS (1, "HWND_DESKTOP closed"); if( hevPrfResetLock ) { DosWaitEventSem (hevPrfResetLock, SEM_INDEFINITE_WAIT); DosSleep(1000); DebugS (1, "hevPrfResetLock released"); } else DosSleep(20000); bSuccess = PrfReset(hab, &prfProfile); DebugULd (1, "PrfReset", "return", bSuccess); /* * Beim Umschalten auf den Root, egal ob von Sammy oder von WPSamF ausgel�st, * wird die Shell vom PrfReset nicht geschlossen. * Solange die Ursache nicht bekannt ist, bleibt nichts anderes �brig, * als an dieser Stelle symptomatisch vorzugehen und die Shell abzuschie�en. */ if (*pszUserIni == '\0') { DosSuspendThread (tid1); DosKillProcess( DKP_PROCESSTREE, ulShellID ); // sog. Budnik'scher Arschtritt DebugS (1, "Shell killed"); DosResumeThread (tid1); } if( !bSuccess ) { WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "OPEN=ICON;WORKAREA=YES"); DebugS (1, "Desktop set to <WP_DESKTOP>"); intSammyRetCode = 250; WinPostQueueMsg (hmq, WM_QUIT, 0L, 0L); } else ulOldFlag = pShareInitOS2->ulFlag; return( bSuccess ); }
ULONG ulExecProg (CHAR *szProgName) { ULONG ulBootDrive; ULONG ulAppType; CHAR szCmdName[CCHMAXPATH]; CHAR szLine[CCHMAXPATH]; PSZ pszScanEnv; RESULTCODES rcTermination; APIRET rcFailure = 0; PCHAR pszEnvironment; /* * Diese Routine versucht eine Shell zu starten. */ pszEnvironment = MakeEnv (pShareInitOS2->pszEnvironment); if ( !(rcFailure = ScanEnv(ENV_SAMWORKPLACE, &pszScanEnv, pszEnvironment)) ) { rcFailure = DosQueryAppType(pszScanEnv, &ulAppType); if ( !rcFailure ) if ( ( (ulAppType & 7) == FAPPTYP_NOTSPEC) || ( (ulAppType & 7) == FAPPTYP_WINDOWAPI) ) rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ pszScanEnv); /* Program file name */ else rcFailure = 1; } if (rcFailure) { WinAlarm (HWND_DESKTOP, WA_ERROR); DebugS (1, "DosExecPgm <1> failed"); } if (rcFailure) { rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ szProgName); /* Program file name */ } if (rcFailure) { if (!(rcFailure = DosScanEnv (ENV_SAMWORKPLACE, &pszScanEnv))) rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ pszScanEnv); /* Program file name */ } if (rcFailure) { DebugS (1, "DosExecPgm <2> failed"); DosQuerySysInfo (QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &ulBootDrive, sizeof (ULONG)); memset (szCmdName, '\0', sizeof(szCmdName)); szCmdName[0] = (CHAR) (ulBootDrive - 1) + 'A'; strcpy (szCmdName+1, ":\\OS2\\PMSHELL.EXE"); rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ szCmdName); /* Program file name */ } /* Falls Shell nicht gestartet werden konnte, wird cmd.exe aufgerufen */ if (rcFailure) { DebugS (1, "DosExecPgm <3> failed"); if (!(rcFailure = DosScanEnv ("COMSPEC", &pszScanEnv))) rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "/K", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ pszScanEnv); /* Program file name */ } if (rcFailure) { DebugS (1, "DosExecPgm <4> failed"); DosQuerySysInfo (QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &ulBootDrive, sizeof (ULONG)); memset (szCmdName, '\0', sizeof(szCmdName)); szCmdName[0] = (CHAR) (ulBootDrive - 1) + 'A'; strcpy (szCmdName+1, ":\\OS2\\CMD.EXE"); rcFailure = DosExecPgm (szLine, /* Object name buffer */ sizeof(szLine), /* Length of object name buffer */ EXEC_ASYNCRESULT, /* Execution flags */ "/K", /* Argument string */ pszEnvironment, /* Environment */ &rcTermination, /* Termination codes */ szCmdName); /* Program file name */ } DosFreeMem(pszEnvironment); if (rcFailure) { intSammyRetCode = rcFailure; WinPostQueueMsg (hmq, WM_CLOSE, 0L, 0L); DebugS (1, "DosExecPgm <5> failed"); } return (rcFailure ? 0 : rcTermination.codeTerminate); }
static FILE *internal_OpenNLSFile(char *pchHomeDirectory) { char achRealLocaleName[128]; char *pchFileName, *pchLang; ULONG rc; int i; FILE *hfNLSFile; hfNLSFile = NULLHANDLE; pchFileName = (char *) malloc(1024); if (pchFileName) { // Let's check the currently set Languagecode string! achRealLocaleName[0] = 0; if (DosRequestMutexSem(hmtxUseNLSTextArray, SEM_INDEFINITE_WAIT)==NO_ERROR) { if (apchNLSText[SSMODULE_NLSTEXT_LANGUAGECODE]) strncpy(achRealLocaleName, apchNLSText[SSMODULE_NLSTEXT_LANGUAGECODE], sizeof(achRealLocaleName)); DosReleaseMutexSem(hmtxUseNLSTextArray); } if (achRealLocaleName[0]==0) { // The ssaver core did not tell us anything about its language, so // try to get language from LANG env variable! #ifdef DEBUG_LOGGING AddLog("[internal_OpenNLSFile] : No language told by SSaver core, using LANG env. variable!\n"); #endif rc = DosScanEnv("LANG", &pchLang); if ((rc!=NO_ERROR) || (!pchLang)) { #ifdef DEBUG_LOGGING AddLog("[internal_OpenNLSFile] : Could not query LANG env. var., will use 'en'\n"); #endif pchLang = "en"; // Default } strncpy(achRealLocaleName, pchLang, sizeof(achRealLocaleName)); } // Get language code if (achRealLocaleName[0]!=0) { // Aaah, there is a language set! // Try that one! pchLang = (char *) malloc(1024); if (!pchLang) { // Not enough memory, so we won't do the long // method of searching for every combination of // the language string, but only for the string itself! // Assemble NLS file name sprintf(pchFileName, "%sModules\\Text\\%s.msg", pchHomeDirectory, achRealLocaleName); #ifdef DEBUG_LOGGING AddLog("[internal_OpenNLSFile] : Trying to open NLS file: ["); AddLog(pchFileName); AddLog("] by achLocalLanguage setting (in Not enough memory branch)!\n"); #endif hfNLSFile = fopenMessageFile(pchFileName); } else { // Fine, we can start trying a lot of filenames! sprintf(pchLang, "%s", achRealLocaleName); do { // Assemble NLS file name sprintf(pchFileName, "%sModules\\Text\\%s.msg", pchHomeDirectory, pchLang); #ifdef DEBUG_LOGGING AddLog("[internal_OpenNLSFile] : Trying to open NLS file: ["); AddLog(pchFileName); AddLog("] by achLocalLanguage setting! (in Loop)\n"); #endif hfNLSFile = fopenMessageFile(pchFileName); // Make pchLang shorter, until the next underscore! i = strlen(pchLang)-1; while ((i>=0) && (pchLang[i]!='_')) i--; if (i<0) i = 0; pchLang[i] = 0; } while ((pchLang[0]) && (!hfNLSFile)); free(pchLang); pchLang = NULL; } } free(pchFileName); } #ifdef DEBUG_LOGGING if (hfNLSFile) AddLog("[internal_OpenNLSFile] : NLS file opened.\n"); else AddLog("[internal_OpenNLSFile] : NLS file could not be opened.\n"); AddLog("[internal_OpenNLSFile] : Done.\n"); #endif return hfNLSFile; }
SOM_Scope BOOL SOMLINK WPSamFolder_RootDesktop (WPSamF *somSelf) { static PRFPROFILE prfProfile; PCHAR szUserIni; PCHAR szSysIni; /* WPSamFData *somThis = WPSamFGetData(somSelf); */ WPSamFMethodDebug ("WPSamF","WPSamFolder_RootDesktop"); /** Untersuchung, ob bereits im Rootdesktop **/ /* Namen der laufenden User- und System-INI-Dateien */ prfProfile.cchUserName = 0L; prfProfile.cchSysName = 0L; PrfQueryProfile (WinQueryAnchorBlock(HWND_DESKTOP), &prfProfile); prfProfile.pszUserName = malloc (prfProfile.cchUserName); prfProfile.pszSysName = malloc (prfProfile.cchSysName); PrfQueryProfile (WinQueryAnchorBlock(HWND_DESKTOP), &prfProfile); DebugE (D_SWT, "RootDesktop (current user-INI)", prfProfile.pszUserName); DebugE (D_SWT, "RootDesktop (current system-INI)", prfProfile.pszSysName); /* Namen der Stammprofile */ if (pShareInitOS2) { szUserIni = pShareInitOS2->pszRootUserIni; szSysIni = pShareInitOS2->pszRootSystemIni; } else szUserIni = szSysIni = ""; if (szUserIni[0] == '\0') if (DosScanEnv(USER_INI, &szUserIni)) goto root_false; if (szSysIni[0] == '\0') if (DosScanEnv (SYSTEM_INI, &szSysIni)) goto root_false; /* Vergleich der User-Ini Namen */ if (strcmpi (szUserIni, prfProfile.pszUserName) == 0) { WinAlarm (HWND_DESKTOP, WA_NOTE); MessageBox (IDS_ALREADYINROOT, IDS_INFORMATION, MB_ENTER | MB_INFORMATION); goto root_false; } free (prfProfile.pszUserName); free (prfProfile.pszSysName); /** Umschaltung **/ if (hevSammy) { pShareInitOS2->pszEnvironment[0] = '\0'; pShareInitOS2->pszEnvironment[1] = '\0'; pShareInitOS2->pszSystemIni[0] = '\0'; pShareInitOS2->pszUserIni[0] = '\0'; DebugE (D_SWT, "RootDesktop", "Ab hier macht Sammy weiter"); DosPostEventSem (hevSammy); } return TRUE; root_false: free (prfProfile.pszUserName); free (prfProfile.pszSysName); return FALSE; }
int main(VOID) { PSZ PathValue = ""; /* PATH environment variable */ UCHAR SearchResult[256] = ""; /* Result of PATH search */ APIRET rc = NO_ERROR; /* Return code */ rc=DosScanEnv("PATH",&PathValue); /* Get contents of PATH environment variable */ if (rc != NO_ERROR) { printf("DosScanEnv error: return code = %u\n",rc); return 1; } else { printf("PATH is:\n%s\n\n", PathValue); } /* Scan the current directory and path for the VIEW.EXE program. Ignore any errors from network drives which may not be in use. */ rc=DosSearchPath(SEARCH_CUR_DIRECTORY | SEARCH_IGNORENETERRS, PathValue, /* Path value just obtained */ "VIEW.EXE", /* Name of file to look for */ SearchResult, /* Result of the search */ sizeof(SearchResult)); /* Length of search buffer */ if (rc != NO_ERROR) { printf("DosSearchPath error: return code = %u\n",rc); return 1; } else { printf("Found desired file -- %s\n", SearchResult); } return NO_ERROR; }
extern "C" APIRET APIENTRY dll_initterm (HMODULE hmod, ULONG flag) { PSZ pszValue; char LoadError[256]; APIRET rc; // call C startup init first rc = __DLLstart_(hmod, flag); //dummy_print = &dummy; if (!rc) return 0; if (flag) { // terminate if (hmodBE) DosFreeModule(hmodBE); } else { //fatal = &_fatal; //db_print = &_db_print; // init rc = DosScanEnv("PM_COMM_BACKEND", &pszValue); if (rc) pszValue = "PMPIPE"; rc = DosLoadModule(LoadError, sizeof(LoadError), pszValue, &hmodBE); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 1, 0, (PFN *)&InitServerConnection); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 2, 0, (PFN *)&CloseServerConnection); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 3, 0, (PFN *)&startServerThreads); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 4, 0, (PFN *)&F_SendCmdToServer); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 5, 0, (PFN *)&F_SendDataToServer); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 6, 0, (PFN *)&F_RecvDataFromServer); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 7, 0, (PFN *)&F_SendGenCmdToServer); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 8, 0, (PFN *)&F_SendGenCmdDataToServer); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 9, 0, (PFN *)&F_RecvCmdFromClient); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 10, 0, (PFN *)&F_RecvDataFromClient); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 11, 0, (PFN *)&F_SendDataToClient); if (rc) return 0; /* rc = DosQueryProcAddr(hmodBE, 12, 0, (PFN *)&fatal); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 13, 0, (PFN *)&db_print); if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 14, 0, (PFN *)&FreePM_db_level); //FreePM_db_level = *addr; if (rc) return 0; rc = DosQueryProcAddr(hmodBE, 15, 0, (PFN *)&FreePM_debugLevels); if (rc) return 0; */ //memset(FreePM_debugLevels, 0, sizeof(FreePM_debugLevels)); // init osFree DosLogWrite output log_init(); } return 1; }
SOM_Scope HWND SOMLINK vptextc_InitHelpInstance(M_VPText *somSelf) { M_VPTextData *somThis = M_VPTextGetData(somSelf); HELPINIT hmiHelpData; /* Help initialization structure */ HWND hwndHelpInstance; CHAR pszHelp[CCHMAXPATH]; PSZ pszTemp; M_VPTextMethodDebug("M_VPText","vptextc_InitHelpInstance"); if (DosScanEnv("VISPRORX",&pszTemp)) { strcpy(pszHelp,"C:\\VISPRORX"); } else { strcpy(pszHelp,pszTemp); } /* endif */ strcat(pszHelp,"\\VPText.HLP"); /**********************************************************************/ /* IPF Initialization Structure */ /**********************************************************************/ /* size of initialization structure */ /**********************************************************************/ hmiHelpData.cb = sizeof(HELPINIT); /**********************************************************************/ /* store HM return code from init. */ /**********************************************************************/ hmiHelpData.ulReturnCode = (ULONG)NULL; /**********************************************************************/ /* no tutorial program */ /**********************************************************************/ hmiHelpData.pszTutorialName = NULL; /**********************************************************************/ /* indicates help table is defined in the RC file. */ /**********************************************************************/ hmiHelpData.phtHelpTable = 0; /**********************************************************************/ /* action bar is not tailored */ /**********************************************************************/ hmiHelpData.hmodAccelActionBarModule = 0; hmiHelpData.idAccelTable = 0; hmiHelpData.idActionBar = 0; /**********************************************************************/ /* help window title */ /**********************************************************************/ hmiHelpData.pszHelpWindowTitle = "VisPro/REXX Circular Slider Help Window"; /**********************************************************************/ /* help table in not in a DLL */ /**********************************************************************/ hmiHelpData.hmodHelpTableModule = 0; /**********************************************************************/ /* help panels ID is not displayed */ /**********************************************************************/ hmiHelpData.fShowPanelId = 0; /**********************************************************************/ /* library with help panels */ /**********************************************************************/ hmiHelpData.pszHelpLibraryName = pszHelp; /**********************************************************************/ /* Create Instance of IPF pass Anchor Block handle and address of IPF */ /* initialization structure, and check that creation was successful. */ /**********************************************************************/ hwndHelpInstance = WinCreateHelpInstance(0, &hmiHelpData); return (hwndHelpInstance); }
PRProcess * _PR_CreateOS2Process( const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr) { PRProcess *proc = NULL; char *cmdLine = NULL; char **newEnvp = NULL; char *envBlock = NULL; STARTDATA startData = {0}; APIRET rc; ULONG ulAppType = 0; PID pid = 0; char *pszComSpec; char pszEXEName[CCHMAXPATH] = ""; char pszFormatString[CCHMAXPATH]; char pszObjectBuffer[CCHMAXPATH]; char *pszFormatResult = NULL; /* * Variables for DosExecPgm */ char szFailed[CCHMAXPATH]; char *pszCmdLine = NULL; RESULTCODES procInfo; HFILE hStdIn = 0, hStdOut = 0, hStdErr = 0; HFILE hStdInSave = -1, hStdOutSave = -1, hStdErrSave = -1; proc = PR_NEW(PRProcess); if (!proc) { PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); goto errorExit; } if (assembleCmdLine(argv, &cmdLine) == -1) { PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); goto errorExit; } #ifdef MOZ_OS2_HIGH_MEMORY /* * DosQueryAppType() fails if path (the char* in the first argument) is in * high memory. If that is the case, the following moves it to low memory. */ if ((ULONG)path >= 0x20000000) { size_t len = strlen(path) + 1; char *copy = (char *)alloca(len); memcpy(copy, path, len); path = copy; } #endif if (envp == NULL) { newEnvp = NULL; } else { int i; int numEnv = 0; while (envp[numEnv]) { numEnv++; } newEnvp = (char **) PR_MALLOC((numEnv+1) * sizeof(char *)); for (i = 0; i <= numEnv; i++) { newEnvp[i] = envp[i]; } qsort((void *) newEnvp, (size_t) numEnv, sizeof(char *), compare); } if (assembleEnvBlock(newEnvp, &envBlock) == -1) { PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); goto errorExit; } rc = DosQueryAppType(path, &ulAppType); if (rc != NO_ERROR) { char *pszDot = strrchr(path, '.'); if (pszDot) { /* If it is a CMD file, launch the users command processor */ if (!stricmp(pszDot, ".cmd")) { rc = DosScanEnv("COMSPEC", (PSZ *)&pszComSpec); if (!rc) { strcpy(pszFormatString, "/C %s %s"); strcpy(pszEXEName, pszComSpec); ulAppType = FAPPTYP_WINDOWCOMPAT; } } } } if (ulAppType == 0) { PR_SetError(PR_UNKNOWN_ERROR, 0); goto errorExit; } if ((ulAppType & FAPPTYP_WINDOWAPI) == FAPPTYP_WINDOWAPI) { startData.SessionType = SSF_TYPE_PM; } else if (ulAppType & FAPPTYP_WINDOWCOMPAT) { startData.SessionType = SSF_TYPE_WINDOWABLEVIO; } else { startData.SessionType = SSF_TYPE_DEFAULT; } if (ulAppType & (FAPPTYP_WINDOWSPROT31 | FAPPTYP_WINDOWSPROT | FAPPTYP_WINDOWSREAL)) { strcpy(pszEXEName, "WINOS2.COM"); startData.SessionType = PROG_31_STDSEAMLESSVDM; strcpy(pszFormatString, "/3 %s %s"); } startData.InheritOpt = SSF_INHERTOPT_SHELL; if (pszEXEName[0]) { pszFormatResult = PR_MALLOC(strlen(pszFormatString)+strlen(path)+strlen(cmdLine)); sprintf(pszFormatResult, pszFormatString, path, cmdLine); startData.PgmInputs = pszFormatResult; } else { strcpy(pszEXEName, path); startData.PgmInputs = cmdLine; } startData.PgmName = pszEXEName; startData.Length = sizeof(startData); startData.Related = SSF_RELATED_INDEPENDENT; startData.ObjectBuffer = pszObjectBuffer; startData.ObjectBuffLen = CCHMAXPATH; startData.Environment = envBlock; if (attr) { /* On OS/2, there is really no way to pass file handles for stdin, * stdout, and stderr to a new process. Instead, we can make it * a child process and make the given file handles a copy of our * stdin, stdout, and stderr. The child process then inherits * ours, and we set ours back. Twisted and gross I know. If you * know a better way, please use it. */ if (attr->stdinFd) { hStdIn = 0; DosDupHandle(hStdIn, &hStdInSave); DosDupHandle((HFILE) attr->stdinFd->secret->md.osfd, &hStdIn); } if (attr->stdoutFd) { hStdOut = 1; DosDupHandle(hStdOut, &hStdOutSave); DosDupHandle((HFILE) attr->stdoutFd->secret->md.osfd, &hStdOut); } if (attr->stderrFd) { hStdErr = 2; DosDupHandle(hStdErr, &hStdErrSave); DosDupHandle((HFILE) attr->stderrFd->secret->md.osfd, &hStdErr); } /* * Build up the Command Line for DosExecPgm */ pszCmdLine = PR_MALLOC(strlen(pszEXEName) + strlen(startData.PgmInputs) + 3); sprintf(pszCmdLine, "%s%c%s%c", pszEXEName, '\0', startData.PgmInputs, '\0'); rc = DosExecPgm(szFailed, CCHMAXPATH, EXEC_ASYNCRESULT, pszCmdLine, envBlock, &procInfo, pszEXEName); PR_DELETE(pszCmdLine); /* Restore our old values. Hope this works */ if (hStdInSave != -1) { DosDupHandle(hStdInSave, &hStdIn); DosClose(hStdInSave); } if (hStdOutSave != -1) { DosDupHandle(hStdOutSave, &hStdOut); DosClose(hStdOutSave); } if (hStdErrSave != -1) { DosDupHandle(hStdErrSave, &hStdErr); DosClose(hStdErrSave); } if (rc != NO_ERROR) { /* XXX what error code? */ PR_SetError(PR_UNKNOWN_ERROR, rc); goto errorExit; } proc->md.pid = procInfo.codeTerminate; } else { /* * If no STDIN/STDOUT redirection is not needed, use DosStartSession * to create a new, independent session */ rc = DosStartSession(&startData, &ulAppType, &pid); if ((rc != NO_ERROR) && (rc != ERROR_SMG_START_IN_BACKGROUND)) { PR_SetError(PR_UNKNOWN_ERROR, rc); goto errorExit; } proc->md.pid = pid; } if (pszFormatResult) { PR_DELETE(pszFormatResult); } PR_DELETE(cmdLine); if (newEnvp) { PR_DELETE(newEnvp); } if (envBlock) { PR_DELETE(envBlock); } return proc; errorExit: if (cmdLine) { PR_DELETE(cmdLine); } if (newEnvp) { PR_DELETE(newEnvp); } if (envBlock) { PR_DELETE(envBlock); } if (proc) { PR_DELETE(proc); } return NULL; } /* _PR_CreateOS2Process */
int main (int argc, char *argv[]) { APIRET rc; PCHAR pcEnv; PRFPROFILE prfProfile; #ifdef DEBUG ulDebugMask = 0xFFFFFFFF; #endif /* DEBUG */ hab = WinInitialize(0); hmq = WinCreateMsgQueue(hab, 0); DebugS (1, "PM Interface initialized"); /* Shared Memory organisieren */ if (rc = DosGetNamedSharedMem ((PPVOID) &pShareInitOS2, SHARE_INITOS2, PAG_READ | PAG_WRITE)) { if (rc = DosAllocSharedMem( (PPVOID) &pShareInitOS2, // Pointer to shared mem SHARE_INITOS2, // Name CCHSHARE_INITOS2, // Size of shared mem PAG_COMMIT | PAG_READ | PAG_WRITE)) // Flags return(1); else { /* Shared Memory initialisieren */ memset (pShareInitOS2, '\0', CCHSHARE_INITOS2); pShareInitOS2->pszRegFile = (PCHAR) pShareInitOS2 + sizeof(*pShareInitOS2); strcpy (pShareInitOS2->pszRegFile, DosScanEnv (ENV_SYSTEM_INI, &pcEnv) ? "" : pcEnv); pShareInitOS2->pszRootUserIni = pShareInitOS2->pszRegFile + strlen(pShareInitOS2->pszRegFile) + 1; pShareInitOS2->pszRootSystemIni = pShareInitOS2->pszRootUserIni + 1; pShareInitOS2->pszUserIni = pShareInitOS2->pszRootSystemIni + 1; pShareInitOS2->pszSystemIni = pShareInitOS2->pszUserIni + CCHMAXPATH; pShareInitOS2->pszEnvironment = pShareInitOS2->pszSystemIni + CCHMAXPATH; } } DebugS (1, "Shared Memory initialized"); /* Semaphoren organisieren */ rc = DosOpenEventSem (HEV_SAMMY, &hevSammy); if( rc ) rc = DosCreateEventSem( HEV_SAMMY, // Name &hevSammy, // Pointer to sem 0, // Not used with named sems FALSE); // Initial state (FALSE = SET) else /* Sammy ist bereits installiert */ { pShareInitOS2->pszEnvironment[0] = '\0'; pShareInitOS2->pszEnvironment[1] = '\0'; pShareInitOS2->pszSystemIni[0] = '\0'; pShareInitOS2->pszUserIni[0] = '\0'; DosPostEventSem(hevSammy); goto Exit; } if( rc ) { intSammyRetCode = rc; goto Exit; } rc = DosOpenEventSem (HEV_PRFRESETLOCK, &hevPrfResetLock); if( rc ) rc = DosCreateEventSem( HEV_PRFRESETLOCK, // Name &hevPrfResetLock, // Pointer to sem 0, // Not used with named sems TRUE); // Initial state (TRUE = POSTED) if( rc ) { intSammyRetCode = rc; goto Exit; } DebugS (1, "Semaphores initialized"); ChangeWPS(pShareInitOS2->pszUserIni, pShareInitOS2->pszSystemIni); /* Hintergrundloop starten, das Shell mit aktueller Env. startet */ DosCreateThread (&tid1, (PFNTHREAD) thStartProg, (ULONG) ((argc > 1) ? argv[1] : ""), 0, THREADSTACK); DebugS (1, "Background loop started"); /* Hintergrundloop starten, das jeweils nach L�schen einer Semaphore */ /* einen prfReset initiiert */ DosCreateThread (&tid2, (PFNTHREAD) thSwitch, (ULONG) 0, 0, THREADSTACK); while (WinGetMsg (hab, &qmsg, 0, 0, 0)) WinDispatchMsg (hab, &qmsg); if (intSammyRetCode) { DosKillThread (tid1); DosKillThread (tid2); WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "WORKAREA=NO"); WinPostMsg(WinQueryWindow(HWND_DESKTOP, QW_BOTTOM), WM_CLOSE, 0, 0); WinAlarm (HWND_DESKTOP, WA_ERROR); prfProfile.pszSysName = (DosScanEnv (ENV_SYSTEM_INI, &pcEnv) ? "" : pcEnv); prfProfile.pszUserName = (DosScanEnv (ENV_USER_INI, &pcEnv) ? "" : pcEnv); prfProfile.cchUserName = strlen(prfProfile.pszUserName); prfProfile.cchSysName = strlen(prfProfile.pszSysName); DosSleep (1000); DosKillProcess( DKP_PROCESSTREE, ulShellID ); if ( !PrfReset(hab, &prfProfile)) WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "OPEN=ICON;WORKAREA=YES"); } Exit: WinDestroyMsgQueue(hmq); WinTerminate(hab); DebugS (1, "Application terminated"); return intSammyRetCode; }
void GTPMWin::backup() { #ifdef __TK21__ PSZ tempEnv; #else PCSZ tempEnv; #endif PSZ pstr; ULONG item, items; OString path; OString includes; OString excludes; OString batch; OString dirfile; OString str; ofstream incfile; ofstream excfile; ofstream batchfile; if ((DosScanEnv("TEMP", &tempEnv)) && (DosScanEnv("TMP", &tempEnv))) { path << GTPMApp::GTakPM->callName; path.rightCut('\\'); } else path << (PSZ)tempEnv; if (path.getText()[strlen(path) - 1] != '\\') path + "\\"; includes << path; includes + "gtmp.inc"; excludes << path; excludes + "gtmp.exc"; batch << path; batch + "gtmp.cmd"; dirfile << path; dirfile + "gtmp.dir"; path << "Cannot open: "; incfile.open(includes); if (!incfile) { path + includes; throw OPMException(path, 0); } excfile.open(excludes); if (!excfile) { path + excludes; throw OPMException(path, 0); } batchfile.open(batch); if (!batchfile) { path + batch; throw OPMException(path, 0); } // write includes-file items = Includes->queryItemCount(); for(item = 0; item < items; item++) if (Includes->queryItemText(str, item)) { pstr = str.getText(); while((pstr = strchr(pstr, '\\'))!=NULL) pstr[0] = '/'; incfile << ((PSZ)(strchr(str, ' ')+1)) << endl; } incfile.close(); // write excludes-file items = Excludes->queryItemCount(); for(item = 0; item < items; item++) if (Excludes->queryItemText(str, item)) { pstr = str.getText(); while((pstr = strchr(pstr, '\\'))!=NULL) pstr[0] = '/'; excfile << ((PSZ)(strchr(str, ' ')+1)) << endl; } excfile.close(); // write batchfile batchfile << "@ECHO OFF\n" << "echo Initializing Tape\n" << "tape stat >NUL 2>NUL\n" << "tape blocksize 0 stat sel 0 eraseq tell\n" << "echo Backup in progress\ntar -cEppP @" << (PSZ) includes << " --totals --exclude-from " << (PSZ) excludes << " -D " << (PSZ) dirfile << "\ntape stat\n" << "echo Compare in progress\n" << "tape rew >NUL 2>NUL\n" << "tar -dEppP\n" << "tape stat\n" << "echo Operation completed.\n"; batchfile.close(); tape->batch(batch); }
HB_BOOL hb_getenv_buffer( const char * szName, char * szBuffer, int nSize ) { HB_BOOL fRetVal; #if defined( HB_OS_WIN ) { LPTSTR lpName = HB_CHARDUP( szName ), lpBuffer; if( szBuffer != NULL || nSize > 0 ) lpBuffer = ( LPTSTR ) hb_xgrab( nSize * sizeof( TCHAR ) ); else lpBuffer = NULL; fRetVal = GetEnvironmentVariable( lpName, lpBuffer, nSize ) != 0; if( lpBuffer ) { if( fRetVal ) { lpBuffer[ nSize - 1 ] = TEXT( '\0' ); HB_OSSTRDUP2( lpBuffer, szBuffer, nSize - 1 ); } hb_xfree( lpBuffer ); } hb_xfree( lpName ); } #elif defined( HB_OS_OS2 ) { PSZ EnvValue = ( PSZ ) ""; char * pszNameFree = NULL; szName = hb_osEncodeCP( szName, &pszNameFree, NULL ); fRetVal = DosScanEnv( ( PCSZ ) szName, &EnvValue ) == NO_ERROR; if( pszNameFree ) hb_xfree( pszNameFree ); if( fRetVal && szBuffer != NULL && nSize != 0 ) hb_osStrDecode2( ( char * ) EnvValue, szBuffer, nSize - 1 ); } #else { char * pszTemp, * pszNameFree = NULL; szName = hb_osEncodeCP( szName, &pszNameFree, NULL ); pszTemp = getenv( szName ); if( pszNameFree ) hb_xfree( pszNameFree ); if( pszTemp != NULL ) { fRetVal = HB_TRUE; if( szBuffer != NULL && nSize != 0 ) hb_osStrDecode2( pszTemp, szBuffer, nSize - 1 ); } else fRetVal = HB_FALSE; } #endif if( ! fRetVal && szBuffer != NULL && nSize != 0 ) szBuffer[ 0 ] = '\0'; return fRetVal; }
static void *get_log_instance() { if (gLogInstance || gLogInstanceState == 2 || gInFork) return gLogInstance; /* Set a flag that we're going to init a new log instance */ if (!__atomic_cmpxchg32(&gLogInstanceState, 1, 0)) { /* * Another thread was faster in starting instance creation, wait for it * to complete in a simple spin loop (completion should be really quick). */ while (gLogInstanceState == 1) DosSleep(1); return gLogInstance; } void *logInstance = NULL; __LIBC_LOGGROUPS *logGroups = NULL; #if defined(TRACE_ENABLED) logGroups = &gLogGroups; __libc_LogGroupInit(&gLogGroups, "LIBCX_TRACE"); #endif /* Check if we are asked to log to console */ { PSZ dummy; gLogToConsole = DosScanEnv("LIBCX_TRACE_TO_CONSOLE", &dummy) == NO_ERROR; } char buf[CCHMAXPATH + 128]; if (gLogToConsole) { logInstance = __libc_LogInit(0, logGroups, "NUL"); if (logInstance) { /* * This is a dirty hack to write logs to stdout, * LIBC isn't capable of it on its own (@todo fix LIBC). */ typedef struct __libc_logInstance { /** Write Semaphore. */ HMTX hmtx; /** Filehandle. */ HFILE hFile; /** Api groups. */ __LIBC_PLOGGROUPS pGroups; } __LIBC_LOGINST, *__LIBC_PLOGINST; /* Sanity check (note: we use LIBC assert here to avoid recursion) */ assert(((__LIBC_PLOGINST)logInstance)->pGroups == logGroups); /* Duplicate STDOUT */ DosDupHandle(1, &((__LIBC_PLOGINST)logInstance)->hFile); } } else { /* * We don't query QSV_TIME_HIGH as it will remain 0 until 19-Jan-2038 and for * our purposes (generate an unique log name sorted by date) it's fine. */ ULONG time; DosQuerySysInfo(QSV_TIME_LOW, QSV_TIME_LOW, &time, sizeof(time)); // Get log directory (boot drive if no UNIXROOT) const char *path = "/var/log/libcx"; PSZ unixroot; if (DosScanEnv("UNIXROOT", &unixroot) != NO_ERROR) { ULONG drv; DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &drv, sizeof(drv)); unixroot = "C:"; unixroot[0] = '@' + drv; path = ""; } else { /* * Make sure the directory exists (no error checks here as a failure to * do so will pop up later in __libc_LogInit anyway). */ if (strlen(unixroot) >= CCHMAXPATH) return NULL; strcpy(buf, unixroot); strcat(buf, path); DosCreateDir(buf, NULL); } // Get program name char name[CCHMAXPATH]; PPIB ppib = NULL; DosGetInfoBlocks(NULL, &ppib); if (DosQueryModuleName(ppib->pib_hmte, sizeof(name), name) != NO_ERROR) return NULL; _remext(name); logInstance = __libc_LogInit(0, logGroups, "%s%s/%s-%08lx-%04x.log", unixroot, path, _getname(name), time, getpid()); } /* Bail out if we failed to create a log file at all */ if (!logInstance) { gLogInstanceState = 0; return NULL; } if (!gLogToConsole) { // Write out LIBCx info strcpy(buf, "LIBCx version : " VERSION_MAJ_MIN_BLD LIBCX_DEBUG_SUFFIX LIBCX_DEV_SUFFIX "\n"); strcat(buf, "LIBCx module : "); APIRET arc = DosQueryModuleName(ghModule, CCHMAXPATH, buf + strlen(buf)); if (arc == NO_ERROR) sprintf(buf + strlen(buf), " (hmod=%04lx)\n", ghModule); else sprintf(buf + strlen(buf), " <error %ld>\n", arc); __libc_LogRaw(logInstance, __LIBC_LOG_MSGF_FLUSH, buf, strlen(buf)); } /* * Finish initialization by storing the instance and setting the state to 2 * (this will unfreeze other threads that started instance creation, if any). */ gLogInstance = logInstance; gLogInstanceState = 2; return gLogInstance; }