void GPGWrapper::init()
{
if (initialized)
return;
initialized = true;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
gpgme_error_t error = gpgme_new(&context);
fail_if_err(error, L"Nie uda³o siê zainicjowaæ kontekstu GPG.");
gpgme_set_textmode(context, 1);
gpgme_set_armor(context, 1);
error = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
fail_if_err(error, L"Nie zainstalowano OpenPGP.");
error = gpgme_set_protocol(context, GPGME_PROTOCOL_OpenPGP);
fail_if_err(error, L"Nie uda³o siê ustawiæ OpenPGP.");
privateKey = getPrivateKey(privateKeyId.c_str());
error = gpgme_signers_add(context, privateKey);
fail_if_err(error, L"Nie uda³o siê ustawiæ klucza prywatnego.");
}
/**
* Initialize the GPGME library.
* This can be safely called multiple times; however it is not thread-safe.
* @param handle the context handle
* @return 0 on success, -1 on error
*/
static int init_gpgme(alpm_handle_t *handle)
{
static int init = 0;
const char *version, *sigdir;
gpgme_error_t gpg_err;
gpgme_engine_info_t enginfo;
if(init) {
/* we already successfully initialized the library */
return 0;
}
sigdir = handle->gpgdir;
if(_alpm_access(handle, sigdir, "pubring.gpg", R_OK)
|| _alpm_access(handle, sigdir, "trustdb.gpg", R_OK)) {
handle->pm_errno = ALPM_ERR_NOT_A_FILE;
_alpm_log(handle, ALPM_LOG_DEBUG, "Signature verification will fail!\n");
_alpm_log(handle, ALPM_LOG_WARNING,
_("Public keyring not found; have you run '%s'?\n"),
"pacman-key --init");
}
/* calling gpgme_check_version() returns the current version and runs
* some internal library setup code */
version = gpgme_check_version(NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
/* NOTE:
* The GPGME library installs a SIGPIPE signal handler automatically if
* the default signal hander is in use. The only time we set a handler
* for SIGPIPE is in dload.c, and we reset it when we are done. Given that
* we do this, we can let GPGME do its automagic. However, if we install
* a library-wide SIGPIPE handler, we will have to be careful.
*/
/* check for OpenPGP support (should be a no-brainer, but be safe) */
gpg_err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
CHECK_ERR();
/* set and check engine information */
gpg_err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, NULL, sigdir);
CHECK_ERR();
gpg_err = gpgme_get_engine_info(&enginfo);
CHECK_ERR();
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
enginfo->file_name, enginfo->home_dir);
init = 1;
return 0;
gpg_error:
_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(gpg_err));
RET_ERR(handle, ALPM_ERR_GPGME, -1);
}
static void
init_gpgme ()
{
setlocale (LC_ALL, "");
gpgme_check_version (NULL);
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
}
static gpgme_error_t geanypg_init_gpgme(void)
{
/* Initialize the locale environment. */
setlocale(LC_ALL, "");
fprintf(stderr, "GeanyPG: %s %s\n", _("Using libgpgme version:"),
gpgme_check_version("1.1.0"));
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES /* only necessary for portability to W32 systems */
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
return gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
}
int
main (int argc, char **argv )
{
gpgme_check_version (NULL);
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifndef HAVE_W32_SYSTEM
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
print_gpgconf_string ("gpg", "group");
return 0;
}
static int init_gpgme(alpm_handle_t *handle)
{
static int init = 0;
const char *version, *sigdir;
gpgme_error_t err;
gpgme_engine_info_t enginfo;
if(init) {
/* we already successfully initialized the library */
return 0;
}
sigdir = alpm_option_get_gpgdir(handle);
/* calling gpgme_check_version() returns the current version and runs
* some internal library setup code */
version = gpgme_check_version(NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
#endif
/* NOTE:
* The GPGME library installs a SIGPIPE signal handler automatically if
* the default signal hander is in use. The only time we set a handler
* for SIGPIPE is in dload.c, and we reset it when we are done. Given that
* we do this, we can let GPGME do its automagic. However, if we install
* a library-wide SIGPIPE handler, we will have to be careful.
*/
/* check for OpenPGP support (should be a no-brainer, but be safe) */
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
CHECK_ERR();
/* set and check engine information */
err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, NULL, sigdir);
CHECK_ERR();
err = gpgme_get_engine_info(&enginfo);
CHECK_ERR();
_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
enginfo->file_name, enginfo->home_dir);
init = 1;
return 0;
error:
_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
RET_ERR(handle, ALPM_ERR_GPGME, 1);
}
void KGpgMe::init(gpgme_protocol_t proto)
{
gpgme_error_t err;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
err = gpgme_engine_check_version(proto);
if(err) {
KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
.arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
}
}
gboolean init_gpgme() {
gpgme_error_t err;
gpgme_check_version(NULL);
setlocale(LC_ALL, "");
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if (err) {
return FALSE;
}
return TRUE;
}
void
init_gpgme (gpgme_protocol_t proto)
{
gpgme_error_t err;
gpgme_check_version (NULL);
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifndef HAVE_W32_SYSTEM
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
err = gpgme_engine_check_version (proto);
fail_if_err (err);
}
/* ------------------
* initialize gpgme lib on module load
* ------------------ */
static void init_gpgme ()
{
const char* version;
/* Initialize the locale environment. */
setlocale (LC_ALL, "");
version = gpgme_check_version (NULL);
purple_debug_info(PLUGIN_ID,"Found gpgme version: %s\n",version);
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
// For W32 portability.
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
}
void setup(gpgme_ctx_t * context, telem_gpg_opts * options) {
gpgme_error_t error;
// gpgme_engine_info_t info;
// Set the defaults
setup_options(options);
/* Initializes gpgme */
gpgme_check_version (NULL);
/* Initialize the locale environment. */
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
error = gpgme_new(context);
fail_if_err(error);
/* Setting the output type must be done at the beginning */
gpgme_set_armor(*context, 1);
/* Check OpenPGP */
// error = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
// fail_if_err(error);
// error = gpgme_get_engine_info (&info);
// fail_if_err(error);
// while (info && info->protocol != gpgme_get_protocol(*context)) {
// info = info->next;
// }
// /* TODO: we should test there *is* a suitable protocol */
// fprintf (stderr, "Engine OpenPGP %s is installed at %s\n", info->version,
// info->file_name); /* And not "path" as the documentation says */
// Create the keyring_dir is it doesnt exist
mkdirs(options->keyring_dir);
/* Initializes the context */
error = gpgme_ctx_set_engine_info(
*context,
GPGME_PROTOCOL_OpenPGP,
NULL,
options->keyring_dir
);
fail_if_err(error);
}
c_gpgme::c_gpgme() {
setlocale (LC_ALL, "");
gpgme_set_locale(nullptr, LC_CTYPE, setlocale (LC_CTYPE, nullptr));
gpgme_check_version(nullptr);
m_error_code = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
m_error_code = gpgme_new(&m_ctx);
assert(m_ctx != nullptr);
#ifdef __CYGWIN__
m_error_code = gpgme_ctx_set_engine_info (m_ctx, GPGME_PROTOCOL_OpenPGP,
"./gpg.exe", nullptr);
#endif
}
static PyObject *
pygpgme_context_set_locale(PyGpgmeContext *self, PyObject *args)
{
int category;
const char *value;
if (!PyArg_ParseTuple(args, "iz", &category, &value))
return NULL;
if (pygpgme_check_error(gpgme_set_locale(self->ctx, category, value)))
return NULL;
Py_RETURN_NONE;
}
int
main (int argc, char **argv)
{
gpgme_error_t err;
gpgme_error_t op_err;
gpgme_ctx_t ctx;
const char *command;
gpgme_check_version (NULL);
#ifndef HAVE_W32_SYSTEM
setlocale (LC_ALL, "");
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
if (argc)
{
argc--;
argv++;
}
command = argc? *argv : "NOP";
err = gpgme_new (&ctx);
fail_if_err (err);
err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_ASSUAN);
fail_if_err (err);
err = gpgme_op_assuan_transact_ext (ctx, command, data_cb, NULL,
inq_cb, NULL, status_cb, NULL, &op_err);
fail_if_err (err || op_err);
gpgme_release (ctx);
return 0;
}
void
p_gpg_init(void)
{
libversion = gpgme_check_version(NULL);
log_debug("GPG: Found gpgme version: %s", libversion);
gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
pubkeys = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_p_gpg_free_pubkeyid);
key_ac = autocomplete_new();
GHashTable *keys = p_gpg_list_keys();
p_gpg_free_keys(keys);
passphrase = NULL;
passphrase_attempt = NULL;
}
int setup(gpgme_ctx_t* ctx)
{
char *p;
gpgme_error_t err;
gpgme_engine_info_t enginfo;
setlocale (LC_ALL, "");
p = (char *) gpgme_check_version(NULL);
printf("version=%s\n",p);
/* set locale, because tests do also */
gpgme_set_locale(NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
/* check for OpenPGP support */
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if(err != GPG_ERR_NO_ERROR) return 1;
p = (char *) gpgme_get_protocol_name(GPGME_PROTOCOL_OpenPGP);
printf("Protocol name: %s\n",p);
/* get engine information */
err = gpgme_get_engine_info(&enginfo);
if(err != GPG_ERR_NO_ERROR) return 2;
printf("file=%s, home=%s\n",enginfo->file_name,enginfo->home_dir);
/* create our own context */
err = gpgme_new(ctx);
if(err != GPG_ERR_NO_ERROR) return 3;
/* set protocol to use in our context */
err = gpgme_set_protocol(*ctx,GPGME_PROTOCOL_OpenPGP);
if(err != GPG_ERR_NO_ERROR) return 4;
/* set engine info in our context; I changed it for ceof like this:
err = gpgme_ctx_set_engine_info (*ctx, GPGME_PROTOCOL_OpenPGP,
"/usr/bin/gpg","/home/user/nico/.ceof/gpg/");
but I'll use standard values for this example: */
err = gpgme_ctx_set_engine_info (*ctx, GPGME_PROTOCOL_OpenPGP,
enginfo->file_name,enginfo->home_dir);
if(err != GPG_ERR_NO_ERROR) return 5;
return 0;
}
GPGME_Error GPGME::init(const QString & gpgHomeDir)
{
if (instancesStore.contains(gpgHomeDir)) {
return GPG_ERR_NO_ERROR;
}
setlocale(LC_ALL, "");
gpgme_check_version(NULL);
gpgme_set_locale(NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#ifdef LC_MESSAGES
gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
#endif
gpgme_error_t err;
gpgme_ctx_t context;
err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if (err != GPG_ERR_NO_ERROR) {
return err;
}
QString protocolName = gpgme_get_protocol_name(GPGME_PROTOCOL_OpenPGP);
qDebug() << "protocol: " << protocolName;
gpgme_engine_info_t engineInfo;
err = gpgme_get_engine_info(&engineInfo);
if (err != GPG_ERR_NO_ERROR) {
return err;
}
qDebug() << "Backend info";
qDebug() << "filename: " << engineInfo->file_name << ", homedir: " << engineInfo->home_dir;
err = gpgme_new(&context);
if (err != GPG_ERR_NO_ERROR) {
return err;
}
err = gpgme_set_protocol(context, GPGME_PROTOCOL_OpenPGP);
if (err != GPG_ERR_NO_ERROR) {
return err;
}
// we don't need to set gnupg home dir explicitly
QString gnupgHome;
if (gpgHomeDir.isEmpty()) {
// i.e. use default gnupg directory or one from environment
QString gnupgHomeEnv = QString::fromLatin1(qgetenv("GNUPGHOME"));
if (!gnupgHomeEnv.isEmpty()) {
gnupgHome = gnupgHomeEnv;
} else {
// use default path: "~/.gnupg"
QDir gh = QDir::home();
gh.cd(".gnupg");
gnupgHome = gh.canonicalPath();
}
} else {
QDir gh(gpgHomeDir);
gnupgHome = gh.canonicalPath();
}
qDebug() << "GNUPGHOME" << gnupgHome;
err = gpgme_ctx_set_engine_info(context, GPGME_PROTOCOL_OpenPGP,
engineInfo->file_name,
gnupgHome.toLatin1().data()
);
if (err != GPG_ERR_NO_ERROR) {
return err;
}
GPGME * inst = new GPGME(context, gnupgHome);
instancesStore[gpgHomeDir] = inst;
qDebug() << "gpgme initalized for the directory " << gnupgHome << "[store key: " << gpgHomeDir << "]";
return GPG_ERR_NO_ERROR;
}
void sgpgme_init()
{
gchar *ctype_locale = NULL, *messages_locale = NULL;
gchar *ctype_utf8_locale = NULL, *messages_utf8_locale = NULL;
gpgme_engine_info_t engineInfo;
if (gpgme_check_version("1.0.0")) {
#ifdef LC_CTYPE
debug_print("setting gpgme CTYPE locale\n");
#ifdef G_OS_WIN32
ctype_locale = g_win32_getlocale();
#else
ctype_locale = g_strdup(setlocale(LC_CTYPE, NULL));
#endif
if (ctype_locale) {
debug_print("setting gpgme CTYPE locale to: %s\n", ctype_locale);
if (strchr(ctype_locale, '.'))
*(strchr(ctype_locale, '.')) = '\0';
else if (strchr(ctype_locale, '@'))
*(strchr(ctype_locale, '@')) = '\0';
ctype_utf8_locale = g_strconcat(ctype_locale, ".UTF-8", NULL);
debug_print("setting gpgme locale to UTF8: %s\n", ctype_utf8_locale ? ctype_utf8_locale : "NULL");
gpgme_set_locale(NULL, LC_CTYPE, ctype_utf8_locale);
debug_print("done\n");
g_free(ctype_utf8_locale);
g_free(ctype_locale);
} else {
debug_print("couldn't set gpgme CTYPE locale\n");
}
#endif
#ifdef LC_MESSAGES
debug_print("setting gpgme MESSAGES locale\n");
#ifdef G_OS_WIN32
messages_locale = g_win32_getlocale();
#else
messages_locale = g_strdup(setlocale(LC_MESSAGES, NULL));
#endif
if (messages_locale) {
debug_print("setting gpgme MESSAGES locale to: %s\n", messages_locale);
if (strchr(messages_locale, '.'))
*(strchr(messages_locale, '.')) = '\0';
else if (strchr(messages_locale, '@'))
*(strchr(messages_locale, '@')) = '\0';
messages_utf8_locale = g_strconcat(messages_locale, ".UTF-8", NULL);
debug_print("setting gpgme locale to UTF8: %s\n", messages_utf8_locale ? messages_utf8_locale : "NULL");
gpgme_set_locale(NULL, LC_MESSAGES, messages_utf8_locale);
debug_print("done\n");
g_free(messages_utf8_locale);
g_free(messages_locale);
} else {
debug_print("couldn't set gpgme MESSAGES locale\n");
}
#endif
if (!gpgme_get_engine_info(&engineInfo)) {
while (engineInfo) {
debug_print("GpgME Protocol: %s\n"
"Version: %s (req %s)\n"
"Executable: %s\n",
gpgme_get_protocol_name(engineInfo->protocol) ? gpgme_get_protocol_name(engineInfo->protocol):"???",
engineInfo->version ? engineInfo->version:"???",
engineInfo->req_version ? engineInfo->req_version:"???",
engineInfo->file_name ? engineInfo->file_name:"???");
if (engineInfo->protocol == GPGME_PROTOCOL_OpenPGP
&& gpgme_engine_check_version(engineInfo->protocol) !=
GPG_ERR_NO_ERROR) {
if (engineInfo->file_name && !engineInfo->version) {
alertpanel_error(_("Gpgme protocol '%s' is unusable: "
"Engine '%s' isn't installed properly."),
gpgme_get_protocol_name(engineInfo->protocol),
engineInfo->file_name);
} else if (engineInfo->file_name && engineInfo->version
&& engineInfo->req_version) {
alertpanel_error(_("Gpgme protocol '%s' is unusable: "
"Engine '%s' version %s is installed, "
"but version %s is required.\n"),
gpgme_get_protocol_name(engineInfo->protocol),
engineInfo->file_name,
engineInfo->version,
engineInfo->req_version);
} else {
alertpanel_error(_("Gpgme protocol '%s' is unusable "
"(unknown problem)"),
gpgme_get_protocol_name(engineInfo->protocol));
}
}
engineInfo = engineInfo->next;
}
}
} else {
sgpgme_disable_all();
if (prefs_gpg_get_config()->gpg_warning) {
AlertValue val;
val = alertpanel_full
(_("Warning"),
_("GnuPG is not installed properly, or needs "
"to be upgraded.\n"
"OpenPGP support disabled."),
GTK_STOCK_CLOSE, NULL, NULL, TRUE, NULL,
ALERT_WARNING, G_ALERTDEFAULT);
if (val & G_ALERTDISABLE)
prefs_gpg_get_config()->gpg_warning = FALSE;
}
}
}
int main (int argc, char *argv[])
{
int c = -1, option_index = 0, action = 0, i = 0, rval = 0;
slapt_list_t *names = slapt_init_list ();
slapt_src_config *config = NULL;
slapt_src_slackbuild_list *sbs = NULL;
slapt_src_slackbuild_list *remote_sbs = NULL;
slapt_pkg_list_t *installed = NULL;
SLAPT_BOOL_T prompt = SLAPT_TRUE, do_dep = SLAPT_TRUE, simulate = SLAPT_FALSE;
char *config_file = NULL, *postcmd = NULL;
static struct option long_options[] = {
{"version", no_argument, 0, VERSION_OPT},
{"help", no_argument, 0, HELP_OPT},
{"update", no_argument, 0, UPDATE_OPT},
{"list", no_argument, 0, LIST_OPT},
{"clean", no_argument, 0, CLEAN_OPT},
{"e", no_argument, 0, CLEAN_OPT},
{"search", required_argument, 0, SEARCH_OPT},
{"s", required_argument, 0, SEARCH_OPT},
{"show", required_argument, 0, SHOW_OPT},
{"w", required_argument, 0, SHOW_OPT},
{"fetch", required_argument, 0, FETCH_OPT},
{"build", required_argument, 0, BUILD_OPT},
{"install", required_argument, 0, INSTALL_OPT},
{"yes", no_argument, 0, YES_OPT},
{"simulate", no_argument, 0, SIMULATE_OPT},
{"t", no_argument, 0, SIMULATE_OPT},
{"no-dep", no_argument, 0, NODEP_OPT},
{"config", required_argument, 0, CONFIG_OPT},
{"c", required_argument, 0, CONFIG_OPT},
{"postprocess", required_argument, 0, POSTCMD_OPT},
{0, 0, 0, 0}
};
/* initialization */
setbuf (stdout, NULL);
#ifdef ENABLE_NLS
setlocale (LC_ALL,"");
textdomain (GETTEXT_PACKAGE);
#endif
#ifdef SLAPT_HAS_GPGME
gpgme_check_version (NULL);
#ifdef ENABLE_NLS
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#endif
#endif
curl_global_init (CURL_GLOBAL_ALL);
uname (&uname_v);
/* stop early */
if (argc < 2) {
help ();
exit (EXIT_SUCCESS);
}
while ( (c = getopt_long_only (argc, argv, "", long_options, &option_index)) != -1) {
switch (c) {
case HELP_OPT: help (); break;
case VERSION_OPT: version (); break;
case UPDATE_OPT: action = UPDATE_OPT; break;
case LIST_OPT: action = LIST_OPT; break;
case CLEAN_OPT: action = CLEAN_OPT; break;
case FETCH_OPT: action = FETCH_OPT; slapt_add_list_item (names, optarg); break;
case SEARCH_OPT: action = SEARCH_OPT; slapt_add_list_item (names, optarg); break;
case SHOW_OPT: action = SHOW_OPT; slapt_add_list_item (names, optarg); break;
case BUILD_OPT: action = BUILD_OPT; slapt_add_list_item (names, optarg); break;
case INSTALL_OPT: action = INSTALL_OPT; slapt_add_list_item (names, optarg); break;
case YES_OPT: prompt = SLAPT_FALSE; break;
case SIMULATE_OPT: simulate = SLAPT_TRUE; break;
case NODEP_OPT: do_dep = SLAPT_FALSE; break;
case CONFIG_OPT: config_file = strdup (optarg); break;
case POSTCMD_OPT: postcmd = strdup (optarg); break;
default: help (); exit (EXIT_FAILURE);
}
}
/* add extra arguments */
while (optind < argc) {
slapt_add_list_item (names, argv[optind]);
++optind;
}
if (config_file != NULL)
config = slapt_src_read_config (config_file);
else
config = slapt_src_read_config (SLAPT_SRC_RC);
if (config == NULL) {
fprintf (stderr, gettext ("Failed to read %s\n"), SLAPT_SRC_RC);
exit (EXIT_FAILURE);
}
/* honor command line option */
config->do_dep = do_dep;
config->postcmd = postcmd; /* to be freed in slapt_src_config_free */
init_builddir (config);
if ( (chdir (config->builddir)) != 0) {
perror (gettext ("Failed to chdir to build directory"));
exit (EXIT_FAILURE);
}
/* setup, fetch, and other preperation steps */
switch (action) {
case LIST_OPT:
case SEARCH_OPT:
case SHOW_OPT:
remote_sbs = slapt_src_get_available_slackbuilds ();
break;
case FETCH_OPT:
case BUILD_OPT:
case INSTALL_OPT:
remote_sbs = slapt_src_get_available_slackbuilds ();
installed = slapt_get_installed_pkgs ();
/* convert all names to slackbuilds */
if (names->count > 0) {
sbs = slapt_src_names_to_slackbuilds (config, remote_sbs, names, installed);
if (sbs == NULL || sbs->count == 0) {
printf (gettext ("Unable to find all specified slackbuilds.\n"));
exit (EXIT_FAILURE);
}
}
/* provide summary */
if (!simulate)
action = show_summary (sbs, names, action, prompt);
break;
}
/* now, actually do what was requested */
switch (action) {
case UPDATE_OPT:
rval = slapt_src_update_slackbuild_cache (config);
break;
case FETCH_OPT:
for (i = 0; i < sbs->count; i++) {
if (simulate) {
printf (gettext ("FETCH: %s\n"), sbs->slackbuilds[i]->name);
continue;
} else
slapt_src_fetch_slackbuild (config, sbs->slackbuilds[i]);
}
break;
case BUILD_OPT:
for (i = 0; i < sbs->count; i++) {
slapt_src_slackbuild *sb = sbs->slackbuilds[i];
int r = 0, nv_len = strlen (sb->name) + strlen (sb->version) + 2;
char *namever = slapt_malloc (sizeof *namever * nv_len);
r = snprintf (namever, nv_len, "%s:%s", sb->name, sb->version);
if (r+1 != nv_len)
exit (EXIT_FAILURE);
if (simulate) {
printf (gettext ("BUILD: %s\n"), sb->name);
free (namever);
continue;
}
slapt_src_fetch_slackbuild (config, sb);
slapt_src_build_slackbuild (config, sb);
/* XXX we assume if we didn't request the slackbuild, then
it is a dependency, and needs to be installed */
if (slapt_search_list (names, sb->name) == NULL && slapt_search_list (names, namever) == NULL)
slapt_src_install_slackbuild (config, sbs->slackbuilds[i]);
free (namever);
}
break;
case INSTALL_OPT:
for (i = 0; i < sbs->count; i++) {
slapt_src_slackbuild *sb = sbs->slackbuilds[i];
if (simulate) {
printf (gettext ("INSTALL: %s\n"), sb->name);
continue;
}
slapt_src_fetch_slackbuild (config, sb);
slapt_src_build_slackbuild (config, sb);
slapt_src_install_slackbuild (config, sb);
}
break;
case SEARCH_OPT:
{
slapt_src_slackbuild_list *search = slapt_src_search_slackbuild_cache (remote_sbs, names);
for (i = 0; i < search->count; i++) {
slapt_src_slackbuild *sb = search->slackbuilds[i];
printf ("%s:%s - %s\n",
sb->name,
sb->version,
sb->short_desc != NULL ? sb->short_desc : ""
);
}
slapt_src_slackbuild_list_free (search);
}
break;
case LIST_OPT:
for (i = 0; i < remote_sbs->count; i++) {
slapt_src_slackbuild *sb = remote_sbs->slackbuilds[i];
printf ("%s:%s - %s\n",
sb->name,
sb->version,
sb->short_desc != NULL ? sb->short_desc : ""
);
}
break;
case SHOW_OPT:
{
int c;
for (i = 0; i < names->count; i++) {
slapt_src_slackbuild *sb = NULL;
slapt_list_t *parts = slapt_parse_delimited_list (names->items[i], ':');
const char *name = parts->items[0];
const char *ver = NULL;
if (parts->count > 1)
ver = parts->items[1];
sb = slapt_src_get_slackbuild (remote_sbs, name, ver);
if (sb != NULL) {
printf (gettext ("SlackBuild Name: %s\n"), sb->name);
printf (gettext ("SlackBuild Version: %s\n"), sb->version);
printf (gettext ("SlackBuild Category: %s\n"), sb->location);
printf (gettext ("SlackBuild Description: %s\n"), sb->short_desc != NULL ? sb->short_desc : "");
printf (gettext ("SlackBuild Files:\n"));
for (c = 0; c < sb->files->count; c++) {
printf (" %s\n", sb->files->items[c]);
}
if (sb->requires != NULL)
printf (gettext ("SlackBuild Requires: %s\n"), sb->requires);
if (i+1 != names->count)
printf ("\n");
/* slapt_src_slackbuild_free (sb); NO FREE */
}
slapt_free_list (parts);
}
}
break;
case CLEAN_OPT:
clean (config);
break;
}
if (names != NULL)
slapt_free_list (names);
if (sbs != NULL)
slapt_src_slackbuild_list_free (sbs);
if (remote_sbs != NULL)
slapt_src_slackbuild_list_free (remote_sbs);
if (installed != NULL)
slapt_free_pkg_list (installed);
if (config_file != NULL)
free (config_file);
slapt_src_config_free (config);
return rval;
}
int main(int argc, char *argv[])
{
char * op=(char *)0;
char * search=(char *)0;
char * searchdec=(char *)0;
char * exact=(char *)0;
gpgme_ctx_t gpgctx;
gpgme_key_t gpgkey;
gpgme_error_t gpgerr;
gpgme_engine_info_t enginfo;
char * qstring, * pchar;
pchar=getenv("QUERY_STRING");
if (! pchar || *pchar == '\0' ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Error handling request</title></head><body><h1>Error handling request: there is no query string.</h1></body></html>");
return 1;
}
qstring=strndup(pchar,QSTRING_MAX); /* copy the QUERY from env to write in */
pchar=qstring;
while (pchar && *pchar) {
if (!strncmp(pchar,"op=",3)) {
pchar+=3;
op=pchar;
} else if (!strncmp(pchar,"search=",7)) {
pchar+=7;
search=pchar;
} else if (!strncmp(pchar,"options=",8)) {
/*this parameter is useless now, as today we only support "mr" option and always enable it (machine readable) */
pchar+=8;
//options=pchar;
} else if (!strncmp(pchar,"fingerprint=",12)) {
/*this parameter is useless now as we only support "mr" options which don't care this */
pchar+=12;
//fingerprints=pchar;
} else if (!strncmp(pchar,"exact=",6)) {
pchar+=6;
exact=pchar;
} /*else: Other parameter not in hkp draft are quietly ignored */
pchar=strchr(pchar,'&');
if (pchar) {
*pchar='\0';
pchar++;
}
}
if (exact) {
if (!strcmp(exact,"off")) {
exact=(char *) 0; /* off is default */
} else if (!strcmp(exact,"on")) {
http_header(501,CTYPE_HTML_STR);
printf("<html><head><title>Not implemented</title></head><body><h1>Error handling request: \"exact\" parameter is not implemented.</h1></body></html>");
return 1;
} else {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Error handling request</title></head><body><h1>Error handling request: \"exact\" parameter only take \"on\" or \"off\" as argument.</h1></body></html>");
return 1;
}
}
if ( ! search ) {
/* (mandatory parameter) */
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Error handling request</title></head><body><h1>Error handling request: Missing \"search\" parameter in \"%s\".</h1></body></html>",getenv("QUERY_STRING"));
return 1;
} else {
if (searchdec=malloc(strlen(search)*sizeof(char)+1))
strdecode(searchdec,search);
else {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Internal malloc(%d) for search fail.</h1></body></html>",strlen(search)*sizeof(char)+1);
return 1;
}
}
if ( ! op )
op="index"; /* defaut operation */
/* Check gpgme version ( http://www.gnupg.org/documentation/manuals/gpgme/Library-Version-Check.html )*/
setlocale (LC_ALL, "");
gpgme_check_version (NULL);
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
/* check for OpenPGP support */
gpgerr=gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
if ( gpgerr != GPG_ERR_NO_ERROR ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (gpgme_engine_check_version).</h1></body></html>");
return 1;
}
/* create context */
gpgerr=gpgme_new(&gpgctx);
if ( gpgerr != GPG_ERR_NO_ERROR ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (gpgme_new %d).</h1></body></html>",gpgerr);
return 1;
}
/*gpgerr = gpgme_get_engine_info(&enginfo);
gpgerr |= gpgme_ctx_set_engine_info(gpgctx, GPGME_PROTOCOL_OpenPGP, enginfo->file_name,"../../new");
if ( gpgerr != GPG_ERR_NO_ERROR ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (gpgme_ctx_set_engine_info %d).</h1></body></html>",gpgerr);
return 1;
}*/
if (!strcmp(op, "get")) {
gpgme_data_t gpgdata;
char buff[BUFFSIZE];
ssize_t read_bytes;
gpgme_set_armor(gpgctx,1);
gpgerr = gpgme_data_new(&gpgdata);
if (gpgerr == GPG_ERR_NO_ERROR) {
gpgerr = gpgme_data_set_encoding(gpgdata,GPGME_DATA_ENCODING_ARMOR);
if (gpgerr == GPG_ERR_NO_ERROR)
gpgerr = gpgme_op_export(gpgctx,searchdec,0,gpgdata);
}
if ( gpgerr != GPG_ERR_NO_ERROR) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (%d).</h1></body></html>",gpgerr);
return 1;
}
gpgme_data_seek (gpgdata, 0, SEEK_SET);
read_bytes = gpgme_data_read (gpgdata, buff, BUFFSIZE);
if ( read_bytes == -1 ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (%s).</h1></body></html>",gpgme_strerror(errno));
return 1;
} else if ( read_bytes <= 0 ) {
http_header(404,CTYPE_HTML_STR);
printf("<html><head><title>ludd Public Key Server -- Get: %s</title></head><body><h1>Public Key Server -- Get: %s : No key found ! :-( </h1></body></html>",search,search);
return 0;
} else {
http_header(200,CTYPE_HTML_STR);
printf("<html><head><title>ludd Public Key Server -- Get: %s</title></head><body><h1>Public Key Server -- Get: %s</h1><pre>",search,search);
fwrite(buff, sizeof(char),read_bytes,stdout); /* Now it's too late to test fwrite return value ;-) */
while ( (read_bytes = gpgme_data_read (gpgdata, buff, BUFFSIZE)) > 0 )
fwrite(buff, sizeof(char),read_bytes,stdout);
printf("\n</pre></body></html>");
return 0;
}
} else if (!strcmp(op, "index")) {
char uidenc[BUFFSIZE];
char begin=0;
gpgme_user_id_t gpguid;
/* check for the searched key(s) */
gpgerr = gpgme_op_keylist_start(gpgctx, searchdec, 0);
//gpgerr = gpgme_op_keylist_start(gpgctx, NULL, 0);
if ( gpgerr != GPG_ERR_NO_ERROR ) {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Internal Error</title></head><body><h1>Error handling request due to internal error (gpgme_op_keylist_start %d).</h1></body></html>",gpgerr);
return 1;
}
gpgerr = gpgme_op_keylist_next (gpgctx, &gpgkey);
while (gpgerr == GPG_ERR_NO_ERROR) {
if (!begin) {
http_header(200,"text/plain; charset=utf-8");
begin=1;
/* Luckily: info "header" is optionnal, see draft-shaw-openpgp-hkp-00.txt */
}
/* first subkey is the main key */
printf("pub:%s:%d:%d:%d:%d\n",gpgkey->subkeys->fpr,gpgkey->subkeys->pubkey_algo,gpgkey->subkeys->length,gpgkey->subkeys->timestamp,(gpgkey->subkeys->expires?gpgkey->subkeys->expires:-1));
gpguid=gpgkey->uids;
while (gpguid) {
printf("uid:%s (%s) <%s>:\n",gpguid->name,gpguid->comment,gpguid->email);
gpguid=gpguid->next;
}
gpgme_key_unref(gpgkey);
gpgerr = gpgme_op_keylist_next (gpgctx, &gpgkey);
}
gpgme_key_unref(gpgkey); /* ... because i don't know how "gpgme_op_keylist_next" behave when not returning GPG_ERR_NO_ERROR */
if (!begin) {
http_header(404,CTYPE_HTML_STR);
printf("<html><head><title>ludd Public Key Server -- index: %s</title></head><body><h1>index Error: No keys found</h1></body></html>",search);
return 1;
}
return 0;
} else if ( !strcmp(op, "photo") || !strcmp(op, "x-photo") ) {
http_header(501,CTYPE_HTML_STR);
printf("<html><head><title>Not implemented</title></head><body><h1>Error handling request: \"%s\" operation is not implemented.</h1></body></html>",op);
return 1;
} else {
http_header(500,CTYPE_HTML_STR);
printf("<html><head><title>Error handling request</title></head><body><h1>Error handling request: Unrecognized action in \"%s\".</h1></body></html>",getenv("QUERY_STRING"));
return 1;
}
}
/** \brief Initialise GpgME
*
* \param get_passphrase Callback function to read a passphrase from the
* user. Note that this function is used \em only for OpenPGP and
* \em only if no GPG Agent is running and can therefore usually be
* NULL. The first (HOOK) argument the passed function accepts
* shall be the parent GtkWindow.
* \param select_key Callback function to let the user select a key from a
* list if more than one is available.
* \param accept_low_trust Callback function to ask the user whether a low
* trust key shall be accepted.
*
* Initialise the GpgME backend and remember the callback functions.
*
* \note This function \em must be called before using any other function
* from this module.
*/
void
libbalsa_gpgme_init(gpgme_passphrase_cb_t get_passphrase,
lbgpgme_select_key_cb select_key,
lbgpgme_accept_low_trust_cb accept_low_trust)
{
gpgme_engine_info_t e;
const gchar *agent_info;
/* initialise the gpgme library */
g_message("init gpgme version %s", gpgme_check_version(NULL));
#ifdef HAVE_GPG
/* configure the GnuPG engine if a specific gpg path has been
* detected */
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, GPG_PATH, NULL);
#endif
#ifdef ENABLE_NLS
gpgme_set_locale(NULL, LC_CTYPE, get_utf8_locale(LC_CTYPE));
gpgme_set_locale(NULL, LC_MESSAGES, get_utf8_locale(LC_MESSAGES));
#endif /* ENABLE_NLS */
/* dump the available engines */
if (gpgme_get_engine_info(&e) == GPG_ERR_NO_ERROR) {
while (e) {
g_message("protocol %s: engine %s (home %s, version %s)",
gpgme_get_protocol_name(e->protocol),
e->file_name, e->home_dir, e->version);
e = e->next;
}
}
/* check for gpg-agent */
agent_info = g_getenv("GPG_AGENT_INFO");
if (agent_info) {
g_message("gpg-agent found: %s", agent_info);
gpgme_passphrase_cb = NULL;
} else {
gpgme_passphrase_cb = get_passphrase;
}
/* verify that the engines we need are there */
if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) ==
GPG_ERR_NO_ERROR) {
g_message("OpenPGP protocol supported");
has_proto_openpgp = TRUE;
} else {
g_warning
("OpenPGP protocol not supported, basic crypto will not work!");
has_proto_openpgp = FALSE;
}
#ifdef HAVE_SMIME
if (gpgme_engine_check_version(GPGME_PROTOCOL_CMS) ==
GPG_ERR_NO_ERROR) {
g_message("CMS (aka S/MIME) protocol supported");
has_proto_cms = TRUE;
} else {
g_warning("CMS protocol not supported, S/MIME will not work!");
has_proto_cms = FALSE;
}
#else
g_message("built without CMS (aka S/MIME) protocol support");
has_proto_cms = FALSE;
#endif
/* remember callbacks */
select_key = select_key_cb;
accept_low_trust = accept_low_trust_cb;
}
