tcp.c

Go to the documentation of this file.

#include "tcp.h"

#ifndef WINSOCK
#       include <netdb.h>
#       include <netinet/in.h>
#       include <fcntl.h>
#else
static int initialized = 0;
static WSADATA wsaData;

/** Initialize Winsock.
 * @return 0 on success, TCP_ERROR on failure.
 */
static inline int initialize() {
        if(!initialized) {
                if(WSAStartup(MAKEWORD(1, 1), &wsaData)) {
                        return TCP_ERROR;
                }
        }
        return 0;
}
#endif /* WINSOCK */

/** Set the IP address and port number in a sockaddr_in struct.
 * @param addr The structure whose fields will be set.
 * @param host The host to set. If NULL, the socket address will be
 *             INADDR_ANY, meaning all local addresses. If not NULL,
 *             the host must be an IPv4 address in dotted quad notation,
 *             or a hostname, which will be resolved to an IP address.
 * @param port The port number to set.
 *
 * @return 0 on success, TCP_ERROR on failure.
 */
static int set_sockaddr(struct sockaddr_in *addr,
        const char *host, int port) {
        struct hostent *he;

        if(host) {
                /* Lookup hostname */
                he = gethostbyname(host);
                if(!he) {
                        return TCP_ERROR;
                }

                /* Copy address into struct */
                memcpy(&addr->sin_addr, he->h_addr, he->h_length);
        } else {
                /* No hostname given, use all local addresses */
                addr->sin_addr.s_addr = INADDR_ANY;
        }

        /* Initialize rest of struct */
        addr->sin_family = AF_INET;
        addr->sin_port = htons((short) port);
        
        return 0;
}

/** Make a new TCP socket.
 * @return The new TCP_SOCKET on success; TCP_ERROR on failure.
 */
static TCP_SOCKET make_socket() {
        TCP_SOCKET sock;

        /* Create socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
#       ifdef WINSOCK
        if(sock == INVALID_SOCKET) return TCP_ERROR;
#       else
        if(sock < 0) return TCP_ERROR;
#       endif
        
        return sock;
}

/** Make a TCP connection to the specified host on the specified port.
 * @param host The host (name or IP address) of the machine to connect to.
 * @param port The port number to connect to.
 *
 * @return The new TCP_CONNECTION on success; TCP_ERROR on failure.
 */
TCP_CONNECTION tcp_connect(const char *host, int port) {
        struct sockaddr_in addr;
        int sock;

#       ifdef WINSOCK
        /* Initialize library, if necessary */
        if(initialize() == TCP_ERROR) return TCP_ERROR;
#       endif

        /* Initialize socket address */
        if(set_sockaddr(&addr, host, port) == TCP_ERROR) return TCP_ERROR;

        /* Create socket */
        sock = make_socket();
        if(sock == TCP_ERROR) return TCP_ERROR;

        /* Connect */
#       ifdef WINSOCK
        if(connect(sock, (struct sockaddr*) &addr, sizeof(addr)) ==
                SOCKET_ERROR) {
#       else
        if(connect(sock, (struct sockaddr*) &addr, sizeof(addr)) < 0) {
#       endif /* WINSOCK */
                tcp_close(sock);
                return TCP_ERROR;
        }

        return sock;
}

/** Close a TCP connection.
 * @param conn The connection to close.
 * @return 0 on success. Any other value indicates failure.
 */
int tcp_close(TCP_CONNECTION conn) {
#       ifdef WINSOCK
        return closesocket(conn);
#       else
        return close(conn);
#endif
}

/** Read from a TCP connection.
 * Up to @a len bytes are read and placed into @a buf. Note that the number
 * of bytes read may be less than @a len.
 *
 * @param conn The connection to read from.
 * @param buf The buffer to place the bytes into.
 * @param len The maximum number of bytes to read; typically equal to
 *            the size of buf.
 *
 * @return The number of bytes actually read on success; a negative
 *         value on failure. A return value of 0 indicates the end of
 *         the transmission.
 */
int tcp_read(TCP_CONNECTION conn, void *buf, int len) {
        return tcp_recv(conn, buf, len, 0);
}

/** Write to a TCP connection.
 * Writes up to @a len bytes from @a buf to the connection @a conn.
 * Note that fewer than @a len bytes may be written. Always check the
 * return value, which indicates the number of bytes actually written.
 *
 * @param conn The connection to write to.
 * @param buf The buffer containing the bytes to be written.
 * @param len The maximum number of bytes to write.
 *
 * @return The number of bytes written on success; a negative value on
 *         failure.
 */
int tcp_write(TCP_CONNECTION conn, const void *buf, int len) {
        return tcp_send(conn, buf, len, 0);
}

/** Make a connection blocking on nonblocking.
 * Blocking affects what happens when a read is performed on a
 * connection when there are not currently any bytes available to be
 * read. A blocking connection will block the read until bytes are
 * available. A non-blocking connection will signal an error and set
 * errno to EAGAIN.
 *
 * A blocking connection should be used when you want to read bytes from the
 * connection and, if none are currently available, wait until they are.
 *
 * Non-blocking connections should be used when you want to read bytes
 * from a connection, but, if none are currently available, do
 * something else instead.
 *
 * @param conn The connection to adjust.
 * @param blocking 0 to make the connection blocking, any other value
 *                 to make it nonblocking. 
 *
 * @return 0 on success, TCP_ERROR on failure.
 */
int tcp_setblocking(TCP_CONNECTION conn, int blocking) {
#       ifdef WINSOCK
        u_long arg = !blocking;

        return ioctlsocket(conn, FIONBIO, &arg);
#       else
        int flags;

        flags = fcntl(conn, F_GETFL, 0);
        if(flags < 0) return TCP_ERROR;
        return fcntl(conn, F_SETFL, blocking ?
                flags | O_NONBLOCK :
                flags & ~(O_NONBLOCK));
#       endif   
}

/** Listen for incoming connections.
 * @param host The address to listen on. Use NULL to listen on all
 *             local adresses.
 * @param port The port to listen on.
 *
 * @return A new TCP_SOCKET on success, TCP_ERROR on failure.
 */
TCP_SOCKET tcp_listen(const char *host, int port) {
        struct hostent *he;
        struct sockaddr_in addr;
        int sock;

#       ifdef WINSOCK
        /* Initialize library, if necessary */
        if(initialize() == TCP_ERROR) return TCP_ERROR;
#       endif

        /* Initialize socket address */
        if(set_sockaddr(&addr, host, port) == TCP_ERROR) return TCP_ERROR;

        /* Create socket */
        sock = make_socket();
        if(sock == TCP_ERROR) return TCP_ERROR;

        /* Bind and start listening */
#       ifdef WINSOCK
        if(bind(sock, (struct sockaddr*) &addr, sizeof(addr)) ==
                SOCKET_ERROR || listen(sock, 3) == SOCKET_ERROR) {
#       else
        if(bind(sock, (struct sockaddr*) &addr, sizeof(addr)) < 0 ||
                listen(sock, 3) < 0) {
#       endif /* WINSOCK */
                tcp_close(sock);
                return TCP_ERROR;
        }

        return sock;
}

/** Accept an incoming connection.
 * @param sock The socket to accept the connection on.
 * @return The new connection.
 */
TCP_CONNECTION tcp_accept(TCP_SOCKET sock) {
#       ifdef WINSOCK
        return accept(sock, 0, 0);
#       else
        int conn;

        conn = accept(sock, 0, 0);
        return conn < 0 ? TCP_ERROR : conn;
#       endif /* WINSOCK */
}

---