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


test/property_test.c:333:1: Array declaration
331.   }
332.   
333. > static int test_query_cache_stochastic(void)
334.   {
335.       const int max = 10000, tail = 10;

test/property_test.c:350:14: Call
348.           v[i] = 2 * i;
349.           BIO_snprintf(buf, sizeof(buf), "n=%d\n", i);
350.           if (!TEST_true(ossl_method_store_add(store, i, buf, "abc", NULL))
                    ^
351.                   || !TEST_true(ossl_method_store_cache_set(store, i, buf, v + i))
352.                   || !TEST_true(ossl_method_store_cache_set(store, i, "n=1234",

crypto/property/property.c:176:1: Parameter `*properties`
  174.   }
  175.   
  176. > int ossl_method_store_add(OSSL_METHOD_STORE *store,
  177.                             int nid, const char *properties,
  178.                             void *method, void (*method_destruct)(void *))

crypto/property/property.c:205:28: Call
  203.       ossl_method_cache_flush(store, nid);
  204.       if ((impl->properties = ossl_prop_defn_get(store->ctx, properties)) == NULL) {
  205.           impl->properties = ossl_parse_property(store->ctx, properties);
                                    ^
  206.           if (impl->properties == NULL)
  207.               goto err;

crypto/property/property_parse.c:336:1: Parameter `*defn`
    334.   }
    335.   
    336. > OSSL_PROPERTY_LIST *ossl_parse_property(OPENSSL_CTX *ctx, const char *defn)
    337.   {
    338.       PROPERTY_DEFINITION *prop = NULL;

crypto/property/property_parse.c:341:5: Assignment
    339.       OSSL_PROPERTY_LIST *res = NULL;
    340.       STACK_OF(PROPERTY_DEFINITION) *sk;
    341.       const char *s = defn;
               ^
    342.       int done;
    343.   

crypto/property/property_parse.c:347:9: Call
    345.           return NULL;
    346.   
    347.       s = skip_space(s);
                   ^
    348.       done = *s == '\0';
    349.       while (!done) {

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

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

crypto/property/property_parse.c:347:5: Assignment
    345.           return NULL;
    346.   
    347.       s = skip_space(s);
               ^
    348.       done = *s == '\0';
    349.       while (!done) {

crypto/property/property_parse.c:357:14: Call
    355.           memset(&prop->v, 0, sizeof(prop->v));
    356.           prop->optional = 0;
    357.           if (!parse_name(ctx, &s, 1, &prop->name_idx))
                        ^
    358.               goto err;
    359.           prop->oper = PROPERTY_OPER_EQ;

crypto/property/property_parse.c:83:1: Parameter `**t`
      81.   }
      82.   
      83. > static int parse_name(OPENSSL_CTX *ctx, const char *t[], int create,
      84.                         OSSL_PROPERTY_IDX *idx)
      85.   {

crypto/property/property_parse.c:365:13: Call
    363.               goto err;
    364.           }
    365.           if (match_ch(&s, '=')) {
                       ^
    366.               if (!parse_value(ctx, &s, prop, 1)) {
    367.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);

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

crypto/property/property_parse.c:366:18: Call
    364.           }
    365.           if (match_ch(&s, '=')) {
    366.               if (!parse_value(ctx, &s, prop, 1)) {
                            ^
    367.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);
    368.                   ERR_add_error_data(2, "HERE-->", start);

crypto/property/property_parse.c:261:1: Parameter `**t`
      259.   }
      260.   
      261. > static int parse_value(OPENSSL_CTX *ctx, const char *t[],
      262.                          PROPERTY_DEFINITION *res, int create)
      263.   {

crypto/property/property_parse.c:264:5: Assignment
      262.                          PROPERTY_DEFINITION *res, int create)
      263.   {
      264.       const char *s = *t;
                 ^
      265.       int r = 0;
      266.   

crypto/property/property_parse.c:268:9: Assignment
      266.   
      267.       if (*s == '"' || *s == '\'') {
      268.           s++;
                     ^
      269.           r = parse_string(ctx, &s, s[-1], res, create);
      270.       } else if (*s == '+') {

crypto/property/property_parse.c:269:13: Call
      267.       if (*s == '"' || *s == '\'') {
      268.           s++;
      269.           r = parse_string(ctx, &s, s[-1], res, create);
                         ^
      270.       } else if (*s == '+') {
      271.           s++;

crypto/property/property_parse.c:191:1: Parameter `**t`
        189.   }
        190.   
        191. > static int parse_string(OPENSSL_CTX *ctx, const char *t[], char delim,
        192.                           PROPERTY_DEFINITION *res, const int create)
        193.   {

crypto/property/property_parse.c:195:5: Assignment
        193.   {
        194.       char v[1000];
        195.       const char *s = *t;
                   ^
        196.       size_t i = 0;
        197.       int err = 0;

crypto/property/property_parse.c:222:10: Call
        220.           res->v.str_val = ossl_property_value(ctx, v, create);
        221.       }
        222.       *t = skip_space(s + 1);
                        ^
        223.       res->type = PROPERTY_TYPE_STRING;
        224.       return !err;

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

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

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