mirror of
git://git.gnupg.org/gnupg.git
synced 2024-12-24 10:39:57 +01:00
211 lines
4.4 KiB
C
211 lines
4.4 KiB
C
/* assuan-util.c - Utility functions for Assuan
|
||
* Copyright (C) 2001, 2002 Free Software Foundation, Inc.
|
||
*
|
||
* This file is part of Assuan.
|
||
*
|
||
* Assuan 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.
|
||
*
|
||
* Assuan 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 program; if not, write to the Free Software
|
||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include "assuan-defs.h"
|
||
|
||
#ifdef HAVE_JNLIB_LOGGING
|
||
#include "../jnlib/logging.h"
|
||
#endif
|
||
|
||
ssize_t (*_assuan_read_wrapper)(int,void*,size_t) = NULL;
|
||
ssize_t (*_assuan_write_wrapper)(int,const void*,size_t) = NULL;
|
||
|
||
|
||
static void *(*alloc_func)(size_t n) = malloc;
|
||
static void *(*realloc_func)(void *p, size_t n) = realloc;
|
||
static void (*free_func)(void*) = free;
|
||
|
||
|
||
|
||
void
|
||
assuan_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
|
||
void *(*new_realloc_func)(void *p, size_t n),
|
||
void (*new_free_func)(void*) )
|
||
{
|
||
alloc_func = new_alloc_func;
|
||
realloc_func = new_realloc_func;
|
||
free_func = new_free_func;
|
||
}
|
||
|
||
void *
|
||
_assuan_malloc (size_t n)
|
||
{
|
||
return alloc_func (n);
|
||
}
|
||
|
||
void *
|
||
_assuan_realloc (void *a, size_t n)
|
||
{
|
||
return realloc_func (a, n);
|
||
}
|
||
|
||
void *
|
||
_assuan_calloc (size_t n, size_t m)
|
||
{
|
||
void *p = _assuan_malloc (n*m);
|
||
if (p)
|
||
memset (p, 0, n* m);
|
||
return p;
|
||
}
|
||
|
||
void
|
||
_assuan_free (void *p)
|
||
{
|
||
if (p)
|
||
free_func (p);
|
||
}
|
||
|
||
/* For use with Pth it is required to have special read and write
|
||
functions. We can't assume an ELF based system so we have to
|
||
explicitly set them if we are going to use Pth. */
|
||
void
|
||
assuan_set_io_func (ssize_t (*r)(int,void*,size_t),
|
||
ssize_t (*w)(int,const void*,size_t))
|
||
{
|
||
_assuan_read_wrapper = r;
|
||
_assuan_write_wrapper = w;
|
||
}
|
||
|
||
|
||
|
||
/* Store the error in the context so that the error sending function
|
||
can take out a descriptive text. Inside the assuan code, use the
|
||
macro set_error instead of this function. */
|
||
int
|
||
assuan_set_error (ASSUAN_CONTEXT ctx, int err, const char *text)
|
||
{
|
||
ctx->err_no = err;
|
||
ctx->err_str = text;
|
||
return err;
|
||
}
|
||
|
||
void
|
||
assuan_set_pointer (ASSUAN_CONTEXT ctx, void *pointer)
|
||
{
|
||
if (ctx)
|
||
ctx->user_pointer = pointer;
|
||
}
|
||
|
||
void *
|
||
assuan_get_pointer (ASSUAN_CONTEXT ctx)
|
||
{
|
||
return ctx? ctx->user_pointer : NULL;
|
||
}
|
||
|
||
|
||
void
|
||
assuan_set_log_stream (ASSUAN_CONTEXT ctx, FILE *fp)
|
||
{
|
||
if (ctx)
|
||
{
|
||
if (ctx->log_fp)
|
||
fflush (ctx->log_fp);
|
||
ctx->log_fp = fp;
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
assuan_begin_confidential (ASSUAN_CONTEXT ctx)
|
||
{
|
||
if (ctx)
|
||
{
|
||
ctx->confidential = 1;
|
||
}
|
||
}
|
||
|
||
void
|
||
assuan_end_confidential (ASSUAN_CONTEXT ctx)
|
||
{
|
||
if (ctx)
|
||
{
|
||
ctx->confidential = 0;
|
||
}
|
||
}
|
||
|
||
void
|
||
_assuan_log_print_buffer (FILE *fp, const void *buffer, size_t length)
|
||
{
|
||
const unsigned char *s;
|
||
int n;
|
||
|
||
for (n=length,s=buffer; n; n--, s++)
|
||
{
|
||
if (*s < ' ' || (*s >= 0x7f && *s <= 0xa0))
|
||
break;
|
||
}
|
||
s = buffer;
|
||
if (!n && *s != '[')
|
||
fwrite (buffer, length, 1, fp);
|
||
else
|
||
{
|
||
putc ('[', fp);
|
||
for (n=0; n < length; n++, s++)
|
||
fprintf (fp, " %02x", *s);
|
||
putc (' ', fp);
|
||
putc (']', fp);
|
||
}
|
||
}
|
||
|
||
|
||
/* print a user supplied string after filtering out potential bad
|
||
characters*/
|
||
void
|
||
_assuan_log_sanitized_string (const char *string)
|
||
{
|
||
const unsigned char *s = string;
|
||
#ifdef HAVE_JNLIB_LOGGING
|
||
FILE *fp = log_get_stream ();
|
||
#else
|
||
FILE *fp = stderr;
|
||
#endif
|
||
|
||
for (; *s; s++)
|
||
{
|
||
if (*s < 0x20 || (*s >= 0x7f && *s <= 0xa0))
|
||
{
|
||
putc ('\\', fp);
|
||
if (*s == '\n')
|
||
putc ('n', fp);
|
||
else if (*s == '\r')
|
||
putc ('r', fp);
|
||
else if (*s == '\f')
|
||
putc ('f', fp);
|
||
else if (*s == '\v')
|
||
putc ('v', fp);
|
||
else if (*s == '\b')
|
||
putc ('b', fp);
|
||
else if (!*s)
|
||
putc ('0', fp);
|
||
else
|
||
fprintf (fp, "x%02x", *s );
|
||
}
|
||
else
|
||
putc (*s, fp);
|
||
}
|
||
}
|
||
|
||
|