1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
/**
* Copyright (c) 2013 LEAP Encryption Access Project and contributers
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package se.leap.bitmaskclient;
import android.os.*;
import org.json.*;
import java.io.*;
import java.net.*;
import java.util.*;
/**
* @author Sean Leonard <meanderingcode@aetherislands.net>
* @author Parménides GV <parmegv@sdf.org>
*/
public final class Provider implements Parcelable {
private JSONObject definition = new JSONObject(); // Represents our Provider's provider.json
private DefaultedURL main_url = new DefaultedURL();
private String certificate_pin = "";
final public static String
API_URL = "api_uri",
API_VERSION = "api_version",
ALLOW_REGISTRATION = "allow_registration",
API_RETURN_SERIAL = "serial",
SERVICE = "service",
KEY = "provider",
CA_CERT = "ca_cert",
CA_CERT_URI = "ca_cert_uri",
CA_CERT_FINGERPRINT = "ca_cert_fingerprint",
NAME = "name",
DESCRIPTION = "description",
DOMAIN = "domain",
MAIN_URL = "main_url",
DOT_JSON_URL = "provider_json_url";
// Array of what API versions we understand
protected static final String[] API_VERSIONS = {"1"}; // I assume we might encounter arbitrary version "numbers"
// Some API pieces we want to know about
private static final String API_TERM_SERVICES = "services";
private static final String API_TERM_NAME = "name";
private static final String API_TERM_DOMAIN = "domain";
private static final String API_TERM_DEFAULT_LANGUAGE = "default_language";
protected static final String[] API_EIP_TYPES = {"openvpn"};
public Provider() { }
public Provider(URL main_url) {
this.main_url.setUrl(main_url);
}
public Provider(URL main_url, String certificate_pin) {
this.main_url.setUrl(main_url);
this.certificate_pin = certificate_pin;
}
public static final Parcelable.Creator<Provider> CREATOR
= new Parcelable.Creator<Provider>() {
public Provider createFromParcel(Parcel in) {
return new Provider(in);
}
public Provider[] newArray(int size) {
return new Provider[size];
}
};
private Provider(Parcel in) {
try {
main_url.setUrl(new URL(in.readString()));
String definition_string = in.readString();
if (!definition_string.isEmpty())
definition = new JSONObject((definition_string));
} catch (MalformedURLException | JSONException e) {
e.printStackTrace();
}
}
public boolean isConfigured() {
return !main_url.isDefault() && definition.length() > 0;
}
protected void setUrl(URL url) {
main_url.setUrl(url);
}
protected void define(JSONObject provider_json) {
definition = provider_json;
}
protected JSONObject definition() {
return definition;
}
protected String getDomain() {
return main_url.getDomain();
}
protected DefaultedURL mainUrl() {
return main_url;
}
protected String certificatePin() { return certificate_pin; }
public String getName() {
// Should we pass the locale in, or query the system here?
String lang = Locale.getDefault().getLanguage();
String name = "";
try {
if (definition != null)
name = definition.getJSONObject(API_TERM_NAME).getString(lang);
else throw new JSONException("Provider not defined");
} catch (JSONException e) {
if (main_url != null) {
String host = main_url.getDomain();
name = host.substring(0, host.indexOf("."));
}
}
return name;
}
protected String getDescription() {
String lang = Locale.getDefault().getLanguage();
String desc = null;
try {
desc = definition.getJSONObject("description").getString(lang);
} catch (JSONException e) {
// TODO: handle exception!!
try {
desc = definition.getJSONObject("description").getString(definition.getString("default_language"));
} catch (JSONException e2) {
// TODO: i can't believe you're doing it again!
}
}
return desc;
}
protected boolean hasEIP() {
try {
JSONArray services = definition.getJSONArray(API_TERM_SERVICES); // returns ["openvpn"]
for (int i = 0; i < API_EIP_TYPES.length + 1; i++) {
try {
// Walk the EIP types array looking for matches in provider's service definitions
if (Arrays.asList(API_EIP_TYPES).contains(services.getString(i)))
return true;
} catch (NullPointerException e) {
e.printStackTrace();
return false;
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
}
}
} catch (Exception e) {
// TODO: handle exception
}
return false;
}
public boolean allowsRegistration() {
try {
return definition.getJSONObject(Provider.SERVICE).getBoolean(Provider.ALLOW_REGISTRATION);
} catch (JSONException e) {
return false;
}
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int i) {
if(main_url != null)
parcel.writeString(main_url.toString());
if (definition != null)
parcel.writeString(definition.toString());
}
@Override
public boolean equals(Object o) {
if (o instanceof Provider) {
Provider p = (Provider) o;
return p.mainUrl().getDomain().equals(mainUrl().getDomain());
} else return false;
}
public JSONObject toJson() {
JSONObject json = new JSONObject();
try {
json.put(Provider.MAIN_URL, main_url);
} catch (JSONException e) {
e.printStackTrace();
}
return json;
}
@Override
public int hashCode() {
return mainUrl().getDomain().hashCode();
}
}
|
