ghttpConnection.h

 /*
GameSpy GHTTP SDK 
Dan "Mr. Pants" Schoenblum
dan@gamespy.com
 
Copyright 1999-2007 GameSpy Industries, Inc
 
devsupport@gamespy.com
*/
 
#ifndef _GHTTPCONNECTION_H_
#define _GHTTPCONNECTION_H_
 
#include "ghttpMain.h"
#include "ghttpEncryption.h"
#include "ghttpBuffer.h"
#include "ghttpPost.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Initial size and increment amount for the send buffer.
#define SEND_BUFFER_INITIAL_SIZE            (2 * 1024)
#define SEND_BUFFER_INCREMENT_SIZE          (4 * 1024)
 
// Initial size and increment amount for the recv buffer.
#define RECV_BUFFER_INITIAL_SIZE            (2 * 1024)
#define RECV_BUFFER_INCREMENT_SIZE          (2 * 1024)
 
// Initial size and increment amount for the get file buffer.
#define GET_FILE_BUFFER_INITIAL_SIZE        (2 * 1024)
#define GET_FILE_BUFFER_INCREMENT_SIZE      (2 * 1024)
 
// Initial size and increment amount for the ssl encoding buffer.
#define ENCODE_BUFFER_INITIAL_SIZE          (2 * 1024)
#define ENCODE_BUFFER_INCREMENT_SIZE        (1 * 1024)
 
// Initial size and increment amount for the ssl decoding buffer.
#define DECODE_BUFFER_INITIAL_SIZE          (2 * 1024)
#define DECODE_BUFFER_INCREMENT_SIZE        (1 * 1024)
 
// The size of the buffer for chunk headers (NOT including the NUL).
#define CHUNK_HEADER_SIZE                   10
 
// The type of request made.
typedef enum
{
    GHIGET,     // Buffer the file.
    GHISAVE,    // Save the file to disk.
    GHISTREAM,  // Stream the file.
    GHIHEAD,    // Get just the headers for a request.
    GHIPOST     // Only posting data (all types can post).
} GHIRequestType;
 
// Chunk-reading states.
typedef enum
{
    CRHeader,       // Reading a chunk header.
    CRChunk,        // Reading chunk (actual content).
    CRCRLF,         // Reading the CRLF at the end of a chunk.
    CRFooter        // Reading the footer at the end of the file (chunk with size of 0).
} CRState;
 
// Protocol.
typedef enum
{
    GHIHttp,
    GHIHttps
} GHIProtocol;
 
// This is the data for a single http connection.
typedef struct GHIConnection
{
    GHTTPBool inUse;              // If true, this connection object is being used.
    GHTTPRequest request;         // This object's request index.
    int uniqueID;                 // Every connection object has a unqiue ID.
 
    GHIRequestType type;          // The type of request this connection is for.
 
    GHTTPState state;             // The state of the request.
 
    char * URL;                   // The URL for the file.
    char * serverAddress;         // The address of the server as contained in the URL.
    unsigned int serverIP;        // The server's IP.
    unsigned short serverPort;    // The server's port.
    char * requestPath;           // The path as contained in the URL.
 
    GHIProtocol protocol;         // Protocol used for this connection.
 
    char * sendHeaders;           // Optional headers to pass with the request.
 
    FILE * saveFile;              // If saving to disk, the file being saved to.
 
    GHTTPBool blocking;           // Blocking flag.
    
    GHTTPBool persistConnection;  // If TRUE, Connection: close will not be sent in the headers and the connection will be left open
 
    GHTTPResult result;           // The result of the request.
    ghttpProgressCallback progressCallback;    // Called periodically with progress updates.
    ghttpCompletedCallback completedCallback;  // Called when the file has been received.
    void * callbackParam;         // User-data to be passed to the callbacks.
 
    SOCKET socket;                // The socket for this connection.
    int socketError;              // If there was a socket error, the last error code is stored here.
 
    GHIBuffer sendBuffer;         // The buffer for outgoing data. 
    GHIBuffer encodeBuffer;       // The buffer for outgoing data. (will be encrypted; only used with https)
    GHIBuffer recvBuffer;         // The buffer for incoming data. (plain text)
    GHIBuffer decodeBuffer;       // The buffer for incoming data. (encrypted)(only used with https)
    
    GHIBuffer getFileBuffer;      // ghttpGetFile[Ex] uses this buffer (which may be user-supplied).
    GHTTPBool userBufferSupplied; // True if a user buffer was supplied.
 
    int statusMajorVersion;       // The major-version number from the server's response.
    int statusMinorVersion;       // The minor-version number from the server's response.
    int statusCode;               // The status-code from the server's response.
    int statusStringIndex;        // Index in the recvBuffer where the status string starts.
    
    int headerStringIndex;        // Index in the recvBuffer where the headers begin
 
    GHTTPBool completed;          // This connection is completed - call the callback and kill it.
 
    GHTTPByteCount fileBytesReceived; // Number of file bytes received.
    GHTTPByteCount totalSize;         // Total size of the file, -1 if unknown.
 
    char * redirectURL;           // If this is not NULL, we need to redirect the download to this URL.
    int redirectCount;            // Number of redirections done for this request.
 
    GHTTPBool chunkedTransfer;    // The body of the response is chunky ("Transfer-Encoding: chunked").
    char chunkHeader[CHUNK_HEADER_SIZE + 1];  // Partial chunk headers are stored in here.
    int chunkHeaderLen;           // The number of bytes in chunkHeader.
    int chunkBytesLeft;           // Number of bytes left in the chunk (only valid for CRChunk).
    CRState chunkReadingState;    // Determines if a chunk header or chunk data is being read.
 
    GHTTPBool processing;         // If true, being processed.  Used to prevent recursive processing.
    GHTTPBool connectionClosed;   // If true, the connection has been closed (orderly or abortive)
 
    GHTTPBool throttle;           // If true, throttle this connection.
    gsi_time lastThrottleRecv;  // The last time we received on a throttled connection.
 
    GHTTPPost post;               // If not NULL, a reference to a post object to upload with the request.
    GHIPostingState postingState; // If posting, the state of the upload.
    
    gsi_time maxRecvTime;         // Max time spent receiving per call to "Think" - Prevents blocking on ultrafast connections
    char * proxyOverrideServer;   // Allows use of a different proxy than the global proxy
    unsigned short proxyOverridePort;
 
    struct GHIEncryptor encryptor;
 
#if !defined(GSI_NO_THREADS)
    GSIResolveHostnameHandle handle; //handle used for asychronous DNS lookups
#endif
    
} GHIConnection;
 
// Create a new connection object.
// Returns NULL on failure.
GHIConnection * ghiNewConnection
(
    void
);
 
// Frees the connection object.
GHTTPBool ghiFreeConnection
(
    GHIConnection * connection
);
 
// Returns the connection object for a request index.
// Returns NULL if the index is bad.
GHIConnection * ghiRequestToConnection
(
    GHTTPRequest request
);
 
// Calls the callback on each connection.
void ghiEnumConnections
(
    GHTTPBool (* callback)(GHIConnection *)
);
 
// Redirects the given connection.
// Resets the connection to get the
// file at connection->redirectURL.
void ghiRedirectConnection
(
    GHIConnection * connection
);
 
// Kills all connections and frees up all memory.
void ghiCleanupConnections
(
    void
);
 
#ifdef __cplusplus
}
#endif
 
#endif