crypto/dist/heimdal/lib/krb5/test_store.c

   1 /*
   2  * Copyright (c) 2006 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 KTH nor the names of its contributors may be
  18  *    used to endorse or promote products derived from this software without
  19  *    specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  32
  33 #include "krb5_locl.h"
  34 #include <getarg.h>
  35
  36 __RCSID("$Heimdal: test_store.c 20192 2007-02-05 23:21:03Z lha $"
  37         "$NetBSD$");
  38
  39 static void
  40 test_int8(krb5_context context, krb5_storage *sp)
  41 {
  42     krb5_error_code ret;
  43     int i;
  44     int8_t val[] = {
  45         0, 1, -1, 128, -127
  46     }, v;
  47
  48     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
  49
  50         ret = krb5_store_int8(sp, val[i]);
  51         if (ret)
  52             krb5_err(context, 1, ret, "krb5_store_int8");
  53         krb5_storage_seek(sp, 0, SEEK_SET);
  54         ret = krb5_ret_int8(sp, &v);
  55         if (ret)
  56             krb5_err(context, 1, ret, "krb5_ret_int8");
  57         if (v != val[i])
  58             krb5_errx(context, 1, "store and ret mismatch");
  59     }
  60 }
  61
  62 static void
  63 test_int16(krb5_context context, krb5_storage *sp)
  64 {
  65     krb5_error_code ret;
  66     int i;
  67     int16_t val[] = {
  68         0, 1, -1, 32768, -32767
  69     }, v;
  70
  71     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
  72
  73         ret = krb5_store_int16(sp, val[i]);
  74         if (ret)
  75             krb5_err(context, 1, ret, "krb5_store_int16");
  76         krb5_storage_seek(sp, 0, SEEK_SET);
  77         ret = krb5_ret_int16(sp, &v);
  78         if (ret)
  79             krb5_err(context, 1, ret, "krb5_ret_int16");
  80         if (v != val[i])
  81             krb5_errx(context, 1, "store and ret mismatch");
  82     }
  83 }
  84
  85 static void
  86 test_int32(krb5_context context, krb5_storage *sp)
  87 {
  88     krb5_error_code ret;
  89     int i;
  90     int32_t val[] = {
  91         0, 1, -1, 2147483647, -2147483646
  92     }, v;
  93
  94     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
  95
  96         ret = krb5_store_int32(sp, val[i]);
  97         if (ret)
  98             krb5_err(context, 1, ret, "krb5_store_int32");
  99         krb5_storage_seek(sp, 0, SEEK_SET);
 100         ret = krb5_ret_int32(sp, &v);
 101         if (ret)
 102             krb5_err(context, 1, ret, "krb5_ret_int32");
 103         if (v != val[i])
 104             krb5_errx(context, 1, "store and ret mismatch");
 105     }
 106 }
 107
 108 static void
 109 test_uint8(krb5_context context, krb5_storage *sp)
 110 {
 111     krb5_error_code ret;
 112     int i;
 113     uint8_t val[] = {
 114         0, 1, 255
 115     }, v;
 116
 117     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
 118
 119         ret = krb5_store_uint8(sp, val[i]);
 120         if (ret)
 121             krb5_err(context, 1, ret, "krb5_store_uint8");
 122         krb5_storage_seek(sp, 0, SEEK_SET);
 123         ret = krb5_ret_uint8(sp, &v);
 124         if (ret)
 125             krb5_err(context, 1, ret, "krb5_ret_uint8");
 126         if (v != val[i])
 127             krb5_errx(context, 1, "store and ret mismatch");
 128     }
 129 }
 130
 131 static void
 132 test_uint16(krb5_context context, krb5_storage *sp)
 133 {
 134     krb5_error_code ret;
 135     int i;
 136     uint16_t val[] = {
 137         0, 1, 65535
 138     }, v;
 139
 140     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
 141
 142         ret = krb5_store_uint16(sp, val[i]);
 143         if (ret)
 144             krb5_err(context, 1, ret, "krb5_store_uint16");
 145         krb5_storage_seek(sp, 0, SEEK_SET);
 146         ret = krb5_ret_uint16(sp, &v);
 147         if (ret)
 148             krb5_err(context, 1, ret, "krb5_ret_uint16");
 149         if (v != val[i])
 150             krb5_errx(context, 1, "store and ret mismatch");
 151     }
 152 }
 153
 154 static void
 155 test_uint32(krb5_context context, krb5_storage *sp)
 156 {
 157     krb5_error_code ret;
 158     int i;
 159     uint32_t val[] = {
 160         0, 1, 4294967295UL
 161     }, v;
 162
 163     for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
 164
 165         ret = krb5_store_uint32(sp, val[i]);
 166         if (ret)
 167             krb5_err(context, 1, ret, "krb5_store_uint32");
 168         krb5_storage_seek(sp, 0, SEEK_SET);
 169         ret = krb5_ret_uint32(sp, &v);
 170         if (ret)
 171             krb5_err(context, 1, ret, "krb5_ret_uint32");
 172         if (v != val[i])
 173             krb5_errx(context, 1, "store and ret mismatch");
 174     }
 175 }
 176
 177
 178 static void
 179 test_storage(krb5_context context)
 180 {
 181     krb5_storage *sp;
 182
 183     sp = krb5_storage_emem();
 184     if (sp == NULL)
 185         krb5_errx(context, 1, "krb5_storage_emem: no mem");
 186
 187     test_int8(context, sp);
 188     test_int16(context, sp);
 189     test_int32(context, sp);
 190     test_uint8(context, sp);
 191     test_uint16(context, sp);
 192     test_uint32(context, sp);
 193
 194     krb5_storage_free(sp);
 195 }
 196
 197 /*
 198  *
 199  */
 200
 201 static int version_flag = 0;
 202 static int help_flag    = 0;
 203
 204 static struct getargs args[] = {
 205     {"version", 0,      arg_flag,       &version_flag,
 206      "print version", NULL },
 207     {"help",    0,      arg_flag,       &help_flag,
 208      NULL, NULL }
 209 };
 210
 211 static void
 212 usage (int ret)
 213 {
 214     arg_printusage (args,
 215                     sizeof(args)/sizeof(*args),
 216                     NULL,
 217                     "");
 218     exit (ret);
 219 }
 220
 221 int
 222 main(int argc, char **argv)
 223 {
 224     krb5_context context;
 225     krb5_error_code ret;
 226     int optidx = 0;
 227
 228     setprogname(argv[0]);
 229
 230     if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
 231         usage(1);
 232
 233     if (help_flag)
 234         usage (0);
 235
 236     if(version_flag){
 237         print_version(NULL);
 238         exit(0);
 239     }
 240
 241     argc -= optidx;
 242     argv += optidx;
 243
 244     ret = krb5_init_context (&context);
 245     if (ret)
 246         errx (1, "krb5_init_context failed: %d", ret);
 247
 248     test_storage(context);
 249
 250     krb5_free_context(context);
 251
 252     return 0;
 253 }