src/libdeviced/mmc.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *       http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19
  20 #include <stdio.h>
  21 #include <vconf.h>
  22 #include <errno.h>
  23
  24 #include "log.h"
  25 #include "dbus.h"
  26 #include "common.h"
  27 #include "dd-mmc.h"
  28
  29 #define METHOD_REQUEST_SECURE_MOUNT             "RequestSecureMount"
  30 #define METHOD_REQUEST_SECURE_UNMOUNT   "RequestSecureUnmount"
  31 #define METHOD_REQUEST_MOUNT            "RequestMount"
  32 #define METHOD_REQUEST_UNMOUNT          "RequestUnmount"
  33 #define METHOD_REQUEST_FORMAT           "RequestFormat"
  34
  35 #define ODE_MOUNT_STATE 1
  36
  37 API int mmc_secure_mount(const char *mount_point)
  38 {
  39         char *arr[1];
  40         arr[0] = (char *)mount_point;
  41         return dbus_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_MMC,
  42                         DEVICED_INTERFACE_MMC, METHOD_REQUEST_SECURE_MOUNT, "s", arr);
  43 }
  44
  45 API int mmc_secure_unmount(const char *mount_point)
  46 {
  47         char *arr[1];
  48         arr[0] = (char *)mount_point;
  49         return dbus_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_MMC,
  50                         DEVICED_INTERFACE_MMC, METHOD_REQUEST_SECURE_UNMOUNT, "s", arr);
  51 }
  52
  53 static void mount_mmc_cb(void *data, DBusMessage *msg, DBusError *err)
  54 {
  55         struct mmc_contents *mmc_data = (struct mmc_contents*)data;
  56         DBusError r_err;
  57         int r, mmc_ret;
  58
  59         _D("mount_mmc_cb called");
  60
  61         if (!msg) {
  62                 _E("no message [%s:%s]", err->name, err->message);
  63                 mmc_ret = -EBADMSG;
  64                 goto exit;
  65         }
  66
  67         dbus_error_init(&r_err);
  68         r = dbus_message_get_args(msg, &r_err, DBUS_TYPE_INT32, &mmc_ret, DBUS_TYPE_INVALID);
  69         if (!r) {
  70                 _E("no message [%s:%s]", r_err.name, r_err.message);
  71                 dbus_error_free(&r_err);
  72                 mmc_ret = -EBADMSG;
  73                 goto exit;
  74         }
  75
  76         _I("Mount State : %d", mmc_ret);
  77
  78 //      if (mmc_ret == ODE_MOUNT_STATE)
  79 //              return;
  80
  81 exit:
  82         (mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
  83 }
  84
  85 API int deviced_request_mount_mmc(struct mmc_contents *mmc_data)
  86 {
  87         void (*mount_cb)(void*, DBusMessage*, DBusError*) = NULL;
  88         void *data = NULL;
  89
  90         if (mmc_data != NULL && mmc_data->mmc_cb != NULL) {
  91                 mount_cb = mount_mmc_cb;
  92                 data = mmc_data;
  93         }
  94
  95         return dbus_method_async_with_reply(DEVICED_BUS_NAME,
  96                         DEVICED_PATH_MMC,
  97                         DEVICED_INTERFACE_MMC,
  98                         METHOD_REQUEST_MOUNT,
  99                         NULL, NULL, mount_cb, -1, data);
 100 }
 101
 102 static void unmount_mmc_cb(void *data, DBusMessage *msg, DBusError *err)
 103 {
 104         struct mmc_contents *mmc_data = (struct mmc_contents*)data;
 105         DBusError r_err;
 106         int r, mmc_ret;
 107
 108         _D("unmount_mmc_cb called");
 109
 110         if (!msg) {
 111                 _E("no message [%s:%s]", err->name, err->message);
 112                 mmc_ret = -EBADMSG;
 113                 goto exit;
 114         }
 115
 116         dbus_error_init(&r_err);
 117         r = dbus_message_get_args(msg, &r_err, DBUS_TYPE_INT32, &mmc_ret, DBUS_TYPE_INVALID);
 118         if (!r) {
 119                 _E("no message [%s:%s]", r_err.name, r_err.message);
 120                 dbus_error_free(&r_err);
 121                 mmc_ret = -EBADMSG;
 122                 goto exit;
 123         }
 124
 125         _I("Unmount State : %d", mmc_ret);
 126
 127 exit:
 128         (mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
 129 }
 130
 131 API int deviced_request_unmount_mmc(struct mmc_contents *mmc_data, int option)
 132 {
 133         char *arr[1];
 134         char buf_opt[32];
 135         void (*unmount_cb)(void*, DBusMessage*, DBusError*) = NULL;
 136         void *data = NULL;
 137
 138         if (option < 0 || option > 1)
 139                 return -EINVAL;
 140
 141         if (mmc_data != NULL && mmc_data->mmc_cb != NULL) {
 142                 unmount_cb = unmount_mmc_cb;
 143                 data = mmc_data;
 144         }
 145
 146         snprintf(buf_opt, sizeof(buf_opt), "%d", option);
 147         arr[0] = buf_opt;
 148         return dbus_method_async_with_reply(DEVICED_BUS_NAME,
 149                         DEVICED_PATH_MMC,
 150                         DEVICED_INTERFACE_MMC,
 151                         METHOD_REQUEST_UNMOUNT,
 152                         "i", arr, unmount_cb, -1, data);
 153 }
 154
 155 static void format_mmc_cb(void *data, DBusMessage *msg, DBusError *err)
 156 {
 157         struct mmc_contents *mmc_data = (struct mmc_contents*)data;
 158         DBusError r_err;
 159         int r, mmc_ret;
 160
 161         _D("format_mmc_cb called");
 162
 163         if (!msg) {
 164                 _E("no message [%s:%s]", err->name, err->message);
 165                 mmc_ret = -EBADMSG;
 166                 goto exit;
 167         }
 168
 169         dbus_error_init(&r_err);
 170         r = dbus_message_get_args(msg, &r_err, DBUS_TYPE_INT32, &mmc_ret, DBUS_TYPE_INVALID);
 171         if (!r) {
 172                 _E("no message [%s:%s]", r_err.name, r_err.message);
 173                 dbus_error_free(&r_err);
 174                 mmc_ret = -EBADMSG;
 175                 goto exit;
 176         }
 177
 178         _I("Format State : %d", mmc_ret);
 179
 180 exit:
 181         (mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
 182 }
 183
 184 API int deviced_request_format_mmc(struct mmc_contents *mmc_data)
 185 {
 186         return deviced_format_mmc(mmc_data, 1);
 187 }
 188
 189 API int deviced_format_mmc(struct mmc_contents *mmc_data, int option)
 190 {
 191         char *arr[1];
 192         char buf_opt[32];
 193         void (*format_cb)(void*, DBusMessage*, DBusError*) = NULL;
 194         void *data = NULL;
 195
 196         if (option < 0 || option > 1)
 197                 return -EINVAL;
 198
 199         if (mmc_data != NULL && mmc_data->mmc_cb != NULL) {
 200                 format_cb = format_mmc_cb;
 201                 data = mmc_data;
 202         }
 203
 204         snprintf(buf_opt, sizeof(buf_opt), "%d", option);
 205         arr[0] = buf_opt;
 206         return dbus_method_async_with_reply(DEVICED_BUS_NAME,
 207                         DEVICED_PATH_MMC,
 208                         DEVICED_INTERFACE_MMC,
 209                         METHOD_REQUEST_FORMAT,
 210                         "i", arr, format_cb, -1, data);
 211 }