crypto/bio/bss_bio.c

   1 /* crypto/bio/bss_bio.c  -*- Mode: C; c-file-style: "eay" -*- */
   2
   3 /* Special method for a BIO where the other endpoint is also a BIO
   4  * of this kind, handled by the same thread (i.e. the "peer" is actually
   5  * ourselves, wearing a different hat).
   6  * Such "BIO pairs" are mainly for using the SSL library with I/O interfaces
   7  * for which no specific BIO method is available.
   8  * See ssl/ssltest.c for some hints on how this can be used. */
   9
  10 #ifndef BIO_PAIR_DEBUG
  11 # undef NDEBUG /* avoid conflicting definitions */
  12 # define NDEBUG
  13 #endif
  14
  15 #include <assert.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include <openssl/bio.h>
  20 #include <openssl/err.h>
  21 #include <openssl/crypto.h>
  22
  23 static int bio_new(BIO *bio);
  24 static int bio_free(BIO *bio);
  25 static int bio_read(BIO *bio, char *buf, int size);
  26 static int bio_write(BIO *bio, char *buf, int num);
  27 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
  28 static int bio_puts(BIO *bio, char *str);
  29
  30 static int bio_make_pair(BIO *bio1, BIO *bio2);
  31 static void bio_destroy_pair(BIO *bio);
  32
  33 static BIO_METHOD methods_biop =
  34 {
  35         BIO_TYPE_BIO,
  36         "BIO pair",
  37         bio_write,
  38         bio_read,
  39         bio_puts,
  40         NULL /* no bio_gets */,
  41         bio_ctrl,
  42         bio_new,
  43         bio_free
  44 };
  45
  46 BIO_METHOD *BIO_s_bio(void)
  47         {
  48         return &methods_biop;
  49         }
  50
  51 struct bio_bio_st
  52 {
  53         BIO *peer;     /* NULL if buf == NULL.
  54                         * If peer != NULL, then peer->ptr is also a bio_bio_st,
  55                         * and its "peer" member points back to us.
  56                         * peer != NULL iff init != 0 in the BIO. */
  57
  58         /* This is for what we write (i.e. reading uses peer's struct): */
  59         int closed;     /* valid iff peer != NULL */
  60         size_t len;     /* valid iff buf != NULL; 0 if peer == NULL */
  61         size_t offset;  /* valid iff buf != NULL; 0 if len == 0 */
  62         size_t size;
  63         char *buf;      /* "size" elements (if != NULL) */
  64
  65         size_t request; /* valid iff peer != NULL; 0 if len != 0;
  66                          * otherwise set by peer to number of bytes
  67                          * it (unsuccesfully) tried to read. */
  68 };
  69
  70 static int bio_new(BIO *bio)
  71         {
  72         struct bio_bio_st *b;
  73
  74         b = Malloc(sizeof *b);
  75         if (b == NULL)
  76                 return 0;
  77
  78         b->peer = NULL;
  79         b->size = 17*1024; /* enough for one TLS record (just a default) */
  80         b->buf = NULL;
  81
  82         bio->ptr = b;
  83         return 1;
  84         }
  85
  86
  87 static int bio_free(BIO *bio)
  88         {
  89         struct bio_bio_st *b;
  90
  91         if (bio == NULL)
  92                 return 0;
  93         b = bio->ptr;
  94
  95         assert(b != NULL);
  96
  97         if (b->peer)
  98                 bio_destroy_pair(bio);
  99
 100         if (b->buf != NULL)
 101                 {
 102                 Free(b->buf);
 103                 }
 104
 105         Free(b);
 106
 107         return 1;
 108         }
 109
 110
 111
 112 static int bio_read(BIO *bio, char *buf, int size_)
 113         {
 114         size_t size = size_;
 115         size_t rest;
 116         struct bio_bio_st *b, *peer_b;
 117
 118         BIO_clear_retry_flags(bio);
 119
 120         if (!bio->init)
 121                 return 0;
 122
 123         b = bio->ptr;
 124         assert(b != NULL);
 125         assert(b->peer != NULL);
 126         peer_b = b->peer->ptr;
 127         assert(peer_b != NULL);
 128         assert(peer_b->buf != NULL);
 129
 130         peer_b->request = 0; /* will be set in "retry_read" situation */
 131
 132         if (buf == NULL || size == 0)
 133                 return 0;
 134
 135         if (peer_b->len == 0)
 136                 {
 137                 if (peer_b->closed)
 138                         return 0; /* writer has closed, and no data is left */
 139                 else
 140                         {
 141                         BIO_set_retry_read(bio); /* buffer is empty */
 142                         if (size <= peer_b->size)
 143                                 peer_b->request = size;
 144                         else
 145                                 peer_b->request = peer_b->size; /* don't ask for more than
 146                                                                  * the peer can deliver
 147                                                                  * in one write */
 148                         return -1;
 149                         }
 150                 }
 151
 152         /* we can read */
 153         if (peer_b->len < size)
 154                 size = peer_b->len;
 155
 156         /* now read "size" bytes */
 157
 158         rest = size;
 159
 160         assert(rest > 0);
 161         do /* one or two iterations */
 162                 {
 163                 size_t chunk;
 164
 165                 assert(rest <= peer_b->len);
 166                 if (peer_b->offset + rest <= peer_b->size)
 167                         chunk = rest;
 168                 else
 169                         /* wrap around ring buffer */
 170                         chunk = peer_b->size - peer_b->offset;
 171                 assert(peer_b->offset + chunk <= peer_b->size);
 172
 173                 memcpy(buf, peer_b->buf + peer_b->offset, chunk);
 174
 175                 peer_b->len -= chunk;
 176                 if (peer_b->len)
 177                         {
 178                         peer_b->offset += chunk;
 179                         assert(peer_b->offset <= peer_b->size);
 180                         if (peer_b->offset == peer_b->size)
 181                                 peer_b->offset = 0;
 182                         buf += chunk;
 183                         }
 184                 else
 185                         {
 186                         /* buffer now empty, no need to advance "buf" */
 187                         assert(chunk == rest);
 188                         peer_b->offset = 0;
 189                         }
 190                 rest -= chunk;
 191                 }
 192         while (rest);
 193
 194         return size;
 195         }
 196
 197 static int bio_write(BIO *bio, char *buf, int num_)
 198         {
 199         size_t num = num_;
 200         size_t rest;
 201         struct bio_bio_st *b;
 202
 203         BIO_clear_retry_flags(bio);
 204
 205         if (!bio->init || buf == NULL || num == 0)
 206                 return 0;
 207
 208         b = bio->ptr;
 209         assert(b != NULL);
 210         assert(b->peer != NULL);
 211         assert(b->buf != NULL);
 212
 213         b->request = 0;
 214         if (b->closed)
 215                 {
 216                 /* we already closed */
 217                 BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE);
 218                 return -1;
 219                 }
 220
 221         assert(b->len <= b->size);
 222
 223         if (b->len == b->size)
 224                 {
 225                 BIO_set_retry_write(bio); /* buffer is full */
 226                 return -1;
 227                 }
 228
 229         /* we can write */
 230         if (num > b->size - b->len)
 231                 num = b->size - b->len;
 232
 233         /* now write "num" bytes */
 234
 235         rest = num;
 236
 237         assert(rest > 0);
 238         do /* one or two iterations */
 239                 {
 240                 size_t write_offset;
 241                 size_t chunk;
 242
 243                 assert(b->len + rest <= b->size);
 244
 245                 write_offset = b->offset + b->len;
 246                 if (write_offset >= b->size)
 247                         write_offset -= b->size;
 248                 /* b->buf[write_offset] is the first byte we can write to. */
 249
 250                 if (write_offset + rest <= b->size)
 251                         chunk = rest;
 252                 else
 253                         /* wrap around ring buffer */
 254                         chunk = b->size - write_offset;
 255
 256                 memcpy(b->buf + write_offset, buf, chunk);
 257
 258                 b->len += chunk;
 259
 260                 assert(b->len <= b->size);
 261
 262                 rest -= chunk;
 263                 buf += chunk;
 264                 }
 265         while (rest);
 266
 267         return num;
 268         }
 269
 270
 271 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
 272         {
 273         long ret;
 274         struct bio_bio_st *b = bio->ptr;
 275
 276         assert(b != NULL);
 277
 278         switch (cmd)
 279                 {
 280         /* specific CTRL codes */
 281
 282         case BIO_C_SET_WRITE_BUF_SIZE:
 283                 if (b->peer)
 284                         {
 285                         BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE);
 286                         ret = 0;
 287                         }
 288                 else if (num == 0)
 289                         {
 290                         BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT);
 291                         ret = 0;
 292                         }
 293                 else
 294                         {
 295                         size_t new_size = num;
 296
 297                         if (b->size != new_size)
 298                                 {
 299                                 if (b->buf)
 300                                         {
 301                                         Free(b->buf);
 302                                         b->buf = NULL;
 303                                         }
 304                                 b->size = new_size;
 305                                 }
 306                         ret = 1;
 307                         }
 308                 break;
 309
 310         case BIO_C_GET_WRITE_BUF_SIZE:
 311                 num = (long) b->size;
 312
 313         case BIO_C_MAKE_BIO_PAIR:
 314                 {
 315                 BIO *other_bio = ptr;
 316
 317                 if (bio_make_pair(bio, other_bio))
 318                         ret = 1;
 319                 else
 320                         ret = 0;
 321                 }
 322                 break;
 323
 324         case BIO_C_DESTROY_BIO_PAIR:
 325                 /* Effects both BIOs in the pair -- call just once!
 326                  * Or let BIO_free(bio1); BIO_free(bio2); do the job. */
 327                 bio_destroy_pair(bio);
 328                 ret = 1;
 329                 break;
 330
 331         case BIO_C_GET_WRITE_GUARANTEE:
 332                 /* How many bytes can the caller feed to the next write
 333                  * withouth having to keep any? */
 334                 if (b->peer == NULL || b->closed)
 335                         ret = 0;
 336                 else
 337                         ret = (long) b->size - b->len;
 338                 break;
 339
 340         case BIO_C_GET_READ_REQUEST:
 341                 /* If the peer unsuccesfully tried to read, how many bytes
 342                  * were requested?  (As with BIO_CTRL_PENDING, that number
 343                  * can usually be treated as boolean.) */
 344                 ret = (long) b->request;
 345                 break;
 346
 347         case BIO_C_SHUTDOWN_WR:
 348                 /* similar to shutdown(..., SHUT_WR) */
 349                 b->closed = 1;
 350                 ret = 1;
 351                 break;
 352
 353
 354         /* standard CTRL codes follow */
 355
 356         case BIO_CTRL_RESET:
 357                 if (b->buf != NULL)
 358                         {
 359                         b->len = 0;
 360                         b->offset = 0;
 361                         }
 362                 ret = 0;
 363                 break;
 364
 365         case BIO_CTRL_GET_CLOSE:
 366                 ret = bio->shutdown;
 367                 break;
 368
 369         case BIO_CTRL_SET_CLOSE:
 370                 bio->shutdown = (int) num;
 371                 ret = 1;
 372                 break;
 373
 374         case BIO_CTRL_PENDING:
 375                 if (b->peer != NULL)
 376                         {
 377                         struct bio_bio_st *peer_b = b->peer->ptr;
 378
 379                         ret = (long) peer_b->len;
 380                         }
 381                 else
 382                         ret = 0;
 383                 break;
 384
 385         case BIO_CTRL_WPENDING:
 386                 if (b->buf != NULL)
 387                         ret = (long) b->len;
 388                 else
 389                         ret = 0;
 390                 break;
 391
 392         case BIO_CTRL_DUP:
 393                 /* See BIO_dup_chain for circumstances we have to expect. */
 394                 {
 395                 BIO *other_bio = ptr;
 396                 struct bio_bio_st *other_b;
 397
 398                 assert(other_bio != NULL);
 399                 other_b = other_bio->ptr;
 400                 assert(other_b != NULL);
 401
 402                 assert(other_b->buf == NULL); /* other_bio is always fresh */
 403
 404                 other_b->size = b->size;
 405                 }
 406
 407                 ret = 1;
 408                 break;
 409
 410         case BIO_CTRL_FLUSH:
 411                 ret = 1;
 412                 break;
 413
 414         case BIO_CTRL_EOF:
 415                 {
 416                 BIO *other_bio = ptr;
 417
 418                 if (other_bio)
 419                         {
 420                         struct bio_bio_st *other_b = other_bio->ptr;
 421
 422                         assert(other_b != NULL);
 423                         ret = other_b->len == 0 && other_b->closed;
 424                         }
 425                 else
 426                         ret = 1;
 427                 }
 428                 break;
 429
 430         default:
 431                 ret = 0;
 432                 }
 433         return ret;
 434         }
 435
 436 static int bio_puts(BIO *bio, char *str)
 437         {
 438         return bio_write(bio, str, strlen(str));
 439         }
 440
 441
 442 static int bio_make_pair(BIO *bio1, BIO *bio2)
 443         {
 444         struct bio_bio_st *b1, *b2;
 445
 446         assert(bio1 != NULL);
 447         assert(bio2 != NULL);
 448
 449         b1 = bio1->ptr;
 450         b2 = bio2->ptr;
 451
 452         if (b1->peer != NULL || b2->peer != NULL)
 453                 {
 454                 BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE);
 455                 return 0;
 456                 }
 457
 458         if (b1->buf == NULL)
 459                 {
 460                 b1->buf = Malloc(b1->size);
 461                 if (b1->buf == NULL)
 462                         {
 463                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
 464                         return 0;
 465                         }
 466                 b1->len = 0;
 467                 b1->offset = 0;
 468                 }
 469
 470         if (b2->buf == NULL)
 471                 {
 472                 b2->buf = Malloc(b2->size);
 473                 if (b2->buf == NULL)
 474                         {
 475                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
 476                         return 0;
 477                         }
 478                 b2->len = 0;
 479                 b2->offset = 0;
 480                 }
 481
 482         b1->peer = bio2;
 483         b1->closed = 0;
 484         b1->request = 0;
 485         b2->peer = bio1;
 486         b2->closed = 0;
 487         b2->request = 0;
 488
 489         bio1->init = 1;
 490         bio2->init = 1;
 491
 492         return 1;
 493         }
 494
 495 static void bio_destroy_pair(BIO *bio)
 496         {
 497         struct bio_bio_st *b = bio->ptr;
 498
 499         if (b != NULL)
 500                 {
 501                 BIO *peer_bio = b->peer;
 502
 503                 if (peer_bio != NULL)
 504                         {
 505                         struct bio_bio_st *peer_b = peer_bio->ptr;
 506
 507                         assert(peer_b != NULL);
 508                         assert(peer_b->peer == bio);
 509
 510                         peer_b->peer = NULL;
 511                         peer_bio->init = 0;
 512                         assert(peer_b->buf != NULL);
 513                         peer_b->len = 0;
 514                         peer_b->offset = 0;
 515
 516                         b->peer = NULL;
 517                         bio->init = 0;
 518                         assert(b->buf != NULL);
 519                         b->len = 0;
 520                         b->offset = 0;
 521                         }
 522                 }
 523         }
 524
 525
 526 /* Exported convenience functions */
 527 int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1,
 528         BIO **bio2_p, size_t writebuf2)
 529          {
 530          BIO *bio1 = NULL, *bio2 = NULL;
 531          long r;
 532          int ret = 0;
 533
 534          bio1 = BIO_new(BIO_s_bio());
 535          if (bio1 == NULL)
 536                  goto err;
 537          bio2 = BIO_new(BIO_s_bio());
 538          if (bio2 == NULL)
 539                  goto err;
 540
 541          if (writebuf1)
 542                  {
 543                  r = BIO_set_write_buf_size(bio1, writebuf1);
 544                  if (!r)
 545                          goto err;
 546                  }
 547          if (writebuf2)
 548                  {
 549                  r = BIO_set_write_buf_size(bio2, writebuf2);
 550                  if (!r)
 551                          goto err;
 552                  }
 553
 554          r = BIO_make_bio_pair(bio1, bio2);
 555          if (!r)
 556                  goto err;
 557          ret = 1;
 558
 559  err:
 560          if (ret == 0)
 561                  {
 562                  if (bio1)
 563                          {
 564                          BIO_free(bio1);
 565                          bio1 = NULL;
 566                          }
 567                  if (bio2)
 568                          {
 569                          BIO_free(bio2);
 570                          bio2 = NULL;
 571                          }
 572                  }
 573
 574          *bio1_p = bio1;
 575          *bio2_p = bio2;
 576          return ret;
 577          }
 578
 579 size_t BIO_ctrl_get_write_guarantee(BIO *bio)
 580     {
 581         return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL);
 582         }
 583
 584 size_t BIO_ctrl_get_read_request(BIO *bio)
 585     {
 586         return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
 587         }