Lines Matching defs:value
44 char *expected_err; /* Expected error value of test */
57 /* Test specific name value pair processing */
58 int (*parse) (EVP_TEST * t, const char *name, const char *value);
85 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
133 static int evp_test_buffer_append(const char *value,
141 if (!parse_bin(value, &db->buf, &db->buflen))
159 static int evp_test_buffer_ncopy(const char *value,
165 int ncopy = atoi(value);
187 static int evp_test_buffer_set_count(const char *value,
191 int count = atoi(value);
272 * For a hex string "value" convert to a binary allocated buffer.
275 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen)
280 if (strcmp(value, "NULL") == 0) {
286 /* Check for empty value */
287 if (*value == '\0') {
302 if (value[0] == '"') {
303 size_t vlen = strlen(++value);
305 if (vlen == 0 || value[vlen - 1] != '"')
308 *buf = unescape(value, vlen, buflen);
313 if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
314 TEST_info("Can't convert %s", value);
376 const char *keyword, const char *value)
381 return evp_test_buffer_append(value, &mdata->input);
383 return parse_bin(value, &mdata->output, &mdata->output_len);
385 return evp_test_buffer_set_count(value, mdata->input);
387 return evp_test_buffer_ncopy(value, mdata->input);
389 return (mdata->pad_type = atoi(value)) > 0;
612 const char *value)
618 return parse_bin(value, &cdat->key, &cdat->key_len);
620 i = atoi(value);
627 return parse_bin(value, &cdat->iv, &cdat->iv_len);
629 return parse_bin(value, &cdat->next_iv, &cdat->iv_len);
631 return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
633 return parse_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
635 i = atoi(value);
649 return parse_bin(value, &cdat->aad[i], &cdat->aad_len[i]);
654 return parse_bin(value, &cdat->tag, &cdat->tag_len);
656 if (strcmp(value, "TRUE") == 0)
658 else if (strcmp(value, "FALSE") == 0)
665 return parse_bin(value, &cdat->mac_key, &cdat->mac_key_len);
669 cdat->tls_version = (int)strtol(value, &endptr, 0);
670 return value[0] != '\0' && endptr[0] == '\0';
675 if (strcmp(value, "ENCRYPT") == 0)
677 else if (strcmp(value, "DECRYPT") == 0)
684 cdat->cts_mode = value;
772 * set tag length and value.
1225 const char *keyword, const char *value)
1230 return parse_bin(value, &mdata->key, &mdata->key_len);
1232 return parse_bin(value, &mdata->iv, &mdata->iv_len);
1234 return parse_bin(value, &mdata->custom, &mdata->custom_len);
1236 return parse_bin(value, &mdata->salt, &mdata->salt_len);
1238 mdata->alg = OPENSSL_strdup(value);
1244 return parse_bin(value, &mdata->input, &mdata->input_len);
1246 return parse_bin(value, &mdata->output, &mdata->output_len);
1252 char *data = OPENSSL_strdup(value);
1259 mdata->output_size = atoi(value);
1265 mdata->block_size = atoi(value);
1274 const char *value)
1279 if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1486 char *value = sk_OPENSSL_STRING_value(expected->controls, i);
1488 if (!TEST_ptr(tmpkey = OPENSSL_strdup(value))) {
1727 const char *value)
1732 if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1757 const char *keyword, const char *value)
1761 return parse_bin(value, &kdata->input, &kdata->input_len);
1763 return parse_bin(value, &kdata->output, &kdata->output_len);
1765 return pkey_test_ctrl(t, kdata->ctx, value);
1893 const char *keyword, const char *value)
1903 if (find_key(&peer, value, public_keys) == 0)
1913 return parse_bin(value, &kdata->output, &kdata->output_len);
1915 return pkey_test_ctrl(t, kdata->ctx, value);
1920 (char *)value, 0);
1930 (char *)value, 0);
1940 (char *)value, 0);
1949 size_t outlen = (size_t)strtoul(value, &endptr, 0);
2038 /* Parse unsigned decimal 64 bit integer value */
2039 static int parse_uint64(const char *value, uint64_t *pr)
2041 const char *p = value;
2044 TEST_info("Invalid empty integer value");
2049 TEST_error("Integer overflow in string %s", value);
2054 TEST_error("Invalid character in string %s", value);
2064 const char *keyword, const char *value)
2069 return parse_uint64(value, &pdata->N);
2071 return parse_uint64(value, &pdata->p);
2073 return parse_uint64(value, &pdata->r);
2075 return parse_uint64(value, &pdata->maxmem);
2081 const char *keyword, const char *value)
2086 pdata->iter = atoi(value);
2092 pdata->md = EVP_get_digestbyname(value);
2101 const char *keyword, const char *value)
2106 pdata->id = atoi(value);
2111 return pbkdf2_test_parse(t, keyword, value);
2151 const char *keyword, const char *value)
2156 return parse_bin(value, &pdata->pass, &pdata->pass_len);
2158 return parse_bin(value, &pdata->salt, &pdata->salt_len);
2160 return parse_bin(value, &pdata->key, &pdata->key_len);
2162 return pbkdf2_test_parse(t, keyword, value);
2164 return pkcs12_test_parse(t, keyword, value);
2167 return scrypt_test_parse(t, keyword, value);
2296 const char *keyword, const char *value)
2301 return parse_bin(value, &edata->input, &edata->input_len);
2303 return parse_bin(value, &edata->output, &edata->output_len);
2487 const char *keyword, const char *value)
2502 return parse_bin(value, &item->entropy, &item->entropy_len);
2504 return parse_bin(value, &item->reseed_entropy,
2507 return parse_bin(value, &item->nonce, &item->nonce_len);
2510 return parse_bin(value, &item->pers, &item->pers_len);
2513 return parse_bin(value, &item->reseed_addin,
2517 return parse_bin(value, &item->addinA, &item->addinA_len);
2520 return parse_bin(value, &item->addinB, &item->addinB_len);
2523 return parse_bin(value, &item->pr_entropyA, &item->pr_entropyA_len);
2526 return parse_bin(value, &item->pr_entropyB, &item->pr_entropyB_len);
2528 return parse_bin(value, &item->output, &item->output_len);
2531 return TEST_ptr(rdata->cipher = OPENSSL_strdup(value));
2533 return TEST_ptr(rdata->digest = OPENSSL_strdup(value));
2535 rdata->use_df = atoi(value) != 0;
2539 if ((n = atoi(value)) <= 0 || n % 8 != 0)
2545 rdata->prediction_resistance = atoi(value) != 0;
2730 const char *value)
2737 if (!TEST_ptr(name = OPENSSL_strdup(value)))
2769 const char *keyword, const char *value)
2774 return parse_bin(value, &kdata->output, &kdata->output_len);
2776 return kdf_test_ctrl(t, kdata->ctx, value);
2869 const char *keyword, const char *value)
2874 return parse_bin(value, &kdata->output, &kdata->output_len);
2876 return pkey_test_ctrl(t, kdata->ctx, value);
2998 static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
3107 const char *keyword, const char *value)
3112 return TEST_ptr(keygen->keyname = OPENSSL_strdup(value));
3114 return pkey_test_ctrl(t, keygen->genctx, value);
3231 const char *keyword, const char *value)
3241 rv = find_key(&pkey, value, public_keys);
3243 rv = find_key(&pkey, value, private_keys);
3262 return parse_bin(value, &mdata->osin, &mdata->osin_len);
3263 return evp_test_buffer_append(value, &mdata->input);
3266 return parse_bin(value, &mdata->output, &mdata->output_len);
3270 return evp_test_buffer_set_count(value, mdata->input);
3272 return evp_test_buffer_ncopy(value, mdata->input);
3277 return pkey_test_ctrl(t, mdata->pctx, value);
3637 /* NULL out the value from |pp| but return it. This "steals" a pointer. */
3640 char *p = pp->value;
3642 pp->value = NULL;
3728 TEST_info("Can't read private key %s", pp->value);
3737 TEST_info("Can't read public key %s", pp->value);
3754 strnid = strchr(pp->value, ':');
3762 TEST_info("Failed to parse %s value", pp->key);
3789 if (!prov_available(pp->value)) {
3791 pp->value, t->s.test_file, t->s.start);
3800 j = fips_provider_version_match(libctx, pp->value);
3818 if (find_key(NULL, pp->value, *klist)) {
3819 TEST_info("Duplicate key %s", pp->value);
3838 if (!t->meth->init(t, pp->value)) {
3839 TEST_error("unknown %s: %s\n", pp->key, pp->value);
3843 /* TEST_info("skipping %s %s", pp->key, pp->value); */
3879 int rv = t->meth->parse(t, pp->key, pp->value);
3887 t->s.curr, pp->key, pp->value);