1 /*

     2  * Copyright (C) 2009 Martin Robinson

     3  *

     4  * This library is free software; you can redistribute it and/or

     5  * modify it under the terms of the GNU Library General Public

     6  * License as published by the Free Software Foundation; either

     7  * version 2 of the License, or (at your option) any later version.

     8  *

     9  * This library is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  * Library General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Library General Public License

    15  * along with this library; see the file COPYING.LIB.  If not, write to

    16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    17  * Boston, MA 02110-1301, USA.

    18  */

    19 

    20 #include "config.h"

    21 #include "webkitwebdatabase.h"

    22 

    23 #include "webkitprivate.h"

    24 

    25 #include "DatabaseDetails.h"

    26 #include "DatabaseTracker.h"

    27 #include <wtf/text/CString.h>

    28 

    29 #include <glib/gi18n-lib.h>

    30 

    31 /**

    32  * SECTION:webkitwebdatabase

    33  * @short_description: A WebKit web application database

    34  *

    35  * #WebKitWebDatabase is a representation of a Web Database database. The

    36  * proposed Web Database standard introduces support for SQL databases that web

    37  * sites can create and access on a local computer through JavaScript.

    38  *

    39  * To get access to all databases defined by a security origin, use

    40  * #webkit_security_origin_get_databases. Each database has a canonical

    41  * name, as well as a user-friendly display name.

    42  * 

    43  * WebKit uses SQLite to create and access the local SQL databases. The location

    44  * of a #WebKitWebDatabase can be accessed wth #webkit_web_database_get_filename.

    45  * You can configure the location of all databases with

    46  * #webkit_set_database_directory_path.

    47  * 

    48  * For each database the web site can define an estimated size which can be

    49  * accessed with #webkit_web_database_get_expected_size. The current size of the

    50  * database in bytes is returned by #webkit_web_database_get_size.

    51  * 

    52  * For more information refer to the Web Database specification proposal at

    53  * http://dev.w3.org/html5/webdatabase

    54  */

    55 

    56 using namespace WebKit;

    57 

    58 enum {

    59     PROP_0,

    60 

    61     PROP_SECURITY_ORIGIN,

    62     PROP_NAME,

    63     PROP_DISPLAY_NAME,

    64     PROP_EXPECTED_SIZE,

    65     PROP_SIZE,

    66     PROP_PATH

    67 };

    68 

    69 G_DEFINE_TYPE(WebKitWebDatabase, webkit_web_database, G_TYPE_OBJECT)

    70 

    71 struct _WebKitWebDatabasePrivate {

    72     WebKitSecurityOrigin* origin;

    73     gchar* name;

    74     gchar* displayName;

    75     gchar* filename;

    76 };

    77 

    78 static gchar* webkit_database_directory_path = NULL;

    79 static guint64 webkit_default_database_quota = 5 * 1024 * 1024;

    80 

    81 #define WEBKIT_WEB_DATABASE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_DATABASE, WebKitWebDatabasePrivate))

    82 

    83 static void webkit_web_database_set_security_origin(WebKitWebDatabase* webDatabase, WebKitSecurityOrigin* security_origin);

    84 

    85 static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name);

    86 

    87 static void webkit_web_database_finalize(GObject* object)

    88 {

    89     WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

    90     WebKitWebDatabasePrivate* priv = webDatabase->priv;

    91 

    92     g_free(priv->name);

    93     g_free(priv->displayName);

    94     g_free(priv->filename);

    95 

    96     G_OBJECT_CLASS(webkit_web_database_parent_class)->finalize(object);

    97 }

    98 

    99 static void webkit_web_database_dispose(GObject* object)

   100 {

   101     WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

   102     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   103 

   104     if (priv->origin) {

   105         g_object_unref(priv->origin);

   106         priv->origin = NULL;

   107     }

   108 

   109     G_OBJECT_CLASS(webkit_web_database_parent_class)->dispose(object);

   110 }

   111 

   112 static void webkit_web_database_set_property(GObject* object, guint propId, const GValue* value, GParamSpec* pspec)

   113 {

   114     WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

   115 

   116     switch (propId) {

   117     case PROP_SECURITY_ORIGIN:

   118         webkit_web_database_set_security_origin(webDatabase, WEBKIT_SECURITY_ORIGIN(g_value_get_object(value)));

   119         break;

   120     case PROP_NAME:

   121         webkit_web_database_set_name(webDatabase, g_value_get_string(value));

   122         break;

   123     default:

   124         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);

   125         break;

   126     }

   127 }

   128 

   129 static void webkit_web_database_get_property(GObject* object, guint propId, GValue* value, GParamSpec* pspec)

   130 {

   131     WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object);

   132     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   133 

   134     switch (propId) {

   135     case PROP_SECURITY_ORIGIN:

   136         g_value_set_object(value, priv->origin);

   137         break;

   138     case PROP_NAME:

   139         g_value_set_string(value, webkit_web_database_get_name(webDatabase));

   140         break;

   141     case PROP_DISPLAY_NAME:

   142         g_value_set_string(value, webkit_web_database_get_display_name(webDatabase));

   143         break;

   144     case PROP_EXPECTED_SIZE:

   145         g_value_set_uint64(value, webkit_web_database_get_expected_size(webDatabase));

   146         break;

   147     case PROP_SIZE:

   148         g_value_set_uint64(value, webkit_web_database_get_size(webDatabase));

   149         break;

   150     case PROP_PATH:

   151         g_value_set_string(value, webkit_web_database_get_filename(webDatabase));

   152         break;

   153     default:

   154         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);

   155         break;

   156     }

   157 }

   158 

   159 static void webkit_web_database_class_init(WebKitWebDatabaseClass* klass)

   160 {

   161     GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);

   162     gobjectClass->dispose = webkit_web_database_dispose;

   163     gobjectClass->finalize = webkit_web_database_finalize;

   164     gobjectClass->set_property = webkit_web_database_set_property;

   165     gobjectClass->get_property = webkit_web_database_get_property;

   166 

   167      /**

   168       * WebKitWebDatabase:security-origin:

   169       *

   170       * The security origin of the database.

   171       *

   172       * Since: 1.1.14

   173       */

   174      g_object_class_install_property(gobjectClass, PROP_SECURITY_ORIGIN,

   175                                      g_param_spec_object("security-origin",

   176                                                          _("Security Origin"),

   177                                                          _("The security origin of the database"),

   178                                                          WEBKIT_TYPE_SECURITY_ORIGIN,

   179                                                          (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

   180 

   181      /**

   182       * WebKitWebDatabase:name:

   183       *

   184       * The name of the Web Database database.

   185       *

   186       * Since: 1.1.14

   187       */

   188      g_object_class_install_property(gobjectClass, PROP_NAME,

   189                                      g_param_spec_string("name",

   190                                                          _("Name"),

   191                                                          _("The name of the Web Database database"),

   192                                                          NULL,

   193                                                          (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));

   194 

   195      /**

   196       * WebKitWebDatabase:display-name:

   197       *

   198       * The display name of the Web Database database.

   199       *

   200       * Since: 1.1.14

   201       */

   202      g_object_class_install_property(gobjectClass, PROP_DISPLAY_NAME,

   203                                      g_param_spec_string("display-name",

   204                                                          _("Display Name"),

   205                                                          _("The display name of the Web Storage database"),

   206                                                          NULL,

   207                                                          WEBKIT_PARAM_READABLE));

   208 

   209      /**

   210      * WebKitWebDatabase:expected-size:

   211      *

   212      * The expected size of the database in bytes as defined by the web author.

   213      *

   214      * Since: 1.1.14

   215      */

   216      g_object_class_install_property(gobjectClass, PROP_EXPECTED_SIZE,

   217                                      g_param_spec_uint64("expected-size",

   218                                                          _("Expected Size"),

   219                                                          _("The expected size of the Web Database database"),

   220                                                          0, G_MAXUINT64, 0,

   221                                                          WEBKIT_PARAM_READABLE));

   222      /**

   223      * WebKitWebDatabase:size:

   224      *

   225      * The current size of the database in bytes.

   226      *

   227      * Since: 1.1.14

   228      */

   229      g_object_class_install_property(gobjectClass, PROP_SIZE,

   230                                      g_param_spec_uint64("size",

   231                                                          _("Size"),

   232                                                          _("The current size of the Web Database database"),

   233                                                          0, G_MAXUINT64, 0,

   234                                                          WEBKIT_PARAM_READABLE));

   235      /**

   236       * WebKitWebDatabase:filename:

   237       *

   238       * The absolute filename of the Web Database database.

   239       *

   240       * Since: 1.1.14

   241       */

   242      g_object_class_install_property(gobjectClass, PROP_PATH,

   243                                      g_param_spec_string("filename",

   244                                                          _("Filename"),

   245                                                          _("The absolute filename of the Web Storage database"),

   246                                                          NULL,

   247                                                          WEBKIT_PARAM_READABLE));

   248 

   249     g_type_class_add_private(klass, sizeof(WebKitWebDatabasePrivate));

   250 }

   251 

   252 static void webkit_web_database_init(WebKitWebDatabase* webDatabase)

   253 {

   254     webDatabase->priv = WEBKIT_WEB_DATABASE_GET_PRIVATE(webDatabase);

   255 }

   256 

   257 // Internal use only

   258 static void webkit_web_database_set_security_origin(WebKitWebDatabase *webDatabase, WebKitSecurityOrigin *securityOrigin)

   259 {

   260     g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

   261     g_return_if_fail(WEBKIT_IS_SECURITY_ORIGIN(securityOrigin));

   262 

   263     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   264 

   265     if (priv->origin)

   266         g_object_unref(priv->origin);

   267 

   268     g_object_ref(securityOrigin);

   269     priv->origin = securityOrigin;

   270 }

   271 

   272 static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name)

   273 {

   274     g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

   275 

   276     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   277     g_free(priv->name);

   278     priv->name = g_strdup(name);

   279 }

   280 

   281 /**

   282  * webkit_web_database_get_security_origin:

   283  * @web_database: a #WebKitWebDatabase

   284  *

   285  * Returns the security origin of the #WebKitWebDatabase.

   286  *

   287  * Returns: the security origin of the database

   288  *

   289  * Since: 1.1.14

   290  **/

   291 WebKitSecurityOrigin* webkit_web_database_get_security_origin(WebKitWebDatabase* webDatabase)

   292 {

   293     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

   294     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   295 

   296     return priv->origin;

   297 }

   298 

   299 /**

   300  * webkit_web_database_get_name:

   301  * @web_database: a #WebKitWebDatabase

   302  *

   303  * Returns the canonical name of the #WebKitWebDatabase.

   304  *

   305  * Returns: the name of the database

   306  *

   307  * Since: 1.1.14

   308  **/

   309 G_CONST_RETURN gchar* webkit_web_database_get_name(WebKitWebDatabase* webDatabase)

   310 {

   311     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

   312     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   313 

   314     return priv->name;

   315 }

   316 

   317 /**

   318  * webkit_web_database_get_display_name:

   319  * @web_database: a #WebKitWebDatabase

   320  *

   321  * Returns the name of the #WebKitWebDatabase as seen by the user.

   322  *

   323  * Returns: the name of the database as seen by the user.

   324  *

   325  * Since: 1.1.14

   326  **/

   327 G_CONST_RETURN gchar* webkit_web_database_get_display_name(WebKitWebDatabase* webDatabase)

   328 {

   329     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

   330 

   331 #if ENABLE(DATABASE)

   332     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   333     WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

   334     WebCore::String displayName =  details.displayName();

   335 

   336     if (displayName.isEmpty())

   337         return "";

   338 

   339     g_free(priv->displayName);

   340     priv->displayName = g_strdup(displayName.utf8().data());

   341     return priv->displayName;

   342 #else

   343     return "";

   344 #endif

   345 }

   346 

   347 /**

   348  * webkit_web_database_get_expected_size:

   349  * @web_database: a #WebKitWebDatabase

   350  *

   351  * Returns the expected size of the #WebKitWebDatabase in bytes as defined by the

   352  * web author. The Web Database standard allows web authors to specify an expected

   353  * size of the database to optimize the user experience.

   354  *

   355  * Returns: the expected size of the database in bytes

   356  *

   357  * Since: 1.1.14

   358  **/

   359 guint64 webkit_web_database_get_expected_size(WebKitWebDatabase* webDatabase)

   360 {

   361     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0);

   362 

   363 #if ENABLE(DATABASE)

   364     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   365     WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

   366     return details.expectedUsage();

   367 #else

   368     return 0;

   369 #endif

   370 }

   371 

   372 /**

   373  * webkit_web_database_get_size:

   374  * @web_database: a #WebKitWebDatabase

   375  *

   376  * Returns the actual size of the #WebKitWebDatabase space on disk in bytes.

   377  *

   378  * Returns: the actual size of the database in bytes

   379  *

   380  * Since: 1.1.14

   381  **/

   382 guint64 webkit_web_database_get_size(WebKitWebDatabase* webDatabase)

   383 {

   384     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0);

   385 

   386 #if ENABLE(DATABASE)

   387     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   388     WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));

   389     return details.currentUsage();

   390 #else

   391     return 0;

   392 #endif

   393 }

   394 

   395 /**

   396  * webkit_web_database_get_filename:

   397  * @web_database: a #WebKitWebDatabase

   398  *

   399  * Returns the absolute filename to the #WebKitWebDatabase file on disk.

   400  *

   401  * Returns: the absolute filename of the database

   402  *

   403  * Since: 1.1.14

   404  **/

   405 G_CONST_RETURN gchar* webkit_web_database_get_filename(WebKitWebDatabase* webDatabase)

   406 {

   407     g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);

   408 

   409 #if ENABLE(DATABASE)

   410     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   411     WebCore::String coreName = WebCore::String::fromUTF8(priv->name);

   412     WebCore::String corePath = WebCore::DatabaseTracker::tracker().fullPathForDatabase(core(priv->origin), coreName);

   413 

   414     if (corePath.isEmpty())

   415         return"";

   416 

   417     g_free(priv->filename);

   418     priv->filename = g_strdup(corePath.utf8().data());

   419     return priv->filename;

   420 

   421 #else

   422     return "";

   423 #endif

   424 }

   425 

   426 /**

   427  * webkit_web_database_remove:

   428  * @web_database: a #WebKitWebDatabase

   429  *

   430  * Removes the #WebKitWebDatabase from its security origin and destroys all data

   431  * stored in the database.

   432  *

   433  * Since: 1.1.14

   434  **/

   435 void webkit_web_database_remove(WebKitWebDatabase* webDatabase)

   436 {

   437     g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase));

   438 

   439 #if ENABLE(DATABASE)

   440     WebKitWebDatabasePrivate* priv = webDatabase->priv;

   441     WebCore::DatabaseTracker::tracker().deleteDatabase(core(priv->origin), priv->name);

   442 #endif

   443 }

   444 

   445 /**

   446  * webkit_remove_all_web_databases:

   447  *

   448  * Removes all web databases from the current database directory path.

   449  *

   450  * Since: 1.1.14

   451  **/

   452 void webkit_remove_all_web_databases()

   453 {

   454 #if ENABLE(DATABASE)

   455     WebCore::DatabaseTracker::tracker().deleteAllDatabases();

   456 #endif

   457 }

   458 

   459 /**

   460  * webkit_get_web_database_directory_path:

   461  *

   462  * Returns the current path to the directory WebKit will write Web 

   463  * Database databases. By default this path will be in the user data

   464  * directory.

   465  *

   466  * Returns: the current database directory path

   467  *

   468  * Since: 1.1.14

   469  **/

   470 G_CONST_RETURN gchar* webkit_get_web_database_directory_path()

   471 {

   472 #if ENABLE(DATABASE)

   473     WebCore::String path = WebCore::DatabaseTracker::tracker().databaseDirectoryPath();

   474 

   475     if (path.isEmpty())

   476         return "";

   477 

   478     g_free(webkit_database_directory_path);

   479     webkit_database_directory_path = g_strdup(path.utf8().data());

   480     return webkit_database_directory_path;

   481 #else

   482     return "";

   483 #endif

   484 }

   485 

   486 /**

   487  * webkit_set_web_database_directory_path:

   488  * @path: the new database directory path

   489  *

   490  * Sets the current path to the directory WebKit will write Web 

   491  * Database databases. 

   492  *

   493  * Since: 1.1.14

   494  **/

   495 void webkit_set_web_database_directory_path(const gchar* path)

   496 {

   497 #if ENABLE(DATABASE)

   498     WebCore::String corePath = WebCore::String::fromUTF8(path);

   499     WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(corePath);

   500 

   501     g_free(webkit_database_directory_path);

   502     webkit_database_directory_path = g_strdup(corePath.utf8().data());

   503 #endif

   504 }

   505 

   506 /**

   507  * webkit_get_default_web_database_quota:

   508  *

   509  * Returns the default quota for Web Database databases. By default

   510  * this value is 5MB.

   511  

   512  * Returns: the current default database quota in bytes

   513  *

   514  * Since: 1.1.14

   515  **/

   516 guint64 webkit_get_default_web_database_quota()

   517 {

   518     return webkit_default_database_quota;

   519 }

   520 

   521 /**

   522  * webkit_set_default_web_database_quota:

   523  * @default_quota: the new default database quota

   524  *

   525  * Sets the current path to the directory WebKit will write Web 

   526  * Database databases. 

   527  *

   528  * Since: 1.1.14

   529  **/

   530 void webkit_set_default_web_database_quota(guint64 defaultQuota)

   531 {

   532     webkit_default_database_quota = defaultQuota;

   533 }