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