cdsa/cdsa_utilities/streams.cpp

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 //
  20 // streams.h - lightweight source and sink objects
  21 //
  22 #include "streams.h"
  23 #include <Security/memutils.h>
  24
  25
  26 namespace Security {
  27
  28
  29 //
  30 // Source and Sink abstract superclasses
  31 //
  32 Source::State Source::state() const
  33 {
  34     return mState;
  35 }
  36
  37 size_t Source::getSize()
  38 {
  39     return unknownSize;
  40 }
  41
  42 void Sink::setSize(size_t)
  43 {
  44     // ignored
  45 }
  46
  47
  48 //
  49 // Null sources and sinks
  50 //
  51 void NullSource::produce(void *, size_t &length)
  52 {
  53     length = 0;
  54 }
  55
  56 Source::State NullSource::state() const
  57 {
  58     return endOfData;
  59 }
  60
  61 void NullSink::consume(const void *, size_t)
  62 {
  63     // ignore the data
  64 }
  65
  66
  67 //
  68 // File sources and sinks
  69 //
  70 void FileSource::produce(void *data, size_t &length)
  71 {
  72     if ((length = read(data, length)) == 0)
  73         mState = endOfData;
  74 }
  75
  76 size_t FileSource::getSize()
  77 {
  78     return fileSize();
  79 }
  80
  81
  82 void FileSink::consume(const void *data, size_t length)
  83 {
  84         write(data, length);
  85 }
  86
  87
  88 //
  89 // Memory sources
  90 //
  91 void MemorySource::produce(void *data, size_t &length)
  92 {
  93     if (mRemaining < length)
  94         length = mRemaining;
  95     memcpy(data, mData, length);
  96     mData = LowLevelMemoryUtilities::increment(mData, length);
  97     mRemaining -= length;
  98 }
  99
 100 size_t MemorySource::getSize()
 101 {
 102     return mRemaining;
 103 }
 104
 105 Source::State MemorySource::state() const
 106 {
 107     return mRemaining ? producing : endOfData;
 108 }
 109
 110
 111 //
 112 // Memory sinks
 113 //
 114 void MemorySink::consume(const void *data, size_t length)
 115 {
 116     if (mSize + length > mMax)
 117         grow(mSize * 3 / 2);
 118     assert(mSize + length <= mMax);
 119     memcpy(((char *)mBuffer) + mSize, data, length);
 120     mSize += length;
 121 }
 122
 123 void MemorySink::setSize(size_t expectedSize)
 124 {
 125     grow(expectedSize);
 126 }
 127
 128 void MemorySink::grow(size_t newSize)
 129 {
 130     if (void *p = realloc(mBuffer, newSize)) {
 131         mBuffer = p;
 132         mMax = newSize;
 133     } else
 134         UnixError::throwMe();
 135 }
 136
 137
 138 }       // end namespace Security