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