diff -urN gale-0.91a/INSTALL gale-0.91b/INSTALL --- gale-0.91a/INSTALL Wed Oct 20 00:05:57 1999 +++ gale-0.91b/INSTALL Wed Jan 12 16:20:48 2000 @@ -14,8 +14,7 @@ * RSAREF Get the RSAREF library. You can retrieve the source from - http://gale.org/dist/rsaref20.tar.Z if you live in the US or Canada. - If you don't, you might try using a workalike such as RSAEURO. + http://gale.org/dist/rsaref20.tar.Z. Unpack the rsaref20.tar.Z file in the "gale/rsaref" directory. The configuration and build process will automatically detect its presence, diff -urN gale-0.91a/Makefile.am gale-0.91b/Makefile.am --- gale-0.91a/Makefile.am Sun Dec 26 21:29:31 1999 +++ gale-0.91b/Makefile.am Sun Jan 30 21:07:09 2000 @@ -1,9 +1,7 @@ ## Process this file with automake to generate Makefile.in AUTOMAKE_OPTIONS = foreign 1.2 -noinst_SCRIPTS = common.sh config.sh domain.sh bin_SCRIPTS = gale-config gale-install -EXTRA_DIST = common.sh config.sh domain.sh if BUILD_GZGW gzgw_dir = gzgw diff -urN gale-0.91a/Makefile.in gale-0.91b/Makefile.in --- gale-0.91a/Makefile.in Sun Dec 26 22:17:23 1999 +++ gale-0.91b/Makefile.in Sun Jan 30 21:54:45 2000 @@ -80,9 +80,7 @@ ZEPHYR_LIBS = @ZEPHYR_LIBS@ AUTOMAKE_OPTIONS = foreign 1.2 -noinst_SCRIPTS = common.sh config.sh domain.sh bin_SCRIPTS = gale-config gale-install -EXTRA_DIST = common.sh config.sh domain.sh @BUILD_GZGW_TRUE@gzgw_dir = gzgw @BUILD_GZGW_FALSE@gzgw_dir = @BUILD_RSAREF_TRUE@rsaref_dir = rsaref @@ -96,7 +94,7 @@ mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs CONFIG_HEADER = ./include/gale/config.h CONFIG_CLEAN_FILES = gale-config gale-install -SCRIPTS = $(bin_SCRIPTS) $(noinst_SCRIPTS) +SCRIPTS = $(bin_SCRIPTS) DIST_COMMON = ./stamp-h.in COPYING INSTALL Makefile.am Makefile.in \ acconfig.h aclocal.m4 config.guess config.h.in config.sub configure \ diff -urN gale-0.91a/common.sh gale-0.91b/common.sh --- gale-0.91a/common.sh Sun Jun 21 14:35:28 1998 +++ gale-0.91b/common.sh Wed Dec 31 16:00:00 1969 @@ -1,42 +0,0 @@ -run() { - echo "$*" - "$@" || exit 1 -} - -qgrep() { - grep "$@" > /dev/null -} - -testkey() { - gkinfo -x "$1" 2>/dev/null | qgrep "^Trusted public key: <$1>" -} - -testkey_stdin() { - gkinfo -x 2>/dev/null | qgrep "^Trusted public key: <$1>" -} - -if [ -n "$GALE_SYS_DIR" ]; then - SYS_DIR="$GALE_SYS_DIR" -elif [ -n "$sysconfdir" ]; then - SYS_DIR="$sysconfdir/gale" -else - echo "Error: neither of \$GALE_SYS_DIR or \$sysconfdir defined." - echo "\"make install\" calls this script; don't run it directly." - exit 1 -fi - -CONF="$SYS_DIR/conf" -umask 022 -PATH="$bindir:$sbindir:$PATH:/usr/ucb" -export PATH - -if [ -f "$CONF" ]; then - exec 3<"$CONF" - - while read var value <&3 ; do - [ -z "$var" -o "x$var" = "x#" ] && continue - eval "CONF_$var=\"$value\"" - done - - exec 3<&- -fi diff -urN gale-0.91a/config.sh gale-0.91b/config.sh --- gale-0.91a/config.sh Sat Jun 5 19:19:48 1999 +++ gale-0.91b/config.sh Wed Dec 31 16:00:00 1969 @@ -1,152 +0,0 @@ -. "$srcdir/common.sh" - -run mkdir -p "$SYS_DIR" -if [ ! -d "$SYS_DIR" ]; then - echo "Error: Invalid or unauthorized SYS_DIR: \"$SYS_DIR\"." - exit 1 -fi - -run mkdir -p "$SYS_DIR/auth/trusted" -run mkdir -p "$SYS_DIR/auth/private" -run mkdir -p "$SYS_DIR/auth/local" -run mkdir -p "$SYS_DIR/auth/cache" -run chmod 1777 "$SYS_DIR/auth/local" -run chmod 777 "$SYS_DIR/auth/cache" - -[ -n "$CONF_GALE_USER" ] && GALE_USER="$CONF_GALE_USER" -[ -n "$CONF_GALE_DOMAIN" ] && GALE_DOMAIN="$CONF_GALE_DOMAIN" -[ -n "$CONF_GALE_SERVER" ] && GALE_SERVER="$CONF_GALE_SERVER" - -if [ -z "$GALE_USER" ]; then -cat << EOM - -Hi. You need to denote a user to own the Gale domain secret key. You must -trust this user with Gale authentication for your domain; the "gksign" program -will run as this user. I recommend using a special "gale" user; if you don't -have administrative priveleges here, you'll probably have to use your own -account. I do not recommend the use of "root". - -No harm done if you stop this script now to set up such a user. - -EOM - - /bin/echo "Enter the Gale username: \c" - read GALE_USER - if [ -z "$GALE_USER" ]; then - echo "Error: Invalid username or no home dir: \"$GALE_USER\"." - exit 1 - fi -else - echo "Using \"$GALE_USER\" as the Gale owner." -fi - -run chown $GALE_USER "$sbindir/gksign" -run chmod 4755 "$sbindir/gksign" -if [ "x$bindir" != "x$sbindir" ]; then - run ln -s "$sbindir/gksign" "$bindir/gksign.tmp.$$" - run mv "$bindir/gksign.tmp.$$" "$bindir/gksign" -fi - -run cp "$srcdir/kutils/ROOT" "$SYS_DIR/auth/trusted" - -if [ -z "$GALE_DOMAIN" ] ; then -cat << EOM - -You need to choose a name for your authentication domain. The extent of the -domain need not correspond to any given physical or logical setup. The domain -name is often a DNS domain (by convention). If you run Gale in the context of -a larger organization, they may have a domain set up; ask your administrators. - -Note that you will need permission from your parent domain; if you choose -"foo.bar.com", you will need to contact the owners of "bar.com". - -We recommend that new users choose an unoccupied name in the free, first-come, -first-served dork.gale.org domain by visiting . -This will streamline the registration process to get you up and running as -quickly as possible with a minimum of human intervention. - -You can always change this later (with a bit of hassle). - -EOM - - /bin/echo "Enter the Gale domain: \c" - read GALE_DOMAIN - case "$GALE_DOMAIN" in - *" "*) echo "Error: Invalid domain specification." ; exit 1 ;; - *""*) echo "Error: Invalid domain specification." ; exit 1 ;; - *""*) echo "Error: Invalid domain specification." ; exit 1 ;; - "") echo "Error: No domain specified." ; exit 1 ;; - esac -else - echo "Using \"$GALE_DOMAIN\" as the Gale domain." -fi - -if [ -z "$GALE_SERVER" ] ; then -cat << EOM - -You need to designate a machine as a Gale server. This machine (not -necessarily under your control, or part of this installation) will need to -run the Gale server "galed"; it will relay messages between Gale clients. -It may well be this machine. Please supply a comma-separated list of one -or more fully-qualified host names, with no spaces. - -EOM - - /bin/echo "Enter the Gale server hostname: \c" - read GALE_SERVER - case "$GALE_SERVER" in - *" "*) echo "Error: Invalid server specification." ; exit 1 ;; - *""*) echo "Error: Invalid server specification." ; exit 1 ;; - *""*) echo "Error: Invalid server specification." ; exit 1 ;; - "") echo "Error: No server specified." ; exit 1 ;; - esac -else - echo "Using \"$GALE_SERVER\" as the Gale server(s)." -fi - -if [ ! -f "$CONF" ]; then -cat > "$CONF" <> "$CONF" <> "$CONF" << EOM - -# The authentication domain to use. (Mandatory) -GALE_DOMAIN $GALE_DOMAIN -EOM - -[ -n "$CONF_GALE_SERVER" ] || cat >> "$CONF" << EOM - -# The hostname(s) of server(s) clients should talk to. (Mandatory) -# Feel free to list several, separated by commas; clients will choose -# the server quickest to respond. -GALE_SERVER $GALE_SERVER -EOM - -testkey "$GALE_DOMAIN" || cat << EOM - -*** You lack a signed key for your domain, "$GALE_DOMAIN". -Become user "$GALE_USER" and make the "domain" target here to create -a new domain; contact your domain administrator if you wish to become -part of an existing domain. -EOM - -echo "" diff -urN gale-0.91a/configure gale-0.91b/configure --- gale-0.91a/configure Sun Dec 26 22:07:15 1999 +++ gale-0.91b/configure Sun Jan 30 21:03:11 2000 @@ -705,7 +705,7 @@ PACKAGE=gale -VERSION=0.91a +VERSION=0.91b if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; } diff -urN gale-0.91a/configure.in gale-0.91b/configure.in --- gale-0.91a/configure.in Sun Dec 26 22:06:35 1999 +++ gale-0.91b/configure.in Sun Jan 30 21:03:08 2000 @@ -2,7 +2,7 @@ AC_PREREQ(2.13) AC_INIT(INSTALL) -AM_INIT_AUTOMAKE(gale,0.91a) +AM_INIT_AUTOMAKE(gale,0.91b) AM_CONFIG_HEADER(include/gale/config.h:config.h.in) AC_CANONICAL_HOST AM_PROG_LIBTOOL diff -urN gale-0.91a/domain.sh gale-0.91b/domain.sh --- gale-0.91a/domain.sh Sat Jun 5 19:19:48 1999 +++ gale-0.91b/domain.sh Wed Dec 31 16:00:00 1969 @@ -1,174 +0,0 @@ -. $srcdir/common.sh - -if [ -z "$HOME" ]; then - cd - HOME="`pwd`" - echo "Warning: \$HOME not set, assuming \"$HOME\"." -fi - -GALE="$HOME/.gale" -mkdir -p "$GALE" -if [ ! -w "$GALE" ]; then - echo "Error: Cannot create \"$GALE\"." - exit 1 -fi - -if [ -z "$CONF_GALE_USER" ]; then - echo "Error: GALE_USER not configured." - echo "Make sure you've completed the \"make install\" process." - exit 1 -fi - -USER="`whoami`" -if [ "x$CONF_GALE_USER" != "x$USER" ]; then -cat </dev/null | qgrep "public key: <$CONF_GALE_DOMAIN>" ; then - echo "Good, it looks like your key..." - else - echo "Error: \"$skey\" not for \"$CONF_GALE_DOMAIN\"." - echo "Here's what it looks like to me:" - gkinfo < "$skey" - exit 1 - fi - - if testkey_stdin "$CONF_GALE_DOMAIN" < "$skey" ; then - echo "And it looks properly signed. Hooray for you!" - else - echo "Error: \"$skey\" is not fully signed." - echo "Here's what it looks like to me:" - gkinfo < "$skey" - exit 1 - fi - - if cp "$skey" "$SYS_DIR/auth/local/$CONF_GALE_DOMAIN" ; then - echo "Signed key successfully installed." - else - echo "Error: copying \"$skey\" to \"$SYS_DIR/auth/local/$CONF_GALE_DOMAIN\"." - exit 1 - fi - -cat << EOM - -The domain should be properly configured now. Assuming users can access a -version of "gksign" setuid to "$CONF_GALE_USER" (this user), they should be -able to start running clients and generating IDs for themselves. - -The installation process is complete! - -EOM - - exit 0 -fi - -cat << EOM - -Greetings. We need to make a key for "$CONF_GALE_DOMAIN". -Please enter a description to go along with the key; for example, -caltech.edu has the description "California Institute of Technology". - -EOM - -/bin/echo "Enter the description: \c" -read descr - -echo "We will generate the key now. Have patience." -gkgen -u "$unsigned" "$CONF_GALE_DOMAIN" "$descr" || exit 1 - -case "$CONF_GALE_DOMAIN" in -*.dork.gale.org) -cat << EOM - -*** Ah, a dork key. Good! -Visit . -Follow the directions; send the file "$unsigned" for -signing. Save the resulting signed key file to disk someplace. When you -have the signed key available, re-run this process, and we will move on to -the next step. - -EOM -;; -*) -cat << EOM - -*** What you must do: Take the file "$unsigned", -which contains the public part of the newly-generated key pair. Send it to -the owner of the "$signer" domain through appropriate means. -Take care to preseve the file's binary data; you may need to uuencode it. - -Assuming they trust you with your subdomain, they should pass the key through -"gksign" as a filter, returning the signed output to you. When you have this -signed key file available, re-run this process, and we will move on to the -next step. - -EOM -;; -esac diff -urN gale-0.91a/gc/Makefile.am gale-0.91b/gc/Makefile.am --- gale-0.91a/gc/Makefile.am Sat Oct 9 12:05:36 1999 +++ gale-0.91b/gc/Makefile.am Sun Jan 30 21:43:57 2000 @@ -15,4 +15,4 @@ $(MAKE) -f Makefile.gc clean srcdir="${srcdir}" CC="${CC}" dist-hook: - $(RM) $(distdir)/README + $(RM) $(distdir)/README $(distdir)/gc.h diff -urN gale-0.91a/gc/Makefile.in gale-0.91b/gc/Makefile.in --- gale-0.91a/gc/Makefile.in Sun Dec 26 22:17:26 1999 +++ gale-0.91b/gc/Makefile.in Sun Jan 30 21:54:47 2000 @@ -411,7 +411,7 @@ $(MAKE) -f Makefile.gc clean srcdir="${srcdir}" CC="${CC}" dist-hook: - $(RM) $(distdir)/README + $(RM) $(distdir)/README $(distdir)/gc.h # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. diff -urN gale-0.91a/gc/gc.h gale-0.91b/gc/gc.h --- gale-0.91a/gc/gc.h Sun Oct 10 11:13:03 1999 +++ gale-0.91b/gc/gc.h Wed Dec 31 16:00:00 1969 @@ -1,754 +0,0 @@ -/* - * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers - * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. - * Copyright 1996 by Silicon Graphics. All rights reserved. - * - * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED - * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. - * - * Permission is hereby granted to use or copy this program - * for any purpose, provided the above notices are retained on all copies. - * Permission to modify the code and to distribute modified code is granted, - * provided the above notices are retained, and a notice that the code was - * modified is included with the above copyright notice. - */ - -/* - * Note that this defines a large number of tuning hooks, which can - * safely be ignored in nearly all cases. For normal use it suffices - * to call only GC_MALLOC and perhaps GC_REALLOC. - * For better performance, also look at GC_MALLOC_ATOMIC, and - * GC_enable_incremental. If you need an action to be performed - * immediately before an object is collected, look at GC_register_finalizer. - * If you are using Solaris threads, look at the end of this file. - * Everything else is best ignored unless you encounter performance - * problems. - */ - -#ifndef _GC_H - -# define _GC_H -# define __GC -# include - -#if defined(__CYGWIN32__) && defined(GC_USE_DLL) -#include "libgc_globals.h" -#endif - -#if defined(_MSC_VER) && defined(_DLL) -# ifdef GC_BUILD -# define GC_API __declspec(dllexport) -# else -# define GC_API __declspec(dllimport) -# endif -#endif - -#if defined(__WATCOMC__) && defined(GC_DLL) -# ifdef GC_BUILD -# define GC_API extern __declspec(dllexport) -# else -# define GC_API extern __declspec(dllimport) -# endif -#endif - -#ifndef GC_API -#define GC_API extern -#endif - -# if defined(__STDC__) || defined(__cplusplus) -# define GC_PROTO(args) args - typedef void * GC_PTR; -# else -# define GC_PROTO(args) () - typedef char * GC_PTR; -# endif - -# ifdef __cplusplus - extern "C" { -# endif - - -/* Define word and signed_word to be unsigned and signed types of the */ -/* size as char * or void *. There seems to be no way to do this */ -/* even semi-portably. The following is probably no better/worse */ -/* than almost anything else. */ -/* The ANSI standard suggests that size_t and ptr_diff_t might be */ -/* better choices. But those appear to have incorrect definitions */ -/* on may systems. Notably "typedef int size_t" seems to be both */ -/* frequent and WRONG. */ -typedef unsigned long GC_word; -typedef long GC_signed_word; - -/* Public read-only variables */ - -GC_API GC_word GC_gc_no;/* Counter incremented per collection. */ - /* Includes empty GCs at startup. */ - - -/* Public R/W variables */ - -GC_API GC_PTR (*GC_oom_fn) GC_PROTO((size_t bytes_requested)); - /* When there is insufficient memory to satisfy */ - /* an allocation request, we return */ - /* (*GC_oom_fn)(). By default this just */ - /* returns 0. */ - /* If it returns, it must return 0 or a valid */ - /* pointer to a previously allocated heap */ - /* object. */ - -GC_API int GC_find_leak; - /* Do not actually garbage collect, but simply */ - /* report inaccessible memory that was not */ - /* deallocated with GC_free. Initial value */ - /* is determined by FIND_LEAK macro. */ - -GC_API int GC_quiet; /* Disable statistics output. Only matters if */ - /* collector has been compiled with statistics */ - /* enabled. This involves a performance cost, */ - /* and is thus not the default. */ - -GC_API int GC_finalize_on_demand; - /* If nonzero, finalizers will only be run in */ - /* response to an eplit GC_invoke_finalizers */ - /* call. The default is determined by whether */ - /* the FINALIZE_ON_DEMAND macro is defined */ - /* when the collector is built. */ - -GC_API int GC_java_finalization; - /* Mark objects reachable from finalizable */ - /* objects in a separate postpass. This makes */ - /* it a bit safer to use non-topologically- */ - /* ordered finalization. Default value is */ - /* determined by JAVA_FINALIZATION macro. */ - -GC_API int GC_dont_gc; /* Dont collect unless explicitly requested, e.g. */ - /* because it's not safe. */ - -GC_API int GC_dont_expand; - /* Dont expand heap unless explicitly requested */ - /* or forced to. */ - -GC_API int GC_full_freq; /* Number of partial collections between */ - /* full collections. Matters only if */ - /* GC_incremental is set. */ - -GC_API GC_word GC_non_gc_bytes; - /* Bytes not considered candidates for collection. */ - /* Used only to control scheduling of collections. */ - -GC_API GC_word GC_free_space_divisor; - /* We try to make sure that we allocate at */ - /* least N/GC_free_space_divisor bytes between */ - /* collections, where N is the heap size plus */ - /* a rough estimate of the root set size. */ - /* Initially, GC_free_space_divisor = 4. */ - /* Increasing its value will use less space */ - /* but more collection time. Decreasing it */ - /* will appreciably decrease collection time */ - /* at the expense of space. */ - /* GC_free_space_divisor = 1 will effectively */ - /* disable collections. */ - -GC_API GC_word GC_max_retries; - /* The maximum number of GCs attempted before */ - /* reporting out of memory after heap */ - /* expansion fails. Initially 0. */ - - -GC_API char *GC_stackbottom; /* Cool end of user stack. */ - /* May be set in the client prior to */ - /* calling any GC_ routines. This */ - /* avoids some overhead, and */ - /* potentially some signals that can */ - /* confuse debuggers. Otherwise the */ - /* collector attempts to set it */ - /* automatically. */ - /* For multithreaded code, this is the */ - /* cold end of the stack for the */ - /* primordial thread. */ - -/* Public procedures */ -/* - * general purpose allocation routines, with roughly malloc calling conv. - * The atomic versions promise that no relevant pointers are contained - * in the object. The nonatomic versions guarantee that the new object - * is cleared. GC_malloc_stubborn promises that no changes to the object - * will occur after GC_end_stubborn_change has been called on the - * result of GC_malloc_stubborn. GC_malloc_uncollectable allocates an object - * that is scanned for pointers to collectable objects, but is not itself - * collectable. GC_malloc_uncollectable and GC_free called on the resulting - * object implicitly update GC_non_gc_bytes appropriately. - */ -GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes)); -GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes)); -GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes)); -GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes)); - -/* The following is only defined if the library has been suitably */ -/* compiled: */ -GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes)); - -/* Explicitly deallocate an object. Dangerous if used incorrectly. */ -/* Requires a pointer to the base of an object. */ -/* If the argument is stubborn, it should not be changeable when freed. */ -/* An object should not be enable for finalization when it is */ -/* explicitly deallocated. */ -/* GC_free(0) is a no-op, as required by ANSI C for free. */ -GC_API void GC_free GC_PROTO((GC_PTR object_addr)); - -/* - * Stubborn objects may be changed only if the collector is explicitly informed. - * The collector is implicitly informed of coming change when such - * an object is first allocated. The following routines inform the - * collector that an object will no longer be changed, or that it will - * once again be changed. Only nonNIL pointer stores into the object - * are considered to be changes. The argument to GC_end_stubborn_change - * must be exacly the value returned by GC_malloc_stubborn or passed to - * GC_change_stubborn. (In the second case it may be an interior pointer - * within 512 bytes of the beginning of the objects.) - * There is a performance penalty for allowing more than - * one stubborn object to be changed at once, but it is acceptable to - * do so. The same applies to dropping stubborn objects that are still - * changeable. - */ -GC_API void GC_change_stubborn GC_PROTO((GC_PTR)); -GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR)); - -/* Return a pointer to the base (lowest address) of an object given */ -/* a pointer to a location within the object. */ -/* Return 0 if displaced_pointer doesn't point to within a valid */ -/* object. */ -GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer)); - -/* Given a pointer to the base of an object, return its size in bytes. */ -/* The returned size may be slightly larger than what was originally */ -/* requested. */ -GC_API size_t GC_size GC_PROTO((GC_PTR object_addr)); - -/* For compatibility with C library. This is occasionally faster than */ -/* a malloc followed by a bcopy. But if you rely on that, either here */ -/* or with the standard C library, your code is broken. In my */ -/* opinion, it shouldn't have been invented, but now we're stuck. -HB */ -/* The resulting object has the same kind as the original. */ -/* If the argument is stubborn, the result will have changes enabled. */ -/* It is an error to have changes enabled for the original object. */ -/* Follows ANSI comventions for NULL old_object. */ -GC_API GC_PTR GC_realloc - GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes)); - -/* Explicitly increase the heap size. */ -/* Returns 0 on failure, 1 on success. */ -GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes)); - -/* Limit the heap size to n bytes. Useful when you're debugging, */ -/* especially on systems that don't handle running out of memory well. */ -/* n == 0 ==> unbounded. This is the default. */ -GC_API void GC_set_max_heap_size GC_PROTO((GC_word n)); - -/* Inform the collector that a certain section of statically allocated */ -/* memory contains no pointers to garbage collected memory. Thus it */ -/* need not be scanned. This is sometimes important if the application */ -/* maps large read/write files into the address space, which could be */ -/* mistaken for dynamic library data segments on some systems. */ -GC_API void GC_exclude_static_roots GC_PROTO((GC_PTR start, GC_PTR finish)); - -/* Clear the set of root segments. Wizards only. */ -GC_API void GC_clear_roots GC_PROTO((void)); - -/* Add a root segment. Wizards only. */ -GC_API void GC_add_roots GC_PROTO((char * low_address, - char * high_address_plus_1)); - -/* Add a displacement to the set of those considered valid by the */ -/* collector. GC_register_displacement(n) means that if p was returned */ -/* by GC_malloc, then (char *)p + n will be considered to be a valid */ -/* pointer to n. N must be small and less than the size of p. */ -/* (All pointers to the interior of objects from the stack are */ -/* considered valid in any case. This applies to heap objects and */ -/* static data.) */ -/* Preferably, this should be called before any other GC procedures. */ -/* Calling it later adds to the probability of excess memory */ -/* retention. */ -/* This is a no-op if the collector was compiled with recognition of */ -/* arbitrary interior pointers enabled, which is now the default. */ -GC_API void GC_register_displacement GC_PROTO((GC_word n)); - -/* The following version should be used if any debugging allocation is */ -/* being done. */ -GC_API void GC_debug_register_displacement GC_PROTO((GC_word n)); - -/* Explicitly trigger a full, world-stop collection. */ -GC_API void GC_gcollect GC_PROTO((void)); - -/* Trigger a full world-stopped collection. Abort the collection if */ -/* and when stop_func returns a nonzero value. Stop_func will be */ -/* called frequently, and should be reasonably fast. This works even */ -/* if virtual dirty bits, and hence incremental collection is not */ -/* available for this architecture. Collections can be aborted faster */ -/* than normal pause times for incremental collection. However, */ -/* aborted collections do no useful work; the next collection needs */ -/* to start from the beginning. */ -/* Return 0 if the collection was aborted, 1 if it succeeded. */ -typedef int (* GC_stop_func) GC_PROTO((void)); -GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func)); - -/* Return the number of bytes in the heap. Excludes collector private */ -/* data structures. Includes empty blocks and fragmentation loss. */ -/* Includes some pages that were allocated but never written. */ -GC_API size_t GC_get_heap_size GC_PROTO((void)); - -/* Return the number of bytes allocated since the last collection. */ -GC_API size_t GC_get_bytes_since_gc GC_PROTO((void)); - -/* Enable incremental/generational collection. */ -/* Not advisable unless dirty bits are */ -/* available or most heap objects are */ -/* pointerfree(atomic) or immutable. */ -/* Don't use in leak finding mode. */ -/* Ignored if GC_dont_gc is true. */ -GC_API void GC_enable_incremental GC_PROTO((void)); - -/* Perform some garbage collection work, if appropriate. */ -/* Return 0 if there is no more work to be done. */ -/* Typically performs an amount of work corresponding roughly */ -/* to marking from one page. May do more work if further */ -/* progress requires it, e.g. if incremental collection is */ -/* disabled. It is reasonable to call this in a wait loop */ -/* until it returns 0. */ -GC_API int GC_collect_a_little GC_PROTO((void)); - -/* Allocate an object of size lb bytes. The client guarantees that */ -/* as long as the object is live, it will be referenced by a pointer */ -/* that points to somewhere within the first 256 bytes of the object. */ -/* (This should normally be declared volatile to prevent the compiler */ -/* from invalidating this assertion.) This routine is only useful */ -/* if a large array is being allocated. It reduces the chance of */ -/* accidentally retaining such an array as a result of scanning an */ -/* integer that happens to be an address inside the array. (Actually, */ -/* it reduces the chance of the allocator not finding space for such */ -/* an array, since it will try hard to avoid introducing such a false */ -/* reference.) On a SunOS 4.X or MS Windows system this is recommended */ -/* for arrays likely to be larger than 100K or so. For other systems, */ -/* or if the collector is not configured to recognize all interior */ -/* pointers, the threshold is normally much higher. */ -GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb)); -GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb)); - -#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720 -# define GC_ADD_CALLER -# define GC_RETURN_ADDR (GC_word)__return_address -#endif - -#ifdef GC_ADD_CALLER -# define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__ -# define GC_EXTRA_PARAMS GC_word ra, char * descr_string, int descr_int -#else -# define GC_EXTRAS __FILE__, __LINE__ -# define GC_EXTRA_PARAMS char * descr_string, int descr_int -#endif - -/* Debugging (annotated) allocation. GC_gcollect will check */ -/* objects allocated in this way for overwrites, etc. */ -GC_API GC_PTR GC_debug_malloc - GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); -GC_API GC_PTR GC_debug_malloc_atomic - GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); -GC_API GC_PTR GC_debug_malloc_uncollectable - GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); -GC_API GC_PTR GC_debug_malloc_stubborn - GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); -GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr)); -GC_API GC_PTR GC_debug_realloc - GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes, - GC_EXTRA_PARAMS)); - -GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR)); -GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR)); -# ifdef GC_DEBUG -# define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS) -# define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, GC_EXTRAS) -# define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \ - GC_EXTRAS) -# define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, GC_EXTRAS) -# define GC_FREE(p) GC_debug_free(p) -# define GC_REGISTER_FINALIZER(p, f, d, of, od) \ - GC_debug_register_finalizer(p, f, d, of, od) -# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ - GC_debug_register_finalizer_ignore_self(p, f, d, of, od) -# define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, GC_EXTRAS); -# define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p) -# define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p) -# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ - GC_general_register_disappearing_link(link, GC_base(obj)) -# define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n) -# else -# define GC_MALLOC(sz) GC_malloc(sz) -# define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz) -# define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz) -# define GC_REALLOC(old, sz) GC_realloc(old, sz) -# define GC_FREE(p) GC_free(p) -# define GC_REGISTER_FINALIZER(p, f, d, of, od) \ - GC_register_finalizer(p, f, d, of, od) -# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ - GC_register_finalizer_ignore_self(p, f, d, of, od) -# define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz) -# define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p) -# define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p) -# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ - GC_general_register_disappearing_link(link, obj) -# define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n) -# endif -/* The following are included because they are often convenient, and */ -/* reduce the chance for a misspecifed size argument. But calls may */ -/* expand to something syntactically incorrect if t is a complicated */ -/* type expression. */ -# define GC_NEW(t) (t *)GC_MALLOC(sizeof (t)) -# define GC_NEW_ATOMIC(t) (t *)GC_MALLOC_ATOMIC(sizeof (t)) -# define GC_NEW_STUBBORN(t) (t *)GC_MALLOC_STUBBORN(sizeof (t)) -# define GC_NEW_UNCOLLECTABLE(t) (t *)GC_MALLOC_UNCOLLECTABLE(sizeof (t)) - -/* Finalization. Some of these primitives are grossly unsafe. */ -/* The idea is to make them both cheap, and sufficient to build */ -/* a safer layer, closer to PCedar finalization. */ -/* The interface represents my conclusions from a long discussion */ -/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, */ -/* Christian Jacobi, and Russ Atkinson. It's not perfect, and */ -/* probably nobody else agrees with it. Hans-J. Boehm 3/13/92 */ -typedef void (*GC_finalization_proc) - GC_PROTO((GC_PTR obj, GC_PTR client_data)); - -GC_API void GC_register_finalizer - GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd, - GC_finalization_proc *ofn, GC_PTR *ocd)); -GC_API void GC_debug_register_finalizer - GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd, - GC_finalization_proc *ofn, GC_PTR *ocd)); - /* When obj is no longer accessible, invoke */ - /* (*fn)(obj, cd). If a and b are inaccessible, and */ - /* a points to b (after disappearing links have been */ - /* made to disappear), then only a will be */ - /* finalized. (If this does not create any new */ - /* pointers to b, then b will be finalized after the */ - /* next collection.) Any finalizable object that */ - /* is reachable from itself by following one or more */ - /* pointers will not be finalized (or collected). */ - /* Thus cycles involving finalizable objects should */ - /* be avoided, or broken by disappearing links. */ - /* All but the last finalizer registered for an object */ - /* is ignored. */ - /* Finalization may be removed by passing 0 as fn. */ - /* Finalizers are implicitly unregistered just before */ - /* they are invoked. */ - /* The old finalizer and client data are stored in */ - /* *ofn and *ocd. */ - /* Fn is never invoked on an accessible object, */ - /* provided hidden pointers are converted to real */ - /* pointers only if the allocation lock is held, and */ - /* such conversions are not performed by finalization */ - /* routines. */ - /* If GC_register_finalizer is aborted as a result of */ - /* a signal, the object may be left with no */ - /* finalization, even if neither the old nor new */ - /* finalizer were NULL. */ - /* Obj should be the nonNULL starting address of an */ - /* object allocated by GC_malloc or friends. */ - /* Note that any garbage collectable object referenced */ - /* by cd will be considered accessible until the */ - /* finalizer is invoked. */ - -/* Another versions of the above follow. It ignores */ -/* self-cycles, i.e. pointers from a finalizable object to */ -/* itself. There is a stylistic argument that this is wrong, */ -/* but it's unavoidable for C++, since the compiler may */ -/* silently introduce these. It's also benign in that specific */ -/* case. */ -GC_API void GC_register_finalizer_ignore_self - GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd, - GC_finalization_proc *ofn, GC_PTR *ocd)); -GC_API void GC_debug_register_finalizer_ignore_self - GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd, - GC_finalization_proc *ofn, GC_PTR *ocd)); - -/* The following routine may be used to break cycles between */ -/* finalizable objects, thus causing cyclic finalizable */ -/* objects to be finalized in the correct order. Standard */ -/* use involves calling GC_register_disappearing_link(&p), */ -/* where p is a pointer that is not followed by finalization */ -/* code, and should not be considered in determining */ -/* finalization order. */ -GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */)); - /* Link should point to a field of a heap allocated */ - /* object obj. *link will be cleared when obj is */ - /* found to be inaccessible. This happens BEFORE any */ - /* finalization code is invoked, and BEFORE any */ - /* decisions about finalization order are made. */ - /* This is useful in telling the finalizer that */ - /* some pointers are not essential for proper */ - /* finalization. This may avoid finalization cycles. */ - /* Note that obj may be resurrected by another */ - /* finalizer, and thus the clearing of *link may */ - /* be visible to non-finalization code. */ - /* There's an argument that an arbitrary action should */ - /* be allowed here, instead of just clearing a pointer. */ - /* But this causes problems if that action alters, or */ - /* examines connectivity. */ - /* Returns 1 if link was already registered, 0 */ - /* otherwise. */ - /* Only exists for backward compatibility. See below: */ - -GC_API int GC_general_register_disappearing_link - GC_PROTO((GC_PTR * /* link */, GC_PTR obj)); - /* A slight generalization of the above. *link is */ - /* cleared when obj first becomes inaccessible. This */ - /* can be used to implement weak pointers easily and */ - /* safely. Typically link will point to a location */ - /* holding a disguised pointer to obj. (A pointer */ - /* inside an "atomic" object is effectively */ - /* disguised.) In this way soft */ - /* pointers are broken before any object */ - /* reachable from them are finalized. Each link */ - /* May be registered only once, i.e. with one obj */ - /* value. This was added after a long email discussion */ - /* with John Ellis. */ - /* Obj must be a pointer to the first word of an object */ - /* we allocated. It is unsafe to explicitly deallocate */ - /* the object containing link. Explicitly deallocating */ - /* obj may or may not cause link to eventually be */ - /* cleared. */ -GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */)); - /* Returns 0 if link was not actually registered. */ - /* Undoes a registration by either of the above two */ - /* routines. */ - -/* Auxiliary fns to make finalization work correctly with displaced */ -/* pointers introduced by the debugging allocators. */ -GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data)); -GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data)); - -GC_API int GC_invoke_finalizers GC_PROTO((void)); - /* Run finalizers for all objects that are ready to */ - /* be finalized. Return the number of finalizers */ - /* that were run. Normally this is also called */ - /* implicitly during some allocations. If */ - /* GC-finalize_on_demand is nonzero, it must be called */ - /* explicitly. */ - -/* GC_set_warn_proc can be used to redirect or filter warning messages. */ -/* p may not be a NULL pointer. */ -typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg)); -GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p)); - /* Returns old warning procedure. */ - -/* The following is intended to be used by a higher level */ -/* (e.g. cedar-like) finalization facility. It is expected */ -/* that finalization code will arrange for hidden pointers to */ -/* disappear. Otherwise objects can be accessed after they */ -/* have been collected. */ -/* Note that putting pointers in atomic objects or in */ -/* nonpointer slots of "typed" objects is equivalent to */ -/* disguising them in this way, and may have other advantages. */ -# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS) - typedef GC_word GC_hidden_pointer; -# define HIDE_POINTER(p) (~(GC_hidden_pointer)(p)) -# define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p))) - /* Converting a hidden pointer to a real pointer requires verifying */ - /* that the object still exists. This involves acquiring the */ - /* allocator lock to avoid a race with the collector. */ -# endif /* I_HIDE_POINTERS */ - -typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data)); -GC_API GC_PTR GC_call_with_alloc_lock - GC_PROTO((GC_fn_type fn, GC_PTR client_data)); - -/* Check that p and q point to the same object. */ -/* Fail conspicuously if they don't. */ -/* Returns the first argument. */ -/* Succeeds if neither p nor q points to the heap. */ -/* May succeed if both p and q point to between heap objects. */ -GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q)); - -/* Checked pointer pre- and post- increment operations. Note that */ -/* the second argument is in units of bytes, not multiples of the */ -/* object size. This should either be invoked from a macro, or the */ -/* call should be automatically generated. */ -GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much)); -GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much)); - -/* Check that p is visible */ -/* to the collector as a possibly pointer containing location. */ -/* If it isn't fail conspicuously. */ -/* Returns the argument in all cases. May erroneously succeed */ -/* in hard cases. (This is intended for debugging use with */ -/* untyped allocations. The idea is that it should be possible, though */ -/* slow, to add such a call to all indirect pointer stores.) */ -/* Currently useless for multithreaded worlds. */ -GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p)); - -/* Check that if p is a pointer to a heap page, then it points to */ -/* a valid displacement within a heap object. */ -/* Fail conspicuously if this property does not hold. */ -/* Uninteresting with ALL_INTERIOR_POINTERS. */ -/* Always returns its argument. */ -GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR p)); - -/* Safer, but slow, pointer addition. Probably useful mainly with */ -/* a preprocessor. Useful only for heap pointers. */ -#ifdef GC_DEBUG -# define GC_PTR_ADD3(x, n, type_of_result) \ - ((type_of_result)GC_same_obj((x)+(n), (x))) -# define GC_PRE_INCR3(x, n, type_of_result) \ - ((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x)) -# define GC_POST_INCR2(x, type_of_result) \ - ((type_of_result)GC_post_incr(&(x), sizeof(*x)) -# ifdef __GNUC__ -# define GC_PTR_ADD(x, n) \ - GC_PTR_ADD3(x, n, typeof(x)) -# define GC_PRE_INCR(x, n) \ - GC_PRE_INCR3(x, n, typeof(x)) -# define GC_POST_INCR(x, n) \ - GC_POST_INCR3(x, typeof(x)) -# else - /* We can't do this right without typeof, which ANSI */ - /* decided was not sufficiently useful. Repeatedly */ - /* mentioning the arguments seems too dangerous to be */ - /* useful. So does not casting the result. */ -# define GC_PTR_ADD(x, n) ((x)+(n)) -# endif -#else /* !GC_DEBUG */ -# define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n)) -# define GC_PTR_ADD(x, n) ((x)+(n)) -# define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n)) -# define GC_PRE_INCR(x, n) ((x) += (n)) -# define GC_POST_INCR2(x, n, type_of_result) ((x)++) -# define GC_POST_INCR(x, n) ((x)++) -#endif - -/* Safer assignment of a pointer to a nonstack location. */ -#ifdef GC_DEBUG -# ifdef __STDC__ -# define GC_PTR_STORE(p, q) \ - (*(void **)GC_is_visible(p) = GC_is_valid_displacement(q)) -# else -# define GC_PTR_STORE(p, q) \ - (*(char **)GC_is_visible(p) = GC_is_valid_displacement(q)) -# endif -#else /* !GC_DEBUG */ -# define GC_PTR_STORE(p, q) *((p) = (q)) -#endif - -/* Fynctions called to report pointer checking errors */ -GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q)); - -GC_API void (*GC_is_valid_displacement_print_proc) - GC_PROTO((GC_PTR p)); - -GC_API void (*GC_is_visible_print_proc) - GC_PROTO((GC_PTR p)); - -#if defined(_SOLARIS_PTHREADS) && !defined(SOLARIS_THREADS) -# define SOLARIS_THREADS -#endif - -#ifdef SOLARIS_THREADS -/* We need to intercept calls to many of the threads primitives, so */ -/* that we can locate thread stacks and stop the world. */ -/* Note also that the collector cannot see thread specific data. */ -/* Thread specific data should generally consist of pointers to */ -/* uncollectable objects, which are deallocated using the destructor */ -/* facility in thr_keycreate. */ -# include -# include - int GC_thr_create(void *stack_base, size_t stack_size, - void *(*start_routine)(void *), void *arg, long flags, - thread_t *new_thread); - int GC_thr_join(thread_t wait_for, thread_t *departed, void **status); - int GC_thr_suspend(thread_t target_thread); - int GC_thr_continue(thread_t target_thread); - void * GC_dlopen(const char *path, int mode); - -# ifdef _SOLARIS_PTHREADS -# include - extern int GC_pthread_create(pthread_t *new_thread, - const pthread_attr_t *attr, - void * (*thread_execp)(void *), void *arg); - extern int GC_pthread_join(pthread_t wait_for, void **status); - -# undef thread_t - -# define pthread_join GC_pthread_join -# define pthread_create GC_pthread_create -#endif - -# define thr_create GC_thr_create -# define thr_join GC_thr_join -# define thr_suspend GC_thr_suspend -# define thr_continue GC_thr_continue -# define dlopen GC_dlopen - -# endif /* SOLARIS_THREADS */ - - -#if defined(IRIX_THREADS) || defined(LINUX_THREADS) -/* We treat these similarly. */ -# include -# include - - int GC_pthread_create(pthread_t *new_thread, - const pthread_attr_t *attr, - void *(*start_routine)(void *), void *arg); - int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset); - int GC_pthread_join(pthread_t thread, void **retval); - -# define pthread_create GC_pthread_create -# define pthread_sigmask GC_pthread_sigmask -# define pthread_join GC_pthread_join - -#endif /* IRIX_THREADS || LINUX_THREADS */ - -# if defined(PCR) || defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || \ - defined(IRIX_THREADS) || defined(LINUX_THREADS) || \ - defined(IRIX_JDK_THREADS) - /* Any flavor of threads except SRC_M3. */ -/* This returns a list of objects, linked through their first */ -/* word. Its use can greatly reduce lock contention problems, since */ -/* the allocation lock can be acquired and released many fewer times. */ -/* lb must be large enough to hold the pointer field. */ -GC_PTR GC_malloc_many(size_t lb); -#define GC_NEXT(p) (*(GC_PTR *)(p)) /* Retrieve the next element */ - /* in returned list. */ -extern void GC_thr_init(); /* Needed for Solaris/X86 */ - -#endif /* THREADS && !SRC_M3 */ - -/* - * If you are planning on putting - * the collector in a SunOS 5 dynamic library, you need to call GC_INIT() - * from the statically loaded program section. - * This circumvents a Solaris 2.X (X<=4) linker bug. - */ -#if defined(sparc) || defined(__sparc) -# define GC_INIT() { extern end, etext; \ - GC_noop(&end, &etext); } -#else -# if defined(__CYGWIN32__) && defined(GC_USE_DLL) - /* - * Similarly gnu-win32 DLLs need explicit initialization - */ -# define GC_INIT() { GC_add_roots(DATASTART, DATAEND); } -# else -# define GC_INIT() -# endif -#endif - -#if (defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \ - || defined(_WIN32) - /* win32S may not free all resources on process exit. */ - /* This explicitly deallocates the heap. */ - GC_API void GC_win32_free_heap (); -#endif - -#ifdef __cplusplus - } /* end of extern "C" */ -#endif - -#endif /* _GC_H */ diff -urN gale-0.91a/gdomain/gdomain.c gale-0.91b/gdomain/gdomain.c --- gale-0.91a/gdomain/gdomain.c Sun Dec 26 19:32:06 1999 +++ gale-0.91b/gdomain/gdomain.c Sun Jan 30 20:57:37 2000 @@ -43,23 +43,17 @@ void request(struct gale_link *link,struct auth_id *id) { struct gale_message *reply; + gale_check_mem(); reply = auth_id_public(id) ? success(id) : failure(id); auth_sign(&reply->data,domain,AUTH_SIGN_SELF); if (reply) link_put(link,reply); } -int prefix(struct gale_text x,struct gale_text prefix) { - return !gale_text_compare(gale_text_left(x,prefix.l),prefix); -} - -int suffix(struct gale_text x,struct gale_text suffix) { - return !gale_text_compare(gale_text_right(x,suffix.l),suffix); -} - void *on_message(struct gale_link *link,struct gale_message *msg,void *data) { struct auth_id *encrypted = NULL,*signature = NULL; - struct gale_text user = null_text; struct gale_fragment frag; + + gale_check_mem(); encrypted = auth_decrypt(&msg->data); if (!msg) return OOP_CONTINUE; diff -urN gale-0.91a/gsub/gsub.c gale-0.91b/gsub/gsub.c --- gale-0.91a/gsub/gsub.c Sun Dec 19 22:27:49 1999 +++ gale-0.91b/gsub/gsub.c Mon Jan 17 22:54:54 2000 @@ -528,7 +528,7 @@ /* Various flags. */ int opt,do_fork = 0,do_kill = 0; struct gale_text rclib = null_text; - struct gale_text other = null_text; + struct gale_text others,other = null_text; /* Subscription list. */ struct gale_text serv = null_text; @@ -566,7 +566,8 @@ add_subs(&serv,gale_var(G_("GALE_GSUB"))); /* Other IDs to listen to. */ - while (gale_text_token(gale_var(G_("GALE_OTHERS")),',',&other)) + others = gale_var(G_("GALE_OTHERS")); + while (gale_text_token(others,',',&other)) if (0 != other.l) add_other(&serv,other); /* Parse command line arguments. */ diff -urN gale-0.91a/include/gale/misc.h gale-0.91b/include/gale/misc.h --- gale-0.91a/include/gale/misc.h Sat Dec 25 13:52:44 1999 +++ gale-0.91b/include/gale/misc.h Sun Jan 30 20:55:04 2000 @@ -68,6 +68,7 @@ void *gale_malloc_safe(size_t size); /* memory will not be collected */ void gale_free(void *); void gale_finalizer(void *,void (*)(void *,void *),void *); +void gale_check_mem(void); struct gale_ptr; struct gale_ptr *gale_make_weak(void *); @@ -169,6 +170,9 @@ struct gale_group,struct gale_text name,enum gale_fragment_type, struct gale_fragment *); +struct gale_text gale_print_fragment(struct gale_fragment); +struct gale_text gale_print_group(struct gale_group,int indent); + /* -- data interchange conversion ------------------------------------------ */ int gale_unpack_copy(struct gale_data *,void *,size_t); @@ -273,6 +277,7 @@ /* Debugging printf. Will only output if gale_debug > level. */ void gale_dprintf(int level,const char *fmt,...); void gale_diprintf(int level,int indent,const char *fmt,...); +void gale_dmessage(int level,struct gale_message *msg); /* -- useful things for servers -------------------------------------------- */ diff -urN gale-0.91a/kutils/gkinfo.c gale-0.91b/kutils/gkinfo.c --- gale-0.91a/kutils/gkinfo.c Sun Dec 26 17:17:15 1999 +++ gale-0.91b/kutils/gkinfo.c Sun Jan 30 20:41:45 2000 @@ -5,13 +5,19 @@ #include "gale/all.h" +/* For MD5: */ +#include "global.h" +#include "rsaref.h" + #include #include #include #include #include -int iflag = 0; +int do_name_only = 0; +int do_verbose = 0; +int is_found = 0; const byte m_gale[] = { 0x68, 0x13 }; const byte m_pub[] = { 0x00, 0x00 }; @@ -20,87 +26,79 @@ const byte m_priv2[] = { 0x00, 0x03 }; const byte m_sign[] = { 0x01, 0x00 }; -void pub_info(struct auth_id *id) { +const byte m_gale3[] = { 'G', 'A', 'L', 'E' }; +const byte m_pub3[] = { 0x00, 0x01 }; + +const char *do_indent(int indent) { + char *str; + gale_create_array(str,1 + indent); + str[indent] = '\0'; + while (indent--) str[indent] = ' '; + return str; +} + +void do_info(struct gale_group grp,const struct inode *i,int indent) { + if (0 != i->name.l) + printf("%sStored in \"%s\"\n",do_indent(indent), + gale_text_to_local(i->name)); + + printf("%s",gale_text_to_local(gale_print_group(grp,2))); +} + +void pub_info(struct auth_id *id,int indent) { struct gale_fragment frag; printf("<%s>",gale_text_to_local(id->name)); if (gale_group_lookup(id->pub_data,G_("key.owner"),frag_text,&frag)) printf(" (%s)",gale_text_to_local(frag.value.text)); - if (gale_group_lookup(id->pub_data,G_("rsa.bits"),frag_number,&frag)) - printf(", %d bits",frag.value.number); if (id->pub_trusted) printf(" [trusted]"); printf("\n"); - if (gale_group_lookup(id->pub_data,G_("key.redirect"),frag_text,&frag)) - printf("Redirector to: <%s>\n", - gale_text_to_local(frag.value.text)); -} -void pub_date(struct gale_time time) { - struct timeval tv; - time_t sec; - char buf[30]; - gale_time_to(&tv,time); - sec = tv.tv_sec; - strftime(buf,sizeof(buf),"%Y-%m-%d %H:%M",localtime(&sec)); - printf("%s",buf); -} + if (do_verbose) do_info(id->pub_data,&id->pub_inode,indent += 2); -void pub_key(struct auth_id *id) { - int indent = 0; + if (gale_group_lookup(id->pub_data,G_("key.redirect"),frag_text,&frag)) + printf("%sRedirector to <%s>\n", + do_indent(indent),gale_text_to_local(frag.value.text)); - if (iflag) { - printf("%s\n",gale_text_to_local(id->name)); + if (do_verbose) { + putchar('\n'); return; } + if (NULL == id->pub_signer) return; + printf("%sSigned: ",do_indent(indent += 2)); + pub_info(id->pub_signer,indent); +} + +void pub_key(struct auth_id *id) { + is_found = 1; + if (do_name_only) return; + if (_ga_trust_pub(id)) printf("Trusted"); else printf("UNTRUSTED"); - printf(" public key: "); pub_info(id); - while (NULL != id->pub_signer) { - struct gale_fragment frag; - int i; - indent += 2; - for (i = 0; i < indent; ++i) printf(" "); - printf("Signed"); - if (gale_group_lookup(id->pub_data,G_("key.signed"), - frag_time,&frag) - && gale_time_compare(gale_time_zero(),frag.value.time) < 0) { - printf(" ("); - pub_date(frag.value.time); - if (gale_group_lookup(id->pub_data,G_("key.expires"), - frag_time,&frag) - && gale_time_compare(frag.value.time, - gale_time_forever()) < 0) { - printf(" - "); - pub_date(frag.value.time); - } - printf(")"); - } - id = id->pub_signer; - printf(": "); pub_info(id); - } + printf(" public key: "); pub_info(id,0); } void priv_key(struct auth_id *id) { - struct gale_fragment frag; - if (iflag) { - printf("%s\n",gale_text_to_local(id->name)); - return; + is_found = 1; + if (do_name_only) return; + + printf("Private key: <%s>\n",gale_text_to_local(id->name)); + if (do_verbose) { + do_info(id->priv_data,&id->priv_inode,2); + putchar('\n'); } - printf("Private key: <%s>",gale_text_to_local(id->name)); - if (gale_group_lookup(id->priv_data,G_("rsa.bits"),frag_number,&frag)) - printf(", %d bits",frag.value.number); - printf("\n"); } void usage(void) { fprintf(stderr, "%s\n" - "usage: gkinfo [-hix] (id | < keyfile)\n" + "usage: gkinfo [-hvix] (id | < keyfile)\n" "flags: -h Display this message\n" " -i Output key ID only\n" + " -v Verbose output\n" " -x Disable remote key retrieval\n" ,GALE_BANNER); exit(1); @@ -113,9 +111,10 @@ gale_init("gkinfo",argc,argv); - while ((arg = getopt(argc,argv,"ixdD")) != EOF) switch (arg) { - case 'i': iflag = 1; break; + while ((arg = getopt(argc,argv,"ixvdD")) != EOF) switch (arg) { + case 'i': do_name_only = 1; break; case 'x': disable_gale_akd(); break; + case 'v': do_verbose = 1; break; case 'd': ++gale_global->debug_level; break; case 'D': gale_global->debug_level += 5; break; case 'h': @@ -123,46 +122,55 @@ } if (optind + 1 == argc) { - int found = 0; init_auth_id(&id,gale_text_from_local(argv[optind],-1)); - if (iflag) { - found = auth_id_private(id) || auth_id_public(id); - printf("%s\n",gale_text_to_local(auth_id_name(id))); - } else { - if (auth_id_private(id)) { - found = 1; - priv_key(id); - } - if (auth_id_public(id)) { - found = 1; - pub_key(id); - } - } - if (!found) gale_alert(GALE_ERROR,"could not find key",0); + if (auth_id_private(id)) priv_key(id); + if (auth_id_public(id)) pub_key(id); } else { + struct gale_data test; + if (optind != argc) usage(); if (isatty(0)) usage(); if (!_ga_load(0,&key)) gale_alert(GALE_ERROR,"could not read file",errno); - if (key.l < 4 || memcmp(key.p,m_gale,sizeof(m_gale))) - gale_alert(GALE_ERROR,"unrecognized file format",0); - - if (!memcmp(key.p + sizeof(m_gale),m_pub,sizeof(m_pub)) - || !memcmp(key.p + sizeof(m_gale),m_pub2,sizeof(m_pub2))) { - struct inode inode = _ga_init_inode(); - _ga_import_pub(&id,key,&inode,IMPORT_NORMAL); - if (!id) gale_alert(GALE_ERROR,"public key invalid",0); - pub_key(id); - } else - if (!memcmp(key.p + sizeof(m_gale),m_priv,sizeof(m_pub)) - || !memcmp(key.p + sizeof(m_gale),m_priv2,sizeof(m_priv2))) { - _ga_import_priv(&id,key,NULL); - if (!id) gale_alert(GALE_ERROR,"private key invalid",0); - priv_key(id); + test = key; + if (gale_unpack_compare(&test,m_gale,sizeof(m_gale))) { + if (gale_unpack_compare(&test,m_pub,sizeof(m_pub)) + || gale_unpack_compare(&test,m_pub2,sizeof(m_pub2))) { + struct inode inode = _ga_init_inode(); + _ga_import_pub(&id,key,&inode,IMPORT_NORMAL); + if (NULL == id) + gale_alert(GALE_ERROR, + "public key invalid",0); + pub_key(id); + } else + if (gale_unpack_compare(&test,m_priv,sizeof(m_priv)) + || gale_unpack_compare(&test,m_priv2,sizeof(m_priv2))){ + _ga_import_priv(&id,key,NULL); + if (NULL == id) + gale_alert(GALE_ERROR, + "private key invalid",0); + priv_key(id); + } else + gale_alert(GALE_ERROR,"invalid key",0); + } else if (gale_unpack_compare(&test,m_gale3,sizeof(m_gale3))) { + if (gale_unpack_compare(&test,m_pub3,sizeof(m_pub3))) { + struct inode inode = _ga_init_inode(); + _ga_import_pub(&id,key,&inode,IMPORT_NORMAL); + if (NULL == id) + gale_alert(GALE_ERROR, + "new public key invalid",0); + pub_key(id); + } else + gale_alert(GALE_ERROR,"invalid key",0); } else - gale_alert(GALE_ERROR,"unknown file data",0); + gale_alert(GALE_ERROR,"unknown file format",0); } + + if (!is_found) + gale_alert(GALE_ERROR,"could not find key",0); + else if (do_name_only) + printf("%s\n",gale_text_to_local(auth_id_name(id))); return 0; } diff -urN gale-0.91a/lib/Makefile.am gale-0.91b/lib/Makefile.am --- gale-0.91a/lib/Makefile.am Sun Dec 26 22:07:10 1999 +++ gale-0.91b/lib/Makefile.am Sun Jan 30 21:02:21 2000 @@ -3,12 +3,12 @@ lib_LTLIBRARIES = libgale.la # version:revision:age -# current as of 0.91 -libgale_la_LDFLAGS = -version-info 7:1:0 +# current as of 0.91b +libgale_la_LDFLAGS = -version-info 8:0:1 libgale_la_SOURCES = \ authgrp.c client.c connect.c find.c id.c init.c global.c \ - input.c kill.c libgale.c link.c message.c output.c \ + input.c kill.c libgale.c link.c message.c output.c debug.c \ standard.c cache.c \ crypt.c customs.c file.c gen.c \ keyid.c findkey.c privkey.c pubkey.c random.c sign.c \ diff -urN gale-0.91a/lib/Makefile.in gale-0.91b/lib/Makefile.in --- gale-0.91a/lib/Makefile.in Sun Dec 26 22:17:32 1999 +++ gale-0.91b/lib/Makefile.in Sun Jan 30 21:54:50 2000 @@ -82,10 +82,10 @@ lib_LTLIBRARIES = libgale.la # version:revision:age -# current as of 0.91 -libgale_la_LDFLAGS = -version-info 7:1:0 +# current as of 0.91b +libgale_la_LDFLAGS = -version-info 8:0:1 -libgale_la_SOURCES = authgrp.c client.c connect.c find.c id.c init.c global.c input.c kill.c libgale.c link.c message.c output.c standard.c cache.c crypt.c customs.c file.c gen.c keyid.c findkey.c privkey.c pubkey.c random.c sign.c dir.c error.c errpuff.c exec.c alloc.c server.c text.c time.c pack.c term.c fragment.c var.c weaktree.c +libgale_la_SOURCES = authgrp.c client.c connect.c find.c id.c init.c global.c input.c kill.c libgale.c link.c message.c output.c debug.c standard.c cache.c crypt.c customs.c file.c gen.c keyid.c findkey.c privkey.c pubkey.c random.c sign.c dir.c error.c errpuff.c exec.c alloc.c server.c text.c time.c pack.c term.c fragment.c var.c weaktree.c noinst_HEADERS = buffer.h common.h file.h id.h key.h pack.h random.h sign.h @@ -103,10 +103,10 @@ libgale_la_LIBADD = libgale_la_OBJECTS = authgrp.lo client.lo connect.lo find.lo id.lo \ init.lo global.lo input.lo kill.lo libgale.lo link.lo message.lo \ -output.lo standard.lo cache.lo crypt.lo customs.lo file.lo gen.lo \ -keyid.lo findkey.lo privkey.lo pubkey.lo random.lo sign.lo dir.lo \ -error.lo errpuff.lo exec.lo alloc.lo server.lo text.lo time.lo pack.lo \ -term.lo fragment.lo var.lo weaktree.lo +output.lo debug.lo standard.lo cache.lo crypt.lo customs.lo file.lo \ +gen.lo keyid.lo findkey.lo privkey.lo pubkey.lo random.lo sign.lo \ +dir.lo error.lo errpuff.lo exec.lo alloc.lo server.lo text.lo time.lo \ +pack.lo term.lo fragment.lo var.lo weaktree.lo CFLAGS = @CFLAGS@ COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) @@ -284,6 +284,10 @@ ../include/gale/misc.h ../include/gale/core.h ../liboop/oop.h \ ../include/gale/auth.h ../include/gale/client.h key.h file.h \ id.h sign.h +debug.lo debug.o : debug.c ../include/gale/misc.h \ + ../include/gale/types.h ../include/gale/compat.h \ + ../include/gale/config.h ../include/gale/core.h ../liboop/oop.h \ + ../include/gale/globals.h ../include/gale/auth.h dir.lo dir.o : dir.c ../include/gale/all.h ../include/gale/globals.h \ ../include/gale/types.h ../include/gale/compat.h \ ../include/gale/config.h ../include/gale/misc.h \ diff -urN gale-0.91a/lib/alloc.c gale-0.91b/lib/alloc.c --- gale-0.91a/lib/alloc.c Fri Jul 23 23:17:45 1999 +++ gale-0.91b/lib/alloc.c Sun Jan 30 20:54:47 2000 @@ -18,6 +18,7 @@ void *gale_malloc_safe(size_t len) { return GC_malloc_uncollectable(len); } void gale_free(void *ptr) { GC_free(ptr); } void *gale_realloc(void *s,size_t len) { return GC_realloc(s,len); } +void gale_check_mem(void) { GC_gcollect(); } void gale_finalizer(void *obj,void (*f)(void *,void *),void *data) { GC_register_finalizer(obj,f,data,0,0); @@ -42,6 +43,7 @@ void *gale_malloc_safe(size_t len) { return malloc(len); } void gale_free(void *ptr) { free(ptr); } void *gale_realloc(void *s,size_t len) { return realloc(s,len); } +void gale_check_mem(void) { } void gale_finalizer(void *obj,void (*f)(void *,void *),void *data) { } diff -urN gale-0.91a/lib/debug.c gale-0.91b/lib/debug.c --- gale-0.91a/lib/debug.c Wed Dec 31 16:00:00 1969 +++ gale-0.91b/lib/debug.c Sun Jan 30 20:46:49 2000 @@ -0,0 +1,38 @@ +#include "gale/misc.h" +#include "gale/core.h" +#include "gale/globals.h" + +#include + +static void debug(int level,int idelta,const char *fmt,va_list ap) { + static int indent = 0; + int i; + if (idelta < 0) indent += idelta; + for (i = 0; i < indent; ++i) fputc(' ',stderr); + vfprintf(stderr,fmt,ap); + fflush(stderr); + if (idelta > 0) indent += idelta; +} + +void gale_dprintf(int level,const char *fmt,...) { + va_list ap; + if (level >= gale_global->debug_level) return; + va_start(ap,fmt); + debug(level,0,fmt,ap); + va_end(ap); +} + +void gale_diprintf(int level,int indent,const char *fmt,...) { + va_list ap; + if (level >= gale_global->debug_level) return; + va_start(ap,fmt); + debug(level,indent,fmt,ap); + va_end(ap); +} + +void gale_dmessage(int level,struct gale_message *msg) { + if (level >= gale_global->debug_level) return; + gale_dprintf(level," category is %s\n",gale_text_to_local(msg->cat)); + gale_dprintf(level,"%s", + gale_text_to_local(gale_print_group(msg->data,2))); +} diff -urN gale-0.91a/lib/fragment.c gale-0.91b/lib/fragment.c --- gale-0.91a/lib/fragment.c Sat Dec 25 21:02:59 1999 +++ gale-0.91b/lib/fragment.c Sun Jan 30 21:53:04 2000 @@ -1,6 +1,9 @@ #include #include "gale/misc.h" +#include "global.h" +#include "rsaref.h" + #define fragment_text 0 #define fragment_data 1 #define fragment_time 2 @@ -292,4 +295,86 @@ } return size; +} + +struct gale_text gale_print_fragment(struct gale_fragment frag) { + struct gale_time t; + struct gale_text r = null_text; + switch (frag.type) { + case frag_text: + return gale_text_concat(3,G_("\""),frag.value.text,G_("\"")); + + case frag_time: + t = frag.value.time; + if (0 == gale_time_compare(gale_time_zero(),t)) + return G_("(long ago)"); + else if (0 == gale_time_compare(gale_time_forever(),t)) + return G_("(never)"); + else + { + struct timeval tv; + time_t sec; + char buf[30]; + gale_time_to(&tv,t); + sec = tv.tv_sec; + strftime(buf,sizeof(buf),"%Y-%m-%d %H:%M", + localtime(&sec)); + return gale_text_from_latin1(buf,-1); + } + + case frag_number: + return gale_text_from_number(frag.value.number,10,0); + + case frag_data: + if (20 >= frag.value.data.l) + { + int i; + for (i = 0; i < frag.value.data.l; ++i) + r = gale_text_concat(3,r, + i ? G_(" ") : G_("["), + gale_text_from_number(frag.value.data.p[i],16,2)); + r = gale_text_concat(2,t,G_("]")); + } + else + { + int i; + u8 hash[16]; + MD5_CTX ctx; + MD5Init(&ctx); + MD5Update(&ctx,frag.value.data.p,frag.value.data.l); + MD5Final(hash,&ctx); + for (i = 0; i < 16; ++i) + r = gale_text_concat(3,r, + i ? G_(" ") : G_("{"), + gale_text_from_number(hash[i],16,2)); + r = gale_text_concat(2,r,G_("}")); + } + return r; + + case frag_group: + return G_("(nested group)"); + + default: + return G_("(unknown type)"); + } +} + +struct gale_text gale_print_group(struct gale_group grp,int indent) { + struct gale_text i,t = null_text; + wch *ch; + gale_create_array(ch,indent); + i.p = ch; + i.l = indent; + while (indent--) ch[indent] = ' '; + + while (!gale_group_null(grp)) + { + struct gale_fragment frag = gale_group_first(grp); + t = gale_text_concat(6, + t,i,frag.name,G_(": "), + gale_print_fragment(frag), + G_("\n")); + grp = gale_group_rest(grp); + } + return t; } diff -urN gale-0.91a/lib/link.c gale-0.91b/lib/link.c --- gale-0.91a/lib/link.c Thu Sep 30 16:10:03 1999 +++ gale-0.91b/lib/link.c Sun Jan 30 20:12:06 2000 @@ -108,6 +108,7 @@ m = link->msg; gale_free(link); gale_dprintf(7,"<- dequeueing message [%p]\n",m); + gale_dmessage(19,m); } return m; } @@ -807,6 +808,7 @@ ++l->queue_num; l->queue_mem += message_size(m); gale_dprintf(7,"-> enqueueing message [%p]\n",m); + gale_dmessage(19,m); activate(l); } diff -urN gale-0.91a/lib/pubkey.c gale-0.91b/lib/pubkey.c --- gale-0.91a/lib/pubkey.c Sun Dec 26 17:11:54 1999 +++ gale-0.91b/lib/pubkey.c Sun Jan 30 21:50:47 2000 @@ -27,7 +27,7 @@ magic: 0x4741 0x4C45 0x0001 id: counted Unicode -- possibly truncated here: EXPORT_STUB -- - data: fragment group + data: fragment group (no zero!) */ static const byte magic[] = { 0x68, 0x13, 0x00, 0x00 }; @@ -89,6 +89,7 @@ return 1; } +#if 0 static int pack_fragment(struct gale_data *data,struct gale_group group, struct gale_text name,enum gale_fragment_type type) { @@ -106,6 +107,7 @@ } return 1; } +#endif void _ga_import_pub(struct auth_id **id,struct gale_data key, struct inode *source,int trust) { @@ -205,7 +207,7 @@ } else valid = _ga_trust_pub(try); - if (valid && !_ga_pub_older(try->pub_data,data)) goto ignore; + if (valid && !trust && !_ga_pub_older(try->pub_data,data)) goto ignore; if (2 >= version && 0 != key.l) { struct gale_data blob = save; @@ -220,11 +222,11 @@ if (NULL != sig.id && gale_text_compare(sig.id->name,_ga_signer(try->name))) { - _ga_warn_id(G_("key \"%\" cannot certify \"%\""),sig.id,key); + _ga_warn_id(G_("key \"%\" cannot certify \"%\""),sig.id,try); _ga_init_sig(&sig); } - if (valid && !_ga_trust_pub(sig.id)) goto ignore; + if (valid && !trust && !_ga_trust_pub(sig.id)) goto ignore; /* OK... now install the key. */ if (!gale_group_null(try->pub_data) @@ -257,7 +259,7 @@ ignore: if (_ga_pub_equal(try->pub_data,data)) goto success; - _ga_warn_id(G_("\"%\": ignoring obsolete public key"),key); + _ga_warn_id(G_("\"%\": ignoring obsolete public key"),try); return; success: diff -urN gale-0.91a/lib/server.c gale-0.91b/lib/server.c --- gale-0.91a/lib/server.c Mon Aug 9 19:05:17 1999 +++ gale-0.91b/lib/server.c Sun Jan 30 20:12:41 2000 @@ -16,33 +16,6 @@ struct gale_cleanup *next; }; -static void debug(int level,int idelta,const char *fmt,va_list ap) { - static int indent = 0; - int i; - if (idelta < 0) indent += idelta; - if (level < gale_global->debug_level) { - for (i = 0; i < indent; ++i) fputc(' ',stderr); - vfprintf(stderr,fmt,ap); - fflush(stderr); - } - if (idelta > 0) indent += idelta; -} - -void gale_dprintf(int level,const char *fmt,...) { - va_list ap; - va_start(ap,fmt); - debug(level,0,fmt,ap); - va_end(ap); -} - -void gale_diprintf(int level,int indent,const char *fmt,...) { - va_list ap; - if (level >= gale_global->debug_level) return; - va_start(ap,fmt); - debug(level,indent,fmt,ap); - va_end(ap); -} - static void *on_ignore(oop_source *source,int sig,void *data) { return OOP_CONTINUE; } diff -urN gale-0.91a/lib/sign.c gale-0.91b/lib/sign.c --- gale-0.91a/lib/sign.c Sun Dec 26 11:16:50 1999 +++ gale-0.91b/lib/sign.c Sun Jan 30 20:59:06 2000 @@ -59,8 +59,6 @@ _ga_pack_u32(data,sig->sig.l); _ga_pack_copy(data,sig->sig.p,sig->sig.l); _ga_pack_copy(data,key.p,key.l); - - gale_free(key.p); } void _ga_init_sig(struct signature *sig) { diff -urN gale-0.91a/lib/text.c gale-0.91b/lib/text.c --- gale-0.91a/lib/text.c Sun Dec 26 13:20:19 1999 +++ gale-0.91b/lib/text.c Mon Jan 17 23:39:06 2000 @@ -71,7 +71,8 @@ } if (token->p < string.p || token->p > string.p + string.l) { - /* Invalid (typically NULL) token => start iteration. */ + /* null_text token => start iteration. */ + assert(NULL == token->p && 0 == token->l); token->p = string.p - 1; token->l = 0; } else if (token->p + token->l >= string.p + string.l) { diff -urN gale-0.91a/liboop/COPYING gale-0.91b/liboop/COPYING --- gale-0.91a/liboop/COPYING Sat Aug 14 18:32:15 1999 +++ gale-0.91b/liboop/COPYING Thu Jan 27 20:59:46 2000 @@ -1,9 +1,3 @@ - Most of liboop is covered under the Lesser GPL (below). - -** However, the contents of the "foreign" directory may have their own -** license agreements. See foreign/README for details. - -------------------------------------------------------------------------------- GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff -urN gale-0.91a/liboop/Makefile.am gale-0.91b/liboop/Makefile.am --- gale-0.91a/liboop/Makefile.am Sun Sep 12 23:22:52 1999 +++ gale-0.91b/liboop/Makefile.am Sun Jan 30 21:26:53 2000 @@ -8,7 +8,7 @@ AUTOMAKE_OPTIONS = foreign 1.2 lib_LTLIBRARIES = liboop.la liboop-adns.la liboop-glib.la liboop-www.la -INCLUDES = $(GLIB_INCLUDES) $(WWW_INCLUDES) -I$(top_srcdir)/foreign +INCLUDES = $(GLIB_INCLUDES) $(WWW_INCLUDES) # versions updated as of 0.4 @@ -30,10 +30,6 @@ test_oop_SOURCES = test-oop.c test_oop_LDADD = $(ADNS_LIBS) $(GLIB_LIBS) $(WWW_LIBS) liboop.la - -dist-hook: - mkdir $(distdir)/foreign - cp -p $(srcdir)/foreign/README $(srcdir)/foreign/*.h $(distdir)/foreign release: dist gzip -dc $(PACKAGE)-$(VERSION).tar.gz | bzip2 -9 \ diff -urN gale-0.91a/liboop/Makefile.in gale-0.91b/liboop/Makefile.in --- gale-0.91a/liboop/Makefile.in Sun Dec 26 22:17:25 1999 +++ gale-0.91b/liboop/Makefile.in Sun Jan 30 21:54:46 2000 @@ -87,7 +87,7 @@ AUTOMAKE_OPTIONS = foreign 1.2 lib_LTLIBRARIES = liboop.la liboop-adns.la liboop-glib.la liboop-www.la -INCLUDES = $(GLIB_INCLUDES) $(WWW_INCLUDES) -I$(top_srcdir)/foreign +INCLUDES = $(GLIB_INCLUDES) $(WWW_INCLUDES) # versions updated as of 0.4 @@ -349,15 +349,13 @@ || cp -p $$d/$$file $(distdir)/$$file || :; \ fi; \ done - $(MAKE) $(AM_MAKEFLAGS) top_distdir="$(top_distdir)" distdir="$(distdir)" dist-hook -adns.lo adns.o : adns.c oop.h foreign/adns.h oop-adns.h +adns.lo adns.o : adns.c oop.h oop-adns.h alloc.lo alloc.o : alloc.c oop.h -glib.lo glib.o : glib.c foreign/glib.h oop-glib.h oop.h +glib.lo glib.o : glib.c oop-glib.h oop.h select.lo select.o : select.c oop.h signal.lo signal.o : signal.c oop.h sys.lo sys.o : sys.c oop.h -test-oop.o: test-oop.c oop.h foreign/glib.h oop-glib.h foreign/adns.h \ - oop-adns.h oop-www.h +test-oop.o: test-oop.c oop.h oop-glib.h oop-adns.h oop-www.h www.lo www.o : www.c oop.h oop-www.h info-am: @@ -442,10 +440,6 @@ mostlyclean-generic distclean-generic clean-generic \ maintainer-clean-generic clean mostlyclean distclean maintainer-clean - -dist-hook: - mkdir $(distdir)/foreign - cp -p $(srcdir)/foreign/README $(srcdir)/foreign/*.h $(distdir)/foreign release: dist gzip -dc $(PACKAGE)-$(VERSION).tar.gz | bzip2 -9 \ diff -urN gale-0.91a/liboop/adns.c gale-0.91b/liboop/adns.c --- gale-0.91a/liboop/adns.c Sun Aug 15 15:19:54 1999 +++ gale-0.91b/liboop/adns.c Sun Jan 30 21:27:26 2000 @@ -4,6 +4,8 @@ terms of the GNU Lesser General Public License, version 2.1 or later. See the file COPYING for details. */ +#ifdef HAVE_ADNS + #include "oop.h" #include "adns.h" #include "oop-adns.h" @@ -141,3 +143,5 @@ adns_afterselect(a->state,num,rfd,wfd,&xfd,&now); return on_process(a->source,OOP_TIME_NOW,a); } + +#endif diff -urN gale-0.91a/liboop/configure gale-0.91b/liboop/configure --- gale-0.91a/liboop/configure Mon Oct 11 19:55:31 1999 +++ gale-0.91b/liboop/configure Sun Jan 30 21:27:47 2000 @@ -701,7 +701,7 @@ PACKAGE=liboop -VERSION=0.4 +VERSION=0.5 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; } diff -urN gale-0.91a/liboop/configure.in gale-0.91b/liboop/configure.in --- gale-0.91a/liboop/configure.in Mon Oct 11 19:53:45 1999 +++ gale-0.91b/liboop/configure.in Sun Jan 30 21:26:40 2000 @@ -1,6 +1,6 @@ dnl Process this file with autoconf to produce a configure script. AC_INIT(INSTALL) -AM_INIT_AUTOMAKE(liboop,0.4) +AM_INIT_AUTOMAKE(liboop,0.5) AC_CANONICAL_HOST dnl Use libtool for shared libraries diff -urN gale-0.91a/liboop/foreign/HTEvent.h gale-0.91b/liboop/foreign/HTEvent.h --- gale-0.91a/liboop/foreign/HTEvent.h Sat Oct 9 12:05:39 1999 +++ gale-0.91b/liboop/foreign/HTEvent.h Wed Dec 31 16:00:00 1969 @@ -1,246 +0,0 @@ -/* - - W3C Sample Code Library libwww Event Class - - -! - The Event Class -! -*/ - -/* -** (c) COPYRIGHT MIT 1995. -** Please first read the full copyright statement in the file COPYRIGH. -*/ - -/* - -The Event Class defines any event manager to be used by libwww for handling -events. An event is not strictly defined as it is highly platform -dependent and hence out of scope for the Library. If you are using the libwww -pseudo threads on Unix then an event is when the select() system -call returns a notification on a socket descriptor, but it may as well -be an asynchronous event from the windows manager etc. If your application -is not using anything but traditional blocking sockets then you do not need -an event manager at all. In that case, libwww will block on any socket or -system call until the process can proceed. - -The libwww interface to an event manager is very simple as it consists of -registering a socket descriptor, the location in the -program, and the current state when an operation (for example -read) would block. When the event manager at a later point in -time gets a notification that the socket has become ready, it can then call -libwww with the state saved from the registration and libwww can continue. -Second, libwww must be able to unregister a socket when it is not -anymore in a state where it can block. Only in case the application -wishes to use non-blocking sockets it should register methods for -handling the registration process as described below. - -Note: The library core does not define any event manager -- it is considered part of the application. The library comes with a -default event manager which can be initiated -using the function HTEventInit() in HTInit -module - -This module is implemented by HTEvent.c, and it is -a part of the W3C Sample Code Library. -*/ - -#ifndef HTEVENT_H -#define HTEVENT_H -#include "wwwsys.h" -#ifdef IN_EVENT -typedef struct _HTTimer HTTimer; -#endif - -typedef enum _HTPriority { - HT_PRIORITY_INV = -1, - HT_PRIORITY_OFF = 0, - HT_PRIORITY_MIN = 1, - HT_PRIORITY_MAX = 20 -} HTPriority; - -#define HTEVENT_INDEX 0x10 -typedef enum { -#ifdef WWW_WIN_ASYNC - HTEvent_READ = (0x001 | 0 << HTEVENT_INDEX), - HTEvent_WRITE = (0x002 | 1 << HTEVENT_INDEX), - HTEvent_OOB = (0x004 | 2 << HTEVENT_INDEX), - HTEvent_ACCEPT = (0x008 | 3 << HTEVENT_INDEX), - HTEvent_CONNECT = (0x010 | 4 << HTEVENT_INDEX), - HTEvent_CLOSE = (0x020 | 5 << HTEVENT_INDEX), - HTEvent_TYPES = 6, /* winsock has seperate events for all of these */ -#define HTEVENT_TYPES 6 /* use in constructing the fake event below */ -#else /* WWW_WIN_ASYNC */ - HTEvent_READ = (0x001 | 0 << HTEVENT_INDEX), - HTEvent_ACCEPT = (0x002 | 0 << HTEVENT_INDEX), - HTEvent_CLOSE = (0x004 | 0 << HTEVENT_INDEX), - HTEvent_WRITE = (0x008 | 1 << HTEVENT_INDEX), - HTEvent_CONNECT = (0x010 | 1 << HTEVENT_INDEX), - HTEvent_OOB = (0x020 | 2 << HTEVENT_INDEX), - HTEvent_TYPES = 3, /* only READ, WRITE, and OOB are real types */ -#define HTEVENT_TYPES 3 /* use in constructing the fake event below */ -#endif /* !WWW_WIN_ASYNC */ - /* - ** fake events - these don't correspond to event manager events, but they - ** are usefull for communicating with the protocol modules - */ - HTEvent_TIMEOUT = (0x040 | HTEVENT_TYPES << HTEVENT_INDEX), - HTEvent_BEGIN = (0x000 | HTEVENT_TYPES << HTEVENT_INDEX), - HTEvent_END = (0x080 | HTEVENT_TYPES << HTEVENT_INDEX), - HTEvent_FLUSH = (0x100 | HTEVENT_TYPES << HTEVENT_INDEX), - HTEvent_RESET = (0x200 | HTEVENT_TYPES << HTEVENT_INDEX), - HTEvent_ALL = 0xFFFF -} HTEventType; - -#define HTEvent_BITS(type) (type & 0xFFFF) -#define HTEvent_INDEX(type) (type >> HTEVENT_INDEX) - -#define HT_EVENT_INITIALIZER \ - {HTEvent_READ, "HTEvent_READ"}, \ - {HTEvent_ACCEPT, "HTEvent_ACCEPT"}, \ - {HTEvent_CLOSE, "HTEvent_CLOSE"}, \ - {HTEvent_WRITE, "HTEvent_WRITE"}, \ - {HTEvent_CONNECT, "HTEvent_CONNECT"}, \ - {HTEvent_OOB, "HTEvent_OOB"}, \ - {HTEvent_TIMEOUT, "HTEvent_TIMEOUT"}, \ - {HTEvent_BEGIN, "HTEvent_BEGIN"}, \ - {HTEvent_END, "HTEvent_END"}, \ - {HTEvent_FLUSH, "HTEvent_FLUSH"}, \ - {HTEvent_RESET, "HTEvent_RESET"} - -extern char * HTEvent_type2str(HTEventType type); - -/* -. - Event Handlers -. - -A location is a function that can be registered by the event manager -and called at a later point in time in order to continue an operation. All -locations must be of type  HTEventCallback as defined here: -*/ - -typedef int HTEventCallback (SOCKET, void *, HTEventType); -typedef struct _HTEvent HTEvent; - -/* Avoid circular include for HTReq->HTNet->HTHost: HTEvent blah */ -#include "HTReq.h" - -/* - -There are many default event handlers provided with the Library. For example, -all the protocol modules such as the HTTP client module -are implemented as event handlers. In stead of using blocking sockets, this -allows a protocol module to register itself when performing an operation -that would block. When the sockets becomes ready the handler is called with -th socket in question, the request object, and the socket operation   -. - Registering and Unregistering Events -. - -As mentioned above, the only interface libwww requires from an event manager -is a method to register an event when an operation would block and -unregister it when the operation has completed The library registers -and unregisters events by calling the following two functions: -*/ - -extern int HTEvent_register (SOCKET, HTEventType, HTEvent *); -extern int HTEvent_unregister (SOCKET, HTEventType); - -/* - -The register function contains information about which socket we are waiting -on to get ready and which operation we are waiting for (read, write, etc.), -the request object containing the current request, the event handler that -we want to be called when the socket becomes reasy, and finally the priority -by which we want the thread to be processed by the event manager. Likewise, -libwww can unregister a operation on a socket which means that libwww is -no longer waiting for this actiion to become ready. -. - Registering an Event Manager -. - -Libwww core does not contain any event manager as it depends on whether you -want to use pseudo threads no threads, or real threads. Instead, libwww comes -with a default implementation that you may register, -but you may as well implement and register your own. The register and unregister -functions above actually does nothing than looking for a registered event -manager and then passes the call on to that. You register your own event -manager by using the methods below: -*/ - -typedef int HTEvent_registerCallback(SOCKET, HTEventType, HTEvent *); -typedef int HTEvent_unregisterCallback(SOCKET, HTEventType); - -extern void HTEvent_setRegisterCallback(HTEvent_registerCallback *); -extern void HTEvent_setUnregisterCallback(HTEvent_unregisterCallback *); - -/* -( - Has Register and Unregister Callbacks been setup? -) - -Replies YES if both an HTEvent_setRegisterCallback and -HTEvent_setUnregisterCallback have been called with non NULL callbacks. -*/ - -extern BOOL HTEvent_isCallbacksRegistered(void); - -/* -. - Create and Delete Events -. -*/ - -extern HTEvent * HTEvent_new (HTEventCallback * cbf, void * context, - HTPriority pritority, int timeoutInMillis); -extern BOOL HTEvent_delete (HTEvent * event); - -/* -( - Event Timeouts, Priorities, Callbacks, and Contexts -) - -Normally, these are set when creating the event. -*/ - -extern BOOL HTEvent_setParam(HTEvent * event, void * param); -extern BOOL HTEvent_setPriority(HTEvent * event, HTPriority priority); -extern BOOL HTEvent_setTimeout(HTEvent * event, int timeoutInMillis); -extern BOOL HTEvent_setCallback(HTEvent * event, HTEventCallback * cbf); - -/* -. - The Raw Event Type -. - -Don't use this directly, use the methods above instead. -*/ - -struct _HTEvent { - HTPriority priority; /* Priority of this request (event) */ - int millis; /* Timeout in ms for this event */ -#ifdef IN_EVENT - HTTimer * timer; -#endif - HTEventCallback * cbf; /* Protocol state machine */ - void * param; /* HTEvent_register parameter */ - HTRequest * request; -}; - -/* - -You can register the event manager provided together with libwww by using -the HTEventInit() in the HTInit module -*/ - -#endif /* HTEVENT_H */ - -/* - - - - @(#) $Id: HTEvent.h,v 1.1 1999/10/09 19:05:39 egnor Exp $ - -*/ diff -urN gale-0.91a/liboop/foreign/HTMemory.h gale-0.91b/liboop/foreign/HTMemory.h --- gale-0.91a/liboop/foreign/HTMemory.h Sat Oct 9 12:37:59 1999 +++ gale-0.91b/liboop/foreign/HTMemory.h Wed Dec 31 16:00:00 1969 @@ -1,169 +0,0 @@ -/* - - - W3C Sample Code Library libwww Dynamic Memory Handlers - - -! - Dynamic Memory Handlers -! -*/ - -/* -** (c) COPYRIGHT MIT 1995. -** Please first read the full copyright statement in the file COPYRIGH. -*/ - -/* - -This module defines any memory handler to be used by libwww for allocating -and de-allocating dynamic memory. As dynamic memory may be a scarce resource, -it is required that an application can handle memory exhaustion gracefully. -This module provides an interface that covers the following situations: - - - o - Handling of allocation, reallocation and de-allocation - of dynamic memory - o - Recovering from temporary lack of available memory - o - Panic handling in case a new allocation fails - - -Note: The Library core provides a default set of memory handlers -for allocating and de-allocating dynamic memory. In order to maintain a -reasonable performance, they are not registered dynamically but assigned -using C style macros. Hence, it is not possible to swap memory handler -at run time but this was considered to be a reasonable trade-off. - -This module is implemented by HTMemory.c, and it -is a part of the W3C Sample Code -Library. -*/ - -#ifndef HTMEMORY_H -#define HTMEMORY_H - -#include "HTUtils.h" - -/* -. - Allocation, Reallocation and De-allocation -. - -The Library provides a default set of methods for handling dynamic memory. -They are very basic and essentially identical to the C style -malloc, calloc, realloc, and -free: -*/ -extern void* HTMemory_malloc(size_t size); -extern void* HTMemory_calloc(size_t count, size_t size); -extern void* HTMemory_realloc(void * ptr, size_t size); -extern void HTMemory_free(void* ptr); - -/* -( - Memory Macros -) - -The methods above are not referred directly in the Library. Instead we use -a set of C style macros. If you don't wany any memory management beyond normal -malloc and alloc then you can just use that instead of the HTMemory_* function. -You can of course also provide your own methods as well. -*/ - -#define HT_MALLOC(size) HTMemory_malloc((size)) -#define HT_CALLOC(count, size) HTMemory_calloc((count), (size)) -#define HT_REALLOC(ptr, size) HTMemory_realloc((ptr), (size)) -#define HT_FREE(pointer) {HTMemory_free((pointer));((pointer))=NULL;} - -/* -. - Memory Freer Functions -. - -The dynamic memory freer functions are typically functions that are capable -of freeing large chunks of memory. In case a new allocation fails, the allocation -method looks for any registered freer functions to call. There can be multiple -freer functions and after each call, the allocation method tries again to -allocate the desired amount of dynamic memory. The freer functions are called -in reverse order meaning that the last one registered gets -called first. That way, it is easy to add temporary freer functions -which then are guaranteed to be called first if a methods fails. -( - Add a Freer Function -) - -You can add a freer function by using the following method. The Library may -itself register a set of free functions during initialization. If the application -does not register any freer functions then the Library looks how it can free -internal memory. The freer function is passed the total number of -bytes requested by the allocation. -*/ -typedef void HTMemoryCallback(size_t size); - -extern BOOL HTMemoryCall_add (HTMemoryCallback * cbf); - -/* -( - Delete a Freer Function -) - -Freer functions can be deleted at any time in which case they are not called -anymore. -*/ - -extern BOOL HTMemoryCall_delete (HTMemoryCallback * cbf); -extern BOOL HTMemoryCall_deleteAll (void); - -/* -. - Panic Handling -. - -If the freer functions are not capable of de-allocation enough memory then -the application must have an organized way of closing down. This is done -using the panic handler. In the libwww, each allocation is tested and -HT_OUTOFMEM is called if a NULL was returned. -HT_OUTOFMEM is a macro which by default calls -HTMemory_outofmem() but of course can point to any method. The -default handler calls an exit function defined by the application in a call -to HTMemory_setExit(). If the application has not defined -an exit function, HTMemory_outofmem() prints an error message -and calls exit(1). -*/ - -typedef void HTMemory_exitCallback(char *name, char *file, unsigned long line); - -extern void HTMemory_setExit(HTMemory_exitCallback * pExit); -extern HTMemory_exitCallback * HTMemory_exit(void); - -/* -( - Call the Exit Handler -) - -If an allocation fails then this function is called. If the application has -registered its own panic handler then this is called directly from this function. -Otherwise, the default behavior is to write a small message to stderr and -then exit. -*/ - -#define outofmem(file, name) HT_OUTOFMEM(name) -#define HT_OUTOFMEM(name) HTMemory_outofmem((name), __FILE__, __LINE__) - -extern void HTMemory_outofmem(char * name, char * file, unsigned long line); - -/* -*/ - -#endif /* HTMEMORY_H */ - -/* - - - - @(#) $Id: HTMemory.h,v 1.1 1999/10/09 19:37:59 egnor Exp $ - -*/ diff -urN gale-0.91a/liboop/foreign/HTReq.h gale-0.91b/liboop/foreign/HTReq.h --- gale-0.91a/liboop/foreign/HTReq.h Sat Sep 4 14:37:50 1999 +++ gale-0.91b/liboop/foreign/HTReq.h Wed Dec 31 16:00:00 1969 @@ -1,8 +0,0 @@ -/* HTReq.h spoof -- exists only to make HTEvent.h work */ - -#ifndef HTREQ_H_SPOOF -#define HTREQ_H_SPOOF - -typedef struct HTRequest_spoof HTRequest; - -#endif diff -urN gale-0.91a/liboop/foreign/HTUtils.h gale-0.91b/liboop/foreign/HTUtils.h --- gale-0.91a/liboop/foreign/HTUtils.h Sat Oct 9 12:37:59 1999 +++ gale-0.91b/liboop/foreign/HTUtils.h Wed Dec 31 16:00:00 1969 @@ -1,409 +0,0 @@ -/* - - W3C Sample Code Library libwww Debug Information and General Purpose - Macros - - -! - Debug Information and General Purpose Macros -! -*/ - -/* -** (c) COPYRIGHT MIT 1995. -** Please first read the full copyright statement in the file COPYRIGH. -*/ - -/* - -This module is a part of the W3C Sample -Code Library. See also the system dependent file -sysdep module for system specific information. -*/ - -#ifndef HTUTILS_H -#define HTUTILS_H - -/* -. - Destination for User Print Messages -. - -You can send print messages to the user to various destinations -depending on the type of your application. By default, on Unix the -messages are sent to stdout using -fprintf. If we are on MSWindows and have a windows -applications then register a HTPrintCallback -function. This is done with HTPrint_setCallback. It tells -HTPrint to call a HTPrintCallback. If -HTDEBUG -is not defined then don't do any of the above. -*/ - -typedef int HTPrintCallback(const char * fmt, va_list pArgs); -extern void HTPrint_setCallback(HTPrintCallback * pCall); -extern HTPrintCallback * HTPrint_getCallback(void); - -extern int HTPrint(const char * fmt, ...); - -/* -. - Debug Message Control -. - -This is the global flag for setting the WWWTRACE options. -The verbose mode is no longer a simple boolean but a bit field so that it -is possible to see parts of the output messages. -*/ - -#if defined(NODEBUG) || defined(NDEBUG) || defined(_NDEBUG) -#undef HTDEBUG -#else -#ifndef HTDEBUG -#define HTDEBUG 1 -#endif /* HTDEBUG */ -#endif - -/* -( - C Preprocessor defines -) - -Make sure that the following macros are defined -*/ - -#ifndef __FILE__ -#define __FILE__ "" -#endif - -#ifndef __LINE__ -#define __LINE__ 0L -#endif - -/* -( - Definition of the Global Trace Flag -) - -The global trace flag variable is available everywhere. -*/ - -#ifdef HTDEBUG -#ifdef WWW_WIN_DLL -extern int * WWW_TraceFlag; /* In DLLs, we need the indirection */ -#define WWWTRACE (*WWW_TraceFlag) -#else -extern unsigned int WWW_TraceFlag; /* Global flag for all W3 trace */ -#define WWWTRACE (WWW_TraceFlag) -#endif /* WWW_WIN_DLL */ -#else -#define WWWTRACE 0 -#endif /* HTDEBUG */ - -/* -( - Select which Trace Messages to show -) - -Libwww has a huge set of trace messages and it is therefor a good idea to -be able to select which ones to see for any particular trace. An easy way -to set this is using the funtion -HTSetTraceMessageMask. The WWWTRACE -define outputs messages if verbose mode is active according to the following -rules: -*/ - -typedef enum _HTTraceFlags { - SHOW_UTIL_TRACE = 0x1, - SHOW_APP_TRACE = 0x2, - SHOW_CACHE_TRACE = 0x4, - SHOW_SGML_TRACE = 0x8, - SHOW_BIND_TRACE = 0x10, - SHOW_THREAD_TRACE = 0x20, - SHOW_STREAM_TRACE = 0x40, - SHOW_PROTOCOL_TRACE = 0x80, - SHOW_MEM_TRACE = 0x100, - SHOW_URI_TRACE = 0x200, - SHOW_AUTH_TRACE = 0x400, - SHOW_ANCHOR_TRACE = 0x800, - SHOW_PICS_TRACE = 0x1000, - SHOW_CORE_TRACE = 0x2000, - SHOW_MUX_TRACE = 0x4000, - SHOW_SQL_TRACE = 0x8000, - SHOW_XML_TRACE = 0x10000, - SHOW_ALL_TRACE = 0xFFFFFFFF -} HTTraceFlags; - -/* - -The flags are made so that they can serve as a group flag for correlated -trace messages, e.g. showing messages for SGML and HTML at the same time. -*/ - -#define UTIL_TRACE (WWWTRACE & SHOW_UTIL_TRACE) -#define APP_TRACE (WWWTRACE & SHOW_APP_TRACE) -#define CACHE_TRACE (WWWTRACE & SHOW_CACHE_TRACE) -#define SGML_TRACE (WWWTRACE & SHOW_SGML_TRACE) -#define BIND_TRACE (WWWTRACE & SHOW_BIND_TRACE) -#define THD_TRACE (WWWTRACE & SHOW_THREAD_TRACE) -#define STREAM_TRACE (WWWTRACE & SHOW_STREAM_TRACE) -#define PROT_TRACE (WWWTRACE & SHOW_PROTOCOL_TRACE) -#define MEM_TRACE (WWWTRACE & SHOW_MEM_TRACE) -#define URI_TRACE (WWWTRACE & SHOW_URI_TRACE) -#define AUTH_TRACE (WWWTRACE & SHOW_AUTH_TRACE) -#define ANCH_TRACE (WWWTRACE & SHOW_ANCHOR_TRACE) -#define PICS_TRACE (WWWTRACE & SHOW_PICS_TRACE) -#define CORE_TRACE (WWWTRACE & SHOW_CORE_TRACE) -#define MUX_TRACE (WWWTRACE & SHOW_MUX_TRACE) -#define SQL_TRACE (WWWTRACE & SHOW_SQL_TRACE) -#define XML_TRACE (WWWTRACE & SHOW_XML_TRACE) -#define ALL_TRACE (WWWTRACE & SHOW_ALL_TRACE) - -/* -( - Destination for Trace Messages -) - -You can send trace messages to various destinations depending on the type -of your application. By default, on Unix the messages are sent to -stderr using fprintf. If we are on MSWindows and -have a windows applications then register a HTTraceCallback -function. This is done with HTTrace_setCallback. It tells -HTTrace to call a HTTraceCallback. If -HTDEBUG is not defined then don't do any of the above. -*/ - -typedef int HTTraceCallback(const char * fmt, va_list pArgs); -extern void HTTrace_setCallback(HTTraceCallback * pCall); -extern HTTraceCallback * HTTrace_getCallback(void); - -/* - -The HTTRACE macro uses "_" as parameter separater -instead of ",". This enables us to use a single macro instead -of a macro for each number of arguments which we consider a more elegant -and flexible solution. The implication is, however, that we can't have variables -that start or end with an "_" if they are to be used in a trace -message. -*/ - -#ifdef HTDEBUG -#undef _ -#define _ , -#define HTTRACE(TYPE, FMT) \ - do { if (TYPE) HTTrace(FMT); } while (0); -extern int HTTrace(const char * fmt, ...); -#else -#define HTTRACE(TYPE, FMT) /* empty */ -#endif /* HTDEBUG */ - -/* -( - Data Trace Logging -) - -A similar mechanism exists for logging data, except that is adds a data and -length argument to the trace call. Again, you can register your own callbacks -if need be. -*/ - -typedef int HTTraceDataCallback(char * data, size_t len, char * fmt, va_list pArgs); -extern void HTTraceData_setCallback(HTTraceDataCallback * pCall); -extern HTTraceDataCallback * HTTraceData_getCallback(void); - -/* - -Again we use the same macro expansion mechanism as for HTTrace -*/ - -#ifdef HTDEBUG -#define HTTRACEDATA(DATA, LEN, FMT) HTTraceData((DATA), (LEN), FMT) -extern int HTTraceData(char * data, size_t len, char * fmt, ...); -#else -#define HTTRACEDATA(DATA, LEN, FMT) /* empty */ -#endif /* HTDEBUG */ - -/* -( - Debug Breaks -) - -Call this function and the program halts. We use the same macro expansion -mechanism as for HTTrace -*/ - -extern void HTDebugBreak(char * file, unsigned long line, const char * fmt, ...); - -#ifdef HTDEBUG -#define HTDEBUGBREAK(FMT) HTDebugBreak(__FILE__, __LINE__, FMT) -#else -#define HTDEBUGBREAK(FMT) /* empty */ -#endif /* HTDEBUG */ - -/* -. - Macros for Function Declarations -. - -These function prefixes are used by scripts and other tools and helps figuring -out which functions are exported and which are not. See also the -libwww style guide. -*/ - -#define PUBLIC /* Accessible outside this module */ -#define PRIVATE static /* Accessible only within this module */ - -/* -. - Often used Interger Macros -. -( - Min and Max functions -) -*/ - -#ifndef HTMIN -#define HTMIN(a,b) ((a) <= (b) ? (a) : (b)) -#define HTMAX(a,b) ((a) >= (b) ? (a) : (b)) -#endif - -/* -( - Double abs function -) -*/ - -#ifndef HTDABS -#define HTDABS(a) ((a) < 0.0 ? (-(a)) : (a)) -#endif - -/* - - -. - Return Codes for Protocol Modules and Streams -. - -Theese are the codes returned from the protocol modules, and the stream modules. -Success are (>=0) and failure are (<0) -*/ - -#define HT_OK 0 /* Generic success */ -#define HT_ALL 1 /* Used by Net Manager */ - -#define HT_CONTINUE 100 /* Continue an operation */ -#define HT_UPGRADE 101 /* Switching protocols */ - -#define HT_LOADED 200 /* Everything's OK */ -#define HT_CREATED 201 /* New object is created */ -#define HT_ACCEPTED 202 /* Accepted */ -#define HT_NO_DATA 204 /* OK but no data was loaded */ -#define HT_RESET_CONTENT 205 /* Reset content */ -#define HT_PARTIAL_CONTENT 206 /* Partial Content */ - -#define HT_MULTIPLE_CHOICES 300 /* Multiple choices */ -#define HT_PERM_REDIRECT 301 /* Permanent redirection */ -#define HT_FOUND 302 /* Found */ -#define HT_SEE_OTHER 303 /* See other */ -#define HT_NOT_MODIFIED 304 /* Not Modified */ -#define HT_USE_PROXY 305 /* Use Proxy */ -#define HT_PROXY_REDIRECT 306 /* Proxy Redirect */ -#define HT_TEMP_REDIRECT 307 /* Temporary redirect */ - -#define HT_IGNORE 900 /* Ignore this in the Net manager */ -#define HT_CLOSED 901 /* The socket was closed */ -#define HT_PENDING 902 /* Wait for connection */ -#define HT_RELOAD 903 /* If we must reload the document */ - -#define HT_ERROR -1 /* Generic failure */ - -#define HT_NO_ACCESS -401 /* Unauthorized */ -#define HT_FORBIDDEN -403 /* Access forbidden */ -#define HT_NOT_FOUND -404 /* Not found */ -#define HT_NOT_ACCEPTABLE -406 /* Not Acceptable */ -#define HT_NO_PROXY_ACCESS -407 /* Proxy Authentication Failed */ -#define HT_CONFLICT -409 /* Conflict */ -#define HT_LENGTH_REQUIRED -411 /* Length required */ -#define HT_PRECONDITION_FAILED -412 /* Precondition failed */ -#define HT_TOO_BIG -413 /* Request entity too large */ -#define HT_URI_TOO_BIG -414 /* Request-URI too long */ -#define HT_UNSUPPORTED -415 /* Unsupported */ -#define HT_BAD_RANGE -416 /* Request Range not satisfiable */ -#define HT_EXPECTATION_FAILED -417 /* Expectation Failed */ -#define HT_REAUTH -418 /* Reauthentication required */ -#define HT_PROXY_REAUTH -419 /* Proxy Reauthentication required */ - -#define HT_RETRY -503 /* If service isn't available */ -#define HT_BAD_VERSION -505 /* Bad protocol version */ - -#define HT_INTERNAL -900 /* Weird -- should never happen. */ -#define HT_WOULD_BLOCK -901 /* If we are in a select */ -#define HT_INTERRUPTED -902 /* Note the negative value! */ -#define HT_PAUSE -903 /* If we want to pause a stream */ -#define HT_RECOVER_PIPE -904 /* Recover pipe line */ -#define HT_TIMEOUT -905 /* Connection timeout */ -#define HT_NO_HOST -906 /* Can't locate host */ - -/* -. - Upper- and Lowercase macros -. - -The problem here is that toupper(x) is not defined officially unless isupper(x) -is. These macros are CERTAINLY needed on #if defined(pyr) || define(mips) -or BDSI platforms. For safefy, we make them mandatory. -*/ - -#ifndef TOLOWER -#define TOLOWER(c) tolower((int) (c)) -#define TOUPPER(c) toupper((int) (c)) -#endif - -/* -. - Max and Min values for Integers and Floating Point -. -*/ - -#ifdef FLT_EPSILON /* The ANSI C way define */ -#define HT_EPSILON FLT_EPSILON -#else -#define HT_EPSILON 0.00000001 -#endif - -/* -. - The local equivalents of CR and LF -. - -We can check for these after net ascii text has been converted to the local -representation. Similarly, we include them in strings to be sent as net ascii -after translation. -*/ - -#define LF FROMASCII('\012') /* ASCII line feed LOCAL EQUIVALENT */ -#define CR FROMASCII('\015') /* Will be converted to ^M for transmission */ - -/* -. - Library Dynamic Memory Magement -. - -The Library has it's own dynamic memory API which is declared in -memory management module. -*/ - -#include "HTMemory.h" - -/* -*/ - -#endif /* HT_UTILS.h */ - -/* - - - - @(#) $Id: HTUtils.h,v 1.1 1999/10/09 19:37:59 egnor Exp $ - -*/ diff -urN gale-0.91a/liboop/foreign/README gale-0.91b/liboop/foreign/README --- gale-0.91a/liboop/foreign/README Sun Sep 5 15:07:49 1999 +++ gale-0.91b/liboop/foreign/README Wed Dec 31 16:00:00 1969 @@ -1,56 +0,0 @@ -This directory contains public header files for those foreign components for -which liboop includes "adapters". By including them here, we can build the -adapters without requiring the presence of the foreign components in question. - -An adapter will still not function without the code it adapts, of course, but -at least this way we eliminate pesky build ordering issues. - -Many of these have specific licensing terms and agreements: - -adns.h - - adns is Ian Jackson's asynchronous DNS access package. - - - While adns is licensed under the GPL, Ian has graciously consented to the - distribution of its public header file (adns.h) under the LGPL: - - I hereby relicence adns.h - and only adns.h - to you (and all third - parties) under the GNU Library General Public Licence. This - statement applies to all versions of adns.h I have released so far, - and to any files adns.h with similar contents and function I might - release during the remainder of this calendar year (1999). - -HTEvent.h -HTMemory.h -HTUtils.h - - These header files are extracted from libwww. - Libwww is a general-purpose Web API written in C. - - - Libwww code is subject to this copyright: - - Copyright © 1995-1998 World Wide Web Consortium, (Massachusetts Institute - of Technology, Institut National de Recherche en Informatique et en - Automatique, Keio University). All Rights Reserved. This program is - distributed under the W3C's Software Intellectual Property License. This - program is distributed in the hope that it will be useful, but WITHOUT ANY - WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - FOR A PARTICULAR PURPOSE. - - See W3C License http://www.w3.org/Consortium/Legal/ for more details. - - Copyright © 1995 CERN. "This product includes computer software created and - made available by CERN. This acknowledgment shall be mentioned in full in - any product which includes the CERN computer software included herein or - parts thereof." - -glib.h - - This is the public header file for GLIB, a "library of useful routines - for C programming" used heavily by the popular GTK+ widget set. - - - GLIB is licensed under the GNU Library GPL, version 2. The copyright - is held by Peter Mattis, Spencer Kimball and Josh MacDonald. diff -urN gale-0.91a/liboop/foreign/adns.h gale-0.91b/liboop/foreign/adns.h --- gale-0.91a/liboop/foreign/adns.h Thu Oct 28 23:59:19 1999 +++ gale-0.91b/liboop/foreign/adns.h Wed Dec 31 16:00:00 1969 @@ -1,815 +0,0 @@ -/* - * adns.h - * - adns user-visible API (single-threaded, without any locking) - */ -/* - * - * This file is - * Copyright (C) 1997-1999 Ian Jackson - * - * It is part of adns, which is - * Copyright (C) 1997-1999 Ian Jackson - * Copyright (C) 1999 Tony Finch - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * - * For the benefit of certain LGPL'd `omnibus' software which provides - * a uniform interface to various things including adns, I make the - * following additional licence. I do this because the GPL would - * otherwise force either the omnibus software to be GPL'd or for the - * adns-using part to be distributed separately. - * - * So, you may also redistribute and/or modify adns.h (but only the - * public header file adns.h and not any other part of adns) under the - * terms of the GNU Library General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at - * your option) any later version. - * - * Note that adns itself is GPL'd. Authors of adns-using applications - * with GPL-incompatible licences, and people who distribute adns with - * applications where the whole distribution is not GPL'd, are still - * likely to be in violation of the GPL. Anyone who wants to do this - * should contact Ian Jackson. Please note that to avoid encouraging - * people to infringe the GPL as it applies the body of adns, I think - * that if you take advantage of the special exception to redistribute - * just adns.h under the LGPL, you should retain this paragraph in its - * place in the appropriate copyright statements. - * - * - * You should have received a copy of the GNU General Public License, - * or the GNU Library General Public License, as appropriate, along - * with this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * - * $Id: adns.h,v 1.3 1999/10/29 06:59:19 egnor Exp $ - */ - -#ifndef ADNS_H_INCLUDED -#define ADNS_H_INCLUDED -#ifdef __cplusplus -extern "C" { /* I really dislike this - iwj. */ -#endif - -#include - -#include -#include -#include -#include -#include - -/* All struct in_addr anywhere in adns are in NETWORK byte order. */ - -typedef struct adns__state *adns_state; -typedef struct adns__query *adns_query; - -typedef enum { - adns_if_noenv= 0x0001, /* do not look at environment */ - adns_if_noerrprint= 0x0002, /* never print output to stderr (_debug overrides) */ - adns_if_noserverwarn= 0x0004, /* do not warn to stderr about duff nameservers etc */ - adns_if_debug= 0x0008, /* enable all output to stderr plus debug msgs */ - adns_if_noautosys= 0x0010, /* do not make syscalls at every opportunity */ - adns_if_eintr= 0x0020, /* allow _wait and _synchronous to return EINTR */ - adns_if_nosigpipe= 0x0040, /* applic has SIGPIPE set to SIG_IGN, do not protect */ - adns_if_checkc_entex= 0x0100, /* do consistency checks on entry/exit to adns funcs */ - adns_if_checkc_freq= 0x0300 /* do consistency checks very frequently (slow!) */ -} adns_initflags; - -typedef enum { - adns_qf_search= 0x00000001, /* use the searchlist */ - adns_qf_usevc= 0x00000002, /* use a virtual circuit (TCP connection) */ - adns_qf_owner= 0x00000004, /* fill in the owner field in the answer */ - adns_qf_quoteok_query= 0x00000010, /* allow quote-requiring chars in query domain */ - adns_qf_quoteok_cname= 0x00000000, /* allow ... in CNAME we go via - now default */ - adns_qf_quoteok_anshost= 0x00000040, /* allow ... in things supposed to be hostnames */ - adns_qf_quotefail_cname= 0x00000080, /* refuse if quote-req chars in CNAME we go via */ - adns_qf_cname_loose= 0x00000100, /* allow refs to CNAMEs - without, get _s_cname */ - adns_qf_cname_forbid= 0x00000200, /* don't follow CNAMEs, instead give _s_cname */ - adns__qf_internalmask= 0x0ff00000 -} adns_queryflags; - -typedef enum { - adns__rrt_typemask= 0x0ffff, - adns__qtf_deref= 0x10000, /* dereference domains and perhaps produce extra data */ - adns__qtf_mail822= 0x20000, /* make mailboxes be in RFC822 rcpt field format */ - - adns_r_none= 0, - - adns_r_a= 1, - - adns_r_ns_raw= 2, - adns_r_ns= adns_r_ns_raw|adns__qtf_deref, - - adns_r_cname= 5, - - adns_r_soa_raw= 6, - adns_r_soa= adns_r_soa_raw|adns__qtf_mail822, - - adns_r_ptr_raw= 12, - adns_r_ptr= adns_r_ptr_raw|adns__qtf_deref, - - adns_r_hinfo= 13, - - adns_r_mx_raw= 15, - adns_r_mx= adns_r_mx_raw|adns__qtf_deref, - - adns_r_txt= 16, - - adns_r_rp_raw= 17, - adns_r_rp= adns_r_rp_raw|adns__qtf_mail822, - - adns_r_addr= adns_r_a|adns__qtf_deref - -} adns_rrtype; - -/* - * In queries without qf_quoteok_*, all domains must have standard - * legal syntax, or you get adns_s_querydomainvalid (if the query - * domain contains bad characters) or adns_s_answerdomaininvalid (if - * the answer contains bad characters). - * - * In queries _with_ qf_quoteok_*, domains in the query or response - * may contain any characters, quoted according to RFC1035 5.1. On - * input to adns, the char* is a pointer to the interior of a " - * delimited string, except that " may appear in it, and on output, - * the char* is a pointer to a string which would be legal either - * inside or outside " delimiters, and any characters not usually - * legal in domain names will be quoted as \X (if the character is - * 33-126 except \ and ") or \DDD. - * - * If the query goes via a CNAME then the canonical name (ie, the - * thing that the CNAME record refers to) is usually allowed to - * contain any characters, which will be quoted as above. With - * adns_qf_quotefail_cname you get adns_s_answerdomaininvalid when - * this happens. (This is a change from version 0.4 and earlier, in - * which failing the query was the default, and you had to say - * adns_qf_quoteok_cname to avoid this; that flag is now deprecated.) - * - * In version 0.4 and earlier, asking for _raw records containing - * mailboxes without specifying _qf_quoteok_anshost was silly. This - * is no longer the case. In this version only parts of responses - * that are actually supposed to be hostnames will be refused by - * default if quote-requiring characters are found. - */ - -/* - * If you ask for an RR which contains domains which are actually - * encoded mailboxes, and don't ask for the _raw version, then adns - * returns the mailbox formatted suitably for an RFC822 recipient - * header field. The particular format used is that if the mailbox - * requires quoting according to the rules in RFC822 then the - * local-part is quoted in double quotes, which end at the next - * unescaped double quote. (\ is the escape char, and is doubled, and - * is used to escape only \ and ".) Otherwise the local-part is - * presented as-is. In any case this is followed by an @ and the - * domain. The domain will not contain any characters not legal in - * hostnames. adns will protect the application from local parts - * containing control characters - these appear to be legal according - * to RFC822 but are clearly a bad idea. - * - * If you ask for the domain with _raw then _no_ checking is done - * (even on the host part, regardless of adns_qf_quoteok_anshost), and - * you just get the domain name in master file format. - * - * If no mailbox is supplied the returned string will be `.' in either - * caswe. - */ - -typedef enum { - adns_s_ok, - - /* locally induced errors */ - adns_s_nomemory, - adns_s_unknownrrtype, - adns_s_systemfail, - - adns_s_max_localfail= 29, - - /* remotely induced errors, detected locally */ - adns_s_timeout, - adns_s_allservfail, - adns_s_norecurse, - adns_s_invalidresponse, - adns_s_unknownformat, - - adns_s_max_remotefail= 59, - - /* remotely induced errors, reported by remote server to us */ - adns_s_rcodeservfail, - adns_s_rcodeformaterror, - adns_s_rcodenotimplemented, - adns_s_rcoderefused, - adns_s_rcodeunknown, - - adns_s_max_tempfail= 99, - - /* remote configuration errors */ - adns_s_inconsistent, /* PTR gives domain whose A does not exist and match */ - adns_s_prohibitedcname, /* CNAME found where eg A expected (not if _qf_loosecname) */ - adns_s_answerdomaininvalid, - adns_s_answerdomaintoolong, - adns_s_invaliddata, - - adns_s_max_misconfig= 199, - - /* permanent problems with the query */ - adns_s_querydomainwrong, - adns_s_querydomaininvalid, - adns_s_querydomaintoolong, - - adns_s_max_misquery= 299, - - /* permanent errors */ - adns_s_nxdomain, - adns_s_nodata, - - adns_s_max_permfail= 499 - -} adns_status; - -typedef struct { - int len; - union { - struct sockaddr sa; - struct sockaddr_in inet; - } addr; -} adns_rr_addr; - -typedef struct { - char *host; - adns_status astatus; - int naddrs; /* temp fail => -1, perm fail => 0, s_ok => >0 */ - adns_rr_addr *addrs; -} adns_rr_hostaddr; - -typedef struct { - char *(array[2]); -} adns_rr_strpair; - -typedef struct { - int i; - adns_rr_hostaddr ha; -} adns_rr_inthostaddr; - -typedef struct { - /* Used both for mx_raw, in which case i is the preference and str the domain, - * and for txt, in which case each entry has i for the `text' length, - * and str for the data (which will have had an extra nul appended - * so that if it was plain text it is now a null-terminated string). - */ - int i; - char *str; -} adns_rr_intstr; - -typedef struct { - adns_rr_intstr array[2]; -} adns_rr_intstrpair; - -typedef struct { - char *mname, *rname; - unsigned long serial, refresh, retry, expire, minimum; -} adns_rr_soa; - -typedef struct { - adns_status status; - char *cname; /* always NULL if query was for CNAME records */ - char *owner; /* only set if requested in query flags */ - adns_rrtype type; /* guaranteed to be same as in query */ - time_t expires; /* expiry time, defined only if _s_ok, nxdomain or nodata. NOT TTL! */ - int nrrs, rrsz; /* nrrs is 0 if an error occurs */ - union { - void *untyped; - unsigned char *bytes; - char *(*str); /* ns_raw, cname, ptr, ptr_raw */ - adns_rr_intstr *(*manyistr); /* txt (list of strings ends with i=-1, str=0) */ - adns_rr_addr *addr; /* addr */ - struct in_addr *inaddr; /* a */ - adns_rr_hostaddr *hostaddr; /* ns */ - adns_rr_intstrpair *intstrpair; /* hinfo */ - adns_rr_strpair *strpair; /* rp, rp_raw */ - adns_rr_inthostaddr *inthostaddr; /* mx */ - adns_rr_intstr *intstr; /* mx_raw */ - adns_rr_soa *soa; /* soa, soa_raw */ - } rrs; -} adns_answer; - -/* Memory management: - * adns_state and adns_query are actually pointers to malloc'd state; - * On submission questions are copied, including the owner domain; - * Answers are malloc'd as a single piece of memory; pointers in the - * answer struct point into further memory in the answer. - * query_io: - * Must always be non-null pointer; - * If *query_io is 0 to start with then any query may be returned; - * If *query_io is !0 adns_query then only that query may be returned. - * If the call is successful, *query_io, *answer_r, and *context_r - * will all be set. - * Errors: - * Return values are 0 or an errno value. - * - * For _init, _init_strcfg, _submit and _synchronous, system errors - * (eg, failure to create sockets, malloc failure, etc.) return errno - * values. - * - * For _wait and _check failures are reported in the answer - * structure, and only 0, ESRCH or (for _check) EAGAIN is - * returned: if no (appropriate) requests are done adns_check returns - * EAGAIN; if no (appropriate) requests are outstanding both - * adns_query and adns_wait return ESRCH. - * - * Additionally, _wait can return EINTR if you set adns_if_eintr. - * - * All other errors (nameserver failure, timed out connections, &c) - * are returned in the status field of the answer. After a - * successful _wait or _check, if status is nonzero then nrrs will be - * 0, otherwise it will be >0. type will always be the type - * requested. - */ - -int adns_init(adns_state *newstate_r, int flags /*adns_initflags*/, - FILE *diagfile /*0=>stderr*/); - -int adns_init_strcfg(adns_state *newstate_r, int flags /*adns_initflags*/, - FILE *diagfile /*0=>discard*/, const char *configtext); - -/* Configuration: - * adns_init reads /etc/resolv.conf, which is expected to be (broadly - * speaking) in the format expected by libresolv. adns_init_strcfg - * is instead passed a string which is interpreted as if it were the - * contents of resolv.conf. In general, configuration which is set - * later overrides any that is set earlier. - * - * Standard directives understood in resolv.conf: - * - * nameserver
- * Must be followed by the IP address of a nameserver. Several - * nameservers may be specified, and they will be tried in the order - * found. There is a compiled in limit, currently 5, on the number - * of nameservers. (libresolv supports only 3 nameservers.) - * - * search ... - * Specifies the search list for queries which specify - * adns_qf_search. This is a list of domains to append to the query - * domain. The query domain will be tried as-is either before all - * of these or after them, depending on the ndots option setting - * (see below). - * - * domain - * This is present only for backward compatibility with obsolete - * versions of libresolv. It should not be used, and is interpreted - * by adns as if it were `search' - note that this is subtly - * different to libresolv's interpretation of this directive. - * - * sortlist / ... - * Should be followed by a sequence of IP-address and netmask pairs, - * separated by spaces. They may be specified as - * eg. 172.30.206.0/24 or 172.30.206.0/255.255.255.0. Currently up - * to 15 pairs may be specified (but note that libresolv only - * supports up to 10). - * - * options - * Should followed by one or more options, separated by spaces. - * Each option consists of an option name, followed by optionally - * a colon and a value. Options are listed below. - * - * Non-standard directives understood in resolv.conf: - * - * clearnameservers - * Clears the list of nameservers, so that further nameserver lines - * start again from the beginning. - * - * include - * The specified file will be read. - * - * Additionally, adns will ignore lines in resolv.conf which start with a #. - * - * Standard options understood: - * - * debug - * Enables debugging output from the resolver, which will be written - * to stderr. - * - * ndots: - * Affects whether queries with adns_qf_search will be tried first - * without adding domains from the searchlist, or whether the bare - * query domain will be tried last. Queries which contain at least - * dots will be tried bare first. The default is 1. - * - * Non-standard options understood: - * - * adns_checkc:none - * adns_checkc:entex - * adns_checkc:freq - * Changes the consistency checking frequency; this overrides the - * setting of adns_if_check_entex, adns_if_check_freq, or neither, - * in the flags passed to adns_init. - * - * There are a number of environment variables which can modify the - * behaviour of adns. They take effect only if adns_init is used, and - * the caller of adns_init can disable them using adns_if_noenv. In - * each case there is both a FOO and an ADNS_FOO; the latter is - * interpreted later so that it can override the former. Unless - * otherwise stated, environment variables are interpreted after - * resolv.conf is read, in the order they are listed here. - * - * RES_CONF, ADNS_RES_CONF - * A filename, whose contets are in the format of resolv.conf. - * - * RES_CONF_TEXT, ADNS_RES_CONF_TEXT - * A string in the format of resolv.conf. - * - * RES_OPTIONS, ADNS_RES_OPTIONS - * These are parsed as if they appeared in the `options' line of a - * resolv.conf. In addition to being parsed at this point in the - * sequence, they are also parsed at the very beginning before - * resolv.conf or any other environment variables are read, so that - * any debug option can affect the processing of the configuration. - * - * LOCALDOMAIN, ADNS_LOCALDOMAIN - * These are interpreted as if their contents appeared in a `search' - * line in resolv.conf. - */ - -int adns_synchronous(adns_state ads, - const char *owner, - adns_rrtype type, - int flags /*adns_queryflags*/, - adns_answer **answer_r); - -/* NB: if you set adns_if_noautosys then _submit and _check do not - * make any system calls; you must use some of the asynch-io event - * processing functions to actually get things to happen. - */ - -int adns_submit(adns_state ads, - const char *owner, - adns_rrtype type, - int flags /*adns_queryflags*/, - void *context, - adns_query *query_r); - -/* The owner should be quoted in master file format. */ - -int adns_check(adns_state ads, - adns_query *query_io, - adns_answer **answer_r, - void **context_r); - -int adns_wait(adns_state ads, - adns_query *query_io, - adns_answer **answer_r, - void **context_r); - -/* same as adns_wait but uses poll(2) internally */ -int adns_wait_poll(adns_state ads, - adns_query *query_io, - adns_answer **answer_r, - void **context_r); - -void adns_cancel(adns_query query); - -/* The adns_query you get back from _submit is valid (ie, can be - * legitimately passed into adns functions) until it is returned by - * adns_check or adns_wait, or passed to adns_cancel. After that it - * must not be used. You can rely on it not being reused until the - * first adns_submit or _transact call using the same adns_state after - * it became invalid, so you may compare it for equality with other - * query handles until you next call _query or _transact. - * - * _submit and _synchronous return ENOSYS if they don't understand the - * query type. - */ - -int adns_submit_reverse(adns_state ads, - const struct sockaddr *addr, - adns_rrtype type, - int flags /*adns_queryflags*/, - void *context, - adns_query *query_r); -/* type must be _r_ptr or _r_ptr_raw. _qf_search is ignored. - * addr->sa_family must be AF_INET or you get ENOSYS. - */ - -void adns_finish(adns_state ads); -/* You may call this even if you have queries outstanding; - * they will be cancelled. - */ - - -void adns_forallqueries_begin(adns_state ads); -adns_query adns_forallqueries_next(adns_state ads, void **context_r); -/* Iterator functions, which you can use to loop over the outstanding - * (submitted but not yet successfuly checked/waited) queries. - * - * You can only have one iteration going at once. You may call _begin - * at any time; after that, an iteration will be in progress. You may - * only call _next when an iteration is in progress - anything else - * may coredump. The iteration remains in progress until _next - * returns 0, indicating that all the queries have been walked over, - * or ANY other adns function is called with the same adns_state (or a - * query in the same adns_state). There is no need to explicitly - * finish an iteration. - * - * context_r may be 0. *context_r may not be set when _next returns 0. - */ - -void adns_checkconsistency(adns_state ads, adns_query qu); -/* Checks the consistency of adns's internal data structures. - * If any error is found, the program will abort(). - * You may pass 0 for qu; if you pass non-null then additional checks - * are done to make sure that qu is a valid query. - */ - -/* - * Example expected/legal calling sequence for submit/check/wait: - * adns_init - * adns_submit 1 - * adns_submit 2 - * adns_submit 3 - * adns_wait 1 - * adns_check 3 -> EAGAIN - * adns_wait 2 - * adns_wait 3 - * .... - * adns_finish - */ - -/* - * Entrypoints for generic asynch io: - * (these entrypoints are not very useful except in combination with * - * some of the other I/O model calls which can tell you which fds to - * be interested in): - * - * Note that any adns call may cause adns to open and close fds, so - * you must call beforeselect or beforepoll again just before - * blocking, or you may not have an up-to-date list of it's fds. - */ - -int adns_processany(adns_state ads); -/* Gives adns flow-of-control for a bit. This will never block, and - * can be used with any threading/asynch-io model. If some error - * occurred which might cause an event loop to spin then the errno - * value is returned. - */ - -int adns_processreadable(adns_state ads, int fd, const struct timeval *now); -int adns_processwriteable(adns_state ads, int fd, const struct timeval *now); -int adns_processexceptional(adns_state ads, int fd, const struct timeval *now); -/* Gives adns flow-of-control so that it can process incoming data - * from, or send outgoing data via, fd. Very like _processany. If it - * returns zero then fd will no longer be readable or writeable - * (unless of course more data has arrived since). adns will _only_ - * use that fd and only in the manner specified, regardless of whether - * adns_if_noautosys was specified. - * - * adns_processexceptional should be called when select(2) reports an - * exceptional condition, or poll(2) reports POLLPRI. - * - * It is fine to call _processreabable or _processwriteable when the - * fd is not ready, or with an fd that doesn't belong to adns; it will - * then just return 0. - * - * If some error occurred which might prevent an event loop to spin - * then the errno value is returned. - */ - -void adns_processtimeouts(adns_state ads, const struct timeval *now); -/* Gives adns flow-of-control so that it can process any timeouts - * which might have happened. Very like _processreadable/writeable. - * - * now may be 0; if it isn't, *now must be the current time, recently - * obtained from gettimeofday. - */ - -void adns_firsttimeout(adns_state ads, - struct timeval **tv_mod, struct timeval *tv_buf, - struct timeval now); -/* Asks adns when it would first like the opportunity to time - * something out. now must be the current time, from gettimeofday. - * - * If tv_mod points to 0 then tv_buf must be non-null, and - * _firsttimeout will fill in *tv_buf with the time until the first - * timeout, and make *tv_mod point to tv_buf. If adns doesn't have - * anything that might need timing out it will leave *tv_mod as 0. - * - * If *tv_mod is not 0 then tv_buf is not used. adns will update - * *tv_mod if it has any earlier timeout, and leave it alone if it - * doesn't. - * - * This call will not actually do any I/O, or change the fds that adns - * is using. It always succeeds and never blocks. - */ - -void adns_globalsystemfailure(adns_state ads); -/* If serious problem(s) happen which globally affect your ability to - * interact properly with adns, or adns's ability to function - * properly, you or adns can call this function. - * - * All currently outstanding queries will be made to fail with - * adns_s_systemfail, and adns will close any stream sockets it has - * open. - * - * This is used by adns, for example, if gettimeofday() fails. - * Without this the program's event loop might start to spin ! - * - * This call will never block. - */ - -/* - * Entrypoints for select-loop based asynch io: - */ - -void adns_beforeselect(adns_state ads, int *maxfd, fd_set *readfds, - fd_set *writefds, fd_set *exceptfds, - struct timeval **tv_mod, struct timeval *tv_buf, - const struct timeval *now); -/* Find out file descriptors adns is interested in, and when it would - * like the opportunity to time something out. If you do not plan to - * block then tv_mod may be 0. Otherwise, tv_mod and tv_buf are as - * for adns_firsttimeout. readfds, writefds, exceptfds and maxfd_io may - * not be 0. - * - * If *now is not 0 then this will never actually do any I/O, or - * change the fds that adns is using or the timeouts it wants. In any - * case it won't block. - */ - -void adns_afterselect(adns_state ads, int maxfd, const fd_set *readfds, - const fd_set *writefds, const fd_set *exceptfds, - const struct timeval *now); -/* Gives adns flow-of-control for a bit; intended for use after - * select. This is just a fancy way of calling adns_processreadable/ - * writeable/timeouts as appropriate, as if select had returned the - * data being passed. Always succeeds. - */ - -/* - * Example calling sequence: - * - * adns_init _noautosys - * loop { - * adns_beforeselect - * select - * adns_afterselect - * ... - * adns_submit / adns_check - * ... - * } - */ - -/* - * Entrypoints for poll-loop based asynch io: - */ - -struct pollfd; -/* In case your system doesn't have it or you forgot to include - * , to stop the following declarations from causing - * problems. If your system doesn't have poll then the following - * entrypoints will not be defined in libadns. Sorry ! - */ - -int adns_beforepoll(adns_state ads, struct pollfd *fds, int *nfds_io, int *timeout_io, - const struct timeval *now); -/* Finds out which fd's adns is interested in, and when it would like - * to be able to time things out. This is in a form suitable for use - * with poll(2). - * - * On entry, usually fds should point to at least *nfds_io structs. - * adns will fill up to that many structs will information for poll, - * and record in *nfds_io how many structs it filled. If it wants to - * listen for more structs then *nfds_io will be set to the number - * required and _beforepoll will return ERANGE. - * - * You may call _beforepoll with fds==0 and *nfds_io 0, in which case - * adns will fill in the number of fds that it might be interested in - * in *nfds_io, and always return either 0 (if it is not interested in - * any fds) or ERANGE (if it is). - * - * NOTE that (unless now is 0) adns may acquire additional fds - * from one call to the next, so you must put adns_beforepoll in a - * loop, rather than assuming that the second call (with the buffer - * size requested by the first) will not return ERANGE. - * - * adns only ever sets POLLIN, POLLOUT and POLLPRI in its pollfd - * structs, and only ever looks at those bits. POLLPRI is required to - * detect TCP Urgent Data (which should not be used by a DNS server) - * so that adns can know that the TCP stream is now useless. - * - * In any case, *timeout_io should be a timeout value as for poll(2), - * which adns will modify downwards as required. If the caller does - * not plan to block then *timeout_io should be 0 on entry, or - * alternatively, timeout_io may be 0. (Alternatively, the caller may - * use _beforeselect with timeout_io==0 to find out about file - * descriptors, and use _firsttimeout is used to find out when adns - * might want to time something out.) - * - * adns_beforepoll will return 0 on success, and will not fail for any - * reason other than the fds buffer being too small (ERANGE). - * - * This call will never actually do any I/O. If you supply the - * current time it will not change the fds that adns is using or the - * timeouts it wants. - * - * In any case this call won't block. - */ - -#define ADNS_POLLFDS_RECOMMENDED 2 -/* If you allocate an fds buf with at least RECOMMENDED entries then - * you are unlikely to need to enlarge it. You are recommended to do - * so if it's convenient. However, you must be prepared for adns to - * require more space than this. - */ - -void adns_afterpoll(adns_state ads, const struct pollfd *fds, int nfds, - const struct timeval *now); -/* Gives adns flow-of-control for a bit; intended for use after - * poll(2). fds and nfds should be the results from poll(). pollfd - * structs mentioning fds not belonging to adns will be ignored. - */ - - -adns_status adns_rr_info(adns_rrtype type, - const char **rrtname_r, const char **fmtname_r, - int *len_r, - const void *datap, char **data_r); -/* - * Get information about a query type, or convert reply data to a - * textual form. type must be specified, and the official name of the - * corresponding RR type will be returned in *rrtname_r, and - * information about the processing style in *fmtname_r. The length - * of the table entry in an answer for that type will be returned in - * in *len_r. Any or all of rrtname_r, fmtname_r and len_r may be 0. - * If fmtname_r is non-null then *fmtname_r may be null on return, - * indicating that no special processing is involved. - * - * data_r be must be non-null iff datap is. In this case *data_r will - * be set to point to a string pointing to a representation of the RR - * data in master file format. (The owner name, timeout, class and - * type will not be present - only the data part of the RR.) The - * memory will have been obtained from malloc() and must be freed by - * the caller. - * - * Usually this routine will succeed. Possible errors include: - * adns_s_nomemory - * adns_s_rrtypeunknown - * adns_s_invaliddata (*datap contained garbage) - * If an error occurs then no memory has been allocated, - * and *rrtname_r, *fmtname_r, *len_r and *data_r are undefined. - * - * There are some adns-invented data formats which are not official - * master file formats. These include: - * - * Mailboxes if __qtf_mail822: these are just included as-is. - * - * Addresses (adns_rr_addr): these may be of pretty much any type. - * The representation is in two parts: first, a word for the address - * family (ie, in AF_XXX, the XXX), and then one or more items for the - * address itself, depending on the format. For an IPv4 address the - * syntax is INET followed by the dotted quad (from inet_ntoa). - * Currently only IPv4 is supported. - * - * Text strings (as in adns_rr_txt) appear inside double quotes, and - * use \" and \\ to represent " and \, and \xHH to represent - * characters not in the range 32-126. - * - * Hostname with addresses (adns_rr_hostaddr): this consists of the - * hostname, as usual, followed by the adns_status value, as an - * abbreviation, and then a descriptive string (encoded as if it were - * a piece of text), for the address lookup, followed by zero or more - * addresses enclosed in ( and ). If the result was a permanent - * failure, then a single ? appears instead of the ( ). If the - * result was a temporary failure then an empty pair of parentheses - * appears (which a space in between). For example, one of the NS - * records for greenend.org.uk comes out like - * ns.chiark.greenend.org.uk ok "OK" ( INET 195.224.76.132 ) - * an MX referring to a nonexistent host might come out like: - * 50 sun2.nsfnet-relay.ac.uk nxdomain "No such domain" ( ) - * and if nameserver information is not available you might get: - * dns2.spong.dyn.ml.org timeout "DNS query timed out" ? - */ - -const char *adns_strerror(adns_status st); -const char *adns_errabbrev(adns_status st); -const char *adns_errtypeabbrev(adns_status st); -/* Like strerror but for adns_status values. adns_errabbrev returns - * the abbreviation of the error - eg, for adns_s_timeout it returns - * "timeout". adns_errtypeabbrev returns the abbreviation of the - * error class: ie, for values up to adns_s_max_XXX it will return the - * string XXX. You MUST NOT call these functions with status values - * not returned by the same adns library. - */ - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif -#endif diff -urN gale-0.91a/liboop/foreign/glib.h gale-0.91b/liboop/foreign/glib.h --- gale-0.91a/liboop/foreign/glib.h Sun Sep 5 15:00:46 1999 +++ gale-0.91b/liboop/foreign/glib.h Wed Dec 31 16:00:00 1969 @@ -1,2795 +0,0 @@ -/* GLIB - Library of useful routines for C programming - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -/* - * Modified by the GLib Team and others 1997-1999. See the AUTHORS - * file for a list of people on the GLib Team. See the ChangeLog - * files for a list of changes. These files are distributed with - * GLib at ftp://ftp.gtk.org/pub/gtk/. - */ - -#ifndef __G_LIB_H__ -#define __G_LIB_H__ - -/* system specific config file glibconfig.h provides definitions for - * the extrema of many of the standard types. These are: - * - * G_MINSHORT, G_MAXSHORT - * G_MININT, G_MAXINT - * G_MINLONG, G_MAXLONG - * G_MINFLOAT, G_MAXFLOAT - * G_MINDOUBLE, G_MAXDOUBLE - * - * It also provides the following typedefs: - * - * gint8, guint8 - * gint16, guint16 - * gint32, guint32 - * gint64, guint64 - * - * It defines the G_BYTE_ORDER symbol to one of G_*_ENDIAN (see later in - * this file). - * - * And it provides a way to store and retrieve a `gint' in/from a `gpointer'. - * This is useful to pass an integer instead of a pointer to a callback. - * - * GINT_TO_POINTER(i), GUINT_TO_POINTER(i) - * GPOINTER_TO_INT(p), GPOINTER_TO_UINT(p) - * - * Finally, it provide the following wrappers to STDC functions: - * - * g_ATEXIT - * To register hooks which are executed on exit(). - * Usually a wrapper for STDC atexit. - * - * void *g_memmove(void *dest, const void *src, guint count); - * A wrapper for STDC memmove, or an implementation, if memmove doesn't - * exist. The prototype looks like the above, give or take a const, - * or size_t. - */ -#include - -/* include varargs functions for assertment macros - */ -#include - -/* optionally feature DMALLOC memory allocation debugger - */ -#ifdef USE_DMALLOC -#include "dmalloc.h" -#endif - - -#ifdef NATIVE_WIN32 - -/* On native Win32, directory separator is the backslash, and search path - * separator is the semicolon. - */ -#define G_DIR_SEPARATOR '\\' -#define G_DIR_SEPARATOR_S "\\" -#define G_SEARCHPATH_SEPARATOR ';' -#define G_SEARCHPATH_SEPARATOR_S ";" - -#else /* !NATIVE_WIN32 */ - -/* Unix */ - -#define G_DIR_SEPARATOR '/' -#define G_DIR_SEPARATOR_S "/" -#define G_SEARCHPATH_SEPARATOR ':' -#define G_SEARCHPATH_SEPARATOR_S ":" - -#endif /* !NATIVE_WIN32 */ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - - -/* Provide definitions for some commonly used macros. - * Some of them are only provided if they haven't already - * been defined. It is assumed that if they are already - * defined then the current definition is correct. - */ -#ifndef NULL -#define NULL ((void*) 0) -#endif - -#ifndef FALSE -#define FALSE (0) -#endif - -#ifndef TRUE -#define TRUE (!FALSE) -#endif - -#undef MAX -#define MAX(a, b) (((a) > (b)) ? (a) : (b)) - -#undef MIN -#define MIN(a, b) (((a) < (b)) ? (a) : (b)) - -#undef ABS -#define ABS(a) (((a) < 0) ? -(a) : (a)) - -#undef CLAMP -#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) - - -/* Define G_VA_COPY() to do the right thing for copying va_list variables. - * glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy. - */ -#if !defined (G_VA_COPY) -# if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32)) -# define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2)) -# elif defined (G_VA_COPY_AS_ARRAY) -# define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list)) -# else /* va_list is a pointer */ -# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2)) -# endif /* va_list is a pointer */ -#endif /* !G_VA_COPY */ - - -/* Provide convenience macros for handling structure - * fields through their offsets. - */ -#define G_STRUCT_OFFSET(struct_type, member) \ - ((gulong) ((gchar*) &((struct_type*) 0)->member)) -#define G_STRUCT_MEMBER_P(struct_p, struct_offset) \ - ((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset))) -#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \ - (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) - - -/* inlining hassle. for compilers that don't allow the `inline' keyword, - * mostly because of strict ANSI C compliance or dumbness, we try to fall - * back to either `__inline__' or `__inline'. - * we define G_CAN_INLINE, if the compiler seems to be actually - * *capable* to do function inlining, in which case inline function bodys - * do make sense. we also define G_INLINE_FUNC to properly export the - * function prototypes if no inlining can be performed. - * we special case most of the stuff, so inline functions can have a normal - * implementation by defining G_INLINE_FUNC to extern and G_CAN_INLINE to 1. - */ -#ifndef G_INLINE_FUNC -# define G_CAN_INLINE 1 -#endif -#ifdef G_HAVE_INLINE -# if defined (__GNUC__) && defined (__STRICT_ANSI__) -# undef inline -# define inline __inline__ -# endif -#else /* !G_HAVE_INLINE */ -# undef inline -# if defined (G_HAVE___INLINE__) -# define inline __inline__ -# else /* !inline && !__inline__ */ -# if defined (G_HAVE___INLINE) -# define inline __inline -# else /* !inline && !__inline__ && !__inline */ -# define inline /* don't inline, then */ -# ifndef G_INLINE_FUNC -# undef G_CAN_INLINE -# endif -# endif -# endif -#endif -#ifndef G_INLINE_FUNC -# ifdef __GNUC__ -# ifdef __OPTIMIZE__ -# define G_INLINE_FUNC extern inline -# else -# undef G_CAN_INLINE -# define G_INLINE_FUNC extern -# endif -# else /* !__GNUC__ */ -# ifdef G_CAN_INLINE -# define G_INLINE_FUNC static inline -# else -# define G_INLINE_FUNC extern -# endif -# endif /* !__GNUC__ */ -#endif /* !G_INLINE_FUNC */ - - -/* Provide simple macro statement wrappers (adapted from Perl): - * G_STMT_START { statements; } G_STMT_END; - * can be used as a single statement, as in - * if (x) G_STMT_START { ... } G_STMT_END; else ... - * - * For gcc we will wrap the statements within `({' and `})' braces. - * For SunOS they will be wrapped within `if (1)' and `else (void) 0', - * and otherwise within `do' and `while (0)'. - */ -#if !(defined (G_STMT_START) && defined (G_STMT_END)) -# if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus) -# define G_STMT_START (void)( -# define G_STMT_END ) -# else -# if (defined (sun) || defined (__sun__)) -# define G_STMT_START if (1) -# define G_STMT_END else (void)0 -# else -# define G_STMT_START do -# define G_STMT_END while (0) -# endif -# endif -#endif - - -/* Provide macros to feature the GCC function attribute. - */ -#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) -#define G_GNUC_PRINTF( format_idx, arg_idx ) \ - __attribute__((format (printf, format_idx, arg_idx))) -#define G_GNUC_SCANF( format_idx, arg_idx ) \ - __attribute__((format (scanf, format_idx, arg_idx))) -#define G_GNUC_FORMAT( arg_idx ) \ - __attribute__((format_arg (arg_idx))) -#define G_GNUC_NORETURN \ - __attribute__((noreturn)) -#define G_GNUC_CONST \ - __attribute__((const)) -#define G_GNUC_UNUSED \ - __attribute__((unused)) -#else /* !__GNUC__ */ -#define G_GNUC_PRINTF( format_idx, arg_idx ) -#define G_GNUC_SCANF( format_idx, arg_idx ) -#define G_GNUC_FORMAT( arg_idx ) -#define G_GNUC_NORETURN -#define G_GNUC_CONST -#define G_GNUC_UNUSED -#endif /* !__GNUC__ */ - - -/* Wrap the gcc __PRETTY_FUNCTION__ and __FUNCTION__ variables with - * macros, so we can refer to them as strings unconditionally. - */ -#ifdef __GNUC__ -#define G_GNUC_FUNCTION __FUNCTION__ -#define G_GNUC_PRETTY_FUNCTION __PRETTY_FUNCTION__ -#else /* !__GNUC__ */ -#define G_GNUC_FUNCTION "" -#define G_GNUC_PRETTY_FUNCTION "" -#endif /* !__GNUC__ */ - -/* we try to provide a usefull equivalent for ATEXIT if it is - * not defined, but use is actually abandoned. people should - * use g_atexit() instead. - */ -#ifndef ATEXIT -# define ATEXIT(proc) g_ATEXIT(proc) -#else -# define G_NATIVE_ATEXIT -#endif /* ATEXIT */ - -/* Hacker macro to place breakpoints for elected machines. - * Actual use is strongly deprecated of course ;) - */ -#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 -#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END -#elif defined (__alpha__) && defined (__GNUC__) && __GNUC__ >= 2 -#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END -#else /* !__i386__ && !__alpha__ */ -#define G_BREAKPOINT() -#endif /* __i386__ */ - - -/* Provide macros for easily allocating memory. The macros - * will cast the allocated memory to the specified type - * in order to avoid compiler warnings. (Makes the code neater). - */ - -#ifdef __DMALLOC_H__ -# define g_new(type, count) (ALLOC (type, count)) -# define g_new0(type, count) (CALLOC (type, count)) -# define g_renew(type, mem, count) (REALLOC (mem, type, count)) -#else /* __DMALLOC_H__ */ -# define g_new(type, count) \ - ((type *) g_malloc ((unsigned) sizeof (type) * (count))) -# define g_new0(type, count) \ - ((type *) g_malloc0 ((unsigned) sizeof (type) * (count))) -# define g_renew(type, mem, count) \ - ((type *) g_realloc (mem, (unsigned) sizeof (type) * (count))) -#endif /* __DMALLOC_H__ */ - -#define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \ - g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \ - sizeof (type), \ - sizeof (type) * (pre_alloc), \ - (alloc_type)) \ -) -#define g_chunk_new(type, chunk) ( \ - (type *) g_mem_chunk_alloc (chunk) \ -) -#define g_chunk_new0(type, chunk) ( \ - (type *) g_mem_chunk_alloc0 (chunk) \ -) -#define g_chunk_free(mem, mem_chunk) G_STMT_START { \ - g_mem_chunk_free ((mem_chunk), (mem)); \ -} G_STMT_END - - -#define g_string(x) #x - - -/* Provide macros for error handling. The "assert" macros will - * exit on failure. The "return" macros will exit the current - * function. Two different definitions are given for the macros - * if G_DISABLE_ASSERT is not defined, in order to support gcc's - * __PRETTY_FUNCTION__ capability. - */ - -#ifdef G_DISABLE_ASSERT - -#define g_assert(expr) -#define g_assert_not_reached() - -#else /* !G_DISABLE_ASSERT */ - -#ifdef __GNUC__ - -#define g_assert(expr) G_STMT_START{ \ - if (!(expr)) \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - "file %s: line %d (%s): assertion failed: (%s)", \ - __FILE__, \ - __LINE__, \ - __PRETTY_FUNCTION__, \ - #expr); }G_STMT_END - -#define g_assert_not_reached() G_STMT_START{ \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - "file %s: line %d (%s): should not be reached", \ - __FILE__, \ - __LINE__, \ - __PRETTY_FUNCTION__); }G_STMT_END - -#else /* !__GNUC__ */ - -#define g_assert(expr) G_STMT_START{ \ - if (!(expr)) \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - "file %s: line %d: assertion failed: (%s)", \ - __FILE__, \ - __LINE__, \ - #expr); }G_STMT_END - -#define g_assert_not_reached() G_STMT_START{ \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - "file %s: line %d: should not be reached", \ - __FILE__, \ - __LINE__); }G_STMT_END - -#endif /* __GNUC__ */ - -#endif /* !G_DISABLE_ASSERT */ - - -#ifdef G_DISABLE_CHECKS - -#define g_return_if_fail(expr) -#define g_return_val_if_fail(expr,val) - -#else /* !G_DISABLE_CHECKS */ - -#ifdef __GNUC__ - -#define g_return_if_fail(expr) G_STMT_START{ \ - if (!(expr)) \ - { \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d (%s): assertion `%s' failed.", \ - __FILE__, \ - __LINE__, \ - __PRETTY_FUNCTION__, \ - #expr); \ - return; \ - }; }G_STMT_END - -#define g_return_val_if_fail(expr,val) G_STMT_START{ \ - if (!(expr)) \ - { \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d (%s): assertion `%s' failed.", \ - __FILE__, \ - __LINE__, \ - __PRETTY_FUNCTION__, \ - #expr); \ - return val; \ - }; }G_STMT_END - -#else /* !__GNUC__ */ - -#define g_return_if_fail(expr) G_STMT_START{ \ - if (!(expr)) \ - { \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d: assertion `%s' failed.", \ - __FILE__, \ - __LINE__, \ - #expr); \ - return; \ - }; }G_STMT_END - -#define g_return_val_if_fail(expr, val) G_STMT_START{ \ - if (!(expr)) \ - { \ - g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d: assertion `%s' failed.", \ - __FILE__, \ - __LINE__, \ - #expr); \ - return val; \ - }; }G_STMT_END - -#endif /* !__GNUC__ */ - -#endif /* !G_DISABLE_CHECKS */ - - -/* Provide type definitions for commonly used types. - * These are useful because a "gint8" can be adjusted - * to be 1 byte (8 bits) on all platforms. Similarly and - * more importantly, "gint32" can be adjusted to be - * 4 bytes (32 bits) on all platforms. - */ - -typedef char gchar; -typedef short gshort; -typedef long glong; -typedef int gint; -typedef gint gboolean; - -typedef unsigned char guchar; -typedef unsigned short gushort; -typedef unsigned long gulong; -typedef unsigned int guint; - -typedef float gfloat; -typedef double gdouble; - -/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms. - * Since gldouble isn't used anywhere, just disable it for now */ - -#if 0 -#ifdef HAVE_LONG_DOUBLE -typedef long double gldouble; -#else /* HAVE_LONG_DOUBLE */ -typedef double gldouble; -#endif /* HAVE_LONG_DOUBLE */ -#endif /* 0 */ - -typedef void* gpointer; -typedef const void *gconstpointer; - - -typedef gint32 gssize; -typedef guint32 gsize; -typedef guint32 GQuark; -typedef gint32 GTime; - - -/* Portable endian checks and conversions - * - * glibconfig.h defines G_BYTE_ORDER which expands to one of - * the below macros. - */ -#define G_LITTLE_ENDIAN 1234 -#define G_BIG_ENDIAN 4321 -#define G_PDP_ENDIAN 3412 /* unused, need specific PDP check */ - - -/* Basic bit swapping functions - */ -#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ - (((guint16) (val) & (guint16) 0x00ffU) << 8) | \ - (((guint16) (val) & (guint16) 0xff00U) >> 8))) -#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \ - (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ - (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \ - (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \ - (((guint32) (val) & (guint32) 0xff000000U) >> 24))) - -/* Intel specific stuff for speed - */ -#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 -# define GUINT16_SWAP_LE_BE_X86(val) \ - (__extension__ \ - ({ register guint16 __v; \ - if (__builtin_constant_p (val)) \ - __v = GUINT16_SWAP_LE_BE_CONSTANT (val); \ - else \ - __asm__ __const__ ("rorw $8, %w0" \ - : "=r" (__v) \ - : "0" ((guint16) (val))); \ - __v; })) -# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val)) -# if !defined(__i486__) && !defined(__i586__) \ - && !defined(__pentium__) && !defined(__i686__) && !defined(__pentiumpro__) -# define GUINT32_SWAP_LE_BE_X86(val) \ - (__extension__ \ - ({ register guint32 __v; \ - if (__builtin_constant_p (val)) \ - __v = GUINT32_SWAP_LE_BE_CONSTANT (val); \ - else \ - __asm__ __const__ ("rorw $8, %w0\n\t" \ - "rorl $16, %0\n\t" \ - "rorw $8, %w0" \ - : "=r" (__v) \ - : "0" ((guint32) (val))); \ - __v; })) -# else /* 486 and higher has bswap */ -# define GUINT32_SWAP_LE_BE_X86(val) \ - (__extension__ \ - ({ register guint32 __v; \ - if (__builtin_constant_p (val)) \ - __v = GUINT32_SWAP_LE_BE_CONSTANT (val); \ - else \ - __asm__ __const__ ("bswap %0" \ - : "=r" (__v) \ - : "0" ((guint32) (val))); \ - __v; })) -# endif /* processor specific 32-bit stuff */ -# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val)) -#else /* !__i386__ */ -# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) -# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val)) -#endif /* __i386__ */ - -#ifdef G_HAVE_GINT64 -# define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x00000000000000ffU)) << 56) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x000000000000ff00U)) << 40) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x0000000000ff0000U)) << 24) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x00000000ff000000U)) << 8) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x000000ff00000000U)) >> 8) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x0000ff0000000000U)) >> 24) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) | \ - (((guint64) (val) & \ - (guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56))) -# if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 -# define GUINT64_SWAP_LE_BE_X86(val) \ - (__extension__ \ - ({ union { guint64 __ll; \ - guint32 __l[2]; } __r; \ - if (__builtin_constant_p (val)) \ - __r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (val); \ - else \ - { \ - union { guint64 __ll; \ - guint32 __l[2]; } __w; \ - __w.__ll = ((guint64) val); \ - __r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]); \ - __r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); \ - } \ - __r.__ll; })) -# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val)) -# else /* !__i386__ */ -# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val)) -# endif -#endif - -#define GUINT16_SWAP_LE_PDP(val) ((guint16) (val)) -#define GUINT16_SWAP_BE_PDP(val) (GUINT16_SWAP_LE_BE (val)) -#define GUINT32_SWAP_LE_PDP(val) ((guint32) ( \ - (((guint32) (val) & (guint32) 0x0000ffffU) << 16) | \ - (((guint32) (val) & (guint32) 0xffff0000U) >> 16))) -#define GUINT32_SWAP_BE_PDP(val) ((guint32) ( \ - (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \ - (((guint32) (val) & (guint32) 0xff00ff00U) >> 8))) - -/* The G*_TO_?E() macros are defined in glibconfig.h. - * The transformation is symmetric, so the FROM just maps to the TO. - */ -#define GINT16_FROM_LE(val) (GINT16_TO_LE (val)) -#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) -#define GINT16_FROM_BE(val) (GINT16_TO_BE (val)) -#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) -#define GINT32_FROM_LE(val) (GINT32_TO_LE (val)) -#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val)) -#define GINT32_FROM_BE(val) (GINT32_TO_BE (val)) -#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val)) - -#ifdef G_HAVE_GINT64 -#define GINT64_FROM_LE(val) (GINT64_TO_LE (val)) -#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val)) -#define GINT64_FROM_BE(val) (GINT64_TO_BE (val)) -#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val)) -#endif - -#define GLONG_FROM_LE(val) (GLONG_TO_LE (val)) -#define GULONG_FROM_LE(val) (GULONG_TO_LE (val)) -#define GLONG_FROM_BE(val) (GLONG_TO_BE (val)) -#define GULONG_FROM_BE(val) (GULONG_TO_BE (val)) - -#define GINT_FROM_LE(val) (GINT_TO_LE (val)) -#define GUINT_FROM_LE(val) (GUINT_TO_LE (val)) -#define GINT_FROM_BE(val) (GINT_TO_BE (val)) -#define GUINT_FROM_BE(val) (GUINT_TO_BE (val)) - - -/* Portable versions of host-network order stuff - */ -#define g_ntohl(val) (GUINT32_FROM_BE (val)) -#define g_ntohs(val) (GUINT16_FROM_BE (val)) -#define g_htonl(val) (GUINT32_TO_BE (val)) -#define g_htons(val) (GUINT16_TO_BE (val)) - - -/* Glib version. - * we prefix variable declarations so they can - * properly get exported in windows dlls. - */ -#ifdef NATIVE_WIN32 -# ifdef GLIB_COMPILATION -# define GUTILS_C_VAR __declspec(dllexport) -# else /* !GLIB_COMPILATION */ -# define GUTILS_C_VAR extern __declspec(dllimport) -# endif /* !GLIB_COMPILATION */ -#else /* !NATIVE_WIN32 */ -# define GUTILS_C_VAR extern -#endif /* !NATIVE_WIN32 */ - -GUTILS_C_VAR const guint glib_major_version; -GUTILS_C_VAR const guint glib_minor_version; -GUTILS_C_VAR const guint glib_micro_version; -GUTILS_C_VAR const guint glib_interface_age; -GUTILS_C_VAR const guint glib_binary_age; - -#define GLIB_CHECK_VERSION(major,minor,micro) \ - (GLIB_MAJOR_VERSION > (major) || \ - (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \ - (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \ - GLIB_MICRO_VERSION >= (micro))) - -/* Forward declarations of glib types. - */ -typedef struct _GAllocator GAllocator; -typedef struct _GArray GArray; -typedef struct _GByteArray GByteArray; -typedef struct _GCache GCache; -typedef struct _GCompletion GCompletion; -typedef struct _GData GData; -typedef struct _GDebugKey GDebugKey; -typedef struct _GHashTable GHashTable; -typedef struct _GHook GHook; -typedef struct _GHookList GHookList; -typedef struct _GList GList; -typedef struct _GMemChunk GMemChunk; -typedef struct _GNode GNode; -typedef struct _GPtrArray GPtrArray; -typedef struct _GRelation GRelation; -typedef struct _GScanner GScanner; -typedef struct _GScannerConfig GScannerConfig; -typedef struct _GSList GSList; -typedef struct _GString GString; -typedef struct _GStringChunk GStringChunk; -typedef struct _GTimer GTimer; -typedef struct _GTree GTree; -typedef struct _GTuples GTuples; -typedef union _GTokenValue GTokenValue; -typedef struct _GIOChannel GIOChannel; - -/* Tree traverse flags */ -typedef enum -{ - G_TRAVERSE_LEAFS = 1 << 0, - G_TRAVERSE_NON_LEAFS = 1 << 1, - G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS, - G_TRAVERSE_MASK = 0x03 -} GTraverseFlags; - -/* Tree traverse orders */ -typedef enum -{ - G_IN_ORDER, - G_PRE_ORDER, - G_POST_ORDER, - G_LEVEL_ORDER -} GTraverseType; - -/* Log level shift offset for user defined - * log levels (0-7 are used by GLib). - */ -#define G_LOG_LEVEL_USER_SHIFT (8) - -/* Glib log levels and flags. - */ -typedef enum -{ - /* log flags */ - G_LOG_FLAG_RECURSION = 1 << 0, - G_LOG_FLAG_FATAL = 1 << 1, - - /* GLib log levels */ - G_LOG_LEVEL_ERROR = 1 << 2, /* always fatal */ - G_LOG_LEVEL_CRITICAL = 1 << 3, - G_LOG_LEVEL_WARNING = 1 << 4, - G_LOG_LEVEL_MESSAGE = 1 << 5, - G_LOG_LEVEL_INFO = 1 << 6, - G_LOG_LEVEL_DEBUG = 1 << 7, - - G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL) -} GLogLevelFlags; - -/* GLib log levels that are considered fatal by default */ -#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR) - - -typedef gpointer (*GCacheNewFunc) (gpointer key); -typedef gpointer (*GCacheDupFunc) (gpointer value); -typedef void (*GCacheDestroyFunc) (gpointer value); -typedef gint (*GCompareFunc) (gconstpointer a, - gconstpointer b); -typedef gchar* (*GCompletionFunc) (gpointer); -typedef void (*GDestroyNotify) (gpointer data); -typedef void (*GDataForeachFunc) (GQuark key_id, - gpointer data, - gpointer user_data); -typedef void (*GFunc) (gpointer data, - gpointer user_data); -typedef guint (*GHashFunc) (gconstpointer key); -typedef void (*GFreeFunc) (gpointer data); -typedef void (*GHFunc) (gpointer key, - gpointer value, - gpointer user_data); -typedef gboolean (*GHRFunc) (gpointer key, - gpointer value, - gpointer user_data); -typedef gint (*GHookCompareFunc) (GHook *new_hook, - GHook *sibling); -typedef gboolean (*GHookFindFunc) (GHook *hook, - gpointer data); -typedef void (*GHookMarshaller) (GHook *hook, - gpointer data); -typedef gboolean (*GHookCheckMarshaller) (GHook *hook, - gpointer data); -typedef void (*GHookFunc) (gpointer data); -typedef gboolean (*GHookCheckFunc) (gpointer data); -typedef void (*GHookFreeFunc) (GHookList *hook_list, - GHook *hook); -typedef void (*GLogFunc) (const gchar *log_domain, - GLogLevelFlags log_level, - const gchar *message, - gpointer user_data); -typedef gboolean (*GNodeTraverseFunc) (GNode *node, - gpointer data); -typedef void (*GNodeForeachFunc) (GNode *node, - gpointer data); -typedef gint (*GSearchFunc) (gpointer key, - gpointer data); -typedef void (*GScannerMsgFunc) (GScanner *scanner, - gchar *message, - gint error); -typedef gint (*GTraverseFunc) (gpointer key, - gpointer value, - gpointer data); -typedef void (*GVoidFunc) (void); - - -struct _GList -{ - gpointer data; - GList *next; - GList *prev; -}; - -struct _GSList -{ - gpointer data; - GSList *next; -}; - -struct _GString -{ - gchar *str; - gint len; -}; - -struct _GArray -{ - gchar *data; - guint len; -}; - -struct _GByteArray -{ - guint8 *data; - guint len; -}; - -struct _GPtrArray -{ - gpointer *pdata; - guint len; -}; - -struct _GTuples -{ - guint len; -}; - -struct _GDebugKey -{ - gchar *key; - guint value; -}; - - -/* Doubly linked lists - */ -void g_list_push_allocator (GAllocator *allocator); -void g_list_pop_allocator (void); -GList* g_list_alloc (void); -void g_list_free (GList *list); -void g_list_free_1 (GList *list); -GList* g_list_append (GList *list, - gpointer data); -GList* g_list_prepend (GList *list, - gpointer data); -GList* g_list_insert (GList *list, - gpointer data, - gint position); -GList* g_list_insert_sorted (GList *list, - gpointer data, - GCompareFunc func); -GList* g_list_concat (GList *list1, - GList *list2); -GList* g_list_remove (GList *list, - gpointer data); -GList* g_list_remove_link (GList *list, - GList *llink); -GList* g_list_reverse (GList *list); -GList* g_list_copy (GList *list); -GList* g_list_nth (GList *list, - guint n); -GList* g_list_find (GList *list, - gpointer data); -GList* g_list_find_custom (GList *list, - gpointer data, - GCompareFunc func); -gint g_list_position (GList *list, - GList *llink); -gint g_list_index (GList *list, - gpointer data); -GList* g_list_last (GList *list); -GList* g_list_first (GList *list); -guint g_list_length (GList *list); -void g_list_foreach (GList *list, - GFunc func, - gpointer user_data); -GList* g_list_sort (GList *list, - GCompareFunc compare_func); -gpointer g_list_nth_data (GList *list, - guint n); -#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) -#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL) - - -/* Singly linked lists - */ -void g_slist_push_allocator (GAllocator *allocator); -void g_slist_pop_allocator (void); -GSList* g_slist_alloc (void); -void g_slist_free (GSList *list); -void g_slist_free_1 (GSList *list); -GSList* g_slist_append (GSList *list, - gpointer data); -GSList* g_slist_prepend (GSList *list, - gpointer data); -GSList* g_slist_insert (GSList *list, - gpointer data, - gint position); -GSList* g_slist_insert_sorted (GSList *list, - gpointer data, - GCompareFunc func); -GSList* g_slist_concat (GSList *list1, - GSList *list2); -GSList* g_slist_remove (GSList *list, - gpointer data); -GSList* g_slist_remove_link (GSList *list, - GSList *llink); -GSList* g_slist_reverse (GSList *list); -GSList* g_slist_copy (GSList *list); -GSList* g_slist_nth (GSList *list, - guint n); -GSList* g_slist_find (GSList *list, - gpointer data); -GSList* g_slist_find_custom (GSList *list, - gpointer data, - GCompareFunc func); -gint g_slist_position (GSList *list, - GSList *llink); -gint g_slist_index (GSList *list, - gpointer data); -GSList* g_slist_last (GSList *list); -guint g_slist_length (GSList *list); -void g_slist_foreach (GSList *list, - GFunc func, - gpointer user_data); -GSList* g_slist_sort (GSList *list, - GCompareFunc compare_func); -gpointer g_slist_nth_data (GSList *list, - guint n); -#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) - - -/* Hash tables - */ -GHashTable* g_hash_table_new (GHashFunc hash_func, - GCompareFunc key_compare_func); -void g_hash_table_destroy (GHashTable *hash_table); -void g_hash_table_insert (GHashTable *hash_table, - gpointer key, - gpointer value); -void g_hash_table_remove (GHashTable *hash_table, - gconstpointer key); -gpointer g_hash_table_lookup (GHashTable *hash_table, - gconstpointer key); -gboolean g_hash_table_lookup_extended(GHashTable *hash_table, - gconstpointer lookup_key, - gpointer *orig_key, - gpointer *value); -void g_hash_table_freeze (GHashTable *hash_table); -void g_hash_table_thaw (GHashTable *hash_table); -void g_hash_table_foreach (GHashTable *hash_table, - GHFunc func, - gpointer user_data); -guint g_hash_table_foreach_remove (GHashTable *hash_table, - GHRFunc func, - gpointer user_data); -guint g_hash_table_size (GHashTable *hash_table); - - -/* Caches - */ -GCache* g_cache_new (GCacheNewFunc value_new_func, - GCacheDestroyFunc value_destroy_func, - GCacheDupFunc key_dup_func, - GCacheDestroyFunc key_destroy_func, - GHashFunc hash_key_func, - GHashFunc hash_value_func, - GCompareFunc key_compare_func); -void g_cache_destroy (GCache *cache); -gpointer g_cache_insert (GCache *cache, - gpointer key); -void g_cache_remove (GCache *cache, - gpointer value); -void g_cache_key_foreach (GCache *cache, - GHFunc func, - gpointer user_data); -void g_cache_value_foreach (GCache *cache, - GHFunc func, - gpointer user_data); - - -/* Balanced binary trees - */ -GTree* g_tree_new (GCompareFunc key_compare_func); -void g_tree_destroy (GTree *tree); -void g_tree_insert (GTree *tree, - gpointer key, - gpointer value); -void g_tree_remove (GTree *tree, - gpointer key); -gpointer g_tree_lookup (GTree *tree, - gpointer key); -void g_tree_traverse (GTree *tree, - GTraverseFunc traverse_func, - GTraverseType traverse_type, - gpointer data); -gpointer g_tree_search (GTree *tree, - GSearchFunc search_func, - gpointer data); -gint g_tree_height (GTree *tree); -gint g_tree_nnodes (GTree *tree); - - - -/* N-way tree implementation - */ -struct _GNode -{ - gpointer data; - GNode *next; - GNode *prev; - GNode *parent; - GNode *children; -}; - -#define G_NODE_IS_ROOT(node) (((GNode*) (node))->parent == NULL && \ - ((GNode*) (node))->prev == NULL && \ - ((GNode*) (node))->next == NULL) -#define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL) - -void g_node_push_allocator (GAllocator *allocator); -void g_node_pop_allocator (void); -GNode* g_node_new (gpointer data); -void g_node_destroy (GNode *root); -void g_node_unlink (GNode *node); -GNode* g_node_insert (GNode *parent, - gint position, - GNode *node); -GNode* g_node_insert_before (GNode *parent, - GNode *sibling, - GNode *node); -GNode* g_node_prepend (GNode *parent, - GNode *node); -guint g_node_n_nodes (GNode *root, - GTraverseFlags flags); -GNode* g_node_get_root (GNode *node); -gboolean g_node_is_ancestor (GNode *node, - GNode *descendant); -guint g_node_depth (GNode *node); -GNode* g_node_find (GNode *root, - GTraverseType order, - GTraverseFlags flags, - gpointer data); - -/* convenience macros */ -#define g_node_append(parent, node) \ - g_node_insert_before ((parent), NULL, (node)) -#define g_node_insert_data(parent, position, data) \ - g_node_insert ((parent), (position), g_node_new (data)) -#define g_node_insert_data_before(parent, sibling, data) \ - g_node_insert_before ((parent), (sibling), g_node_new (data)) -#define g_node_prepend_data(parent, data) \ - g_node_prepend ((parent), g_node_new (data)) -#define g_node_append_data(parent, data) \ - g_node_insert_before ((parent), NULL, g_node_new (data)) - -/* traversal function, assumes that `node' is root - * (only traverses `node' and its subtree). - * this function is just a high level interface to - * low level traversal functions, optimized for speed. - */ -void g_node_traverse (GNode *root, - GTraverseType order, - GTraverseFlags flags, - gint max_depth, - GNodeTraverseFunc func, - gpointer data); - -/* return the maximum tree height starting with `node', this is an expensive - * operation, since we need to visit all nodes. this could be shortened by - * adding `guint height' to struct _GNode, but then again, this is not very - * often needed, and would make g_node_insert() more time consuming. - */ -guint g_node_max_height (GNode *root); - -void g_node_children_foreach (GNode *node, - GTraverseFlags flags, - GNodeForeachFunc func, - gpointer data); -void g_node_reverse_children (GNode *node); -guint g_node_n_children (GNode *node); -GNode* g_node_nth_child (GNode *node, - guint n); -GNode* g_node_last_child (GNode *node); -GNode* g_node_find_child (GNode *node, - GTraverseFlags flags, - gpointer data); -gint g_node_child_position (GNode *node, - GNode *child); -gint g_node_child_index (GNode *node, - gpointer data); - -GNode* g_node_first_sibling (GNode *node); -GNode* g_node_last_sibling (GNode *node); - -#define g_node_prev_sibling(node) ((node) ? \ - ((GNode*) (node))->prev : NULL) -#define g_node_next_sibling(node) ((node) ? \ - ((GNode*) (node))->next : NULL) -#define g_node_first_child(node) ((node) ? \ - ((GNode*) (node))->children : NULL) - - -/* Callback maintenance functions - */ -#define G_HOOK_FLAG_USER_SHIFT (4) -typedef enum -{ - G_HOOK_FLAG_ACTIVE = 1 << 0, - G_HOOK_FLAG_IN_CALL = 1 << 1, - G_HOOK_FLAG_MASK = 0x0f -} GHookFlagMask; - -#define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01) - -struct _GHookList -{ - guint seq_id; - guint hook_size; - guint is_setup : 1; - GHook *hooks; - GMemChunk *hook_memchunk; - GHookFreeFunc hook_free; /* virtual function */ - GHookFreeFunc hook_destroy; /* virtual function */ -}; - -struct _GHook -{ - gpointer data; - GHook *next; - GHook *prev; - guint ref_count; - guint hook_id; - guint flags; - gpointer func; - GDestroyNotify destroy; -}; - -#define G_HOOK_ACTIVE(hook) ((((GHook*) hook)->flags & \ - G_HOOK_FLAG_ACTIVE) != 0) -#define G_HOOK_IN_CALL(hook) ((((GHook*) hook)->flags & \ - G_HOOK_FLAG_IN_CALL) != 0) -#define G_HOOK_IS_VALID(hook) (((GHook*) hook)->hook_id != 0 && \ - G_HOOK_ACTIVE (hook)) -#define G_HOOK_IS_UNLINKED(hook) (((GHook*) hook)->next == NULL && \ - ((GHook*) hook)->prev == NULL && \ - ((GHook*) hook)->hook_id == 0 && \ - ((GHook*) hook)->ref_count == 0) - -void g_hook_list_init (GHookList *hook_list, - guint hook_size); -void g_hook_list_clear (GHookList *hook_list); -GHook* g_hook_alloc (GHookList *hook_list); -void g_hook_free (GHookList *hook_list, - GHook *hook); -void g_hook_ref (GHookList *hook_list, - GHook *hook); -void g_hook_unref (GHookList *hook_list, - GHook *hook); -gboolean g_hook_destroy (GHookList *hook_list, - guint hook_id); -void g_hook_destroy_link (GHookList *hook_list, - GHook *hook); -void g_hook_prepend (GHookList *hook_list, - GHook *hook); -void g_hook_insert_before (GHookList *hook_list, - GHook *sibling, - GHook *hook); -void g_hook_insert_sorted (GHookList *hook_list, - GHook *hook, - GHookCompareFunc func); -GHook* g_hook_get (GHookList *hook_list, - guint hook_id); -GHook* g_hook_find (GHookList *hook_list, - gboolean need_valids, - GHookFindFunc func, - gpointer data); -GHook* g_hook_find_data (GHookList *hook_list, - gboolean need_valids, - gpointer data); -GHook* g_hook_find_func (GHookList *hook_list, - gboolean need_valids, - gpointer func); -GHook* g_hook_find_func_data (GHookList *hook_list, - gboolean need_valids, - gpointer func, - gpointer data); -/* return the first valid hook, and increment its reference count */ -GHook* g_hook_first_valid (GHookList *hook_list, - gboolean may_be_in_call); -/* return the next valid hook with incremented reference count, and - * decrement the reference count of the original hook - */ -GHook* g_hook_next_valid (GHookList *hook_list, - GHook *hook, - gboolean may_be_in_call); - -/* GHookCompareFunc implementation to insert hooks sorted by their id */ -gint g_hook_compare_ids (GHook *new_hook, - GHook *sibling); - -/* convenience macros */ -#define g_hook_append( hook_list, hook ) \ - g_hook_insert_before ((hook_list), NULL, (hook)) - -/* invoke all valid hooks with the (*GHookFunc) signature. - */ -void g_hook_list_invoke (GHookList *hook_list, - gboolean may_recurse); -/* invoke all valid hooks with the (*GHookCheckFunc) signature, - * and destroy the hook if FALSE is returned. - */ -void g_hook_list_invoke_check (GHookList *hook_list, - gboolean may_recurse); -/* invoke a marshaller on all valid hooks. - */ -void g_hook_list_marshal (GHookList *hook_list, - gboolean may_recurse, - GHookMarshaller marshaller, - gpointer data); -void g_hook_list_marshal_check (GHookList *hook_list, - gboolean may_recurse, - GHookCheckMarshaller marshaller, - gpointer data); - - -/* Fatal error handlers. - * g_on_error_query() will prompt the user to either - * [E]xit, [H]alt, [P]roceed or show [S]tack trace. - * g_on_error_stack_trace() invokes gdb, which attaches to the current - * process and shows a stack trace. - * These function may cause different actions on non-unix platforms. - * The prg_name arg is required by gdb to find the executable, if it is - * passed as NULL, g_on_error_query() will try g_get_prgname(). - */ -void g_on_error_query (const gchar *prg_name); -void g_on_error_stack_trace (const gchar *prg_name); - - -/* Logging mechanism - */ -extern const gchar *g_log_domain_glib; -guint g_log_set_handler (const gchar *log_domain, - GLogLevelFlags log_levels, - GLogFunc log_func, - gpointer user_data); -void g_log_remove_handler (const gchar *log_domain, - guint handler_id); -void g_log_default_handler (const gchar *log_domain, - GLogLevelFlags log_level, - const gchar *message, - gpointer unused_data); -void g_log (const gchar *log_domain, - GLogLevelFlags log_level, - const gchar *format, - ...) G_GNUC_PRINTF (3, 4); -void g_logv (const gchar *log_domain, - GLogLevelFlags log_level, - const gchar *format, - va_list args); -GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain, - GLogLevelFlags fatal_mask); -GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); -#ifndef G_LOG_DOMAIN -#define G_LOG_DOMAIN ((gchar*) 0) -#endif /* G_LOG_DOMAIN */ -#ifdef __GNUC__ -#define g_error(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - format, ##args) -#define g_message(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_MESSAGE, \ - format, ##args) -#define g_warning(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_WARNING, \ - format, ##args) -#else /* !__GNUC__ */ -static void -g_error (const gchar *format, - ...) -{ - va_list args; - va_start (args, format); - g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args); - va_end (args); -} -static void -g_message (const gchar *format, - ...) -{ - va_list args; - va_start (args, format); - g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args); - va_end (args); -} -static void -g_warning (const gchar *format, - ...) -{ - va_list args; - va_start (args, format); - g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args); - va_end (args); -} -#endif /* !__GNUC__ */ - -typedef void (*GPrintFunc) (const gchar *string); -void g_print (const gchar *format, - ...) G_GNUC_PRINTF (1, 2); -GPrintFunc g_set_print_handler (GPrintFunc func); -void g_printerr (const gchar *format, - ...) G_GNUC_PRINTF (1, 2); -GPrintFunc g_set_printerr_handler (GPrintFunc func); - -/* deprecated compatibility functions, use g_log_set_handler() instead */ -typedef void (*GErrorFunc) (const gchar *str); -typedef void (*GWarningFunc) (const gchar *str); -GErrorFunc g_set_error_handler (GErrorFunc func); -GWarningFunc g_set_warning_handler (GWarningFunc func); -GPrintFunc g_set_message_handler (GPrintFunc func); - - -/* Memory allocation and debugging - */ -#ifdef USE_DMALLOC - -#define g_malloc(size) ((gpointer) MALLOC (size)) -#define g_malloc0(size) ((gpointer) CALLOC (char, size)) -#define g_realloc(mem,size) ((gpointer) REALLOC (mem, char, size)) -#define g_free(mem) FREE (mem) - -#else /* !USE_DMALLOC */ - -gpointer g_malloc (gulong size); -gpointer g_malloc0 (gulong size); -gpointer g_realloc (gpointer mem, - gulong size); -void g_free (gpointer mem); - -#endif /* !USE_DMALLOC */ - -void g_mem_profile (void); -void g_mem_check (gpointer mem); - -/* Generic allocators - */ -GAllocator* g_allocator_new (const gchar *name, - guint n_preallocs); -void g_allocator_free (GAllocator *allocator); - -#define G_ALLOCATOR_LIST (1) -#define G_ALLOCATOR_SLIST (2) -#define G_ALLOCATOR_NODE (3) - - -/* "g_mem_chunk_new" creates a new memory chunk. - * Memory chunks are used to allocate pieces of memory which are - * always the same size. Lists are a good example of such a data type. - * The memory chunk allocates and frees blocks of memory as needed. - * Just be sure to call "g_mem_chunk_free" and not "g_free" on data - * allocated in a mem chunk. ("g_free" will most likely cause a seg - * fault...somewhere). - * - * Oh yeah, GMemChunk is an opaque data type. (You don't really - * want to know what's going on inside do you?) - */ - -/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation - * is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per - * atom. (They are also useful for lists which use MemChunk to allocate - * memory but are also part of the MemChunk implementation). - * ALLOC_AND_FREE MemChunk's can allocate and free memory. - */ - -#define G_ALLOC_ONLY 1 -#define G_ALLOC_AND_FREE 2 - -GMemChunk* g_mem_chunk_new (gchar *name, - gint atom_size, - gulong area_size, - gint type); -void g_mem_chunk_destroy (GMemChunk *mem_chunk); -gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk); -gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk); -void g_mem_chunk_free (GMemChunk *mem_chunk, - gpointer mem); -void g_mem_chunk_clean (GMemChunk *mem_chunk); -void g_mem_chunk_reset (GMemChunk *mem_chunk); -void g_mem_chunk_print (GMemChunk *mem_chunk); -void g_mem_chunk_info (void); - -/* Ah yes...we have a "g_blow_chunks" function. - * "g_blow_chunks" simply compresses all the chunks. This operation - * consists of freeing every memory area that should be freed (but - * which we haven't gotten around to doing yet). And, no, - * "g_blow_chunks" doesn't follow the naming scheme, but it is a - * much better name than "g_mem_chunk_clean_all" or something - * similar. - */ -void g_blow_chunks (void); - - -/* Timer - */ -GTimer* g_timer_new (void); -void g_timer_destroy (GTimer *timer); -void g_timer_start (GTimer *timer); -void g_timer_stop (GTimer *timer); -void g_timer_reset (GTimer *timer); -gdouble g_timer_elapsed (GTimer *timer, - gulong *microseconds); - - -/* String utility functions that modify a string argument or - * return a constant string that must not be freed. - */ -#define G_STR_DELIMITERS "_-|> <." -gchar* g_strdelimit (gchar *string, - const gchar *delimiters, - gchar new_delimiter); -gdouble g_strtod (const gchar *nptr, - gchar **endptr); -gchar* g_strerror (gint errnum); -gchar* g_strsignal (gint signum); -gint g_strcasecmp (const gchar *s1, - const gchar *s2); -gint g_strncasecmp (const gchar *s1, - const gchar *s2, - guint n); -void g_strdown (gchar *string); -void g_strup (gchar *string); -void g_strreverse (gchar *string); -/* removes leading spaces */ -gchar* g_strchug (gchar *string); -/* removes trailing spaces */ -gchar* g_strchomp (gchar *string); -/* removes leading & trailing spaces */ -#define g_strstrip( string ) g_strchomp (g_strchug (string)) - -/* String utility functions that return a newly allocated string which - * ought to be freed from the caller at some point. - */ -gchar* g_strdup (const gchar *str); -gchar* g_strdup_printf (const gchar *format, - ...) G_GNUC_PRINTF (1, 2); -gchar* g_strdup_vprintf (const gchar *format, - va_list args); -gchar* g_strndup (const gchar *str, - guint n); -gchar* g_strnfill (guint length, - gchar fill_char); -gchar* g_strconcat (const gchar *string1, - ...); /* NULL terminated */ -gchar* g_strjoin (const gchar *separator, - ...); /* NULL terminated */ -gchar* g_strescape (gchar *string); -gpointer g_memdup (gconstpointer mem, - guint byte_size); - -/* NULL terminated string arrays. - * g_strsplit() splits up string into max_tokens tokens at delim and - * returns a newly allocated string array. - * g_strjoinv() concatenates all of str_array's strings, sliding in an - * optional separator, the returned string is newly allocated. - * g_strfreev() frees the array itself and all of its strings. - */ -gchar** g_strsplit (const gchar *string, - const gchar *delimiter, - gint max_tokens); -gchar* g_strjoinv (const gchar *separator, - gchar **str_array); -void g_strfreev (gchar **str_array); - - - -/* calculate a string size, guarranteed to fit format + args. - */ -guint g_printf_string_upper_bound (const gchar* format, - va_list args); - - -/* Retrive static string info - */ -gchar* g_get_user_name (void); -gchar* g_get_real_name (void); -gchar* g_get_home_dir (void); -gchar* g_get_tmp_dir (void); -gchar* g_get_prgname (void); -void g_set_prgname (const gchar *prgname); - - -/* Miscellaneous utility functions - */ -guint g_parse_debug_string (const gchar *string, - GDebugKey *keys, - guint nkeys); -gint g_snprintf (gchar *string, - gulong n, - gchar const *format, - ...) G_GNUC_PRINTF (3, 4); -gint g_vsnprintf (gchar *string, - gulong n, - gchar const *format, - va_list args); -gchar* g_basename (const gchar *file_name); -/* Check if a file name is an absolute path */ -gboolean g_path_is_absolute (const gchar *file_name); -/* In case of absolute paths, skip the root part */ -gchar* g_path_skip_root (gchar *file_name); - -/* strings are newly allocated with g_malloc() */ -gchar* g_dirname (const gchar *file_name); -gchar* g_get_current_dir (void); -gchar* g_getenv (const gchar *variable); - - -/* we use a GLib function as a replacement for ATEXIT, so - * the programmer is not required to check the return value - * (if there is any in the implementation) and doesn't encounter - * missing include files. - */ -void g_atexit (GVoidFunc func); - - -/* Bit tests - */ -G_INLINE_FUNC gint g_bit_nth_lsf (guint32 mask, - gint nth_bit); -#ifdef G_CAN_INLINE -G_INLINE_FUNC gint -g_bit_nth_lsf (guint32 mask, - gint nth_bit) -{ - do - { - nth_bit++; - if (mask & (1 << (guint) nth_bit)) - return nth_bit; - } - while (nth_bit < 32); - return -1; -} -#endif /* G_CAN_INLINE */ - -G_INLINE_FUNC gint g_bit_nth_msf (guint32 mask, - gint nth_bit); -#ifdef G_CAN_INLINE -G_INLINE_FUNC gint -g_bit_nth_msf (guint32 mask, - gint nth_bit) -{ - if (nth_bit < 0) - nth_bit = 32; - do - { - nth_bit--; - if (mask & (1 << (guint) nth_bit)) - return nth_bit; - } - while (nth_bit > 0); - return -1; -} -#endif /* G_CAN_INLINE */ - -G_INLINE_FUNC guint g_bit_storage (guint number); -#ifdef G_CAN_INLINE -G_INLINE_FUNC guint -g_bit_storage (guint number) -{ - register guint n_bits = 0; - - do - { - n_bits++; - number >>= 1; - } - while (number); - return n_bits; -} -#endif /* G_CAN_INLINE */ - -/* String Chunks - */ -GStringChunk* g_string_chunk_new (gint size); -void g_string_chunk_free (GStringChunk *chunk); -gchar* g_string_chunk_insert (GStringChunk *chunk, - const gchar *string); -gchar* g_string_chunk_insert_const (GStringChunk *chunk, - const gchar *string); - - -/* Strings - */ -GString* g_string_new (const gchar *init); -GString* g_string_sized_new (guint dfl_size); -void g_string_free (GString *string, - gint free_segment); -GString* g_string_assign (GString *lval, - const gchar *rval); -GString* g_string_truncate (GString *string, - gint len); -GString* g_string_append (GString *string, - const gchar *val); -GString* g_string_append_c (GString *string, - gchar c); -GString* g_string_prepend (GString *string, - const gchar *val); -GString* g_string_prepend_c (GString *string, - gchar c); -GString* g_string_insert (GString *string, - gint pos, - const gchar *val); -GString* g_string_insert_c (GString *string, - gint pos, - gchar c); -GString* g_string_erase (GString *string, - gint pos, - gint len); -GString* g_string_down (GString *string); -GString* g_string_up (GString *string); -void g_string_sprintf (GString *string, - const gchar *format, - ...) G_GNUC_PRINTF (2, 3); -void g_string_sprintfa (GString *string, - const gchar *format, - ...) G_GNUC_PRINTF (2, 3); - - -/* Resizable arrays, remove fills any cleared spot and shortens the - * array, while preserving the order. remove_fast will distort the - * order by moving the last element to the position of the removed - */ - -#define g_array_append_val(a,v) g_array_append_vals (a, &v, 1) -#define g_array_prepend_val(a,v) g_array_prepend_vals (a, &v, 1) -#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1) -#define g_array_index(a,t,i) (((t*) (a)->data) [(i)]) - -GArray* g_array_new (gboolean zero_terminated, - gboolean clear, - guint element_size); -void g_array_free (GArray *array, - gboolean free_segment); -GArray* g_array_append_vals (GArray *array, - gconstpointer data, - guint len); -GArray* g_array_prepend_vals (GArray *array, - gconstpointer data, - guint len); -GArray* g_array_insert_vals (GArray *array, - guint index, - gconstpointer data, - guint len); -GArray* g_array_set_size (GArray *array, - guint length); -GArray* g_array_remove_index (GArray *array, - guint index); -GArray* g_array_remove_index_fast (GArray *array, - guint index); - -/* Resizable pointer array. This interface is much less complicated - * than the above. Add appends appends a pointer. Remove fills any - * cleared spot and shortens the array. remove_fast will again distort - * order. - */ -#define g_ptr_array_index(array,index) (array->pdata)[index] -GPtrArray* g_ptr_array_new (void); -void g_ptr_array_free (GPtrArray *array, - gboolean free_seg); -void g_ptr_array_set_size (GPtrArray *array, - gint length); -gpointer g_ptr_array_remove_index (GPtrArray *array, - guint index); -gpointer g_ptr_array_remove_index_fast (GPtrArray *array, - guint index); -gboolean g_ptr_array_remove (GPtrArray *array, - gpointer data); -gboolean g_ptr_array_remove_fast (GPtrArray *array, - gpointer data); -void g_ptr_array_add (GPtrArray *array, - gpointer data); - -/* Byte arrays, an array of guint8. Implemented as a GArray, - * but type-safe. - */ - -GByteArray* g_byte_array_new (void); -void g_byte_array_free (GByteArray *array, - gboolean free_segment); -GByteArray* g_byte_array_append (GByteArray *array, - const guint8 *data, - guint len); -GByteArray* g_byte_array_prepend (GByteArray *array, - const guint8 *data, - guint len); -GByteArray* g_byte_array_set_size (GByteArray *array, - guint length); -GByteArray* g_byte_array_remove_index (GByteArray *array, - guint index); -GByteArray* g_byte_array_remove_index_fast (GByteArray *array, - guint index); - - -/* Hash Functions - */ -gint g_str_equal (gconstpointer v, - gconstpointer v2); -guint g_str_hash (gconstpointer v); - -gint g_int_equal (gconstpointer v, - gconstpointer v2); -guint g_int_hash (gconstpointer v); - -/* This "hash" function will just return the key's adress as an - * unsigned integer. Useful for hashing on plain adresses or - * simple integer values. - * passing NULL into g_hash_table_new() as GHashFunc has the - * same effect as passing g_direct_hash(). - */ -guint g_direct_hash (gconstpointer v); -gint g_direct_equal (gconstpointer v, - gconstpointer v2); - - -/* Quarks (string<->id association) - */ -GQuark g_quark_try_string (const gchar *string); -GQuark g_quark_from_static_string (const gchar *string); -GQuark g_quark_from_string (const gchar *string); -gchar* g_quark_to_string (GQuark quark); - - -/* Keyed Data List - */ -void g_datalist_init (GData **datalist); -void g_datalist_clear (GData **datalist); -gpointer g_datalist_id_get_data (GData **datalist, - GQuark key_id); -void g_datalist_id_set_data_full (GData **datalist, - GQuark key_id, - gpointer data, - GDestroyNotify destroy_func); -void g_datalist_id_remove_no_notify (GData **datalist, - GQuark key_id); -void g_datalist_foreach (GData **datalist, - GDataForeachFunc func, - gpointer user_data); -#define g_datalist_id_set_data(dl, q, d) \ - g_datalist_id_set_data_full ((dl), (q), (d), NULL) -#define g_datalist_id_remove_data(dl, q) \ - g_datalist_id_set_data ((dl), (q), NULL) -#define g_datalist_get_data(dl, k) \ - (g_datalist_id_get_data ((dl), g_quark_try_string (k))) -#define g_datalist_set_data_full(dl, k, d, f) \ - g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f)) -#define g_datalist_remove_no_notify(dl, k) \ - g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k)) -#define g_datalist_set_data(dl, k, d) \ - g_datalist_set_data_full ((dl), (k), (d), NULL) -#define g_datalist_remove_data(dl, k) \ - g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL) - - -/* Location Associated Keyed Data - */ -void g_dataset_destroy (gconstpointer dataset_location); -gpointer g_dataset_id_get_data (gconstpointer dataset_location, - GQuark key_id); -void g_dataset_id_set_data_full (gconstpointer dataset_location, - GQuark key_id, - gpointer data, - GDestroyNotify destroy_func); -void g_dataset_id_remove_no_notify (gconstpointer dataset_location, - GQuark key_id); -void g_dataset_foreach (gconstpointer dataset_location, - GDataForeachFunc func, - gpointer user_data); -#define g_dataset_id_set_data(l, k, d) \ - g_dataset_id_set_data_full ((l), (k), (d), NULL) -#define g_dataset_id_remove_data(l, k) \ - g_dataset_id_set_data ((l), (k), NULL) -#define g_dataset_get_data(l, k) \ - (g_dataset_id_get_data ((l), g_quark_try_string (k))) -#define g_dataset_set_data_full(l, k, d, f) \ - g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f)) -#define g_dataset_remove_no_notify(l, k) \ - g_dataset_id_remove_no_notify ((l), g_quark_try_string (k)) -#define g_dataset_set_data(l, k, d) \ - g_dataset_set_data_full ((l), (k), (d), NULL) -#define g_dataset_remove_data(l, k) \ - g_dataset_id_set_data ((l), g_quark_try_string (k), NULL) - - -/* GScanner: Flexible lexical scanner for general purpose. - */ - -/* Character sets */ -#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" -#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" -#define G_CSET_LATINC "\300\301\302\303\304\305\306"\ - "\307\310\311\312\313\314\315\316\317\320"\ - "\321\322\323\324\325\326"\ - "\330\331\332\333\334\335\336" -#define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\ - "\347\350\351\352\353\354\355\356\357\360"\ - "\361\362\363\364\365\366"\ - "\370\371\372\373\374\375\376\377" - -/* Error types */ -typedef enum -{ - G_ERR_UNKNOWN, - G_ERR_UNEXP_EOF, - G_ERR_UNEXP_EOF_IN_STRING, - G_ERR_UNEXP_EOF_IN_COMMENT, - G_ERR_NON_DIGIT_IN_CONST, - G_ERR_DIGIT_RADIX, - G_ERR_FLOAT_RADIX, - G_ERR_FLOAT_MALFORMED -} GErrorType; - -/* Token types */ -typedef enum -{ - G_TOKEN_EOF = 0, - - G_TOKEN_LEFT_PAREN = '(', - G_TOKEN_RIGHT_PAREN = ')', - G_TOKEN_LEFT_CURLY = '{', - G_TOKEN_RIGHT_CURLY = '}', - G_TOKEN_LEFT_BRACE = '[', - G_TOKEN_RIGHT_BRACE = ']', - G_TOKEN_EQUAL_SIGN = '=', - G_TOKEN_COMMA = ',', - - G_TOKEN_NONE = 256, - - G_TOKEN_ERROR, - - G_TOKEN_CHAR, - G_TOKEN_BINARY, - G_TOKEN_OCTAL, - G_TOKEN_INT, - G_TOKEN_HEX, - G_TOKEN_FLOAT, - G_TOKEN_STRING, - - G_TOKEN_SYMBOL, - G_TOKEN_IDENTIFIER, - G_TOKEN_IDENTIFIER_NULL, - - G_TOKEN_COMMENT_SINGLE, - G_TOKEN_COMMENT_MULTI, - G_TOKEN_LAST -} GTokenType; - -union _GTokenValue -{ - gpointer v_symbol; - gchar *v_identifier; - gulong v_binary; - gulong v_octal; - gulong v_int; - gdouble v_float; - gulong v_hex; - gchar *v_string; - gchar *v_comment; - guchar v_char; - guint v_error; -}; - -struct _GScannerConfig -{ - /* Character sets - */ - gchar *cset_skip_characters; /* default: " \t\n" */ - gchar *cset_identifier_first; - gchar *cset_identifier_nth; - gchar *cpair_comment_single; /* default: "#\n" */ - - /* Should symbol lookup work case sensitive? - */ - guint case_sensitive : 1; - - /* Boolean values to be adjusted "on the fly" - * to configure scanning behaviour. - */ - guint skip_comment_multi : 1; /* C like comment */ - guint skip_comment_single : 1; /* single line comment */ - guint scan_comment_multi : 1; /* scan multi line comments? */ - guint scan_identifier : 1; - guint scan_identifier_1char : 1; - guint scan_identifier_NULL : 1; - guint scan_symbols : 1; - guint scan_binary : 1; - guint scan_octal : 1; - guint scan_float : 1; - guint scan_hex : 1; /* `0x0ff0' */ - guint scan_hex_dollar : 1; /* `$0ff0' */ - guint scan_string_sq : 1; /* string: 'anything' */ - guint scan_string_dq : 1; /* string: "\\-escapes!\n" */ - guint numbers_2_int : 1; /* bin, octal, hex => int */ - guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */ - guint identifier_2_string : 1; - guint char_2_token : 1; /* return G_TOKEN_CHAR? */ - guint symbol_2_token : 1; - guint scope_0_fallback : 1; /* try scope 0 on lookups? */ -}; - -struct _GScanner -{ - /* unused fields */ - gpointer user_data; - guint max_parse_errors; - - /* g_scanner_error() increments this field */ - guint parse_errors; - - /* name of input stream, featured by the default message handler */ - const gchar *input_name; - - /* data pointer for derived structures */ - gpointer derived_data; - - /* link into the scanner configuration */ - GScannerConfig *config; - - /* fields filled in after g_scanner_get_next_token() */ - GTokenType token; - GTokenValue value; - guint line; - guint position; - - /* fields filled in after g_scanner_peek_next_token() */ - GTokenType next_token; - GTokenValue next_value; - guint next_line; - guint next_position; - - /* to be considered private */ - GHashTable *symbol_table; - gint input_fd; - const gchar *text; - const gchar *text_end; - gchar *buffer; - guint scope_id; - - /* handler function for _warn and _error */ - GScannerMsgFunc msg_handler; -}; - -GScanner* g_scanner_new (GScannerConfig *config_templ); -void g_scanner_destroy (GScanner *scanner); -void g_scanner_input_file (GScanner *scanner, - gint input_fd); -void g_scanner_sync_file_offset (GScanner *scanner); -void g_scanner_input_text (GScanner *scanner, - const gchar *text, - guint text_len); -GTokenType g_scanner_get_next_token (GScanner *scanner); -GTokenType g_scanner_peek_next_token (GScanner *scanner); -GTokenType g_scanner_cur_token (GScanner *scanner); -GTokenValue g_scanner_cur_value (GScanner *scanner); -guint g_scanner_cur_line (GScanner *scanner); -guint g_scanner_cur_position (GScanner *scanner); -gboolean g_scanner_eof (GScanner *scanner); -guint g_scanner_set_scope (GScanner *scanner, - guint scope_id); -void g_scanner_scope_add_symbol (GScanner *scanner, - guint scope_id, - const gchar *symbol, - gpointer value); -void g_scanner_scope_remove_symbol (GScanner *scanner, - guint scope_id, - const gchar *symbol); -gpointer g_scanner_scope_lookup_symbol (GScanner *scanner, - guint scope_id, - const gchar *symbol); -void g_scanner_scope_foreach_symbol (GScanner *scanner, - guint scope_id, - GHFunc func, - gpointer user_data); -gpointer g_scanner_lookup_symbol (GScanner *scanner, - const gchar *symbol); -void g_scanner_freeze_symbol_table (GScanner *scanner); -void g_scanner_thaw_symbol_table (GScanner *scanner); -void g_scanner_unexp_token (GScanner *scanner, - GTokenType expected_token, - const gchar *identifier_spec, - const gchar *symbol_spec, - const gchar *symbol_name, - const gchar *message, - gint is_error); -void g_scanner_error (GScanner *scanner, - const gchar *format, - ...) G_GNUC_PRINTF (2,3); -void g_scanner_warn (GScanner *scanner, - const gchar *format, - ...) G_GNUC_PRINTF (2,3); -gint g_scanner_stat_mode (const gchar *filename); -/* keep downward source compatibility */ -#define g_scanner_add_symbol( scanner, symbol, value ) G_STMT_START { \ - g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \ -} G_STMT_END -#define g_scanner_remove_symbol( scanner, symbol ) G_STMT_START { \ - g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \ -} G_STMT_END -#define g_scanner_foreach_symbol( scanner, func, data ) G_STMT_START { \ - g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \ -} G_STMT_END - - -/* GCompletion - */ - -struct _GCompletion -{ - GList* items; - GCompletionFunc func; - - gchar* prefix; - GList* cache; -}; - -GCompletion* g_completion_new (GCompletionFunc func); -void g_completion_add_items (GCompletion* cmp, - GList* items); -void g_completion_remove_items (GCompletion* cmp, - GList* items); -void g_completion_clear_items (GCompletion* cmp); -GList* g_completion_complete (GCompletion* cmp, - gchar* prefix, - gchar** new_prefix); -void g_completion_free (GCompletion* cmp); - - -/* GDate - * - * Date calculations (not time for now, to be resolved). These are a - * mutant combination of Steffen Beyer's DateCalc routines - * (http://www.perl.com/CPAN/authors/id/STBEY/) and Jon Trowbridge's - * date routines (written for in-house software). Written by Havoc - * Pennington - */ - -typedef guint16 GDateYear; -typedef guint8 GDateDay; /* day of the month */ -typedef struct _GDate GDate; -/* make struct tm known without having to include time.h */ -struct tm; - -/* enum used to specify order of appearance in parsed date strings */ -typedef enum -{ - G_DATE_DAY = 0, - G_DATE_MONTH = 1, - G_DATE_YEAR = 2 -} GDateDMY; - -/* actual week and month values */ -typedef enum -{ - G_DATE_BAD_WEEKDAY = 0, - G_DATE_MONDAY = 1, - G_DATE_TUESDAY = 2, - G_DATE_WEDNESDAY = 3, - G_DATE_THURSDAY = 4, - G_DATE_FRIDAY = 5, - G_DATE_SATURDAY = 6, - G_DATE_SUNDAY = 7 -} GDateWeekday; -typedef enum -{ - G_DATE_BAD_MONTH = 0, - G_DATE_JANUARY = 1, - G_DATE_FEBRUARY = 2, - G_DATE_MARCH = 3, - G_DATE_APRIL = 4, - G_DATE_MAY = 5, - G_DATE_JUNE = 6, - G_DATE_JULY = 7, - G_DATE_AUGUST = 8, - G_DATE_SEPTEMBER = 9, - G_DATE_OCTOBER = 10, - G_DATE_NOVEMBER = 11, - G_DATE_DECEMBER = 12 -} GDateMonth; - -#define G_DATE_BAD_JULIAN 0U -#define G_DATE_BAD_DAY 0U -#define G_DATE_BAD_YEAR 0U - -/* Note: directly manipulating structs is generally a bad idea, but - * in this case it's an *incredibly* bad idea, because all or part - * of this struct can be invalid at any given time. Use the functions, - * or you will get hosed, I promise. - */ -struct _GDate -{ - guint julian_days : 32; /* julian days representation - we use a - * bitfield hoping that 64 bit platforms - * will pack this whole struct in one big - * int - */ - - guint julian : 1; /* julian is valid */ - guint dmy : 1; /* dmy is valid */ - - /* DMY representation */ - guint day : 6; - guint month : 4; - guint year : 16; -}; - -/* g_date_new() returns an invalid date, you then have to _set() stuff - * to get a usable object. You can also allocate a GDate statically, - * then call g_date_clear() to initialize. - */ -GDate* g_date_new (void); -GDate* g_date_new_dmy (GDateDay day, - GDateMonth month, - GDateYear year); -GDate* g_date_new_julian (guint32 julian_day); -void g_date_free (GDate *date); - -/* check g_date_valid() after doing an operation that might fail, like - * _parse. Almost all g_date operations are undefined on invalid - * dates (the exceptions are the mutators, since you need those to - * return to validity). - */ -gboolean g_date_valid (GDate *date); -gboolean g_date_valid_day (GDateDay day); -gboolean g_date_valid_month (GDateMonth month); -gboolean g_date_valid_year (GDateYear year); -gboolean g_date_valid_weekday (GDateWeekday weekday); -gboolean g_date_valid_julian (guint32 julian_date); -gboolean g_date_valid_dmy (GDateDay day, - GDateMonth month, - GDateYear year); - -GDateWeekday g_date_weekday (GDate *date); -GDateMonth g_date_month (GDate *date); -GDateYear g_date_year (GDate *date); -GDateDay g_date_day (GDate *date); -guint32 g_date_julian (GDate *date); -guint g_date_day_of_year (GDate *date); - -/* First monday/sunday is the start of week 1; if we haven't reached - * that day, return 0. These are not ISO weeks of the year; that - * routine needs to be added. - * these functions return the number of weeks, starting on the - * corrsponding day - */ -guint g_date_monday_week_of_year (GDate *date); -guint g_date_sunday_week_of_year (GDate *date); - -/* If you create a static date struct you need to clear it to get it - * in a sane state before use. You can clear a whole array at - * once with the ndates argument. - */ -void g_date_clear (GDate *date, - guint n_dates); - -/* The parse routine is meant for dates typed in by a user, so it - * permits many formats but tries to catch common typos. If your data - * needs to be strictly validated, it is not an appropriate function. - */ -void g_date_set_parse (GDate *date, - const gchar *str); -void g_date_set_time (GDate *date, - GTime time); -void g_date_set_month (GDate *date, - GDateMonth month); -void g_date_set_day (GDate *date, - GDateDay day); -void g_date_set_year (GDate *date, - GDateYear year); -void g_date_set_dmy (GDate *date, - GDateDay day, - GDateMonth month, - GDateYear y); -void g_date_set_julian (GDate *date, - guint32 julian_date); -gboolean g_date_is_first_of_month (GDate *date); -gboolean g_date_is_last_of_month (GDate *date); - -/* To go forward by some number of weeks just go forward weeks*7 days */ -void g_date_add_days (GDate *date, - guint n_days); -void g_date_subtract_days (GDate *date, - guint n_days); - -/* If you add/sub months while day > 28, the day might change */ -void g_date_add_months (GDate *date, - guint n_months); -void g_date_subtract_months (GDate *date, - guint n_months); - -/* If it's feb 29, changing years can move you to the 28th */ -void g_date_add_years (GDate *date, - guint n_years); -void g_date_subtract_years (GDate *date, - guint n_years); -gboolean g_date_is_leap_year (GDateYear year); -guint8 g_date_days_in_month (GDateMonth month, - GDateYear year); -guint8 g_date_monday_weeks_in_year (GDateYear year); -guint8 g_date_sunday_weeks_in_year (GDateYear year); - -/* qsort-friendly (with a cast...) */ -gint g_date_compare (GDate *lhs, - GDate *rhs); -void g_date_to_struct_tm (GDate *date, - struct tm *tm); - -/* Just like strftime() except you can only use date-related formats. - * Using a time format is undefined. - */ -gsize g_date_strftime (gchar *s, - gsize slen, - const gchar *format, - GDate *date); - - -/* GRelation - * - * Indexed Relations. Imagine a really simple table in a - * database. Relations are not ordered. This data type is meant for - * maintaining a N-way mapping. - * - * g_relation_new() creates a relation with FIELDS fields - * - * g_relation_destroy() frees all resources - * g_tuples_destroy() frees the result of g_relation_select() - * - * g_relation_index() indexes relation FIELD with the provided - * equality and hash functions. this must be done before any - * calls to insert are made. - * - * g_relation_insert() inserts a new tuple. you are expected to - * provide the right number of fields. - * - * g_relation_delete() deletes all relations with KEY in FIELD - * g_relation_select() returns ... - * g_relation_count() counts ... - */ - -GRelation* g_relation_new (gint fields); -void g_relation_destroy (GRelation *relation); -void g_relation_index (GRelation *relation, - gint field, - GHashFunc hash_func, - GCompareFunc key_compare_func); -void g_relation_insert (GRelation *relation, - ...); -gint g_relation_delete (GRelation *relation, - gconstpointer key, - gint field); -GTuples* g_relation_select (GRelation *relation, - gconstpointer key, - gint field); -gint g_relation_count (GRelation *relation, - gconstpointer key, - gint field); -gboolean g_relation_exists (GRelation *relation, - ...); -void g_relation_print (GRelation *relation); - -void g_tuples_destroy (GTuples *tuples); -gpointer g_tuples_index (GTuples *tuples, - gint index, - gint field); - - -/* Prime numbers. - */ - -/* This function returns prime numbers spaced by approximately 1.5-2.0 - * and is for use in resizing data structures which prefer - * prime-valued sizes. The closest spaced prime function returns the - * next largest prime, or the highest it knows about which is about - * MAXINT/4. - */ -guint g_spaced_primes_closest (guint num); - - -/* GIOChannel - */ - -typedef struct _GIOFuncs GIOFuncs; -typedef enum -{ - G_IO_ERROR_NONE, - G_IO_ERROR_AGAIN, - G_IO_ERROR_INVAL, - G_IO_ERROR_UNKNOWN -} GIOError; -typedef enum -{ - G_SEEK_CUR, - G_SEEK_SET, - G_SEEK_END -} GSeekType; -typedef enum -{ - G_IO_IN GLIB_SYSDEF_POLLIN, - G_IO_OUT GLIB_SYSDEF_POLLOUT, - G_IO_PRI GLIB_SYSDEF_POLLPRI, - G_IO_ERR GLIB_SYSDEF_POLLERR, - G_IO_HUP GLIB_SYSDEF_POLLHUP, - G_IO_NVAL GLIB_SYSDEF_POLLNVAL -} GIOCondition; - -struct _GIOChannel -{ - guint channel_flags; - guint ref_count; - GIOFuncs *funcs; -}; - -typedef gboolean (*GIOFunc) (GIOChannel *source, - GIOCondition condition, - gpointer data); -struct _GIOFuncs -{ - GIOError (*io_read) (GIOChannel *channel, - gchar *buf, - guint count, - guint *bytes_read); - GIOError (*io_write) (GIOChannel *channel, - gchar *buf, - guint count, - guint *bytes_written); - GIOError (*io_seek) (GIOChannel *channel, - gint offset, - GSeekType type); - void (*io_close) (GIOChannel *channel); - guint (*io_add_watch) (GIOChannel *channel, - gint priority, - GIOCondition condition, - GIOFunc func, - gpointer user_data, - GDestroyNotify notify); - void (*io_free) (GIOChannel *channel); -}; - -void g_io_channel_init (GIOChannel *channel); -void g_io_channel_ref (GIOChannel *channel); -void g_io_channel_unref (GIOChannel *channel); -GIOError g_io_channel_read (GIOChannel *channel, - gchar *buf, - guint count, - guint *bytes_read); -GIOError g_io_channel_write (GIOChannel *channel, - gchar *buf, - guint count, - guint *bytes_written); -GIOError g_io_channel_seek (GIOChannel *channel, - gint offset, - GSeekType type); -void g_io_channel_close (GIOChannel *channel); -guint g_io_add_watch_full (GIOChannel *channel, - gint priority, - GIOCondition condition, - GIOFunc func, - gpointer user_data, - GDestroyNotify notify); -guint g_io_add_watch (GIOChannel *channel, - GIOCondition condition, - GIOFunc func, - gpointer user_data); - - -/* Main loop - */ -typedef struct _GTimeVal GTimeVal; -typedef struct _GSourceFuncs GSourceFuncs; -typedef struct _GMainLoop GMainLoop; /* Opaque */ - -struct _GTimeVal -{ - glong tv_sec; - glong tv_usec; -}; -struct _GSourceFuncs -{ - gboolean (*prepare) (gpointer source_data, - GTimeVal *current_time, - gint *timeout, - gpointer user_data); - gboolean (*check) (gpointer source_data, - GTimeVal *current_time, - gpointer user_data); - gboolean (*dispatch) (gpointer source_data, - GTimeVal *current_time, - gpointer user_data); - GDestroyNotify destroy; -}; - -/* Standard priorities */ - -#define G_PRIORITY_HIGH -100 -#define G_PRIORITY_DEFAULT 0 -#define G_PRIORITY_HIGH_IDLE 100 -#define G_PRIORITY_DEFAULT_IDLE 200 -#define G_PRIORITY_LOW 300 - -typedef gboolean (*GSourceFunc) (gpointer data); - -/* Hooks for adding to the main loop */ -guint g_source_add (gint priority, - gboolean can_recurse, - GSourceFuncs *funcs, - gpointer source_data, - gpointer user_data, - GDestroyNotify notify); -gboolean g_source_remove (guint tag); -gboolean g_source_remove_by_user_data (gpointer user_data); -gboolean g_source_remove_by_source_data (gpointer source_data); -gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs, - gpointer user_data); - -void g_get_current_time (GTimeVal *result); - -/* Running the main loop */ -GMainLoop* g_main_new (gboolean is_running); -void g_main_run (GMainLoop *loop); -void g_main_quit (GMainLoop *loop); -void g_main_destroy (GMainLoop *loop); -gboolean g_main_is_running (GMainLoop *loop); - -/* Run a single iteration of the mainloop. If block is FALSE, - * will never block - */ -gboolean g_main_iteration (gboolean may_block); - -/* See if any events are pending */ -gboolean g_main_pending (void); - -/* Idles and timeouts */ -guint g_timeout_add_full (gint priority, - guint interval, - GSourceFunc function, - gpointer data, - GDestroyNotify notify); -guint g_timeout_add (guint interval, - GSourceFunc function, - gpointer data); -guint g_idle_add (GSourceFunc function, - gpointer data); -guint g_idle_add_full (gint priority, - GSourceFunc function, - gpointer data, - GDestroyNotify destroy); -gboolean g_idle_remove_by_data (gpointer data); - -/* GPollFD - * - * System-specific IO and main loop calls - * - * On Win32, the fd in a GPollFD should be Win32 HANDLE (*not* a file - * descriptor as provided by the C runtime) that can be used by - * MsgWaitForMultipleObjects. This does *not* include file handles - * from CreateFile, SOCKETs, nor pipe handles. (But you can use - * WSAEventSelect to signal events when a SOCKET is readable). - * - * On Win32, fd can also be the special value G_WIN32_MSG_HANDLE to - * indicate polling for messages. These message queue GPollFDs should - * be added with the g_main_poll_win32_msg_add function. - * - * But note that G_WIN32_MSG_HANDLE GPollFDs should not be used by GDK - * (GTK) programs, as GDK itself wants to read messages and convert them - * to GDK events. - * - * So, unless you really know what you are doing, it's best not to try - * to use the main loop polling stuff for your own needs on - * Win32. It's really only written for the GIMP's needs so - * far. - */ - -typedef struct _GPollFD GPollFD; -typedef gint (*GPollFunc) (GPollFD *ufds, - guint nfsd, - gint timeout); -struct _GPollFD -{ - gint fd; - gushort events; - gushort revents; -}; - -void g_main_add_poll (GPollFD *fd, - gint priority); -void g_main_remove_poll (GPollFD *fd); -void g_main_set_poll_func (GPollFunc func); - -/* On Unix, IO channels created with this function for any file - * descriptor or socket. - * - * On Win32, use this only for plain files opened with the MSVCRT (the - * Microsoft run-time C library) _open(), including file descriptors - * 0, 1 and 2 (corresponding to stdin, stdout and stderr). - * Actually, don't do even that, this code isn't done yet. - * - * The term file descriptor as used in the context of Win32 refers to - * the emulated Unix-like file descriptors MSVCRT provides. - */ -GIOChannel* g_io_channel_unix_new (int fd); -gint g_io_channel_unix_get_fd (GIOChannel *channel); - -#ifdef NATIVE_WIN32 - -GUTILS_C_VAR guint g_pipe_readable_msg; - -#define G_WIN32_MSG_HANDLE 19981206 - -/* This is used to add polling for Windows messages. GDK (GTk+) programs - * should *not* use this. (In fact, I can't think of any program that - * would want to use this, but it's here just for completeness's sake. - */ -void g_main_poll_win32_msg_add(gint priority, - GPollFD *fd, - guint hwnd); - -/* An IO channel for Windows messages for window handle hwnd. */ -GIOChannel *g_io_channel_win32_new_messages (guint hwnd); - -/* An IO channel for an anonymous pipe as returned from the MSVCRT - * _pipe(), with no mechanism for the writer to tell the reader when - * there is data in the pipe. - * - * This is not really implemented yet. - */ -GIOChannel *g_io_channel_win32_new_pipe (int fd); - -/* An IO channel for a pipe as returned from the MSVCRT _pipe(), with - * Windows user messages used to signal data in the pipe for the - * reader. - * - * fd is the file descriptor. For the write end, peer is the thread id - * of the reader, and peer_fd is his file descriptor for the read end - * of the pipe. - * - * This is used by the GIMP, and works. - */ -GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd, - guint peer, - int peer_fd); - -void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel, - guint peer, - int peer_fd); - -void g_io_channel_win32_pipe_readable (int fd, - guint offset); - -/* Get the C runtime file descriptor of a channel. */ -gint g_io_channel_win32_get_fd (GIOChannel *channel); - -/* An IO channel for a SOCK_STREAM winsock socket. The parameter is - * actually a SOCKET. - */ -GIOChannel *g_io_channel_win32_new_stream_socket (int socket); - -#endif - -/* Windows emulation stubs for common Unix functions - */ -#ifdef NATIVE_WIN32 -# define MAXPATHLEN 1024 -# ifdef _MSC_VER -typedef int pid_t; - -/* These POSIXish functions are available in the Microsoft C library - * prefixed with underscore (which of course technically speaking is - * the Right Thing, as they are non-ANSI. Not that being non-ANSI - * prevents Microsoft from practically requiring you to include - * every now and then...). - * - * You still need to include the appropriate headers to get the - * prototypes, or . - * - * For some functions, we provide emulators in glib, which are prefixed - * with gwin_. - */ -# define getcwd _getcwd -# define getpid _getpid -# define access _access -# define open _open -# define read _read -# define write _write -# define lseek _lseek -# define close _close -# define pipe(phandles) _pipe (phandles, 4096, _O_BINARY) -# define popen _popen -# define pclose _pclose -# define fdopen _fdopen -# define ftruncate(fd, size) gwin_ftruncate (fd, size) -# define opendir gwin_opendir -# define readdir gwin_readdir -# define rewinddir gwin_rewinddir -# define closedir gwin_closedir -# define NAME_MAX 255 -struct DIR -{ - gchar *dir_name; - gboolean just_opened; - guint find_file_handle; - gpointer find_file_data; -}; -typedef struct DIR DIR; -struct dirent -{ - gchar d_name[NAME_MAX + 1]; -}; -/* emulation functions */ -extern int gwin_ftruncate (gint f, - guint size); -DIR* gwin_opendir (const gchar *dirname); -struct dirent* gwin_readdir (DIR *dir); -void gwin_rewinddir (DIR *dir); -gint gwin_closedir (DIR *dir); -# endif /* _MSC_VER */ -#endif /* NATIVE_WIN32 */ - - -/* GLib Thread support - */ -typedef struct _GMutex GMutex; -typedef struct _GCond GCond; -typedef struct _GPrivate GPrivate; -typedef struct _GStaticPrivate GStaticPrivate; -typedef struct _GThreadFunctions GThreadFunctions; -struct _GThreadFunctions -{ - GMutex* (*mutex_new) (void); - void (*mutex_lock) (GMutex *mutex); - gboolean (*mutex_trylock) (GMutex *mutex); - void (*mutex_unlock) (GMutex *mutex); - void (*mutex_free) (GMutex *mutex); - GCond* (*cond_new) (void); - void (*cond_signal) (GCond *cond); - void (*cond_broadcast) (GCond *cond); - void (*cond_wait) (GCond *cond, - GMutex *mutex); - gboolean (*cond_timed_wait) (GCond *cond, - GMutex *mutex, - GTimeVal *end_time); - void (*cond_free) (GCond *cond); - GPrivate* (*private_new) (GDestroyNotify destructor); - gpointer (*private_get) (GPrivate *private_key); - void (*private_set) (GPrivate *private_key, - gpointer data); -}; - -GUTILS_C_VAR GThreadFunctions g_thread_functions_for_glib_use; -GUTILS_C_VAR gboolean g_thread_use_default_impl; -GUTILS_C_VAR gboolean g_threads_got_initialized; - -/* initializes the mutex/cond/private implementation for glib, might - * only be called once, and must not be called directly or indirectly - * from another glib-function, e.g. as a callback. - */ -void g_thread_init (GThreadFunctions *vtable); - -/* internal function for fallback static mutex implementation */ -GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex); - -/* shorthands for conditional and unconditional function calls */ -#define G_THREAD_UF(name, arglist) \ - (*g_thread_functions_for_glib_use . name) arglist -#define G_THREAD_CF(name, fail, arg) \ - (g_thread_supported () ? G_THREAD_UF (name, arg) : (fail)) -/* keep in mind, all those mutexes and static mutexes are not - * recursive in general, don't rely on that - */ -#define g_thread_supported() (g_threads_got_initialized) -#define g_mutex_new() G_THREAD_UF (mutex_new, ()) -#define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex)) -#define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex)) -#define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex)) -#define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex)) -#define g_cond_new() G_THREAD_UF (cond_new, ()) -#define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond)) -#define g_cond_broadcast(cond) G_THREAD_CF (cond_broadcast, (void)0, (cond)) -#define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait, (void)0, (cond, \ - mutex)) -#define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond)) -#define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \ - TRUE, \ - (cond, mutex, \ - abs_time)) -#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor)) -#define g_private_get(private_key) G_THREAD_CF (private_get, \ - ((gpointer)private_key), \ - (private_key)) -#define g_private_set(private_key, value) G_THREAD_CF (private_set, \ - (void) (private_key = \ - (GPrivate*) (value)), \ - (private_key, value)) -/* GStaticMutexes can be statically initialized with the value - * G_STATIC_MUTEX_INIT, and then they can directly be used, that is - * much easier, than having to explicitly allocate the mutex before - * use - */ -#define g_static_mutex_lock(mutex) \ - g_mutex_lock (g_static_mutex_get_mutex (mutex)) -#define g_static_mutex_trylock(mutex) \ - g_mutex_trylock (g_static_mutex_get_mutex (mutex)) -#define g_static_mutex_unlock(mutex) \ - g_mutex_unlock (g_static_mutex_get_mutex (mutex)) -struct _GStaticPrivate -{ - guint index; -}; -#define G_STATIC_PRIVATE_INIT { 0 } -gpointer g_static_private_get (GStaticPrivate *private_key); -void g_static_private_set (GStaticPrivate *private_key, - gpointer data, - GDestroyNotify notify); - -/* these are some convenience macros that expand to nothing if GLib - * was configured with --disable-threads. for using StaticMutexes, - * you define them with G_LOCK_DEFINE_STATIC (name) or G_LOCK_DEFINE (name) - * if you need to export the mutex. With G_LOCK_EXTERN (name) you can - * declare such an globally defined lock. name is a unique identifier - * for the protected varibale or code portion. locking, testing and - * unlocking of such mutexes can be done with G_LOCK(), G_UNLOCK() and - * G_TRYLOCK() respectively. - */ -extern void glib_dummy_decl (void); -#define G_LOCK_NAME(name) (g__ ## name ## _lock) -#ifdef G_THREADS_ENABLED -# define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name) -# define G_LOCK_DEFINE(name) \ - GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT -# define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name) - -# ifdef G_DEBUG_LOCKS -# define G_LOCK(name) G_STMT_START{ \ - g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ - "file %s: line %d (%s): locking: %s ", \ - __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ - #name); \ - g_static_mutex_lock (&G_LOCK_NAME (name)); \ - }G_STMT_END -# define G_UNLOCK(name) G_STMT_START{ \ - g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ - "file %s: line %d (%s): unlocking: %s ", \ - __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ - #name); \ - g_static_mutex_unlock (&G_LOCK_NAME (name)); \ - }G_STMT_END -# define G_TRYLOCK(name) G_STMT_START{ \ - g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ - "file %s: line %d (%s): try locking: %s ", \ - __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ - #name); \ - }G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name)) -# else /* !G_DEBUG_LOCKS */ -# define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name)) -# define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name)) -# define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name)) -# endif /* !G_DEBUG_LOCKS */ -#else /* !G_THREADS_ENABLED */ -# define G_LOCK_DEFINE_STATIC(name) extern void glib_dummy_decl (void) -# define G_LOCK_DEFINE(name) extern void glib_dummy_decl (void) -# define G_LOCK_EXTERN(name) extern void glib_dummy_decl (void) -# define G_LOCK(name) -# define G_UNLOCK(name) -# define G_TRYLOCK(name) (FALSE) -#endif /* !G_THREADS_ENABLED */ - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - - -#endif /* __G_LIB_H__ */ diff -urN gale-0.91a/liboop/foreign/glibconfig.h gale-0.91b/liboop/foreign/glibconfig.h --- gale-0.91a/liboop/foreign/glibconfig.h Sun Sep 5 17:35:21 1999 +++ gale-0.91b/liboop/foreign/glibconfig.h Wed Dec 31 16:00:00 1969 @@ -1,32 +0,0 @@ -/* glibconfig.h spoof -- exists only to make glib.h work */ - -#ifndef GLIBCONFIG_H_SPOOF -#define GLIBCONFIG_H_SPOOF - -/* cheesy */ -typedef unsigned char guint8; -typedef unsigned short guint16; -typedef unsigned int guint32; -typedef int gint32; - -#ifdef HAVE_POLL_H -#include -#endif - -#if defined(POLLIN) && defined(POLLOUT) -#define GLIB_SYSDEF_POLLIN =POLLIN -#define GLIB_SYSDEF_POLLOUT =POLLOUT -#define GLIB_SYSDEF_POLLPRI =POLLPRI -#define GLIB_SYSDEF_POLLERR =POLLERR -#define GLIB_SYSDEF_POLLHUP =POLLHUP -#define GLIB_SYSDEF_POLLNVAL =POLLNVAL -#else -#define GLIB_SYSDEF_POLLIN =1 -#define GLIB_SYSDEF_POLLOUT =4 -#define GLIB_SYSDEF_POLLPRI =2 -#define GLIB_SYSDEF_POLLERR =8 -#define GLIB_SYSDEF_POLLHUP =16 -#define GLIB_SYSDEF_POLLNVAL =32 -#endif - -#endif diff -urN gale-0.91a/liboop/foreign/wwwsys.h gale-0.91b/liboop/foreign/wwwsys.h --- gale-0.91a/liboop/foreign/wwwsys.h Sat Sep 4 14:37:38 1999 +++ gale-0.91b/liboop/foreign/wwwsys.h Wed Dec 31 16:00:00 1969 @@ -1,9 +0,0 @@ -/* wwwsys.h spoof -- exists only to make HTEvent.h work */ - -#ifndef WWWSYS_H_SPOOF -#define WWWSYS_H_SPOOF - -typedef char BOOL; -typedef int SOCKET; - -#endif diff -urN gale-0.91a/liboop/glib.c gale-0.91b/liboop/glib.c --- gale-0.91a/liboop/glib.c Mon Oct 11 19:55:09 1999 +++ gale-0.91b/liboop/glib.c Sun Jan 30 21:27:14 2000 @@ -4,6 +4,8 @@ terms of the GNU Lesser General Public License, version 2.1 or later. See the file COPYING for details. */ +#ifdef HAVE_GLIB + #include "glib.h" #include "oop-glib.h" #include "oop.h" @@ -104,4 +106,6 @@ oop_sys_delete(sys); g_main_set_poll_func(real_poll); } +#endif + #endif diff -urN gale-0.91a/liboop/www.c gale-0.91b/liboop/www.c --- gale-0.91a/liboop/www.c Sun Oct 3 10:28:23 1999 +++ gale-0.91b/liboop/www.c Sun Jan 30 21:27:46 2000 @@ -4,6 +4,8 @@ terms of the GNU Lesser General Public License, version 2.1 or later. See the file COPYING for details. */ +#ifdef HAVE_WWW + /* Yecch: the libwww header files need this. */ #define HAVE_CONFIG_H #undef PACKAGE @@ -183,3 +185,5 @@ oop_malloc = HTMemory_malloc; oop_free = HTMemory_free; } + +#endif