static void test_fingerprint(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* both server & client with cert */
str_check(create_worker(&server, true, SERVER1, CA2,
"verify-client=1",
"peer-sha1=ssl/ca2_client2.crt.sha1",
"peer-sha256=ssl/ca2_client2.crt.sha256",
NULL), "OK");
str_check(create_worker(&client, false, CLIENT2, CA1,
"host=server1.com",
"peer-sha1=ssl/ca1_server1.crt.sha1",
"peer-sha256=ssl/ca1_server1.crt.sha256",
NULL), "OK");
str_check(run_case(client, server), "OK");
/* client without cert */
str_check(create_worker(&server, true, SERVER1, CA1,
"verify-client=1",
"peer-sha1=ssl/ca2_client2.crt.sha1",
"peer-sha256=ssl/ca2_client2.crt.sha256",
NULL), "OK");
str_check(create_worker(&client, false, CA1, "host=server1.com", NULL), "OK");
str_any2(run_case(client, server),
"C:sslv3 alert handshake failure - S:peer did not return a certificate",
"C:sslv3 alert handshake failure,C:shutdown while in init - S:peer did not return a certificate");
end:;
}
static const char *run_case(struct Worker *client, struct Worker *server)
{
struct event_base *base = NULL;
int spair[2];
const char *res = "huh";
bool done = false;
ignore_sigpipe();
base = event_init();
client->evbase = base;
server->evbase = base;
tt_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, spair) == 0);
tt_assert(socket_setup(spair[0], true));
tt_assert(socket_setup(spair[1], true));
str_check(start_worker(client, spair[1]), "OK");
str_check(start_worker(server, spair[0]), "OK");
while (client->ctx || server->ctx)
tt_assert(event_base_loop(base, EVLOOP_ONCE) == 0);
done = true;
end:
res = check_errors(client, server);
free_worker(client);
free_worker(server);
event_base_free(base);
return done ? res : "fail";
}
static void hdl_nrecv(void)
{
int8 num = VAL_NONE;
int32 maxlen;
if(atci.poll == POLL_MODE_NONE) RESP_CR(RET_DISABLED);
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_EQUAL;
if(atci.tcmd.sign == CMD_SIGN_QUEST) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
if(atci.tcmd.arg2[0] == 0) maxlen = WORK_BUF_SIZE; // 사이즈 지정안되면 최대값으로 지정
else if(str_check(isdigit, atci.tcmd.arg2) != RET_OK) RESP_CDR(RET_WRONG_ARG, 2);
else if((maxlen = atoi((char*)atci.tcmd.arg2)) < 1 || maxlen > WORK_BUF_SIZE)
RESP_CDR(RET_RANGE_OUT, 2);
CMD_CLEAR();
act_nrecv(num, maxlen);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_mset(void)
{
int8 echo, poll, num = -1; //, mode, country
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST; // [?] 구현
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 4)) RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mset_q(num);
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 4)) RESP_CDR(RET_RANGE_OUT, 1);
if(num == 1) {
if(CMP_CHAR_2(atci.tcmd.arg2, 'E', 'D')) RESP_CDR(RET_WRONG_ARG, 2);
echo = atci.tcmd.arg2[0];
CMD_CLEAR();
act_mset_a(echo, 0, 0, 0);
} else if(num == 2) {
RESP_CDR(RET_NOT_ALLOWED, 2); // 아직 정해진 것 없음
} else if(num == 3) {
if(CMP_CHAR_3(atci.tcmd.arg2, 'F', 'S', 'D')) RESP_CDR(RET_WRONG_ARG, 2);
poll = atci.tcmd.arg2[0];
CMD_CLEAR();
act_mset_a(0, 0, poll, 0);
} else RESP_CDR(RET_NOT_ALLOWED, 2); // 국가 설정 아직 구현안함
} else RESP_CDR(RET_WRONG_ARG, 1);
}
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
num = 0;
if(atci.tcmd.arg1[0] != 0) {
num++;
if(CMP_CHAR_2(atci.tcmd.arg1, 'E', 'D')) RESP_CDR(RET_WRONG_ARG, 1);
}
if(atci.tcmd.arg3[0] != 0) {
num++;
if(CMP_CHAR_3(atci.tcmd.arg3, 'F', 'S', 'D')) RESP_CDR(RET_WRONG_ARG, 3);
}
// arg 2, 4 는 일단 무시
if(num == 0) RESP_CR(RET_NOT_ALLOWED);
echo = atci.tcmd.arg1[0];
poll = atci.tcmd.arg3[0];
CMD_CLEAR();
act_mset_a(echo, 0, poll, 0);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void test_set_mem(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* both server & client with cert */
str_check(create_worker(&server, true, "mem=1", SERVER1, CA2, NULL), "OK");
str_check(create_worker(&client, false, "mem=1", CLIENT2, CA1, "host=server1.com", NULL), "OK");
str_check(run_case(client, server), "OK");
end:;
}
static void test_time(void *_)
{
//str_check(run_time("U:1401010215Z"), "2014-01-01 02:15:00 GMT");
str_check(run_time("U:140101021500Z"), "2014-01-01 02:15:00 GMT");
//str_check(run_time("U:1401010215"), "2014-01-01 02:15:00 GMT");
//str_check(run_time("U:140101021500"), "2014-01-01 02:15:00 GMT");
str_check(run_time("U:14010102150"), "Invalid asn1 time");
str_check(run_time("U:"), "Invalid asn1 time");
str_check(run_time("X:"), "Invalid time object type: 88");
str_check(run_time("G:20140101021544Z"), "2014-01-01 02:15:44 GMT");
end:;
}
static void test_strlcat(void *ptr)
{
char buf[128];
str_check(run_strlcat(buf, "", 16, 3), "PFX");
str_check(run_strlcat(buf, "abc", 16, 6), "PFXabc");
str_check(run_strlcat(buf, "abc", 7, 6), "PFXabc");
str_check(run_strlcat(buf, "abc", 6, 6), "PFXab");
str_check(run_strlcat(buf, "abc", 5, 6), "PFXa");
str_check(run_strlcat(buf, "abc", 4, 6), "PFX");
str_check(run_strlcat(buf, "abc", 3, 6), "PFX");
str_check(run_strlcat(buf, "abc", 2, 5), "PFX");
str_check(run_strlcat(buf, "abc", 1, 4), "PFX");
str_check(run_strlcat(buf, "abc", 0, 3), "PFX");
end:;
}
int check_arg(char *str)
{
if (str[0] == '/' || str[0] == '.')
return (1);
else if ((str_check(str, "cd") == 1))
return (2);
else if ((str_check(str, "setenv")) == 1)
return (2);
else if ((str_check(str, "unsetenv")) == 1)
return (2);
else if ((str_check(str, "env")) == 1)
return (2);
else
return (0);
}
static void test_cipher_nego(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* server key is EC:secp384r1 - ECDHE-ECDSA */
str_check(create_worker(&server, true, "show=ciphers", SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA1,
"ciphers=AESGCM",
"host=server1.com",
NULL), "OK");
str_any3(run_case(client, server),
"TLSv1.2/ECDHE-ECDSA-AES256-GCM-SHA384/ECDH=secp384r1",
"TLSv1.2/ECDHE-ECDSA-AES256-GCM-SHA384/ECDH=X25519",
"TLSv1.2/ECDHE-ECDSA-AES256-GCM-SHA384");
/* server key is RSA - ECDHE-RSA */
str_check(create_worker(&server, true, "show=ciphers", SERVER2, NULL), "OK");
str_check(create_worker(&client, false, CA2,
"ciphers=AESGCM",
"host=server2.com",
NULL), "OK");
str_any3(run_case(client, server),
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384/ECDH=prime256v1",
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384/ECDH=X25519",
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384");
/* server key is RSA - DHE-RSA */
str_check(create_worker(&server, true, SERVER2,
"show=ciphers",
"dheparams=auto",
NULL), "OK");
str_check(create_worker(&client, false, CA2,
"ciphers=EDH+AESGCM",
"host=server2.com",
NULL), "OK");
str_check(run_case(client, server), "TLSv1.2/DHE-RSA-AES256-GCM-SHA384/DH=2048");
/* server key is RSA - ECDHE-RSA */
str_check(create_worker(&server, true, SERVER2,
"show=ciphers",
NULL), "OK");
str_check(create_worker(&client, false, CA2,
"ciphers=EECDH+AES",
"host=server2.com",
NULL), "OK");
str_any3(run_case(client, server),
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384/ECDH=prime256v1",
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384/ECDH=X25519",
"TLSv1.2/ECDHE-RSA-AES256-GCM-SHA384");
end:;
}
/**
* Check a string is right IP Address, and if right, copy the address to the 'ip' variable as array.
*
* @param str The string to investigate if it is right IP Address.
* @param ip The array pointer in which the address will enter when it is right IP address.
* @return RET_OK: This is right IP Address.
* @return RET_NOK: This is not IP Address.
*/
int8_t ip_check(int8_t *str, uint8_t *ip)
{
uint8_t cnt=0;
int8_t tmp[16], *split;
int32_t digit, sumchk = 0;
digit = strlen((char*)str);
if(digit > 15 || digit < 7) {
return RET_NOK;
}
strcpy((char*)tmp, (char*)str);
split = (int8_t*)strtok((char*)tmp, ".");
while(split != NULL && str_check(isdigit, split) == RET_OK) {
digit = atoi((char*)split);
if(digit > 255 || digit < 0) return RET_NOK;
if(ip) ip[cnt] = digit;
sumchk += digit;
cnt++;
split = (int8_t*)strtok(NULL, ".");
}
if(cnt != 4 || sumchk == 0) { //printf("not 4 digit (%d)\r\n", cnt);
return RET_NOK;
}
return RET_OK;
}
static int8 mn_loopback(menu_ctrl mctrl, int8 *mbuf)
{
if(mctrl == MC_START) {
if(lb_tcp || lb_udp) {
printf("Turning off (%s) Loopback\r\n", lb_tcp?"TCP":"UDP");
lb_tcp = lb_udp = FALSE;
return RET_OK;
} else printf("Enter the number [1: TCP, 2: UDP]\r\n");
} else if(mctrl == MC_END) {
} else if(mctrl == MC_DATA) {
if(str_check(isdigit, mbuf) == RET_OK) {
uint8 input = atoi((char*)mbuf);
if(input == 1) lb_tcp = TRUE;
else if(input == 2) lb_udp = TRUE;
else printf("Enter the number [1: TCP, 2: UDP]\r\n");
if(lb_tcp || lb_udp) {
printf("Turning on (%s) Loopback\r\n", lb_tcp?"TCP":"UDP");
return RET_OK;
}
} else {
printf("It is not digit(%s) - Please try again\r\n", mbuf);
}
}
return RET_NOK;
}
/**
* Check a string is right MAC Address, and if right, copy the address to the 'mac' variable as array.
*
* @param str The string to investigate if it is right MAC Address.
* @param mac The array pointer in which the address will enter when it is right MAC address.
* @return RET_OK: This is right MAC Address.
* @return RET_NOK: This is not MAC Address.
*/
int8_t mac_check(int8_t *str, uint8_t *mac)
{
uint8_t cnt=0;
int8_t tmp[18], *split;
int32_t digit;
if(strlen((char*)str) != 17) {
return RET_NOK;
}
strcpy((char*)tmp, (char*)str);
split = (int8_t*)strtok((char*)tmp, ":");
while(split != NULL && str_check(isxdigit, split) == RET_OK) {
digit = strtol((char*)split, NULL, 16);
if(digit > 255 || digit < 0) return RET_NOK;
if(mac) mac[cnt] = digit;
cnt++;
split = (int8_t*)strtok(NULL, ":");
}
if(cnt != 6) { //printf("not 6 digit (%d)\r\n", cnt);
return RET_NOK;
}
return RET_OK;
}
static int8 mn_set_led(menu_ctrl mctrl, int8 *mbuf)
{
if(mctrl == MC_START) {
printf("Enter the number [1: ON, 2: OFF]\r\n");
} else if(mctrl == MC_END) {
} else if(mctrl == MC_DATA) {
if(str_check(isdigit, mbuf) == RET_OK) {
uint8 input = atoi((char*)mbuf);
if(input == 1) {
wizpf_led_set(WIZ_LED1, VAL_ON);
wizpf_led_set(WIZ_LED2, VAL_ON);
printf("LED On\r\n");
} else if(input == 2) {
wizpf_led_set(WIZ_LED1, VAL_OFF);
wizpf_led_set(WIZ_LED2, VAL_OFF);
printf("LED Off\r\n");
} else {
printf("wrong number(%d) - try again\r\n", input);
return RET_NOK;
}
return RET_OK;
} else {
printf("not digit(%s) - try again\r\n", mbuf);
return RET_NOK;
}
}
return RET_NOK;
}
static
int str_check_t(void)
{
int i, res, rc = 0;
char allchars[128];
struct test {
const char *str;
int allowed;
int res;
} T[] = {
{ NULL, 0, 1 },
{ NULL, ~0, 1 },
{ "", 0, 1 },
{ "", ~0, 1 },
{ "0123456789abcd", CC_ALNUM, 1 },
{ "0123456789abcd", CC_ALPHA, 0 },
{ "abcdefghijklmn", CC_ALPHA, 1 },
{ allchars, CC_ASCII, 1 },
{ " \t \t \t \t ", CC_BLANK, 1 },
{ " \t \t\v\t \t ", CC_BLANK, 0 },
{ "01234567891234", CC_DIGIT, 1 },
{ "0123456789abcd", CC_DIGIT, 0 },
{ "abcdefghijklmn", CC_LOWER, 1 },
{ "!\"#$%&'()*+,,", CC_PUNCT, 1 },
{ "/:;<=>?@[\\]^_", CC_PUNCT, 1 },
{ "`{|}~", CC_PUNCT, 1 },
{ "/:;<=>a@[\\]^_", CC_PUNCT, 0 },
{ " \t \t \t \t ", CC_SPACE, 1 },
{ "\t\t\t\t\t\t\t", CC_SPACE, 1 },
{ "\t\t\taa\t\t\t", CC_SPACE, 0 },
{ "abcdefghijklmn", CC_UPPER, 0 },
{ "aBcdefgHijklmn", CC_UPPER, 0 },
{ "ABCDEFGHIJKLMN", CC_UPPER, 1 },
{ "024A6789ABCDEF", CC_XDIGIT, 1 },
{ "024A6789ABCDEG", CC_XDIGIT, 0 },
{ "0x4A6789ABCDEF", CC_XDIGIT, 0 },
{ allchars, 0, 0 },
{ allchars, ~0, 1 },
};
int TS = sizeof(T) / sizeof(T[0]);
for (i = 0; i < 127; i++)
allchars[i] = i + 1;
allchars[127] = 0;
for (i = 0; i < TS; i++) {
res = str_check(T[i].str, T[i].allowed);
if (res != T[i].res)
rc += log_error("[%s/%02d] E[%d] R[%d]",
__FUNCTION__, i,
T[i].res, res);
}
return rc;
}
static void test_strlcpy(void *ptr)
{
char buf[128];
str_check(run_strlcpy(buf, "", 16, 0), "");
str_check(run_strlcpy(buf, "", 0, 0), "XXX");
str_check(run_strlcpy(buf, "", 16, 0), "");
str_check(run_strlcpy(buf, "abc", 16, 3), "abc");
str_check(run_strlcpy(buf, "abc", 4, 3), "abc");
str_check(run_strlcpy(buf, "abc", 3, 3), "ab");
str_check(run_strlcpy(buf, "abc", 2, 3), "a");
str_check(run_strlcpy(buf, "abc", 1, 3), "");
str_check(run_strlcpy(buf, "abc", 0, 3), "XXX");
end:;
}
static void test_basename(void *p)
{
str_check(run_basename("/usr/lib"), "lib");
str_check(run_basename("/usr/"), "usr");
str_check(run_basename("/"), "/");
str_check(run_basename("///"), "/");
str_check(run_basename("//usr//lib//"), "lib");
str_check(run_basename(""), ".");
str_check(run_basename("a/"), "a");
str_check(run_basename(NULL), ".");
end:;
}
static void hdl_nsend(void)
{
int8 num = -1;
int32 ret;
uint8 *dip = NULL;
uint16 *dport = NULL;
if(atci.tcmd.sign == CMD_SIGN_NONE) RESP_CR(RET_WRONG_SIGN);
if(atci.tcmd.sign == CMD_SIGN_QUEST) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
if(str_check(isdigit, atci.tcmd.arg2) != RET_OK ||
(atci.sendlen = atoi((char*)atci.tcmd.arg2)) < 1 ||
atci.sendlen > WORK_BUF_SIZE) RESP_CDR(RET_RANGE_OUT, 2);
if(atci.tcmd.arg3[0]) {
if(ip_check(atci.tcmd.arg3, atci.sendip) == RET_OK) dip = atci.sendip;
else RESP_CDR(RET_WRONG_ARG, 3);
}
if(atci.tcmd.arg4[0]) {
if(port_check(atci.tcmd.arg4, &atci.sendport)==RET_OK) dport = &atci.sendport;
else RESP_CDR(RET_WRONG_ARG, 4);
}
CHK_ARG_LEN(atci.tcmd.arg5, 0, 5);
CHK_ARG_LEN(atci.tcmd.arg6, 0, 6);
CMD_CLEAR();
ret = act_nsend_chk(num, &atci.sendlen, dip, dport);
if(ret != RET_OK) return;
atci.sendsock = num; // 유효성 검사가 완료되면 SEND모드로 전환
atci.worklen = 0;
cmd_resp(RET_ASYNC, num);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void test_fingerprint(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* both server & client with cert */
str_check(create_worker(&server, true, SERVER1, CA2,
"peer-sha1=ssl/ca2_client2.crt.sha1",
"peer-sha256=ssl/ca2_client2.crt.sha256",
NULL), "OK");
str_check(create_worker(&client, false, CLIENT2, CA1,
"host=server1.com",
"peer-sha1=ssl/ca1_server1.crt.sha1",
"peer-sha256=ssl/ca1_server1.crt.sha256",
NULL), "OK");
str_check(run_case(client, server), "OK");
/* client without cert */
str_check(create_worker(&server, true, SERVER1, CA1,
"peer-sha1=ssl/ca2_client2.crt.sha1",
"peer-sha256=ssl/ca2_client2.crt.sha256",
NULL), "OK");
str_check(create_worker(&client, false, CA1, "host=server1.com", NULL), "OK");
str_check(run_case(client, server), "C:write!=3 - S:FP-sha1-fail");
end:;
}
static void test_cert_info(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* server shows client cert */
str_check(create_worker(&server, true, "show=peer-cert", SERVER1, CA2,
"peer-sha1=ssl/ca2_client2.crt.sha1",
"peer-sha256=ssl/ca2_client2.crt.sha256",
"verify-client=1",
NULL), "OK");
str_check(create_worker(&client, false, CLIENT2, CA1,
"host=server1.com",
"peer-sha1=ssl/ca1_server1.crt.sha1",
"peer-sha256=ssl/ca1_server1.crt.sha256",
NULL), "OK");
str_check(run_case(client, server),
"Subject: /CN=client2/C=XX/ST=State2/L=City2/O=Org2"
" Issuer: /CN=TestCA2"
" Serial: 1387724136048036785122419970010419099185643835502"
" NotBefore: 2010-01-01T08:05:00Z"
" NotAfter: 2060-12-31T23:55:00Z");
/* client shows server cert - utf8 */
str_check(create_worker(&server, true, COMPLEX1, NULL), "OK");
str_check(create_worker(&client, false, CA1, "show=peer-cert", "host=complex1.com", NULL), "OK");
str_check(run_case(client, server),
"Subject: /CN=complex1.com/ST=様々な論争を引き起こしてきた。/L=Kõzzä"
" Issuer: /CN=TestCA1/C=AA/ST=State1/L=City1/O=Org1"
" Serial: 1113692385315072860785465640275941003895485612482"
" NotBefore: 2010-01-01T08:05:00Z"
" NotAfter: 2060-12-31T23:55:00Z");
/* client shows server cert - t61/bmp */
str_check(create_worker(&server, true, COMPLEX2, NULL), "OK");
str_check(create_worker(&client, false, CA2, "show=peer-cert", "host=complex2.com", NULL), "OK");
str_check(run_case(client, server),
"Subject: /CN=complex2.com/ST=様々な論争を引き起こしてきた。/L=Kõzzä"
" Issuer: /CN=TestCA2"
" Serial: 344032136906054686761742495217219742691739762030"
" NotBefore: 2010-01-01T08:05:00Z"
" NotAfter: 2060-12-31T23:55:00Z");
end:;
}
static void test_wlist(void *p)
{
str_check(wlist("1,2,3"), "1,2,3");
str_check(wlist(" 1 , \n 2 \t , \t3"), "1,2,3");
str_check(wlist(" 1 "), "1");
str_check(wlist(" 1 ,"), "1");
str_check(wlist(", 1 "), "1");
str_check(wlist("1 2"), "1 2");
str_check(wlist(" "), "");
end:;
}
static void test_mdict(void *p)
{
struct MDict *d;
struct MBuf buf;
const char *s;
d = mdict_new(NULL);
str_check(xget(d, "key"), "NULL");
int_check(mdict_put(d, "key", "val"), 1);
int_check(mdict_put(d, "key2", "foo"), 1);
int_check(mdict_put(d, "key2", ""), 1);
int_check(mdict_put(d, "key3", NULL), 1);
int_check(mdict_put(d, "key4", "v1"), 1);
int_check(mdict_del(d, "key4"), 1);
str_check(xget(d, "key"), "val");
str_check(xget(d, "key2"), "");
str_check(xget(d, "key3"), "NULL");
str_check(xget(d, "key4"), "NULL");
str_check(xget(d, "key5"), "NULL");
int_check(mdict_del(d, "key5"), 0);
mbuf_init_dynamic(&buf);
int_check(mdict_urlencode(d, &buf), 1);
int_check(mbuf_write_byte(&buf, 0), 1);
str_check(mbuf_data(&buf), "key=val&key2=&key3");
mbuf_free(&buf);
mdict_free(d);
d = mdict_new(NULL);
s = "key=val&key2=&key3";
int_check(mdict_urldecode(d, s, strlen(s)), 1);
str_check(xget(d, "key"), "val");
str_check(xget(d, "key2"), "");
str_check(xget(d, "key3"), "NULL");
mdict_free(d);
end:;
}
char *get_my_env(t_array *array)
{
int i;
char *tmp;
i = 0;
while (array->indice[i] != NULL)
{
if (str_check(array->indice[i], "PATH") == 1)
{
tmp = my_strdup(array->line[i]);
return (tmp);
}
i++;
}
}
static void test_verify(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* default: client checks server cert, succeeds */
str_check(create_worker(&server, true, SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA1, "host=server1.com", NULL), "OK");
str_check(run_case(client, server), "OK");
/* default: client checks server cert, fails due to bad ca */
str_check(create_worker(&server, true, SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA2, "host=example.com", NULL), "OK");
str_check(run_case(client, server), "C:certificate verify failed - S:handshake failure");
/* default: client checks server cert, fails due to bad hostname */
str_check(create_worker(&server, true, SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA1, "host=example2.com", NULL), "OK");
str_check(run_case(client, server), "C:name 'example2.com' does not match cert");
end:;
}
static void test_strpool(void *p)
{
struct StrPool *pool;
struct PStr *s;
pool = strpool_create(NULL);
tt_assert(pool);
strpool_free(pool);
pool = strpool_create(NULL);
tt_assert(pool);
int_check(strpool_total(pool), 0);
s = strpool_get(pool, "foo", -1);
str_check(s->str, "foo");
int_check(s->refcnt, 1);
int_check(s->len, 3);
int_check(strpool_total(pool), 1);
tt_assert(s == strpool_get(pool, "fooTAIL", 3));
int_check(s->refcnt, 2);
int_check(strpool_total(pool), 1);
strpool_incref(s);
int_check(s->refcnt, 3);
strpool_decref(s);
int_check(s->refcnt, 2);
strpool_decref(s);
int_check(s->refcnt, 1);
int_check(strpool_total(pool), 1);
strpool_decref(s);
int_check(strpool_total(pool), 0);
strpool_free(pool);
/* free strc with strings */
pool = strpool_create(NULL);
tt_assert(pool);
s = strpool_get(pool, "foo", -1);
s = strpool_get(pool, "bar", 3);
int_check(strpool_total(pool), 2);
strpool_free(pool);
end:;
}
static void hdl_mstat(void)
{
int8 num = -1;
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST;
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 1)) RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mstat();
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL) RESP_CR(RET_WRONG_SIGN);
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
int lenght_gest(const char *str)
{
char tab[LENGHT];
int i;
tab[0] = 'h';
tab[1] = 'l';
tab[2] = 'j';
tab[3] = 'z';
if ((i = str_check(str)) > 0)
return (i);
else
{
while (i <= 5)
{
if (tab[i] == *str)
return (i);
i++;
}
}
return (LENGHT);
}
static void test_encdec(void *p)
{
ull_check(tdecode( 2, 1,2), 0x0102);
ull_check(tdecode(-2, 1,2), 0x0201);
ull_check(tdecode( 4, 1,2,3,4), 0x01020304);
ull_check(tdecode(-4, 1,2,3,4), 0x04030201);
ull_check(tdecode( 8, 1,2,3,4,5,6,7,8), 0x0102030405060708);
ull_check(tdecode(-8, 1,2,3,4,5,6,7,8), 0x0807060504030201);
str_check(tencode( 2, 0x0102), "01 02");
str_check(tencode(-2, 0x0102), "02 01");
str_check(tencode( 4, 0x01020304), "01 02 03 04");
str_check(tencode(-4, 0x01020304), "04 03 02 01");
str_check(tencode( 8, 0x0102030405060708ULL), "01 02 03 04 05 06 07 08");
str_check(tencode(-8, 0x0102030405060708ULL), "08 07 06 05 04 03 02 01");
end:;
}
int main()
{
int T,i,j,len;
int *m;
char *p1,*p2;
p1=p2="";
x=0;
scanf("%d",&T);
m=(int *)malloc(T*sizeof(int));
char *res[T];
for(i=0;i<T;i++){
PWD="/";
scanf("%d",m[i]);
for(j=0;j<m[i];j++){
scanf("%s",p1);
if(p1[0]=='p'){
*(res+x)=PWD;
x++;
}
else if(p1[0]=='c'){
scanf("%s",p2);
len=strlen(p2);
p2=str_check(p2,strlen(p2));
PWD=p2;
*(res+x)=p2;
x++;
}
}
}
i=0;
while(*(res+i)!="\0"){
printf("%s\n",res+i);
i++;
}
return 0;
}
static void hdl_mevt(void)
{
int8 num = -1;
if(atci.poll != POLL_MODE_FULL) RESP_CR(RET_DISABLED);
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_EQUAL;
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
CMD_CLEAR();
act_mevt_q();
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mevt_a(num);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void test_noverifyname(void *z)
{
struct Worker *server = NULL, *client = NULL;
tt_assert(tls_init() == 0);
/* noverifyname: client checks server cert, ignore bad hostname */
str_check(create_worker(&server, true, SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA1, "host=example2.com",
"noverifyname=1",
NULL), "OK");
str_check(run_case(client, server), "OK");
/* noverifyname: client checks server cert, ignore NULL hostname */
str_check(create_worker(&server, true, SERVER1, NULL), "OK");
str_check(create_worker(&client, false, CA1, "noverifyname=1", NULL), "OK");
str_check(run_case(client, server), "OK");
end:;
}
