static void
resume_clicked (GtkWidget * wid, gpointer none)
{
struct DCC *dcc;
char buf[512];
GSList *list;
list = dcc_get_selected ();
if (!list)
return;
dcc = list->data;
g_slist_free (list);
if (dcc->type == TYPE_RECV && !dcc_resume (dcc))
{
switch (dcc->resume_error)
{
case 0: /* unknown error */
fe_message (_("That file is not resumable."), FE_MSG_ERROR);
break;
case 1:
snprintf (buf, sizeof (buf),
_( "Cannot access file: %s\n"
"%s.\n"
"Resuming not possible."), dcc->destfile,
errorstring (dcc->resume_errno));
fe_message (buf, FE_MSG_ERROR);
break;
case 2:
fe_message (_("File in download directory is larger "
"than file offered. Resuming not possible."), FE_MSG_ERROR);
break;
case 3:
fe_message (_("Cannot resume the same file from two people."), FE_MSG_ERROR);
}
}
}
/**
* Enables SSL for the given connection.
*
* @param connection The connection to enable SSL for.
*
* @return IDEVICE_E_SUCCESS on success, IDEVICE_E_INVALID_ARG when connection
* is NULL or connection->ssl_data is non-NULL, or IDEVICE_E_SSL_ERROR when
* SSL initialization, setup, or handshake fails.
*/
idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
{
if (!connection || connection->ssl_data)
return IDEVICE_E_INVALID_ARG;
idevice_error_t ret = IDEVICE_E_SSL_ERROR;
uint32_t return_me = 0;
#ifdef HAVE_OPENSSL
key_data_t root_cert = { NULL, 0 };
key_data_t root_privkey = { NULL, 0 };
userpref_error_t uerr = userpref_device_record_get_keys_and_certs(connection->udid, &root_privkey, &root_cert, NULL, NULL);
if (uerr != USERPREF_E_SUCCESS) {
debug_info("Error %d when loading keys and certificates! %d", uerr);
}
/* Set up OpenSSL */
if (openssl_init_done == 0) {
SSL_library_init();
openssl_init_done = 1;
}
BIO *ssl_bio = BIO_new(BIO_s_socket());
if (!ssl_bio) {
debug_info("ERROR: Could not create SSL bio.");
return ret;
}
BIO_set_fd(ssl_bio, (int)(long)connection->data, BIO_NOCLOSE);
SSL_CTX *ssl_ctx = SSL_CTX_new(SSLv3_method());
if (ssl_ctx == NULL) {
debug_info("ERROR: Could not create SSL context.");
BIO_free(ssl_bio);
return ret;
}
BIO* membp;
X509* rootCert = NULL;
membp = BIO_new_mem_buf(root_cert.data, root_cert.size);
PEM_read_bio_X509(membp, &rootCert, NULL, NULL);
BIO_free(membp);
if (SSL_CTX_use_certificate(ssl_ctx, rootCert) != 1) {
debug_info("WARNING: Could not load RootCertificate");
}
X509_free(rootCert);
free(root_cert.data);
RSA* rootPrivKey = NULL;
membp = BIO_new_mem_buf(root_privkey.data, root_privkey.size);
PEM_read_bio_RSAPrivateKey(membp, &rootPrivKey, NULL, NULL);
BIO_free(membp);
if (SSL_CTX_use_RSAPrivateKey(ssl_ctx, rootPrivKey) != 1) {
debug_info("WARNING: Could not load RootPrivateKey");
}
RSA_free(rootPrivKey);
free(root_privkey.data);
SSL *ssl = SSL_new(ssl_ctx);
if (!ssl) {
debug_info("ERROR: Could not create SSL object");
BIO_free(ssl_bio);
SSL_CTX_free(ssl_ctx);
return ret;
}
SSL_set_connect_state(ssl);
SSL_set_verify(ssl, 0, ssl_verify_callback);
SSL_set_bio(ssl, ssl_bio, ssl_bio);
return_me = SSL_do_handshake(ssl);
if (return_me != 1) {
debug_info("ERROR in SSL_do_handshake: %s", errorstring(SSL_get_error(ssl, return_me)));
BIO_free(ssl_bio);
SSL_CTX_free(ssl_ctx);
} else {
ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private));
ssl_data_loc->session = ssl;
ssl_data_loc->ctx = ssl_ctx;
ssl_data_loc->bio = ssl_bio;
connection->ssl_data = ssl_data_loc;
ret = IDEVICE_E_SUCCESS;
debug_info("SSL mode enabled, cipher: %s", SSL_get_cipher(ssl));
}
#else
ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private));
/* Set up GnuTLS... */
debug_info("enabling SSL mode");
errno = 0;
gnutls_global_init();
gnutls_certificate_allocate_credentials(&ssl_data_loc->certificate);
gnutls_certificate_client_set_retrieve_function (ssl_data_loc->certificate, internal_cert_callback);
gnutls_init(&ssl_data_loc->session, GNUTLS_CLIENT);
gnutls_priority_set_direct(ssl_data_loc->session, "NONE:+VERS-SSL3.0:+ANON-DH:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA1:+MD5:+COMP-NULL", NULL);
gnutls_credentials_set(ssl_data_loc->session, GNUTLS_CRD_CERTIFICATE, ssl_data_loc->certificate);
gnutls_session_set_ptr(ssl_data_loc->session, ssl_data_loc);
gnutls_x509_crt_init(&ssl_data_loc->root_cert);
gnutls_x509_crt_init(&ssl_data_loc->host_cert);
gnutls_x509_privkey_init(&ssl_data_loc->root_privkey);
gnutls_x509_privkey_init(&ssl_data_loc->host_privkey);
userpref_error_t uerr = userpref_device_record_get_keys_and_certs(connection->udid, ssl_data_loc->root_privkey, ssl_data_loc->root_cert, ssl_data_loc->host_privkey, ssl_data_loc->host_cert);
if (uerr != USERPREF_E_SUCCESS) {
debug_info("Error %d when loading keys and certificates! %d", uerr);
}
debug_info("GnuTLS step 1...");
gnutls_transport_set_ptr(ssl_data_loc->session, (gnutls_transport_ptr_t)connection);
debug_info("GnuTLS step 2...");
gnutls_transport_set_push_function(ssl_data_loc->session, (gnutls_push_func) & internal_ssl_write);
debug_info("GnuTLS step 3...");
gnutls_transport_set_pull_function(ssl_data_loc->session, (gnutls_pull_func) & internal_ssl_read);
debug_info("GnuTLS step 4 -- now handshaking...");
if (errno) {
debug_info("WARN: errno says %s before handshake!", strerror(errno));
}
return_me = gnutls_handshake(ssl_data_loc->session);
debug_info("GnuTLS handshake done...");
if (return_me != GNUTLS_E_SUCCESS) {
internal_ssl_cleanup(ssl_data_loc);
free(ssl_data_loc);
debug_info("GnuTLS reported something wrong.");
gnutls_perror(return_me);
debug_info("oh.. errno says %s", strerror(errno));
} else {
connection->ssl_data = ssl_data_loc;
ret = IDEVICE_E_SUCCESS;
debug_info("SSL mode enabled");
}
#endif
return ret;
}
bool HDRMergeOptionsDialog::BuildCommandLineArgument()
{
int selection=m_mode->GetSelection();
m_cmd.Clear();
bool correct_input=true;
double i = 0;
wxString errorstring(_("Invalid input\n"));
switch(selection)
{
case 0:
m_cmd.Append(wxT("-m avg"));
if(m_option_c->IsChecked())
m_cmd.Append(wxT(" -c"));
break;
case 1:
m_cmd.Append(wxT("-m avg_slow"));
break;
case 2:
m_cmd.Append(wxT("-m khan"));
if(m_khan_iter->GetValue())
{
m_cmd.Append(wxString::Format(wxT(" -i %d"),m_khan_iter->GetValue()));
}
else
{
correct_input=false;
errorstring.Append(wxString::Format(_("Input \"%s\" for %s is not a valid number\n"),
m_khan_iter->GetValue(),_("Iteration")));
};
if(m_khan_sigma->GetValue().ToDouble(&i))
{
//change locale for correct numeric output
char * p = setlocale(LC_NUMERIC,NULL);
char * old_locale = strdup(p);
setlocale(LC_NUMERIC,"C");
m_cmd.Append(wxString::Format(wxT(" -s %f"),i));
//reset locale
setlocale(LC_NUMERIC,old_locale);
free(old_locale);
}
else
{
correct_input=false;
errorstring.Append(wxString::Format(_("Input \"%s\" for %s is not a valid number\n"),
m_khan_iter->GetValue(),_("Sigma")));
};
if(m_option_khan_af->IsChecked() || m_option_khan_ag->IsChecked() ||
m_option_khan_am->IsChecked())
{
m_cmd.Append(wxT(" -a "));
if(m_option_khan_af->IsChecked())
m_cmd.Append(wxT("f"));
if(m_option_khan_ag->IsChecked())
m_cmd.Append(wxT("g"));
if(m_option_khan_am->IsChecked())
m_cmd.Append(wxT("m"));
}
break;
};
if(!correct_input)
wxMessageBox(errorstring,_("Wrong input"),wxOK | wxICON_INFORMATION);
return correct_input;
};
