/** * Adds a file or directory. * * @returns Program exit code. * @param pszPath The user supplied path to the file or directory. * @param pszCache The path to the cache. * @param fRecursive Whether to process directories recursively. * @param fOverwriteOnConflict Whether to overwrite existing cache entry on * conflict, or just leave it. */ static RTEXITCODE rtDbgSymCacheAddFileOrDir(const char *pszPath, const char *pszCache, bool fRecursive, bool fOverwriteOnConflict) { RT_NOREF1(fOverwriteOnConflict); RTDBGSYMCACHEADDCFG Cfg; Cfg.fRecursive = fRecursive; Cfg.pszCache = pszCache; Cfg.pszFilter = NULL; int rc; RTDBGSYMCACHEFILETYPE enmType = rtDbgSymCacheFigureType(pszPath); switch (enmType) { default: case RTDBGSYMCACHEFILETYPE_INVALID: return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid: '%s'", pszPath); case RTDBGSYMCACHEFILETYPE_DIR_FILTER: Cfg.pszFilter = RTPathFilename(pszPath); /* fall thru */ case RTDBGSYMCACHEFILETYPE_DIR: rc = rtDbgSymCacheAddDir(pszPath, &Cfg); break; case RTDBGSYMCACHEFILETYPE_DEBUG_FILE: rc = rtDbgSymCacheAddDebugFile(pszPath, &Cfg); break; case RTDBGSYMCACHEFILETYPE_IMAGE_FILE: rc = rtDbgSymCacheAddImageFile(pszPath, NULL /*pszExtraSuff*/, RTDBG_CACHE_UUID_MAP_DIR_IMAGES, &Cfg); break; case RTDBGSYMCACHEFILETYPE_DEBUG_BUNDLE: case RTDBGSYMCACHEFILETYPE_IMAGE_BUNDLE: { size_t cchPath = strlen(pszPath); size_t cchFilename = strlen(RTPathFilename(pszPath)); char szPathBuf[RTPATH_MAX]; if (cchPath < sizeof(szPathBuf)) { memcpy(szPathBuf, pszPath, cchPath + 1); if (enmType == RTDBGSYMCACHEFILETYPE_DEBUG_BUNDLE) rc = rtDbgSymCacheAddDebugBundle(szPathBuf, cchPath - cchFilename, cchFilename, &Cfg); else { RTDIRENTRYEX DirEntry; rc = rtDbgSymCacheAddImageBundle(szPathBuf, cchPath - cchFilename, cchFilename, &DirEntry, &Cfg); } } else rc = RTMsgErrorRc(VERR_FILENAME_TOO_LONG, "Filename too long: '%s'", pszPath); break; } case RTDBGSYMCACHEFILETYPE_IGNORE: rc = RTMsgErrorRc(VERR_INVALID_PARAMETER, "Invalid file: '%s'", pszPath); break; } return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; }
static void usbTestUsage(PRTSTREAM pStrm) { char szExec[RTPATH_MAX]; RTStrmPrintf(pStrm, "usage: %s [options]\n", RTPathFilename(RTProcGetExecutablePath(szExec, sizeof(szExec)))); RTStrmPrintf(pStrm, "\n"); RTStrmPrintf(pStrm, "options: \n"); for (unsigned i = 0; i < RT_ELEMENTS(g_aCmdOptions); i++) { const char *pszHelp; switch (g_aCmdOptions[i].iShort) { case 'h': pszHelp = "Displays this help and exit"; break; case 'd': pszHelp = "Use the specified test device"; break; default: pszHelp = "Option undocumented"; break; } char szOpt[256]; RTStrPrintf(szOpt, sizeof(szOpt), "%s, -%c", g_aCmdOptions[i].pszLong, g_aCmdOptions[i].iShort); RTStrmPrintf(pStrm, " %-20s%s\n", szOpt, pszHelp); } }
RTR3DECL(int) RTManifestWriteFilesBuf(void **ppvBuf, size_t *pcbSize, RTDIGESTTYPE enmDigestType, PRTMANIFESTTEST paFiles, size_t cFiles) { /* Validate input */ AssertPtrReturn(ppvBuf, VERR_INVALID_POINTER); AssertPtrReturn(pcbSize, VERR_INVALID_POINTER); AssertPtrReturn(paFiles, VERR_INVALID_POINTER); AssertReturn(cFiles > 0, VERR_INVALID_PARAMETER); const char *pcszDigestType; switch (enmDigestType) { case RTDIGESTTYPE_CRC32: pcszDigestType = "CRC32"; break; case RTDIGESTTYPE_CRC64: pcszDigestType = "CRC64"; break; case RTDIGESTTYPE_MD5: pcszDigestType = "MD5"; break; case RTDIGESTTYPE_SHA1: pcszDigestType = "SHA1"; break; case RTDIGESTTYPE_SHA256: pcszDigestType = "SHA256"; break; default: return VERR_INVALID_PARAMETER; } /* Calculate the size necessary for the memory buffer. */ size_t cbSize = 0; size_t cbMaxSize = 0; for (size_t i = 0; i < cFiles; ++i) { size_t cbTmp = strlen(RTPathFilename(paFiles[i].pszTestFile)) + strlen(paFiles[i].pszTestDigest) + strlen(pcszDigestType) + 6; cbMaxSize = RT_MAX(cbMaxSize, cbTmp); cbSize += cbTmp; } /* Create the memory buffer */ void *pvBuf = RTMemAlloc(cbSize); if (!pvBuf) return VERR_NO_MEMORY; /* Allocate a temporary string buffer. */ char *pszTmp = RTStrAlloc(cbMaxSize + 1); if (!pszTmp) { RTMemFree(pvBuf); return VERR_NO_MEMORY; } size_t cbPos = 0; for (size_t i = 0; i < cFiles; ++i) { size_t cch = RTStrPrintf(pszTmp, cbMaxSize + 1, "%s (%s)= %s\n", pcszDigestType, RTPathFilename(paFiles[i].pszTestFile), paFiles[i].pszTestDigest); memcpy(&((char*)pvBuf)[cbPos], pszTmp, cch); cbPos += cch; } RTStrFree(pszTmp); /* Results */ *ppvBuf = pvBuf; *pcbSize = cbSize; return VINF_SUCCESS; }
/** * Extract the extension pack name from the tarball path. * * @returns String containing the name on success, the caller must delete it. * NULL if no valid name was found or if we ran out of memory. * @param pszTarball The path to the tarball. */ RTCString *VBoxExtPackExtractNameFromTarballPath(const char *pszTarball) { /* * Skip ahead to the filename part and count the number of characters * that matches the criteria for a mangled extension pack name. */ const char *pszSrc = RTPathFilename(pszTarball); if (!pszSrc) return NULL; size_t off = 0; while (RT_C_IS_ALNUM(pszSrc[off]) || pszSrc[off] == '_') off++; /* * Check min and max name limits. */ if ( off > VBOX_EXTPACK_NAME_MAX_LEN || off < VBOX_EXTPACK_NAME_MIN_LEN) return NULL; /* * Return the unmangled name. */ return VBoxExtPackUnmangleName(pszSrc, off); }
/** * @callback_method_impl{FNDBGCCMD, The '.injecterror' command.} */ static DECLCALLBACK(int) pdmacEpFileErrorInject(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR pArgs, unsigned cArgs) { /* * Validate input. */ DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 3); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, pArgs[0].enmType == DBGCVAR_TYPE_STRING); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pArgs[1].enmType == DBGCVAR_TYPE_STRING); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 2, pArgs[2].enmType == DBGCVAR_TYPE_NUMBER); PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile; pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pUVM->pdm.s.apAsyncCompletionEndpointClass[PDMASYNCCOMPLETIONEPCLASSTYPE_FILE]; /* Syntax is "read|write <filename> <status code>" */ bool fWrite; if (!RTStrCmp(pArgs[0].u.pszString, "read")) fWrite = false; else if (!RTStrCmp(pArgs[0].u.pszString, "write")) fWrite = true; else return DBGCCmdHlpFail(pCmdHlp, pCmd, "invalid transfer direction '%s'", pArgs[0].u.pszString); int32_t rcToInject = (int32_t)pArgs[2].u.u64Number; if ((uint64_t)rcToInject != pArgs[2].u.u64Number) return DBGCCmdHlpFail(pCmdHlp, pCmd, "The status code '%lld' is out of range", pArgs[0].u.u64Number); /* * Search for the matching endpoint. */ RTCritSectEnter(&pEpClassFile->Core.CritSect); PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpClassFile->Core.pEndpointsHead; while (pEpFile) { if (!RTStrCmp(pArgs[1].u.pszString, RTPathFilename(pEpFile->Core.pszUri))) break; pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpFile->Core.pNext; } if (pEpFile) { /* * Do the job. */ if (fWrite) ASMAtomicXchgS32(&pEpFile->rcReqWrite, rcToInject); else ASMAtomicXchgS32(&pEpFile->rcReqRead, rcToInject); DBGCCmdHlpPrintf(pCmdHlp, "Injected %Rrc into '%s' for %s\n", (int)rcToInject, pArgs[1].u.pszString, pArgs[0].u.pszString); } RTCritSectLeave(&pEpClassFile->Core.CritSect); if (!pEpFile) return DBGCCmdHlpFail(pCmdHlp, pCmd, "No file with name '%s' found", pArgs[1].u.pszString); return VINF_SUCCESS; }
GLboolean renderspu_SystemVBoxCreateWindow(VisualInfo *pVisInfo, GLboolean fShowIt, WindowInfo *pWinInfo) { CRASSERT(pVisInfo); CRASSERT(pWinInfo); /* VirtualBox is the only frontend which support 3D right now. */ char pszName[256]; if (RTProcGetExecutablePath(pszName, sizeof(pszName))) /* Check for VirtualBox and VirtualBoxVM */ if (RTStrNICmp(RTPathFilename(pszName), "VirtualBox", 10) != 0) return GL_FALSE; pWinInfo->visual = pVisInfo; pWinInfo->window = NULL; pWinInfo->nativeWindow = NULL; pWinInfo->currentCtx = NULL; #ifdef __LP64__ NativeNSViewRef pParentWin = (NativeNSViewRef)render_spu_parent_window_id; #else /* __LP64__ */ NativeNSViewRef pParentWin = (NativeNSViewRef)(uint32_t)render_spu_parent_window_id; #endif /* __LP64__ */ cocoaViewCreate(&pWinInfo->window, pWinInfo, pParentWin, pVisInfo->visAttribs); if (fShowIt) renderspu_SystemShowWindow(pWinInfo, fShowIt); return GL_TRUE; }
RTDECL(int) RTCrX509Certificate_ReadFromFile(PRTCRX509CERTIFICATE pCertificate, const char *pszFilename, uint32_t fFlags, PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo) { AssertReturn(!fFlags, VERR_INVALID_FLAGS); PCRTCRPEMSECTION pSectionHead; int rc = RTCrPemReadFile(pszFilename, 0, g_aCertificateMarkers, RT_ELEMENTS(g_aCertificateMarkers), &pSectionHead, pErrInfo); if (RT_SUCCESS(rc)) { RTCRX509CERTIFICATE TmpCert; RTASN1CURSORPRIMARY PrimaryCursor; RTAsn1CursorInitPrimary(&PrimaryCursor, pSectionHead->pbData, (uint32_t)RT_MIN(pSectionHead->cbData, UINT32_MAX), pErrInfo, pAllocator, RTASN1CURSOR_FLAGS_DER, RTPathFilename(pszFilename)); rc = RTCrX509Certificate_DecodeAsn1(&PrimaryCursor.Cursor, 0, &TmpCert, "Cert"); if (RT_SUCCESS(rc)) { rc = RTCrX509Certificate_CheckSanity(&TmpCert, 0, pErrInfo, "Cert"); if (RT_SUCCESS(rc)) { rc = RTCrX509Certificate_Clone(pCertificate, &TmpCert, &g_RTAsn1DefaultAllocator); if (RT_SUCCESS(rc)) { if (pSectionHead->pNext || PrimaryCursor.Cursor.cbLeft) rc = VINF_ASN1_MORE_DATA; } } RTCrX509Certificate_Delete(&TmpCert); } RTCrPemFreeSections(pSectionHead); } return rc; }
int main(int argc, char **argv) { RTTEST hTest; int rc = RTTestInitAndCreate("tstRTFileGetSize-1", &hTest); if (rc) return rc; RTTestBanner(hTest); for (int i = 0; i < argc; i++) { char *pszNm = RTPathFilename(argv[i]); if (!pszNm) pszNm = argv[i]; test1(pszNm, argv[i]); } #ifdef RT_OS_WINDOWS test1("//./PhysicalDrive0", "//./PhysicalDrive0"); test1("//./HarddiskVolume1", "//./HarddiskVolume1"); test1("//./null", "//./nul"); #else test1("/dev/null", "/dev/null"); # ifdef RT_OS_LINUX test1("/dev/sda", "/dev/sda"); test1("/dev/sda1", "/dev/sda1"); test1("/dev/sda5", "/dev/sda5"); # endif #endif /* * Summary. */ return RTTestSummaryAndDestroy(hTest); }
/** * Opens the output file. * * @returns Command exit, error messages written using RTMsg*. * * @param pszFile The input filename. * @param pOpts The options, szOutput will be filled in by this * function on success. * @param phVfsIos Where to return the output stream handle. * * @remarks This is actually not quite the way we need to do things. * * First of all, we need a GZIP file system stream for a real GZIP * implementation, since there may be more than one file in the gzipped * file. * * Second, we need to open the output files as we encounter files in the input * file system stream. The gzip format contains timestamp and usually a * filename, the default is to use this name (see the --no-name * option). */ static RTEXITCODE gzipOpenOutput(const char *pszFile, PRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsIos) { int rc; if (!strcmp(pszFile, "-") || pOpts->fStdOut) { strcpy(pOpts->szOutput, "-"); if ( !pOpts->fForce && !pOpts->fDecompress && gzipIsStdHandleATty(RTHANDLESTD_OUTPUT)) return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Yeah, right. I'm not writing any compressed data to the terminal without --force.\n"); rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE, true /*fLeaveOpen*/, phVfsIos); if (RT_FAILURE(rc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening standard output: %Rrc", rc); } else { Assert(!RTVfsChainIsSpec(pszFile)); /* Construct an output filename. */ rc = RTStrCopy(pOpts->szOutput, sizeof(pOpts->szOutput), pszFile); if (RT_FAILURE(rc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: %Rrc", rc); if (pOpts->fDecompress) { /** @todo take filename from archive? */ size_t cchSuff = strlen(pOpts->pszSuff); Assert(cchSuff > 0); size_t cch = strlen(pOpts->szOutput); if ( cch <= cchSuff || strcmp(&pOpts->szOutput[cch - cchSuff], pOpts->pszSuff)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Input file does not end with: '%s'", pOpts->pszSuff); pOpts->szOutput[cch - cchSuff] = '\0'; if (!RTPathFilename(pOpts->szOutput)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: Input file name is all suffix."); } else { rc = RTStrCat(pOpts->szOutput, sizeof(pOpts->szOutput), pOpts->pszSuff); if (RT_FAILURE(rc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: %Rrc", rc); } /* Open the output file. */ uint32_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE; if (pOpts->fForce) fOpen |= RTFILE_O_CREATE_REPLACE; else fOpen |= RTFILE_O_CREATE; rc = RTVfsIoStrmOpenNormal(pOpts->szOutput, fOpen, phVfsIos); if (RT_FAILURE(rc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening output file '%s': %Rrc", pOpts->szOutput, rc); } return RTEXITCODE_SUCCESS; }
/** Check that the string is an absolute path to a file or print an error. */ bool checkAbsoluteFilePath(const char *pcszName, const char *pcszValue) { if (RTPathFilename(pcszValue) && RTPathStartsWithRoot(pcszValue)) return true; RTStrmPrintf(g_pStdErr, "%s: %s must be an absolute path of a file.\n", pcszName, pcszValue); return false; }
STDMETHODIMP VFSExplorer::Exists(ComSafeArrayIn(IN_BSTR, aNames), ComSafeArrayOut(BSTR, aExists)) { CheckComArgSafeArrayNotNull(aNames); AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); com::SafeArray<IN_BSTR> sfaNames(ComSafeArrayInArg(aNames)); std::list<BSTR> listExists; for (size_t a=0; a < sfaNames.size(); ++a) { std::list<VFSExplorer::Data::DirEntry>::const_iterator it; for (it = m->entryList.begin(); it != m->entryList.end(); ++it) { const VFSExplorer::Data::DirEntry &entry = (*it); if (entry.name == RTPathFilename(Utf8Str(sfaNames[a]).c_str())) { BSTR name; Bstr tmp(sfaNames[a]); /* gcc-3.3 cruft */ tmp.cloneTo(&name); listExists.push_back(name); } } } com::SafeArray<BSTR> sfaExists(listExists); sfaExists.detachTo(ComSafeArrayOutArg(aExists)); return S_OK; }
/** * Delay inject callback. */ static DECLCALLBACK(int) pdmacEpFileDelayInject(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pArgs, unsigned cArgs) { /* * Validate input. */ DBGC_CMDHLP_REQ_VM_RET(pCmdHlp, pCmd, pVM); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 3); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, pArgs[0].enmType == DBGCVAR_TYPE_STRING); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pArgs[1].enmType == DBGCVAR_TYPE_STRING); DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 2, pArgs[2].enmType == DBGCVAR_TYPE_NUMBER); PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile; pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pVM->pUVM->pdm.s.apAsyncCompletionEndpointClass[PDMASYNCCOMPLETIONEPCLASSTYPE_FILE]; /* Syntax is "read|write <filename> <status code>" */ bool fWrite; if (!RTStrCmp(pArgs[0].u.pszString, "read")) fWrite = false; else if (!RTStrCmp(pArgs[0].u.pszString, "write")) fWrite = true; else return DBGCCmdHlpFail(pCmdHlp, pCmd, "invalid transfer direction '%s'", pArgs[0].u.pszString); uint32_t msDelay = (uint32_t)pArgs[2].u.u64Number; if ((uint64_t)msDelay != pArgs[2].u.u64Number) return DBGCCmdHlpFail(pCmdHlp, pCmd, "The delay '%lld' is out of range", pArgs[0].u.u64Number); /* * Search for the matching endpoint. */ RTCritSectEnter(&pEpClassFile->Core.CritSect); PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpClassFile->Core.pEndpointsHead; while (pEpFile) { if (!RTStrCmp(pArgs[1].u.pszString, RTPathFilename(pEpFile->Core.pszUri))) break; pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpFile->Core.pNext; } if (pEpFile) { bool fXchg = ASMAtomicCmpXchgU32(&pEpFile->msDelay, msDelay, 0); if (fXchg) DBGCCmdHlpPrintf(pCmdHlp, "Injected delay of %u ms into '%s' for %s\n", msDelay, pArgs[1].u.pszString, pArgs[0].u.pszString); else DBGCCmdHlpPrintf(pCmdHlp, "Another delay for '%s' is still active, ignoring\n", pArgs[1].u.pszString); } RTCritSectLeave(&pEpClassFile->Core.CritSect); if (!pEpFile) return DBGCCmdHlpFail(pCmdHlp, pCmd, "No file with name '%s' found", pArgs[1].u.pszString); return VINF_SUCCESS; }
/** * Worker that add the image file to the right place. * * @returns IPRT status code. * @param pszPath Path to the image file. * @param pCfg Configuration data. * @param hLdrMod Image handle. * @param pszExtraSuff Optional extra suffix. Mach-O dSYM hack. * @param pszUuidMapDir Optional UUID map cache directory if the image * should be mapped by UUID. * The map is a Mac OS X debug feature supported by * the two native debuggers gdb and lldb. Look for * descriptions of DBGFileMappedPaths in the * com.apple.DebugSymbols in the user defaults. */ static int rtDbgSymCacheAddImageFileWorker(const char *pszPath, PCRTDBGSYMCACHEADDCFG pCfg, RTLDRMOD hLdrMod, const char *pszExtrSuff, const char *pszUuidMapDir) { /* * Determine which subdirectory to put the files in. */ RTUUID Uuid; PRTUUID pUuid = NULL; int rc; char szSubDir[48]; RTLDRFMT enmFmt = RTLdrGetFormat(hLdrMod); switch (enmFmt) { case RTLDRFMT_MACHO: { rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_UUID, &Uuid, sizeof(Uuid)); if (RT_FAILURE(rc)) return RTMsgErrorRc(rc, "Error quering image UUID from image '%s': %Rrc", pszPath, rc); rc = RTUuidToStr(&Uuid, szSubDir, sizeof(szSubDir)); if (RT_FAILURE(rc)) return RTMsgErrorRc(rc, "Error convering UUID for image '%s' to string: %Rrc", pszPath, rc); pUuid = &Uuid; break; } case RTLDRFMT_PE: { uint32_t uTimestamp; rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_TIMESTAMP_SECONDS, &uTimestamp, sizeof(uTimestamp)); if (RT_FAILURE(rc)) return RTMsgErrorRc(rc, "Error quering timestamp from image '%s': %Rrc", pszPath, rc); size_t cbImage = RTLdrSize(hLdrMod); if (cbImage == ~(size_t)0) return RTMsgErrorRc(rc, "Error quering size of image '%s': %Rrc", pszPath, rc); RTStrPrintf(szSubDir, sizeof(szSubDir), "%08X%x", uTimestamp, cbImage); break; } case RTLDRFMT_AOUT: return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Caching of a.out image has not yet been implemented: %s", pszPath); case RTLDRFMT_ELF: return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Caching of ELF image has not yet been implemented: %s", pszPath); case RTLDRFMT_LX: return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Caching of LX image has not yet been implemented: %s", pszPath); default: return RTMsgErrorRc(VERR_NOT_SUPPORTED, "Unknown loader format for '%s': %d", pszPath, enmFmt); } /* * Now add it. */ return rtDbgSymCacheAddOneFile(pszPath, RTPathFilename(pszPath), pszExtrSuff, szSubDir, pUuid, pszUuidMapDir, pCfg); }
static int rtCreateTempValidateTemplate(char *pszTemplate, char **ppszX, unsigned *pcXes) { /* * Validate input and count X'es. * * The X'es may be trailing, or they may be a cluster of 3 or more inside * the file name. */ AssertPtr(pszTemplate); AssertPtr(ppszX); AssertPtr(pcXes); unsigned cXes = 0; char *pszX = strchr(pszTemplate, '\0'); if ( pszX != pszTemplate && pszX[-1] != 'X') { /* look inside the file name. */ char *pszFilename = RTPathFilename(pszTemplate); if ( pszFilename && (size_t)(pszX - pszFilename) > 3) { char *pszXEnd = pszX - 1; pszFilename += 3; do { if ( pszXEnd[-1] == 'X' && pszXEnd[-2] == 'X' && pszXEnd[-3] == 'X') { pszX = pszXEnd - 3; cXes = 3; break; } } while (pszXEnd-- != pszFilename); } } /* count them */ while ( pszX != pszTemplate && pszX[-1] == 'X') { pszX--; cXes++; } /* fail if none found. */ if (!cXes) { AssertFailed(); return VERR_INVALID_PARAMETER; } *ppszX = pszX; *pcXes = cXes; return VINF_SUCCESS; }
int main(int argc, char **argv) { RTEXITCODE rcExit = RTTestInitAndCreate(RTPathFilename(argv[0]), &g_hTest); if (rcExit != RTEXITCODE_SUCCESS) return rcExit; RTTestBanner(g_hTest); testAPI(g_hTest); return RTTestSummaryAndDestroy(g_hTest); }
/** * Hack to strip of the architecture subdirectory from the exec dir. * * @returns See RTPathExecDir. * @param pszPath See RTPathExecDir. * @param cchPath See RTPathExecDir. */ DECLINLINE(int) rtPathSolarisArchHack(char *pszPath, size_t cchPath) { int rc = RTPathExecDir(pszPath, cchPath); if (RT_SUCCESS(rc)) { const char *pszLast = RTPathFilename(pszPath); if ( !strcmp(pszLast, "amd64") || !strcmp(pszLast, "i386")) RTPathStripFilename(pszPath); } return rc; }
RTR3DECL(int) RTManifestWriteFilesBuf(void **ppvBuf, size_t *pcbSize, PRTMANIFESTTEST paFiles, size_t cFiles) { /* Validate input */ AssertPtrReturn(ppvBuf, VERR_INVALID_POINTER); AssertPtrReturn(pcbSize, VERR_INVALID_POINTER); AssertPtrReturn(paFiles, VERR_INVALID_POINTER); AssertReturn(cFiles > 0, VERR_INVALID_PARAMETER); /* Calculate the size necessary for the memory buffer. */ size_t cbSize = 0; size_t cbMaxSize = 0; for (size_t i = 0; i < cFiles; ++i) { size_t cbTmp = strlen(RTPathFilename(paFiles[i].pszTestFile)) + strlen(paFiles[i].pszTestDigest) + 10; cbMaxSize = RT_MAX(cbMaxSize, cbTmp); cbSize += cbTmp; } /* Create the memory buffer */ void *pvBuf = RTMemAlloc(cbSize); if (!pvBuf) return VERR_NO_MEMORY; /* Allocate a temporary string buffer. */ char * pszTmp = RTStrAlloc(cbMaxSize + 1); size_t cbPos = 0; for (size_t i = 0; i < cFiles; ++i) { size_t cch = RTStrPrintf(pszTmp, cbMaxSize + 1, "SHA1 (%s)= %s\n", RTPathFilename(paFiles[i].pszTestFile), paFiles[i].pszTestDigest); memcpy(&((char*)pvBuf)[cbPos], pszTmp, cch); cbPos += cch; } RTStrFree(pszTmp); /* Results */ *ppvBuf = pvBuf; *pcbSize = cbSize; return VINF_SUCCESS; }
void GluePrintErrorContext(const char *pcszContext, const char *pcszSourceFile, uint32_t ulLine) { // pcszSourceFile comes from __FILE__ macro, which always contains the full path, // which we don't want to see printed: Utf8Str strFilename(RTPathFilename(pcszSourceFile)); Utf8Str str = Utf8StrFmt("Context: \"%s\" at line %d of file %s\n", pcszContext, ulLine, strFilename.c_str()); // print and log RTMsgError("%s", str.c_str()); Log(("%s", str.c_str())); }
int DnDURIList::AppendURIPath(const char *pszURI, uint32_t fFlags) { AssertPtrReturn(pszURI, VERR_INVALID_POINTER); /** @todo Check for string termination? */ #ifdef DEBUG_andy LogFlowFunc(("pszPath=%s, fFlags=0x%x\n", pszURI, fFlags)); #endif int rc = VINF_SUCCESS; /* Query the path component of a file URI. If this hasn't a * file scheme NULL is returned. */ char *pszFilePath = RTUriFilePath(pszURI, URI_FILE_FORMAT_AUTO); if (pszFilePath) { /* Add the path to our internal file list (recursive in * the case of a directory). */ size_t cbPathLen = RTPathStripTrailingSlash(pszFilePath); if (cbPathLen) { char *pszFileName = RTPathFilename(pszFilePath); if (pszFileName) { Assert(pszFileName >= pszFilePath); size_t cbBase = (fFlags & DNDURILIST_FLAGS_ABSOLUTE_PATHS) ? 0 /* Use start of path as root. */ : pszFileName - pszFilePath; char *pszRoot = &pszFilePath[cbBase]; m_lstRoot.append(pszRoot); #ifdef DEBUG_andy LogFlowFunc(("pszFilePath=%s, pszFileName=%s, pszRoot=%s\n", pszFilePath, pszFileName, pszRoot)); #endif rc = appendPathRecursive(pszFilePath, cbBase, fFlags); } else rc = VERR_NOT_FOUND; } else rc = VERR_INVALID_PARAMETER; RTStrFree(pszFilePath); } else rc = VERR_INVALID_PARAMETER; LogFlowFuncLeaveRC(rc); return rc; }
static int Error(const char *pszFormat, ...) { char szName[RTPATH_MAX]; if (!RTProcGetExecutablePath(szName, sizeof(szName))) strcpy(szName, "tstRTDigest"); RTStrmPrintf(g_pStdErr, "%s: error: ", RTPathFilename(szName)); va_list va; va_start(va, pszFormat); RTStrmPrintfV(g_pStdErr, pszFormat, va); va_end(va); return 1; }
RTDECL(ssize_t) RTLinuxSysFsGetLinkDestV(char *pszBuf, size_t cchBuf, const char *pszFormat, va_list va) { AssertReturnStmt(cchBuf >= 2, errno = EINVAL, -1); /* * Construct the filename and read the link. */ char szFilename[RTPATH_MAX]; int rc = rtLinuxSysFsConstructPath(szFilename, sizeof(szFilename), pszFormat, va); if (rc == -1) return -1; char szLink[RTPATH_MAX]; rc = readlink(szFilename, szLink, sizeof(szLink)); if (rc == -1) return -1; if ((size_t)rc > sizeof(szLink) - 1) { errno = ERANGE; return -1; } szLink[rc] = '\0'; /* readlink fun. */ /* * Extract the file name component and copy it into the return buffer. */ size_t cchName; const char *pszName = RTPathFilename(szLink); if (pszName) { cchName = strlen(pszName); /* = &szLink[rc] - pszName; */ if (cchName >= cchBuf) { errno = ERANGE; return -1; } memcpy(pszBuf, pszName, cchName + 1); } else { *pszBuf = '\0'; cchName = 0; } return cchName; }
static void tstDirCreateTemp(const char *pszSubTest, const char *pszTemplate, unsigned cTimes, bool fSkipXCheck) { RTTestISub(pszSubTest); /* Allocate the result array. */ char **papszNames = (char **)RTMemTmpAllocZ(cTimes * sizeof(char *)); RTTESTI_CHECK_RETV(papszNames != NULL); /* The test loop. */ unsigned i; for (i = 0; i < cTimes; i++) { int rc; char szName[RTPATH_MAX]; RTTESTI_CHECK_RC(rc = RTPathAppend(strcpy(szName, g_szTempPath), sizeof(szName), pszTemplate), VINF_SUCCESS); if (RT_FAILURE(rc)) break; RTTESTI_CHECK(papszNames[i] = RTStrDup(szName)); if (!papszNames[i]) break; rc = RTDirCreateTemp(papszNames[i]); if (rc != VINF_SUCCESS) { RTTestIFailed("RTDirCreateTemp(%s) call #%u -> %Rrc\n", szName, i, rc); RTStrFree(papszNames[i]); papszNames[i] = NULL; break; } RTTestIPrintf(RTTESTLVL_DEBUG, "%s\n", papszNames[i]); RTTESTI_CHECK_MSG(strlen(szName) == strlen(papszNames[i]), ("szName %s\nReturned %s\n", szName, papszNames[i])); if (!fSkipXCheck) RTTESTI_CHECK_MSG(strchr(RTPathFilename(papszNames[i]), 'X') == NULL, ("szName %s\nReturned %s\n", szName, papszNames[i])); } /* cleanup */ while (i-- > 0) { RTTESTI_CHECK_RC(RTDirRemove(papszNames[i]), VINF_SUCCESS); RTStrFree(papszNames[i]); } RTMemTmpFree(papszNames); }
RTDECL(int) RTDirOpenFiltered(PRTDIR *ppDir, const char *pszPath, RTDIRFILTER enmFilter, uint32_t fOpen) { /* * Validate input. */ AssertMsgReturn(VALID_PTR(ppDir), ("%p\n", ppDir), VERR_INVALID_POINTER); AssertMsgReturn(VALID_PTR(pszPath), ("%p\n", pszPath), VERR_INVALID_POINTER); AssertReturn(!(fOpen & ~RTDIROPEN_FLAGS_NO_SYMLINKS), VERR_INVALID_FLAGS); switch (enmFilter) { case RTDIRFILTER_UNIX: case RTDIRFILTER_UNIX_UPCASED: AssertMsgFailed(("%d is not implemented!\n", enmFilter)); return VERR_NOT_IMPLEMENTED; case RTDIRFILTER_NONE: case RTDIRFILTER_WINNT: break; default: AssertMsgFailedReturn(("%d\n", enmFilter), VERR_INVALID_PARAMETER); } /* * Find the last component, i.e. where the filter criteria starts and the dir name ends. */ const char *pszFilter; if (enmFilter == RTDIRFILTER_NONE) pszFilter = NULL; else { pszFilter = RTPathFilename(pszPath); if (!pszFilter) /* trailing slash => directory to read => no filter. */ enmFilter = RTDIRFILTER_NONE; } /* * Call worker common with RTDirOpen which will verify the path, allocate * and initialize the handle, and finally call the backend. */ int rc = rtDirOpenCommon(ppDir, pszPath, pszFilter, enmFilter); LogFlow(("RTDirOpenFiltered(%p:{%p}, %p:{%s}, %d): return %Rrc\n", ppDir, *ppDir, pszPath, pszPath, enmFilter, rc)); return rc; }
/** * Figure file type based on name, will stat the file/dir. * * @returns File type. * @param pszPath The path to the file/dir to figure. */ static RTDBGSYMCACHEFILETYPE rtDbgSymCacheFigureType(const char *pszPath) { const char *pszName = RTPathFilename(pszPath); /* Trailing slash. */ if (!pszName) return RTDBGSYMCACHEFILETYPE_DIR; /* Wildcard means listing directory and filtering. */ if (strpbrk(pszName, "?*")) return RTDBGSYMCACHEFILETYPE_DIR_FILTER; /* Get object info, following links. */ RTFSOBJINFO ObjInfo; int rc = RTPathQueryInfoEx(pszPath, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK); if (RT_FAILURE(rc)) return RTDBGSYMCACHEFILETYPE_INVALID; return rtDbgSymCacheFigureType2(pszPath, &ObjInfo); }
void XmlFileWriter::write(const char *pcszFilename, bool fSafe) { if (!fSafe) writeInternal(pcszFilename, fSafe); else { /* Empty string and directory spec must be avoid. */ if (RTPathFilename(pcszFilename) == NULL) throw xml::LogicError(RT_SRC_POS); /* Construct both filenames first to ease error handling. */ char szTmpFilename[RTPATH_MAX]; int rc = RTStrCopy(szTmpFilename, sizeof(szTmpFilename) - strlen(s_pszTmpSuff), pcszFilename); if (RT_FAILURE(rc)) throw EIPRTFailure(rc, "RTStrCopy"); strcat(szTmpFilename, s_pszTmpSuff); char szPrevFilename[RTPATH_MAX]; rc = RTStrCopy(szPrevFilename, sizeof(szPrevFilename) - strlen(s_pszPrevSuff), pcszFilename); if (RT_FAILURE(rc)) throw EIPRTFailure(rc, "RTStrCopy"); strcat(szPrevFilename, s_pszPrevSuff); /* Write the XML document to the temporary file. */ writeInternal(szTmpFilename, fSafe); /* Make a backup of any existing file (ignore failure). */ uint64_t cbPrevFile; rc = RTFileQuerySize(pcszFilename, &cbPrevFile); if (RT_SUCCESS(rc) && cbPrevFile >= 16) RTFileRename(pcszFilename, szPrevFilename, RTPATHRENAME_FLAGS_REPLACE); /* Commit the temporary file. Just leave the tmp file behind on failure. */ rc = RTFileRename(szTmpFilename, pcszFilename, RTPATHRENAME_FLAGS_REPLACE); if (RT_FAILURE(rc)) throw EIPRTFailure(rc, "Failed to replace '%s' with '%s'", pcszFilename, szTmpFilename); /* Flush the directory changes (required on linux at least). */ RTPathStripFilename(szTmpFilename); rc = RTDirFlush(szTmpFilename); AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_SUPPORTED || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc)); } }
/** * Converts Unix attributes to Dos-style attributes. * * @returns File mode mask. * @param fMode The mode mask containing dos-style attributes only. * @param pszName The filename which this applies to (hidden check). * @param cbName The length of that filename. (optional, set 0) */ RTFMODE rtFsModeFromUnix(RTFMODE fMode, const char *pszName, size_t cbName) { NOREF(cbName); fMode &= RTFS_UNIX_MASK; if (!(fMode & (RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH))) fMode |= RTFS_DOS_READONLY; if (RTFS_IS_DIRECTORY(fMode)) fMode |= RTFS_DOS_DIRECTORY; if (!(fMode & RTFS_DOS_MASK)) fMode |= RTFS_DOS_NT_NORMAL; if (!(fMode & RTFS_DOS_HIDDEN) && pszName) { pszName = RTPathFilename(pszName); if (pszName && *pszName == '.') fMode |= RTFS_DOS_HIDDEN; } return fMode; }
HRESULT VFSExplorer::exists(const std::vector<com::Utf8Str> &aNames, std::vector<com::Utf8Str> &aExists) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); aExists.resize(0); for (size_t i=0; i < aNames.size(); ++i) { std::list<VFSExplorer::Data::DirEntry>::const_iterator it; for (it = m->entryList.begin(); it != m->entryList.end(); ++it) { const VFSExplorer::Data::DirEntry &entry = (*it); if (entry.name == RTPathFilename(aNames[i].c_str())) aExists.push_back(aNames[i]); } } return S_OK; }
/** * Construct a dot svn filename for the file being rewritten. * * @returns IPRT status code. * @param pState The rewrite state (for the name). * @param pszDir The directory, including ".svn/". * @param pszSuff The filename suffix. * @param pszDst The output buffer. RTPATH_MAX in size. */ static int scmSvnConstructName(PSCMRWSTATE pState, const char *pszDir, const char *pszSuff, char *pszDst) { strcpy(pszDst, pState->pszFilename); /* ASSUMES sizeof(szBuf) <= sizeof(szPath) */ RTPathStripFilename(pszDst); int rc = RTPathAppend(pszDst, RTPATH_MAX, pszDir); if (RT_SUCCESS(rc)) { rc = RTPathAppend(pszDst, RTPATH_MAX, RTPathFilename(pState->pszFilename)); if (RT_SUCCESS(rc)) { size_t cchDst = strlen(pszDst); size_t cchSuff = strlen(pszSuff); if (cchDst + cchSuff < RTPATH_MAX) { memcpy(&pszDst[cchDst], pszSuff, cchSuff + 1); return VINF_SUCCESS; } else rc = VERR_BUFFER_OVERFLOW; } } return rc; }
/** * Figure the type of a file/dir based on path and FS object info. * * @returns The type. * @param pszPath The path to the file/dir. * @param pObjInfo The object information, symlinks followed. */ static RTDBGSYMCACHEFILETYPE rtDbgSymCacheFigureType2(const char *pszPath, PCRTFSOBJINFO pObjInfo) { const char *pszName = RTPathFilename(pszPath); const char *pszExt = RTPathSuffix(pszName); if (pszExt) pszExt++; else pszExt = ""; if ( RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode) || (pObjInfo->Attr.fMode & RTFS_DOS_DIRECTORY)) /** @todo OS X samba reports reparse points in /Volumes/ that we cannot resolve. */ { /* Skip directories shouldn't bother with. */ if ( !RTStrICmp(pszName, ".Trashes") || !RTStrICmp(pszName, ".$RESCYCLE.BIN") || !RTStrICmp(pszName, "System.kext") /* Usually only plugins here, so skip it. */ ) return RTDBGSYMCACHEFILETYPE_IGNORE; /* Directories can also be bundles on the mac. */ if (!RTStrICmp(pszExt, "dSYM")) return RTDBGSYMCACHEFILETYPE_DEBUG_BUNDLE; for (unsigned i = 0; i < RT_ELEMENTS(g_apszBundleSuffixes) - 1; i++) if (!RTStrICmp(pszExt, &g_apszBundleSuffixes[i][1])) return RTDBGSYMCACHEFILETYPE_IMAGE_BUNDLE; return RTDBGSYMCACHEFILETYPE_DIR; } if (!RTFS_IS_FILE(pObjInfo->Attr.fMode)) return RTDBGSYMCACHEFILETYPE_INVALID; /* Select image vs debug info based on extension. */ if ( !RTStrICmp(pszExt, "pdb") || !RTStrICmp(pszExt, "dbg") || !RTStrICmp(pszExt, "sym") || !RTStrICmp(pszExt, "dwo") || !RTStrICmp(pszExt, "dwp") || !RTStrICmp(pszExt, "debug") || !RTStrICmp(pszExt, "dsym") || !RTStrICmp(pszExt, "dwarf") || !RTStrICmp(pszExt, "map") || !RTStrICmp(pszExt, "cv")) return RTDBGSYMCACHEFILETYPE_DEBUG_FILE; /* Filter out a bunch of files which obviously shouldn't be images. */ if ( !RTStrICmp(pszExt, "txt") || !RTStrICmp(pszExt, "html") || !RTStrICmp(pszExt, "htm") || !RTStrICmp(pszExt, "rtf") || !RTStrICmp(pszExt, "zip") || !RTStrICmp(pszExt, "doc") || !RTStrICmp(pszExt, "gz") || !RTStrICmp(pszExt, "bz2") || !RTStrICmp(pszExt, "xz") || !RTStrICmp(pszExt, "kmk") || !RTStrICmp(pszExt, "c") || !RTStrICmp(pszExt, "cpp") || !RTStrICmp(pszExt, "h") || !RTStrICmp(pszExt, "m") || !RTStrICmp(pszExt, "mm") || !RTStrICmp(pszExt, "asm") || !RTStrICmp(pszExt, "S") || !RTStrICmp(pszExt, "inc") || !RTStrICmp(pszExt, "sh") ) return RTDBGSYMCACHEFILETYPE_IGNORE; if ( !RTStrICmp(pszName, "Makefile") || !RTStrICmp(pszName, "GNUmakefile") || !RTStrICmp(pszName, "createsymbolfiles") || !RTStrICmp(pszName, "kgmacros") ) return RTDBGSYMCACHEFILETYPE_IGNORE; return RTDBGSYMCACHEFILETYPE_IMAGE_FILE; }
/** * Searches for the file in the path. * * The file is first tested without any path modification, then we walk the path * looking in each directory. * * @returns VBox status code. * @param pszFilename The file to search for. * @param pszPath The search path. * @param pfnOpen The open callback function. * @param pvUser User argument for the callback. */ static int dbgfR3AsSearchPath(const char *pszFilename, const char *pszPath, PFNDBGFR3ASSEARCHOPEN pfnOpen, void *pvUser) { char szFound[RTPATH_MAX]; /* Check the filename length. */ size_t const cchFilename = strlen(pszFilename); if (cchFilename >= sizeof(szFound)) return VERR_FILENAME_TOO_LONG; const char *pszName = RTPathFilename(pszFilename); if (!pszName) return VERR_IS_A_DIRECTORY; size_t const cchName = strlen(pszName); /* * Try default location first. */ memcpy(szFound, pszFilename, cchFilename + 1); int rc = pfnOpen(szFound, pvUser); if (RT_SUCCESS(rc)) return rc; /* * Walk the search path. */ const char *psz = pszPath; while (*psz) { /* Skip leading blanks - no directories with leading spaces, thank you. */ while (RT_C_IS_BLANK(*psz)) psz++; /* Find the end of this element. */ const char *pszNext; const char *pszEnd = strchr(psz, ';'); if (!pszEnd) pszEnd = pszNext = strchr(psz, '\0'); else pszNext = pszEnd + 1; if (pszEnd != psz) { size_t const cch = pszEnd - psz; if (cch + 1 + cchName < sizeof(szFound)) { /** @todo RTPathCompose, RTPathComposeN(). This code isn't right * for 'E:' on DOS systems. It may also create unwanted double slashes. */ memcpy(szFound, psz, cch); szFound[cch] = '/'; memcpy(szFound + cch + 1, pszName, cchName + 1); int rc2 = pfnOpen(szFound, pvUser); if (RT_SUCCESS(rc2)) return rc2; if ( rc2 != rc && ( rc == VERR_FILE_NOT_FOUND || rc == VERR_OPEN_FAILED)) rc = rc2; } } /* advance */ psz = pszNext; } /* * Walk the path once again, this time do a depth search. */ /** @todo do a depth search using the specified path. */ /* failed */ return rc; }