vboot2: Get rid of extra '2' at end of new struct names

Now that lib20 and lib21 are distinct, they can have overlapping
struct names.  This will be cleaner in the long run, since vboot 2.0
(lib20) is just a temporary stepping stone to vboot 2.1 (lib21).  It
would be a shame to need to carry around the overhead of that extra
digit forever.

No functional changes, just a lot of renaming.

BUG=chromium:423882
BRANCH=none
TEST=make runtests && VBOOT2=1 make runtests (works with/withoug VBOOT2 flag)
     And compile firmware for veyron_pinky

Change-Id: I25f348fd31e32d08ca576836dfdd1278828765a1
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/233183
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>

1 files changed, 65 insertions, 65 deletions

diff --git a/tests/vb21_common2_tests.c b/tests/vb21_common2_tests.c
index 510665e2..199a063a 100644
--- a/tests/vb21_common2_tests.c
+++ b/tests/vb21_common2_tests.c
@@ -22,48 +22,48 @@
 static const uint8_t test_data[] = "This is some test data to sign.";
 static const uint32_t test_size = sizeof(test_data);
 
-static void test_unpack_key2(const struct vb2_packed_key2 *key)
+static void test_unpack_key(const struct vb2_packed_key *key)
 {
 	struct vb2_public_key pubk;
-	struct vb2_packed_key2 *key2;
+	struct vb2_packed_key *key2;
 	uint32_t size = key->c.total_size;
 
 	/* Make a copy of the key for testing */
-	key2 = (struct vb2_packed_key2 *)malloc(size);
+	key2 = (struct vb2_packed_key *)malloc(size);
 
 	memcpy(key2, key, size);
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() ok");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() ok");
 
 	memcpy(key2, key, size);
 	key2->key_offset += 4;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_MEMBER_SIZE,
-		"vb2_unpack_key2() buffer too small");
+		"vb2_unpack_key() buffer too small");
 
 	memcpy(key2, key, size);
 	key2->c.fixed_size += size;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_FIXED_SIZE,
-		"vb2_unpack_key2() buffer too small for desc");
+		"vb2_unpack_key() buffer too small for desc");
 
 	memcpy(key2, key, size);
 	key2->c.desc_size = 0;
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() no desc");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() no desc");
 	TEST_EQ(strcmp(pubk.desc, ""), 0, "  empty desc string");
 
 	memcpy(key2, key, size);
 	key2->c.magic++;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_MAGIC,
-		"vb2_unpack_key2() bad magic");
+		"vb2_unpack_key() bad magic");
 
 	memcpy(key2, key, size);
 	key2->c.struct_version_major++;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_STRUCT_VERSION,
-		"vb2_unpack_key2() bad major version");
+		"vb2_unpack_key() bad major version");
 
 	/*
 	 * Minor version changes are ok.  Note that this test assumes that the
@@ -76,104 +76,104 @@ static void test_unpack_key2(const struct vb2_packed_key2 *key)
 	 */
 	memcpy(key2, key, size);
 	key2->c.struct_version_minor++;
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() minor version change ok");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() minor version change ok");
 
 	memcpy(key2, key, size);
 	key2->sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
-		"vb2_unpack_key2() bad sig algorithm");
+		"vb2_unpack_key() bad sig algorithm");
 
 	memcpy(key2, key, size);
 	key2->hash_alg = VB2_HASH_INVALID;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
-		"vb2_unpack_key2() bad hash algorithm");
+		"vb2_unpack_key() bad hash algorithm");
 
 	memcpy(key2, key, size);
 	key2->key_size -= 4;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_SIZE,
-		"vb2_unpack_key2() invalid size");
+		"vb2_unpack_key() invalid size");
 
 	memcpy(key2, key, size);
 	key2->key_offset--;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_MEMBER_UNALIGNED,
-		"vb2_unpack_key2() unaligned data");
+		"vb2_unpack_key() unaligned data");
 
 	memcpy(key2, key, size);
 	*(uint32_t *)((uint8_t *)key2 + key2->key_offset) /= 2;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_ARRAY_SIZE,
-		"vb2_unpack_key2() invalid key array size");
+		"vb2_unpack_key() invalid key array size");
 
 	free(key2);
 }
 
-static void test_verify_signature2(const struct vb2_signature2 *sig)
+static void test_verify_signature(const struct vb2_signature *sig)
 {
-	struct vb2_signature2 *sig2;
+	struct vb2_signature *sig2;
 	uint8_t *buf2;
 	uint32_t size;
 
 	/* Make a copy of the signature */
 	size = sig->c.total_size;
 	buf2 = malloc(size);
-	sig2 = (struct vb2_signature2 *)buf2;
+	sig2 = (struct vb2_signature *)buf2;
 
 	memcpy(buf2, sig, size);
-	TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig ok");
-	sig2->c.magic = VB2_MAGIC_PACKED_KEY2;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_MAGIC,
+	TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig ok");
+	sig2->c.magic = VB2_MAGIC_PACKED_KEY;
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_MAGIC,
 		"verify_sig magic");
 
 	memcpy(buf2, sig, size);
 	sig2->c.total_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE,
 		"verify_sig common header");
 
 	memcpy(buf2, sig, size);
 	sig2->c.struct_version_minor++;
-	TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig minor ver");
+	TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig minor ver");
 	sig2->c.struct_version_major++;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_VERSION,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_VERSION,
 		"verify_sig major ver");
 
 	memcpy(buf2, sig, size);
 	sig2->c.fixed_size -= 4;
 	sig2->c.desc_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_HEADER_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_HEADER_SIZE,
 		"verify_sig header size");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE,
 		"verify_sig sig size");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_ALGORITHM,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_ALGORITHM,
 		"verify_sig sig alg");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_alg = (sig2->sig_alg == VB2_SIG_NONE ?
 			 VB2_SIG_RSA1024 : VB2_SIG_NONE);
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_SIZE,
 		"verify_sig sig size");
 
 	free(buf2);
 }
 
-static void test_verify_data2(const struct vb2_public_key *pubk_orig,
-			      const struct vb2_signature2 *sig)
+static void test_verify_data(const struct vb2_public_key *pubk_orig,
+			      const struct vb2_signature *sig)
 {
 	uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES];
 	struct vb2_workbuf wb;
 
 	struct vb2_public_key pubk;
-	struct vb2_signature2 *sig2;
+	struct vb2_signature *sig2;
 	uint8_t *buf2;
 	uint32_t size;
 
@@ -184,53 +184,53 @@ static void test_verify_data2(const struct vb2_public_key *pubk_orig,
 	/* Allocate signature copy for tests */
 	size = sig->c.total_size;
 	buf2 = malloc(size);
-	sig2 = (struct vb2_signature2 *)buf2;
+	sig2 = (struct vb2_signature *)buf2;
 
 	memcpy(buf2, sig, size);
 	pubk.sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data2() bad sig alg");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data() bad sig alg");
 	pubk = *pubk_orig;
 
 	memcpy(buf2, sig, size);
 	pubk.hash_alg = VB2_HASH_INVALID;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_DIGEST_SIZE,
-		"vb2_verify_data2() bad hash alg");
+		"vb2_verify_data() bad hash alg");
 	pubk = *pubk_orig;
 
 	vb2_workbuf_init(&wb, workbuf, 4);
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_WORKBUF_DIGEST,
-		"vb2_verify_data2() workbuf too small");
+		"vb2_verify_data() workbuf too small");
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
 
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		0, "vb2_verify_data2() ok");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		0, "vb2_verify_data() ok");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_size -= 16;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data2() wrong sig size");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data() wrong sig size");
 
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size - 1, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_SIZE, "vb2_verify_data2() wrong data size");
+	TEST_EQ(vb2_verify_data(test_data, test_size - 1, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_SIZE, "vb2_verify_data() wrong data size");
 
 	memcpy(buf2, sig, size);
 	sig2->hash_alg = (sig2->hash_alg == VB2_HASH_SHA1 ?
 			  VB2_HASH_SHA256 : VB2_HASH_SHA1);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_ALGORITHM_MISMATCH,
-		"vb2_verify_data2() alg mismatch");
+		"vb2_verify_data() alg mismatch");
 
 
 	memcpy(buf2, sig, size);
 	buf2[sig2->sig_offset] ^= 0x5A;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_RSA_PADDING, "vb2_verify_data2() wrong sig");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_RSA_PADDING, "vb2_verify_data() wrong sig");
 
 	free(buf2);
 }
@@ -245,9 +245,9 @@ int test_algorithm(int key_algorithm, const char *keys_dir)
 	enum vb2_hash_algorithm hash_alg = vb2_crypto_to_hash(key_algorithm);
 
 	struct vb2_private_key *prik = NULL;
-	struct vb2_signature2 *sig2 = NULL;
+	struct vb2_signature *sig2 = NULL;
 	struct vb2_public_key *pubk = NULL;
-	struct vb2_packed_key2 *key2 = NULL;
+	struct vb2_packed_key *key2 = NULL;
 
 	printf("***Testing algorithm: %s\n", algo_strings[key_algorithm]);
 
@@ -269,9 +269,9 @@ int test_algorithm(int key_algorithm, const char *keys_dir)
 	TEST_SUCC(vb2_sign_data(&sig2, test_data, test_size, prik, ""),
 		  "Make test signature");
 
-	test_unpack_key2(key2);
-	test_verify_data2(pubk, sig2);
-	test_verify_signature2(sig2);
+	test_unpack_key(key2);
+	test_verify_data(pubk, sig2);
+	test_verify_signature(sig2);
 
 	free(key2);
 	free(sig2);