src/lib/openjpip/sock_manager.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2014, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifdef _WIN32
  32 #include <windows.h>
  33 #ifdef _MSC_VER
  34 typedef SSIZE_T ssize_t;
  35 #endif
  36 #else
  37 #include <sys/types.h>
  38 #include <sys/socket.h>
  39 #include <arpa/inet.h>
  40 #include <unistd.h>
  41 #endif
  42
  43 #include <stdio.h>
  44 #include <string.h>
  45 #include <stdlib.h>
  46 #include "sock_manager.h"
  47
  48 #ifdef SERVER
  49 #include "fcgi_stdio.h"
  50 #define logstream FCGI_stdout
  51 #else
  52 #define FCGI_stdout stdout
  53 #define FCGI_stderr stderr
  54 #define logstream stderr
  55 #endif /*SERVER*/
  56
  57 SOCKET open_listeningsocket(uint16_t port)
  58 {
  59     SOCKET listening_socket;
  60     struct sockaddr_in sin;
  61     int sock_optval = 1;
  62
  63     listening_socket = socket(AF_INET, SOCK_STREAM, 0);
  64     if (listening_socket == -1) {
  65         perror("socket");
  66         exit(1);
  67     }
  68
  69     if (setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR,
  70                    (const char *)&sock_optval, sizeof(sock_optval)) == -1) {
  71         perror("setsockopt");
  72         exit(1);
  73     }
  74
  75     memset(&sin, 0, sizeof(sin));
  76     sin.sin_family = AF_INET;
  77     sin.sin_port = htons(port);
  78     sin.sin_addr.s_addr = htonl(INADDR_ANY);
  79
  80     if (bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
  81         perror("bind");
  82         close_socket(listening_socket);
  83         exit(1);
  84     }
  85
  86     if (listen(listening_socket, SOMAXCONN) == -1) {
  87         perror("listen");
  88         close_socket(listening_socket);
  89         exit(1);
  90     }
  91     fprintf(FCGI_stderr, "port %d is listened\n", port);
  92
  93     return listening_socket;
  94 }
  95
  96 SOCKET accept_socket(SOCKET listening_socket)
  97 {
  98     struct sockaddr_in peer_sin;
  99     unsigned int addrlen = sizeof(peer_sin);
 100
 101     return accept(listening_socket, (struct sockaddr *)&peer_sin, &addrlen);
 102 }
 103
 104 void send_stream(SOCKET connected_socket, const void *stream, OPJ_SIZE_T length)
 105 {
 106     char *ptr = (char*)stream;
 107     OPJ_SIZE_T remlen = length;
 108
 109     while (remlen > 0) {
 110         ssize_t sentlen = send(connected_socket, ptr, remlen, 0);
 111         if (sentlen == -1) {
 112             fprintf(FCGI_stderr, "sending stream error\n");
 113             break;
 114         }
 115         remlen = remlen - (OPJ_SIZE_T)sentlen;
 116         ptr = ptr + sentlen;
 117     }
 118 }
 119
 120 void * receive_stream(SOCKET connected_socket, OPJ_SIZE_T length)
 121 {
 122     char *stream, *ptr;
 123     OPJ_SIZE_T remlen;
 124
 125     ptr = stream = malloc(length);
 126     remlen = length;
 127
 128     while (remlen > 0) {
 129         ssize_t redlen = recv(connected_socket, ptr, remlen, 0);
 130         if (redlen == -1) {
 131             fprintf(FCGI_stderr, "receive stream error\n");
 132             free(stream);
 133             stream = NULL;
 134             break;
 135         }
 136         remlen -= (OPJ_SIZE_T)redlen;
 137         ptr = ptr + redlen;
 138     }
 139     return stream;
 140 }
 141
 142 OPJ_SIZE_T receive_line(SOCKET connected_socket, char *p)
 143 {
 144     OPJ_SIZE_T len = 0;
 145     while (1) {
 146         ssize_t ret;
 147         ret = recv(connected_socket, p, 1, 0);
 148         if (ret == -1) {
 149             perror("receive");
 150             exit(1);
 151         } else if (ret == 0) {
 152             break;
 153         }
 154         if (*p == '\n') {
 155             break;
 156         }
 157         p++;
 158         len++;
 159     }
 160     *p = '\0';
 161
 162     if (len == 0) {
 163         fprintf(FCGI_stderr, "Header receive error\n");
 164     }
 165
 166     return len;
 167 }
 168
 169 char * receive_string(SOCKET connected_socket)
 170 {
 171     char buf[BUF_LEN];
 172
 173     /* MM FIXME: there is a nasty bug here, size of buf if BUF_LEN which is never
 174     indicated to downstream receive_line */
 175     receive_line(connected_socket, buf);
 176
 177     return strdup(buf);
 178 }
 179
 180 int close_socket(SOCKET sock)
 181 {
 182 #ifdef _WIN32
 183     return closesocket(sock);
 184 #else
 185     return close(sock);
 186 #endif
 187 }