• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2007 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 #define LOG_TAG "sqlite3_android"
18 
19 #include <ctype.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <unistd.h>
23 
24 #include <unicode/ucol.h>
25 #include <unicode/uiter.h>
26 #include <unicode/ustring.h>
27 #include <unicode/utypes.h>
28 #include <cutils/log.h>
29 
30 #include "sqlite3_android.h"
31 #include "PhoneNumberUtils.h"
32 #include "PhonebookIndex.h"
33 
34 #define ENABLE_ANDROID_LOG 0
35 #define SMALL_BUFFER_SIZE 10
36 #define PHONE_NUMBER_BUFFER_SIZE 40
37 
collate16(void * p,int n1,const void * v1,int n2,const void * v2)38 static int collate16(void *p, int n1, const void *v1, int n2, const void *v2)
39 {
40     UCollator *coll = (UCollator *) p;
41     UCollationResult result = ucol_strcoll(coll, (const UChar *) v1, n1,
42                                                  (const UChar *) v2, n2);
43 
44     if (result == UCOL_LESS) {
45         return -1;
46     } else if (result == UCOL_GREATER) {
47         return 1;
48     } else {
49         return 0;
50     }
51 }
52 
collate8(void * p,int n1,const void * v1,int n2,const void * v2)53 static int collate8(void *p, int n1, const void *v1, int n2, const void *v2)
54 {
55     UCollator *coll = (UCollator *) p;
56     UCharIterator i1, i2;
57     UErrorCode status = U_ZERO_ERROR;
58 
59     uiter_setUTF8(&i1, (const char *) v1, n1);
60     uiter_setUTF8(&i2, (const char *) v2, n2);
61 
62     UCollationResult result = ucol_strcollIter(coll, &i1, &i2, &status);
63 
64     if (U_FAILURE(status)) {
65 //        LOGE("Collation iterator error: %d\n", status);
66     }
67 
68     if (result == UCOL_LESS) {
69         return -1;
70     } else if (result == UCOL_GREATER) {
71         return 1;
72     } else {
73         return 0;
74     }
75 }
76 
77 /**
78  * Obtains the first UNICODE letter from the supplied string, normalizes and returns it.
79  */
get_phonebook_index(sqlite3_context * context,int argc,sqlite3_value ** argv)80 static void get_phonebook_index(
81     sqlite3_context * context, int argc, sqlite3_value ** argv)
82 {
83     if (argc != 2) {
84       sqlite3_result_null(context);
85       return;
86     }
87 
88     char const * src = (char const *)sqlite3_value_text(argv[0]);
89     char const * locale = (char const *)sqlite3_value_text(argv[1]);
90     if (src == NULL || src[0] == 0 || locale == NULL) {
91       sqlite3_result_null(context);
92       return;
93     }
94 
95     UCharIterator iter;
96     uiter_setUTF8(&iter, src, -1);
97 
98     UBool isError = FALSE;
99     UChar index[SMALL_BUFFER_SIZE];
100     uint32_t len = android::GetPhonebookIndex(&iter, locale, index, sizeof(index), &isError);
101     if (isError) {
102       sqlite3_result_null(context);
103       return;
104     }
105 
106     uint32_t outlen = 0;
107     uint8_t out[SMALL_BUFFER_SIZE];
108     for (uint32_t i = 0; i < len; i++) {
109       U8_APPEND(out, outlen, sizeof(out), index[i], isError);
110       if (isError) {
111         sqlite3_result_null(context);
112         return;
113       }
114     }
115 
116     if (outlen == 0) {
117       sqlite3_result_null(context);
118       return;
119     }
120 
121     sqlite3_result_text(context, (const char*)out, outlen, SQLITE_TRANSIENT);
122 }
123 
phone_numbers_equal(sqlite3_context * context,int argc,sqlite3_value ** argv)124 static void phone_numbers_equal(sqlite3_context * context, int argc, sqlite3_value ** argv)
125 {
126     if (argc != 2 && argc != 3) {
127         sqlite3_result_int(context, 0);
128         return;
129     }
130 
131     char const * num1 = (char const *)sqlite3_value_text(argv[0]);
132     char const * num2 = (char const *)sqlite3_value_text(argv[1]);
133 
134     bool use_strict = false;
135     if (argc == 3) {
136         use_strict = (sqlite3_value_int(argv[2]) != 0);
137     }
138 
139     if (num1 == NULL || num2 == NULL) {
140         sqlite3_result_null(context);
141         return;
142     }
143 
144     bool equal =
145         (use_strict ?
146          android::phone_number_compare_strict(num1, num2) :
147          android::phone_number_compare_loose(num1, num2));
148 
149     if (equal) {
150         sqlite3_result_int(context, 1);
151     } else {
152         sqlite3_result_int(context, 0);
153     }
154 }
155 
phone_number_stripped_reversed(sqlite3_context * context,int argc,sqlite3_value ** argv)156 static void phone_number_stripped_reversed(sqlite3_context * context, int argc,
157       sqlite3_value ** argv)
158 {
159     if (argc != 1) {
160         sqlite3_result_int(context, 0);
161         return;
162     }
163 
164     char const * number = (char const *)sqlite3_value_text(argv[0]);
165     if (number == NULL) {
166         sqlite3_result_null(context);
167         return;
168     }
169 
170     char out[PHONE_NUMBER_BUFFER_SIZE];
171     int outlen = 0;
172     android::phone_number_stripped_reversed_inter(number, out, PHONE_NUMBER_BUFFER_SIZE, &outlen);
173     sqlite3_result_text(context, (const char*)out, outlen, SQLITE_TRANSIENT);
174 }
175 
176 
177 #if ENABLE_ANDROID_LOG
android_log(sqlite3_context * context,int argc,sqlite3_value ** argv)178 static void android_log(sqlite3_context * context, int argc, sqlite3_value ** argv)
179 {
180     char const * tag = "sqlite_trigger";
181     char const * msg = "";
182     int msgIndex = 0;
183 
184     switch (argc) {
185         case 2:
186             tag = (char const *)sqlite3_value_text(argv[0]);
187             if (tag == NULL) {
188                 tag = "sqlite_trigger";
189             }
190             msgIndex = 1;
191         case 1:
192             msg = (char const *)sqlite3_value_text(argv[msgIndex]);
193             if (msg == NULL) {
194                 msg = "";
195             }
196             LOG(LOG_INFO, tag, msg);
197             sqlite3_result_int(context, 1);
198             return;
199 
200         default:
201             sqlite3_result_int(context, 0);
202             return;
203     }
204 }
205 #endif
206 
delete_file(sqlite3_context * context,int argc,sqlite3_value ** argv)207 static void delete_file(sqlite3_context * context, int argc, sqlite3_value ** argv)
208 {
209     if (argc != 1) {
210         sqlite3_result_int(context, 0);
211         return;
212     }
213 
214     char const * path = (char const *)sqlite3_value_text(argv[0]);
215     // Don't allow ".." in paths
216     if (path == NULL || strstr(path, "/../") != NULL) {
217         sqlite3_result_null(context);
218         return;
219     }
220 
221     // We only allow deleting files in the EXTERNAL_STORAGE path, or one of the
222     // SECONDARY_STORAGE paths
223     bool good_path = false;
224     char const * external_storage = getenv("EXTERNAL_STORAGE");
225     if (external_storage && strncmp(external_storage, path, strlen(external_storage)) == 0) {
226         good_path = true;
227     } else {
228         // check SECONDARY_STORAGE, which should be a colon separated list of paths
229         char const * secondary_paths = getenv("SECONDARY_STORAGE");
230         while (secondary_paths && secondary_paths[0]) {
231             const char* colon = strchr(secondary_paths, ':');
232             int length = (colon ? colon - secondary_paths : strlen(secondary_paths));
233             if (strncmp(secondary_paths, path, length) == 0) {
234                 good_path = true;
235             }
236             secondary_paths += length;
237             while (*secondary_paths == ':') secondary_paths++;
238         }
239     }
240 
241     if (!good_path) {
242         sqlite3_result_null(context);
243         return;
244     }
245 
246     int err = unlink(path);
247     if (err != -1) {
248         // No error occured, return true
249         sqlite3_result_int(context, 1);
250     } else {
251         // An error occured, return false
252         sqlite3_result_int(context, 0);
253     }
254 }
255 
tokenize_auxdata_delete(void * data)256 static void tokenize_auxdata_delete(void * data)
257 {
258     sqlite3_stmt * statement = (sqlite3_stmt *)data;
259     sqlite3_finalize(statement);
260 }
261 
base16Encode(char * dest,const char * src,uint32_t size)262 static void base16Encode(char* dest, const char* src, uint32_t size)
263 {
264     static const char * BASE16_TABLE = "0123456789abcdef";
265     for (uint32_t i = 0; i < size; i++) {
266         char ch = *src++;
267         *dest++ = BASE16_TABLE[ (ch & 0xf0) >> 4 ];
268         *dest++ = BASE16_TABLE[ (ch & 0x0f)      ];
269     }
270 }
271 
272 struct SqliteUserData {
273     sqlite3 * handle;
274     UCollator* collator;
275 };
276 
277 /**
278  * This function is invoked as:
279  *
280  *  _TOKENIZE('<token_table>', <data_row_id>, <data>, <delimiter>,
281  *             <use_token_index>, <data_tag>)
282  *
283  * If <use_token_index> is omitted, it is treated as 0.
284  * If <data_tag> is omitted, it is treated as NULL.
285  *
286  * It will split <data> on each instance of <delimiter> and insert each token
287  * into <token_table>. The following columns in <token_table> are used:
288  * token TEXT, source INTEGER, token_index INTEGER, tag (any type)
289  * The token_index column is not required if <use_token_index> is 0.
290  * The tag column is not required if <data_tag> is NULL.
291  *
292  * One row is inserted for each token in <data>.
293  * In each inserted row, 'source' is <data_row_id>.
294  * In the first inserted row, 'token' is the hex collation key of
295  * the entire <data> string, and 'token_index' is 0.
296  * In each row I (where 1 <= I < N, and N is the number of tokens in <data>)
297  * 'token' will be set to the hex collation key of the I:th token (0-based).
298  * If <use_token_index> != 0, 'token_index' is set to I.
299  * If <data_tag> is not NULL, 'tag' is set to <data_tag>.
300  *
301  * In other words, there will be one row for the entire string,
302  * and one row for each token except the first one.
303  *
304  * The function returns the number of tokens generated.
305  */
tokenize(sqlite3_context * context,int argc,sqlite3_value ** argv)306 static void tokenize(sqlite3_context * context, int argc, sqlite3_value ** argv)
307 {
308     //LOGD("enter tokenize");
309     int err;
310     int useTokenIndex = 0;
311     int useDataTag = 0;
312 
313     if (!(argc >= 4 || argc <= 6)) {
314         LOGE("Tokenize requires 4 to 6 arguments");
315         sqlite3_result_null(context);
316         return;
317     }
318 
319     if (argc > 4) {
320         useTokenIndex = sqlite3_value_int(argv[4]);
321     }
322 
323     if (argc > 5) {
324         useDataTag = (sqlite3_value_type(argv[5]) != SQLITE_NULL);
325     }
326 
327     sqlite3 * handle = sqlite3_context_db_handle(context);
328     UCollator* collator = (UCollator*)sqlite3_user_data(context);
329     char const * tokenTable = (char const *)sqlite3_value_text(argv[0]);
330     if (tokenTable == NULL) {
331         LOGE("tokenTable null");
332         sqlite3_result_null(context);
333         return;
334     }
335 
336     // Get or create the prepared statement for the insertions
337     sqlite3_stmt * statement = (sqlite3_stmt *)sqlite3_get_auxdata(context, 0);
338     if (!statement) {
339         char const * tokenIndexCol = useTokenIndex ? ", token_index" : "";
340         char const * tokenIndexParam = useTokenIndex ? ", ?" : "";
341         char const * dataTagCol = useDataTag ? ", tag" : "";
342         char const * dataTagParam = useDataTag ? ", ?" : "";
343         char * sql = sqlite3_mprintf("INSERT INTO %s (token, source%s%s) VALUES (?, ?%s%s);",
344                 tokenTable, tokenIndexCol, dataTagCol, tokenIndexParam, dataTagParam);
345         err = sqlite3_prepare_v2(handle, sql, -1, &statement, NULL);
346         sqlite3_free(sql);
347         if (err) {
348             LOGE("prepare failed");
349             sqlite3_result_null(context);
350             return;
351         }
352         // This binds the statement to the table it was compiled against, which is argv[0].
353         // If this function is ever called with a different table the finalizer will be called
354         // and sqlite3_get_auxdata() will return null above, forcing a recompile for the new table.
355         sqlite3_set_auxdata(context, 0, statement, tokenize_auxdata_delete);
356     } else {
357         // Reset the cached statement so that binding the row ID will work properly
358         sqlite3_reset(statement);
359     }
360 
361     // Bind the row ID of the source row
362     int64_t rowID = sqlite3_value_int64(argv[1]);
363     err = sqlite3_bind_int64(statement, 2, rowID);
364     if (err != SQLITE_OK) {
365         LOGE("bind failed");
366         sqlite3_result_null(context);
367         return;
368     }
369 
370     // Bind <data_tag> to the tag column
371     if (useDataTag) {
372         int dataTagParamIndex = useTokenIndex ? 4 : 3;
373         err = sqlite3_bind_value(statement, dataTagParamIndex, argv[5]);
374         if (err != SQLITE_OK) {
375             LOGE("bind failed");
376             sqlite3_result_null(context);
377             return;
378         }
379     }
380 
381     // Get the raw bytes for the string to tokenize
382     // the string will be modified by following code
383     // however, sqlite did not reuse the string, so it is safe to not dup it
384     UChar * origData = (UChar *)sqlite3_value_text16(argv[2]);
385     if (origData == NULL) {
386         sqlite3_result_null(context);
387         return;
388     }
389 
390     // Get the raw bytes for the delimiter
391     const UChar * delim = (const UChar *)sqlite3_value_text16(argv[3]);
392     if (delim == NULL) {
393         LOGE("can't get delimiter");
394         sqlite3_result_null(context);
395         return;
396     }
397 
398     UChar * token = NULL;
399     UChar *state;
400     int numTokens = 0;
401 
402     do {
403         if (numTokens == 0) {
404             token = origData;
405         }
406 
407         // Reset the program so we can use it to perform the insert
408         sqlite3_reset(statement);
409         UErrorCode status = U_ZERO_ERROR;
410         char keybuf[1024];
411         uint32_t result = ucol_getSortKey(collator, token, -1, (uint8_t*)keybuf, sizeof(keybuf)-1);
412         if (result > sizeof(keybuf)) {
413             // TODO allocate memory for this super big string
414             LOGE("ucol_getSortKey needs bigger buffer %d", result);
415             break;
416         }
417         uint32_t keysize = result-1;
418         uint32_t base16Size = keysize*2;
419         char *base16buf = (char*)malloc(base16Size);
420         base16Encode(base16buf, keybuf, keysize);
421         err = sqlite3_bind_text(statement, 1, base16buf, base16Size, SQLITE_STATIC);
422 
423         if (err != SQLITE_OK) {
424             LOGE(" sqlite3_bind_text16 error %d", err);
425             free(base16buf);
426             break;
427         }
428 
429         if (useTokenIndex) {
430             err = sqlite3_bind_int(statement, 3, numTokens);
431             if (err != SQLITE_OK) {
432                 LOGE(" sqlite3_bind_int error %d", err);
433                 free(base16buf);
434                 break;
435             }
436         }
437 
438         err = sqlite3_step(statement);
439         free(base16buf);
440 
441         if (err != SQLITE_DONE) {
442             LOGE(" sqlite3_step error %d", err);
443             break;
444         }
445         numTokens++;
446         if (numTokens == 1) {
447             // first call
448             u_strtok_r(origData, delim, &state);
449         }
450     } while ((token = u_strtok_r(NULL, delim, &state)) != NULL);
451     sqlite3_result_int(context, numTokens);
452 }
453 
localized_collator_dtor(UCollator * collator)454 static void localized_collator_dtor(UCollator* collator)
455 {
456     ucol_close(collator);
457 }
458 
459 #define LOCALIZED_COLLATOR_NAME "LOCALIZED"
460 
461 // This collator may be removed in the near future, so you MUST not use now.
462 #define PHONEBOOK_COLLATOR_NAME "PHONEBOOK"
463 
register_localized_collators(sqlite3 * handle,const char * systemLocale,int utf16Storage)464 extern "C" int register_localized_collators(sqlite3* handle, const char* systemLocale, int utf16Storage)
465 {
466     int err;
467     UErrorCode status = U_ZERO_ERROR;
468     void* icudata;
469 
470     UCollator* collator = ucol_open(systemLocale, &status);
471     if (U_FAILURE(status)) {
472         return -1;
473     }
474 
475     ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_PRIMARY, &status);
476     if (U_FAILURE(status)) {
477         return -1;
478     }
479 
480     status = U_ZERO_ERROR;
481     char buf[1024];
482     ucol_getShortDefinitionString(collator, NULL, buf, 1024, &status);
483 
484     if (utf16Storage) {
485         err = sqlite3_create_collation_v2(handle, LOCALIZED_COLLATOR_NAME, SQLITE_UTF16, collator,
486                 collate16, (void(*)(void*))localized_collator_dtor);
487     } else {
488         err = sqlite3_create_collation_v2(handle, LOCALIZED_COLLATOR_NAME, SQLITE_UTF8, collator,
489                 collate8, (void(*)(void*))localized_collator_dtor);
490     }
491 
492     if (err != SQLITE_OK) {
493         return err;
494     }
495 
496     // Register the _TOKENIZE function
497     err = sqlite3_create_function(handle, "_TOKENIZE", 4, SQLITE_UTF16, collator, tokenize, NULL, NULL);
498     if (err != SQLITE_OK) {
499         return err;
500     }
501     err = sqlite3_create_function(handle, "_TOKENIZE", 5, SQLITE_UTF16, collator, tokenize, NULL, NULL);
502     if (err != SQLITE_OK) {
503         return err;
504     }
505     err = sqlite3_create_function(handle, "_TOKENIZE", 6, SQLITE_UTF16, collator, tokenize, NULL, NULL);
506     if (err != SQLITE_OK) {
507         return err;
508     }
509 
510 
511     //// PHONEBOOK_COLLATOR
512     // The collator may be removed in the near future. Do not depend on it.
513     // TODO: it might be better to have another function for registering phonebook collator.
514     status = U_ZERO_ERROR;
515     if (strcmp(systemLocale, "ja") == 0 || strcmp(systemLocale, "ja_JP") == 0) {
516         collator = ucol_open("ja@collation=phonebook", &status);
517     } else {
518         collator = ucol_open(systemLocale, &status);
519     }
520     if (U_FAILURE(status)) {
521         return -1;
522     }
523 
524     status = U_ZERO_ERROR;
525     ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_PRIMARY, &status);
526     if (U_FAILURE(status)) {
527         return -1;
528     }
529 
530     status = U_ZERO_ERROR;
531     // ucol_getShortDefinitionString(collator, NULL, buf, 1024, &status);
532     if (utf16Storage) {
533         err = sqlite3_create_collation_v2(handle, PHONEBOOK_COLLATOR_NAME, SQLITE_UTF16, collator,
534                 collate16, (void(*)(void*))localized_collator_dtor);
535     } else {
536         err = sqlite3_create_collation_v2(handle, PHONEBOOK_COLLATOR_NAME, SQLITE_UTF8, collator,
537                 collate8, (void(*)(void*))localized_collator_dtor);
538     }
539 
540     if (err != SQLITE_OK) {
541         return err;
542     }
543     //// PHONEBOOK_COLLATOR
544 
545     return SQLITE_OK;
546 }
547 
548 
register_android_functions(sqlite3 * handle,int utf16Storage)549 extern "C" int register_android_functions(sqlite3 * handle, int utf16Storage)
550 {
551     int err;
552     UErrorCode status = U_ZERO_ERROR;
553 
554     UCollator * collator = ucol_open(NULL, &status);
555     if (U_FAILURE(status)) {
556         return -1;
557     }
558 
559     if (utf16Storage) {
560         // Note that text should be stored as UTF-16
561         err = sqlite3_exec(handle, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);
562         if (err != SQLITE_OK) {
563             return err;
564         }
565 
566         // Register the UNICODE collation
567         err = sqlite3_create_collation_v2(handle, "UNICODE", SQLITE_UTF16, collator, collate16,
568                 (void(*)(void*))localized_collator_dtor);
569     } else {
570         err = sqlite3_create_collation_v2(handle, "UNICODE", SQLITE_UTF8, collator, collate8,
571                 (void(*)(void*))localized_collator_dtor);
572     }
573 
574     if (err != SQLITE_OK) {
575         return err;
576     }
577 
578     // Register the PHONE_NUM_EQUALS function
579     err = sqlite3_create_function(
580         handle, "PHONE_NUMBERS_EQUAL", 2,
581         SQLITE_UTF8, NULL, phone_numbers_equal, NULL, NULL);
582     if (err != SQLITE_OK) {
583         return err;
584     }
585 
586     // Register the PHONE_NUM_EQUALS function with an additional argument "use_strict"
587     err = sqlite3_create_function(
588         handle, "PHONE_NUMBERS_EQUAL", 3,
589         SQLITE_UTF8, NULL, phone_numbers_equal, NULL, NULL);
590     if (err != SQLITE_OK) {
591         return err;
592     }
593 
594     // Register the _DELETE_FILE function
595     err = sqlite3_create_function(handle, "_DELETE_FILE", 1, SQLITE_UTF8, NULL, delete_file, NULL, NULL);
596     if (err != SQLITE_OK) {
597         return err;
598     }
599 
600 #if ENABLE_ANDROID_LOG
601     // Register the _LOG function
602     err = sqlite3_create_function(handle, "_LOG", 1, SQLITE_UTF8, NULL, android_log, NULL, NULL);
603     if (err != SQLITE_OK) {
604         return err;
605     }
606 #endif
607 
608     // Register the GET_PHONEBOOK_INDEX function
609     err = sqlite3_create_function(handle,
610         "GET_PHONEBOOK_INDEX",
611         2, SQLITE_UTF8, NULL,
612         get_phonebook_index,
613         NULL, NULL);
614     if (err != SQLITE_OK) {
615         return err;
616     }
617 
618     // Register the _PHONE_NUMBER_STRIPPED_REVERSED function, which imitates
619     // PhoneNumberUtils.getStrippedReversed.  This function is not public API,
620     // it is only used for compatibility with Android 1.6 and earlier.
621     err = sqlite3_create_function(handle,
622         "_PHONE_NUMBER_STRIPPED_REVERSED",
623         1, SQLITE_UTF8, NULL,
624         phone_number_stripped_reversed,
625         NULL, NULL);
626     if (err != SQLITE_OK) {
627         return err;
628     }
629 
630     return SQLITE_OK;
631 }
632