VirtualBox

Changeset 99758 in vbox for trunk/src/VBox/Runtime/r3


Ignore:
Timestamp:
May 11, 2023 9:37:59 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
157349
Message:

IPRT: Make doxygen 1.9.6 happy. Mostly removing duplicate docs (iprt is documented in the header files). bugref:10442

Location:
trunk/src/VBox/Runtime/r3
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/r3/fileio.cpp

    r98103 r99758  
    210210
    211211
    212 /**
    213  * Gets the current file position.
    214  *
    215  * @returns File offset.
    216  * @returns ~0UUL on failure.
    217  * @param   File        File handle.
    218  */
    219212RTR3DECL(uint64_t)  RTFileTell(RTFILE File)
    220213{

  • trunk/src/VBox/Runtime/r3/ftp-server.cpp

    r99375 r99758  
    12411241 * Destroys a data connection.
    12421242 *
    1243  * @returns VBox status code.
    12441243 * @param   pDataConn           Data connection to destroy. The pointer is not valid anymore after successful return.
    12451244 */
    … …  
    12661265 * Resets a data connection structure.
    12671266 *
    1268  * @returns VBox status code.
    12691267 * @param   pDataConn           Data connection structure to reset.
    12701268 */

  • trunk/src/VBox/Runtime/r3/generic/dirrel-r3-generic.cpp

    r98103 r99758  
    118118
    119119
    120 /**
    121  * Open a file relative to @a hDir.
    122  *
    123  * @returns IPRT status code.
    124  * @param   hDir            The directory to open relative to.
    125  * @param   pszRelFilename  The relative path to the file.
    126  * @param   fOpen           Open flags, i.e a combination of the RTFILE_O_XXX
    127  *                          defines.  The ACCESS, ACTION and DENY flags are
    128  *                          mandatory!
    129  * @param   phFile          Where to store the handle to the opened file.
    130  *
    131  * @sa      RTFileOpen
    132  */
    133120RTDECL(int)  RTDirRelFileOpen(RTDIR hDir, const char *pszRelFilename, uint64_t fOpen, PRTFILE phFile)
    134121{
    … …  
    158145
    159146
    160 /**
    161  * Opens a directory relative to @a hDir.
    162  *
    163  * @returns IPRT status code.
    164  * @param   hDir            The directory to open relative to.
    165  * @param   pszDir          The relative path to the directory to open.
    166  * @param   phDir           Where to store the directory handle.
    167  *
    168  * @sa      RTDirOpen
    169  */
    170147RTDECL(int) RTDirRelDirOpen(RTDIR hDir, const char *pszDir, RTDIR *phDir)
    171148{
    … …  
    183160
    184161
    185 /**
    186  * Opens a directory relative to @a hDir, with flags and optional filtering.
    187  *
    188  * @returns IPRT status code.
    189  * @param   hDir            The directory to open relative to.
    190  * @param   pszDirAndFilter The relative path to the directory to search, this
    191  *                          must include wildcards.
    192  * @param   enmFilter       The kind of filter to apply. Setting this to
    193  *                          RTDIRFILTER_NONE makes this function behave like
    194  *                          RTDirOpen.
    195  * @param   fFlags          Open flags, RTDIR_F_XXX.
    196  * @param   phDir           Where to store the directory handle.
    197  *
    198  * @sa      RTDirOpenFiltered
    199  */
    200162RTDECL(int) RTDirRelDirOpenFiltered(RTDIR hDir, const char *pszDirAndFilter, RTDIRFILTER enmFilter,
    201163                                    uint32_t fFlags, RTDIR *phDir)
    … …  
    213175
    214176
    215 /**
    216  * Creates a directory relative to @a hDir.
    217  *
    218  * @returns IPRT status code.
    219  * @param   hDir            The directory @a pszRelPath is relative to.
    220  * @param   pszRelPath      The relative path to the directory to create.
    221  * @param   fMode           The mode of the new directory.
    222  * @param   fCreate         Create flags, RTDIRCREATE_FLAGS_XXX.
    223  * @param   phSubDir        Where to return the handle of the created directory.
    224  *                          Optional.
    225  *
    226  * @sa      RTDirCreate
    227  */
    228177RTDECL(int) RTDirRelDirCreate(RTDIR hDir, const char *pszRelPath, RTFMODE fMode, uint32_t fCreate, RTDIR *phSubDir)
    229178{
    … …  
    244193
    245194
    246 /**
    247  * Removes a directory relative to @a hDir if empty.
    248  *
    249  * @returns IPRT status code.
    250  * @param   hDir            The directory @a pszRelPath is relative to.
    251  * @param   pszRelPath      The relative path to the directory to remove.
    252  *
    253  * @sa      RTDirRemove
    254  */
    255195RTDECL(int) RTDirRelDirRemove(RTDIR hDir, const char *pszRelPath)
    256196{
    … …  
    277217
    278218
    279 /**
    280  * Query information about a file system object relative to @a hDir.
    281  *
    282  * @returns IPRT status code.
    283  * @retval  VINF_SUCCESS if the object exists, information returned.
    284  * @retval  VERR_PATH_NOT_FOUND if any but the last component in the specified
    285  *          path was not found or was not a directory.
    286  * @retval  VERR_FILE_NOT_FOUND if the object does not exist (but path to the
    287  *          parent directory exists).
    288  *
    289  * @param   hDir            The directory @a pszRelPath is relative to.
    290  * @param   pszRelPath      The relative path to the file system object.
    291  * @param   pObjInfo        Object information structure to be filled on successful
    292  *                          return.
    293  * @param   enmAddAttr      Which set of additional attributes to request.
    294  *                          Use RTFSOBJATTRADD_NOTHING if this doesn't matter.
    295  * @param   fFlags          RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    296  *
    297  * @sa      RTPathQueryInfoEx
    298  */
    299219RTDECL(int) RTDirRelPathQueryInfo(RTDIR hDir, const char *pszRelPath, PRTFSOBJINFO pObjInfo,
    300220                                  RTFSOBJATTRADD enmAddAttr, uint32_t fFlags)
    … …  
    312232
    313233
    314 /**
    315  * Changes the mode flags of a file system object relative to @a hDir.
    316  *
    317  * The API requires at least one of the mode flag sets (Unix/Dos) to
    318  * be set. The type is ignored.
    319  *
    320  * @returns IPRT status code.
    321  * @param   hDir            The directory @a pszRelPath is relative to.
    322  * @param   pszRelPath      The relative path to the file system object.
    323  * @param   fMode           The new file mode, see @ref grp_rt_fs for details.
    324  * @param   fFlags          RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    325  *
    326  * @sa      RTPathSetMode
    327  */
    328234RTDECL(int) RTDirRelPathSetMode(RTDIR hDir, const char *pszRelPath, RTFMODE fMode, uint32_t fFlags)
    329235{
    … …  
    348254
    349255
    350 /**
    351  * Changes one or more of the timestamps associated of file system object
    352  * relative to @a hDir.
    353  *
    354  * @returns IPRT status code.
    355  * @param   hDir                The directory @a pszRelPath is relative to.
    356  * @param   pszRelPath          The relative path to the file system object.
    357  * @param   pAccessTime         Pointer to the new access time.
    358  * @param   pModificationTime   Pointer to the new modification time.
    359  * @param   pChangeTime         Pointer to the new change time. NULL if not to be changed.
    360  * @param   pBirthTime          Pointer to the new time of birth. NULL if not to be changed.
    361  * @param   fFlags              RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    362  *
    363  * @remark  The file system might not implement all these time attributes,
    364  *          the API will ignore the ones which aren't supported.
    365  *
    366  * @remark  The file system might not implement the time resolution
    367  *          employed by this interface, the time will be chopped to fit.
    368  *
    369  * @remark  The file system may update the change time even if it's
    370  *          not specified.
    371  *
    372  * @remark  POSIX can only set Access & Modification and will always set both.
    373  *
    374  * @sa      RTPathSetTimesEx
    375  */
    376256RTDECL(int) RTDirRelPathSetTimes(RTDIR hDir, const char *pszRelPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
    377257                                 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime, uint32_t fFlags)
    … …  
    389269
    390270
    391 /**
    392  * Changes the owner and/or group of a file system object relative to @a hDir.
    393  *
    394  * @returns IPRT status code.
    395  * @param   hDir            The directory @a pszRelPath is relative to.
    396  * @param   pszRelPath      The relative path to the file system object.
    397  * @param   uid             The new file owner user id.  Pass NIL_RTUID to leave
    398  *                          this unchanged.
    399  * @param   gid             The new group id.  Pass NIL_RTGID to leave this
    400  *                          unchanged.
    401  * @param   fFlags          RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    402  *
    403  * @sa      RTPathSetOwnerEx
    404  */
    405271RTDECL(int) RTDirRelPathSetOwner(RTDIR hDir, const char *pszRelPath, uint32_t uid, uint32_t gid, uint32_t fFlags)
    406272{
    … …  
    424290
    425291
    426 /**
    427  * Renames a directory relative path within a filesystem.
    428  *
    429  * This will rename symbolic links.  If RTPATHRENAME_FLAGS_REPLACE is used and
    430  * pszDst is a symbolic link, it will be replaced and not its target.
    431  *
    432  * @returns IPRT status code.
    433  * @param   hDirSrc         The directory the source path is relative to.
    434  * @param   pszSrc          The source path, relative to @a hDirSrc.
    435  * @param   hDirDst         The directory the destination path is relative to.
    436  * @param   pszDst          The destination path, relative to @a hDirDst.
    437  * @param   fRename         Rename flags, RTPATHRENAME_FLAGS_XXX.
    438  *
    439  * @sa      RTPathRename
    440  */
    441292RTDECL(int) RTDirRelPathRename(RTDIR hDirSrc, const char *pszSrc, RTDIR hDirDst, const char *pszDst, unsigned fRename)
    442293{
    … …  
    465316
    466317
    467 /**
    468  * Removes the last component of the directory relative path.
    469  *
    470  * @returns IPRT status code.
    471  * @param   hDir            The directory @a pszRelPath is relative to.
    472  * @param   pszRelPath      The relative path to the file system object.
    473  * @param   fUnlink         Unlink flags, RTPATHUNLINK_FLAGS_XXX.
    474  *
    475  * @sa      RTPathUnlink
    476  */
    477318RTDECL(int) RTDirRelPathUnlink(RTDIR hDir, const char *pszRelPath, uint32_t fUnlink)
    478319{
    … …  
    499340
    500341
    501 /**
    502  * Creates a symbolic link (@a pszSymlink) relative to @a hDir targeting @a
    503  * pszTarget.
    504  *
    505  * @returns IPRT status code.
    506  * @param   hDir            The directory @a pszSymlink is relative to.
    507  * @param   pszSymlink      The relative path of the symbolic link.
    508  * @param   pszTarget       The path to the symbolic link target.  This is
    509  *                          relative to @a pszSymlink or an absolute path.
    510  * @param   enmType         The symbolic link type.  For Windows compatability
    511  *                          it is very important to set this correctly.  When
    512  *                          RTSYMLINKTYPE_UNKNOWN is used, the API will try
    513  *                          make a guess and may attempt query information
    514  *                          about @a pszTarget in the process.
    515  * @param   fCreate         Create flags, RTSYMLINKCREATE_FLAGS_XXX.
    516  *
    517  * @sa      RTSymlinkCreate
    518  */
    519342RTDECL(int) RTDirRelSymlinkCreate(RTDIR hDir, const char *pszSymlink, const char *pszTarget,
    520343                                  RTSYMLINKTYPE enmType, uint32_t fCreate)
    … …  
    532355
    533356
    534 /**
    535  * Read the symlink target relative to @a hDir.
    536  *
    537  * @returns IPRT status code.
    538  * @retval  VERR_NOT_SYMLINK if @a pszSymlink does not specify a symbolic link.
    539  * @retval  VERR_BUFFER_OVERFLOW if the link is larger than @a cbTarget.  The
    540  *          buffer will contain what all we managed to read, fully terminated
    541  *          if @a cbTarget > 0.
    542  *
    543  * @param   hDir            The directory @a pszSymlink is relative to.
    544  * @param   pszSymlink      The relative path to the symbolic link that should
    545  *                          be read.
    546  * @param   pszTarget       The target buffer.
    547  * @param   cbTarget        The size of the target buffer.
    548  * @param   fRead           Read flags, RTSYMLINKREAD_FLAGS_XXX.
    549  *
    550  * @sa      RTSymlinkRead
    551  */
    552357RTDECL(int) RTDirRelSymlinkRead(RTDIR hDir, const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead)
    553358{

  • trunk/src/VBox/Runtime/r3/nt/dirrel-r3-nt.cpp

    r98103 r99758  
    482482
    483483
    484 /**
    485  * Changes the mode flags of a file system object relative to @a hDir.
    486  *
    487  * The API requires at least one of the mode flag sets (Unix/Dos) to
    488  * be set. The type is ignored.
    489  *
    490  * @returns IPRT status code.
    491  * @param   hDir            The directory @a pszRelPath is relative to.
    492  * @param   pszRelPath      The relative path to the file system object.
    493  * @param   fMode           The new file mode, see @ref grp_rt_fs for details.
    494  * @param   fFlags          RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    495  *
    496  * @sa      RTPathSetMode
    497  */
    498484RTDECL(int) RTDirRelPathSetMode(RTDIR hDir, const char *pszRelPath, RTFMODE fMode, uint32_t fFlags)
    499485{
    … …  
    550536
    551537
    552 /**
    553  * Changes one or more of the timestamps associated of file system object
    554  * relative to @a hDir.
    555  *
    556  * @returns IPRT status code.
    557  * @param   hDir                The directory @a pszRelPath is relative to.
    558  * @param   pszRelPath          The relative path to the file system object.
    559  * @param   pAccessTime         Pointer to the new access time.
    560  * @param   pModificationTime   Pointer to the new modification time.
    561  * @param   pChangeTime         Pointer to the new change time. NULL if not to be changed.
    562  * @param   pBirthTime          Pointer to the new time of birth. NULL if not to be changed.
    563  * @param   fFlags              RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    564  *
    565  * @remark  The file system might not implement all these time attributes,
    566  *          the API will ignore the ones which aren't supported.
    567  *
    568  * @remark  The file system might not implement the time resolution
    569  *          employed by this interface, the time will be chopped to fit.
    570  *
    571  * @remark  The file system may update the change time even if it's
    572  *          not specified.
    573  *
    574  * @remark  POSIX can only set Access & Modification and will always set both.
    575  *
    576  * @sa      RTPathSetTimesEx
    577  */
    578538RTDECL(int) RTDirRelPathSetTimes(RTDIR hDir, const char *pszRelPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
    579539                                 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime, uint32_t fFlags)
    … …  
    586546    int rc = rtDirRelBuildFullPath(pThis, szPath, sizeof(szPath), pszRelPath);
    587547    if (RT_SUCCESS(rc))
    588     {
    589 RTAssertMsg2("DBG: RTDirRelPathSetTimes(%s)...\n", szPath);
    590548        rc = RTPathSetTimesEx(szPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, fFlags);
    591     }
    592     return rc;
    593 }
    594 
    595 
    596 /**
    597  * Changes the owner and/or group of a file system object relative to @a hDir.
    598  *
    599  * @returns IPRT status code.
    600  * @param   hDir            The directory @a pszRelPath is relative to.
    601  * @param   pszRelPath      The relative path to the file system object.
    602  * @param   uid             The new file owner user id.  Pass NIL_RTUID to leave
    603  *                          this unchanged.
    604  * @param   gid             The new group id.  Pass NIL_RTGID to leave this
    605  *                          unchanged.
    606  * @param   fFlags          RTPATH_F_ON_LINK or RTPATH_F_FOLLOW_LINK.
    607  *
    608  * @sa      RTPathSetOwnerEx
    609  */
     549    return rc;
     550}
     551
     552
    610553RTDECL(int) RTDirRelPathSetOwner(RTDIR hDir, const char *pszRelPath, uint32_t uid, uint32_t gid, uint32_t fFlags)
    611554{
    … …  
    618561    if (RT_SUCCESS(rc))
    619562    {
    620 RTAssertMsg2("DBG: RTDirRelPathSetOwner(%s)...\n", szPath);
    621563#ifndef RT_OS_WINDOWS
    622564        rc = RTPathSetOwnerEx(szPath, uid, gid, fFlags);
    … …  
    630572
    631573
    632 /**
    633  * Renames a directory relative path within a filesystem.
    634  *
    635  * This will rename symbolic links.  If RTPATHRENAME_FLAGS_REPLACE is used and
    636  * pszDst is a symbolic link, it will be replaced and not its target.
    637  *
    638  * @returns IPRT status code.
    639  * @param   hDirSrc         The directory the source path is relative to.
    640  * @param   pszSrc          The source path, relative to @a hDirSrc.
    641  * @param   hDirSrc         The directory the destination path is relative to.
    642  * @param   pszDst          The destination path, relative to @a hDirDst.
    643  * @param   fRename         Rename flags, RTPATHRENAME_FLAGS_XXX.
    644  *
    645  * @sa      RTPathRename
    646  */
    647574RTDECL(int) RTDirRelPathRename(RTDIR hDirSrc, const char *pszSrc, RTDIR hDirDst, const char *pszDst, unsigned fRename)
    648575{
    … …  
    665592        rc = rtDirRelBuildFullPath(pThis, szDstPath, sizeof(szDstPath), pszDst);
    666593        if (RT_SUCCESS(rc))
    667         {
    668 RTAssertMsg2("DBG: RTDirRelPathRename(%s,%s)...\n", szSrcPath, szDstPath);
    669594            rc = RTPathRename(szSrcPath, szDstPath, fRename);
    670         }
    671     }
    672     return rc;
    673 }
    674 
    675 
    676 /**
    677  * Removes the last component of the directory relative path.
    678  *
    679  * @returns IPRT status code.
    680  * @param   hDir            The directory @a pszRelPath is relative to.
    681  * @param   pszRelPath      The relative path to the file system object.
    682  * @param   fUnlink         Unlink flags, RTPATHUNLINK_FLAGS_XXX.
    683  *
    684  * @sa      RTPathUnlink
    685  */
     595    }
     596    return rc;
     597}
     598
     599
    686600RTDECL(int) RTDirRelPathUnlink(RTDIR hDir, const char *pszRelPath, uint32_t fUnlink)
    687601{
    … …  
    693607    int rc = rtDirRelBuildFullPath(pThis, szPath, sizeof(szPath), pszRelPath);
    694608    if (RT_SUCCESS(rc))
    695     {
    696 RTAssertMsg2("DBG: RTDirRelPathUnlink(%s)...\n", szPath);
    697609        rc = RTPathUnlink(szPath, fUnlink);
    698     }
    699610    return rc;
    700611}
    … …  
    711622
    712623
    713 /**
    714  * Creates a symbolic link (@a pszSymlink) relative to @a hDir targeting @a
    715  * pszTarget.
    716  *
    717  * @returns IPRT status code.
    718  * @param   hDir            The directory @a pszSymlink is relative to.
    719  * @param   pszSymlink      The relative path of the symbolic link.
    720  * @param   pszTarget       The path to the symbolic link target.  This is
    721  *                          relative to @a pszSymlink or an absolute path.
    722  * @param   enmType         The symbolic link type.  For Windows compatability
    723  *                          it is very important to set this correctly.  When
    724  *                          RTSYMLINKTYPE_UNKNOWN is used, the API will try
    725  *                          make a guess and may attempt query information
    726  *                          about @a pszTarget in the process.
    727  * @param   fCreate         Create flags, RTSYMLINKCREATE_FLAGS_XXX.
    728  *
    729  * @sa      RTSymlinkCreate
    730  */
    731624RTDECL(int) RTDirRelSymlinkCreate(RTDIR hDir, const char *pszSymlink, const char *pszTarget,
    732625                                  RTSYMLINKTYPE enmType, uint32_t fCreate)
    … …  
    739632    int rc = rtDirRelBuildFullPath(pThis, szPath, sizeof(szPath), pszSymlink);
    740633    if (RT_SUCCESS(rc))
    741     {
    742 RTAssertMsg2("DBG: RTDirRelSymlinkCreate(%s)...\n", szPath);
    743634        rc = RTSymlinkCreate(szPath, pszTarget, enmType, fCreate);
    744     }
    745     return rc;
    746 }
    747 
    748 
    749 /**
    750  * Read the symlink target relative to @a hDir.
    751  *
    752  * @returns IPRT status code.
    753  * @retval  VERR_NOT_SYMLINK if @a pszSymlink does not specify a symbolic link.
    754  * @retval  VERR_BUFFER_OVERFLOW if the link is larger than @a cbTarget.  The
    755  *          buffer will contain what all we managed to read, fully terminated
    756  *          if @a cbTarget > 0.
    757  *
    758  * @param   hDir            The directory @a pszSymlink is relative to.
    759  * @param   pszSymlink      The relative path to the symbolic link that should
    760  *                          be read.
    761  * @param   pszTarget       The target buffer.
    762  * @param   cbTarget        The size of the target buffer.
    763  * @param   fRead           Read flags, RTSYMLINKREAD_FLAGS_XXX.
    764  *
    765  * @sa      RTSymlinkRead
    766  */
     635    return rc;
     636}
     637
     638
    767639RTDECL(int) RTDirRelSymlinkRead(RTDIR hDir, const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead)
    768640{
    … …  
    774646    int rc = rtDirRelBuildFullPath(pThis, szPath, sizeof(szPath), pszSymlink);
    775647    if (RT_SUCCESS(rc))
    776     {
    777 RTAssertMsg2("DBG: RTDirRelSymlinkRead(%s)...\n", szPath);
    778648        rc = RTSymlinkRead(szPath, pszTarget, cbTarget, fRead);
    779     }
    780     return rc;
    781 }
    782 
     649    return rc;
     650}
     651

  • trunk/src/VBox/Runtime/r3/stream.cpp

    r98103 r99758  
    642642
    643643
    644 /**
    645  * Opens a file stream.
    646  *
    647  * @returns iprt status code.
    648  * @param   pszFilename     Path to the file to open.
    649  * @param   pszMode         The open mode. See fopen() standard.
    650  *                          Format: <a|r|w>[+][b|t][x][e|N|E]
    651  *                              - 'a': Open or create file and writes
    652  *                                append tos it.
    653  *                              - 'r': Open existing file and read from it.
    654  *                              - 'w': Open or truncate existing file and write
    655  *                                to it.
    656  *                              - '+': Open for both read and write access.
    657  *                              - 'b' / 't': binary / text
    658  *                              - 'x': exclusively create, no open. Only
    659  *                                possible with 'w'.
    660  *                              - 'e' / 'N': No inherit on exec.  (The 'e' is
    661  *                                how Linux and FreeBSD expresses this, the
    662  *                                latter is Visual C++).
    663  * @param   ppStream        Where to store the opened stream.
    664  */
    665644RTR3DECL(int) RTStrmOpen(const char *pszFilename, const char *pszMode, PRTSTREAM *ppStream)
    666645{
    … …  
    671650
    672651
    673 /**
    674  * Opens a file stream.
    675  *
    676  * @returns iprt status code.
    677  * @param   pszMode         The open mode. See fopen() standard.
    678  *                          Format: <a|r|w>[+][b]
    679  * @param   ppStream        Where to store the opened stream.
    680  * @param   pszFilenameFmt  Filename path format string.
    681  * @param   args            Arguments to the format string.
    682  */
    683652RTR3DECL(int) RTStrmOpenFV(const char *pszMode, PRTSTREAM *ppStream, const char *pszFilenameFmt, va_list args)
    684653{
    … …  
    697666
    698667
    699 /**
    700  * Opens a file stream.
    701  *
    702  * @returns iprt status code.
    703  * @param   pszMode         The open mode. See fopen() standard.
    704  *                          Format: <a|r|w>[+][b]
    705  * @param   ppStream        Where to store the opened stream.
    706  * @param   pszFilenameFmt  Filename path format string.
    707  * @param   ...             Arguments to the format string.
    708  */
    709668RTR3DECL(int) RTStrmOpenF(const char *pszMode, PRTSTREAM *ppStream, const char *pszFilenameFmt, ...)
    710669{
    … …  
    717676
    718677
    719 /**
    720  * Opens a file stream for a RTFILE handle, taking ownership of the handle.
    721  *
    722  * @returns iprt status code.
    723  * @param   hFile           The file handle to use.  On success, handle
    724  *                          ownership is transfered to the stream and it will be
    725  *                          closed when the stream closes.
    726  * @param   pszMode         The open mode, accept the same as RTStrOpen and
    727  *                          friends however it is only used to figure out what
    728  *                          we can do with the handle.
    729  * @param   fFlags          Reserved, must be zero.
    730  * @param   ppStream        Where to store the opened stream.
    731  */
    732678RTR3DECL(int) RTStrmOpenFileHandle(RTFILE hFile, const char *pszMode, uint32_t fFlags, PRTSTREAM *ppStream)
    733679{
    … …  
    739685
    740686
    741 /**
    742  * Closes the specified stream.
    743  *
    744  * @returns iprt status code.
    745  * @param   pStream         The stream to close.
    746  */
    747687RTR3DECL(int) RTStrmClose(PRTSTREAM pStream)
    748688{
    … …  
    815755
    816756
    817 /**
    818  * Get the pending error of the stream.
    819  *
    820  * @returns iprt status code. of the stream.
    821  * @param   pStream         The stream.
    822  */
    823757RTR3DECL(int) RTStrmError(PRTSTREAM pStream)
    824758{
    … …  
    829763
    830764
    831 /**
    832  * Clears stream error condition.
    833  *
    834  * All stream operations save RTStrmClose and this will fail
    835  * while an error is asserted on the stream
    836  *
    837  * @returns iprt status code.
    838  * @param   pStream         The stream.
    839  */
    840765RTR3DECL(int) RTStrmClearError(PRTSTREAM pStream)
    841766{
    … …  
    16741599
    16751600
    1676 /**
    1677  * Rewinds the stream.
    1678  *
    1679  * Stream errors will be reset on success.
    1680  *
    1681  * @returns IPRT status code.
    1682  *
    1683  * @param   pStream         The stream.
    1684  *
    1685  * @remarks Not all streams are rewindable and that behavior is currently
    1686  *          undefined for those.
    1687  */
    16881601RTR3DECL(int) RTStrmRewind(PRTSTREAM pStream)
    16891602{
    … …  
    17121625
    17131626
    1714 /**
    1715  * Changes the file position.
    1716  *
    1717  * @returns IPRT status code.
    1718  *
    1719  * @param   pStream         The stream.
    1720  * @param   off             The seek offset.
    1721  * @param   uMethod         Seek method, i.e. one of the RTFILE_SEEK_* defines.
    1722  *
    1723  * @remarks Not all streams are seekable and that behavior is currently
    1724  *          undefined for those.
    1725  */
    17261627RTR3DECL(int) RTStrmSeek(PRTSTREAM pStream, RTFOFF off, uint32_t uMethod)
    17271628{
    … …  
    17531654
    17541655
    1755 /**
    1756  * Tells the stream position.
    1757  *
    1758  * @returns Stream position or IPRT error status. Non-negative numbers are
    1759  *          stream positions, while negative numbers are IPRT error stauses.
    1760  *
    1761  * @param   pStream         The stream.
    1762  *
    1763  * @remarks Not all streams have a position and that behavior is currently
    1764  *          undefined for those.
    1765  */
    17661656RTR3DECL(RTFOFF) RTStrmTell(PRTSTREAM pStream)
    17671657{
    … …  
    18501740
    18511741
    1852 /**
    1853  * Reads from a file stream.
    1854  *
    1855  * @returns iprt status code.
    1856  * @param   pStream         The stream.
    1857  * @param   pvBuf           Where to put the read bits.
    1858  *                          Must be cbRead bytes or more.
    1859  * @param   cbToRead        Number of bytes to read.
    1860  * @param   pcbRead         Where to store the number of bytes actually read.
    1861  *                          If NULL cbRead bytes are read or an error is returned.
    1862  */
    18631742RTR3DECL(int) RTStrmReadEx(PRTSTREAM pStream, void *pvBuf, size_t cbToRead, size_t *pcbRead)
    18641743{
    … …  
    23212200
    23222201
    2323 /**
    2324  * Writes to a file stream.
    2325  *
    2326  * @returns iprt status code.
    2327  * @param   pStream         The stream.
    2328  * @param   pvBuf           Where to get the bits to write from.
    2329  * @param   cbToWrite       Number of bytes to write.
    2330  * @param   pcbWritten      Where to store the number of bytes actually written.
    2331  *                          If NULL cbToWrite bytes are written or an error is
    2332  *                          returned.
    2333  */
    23342202RTR3DECL(int) RTStrmWriteEx(PRTSTREAM pStream, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten)
    23352203{
    … …  
    23392207
    23402208
    2341 /**
    2342  * Reads a character from a file stream.
    2343  *
    2344  * @returns The char as an unsigned char cast to int.
    2345  * @returns -1 on failure.
    2346  * @param   pStream         The stream.
    2347  */
    23482209RTR3DECL(int) RTStrmGetCh(PRTSTREAM pStream)
    23492210{
    … …  
    23562217
    23572218
    2358 /**
    2359  * Writes a character to a file stream.
    2360  *
    2361  * @returns iprt status code.
    2362  * @param   pStream         The stream.
    2363  * @param   ch              The char to write.
    2364  */
    23652219RTR3DECL(int) RTStrmPutCh(PRTSTREAM pStream, int ch)
    23662220{
    … …  
    23692223
    23702224
    2371 /**
    2372  * Writes a string to a file stream.
    2373  *
    2374  * @returns iprt status code.
    2375  * @param   pStream         The stream.
    2376  * @param   pszString       The string to write.
    2377  *                          No newlines or anything is appended or prepended.
    2378  *                          The terminating '\\0' is not written, of course.
    2379  */
    23802225RTR3DECL(int) RTStrmPutStr(PRTSTREAM pStream, const char *pszString)
    23812226{
    … …  
    25412386
    25422387
    2543 /**
    2544  * Flushes a stream.
    2545  *
    2546  * @returns iprt status code.
    2547  * @param   pStream         The stream to flush.
    2548  */
    25492388RTR3DECL(int) RTStrmFlush(PRTSTREAM pStream)
    25502389{
    … …  
    25832422
    25842423
    2585 /**
    2586  * Prints a formatted string to the specified stream.
    2587  *
    2588  * @returns Number of bytes printed.
    2589  * @param   pStream         The stream to print to.
    2590  * @param   pszFormat       IPRT format string.
    2591  * @param   args            Arguments specified by pszFormat.
    2592  */
    25932424RTR3DECL(int) RTStrmPrintfV(PRTSTREAM pStream, const char *pszFormat, va_list args)
    25942425{
    … …  
    26092440
    26102441
    2611 /**
    2612  * Prints a formatted string to the specified stream.
    2613  *
    2614  * @returns Number of bytes printed.
    2615  * @param   pStream         The stream to print to.
    2616  * @param   pszFormat       IPRT format string.
    2617  * @param   ...             Arguments specified by pszFormat.
    2618  */
    26192442RTR3DECL(int) RTStrmPrintf(PRTSTREAM pStream, const char *pszFormat, ...)
    26202443{
    … …  
    26272450
    26282451
    2629 /**
    2630  * Dumper vprintf-like function outputting to a stream.
    2631  *
    2632  * @param   pvUser          The stream to print to.  NULL means standard output.
    2633  * @param   pszFormat       Runtime format string.
    2634  * @param   va              Arguments specified by pszFormat.
    2635  */
    26362452RTDECL(void) RTStrmDumpPrintfV(void *pvUser, const char *pszFormat, va_list va)
    26372453{
    … …  
    26402456
    26412457
    2642 /**
    2643  * Prints a formatted string to the standard output stream (g_pStdOut).
    2644  *
    2645  * @returns Number of bytes printed.
    2646  * @param   pszFormat       IPRT format string.
    2647  * @param   args            Arguments specified by pszFormat.
    2648  */
    26492458RTR3DECL(int) RTPrintfV(const char *pszFormat, va_list args)
    26502459{
    … …  
    26532462
    26542463
    2655 /**
    2656  * Prints a formatted string to the standard output stream (g_pStdOut).
    2657  *
    2658  * @returns Number of bytes printed.
    2659  * @param   pszFormat       IPRT format string.
    2660  * @param   ...             Arguments specified by pszFormat.
    2661  */
    26622464RTR3DECL(int) RTPrintf(const char *pszFormat, ...)
    26632465{

  • trunk/src/VBox/Runtime/r3/tcp.cpp

    r98103 r99758  
    215215
    216216
    217 /**
    218  * Create single connection at a time TCP Server in a separate thread.
    219  *
    220  * The thread will loop accepting connections and call pfnServe for
    221  * each of the incoming connections in turn. The pfnServe function can
    222  * return VERR_TCP_SERVER_STOP too terminate this loop. RTTcpServerDestroy()
    223  * should be used to terminate the server.
    224  *
    225  * @returns iprt status code.
    226  * @param   pszAddress      The address for creating a listening socket.
    227  *                          If NULL or empty string the server is bound to all interfaces.
    228  * @param   uPort           The port for creating a listening socket.
    229  * @param   enmType         The thread type.
    230  * @param   pszThrdName     The name of the worker thread.
    231  * @param   pfnServe        The function which will serve a new client connection.
    232  * @param   pvUser          User argument passed to pfnServe.
    233  * @param   ppServer        Where to store the serverhandle.
    234  */
    235217RTR3DECL(int)  RTTcpServerCreate(const char *pszAddress, unsigned uPort, RTTHREADTYPE enmType, const char *pszThrdName,
    236218                                 PFNRTTCPSERVE pfnServe, void *pvUser, PPRTTCPSERVER ppServer)
    … …  
    302284
    303285
    304 /**
    305  * Create single connection at a time TCP Server.
    306  * The caller must call RTTcpServerListen() to actually start the server.
    307  *
    308  * @returns iprt status code.
    309  * @param   pszAddress      The address for creating a listening socket.
    310  *                          If NULL the server is bound to all interfaces.
    311  * @param   uPort           The port for creating a listening socket.
    312  * @param   ppServer        Where to store the serverhandle.
    313  */
    314286RTR3DECL(int) RTTcpServerCreateEx(const char *pszAddress, uint32_t uPort, PPRTTCPSERVER ppServer)
    315287{
    … …  
    379351
    380352
    381 /**
    382  * Listen for incoming connections.
    383  *
    384  * The function will loop accepting connections and call pfnServe for
    385  * each of the incoming connections in turn. The pfnServe function can
    386  * return VERR_TCP_SERVER_STOP too terminate this loop. A stopped server
    387  * can only be destroyed.
    388  *
    389  * @returns IPRT status code.
    390  * @retval  VERR_TCP_SERVER_STOP if stopped by pfnServe.
    391  * @retval  VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
    392  *
    393  * @param   pServer         The server handle as returned from RTTcpServerCreateEx().
    394  * @param   pfnServe        The function which will serve a new client connection.
    395  * @param   pvUser          User argument passed to pfnServe.
    396  */
    397353RTR3DECL(int) RTTcpServerListen(PRTTCPSERVER pServer, PFNRTTCPSERVE pfnServe, void *pvUser)
    398354{
    … …  
    560516
    561517
    562 /**
    563  * Listen and accept one incoming connection.
    564  *
    565  * This is an alternative to RTTcpServerListen for the use the callbacks are not
    566  * possible.
    567  *
    568  * @returns IPRT status code.
    569  * @retval  VERR_TCP_SERVER_SHUTDOWN if shut down by RTTcpServerShutdown.
    570  * @retval  VERR_INTERRUPTED if the listening was interrupted.
    571  *
    572  * @param   pServer         The server handle as returned from RTTcpServerCreateEx().
    573  * @param   phClientSocket  Where to return the socket handle to the client
    574  *                          connection (on success only).  This must be closed
    575  *                          by calling RTTcpServerDisconnectClient2().
    576  */
    577518RTR3DECL(int) RTTcpServerListen2(PRTTCPSERVER pServer, PRTSOCKET phClientSocket)
    578519{
    … …  
    656597
    657598
    658 /**
    659  * Terminate the open connection to the server.
    660  *
    661  * @returns iprt status code.
    662  * @param   pServer         Handle to the server.
    663  */
    664599RTR3DECL(int) RTTcpServerDisconnectClient(PRTTCPSERVER pServer)
    665600{
    … …  
    678613
    679614
    680 /**
    681  * Terminates an open client connect when using RTTcpListen2
    682  *
    683  * @returns IPRT status code.
    684  * @param   hClientSocket   The client socket handle.  This will be invalid upon
    685  *                          return, whether successful or not.  NIL is quietly
    686  *                          ignored (VINF_SUCCESS).
    687  */
    688615RTR3DECL(int) RTTcpServerDisconnectClient2(RTSOCKET hClientSocket)
    689616{
    … …  
    692619
    693620
    694 /**
    695  * Shuts down the server, leaving client connections open.
    696  *
    697  * @returns IPRT status code.
    698  * @param   pServer         Handle to the server.
    699  */
    700621RTR3DECL(int) RTTcpServerShutdown(PRTTCPSERVER pServer)
    701622{
    … …  
    745666
    746667
    747 /**
    748  * Closes down and frees a TCP Server.
    749  * This will also terminate any open connections to the server.
    750  *
    751  * @returns iprt status code.
    752  * @param   pServer         Handle to the server.
    753  */
    754668RTR3DECL(int) RTTcpServerDestroy(PRTTCPSERVER pServer)
    755669{
    … …  
    1028942
    1029943
    1030 /**
    1031  * Creates connected pair of TCP sockets.
    1032  *
    1033  * @returns IPRT status code.
    1034  * @param   phServer            Where to return the "server" side of the pair.
    1035  * @param   phClient            Where to return the "client" side of the pair.
    1036  *
    1037  * @note    There is no server or client side, but we gotta call it something.
    1038  */
    1039944RTR3DECL(int) RTTcpCreatePair(PRTSOCKET phServer, PRTSOCKET phClient, uint32_t fFlags)
    1040945{

  • trunk/src/VBox/Runtime/r3/test.cpp

    r98103 r99758  
    486486
    487487
    488 /**
    489  * Destroys a test instance previously created by RTTestCreate.
    490  *
    491  * @returns IPRT status code.
    492  * @param   hTest       The test handle. NIL_RTTEST is ignored.
    493  */
    494488RTR3DECL(int) RTTestDestroy(RTTEST hTest)
    495489{
    … …  
    540534
    541535
    542 /**
    543  * Changes the default test instance for the calling thread.
    544  *
    545  * @returns IPRT status code.
    546  *
    547  * @param   hNewDefaultTest The new default test. NIL_RTTEST is fine.
    548  * @param   phOldTest       Where to store the old test handle. Optional.
    549  */
    550536RTR3DECL(int) RTTestSetDefault(RTTEST hNewDefaultTest, PRTTEST phOldTest)
    551537{
    … …  
    584570
    585571
    586 /**
    587  * Allocate a block of guarded memory.
    588  *
    589  * @returns IPRT status code.
    590  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    591  *                      associated with the calling thread.
    592  * @param   cb          The amount of memory to allocate.
    593  * @param   cbAlign     The alignment of the returned block.
    594  * @param   fHead       Head or tail optimized guard.
    595  * @param   ppvUser     Where to return the pointer to the block.
    596  */
    597572RTR3DECL(int) RTTestGuardedAlloc(RTTEST hTest, size_t cb, uint32_t cbAlign, bool fHead, void **ppvUser)
    598573{
    … …  
    662637
    663638
    664 /**
    665  * Allocates a block of guarded memory where the guarded is immediately after
    666  * the user memory.
    667  *
    668  * @returns Pointer to the allocated memory. NULL on failure.
    669  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    670  *                      associated with the calling thread.
    671  * @param   cb          The amount of memory to allocate.
    672  */
    673639RTR3DECL(void *) RTTestGuardedAllocTail(RTTEST hTest, size_t cb)
    674640{
    … …  
    681647
    682648
    683 /**
    684  * Allocates a block of guarded memory where the guarded is right in front of
    685  * the user memory.
    686  *
    687  * @returns Pointer to the allocated memory. NULL on failure.
    688  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    689  *                      associated with the calling thread.
    690  * @param   cb          The amount of memory to allocate.
    691  */
    692649RTR3DECL(void *) RTTestGuardedAllocHead(RTTEST hTest, size_t cb)
    693650{
    … …  
    717674
    718675
    719 /**
    720  * Frees a block of guarded memory.
    721  *
    722  * @returns IPRT status code.
    723  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    724  *                      associated with the calling thread.
    725  * @param   pv          The memory. NULL is ignored.
    726  */
    727676RTR3DECL(int) RTTestGuardedFree(RTTEST hTest, void *pv)
    728677{
    … …  
    11011050
    11021051
    1103 /**
    1104  * Test vprintf making sure the output starts on a new line.
    1105  *
    1106  * @returns Number of chars printed.
    1107  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1108  *                      associated with the calling thread.
    1109  * @param   enmLevel    Message importance level.
    1110  * @param   pszFormat   The message.
    1111  * @param   va          Arguments.
    1112  */
    11131052RTR3DECL(int) RTTestPrintfNlV(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, va_list va)
    11141053{
    … …  
    11321071
    11331072
    1134 /**
    1135  * Test printf making sure the output starts on a new line.
    1136  *
    1137  * @returns Number of chars printed.
    1138  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1139  *                      associated with the calling thread.
    1140  * @param   enmLevel    Message importance level.
    1141  * @param   pszFormat   The message.
    1142  * @param   ...         Arguments.
    1143  */
    11441073RTR3DECL(int) RTTestPrintfNl(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, ...)
    11451074{
    … …  
    11541083
    11551084
    1156 /**
    1157  * Test vprintf, makes sure lines are prefixed and so forth.
    1158  *
    1159  * @returns Number of chars printed.
    1160  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1161  *                      associated with the calling thread.
    1162  * @param   enmLevel    Message importance level.
    1163  * @param   pszFormat   The message.
    1164  * @param   va          Arguments.
    1165  */
    11661085RTR3DECL(int) RTTestPrintfV(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, va_list va)
    11671086{
    … …  
    11791098
    11801099
    1181 /**
    1182  * Test printf, makes sure lines are prefixed and so forth.
    1183  *
    1184  * @returns Number of chars printed.
    1185  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1186  *                      associated with the calling thread.
    1187  * @param   enmLevel    Message importance level.
    1188  * @param   pszFormat   The message.
    1189  * @param   ...         Arguments.
    1190  */
    11911100RTR3DECL(int) RTTestPrintf(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, ...)
    11921101{
    … …  
    12011110
    12021111
    1203 /**
    1204  * Prints the test banner.
    1205  *
    1206  * @returns Number of chars printed.
    1207  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1208  *                      associated with the calling thread.
    1209  */
    12101112RTR3DECL(int) RTTestBanner(RTTEST hTest)
    12111113{
    … …  
    12821184
    12831185
    1284 /**
    1285  * Summaries the test, destroys the test instance and return an exit code.
    1286  *
    1287  * @returns Test program exit code.
    1288  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1289  *                      associated with the calling thread.
    1290  */
    12911186RTR3DECL(RTEXITCODE) RTTestSummaryAndDestroy(RTTEST hTest)
    12921187{
    … …  
    13531248
    13541249
    1355 /**
    1356  * Starts a sub-test.
    1357  *
    1358  * This will perform an implicit RTTestSubDone() call if that has not been done
    1359  * since the last RTTestSub call.
    1360  *
    1361  * @returns Number of chars printed.
    1362  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1363  *                      associated with the calling thread.
    1364  * @param   pszSubTest  The sub-test name
    1365  */
    13661250RTR3DECL(int) RTTestSub(RTTEST hTest, const char *pszSubTest)
    13671251{
    … …  
    14021286
    14031287
    1404 /**
    1405  * Format string version of RTTestSub.
    1406  *
    1407  * See RTTestSub for details.
    1408  *
    1409  * @returns Number of chars printed.
    1410  * @param   hTest           The test handle. If NIL_RTTEST we'll use the one
    1411  *                          associated with the calling thread.
    1412  * @param   pszSubTestFmt   The sub-test name format string.
    1413  * @param   ...             Arguments.
    1414  */
    14151288RTR3DECL(int) RTTestSubF(RTTEST hTest, const char *pszSubTestFmt, ...)
    14161289{
    … …  
    14231296
    14241297
    1425 /**
    1426  * Format string version of RTTestSub.
    1427  *
    1428  * See RTTestSub for details.
    1429  *
    1430  * @returns Number of chars printed.
    1431  * @param   hTest           The test handle. If NIL_RTTEST we'll use the one
    1432  *                          associated with the calling thread.
    1433  * @param   pszSubTestFmt   The sub-test name format string.
    1434  * @param   ...             Arguments.
    1435  */
    14361298RTR3DECL(int) RTTestSubV(RTTEST hTest, const char *pszSubTestFmt, va_list va)
    14371299{
    … …  
    14481310
    14491311
    1450 /**
    1451  * Completes a sub-test.
    1452  *
    1453  * @returns Number of chars printed.
    1454  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1455  *                      associated with the calling thread.
    1456  */
    14571312RTR3DECL(int) RTTestSubDone(RTTEST hTest)
    14581313{
    … …  
    14671322}
    14681323
    1469 /**
    1470  * Prints an extended PASSED message, optional.
    1471  *
    1472  * This does not conclude the sub-test, it could be used to report the passing
    1473  * of a sub-sub-to-the-power-of-N-test.
    1474  *
    1475  * @returns IPRT status code.
    1476  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1477  *                      associated with the calling thread.
    1478  * @param   pszFormat   The message. No trailing newline.
    1479  * @param   va          The arguments.
    1480  */
     1324
    14811325RTR3DECL(int) RTTestPassedV(RTTEST hTest, const char *pszFormat, va_list va)
    14821326{
    … …  
    15021346
    15031347
    1504 /**
    1505  * Prints an extended PASSED message, optional.
    1506  *
    1507  * This does not conclude the sub-test, it could be used to report the passing
    1508  * of a sub-sub-to-the-power-of-N-test.
    1509  *
    1510  * @returns IPRT status code.
    1511  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1512  *                      associated with the calling thread.
    1513  * @param   pszFormat   The message. No trailing newline.
    1514  * @param   ...         The arguments.
    1515  */
    15161348RTR3DECL(int) RTTestPassed(RTTEST hTest, const char *pszFormat, ...)
    15171349{
    … …  
    16731505
    16741506
    1675 /**
    1676  * Increments the error counter.
    1677  *
    1678  * @returns IPRT status code.
    1679  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1680  *                      associated with the calling thread.
    1681  */
    16821507RTR3DECL(int) RTTestErrorInc(RTTEST hTest)
    16831508{
    … …  
    16911516
    16921517
    1693 
    1694 /**
    1695  * Get the current error count.
    1696  *
    1697  * @returns The error counter, UINT32_MAX if no valid test handle.
    1698  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1699  *                      associated with the calling thread.
    1700  */
    17011518RTR3DECL(uint32_t) RTTestErrorCount(RTTEST hTest)
    17021519{
    … …  
    17171534
    17181535
    1719 /**
    1720  * Increments the error counter and prints a failure message.
    1721  *
    1722  * @returns IPRT status code.
    1723  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1724  *                      associated with the calling thread.
    1725  * @param   pszFormat   The message. No trailing newline.
    1726  * @param   va          The arguments.
    1727  */
    17281536RTR3DECL(int) RTTestFailedV(RTTEST hTest, const char *pszFormat, va_list va)
    17291537{
    … …  
    17601568
    17611569
    1762 /**
    1763  * Increments the error counter and prints a failure message.
    1764  *
    1765  * @returns IPRT status code.
    1766  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1767  *                      associated with the calling thread.
    1768  * @param   pszFormat   The message. No trailing newline.
    1769  * @param   ...         The arguments.
    1770  */
    17711570RTR3DECL(int) RTTestFailed(RTTEST hTest, const char *pszFormat, ...)
    17721571{
    … …  
    17811580
    17821581
    1783 /**
    1784  * Same as RTTestPrintfV with RTTESTLVL_FAILURE.
    1785  *
    1786  * @returns Number of chars printed.
    1787  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1788  *                      associated with the calling thread.
    1789  * @param   pszFormat   The message.
    1790  * @param   va          Arguments.
    1791  */
    17921582RTR3DECL(int) RTTestFailureDetailsV(RTTEST hTest, const char *pszFormat, va_list va)
    17931583{
    … …  
    17961586
    17971587
    1798 /**
    1799  * Same as RTTestPrintf with RTTESTLVL_FAILURE.
    1800  *
    1801  * @returns Number of chars printed.
    1802  * @param   hTest       The test handle. If NIL_RTTEST we'll use the one
    1803  *                      associated with the calling thread.
    1804  * @param   pszFormat   The message.
    1805  * @param   ...         Arguments.
    1806  */
    18071588RTR3DECL(int) RTTestFailureDetails(RTTEST hTest, const char *pszFormat, ...)
    18081589{

  • trunk/src/VBox/Runtime/r3/udp.cpp

    r98103 r99758  
    185185
    186186
    187 /**
    188  * Create single datagram at a time UDP Server in a separate thread.
    189  *
    190  * The thread will loop waiting for datagrams and call pfnServe for
    191  * each of the incoming datagrams in turn. The pfnServe function can
    192  * return VERR_UDP_SERVER_STOP too terminate this loop. RTUdpServerDestroy()
    193  * should be used to terminate the server.
    194  *
    195  * @returns iprt status code.
    196  * @param   pszAddress      The address for creating a datagram socket.
    197  *                          If NULL or empty string the server is bound to all interfaces.
    198  * @param   uPort           The port for creating a datagram socket.
    199  * @param   enmType         The thread type.
    200  * @param   pszThrdName     The name of the worker thread.
    201  * @param   pfnServe        The function which will handle incoming datagrams.
    202  * @param   pvUser          User argument passed to pfnServe.
    203  * @param   ppServer        Where to store the serverhandle.
    204  */
    205187RTR3DECL(int)  RTUdpServerCreate(const char *pszAddress, unsigned uPort, RTTHREADTYPE enmType, const char *pszThrdName,
    206188                                 PFNRTUDPSERVE pfnServe, void *pvUser, PPRTUDPSERVER ppServer)
    … …  
    272254
    273255
    274 /**
    275  * Create single datagram at a time UDP Server.
    276  * The caller must call RTUdpServerReceive() to actually start the server.
    277  *
    278  * @returns iprt status code.
    279  * @param   pszAddress      The address for creating a datagram socket.
    280  *                          If NULL the server is bound to all interfaces.
    281  * @param   uPort           The port for creating a datagram socket.
    282  * @param   ppServer        Where to store the serverhandle.
    283  */
    284256RTR3DECL(int) RTUdpServerCreateEx(const char *pszAddress, uint32_t uPort, PPRTUDPSERVER ppServer)
    285257{
    … …  
    347319
    348320
    349 /**
    350  * Listen for incoming datagrams.
    351  *
    352  * The function will loop waiting for datagrams and call pfnServe for
    353  * each of the incoming datagrams in turn. The pfnServe function can
    354  * return VERR_UDP_SERVER_STOP too terminate this loop. A stopped server
    355  * can only be destroyed.
    356  *
    357  * @returns IPRT status code.
    358  * @retval  VERR_UDP_SERVER_STOP if stopped by pfnServe.
    359  * @retval  VERR_UDP_SERVER_SHUTDOWN if shut down by RTUdpServerShutdown.
    360  *
    361  * @param   pServer         The server handle as returned from RTUdpServerCreateEx().
    362  * @param   pfnServe        The function which will handle incoming datagrams.
    363  * @param   pvUser          User argument passed to pfnServe.
    364  */
    365321RTR3DECL(int) RTUdpServerListen(PRTUDPSERVER pServer, PFNRTUDPSERVE pfnServe, void *pvUser)
    366322{
    … …  
    516472
    517473
    518 /**
    519  * Shuts down the server.
    520  *
    521  * @returns IPRT status code.
    522  * @param   pServer         Handle to the server.
    523  */
    524474RTR3DECL(int) RTUdpServerShutdown(PRTUDPSERVER pServer)
    525475{
    … …  
    569519
    570520
    571 /**
    572  * Closes down and frees a UDP Server.
    573  *
    574  * @returns iprt status code.
    575  * @param   pServer         Handle to the server.
    576  */
    577521RTR3DECL(int) RTUdpServerDestroy(PRTUDPSERVER pServer)
    578522{

  • trunk/src/VBox/Runtime/r3/win/localipc-win.cpp

    r98103 r99758  
    567567 * Retains a reference to the server instance.
    568568 *
    569  * @returns
    570569 * @param   pThis               The server instance.
    571570 */

  • trunk/src/VBox/Runtime/r3/win/path-win.cpp

    r98103 r99758  
    6161typedef FNSHGETFOLDERPATHW *PFNSHGETFOLDERPATHW;
    6262
    63 /**
    64  * Get the real (no symlinks, no . or .. components) path, must exist.
    65  *
    66  * @returns iprt status code.
    67  * @param   pszPath         The path to resolve.
    68  * @param   pszRealPath     Where to store the real path.
    69  * @param   cchRealPath     Size of the buffer.
    70  */
     63
    7164RTDECL(int) RTPathReal(const char *pszPath, char *pszRealPath, size_t cchRealPath)
    7265{
    … …  
    10194
    10295#if 0
    103 /**
    104  * Get the absolute path (no symlinks, no . or .. components), doesn't have to exit.
    105  *
    106  * @returns iprt status code.
    107  * @param   pszPath         The path to resolve.
    108  * @param   pszAbsPath      Where to store the absolute path.
    109  * @param   cchAbsPath      Size of the buffer.
    110  */
    11196RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cchAbsPath)
    11297{
    … …  
    160145
    161146
    162 /**
    163  * Gets the user home directory.
    164  *
    165  * @returns iprt status code.
    166  * @param   pszPath     Buffer where to store the path.
    167  * @param   cchPath     Buffer size in bytes.
    168  */
    169147RTDECL(int) RTPathUserHome(char *pszPath, size_t cchPath)
    170148{

  • trunk/src/VBox/Runtime/r3/xml.cpp

    r99730 r99758  
    751751
    752752
    753 /**
    754  * Gets the next tree element in a full tree enumeration.
    755  *
    756  * @returns Pointer to the next element in the tree, NULL if we're done.
    757  * @param   pElmRoot            The root of the tree we're enumerating.  NULL if
    758  *                              it's the entire tree.
    759  */
    760753ElementNode const *ElementNode::getNextTreeElement(ElementNode const *pElmRoot /*= NULL */) const
    761754{
Note: See TracChangeset for help on using the changeset viewer.

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