1 /* $NetBSD: store_mem.c,v 1.1.1.2 2014/04/24 12:45:51 pettai Exp $ */
2
3 /*
4 * Copyright (c) 1997 - 2000, 2002 Kungliga Tekniska Högskolan
5 * (Royal Institute of Technology, Stockholm, Sweden).
6 * All rights reserved.
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 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "krb5_locl.h"
37 #include "store-int.h"
38
39 typedef struct mem_storage{
40 unsigned char *base;
41 size_t size;
42 unsigned char *ptr;
43 }mem_storage;
44
45 static ssize_t
mem_fetch(krb5_storage * sp,void * data,size_t size)46 mem_fetch(krb5_storage *sp, void *data, size_t size)
47 {
48 mem_storage *s = (mem_storage*)sp->data;
49 if(size > (size_t)(s->base + s->size - s->ptr))
50 size = s->base + s->size - s->ptr;
51 memmove(data, s->ptr, size);
52 sp->seek(sp, size, SEEK_CUR);
53 return size;
54 }
55
56 static ssize_t
mem_store(krb5_storage * sp,const void * data,size_t size)57 mem_store(krb5_storage *sp, const void *data, size_t size)
58 {
59 mem_storage *s = (mem_storage*)sp->data;
60 if(size > (size_t)(s->base + s->size - s->ptr))
61 size = s->base + s->size - s->ptr;
62 memmove(s->ptr, data, size);
63 sp->seek(sp, size, SEEK_CUR);
64 return size;
65 }
66
67 static ssize_t
mem_no_store(krb5_storage * sp,const void * data,size_t size)68 mem_no_store(krb5_storage *sp, const void *data, size_t size)
69 {
70 return -1;
71 }
72
73 static off_t
mem_seek(krb5_storage * sp,off_t offset,int whence)74 mem_seek(krb5_storage *sp, off_t offset, int whence)
75 {
76 mem_storage *s = (mem_storage*)sp->data;
77 switch(whence){
78 case SEEK_SET:
79 if((size_t)offset > s->size)
80 offset = s->size;
81 if(offset < 0)
82 offset = 0;
83 s->ptr = s->base + offset;
84 break;
85 case SEEK_CUR:
86 return sp->seek(sp, s->ptr - s->base + offset, SEEK_SET);
87 case SEEK_END:
88 return sp->seek(sp, s->size + offset, SEEK_SET);
89 default:
90 errno = EINVAL;
91 return -1;
92 }
93 return s->ptr - s->base;
94 }
95
96 static int
mem_trunc(krb5_storage * sp,off_t offset)97 mem_trunc(krb5_storage *sp, off_t offset)
98 {
99 mem_storage *s = (mem_storage*)sp->data;
100 if((size_t)offset > s->size)
101 return ERANGE;
102 s->size = offset;
103 if ((s->ptr - s->base) > offset)
104 s->ptr = s->base + offset;
105 return 0;
106 }
107
108 static int
mem_no_trunc(krb5_storage * sp,off_t offset)109 mem_no_trunc(krb5_storage *sp, off_t offset)
110 {
111 return EINVAL;
112 }
113
114 /**
115 * Create a fixed size memory storage block
116 *
117 * @return A krb5_storage on success, or NULL on out of memory error.
118 *
119 * @ingroup krb5_storage
120 *
121 * @sa krb5_storage_mem()
122 * @sa krb5_storage_from_readonly_mem()
123 * @sa krb5_storage_from_data()
124 * @sa krb5_storage_from_fd()
125 */
126
127 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_mem(void * buf,size_t len)128 krb5_storage_from_mem(void *buf, size_t len)
129 {
130 krb5_storage *sp = malloc(sizeof(krb5_storage));
131 mem_storage *s;
132 if(sp == NULL)
133 return NULL;
134 s = malloc(sizeof(*s));
135 if(s == NULL) {
136 free(sp);
137 return NULL;
138 }
139 sp->data = s;
140 sp->flags = 0;
141 sp->eof_code = HEIM_ERR_EOF;
142 s->base = buf;
143 s->size = len;
144 s->ptr = buf;
145 sp->fetch = mem_fetch;
146 sp->store = mem_store;
147 sp->seek = mem_seek;
148 sp->trunc = mem_trunc;
149 sp->free = NULL;
150 sp->max_alloc = UINT_MAX/8;
151 return sp;
152 }
153
154 /**
155 * Create a fixed size memory storage block
156 *
157 * @return A krb5_storage on success, or NULL on out of memory error.
158 *
159 * @ingroup krb5_storage
160 *
161 * @sa krb5_storage_mem()
162 * @sa krb5_storage_from_mem()
163 * @sa krb5_storage_from_readonly_mem()
164 * @sa krb5_storage_from_fd()
165 */
166
167 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_data(krb5_data * data)168 krb5_storage_from_data(krb5_data *data)
169 {
170 return krb5_storage_from_mem(data->data, data->length);
171 }
172
173 /**
174 * Create a fixed size memory storage block that is read only
175 *
176 * @return A krb5_storage on success, or NULL on out of memory error.
177 *
178 * @ingroup krb5_storage
179 *
180 * @sa krb5_storage_mem()
181 * @sa krb5_storage_from_mem()
182 * @sa krb5_storage_from_data()
183 * @sa krb5_storage_from_fd()
184 */
185
186 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_readonly_mem(const void * buf,size_t len)187 krb5_storage_from_readonly_mem(const void *buf, size_t len)
188 {
189 krb5_storage *sp = malloc(sizeof(krb5_storage));
190 mem_storage *s;
191 if(sp == NULL)
192 return NULL;
193 s = malloc(sizeof(*s));
194 if(s == NULL) {
195 free(sp);
196 return NULL;
197 }
198 sp->data = s;
199 sp->flags = 0;
200 sp->eof_code = HEIM_ERR_EOF;
201 s->base = rk_UNCONST(buf);
202 s->size = len;
203 s->ptr = rk_UNCONST(buf);
204 sp->fetch = mem_fetch;
205 sp->store = mem_no_store;
206 sp->seek = mem_seek;
207 sp->trunc = mem_no_trunc;
208 sp->free = NULL;
209 sp->max_alloc = UINT_MAX/8;
210 return sp;
211 }
212