static bRC setAcl(bpContext *ctx, acl_pkt *ap)
{
int status;
unser_declare;
uint32_t acl_name_length;
uint32_t xattr_value_length;
POOL_MEM xattr_value(PM_MESSAGE),
acl_name(PM_MESSAGE);
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
unser_begin(ap->content, ap->content_length);
while (unser_length(ap->content) < ap->content_length) {
unser_uint32(acl_name_length);
/*
* Decode the ACL name including the \0
*/
acl_name.check_size(acl_name_length);
unser_bytes(acl_name.c_str(), acl_name_length);
unser_uint32(xattr_value_length);
/*
* Decode the actual ACL data as stored as XATTR.
*/
xattr_value.check_size(xattr_value_length);
unser_bytes(xattr_value.c_str(), xattr_value_length);
status = ceph_lsetxattr(p_ctx->cmount, ap->fname, acl_name.c_str(),
xattr_value.c_str(), xattr_value_length, 0);
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_lsetxattr(%s) failed: %s\n", ap->fname, be.bstrerror(-status));
return bRC_Error;
}
}
unser_end(ap->content, ap->content_length);
return bRC_OK;
}
bool decompress_data(JCR *jcr,
const char *last_fname,
int32_t stream,
char **data,
uint32_t *length,
bool want_data_stream)
{
Dmsg1(400, "Stream found in decompress_data(): %d\n", stream);
switch (stream) {
case STREAM_COMPRESSED_DATA:
case STREAM_SPARSE_COMPRESSED_DATA:
case STREAM_WIN32_COMPRESSED_DATA:
case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA: {
uint32_t comp_magic, comp_len;
uint16_t comp_level, comp_version;
/*
* Read compress header
*/
unser_declare;
unser_begin(*data, sizeof(comp_stream_header));
unser_uint32(comp_magic);
unser_uint32(comp_len);
unser_uint16(comp_level);
unser_uint16(comp_version);
unser_end(*data, sizeof(comp_stream_header));
Dmsg4(400, "Compressed data stream found: magic=0x%x, len=%d, level=%d, ver=0x%x\n",
comp_magic, comp_len, comp_level, comp_version);
/*
* Version check
*/
if (comp_version != COMP_HEAD_VERSION) {
Qmsg(jcr, M_ERROR, 0, _("Compressed header version error. version=0x%x\n"), comp_version);
return false;
}
/*
* Size check
*/
if (comp_len + sizeof(comp_stream_header) != *length) {
Qmsg(jcr, M_ERROR, 0, _("Compressed header size error. comp_len=%d, msglen=%d\n"),
comp_len, *length);
return false;
}
/*
* Based on the compression used perform the actual decompression of the data.
*/
switch (comp_magic) {
#ifdef HAVE_LIBZ
case COMPRESS_GZIP:
switch (stream) {
case STREAM_SPARSE_COMPRESSED_DATA:
return decompress_with_zlib(jcr, last_fname, data, length, true, true, want_data_stream);
default:
return decompress_with_zlib(jcr, last_fname, data, length, false, true, want_data_stream);
}
#endif
#ifdef HAVE_LZO
case COMPRESS_LZO1X:
switch (stream) {
case STREAM_SPARSE_COMPRESSED_DATA:
return decompress_with_lzo(jcr, last_fname, data, length, true, want_data_stream);
default:
return decompress_with_lzo(jcr, last_fname, data, length, false, want_data_stream);
}
#endif
#ifdef HAVE_FASTLZ
case COMPRESS_FZFZ:
case COMPRESS_FZ4L:
case COMPRESS_FZ4H:
switch (stream) {
case STREAM_SPARSE_COMPRESSED_DATA:
return decompress_with_fastlz(jcr, last_fname, data, length, comp_magic, true, want_data_stream);
default:
return decompress_with_fastlz(jcr, last_fname, data, length, comp_magic, false, want_data_stream);
}
#endif
default:
Qmsg(jcr, M_ERROR, 0, _("Compression algorithm 0x%x found, but not supported!\n"), comp_magic);
return false;
}
break;
}
default:
#ifdef HAVE_LIBZ
switch (stream) {
case STREAM_SPARSE_GZIP_DATA:
return decompress_with_zlib(jcr, last_fname, data, length, true, false, want_data_stream);
default:
return decompress_with_zlib(jcr, last_fname, data, length, false, false, want_data_stream);
}
#else
Qmsg(jcr, M_ERROR, 0, _("Compression algorithm GZIP found, but not supported!\n"));
return false;
#endif
}
}
struct container* retrieve_container_by_id(containerid id) {
struct container *c = (struct container*) malloc(sizeof(struct container));
init_container_meta(&c->meta);
unsigned char *cur = 0;
if (destor.simulation_level >= SIMULATION_RESTORE) {
c->data = malloc(CONTAINER_META_SIZE);
pthread_mutex_lock(&mutex);
if (destor.simulation_level >= SIMULATION_APPEND)
fseek(fp, id * CONTAINER_META_SIZE + 8, SEEK_SET);
else
fseek(fp, (id + 1) * CONTAINER_SIZE - CONTAINER_META_SIZE + 8,
SEEK_SET);
fread(c->data, CONTAINER_META_SIZE, 1, fp);
pthread_mutex_unlock(&mutex);
cur = c->data;
} else {
c->data = malloc(CONTAINER_SIZE);
pthread_mutex_lock(&mutex);
fseek(fp, id * CONTAINER_SIZE + 8, SEEK_SET);
fread(c->data, CONTAINER_SIZE, 1, fp);
pthread_mutex_unlock(&mutex);
cur = &c->data[CONTAINER_SIZE - CONTAINER_META_SIZE];
}
unser_declare;
unser_begin(cur, CONTAINER_META_SIZE);
unser_int64(c->meta.id);
unser_int32(c->meta.chunk_num);
unser_int32(c->meta.data_size);
if(c->meta.id != id){
WARNING("expect %lld, but read %lld", id, c->meta.id);
assert(c->meta.id == id);
}
int i;
for (i = 0; i < c->meta.chunk_num; i++) {
struct metaEntry* me = (struct metaEntry*) malloc(
sizeof(struct metaEntry));
unser_bytes(&me->fp, sizeof(fingerprint));
unser_bytes(&me->len, sizeof(int32_t));
unser_bytes(&me->off, sizeof(int32_t));
g_hash_table_insert(c->meta.map, &me->fp, me);
}
unser_end(cur, CONTAINER_META_SIZE);
if (destor.simulation_level >= SIMULATION_RESTORE) {
free(c->data);
c->data = 0;
}
return c;
}
