base/libs/qdecoder/qSocket.c

Go to the documentation of this file.

/*
 * Copyright 2008 The qDecoder Project. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE QDECODER PROJECT ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE QDECODER PROJECT BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef DISABLE_SOCKET
#ifndef _WIN32

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdarg.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/stat.h>
#include "qDecoder.h"
#include "qInternal.h"

#if defined(ENABLE_SENDFILE) && defined(__linux__)
#include <sys/sendfile.h>
#define MAX_SENDFILE_CHUNK_SIZE     (1 * 1024 * 1024 * 1024)
#else
#define MAX_SENDFILE_CHUNK_SIZE     (64 * 1024)
#endif
#define MAX_SAVEINTOFILE_CHUNK_SIZE (64 * 1024)

static bool _getAddr(struct sockaddr_in *addr, const char *hostname, int port);

int qSocketOpen(const char *hostname, int port) {
    /* host conversion */
    struct sockaddr_in addr;
    if (_getAddr(&addr, hostname, port) == false) return -1; /* invalid hostname */

    /* make sockfd */
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return -2; /* sockfd creation fail */

    /* connect */
    if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        qSocketClose(sockfd);
        return -3; /* connection fail */
    }

    return sockfd;
}

bool qSocketClose(int sockfd) {
    if(close(sockfd) == 0) return true;
    return false;
}

int qSocketWaitReadable(int sockfd, int timeoutms) {
    struct pollfd fds[1];

    fds[0].fd = sockfd;
    fds[0].events = POLLIN;

    int status = poll(fds, 1, timeoutms);
    if(status <= 0) return status;

    if(fds[0].revents & POLLIN) return 1;
    return -1;
}

int qSocketWaitWritable(int sockfd, int timeoutms) {
    struct pollfd fds[1];

    fds[0].fd = sockfd;
    fds[0].events = POLLOUT;

    int status = poll(fds, 1, timeoutms);
    if(status <= 0) return status;

    if(fds[0].revents & POLLOUT) return 1;
    return -1;
}

ssize_t qSocketRead(void *binary, int sockfd, size_t nbytes, int timeoutms) {
    if(nbytes == 0) return 0;

    ssize_t readbytes = 0;
    int sockstatus = 0;
    while(readbytes < nbytes) {
        sockstatus = qSocketWaitReadable(sockfd, timeoutms);
        if(sockstatus <= 0) break;

        ssize_t readsize = read(sockfd, binary+readbytes, nbytes-readbytes);
        if(readsize <= 0) {
            sockstatus = -1;
            break;
        }
        readbytes += readsize;
    }

    if(readbytes > 0) return readbytes;
    return sockstatus;
}

ssize_t qSocketGets(char *str, int sockfd, size_t nbytes, int timeoutms) {
    char *ptr;
    ssize_t readcnt = 0;
    for (ptr = str; readcnt < (nbytes - 1); ptr++) {
        int sockstatus = qSocketWaitReadable(sockfd, timeoutms);
        if (sockstatus <= 0) {
            *ptr = '\0';
            return sockstatus;
        }

        if (read(sockfd, ptr, 1) != 1) {
            if (ptr == str) return -1;
            break;
        }

        readcnt++;
        if (*ptr == '\n') break;
        if (*ptr == '\r') ptr--;
    }

    *ptr = '\0';
    return readcnt;
}

ssize_t qSocketWrite(int sockfd, const void *binary, size_t nbytes) {
    return _q_write(sockfd, binary, nbytes);
}

ssize_t qSocketPuts(int sockfd, const char *str) {
    char *buf = (char *)malloc(strlen(str) + 2 + 1);
    if(buf == NULL) return -1;
    sprintf(buf, "%s\r\n", str);

    ssize_t sent = _q_write(sockfd, buf, strlen(buf));
    free(buf);

    return sent;
}

ssize_t qSocketPrintf(int sockfd, const char *format, ...) {
    char buf[MAX_LINEBUF];
    va_list arglist;

    va_start(arglist, format);
    vsnprintf(buf, sizeof(buf), format, arglist);
    va_end(arglist);

    return _q_write(sockfd, buf, strlen(buf));
}

off_t qSocketSendfile(int sockfd, int fd, off_t offset, off_t nbytes) {
    struct stat filestat;
    if (fstat(fd, &filestat) < 0) return -1;

    off_t sent = 0;                 // total size sent
    off_t rangesize = filestat.st_size - offset;    // maximum available size can be sent
    if(rangesize < 0) rangesize = 0;
    else if(nbytes > 0 && nbytes < rangesize) rangesize = nbytes; // set rangesize to requested size

#if !(defined(ENABLE_SENDFILE) && defined(__linux__))
    if (offset > 0) lseek(fd, offset, SEEK_SET);
#endif

    while(sent < rangesize) {
        size_t sendsize;    // this time sending size
        if(rangesize - sent <= MAX_SENDFILE_CHUNK_SIZE) sendsize = rangesize - sent;
        else sendsize = MAX_SENDFILE_CHUNK_SIZE;

        ssize_t ret = 0;
#if defined(ENABLE_SENDFILE) && defined(__linux__)
        ret = sendfile(sockfd, fd, &offset, sendsize);
#else
        ret = qFileSend(sockfd, fd, sendsize);
#endif
        if(ret <= 0) break; // Connection closed by peer
        sent += ret;
    }

    return sent;
}

off_t qSocketSaveIntoFile(int fd, int sockfd, off_t nbytes, int timeoutms) {
    if(nbytes <= 0) return 0;

    off_t readbytes, readed;
    for (readbytes = 0; readbytes < nbytes; readbytes += readed) {
        // calculate reading size
        int readsize;
        if (nbytes - readbytes < MAX_SAVEINTOFILE_CHUNK_SIZE) readsize = nbytes - readbytes;
        else readsize = MAX_SAVEINTOFILE_CHUNK_SIZE;

        // read data
        if (qSocketWaitReadable(sockfd, timeoutms) <= 0) {
            if(readbytes == 0) return -1;
            break;
        }

        readed = qFileSend(fd, sockfd, readsize);
        if (readed <= 0) {
            if(readbytes == 0) return -1;
            break;
        }
    }
    return readbytes;
}

ssize_t qSocketSaveIntoMemory(char *mem, int sockfd, size_t nbytes, int timeoutms) {
    if(nbytes <= 0) return 0;

    char *mp;
    ssize_t readbytes, readed;
    for (readbytes = 0, mp = mem; readbytes < nbytes; readbytes += readed, mp += readed) {
        // calculate reading size
        size_t readsize = nbytes - readbytes;

        // wait data
        if (qSocketWaitReadable(sockfd, timeoutms) <= 0) {
            if(readbytes == 0) return -1;
            break;
        }

        // read data
        readed = read(sockfd, mp, readsize);
        if (readed <= 0) {
            if(readbytes == 0) return -1;
            break;
        }
    }

    return readbytes;
}

static bool _getAddr(struct sockaddr_in *addr, const char *hostname, int port) {
    /* here we assume that the hostname argument contains ip address */
    memset((void*)addr, 0, sizeof(struct sockaddr_in));
    if (!inet_aton(hostname, &addr->sin_addr)) { /* fail then try another way */
        struct hostent *hp;
        if ((hp = gethostbyname (hostname)) == 0) return false;
        memcpy (&addr->sin_addr, hp->h_addr, sizeof(struct in_addr));
    }
    addr->sin_family = AF_INET;
    addr->sin_port = htons(port);

    return true;
}

#endif /* _WIN32 */
#endif /* DISABLE_SOCKET */

---