VirtualBox

Changeset 30320 in vbox for trunk


Ignore:
Timestamp:
Jun 21, 2010 8:35:09 AM (15 years ago)
Author:
vboxsync
Message:

*: Replaced memchr(psz, '\0', cb) with RTStrEnd(psz, cb) and worked around memchr( RTSTR_MAX) issue in RTStrEnd. Here (linux.amd64 / glibc-2.10.1-r1) memchr fails for cb > ~(size_t)11. Since RTSTR_MAX is ~(size_t)0, this behavior breaks several IPRT string APIs.

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/cpp/ministring.h

    r30318 r30320  
    328328
    329329    /**
    330      * Returns true if the member string has no length.
    331      * This is true for instances created from both NULL and "" input strings.
     330     * Returns @c true if the member string has no length.
     331     *
     332     * This is @c true for instances created from both NULL and "" input
     333     * strings.
    332334     *
    333335     * This states nothing about how much memory might be allocated.
    334336     *
    335      * @returns true if empty, false if not.
     337     * @returns @c true if empty, @c false if not.
    336338     */
    337339    bool isEmpty() const
    338340    {
    339341        return length() == 0;
     342    }
     343
     344    /**
     345     * Returns @c false if the member string has no length.
     346     *
     347     * This is @c false for instances created from both NULL and "" input
     348     * strings.
     349     *
     350     * This states nothing about how much memory might be allocated.
     351     *
     352     * @returns @c false if empty, @c true if not.
     353     */
     354    bool isNotEmpty() const
     355    {
     356        return length() != 0;
    340357    }
    341358

  • trunk/include/iprt/string.h

    r28800 r30320  
    11951195RTDECL(int) RTStrNLenEx(const char *pszString, size_t cchMax, size_t *pcch);
    11961196
     1197RT_C_DECLS_END
     1198
     1199/** The maximum size argument of a memchr call. */
     1200#define RTSTR_MEMCHR_MAX            (~(size_t)0x10000)
     1201
     1202/**
     1203 * Find the zero terminator in a string with a limited length.
     1204 *
     1205 * @returns Pointer to the zero terminator.
     1206 * @returns NULL if the zero terminator was not found.
     1207 *
     1208 * @param   pszString   The string.
     1209 * @param   cchMax      The max string length.  RTSTR_MAX is fine.
     1210 */
     1211#if defined(__cplusplus) && !defined(DOXYGEN_RUNNING)
     1212DECLINLINE(char const *) RTStrEnd(char const *pszString, size_t cchMax)
     1213{
     1214    /* Avoid potential issues with memchr seen in glibc. */
     1215    if (cchMax > RTSTR_MEMCHR_MAX)
     1216    {
     1217        char const *pszRet = (char const *)memchr(pszString, '\0', RTSTR_MEMCHR_MAX);
     1218        if (RT_LIKELY(pszRet))
     1219            return pszRet;
     1220        pszString += RTSTR_MEMCHR_MAX;
     1221        cchMax    -= RTSTR_MEMCHR_MAX;
     1222    }
     1223    return (char const *)memchr(pszString, '\0', cchMax);
     1224}
     1225
     1226DECLINLINE(char *) RTStrEnd(char *pszString, size_t cchMax)
     1227#else
     1228DECLINLINE(char *) RTStrEnd(const char *pszString, size_t cchMax)
     1229#endif
     1230{
     1231    /* Avoid potential issues with memchr seen in glibc. */
     1232    if (cchMax > RTSTR_MEMCHR_MAX)
     1233    {
     1234        char *pszRet = (char *)memchr(pszString, '\0', RTSTR_MEMCHR_MAX);
     1235        if (RT_LIKELY(pszRet))
     1236            return pszRet;
     1237        pszString += RTSTR_MEMCHR_MAX;
     1238        cchMax    -= RTSTR_MEMCHR_MAX;
     1239    }
     1240    return (char *)memchr(pszString, '\0', cchMax);
     1241}
     1242
     1243RT_C_DECLS_BEGIN
     1244
    11971245/**
    11981246 * Matches a simple string pattern.

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestProp.cpp

    r28800 r30320  
    329329    {
    330330        /* Validate / skip 'Name'. */
    331         char *pszFlags = (char *)memchr(pvBuf, '\0', cbBuf) + 1;
     331        char *pszFlags = RTStrEnd((char *)pvBuf, cbBuf) + 1;
    332332        AssertPtrReturn(pszFlags, VERR_TOO_MUCH_DATA);
    333333        if (ppszValue)
    … …  
    337337        {
    338338            /* Validate 'Flags'. */
    339             void *pvEos = memchr(pszFlags, '\0', cbBuf - (pszFlags - (char *)pvBuf));
    340             AssertPtrReturn(pvEos, VERR_TOO_MUCH_DATA);
     339            char *pszEos = RTStrEnd(pszFlags, cbBuf - (pszFlags - (char *)pvBuf));
     340            AssertPtrReturn(pszEos, VERR_TOO_MUCH_DATA);
    341341            *ppszFlags = pszFlags;
    342342        }
    … …  
    685685
    686686    char *pszName      = pchNext;
    687     char *pszValue     = pchNext = (char *)memchr(pchNext, '\0', pchEnd - pchNext) + 1;
     687    char *pszValue     = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
    688688    AssertPtrReturn(pchNext, VERR_PARSE_ERROR);  /* 0x1 is also an invalid pointer :) */
    689689
    690     char *pszTimestamp = pchNext = (char *)memchr(pchNext, '\0', pchEnd - pchNext) + 1;
     690    char *pszTimestamp = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
    691691    AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
    692692
    693     char *pszFlags     = pchNext = (char *)memchr(pchNext, '\0', pchEnd - pchNext) + 1;
     693    char *pszFlags     = pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
    694694    AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
    695695
    … …  
    701701    if (*pszName != '\0')
    702702    {
    703         pchNext = (char *)memchr(pchNext, '\0', pchEnd - pchNext) + 1;
     703        pchNext = RTStrEnd(pchNext, pchEnd - pchNext) + 1;
    704704        AssertPtrReturn(pchNext, VERR_PARSE_ERROR);
    705705
    … …  
    880880    {
    881881        /* Validate / skip 'Name'. */
    882         char *pszValue = (char *)memchr(pvBuf, '\0', cbBuf) + 1;
     882        char *pszValue = RTStrEnd((char *)pvBuf, cbBuf) + 1;
    883883        AssertPtrReturn(pszValue, VERR_TOO_MUCH_DATA);
    884884        if (ppszName)
    … …  
    886886
    887887        /* Validate / skip 'Value'. */
    888         char *pszFlags = (char *)memchr(pszValue, '\0',
    889                                         cbBuf - (pszValue - (char *)pvBuf)) + 1;
     888        char *pszFlags = RTStrEnd(pszValue, cbBuf - (pszValue - (char *)pvBuf)) + 1;
    890889        AssertPtrReturn(pszFlags, VERR_TOO_MUCH_DATA);
    891890        if (ppszValue)
    … …  
    895894        {
    896895            /* Validate 'Flags'. */
    897             void *pvEos = memchr(pszFlags, '\0', cbBuf - (pszFlags - (char *)pvBuf));
    898             AssertPtrReturn(pvEos, VERR_TOO_MUCH_DATA);
     896            char *pszEos = RTStrEnd(pszFlags, cbBuf - (pszFlags - (char *)pvBuf));
     897            AssertPtrReturn(pszEos, VERR_TOO_MUCH_DATA);
    899898            *ppszFlags = pszFlags;
    900899        }

  • trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp

    r30111 r30320  
    52895289
    52905290    AssertPtrReturn(pszNetwork, VERR_INVALID_PARAMETER);
    5291     const char *pszNetworkEnd = (const char *)memchr(pszNetwork, '\0', INTNET_MAX_NETWORK_NAME);
     5291    const char *pszNetworkEnd = RTStrEnd(pszNetwork, INTNET_MAX_NETWORK_NAME);
    52925292    AssertReturn(pszNetworkEnd, VERR_INVALID_PARAMETER);
    52935293    size_t cchNetwork = pszNetworkEnd - pszNetwork;
    … …  
    52975297    {
    52985298        AssertPtrReturn(pszTrunk, VERR_INVALID_PARAMETER);
    5299         const char *pszTrunkEnd = (const char *)memchr(pszTrunk, '\0', INTNET_MAX_TRUNK_NAME);
     5299        const char *pszTrunkEnd = RTStrEnd(pszTrunk, INTNET_MAX_TRUNK_NAME);
    53005300        AssertReturn(pszTrunkEnd, VERR_INVALID_PARAMETER);
    53015301    }

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.c

    r29978 r30320  
    12181218            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageBits < pReq->u.In.cbImageWithTabs);
    12191219            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.szName[0]);
    1220             REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
     1220            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, RTStrEnd(pReq->u.In.szName, sizeof(pReq->u.In.szName)));
    12211221            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, !supdrvCheckInvalidChar(pReq->u.In.szName, ";:()[]{}/\\|&*%#@!~`\"'"));
    1222             REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szFilename, '\0', sizeof(pReq->u.In.szFilename)));
     1222            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, RTStrEnd(pReq->u.In.szFilename, sizeof(pReq->u.In.szFilename)));
    12231223
    12241224            /* execute */
    … …  
    12561256                    REQ_CHECK_EXPR_FMT(paSyms[i].offName < pReq->u.In.cbStrTab,
    12571257                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
    1258                     REQ_CHECK_EXPR_FMT(memchr(&pReq->u.In.abImage[pReq->u.In.offStrTab + paSyms[i].offName], '\0', pReq->u.In.cbStrTab - paSyms[i].offName),
     1258                    REQ_CHECK_EXPR_FMT(RTStrEnd(&pReq->u.In.abImage[pReq->u.In.offStrTab + paSyms[i].offName], pReq->u.In.cbStrTab - paSyms[i].offName),
    12591259                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
    12601260                }
    … …  
    12821282            PSUPLDRGETSYMBOL pReq = (PSUPLDRGETSYMBOL)pReqHdr;
    12831283            REQ_CHECK_SIZES(SUP_IOCTL_LDR_GET_SYMBOL);
    1284             REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, memchr(pReq->u.In.szSymbol, '\0', sizeof(pReq->u.In.szSymbol)));
     1284            REQ_CHECK_EXPR(SUP_IOCTL_LDR_GET_SYMBOL, RTStrEnd(pReq->u.In.szSymbol, sizeof(pReq->u.In.szSymbol)));
    12851285
    12861286            /* execute */
    … …  
    14931493                REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(pSrvReq->cbReq), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(pSrvReq->cbReq));
    14941494            }
    1495             REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
     1495            REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, RTStrEnd(pReq->u.In.szName, sizeof(pReq->u.In.szName)));
    14961496
    14971497            /* execute */
    … …  
    32873287    AssertPtrReturn(pFactory, VERR_INVALID_POINTER);
    32883288    AssertPtrReturn(pFactory->pfnQueryFactoryInterface, VERR_INVALID_POINTER);
    3289     psz = (const char *)memchr(pFactory->szName, '\0', sizeof(pFactory->szName));
     3289    psz = RTStrEnd(pFactory->szName, sizeof(pFactory->szName));
    32903290    AssertReturn(psz, VERR_INVALID_PARAMETER);
    32913291
    … …  
    34263426
    34273427    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
    3428     pszEnd = memchr(pszName, '\0', RT_SIZEOFMEMB(SUPDRVFACTORY, szName));
     3428    pszEnd = RTStrEnd(pszName, RT_SIZEOFMEMB(SUPDRVFACTORY, szName));
    34293429    AssertReturn(pszEnd, VERR_INVALID_PARAMETER);
    34303430    cchName = pszEnd - pszName;
    34313431
    34323432    AssertPtrReturn(pszInterfaceUuid, VERR_INVALID_POINTER);
    3433     pszEnd = memchr(pszInterfaceUuid, '\0', RTUUID_STR_LENGTH);
     3433    pszEnd = RTStrEnd(pszInterfaceUuid, RTUUID_STR_LENGTH);
    34343434    AssertReturn(pszEnd, VERR_INVALID_PARAMETER);
    34353435
    … …  
    41394139     */
    41404140    AssertPtrReturn(pszSymbol, VERR_INVALID_POINTER);
    4141     pszEnd = (char *)memchr(pszSymbol, '\0', 512);
     4141    pszEnd = RTStrEnd(pszSymbol, 512);
    41424142    AssertReturn(pszEnd, VERR_INVALID_PARAMETER);
    41434143    cbSymbol = pszEnd - pszSymbol + 1;
    … …  
    41464146    {
    41474147        AssertPtrReturn(pszModule, VERR_INVALID_POINTER);
    4148         pszEnd = (char *)memchr(pszModule, '\0', 64);
     4148        pszEnd = RTStrEnd(pszModule, 64);
    41494149        AssertReturn(pszEnd, VERR_INVALID_PARAMETER);
    41504150    }

  • trunk/src/VBox/HostDrivers/VBoxNetAdp/darwin/VBoxNetAdp-darwin.cpp

    r28800 r30320  
    365365        case IOCBASECMD(VBOXNETADP_CTL_REMOVE):
    366366        {
    367             if (!memchr(pReq->szName, '\0', RT_MIN(cbReq, sizeof(pReq->szName))))
     367            if (!RTStrEnd(pReq->szName, RT_MIN(cbReq, sizeof(pReq->szName))))
    368368                return EINVAL;
    369369

  • trunk/src/VBox/HostDrivers/VBoxNetAdp/freebsd/VBoxNetAdp-freebsd.c

    r29713 r30320  
    170170
    171171        case VBOXNETADP_CTL_REMOVE:
    172             if (!memchr(pReq->szName, '\0', RT_MIN(sizeof(pReq->szName), IOCPARM_LEN(iCmd))))
     172            if (!RTStrEnd(pReq->szName, RT_MIN(sizeof(pReq->szName), IOCPARM_LEN(iCmd))))
    173173                return EINVAL;
    174174

  • trunk/src/VBox/Runtime/common/path/RTPathAppend.cpp

    r28800 r30320  
    107107RTDECL(int) RTPathAppend(char *pszPath, size_t cbPathDst, const char *pszAppend)
    108108{
    109     char *pszPathEnd = (char *)memchr(pszPath, '\0', cbPathDst);
     109    char *pszPathEnd = RTStrEnd(pszPath, cbPathDst);
    110110    AssertReturn(pszPathEnd, VERR_INVALID_PARAMETER);
    111111

  • trunk/src/VBox/Runtime/common/string/RTStrCopyEx.cpp

    r28800 r30320  
    3535RTDECL(int) RTStrCopyEx(char *pszDst, size_t cbDst, const char *pszSrc, size_t cchMaxSrc)
    3636{
    37     const char *pszSrcEol = (const char *)memchr(pszSrc, '\0', cchMaxSrc);
     37    const char *pszSrcEol = RTStrEnd(pszSrc, cchMaxSrc);
    3838    size_t      cchSrc    = pszSrcEol ? (size_t)(pszSrcEol - pszSrc) : cchMaxSrc;
    3939    if (RT_LIKELY(cchSrc < cbDst))

  • trunk/src/VBox/Runtime/common/string/RTStrNLen.cpp

    r28800 r30320  
    3535RTDECL(size_t) RTStrNLen(const char *pszString, size_t cchMax)
    3636{
    37     const char *pchEnd = (const char *)memchr(pszString, '\0', cchMax);
     37    const char *pchEnd = RTStrEnd(pszString, cchMax);
    3838    return pchEnd ? pchEnd - pszString : cchMax;
    3939}

  • trunk/src/VBox/Runtime/common/string/RTStrNLenEx.cpp

    r28800 r30320  
    3434RTDECL(int) RTStrNLenEx(const char *pszString, size_t cchMax, size_t *pcch)
    3535{
    36     const char *pchEnd = (const char *)memchr(pszString, '\0', cchMax);
     36    const char *pchEnd = RTStrEnd(pszString, cchMax);
    3737    if (!pchEnd)
    3838    {

  • trunk/src/VBox/Runtime/common/string/strcache.cpp

    r28800 r30320  
    153153    AssertPtr(pchString);
    154154    AssertReturn(cchString < _1G, NULL);
    155     Assert(!memchr(pchString, '\0', cchString));
     155    Assert(!RTStrEnd(pchString, cchString));
    156156
    157157    return (const char *)RTMemPoolDupEx((RTMEMPOOL)hStrCache, pchString, cchString, 1);

  • trunk/src/VBox/Runtime/common/string/stringalloc.cpp

    r28800 r30320  
    132132{
    133133    AssertPtr(pszString);
    134     char  *pszEnd = (char *)memchr(pszString, '\0', cchMax);
    135     size_t cch    = pszEnd ? (uintptr_t)pszEnd - (uintptr_t)pszString : cchMax;
    136     char  *pszDst = (char *)RTMemAlloc(cch + 1);
     134    char const *pszEnd = RTStrEnd(pszString, cchMax);
     135    size_t      cch    = pszEnd ? (uintptr_t)pszEnd - (uintptr_t)pszString : cchMax;
     136    char       *pszDst = (char *)RTMemAlloc(cch + 1);
    137137    if (pszDst)
    138138    {
    … …  
    262262    {
    263263        AssertPtrReturn(pszOld, VERR_OUT_OF_RANGE);
    264         char *pszZero = (char *)memchr(pszOld, '\0', cchNew + 63);
     264        AssertPtrReturn(cchNew < ~(size_t)64, VERR_OUT_OF_RANGE);
     265        char *pszZero = RTStrEnd(pszOld, cchNew + 63);
    265266        AssertReturn(!pszZero || (size_t)(pszZero - pszOld) >= cchNew, VERR_OUT_OF_RANGE);
    266267        pszOld[cchNew] = '\0';

  • trunk/src/VBox/Runtime/generic/strcache-stubs-generic.cpp

    r30253 r30320  
    6464    AssertPtr(pchString);
    6565    AssertReturn(cchString < _1G, NULL);
    66     Assert(!memchr(pchString, '\0', cchString));
     66    Assert(!RTStrEnd(pchString, cchString));
    6767
    6868    return (const char *)RTMemPoolDupEx((RTMEMPOOL)hStrCache, pchString, cchString, 1);

  • trunk/src/VBox/Runtime/testcase/tstNoCrt-1.cpp

    r30255 r30320  
    55
    66/*
    7  * Copyright (C) 2008 Oracle Corporation
     7 * Copyright (C) 2008-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    427427    pv = RT_NOCRT(memchr)(&s_szTest1[0x00], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
    428428    pv = RT_NOCRT(memchr)(&s_szTest1[0x0f], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
    429     pv = RT_NOCRT(memchr)(&s_szTest1[0x03], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
    430     pv = RT_NOCRT(memchr)(&s_szTest1[0x10], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
     429    pv = RT_NOCRT(memchr)(&s_szTest1[0x03],   0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
     430    pv = RT_NOCRT(memchr)(&s_szTest1[0x10],   0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
     431    pv = RT_NOCRT(memchr)(&s_szTest1,         0, ~(size_t)0);        CHECK_PV(&s_szTest1[0x10]);
     432    pv = RT_NOCRT(memchr)(&s_szTest1,         0, ~(size_t)1);        CHECK_PV(&s_szTest1[0x10]);
     433    pv = RT_NOCRT(memchr)(&s_szTest1,         0, ~(size_t)16);       CHECK_PV(&s_szTest1[0x10]);
    431434    for (unsigned i = 0; i < sizeof(s_szTest1); i++)
    432435        for (unsigned j = 0; j <= i; j++)

  • trunk/src/VBox/Runtime/testcase/tstRTSystemQueryDmi.cpp

    r29560 r30320  
    7474            RTTestIFailed("level=%d; unterminated buffer on VERR_NOT_SUPPORTED\n", i);
    7575        else if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
    76             RTTESTI_CHECK(memchr(szInfo, '\0', sizeof(szInfo)) != NULL);
     76            RTTESTI_CHECK(RTStrEnd(szInfo, sizeof(szInfo)) != NULL);
    7777        else if (rc != VERR_NOT_SUPPORTED && rc != VERR_ACCESS_DENIED)
    7878            RTTestIFailed("level=%d unexpected rc=%Rrc\n", i, rc);
    … …  
    109109
    110110            /* check for zero terminator. */
    111             if (!memchr(szInfo, '\0', cch))
     111            if (!RTStrEnd(szInfo, cch))
    112112                RTTestIFailed("level=%d, rc=%Rrc, cch=%zu: Buffer not terminated!\n", i, rc, cch);
    113113        }

  • trunk/src/VBox/Runtime/testcase/tstRTSystemQueryOsInfo.cpp

    r28800 r30320  
    7777            RTTestIFailed("level=%d; unterminated buffer on VERR_NOT_SUPPORTED\n", i);
    7878        else if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
    79             RTTESTI_CHECK(memchr(szInfo, '\0', sizeof(szInfo)) != NULL);
     79            RTTESTI_CHECK(RTStrEnd(szInfo, sizeof(szInfo)) != NULL);
    8080        else if (rc != VERR_NOT_SUPPORTED)
    8181            RTTestIFailed("level=%d unexpected rc=%Rrc\n", i, rc);
    … …  
    112112
    113113            /* check for zero terminator. */
    114             if (!memchr(szInfo, '\0', cch))
     114            if (!RTStrEnd(szInfo, cch))
    115115                RTTestIFailed("level=%d, rc=%Rrc, cch=%zu: Buffer not terminated!\n", i, rc, cch);
    116116        }

  • trunk/src/VBox/Runtime/testcase/tstUtf8.cpp

    r30318 r30320  
    844844
    845845    RTTestSubDone(hTest);
     846}
     847
     848
     849/**
     850 * Tests RTStrEnd
     851 */
     852static void testStrEnd(RTTEST hTest)
     853{
     854    RTTestSub(hTest, "RTStrEnd");
     855
     856    static char const s_szEmpty[1] = "";
     857    RTTESTI_CHECK(RTStrEnd(s_szEmpty, 0) == NULL);
     858    RTTESTI_CHECK(RTStrEnd(s_szEmpty, 1) == &s_szEmpty[0]);
     859    for (size_t i = 0; i < _1M; i++)
     860        RTTESTI_CHECK(RTStrEnd(s_szEmpty, ~i) == &s_szEmpty[0]);
     861
    846862}
    847863
    … …  
    12221238    test3(hTest);
    12231239    TstRTStrXCmp(hTest);
     1240    testStrEnd(hTest);
    12241241    testStrStr(hTest);
    12251242    testMinistring(hTest);

  • trunk/src/VBox/VMM/DBGFMem.cpp

    r28800 r30320  
    244244     * This may look a bit reckless with the rc but, it should be fine.
    245245     */
    246     if (!memchr(pszBuf, '\0', cchBuf))
     246    if (!RTStrEnd(pszBuf, cchBuf))
    247247    {
    248248        pszBuf[cchBuf - 1] = '\0';

  • trunk/src/VBox/VMM/DBGFOS.cpp

    r28800 r30320  
    143143    AssertReturn(pReg->cbData < _2G, VERR_INVALID_PARAMETER);
    144144    AssertReturn(pReg->szName[0], VERR_INVALID_NAME);
    145     AssertReturn(memchr(&pReg->szName[0], '\0', sizeof(pReg->szName)), VERR_INVALID_NAME);
     145    AssertReturn(RTStrEnd(&pReg->szName[0], sizeof(pReg->szName)), VERR_INVALID_NAME);
    146146    AssertPtrReturn(pReg->pfnConstruct, VERR_INVALID_POINTER);
    147147    AssertPtrNullReturn(pReg->pfnDestruct, VERR_INVALID_POINTER);
    … …  
    229229    AssertReturn(pReg->u32Magic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
    230230    AssertReturn(pReg->u32EndMagic == DBGFOSREG_MAGIC, VERR_INVALID_MAGIC);
    231     AssertReturn(memchr(&pReg->szName[0], '\0', sizeof(pReg->szName)), VERR_INVALID_NAME);
     231    AssertReturn(RTStrEnd(&pReg->szName[0], sizeof(pReg->szName)), VERR_INVALID_NAME);
    232232
    233233    DBGF_OS_READ_LOCK(pVM);

  • trunk/src/VBox/VMM/PDMDriver.cpp

    r30217 r30320  
    263263                    VERR_PDM_UNKNOWN_DRVREG_VERSION);
    264264    AssertReturn(pReg->szName[0], VERR_PDM_INVALID_DRIVER_REGISTRATION);
    265     AssertMsgReturn(memchr(pReg->szName, '\0', sizeof(pReg->szName)),
     265    AssertMsgReturn(RTStrEnd(pReg->szName, sizeof(pReg->szName)),
    266266                    (".*s\n", sizeof(pReg->szName), pReg->szName),
    267267                    VERR_PDM_INVALID_DRIVER_REGISTRATION);
    268268    AssertMsgReturn(    !(pReg->fFlags & PDM_DRVREG_FLAGS_R0)
    269269                    ||  (   pReg->szR0Mod[0]
    270                          && memchr(pReg->szR0Mod, '\0', sizeof(pReg->szR0Mod))),
     270                         && RTStrEnd(pReg->szR0Mod, sizeof(pReg->szR0Mod))),
    271271                    ("%s: %.*s\n", pReg->szName, sizeof(pReg->szR0Mod), pReg->szR0Mod),
    272272                    VERR_PDM_INVALID_DRIVER_REGISTRATION);
    273273    AssertMsgReturn(    !(pReg->fFlags & PDM_DRVREG_FLAGS_RC)
    274274                    ||  (   pReg->szRCMod[0]
    275                          && memchr(pReg->szRCMod, '\0', sizeof(pReg->szRCMod))),
     275                         && RTStrEnd(pReg->szRCMod, sizeof(pReg->szRCMod))),
    276276                    ("%s: %.*s\n", pReg->szName, sizeof(pReg->szRCMod), pReg->szRCMod),
    277277                    VERR_PDM_INVALID_DRIVER_REGISTRATION);

  • trunk/src/VBox/VMM/VMMAll/VMAll.cpp

    r28800 r30320  
    242242    AssertPtr(pszErrorId);
    243243    Assert(*pszErrorId);
    244     Assert(memchr(pszErrorId, '\0', 128) != NULL);
     244    Assert(RTStrEnd(pszErrorId, 128) != NULL);
    245245    AssertPtr(pszFormat);
    246     Assert(memchr(pszFormat, '\0', 512) != NULL);
     246    Assert(RTStrEnd(pszFormat, 512) != NULL);
    247247
    248248#ifdef IN_RING3

  • trunk/src/bldprogs/scm.cpp

    r29907 r30320  
    724724bool ScmStreamIsText(PSCMSTREAM pStream)
    725725{
    726     if (memchr(pStream->pch, '\0', pStream->cb))
     726    if (RTStrEnd(pStream->pch, pStream->cb))
    727727        return false;
    728728    if (!pStream->cb)
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette