1.1 --- a/.rootkeys	Mon Jun 28 08:17:15 2004 +0000
     1.2 +++ b/.rootkeys	Mon Jun 28 15:03:15 2004 +0000
     1.3 @@ -165,6 +165,44 @@ 401d7e16RJj-lbtsVEjua6HYAIiKiA tools/exa
     1.4  40c9c468pXANclL7slGaoD0kSrIwoQ tools/examples/xm_dom_create.py
     1.5  40cf2937oKlROYOJTN8GWwWM5AmjBg tools/examples/xmdefaults
     1.6  40dfd40auJwNnb8NoiSnRkvZaaXkUg tools/examples/xmnetbsd
     1.7 +40e033325Sjqs-_4TuzeUEprP_gYFg tools/lib/allocate.c
     1.8 +40e03332KYz7o1bn2MG_KPbBlyoIMA tools/lib/allocate.h
     1.9 +40e03332IyRttYoXKoJla5qCC514SQ tools/lib/debug.h
    1.10 +40e03332qV5tJ-GJZjo-LBCeGuEjJA tools/lib/enum.c
    1.11 +40e03332wwMVxfobgA1PSMTSAGLiCw tools/lib/enum.h
    1.12 +40e03332p5Dc_owJQRuN72ymJZddFQ tools/lib/file_stream.c
    1.13 +40e03332jWfB2viAhLSkq1WK0r_iDQ tools/lib/file_stream.h
    1.14 +40e03332rUjNMGg11n2rN6V4DCrvOg tools/lib/gzip_stream.c
    1.15 +40e033321O5Qg22haLoq5lpmk4tooQ tools/lib/gzip_stream.h
    1.16 +40e03332QrTR96tc6yS2rMBpd2mq1A tools/lib/hash_table.c
    1.17 +40e033325KoIb0d_uy8s7b5DUR9fPQ tools/lib/hash_table.h
    1.18 +40e03332ihnBGzHykVwZnFmkAppb4g tools/lib/iostream.c
    1.19 +40e03332UGwbLR4wsw4ft14p0Yw5pg tools/lib/iostream.h
    1.20 +40e0333245DLDzJemeSVBLuutHtzEQ tools/lib/kernel_stream.c
    1.21 +40e03332aK0GkgpDdc-PVTkWKTeOBg tools/lib/kernel_stream.h
    1.22 +40e03332HJ0cDcZDKDUUT-tEiBWOZw tools/lib/lexis.c
    1.23 +40e03332tnH9Ggzxbfi3xY9Vh2hUlg tools/lib/lexis.h
    1.24 +40e03332aYIW0BNBh6wXuKKn_P7Yyg tools/lib/lzi_stream.c
    1.25 +40e0333233voTffE4cJSMGJARfiSSQ tools/lib/lzi_stream.h
    1.26 +40e03332FXuMoUnfsAKSgV8X4rFbYQ tools/lib/lzo_stream.c
    1.27 +40e03332InJaiLfpDcIXBy2fI0RFGQ tools/lib/lzo_stream.h
    1.28 +40e03332a5SCuRsejHStTuWzMQNv8Q tools/lib/marshal.c
    1.29 +40e03332TwKyJrZQiiQfNq4vc2hpgw tools/lib/marshal.h
    1.30 +40e033328ccHlJuTR1FswYL_EC6LFA tools/lib/socket_stream.c
    1.31 +40e03332P0KVQGkmahj47aafo1X0nA tools/lib/socket_stream.h
    1.32 +40e03332KT_tnnoAMbPVAZBB7kSOAQ tools/lib/string_stream.c
    1.33 +40e03332-VtK6_OZa1vMHXFil8uq6w tools/lib/string_stream.h
    1.34 +40e03332dDtczi6YX7_mMxhYjJeAdQ tools/lib/sxpr.c
    1.35 +40e03332QPuyNKDOTIYVvkwK5qO-vg tools/lib/sxpr.h
    1.36 +40e03332Pi0_osJ3XPBi38ADPqdl4A tools/lib/sxpr_parser.c
    1.37 +40e033324v5QFMvWEXXzv38uUT9kHg tools/lib/sxpr_parser.h
    1.38 +40e03332gKUInsqtxQOV4mPiMqf_dg tools/lib/sys_ctype.h
    1.39 +40e03332Rkvq6nn_UNjzAAK_Tk9v1g tools/lib/sys_net.c
    1.40 +40e03332lQHvQHw4Rh7VsT1_sui29A tools/lib/sys_net.h
    1.41 +40e033321smklZd7bDSdWvQCeIshtg tools/lib/sys_string.c
    1.42 +40e03332h5V611rRWURRLqb1Ekatxg tools/lib/sys_string.h
    1.43 +40e03332u4q5kgF0N7RfqB4s0pZVew tools/lib/xdr.c
    1.44 +40e03332hY16nfRXF4gGd5S1aUJUBw tools/lib/xdr.h
    1.45  3f776bd2Xd-dUcPKlPN2vG89VGtfvQ tools/misc/Makefile
    1.46  40ab2cfawIw8tsYo0dQKtp83h4qfTQ tools/misc/fakei386xen
    1.47  3f6dc136ZKOjd8PIqLbFBl_v-rnkGg tools/misc/miniterm/Makefile
    1.48 @@ -185,6 +223,8 @@ 3fbba6dbEVkVMX0JuDFzap9jeaucGA tools/xc/
    1.49  3fbba6dbasJQV-MVElDC0DGSHMiL5w tools/xc/lib/xc_domain.c
    1.50  40278d99BLsfUv3qxv0I8C1sClZ0ow tools/xc/lib/xc_elf.h
    1.51  403e0977Bjsm_e82pwvl9VvaJxh8Gg tools/xc/lib/xc_evtchn.c
    1.52 +40e03333Eegw8czSWvHsbKxrRZJjRA tools/xc/lib/xc_io.c
    1.53 +40e03333vrWGbLAhyJjXlqCHaJt7eA tools/xc/lib/xc_io.h
    1.54  3fbba6dbNCU7U6nsMYiXzKkp3ztaJg tools/xc/lib/xc_linux_build.c
    1.55  3fbba6dbl267zZOAVHYLOdLCdhcZMw tools/xc/lib/xc_linux_restore.c
    1.56  3fbba6db7li3FJiABYtCmuGxOJxEGw tools/xc/lib/xc_linux_save.c

     2.1 --- a/BitKeeper/etc/ignore	Mon Jun 28 08:17:15 2004 +0000
     2.2 +++ b/BitKeeper/etc/ignore	Mon Jun 28 15:03:15 2004 +0000
     2.3 @@ -31,3 +31,21 @@ xen/tools/figlet/figlet
     2.4  xen/xen
     2.5  xen/xen-syms
     2.6  xen/xen.*
     2.7 +tools/xc/lib/.allocate.o.d
     2.8 +tools/xc/lib/.file_stream.o.d
     2.9 +tools/xc/lib/.gzip_stream.o.d
    2.10 +tools/xc/lib/.iostream.o.d
    2.11 +tools/xc/lib/.sys_net.o.d
    2.12 +tools/xc/lib/.sys_string.o.d
    2.13 +tools/xc/lib/.xc_atropos.o.d
    2.14 +tools/xc/lib/.xc_bvtsched.o.d
    2.15 +tools/xc/lib/.xc_domain.o.d
    2.16 +tools/xc/lib/.xc_evtchn.o.d
    2.17 +tools/xc/lib/.xc_io.o.d
    2.18 +tools/xc/lib/.xc_linux_build.o.d
    2.19 +tools/xc/lib/.xc_linux_restore.o.d
    2.20 +tools/xc/lib/.xc_linux_save.o.d
    2.21 +tools/xc/lib/.xc_misc.o.d
    2.22 +tools/xc/lib/.xc_netbsd_build.o.d
    2.23 +tools/xc/lib/.xc_physdev.o.d
    2.24 +tools/xc/lib/.xc_private.o.d

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/tools/lib/allocate.c	Mon Jun 28 15:03:15 2004 +0000
     3.3 @@ -0,0 +1,116 @@
     3.4 +/*
     3.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
     3.6 + *
     3.7 + * This library is free software; you can redistribute it and/or modify
     3.8 + * it under the terms of the GNU Lesser General Public License as published by
     3.9 + * the Free Software Foundation; either version 2.1 of the License, or
    3.10 + * (at your option) any later version.
    3.11 + *
    3.12 + * This library is distributed in the hope that it will be useful,
    3.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    3.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    3.15 + * GNU Lesser General Public License for more details.
    3.16 + *
    3.17 + * You should have received a copy of the GNU Lesser General Public License
    3.18 + * along with this library; if not, write to the Free Software
    3.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    3.20 + */
    3.21 +
    3.22 +#include "allocate.h"
    3.23 +
    3.24 +/** @file
    3.25 + * Support for allocating memory.
    3.26 + * Usable from user code or kernel code (with __KERNEL__ defined).
    3.27 + * In user code will use GC if USE_GC is defined.
    3.28 + */
    3.29 +
    3.30 +#ifdef __KERNEL__
    3.31 +/*----------------------------------------------------------------------------*/
    3.32 +#  include <linux/config.h>
    3.33 +#  include <linux/slab.h>
    3.34 +#  include <linux/string.h>
    3.35 +#  include <linux/types.h>
    3.36 +
    3.37 +#  define DEFAULT_TYPE    0
    3.38 +#  define MALLOC(n, type) kmalloc(n, type)
    3.39 +#  define FREE(ptr)       kfree(ptr)
    3.40 +
    3.41 +/*----------------------------------------------------------------------------*/
    3.42 +#else /* ! __KERNEL__ */
    3.43 +
    3.44 +#  include <stdlib.h>
    3.45 +#  include <string.h>
    3.46 +
    3.47 +#  define DEFAULT_TYPE    0
    3.48 +
    3.49 +#ifdef USE_GC
    3.50 +#  include "gc.h"
    3.51 +#  define MALLOC(n, typ)  GC_malloc(n)
    3.52 +#  define FREE(ptr)       (ptr=NULL)
    3.53 +//typedef void *GC_PTR;
    3.54 +//GC_PTR (*GC_oom_fn)(size_t n);
    3.55 +#else
    3.56 +#  define MALLOC(n, type) malloc(n)
    3.57 +#  define FREE(ptr)       free(ptr)
    3.58 +#endif
    3.59 +
    3.60 +/*----------------------------------------------------------------------------*/
    3.61 +#endif
    3.62 +
    3.63 +/** Function to call when memory cannot be allocated. */
    3.64 +AllocateFailedFn *allocate_failed_fn = NULL;
    3.65 +
    3.66 +/** Allocate memory and zero it.
    3.67 + * The type is only relevant when calling from kernel code,
    3.68 + * from user code it is ignored.
    3.69 + * In kernel code the values accepted by kmalloc can be used:
    3.70 + * GFP_USER, GFP_ATOMIC, GFP_KERNEL.
    3.71 + *
    3.72 + * @param size number of bytes to allocate
    3.73 + * @param type memory type to allocate (kernel only)
    3.74 + * @return pointer to the allocated memory or zero
    3.75 + * if malloc failed
    3.76 + */
    3.77 +void *allocate_type(int size, int type){
    3.78 +    void *p = MALLOC(size, type);
    3.79 +    if(p){
    3.80 +        memzero(p, size);
    3.81 +    } else if(allocate_failed_fn){
    3.82 +        allocate_failed_fn(size, type);
    3.83 +    }
    3.84 +    return p;
    3.85 +}
    3.86 +
    3.87 +/** Allocate memory and zero it.
    3.88 + *
    3.89 + * @param size number of bytes to allocate
    3.90 + * @return pointer to the allocated memory or zero
    3.91 + * if malloc failed
    3.92 + */
    3.93 +void *allocate(int size){
    3.94 +    return allocate_type(size, DEFAULT_TYPE);
    3.95 +}
    3.96 +
    3.97 +/** Free memory allocated by allocate().
    3.98 + * No-op if 'p' is null.
    3.99 + *
   3.100 + * @param p memory to free
   3.101 + */
   3.102 +void deallocate(void *p){
   3.103 +    if(p){
   3.104 +        FREE(p);
   3.105 +    }
   3.106 +}
   3.107 +
   3.108 +/** Set bytes to zero.
   3.109 + * No-op if 'p' is null.
   3.110 + *
   3.111 + * @param p memory to zero
   3.112 + * @param size number of bytes to zero
   3.113 + */
   3.114 +void memzero(void *p, int size){
   3.115 +    if(p){
   3.116 +        memset(p, 0, (size_t)size);
   3.117 +    }
   3.118 +}
   3.119 +

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/tools/lib/allocate.h	Mon Jun 28 15:03:15 2004 +0000
     4.3 @@ -0,0 +1,45 @@
     4.4 +/*
     4.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
     4.6 + *
     4.7 + * This library is free software; you can redistribute it and/or modify
     4.8 + * it under the terms of the GNU Lesser General Public License as published by
     4.9 + * the Free Software Foundation; either version 2.1 of the License, or
    4.10 + * (at your option) any later version.
    4.11 + *
    4.12 + * This library is distributed in the hope that it will be useful,
    4.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    4.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    4.15 + * GNU Lesser General Public License for more details.
    4.16 + *
    4.17 + * You should have received a copy of the GNU Lesser General Public License
    4.18 + * along with this library; if not, write to the Free Software
    4.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    4.20 + */
    4.21 +
    4.22 +#ifndef _XEN_LIB_ALLOCATE_H_
    4.23 +#define _XEN_LIB_ALLOCATE_H_
    4.24 +
    4.25 +/** Allocate memory for a given type, and cast. */
    4.26 +#define ALLOCATE(ctype) (ctype *)allocate(sizeof(ctype))
    4.27 +
    4.28 +/** Allocate memory for a given type, and cast. */
    4.29 +#define ALLOCATE_TYPE(ctype, type) (ctype *)allocate(sizeof(ctype))
    4.30 +
    4.31 +extern void *allocate_type(int size, int type);
    4.32 +extern void *allocate(int size);
    4.33 +extern void deallocate(void *);
    4.34 +extern void memzero(void *p, int size);
    4.35 +
    4.36 +typedef void AllocateFailedFn(int size, int type);
    4.37 +extern AllocateFailedFn *allocate_failed_fn;
    4.38 +
    4.39 +#endif /* _XEN_LIB_ALLOCATE_H_ */
    4.40 +
    4.41 +
    4.42 +
    4.43 +
    4.44 +
    4.45 +
    4.46 +
    4.47 +
    4.48 +

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/tools/lib/debug.h	Mon Jun 28 15:03:15 2004 +0000
     5.3 @@ -0,0 +1,72 @@
     5.4 +/*
     5.5 + * Copyright (C) 2004 Mike Wray <mike.wray@hp.com>
     5.6 + *
     5.7 + * This library is free software; you can redistribute it and/or modify
     5.8 + * it under the terms of the GNU Lesser General Public License as published by
     5.9 + * the Free Software Foundation; either version 2.1 of the License, or
    5.10 + * (at your option) any later version.
    5.11 + *
    5.12 + * This library is distributed in the hope that it will be useful,
    5.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    5.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    5.15 + * GNU Lesser General Public License for more details.
    5.16 + *
    5.17 + * You should have received a copy of the GNU Lesser General Public License
    5.18 + * along with this library; if not, write to the Free Software
    5.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    5.20 + */
    5.21 +#ifndef _XEN_LIB_DEBUG_H_
    5.22 +#define _XEN_LIB_DEBUG_H_
    5.23 +
    5.24 +#ifndef MODULE_NAME
    5.25 +#define MODULE_NAME ""
    5.26 +#endif
    5.27 +
    5.28 +#ifdef __KERNEL__
    5.29 +#include <linux/config.h>
    5.30 +#include <linux/kernel.h>
    5.31 +
    5.32 +#ifdef DEBUG
    5.33 +
    5.34 +#define dprintf(fmt, args...) printk(KERN_DEBUG   "[DBG] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.35 +#define wprintf(fmt, args...) printk(KERN_WARNING "[WRN] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.36 +#define iprintf(fmt, args...) printk(KERN_INFO    "[INF] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.37 +#define eprintf(fmt, args...) printk(KERN_ERR     "[ERR] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.38 +
    5.39 +#else
    5.40 +
    5.41 +#define dprintf(fmt, args...) do {} while(0)
    5.42 +#define wprintf(fmt, args...) printk(KERN_WARNING "[WRN] " MODULE_NAME fmt, ##args)
    5.43 +#define iprintf(fmt, args...) printk(KERN_INFO    "[INF] " MODULE_NAME fmt, ##args)
    5.44 +#define eprintf(fmt, args...) printk(KERN_ERR     "[ERR] " MODULE_NAME fmt, ##args)
    5.45 +
    5.46 +#endif
    5.47 +
    5.48 +#else
    5.49 +
    5.50 +#include <stdio.h>
    5.51 +
    5.52 +#ifdef DEBUG
    5.53 +
    5.54 +#define dprintf(fmt, args...) fprintf(stdout, "[DBG] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.55 +#define wprintf(fmt, args...) fprintf(stderr, "[WRN] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.56 +#define iprintf(fmt, args...) fprintf(stderr, "[INF] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.57 +#define eprintf(fmt, args...) fprintf(stderr, "[ERR] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    5.58 +
    5.59 +#else
    5.60 +
    5.61 +#define dprintf(fmt, args...) do {} while(0)
    5.62 +#define wprintf(fmt, args...) fprintf(stderr, "[WRN] " MODULE_NAME fmt, ##args)
    5.63 +#define iprintf(fmt, args...) fprintf(stderr, "[INF] " MODULE_NAME fmt, ##args)
    5.64 +#define eprintf(fmt, args...) fprintf(stderr, "[ERR] " MODULE_NAME fmt, ##args)
    5.65 +
    5.66 +#endif
    5.67 +
    5.68 +#endif
    5.69 +
    5.70 +/** Print format for an IP address.
    5.71 + * See NIPQUAD(), HIPQUAD()
    5.72 + */
    5.73 +#define IPFMT "%u.%u.%u.%u"
    5.74 +
    5.75 +#endif /* ! _XEN_LIB_DEBUG_H_ */

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/tools/lib/enum.c	Mon Jun 28 15:03:15 2004 +0000
     6.3 @@ -0,0 +1,61 @@
     6.4 +/*
     6.5 + * Copyright (C) 2002, 2004 Mike Wray <mike.wray@hp.com>
     6.6 + *
     6.7 + * This library is free software; you can redistribute it and/or modify
     6.8 + * it under the terms of the GNU Lesser General Public License as
     6.9 + * published by the Free Software Foundation; either version 2.1 of the
    6.10 + * License, or  (at your option) any later version. This library is 
    6.11 + * distributed in the  hope that it will be useful, but WITHOUT ANY
    6.12 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
    6.13 + * FITNESS FOR A PARTICULAR PURPOSE.
    6.14 + * See the GNU Lesser General Public License for more details.
    6.15 + *
    6.16 + * You should have received a copy of the GNU Lesser General Public License
    6.17 + * along with this library; if not, write to the Free Software Foundation,
    6.18 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    6.19 + */
    6.20 +
    6.21 +#ifdef __KERNEL__
    6.22 +#include <linux/errno.h>
    6.23 +#else
    6.24 +#include <errno.h>
    6.25 +#endif
    6.26 +
    6.27 +#include "sys_string.h"
    6.28 +#include "enum.h"
    6.29 +
    6.30 +/** Map an enum name to its value using a table.
    6.31 + *
    6.32 + * @param name enum name
    6.33 + * @param defs enum definitions
    6.34 + * @return enum value or -1 if not known
    6.35 + */
    6.36 +int enum_name_to_val(char *name, EnumDef *defs){
    6.37 +    int val = -1;
    6.38 +    for(; defs->name; defs++){
    6.39 +	if(!strcmp(defs->name, name)){
    6.40 +	    val = defs->val;
    6.41 +	    break;
    6.42 +	}
    6.43 +    }
    6.44 +    return val;
    6.45 +}
    6.46 +
    6.47 +/** Map an enum value to its name using a table.
    6.48 + *
    6.49 + * @param val enum value
    6.50 + * @param defs enum definitions
    6.51 + * @param defs_n number of definitions
    6.52 + * @return enum name or NULL if not known
    6.53 + */
    6.54 +char *enum_val_to_name(int val, EnumDef *defs){
    6.55 +    char *name = NULL;
    6.56 +    for(; defs->name; defs++){
    6.57 +	if(val == defs->val){
    6.58 +	    name = defs->name;
    6.59 +	    break;
    6.60 +	}
    6.61 +    }
    6.62 +    return name;
    6.63 +}
    6.64 +

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/tools/lib/enum.h	Mon Jun 28 15:03:15 2004 +0000
     7.3 @@ -0,0 +1,30 @@
     7.4 +/*
     7.5 + * Copyright (C) 2002, 2004 Mike Wray <mike.wray@hp.com>
     7.6 + *
     7.7 + * This library is free software; you can redistribute it and/or modify
     7.8 + * it under the terms of the GNU Lesser General Public License as
     7.9 + * published by the Free Software Foundation; either version 2.1 of the
    7.10 + * License, or  (at your option) any later version. This library is 
    7.11 + * distributed in the  hope that it will be useful, but WITHOUT ANY
    7.12 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
    7.13 + * FITNESS FOR A PARTICULAR PURPOSE.
    7.14 + * See the GNU Lesser General Public License for more details.
    7.15 + *
    7.16 + * You should have received a copy of the GNU Lesser General Public License
    7.17 + * along with this library; if not, write to the Free Software Foundation,
    7.18 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    7.19 + */
    7.20 +
    7.21 +#ifndef _XEN_LIB_ENUM_H_
    7.22 +#define _XEN_LIB_ENUM_H_
    7.23 +
    7.24 +/** Mapping of an enum value to a name. */
    7.25 +typedef struct EnumDef {
    7.26 +    int val;
    7.27 +    char *name;
    7.28 +} EnumDef;
    7.29 +
    7.30 +extern int enum_name_to_val(char *name, EnumDef *defs);
    7.31 +extern char *enum_val_to_name(int val, EnumDef *defs);
    7.32 +
    7.33 +#endif /* _XEN_LIB_ENUM_H_ */

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/tools/lib/file_stream.c	Mon Jun 28 15:03:15 2004 +0000
     8.3 @@ -0,0 +1,202 @@
     8.4 +/*
     8.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
     8.6 + *
     8.7 + * This library is free software; you can redistribute it and/or modify
     8.8 + * it under the terms of the GNU Lesser General Public License as published by
     8.9 + * the Free Software Foundation; either version 2.1 of the License, or
    8.10 + * (at your option) any later version.
    8.11 + *
    8.12 + * This library is distributed in the hope that it will be useful,
    8.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    8.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    8.15 + * GNU Lesser General Public License for more details.
    8.16 + *
    8.17 + * You should have received a copy of the GNU Lesser General Public License
    8.18 + * along with this library; if not, write to the Free Software
    8.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    8.20 + */
    8.21 +
    8.22 +/** @file
    8.23 + * An IOStream implementation using FILE*.
    8.24 + */
    8.25 +#ifndef __KERNEL__
    8.26 +#include <stdio.h>
    8.27 +#include <stdlib.h>
    8.28 +#include "allocate.h"
    8.29 +#include "file_stream.h"
    8.30 +
    8.31 +static int file_read(IOStream *s, void *buf, size_t n);
    8.32 +static int file_write(IOStream *s, const void *buf, size_t n);
    8.33 +static int file_error(IOStream *s);
    8.34 +static int file_close(IOStream *s);
    8.35 +static void file_free(IOStream *s);
    8.36 +static int file_flush(IOStream *s);
    8.37 +
    8.38 +/** Methods used by a FILE* IOStream. */
    8.39 +static const IOMethods file_methods = {
    8.40 +    read:  file_read,
    8.41 +    write: file_write,
    8.42 +    error: file_error,
    8.43 +    close: file_close,
    8.44 +    free:  file_free,
    8.45 +    flush: file_flush,
    8.46 +};
    8.47 +
    8.48 +/** IOStream for stdin. */
    8.49 +static IOStream _iostdin = {
    8.50 +    methods: &file_methods,
    8.51 +    data: (void*)1,
    8.52 +};
    8.53 +
    8.54 +/** IOStream for stdout. */
    8.55 +static IOStream _iostdout = {
    8.56 +    methods: &file_methods,
    8.57 +    data: (void*)2,
    8.58 +};
    8.59 +
    8.60 +/** IOStream for stderr. */
    8.61 +static IOStream _iostderr = {
    8.62 +    methods: &file_methods,
    8.63 +    data: (void*)3,
    8.64 +};
    8.65 +
    8.66 +/** IOStream for stdin. */
    8.67 +IOStream *iostdin = &_iostdin;
    8.68 +
    8.69 +/** IOStream for stdout. */
    8.70 +IOStream *iostdout = &_iostdout;
    8.71 +
    8.72 +/** IOStream for stderr. */
    8.73 +IOStream *iostderr = &_iostderr;
    8.74 +
    8.75 +/** Get the underlying FILE*.
    8.76 + * 
    8.77 + * @param s file stream
    8.78 + * @return the stream s wraps
    8.79 + */
    8.80 +static inline FILE *get_file(IOStream *s){
    8.81 +    switch((long)s->data){
    8.82 +    case 1: s->data = stdin; break;
    8.83 +    case 2: s->data = stdout; break;
    8.84 +    case 3: s->data = stderr; break;
    8.85 +    }
    8.86 +    return (FILE*)s->data;
    8.87 +}
    8.88 +
    8.89 +/** Control buffering on the underlying stream, like setvbuf().
    8.90 + *
    8.91 + * @param io file stream
    8.92 + * @param buf buffer
    8.93 + * @param mode buffering mode (see man setvbuf())
    8.94 + * @param size buffer size
    8.95 + * @return 0 on success, non-zero otherwise
    8.96 + */
    8.97 +int file_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size){
    8.98 +    return setvbuf(get_file(io), buf, mode, size);
    8.99 +}
   8.100 +
   8.101 +/** Write to the underlying stream using fwrite();
   8.102 + *
   8.103 + * @param stream input
   8.104 + * @param buf where to put input
   8.105 + * @param n number of bytes to write
   8.106 + * @return number of bytes written
   8.107 + */
   8.108 +static int file_write(IOStream *s, const void *buf, size_t n){
   8.109 +    return fwrite(buf, 1, n, get_file(s));
   8.110 +}
   8.111 +
   8.112 +/** Read from the underlying stream using fread();
   8.113 + *
   8.114 + * @param stream input
   8.115 + * @param buf where to put input
   8.116 + * @param n number of bytes to read
   8.117 + * @return number of bytes read
   8.118 + */
   8.119 +static int file_read(IOStream *s, void *buf, size_t n){
   8.120 +    return fread(buf, 1, n, get_file(s));
   8.121 +}
   8.122 +
   8.123 +/** Fush the underlying stream using fflush().
   8.124 + *
   8.125 + * @param s file stream
   8.126 + * @return 0 on success, error code otherwise
   8.127 + */
   8.128 +static int file_flush(IOStream *s){
   8.129 +    return fflush(get_file(s));
   8.130 +}
   8.131 +
   8.132 +/** Check if a stream has an error.
   8.133 + *
   8.134 + * @param s file stream
   8.135 + * @return 1 if has an error, 0 otherwise
   8.136 + */
   8.137 +static int file_error(IOStream *s){
   8.138 +    return ferror(get_file(s));
   8.139 +}
   8.140 +
   8.141 +/** Close a file stream.
   8.142 + *
   8.143 + * @param s file stream to close
   8.144 + * @return result of the close
   8.145 + */
   8.146 +static int file_close(IOStream *s){
   8.147 +    return fclose(get_file(s));
   8.148 +}
   8.149 +
   8.150 +/** Free a file stream.
   8.151 + *
   8.152 + * @param s file stream
   8.153 + */
   8.154 +static void file_free(IOStream *s){
   8.155 +    // Do nothing - fclose does it all?
   8.156 +}
   8.157 +
   8.158 +/** Create an IOStream for a stream.
   8.159 + *
   8.160 + * @param f stream to wrap
   8.161 + * @return new IOStream using f for i/o
   8.162 + */
   8.163 +IOStream *file_stream_new(FILE *f){
   8.164 +    IOStream *io = ALLOCATE(IOStream);
   8.165 +    if(io){
   8.166 +	io->methods = &file_methods;
   8.167 +	io->data = (void*)f;
   8.168 +    }
   8.169 +    return io;
   8.170 +}
   8.171 +
   8.172 +/** IOStream version of fopen().
   8.173 + *
   8.174 + * @param file name of the file to open
   8.175 + * @param flags giving the mode to open in (as for fopen())
   8.176 + * @return new stream for the open file, or 0 if failed
   8.177 + */
   8.178 +IOStream *file_stream_fopen(const char *file, const char *flags){
   8.179 +    IOStream *io = 0;
   8.180 +    FILE *fin = fopen(file, flags);
   8.181 +    if(fin){
   8.182 +	io = file_stream_new(fin);
   8.183 +	if(!io){
   8.184 +	    fclose(fin);
   8.185 +	    //free(fin); // fclose frees ?
   8.186 +	}
   8.187 +    }
   8.188 +    return io;
   8.189 +}
   8.190 +
   8.191 +/** IOStream version of fdopen().
   8.192 + *
   8.193 + * @param fd file descriptor
   8.194 + * @param flags giving the mode to open in (as for fdopen())
   8.195 + * @return new stream for the open file, or 0 if failed
   8.196 + */
   8.197 +IOStream *file_stream_fdopen(int fd, const char *flags){
   8.198 +    IOStream *io = 0;
   8.199 +    FILE *fin = fdopen(fd, flags);
   8.200 +    if(fin){
   8.201 +	io = file_stream_new(fin);
   8.202 +    }
   8.203 +    return io;
   8.204 +}
   8.205 +#endif

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/tools/lib/file_stream.h	Mon Jun 28 15:03:15 2004 +0000
     9.3 @@ -0,0 +1,35 @@
     9.4 +/*
     9.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
     9.6 + *
     9.7 + * This library is free software; you can redistribute it and/or modify
     9.8 + * it under the terms of the GNU Lesser General Public License as published by
     9.9 + * the Free Software Foundation; either version 2.1 of the License, or
    9.10 + * (at your option) any later version.
    9.11 + *
    9.12 + * This library is distributed in the hope that it will be useful,
    9.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9.15 + * GNU Lesser General Public License for more details.
    9.16 + *
    9.17 + * You should have received a copy of the GNU Lesser General Public License
    9.18 + * along with this library; if not, write to the Free Software
    9.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    9.20 + */
    9.21 +
    9.22 +#ifndef _XEN_LIB_FILE_STREAM_H_
    9.23 +#define _XEN_LIB_FILE_STREAM_H_
    9.24 +
    9.25 +#ifndef __KERNEL__
    9.26 +#include "iostream.h"
    9.27 +#include <stdio.h>
    9.28 +
    9.29 +extern IOStream *file_stream_new(FILE *f);
    9.30 +extern IOStream *file_stream_fopen(const char *file, const char *flags);
    9.31 +extern IOStream *file_stream_fdopen(int fd, const char *flags);
    9.32 +extern IOStream get_stream_stdout(void);
    9.33 +extern IOStream get_stream_stderr(void);
    9.34 +extern IOStream get_stream_stdin(void);
    9.35 +
    9.36 +extern int file_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size);
    9.37 +#endif
    9.38 +#endif /* !_XEN_LIB_FILE_STREAM_H_ */

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/tools/lib/gzip_stream.c	Mon Jun 28 15:03:15 2004 +0000
    10.3 @@ -0,0 +1,185 @@
    10.4 +/* $Id: gzip_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $ */
    10.5 +/*
    10.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    10.7 + *
    10.8 + * This library is free software; you can redistribute it and/or modify
    10.9 + * it under the terms of the GNU Lesser General Public License as published by
   10.10 + * the Free Software Foundation; either version 2.1 of the License, or
   10.11 + * (at your option) any later version.
   10.12 + *
   10.13 + * This library is distributed in the hope that it will be useful,
   10.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.16 + * GNU Lesser General Public License for more details.
   10.17 + *
   10.18 + * You should have received a copy of the GNU Lesser General Public License
   10.19 + * along with this library; if not, write to the Free Software
   10.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   10.21 + */
   10.22 +
   10.23 +/** @file
   10.24 + * An IOStream implementation using zlib gzFile to provide
   10.25 + * compression and decompression.
   10.26 + */
   10.27 +#ifndef __KERNEL__
   10.28 +
   10.29 +#include <stdio.h>
   10.30 +#include <stdlib.h>
   10.31 +
   10.32 +#include "zlib.h"
   10.33 +
   10.34 +extern FILE* gzfile(gzFile file);
   10.35 +
   10.36 +#include "allocate.h"
   10.37 +#include "gzip_stream.h"
   10.38 +
   10.39 +static int gzip_read(IOStream *s, void *buf, size_t n);
   10.40 +static int gzip_write(IOStream *s, const void *buf, size_t n);
   10.41 +static int gzip_error(IOStream *s);
   10.42 +static int gzip_close(IOStream *s);
   10.43 +static void gzip_free(IOStream *s);
   10.44 +static int gzip_flush(IOStream *s);
   10.45 +
   10.46 +/** Methods used by a gzFile* IOStream. */
   10.47 +static const IOMethods gzip_methods = {
   10.48 +    read: gzip_read,
   10.49 +    write: gzip_write,
   10.50 +    error: gzip_error,
   10.51 +    close: gzip_close,
   10.52 +    free:  gzip_free,
   10.53 +    flush: gzip_flush,
   10.54 +};
   10.55 +
   10.56 +/** Get the underlying gzFile*.
   10.57 + * 
   10.58 + * @param s gzip stream
   10.59 + * @return the stream s wraps
   10.60 + */
   10.61 +static inline gzFile get_gzfile(IOStream *s){
   10.62 +    return (gzFile)s->data;
   10.63 +}
   10.64 +
   10.65 +/** Control buffering on the underlying stream, like setvbuf().
   10.66 + *
   10.67 + * @param io gzip stream
   10.68 + * @param buf buffer
   10.69 + * @param mode buffering mode (see man setvbuf())
   10.70 + * @param size buffer size
   10.71 + * @return 0 on success, non-zero otherwise
   10.72 + */
   10.73 +int gzip_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size){
   10.74 +    return setvbuf(gzfile(get_gzfile(io)), buf, mode, size);
   10.75 +}
   10.76 +
   10.77 +/** Write to the underlying stream.
   10.78 + *
   10.79 + * @param stream destination
   10.80 + * @param buf data
   10.81 + * @param n number of bytes to write
   10.82 + * @return number of bytes written
   10.83 + */
   10.84 +static int gzip_write(IOStream *s, const void *buf, size_t n){
   10.85 +    return gzwrite(get_gzfile(s), (void*)buf, n);
   10.86 +}
   10.87 +
   10.88 +/** Read from the underlying stream.
   10.89 + *
   10.90 + * @param stream input
   10.91 + * @param buf where to put input
   10.92 + * @param n number of bytes to read
   10.93 + * @return number of bytes read
   10.94 + */
   10.95 +static int gzip_read(IOStream *s, void *buf, size_t n){
   10.96 +    return gzread(get_gzfile(s), buf, n);
   10.97 +}
   10.98 +
   10.99 +/** Flush the underlying stream.
  10.100 + *
  10.101 + * @param s gzip stream
  10.102 + * @return 0 on success, error code otherwise
  10.103 + */
  10.104 +static int gzip_flush(IOStream *s){
  10.105 +    //return gzflush(get_gzfile(s), Z_NO_FLUSH);
  10.106 +    return gzflush(get_gzfile(s), Z_SYNC_FLUSH);
  10.107 +    //return gzflush(get_gzfile(s), Z_FULL_FLUSH);
  10.108 +}
  10.109 +
  10.110 +/** Check if a stream has an error.
  10.111 + *
  10.112 + * @param s gzip stream
  10.113 + * @return 1 if has an error, 0 otherwise
  10.114 + */
  10.115 +static int gzip_error(IOStream *s){
  10.116 +    int err;
  10.117 +    gzFile *gz = get_gzfile(s);
  10.118 +    gzerror(gz, &err);
  10.119 +    return (err == Z_ERRNO ? ferror(gzfile(gz)) : err);
  10.120 +}
  10.121 +
  10.122 +/** Close a gzip stream.
  10.123 + *
  10.124 + * @param s gzip stream to close
  10.125 + * @return result of the close
  10.126 + */
  10.127 +static int gzip_close(IOStream *s){
  10.128 +    return gzclose(get_gzfile(s));
  10.129 +}
  10.130 +
  10.131 +/** Free a gzip stream.
  10.132 + *
  10.133 + * @param s gzip stream
  10.134 + */
  10.135 +static void gzip_free(IOStream *s){
  10.136 +    // Do nothing - fclose does it all?
  10.137 +}
  10.138 +
  10.139 +/** Create an IOStream for a gzip stream.
  10.140 + *
  10.141 + * @param f stream to wrap
  10.142 + * @return new IOStream using f for i/o
  10.143 + */
  10.144 +IOStream *gzip_stream_new(gzFile *f){
  10.145 +    IOStream *io = ALLOCATE(IOStream);
  10.146 +    if(io){
  10.147 +	io->methods = &gzip_methods;
  10.148 +	io->data = (void*)f;
  10.149 +    }
  10.150 +    return io;
  10.151 +}
  10.152 +
  10.153 +/** IOStream version of fopen().
  10.154 + *
  10.155 + * @param file name of the file to open
  10.156 + * @param flags giving the mode to open in (as for fopen())
  10.157 + * @return new stream for the open file, or NULL if failed
  10.158 + */
  10.159 +IOStream *gzip_stream_fopen(const char *file, const char *flags){
  10.160 +    IOStream *io = NULL;
  10.161 +    gzFile *fgz;
  10.162 +    fgz = gzopen(file, flags);
  10.163 +    if(fgz){
  10.164 +	io = gzip_stream_new(fgz);
  10.165 +	if(!io){
  10.166 +	    gzclose(fgz);
  10.167 +	    //free(fgz); // gzclose frees ?
  10.168 +	}
  10.169 +    }
  10.170 +    return io;
  10.171 +}
  10.172 +
  10.173 +/** IOStream version of fdopen().
  10.174 + *
  10.175 + * @param fd file descriptor
  10.176 + * @param flags giving the mode to open in (as for fdopen())
  10.177 + * @return new stream for the open file, or NULL if failed
  10.178 + */
  10.179 +IOStream *gzip_stream_fdopen(int fd, const char *flags){
  10.180 +    IOStream *io = NULL;
  10.181 +    gzFile *fgz;
  10.182 +    fgz = gzdopen(fd, flags);
  10.183 +    if(fgz){
  10.184 +	io = gzip_stream_new(fgz);
  10.185 +    }
  10.186 +    return io;
  10.187 +}
  10.188 +#endif

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/tools/lib/gzip_stream.h	Mon Jun 28 15:03:15 2004 +0000
    11.3 @@ -0,0 +1,33 @@
    11.4 +#/* $Id: gzip_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    11.5 +/*
    11.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    11.7 + *
    11.8 + * This library is free software; you can redistribute it and/or modify
    11.9 + * it under the terms of the GNU Lesser General Public License as published by
   11.10 + * the Free Software Foundation; either version 2.1 of the License, or
   11.11 + * (at your option) any later version.
   11.12 + *
   11.13 + * This library is distributed in the hope that it will be useful,
   11.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   11.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   11.16 + * GNU Lesser General Public License for more details.
   11.17 + *
   11.18 + * You should have received a copy of the GNU Lesser General Public License
   11.19 + * along with this library; if not, write to the Free Software
   11.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   11.21 + */
   11.22 +
   11.23 +#ifndef _SP_GZIP_STREAM_H_
   11.24 +#define _SP_GZIP_STREAM_H_
   11.25 +
   11.26 +#ifndef __KERNEL__
   11.27 +#include "iostream.h"
   11.28 +#include "zlib.h"
   11.29 +
   11.30 +extern IOStream *gzip_stream_new(gzFile *f);
   11.31 +extern IOStream *gzip_stream_fopen(const char *file, const char *flags);
   11.32 +extern IOStream *gzip_stream_fdopen(int fd, const char *flags);
   11.33 +
   11.34 +extern int gzip_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size);
   11.35 +#endif
   11.36 +#endif /* !_SP_FILE_STREAM_H_ */

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/tools/lib/hash_table.c	Mon Jun 28 15:03:15 2004 +0000
    12.3 @@ -0,0 +1,640 @@
    12.4 +/*
    12.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    12.6 + *
    12.7 + * This library is free software; you can redistribute it and/or modify
    12.8 + * it under the terms of the GNU Lesser General Public License as published by
    12.9 + * the Free Software Foundation; either version 2.1 of the License, or
   12.10 + * (at your option) any later version.
   12.11 + *
   12.12 + * This library is distributed in the hope that it will be useful,
   12.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.15 + * GNU Lesser General Public License for more details.
   12.16 + *
   12.17 + * You should have received a copy of the GNU Lesser General Public License
   12.18 + * along with this library; if not, write to the Free Software
   12.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   12.20 + */
   12.21 +
   12.22 +#ifdef __KERNEL__
   12.23 +#  include <linux/config.h>
   12.24 +#  include <linux/module.h>
   12.25 +#  include <linux/kernel.h>
   12.26 +#  include <linux/errno.h>
   12.27 +#else
   12.28 +#  include <errno.h>
   12.29 +#  include <stddef.h>
   12.30 +#endif
   12.31 +
   12.32 +//#include <limits.h>
   12.33 +
   12.34 +#include "allocate.h"
   12.35 +#include "hash_table.h"
   12.36 +
   12.37 +/** @file
   12.38 + * Base support for hashtables.
   12.39 + *
   12.40 + * Hash codes are reduced modulo the number of buckets to index tables,
   12.41 + * so there is no need for hash functions to limit the range of hashcodes.
   12.42 + * In fact it is assumed that hashcodes do not change when the number of
   12.43 + * buckets in the table changes.
   12.44 + */
   12.45 +
   12.46 +/*==========================================================================*/
   12.47 +/** Number of bits in half a word. */
   12.48 +//#if __WORDSIZE == 64
   12.49 +//#define HALF_WORD_BITS 32
   12.50 +//#else
   12.51 +#define HALF_WORD_BITS 16
   12.52 +//#endif
   12.53 +
   12.54 +/** Mask for lo half of a word. On 32-bit this is 
   12.55 + * (1<<16) - 1 = 65535 = 0xffff
   12.56 + * It's 4294967295 = 0xffffffff on 64-bit.
   12.57 + */
   12.58 +#define LO_HALF_MASK ((1 << HALF_WORD_BITS) - 1)
   12.59 +
   12.60 +/** Get the lo half of a word. */
   12.61 +#define LO_HALF(x) ((x) & LO_HALF_MASK)
   12.62 +
   12.63 +/** Get the hi half of a word. */
   12.64 +#define HI_HALF(x) ((x) >> HALF_WORD_BITS)
   12.65 +
   12.66 +/** Do a full hash on both inputs, using DES-style non-linear scrambling.
   12.67 + * Both inputs are replaced with the results of the hash.
   12.68 + *
   12.69 + * @param pleft input/output word
   12.70 + * @param pright input/output word
   12.71 + */
   12.72 +void pseudo_des(unsigned long *pleft, unsigned long *pright){
   12.73 +    // Bit-rich mixing constant.
   12.74 +    static const unsigned long a_mixer[] = {
   12.75 +        0xbaa96887L, 0x1e17d32cL, 0x03bcdc3cL, 0x0f33d1b2L, };
   12.76 +
   12.77 +    // Bit-rich mixing constant.
   12.78 +    static const unsigned long b_mixer[] = {
   12.79 +        0x4b0f3b58L, 0xe874f0c3L, 0x6955c5a6L, 0x55a7ca46L, };
   12.80 +
   12.81 +    // Number of iterations - must be 2 or 4.
   12.82 +    static const int ncycle = 4;
   12.83 +    //static const int ncycle = 2;
   12.84 +
   12.85 +    unsigned long left = *pleft, right = *pright;
   12.86 +    unsigned long v, v_hi, v_lo;
   12.87 +    int i;
   12.88 +
   12.89 +    for(i=0; i<ncycle; i++){
   12.90 +        // Flip some bits in right to get v.
   12.91 +        v = right;
   12.92 +        v ^= a_mixer[i];
   12.93 +        // Get lo and hi halves of v.
   12.94 +        v_lo = LO_HALF(v);
   12.95 +        v_hi = HI_HALF(v);
   12.96 +        // Non-linear mix of the halves of v.
   12.97 +        v = ((v_lo * v_lo) + ~(v_hi * v_hi));
   12.98 +        // Swap the halves of v.
   12.99 +        v = (HI_HALF(v) | (LO_HALF(v) << HALF_WORD_BITS));
  12.100 +        // Flip some bits.
  12.101 +        v ^= b_mixer[i];
  12.102 +        // More non-linear mixing.
  12.103 +        v += (v_lo * v_hi);
  12.104 +        v ^= left;
  12.105 +        left = right;
  12.106 +        right = v;
  12.107 +    }
  12.108 +    *pleft = left;
  12.109 +    *pright = right;
  12.110 +}
  12.111 +
  12.112 +/** Hash a string.
  12.113 + *
  12.114 + * @param s input to hash
  12.115 + * @return hashcode
  12.116 + */
  12.117 +Hashcode hash_string(char *s){
  12.118 +    Hashcode h = 0;
  12.119 +    if(s){
  12.120 +        for( ; *s; s++){
  12.121 +            h = hash_2ul(h, *s);
  12.122 +        }
  12.123 +    }
  12.124 +    return h;
  12.125 +}
  12.126 +
  12.127 +/** Get the bucket for a hashcode in a hash table.
  12.128 + *
  12.129 + * @param table to get bucket from
  12.130 + * @param hashcode to get bucket for
  12.131 + * @return bucket
  12.132 + */
  12.133 +inline HTBucket * get_bucket(HashTable *table, Hashcode hashcode){
  12.134 +    return table->buckets + (hashcode % table->buckets_n);
  12.135 +}
  12.136 +
  12.137 +/** Initialize a hash table.
  12.138 + * Can be safely called more than once.
  12.139 + *
  12.140 + * @param table to initialize
  12.141 + */
  12.142 +void HashTable_init(HashTable *table){
  12.143 +    int i;
  12.144 +
  12.145 +    if(!table->init_done){
  12.146 +        table->init_done = 1;
  12.147 +        table->next_id = 0;
  12.148 +        for(i=0; i<table->buckets_n; i++){
  12.149 +            HTBucket *bucket = get_bucket(table, i);
  12.150 +            bucket->head = 0;
  12.151 +            bucket->count = 0;
  12.152 +        }
  12.153 +        table->entry_count = 0;
  12.154 +    }
  12.155 +}
  12.156 +
  12.157 +/** Allocate a new hashtable.
  12.158 + * If the number of buckets is not positive the default is used.
  12.159 + * The number of buckets should usually be prime.
  12.160 + *
  12.161 + * @param buckets_n number of buckets
  12.162 + * @return new hashtable or null
  12.163 + */
  12.164 +HashTable *HashTable_new(int buckets_n){
  12.165 +    HashTable *z = ALLOCATE(HashTable);
  12.166 +    if(!z) goto exit;
  12.167 +    if(buckets_n <= 0){
  12.168 +        buckets_n = HT_BUCKETS_N;
  12.169 +    }
  12.170 +    z->buckets = (HTBucket*)allocate(buckets_n * sizeof(HTBucket));
  12.171 +    if(!z->buckets){
  12.172 +        deallocate(z);
  12.173 +        z = 0;
  12.174 +        goto exit;
  12.175 +    }
  12.176 +    z->buckets_n = buckets_n;
  12.177 +    HashTable_init(z);
  12.178 +  exit:
  12.179 +    return z;
  12.180 +}
  12.181 +
  12.182 +/** Free a hashtable.
  12.183 + * Any entries are removed and freed.
  12.184 + *
  12.185 + * @param h hashtable (ignored if null)
  12.186 + */
  12.187 +void HashTable_free(HashTable *h){
  12.188 +    if(h){
  12.189 +        HashTable_clear(h);
  12.190 +        deallocate(h->buckets);
  12.191 +        deallocate(h);
  12.192 +    }
  12.193 +}
  12.194 +
  12.195 +/** Push an entry on the list in the bucket for a given hashcode.
  12.196 + *
  12.197 + * @param table to add entry to
  12.198 + * @param hashcode for the entry
  12.199 + * @param entry to add
  12.200 + */
  12.201 +static inline void push_on_bucket(HashTable *table, Hashcode hashcode,
  12.202 +				  HTEntry *entry){
  12.203 +    HTBucket *bucket;
  12.204 +    HTEntry *old_head;
  12.205 +
  12.206 +    bucket = get_bucket(table, hashcode);
  12.207 +    old_head = bucket->head;
  12.208 +    bucket->count++;
  12.209 +    bucket->head = entry;
  12.210 +    entry->next = old_head;
  12.211 +}
  12.212 +
  12.213 +/** Change the number of buckets in a hashtable.
  12.214 + * No-op if the number of buckets is not positive.
  12.215 + * Existing entries are reallocated to buckets based on their hashcodes.
  12.216 + * The table is unmodified if the number of buckets cannot be changed.
  12.217 + *
  12.218 + * @param table hashtable
  12.219 + * @param buckets_n new number of buckets
  12.220 + * @return 0 on success, error code otherwise
  12.221 + */
  12.222 +int HashTable_set_buckets_n(HashTable *table, int buckets_n){
  12.223 +    int err = 0;
  12.224 +    HTBucket *old_buckets = table->buckets;
  12.225 +    int old_buckets_n = table->buckets_n;
  12.226 +    int i;
  12.227 +
  12.228 +    if(buckets_n <= 0){
  12.229 +        err = -EINVAL;
  12.230 +        goto exit;
  12.231 +    }
  12.232 +    table->buckets = (HTBucket*)allocate(buckets_n * sizeof(HTBucket));
  12.233 +    if(!table->buckets){
  12.234 +        err = -ENOMEM;
  12.235 +        table->buckets = old_buckets;
  12.236 +        goto exit;
  12.237 +    }
  12.238 +    table->buckets_n = buckets_n;
  12.239 +    for(i=0; i<old_buckets_n; i++){
  12.240 +        HTBucket *bucket = old_buckets + i;
  12.241 +        HTEntry *entry, *next;
  12.242 +        for(entry = bucket->head; entry; entry = next){
  12.243 +            next = entry->next;
  12.244 +            push_on_bucket(table, entry->hashcode, entry);
  12.245 +        }
  12.246 +    }
  12.247 +    deallocate(old_buckets);
  12.248 +  exit:
  12.249 +    return err;
  12.250 +}
  12.251 +
  12.252 +/** Adjust the number of buckets so the table is neither too full nor too empty.
  12.253 + * The table is unmodified if adjusting fails.
  12.254 + *
  12.255 + * @param table hash table
  12.256 + * @param buckets_min minimum number of buckets (use default if 0 or negative)
  12.257 + * @return 0 on success, error code otherwise
  12.258 + */
  12.259 +int HashTable_adjust(HashTable *table, int buckets_min){
  12.260 +    int buckets_n = 0;
  12.261 +    int err = 0;
  12.262 +    if(buckets_min <= 0) buckets_min = HT_BUCKETS_N;
  12.263 +    if(table->entry_count >= table->buckets_n){
  12.264 +        // The table is dense - expand it.
  12.265 +        buckets_n = 2 * table->buckets_n;
  12.266 +    } else if((table->buckets_n > buckets_min) &&
  12.267 +              (4 * table->entry_count < table->buckets_n)){
  12.268 +        // The table is more than minimum size and sparse - shrink it.
  12.269 +        buckets_n = 2 * table->entry_count;
  12.270 +        if(buckets_n < buckets_min) buckets_n = buckets_min;
  12.271 +    }
  12.272 +    if(buckets_n){
  12.273 +        err = HashTable_set_buckets_n(table, buckets_n);
  12.274 +    }
  12.275 +    return err;
  12.276 +}
  12.277 +
  12.278 +/** Allocate a new entry for a given value.
  12.279 + *
  12.280 + * @param value to put in the entry
  12.281 + * @return entry, or 0 on failure
  12.282 + */
  12.283 +HTEntry * HTEntry_new(Hashcode hashcode, void *key, void *value){
  12.284 +    HTEntry *z = ALLOCATE(HTEntry);
  12.285 +    if(z){
  12.286 +        z->hashcode = hashcode;
  12.287 +        z->key = key;
  12.288 +        z->value = value;
  12.289 +    }
  12.290 +    return z;
  12.291 +}
  12.292 +
  12.293 +/** Free an entry.
  12.294 + *
  12.295 + * @param z entry to free
  12.296 + */
  12.297 +inline void HTEntry_free(HTEntry *z){
  12.298 +    if(z){
  12.299 +        deallocate(z);
  12.300 +    }
  12.301 +}
  12.302 +
  12.303 +/** Free an entry in a hashtable.
  12.304 + * The table's entry_free_fn is used is defined, otherwise 
  12.305 + * the HTEntry itself is freed.
  12.306 + *
  12.307 + * @param table hashtable
  12.308 + * @param entry to free
  12.309 + */
  12.310 +inline void HashTable_free_entry(HashTable *table, HTEntry *entry){
  12.311 +    if(!entry)return;
  12.312 +    if(table && table->entry_free_fn){
  12.313 +        table->entry_free_fn(table, entry);
  12.314 +    } else {
  12.315 +        HTEntry_free(entry);
  12.316 +    }
  12.317 +}
  12.318 +
  12.319 +/** Get the first entry satisfying a test from the bucket for the
  12.320 + * given hashcode.
  12.321 + *
  12.322 + * @param table to look in
  12.323 + * @param hashcode indicates the bucket
  12.324 + * @param test_fn test to apply to elements
  12.325 + * @param arg first argument to calls to test_fn
  12.326 + * @return entry found, or 0
  12.327 + */
  12.328 +inline HTEntry * HashTable_find_entry(HashTable *table, Hashcode hashcode,
  12.329 +				      TableTestFn *test_fn, TableArg arg){
  12.330 +    HTBucket *bucket;
  12.331 +    HTEntry *entry = 0;
  12.332 +    HTEntry *next;
  12.333 +
  12.334 +    bucket = get_bucket(table, hashcode);
  12.335 +    for(entry = bucket->head; entry; entry = next){
  12.336 +        next = entry->next;
  12.337 +        if(test_fn(arg, table, entry)){
  12.338 +            break;
  12.339 +        }
  12.340 +    }
  12.341 +    return entry;
  12.342 +}
  12.343 +
  12.344 +/** Test hashtable keys for equality.
  12.345 + * Uses the table's key_equal_fn if defined, otherwise pointer equality.
  12.346 + *
  12.347 + * @param key1 key to compare
  12.348 + * @param key2 key to compare
  12.349 + * @return 1 if equal, 0 otherwise
  12.350 + */
  12.351 +inline int HashTable_key_equal(HashTable *table, void *key1, void *key2){
  12.352 +    return (table->key_equal_fn ? table->key_equal_fn(key1, key2) : key1==key2);
  12.353 +}
  12.354 +
  12.355 +/** Compute the hashcode of a hashtable key.
  12.356 + * The table's key_hash_fn is used if defined, otherwise the address of
  12.357 + * the key is hashed.
  12.358 + *
  12.359 + * @param table hashtable
  12.360 + * @param key to hash
  12.361 + * @return hashcode
  12.362 + */
  12.363 +inline Hashcode HashTable_key_hash(HashTable *table, void *key){
  12.364 +    return (table->key_hash_fn ? table->key_hash_fn(key) : hash_ul((unsigned long)key));
  12.365 +}
  12.366 +
  12.367 +/** Test if an entry has a given key.
  12.368 + *
  12.369 + * @param arg containing key to test for
  12.370 + * @param table the entry is in
  12.371 + * @param entry to test
  12.372 + * @return 1 if the entry has the key, 0 otherwise
  12.373 + */
  12.374 +static inline int has_key(TableArg arg, HashTable *table, HTEntry *entry){
  12.375 +    return HashTable_key_equal(table, arg.ptr, entry->key);
  12.376 +}
  12.377 +
  12.378 +/** Get an entry with a given key.
  12.379 + *
  12.380 + * @param table to search
  12.381 + * @param key to look for
  12.382 + * @return entry if found, null otherwise
  12.383 + */
  12.384 +#if 0
  12.385 +inline HTEntry * HashTable_get_entry(HashTable *table, void *key){
  12.386 +    TableArg arg = { ptr: key };
  12.387 +    return HashTable_find_entry(table, HashTable_key_hash(table, key), has_key, arg);
  12.388 +}
  12.389 +#else
  12.390 +inline HTEntry * HashTable_get_entry(HashTable *table, void *key){
  12.391 +    Hashcode hashcode;
  12.392 +    HTBucket *bucket;
  12.393 +    HTEntry *entry = 0;
  12.394 +    HTEntry *next;
  12.395 +
  12.396 +    hashcode = HashTable_key_hash(table, key);
  12.397 +    bucket = get_bucket(table, hashcode);
  12.398 +    for(entry = bucket->head; entry; entry = next){
  12.399 +        next = entry->next;
  12.400 +        if(HashTable_key_equal(table, key, entry->key)){
  12.401 +            break;
  12.402 +        }
  12.403 +    }
  12.404 +    return entry;
  12.405 +}
  12.406 +#endif
  12.407 +
  12.408 +/** Get the value of an entry with a given key.
  12.409 + *
  12.410 + * @param table to search
  12.411 + * @param key to look for
  12.412 + * @return value if an entry was found, null otherwise
  12.413 + */
  12.414 +inline void * HashTable_get(HashTable *table, void *key){
  12.415 +    HTEntry *entry = HashTable_get_entry(table, key);
  12.416 +    return (entry ? entry->value : 0);
  12.417 +}
  12.418 +
  12.419 +/** Print the buckets in a table.
  12.420 + *
  12.421 + * @param table to print
  12.422 + */
  12.423 +void show_buckets(HashTable *table, IOStream *io){
  12.424 +    int i,j ;
  12.425 +    IOStream_print(io, "entry_count=%d buckets_n=%d\n", table->entry_count, table->buckets_n);
  12.426 +    for(i=0; i<table->buckets_n; i++){
  12.427 +        if(0 || table->buckets[i].count>0){
  12.428 +            IOStream_print(io, "bucket %3d %3d %10p ", i,
  12.429 +                        table->buckets[i].count,
  12.430 +                        table->buckets[i].head);
  12.431 +            for(j = table->buckets[i].count; j>0; j--){
  12.432 +                IOStream_print(io, "+");
  12.433 +            }
  12.434 +            IOStream_print(io, "\n");
  12.435 +        }
  12.436 +    }
  12.437 +    HashTable_print(table, io); 
  12.438 +}
  12.439 +    
  12.440 +/** Print an entry in a table.
  12.441 + *
  12.442 + * @param entry to print
  12.443 + * @param arg a pointer to an IOStream to print to
  12.444 + * @return 0
  12.445 + */
  12.446 +static int print_entry(TableArg arg, HashTable *table, HTEntry *entry){
  12.447 +    IOStream *io = (IOStream*)arg.ptr;
  12.448 +    IOStream_print(io, " b=%4lx h=%08lx i=%08lx |-> e=%8p k=%8p v=%8p\n",
  12.449 +                entry->hashcode % table->buckets_n,
  12.450 +                entry->hashcode,
  12.451 +                entry->index,
  12.452 +                entry, entry->key, entry->value);
  12.453 +    return 0;
  12.454 +}
  12.455 +
  12.456 +/** Print a hash table.
  12.457 + *
  12.458 + * @param table to print
  12.459 + */
  12.460 +void HashTable_print(HashTable *table, IOStream *io){
  12.461 +    IOStream_print(io, "{\n");
  12.462 +    HashTable_map(table, print_entry, (TableArg){ ptr: io });
  12.463 +    IOStream_print(io, "}\n");
  12.464 +}
  12.465 +/*==========================================================================*/
  12.466 +
  12.467 +/** Get the next entry id to use for a table.
  12.468 + *
  12.469 + * @param table hash table
  12.470 + * @return non-zero entry id
  12.471 + */
  12.472 +static inline unsigned long get_next_id(HashTable *table){
  12.473 +    unsigned long id;
  12.474 +
  12.475 +    if(table->next_id == 0){
  12.476 +        table->next_id = 1;
  12.477 +    }
  12.478 +    id = table->next_id++;
  12.479 +    return id;
  12.480 +}
  12.481 +
  12.482 +/** Add an entry to the bucket for the
  12.483 + * given hashcode.
  12.484 + *
  12.485 + * @param table to insert in
  12.486 + * @param hashcode indicates the bucket
  12.487 + * @param key to add an entry for
  12.488 + * @param value to add an entry for
  12.489 + * @return entry on success, 0 on failure
  12.490 + */
  12.491 +inline HTEntry * HashTable_add_entry(HashTable *table, Hashcode hashcode, void *key, void *value){
  12.492 +    HTEntry *entry = HTEntry_new(hashcode, key, value);
  12.493 +    if(entry){
  12.494 +        entry->index = get_next_id(table);
  12.495 +        push_on_bucket(table, hashcode, entry);
  12.496 +        table->entry_count++;
  12.497 +    }
  12.498 +    return entry;
  12.499 +}
  12.500 +
  12.501 +/** Move the front entry for a bucket to the correct point in the bucket order as
  12.502 + * defined by the order function. If this is called every time a new entry is added
  12.503 + * the bucket will be maintained in sorted order.
  12.504 + *
  12.505 + * @param table to modify
  12.506 + * @param hashcode indicates the bucket
  12.507 + * @param order entry comparison function
  12.508 + * @return 0 if an entry was moved, 1 if not
  12.509 + */
  12.510 +int HashTable_order_bucket(HashTable *table, Hashcode hashcode, TableOrderFn *order){
  12.511 +    HTEntry *new_entry = NULL, *prev = NULL, *entry = NULL;
  12.512 +    HTBucket *bucket;
  12.513 +    int err = 1;
  12.514 +
  12.515 +    bucket = get_bucket(table, hashcode);
  12.516 +    new_entry = bucket->head;
  12.517 +    if(!new_entry || !new_entry->next) goto exit;
  12.518 +    for(entry = new_entry->next; entry; prev = entry, entry = entry->next){
  12.519 +        if(order(new_entry, entry) <= 0) break;
  12.520 +    }
  12.521 +    if(prev){
  12.522 +        err = 0;
  12.523 +        bucket->head = new_entry->next; 
  12.524 +        new_entry->next = entry;
  12.525 +        prev->next = new_entry;
  12.526 +    }
  12.527 +  exit:
  12.528 +    return err;
  12.529 +}
  12.530 +
  12.531 +/** Add an entry to a hashtable.
  12.532 + * The entry is added to the bucket for its key's hashcode.
  12.533 + *
  12.534 + * @param table to insert in
  12.535 + * @param key to add an entry for
  12.536 + * @param value to add an entry for
  12.537 + * @return entry on success, 0 on failure
  12.538 + */
  12.539 +inline HTEntry * HashTable_add(HashTable *table, void *key, void *value){
  12.540 +    return HashTable_add_entry(table, HashTable_key_hash(table, key), key, value);
  12.541 +}
  12.542 +
  12.543 +
  12.544 +/** Remove entries satisfying a test from the bucket for the
  12.545 + * given hashcode. 
  12.546 + *
  12.547 + * @param table to remove from
  12.548 + * @param hashcode indicates the bucket
  12.549 + * @param test_fn test to apply to elements
  12.550 + * @param arg first argument to calls to test_fn
  12.551 + * @return number of entries removed
  12.552 + */
  12.553 +inline int HashTable_remove_entry(HashTable *table, Hashcode hashcode,
  12.554 +				  TableTestFn *test_fn, TableArg arg){
  12.555 +    HTBucket *bucket;
  12.556 +    HTEntry *entry, *prev = 0, *next;
  12.557 +    int removed_count = 0;
  12.558 +
  12.559 +    bucket = get_bucket(table, hashcode);
  12.560 +    for(entry = bucket->head; entry; entry = next){
  12.561 +        next = entry->next;
  12.562 +        if(test_fn(arg, table, entry)){
  12.563 +            if(prev){
  12.564 +                prev->next = next;
  12.565 +            } else {
  12.566 +                bucket->head = next;
  12.567 +            }
  12.568 +            bucket->count--;
  12.569 +            table->entry_count--;
  12.570 +            removed_count++;
  12.571 +            HashTable_free_entry(table, entry);
  12.572 +            entry = 0;
  12.573 +        }
  12.574 +        prev = entry;
  12.575 +    }
  12.576 +    return removed_count;
  12.577 +}
  12.578 +
  12.579 +/** Remove entries with a given key. 
  12.580 + *
  12.581 + * @param table to remove from
  12.582 + * @param key of entries to remove
  12.583 + * @return number of entries removed
  12.584 + */
  12.585 +inline int HashTable_remove(HashTable *table, void *key){
  12.586 +#if 1
  12.587 +    Hashcode hashcode;
  12.588 +    HTBucket *bucket;
  12.589 +    HTEntry *entry, *prev = 0, *next;
  12.590 +    int removed_count = 0;
  12.591 +
  12.592 +    hashcode = HashTable_key_hash(table, key);
  12.593 +    bucket = get_bucket(table, hashcode);
  12.594 +    for(entry = bucket->head; entry; entry = next){
  12.595 +        next = entry->next;
  12.596 +        if(HashTable_key_equal(table, key, entry->key)){
  12.597 +            if(prev){
  12.598 +                prev->next = next;
  12.599 +            } else {
  12.600 +                bucket->head = next;
  12.601 +            }
  12.602 +            bucket->count--;
  12.603 +            table->entry_count--;
  12.604 +            removed_count++;
  12.605 +            HashTable_free_entry(table, entry);
  12.606 +            entry = 0;
  12.607 +        }
  12.608 +        prev = entry;
  12.609 +    }
  12.610 +    return removed_count;
  12.611 +#else
  12.612 +    return HashTable_remove_entry(table, HashTable_key_hash(table, key),
  12.613 +				  has_key, (TableArg){ ptr: key});
  12.614 +#endif
  12.615 +}
  12.616 +
  12.617 +/** Remove (and free) all the entries in a bucket.
  12.618 + *
  12.619 + * @param bucket to clear
  12.620 + */
  12.621 +static inline void bucket_clear(HashTable *table, HTBucket *bucket){
  12.622 +    HTEntry *entry, *next;
  12.623 +
  12.624 +    for(entry = bucket->head; entry; entry = next){
  12.625 +        next = entry->next;
  12.626 +        HashTable_free_entry(table, entry);
  12.627 +    }
  12.628 +    bucket->head = 0;
  12.629 +    table->entry_count -= bucket->count;
  12.630 +    bucket->count = 0;
  12.631 +}
  12.632 +
  12.633 +/** Remove (and free) all the entries in a table.
  12.634 + *
  12.635 + * @param table to clear
  12.636 + */
  12.637 +void HashTable_clear(HashTable *table){
  12.638 +    int i, n = table->buckets_n;
  12.639 +
  12.640 +    for(i=0; i<n; i++){
  12.641 +        bucket_clear(table, table->buckets + i);
  12.642 +    }
  12.643 +}

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/tools/lib/hash_table.h	Mon Jun 28 15:03:15 2004 +0000
    13.3 @@ -0,0 +1,295 @@
    13.4 +/* $Id: hash_table.h,v 1.1 2004/03/30 16:21:26 mjw Exp $ */
    13.5 +/*
    13.6 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    13.7 + *
    13.8 + * This library is free software; you can redistribute it and/or modify
    13.9 + * it under the terms of the GNU Lesser General Public License as published by
   13.10 + * the Free Software Foundation; either version 2.1 of the License, or
   13.11 + * (at your option) any later version.
   13.12 + *
   13.13 + * This library is distributed in the hope that it will be useful,
   13.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   13.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13.16 + * GNU Lesser General Public License for more details.
   13.17 + *
   13.18 + * You should have received a copy of the GNU Lesser General Public License
   13.19 + * along with this library; if not, write to the Free Software
   13.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   13.21 + */
   13.22 +
   13.23 +#ifndef _XEN_LIB_HASH_TABLE_H_
   13.24 +#define _XEN_LIB_HASH_TABLE_H_
   13.25 +
   13.26 +#include "iostream.h"
   13.27 +
   13.28 +typedef unsigned long Hashcode;
   13.29 +
   13.30 +/** Type used to pass parameters to table functions. */
   13.31 +typedef union TableArg {
   13.32 +    unsigned long ul;
   13.33 +    void *ptr;
   13.34 +} TableArg;
   13.35 +
   13.36 +/** An entry in a bucket list. */
   13.37 +typedef struct HTEntry {
   13.38 +    /** Hashcode of the entry's key. */
   13.39 +    Hashcode hashcode;
   13.40 +    /** Identifier for this entry in the table. */
   13.41 +    int index;
   13.42 +    /** The key for this entry. */
   13.43 +    void *key;
   13.44 +    /** The value in this entry. */
   13.45 +    void *value;
   13.46 +    /** The next entry in the list. */
   13.47 +    struct HTEntry *next;
   13.48 +} HTEntry;
   13.49 +
   13.50 +/** A bucket in a rule table. */
   13.51 +typedef struct HTBucket {
   13.52 +    /** Number of entries in the bucket. */
   13.53 +    int count;
   13.54 +    /** First entry in the bucket (may be null). */
   13.55 +    HTEntry *head;
   13.56 +} HTBucket;
   13.57 +
   13.58 +/** Default number of buckets in a hash table.
   13.59 + * You want enough buckets so the lists in the buckets will typically be short.
   13.60 + * It's a good idea if this is prime, since that will help to spread hashcodes
   13.61 + * around the table.
   13.62 + */
   13.63 +//#define HT_BUCKETS_N 1
   13.64 +//#define HT_BUCKETS_N 3
   13.65 +//#define HT_BUCKETS_N 7
   13.66 +//#define HT_BUCKETS_N 17
   13.67 +//#define HT_BUCKETS_N 97
   13.68 +//#define HT_BUCKETS_N 211
   13.69 +//#define HT_BUCKETS_N 401
   13.70 +#define HT_BUCKETS_N 1021
   13.71 +
   13.72 +typedef struct HashTable HashTable;
   13.73 +
   13.74 +/** Type for a function used to select table entries. */
   13.75 +typedef int TableTestFn(TableArg arg, HashTable *table, HTEntry *entry);
   13.76 +
   13.77 +/** Type for a function to map over table entries. */
   13.78 +typedef int TableMapFn(TableArg arg, HashTable *table, HTEntry *entry);
   13.79 +
   13.80 +/** Type for a function to free table entries. */
   13.81 +typedef void TableFreeFn(HashTable *table, HTEntry *entry);
   13.82 +
   13.83 +/** Type for a function to hash table keys. */
   13.84 +typedef Hashcode TableHashFn(void *key);
   13.85 +
   13.86 +/** Type for a function to test table keys for equality. */
   13.87 +typedef int TableEqualFn(void *key1, void *key2);
   13.88 +
   13.89 +/** Type for a function to order table entries. */
   13.90 +typedef int TableOrderFn(HTEntry *e1, HTEntry *e2);
   13.91 +
   13.92 +/** General hash table.
   13.93 + * A hash table with a list in each bucket.
   13.94 + * Functions can be supplied for freeing entries, hashing keys, and comparing keys.
   13.95 + * These all default to 0, when default behaviour treating keys as integers is used.
   13.96 + */
   13.97 +struct HashTable {
   13.98 +    /** Flag indicating whether the table has been initialised. */
   13.99 +    int init_done;
  13.100 +    /** Next value for the id field in inserted rules. */
  13.101 +    unsigned long next_id;
  13.102 +    /** Number of buckets in the bucket array. */
  13.103 +    int buckets_n;
  13.104 +    /** Array of buckets, each with its own list. */
  13.105 +    HTBucket *buckets;
  13.106 +    /** Number of entries in the table. */
  13.107 +    int entry_count;
  13.108 +    /** Function to free keys and values in entries. */
  13.109 +    TableFreeFn *entry_free_fn;
  13.110 +    /** Function to hash keys. */
  13.111 +    TableHashFn *key_hash_fn;
  13.112 +    /** Function to compare keys for equality. */
  13.113 +    TableEqualFn *key_equal_fn;
  13.114 +    /** Place for the user of the table to hang extra data. */
  13.115 +    void *user_data;
  13.116 +};
  13.117 +
  13.118 +extern HashTable *HashTable_new(int bucket_n);
  13.119 +extern void HashTable_free(HashTable *table);
  13.120 +extern HTEntry * HTEntry_new(Hashcode hashcode, void *key, void *value);
  13.121 +extern void HTEntry_free(HTEntry *entry);
  13.122 +extern int HashTable_set_bucket_n(HashTable *table, int bucket_n);
  13.123 +extern void HashTable_clear(HashTable *table);
  13.124 +extern HTEntry * HashTable_add_entry(HashTable *table, Hashcode hashcode, void *key, void *value);
  13.125 +extern HTEntry * HashTable_get_entry(HashTable *table, void *key);
  13.126 +extern HTEntry * HashTable_add(HashTable *table, void *key, void *value);
  13.127 +extern void * HashTable_get(HashTable *table, void *key);
  13.128 +extern int HashTable_remove(HashTable *table, void *key);
  13.129 +extern HTEntry * HashTable_find_entry(HashTable *table, Hashcode hashcode,
  13.130 +                                      TableTestFn *test_fn, TableArg arg);
  13.131 +extern int HashTable_remove_entry(HashTable *table, Hashcode hashcode,
  13.132 +                                   TableTestFn *test_fn, TableArg arg);
  13.133 +//extern int HashTable_map(HashTable *table, TableMapFn *map_fn, TableArg arg);
  13.134 +extern void HashTable_print(HashTable *table, IOStream *out);
  13.135 +extern int HashTable_set_buckets_n(HashTable *table, int buckets_n);
  13.136 +extern int HashTable_adjust(HashTable *table, int buckets_min);
  13.137 +extern void pseudo_des(unsigned long *pleft, unsigned long *pright);
  13.138 +extern Hashcode hash_string(char *s);
  13.139 +
  13.140 +extern int HashTable_order_bucket(HashTable *table, Hashcode hashcode, TableOrderFn *order);
  13.141 +
  13.142 +/** Control whether to use hashing based on DES or simple
  13.143 + * hashing. DES hashing is `more random' but much more expensive.
  13.144 + */
  13.145 +#define HASH_PSEUDO_DES 0
  13.146 +
  13.147 +/** Hash a long using a quick and dirty linear congruential random number generator.
  13.148 + *  See `Numerical Recipes in C', Chapter 7, "An Even Quicker Generator".
  13.149 + *
  13.150 + * @param a value to hash
  13.151 + * @return hashed input
  13.152 + */
  13.153 +static inline unsigned long lcrng_hash(unsigned long a){
  13.154 +    return (1664525L * a + 1013904223L);
  13.155 +}
  13.156 +
  13.157 +/** Hash an unsigned long.
  13.158 + *
  13.159 + * @param a input to hash
  13.160 + * @return hashcode
  13.161 + */
  13.162 +static inline Hashcode hash_ul(unsigned long a){
  13.163 +#if HASH_PSEUDO_DES
  13.164 +    unsigned long left = a;
  13.165 +    unsigned long right = 0L;
  13.166 +    pseudo_des(&left, &right);
  13.167 +    return right;
  13.168 +#else
  13.169 +    a = lcrng_hash(a);
  13.170 +    a = lcrng_hash(a);
  13.171 +    return a;
  13.172 +#endif
  13.173 +}
  13.174 +
  13.175 +/** Hash two unsigned longs together.
  13.176 + *
  13.177 + * @param a input to hash
  13.178 + * @param b input to hash
  13.179 + * @return hashcode
  13.180 + */
  13.181 +static inline Hashcode hash_2ul(unsigned long a, unsigned long b){
  13.182 +#if HASH_PSEUDO_DES
  13.183 +    unsigned long left = a;
  13.184 +    unsigned long right = b;
  13.185 +    pseudo_des(&left, &right);
  13.186 +    return right;
  13.187 +#else
  13.188 +    a = lcrng_hash(a);
  13.189 +    a ^= b;
  13.190 +    a = lcrng_hash(a);
  13.191 +    return a;
  13.192 +#endif
  13.193 +}
  13.194 +
  13.195 +/** Hash a hashcode and an unsigned long together.
  13.196 + *
  13.197 + * @param a input hashcode
  13.198 + * @param b input to hash
  13.199 + * @return hashcode
  13.200 + */
  13.201 +static inline Hashcode hash_hul(Hashcode a, unsigned long b){
  13.202 +#if HASH_PSEUDO_DES
  13.203 +    unsigned long left = a;
  13.204 +    unsigned long right = b;
  13.205 +    pseudo_des(&left, &right);
  13.206 +    return right;
  13.207 +#else
  13.208 +    a ^= b;
  13.209 +    a = lcrng_hash(a);
  13.210 +    return a;
  13.211 +#endif
  13.212 +}
  13.213 +
  13.214 +/** Macro to declare variables for HashTable_for_each() to use.
  13.215 + *
  13.216 + * @param entry variable that is set to entries in the table
  13.217 + */
  13.218 +#define HashTable_for_decl(entry) \
  13.219 +  HashTable *_var_table; \
  13.220 +  HTBucket *_var_bucket; \
  13.221 +  HTBucket *_var_end; \
  13.222 +  HTEntry *_var_next; \
  13.223 +  HTEntry *entry
  13.224 +
  13.225 +/** Macro to iterate over the entries in a hashtable.
  13.226 + * Must be in a scope where HashTable_for_decl() has been used to declare
  13.227 + * variables for it to use.
  13.228 + * The variable 'entry' is iterated over entries in the table.
  13.229 + * The code produced is syntactically a loop, so it must be followed by
  13.230 + * a loop body, typically some statements in braces:
  13.231 + * HashTable_for_each(entry, table){ ...loop body... }
  13.232 + *
  13.233 + * HashTable_for_each() and HashTable_for_decl() cannot be used for nested
  13.234 + * loops as variables will clash.
  13.235 + *
  13.236 + * @note The simplest way to code a direct loop over the entries in a hashtable
  13.237 + * is to use a loop over the buckets, with a nested loop over the entries
  13.238 + * in a bucket. Using this approach in a macro means the macro contains
  13.239 + * an opening brace, and calls to it must be followed by 2 braces!
  13.240 + * To avoid this the code has been restructured so that it is a for loop.
  13.241 + * So that statements could be used in the test expression of the for loop,
  13.242 + * we have used the gcc statement expression extension ({ ... }).
  13.243 + *
  13.244 + * @param entry variable to iterate over the entries
  13.245 + * @param table to iterate over (non-null)
  13.246 + */
  13.247 +#define HashTable_for_each(entry, table) \
  13.248 +  _var_table = table; \
  13.249 +  _var_bucket = _var_table->buckets; \
  13.250 +  _var_end = _var_bucket + _var_table->buckets_n; \
  13.251 +  for(entry=0, _var_next=0; \
  13.252 +      ({ if(_var_next){ \
  13.253 +             entry = _var_next; \
  13.254 +             _var_next = entry->next; \
  13.255 +          } else { \
  13.256 +             while(_var_bucket < _var_end){ \
  13.257 +                 entry = _var_bucket->head; \
  13.258 +                 _var_bucket++; \
  13.259 +                 if(entry){ \
  13.260 +                      _var_next = entry->next; \
  13.261 +                      break; \
  13.262 +                 } \
  13.263 +             } \
  13.264 +          }; \
  13.265 +         entry; }); \
  13.266 +      entry = _var_next )
  13.267 +
  13.268 +/** Map a function over the entries in a table.
  13.269 + * Mapping stops when the function returns a non-zero value.
  13.270 + * Uses the gcc statement expression extension ({ ... }).
  13.271 + *
  13.272 + * @param table to map over
  13.273 + * @param fn function to apply to entries
  13.274 + * @param arg first argument to call the function with
  13.275 + * @return 0 if fn always returned 0, first non-zero value otherwise
  13.276 + */
  13.277 +#define HashTable_map(table, fn, arg) \
  13.278 +  ({ HashTable_for_decl(_var_entry); \
  13.279 +    TableArg _var_arg = arg; \
  13.280 +    int _var_value = 0; \
  13.281 +    HashTable_for_each(_var_entry, table){ \
  13.282 +        if((_var_value = fn(_var_arg, _var_table, _var_entry))) break; \
  13.283 +    } \
  13.284 +    _var_value; })
  13.285 +
  13.286 +/** Cast x to the type for a key or value in a hash table.
  13.287 + * This avoids compiler warnings when using short integers
  13.288 + * as keys or values (especially on 64-bit platforms).
  13.289 + */
  13.290 +#define HKEY(x) ((void*)(unsigned long)(x))
  13.291 +
  13.292 +/** Cast x from the type for a key or value in a hash table.
  13.293 + * to an unsigned long. This avoids compiler warnings when using
  13.294 + * short integers as keys or values (especially on 64-bit platforms).
  13.295 + */
  13.296 +#define HVAL(x) ((unsigned long)(x))
  13.297 +
  13.298 +#endif /* !_XEN_LIB_HASH_TABLE_H_ */

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/tools/lib/iostream.c	Mon Jun 28 15:03:15 2004 +0000
    14.3 @@ -0,0 +1,37 @@
    14.4 +#include "iostream.h"
    14.5 +#include "sys_string.h"
    14.6 +
    14.7 +/** Print on a stream, like vfprintf().
    14.8 + *
    14.9 + * @param stream to print to
   14.10 + * @param format for the print (as fprintf())
   14.11 + * @param args arguments to print
   14.12 + * @return result code from the print
   14.13 + */
   14.14 +int IOStream_vprint(IOStream *stream, const char *format, va_list args){
   14.15 +  char buffer[1024];
   14.16 +  int k = sizeof(buffer), n;
   14.17 +
   14.18 +  n = vsnprintf(buffer, k, (char*)format, args);
   14.19 +  if(n < 0 || n > k ){
   14.20 +      n = k;
   14.21 +  }
   14.22 +  n = IOStream_write(stream, buffer, n);
   14.23 +  return n;
   14.24 +}
   14.25 +
   14.26 +/** Print on a stream, like fprintf().
   14.27 + *
   14.28 + * @param stream to print to
   14.29 + * @param format for the print (as fprintf())
   14.30 + * @return result code from the print
   14.31 + */
   14.32 +int IOStream_print(IOStream *stream, const char *format, ...){
   14.33 +  va_list args;
   14.34 +  int result = -1;
   14.35 +
   14.36 +  va_start(args, format);
   14.37 +  result = IOStream_vprint(stream, format, args);
   14.38 +  va_end(args);
   14.39 +  return result;
   14.40 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/tools/lib/iostream.h	Mon Jun 28 15:03:15 2004 +0000
    15.3 @@ -0,0 +1,243 @@
    15.4 +#ifndef _XC_LINUX_SAVE_H_
    15.5 +#define _XC_LINUX_SAVE_H_
    15.6 +
    15.7 +#include <stdarg.h>
    15.8 +#include <stdint.h>
    15.9 +#include <stddef.h>
   15.10 +
   15.11 +#ifdef __KERNEL__
   15.12 +#include <linux/errno.h>
   15.13 +#else
   15.14 +#include <errno.h>
   15.15 +#endif
   15.16 +
   15.17 +#include "allocate.h"
   15.18 +
   15.19 +/** End of input return value. */
   15.20 +#define IOSTREAM_EOF -1
   15.21 +
   15.22 +/** An input/output abstraction.
   15.23 + */
   15.24 +typedef struct IOStream IOStream;
   15.25 +
   15.26 +/** Record of the functions to use for operations on an
   15.27 + * IOStream implementation.
   15.28 + */
   15.29 +typedef struct IOMethods {
   15.30 +    /** Read function.  Called with the user data, buffer to read into
   15.31 +     * and number of bytes to read.  Must return number of bytes read
   15.32 +     * on success, less than zero on error.
   15.33 +     */
   15.34 +    int (*read)(IOStream *stream, void *buf, size_t n);
   15.35 +
   15.36 +    /** Write function. Called with user data, buffer to write and
   15.37 +     * number of bytes to write. Must return number of bytes written on
   15.38 +     * success, less than zero otherwise.
   15.39 +     */
   15.40 +    int (*write)(IOStream *stream, const void *buf, size_t n);
   15.41 +
   15.42 +    int (*flush)(IOStream *s);
   15.43 +
   15.44 +    int (*error)(IOStream *s);
   15.45 +
   15.46 +    int (*close)(IOStream *s);
   15.47 +
   15.48 +    void (*free)(IOStream *s);
   15.49 +
   15.50 +    void (*lock)(IOStream *s);
   15.51 +    void (*unlock)(IOStream *s);
   15.52 +
   15.53 +} IOMethods;
   15.54 +
   15.55 +/** Abstract i/o object.
   15.56 + */
   15.57 +struct IOStream {
   15.58 +    /** Methods to use to implement operations. */
   15.59 +    const IOMethods *methods;
   15.60 +    /** Private state for the implementation. */
   15.61 +    const void *data;
   15.62 +    /** Flag indicating whether the stream is closed. */
   15.63 +    int closed;
   15.64 +    /** Number of bytes written. */
   15.65 +    int written;
   15.66 +    /** Number of bytes read. */
   15.67 +    int read;
   15.68 +};
   15.69 +
   15.70 +
   15.71 +/** IOStream version of stdin. */
   15.72 +extern IOStream *iostdin;
   15.73 +
   15.74 +/** IOStream version of stdout, */
   15.75 +extern IOStream *iostdout;
   15.76 +
   15.77 +/** IOStream version of stderr. */
   15.78 +extern IOStream *iostderr;
   15.79 +
   15.80 +extern int IOStream_print(IOStream *io, const char *format, ...);
   15.81 +extern int IOStream_vprint(IOStream *io, const char *format, va_list args);
   15.82 +
   15.83 +/** Read from a stream.
   15.84 + *
   15.85 + * @param stream input
   15.86 + * @param buf where to put input
   15.87 + * @param n number of bytes to read
   15.88 + * @return if ok, number of bytes read, otherwise negative error code
   15.89 + */
   15.90 +static inline int IOStream_read(IOStream *stream, void *buf, size_t n){
   15.91 +    int result = 0;
   15.92 +    if(stream->closed) goto exit;
   15.93 +    if(!stream->methods || !stream->methods->read){
   15.94 +        result = -EINVAL;
   15.95 +        goto exit;
   15.96 +    }
   15.97 +    result = stream->methods->read(stream, buf, n);
   15.98 +    if(result > 0){
   15.99 +        stream->read += result;
  15.100 +    }
  15.101 +  exit:
  15.102 +    return result;
  15.103 +}
  15.104 +
  15.105 +/** Write to a stream.
  15.106 + *
  15.107 + * @param stream input
  15.108 + * @param buf where to put input
  15.109 + * @param n number of bytes to write
  15.110 + * @return if ok, number of bytes read, otherwise negative error code
  15.111 + */
  15.112 +static inline int IOStream_write(IOStream *stream, const void *buf, size_t n){
  15.113 +    int result = 0;
  15.114 +    if(stream->closed) goto exit;
  15.115 +    if(!stream->methods || !stream->methods->write){
  15.116 +        result = -EINVAL;
  15.117 +        goto exit;
  15.118 +    }
  15.119 +    result = stream->methods->write(stream, buf, n);
  15.120 +    if(result > 0){
  15.121 +        stream->written += result;
  15.122 +    }
  15.123 +  exit:
  15.124 +    return result;
  15.125 +}
  15.126 +
  15.127 +/** Flush the stream.
  15.128 + *
  15.129 + * @param stream stream
  15.130 + * @return 0 on success, IOSTREAM_EOF otherwise
  15.131 + */
  15.132 +static inline int IOStream_flush(IOStream *stream){
  15.133 +    int result = 0;
  15.134 +    if(stream->closed){
  15.135 +        result = IOSTREAM_EOF;
  15.136 +    } else if(stream->methods->flush){
  15.137 +        result = stream->methods->flush(stream);
  15.138 +        if(result < 0) result = IOSTREAM_EOF;
  15.139 +    }
  15.140 +    return result;
  15.141 +}
  15.142 +
  15.143 +/** Check whether the stream has an error.
  15.144 + *
  15.145 + * @param stream to check
  15.146 + * @return 1 for error, 0 otherwise
  15.147 + */
  15.148 +static inline int IOStream_error(IOStream *stream){
  15.149 +    int err = 0;
  15.150 +    if(stream->methods && stream->methods->error){
  15.151 +       err = stream->methods->error(stream);
  15.152 +    }
  15.153 +    return err;
  15.154 +}
  15.155 +
  15.156 +/** Close the stream.
  15.157 + *
  15.158 + * @param stream to close
  15.159 + * @return 1 for error, 0 otherwise
  15.160 + */
  15.161 +static inline int IOStream_close(IOStream *stream){
  15.162 +    int err = 1;
  15.163 +    if(stream->methods && stream->methods->close){
  15.164 +        err = stream->methods->close(stream);
  15.165 +    }
  15.166 +    return err;
  15.167 +}
  15.168 +
  15.169 +/** Test if the stream has been closed.
  15.170 + *
  15.171 + * @param stream to check
  15.172 + * @return 1 if closed, 0 otherwise
  15.173 + */
  15.174 +static inline int IOStream_is_closed(IOStream *stream){
  15.175 +  return stream->closed;
  15.176 +}
  15.177 +
  15.178 +/** Free the memory used by the stream.
  15.179 + *
  15.180 + * @param stream to free
  15.181 + */
  15.182 +static inline void IOStream_free(IOStream *stream){
  15.183 +  if(stream->methods && stream->methods->free){
  15.184 +    stream->methods->free(stream);
  15.185 +  }
  15.186 +  *stream = (IOStream){};
  15.187 +  deallocate(stream);
  15.188 +}
  15.189 +
  15.190 +
  15.191 +/** Print a character to a stream, like fputc().
  15.192 + *
  15.193 + * @param stream to print to
  15.194 + * @param c character to print
  15.195 + * @return result code from the print
  15.196 + */
  15.197 +static inline int IOStream_putc(IOStream *stream, int c){
  15.198 +    int err;
  15.199 +    unsigned char b = (unsigned char)c;
  15.200 +    err = IOStream_write(stream, &b, 1);
  15.201 +    if(err < 1){
  15.202 +        err = IOSTREAM_EOF;
  15.203 +    } else {
  15.204 +        err = b;
  15.205 +    }
  15.206 +    return err;
  15.207 +}
  15.208 +
  15.209 +/** Read from a stream, like fgetc().
  15.210 + *
  15.211 + * @param stream to read from
  15.212 + * @return IOSTREAM_EOF on error, character read otherwise
  15.213 + */
  15.214 +static inline int IOStream_getc(IOStream *stream){
  15.215 +    int err, rc;
  15.216 +    unsigned char b;
  15.217 +
  15.218 +    err = IOStream_read(stream, &b, 1);
  15.219 +    if(err < 1){
  15.220 +        rc = IOSTREAM_EOF;
  15.221 +    } else {
  15.222 +        rc = b;
  15.223 +    }
  15.224 +    return rc;
  15.225 +}
  15.226 +
  15.227 +/** Get number of bytes read.
  15.228 + *
  15.229 + * @param stream to get from
  15.230 + * @return number of bytes read
  15.231 + */
  15.232 +static inline int IOStream_get_read(IOStream *stream){
  15.233 +    return stream->read;
  15.234 +}
  15.235 +
  15.236 +/** Get number of bytes written.
  15.237 + *
  15.238 + * @param stream to get from
  15.239 + * @return number of bytes written
  15.240 + */
  15.241 +static inline int IOStream_get_written(IOStream *stream){
  15.242 +    return stream->written;
  15.243 +}
  15.244 +
  15.245 +
  15.246 +#endif /* ! _XC_LINUX_SAVE_H_ */

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/tools/lib/kernel_stream.c	Mon Jun 28 15:03:15 2004 +0000
    16.3 @@ -0,0 +1,177 @@
    16.4 +/*
    16.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    16.6 + *
    16.7 + * This library is free software; you can redistribute it and/or modify
    16.8 + * it under the terms of the GNU Lesser General Public License as published by
    16.9 + * the Free Software Foundation; either version 2.1 of the License, or
   16.10 + * (at your option) any later version.
   16.11 + *
   16.12 + * This library is distributed in the hope that it will be useful,
   16.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   16.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16.15 + * GNU Lesser General Public License for more details.
   16.16 + *
   16.17 + * You should have received a copy of the GNU Lesser General Public License
   16.18 + * along with this library; if not, write to the Free Software
   16.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   16.20 + */
   16.21 +
   16.22 +/** @file
   16.23 + * An IOStream implementation using printk() for output.
   16.24 + * Input is not implemented.
   16.25 + */
   16.26 +#ifdef __KERNEL__
   16.27 +
   16.28 +#include <linux/config.h>
   16.29 +#include <linux/module.h>
   16.30 +#include <linux/kernel.h>
   16.31 +#include <linux/types.h>
   16.32 +#include <linux/errno.h>
   16.33 +#include <linux/slab.h>
   16.34 +#include <linux/spinlock.h>
   16.35 +
   16.36 +#include "kernel_stream.h"
   16.37 +#include "allocate.h"
   16.38 +
   16.39 +/** Number of characters in the output buffer.
   16.40 + * The kernel uses 1024 for printk, so that should suffice.
   16.41 + */
   16.42 +#define BUF_N 1024
   16.43 +
   16.44 +/** State for a kernel stream. */
   16.45 +typedef struct KernelData {
   16.46 +    /** Stream lock. We need a lock to serialize access to the stream. */
   16.47 +    spinlock_t lock;
   16.48 +    /** Saved flags for locking. */
   16.49 +    unsigned long flags;
   16.50 +    /** Size of the output buffer. */
   16.51 +    int buf_n;
   16.52 +    /** Output buffer. */
   16.53 +    char buf[BUF_N];
   16.54 +} KernelData;
   16.55 +
   16.56 +static int kernel_write(IOStream *s, const char *msg, int n);
   16.57 +static void kernel_free(IOStream *s);
   16.58 +static void kernel_stream_lock(IOStream *s);
   16.59 +static void kernel_stream_unlock(IOStream *s);
   16.60 +
   16.61 +/** Methods for a kernel stream. Output only. */
   16.62 +static const IOMethods kernel_methods = {
   16.63 +  write:  kernel_write,
   16.64 +  free:   kernel_free,
   16.65 +  lock:   kernel_stream_lock,
   16.66 +  unlock: kernel_stream_unlock,
   16.67 +};
   16.68 +
   16.69 +/** Shared state for kernel streams.
   16.70 + * All implementations write using printk, so we can use
   16.71 + * shared state and avoid allocating it.
   16.72 + */
   16.73 +static const KernelData kernel_data = {
   16.74 +  lock: SPIN_LOCK_UNLOCKED,
   16.75 +  flags: 0,
   16.76 +  buf_n: BUF_N,
   16.77 +};
   16.78 +
   16.79 +/** Stream for kernel printk. */
   16.80 +static IOStream iokernel = {
   16.81 +    methods: &kernel_methods,
   16.82 +    data:    &kernel_data,
   16.83 +};
   16.84 +
   16.85 +/** Stream for kernel printk. */
   16.86 +IOStream *iostdout = &iokernel;
   16.87 +
   16.88 +/** Stream for kernel printk. */
   16.89 +IOStream *iostdin = &iokernel;
   16.90 +
   16.91 +/** Stream for kernel printk. */
   16.92 +IOStream *iostderr = &iokernel;
   16.93 +
   16.94 +/** Get an output-only stream implementation using
   16.95 + * printk(). The stream uses static storage, and must not be freed.
   16.96 + *
   16.97 + * @return kernel stream
   16.98 + */
   16.99 +IOStream get_stream_kernel(void){
  16.100 +  return iokernel;
  16.101 +}
  16.102 +
  16.103 +/** Obtain the lock on the stream state.
  16.104 + *
  16.105 + * @param kdata stream state
  16.106 + */
  16.107 +static inline void KernelData_lock(KernelData *kdata){
  16.108 +  spin_lock_irqsave(&kdata->lock, kdata->flags);
  16.109 +}
  16.110 +
  16.111 +/** Release the lock on the stream state.
  16.112 + *
  16.113 + * @param kdata stream state
  16.114 + */
  16.115 +static inline void KernelData_unlock(KernelData *kdata){
  16.116 +  spin_unlock_irqrestore(&kdata->lock, kdata->flags);
  16.117 +}
  16.118 +
  16.119 +/** Get the stream state.
  16.120 + *
  16.121 + * @param s kernel stream
  16.122 + * @return stream state
  16.123 + */
  16.124 +static inline KernelData *get_kernel_data(IOStream *s){
  16.125 +  return (KernelData*)s->data;
  16.126 +}
  16.127 +
  16.128 +/** Obtain the lock on the stream state.
  16.129 + *
  16.130 + * @param s stream
  16.131 + */
  16.132 +void kernel_stream_lock(IOStream *s){
  16.133 +    KernelData_lock(get_kernel_data(s));
  16.134 +}
  16.135 +
  16.136 +/** Release the lock on the stream state.
  16.137 + *
  16.138 + * @param s stream
  16.139 + */
  16.140 +void kernel_stream_unlock(IOStream *s){
  16.141 +    KernelData_unlock(get_kernel_data(s));
  16.142 +}
  16.143 +
  16.144 +/** Write to a kernel stream.
  16.145 + *
  16.146 + * @param stream kernel stream
  16.147 + * @param format print format
  16.148 + * @param args print arguments
  16.149 + * @return result of the print
  16.150 + */
  16.151 +static int kernel_write(IOStream *stream, const char *buf, int n){
  16.152 +  KernelData *kdata = get_kernel_data(stream);
  16.153 +  int k;
  16.154 +  k = kdata->buf_n - 1;
  16.155 +  if(n < k) k = n;
  16.156 +  memcpy(kdata->buf, buf, k);
  16.157 +  kdata->buf[k] = '\0'
  16.158 +  printk(kdata->buf);
  16.159 +  return k;
  16.160 +}
  16.161 +
  16.162 +/** Free a kernel stream.
  16.163 + * Frees the internal state of the stream.
  16.164 + * Do not call this unless the stream was dynamically allocated.
  16.165 + * Do not call this on a stream returned from get_stream_kernel().
  16.166 + *
  16.167 + * @param io stream to free
  16.168 + */
  16.169 +static void kernel_free(IOStream *io){
  16.170 +  KernelData *kdata;
  16.171 +  if(io == &iokernel) return;
  16.172 +  kdata = get_kernel_data(io);
  16.173 +  zero(kdata, sizeof(*kdata));
  16.174 +  deallocate(kdata);
  16.175 +}
  16.176 +#endif /* __KERNEL__ */
  16.177 +
  16.178 +
  16.179 +
  16.180 +

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/tools/lib/kernel_stream.h	Mon Jun 28 15:03:15 2004 +0000
    17.3 @@ -0,0 +1,29 @@
    17.4 +/*
    17.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    17.6 + *
    17.7 + * This library is free software; you can redistribute it and/or modify
    17.8 + * it under the terms of the GNU Lesser General Public License as published by
    17.9 + * the Free Software Foundation; either version 2.1 of the License, or
   17.10 + * (at your option) any later version.
   17.11 + *
   17.12 + * This library is distributed in the hope that it will be useful,
   17.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   17.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17.15 + * GNU Lesser General Public License for more details.
   17.16 + *
   17.17 + * You should have received a copy of the GNU Lesser General Public License
   17.18 + * along with this library; if not, write to the Free Software
   17.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   17.20 + */
   17.21 +
   17.22 +#ifndef _XEN_LIB_KERNEL_STREAM_H_
   17.23 +#define _XEN_LIB_KERNEL_STREAM_H_
   17.24 +
   17.25 +#ifdef __KERNEL__
   17.26 +#include "iostream.h"
   17.27 +
   17.28 +extern IOStream get_stream_kernel(void);
   17.29 +#define get_stream_stdout get_stream_kernel
   17.30 +
   17.31 +#endif /* __KERNEL__ */
   17.32 +#endif /* !_XEN_LIB_KERNEL_STREAM_H_ */

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/tools/lib/lexis.c	Mon Jun 28 15:03:15 2004 +0000
    18.3 @@ -0,0 +1,93 @@
    18.4 +/*
    18.5 + *
    18.6 + * This library is free software; you can redistribute it and/or modify
    18.7 + * it under the terms of the GNU Lesser General Public License as
    18.8 + * published by the Free Software Foundation; either version 2.1 of the
    18.9 + * License, or  (at your option) any later version. This library is 
   18.10 + * distributed in the  hope that it will be useful, but WITHOUT ANY
   18.11 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
   18.12 + * FITNESS FOR A PARTICULAR PURPOSE.
   18.13 + * See the GNU Lesser General Public License for more details.
   18.14 + *
   18.15 + * You should have received a copy of the GNU Lesser General Public License
   18.16 + * along with this library; if not, write to the Free Software Foundation,
   18.17 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   18.18 + */
   18.19 +
   18.20 +/** @file
   18.21 + * Lexical analysis.
   18.22 + */
   18.23 +
   18.24 +#include "sys_string.h"
   18.25 +#include "lexis.h"
   18.26 +#include <errno.h>
   18.27 +
   18.28 +/** Check if a value lies in a (closed) range.
   18.29 + *
   18.30 + * @param x value to test
   18.31 + * @param lo low end of the range
   18.32 + * @param hi high end of the range
   18.33 + * @return 1 if x is in the interval [lo, hi], 0 otherwise
   18.34 + */
   18.35 +inline static int in_range(int x, int lo, int hi){
   18.36 +    return (lo <= x) && (x <= hi);
   18.37 +}
   18.38 +
   18.39 +/** Determine if a string is an (unsigned) decimal number.
   18.40 + * 
   18.41 + * @param s pointer to characters to test
   18.42 + * @param n length of string
   18.43 + * @return 1 if s is a decimal number, 0 otherwise.
   18.44 + */
   18.45 +int is_decimal_number(const char *s, int n){
   18.46 +    int i;
   18.47 +    if(n <= 0)return 0;
   18.48 +    for(i = 0; i < n; i++){
   18.49 +        if(!in_decimal_digit_class(s[i])) return 0;
   18.50 +    }
   18.51 +    return 1;
   18.52 +}
   18.53 +
   18.54 +/** Determine if a string is a hex number.
   18.55 + * Hex numbers are 0, or start with 0x or 0X followed
   18.56 + * by a non-zero number of hex digits (0-9,a-f,A-F).
   18.57 + * 
   18.58 + * @param s pointer to characters to test
   18.59 + * @param n length of string
   18.60 + * @return 1 if s is a hex number, 0 otherwise.
   18.61 + */
   18.62 +int is_hex_number(const char *s, int n){
   18.63 +    int i;
   18.64 +    if(n <= 0) return 0;
   18.65 +    if(n == 1){
   18.66 +        return s[0]=='0';
   18.67 +    }
   18.68 +    if(n <= 3) return 0;
   18.69 +    if(s[0] != '0' || (s[1] != 'x' && s[1] != 'X')) return 0;
   18.70 +    for(i = 2; i < n; i++){
   18.71 +        if(!in_hex_digit_class(s[i])) return 0;
   18.72 +    }
   18.73 +    return 1;
   18.74 +}
   18.75 +
   18.76 +/** Test if a string matches a keyword.
   18.77 + * The comparison is case-insensitive.
   18.78 + * The comparison fails if either argument is null.
   18.79 + *
   18.80 + * @param s string
   18.81 + * @param k keyword
   18.82 + * @return 1 if they match, 0 otherwise
   18.83 + */
   18.84 +int is_keyword(const char *s, const char *k){
   18.85 +  return s && k && !strcasecmp(s, k);
   18.86 +}
   18.87 +
   18.88 +/** Test if a string matches a character.
   18.89 + *
   18.90 + * @param s string
   18.91 + * @param c character (non-null)
   18.92 + * @return 1 if s contains exactly c, 0 otherwise
   18.93 + */
   18.94 +int is_keychar(const char *s, char c){
   18.95 +  return c && (s[0] == c) && !s[1];
   18.96 +}

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/tools/lib/lexis.h	Mon Jun 28 15:03:15 2004 +0000
    19.3 @@ -0,0 +1,122 @@
    19.4 +/*
    19.5 + *
    19.6 + * This library is free software; you can redistribute it and/or modify
    19.7 + * it under the terms of the GNU Lesser General Public License as
    19.8 + * published by the Free Software Foundation; either version 2.1 of the
    19.9 + * License, or  (at your option) any later version. This library is 
   19.10 + * distributed in the  hope that it will be useful, but WITHOUT ANY
   19.11 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
   19.12 + * FITNESS FOR A PARTICULAR PURPOSE.
   19.13 + * See the GNU Lesser General Public License for more details.
   19.14 + *
   19.15 + * You should have received a copy of the GNU Lesser General Public License
   19.16 + * along with this library; if not, write to the Free Software Foundation,
   19.17 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   19.18 + */
   19.19 +
   19.20 +#ifndef _SP_LEXIS_H_
   19.21 +#define _SP_LEXIS_H_
   19.22 +
   19.23 +#include "sys_string.h"
   19.24 +#include "sys_ctype.h"
   19.25 +
   19.26 +/** @file
   19.27 + * Lexical analysis.
   19.28 + */
   19.29 +
   19.30 +/** Class of characters treated as space. */
   19.31 +#define space_class ((char []){ '\n', '\r', '\t', ' ', '\f' , 0 })
   19.32 +
   19.33 +/** Class of separator characters. */
   19.34 +#define sep_class "{}()<>[]@!;"
   19.35 +
   19.36 +#define comment_class "#"
   19.37 +
   19.38 +/** Determine if a character is in a given class.
   19.39 + * 
   19.40 + * @param c character to test
   19.41 + * @param s null-terminated string of characters in the class
   19.42 + * @return 1 if c is in the class, 0 otherwise.
   19.43 + */
   19.44 +static inline int in_class(int c, const char *s){
   19.45 +  return s && (strchr(s, c) != 0);
   19.46 +}
   19.47 +
   19.48 +/** Determine if a character is in the space class.
   19.49 + * 
   19.50 + * @param c character to test
   19.51 + * @return 1 if c is in the class, 0 otherwise.
   19.52 + */
   19.53 +static inline int in_space_class(int c){
   19.54 +    return in_class(c, space_class);
   19.55 +}
   19.56 +
   19.57 +static inline int in_comment_class(int c){
   19.58 +    return in_class(c, comment_class);
   19.59 +}
   19.60 +
   19.61 +/** Determine if a character is in the separator class.
   19.62 + * Separator characters terminate tokens, and do not need space
   19.63 + * to separate them.
   19.64 + * 
   19.65 + * @param c character to test
   19.66 + * @return 1 if c is in the class, 0 otherwise.
   19.67 + */
   19.68 +static inline int in_sep_class(int c){
   19.69 +    return in_class(c, sep_class);
   19.70 +}
   19.71 +
   19.72 +/** Determine if a character is in the alpha class.
   19.73 + * 
   19.74 + * @param c character to test
   19.75 + * @return 1 if c is in the class, 0 otherwise.
   19.76 + */
   19.77 +static inline int in_alpha_class(int c){
   19.78 +    return isalpha(c);
   19.79 +}
   19.80 +
   19.81 +/** Determine if a character is in the octal digit class.
   19.82 + * 
   19.83 + * @param c character to test
   19.84 + * @return 1 if c is in the class, 0 otherwise.
   19.85 + */
   19.86 +static inline int in_octal_digit_class(int c){
   19.87 +    return '0' <= c && c <= '7';
   19.88 +}
   19.89 +
   19.90 +/** Determine if a character is in the decimal digit class.
   19.91 + * 
   19.92 + * @param c character to test
   19.93 + * @return 1 if c is in the class, 0 otherwise.
   19.94 + */
   19.95 +static inline int in_decimal_digit_class(int c){
   19.96 +    return isdigit(c);
   19.97 +}
   19.98 +
   19.99 +/** Determine if a character is in the hex digit class.
  19.100 + * 
  19.101 + * @param c character to test
  19.102 + * @return 1 if c is in the class, 0 otherwise.
  19.103 + */
  19.104 +static inline int in_hex_digit_class(int c){
  19.105 +    return isdigit(c) || in_class(c, "abcdefABCDEF");
  19.106 +}
  19.107 +
  19.108 +
  19.109 +static inline int in_string_quote_class(int c){
  19.110 +    return in_class(c, "'\"");
  19.111 +}
  19.112 +
  19.113 +static inline int in_printable_class(int c){
  19.114 +    return ('A' <= c && c <= 'Z')
  19.115 +        || ('a' <= c && c <= 'z')
  19.116 +        || ('0' <= c && c <= '9')
  19.117 +        || in_class(c, "!$%&*+,-./:;<=>?@^_`{|}~");
  19.118 +}
  19.119 +
  19.120 +extern int is_decimal_number(const char *s, int n);
  19.121 +extern int is_hex_number(const char *s, int n);
  19.122 +extern int is_keyword(const char *s, const char *k);
  19.123 +extern int is_keychar(const char *s, char c);
  19.124 +
  19.125 +#endif /* !_SP_LEXIS_H_ */

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/tools/lib/lzi_stream.c	Mon Jun 28 15:03:15 2004 +0000
    20.3 @@ -0,0 +1,590 @@
    20.4 +/* $Id: lzi_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $ */
    20.5 +#define __FILE_ID_INFO "$Id: lzi_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $"
    20.6 +#include <what.h>
    20.7 +static char __rcsid[] __attribute__((unused)) = WHAT_ID __FILE_ID_INFO;
    20.8 +/*
    20.9 + * Copyright (C) 2003 Hewlett-Packard Company.
   20.10 + *
   20.11 + * This library is free software; you can redistribute it and/or modify
   20.12 + * it under the terms of the GNU Lesser General Public License as published by
   20.13 + * the Free Software Foundation; either version 2.1 of the License, or
   20.14 + * (at your option) any later version.
   20.15 + *
   20.16 + * This library is distributed in the hope that it will be useful,
   20.17 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   20.18 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   20.19 + * GNU Lesser General Public License for more details.
   20.20 + *
   20.21 + * You should have received a copy of the GNU Lesser General Public License
   20.22 + * along with this library; if not, write to the Free Software
   20.23 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   20.24 + */
   20.25 +
   20.26 +/** @file
   20.27 + * An IOStream implementation using LZI to provide compression and decompression.
   20.28 + * This is designed to provide compression without output latency.
   20.29 + * Flushing an LZI stream flushes all pending data to the underlying stream.
   20.30 + * This is essential for stream-based (e.g. networked) applications.
   20.31 + *
   20.32 + * A compressed data stream is a sequence of blocks.
   20.33 + * Each block is the block size followed by the compressed data.
   20.34 + * The last block has size zero.
   20.35 + * Sizes are 4-byte unsigned in network order.
   20.36 + *
   20.37 + * This format allows compressed data to be read from a stream without reading
   20.38 + * past the logical end of compressed data.
   20.39 + *
   20.40 + * @author Mike Wray <mike.wray@hpl.hp.com>
   20.41 + */
   20.42 +#ifndef __KERNEL__
   20.43 +
   20.44 +#include <stdio.h>
   20.45 +#include <stdlib.h>
   20.46 +#include <errno.h>
   20.47 +#include <string.h>
   20.48 +
   20.49 +#include "zlib.h"
   20.50 +
   20.51 +#include "allocate.h"
   20.52 +#include "lzi_stream.h"
   20.53 +#include "file_stream.h"
   20.54 +#include "marshal.h"
   20.55 +
   20.56 +#define dprintf(fmt, args...) fprintf(stdout, "[DEBUG] LZI>%s" fmt, __FUNCTION__, ##args)
   20.57 +#define wprintf(fmt, args...) fprintf(stderr, "[WARN]  LZI>%s" fmt, __FUNCTION__, ##args)
   20.58 +#define iprintf(fmt, args...) fprintf(stdout, "[INFO]  LZI>%s" fmt, __FUNCTION__, ##args)
   20.59 +#define eprintf(fmt, args...) fprintf(stderr, "[ERROR] LZI>%s" fmt, __FUNCTION__, ##args)
   20.60 +
   20.61 +static int lzi_read(IOStream *s, void *buf, size_t size, size_t count);
   20.62 +static int lzi_write(IOStream *s, const void *buf, size_t size, size_t count);
   20.63 +static int lzi_print(IOStream *s, const char *msg, va_list args);
   20.64 +static int lzi_getc(IOStream *s);
   20.65 +static int lzi_error(IOStream *s);
   20.66 +static int lzi_close(IOStream *s);
   20.67 +static void lzi_free(IOStream *s);
   20.68 +static int lzi_flush(IOStream *s);
   20.69 +
   20.70 +enum {
   20.71 +    LZI_WRITE = 1,
   20.72 +    LZI_READ = 2,
   20.73 +};
   20.74 +
   20.75 +/** Methods used by a gzFile* IOStream. */
   20.76 +static const IOMethods lzi_methods = {
   20.77 +    read: lzi_read,
   20.78 +    write: lzi_write,
   20.79 +    print: lzi_print,
   20.80 +    getc:  lzi_getc,
   20.81 +    error: lzi_error,
   20.82 +    close: lzi_close,
   20.83 +    free:  lzi_free,
   20.84 +    flush: lzi_flush,
   20.85 +};
   20.86 +
   20.87 +#define BUFFER_SIZE (512 * 1024)
   20.88 +
   20.89 +typedef struct LZIState {
   20.90 +    z_stream zstream;
   20.91 +    void *inbuf;
   20.92 +    uint32_t inbuf_size;
   20.93 +    void *outbuf;
   20.94 +    uint32_t outbuf_size;
   20.95 +    /** Underlying stream for I/O. */
   20.96 +    IOStream *io;
   20.97 +    /** Flags. */
   20.98 +    int flags;
   20.99 +    /** Error indicator. */
  20.100 +    int error;
  20.101 +    int eof;
  20.102 +    int plain_bytes;
  20.103 +    int comp_bytes;
  20.104 +    int zstream_initialized;
  20.105 +    int flushed;
  20.106 +} LZIState;
  20.107 +
  20.108 +static inline int LZIState_writeable(LZIState *s){
  20.109 +    return (s->flags & LZI_WRITE) != 0;
  20.110 +}
  20.111 +
  20.112 +static inline int LZIState_readable(LZIState *s){
  20.113 +    return (s->flags & LZI_READ) != 0;
  20.114 +}
  20.115 +
  20.116 +void LZIState_free(LZIState *z){
  20.117 +    if(!z) return;
  20.118 +    if(z->zstream_initialized){
  20.119 +        if(LZIState_writeable(z)){
  20.120 +            deflateEnd(&z->zstream);
  20.121 +        } else if(LZIState_readable(z)){
  20.122 +            inflateEnd(&z->zstream);
  20.123 +        }
  20.124 +    }
  20.125 +    deallocate(z->inbuf);
  20.126 +    deallocate(z->outbuf);
  20.127 +    deallocate(z);
  20.128 +}
  20.129 +
  20.130 +static int mode_flags(const char *mode, int *flags){
  20.131 +    int err = 0;
  20.132 +    int r=0, w=0;
  20.133 +    if(!mode){
  20.134 +        err = -EINVAL;
  20.135 +        goto exit;
  20.136 +    }
  20.137 +    for(; *mode; mode++){
  20.138 +        if(*mode == 'w') w = 1;
  20.139 +        if(*mode == 'r') r = 1;
  20.140 +    }
  20.141 +    if(r + w != 1){
  20.142 +        err = -EINVAL;
  20.143 +        goto exit;
  20.144 +    }
  20.145 +    if(r) *flags |= LZI_READ;
  20.146 +    if(w) *flags |= LZI_WRITE;
  20.147 +  exit:
  20.148 +    return err;
  20.149 +}
  20.150 +
  20.151 +/** Get the stream state.
  20.152 + * 
  20.153 + * @param s lzi stream
  20.154 + * @return stream state.
  20.155 + */
  20.156 +static inline LZIState * lzi_state(IOStream *io){
  20.157 +    return io->data;
  20.158 +}
  20.159 +
  20.160 +IOStream *lzi_stream_io(IOStream *io){
  20.161 +    LZIState *s = lzi_state(io);
  20.162 +    return s->io;
  20.163 +}
  20.164 +
  20.165 +static inline void set_error(LZIState *s, int err){
  20.166 +    if(err < 0 && !s->error){
  20.167 +        s->error = err;
  20.168 +    }
  20.169 +}
  20.170 +
  20.171 +static int zerror(LZIState *s, int err){
  20.172 +    if(err){
  20.173 +        //dprintf("> err=%d\n", err);
  20.174 +        if(err < 0) set_error(s, -EIO);
  20.175 +    }
  20.176 +    return s->error;
  20.177 +}
  20.178 +
  20.179 +int lzi_stream_plain_bytes(IOStream *io){
  20.180 +    LZIState *s = lzi_state(io);
  20.181 +    return s->plain_bytes;
  20.182 +}
  20.183 +
  20.184 +int lzi_stream_comp_bytes(IOStream *io){
  20.185 +    LZIState *s = lzi_state(io);
  20.186 +    return s->comp_bytes;
  20.187 +}
  20.188 +
  20.189 +float lzi_stream_ratio(IOStream *io){
  20.190 +    LZIState *s = lzi_state(io);
  20.191 +    float ratio = 0.0;
  20.192 +    if(s->comp_bytes){
  20.193 +        ratio = ((float) s->comp_bytes)/((float) s->plain_bytes);
  20.194 +    }
  20.195 +    return ratio;
  20.196 +}
  20.197 +
  20.198 +static int alloc(void **p, int n){
  20.199 +    *p = allocate(n);
  20.200 +    return (p ? 0 : -ENOMEM);
  20.201 +}
  20.202 +
  20.203 +LZIState * LZIState_new(IOStream *io, int flags){
  20.204 +    int err = -ENOMEM;
  20.205 +    int zlevel = Z_BEST_SPEED; // Level 1 compression - fastest.
  20.206 +    int zstrategy = Z_DEFAULT_STRATEGY;
  20.207 +    int zwindow = MAX_WBITS;
  20.208 +    int zmemory = 8;
  20.209 +    LZIState *z = ALLOCATE(LZIState);
  20.210 +
  20.211 +    //dprintf(">\n");
  20.212 +    if(!z) goto exit;
  20.213 +    z->io = io;
  20.214 +    z->flags = flags;
  20.215 +
  20.216 +    if(LZIState_writeable(z)){
  20.217 +        z->outbuf_size = BUFFER_SIZE;
  20.218 +        /* windowBits is passed < 0 to suppress zlib header */
  20.219 +        err = deflateInit2(&z->zstream, zlevel, Z_DEFLATED, -zwindow, zmemory, zstrategy);
  20.220 +        if (err != Z_OK) goto exit;
  20.221 +        z->zstream_initialized = 1;
  20.222 +        err = alloc(&z->outbuf, z->outbuf_size);
  20.223 +        if(err) goto exit;
  20.224 +        z->zstream.next_out = z->outbuf;
  20.225 +        z->zstream.avail_out = z->outbuf_size;
  20.226 +    } else {
  20.227 +        z->inbuf_size = BUFFER_SIZE;
  20.228 +        err = alloc(&z->inbuf, z->inbuf_size);
  20.229 +        if(err) goto exit;
  20.230 +        ///z->zstream.next_in  = z->inbuf;
  20.231 +
  20.232 +        /* windowBits is passed < 0 to tell that there is no zlib header.
  20.233 +         * Note that in this case inflate *requires* an extra "dummy" byte
  20.234 +         * after the compressed stream in order to complete decompression and
  20.235 +         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
  20.236 +         * present after the compressed stream.
  20.237 +         */
  20.238 +        err = inflateInit2(&z->zstream, -zwindow);
  20.239 +        if(err != Z_OK) goto exit;
  20.240 +        z->zstream_initialized = 1;
  20.241 +    }
  20.242 +        
  20.243 +  exit:
  20.244 +    if(err){
  20.245 +        LZIState_free(z);
  20.246 +        z = NULL;
  20.247 +    }
  20.248 +    //dprintf("< z=%p\n", z);
  20.249 +    return z;
  20.250 +}
  20.251 +
  20.252 +int read_block(LZIState *s){
  20.253 +    int err = 0, k = 0;
  20.254 +    //dprintf(">\n");
  20.255 +    if(s->eof) goto exit;
  20.256 +    err = unmarshal_uint32(s->io, &k);
  20.257 +    if(err) goto exit;
  20.258 +    if(k > s->inbuf_size){
  20.259 +        err = -EINVAL;
  20.260 +        goto exit;
  20.261 +    }
  20.262 +    if(k){
  20.263 +        err = unmarshal_bytes(s->io, s->inbuf, k);
  20.264 +        if(err) goto exit;
  20.265 +    } else {
  20.266 +        s->eof = 1;
  20.267 +    }        
  20.268 +    s->zstream.avail_in = k;
  20.269 +    s->zstream.next_in = s->inbuf;
  20.270 +    s->comp_bytes += 4;
  20.271 +    s->comp_bytes += k;
  20.272 +  exit:
  20.273 +    //dprintf("< err=%d\n", err);
  20.274 +    return err;
  20.275 +}
  20.276 +
  20.277 +int write_block(LZIState *s){
  20.278 +    int err = 0;
  20.279 +    int k = ((char*)s->zstream.next_out) - ((char*)s->outbuf);
  20.280 +    int k2 = s->outbuf_size - s->zstream.avail_out;
  20.281 +    //dprintf("> k=%d k2=%d\n", k, k2);
  20.282 +    if(!k) goto exit;
  20.283 +    err = marshal_uint32(s->io, k);
  20.284 +    if(err) goto exit;
  20.285 +    err = marshal_bytes(s->io, s->outbuf, k);
  20.286 +    if(err) goto exit;
  20.287 +    s->zstream.next_out = s->outbuf;
  20.288 +    s->zstream.avail_out = s->outbuf_size;
  20.289 +    s->comp_bytes += 4;
  20.290 +    s->comp_bytes += k;
  20.291 +  exit:
  20.292 +    //dprintf("< err=%d\n", err);
  20.293 +    return err;
  20.294 +}
  20.295 +
  20.296 +int write_terminator(LZIState *s){
  20.297 +    int err = 0;
  20.298 +    char c = 0;
  20.299 +    err = marshal_uint32(s->io, 1);
  20.300 +    if(err) goto exit;
  20.301 +    err = marshal_bytes(s->io, &c, 1);
  20.302 +    if(err) goto exit;
  20.303 +    err = marshal_uint32(s->io, 0);
  20.304 +    if(err) goto exit;
  20.305 +    s->comp_bytes += 9;
  20.306 +  exit:
  20.307 +    return err;
  20.308 +}
  20.309 +
  20.310 +/** Write to the underlying stream using fwrite();
  20.311 + *
  20.312 + * @param io destination
  20.313 + * @param buf data
  20.314 + * @param size size of data elements
  20.315 + * @param count number of data elements to write
  20.316 + * @return number of data elements written
  20.317 + */
  20.318 +static int lzi_write(IOStream *io, const void *buf, size_t size, size_t count){
  20.319 +    int err = 0;
  20.320 +    int n = size * count;
  20.321 +    LZIState *s = lzi_state(io);
  20.322 +
  20.323 +    //dprintf("> buf=%p size=%d count=%d n=%d\n", buf, size, count, n);
  20.324 +    if(!LZIState_writeable(s)){
  20.325 +        err = -EINVAL;
  20.326 +        goto exit;
  20.327 +    }
  20.328 +    s->flushed = 0;
  20.329 +    s->zstream.next_in = (void*)buf;
  20.330 +    s->zstream.avail_in = n;
  20.331 +    while(s->zstream.avail_in){
  20.332 +        if(s->zstream.avail_out == 0){
  20.333 +            err = write_block(s);
  20.334 +            if(err) goto exit;
  20.335 +        }
  20.336 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.337 +        //dprintf("> 1 deflate next_in=%p next_out=%p\n", s->zstream.next_in, s->zstream.next_out);
  20.338 +        err = zerror(s, deflate(&s->zstream, Z_NO_FLUSH));
  20.339 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.340 +        //dprintf("> 2 deflate next_in=%p next_out=%p\n", s->zstream.next_in, s->zstream.next_out);
  20.341 +        if(err) goto exit;
  20.342 +    }
  20.343 +    err = n;
  20.344 +    s->plain_bytes += n;
  20.345 +    if(size != 1) err /= size;
  20.346 +  exit:
  20.347 +    //dprintf("< err=%d\n", err);
  20.348 +    return err;
  20.349 +}
  20.350 +
  20.351 +
  20.352 +/** Read from the underlying stream.
  20.353 + *
  20.354 + * @param io input
  20.355 + * @param buf where to put input
  20.356 + * @param size size of data elements
  20.357 + * @param count number of data elements to read
  20.358 + * @return number of data elements read
  20.359 + */
  20.360 +static int lzi_read(IOStream *io, void *buf, size_t size, size_t count){
  20.361 +    int err, zerr;
  20.362 +    int n = size * count;
  20.363 +    LZIState *s = lzi_state(io);
  20.364 +
  20.365 +    //dprintf("> size=%d count=%d n=%d\n", size, count, n);
  20.366 +    if(!LZIState_readable(s)){
  20.367 +        err = -EINVAL;
  20.368 +        goto exit;
  20.369 +    }
  20.370 +    s->zstream.next_out = buf;
  20.371 +    s->zstream.avail_out = n;
  20.372 +    while(s->zstream.avail_out){
  20.373 +        if(s->zstream.avail_in == 0){
  20.374 +            err = read_block(s);
  20.375 +        }
  20.376 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.377 +        zerr = inflate(&s->zstream, Z_NO_FLUSH);
  20.378 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.379 +        if(zerr == Z_STREAM_END) break;
  20.380 +        //dprintf("> zerr=%d\n", zerr);
  20.381 +        err = zerror(s, zerr);
  20.382 +        if(err) goto exit;
  20.383 +    }
  20.384 +    err = n - s->zstream.avail_out;
  20.385 +    s->plain_bytes += err;
  20.386 +    if(size != 1) err /= size;
  20.387 +  exit:
  20.388 +    set_error(s, err);
  20.389 +    //dprintf("< err=%d\n", err);
  20.390 +    return err;
  20.391 +}
  20.392 +
  20.393 +/** Print to the underlying stream.
  20.394 + * Returns 0 if the formatted output is too big for the internal buffer.
  20.395 + *
  20.396 + * @param io lzi stream
  20.397 + * @param msg format to use
  20.398 + * @param args arguments
  20.399 + * @return result of the print
  20.400 + */
  20.401 +static int lzi_print(IOStream *io, const char *msg, va_list args){
  20.402 +    char buf[1024];
  20.403 +    int buf_n = sizeof(buf);
  20.404 +    int n;
  20.405 +    LZIState *s = lzi_state(io);
  20.406 +    if(!LZIState_writeable(s)){
  20.407 +        n = -EINVAL;
  20.408 +        goto exit;
  20.409 +    }
  20.410 +    n = vsnprintf(buf, buf_n, (char*)msg, args);
  20.411 +    if(n < 0) goto exit;
  20.412 +    if(n > buf_n){
  20.413 +        n = 0;
  20.414 +    } else {
  20.415 +        n = lzi_write(io, buf, 1, n);
  20.416 +    }
  20.417 +  exit:
  20.418 +    return n;
  20.419 +}
  20.420 +
  20.421 +/** Read a character from the underlying stream
  20.422 + *
  20.423 + * @param io lzi stream
  20.424 + * @return character read, IOSTREAM_EOF on end of file (or error)
  20.425 + */
  20.426 +static int lzi_getc(IOStream *io){
  20.427 +    int err;
  20.428 +    char c;
  20.429 +    err = lzi_read(io, &c, 1, 1);
  20.430 +    if(err < 1) c = EOF;
  20.431 +    err = (c==EOF ? IOSTREAM_EOF : c);
  20.432 +    return err;
  20.433 +}
  20.434 +
  20.435 +static int flush_output(LZIState *s, int mode){
  20.436 +    int err = 0, zerr;
  20.437 +    int done = 0;
  20.438 +    int avail_out_old;
  20.439 +    int count = 10;
  20.440 +
  20.441 +    //dprintf("> avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.442 +    if(s->flushed == 1 + mode) goto exit;
  20.443 +    //s->zstream.avail_in = 0; /* should be zero already anyway */
  20.444 +    for(;;){
  20.445 +        // Write any available output.
  20.446 +        if(done || s->zstream.avail_out == 0){
  20.447 +            err = write_block(s);
  20.448 +            if(err) goto exit;
  20.449 +            if(done) break;
  20.450 +        }
  20.451 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.452 +        avail_out_old = s->zstream.avail_out;
  20.453 +        zerr = deflate(&s->zstream, mode);
  20.454 +        err = zerror(s, zerr);
  20.455 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  20.456 +        //dprintf("> deflate=%d\n", err);
  20.457 +        //done = (s->zstream.avail_out != 0);
  20.458 +        //done = (s->zstream.avail_in == 0) && (s->zstream.avail_out == avail_out_old);
  20.459 +        if(0 && mode == Z_FINISH){
  20.460 +            done = (zerr ==  Z_STREAM_END);
  20.461 +        } else {
  20.462 +            done = (s->zstream.avail_in == 0)
  20.463 +                //&& (s->zstream.avail_out == avail_out_old)
  20.464 +                && (s->zstream.avail_out != 0);
  20.465 +        }
  20.466 +    }
  20.467 +    s->flushed = 1 + mode;
  20.468 +  exit:
  20.469 +    //dprintf("< err=%d\n", err);
  20.470 +    return err;
  20.471 +}
  20.472 +
  20.473 +/** Flush any pending input to the underlying stream.
  20.474 + *
  20.475 + * @param s lzi stream
  20.476 + * @return 0 on success, error code otherwise
  20.477 + */
  20.478 +static int lzi_flush(IOStream *io){
  20.479 +    int err = 0;
  20.480 +    LZIState *s = lzi_state(io);
  20.481 +    //dprintf(">\n");
  20.482 +    if(!LZIState_writeable(s)){
  20.483 +        err = -EINVAL;
  20.484 +        goto exit;
  20.485 +    }
  20.486 +    err = flush_output(s, Z_SYNC_FLUSH);
  20.487 +    if(err) goto exit;
  20.488 +    err = IOStream_flush(s->io);
  20.489 +  exit:
  20.490 +    set_error(s, err);
  20.491 +    //dprintf("< err=%d\n", err);
  20.492 +    return (err < 0 ? err : 0);
  20.493 +}
  20.494 +
  20.495 +/** Check if a stream has an error.
  20.496 + *
  20.497 + * @param s lzi stream
  20.498 + * @return code if has an error, 0 otherwise
  20.499 + */
  20.500 +static int lzi_error(IOStream *s){
  20.501 +    int err = 0;
  20.502 +    LZIState *state = lzi_state(s);
  20.503 +    err = state->error;
  20.504 +    if(err) goto exit;
  20.505 +    err = IOStream_error(state->io);
  20.506 +  exit:
  20.507 +    return err;
  20.508 +}
  20.509 +
  20.510 +/** Close an lzi stream.
  20.511 + *
  20.512 + * @param s lzi stream to close
  20.513 + * @return result of the close
  20.514 + */
  20.515 +static int lzi_close(IOStream *io){
  20.516 +    int err = 0;
  20.517 +    LZIState *s = lzi_state(io);
  20.518 +    if(LZIState_writeable(s)){
  20.519 +        err = flush_output(s, Z_FINISH);
  20.520 +        if(err) goto exit;
  20.521 +        err = write_terminator(s);
  20.522 +        if(err) goto exit;
  20.523 +        err = IOStream_flush(s->io);
  20.524 +    }   
  20.525 +  exit:
  20.526 +    err = IOStream_close(s->io);
  20.527 +    set_error(s, err);
  20.528 +    return err;
  20.529 +}
  20.530 +
  20.531 +/** Free an lzi stream.
  20.532 + *
  20.533 + * @param s lzi stream
  20.534 + */
  20.535 +static void lzi_free(IOStream *s){
  20.536 +    LZIState *state = lzi_state(s);
  20.537 +    IOStream_free(state->io);
  20.538 +    LZIState_free(state);
  20.539 +    s->data = NULL;
  20.540 +}
  20.541 +
  20.542 +/** Create an lzi stream for an IOStream.
  20.543 + *
  20.544 + * @param io stream to wrap
  20.545 + * @return new IOStream using f for i/o
  20.546 + */
  20.547 +IOStream *lzi_stream_new(IOStream *io, const char *mode){
  20.548 +    int err = -ENOMEM;
  20.549 +    int flags = 0;
  20.550 +    IOStream *zio = NULL;
  20.551 +    LZIState *state = NULL;
  20.552 +
  20.553 +    zio = ALLOCATE(IOStream);
  20.554 +    if(!zio) goto exit;
  20.555 +    err = mode_flags(mode, &flags);
  20.556 +    if(err) goto exit;
  20.557 +    state = LZIState_new(io, flags);
  20.558 +    if(!state) goto exit;
  20.559 +    err = 0;
  20.560 +    zio->data = state;
  20.561 +    zio->methods = &lzi_methods;
  20.562 +  exit:
  20.563 +    if(err){
  20.564 +        if(state) LZIState_free(state);
  20.565 +        if(zio) deallocate(zio);
  20.566 +        zio = NULL;
  20.567 +    }
  20.568 +    return zio;
  20.569 +}
  20.570 +
  20.571 +/** IOStream version of fdopen().
  20.572 + *
  20.573 + * @param fd file descriptor
  20.574 + * @param flags giving the mode to open in (as for fdopen())
  20.575 + * @return new stream for the open file, or NULL if failed
  20.576 + */
  20.577 +IOStream *lzi_stream_fdopen(int fd, const char *mode){
  20.578 +    int err = -ENOMEM;
  20.579 +    IOStream *io = NULL, *zio = NULL;
  20.580 +    io = file_stream_fdopen(fd, mode);
  20.581 +    if(!io) goto exit;
  20.582 +    zio = lzi_stream_new(io, mode);
  20.583 +    if(!io) goto exit;
  20.584 +    err = 0;
  20.585 +  exit:
  20.586 +    if(err){
  20.587 +        IOStream_free(io);
  20.588 +        IOStream_free(zio);
  20.589 +        zio = NULL;
  20.590 +    }
  20.591 +    return zio;
  20.592 +}
  20.593 +#endif

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/tools/lib/lzi_stream.h	Mon Jun 28 15:03:15 2004 +0000
    21.3 @@ -0,0 +1,36 @@
    21.4 +#/* $Id: lzi_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    21.5 +/*
    21.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    21.7 + *
    21.8 + * This library is free software; you can redistribute it and/or modify
    21.9 + * it under the terms of the GNU Lesser General Public License as published by
   21.10 + * the Free Software Foundation; either version 2.1 of the License, or
   21.11 + * (at your option) any later version.
   21.12 + *
   21.13 + * This library is distributed in the hope that it will be useful,
   21.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   21.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   21.16 + * GNU Lesser General Public License for more details.
   21.17 + *
   21.18 + * You should have received a copy of the GNU Lesser General Public License
   21.19 + * along with this library; if not, write to the Free Software
   21.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   21.21 + */
   21.22 +
   21.23 +#ifndef _SP_LZI_STREAM_H_
   21.24 +#define _SP_LZI_STREAM_H_
   21.25 +
   21.26 +#ifndef __KERNEL__
   21.27 +#include "iostream.h"
   21.28 +
   21.29 +extern IOStream *lzi_stream_new(IOStream *io, const char *mode);
   21.30 +extern IOStream *lzi_stream_fopen(const char *file, const char *mode);
   21.31 +extern IOStream *lzi_stream_fdopen(int fd, const char *mode);
   21.32 +extern IOStream *lzi_stream_io(IOStream *zio);
   21.33 +
   21.34 +extern int lzi_stream_plain_bytes(IOStream *io);
   21.35 +extern int lzi_stream_comp_bytes(IOStream *io);
   21.36 +extern float lzi_stream_ratio(IOStream *io);
   21.37 +
   21.38 +#endif
   21.39 +#endif /* !_SP_FILE_STREAM_H_ */

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/tools/lib/lzo_stream.c	Mon Jun 28 15:03:15 2004 +0000
    22.3 @@ -0,0 +1,596 @@
    22.4 +/* $Id: lzo_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $ */
    22.5 +#define __FILE_ID_INFO "$Id: lzo_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $"
    22.6 +#include <what.h>
    22.7 +static char __rcsid[] __attribute__((unused)) = WHAT_ID __FILE_ID_INFO;
    22.8 +/*
    22.9 + * Copyright (C) 2003 Hewlett-Packard Company.
   22.10 + *
   22.11 + * This library is free software; you can redistribute it and/or modify
   22.12 + * it under the terms of the GNU Lesser General Public License as published by
   22.13 + * the Free Software Foundation; either version 2.1 of the License, or
   22.14 + * (at your option) any later version.
   22.15 + *
   22.16 + * This library is distributed in the hope that it will be useful,
   22.17 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   22.18 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   22.19 + * GNU Lesser General Public License for more details.
   22.20 + *
   22.21 + * You should have received a copy of the GNU Lesser General Public License
   22.22 + * along with this library; if not, write to the Free Software
   22.23 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   22.24 + */
   22.25 +
   22.26 +/** @file
   22.27 + * An IOStream implementation using LZO to provide compression and decompression.
   22.28 + * This is designed to provide reasonable compression without output latency.
   22.29 + * Flushing an LZO stream flushes all pending data to the underlying stream.
   22.30 + * This is essential for stream-based (e.g. networked) applications.
   22.31 + *
   22.32 + * A compressed data stream is a sequence of blocks.
   22.33 + * Each block except the last is the plain data size followed by the compressed data size
   22.34 + * and the compressed data. The last block has plain data size zero and omits the rest.
   22.35 + * Sizes are 4-byte unsigned in network order. If the compressed size is smaller than
   22.36 + * the plain size the block data is compressed, otherwise it is plain (uncompressed).
   22.37 + *
   22.38 + * This format allows compressed data to be read from a stream without reading
   22.39 + * past the logical end of compressed data.
   22.40 + *
   22.41 + * @author Mike Wray <mike.wray@hpl.hp.com>
   22.42 + */
   22.43 +#ifndef __KERNEL__
   22.44 +
   22.45 +#include <stdio.h>
   22.46 +#include <stdlib.h>
   22.47 +#include <errno.h>
   22.48 +#include <string.h>
   22.49 +
   22.50 +#include "lzo1x.h"
   22.51 +
   22.52 +#include "allocate.h"
   22.53 +#include "lzo_stream.h"
   22.54 +#include "file_stream.h"
   22.55 +#include "marshal.h"
   22.56 +
   22.57 +#define dprintf(fmt, args...) fprintf(stdout, "[DEBUG] LZO>%s" fmt, __FUNCTION__, ##args)
   22.58 +#define wprintf(fmt, args...) fprintf(stderr, "[WARN]  LZO>%s" fmt, __FUNCTION__, ##args)
   22.59 +#define iprintf(fmt, args...) fprintf(stdout, "[INFO]  LZO>%s" fmt, __FUNCTION__, ##args)
   22.60 +#define eprintf(fmt, args...) fprintf(stderr, "[ERROR] LZO>%s" fmt, __FUNCTION__, ##args)
   22.61 +
   22.62 +static int lzo_read(IOStream *s, void *buf, size_t size, size_t count);
   22.63 +static int lzo_write(IOStream *s, const void *buf, size_t size, size_t count);
   22.64 +static int lzo_print(IOStream *s, const char *msg, va_list args);
   22.65 +static int lzo_getc(IOStream *s);
   22.66 +static int lzo_error(IOStream *s);
   22.67 +static int lzo_close(IOStream *s);
   22.68 +static void lzo_free(IOStream *s);
   22.69 +static int lzo_flush(IOStream *s);
   22.70 +
   22.71 +enum {
   22.72 +    LZO_WRITE = 1,
   22.73 +    LZO_READ = 2,
   22.74 +};
   22.75 +
   22.76 +/** Methods used by a gzFile* IOStream. */
   22.77 +static const IOMethods lzo_methods = {
   22.78 +    read: lzo_read,
   22.79 +    write: lzo_write,
   22.80 +    print: lzo_print,
   22.81 +    getc:  lzo_getc,
   22.82 +    error: lzo_error,
   22.83 +    close: lzo_close,
   22.84 +    free:  lzo_free,
   22.85 +    flush: lzo_flush,
   22.86 +};
   22.87 +
   22.88 +//#define PLAIN_SIZE (64 * 1024)
   22.89 +//#define PLAIN_SIZE (128 * 1024)
   22.90 +#define PLAIN_SIZE (512 * 1024)
   22.91 +
   22.92 +//#define NOCOMPRESS
   22.93 +
   22.94 +typedef struct LZOState {
   22.95 +    /** Flags. */
   22.96 +    int flags;
   22.97 +    /** Error indicator. */
   22.98 +    int error;
   22.99 +    /** Underlying stream for I/O. */
  22.100 +    IOStream *io;
  22.101 +    /** Working memory (only needed for compression, not decompression). */
  22.102 +    lzo_byte *memory;
  22.103 +    /** Buffer for plain (uncompressed) data. */
  22.104 +    lzo_byte *plain;
  22.105 +    /** Size of the plain buffer. */
  22.106 +    lzo_uint plain_size;
  22.107 +    /** Pointer into the plain buffer. */
  22.108 +    lzo_byte *plain_ptr;
  22.109 +    /** Number of bytes of plain data available. */
  22.110 +    lzo_uint plain_n;
  22.111 +    /** Buffer for compressed data. */
  22.112 +    lzo_byte *comp;
  22.113 +    /** Size of the compressed buffer. */
  22.114 +    lzo_uint comp_size;
  22.115 +
  22.116 +    int plain_bytes;
  22.117 +    int comp_bytes;
  22.118 +} LZOState;
  22.119 +
  22.120 +void LZOState_free(LZOState *z){
  22.121 +    if(!z) return;
  22.122 +    deallocate(z->memory);
  22.123 +    deallocate(z->plain);
  22.124 +    deallocate(z->comp);
  22.125 +    deallocate(z);
  22.126 +}
  22.127 +
  22.128 +/** Maximum size of compressed data for the given plain data size.
  22.129 + *
  22.130 + * @param plain_size size of plain data
  22.131 + * @return maximum size of compressed data
  22.132 + */
  22.133 +static int comp_size(int plain_size){
  22.134 +    return plain_size + (plain_size / 64) + 16 + 3;
  22.135 +}
  22.136 +
  22.137 +static int mode_flags(const char *mode, int *flags){
  22.138 +    int err = 0;
  22.139 +    int r=0, w=0;
  22.140 +    if(!mode){
  22.141 +        err = -EINVAL;
  22.142 +        goto exit;
  22.143 +    }
  22.144 +    for(; *mode; mode++){
  22.145 +        if(*mode == 'w') w = 1;
  22.146 +        if(*mode == 'r') r = 1;
  22.147 +    }
  22.148 +    if(r + w != 1){
  22.149 +        err = -EINVAL;
  22.150 +        goto exit;
  22.151 +    }
  22.152 +    if(r) *flags |= LZO_READ;
  22.153 +    if(w) *flags |= LZO_WRITE;
  22.154 +  exit:
  22.155 +    return err;
  22.156 +}
  22.157 +
  22.158 +/** Get the stream state.
  22.159 + * 
  22.160 + * @param s lzo stream
  22.161 + * @return stream state.
  22.162 + */
  22.163 +static inline LZOState * lzo_state(IOStream *s){
  22.164 +    return s->data;
  22.165 +}
  22.166 +
  22.167 +IOStream *lzo_stream_io(IOStream *s){
  22.168 +    LZOState *state = lzo_state(s);
  22.169 +    return state->io;
  22.170 +}
  22.171 +
  22.172 +static inline void set_error(LZOState *state, int err){
  22.173 +    if(err < 0 && !state->error){
  22.174 +        state->error = err;
  22.175 +    }
  22.176 +}
  22.177 +
  22.178 +int lzo_stream_plain_bytes(IOStream *s){
  22.179 +    LZOState *state = lzo_state(s);
  22.180 +    return state->plain_bytes;
  22.181 +}
  22.182 +
  22.183 +int lzo_stream_comp_bytes(IOStream *s){
  22.184 +    LZOState *state = lzo_state(s);
  22.185 +    return state->comp_bytes;
  22.186 +}
  22.187 +
  22.188 +float lzo_stream_ratio(IOStream *s){
  22.189 +    LZOState *state = lzo_state(s);
  22.190 +    float ratio = 0.0;
  22.191 +    if(state->comp_bytes){
  22.192 +        ratio = ((float) state->comp_bytes)/((float) state->plain_bytes);
  22.193 +    }
  22.194 +    return ratio;
  22.195 +}
  22.196 +
  22.197 +static inline int LZOState_writeable(LZOState *state){
  22.198 +    return (state->flags & LZO_WRITE) != 0;
  22.199 +}
  22.200 +
  22.201 +static inline int LZOState_readable(LZOState *state){
  22.202 +    return (state->flags & LZO_READ) != 0;
  22.203 +}
  22.204 +
  22.205 +LZOState * LZOState_new(IOStream *io, int flags){
  22.206 +    int err = -ENOMEM;
  22.207 +    LZOState *z = ALLOCATE(LZOState);
  22.208 +    //dprintf(">\n");
  22.209 +    if(!z) goto exit;
  22.210 +    z->io = io;
  22.211 +    z->flags = flags;
  22.212 +    if(LZOState_writeable(z)){
  22.213 +        z->memory = allocate(LZO1X_1_MEM_COMPRESS);
  22.214 +        if(!z->memory) goto exit;
  22.215 +    }
  22.216 +    z->plain_size = PLAIN_SIZE;
  22.217 +    z->plain = allocate(z->plain_size);
  22.218 +    if(!z->plain) goto exit;
  22.219 +    z->plain_ptr = z->plain;
  22.220 +    z->comp_size = comp_size(z->plain_size);
  22.221 +    z->comp = allocate(z->comp_size);
  22.222 +    if(!z->comp) goto exit;
  22.223 +    err = 0;
  22.224 +  exit:
  22.225 +    if(err){
  22.226 +        LZOState_free(z);
  22.227 +        z = NULL;
  22.228 +    }
  22.229 +    //dprintf("< z=%p\n", z);
  22.230 +    return z;
  22.231 +}
  22.232 +
  22.233 +static int lzo_compress(LZOState *state){
  22.234 +    int err = 0;
  22.235 +    int k, comp_n;
  22.236 +    //dprintf(">\n");
  22.237 +    //dprintf(">plain=%p plain_n=%d comp=%p memory=%p\n", state->plain, state->plain_n, state->comp, state->memory);
  22.238 +    // Compress the plain buffer.
  22.239 +    err = lzo1x_1_compress(state->plain, state->plain_n,
  22.240 +                           state->comp, &comp_n,
  22.241 +                           state->memory);
  22.242 +    //dprintf("> err=%d plain_n=%d comp_n=%d\n", err, state->plain_n, comp_n);
  22.243 +    // Write plain size, compressed size.
  22.244 +    err = marshal_uint32(state->io, state->plain_n);
  22.245 +    if(err) goto exit;
  22.246 +    err = marshal_uint32(state->io, comp_n);
  22.247 +    if(err) goto exit;
  22.248 +    //dprintf("> write data...\n");
  22.249 +    // Write the smaller of the compressed and plain data.
  22.250 +    if(state->plain_n < comp_n){
  22.251 +        k = state->plain_n;
  22.252 +        err = marshal_bytes(state->io, state->plain, state->plain_n);
  22.253 +    } else {
  22.254 +        k = comp_n;
  22.255 +        err = marshal_bytes(state->io, state->comp, comp_n);
  22.256 +    }
  22.257 +    if(err) goto exit;
  22.258 +    // Total output bytes.
  22.259 +    k+= 8;
  22.260 +    //dprintf("> wrote %d bytes\n", k);
  22.261 +    state->plain_bytes += state->plain_n;
  22.262 +    state->comp_bytes += k;
  22.263 +    //dprintf("> plain=%d, comp=%d, ratio=%3.2f\n",
  22.264 +    //        state->plain_bytes, state->comp_bytes,
  22.265 +    //        ((float)state->comp_bytes)/((float)state->plain_bytes));
  22.266 +    // Reset the plain buffer.
  22.267 +    state->plain_ptr = state->plain;
  22.268 +    state->plain_n = 0;
  22.269 +    err = k;
  22.270 +  exit:
  22.271 +    //dprintf("< err=%d\n", err);
  22.272 +    return err;
  22.273 +}
  22.274 +
  22.275 +static int lzo_decompress(LZOState *state){
  22.276 +    int plain_n, comp_n;
  22.277 +    int err, k;
  22.278 +    //dprintf(">\n");
  22.279 +    err = unmarshal_uint32(state->io, &plain_n);
  22.280 +    //dprintf("> err=%d plain_n=%d\n", err, plain_n);
  22.281 +    if(err) goto exit;
  22.282 +    state->comp_bytes += 4;
  22.283 +    if(plain_n == 0) goto exit;
  22.284 +    err = unmarshal_uint32(state->io, &comp_n);
  22.285 +    //dprintf("> err=%d comp_n=%d\n", err, comp_n);
  22.286 +    if(err) goto exit;
  22.287 +    state->comp_bytes += 4;
  22.288 +    if(plain_n > state->plain_size){
  22.289 +        err = -EINVAL;
  22.290 +        goto exit;
  22.291 +    }
  22.292 +    if(comp_n > plain_n){
  22.293 +        //dprintf("> reading plain data %d...\n", plain_n);
  22.294 +        k = plain_n;
  22.295 +        err = unmarshal_bytes(state->io, state->plain, plain_n);
  22.296 +        state->plain_n = plain_n;
  22.297 +    } else {
  22.298 +        //dprintf("> reading comp data %d...\n", comp_n);
  22.299 +        k = comp_n;
  22.300 +        err = unmarshal_bytes(state->io, state->comp, comp_n);
  22.301 +        //dprintf("> decompress comp_n=%d\n", comp_n);
  22.302 +        err = lzo1x_decompress(state->comp, comp_n,
  22.303 +                               state->plain, &state->plain_n,
  22.304 +                               state->memory);
  22.305 +        //dprintf("> err=%d plain=%d state->plain_n=%d\n", err, plain_n, state->plain_n);
  22.306 +        if(err != LZO_E_OK || state->plain_n != plain_n){
  22.307 +            // Bad. Corrupted input.
  22.308 +            err = -EINVAL;
  22.309 +            eprintf("> Corrupted!\n");
  22.310 +            goto exit;
  22.311 +        }
  22.312 +    }
  22.313 +    state->comp_bytes += k;
  22.314 +    state->plain_bytes += state->plain_n;
  22.315 +    state->plain_ptr = state->plain;
  22.316 +    err = k;
  22.317 +  exit:
  22.318 +    //dprintf("< err=%d\n", err);
  22.319 +    return err;
  22.320 +}
  22.321 +
  22.322 +/** Write to the underlying stream using fwrite();
  22.323 + *
  22.324 + * @param stream destination
  22.325 + * @param buf data
  22.326 + * @param size size of data elements
  22.327 + * @param count number of data elements to write
  22.328 + * @return number of data elements written
  22.329 + */
  22.330 +static int lzo_write(IOStream *s, const void *buf, size_t size, size_t count){
  22.331 +    int err = 0;
  22.332 +    int n = size * count; // Total number of bytes to write.
  22.333 +    int chunk;            // Size of chunk to write.
  22.334 +    int remaining;        // Number of bytes remaining to write.
  22.335 +    int space;            // Amount of space left in plain buffer.
  22.336 +    LZOState *state = lzo_state(s);
  22.337 +#ifdef NOCOMPRESS
  22.338 +    //dprintf("> buf=%p size=%d count=%d\n", buf, size, count);
  22.339 +    err = IOStream_write(state->io, buf, size, count);
  22.340 +    //dprintf("< err=%d\n", err);
  22.341 +#else
  22.342 +    //dprintf("> buf=%p size=%d count=%d n=%d\n", buf, size, count, n);
  22.343 +    remaining = n;
  22.344 +    space = state->plain_size - state->plain_n;
  22.345 +    //dprintf("> plain=%p plain_ptr=%p plain_n=%d space=%d\n",
  22.346 +    //        state->plain, state->plain_ptr, state->plain_n, space);
  22.347 +    while(remaining){
  22.348 +        chunk = remaining;
  22.349 +        if(chunk > space) chunk = space;
  22.350 +        //dprintf("> memcpy %p %p %d\n", state->plain_ptr, buf, chunk);
  22.351 +        memcpy(state->plain_ptr, buf, chunk);
  22.352 +        remaining -= chunk;
  22.353 +        space -= chunk;
  22.354 +        state->plain_ptr += chunk;
  22.355 +        state->plain_n += chunk;
  22.356 +        if(space == 0){
  22.357 +            // Input buffer is full. Compress and write it.
  22.358 +            err = lzo_compress(state);
  22.359 +            if(err < 0) goto exit;
  22.360 +            space = state->plain_size - state->plain_n;
  22.361 +        }
  22.362 +    }
  22.363 +    err = (size > 1 ? n / size : n);
  22.364 +  exit:
  22.365 +    set_error(state, err);
  22.366 +#endif
  22.367 +    return err;
  22.368 +}
  22.369 +
  22.370 +
  22.371 +/** Read from the underlying stream.
  22.372 + *
  22.373 + * @param stream input
  22.374 + * @param buf where to put input
  22.375 + * @param size size of data elements
  22.376 + * @param count number of data elements to read
  22.377 + * @return number of data elements read
  22.378 + */
  22.379 +static int lzo_read(IOStream *s, void *buf, size_t size, size_t count){
  22.380 +    int err = 0;
  22.381 +    int k = 0;                     // Number of (plain) bytes read.
  22.382 +    int remaining = size * count;  // Number of bytes remaining to read.
  22.383 +    int chunk;                     // Size of chunk to read.
  22.384 +    LZOState *state = lzo_state(s);
  22.385 +#ifdef NOCOMPRESS
  22.386 +    //dprintf("> buf=%p size=%d count=%d\n", buf, size, count);
  22.387 +    err = IOStream_read(state->io, buf, size, count);
  22.388 +    //dprintf("< err=%d\n", err);
  22.389 +#else
  22.390 +    if(!(state->flags & LZO_READ)){
  22.391 +        err = -EINVAL;
  22.392 +        goto exit;
  22.393 +    }
  22.394 +    while(remaining){
  22.395 +        if(state->plain_n == 0){
  22.396 +            // No more plain input, decompress some more.
  22.397 +            err = lzo_decompress(state);
  22.398 +            if(err < 0) goto exit;
  22.399 +            // Stop reading if there is no more input.
  22.400 +            if(err == 0 || state->plain_n == 0) break;
  22.401 +        }
  22.402 +        chunk = remaining;
  22.403 +        if(chunk > state->plain_n) chunk = state->plain_n;
  22.404 +        memcpy(buf, state->plain_ptr, chunk);
  22.405 +        k += chunk;
  22.406 +        buf += chunk;
  22.407 +        state->plain_ptr += chunk;
  22.408 +        state->plain_n -= chunk;
  22.409 +        remaining -= chunk;
  22.410 +    }
  22.411 +    err = k;
  22.412 +  exit:
  22.413 +    set_error(state, err);
  22.414 +#endif
  22.415 +    return err;
  22.416 +}
  22.417 +
  22.418 +/** Print to the underlying stream.
  22.419 + * Returns 0 if the formatted output is too big for the internal buffer.
  22.420 + *
  22.421 + * @param s lzo stream
  22.422 + * @param msg format to use
  22.423 + * @param args arguments
  22.424 + * @return result of the print
  22.425 + */
  22.426 +static int lzo_print(IOStream *s, const char *msg, va_list args){
  22.427 +    char buf[1024];
  22.428 +    int buf_n = sizeof(buf);
  22.429 +    int n;
  22.430 +    LZOState *state = lzo_state(s);
  22.431 +    if(!LZOState_writeable(state)){
  22.432 +        n = -EINVAL;
  22.433 +        goto exit;
  22.434 +    }
  22.435 +    n = vsnprintf(buf, buf_n, (char*)msg, args);
  22.436 +    if(n < 0) goto exit;
  22.437 +    if(n > buf_n){
  22.438 +        n = 0;
  22.439 +    } else {
  22.440 +        n = lzo_write(s, buf, 1, n);
  22.441 +    }
  22.442 +  exit:
  22.443 +    return n;
  22.444 +}
  22.445 +
  22.446 +/** Read a character from the underlying stream
  22.447 + *
  22.448 + * @param s lzo stream
  22.449 + * @return character read, IOSTREAM_EOF on end of file (or error)
  22.450 + */
  22.451 +static int lzo_getc(IOStream *s){
  22.452 +    int err;
  22.453 +    char c;
  22.454 +    err = lzo_read(s, &c, 1, 1);
  22.455 +    if(err < 1) c = EOF;
  22.456 +    err = (c==EOF ? IOSTREAM_EOF : c);
  22.457 +    return err;
  22.458 +}
  22.459 +
  22.460 +/** Flush any pending input to the underlying stream.
  22.461 + *
  22.462 + * @param s lzo stream
  22.463 + * @return 0 on success, error code otherwise
  22.464 + */
  22.465 +static int lzo_flush(IOStream *s){
  22.466 +    int err = 0;
  22.467 +    LZOState *state = lzo_state(s);
  22.468 +    //dprintf(">\n");
  22.469 +#ifdef NOCOMPRESS
  22.470 +    err = IOStream_flush(state->io);
  22.471 +#else    
  22.472 +    if(!LZOState_writeable(state)){
  22.473 +        err = -EINVAL;
  22.474 +        goto exit;
  22.475 +    }
  22.476 +    if(state->plain_n){
  22.477 +        err = lzo_compress(state);
  22.478 +        if(err < 0) goto exit;
  22.479 +    }
  22.480 +    err = IOStream_flush(state->io);
  22.481 +  exit:
  22.482 +    set_error(state, err);
  22.483 +#endif
  22.484 +    //dprintf("< err=%d\n", err);
  22.485 +    return (err < 0 ? err : 0);
  22.486 +}
  22.487 +
  22.488 +/** Check if a stream has an error.
  22.489 + *
  22.490 + * @param s lzo stream
  22.491 + * @return code if has an error, 0 otherwise
  22.492 + */
  22.493 +static int lzo_error(IOStream *s){
  22.494 +    int err = 0;
  22.495 +    LZOState *state = lzo_state(s);
  22.496 +    err = state->error;
  22.497 +    if(err) goto exit;
  22.498 +    err = IOStream_error(state->io);
  22.499 +  exit:
  22.500 +    return err;
  22.501 +}
  22.502 +
  22.503 +int lzo_stream_finish(IOStream *s){
  22.504 +    int err = 0;
  22.505 +    LZOState *state = lzo_state(s);
  22.506 +    if(!LZOState_writeable(state)){
  22.507 +        err = -EINVAL;
  22.508 +        goto exit;
  22.509 +    }
  22.510 +    err = lzo_flush(s);
  22.511 +    if(err < 0) goto exit;
  22.512 +    err = marshal_int32(state->io, 0);
  22.513 +  exit:
  22.514 +    return err;
  22.515 +}        
  22.516 +
  22.517 +/** Close an lzo stream.
  22.518 + *
  22.519 + * @param s lzo stream to close
  22.520 + * @return result of the close
  22.521 + */
  22.522 +static int lzo_close(IOStream *s){
  22.523 +    int err = 0;
  22.524 +    LZOState *state = lzo_state(s);
  22.525 +#ifdef NOCOMPRESS
  22.526 +    err = IOStream_close(state->io);
  22.527 +#else    
  22.528 +    if(LZOState_writeable(state)){
  22.529 +        err = lzo_stream_finish(s);
  22.530 +    }        
  22.531 +    err = IOStream_close(state->io);
  22.532 +    set_error(state, err);
  22.533 +#endif
  22.534 +    return err;
  22.535 +}
  22.536 +
  22.537 +/** Free an lzo stream.
  22.538 + *
  22.539 + * @param s lzo stream
  22.540 + */
  22.541 +static void lzo_free(IOStream *s){
  22.542 +    LZOState *state = lzo_state(s);
  22.543 +    IOStream_free(state->io);
  22.544 +    LZOState_free(state);
  22.545 +    s->data = NULL;
  22.546 +}
  22.547 +
  22.548 +/** Create an lzo stream for an IOStream.
  22.549 + *
  22.550 + * @param io stream to wrap
  22.551 + * @return new IOStream using f for i/o
  22.552 + */
  22.553 +IOStream *lzo_stream_new(IOStream *io, const char *mode){
  22.554 +    int err = -ENOMEM;
  22.555 +    int flags = 0;
  22.556 +    IOStream *zio = NULL;
  22.557 +    LZOState *state = NULL;
  22.558 +
  22.559 +    zio = ALLOCATE(IOStream);
  22.560 +    if(!zio) goto exit;
  22.561 +    err = mode_flags(mode, &flags);
  22.562 +    if(err) goto exit;
  22.563 +    state = LZOState_new(io, flags);
  22.564 +    if(!state) goto exit;
  22.565 +    err = 0;
  22.566 +    zio->data = state;
  22.567 +    zio->methods = &lzo_methods;
  22.568 +  exit:
  22.569 +    if(err){
  22.570 +        if(state) LZOState_free(state);
  22.571 +        if(zio) deallocate(zio);
  22.572 +        zio = NULL;
  22.573 +    }
  22.574 +    return zio;
  22.575 +}
  22.576 +
  22.577 +/** IOStream version of fdopen().
  22.578 + *
  22.579 + * @param fd file descriptor
  22.580 + * @param flags giving the mode to open in (as for fdopen())
  22.581 + * @return new stream for the open file, or NULL if failed
  22.582 + */
  22.583 +IOStream *lzo_stream_fdopen(int fd, const char *mode){
  22.584 +    int err = -ENOMEM;
  22.585 +    IOStream *io = NULL, *zio = NULL;
  22.586 +    io = file_stream_fdopen(fd, mode);
  22.587 +    if(!io) goto exit;
  22.588 +    zio = lzo_stream_new(io, mode);
  22.589 +    if(!io) goto exit;
  22.590 +    err = 0;
  22.591 +  exit:
  22.592 +    if(err){
  22.593 +        IOStream_free(io);
  22.594 +        IOStream_free(zio);
  22.595 +        zio = NULL;
  22.596 +    }
  22.597 +    return zio;
  22.598 +}
  22.599 +#endif

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/tools/lib/lzo_stream.h	Mon Jun 28 15:03:15 2004 +0000
    23.3 @@ -0,0 +1,36 @@
    23.4 +#/* $Id: lzo_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    23.5 +/*
    23.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    23.7 + *
    23.8 + * This library is free software; you can redistribute it and/or modify
    23.9 + * it under the terms of the GNU Lesser General Public License as published by
   23.10 + * the Free Software Foundation; either version 2.1 of the License, or
   23.11 + * (at your option) any later version.
   23.12 + *
   23.13 + * This library is distributed in the hope that it will be useful,
   23.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   23.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   23.16 + * GNU Lesser General Public License for more details.
   23.17 + *
   23.18 + * You should have received a copy of the GNU Lesser General Public License
   23.19 + * along with this library; if not, write to the Free Software
   23.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   23.21 + */
   23.22 +
   23.23 +#ifndef _SP_LZO_STREAM_H_
   23.24 +#define _SP_LZO_STREAM_H_
   23.25 +
   23.26 +#ifndef __KERNEL__
   23.27 +#include "iostream.h"
   23.28 +
   23.29 +extern IOStream *lzo_stream_new(IOStream *io, const char *mode);
   23.30 +extern IOStream *lzo_stream_fopen(const char *file, const char *mode);
   23.31 +extern IOStream *lzo_stream_fdopen(int fd, const char *mode);
   23.32 +extern IOStream *lzo_stream_io(IOStream *zio);
   23.33 +
   23.34 +extern int lzo_stream_plain_bytes(IOStream *io);
   23.35 +extern int lzo_stream_comp_bytes(IOStream *io);
   23.36 +extern float lzo_stream_ratio(IOStream *io);
   23.37 +
   23.38 +#endif
   23.39 +#endif /* !_SP_FILE_STREAM_H_ */

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/tools/lib/marshal.c	Mon Jun 28 15:03:15 2004 +0000
    24.3 @@ -0,0 +1,207 @@
    24.4 +#include <errno.h>
    24.5 +#include "sys_net.h"
    24.6 +#include "allocate.h"
    24.7 +#include "marshal.h"
    24.8 +
    24.9 +#define dprintf(fmt, args...) IOStream_print(iostdout, "[DEBUG] %s" fmt, __FUNCTION__, ##args)
   24.10 +#define wprintf(fmt, args...) IOStream_print(iostderr, "[WARN]  %s" fmt, __FUNCTION__, ##args)
   24.11 +#define iprintf(fmt, args...) IOStream_print(iostdout, "[INFO]  %s" fmt, __FUNCTION__, ##args)
   24.12 +#define eprintf(fmt, args...) IOStream_print(iostderr, "[ERROR] %s" fmt, __FUNCTION__, ##args)
   24.13 +
   24.14 +
   24.15 +#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof((ary)[0]))
   24.16 +
   24.17 +/* Messages are coded as msgid followed by message fields.
   24.18 + * Initial message on any channel is hello - so can check version
   24.19 + * compatibility.
   24.20 + *
   24.21 + * char* -> uint16_t:n <n bytes>
   24.22 + * ints/uints go as suitable number of bytes (e.g. uint16_t is 2 bytes).
   24.23 + * optional fields go as '1' <val> or '0' (the 0/1 is 1 byte).
   24.24 + * lists go as ('1' <elt>)* '0'
   24.25 + */
   24.26 +
   24.27 +int marshal_flush(IOStream *io){
   24.28 +    int err  = 0;
   24.29 +    err = IOStream_flush(io);
   24.30 +    return err;
   24.31 +}
   24.32 +
   24.33 +int marshal_bytes(IOStream *io, void *s, uint32_t s_n){
   24.34 +    int err = 0;
   24.35 +    int n;
   24.36 +    n = IOStream_write(io, s, s_n);
   24.37 +    if(n < 0){
   24.38 +        err = n;
   24.39 +    } else if (n < s_n){
   24.40 +        wprintf("> Wanted %d, got %d\n", s_n, n);
   24.41 +        err = -EIO;
   24.42 +    }
   24.43 +    return err;
   24.44 +}
   24.45 +
   24.46 +int unmarshal_bytes(IOStream *io, void *s, uint32_t s_n){
   24.47 +    int err = 0;
   24.48 +    int n;
   24.49 +    //dprintf("> s_n=%d\n", s_n);
   24.50 +    n = IOStream_read(io, s, s_n);
   24.51 +    //dprintf("> n=%d\n", n);
   24.52 +    if(n < 0){
   24.53 +        err = n;
   24.54 +    } else if(n < s_n){
   24.55 +        wprintf("> Wanted %d, got %d\n", s_n, n);
   24.56 +        err = -EIO;
   24.57 +    }
   24.58 +    //dprintf("< err=%d\n", err);
   24.59 +    return err;
   24.60 +}
   24.61 +
   24.62 +int marshal_uint8(IOStream *io, uint8_t x){
   24.63 +    return marshal_bytes(io, &x, sizeof(x));
   24.64 +}
   24.65 +
   24.66 +int unmarshal_uint8(IOStream *io, uint8_t *x){
   24.67 +    return unmarshal_bytes(io, x, sizeof(*x));
   24.68 +}
   24.69 +
   24.70 +int marshal_uint16(IOStream *io, uint16_t x){
   24.71 +    x = htons(x);
   24.72 +    return marshal_bytes(io, &x, sizeof(x));
   24.73 +}
   24.74 +
   24.75 +int unmarshal_uint16(IOStream *io, uint16_t *x){
   24.76 +    int err = 0;
   24.77 +    err = unmarshal_bytes(io, x, sizeof(*x));
   24.78 +    *x = ntohs(*x);
   24.79 +    return err;
   24.80 +}
   24.81 +
   24.82 +int marshal_int32(IOStream *io, int32_t x){
   24.83 +    int err = 0;
   24.84 +    //dprintf("> x=%d\n", x);
   24.85 +    x = htonl(x);
   24.86 +    err = marshal_bytes(io, &x, sizeof(x));
   24.87 +    //dprintf("< err=%d\n", err);
   24.88 +    return err;
   24.89 +}
   24.90 +
   24.91 +int unmarshal_int32(IOStream *io, int32_t *x){
   24.92 +    int err = 0;
   24.93 +    //dprintf(">\n");
   24.94 +    err = unmarshal_bytes(io, x, sizeof(*x));
   24.95 +    *x = ntohl(*x);
   24.96 +    //dprintf("< err=%d x=%d\n", err, *x);
   24.97 +    return err;
   24.98 +}
   24.99 +
  24.100 +int marshal_uint32(IOStream *io, uint32_t x){
  24.101 +    int err = 0;
  24.102 +    //dprintf("> x=%u\n", x);
  24.103 +    x = htonl(x);
  24.104 +    err = marshal_bytes(io, &x, sizeof(x));
  24.105 +    //dprintf("< err=%d\n", err);
  24.106 +    return err;
  24.107 +}
  24.108 +
  24.109 +int unmarshal_uint32(IOStream *io, uint32_t *x){
  24.110 +    int err = 0;
  24.111 +    //dprintf(">\n");
  24.112 +    err = unmarshal_bytes(io, x, sizeof(*x));
  24.113 +    *x = ntohl(*x);
  24.114 +    //dprintf("< err=%d x=%u\n", err, *x);
  24.115 +    return err;
  24.116 +}
  24.117 +
  24.118 +int marshal_uint64(IOStream *io, uint64_t x){
  24.119 +    int err;
  24.120 +    err = marshal_uint32(io, (uint32_t) ((x >> 32) & 0xffffffff));
  24.121 +    if(err) goto exit;
  24.122 +    err = marshal_uint32(io, (uint32_t) ( x        & 0xffffffff));
  24.123 +  exit:
  24.124 +    return err;
  24.125 +}
  24.126 +
  24.127 +int unmarshal_uint64(IOStream *io, uint64_t *x){
  24.128 +    int err = 0;
  24.129 +    uint32_t hi, lo;
  24.130 +    err = unmarshal_uint32(io, &hi);
  24.131 +    if(err) goto exit;
  24.132 +    err = unmarshal_uint32(io, &lo);
  24.133 +    *x = (((uint64_t) hi) << 32) | lo;
  24.134 +  exit:
  24.135 +    return err;
  24.136 +}
  24.137 +
  24.138 +int marshal_net16(IOStream *io, net16_t x){
  24.139 +    return marshal_bytes(io, &x, sizeof(x));
  24.140 +}
  24.141 +
  24.142 +int unmarshal_net16(IOStream *io, net16_t *x){
  24.143 +    int err = 0;
  24.144 +    err = unmarshal_bytes(io, x, sizeof(*x));
  24.145 +    return err;
  24.146 +}
  24.147 +
  24.148 +int marshal_net32(IOStream *io, net32_t x){
  24.149 +    return marshal_bytes(io, &x, sizeof(x));
  24.150 +}
  24.151 +
  24.152 +int unmarshal_net32(IOStream *io, net32_t *x){
  24.153 +    int err = 0;
  24.154 +    err = unmarshal_bytes(io, x, sizeof(*x));
  24.155 +    return err;
  24.156 +}
  24.157 +
  24.158 +int marshal_string(IOStream *io, char *s, uint32_t s_n){
  24.159 +    int err;
  24.160 +    //dprintf("> s=%s\n", s);
  24.161 +    err = marshal_uint32(io, s_n);
  24.162 +    if(err) goto exit;
  24.163 +    err = marshal_bytes(io, s, s_n);
  24.164 +  exit:
  24.165 +    //dprintf("< err=%d\n", err);
  24.166 +    return err;
  24.167 +}
  24.168 +
  24.169 +int unmarshal_string(IOStream *io, char *s, uint32_t s_n){
  24.170 +    int err = 0, val_n = 0;
  24.171 +    //dprintf(">\n");
  24.172 +    err = unmarshal_uint32(io, &val_n);
  24.173 +    if(err) goto exit;
  24.174 +    if(val_n >= s_n){
  24.175 +        err = -EINVAL;
  24.176 +        goto exit;
  24.177 +    }
  24.178 +    err = unmarshal_bytes(io, s, val_n);
  24.179 +    if(err) goto exit;
  24.180 +    s[val_n] = '\0';
  24.181 +  exit:
  24.182 +    //dprintf("< err=%d s=%s\n", err, s);
  24.183 +    return err;
  24.184 +}
  24.185 +
  24.186 +int unmarshal_new_string(IOStream *io, char **s, uint32_t *s_n){
  24.187 +    int err = 0, val_n = 0;
  24.188 +    char *val = NULL;
  24.189 +    //dprintf(">\n");
  24.190 +    err = unmarshal_uint32(io, &val_n);
  24.191 +    if(err) goto exit;
  24.192 +    val = allocate(val_n + 1);
  24.193 +    if(!val){
  24.194 +        err = -ENOMEM;
  24.195 +        goto exit;
  24.196 +    }
  24.197 +    err = unmarshal_bytes(io, val, val_n);
  24.198 +    if(err) goto exit;
  24.199 +    val[val_n] = '\0';
  24.200 +  exit:
  24.201 +    if(err){
  24.202 +        if(val) deallocate(val);
  24.203 +        val = NULL;
  24.204 +        val_n = 0;
  24.205 +    }
  24.206 +    *s = val;
  24.207 +    if(s_n) *s_n = val_n;
  24.208 +    //dprintf("< err=%d s=%s\n", err, *s);
  24.209 +    return err;
  24.210 +}