1.1 --- a/.rootkeys	Tue Jun 29 00:51:10 2004 +0000
     1.2 +++ b/.rootkeys	Tue Jun 29 12:05:29 2004 +0000
     1.3 @@ -164,6 +164,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	Tue Jun 29 00:51:10 2004 +0000
     2.2 +++ b/BitKeeper/etc/ignore	Tue Jun 29 12:05:29 2004 +0000
     2.3 @@ -3,8 +3,8 @@
     2.4  *.pyc
     2.5  *.so
     2.6  *.so.*
     2.7 +*.tar.bz2
     2.8  *.tar.gz
     2.9 -*.tar.bz2
    2.10  *~
    2.11  BitKeeper/*/*
    2.12  PENDING/*
    2.13 @@ -12,15 +12,34 @@ TAGS
    2.14  extras/mini-os/h/hypervisor-ifs
    2.15  install
    2.16  install/*
    2.17 +linux-*-xen*/*
    2.18 +linux-2.4.26-xen/*
    2.19 +linux-xen-sparse
    2.20  patches/*
    2.21 -linux-*-xen*/*
    2.22 -linux-xen-sparse
    2.23  tools/*/build/lib*/*.py
    2.24  tools/balloon/balloon
    2.25  tools/misc/miniterm/miniterm
    2.26  tools/misc/xen_cpuperf
    2.27  tools/misc/xen_log
    2.28  tools/misc/xen_read_console
    2.29 +tools/xc/lib/.allocate.o.d
    2.30 +tools/xc/lib/.file_stream.o.d
    2.31 +tools/xc/lib/.gzip_stream.o.d
    2.32 +tools/xc/lib/.iostream.o.d
    2.33 +tools/xc/lib/.sys_net.o.d
    2.34 +tools/xc/lib/.sys_string.o.d
    2.35 +tools/xc/lib/.xc_atropos.o.d
    2.36 +tools/xc/lib/.xc_bvtsched.o.d
    2.37 +tools/xc/lib/.xc_domain.o.d
    2.38 +tools/xc/lib/.xc_evtchn.o.d
    2.39 +tools/xc/lib/.xc_io.o.d
    2.40 +tools/xc/lib/.xc_linux_build.o.d
    2.41 +tools/xc/lib/.xc_linux_restore.o.d
    2.42 +tools/xc/lib/.xc_linux_save.o.d
    2.43 +tools/xc/lib/.xc_misc.o.d
    2.44 +tools/xc/lib/.xc_netbsd_build.o.d
    2.45 +tools/xc/lib/.xc_physdev.o.d
    2.46 +tools/xc/lib/.xc_private.o.d
    2.47  tools/xentrace/xentrace
    2.48  xen/drivers/pci/classlist.h
    2.49  xen/drivers/pci/devlist.h

     3.1 --- a/tools/examples/xmdefaults	Tue Jun 29 00:51:10 2004 +0000
     3.2 +++ b/tools/examples/xmdefaults	Tue Jun 29 12:05:29 2004 +0000
     3.3 @@ -5,9 +5,6 @@
     3.4  # This file expects the variable 'vmid' to be set.
     3.5  #============================================================================
     3.6  
     3.7 -import sys
     3.8 -import xenctl.ip
     3.9 -
    3.10  try:
    3.11      vmid = int(vmid) # convert to integer
    3.12  except:

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/tools/lib/allocate.c	Tue Jun 29 12:05:29 2004 +0000
     4.3 @@ -0,0 +1,116 @@
     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 +#include "allocate.h"
    4.23 +
    4.24 +/** @file
    4.25 + * Support for allocating memory.
    4.26 + * Usable from user code or kernel code (with __KERNEL__ defined).
    4.27 + * In user code will use GC if USE_GC is defined.
    4.28 + */
    4.29 +
    4.30 +#ifdef __KERNEL__
    4.31 +/*----------------------------------------------------------------------------*/
    4.32 +#  include <linux/config.h>
    4.33 +#  include <linux/slab.h>
    4.34 +#  include <linux/string.h>
    4.35 +#  include <linux/types.h>
    4.36 +
    4.37 +#  define DEFAULT_TYPE    0
    4.38 +#  define MALLOC(n, type) kmalloc(n, type)
    4.39 +#  define FREE(ptr)       kfree(ptr)
    4.40 +
    4.41 +/*----------------------------------------------------------------------------*/
    4.42 +#else /* ! __KERNEL__ */
    4.43 +
    4.44 +#  include <stdlib.h>
    4.45 +#  include <string.h>
    4.46 +
    4.47 +#  define DEFAULT_TYPE    0
    4.48 +
    4.49 +#ifdef USE_GC
    4.50 +#  include "gc.h"
    4.51 +#  define MALLOC(n, typ)  GC_malloc(n)
    4.52 +#  define FREE(ptr)       (ptr=NULL)
    4.53 +//typedef void *GC_PTR;
    4.54 +//GC_PTR (*GC_oom_fn)(size_t n);
    4.55 +#else
    4.56 +#  define MALLOC(n, type) malloc(n)
    4.57 +#  define FREE(ptr)       free(ptr)
    4.58 +#endif
    4.59 +
    4.60 +/*----------------------------------------------------------------------------*/
    4.61 +#endif
    4.62 +
    4.63 +/** Function to call when memory cannot be allocated. */
    4.64 +AllocateFailedFn *allocate_failed_fn = NULL;
    4.65 +
    4.66 +/** Allocate memory and zero it.
    4.67 + * The type is only relevant when calling from kernel code,
    4.68 + * from user code it is ignored.
    4.69 + * In kernel code the values accepted by kmalloc can be used:
    4.70 + * GFP_USER, GFP_ATOMIC, GFP_KERNEL.
    4.71 + *
    4.72 + * @param size number of bytes to allocate
    4.73 + * @param type memory type to allocate (kernel only)
    4.74 + * @return pointer to the allocated memory or zero
    4.75 + * if malloc failed
    4.76 + */
    4.77 +void *allocate_type(int size, int type){
    4.78 +    void *p = MALLOC(size, type);
    4.79 +    if(p){
    4.80 +        memzero(p, size);
    4.81 +    } else if(allocate_failed_fn){
    4.82 +        allocate_failed_fn(size, type);
    4.83 +    }
    4.84 +    return p;
    4.85 +}
    4.86 +
    4.87 +/** Allocate memory and zero it.
    4.88 + *
    4.89 + * @param size number of bytes to allocate
    4.90 + * @return pointer to the allocated memory or zero
    4.91 + * if malloc failed
    4.92 + */
    4.93 +void *allocate(int size){
    4.94 +    return allocate_type(size, DEFAULT_TYPE);
    4.95 +}
    4.96 +
    4.97 +/** Free memory allocated by allocate().
    4.98 + * No-op if 'p' is null.
    4.99 + *
   4.100 + * @param p memory to free
   4.101 + */
   4.102 +void deallocate(void *p){
   4.103 +    if(p){
   4.104 +        FREE(p);
   4.105 +    }
   4.106 +}
   4.107 +
   4.108 +/** Set bytes to zero.
   4.109 + * No-op if 'p' is null.
   4.110 + *
   4.111 + * @param p memory to zero
   4.112 + * @param size number of bytes to zero
   4.113 + */
   4.114 +void memzero(void *p, int size){
   4.115 +    if(p){
   4.116 +        memset(p, 0, (size_t)size);
   4.117 +    }
   4.118 +}
   4.119 +

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/tools/lib/allocate.h	Tue Jun 29 12:05:29 2004 +0000
     5.3 @@ -0,0 +1,45 @@
     5.4 +/*
     5.5 + * Copyright (C) 2001 - 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 +
    5.22 +#ifndef _XEN_LIB_ALLOCATE_H_
    5.23 +#define _XEN_LIB_ALLOCATE_H_
    5.24 +
    5.25 +/** Allocate memory for a given type, and cast. */
    5.26 +#define ALLOCATE(ctype) (ctype *)allocate(sizeof(ctype))
    5.27 +
    5.28 +/** Allocate memory for a given type, and cast. */
    5.29 +#define ALLOCATE_TYPE(ctype, type) (ctype *)allocate(sizeof(ctype))
    5.30 +
    5.31 +extern void *allocate_type(int size, int type);
    5.32 +extern void *allocate(int size);
    5.33 +extern void deallocate(void *);
    5.34 +extern void memzero(void *p, int size);
    5.35 +
    5.36 +typedef void AllocateFailedFn(int size, int type);
    5.37 +extern AllocateFailedFn *allocate_failed_fn;
    5.38 +
    5.39 +#endif /* _XEN_LIB_ALLOCATE_H_ */
    5.40 +
    5.41 +
    5.42 +
    5.43 +
    5.44 +
    5.45 +
    5.46 +
    5.47 +
    5.48 +

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/tools/lib/debug.h	Tue Jun 29 12:05:29 2004 +0000
     6.3 @@ -0,0 +1,72 @@
     6.4 +/*
     6.5 + * Copyright (C) 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 published by
     6.9 + * the Free Software Foundation; either version 2.1 of the License, or
    6.10 + * (at your option) any later version.
    6.11 + *
    6.12 + * This library is distributed in the hope that it will be useful,
    6.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6.15 + * GNU Lesser General Public License for more details.
    6.16 + *
    6.17 + * You should have received a copy of the GNU Lesser General Public License
    6.18 + * along with this library; if not, write to the Free Software
    6.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    6.20 + */
    6.21 +#ifndef _XEN_LIB_DEBUG_H_
    6.22 +#define _XEN_LIB_DEBUG_H_
    6.23 +
    6.24 +#ifndef MODULE_NAME
    6.25 +#define MODULE_NAME ""
    6.26 +#endif
    6.27 +
    6.28 +#ifdef __KERNEL__
    6.29 +#include <linux/config.h>
    6.30 +#include <linux/kernel.h>
    6.31 +
    6.32 +#ifdef DEBUG
    6.33 +
    6.34 +#define dprintf(fmt, args...) printk(KERN_DEBUG   "[DBG] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.35 +#define wprintf(fmt, args...) printk(KERN_WARNING "[WRN] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.36 +#define iprintf(fmt, args...) printk(KERN_INFO    "[INF] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.37 +#define eprintf(fmt, args...) printk(KERN_ERR     "[ERR] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.38 +
    6.39 +#else
    6.40 +
    6.41 +#define dprintf(fmt, args...) do {} while(0)
    6.42 +#define wprintf(fmt, args...) printk(KERN_WARNING "[WRN] " MODULE_NAME fmt, ##args)
    6.43 +#define iprintf(fmt, args...) printk(KERN_INFO    "[INF] " MODULE_NAME fmt, ##args)
    6.44 +#define eprintf(fmt, args...) printk(KERN_ERR     "[ERR] " MODULE_NAME fmt, ##args)
    6.45 +
    6.46 +#endif
    6.47 +
    6.48 +#else
    6.49 +
    6.50 +#include <stdio.h>
    6.51 +
    6.52 +#ifdef DEBUG
    6.53 +
    6.54 +#define dprintf(fmt, args...) fprintf(stdout, "[DBG] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.55 +#define wprintf(fmt, args...) fprintf(stderr, "[WRN] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.56 +#define iprintf(fmt, args...) fprintf(stderr, "[INF] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.57 +#define eprintf(fmt, args...) fprintf(stderr, "[ERR] " MODULE_NAME ">%s" fmt, __FUNCTION__, ##args)
    6.58 +
    6.59 +#else
    6.60 +
    6.61 +#define dprintf(fmt, args...) do {} while(0)
    6.62 +#define wprintf(fmt, args...) fprintf(stderr, "[WRN] " MODULE_NAME fmt, ##args)
    6.63 +#define iprintf(fmt, args...) fprintf(stderr, "[INF] " MODULE_NAME fmt, ##args)
    6.64 +#define eprintf(fmt, args...) fprintf(stderr, "[ERR] " MODULE_NAME fmt, ##args)
    6.65 +
    6.66 +#endif
    6.67 +
    6.68 +#endif
    6.69 +
    6.70 +/** Print format for an IP address.
    6.71 + * See NIPQUAD(), HIPQUAD()
    6.72 + */
    6.73 +#define IPFMT "%u.%u.%u.%u"
    6.74 +
    6.75 +#endif /* ! _XEN_LIB_DEBUG_H_ */

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/tools/lib/enum.c	Tue Jun 29 12:05:29 2004 +0000
     7.3 @@ -0,0 +1,61 @@
     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 +#ifdef __KERNEL__
    7.22 +#include <linux/errno.h>
    7.23 +#else
    7.24 +#include <errno.h>
    7.25 +#endif
    7.26 +
    7.27 +#include "sys_string.h"
    7.28 +#include "enum.h"
    7.29 +
    7.30 +/** Map an enum name to its value using a table.
    7.31 + *
    7.32 + * @param name enum name
    7.33 + * @param defs enum definitions
    7.34 + * @return enum value or -1 if not known
    7.35 + */
    7.36 +int enum_name_to_val(char *name, EnumDef *defs){
    7.37 +    int val = -1;
    7.38 +    for(; defs->name; defs++){
    7.39 +	if(!strcmp(defs->name, name)){
    7.40 +	    val = defs->val;
    7.41 +	    break;
    7.42 +	}
    7.43 +    }
    7.44 +    return val;
    7.45 +}
    7.46 +
    7.47 +/** Map an enum value to its name using a table.
    7.48 + *
    7.49 + * @param val enum value
    7.50 + * @param defs enum definitions
    7.51 + * @param defs_n number of definitions
    7.52 + * @return enum name or NULL if not known
    7.53 + */
    7.54 +char *enum_val_to_name(int val, EnumDef *defs){
    7.55 +    char *name = NULL;
    7.56 +    for(; defs->name; defs++){
    7.57 +	if(val == defs->val){
    7.58 +	    name = defs->name;
    7.59 +	    break;
    7.60 +	}
    7.61 +    }
    7.62 +    return name;
    7.63 +}
    7.64 +

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/tools/lib/enum.h	Tue Jun 29 12:05:29 2004 +0000
     8.3 @@ -0,0 +1,30 @@
     8.4 +/*
     8.5 + * Copyright (C) 2002, 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
     8.9 + * published by the Free Software Foundation; either version 2.1 of the
    8.10 + * License, or  (at your option) any later version. This library is 
    8.11 + * distributed in the  hope that it will be useful, but WITHOUT ANY
    8.12 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.13 + * FITNESS FOR A PARTICULAR PURPOSE.
    8.14 + * See the GNU Lesser General Public License for more details.
    8.15 + *
    8.16 + * You should have received a copy of the GNU Lesser General Public License
    8.17 + * along with this library; if not, write to the Free Software Foundation,
    8.18 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    8.19 + */
    8.20 +
    8.21 +#ifndef _XEN_LIB_ENUM_H_
    8.22 +#define _XEN_LIB_ENUM_H_
    8.23 +
    8.24 +/** Mapping of an enum value to a name. */
    8.25 +typedef struct EnumDef {
    8.26 +    int val;
    8.27 +    char *name;
    8.28 +} EnumDef;
    8.29 +
    8.30 +extern int enum_name_to_val(char *name, EnumDef *defs);
    8.31 +extern char *enum_val_to_name(int val, EnumDef *defs);
    8.32 +
    8.33 +#endif /* _XEN_LIB_ENUM_H_ */

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/tools/lib/file_stream.c	Tue Jun 29 12:05:29 2004 +0000
     9.3 @@ -0,0 +1,202 @@
     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 +/** @file
    9.23 + * An IOStream implementation using FILE*.
    9.24 + */
    9.25 +#ifndef __KERNEL__
    9.26 +#include <stdio.h>
    9.27 +#include <stdlib.h>
    9.28 +#include "allocate.h"
    9.29 +#include "file_stream.h"
    9.30 +
    9.31 +static int file_read(IOStream *s, void *buf, size_t n);
    9.32 +static int file_write(IOStream *s, const void *buf, size_t n);
    9.33 +static int file_error(IOStream *s);
    9.34 +static int file_close(IOStream *s);
    9.35 +static void file_free(IOStream *s);
    9.36 +static int file_flush(IOStream *s);
    9.37 +
    9.38 +/** Methods used by a FILE* IOStream. */
    9.39 +static const IOMethods file_methods = {
    9.40 +    read:  file_read,
    9.41 +    write: file_write,
    9.42 +    error: file_error,
    9.43 +    close: file_close,
    9.44 +    free:  file_free,
    9.45 +    flush: file_flush,
    9.46 +};
    9.47 +
    9.48 +/** IOStream for stdin. */
    9.49 +static IOStream _iostdin = {
    9.50 +    methods: &file_methods,
    9.51 +    data: (void*)1,
    9.52 +};
    9.53 +
    9.54 +/** IOStream for stdout. */
    9.55 +static IOStream _iostdout = {
    9.56 +    methods: &file_methods,
    9.57 +    data: (void*)2,
    9.58 +};
    9.59 +
    9.60 +/** IOStream for stderr. */
    9.61 +static IOStream _iostderr = {
    9.62 +    methods: &file_methods,
    9.63 +    data: (void*)3,
    9.64 +};
    9.65 +
    9.66 +/** IOStream for stdin. */
    9.67 +IOStream *iostdin = &_iostdin;
    9.68 +
    9.69 +/** IOStream for stdout. */
    9.70 +IOStream *iostdout = &_iostdout;
    9.71 +
    9.72 +/** IOStream for stderr. */
    9.73 +IOStream *iostderr = &_iostderr;
    9.74 +
    9.75 +/** Get the underlying FILE*.
    9.76 + * 
    9.77 + * @param s file stream
    9.78 + * @return the stream s wraps
    9.79 + */
    9.80 +static inline FILE *get_file(IOStream *s){
    9.81 +    switch((long)s->data){
    9.82 +    case 1: s->data = stdin; break;
    9.83 +    case 2: s->data = stdout; break;
    9.84 +    case 3: s->data = stderr; break;
    9.85 +    }
    9.86 +    return (FILE*)s->data;
    9.87 +}
    9.88 +
    9.89 +/** Control buffering on the underlying stream, like setvbuf().
    9.90 + *
    9.91 + * @param io file stream
    9.92 + * @param buf buffer
    9.93 + * @param mode buffering mode (see man setvbuf())
    9.94 + * @param size buffer size
    9.95 + * @return 0 on success, non-zero otherwise
    9.96 + */
    9.97 +int file_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size){
    9.98 +    return setvbuf(get_file(io), buf, mode, size);
    9.99 +}
   9.100 +
   9.101 +/** Write to the underlying stream using fwrite();
   9.102 + *
   9.103 + * @param stream input
   9.104 + * @param buf where to put input
   9.105 + * @param n number of bytes to write
   9.106 + * @return number of bytes written
   9.107 + */
   9.108 +static int file_write(IOStream *s, const void *buf, size_t n){
   9.109 +    return fwrite(buf, 1, n, get_file(s));
   9.110 +}
   9.111 +
   9.112 +/** Read from the underlying stream using fread();
   9.113 + *
   9.114 + * @param stream input
   9.115 + * @param buf where to put input
   9.116 + * @param n number of bytes to read
   9.117 + * @return number of bytes read
   9.118 + */
   9.119 +static int file_read(IOStream *s, void *buf, size_t n){
   9.120 +    return fread(buf, 1, n, get_file(s));
   9.121 +}
   9.122 +
   9.123 +/** Fush the underlying stream using fflush().
   9.124 + *
   9.125 + * @param s file stream
   9.126 + * @return 0 on success, error code otherwise
   9.127 + */
   9.128 +static int file_flush(IOStream *s){
   9.129 +    return fflush(get_file(s));
   9.130 +}
   9.131 +
   9.132 +/** Check if a stream has an error.
   9.133 + *
   9.134 + * @param s file stream
   9.135 + * @return 1 if has an error, 0 otherwise
   9.136 + */
   9.137 +static int file_error(IOStream *s){
   9.138 +    return ferror(get_file(s));
   9.139 +}
   9.140 +
   9.141 +/** Close a file stream.
   9.142 + *
   9.143 + * @param s file stream to close
   9.144 + * @return result of the close
   9.145 + */
   9.146 +static int file_close(IOStream *s){
   9.147 +    return fclose(get_file(s));
   9.148 +}
   9.149 +
   9.150 +/** Free a file stream.
   9.151 + *
   9.152 + * @param s file stream
   9.153 + */
   9.154 +static void file_free(IOStream *s){
   9.155 +    // Do nothing - fclose does it all?
   9.156 +}
   9.157 +
   9.158 +/** Create an IOStream for a stream.
   9.159 + *
   9.160 + * @param f stream to wrap
   9.161 + * @return new IOStream using f for i/o
   9.162 + */
   9.163 +IOStream *file_stream_new(FILE *f){
   9.164 +    IOStream *io = ALLOCATE(IOStream);
   9.165 +    if(io){
   9.166 +	io->methods = &file_methods;
   9.167 +	io->data = (void*)f;
   9.168 +    }
   9.169 +    return io;
   9.170 +}
   9.171 +
   9.172 +/** IOStream version of fopen().
   9.173 + *
   9.174 + * @param file name of the file to open
   9.175 + * @param flags giving the mode to open in (as for fopen())
   9.176 + * @return new stream for the open file, or 0 if failed
   9.177 + */
   9.178 +IOStream *file_stream_fopen(const char *file, const char *flags){
   9.179 +    IOStream *io = 0;
   9.180 +    FILE *fin = fopen(file, flags);
   9.181 +    if(fin){
   9.182 +	io = file_stream_new(fin);
   9.183 +	if(!io){
   9.184 +	    fclose(fin);
   9.185 +	    //free(fin); // fclose frees ?
   9.186 +	}
   9.187 +    }
   9.188 +    return io;
   9.189 +}
   9.190 +
   9.191 +/** IOStream version of fdopen().
   9.192 + *
   9.193 + * @param fd file descriptor
   9.194 + * @param flags giving the mode to open in (as for fdopen())
   9.195 + * @return new stream for the open file, or 0 if failed
   9.196 + */
   9.197 +IOStream *file_stream_fdopen(int fd, const char *flags){
   9.198 +    IOStream *io = 0;
   9.199 +    FILE *fin = fdopen(fd, flags);
   9.200 +    if(fin){
   9.201 +	io = file_stream_new(fin);
   9.202 +    }
   9.203 +    return io;
   9.204 +}
   9.205 +#endif

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/tools/lib/file_stream.h	Tue Jun 29 12:05:29 2004 +0000
    10.3 @@ -0,0 +1,35 @@
    10.4 +/*
    10.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    10.6 + *
    10.7 + * This library is free software; you can redistribute it and/or modify
    10.8 + * it under the terms of the GNU Lesser General Public License as published by
    10.9 + * the Free Software Foundation; either version 2.1 of the License, or
   10.10 + * (at your option) any later version.
   10.11 + *
   10.12 + * This library is distributed in the hope that it will be useful,
   10.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.15 + * GNU Lesser General Public License for more details.
   10.16 + *
   10.17 + * You should have received a copy of the GNU Lesser General Public License
   10.18 + * along with this library; if not, write to the Free Software
   10.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   10.20 + */
   10.21 +
   10.22 +#ifndef _XEN_LIB_FILE_STREAM_H_
   10.23 +#define _XEN_LIB_FILE_STREAM_H_
   10.24 +
   10.25 +#ifndef __KERNEL__
   10.26 +#include "iostream.h"
   10.27 +#include <stdio.h>
   10.28 +
   10.29 +extern IOStream *file_stream_new(FILE *f);
   10.30 +extern IOStream *file_stream_fopen(const char *file, const char *flags);
   10.31 +extern IOStream *file_stream_fdopen(int fd, const char *flags);
   10.32 +extern IOStream get_stream_stdout(void);
   10.33 +extern IOStream get_stream_stderr(void);
   10.34 +extern IOStream get_stream_stdin(void);
   10.35 +
   10.36 +extern int file_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size);
   10.37 +#endif
   10.38 +#endif /* !_XEN_LIB_FILE_STREAM_H_ */

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/tools/lib/gzip_stream.c	Tue Jun 29 12:05:29 2004 +0000
    11.3 @@ -0,0 +1,171 @@
    11.4 +/* $Id: gzip_stream.c,v 1.4 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 +/** @file
   11.24 + * An IOStream implementation using zlib gzFile to provide
   11.25 + * compression and decompression.
   11.26 + */
   11.27 +#ifndef __KERNEL__
   11.28 +
   11.29 +#include <stdio.h>
   11.30 +#include <stdlib.h>
   11.31 +
   11.32 +#include "zlib.h"
   11.33 +
   11.34 +#include "allocate.h"
   11.35 +#include "gzip_stream.h"
   11.36 +
   11.37 +static int gzip_read(IOStream *s, void *buf, size_t n);
   11.38 +static int gzip_write(IOStream *s, const void *buf, size_t n);
   11.39 +static int gzip_error(IOStream *s);
   11.40 +static int gzip_close(IOStream *s);
   11.41 +static void gzip_free(IOStream *s);
   11.42 +static int gzip_flush(IOStream *s);
   11.43 +
   11.44 +/** Methods used by a gzFile* IOStream. */
   11.45 +static const IOMethods gzip_methods = {
   11.46 +    read: gzip_read,
   11.47 +    write: gzip_write,
   11.48 +    error: gzip_error,
   11.49 +    close: gzip_close,
   11.50 +    free:  gzip_free,
   11.51 +    flush: gzip_flush,
   11.52 +};
   11.53 +
   11.54 +/** Get the underlying gzFile*.
   11.55 + * 
   11.56 + * @param s gzip stream
   11.57 + * @return the stream s wraps
   11.58 + */
   11.59 +static inline gzFile get_gzfile(IOStream *s){
   11.60 +    return (gzFile)s->data;
   11.61 +}
   11.62 +
   11.63 +/** Write to the underlying stream.
   11.64 + *
   11.65 + * @param stream destination
   11.66 + * @param buf data
   11.67 + * @param n number of bytes to write
   11.68 + * @return number of bytes written
   11.69 + */
   11.70 +static int gzip_write(IOStream *s, const void *buf, size_t n){
   11.71 +    return gzwrite(get_gzfile(s), (void*)buf, n);
   11.72 +}
   11.73 +
   11.74 +/** Read from the underlying stream.
   11.75 + *
   11.76 + * @param stream input
   11.77 + * @param buf where to put input
   11.78 + * @param n number of bytes to read
   11.79 + * @return number of bytes read
   11.80 + */
   11.81 +static int gzip_read(IOStream *s, void *buf, size_t n){
   11.82 +    return gzread(get_gzfile(s), buf, n);
   11.83 +}
   11.84 +
   11.85 +/** Flush the underlying stream.
   11.86 + *
   11.87 + * @param s gzip stream
   11.88 + * @return 0 on success, error code otherwise
   11.89 + */
   11.90 +static int gzip_flush(IOStream *s){
   11.91 +    //return gzflush(get_gzfile(s), Z_NO_FLUSH);
   11.92 +    return gzflush(get_gzfile(s), Z_SYNC_FLUSH);
   11.93 +    //return gzflush(get_gzfile(s), Z_FULL_FLUSH);
   11.94 +}
   11.95 +
   11.96 +/** Check if a stream has an error.
   11.97 + *
   11.98 + * @param s gzip stream
   11.99 + * @return 1 if has an error, 0 otherwise
  11.100 + */
  11.101 +static int gzip_error(IOStream *s){
  11.102 +    int err;
  11.103 +    gzFile *gz = get_gzfile(s);
  11.104 +    gzerror(gz, &err);
  11.105 +    return (err == Z_ERRNO ? 1 /* ferror(gzfile(gz)) */ : err);
  11.106 +}
  11.107 +
  11.108 +/** Close a gzip stream.
  11.109 + *
  11.110 + * @param s gzip stream to close
  11.111 + * @return result of the close
  11.112 + */
  11.113 +static int gzip_close(IOStream *s){
  11.114 +    return gzclose(get_gzfile(s));
  11.115 +}
  11.116 +
  11.117 +/** Free a gzip stream.
  11.118 + *
  11.119 + * @param s gzip stream
  11.120 + */
  11.121 +static void gzip_free(IOStream *s){
  11.122 +    // Do nothing - fclose does it all?
  11.123 +}
  11.124 +
  11.125 +/** Create an IOStream for a gzip stream.
  11.126 + *
  11.127 + * @param f stream to wrap
  11.128 + * @return new IOStream using f for i/o
  11.129 + */
  11.130 +IOStream *gzip_stream_new(gzFile *f){
  11.131 +    IOStream *io = ALLOCATE(IOStream);
  11.132 +    if(io){
  11.133 +	io->methods = &gzip_methods;
  11.134 +	io->data = (void*)f;
  11.135 +    }
  11.136 +    return io;
  11.137 +}
  11.138 +
  11.139 +/** IOStream version of fopen().
  11.140 + *
  11.141 + * @param file name of the file to open
  11.142 + * @param flags giving the mode to open in (as for fopen())
  11.143 + * @return new stream for the open file, or NULL if failed
  11.144 + */
  11.145 +IOStream *gzip_stream_fopen(const char *file, const char *flags){
  11.146 +    IOStream *io = NULL;
  11.147 +    gzFile *fgz;
  11.148 +    fgz = gzopen(file, flags);
  11.149 +    if(fgz){
  11.150 +	io = gzip_stream_new(fgz);
  11.151 +	if(!io){
  11.152 +	    gzclose(fgz);
  11.153 +	    //free(fgz); // gzclose frees ?
  11.154 +	}
  11.155 +    }
  11.156 +    return io;
  11.157 +}
  11.158 +
  11.159 +/** IOStream version of fdopen().
  11.160 + *
  11.161 + * @param fd file descriptor
  11.162 + * @param flags giving the mode to open in (as for fdopen())
  11.163 + * @return new stream for the open file, or NULL if failed
  11.164 + */
  11.165 +IOStream *gzip_stream_fdopen(int fd, const char *flags){
  11.166 +    IOStream *io = NULL;
  11.167 +    gzFile *fgz;
  11.168 +    fgz = gzdopen(fd, flags);
  11.169 +    if(fgz){
  11.170 +	io = gzip_stream_new(fgz);
  11.171 +    }
  11.172 +    return io;
  11.173 +}
  11.174 +#endif

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/tools/lib/gzip_stream.h	Tue Jun 29 12:05:29 2004 +0000
    12.3 @@ -0,0 +1,31 @@
    12.4 +#/* $Id: gzip_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    12.5 +/*
    12.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    12.7 + *
    12.8 + * This library is free software; you can redistribute it and/or modify
    12.9 + * it under the terms of the GNU Lesser General Public License as published by
   12.10 + * the Free Software Foundation; either version 2.1 of the License, or
   12.11 + * (at your option) any later version.
   12.12 + *
   12.13 + * This library is distributed in the hope that it will be useful,
   12.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.16 + * GNU Lesser General Public License for more details.
   12.17 + *
   12.18 + * You should have received a copy of the GNU Lesser General Public License
   12.19 + * along with this library; if not, write to the Free Software
   12.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   12.21 + */
   12.22 +
   12.23 +#ifndef _SP_GZIP_STREAM_H_
   12.24 +#define _SP_GZIP_STREAM_H_
   12.25 +
   12.26 +#ifndef __KERNEL__
   12.27 +#include "iostream.h"
   12.28 +#include "zlib.h"
   12.29 +
   12.30 +extern IOStream *gzip_stream_new(gzFile *f);
   12.31 +extern IOStream *gzip_stream_fopen(const char *file, const char *flags);
   12.32 +extern IOStream *gzip_stream_fdopen(int fd, const char *flags);
   12.33 +#endif
   12.34 +#endif /* !_SP_FILE_STREAM_H_ */

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/tools/lib/hash_table.c	Tue Jun 29 12:05:29 2004 +0000
    13.3 @@ -0,0 +1,640 @@
    13.4 +/*
    13.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    13.6 + *
    13.7 + * This library is free software; you can redistribute it and/or modify
    13.8 + * it under the terms of the GNU Lesser General Public License as published by
    13.9 + * the Free Software Foundation; either version 2.1 of the License, or
   13.10 + * (at your option) any later version.
   13.11 + *
   13.12 + * This library is distributed in the hope that it will be useful,
   13.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   13.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13.15 + * GNU Lesser General Public License for more details.
   13.16 + *
   13.17 + * You should have received a copy of the GNU Lesser General Public License
   13.18 + * along with this library; if not, write to the Free Software
   13.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   13.20 + */
   13.21 +
   13.22 +#ifdef __KERNEL__
   13.23 +#  include <linux/config.h>
   13.24 +#  include <linux/module.h>
   13.25 +#  include <linux/kernel.h>
   13.26 +#  include <linux/errno.h>
   13.27 +#else
   13.28 +#  include <errno.h>
   13.29 +#  include <stddef.h>
   13.30 +#endif
   13.31 +
   13.32 +//#include <limits.h>
   13.33 +
   13.34 +#include "allocate.h"
   13.35 +#include "hash_table.h"
   13.36 +
   13.37 +/** @file
   13.38 + * Base support for hashtables.
   13.39 + *
   13.40 + * Hash codes are reduced modulo the number of buckets to index tables,
   13.41 + * so there is no need for hash functions to limit the range of hashcodes.
   13.42 + * In fact it is assumed that hashcodes do not change when the number of
   13.43 + * buckets in the table changes.
   13.44 + */
   13.45 +
   13.46 +/*==========================================================================*/
   13.47 +/** Number of bits in half a word. */
   13.48 +//#if __WORDSIZE == 64
   13.49 +//#define HALF_WORD_BITS 32
   13.50 +//#else
   13.51 +#define HALF_WORD_BITS 16
   13.52 +//#endif
   13.53 +
   13.54 +/** Mask for lo half of a word. On 32-bit this is 
   13.55 + * (1<<16) - 1 = 65535 = 0xffff
   13.56 + * It's 4294967295 = 0xffffffff on 64-bit.
   13.57 + */
   13.58 +#define LO_HALF_MASK ((1 << HALF_WORD_BITS) - 1)
   13.59 +
   13.60 +/** Get the lo half of a word. */
   13.61 +#define LO_HALF(x) ((x) & LO_HALF_MASK)
   13.62 +
   13.63 +/** Get the hi half of a word. */
   13.64 +#define HI_HALF(x) ((x) >> HALF_WORD_BITS)
   13.65 +
   13.66 +/** Do a full hash on both inputs, using DES-style non-linear scrambling.
   13.67 + * Both inputs are replaced with the results of the hash.
   13.68 + *
   13.69 + * @param pleft input/output word
   13.70 + * @param pright input/output word
   13.71 + */
   13.72 +void pseudo_des(unsigned long *pleft, unsigned long *pright){
   13.73 +    // Bit-rich mixing constant.
   13.74 +    static const unsigned long a_mixer[] = {
   13.75 +        0xbaa96887L, 0x1e17d32cL, 0x03bcdc3cL, 0x0f33d1b2L, };
   13.76 +
   13.77 +    // Bit-rich mixing constant.
   13.78 +    static const unsigned long b_mixer[] = {
   13.79 +        0x4b0f3b58L, 0xe874f0c3L, 0x6955c5a6L, 0x55a7ca46L, };
   13.80 +
   13.81 +    // Number of iterations - must be 2 or 4.
   13.82 +    static const int ncycle = 4;
   13.83 +    //static const int ncycle = 2;
   13.84 +
   13.85 +    unsigned long left = *pleft, right = *pright;
   13.86 +    unsigned long v, v_hi, v_lo;
   13.87 +    int i;
   13.88 +
   13.89 +    for(i=0; i<ncycle; i++){
   13.90 +        // Flip some bits in right to get v.
   13.91 +        v = right;
   13.92 +        v ^= a_mixer[i];
   13.93 +        // Get lo and hi halves of v.
   13.94 +        v_lo = LO_HALF(v);
   13.95 +        v_hi = HI_HALF(v);
   13.96 +        // Non-linear mix of the halves of v.
   13.97 +        v = ((v_lo * v_lo) + ~(v_hi * v_hi));
   13.98 +        // Swap the halves of v.
   13.99 +        v = (HI_HALF(v) | (LO_HALF(v) << HALF_WORD_BITS));
  13.100 +        // Flip some bits.
  13.101 +        v ^= b_mixer[i];
  13.102 +        // More non-linear mixing.
  13.103 +        v += (v_lo * v_hi);
  13.104 +        v ^= left;
  13.105 +        left = right;
  13.106 +        right = v;
  13.107 +    }
  13.108 +    *pleft = left;
  13.109 +    *pright = right;
  13.110 +}
  13.111 +
  13.112 +/** Hash a string.
  13.113 + *
  13.114 + * @param s input to hash
  13.115 + * @return hashcode
  13.116 + */
  13.117 +Hashcode hash_string(char *s){
  13.118 +    Hashcode h = 0;
  13.119 +    if(s){
  13.120 +        for( ; *s; s++){
  13.121 +            h = hash_2ul(h, *s);
  13.122 +        }
  13.123 +    }
  13.124 +    return h;
  13.125 +}
  13.126 +
  13.127 +/** Get the bucket for a hashcode in a hash table.
  13.128 + *
  13.129 + * @param table to get bucket from
  13.130 + * @param hashcode to get bucket for
  13.131 + * @return bucket
  13.132 + */
  13.133 +inline HTBucket * get_bucket(HashTable *table, Hashcode hashcode){
  13.134 +    return table->buckets + (hashcode % table->buckets_n);
  13.135 +}
  13.136 +
  13.137 +/** Initialize a hash table.
  13.138 + * Can be safely called more than once.
  13.139 + *
  13.140 + * @param table to initialize
  13.141 + */
  13.142 +void HashTable_init(HashTable *table){
  13.143 +    int i;
  13.144 +
  13.145 +    if(!table->init_done){
  13.146 +        table->init_done = 1;
  13.147 +        table->next_id = 0;
  13.148 +        for(i=0; i<table->buckets_n; i++){
  13.149 +            HTBucket *bucket = get_bucket(table, i);
  13.150 +            bucket->head = 0;
  13.151 +            bucket->count = 0;
  13.152 +        }
  13.153 +        table->entry_count = 0;
  13.154 +    }
  13.155 +}
  13.156 +
  13.157 +/** Allocate a new hashtable.
  13.158 + * If the number of buckets is not positive the default is used.
  13.159 + * The number of buckets should usually be prime.
  13.160 + *
  13.161 + * @param buckets_n number of buckets
  13.162 + * @return new hashtable or null
  13.163 + */
  13.164 +HashTable *HashTable_new(int buckets_n){
  13.165 +    HashTable *z = ALLOCATE(HashTable);
  13.166 +    if(!z) goto exit;
  13.167 +    if(buckets_n <= 0){
  13.168 +        buckets_n = HT_BUCKETS_N;
  13.169 +    }
  13.170 +    z->buckets = (HTBucket*)allocate(buckets_n * sizeof(HTBucket));
  13.171 +    if(!z->buckets){
  13.172 +        deallocate(z);
  13.173 +        z = 0;
  13.174 +        goto exit;
  13.175 +    }
  13.176 +    z->buckets_n = buckets_n;
  13.177 +    HashTable_init(z);
  13.178 +  exit:
  13.179 +    return z;
  13.180 +}
  13.181 +
  13.182 +/** Free a hashtable.
  13.183 + * Any entries are removed and freed.
  13.184 + *
  13.185 + * @param h hashtable (ignored if null)
  13.186 + */
  13.187 +void HashTable_free(HashTable *h){
  13.188 +    if(h){
  13.189 +        HashTable_clear(h);
  13.190 +        deallocate(h->buckets);
  13.191 +        deallocate(h);
  13.192 +    }
  13.193 +}
  13.194 +
  13.195 +/** Push an entry on the list in the bucket for a given hashcode.
  13.196 + *
  13.197 + * @param table to add entry to
  13.198 + * @param hashcode for the entry
  13.199 + * @param entry to add
  13.200 + */
  13.201 +static inline void push_on_bucket(HashTable *table, Hashcode hashcode,
  13.202 +				  HTEntry *entry){
  13.203 +    HTBucket *bucket;
  13.204 +    HTEntry *old_head;
  13.205 +
  13.206 +    bucket = get_bucket(table, hashcode);
  13.207 +    old_head = bucket->head;
  13.208 +    bucket->count++;
  13.209 +    bucket->head = entry;
  13.210 +    entry->next = old_head;
  13.211 +}
  13.212 +
  13.213 +/** Change the number of buckets in a hashtable.
  13.214 + * No-op if the number of buckets is not positive.
  13.215 + * Existing entries are reallocated to buckets based on their hashcodes.
  13.216 + * The table is unmodified if the number of buckets cannot be changed.
  13.217 + *
  13.218 + * @param table hashtable
  13.219 + * @param buckets_n new number of buckets
  13.220 + * @return 0 on success, error code otherwise
  13.221 + */
  13.222 +int HashTable_set_buckets_n(HashTable *table, int buckets_n){
  13.223 +    int err = 0;
  13.224 +    HTBucket *old_buckets = table->buckets;
  13.225 +    int old_buckets_n = table->buckets_n;
  13.226 +    int i;
  13.227 +
  13.228 +    if(buckets_n <= 0){
  13.229 +        err = -EINVAL;
  13.230 +        goto exit;
  13.231 +    }
  13.232 +    table->buckets = (HTBucket*)allocate(buckets_n * sizeof(HTBucket));
  13.233 +    if(!table->buckets){
  13.234 +        err = -ENOMEM;
  13.235 +        table->buckets = old_buckets;
  13.236 +        goto exit;
  13.237 +    }
  13.238 +    table->buckets_n = buckets_n;
  13.239 +    for(i=0; i<old_buckets_n; i++){
  13.240 +        HTBucket *bucket = old_buckets + i;
  13.241 +        HTEntry *entry, *next;
  13.242 +        for(entry = bucket->head; entry; entry = next){
  13.243 +            next = entry->next;
  13.244 +            push_on_bucket(table, entry->hashcode, entry);
  13.245 +        }
  13.246 +    }
  13.247 +    deallocate(old_buckets);
  13.248 +  exit:
  13.249 +    return err;
  13.250 +}
  13.251 +
  13.252 +/** Adjust the number of buckets so the table is neither too full nor too empty.
  13.253 + * The table is unmodified if adjusting fails.
  13.254 + *
  13.255 + * @param table hash table
  13.256 + * @param buckets_min minimum number of buckets (use default if 0 or negative)
  13.257 + * @return 0 on success, error code otherwise
  13.258 + */
  13.259 +int HashTable_adjust(HashTable *table, int buckets_min){
  13.260 +    int buckets_n = 0;
  13.261 +    int err = 0;
  13.262 +    if(buckets_min <= 0) buckets_min = HT_BUCKETS_N;
  13.263 +    if(table->entry_count >= table->buckets_n){
  13.264 +        // The table is dense - expand it.
  13.265 +        buckets_n = 2 * table->buckets_n;
  13.266 +    } else if((table->buckets_n > buckets_min) &&
  13.267 +              (4 * table->entry_count < table->buckets_n)){
  13.268 +        // The table is more than minimum size and sparse - shrink it.
  13.269 +        buckets_n = 2 * table->entry_count;
  13.270 +        if(buckets_n < buckets_min) buckets_n = buckets_min;
  13.271 +    }
  13.272 +    if(buckets_n){
  13.273 +        err = HashTable_set_buckets_n(table, buckets_n);
  13.274 +    }
  13.275 +    return err;
  13.276 +}
  13.277 +
  13.278 +/** Allocate a new entry for a given value.
  13.279 + *
  13.280 + * @param value to put in the entry
  13.281 + * @return entry, or 0 on failure
  13.282 + */
  13.283 +HTEntry * HTEntry_new(Hashcode hashcode, void *key, void *value){
  13.284 +    HTEntry *z = ALLOCATE(HTEntry);
  13.285 +    if(z){
  13.286 +        z->hashcode = hashcode;
  13.287 +        z->key = key;
  13.288 +        z->value = value;
  13.289 +    }
  13.290 +    return z;
  13.291 +}
  13.292 +
  13.293 +/** Free an entry.
  13.294 + *
  13.295 + * @param z entry to free
  13.296 + */
  13.297 +inline void HTEntry_free(HTEntry *z){
  13.298 +    if(z){
  13.299 +        deallocate(z);
  13.300 +    }
  13.301 +}
  13.302 +
  13.303 +/** Free an entry in a hashtable.
  13.304 + * The table's entry_free_fn is used is defined, otherwise 
  13.305 + * the HTEntry itself is freed.
  13.306 + *
  13.307 + * @param table hashtable
  13.308 + * @param entry to free
  13.309 + */
  13.310 +inline void HashTable_free_entry(HashTable *table, HTEntry *entry){
  13.311 +    if(!entry)return;
  13.312 +    if(table && table->entry_free_fn){
  13.313 +        table->entry_free_fn(table, entry);
  13.314 +    } else {
  13.315 +        HTEntry_free(entry);
  13.316 +    }
  13.317 +}
  13.318 +
  13.319 +/** Get the first entry satisfying a test from the bucket for the
  13.320 + * given hashcode.
  13.321 + *
  13.322 + * @param table to look in
  13.323 + * @param hashcode indicates the bucket
  13.324 + * @param test_fn test to apply to elements
  13.325 + * @param arg first argument to calls to test_fn
  13.326 + * @return entry found, or 0
  13.327 + */
  13.328 +inline HTEntry * HashTable_find_entry(HashTable *table, Hashcode hashcode,
  13.329 +				      TableTestFn *test_fn, TableArg arg){
  13.330 +    HTBucket *bucket;
  13.331 +    HTEntry *entry = 0;
  13.332 +    HTEntry *next;
  13.333 +
  13.334 +    bucket = get_bucket(table, hashcode);
  13.335 +    for(entry = bucket->head; entry; entry = next){
  13.336 +        next = entry->next;
  13.337 +        if(test_fn(arg, table, entry)){
  13.338 +            break;
  13.339 +        }
  13.340 +    }
  13.341 +    return entry;
  13.342 +}
  13.343 +
  13.344 +/** Test hashtable keys for equality.
  13.345 + * Uses the table's key_equal_fn if defined, otherwise pointer equality.
  13.346 + *
  13.347 + * @param key1 key to compare
  13.348 + * @param key2 key to compare
  13.349 + * @return 1 if equal, 0 otherwise
  13.350 + */
  13.351 +inline int HashTable_key_equal(HashTable *table, void *key1, void *key2){
  13.352 +    return (table->key_equal_fn ? table->key_equal_fn(key1, key2) : key1==key2);
  13.353 +}
  13.354 +
  13.355 +/** Compute the hashcode of a hashtable key.
  13.356 + * The table's key_hash_fn is used if defined, otherwise the address of
  13.357 + * the key is hashed.
  13.358 + *
  13.359 + * @param table hashtable
  13.360 + * @param key to hash
  13.361 + * @return hashcode
  13.362 + */
  13.363 +inline Hashcode HashTable_key_hash(HashTable *table, void *key){
  13.364 +    return (table->key_hash_fn ? table->key_hash_fn(key) : hash_ul((unsigned long)key));
  13.365 +}
  13.366 +
  13.367 +/** Test if an entry has a given key.
  13.368 + *
  13.369 + * @param arg containing key to test for
  13.370 + * @param table the entry is in
  13.371 + * @param entry to test
  13.372 + * @return 1 if the entry has the key, 0 otherwise
  13.373 + */
  13.374 +static inline int has_key(TableArg arg, HashTable *table, HTEntry *entry){
  13.375 +    return HashTable_key_equal(table, arg.ptr, entry->key);
  13.376 +}
  13.377 +
  13.378 +/** Get an entry with a given key.
  13.379 + *
  13.380 + * @param table to search
  13.381 + * @param key to look for
  13.382 + * @return entry if found, null otherwise
  13.383 + */
  13.384 +#if 0
  13.385 +inline HTEntry * HashTable_get_entry(HashTable *table, void *key){
  13.386 +    TableArg arg = { ptr: key };
  13.387 +    return HashTable_find_entry(table, HashTable_key_hash(table, key), has_key, arg);
  13.388 +}
  13.389 +#else
  13.390 +inline HTEntry * HashTable_get_entry(HashTable *table, void *key){
  13.391 +    Hashcode hashcode;
  13.392 +    HTBucket *bucket;
  13.393 +    HTEntry *entry = 0;
  13.394 +    HTEntry *next;
  13.395 +
  13.396 +    hashcode = HashTable_key_hash(table, key);
  13.397 +    bucket = get_bucket(table, hashcode);
  13.398 +    for(entry = bucket->head; entry; entry = next){
  13.399 +        next = entry->next;
  13.400 +        if(HashTable_key_equal(table, key, entry->key)){
  13.401 +            break;
  13.402 +        }
  13.403 +    }
  13.404 +    return entry;
  13.405 +}
  13.406 +#endif
  13.407 +
  13.408 +/** Get the value of an entry with a given key.
  13.409 + *
  13.410 + * @param table to search
  13.411 + * @param key to look for
  13.412 + * @return value if an entry was found, null otherwise
  13.413 + */
  13.414 +inline void * HashTable_get(HashTable *table, void *key){
  13.415 +    HTEntry *entry = HashTable_get_entry(table, key);
  13.416 +    return (entry ? entry->value : 0);
  13.417 +}
  13.418 +
  13.419 +/** Print the buckets in a table.
  13.420 + *
  13.421 + * @param table to print
  13.422 + */
  13.423 +void show_buckets(HashTable *table, IOStream *io){
  13.424 +    int i,j ;
  13.425 +    IOStream_print(io, "entry_count=%d buckets_n=%d\n", table->entry_count, table->buckets_n);
  13.426 +    for(i=0; i<table->buckets_n; i++){
  13.427 +        if(0 || table->buckets[i].count>0){
  13.428 +            IOStream_print(io, "bucket %3d %3d %10p ", i,
  13.429 +                        table->buckets[i].count,
  13.430 +                        table->buckets[i].head);
  13.431 +            for(j = table->buckets[i].count; j>0; j--){
  13.432 +                IOStream_print(io, "+");
  13.433 +            }
  13.434 +            IOStream_print(io, "\n");
  13.435 +        }
  13.436 +    }
  13.437 +    HashTable_print(table, io); 
  13.438 +}
  13.439 +    
  13.440 +/** Print an entry in a table.
  13.441 + *
  13.442 + * @param entry to print
  13.443 + * @param arg a pointer to an IOStream to print to
  13.444 + * @return 0
  13.445 + */
  13.446 +static int print_entry(TableArg arg, HashTable *table, HTEntry *entry){
  13.447 +    IOStream *io = (IOStream*)arg.ptr;
  13.448 +    IOStream_print(io, " b=%4lx h=%08lx i=%08lx |-> e=%8p k=%8p v=%8p\n",
  13.449 +                entry->hashcode % table->buckets_n,
  13.450 +                entry->hashcode,
  13.451 +                entry->index,
  13.452 +                entry, entry->key, entry->value);
  13.453 +    return 0;
  13.454 +}
  13.455 +
  13.456 +/** Print a hash table.
  13.457 + *
  13.458 + * @param table to print
  13.459 + */
  13.460 +void HashTable_print(HashTable *table, IOStream *io){
  13.461 +    IOStream_print(io, "{\n");
  13.462 +    HashTable_map(table, print_entry, (TableArg){ ptr: io });
  13.463 +    IOStream_print(io, "}\n");
  13.464 +}
  13.465 +/*==========================================================================*/
  13.466 +
  13.467 +/** Get the next entry id to use for a table.
  13.468 + *
  13.469 + * @param table hash table
  13.470 + * @return non-zero entry id
  13.471 + */
  13.472 +static inline unsigned long get_next_id(HashTable *table){
  13.473 +    unsigned long id;
  13.474 +
  13.475 +    if(table->next_id == 0){
  13.476 +        table->next_id = 1;
  13.477 +    }
  13.478 +    id = table->next_id++;
  13.479 +    return id;
  13.480 +}
  13.481 +
  13.482 +/** Add an entry to the bucket for the
  13.483 + * given hashcode.
  13.484 + *
  13.485 + * @param table to insert in
  13.486 + * @param hashcode indicates the bucket
  13.487 + * @param key to add an entry for
  13.488 + * @param value to add an entry for
  13.489 + * @return entry on success, 0 on failure
  13.490 + */
  13.491 +inline HTEntry * HashTable_add_entry(HashTable *table, Hashcode hashcode, void *key, void *value){
  13.492 +    HTEntry *entry = HTEntry_new(hashcode, key, value);
  13.493 +    if(entry){
  13.494 +        entry->index = get_next_id(table);
  13.495 +        push_on_bucket(table, hashcode, entry);
  13.496 +        table->entry_count++;
  13.497 +    }
  13.498 +    return entry;
  13.499 +}
  13.500 +
  13.501 +/** Move the front entry for a bucket to the correct point in the bucket order as
  13.502 + * defined by the order function. If this is called every time a new entry is added
  13.503 + * the bucket will be maintained in sorted order.
  13.504 + *
  13.505 + * @param table to modify
  13.506 + * @param hashcode indicates the bucket
  13.507 + * @param order entry comparison function
  13.508 + * @return 0 if an entry was moved, 1 if not
  13.509 + */
  13.510 +int HashTable_order_bucket(HashTable *table, Hashcode hashcode, TableOrderFn *order){
  13.511 +    HTEntry *new_entry = NULL, *prev = NULL, *entry = NULL;
  13.512 +    HTBucket *bucket;
  13.513 +    int err = 1;
  13.514 +
  13.515 +    bucket = get_bucket(table, hashcode);
  13.516 +    new_entry = bucket->head;
  13.517 +    if(!new_entry || !new_entry->next) goto exit;
  13.518 +    for(entry = new_entry->next; entry; prev = entry, entry = entry->next){
  13.519 +        if(order(new_entry, entry) <= 0) break;
  13.520 +    }
  13.521 +    if(prev){
  13.522 +        err = 0;
  13.523 +        bucket->head = new_entry->next; 
  13.524 +        new_entry->next = entry;
  13.525 +        prev->next = new_entry;
  13.526 +    }
  13.527 +  exit:
  13.528 +    return err;
  13.529 +}
  13.530 +
  13.531 +/** Add an entry to a hashtable.
  13.532 + * The entry is added to the bucket for its key's hashcode.
  13.533 + *
  13.534 + * @param table to insert in
  13.535 + * @param key to add an entry for
  13.536 + * @param value to add an entry for
  13.537 + * @return entry on success, 0 on failure
  13.538 + */
  13.539 +inline HTEntry * HashTable_add(HashTable *table, void *key, void *value){
  13.540 +    return HashTable_add_entry(table, HashTable_key_hash(table, key), key, value);
  13.541 +}
  13.542 +
  13.543 +
  13.544 +/** Remove entries satisfying a test from the bucket for the
  13.545 + * given hashcode. 
  13.546 + *
  13.547 + * @param table to remove from
  13.548 + * @param hashcode indicates the bucket
  13.549 + * @param test_fn test to apply to elements
  13.550 + * @param arg first argument to calls to test_fn
  13.551 + * @return number of entries removed
  13.552 + */
  13.553 +inline int HashTable_remove_entry(HashTable *table, Hashcode hashcode,
  13.554 +				  TableTestFn *test_fn, TableArg arg){
  13.555 +    HTBucket *bucket;
  13.556 +    HTEntry *entry, *prev = 0, *next;
  13.557 +    int removed_count = 0;
  13.558 +
  13.559 +    bucket = get_bucket(table, hashcode);
  13.560 +    for(entry = bucket->head; entry; entry = next){
  13.561 +        next = entry->next;
  13.562 +        if(test_fn(arg, table, entry)){
  13.563 +            if(prev){
  13.564 +                prev->next = next;
  13.565 +            } else {
  13.566 +                bucket->head = next;
  13.567 +            }
  13.568 +            bucket->count--;
  13.569 +            table->entry_count--;
  13.570 +            removed_count++;
  13.571 +            HashTable_free_entry(table, entry);
  13.572 +            entry = 0;
  13.573 +        }
  13.574 +        prev = entry;
  13.575 +    }
  13.576 +    return removed_count;
  13.577 +}
  13.578 +
  13.579 +/** Remove entries with a given key. 
  13.580 + *
  13.581 + * @param table to remove from
  13.582 + * @param key of entries to remove
  13.583 + * @return number of entries removed
  13.584 + */
  13.585 +inline int HashTable_remove(HashTable *table, void *key){
  13.586 +#if 1
  13.587 +    Hashcode hashcode;
  13.588 +    HTBucket *bucket;
  13.589 +    HTEntry *entry, *prev = 0, *next;
  13.590 +    int removed_count = 0;
  13.591 +
  13.592 +    hashcode = HashTable_key_hash(table, key);
  13.593 +    bucket = get_bucket(table, hashcode);
  13.594 +    for(entry = bucket->head; entry; entry = next){
  13.595 +        next = entry->next;
  13.596 +        if(HashTable_key_equal(table, key, entry->key)){
  13.597 +            if(prev){
  13.598 +                prev->next = next;
  13.599 +            } else {
  13.600 +                bucket->head = next;
  13.601 +            }
  13.602 +            bucket->count--;
  13.603 +            table->entry_count--;
  13.604 +            removed_count++;
  13.605 +            HashTable_free_entry(table, entry);
  13.606 +            entry = 0;
  13.607 +        }
  13.608 +        prev = entry;
  13.609 +    }
  13.610 +    return removed_count;
  13.611 +#else
  13.612 +    return HashTable_remove_entry(table, HashTable_key_hash(table, key),
  13.613 +				  has_key, (TableArg){ ptr: key});
  13.614 +#endif
  13.615 +}
  13.616 +
  13.617 +/** Remove (and free) all the entries in a bucket.
  13.618 + *
  13.619 + * @param bucket to clear
  13.620 + */
  13.621 +static inline void bucket_clear(HashTable *table, HTBucket *bucket){
  13.622 +    HTEntry *entry, *next;
  13.623 +
  13.624 +    for(entry = bucket->head; entry; entry = next){
  13.625 +        next = entry->next;
  13.626 +        HashTable_free_entry(table, entry);
  13.627 +    }
  13.628 +    bucket->head = 0;
  13.629 +    table->entry_count -= bucket->count;
  13.630 +    bucket->count = 0;
  13.631 +}
  13.632 +
  13.633 +/** Remove (and free) all the entries in a table.
  13.634 + *
  13.635 + * @param table to clear
  13.636 + */
  13.637 +void HashTable_clear(HashTable *table){
  13.638 +    int i, n = table->buckets_n;
  13.639 +
  13.640 +    for(i=0; i<n; i++){
  13.641 +        bucket_clear(table, table->buckets + i);
  13.642 +    }
  13.643 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/tools/lib/hash_table.h	Tue Jun 29 12:05:29 2004 +0000
    14.3 @@ -0,0 +1,295 @@
    14.4 +/* $Id: hash_table.h,v 1.1 2004/03/30 16:21:26 mjw Exp $ */
    14.5 +/*
    14.6 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    14.7 + *
    14.8 + * This library is free software; you can redistribute it and/or modify
    14.9 + * it under the terms of the GNU Lesser General Public License as published by
   14.10 + * the Free Software Foundation; either version 2.1 of the License, or
   14.11 + * (at your option) any later version.
   14.12 + *
   14.13 + * This library is distributed in the hope that it will be useful,
   14.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14.16 + * GNU Lesser General Public License for more details.
   14.17 + *
   14.18 + * You should have received a copy of the GNU Lesser General Public License
   14.19 + * along with this library; if not, write to the Free Software
   14.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   14.21 + */
   14.22 +
   14.23 +#ifndef _XEN_LIB_HASH_TABLE_H_
   14.24 +#define _XEN_LIB_HASH_TABLE_H_
   14.25 +
   14.26 +#include "iostream.h"
   14.27 +
   14.28 +typedef unsigned long Hashcode;
   14.29 +
   14.30 +/** Type used to pass parameters to table functions. */
   14.31 +typedef union TableArg {
   14.32 +    unsigned long ul;
   14.33 +    void *ptr;
   14.34 +} TableArg;
   14.35 +
   14.36 +/** An entry in a bucket list. */
   14.37 +typedef struct HTEntry {
   14.38 +    /** Hashcode of the entry's key. */
   14.39 +    Hashcode hashcode;
   14.40 +    /** Identifier for this entry in the table. */
   14.41 +    int index;
   14.42 +    /** The key for this entry. */
   14.43 +    void *key;
   14.44 +    /** The value in this entry. */
   14.45 +    void *value;
   14.46 +    /** The next entry in the list. */
   14.47 +    struct HTEntry *next;
   14.48 +} HTEntry;
   14.49 +
   14.50 +/** A bucket in a rule table. */
   14.51 +typedef struct HTBucket {
   14.52 +    /** Number of entries in the bucket. */
   14.53 +    int count;
   14.54 +    /** First entry in the bucket (may be null). */
   14.55 +    HTEntry *head;
   14.56 +} HTBucket;
   14.57 +
   14.58 +/** Default number of buckets in a hash table.
   14.59 + * You want enough buckets so the lists in the buckets will typically be short.
   14.60 + * It's a good idea if this is prime, since that will help to spread hashcodes
   14.61 + * around the table.
   14.62 + */
   14.63 +//#define HT_BUCKETS_N 1
   14.64 +//#define HT_BUCKETS_N 3
   14.65 +//#define HT_BUCKETS_N 7
   14.66 +//#define HT_BUCKETS_N 17
   14.67 +//#define HT_BUCKETS_N 97
   14.68 +//#define HT_BUCKETS_N 211
   14.69 +//#define HT_BUCKETS_N 401
   14.70 +#define HT_BUCKETS_N 1021
   14.71 +
   14.72 +typedef struct HashTable HashTable;
   14.73 +
   14.74 +/** Type for a function used to select table entries. */
   14.75 +typedef int TableTestFn(TableArg arg, HashTable *table, HTEntry *entry);
   14.76 +
   14.77 +/** Type for a function to map over table entries. */
   14.78 +typedef int TableMapFn(TableArg arg, HashTable *table, HTEntry *entry);
   14.79 +
   14.80 +/** Type for a function to free table entries. */
   14.81 +typedef void TableFreeFn(HashTable *table, HTEntry *entry);
   14.82 +
   14.83 +/** Type for a function to hash table keys. */
   14.84 +typedef Hashcode TableHashFn(void *key);
   14.85 +
   14.86 +/** Type for a function to test table keys for equality. */
   14.87 +typedef int TableEqualFn(void *key1, void *key2);
   14.88 +
   14.89 +/** Type for a function to order table entries. */
   14.90 +typedef int TableOrderFn(HTEntry *e1, HTEntry *e2);
   14.91 +
   14.92 +/** General hash table.
   14.93 + * A hash table with a list in each bucket.
   14.94 + * Functions can be supplied for freeing entries, hashing keys, and comparing keys.
   14.95 + * These all default to 0, when default behaviour treating keys as integers is used.
   14.96 + */
   14.97 +struct HashTable {
   14.98 +    /** Flag indicating whether the table has been initialised. */
   14.99 +    int init_done;
  14.100 +    /** Next value for the id field in inserted rules. */
  14.101 +    unsigned long next_id;
  14.102 +    /** Number of buckets in the bucket array. */
  14.103 +    int buckets_n;
  14.104 +    /** Array of buckets, each with its own list. */
  14.105 +    HTBucket *buckets;
  14.106 +    /** Number of entries in the table. */
  14.107 +    int entry_count;
  14.108 +    /** Function to free keys and values in entries. */
  14.109 +    TableFreeFn *entry_free_fn;
  14.110 +    /** Function to hash keys. */
  14.111 +    TableHashFn *key_hash_fn;
  14.112 +    /** Function to compare keys for equality. */
  14.113 +    TableEqualFn *key_equal_fn;
  14.114 +    /** Place for the user of the table to hang extra data. */
  14.115 +    void *user_data;
  14.116 +};
  14.117 +
  14.118 +extern HashTable *HashTable_new(int bucket_n);
  14.119 +extern void HashTable_free(HashTable *table);
  14.120 +extern HTEntry * HTEntry_new(Hashcode hashcode, void *key, void *value);
  14.121 +extern void HTEntry_free(HTEntry *entry);
  14.122 +extern int HashTable_set_bucket_n(HashTable *table, int bucket_n);
  14.123 +extern void HashTable_clear(HashTable *table);
  14.124 +extern HTEntry * HashTable_add_entry(HashTable *table, Hashcode hashcode, void *key, void *value);
  14.125 +extern HTEntry * HashTable_get_entry(HashTable *table, void *key);
  14.126 +extern HTEntry * HashTable_add(HashTable *table, void *key, void *value);
  14.127 +extern void * HashTable_get(HashTable *table, void *key);
  14.128 +extern int HashTable_remove(HashTable *table, void *key);
  14.129 +extern HTEntry * HashTable_find_entry(HashTable *table, Hashcode hashcode,
  14.130 +                                      TableTestFn *test_fn, TableArg arg);
  14.131 +extern int HashTable_remove_entry(HashTable *table, Hashcode hashcode,
  14.132 +                                   TableTestFn *test_fn, TableArg arg);
  14.133 +//extern int HashTable_map(HashTable *table, TableMapFn *map_fn, TableArg arg);
  14.134 +extern void HashTable_print(HashTable *table, IOStream *out);
  14.135 +extern int HashTable_set_buckets_n(HashTable *table, int buckets_n);
  14.136 +extern int HashTable_adjust(HashTable *table, int buckets_min);
  14.137 +extern void pseudo_des(unsigned long *pleft, unsigned long *pright);
  14.138 +extern Hashcode hash_string(char *s);
  14.139 +
  14.140 +extern int HashTable_order_bucket(HashTable *table, Hashcode hashcode, TableOrderFn *order);
  14.141 +
  14.142 +/** Control whether to use hashing based on DES or simple
  14.143 + * hashing. DES hashing is `more random' but much more expensive.
  14.144 + */
  14.145 +#define HASH_PSEUDO_DES 0
  14.146 +
  14.147 +/** Hash a long using a quick and dirty linear congruential random number generator.
  14.148 + *  See `Numerical Recipes in C', Chapter 7, "An Even Quicker Generator".
  14.149 + *
  14.150 + * @param a value to hash
  14.151 + * @return hashed input
  14.152 + */
  14.153 +static inline unsigned long lcrng_hash(unsigned long a){
  14.154 +    return (1664525L * a + 1013904223L);
  14.155 +}
  14.156 +
  14.157 +/** Hash an unsigned long.
  14.158 + *
  14.159 + * @param a input to hash
  14.160 + * @return hashcode
  14.161 + */
  14.162 +static inline Hashcode hash_ul(unsigned long a){
  14.163 +#if HASH_PSEUDO_DES
  14.164 +    unsigned long left = a;
  14.165 +    unsigned long right = 0L;
  14.166 +    pseudo_des(&left, &right);
  14.167 +    return right;
  14.168 +#else
  14.169 +    a = lcrng_hash(a);
  14.170 +    a = lcrng_hash(a);
  14.171 +    return a;
  14.172 +#endif
  14.173 +}
  14.174 +
  14.175 +/** Hash two unsigned longs together.
  14.176 + *
  14.177 + * @param a input to hash
  14.178 + * @param b input to hash
  14.179 + * @return hashcode
  14.180 + */
  14.181 +static inline Hashcode hash_2ul(unsigned long a, unsigned long b){
  14.182 +#if HASH_PSEUDO_DES
  14.183 +    unsigned long left = a;
  14.184 +    unsigned long right = b;
  14.185 +    pseudo_des(&left, &right);
  14.186 +    return right;
  14.187 +#else
  14.188 +    a = lcrng_hash(a);
  14.189 +    a ^= b;
  14.190 +    a = lcrng_hash(a);
  14.191 +    return a;
  14.192 +#endif
  14.193 +}
  14.194 +
  14.195 +/** Hash a hashcode and an unsigned long together.
  14.196 + *
  14.197 + * @param a input hashcode
  14.198 + * @param b input to hash
  14.199 + * @return hashcode
  14.200 + */
  14.201 +static inline Hashcode hash_hul(Hashcode a, unsigned long b){
  14.202 +#if HASH_PSEUDO_DES
  14.203 +    unsigned long left = a;
  14.204 +    unsigned long right = b;
  14.205 +    pseudo_des(&left, &right);
  14.206 +    return right;
  14.207 +#else
  14.208 +    a ^= b;
  14.209 +    a = lcrng_hash(a);
  14.210 +    return a;
  14.211 +#endif
  14.212 +}
  14.213 +
  14.214 +/** Macro to declare variables for HashTable_for_each() to use.
  14.215 + *
  14.216 + * @param entry variable that is set to entries in the table
  14.217 + */
  14.218 +#define HashTable_for_decl(entry) \
  14.219 +  HashTable *_var_table; \
  14.220 +  HTBucket *_var_bucket; \
  14.221 +  HTBucket *_var_end; \
  14.222 +  HTEntry *_var_next; \
  14.223 +  HTEntry *entry
  14.224 +
  14.225 +/** Macro to iterate over the entries in a hashtable.
  14.226 + * Must be in a scope where HashTable_for_decl() has been used to declare
  14.227 + * variables for it to use.
  14.228 + * The variable 'entry' is iterated over entries in the table.
  14.229 + * The code produced is syntactically a loop, so it must be followed by
  14.230 + * a loop body, typically some statements in braces:
  14.231 + * HashTable_for_each(entry, table){ ...loop body... }
  14.232 + *
  14.233 + * HashTable_for_each() and HashTable_for_decl() cannot be used for nested
  14.234 + * loops as variables will clash.
  14.235 + *
  14.236 + * @note The simplest way to code a direct loop over the entries in a hashtable
  14.237 + * is to use a loop over the buckets, with a nested loop over the entries
  14.238 + * in a bucket. Using this approach in a macro means the macro contains
  14.239 + * an opening brace, and calls to it must be followed by 2 braces!
  14.240 + * To avoid this the code has been restructured so that it is a for loop.
  14.241 + * So that statements could be used in the test expression of the for loop,
  14.242 + * we have used the gcc statement expression extension ({ ... }).
  14.243 + *
  14.244 + * @param entry variable to iterate over the entries
  14.245 + * @param table to iterate over (non-null)
  14.246 + */
  14.247 +#define HashTable_for_each(entry, table) \
  14.248 +  _var_table = table; \
  14.249 +  _var_bucket = _var_table->buckets; \
  14.250 +  _var_end = _var_bucket + _var_table->buckets_n; \
  14.251 +  for(entry=0, _var_next=0; \
  14.252 +      ({ if(_var_next){ \
  14.253 +             entry = _var_next; \
  14.254 +             _var_next = entry->next; \
  14.255 +          } else { \
  14.256 +             while(_var_bucket < _var_end){ \
  14.257 +                 entry = _var_bucket->head; \
  14.258 +                 _var_bucket++; \
  14.259 +                 if(entry){ \
  14.260 +                      _var_next = entry->next; \
  14.261 +                      break; \
  14.262 +                 } \
  14.263 +             } \
  14.264 +          }; \
  14.265 +         entry; }); \
  14.266 +      entry = _var_next )
  14.267 +
  14.268 +/** Map a function over the entries in a table.
  14.269 + * Mapping stops when the function returns a non-zero value.
  14.270 + * Uses the gcc statement expression extension ({ ... }).
  14.271 + *
  14.272 + * @param table to map over
  14.273 + * @param fn function to apply to entries
  14.274 + * @param arg first argument to call the function with
  14.275 + * @return 0 if fn always returned 0, first non-zero value otherwise
  14.276 + */
  14.277 +#define HashTable_map(table, fn, arg) \
  14.278 +  ({ HashTable_for_decl(_var_entry); \
  14.279 +    TableArg _var_arg = arg; \
  14.280 +    int _var_value = 0; \
  14.281 +    HashTable_for_each(_var_entry, table){ \
  14.282 +        if((_var_value = fn(_var_arg, _var_table, _var_entry))) break; \
  14.283 +    } \
  14.284 +    _var_value; })
  14.285 +
  14.286 +/** Cast x to the type for a key or value in a hash table.
  14.287 + * This avoids compiler warnings when using short integers
  14.288 + * as keys or values (especially on 64-bit platforms).
  14.289 + */
  14.290 +#define HKEY(x) ((void*)(unsigned long)(x))
  14.291 +
  14.292 +/** Cast x from the type for a key or value in a hash table.
  14.293 + * to an unsigned long. This avoids compiler warnings when using
  14.294 + * short integers as keys or values (especially on 64-bit platforms).
  14.295 + */
  14.296 +#define HVAL(x) ((unsigned long)(x))
  14.297 +
  14.298 +#endif /* !_XEN_LIB_HASH_TABLE_H_ */

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/tools/lib/iostream.c	Tue Jun 29 12:05:29 2004 +0000
    15.3 @@ -0,0 +1,37 @@
    15.4 +#include "iostream.h"
    15.5 +#include "sys_string.h"
    15.6 +
    15.7 +/** Print on a stream, like vfprintf().
    15.8 + *
    15.9 + * @param stream to print to
   15.10 + * @param format for the print (as fprintf())
   15.11 + * @param args arguments to print
   15.12 + * @return result code from the print
   15.13 + */
   15.14 +int IOStream_vprint(IOStream *stream, const char *format, va_list args){
   15.15 +  char buffer[1024];
   15.16 +  int k = sizeof(buffer), n;
   15.17 +
   15.18 +  n = vsnprintf(buffer, k, (char*)format, args);
   15.19 +  if(n < 0 || n > k ){
   15.20 +      n = k;
   15.21 +  }
   15.22 +  n = IOStream_write(stream, buffer, n);
   15.23 +  return n;
   15.24 +}
   15.25 +
   15.26 +/** Print on a stream, like fprintf().
   15.27 + *
   15.28 + * @param stream to print to
   15.29 + * @param format for the print (as fprintf())
   15.30 + * @return result code from the print
   15.31 + */
   15.32 +int IOStream_print(IOStream *stream, const char *format, ...){
   15.33 +  va_list args;
   15.34 +  int result = -1;
   15.35 +
   15.36 +  va_start(args, format);
   15.37 +  result = IOStream_vprint(stream, format, args);
   15.38 +  va_end(args);
   15.39 +  return result;
   15.40 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/tools/lib/iostream.h	Tue Jun 29 12:05:29 2004 +0000
    16.3 @@ -0,0 +1,243 @@
    16.4 +#ifndef _XC_LINUX_SAVE_H_
    16.5 +#define _XC_LINUX_SAVE_H_
    16.6 +
    16.7 +#include <stdarg.h>
    16.8 +#include <stdint.h>
    16.9 +#include <stddef.h>
   16.10 +
   16.11 +#ifdef __KERNEL__
   16.12 +#include <linux/errno.h>
   16.13 +#else
   16.14 +#include <errno.h>
   16.15 +#endif
   16.16 +
   16.17 +#include "allocate.h"
   16.18 +
   16.19 +/** End of input return value. */
   16.20 +#define IOSTREAM_EOF -1
   16.21 +
   16.22 +/** An input/output abstraction.
   16.23 + */
   16.24 +typedef struct IOStream IOStream;
   16.25 +
   16.26 +/** Record of the functions to use for operations on an
   16.27 + * IOStream implementation.
   16.28 + */
   16.29 +typedef struct IOMethods {
   16.30 +    /** Read function.  Called with the user data, buffer to read into
   16.31 +     * and number of bytes to read.  Must return number of bytes read
   16.32 +     * on success, less than zero on error.
   16.33 +     */
   16.34 +    int (*read)(IOStream *stream, void *buf, size_t n);
   16.35 +
   16.36 +    /** Write function. Called with user data, buffer to write and
   16.37 +     * number of bytes to write. Must return number of bytes written on
   16.38 +     * success, less than zero otherwise.
   16.39 +     */
   16.40 +    int (*write)(IOStream *stream, const void *buf, size_t n);
   16.41 +
   16.42 +    int (*flush)(IOStream *s);
   16.43 +
   16.44 +    int (*error)(IOStream *s);
   16.45 +
   16.46 +    int (*close)(IOStream *s);
   16.47 +
   16.48 +    void (*free)(IOStream *s);
   16.49 +
   16.50 +    void (*lock)(IOStream *s);
   16.51 +    void (*unlock)(IOStream *s);
   16.52 +
   16.53 +} IOMethods;
   16.54 +
   16.55 +/** Abstract i/o object.
   16.56 + */
   16.57 +struct IOStream {
   16.58 +    /** Methods to use to implement operations. */
   16.59 +    const IOMethods *methods;
   16.60 +    /** Private state for the implementation. */
   16.61 +    const void *data;
   16.62 +    /** Flag indicating whether the stream is closed. */
   16.63 +    int closed;
   16.64 +    /** Number of bytes written. */
   16.65 +    int written;
   16.66 +    /** Number of bytes read. */
   16.67 +    int read;
   16.68 +};
   16.69 +
   16.70 +
   16.71 +/** IOStream version of stdin. */
   16.72 +extern IOStream *iostdin;
   16.73 +
   16.74 +/** IOStream version of stdout, */
   16.75 +extern IOStream *iostdout;
   16.76 +
   16.77 +/** IOStream version of stderr. */
   16.78 +extern IOStream *iostderr;
   16.79 +
   16.80 +extern int IOStream_print(IOStream *io, const char *format, ...);
   16.81 +extern int IOStream_vprint(IOStream *io, const char *format, va_list args);
   16.82 +
   16.83 +/** Read from a stream.
   16.84 + *
   16.85 + * @param stream input
   16.86 + * @param buf where to put input
   16.87 + * @param n number of bytes to read
   16.88 + * @return if ok, number of bytes read, otherwise negative error code
   16.89 + */
   16.90 +static inline int IOStream_read(IOStream *stream, void *buf, size_t n){
   16.91 +    int result = 0;
   16.92 +    if(stream->closed) goto exit;
   16.93 +    if(!stream->methods || !stream->methods->read){
   16.94 +        result = -EINVAL;
   16.95 +        goto exit;
   16.96 +    }
   16.97 +    result = stream->methods->read(stream, buf, n);
   16.98 +    if(result > 0){
   16.99 +        stream->read += result;
  16.100 +    }
  16.101 +  exit:
  16.102 +    return result;
  16.103 +}
  16.104 +
  16.105 +/** Write to a stream.
  16.106 + *
  16.107 + * @param stream input
  16.108 + * @param buf where to put input
  16.109 + * @param n number of bytes to write
  16.110 + * @return if ok, number of bytes read, otherwise negative error code
  16.111 + */
  16.112 +static inline int IOStream_write(IOStream *stream, const void *buf, size_t n){
  16.113 +    int result = 0;
  16.114 +    if(stream->closed) goto exit;
  16.115 +    if(!stream->methods || !stream->methods->write){
  16.116 +        result = -EINVAL;
  16.117 +        goto exit;
  16.118 +    }
  16.119 +    result = stream->methods->write(stream, buf, n);
  16.120 +    if(result > 0){
  16.121 +        stream->written += result;
  16.122 +    }
  16.123 +  exit:
  16.124 +    return result;
  16.125 +}
  16.126 +
  16.127 +/** Flush the stream.
  16.128 + *
  16.129 + * @param stream stream
  16.130 + * @return 0 on success, IOSTREAM_EOF otherwise
  16.131 + */
  16.132 +static inline int IOStream_flush(IOStream *stream){
  16.133 +    int result = 0;
  16.134 +    if(stream->closed){
  16.135 +        result = IOSTREAM_EOF;
  16.136 +    } else if(stream->methods->flush){
  16.137 +        result = stream->methods->flush(stream);
  16.138 +        if(result < 0) result = IOSTREAM_EOF;
  16.139 +    }
  16.140 +    return result;
  16.141 +}
  16.142 +
  16.143 +/** Check whether the stream has an error.
  16.144 + *
  16.145 + * @param stream to check
  16.146 + * @return 1 for error, 0 otherwise
  16.147 + */
  16.148 +static inline int IOStream_error(IOStream *stream){
  16.149 +    int err = 0;
  16.150 +    if(stream->methods && stream->methods->error){
  16.151 +       err = stream->methods->error(stream);
  16.152 +    }
  16.153 +    return err;
  16.154 +}
  16.155 +
  16.156 +/** Close the stream.
  16.157 + *
  16.158 + * @param stream to close
  16.159 + * @return 1 for error, 0 otherwise
  16.160 + */
  16.161 +static inline int IOStream_close(IOStream *stream){
  16.162 +    int err = 1;
  16.163 +    if(stream->methods && stream->methods->close){
  16.164 +        err = stream->methods->close(stream);
  16.165 +    }
  16.166 +    return err;
  16.167 +}
  16.168 +
  16.169 +/** Test if the stream has been closed.
  16.170 + *
  16.171 + * @param stream to check
  16.172 + * @return 1 if closed, 0 otherwise
  16.173 + */
  16.174 +static inline int IOStream_is_closed(IOStream *stream){
  16.175 +  return stream->closed;
  16.176 +}
  16.177 +
  16.178 +/** Free the memory used by the stream.
  16.179 + *
  16.180 + * @param stream to free
  16.181 + */
  16.182 +static inline void IOStream_free(IOStream *stream){
  16.183 +  if(stream->methods && stream->methods->free){
  16.184 +    stream->methods->free(stream);
  16.185 +  }
  16.186 +  *stream = (IOStream){};
  16.187 +  deallocate(stream);
  16.188 +}
  16.189 +
  16.190 +
  16.191 +/** Print a character to a stream, like fputc().
  16.192 + *
  16.193 + * @param stream to print to
  16.194 + * @param c character to print
  16.195 + * @return result code from the print
  16.196 + */
  16.197 +static inline int IOStream_putc(IOStream *stream, int c){
  16.198 +    int err;
  16.199 +    unsigned char b = (unsigned char)c;
  16.200 +    err = IOStream_write(stream, &b, 1);
  16.201 +    if(err < 1){
  16.202 +        err = IOSTREAM_EOF;
  16.203 +    } else {
  16.204 +        err = b;
  16.205 +    }
  16.206 +    return err;
  16.207 +}
  16.208 +
  16.209 +/** Read from a stream, like fgetc().
  16.210 + *
  16.211 + * @param stream to read from
  16.212 + * @return IOSTREAM_EOF on error, character read otherwise
  16.213 + */
  16.214 +static inline int IOStream_getc(IOStream *stream){
  16.215 +    int err, rc;
  16.216 +    unsigned char b;
  16.217 +
  16.218 +    err = IOStream_read(stream, &b, 1);
  16.219 +    if(err < 1){
  16.220 +        rc = IOSTREAM_EOF;
  16.221 +    } else {
  16.222 +        rc = b;
  16.223 +    }
  16.224 +    return rc;
  16.225 +}
  16.226 +
  16.227 +/** Get number of bytes read.
  16.228 + *
  16.229 + * @param stream to get from
  16.230 + * @return number of bytes read
  16.231 + */
  16.232 +static inline int IOStream_get_read(IOStream *stream){
  16.233 +    return stream->read;
  16.234 +}
  16.235 +
  16.236 +/** Get number of bytes written.
  16.237 + *
  16.238 + * @param stream to get from
  16.239 + * @return number of bytes written
  16.240 + */
  16.241 +static inline int IOStream_get_written(IOStream *stream){
  16.242 +    return stream->written;
  16.243 +}
  16.244 +
  16.245 +
  16.246 +#endif /* ! _XC_LINUX_SAVE_H_ */

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/tools/lib/kernel_stream.c	Tue Jun 29 12:05:29 2004 +0000
    17.3 @@ -0,0 +1,177 @@
    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 +/** @file
   17.23 + * An IOStream implementation using printk() for output.
   17.24 + * Input is not implemented.
   17.25 + */
   17.26 +#ifdef __KERNEL__
   17.27 +
   17.28 +#include <linux/config.h>
   17.29 +#include <linux/module.h>
   17.30 +#include <linux/kernel.h>
   17.31 +#include <linux/types.h>
   17.32 +#include <linux/errno.h>
   17.33 +#include <linux/slab.h>
   17.34 +#include <linux/spinlock.h>
   17.35 +
   17.36 +#include "kernel_stream.h"
   17.37 +#include "allocate.h"
   17.38 +
   17.39 +/** Number of characters in the output buffer.
   17.40 + * The kernel uses 1024 for printk, so that should suffice.
   17.41 + */
   17.42 +#define BUF_N 1024
   17.43 +
   17.44 +/** State for a kernel stream. */
   17.45 +typedef struct KernelData {
   17.46 +    /** Stream lock. We need a lock to serialize access to the stream. */
   17.47 +    spinlock_t lock;
   17.48 +    /** Saved flags for locking. */
   17.49 +    unsigned long flags;
   17.50 +    /** Size of the output buffer. */
   17.51 +    int buf_n;
   17.52 +    /** Output buffer. */
   17.53 +    char buf[BUF_N];
   17.54 +} KernelData;
   17.55 +
   17.56 +static int kernel_write(IOStream *s, const char *msg, int n);
   17.57 +static void kernel_free(IOStream *s);
   17.58 +static void kernel_stream_lock(IOStream *s);
   17.59 +static void kernel_stream_unlock(IOStream *s);
   17.60 +
   17.61 +/** Methods for a kernel stream. Output only. */
   17.62 +static const IOMethods kernel_methods = {
   17.63 +  write:  kernel_write,
   17.64 +  free:   kernel_free,
   17.65 +  lock:   kernel_stream_lock,
   17.66 +  unlock: kernel_stream_unlock,
   17.67 +};
   17.68 +
   17.69 +/** Shared state for kernel streams.
   17.70 + * All implementations write using printk, so we can use
   17.71 + * shared state and avoid allocating it.
   17.72 + */
   17.73 +static const KernelData kernel_data = {
   17.74 +  lock: SPIN_LOCK_UNLOCKED,
   17.75 +  flags: 0,
   17.76 +  buf_n: BUF_N,
   17.77 +};
   17.78 +
   17.79 +/** Stream for kernel printk. */
   17.80 +static IOStream iokernel = {
   17.81 +    methods: &kernel_methods,
   17.82 +    data:    &kernel_data,
   17.83 +};
   17.84 +
   17.85 +/** Stream for kernel printk. */
   17.86 +IOStream *iostdout = &iokernel;
   17.87 +
   17.88 +/** Stream for kernel printk. */
   17.89 +IOStream *iostdin = &iokernel;
   17.90 +
   17.91 +/** Stream for kernel printk. */
   17.92 +IOStream *iostderr = &iokernel;
   17.93 +
   17.94 +/** Get an output-only stream implementation using
   17.95 + * printk(). The stream uses static storage, and must not be freed.
   17.96 + *
   17.97 + * @return kernel stream
   17.98 + */
   17.99 +IOStream get_stream_kernel(void){
  17.100 +  return iokernel;
  17.101 +}
  17.102 +
  17.103 +/** Obtain the lock on the stream state.
  17.104 + *
  17.105 + * @param kdata stream state
  17.106 + */
  17.107 +static inline void KernelData_lock(KernelData *kdata){
  17.108 +  spin_lock_irqsave(&kdata->lock, kdata->flags);
  17.109 +}
  17.110 +
  17.111 +/** Release the lock on the stream state.
  17.112 + *
  17.113 + * @param kdata stream state
  17.114 + */
  17.115 +static inline void KernelData_unlock(KernelData *kdata){
  17.116 +  spin_unlock_irqrestore(&kdata->lock, kdata->flags);
  17.117 +}
  17.118 +
  17.119 +/** Get the stream state.
  17.120 + *
  17.121 + * @param s kernel stream
  17.122 + * @return stream state
  17.123 + */
  17.124 +static inline KernelData *get_kernel_data(IOStream *s){
  17.125 +  return (KernelData*)s->data;
  17.126 +}
  17.127 +
  17.128 +/** Obtain the lock on the stream state.
  17.129 + *
  17.130 + * @param s stream
  17.131 + */
  17.132 +void kernel_stream_lock(IOStream *s){
  17.133 +    KernelData_lock(get_kernel_data(s));
  17.134 +}
  17.135 +
  17.136 +/** Release the lock on the stream state.
  17.137 + *
  17.138 + * @param s stream
  17.139 + */
  17.140 +void kernel_stream_unlock(IOStream *s){
  17.141 +    KernelData_unlock(get_kernel_data(s));
  17.142 +}
  17.143 +
  17.144 +/** Write to a kernel stream.
  17.145 + *
  17.146 + * @param stream kernel stream
  17.147 + * @param format print format
  17.148 + * @param args print arguments
  17.149 + * @return result of the print
  17.150 + */
  17.151 +static int kernel_write(IOStream *stream, const char *buf, int n){
  17.152 +  KernelData *kdata = get_kernel_data(stream);
  17.153 +  int k;
  17.154 +  k = kdata->buf_n - 1;
  17.155 +  if(n < k) k = n;
  17.156 +  memcpy(kdata->buf, buf, k);
  17.157 +  kdata->buf[k] = '\0'
  17.158 +  printk(kdata->buf);
  17.159 +  return k;
  17.160 +}
  17.161 +
  17.162 +/** Free a kernel stream.
  17.163 + * Frees the internal state of the stream.
  17.164 + * Do not call this unless the stream was dynamically allocated.
  17.165 + * Do not call this on a stream returned from get_stream_kernel().
  17.166 + *
  17.167 + * @param io stream to free
  17.168 + */
  17.169 +static void kernel_free(IOStream *io){
  17.170 +  KernelData *kdata;
  17.171 +  if(io == &iokernel) return;
  17.172 +  kdata = get_kernel_data(io);
  17.173 +  zero(kdata, sizeof(*kdata));
  17.174 +  deallocate(kdata);
  17.175 +}
  17.176 +#endif /* __KERNEL__ */
  17.177 +
  17.178 +
  17.179 +
  17.180 +

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/tools/lib/kernel_stream.h	Tue Jun 29 12:05:29 2004 +0000
    18.3 @@ -0,0 +1,29 @@
    18.4 +/*
    18.5 + * Copyright (C) 2001 - 2004 Mike Wray <mike.wray@hp.com>
    18.6 + *
    18.7 + * This library is free software; you can redistribute it and/or modify
    18.8 + * it under the terms of the GNU Lesser General Public License as published by
    18.9 + * the Free Software Foundation; either version 2.1 of the License, or
   18.10 + * (at your option) any later version.
   18.11 + *
   18.12 + * This library is distributed in the hope that it will be useful,
   18.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   18.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18.15 + * GNU Lesser General Public License for more details.
   18.16 + *
   18.17 + * You should have received a copy of the GNU Lesser General Public License
   18.18 + * along with this library; if not, write to the Free Software
   18.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   18.20 + */
   18.21 +
   18.22 +#ifndef _XEN_LIB_KERNEL_STREAM_H_
   18.23 +#define _XEN_LIB_KERNEL_STREAM_H_
   18.24 +
   18.25 +#ifdef __KERNEL__
   18.26 +#include "iostream.h"
   18.27 +
   18.28 +extern IOStream get_stream_kernel(void);
   18.29 +#define get_stream_stdout get_stream_kernel
   18.30 +
   18.31 +#endif /* __KERNEL__ */
   18.32 +#endif /* !_XEN_LIB_KERNEL_STREAM_H_ */

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/tools/lib/lexis.c	Tue Jun 29 12:05:29 2004 +0000
    19.3 @@ -0,0 +1,93 @@
    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 +/** @file
   19.21 + * Lexical analysis.
   19.22 + */
   19.23 +
   19.24 +#include "sys_string.h"
   19.25 +#include "lexis.h"
   19.26 +#include <errno.h>
   19.27 +
   19.28 +/** Check if a value lies in a (closed) range.
   19.29 + *
   19.30 + * @param x value to test
   19.31 + * @param lo low end of the range
   19.32 + * @param hi high end of the range
   19.33 + * @return 1 if x is in the interval [lo, hi], 0 otherwise
   19.34 + */
   19.35 +inline static int in_range(int x, int lo, int hi){
   19.36 +    return (lo <= x) && (x <= hi);
   19.37 +}
   19.38 +
   19.39 +/** Determine if a string is an (unsigned) decimal number.
   19.40 + * 
   19.41 + * @param s pointer to characters to test
   19.42 + * @param n length of string
   19.43 + * @return 1 if s is a decimal number, 0 otherwise.
   19.44 + */
   19.45 +int is_decimal_number(const char *s, int n){
   19.46 +    int i;
   19.47 +    if(n <= 0)return 0;
   19.48 +    for(i = 0; i < n; i++){
   19.49 +        if(!in_decimal_digit_class(s[i])) return 0;
   19.50 +    }
   19.51 +    return 1;
   19.52 +}
   19.53 +
   19.54 +/** Determine if a string is a hex number.
   19.55 + * Hex numbers are 0, or start with 0x or 0X followed
   19.56 + * by a non-zero number of hex digits (0-9,a-f,A-F).
   19.57 + * 
   19.58 + * @param s pointer to characters to test
   19.59 + * @param n length of string
   19.60 + * @return 1 if s is a hex number, 0 otherwise.
   19.61 + */
   19.62 +int is_hex_number(const char *s, int n){
   19.63 +    int i;
   19.64 +    if(n <= 0) return 0;
   19.65 +    if(n == 1){
   19.66 +        return s[0]=='0';
   19.67 +    }
   19.68 +    if(n <= 3) return 0;
   19.69 +    if(s[0] != '0' || (s[1] != 'x' && s[1] != 'X')) return 0;
   19.70 +    for(i = 2; i < n; i++){
   19.71 +        if(!in_hex_digit_class(s[i])) return 0;
   19.72 +    }
   19.73 +    return 1;
   19.74 +}
   19.75 +
   19.76 +/** Test if a string matches a keyword.
   19.77 + * The comparison is case-insensitive.
   19.78 + * The comparison fails if either argument is null.
   19.79 + *
   19.80 + * @param s string
   19.81 + * @param k keyword
   19.82 + * @return 1 if they match, 0 otherwise
   19.83 + */
   19.84 +int is_keyword(const char *s, const char *k){
   19.85 +  return s && k && !strcasecmp(s, k);
   19.86 +}
   19.87 +
   19.88 +/** Test if a string matches a character.
   19.89 + *
   19.90 + * @param s string
   19.91 + * @param c character (non-null)
   19.92 + * @return 1 if s contains exactly c, 0 otherwise
   19.93 + */
   19.94 +int is_keychar(const char *s, char c){
   19.95 +  return c && (s[0] == c) && !s[1];
   19.96 +}

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/tools/lib/lexis.h	Tue Jun 29 12:05:29 2004 +0000
    20.3 @@ -0,0 +1,122 @@
    20.4 +/*
    20.5 + *
    20.6 + * This library is free software; you can redistribute it and/or modify
    20.7 + * it under the terms of the GNU Lesser General Public License as
    20.8 + * published by the Free Software Foundation; either version 2.1 of the
    20.9 + * License, or  (at your option) any later version. This library is 
   20.10 + * distributed in the  hope that it will be useful, but WITHOUT ANY
   20.11 + * WARRANTY; without even the implied warranty of MERCHANTABILITY or
   20.12 + * FITNESS FOR A PARTICULAR PURPOSE.
   20.13 + * See the GNU Lesser General Public License for more details.
   20.14 + *
   20.15 + * You should have received a copy of the GNU Lesser General Public License
   20.16 + * along with this library; if not, write to the Free Software Foundation,
   20.17 + * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   20.18 + */
   20.19 +
   20.20 +#ifndef _SP_LEXIS_H_
   20.21 +#define _SP_LEXIS_H_
   20.22 +
   20.23 +#include "sys_string.h"
   20.24 +#include "sys_ctype.h"
   20.25 +
   20.26 +/** @file
   20.27 + * Lexical analysis.
   20.28 + */
   20.29 +
   20.30 +/** Class of characters treated as space. */
   20.31 +#define space_class ((char []){ '\n', '\r', '\t', ' ', '\f' , 0 })
   20.32 +
   20.33 +/** Class of separator characters. */
   20.34 +#define sep_class "{}()<>[]@!;"
   20.35 +
   20.36 +#define comment_class "#"
   20.37 +
   20.38 +/** Determine if a character is in a given class.
   20.39 + * 
   20.40 + * @param c character to test
   20.41 + * @param s null-terminated string of characters in the class
   20.42 + * @return 1 if c is in the class, 0 otherwise.
   20.43 + */
   20.44 +static inline int in_class(int c, const char *s){
   20.45 +  return s && (strchr(s, c) != 0);
   20.46 +}
   20.47 +
   20.48 +/** Determine if a character is in the space class.
   20.49 + * 
   20.50 + * @param c character to test
   20.51 + * @return 1 if c is in the class, 0 otherwise.
   20.52 + */
   20.53 +static inline int in_space_class(int c){
   20.54 +    return in_class(c, space_class);
   20.55 +}
   20.56 +
   20.57 +static inline int in_comment_class(int c){
   20.58 +    return in_class(c, comment_class);
   20.59 +}
   20.60 +
   20.61 +/** Determine if a character is in the separator class.
   20.62 + * Separator characters terminate tokens, and do not need space
   20.63 + * to separate them.
   20.64 + * 
   20.65 + * @param c character to test
   20.66 + * @return 1 if c is in the class, 0 otherwise.
   20.67 + */
   20.68 +static inline int in_sep_class(int c){
   20.69 +    return in_class(c, sep_class);
   20.70 +}
   20.71 +
   20.72 +/** Determine if a character is in the alpha class.
   20.73 + * 
   20.74 + * @param c character to test
   20.75 + * @return 1 if c is in the class, 0 otherwise.
   20.76 + */
   20.77 +static inline int in_alpha_class(int c){
   20.78 +    return isalpha(c);
   20.79 +}
   20.80 +
   20.81 +/** Determine if a character is in the octal digit class.
   20.82 + * 
   20.83 + * @param c character to test
   20.84 + * @return 1 if c is in the class, 0 otherwise.
   20.85 + */
   20.86 +static inline int in_octal_digit_class(int c){
   20.87 +    return '0' <= c && c <= '7';
   20.88 +}
   20.89 +
   20.90 +/** Determine if a character is in the decimal digit class.
   20.91 + * 
   20.92 + * @param c character to test
   20.93 + * @return 1 if c is in the class, 0 otherwise.
   20.94 + */
   20.95 +static inline int in_decimal_digit_class(int c){
   20.96 +    return isdigit(c);
   20.97 +}
   20.98 +
   20.99 +/** Determine if a character is in the hex digit class.
  20.100 + * 
  20.101 + * @param c character to test
  20.102 + * @return 1 if c is in the class, 0 otherwise.
  20.103 + */
  20.104 +static inline int in_hex_digit_class(int c){
  20.105 +    return isdigit(c) || in_class(c, "abcdefABCDEF");
  20.106 +}
  20.107 +
  20.108 +
  20.109 +static inline int in_string_quote_class(int c){
  20.110 +    return in_class(c, "'\"");
  20.111 +}
  20.112 +
  20.113 +static inline int in_printable_class(int c){
  20.114 +    return ('A' <= c && c <= 'Z')
  20.115 +        || ('a' <= c && c <= 'z')
  20.116 +        || ('0' <= c && c <= '9')
  20.117 +        || in_class(c, "!$%&*+,-./:;<=>?@^_`{|}~");
  20.118 +}
  20.119 +
  20.120 +extern int is_decimal_number(const char *s, int n);
  20.121 +extern int is_hex_number(const char *s, int n);
  20.122 +extern int is_keyword(const char *s, const char *k);
  20.123 +extern int is_keychar(const char *s, char c);
  20.124 +
  20.125 +#endif /* !_SP_LEXIS_H_ */

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/tools/lib/lzi_stream.c	Tue Jun 29 12:05:29 2004 +0000
    21.3 @@ -0,0 +1,590 @@
    21.4 +/* $Id: lzi_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $ */
    21.5 +#define __FILE_ID_INFO "$Id: lzi_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $"
    21.6 +#include <what.h>
    21.7 +static char __rcsid[] __attribute__((unused)) = WHAT_ID __FILE_ID_INFO;
    21.8 +/*
    21.9 + * Copyright (C) 2003 Hewlett-Packard Company.
   21.10 + *
   21.11 + * This library is free software; you can redistribute it and/or modify
   21.12 + * it under the terms of the GNU Lesser General Public License as published by
   21.13 + * the Free Software Foundation; either version 2.1 of the License, or
   21.14 + * (at your option) any later version.
   21.15 + *
   21.16 + * This library is distributed in the hope that it will be useful,
   21.17 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   21.18 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   21.19 + * GNU Lesser General Public License for more details.
   21.20 + *
   21.21 + * You should have received a copy of the GNU Lesser General Public License
   21.22 + * along with this library; if not, write to the Free Software
   21.23 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   21.24 + */
   21.25 +
   21.26 +/** @file
   21.27 + * An IOStream implementation using LZI to provide compression and decompression.
   21.28 + * This is designed to provide compression without output latency.
   21.29 + * Flushing an LZI stream flushes all pending data to the underlying stream.
   21.30 + * This is essential for stream-based (e.g. networked) applications.
   21.31 + *
   21.32 + * A compressed data stream is a sequence of blocks.
   21.33 + * Each block is the block size followed by the compressed data.
   21.34 + * The last block has size zero.
   21.35 + * Sizes are 4-byte unsigned in network order.
   21.36 + *
   21.37 + * This format allows compressed data to be read from a stream without reading
   21.38 + * past the logical end of compressed data.
   21.39 + *
   21.40 + * @author Mike Wray <mike.wray@hpl.hp.com>
   21.41 + */
   21.42 +#ifndef __KERNEL__
   21.43 +
   21.44 +#include <stdio.h>
   21.45 +#include <stdlib.h>
   21.46 +#include <errno.h>
   21.47 +#include <string.h>
   21.48 +
   21.49 +#include "zlib.h"
   21.50 +
   21.51 +#include "allocate.h"
   21.52 +#include "lzi_stream.h"
   21.53 +#include "file_stream.h"
   21.54 +#include "marshal.h"
   21.55 +
   21.56 +#define dprintf(fmt, args...) fprintf(stdout, "[DEBUG] LZI>%s" fmt, __FUNCTION__, ##args)
   21.57 +#define wprintf(fmt, args...) fprintf(stderr, "[WARN]  LZI>%s" fmt, __FUNCTION__, ##args)
   21.58 +#define iprintf(fmt, args...) fprintf(stdout, "[INFO]  LZI>%s" fmt, __FUNCTION__, ##args)
   21.59 +#define eprintf(fmt, args...) fprintf(stderr, "[ERROR] LZI>%s" fmt, __FUNCTION__, ##args)
   21.60 +
   21.61 +static int lzi_read(IOStream *s, void *buf, size_t size, size_t count);
   21.62 +static int lzi_write(IOStream *s, const void *buf, size_t size, size_t count);
   21.63 +static int lzi_print(IOStream *s, const char *msg, va_list args);
   21.64 +static int lzi_getc(IOStream *s);
   21.65 +static int lzi_error(IOStream *s);
   21.66 +static int lzi_close(IOStream *s);
   21.67 +static void lzi_free(IOStream *s);
   21.68 +static int lzi_flush(IOStream *s);
   21.69 +
   21.70 +enum {
   21.71 +    LZI_WRITE = 1,
   21.72 +    LZI_READ = 2,
   21.73 +};
   21.74 +
   21.75 +/** Methods used by a gzFile* IOStream. */
   21.76 +static const IOMethods lzi_methods = {
   21.77 +    read: lzi_read,
   21.78 +    write: lzi_write,
   21.79 +    print: lzi_print,
   21.80 +    getc:  lzi_getc,
   21.81 +    error: lzi_error,
   21.82 +    close: lzi_close,
   21.83 +    free:  lzi_free,
   21.84 +    flush: lzi_flush,
   21.85 +};
   21.86 +
   21.87 +#define BUFFER_SIZE (512 * 1024)
   21.88 +
   21.89 +typedef struct LZIState {
   21.90 +    z_stream zstream;
   21.91 +    void *inbuf;
   21.92 +    uint32_t inbuf_size;
   21.93 +    void *outbuf;
   21.94 +    uint32_t outbuf_size;
   21.95 +    /** Underlying stream for I/O. */
   21.96 +    IOStream *io;
   21.97 +    /** Flags. */
   21.98 +    int flags;
   21.99 +    /** Error indicator. */
  21.100 +    int error;
  21.101 +    int eof;
  21.102 +    int plain_bytes;
  21.103 +    int comp_bytes;
  21.104 +    int zstream_initialized;
  21.105 +    int flushed;
  21.106 +} LZIState;
  21.107 +
  21.108 +static inline int LZIState_writeable(LZIState *s){
  21.109 +    return (s->flags & LZI_WRITE) != 0;
  21.110 +}
  21.111 +
  21.112 +static inline int LZIState_readable(LZIState *s){
  21.113 +    return (s->flags & LZI_READ) != 0;
  21.114 +}
  21.115 +
  21.116 +void LZIState_free(LZIState *z){
  21.117 +    if(!z) return;
  21.118 +    if(z->zstream_initialized){
  21.119 +        if(LZIState_writeable(z)){
  21.120 +            deflateEnd(&z->zstream);
  21.121 +        } else if(LZIState_readable(z)){
  21.122 +            inflateEnd(&z->zstream);
  21.123 +        }
  21.124 +    }
  21.125 +    deallocate(z->inbuf);
  21.126 +    deallocate(z->outbuf);
  21.127 +    deallocate(z);
  21.128 +}
  21.129 +
  21.130 +static int mode_flags(const char *mode, int *flags){
  21.131 +    int err = 0;
  21.132 +    int r=0, w=0;
  21.133 +    if(!mode){
  21.134 +        err = -EINVAL;
  21.135 +        goto exit;
  21.136 +    }
  21.137 +    for(; *mode; mode++){
  21.138 +        if(*mode == 'w') w = 1;
  21.139 +        if(*mode == 'r') r = 1;
  21.140 +    }
  21.141 +    if(r + w != 1){
  21.142 +        err = -EINVAL;
  21.143 +        goto exit;
  21.144 +    }
  21.145 +    if(r) *flags |= LZI_READ;
  21.146 +    if(w) *flags |= LZI_WRITE;
  21.147 +  exit:
  21.148 +    return err;
  21.149 +}
  21.150 +
  21.151 +/** Get the stream state.
  21.152 + * 
  21.153 + * @param s lzi stream
  21.154 + * @return stream state.
  21.155 + */
  21.156 +static inline LZIState * lzi_state(IOStream *io){
  21.157 +    return io->data;
  21.158 +}
  21.159 +
  21.160 +IOStream *lzi_stream_io(IOStream *io){
  21.161 +    LZIState *s = lzi_state(io);
  21.162 +    return s->io;
  21.163 +}
  21.164 +
  21.165 +static inline void set_error(LZIState *s, int err){
  21.166 +    if(err < 0 && !s->error){
  21.167 +        s->error = err;
  21.168 +    }
  21.169 +}
  21.170 +
  21.171 +static int zerror(LZIState *s, int err){
  21.172 +    if(err){
  21.173 +        //dprintf("> err=%d\n", err);
  21.174 +        if(err < 0) set_error(s, -EIO);
  21.175 +    }
  21.176 +    return s->error;
  21.177 +}
  21.178 +
  21.179 +int lzi_stream_plain_bytes(IOStream *io){
  21.180 +    LZIState *s = lzi_state(io);
  21.181 +    return s->plain_bytes;
  21.182 +}
  21.183 +
  21.184 +int lzi_stream_comp_bytes(IOStream *io){
  21.185 +    LZIState *s = lzi_state(io);
  21.186 +    return s->comp_bytes;
  21.187 +}
  21.188 +
  21.189 +float lzi_stream_ratio(IOStream *io){
  21.190 +    LZIState *s = lzi_state(io);
  21.191 +    float ratio = 0.0;
  21.192 +    if(s->comp_bytes){
  21.193 +        ratio = ((float) s->comp_bytes)/((float) s->plain_bytes);
  21.194 +    }
  21.195 +    return ratio;
  21.196 +}
  21.197 +
  21.198 +static int alloc(void **p, int n){
  21.199 +    *p = allocate(n);
  21.200 +    return (p ? 0 : -ENOMEM);
  21.201 +}
  21.202 +
  21.203 +LZIState * LZIState_new(IOStream *io, int flags){
  21.204 +    int err = -ENOMEM;
  21.205 +    int zlevel = Z_BEST_SPEED; // Level 1 compression - fastest.
  21.206 +    int zstrategy = Z_DEFAULT_STRATEGY;
  21.207 +    int zwindow = MAX_WBITS;
  21.208 +    int zmemory = 8;
  21.209 +    LZIState *z = ALLOCATE(LZIState);
  21.210 +
  21.211 +    //dprintf(">\n");
  21.212 +    if(!z) goto exit;
  21.213 +    z->io = io;
  21.214 +    z->flags = flags;
  21.215 +
  21.216 +    if(LZIState_writeable(z)){
  21.217 +        z->outbuf_size = BUFFER_SIZE;
  21.218 +        /* windowBits is passed < 0 to suppress zlib header */
  21.219 +        err = deflateInit2(&z->zstream, zlevel, Z_DEFLATED, -zwindow, zmemory, zstrategy);
  21.220 +        if (err != Z_OK) goto exit;
  21.221 +        z->zstream_initialized = 1;
  21.222 +        err = alloc(&z->outbuf, z->outbuf_size);
  21.223 +        if(err) goto exit;
  21.224 +        z->zstream.next_out = z->outbuf;
  21.225 +        z->zstream.avail_out = z->outbuf_size;
  21.226 +    } else {
  21.227 +        z->inbuf_size = BUFFER_SIZE;
  21.228 +        err = alloc(&z->inbuf, z->inbuf_size);
  21.229 +        if(err) goto exit;
  21.230 +        ///z->zstream.next_in  = z->inbuf;
  21.231 +
  21.232 +        /* windowBits is passed < 0 to tell that there is no zlib header.
  21.233 +         * Note that in this case inflate *requires* an extra "dummy" byte
  21.234 +         * after the compressed stream in order to complete decompression and
  21.235 +         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
  21.236 +         * present after the compressed stream.
  21.237 +         */
  21.238 +        err = inflateInit2(&z->zstream, -zwindow);
  21.239 +        if(err != Z_OK) goto exit;
  21.240 +        z->zstream_initialized = 1;
  21.241 +    }
  21.242 +        
  21.243 +  exit:
  21.244 +    if(err){
  21.245 +        LZIState_free(z);
  21.246 +        z = NULL;
  21.247 +    }
  21.248 +    //dprintf("< z=%p\n", z);
  21.249 +    return z;
  21.250 +}
  21.251 +
  21.252 +int read_block(LZIState *s){
  21.253 +    int err = 0, k = 0;
  21.254 +    //dprintf(">\n");
  21.255 +    if(s->eof) goto exit;
  21.256 +    err = unmarshal_uint32(s->io, &k);
  21.257 +    if(err) goto exit;
  21.258 +    if(k > s->inbuf_size){
  21.259 +        err = -EINVAL;
  21.260 +        goto exit;
  21.261 +    }
  21.262 +    if(k){
  21.263 +        err = unmarshal_bytes(s->io, s->inbuf, k);
  21.264 +        if(err) goto exit;
  21.265 +    } else {
  21.266 +        s->eof = 1;
  21.267 +    }        
  21.268 +    s->zstream.avail_in = k;
  21.269 +    s->zstream.next_in = s->inbuf;
  21.270 +    s->comp_bytes += 4;
  21.271 +    s->comp_bytes += k;
  21.272 +  exit:
  21.273 +    //dprintf("< err=%d\n", err);
  21.274 +    return err;
  21.275 +}
  21.276 +
  21.277 +int write_block(LZIState *s){
  21.278 +    int err = 0;
  21.279 +    int k = ((char*)s->zstream.next_out) - ((char*)s->outbuf);
  21.280 +    int k2 = s->outbuf_size - s->zstream.avail_out;
  21.281 +    //dprintf("> k=%d k2=%d\n", k, k2);
  21.282 +    if(!k) goto exit;
  21.283 +    err = marshal_uint32(s->io, k);
  21.284 +    if(err) goto exit;
  21.285 +    err = marshal_bytes(s->io, s->outbuf, k);
  21.286 +    if(err) goto exit;
  21.287 +    s->zstream.next_out = s->outbuf;
  21.288 +    s->zstream.avail_out = s->outbuf_size;
  21.289 +    s->comp_bytes += 4;
  21.290 +    s->comp_bytes += k;
  21.291 +  exit:
  21.292 +    //dprintf("< err=%d\n", err);
  21.293 +    return err;
  21.294 +}
  21.295 +
  21.296 +int write_terminator(LZIState *s){
  21.297 +    int err = 0;
  21.298 +    char c = 0;
  21.299 +    err = marshal_uint32(s->io, 1);
  21.300 +    if(err) goto exit;
  21.301 +    err = marshal_bytes(s->io, &c, 1);
  21.302 +    if(err) goto exit;
  21.303 +    err = marshal_uint32(s->io, 0);
  21.304 +    if(err) goto exit;
  21.305 +    s->comp_bytes += 9;
  21.306 +  exit:
  21.307 +    return err;
  21.308 +}
  21.309 +
  21.310 +/** Write to the underlying stream using fwrite();
  21.311 + *
  21.312 + * @param io destination
  21.313 + * @param buf data
  21.314 + * @param size size of data elements
  21.315 + * @param count number of data elements to write
  21.316 + * @return number of data elements written
  21.317 + */
  21.318 +static int lzi_write(IOStream *io, const void *buf, size_t size, size_t count){
  21.319 +    int err = 0;
  21.320 +    int n = size * count;
  21.321 +    LZIState *s = lzi_state(io);
  21.322 +
  21.323 +    //dprintf("> buf=%p size=%d count=%d n=%d\n", buf, size, count, n);
  21.324 +    if(!LZIState_writeable(s)){
  21.325 +        err = -EINVAL;
  21.326 +        goto exit;
  21.327 +    }
  21.328 +    s->flushed = 0;
  21.329 +    s->zstream.next_in = (void*)buf;
  21.330 +    s->zstream.avail_in = n;
  21.331 +    while(s->zstream.avail_in){
  21.332 +        if(s->zstream.avail_out == 0){
  21.333 +            err = write_block(s);
  21.334 +            if(err) goto exit;
  21.335 +        }
  21.336 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.337 +        //dprintf("> 1 deflate next_in=%p next_out=%p\n", s->zstream.next_in, s->zstream.next_out);
  21.338 +        err = zerror(s, deflate(&s->zstream, Z_NO_FLUSH));
  21.339 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.340 +        //dprintf("> 2 deflate next_in=%p next_out=%p\n", s->zstream.next_in, s->zstream.next_out);
  21.341 +        if(err) goto exit;
  21.342 +    }
  21.343 +    err = n;
  21.344 +    s->plain_bytes += n;
  21.345 +    if(size != 1) err /= size;
  21.346 +  exit:
  21.347 +    //dprintf("< err=%d\n", err);
  21.348 +    return err;
  21.349 +}
  21.350 +
  21.351 +
  21.352 +/** Read from the underlying stream.
  21.353 + *
  21.354 + * @param io input
  21.355 + * @param buf where to put input
  21.356 + * @param size size of data elements
  21.357 + * @param count number of data elements to read
  21.358 + * @return number of data elements read
  21.359 + */
  21.360 +static int lzi_read(IOStream *io, void *buf, size_t size, size_t count){
  21.361 +    int err, zerr;
  21.362 +    int n = size * count;
  21.363 +    LZIState *s = lzi_state(io);
  21.364 +
  21.365 +    //dprintf("> size=%d count=%d n=%d\n", size, count, n);
  21.366 +    if(!LZIState_readable(s)){
  21.367 +        err = -EINVAL;
  21.368 +        goto exit;
  21.369 +    }
  21.370 +    s->zstream.next_out = buf;
  21.371 +    s->zstream.avail_out = n;
  21.372 +    while(s->zstream.avail_out){
  21.373 +        if(s->zstream.avail_in == 0){
  21.374 +            err = read_block(s);
  21.375 +        }
  21.376 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.377 +        zerr = inflate(&s->zstream, Z_NO_FLUSH);
  21.378 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.379 +        if(zerr == Z_STREAM_END) break;
  21.380 +        //dprintf("> zerr=%d\n", zerr);
  21.381 +        err = zerror(s, zerr);
  21.382 +        if(err) goto exit;
  21.383 +    }
  21.384 +    err = n - s->zstream.avail_out;
  21.385 +    s->plain_bytes += err;
  21.386 +    if(size != 1) err /= size;
  21.387 +  exit:
  21.388 +    set_error(s, err);
  21.389 +    //dprintf("< err=%d\n", err);
  21.390 +    return err;
  21.391 +}
  21.392 +
  21.393 +/** Print to the underlying stream.
  21.394 + * Returns 0 if the formatted output is too big for the internal buffer.
  21.395 + *
  21.396 + * @param io lzi stream
  21.397 + * @param msg format to use
  21.398 + * @param args arguments
  21.399 + * @return result of the print
  21.400 + */
  21.401 +static int lzi_print(IOStream *io, const char *msg, va_list args){
  21.402 +    char buf[1024];
  21.403 +    int buf_n = sizeof(buf);
  21.404 +    int n;
  21.405 +    LZIState *s = lzi_state(io);
  21.406 +    if(!LZIState_writeable(s)){
  21.407 +        n = -EINVAL;
  21.408 +        goto exit;
  21.409 +    }
  21.410 +    n = vsnprintf(buf, buf_n, (char*)msg, args);
  21.411 +    if(n < 0) goto exit;
  21.412 +    if(n > buf_n){
  21.413 +        n = 0;
  21.414 +    } else {
  21.415 +        n = lzi_write(io, buf, 1, n);
  21.416 +    }
  21.417 +  exit:
  21.418 +    return n;
  21.419 +}
  21.420 +
  21.421 +/** Read a character from the underlying stream
  21.422 + *
  21.423 + * @param io lzi stream
  21.424 + * @return character read, IOSTREAM_EOF on end of file (or error)
  21.425 + */
  21.426 +static int lzi_getc(IOStream *io){
  21.427 +    int err;
  21.428 +    char c;
  21.429 +    err = lzi_read(io, &c, 1, 1);
  21.430 +    if(err < 1) c = EOF;
  21.431 +    err = (c==EOF ? IOSTREAM_EOF : c);
  21.432 +    return err;
  21.433 +}
  21.434 +
  21.435 +static int flush_output(LZIState *s, int mode){
  21.436 +    int err = 0, zerr;
  21.437 +    int done = 0;
  21.438 +    int avail_out_old;
  21.439 +    int count = 10;
  21.440 +
  21.441 +    //dprintf("> avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.442 +    if(s->flushed == 1 + mode) goto exit;
  21.443 +    //s->zstream.avail_in = 0; /* should be zero already anyway */
  21.444 +    for(;;){
  21.445 +        // Write any available output.
  21.446 +        if(done || s->zstream.avail_out == 0){
  21.447 +            err = write_block(s);
  21.448 +            if(err) goto exit;
  21.449 +            if(done) break;
  21.450 +        }
  21.451 +        //dprintf("> 1 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.452 +        avail_out_old = s->zstream.avail_out;
  21.453 +        zerr = deflate(&s->zstream, mode);
  21.454 +        err = zerror(s, zerr);
  21.455 +        //dprintf("> 2 deflate avail_in=%d avail_out=%d\n", s->zstream.avail_in, s->zstream.avail_out);
  21.456 +        //dprintf("> deflate=%d\n", err);
  21.457 +        //done = (s->zstream.avail_out != 0);
  21.458 +        //done = (s->zstream.avail_in == 0) && (s->zstream.avail_out == avail_out_old);
  21.459 +        if(0 && mode == Z_FINISH){
  21.460 +            done = (zerr ==  Z_STREAM_END);
  21.461 +        } else {
  21.462 +            done = (s->zstream.avail_in == 0)
  21.463 +                //&& (s->zstream.avail_out == avail_out_old)
  21.464 +                && (s->zstream.avail_out != 0);
  21.465 +        }
  21.466 +    }
  21.467 +    s->flushed = 1 + mode;
  21.468 +  exit:
  21.469 +    //dprintf("< err=%d\n", err);
  21.470 +    return err;
  21.471 +}
  21.472 +
  21.473 +/** Flush any pending input to the underlying stream.
  21.474 + *
  21.475 + * @param s lzi stream
  21.476 + * @return 0 on success, error code otherwise
  21.477 + */
  21.478 +static int lzi_flush(IOStream *io){
  21.479 +    int err = 0;
  21.480 +    LZIState *s = lzi_state(io);
  21.481 +    //dprintf(">\n");
  21.482 +    if(!LZIState_writeable(s)){
  21.483 +        err = -EINVAL;
  21.484 +        goto exit;
  21.485 +    }
  21.486 +    err = flush_output(s, Z_SYNC_FLUSH);
  21.487 +    if(err) goto exit;
  21.488 +    err = IOStream_flush(s->io);
  21.489 +  exit:
  21.490 +    set_error(s, err);
  21.491 +    //dprintf("< err=%d\n", err);
  21.492 +    return (err < 0 ? err : 0);
  21.493 +}
  21.494 +
  21.495 +/** Check if a stream has an error.
  21.496 + *
  21.497 + * @param s lzi stream
  21.498 + * @return code if has an error, 0 otherwise
  21.499 + */
  21.500 +static int lzi_error(IOStream *s){
  21.501 +    int err = 0;
  21.502 +    LZIState *state = lzi_state(s);
  21.503 +    err = state->error;
  21.504 +    if(err) goto exit;
  21.505 +    err = IOStream_error(state->io);
  21.506 +  exit:
  21.507 +    return err;
  21.508 +}
  21.509 +
  21.510 +/** Close an lzi stream.
  21.511 + *
  21.512 + * @param s lzi stream to close
  21.513 + * @return result of the close
  21.514 + */
  21.515 +static int lzi_close(IOStream *io){
  21.516 +    int err = 0;
  21.517 +    LZIState *s = lzi_state(io);
  21.518 +    if(LZIState_writeable(s)){
  21.519 +        err = flush_output(s, Z_FINISH);
  21.520 +        if(err) goto exit;
  21.521 +        err = write_terminator(s);
  21.522 +        if(err) goto exit;
  21.523 +        err = IOStream_flush(s->io);
  21.524 +    }   
  21.525 +  exit:
  21.526 +    err = IOStream_close(s->io);
  21.527 +    set_error(s, err);
  21.528 +    return err;
  21.529 +}
  21.530 +
  21.531 +/** Free an lzi stream.
  21.532 + *
  21.533 + * @param s lzi stream
  21.534 + */
  21.535 +static void lzi_free(IOStream *s){
  21.536 +    LZIState *state = lzi_state(s);
  21.537 +    IOStream_free(state->io);
  21.538 +    LZIState_free(state);
  21.539 +    s->data = NULL;
  21.540 +}
  21.541 +
  21.542 +/** Create an lzi stream for an IOStream.
  21.543 + *
  21.544 + * @param io stream to wrap
  21.545 + * @return new IOStream using f for i/o
  21.546 + */
  21.547 +IOStream *lzi_stream_new(IOStream *io, const char *mode){
  21.548 +    int err = -ENOMEM;
  21.549 +    int flags = 0;
  21.550 +    IOStream *zio = NULL;
  21.551 +    LZIState *state = NULL;
  21.552 +
  21.553 +    zio = ALLOCATE(IOStream);
  21.554 +    if(!zio) goto exit;
  21.555 +    err = mode_flags(mode, &flags);
  21.556 +    if(err) goto exit;
  21.557 +    state = LZIState_new(io, flags);
  21.558 +    if(!state) goto exit;
  21.559 +    err = 0;
  21.560 +    zio->data = state;
  21.561 +    zio->methods = &lzi_methods;
  21.562 +  exit:
  21.563 +    if(err){
  21.564 +        if(state) LZIState_free(state);
  21.565 +        if(zio) deallocate(zio);
  21.566 +        zio = NULL;
  21.567 +    }
  21.568 +    return zio;
  21.569 +}
  21.570 +
  21.571 +/** IOStream version of fdopen().
  21.572 + *
  21.573 + * @param fd file descriptor
  21.574 + * @param flags giving the mode to open in (as for fdopen())
  21.575 + * @return new stream for the open file, or NULL if failed
  21.576 + */
  21.577 +IOStream *lzi_stream_fdopen(int fd, const char *mode){
  21.578 +    int err = -ENOMEM;
  21.579 +    IOStream *io = NULL, *zio = NULL;
  21.580 +    io = file_stream_fdopen(fd, mode);
  21.581 +    if(!io) goto exit;
  21.582 +    zio = lzi_stream_new(io, mode);
  21.583 +    if(!io) goto exit;
  21.584 +    err = 0;
  21.585 +  exit:
  21.586 +    if(err){
  21.587 +        IOStream_free(io);
  21.588 +        IOStream_free(zio);
  21.589 +        zio = NULL;
  21.590 +    }
  21.591 +    return zio;
  21.592 +}
  21.593 +#endif

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/tools/lib/lzi_stream.h	Tue Jun 29 12:05:29 2004 +0000
    22.3 @@ -0,0 +1,36 @@
    22.4 +#/* $Id: lzi_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    22.5 +/*
    22.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    22.7 + *
    22.8 + * This library is free software; you can redistribute it and/or modify
    22.9 + * it under the terms of the GNU Lesser General Public License as published by
   22.10 + * the Free Software Foundation; either version 2.1 of the License, or
   22.11 + * (at your option) any later version.
   22.12 + *
   22.13 + * This library is distributed in the hope that it will be useful,
   22.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   22.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   22.16 + * GNU Lesser General Public License for more details.
   22.17 + *
   22.18 + * You should have received a copy of the GNU Lesser General Public License
   22.19 + * along with this library; if not, write to the Free Software
   22.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   22.21 + */
   22.22 +
   22.23 +#ifndef _SP_LZI_STREAM_H_
   22.24 +#define _SP_LZI_STREAM_H_
   22.25 +
   22.26 +#ifndef __KERNEL__
   22.27 +#include "iostream.h"
   22.28 +
   22.29 +extern IOStream *lzi_stream_new(IOStream *io, const char *mode);
   22.30 +extern IOStream *lzi_stream_fopen(const char *file, const char *mode);
   22.31 +extern IOStream *lzi_stream_fdopen(int fd, const char *mode);
   22.32 +extern IOStream *lzi_stream_io(IOStream *zio);
   22.33 +
   22.34 +extern int lzi_stream_plain_bytes(IOStream *io);
   22.35 +extern int lzi_stream_comp_bytes(IOStream *io);
   22.36 +extern float lzi_stream_ratio(IOStream *io);
   22.37 +
   22.38 +#endif
   22.39 +#endif /* !_SP_FILE_STREAM_H_ */

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/tools/lib/lzo_stream.c	Tue Jun 29 12:05:29 2004 +0000
    23.3 @@ -0,0 +1,596 @@
    23.4 +/* $Id: lzo_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $ */
    23.5 +#define __FILE_ID_INFO "$Id: lzo_stream.c,v 1.4 2003/09/30 15:22:53 mjw Exp $"
    23.6 +#include <what.h>
    23.7 +static char __rcsid[] __attribute__((unused)) = WHAT_ID __FILE_ID_INFO;
    23.8 +/*
    23.9 + * Copyright (C) 2003 Hewlett-Packard Company.
   23.10 + *
   23.11 + * This library is free software; you can redistribute it and/or modify
   23.12 + * it under the terms of the GNU Lesser General Public License as published by
   23.13 + * the Free Software Foundation; either version 2.1 of the License, or
   23.14 + * (at your option) any later version.
   23.15 + *
   23.16 + * This library is distributed in the hope that it will be useful,
   23.17 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   23.18 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   23.19 + * GNU Lesser General Public License for more details.
   23.20 + *
   23.21 + * You should have received a copy of the GNU Lesser General Public License
   23.22 + * along with this library; if not, write to the Free Software
   23.23 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   23.24 + */
   23.25 +
   23.26 +/** @file
   23.27 + * An IOStream implementation using LZO to provide compression and decompression.
   23.28 + * This is designed to provide reasonable compression without output latency.
   23.29 + * Flushing an LZO stream flushes all pending data to the underlying stream.
   23.30 + * This is essential for stream-based (e.g. networked) applications.
   23.31 + *
   23.32 + * A compressed data stream is a sequence of blocks.
   23.33 + * Each block except the last is the plain data size followed by the compressed data size
   23.34 + * and the compressed data. The last block has plain data size zero and omits the rest.
   23.35 + * Sizes are 4-byte unsigned in network order. If the compressed size is smaller than
   23.36 + * the plain size the block data is compressed, otherwise it is plain (uncompressed).
   23.37 + *
   23.38 + * This format allows compressed data to be read from a stream without reading
   23.39 + * past the logical end of compressed data.
   23.40 + *
   23.41 + * @author Mike Wray <mike.wray@hpl.hp.com>
   23.42 + */
   23.43 +#ifndef __KERNEL__
   23.44 +
   23.45 +#include <stdio.h>
   23.46 +#include <stdlib.h>
   23.47 +#include <errno.h>
   23.48 +#include <string.h>
   23.49 +
   23.50 +#include "lzo1x.h"
   23.51 +
   23.52 +#include "allocate.h"
   23.53 +#include "lzo_stream.h"
   23.54 +#include "file_stream.h"
   23.55 +#include "marshal.h"
   23.56 +
   23.57 +#define dprintf(fmt, args...) fprintf(stdout, "[DEBUG] LZO>%s" fmt, __FUNCTION__, ##args)
   23.58 +#define wprintf(fmt, args...) fprintf(stderr, "[WARN]  LZO>%s" fmt, __FUNCTION__, ##args)
   23.59 +#define iprintf(fmt, args...) fprintf(stdout, "[INFO]  LZO>%s" fmt, __FUNCTION__, ##args)
   23.60 +#define eprintf(fmt, args...) fprintf(stderr, "[ERROR] LZO>%s" fmt, __FUNCTION__, ##args)
   23.61 +
   23.62 +static int lzo_read(IOStream *s, void *buf, size_t size, size_t count);
   23.63 +static int lzo_write(IOStream *s, const void *buf, size_t size, size_t count);
   23.64 +static int lzo_print(IOStream *s, const char *msg, va_list args);
   23.65 +static int lzo_getc(IOStream *s);
   23.66 +static int lzo_error(IOStream *s);
   23.67 +static int lzo_close(IOStream *s);
   23.68 +static void lzo_free(IOStream *s);
   23.69 +static int lzo_flush(IOStream *s);
   23.70 +
   23.71 +enum {
   23.72 +    LZO_WRITE = 1,
   23.73 +    LZO_READ = 2,
   23.74 +};
   23.75 +
   23.76 +/** Methods used by a gzFile* IOStream. */
   23.77 +static const IOMethods lzo_methods = {
   23.78 +    read: lzo_read,
   23.79 +    write: lzo_write,
   23.80 +    print: lzo_print,
   23.81 +    getc:  lzo_getc,
   23.82 +    error: lzo_error,
   23.83 +    close: lzo_close,
   23.84 +    free:  lzo_free,
   23.85 +    flush: lzo_flush,
   23.86 +};
   23.87 +
   23.88 +//#define PLAIN_SIZE (64 * 1024)
   23.89 +//#define PLAIN_SIZE (128 * 1024)
   23.90 +#define PLAIN_SIZE (512 * 1024)
   23.91 +
   23.92 +//#define NOCOMPRESS
   23.93 +
   23.94 +typedef struct LZOState {
   23.95 +    /** Flags. */
   23.96 +    int flags;
   23.97 +    /** Error indicator. */
   23.98 +    int error;
   23.99 +    /** Underlying stream for I/O. */
  23.100 +    IOStream *io;
  23.101 +    /** Working memory (only needed for compression, not decompression). */
  23.102 +    lzo_byte *memory;
  23.103 +    /** Buffer for plain (uncompressed) data. */
  23.104 +    lzo_byte *plain;
  23.105 +    /** Size of the plain buffer. */
  23.106 +    lzo_uint plain_size;
  23.107 +    /** Pointer into the plain buffer. */
  23.108 +    lzo_byte *plain_ptr;
  23.109 +    /** Number of bytes of plain data available. */
  23.110 +    lzo_uint plain_n;
  23.111 +    /** Buffer for compressed data. */
  23.112 +    lzo_byte *comp;
  23.113 +    /** Size of the compressed buffer. */
  23.114 +    lzo_uint comp_size;
  23.115 +
  23.116 +    int plain_bytes;
  23.117 +    int comp_bytes;
  23.118 +} LZOState;
  23.119 +
  23.120 +void LZOState_free(LZOState *z){
  23.121 +    if(!z) return;
  23.122 +    deallocate(z->memory);
  23.123 +    deallocate(z->plain);
  23.124 +    deallocate(z->comp);
  23.125 +    deallocate(z);
  23.126 +}
  23.127 +
  23.128 +/** Maximum size of compressed data for the given plain data size.
  23.129 + *
  23.130 + * @param plain_size size of plain data
  23.131 + * @return maximum size of compressed data
  23.132 + */
  23.133 +static int comp_size(int plain_size){
  23.134 +    return plain_size + (plain_size / 64) + 16 + 3;
  23.135 +}
  23.136 +
  23.137 +static int mode_flags(const char *mode, int *flags){
  23.138 +    int err = 0;
  23.139 +    int r=0, w=0;
  23.140 +    if(!mode){
  23.141 +        err = -EINVAL;
  23.142 +        goto exit;
  23.143 +    }
  23.144 +    for(; *mode; mode++){
  23.145 +        if(*mode == 'w') w = 1;
  23.146 +        if(*mode == 'r') r = 1;
  23.147 +    }
  23.148 +    if(r + w != 1){
  23.149 +        err = -EINVAL;
  23.150 +        goto exit;
  23.151 +    }
  23.152 +    if(r) *flags |= LZO_READ;
  23.153 +    if(w) *flags |= LZO_WRITE;
  23.154 +  exit:
  23.155 +    return err;
  23.156 +}
  23.157 +
  23.158 +/** Get the stream state.
  23.159 + * 
  23.160 + * @param s lzo stream
  23.161 + * @return stream state.
  23.162 + */
  23.163 +static inline LZOState * lzo_state(IOStream *s){
  23.164 +    return s->data;
  23.165 +}
  23.166 +
  23.167 +IOStream *lzo_stream_io(IOStream *s){
  23.168 +    LZOState *state = lzo_state(s);
  23.169 +    return state->io;
  23.170 +}
  23.171 +
  23.172 +static inline void set_error(LZOState *state, int err){
  23.173 +    if(err < 0 && !state->error){
  23.174 +        state->error = err;
  23.175 +    }
  23.176 +}
  23.177 +
  23.178 +int lzo_stream_plain_bytes(IOStream *s){
  23.179 +    LZOState *state = lzo_state(s);
  23.180 +    return state->plain_bytes;
  23.181 +}
  23.182 +
  23.183 +int lzo_stream_comp_bytes(IOStream *s){
  23.184 +    LZOState *state = lzo_state(s);
  23.185 +    return state->comp_bytes;
  23.186 +}
  23.187 +
  23.188 +float lzo_stream_ratio(IOStream *s){
  23.189 +    LZOState *state = lzo_state(s);
  23.190 +    float ratio = 0.0;
  23.191 +    if(state->comp_bytes){
  23.192 +        ratio = ((float) state->comp_bytes)/((float) state->plain_bytes);
  23.193 +    }
  23.194 +    return ratio;
  23.195 +}
  23.196 +
  23.197 +static inline int LZOState_writeable(LZOState *state){
  23.198 +    return (state->flags & LZO_WRITE) != 0;
  23.199 +}
  23.200 +
  23.201 +static inline int LZOState_readable(LZOState *state){
  23.202 +    return (state->flags & LZO_READ) != 0;
  23.203 +}
  23.204 +
  23.205 +LZOState * LZOState_new(IOStream *io, int flags){
  23.206 +    int err = -ENOMEM;
  23.207 +    LZOState *z = ALLOCATE(LZOState);
  23.208 +    //dprintf(">\n");
  23.209 +    if(!z) goto exit;
  23.210 +    z->io = io;
  23.211 +    z->flags = flags;
  23.212 +    if(LZOState_writeable(z)){
  23.213 +        z->memory = allocate(LZO1X_1_MEM_COMPRESS);
  23.214 +        if(!z->memory) goto exit;
  23.215 +    }
  23.216 +    z->plain_size = PLAIN_SIZE;
  23.217 +    z->plain = allocate(z->plain_size);
  23.218 +    if(!z->plain) goto exit;
  23.219 +    z->plain_ptr = z->plain;
  23.220 +    z->comp_size = comp_size(z->plain_size);
  23.221 +    z->comp = allocate(z->comp_size);
  23.222 +    if(!z->comp) goto exit;
  23.223 +    err = 0;
  23.224 +  exit:
  23.225 +    if(err){
  23.226 +        LZOState_free(z);
  23.227 +        z = NULL;
  23.228 +    }
  23.229 +    //dprintf("< z=%p\n", z);
  23.230 +    return z;
  23.231 +}
  23.232 +
  23.233 +static int lzo_compress(LZOState *state){
  23.234 +    int err = 0;
  23.235 +    int k, comp_n;
  23.236 +    //dprintf(">\n");
  23.237 +    //dprintf(">plain=%p plain_n=%d comp=%p memory=%p\n", state->plain, state->plain_n, state->comp, state->memory);
  23.238 +    // Compress the plain buffer.
  23.239 +    err = lzo1x_1_compress(state->plain, state->plain_n,
  23.240 +                           state->comp, &comp_n,
  23.241 +                           state->memory);
  23.242 +    //dprintf("> err=%d plain_n=%d comp_n=%d\n", err, state->plain_n, comp_n);
  23.243 +    // Write plain size, compressed size.
  23.244 +    err = marshal_uint32(state->io, state->plain_n);
  23.245 +    if(err) goto exit;
  23.246 +    err = marshal_uint32(state->io, comp_n);
  23.247 +    if(err) goto exit;
  23.248 +    //dprintf("> write data...\n");
  23.249 +    // Write the smaller of the compressed and plain data.
  23.250 +    if(state->plain_n < comp_n){
  23.251 +        k = state->plain_n;
  23.252 +        err = marshal_bytes(state->io, state->plain, state->plain_n);
  23.253 +    } else {
  23.254 +        k = comp_n;
  23.255 +        err = marshal_bytes(state->io, state->comp, comp_n);
  23.256 +    }
  23.257 +    if(err) goto exit;
  23.258 +    // Total output bytes.
  23.259 +    k+= 8;
  23.260 +    //dprintf("> wrote %d bytes\n", k);
  23.261 +    state->plain_bytes += state->plain_n;
  23.262 +    state->comp_bytes += k;
  23.263 +    //dprintf("> plain=%d, comp=%d, ratio=%3.2f\n",
  23.264 +    //        state->plain_bytes, state->comp_bytes,
  23.265 +    //        ((float)state->comp_bytes)/((float)state->plain_bytes));
  23.266 +    // Reset the plain buffer.
  23.267 +    state->plain_ptr = state->plain;
  23.268 +    state->plain_n = 0;
  23.269 +    err = k;
  23.270 +  exit:
  23.271 +    //dprintf("< err=%d\n", err);
  23.272 +    return err;
  23.273 +}
  23.274 +
  23.275 +static int lzo_decompress(LZOState *state){
  23.276 +    int plain_n, comp_n;
  23.277 +    int err, k;
  23.278 +    //dprintf(">\n");
  23.279 +    err = unmarshal_uint32(state->io, &plain_n);
  23.280 +    //dprintf("> err=%d plain_n=%d\n", err, plain_n);
  23.281 +    if(err) goto exit;
  23.282 +    state->comp_bytes += 4;
  23.283 +    if(plain_n == 0) goto exit;
  23.284 +    err = unmarshal_uint32(state->io, &comp_n);
  23.285 +    //dprintf("> err=%d comp_n=%d\n", err, comp_n);
  23.286 +    if(err) goto exit;
  23.287 +    state->comp_bytes += 4;
  23.288 +    if(plain_n > state->plain_size){
  23.289 +        err = -EINVAL;
  23.290 +        goto exit;
  23.291 +    }
  23.292 +    if(comp_n > plain_n){
  23.293 +        //dprintf("> reading plain data %d...\n", plain_n);
  23.294 +        k = plain_n;
  23.295 +        err = unmarshal_bytes(state->io, state->plain, plain_n);
  23.296 +        state->plain_n = plain_n;
  23.297 +    } else {
  23.298 +        //dprintf("> reading comp data %d...\n", comp_n);
  23.299 +        k = comp_n;
  23.300 +        err = unmarshal_bytes(state->io, state->comp, comp_n);
  23.301 +        //dprintf("> decompress comp_n=%d\n", comp_n);
  23.302 +        err = lzo1x_decompress(state->comp, comp_n,
  23.303 +                               state->plain, &state->plain_n,
  23.304 +                               state->memory);
  23.305 +        //dprintf("> err=%d plain=%d state->plain_n=%d\n", err, plain_n, state->plain_n);
  23.306 +        if(err != LZO_E_OK || state->plain_n != plain_n){
  23.307 +            // Bad. Corrupted input.
  23.308 +            err = -EINVAL;
  23.309 +            eprintf("> Corrupted!\n");
  23.310 +            goto exit;
  23.311 +        }
  23.312 +    }
  23.313 +    state->comp_bytes += k;
  23.314 +    state->plain_bytes += state->plain_n;
  23.315 +    state->plain_ptr = state->plain;
  23.316 +    err = k;
  23.317 +  exit:
  23.318 +    //dprintf("< err=%d\n", err);
  23.319 +    return err;
  23.320 +}
  23.321 +
  23.322 +/** Write to the underlying stream using fwrite();
  23.323 + *
  23.324 + * @param stream destination
  23.325 + * @param buf data
  23.326 + * @param size size of data elements
  23.327 + * @param count number of data elements to write
  23.328 + * @return number of data elements written
  23.329 + */
  23.330 +static int lzo_write(IOStream *s, const void *buf, size_t size, size_t count){
  23.331 +    int err = 0;
  23.332 +    int n = size * count; // Total number of bytes to write.
  23.333 +    int chunk;            // Size of chunk to write.
  23.334 +    int remaining;        // Number of bytes remaining to write.
  23.335 +    int space;            // Amount of space left in plain buffer.
  23.336 +    LZOState *state = lzo_state(s);
  23.337 +#ifdef NOCOMPRESS
  23.338 +    //dprintf("> buf=%p size=%d count=%d\n", buf, size, count);
  23.339 +    err = IOStream_write(state->io, buf, size, count);
  23.340 +    //dprintf("< err=%d\n", err);
  23.341 +#else
  23.342 +    //dprintf("> buf=%p size=%d count=%d n=%d\n", buf, size, count, n);
  23.343 +    remaining = n;
  23.344 +    space = state->plain_size - state->plain_n;
  23.345 +    //dprintf("> plain=%p plain_ptr=%p plain_n=%d space=%d\n",
  23.346 +    //        state->plain, state->plain_ptr, state->plain_n, space);
  23.347 +    while(remaining){
  23.348 +        chunk = remaining;
  23.349 +        if(chunk > space) chunk = space;
  23.350 +        //dprintf("> memcpy %p %p %d\n", state->plain_ptr, buf, chunk);
  23.351 +        memcpy(state->plain_ptr, buf, chunk);
  23.352 +        remaining -= chunk;
  23.353 +        space -= chunk;
  23.354 +        state->plain_ptr += chunk;
  23.355 +        state->plain_n += chunk;
  23.356 +        if(space == 0){
  23.357 +            // Input buffer is full. Compress and write it.
  23.358 +            err = lzo_compress(state);
  23.359 +            if(err < 0) goto exit;
  23.360 +            space = state->plain_size - state->plain_n;
  23.361 +        }
  23.362 +    }
  23.363 +    err = (size > 1 ? n / size : n);
  23.364 +  exit:
  23.365 +    set_error(state, err);
  23.366 +#endif
  23.367 +    return err;
  23.368 +}
  23.369 +
  23.370 +
  23.371 +/** Read from the underlying stream.
  23.372 + *
  23.373 + * @param stream input
  23.374 + * @param buf where to put input
  23.375 + * @param size size of data elements
  23.376 + * @param count number of data elements to read
  23.377 + * @return number of data elements read
  23.378 + */
  23.379 +static int lzo_read(IOStream *s, void *buf, size_t size, size_t count){
  23.380 +    int err = 0;
  23.381 +    int k = 0;                     // Number of (plain) bytes read.
  23.382 +    int remaining = size * count;  // Number of bytes remaining to read.
  23.383 +    int chunk;                     // Size of chunk to read.
  23.384 +    LZOState *state = lzo_state(s);
  23.385 +#ifdef NOCOMPRESS
  23.386 +    //dprintf("> buf=%p size=%d count=%d\n", buf, size, count);
  23.387 +    err = IOStream_read(state->io, buf, size, count);
  23.388 +    //dprintf("< err=%d\n", err);
  23.389 +#else
  23.390 +    if(!(state->flags & LZO_READ)){
  23.391 +        err = -EINVAL;
  23.392 +        goto exit;
  23.393 +    }
  23.394 +    while(remaining){
  23.395 +        if(state->plain_n == 0){
  23.396 +            // No more plain input, decompress some more.
  23.397 +            err = lzo_decompress(state);
  23.398 +            if(err < 0) goto exit;
  23.399 +            // Stop reading if there is no more input.
  23.400 +            if(err == 0 || state->plain_n == 0) break;
  23.401 +        }
  23.402 +        chunk = remaining;
  23.403 +        if(chunk > state->plain_n) chunk = state->plain_n;
  23.404 +        memcpy(buf, state->plain_ptr, chunk);
  23.405 +        k += chunk;
  23.406 +        buf += chunk;
  23.407 +        state->plain_ptr += chunk;
  23.408 +        state->plain_n -= chunk;
  23.409 +        remaining -= chunk;
  23.410 +    }
  23.411 +    err = k;
  23.412 +  exit:
  23.413 +    set_error(state, err);
  23.414 +#endif
  23.415 +    return err;
  23.416 +}
  23.417 +
  23.418 +/** Print to the underlying stream.
  23.419 + * Returns 0 if the formatted output is too big for the internal buffer.
  23.420 + *
  23.421 + * @param s lzo stream
  23.422 + * @param msg format to use
  23.423 + * @param args arguments
  23.424 + * @return result of the print
  23.425 + */
  23.426 +static int lzo_print(IOStream *s, const char *msg, va_list args){
  23.427 +    char buf[1024];
  23.428 +    int buf_n = sizeof(buf);
  23.429 +    int n;
  23.430 +    LZOState *state = lzo_state(s);
  23.431 +    if(!LZOState_writeable(state)){
  23.432 +        n = -EINVAL;
  23.433 +        goto exit;
  23.434 +    }
  23.435 +    n = vsnprintf(buf, buf_n, (char*)msg, args);
  23.436 +    if(n < 0) goto exit;
  23.437 +    if(n > buf_n){
  23.438 +        n = 0;
  23.439 +    } else {
  23.440 +        n = lzo_write(s, buf, 1, n);
  23.441 +    }
  23.442 +  exit:
  23.443 +    return n;
  23.444 +}
  23.445 +
  23.446 +/** Read a character from the underlying stream
  23.447 + *
  23.448 + * @param s lzo stream
  23.449 + * @return character read, IOSTREAM_EOF on end of file (or error)
  23.450 + */
  23.451 +static int lzo_getc(IOStream *s){
  23.452 +    int err;
  23.453 +    char c;
  23.454 +    err = lzo_read(s, &c, 1, 1);
  23.455 +    if(err < 1) c = EOF;
  23.456 +    err = (c==EOF ? IOSTREAM_EOF : c);
  23.457 +    return err;
  23.458 +}
  23.459 +
  23.460 +/** Flush any pending input to the underlying stream.
  23.461 + *
  23.462 + * @param s lzo stream
  23.463 + * @return 0 on success, error code otherwise
  23.464 + */
  23.465 +static int lzo_flush(IOStream *s){
  23.466 +    int err = 0;
  23.467 +    LZOState *state = lzo_state(s);
  23.468 +    //dprintf(">\n");
  23.469 +#ifdef NOCOMPRESS
  23.470 +    err = IOStream_flush(state->io);
  23.471 +#else    
  23.472 +    if(!LZOState_writeable(state)){
  23.473 +        err = -EINVAL;
  23.474 +        goto exit;
  23.475 +    }
  23.476 +    if(state->plain_n){
  23.477 +        err = lzo_compress(state);
  23.478 +        if(err < 0) goto exit;
  23.479 +    }
  23.480 +    err = IOStream_flush(state->io);
  23.481 +  exit:
  23.482 +    set_error(state, err);
  23.483 +#endif
  23.484 +    //dprintf("< err=%d\n", err);
  23.485 +    return (err < 0 ? err : 0);
  23.486 +}
  23.487 +
  23.488 +/** Check if a stream has an error.
  23.489 + *
  23.490 + * @param s lzo stream
  23.491 + * @return code if has an error, 0 otherwise
  23.492 + */
  23.493 +static int lzo_error(IOStream *s){
  23.494 +    int err = 0;
  23.495 +    LZOState *state = lzo_state(s);
  23.496 +    err = state->error;
  23.497 +    if(err) goto exit;
  23.498 +    err = IOStream_error(state->io);
  23.499 +  exit:
  23.500 +    return err;
  23.501 +}
  23.502 +
  23.503 +int lzo_stream_finish(IOStream *s){
  23.504 +    int err = 0;
  23.505 +    LZOState *state = lzo_state(s);
  23.506 +    if(!LZOState_writeable(state)){
  23.507 +        err = -EINVAL;
  23.508 +        goto exit;
  23.509 +    }
  23.510 +    err = lzo_flush(s);
  23.511 +    if(err < 0) goto exit;
  23.512 +    err = marshal_int32(state->io, 0);
  23.513 +  exit:
  23.514 +    return err;
  23.515 +}        
  23.516 +
  23.517 +/** Close an lzo stream.
  23.518 + *
  23.519 + * @param s lzo stream to close
  23.520 + * @return result of the close
  23.521 + */
  23.522 +static int lzo_close(IOStream *s){
  23.523 +    int err = 0;
  23.524 +    LZOState *state = lzo_state(s);
  23.525 +#ifdef NOCOMPRESS
  23.526 +    err = IOStream_close(state->io);
  23.527 +#else    
  23.528 +    if(LZOState_writeable(state)){
  23.529 +        err = lzo_stream_finish(s);
  23.530 +    }        
  23.531 +    err = IOStream_close(state->io);
  23.532 +    set_error(state, err);
  23.533 +#endif
  23.534 +    return err;
  23.535 +}
  23.536 +
  23.537 +/** Free an lzo stream.
  23.538 + *
  23.539 + * @param s lzo stream
  23.540 + */
  23.541 +static void lzo_free(IOStream *s){
  23.542 +    LZOState *state = lzo_state(s);
  23.543 +    IOStream_free(state->io);
  23.544 +    LZOState_free(state);
  23.545 +    s->data = NULL;
  23.546 +}
  23.547 +
  23.548 +/** Create an lzo stream for an IOStream.
  23.549 + *
  23.550 + * @param io stream to wrap
  23.551 + * @return new IOStream using f for i/o
  23.552 + */
  23.553 +IOStream *lzo_stream_new(IOStream *io, const char *mode){
  23.554 +    int err = -ENOMEM;
  23.555 +    int flags = 0;
  23.556 +    IOStream *zio = NULL;
  23.557 +    LZOState *state = NULL;
  23.558 +
  23.559 +    zio = ALLOCATE(IOStream);
  23.560 +    if(!zio) goto exit;
  23.561 +    err = mode_flags(mode, &flags);
  23.562 +    if(err) goto exit;
  23.563 +    state = LZOState_new(io, flags);
  23.564 +    if(!state) goto exit;
  23.565 +    err = 0;
  23.566 +    zio->data = state;
  23.567 +    zio->methods = &lzo_methods;
  23.568 +  exit:
  23.569 +    if(err){
  23.570 +        if(state) LZOState_free(state);
  23.571 +        if(zio) deallocate(zio);
  23.572 +        zio = NULL;
  23.573 +    }
  23.574 +    return zio;
  23.575 +}
  23.576 +
  23.577 +/** IOStream version of fdopen().
  23.578 + *
  23.579 + * @param fd file descriptor
  23.580 + * @param flags giving the mode to open in (as for fdopen())
  23.581 + * @return new stream for the open file, or NULL if failed
  23.582 + */
  23.583 +IOStream *lzo_stream_fdopen(int fd, const char *mode){
  23.584 +    int err = -ENOMEM;
  23.585 +    IOStream *io = NULL, *zio = NULL;
  23.586 +    io = file_stream_fdopen(fd, mode);
  23.587 +    if(!io) goto exit;
  23.588 +    zio = lzo_stream_new(io, mode);
  23.589 +    if(!io) goto exit;
  23.590 +    err = 0;
  23.591 +  exit:
  23.592 +    if(err){
  23.593 +        IOStream_free(io);
  23.594 +        IOStream_free(zio);
  23.595 +        zio = NULL;
  23.596 +    }
  23.597 +    return zio;
  23.598 +}
  23.599 +#endif

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/tools/lib/lzo_stream.h	Tue Jun 29 12:05:29 2004 +0000
    24.3 @@ -0,0 +1,36 @@
    24.4 +#/* $Id: lzo_stream.h,v 1.3 2003/09/30 15:22:53 mjw Exp $ */
    24.5 +/*
    24.6 + * Copyright (C) 2003 Hewlett-Packard Company.
    24.7 + *
    24.8 + * This library is free software; you can redistribute it and/or modify
    24.9 + * it under the terms of the GNU Lesser General Public License as published by
   24.10 + * the Free Software Foundation; either version 2.1 of the License, or
   24.11 + * (at your option) any later version.
   24.12 + *
   24.13 + * This library is distributed in the hope that it will be useful,
   24.14 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   24.15 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   24.16 + * GNU Lesser General Public License for more details.
   24.17 + *
   24.18 + * You should have received a copy of the GNU Lesser General Public License
   24.19 + * along with this library; if not, write to the Free Software
   24.20 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   24.21 + */
   24.22 +
   24.23 +#ifndef _SP_LZO_STREAM_H_
   24.24 +#define _SP_LZO_STREAM_H_
   24.25 +
   24.26 +#ifndef __KERNEL__
   24.27 +#include "iostream.h"
   24.28 +
   24.29 +extern IOStream *lzo_stream_new(IOStream *io, const char *mode);
   24.30 +extern IOStream *lzo_stream_fopen(const char *file, const char *mode);
   24.31 +extern IOStream *lzo_stream_fdopen(int fd, const char *mode);
   24.32 +extern IOStream *lzo_stream_io(IOStream *zio);
   24.33 +
   24.34 +extern int lzo_stream_plain_bytes(IOStream *io);
   24.35 +extern int lzo_stream_comp_bytes(IOStream *io);
   24.36 +extern float lzo_stream_ratio(IOStream *io);
   24.37 +
   24.38 +#endif
   24.39 +#endif /* !_SP_FILE_STREAM_H_ */

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/tools/lib/marshal.c	Tue Jun 29 12:05:29 2004 +0000
    25.3 @@ -0,0 +1,207 @@
    25.4 +#include <errno.h>
    25.5 +#include "sys_net.h"
    25.6 +#include "allocate.h"
    25.7 +#include "marshal.h"
    25.8 +
    25.9 +#define dprintf(fmt, args...) IOStream_print(iostdout, "[DEBUG] %s" fmt, __FUNCTION__, ##args)
   25.10 +#define wprintf(fmt, args...) IOStream_print(iostderr, "[WARN]  %s" fmt, __FUNCTION__, ##args)
   25.11 +#define iprintf(fmt, args...) IOStream_print(iostdout, "[INFO]  %s" fmt, __FUNCTION__, ##args)
   25.12 +#define eprintf(fmt, args...) IOStream_print(iostderr, "[ERROR] %s" fmt, __FUNCTION__, ##args)
   25.13 +
   25.14 +
   25.15 +#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof((ary)[0]))
   25.16 +
   25.17 +/* Messages are coded as msgid followed by message fields.
   25.18 + * Initial message on any channel is hello - so can check version
   25.19 + * compatibility.
   25.20 + *
   25.21 + * char* -> uint16_t:n <n bytes>
   25.22 + * ints/uints go as suitable number of bytes (e.g. uint16_t is 2 bytes).
   25.23 + * optional fields go as '1' <val> or '0' (the 0/1 is 1 byte).
   25.24 + * lists go as ('1' <elt>)* '0'
   25.25 + */
   25.26 +
   25.27 +int marshal_flush(IOStream *io){
   25.28 +    int err  = 0;
   25.29 +    err = IOStream_flush(io);
   25.30 +    return err;
   25.31 +}
   25.32 +
   25.33 +int marshal_bytes(IOStream *io, void *s, uint32_t s_n){
   25.34 +    int err = 0;
   25.35 +    int n;
   25.36 +    n = IOStream_write(io, s, s_n);
   25.37 +    if(n < 0){
   25.38 +        err = n;
   25.39 +    } else if (n < s_n){
   25.40 +        wprintf("> Wanted %d, got %d\n", s_n, n);
   25.41 +        err = -EIO;
   25.42 +    }
   25.43 +    return err;
   25.44 +}
   25.45 +
   25.46 +int unmarshal_bytes(IOStream *io, void *s, uint32_t s_n){
   25.47 +    int err = 0;
   25.48 +    int n;
   25.49 +    //dprintf("> s_n=%d\n", s_n);
   25.50 +    n = IOStream_read(io, s, s_n);
   25.51 +    //dprintf("> n=%d\n", n);
   25.52 +    if(n < 0){
   25.53 +        err = n;
   25.54 +    } else if(n < s_n){
   25.55 +        wprintf("> Wanted %d, got %d\n", s_n, n);
   25.56 +        err = -EIO;
   25.57 +    }
   25.58 +    //dprintf("< err=%d\n", err);
   25.59 +    return err;
   25.60 +}
   25.61 +
   25.62 +int marshal_uint8(IOStream *io, uint8_t x){
   25.63 +    return marshal_bytes(io, &x, sizeof(x));
   25.64 +}
   25.65 +
   25.66 +int unmarshal_uint8(IOStream *io, uint8_t *x){
   25.67 +    return unmarshal_bytes(io, x, sizeof(*x));
   25.68 +}
   25.69 +
   25.70 +int marshal_uint16(IOStream *io, uint16_t x){
   25.71 +    x = htons(x);
   25.72 +    return marshal_bytes(io, &x, sizeof(x));
   25.73 +}
   25.74 +
   25.75 +int unmarshal_uint16(IOStream *io, uint16_t *x){
   25.76 +    int err = 0;
   25.77 +    err = unmarshal_bytes(io, x, sizeof(*x));
   25.78 +    *x = ntohs(*x);
   25.79 +    return err;
   25.80 +}
   25.81 +
   25.82 +int marshal_int32(IOStream *io, int32_t x){
   25.83 +    int err = 0;
   25.84 +    //dprintf("> x=%d\n", x);
   25.85 +    x = htonl(x);
   25.86 +    err = marshal_bytes(io, &x, sizeof(x));
   25.87 +    //dprintf("< err=%d\n", err);
   25.88 +    return err;
   25.89 +}
   25.90 +
   25.91 +int unmarshal_int32(IOStream *io, int32_t *x){
   25.92 +    int err = 0;
   25.93 +    //dprintf(">\n");
   25.94 +    err = unmarshal_bytes(io, x, sizeof(*x));
   25.95 +    *x = ntohl(*x);
   25.96 +    //dprintf("< err=%d x=%d\n", err, *x);
   25.97 +    return err;
   25.98 +}
   25.99 +
  25.100 +int marshal_uint32(IOStream *io, uint32_t x){
  25.101 +    int err = 0;
  25.102 +    //dprintf("> x=%u\n", x);
  25.103 +    x = htonl(x);
  25.104 +    err = marshal_bytes(io, &x, sizeof(x));
  25.105 +    //dprintf("< err=%d\n", err);
  25.106 +    return err;
  25.107 +}
  25.108 +
  25.109 +int unmarshal_uint32(IOStream *io, uint32_t *x){
  25.110 +    int err = 0;
  25.111 +    //dprintf(">\n");
  25.112 +    err = unmarshal_bytes(io, x, sizeof(*x));
  25.113 +    *x = ntohl(*x);
  25.114 +    //dprintf("< err=%d x=%u\n", err, *x);
  25.115 +    return err;
  25.116 +}
  25.117 +
  25.118 +int marshal_uint64(IOStream *io, uint64_t x){
  25.119 +    int err;
  25.120 +    err = marshal_uint32(io, (uint32_t) ((x >> 32) & 0xffffffff));
  25.121 +    if(err) goto exit;
  25.122 +    err = marshal_uint32(io, (uint32_t) ( x        & 0xffffffff));
  25.123 +  exit:
  25.124 +    return err;
  25.125 +}
  25.126 +
  25.127 +int unmarshal_uint64(IOStream *io, uint64_t *x){
  25.128 +    int err = 0;
  25.129 +    uint32_t hi, lo;
  25.130 +    err = unmarshal_uint32(io, &hi);
  25.131 +    if(err) goto exit;
  25.132 +    err = unmarshal_uint32(io, &lo);
  25.133 +    *x = (((uint64_t) hi) << 32) | lo;
  25.134 +  exit:
  25.135 +    return err;
  25.136 +}
  25.137 +
  25.138 +int marshal_net16(IOStream *io, net16_t x){
  25.139 +    return marshal_bytes(io, &x, sizeof(x));
  25.140 +}
  25.141 +
  25.142 +int unmarshal_net16(IOStream *io, net16_t *x){
  25.143 +    int err = 0;
  25.144 +    err = unmarshal_bytes(io, x, sizeof(*x));
  25.145 +    return err;
  25.146 +}
  25.147 +
  25.148 +int marshal_net32(IOStream *io, net32_t x){
  25.149 +    return marshal_bytes(io, &x, sizeof(x));
  25.150 +}
  25.151 +
  25.152 +int unmarshal_net32(IOStream *io, net32_t *x){
  25.153 +    int err = 0;
  25.154 +    err = unmarshal_bytes(io, x, sizeof(*x));
  25.155 +    return err;
  25.156 +}
  25.157 +
  25.158 +int marshal_string(IOStream *io, char *s, uint32_t s_n){
  25.159 +    int err;
  25.160 +    //dprintf("> s=%s\n", s);
  25.161 +    err = marshal_uint32(io, s_n);
  25.162 +    if(err) goto exit;
  25.163 +    err = marshal_bytes(io, s, s_n);
  25.164 +  exit:
  25.165 +    //dprintf("< err=%d\n", err);
  25.166 +    return err;
  25.167 +}
  25.168 +
  25.169 +int unmarshal_string(IOStream *io, char *s, uint32_t s_n){
  25.170 +    int err = 0, val_n = 0;
  25.171 +    //dprintf(">\n");
  25.172 +    err = unmarshal_uint32(io, &val_n);
  25.173 +    if(err) goto exit;
  25.174 +    if(val_n >= s_n){
  25.175 +        err = -EINVAL;
  25.176 +        goto exit;
  25.177 +    }
  25.178 +    err = unmarshal_bytes(io, s, val_n);
  25.179 +    if(err) goto exit;
  25.180 +    s[val_n] = '\0';
  25.181 +  exit:
  25.182 +    //dprintf("< err=%d s=%s\n", err, s);
  25.183 +    return err;
  25.184 +}
  25.185 +
  25.186 +int unmarshal_new_string(IOStream *io, char **s, uint32_t *s_n){
  25.187 +    int err = 0, val_n = 0;
  25.188 +    char *val = NULL;
  25.189 +    //dprintf(">\n");
  25.190 +    err = unmarshal_uint32(io, &val_n);
  25.191 +    if(err) goto exit;
  25.192 +    val = allocate(val_n + 1);
  25.193 +    if(!val){
  25.194 +        err = -ENOMEM;
  25.195 +        goto exit;
  25.196 +    }
  25.197 +    err = unmarshal_bytes(io, val, val_n);
  25.198 +    if(err) goto exit;
  25.199 +    val[val_n] = '\0';
  25.200 +  exit:
  25.201 +    if(err){
  25.202 +        if(val) deallocate(val);
  25.203 +        val = NULL;
  25.204 +        val_n = 0;
  25.205 +    }
  25.206 +    *s = val;
  25.207 +    if(s_n) *s_n = val_n;
  25.208 +    //dprintf("< err=%d s=%s\n", err, *s);
  25.209 +    return err;
  25.210 +}