static void ft_handler_populate_outgoing_request (EmpathyFTHandler *handler) { guint contact_handle; EmpathyFTHandlerPriv *priv = handler->priv; gchar *uri; contact_handle = tp_contact_get_handle (priv->contact); uri = g_file_get_uri (priv->gfile); priv->request = tp_asv_new ( TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT, TP_PROP_CHANNEL_TARGET_HANDLE, G_TYPE_UINT, contact_handle, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_TYPE, G_TYPE_STRING, priv->content_type, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_FILENAME, G_TYPE_STRING, priv->filename, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_SIZE, G_TYPE_UINT64, priv->total_bytes, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_DATE, G_TYPE_UINT64, priv->mtime, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_URI, G_TYPE_STRING, uri, NULL); if (priv->service_name != NULL) tp_asv_set_string (priv->request, TP_PROP_CHANNEL_INTERFACE_FILE_TRANSFER_METADATA_SERVICE_NAME, priv->service_name); if (priv->description != NULL) tp_asv_set_string (priv->request, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_DESCRIPTION, priv->description); g_free (uri); }
static gboolean handle_subject (WockyNode *parent_node, GHashTable *mail) { gboolean dirty = FALSE; WockyNode *node; node = wocky_node_get_child (parent_node, "subject"); if (node != NULL) { if (tp_strdiff (node->content, tp_asv_get_string (mail, "subject"))) { dirty = TRUE; tp_asv_set_string (mail, "subject", node->content); } } return dirty; }
static void change_current_state (GabbleServerSaslChannel *self, TpSASLStatus status, const gchar *dbus_error, const gchar *debug_message) { self->priv->sasl_status = status; g_free (self->priv->sasl_error); self->priv->sasl_error = g_strdup (dbus_error); g_hash_table_remove_all (self->priv->sasl_error_details); if (debug_message != NULL) tp_asv_set_string (self->priv->sasl_error_details, "debug-message", debug_message); tp_svc_channel_interface_sasl_authentication_emit_sasl_status_changed ( self, self->priv->sasl_status, self->priv->sasl_error, self->priv->sasl_error_details); }
static gboolean hash_job_done (gpointer user_data) { HashingData *hash_data = user_data; EmpathyFTHandler *handler = hash_data->handler; EmpathyFTHandlerPriv *priv; GError *error = NULL; DEBUG ("Closing stream after hashing."); priv = GET_PRIV (handler); if (hash_data->error != NULL) { error = hash_data->error; hash_data->error = NULL; goto cleanup; } DEBUG ("Got file hash %s", g_checksum_get_string (hash_data->checksum)); if (empathy_ft_handler_is_incoming (handler)) { if (g_strcmp0 (g_checksum_get_string (hash_data->checksum), priv->content_hash)) { DEBUG ("Hash mismatch when checking incoming handler: " "received %s, calculated %s", priv->content_hash, g_checksum_get_string (hash_data->checksum)); error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK, EMPATHY_FT_ERROR_HASH_MISMATCH, _("File transfer completed, but the file was corrupted")); goto cleanup; } else { DEBUG ("Hash verification matched, received %s, calculated %s", priv->content_hash, g_checksum_get_string (hash_data->checksum)); } } else { /* set the checksum in the request... * org.freedesktop.Telepathy.Channel.Type.FileTransfer.ContentHash */ tp_asv_set_string (priv->request, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_HASH, g_checksum_get_string (hash_data->checksum)); } cleanup: if (error != NULL) { emit_error_signal (handler, error); g_clear_error (&error); } else { g_signal_emit (handler, signals[HASHING_DONE], 0); if (!empathy_ft_handler_is_incoming (handler)) /* the request is complete now, push it to the dispatcher */ ft_handler_push_to_dispatcher (handler); } hash_data_free (hash_data); return FALSE; }
static void real_start_verification(HevImpathyTLSVerifier *self) { HevImpathyTLSVerifierPrivate *priv = HEV_IMPATHY_TLS_VERIFIER_GET_PRIVATE(self); gnutls_x509_crt_t first_cert = 0, last_cert = 0; gint idx = 0; gboolean res = FALSE; gint num_certs = 0; TpTLSCertificateRejectReason reason = TP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); /* check if the certificate matches the hostname first. */ first_cert = g_ptr_array_index(priv->cert_chain, 0); if(0 == gnutls_x509_crt_check_hostname(first_cert, priv->hostname)) { gchar *certified_hostname = NULL; reason = TP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH; certified_hostname = (gchar *)hev_impathy_get_x509_certificate_hostname(first_cert); tp_asv_set_string(priv->details, "expected-hostname", priv->hostname); tp_asv_set_string(priv->details, "certificate-hostname", certified_hostname); g_free(certified_hostname); goto out; } num_certs = priv->cert_chain->len; if(0 < priv->trusted_ca_list->len) { /* if the last certificate is self-signed, and we have a list of * trusted CAs, ignore it, as we want to check the chain against our * trusted CAs list first. * if we have only one certificate in the chain, don't ignore it though, * as it's the CA certificate itself. */ last_cert = g_ptr_array_index(priv->cert_chain, num_certs - 1); if((0<gnutls_x509_crt_check_issuer(last_cert, last_cert)) && (1<num_certs)) num_certs --; } for (idx = 1; idx < num_certs; idx++) { res = verify_certificate(self, g_ptr_array_index(priv->cert_chain, idx-1), g_ptr_array_index(priv->cert_chain, idx), &reason); if(!res) { abort_verification(self, reason); return; } } res = verify_last_certificate(self, g_ptr_array_index(priv->cert_chain, num_certs - 1), &reason); out: if(!res) { abort_verification(self, reason); return; } complete_verification(self); }
static void perform_verification (EmpathyTLSVerifier *self, GcrCertificateChain *chain) { gboolean ret = FALSE; EmpTLSCertificateRejectReason reason = EMP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN; gnutls_x509_crt_t *list, *anchors; guint n_list, n_anchors; guint verify_output; gint res; gint i; gboolean matched = FALSE; EmpathyTLSVerifierPriv *priv = GET_PRIV (self); DEBUG ("Performing verification"); debug_certificate_chain (chain); list = anchors = NULL; n_list = n_anchors = 0; /* * If the first certificate is an pinned certificate then we completely * ignore the rest of the verification process. */ if (gcr_certificate_chain_get_status (chain) == GCR_CERTIFICATE_CHAIN_PINNED) { DEBUG ("Found pinned certificate for %s", priv->hostname); complete_verification (self); goto out; } build_certificate_list_for_gnutls (chain, &list, &n_list, &anchors, &n_anchors); if (list == NULL || n_list == 0) { g_warn_if_reached (); abort_verification (self, EMP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN); goto out; } verify_output = 0; res = gnutls_x509_crt_list_verify (list, n_list, anchors, n_anchors, NULL, 0, 0, &verify_output); ret = verification_output_to_reason (res, verify_output, &reason); DEBUG ("Certificate verification gave result %d with reason %u", ret, reason); if (!ret) { abort_verification (self, reason); goto out; } /* now check if the certificate matches one of the reference identities. */ if (priv->reference_identities != NULL) { for (i = 0, matched = FALSE; priv->reference_identities[i] != NULL; ++i) { if (gnutls_x509_crt_check_hostname (list[0], priv->reference_identities[i]) == 1) { matched = TRUE; break; } } } if (!matched) { gchar *certified_hostname; certified_hostname = empathy_get_x509_certificate_hostname (list[0]); tp_asv_set_string (priv->details, "expected-hostname", priv->hostname); tp_asv_set_string (priv->details, "certificate-hostname", certified_hostname); DEBUG ("Hostname mismatch: got %s but expected %s", certified_hostname, priv->hostname); g_free (certified_hostname); abort_verification (self, EMP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH); goto out; } DEBUG ("Hostname matched"); complete_verification (self); out: free_certificate_list_for_gnutls (list, n_list); free_certificate_list_for_gnutls (anchors, n_anchors); }