VirtualBox

Changeset 33464 in vbox for trunk


Ignore:
Timestamp:
Oct 26, 2010 12:27:50 PM (14 years ago)
Author:
vboxsync
Message:

*: Fixes for incorrect RTStrAPrintf usage (it does NOT return an IPRT status code) and the odd bugs nearby.

Location:
trunk
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/iprt/fs.h

    r30365 r33464  
    563563RT_C_DECLS_END
    564564
    565 #endif /* ___iprt_fs_h */
    566 
     565#endif /* !___iprt_fs_h */
     566
  • trunk/include/iprt/isofs.h

    r33449 r33464  
    2727#define ___iprt_isofs_h
    2828
    29 #include <iprt/file.h>
    30 #include <iprt/mem.h>
     29#include <iprt/types.h>
    3130#include <iprt/list.h>
    32 #include <iprt/string.h>
    3331
    3432RT_C_DECLS_BEGIN
     
    221219RT_C_DECLS_END
    222220
    223 #endif /* ___iprt_isofs_h */
    224 
     221#endif
     222
  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxSharedFolders.cpp

    r31111 r33464  
    5757                        Log(("VBoxTray: Connecting share %u (%s) ...\n", i+1, pszName));
    5858
    59                         char *pszShareName = NULL;
    60                         if (   RTStrAPrintf(&pszShareName, "\\\\vboxsrv\\%s", pszName) > 0
    61                             && pszShareName)
     59                        char *pszShareName;
     60                        if (RTStrAPrintf(&pszShareName, "\\\\vboxsrv\\%s", pszName) >= 0)
    6261                        {
    63                             char cDrive = 'D'; /* Start probing whether drive D: is free to use. */
     62                            char chDrive = 'D'; /* Start probing whether drive D: is free to use. */
    6463                            do
    6564                            {
    6665                                char szCurDrive[3];
    67                                 RTStrPrintf(szCurDrive, sizeof(szCurDrive), "%c:", cDrive++);
     66                                RTStrPrintf(szCurDrive, sizeof(szCurDrive), "%c:", chDrive++);
    6867
    6968                                NETRESOURCE resource;
     
    102101                                    }
    103102                                }
    104                             } while(cDrive <= 'Z');
    105 
    106                             if (cDrive > 'Z')
     103                            } while (chDrive <= 'Z');
     104
     105                            if (chDrive > 'Z')
    107106                            {
    108107                                LogRel(("VBoxTray: No free driver letter found to assign shared folder \"%s\", aborting.\n", pszName));
     
    113112                        }
    114113                        else
    115                             rc = VERR_NO_MEMORY;
     114                            rc = VERR_NO_STR_MEMORY;
    116115                        RTStrFree(pszName);
    117116                    }
     
    156155                    Log(("VBoxTray: Disconnecting share %u (%s) ...\n", i+1, pszName));
    157156
    158                     char *pszShareName = NULL;
    159                     if (   RTStrAPrintf(&pszShareName, "\\\\vboxsrv\\%s", pszName) > 0
    160                         && pszShareName)
     157                    char *pszShareName;
     158                    if (RTStrAPrintf(&pszShareName, "\\\\vboxsrv\\%s", pszName) >= 0)
    161159                    {
    162160                        DWORD dwErr = WNetCancelConnection2(pszShareName, 0, FALSE /* Force disconnect */);
     
    164162                        {
    165163                            LogRel(("VBoxTray: Share \"%s\" was disconnected\n", pszShareName));
     164                            RTStrFree(pszShareName);
     165                            RTStrFree(pszName);
    166166                            break;
    167167                        }
    168                         else
     168
     169                        LogRel(("VBoxTray: Disconnecting \"%s\" failed, dwErr = %ld\n", pszShareName, dwErr));
     170
     171                        switch (dwErr)
    169172                        {
    170                             LogRel(("VBoxTray: Disconnecting \"%s\" failed, dwErr = %ld\n", pszShareName, dwErr));
    171 
    172                             switch (dwErr)
    173                             {
    174                                 case ERROR_NOT_CONNECTED:
    175                                     break;
    176 
    177                                 default:
    178                                     LogRel(("VBoxTray: Error while disconnecting shared folder \"%s\", error = %ld\n",
    179                                             pszShareName, dwErr));
    180                                     break;
    181                             }
     173                            case ERROR_NOT_CONNECTED:
     174                                break;
     175
     176                            default:
     177                                LogRel(("VBoxTray: Error while disconnecting shared folder \"%s\", error = %ld\n",
     178                                        pszShareName, dwErr));
     179                                break;
    182180                        }
    183181
  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibSharedFolders.cpp

    r32705 r33464  
    280280        {
    281281#endif
    282             if (RTStrAPrintf(ppszPrefix, "sf_"))
    283                 rc = VINF_SUCCESS;
    284             else
    285                 rc = VERR_NO_MEMORY;
     282            rc = RTStrDupEx(ppszPrefix, "sf_");
    286283#ifdef VBOX_WITH_GUEST_PROPS
    287284        }
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp

    r33448 r33464  
    940940        if (uNumEnvVars)
    941941        {
    942             pData->papszEnv = (char**)RTMemAlloc(uNumEnvVars * sizeof(char*));
     942            pData->papszEnv = (char **)RTMemAlloc(uNumEnvVars * sizeof(char*));
    943943            AssertPtr(pData->papszEnv);
    944944            pData->uNumEnvVars = uNumEnvVars;
    945945
    946             const char *pcCur = pszEnv;
     946            const char *pszCur = pszEnv;
    947947            uint32_t i = 0;
    948948            uint32_t cbLen = 0;
     
    955955                    break;
    956956                }
    957                 int cbStr = RTStrAPrintf(&pData->papszEnv[i++], "%s", pcCur);
     957                int cbStr = RTStrAPrintf(&pData->papszEnv[i++], "%s", pszCur);
    958958                if (cbStr < 0)
    959959                {
    960                     rc = VERR_NO_MEMORY;
     960                    rc = VERR_NO_STR_MEMORY;
    961961                    break;
    962962                }
    963                 cbLen += cbStr + 1; /* Skip terminating '\0' */
    964                 pcCur += cbStr + 1; /* Skip terminating '\0' */
     963                pszCur += cbStr + 1; /* Skip terminating '\0' */
     964                cbLen += cbStr + 1; /* Skip terminating '\0' */
    965965            }
    966966        }
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceCpuHotPlug.cpp

    r30013 r33464  
    154154            {
    155155                PCSYSFSCPUPATHCOMP pPathComponent = &pAcpiCpuPathLvl->aComponentsPossible[iCompCurr];
     156
     157                /* Open the directory */
    156158                PRTDIR pDirCurr = NULL;
    157                 char *pszPathTmp = NULL;
    158                 bool fFound = false;
    159 
    160                 rc = RTStrAPrintf(&pszPathTmp, "%s/%s*", pszPath, pPathComponent->pcszName);
     159                char *pszPathTmp = RTPathJoinA(pszPath, pPathComponent->pcszName);
     160                if (pszPathTmp)
     161                {
     162                    rc = RTDirOpenFiltered(&pDirCurr, pszPathTmp, RTDIRFILTER_WINNT);
     163                    RTStrFree(pszPathTmp);
     164                }
     165                else
     166                    rc = VERR_NO_STR_MEMORY;
    161167                if (RT_FAILURE(rc))
    162168                    break;
    163169
    164                 /* Open the directory */
    165                 rc = RTDirOpenFiltered(&pDirCurr, pszPathTmp, RTDIRFILTER_WINNT);
    166                 if (RT_FAILURE(rc))
    167                 {
    168                     RTStrFree(pszPathTmp);
    169                     break;
    170                 }
    171 
    172170                /* Search if the current directory contains one of the possible parts. */
     171                size_t cchName = strlen(pPathComponent->pcszName);
    173172                RTDIRENTRY DirFolderContent;
     173                bool fFound = false;
    174174                while (RT_SUCCESS(RTDirRead(pDirCurr, &DirFolderContent, NULL))) /* Assumption that szName has always enough space */
    175175                {
    176                     if (!strncmp(DirFolderContent.szName, pPathComponent->pcszName, strlen(pPathComponent->pcszName)))
     176                    if (   DirFolderContent.cbName >= cchName
     177                        && !strncmp(DirFolderContent.szName, pPathComponent->pcszName, cchName))
    177178                    {
    178                         char *pszPathLvl = NULL;
    179 
    180179                        /* Found, use the complete name to dig deeper. */
    181180                        fFound = true;
    182181                        pAcpiCpuPathLvl->uId = iCompCurr;
    183                         rc = RTStrAPrintf(&pszPathLvl, "%s/%s", pszPath, DirFolderContent.szName);
    184 
    185                         if (RT_SUCCESS(rc))
     182                        char *pszPathLvl = RTPathJoinA(pszPath, DirFolderContent.szName);
     183                        if (pszPathLvl)
    186184                        {
    187185                            RTStrFree(pszPath);
    188186                            pszPath = pszPathLvl;
    189187                        }
     188                        else
     189                            rc = VERR_NO_STR_MEMORY;
    190190                        break;
    191191                    }
     
    235235        /* Init everything. */
    236236        Assert(pAcpiCpuPathLvl->uId != ACPI_CPU_PATH_NOT_PROBED);
    237         rc = RTStrAPrintf(&pszPath,
    238                           "%s/%s*", SYSFS_ACPI_CPU_PATH,
    239                           pAcpiCpuPathLvl->aComponentsPossible[pAcpiCpuPathLvl->uId].pcszName);
    240         if (RT_FAILURE(rc))
    241             return rc;
     237        pszPath = RTPathJoinA(SYSFS_ACPI_CPU_PATH, pAcpiCpuPathLvl->aComponentsPossible[pAcpiCpuPathLvl->uId].pcszName);
     238        if (!pszPath)
     239            return VERR_NO_STR_MEMORY;
    242240
    243241        pAcpiCpuPathLvl->pszPath = RTStrDup(SYSFS_ACPI_CPU_PATH);
    244242        if (!pAcpiCpuPathLvl->pszPath)
    245             return VERR_NO_MEMORY;
     243        {
     244            RTStrFree(pszPath);
     245            return VERR_NO_STR_MEMORY;
     246        }
    246247
    247248        /* Open the directory */
     
    259260                if (RT_SUCCESS(rc))
    260261                {
    261                     char *pszPathCurr;
    262 
    263262                    /* Create the new path. */
    264                     rc = RTStrAPrintf(&pszPathCurr, "%s/%s", pAcpiCpuPathLvl->pszPath, DirFolderContent.szName);
    265                     if (RT_FAILURE(rc))
     263                    char *pszPathCurr = RTPathJoinA(pAcpiCpuPathLvl->pszPath, DirFolderContent.szName);
     264                    if (!pszPathCurr)
     265                    {
     266                        rc = VERR_NO_STR_MEMORY;
    266267                        break;
     268                    }
    267269
    268270                    /* If this is the last level check for the given core and package id. */
     
    306308                        Assert(pAcpiCpuPathLvl->uId != ACPI_CPU_PATH_NOT_PROBED);
    307309
    308                         rc = RTStrAPrintf(&pszPathDir, "%s/%s*", pszPathCurr, pPathComponent->pcszName);
    309                         if (RT_FAILURE(rc))
     310                        pszPathDir = RTPathJoinA(pszPathCurr, pPathComponent->pcszName);
     311                        if (!pszPathDir)
     312                        {
     313                            rc = VERR_NO_STR_MEMORY;
    310314                            break;
     315                        }
    311316
    312317                        VBoxServiceVerbose(3, "New path %s\n", pszPathDir);
  • trunk/src/VBox/Devices/Network/lwip/vbox/sys_arch.c

    r28800 r33464  
    383383{
    384384    int rc;
    385     char *pszThread = NULL;
    386385#if SYS_LIGHTWEIGHT_PROT
    387386    SYS_ARCH_DECL_PROTECT(old_level);
     
    400399    g_aTLS[id].thread = thread;
    401400    g_aTLS[id].arg = arg;
    402     RTStrAPrintf(&pszThread, "lwIP%u", id);
    403     rc = RTThreadCreate(&tid, sys_thread_adapter, &g_aTLS[id], 0,
    404                         RTTHREADTYPE_IO, 0, pszThread);
     401    rc = RTThreadCreateF(&tid, sys_thread_adapter, &g_aTLS[id], 0,
     402                         RTTHREADTYPE_IO, 0, "lwIP%u", id);
    405403    if (RT_FAILURE(rc))
    406404    {
  • trunk/src/VBox/Devices/Storage/DrvHostBase.cpp

    r28800 r33464  
    970970        rc = RTStrAPrintf(&pszPassthroughDevice, "/dev/%s%u",
    971971                          DeviceCCB.cgdl.periph_name, DeviceCCB.cgdl.unit_number);
    972         if (RT_SUCCESS(rc))
     972        if (rc >= 0)
    973973        {
    974974            RTFILE PassthroughDevice;
     
    10131013            }
    10141014        }
     1015        else
     1016            rc = VERR_NO_STR_MEMORY;
    10151017    }
    10161018    else
  • trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

    r33355 r33464  
    20752075
    20762076    /* To get all entries with VBoxHDD as prefix. */
    2077     char *pszPluginFilter;
    2078     rc = RTStrAPrintf(&pszPluginFilter, "%s/%s*", szPath, VBOX_HDDFORMAT_PLUGIN_PREFIX);
    2079     if (RT_FAILURE(rc))
    2080     {
    2081         rc = VERR_NO_MEMORY;
    2082         return rc;
    2083     }
     2077    char *pszPluginFilter = RTPathJoinA(szPath, VBOX_HDDFORMAT_PLUGIN_PREFIX "*");
     2078    if (!pszPluginFilter)
     2079        return VERR_NO_STR_MEMORY;
    20842080
    20852081    PRTDIRENTRYEX pPluginDirEntry = NULL;
     
    21272123
    21282124        /* Prepend the path to the libraries. */
    2129         rc = RTStrAPrintf(&pszPluginPath, "%s/%s", szPath, pPluginDirEntry->szName);
    2130         if (RT_FAILURE(rc))
    2131         {
    2132             rc = VERR_NO_MEMORY;
     2125        pszPluginPath = RTPathJoinA(szPath, pPluginDirEntry->szName);
     2126        if (!pszPluginPath)
     2127        {
     2128            rc = VERR_NO_STR_MEMORY;
    21332129            break;
    21342130        }
     
    21952191
    21962192    /* To get all entries with VBoxHDD as prefix. */
    2197     char *pszPluginFilter;
    2198     rc = RTStrAPrintf(&pszPluginFilter, "%s/%s*", szPath, VD_CACHEFORMAT_PLUGIN_PREFIX);
    2199     if (RT_FAILURE(rc))
    2200     {
    2201         rc = VERR_NO_MEMORY;
     2193    char *pszPluginFilter = RTPathJoinA(szPath, VD_CACHEFORMAT_PLUGIN_PREFIX "*");
     2194    if (!pszPluginFilter)
     2195    {
     2196        rc = VERR_NO_STR_MEMORY;
    22022197        return rc;
    22032198    }
     
    22472242
    22482243        /* Prepend the path to the libraries. */
    2249         rc = RTStrAPrintf(&pszPluginPath, "%s/%s", szPath, pPluginDirEntry->szName);
    2250         if (RT_FAILURE(rc))
    2251         {
    2252             rc = VERR_NO_MEMORY;
     2244        pszPluginPath = RTPathJoinA(szPath, pPluginDirEntry->szName);
     2245        if (!pszPluginPath)
     2246        {
     2247            rc = VERR_NO_STR_MEMORY;
    22532248            break;
    22542249        }
  • trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

    r33191 r33464  
    17001700    char *pszValueQuoted;
    17011701
    1702     int rc = RTStrAPrintf(&pszValueQuoted, "\"%s\"", pszValue);
    1703     if (RT_FAILURE(rc))
    1704         return rc;
    1705     rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc, pszKey,
    1706                         pszValueQuoted);
     1702    RTStrAPrintf(&pszValueQuoted, "\"%s\"", pszValue);
     1703    if (!pszValueQuoted)
     1704        return VERR_NO_STR_MEMORY;
     1705    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc, pszKey,
     1706                            pszValueQuoted);
    17071707    RTStrFree(pszValueQuoted);
    17081708    return rc;
     
    18701870    if (pszVal)
    18711871    {
    1872         rc = RTStrAPrintf(&pszValQuoted, "\"%s\"", pszVal);
    1873         if (RT_FAILURE(rc))
    1874             return rc;
     1872        RTStrAPrintf(&pszValQuoted, "\"%s\"", pszVal);
     1873        if (!pszValQuoted)
     1874            return VERR_NO_STR_MEMORY;
    18751875    }
    18761876    else
     
    18881888    char *pszUuid;
    18891889
    1890     int rc = RTStrAPrintf(&pszUuid, "\"%RTuuid\"", pUuid);
    1891     if (RT_FAILURE(rc))
    1892         return rc;
    1893     rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
    1894                         pszUuid);
     1890    RTStrAPrintf(&pszUuid, "\"%RTuuid\"", pUuid);
     1891    if (!pszUuid)
     1892        return VERR_NO_STR_MEMORY;
     1893    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
     1894                            pszUuid);
    18951895    RTStrFree(pszUuid);
    18961896    return rc;
     
    19021902    char *pszValue;
    19031903
    1904     int rc = RTStrAPrintf(&pszValue, "\"%d\"", uValue);
    1905     if (RT_FAILURE(rc))
    1906         return rc;
    1907     rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
    1908                         pszValue);
     1904    RTStrAPrintf(&pszValue, "\"%d\"", uValue);
     1905    if (!pszValue)
     1906        return VERR_NO_STR_MEMORY;
     1907    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
     1908                            pszValue);
    19091909    RTStrFree(pszValue);
    19101910    return rc;
     
    34473447                else
    34483448                {
    3449                     size_t cbDirname;
    34503449                    char *pszDirname = RTStrDup(pImage->pszFilename);
    34513450                    if (!pszDirname)
     
    34553454                    }
    34563455                    RTPathStripFilename(pszDirname);
    3457                     cbDirname = strlen(pszDirname);
    3458                     rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszDirname,
    3459                                       RTPATH_SLASH, pExtent->pszBasename);
     3456                    pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
    34603457                    RTStrFree(pszDirname);
    3461                     if (RT_FAILURE(rc))
     3458                    if (!pszFullname)
     3459                    {
     3460                        rc = VERR_NO_STR_MEMORY;
    34623461                        goto out;
     3462                    }
    34633463                }
    34643464                pExtent->pszFullname = pszFullname;
     
    37203720
    37213721                /* Set up full name for partition extent. */
    3722                 size_t cbDirname;
    37233722                char *pszDirname = RTStrDup(pImage->pszFilename);
    37243723                if (!pszDirname)
    3725                     return VERR_NO_MEMORY;
     3724                    return VERR_NO_STR_MEMORY;
    37263725                RTPathStripFilename(pszDirname);
    3727                 cbDirname = strlen(pszDirname);
    3728                 char *pszFullname;
    3729                 rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszDirname,
    3730                                   RTPATH_SLASH, pExtent->pszBasename);
     3726                char *pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
    37313727                RTStrFree(pszDirname);
    3732                 if (RT_FAILURE(rc))
    3733                     return rc;
     3728                if (!pszDirname)
     3729                    return VERR_NO_STR_MEMORY;
    37343730                pExtent->pszFullname = pszFullname;
    37353731                pExtent->enmType = VMDKETYPE_FLAT;
     
    38883884            {
    38893885                if (cExtents == 1)
    3890                     rc = RTStrAPrintf(&pszTmp, "%s-flat%s", pszBasenameBase,
    3891                                       pszBasenameExt);
     3886                    RTStrAPrintf(&pszTmp, "%s-flat%s", pszBasenameBase,
     3887                                 pszBasenameExt);
    38923888                else
    3893                     rc = RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
    3894                                       i+1, pszBasenameExt);
     3889                    RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
     3890                                 i+1, pszBasenameExt);
    38953891            }
    38963892            else
    3897                 rc = RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, i+1,
    3898                                   pszBasenameExt);
     3893                RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, i+1,
     3894                             pszBasenameExt);
    38993895            RTStrFree(pszBasenameBase);
    3900             if (RT_FAILURE(rc))
    3901                 return rc;
     3896            if (!pszTmp)
     3897                return VERR_NO_STR_MEMORY;
    39023898            cbTmp = strlen(pszTmp) + 1;
    39033899            char *pszBasename = (char *)RTMemTmpAlloc(cbTmp);
     
    39113907        }
    39123908        char *pszBasedirectory = RTStrDup(pImage->pszFilename);
     3909        if (!pszBasedirectory)
     3910            return VERR_NO_STR_MEMORY;
    39133911        RTPathStripFilename(pszBasedirectory);
    3914         char *pszFullname;
    3915         rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszBasedirectory,
    3916                           RTPATH_SLASH, pExtent->pszBasename);
     3912        char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
    39173913        RTStrFree(pszBasedirectory);
    3918         if (RT_FAILURE(rc))
    3919             return rc;
     3914        if (!pszFullname)
     3915            return VERR_NO_STR_MEMORY;
    39203916        pExtent->pszFullname = pszFullname;
    39213917
     
    41104106    char *pszBasedirectory = RTStrDup(pImage->pszFilename);
    41114107    RTPathStripFilename(pszBasedirectory);
    4112     char *pszFullname;
    4113     rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszBasedirectory,
    4114                       RTPATH_SLASH, pExtent->pszBasename);
     4108    char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
    41154109    RTStrFree(pszBasedirectory);
    4116     if (RT_FAILURE(rc))
    4117         return rc;
     4110    if (!pszFullname)
     4111        return VERR_NO_STR_MEMORY;
    41184112    pExtent->pszFullname = pszFullname;
    41194113
  • trunk/src/VBox/Frontends/VBoxHeadless/FramebufferVNC.cpp

    r31698 r33464  
    9393    char *pszDesktopName;
    9494    rc = RTStrAPrintf(&pszDesktopName, "%s - VirtualBox", pszName);
    95     if (RT_SUCCESS(rc))
    96         vncServer->desktopName = (const char*)pszDesktopName;
     95    if (rc >= 0)
     96        vncServer->desktopName = pszDesktopName;
    9797    else
    9898        vncServer->desktopName = "VirtualBox";
  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r33294 r33464  
    13231323                    /* Refer to the correct partition and use offset 0. */
    13241324                    char *psz;
    1325                     vrc = RTStrAPrintf(&psz, "%s%u", rawdisk.c_str(),
    1326                                        partitions.aPartitions[i].uIndex);
    1327                     if (RT_FAILURE(vrc))
     1325                    RTStrAPrintf(&psz, "%s%u", rawdisk.c_str(),
     1326                                 partitions.aPartitions[i].uIndex);
     1327                    if (!psz)
    13281328                    {
     1329                        vrc = VERR_NO_STR_MEMORY;
    13291330                        RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
    1330                                  partitions.aPartitions[i].uIndex, vrc);
     1331                                   partitions.aPartitions[i].uIndex, vrc);
    13311332                        goto out;
    13321333                    }
     
    13361337                    /* Refer to the correct partition and use offset 0. */
    13371338                    char *psz;
    1338                     vrc = RTStrAPrintf(&psz, "%ss%u", rawdisk.c_str(),
    1339                                        partitions.aPartitions[i].uIndex);
    1340                     if (RT_FAILURE(vrc))
     1339                    RTStrAPrintf(&psz, "%ss%u", rawdisk.c_str(),
     1340                                 partitions.aPartitions[i].uIndex);
     1341                    if (!psz)
    13411342                    {
     1343                        vrc = VERR_NO_STR_MEMORY;
    13421344                        RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
    13431345                                 partitions.aPartitions[i].uIndex, vrc);
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r33448 r33464  
    3737#include <iprt/asm.h>
    3838#include <iprt/dir.h>
     39#include <iprt/file.h>
    3940#include <iprt/isofs.h>
    4041#include <iprt/getopt.h>
     
    746747                    if (RTStrAPrintf(&pszFileSource, "%s%s%s",
    747748                                     pszRootDir, pszSubDir ? pszSubDir : "",
    748                                      DirEntry.szName))
     749                                     DirEntry.szName) >= 0)
    749750                    {
    750751                        if (!RTStrAPrintf(&pszFileDest, "%s%s",
    751752                                          pszSubDir ? pszSubDir : "",
    752                                           DirEntry.szName))
     753                                          DirEntry.szName) >= 0)
    753754                        {
    754755                            rc = VERR_NO_MEMORY;
  • trunk/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp

    r31939 r33464  
    207207    {
    208208        *pInstance = Req.Instance;
    209         rc = RTStrAPrintf(ppszClientPath, "%s", Req.achClientPath);
     209        rc = RTStrDupEx(ppszClientPath, Req.achClientPath);
    210210        if (RT_SUCCESS(rc))
    211211            return VINF_SUCCESS;
  • trunk/src/VBox/Main/ApplianceImpl.cpp

    r33417 r33464  
    589589    char *tmpName = RTStrDup(aName.c_str());
    590590    int i = 1;
    591     /* @todo: Maybe too cost-intensive; try to find a lighter way */
     591    /** @todo: Maybe too cost-intensive; try to find a lighter way */
    592592    while (mVirtualBox->FindMachine(Bstr(tmpName).raw(), &machine) != VBOX_E_OBJECT_NOT_FOUND)
    593593    {
     
    609609    /* Check if the file exists or if a file with this path is registered
    610610     * already */
    611     /* @todo: Maybe too cost-intensive; try to find a lighter way */
     611    /** @todo: Maybe too cost-intensive; try to find a lighter way */
    612612    while (    RTPathExists(tmpName)
    613613            || mVirtualBox->FindMedium(Bstr(tmpName).raw(), DeviceType_HardDisk, &harddisk) != VBOX_E_OBJECT_NOT_FOUND
  • trunk/src/VBox/Main/ApplianceImplExport.cpp

    r33417 r33464  
    19241924    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
    19251925    /* The template for the temporary directory created below */
    1926     char *pszTmpDir;
    1927     RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
     1926    char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
    19281927    list< pair<Utf8Str, ULONG> > filesList;
    19291928
  • trunk/src/VBox/Main/ApplianceImplImport.cpp

    r33458 r33464  
    874874    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
    875875    /* The template for the temporary directory created below */
    876     char *pszTmpDir;
    877     RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
     876    char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
    878877    list< pair<Utf8Str, ULONG> > filesList;
    879878    Utf8Str strTmpOvf;
     
    13041303    RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
    13051304    /* The template for the temporary directory created below */
    1306     char *pszTmpDir;
    1307     RTStrAPrintf(&pszTmpDir, "%s"RTPATH_SLASH_STR"vbox-ovf-XXXXXX", szOSTmpDir);
     1305    char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
    13081306    list< pair<Utf8Str, ULONG> > filesList;
    13091307
  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r33408 r33464  
    636636    }
    637637
    638     int rc;
    639     char *pszPropertyName;
     638    char szPropNm[256];
    640639    Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
    641640
    642     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
    643     if (RT_SUCCESS(rc))
    644     {
    645         Bstr clientName;
    646         mVRDEServerInfo->COMGETTER(ClientName)(clientName.asOutParam());
    647 
    648         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
    649                                    clientName.raw(),
    650                                    bstrReadOnlyGuest.raw());
    651         RTStrFree(pszPropertyName);
    652     }
    653 
    654     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
    655     if (RT_SUCCESS(rc))
    656     {
    657         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
    658                                    Bstr(pszUser).raw(),
    659                                    bstrReadOnlyGuest.raw());
    660         RTStrFree(pszPropertyName);
    661     }
    662 
    663     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
    664     if (RT_SUCCESS(rc))
    665     {
    666         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
    667                                    Bstr(pszDomain).raw(),
    668                                    bstrReadOnlyGuest.raw());
    669         RTStrFree(pszPropertyName);
    670     }
    671 
    672     char *pszClientId;
    673     rc = RTStrAPrintf(&pszClientId, "%d", u32ClientId);
    674     if (RT_SUCCESS(rc))
    675     {
    676         mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastConnectedClient").raw(),
    677                                    Bstr(pszClientId).raw(),
    678                                    bstrReadOnlyGuest.raw());
    679         RTStrFree(pszClientId);
    680     }
     641    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
     642    Bstr clientName;
     643    mVRDEServerInfo->COMGETTER(ClientName)(clientName.asOutParam());
     644
     645    mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
     646                               clientName.raw(),
     647                               bstrReadOnlyGuest.raw());
     648
     649    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
     650    mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
     651                               Bstr(pszUser).raw(),
     652                               bstrReadOnlyGuest.raw());
     653
     654    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
     655    mMachine->SetGuestProperty(Bstr(szPropNm).raw(),
     656                               Bstr(pszDomain).raw(),
     657                               bstrReadOnlyGuest.raw());
     658
     659    char szClientId[64];
     660    RTStrPrintf(szClientId, sizeof(szClientId), "%d", u32ClientId);
     661    mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastConnectedClient").raw(),
     662                               Bstr(szClientId).raw(),
     663                               bstrReadOnlyGuest.raw());
    681664
    682665    return;
     
    690673    Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
    691674
    692     int rc;
    693     char *pszPropertyName;
    694 
    695     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
    696     if (RT_SUCCESS(rc))
    697     {
    698         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
    699                                    bstrReadOnlyGuest.raw());
    700         RTStrFree(pszPropertyName);
    701     }
    702 
    703     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
    704     if (RT_SUCCESS(rc))
    705     {
    706         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
    707                                    bstrReadOnlyGuest.raw());
    708         RTStrFree(pszPropertyName);
    709     }
    710 
    711     rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
    712     if (RT_SUCCESS(rc))
    713     {
    714         mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
    715                                    bstrReadOnlyGuest.raw());
    716         RTStrFree(pszPropertyName);
    717     }
    718 
    719     char *pszClientId;
    720     rc = RTStrAPrintf(&pszClientId, "%d", u32ClientId);
    721     if (RT_SUCCESS(rc))
    722     {
    723         mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastDisconnectedClient").raw(),
    724                                    Bstr(pszClientId).raw(),
    725                                    bstrReadOnlyGuest.raw());
    726         RTStrFree(pszClientId);
    727     }
     675    char szPropNm[256];
     676    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
     677    mMachine->SetGuestProperty(Bstr(szPropNm).raw(), Bstr("").raw(),
     678                               bstrReadOnlyGuest.raw());
     679
     680    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/User", u32ClientId);
     681    mMachine->SetGuestProperty(Bstr(szPropNm).raw(), Bstr("").raw(),
     682                               bstrReadOnlyGuest.raw());
     683
     684    RTStrPrintf(szPropNm, sizeof(szPropNm), "/VirtualBox/HostInfo/VRDP/Client/%u/Domain", u32ClientId);
     685    mMachine->SetGuestProperty(Bstr(szPropNm).raw(), Bstr("").raw(),
     686                               bstrReadOnlyGuest.raw());
     687
     688    char szClientId[64];
     689    RTStrPrintf(szClientId, sizeof(szClientId), "%d", u32ClientId);
     690    mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastDisconnectedClient").raw(),
     691                               Bstr(szClientId).raw(),
     692                               bstrReadOnlyGuest.raw());
    728693
    729694    return;
  • trunk/src/VBox/Main/GuestImpl.cpp

    r33446 r33464  
    505505#ifdef VBOX_WITH_GUEST_CONTROL
    506506/**
    507  * Appends environment variables to the environment block. Each var=value pair is separated
    508  * by NULL (\0) sequence. The whole block will be stored in one blob and disassembled on the
    509  * guest side later to fit into the HGCM param structure.
     507 * Appends environment variables to the environment block.
     508 *
     509 * Each var=value pair is separated by the null character ('\\0').  The whole
     510 * block will be stored in one blob and disassembled on the guest side later to
     511 * fit into the HGCM param structure.
    510512 *
    511513 * @returns VBox status code.
    512514 *
    513  * @todo
    514  *
     515 * @param   pszEnvVar       The environment variable=value to append to the
     516 *                          environment block.
     517 * @param   ppvList         This is actually a pointer to a char pointer
     518 *                          variable which keeps track of the environment block
     519 *                          that we're constructing.
     520 * @param   pcbList         Pointer to the variable holding the current size of
     521 *                          the environment block.  (List is a misnomer, go
     522 *                          ahead a be confused.)
     523 * @param   pcEnvVars       Pointer to the variable holding count of variables
     524 *                          stored in the environment block.
    515525 */
    516 int Guest::prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnv)
     526int Guest::prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars)
    517527{
    518528    int rc = VINF_SUCCESS;
    519     uint32_t cbLen = strlen(pszEnv);
     529    uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
    520530    if (*ppvList)
    521531    {
    522         uint32_t cbNewLen = *pcbList + cbLen + 1; /* Include zero termination. */
    523         char *pvTmp = (char*)RTMemRealloc(*ppvList, cbNewLen);
    524         if (NULL == pvTmp)
    525         {
     532        uint32_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
     533        char *pvTmp = (char *)RTMemRealloc(*ppvList, cbNewLen);
     534        if (pvTmp == NULL)
    526535            rc = VERR_NO_MEMORY;
    527         }
    528536        else
    529537        {
    530             memcpy(pvTmp + *pcbList, pszEnv, cbLen);
     538            memcpy(pvTmp + *pcbList, pszEnv, cchEnv);
    531539            pvTmp[cbNewLen - 1] = '\0'; /* Add zero termination. */
    532             *ppvList = (void**)pvTmp;
     540            *ppvList = (void **)pvTmp;
    533541        }
    534542    }
    535543    else
    536544    {
    537         char *pcTmp;
    538         if (RTStrAPrintf(&pcTmp, "%s", pszEnv) > 0)
    539         {
    540             *ppvList = (void**)pcTmp;
     545        char *pszTmp;
     546        if (RTStrAPrintf(&pszTmp, "%s", pszEnv) >= 0)
     547        {
     548            *ppvList = (void **)pszTmp;
    541549            /* Reset counters. */
    542             *pcEnv = 0;
     550            *pcEnvVars = 0;
    543551            *pcbList = 0;
    544552        }
     
    546554    if (RT_SUCCESS(rc))
    547555    {
    548         *pcbList += cbLen + 1; /* Include zero termination. */
    549         *pcEnv += 1;           /* Increase env pairs count. */
     556        *pcbList += cchEnv + 1; /* Include zero termination. */
     557        *pcEnvVars += 1;        /* Increase env variable count. */
    550558    }
    551559    return rc;
  • trunk/src/VBox/Main/linux/USBProxyServiceLinux.cpp

    r33100 r33464  
    169169     */
    170170    int rc;
    171     char *pszDevices;
    172     RTStrAPrintf(&pszDevices, "%s/devices", mUsbfsRoot.c_str());
     171    char *pszDevices = RTPathJoinA(mUsbfsRoot.c_str(), "devices");
    173172    if (pszDevices)
    174173    {
  • trunk/src/VBox/Runtime/common/misc/tar.cpp

    r33289 r33464  
    12981298
    12991299        uint64_t cbOverallWritten = 0;
    1300         for(size_t i=0; i < cFiles; ++i)
     1300        for (size_t i = 0; i < cFiles; ++i)
    13011301        {
    13021302            RTTARFILE hFile;
     
    13041304            if (RT_FAILURE(rc))
    13051305                break;
    1306             char *pszTargetFile;
    1307             rc = RTStrAPrintf(&pszTargetFile, "%s/%s", pszOutputDir, papszFiles[i]);
    1308             if (RT_FAILURE(rc))
    1309                 break;
     1306            char *pszTargetFile = RTPathJoinA(pszOutputDir, papszFiles[i]);
     1307            if (!pszTargetFile)
     1308            {
     1309                rc = VERR_NO_STR_MEMORY;
     1310                break;
     1311            }
    13101312            rc = rtTarExtractFileToFile(hFile, pszTargetFile, cbOverallSize, cbOverallWritten, pfnProgressCallback, pvUser);
    13111313            RTStrFree(pszTargetFile);
  • trunk/src/VBox/Runtime/common/string/straprintf.cpp

    r31157 r33464  
    140140RTDECL(int) RTStrAPrintfVTag(char **ppszBuffer, const char *pszFormat, va_list args, const char *pszTag)
    141141{
     142#ifdef IN_RING3
    142143    char            szBuf[2048];
     144#else
     145    char            szBuf[256];
     146#endif
    143147    STRALLOCARG     Arg;
    144148    Arg.fAllocated  = false;
  • trunk/src/VBox/Runtime/r3/posix/env-posix.cpp

    r28800 r33464  
    103103    AssertReturn(!strchr(pszVar, '='), VERR_INVALID_PARAMETER);
    104104
    105     /* Check that it exists first.  */
     105    /*
     106     * Check that it exists first.
     107     */
    106108    if (!RTEnvExist(pszVar))
    107109        return VINF_ENV_VAR_NOT_FOUND;
    108110
    109     /* Ok, try remove it. */
     111    /*
     112     * Ok, try remove it.
     113     */
    110114#ifdef RT_OS_WINDOWS
    111     /* Windows does not have unsetenv(). Clear the environment variable according to the MSN docs. */
    112     char *pszBuf;
    113     int rc = RTStrAPrintf(&pszBuf, "%s=", pszVar);
    114     if (RT_FAILURE(rc))
    115         return rc;
    116     rc = putenv(pszBuf);
    117     RTStrFree(pszBuf);
    118     if (!rc)
     115    /* Use putenv(var=) since Windows does not have unsetenv(). */
     116    size_t cchVar = strlen(pszVar);
     117    char *pszBuf = (char *)alloca(cchVar + 2);
     118    memcpy(pszBuf, pszVar, cchVar);
     119    pszBuf[cchVar]     = '=';
     120    pszBuf[cchVar + 1] = '\0';
     121
     122    if (!putenv(pszBuf))
    119123        return VINF_SUCCESS;
     124
    120125#else
    121126    /* This is the preferred function as putenv() like used above does neither work on Solaris nor on Darwin. */
  • trunk/src/VBox/Runtime/r3/xml.cpp

    r33056 r33464  
    10451045AttributeNode* ElementNode::setAttribute(const char *pcszName, int32_t i)
    10461046{
    1047     char *psz = NULL;
    1048     RTStrAPrintf(&psz, "%RI32", i);
    1049     AttributeNode *p = setAttribute(pcszName, psz);
    1050     RTStrFree(psz);
     1047    char szValue[64];
     1048    RTStrPrintf(szValue, sizeof(szValue), "%RI32", i);
     1049    AttributeNode *p = setAttribute(pcszName, szValue);
    10511050    return p;
    10521051}
    10531052
    1054 AttributeNode* ElementNode::setAttribute(const char *pcszName, uint32_t i)
    1055 {
    1056     char *psz = NULL;
    1057     RTStrAPrintf(&psz, "%RU32", i);
    1058     AttributeNode *p = setAttribute(pcszName, psz);
    1059     RTStrFree(psz);
     1053AttributeNode* ElementNode::setAttribute(const char *pcszName, uint32_t u)
     1054{
     1055    char szValue[64];
     1056    RTStrPrintf(szValue, sizeof(szValue), "%RU32", u);
     1057    AttributeNode *p = setAttribute(pcszName, szValue);
    10601058    return p;
    10611059}
     
    10631061AttributeNode* ElementNode::setAttribute(const char *pcszName, int64_t i)
    10641062{
    1065     char *psz = NULL;
    1066     RTStrAPrintf(&psz, "%RI64", i);
    1067     AttributeNode *p = setAttribute(pcszName, psz);
    1068     RTStrFree(psz);
     1063    char szValue[64];
     1064    RTStrPrintf(szValue, sizeof(szValue), "%RI64", i);
     1065    AttributeNode *p = setAttribute(pcszName, szValue);
    10691066    return p;
    10701067}
    10711068
    1072 AttributeNode* ElementNode::setAttribute(const char *pcszName, uint64_t i)
    1073 {
    1074     char *psz = NULL;
    1075     RTStrAPrintf(&psz, "%RU64", i);
    1076     AttributeNode *p = setAttribute(pcszName, psz);
    1077     RTStrFree(psz);
     1069AttributeNode* ElementNode::setAttribute(const char *pcszName, uint64_t u)
     1070{
     1071    char szValue[64];
     1072    RTStrPrintf(szValue, sizeof(szValue), "%RU64", u);
     1073    AttributeNode *p = setAttribute(pcszName, szValue);
    10781074    return p;
    10791075}
    10801076
    1081 AttributeNode* ElementNode::setAttributeHex(const char *pcszName, uint32_t i)
    1082 {
    1083     char *psz = NULL;
    1084     RTStrAPrintf(&psz, "0x%RX32", i);
    1085     AttributeNode *p = setAttribute(pcszName, psz);
    1086     RTStrFree(psz);
     1077AttributeNode* ElementNode::setAttributeHex(const char *pcszName, uint32_t u)
     1078{
     1079    char szValue[64];
     1080    RTStrPrintf(szValue, sizeof(szValue), "0x%RX32", u);
     1081    AttributeNode *p = setAttribute(pcszName, szValue);
    10871082    return p;
    10881083}
  • trunk/src/VBox/Runtime/testcase/tstDir-3.cpp

    r28800 r33464  
    8484    const char *pszTestDir = ".";
    8585
    86     char *pszFilter1 = NULL;
    87     rc = RTStrAPrintf(&pszFilter1, "%s%c%s", pszTestDir, RTPATH_SLASH, "xyxzxq*");
    88     if (RT_FAILURE(rc))
     86    char *pszFilter1 = RTPathJoinA(pszTestDir, "xyxzxq*");
     87    if (!pszFilter1)
    8988    {
    90         RTPrintf("tstDir-3: cannot create non-match filter! rc=%Rrc\n", rc);
     89        RTPrintf("tstDir-3: cannot create non-match filter!\n");
    9190        return 1;
    9291    }
    9392
    94     char *pszFilter2 = NULL;
    95     rc = RTStrAPrintf(&pszFilter2, "%s%c%s", pszTestDir, RTPATH_SLASH, "*");
    96     if (RT_FAILURE(rc))
     93    char *pszFilter2 = RTPathJoinA(pszTestDir, "*");
     94    if (!pszFilter2)
    9795    {
    98         RTPrintf("tstDir-3: cannot create match filter! rc=%Rrc\n", rc);
     96        RTPrintf("tstDir-3: cannot create match filter!\n");
    9997        return 1;
    10098    }
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