mono/btls/btls-bio.c

   1 //
   2 //  btls-bio.c
   3 //  MonoBtls
   4 //
   5 //  Created by Martin Baulig on 14/11/15.
   6 //  Copyright (c) 2015 Xamarin. All rights reserved.
   7 //
   8
   9 #include "btls-ssl.h"
  10 #include "btls-bio.h"
  11 #include "../utils/mono-errno.h"
  12 #include <errno.h>
  13
  14 struct MonoBtlsBio {
  15         const void *instance;
  16         MonoBtlsReadFunc read_func;
  17         MonoBtlsWriteFunc write_func;
  18         MonoBtlsControlFunc control_func;
  19 };
  20
  21 #if 0
  22 static void
  23 mono_debug (const char *message)
  24 {
  25         BIO *bio_err;
  26         bio_err = BIO_new_fp (stderr, BIO_NOCLOSE);
  27         fprintf (stderr, "DEBUG: %s\n", message);
  28         ERR_print_errors (bio_err);
  29 }
  30 #endif
  31
  32 static int
  33 mono_read (BIO *bio, char *out, int outl)
  34 {
  35         MonoBtlsBio *mono = (MonoBtlsBio *)bio->ptr;
  36         int ret, wantMore;
  37
  38         if (!mono)
  39                 return -1;
  40
  41         ret = mono->read_func (mono->instance, out, outl, &wantMore);
  42
  43         if (ret < 0) {
  44                 mono_set_errno (EIO);
  45                 return -1;
  46         }
  47         if (ret > 0)
  48                 return ret;
  49
  50         if (wantMore) {
  51                 mono_set_errno (EAGAIN);
  52                 BIO_set_retry_read (bio);
  53                 return -1;
  54         }
  55
  56         return 0;
  57 }
  58
  59 static int
  60 mono_write (BIO *bio, const char *in, int inl)
  61 {
  62         MonoBtlsBio *mono = (MonoBtlsBio *)bio->ptr;
  63
  64         if (!mono)
  65                 return -1;
  66
  67         return mono->write_func (mono->instance, in, inl);
  68 }
  69
  70 static long
  71 mono_ctrl (BIO *bio, int cmd, long num, void *ptr)
  72 {
  73         MonoBtlsBio *mono = (MonoBtlsBio *)bio->ptr;
  74
  75         if (!mono)
  76                 return -1;
  77
  78         // fprintf (stderr, "mono_ctrl: %x - %lx - %p\n", cmd, num, ptr);
  79         switch (cmd) {
  80                 case BIO_CTRL_FLUSH:
  81                         return (long)mono->control_func (mono->instance, MONO_BTLS_CONTROL_COMMAND_FLUSH, 0);
  82                 default:
  83                         return -1;
  84         }
  85         return -1;
  86 }
  87
  88 static int
  89 mono_new (BIO *bio)
  90 {
  91         // mono_debug("mono_new!\n");
  92         bio->init = 0;
  93         bio->num = -1;
  94         bio->flags = 0;
  95         return 1;
  96 }
  97
  98 static int
  99 mono_free (BIO *bio)
 100 {
 101         // mono_debug ("mono_free!\n");
 102         if (bio->ptr) {
 103                 MonoBtlsBio *mono = (MonoBtlsBio *)bio->ptr;
 104
 105                 bio->ptr = NULL;
 106                 mono->instance = NULL;
 107                 mono->read_func = NULL;
 108                 mono->write_func = NULL;
 109                 mono->control_func = NULL;
 110                 free (mono);
 111         }
 112         return 1;
 113 }
 114
 115 static const BIO_METHOD mono_method = {
 116         BIO_TYPE_NONE, "mono", mono_write, mono_read,
 117         NULL, NULL, mono_ctrl, mono_new, mono_free, NULL
 118 };
 119
 120 BIO *
 121 mono_btls_bio_mono_new (void)
 122 {
 123         BIO *bio;
 124         MonoBtlsBio *monoBio;
 125
 126         bio = BIO_new (&mono_method);
 127         if (!bio)
 128                 return NULL;
 129
 130         monoBio = calloc (1, sizeof (MonoBtlsBio));
 131         if (!monoBio) {
 132                 BIO_free (bio);
 133                 return NULL;
 134         }
 135
 136         bio->ptr = monoBio;
 137         bio->init = 0;
 138
 139         return bio;
 140 }
 141
 142 void
 143 mono_btls_bio_mono_initialize (BIO *bio, const void *instance,
 144                               MonoBtlsReadFunc read_func, MonoBtlsWriteFunc write_func,
 145                               MonoBtlsControlFunc control_func)
 146 {
 147         MonoBtlsBio *monoBio = bio->ptr;
 148
 149         monoBio->instance = instance;
 150         monoBio->read_func = read_func;
 151         monoBio->write_func = write_func;
 152         monoBio->control_func = control_func;
 153
 154         bio->init = 1;
 155 }
 156
 157 int
 158 mono_btls_bio_read (BIO *bio, void *data, int len)
 159 {
 160         return BIO_read (bio, data, len);
 161 }
 162
 163 int
 164 mono_btls_bio_write (BIO *bio, const void *data, int len)
 165 {
 166         return BIO_write (bio, data, len);
 167 }
 168
 169 int
 170 mono_btls_bio_flush (BIO *bio)
 171 {
 172         return BIO_flush (bio);
 173 }
 174
 175 int
 176 mono_btls_bio_indent (BIO *bio, unsigned indent, unsigned max_indent)
 177 {
 178         return BIO_indent (bio, indent, max_indent);
 179 }
 180
 181 int
 182 mono_btls_bio_hexdump (BIO *bio, const uint8_t *data, int len, unsigned indent)
 183 {
 184         return BIO_hexdump (bio, data, len, indent);
 185 }
 186
 187 void
 188 mono_btls_bio_print_errors (BIO *bio)
 189 {
 190         BIO_print_errors (bio);
 191 }
 192
 193 void
 194 mono_btls_bio_free (BIO *bio)
 195 {
 196         BIO_free (bio);
 197 }
 198
 199 BIO *
 200 mono_btls_bio_mem_new (void)
 201 {
 202         return BIO_new (BIO_s_mem ());
 203 }
 204
 205 int
 206 mono_btls_bio_mem_get_data (BIO *bio, void **data)
 207 {
 208         return (int)BIO_get_mem_data (bio, (char**)data);
 209 }