static int tc05(void)
{
int major, pass = 16;
unsigned int i, test_major[2] = {512, UINT_MAX};
prk_info("Test Case 5: register_blkdev() with major=%u/%u\n",
test_major[0], test_major[1]);
for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) {
major = register_blkdev(test_major[i], BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(test_major[i], BLK_DEV_NAME);
#ifdef BLKDEV_MAJOR_MAX
pass = 0;
#endif
} else {
prk_debug("register_blkdev() with major %u got error %i\n",
test_major[i], major);
#ifndef BLKDEV_MAJOR_MAX
pass = 0;
#endif
}
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc01(void)
{
int major1, major2;
int pass = 1;
prk_info("Test Case 1: register_blkdev() with auto allocating "
"major numbers (major=0)\n");
major1 = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major1 = %i\n", major1);
major2 = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major2 = %i\n", major2);
if (major1 >= 0) {
unregister_blkdev(major1, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("1st call to register_blkdev() failed, error %i\n",
major1);
}
if (major2 >= 0) {
unregister_blkdev(major2, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("2nd call to register_blkdev() failed, error %i\n",
major2);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc04(void)
{
int major, pass = 8;
unsigned int i, test_major[2] = {256, 511};
prk_info("Test Case 4: register_blkdev() with major=%u/%u\n",
test_major[0], test_major[1]);
for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) {
major = register_blkdev(test_major[i], BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(test_major[i], BLK_DEV_NAME);
} else if (major == -EBUSY) {
prk_debug("device was busy, register_blkdev() with major %u skipped\n",
test_major[i]);
} else {
pass = 0;
prk_debug("register_blkdev() with major %u got error %i\n",
test_major[i], major);
}
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
Selector* Contextualize::operator()(Selector_Schema* s)
{
To_String to_string;
string result_str(s->contents()->perform(eval->with(env, backtrace))->perform(&to_string));
result_str += '{'; // the parser looks for a brace to end the selector
Selector* result_sel = Parser::from_c_str(result_str.c_str(), ctx, s->path(), s->position()).parse_selector_group();
return result_sel->perform(this);
}
Selector* Contextualize_Eval::operator()(Selector_Schema* s)
{
To_String to_string;
string result_str(s->contents()->perform(eval)->perform(&to_string));
result_str += '{'; // the parser looks for a brace to end the selector
Selector* result_sel = Parser::from_c_str(result_str.c_str(), ctx, s->pstate()).parse_selector_group();
return result_sel->perform(this);
}
std::string __convert_py_to_string(PyObject* py_str) {
Py_ssize_t str_len = PyString_Size(py_str);
char* c_str = new char[str_len+1];
memset(c_str, 0, str_len+1);
strcpy_s(c_str, str_len+1, PyString_AsString(py_str));
std::string result_str(c_str);
return result_str;
}
std::string conv_str(std::string src_str,
const char* to_code,
const char* from_code)
{
std::string result_str("");
if (src_str.length() == 0)
return result_str;
iconv_t cd = iconv_open(to_code, from_code);
if (cd == (iconv_t)(-1)) {
perror("iconv_open");
return result_str;
}
char* src = (char*)src_str.data();
size_t src_len = src_str.length();
size_t dest_len = (src_len * 4) + 1;
#if USE_SHARED_ARRAY
boost::shared_array<char> dest_buffer = boost::shared_array<char> (new char[dest_len]);
char* dest = dest_buffer.get();
memset(dest, 0, dest_len * sizeof(char));
#else
char* dest = (char*) calloc(dest_len, sizeof(char));
#endif
char* saved_dest = dest; // save start pointer of dest buffer
#if TEST_MODE
puts(src);
printf("length of src = %d\n", src_len);
printf("length of dest = %d\n", dest_len);
#endif
if (iconv(cd, &src, &src_len, &dest, &dest_len) == -1) {
printf("failed to iconv errno:%d EILSEQ:%d\n", errno, EILSEQ);
return result_str;
}
#if TEST_MODE
for (int i = 0; i < dest_len; i ++)
printf("dest[%d] = %d\n", i, saved_dest[i]);
printf("dest = [%s]\n", saved_dest);
printf("length of dest = %d\n", dest_len);
#endif
iconv_close(cd);
return std::string(saved_dest);
}
static int tc03(void)
{
int major, major2, major3;
int pass = 4;
prk_info("Test Case 3: register_blkdev() with major != 0\n");
/* autosearch for a free major number */
major = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major > 0) {
unregister_blkdev(major, BLK_DEV_NAME);
/* expected to return 0 */
major2 = register_blkdev(major, BLK_DEV_NAME);
/* this call has to fail with EBUSY return value */
major3 = register_blkdev(major, BLK_DEV_NAME);
if (major2 == 0) {
unregister_blkdev(major, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("1st call to register_blkdev() with major=%i "
"failed with error %i\n", major, major2);
}
if (major3 == 0) {
unregister_blkdev(major, BLK_DEV_NAME);
pass = 0;
} else {
if (major3 != -EBUSY)
pass = 0;
prk_debug("2nd call to register_blkdev() with major=%i "
"failed with error %i\n", major, major3);
}
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc06(void)
{
int major, pass = 32;
prk_info("Test Case 6: register_blkdev() with name=\"\"\n");
major = register_blkdev(0, "");
prk_debug("major = %i\n", major);
if (major >= 0) {
unregister_blkdev(major, "");
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc04(void)
{
int major, pass = 8;
prk_info("Test Case 4: register_blkdev() with major=256\n");
major = register_blkdev(256, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(256, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc08(void)
{
int major, pass = 128;
prk_info("Test Case 8: register_blkdev() with name=NULL\n");
/* should fail with -EINVAL */
major = register_blkdev(0, NULL);
prk_debug("major = %i\n", major);
if (major >= 0) {
unregister_blkdev(major, NULL);
pass = 0;
} else {
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc05(void)
{
int major, pass = 16;
prk_info("Test Case 5: register_blkdev() with major=%u\n", UINT_MAX);
major = register_blkdev(UINT_MAX, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(UINT_MAX, BLK_DEV_NAME);
} else {
prk_debug("reg blkdev with major %d failed with error %i\n",
UINT_MAX, major);
pass = 0;
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc09(void)
{
int major, pass = 256;
prk_info("Test Case 9: unregister_blkdev() with name=NULL\n");
major = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major >= 0) {
/* kernel should silently ignore this */
unregister_blkdev(major, NULL);
unregister_blkdev(major, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc07(void)
{
int major, pass = 64;
prk_info("Test Case 7: unregister_blkdev() with major=0\n");
major = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major >= 0) {
prk_debug("calling unregister_blkdev() with major=0\n");
unregister_blkdev(0, BLK_DEV_NAME);
prk_debug("calling unregister_blkdev() with major=%i\n", major);
unregister_blkdev(major, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc02(void)
{
int major[MAX_MAJOR + 1];
int i, pass = 2;
/* Try to allocate block devices until all major numbers are used.
* After this register_blkdev() should return -EBUSY
*/
prk_info("Test Case 2: stress test of register_blkdev() "
"with auto allocating major numbers (major=0)\n");
memset(major, 0, sizeof(major));
for (i = 0; i < sizeof(major) / sizeof(*major); ++i) {
major[i] = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major[%i] = %i\n", i, major[i]);
if (major[i] == -EBUSY) {
prk_info("device is busy, register_blkdev() ret %i\n",
major[i]);
} else if (major[i] < 0) {
prk_debug("register_blkdev() failed with error %i\n",
major[i]);
pass = 0;
}
}
for (i = 0; i < sizeof(major) / sizeof(*major); ++i) {
if (major[i] >= 0)
unregister_blkdev(major[i], BLK_DEV_NAME);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static void wpa_supplicant_eapol_cb(struct eapol_sm *eapol,
enum eapol_supp_result result,
void *ctx)
{
struct wpa_supplicant *wpa_s = ctx;
int res, pmk_len;
u8 pmk[PMK_LEN];
wpa_printf(MSG_DEBUG, "EAPOL authentication completed - result=%s",
result_str(result));
if (wpas_wps_eapol_cb(wpa_s) > 0)
return;
wpa_s->eap_expected_failure = result ==
EAPOL_SUPP_RESULT_EXPECTED_FAILURE;
if (result != EAPOL_SUPP_RESULT_SUCCESS) {
/*
* Make sure we do not get stuck here waiting for long EAPOL
* timeout if the AP does not disconnect in case of
* authentication failure.
*/
wpa_supplicant_req_auth_timeout(wpa_s, 2, 0);
} else {
ieee802_1x_notify_create_actor(wpa_s, wpa_s->last_eapol_src);
}
if (result != EAPOL_SUPP_RESULT_SUCCESS ||
!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
return;
if (!wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt))
return;
wpa_printf(MSG_DEBUG, "Configure PMK for driver-based RSN 4-way "
"handshake");
pmk_len = PMK_LEN;
if (wpa_key_mgmt_ft(wpa_s->key_mgmt)) {
#ifdef CONFIG_IEEE80211R
u8 buf[2 * PMK_LEN];
wpa_printf(MSG_DEBUG, "RSN: Use FT XXKey as PMK for "
"driver-based 4-way hs and FT");
res = eapol_sm_get_key(eapol, buf, 2 * PMK_LEN);
if (res == 0) {
os_memcpy(pmk, buf + PMK_LEN, PMK_LEN);
os_memset(buf, 0, sizeof(buf));
}
#else /* CONFIG_IEEE80211R */
res = -1;
#endif /* CONFIG_IEEE80211R */
} else {
res = eapol_sm_get_key(eapol, pmk, PMK_LEN);
if (res) {
/*
* EAP-LEAP is an exception from other EAP methods: it
* uses only 16-byte PMK.
*/
res = eapol_sm_get_key(eapol, pmk, 16);
pmk_len = 16;
}
}
if (res) {
wpa_printf(MSG_DEBUG, "Failed to get PMK from EAPOL state "
"machines");
return;
}
wpa_hexdump_key(MSG_DEBUG, "RSN: Configure PMK for driver-based 4-way "
"handshake", pmk, pmk_len);
if (wpa_drv_set_key(wpa_s, WPA_ALG_PMK, NULL, 0, 0, NULL, 0, pmk,
pmk_len)) {
wpa_printf(MSG_DEBUG, "Failed to set PMK to the driver");
}
wpa_supplicant_cancel_scan(wpa_s);
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
}
