125 lines
4.5 KiB
C
125 lines
4.5 KiB
C
/*
|
|
* Copyright (c) 2012-2013 Spotify AB
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
|
* the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "logheader.h"
|
|
#include "endiantools.h"
|
|
#include "util.h"
|
|
|
|
static char * compression_types[] = { "Uncompressed", "Snappy", NULL };
|
|
|
|
void print_logheader(sparkey_logheader *header) {
|
|
printf("Log file version %d.%d\n", header->major_version,
|
|
header->minor_version);
|
|
printf("Identifier: %08x\n", header->file_identifier);
|
|
printf("Puts: %"PRIu64", Deletes: %"PRIu64"\n", header->num_puts, header->num_deletes);
|
|
printf("Max key size: %"PRIu64", Max value size: %"PRIu64"\n", header->max_key_len, header->max_value_len);
|
|
printf("Compression: %s, block size: %d\n",
|
|
compression_types[header->compression_type],
|
|
header->compression_block_size);
|
|
}
|
|
|
|
static sparkey_returncode logheader_version0(sparkey_logheader *header, FILE *fp) {
|
|
RETHROW(fread_little_endian32(fp, &header->file_identifier));
|
|
RETHROW(fread_little_endian64(fp, &header->num_puts));
|
|
RETHROW(fread_little_endian64(fp, &header->num_deletes));
|
|
RETHROW(fread_little_endian64(fp, &header->data_end));
|
|
RETHROW(fread_little_endian64(fp, &header->max_key_len));
|
|
RETHROW(fread_little_endian64(fp, &header->max_value_len));
|
|
RETHROW(fread_little_endian64(fp, &header->delete_size));
|
|
RETHROW(fread_little_endian32(fp, &header->compression_type));
|
|
RETHROW(fread_little_endian32(fp, &header->compression_block_size));
|
|
RETHROW(fread_little_endian64(fp, &header->put_size));
|
|
RETHROW(fread_little_endian32(fp, &header->max_entries_per_block));
|
|
header->header_size = LOG_HEADER_SIZE;
|
|
|
|
// Some basic consistency checks
|
|
if (header->data_end < header->header_size) {
|
|
return SPARKEY_LOG_HEADER_CORRUPT;
|
|
}
|
|
if (header->num_puts > header->data_end) {
|
|
return SPARKEY_LOG_HEADER_CORRUPT;
|
|
}
|
|
if (header->num_deletes > header->data_end) {
|
|
return SPARKEY_LOG_HEADER_CORRUPT;
|
|
}
|
|
if (header->compression_type > SPARKEY_COMPRESSION_SNAPPY) {
|
|
return SPARKEY_LOG_HEADER_CORRUPT;
|
|
}
|
|
return SPARKEY_SUCCESS;
|
|
}
|
|
|
|
|
|
typedef sparkey_returncode (*loader)(sparkey_logheader *header, FILE *fp);
|
|
|
|
static loader loaders[1] = { logheader_version0 };
|
|
|
|
sparkey_returncode sparkey_load_logheader(sparkey_logheader *header, const char *filename) {
|
|
FILE *fp = fopen(filename, "r");
|
|
if (fp == NULL) {
|
|
return sparkey_open_returncode(errno);
|
|
}
|
|
|
|
uint32_t tmp;
|
|
RETHROW(fread_little_endian32(fp, &tmp));
|
|
if (tmp != LOG_MAGIC_NUMBER) {
|
|
fclose(fp);
|
|
return SPARKEY_WRONG_LOG_MAGIC_NUMBER;
|
|
}
|
|
RETHROW(fread_little_endian32(fp, &header->major_version));
|
|
if (header->major_version != LOG_MAJOR_VERSION) {
|
|
fclose(fp);
|
|
return SPARKEY_WRONG_LOG_MAJOR_VERSION;
|
|
}
|
|
RETHROW(fread_little_endian32(fp, &header->minor_version));
|
|
if (header->minor_version > LOG_MINOR_VERSION) {
|
|
fclose(fp);
|
|
return SPARKEY_UNSUPPORTED_LOG_MINOR_VERSION;
|
|
}
|
|
int version = header->minor_version;
|
|
loader l = loaders[version];
|
|
if (l == NULL) {
|
|
fclose(fp);
|
|
return SPARKEY_INTERNAL_ERROR;
|
|
}
|
|
sparkey_returncode x = (*l)(header, fp);
|
|
fclose(fp);
|
|
return x;
|
|
}
|
|
|
|
sparkey_returncode write_logheader(int fd, sparkey_logheader *header) {
|
|
RETHROW(fwrite_little_endian32(fd, LOG_MAGIC_NUMBER));
|
|
RETHROW(fwrite_little_endian32(fd, LOG_MAJOR_VERSION));
|
|
RETHROW(fwrite_little_endian32(fd, LOG_MINOR_VERSION));
|
|
RETHROW(fwrite_little_endian32(fd, header->file_identifier));
|
|
RETHROW(fwrite_little_endian64(fd, header->num_puts));
|
|
RETHROW(fwrite_little_endian64(fd, header->num_deletes));
|
|
RETHROW(fwrite_little_endian64(fd, header->data_end));
|
|
RETHROW(fwrite_little_endian64(fd, header->max_key_len));
|
|
RETHROW(fwrite_little_endian64(fd, header->max_value_len));
|
|
RETHROW(fwrite_little_endian64(fd, header->delete_size));
|
|
RETHROW(fwrite_little_endian32(fd, header->compression_type));
|
|
RETHROW(fwrite_little_endian32(fd, header->compression_block_size));
|
|
RETHROW(fwrite_little_endian64(fd, header->put_size));
|
|
RETHROW(fwrite_little_endian32(fd, header->max_entries_per_block));
|
|
return SPARKEY_SUCCESS;
|
|
}
|
|
|
|
|