Студентам здесь не подают. Если уж стырил код, то напряги то, что замещает у тебя мозг, и почитай хотя бы лекции.

вот здесь ошибка:

main()
{
    BIO *sbio, *bbio, *acpt, *out;
    int len;
    char tmpbuf[1024];
    SSL_CTX *ctx;
    SSL *ssl;
    ERR_load_crypto_strings();
    ERR_load_SSL_strings();
    OpenSSL_add_all_algorithms();
    SSL_library_init();  
    /* Might seed PRNG here */
    ctx=SSL_CTX_new(SSLv23_server_method());
        if(ctx == NULL)
    {
        printf("CTX is null\n");
        return;
    }
        
    printf("After Cert Load\n");
    if (!SSL_CTX_use_certificate_file(ctx,"certfiles/cacert.pem", SSL_FILETYPE_PEM)
        || SSL_CTX_use_PrivateKey_file(ctx,"certfiles/rsa_private_key.pem", SSL_FILETYPE_PEM)
        || SSL_CTX_check_private_key(ctx))
    {
        fprintf(stderr, "Error setting up SSL_CTX\n");
        ERR_print_errors_fp(stderr);
        return 0;
    }
    printf("After Cert Load\n    ");
    /* Might do other things here like setting verify locations and
    * DH and/or RSA temporary key callbacks
    */
    /* New SSL BIO setup as server */
    sbio=BIO_new_ssl(ctx,0);
    BIO_get_ssl(sbio, &ssl);
    if(!ssl) {
        fprintf(stderr, "Can't locate SSL pointer\n");
        /* whatever ... */
    }
    /* Don't want any retries */
    SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
    /* Create the buffering BIO */
    bbio = BIO_new(BIO_f_buffer());
    /* Add to chain */
    sbio = BIO_push(bbio, sbio);
    acpt=BIO_new_accept("1332");
    /* By doing this when a new connection is established
    * we automatically have sbio inserted into it. The
    * BIO chain is now 'swallowed' by the accept BIO and
    * will be freed when the accept BIO is freed.
    */
    
    BIO_set_accept_bios(acpt,sbio);
    out = BIO_new_fp(stdout, BIO_NOCLOSE);
    /* Setup accept BIO */
    if(BIO_do_accept(acpt) <= 0) {
        fprintf(stderr, "Error setting up accept BIO\n");
        ERR_print_errors_fp(stderr);
        return 0;
    }
    /* Now wait for incoming connection */
    if(BIO_do_accept(acpt) <= 0) {
        fprintf(stderr, "Error in connection\n");
        ERR_print_errors_fp(stderr);
        return 0;
    }
    /* We only want one connection so remove and free
    * accept BIO
    */
    sbio = BIO_pop(acpt);
    BIO_free_all(acpt);
    if(BIO_do_handshake(sbio) <= 0)
    {
        fprintf(stderr, "Error in SSL handshake\n");
        ERR_print_errors_fp(stderr);
        return 0;
    }
    BIO_puts(sbio, "HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n");
    BIO_puts(sbio, "\r\nConnection Established\r\nRequest headers:\r\n");
    BIO_puts(sbio, "--------------------------------------------------\r\n");
    for(;;) {
        len = BIO_gets(sbio, tmpbuf, 1024);
        if(len <= 0) break;
        BIO_write(sbio, tmpbuf, len);
        BIO_write(out, tmpbuf, len);
        /* Look for blank line signifying end of headers*/
        if((tmpbuf[0] == '\r') || (tmpbuf[0] == '\n')) break;
    }
    BIO_puts(sbio, "--------------------------------------------------\r\n");
    BIO_puts(sbio, "\r\n");
    /* Since there is a buffering BIO present we had better flush it */
    BIO_flush(sbio);
    BIO_free_all(sbio);
}
//----------------------------------------------------
client.c
//----------------------------------------------------
#include <openssl/bio.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#include <stdio.h>
#include <string.h>

main()
{
    BIO *sbio, *out;
    int len;
    char tmpbuf[1024];
    SSL_CTX *ctx;
    SSL *ssl;
    ERR_load_crypto_strings();
    ERR_load_SSL_strings();
    OpenSSL_add_all_algorithms();
    SSL_library_init();
    /* We would seed the PRNG here if the platform didn't
    * do it automatically
    */
    ctx = SSL_CTX_new(SSLv23_client_method());
    /* We'd normally set some stuff like the verify paths and
    * mode here because as things stand this will connect to
    * any server whose certificate is signed by any CA.
    */
    sbio = BIO_new_ssl_connect(ctx);
    BIO_get_ssl(sbio, &ssl);
    if(!ssl) {
        fprintf(stderr, "Can't locate SSL pointer\n");
        /* whatever ... */
    }
    /* Don't want any retries */
    SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
    /* We might want to do other things with ssl here */
    BIO_set_conn_hostname(sbio, "localhost:1332");
    out = BIO_new_fp(stdout, BIO_NOCLOSE);
    if(BIO_do_connect(sbio) <= 0) {
        fprintf(stderr, "Error connecting to server\n");
        ERR_print_errors_fp(stderr);
        /* whatever ... */
    }
    if(BIO_do_handshake(sbio) <= 0) {
        fprintf(stderr, "Error establishing SSL connection\n");
        ERR_print_errors_fp(stderr);
        /* whatever ... */
    }
    /* Could examine ssl here to get      info */
    BIO_puts(sbio, "GET / HTTP/1.0\n\n");
    for(;;) {
        len = BIO_read(sbio, tmpbuf, 1024);
        if(len <= 0) break;
        BIO_write(out, tmpbuf, len);
    }
    BIO_free_all(sbio);
    BIO_free(out);
}

Вобщем в итоге все упирается в то, что BIO_read на сервере возвращает -2 по документации If the return value is -2 then the operation is not implemented in the specific BIO type.
И вот тут тупик. На клиенте функция отрабатывает.

P.S. Если я опять по вашему мнению спираю всю мысленную работу на вас - вы хоть отпишите(Даже сообщения ты студент, ты пень, кури маны только приветвтвуются)

Прошу прощения я не правильно вставил код.
Вобщем почитал я тут поэксперементировал немного - некоторые вещи прояснились переделал код - в общем я в обе стороны могу передавать, но возникла следующая трудность:
Код подкючения и тд и тп я писать не буду - он рабочий осталость только понять как работают BIO_read + BIO_write вобщем
Идея следующая - код записи и чтения везде одинаковый на одной стороне считать а потом записать а на втором конце соответственно наоборот.
Получается следующая картина:
./send
Sending Hello server
End writing
lets reading
Before read

./recv
Before read

Это означает то, что функция write отработала программа пошла дальше читать, а на другом конце read не получила ничего. - Но прикол в следующем если убрать код чтения из send. - Он будет отмечен внизу, read
получит свой Hello server.
$./recv
Before read
[13]<-----
[Hello client
] --- [13]
End reading
lets writing
Sending Hello server
End writing

$ ./send
Sending Hello server
End writing
lets reading

- И еще один момент - read отрабатывает после sleep на send. Это блин почему так может получиться? Складыавется такое чувство что данные передаются когда соединение завершается. - Странно не правда ли?

Код на одном конце:(recv.c)
    //Read begin
    for(;;)
    {
    printf("Before read\n");
    len = BIO_read(sbio, tmpbuf, sizeof(tmpbuf));
    printf("[%d]<-----\n",len);
    if(len == 0)
    {
      printf("Server is close connection\n");
      return 0;
    }
    else if(len < 0)
    {
      if(! BIO_should_retry(sbio))
       {
       printf("Read is crashed %d\n",len);
       return 0;
       }
       continue;
    }
    tmpbuf[len]=0;
    break;
    }    
    printf("[%s] --- [%d] \n",tmpbuf, strlen(tmpbuf));
    //Read end
    printf("End reading\n");
    BIO_flush(sbio);
    sleep(5);
    printf("lets writing\n");
    
    //Write begin
    printf("Sending Hello server\n");
    strcpy(tmpbuf, "Hello client\n");
    for(;;)
    {
    if(BIO_write(sbio, tmpbuf, strlen(tmpbuf)) <= 0)
    {
      if(! BIO_should_retry(sbio))
      {
       printf("Write is crashed\n");
       return 0;
      }
      continue;
      }
    break;
       }
    // Write end
    printf("End writing\n");
___________________________А вот на другом__________________________________________(send.c)

    //Write begin
    printf("Sending Hello server\n");
    strcpy(tmpbuf, "Hello client\n");
    for(;;)
    {
    if(BIO_write(sbio, tmpbuf, strlen(tmpbuf)) <= 0)
    {
      if(! BIO_should_retry(sbio))
      {
       printf("Write is crashed\n");
       return 0;
      }
      continue;
      }
    break;
    }
    // Write end
    printf("End writing\n");
    sleep(5);
    printf("lets reading\n");
    
    //Read begin <-----------------------
    for(;;)
    {
    printf("Before read\n");
    len = BIO_read(sbio, tmpbuf, sizeof(tmpbuf));
    printf("[%d]<-----\n",len);
    if(len == 0)
    {
      printf("Server is close connection\n");
      return 0;
    }
    else if(len < 0)
    {
      if(! BIO_should_retry(sbio))
       {
       printf("Read is crashed %d\n",len);
       return 0;
       }
       continue;
    }
    tmpbuf[len]=0;
    break;
    }    
    printf("[%s] --- [%d] \n",tmpbuf, strlen(tmpbuf));
    //Read end
    printf("End reading\n");
    BIO_flush(sbio);<--------------------------------------
    

Ну вот я уже можно сказать скурил все маны оказалось что
int BIO_read(BIO *b, void *buf, int len);
Пытается прочесть из объекта b len байт данных в буфер buf. Возвращает количество
прочитанных байт.
- И будет пытаться пока соединение не завершится(Поэтому данные передавались в конце соединения - соединение рвется BIO_read выходит из цикла и показывает что получла) в отличие от
int BIO_gets(BIO *b, char *buf, int size);
Для большинства типов BIO выполняет операцию, аналогичную fgets — читает из b в buf
до ближайшего конца строки, но не более size байт.
Тоесть функция read ждет а gets не ждет. - Поскольку я не знаю сколько мне должно придти (параметр len мне узнать не откуда) функция gets выглядит более предпочтительно - НО! Функция BIO_set_conn_hostname которая определяет объект ввода вывода не поддерживает BIO_gets
Connect BIOs support BIO_puts() but not BIO_gets().
Как мне быть? Куда смотреть теперь?