/**
******************************************************************************
* @brief 1. 打开读卡器
* @param[in] None
* @param[out] None
*
* @retval 0 : 打开读卡器端口成功
* @retval 1 : 打开读卡器端口失败
******************************************************************************
*/
extern int
MS_OpenPort()
{
unsigned int socketfd = 0;
char buf[16] = {0};
int pos = 0;
int sendlen = 0;
int recvlen = 0;
int ret = 1;
if ((socketfd = connect_start()) == 0)
{
log_exit();
return 1;
}
memcpy(buf, the_head, 3); //3字节GET
pos += 3;
buf[pos] = 1;
pos += 1;
memcpy(buf + pos, &sendlen, sizeof(int));
pos += sizeof(int);
do
{
if ((sendlen + 8) != socket_send(socketfd, buf, sendlen + 8))
{
log_print("%s发送数据数据出错\n", __FUNCTION__);
break;
}
memset(buf, 0x00, sizeof(buf));
recvlen = socket_recv(socketfd, buf, 12); //len = 8 + 4
if ((recvlen == -1) || (recvlen != 12))
{
log_print("%s接收数据出错[recvlen:%d]\n", __FUNCTION__, recvlen);
break;
}
pos = 0;
if ((memcmp(buf, "PUT", 3) != 0) || (buf[3] != 1))
{
log_print("%s 头不合法\n", __FUNCTION__);
break;
}
pos += 4;
memcpy(&recvlen, buf + pos, sizeof(int));
if (recvlen != sizeof(int))
{
log_print("%s 长度不合法\n", __FUNCTION__);
break;
}
pos += 4;
memcpy(&ret, buf + pos, sizeof(int));
ret = (ret == 0) ? ret : 1;
} while(0);
connect_close(socketfd);
return ret;
}
void sploit_run(void)
{
sploit_proto = net_register(NET_CLIENT, "sploit", sploit_handler);
ssl_add("connect", SSL_CONTEXT_CLIENT,
"/etc/ircd/ircd.crt", "/etc/ircd/ircd.key",
"RSA+HIGH:RSA+MEDIUM:@STRENGTH");
sploit_connect = connect_add("127.0.0.1", 6667, sploit_proto,
30000ull, 0, 1, 0, "connect");
connect_start(sploit_connect);
}
static void select_current_item() {
// state screen
if (current_item <= 0) {
if(state == 2) {
// if connected then go to options
settings_start();
} else {
// start connection process
connect_start();
}
}
else
queue_item(current_item - 1);
}
MDB_ASYNC_ST MySQL_Connection::handler(short event) {
if (mysql==NULL) {
// it is the first time handler() is being called
async_state_machine=ASYNC_CONNECT_START;
myds->wait_until=myds->sess->thread->curtime+mysql_thread___connect_timeout_server*1000;
}
handler_again:
proxy_debug(PROXY_DEBUG_MYSQL_PROTOCOL, 6,"async_state_machine=%d\n", async_state_machine);
switch (async_state_machine) {
case ASYNC_CONNECT_START:
connect_start();
if (async_exit_status) {
next_event(ASYNC_CONNECT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_CONNECT_END);
}
break;
case ASYNC_CONNECT_CONT:
if (event) {
connect_cont(event);
}
if (async_exit_status) {
if (myds->sess->thread->curtime >= myds->wait_until) {
NEXT_IMMEDIATE(ASYNC_CONNECT_TIMEOUT);
}
next_event(ASYNC_CONNECT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_CONNECT_END);
}
break;
break;
case ASYNC_CONNECT_END:
if (!ret_mysql) {
// always increase the counter
proxy_error("Failed to mysql_real_connect() on %s:%d , %d: %s\n", parent->address, parent->port, mysql_errno(mysql), mysql_error(mysql));
NEXT_IMMEDIATE(ASYNC_CONNECT_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_CONNECT_SUCCESSFUL);
}
break;
case ASYNC_CONNECT_SUCCESSFUL:
__sync_fetch_and_add(&MyHGM->status.server_connections_connected,1);
__sync_fetch_and_add(&parent->connect_OK,1);
break;
case ASYNC_CONNECT_FAILED:
parent->connect_error(mysql_errno(mysql));
break;
case ASYNC_CONNECT_TIMEOUT:
proxy_error("Connect timeout on %s:%d : %llu - %llu = %llu\n", parent->address, parent->port, myds->sess->thread->curtime , myds->wait_until, myds->sess->thread->curtime - myds->wait_until);
parent->connect_error(mysql_errno(mysql));
break;
case ASYNC_CHANGE_USER_START:
change_user_start();
if (async_exit_status) {
next_event(ASYNC_CHANGE_USER_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_CHANGE_USER_END);
}
break;
case ASYNC_CHANGE_USER_CONT:
assert(myds->sess->status==CHANGING_USER_SERVER);
change_user_cont(event);
if (async_exit_status) {
next_event(ASYNC_CHANGE_USER_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_CHANGE_USER_END);
}
break;
case ASYNC_CHANGE_USER_END:
if (ret_bool) {
fprintf(stderr,"Failed to mysql_change_user()");
NEXT_IMMEDIATE(ASYNC_CHANGE_USER_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_CHANGE_USER_SUCCESSFUL);
}
break;
case ASYNC_CHANGE_USER_SUCCESSFUL:
break;
case ASYNC_CHANGE_USER_FAILED:
break;
case ASYNC_PING_START:
ping_start();
if (async_exit_status) {
next_event(ASYNC_PING_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_PING_END);
}
break;
case ASYNC_PING_CONT:
assert(myds->sess->status==PINGING_SERVER);
ping_cont(event);
if (async_exit_status) {
next_event(ASYNC_PING_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_PING_END);
}
break;
case ASYNC_PING_END:
if (interr) {
NEXT_IMMEDIATE(ASYNC_PING_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_PING_SUCCESSFUL);
}
break;
case ASYNC_PING_SUCCESSFUL:
break;
case ASYNC_PING_FAILED:
break;
case ASYNC_QUERY_START:
real_query_start();
__sync_fetch_and_add(&parent->queries_sent,1);
__sync_fetch_and_add(&parent->bytes_sent,query.length);
myds->sess->thread->status_variables.queries_backends_bytes_sent+=query.length;
if (async_exit_status) {
next_event(ASYNC_QUERY_CONT);
} else {
#ifdef PROXYSQL_USE_RESULT
NEXT_IMMEDIATE(ASYNC_USE_RESULT_START);
#else
NEXT_IMMEDIATE(ASYNC_STORE_RESULT_START);
#endif
}
break;
case ASYNC_QUERY_CONT:
real_query_cont(event);
if (async_exit_status) {
next_event(ASYNC_QUERY_CONT);
} else {
#ifdef PROXYSQL_USE_RESULT
NEXT_IMMEDIATE(ASYNC_USE_RESULT_START);
#else
NEXT_IMMEDIATE(ASYNC_STORE_RESULT_START);
#endif
}
break;
case ASYNC_STORE_RESULT_START:
if (mysql_errno(mysql)) {
NEXT_IMMEDIATE(ASYNC_QUERY_END);
}
store_result_start();
if (async_exit_status) {
next_event(ASYNC_STORE_RESULT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_QUERY_END);
}
break;
case ASYNC_STORE_RESULT_CONT:
store_result_cont(event);
if (async_exit_status) {
next_event(ASYNC_STORE_RESULT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_QUERY_END);
}
break;
case ASYNC_USE_RESULT_START:
if (mysql_errno(mysql)) {
NEXT_IMMEDIATE(ASYNC_QUERY_END);
}
mysql_result=mysql_use_result(mysql);
if (mysql_result==NULL) {
NEXT_IMMEDIATE(ASYNC_QUERY_END);
} else {
MyRS=new MySQL_ResultSet(&myds->sess->client_myds->myprot, mysql_result, mysql);
async_fetch_row_start=false;
NEXT_IMMEDIATE(ASYNC_USE_RESULT_CONT);
}
break;
case ASYNC_USE_RESULT_CONT:
if (async_fetch_row_start==false) {
async_exit_status=mysql_fetch_row_start(&mysql_row,mysql_result);
async_fetch_row_start=true;
} else {
async_exit_status=mysql_fetch_row_cont(&mysql_row,mysql_result, mysql_status(event, true));
}
if (async_exit_status) {
next_event(ASYNC_USE_RESULT_CONT);
} else {
async_fetch_row_start=false;
if (mysql_row) {
unsigned int br=MyRS->add_row(mysql_row);
__sync_fetch_and_add(&parent->bytes_recv,br);
myds->sess->thread->status_variables.queries_backends_bytes_recv+=br;
NEXT_IMMEDIATE(ASYNC_USE_RESULT_CONT);
} else {
MyRS->add_eof();
NEXT_IMMEDIATE(ASYNC_QUERY_END);
}
}
break;
case ASYNC_QUERY_END:
break;
case ASYNC_SET_AUTOCOMMIT_START:
set_autocommit_start();
if (async_exit_status) {
next_event(ASYNC_SET_AUTOCOMMIT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_END);
}
break;
case ASYNC_SET_AUTOCOMMIT_CONT:
set_autocommit_cont(event);
if (async_exit_status) {
next_event(ASYNC_SET_AUTOCOMMIT_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_END);
}
break;
case ASYNC_SET_AUTOCOMMIT_END:
if (ret_bool) {
NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_SUCCESSFUL);
}
break;
case ASYNC_SET_AUTOCOMMIT_SUCCESSFUL:
break;
case ASYNC_SET_AUTOCOMMIT_FAILED:
fprintf(stderr,"%s\n",mysql_error(mysql));
break;
case ASYNC_SET_NAMES_START:
set_names_start();
if (async_exit_status) {
next_event(ASYNC_SET_NAMES_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_SET_NAMES_END);
}
break;
case ASYNC_SET_NAMES_CONT:
set_names_cont(event);
if (async_exit_status) {
next_event(ASYNC_SET_NAMES_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_SET_NAMES_END);
}
break;
case ASYNC_SET_NAMES_END:
if (interr) {
NEXT_IMMEDIATE(ASYNC_SET_NAMES_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_SET_NAMES_SUCCESSFUL);
}
break;
case ASYNC_SET_NAMES_SUCCESSFUL:
break;
case ASYNC_SET_NAMES_FAILED:
fprintf(stderr,"%s\n",mysql_error(mysql));
break;
case ASYNC_INITDB_START:
initdb_start();
if (async_exit_status) {
next_event(ASYNC_INITDB_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_INITDB_END);
}
break;
case ASYNC_INITDB_CONT:
initdb_cont(event);
if (async_exit_status) {
next_event(ASYNC_INITDB_CONT);
} else {
NEXT_IMMEDIATE(ASYNC_INITDB_END);
}
break;
case ASYNC_INITDB_END:
if (interr) {
NEXT_IMMEDIATE(ASYNC_INITDB_FAILED);
} else {
NEXT_IMMEDIATE(ASYNC_INITDB_SUCCESSFUL);
}
break;
case ASYNC_INITDB_SUCCESSFUL:
break;
case ASYNC_INITDB_FAILED:
fprintf(stderr,"%s\n",mysql_error(mysql));
break;
default:
assert(0); //we should never reach here
break;
}
return async_state_machine;
}
/**
******************************************************************************
* @brief 3. 会话初始化/恢复
* @param[in] ESAMNo : ESAM序列号; 8字节
* @param[in] state : 证书状态标识; 1字节, 00--测试证书, 01--正式证书
* @param[in] VersionNum : 版本号; 1字节,固定“01”
* @param[in] SessionID : 会话ID; 1字节, 00-- 新建注册, 01--恢复
* @param[in] R1 : 随机数1; 16字节
* @param[out] message1 : 报文1; N字节(大于1K,小于2K)
*
* @retval 0 : 正常返回
* @retval 1001 : ESAM序列号错误
* @retval 1002 : 证书状态标识错误
* @retval 1003 : 版本号错误
* @retval 1004 : 会话ID错误
* @retval 1005 : 随机数错误
******************************************************************************
*/
extern int
SessionInitRec(char *ESAMNo, char *state, char *VersionNum,
char *SessionID, char *R1, char *message1)
{
unsigned int socket = 0;
char *buf = inbuf;
int pos = 0;
int sendlen = 0;
int recvlen = 0;
int ret = 1001;
head_t *head = (head_t *)inbuf;
if (strlen(ESAMNo) != 8 * 2)
{
return 1001;
}
if (strlen(state) != 1 *2)
{
return 1002;
}
if (strcmp(VersionNum, "01") != 0)
{
return 1003;
}
if (strlen(SessionID) != 1 * 2)
{
return 1004;
}
if (strlen(R1) != 16 * 2)
{
return 1005;
}
if ((socket = connect_start()) == 0)
{
return 1;
}
memcpy(head->str, the_head, 3); //3字节GET
head->pfn[0] = 3;
buf += sizeof(head_t);
strcpy(buf, ESAMNo);
buf += strlen(ESAMNo) + 1;
strcpy(buf, state);
buf += strlen(state) + 1;
strcpy(buf, VersionNum);
buf += strlen(VersionNum) + 1;
strcpy(buf, SessionID);
buf += strlen(SessionID) + 1;
strcpy(buf, R1);
buf += strlen(R1) + 1;
sendlen = buf - inbuf;
head->len = sendlen - sizeof(head_t);
log_print("ESAMNo:%s\n", ESAMNo);
log_print("state:%s\n", state);
log_print("VersionNum:%s\n", VersionNum);
log_print("SessionID:%s\n", SessionID);
log_print("R1:%s\n", R1);
do
{
if (sendlen != socket_send(socket, inbuf, sendlen))
{
log_print("%s发送数据出错\n", __FUNCTION__);
break;
}
memset(buf, 0x00, sizeof(buf));
recvlen = socket_recv(socket, buf, 12); //len = 8 + 4
if ((recvlen == -1) || (recvlen != 12))
{
log_print("%s接收数据出错[recvlen:%d]\n", __FUNCTION__, recvlen);
break;
}
pos = 0;
if ((memcmp(buf, "PUT", 3) != 0) || (buf[3] != 3))
{
log_print("%s头校验错误!\n", __FUNCTION__);
break;
}
pos += 4;
memcpy(&recvlen, buf + pos, sizeof(int));
pos += 4;
memcpy(&ret, buf + pos, sizeof(int));
memset(outbuf, 0x00, sizeof(outbuf));
if (socket_recv(socket, outbuf, recvlen - 4) != recvlen - 4)
{
log_print("%s接收数据错误!\n", __FUNCTION__);
break;
}
if (ret == 0) //成功则读取数据
{
log_print("message1:%s\n", message1);
strncpy(message1, outbuf, 1024 * 2 * 2);
}
} while(0);
connect_close(socket);
return ret;
}
