1  /*
  2   * Copyright (c) 1999-2001,2005-2007,2010-2012,2014 Apple Inc. All Rights Reserved.
  3   *
  4   * @APPLE_LICENSE_HEADER_START@
  5   * 
  6   * This file contains Original Code and/or Modifications of Original Code
  7   * as defined in and that are subject to the Apple Public Source License
  8   * Version 2.0 (the 'License'). You may not use this file except in
  9   * compliance with the License. Please obtain a copy of the License at
 10   * http://www.opensource.apple.com/apsl/ and read it before using this
 11   * file.
 12   * 
 13   * The Original Code and all software distributed under the License are
 14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 18   * Please see the License for the specific language governing rights and
 19   * limitations under the License.
 20   * 
 21   * @APPLE_LICENSE_HEADER_END@
 22   */
 23  
 24  /*
 25   * sslMemory.c - Memory allocator implementation
 26   */
 27  
 28  /* THIS FILE CONTAINS KERNEL CODE */
 29  
 30  #include "sslMemory.h"
 31  #include "sslDebug.h"
 32  
 33  #include <string.h>			/* memset */
 34  #include <AssertMacros.h>
 35  
 36  // MARK: -
 37  // MARK: Basic low-level malloc/free
 38  
 39  /*
 40   * For now, all allocs/frees go thru here.
 41   */
 42  
 43  #ifdef KERNEL
 44  
 45  /* BSD Malloc */
 46  #include <sys/malloc.h>
 47  #include <IOKit/IOLib.h>
 48  #include <libkern/libkern.h>
 49  
 50  /* Define this for debugging sslMalloc and sslFree */
 51  //#define SSL_CANARIS
 52  
 53  void *
 54  sslMalloc(size_t length)
 55  {
 56      void *p;
 57  
 58  #ifdef SSL_CANARIS
 59      length+=8;
 60  #endif
 61      
 62      p = _MALLOC(length, M_TEMP, M_WAITOK);
 63      check(p);
 64      
 65      if(p==NULL)
 66          return p;
 67      
 68  #ifdef SSL_CANARIS
 69      *(uint32_t *)p=(uint32_t)length-8;
 70      printf("sslMalloc @%p of 0x%08lx bytes\n", p, length-8);
 71      *(uint32_t *)(p+length-4)=0xdeadbeed;
 72      p+=4;
 73  #endif
 74  
 75      return p;
 76  }
 77  
 78  void
 79  sslFree(void *p)
 80  {
 81  	if(p != NULL) {
 82  
 83  #ifdef SSL_CANARIS
 84          p=p-4;
 85          uint32_t len=*(uint32_t *)p;
 86          uint32_t marker=*(uint32_t *)(p+4+len);
 87          printf("sslFree @%p len=0x%08x\n", p, len);
 88          if(marker!=0xdeadbeef)
 89              panic("Buffer overflow in SSL!\n");
 90  #endif
 91          
 92          _FREE(p, M_TEMP);
 93  	}
 94  }
 95  
 96  #else
 97  
 98  #include <stdlib.h>
 99  
100  void *
101  sslMalloc(size_t length)
102  {
103  	return malloc(length);
104  }
105  
106  void
107  sslFree(void *p)
108  {   
109  	if(p != NULL) {
110  		free(p);
111  	}
112  }
113  
114  #endif
115  
116  // MARK: -
117  // MARK: SSLBuffer-level alloc/free
118  
119  int SSLAllocBuffer(
120  	SSLBuffer *buf,
121  	size_t length)
122  {
123  	buf->data = (uint8_t *)sslMalloc(length);
124  	if(buf->data == NULL) {
125          sslErrorLog("SSLAllocBuffer: NULL buf!\n");
126          check(0);
127  		buf->length = 0;
128  		return -1;
129  	}
130      buf->length = length;
131      return 0;
132  }
133  
134  int
135  SSLFreeBuffer(SSLBuffer *buf)
136  {   
137  	if(buf == NULL) {
138  		sslErrorLog("SSLFreeBuffer: NULL buf!\n");
139          check(0);
140  		return -1;
141  	}
142      sslFree(buf->data);
143      buf->data = NULL;
144      buf->length = 0;
145      return 0;
146  }
147  
148  uint8_t *sslAllocCopy(
149  	const uint8_t *src,
150  	size_t len)
151  {
152  	uint8_t *dst;
153  	
154  	dst = (uint8_t *)sslMalloc(len);
155  	if(dst == NULL) {
156  		return NULL;
157  	}
158  	memmove(dst, src, len);
159  	return dst;
160  }
161  
162  int SSLCopyBufferFromData(
163  	const void *src,
164  	size_t len,
165  	SSLBuffer *dst)		// data mallocd and returned 
166  {   
167  	dst->data = sslAllocCopy((const uint8_t *)src, len);
168  	if(dst->data == NULL) {
169          sslErrorLog("SSLCopyBufferFromData: NULL buf!\n");
170          check(0);
171  		return -1;
172  	}
173      dst->length = len;
174      return 0;
175  }
176  
177  int SSLCopyBuffer(
178  	const SSLBuffer *src, 
179  	SSLBuffer *dst)		// data mallocd and returned 
180  {   
181  	return SSLCopyBufferFromData(src->data, src->length, dst);
182  }
183