← Back to branch summary

~ubuntu-branches/ubuntu/saucy/geary/saucy-updates

« back to all changes in this revision

Viewing changes to src/engine/api/geary-endpoint.vala

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2013-03-14 13:48:23 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20130314134823-gyk5av1g508zyj8a
Tags: 0.3.0~pr1-0ubuntu1
https://launchpad.net/bugs/1154316
New upstream version (FFE lp: #1154316), supports multiple account as
well as full conversation views with inline replies

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/engine/api/geary-endpoint.vala
36
36
    public uint16 default_port { get; private set; }
37
37
    public Flags flags { get; private set; }
38
38
    public uint timeout_sec { get; private set; }
 
39
    public TlsCertificateFlags tls_validation_flags { get; set; default = TlsCertificateFlags.VALIDATE_ALL; }
 
40
    public bool force_ssl3 { get; set; default = false; }
39
41
    
40
42
    public bool is_ssl { get {
41
43
        return flags.is_all_set(Flags.SSL);
60
62
 
61
63
        socket_client = new SocketClient();
62
64
 
63
 
        if (flags.is_all_set(Flags.SSL)) {
 
65
        if (is_ssl) {
64
66
            socket_client.set_tls(true);
65
 
            socket_client.set_tls_validation_flags(TlsCertificateFlags.UNKNOWN_CA);
 
67
            socket_client.set_tls_validation_flags(tls_validation_flags);
 
68
            socket_client.event.connect(on_socket_client_event);
66
69
        }
67
70
 
68
71
        socket_client.set_timeout(timeout_sec);
81
84
        return cx;
82
85
    }
83
86
    
 
87
    public async TlsClientConnection starttls_handshake_async(IOStream base_stream,
 
88
        SocketConnectable connectable, Cancellable? cancellable = null) throws Error {
 
89
        TlsClientConnection tls_cx = TlsClientConnection.new(base_stream, connectable);
 
90
        prepare_tls_cx(tls_cx, true);
 
91
        
 
92
        yield tls_cx.handshake_async(Priority.DEFAULT, cancellable);
 
93
        
 
94
        return tls_cx;
 
95
    }
 
96
    
 
97
    private void on_socket_client_event(SocketClientEvent event, SocketConnectable? connectable,
 
98
        IOStream? ios) {
 
99
        // get TlsClientConnection to bind signals and set flags prior to handshake
 
100
        if (event == SocketClientEvent.TLS_HANDSHAKING)
 
101
            prepare_tls_cx((TlsClientConnection) ios, false);
 
102
    }
 
103
    
 
104
    private void prepare_tls_cx(TlsClientConnection tls_cx, bool starttls) {
 
105
        tls_cx.use_ssl3 = force_ssl3;
 
106
        tls_cx.set_validation_flags(tls_validation_flags);
 
107
        
 
108
        // Vala doesn't do delegates in a ternary operator very well
 
109
        if (starttls)
 
110
            tls_cx.accept_certificate.connect(on_accept_starttls_certificate);
 
111
        else
 
112
            tls_cx.accept_certificate.connect(on_accept_ssl_certificate);
 
113
    }
 
114
    
 
115
    private bool on_accept_starttls_certificate(TlsConnection cx, TlsCertificate cert, TlsCertificateFlags flags) {
 
116
        return report_tls_warnings("STARTTLS", flags);
 
117
    }
 
118
    
 
119
    private bool on_accept_ssl_certificate(TlsConnection cx, TlsCertificate cert, TlsCertificateFlags flags) {
 
120
        return report_tls_warnings("SSL", flags);
 
121
    }
 
122
    
 
123
    private bool report_tls_warnings(string cx_type, TlsCertificateFlags warnings) {
 
124
        // TODO: Report or verify flags with user, but for now merely log for informational/debugging
 
125
        // reasons and accede
 
126
        message("%s TLS warnings connecting to %s: %Xh (%s)", cx_type, to_string(), warnings,
 
127
            tls_flags_to_string(warnings));
 
128
        
 
129
        return true;
 
130
    }
 
131
    
 
132
    private string tls_flags_to_string(TlsCertificateFlags flags) {
 
133
        StringBuilder builder = new StringBuilder();
 
134
        for (int pos = 0; pos < sizeof (TlsCertificateFlags) * 8; pos++) {
 
135
            TlsCertificateFlags flag = flags & (1 << pos);
 
136
            if (flag != 0) {
 
137
                if (!String.is_empty(builder.str))
 
138
                    builder.append(" | ");
 
139
                
 
140
                builder.append(tls_flag_to_string(flag));
 
141
            }
 
142
        }
 
143
        
 
144
        return !String.is_empty(builder.str) ? builder.str : "(none)";
 
145
    }
 
146
    
 
147
    // Vala to_string() for Flags enums currently doesn't work -- bummer...
 
148
    // Should only be called when a single flag is set, otherwise returns a string indicating an
 
149
    // unknown value
 
150
    public string tls_flag_to_string(TlsCertificateFlags flag) {
 
151
        switch (flag) {
 
152
            case TlsCertificateFlags.BAD_IDENTITY:
 
153
                return "BAD_IDENTITY";
 
154
            
 
155
            case TlsCertificateFlags.EXPIRED:
 
156
                return "EXPIRED";
 
157
            
 
158
            case TlsCertificateFlags.GENERIC_ERROR:
 
159
                return "GENERIC_ERROR";
 
160
            
 
161
            case TlsCertificateFlags.INSECURE:
 
162
                return "INSECURE";
 
163
            
 
164
            case TlsCertificateFlags.NOT_ACTIVATED:
 
165
                return "NOT_ACTIVATED";
 
166
            
 
167
            case TlsCertificateFlags.REVOKED:
 
168
                return "REVOKED";
 
169
            
 
170
            case TlsCertificateFlags.UNKNOWN_CA:
 
171
                return "UNKNOWN_CA";
 
172
            
 
173
            default:
 
174
                return "(unknown=%Xh)".printf(flag);
 
175
        }
 
176
    }
 
177
    
84
178
    /**
85
179
     * Returns true if a STARTTLS command should be attempted on the connection:
86
180
     * (a) STARTTLS is reported available (a parameter specified by the caller to this method),