1 /*
2 * Copyright 2009, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <ctype.h>
18 #include <string.h>
19
20 namespace android {
21
22 /* Generated by the following Python script. Values of country calling codes
23 are from http://en.wikipedia.org/wiki/List_of_country_calling_codes
24
25 #!/usr/bin/python
26 import sys
27 ccc_set_2digits = set([0, 1, 7,
28 20, 27, 28, 30, 31, 32, 33, 34, 36, 39, 40, 43, 44, 45,
29 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 60, 61,
30 62, 63, 64, 65, 66, 81, 82, 83, 84, 86, 89, 90, 91, 92,
31 93, 94, 95, 98])
32
33 ONE_LINE_NUM = 10
34
35 for i in xrange(100):
36 if i % ONE_LINE_NUM == 0:
37 sys.stdout.write(' ')
38 if i in ccc_set_2digits:
39 included = 'true'
40 else:
41 included = 'false'
42 sys.stdout.write(included + ',')
43 if ((i + 1) % ONE_LINE_NUM) == 0:
44 sys.stdout.write('\n')
45 else:
46 sys.stdout.write(' ')
47 */
48 static bool two_length_country_code_map[100] = {
49 true, true, false, false, false, false, false, true, false, false,
50 false, false, false, false, false, false, false, false, false, false,
51 true, false, false, false, false, false, false, true, true, false,
52 true, true, true, true, true, false, true, false, false, true,
53 true, false, false, true, true, true, true, true, true, true,
54 false, true, true, true, true, true, true, true, true, false,
55 true, true, true, true, true, true, true, false, false, false,
56 false, false, false, false, false, false, false, false, false, false,
57 false, true, true, true, true, false, true, false, false, true,
58 true, true, true, true, true, true, false, false, true, false,
59 };
60
61 #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
62
63 /**
64 * Returns true if "ccc_candidate" expresses (part of ) some country calling
65 * code.
66 * Returns false otherwise.
67 */
isCountryCallingCode(int ccc_candidate)68 static bool isCountryCallingCode(int ccc_candidate) {
69 return ccc_candidate > 0 &&
70 ccc_candidate < (int)ARRAY_SIZE(two_length_country_code_map) &&
71 two_length_country_code_map[ccc_candidate];
72 }
73
74 /**
75 * Returns interger corresponding to the input if input "ch" is
76 * ISO-LATIN characters 0-9.
77 * Returns -1 otherwise
78 */
tryGetISODigit(char ch)79 static int tryGetISODigit (char ch)
80 {
81 if ('0' <= ch && ch <= '9') {
82 return ch - '0';
83 } else {
84 return -1;
85 }
86 }
87
88 /**
89 * True if ch is ISO-LATIN characters 0-9, *, # , +
90 * Note this method current does not account for the WILD char 'N'
91 */
isDialable(char ch)92 static bool isDialable(char ch)
93 {
94 return ('0' <= ch && ch <= '9') || ch == '*' || ch == '#' || ch == '+';
95 }
96
97 /** Returns true if ch is not dialable or alpha char */
isSeparator(char ch)98 static bool isSeparator(char ch)
99 {
100 return !isDialable(ch) && (isalpha(ch) == 0);
101 }
102
103 /**
104 * Try to store the pointer to "new_ptr" which does not have trunk prefix.
105 *
106 * Currently this function simply ignore the first digit assuming it is
107 * trunk prefix. Actually trunk prefix is different in each country.
108 *
109 * e.g.
110 * "+79161234567" equals "89161234567" (Russian trunk digit is 8)
111 * "+33123456789" equals "0123456789" (French trunk digit is 0)
112 *
113 */
tryGetTrunkPrefixOmittedStr(const char * str,size_t len,const char ** new_ptr,size_t * new_len)114 static bool tryGetTrunkPrefixOmittedStr(const char *str, size_t len,
115 const char **new_ptr, size_t *new_len)
116 {
117 for (size_t i = 0 ; i < len ; i++) {
118 char ch = str[i];
119 if (tryGetISODigit(ch) >= 0) {
120 if (new_ptr != NULL) {
121 *new_ptr = str + i + 1;
122 }
123 if (new_len != NULL) {
124 *new_len = len - (i + 1);
125 }
126 return true;
127 } else if (isDialable(ch)) {
128 return false;
129 }
130 }
131
132 return false;
133 }
134
135 /*
136 * Note that this function does not strictly care the country calling code with
137 * 3 length (like Morocco: +212), assuming it is enough to use the first two
138 * digit to compare two phone numbers.
139 */
tryGetCountryCallingCode(const char * str,size_t len,const char ** new_ptr,size_t * new_len,bool accept_thailand_case)140 static int tryGetCountryCallingCode(const char *str, size_t len,
141 const char **new_ptr, size_t *new_len,
142 bool accept_thailand_case)
143 {
144 // Rough regexp:
145 // ^[^0-9*#+]*((\+|0(0|11)\d\d?|166) [^0-9*#+] $
146 // 0 1 2 3 45 6 7 89
147 //
148 // In all the states, this function ignores separator characters.
149 // "166" is the special case for the call from Thailand to the US. Ugu!
150
151 int state = 0;
152 int ccc = 0;
153 for (size_t i = 0 ; i < len ; i++ ) {
154 char ch = str[i];
155 switch (state) {
156 case 0:
157 if (ch == '+') state = 1;
158 else if (ch == '0') state = 2;
159 else if (ch == '1') {
160 if (accept_thailand_case) {
161 state = 8;
162 } else {
163 return -1;
164 }
165 } else if (isDialable(ch)) return -1;
166 break;
167
168 case 2:
169 if (ch == '0') state = 3;
170 else if (ch == '1') state = 4;
171 else if (isDialable(ch)) return -1;
172 break;
173
174 case 4:
175 if (ch == '1') state = 5;
176 else if (isDialable(ch)) return -1;
177 break;
178
179 case 1:
180 case 3:
181 case 5:
182 case 6:
183 case 7:
184 {
185 int ret = tryGetISODigit(ch);
186 if (ret > 0) {
187 ccc = ccc * 10 + ret;
188 if (ccc >= 100 || isCountryCallingCode(ccc)) {
189 if (new_ptr != NULL) {
190 *new_ptr = str + i + 1;
191 }
192 if (new_len != NULL) {
193 *new_len = len - (i + 1);
194 }
195 return ccc;
196 }
197 if (state == 1 || state == 3 || state == 5) {
198 state = 6;
199 } else {
200 state++;
201 }
202 } else if (isDialable(ch)) {
203 return -1;
204 }
205 }
206 break;
207 case 8:
208 if (ch == '6') state = 9;
209 else if (isDialable(ch)) return -1;
210 break;
211 case 9:
212 if (ch == '6') {
213 if (new_ptr != NULL) {
214 *new_ptr = str + i + 1;
215 }
216 if (new_len != NULL) {
217 *new_len = len - (i + 1);
218 }
219 return 66;
220 } else {
221 return -1;
222 }
223 break;
224 default:
225 return -1;
226 }
227 }
228
229 return -1;
230 }
231
232 /**
233 * Return true if the prefix of "ch" is "ignorable". Here, "ignorable" means
234 * that "ch" has only one digit and separater characters. The one digit is
235 * assumed to be trunk prefix.
236 */
checkPrefixIsIgnorable(const char * ch,int i)237 static bool checkPrefixIsIgnorable(const char* ch, int i) {
238 bool trunk_prefix_was_read = false;
239 while (i >= 0) {
240 if (tryGetISODigit(ch[i]) >= 0) {
241 if (trunk_prefix_was_read) {
242 // More than one digit appeared, meaning that "a" and "b"
243 // is different.
244 return false;
245 } else {
246 // Ignore just one digit, assuming it is trunk prefix.
247 trunk_prefix_was_read = true;
248 }
249 } else if (isDialable(ch[i])) {
250 // Trunk prefix is a digit, not "*", "#"...
251 return false;
252 }
253 i--;
254 }
255
256 return true;
257 }
258
259 /**
260 * Compare phone numbers a and b, return true if they're identical
261 * enough for caller ID purposes.
262 *
263 * Assume NULL as 0-length string.
264 *
265 * Detailed information:
266 * Currently (as of 2009-06-12), we cannot depend on the locale given from the
267 * OS. For example, current Android does not accept "en_JP", meaning
268 * "the display language is English but the phone should be in Japan", but
269 * en_US, es_US, etc. So we cannot identify which digit is valid trunk prefix
270 * in the country where the phone is used. More specifically, "880-1234-1234"
271 * is not valid phone number in Japan since the trunk prefix in Japan is not 8
272 * but 0 (correct number should be "080-1234-1234"), while Russian trunk prefix
273 * is 8. Also, we cannot know whether the country where users live has trunk
274 * prefix itself. So, we cannot determine whether "+81-80-1234-1234" is NOT
275 * same as "880-1234-1234" (while "+81-80-1234-1234" is same as "080-1234-1234"
276 * and we can determine "880-1234-1234" is different from "080-1234-1234").
277 *
278 * In the future, we should handle trunk prefix more correctly, but as of now,
279 * we just ignore it...
280 */
phone_number_compare_inter(const char * const org_a,const char * const org_b,bool accept_thailand_case)281 static bool phone_number_compare_inter(const char* const org_a, const char* const org_b,
282 bool accept_thailand_case)
283 {
284 const char* a = org_a;
285 const char* b = org_b;
286 size_t len_a = 0;
287 size_t len_b = 0;
288 if (a == NULL) {
289 a = "";
290 } else {
291 len_a = strlen(a);
292 }
293 if (b == NULL) {
294 b = "";
295 } else {
296 len_b = strlen(b);
297 }
298
299 const char* tmp_a = NULL;
300 const char* tmp_b = NULL;
301 size_t tmp_len_a = len_a;
302 size_t tmp_len_b = len_b;
303
304 int ccc_a = tryGetCountryCallingCode(a, len_a, &tmp_a, &tmp_len_a, accept_thailand_case);
305 int ccc_b = tryGetCountryCallingCode(b, len_b, &tmp_b, &tmp_len_b, accept_thailand_case);
306 bool both_have_ccc = false;
307 bool ok_to_ignore_prefix = true;
308 bool trunk_prefix_is_omitted_a = false;
309 bool trunk_prefix_is_omitted_b = false;
310 if (ccc_a >= 0 && ccc_b >= 0) {
311 if (ccc_a != ccc_b) {
312 // Different Country Calling Code. Must be different phone number.
313 return false;
314 }
315 // When both have ccc, do not ignore trunk prefix. Without this,
316 // "+81123123" becomes same as "+810123123" (+81 == Japan)
317 ok_to_ignore_prefix = false;
318 both_have_ccc = true;
319 } else if (ccc_a < 0 && ccc_b < 0) {
320 // When both do not have ccc, do not ignore trunk prefix. Without this,
321 // "123123" becomes same as "0123123"
322 ok_to_ignore_prefix = false;
323 } else {
324 if (ccc_a < 0) {
325 tryGetTrunkPrefixOmittedStr(a, len_a, &tmp_a, &tmp_len_a);
326 trunk_prefix_is_omitted_a = true;
327 }
328 if (ccc_b < 0) {
329 tryGetTrunkPrefixOmittedStr(b, len_b, &tmp_b, &tmp_len_b);
330 trunk_prefix_is_omitted_b = true;
331 }
332 }
333
334 if (tmp_a != NULL) {
335 a = tmp_a;
336 len_a = tmp_len_a;
337 }
338 if (tmp_b != NULL) {
339 b = tmp_b;
340 len_b = tmp_len_b;
341 }
342
343 int i_a = len_a - 1;
344 int i_b = len_b - 1;
345 while (i_a >= 0 && i_b >= 0) {
346 bool skip_compare = false;
347 char ch_a = a[i_a];
348 char ch_b = b[i_b];
349 if (isSeparator(ch_a)) {
350 i_a--;
351 skip_compare = true;
352 }
353 if (isSeparator(ch_b)) {
354 i_b--;
355 skip_compare = true;
356 }
357
358 if (!skip_compare) {
359 if (ch_a != ch_b) {
360 return false;
361 }
362 i_a--;
363 i_b--;
364 }
365 }
366
367 if (ok_to_ignore_prefix) {
368 if ((trunk_prefix_is_omitted_a && i_a >= 0) ||
369 !checkPrefixIsIgnorable(a, i_a)) {
370 if (accept_thailand_case) {
371 // Maybe the code handling the special case for Thailand makes the
372 // result garbled, so disable the code and try again.
373 // e.g. "16610001234" must equal to "6610001234", but with
374 // Thailand-case handling code, they become equal to each other.
375 //
376 // Note: we select simplicity rather than adding some complicated
377 // logic here for performance(like "checking whether remaining
378 // numbers are just 66 or not"), assuming inputs are small
379 // enough.
380 return phone_number_compare_inter(org_a, org_b, false);
381 } else {
382 return false;
383 }
384 }
385 if ((trunk_prefix_is_omitted_b && i_b >= 0) ||
386 !checkPrefixIsIgnorable(b, i_b)) {
387 if (accept_thailand_case) {
388 return phone_number_compare_inter(org_a, org_b, false);
389 } else {
390 return false;
391 }
392 }
393 } else {
394 // In the US, 1-650-555-1234 must be equal to 650-555-1234,
395 // while 090-1234-1234 must not be equalt to 90-1234-1234 in Japan.
396 // This request exists just in US (with 1 trunk (NDD) prefix).
397 // In addition, "011 11 7005554141" must not equal to "+17005554141",
398 // while "011 1 7005554141" must equal to "+17005554141"
399 //
400 // In this comparison, we ignore the prefix '1' just once, when
401 // - at least either does not have CCC, or
402 // - the remaining non-separator number is 1
403 bool may_be_namp = !both_have_ccc;
404 while (i_a >= 0) {
405 const char ch_a = a[i_a];
406 if (isDialable(ch_a)) {
407 if (may_be_namp && tryGetISODigit(ch_a) == 1) {
408 may_be_namp = false;
409 } else {
410 return false;
411 }
412 }
413 i_a--;
414 }
415 while (i_b >= 0) {
416 const char ch_b = b[i_b];
417 if (isDialable(ch_b)) {
418 if (may_be_namp && tryGetISODigit(ch_b) == 1) {
419 may_be_namp = false;
420 } else {
421 return false;
422 }
423 }
424 i_b--;
425 }
426 }
427
428 return true;
429 }
430
phone_number_compare_strict(const char * a,const char * b)431 bool phone_number_compare_strict(const char* a, const char* b)
432 {
433 return phone_number_compare_inter(a, b, true);
434 }
435
436 /**
437 * Imitates the Java method PhoneNumberUtils.getStrippedReversed.
438 * Used for API compatibility with Android 1.6 and earlier.
439 */
phone_number_stripped_reversed_inter(const char * in,char * out,const int len,int * outlen)440 bool phone_number_stripped_reversed_inter(const char* in, char* out, const int len, int *outlen) {
441 int in_len = strlen(in);
442 int out_len = 0;
443 bool have_seen_plus = false;
444 for (int i = in_len; --i >= 0;) {
445 char c = in[i];
446 if ((c >= '0' && c <= '9') || c == '*' || c == '#' || c == 'N') {
447 if (out_len < len) {
448 out[out_len++] = c;
449 }
450 } else {
451 switch (c) {
452 case '+':
453 if (!have_seen_plus) {
454 if (out_len < len) {
455 out[out_len++] = c;
456 }
457 have_seen_plus = true;
458 }
459 break;
460 case ',':
461 case ';':
462 out_len = 0;
463 break;
464 }
465 }
466 }
467
468 *outlen = out_len;
469 return true;
470 }
471
472 } // namespace android
473