1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17package com.squareup.okhttp.internal.http;
18
19import com.squareup.okhttp.Handshake;
20import java.io.IOException;
21import java.io.InputStream;
22import java.io.OutputStream;
23import java.net.HttpURLConnection;
24import java.net.ProtocolException;
25import java.net.URL;
26import java.security.Permission;
27import java.security.Principal;
28import java.security.cert.Certificate;
29import java.util.List;
30import java.util.Map;
31import javax.net.ssl.HostnameVerifier;
32import javax.net.ssl.HttpsURLConnection;
33import javax.net.ssl.SSLPeerUnverifiedException;
34import javax.net.ssl.SSLSocketFactory;
35
36/**
37 * Implement an HTTPS connection by delegating to an HTTP connection for
38 * everything but the HTTPS-specific stuff.
39 */
40abstract class DelegatingHttpsURLConnection extends HttpsURLConnection {
41  private final HttpURLConnection delegate;
42
43  public DelegatingHttpsURLConnection(HttpURLConnection delegate) {
44    super(delegate.getURL());
45    this.delegate = delegate;
46  }
47
48  protected abstract Handshake handshake();
49
50  @Override public abstract void setHostnameVerifier(HostnameVerifier hostnameVerifier);
51
52  @Override public abstract HostnameVerifier getHostnameVerifier();
53
54  @Override public abstract void setSSLSocketFactory(SSLSocketFactory sslSocketFactory);
55
56  @Override public abstract SSLSocketFactory getSSLSocketFactory();
57
58  @Override public String getCipherSuite() {
59    Handshake handshake = handshake();
60    return handshake != null ? handshake.cipherSuite() : null;
61  }
62
63  @Override public Certificate[] getLocalCertificates() {
64    Handshake handshake = handshake();
65    if (handshake == null) return null;
66    List<Certificate> result = handshake.localCertificates();
67    return !result.isEmpty() ? result.toArray(new Certificate[result.size()]) : null;
68  }
69
70  @Override public Certificate[] getServerCertificates() throws SSLPeerUnverifiedException {
71    Handshake handshake = handshake();
72    if (handshake == null) return null;
73    List<Certificate> result = handshake.peerCertificates();
74    return !result.isEmpty() ? result.toArray(new Certificate[result.size()]) : null;
75  }
76
77  @Override public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {
78    Handshake handshake = handshake();
79    return handshake != null ? handshake.peerPrincipal() : null;
80  }
81
82  @Override public Principal getLocalPrincipal() {
83    Handshake handshake = handshake();
84    return handshake != null ? handshake.localPrincipal() : null;
85  }
86
87  @Override public void connect() throws IOException {
88    connected = true;
89    delegate.connect();
90  }
91
92  @Override public void disconnect() {
93    delegate.disconnect();
94  }
95
96  @Override public InputStream getErrorStream() {
97    return delegate.getErrorStream();
98  }
99
100  @Override public String getRequestMethod() {
101    return delegate.getRequestMethod();
102  }
103
104  @Override public int getResponseCode() throws IOException {
105    return delegate.getResponseCode();
106  }
107
108  @Override public String getResponseMessage() throws IOException {
109    return delegate.getResponseMessage();
110  }
111
112  @Override public void setRequestMethod(String method) throws ProtocolException {
113    delegate.setRequestMethod(method);
114  }
115
116  @Override public boolean usingProxy() {
117    return delegate.usingProxy();
118  }
119
120  @Override public boolean getInstanceFollowRedirects() {
121    return delegate.getInstanceFollowRedirects();
122  }
123
124  @Override public void setInstanceFollowRedirects(boolean followRedirects) {
125    delegate.setInstanceFollowRedirects(followRedirects);
126  }
127
128  @Override public boolean getAllowUserInteraction() {
129    return delegate.getAllowUserInteraction();
130  }
131
132  @Override public Object getContent() throws IOException {
133    return delegate.getContent();
134  }
135
136  @SuppressWarnings("unchecked") // Spec does not generify
137  @Override public Object getContent(Class[] types) throws IOException {
138    return delegate.getContent(types);
139  }
140
141  @Override public String getContentEncoding() {
142    return delegate.getContentEncoding();
143  }
144
145  @Override public int getContentLength() {
146    return delegate.getContentLength();
147  }
148
149  @Override public String getContentType() {
150    return delegate.getContentType();
151  }
152
153  @Override public long getDate() {
154    return delegate.getDate();
155  }
156
157  @Override public boolean getDefaultUseCaches() {
158    return delegate.getDefaultUseCaches();
159  }
160
161  @Override public boolean getDoInput() {
162    return delegate.getDoInput();
163  }
164
165  @Override public boolean getDoOutput() {
166    return delegate.getDoOutput();
167  }
168
169  @Override public long getExpiration() {
170    return delegate.getExpiration();
171  }
172
173  @Override public String getHeaderField(int pos) {
174    return delegate.getHeaderField(pos);
175  }
176
177  @Override public Map<String, List<String>> getHeaderFields() {
178    return delegate.getHeaderFields();
179  }
180
181  @Override public Map<String, List<String>> getRequestProperties() {
182    return delegate.getRequestProperties();
183  }
184
185  @Override public void addRequestProperty(String field, String newValue) {
186    delegate.addRequestProperty(field, newValue);
187  }
188
189  @Override public String getHeaderField(String key) {
190    return delegate.getHeaderField(key);
191  }
192
193  @Override public long getHeaderFieldDate(String field, long defaultValue) {
194    return delegate.getHeaderFieldDate(field, defaultValue);
195  }
196
197  @Override public int getHeaderFieldInt(String field, int defaultValue) {
198    return delegate.getHeaderFieldInt(field, defaultValue);
199  }
200
201  @Override public String getHeaderFieldKey(int position) {
202    return delegate.getHeaderFieldKey(position);
203  }
204
205  @Override public long getIfModifiedSince() {
206    return delegate.getIfModifiedSince();
207  }
208
209  @Override public InputStream getInputStream() throws IOException {
210    return delegate.getInputStream();
211  }
212
213  @Override public long getLastModified() {
214    return delegate.getLastModified();
215  }
216
217  @Override public OutputStream getOutputStream() throws IOException {
218    return delegate.getOutputStream();
219  }
220
221  @Override public Permission getPermission() throws IOException {
222    return delegate.getPermission();
223  }
224
225  @Override public String getRequestProperty(String field) {
226    return delegate.getRequestProperty(field);
227  }
228
229  @Override public URL getURL() {
230    return delegate.getURL();
231  }
232
233  @Override public boolean getUseCaches() {
234    return delegate.getUseCaches();
235  }
236
237  @Override public void setAllowUserInteraction(boolean newValue) {
238    delegate.setAllowUserInteraction(newValue);
239  }
240
241  @Override public void setDefaultUseCaches(boolean newValue) {
242    delegate.setDefaultUseCaches(newValue);
243  }
244
245  @Override public void setDoInput(boolean newValue) {
246    delegate.setDoInput(newValue);
247  }
248
249  @Override public void setDoOutput(boolean newValue) {
250    delegate.setDoOutput(newValue);
251  }
252
253  @Override public void setIfModifiedSince(long newValue) {
254    delegate.setIfModifiedSince(newValue);
255  }
256
257  @Override public void setRequestProperty(String field, String newValue) {
258    delegate.setRequestProperty(field, newValue);
259  }
260
261  @Override public void setUseCaches(boolean newValue) {
262    delegate.setUseCaches(newValue);
263  }
264
265  @Override public void setConnectTimeout(int timeoutMillis) {
266    delegate.setConnectTimeout(timeoutMillis);
267  }
268
269  @Override public int getConnectTimeout() {
270    return delegate.getConnectTimeout();
271  }
272
273  @Override public void setReadTimeout(int timeoutMillis) {
274    delegate.setReadTimeout(timeoutMillis);
275  }
276
277  @Override public int getReadTimeout() {
278    return delegate.getReadTimeout();
279  }
280
281  @Override public String toString() {
282    return delegate.toString();
283  }
284
285  @Override public void setFixedLengthStreamingMode(int contentLength) {
286    delegate.setFixedLengthStreamingMode(contentLength);
287  }
288
289  @Override public void setChunkedStreamingMode(int chunkLength) {
290    delegate.setChunkedStreamingMode(chunkLength);
291  }
292}
293