Changeset 2868


Ignore:
Timestamp:
Nov 11, 2006, 1:48:54 PM (19 years ago)
Author:
bird
Message:

Did the remaining search bit (I hope).

Location:
trunk/kLdr
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/kLdr/kLdr.h

    r2867 r2868  
    10311031/** @name kLdrModPE status codes
    10321032 * @{ */
    1033 #define KLDR_ERR_BASE_PE                                    (KLDR_ERR_BASE + 96)
     1033#define KLDR_ERR_BASE_PE                                    (KLDR_ERR_BASE + 59)
    10341034/** The machine isn't supported by the interpreter. */
    10351035#define KLDR_ERR_PE_UNSUPPORTED_MACHINE                     (KLDR_ERR_BASE_PE + 0)
     
    10501050/** @} */
    10511051
     1052/** End of the valid kLdr status codes. */
     1053#define KLDR_ERR_END                                        (KLDR_ERR_BASE_PE + 8)
    10521054
    10531055/** @} */
  • trunk/kLdr/kLdrDyld.c

    r2867 r2868  
    770770    unsigned        cEntries;
    771771    int             rc = 0;
     772
     773    /* Prerequisites are always global and they just aren't executables. */
     774    fFlags &= ~(KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE | KLDRDYLD_LOAD_FLAGS_EXECUTABLE);
    772775
    773776    /* push the first entry. */
  • trunk/kLdr/kLdrDyldFind.c

    r2867 r2868  
    7373
    7474/*******************************************************************************
     75*   Structures and Typedefs                                                    *
     76*******************************************************************************/
     77/**
     78 * Search arguments.
     79 * This avoids a bunch of unnecessary string lengths and calculations.
     80 */
     81typedef struct KLDRDYLDFINDARGS
     82{
     83    const char *pszName;
     84    size_t      cchName;
     85
     86    const char *pszPrefix;
     87    size_t      cchPrefix;
     88
     89    const char *pszSuffix;
     90    size_t      cchSuffix;
     91
     92    size_t      cchMaxLength;
     93
     94    KLDRDYLDSEARCH  enmSearch;
     95    uint32_t        fFlags;
     96    PPKLDRRDR       ppRdr;
     97} KLDRDYLDFINDARGS, *PKLDRDYLDFINDARGS;
     98
     99typedef const KLDRDYLDFINDARGS *PCKLDRDYLDFINDARGS;
     100
     101
     102/*******************************************************************************
    75103*   Global Variables                                                           *
    76104*******************************************************************************/
     
    170198                                KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr);
    171199static int kldrDyldFindTryOpen(const char *pszFilename, PPKLDRRDR ppRdr);
    172 static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, const char *pszName, const char *pszPrefix,
    173                                    const char *pszSuffix, PPKLDRRDR ppRdr);
    174 static int kldrDyldFindEnumeratePath(const char *pszSearchPath, const char *pszName, const char *pszPrefix,
    175                                      const char *pszSuffix, PPKLDRRDR ppRdr);
     200static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, PCKLDRDYLDFINDARGS pArgs);
     201static int kldrDyldFindEnumeratePath(const char *pszSearchPath, PCKLDRDYLDFINDARGS pArgs);
     202static int kldrDyldFindGetDefaults(KLDRDYLDSEARCH *penmSearch, const char **pszPrefix, const char **pszSuffix, const char *pszName);
    176203
    177204
     
    325352         * Create a new module.
    326353         */
    327         rc = kldrDyldModCreate(pRdr, ppMod);
     354        rc = kldrDyldModCreate(pRdr, fFlags, ppMod);
    328355        if (rc)
    329356            kLdrRdrClose(pRdr);
     
    350377{
    351378    int rc;
    352 
    353     /*
    354      * Fixup search method alias.
    355      */
    356     if (enmSearch == KLDRDYLD_SEARCH_HOST)
    357         enmSearch = KLDRDYLD_SEARCH_KLDR; /** @todo find more suitable place for this. */
     379    KLDRDYLDFINDARGS Args;
     380
     381    /*
     382     * Initialize the argument structure and resolve defaults.
     383     */
     384    Args.enmSearch = enmSearch;
     385    Args.pszPrefix = pszPrefix;
     386    Args.pszSuffix = pszSuffix;
     387    rc = kldrDyldFindGetDefaults(&Args.enmSearch, &Args.pszPrefix, &Args.pszSuffix, pszName);
     388    if (rc)
     389        return rc;
     390    Args.pszName = pszName;
     391    Args.cchName = kLdrHlpStrLen(pszName);
     392    Args.cchPrefix = Args.pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
     393    Args.cchSuffix = Args.pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
     394    Args.cchMaxLength = Args.cchName + Args.cchSuffix + Args.cchPrefix;
     395    Args.fFlags = fFlags;
     396    Args.ppRdr = ppRdr;
    358397
    359398    /*
    360399     * Apply the specified search method.
    361400     */
     401/** @todo get rid of the strlen() on the various paths here! */
    362402    switch (enmSearch)
    363403    {
    364404        case KLDRDYLD_SEARCH_KLDR:
    365405        {
    366             if (!pszPrefix && kLdrDyldDefPrefix[0])
    367                 pszPrefix = kLdrDyldDefPrefix;
    368             if (!pszSuffix && kLdrDyldDefSuffix[0])
    369                 pszSuffix = kLdrDyldDefSuffix;
    370 
    371406            if (kLdrDyldAppDir[0] != '\0')
    372407            {
    373                 rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kLdrHlpStrLen(kLdrDyldAppDir),
    374                                              pszName, pszPrefix, pszSuffix, ppRdr);
     408                rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kLdrHlpStrLen(kLdrDyldAppDir), &Args);
    375409                if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    376410                    break;
    377411            }
    378             rc = kldrDyldFindTryOpenPath(".", 1, pszName, pszPrefix, pszSuffix, ppRdr);
     412            rc = kldrDyldFindTryOpenPath(".", 1, &Args);
    379413            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    380414                break;
    381             rc = kldrDyldFindEnumeratePath(kLdrDyldPath, pszName, pszPrefix, pszSuffix, ppRdr);
     415            rc = kldrDyldFindEnumeratePath(kLdrDyldPath, &Args);
    382416            break;
    383417        }
     
    385419        case KLDRDYLD_SEARCH_OS2:
    386420        {
    387             if (!pszSuffix)
    388                 pszSuffix = ".dll";
    389 
    390             rc = kldrDyldFindEnumeratePath(kLdrDyldOS2BeginLibpath, pszName, pszPrefix, pszSuffix, ppRdr);
     421            rc = kldrDyldFindEnumeratePath(kLdrDyldOS2BeginLibpath, &Args);
    391422            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    392423                break;
    393             rc = kldrDyldFindEnumeratePath(kLdrDyldOS2Libpath, pszName, pszPrefix, pszSuffix, ppRdr);
     424            rc = kldrDyldFindEnumeratePath(kLdrDyldOS2Libpath, &Args);
    394425            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    395426                break;
    396             rc = kldrDyldFindEnumeratePath(kLdrDyldOS2EndLibpath, pszName, pszPrefix, pszSuffix, ppRdr);
     427            rc = kldrDyldFindEnumeratePath(kLdrDyldOS2EndLibpath, &Args);
    397428            break;
    398429        }
     
    401432        case KLDRDYLD_SEARCH_WINDOWS_ALTERED:
    402433        {
    403             if (!pszSuffix)
    404                 pszSuffix = ".dll";
    405 
    406             rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsAppDir, kLdrHlpStrLen(kLdrDyldWindowsAppDir),
    407                                          pszName, pszPrefix, pszSuffix, ppRdr);
     434            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsAppDir, kLdrHlpStrLen(kLdrDyldWindowsAppDir), &Args);
    408435            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    409436                break;
    410437            if (enmSearch == KLDRDYLD_SEARCH_WINDOWS_ALTERED)
    411438            {
    412                 rc = kldrDyldFindTryOpenPath(".", 1, pszName, pszPrefix, pszSuffix, ppRdr);
     439                rc = kldrDyldFindTryOpenPath(".", 1, &Args);
    413440                if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    414441                    break;
    415442            }
    416             rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsSystemDir, kLdrHlpStrLen(kLdrDyldWindowsSystemDir),
    417                                          pszName, pszPrefix, pszSuffix, ppRdr);
     443            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsSystemDir, kLdrHlpStrLen(kLdrDyldWindowsSystemDir), &Args);
    418444            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    419445                break;
    420             rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsDir, kLdrHlpStrLen(kLdrDyldWindowsDir),
    421                                          pszName, pszPrefix, pszSuffix, ppRdr);
     446            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsDir, kLdrHlpStrLen(kLdrDyldWindowsDir), &Args);
    422447            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    423448                break;
    424449            if (enmSearch == KLDRDYLD_SEARCH_WINDOWS)
    425450            {
    426                 rc = kldrDyldFindTryOpenPath(".", 1, pszName, pszPrefix, pszSuffix, ppRdr);
     451                rc = kldrDyldFindTryOpenPath(".", 1, &Args);
    427452                if (rc != KLDR_ERR_MODULE_NOT_FOUND)
    428453                    break;
    429454            }
    430             rc = kldrDyldFindEnumeratePath(kLdrDyldWindowsPath, pszName, pszPrefix, pszSuffix, ppRdr);
     455            rc = kldrDyldFindEnumeratePath(kLdrDyldWindowsPath, &Args);
    431456            break;
    432457        }
     
    434459        case KLDRDYLD_SEARCH_UNIX_COMMON:
    435460        {
    436             rc = kldrDyldFindEnumeratePath(kLdrDyldUnixLibraryPath, pszName, pszPrefix, pszSuffix, ppRdr);
     461            rc = kldrDyldFindEnumeratePath(kLdrDyldUnixLibraryPath, &Args);
    437462            if (rc == KLDR_ERR_MODULE_NOT_FOUND)
    438463                break;
    439             rc = kldrDyldFindEnumeratePath(kLdrDyldUnixSystemLibraryPath, pszName, pszPrefix, pszSuffix, ppRdr);
     464            rc = kldrDyldFindEnumeratePath(kLdrDyldUnixSystemLibraryPath, &Args);
    440465            break;
    441466        }
    442467
    443         default:
    444             KLDRDYLDFIND_ASSERT(!"invalid search method");
    445             return KLDR_ERR_INVALID_PARAMETER;
    446 
     468        default: kldrHlpAssert(!"internal error"); return -1;
    447469    }
    448470    return rc;
     
    461483static int kldrDyldFindTryOpen(const char *pszFilename, PPKLDRRDR ppRdr)
    462484{
     485    int rc;
     486
     487    /*
     488     * Try open the file.
     489     */
     490    rc = kLdrRdrOpen(ppRdr, pszFilename);
     491    if (!rc)
     492        return 0;
     493    /** @todo deal with return codes properly. */
     494    if (rc >= KLDR_ERR_BASE && rc <= KLDR_ERR_END)
     495        return rc;
     496
    463497    return KLDR_ERR_MODULE_NOT_FOUND;
    464498}
     
    471505 * @param   pchPath     The directory path - this doesn't have to be null terminated.
    472506 * @param   cchPath     The length of the path.
    473  * @param   pszName     The base name.
    474  * @param   pszPrefix   The prefix to use. (optional)
    475  * @param   pszSuffix   The suffix to use. (optional)
    476  *                      Will try without first if the name contains a suffix already.
    477  * @param   ppRdr       See kldrDyldFindTryOpen.
     507 * @param   pArgs       The search argument structure.
    478508 *
    479509 * @returns See kldrDyldFindTryOpen
    480510 */
    481 static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, const char *pszName, const char *pszPrefix,
    482                                    const char *pszSuffix, PPKLDRRDR ppRdr)
     511static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, PCKLDRDYLDFINDARGS pArgs)
    483512{
    484     return KLDR_ERR_MODULE_NOT_FOUND;
     513    static char s_szFilename[1024];
     514    char *psz;
     515
     516    /*
     517     * Limit check first.
     518     */
     519    if (cchPath + 1 + pArgs->cchMaxLength >= sizeof(s_szFilename))
     520    {
     521        KLDRDYLDFIND_ASSERT(!"too long");
     522        return KLDR_ERR_MODULE_NOT_FOUND; /* ignore */
     523    }
     524
     525    /*
     526     * The directory path.
     527     */
     528    kLdrHlpMemCopy(s_szFilename, pchPath, cchPath);
     529    psz = &s_szFilename[cchPath];
     530    if (psz[-1] != '/'
     531#if defined(__OS2__) || defined(__WIN__)
     532        && psz[-1] != '\\'
     533        && psz[-1] != ':'
     534#endif
     535        )
     536        *psz++ = '/';
     537
     538    /*
     539     * The name.
     540     */
     541    if (pArgs->cchPrefix)
     542    {
     543        kLdrHlpMemCopy(psz, pArgs->pszPrefix, pArgs->cchPrefix);
     544        psz += pArgs->cchPrefix;
     545    }
     546    kLdrHlpMemCopy(psz, pArgs->pszName, pArgs->cchName);
     547    psz += pArgs->cchName;
     548    if (pArgs->cchSuffix)
     549    {
     550        kLdrHlpMemCopy(psz, pArgs->pszSuffix, pArgs->cchSuffix);
     551        psz += pArgs->cchSuffix;
     552    }
     553    *psz = '\0';
     554
     555    /*
     556     * Try open it.
     557     */
     558    return kldrDyldFindTryOpen(s_szFilename, pArgs->ppRdr);
    485559}
    486560
     
    492566 * @returns KLDR_ERR_MODULE_NOT_FOUND if the end of the search path was reached.
    493567 * @param   pszSearchPath   The search path to enumeare.
    494  * @param   pszName         The pszName argument for kldrDyldFindTryOpenPath.
    495  * @param   pszPrefix       The pszPrefix argument for kldrDyldFindTryOpenPath.
    496  * @param   pszSuffix       The pszSuffix argument for kldrDyldFindTryOpenPath.
    497  * @param   ppRdr           The ppRdr argument for kldrDyldFindTryOpenPath.
    498  */
    499 static int kldrDyldFindEnumeratePath(const char *pszSearchPath, const char *pszName, const char *pszPrefix,
    500                                      const char *pszSuffix, PPKLDRRDR ppRdr)
     568 * @param   pArgs       The search argument structure.
     569 */
     570static int kldrDyldFindEnumeratePath(const char *pszSearchPath, PCKLDRDYLDFINDARGS pArgs)
    501571{
    502     return KLDR_ERR_MODULE_NOT_FOUND;
     572    const char *psz = pszSearchPath;
     573    for (;;)
     574    {
     575        const char *pszEnd;
     576        size_t      cchPath;
     577
     578        /*
     579         * Trim.
     580         */
     581        while (*psz == ';' || *psz == ':')
     582            psz++;
     583        if (*psz == '\0')
     584            return KLDR_ERR_MODULE_NOT_FOUND;
     585
     586        /*
     587         * Find the end.
     588         */
     589        pszEnd = psz + 1;
     590        while (     *pszEnd != '\0'
     591               &&   *pszEnd != ';'
     592#if defined(__OS2__) || defined(__WIN__)
     593               && (     *pszEnd != ':'
     594                   ||   (   pszEnd - psz == 1
     595                         && (   (*psz >= 'A' && *psz <= 'Z')
     596                             || (*psz >= 'a' && *psz <= 'z')
     597                            )
     598                        )
     599                  )
     600#else
     601               && *pszEnd != ':'
     602#endif
     603              )
     604            pszEnd++;
     605
     606        /*
     607         * If not empty path, try open the module using it.
     608         */
     609        cchPath = pszEnd - psz - 1;
     610        if (cchPath > 0)
     611        {
     612            int rc;
     613            rc = kldrDyldFindTryOpenPath(psz, cchPath, pArgs);
     614            if (rc != KLDR_ERR_MODULE_NOT_FOUND)
     615                return rc;
     616        }
     617
     618        /* next */
     619        psz = pszEnd;
     620    }
    503621}
    504622
     623
     624/**
     625 * Resolve default search method, prefix and suffix.
     626 *
     627 * @returns 0 on success, KLDR_ERR_INVALID_PARAMETER on failure.
     628 * @param   penmSearch  The search method. In/Out.
     629 * @param   ppszPrefix  The prefix. In/Out.
     630 * @param   ppszSuffix  The suffix. In/Out.
     631 * @param   pszName     The name. In.
     632 */
     633static int kldrDyldFindGetDefaults(KLDRDYLDSEARCH *penmSearch, const char **ppszPrefix, const char **ppszSuffix,
     634                                   const char *pszName)
     635{
     636    unsigned fCaseSensitive;
     637
     638    /*
     639     * Fixup search method alias.
     640     */
     641    if (*penmSearch == KLDRDYLD_SEARCH_HOST)
     642#if defined(__OS2__)
     643        *penmSearch = KLDRDYLD_SEARCH_OS2;
     644#elif defined(__WIN__)
     645        *penmSearch = KLDRDYLD_SEARCH_WINDOWS;
     646#else
     647# error "Port me"
     648#endif
     649
     650    /*
     651     * Apply search method specific prefix/suffix.
     652     */
     653    switch (*penmSearch)
     654    {
     655        case KLDRDYLD_SEARCH_KLDR:
     656            if (!*ppszPrefix && kLdrDyldDefPrefix[0])
     657                *ppszPrefix = kLdrDyldDefPrefix;
     658            if (!*ppszSuffix && kLdrDyldDefSuffix[0])
     659                *ppszSuffix = kLdrDyldDefSuffix;
     660            fCaseSensitive = 1;
     661            break;
     662
     663        case KLDRDYLD_SEARCH_OS2:
     664            if (!*ppszSuffix)
     665                *ppszSuffix = ".dll";
     666            fCaseSensitive = 0;
     667            break;
     668
     669        case KLDRDYLD_SEARCH_WINDOWS:
     670        case KLDRDYLD_SEARCH_WINDOWS_ALTERED:
     671            if (!*ppszSuffix)
     672                *ppszSuffix = ".dll";
     673            fCaseSensitive = 0;
     674            break;
     675
     676        case KLDRDYLD_SEARCH_UNIX_COMMON:
     677            fCaseSensitive = 1;
     678            break;
     679
     680        default:
     681            KLDRDYLDFIND_ASSERT(!"invalid search method");
     682            return KLDR_ERR_INVALID_PARAMETER;
     683    }
     684
     685    /*
     686     * Drop the suffix if it's already included in the name.
     687     */
     688    if (*ppszSuffix)
     689    {
     690        const size_t cchName = kLdrHlpStrLen(pszName);
     691        const size_t cchSuffix = kLdrHlpStrLen(*ppszSuffix);
     692        if (    cchName > cchSuffix
     693            &&  (   fCaseSensitive
     694                 ?  kLdrHlpMemComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix)
     695                 :  kLdrHlpMemIComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix))
     696           )
     697            *ppszSuffix = NULL;
     698    }
     699
     700    return 0;
     701}
    505702
    506703
     
    532729
    533730    /*
    534      * Fixup search method alias.
    535      */
    536     if (enmSearch == KLDRDYLD_SEARCH_HOST)
    537         enmSearch = KLDRDYLD_SEARCH_KLDR; /** @todo find more suitable place for this. */
     731     * Defaults.
     732     */
     733    rc = kldrDyldFindGetDefaults(&enmSearch, &pszPrefix, &pszSuffix, pszName);
     734    if (rc)
     735        return rc;
    538736
    539737    /*
     
    580778    else
    581779    {
     780        const size_t    cchName = kLdrHlpStrLen(pszName);
     781        const size_t    cchPrefix = pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
     782        const size_t    cchSuffix = pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
     783        const char     *pszNameSuffix = kldrHlpGetSuff(pszName);
     784        PKLDRDYLDMOD    pCur = kLdrDyldHead;
     785
    582786        /*
    583          * Get default prefix and suffix.
     787         * Some of the methods are case insensitive (ASCII), others are case sensitive.
     788         * To avoid having todo indirect calls to the compare functions here, we split
     789         * ways even if it means a lot of duplicate code.
    584790         */
    585         rc = 0;
    586         switch (enmSearch)
    587         {
    588             case KLDRDYLD_SEARCH_KLDR:
    589                 if (!pszPrefix && kLdrDyldDefPrefix[0])
    590                     pszPrefix = kLdrDyldDefPrefix;
    591                 if (!pszSuffix && kLdrDyldDefSuffix[0])
    592                     pszSuffix = kLdrDyldDefSuffix;
    593                 break;
    594 
    595             case KLDRDYLD_SEARCH_OS2:
    596                 if (!pszSuffix)
    597                     pszSuffix = ".dll";
    598                 break;
    599 
    600             case KLDRDYLD_SEARCH_WINDOWS:
    601             case KLDRDYLD_SEARCH_WINDOWS_ALTERED:
    602                 if (!pszSuffix)
    603                     pszSuffix = ".dll";
    604 
    605             case KLDRDYLD_SEARCH_UNIX_COMMON:
    606                 break;
    607 
    608             default:
    609                 KLDRDYLDFIND_ASSERT(!"invalid search method");
    610                 rc = KLDR_ERR_INVALID_PARAMETER;
    611                 break;
    612         }
    613         if (!rc)
    614         {
    615             const size_t    cchName = kLdrHlpStrLen(pszName);
    616             const size_t    cchPrefix = pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
    617             const size_t    cchSuffix = pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
    618             const char     *pszNameSuffix = kldrHlpGetSuff(pszName);
    619             PKLDRDYLDMOD    pCur = kLdrDyldHead;
    620 
    621             /*
    622              * Some of the methods are case insensitive (ASCII), others are case sensitive.
    623              * To avoid having todo indirect calls to the compare functions here, we split
    624              * ways even if it means a lot of duplicate code.
    625              */
    626             if (   enmSearch == KLDRDYLD_SEARCH_OS2
    627                 || enmSearch == KLDRDYLD_SEARCH_WINDOWS
    628                 || enmSearch == KLDRDYLD_SEARCH_WINDOWS_ALTERED)
     791        if (   enmSearch == KLDRDYLD_SEARCH_OS2
     792            || enmSearch == KLDRDYLD_SEARCH_WINDOWS
     793            || enmSearch == KLDRDYLD_SEARCH_WINDOWS_ALTERED)
     794        {
     795            const unsigned fNameHasSuffix = pszNameSuffix
     796                                         && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
     797                                         && kLdrHlpMemIComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
     798            for (; pCur; pCur = pCur->Load.pNext)
    629799            {
    630                 const unsigned fNameHasSuffix = pszNameSuffix
    631                                              && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
    632                                              && kLdrHlpMemIComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
    633                 for (; pCur; pCur = pCur->Load.pNext)
     800                /* match global / specific */
     801                if (    !pCur->fGlobalOrSpecific
     802                    &&  !(fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE))
     803                    continue;
     804
     805                /* match name */
     806                if (    pCur->pMod->cchName == cchName
     807                    &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
     808                    break;
     809                if (cchPrefix)
    634810                {
    635                     /* match global / specific */
    636                     if (    !pCur->fGlobalOrSpecific
    637                         &&  !(fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE))
    638                         continue;
    639 
    640                     /* match name */
    641                     if (    pCur->pMod->cchName == cchName
     811                    if (    pCur->pMod->cchName == cchName + cchPrefix
     812                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
     813                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
     814                    break;
     815                }
     816                if (cchSuffix)
     817                {
     818                    if (    pCur->pMod->cchName == cchName + cchSuffix
     819                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
    642820                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
    643                         break;
     821                    break;
     822                    if (    fNameHasSuffix
     823                        &&  pCur->pMod->cchName == cchName - cchSuffix
     824                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
     825                    break;
    644826                    if (cchPrefix)
    645827                    {
    646                         if (    pCur->pMod->cchName == cchName + cchPrefix
     828                        if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
    647829                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    648                             &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
    649                         break;
    650                     }
    651                     if (cchSuffix)
    652                     {
    653                         if (    pCur->pMod->cchName == cchName + cchSuffix
    654                             &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
    655                             &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
     830                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
     831                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
    656832                        break;
    657833                        if (    fNameHasSuffix
    658                             &&  pCur->pMod->cchName == cchName - cchSuffix
    659                             &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
     834                            &&  pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
     835                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
     836                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
    660837                        break;
    661                         if (cchPrefix)
    662                         {
    663                             if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
    664                                 &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    665                                 &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
    666                                 &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
    667                             break;
    668                             if (    fNameHasSuffix
    669                                 &&  pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
    670                                 &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    671                                 &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
    672                             break;
    673                         }
    674838                    }
    675839                }
    676840            }
    677             else
     841        }
     842        else
     843        {
     844            const unsigned fNameHasSuffix = pszNameSuffix
     845                                         && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
     846                                         && kLdrHlpMemComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
     847            for (; pCur; pCur = pCur->Load.pNext)
    678848            {
    679                 const unsigned fNameHasSuffix = pszNameSuffix
    680                                              && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
    681                                              && kLdrHlpMemComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
    682                 for (; pCur; pCur = pCur->Load.pNext)
     849                /* match global / specific */
     850                if (    !pCur->fGlobalOrSpecific
     851                    &&  !(fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE))
     852                    continue;
     853
     854                /* match name */
     855                if (    pCur->pMod->cchName == cchName
     856                    &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName))
     857                    break;
     858                if (cchPrefix)
    683859                {
    684                     /* match global / specific */
    685                     if (    !pCur->fGlobalOrSpecific
    686                         &&  !(fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE))
    687                         continue;
    688 
    689                     /* match name */
    690                     if (    pCur->pMod->cchName == cchName
     860                    if (    pCur->pMod->cchName == cchName + cchPrefix
     861                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
     862                        &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
     863                    break;
     864                }
     865                if (cchSuffix)
     866                {
     867                    if (    pCur->pMod->cchName == cchName + cchSuffix
     868                        &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
    691869                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName))
    692                         break;
     870                    break;
     871                    if (    fNameHasSuffix
     872                        &&  pCur->pMod->cchName == cchName - cchSuffix
     873                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
     874                    break;
    693875                    if (cchPrefix)
    694876                    {
    695                         if (    pCur->pMod->cchName == cchName + cchPrefix
     877                        if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
    696878                            &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    697                             &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
     879                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
     880                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
    698881                        break;
    699                     }
    700                     if (cchSuffix)
    701                     {
    702                         if (    pCur->pMod->cchName == cchName + cchSuffix
    703                             &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
    704                             &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName))
     882                        if (    pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
     883                            &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
     884                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
    705885                        break;
    706                         if (    fNameHasSuffix
    707                             &&  pCur->pMod->cchName == cchName - cchSuffix
    708                             &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
    709                         break;
    710                         if (cchPrefix)
    711                         {
    712                             if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
    713                                 &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    714                                 &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
    715                                 &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
    716                             break;
    717                             if (    pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
    718                                 &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
    719                                 &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
    720                             break;
    721                         }
    722886                    }
    723887                }
    724888            }
    725             if (pCur)
    726             {
    727                 *ppMod = pCur;
    728                 rc = 0;
    729             }
    730             else
    731                 rc = KLDR_ERR_MODULE_NOT_FOUND;
    732         }
     889        }
     890
     891        /* search result. */
     892        if (pCur)
     893        {
     894            *ppMod = pCur;
     895            rc = 0;
     896        }
     897        else
     898            rc = KLDR_ERR_MODULE_NOT_FOUND;
    733899    }
    734900
  • trunk/kLdr/kLdrDyldMod.c

    r2859 r2868  
    6464 *          On failure a non-zero kLdr status code is returned.
    6565 * @param   pRdr    The file provider instance.
     66 * @param   fFlags  Load/search flags.
    6667 * @param   ppMod   Where to put the pointer to the new module on success.
    6768 */
    68 int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod)
     69int kldrDyldModCreate(PKLDRRDR pRdr, uint32_t fFlags, PPKLDRDYLDMOD ppMod)
    6970{
    7071    PKLDRDYLDMOD pMod;
     
    7374
    7475    *ppMod = NULL;
     76
     77/** @todo deal with fFlags (exec/dll) */
    7578
    7679    /*
  • trunk/kLdr/kLdrInternal.h

    r2867 r2868  
    322322
    323323
    324 int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod);
     324int kldrDyldModCreate(PKLDRRDR pRdr, uint32_t fFlags, PPKLDRDYLDMOD ppMod);
    325325void kldrDyldModDestroy(PKLDRDYLDMOD pMod);
    326326void kldrDyldModAddRef(PKLDRDYLDMOD pMod);
Note: See TracChangeset for help on using the changeset viewer.