httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject cvs commit: httpd-2.0/modules/ssl README ssl_util_table.c ssl_util_table.h
Date Sat, 05 May 2001 20:19:37 GMT
rse         01/05/05 13:19:36

  Modified:    modules/ssl README ssl_util_table.c ssl_util_table.h
  Log:
  Port ssl_util_table.[ch] to Apache 2.0 by just removing all platform
  depended code (table_read, table_write). This is possible because this
  table library is local to mod_ssl and inside mod_ssl this library is
  used for manipulating hash tables inside shared memory segments only. So
  we can just get rid of the unportable parts at all.
  
  Revision  Changes    Path
  1.16      +2 -2      httpd-2.0/modules/ssl/README
  
  Index: README
  ===================================================================
  RCS file: /home/cvs/httpd-2.0/modules/ssl/README,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- README	2001/05/05 20:11:04	1.15
  +++ README	2001/05/05 20:19:34	1.16
  @@ -54,8 +54,8 @@
    - ssl_util.c .............. utility functions
    # ssl_util_ssl.c .......... the OpenSSL companion source
    # ssl_util_ssl.h .......... the OpenSSL companion header
  - - ssl_util_table.c ........ the hash table library source
  - - ssl_util_table.h ........ the hash table library header
  + # ssl_util_table.c ........ the hash table library source
  + # ssl_util_table.h ........ the hash table library header
   
    Legend: # = already ported to Apache 2.0
            - = port still not finished
  
  
  
  1.4       +0 -353    httpd-2.0/modules/ssl/ssl_util_table.c
  
  Index: ssl_util_table.c
  ===================================================================
  RCS file: /home/cvs/httpd-2.0/modules/ssl/ssl_util_table.c,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- ssl_util_table.c	2001/05/05 10:12:08	1.3
  +++ ssl_util_table.c	2001/05/05 20:19:34	1.4
  @@ -87,18 +87,8 @@
    *   o added support for MM library via ta_{malloc,calloc,realloc,free}
    */
   
  -#if 0 /* XXX */
  -
  -#include <fcntl.h>
  -#include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
  -#ifdef WIN32
  -#include <io.h>
  -#include <errno.h>
  -#else
  -#include <unistd.h>
  -#endif
   
   /* forward definitions for table.h */
   typedef struct table_st table_t;
  @@ -2352,347 +2342,6 @@
       return TABLE_ERROR_NONE;
   }
   
  -/******************************* file routines *******************************/
  -
  -/*
  - * int table_read
  - *
  - * DESCRIPTION:
  - *
  - * Read in a table from a file that had been written to disk earlier
  - * via table_write.
  - *
  - * RETURNS:
  - *
  - * Success - Pointer to the new table structure which must be passed
  - * to table_free to be deallocated.
  - *
  - * Failure - NULL
  - *
  - * ARGUMENTS:
  - *
  - * path - Table file to read in.
  - *
  - * error_p - Pointer to an integer which, if not NULL, will contain a
  - * table error code.
  - */
  -table_t *table_read(const char *path, int *error_p,
  -                    void *(*malloc_f)(size_t size),
  -                    void *(*calloc_f)(size_t number, size_t size),
  -                    void *(*realloc_f)(void *ptr, size_t size),
  -                    void (*free_f)(void *ptr))
  -{
  -    unsigned int size;
  -    int fd, ent_size;
  -    FILE *infile;
  -    table_entry_t entry, **bucket_p, *entry_p = NULL, *last_p;
  -    unsigned long pos;
  -    table_t *table_p;
  -
  -    /* open the file */
  -    fd = open(path, O_RDONLY, 0);
  -    if (fd < 0) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_OPEN;
  -        return NULL;
  -    }
  -
  -    /* allocate a table structure */
  -    if (malloc_f != NULL)
  -        table_p = malloc_f(sizeof(table_t));
  -    else
  -        table_p = malloc(sizeof(table_t));
  -    if (table_p == NULL) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_ALLOC;
  -        return NULL;
  -    }
  -
  -    /* now open the fd to get buffered i/o */
  -    infile = fdopen(fd, "r");
  -    if (infile == NULL) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_OPEN;
  -        return NULL;
  -    }
  -
  -    /* read the main table struct */
  -    if (fread(table_p, sizeof(table_t), 1, infile) != 1) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_READ;
  -        if (free_f != NULL)
  -            free_f(table_p);
  -        else
  -            free(table_p);
  -        return NULL;
  -    }
  -    table_p->ta_file_size = 0;
  -
  -    table_p->ta_malloc  = malloc_f  != NULL ? malloc_f  : malloc;
  -    table_p->ta_calloc  = calloc_f  != NULL ? calloc_f  : calloc;
  -    table_p->ta_realloc = realloc_f != NULL ? realloc_f : realloc;
  -    table_p->ta_free    = free_f    != NULL ? free_f    : free;
  -
  -    /* is the file contain bad info or maybe another system type? */
  -    if (table_p->ta_magic != TABLE_MAGIC) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_PNT;
  -        return NULL;
  -    }
  -
  -    /* allocate the buckets */
  -    table_p->ta_buckets = (table_entry_t **)table_p->ta_calloc(table_p->ta_bucket_n,
sizeof(table_entry_t *));
  -    if (table_p->ta_buckets == NULL) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_ALLOC;
  -        table_p->ta_free(table_p);
  -        return NULL;
  -    }
  -
  -    if (fread(table_p->ta_buckets, sizeof(table_entry_t *), table_p->ta_bucket_n,
  -              infile) != (size_t) table_p->ta_bucket_n) {
  -        if (error_p != NULL)
  -            *error_p = TABLE_ERROR_READ;
  -        table_p->ta_free(table_p->ta_buckets);
  -        table_p->ta_free(table_p);
  -        return NULL;
  -    }
  -
  -    /* read in the entries */
  -    for (bucket_p = table_p->ta_buckets;
  -         bucket_p < table_p->ta_buckets + table_p->ta_bucket_n;
  -         bucket_p++) {
  -
  -        /* skip null buckets */
  -        if (*bucket_p == NULL)
  -            continue;
  -        /* run through the entry list */
  -        last_p = NULL;
  -        for (pos = *(unsigned long *) bucket_p;;
  -             pos = (unsigned long) entry_p->te_next_p) {
  -
  -            /* read in the entry */
  -            if (fseek(infile, pos, SEEK_SET) != 0) {
  -                if (error_p != NULL)
  -                    *error_p = TABLE_ERROR_SEEK;
  -                table_p->ta_free(table_p->ta_buckets);
  -                if (entry_p != NULL)
  -                    table_p->ta_free(entry_p);
  -                table_p->ta_free(table_p);
  -                /* the other table elements will not be freed */
  -                return NULL;
  -            }
  -            if (fread(&entry, sizeof(struct table_shell_st), 1, infile) != 1) {
  -                if (error_p != NULL)
  -                    *error_p = TABLE_ERROR_READ;
  -                table_p->ta_free(table_p->ta_buckets);
  -                if (entry_p != NULL)
  -                    table_p->ta_free(entry_p);
  -                table_p->ta_free(table_p);
  -                /* the other table elements will not be freed */
  -                return NULL;
  -            }
  -
  -            /* make a new entry */
  -            ent_size = entry_size(table_p, entry.te_key_size, entry.te_data_size);
  -            entry_p = (table_entry_t *)table_p->ta_malloc(ent_size);
  -            if (entry_p == NULL) {
  -                if (error_p != NULL)
  -                    *error_p = TABLE_ERROR_ALLOC;
  -                table_p->ta_free(table_p->ta_buckets);
  -                table_p->ta_free(table_p);
  -                /* the other table elements will not be freed */
  -                return NULL;
  -            }
  -            entry_p->te_key_size = entry.te_key_size;
  -            entry_p->te_data_size = entry.te_data_size;
  -            entry_p->te_next_p = entry.te_next_p;
  -
  -            if (last_p == NULL)
  -                *bucket_p = entry_p;
  -            else
  -                last_p->te_next_p = entry_p;
  -            /* determine how much more we have to read */
  -            size = ent_size - sizeof(struct table_shell_st);
  -            if (fread(ENTRY_KEY_BUF(entry_p), sizeof(char), size, infile) != size) {
  -                if (error_p != NULL)
  -                    *error_p = TABLE_ERROR_READ;
  -                table_p->ta_free(table_p->ta_buckets);
  -                table_p->ta_free(entry_p);
  -                table_p->ta_free(table_p);
  -                /* the other table elements will not be freed */
  -                return NULL;
  -            }
  -
  -            /* we are done if the next pointer is null */
  -            if (entry_p->te_next_p == (unsigned long) 0)
  -                break;
  -            last_p = entry_p;
  -        }
  -    }
  -
  -    (void) fclose(infile);
  -
  -    if (error_p != NULL)
  -        *error_p = TABLE_ERROR_NONE;
  -    return table_p;
  -}
  -
  -/*
  - * int table_write
  - *
  - * DESCRIPTION:
  - *
  - * Write a table from memory to file.
  - *
  - * RETURNS:
  - *
  - * Success - TABLE_ERROR_NONE
  - *
  - * Failure - Table error code.
  - *
  - * ARGUMENTS:
  - *
  - * table_p - Pointer to the table that we are writing to the file.
  - *
  - * path - Table file to write out to.
  - *
  - * mode - Mode of the file.  This argument is passed on to open when
  - * the file is created.
  - */
  -int table_write(const table_t * table_p, const char *path, const int mode)
  -{
  -    int fd, rem, ent_size;
  -    unsigned int bucket_c;
  -    unsigned long size;
  -    table_entry_t *entry_p, **buckets, **bucket_p, *next_p;
  -    table_t tmain;
  -    FILE *outfile;
  -
  -    if (table_p == NULL)
  -        return TABLE_ERROR_ARG_NULL;
  -    if (table_p->ta_magic != TABLE_MAGIC)
  -        return TABLE_ERROR_PNT;
  -    fd = open(path, O_WRONLY | O_CREAT, mode);
  -    if (fd < 0)
  -        return TABLE_ERROR_OPEN;
  -    outfile = fdopen(fd, "w");
  -    if (outfile == NULL)
  -        return TABLE_ERROR_OPEN;
  -    /* allocate a block of sizes for each bucket */
  -    buckets = (table_entry_t **) table_p->ta_malloc(sizeof(table_entry_t *) *
  -                                        table_p->ta_bucket_n);
  -    if (buckets == NULL)
  -        return TABLE_ERROR_ALLOC;
  -    /* make a copy of the tmain struct */
  -    tmain = *table_p;
  -
  -    /* start counting the bytes */
  -    size = 0;
  -    size += sizeof(table_t);
  -
  -    /* buckets go right after tmain struct */
  -    tmain.ta_buckets = (table_entry_t **) size;
  -    size += sizeof(table_entry_t *) * table_p->ta_bucket_n;
  -
  -    /* run through and count the buckets */
  -    for (bucket_c = 0; bucket_c < table_p->ta_bucket_n; bucket_c++) {
  -        bucket_p = table_p->ta_buckets + bucket_c;
  -        if (*bucket_p == NULL) {
  -            buckets[bucket_c] = NULL;
  -            continue;
  -        }
  -        buckets[bucket_c] = (table_entry_t *) size;
  -        for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) {
  -            size += entry_size(table_p, entry_p->te_key_size, entry_p->te_data_size);
  -            /*
  -             * We now have to round the file to the nearest long so the
  -             * mmaping of the longs in the entry structs will work.
  -             */
  -            rem = size & (sizeof(long) - 1);
  -            if (rem > 0)
  -                size += sizeof(long) - rem;
  -        }
  -    }
  -    /* add a \0 at the end to fill the last section */
  -    size++;
  -
  -    /* set the tmain fields */
  -    tmain.ta_linear.tl_magic = 0;
  -    tmain.ta_linear.tl_bucket_c = 0;
  -    tmain.ta_linear.tl_entry_c = 0;
  -    tmain.ta_file_size = size;
  -
  -    /*
  -     * Now we can start the writing because we got the bucket offsets.
  -     */
  -
  -    /* write the tmain table struct */
  -    size = 0;
  -    if (fwrite(&tmain, sizeof(table_t), 1, outfile) != 1) {
  -        table_p->ta_free(buckets);
  -        return TABLE_ERROR_WRITE;
  -    }
  -    size += sizeof(table_t);
  -    if (fwrite(buckets, sizeof(table_entry_t *), table_p->ta_bucket_n,
  -               outfile) != (size_t) table_p->ta_bucket_n) {
  -        table_p->ta_free(buckets);
  -        return TABLE_ERROR_WRITE;
  -    }
  -    size += sizeof(table_entry_t *) * table_p->ta_bucket_n;
  -
  -    /* write out the entries */
  -    for (bucket_p = table_p->ta_buckets;
  -         bucket_p < table_p->ta_buckets + table_p->ta_bucket_n;
  -         bucket_p++) {
  -        for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) {
  -
  -            ent_size = entry_size(table_p, entry_p->te_key_size,
  -                                  entry_p->te_data_size);
  -            size += ent_size;
  -            /* round to nearest long here so we can write copy */
  -            rem = size & (sizeof(long) - 1);
  -            if (rem > 0)
  -                size += sizeof(long) - rem;
  -            next_p = entry_p->te_next_p;
  -            if (next_p != NULL)
  -                entry_p->te_next_p = (table_entry_t *) size;
  -            /* now write to disk */
  -            if (fwrite(entry_p, ent_size, 1, outfile) != 1) {
  -                table_p->ta_free(buckets);
  -                return TABLE_ERROR_WRITE;
  -            }
  -
  -            /* restore the next pointer */
  -            if (next_p != NULL)
  -                entry_p->te_next_p = next_p;
  -            /* now write the padding information */
  -            if (rem > 0) {
  -                rem = sizeof(long) - rem;
  -                /*
  -                 * NOTE: this won't leave fseek'd space at the end but we
  -                 * don't care there because there is no accessed memory
  -                 * afterwards.  We write 1 \0 at the end to make sure.
  -                 */
  -                if (fseek(outfile, rem, SEEK_CUR) != 0) {
  -                    table_p->ta_free(buckets);
  -                    return TABLE_ERROR_SEEK;
  -                }
  -            }
  -        }
  -    }
  -    /*
  -     * Write a \0 at the end of the file to make sure that the last
  -     * fseek filled with nulls.
  -     */
  -    (void) fputc('\0', outfile);
  -
  -    (void) fclose(outfile);
  -    table_p->ta_free(buckets);
  -
  -    return TABLE_ERROR_NONE;
  -}
  -
   /******************************** table order ********************************/
   
   /*
  @@ -2866,6 +2515,4 @@
           *data_size_p = entry_p->te_data_size;
       return TABLE_ERROR_NONE;
   }
  -
  -#endif /* XXX */
   
  
  
  
  1.5       +0 -6      httpd-2.0/modules/ssl/ssl_util_table.h
  
  Index: ssl_util_table.h
  ===================================================================
  RCS file: /home/cvs/httpd-2.0/modules/ssl/ssl_util_table.h,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- ssl_util_table.h	2001/05/05 19:56:17	1.4
  +++ ssl_util_table.h	2001/05/05 20:19:35	1.5
  @@ -83,8 +83,6 @@
   #ifndef __SSL_UTIL_TABLE_H__
   #define __SSL_UTIL_TABLE_H__
   
  -#if 0 /* XXX */
  -
   #ifdef __cplusplus
   extern "C" {
   #endif /* __cplusplus */
  @@ -177,15 +175,11 @@
   extern int             table_first_r(table_t *table_p, table_linear_t *linear_p, void **key_buf_p,
int *key_size_p, void **data_buf_p, int *data_size_p);
   extern int             table_next_r(table_t *table_p, table_linear_t *linear_p, void **key_buf_p,
int *key_size_p, void **data_buf_p, int *data_size_p);
   extern int             table_this_r(table_t *table_p, table_linear_t *linear_p, void **key_buf_p,
int *key_size_p, void **data_buf_p, int *data_size_p);
  -extern table_t        *table_read(const char *path, int *error_p, void *(*malloc_f)(size_t
size), void *(*calloc_f)(size_t number, size_t size), void *(*realloc_f)(void *ptr, size_t
size), void (*free_f)(void *ptr));
  -extern int             table_write(const table_t *table_p, const char *path, const int
mode);
   extern table_entry_t **table_order(table_t *table_p, table_compare_t compare, int *num_entries_p,
int *error_p);
   extern int             table_entry_info(table_t *table_p, table_entry_t *entry_p, void
**key_buf_p, int *key_size_p, void **data_buf_p, int *data_size_p);
   
   #ifdef __cplusplus
   }
   #endif /* __cplusplus */
  -
  -#endif /* XXX */
   
   #endif /* __SSL_UTIL_TABLE_H__ */
  
  
  

Mime
View raw message