src/socket.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2
   3 /*  Monkey HTTP Daemon
   4  *  ------------------
   5  *  Copyright (C) 2001-2010 Eduardo Silva P. <edsiper@gmail.com>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <time.h>
  26 #include <arpa/inet.h>
  27 #include <netinet/tcp.h>
  28 #include <sys/socket.h>
  29 #include <sys/sendfile.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <string.h>
  33
  34 #include "socket.h"
  35 #include "memory.h"
  36 #include "utils.h"
  37 #include "plugin.h"
  38 #include "monkey.h"
  39
  40 /*
  41  * Example from:
  42  * http://www.baus.net/on-tcp_cork
  43  */
  44 int mk_socket_set_cork_flag(int fd, int state)
  45 {
  46
  47 #ifdef TRACE
  48     MK_TRACE("Socket, set Cork Flag FD %i to %s", fd, (state ? "ON" : "OFF"));
  49 #endif
  50
  51     return setsockopt(fd, SOL_TCP, TCP_CORK, &state, sizeof(state));
  52 }
  53
  54 int mk_socket_set_nonblocking(int sockfd)
  55 {
  56
  57 #ifdef TRACE
  58     MK_TRACE("Socket, set FD %i to non-blocking", sockfd);
  59 #endif
  60
  61     if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0) | O_NONBLOCK) == -1) {
  62         perror("fcntl");
  63         return -1;
  64     }
  65     return 0;
  66 }
  67
  68 int mk_socket_set_tcp_nodelay(int sockfd)
  69 {
  70     int on = 1;
  71
  72     return setsockopt(sockfd, SOL_TCP, TCP_NODELAY, &on, sizeof(on));
  73 }
  74
  75 int mk_socket_get_ip(int socket, char *ipv4)
  76 {
  77     int ipv4_len = 16;
  78     socklen_t len;
  79     struct sockaddr_in m_addr;
  80
  81     len = sizeof(m_addr);
  82     getpeername(socket, (struct sockaddr *) &m_addr, &len);
  83     inet_ntop(PF_INET, &m_addr.sin_addr, ipv4, ipv4_len);
  84
  85     return 0;
  86 }
  87
  88 int mk_socket_close(int socket)
  89 {
  90     return close(socket);
  91 }
  92
  93 int mk_socket_create()
  94 {
  95     int sockfd;
  96
  97     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
  98         perror("client: socket");
  99         return -1;
 100     }
 101
 102     return sockfd;
 103 }
 104
 105 int mk_socket_connect(int socket_fd, char *host, int port)
 106 {
 107     int ret;
 108
 109     ret = plg_netiomap->connect(socket_fd, host, port);
 110
 111     return ret;
 112 }
 113
 114 void mk_socket_reset(int socket)
 115 {
 116     int status = 1;
 117
 118     if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &status, sizeof(int)) ==
 119         -1) {
 120         perror("setsockopt");
 121         exit(1);
 122     }
 123 }
 124
 125 /* Just IPv4 for now... */
 126 int mk_socket_server(int port, char *listen_addr)
 127 {
 128     int socket_fd;
 129
 130     socket_fd = plg_netiomap->server(port, listen_addr);
 131
 132     if (socket_fd < 0) {
 133         exit(EXIT_FAILURE);
 134     }
 135
 136     return socket_fd;
 137 }
 138
 139 /* NETWORK_IO plugin functions */
 140 int mk_socket_accept(int server_fd, struct sockaddr_in sock_addr)
 141 {
 142     return plg_netiomap->accept(server_fd, sock_addr);
 143 }
 144
 145 int mk_socket_sendv(int socket_fd, struct mk_iov *mk_io, int to)
 146 {
 147     return plg_netiomap->writev(socket_fd, mk_io);
 148 }
 149
 150 int mk_socket_send(int socket_fd, const void *buf, size_t count)
 151 {
 152     return plg_netiomap->write(socket_fd, buf, count);
 153 }
 154
 155 int mk_socket_read(int socket_fd, void *buf, int count)
 156 {
 157     return plg_netiomap->read(socket_fd, (void *)buf, count);
 158 }
 159
 160 int mk_socket_send_file(int socket_fd, int file_fd, off_t *file_offset,
 161                         size_t file_count)
 162 {
 163     return plg_netiomap->send_file(socket_fd, file_fd,
 164                                    file_offset, file_count);
 165 }