crypto/external/bsd/netpgp/dist/src/lib/packet-parse.h

   1 /*-
   2  * Copyright (c) 2009 The NetBSD Foundation, Inc.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to The NetBSD Foundation
   6  * by Alistair Crooks (agc@NetBSD.org)
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  */
  29 /*
  30  * Copyright (c) 2005-2008 Nominet UK (www.nic.uk)
  31  * All rights reserved.
  32  * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted
  33  * their moral rights under the UK Copyright Design and Patents Act 1988 to
  34  * be recorded as the authors of this copyright work.
  35  *
  36  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  37  * use this file except in compliance with the License.
  38  *
  39  * You may obtain a copy of the License at
  40  *     http://www.apache.org/licenses/LICENSE-2.0
  41  *
  42  * Unless required by applicable law or agreed to in writing, software
  43  * distributed under the License is distributed on an "AS IS" BASIS,
  44  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  45  *
  46  * See the License for the specific language governing permissions and
  47  * limitations under the License.
  48  */
  49
  50 /** \file
  51  * Parser for OpenPGP packets - headers.
  52  */
  53
  54 #ifndef PACKET_PARSE_H_
  55 #define PACKET_PARSE_H_
  56
  57 #include "types.h"
  58 #include "packet.h"
  59
  60 /** __ops_region_t */
  61 typedef struct __ops_region_t {
  62         struct __ops_region_t   *parent;
  63         unsigned                 length;
  64         unsigned                 readc;         /* length read */
  65         unsigned                 last_read;
  66                 /* length of last read, only valid in deepest child */
  67         unsigned                 indeterminate:1;
  68 } __ops_region_t;
  69
  70 void __ops_init_subregion(__ops_region_t *, __ops_region_t *);
  71
  72 /** __ops_cb_ret_t */
  73 typedef enum {
  74         OPS_RELEASE_MEMORY,
  75         OPS_KEEP_MEMORY,
  76         OPS_FINISHED
  77 } __ops_cb_ret_t;
  78
  79 typedef struct __ops_cbdata_t    __ops_cbdata_t;
  80
  81 typedef __ops_cb_ret_t __ops_cbfunc_t(const __ops_packet_t *,
  82                                         __ops_cbdata_t *);
  83
  84 __ops_cb_ret_t
  85 get_passphrase_cb(const __ops_packet_t *, __ops_cbdata_t *);
  86
  87 typedef struct __ops_stream_t   __ops_stream_t;
  88 typedef struct __ops_reader_t           __ops_reader_t;
  89 typedef struct __ops_cryptinfo_t        __ops_cryptinfo_t;
  90
  91 /*
  92    A reader MUST read at least one byte if it can, and should read up
  93    to the number asked for. Whether it reads more for efficiency is
  94    its own decision, but if it is a stacked reader it should never
  95    read more than the length of the region it operates in (which it
  96    would have to be given when it is stacked).
  97
  98    If a read is short because of EOF, then it should return the short
  99    read (obviously this will be zero on the second attempt, if not the
 100    first). Because a reader is not obliged to do a full read, only a
 101    zero return can be taken as an indication of EOF.
 102
 103    If there is an error, then the callback should be notified, the
 104    error stacked, and -1 should be returned.
 105
 106    Note that although length is a size_t, a reader will never be asked
 107    to read more than INT_MAX in one go.
 108
 109  */
 110 typedef int __ops_reader_func_t(void *, size_t, __ops_error_t **,
 111                                 __ops_reader_t *, __ops_cbdata_t *);
 112
 113 typedef void __ops_reader_destroyer_t(__ops_reader_t *);
 114
 115 void __ops_stream_delete(__ops_stream_t *);
 116 __ops_error_t *__ops_stream_get_errors(__ops_stream_t *);
 117 __ops_crypt_t *__ops_get_decrypt(__ops_stream_t *);
 118
 119 void __ops_set_callback(__ops_stream_t *, __ops_cbfunc_t *, void *);
 120 void __ops_callback_push(__ops_stream_t *, __ops_cbfunc_t *, void *);
 121 void *__ops_callback_arg(__ops_cbdata_t *);
 122 void *__ops_callback_errors(__ops_cbdata_t *);
 123 void __ops_reader_set(__ops_stream_t *, __ops_reader_func_t *,
 124                         __ops_reader_destroyer_t *, void *);
 125 void __ops_reader_push(__ops_stream_t *, __ops_reader_func_t *,
 126                         __ops_reader_destroyer_t *, void *);
 127 void __ops_reader_pop(__ops_stream_t *);
 128
 129 void *__ops_reader_get_arg(__ops_reader_t *);
 130
 131 __ops_cb_ret_t __ops_callback(const __ops_packet_t *,
 132                                         __ops_cbdata_t *);
 133 __ops_cb_ret_t __ops_stacked_callback(const __ops_packet_t *,
 134                                         __ops_cbdata_t *);
 135 __ops_reader_t *__ops_readinfo(__ops_stream_t *);
 136
 137 int __ops_parse(__ops_stream_t *, const int);
 138
 139 /** Used to specify whether subpackets should be returned raw, parsed
 140 * or ignored.  */
 141 typedef enum {
 142         OPS_PARSE_RAW,          /* Callback Raw */
 143         OPS_PARSE_PARSED,       /* Callback Parsed */
 144         OPS_PARSE_IGNORE        /* Don't callback */
 145 } __ops_parse_type_t;
 146
 147 void __ops_parse_options(__ops_stream_t *, __ops_content_tag_t,
 148                         __ops_parse_type_t);
 149
 150 unsigned __ops_limited_read(unsigned char *, size_t, __ops_region_t *,
 151                         __ops_error_t **, __ops_reader_t *,
 152                         __ops_cbdata_t *);
 153 unsigned __ops_stacked_limited_read(unsigned char *, unsigned,
 154                         __ops_region_t *, __ops_error_t **,
 155                         __ops_reader_t *, __ops_cbdata_t *);
 156 void __ops_parse_hash_init(__ops_stream_t *, __ops_hash_alg_t,
 157                         const unsigned char *);
 158 void __ops_parse_hash_data(__ops_stream_t *, const void *, size_t);
 159 void __ops_parse_hash_finish(__ops_stream_t *);
 160 __ops_hash_t *__ops_parse_hash_find(__ops_stream_t *, const unsigned char *);
 161
 162 __ops_reader_func_t    __ops_stacked_read;
 163
 164 int __ops_decompress(__ops_region_t *, __ops_stream_t *,
 165                         __ops_compression_type_t);
 166 unsigned __ops_writez(const unsigned char *, const unsigned int,
 167                         __ops_output_t *);
 168
 169 #endif /* PACKET_PARSE_H_ */