test/property_test.c:232: error: BUFFER_OVERRUN_L3
  Offset: [2, +oo] Size: [1, 11] by call to `ossl_method_store_add`.
Showing all 25 steps of the trace


test/property_test.c:218:9: Array declaration
216.           char *impl;
217.       } impls[] = {
218.           { 6, "position=1", "a" },
               ^
219.           { 6, "position=2", "b" },
220.           { 6, "position=3", "c" },

test/property_test.c:232:14: Call
230.   
231.       for (i = 0; i < OSSL_NELEM(impls); i++)
232.           if (!TEST_true(ossl_method_store_add(store, impls[i].nid, impls[i].prop,
                    ^
233.                                                impls[i].impl, NULL))) {
234.               TEST_note("iteration %zd", i + 1);

crypto/property/property.c:186:1: Parameter `*properties`
  184.   }
  185.   
  186. > int ossl_method_store_add(OSSL_METHOD_STORE *store,
  187.                             int nid, const char *properties,
  188.                             void *method, void (*method_destruct)(void *))

crypto/property/property.c:215:33: Call
  213.       ossl_method_cache_flush(store, nid);
  214.       if ((impl->properties = ossl_prop_defn_get(properties)) == NULL) {
  215.           if ((impl->properties = ossl_parse_property(properties)) == NULL)
                                         ^
  216.               goto err;
  217.           ossl_prop_defn_set(properties, impl->properties);

crypto/property/property_parse.c:315:1: Parameter `*defn`
    313.   }
    314.   
    315. > OSSL_PROPERTY_LIST *ossl_parse_property(const char *defn)
    316.   {
    317.       PROPERTY_DEFINITION *prop = NULL;

crypto/property/property_parse.c:320:5: Assignment
    318.       OSSL_PROPERTY_LIST *res = NULL;
    319.       STACK_OF(PROPERTY_DEFINITION) *sk;
    320.       const char *s = defn;
               ^
    321.       int done;
    322.   

crypto/property/property_parse.c:326:9: Call
    324.           return NULL;
    325.   
    326.       s = skip_space(s);
                   ^
    327.       done = *s == '\0';
    328.       while (!done) {

crypto/property/property_parse.c:50:1: Parameter `*s`
      48.   DEFINE_STACK_OF(PROPERTY_DEFINITION)
      49.   
      50. > static const char *skip_space(const char *s)
      51.   {
      52.       while (ossl_isspace(*s))

crypto/property/property_parse.c:54:5: Assignment
      52.       while (ossl_isspace(*s))
      53.           s++;
      54.       return s;
                ^
      55.   }
      56.   

crypto/property/property_parse.c:326:5: Assignment
    324.           return NULL;
    325.   
    326.       s = skip_space(s);
               ^
    327.       done = *s == '\0';
    328.       while (!done) {

crypto/property/property_parse.c:333:14: Call
    331.               goto err;
    332.           memset(&prop->v, 0, sizeof(prop->v));
    333.           if (!parse_name(&s, 1, &prop->name_idx))
                        ^
    334.               goto err;
    335.           prop->oper = PROPERTY_OPER_EQ;

crypto/property/property_parse.c:81:1: Parameter `**t`
      79.   }
      80.   
      81. > static int parse_name(const char *t[], int create, OSSL_PROPERTY_IDX *idx)
      82.   {
      83.       char name[100];

crypto/property/property_parse.c:340:13: Call
    338.               goto err;
    339.           }
    340.           if (match_ch(&s, '=')) {
                       ^
    341.               if (!parse_value(&s, prop, 1)) {
    342.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);

crypto/property/property_parse.c:57:1: Parameter `**t`
      55.   }
      56.   
      57. > static int match_ch(const char *t[], char m)
      58.   {
      59.       const char *s = *t;

crypto/property/property_parse.c:341:18: Call
    339.           }
    340.           if (match_ch(&s, '=')) {
    341.               if (!parse_value(&s, prop, 1)) {
                            ^
    342.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);
    343.                   goto err;

crypto/property/property_parse.c:244:1: Parameter `**t`
      242.   }
      243.   
      244. > static int parse_value(const char *t[], PROPERTY_DEFINITION *res, int create)
      245.   {
      246.       const char *s = *t;

crypto/property/property_parse.c:246:5: Assignment
      244.   static int parse_value(const char *t[], PROPERTY_DEFINITION *res, int create)
      245.   {
      246.       const char *s = *t;
                 ^
      247.       int r = 0;
      248.   

crypto/property/property_parse.c:250:9: Assignment
      248.   
      249.       if (*s == '"' || *s == '\'') {
      250.           s++;
                     ^
      251.           r = parse_string(&s, s[-1], res, create);
      252.       } else if (*s == '+') {

crypto/property/property_parse.c:251:13: Call
      249.       if (*s == '"' || *s == '\'') {
      250.           s++;
      251.           r = parse_string(&s, s[-1], res, create);
                         ^
      252.       } else if (*s == '+') {
      253.           s++;

crypto/property/property_parse.c:183:1: Parameter `**t`
        181.   }
        182.   
        183. > static int parse_string(const char *t[], char delim, PROPERTY_DEFINITION *res,
        184.                           const int create)
        185.   {

crypto/property/property_parse.c:187:5: Assignment
        185.   {
        186.       char v[1000];
        187.       const char *s = *t;
                   ^
        188.       size_t i = 0;
        189.       int err = 0;

crypto/property/property_parse.c:204:10: Call
        202.       }
        203.       v[i] = '\0';
        204.       *t = skip_space(s + 1);
                        ^
        205.       if (err)
        206.           PROPerr(PROP_F_PARSE_STRING, PROP_R_STRING_TOO_LONG);

crypto/property/property_parse.c:50:1: <Length trace>
48.   DEFINE_STACK_OF(PROPERTY_DEFINITION)
49.   
50. > static const char *skip_space(const char *s)
51.   {
52.       while (ossl_isspace(*s))

crypto/property/property_parse.c:50:1: Parameter `*s`
          48.   DEFINE_STACK_OF(PROPERTY_DEFINITION)
          49.   
          50. > static const char *skip_space(const char *s)
          51.   {
          52.       while (ossl_isspace(*s))

crypto/property/property_parse.c:52:12: Array access: Offset: [2, +oo] Size: [1, 11] by call to `ossl_method_store_add` 
          50.   static const char *skip_space(const char *s)
          51.   {
          52.       while (ossl_isspace(*s))
                           ^
          53.           s++;
          54.       return s;
