gboolean
mm_iface_modem_messaging_is_storage_supported_for_storing (MMIfaceModemMessaging *self,
MMSmsStorage storage,
GError **error)
{
/* mem2 is for storing */
return is_storage_supported ((get_storage_context (self))->supported_mem2,
storage,
"storing",
error);
}
static MMSmsStorage
get_best_initial_default_sms_storage (MMIfaceModemMessaging *self)
{
StorageContext *storage_ctx;
guint i;
MMSmsStorage default_storages_preference[] = {
MM_SMS_STORAGE_MT, /* MT=ME+SM */
MM_SMS_STORAGE_ME,
MM_SMS_STORAGE_SM,
MM_SMS_STORAGE_UNKNOWN
};
storage_ctx = get_storage_context (self);
for (i = 0; default_storages_preference[i] != MM_SMS_STORAGE_UNKNOWN; i++) {
/* Check if the requested storage is really supported in both mem2 and mem3 */
if (is_storage_supported (storage_ctx->supported_mem2, default_storages_preference[i], "storing", NULL) &&
is_storage_supported (storage_ctx->supported_mem3, default_storages_preference[i], "receiving", NULL)) {
break;
}
}
return default_storages_preference[i];
}
static void
load_initial_sms_parts_ready (MMIfaceModemMessaging *self,
GAsyncResult *res,
EnablingContext *ctx)
{
GError *error = NULL;
MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (self)->load_initial_sms_parts_finish (self, res, &error);
if (error) {
StorageContext *storage_ctx;
storage_ctx = get_storage_context (ctx->self);
mm_dbg ("Couldn't load SMS parts from storage '%s': '%s'",
mm_sms_storage_get_string (g_array_index (storage_ctx->supported_mem1,
MMSmsStorage,
ctx->mem1_storage_index)),
error->message);
g_error_free (error);
}
/* Go on with the storage iteration */
ctx->mem1_storage_index++;
load_initial_sms_parts_from_storages (ctx);
}
static int
reset_and_reopen(GFS_File gf, void *closure)
{
gfarm_error_t e = GFARM_ERR_NO_ERROR;
struct reset_and_reopen_info *ri = closure;
struct gfm_connection *gfm_server = ri->gfm_server;
struct gfm_connection *gfm_server1;
struct gfs_connection *sc;
struct gfarm_filesystem *fs =
gfarm_filesystem_get_by_connection(gfm_server);
int fc = gfarm_filesystem_failover_count(fs);
if ((e = gfm_client_connection_acquire(gfm_client_hostname(gfm_server),
gfm_client_port(gfm_server), gfm_client_username(gfm_server),
&gfm_server1)) != GFARM_ERR_NO_ERROR) {
gf->error = e;
gflog_debug(GFARM_MSG_1003383,
"gfm_client_connection_acquire: %s",
gfarm_error_string(e));
return (1);
}
if (gfm_server != gfm_server1) {
gfm_client_connection_free(gfm_server1);
gflog_debug(GFARM_MSG_1003384,
"reconnected to other gfmd or gfmd restarted");
ri->must_retry = 1;
return (0);
}
/* if old gfm_connection is alive, fd must be closed */
(void)gfm_close_fd(gf->gfm_server, gf->fd);
gf->fd = GFARM_DESCRIPTOR_INVALID;
gfm_client_connection_free(gf->gfm_server);
/* ref count of gfm_server is incremented above */
gf->gfm_server = gfm_server;
if ((sc = get_storage_context(gf->view_context)) != NULL) {
/*
* pid will be 0 if gfarm_client_process_reset() resulted
* in failure at reset_and_reopen() previously called with
* the same gfs_connection.
*/
if (gfs_client_pid(sc) == 0) {
gf->error = GFARM_ERR_CONNECTION_ABORTED;
gflog_debug(GFARM_MSG_1003385,
"%s", gfarm_error_string(gf->error));
return (1);
}
/* reset pid */
if (fc > gfs_client_connection_failover_count(sc)) {
gfs_client_connection_set_failover_count(sc, fc);
/*
* gfs_file just in scheduling is not related to
* gfs_server.
* In that case, gfarm_client_process_reset() is
* called in gfs_pio_open_section().
*
* all fd will be closed in gfsd by
* gfarm_client_process_reset().
*/
e = gfarm_client_process_reset(sc, gfm_server);
if (e != GFARM_ERR_NO_ERROR) {
gf->error = e;
gflog_debug(GFARM_MSG_1003386,
"gfarm_client_process_reset: %s",
gfarm_error_string(e));
return (1);
}
}
}
/* reopen file */
if (gfs_pio_error(gf) != GFARM_ERR_STALE_FILE_HANDLE &&
(e = gfs_pio_reopen(fs, gf)) != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1003387,
"gfs_pio_reopen: %s", gfarm_error_string(e));
}
return (1);
}
static void
load_supported_storages_ready (MMIfaceModemMessaging *self,
GAsyncResult *res,
InitializationContext *ctx)
{
StorageContext *storage_ctx;
GError *error = NULL;
storage_ctx = get_storage_context (self);
if (!MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (self)->load_supported_storages_finish (
self,
res,
&storage_ctx->supported_mem1,
&storage_ctx->supported_mem2,
&storage_ctx->supported_mem3,
&error)) {
mm_dbg ("Couldn't load supported storages: '%s'", error->message);
g_error_free (error);
} else {
gchar *mem1;
gchar *mem2;
gchar *mem3;
GArray *supported_storages;
guint i;
mem1 = mm_common_build_sms_storages_string ((MMSmsStorage *)storage_ctx->supported_mem1->data,
storage_ctx->supported_mem1->len);
mem2 = mm_common_build_sms_storages_string ((MMSmsStorage *)storage_ctx->supported_mem2->data,
storage_ctx->supported_mem2->len);
mem3 = mm_common_build_sms_storages_string ((MMSmsStorage *)storage_ctx->supported_mem3->data,
storage_ctx->supported_mem3->len);
mm_dbg ("Supported storages loaded:");
mm_dbg (" mem1 (list/read/delete) storages: '%s'", mem1);
mm_dbg (" mem2 (write/send) storages: '%s'", mem2);
mm_dbg (" mem3 (reception) storages: '%s'", mem3);
g_free (mem1);
g_free (mem2);
g_free (mem3);
/* We set in the interface the list of storages which are allowed for
* both write/send and receive */
supported_storages = g_array_sized_new (FALSE, FALSE, sizeof (guint32), storage_ctx->supported_mem2->len);
for (i = 0; i < storage_ctx->supported_mem2->len; i++) {
gboolean found = FALSE;
guint j;
for (j = 0; j < storage_ctx->supported_mem3->len && !found; j++) {
if (g_array_index (storage_ctx->supported_mem3, MMSmsStorage, j) ==
g_array_index (storage_ctx->supported_mem2, MMSmsStorage, i))
found = TRUE;
}
if (found) {
guint32 val;
val = g_array_index (storage_ctx->supported_mem2, MMSmsStorage, i);
g_array_append_val (supported_storages, val);
}
}
mm_gdbus_modem_messaging_set_supported_storages (
ctx->skeleton,
mm_common_sms_storages_garray_to_variant (supported_storages));
g_array_unref (supported_storages);
}
/* Go on to next step */
ctx->step++;
interface_initialization_step (ctx);
}