Use standard lib functionality only when available

Author: real-or-random

include/secp256k1.h

@@ -138,6 +138,12 @@ typedef int (*secp256k1_nonce_function)(
      /* Unreachable with a confirming compiler. Guess "yes" as a last resort. */
 #    define SECP256K1_HAVE_STDIO_H 1
 #  endif
+#  if !SECP256K1_HAVE_STDIO_H && defined(SECP256K1_BUILD) && !defined(USE_EXTERNAL_DEFAULT_CALLBACKS)
+#    pragma message( \
+       "<stdio.h> appears unavailable, " \
+       "disabling debugging output for fatal errors in libsecp256k1. " \
+       "(#define SECP256K1_HAVE_STDIO_H 0 to suppress this message.)")
+#  endif
 #endif
 #if !defined(SECP256K1_HAVE_STDLIB_H)
 #  if defined(__has_include)
@@ -148,6 +154,12 @@ typedef int (*secp256k1_nonce_function)(
      /* Unreachable with a confirming compiler. Guess "yes" as a last resort. */
 #    define SECP256K1_HAVE_STDLIB_H 1
 #  endif
+#  if !SECP256K1_HAVE_STDLIB_H && defined(SECP256K1_BUILD)
+#    pragma message( \
+       "<stdlib.h> appears unavailable, " \
+       "disabling dynamic memory allocation in libsecp256k1. " \
+       "(#define SECP256K1_HAVE_STDLIB_H 0 to suppress this message.)")
+#  endif
 #endif
 
 /*  When this header is used at build-time the SECP256K1_BUILD define needs to be set

src/scratch_impl.h

@@ -7,9 +7,12 @@
 #ifndef SECP256K1_SCRATCH_IMPL_H
 #define SECP256K1_SCRATCH_IMPL_H
 
+#include <string.h>
+
 #include "util.h"
 #include "scratch.h"
 
+#if SECP256K1_HAVE_STDLIB_H
 static secp256k1_scratch* secp256k1_scratch_create(const secp256k1_callback* error_callback, size_t size) {
     const size_t base_alloc = ROUND_TO_ALIGN(sizeof(secp256k1_scratch));
     void *alloc = checked_malloc(error_callback, base_alloc + size);
@@ -34,6 +37,7 @@ static void secp256k1_scratch_destroy(const secp256k1_callback* error_callback,
         free(scratch);
     }
 }
+#endif
 
 static size_t secp256k1_scratch_checkpoint(const secp256k1_callback* error_callback, const secp256k1_scratch* scratch) {
     if (secp256k1_memcmp_var(scratch->magic, "scratch", 8) != 0) {

src/secp256k1.c

@@ -137,6 +137,7 @@ secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigne
     return ret;
 }
 
+#if SECP256K1_HAVE_STDLIB_H
 secp256k1_context* secp256k1_context_create(unsigned int flags) {
     size_t const prealloc_size = secp256k1_context_preallocated_size(flags);
     secp256k1_context* ctx = (secp256k1_context*)checked_malloc(&default_error_callback, prealloc_size);
@@ -147,6 +148,7 @@ secp256k1_context* secp256k1_context_create(unsigned int flags) {
 
     return ctx;
 }
+#endif
 
 secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context* ctx, void* prealloc) {
     secp256k1_context* ret;
@@ -159,6 +161,7 @@ secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context*
     return ret;
 }
 
+#if SECP256K1_HAVE_STDLIB_H
 secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
     secp256k1_context* ret;
     size_t prealloc_size;
@@ -171,6 +174,7 @@ secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
     ret = secp256k1_context_preallocated_clone(ctx, ret);
     return ret;
 }
+#endif
 
 void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
     ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
@@ -183,6 +187,7 @@ void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
     secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
 }
 
+#if SECP256K1_HAVE_STDLIB_H
 void secp256k1_context_destroy(secp256k1_context* ctx) {
     ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
 
@@ -194,6 +199,7 @@ void secp256k1_context_destroy(secp256k1_context* ctx) {
     secp256k1_context_preallocated_destroy(ctx);
     free(ctx);
 }
+#endif
 
 void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
     /* We compare pointers instead of checking secp256k1_context_is_proper() here
@@ -219,6 +225,7 @@ void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(co
     ctx->error_callback.data = data;
 }
 
+#if SECP256K1_HAVE_STDLIB_H
 secp256k1_scratch_space* secp256k1_scratch_space_create(const secp256k1_context* ctx, size_t max_size) {
     VERIFY_CHECK(ctx != NULL);
     return secp256k1_scratch_create(&ctx->error_callback, max_size);
@@ -228,6 +235,7 @@ void secp256k1_scratch_space_destroy(const secp256k1_context *ctx, secp256k1_scr
     VERIFY_CHECK(ctx != NULL);
     secp256k1_scratch_destroy(&ctx->error_callback, scratch);
 }
+#endif
 
 /* Mark memory as no-longer-secret for the purpose of analysing constant-time behaviour
  *  of the software.

src/util.h

@@ -9,16 +9,22 @@
 
 #include "../include/secp256k1.h"
 
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#if SECP256K1_HAVE_STDIO_H
+#  include <stdio.h>
+#endif
+#if SECP256K1_HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
 
 #define STR_(x) #x
 #define STR(x) STR_(x)
 #define DEBUG_CONFIG_MSG(x) "DEBUG_CONFIG: " x
 #define DEBUG_CONFIG_DEF(x) DEBUG_CONFIG_MSG(#x "=" STR(x))
 
+#if SECP256K1_HAVE_STDIO_H
 /* Debug helper for printing arrays of unsigned char. */
 #define PRINT_BUF(buf, len) do { \
     printf("%s[%lu] = ", #buf, (unsigned long)len); \
@@ -38,6 +44,7 @@ static void print_buf_plain(const unsigned char *buf, size_t len) {
     }
     printf("\n}\n");
 }
+#endif
 
 # if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
 #  if SECP256K1_GNUC_PREREQ(2,7)
@@ -73,15 +80,27 @@ static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback *
     cb->fn(text, (void*)cb->data);
 }
 
-#ifndef USE_EXTERNAL_DEFAULT_CALLBACKS
+#if !SECP256K1_HAVE_STDLIB_H && !defined(USE_EXTERNAL_DEFAULT_CALLBACKS)
+#  error "<stdlib.h> is not available. You need to use external default callbacks, see the documentation of secp256k1_context_set_illegal_callback."
+#endif
+
+#if SECP256K1_HAVE_STDLIB_H
 static void secp256k1_default_illegal_callback_fn(const char* str, void* data) {
     (void)data;
+#if SECP256K1_HAVE_STDIO_H
     fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
+#else
+    (void)str;
+#endif
     abort();
 }
 static void secp256k1_default_error_callback_fn(const char* str, void* data) {
     (void)data;
+#if SECP256K1_HAVE_STDIO_H
     fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
+#else
+    (void)str;
+#endif
     abort();
 }
 #else
@@ -139,13 +158,15 @@ static const secp256k1_callback default_error_callback = {
 #define VERIFY_CHECK(cond)
 #endif
 
+#if SECP256K1_HAVE_STDLIB_H
 static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
     void *ret = malloc(size);
     if (ret == NULL) {
         secp256k1_callback_call(cb, "Out of memory");
     }
     return ret;
 }
+#endif
 
 #if defined(__BIGGEST_ALIGNMENT__)
 #define ALIGNMENT __BIGGEST_ALIGNMENT__