/* Converts a data string to an LDAP rfc2253 hex string
* something like '#01020304'
*/
static int
data2hex(const void *data, size_t data_size,
gnutls_datum_t *out)
{
gnutls_datum_t tmp, td;
int ret;
size_t size;
td.size = hex_str_size(data_size) + 1; /* +1 for '#' */
td.data = gnutls_malloc(td.size);
if (td.data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
tmp.data = (void*)data;
tmp.size = data_size;
td.data[0] = '#';
size = td.size-1; /* don't include '#' */
ret =
gnutls_hex_encode(&tmp,
(char*)&td.data[1], &size);
if (ret < 0) {
gnutls_assert();
gnutls_free(td.data);
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
td.size--; /* don't include null */
out->data = td.data;
out->size = td.size;
return 0;
}
int main(int argc, char *argv[])
{
const tal_t *ctx = tal_arr(NULL, char, 0);
struct bitcoin_tx *tx;
struct sha256_double txid;
char str[hex_str_size(sizeof(txid))];
err_set_progname(argv[0]);
/* FIXME: Take update.pbs to adjust channel */
opt_register_noarg("--help|-h", opt_usage_and_exit,
"<tx>\n"
"Print txid of the transaction in the file",
"Print this message.");
opt_register_version();
opt_parse(&argc, argv, opt_log_stderr_exit);
if (argc != 2)
opt_usage_exit_fail("Expected 1 argument");
tx = bitcoin_tx_from_file(ctx, argv[1]);
bitcoin_txid(tx, &txid);
if (!bitcoin_txid_to_hex(&txid, str, sizeof(str)))
abort();
/* Print it out. */
if (!write_all(STDOUT_FILENO, str, strlen(str)))
err(1, "Writing out txid");
tal_free(ctx);
return 0;
}
void json_add_hex(struct json_result *result, const char *fieldname,
const void *data, size_t len)
{
char hex[hex_str_size(len)];
hex_encode(data, len, hex, sizeof(hex));
json_add_string(result, fieldname, hex);
}
static char *fmt_bitcoin_blkid(const tal_t *ctx,
const struct bitcoin_blkid *blkid)
{
char *hexstr = tal_arr(ctx, char, hex_str_size(sizeof(*blkid)));
bitcoin_blkid_to_hex(blkid, hexstr, hex_str_size(sizeof(*blkid)));
return hexstr;
}
static void print_keypair(bool pub, bool priv)
{
secp256k1_context *ctx;
struct seckey seckey;
struct compressed_pubkey pubkey;
char sechex[hex_str_size(sizeof(seckey))];
char pubhex[hex_str_size(sizeof(pubkey))];
assert(pub || priv);
ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
gen_keys(ctx, &seckey, &pubkey);
hex_encode(&seckey, sizeof(seckey), sechex, sizeof(sechex));
hex_encode(&pubkey, sizeof(pubkey), pubhex, sizeof(pubhex));
if (pub && priv) {
printf("%s:%s\n", sechex, pubhex);
} else {
printf("%s\n", (priv ? sechex : pubhex));
}
}
static char *make_message(secp256k1_context *ctx,
const secp256k1_pubkey *pubkey)
{
char *m;
unsigned char tmp[33];
size_t len = sizeof(tmp);
char hexstr[hex_str_size(20)];
secp256k1_ec_pubkey_serialize(ctx, tmp, &len, pubkey,
SECP256K1_EC_COMPRESSED);
hex_encode(tmp+1, 20, hexstr, sizeof(hexstr));
asprintf(&m, "Message for %s...", hexstr);
return m;
}
int main(void)
{
const char teststr[] = "0123456789abcdefABCDEF";
const char bad_teststr[] = "0123456789abcdefABCDEF1O";
const unsigned char testdata[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
0xcd, 0xef, 0xAB, 0xCD, 0xEF };
unsigned char data[11];
char str[23];
size_t i;
plan_tests(10 + sizeof(str));
ok1(hex_str_size(sizeof(testdata)) == sizeof(teststr));
/* This gives right result with or without nul included */
ok1(hex_data_size(strlen(teststr)) == sizeof(testdata));
ok1(hex_data_size(sizeof(teststr)) == sizeof(testdata));
ok1(hex_decode(teststr, strlen(teststr), data, sizeof(data)));
ok1(memcmp(data, testdata, sizeof(testdata)) == 0);
ok1(hex_encode(testdata, sizeof(testdata), str, sizeof(str)));
ok1(strcmp(str, "0123456789abcdefabcdef") == 0);
/* Bad char */
ok1(!hex_decode(bad_teststr, strlen(bad_teststr), data, sizeof(data)));
/* Bad hex string len */
ok1(!hex_decode(teststr, strlen(teststr) - 1, data, sizeof(data)));
/* Bad buffer len */
ok1(!hex_decode(teststr, strlen(teststr), data, sizeof(data) - 1));
/* Bad deststring size. */
for (i = 1; i <= sizeof(str); i++)
ok1(!hex_encode(testdata, sizeof(testdata), str, sizeof(str)-i));
/* This exits depending on whether all tests passed */
return exit_status();
}
char *tal_hexstr(const tal_t *ctx, const void *data, size_t len)
{
char *str = tal_arr(ctx, char, hex_str_size(len));
hex_encode(data, len, str, hex_str_size(len));
return str;
}
static char *hex_of(const tal_t *ctx, const void *p, size_t n)
{
char *hex = tal_arr(ctx, char, hex_str_size(n));
hex_encode(p, n, hex, hex_str_size(n));
return hex;
}
