staflocalipcconnprovider.cpp

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

                if (errorBuffer) *errorBuffer = error.adoptImpl();
                STAFSocketClose(connImpl.clientSocket);
                return kSTAFCommunicationError;
            }

            // On AIX, select() returns successfully if the target system exists.
            // This is true, even if the connection to the particular port is
            // refused.  So, we put in a zero-byte read to make sure that the
            // socket is actually connected successfully.
            // On Windows, we need to check if errno is SOCEWOULDBLOCK

            int recvRC = recv(connImpl.clientSocket, 0 , 0, STAF_MSG_NOSIGNAL);

            if ((recvRC < 0) && (STAFSocketGetLastError() != SOCEWOULDBLOCK))
            {
                STAFString error = STAFString("Error performing test read on "
                                              "connected endpoint: recv() RC=") +
                                   STAFSocketGetLastError();
                if (errorBuffer) *errorBuffer = error.adoptImpl();
                STAFSocketClose(connImpl.clientSocket);
                return kSTAFCommunicationError;
            }
        }

        modeRC = STAFSocketSetBlockingMode(connImpl.clientSocket,
                                           kSTAFSocketBlocking, errorBuffer);
        if (modeRC != 0)
        {
            STAFString error = STAFString("Error setting socket to blocking "
                                          "mode:");
            if (errorBuffer)
            {
                error += STAFString(*errorBuffer, STAFString::kShallow);
                *errorBuffer = error.adoptImpl();
            }

            STAFSocketClose(connImpl.clientSocket);

            return kSTAFCommunicationError;
        }

        *connection = new STAFLocalConnectionImpl(connImpl);

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionProviderConnect");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionProviderGetMyNetworkIDs(
    STAFConnectionProvider_t baseProvider,
    STAFStringConst_t *logicalID,
    STAFStringConst_t *physicalID,
    STAFString_t *errorBuffer)
{
    if (baseProvider   == 0) return kSTAFInvalidObject;
    if (logicalID  == 0) return kSTAFInvalidParm;
    if (physicalID == 0) return kSTAFInvalidParm;

    try
    {
        STAFLocalConnectionProviderImpl *provider =
            static_cast<STAFLocalConnectionProviderImpl *>(baseProvider);

        *logicalID = (STAFStringConst_t)provider->logicalNetworkID.getImpl();
        *physicalID = (STAFStringConst_t)provider->physicalNetworkID.getImpl();

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionProviderGetMyNetworkIDs");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionProviderGetOptions(
    STAFConnectionProvider_t baseProvider,
    STAFObject_t *options,
    STAFString_t *errorBuffer)
{
    if (baseProvider == 0) return kSTAFInvalidObject;
    if (options  == 0) return kSTAFInvalidParm;

    try
    {
        STAFLocalConnectionProviderImpl *provider =
            static_cast<STAFLocalConnectionProviderImpl *>(baseProvider);

        STAFObjectConstructReference(options, provider->options->getImpl());

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionProviderGetOptions");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionProviderGetProperty(
    STAFConnectionProvider_t baseProvider,
    STAFConnectionProviderProperty_t property, STAFStringConst_t *value,
    STAFString_t *errorBuffer)
{
    if (baseProvider == 0) return kSTAFInvalidObject;
    if (value    == 0) return kSTAFInvalidParm;
    
    try
    {
        STAFLocalConnectionProviderImpl *provider =
            static_cast<STAFLocalConnectionProviderImpl *>(baseProvider);

        if (property == kSTAFConnectionProviderPortProperty)
            *value = (STAFStringConst_t)provider->portProperty.getImpl();
        else if (property == kSTAFConnectionProviderIsSecureProperty)
            *value = (STAFStringConst_t)provider->isSecureProperty.getImpl();
        else
            return kSTAFInvalidValue;

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionProviderGetProperty");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionRead(STAFConnection_t baseConnection, void *buffer,
                            unsigned int readLength,
                            STAFString_t *errorBuffer)
{
    if (baseConnection == 0) return kSTAFInvalidObject;
    if ((buffer == 0) && (readLength != 0)) return kSTAFInvalidParm;

    try
    {
        STAFLocalConnectionImpl *connection =
            static_cast<STAFLocalConnectionImpl *>(baseConnection);

        int rc = 0;

        for(unsigned current = 0; current < readLength; current += rc)
        {
            // XXX: There should probably be a select() call here and in write

            int recvSize = (int)STAF_MIN((size_t)(readLength - current), 
                                         sizeof(connection->buffer));
            rc = recv(connection->clientSocket, connection->buffer, recvSize,
                      STAF_MSG_NOSIGNAL);

            if (rc < 0)
            {
                STAFString error = STAFString("Error reading from socket: "
                                              "recv() RC=") +
                                   STAFSocketGetLastError();
                if (errorBuffer) *errorBuffer = error.adoptImpl();
                return kSTAFCommunicationError;
            }
            else if (rc == 0)
            {
                STAFString error = STAFString("Error reading from socket: "
                                              "other side closed socket");
                if (errorBuffer) *errorBuffer = error.adoptImpl();
                return kSTAFCommunicationError;
            }
            else
            {
                memcpy((char *)buffer + current, connection->buffer, rc);
            }
        }

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionRead");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionReadUInt(STAFConnection_t connection,
                                unsigned int *uint, STAFString_t *errorBuffer)
{
    if (connection == 0) return kSTAFInvalidObject;
    if (uint == 0) return kSTAFInvalidParm;

    STAFRC_t rc = STAFConnectionRead(connection, uint, sizeof(unsigned int),
                                     errorBuffer);

    if (rc == kSTAFOk) *uint = STAFUtilConvertLEUIntToNative(*uint);

    return rc;
}


STAFRC_t STAFConnectionReadSTAFString(STAFConnection_t connection,
                                      STAFString_t *stafString,
                                      STAFString_t *errorBuffer)
{
    if (connection == 0) return kSTAFInvalidObject;
    if (stafString == 0) return kSTAFInvalidParm;

    try
    {
        // First, get the size of the string

        unsigned int size = 0;
        STAFRC_t rc = STAFConnectionReadUInt(connection, &size, errorBuffer);

        if (rc != kSTAFOk) return rc;

        // Next read in the actual UTF-8 data

        char *inputData = new char[size];

        rc = STAFConnectionRead(connection, (void *)inputData, size,
                                errorBuffer);

        if (rc != kSTAFOk)
        {
            delete [] inputData;
            return rc;
        }

        // Now, create the actual STAFString

        unsigned int osRC = 0;

        rc = STAFStringConstruct(stafString, inputData, size, &osRC);

        if ((rc == kSTAFBaseOSError) && (errorBuffer != 0))
            *errorBuffer = STAFString(osRC).adoptImpl();

        delete [] inputData;

        return rc;
    }
    CATCH_STANDARD("STAFConnectionReadSTAFString");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionWrite(STAFConnection_t baseConnection, void *buffer,
                             unsigned int writeLength,
                             STAFString_t *errorBuffer)
{
    if (baseConnection == 0) return kSTAFInvalidObject;
    if ((buffer == 0) && (writeLength != 0)) return kSTAFInvalidParm;

    try
    {
        STAFLocalConnectionImpl *connection =
            static_cast<STAFLocalConnectionImpl *>(baseConnection);

        int rc = 0;

        for(unsigned int current = 0; current < writeLength; current += rc)
        {
            int sendSize = (int)STAF_MIN((size_t)(writeLength - current), 
                                         sizeof(connection->buffer));
            memcpy(connection->buffer, (char *)buffer + current, sendSize);

            rc = send(connection->clientSocket, (char *)connection->buffer,
                      (int)sendSize, 0);

            if (rc < 0)
            {
                STAFString error = STAFString("Error writing to socket: "
                                              "send() RC=") +
                                   STAFSocketGetLastError();
                if (errorBuffer) *errorBuffer = error.adoptImpl();
                return kSTAFCommunicationError;
            }
        }

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionWrite");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionWriteUInt(STAFConnection_t connection,
                                 unsigned int uint, STAFString_t *errorBuffer)
{
    unsigned int leUInt = STAFUtilConvertNativeUIntToLE(uint);

    return STAFConnectionWrite(connection, &leUInt, sizeof(unsigned int),
                               errorBuffer);
}


STAFRC_t STAFConnectionWriteSTAFString(STAFConnection_t connection,
                                       STAFStringConst_t stafString,
                                       STAFString_t *errorBuffer)
{
    if (connection == 0) return kSTAFInvalidObject;
    if (stafString == 0) return kSTAFInvalidObject;

    try
    {
        unsigned int osRC = 0;
        unsigned int length = 0;
        const char *buffer = 0;
        STAFRC_t rc = STAFStringGetBuffer(stafString, &buffer, &length, &osRC);

        if ((rc == kSTAFBaseOSError) && (errorBuffer != 0))
        {
            *errorBuffer = STAFString(osRC).adoptImpl();
            return rc;
        }

        rc = STAFConnectionWriteUInt(connection, length, errorBuffer);

        if (rc == kSTAFOk)
        {
            rc = STAFConnectionWrite(connection, const_cast<char *>(buffer),
                                     length, errorBuffer);
        }

        return rc;
    }
    CATCH_STANDARD("STAFConnectionWriteSTAFString");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionGetPeerNetworkIDs(STAFConnection_t connection,
                                         STAFStringConst_t *logicalID,
                                         STAFStringConst_t *physicalID,
                                         STAFString_t *errorBuffer)
{
    if (connection == 0) return kSTAFInvalidObject;
    if (logicalID  == 0) return kSTAFInvalidParm;
    if (physicalID == 0) return kSTAFInvalidParm;

    try
    {
        static STAFString sLocalString("local");

        *logicalID = sLocalString.getImpl();
        *physicalID = sLocalString.getImpl();

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionGetPeerNetworkIDs");

    return kSTAFUnknownError;
}


STAFRC_t STAFConnectionDestruct(STAFConnection_t *baseConnection,
                                STAFString_t *errorBuffer)
{
    if (baseConnection == 0) return kSTAFInvalidParm;
    if (*baseConnection == 0) return kSTAFInvalidObject;

    try
    {
        STAFLocalConnectionImpl *connection =
            static_cast<STAFLocalConnectionImpl *>(*baseConnection);

        STAFSocketClose(connection->clientSocket);

        delete connection;

        connection = 0;

        return kSTAFOk;
    }
    CATCH_STANDARD("STAFConnectionDestruct");

    return kSTAFUnknownError;
}