C

Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

See more Socket/SSL/TLS Examples

This example demonstrates how to simultaneously read/write on a single socket connection. C

#include <C_CkSocket.h>
#include <C_CkTask.h>

void ChilkatSample(void)
    {
    BOOL success;
    HCkSocket tlsRead;
    BOOL bUseTls;
    int maxWaitMs;
    HCkSocket tlsWrite;
    HCkTask task;
    const char *httpGetReq;

    success = FALSE;

    //  This example requires the Chilkat API to have been previously unlocked.
    //  See Global Unlock Sample for sample code.

    tlsRead = CkSocket_Create();

    //  We'll just use an HTTPS server for this example...
    bUseTls = TRUE;
    maxWaitMs = 5000;
    success = CkSocket_Connect(tlsRead,"www.chilkatsoft.com",443,bUseTls,maxWaitMs);
    if (success == FALSE) {
        printf("%s\n",CkSocket_lastErrorText(tlsRead));
        CkSocket_Dispose(tlsRead);
        return;
    }

    //  Chilkat classes are thread-safe.  This means that only one method call can be active
    //  at a time for a given object instance.  It would seem that this would prevent the possibility
    //  to simultaneously read/write a given connection because it would require two method calls
    //  to be simultaneously active: one for reading and one for writing.
    //  
    //  There's a trick to doing it...
    //  
    //  The DupSocket method is provided to get a new object instance that shares the same socket
    //  connection.  This allows for the coarse-grained object-level thread safety to be maintained, 
    //  while finer-grained thread-safety mechanisms keep things kosher internally.

    //  One object will be used for reading, and the cloned socket is used for writing.
    //  It doesn't matter which --  you can use the cloned socket for reading or the original for writing.
    //  However.. if you try to read simultneously from both the original and cloned objects at the same
    //  time, then one will block until the other finishes.  (This is because of the finer-grained thread
    //  safety internally.)  The same is true if you try to write both socket objects simultaneously.

    tlsWrite = CkSocket_Create();
    success = CkSocket_DupSocket(tlsRead,tlsWrite);
    if (success == FALSE) {
        printf("%s\n",CkSocket_lastErrorText(tlsRead));
        CkSocket_Dispose(tlsRead);
        CkSocket_Dispose(tlsWrite);
        return;
    }

    //  Let's start an async read on the socket.  Nothing will be arriving until we actually send the GET
    //  request and the server responds.  This will read until the end of the HTTP response header.
    task = CkSocket_ReceiveUntilMatchAsync(tlsRead,"\r\n\r\n");
    CkTask_Run(task);

    //  Now send the request.  This should not block because the read is happening on the tlsRead object.
    httpGetReq = "GET / HTTP/1.1\r\nHost: www.chilkatsoft.com\r\n\r\n";
    success = CkSocket_SendString(tlsWrite,httpGetReq);
    //  Assuming success for the example...

    //  Wait for the read task to finish.
    //  The TRUE/FALSE returned by Wait applies to the Wait method call, not the task.
    maxWaitMs = 5000;
    success = CkTask_Wait(task,maxWaitMs);
    if (!success || (CkTask_getStatusInt(task) != 7) || (CkTask_getTaskSuccess(task) != TRUE)) {
        if (!success) {
            //  The task.LastErrorText applies to the Wait method call.
            printf("%s\n",CkTask_lastErrorText(task));
        }
        else {
            //  The ResultErrorText applies to the underlying task method call (i.e. the Connect)
            printf("%s\n",CkTask_status(task));
            printf("%s\n",CkTask_resultErrorText(task));
        }

        CkTask_Dispose(task);
        CkSocket_Dispose(tlsRead);
        CkSocket_Dispose(tlsWrite);
        return;
    }

    //  Examine the received HTTP response header:
    printf("HTTP response header:\n");
    printf("%s\n",CkTask_getResultString(task));

    //  We should get a response that looks like this:
    //  	HTTP response header:
    //  	HTTP/1.1 200 OK
    //  	Cache-Control: private
    //  	Content-Length: 7477
    //  	Content-Type: text/html
    //  	Server: Microsoft-IIS/8.5
    //  	Set-Cookie: ASPSESSIONIDSWDSTRTQ=BBNMIKGCHFJNILFFPLDIOGDE; secure; path=/
    //  	X-Powered-By: ASP.NET
    //  	X-Powered-By-Plesk: PleskWin
    //  	Date: Thu, 06 Apr 2017 12:03:30 GMT

    CkTask_Dispose(task);

    //  Forget about the remainder of the HTTP response... The example was only to demonstrate
    //  simultaneous reading/writing..
    maxWaitMs = 20;
    CkSocket_Close(tlsRead,maxWaitMs);


    CkSocket_Dispose(tlsRead);
    CkSocket_Dispose(tlsWrite);

    }