xref: /netbsd-src/crypto/external/bsd/heimdal/dist/lib/krb5/store_mem.c (revision d3273b5b76f5afaafe308cead5511dbb8df8c5e9)
1 /*	$NetBSD: store_mem.c,v 1.2 2017/01/28 21:31:49 christos 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  * @sa krb5_storage_from_socket()
126  */
127 
128 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_mem(void * buf,size_t len)129 krb5_storage_from_mem(void *buf, size_t len)
130 {
131     krb5_storage *sp = malloc(sizeof(krb5_storage));
132     mem_storage *s;
133     if(sp == NULL)
134 	return NULL;
135     s = malloc(sizeof(*s));
136     if(s == NULL) {
137 	free(sp);
138 	return NULL;
139     }
140     sp->data = s;
141     sp->flags = 0;
142     sp->eof_code = HEIM_ERR_EOF;
143     s->base = buf;
144     s->size = len;
145     s->ptr = buf;
146     sp->fetch = mem_fetch;
147     sp->store = mem_store;
148     sp->seek = mem_seek;
149     sp->trunc = mem_trunc;
150     sp->fsync = NULL;
151     sp->free = NULL;
152     sp->max_alloc = UINT_MAX/8;
153     return sp;
154 }
155 
156 /**
157  * Create a fixed size memory storage block
158  *
159  * @return A krb5_storage on success, or NULL on out of memory error.
160  *
161  * @ingroup krb5_storage
162  *
163  * @sa krb5_storage_mem()
164  * @sa krb5_storage_from_mem()
165  * @sa krb5_storage_from_readonly_mem()
166  * @sa krb5_storage_from_fd()
167  */
168 
169 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_data(krb5_data * data)170 krb5_storage_from_data(krb5_data *data)
171 {
172     return krb5_storage_from_mem(data->data, data->length);
173 }
174 
175 /**
176  * Create a fixed size memory storage block that is read only
177  *
178  * @return A krb5_storage on success, or NULL on out of memory error.
179  *
180  * @ingroup krb5_storage
181  *
182  * @sa krb5_storage_mem()
183  * @sa krb5_storage_from_mem()
184  * @sa krb5_storage_from_data()
185  * @sa krb5_storage_from_fd()
186  */
187 
188 KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_readonly_mem(const void * buf,size_t len)189 krb5_storage_from_readonly_mem(const void *buf, size_t len)
190 {
191     krb5_storage *sp = malloc(sizeof(krb5_storage));
192     mem_storage *s;
193     if(sp == NULL)
194 	return NULL;
195     s = malloc(sizeof(*s));
196     if(s == NULL) {
197 	free(sp);
198 	return NULL;
199     }
200     sp->data = s;
201     sp->flags = 0;
202     sp->eof_code = HEIM_ERR_EOF;
203     s->base = rk_UNCONST(buf);
204     s->size = len;
205     s->ptr = rk_UNCONST(buf);
206     sp->fetch = mem_fetch;
207     sp->store = mem_no_store;
208     sp->seek = mem_seek;
209     sp->trunc = mem_no_trunc;
210     sp->fsync = NULL;
211     sp->free = NULL;
212     sp->max_alloc = UINT_MAX/8;
213     return sp;
214 }
215