src/mdg_util.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   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 #include <glib.h>
  18 #include <mdg.h>
  19 #include <mdg_debug.h>
  20 #include <mdg_private.h>
  21 #include <stdlib.h>
  22
  23 mdg_group_s *mdg_get_group_from_variant(GVariant *va)
  24 {
  25         char *device_id = NULL;
  26         char *group_name = NULL;
  27         mdg_group_type_e type = MDG_GROUP_TYPE_LOCAL;
  28         GVariantIter *iter = NULL;
  29         const gchar *key;
  30         GVariant *key_value = NULL;
  31
  32         mdg_group_s *group = calloc(1, sizeof(mdg_group_s));
  33         if (NULL == group) {
  34                 /* LCOV_EXCL_START */
  35                 _ERR("Memory allocation failed");
  36                 return NULL;
  37                 /* LCOV_EXCL_STOP */
  38         }
  39
  40         g_variant_get(va, "a{sv}", &iter);
  41         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  42                 if (g_strcmp0(key, "DeviceID") == 0)
  43                         device_id = (char *)g_variant_get_string(key_value, NULL);
  44                 else if (g_strcmp0(key, "GroupName") == 0)
  45                         group_name = (char *)g_variant_get_string(key_value, NULL);
  46                 else if (g_strcmp0(key, "Type") == 0)
  47                         type = g_variant_get_int32(key_value);
  48         }
  49
  50         group->device_id = g_strdup(device_id);
  51         group->group_name = g_strdup(group_name);
  52         group->type = type;
  53
  54         g_variant_iter_free(iter);
  55
  56         return group;
  57 }
  58
  59 mdg_device_s *mdg_get_device_from_variant(GVariant *va)
  60 {
  61         char *device_id = NULL;
  62         char *model_name = NULL;
  63         char *device_name = NULL;
  64         char *platform_ver = NULL;
  65         char *vendor_id = NULL;
  66         char *profile = NULL;
  67         bool is_invited = false;
  68         int type = MDG_DEVICE_TYPE_LOCAL;
  69         GVariantIter *iter = NULL;
  70         const gchar *key;
  71         GVariant *key_value = NULL;
  72
  73         mdg_device_s *device = calloc(1, sizeof(mdg_device_s));
  74         if (NULL == device) {
  75                 /* LCOV_EXCL_START */
  76                 _ERR("Memory allocation failed");
  77                 return NULL;
  78                 /* LCOV_EXCL_STOP */
  79         }
  80
  81         g_variant_get(va, "a{sv}", &iter);
  82         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  83                 if (g_strcmp0(key, "DeviceID") == 0)
  84                         device_id = (char *)g_variant_get_string(key_value, NULL);
  85                 else if (g_strcmp0(key, "ModelName") == 0)
  86                         model_name = (char *)g_variant_get_string(key_value, NULL);
  87                 else if (g_strcmp0(key, "DeviceName") == 0)
  88                         device_name = (char *)g_variant_get_string(key_value, NULL);
  89                 else if (g_strcmp0(key, "PlatformVer") == 0)
  90                         platform_ver = (char *)g_variant_get_string(key_value, NULL);
  91                 else if (g_strcmp0(key, "VendorID") == 0)
  92                         vendor_id = (char *)g_variant_get_string(key_value, NULL);
  93                 else if (g_strcmp0(key, "Profile") == 0)
  94                         profile = (char *)g_variant_get_string(key_value, NULL);
  95                 else if (g_strcmp0(key, "IsInvited") == 0)
  96                         is_invited = g_variant_get_int32(key_value);
  97                 else if (g_strcmp0(key, "Type") == 0)
  98                         type = g_variant_get_int32(key_value);
  99         }
 100
 101         device->device_id = g_strdup(device_id);
 102         device->model_name = g_strdup(model_name);
 103         device->device_name = g_strdup(device_name);
 104         device->platform_ver = g_strdup(platform_ver);
 105         device->vendor_id = g_strdup(vendor_id);
 106         device->profile = g_strdup(profile);
 107         device->is_invited = is_invited;
 108         device->type = type;
 109
 110         g_variant_iter_free(iter);
 111
 112         return device;
 113 }
 114
 115 void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id,
 116         char **remote_address)
 117 {
 118         GVariantIter *iter = NULL;
 119         const gchar *key;
 120         GVariant *key_value = NULL;
 121
 122         g_variant_get(va, "a{sv}", &iter);
 123         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 124                 if (g_strcmp0(key, "DeviceID") == 0)
 125                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 126                 else if (g_strcmp0(key, "ChannelID") == 0)
 127                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 128                 else if (g_strcmp0(key, "RemoteAddress") == 0) {
 129                         if (remote_address != NULL)
 130                                 *remote_address = (char *)g_variant_get_string(key_value, NULL);
 131                 }
 132         }
 133
 134         g_variant_iter_free(iter);
 135 }
 136
 137 void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id,
 138                                int *msg_id, unsigned char **data, int *data_len)
 139 {
 140         GVariantIter *iter = NULL;
 141         const gchar *key;
 142         GVariant *key_value = NULL;
 143         GVariant *data_va = NULL;
 144         GVariantIter *data_iter = NULL;
 145         unsigned char byte_data;
 146
 147         g_variant_get(va, "a{sv}", &iter);
 148         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 149                 if (g_strcmp0(key, "DeviceID") == 0)
 150                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 151                 else if (g_strcmp0(key, "ChannelID") == 0)
 152                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 153                 else if (g_strcmp0(key, "MsgID") == 0)
 154                         *msg_id = g_variant_get_int32(key_value);
 155                 else if (g_strcmp0(key, "Data") == 0)
 156                         data_va = g_variant_get_variant(key_value);
 157                 else if (g_strcmp0(key, "DataLen") == 0)
 158                         *data_len = g_variant_get_int32(key_value);
 159         }
 160
 161         if (*data_len > 0) {
 162                 int i = 0;
 163                 *data = (unsigned char *)g_try_malloc0(*data_len + 1);
 164
 165                 g_variant_get(data_va, "a(y)", &data_iter);
 166                 while (g_variant_iter_loop(data_iter, "(y)", &byte_data))
 167                         (*data)[i++] = byte_data;
 168         }
 169
 170         g_variant_iter_free(iter);
 171 }
 172
 173 void mdg_get_progress_from_variant(GVariant *va, char **file_path,
 174                                    long long *send_size, long long *total_size, int *percent)
 175 {
 176         GVariantIter *iter = NULL;
 177         const gchar *key;
 178         GVariant *key_value = NULL;
 179
 180         g_variant_get(va, "a{sv}", &iter);
 181         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 182                 if (g_strcmp0(key, "FilePath") == 0)
 183                         *file_path = (char *)g_variant_get_string(key_value, NULL);
 184                 if (g_strcmp0(key, "SendSize") == 0)
 185                         *send_size = g_variant_get_int64(key_value);
 186                 if (g_strcmp0(key, "TotalSize") == 0)
 187                         *total_size = g_variant_get_int64(key_value);
 188                 if (g_strcmp0(key, "Percent") == 0)
 189                         *percent = g_variant_get_int32(key_value);
 190         }
 191
 192         g_variant_iter_free(iter);
 193 }
 194
 195 void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path)
 196 {
 197         GVariantIter *iter = NULL;
 198         const gchar *key;
 199         GVariant *key_value = NULL;
 200
 201         g_variant_get(va, "a{sv}", &iter);
 202         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 203                 if (g_strcmp0(key, "DeviceID") == 0)
 204                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 205                 if (g_strcmp0(key, "FilePath") == 0)
 206                         *file_path = (char *)g_variant_get_string(key_value, NULL);
 207         }
 208
 209         g_variant_iter_free(iter);
 210 }
 211
 212 GVariant *mdg_create_variant_device(mdg_device_s *device)
 213 {
 214         GVariant *va;
 215
 216         GVariantBuilder *builder;
 217
 218         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 219
 220         g_variant_builder_add(builder, "{sv}", "DeviceID",
 221                               g_variant_new_string(device->device_id));
 222         g_variant_builder_add(builder, "{sv}", "ModelName",
 223                               g_variant_new_string(device->model_name));
 224         g_variant_builder_add(builder, "{sv}", "DeviceName",
 225                               g_variant_new_string(device->device_name));
 226         g_variant_builder_add(builder, "{sv}", "PlatformVer",
 227                               g_variant_new_string(device->platform_ver));
 228         g_variant_builder_add(builder, "{sv}", "VendorID",
 229                               g_variant_new_string(device->vendor_id));
 230         g_variant_builder_add(builder, "{sv}", "Profile",
 231                               g_variant_new_string(device->profile));
 232         g_variant_builder_add(builder, "{sv}", "IsInvited",
 233                               g_variant_new_int32(device->is_invited));
 234         g_variant_builder_add(builder, "{sv}", "Type",
 235                               g_variant_new_int32(device->type));
 236
 237         va = g_variant_builder_end(builder);
 238
 239         g_variant_builder_unref(builder);
 240
 241         return va;
 242 }
 243
 244 void mdg_clean_group (mdg_group_s *group)
 245 {
 246         if (group == NULL)
 247                 return;
 248
 249         if (group->device_id) {
 250                 g_free(group->device_id);
 251                 group->device_id = NULL;
 252         }
 253         if (group->group_name) {
 254                 g_free(group->group_name);
 255                 group->group_name = NULL;
 256         }
 257
 258         g_free(group);
 259         group = NULL;
 260 }
 261
 262 void mdg_clean_device (mdg_device_s *device)
 263 {
 264         if (device == NULL)
 265                 return;
 266
 267         if (device->device_id) {
 268                 g_free(device->device_id);
 269                 device->device_id = NULL;
 270         }
 271
 272         if (device->model_name) {
 273                 g_free(device->model_name);
 274                 device->model_name = NULL;
 275         }
 276
 277         if (device->device_name) {
 278                 g_free(device->device_name);
 279                 device->device_name = NULL;
 280         }
 281
 282         if (device->platform_ver) {
 283                 g_free(device->platform_ver);
 284                 device->platform_ver = NULL;
 285         }
 286
 287         if (device->vendor_id) {
 288                 g_free(device->vendor_id);
 289                 device->vendor_id = NULL;
 290         }
 291
 292         if (device->profile) {
 293                 g_free(device->profile);
 294                 device->profile = NULL;
 295         }
 296
 297         g_free(device);
 298         device = NULL;
 299 }
 300
 301 void mdg_clean_channel (mdg_channel_s *channel)
 302 {
 303         if (channel == NULL)
 304                 return;
 305
 306         if (channel->device_id) {
 307                 g_free(channel->device_id);
 308                 channel->device_id = NULL;
 309         }
 310
 311         if (channel->channel_id) {
 312                 g_free(channel->channel_id);
 313                 channel->channel_id = NULL;
 314         }
 315
 316         if (channel->remote_address) {
 317                 g_free(channel->remote_address);
 318                 channel->remote_address = NULL;
 319         }
 320
 321         g_free(channel);
 322         channel = NULL;
 323 }
 324