* gpgkeys_hkp.c (http_get, http_post): Use CRLF for line endings.
[gnupg.git] / assuan / assuan-util.c
1 /* assuan-util.c - Utility functions for Assuan 
2  *      Copyright (C) 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of Assuan.
5  *
6  * Assuan is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Assuan is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #include "assuan-defs.h"
27
28 #ifdef HAVE_JNLIB_LOGGING
29 #include "../jnlib/logging.h"
30 #endif
31
32 ssize_t (*_assuan_read_wrapper)(int,void*,size_t) = NULL;
33 ssize_t (*_assuan_write_wrapper)(int,const void*,size_t) = NULL;
34
35
36 static void *(*alloc_func)(size_t n) = malloc;
37 static void *(*realloc_func)(void *p, size_t n) = realloc;
38 static void (*free_func)(void*) = free;
39
40
41
42 void
43 assuan_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
44                           void *(*new_realloc_func)(void *p, size_t n),
45                           void (*new_free_func)(void*) )
46 {
47   alloc_func        = new_alloc_func;
48   realloc_func      = new_realloc_func;
49   free_func         = new_free_func;
50 }
51
52 void *
53 _assuan_malloc (size_t n)
54 {
55   return alloc_func (n);
56 }
57
58 void *
59 _assuan_realloc (void *a, size_t n)
60 {
61   return realloc_func (a, n);
62 }
63
64 void *
65 _assuan_calloc (size_t n, size_t m)
66 {
67   void *p = _assuan_malloc (n*m);
68   if (p)
69     memset (p, 0, n* m);
70   return p;
71 }
72
73 void
74 _assuan_free (void *p)
75 {
76   if (p)
77     free_func (p);
78 }
79
80 /* For use with Pth it is required to have special read and write
81    functions.  We can't assume an ELF based system so we have to
82    explicitly set them if we are going to use Pth. */
83 void
84 assuan_set_io_func (ssize_t (*r)(int,void*,size_t),
85                     ssize_t (*w)(int,const void*,size_t))
86 {
87   _assuan_read_wrapper = r;
88   _assuan_write_wrapper = w;
89 }
90
91
92 \f
93 /* Store the error in the context so that the error sending function
94   can take out a descriptive text.  Inside the assuan code, use the
95   macro set_error instead of this function. */
96 int
97 assuan_set_error (ASSUAN_CONTEXT ctx, int err, const char *text)
98 {
99   ctx->err_no = err;
100   ctx->err_str = text;
101   return err;
102 }
103
104 void
105 assuan_set_pointer (ASSUAN_CONTEXT ctx, void *pointer)
106 {
107   if (ctx)
108     ctx->user_pointer = pointer;
109 }
110
111 void *
112 assuan_get_pointer (ASSUAN_CONTEXT ctx)
113 {
114   return ctx? ctx->user_pointer : NULL;
115 }
116
117
118 void
119 assuan_set_log_stream (ASSUAN_CONTEXT ctx, FILE *fp)
120 {
121   if (ctx)
122     {
123       if (ctx->log_fp)
124         fflush (ctx->log_fp);
125       ctx->log_fp = fp;
126     }
127 }
128
129
130 void
131 assuan_begin_confidential (ASSUAN_CONTEXT ctx)
132 {
133   if (ctx)
134     {
135       ctx->confidential = 1;
136     }
137 }
138
139 void
140 assuan_end_confidential (ASSUAN_CONTEXT ctx)
141 {
142   if (ctx)
143     {
144       ctx->confidential = 0;
145     }
146 }
147
148 void
149 _assuan_log_print_buffer (FILE *fp, const void *buffer, size_t length)
150 {
151   const unsigned char *s;
152   int n;
153
154   for (n=length,s=buffer; n; n--, s++)
155     {
156       if (*s < ' ' || (*s >= 0x7f && *s <= 0xa0))
157         break;
158     }
159   s = buffer;
160   if (!n && *s != '[')
161     fwrite (buffer, length, 1, fp);
162   else
163     {
164       putc ('[', fp);
165       for (n=0; n < length; n++, s++)
166           fprintf (fp, " %02x", *s);
167       putc (' ', fp);
168       putc (']', fp);
169     }
170 }
171
172
173 /* print a user supplied string after filtering out potential bad
174    characters*/
175 void
176 _assuan_log_sanitized_string (const char *string)
177 {
178   const unsigned char *s = string;
179 #ifdef HAVE_JNLIB_LOGGING
180   FILE *fp = log_get_stream ();
181 #else
182   FILE *fp = stderr;
183 #endif
184
185   for (; *s; s++)
186     {
187       if (*s < 0x20 || (*s >= 0x7f && *s <= 0xa0))
188         {
189           putc ('\\', fp);
190           if (*s == '\n')
191             putc ('n', fp);
192           else if (*s == '\r')
193             putc ('r', fp);
194           else if (*s == '\f')
195             putc ('f', fp);
196           else if (*s == '\v')
197             putc ('v', fp);
198           else if (*s == '\b')
199             putc ('b', fp);
200           else if (!*s)
201             putc ('0', fp);
202           else
203             fprintf (fp, "x%02x", *s );
204         }
205       else
206         putc (*s, fp);
207     }
208 }
209
210