memory_buffer_alloc.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754
  1. /*
  2. * Buffer-based memory allocator
  3. *
  4. * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
  5. * SPDX-License-Identifier: Apache-2.0
  6. *
  7. * Licensed under the Apache License, Version 2.0 (the "License"); you may
  8. * not use this file except in compliance with the License.
  9. * You may obtain a copy of the License at
  10. *
  11. * http://www.apache.org/licenses/LICENSE-2.0
  12. *
  13. * Unless required by applicable law or agreed to in writing, software
  14. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16. * See the License for the specific language governing permissions and
  17. * limitations under the License.
  18. *
  19. * This file is part of mbed TLS (https://tls.mbed.org)
  20. */
  21. #if !defined(MBEDTLS_CONFIG_FILE)
  22. #include "mbedtls/config.h"
  23. #else
  24. #include MBEDTLS_CONFIG_FILE
  25. #endif
  26. #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
  27. #include "mbedtls/memory_buffer_alloc.h"
  28. /* No need for the header guard as MBEDTLS_MEMORY_BUFFER_ALLOC_C
  29. is dependent upon MBEDTLS_PLATFORM_C */
  30. #include "mbedtls/platform.h"
  31. #include <string.h>
  32. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  33. #include <execinfo.h>
  34. #endif
  35. #if defined(MBEDTLS_THREADING_C)
  36. #include "mbedtls/threading.h"
  37. #endif
  38. /* Implementation that should never be optimized out by the compiler */
  39. static void mbedtls_zeroize( void *v, size_t n ) {
  40. volatile unsigned char *p = v; while( n-- ) *p++ = 0;
  41. }
  42. #define MAGIC1 0xFF00AA55
  43. #define MAGIC2 0xEE119966
  44. #define MAX_BT 20
  45. typedef struct _memory_header memory_header;
  46. struct _memory_header
  47. {
  48. size_t magic1;
  49. size_t size;
  50. size_t alloc;
  51. memory_header *prev;
  52. memory_header *next;
  53. memory_header *prev_free;
  54. memory_header *next_free;
  55. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  56. char **trace;
  57. size_t trace_count;
  58. #endif
  59. size_t magic2;
  60. };
  61. typedef struct
  62. {
  63. unsigned char *buf;
  64. size_t len;
  65. memory_header *first;
  66. memory_header *first_free;
  67. int verify;
  68. #if defined(MBEDTLS_MEMORY_DEBUG)
  69. size_t alloc_count;
  70. size_t free_count;
  71. size_t total_used;
  72. size_t maximum_used;
  73. size_t header_count;
  74. size_t maximum_header_count;
  75. #endif
  76. #if defined(MBEDTLS_THREADING_C)
  77. mbedtls_threading_mutex_t mutex;
  78. #endif
  79. }
  80. buffer_alloc_ctx;
  81. static buffer_alloc_ctx heap;
  82. #if defined(MBEDTLS_MEMORY_DEBUG)
  83. static void debug_header( memory_header *hdr )
  84. {
  85. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  86. size_t i;
  87. #endif
  88. mbedtls_fprintf( stderr, "HDR: PTR(%10zu), PREV(%10zu), NEXT(%10zu), "
  89. "ALLOC(%zu), SIZE(%10zu)\n",
  90. (size_t) hdr, (size_t) hdr->prev, (size_t) hdr->next,
  91. hdr->alloc, hdr->size );
  92. mbedtls_fprintf( stderr, " FPREV(%10zu), FNEXT(%10zu)\n",
  93. (size_t) hdr->prev_free, (size_t) hdr->next_free );
  94. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  95. mbedtls_fprintf( stderr, "TRACE: \n" );
  96. for( i = 0; i < hdr->trace_count; i++ )
  97. mbedtls_fprintf( stderr, "%s\n", hdr->trace[i] );
  98. mbedtls_fprintf( stderr, "\n" );
  99. #endif
  100. }
  101. static void debug_chain()
  102. {
  103. memory_header *cur = heap.first;
  104. mbedtls_fprintf( stderr, "\nBlock list\n" );
  105. while( cur != NULL )
  106. {
  107. debug_header( cur );
  108. cur = cur->next;
  109. }
  110. mbedtls_fprintf( stderr, "Free list\n" );
  111. cur = heap.first_free;
  112. while( cur != NULL )
  113. {
  114. debug_header( cur );
  115. cur = cur->next_free;
  116. }
  117. }
  118. #endif /* MBEDTLS_MEMORY_DEBUG */
  119. static int verify_header( memory_header *hdr )
  120. {
  121. if( hdr->magic1 != MAGIC1 )
  122. {
  123. #if defined(MBEDTLS_MEMORY_DEBUG)
  124. mbedtls_fprintf( stderr, "FATAL: MAGIC1 mismatch\n" );
  125. #endif
  126. return( 1 );
  127. }
  128. if( hdr->magic2 != MAGIC2 )
  129. {
  130. #if defined(MBEDTLS_MEMORY_DEBUG)
  131. mbedtls_fprintf( stderr, "FATAL: MAGIC2 mismatch\n" );
  132. #endif
  133. return( 1 );
  134. }
  135. if( hdr->alloc > 1 )
  136. {
  137. #if defined(MBEDTLS_MEMORY_DEBUG)
  138. mbedtls_fprintf( stderr, "FATAL: alloc has illegal value\n" );
  139. #endif
  140. return( 1 );
  141. }
  142. if( hdr->prev != NULL && hdr->prev == hdr->next )
  143. {
  144. #if defined(MBEDTLS_MEMORY_DEBUG)
  145. mbedtls_fprintf( stderr, "FATAL: prev == next\n" );
  146. #endif
  147. return( 1 );
  148. }
  149. if( hdr->prev_free != NULL && hdr->prev_free == hdr->next_free )
  150. {
  151. #if defined(MBEDTLS_MEMORY_DEBUG)
  152. mbedtls_fprintf( stderr, "FATAL: prev_free == next_free\n" );
  153. #endif
  154. return( 1 );
  155. }
  156. return( 0 );
  157. }
  158. static int verify_chain()
  159. {
  160. memory_header *prv = heap.first, *cur;
  161. if( prv == NULL || verify_header( prv ) != 0 )
  162. {
  163. #if defined(MBEDTLS_MEMORY_DEBUG)
  164. mbedtls_fprintf( stderr, "FATAL: verification of first header "
  165. "failed\n" );
  166. #endif
  167. return( 1 );
  168. }
  169. if( heap.first->prev != NULL )
  170. {
  171. #if defined(MBEDTLS_MEMORY_DEBUG)
  172. mbedtls_fprintf( stderr, "FATAL: verification failed: "
  173. "first->prev != NULL\n" );
  174. #endif
  175. return( 1 );
  176. }
  177. cur = heap.first->next;
  178. while( cur != NULL )
  179. {
  180. if( verify_header( cur ) != 0 )
  181. {
  182. #if defined(MBEDTLS_MEMORY_DEBUG)
  183. mbedtls_fprintf( stderr, "FATAL: verification of header "
  184. "failed\n" );
  185. #endif
  186. return( 1 );
  187. }
  188. if( cur->prev != prv )
  189. {
  190. #if defined(MBEDTLS_MEMORY_DEBUG)
  191. mbedtls_fprintf( stderr, "FATAL: verification failed: "
  192. "cur->prev != prv\n" );
  193. #endif
  194. return( 1 );
  195. }
  196. prv = cur;
  197. cur = cur->next;
  198. }
  199. return( 0 );
  200. }
  201. static void *buffer_alloc_calloc( size_t n, size_t size )
  202. {
  203. memory_header *new, *cur = heap.first_free;
  204. unsigned char *p;
  205. void *ret;
  206. size_t original_len, len;
  207. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  208. void *trace_buffer[MAX_BT];
  209. size_t trace_cnt;
  210. #endif
  211. if( heap.buf == NULL || heap.first == NULL )
  212. return( NULL );
  213. original_len = len = n * size;
  214. if( n == 0 || size == 0 || len / n != size )
  215. return( NULL );
  216. else if( len > (size_t)-MBEDTLS_MEMORY_ALIGN_MULTIPLE )
  217. return( NULL );
  218. if( len % MBEDTLS_MEMORY_ALIGN_MULTIPLE )
  219. {
  220. len -= len % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
  221. len += MBEDTLS_MEMORY_ALIGN_MULTIPLE;
  222. }
  223. // Find block that fits
  224. //
  225. while( cur != NULL )
  226. {
  227. if( cur->size >= len )
  228. break;
  229. cur = cur->next_free;
  230. }
  231. if( cur == NULL )
  232. return( NULL );
  233. if( cur->alloc != 0 )
  234. {
  235. #if defined(MBEDTLS_MEMORY_DEBUG)
  236. mbedtls_fprintf( stderr, "FATAL: block in free_list but allocated "
  237. "data\n" );
  238. #endif
  239. mbedtls_exit( 1 );
  240. }
  241. #if defined(MBEDTLS_MEMORY_DEBUG)
  242. heap.alloc_count++;
  243. #endif
  244. // Found location, split block if > memory_header + 4 room left
  245. //
  246. if( cur->size - len < sizeof(memory_header) +
  247. MBEDTLS_MEMORY_ALIGN_MULTIPLE )
  248. {
  249. cur->alloc = 1;
  250. // Remove from free_list
  251. //
  252. if( cur->prev_free != NULL )
  253. cur->prev_free->next_free = cur->next_free;
  254. else
  255. heap.first_free = cur->next_free;
  256. if( cur->next_free != NULL )
  257. cur->next_free->prev_free = cur->prev_free;
  258. cur->prev_free = NULL;
  259. cur->next_free = NULL;
  260. #if defined(MBEDTLS_MEMORY_DEBUG)
  261. heap.total_used += cur->size;
  262. if( heap.total_used > heap.maximum_used )
  263. heap.maximum_used = heap.total_used;
  264. #endif
  265. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  266. trace_cnt = backtrace( trace_buffer, MAX_BT );
  267. cur->trace = backtrace_symbols( trace_buffer, trace_cnt );
  268. cur->trace_count = trace_cnt;
  269. #endif
  270. if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
  271. mbedtls_exit( 1 );
  272. ret = (unsigned char *) cur + sizeof( memory_header );
  273. memset( ret, 0, original_len );
  274. return( ret );
  275. }
  276. p = ( (unsigned char *) cur ) + sizeof(memory_header) + len;
  277. new = (memory_header *) p;
  278. new->size = cur->size - len - sizeof(memory_header);
  279. new->alloc = 0;
  280. new->prev = cur;
  281. new->next = cur->next;
  282. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  283. new->trace = NULL;
  284. new->trace_count = 0;
  285. #endif
  286. new->magic1 = MAGIC1;
  287. new->magic2 = MAGIC2;
  288. if( new->next != NULL )
  289. new->next->prev = new;
  290. // Replace cur with new in free_list
  291. //
  292. new->prev_free = cur->prev_free;
  293. new->next_free = cur->next_free;
  294. if( new->prev_free != NULL )
  295. new->prev_free->next_free = new;
  296. else
  297. heap.first_free = new;
  298. if( new->next_free != NULL )
  299. new->next_free->prev_free = new;
  300. cur->alloc = 1;
  301. cur->size = len;
  302. cur->next = new;
  303. cur->prev_free = NULL;
  304. cur->next_free = NULL;
  305. #if defined(MBEDTLS_MEMORY_DEBUG)
  306. heap.header_count++;
  307. if( heap.header_count > heap.maximum_header_count )
  308. heap.maximum_header_count = heap.header_count;
  309. heap.total_used += cur->size;
  310. if( heap.total_used > heap.maximum_used )
  311. heap.maximum_used = heap.total_used;
  312. #endif
  313. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  314. trace_cnt = backtrace( trace_buffer, MAX_BT );
  315. cur->trace = backtrace_symbols( trace_buffer, trace_cnt );
  316. cur->trace_count = trace_cnt;
  317. #endif
  318. if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC ) && verify_chain() != 0 )
  319. mbedtls_exit( 1 );
  320. ret = (unsigned char *) cur + sizeof( memory_header );
  321. memset( ret, 0, original_len );
  322. return( ret );
  323. }
  324. static void buffer_alloc_free( void *ptr )
  325. {
  326. memory_header *hdr, *old = NULL;
  327. unsigned char *p = (unsigned char *) ptr;
  328. if( ptr == NULL || heap.buf == NULL || heap.first == NULL )
  329. return;
  330. if( p < heap.buf || p >= heap.buf + heap.len )
  331. {
  332. #if defined(MBEDTLS_MEMORY_DEBUG)
  333. mbedtls_fprintf( stderr, "FATAL: mbedtls_free() outside of managed "
  334. "space\n" );
  335. #endif
  336. mbedtls_exit( 1 );
  337. }
  338. p -= sizeof(memory_header);
  339. hdr = (memory_header *) p;
  340. if( verify_header( hdr ) != 0 )
  341. mbedtls_exit( 1 );
  342. if( hdr->alloc != 1 )
  343. {
  344. #if defined(MBEDTLS_MEMORY_DEBUG)
  345. mbedtls_fprintf( stderr, "FATAL: mbedtls_free() on unallocated "
  346. "data\n" );
  347. #endif
  348. mbedtls_exit( 1 );
  349. }
  350. hdr->alloc = 0;
  351. #if defined(MBEDTLS_MEMORY_DEBUG)
  352. heap.free_count++;
  353. heap.total_used -= hdr->size;
  354. #endif
  355. #if defined(MBEDTLS_MEMORY_BACKTRACE)
  356. free( hdr->trace );
  357. hdr->trace = NULL;
  358. hdr->trace_count = 0;
  359. #endif
  360. // Regroup with block before
  361. //
  362. if( hdr->prev != NULL && hdr->prev->alloc == 0 )
  363. {
  364. #if defined(MBEDTLS_MEMORY_DEBUG)
  365. heap.header_count--;
  366. #endif
  367. hdr->prev->size += sizeof(memory_header) + hdr->size;
  368. hdr->prev->next = hdr->next;
  369. old = hdr;
  370. hdr = hdr->prev;
  371. if( hdr->next != NULL )
  372. hdr->next->prev = hdr;
  373. memset( old, 0, sizeof(memory_header) );
  374. }
  375. // Regroup with block after
  376. //
  377. if( hdr->next != NULL && hdr->next->alloc == 0 )
  378. {
  379. #if defined(MBEDTLS_MEMORY_DEBUG)
  380. heap.header_count--;
  381. #endif
  382. hdr->size += sizeof(memory_header) + hdr->next->size;
  383. old = hdr->next;
  384. hdr->next = hdr->next->next;
  385. if( hdr->prev_free != NULL || hdr->next_free != NULL )
  386. {
  387. if( hdr->prev_free != NULL )
  388. hdr->prev_free->next_free = hdr->next_free;
  389. else
  390. heap.first_free = hdr->next_free;
  391. if( hdr->next_free != NULL )
  392. hdr->next_free->prev_free = hdr->prev_free;
  393. }
  394. hdr->prev_free = old->prev_free;
  395. hdr->next_free = old->next_free;
  396. if( hdr->prev_free != NULL )
  397. hdr->prev_free->next_free = hdr;
  398. else
  399. heap.first_free = hdr;
  400. if( hdr->next_free != NULL )
  401. hdr->next_free->prev_free = hdr;
  402. if( hdr->next != NULL )
  403. hdr->next->prev = hdr;
  404. memset( old, 0, sizeof(memory_header) );
  405. }
  406. // Prepend to free_list if we have not merged
  407. // (Does not have to stay in same order as prev / next list)
  408. //
  409. if( old == NULL )
  410. {
  411. hdr->next_free = heap.first_free;
  412. if( heap.first_free != NULL )
  413. heap.first_free->prev_free = hdr;
  414. heap.first_free = hdr;
  415. }
  416. if( ( heap.verify & MBEDTLS_MEMORY_VERIFY_FREE ) && verify_chain() != 0 )
  417. mbedtls_exit( 1 );
  418. }
  419. void mbedtls_memory_buffer_set_verify( int verify )
  420. {
  421. heap.verify = verify;
  422. }
  423. int mbedtls_memory_buffer_alloc_verify()
  424. {
  425. return verify_chain();
  426. }
  427. #if defined(MBEDTLS_MEMORY_DEBUG)
  428. void mbedtls_memory_buffer_alloc_status()
  429. {
  430. mbedtls_fprintf( stderr,
  431. "Current use: %zu blocks / %zu bytes, max: %zu blocks / "
  432. "%zu bytes (total %zu bytes), alloc / free: %zu / %zu\n",
  433. heap.header_count, heap.total_used,
  434. heap.maximum_header_count, heap.maximum_used,
  435. heap.maximum_header_count * sizeof( memory_header )
  436. + heap.maximum_used,
  437. heap.alloc_count, heap.free_count );
  438. if( heap.first->next == NULL )
  439. {
  440. mbedtls_fprintf( stderr, "All memory de-allocated in stack buffer\n" );
  441. }
  442. else
  443. {
  444. mbedtls_fprintf( stderr, "Memory currently allocated:\n" );
  445. debug_chain();
  446. }
  447. }
  448. void mbedtls_memory_buffer_alloc_max_get( size_t *max_used, size_t *max_blocks )
  449. {
  450. *max_used = heap.maximum_used;
  451. *max_blocks = heap.maximum_header_count;
  452. }
  453. void mbedtls_memory_buffer_alloc_max_reset( void )
  454. {
  455. heap.maximum_used = 0;
  456. heap.maximum_header_count = 0;
  457. }
  458. void mbedtls_memory_buffer_alloc_cur_get( size_t *cur_used, size_t *cur_blocks )
  459. {
  460. *cur_used = heap.total_used;
  461. *cur_blocks = heap.header_count;
  462. }
  463. #endif /* MBEDTLS_MEMORY_DEBUG */
  464. #if defined(MBEDTLS_THREADING_C)
  465. static void *buffer_alloc_calloc_mutexed( size_t n, size_t size )
  466. {
  467. void *buf;
  468. if( mbedtls_mutex_lock( &heap.mutex ) != 0 )
  469. return( NULL );
  470. buf = buffer_alloc_calloc( n, size );
  471. if( mbedtls_mutex_unlock( &heap.mutex ) )
  472. return( NULL );
  473. return( buf );
  474. }
  475. static void buffer_alloc_free_mutexed( void *ptr )
  476. {
  477. /* We have to good option here, but corrupting the heap seems
  478. * worse than loosing memory. */
  479. if( mbedtls_mutex_lock( &heap.mutex ) )
  480. return;
  481. buffer_alloc_free( ptr );
  482. (void) mbedtls_mutex_unlock( &heap.mutex );
  483. }
  484. #endif /* MBEDTLS_THREADING_C */
  485. void mbedtls_memory_buffer_alloc_init( unsigned char *buf, size_t len )
  486. {
  487. memset( &heap, 0, sizeof( buffer_alloc_ctx ) );
  488. #if defined(MBEDTLS_THREADING_C)
  489. mbedtls_mutex_init( &heap.mutex );
  490. mbedtls_platform_set_calloc_free( buffer_alloc_calloc_mutexed,
  491. buffer_alloc_free_mutexed );
  492. #else
  493. mbedtls_platform_set_calloc_free( buffer_alloc_calloc, buffer_alloc_free );
  494. #endif
  495. if( len < sizeof( memory_header ) + MBEDTLS_MEMORY_ALIGN_MULTIPLE )
  496. return;
  497. else if( (size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE )
  498. {
  499. /* Adjust len first since buf is used in the computation */
  500. len -= MBEDTLS_MEMORY_ALIGN_MULTIPLE
  501. - (size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
  502. buf += MBEDTLS_MEMORY_ALIGN_MULTIPLE
  503. - (size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE;
  504. }
  505. memset( buf, 0, len );
  506. heap.buf = buf;
  507. heap.len = len;
  508. heap.first = (memory_header *)buf;
  509. heap.first->size = len - sizeof( memory_header );
  510. heap.first->magic1 = MAGIC1;
  511. heap.first->magic2 = MAGIC2;
  512. heap.first_free = heap.first;
  513. }
  514. void mbedtls_memory_buffer_alloc_free()
  515. {
  516. #if defined(MBEDTLS_THREADING_C)
  517. mbedtls_mutex_free( &heap.mutex );
  518. #endif
  519. mbedtls_zeroize( &heap, sizeof(buffer_alloc_ctx) );
  520. }
  521. #if defined(MBEDTLS_SELF_TEST)
  522. static int check_pointer( void *p )
  523. {
  524. if( p == NULL )
  525. return( -1 );
  526. if( (size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0 )
  527. return( -1 );
  528. return( 0 );
  529. }
  530. static int check_all_free( )
  531. {
  532. if(
  533. #if defined(MBEDTLS_MEMORY_DEBUG)
  534. heap.total_used != 0 ||
  535. #endif
  536. heap.first != heap.first_free ||
  537. (void *) heap.first != (void *) heap.buf )
  538. {
  539. return( -1 );
  540. }
  541. return( 0 );
  542. }
  543. #define TEST_ASSERT( condition ) \
  544. if( ! (condition) ) \
  545. { \
  546. if( verbose != 0 ) \
  547. mbedtls_printf( "failed\n" ); \
  548. \
  549. ret = 1; \
  550. goto cleanup; \
  551. }
  552. int mbedtls_memory_buffer_alloc_self_test( int verbose )
  553. {
  554. unsigned char buf[1024];
  555. unsigned char *p, *q, *r, *end;
  556. int ret = 0;
  557. if( verbose != 0 )
  558. mbedtls_printf( " MBA test #1 (basic alloc-free cycle): " );
  559. mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
  560. p = mbedtls_calloc( 1, 1 );
  561. q = mbedtls_calloc( 1, 128 );
  562. r = mbedtls_calloc( 1, 16 );
  563. TEST_ASSERT( check_pointer( p ) == 0 &&
  564. check_pointer( q ) == 0 &&
  565. check_pointer( r ) == 0 );
  566. mbedtls_free( r );
  567. mbedtls_free( q );
  568. mbedtls_free( p );
  569. TEST_ASSERT( check_all_free( ) == 0 );
  570. /* Memorize end to compare with the next test */
  571. end = heap.buf + heap.len;
  572. mbedtls_memory_buffer_alloc_free( );
  573. if( verbose != 0 )
  574. mbedtls_printf( "passed\n" );
  575. if( verbose != 0 )
  576. mbedtls_printf( " MBA test #2 (buf not aligned): " );
  577. mbedtls_memory_buffer_alloc_init( buf + 1, sizeof( buf ) - 1 );
  578. TEST_ASSERT( heap.buf + heap.len == end );
  579. p = mbedtls_calloc( 1, 1 );
  580. q = mbedtls_calloc( 1, 128 );
  581. r = mbedtls_calloc( 1, 16 );
  582. TEST_ASSERT( check_pointer( p ) == 0 &&
  583. check_pointer( q ) == 0 &&
  584. check_pointer( r ) == 0 );
  585. mbedtls_free( r );
  586. mbedtls_free( q );
  587. mbedtls_free( p );
  588. TEST_ASSERT( check_all_free( ) == 0 );
  589. mbedtls_memory_buffer_alloc_free( );
  590. if( verbose != 0 )
  591. mbedtls_printf( "passed\n" );
  592. if( verbose != 0 )
  593. mbedtls_printf( " MBA test #3 (full): " );
  594. mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
  595. p = mbedtls_calloc( 1, sizeof( buf ) - sizeof( memory_header ) );
  596. TEST_ASSERT( check_pointer( p ) == 0 );
  597. TEST_ASSERT( mbedtls_calloc( 1, 1 ) == NULL );
  598. mbedtls_free( p );
  599. p = mbedtls_calloc( 1, sizeof( buf ) - 2 * sizeof( memory_header ) - 16 );
  600. q = mbedtls_calloc( 1, 16 );
  601. TEST_ASSERT( check_pointer( p ) == 0 && check_pointer( q ) == 0 );
  602. TEST_ASSERT( mbedtls_calloc( 1, 1 ) == NULL );
  603. mbedtls_free( q );
  604. TEST_ASSERT( mbedtls_calloc( 1, 17 ) == NULL );
  605. mbedtls_free( p );
  606. TEST_ASSERT( check_all_free( ) == 0 );
  607. mbedtls_memory_buffer_alloc_free( );
  608. if( verbose != 0 )
  609. mbedtls_printf( "passed\n" );
  610. cleanup:
  611. mbedtls_memory_buffer_alloc_free( );
  612. return( ret );
  613. }
  614. #endif /* MBEDTLS_SELF_TEST */
  615. #endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */