contrib/pgcrypto/mbuf.c

   1 /*
   2  * mbuf.c
   3  *              Memory buffer operations.
   4  *
   5  * Copyright (c) 2005 Marko Kreen
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *        notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *        notice, this list of conditions and the following disclaimer in the
  15  *        documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.      IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $PostgreSQL$
  30  */
  31
  32 #include "postgres.h"
  33
  34 #include "px.h"
  35 #include "mbuf.h"
  36
  37 #define STEP  (16*1024)
  38
  39 struct MBuf
  40 {
  41         uint8      *data;
  42         uint8      *data_end;
  43         uint8      *read_pos;
  44         uint8      *buf_end;
  45         bool            no_write;
  46         bool            own_data;
  47 };
  48
  49 int
  50 mbuf_avail(MBuf * mbuf)
  51 {
  52         return mbuf->data_end - mbuf->read_pos;
  53 }
  54
  55 int
  56 mbuf_size(MBuf * mbuf)
  57 {
  58         return mbuf->data_end - mbuf->data;
  59 }
  60
  61 int
  62 mbuf_tell(MBuf * mbuf)
  63 {
  64         return mbuf->read_pos - mbuf->data;
  65 }
  66
  67 int
  68 mbuf_free(MBuf * mbuf)
  69 {
  70         if (mbuf->own_data)
  71         {
  72                 memset(mbuf->data, 0, mbuf->buf_end - mbuf->data);
  73                 px_free(mbuf->data);
  74         }
  75         px_free(mbuf);
  76         return 0;
  77 }
  78
  79 static void
  80 prepare_room(MBuf * mbuf, int block_len)
  81 {
  82         uint8      *newbuf;
  83         unsigned        newlen;
  84
  85         if (mbuf->data_end + block_len <= mbuf->buf_end)
  86                 return;
  87
  88         newlen = (mbuf->buf_end - mbuf->data)
  89                 + ((block_len + STEP + STEP - 1) & -STEP);
  90
  91         newbuf = px_realloc(mbuf->data, newlen);
  92
  93         mbuf->buf_end = newbuf + newlen;
  94         mbuf->data_end = newbuf + (mbuf->data_end - mbuf->data);
  95         mbuf->read_pos = newbuf + (mbuf->read_pos - mbuf->data);
  96         mbuf->data = newbuf;
  97
  98         return;
  99 }
 100
 101 int
 102 mbuf_append(MBuf * dst, const uint8 *buf, int len)
 103 {
 104         if (dst->no_write)
 105         {
 106                 px_debug("mbuf_append: no_write");
 107                 return PXE_BUG;
 108         }
 109
 110         prepare_room(dst, len);
 111
 112         memcpy(dst->data_end, buf, len);
 113         dst->data_end += len;
 114
 115         return 0;
 116 }
 117
 118 MBuf *
 119 mbuf_create(int len)
 120 {
 121         MBuf       *mbuf;
 122
 123         if (!len)
 124                 len = 8192;
 125
 126         mbuf = px_alloc(sizeof *mbuf);
 127         mbuf->data = px_alloc(len);
 128         mbuf->buf_end = mbuf->data + len;
 129         mbuf->data_end = mbuf->data;
 130         mbuf->read_pos = mbuf->data;
 131
 132         mbuf->no_write = false;
 133         mbuf->own_data = true;
 134
 135         return mbuf;
 136 }
 137
 138 MBuf *
 139 mbuf_create_from_data(const uint8 *data, int len)
 140 {
 141         MBuf       *mbuf;
 142
 143         mbuf = px_alloc(sizeof *mbuf);
 144         mbuf->data = (uint8 *) data;
 145         mbuf->buf_end = mbuf->data + len;
 146         mbuf->data_end = mbuf->data + len;
 147         mbuf->read_pos = mbuf->data;
 148
 149         mbuf->no_write = true;
 150         mbuf->own_data = false;
 151
 152         return mbuf;
 153 }
 154
 155
 156 int
 157 mbuf_grab(MBuf * mbuf, int len, uint8 **data_p)
 158 {
 159         if (len > mbuf_avail(mbuf))
 160                 len = mbuf_avail(mbuf);
 161
 162         mbuf->no_write = true;
 163
 164         *data_p = mbuf->read_pos;
 165         mbuf->read_pos += len;
 166         return len;
 167 }
 168
 169 int
 170 mbuf_rewind(MBuf * mbuf)
 171 {
 172         mbuf->read_pos = mbuf->data;
 173         return 0;
 174 }
 175
 176 int
 177 mbuf_steal_data(MBuf * mbuf, uint8 **data_p)
 178 {
 179         int                     len = mbuf_size(mbuf);
 180
 181         mbuf->no_write = true;
 182         mbuf->own_data = false;
 183
 184         *data_p = mbuf->data;
 185
 186         mbuf->data = mbuf->data_end = mbuf->read_pos = mbuf->buf_end = NULL;
 187
 188         return len;
 189 }
 190
 191 /*
 192  * PullFilter
 193  */
 194
 195 struct PullFilter
 196 {
 197         PullFilter *src;
 198         const PullFilterOps *op;
 199         int                     buflen;
 200         uint8      *buf;
 201         int                     pos;
 202         void       *priv;
 203 };
 204
 205 int
 206 pullf_create(PullFilter ** pf_p, const PullFilterOps * op, void *init_arg, PullFilter * src)
 207 {
 208         PullFilter *pf;
 209         void       *priv;
 210         int                     res;
 211
 212         if (op->init != NULL)
 213         {
 214                 res = op->init(&priv, init_arg, src);
 215                 if (res < 0)
 216                         return res;
 217         }
 218         else
 219         {
 220                 priv = init_arg;
 221                 res = 0;
 222         }
 223
 224         pf = px_alloc(sizeof(*pf));
 225         memset(pf, 0, sizeof(*pf));
 226         pf->buflen = res;
 227         pf->op = op;
 228         pf->priv = priv;
 229         pf->src = src;
 230         if (pf->buflen > 0)
 231         {
 232                 pf->buf = px_alloc(pf->buflen);
 233                 pf->pos = 0;
 234         }
 235         else
 236         {
 237                 pf->buf = NULL;
 238                 pf->pos = 0;
 239         }
 240         *pf_p = pf;
 241         return 0;
 242 }
 243
 244 void
 245 pullf_free(PullFilter * pf)
 246 {
 247         if (pf->op->free)
 248                 pf->op->free(pf->priv);
 249
 250         if (pf->buf)
 251         {
 252                 memset(pf->buf, 0, pf->buflen);
 253                 px_free(pf->buf);
 254         }
 255
 256         memset(pf, 0, sizeof(*pf));
 257         px_free(pf);
 258 }
 259
 260 /* may return less data than asked, 0 means eof */
 261 int
 262 pullf_read(PullFilter * pf, int len, uint8 **data_p)
 263 {
 264         int                     res;
 265
 266         if (pf->op->pull)
 267         {
 268                 if (pf->buflen && len > pf->buflen)
 269                         len = pf->buflen;
 270                 res = pf->op->pull(pf->priv, pf->src, len, data_p,
 271                                                    pf->buf, pf->buflen);
 272         }
 273         else
 274                 res = pullf_read(pf->src, len, data_p);
 275         return res;
 276 }
 277
 278 int
 279 pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
 280 {
 281         int                     res,
 282                                 total;
 283         uint8      *tmp;
 284
 285         res = pullf_read(pf, len, data_p);
 286         if (res <= 0 || res == len)
 287                 return res;
 288
 289         /* read was shorter, use tmpbuf */
 290         memcpy(tmpbuf, *data_p, res);
 291         *data_p = tmpbuf;
 292         len -= res;
 293         total = res;
 294
 295         while (len > 0)
 296         {
 297                 res = pullf_read(pf, len, &tmp);
 298                 if (res < 0)
 299                 {
 300                         /* so the caller must clear only on success */
 301                         memset(tmpbuf, 0, total);
 302                         return res;
 303                 }
 304                 if (res == 0)
 305                         break;
 306                 memcpy(tmpbuf + total, tmp, res);
 307                 total += res;
 308         }
 309         return total;
 310 }
 311
 312 /*
 313  * caller wants exatly len bytes and dont bother with references
 314  */
 315 int
 316 pullf_read_fixed(PullFilter * src, int len, uint8 *dst)
 317 {
 318         int                     res;
 319         uint8      *p;
 320
 321         res = pullf_read_max(src, len, &p, dst);
 322         if (res < 0)
 323                 return res;
 324         if (res != len)
 325         {
 326                 px_debug("pullf_read_fixed: need=%d got=%d", len, res);
 327                 return PXE_MBUF_SHORT_READ;
 328         }
 329         if (p != dst)
 330                 memcpy(dst, p, len);
 331         return 0;
 332 }
 333
 334 /*
 335  * read from MBuf
 336  */
 337 static int
 338 pull_from_mbuf(void *arg, PullFilter * src, int len,
 339                            uint8 **data_p, uint8 *buf, int buflen)
 340 {
 341         MBuf       *mbuf = arg;
 342
 343         return mbuf_grab(mbuf, len, data_p);
 344 }
 345
 346 static const struct PullFilterOps mbuf_reader = {
 347         NULL, pull_from_mbuf, NULL
 348 };
 349
 350 int
 351 pullf_create_mbuf_reader(PullFilter ** mp_p, MBuf * src)
 352 {
 353         return pullf_create(mp_p, &mbuf_reader, src, NULL);
 354 }
 355
 356
 357 /*
 358  * PushFilter
 359  */
 360
 361 struct PushFilter
 362 {
 363         PushFilter *next;
 364         const PushFilterOps *op;
 365         int                     block_size;
 366         uint8      *buf;
 367         int                     pos;
 368         void       *priv;
 369 };
 370
 371 int
 372 pushf_create(PushFilter ** mp_p, const PushFilterOps * op, void *init_arg, PushFilter * next)
 373 {
 374         PushFilter *mp;
 375         void       *priv;
 376         int                     res;
 377
 378         if (op->init != NULL)
 379         {
 380                 res = op->init(next, init_arg, &priv);
 381                 if (res < 0)
 382                         return res;
 383         }
 384         else
 385         {
 386                 priv = init_arg;
 387                 res = 0;
 388         }
 389
 390         mp = px_alloc(sizeof(*mp));
 391         memset(mp, 0, sizeof(*mp));
 392         mp->block_size = res;
 393         mp->op = op;
 394         mp->priv = priv;
 395         mp->next = next;
 396         if (mp->block_size > 0)
 397         {
 398                 mp->buf = px_alloc(mp->block_size);
 399                 mp->pos = 0;
 400         }
 401         else
 402         {
 403                 mp->buf = NULL;
 404                 mp->pos = 0;
 405         }
 406         *mp_p = mp;
 407         return 0;
 408 }
 409
 410 void
 411 pushf_free(PushFilter * mp)
 412 {
 413         if (mp->op->free)
 414                 mp->op->free(mp->priv);
 415
 416         if (mp->buf)
 417         {
 418                 memset(mp->buf, 0, mp->block_size);
 419                 px_free(mp->buf);
 420         }
 421
 422         memset(mp, 0, sizeof(*mp));
 423         px_free(mp);
 424 }
 425
 426 void
 427 pushf_free_all(PushFilter * mp)
 428 {
 429         PushFilter *tmp;
 430
 431         while (mp)
 432         {
 433                 tmp = mp->next;
 434                 pushf_free(mp);
 435                 mp = tmp;
 436         }
 437 }
 438
 439 static int
 440 wrap_process(PushFilter * mp, const uint8 *data, int len)
 441 {
 442         int                     res;
 443
 444         if (mp->op->push != NULL)
 445                 res = mp->op->push(mp->next, mp->priv, data, len);
 446         else
 447                 res = pushf_write(mp->next, data, len);
 448         if (res > 0)
 449                 return PXE_BUG;
 450         return res;
 451 }
 452
 453 /* consumes all data, returns len on success */
 454 int
 455 pushf_write(PushFilter * mp, const uint8 *data, int len)
 456 {
 457         int                     need,
 458                                 res;
 459
 460         /*
 461          * no buffering
 462          */
 463         if (mp->block_size <= 0)
 464                 return wrap_process(mp, data, len);
 465
 466         /*
 467          * try to empty buffer
 468          */
 469         need = mp->block_size - mp->pos;
 470         if (need > 0)
 471         {
 472                 if (len < need)
 473                 {
 474                         memcpy(mp->buf + mp->pos, data, len);
 475                         mp->pos += len;
 476                         return 0;
 477                 }
 478                 memcpy(mp->buf + mp->pos, data, need);
 479                 len -= need;
 480                 data += need;
 481         }
 482
 483         /*
 484          * buffer full, process
 485          */
 486         res = wrap_process(mp, mp->buf, mp->block_size);
 487         if (res < 0)
 488                 return res;
 489         mp->pos = 0;
 490
 491         /*
 492          * now process directly from data
 493          */
 494         while (len > 0)
 495         {
 496                 if (len > mp->block_size)
 497                 {
 498                         res = wrap_process(mp, data, mp->block_size);
 499                         if (res < 0)
 500                                 return res;
 501                         data += mp->block_size;
 502                         len -= mp->block_size;
 503                 }
 504                 else
 505                 {
 506                         memcpy(mp->buf, data, len);
 507                         mp->pos += len;
 508                         break;
 509                 }
 510         }
 511         return 0;
 512 }
 513
 514 int
 515 pushf_flush(PushFilter * mp)
 516 {
 517         int                     res;
 518
 519         while (mp)
 520         {
 521                 if (mp->block_size > 0)
 522                 {
 523                         res = wrap_process(mp, mp->buf, mp->pos);
 524                         if (res < 0)
 525                                 return res;
 526                 }
 527
 528                 if (mp->op->flush)
 529                 {
 530                         res = mp->op->flush(mp->next, mp->priv);
 531                         if (res < 0)
 532                                 return res;
 533                 }
 534
 535                 mp = mp->next;
 536         }
 537         return 0;
 538 }
 539
 540
 541 /*
 542  * write to MBuf
 543  */
 544 static int
 545 push_into_mbuf(PushFilter * next, void *arg, const uint8 *data, int len)
 546 {
 547         int                     res = 0;
 548         MBuf       *mbuf = arg;
 549
 550         if (len > 0)
 551                 res = mbuf_append(mbuf, data, len);
 552         return res < 0 ? res : 0;
 553 }
 554
 555 static const struct PushFilterOps mbuf_filter = {
 556         NULL, push_into_mbuf, NULL, NULL
 557 };
 558
 559 int
 560 pushf_create_mbuf_writer(PushFilter ** res, MBuf * dst)
 561 {
 562         return pushf_create(res, &mbuf_filter, dst, NULL);
 563 }