stafconnectionprovider.h

Software Testing Automation Framework (STAF)的开发代码

/*          (Out) Pointer to physical network identifier                      */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : If the logical network identifier can not be determined or is     */
/*          otherwise unavailable, the physical network identifier will be    */
/*          returned for both the logical and physical network identifiers    */
/******************************************************************************/
STAFRC_t STAFConnectionProviderGetMyNetworkIDs(STAFConnectionProvider_t provider,
                                               STAFStringConst_t *logicalID,
                                               STAFStringConst_t *physicalID,
                                               STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionGetOptions - Get the options (name[=value]) for this         */
/*                              connection provider                           */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (Out) Pointer to a STAFObjectPtr containing a list of the options */
/*                for this connection provider.  Each option is the list has  */
/*                format:  <Option Name>=<Option Value>                       */
/*                For example: [ "PORT=6500", "PROTOCOL=ipv4 "]               */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/******************************************************************************/
STAFRC_t STAFConnectionProviderGetOptions(
    STAFConnectionProvider_t provider,
    STAFObject_t *options,
    STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionProviderGetProperty - Get a specified property for this      */
/*                                     connection provider                    */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (In)  The property to retrieve                                    */
/*          (Out) Pointer to a string containing the property's value         */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/******************************************************************************/
STAFRC_t STAFConnectionProviderGetProperty(
    STAFConnectionProvider_t provider,
    STAFConnectionProviderProperty_t property, STAFStringConst_t *value,
    STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionRead - Reads arbitrary data from a connection                */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (I/O) Pointer to buffer in which to write data                    */
/*          (In)  Length of data (in bytes) to read                           */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : The buffer must be at least as long as the readLength passed in   */
/******************************************************************************/
STAFRC_t STAFConnectionRead(STAFConnection_t connection,
                            void *buffer,
                            unsigned int readLength,
                            STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionReadUInt - Reads an unsigned integer from a connection       */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (Out) Pointer to an unsigned integer                              */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : This function is platform/endian agnostic.  In other words it     */
/*          will convert for endianness between different platforms.          */
/******************************************************************************/
STAFRC_t STAFConnectionReadUInt(STAFConnection_t connection,
                                unsigned int *uint,
                                STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionReadSTAFString - Reads a STAFString from a connection        */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (Out) Pointer to a STAFString_t                                   */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : 1) This function is platform/endian agnostic.  In other words it  */
/*             will convert a STAFString between different platforms.         */
/*          2) On successful return, the caller is responsible for calling    */
/*             STAFStringDestruct on the returned string.                     */
/******************************************************************************/
STAFRC_t STAFConnectionReadSTAFString(STAFConnection_t connection,
                                      STAFString_t *stafString,
                                      STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionWrite - Writes arbitrary data to a connection                */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (I/O) Pointer to buffer from which to read data                   */
/*          (In)  Length of data (in bytes) to write                          */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : The buffer must be at least as long as the writeLength passed in  */
/******************************************************************************/
STAFRC_t STAFConnectionWrite(STAFConnection_t connection,
                             void *buffer,
                             unsigned int writeLength,
                             STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionWriteUInt - Writes an unsigned integer to a connection       */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (In)  An unsigned integer                                         */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : This function is platform/endian agnostic.  In other words it     */
/*          will convert for endianness between different platforms.          */
/******************************************************************************/
STAFRC_t STAFConnectionWriteUInt(STAFConnection_t connection,
                                 unsigned int uint,
                                 STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionWriteSTAFString - Writes a STAFString to a connection        */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (In)  A STAFString_t                                              */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : This function is platform/endian agnostic.  In other words it     */
/*          will convert a STAFString between different platforms.            */
/******************************************************************************/
STAFRC_t STAFConnectionWriteSTAFString(STAFConnection_t connection,
                                       STAFStringConst_t stafString,
                                       STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionGetPeerNetworkIDs - Get the logical and physical network     */
/*                                   identifiers for the connected peer       */
/*                                                                            */
/* Accepts: (In)  Connection                                                  */
/*          (Out) Pointer to logical network identifier                       */
/*          (Out) Pointer to physical network identifier                      */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/*                                                                            */
/* Notes  : If the logical network identifier can not be determined or is     */
/*          otherwise unavailable, the physical network identifier will be    */
/*          returned for both the logical and physical network identifiers    */
/******************************************************************************/
STAFRC_t STAFConnectionGetPeerNetworkIDs(STAFConnection_t connection,
                                         STAFStringConst_t *logicalID,
                                         STAFStringConst_t *physicalID,
                                         STAFString_t *errorBuffer);


/******************************************************************************/
/* STAFConnectionDestruct - Destroys/frees a connection                       */
/*                                                                            */
/* Accepts: (I/O) Pointer to a connection                                     */
/*          (Out) Pointer to error buffer                                     */
/*                                                                            */
/* Returns: kSTAFOk, on success                                               */
/*          other on error                                                    */
/******************************************************************************/
STAFRC_t STAFConnectionDestruct(STAFConnection_t *connection,
                                STAFString_t *errorBuffer);


// Function typedefs

typedef STAFRC_t (*STAFConnectionProviderConstructFunc_t)(
    STAFConnectionProvider_t *provider, void *constructInfo,
    unsigned int constructInfoLevel, STAFString_t *errorBuffer);

typedef STAFRC_t (*STAFConnectionProviderStartFunc_t)(
    STAFConnectionProvider_t provider, void *startInfo,
    unsigned int startInfoLevel, STAFString_t *errorBuffer);

typedef STAFRC_t (*STAFConnectionProviderStopFunc_t)(
    STAFConnectionProvider_t provider, void *stopInfo,
    unsigned int stopInfoLevel, STAFString_t *errorBuffer);

typedef STAFRC_t (*STAFConnectionProviderDestructFunc_t)(
    STAFConnectionProvider_t *provider, void *destructInfo,
    unsigned int destructInfoLevel, STAFString_t *errorBuffer);