int SelectPoll::unregisterFd(SOCKET_FD fd)
{
KUMA_INFOTRACE("SelectPoll::unregisterFd, fd="<<fd);
int max_fd = int(poll_items_.size() - 1);
if (fd < 0 || fd > max_fd) {
KUMA_WARNTRACE("SelectPoll::unregisterFd, failed, max_fd=" << max_fd);
return KUMA_ERROR_INVALID_PARAM;
}
updateFdSet(fd, 0);
int idx = poll_items_[fd].idx;
if (fd == max_fd) {
poll_items_.pop_back();
} else {
poll_items_[fd].fd = INVALID_FD;
poll_items_[fd].cb = nullptr;
poll_items_[fd].idx = -1;
}
int last_idx = int(poll_fds_.size() - 1);
if (idx > last_idx || -1 == idx) {
return KUMA_ERROR_NOERR;
}
if (idx != last_idx) {
std::iter_swap(poll_fds_.begin() + idx, poll_fds_.end() - 1);
poll_items_[poll_fds_[idx].fd].idx = idx;
}
poll_fds_.pop_back();
return KUMA_ERROR_NOERR;
}
KMError VPoll::unregisterFd(SOCKET_FD fd)
{
int max_fd = int(poll_items_.size() - 1);
KUMA_INFOTRACE("VPoll::unregisterFd, fd="<<fd<<", max_fd="<<max_fd);
if (fd < 0 || -1 == max_fd || fd > max_fd) {
KUMA_WARNTRACE("VPoll::unregisterFd, failed, max_fd="<<max_fd);
return KMError::INVALID_PARAM;
}
int idx = poll_items_[fd].idx;
if(fd < max_fd) {
poll_items_[fd].reset();
} else if (fd == max_fd) {
poll_items_.pop_back();
}
int last_idx = int(poll_fds_.size() - 1);
if (idx > last_idx || -1 == idx) {
return KMError::NOERR;
}
if (idx != last_idx) {
std::iter_swap(poll_fds_.begin()+idx, poll_fds_.end()-1);
poll_items_[poll_fds_[idx].fd].idx = idx;
}
poll_fds_.pop_back();
return KMError::NOERR;
}
int SelectPoll::updateFd(SOCKET_FD fd, uint32_t events)
{
int max_fd = int(poll_items_.size() - 1);
if (fd < 0 || -1 == max_fd || fd > max_fd) {
KUMA_WARNTRACE("SelectPoll::updateFd, failed, fd="<<fd<<", max_fd="<<max_fd);
return KUMA_ERROR_INVALID_PARAM;
}
if(poll_items_[fd].fd != fd) {
KUMA_WARNTRACE("SelectPoll::updateFd, failed, fd="<<fd<<", item_fd="<<poll_items_[fd].fd);
return KUMA_ERROR_INVALID_PARAM;
}
int idx = poll_items_[fd].idx;
if (idx < 0 || idx >= poll_fds_.size()) {
KUMA_WARNTRACE("SelectPoll::updateFd, failed, index="<<idx);
return KUMA_ERROR_INVALID_STATE;
}
if(poll_fds_[idx].fd != fd) {
KUMA_WARNTRACE("SelectPoll::updateFd, failed, fd="<<fd<<", pfds_fd="<<poll_fds_[idx].fd);
return KUMA_ERROR_INVALID_PARAM;
}
poll_fds_[idx].events = events;
updateFdSet(fd, events);
return KUMA_ERROR_NOERR;
}
KMError VPoll::updateFd(SOCKET_FD fd, KMEvent events)
{
int max_fd = int(poll_items_.size() - 1);
if (fd < 0 || -1 == max_fd || fd > max_fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", max_fd="<<max_fd);
return KMError::INVALID_PARAM;
}
if(poll_items_[fd].fd != fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", item_fd="<<poll_items_[fd].fd);
return KMError::INVALID_PARAM;
}
int idx = poll_items_[fd].idx;
if (idx < 0 || idx >= poll_fds_.size()) {
KUMA_WARNTRACE("VPoll::updateFd, failed, index="<<idx);
return KMError::INVALID_STATE;
}
if(poll_fds_[idx].fd != fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", pfds_fd="<<poll_fds_[idx].fd);
return KMError::INVALID_PARAM;
}
poll_fds_[idx].events = get_events(events);
poll_items_[fd].events = events;
return KMError::NOERR;
}
int HttpParserImpl::parse(const char* data, uint32_t len)
{
if(HTTP_READ_DONE == read_state_ || HTTP_READ_ERROR == read_state_) {
KUMA_WARNTRACE("HttpParser::parse, invalid state="<<read_state_);
return 0;
}
if(HTTP_READ_BODY == read_state_ && !is_chunked_ && !has_content_length_)
{// return directly, read untill EOF
total_bytes_read_ += len;
if(cb_data_) cb_data_(data, len);
return len;
}
const char* pos = data;
const char* end = data + len;
ParseState parse_state = parseHttp(pos, end);
int parsed_len = (int)(pos - data);
if(PARSE_STATE_DESTROY == parse_state) {
return parsed_len;
}
if(PARSE_STATE_ERROR == parse_state && cb_event_) {
cb_event_(HTTP_ERROR);
}
return parsed_len;
}
KMError KQueue::unregisterFd(SOCKET_FD fd)
{
int max_fd = int(poll_items_.size() - 1);
KUMA_INFOTRACE("KQueue::unregisterFd, fd="<<fd<<", max_fd="<<max_fd);
if (fd < 0 || fd > max_fd) {
KUMA_WARNTRACE("KQueue::unregisterFd, failed, max_fd=" << max_fd);
return KMError::INVALID_PARAM;
}
struct kevent kevents[2];
int nchanges = 0;
if (poll_items_[fd].events & KUMA_EV_READ) {
EV_SET(&kevents[nchanges++], fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
}
if (poll_items_[fd].events & KUMA_EV_WRITE) {
EV_SET(&kevents[nchanges++], fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
}
::kevent(kqueue_fd_, kevents, nchanges, 0, 0, 0);
if(fd < max_fd) {
poll_items_[fd].reset();
} else if (fd == max_fd) {
poll_items_.pop_back();
}
return KMError::NOERR;
}
bool OpenSslLib::init(const char* path)
{
if(ssl_ctx_client_ || ssl_ctx_server_) {
return true;
}
std::string cert_path;
if(path == NULL) {
cert_path = getCurrentModulePath();
} else {
cert_path = path;
if(cert_path.empty()) {
cert_path = getCurrentModulePath();
} else if(cert_path.at(cert_path.length() - 1) != PATH_SEPARATOR) {
cert_path += PATH_SEPARATOR;
}
}
std::string server_cert_file = cert_path + "server.cer";
std::string server_key_file = cert_path + "server.key";
std::string client_cert_file;// = cert_path + "cleint.cer";
std::string client_key_file;// = cert_path + "client.key";
std::string ca_cert_file = cert_path + "ca.cer";
SSL_library_init();
//OpenSSL_add_all_algorithms();
SSL_load_error_strings();
bool server_ctx_ok = false;
bool client_ctx_ok = false;
do {
ssl_ctx_server_ = SSL_CTX_new(SSLv23_server_method());
if(NULL == ssl_ctx_server_) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_new failed, err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
//const long flags = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION;
//SSL_CTX_set_options(ssl_ctx_server_, flags);
SSL_CTX_set_options(ssl_ctx_server_, SSL_OP_NO_SSLv2);
SSL_CTX_set_mode(ssl_ctx_server_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
SSL_CTX_set_mode(ssl_ctx_server_, SSL_MODE_ENABLE_PARTIAL_WRITE);
if(!server_cert_file.empty() && !server_key_file.empty()) {
if(SSL_CTX_use_certificate_file(ssl_ctx_server_, server_cert_file.c_str(), SSL_FILETYPE_PEM) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_use_certificate_file failed, file="<<server_cert_file
<<", err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
if(SSL_CTX_use_PrivateKey_file(ssl_ctx_server_, server_key_file.c_str(), SSL_FILETYPE_PEM) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_use_PrivateKey_file failed, file:"<<server_key_file
<<", err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
if(SSL_CTX_check_private_key(ssl_ctx_server_) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_check_private_key failed, err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
}
/*
SSL_CTX_set_verify(ssl_ctx_client_, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verifyCallback);
app_verify_arg arg0;
SSL_CTX_set_cert_verify_callback(ssl_ctx_server_, appVerifyCallback, &arg0);
int session_id_context = 1;
if(SSL_CTX_set_session_id_context(ssl_ctx_server_, (unsigned char *)&session_id_context, sizeof(session_id_context)) != 1)
{
}
*/
server_ctx_ok = true;
} while(0);
do {
ssl_ctx_client_ = SSL_CTX_new(SSLv23_client_method());
if(NULL == ssl_ctx_client_) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_new failed, err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
SSL_CTX_set_verify(ssl_ctx_client_, SSL_VERIFY_PEER, verifyCallback);
//SSL_CTX_set_verify_depth(ssl_ctx_client_, 4);
//app_verify_arg arg1;
//SSL_CTX_set_cert_verify_callback(ssl_ctx_client_, appVerifyCallback, &arg1);
//const long flags = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION;
//SSL_CTX_set_options(ssl_ctx_client_, flags);
SSL_CTX_set_options(ssl_ctx_client_, SSL_OP_NO_SSLv2);
SSL_CTX_set_mode(ssl_ctx_client_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
SSL_CTX_set_mode(ssl_ctx_client_, SSL_MODE_ENABLE_PARTIAL_WRITE);
// set AES256_SHA cipher for client.
//if(SSL_CTX_set_cipher_list(ssl_ctx_client_,"AES256-SHA") != 1)
//{
// KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_set_cipher_list failed, err="<<ERR_reason_error_string(ERR_get_error()));
//}
if(!client_cert_file.empty() && !client_key_file.empty()) {
if(SSL_CTX_use_certificate_file(ssl_ctx_client_, client_cert_file.c_str(), SSL_FILETYPE_PEM) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_use_certificate_file failed, file="<<client_cert_file
<<", err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
if(SSL_CTX_use_PrivateKey_file(ssl_ctx_client_, client_key_file.c_str(), SSL_FILETYPE_PEM) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_use_PrivateKey_file failed, file="<<client_key_file
<<", err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
if(SSL_CTX_check_private_key(ssl_ctx_client_) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_check_private_key failed, err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
}
if(!ca_cert_file.empty() &&
SSL_CTX_load_verify_locations(ssl_ctx_client_, ca_cert_file.c_str(), NULL) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_load_verify_locations failed, file="<<ca_cert_file
<<", err="<<ERR_reason_error_string(ERR_get_error()));
break;
}
if(SSL_CTX_set_default_verify_paths(ssl_ctx_client_) != 1) {
KUMA_WARNTRACE("OpenSslLib::init, SSL_CTX_set_default_verify_paths failed, err="
<<ERR_reason_error_string(ERR_get_error()));
break;
}
client_ctx_ok = true;
} while(0);
if(!server_ctx_ok && ssl_ctx_server_) {
SSL_CTX_free(ssl_ctx_server_);
ssl_ctx_server_ = NULL;
}
if(!client_ctx_ok && ssl_ctx_client_) {
SSL_CTX_free(ssl_ctx_client_);
ssl_ctx_client_ = NULL;
}
if(!server_ctx_ok && !client_ctx_ok) {
return false;
}
ssl_locks_ = new std::mutex[CRYPTO_num_locks()];
CRYPTO_set_id_callback(threadIdCallback);
CRYPTO_set_locking_callback(lockingCallback);
// PRNG
RAND_poll();
while(RAND_status() == 0) {
unsigned short rand_ret = rand() % 65536;
RAND_seed(&rand_ret, sizeof(rand_ret));
}
return true;
}
