static void
test_truncate(krb5_context context, krb5_storage *sp, int fd)
{
struct stat sb;
krb5_store_string(sp, "hej");
krb5_storage_truncate(sp, 2);
if (fstat(fd, &sb) != 0)
krb5_err(context, 1, errno, "fstat");
if (sb.st_size != 2)
krb5_errx(context, 1, "length not 2");
krb5_storage_truncate(sp, 1024);
if (fstat(fd, &sb) != 0)
krb5_err(context, 1, errno, "fstat");
if (sb.st_size != 1024)
krb5_errx(context, 1, "length not 2");
}
static void
check_too_large(krb5_context context, krb5_storage *sp)
{
uint32_t too_big_sizes[] = { INT_MAX, INT_MAX / 2, INT_MAX / 4, INT_MAX / 8 + 1};
krb5_error_code ret;
krb5_data data;
size_t n;
for (n = 0; n < sizeof(too_big_sizes) / sizeof(too_big_sizes); n++) {
krb5_storage_truncate(sp, 0);
krb5_store_uint32(sp, too_big_sizes[n]);
krb5_storage_seek(sp, 0, SEEK_SET);
ret = krb5_ret_data(sp, &data);
if (ret != HEIM_ERR_TOO_BIG)
errx(1, "not too big: %lu", (unsigned long)n);
}
}
static void
test_int32(krb5_context context, krb5_storage *sp)
{
krb5_error_code ret;
int i;
int32_t val[] = {
0, 1, -1, 2147483647, -2147483646
}, v;
krb5_storage_truncate(sp, 0);
for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
ret = krb5_store_int32(sp, val[i]);
if (ret)
krb5_err(context, 1, ret, "krb5_store_int32");
krb5_storage_seek(sp, 0, SEEK_SET);
ret = krb5_ret_int32(sp, &v);
if (ret)
krb5_err(context, 1, ret, "krb5_ret_int32");
if (v != val[i])
krb5_errx(context, 1, "store and ret mismatch");
}
}
static void
test_uint16(krb5_context context, krb5_storage *sp)
{
krb5_error_code ret;
int i;
uint16_t val[] = {
0, 1, 65535
}, v;
krb5_storage_truncate(sp, 0);
for (i = 0; i < sizeof(val[0])/sizeof(val); i++) {
ret = krb5_store_uint16(sp, val[i]);
if (ret)
krb5_err(context, 1, ret, "krb5_store_uint16");
krb5_storage_seek(sp, 0, SEEK_SET);
ret = krb5_ret_uint16(sp, &v);
if (ret)
krb5_err(context, 1, ret, "krb5_ret_uint16");
if (v != val[i])
krb5_errx(context, 1, "store and ret mismatch");
}
}
static int
write_dump (krb5_context context, krb5_storage *dump,
const char *database, uint32_t current_version)
{
krb5_error_code ret;
krb5_storage *sp;
HDB *db;
krb5_data data;
char buf[8];
/* we assume that the caller has obtained an exclusive lock */
ret = krb5_storage_truncate(dump, 0);
if (ret)
return ret;
if (krb5_storage_seek(dump, 0, SEEK_SET) != 0)
return errno;
/*
* First we store zero as the HDB version, this will indicate to a
* later reader that the dumpfile is invalid. We later write the
* correct version in the file after we have written all of the
* messages. A dump with a zero version will not be considered
* to be valid.
*/
ret = krb5_store_uint32(dump, 0);
ret = hdb_create (context, &db, database);
if (ret)
krb5_err (context, IPROPD_RESTART, ret, "hdb_create: %s", database);
ret = db->hdb_open (context, db, O_RDONLY, 0);
if (ret)
krb5_err (context, IPROPD_RESTART, ret, "db->open");
sp = krb5_storage_from_mem (buf, 4);
if (sp == NULL)
krb5_errx (context, IPROPD_RESTART, "krb5_storage_from_mem");
krb5_store_uint32 (sp, TELL_YOU_EVERYTHING);
krb5_storage_free (sp);
data.data = buf;
data.length = 4;
ret = krb5_store_data(dump, data);
if (ret) {
krb5_warn (context, ret, "write_dump");
return ret;
}
ret = hdb_foreach (context, db, HDB_F_ADMIN_DATA, dump_one, dump);
if (ret) {
krb5_warn (context, ret, "write_dump: hdb_foreach");
return ret;
}
(*db->hdb_close)(context, db);
(*db->hdb_destroy)(context, db);
sp = krb5_storage_from_mem (buf, 8);
if (sp == NULL)
krb5_errx (context, IPROPD_RESTART, "krb5_storage_from_mem");
ret = krb5_store_uint32(sp, NOW_YOU_HAVE);
if (ret == 0)
krb5_store_uint32(sp, current_version);
krb5_storage_free (sp);
data.length = 8;
if (ret == 0)
ret = krb5_store_data(dump, data);
/*
* We must ensure that the entire valid dump is written to disk
* before we write the current version at the front thus making
* it a valid dump file. If we crash around here, this can be
* important upon reboot.
*/
if (ret == 0)
ret = krb5_storage_fsync(dump);
if (ret == 0 && krb5_storage_seek(dump, 0, SEEK_SET) == -1)
ret = errno;
/* Write current version at the front making the dump valid */
if (ret == 0)
ret = krb5_store_uint32(dump, current_version);
/*
* We don't need to fsync(2) after the real version is written as
* it is not a disaster if it doesn't make it to disk if we crash.
* After all, we'll just create a new dumpfile.
*/
if (ret == 0)
krb5_warnx(context, "wrote new dumpfile (version %u)",
current_version);
else
krb5_warn(context, ret, "failed to write new dumpfile (version %u)",
current_version);
return ret;
}
