| 1 |
/* writer.c - provides the Writer object |
| 2 |
* Copyright (C) 2001, 2010, 2012 g10 Code GmbH |
| 3 |
* |
| 4 |
* This file is part of KSBA. |
| 5 |
* |
| 6 |
* KSBA is free software; you can redistribute it and/or modify |
| 7 |
* it under the terms of either |
| 8 |
* |
| 9 |
* - the GNU Lesser General Public License as published by the Free |
| 10 |
* Software Foundation; either version 3 of the License, or (at |
| 11 |
* your option) any later version. |
| 12 |
* |
| 13 |
* or |
| 14 |
* |
| 15 |
* - the GNU General Public License as published by the Free |
| 16 |
* Software Foundation; either version 2 of the License, or (at |
| 17 |
* your option) any later version. |
| 18 |
* |
| 19 |
* or both in parallel, as here. |
| 20 |
* |
| 21 |
* KSBA is distributed in the hope that it will be useful, but WITHOUT |
| 22 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| 23 |
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public |
| 24 |
* License for more details. |
| 25 |
* |
| 26 |
* You should have received a copies of the GNU General Public License |
| 27 |
* and the GNU Lesser General Public License along with this program; |
| 28 |
* if not, see <http://www.gnu.org/licenses/>. |
| 29 |
*/ |
| 30 |
|
| 31 |
#include <config.h> |
| 32 |
#include <stdio.h> |
| 33 |
#include <stdlib.h> |
| 34 |
#include <string.h> |
| 35 |
#include <assert.h> |
| 36 |
#include <errno.h> |
| 37 |
#include "util.h" |
| 38 |
|
| 39 |
#include "ksba.h" |
| 40 |
#include "writer.h" |
| 41 |
#include "asn1-func.h" |
| 42 |
#include "ber-help.h" |
| 43 |
|
| 44 |
/** |
| 45 |
* ksba_writer_new: |
| 46 |
* |
| 47 |
* Create a new but uninitialized ksba_writer_t Object. Using this |
| 48 |
* write object in unitialized state does always return an error. |
| 49 |
* |
| 50 |
* Return value: ksba_writer_t object or an error code. |
| 51 |
**/ |
| 52 |
gpg_error_t |
| 53 |
ksba_writer_new (ksba_writer_t *r_w) |
| 54 |
{ |
| 55 |
*r_w = xtrycalloc (1, sizeof **r_w); |
| 56 |
if (!*r_w) |
| 57 |
return gpg_error_from_errno (errno); |
| 58 |
|
| 59 |
return 0; |
| 60 |
} |
| 61 |
|
| 62 |
|
| 63 |
/** |
| 64 |
* ksba_writer_release: |
| 65 |
* @w: Writer Object (or NULL) |
| 66 |
* |
| 67 |
* Release this object |
| 68 |
**/ |
| 69 |
void |
| 70 |
ksba_writer_release (ksba_writer_t w) |
| 71 |
{ |
| 72 |
if (!w) |
| 73 |
return; |
| 74 |
if (w->notify_cb) |
| 75 |
{ |
| 76 |
void (*notify_fnc)(void*,ksba_writer_t) = w->notify_cb; |
| 77 |
|
| 78 |
w->notify_cb = NULL; |
| 79 |
notify_fnc (w->notify_cb_value, w); |
| 80 |
} |
| 81 |
if (w->type == WRITER_TYPE_MEM) |
| 82 |
xfree (w->u.mem.buffer); |
| 83 |
xfree (w); |
| 84 |
} |
| 85 |
|
| 86 |
|
| 87 |
/* Set NOTIFY as function to be called by ksba_reader_release before |
| 88 |
resources are actually deallocated. NOTIFY_VALUE is passed to the |
| 89 |
called function as its first argument. Note that only the last |
| 90 |
registered function will be called; passing NULL for NOTIFY removes |
| 91 |
the notification. */ |
| 92 |
gpg_error_t |
| 93 |
ksba_writer_set_release_notify (ksba_writer_t w, |
| 94 |
void (*notify)(void*,ksba_writer_t), |
| 95 |
void *notify_value) |
| 96 |
{ |
| 97 |
if (!w) |
| 98 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 99 |
w->notify_cb = notify; |
| 100 |
w->notify_cb_value = notify_value; |
| 101 |
return 0; |
| 102 |
} |
| 103 |
|
| 104 |
|
| 105 |
int |
| 106 |
ksba_writer_error (ksba_writer_t w) |
| 107 |
{ |
| 108 |
return w? gpg_error_from_errno (w->error) : gpg_error (GPG_ERR_INV_VALUE); |
| 109 |
} |
| 110 |
|
| 111 |
unsigned long |
| 112 |
ksba_writer_tell (ksba_writer_t w) |
| 113 |
{ |
| 114 |
return w? w->nwritten : 0; |
| 115 |
} |
| 116 |
|
| 117 |
|
| 118 |
/** |
| 119 |
* ksba_writer_set_fd: |
| 120 |
* @w: Writer object |
| 121 |
* @fd: file descriptor |
| 122 |
* |
| 123 |
* Initialize the Writer object with a file descriptor, so that write |
| 124 |
* operations on this object are excuted on this file descriptor. |
| 125 |
* |
| 126 |
* Return value: |
| 127 |
**/ |
| 128 |
gpg_error_t |
| 129 |
ksba_writer_set_fd (ksba_writer_t w, int fd) |
| 130 |
{ |
| 131 |
if (!w || fd == -1) |
| 132 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 133 |
if (w->type) |
| 134 |
return gpg_error (GPG_ERR_CONFLICT); |
| 135 |
|
| 136 |
w->error = 0; |
| 137 |
w->type = WRITER_TYPE_FD; |
| 138 |
w->u.fd = fd; |
| 139 |
|
| 140 |
return 0; |
| 141 |
} |
| 142 |
|
| 143 |
/** |
| 144 |
* ksba_writer_set_file: |
| 145 |
* @w: Writer object |
| 146 |
* @fp: file pointer |
| 147 |
* |
| 148 |
* Initialize the Writer object with a stdio file pointer, so that write |
| 149 |
* operations on this object are excuted on this stream |
| 150 |
* |
| 151 |
* Return value: |
| 152 |
**/ |
| 153 |
gpg_error_t |
| 154 |
ksba_writer_set_file (ksba_writer_t w, FILE *fp) |
| 155 |
{ |
| 156 |
if (!w || !fp) |
| 157 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 158 |
if (w->type) |
| 159 |
return gpg_error (GPG_ERR_CONFLICT); |
| 160 |
|
| 161 |
w->error = 0; |
| 162 |
w->type = WRITER_TYPE_FILE; |
| 163 |
w->u.file = fp; |
| 164 |
return 0; |
| 165 |
} |
| 166 |
|
| 167 |
|
| 168 |
|
| 169 |
/** |
| 170 |
* ksba_writer_set_cb: |
| 171 |
* @w: Writer object |
| 172 |
* @cb: Callback function |
| 173 |
* @cb_value: Value passed to the callback function |
| 174 |
* |
| 175 |
* Initialize the writer object with a callback function. |
| 176 |
* This callback function is defined as: |
| 177 |
* <literal> |
| 178 |
* typedef int (*cb) (void *cb_value, |
| 179 |
* const void *buffer, size_t count); |
| 180 |
* </literal> |
| 181 |
* |
| 182 |
* The callback is expected to process all @count bytes from @buffer |
| 183 |
* @count should not be 0 and @buffer should not be %NULL |
| 184 |
* The callback should return 0 on success or an %KSBA_xxx error code. |
| 185 |
* |
| 186 |
* Return value: 0 on success or an error code |
| 187 |
**/ |
| 188 |
gpg_error_t |
| 189 |
ksba_writer_set_cb (ksba_writer_t w, |
| 190 |
int (*cb)(void*,const void *,size_t), void *cb_value ) |
| 191 |
{ |
| 192 |
if (!w || !cb) |
| 193 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 194 |
if (w->type) |
| 195 |
return gpg_error (GPG_ERR_CONFLICT); |
| 196 |
|
| 197 |
w->error = 0; |
| 198 |
w->type = WRITER_TYPE_CB; |
| 199 |
w->u.cb.fnc = cb; |
| 200 |
w->u.cb.value = cb_value; |
| 201 |
|
| 202 |
return 0; |
| 203 |
} |
| 204 |
|
| 205 |
|
| 206 |
gpg_error_t |
| 207 |
ksba_writer_set_mem (ksba_writer_t w, size_t initial_size) |
| 208 |
{ |
| 209 |
if (!w) |
| 210 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 211 |
if (w->type == WRITER_TYPE_MEM) |
| 212 |
; /* Reuse the buffer (we ignore the initial size)*/ |
| 213 |
else |
| 214 |
{ |
| 215 |
if (w->type) |
| 216 |
return gpg_error (GPG_ERR_CONFLICT); |
| 217 |
|
| 218 |
if (!initial_size) |
| 219 |
initial_size = 1024; |
| 220 |
|
| 221 |
w->u.mem.buffer = xtrymalloc (initial_size); |
| 222 |
if (!w->u.mem.buffer) |
| 223 |
return gpg_error (GPG_ERR_ENOMEM); |
| 224 |
w->u.mem.size = initial_size; |
| 225 |
w->type = WRITER_TYPE_MEM; |
| 226 |
} |
| 227 |
w->error = 0; |
| 228 |
w->nwritten = 0; |
| 229 |
|
| 230 |
return 0; |
| 231 |
} |
| 232 |
|
| 233 |
/* Return the pointer to the memory and the size of it. This pointer |
| 234 |
is valid as long as the writer object is valid and no write |
| 235 |
operations takes place (because they might reallocate the buffer). |
| 236 |
if NBYTES is not NULL, it will receive the number of bytes in this |
| 237 |
buffer which is the same value ksba_writer_tell() returns. |
| 238 |
|
| 239 |
In case of an error NULL is returned. |
| 240 |
*/ |
| 241 |
const void * |
| 242 |
ksba_writer_get_mem (ksba_writer_t w, size_t *nbytes) |
| 243 |
{ |
| 244 |
if (!w || w->type != WRITER_TYPE_MEM || w->error) |
| 245 |
return NULL; |
| 246 |
if (nbytes) |
| 247 |
*nbytes = w->nwritten; |
| 248 |
return w->u.mem.buffer; |
| 249 |
} |
| 250 |
|
| 251 |
/* Return the the memory and the size of it. The writer object is set |
| 252 |
back into the uninitalized state; i.e. one of the |
| 253 |
ksab_writer_set_xxx () must be used before all other operations. |
| 254 |
if NBYTES is not NULL, it will receive the number of bytes in this |
| 255 |
buffer which is the same value ksba_writer_tell() returns. |
| 256 |
|
| 257 |
In case of an error NULL is returned. */ |
| 258 |
void * |
| 259 |
ksba_writer_snatch_mem (ksba_writer_t w, size_t *nbytes) |
| 260 |
{ |
| 261 |
void *p; |
| 262 |
|
| 263 |
if (!w || w->type != WRITER_TYPE_MEM || w->error) |
| 264 |
return NULL; |
| 265 |
if (nbytes) |
| 266 |
*nbytes = w->nwritten; |
| 267 |
p = w->u.mem.buffer; |
| 268 |
w->u.mem.buffer = NULL; |
| 269 |
w->type = 0; |
| 270 |
w->nwritten = 0; |
| 271 |
return p; |
| 272 |
} |
| 273 |
|
| 274 |
|
| 275 |
|
| 276 |
gpg_error_t |
| 277 |
ksba_writer_set_filter (ksba_writer_t w, |
| 278 |
gpg_error_t (*filter)(void*, |
| 279 |
const void *,size_t, size_t *, |
| 280 |
void *, size_t, size_t *), |
| 281 |
void *filter_arg) |
| 282 |
{ |
| 283 |
if (!w) |
| 284 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 285 |
|
| 286 |
w->filter = filter; |
| 287 |
w->filter_arg = filter_arg; |
| 288 |
return 0; |
| 289 |
} |
| 290 |
|
| 291 |
|
| 292 |
|
| 293 |
|
| 294 |
static gpg_error_t |
| 295 |
do_writer_write (ksba_writer_t w, const void *buffer, size_t length) |
| 296 |
{ |
| 297 |
if (!w->type) |
| 298 |
{ |
| 299 |
w->error = EINVAL; |
| 300 |
return gpg_error_from_errno (w->error); |
| 301 |
} |
| 302 |
else if (w->type == WRITER_TYPE_MEM) |
| 303 |
{ |
| 304 |
if (w->error == ENOMEM) |
| 305 |
return gpg_error (GPG_ERR_ENOMEM); /* it does not make sense to proceed then */ |
| 306 |
|
| 307 |
if (w->nwritten + length > w->u.mem.size) |
| 308 |
{ |
| 309 |
size_t newsize = w->nwritten + length; |
| 310 |
char *p; |
| 311 |
|
| 312 |
newsize = ((newsize + 4095)/4096)*4096; |
| 313 |
if (newsize < 16384) |
| 314 |
newsize += 4096; |
| 315 |
else |
| 316 |
newsize += 16384; |
| 317 |
|
| 318 |
p = xtryrealloc (w->u.mem.buffer, newsize); |
| 319 |
if (!p) |
| 320 |
{ |
| 321 |
/* Keep an error flag so that the user does not need to |
| 322 |
check the return code of a write but instead use |
| 323 |
ksba_writer_error() to check for it or even figure |
| 324 |
this state out when using ksba_writer_get_mem() */ |
| 325 |
w->error = ENOMEM; |
| 326 |
return gpg_error (GPG_ERR_ENOMEM); |
| 327 |
} |
| 328 |
w->u.mem.buffer = p; |
| 329 |
w->u.mem.size = newsize; |
| 330 |
/* Better check again in case of an overwrap. */ |
| 331 |
if (w->nwritten + length > w->u.mem.size) |
| 332 |
return gpg_error (GPG_ERR_ENOMEM); |
| 333 |
} |
| 334 |
memcpy (w->u.mem.buffer + w->nwritten, buffer, length); |
| 335 |
w->nwritten += length; |
| 336 |
} |
| 337 |
else if (w->type == WRITER_TYPE_FILE) |
| 338 |
{ |
| 339 |
if (!length) |
| 340 |
return 0; |
| 341 |
|
| 342 |
if ( fwrite (buffer, length, 1, w->u.file) == 1) |
| 343 |
{ |
| 344 |
w->nwritten += length; |
| 345 |
} |
| 346 |
else |
| 347 |
{ |
| 348 |
w->error = errno; |
| 349 |
return gpg_error_from_errno (errno); |
| 350 |
} |
| 351 |
} |
| 352 |
else if (w->type == WRITER_TYPE_CB) |
| 353 |
{ |
| 354 |
int err = w->u.cb.fnc (w->u.cb.value, buffer, length); |
| 355 |
if (err) |
| 356 |
return err; |
| 357 |
w->nwritten += length; |
| 358 |
} |
| 359 |
else |
| 360 |
return gpg_error (GPG_ERR_BUG); |
| 361 |
|
| 362 |
return 0; |
| 363 |
} |
| 364 |
|
| 365 |
/** |
| 366 |
* ksba_writer_write: |
| 367 |
* @w: Writer object |
| 368 |
* @buffer: A buffer with the data to be written |
| 369 |
* @length: The length of this buffer |
| 370 |
* |
| 371 |
* Write @length bytes from @buffer. |
| 372 |
* |
| 373 |
* Return value: 0 on success or an error code |
| 374 |
**/ |
| 375 |
gpg_error_t |
| 376 |
ksba_writer_write (ksba_writer_t w, const void *buffer, size_t length) |
| 377 |
{ |
| 378 |
gpg_error_t err=0; |
| 379 |
|
| 380 |
if (!w) |
| 381 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 382 |
|
| 383 |
if (!buffer) |
| 384 |
return gpg_error (GPG_ERR_NOT_IMPLEMENTED); |
| 385 |
|
| 386 |
if (w->filter) |
| 387 |
{ |
| 388 |
char outbuf[4096]; |
| 389 |
size_t nin, nout; |
| 390 |
const char *p = buffer; |
| 391 |
|
| 392 |
while (length) |
| 393 |
{ |
| 394 |
err = w->filter (w->filter_arg, p, length, &nin, |
| 395 |
outbuf, sizeof (outbuf), &nout); |
| 396 |
if (err) |
| 397 |
break; |
| 398 |
if (nin > length || nout > sizeof (outbuf)) |
| 399 |
return gpg_error (GPG_ERR_BUG); /* tsss, someone else made an error */ |
| 400 |
err = do_writer_write (w, outbuf, nout); |
| 401 |
if (err) |
| 402 |
break; |
| 403 |
length -= nin; |
| 404 |
p += nin; |
| 405 |
} |
| 406 |
} |
| 407 |
else |
| 408 |
{ |
| 409 |
err = do_writer_write (w, buffer, length); |
| 410 |
} |
| 411 |
|
| 412 |
return err; |
| 413 |
} |
| 414 |
|
| 415 |
/* Write LENGTH bytes of BUFFER to W while encoding it as an BER |
| 416 |
encoded octet string. With FLUSH set to 1 the octet stream will be |
| 417 |
terminated. If the entire octet string is available in BUFFER it |
| 418 |
is a good idea to set FLUSH to 1 so that the function does not need |
| 419 |
to encode the string partially. */ |
| 420 |
gpg_error_t |
| 421 |
ksba_writer_write_octet_string (ksba_writer_t w, |
| 422 |
const void *buffer, size_t length, int flush) |
| 423 |
{ |
| 424 |
gpg_error_t err = 0; |
| 425 |
|
| 426 |
if (!w) |
| 427 |
return gpg_error (GPG_ERR_INV_VALUE); |
| 428 |
|
| 429 |
if (buffer && length) |
| 430 |
{ |
| 431 |
if (!w->ndef_is_open && !flush) |
| 432 |
{ |
| 433 |
err = _ksba_ber_write_tl (w, TYPE_OCTET_STRING, |
| 434 |
CLASS_UNIVERSAL, 1, 0); |
| 435 |
if (err) |
| 436 |
return err; |
| 437 |
w->ndef_is_open = 1; |
| 438 |
} |
| 439 |
|
| 440 |
err = _ksba_ber_write_tl (w, TYPE_OCTET_STRING, |
| 441 |
CLASS_UNIVERSAL, 0, length); |
| 442 |
if (!err) |
| 443 |
err = ksba_writer_write (w, buffer, length); |
| 444 |
} |
| 445 |
|
| 446 |
if (!err && flush && w->ndef_is_open) /* write an end tag */ |
| 447 |
err = _ksba_ber_write_tl (w, 0, 0, 0, 0); |
| 448 |
|
| 449 |
if (flush) /* Reset it even in case of an error. */ |
| 450 |
w->ndef_is_open = 1; |
| 451 |
|
| 452 |
return err; |
| 453 |
} |