EXPORT void str_unref (char * str)
#endif
{
if (! str)
return;
pthread_mutex_lock (& mutex);
STR_CHECK (str);
#ifdef STRPOOL_DEBUG
str_log (str, "unref", file, line);
#endif
void * mem = str - 5;
if (! -- (* (int32_t *) mem))
g_hash_table_remove (table, str);
pthread_mutex_unlock (& mutex);
}
EXPORT char * str_ref (char * str)
#endif
{
if (! str)
return NULL;
pthread_mutex_lock (& mutex);
STR_CHECK (str);
#ifdef STRPOOL_DEBUG
str_log (str, "ref", file, line);
#endif
void * mem = str - 5;
(* (int32_t *) mem) ++;
pthread_mutex_unlock (& mutex);
return str;
}
/* basic testing of all RAW_QFS_* calls
for each call we test that it succeeds, and where possible test
for consistency between the calls.
Some of the consistency tests assume that the target filesystem is
quiescent, which is sometimes hard to achieve
*/
bool torture_raw_qfsinfo(struct torture_context *torture,
struct smbcli_state *cli)
{
int i;
bool ret = true;
int count;
union smb_fsinfo *s1, *s2;
/* scan all the levels, pulling the results */
for (i=0; levels[i].name; i++) {
torture_comment(torture, "Running level %s\n", levels[i].name);
levels[i].fsinfo.generic.level = levels[i].level;
levels[i].status = smb_raw_fsinfo(cli->tree, torture, &levels[i].fsinfo);
}
/* check for completely broken levels */
for (count=i=0; levels[i].name; i++) {
uint32_t cap = cli->transport->negotiate.capabilities;
/* see if this server claims to support this level */
if ((cap & levels[i].capability_mask) != levels[i].capability_mask) {
continue;
}
if (!NT_STATUS_IS_OK(levels[i].status)) {
printf("ERROR: level %s failed - %s\n",
levels[i].name, nt_errstr(levels[i].status));
count++;
}
}
if (count != 0) {
torture_comment(torture, "%d levels failed\n", count);
torture_assert(torture, count > 13, "too many level failures - giving up");
}
torture_comment(torture, "check for correct aliases\n");
s1 = find("SIZE_INFO");
s2 = find("SIZE_INFORMATION");
if (s1 && s2) {
VAL_EQUAL(size_info, total_alloc_units, size_info, total_alloc_units);
VAL_APPROX_EQUAL(size_info, avail_alloc_units, size_info, avail_alloc_units);
VAL_EQUAL(size_info, sectors_per_unit, size_info, sectors_per_unit);
VAL_EQUAL(size_info, bytes_per_sector, size_info, bytes_per_sector);
}
s1 = find("DEVICE_INFO");
s2 = find("DEVICE_INFORMATION");
if (s1 && s2) {
VAL_EQUAL(device_info, device_type, device_info, device_type);
VAL_EQUAL(device_info, characteristics, device_info, characteristics);
}
s1 = find("VOLUME_INFO");
s2 = find("VOLUME_INFORMATION");
if (s1 && s2) {
STRUCT_EQUAL(volume_info, create_time, volume_info, create_time);
VAL_EQUAL (volume_info, serial_number, volume_info, serial_number);
STR_EQUAL (volume_info, volume_name.s, volume_info, volume_name.s);
torture_comment(torture, "volume_info.volume_name = '%s'\n", s1->volume_info.out.volume_name.s);
}
s1 = find("ATTRIBUTE_INFO");
s2 = find("ATTRIBUTE_INFORMATION");
if (s1 && s2) {
VAL_EQUAL(attribute_info, fs_attr,
attribute_info, fs_attr);
VAL_EQUAL(attribute_info, max_file_component_length,
attribute_info, max_file_component_length);
STR_EQUAL(attribute_info, fs_type.s, attribute_info, fs_type.s);
torture_comment(torture, "attribute_info.fs_type = '%s'\n", s1->attribute_info.out.fs_type.s);
}
torture_comment(torture, "check for consistent disk sizes\n");
s1 = find("DSKATTR");
s2 = find("ALLOCATION");
if (s1 && s2) {
double size1, size2;
double scale = s1->dskattr.out.blocks_per_unit * s1->dskattr.out.block_size;
size1 = 1.0 *
s1->dskattr.out.units_total *
s1->dskattr.out.blocks_per_unit *
s1->dskattr.out.block_size / scale;
size2 = 1.0 *
s2->allocation.out.sectors_per_unit *
s2->allocation.out.total_alloc_units *
s2->allocation.out.bytes_per_sector / scale;
if (abs(size1 - size2) > 1) {
printf("Inconsistent total size in DSKATTR and ALLOCATION - size1=%.0f size2=%.0f\n",
size1, size2);
ret = false;
}
torture_comment(torture, "total disk = %.0f MB\n", size1*scale/1.0e6);
}
torture_comment(torture, "check consistent free disk space\n");
s1 = find("DSKATTR");
s2 = find("ALLOCATION");
if (s1 && s2) {
double size1, size2;
double scale = s1->dskattr.out.blocks_per_unit * s1->dskattr.out.block_size;
size1 = 1.0 *
s1->dskattr.out.units_free *
s1->dskattr.out.blocks_per_unit *
s1->dskattr.out.block_size / scale;
size2 = 1.0 *
s2->allocation.out.sectors_per_unit *
s2->allocation.out.avail_alloc_units *
s2->allocation.out.bytes_per_sector / scale;
if (abs(size1 - size2) > 1) {
printf("Inconsistent avail size in DSKATTR and ALLOCATION - size1=%.0f size2=%.0f\n",
size1, size2);
ret = false;
}
torture_comment(torture, "free disk = %.0f MB\n", size1*scale/1.0e6);
}
torture_comment(torture, "volume info consistency\n");
s1 = find("VOLUME");
s2 = find("VOLUME_INFO");
if (s1 && s2) {
VAL_EQUAL(volume, serial_number, volume_info, serial_number);
STR_EQUAL(volume, volume_name.s, volume_info, volume_name.s);
}
/* disk size consistency - notice that 'avail_alloc_units' maps to the caller
available allocation units, not the total */
s1 = find("SIZE_INFO");
s2 = find("FULL_SIZE_INFORMATION");
if (s1 && s2) {
VAL_EQUAL(size_info, total_alloc_units, full_size_information, total_alloc_units);
VAL_APPROX_EQUAL(size_info, avail_alloc_units, full_size_information, call_avail_alloc_units);
VAL_EQUAL(size_info, sectors_per_unit, full_size_information, sectors_per_unit);
VAL_EQUAL(size_info, bytes_per_sector, full_size_information, bytes_per_sector);
}
printf("check for non-zero unknown fields\n");
s1 = find("QUOTA_INFORMATION");
if (s1) {
VAL_UNKNOWN(quota_information, unknown[0]);
VAL_UNKNOWN(quota_information, unknown[1]);
VAL_UNKNOWN(quota_information, unknown[2]);
}
s1 = find("OBJECTID_INFORMATION");
if (s1) {
VAL_UNKNOWN(objectid_information, unknown[0]);
VAL_UNKNOWN(objectid_information, unknown[1]);
VAL_UNKNOWN(objectid_information, unknown[2]);
VAL_UNKNOWN(objectid_information, unknown[3]);
VAL_UNKNOWN(objectid_information, unknown[4]);
VAL_UNKNOWN(objectid_information, unknown[5]);
}
#define STR_CHECK(sname, stype, field, flags) do { \
s1 = find(sname); \
if (s1) { \
if (s1->stype.out.field.s && wire_bad_flags(&s1->stype.out.field, flags, cli->transport)) { \
printf("(%d) incorrect string termination in %s/%s\n", \
__LINE__, #stype, #field); \
ret = false; \
} \
}} while (0)
torture_comment(torture, "check for correct termination\n");
STR_CHECK("VOLUME", volume, volume_name, 0);
STR_CHECK("VOLUME_INFO", volume_info, volume_name, STR_UNICODE);
STR_CHECK("VOLUME_INFORMATION", volume_info, volume_name, STR_UNICODE);
STR_CHECK("ATTRIBUTE_INFO", attribute_info, fs_type, STR_UNICODE);
STR_CHECK("ATTRIBUTE_INFORMATION", attribute_info, fs_type, STR_UNICODE);
return ret;
}
static void str_test(void)
{
yp_item_t *scheme;
yp_check_ctx_t *ctx = NULL;
int ret = yp_scheme_copy(&scheme, static_scheme);
ok(ret == KNOT_EOK, "scheme copy");
if (ret != KNOT_EOK) {
goto error_str;
}
ctx = yp_scheme_check_init(scheme);
ok(ctx != NULL, "create check ctx");
if (ctx == NULL) {
goto error_str;
}
yp_node_t *node;
yp_node_t *parent;
const yp_item_t *id;
diag("str key0 test");
STR_CHECK(0, "option", NULL, NULL, "one");
ok(strcmp(node->item->name + 1, "option") == 0, "name check");
ok(node->item->type == YP_TOPT, "type check");
ok(yp_opt(node->data) == 1, "value check");
diag("str group test");
STR_CHECK(0, "group", NULL, NULL, NULL);
ok(strcmp(node->item->name + 1, "group") == 0, "name check");
ok(node->item->type == YP_TGRP, "type check");
ok(node->data_len == 0, "value length check");
STR_CHECK(1, "group", "integer", NULL, "20");
ok(strcmp(node->item->name + 1, "integer") == 0, "name check");
ok(node->item->type == YP_TINT, "type check");
ok(yp_int(node->data) == 20, "value check");
STR_CHECK(1, "group", "string", NULL, "short");
ok(strcmp(node->item->name + 1, "string") == 0, "name check");
ok(node->item->type == YP_TSTR, "type check");
ok(strcmp(yp_str(node->data), "short") == 0, "value check");
STR_CHECK(1, "group", "string", NULL, "long string");
ok(strcmp(node->item->name + 1, "string") == 0, "name check");
ok(node->item->type == YP_TSTR, "type check");
ok(strcmp(yp_str(node->data), "long string") == 0, "value check");
diag("str multi-group test");
STR_CHECK(0, "multi-group", NULL, NULL, NULL);
ok(strcmp(node->item->name + 1, "multi-group") == 0, "name check");
ok(node->item->type == YP_TGRP, "type check");
ok(node->data_len == 0, "value length check");
STR_CHECK(0, "multi-group", NULL, "foo", NULL);
ok(node->id_len > 0, "id check");
ok(strcmp(node->item->name + 1, "multi-group") == 0, "name check");
ok(node->item->type == YP_TGRP, "type check");
ok(node->data_len == 0, "value length check");
id = node->item->var.g.id;
ok(strcmp(id->name + 1, "id") == 0, "name check");
ok(id->type == YP_TSTR, "type check");
ok(strcmp(yp_str(node->id), "foo") == 0, "value check");
STR_CHECK(1, "multi-group", "base64", "foo", "Zm9vYmFy");
id = parent->item->var.g.id;
ok(strcmp(parent->item->name + 1, "multi-group") == 0, "name check");
ok(parent->item->type == YP_TGRP, "type check");
ok(parent->data_len == 0, "value length check");
ok(strcmp(yp_str(parent->id), "foo") == 0, "value check");
ok(strcmp(id->name + 1, "id") == 0, "name check");
ok(id->type == YP_TSTR, "type check");
ok(strcmp(node->item->name + 1, "base64") == 0, "name check");
ok(node->item->type == YP_TB64, "type check");
ok(memcmp(yp_bin(node->data), "foobar", yp_bin_len(node->data)) == 0,
"value check");
ok(node->id_len == 0, "id length check");
STR_CHECK(0, "reference", NULL, NULL, "foo");
ok(strcmp(node->item->name + 1, "reference") == 0, "name check");
ok(node->item->type == YP_TREF, "type check");
ok(strcmp(yp_str(node->data), "foo") == 0, "value check");
diag("str check return");
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, "", "", "", "");
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, NULL, NULL, NULL, NULL);
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, "unknown", NULL, NULL, NULL);
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, NULL, "unknown", NULL, NULL);
STR_RET_CHECK(KNOT_EINVAL, "dname", "", "", "");
STR_RET_CHECK(KNOT_EOK, "dname", NULL, NULL, NULL);
STR_RET_CHECK(KNOT_EOK, "dname", NULL, NULL, ".");
STR_RET_CHECK(KNOT_EINVAL, "dname", NULL, NULL, "..");
STR_RET_CHECK(KNOT_YP_ENOTSUP_ID, "dname", NULL, "id", NULL);
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, "dname", "unknown", NULL, NULL);
STR_RET_CHECK(KNOT_EOK, "group", "", "", "");
STR_RET_CHECK(KNOT_EOK, "group", NULL, NULL, NULL);
STR_RET_CHECK(KNOT_YP_ENOTSUP_DATA, "group", "", "", "data");
STR_RET_CHECK(KNOT_YP_EINVAL_ITEM, "group", "unknown", NULL, NULL);
STR_RET_CHECK(KNOT_EOK, "group", "string", NULL, NULL);
STR_RET_CHECK(KNOT_EOK, "group", "string", NULL, "data");
STR_RET_CHECK(KNOT_EOK, "group", "string", NULL, "");
STR_RET_CHECK(KNOT_YP_ENOTSUP_ID, "group", "", "id", NULL);
STR_RET_CHECK(KNOT_YP_ENOTSUP_ID, "group", "string", "id", NULL);
STR_RET_CHECK(KNOT_EOK, "multi-group", "", "", "");
STR_RET_CHECK(KNOT_EOK, "multi-group", NULL, NULL, NULL);
STR_RET_CHECK(KNOT_YP_ENOTSUP_DATA, "multi-group", NULL, NULL, "data");
STR_RET_CHECK(KNOT_EOK, "multi-group", NULL, "idval", NULL);
STR_RET_CHECK(KNOT_YP_ENOTSUP_DATA, "multi-group", NULL, "idval", "data");
STR_RET_CHECK(KNOT_EOK, "multi-group", "hex", "idval", NULL);
STR_RET_CHECK(KNOT_EOK, "multi-group", "hex", "idval", "data");
STR_RET_CHECK(KNOT_EOK, "multi-group", "hex", NULL, NULL);
STR_RET_CHECK(KNOT_EOK, "multi-group", "hex", NULL, "data");
STR_RET_CHECK(KNOT_EOK, "multi-group", "id", "", NULL);
STR_RET_CHECK(KNOT_EOK, "multi-group", "id", NULL, "idval");
STR_RET_CHECK(KNOT_EOK, "multi-group", "id", "idval", NULL);
STR_RET_CHECK(KNOT_YP_ENOTSUP_DATA, "multi-group", "id", "idval", "data");
error_str:
yp_scheme_check_deinit(ctx);
yp_scheme_free(scheme);
}
