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_enum, 148 __ops_parse_type_t); 149 150 unsigned __ops_limited_read(uint8_t *, size_t, __ops_region_t *, 151 __ops_error_t **, __ops_reader_t *, 152 __ops_cbdata_t *); 153 unsigned __ops_stacked_limited_read(uint8_t *, 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 uint8_t *); 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 uint8_t *); 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(__ops_output_t *, const uint8_t *, 167 const unsigned); 168 169 #endif /* PACKET_PARSE_H_ */ 170