OpenSSL Blocking Sockets SSL_read blocks [closed] - sockets

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 5 years ago.
Improve this question
I am using blocking sockets in OpenSSL connection. SSL_read blocks sometimes for few seconds. In server - BIO_write is used to send data in variable buffer size. In client - first SSL_read to get buffer size succeeds but following SSL_read to get buffer data blocks for few seconds(this issue is simulated after 2 to 3mins) even though data sent successfully. I wait on poll() to invoke client read function. How to correct these problem in blocking sockets?
Server Code
void process_and_send() {
// sending variable size buffer each time
// sbuf - first 4 bytes contains sbuf size information
send_data(sbuf, sbufSize);
}
void send_data(void *sbuf, int pending_len) {
while(pending_len > 0) {
result = BIO_write(bio, sbuf, pending_len);
if(result == 0) {
attempts = 0;
LOG_D("%s", log_str(SSL_CONN_CLOSE));
SSL_FN_TRACE("connection closed\n");
break;
}
else if(result < 0) {
LOG_I("%s", log_str(SSL_WRITE_FAIL));
SSL_FN_TRACE("BIO_write fail\n");
if(errno == EINTR) {
continue;
}
if(errno == EAGAIN) {
attempts++;
continue;
}
if(errno == EWOULDBLOCK) {
attempts++;
continue;
}
break;
}
else {
BIO_flush(bio);
pending_len -= result;
sbuf += result;
}
}
}
Client Code
// wait on poll() and call receive_and_process
void receive_and_process() {
int rbufSize = 0;
// get the size of data to read
receive_data((void *)&rbufSize, sizeof(Int));
// this call blocks for few seconds
receive_data(rbuf, rbufSize);
}
void receive_data(void *rbuf, int pending_len) {
while(pending_len > 0) {
result = SSL_read(ssl, rbuf, pending_len);
if(result == 0) {
LOG_D("%s", log_str(SSL_CONN_CLOSE));
SSL_FN_TRACE("connection closed\n");
return NULL;
}
else if(result < 0) {
if(errno == ETIMEDOUT) {
SSL_FN_ERROR("SSL read timeout: \n");
continue;
}
if(errno == EINTR) {
continue;
}
if(errno == EAGAIN) {
continue;
}
if(errno == EWOULDBLOCK) {
continue;
}
SSL_FN_ERROR("SSL read fail error no: %s\n",
ERR_reason_error_string(ERR_get_error()));
LOG_I("%s", log_str(SSL_READ_FAIL));
return NULL;
}
pending_len -= result;
rbuf += result;
FN_ERROR("after read full data pending len %d\n", pending_len);
}
}

Answer 1

Well, for starters, your client code can't compile as shown, because receive_data() has a void return type, so return NULL is a compiler error. Also, you can't use the += operator on a void* pointer, that is also a compiler error.
Beside that, if SSL_read() returns < 0, you need to use SSL_get_error() instead of errno to find out why it failed. Don't use errno unless SSL_get_error() returns SSL_ERROR_SYSCALL. If SSL_get_error() returns SSL_ERROR_SSL, use ERR_get_error() and related functions instead. And, make sure you are handling the SSL_ERROR_WANT_READ and SSL_ERROR_WANT_WRITE errors.
Also, when sending multi-byte integers, you have to deal with endian issues if you are sending across machine boundaries. Best to use functions like htonl() and ntohl() to send integers over the connection in network byte order.
Try something more like this:
Server:
void process_and_send() {
// sending variable size buffer each time
// sbuf - DO NOT store the size information in the first 4 bytes!
// handle the size separately...
int32_t size = htonl(sbufSize);
if (send_data(&size, sizeof(size)))
send_data(sbuf, sbufSize);
}
bool send_data(void *sbuf, int pending_len) {
unsigned char *pbuf = (unsigned char *) sbuf;
while (pending_len > 0) {
result = BIO_write(bio, pbuf, pending_len);
if (result > 0) {
BIO_flush(bio);
pbuf += result;
pending_len -= result;
}
else if (result == 0) {
attempts = 0;
LOG_D("%s", log_str(SSL_CONN_CLOSE));
SSL_FN_TRACE("connection closed\n");
return false;
}
else if (!BIO_should_retry(bio)) {
LOG_I("%s", log_str(SSL_WRITE_FAIL));
SSL_FN_TRACE("BIO_write fail\n");
return false;
}
else {
++attempts;
}
}
return true;
}
Client:
// wait on poll() and call receive_and_process
void receive_and_process() {
int32_t rbufSize = 0;
// get the size of data to read
if (receive_data(&rbufSize, sizeof(rbufSize))) {
rbufSize = ntohl(rbufSize);
// TODO: make sure rbuf is at least rbufSize in size...
receive_data(rbuf, rbufSize);
}
}
bool receive_data(void *rbuf, int pending_len) {
unsigned char *pbuf = (unsigned char *) rbuf;
while (pending_len > 0) {
result = SSL_read(ssl, pbuf, pending_len);
if (result > 0) {
pbuf += result;
pending_len -= result;
FN_ERROR("after read full data pending len %d\n", pending_len);
}
else {
result = SSL_get_error();
if (result == SSL_ERROR_ZERO_RETURN) {
LOG_D("%s", log_str(SSL_CONN_CLOSE));
SSL_FN_TRACE("connection closed\n");
}
else {
if (result == SSL_ERROR_WANT_READ) {
// TODO: use select() to wait for the socket to be readable before trying again...
continue;
}
else if (result == SSL_ERROR_WANT_WRITE) {
// TODO: use select() to wait for the socket to be writable before trying again...
continue;
}
else if (result == SSL_ERROR_SYSCALL) {
if ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK)) {
continue;
}
if (errno == ETIMEDOUT) {
SSL_FN_ERROR("SSL read timeout: \n");
continue;
}
SSL_FN_ERROR("SSL read fail error no: %d\n", errno);
}
else if (result == SSL_ERROR_SSL) {
SSL_FN_ERROR("SSL read fail error no: %s\n",
ERR_reason_error_string(ERR_get_error()));
}
else {
SSL_FN_ERROR("SSL read fail error no: %d\n", result);
}
LOG_I("%s", log_str(SSL_READ_FAIL));
}
return false;
}
}
return true;
}