Security-57031.1.35.tar.gz

[apple/security.git] / certificates / ota_cert_tool / ios_ota_cert_tool / CommonBuffering.c

diff --git a/certificates/ota_cert_tool/ios_ota_cert_tool/CommonBuffering.c b/certificates/ota_cert_tool/ios_ota_cert_tool/CommonBuffering.c
new file mode 100644 (file)
index 0000000..76b4769
--- /dev/null
+++ b/certificates/ota_cert_tool/ios_ota_cert_tool/CommonBuffering.c
@@ -0,0 +1,114 @@
+//
+//  CommonBuffering.c
+//  CommonCrypto
+//
+
+#include <stdio.h>
+#include "ccMemory.h"
+#include "CommonBufferingPriv.h"
+#include <AssertMacros.h>
+
+
+CNBufferRef
+CNBufferCreate(size_t chunksize)
+{
+    CNBufferRef retval = CC_XMALLOC(sizeof(CNBuffer));
+    __Require_Quiet(NULL != retval, errOut);
+    retval->chunksize = chunksize;
+    retval->bufferPos = 0;
+    retval->buf = CC_XMALLOC(chunksize);
+    __Require_Quiet(NULL != retval->buf, errOut);
+    return retval;
+    
+errOut:
+    if(retval) {
+        if(retval->buf) CC_XFREE(retval->buf, chunksize);
+        CC_XFREE(retval, sizeof(CNBuffer));
+    }
+    return NULL;
+}
+
+CNStatus
+CNBufferRelease(CNBufferRef *bufRef)
+{
+    CNBufferRef ref;
+    
+    __Require_Quiet(NULL != bufRef, out);
+    ref = *bufRef;
+    if(ref->buf) CC_XFREE(ref->buf, chunksize);
+    if(ref) CC_XFREE(ref, sizeof(CNBuffer));
+out:
+    return kCNSuccess;
+}
+
+
+
+CNStatus
+CNBufferProcessData(CNBufferRef bufRef,
+                    void *ctx, const void *in, const size_t inLen, void *out, size_t *outLen,
+                    cnProcessFunction pFunc, cnSizeFunction sizeFunc)
+{
+    size_t  blocksize = bufRef->chunksize;
+    uint8_t *input = (uint8_t *) in, *output = out;
+    size_t inputLen = inLen, outputLen, inputUsing, outputAvailable;
+    
+    outputAvailable = outputLen = *outLen;
+    
+    if(sizeFunc(ctx, bufRef->bufferPos + inLen) > outputAvailable) return  kCNBufferTooSmall;
+    *outLen = 0;
+    if(bufRef->bufferPos > 0) {
+        inputUsing = CC_XMIN(blocksize - bufRef->bufferPos, inputLen);
+        CC_XMEMCPY(&bufRef->buf[bufRef->bufferPos], in, inputUsing);
+        bufRef->bufferPos += inputUsing;
+        if(bufRef->bufferPos < blocksize) {
+            return kCNSuccess;
+        }
+        pFunc(ctx, bufRef->buf, blocksize, output, &outputLen);
+        inputLen -= inputUsing; input += inputUsing;
+        output += outputLen; *outLen = outputLen; outputAvailable -= outputLen;
+        bufRef->bufferPos = 0;
+    }
+    
+    inputUsing = inputLen - inputLen % blocksize;
+    if(inputUsing > 0) {
+        outputLen = outputAvailable;
+        pFunc(ctx, input, inputUsing, output, &outputLen);
+        inputLen -= inputUsing; input += inputUsing;
+        *outLen += outputLen;
+    }
+    
+    if(inputLen > blocksize) {
+        return kCNAlignmentError;
+    } else if(inputLen > 0) {
+        CC_XMEMCPY(bufRef->buf, input, inputLen);
+        bufRef->bufferPos = inputLen;
+    }
+    return kCNSuccess;
+    
+}
+
+CNStatus
+CNBufferFlushData(CNBufferRef bufRef,
+                  void *ctx, void *out, size_t *outLen,
+                  cnProcessFunction pFunc, cnSizeFunction sizeFunc)
+{
+    //    size_t outputLen, outputAvailable;
+    //    outputAvailable = outputLen = *outLen;
+    
+    if(bufRef->bufferPos > 0) {
+        if(bufRef->bufferPos > bufRef->chunksize) return kCNAlignmentError;
+        if(sizeFunc(ctx, bufRef->bufferPos) > *outLen) return kCNBufferTooSmall;
+        pFunc(ctx, bufRef->buf, bufRef->bufferPos, out, outLen);
+    } else {
+        *outLen = 0;
+    }
+    return kCNSuccess;
+}
+
+
+
+bool
+CNBufferEmpty(CNBufferRef bufRef)
+{
+    return bufRef->bufferPos == 0;
+}