[paragui-cvs] CVS: paragui/src/physfs/extras Makefile.am,NONE,1.3.2.1 abs-file.h,NONE,1.1.2.1 physfshttpd.c,NONE,1.2.2.1 physfsrwops.c,NONE,1.2.2.1 physfsrwops.h,NONE,1.2.2.1

[Alexander Pipelka <address@hidden>]

Update of /cvsroot/paragui/paragui/src/physfs/extras
In directory subversions:/tmp/cvs-serv29364/src/physfs/extras

Added Files:
      Tag: devel-opengl
        Makefile.am abs-file.h physfshttpd.c physfsrwops.c 
        physfsrwops.h 
Log Message:
- GCC 3.2 compilation fixes
- updated physfs



--- NEW FILE ---
EXTRA_DIST = \
        physfsrwops.c  \
        physfsrwops.h  \
        physfshttpd.c



--- NEW FILE ---
/*
 * stdio/physfs abstraction layer 2002-08-29
 *
 * Adam D. Moss <address@hidden> <address@hidden>
 *
 * These wrapper macros and functions are designed to allow a program
 * to perform file I/O with identical semantics and syntax regardless
 * of whether PhysicsFS is being used or not.  Define USE_PHYSFS if
 * PhysicsFS is being usedl in this case you will still need to initialize
 * PhysicsFS yourself and set up its search-paths.
 */
#ifndef _ABS_FILE_H
#define _ABS_FILE_H
/*
PLEASE NOTE: This license applies to abs-file.h ONLY (to make it clear that
you may embed this wrapper code within commercial software); PhysicsFS itself
is (at the time of writing) released under a different license with
additional restrictions.

Copyright (C) 2002 Adam D. Moss (the "Author").  All Rights Reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is fur-
nished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the Author of the
Software shall not be used in advertising or otherwise to promote the sale,
use or other dealings in this Software without prior written authorization
from the Author.
*/

#include <stdlib.h>
#include <stdio.h>

#ifdef USE_PHYSFS

#include <physfs.h>
#define MY_FILETYPE PHYSFS_file
#define MY_READ(p,s,n,fp) PHYSFS_read(fp,p,s,n)
#define MY_OPEN_FOR_READ(fn) PHYSFS_openRead(fn)
static int MY_GETC(MY_FILETYPE * fp) {
  unsigned char c;
  /*if (PHYSFS_eof(fp)) {
    return EOF;
  }
  MY_READ(&c, 1, 1, fp);*/
  if (MY_READ(&c, 1, 1, fp) != 1) {
    return EOF;
  }
  return c;
}
static char * MY_GETS(char * const str, int size, MY_FILETYPE * fp) {
  int i = 0;
  int c;
  do {
    if (i == size-1) {
      break;
    }
    c = MY_GETC(fp);
    if (c == EOF) {
      break;
    }
    str[i++] = c;
  } while (c != '\0' &&
           c != -1 &&
           c != '\n');
  str[i] = '\0';
  if (i == 0) {
    return NULL;
  }
  return str;
}
#define MY_CLOSE(fp) PHYSFS_close(fp)
#define MY_ATEOF(fp) PHYSFS_eof(fp)
#define MY_REWIND(fp) PHYSFS_seek(fp,0)

#else

#define MY_FILETYPE FILE
#define MY_READ(p,s,n,fp) fread(p,s,n,fp)
#define MY_OPEN_FOR_READ(n) fopen(n, "rb")
#define MY_GETC(fp) fgetc(fp)
#define MY_GETS(str,size,fp) fgets(str,size,fp)
#define MY_CLOSE(fp) fclose(fp)
#define MY_ATEOF(fp) feof(fp)
#define MY_REWIND(fp) rewind(fp)

#endif

#endif

--- NEW FILE ---
/*
 * This is a quick and dirty HTTP server that uses PhysicsFS to retrieve
 *  files. It is not robust at all, probably buggy, and definitely poorly
 *  designed. It's just meant to show that it can be done.
 *
 * Basically, you compile this code, and run it:
 *   ./physfshttpd archive1.zip archive2.zip /path/to/a/real/dir etc...
 *
 * The files are appended in order to the PhysicsFS search path, and when
 *  a client request comes it, it looks for the file in said search path.
 *
 * My goal was to make this work in less than 300 lines of C, so again, it's
 *  not to be used for any serious purpose. Patches to make this application
 *  suck less will be readily and gratefully accepted.
 *
 * Command line I used to build this on Linux:
 *  gcc -Wall -Werror -g -o bin/physfshttpd extras/physfshttpd.c -lphysfs
 *
 * License: this code is public domain. I make no warranty that it is useful,
 *  correct, harmless, or environmentally safe.
 *
 * This particular file may be used however you like, including copying it
 *  verbatim into a closed-source project, exploiting it commercially, and
 *  removing any trace of my name from the source (although I hope you won't
 *  do that). I welcome enhancements and corrections to this file, but I do
 *  not require you to send me patches if you make changes.
 *
 * Unless otherwise stated, the rest of PhysicsFS falls under the GNU Lesser
 *  General Public License: http://www.gnu.org/licenses/lgpl.txt
 *
 *  This file was written by Ryan C. Gordon. (address@hidden).
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#ifndef LACKING_SIGNALS
#include <signal.h>
#endif

#ifndef LACKING_PROTOENT
#include <netdb.h>
#endif

#include "physfs.h"


#define DEFAULT_PORTNUM  6667

typedef struct
{
    int sock;
    struct sockaddr *addr;
    socklen_t addrlen;
} http_args;


static char *txt404 =
"HTTP/1.0 404 Not Found\n"
"Connection: close\n"
"Content-type: text/html\n"
"\n"
"<html><head><title>404 Not Found</title></head>\n"
"<body>Can't find that.</body></html>\n\n";


static void feed_file_http(const char *ipstr, int sock, const char *fname)
{
    PHYSFS_file *in = PHYSFS_openRead(fname);
    char buffer[1024];
    printf("%s: requested [%s].\n", ipstr, fname);
    if (in == NULL)
    {
        printf("%s: Can't open [%s]: %s.\n",
               ipstr, fname, PHYSFS_getLastError());
        write(sock, txt404, strlen(txt404));  /* !!! FIXME: Check retval */
    } /* if */
    else
    {
        do
        {
            PHYSFS_sint64 br = PHYSFS_read(in, buffer, 1, sizeof (buffer));
            if (br == -1)
            {
                printf("%s: Read error: %s.\n", ipstr, PHYSFS_getLastError());
                break;
            } /* if */

            write(sock, buffer, (int) br);   /* !!! FIXME: CHECK THIS RETVAL! */
        } while (!PHYSFS_eof(in));

        PHYSFS_close(in);
    } /* else */
} /* feed_file_http */


static void *do_http(void *_args)
{
    http_args *args = (http_args *) _args;
    char ipstr[128];
    char buffer[512];
    char *ptr;
    strncpy(ipstr, inet_ntoa(((struct sockaddr_in *) args->addr)->sin_addr),
            sizeof (ipstr));
    ipstr[sizeof (ipstr) - 1] = '\0';

    printf("%s: connected.\n", ipstr);
    read(args->sock, buffer, sizeof (buffer));
    buffer[sizeof (buffer) - 1] = '\0';
    ptr = strchr(buffer, '\n');
    if (!ptr)
        printf("%s: potentially bogus request.\n", ipstr);
    else
    {
        *ptr = '\0';
        ptr = strchr(buffer, '\r');
        if (ptr != NULL)
            *ptr = '\0';

        if ((toupper(buffer[0]) == 'G') &&
            (toupper(buffer[1]) == 'E') &&
            (toupper(buffer[2]) == 'T') &&
            (toupper(buffer[3]) == ' ') &&
            (toupper(buffer[4]) == '/'))
        {
            ptr = strchr(buffer + 5, ' ');
            if (ptr != NULL)
                *ptr = '\0';
            feed_file_http(ipstr, args->sock, buffer + 4);
        } /* if */
    } /* else */

    /* !!! FIXME: Time the transfer. */
    printf("%s: closing connection.\n", ipstr);
    close(args->sock);
    free(args->addr);
    free(args);
    return(NULL);
} /* do_http */


static void serve_http_request(int sock, struct sockaddr *addr,
                               socklen_t addrlen)
{
    http_args *args = (http_args *) malloc(sizeof (http_args));
    if (args == NULL)
    {
        printf("out of memory.\n");
        return;
    } // if
    args->addr = (struct sockaddr *) malloc(addrlen);
    if (args->addr == NULL)
    {
        free(args);
        printf("out of memory.\n");
        return;
    } // if

    args->sock = sock;
    args->addrlen = addrlen;
    memcpy(args->addr, addr, addrlen);

    /* !!! FIXME: optionally spin a thread... */
    do_http((void *) args);
} /* server_http_request */


static int create_listen_socket(short portnum)
{
    int retval = -1;
    int protocol = 0;  /* pray this is right. */

#ifndef LACKING_PROTOENT
    struct protoent *prot;
    setprotoent(0);
    prot = getprotobyname("tcp");
    if (prot != NULL)
        protocol = prot->p_proto;
#endif

    retval = socket(PF_INET, SOCK_STREAM, protocol);
    if (retval >= 0)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(portnum);
        addr.sin_addr.s_addr = INADDR_ANY;
        if ((bind(retval, &addr, (socklen_t) sizeof (addr)) == -1) ||
            (listen(retval, 5) == -1))
        {
            close(retval);
            retval = -1;
        } /* if */
    } /* if */

    return(retval);
} /* create_listen_socket */


static int listensocket = -1;

void at_exit_cleanup(void)
{
    /*
     * !!! FIXME: If thread support, signal threads to terminate and
     * !!! FIXME:  wait for them to clean up.
     */

    if (listensocket >= 0)
        close(listensocket);

    if (!PHYSFS_deinit())
        printf("PHYSFS_deinit() failed: %s\n", PHYSFS_getLastError());
} /* at_exit_cleanup */


int main(int argc, char **argv)
{
    int i;
    int portnum = DEFAULT_PORTNUM;

    setbuf(stdout, NULL);
    setbuf(stderr, NULL);

#ifndef LACKING_SIGNALS
    /* I'm not sure if this qualifies as a cheap trick... */
    signal(SIGTERM, exit);
    signal(SIGINT, exit);
    signal(SIGFPE, exit);
    signal(SIGSEGV, exit);
    signal(SIGPIPE, exit);
    signal(SIGILL, exit);
#endif

    if (argc == 1)
    {
        printf("USAGE: %s <archive1> [archive2 [... archiveN]]\n", argv[0]);
        return(42);
    } /* if */

    if (!PHYSFS_init(argv[0]))
    {
        printf("PHYSFS_init() failed: %s\n", PHYSFS_getLastError());
        return(42);
    } /* if */

    /* normally, this is bad practice, but oh well. */
    atexit(at_exit_cleanup);

    for (i = 1; i < argc; i++)
    {
        if (!PHYSFS_addToSearchPath(argv[i], 1))
            printf(" WARNING: failed to add [%s] to search path.\n", argv[i]);
    } /* else */

    listensocket = create_listen_socket(portnum);
    if (listensocket < 0)
    {
        printf("listen socket failed to create.\n");
        return(42);
    } /* if */

    while (1)  /* infinite loop for now. */
    {
        struct sockaddr addr;
        socklen_t len;
        int s = accept(listensocket, &addr, &len);
        if (s < 0)
        {
            printf("accept() failed: %s\n", strerror(errno));
            close(listensocket);
            return(42);
        } /* if */

        serve_http_request(s, &addr, len);
    } /* while */

    return(0);
} /* main */

/* end of physfshttpd.c ... */


--- NEW FILE ---
/*
 * This code provides a glue layer between PhysicsFS and Simple Directmedia
 *  Layer's (SDL) RWops i/o abstraction.
 *
 * License: this code is public domain. I make no warranty that it is useful,
 *  correct, harmless, or environmentally safe.
 *
 * This particular file may be used however you like, including copying it
 *  verbatim into a closed-source project, exploiting it commercially, and
 *  removing any trace of my name from the source (although I hope you won't
 *  do that). I welcome enhancements and corrections to this file, but I do
 *  not require you to send me patches if you make changes.
 *
 * Unless otherwise stated, the rest of PhysicsFS falls under the GNU Lesser
 *  General Public License: http://www.gnu.org/licenses/lgpl.txt
 *
 * SDL falls under the LGPL, too. You can get SDL at http://www.libsdl.org/
 *
 *  This file was written by Ryan C. Gordon. (address@hidden).
 */

#include <stdio.h>  /* used for SEEK_SET, SEEK_CUR, SEEK_END ... */
#include "physfsrwops.h"

static int physfsrwops_seek(SDL_RWops *rw, int offset, int whence)
{
    PHYSFS_file *handle = (PHYSFS_file *) rw->hidden.unknown.data1;
    int pos = 0;

    if (whence == SEEK_SET)
    {
        pos = offset;
    } /* if */

    else if (whence == SEEK_CUR)
    {
        PHYSFS_sint64 current = PHYSFS_tell(handle);
        if (current == -1)
        {
            SDL_SetError("Can't find position in file: %s",
                          PHYSFS_getLastError());
            return(-1);
        } /* if */

        pos = (int) current;
        if ( ((PHYSFS_sint64) pos) != current )
        {
            SDL_SetError("Can't fit current file position in an int!");
            return(-1);
        } /* if */

        if (offset == 0)  /* this is a "tell" call. We're done. */
            return(pos);

        pos += offset;
    } /* else if */

    else if (whence == SEEK_END)
    {
        PHYSFS_sint64 len = PHYSFS_fileLength(handle);
        if (len == -1)
        {
            SDL_SetError("Can't find end of file: %s", PHYSFS_getLastError());
            return(-1);
        } /* if */

        pos = (int) len;
        if ( ((PHYSFS_sint64) pos) != len )
        {
            SDL_SetError("Can't fit end-of-file position in an int!");
            return(-1);
        } /* if */

        pos += offset;
    } /* else if */

    else
    {
        SDL_SetError("Invalid 'whence' parameter.");
        return(-1);
    } /* else */

    if ( pos < 0 )
    {
        SDL_SetError("Attempt to seek past start of file.");
        return(-1);
    } /* if */
    
    if (!PHYSFS_seek(handle, (PHYSFS_uint64) pos))
    {
        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
        return(-1);
    } /* if */

    return(pos);
} /* physfsrwops_seek */


static int physfsrwops_read(SDL_RWops *rw, void *ptr, int size, int maxnum)
{
    PHYSFS_file *handle = (PHYSFS_file *) rw->hidden.unknown.data1;
    PHYSFS_sint64 rc = PHYSFS_read(handle, ptr, size, maxnum);
    if (rc != maxnum)
    {
        if (!PHYSFS_eof(handle)) /* not EOF? Must be an error. */
            SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
    } /* if */

    return((int) rc);
} /* physfsrwops_read */


static int physfsrwops_write(SDL_RWops *rw, const void *ptr, int size, int num)
{
    PHYSFS_file *handle = (PHYSFS_file *) rw->hidden.unknown.data1;
    PHYSFS_sint64 rc = PHYSFS_write(handle, ptr, size, num);
    if (rc != num)
        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());

    return((int) rc);
} /* physfsrwops_write */


static int physfsrwops_close(SDL_RWops *rw)
{
    PHYSFS_file *handle = (PHYSFS_file *) rw->hidden.unknown.data1;
    if (!PHYSFS_close(handle))
    {
        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
        return(-1);
    } /* if */

    SDL_FreeRW(rw);
    return(0);
} /* physfsrwops_close */


static SDL_RWops *create_rwops(PHYSFS_file *handle)
{
    SDL_RWops *retval = NULL;

    if (handle == NULL)
        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
    else
    {
        retval = SDL_AllocRW();
        if (retval != NULL)
        {
            retval->seek  = physfsrwops_seek;
            retval->read  = physfsrwops_read;
            retval->write = physfsrwops_write;
            retval->close = physfsrwops_close;
            retval->hidden.unknown.data1 = handle;
        } /* if */
    } /* else */

    return(retval);
} /* create_rwops */


SDL_RWops *PHYSFSRWOPS_makeRWops(PHYSFS_file *handle)
{
    SDL_RWops *retval = NULL;
    if (handle == NULL)
        SDL_SetError("NULL pointer passed to PHYSFSRWOPS_makeRWops().");
    else
        retval = create_rwops(handle);

    return(retval);
} /* PHYSFSRWOPS_makeRWops */


SDL_RWops *PHYSFSRWOPS_openRead(const char *fname)
{
    return(create_rwops(PHYSFS_openRead(fname)));
} /* PHYSFSRWOPS_openRead */


SDL_RWops *PHYSFSRWOPS_openWrite(const char *fname)
{
    return(create_rwops(PHYSFS_openWrite(fname)));
} /* PHYSFSRWOPS_openWrite */


SDL_RWops *PHYSFSRWOPS_openAppend(const char *fname)
{
    return(create_rwops(PHYSFS_openAppend(fname)));
} /* PHYSFSRWOPS_openAppend */


/* end of physfsrwops.c ... */


--- NEW FILE ---
/*
 * This code provides a glue layer between PhysicsFS and Simple Directmedia
 *  Layer's (SDL) RWops i/o abstraction.
 *
 * License: this code is public domain. I make no warranty that it is useful,
 *  correct, harmless, or environmentally safe.
 *
 * This particular file may be used however you like, including copying it
 *  verbatim into a closed-source project, exploiting it commercially, and
 *  removing any trace of my name from the source (although I hope you won't
 *  do that). I welcome enhancements and corrections to this file, but I do
 *  not require you to send me patches if you make changes.
 *
 * Unless otherwise stated, the rest of PhysicsFS falls under the GNU Lesser
 *  General Public License: http://www.gnu.org/licenses/lgpl.txt
 *
 * SDL falls under the LGPL, too. You can get SDL at http://www.libsdl.org/
 *
 *  This file was written by Ryan C. Gordon. (address@hidden).
 */

#ifndef _INCLUDE_PHYSFSRWOPS_H_
#define _INCLUDE_PHYSFSRWOPS_H_

#include "physfs.h"
#include "SDL.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * Open a platform-independent filename for reading, and make it accessible
 *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
 *  RWops is closed. PhysicsFS should be configured to your liking before
 *  opening files through this method.
 *
 *   @param filename File to open in platform-independent notation.
 *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
 *           of the error can be gleaned from PHYSFS_getLastError().
 */
__EXPORT__ SDL_RWops *PHYSFSRWOPS_openRead(const char *fname);

/**
 * Open a platform-independent filename for writing, and make it accessible
 *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
 *  RWops is closed. PhysicsFS should be configured to your liking before
 *  opening files through this method.
 *
 *   @param filename File to open in platform-independent notation.
 *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
 *           of the error can be gleaned from PHYSFS_getLastError().
 */
__EXPORT__ SDL_RWops *PHYSFSRWOPS_openWrite(const char *fname);

/**
 * Open a platform-independent filename for appending, and make it accessible
 *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
 *  RWops is closed. PhysicsFS should be configured to your liking before
 *  opening files through this method.
 *
 *   @param filename File to open in platform-independent notation.
 *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
 *           of the error can be gleaned from PHYSFS_getLastError().
 */
__EXPORT__ SDL_RWops *PHYSFSRWOPS_openAppend(const char *fname);

/**
 * Make a SDL_RWops from an existing PhysicsFS file handle. You should
 *  dispose of any references to the handle after successful creation of
 *  the RWops. The actual PhysicsFS handle will be destroyed when the
 *  RWops is closed.
 *
 *   @param handle a valid PhysicsFS file handle.
 *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
 *           of the error can be gleaned from PHYSFS_getLastError().
 */
__EXPORT__ SDL_RWops *PHYSFSRWOPS_makeRWops(PHYSFS_file *handle);

#ifdef __cplusplus
}
#endif

#endif /* include-once blocker */

/* end of physfsrwops.h ... */