path: root/src/common/socket.c

// $Id: socket.c,v 1.1.1.1 2004/09/10 17:44:49 MagicalTux Exp $
// original : core.c 2003/02/26 18:03:12 Rev 1.7

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <errno.h>

#ifdef LCCWIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winsock2.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/time.h>
#include <unistd.h>
#endif

#include <fcntl.h>
#include <string.h>

#include "mmo.h"                // [Valaris] thanks to fov
#include "socket.h"
#include "utils.h"

#ifdef MEMWATCH
#include "memwatch.h"
#endif

fd_set readfds;
int  fd_max;
int  currentuse;

int  rfifo_size = 65536;
int  wfifo_size = 65536;

struct socket_data *session[FD_SETSIZE];

static int null_parse (int fd);
static int (*default_func_parse) (int) = null_parse;

/*======================================
 *	CORE : Set function
 *--------------------------------------
 */
void set_defaultparse (int (*defaultparse) (int))
{
    default_func_parse = defaultparse;
}

/*======================================
 *	CORE : Socket Sub Function
 *--------------------------------------
 */

static int recv_to_fifo (int fd)
{
    int  len;

    //printf("recv_to_fifo : %d %d\n",fd,session[fd]->eof);
    if (session[fd]->eof)
        return -1;

#ifdef LCCWIN32
    len =
        recv (fd, session[fd]->rdata + session[fd]->rdata_size,
              RFIFOSPACE (fd), 0);
#else
    len =
        read (fd, session[fd]->rdata + session[fd]->rdata_size,
              RFIFOSPACE (fd));
#endif

//  printf (":::RECEIVE:::\n");
//  dump(session[fd]->rdata, len); printf ("\n");

    //{ int i; printf("recv %d : ",fd); for(i=0;i<len;i++){ printf("%02x ",RFIFOB(fd,session[fd]->rdata_size+i)); } printf("\n");}
    if (len > 0)
    {
        session[fd]->rdata_size += len;
        if (!session[fd]->connected)
            session[fd]->connected = 1;
    }
    else if (len <= 0)
    {
        // value of connection is not necessary the same
//      if (fd == 4)            // Removed [Yor]
//          printf("Char-Server Has Disconnected.\n");
//      else if (fd == 5)       // Removed [Yor]
//          printf("Attempt To Log In Successful.\n");
//      else if (fd == 7)       // Removed [Yor]
//          printf("Char-Server Has Disconnected.\n");
//      else if (fd == 8)       // Removed [Valaris]
//          printf("%s has logged off your server.\n",RFIFOP(fd,6));    // Removed [Valaris]

//      else if (fd != 8)   // [Valaris]
        printf ("set eof : connection #%d\n", fd);
        session[fd]->eof = 1;
    }
    return 0;
}

static int send_from_fifo (int fd)
{
    int  len;

    //printf("send_from_fifo : %d\n",fd);
    if (session[fd]->eof)
        return -1;

#ifdef LCCWIN32
    len = send (fd, session[fd]->wdata, session[fd]->wdata_size, 0);
#else
    len = write (fd, session[fd]->wdata, session[fd]->wdata_size);
#endif

//  printf (":::SEND:::\n");
//  dump(session[fd]->wdata, len); printf ("\n");

    //{ int i; printf("send %d : ",fd);  for(i=0;i<len;i++){ printf("%02x ",session[fd]->wdata[i]); } printf("\n");}
    if (len > 0)
    {
        if (len < session[fd]->wdata_size)
        {
            memmove (session[fd]->wdata, session[fd]->wdata + len,
                     session[fd]->wdata_size - len);
            session[fd]->wdata_size -= len;
        }
        else
        {
            session[fd]->wdata_size = 0;
        }
        if (!session[fd]->connected)
            session[fd]->connected = 1;
    }
    else
    {
        printf ("set eof :%d\n", fd);
        session[fd]->eof = 1;
    }
    return 0;
}

static int null_parse (int fd)
{
    printf ("null_parse : %d\n", fd);
    RFIFOSKIP (fd, RFIFOREST (fd));
    return 0;
}

/*======================================
 *	CORE : Socket Function
 *--------------------------------------
 */

static int connect_client (int listen_fd)
{
    int  fd;
    struct sockaddr_in client_address;
    unsigned int len;
    int  result;
    int  yes = 1;               // reuse fix

    //printf("connect_client : %d\n",listen_fd);

    printf ("used: %d, max FDs: %d, SOFT: %d\n", currentuse, FD_SETSIZE,
            SOFT_LIMIT);

    len = sizeof (client_address);

    fd = accept (listen_fd, (struct sockaddr *) &client_address, &len);
    if (fd_max <= fd)
    {
        fd_max = fd + 1;
    }
    else if (fd == -1)
    {
        perror ("accept");
        return -1;
    }
    if (!free_fds ())
    {                           // gracefully end the connecting if no free FD
        printf ("softlimit reached, disconnecting : %d\n", fd);
        delete_session (fd);
        return -1;
    }

//  setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof yes);   // reuse fix
#ifdef SO_REUSEPORT
//  setsockopt(fd,SOL_SOCKET,SO_REUSEPORT,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEPORT, (char *) &yes, sizeof yes);   //reuse fix
#endif
//  setsockopt(fd,IPPROTO_TCP,TCP_NODELAY,NULL,0);
    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *) &yes, sizeof yes);   // reuse fix

    FD_SET (fd, &readfds);

#ifdef LCCWIN32
    {
        unsigned long val = 1;
        ioctlsocket (fd, FIONBIO, &val);
    }
#else
    result = fcntl (fd, F_SETFL, O_NONBLOCK);
#endif

    CREATE (session[fd], struct socket_data, 1);
    CREATE (session[fd]->rdata, unsigned char, rfifo_size);
    CREATE (session[fd]->wdata, unsigned char, wfifo_size);

    session[fd]->max_rdata = rfifo_size;
    session[fd]->max_wdata = wfifo_size;
    session[fd]->func_recv = recv_to_fifo;
    session[fd]->func_send = send_from_fifo;
    session[fd]->func_parse = default_func_parse;
    session[fd]->client_addr = client_address;
    session[fd]->created = time (NULL);
    session[fd]->connected = 0;

    currentuse++;

    //printf("new_session : %d %d\n",fd,session[fd]->eof);
    return fd;
}

int make_listen_port (int port)
{
    struct sockaddr_in server_address;
    int  fd;
    int  result;
    int  yes = 1;               // reuse fix

    fd = socket (AF_INET, SOCK_STREAM, 0);
    if (fd_max <= fd)
        fd_max = fd + 1;
    else if (fd == -1)
    {
        perror ("connect");
        return -1;
    }

#ifdef LCCWIN32
    {
        unsigned long val = 1;
        ioctlsocket (fd, FIONBIO, &val);
    }
#else
    result = fcntl (fd, F_SETFL, O_NONBLOCK);
#endif

//  setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof yes);   // reuse fix
#ifdef SO_REUSEPORT
//  setsockopt(fd,SOL_SOCKET,SO_REUSEPORT,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEPORT, (char *) &yes, sizeof yes);   //reuse fix
#endif
//  setsockopt(fd,IPPROTO_TCP,TCP_NODELAY,NULL,0);
    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *) &yes, sizeof yes);   // reuse fix

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl (INADDR_ANY);
    server_address.sin_port = htons (port);

    result =
        bind (fd, (struct sockaddr *) &server_address,
              sizeof (server_address));
    if (result == -1)
    {
        perror ("bind");
        exit (1);
    }
    result = listen (fd, 5);
    if (result == -1)
    {                           /* error */
        perror ("listen");
        exit (1);
    }

    FD_SET (fd, &readfds);

    CREATE (session[fd], struct socket_data, 1);

    if (session[fd] == NULL)
    {
        printf ("out of memory : make_listen_port\n");
        exit (1);
    }
    memset (session[fd], 0, sizeof (*session[fd]));
    session[fd]->func_recv = connect_client;
    session[fd]->created = time (NULL);
    session[fd]->connected = 1;

    currentuse++;
    return fd;
}

int make_connection (long ip, int port)
{
    struct sockaddr_in server_address;
    int  fd;
    int  result;
    int  yes = 1;               // reuse fix

    fd = socket (AF_INET, SOCK_STREAM, 0);
    if (fd_max <= fd)
        fd_max = fd + 1;
    else if (fd == -1)
    {
        perror ("socket");
        return -1;
    }

//  setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof yes);   // reuse fix
#ifdef SO_REUSEPORT
//  setsockopt(fd,SOL_SOCKET,SO_REUSEPORT,NULL,0);
    setsockopt (fd, SOL_SOCKET, SO_REUSEPORT, (char *) &yes, sizeof yes);   //reuse fix
#endif
//  setsockopt(fd,IPPROTO_TCP,TCP_NODELAY,NULL,0);
    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *) &yes, sizeof yes);   // reuse fix

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = ip;
    server_address.sin_port = htons (port);

#ifdef LCCWIN32
    {
        unsigned long val = 1;
        ioctlsocket (fd, FIONBIO, &val);
    }
#else
    result = fcntl (fd, F_SETFL, O_NONBLOCK);
#endif

    result =
        connect (fd, (struct sockaddr *) (&server_address),
                 sizeof (struct sockaddr_in));

    FD_SET (fd, &readfds);

    CREATE (session[fd], struct socket_data, 1);
    CREATE (session[fd]->rdata, unsigned char, rfifo_size);
    CREATE (session[fd]->wdata, unsigned char, wfifo_size);

    session[fd]->max_rdata = rfifo_size;
    session[fd]->max_wdata = wfifo_size;
    session[fd]->func_recv = recv_to_fifo;
    session[fd]->func_send = send_from_fifo;
    session[fd]->func_parse = default_func_parse;
    session[fd]->created = time (NULL);
    session[fd]->connected = 1;

    currentuse++;
    return fd;
}

int delete_session (int fd)
{
    if (fd < 0 || fd >= FD_SETSIZE)
        return -1;
    FD_CLR (fd, &readfds);
    if (session[fd])
    {
        if (session[fd]->rdata)
            free (session[fd]->rdata);
        if (session[fd]->wdata)
            free (session[fd]->wdata);
        if (session[fd]->session_data)
            free (session[fd]->session_data);
        free (session[fd]);
    }
    session[fd] = NULL;
    shutdown (fd, SHUT_RDWR);
    close (fd);
    currentuse--;
    if (currentuse < 0)
    {
        printf ("delete_session: current sessions negative!\n");
        currentuse = 0;
    }
    //printf("delete_session:%d\n",fd);
    return 0;
}

int realloc_fifo (int fd, int rfifo_size, int wfifo_size)
{
    struct socket_data *s = session[fd];
    if (s->max_rdata != rfifo_size && s->rdata_size < rfifo_size)
    {
        RECREATE (s->rdata, unsigned char, rfifo_size);
        s->max_rdata = rfifo_size;
    }
    if (s->max_wdata != wfifo_size && s->wdata_size < wfifo_size)
    {
        RECREATE (s->wdata, unsigned char, wfifo_size);
        s->max_wdata = wfifo_size;
    }
    return 0;
}

int WFIFOSET (int fd, int len)
{
    struct socket_data *s = session[fd];
    if (s->wdata_size + len + 16384 > s->max_wdata)
    {
        realloc_fifo (fd, s->max_rdata, s->max_wdata << 1);
        printf ("socket: %d wdata expanded to %d bytes.\n", fd, s->max_wdata);
    }
    s->wdata_size = (s->wdata_size + (len) + 2048 < s->max_wdata) ?
        s->wdata_size + len : (printf ("socket: %d wdata lost !!\n", fd),
                               s->wdata_size);
    return 0;
}

int do_sendrecv (int next)
{
    fd_set rfd, wfd;
    struct timeval timeout;
    int  ret, i;

    rfd = readfds;
    FD_ZERO (&wfd);
    for (i = 0; i < fd_max; i++)
    {
        if (!session[i] && FD_ISSET (i, &readfds))
        {
            printf ("force clr fds %d\n", i);
            FD_CLR (i, &readfds);
            continue;
        }
        if (!session[i])
            continue;
        if (session[i]->wdata_size)
            FD_SET (i, &wfd);
    }
    timeout.tv_sec = next / 1000;
    timeout.tv_usec = next % 1000 * 1000;
    ret = select (fd_max, &rfd, &wfd, NULL, &timeout);
    if (ret <= 0)
        return 0;
    for (i = 0; i < fd_max; i++)
    {
        if (!session[i])
            continue;
        if (FD_ISSET (i, &wfd))
        {
            //printf("write:%d\n",i);
            if (session[i]->func_send)
                //send_from_fifo(i);
                session[i]->func_send (i);
        }
        if (FD_ISSET (i, &rfd))
        {
            //printf("read:%d\n",i);
            if (session[i]->func_recv)
                //recv_to_fifo(i);
                session[i]->func_recv (i);
        }
    }
    return 0;
}

int do_parsepacket (void)
{
    int  i;
    for (i = 0; i < fd_max; i++)
    {
        if (!session[i])
            continue;
        if (!session[i]->connected
            && time (NULL) - session[i]->created > CONNECT_TIMEOUT)
        {
            printf ("Session #%d timed out\n", i);
            session[i]->eof = 1;
        }
        if (session[i]->rdata_size == 0 && session[i]->eof == 0)
            continue;
        if (session[i]->func_parse)
        {
            session[i]->func_parse (i);
            if (!session[i])
                continue;
        }
        RFIFOFLUSH (i);
    }
    return 0;
}

void do_socket (void)
{
    FD_ZERO (&readfds);
    currentuse = 2;
}

int RFIFOSKIP (int fd, int len)
{
    struct socket_data *s = session[fd];

    if (s->rdata_size - s->rdata_pos - len < 0)
    {
        fprintf (stderr, "too many skip\n");
        exit (1);
    }

    s->rdata_pos = s->rdata_pos + len;

    return 0;
}

int Net_Init (void)
{
#ifdef LCCWIN32
    /* Start up the windows networking */
    WORD version_wanted = MAKEWORD (1, 1);
    WSADATA wsaData;

    if (WSAStartup (version_wanted, &wsaData) != 0)
    {
        printf ("SYSERR: WinSock not available!\n");
        exit (1);
    }
#endif

    return (0);
}

int fclose_ (FILE * fp)
{
    int  res = fclose (fp);
    if (res == 0)
        currentuse--;
//  printf("file closed: used: %d\n",currentuse);
    return res;
}

FILE *fopen_ (const char *path, const char *mode)
{
    FILE *f = fopen (path, mode);
    if (f != NULL)
        currentuse++;
//  printf("file opened: used: %d\n",currentuse);
    return f;
}

int free_fds ()
{
    return (currentuse + 1 < SOFT_LIMIT) ? 1 : 0;
}