keyname
#define _THREAD_PRIVATE(keyname, storage, error) &(storage)
#define _THREAD_PRIVATE_DT(keyname, storage, dt, error) &(storage)
#define _THREAD_PRIVATE(keyname, storage, error) \
_thread_cb.tc_tag_storage(&(__THREAD_NAME(keyname)), \
#define _THREAD_PRIVATE_DT(keyname, storage, dt, error) \
_thread_cb.tc_tag_storage(&(__THREAD_NAME(keyname)), \
extern NCURSES_EXPORT(NCURSES_CONST char *) NCURSES_SP_NAME(keyname) (SCREEN*, int); /* implemented:SP_FUNC */
extern NCURSES_EXPORT(NCURSES_CONST char *) keyname (int); /* implemented */
#define safe_keyname NCURSES_SP_NAME(keyname)
tls_server_ticket_key(struct tls_config *config, unsigned char *keyname)
if (keyname == NULL || timingsafe_memcmp(keyname,
tls_server_ticket_cb(SSL *ssl, unsigned char *keyname, unsigned char *iv,
memcpy(keyname, key->key_name, sizeof(key->key_name));
key = tls_server_ticket_key(tls_ctx->config, keyname);
msgkey = ftok(keyname, 4160);
remove(keyname);
char keyname[] = "/tmp/msgtestXXXXXXXX";
if ((fd = mkstemp(keyname)) < 0)
semkey = ftok(keyname, arc4random() & INT_MAX);
remove(keyname);
char keyname[] = "/tmp/msgtestXXXXXXXX";
if ((fd = mkstemp(keyname)) < 0)
remove(keyname);
char keyname[] = "/tmp/msgtestXXXXXXXX";
if ((fd = mkstemp(keyname)) < 0)
#define PREPARE(label, keyname, keywords) \
cert = load_key(keyname ".cert"); \
#define FLAG_CASE(keybase, label, keyname, keywords, mostly_off, var, val) \
PREPARE(keybase " " label, keyname, keywords); \
keyname = strdup(sshkey_ssh_name(private));
ASSERT_PTR_NE(keyname, NULL);
kex_params.proposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = keyname;
free(keyname);
char *keyname = NULL;
check_sig(const char *keyname, const char *signame, const struct sshbuf *msg,
k = load_key(keyname);
const char *keyname;
kvp_pool_auto[i].keyname, kvp_pool_auto[i].value,
const char *keyname;
keyname = cfg_obj_asstring(cfg_map_getname(keyobj));
strlcpy(keynametext, keyname, sizeof(keynametext));
dns_name_t keyname;
dns_name_init(&keyname, NULL);
result = dns_name_fromtext(&keyname, namebuf, dns_rootname, 0, namebuf);
result = dns_tsigkey_create(&keyname, hmacname, secretstore,
dns_name_invalidate(&keyname);
dns_name_t *keyname;
keyname = msg->tsigname;
if (!dns_name_equal(keyname, &tsigkey->name) ||
dns_name_t *keyname;
keyname = msg->tsigname;
(!dns_name_equal(keyname, &tsigkey->name) ||
ret = dns_tsigkey_create(keyname, &tsig.algorithm,
char *keyname;
.opt.arg = &cfg.keyname,
key = load_key(bio_err, cfg.keyname ?
cfg.keyname : cfg.infile,
const char *keyname = check_keyname_compliance(NULL,
VERIFYWITH "%.*s.pub", (int)strlen(keyname) - 4, keyname);
sshkey_match_keyname_to_sigalgs(const char *keyname, const char *sigalgs)
(ktype = sshkey_type_from_name(keyname)) == KEY_UNSPEC)
return match_pattern_list(keyname, sigalgs, 0) == 1;
fprintf(stderr, " %s", keyname(data->keycode));
ca->sslpath, keyname);
warn("Problem with certificate for '%s'", keyname);
if (keyname)
if (keyname) {
ca_setcnf(struct ca *ca, const char *keyname)
ca->sslpath, keyname);
ca->sslpath, keyname);
ca_key_create(struct ca *ca, char *keyname)
ca->sslpath, keyname);
ca_key_import(struct ca *ca, char *keyname, char *import)
len = snprintf(dst, sizeof(dst), "%s/private/%s.key", ca->sslpath, keyname);
ca_key_delete(struct ca *ca, char *keyname)
ca->sslpath, keyname);
ca_delkey(struct ca *ca, char *keyname)
len = snprintf(file, sizeof(file), "%s/%s.crt", ca->sslpath, keyname);
len = snprintf(file, sizeof(file), "%s/private/%s.key", ca->sslpath, keyname);
len = snprintf(file, sizeof(file), "%s/private/%s.csr", ca->sslpath, keyname);
len = snprintf(file, sizeof(file), "%s/private/%s.pfx", ca->sslpath, keyname);
ca_request(struct ca *ca, char *keyname, int type)
ca_setenv("$ENV::CERT_CN", keyname);
strlcpy(name, keyname, sizeof(name));
if (!strcmp(keyname, "local")) {
ca_setcnf(ca, keyname);
len = snprintf(key, sizeof(key), "%s/private/%s.key", ca->sslpath, keyname);
len = snprintf(path, sizeof(path), "%s/private/%s.csr", ca->sslpath, keyname);
ca_sign(struct ca *ca, char *keyname, int type)
ca_setcnf(ca, keyname);
len = snprintf(out, sizeof(out), "%s/%s.crt", ca->sslpath, keyname);
len = snprintf(in, sizeof(in), "%s/private/%s.csr", ca->sslpath, keyname);
ca_certificate(struct ca *ca, char *keyname, int type, int action)
ca_key_create(ca, keyname);
ca_request(ca, keyname, type);
ca_sign(ca, keyname, type);
ca_key_install(struct ca *ca, char *keyname, char *dir)
len = snprintf(src, sizeof(src), "%s/private/%s.key", ca->sslpath, keyname);
ca_cert_install(struct ca *ca, char *keyname, char *dir)
if ((r = ca_key_install(ca, keyname, dir)) != 0) {
len = snprintf(src, sizeof(src), "%s/%s.crt", ca->sslpath, keyname);
len = snprintf(dst, sizeof(dst), "%s/certs/%s.crt", dir, keyname);
ca_export(struct ca *ca, char *keyname, char *myname, char *password)
if (keyname != NULL) {
if (strlcpy(oname, keyname, sizeof(oname)) >= sizeof(oname))
len = snprintf(key, sizeof(key), "%s/private/%s.key", ca->sslpath, keyname);
len = snprintf(crt, sizeof(crt), "%s/%s.crt", ca->sslpath, keyname);
if (keyname != NULL) {
"-name", keyname, "-CAfile", cacrt, "-inkey", key,
if (keyname != NULL) {
ca->sslpath, keyname);
len = snprintf(dst, sizeof(dst), "%s/private/%s.key", p, keyname);
keyname);
len = snprintf(dst, sizeof(dst), "%s/certs/%s.crt", p, keyname);
if (keyname == NULL) {
ca_revoke(struct ca *ca, char *keyname)
if (keyname) {
struct keyname *keyname;
while ((keyname =
TAILQ_REMOVE(&proto->tlscerts, keyname, entry);
free(keyname->name);
free(keyname);
struct keyname *name;
struct keyname *name;
struct keyname *name;
TAILQ_ENTRY(keyname) entry;
TAILQ_HEAD(keynamelist, keyname);