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