Make writecube safer

1 files changed, 33 insertions, 40 deletions

diff --git a/src/nissy.c b/src/nissy.c
index bc608de..d725599 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -5,15 +5,14 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "nissy.h"
 #include "utils/utils.h"
 #include "arch/arch.h"
 #include "core/core.h"
 #include "solvers/solvers.h"
 
-#include "nissy.h"
-
 int parse_h48_solver(const char *, uint8_t [static 1], uint8_t [static 1]);
-STATIC int64_t write_result(cube_t, char [static 22]);
+STATIC int64_t write_result(cube_t, char [static NISSY_SIZE_B32]);
 STATIC bool distribution_equal(const uint64_t [static INFO_DISTRIBUTION_LEN],
     const uint64_t [static INFO_DISTRIBUTION_LEN], uint8_t);
 STATIC bool checkdata(const char *, const tableinfo_t *);
@@ -107,9 +106,9 @@ distribution_equal(
 }
 
 STATIC int64_t
-write_result(cube_t cube, char result[static 22])
+write_result(cube_t cube, char result[static NISSY_SIZE_B32])
 {
-        writecube("B32", cube, result);
+        writecube("B32", cube, NISSY_SIZE_B32, result);
 
         if (!issolvable(cube)) {
                 LOG("Warning: resulting cube is not solvable\n");
@@ -121,9 +120,9 @@ write_result(cube_t cube, char result[static 22])
 
 int64_t
 nissy_compose(
-        const char cube[static 22],
-        const char permutation[static 22],
-        char result[static 22]
+        const char cube[static NISSY_SIZE_B32],
+        const char permutation[static NISSY_SIZE_B32],
+        char result[static NISSY_SIZE_B32]
 )
 {
         cube_t c, p, res;
@@ -156,14 +155,14 @@ nissy_compose(
         return write_result(res, result);
 
 nissy_compose_error:
-        writecube("B32", ZERO_CUBE, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
         return err;
 }
 
 int64_t
 nissy_inverse(
-        const char cube[static 22],
-        char result[static 22]
+        const char cube[static NISSY_SIZE_B32],
+        char result[static NISSY_SIZE_B32]
 )
 {
         cube_t c, res;
@@ -188,15 +187,15 @@ nissy_inverse(
         return write_result(res, result);
 
 nissy_inverse_error:
-        writecube("B32", ZERO_CUBE, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
         return err;
 }
 
 int64_t
 nissy_applymoves(
-        const char cube[static 22],
+        const char cube[static NISSY_SIZE_B32],
         const char *moves,
-        char result[static 22]
+        char result[static NISSY_SIZE_B32]
 )
 {
         cube_t c, res;
@@ -227,15 +226,15 @@ nissy_applymoves(
         return write_result(res, result);
 
 nissy_applymoves_error:
-        writecube("B32", ZERO_CUBE, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
         return err;
 }
 
 int64_t
 nissy_applytrans(
-        const char cube[static 22],
-        const char transformation[static 12],
-        char result[static 22]
+        const char cube[static NISSY_SIZE_B32],
+        const char transformation[static NISSY_SIZE_TRANSFORMATION],
+        char result[static NISSY_SIZE_B32]
 )
 {
         cube_t c, res;
@@ -260,14 +259,14 @@ nissy_applytrans(
         return write_result(res, result);
 
 nissy_applytrans_error:
-        writecube("B32", ZERO_CUBE, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
         return err;
 }
 
 int64_t
 nissy_frommoves(
         const char *moves,
-        char result[static 22]
+        char result[static NISSY_SIZE_B32]
 )
 {
         cube_t res;
@@ -290,7 +289,7 @@ nissy_frommoves(
         return write_result(res, result);
 
 nissy_frommoves_error:
-        writecube("B32", ZERO_CUBE, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
         return err;
 }
 
@@ -304,7 +303,6 @@ nissy_convert(
 )
 {
         cube_t c;
-        int ret;
         int64_t err;
 
         if (format_in == NULL) {
@@ -327,28 +325,15 @@ nissy_convert(
 
         c = readcube(format_in, cube_string);
 
-        if (iserror(c)) {
-                err = NISSY_ERROR_INVALID_CUBE;
-                goto nissy_convert_error;
-        }
-
-        ret = writecube(format_out, c, result);
-
-        if (ret != 0) {
-                /* Assume the format was invalid */
-                err = NISSY_ERROR_INVALID_FORMAT;
-                goto nissy_convert_error;
-        }
-
         if (!isconsistent(c)) {
-                err = NISSY_ERROR_UNKNOWN;
+                err = NISSY_ERROR_INVALID_CUBE;
                 goto nissy_convert_error;
         }
 
-        return NISSY_OK;
+        return writecube(format_out, c, result_size, result);
 
 nissy_convert_error:
-        /* We don't write anything to result, we don't know the format */
+        result[0] = '\0';
         return err;
 }
 
@@ -359,7 +344,7 @@ nissy_getcube(
         int64_t cp,
         int64_t co,
         const char *options,
-        char result[static 22]
+        char result[static NISSY_SIZE_B32]
 )
 {
         int i;
@@ -498,7 +483,7 @@ nissy_checkdata(
 
 int64_t
 nissy_solve(
-        const char cube[static 22],
+        const char cube[static NISSY_SIZE_B32],
         const char *solver, 
         uint8_t nissflag,
         int8_t minmoves,
@@ -671,6 +656,14 @@ nissy_explainerror(
                     "is NULL.\n", NISSY_ERROR_NULL_POINTER
                 );
                 return NISSY_OK;
+        case NISSY_ERROR_BUFFER_SIZE:
+                write(
+                    "The value %" PRId64 " means that one of the buffers "
+                    "provided is too small. For example, it could be too "
+                    "small to hold the result or too small to hold the data "
+                    "generated by gendata.\n", NISSY_ERROR_BUFFER_SIZE
+                );
+                return NISSY_OK;
         case NISSY_ERROR_DATA:
                 write(
                     "The value %" PRId64 " means that the provided data is "