apps/websrv/net.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   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 3 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 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, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/socket.h>
  28 #include <netdb.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include "http.h"
  32 #include "client.h"
  33 #include "net.h"
  34
  35 #define SUPPORT_IPV6    1
  36
  37 struct sockaddr *sockName;    // "Jmeno" portu
  38 struct sockaddr *clientInfo;  // Klient, ktere se pripojil
  39
  40 int mainSocket;               // Soket
  41 socklen_t addrlen;            // Velikost adresy vzdaleneho pocítace
  42 char *buffer;                 // Buffer
  43 int client_count;             // Pocet pripojenych clientu
  44 int proto;                    // Protocol
  45
  46 client_t client_list;
  47
  48
  49 int send_to_socket (int fd, char *data, unsigned len)
  50 {
  51         int ret;
  52         if ((ret = send (fd, data, len, 0)) == -1) {
  53                 printf ("ERROR -> send () = -1\n");
  54                 return -1;
  55         }
  56
  57         return ret;
  58 }
  59
  60 int client_get (client_t *c)
  61 {
  62         if (c->ret > 32566) {
  63                 c->state = CLIENT_STATE_TIMEOUT;
  64                 return 1;
  65         }
  66
  67         memset (buffer, 0, 1024);
  68         int ret = recv (c->fd, buffer, 1024, 0);
  69
  70         if (ret < 1) {
  71                 c->ret ++;
  72                 return ret;
  73         }
  74
  75         buffer[ret] = '\0';
  76
  77 //      printf ("DATA: %s\n", buffer);
  78
  79         if (!strncmp (buffer, "GET /", 5)) {
  80
  81                 int i;
  82                 for (i = 4; i < ret; i ++)
  83                         if (buffer[i] == ' ')
  84                                 break;
  85
  86                 if ((i-5) >= 32)
  87                         i = 36;
  88
  89                 memcpy (c->page, buffer+5, i-5);
  90                 c->page[i-5] = '\0';
  91
  92                 c->state = CLIENT_STATE_TRANSFER;
  93
  94                 return 1;
  95         } else
  96                 printf ("ERROR -> corrupted http session ..\n");
  97
  98         c->state = CLIENT_STATE_DONE;
  99
 100         return ret;
 101 }
 102
 103 client_t *client_connected (int fd)
 104 {
 105         client_t *c;
 106         for (c = client_list.next; c != &client_list; c = c->next)
 107                 if (c->fd == fd)
 108                         return 0;
 109
 110         // alloc and init context
 111         client_t *ctx = (client_t *) malloc (sizeof (client_t));
 112
 113         if (!ctx)
 114                 return 0;
 115
 116         ctx->fd = fd;
 117         ctx->state = CLIENT_STATE_CONNECTED;
 118         ctx->ret = 0;
 119
 120         ctx->next = &client_list;
 121         ctx->prev = client_list.prev;
 122         ctx->prev->next = ctx;
 123         ctx->next->prev = ctx;
 124
 125         return ctx;
 126 }
 127
 128 int client_handle (client_t *c)
 129 {
 130         switch (c->state) {
 131                 case CLIENT_STATE_CONNECTED:
 132                         return client_get (c);
 133                 case CLIENT_STATE_TRANSFER:
 134                         return http_transfer (c);
 135                 case CLIENT_STATE_DONE:
 136                 case CLIENT_STATE_TIMEOUT:
 137                         /* disconnect socket */
 138                         close (c->fd);
 139
 140                         /* delete client_t * struct from list */
 141                         c->next->prev = c->prev;
 142                         c->prev->next = c->next;
 143
 144                         free (c);
 145                         return 0;
 146         }
 147
 148         return 0;
 149 }
 150
 151 int init (int port, int flags)
 152 {
 153         proto = AF_INET;
 154
 155         /* switch to IPv6 */
 156         if (flags & FLAG_IPV6) {
 157                  proto = AF_INET6;
 158                  printf ("> initializing IPv6\n");
 159         } else
 160                  printf ("> initializing IPv4\n");
 161
 162         if ((mainSocket = socket (proto, SOCK_STREAM, IPPROTO_TCP)) == -1) {
 163                 printf ("ERROR -> socket ()\n");
 164                 return -1;
 165         }
 166
 167         if (proto == AF_INET6) {
 168                 struct sockaddr_in6 *sockName6 = (struct sockaddr_in6 *) malloc (sizeof (struct sockaddr_in6));
 169                 clientInfo = (struct sockaddr *) malloc (sizeof (struct sockaddr_in6));
 170
 171                 if (!sockName6 || !clientInfo)
 172                         return 0;
 173
 174                 sockName6->sin6_family = proto;
 175                 sockName6->sin6_port = htons (port);
 176                 //sockName6->sin6_addr.s6_addr = INADDR6_ANY;
 177
 178                 sockName = (struct sockaddr *) sockName6;
 179
 180                 addrlen = sizeof (struct sockaddr_in6);
 181         } else {
 182                 struct sockaddr_in *sockName4 = (struct sockaddr_in *) malloc (sizeof (struct sockaddr_in));
 183                 clientInfo = (struct sockaddr *) malloc (sizeof (struct sockaddr_in));
 184
 185                 if (!sockName4 || !clientInfo)
 186                         return 0;
 187
 188                 sockName4->sin_family = proto;
 189                 sockName4->sin_port = htons (port);
 190                 sockName4->sin_addr.s_addr = INADDR_ANY;
 191
 192                 sockName = (struct sockaddr *) sockName4;
 193
 194                 addrlen = sizeof (struct sockaddr_in);
 195         }
 196
 197         if ((bind (mainSocket, (struct sockaddr *) sockName, addrlen)) == -1) {
 198                 printf ("ERROR -> bind () - %d\n", port);
 199                 return -1;
 200         }
 201
 202         /* max 10 connecting clients */
 203         if (listen (mainSocket, 10) == -1) {
 204                 printf ("ERROR -> listen ()\n");
 205                 return -1;
 206         }
 207
 208         // Let's switch socket mode to non-blocking
 209         int oldFlag = fcntl (mainSocket, F_GETFL, 0);
 210         if (fcntl (mainSocket, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 211                 printf ("ERROR -> fcntl ()\n");
 212                 return 0;
 213         }
 214
 215         printf ("> listen on port: %d\n", port);
 216
 217         buffer = (char *) malloc (sizeof (char) * 1025);
 218
 219         if (!buffer) {
 220                 printf ("Buffer is out of memory\n");
 221                 return 0;
 222         }
 223
 224         client_list.next = &client_list;
 225         client_list.prev = &client_list;
 226
 227         client_count = 0;
 228
 229         return http_init ();
 230 }
 231
 232 int loop ()
 233 {
 234         int client = 0;
 235
 236         client = accept (mainSocket, (struct sockaddr *) clientInfo, &addrlen);
 237
 238         if (client > 0) {
 239                 char str[40];
 240
 241                 if (proto == AF_INET) {
 242                         struct sockaddr_in *clientInfoS = (struct sockaddr_in *) clientInfo;
 243                         inet_ntop (proto, (void *) &clientInfoS->sin_addr, str, 40);
 244
 245                         printf ("> New client (%d) -- %s:%d connected !\n", client, str, clientInfoS->sin_port);
 246                 } else if (proto == AF_INET6) {
 247                         struct sockaddr_in6 *clientInfoS = (struct sockaddr_in6 *) clientInfo;
 248                         inet_ntop (proto, (void *) &clientInfoS->sin6_addr, str, 40);
 249
 250                         printf ("> New client (%d) -- [%s]:%d connected !\n", client, str, clientInfoS->sin6_port);
 251                 }
 252
 253                 // Nastavime soket do neblokovaciho rezimu
 254                 int oldFlag = fcntl (client, F_GETFL, 0);
 255                 if (fcntl (client, F_SETFL, oldFlag | O_NONBLOCK) == -1) {
 256                         printf ("Cant set socket to nonblocking mode\n");
 257                         return 0;
 258                 }
 259
 260                 client_t *c = client_connected (client);
 261
 262                 if (!c)
 263                         close (client);
 264         }
 265
 266         unsigned i = 0;
 267
 268         client_t *c;
 269         for (c = client_list.next; c != &client_list; c = c->next) {
 270                 if (!client_handle (c))
 271                         break;
 272
 273                 i ++;
 274         }
 275
 276         if (!i)
 277                 usleep (64);
 278
 279         return 1;
 280 }