/* for exit() */
#include <unistd.h>
-int loglevel = 0;
+static int loglevel = 0;
-
-void err(const char* fmt, ...) {
+void err(int level, const char* fmt, ...) {
va_list ap;
+ if (level < loglevel)
+ return;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
unsigned hi = hex2bin(in[pkix]);
unsigned lo = hex2bin(in[pkix + 1]);
if (hi == 0xff) {
- err("character '%c' is not a hex char\n", in[pkix]);
+ err(0, "character '%c' is not a hex char\n", in[pkix]);
exit(1);
}
if (lo == 0xff) {
- err("character '%c' is not a hex char\n", in[pkix + 1]);
+ err(0, "character '%c' is not a hex char\n", in[pkix + 1]);
exit(1);
}
out[outkix] = lo | (hi << 4);
(str[x] != '\0')) {
if (isxdigit(str[x])) {
if (arglen == sizeof(printable_keyid)) {
- err("There are more than %d hex digits in the keyid '%s'\n", sizeof(printable_keyid), str);
+ err(0, "There are more than %d hex digits in the keyid '%s'\n", sizeof(printable_keyid), str);
return 1;
}
pkeyid[arglen] = str[x];
}
if (arglen != sizeof(printable_keyid)) {
- err("keyid '%s' is not %d hex digits in length\n", str, sizeof(printable_keyid));
+ err(0, "Keyid '%s' is not %d hex digits in length\n", str, sizeof(printable_keyid));
return 1;
}
return 0;
const char* debug_string = NULL;
int ret;
+ if (debug_string = getenv("MONKEYSPHERE_DEBUG"), debug_string) {
+ loglevel = atoi(debug_string);
+ }
+
if (ret = gnutls_global_init(), ret) {
- err("Failed to do gnutls_global_init() (error: %d)\n", ret);
+ err(0, "Failed to do gnutls_global_init() (error: %d)\n", ret);
return 1;
}
version = gnutls_check_version(NULL);
if (version)
- err("gnutls version: %s\n", version);
+ err(1, "gnutls version: %s\n", version);
else {
- err("no version found!\n");
+ err(0, "no gnutls version found!\n");
return 1;
}
- if (debug_string = getenv("MONKEYSPHERE_DEBUG"), debug_string) {
- loglevel = atoi(debug_string);
- gnutls_global_set_log_function(logfunc);
-
- gnutls_global_set_log_level(loglevel);
- err("set log level to %d\n", loglevel);
- }
+ gnutls_global_set_log_function(logfunc);
+
+ gnutls_global_set_log_level(loglevel);
+ err(1, "set log level to %d\n", loglevel);
+
return 0;
}
}
int compare_data(const gnutls_datum_t* a, const gnutls_datum_t* b) {
if (a->size > b->size) {
- err("a is larger\n");
+ err(0,"a is larger\n");
return 1;
}
if (a->size < b->size) {
- err("b is larger\n");
+ err(0,"b is larger\n");
return -1;
}
return memcmp(a->data, b->data, a->size);
bufsize = 1024;
d->data = gnutls_realloc(d->data, bufsize);
if (d->data == NULL) {
- err("out of memory!\n");
+ err(0,"out of memory!\n");
return -1;
}
d->size = bufsize;
}
f = fdopen(fd, "r");
if (NULL == f) {
- err("could not fdopen FD %d\n", fd);
+ err(0,"could not fdopen FD %d\n", fd);
}
clearerr(f);
while (!feof(f) && !ferror(f)) {
bufsize *= 2;
d->data = gnutls_realloc(d->data, bufsize);
if (d->data == NULL) {
- err("out of memory!\n");
+ err(0,"out of memory!\n");
return -1;
};
d->size = bufsize;
}
len += fread(d->data + len, 1, bufsize - len, f);
- /* err("read %d bytes\n", len); */
+ /* err(0,"read %d bytes\n", len); */
}
if (ferror(f)) {
- err("Error reading from fd %d (error: %d) (error: %d '%s')\n", fd, ferror(f), errno, strerror(errno));
+ err(0,"Error reading from fd %d (error: %d) (error: %d '%s')\n", fd, ferror(f), errno, strerror(errno));
return -1;
}
size_t x = 0;
if (0 != stat(fname, &sbuf)) {
- err("failed to stat '%s'\n", fname);
+ err(0,"failed to stat '%s'\n", fname);
return -1;
}
c = gnutls_realloc(d->data, sbuf.st_size);
if (NULL == c) {
- err("failed to allocate %d bytes for '%s'\n", sbuf.st_size, fname);
+ err(0,"failed to allocate %d bytes for '%s'\n", sbuf.st_size, fname);
return -1;
}
d->size = sbuf.st_size;
file = fopen(fname, "r");
if (NULL == file) {
- err("failed to open '%s' for reading\n", fname);
+ err(0,"failed to open '%s' for reading\n", fname);
return -1;
}
x = fread(d->data, d->size, 1, file);
if (x != 1) {
- err("tried to read %d bytes, read %d instead from '%s'\n", d->size, x, fname);
+ err(0,"tried to read %d bytes, read %d instead from '%s'\n", d->size, x, fname);
fclose(file);
return -1;
}
int write_datum_fd(int fd, const gnutls_datum_t* d) {
if (d->size != write(fd, d->data, d->size)) {
- err("failed to write body of datum.\n");
+ err(0,"failed to write body of datum.\n");
return -1;
}
return 0;
len = htonl(d->size);
}
if (write(fd, &len, sizeof(len)) != sizeof(len)) {
- err("failed to write size of datum.\n");
+ err(0,"failed to write size of datum.\n");
return -2;
}
if (looks_negative) {
if (write(fd, &zero, 1) != 1) {
- err("failed to write padding byte for MPI.\n");
+ err(0,"failed to write padding byte for MPI.\n");
return -2;
}
}
int ret;
if (pid == NULL) {
- err("bad pointer passed to create_writing_pipe()\n");
+ err(0,"bad pointer passed to create_writing_pipe()\n");
return -1;
}
if (ret = pipe(p), ret == -1) {
- err("failed to create a pipe (error: %d \"%s\")\n", errno, strerror(errno));
+ err(0,"failed to create a pipe (error: %d \"%s\")\n", errno, strerror(errno));
return -1;
}
*pid = fork();
if (*pid == -1) {
- err("Failed to fork (error: %d \"%s\")\n", errno, strerror(errno));
+ err(0,"Failed to fork (error: %d \"%s\")\n", errno, strerror(errno));
return -1;
}
if (*pid == 0) { /* this is the child */
close(p[1]); /* close unused write end */
if (0 != dup2(p[0], 0)) { /* map the reading end into stdin */
- err("Failed to transfer reading file descriptor to stdin (error: %d \"%s\")\n", errno, strerror(errno));
+ err(0,"Failed to transfer reading file descriptor to stdin (error: %d \"%s\")\n", errno, strerror(errno));
exit(1);
}
execv(path, argv);
- err("exec %s failed (error: %d \"%s\")\n", path, errno, strerror(errno));
+ err(0,"exec %s failed (error: %d \"%s\")\n", path, errno, strerror(errno));
/* close the open file descriptors */
close(p[0]);
close(0);
/* choke if userid does not match the expected format
("ssh://fully.qualified.domain.name") */
if (strncmp("ssh://", userid, strlen("ssh://")) != 0) {
- err("The user ID should start with ssh:// for a host key\n");
+ err(0,"The user ID should start with ssh:// for a host key\n");
goto fail;
}
/* so that isalnum will work properly */
userid += strlen("ssh://");
while (0 != (*userid)) {
if (!isalnum(*userid)) {
- err("label did not start with a letter or a digit! (%s)\n", userid);
+ err(0,"label did not start with a letter or a digit! (%s)\n", userid);
goto fail;
}
userid++;
check last char
isalnum */
if (!isalnum(*(userid - 1))) {
- err("label did not end with a letter or a digit!\n");
+ err(0,"label did not end with a letter or a digit!\n");
goto fail;
}
if ('.' == (*userid)) /* advance to the start of the next label */
userid++;
} else {
- err("invalid character in domain name: %c\n", *userid);
+ err(0,"invalid character in domain name: %c\n", *userid);
goto fail;
}
}
/* ensure that the last character is valid: */
if (!isalnum(*(userid - 1))) {
- err("hostname did not end with a letter or a digit!\n");
+ err(0,"hostname did not end with a letter or a digit!\n");
goto fail;
}
/* FIXME: fqdn's can be unicode now, thanks to RFC 3490 -- how do we
pgp_algo = gnutls_openpgp_privkey_get_pk_algorithm(*pgp_privkey, &pgp_bits);
if (pgp_algo < 0) {
- err("failed to get OpenPGP key algorithm (error: %d)\n", pgp_algo);
+ err(0, "failed to get OpenPGP key algorithm (error: %d)\n", pgp_algo);
return 1;
}
if (pgp_algo == GNUTLS_PK_RSA) {
- err("OpenPGP RSA Key, with %d bits\n", pgp_bits);
+ err(0,"OpenPGP RSA Key, with %d bits\n", pgp_bits);
ret = gnutls_openpgp_privkey_export_rsa_raw(*pgp_privkey, &m, &e, &d, &p, &q, &u);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export RSA key parameters (error: %d)\n", ret);
+ err(1, "failed to export RSA key parameters (error: %d)\n", ret);
return 1;
}
ret = gnutls_x509_privkey_import_rsa_raw (*output, &m, &e, &d, &p, &q, &u);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to import RSA key parameters (error: %d)\n", ret);
+ err(1, "failed to import RSA key parameters (error: %d)\n", ret);
return 1;
}
} else if (pgp_algo == GNUTLS_PK_DSA) {
- err("OpenPGP DSA Key, with %d bits\n", pgp_bits);
+ err(0,"OpenPGP DSA Key, with %d bits\n", pgp_bits);
ret = gnutls_openpgp_privkey_export_dsa_raw(*pgp_privkey, &p, &q, &g, &y, &x);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export DSA key parameters (error: %d)\n", ret);
+ err(0,"failed to export DSA key parameters (error: %d)\n", ret);
return 1;
}
ret = gnutls_x509_privkey_import_dsa_raw (*output, &p, &q, &g, &y, &x);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to import DSA key parameters (error: %d)\n", ret);
+ err(0,"failed to import DSA key parameters (error: %d)\n", ret);
return 1;
}
} else {
- err("OpenPGP Key was not RSA or DSA -- can't deal! (actual algorithm was: %d)\n", pgp_algo);
+ err(0,"OpenPGP Key was not RSA or DSA -- can't deal! (actual algorithm was: %d)\n", pgp_algo);
return 1;
}
ret = gnutls_x509_privkey_fix(*output);
if (ret != 0) {
- err("failed to fix up the private key in X.509 format (error: %d)\n", ret);
+ err(0,"failed to fix up the private key in X.509 format (error: %d)\n", ret);
return 1;
}
/* figure out if we've got the right thing: */
subkeycount = gnutls_openpgp_crt_get_subkey_count(*pgp_crt);
if (subkeycount < 0) {
- err("Could not determine subkey count (got value %d)\n", subkeycount);
+ err(0,"Could not determine subkey count (got value %d)\n", subkeycount);
return 1;
}
if ((keyid == NULL) &&
(subkeycount > 0)) {
- err("No keyid passed in, but there were %d keys to choose from\n", subkeycount + 1);
+ err(0,"No keyid passed in, but there were %d keys to choose from\n", subkeycount + 1);
return 1;
}
if (keyid != NULL) {
ret = gnutls_openpgp_crt_get_key_id(*pgp_crt, curkeyid);
if (ret) {
- err("Could not get keyid (error: %d)\n", ret);
+ err(0,"Could not get keyid (error: %d)\n", ret);
return 1;
}
}
if ((keyid == NULL) || (memcmp(*keyid, curkeyid, sizeof(gnutls_openpgp_keyid_t)) == 0)) {
/* we want to export the primary key: */
- err("exporting primary key\n");
+ err(0,"exporting primary key\n");
/* FIXME: this is almost identical to the block below for subkeys.
This clumsiness seems inherent in the gnutls OpenPGP API,
though. ugh. */
algo = gnutls_openpgp_crt_get_pk_algorithm(*pgp_crt, &bits);
if (algo < 0) {
- err("failed to get the algorithm of the OpenPGP public key (error: %d)\n", algo);
+ err(0,"failed to get the algorithm of the OpenPGP public key (error: %d)\n", algo);
return algo;
} else if (algo == GNUTLS_PK_RSA) {
- err("OpenPGP RSA certificate, with %d bits\n", bits);
+ err(0,"OpenPGP RSA certificate, with %d bits\n", bits);
ret = gnutls_openpgp_crt_get_pk_rsa_raw(*pgp_crt, &m, &e);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export RSA key parameters (error: %d)\n", ret);
+ err(0,"failed to export RSA key parameters (error: %d)\n", ret);
return 1;
}
} else if (algo == GNUTLS_PK_DSA) {
- err("OpenPGP DSA Key, with %d bits\n", bits);
+ err(0,"OpenPGP DSA Key, with %d bits\n", bits);
ret = gnutls_openpgp_crt_get_pk_dsa_raw(*pgp_crt, &p, &q, &g, &y);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export DSA key parameters (error: %d)\n", ret);
+ err(0,"failed to export DSA key parameters (error: %d)\n", ret);
return 1;
}
}
for (subkeyidx = 0; (subkeyidx < subkeycount) && !found; subkeyidx++) {
ret = gnutls_openpgp_crt_get_subkey_id(*pgp_crt, subkeyidx, curkeyid);
if (ret) {
- err("Could not get keyid of subkey with index %d (error: %d)\n", subkeyidx, ret);
+ err(0,"Could not get keyid of subkey with index %d (error: %d)\n", subkeyidx, ret);
return 1;
}
if (memcmp(*keyid, curkeyid, sizeof(gnutls_openpgp_keyid_t)) == 0) {
- err("exporting subkey index %d\n", subkeyidx);
+ err(0,"exporting subkey index %d\n", subkeyidx);
/* FIXME: this is almost identical to the block above for the
primary key. */
algo = gnutls_openpgp_crt_get_subkey_pk_algorithm(*pgp_crt, subkeyidx, &bits);
if (algo < 0) {
- err("failed to get the algorithm of the OpenPGP public key (error: %d)\n", algo);
+ err(0,"failed to get the algorithm of the OpenPGP public key (error: %d)\n", algo);
return algo;
} else if (algo == GNUTLS_PK_RSA) {
- err("OpenPGP RSA certificate, with %d bits\n", bits);
+ err(0,"OpenPGP RSA certificate, with %d bits\n", bits);
ret = gnutls_openpgp_crt_get_subkey_pk_rsa_raw(*pgp_crt, subkeyidx, &m, &e);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export RSA key parameters (error: %d)\n", ret);
+ err(0,"failed to export RSA key parameters (error: %d)\n", ret);
return 1;
}
} else if (algo == GNUTLS_PK_DSA) {
- err("OpenPGP DSA Key, with %d bits\n", bits);
+ err(0,"OpenPGP DSA Key, with %d bits\n", bits);
ret = gnutls_openpgp_crt_get_subkey_pk_dsa_raw(*pgp_crt, subkeyidx, &p, &q, &g, &y);
if (GNUTLS_E_SUCCESS != ret) {
- err ("failed to export DSA key parameters (error: %d)\n", ret);
+ err(0,"failed to export DSA key parameters (error: %d)\n", ret);
return 1;
}
}
}
if (!found) {
- err("Could not find key in input\n");
+ err(0,"Could not find key in input\n");
return 1;
}
all[3] = &g;
all[4] = &y;
} else {
- err("Key algorithm was neither DSA nor RSA (it was %d). Can't deal. Sorry!\n", algo);
+ err(0,"Key algorithm was neither DSA nor RSA (it was %d). Can't deal. Sorry!\n", algo);
return 1;
}
if (ret = datum_from_string(&algolabel, algoname), ret) {
- err("couldn't label string (error: %d)\n", ret);
+ err(0,"couldn't label string (error: %d)\n", ret);
return ret;
}
pipefd = create_writing_pipe(&child_pid, b64args[0], b64args);
if (pipefd < 0) {
- err("failed to create a writing pipe (returned %d)\n", pipefd);
+ err(0,"failed to create a writing pipe (returned %d)\n", pipefd);
return pipefd;
}
write(1, output_data, strlen(output_data));
if (0 != write_data_fd_with_length(pipefd, all, mpicount)) {
- err("was not able to write out RSA key data\n");
+ err(0,"was not able to write out RSA key data\n");
return 1;
}
close(pipefd);
if (child_pid != waitpid(child_pid, &pipestatus, 0)) {
- err("could not wait for child process to return for some reason.\n");
+ err(0,"could not wait for child process to return for some reason.\n");
return 1;
}
if (pipestatus != 0) {
- err("base64 pipe died with return code %d\n", pipestatus);
+ err(0,"base64 pipe died with return code %d\n", pipestatus);
return pipestatus;
}
/* slurp in the key from stdin */
if (ret = set_datum_fd(&data, 0), ret) {
- err("didn't read file descriptor 0\n");
+ err(0,"didn't read file descriptor 0\n");
return 1;
}
if (ret = gnutls_openpgp_privkey_init(&pgp_privkey), ret) {
- err("Failed to initialized OpenPGP private key (error: %d)\n", ret);
+ err(0,"Failed to initialized OpenPGP private key (error: %d)\n", ret);
return 1;
}
/* check whether it's a private key or a public key, by trying them: */
if ((gnutls_openpgp_privkey_import(pgp_privkey, &data, GNUTLS_OPENPGP_FMT_RAW, NULL, 0) == 0) ||
(gnutls_openpgp_privkey_import(pgp_privkey, &data, GNUTLS_OPENPGP_FMT_BASE64, NULL, 0) == 0)) {
/* we're dealing with a private key */
- err("Translating private key\n");
+ err(0,"Translating private key\n");
if (ret = gnutls_x509_privkey_init(&x509_privkey), ret) {
- err("Failed to initialize X.509 private key for output (error: %d)\n", ret);
+ err(0,"Failed to initialize X.509 private key for output (error: %d)\n", ret);
return 1;
}
} else {
if (ret = gnutls_openpgp_crt_init(&pgp_crt), ret) {
- err("Failed to initialized OpenPGP certificate (error: %d)\n", ret);
+ err(0,"Failed to initialized OpenPGP certificate (error: %d)\n", ret);
return 1;
}
if ((gnutls_openpgp_crt_import(pgp_crt, &data, GNUTLS_OPENPGP_FMT_RAW) == 0) ||
(gnutls_openpgp_crt_import(pgp_crt, &data, GNUTLS_OPENPGP_FMT_BASE64) == 0)) {
/* we're dealing with a public key */
- err("Translating public key\n");
+ err(0,"Translating public key\n");
ret = emit_public_openssh_from_pgp(&pgp_crt, use_keyid);
} else {
/* we have no idea what kind of key this is at all anyway! */
- err("Input does contain any form of OpenPGP key I recognize.");
+ err(0,"Input does contain any form of OpenPGP key I recognize.");
return 1;
}
}
projects / monkeysphere.git / commitdiff