OpenSSL Library - BIO 概論

class BIO_METHOD {
    int type;
    virtual int read(void *data, int len);
    virtual int gets(char *buf, int size);
    virtual int write(const void *data, int len);
    virtual int puts(const char *buf);
};

class BIO : BIO_METHOD {
  public:
    BIO(BIO_METHOD *type); // BIO_new()
    /*
    BIO_METHOD 是一個函數指標表，其用途即 OOPL 的 interface，
    每一個函數指標即 interface 中的抽象函數，
    當建構實體時，才會將指標指向實際的函數。
    最初的 C 語言便是透過這種模式實作繼承機制。
    type:
        BIO_s_file()
        BIO_s_mem()
        and more...
    */

    ~BIO(); // BIO_free()

    int read(void *data, int len); // BIO_read()
    int gets(char *buf, int size); // BIO_gets()
    int write(const void *data, int len); // BIO_write()
    int puts(const char *buf);  // BIO_puts()
    // manpage fread(),fgets(),fwrite(),fputs()
    
    int tell(); // BIO_tell()
    int seek(long offset); // BIO_seek()
    // manpage fseek(3), ftell(3)

    int printf(...); // BIO_printf()
    int snprintf(...); // BIO_snprintf()
    // manpage printf(3)
    
    int ctrl(...); // BIO_ctrl()
};

// close_flag
#define BIO_NOCLOSE 0
#define BIO_CLOSE 1

class BIO_file: public BIO {
  public:
    BIO_file(FILE *stream, int close_flag); // BIO_new_fp()
    BIO_file(const char *filename, const char *mode); // BIO_new_file()
    // manpage fopen(3)
};

class BIO_fd: public BIO {
  public:
    BIO_fd(int fd, int close_flag); // BIO_new_fd()
    // manpage open(2)
};

class BIO_mem: public BIO {
  public:
    BIO_mem(); // BIO_new(BIO_s_mem())

    BIO_mem(void *buf, int len); // BIO_new_mem_buf()
    
    struct BUF_MEM {
        void *data;
        int length;
        int max;
    };
    
    int get_mem_ptr(BUF_MEM **ptr);
};

char buf[4096]; // fixed-size memory block
BIO *bio1 = new BIO_mem(buf, sizeof(buf)); // read-only
bio1->puts("hello"); // nothing changed.

BIO *bio2 = new BIO(BIO_s_mem()); // dynamic-allocate memory block
bio2->puts("hello"); // store "hello" into the memory block.

class BIO_socket: public BIO {
  public:
    BIO_socket(int sockfd, int close_flag); // BIO_new_socket()
    // manpage socket(2), type SOCK_STREAM
};

class BIO_dgram: public BIO {
  public:
    BIO_dgram(int fd, int close_flag);   
    // manpage socket(2), type SOCK_DGRAM
};

class BIO_connect: public BIO {
  public:
    BIO_connect(char *host_port);
    // manpage connect(2)
};

class BIO_accept: public BIO {
  public:
    BIO_accept(char *host_port);         
    // manpage accept(2)
};

// gcc -c bio_pseudo.cpp
#include <cstdio>
#include "bio.hpp"
#include "bio_file.hpp"
#include "bio_mem.hpp"

int foo(BIO *bio, const char *msg) {
    return bio->puts(msg);
}

int main() {
    BIO *bio1 = new BIO_file(stdin, BIO_NOCLOSE);
    BIO *bio2 = new BIO_file("/tmp/abc", "w");
    
    // dynamic allocate memory block.
    BIO_mem *bio3 = new BIO_mem();

    BIO *bio4 = new BIO_fd(1, BIO_NOCLOSE); // 1 is stdout

    foo(bio1, "bio1 say\n"); // put to screen
    foo(bio2, "bio2 say\n"); // put to file '/tmp/abc' 
    foo(bio3, "bio3 say\n"); // put to memory
    foo(bio4, "bio4 say\n"); // put to screen
    
    BIO_mem::BUF_MEM *mem_ptr = NULL;
    
    bio3->get_mem_ptr(&mem_ptr);
    printf("size of mem ptr: %d; max: %d; data: %s", 
        mem_ptr->length, mem_ptr->max, (char*)mem_ptr->data);
    
    return 0;
}

// gcc -lssl -o bio_example bio_example.c
#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>

int foo(BIO *bio, const char *msg) {
    return BIO_puts(bio, msg);
}

int main() {
    BIO *bio1 = BIO_new_fp(stdout, BIO_NOCLOSE);
    BIO *bio2 = BIO_new_file("/tmp/abc", "w");
    
    // dynamic allocate memory block.
    BIO *bio3 = BIO_new(BIO_s_mem());

    BIO *bio4 = BIO_new_fd(1, BIO_NOCLOSE);

    foo(bio1, "bio1 say\n"); // put to screen
    foo(bio2, "bio2 say\n"); // put to file '/tmp/abc' 
    foo(bio3, "bio3 say\n"); // put to memory
    foo(bio4, "bio4 say\n"); // put to screen
    
    BUF_MEM *mem_ptr = NULL;

    BIO_get_mem_ptr(bio3, &mem_ptr);
    printf("size of mem ptr: %d; max: %d; data: %s", 
        mem_ptr->length, mem_ptr->max, mem_ptr->data);

    return 0;
}

// gcc -lssl -o bio_base64 bio_base64.c
#include <openssl/bio.h>
#include <openssl/evp.h>

// program [input_filepath] [output_filepath]
// default behaviour is to read from stdin then write to stdout.
int main(int argc, char *argv[]) {
    BIO *bin, *bout, *b64filter;
    char buff[1024];
    int rc = 0;

    if (argc < 2)
        bin = BIO_new_fp(stdin, BIO_NOCLOSE);
    else
        bin = BIO_new_file(argv[1], "r");
    
    if (bin == NULL) {
        printf("Failed to open input file.\n");
        return 1;
    }

    if (argc > 2)
        bout = BIO_new_file(argv[2], "w");
    else
        bout = BIO_new_fp(stdout, BIO_NOCLOSE);

    if (bin == NULL) {
        printf("Failed to open output file.\n");
        return 1;
    }

    b64filter = BIO_new(BIO_f_base64());
    bout = BIO_push(b64filter, bout); // insert the filter.
    
    while ((rc = BIO_read(bin, buff, sizeof(buff))) > 0) {
        BIO_write(bout, buff, rc);
    }
    BIO_flush(bout);

    BIO_free_all(bout);
    BIO_free_all(bin);

    return 0;
}