int pr_str2gid(const char *val, gid_t *gid) {
#ifdef HAVE_STRTOULL
unsigned long long ull = 0ULL;
#endif /* HAVE_STRTOULL */
unsigned long ul = 0UL;
if (val == NULL ||
gid == NULL) {
errno = EINVAL;
return -1;
}
#if SIZEOF_GID_T == SIZEOF_LONG_LONG
# ifdef HAVE_STRTOULL
if (parse_ull(val, &ull) < 0) {
return -1;
}
*gid = ull;
# else
if (parse_ul(val, &ul) < 0) {
return -1;
}
*gid = ul;
# endif /* HAVE_STRTOULL */
#else
(void) ull;
if (parse_ul(val, &ul) < 0) {
return -1;
}
*gid = ul;
#endif /* sizeof(gid_t) != sizeof(long long) */
return 0;
}
static ContentItem *parse_hhc(HHInfo *info, IStream *str, ContentItem *hhc_root,
insert_type_t *insert_type)
{
stream_t stream;
strbuf_t node, node_name;
ContentItem *ret = NULL, *prev = NULL;
*insert_type = INSERT_NEXT;
strbuf_init(&node);
strbuf_init(&node_name);
stream_init(&stream, str);
while(next_node(&stream, &node)) {
get_node_name(&node, &node_name);
TRACE("%s\n", node.buf);
if(!strcasecmp(node_name.buf, "ul")) {
ContentItem *item = parse_ul(info, &stream, hhc_root);
prev = insert_item(prev, item, INSERT_CHILD);
if(!ret)
ret = prev;
*insert_type = INSERT_CHILD;
}
strbuf_zero(&node);
}
strbuf_free(&node);
strbuf_free(&node_name);
return ret;
}
static int handle_reconfigure(int argc, char **argv){
int ret, c;
unsigned int minor;
unsigned long cache_size = 0;
//get cache size and fallocated space params, if given
while((c = getopt(argc, argv, "c:")) != -1){
switch(c){
case 'c':
ret = parse_ul(optarg, &cache_size);
if(ret) goto handle_reconfigure_error;
break;
default:
errno = EINVAL;
goto handle_reconfigure_error;
}
}
if(argc - optind != 1){
errno = EINVAL;
goto handle_reconfigure_error;
}
ret = parse_ui(argv[optind], &minor);
if(ret) goto handle_reconfigure_error;
return reconfigure(minor, cache_size);
handle_reconfigure_error:
perror("error interpreting reconfigure parameters");
print_help(-1);
return 0;
}
static int handle_setup_snap(int argc, char **argv){
int ret, c;
unsigned int minor;
unsigned long cache_size = 0, fallocated_space = 0;
char *bdev, *cow;
//get cache size and fallocated space params, if given
while((c = getopt(argc, argv, "c:f:")) != -1){
switch(c){
case 'c':
ret = parse_ul(optarg, &cache_size);
if(ret) goto handle_setup_snap_error;
break;
case 'f':
ret = parse_ul(optarg, &fallocated_space);
if(ret) goto handle_setup_snap_error;
break;
default:
errno = EINVAL;
goto handle_setup_snap_error;
}
}
if(argc - optind != 3){
errno = EINVAL;
goto handle_setup_snap_error;
}
bdev = argv[optind];
cow = argv[optind + 1];
ret = parse_ui(argv[optind + 2], &minor);
if(ret) goto handle_setup_snap_error;
return setup_snapshot(minor, bdev, cow, fallocated_space, cache_size);
handle_setup_snap_error:
perror("error interpreting setup snapshot parameters");
print_help(-1);
return 0;
}
static ContentItem *parse_ul(HHInfo *info, stream_t *stream, ContentItem *hhc_root)
{
strbuf_t node, node_name;
ContentItem *ret = NULL, *prev = NULL, *new_item = NULL;
insert_type_t it;
strbuf_init(&node);
strbuf_init(&node_name);
while(next_node(stream, &node)) {
get_node_name(&node, &node_name);
TRACE("%s\n", node.buf);
if(!strcasecmp(node_name.buf, "object")) {
const char *ptr;
int len;
static const char sz_text_sitemap[] = "text/sitemap";
ptr = get_attr(node.buf, "type", &len);
if(ptr && len == sizeof(sz_text_sitemap)-1
&& !memcmp(ptr, sz_text_sitemap, len)) {
new_item = parse_sitemap_object(info, stream, hhc_root, &it);
prev = insert_item(prev, new_item, it);
if(!ret)
ret = prev;
}
}else if(!strcasecmp(node_name.buf, "ul")) {
new_item = parse_ul(info, stream, hhc_root);
insert_item(prev, new_item, INSERT_CHILD);
}else if(!strcasecmp(node_name.buf, "/ul")) {
break;
}
strbuf_zero(&node);
}
strbuf_free(&node);
strbuf_free(&node_name);
return ret;
}
static int handle_transition_snap(int argc, char **argv){
int ret, c;
unsigned int minor;
unsigned long fallocated_space = 0;
char *cow;
//get cache size and fallocated space params, if given
while((c = getopt(argc, argv, "f:")) != -1){
switch(c){
case 'f':
ret = parse_ul(optarg, &fallocated_space);
if(ret) goto handle_transition_snap_error;
break;
default:
errno = EINVAL;
goto handle_transition_snap_error;
}
}
if(argc - optind != 2){
errno = EINVAL;
goto handle_transition_snap_error;
}
cow = argv[optind];
ret = parse_ui(argv[optind + 1], &minor);
if(ret) goto handle_transition_snap_error;
return transition_snapshot(minor, cow, fallocated_space);
handle_transition_snap_error:
perror("error interpreting transition to snapshot parameters");
print_help(-1);
return 0;
}
bool KHTMLReader::parse_ol(DOM::Element e)
{
return parse_ul(e);
}
static int parse_xml(const char *basedir, xmlNode *root_node, struct ploop_disk_images_data *di)
{
xmlNode *cur_node, *node;
char image[PATH_MAX];
const char *data = NULL;
const char *file = NULL;
const char *guid = NULL;
const char *parent_guid = NULL;
__u64 val;
int is_preallocated = 0;
int mode = PLOOP_EXPANDED_MODE;
int n;
cur_node = seek(root_node, "/Disk_Parameters");
ERR(cur_node, "/Disk_Parameters");
node = seek(cur_node, "Disk_size");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) == 0)
di->size = val;
}
node = seek(cur_node, "Max_delta_size");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) == 0)
di->max_delta_size = val;
}
node = seek(cur_node, "Cylinders");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) == 0)
di->cylinders = (unsigned)val;
}
node = seek(cur_node, "Heads");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) == 0)
di->heads = (unsigned)val;
}
node = seek(cur_node, "Sectors");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) == 0)
di->sectors= (unsigned)val;
}
cur_node = seek(root_node, "/StorageData/Storage");
ERR(cur_node, "/StorageData/Storage");
for (n = 0; cur_node; cur_node = cur_node->next, n++) {
if (cur_node->type != XML_ELEMENT_NODE)
continue;
if (n > 0) {
ploop_err(0, "Invalid disk descriptor file format:"
" splitted disk is not supported");
return -1;
}
node = seek(cur_node, "Blocksize");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val)) {
ploop_err(0, "Invalid disk descriptor file format:"
" Invalid Blocksize %s", data);
return -1;
}
di->blocksize = (unsigned)val;
}
node = seek(cur_node, "Preallocated");
if (node != NULL) {
data = get_element_txt(node);
if (parse_ul(data, &val) != 0 || val > 1) {
ploop_err(0, "Invalid disk descriptor file format:"
" Invalid Preallocated tag");
return -1;
}
is_preallocated = val;
}
}
cur_node = seek(root_node, "/StorageData/Storage/Image");
ERR(cur_node, "/StorageData/Storage/Image");
for (; cur_node; cur_node = cur_node->next) {
if (cur_node->type != XML_ELEMENT_NODE)
continue;
guid = NULL;
node = seek(cur_node, "GUID");
if (node != NULL) {
guid = get_element_txt(node);
if (guid == NULL)
guid = "";
}
ERR(guid, "GUID");
node = seek(cur_node, "Type");
if (node != NULL) {
data = get_element_txt(node);
if (data != NULL && !strcmp(data, "Plain"))
mode = PLOOP_RAW_MODE;
}
file = NULL;
node = seek(cur_node, "File");
if (node != NULL) {
file = get_element_txt(node);
if (file != NULL) {
if (basedir[0] != 0 && file[0] != '/')
snprintf(image, sizeof(image), "%s%s", basedir, file);
else
snprintf(image, sizeof(image), "%s", file);
}
}
ERR(file, "File");
if (ploop_add_image_entry(di, image, guid))
return -1;
}
if (is_preallocated) {
if (mode == PLOOP_RAW_MODE) {
ploop_err(0, "Invalid disk descriptor file format:"
" Preallocated is not compatible with Plain image");
return -1;
}
di->mode = PLOOP_EXPANDED_PREALLOCATED_MODE;
} else {
di->mode = mode;
}
cur_node = seek(root_node, "/Snapshots");
ERR(cur_node, "/Snapshots");
node = seek(cur_node, "TopGUID");
if (node != NULL) {
data = get_element_txt(node);
ERR(data, "TopGUID");
di->top_guid = strdup(data);
}
cur_node = seek(root_node, "/Snapshots/Shot");
if (cur_node != NULL) {
for (; cur_node; cur_node = cur_node->next) {
int temporary = 0;
if (cur_node->type != XML_ELEMENT_NODE)
continue;
guid = NULL;
node = seek(cur_node, "GUID");
if (node != NULL)
guid = get_element_txt(node);
ERR(guid, "Snapshots GUID");
parent_guid = NULL;
node = seek(cur_node, "ParentGUID");
if (node != NULL)
parent_guid = get_element_txt(node);
ERR(parent_guid, "ParentGUID");
node = seek(cur_node, "Temporary");
if (node != NULL)
temporary = 1;
if (ploop_add_snapshot_entry(di, guid, parent_guid, temporary))
return -1;
}
}
return 0;
}
