-
+ B130326CE04125D505761664BF84F3B71836FB198BF39CFECDF464D02103B26015149CABB3D4107D59D4EBF6CC94E8E456916766CC095EE4DB35605718454D79
mpi/bin/README

(0 . 0)(1 . 1)
bin

- 2637E827D61AC5BE58C3CC88799EAF49DAED6C957ED6C6647B6D8D787E4F7FD731CDD16DB53CB1FA15E35230E918CD62DA33B4DD410CC073CA4092BC973F5AD1
+
mpi/errors.c

(1 . 113)(0 . 0)
/* errors.c  -	error strings
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

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

#include "errors.h"

#ifndef HAVE_STRERROR
char *
strerror( int n )
{
    extern char *sys_errlist[];
    extern int sys_nerr;
    static char buf[15];

    if( n >= 0 && n < sys_nerr )
	return sys_errlist[n];
    strcpy( buf, "Unknown error" );
    return buf;
}
#endif /* !HAVE_STRERROR */

const char *
g10_errstr( int err )
{
    static char buf[50];
    const char *p;

#define X(n,s) case G10ERR_##n : p = s; break;
    switch( err ) {
      case -1:		p = "eof"; break;
      case 0:		p = "okay"; break;
      X(GENERAL,	N_("general error"))
      X(UNKNOWN_PACKET, N_("unknown packet type"))
      X(UNKNOWN_VERSION,N_("unknown version"))
      X(PUBKEY_ALGO    ,N_("unknown pubkey algorithm"))
      X(DIGEST_ALGO    ,N_("unknown digest algorithm"))
      X(BAD_PUBKEY     ,N_("bad public key"))
      X(BAD_SECKEY     ,N_("bad secret key"))
      X(BAD_SIGN       ,N_("bad signature"))
      X(CHECKSUM   ,	N_("checksum error"))
      X(BAD_PASS     ,	N_("bad passphrase"))
      X(NO_PUBKEY      ,N_("public key not found"))
      X(CIPHER_ALGO    ,N_("unknown cipher algorithm"))
      X(KEYRING_OPEN   ,N_("can't open the keyring"))
      X(INVALID_PACKET ,N_("invalid packet"))
      X(INVALID_ARMOR  ,N_("invalid armor"))
      X(NO_USER_ID     ,N_("no such user id"))
      X(NO_SECKEY      ,N_("secret key not available"))
      X(WRONG_SECKEY   ,N_("wrong secret key used"))
      X(UNSUPPORTED    ,N_("not supported"))
      X(BAD_KEY        ,N_("bad key"))
      X(READ_FILE      ,N_("file read error"))
      X(WRITE_FILE     ,N_("file write error"))
      X(COMPR_ALGO     ,N_("unknown compress algorithm"))
      X(OPEN_FILE      ,N_("file open error"))
      X(CREATE_FILE    ,N_("file create error"))
      X(PASSPHRASE     ,N_("invalid passphrase"))
      X(NI_PUBKEY      ,N_("unimplemented pubkey algorithm"))
      X(NI_CIPHER      ,N_("unimplemented cipher algorithm"))
      X(SIG_CLASS      ,N_("unknown signature class"))
      X(TRUSTDB        ,N_("trust database error"))
      X(BAD_MPI        ,N_("bad MPI"))
      X(RESOURCE_LIMIT ,N_("resource limit"))
      X(INV_KEYRING    ,N_("invalid keyring"))
      X(BAD_CERT       ,N_("bad certificate"))
      X(INV_USER_ID    ,N_("malformed user id"))
      X(CLOSE_FILE     ,N_("file close error"))
      X(RENAME_FILE    ,N_("file rename error"))
      X(DELETE_FILE    ,N_("file delete error"))
      X(UNEXPECTED     ,N_("unexpected data"))
      X(TIME_CONFLICT  ,N_("timestamp conflict"))
      X(WR_PUBKEY_ALGO ,N_("unusable pubkey algorithm"))
      X(FILE_EXISTS    ,N_("file exists"))
      X(WEAK_KEY       ,N_("weak key"))
      X(INV_ARG        ,N_("invalid argument"))
      X(BAD_URI        ,N_("bad URI"))
      X(INVALID_URI    ,N_("unsupported URI"))
      X(NETWORK        ,N_("network error"))
      X(SELFTEST_FAILED,"selftest failed")
      X(NOT_ENCRYPTED  ,N_("not encrypted"))
      X(NOT_PROCESSED  ,N_("not processed"))
      /* the key cannot be used for a specific usage */
      X(UNU_PUBKEY     ,N_("unusable public key"))
      X(UNU_SECKEY     ,N_("unusable secret key"))
      X(KEYSERVER      ,N_("keyserver error"))
      X(CANCELED       ,N_("canceled"))
      X(NO_CARD        ,N_("no card"))
      X(NO_DATA        ,N_("no data"))
      default: p = buf; sprintf(buf, "g10err=%d", err); break;
    }
#undef X
    return _(p);
}

- CBB804CBF1D96718EEBC82ABDED7FB63514BA10EFD2EB136A606D85BD1896DBEAA0D631CD87BF01C8C1E014350F5664309EC9136A0D4C6EDF63C039227450926
+
mpi/include/compat.h

(1 . 25)(0 . 0)
#ifndef _COMPAT_H_
#define _COMPAT_H_

/* Note this isn't identical to a C locale isspace() without \f and
   \v, but works for the purposes used here. */
#define ascii_isspace(a) ((a)==' ' || (a)=='\n' || (a)=='\r' || (a)=='\t')

int hextobyte( const char *s );
int ascii_toupper (int c);
int ascii_tolower (int c);
int ascii_strcasecmp( const char *a, const char *b );
int ascii_strncasecmp( const char *a, const char *b, size_t n);

#ifndef HAVE_STRSEP
char *strsep (char **stringp, const char *delim);
#endif

#if __GNUC__ >= 4 
char *xstrconcat (const char *s1, ...) __attribute__ ((sentinel(0)));
#else
char *xstrconcat (const char *s1, ...);
#endif


#endif /* !_COMPAT_H_ */

- F16ECF4FD4CFFB8CB4C97BEE3A486E8FEAAA6CE8C2D70FDF6AB80687847AE8700B2DC199476459401505048D1642B4D94FD2E4152D911E8B6D54065DA09EFE66
+
mpi/include/config.h

(1 . 89)(0 . 0)
/* config.h.
   ORIGINALLY Generated from config.h.in by configure.
   Cleaned up by hand. The price of this is that the knobs must
   now be turned by hand.
*/

#ifndef GNUPG_CONFIG_H_INCLUDED
#define GNUPG_CONFIG_H_INCLUDED

/* Define to 1 if you have the `atexit' function. */
#define HAVE_ATEXIT 1

/* Defined if the mlock() call does not work */
/* #undef HAVE_BROKEN_MLOCK */

/* Defined if a `byte' is typedef'd */
/* #undef HAVE_BYTE_TYPEDEF */

/* defined if we run on some of the PCDOS like systems (DOS, Windoze. OS/2)
   with special properties like no file modes */
/* #undef HAVE_DOSISH_SYSTEM */

/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
#define HAVE_FSEEKO 1

/* Define to 1 if you have the `getpagesize' function. */
#define HAVE_GETPAGESIZE 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define to 1 if you have the <locale.h> header file. */
// #undef HAVE_LOCALE_H

/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1

/* Defined if the system supports an mlock() call */
#define HAVE_MLOCK 1

/* Define to 1 if you have the `mmap' function. */
#define HAVE_MMAP 1

/* Define to 1 if you have the `plock' function. */
/* #undef HAVE_PLOCK */

/* Define to 1 if you have the `raise' function. */
#define HAVE_RAISE 1

/* Define to 1 if you have the `stpcpy' function. */
#define HAVE_STPCPY 1

/* Define to 1 if you have the `strcasecmp' function. */
#define HAVE_STRCASECMP 1

/* Define to 1 if you have the `strerror' function. */
#define HAVE_STRERROR 1

/* Define to 1 if you have the `strlwr' function. */
/* #undef HAVE_STRLWR */

/* Define to 1 if you have the `strncasecmp' function. */
#define HAVE_STRNCASECMP 1

/* Define to 1 if you have the `strsep' function. */
#define HAVE_STRSEP 1

/* Define to 1 if you have the `strtoul' function. */
#define HAVE_STRTOUL 1

/* Define to 1 if you have the `sysconf' function. */
#define HAVE_SYSCONF 1

/* Defined if a `u16' is typedef'd */
/* #undef HAVE_U16_TYPEDEF */

/* Defined if a `u32' is typedef'd */
/* #undef HAVE_U32_TYPEDEF */

/* Defined if a `ulong' is typedef'd */
#define HAVE_ULONG_TYPEDEF 1

/* Defined if a `ushort' is typedef'd */
#define HAVE_USHORT_TYPEDEF 1

#endif /*GNUPG_CONFIG_H_INCLUDED*/

- 6C4FAB042DB987C280EA86471C8549A167903CB11073D0B74A426DC78CE9E65A1B66FB2815722ACB069DF807506181548960E60C33EE27C64246672A8457F752
+
mpi/include/errors.h

(1 . 89)(0 . 0)
/* errors.h - erro code
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 *
 * This file is part of GNUPG.
 *
 * GNUPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
#ifndef G10_ERRORS_H
#define G10_ERRORS_H

#define G10ERR_GENERAL	       1
#define G10ERR_UNKNOWN_PACKET  2
#define G10ERR_UNKNOWN_VERSION 3 /* Unknown version (in packet) */
#define G10ERR_PUBKEY_ALGO     4 /* Unknown pubkey algorithm */
#define G10ERR_DIGEST_ALGO     5 /* Unknown digest algorithm */
#define G10ERR_BAD_PUBKEY      6 /* Bad public key */
#define G10ERR_BAD_SECKEY      7 /* Bad secret key */
#define G10ERR_BAD_SIGN        8 /* Bad signature */
#define G10ERR_NO_PUBKEY       9 /* public key not found */
#define G10ERR_CHECKSUM       10 /* checksum error */
#define G10ERR_BAD_PASS       11 /* Bad passphrase */
#define G10ERR_CIPHER_ALGO    12 /* Unknown cipher algorithm */
#define G10ERR_KEYRING_OPEN   13
#define G10ERR_INVALID_PACKET 14
#define G10ERR_INVALID_ARMOR  15
#define G10ERR_NO_USER_ID     16
#define G10ERR_NO_SECKEY      17 /* secret key not available */
#define G10ERR_WRONG_SECKEY   18 /* wrong seckey used */
#define G10ERR_UNSUPPORTED    19
#define G10ERR_BAD_KEY	      20 /* bad (session) key */
#define G10ERR_READ_FILE      21
#define G10ERR_WRITE_FILE     22
#define G10ERR_COMPR_ALGO     23 /* Unknown compress algorithm */
#define G10ERR_OPEN_FILE      24
#define G10ERR_CREATE_FILE    25
#define G10ERR_PASSPHRASE     26 /* invalid passphrase */
#define G10ERR_NI_PUBKEY      27
#define G10ERR_NI_CIPHER      28
#define G10ERR_SIG_CLASS      29
#define G10ERR_BAD_MPI	      30
#define G10ERR_RESOURCE_LIMIT 31
#define G10ERR_INV_KEYRING    32
#define G10ERR_TRUSTDB	      33 /* a problem with the trustdb */
#define G10ERR_BAD_CERT       34 /* bad certicate */
#define G10ERR_INV_USER_ID    35
#define G10ERR_CLOSE_FILE     36
#define G10ERR_RENAME_FILE    37
#define G10ERR_DELETE_FILE    38
#define G10ERR_UNEXPECTED     39
#define G10ERR_TIME_CONFLICT  40
#define G10ERR_WR_PUBKEY_ALGO 41 /* unusabe pubkey algo */
#define G10ERR_FILE_EXISTS    42
#define G10ERR_WEAK_KEY       43 /* NOTE: hardcoded into the cipher modules */
#define G10ERR_WRONG_KEYLEN   44 /* NOTE: hardcoded into the cipher modules */
#define G10ERR_INV_ARG	      45
#define G10ERR_BAD_URI	      46  /* syntax error in URI */
#define G10ERR_INVALID_URI    47  /* e.g. unsupported scheme */
#define G10ERR_NETWORK	      48  /* general network error */
#define G10ERR_UNKNOWN_HOST   49
#define G10ERR_SELFTEST_FAILED 50
#define G10ERR_NOT_ENCRYPTED  51
#define G10ERR_NOT_PROCESSED  52
#define G10ERR_UNU_PUBKEY     53
#define G10ERR_UNU_SECKEY     54
#define G10ERR_KEYSERVER      55
#define G10ERR_CANCELED       56
#define G10ERR_NO_CARD        57
#define G10ERR_NO_DATA        58

#ifndef HAVE_STRERROR
char *strerror (int n);
#endif

#ifdef _WIN32
const char * w32_strerror (int w32_errno);
#endif

#endif /*G10_ERRORS_H*/

- 42269E10B09731558FE6D6E4F8D52F3C3CE10AD1C67496E22F7EC0E19C6D6586F1491921486E90A468905A68D6414D7B7F68914582206CCC2CE2E3ED1E2D3F3D
+
mpi/include/iobuf.h

(1 . 161)(0 . 0)
/* iobuf.h - I/O buffer
 * Copyright (C) 1998, 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
 *
 * This file is part of GNUPG.
 *
 * GNUPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_IOBUF_H
#define G10_IOBUF_H

#include "types.h"


#define DBG_IOBUF   iobuf_debug_mode

#define IOBUFCTRL_INIT	    1
#define IOBUFCTRL_FREE	    2
#define IOBUFCTRL_UNDERFLOW 3
#define IOBUFCTRL_FLUSH     4
#define IOBUFCTRL_DESC	    5
#define IOBUFCTRL_CANCEL    6
#define IOBUFCTRL_USER	    16

typedef struct iobuf_struct *IOBUF;
typedef struct iobuf_struct *iobuf_t;

/* fixme: we should hide most of this stuff */
struct iobuf_struct {
    int use;	       /* 1 input , 2 output, 3 temp */
    off_t nlimit;
    off_t nbytes;      /* used together with nlimit */
    off_t ntotal;      /* total bytes read (position of stream) */
    int nofast; 	/* used by the iobuf_get() */
    void *directfp;
    struct {
	size_t size;   /* allocated size */
	size_t start;  /* number of invalid bytes at the begin of the buffer */
	size_t len;    /* currently filled to this size */
	byte *buf;
    } d;
    int filter_eof;
    int error;
    int (*filter)( void *opaque, int control,
		   IOBUF chain, byte *buf, size_t *len);
    void *filter_ov;	/* value for opaque */
    int filter_ov_owner;
    char *real_fname;
    IOBUF chain;	/* next iobuf used for i/o if any (passed to filter) */
    int no, subno;
    const char *desc;
    void *opaque;      /* can be used to hold any information	 */
		       /* this value is copied to all instances */
    struct {
	size_t size;   /* allocated size */
	size_t start;  /* number of invalid bytes at the begin of the buffer */
	size_t len;    /* currently filled to this size */
	byte *buf;
    } unget;
};

#ifndef EXTERN_UNLESS_MAIN_MODULE
#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
#define EXTERN_UNLESS_MAIN_MODULE extern
#else
#define EXTERN_UNLESS_MAIN_MODULE 
#endif
#endif
EXTERN_UNLESS_MAIN_MODULE int iobuf_debug_mode;

void  iobuf_enable_special_filenames ( int yes );
int   iobuf_is_pipe_filename (const char *fname);
IOBUF iobuf_alloc(int use, size_t bufsize);
IOBUF iobuf_temp(void);
IOBUF iobuf_temp_with_content( const char *buffer, size_t length );
IOBUF iobuf_open( const char *fname );
IOBUF iobuf_fdopen( int fd, const char *mode );
IOBUF iobuf_sockopen( int fd, const char *mode );
IOBUF iobuf_create( const char *fname );
IOBUF iobuf_append( const char *fname );
IOBUF iobuf_openrw( const char *fname );
int   iobuf_ioctl ( IOBUF a, int cmd, int intval, void *ptrval );
int   iobuf_close( IOBUF iobuf );
int   iobuf_cancel( IOBUF iobuf );

int iobuf_push_filter( IOBUF a, int (*f)(void *opaque, int control,
		       IOBUF chain, byte *buf, size_t *len), void *ov );
int iobuf_push_filter2( IOBUF a,
		    int (*f)(void *opaque, int control,
		    IOBUF chain, byte *buf, size_t *len),
		    void *ov, int rel_ov );
int iobuf_flush(IOBUF a);
void iobuf_clear_eof(IOBUF a);
#define iobuf_set_error(a)    do { (a)->error = 1; } while(0)
#define iobuf_error(a)	      ((a)->error)

void iobuf_set_limit( IOBUF a, off_t nlimit );

off_t iobuf_tell( IOBUF a );
int   iobuf_seek( IOBUF a, off_t newpos );

int  iobuf_readbyte(IOBUF a);
int  iobuf_read(IOBUF a, byte *buf, unsigned buflen );
unsigned iobuf_read_line( IOBUF a, byte **addr_of_buffer,
			  unsigned *length_of_buffer, unsigned *max_length );
int  iobuf_peek(IOBUF a, byte *buf, unsigned buflen );
int  iobuf_writebyte(IOBUF a, unsigned c);
int  iobuf_write(IOBUF a, byte *buf, unsigned buflen );
int  iobuf_writestr(IOBUF a, const char *buf );

void iobuf_flush_temp( IOBUF temp );
int  iobuf_write_temp( IOBUF a, IOBUF temp );
size_t iobuf_temp_to_buffer( IOBUF a, byte *buffer, size_t buflen );
void iobuf_unget_and_close_temp( IOBUF a, IOBUF temp );

int  iobuf_get_fd (IOBUF a);
off_t iobuf_get_filelength (IOBUF a, int *overflow);
#define IOBUF_FILELENGTH_LIMIT 0xffffffff
const char *iobuf_get_real_fname( IOBUF a );
const char *iobuf_get_fname( IOBUF a );

void iobuf_set_partial_block_mode( IOBUF a, size_t len );

int iobuf_translate_file_handle ( int fd, int for_write );

/* Get a byte form the iobuf; must check for eof prior to this function.
 * This function returns values in the range 0 .. 255 or -1 to indicate EOF
 * iobuf_get_noeof() does not return -1 to indicate EOF, but masks the
 * returned value to be in the range 0..255.
 */
#define iobuf_get(a)  \
     (	((a)->nofast || (a)->d.start >= (a)->d.len )?  \
	iobuf_readbyte((a)) : ( (a)->nbytes++, (a)->d.buf[(a)->d.start++] ) )
#define iobuf_get_noeof(a)    (iobuf_get((a))&0xff)

/* write a byte to the iobuf and return true on write error
 * This macro does only write the low order byte
 */
#define iobuf_put(a,c)	iobuf_writebyte(a,c)

#define iobuf_where(a)	"[don't know]"
#define iobuf_id(a)	((a)->no)

#define iobuf_get_temp_buffer(a) ( (a)->d.buf )
#define iobuf_get_temp_length(a) ( (a)->d.len )
#define iobuf_is_temp(a)	 ( (a)->use == 3 )

void iobuf_skip_rest (IOBUF a, unsigned long n, int partial);

#endif /*G10_IOBUF_H*/

-
+ A441A78465E16D369E66F080D444BC97EF7C0E0D9208E88565D8646A1B31BACAC8B39411C4092C2FC56BD07CDF8FD686940F18424BF1928C9220B68B46840330
mpi/include/knobs.h

(0 . 0)(1 . 75)
/* knobs.h -- Originally generated from config.h.in by autoconf.
 *            But there is no more autoconf in this project.
 *
 * No Such Labs. (C) 2015. See README.
 *
 * 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 3 of the License, 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef GNUPG_CONFIG_H_INCLUDED
#define GNUPG_CONFIG_H_INCLUDED

/* Report memory usage. */
//#define M_DEBUG 1

/* Define to 1 if you have the `atexit' function. */
#define HAVE_ATEXIT 1

/* Defined if the mlock() call does not work */
/* #undef HAVE_BROKEN_MLOCK */

/* Defined if a `byte' is typedef'd */
/* #undef HAVE_BYTE_TYPEDEF */

/* defined if we run on some of the PCDOS like systems (DOS, Windoze. OS/2)
   with special properties like no file modes */
/* #undef HAVE_DOSISH_SYSTEM */

/* Define to 1 if you have the `getpagesize' function. */
#define HAVE_GETPAGESIZE 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1

/* Defined if the system supports an mlock() call */
#define HAVE_MLOCK 1

/* Define to 1 if you have the `mmap' function. */
#define HAVE_MMAP 1

/* Define to 1 if you have the `plock' function. */
/* #undef HAVE_PLOCK */

/* Define to 1 if you have the `raise' function. */
#define HAVE_RAISE 1

/* Define to 1 if you have the `sysconf' function. */
#define HAVE_SYSCONF 1

/* Defined if a `u16' is typedef'd */
/* #undef HAVE_U16_TYPEDEF */

/* Defined if a `u32' is typedef'd */
/* #undef HAVE_U32_TYPEDEF */

/* Defined if a `ulong' is typedef'd */
#define HAVE_ULONG_TYPEDEF 1

/* Defined if a `ushort' is typedef'd */
#define HAVE_USHORT_TYPEDEF 1

#endif /*GNUPG_CONFIG_H_INCLUDED*/

- 042BA62021E6A33FA5F28447D8D268D4FD9A66D49BD10B904AA5F5C9FB6A30345F5CFEA787FBA1145B328F56E77C39E4D7C3D6DF94CCD4B7696B9FE2C8AA7055
+ A4A9188BECDE0BEF5A0F54061C6758B618A85CE7C483AF33F5D7655EB1CE7165A8FFC185BF37AE4D3781DEAB518DB3D4FE946692406DE0BD73212331EF400F27
mpi/include/longlong.h

(1 . 22)(1 . 24)
/* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
   Note: I added some stuff for use with gnupg

Copyright (C) 1991, 1992, 1993, 1994, 1996, 1998,
              2000, 2001, 2002, 2003 Free Software Foundation, Inc.

This file is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version.

This file 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 Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this file; if not, see <http://www.gnu.org/licenses/>.  */

 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * 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 3 of the License, 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* You have to define the following before including this file:

- B48416427E71FE46868283490813E4D0A22DA9F4B17EFF706673A9B05380AE2D85EC9B183DB47EAA8AA197B7C7629EB873E63E5F8A66208BF230A794B6967FAB
+ 6580645F16FEA9A37EFF8460584FCA09F39B1EC9BA88E00AA0207C75267F7190810CF45F2733C9960AAEC0DAAAC7FE74785F38287AA61CB4CD5D4F50EA1158C9
mpi/include/memory.h

(1 . 34)(1 . 36)
/* memory.h - memory allocation
 * Copyright (C) 1998, 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GNUPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_MEMORY_H
#define G10_MEMORY_H

#ifdef M_DEBUG

#ifndef STR
#define STR(v) #v
#endif
#ifndef __riscos__

#define M_DBGINFO(a)	    __FUNCTION__ "["__FILE__ ":"  STR(a) "]"
#else /* __riscos__ */
#define M_DBGINFO(a)	     "["__FILE__ ":"  STR(a) "]"
#endif /* __riscos__ */

#define xmalloc(n)		m_debug_alloc((n), M_DBGINFO( __LINE__ ) )
#define xtrymalloc(n)		m_debug_trymalloc ((n), M_DBGINFO( __LINE__ ))
#define xmalloc_clear(n)	m_debug_alloc_clear((n), M_DBGINFO(__LINE__) )
(91 . 12)(93 . 8)
#define DBG_MEMSTAT   memory_stat_debug_mode

#ifndef EXTERN_UNLESS_MAIN_MODULE
#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
#define EXTERN_UNLESS_MAIN_MODULE extern
#else
#define EXTERN_UNLESS_MAIN_MODULE 
#endif
#endif
EXTERN_UNLESS_MAIN_MODULE int memory_debug_mode;
EXTERN_UNLESS_MAIN_MODULE int memory_stat_debug_mode;

- FB2AFC7686790FA12E3143E79C4728DAC3E43C4056C647650D216B7EC7350F7651F6C44C4393858E8BAB02719B7674AD7F29E1FCB10511DE0A5AE4A2C12AF5A6
+
mpi/include/mpi-asm-defs.h

(1 . 10)(0 . 0)
/* This file defines some basic constants for the MPI machinery.  We
 * need to define the types on a per-CPU basis, so it is done with
 * this file here.  */
#define BYTES_PER_MPI_LIMB  (SIZEOF_UNSIGNED_LONG)

- E539EF777487B66317CD23B7D19F883A9BAB67A9CB984DFB5D1A5DF4575A66CB44B7EC199AC0829B1270EDFA68F182D646CE944C14F5C401654E1E0F68271BAF
+ 0BC1BE9F757231B114821A55B106387358B919237DCEDC3C4F23C0DF61F7ACD00656CEFBA6A48313304FCFBCE2ABF528EC2FBA998C0F67784DE486D00B8F6CC2
mpi/include/mpi.h

(1 . 47)(1 . 36)
/* mpi.h  -  Multi Precision Integers
 *	Copyright (C) 1994, 1996, 1998, 1999,
 *                    2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GNUPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_MPI_H
#define G10_MPI_H

#include <config.h>
#include <stdio.h>
#include "iobuf.h"
#include "knobs.h"
#include "types.h"
#include "memory.h"

#ifndef EXTERN_UNLESS_MAIN_MODULE
#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
#define EXTERN_UNLESS_MAIN_MODULE extern
#else
#define EXTERN_UNLESS_MAIN_MODULE 
#endif
#endif

#define DBG_MPI     mpi_debug_mode
EXTERN_UNLESS_MAIN_MODULE int mpi_debug_mode;
(92 . 18)(81 . 10)
unsigned int mpi_get_flags (MPI a);

/*-- mpicoder.c --*/
int mpi_write( IOBUF out, MPI a );
#ifdef M_DEBUG
#define mpi_read(a,b,c)   mpi_debug_read((a),(b),(c),  M_DBGINFO( __LINE__ ) )
MPI mpi_debug_read(IOBUF inp, unsigned *nread, int secure, const char *info);
#else
MPI mpi_read(IOBUF inp, unsigned *nread, int secure);
#endif
MPI mpi_read_from_buffer(byte *buffer, unsigned *ret_nread, int secure);
int mpi_fromstr(MPI val, const char *str);
int mpi_print( FILE *fp, MPI a, int mode );
void g10_log_mpidump( const char *text, MPI a );
u32 mpi_get_keyid( MPI a, u32 *keyid );
//void g10_log_mpidump( const char *text, MPI a );
byte *mpi_get_buffer( MPI a, unsigned *nbytes, int *sign );
byte *mpi_get_secure_buffer( MPI a, unsigned *nbytes, int *sign );
void  mpi_set_buffer( MPI a, const byte *buffer, unsigned nbytes, int sign );

- DF6064B02A11C90FB20945DAD1ECC4753A231F894D6CF60E133D6196D924442E0FA08C1D38421A97511F4007A9545C6A980960A20817E6EAECF4CE36E920F151
+ F1A5F8EE7289D1AA4526A7AE2CABE769EE43FA525AE47658A12D6856B51174D174C96CD1E93BE6836BB29F53725BE73649A0AF667CDD4E71A08431B984BDA8C4
mpi/include/mpi-inline.h

(1 . 28)(1 . 23)
/* mpi-inline.h  -  Internal to the Multi Precision Integers
 *	Copyright (C) 1994, 1996, 1998, 1999 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_MPI_INLINE_H

- 98C4253D69C7531F96DC7631D3D26C5733D5104A3DDBD9EAFD622F8AACD8619E71ABB55D0C951B148E9D33887DAB0EDF2CBD9C9B38CA908BC8E04ED930943FDE
+ D1B3EAED32DC555D5F779EDE28A995D2AC6BF3A5BF87362955675B11BAD91A928FBF62B7FC7FCA5EF1A2C8D33409978EF73D5D879564ED3829C5FC6DACD6CDFD
mpi/include/mpi-internal.h

(1 . 36)(1 . 32)
/* mpi-internal.h  -  Internal to the Multi Precision Integers
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 *	Copyright (C) 1998, 2000 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_MPI_INTERNAL_H
#define G10_MPI_INTERNAL_H

#include "mpi.h"
#include "mpi-asm-defs.h"

/* from the old mpi-asm-defs.h */
#define BYTES_PER_MPI_LIMB  (SIZEOF_UNSIGNED_LONG)

#if BYTES_PER_MPI_LIMB == SIZEOF_UNSIGNED_INT
  typedef unsigned int mpi_limb_t;

- 85D1DE1E79681B0CECE4CAEA7CA324374FB41317C449585E8CD4D23FAE4EF10923285545645FAC2921D3C53A0C897E33DA32D895B9BD0B761F696D0D8E036479
+
mpi/include/ttyio.h

(1 . 58)(0 . 0)
/* ttyio.h
 * Copyright (C) 1998, 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
 *
 * This file is part of GNUPG.
 *
 * GNUPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
#ifndef G10_TTYIO_H
#define G10_TTYIO_H

#ifdef HAVE_LIBREADLINE
#include <stdio.h>
#include <readline/readline.h>
#endif

const char *tty_get_ttyname (void);
int tty_batchmode( int onoff );
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
 void tty_printf (const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
 void tty_fprintf (FILE *fp, const char *fmt, ... )
                                __attribute__ ((format (printf,2,3)));
#else
 void tty_printf (const char *fmt, ... );
 void tty_fprintf (FILE *fp, const char *fmt, ... );
#endif
void tty_print_string( const byte *p, size_t n );
void tty_print_utf8_string( const byte *p, size_t n );
void tty_print_utf8_string2( const byte *p, size_t n, size_t max_n );
char *tty_get( const char *prompt );
char *tty_get_hidden( const char *prompt );
void tty_kill_prompt(void);
int tty_get_answer_is_yes( const char *prompt );
int tty_no_terminal(int onoff);

#ifdef HAVE_LIBREADLINE
void tty_enable_completion(rl_completion_func_t *completer);
void tty_disable_completion(void);
#else
/* Use a macro to stub out these functions since a macro has no need
   to typedef a "rl_completion_func_t" which would be undefined
   without readline. */
#define tty_enable_completion(x)
#define tty_disable_completion()
#endif
void tty_cleanup_after_signal (void);

#endif /*G10_TTYIO_H*/

- D355F8BB711647E95451CF2D53F8C496013D9C797ACC81560FAE155C5850823C880D647347426A4562DA568A6CDE708FDCCBD1E881568816156C0801C7E47FD7
+ 7080AB52C460BB847F724212473D3F0B93AA44175577E977E937BC2246E11BE0B0BA2439B9E1053A1C898B606617717260D61937D7BA70B034B77CED2149EA83
mpi/include/types.h

(1 . 20)(1 . 23)
/* types.h - some common typedefs
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GNUPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_TYPES_H
(46 . 14)(49 . 7)

#ifndef HAVE_BYTE_TYPEDEF
#undef byte	    /* maybe there is a macro with this name */
#ifndef __riscos__
typedef unsigned char byte;
#else 
/* Norcroft treats char  = unsigned char  as legal assignment
               but char* = unsigned char* as illegal assignment
   and the same applies to the signed variants as well  */
typedef char byte;
#endif
#define HAVE_BYTE_TYPEDEF
#endif

- 5B4ADEDB0DDA25D37413FD81037EF2D94722CEE3B58B5A5314DA3816308540588319A280819E272845D154B6F2FDBDCECE3A73C15B2802F33BC6BFE484F0B4A5
+ 60F97FC937B6974E1AD4AA0D6728491D71127244D9FF43369612222359802A7816F57FE6060354582782A04CE62B6568BABAC0A0BF886FD6D8CBE3A17F540BCA
mpi/include/util.h

(1 . 22)(1 . 25)
/* util.h
 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
 *               2006 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GNUPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef G10_UTIL_H
#define G10_UTIL_H

(25 . 244)(28 . 25)
#endif

#include "types.h"
#include "errors.h"
#include "types.h"
#include "mpi.h"
#include "compat.h"

typedef struct {
     int  *argc;	    /* pointer to argc (value subject to change) */
     char ***argv;	    /* pointer to argv (value subject to change) */
     unsigned flags;	    /* Global flags (DO NOT CHANGE) */
     int err;		    /* print error about last option */
			    /* 1 = warning, 2 = abort */
     int r_opt; 	    /* return option */
     int r_type;	    /* type of return value (0 = no argument found)*/
     union {
	 int   ret_int;
	 long  ret_long;
	 ulong ret_ulong;
	 char *ret_str;
     } r;		    /* Return values */
     struct {
	 int idx;
	 int inarg;
	 int stopped;
	 const char *last;
	 void *aliases;
	 const void *cur_alias;
     } internal;	    /* DO NOT CHANGE */
} ARGPARSE_ARGS;

typedef struct {
    int 	short_opt;
    const char *long_opt;
    unsigned flags;
    const char *description; /* optional option description */
} ARGPARSE_OPTS;

/*-- logger.c --*/
void log_set_logfile( const char *name, int fd );
FILE *log_stream(void);
void g10_log_print_prefix(const char *text);
void log_set_name( const char *name );
const char *log_get_name(void);
void log_set_pid( int pid );
int  log_get_errorcount( int clear );
void log_inc_errorcount(void);
int log_set_strict(int val);
void g10_log_hexdump( const char *text, const char *buf, size_t len );

#if defined (__riscos__) \
    || (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
  void g10_log_bug( const char *fmt, ... )
			    __attribute__ ((noreturn, format (printf,1,2)));
  void g10_log_bug0( const char *, int, const char * ) __attribute__ ((noreturn));
  void g10_log_fatal( const char *fmt, ... )
			    __attribute__ ((noreturn, format (printf,1,2)));
  void g10_log_error( const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
  void g10_log_info( const char *fmt, ... )  __attribute__ ((format (printf,1,2)));
  void g10_log_warning( const char *fmt, ... )  __attribute__ ((format (printf,1,2)));
  void g10_log_debug( const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
#ifndef __riscos__
#define BUG() g10_log_bug0(  __FILE__ , __LINE__, __FUNCTION__ )
#else
#define BUG() g10_log_bug0(  __FILE__ , __LINE__, __func__ )
#endif
#else
  void g10_log_bug( const char *fmt, ... );
  void g10_log_bug0( const char *, int );
  void g10_log_fatal( const char *fmt, ... );
  void g10_log_error( const char *fmt, ... );
  void g10_log_info( const char *fmt, ... );
  void g10_log_warning( const char *fmt, ... );
  void g10_log_debug( const char *fmt, ... );
#define BUG() g10_log_bug0( __FILE__ , __LINE__ )
#endif
#define log_hexdump printf
#define log_bug     printf
#define log_bug0    printf
#define log_fatal   printf
#define log_error   printf
#define log_info    printf
#define log_warning printf
#define log_debug   printf

#define g10_log_print_prefix printf

#define log_hexdump g10_log_hexdump
#define log_bug     g10_log_bug
#define log_bug0    g10_log_bug0
#define log_fatal   g10_log_fatal
#define log_error   g10_log_error
#define log_info    g10_log_info
#define log_warning g10_log_warning
#define log_debug   g10_log_debug


/*-- errors.c --*/
const char * g10_errstr( int no );

/*-- argparse.c --*/
int arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
int optfile_parse( FILE *fp, const char *filename, unsigned *lineno,
		   ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
void usage( int level );
const char *default_strusage( int level );


/*-- (main program) --*/
const char *strusage( int level );


/*-- dotlock.c --*/
struct dotlock_handle;
typedef struct dotlock_handle *DOTLOCK;

void disable_dotlock(void);
DOTLOCK create_dotlock( const char *file_to_lock );
void destroy_dotlock ( DOTLOCK h );
int make_dotlock( DOTLOCK h, long timeout );
int release_dotlock( DOTLOCK h );
void remove_lockfiles (void);

/*-- fileutil.c --*/
char * make_basename(const char *filepath, const char *inputpath);
char * make_dirname(const char *filepath);
char *make_filename( const char *first_part, ... );
int compare_filenames( const char *a, const char *b );
int same_file_p (const char *name1, const char *name2);
const char *print_fname_stdin( const char *s );
const char *print_fname_stdout( const char *s );
int is_file_compressed(const char *s, int *r_status);

/*-- miscutil.c --*/
u32 make_timestamp(void);
u32 scan_isodatestr( const char *string );
u32 isotime2seconds (const char *string);
const char *strtimevalue( u32 stamp );
const char *strtimestamp( u32 stamp ); /* GMT */
const char *isotimestamp( u32 stamp ); /* GMT with hh:mm:ss */
const char *asctimestamp( u32 stamp ); /* localized */
void print_string( FILE *fp, const byte *p, size_t n, int delim );
void print_string2( FILE *fp, const byte *p, size_t n, int delim, int delim2 );
void  print_utf8_string( FILE *fp, const byte *p, size_t n );
void  print_utf8_string2( FILE *fp, const byte *p, size_t n, int delim);
char *make_printable_string( const byte *p, size_t n, int delim );
int answer_is_yes_no_default( const char *s, int def_answer );
int answer_is_yes( const char *s );
int answer_is_yes_no_quit( const char *s );
int answer_is_okay_cancel (const char *s, int def_answer);
int match_multistr(const char *multistr,const char *match);

/*-- strgutil.c --*/
void free_strlist( STRLIST sl );
#define FREE_STRLIST(a) do { free_strlist((a)); (a) = NULL ; } while(0)
STRLIST add_to_strlist( STRLIST *list, const char *string );
STRLIST add_to_strlist2( STRLIST *list, const char *string, int is_utf8 );
STRLIST append_to_strlist( STRLIST *list, const char *string );
STRLIST append_to_strlist2( STRLIST *list, const char *string, int is_utf8 );
STRLIST strlist_prev( STRLIST head, STRLIST node );
STRLIST strlist_last( STRLIST node );
char *pop_strlist( STRLIST *list );
const char *memistr( const char *buf, size_t buflen, const char *sub );
const char *ascii_memistr( const char *buf, size_t buflen, const char *sub );
char *mem2str( char *, const void *, size_t);
char *trim_spaces( char *string );
unsigned int trim_trailing_chars( byte *line, unsigned int len,
                                  const char *trimchars);
unsigned int trim_trailing_ws( byte *line, unsigned len );
unsigned int check_trailing_chars( const byte *line, unsigned int len,
                                   const char *trimchars );
unsigned int check_trailing_ws( const byte *line, unsigned int len );
int string_count_chr( const char *string, int c );
int set_native_charset( const char *newset );
const char* get_native_charset(void);
char *native_to_utf8( const char *string );
char *utf8_to_native( const char *string, size_t length, int delim);
char *string_to_utf8 (const char *string);

int ascii_isupper (int c);
int ascii_islower (int c);
int ascii_memcasecmp( const char *a, const char *b, size_t n);

#ifndef HAVE_STPCPY
char *stpcpy(char *a,const char *b);
#endif
#ifndef HAVE_STRLWR
char *strlwr(char *a);
#endif
#ifndef HAVE_STRCASECMP
int strcasecmp( const char *, const char *b);
#endif
#ifndef HAVE_STRNCASECMP
int strncasecmp (const char *, const char *b, size_t n);
#endif
#ifndef HAVE_STRTOUL
#define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
#endif
#ifndef HAVE_MEMMOVE
#define memmove(d, s, n) bcopy((s), (d), (n))
#endif

/*-- membuf.c --*/
/* The definition of the structure is private, we only need it here,
   so it can be allocated on the stack. */
struct private_membuf_s {
  size_t len;      
  size_t size;     
  char *buf;       
  int out_of_core; 
};

typedef struct private_membuf_s membuf_t;

void init_membuf (membuf_t *mb, int initiallen);
void put_membuf  (membuf_t *mb, const void *buf, size_t len);
void *get_membuf (membuf_t *mb, size_t *len);



#if defined (_WIN32)
/*-- w32reg.c --*/
char *read_w32_registry_string( const char *root,
				const char *dir, const char *name );
int write_w32_registry_string(const char *root, const char *dir,
                              const char *name, const char *value);

#endif /*_WIN32*/

/*-- strgutil.c --*/
char *xasprintf (const char *fmt, ...);
char *xtryasprintf (const char *fmt, ...);


/*-- pka.c --*/
char *get_pka_info (const char *address, unsigned char *fpr);

/*-- cert.c --*/
int get_cert(const char *name,size_t max_size,IOBUF *iobuf,
	     unsigned char **fpr,size_t *fpr_len,char **url);

/*-- convert.c --*/
int hex2bin (const char *string, void *buffer, size_t length);
int hexcolon2bin (const char *string, void *buffer, size_t length);
char *bin2hex (const void *buffer, size_t length, char *stringbuf);
char *bin2hexcolon (const void *buffer, size_t length, char *stringbuf);
const char *hex2str (const char *hexstring,
                     char *buffer, size_t bufsize, size_t *buflen);
char *hex2str_alloc (const char *hexstring, size_t *r_count);


/**** other missing stuff ****/
#ifndef HAVE_ATEXIT  /* For SunOS */
(273 . 10)(57 . 6)
#define raise(a) kill(getpid(), (a))
#endif

/*-- Replacement functions from funcname.c --*/



/******** some macros ************/
#ifndef STR
#define STR(v) #v
(302 . 33)(82 . 5)
                     *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
#define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))

/******* RISC OS stuff ***********/
#ifdef __riscos__
int riscos_load_module(const char *name, const char * const path[], int fatal);
int riscos_get_filetype_from_string(const char *string, int len);
int riscos_get_filetype(const char *filename);
void riscos_set_filetype_by_number(const char *filename, int type);
void riscos_set_filetype_by_mimetype(const char *filename, const char *mimetype);
pid_t riscos_getpid(void);
int riscos_kill(pid_t pid, int sig);
int riscos_access(const char *path, int amode);
int riscos_getchar(void);
char *riscos_make_basename(const char *filepath, const char *inputpath);
int riscos_check_regexp(const char *exp, const char *string, int debug);
int riscos_fdopenfile(const char *filename, const int allow_write);
void riscos_close_fds(void);
int riscos_renamefile(const char *old, const char *new);
char *riscos_gstrans(const char *old);
void riscos_not_implemented(const char *feature);
#ifdef DEBUG
void riscos_dump_fdlist(void);
void riscos_list_openfiles(void);
#endif
#ifndef __RISCOS__C__
#define getpid riscos_getpid
#define kill(a,b) riscos_kill((a),(b))
#define access(a,b) riscos_access((a),(b))
#endif /* !__RISCOS__C__ */
#endif /* __riscos__ */

#endif /*G10_UTIL_H*/

- C5DDDD9D52900BA3D847422F9DBA2799BE2954AD9CCA3B9AA6FB1654DD89EE00575C52D15BD65E98D3054D4646943372CA8AD591F610EA7761D21FE4C3AE6187
+
mpi/iobuf.c

(1 . 2326)(0 . 0)
/* iobuf.c  -  file handling
 * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2008,
 *               2009 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> 
#include <unistd.h>
#ifdef HAVE_DOSISH_SYSTEM
#include <windows.h>
#endif
#ifdef __riscos__
#include <kernel.h>
#include <swis.h>
#endif /* __riscos__ */

#include "memory.h"
#include "util.h"
#include "iobuf.h"

/* The size of the internal buffers. 
   NOTE: If you change this value you MUST also adjust the regression
   test "armored_key_8192" in armor.test! */
#define IOBUF_BUFFER_SIZE  8192


#undef FILE_FILTER_USES_STDIO

#ifdef HAVE_DOSISH_SYSTEM
#define USE_SETMODE 1
#endif

#ifdef FILE_FILTER_USES_STDIO
#define my_fileno(a)  fileno ((a))
#define my_fopen_ro(a,b) fopen ((a),(b))
#define my_fopen(a,b)    fopen ((a),(b))
typedef FILE *FILEP_OR_FD;
#define INVALID_FP    NULL
#define FILEP_OR_FD_FOR_STDIN  (stdin)
#define FILEP_OR_FD_FOR_STDOUT  (stdout)
typedef struct {
     FILE *fp;	   /* open file handle */
     int keep_open;
     int no_cache;
     int  print_only_name; /* flags indicating that fname is not a real file*/
     char fname[1]; /* name of the file */
 } file_filter_ctx_t ;
#else
#define my_fileno(a)  (a)
#define my_fopen_ro(a,b) fd_cache_open ((a),(b)) 
#define my_fopen(a,b) direct_open ((a),(b)) 
#ifdef HAVE_DOSISH_SYSTEM
typedef HANDLE FILEP_OR_FD;
#define INVALID_FP  ((HANDLE)-1)
#define FILEP_OR_FD_FOR_STDIN  (GetStdHandle (STD_INPUT_HANDLE))
#define FILEP_OR_FD_FOR_STDOUT (GetStdHandle (STD_OUTPUT_HANDLE))
#undef USE_SETMODE
#else
typedef int FILEP_OR_FD;
#define INVALID_FP  (-1)
#define FILEP_OR_FD_FOR_STDIN  (0)
#define FILEP_OR_FD_FOR_STDOUT (1)
#endif
typedef struct {
     FILEP_OR_FD  fp;	   /* open file handle */
     int keep_open;
     int no_cache;
     int eof_seen;
     int  print_only_name; /* flags indicating that fname is not a real file*/
     char fname[1]; /* name of the file */
 } file_filter_ctx_t ;

 struct close_cache_s { 
    struct close_cache_s *next;
    FILEP_OR_FD fp;
    char fname[1];
 };
 typedef struct close_cache_s *CLOSE_CACHE;
 static CLOSE_CACHE close_cache;
#endif

#ifdef _WIN32
typedef struct {
    int sock;
    int keep_open;
    int no_cache;
    int eof_seen;
    int  print_only_name; /* flags indicating that fname is not a real file*/
    char fname[1]; /* name of the file */
} sock_filter_ctx_t ;
#endif /*_WIN32*/

/* The first partial length header block must be of size 512
 * to make it easier (and efficienter) we use a min. block size of 512
 * for all chunks (but the last one) */
#define OP_MIN_PARTIAL_CHUNK	  512
#define OP_MIN_PARTIAL_CHUNK_2POW 9

typedef struct {
    int use;
    size_t size;
    size_t count;
    int partial;  /* 1 = partial header, 2 in last partial packet */
    char *buffer;    /* used for partial header */
    size_t buflen;   /* used size of buffer */
    int first_c;     /* of partial header (which is > 0)*/
    int eof;
} block_filter_ctx_t;

static int special_names_enabled;

static int underflow(IOBUF a);
static int translate_file_handle ( int fd, int for_write );



#ifndef FILE_FILTER_USES_STDIO

/* This is a replacement for strcmp.  Under W32 it does not
   distinguish between backslash and slash.  */
static int
fd_cache_strcmp (const char *a, const char *b)
{
#ifdef HAVE_DOSISH_SYSTEM
  for (; *a && *b; a++, b++)
    {
      if (*a != *b && !((*a == '/' && *b == '\\') 
                        || (*a == '\\' && *b == '/')) )
        break;
    }
  return *(const unsigned char *)a - *(const unsigned char *)b;
#else
  return strcmp (a, b);
#endif
}

/*
 * Invalidate (i.e. close) a cached iobuf or all iobufs if NULL is
 * used for FNAME.
 */
static int
fd_cache_invalidate (const char *fname)
{
    CLOSE_CACHE cc;
    int err=0;

    if (!fname) {
        if( DBG_IOBUF )
            log_debug ("fd_cache_invalidate (all)\n");

        for (cc=close_cache; cc; cc = cc->next ) {
            if ( cc->fp != INVALID_FP ) {
#ifdef HAVE_DOSISH_SYSTEM
                CloseHandle (cc->fp);
#else
                close(cc->fp);
#endif
                cc->fp = INVALID_FP;
            }
        }
        return err;
    }

    if( DBG_IOBUF )
        log_debug ("fd_cache_invalidate (%s)\n", fname);

    for (cc=close_cache; cc; cc = cc->next ) {
        if ( cc->fp != INVALID_FP && !fd_cache_strcmp (cc->fname, fname) ) {
            if( DBG_IOBUF )
                log_debug ("                did (%s)\n", cc->fname);
#ifdef HAVE_DOSISH_SYSTEM
            if(CloseHandle (cc->fp)==0)
	      err=-1;
#else
	    err=close(cc->fp);
#endif
            cc->fp = INVALID_FP;
        }
    }

    return err;
}

static int
fd_cache_synchronize(const char *fname)
{
  int err=0;

#ifndef HAVE_DOSISH_SYSTEM
  CLOSE_CACHE cc;

  if( DBG_IOBUF )
    log_debug ("fd_cache_synchronize (%s)\n", fname);

  for (cc=close_cache; cc; cc = cc->next )
    {
      if ( cc->fp != INVALID_FP && !fd_cache_strcmp (cc->fname, fname) )
	{
	  if( DBG_IOBUF )
	    log_debug ("                did (%s)\n", cc->fname);

	  err=fsync(cc->fp);
	}
    }
#endif

  return err;
}

static FILEP_OR_FD
direct_open (const char *fname, const char *mode)
{
#ifdef HAVE_DOSISH_SYSTEM
    unsigned long da, cd, sm;
    HANDLE hfile;

    /* Note, that we do not handle all mode combinations */

    /* According to the ReactOS source it seems that open() of the
     * standard MSW32 crt does open the file in share mode which is
     * something new for MS applications ;-)
     */
    if ( strchr (mode, '+') ) {
        fd_cache_invalidate (fname);
        da = GENERIC_READ|GENERIC_WRITE;
        cd = OPEN_EXISTING;
        sm = FILE_SHARE_READ | FILE_SHARE_WRITE;
    }
    else if ( strchr (mode, 'w') ) {
        fd_cache_invalidate (fname);
        da = GENERIC_WRITE;
        cd = CREATE_ALWAYS;
        sm = FILE_SHARE_WRITE;
    }
    else {
        da = GENERIC_READ;
        cd = OPEN_EXISTING;
        sm = FILE_SHARE_READ;
    }

    hfile = CreateFile (fname, da, sm, NULL, cd, FILE_ATTRIBUTE_NORMAL, NULL);
    return hfile;
#else
    int oflag;
    int cflag = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;

    /* Note, that we do not handle all mode combinations */
    if ( strchr (mode, '+') ) {
        fd_cache_invalidate (fname);
        oflag = O_RDWR;
    }
    else if ( strchr (mode, 'w') ) {
        fd_cache_invalidate (fname);
        oflag = O_WRONLY | O_CREAT | O_TRUNC;
    }
    else {
        oflag = O_RDONLY;
    }
#ifdef O_BINARY
    if (strchr (mode, 'b'))
      oflag |= O_BINARY;
#endif
#ifndef __riscos__
    return open (fname, oflag, cflag );
#else
    {
        struct stat buf;
        int rc = stat( fname, &buf );
        
        /* Don't allow iobufs on directories */
        if( !rc && S_ISDIR(buf.st_mode) && !S_ISREG(buf.st_mode) )
            return __set_errno( EISDIR );
        else
            return open( fname, oflag, cflag );
    }
#endif
#endif
}


/*
 * Instead of closing an FD we keep it open and cache it for later reuse 
 * Note that this caching strategy only works if the process does not chdir.
 */
static void
fd_cache_close (const char *fname, FILEP_OR_FD fp)
{
    CLOSE_CACHE cc;

    assert (fp);
    if ( !fname || !*fname ) {
#ifdef HAVE_DOSISH_SYSTEM
        CloseHandle (fp);
#else
        close(fp);
#endif
        if( DBG_IOBUF )
          log_debug ("fd_cache_close (%d) real\n", (int)fp);
        return;
    }
    /* try to reuse a slot */
    for (cc=close_cache; cc; cc = cc->next ) {
        if ( cc->fp == INVALID_FP && !fd_cache_strcmp (cc->fname, fname) ) {
            cc->fp = fp;
            if( DBG_IOBUF )
                log_debug ("fd_cache_close (%s) used existing slot\n", fname);
            return;
        }
    }
    /* add a new one */
    if( DBG_IOBUF )
        log_debug ("fd_cache_close (%s) new slot created\n", fname);
    cc = xmalloc_clear (sizeof *cc + strlen (fname));
    strcpy (cc->fname, fname);
    cc->fp = fp;
    cc->next = close_cache;
    close_cache = cc;
}

/*
 * Do an direct_open on FNAME but first try to reuse one from the fd_cache
 */
static FILEP_OR_FD
fd_cache_open (const char *fname, const char *mode)
{
    CLOSE_CACHE cc;

    assert (fname);
    for (cc=close_cache; cc; cc = cc->next ) {
        if ( cc->fp != INVALID_FP && !fd_cache_strcmp (cc->fname, fname) ) {
            FILEP_OR_FD fp = cc->fp;
            cc->fp = INVALID_FP;
            if( DBG_IOBUF )
                log_debug ("fd_cache_open (%s) using cached fp\n", fname);
#ifdef HAVE_DOSISH_SYSTEM
            if (SetFilePointer (fp, 0, NULL, FILE_BEGIN) == 0xffffffff ) {
                log_error ("rewind file failed on handle %p: %s\n",
                           fp, w32_strerror (errno));
                fp = INVALID_FP;
            }
#else
            if ( lseek (fp, 0, SEEK_SET) == (off_t)-1 ) {
                log_error("can't rewind fd %d: %s\n", fp, strerror(errno) );
                fp = INVALID_FP;
            }
#endif
            return fp;
        }
    }
    if( DBG_IOBUF )
        log_debug ("fd_cache_open (%s) not cached\n", fname);
    return direct_open (fname, mode);
}


#endif /*FILE_FILTER_USES_STDIO*/


/****************
 * Read data from a file into buf which has an allocated length of *LEN.
 * return the number of read bytes in *LEN. OPAQUE is the FILE * of
 * the stream. A is not used.
 * control may be:
 * IOBUFCTRL_INIT: called just before the function is linked into the
 *		   list of function. This can be used to prepare internal
 *		   data structures of the function.
 * IOBUFCTRL_FREE: called just before the function is removed from the
 *		    list of functions and can be used to release internal
 *		    data structures or close a file etc.
 * IOBUFCTRL_UNDERFLOW: called by iobuf_underflow to fill the buffer
 *		    with new stuff. *RET_LEN is the available size of the
 *		    buffer, and should be set to the number of bytes
 *		    which were put into the buffer. The function
 *		    returns 0 to indicate success, -1 on EOF and
 *		    G10ERR_xxxxx for other errors.
 *
 * IOBUFCTRL_FLUSH: called by iobuf_flush() to write out the collected stuff.
 *		    *RET_LAN is the number of bytes in BUF.
 *
 * IOBUFCTRL_CANCEL: send to all filters on behalf of iobuf_cancel.  The
 *		    filter may take appropriate action on this message.
 */
static int
file_filter(void *opaque, int control, IOBUF chain, byte *buf, size_t *ret_len)
{
    file_filter_ctx_t *a = opaque;
    FILEP_OR_FD f = a->fp;
    size_t size = *ret_len;
    size_t nbytes = 0;
    int rc = 0;

#ifdef FILE_FILTER_USES_STDIO
    if( control == IOBUFCTRL_UNDERFLOW ) {
	assert( size ); /* need a buffer */
	if ( feof(f)) {	/* On terminals you could easiely read as many EOFs as you call 	*/
	    rc = -1;		/* fread() or fgetc() repeatly. Every call will block until you press	*/
	    *ret_len = 0;	/* CTRL-D. So we catch this case before we call fread() again.		*/
	}
	else {
	    clearerr( f );
	    nbytes = fread( buf, 1, size, f );
	    if( feof(f) && !nbytes ) {
		rc = -1; /* okay: we can return EOF now. */
            }
	    else if( ferror(f) && errno != EPIPE  ) {
		log_error("%s: read error: %s\n",
			  a->fname, strerror(errno));
		rc = G10ERR_READ_FILE;
	    }
	    *ret_len = nbytes;
	}
    }
    else if( control == IOBUFCTRL_FLUSH ) {
	if( size ) {
	    clearerr( f );
	    nbytes = fwrite( buf, 1, size, f );
	    if( ferror(f) ) {
		log_error("%s: write error: %s\n", a->fname, strerror(errno));
		rc = G10ERR_WRITE_FILE;
	    }
	}
	*ret_len = nbytes;
    }
    else if( control == IOBUFCTRL_INIT ) {
        a->keep_open = a->no_cache = 0;
    }
    else if( control == IOBUFCTRL_DESC ) {
	*(char**)buf = "file_filter";
    }
    else if( control == IOBUFCTRL_FREE ) {
	if( f != stdin && f != stdout ) {
	    if( DBG_IOBUF )
		log_debug("%s: close fd %d\n", a->fname, fileno(f) );
            if (!a->keep_open)
                fclose(f);
	}
	f = NULL;
	xfree(a); /* we can free our context now */
    }
#else /* !stdio implementation */

    if( control == IOBUFCTRL_UNDERFLOW ) {
	assert( size ); /* need a buffer */
	if ( a->eof_seen) {
	    rc = -1;		
	    *ret_len = 0;	
	}
	else {
#ifdef HAVE_DOSISH_SYSTEM
            unsigned long nread;

            nbytes = 0;
            if ( !ReadFile ( f, buf, size, &nread, NULL ) ) {
                if ((int)GetLastError () != ERROR_BROKEN_PIPE) {
                    log_error ("%s: read error: %s\n", a->fname,
                               w32_strerror (0));
                    rc = G10ERR_READ_FILE;
                }
            }
            else if ( !nread ) {
                a->eof_seen = 1;
                rc = -1;
            }
            else {
                nbytes = nread;
            }

#else

            int n;

            nbytes = 0;
            do {
                n = read ( f, buf, size );
            } while (n == -1 && errno == EINTR );
            if ( n == -1 ) { /* error */
                if (errno != EPIPE) {
                    log_error("%s: read error: %s\n",
                              a->fname, strerror(errno));
                    rc = G10ERR_READ_FILE;
                }
            }
            else if ( !n ) { /* eof */
                a->eof_seen = 1;
                rc = -1;
            }
            else {
                nbytes = n;
            }
#endif
	    *ret_len = nbytes;
	}
    }
    else if( control == IOBUFCTRL_FLUSH ) {
	if( size ) {
#ifdef HAVE_DOSISH_SYSTEM
            byte *p = buf;
            unsigned long n;

            nbytes = size;
            do {
                if (size && !WriteFile (f,  p, nbytes, &n, NULL)) {
                    log_error ("%s: write error: %s\n", a->fname,
                               w32_strerror (0));
                    rc = G10ERR_WRITE_FILE;
                    break;
                }
                p += n;
                nbytes -= n;
            } while ( nbytes );
            nbytes = p - buf;
#else
            byte *p = buf;
            int n;

            nbytes = size;
            do {
                do {
                    n = write ( f, p, nbytes );
                } while ( n == -1 && errno == EINTR );
                if ( n > 0 ) {
                    p += n;
                    nbytes -= n;
                }
            } while ( n != -1 && nbytes );
	    if( n == -1 ) {
		log_error("%s: write error: %s\n", a->fname, strerror(errno));
		rc = G10ERR_WRITE_FILE;
	    }
            nbytes = p - buf;
#endif
	}
	*ret_len = nbytes;
    }
    else if ( control == IOBUFCTRL_INIT ) {
        a->eof_seen = 0;
        a->keep_open = 0;
        a->no_cache = 0;
    }
    else if ( control == IOBUFCTRL_DESC ) {
	*(char**)buf = "file_filter(fd)";
    }
    else if ( control == IOBUFCTRL_FREE ) {
#ifdef HAVE_DOSISH_SYSTEM
        if ( f != FILEP_OR_FD_FOR_STDIN && f != FILEP_OR_FD_FOR_STDOUT ) {
	    if( DBG_IOBUF )
		log_debug("%s: close handle %p\n", a->fname, f );
            if (!a->keep_open)
                fd_cache_close (a->no_cache?NULL:a->fname, f);
        }
#else
	if ( (int)f != 0 && (int)f != 1 ) {
	    if( DBG_IOBUF )
		log_debug("%s: close fd %d\n", a->fname, f );
            if (!a->keep_open)
                fd_cache_close (a->no_cache?NULL:a->fname, f);
	}
	f = INVALID_FP;
#endif
	xfree (a); /* we can free our context now */
    }
#endif /* !stdio implementation */
    return rc;
}

#ifdef _WIN32
/* Becuase sockets are an special object under Lose32 we have to
 * use a special filter */
static int
sock_filter (void *opaque, int control, IOBUF chain, byte *buf, size_t *ret_len)
{
    sock_filter_ctx_t *a = opaque;
    size_t size = *ret_len;
    size_t nbytes = 0;
    int rc = 0;

    if( control == IOBUFCTRL_UNDERFLOW ) {
	assert( size ); /* need a buffer */
	if ( a->eof_seen) {
	    rc = -1;		
	    *ret_len = 0;	
	}
	else {
            int nread;

            nread = recv ( a->sock, buf, size, 0 );
            if ( nread == SOCKET_ERROR ) {
                int ec = (int)WSAGetLastError ();
                log_error("socket read error: ec=%d\n", ec);
                rc = G10ERR_READ_FILE;
            }
            else if ( !nread ) {
                a->eof_seen = 1;
                rc = -1;
            }
            else {
                nbytes = nread;
            }
	    *ret_len = nbytes;
	}
    }
    else if( control == IOBUFCTRL_FLUSH ) {
	if( size ) {
            byte *p = buf;
            int n;

            nbytes = size;
            do {
                n = send (a->sock, p, nbytes, 0);
                if ( n == SOCKET_ERROR ) {
                    int ec = (int)WSAGetLastError ();
                    log_error("socket write error: ec=%d\n", ec);
                    rc = G10ERR_WRITE_FILE;
                    break;
                }
                p += n;
                nbytes -= n;
            } while ( nbytes );
            nbytes = p - buf;
	}
	*ret_len = nbytes;
    }
    else if ( control == IOBUFCTRL_INIT ) {
        a->eof_seen = 0;
        a->keep_open = 0;
        a->no_cache = 0;
    }
    else if ( control == IOBUFCTRL_DESC ) {
	*(char**)buf = "sock_filter";
    }
    else if ( control == IOBUFCTRL_FREE ) {
        if (!a->keep_open)
            closesocket (a->sock);
	xfree (a); /* we can free our context now */
    }
    return rc;
}
#endif /*_WIN32*/

/****************
 * This is used to implement the block write mode.
 * Block reading is done on a byte by byte basis in readbyte(),
 * without a filter
 */
static int
block_filter(void *opaque, int control, IOBUF chain, byte *buf, size_t *ret_len)
{
    block_filter_ctx_t *a = opaque;
    size_t size = *ret_len;
    int c, needed, rc = 0;
    char *p;

    if( control == IOBUFCTRL_UNDERFLOW ) {
	size_t n=0;

	p = buf;
	assert( size ); /* need a buffer */
	if( a->eof ) /* don't read any further */
	    rc = -1;
	while( !rc && size ) {
	    if( !a->size ) { /* get the length bytes */
		if( a->partial == 2 ) {
		    a->eof = 1;
		    if( !n )
			rc = -1;
		    break;
		}
		else if( a->partial ) {
		    /* These OpenPGP introduced huffman like encoded length
		     * bytes are really a mess :-( */
		    if( a->first_c ) {
			c = a->first_c;
			a->first_c = 0;
		    }
		    else if( (c = iobuf_get(chain)) == -1 ) {
			log_error("block_filter: 1st length byte missing\n");
			rc = G10ERR_READ_FILE;
			break;
		    }
		    if( c < 192 ) {
			a->size = c;
			a->partial = 2;
			if( !a->size ) {
			    a->eof = 1;
			    if( !n )
				rc = -1;
			    break;
			}
		    }
		    else if( c < 224 ) {
			a->size = (c - 192) * 256;
			if( (c = iobuf_get(chain)) == -1 ) {
			    log_error("block_filter: 2nd length byte missing\n");
			    rc = G10ERR_READ_FILE;
			    break;
			}
			a->size += c + 192;
			a->partial = 2;
			if( !a->size ) {
			    a->eof = 1;
			    if( !n )
				rc = -1;
			    break;
			}
		    }
		    else if( c == 255 ) {
			a->size  = iobuf_get(chain) << 24;
			a->size |= iobuf_get(chain) << 16;
			a->size |= iobuf_get(chain) << 8;
			if( (c = iobuf_get(chain)) == -1 ) {
			    log_error("block_filter: invalid 4 byte length\n");
			    rc = G10ERR_READ_FILE;
			    break;
			}
			a->size |= c;
			a->partial = 2;
			if( !a->size ) {
			    a->eof = 1;
			    if( !n )
				rc = -1;
			    break;
			}
		    }
		    else { /* next partial body length */
			a->size = 1 << (c & 0x1f);
		    }
	    /*	log_debug("partial: ctx=%p c=%02x size=%u\n", a, c, a->size);*/
		}
		else
		  BUG();
	    }

	    while( !rc && size && a->size ) {
		needed = size < a->size ? size : a->size;
		c = iobuf_read( chain, p, needed );
		if( c < needed ) {
		    if( c == -1 ) c = 0;
		    log_error("block_filter %p: read error (size=%lu,a->size=%lu)\n",
			      a,  (ulong)size+c, (ulong)a->size+c);
		    rc = G10ERR_READ_FILE;
		}
		else {
		    size -= c;
		    a->size -= c;
		    p += c;
		    n += c;
		}
	    }
	}
	*ret_len = n;
    }
    else if( control == IOBUFCTRL_FLUSH ) {
	if( a->partial ) { /* the complicated openpgp scheme */
	    size_t blen, n, nbytes = size + a->buflen;

	    assert( a->buflen <= OP_MIN_PARTIAL_CHUNK );
	    if( nbytes < OP_MIN_PARTIAL_CHUNK ) {
		/* not enough to write a partial block out; so we store it*/
		if( !a->buffer )
		    a->buffer = xmalloc( OP_MIN_PARTIAL_CHUNK );
		memcpy( a->buffer + a->buflen, buf, size );
		a->buflen += size;
	    }
	    else { /* okay, we can write out something */
		/* do this in a loop to use the most efficient block lengths */
		p = buf;
		do {
		    /* find the best matching block length - this is limited
		     * by the size of the internal buffering */
		    for( blen=OP_MIN_PARTIAL_CHUNK*2,
			    c=OP_MIN_PARTIAL_CHUNK_2POW+1; blen <= nbytes;
							    blen *=2, c++ )
			;
		    blen /= 2; c--;
		    /* write the partial length header */
		    assert( c <= 0x1f ); /*;-)*/
		    c |= 0xe0;
		    iobuf_put( chain, c );
		    if( (n=a->buflen) ) { /* write stuff from the buffer */
			assert( n == OP_MIN_PARTIAL_CHUNK);
			if( iobuf_write(chain, a->buffer, n ) )
			    rc = G10ERR_WRITE_FILE;
			a->buflen = 0;
			nbytes -= n;
		    }
		    if( (n = nbytes) > blen )
			n = blen;
		    if( n && iobuf_write(chain, p, n ) )
			rc = G10ERR_WRITE_FILE;
		    p += n;
		    nbytes -= n;
		} while( !rc && nbytes >= OP_MIN_PARTIAL_CHUNK );
		/* store the rest in the buffer */
		if( !rc && nbytes ) {
		    assert( !a->buflen );
		    assert( nbytes < OP_MIN_PARTIAL_CHUNK );
		    if( !a->buffer )
			a->buffer = xmalloc( OP_MIN_PARTIAL_CHUNK );
		    memcpy( a->buffer, p, nbytes );
		    a->buflen = nbytes;
		}
	    }
	}
	else
	  BUG();
    }
    else if( control == IOBUFCTRL_INIT ) {
	if( DBG_IOBUF )
	    log_debug("init block_filter %p\n", a );
	if( a->partial )
	    a->count = 0;
	else if( a->use == 1 )
	    a->count = a->size = 0;
	else
	    a->count = a->size; /* force first length bytes */
	a->eof = 0;
	a->buffer = NULL;
	a->buflen = 0;
    }
    else if( control == IOBUFCTRL_DESC ) {
	*(char**)buf = "block_filter";
    }
    else if( control == IOBUFCTRL_FREE ) {
	if( a->use == 2 ) { /* write the end markers */
	    if( a->partial ) {
		u32 len;
		/* write out the remaining bytes without a partial header
		 * the length of this header may be 0 - but if it is
		 * the first block we are not allowed to use a partial header
		 * and frankly we can't do so, because this length must be
		 * a power of 2. This is _really_ complicated because we
		 * have to check the possible length of a packet prior
		 * to it's creation: a chain of filters becomes complicated
		 * and we need a lot of code to handle compressed packets etc.
		 *   :-(((((((
		 */
		/* construct header */
		len = a->buflen;
		/*log_debug("partial: remaining length=%u\n", len );*/
		if( len < 192 )
		    rc = iobuf_put(chain, len );
		else if( len < 8384 ) {
		    if( !(rc=iobuf_put( chain, ((len-192) / 256) + 192)) )
			rc = iobuf_put( chain, ((len-192) % 256));
		}
		else { /* use a 4 byte header */
		    if( !(rc=iobuf_put( chain, 0xff )) )
			if( !(rc=iobuf_put( chain, (len >> 24)&0xff )) )
			    if( !(rc=iobuf_put( chain, (len >> 16)&0xff )) )
				if( !(rc=iobuf_put( chain, (len >> 8)&0xff )))
				    rc=iobuf_put( chain, len & 0xff );
		}
		if( !rc && len )
		    rc = iobuf_write(chain, a->buffer, len );
		if( rc ) {
		    log_error("block_filter: write error: %s\n",strerror(errno));
		    rc = G10ERR_WRITE_FILE;
		}
		xfree( a->buffer ); a->buffer = NULL; a->buflen = 0;
	    }
	    else
	      BUG();
	}
	else if( a->size ) {
	    log_error("block_filter: pending bytes!\n");
	}
	if( DBG_IOBUF )
	    log_debug("free block_filter %p\n", a );
	xfree(a); /* we can free our context now */
    }

    return rc;
}


static void
print_chain( IOBUF a )
{
    if( !DBG_IOBUF )
	return;
    for(; a; a = a->chain ) {
	size_t dummy_len = 0;
	const char *desc = "[none]";

	if( a->filter )
	    a->filter( a->filter_ov, IOBUFCTRL_DESC, NULL,
						(byte*)&desc, &dummy_len );

	log_debug("iobuf chain: %d.%d `%s' filter_eof=%d start=%d len=%d\n",
		   a->no, a->subno, desc?desc:"?", a->filter_eof,
		   (int)a->d.start, (int)a->d.len );
    }
}

int
iobuf_print_chain( IOBUF a )
{
    print_chain(a);
    return 0;
}

/****************
 * Allocate a new io buffer, with no function assigned.
 * Use is the desired usage: 1 for input, 2 for output, 3 for temp buffer
 * BUFSIZE is a suggested buffer size.
 */
IOBUF
iobuf_alloc(int use, size_t bufsize)
{
    IOBUF a;
    static int number=0;

    a = xmalloc_clear(sizeof *a);
    a->use = use;
    a->d.buf = xmalloc( bufsize );
    a->d.size = bufsize;
    a->no = ++number;
    a->subno = 0;
    a->opaque = NULL;
    a->real_fname = NULL;
    return a;
}

int
iobuf_close ( IOBUF a )
{
    IOBUF a2;
    size_t dummy_len=0;
    int rc=0;

    if( a && a->directfp ) {
	fclose( a->directfp );
	xfree( a->real_fname );
	if( DBG_IOBUF )
	    log_debug("iobuf_close -> %p\n", a->directfp );
	return 0;
    }

    for( ; a && !rc ; a = a2 ) {
	a2 = a->chain;
	if( a->use == 2 && (rc=iobuf_flush(a)) )
	    log_error("iobuf_flush failed on close: %s\n", g10_errstr(rc));

	if( DBG_IOBUF )
	    log_debug("iobuf-%d.%d: close `%s'\n", a->no, a->subno,
                      a->desc?a->desc:"?");
	if( a->filter && (rc = a->filter(a->filter_ov, IOBUFCTRL_FREE,
					 a->chain, NULL, &dummy_len)) )
	    log_error("IOBUFCTRL_FREE failed on close: %s\n", g10_errstr(rc) );
	xfree(a->real_fname);
        if (a->d.buf) {
            memset (a->d.buf, 0, a->d.size); /* erase the buffer */
            xfree(a->d.buf);
        }
	xfree(a);
    }
    return rc;
}

int
iobuf_cancel( IOBUF a )
{
    const char *s;
    IOBUF a2;
    int rc;
#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
    char *remove_name = NULL;
#endif

    if( a && a->use == 2 ) {
	s = iobuf_get_real_fname(a);
	if( s && *s ) {
#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
	    remove_name = xstrdup ( s );
#else
	    remove(s);
#endif
	}
    }

    /* send a cancel message to all filters */
    for( a2 = a; a2 ; a2 = a2->chain ) {
	size_t dummy;
	if( a2->filter )
	    a2->filter( a2->filter_ov, IOBUFCTRL_CANCEL, a2->chain,
							 NULL, &dummy );
    }

    rc = iobuf_close(a);
#if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
    if ( remove_name ) {
	/* Argg, MSDOS does not allow to remove open files.  So
	 * we have to do it here */
	remove ( remove_name );
	xfree ( remove_name );
    }
#endif
    return rc;
}


/****************
 * create a temporary iobuf, which can be used to collect stuff
 * in an iobuf and later be written by iobuf_write_temp() to another
 * iobuf.
 */
IOBUF
iobuf_temp()
{
    IOBUF a;

    a = iobuf_alloc(3, IOBUF_BUFFER_SIZE );

    return a;
}

IOBUF
iobuf_temp_with_content( const char *buffer, size_t length )
{
    IOBUF a;

    a = iobuf_alloc(3, length );
    memcpy( a->d.buf, buffer, length );
    a->d.len = length;

    return a;
}

void
iobuf_enable_special_filenames ( int yes )
{
    special_names_enabled = yes;
}

/*
 * see whether the filename has the for "-&nnnn", where n is a
 * non-zero number.
 * Returns this number or -1 if it is not the case.
 */
static int
check_special_filename ( const char *fname )
{
    if ( special_names_enabled
         && fname && *fname == '-' && fname[1] == '&' ) {
        int i;

        fname += 2;
        for (i=0; digitp (fname+i); i++ )
            ;
        if ( !fname[i] ) 
            return atoi (fname);
    }
    return -1;
}

/* This fucntion returns true if FNAME indicates a PIPE (stdout or
   stderr) or a special file name if those are enabled. */
int
iobuf_is_pipe_filename (const char *fname)
{
  if (!fname || (*fname=='-' && !fname[1]) )
    return 1;
  return check_special_filename (fname) != -1;
}

/****************
 * Create a head iobuf for reading from a file
 * returns: NULL if an error occures and sets errno
 */
IOBUF
iobuf_open( const char *fname )
{
    IOBUF a;
    FILEP_OR_FD fp;
    file_filter_ctx_t *fcx;
    size_t len;
    int print_only = 0;
    int fd;

    if( !fname || (*fname=='-' && !fname[1])  ) {
	fp = FILEP_OR_FD_FOR_STDIN;
#ifdef USE_SETMODE
	setmode ( my_fileno(fp) , O_BINARY );
#endif
	fname = "[stdin]";
	print_only = 1;
    }
    else if ( (fd = check_special_filename ( fname )) != -1 )
        return iobuf_fdopen ( translate_file_handle (fd,0), "rb" );
    else if( (fp = my_fopen_ro(fname, "rb")) == INVALID_FP )
	return NULL;
    a = iobuf_alloc(1, IOBUF_BUFFER_SIZE );
    fcx = xmalloc( sizeof *fcx + strlen(fname) );
    fcx->fp = fp;
    fcx->print_only_name = print_only;
    strcpy(fcx->fname, fname );
    if( !print_only )
	a->real_fname = xstrdup( fname );
    a->filter = file_filter;
    a->filter_ov = fcx;
    file_filter( fcx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    file_filter( fcx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: open `%s' fd=%d\n",
		   a->no, a->subno, fname, (int)my_fileno(fcx->fp) );

    return a;
}

/****************
 * Create a head iobuf for reading from a file
 * returns: NULL if an error occures and sets errno
 */
IOBUF
iobuf_fdopen( int fd, const char *mode )
{
    IOBUF a;
    FILEP_OR_FD fp;
    file_filter_ctx_t *fcx;
    size_t len;

#ifdef FILE_FILTER_USES_STDIO
    if( !(fp = fdopen(fd, mode)) )
	return NULL;
#else
    fp = (FILEP_OR_FD)fd;
#endif
    a = iobuf_alloc( strchr( mode, 'w')? 2:1, IOBUF_BUFFER_SIZE );
    fcx = xmalloc( sizeof *fcx + 20 );
    fcx->fp = fp;
    fcx->print_only_name = 1;
    sprintf(fcx->fname, "[fd %d]", fd );
    a->filter = file_filter;
    a->filter_ov = fcx;
    file_filter( fcx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    file_filter( fcx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: fdopen `%s'\n", a->no, a->subno, fcx->fname );
    iobuf_ioctl (a,3,1,NULL); /* disable fd caching */
    return a;
}


IOBUF
iobuf_sockopen ( int fd, const char *mode )
{
    IOBUF a;
#ifdef _WIN32
    sock_filter_ctx_t *scx;
    size_t len;

    a = iobuf_alloc( strchr( mode, 'w')? 2:1, IOBUF_BUFFER_SIZE );
    scx = xmalloc( sizeof *scx + 25 );
    scx->sock = fd;
    scx->print_only_name = 1;
    sprintf(scx->fname, "[sock %d]", fd );
    a->filter = sock_filter;
    a->filter_ov = scx;
    sock_filter( scx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    sock_filter( scx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: sockopen `%s'\n", a->no, a->subno, scx->fname);
    iobuf_ioctl (a,3,1,NULL); /* disable fd caching */ 
#else
    a = iobuf_fdopen (fd, mode);
#endif
    return a;
}

/****************
 * create an iobuf for writing to a file; the file will be created.
 */
IOBUF
iobuf_create( const char *fname )
{
    IOBUF a;
    FILEP_OR_FD fp;
    file_filter_ctx_t *fcx;
    size_t len;
    int print_only = 0;
    int fd;

    if( !fname || (*fname=='-' && !fname[1]) ) {
	fp = FILEP_OR_FD_FOR_STDOUT;
#ifdef USE_SETMODE
	setmode ( my_fileno(fp) , O_BINARY );
#endif
	fname = "[stdout]";
	print_only = 1;
    }
    else if ( (fd = check_special_filename ( fname )) != -1 )
        return iobuf_fdopen ( translate_file_handle (fd, 1), "wb" );
    else if( (fp = my_fopen(fname, "wb")) == INVALID_FP )
	return NULL;
    a = iobuf_alloc(2, IOBUF_BUFFER_SIZE );
    fcx = xmalloc( sizeof *fcx + strlen(fname) );
    fcx->fp = fp;
    fcx->print_only_name = print_only;
    strcpy(fcx->fname, fname );
    if( !print_only )
	a->real_fname = xstrdup( fname );
    a->filter = file_filter;
    a->filter_ov = fcx;
    file_filter( fcx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    file_filter( fcx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: create `%s'\n", a->no, a->subno, 
                  a->desc?a->desc:"?" );

    return a;
}

/****************
 * append to an iobuf; if the file does not exist, create it.
 * cannot be used for stdout.
 * Note: This is not used.
 */
#if 0 /* not used */
IOBUF
iobuf_append( const char *fname )
{
    IOBUF a;
    FILE *fp;
    file_filter_ctx_t *fcx;
    size_t len;

    if( !fname )
	return NULL;
    else if( !(fp = my_fopen(fname, "ab")) )
	return NULL;
    a = iobuf_alloc(2, IOBUF_BUFFER_SIZE );
    fcx = xmalloc( sizeof *fcx + strlen(fname) );
    fcx->fp = fp;
    strcpy(fcx->fname, fname );
    a->real_fname = xstrdup( fname );
    a->filter = file_filter;
    a->filter_ov = fcx;
    file_filter( fcx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    file_filter( fcx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: append `%s'\n", a->no, a->subno, 
                  a->desc?a->desc:"?" );

    return a;
}
#endif

IOBUF
iobuf_openrw( const char *fname )
{
    IOBUF a;
    FILEP_OR_FD fp;
    file_filter_ctx_t *fcx;
    size_t len;

    if( !fname )
	return NULL;
    else if( (fp = my_fopen(fname, "r+b")) == INVALID_FP )
	return NULL;
    a = iobuf_alloc(2, IOBUF_BUFFER_SIZE );
    fcx = xmalloc( sizeof *fcx + strlen(fname) );
    fcx->fp = fp;
    strcpy(fcx->fname, fname );
    a->real_fname = xstrdup( fname );
    a->filter = file_filter;
    a->filter_ov = fcx;
    file_filter( fcx, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &len );
    file_filter( fcx, IOBUFCTRL_INIT, NULL, NULL, &len );
    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: openrw `%s'\n", a->no, a->subno, 
                  a->desc?a->desc:"?");

    return a;
}


int
iobuf_ioctl ( IOBUF a, int cmd, int intval, void *ptrval )
{
    if ( cmd == 1 ) {  /* keep system filepointer/descriptor open */
        if( DBG_IOBUF )
            log_debug("iobuf-%d.%d: ioctl `%s' keep=%d\n",
                      a? a->no:-1, a?a->subno:-1, 
                      a&&a->desc?a->desc:"?", intval );
        for( ; a; a = a->chain )
            if( !a->chain && a->filter == file_filter ) {
                file_filter_ctx_t *b = a->filter_ov;
                b->keep_open = intval;
                return 0;
            }
#ifdef _WIN32
            else if( !a->chain && a->filter == sock_filter ) {
                sock_filter_ctx_t *b = a->filter_ov;
                b->keep_open = intval;
                return 0;
            }
#endif
    }
    else if ( cmd == 2 ) {  /* invalidate cache */
        if( DBG_IOBUF )
            log_debug("iobuf-*.*: ioctl `%s' invalidate\n",
                      ptrval? (char*)ptrval:"[all]");
        if ( !a && !intval ) {
#ifndef FILE_FILTER_USES_STDIO
	    return fd_cache_invalidate (ptrval);
#endif
            return 0;
	 }
    }
    else if ( cmd == 3 ) {  /* disallow/allow caching */
        if( DBG_IOBUF )
            log_debug("iobuf-%d.%d: ioctl `%s' no_cache=%d\n",
                      a? a->no:-1, a?a->subno:-1, 
                      a&&a->desc?a->desc:"?", intval );
        for( ; a; a = a->chain )
            if( !a->chain && a->filter == file_filter ) {
                file_filter_ctx_t *b = a->filter_ov;
                b->no_cache = intval;
                return 0;
            }
#ifdef _WIN32
            else if( !a->chain && a->filter == sock_filter ) {
                sock_filter_ctx_t *b = a->filter_ov;
                b->no_cache = intval;
                return 0;
            }
#endif
    }
    else if(cmd==4)
      {
	/* Do a fsync on the open fd and return any errors to the
	   caller of iobuf_ioctl */
        if( DBG_IOBUF )
	  log_debug("iobuf-*.*: ioctl `%s' fsync\n",
                      ptrval? (char*)ptrval:"<null>");

	if(!a && !intval && ptrval)
	  {
#ifndef FILE_FILTER_USES_STDIO
	    return fd_cache_synchronize (ptrval);
#else
	    return 0;
#endif
	  }
      }

    return -1;
}


/****************
 * Register an i/o filter.
 */
int
iobuf_push_filter( IOBUF a,
		   int (*f)(void *opaque, int control,
		   IOBUF chain, byte *buf, size_t *len), void *ov )
{
    return iobuf_push_filter2( a, f, ov, 0 );
}

int
iobuf_push_filter2( IOBUF a,
		    int (*f)(void *opaque, int control,
		    IOBUF chain, byte *buf, size_t *len),
		    void *ov, int rel_ov )
{
    IOBUF b;
    size_t dummy_len=0;
    int rc=0;

    if( a->directfp )
	BUG();

    if( a->use == 2 && (rc=iobuf_flush(a)) )
	return rc;
    /* make a copy of the current stream, so that
     * A is the new stream and B the original one.
     * The contents of the buffers are transferred to the
     * new stream.
     */
    b = xmalloc(sizeof *b);
    memcpy(b, a, sizeof *b );
    /* fixme: it is stupid to keep a copy of the name at every level
     * but we need the name somewhere because the name known by file_filter
     * may have been released when we need the name of the file */
    b->real_fname = a->real_fname? xstrdup(a->real_fname):NULL;
    /* remove the filter stuff from the new stream */
    a->filter = NULL;
    a->filter_ov = NULL;
    a->filter_ov_owner = 0;
    a->filter_eof = 0;
    if( a->use == 3 )
	a->use = 2;  /* make a write stream from a temp stream */

    if( a->use == 2 ) { /* allocate a fresh buffer for the original stream */
	b->d.buf = xmalloc( a->d.size );
	b->d.len = 0;
	b->d.start = 0;
    }
    else { /* allocate a fresh buffer for the new stream */
	a->d.buf = xmalloc( a->d.size );
	a->d.len = 0;
	a->d.start = 0;
    }
    /* disable nlimit for the new stream */
    a->ntotal = b->ntotal + b->nbytes;
    a->nlimit = a->nbytes = 0;
    a->nofast &= ~1;
    /* make a link from the new stream to the original stream */
    a->chain = b;
    a->opaque = b->opaque;

    /* setup the function on the new stream */
    a->filter = f;
    a->filter_ov = ov;
    a->filter_ov_owner = rel_ov;

    a->subno = b->subno + 1;
    f( ov, IOBUFCTRL_DESC, NULL, (byte*)&a->desc, &dummy_len );

    if( DBG_IOBUF ) {
	log_debug("iobuf-%d.%d: push `%s'\n", a->no, a->subno, 
                  a->desc?a->desc:"?" );
	print_chain( a );
    }

    /* now we can initialize the new function if we have one */
    if( a->filter && (rc = a->filter(a->filter_ov, IOBUFCTRL_INIT, a->chain,
		       NULL, &dummy_len)) )
	log_error("IOBUFCTRL_INIT failed: %s\n", g10_errstr(rc) );
    return rc;
}

/****************
 * Remove an i/o filter.
 */
static int
pop_filter( IOBUF a, int (*f)(void *opaque, int control,
		      IOBUF chain, byte *buf, size_t *len), void *ov )
{
    IOBUF b;
    size_t dummy_len=0;
    int rc=0;

    if( a->directfp )
	BUG();

    if( DBG_IOBUF )
	log_debug("iobuf-%d.%d: pop `%s'\n", a->no, a->subno,
                  a->desc?a->desc:"?" );
    if( !a->filter ) { /* this is simple */
	b = a->chain;
	assert(b);
	xfree(a->d.buf);
	xfree(a->real_fname);
	memcpy(a,b, sizeof *a);
	xfree(b);
	return 0;
    }
    for(b=a ; b; b = b->chain )
	if( b->filter == f && (!ov || b->filter_ov == ov) )
	    break;
    if( !b )
	log_bug("pop_filter(): filter function not found\n");

    /* flush this stream if it is an output stream */
    if( a->use == 2 && (rc=iobuf_flush(b)) ) {
	log_error("iobuf_flush failed in pop_filter: %s\n", g10_errstr(rc));
	return rc;
    }
    /* and tell the filter to free it self */
    if( b->filter && (rc = b->filter(b->filter_ov, IOBUFCTRL_FREE, b->chain,
		       NULL, &dummy_len)) ) {
	log_error("IOBUFCTRL_FREE failed: %s\n", g10_errstr(rc) );
	return rc;
    }
    if( b->filter_ov && b->filter_ov_owner ) {
	xfree( b->filter_ov );
	b->filter_ov = NULL;
    }


    /* and see how to remove it */
    if( a == b && !b->chain )
	log_bug("can't remove the last filter from the chain\n");
    else if( a == b ) { /* remove the first iobuf from the chain */
	/* everything from b is copied to a. This is save because
	 * a flush has been done on the to be removed entry
	 */
	b = a->chain;
	xfree(a->d.buf);
	xfree(a->real_fname);
	memcpy(a,b, sizeof *a);
	xfree(b);
	if( DBG_IOBUF )
	   log_debug("iobuf-%d.%d: popped filter\n", a->no, a->subno );
    }
    else if( !b->chain ) { /* remove the last iobuf from the chain */
	log_bug("Ohh jeee, trying to remove a head filter\n");
    }
    else {  /* remove an intermediate iobuf from the chain */
	log_bug("Ohh jeee, trying to remove an intermediate filter\n");
    }

    return rc;
}


/****************
 * read underflow: read more bytes into the buffer and return
 * the first byte or -1 on EOF.
 */
static int
underflow(IOBUF a)
{
    size_t len;
    int rc;

    assert( a->d.start == a->d.len );
    if( a->use == 3 )
	return -1; /* EOF because a temp buffer can't do an underflow */

    if( a->filter_eof ) {
	if( a->chain ) {
	    IOBUF b = a->chain;
	    if( DBG_IOBUF )
		log_debug("iobuf-%d.%d: pop `%s' in underflow\n",
                          a->no, a->subno, a->desc?a->desc:"?" );
	    xfree(a->d.buf);
	    xfree(a->real_fname);
	    memcpy(a, b, sizeof *a);
	    xfree(b);
	    print_chain(a);
	}
	else
             a->filter_eof = 0;  /* for the top level filter */
	if( DBG_IOBUF )
	    log_debug("iobuf-%d.%d: underflow: eof (due to filter eof)\n",
						    a->no, a->subno );
	return -1; /* return one(!) EOF */
    }
    if( a->error ) {
	if( DBG_IOBUF )
	    log_debug("iobuf-%d.%d: error\n", a->no, a->subno );
	return -1;
    }

    if( a->directfp ) {
	FILE *fp = a->directfp;

	len = fread( a->d.buf, 1, a->d.size, fp);
	if( len < a->d.size ) {
	    if( ferror(fp) )
		a->error = 1;
	}
	a->d.len = len;
	a->d.start = 0;
	return len? a->d.buf[a->d.start++] : -1;
    }


    if( a->filter ) {
	len = a->d.size;
	if( DBG_IOBUF )
	    log_debug("iobuf-%d.%d: underflow: req=%lu\n",
                      a->no, a->subno, (ulong)len );
	rc = a->filter( a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
			a->d.buf, &len );
	if( DBG_IOBUF ) {
	    log_debug("iobuf-%d.%d: underflow: got=%lu rc=%d\n",
		    a->no, a->subno, (ulong)len, rc );
/*  	    if( a->no == 1 ) */
/*                   log_hexdump ("     data:", a->d.buf, len); */
	}
	if( a->use == 1 && rc == -1 ) { /* EOF: we can remove the filter */
	    size_t dummy_len=0;

	    /* and tell the filter to free itself */
	    if( (rc = a->filter(a->filter_ov, IOBUFCTRL_FREE, a->chain,
			       NULL, &dummy_len)) )
		log_error("IOBUFCTRL_FREE failed: %s\n", g10_errstr(rc) );
	    if( a->filter_ov && a->filter_ov_owner ) {
		xfree( a->filter_ov );
		a->filter_ov = NULL;
	    }
	    a->filter = NULL;
	    a->desc = NULL;
	    a->filter_ov = NULL;
	    a->filter_eof = 1;
	    if( !len && a->chain ) {
		IOBUF b = a->chain;
		if( DBG_IOBUF )
		    log_debug("iobuf-%d.%d: pop in underflow (!len)\n",
                              a->no, a->subno);
		xfree(a->d.buf);
		xfree(a->real_fname);
		memcpy(a,b, sizeof *a);
		xfree(b);
		print_chain(a);
	    }
	}
	else if( rc )
	    a->error = 1;

	if( !len ) {
	    if( DBG_IOBUF )
		log_debug("iobuf-%d.%d: underflow: eof\n", a->no, a->subno );
	    return -1;
	}
	a->d.len = len;
	a->d.start = 0;
	return a->d.buf[a->d.start++];
    }
    else {
	if( DBG_IOBUF )
	    log_debug("iobuf-%d.%d: underflow: eof (no filter)\n",
						    a->no, a->subno );
	return -1;  /* no filter; return EOF */
    }
}


int
iobuf_flush(IOBUF a)
{
    size_t len;
    int rc;

    if( a->directfp )
	return 0;

    if( a->use == 3 ) { /* increase the temp buffer */
	char *newbuf;
	size_t newsize = a->d.size + IOBUF_BUFFER_SIZE;

	if( DBG_IOBUF )
	  log_debug("increasing temp iobuf from %lu to %lu\n",
		    (ulong)a->d.size, (ulong)newsize );
	newbuf = xmalloc( newsize );
	memcpy( newbuf, a->d.buf, a->d.len );
	xfree(a->d.buf);
	a->d.buf = newbuf;
	a->d.size = newsize;
	return 0;
    }
    else if( a->use != 2 )
	log_bug("flush on non-output iobuf\n");
    else if( !a->filter )
	log_bug("iobuf_flush: no filter\n");
    len = a->d.len;
    rc = a->filter( a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len );
    if( !rc && len != a->d.len ) {
	log_info("iobuf_flush did not write all!\n");
	rc = G10ERR_WRITE_FILE;
    }
    else if( rc )
	a->error = 1;
    a->d.len = 0;

    return rc;
}


/****************
 * Read a byte from the iobuf; returns -1 on EOF
 */
int
iobuf_readbyte(IOBUF a)
{
    int c;

    /* nlimit does not work together with unget */
    /* nbytes is also not valid! */
    if( a->unget.buf ) {
	if( a->unget.start < a->unget.len )
	    return a->unget.buf[a->unget.start++];
	xfree(a->unget.buf);
	a->unget.buf = NULL;
	a->nofast &= ~2;
    }

    if( a->nlimit && a->nbytes >= a->nlimit )
	return -1; /* forced EOF */

    if( a->d.start < a->d.len ) {
	c = a->d.buf[a->d.start++];
    }
    else if( (c=underflow(a)) == -1 )
	return -1; /* EOF */

    a->nbytes++;
    return c;
}


int
iobuf_read(IOBUF a, byte *buf, unsigned buflen )
{
    int c, n;

    if( a->unget.buf || a->nlimit ) {
	/* handle special cases */
	for(n=0 ; n < buflen; n++ ) {
	    if( (c = iobuf_readbyte(a)) == -1 ) {
		if( !n )
		    return -1; /* eof */
		break;
	    }
	    else
		if( buf ) *buf = c;
	    if( buf ) buf++;
	}
	return n;
    }

    n = 0;
    do {
	if( n < buflen && a->d.start < a->d.len ) {
	    unsigned size = a->d.len - a->d.start;
	    if( size > buflen - n )
		size = buflen - n;
	    if( buf )
		memcpy( buf, a->d.buf + a->d.start, size );
	    n += size;
	    a->d.start += size;
	    if( buf )
		buf += size;
	}
	if( n < buflen ) {
	    if( (c=underflow(a)) == -1 ) {
		a->nbytes += n;
		return n? n : -1/*EOF*/;
	    }
	    if( buf )
		*buf++ = c;
	    n++;
	}
    } while( n < buflen );
    a->nbytes += n;
    return n;
}


/****************
 * Have a look at the iobuf.
 * NOTE: This only works in special cases.
 */
int
iobuf_peek(IOBUF a, byte *buf, unsigned buflen )
{
    int n=0;

    if( a->filter_eof )
	return -1;

    if( !(a->d.start < a->d.len) ) {
	if( underflow(a) == -1 )
	    return -1;
	/* and unget this character */
	assert(a->d.start == 1);
	a->d.start = 0;
    }

    for(n=0 ; n < buflen && (a->d.start+n) < a->d.len ; n++, buf++ )
	*buf = a->d.buf[n];
    return n;
}




int
iobuf_writebyte(IOBUF a, unsigned c)
{

    if( a->directfp )
	BUG();

    if( a->d.len == a->d.size )
	if( iobuf_flush(a) )
	    return -1;

    assert( a->d.len < a->d.size );
    a->d.buf[a->d.len++] = c;
    return 0;
}


int
iobuf_write(IOBUF a, byte *buf, unsigned buflen )
{

    if( a->directfp )
	BUG();

    do {
	if( buflen && a->d.len < a->d.size ) {
	    unsigned size = a->d.size - a->d.len;
	    if( size > buflen ) size = buflen;
	    memcpy( a->d.buf + a->d.len, buf, size );
	    buflen -= size;
	    buf += size;
	    a->d.len += size;
	}
	if( buflen ) {
	    if( iobuf_flush(a) )
		return -1;
	}
    } while( buflen );
    return 0;
}


int
iobuf_writestr(IOBUF a, const char *buf )
{
    for( ; *buf; buf++ )
	if( iobuf_writebyte(a, *buf) )
	    return -1;
    return 0;
}



/****************
 * copy the contents of TEMP to A.
 */
int
iobuf_write_temp( IOBUF a, IOBUF temp )
{
    while( temp->chain )
	pop_filter( temp, temp->filter, NULL );
    return iobuf_write(a, temp->d.buf, temp->d.len );
}

/****************
 * copy the contents of the temp io stream to BUFFER.
 */
size_t
iobuf_temp_to_buffer( IOBUF a, byte *buffer, size_t buflen )
{
    size_t n = a->d.len;

    if( n > buflen )
	n = buflen;
    memcpy( buffer, a->d.buf, n );
    return n;
}


/****************
 * Call this function to terminate processing of the temp stream
 * without closing it.	This removes all filters from the stream
 * makes sure that iobuf_get_temp_{buffer,length}() returns correct
 * values.
 */
void
iobuf_flush_temp( IOBUF temp )
{
    while( temp->chain )
	pop_filter( temp, temp->filter, NULL );
}


/****************
 * Set a limit on how many bytes may be read from the input stream A.
 * Setting the limit to 0 disables this feature.
 */
void
iobuf_set_limit( IOBUF a, off_t nlimit )
{
    if( nlimit )
	a->nofast |= 1;
    else
	a->nofast &= ~1;
    a->nlimit = nlimit;
    a->ntotal += a->nbytes;
    a->nbytes = 0;
}



/* Return the length of an open file A.  IF OVERFLOW is not NULL it
   will be set to true if the file is larger than what off_t can cope
   with.  The function return 0 on error or on overflow condition.  */
off_t
iobuf_get_filelength (IOBUF a, int *overflow )
{
    struct stat st;

    if (overflow)
      *overflow = 0;

    if( a->directfp )  {
	FILE *fp = a->directfp;

       if( !fstat(fileno(fp), &st) )
           return st.st_size;
	log_error("fstat() failed: %s\n", strerror(errno) );
	return 0;
    }

    /* Hmmm: file_filter may have already been removed */
    for( ; a; a = a->chain )
	if( !a->chain && a->filter == file_filter ) {
	    file_filter_ctx_t *b = a->filter_ov;
	    FILEP_OR_FD fp = b->fp;

#if defined(HAVE_DOSISH_SYSTEM) && !defined(FILE_FILTER_USES_STDIO)
            ulong size;
            static int (* __stdcall get_file_size_ex) 
              (void *handle, LARGE_INTEGER *size);
            static int get_file_size_ex_initialized;

            if (!get_file_size_ex_initialized)
              {
                void *handle;
                
                handle = dlopen ("kernel32.dll", RTLD_LAZY);
                if (handle)
                  {
                    get_file_size_ex = dlsym (handle, "GetFileSizeEx");
                    if (!get_file_size_ex)
                    dlclose (handle);
                  }
                get_file_size_ex_initialized = 1;
              }

            if (get_file_size_ex)
              {
                /* This is a newer system with GetFileSizeEx; we use
                   this then becuase it seem that GetFileSize won't
                   return a proper error in case a file is larger than
                   4GB. */
                LARGE_INTEGER size;
                
                if (get_file_size_ex (fp, &size))
                  {
                    if (!size.u.HighPart)
                      return size.u.LowPart;
                    if (overflow)
                      *overflow = 1;
                    return 0; 
                  }
              }
            else
              {
                if  ((size=GetFileSize (fp, NULL)) != 0xffffffff)
                  return size;
              }
            log_error ("GetFileSize for handle %p failed: %s\n",
                       fp, w32_strerror (0));
#else
            if( !fstat(my_fileno(fp), &st) )
		return st.st_size;
	    log_error("fstat() failed: %s\n", strerror(errno) );
#endif
	    break;
	}

    return 0;
}


/* Return the file descriptor of the underlying file or -1 if it is
   not available.  */
int 
iobuf_get_fd (IOBUF a)
{
  if (a->directfp)
    return fileno ( (FILE*)a->directfp );

  for ( ; a; a = a->chain )
    if (!a->chain && a->filter == file_filter)
      {
        file_filter_ctx_t *b = a->filter_ov;
        FILEP_OR_FD fp = b->fp;

        return my_fileno (fp);
      }

  return -1;
}


/****************
 * Tell the file position, where the next read will take place
 */
off_t
iobuf_tell( IOBUF a )
{
    return a->ntotal + a->nbytes;
}


#if !defined(HAVE_FSEEKO) && !defined(fseeko)

#ifdef HAVE_LIMITS_H
# include <limits.h>
#endif
#ifndef LONG_MAX
# define LONG_MAX ((long) ((unsigned long) -1 >> 1))
#endif
#ifndef LONG_MIN
# define LONG_MIN (-1 - LONG_MAX)
#endif

/****************
 * A substitute for fseeko, for hosts that don't have it.
 */
static int
fseeko( FILE *stream, off_t newpos, int whence )
{
    while( newpos != (long) newpos ) {
       long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
       if( fseek( stream, pos, whence ) != 0 )
           return -1;
       newpos -= pos;
       whence = SEEK_CUR;
    }
    return fseek( stream, (long)newpos, whence );
}
#endif

/****************
 * This is a very limited implementation. It simply discards all internal
 * buffering and removes all filters but the first one.
 */
int
iobuf_seek( IOBUF a, off_t newpos )
{
    file_filter_ctx_t *b = NULL;

    if( a->directfp ) {
	FILE *fp = a->directfp;
        if( fseeko( fp, newpos, SEEK_SET ) ) {
            log_error("can't seek: %s\n", strerror(errno) );
	    return -1;
	}
	clearerr(fp);
    }
    else {
	for( ; a; a = a->chain ) {
	    if( !a->chain && a->filter == file_filter ) {
		b = a->filter_ov;
		break;
	    }
	}
	if( !a )
	    return -1;
#ifdef FILE_FILTER_USES_STDIO
       if( fseeko( b->fp, newpos, SEEK_SET ) ) {
           log_error("can't fseek: %s\n", strerror(errno) );
           return -1;
       }
#else
#ifdef HAVE_DOSISH_SYSTEM
       if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff ) {
           log_error ("SetFilePointer failed on handle %p: %s\n",
                      b->fp, w32_strerror (0));
           return -1;
       }
#else
       if ( lseek (b->fp, newpos, SEEK_SET) == (off_t)-1 ) {
           log_error("can't lseek: %s\n", strerror(errno) );
           return -1;
       }
#endif
#endif
    }
    a->d.len = 0;   /* discard buffer */
    a->d.start = 0;
    a->nbytes = 0;
    a->nlimit = 0;
    a->nofast &= ~1;
    a->ntotal = newpos;
    a->error = 0;
    /* remove filters, but the last */
    if( a->chain )
	log_debug("pop_filter called in iobuf_seek - please report\n");
    while( a->chain )
       pop_filter( a, a->filter, NULL );

    return 0;
}






/****************
 * Retrieve the real filename
 */
const char *
iobuf_get_real_fname( IOBUF a )
{
    if( a->real_fname )
	return a->real_fname;

    /* the old solution */
    for( ; a; a = a->chain )
	if( !a->chain && a->filter == file_filter ) {
	    file_filter_ctx_t *b = a->filter_ov;
	    return b->print_only_name? NULL : b->fname;
	}

    return NULL;
}


/****************
 * Retrieve the filename
 */
const char *
iobuf_get_fname( IOBUF a )
{
    for( ; a; a = a->chain )
	if( !a->chain && a->filter == file_filter ) {
	    file_filter_ctx_t *b = a->filter_ov;
	    return b->fname;
	}

    return NULL;
}


/****************
 * enable partial block mode as described in the OpenPGP draft.
 * LEN is the first length byte on read, but ignored on writes.
 */
void
iobuf_set_partial_block_mode( IOBUF a, size_t len )
{
    block_filter_ctx_t *ctx = xmalloc_clear( sizeof *ctx );

    assert( a->use == 1 || a->use == 2 );
    ctx->use = a->use;
    if( !len ) {
	if( a->use == 1 )
	    log_debug("pop_filter called in set_partial_block_mode"
						    " - please report\n");
	pop_filter(a, block_filter, NULL );
    }
    else {
	ctx->partial = 1;
	ctx->size = 0;
	ctx->first_c = len;
	iobuf_push_filter(a, block_filter, ctx );
    }
}


/****************
 * Same as fgets() but if the buffer is too short a larger one will
 * be allocated up to some limit *max_length.
 * A line is considered a byte stream ending in a LF.
 * Returns the length of the line. EOF is indicated by a line of
 * length zero. The last LF may be missing due to an EOF.
 * is max_length is zero on return, the line has been truncated.
 *
 * Note: The buffer is allocated with enough space to append a CR,LF,EOL
 */
unsigned
iobuf_read_line( IOBUF a, byte **addr_of_buffer,
			  unsigned *length_of_buffer, unsigned *max_length )
{
    int c;
    char *buffer = *addr_of_buffer;
    unsigned length = *length_of_buffer;
    unsigned nbytes = 0;
    unsigned maxlen = *max_length;
    char *p;

    if( !buffer ) { /* must allocate a new buffer */
	length = 256;
	buffer = xmalloc( length );
	*addr_of_buffer = buffer;
	*length_of_buffer = length;
    }

    length -= 3; /* reserve 3 bytes (cr,lf,eol) */
    p = buffer;
    while( (c=iobuf_get(a)) != -1 ) {
	if( nbytes == length ) { /* increase the buffer */
	    if( length > maxlen  ) { /* this is out limit */
		/* skip the rest of the line */
		while( c != '\n' && (c=iobuf_get(a)) != -1 )
		    ;
		*p++ = '\n'; /* always append a LF (we have reserved space) */
		nbytes++;
		*max_length = 0; /* indicate truncation */
		break;
	    }
	    length += 3; /* correct for the reserved byte */
	    length += length < 1024? 256 : 1024;
	    buffer = xrealloc( buffer, length );
	    *addr_of_buffer = buffer;
	    *length_of_buffer = length;
	    length -= 3; /* and reserve again */
	    p = buffer + nbytes;
	}
	*p++ = c;
	nbytes++;
	if( c == '\n' )
	    break;
    }
    *p = 0; /* make sure the line is a string */

    return nbytes;
}

/* This is the non iobuf specific function */
int
iobuf_translate_file_handle ( int fd, int for_write )
{
#ifdef _WIN32
    {
        int x;
            
        if  ( fd <= 2 )
            return fd; /* do not do this for error, stdin, stdout, stderr */

        x = _open_osfhandle ( fd, for_write? 1:0 );
        if (x==-1 )
            log_error ("failed to translate osfhandle %p\n", (void*)fd );
        else {
            /*log_info ("_open_osfhandle %p yields %d%s\n",
              (void*)fd, x, for_write? " for writing":"" );*/
            fd = x;
        }
    }
#endif
    return fd;
}

static int
translate_file_handle ( int fd, int for_write )
{
#ifdef _WIN32
#ifdef FILE_FILTER_USES_STDIO  
    fd = iobuf_translate_file_handle (fd, for_write);
#else
    {
        int x;

        if  ( fd == 0 ) 
            x = (int)GetStdHandle (STD_INPUT_HANDLE);
        else if (fd == 1)    
            x = (int)GetStdHandle (STD_OUTPUT_HANDLE);
        else if (fd == 2)    
            x = (int)GetStdHandle (STD_ERROR_HANDLE);
        else
            x = fd;

        if (x == -1)
            log_debug ("GetStdHandle(%d) failed: %s\n",
                       fd, w32_strerror (0));

        fd = x;
    }
#endif
#endif
    return fd;
}


void
iobuf_skip_rest(IOBUF a, unsigned long n, int partial)
{
    if ( partial ) {
	for (;;) {
	    if (a->nofast || a->d.start >= a->d.len) {
		if (iobuf_readbyte (a) == -1) {
		    break;
		}
	    } else {
		unsigned long count = a->d.len - a->d.start;
		a->nbytes += count;
		a->d.start = a->d.len;
	    }
	}
    } else {
	unsigned long remaining = n;
	while (remaining > 0) {
	    if (a->nofast || a->d.start >= a->d.len) {
		if (iobuf_readbyte (a) == -1) {
		    break;
		}
		--remaining;
	    } else {
		unsigned long count = a->d.len - a->d.start;
		if (count > remaining) {
		    count = remaining;
		}
		a->nbytes += count;
		a->d.start += count;
		remaining -= count;
	    }
	}
    }
}

- A4CA272E00EBA069786CB1EDFB3F7054C5B31630A22AE66C012878D4BCEE96B11298141730589F0A0DDB04EEFF1C2F4EEF5A25D88447226F32EAA5346595EA96
+
mpi/logger.c

(1 . 262)(0 . 0)
/* logger.c  -	log functions
 *	Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>

#include "util.h"

static char pidstring[15];
static char *pgm_name;
static int errorcount;
static int strict;
static FILE *logfp;

/****************
 * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
 * the Fd where logoutputs should go.
 */
void
log_set_logfile( const char *name, int fd )
{
    if( name )
	BUG();

    if( logfp && logfp != stderr && logfp != stdout )
	fclose( logfp );
    if( fd == 1 )
	logfp = stdout;
    else if( fd == 2 )
	logfp = stderr;
    else
	logfp = fdopen( fd, "a" );
    if( !logfp ) {
	logfp = stderr;
	log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
    }
}

FILE *
log_stream()
{
    if( !logfp )
	logfp = stderr;
    return logfp;
}


void
log_set_name( const char *name )
{
    xfree(pgm_name);
    if( name )
	pgm_name = xstrdup(name);
    else
	pgm_name = NULL;
}

const char *
log_get_name(void)
{
    return pgm_name? pgm_name : "";
}


void
log_set_pid( int pid )
{
    if( pid )
	sprintf(pidstring,"[%u]", (unsigned)pid );
    else
	*pidstring = 0;
}

int
log_get_errorcount( int clear)
{
    int n = errorcount;
    if( clear )
	errorcount = 0;
    return n;
}

void
log_inc_errorcount()
{
    errorcount++;
}

int
log_set_strict(int val)
{
  int old=strict;
  strict=val;
  return old;
}

void
g10_log_print_prefix(const char *text)
{
    if( !logfp )
	logfp = stderr;
    if( pgm_name )
	fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
    else
	fprintf(logfp, "?%s: %s", pidstring, text );
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}


void
g10_log_info( const char *fmt, ... )
{
    va_list arg_ptr ;

    g10_log_print_prefix("");
    va_start( arg_ptr, fmt ) ;
    vfprintf(logfp,fmt,arg_ptr) ;
    va_end(arg_ptr);
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}


void
g10_log_warning( const char *fmt, ... )
{
    va_list arg_ptr ;

    if(strict)
      {
	errorcount++;
	g10_log_print_prefix(_("ERROR: "));
      }
    else
      g10_log_print_prefix(_("WARNING: "));

    va_start( arg_ptr, fmt ) ;
    vfprintf(logfp,fmt,arg_ptr) ;
    va_end(arg_ptr);
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}


void
g10_log_error( const char *fmt, ... )
{
    va_list arg_ptr ;

    g10_log_print_prefix("");
    va_start( arg_ptr, fmt ) ;
    vfprintf(logfp,fmt,arg_ptr) ;
    va_end(arg_ptr);
    errorcount++;
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}


void
g10_log_fatal( const char *fmt, ... )
{
    va_list arg_ptr ;

    g10_log_print_prefix("fatal: ");
    va_start( arg_ptr, fmt ) ;
    vfprintf(logfp,fmt,arg_ptr) ;
    va_end(arg_ptr);
    secmem_dump_stats();
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
    exit(2);
}

void
g10_log_bug( const char *fmt, ... )
{
    va_list arg_ptr ;

    putc('\n', stderr );
    g10_log_print_prefix("Ohhhh jeeee: ");
    va_start( arg_ptr, fmt ) ;
    vfprintf(stderr,fmt,arg_ptr) ;
    va_end(arg_ptr);
    fflush(stderr);
    secmem_dump_stats();
    abort();
}

#if defined (__riscos__) \
    || ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
void
g10_log_bug0( const char *file, int line, const char *func )
{
    log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
}
#else
void
g10_log_bug0( const char *file, int line )
{
    log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
}
#endif

void
g10_log_debug( const char *fmt, ... )
{
    va_list arg_ptr ;

    g10_log_print_prefix("DBG: ");
    va_start( arg_ptr, fmt ) ;
    vfprintf(logfp,fmt,arg_ptr) ;
    va_end(arg_ptr);
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}



void
g10_log_hexdump( const char *text, const char *buf, size_t len )
{
    int i;

    g10_log_print_prefix(text);
    for(i=0; i < len; i++ )
	fprintf(logfp, " %02X", ((const byte*)buf)[i] );
    fputc('\n', logfp);
#ifdef __riscos__
    fflush( logfp );
#endif /* __riscos__ */
}

- D946187EDC8013ACEC997499092EB30464487922925230FBFE5D21EA6CD76320625E947B8F47CF19EC4C47987CC5DCD0C22E6DBFB4B40E4B0F93189C29B5BFC9
+ 50746FE355731DA38601BCF9CEE34DDBA73D8C28B950912F6A4FBD5D2F614CBEB8A245F4EC0E9E97EE7D21AA0A39CF1337A519B78EB81B27C77A750EA893BA8B
mpi/Makefile

(17 . 6)(17 . 7)

$(PROGRAM):     $(OBJECTS)
		ar rcs $(DIST)/$(PROGRAM) $(OBJECTS)
		#ld -o $(DIST)/$(PROGRAM).o $(OBJECTS) -lc

clean :
	rm -rf nul core *flymake* $(BUILD)/*.o $(DIST)/$(PROGRAM) *~ bin/*

- 9DEA2170DE57AC92123D3DAC0FD5930BC5C1A5AC88CA1C2FDA88C8555091A38E5862FD7AC5BCED9393349F66AB970707B27D759FE0041F358A0D205E066ECDE0
+ 4E3DCB1355D54A4A2CC9EEBDDFEEAB38E3EDD49F20EF18A7DDCA12CB57497820AE200708B20FA697CEC54E4B65CD8AD3F2487ADD90DEFC420EB33B94AB460304
mpi/memory.c

(1 . 23)(1 . 26)
/* memory.c  -	memory allocation
 * Copyright (C) 1998, 1999, 2001, 2005 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 *
 * We use our own memory allocation functions instead of plain malloc(),
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/* We use our own memory allocation functions instead of plain malloc(),
 * so that we can provide some special enhancements:
 *  a) functions to provide memory from a secure memory.
 *  b) by looking at the requested allocation size we
(27 . 17)(30 . 16)
 *  d) memory checking if compiled with M_GUARD
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <string.h>

#include "knobs.h"
#include "types.h"
#include "memory.h"
#include "util.h"


#define MAGIC_NOR_BYTE 0x55
#define MAGIC_SEC_BYTE 0xcc
#define MAGIC_END_BYTE 0xaa
(76 . 14)(78 . 10)
#define FNAMEXM(a) m_debug_ ##a
#define FNAMEPRT  , const char *info
#define FNAMEARG  , info
#ifndef __riscos__

#define store_len(p,n,m) do { add_entry(p,n,m, \
					info, __FUNCTION__);  } while(0)
#else
#define store_len(p,n,m) do { add_entry(p,n,m, \
	          info, __func__ );  } while(0)
#endif
#else
#define FNAME(a)   m_ ##a
#define FNAMEX(a)  x ##a
#define FNAMEXM(a) xm ##a
(337 . 11)(335 . 7)

    for( e = memtbl, n = 0; n < memtbl_len; n++, e++ ) {
	if( e->inuse ) {
#ifndef __riscos__
	    check_mem(e->user_p-4-EXTRA_ALIGN, info);
#else 
	    check_mem((const byte *) e->user_p-4-EXTRA_ALIGN, info);
#endif
        }
    }
}
(411 . 10)(405 . 7)
        log_info ("(this may be caused by too many secret keys used "
                  "simultaneously or due to excessive large key sizes)\n");
    }
#if defined(M_GUARD) && defined(__riscos__)
    abort();
#endif
    exit (2);
    exit(2);
}

/****************
(678 . 4)(669 . 3)
    out_of_core (nbytes, 1);
  return xmalloc_secure_clear (nbytes);
}

- FFCEA4F2389EB4919DF50FC60423606D2835E4BE6A853FA885754CF04C397FE96D4A688ECCD591C60BC687846AE1E230304D3554B3E504E2E53662270342C591
+ 956452037539C9B7F45834858A92E436FB65D7482B6B44D2624E2279E9203B59D992A0D405F778638B5E03ADB9F51A545D5C5B55CC31D59453523FBD75F2BE5B
mpi/mpi-add.c

(1 . 35)(1 . 29)
/* mpi-add.c  -  MPI functions
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

- A48F6DCD95712D600A89EFAE6DC7425B5CADE2869B48AA49D6D6FC5C42D63EC462E2A1FCB08CB1DF5468A9A5AD8C8DD419DC7FB8F5758AD0D93007960B19A153
+ D3AB216D028E41835D4511CD451A4D774B268DC38A17322DCDEEED542A949E5DBAEECBB377DAA353B7E31ADA19EBE05247FF696CA571D2862DD26C631AA124EE
mpi/mpi-bit.c

(1 . 26)(1 . 30)
/* mpi-bit.c  -  MPI bit level fucntions
 * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 83C978461CA2FC606EAB05035DB9A67D600396F013E5CE0DB8CC110D8881E9BE513D540B27DAECC8B0293178D7AB27EE52F5C947A0B9976863B9094F82EBD522
+ C16F3EACAC322384CD8D5AC67D1A3F287E5A32EA9CD3A8AF650F97952739D9BC361BC1808390C5B1E6F914FC119BBCDAB020F7B403B9ADB2A03593569DA5326D
mpi/mpi-cmp.c

(1 . 25)(1 . 29)
/* mpi-cmp.c  -  MPI functions
 * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

int

- 6A4860EA723098A2E2BA703D8748F6D26C22D1AE72647A5CCCA67AB93976390B0D992BA870796BE3DA3B736B1A11B36F700A93214AE5926EC2652D1EDEE390A3
+ 86D94794C314885A11E11ADBAEB4F4C4E4576BDECD18E35FA758AC471D151322E051D57488DF4910BDF315B1670F5B3E0D6E1423856209FC6EC05CAE1704E6B8
mpi/mpicoder.c

(1 . 31)(1 . 33)
/* mpicoder.c  -  Coder for the external representation of MPIs
 * Copyright (C) 1998, 1999, 2005 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#include "knobs.h"
#include "mpi.h"
#include "mpi-internal.h"
#include "iobuf.h"
#include "memory.h"
#include "util.h"

(35 . 110)(37 . 6)

#define MAX_EXTERN_MPI_BITS 16384

/****************
 * write an mpi to out.
 */
int
mpi_write( IOBUF out, MPI a )
{
    int rc;
    unsigned nbits = mpi_get_nbits(a);
    byte *p, *buf;
    unsigned n;

    if( nbits > MAX_EXTERN_MPI_BITS )
	log_bug("mpi_encode: mpi too large (%u bits)\n", nbits);

    iobuf_put(out, (nbits >>8) );
    iobuf_put(out, (nbits) );

    p = buf = mpi_get_buffer( a, &n, NULL );
    rc = iobuf_write( out, p, n );
    xfree(buf);
    return rc;
}


/****************
 * Read an external representation of an mpi and return the MPI
 * The external format is a 16 bit unsigned value stored in network byte order,
 * giving the number of bits for the following integer. The integer is stored
 * with MSB first (left padded with zeroes to align on a byte boundary).
 */
MPI
#ifdef M_DEBUG
mpi_debug_read(IOBUF inp, unsigned *ret_nread, int secure, const char *info)
#else
mpi_read(IOBUF inp, unsigned *ret_nread, int secure)
#endif
{
    int c, i, j;
    unsigned int nmax = *ret_nread;
    unsigned nbits, nbytes, nlimbs, nread=0;
    mpi_limb_t a;
    MPI val = NULL;

    if (nread == nmax)
        goto overflow;
    if( (c = iobuf_get(inp)) == -1 )
	goto leave;
    nread++;
    nbits = c << 8;

    if (nread == nmax)
        goto overflow;
    if( (c = iobuf_get(inp)) == -1 )
	goto leave;
    nread++;
    nbits |= c;

    if( nbits > MAX_EXTERN_MPI_BITS ) {
	log_error("mpi too large for this implementation (%u bits)\n", nbits);
	goto leave;
    }

    nbytes = (nbits+7) / 8;
    nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;
#ifdef M_DEBUG
    val = secure? mpi_debug_alloc_secure( nlimbs, info )
		: mpi_debug_alloc( nlimbs, info );
#else
    val = secure? mpi_alloc_secure( nlimbs )
		: mpi_alloc( nlimbs );
#endif
    i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
    i %= BYTES_PER_MPI_LIMB;
    val->nbits = nbits;
    j= val->nlimbs = nlimbs;
    val->sign = 0;
    for( ; j > 0; j-- ) {
	a = 0;
	for(; i < BYTES_PER_MPI_LIMB; i++ ) {
            if (nread == nmax) {
#ifdef M_DEBUG
                mpi_debug_free (val);
#else
                mpi_free (val);
#endif
                val = NULL;
                goto overflow;
            }
	    a <<= 8;
	    a |= iobuf_get(inp) & 0xff; nread++;
	}
	i = 0;
	val->d[j-1] = a;
    }

  leave:
    *ret_nread = nread;
    return val;
  overflow:
    log_error ("mpi larger than indicated length (%u bytes)\n", nmax);
    *ret_nread = nread;
    return val;
}


MPI
mpi_read_from_buffer(byte *buffer, unsigned int *ret_nread, int secure)
(309 . 6)(207 . 7)
}


/*
void
g10_log_mpidump( const char *text, MPI a )
{
(318 . 31)(217 . 7)
    mpi_print(fp, a, 1 );
    fputc('\n', fp);
}

/****************
 * Special function to get the low 8 bytes from an mpi.
 * This can be used as a keyid; KEYID is an 2 element array.
 * Return the low 4 bytes.
 */
u32
mpi_get_keyid( MPI a, u32 *keyid )
{
#if BYTES_PER_MPI_LIMB == 4
    if( keyid ) {
	keyid[0] = a->nlimbs >= 2? a->d[1] : 0;
	keyid[1] = a->nlimbs >= 1? a->d[0] : 0;
    }
    return a->nlimbs >= 1? a->d[0] : 0;
#elif BYTES_PER_MPI_LIMB == 8
    if( keyid ) {
	keyid[0] = a->nlimbs? (u32)(a->d[0] >> 32) : 0;
	keyid[1] = a->nlimbs? (u32)(a->d[0] & 0xffffffff) : 0;
    }
    return a->nlimbs? (u32)(a->d[0] & 0xffffffff) : 0;
#else
#error Make this function work with other LIMB sizes
#endif
}
*/


/****************

- B320709B57B3CF0C00BC98277B037494C62FED93FD99BCA0412EA633F8662844D35ED62990CBE1FC02A47DEE5795D3A7B6B401440F6E80A8A00243868815C06A
+ C35F9C1DD65BD4564AC028B876D7351CD30F72780AFD03FD6A764B0FCCFE57C10AE496D64407F04953364788FA2824759239CC598A44466537A379E57E0BAD8C
mpi/mpi-div.c

(1 . 34)(1 . 29)
/* mpi-div.c  -  MPI functions
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- F582DE56EE9BC1D4CF2EEA35BDABDCD61E0CC93DD186950709E32FC707D2F769669BAFDCFBF2AD074596BA474BF1E7AF5E29EA81CFF2316ACBFCD27A0F93F185
+ 6DFF8D166D0D34557BBAF7E739B83AEC2F73E2383424D08CE2D10C6A1609095381A27B8C38029950548942C3D4B5FAADCBE62322BC623154FA1911B3EAA3FE38
mpi/mpi-gcd.c

(1 . 25)(1 . 29)
/* mpi-gcd.c  -  MPI functions
 * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

/****************

- FB06EA790BD2B2C18013B3FB51F05A5C1577F45FDD67644E7745C3373FA26FA90DE8F30FD9221E978BA9676423ED1C4C27C0407F22A50E10F216AE9BBF4AC3F3
+ 15E95347519C17744E8346A37975E5B482E833625862C1E01629E07D3E80CDBDEE590F6BCBED8214092D395979E38EF50CEFE58B2DC64472A2B3860BC374EE2D
mpi/mpih-add1.c

(1 . 34)(1 . 29)
/* mpihelp-add_1.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1997, 1998, 
 *               2000 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 88A21583524C37A7FEBB2EEDAF38F0942183A201EE8DF8B9E04A8098E892DD88B7F8566E40CC8BF042D5713E2F78886526CC23DE79C61463E7763685F280C37E
+ E0F453BECB6712C9A4C33BF2969CCCEFBF5097F29992A486D12726B509D90A3F2F91E53729FEB9C2F3B8452E5C2A2348B409CEEFF253ADEFE2E5A627E1B19CC1
mpi/mpih-cmp.c

(1 . 35)(1 . 29)
/* mpihelp-sub.c  -  MPI helper functions
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

/****************

- AA4E2EFA1E53416AEDF9CBF7A73A00FBDE7A8266F532002DC046B0B995CF49D060496C45C74944EC3F41CF0DD441884FF6230260978FCBF227903EB7213B074A
+ 62BDE6DDF9FEECCD5C2AFB41FB0B86B32B558CB48D58107AE9AB1ED46C3769731C0804BD460565B85E731146C8D942E082EE12B69FCFFD1B973A08F79BCAE4D0
mpi/mpih-div.c

(1 . 34)(1 . 29)
/* mpihelp-div.c  -  MPI helper functions
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 *	Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 3222BFC241FA6104936CC585FDA392F220D88031FA0FDF460BB201A3AA7295E6D1DC75007BF53D2E501734D9FAAA31934EED944CE7452A6AA3AFCD3A333D3C13
+ 25E8EFCBAE822D6B21202C4E4D2A1D1D0370C3676AF7518EA81C8A59D87E0DF7CAF2B81E43F307EF8910BC63D4C482CC6F94794B73EA68C19E69391613405EBA
mpi/mpih-lshift.c

(1 . 33)(1 . 29)
/* mpihelp-lshift.c  -	MPI helper functions
 * Copyright (C) 1994, 1996, 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

/* Shift U (pointed to by UP and USIZE digits long) CNT bits to the left

- 86B925ACDAEDFAAF9C7F7FF783DA4A049C62C8F63929BF288FDC8E4760DC9B451440ED5ED5F8549E8B2CCBD4F00175F068DE9DC337EEDFD8FAD8348D21F3ED13
+ E8D6C90380880315A6BF877BA13B073A93159645C447B67723CC6B76ECE8499C13758759085900049695BE381076A06880C6B1721EBAE6E36263ECCBC56260C5
mpi/mpih-mul1.c

(1 . 33)(1 . 29)
/* mpihelp-mul_1.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 340744F79D1466A916FCA829C66F86915B808800BF3EBE2CCADABA1D5FD89EF5C5DB486C94B0F01ACE52F13D7A74784B68214499F5AC120AC8449FC9EB5C61C3
+ 95CD771C444012E1F8E329FC4A7687D1A0F5E3B2D0635C07D7C47913AF09D55040478FEF672766F5CCBF2FBBFF74FEA0B95F57D37BC4A3D0DCF3FD8C7F3288AB
mpi/mpih-mul2.c

(1 . 33)(1 . 29)
/* mpihelp-mul_2.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 683F47357B0F57E3DC50AEFC32BDCD8C20E7A9A4C3DC48D3BA9E5715E12836B6CE53B8DFF653BDB86CDD197DAAB9AF7532DEF5BB06D861BDF48F4DC705AC6AA4
+ C86699C63F32A4627023A4AD8B89138FCBEF21E066E98E73C8F652B62F521C67110CEB48121EF5F7A586745328E8777B8170699E1417D70FB54849C5DFE88811
mpi/mpih-mul3.c

(1 . 33)(1 . 29)
/* mpihelp-mul_3.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 2D6F3C1ECB3331CDFB54C9EFA53246CAC6A6DFA16465D2E354C6801974964229CB173E7AFF19C4C92E896B8C65CFBC6DA79EF03C20022772F5C299F1C3CBC063
+ 8D2390541B928FC4B9E92C17766530734CE64B823A3AFF6E648C0CFEEF6367A9FC18A0DE2754378B04DBD6072D862CECB447C372CEFAAD1D39D5D619B2FF6ABD
mpi/mpih-mul.c

(1 . 40)(1 . 34)
/* mpihelp-mul.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1998, 1999,
 *               2000 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"



#define MPN_MUL_N_RECURSE(prodp, up, vp, size, tspace) \
    do {						\
	if( (size) < KARATSUBA_THRESHOLD )		\
(52 . 8)(46 . 6)
    } while (0);




/* Multiply the natural numbers u (pointed to by UP) and v (pointed to by VP),
 * both with SIZE limbs, and store the result at PRODP.  2 * SIZE limbs are
 * always stored.  Return the most significant limb.

- B98CF2FB49B284C7FFDA191D6E1A336E87BC9D5C302753C04E704DE455793BD9736D6318E1C314FC8CF97BAEBC830EAE998C35382AFB2810126C1CC9BD18BDCE
+ ECA25CB1840CEF7D60FA2BC6ECB32660CFAD14E3A3A8AEEB11EC5A5EB2D702C972331351DA75C5C111B7C90075B1922DB5C475C246B11D7D6097E50538B230F8
mpi/mpih-rshift.c

(1 . 34)(1 . 29)
/* mpih-rshift.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1998, 1999,
 *               2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GNUPG
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GNUPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GNUPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

- 1F021E754F091EAC1AB7B46306B00849F7160CFA7CD0CC8A6481020B6D42CB12058CD12AC9E2B1D7F730688FBE2D876374EC9D5BB7A5F9D66A42CC9259CF2539
+ A23C0420E5786F7ED38842DC31330EC3C7F5544566A434414B7D097F237969D37D3C9390D2CC393D58F011EC991959CB059758B5E66FFCEA2002F4597AC049CF
mpi/mpih-sub1.c

(1 . 33)(1 . 29)
/* mpihelp-add_2.c  -  MPI helper functions
 * Copyright (C) 1994, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 22B8E75D35ABC0449E048A2B18461B17D7EF5A6A00A56FE1A16BD89B526B8F6F19DEA196A258D6E3760F84B1124D7D40FA28D1B6C5BC4932BE11B9D91C7077EC
+ 8A4A177C130B437C9ED2E935A375E693B12A57B12B241660B5F715698B9926D82F68C0C74C450BEA2DC60888920BB04F9370BEDC8737D1EC375A307EB3D4A0A1
mpi/mpi-inline.c

(1 . 26)(1 . 30)
/* mpi-inline.c
 * Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"

/* put the inline functions as real functions into the lib */
#define G10_MPI_INLINE_DECL

- 66EDF48A07BB672B7D9329150436A40AB2F1628F1F289B4C52B2E4BDB987B9105F36C441FB21A141346406A675D34B6265A4A0BC00D3C4DE471F461D0ACC5765
+ 89B26071AE7D00A43324B0152330B04E9981DC9F81C0482E760C629C4FD056ED3125C7432155E7A44CADB0FF26C3EB6ABEF3EBACFCAC4781F628D315C59F3539
mpi/mpi-inv.c

(1 . 25)(1 . 29)
/* mpi-inv.c  -  MPI functions
 * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

- A87EBB2E2397F5903EAA0066A9ADF8F977BF7A67866CD181D0699B6D6A029880D86F349BE9CB9E6901D35B052BD871380E18AB19EFCF319C8A3662A93691856E
+ 770F4B4229521F5F780D90EAD019BB19AC247128A768D6EEF565DA48FADE1634FF195A94E39412973B08C01C55C410DB075D2BE44E393B8F343568B2B4B85CDD
mpi/mpi-mpow.c

(1 . 28)(1 . 33)
/* mpi-mpow.c  -  MPI functions
 * Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"
#include <assert.h>


static int
build_index( MPI *exparray, int k, int i, int t )

- 8A56ADB14BCAC8D72E4454562A0455C241756EDE576D2CD4E8A42CFDFF5ABE7C803A5F1523945EE81D5A149B88D969739443D00165FDAAB7041BAC9BE10DC8CF
+ E59E2D292E0E80C84BBC7526FFB1D48CF9CE718840C0B6D6FF26E1BEE1A331E7EAA4F7002050D195AF9D7E915CE49CA6B4B9A43F7D4C0D74E9C6040B6B871BF6
mpi/mpi-mul.c

(1 . 34)(1 . 29)
/* mpi-mul.c  -  MPI functions
 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.
 *	Copyright (C) 1998, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"

- 8341923461226EC55DE5B29209CC03051587DE11885CB49433FF4C0EBA2160798B7DC27573B9BC363EE0954A8FC08CBD21AF3F655A9C0BC8AA294A74F80EB2C9
+ 054BF70520A4B8936CE1E9A3176884AE01FA796177F57FEB9676BE0197E3D87F82A7074E19144553D603861B5AFE804808A10C0E59E6F649BE4435BF6055BA88
mpi/mpi-pow.c

(1 . 37)(1 . 34)
/* mpi-pow.c  -  MPI functions
 *	Copyright (C) 1994, 1996, 1998, 2000 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Note: This code is heavily based on the GNU MP Library.
 *	 Actually it's the same code with only minor changes in the
 *	 way the data is stored; this is to support the abstraction
 *	 of an optional secure memory allocation which may be used
 *	 to avoid revealing of sensitive data due to paging etc.
 *	 The GNU MP Library itself is published under the LGPL;
 *	 however I decided to publish this code under the plain GPL.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"
#include <assert.h>



/****************

- AFFA0E93E6625CAD75CD10C454B493CBEBF061AECA3185E45B6571A26AE10F03947A1EF363C0898609F95CC737053E45A73926B22F14F4EC6A800410915D3FF9
+ A5515E663FE1096BC9E9187508E493A8992770E13039758663F0B5979F49AB422F7F5847B707007A6D53190493F5250C8963C147405DEFEE82BCA6037731B869
mpi/mpi-scan.c

(1 . 25)(1 . 29)
/* mpi-scan.c  -  MPI functions
 * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

#include "knobs.h"
#include "mpi-internal.h"
#include "longlong.h"

- 757F8A9FFA7640843ABC7A20EE7F0460FAE4CB11A2928963C85399B7EA7ABA3332F5C1574E86DAB4BBA8384E5BF3F95161C1D1E15DB7B85BB96F369F1E67F6FA
+ 38480C0221F17670A5009ECE9021655C15EAE6C5C378BA516CDDCDD1C3179A647F1862B1CD92391A57F62313A208FAA2FBE2EBDF2584C6570500626CF5B926C1
mpi/mpiutil.c

(1 . 28)(1 . 31)
/* mpiutil.ac  -  Utility functions for MPI
 * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "knobs.h"
#include "mpi.h"
#include "mpi-internal.h"
#include "memory.h"

- 6BE57F08EC92D8BB7FBA6E14DE060CA60D0655B3DAD55CCC31B8387B9A305361F208E05589F091F8A0F774D9830E43B015E81E5DDC16EC41C16B00A04A13F69F
+ 812488321DD4DD4E83CFC49F1FFD543231BFD8099880BF8106D7C5DEBF7E7FEC8B6E17F9B91EBC7CC7C772B06C03C6FFC176438BC3204953BDA7842F06EF43AE
mpi/README

(6 . 6)(6 . 18)
SHA512(gnupg-1.4.10.tar.gz) :
d037041d2e6882fd3b999500b5a7b42be2c224836afc358e1f8a2465c1b74473d518f185b7c324b2c8dec4ffb70e9e34a03c94d1a54cc55d297f40c9745f6e1b

DEMO:

1) make
2) cd tests
3) make
4) ./test_mpi
5) output is:
   37A063D056817668C7AA3418F29
6) q: 'Waaaaaa, it barfed!'
   a: You are probably using GCC 5 or LLVM. Stop.


CHANGES FROM ORIGINAL:

1) Everything pertaining to Automake was nuked, and the earth where it stood -
(16 . 7)(28 . 7)
   another project. This will turn up in 'bin'.

   Among other things, this now means that all KNOBS now reside in a
   MANUALLY-controlled 'config.h' found in 'include'.  If you are building
   MANUALLY-controlled 'knobs.h' found in 'include'.  If you are building
   on some very peculiar unix, please read it and adjust as appropriate.
   It contains ONLY those knobs which actually pertain to the code.

(41 . 7)(53 . 7)
   don't need'em in their source code.

4) Other code has been altered solely to the extent required by items
   (1) and (2).
   (1), (2), and (3).

   Cruft which appears in dead #ifdefs may be removed in the future.
   Don't get comfortable with it being there.
(55 . 3)(67 . 20)

7) The original code was distributed under GPL 3, which may apply on
   your planet and is therefore included. (See COPYING.)

----------
UPDATE #1:
----------

1) Abolished the logging subsystem inherited from GPG.

2) Abolished the I/O buffering subsystem, from same.

3) Eliminated all #ifdef blocks pertaining to RiscOS.

4) config.h is now knobs.h and is considerably shorter
   on account of there now being a great many fewer knobs.

5) Eliminated certain blocks of dead code.

6) Inserted notice of modifications as specified in GPL-3

- A0B28117315BD9560BE404C97E44252316FD19FF9CBC762BF5D46235034846155D5058E22A73D7010F78CF7442BA6624E2417A719FFCBE2F8A163090706E069C
+ 914398E87EDAF3B4ED8010EC6795C55F1A46B7C112D8DF2A28B9B73C4A786AB7335A662B097522FCF79695B5DBEE04C7AD8F2C8E70CAECA39C40430B7BC2FEB8
mpi/secmem.c

(1 . 24)(1 . 27)
/* secmem.c  -	memory allocation from a secure heap
 *	Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
 *                    2007 Free Software Foundation, Inc.
 * Modified by No Such Labs. (C) 2015. See README.
 *
 * This file is part of GnuPG.
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
 *        0bfd74660a2f6cedcf7d8256db4a63c996ffebbcdc2cf54397bfb72878c5a85a
 * (C) 1994-2005 Free Software Foundation, Inc.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * 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 3 of the License, or
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include "knobs.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
(92 . 9)(95 . 7)
{
  if (!no_warning)
    {
      log_info(_("WARNING: using insecure memory!\n"));
      log_info(_("please see http://www.gnupg.org/faq.html"
		 " for more information\n"));
      log_info("WARNING: using insecure memory!\n");
    }
}

(202 . 11)(203 . 6)
    /* It does not make sense to print such a warning, given the fact that 
     * this whole Windows !@#$% and their user base are inherently insecure
     */
#elif defined (__riscos__)
    /* no virtual memory on RISC OS, so no pages are swapped to disc,
     * besides we don't have mmap, so we don't use it! ;-)
     * But don't complain, as explained above.
     */
#else
    log_info("Please note that you don't have secure memory on this system\n");
#endif
(313 . 14)(309 . 11)
secmem_init( size_t n )
{
    if( !n ) {
#ifndef __riscos__
#ifdef USE_CAPABILITIES
	/* drop all capabilities */
	cap_set_proc( cap_from_text("all-eip") );

#elif !defined(HAVE_DOSISH_SYSTEM)
	uid_t uid;

	disable_secmem=1;
	uid = getuid();
	if( uid != geteuid() ) {
(328 . 7)(321 . 6)
		log_fatal("failed to drop setuid\n" );
	}
#endif
#endif /* !__riscos__ */
    }
    else {
	if( n < DEFAULT_POOLSIZE )
(351 . 8)(343 . 8)

    if( !pool_okay ) {
	log_info(
	 _("operation is not possible without initialized secure memory\n"));
	log_info(_("(you may have used the wrong program for this task)\n"));
	 "operation is not possible without initialized secure memory\n");
	log_info("(you may have used the wrong program for this task)\n");
	exit(2);
    }
    if( show_warning && !suspend_warning ) {

-
+ B063BF6E022989224FA35D648E8FC1CEF134C07C8602D502F83A2FDBA824707919FC09460552C52E6EE533625E949A4F83E733182050B728CE64E92EF8C26AD8
mpi/tests/Makefile

(0 . 0)(1 . 24)
PROGRAM = test_mpi

CXX = gcc
OBJECTS := $(patsubst %.c,%.o,$(wildcard *.c))
FLAGS = -g -Wall
INCLUDE = -I ../include
MPI = ../bin/mpi.a
LIBS := $(MPI)

.SUFFIXES: .o .c

.c.o:
	$(CXX) $(FLAGS) $(INCLUDE) -c $< -o $@

all:    $(PROGRAM)

$(PROGRAM):     $(OBJECTS)
		$(CXX) $(FLAGS) $(INCLUDE) -o $(PROGRAM) $(OBJECTS) $(LIBS)

clean :
	rm -rf nul core *flymake* *.o $(PROGRAM) *~ bin obj

check-syntax:
	$(CXX) -c $(FLAGS) $(INCLUDE) -o nul -Wall -S $(CHK_SOURCES)

-
+ 5F400376F8290AE83062C457BEDFDE1FB7A2C2E31EFE956ADA2E4DC4EAAF6871428B74BE1193D9268EE74CF454BDC3DF5C4C4A88E6942D216DDB5A0395F48099
mpi/tests/test_mpi.c

(0 . 0)(1 . 39)
#include "mpi.h"
#include <stdlib.h>

void err(char *msg)
{
  fprintf(stderr, "%s\n", msg);
  exit(1);
}

void terpri(FILE *fp)
{
  fprintf(fp, "\n");
}

int main(int ac, char **av)
{
  MPI a, b, y;
  int r;
  
  r = secmem_init(1000);
  if (r==0) err("secmem init");

  a = mpi_alloc_secure(0);
  b = mpi_alloc_secure(0);
  y = mpi_alloc_secure(0);
  mpi_fromstr(a, "0x1B0B206C488601");
  mpi_fromstr(b, "0x20E92FE28E1929");
  mpi_mul(y, a, b);
  mpi_free(a);
  mpi_free(b);
  
  mpi_print(stdout, y, 1);
  mpi_free(y);
  
  terpri(stdout);
  secmem_term();
  
  return 0;
}

- FB984A326A9BCDA1A4CBC05EE279E55CFEFCF157393D2F66405760B256395C3A73F1F41EBFC335722022EA04C79F6E02AB3179ECC9A66E037DD7A106572B4924
+
mpi/udiv-w-sdiv.c

(1 . 132)(0 . 0)
/* mpihelp_udiv_w_sdiv -- implement udiv_qrnnd on machines with only signed
 *			  division.
 * Copyright (C) 1992, 1994, 1996, 1998 Free Software Foundation, Inc.
 * Contributed by Peter L. Montgomery.
 *
 * This file is part of GnuPG.
 *
 * GnuPG 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 3 of the License, or
 * (at your option) any later version.
 *
 * GnuPG 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include "mpi-internal.h"
#include "longlong.h"


#if 0  /* not yet ported to MPI */

mpi_limb_t
mpihelp_udiv_w_sdiv( mpi_limp_t *rp,
		     mpi_limp_t *a1,
		     mpi_limp_t *a0,
		     mpi_limp_t *d   )
{
  mp_limb_t q, r;
  mp_limb_t c0, c1, b1;

  if ((mpi_limb_signed_t) d >= 0)
    {
      if (a1 < d - a1 - (a0 >> (BITS_PER_MP_LIMB - 1)))
	{
	  /* dividend, divisor, and quotient are nonnegative */
	  sdiv_qrnnd (q, r, a1, a0, d);
	}
      else
	{
	  /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
	  sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (BITS_PER_MP_LIMB - 1));
	  /* Divide (c1*2^32 + c0) by d */
	  sdiv_qrnnd (q, r, c1, c0, d);
	  /* Add 2^31 to quotient */
	  q += (mp_limb_t) 1 << (BITS_PER_MP_LIMB - 1);
	}
    }
  else
    {
      b1 = d >> 1;			/* d/2, between 2^30 and 2^31 - 1 */
      c1 = a1 >> 1;			/* A/2 */
      c0 = (a1 << (BITS_PER_MP_LIMB - 1)) + (a0 >> 1);

      if (a1 < b1)			/* A < 2^32*b1, so A/2 < 2^31*b1 */
	{
	  sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */

	  r = 2*r + (a0 & 1);		/* Remainder from A/(2*b1) */
	  if ((d & 1) != 0)
	    {
	      if (r >= q)
		r = r - q;
	      else if (q - r <= d)
		{
		  r = r - q + d;
		  q--;
		}
	      else
		{
		  r = r - q + 2*d;
		  q -= 2;
		}
	    }
	}
      else if (c1 < b1) 		/* So 2^31 <= (A/2)/b1 < 2^32 */
	{
	  c1 = (b1 - 1) - c1;
	  c0 = ~c0;			/* logical NOT */

	  sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */

	  q = ~q;			/* (A/2)/b1 */
	  r = (b1 - 1) - r;

	  r = 2*r + (a0 & 1);		/* A/(2*b1) */

	  if ((d & 1) != 0)
	    {
	      if (r >= q)
		r = r - q;
	      else if (q - r <= d)
		{
		  r = r - q + d;
		  q--;
		}
	      else
		{
		  r = r - q + 2*d;
		  q -= 2;
		}
	    }
	}
      else				/* Implies c1 = b1 */
	{				/* Hence a1 = d - 1 = 2*b1 - 1 */
	  if (a0 >= -d)
	    {
	      q = -1;
	      r = a0 + d;
	    }
	  else
	    {
	      q = -2;
	      r = a0 + 2*d;
	    }
	}
    }

  *rp = r;
  return q;
}

#endif