Line data    Source code

       1             : /*
       2             :  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
       3             :  * (Royal Institute of Technology, Stockholm, Sweden).
       4             :  * All rights reserved.
       5             :  *
       6             :  * Redistribution and use in source and binary forms, with or without
       7             :  * modification, are permitted provided that the following conditions
       8             :  * are met:
       9             :  *
      10             :  * 1. Redistributions of source code must retain the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer.
      12             :  *
      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             :  * 3. Neither the name of the Institute nor the names of its contributors
      18             :  *    may be used to endorse or promote products derived from this software
      19             :  *    without specific prior written permission.
      20             :  *
      21             :  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
      22             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
      25             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      26             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      27             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      28             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      31             :  * SUCH DAMAGE.
      32             :  */
      33             : 
      34             : #include "krb5_locl.h"
      35             : #include "store-int.h"
      36             : #include <assert.h>
      37             : 
      38             : typedef struct emem_storage{
      39             :     unsigned char *base;
      40             :     size_t size;
      41             :     size_t len;
      42             :     unsigned char *ptr;
      43             : }emem_storage;
      44             : 
      45             : static ssize_t
      46      446700 : emem_fetch(krb5_storage *sp, void *data, size_t size)
      47             : {
      48      446700 :     emem_storage *s = (emem_storage*)sp->data;
      49             : 
      50      446700 :     assert(data != NULL && s->ptr != NULL);
      51             : 
      52      446700 :     if((size_t)(s->base + s->len - s->ptr) < size)
      53           0 :         size = s->base + s->len - s->ptr;
      54      446700 :     memmove(data, s->ptr, size);
      55      446700 :     sp->seek(sp, size, SEEK_CUR);
      56      446700 :     return size;
      57             : }
      58             : 
      59             : static ssize_t
      60     4529198 : emem_store(krb5_storage *sp, const void *data, size_t size)
      61             : {
      62      158562 :     emem_storage *s;
      63             : 
      64     4529198 :     if (size == 0) {
      65      186658 :         sp->seek(sp, 0, SEEK_CUR);
      66      186658 :         return 0;
      67             :     }
      68             : 
      69     4342540 :     s = (emem_storage*)sp->data;
      70             : 
      71     4342540 :     assert(data != NULL);
      72             : 
      73     4342540 :     if(size > (size_t)(s->base + s->size - s->ptr)){
      74        2147 :         void *base;
      75        2147 :         size_t sz, off;
      76       52405 :         off = s->ptr - s->base;
      77       52405 :         sz = off + size;
      78       52405 :         if (sz < 4096)
      79       52396 :             sz *= 2;
      80       52405 :         base = realloc(s->base, sz);
      81       52405 :         if(base == NULL)
      82           0 :             return -1;
      83       52405 :         s->size = sz;
      84       52405 :         s->base = base;
      85       52405 :         s->ptr = (unsigned char*)base + off;
      86             :     }
      87     4342540 :     if (size)
      88     4342540 :         memmove(s->ptr, data, size);
      89     4342540 :     sp->seek(sp, size, SEEK_CUR);
      90     4342540 :     return size;
      91             : }
      92             : 
      93             : static off_t
      94    12632000 : emem_seek(krb5_storage *sp, off_t offset, int whence)
      95             : {
      96    12632000 :     emem_storage *s = (emem_storage*)sp->data;
      97    12632000 :     switch(whence){
      98     6762700 :     case SEEK_SET:
      99     6762700 :         if((size_t)offset > s->size)
     100           0 :             offset = s->size;
     101     6762700 :         if(offset < 0)
     102           0 :             offset = 0;
     103     6762700 :         s->ptr = s->base + offset;
     104     6762700 :         if((size_t)offset > s->len)
     105     4342540 :             s->len = offset;
     106     6530748 :         break;
     107     5422598 :     case SEEK_CUR:
     108     5422598 :         sp->seek(sp,s->ptr - s->base + offset, SEEK_SET);
     109     5422598 :         break;
     110      446702 :     case SEEK_END:
     111      446702 :         sp->seek(sp, s->len + offset, SEEK_SET);
     112      446702 :         break;
     113           0 :     default:
     114           0 :         errno = EINVAL;
     115           0 :         return -1;
     116             :     }
     117    12632000 :     return s->ptr - s->base;
     118             : }
     119             : 
     120             : static int
     121           0 : emem_trunc(krb5_storage *sp, off_t offset)
     122             : {
     123           0 :     emem_storage *s = (emem_storage*)sp->data;
     124             :     /*
     125             :      * If offset is larget then current size, or current size is
     126             :      * shrunk more then half of the current size, adjust buffer.
     127             :      */
     128           0 :     if (offset == 0) {
     129           0 :         if (s->size > 1024) {
     130           0 :             void *base;
     131             : 
     132           0 :             base = realloc(s->base, 1024);
     133           0 :             if (base) {
     134           0 :                 s->base = base;
     135           0 :                 s->size = 1024;
     136             :             }
     137             :         }
     138           0 :         s->len = 0;
     139           0 :         s->ptr = s->base;
     140           0 :     } else if ((size_t)offset > s->size || (s->size / 2) > (size_t)offset) {
     141           0 :         void *base;
     142           0 :         size_t off;
     143           0 :         off = s->ptr - s->base;
     144           0 :         base = realloc(s->base, offset);
     145           0 :         if(base == NULL)
     146           0 :             return ENOMEM;
     147           0 :         if ((size_t)offset > s->size)
     148           0 :             memset((char *)base + s->size, 0, offset - s->size);
     149           0 :         s->size = offset;
     150           0 :         s->base = base;
     151           0 :         s->ptr = (unsigned char *)base + off;
     152             :     }
     153           0 :     s->len = offset;
     154           0 :     if ((s->ptr - s->base) > offset)
     155           0 :         s->ptr = s->base + offset;
     156           0 :     return 0;
     157             : }
     158             : 
     159             : 
     160             : static void
     161      446700 : emem_free(krb5_storage *sp)
     162             : {
     163      446700 :     emem_storage *s = sp->data;
     164             : 
     165      446700 :     assert(s->base != NULL);
     166             : 
     167      446700 :     memset_s(s->base, s->len, 0, s->len);
     168      446700 :     free(s->base);
     169      446700 : }
     170             : 
     171             : /**
     172             :  * Create a elastic (allocating) memory storage backend. Memory is
     173             :  * allocated on demand. Free returned krb5_storage with
     174             :  * krb5_storage_free().
     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_from_mem()
     181             :  * @sa krb5_storage_from_readonly_mem()
     182             :  * @sa krb5_storage_from_fd()
     183             :  * @sa krb5_storage_from_data()
     184             :  * @sa krb5_storage_from_socket()
     185             :  */
     186             : 
     187             : KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
     188      446700 : krb5_storage_emem(void)
     189             : {
     190       14678 :     krb5_storage *sp;
     191       14678 :     emem_storage *s;
     192             : 
     193      446700 :     sp = malloc(sizeof(krb5_storage));
     194      446700 :     if (sp == NULL)
     195           0 :         return NULL;
     196             : 
     197      446700 :     s = malloc(sizeof(*s));
     198      446700 :     if (s == NULL) {
     199           0 :         free(sp);
     200           0 :         return NULL;
     201             :     }
     202      446700 :     sp->data = s;
     203      446700 :     sp->flags = 0;
     204      446700 :     sp->eof_code = HEIM_ERR_EOF;
     205      446700 :     s->size = 1024;
     206      446700 :     s->base = calloc(1, s->size);
     207      446700 :     if (s->base == NULL) {
     208           0 :         free(sp);
     209           0 :         free(s);
     210           0 :         return NULL;
     211             :     }
     212      446700 :     s->len = 0;
     213      446700 :     s->ptr = s->base;
     214      446700 :     sp->fetch = emem_fetch;
     215      446700 :     sp->store = emem_store;
     216      446700 :     sp->seek = emem_seek;
     217      446700 :     sp->trunc = emem_trunc;
     218      446700 :     sp->fsync = NULL;
     219      446700 :     sp->free = emem_free;
     220      446700 :     sp->max_alloc = UINT32_MAX/64;
     221      446700 :     return sp;
     222             : }