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 <stdlib.h>
  19 #include <mdg.h>
  20 #include <mdg_debug.h>
  21 #include <mdg_private.h>
  22
  23 mdg_group_s *mdg_get_group_from_variant(GVariant *va)
  24 {
  25         char *device_id = NULL;
  26         char *host_addr = NULL;
  27         char *group_name = NULL;
  28         mdg_group_type_e type = MDG_GROUP_TYPE_LOCAL;
  29         GVariantIter *iter = NULL;
  30         const gchar *key;
  31         GVariant *key_value = NULL;
  32
  33         mdg_group_s *group = calloc(1, sizeof(mdg_group_s));
  34         if (NULL == group) {
  35                         /* LCOV_EXCL_START */
  36                         _ERR("Memory allocation failed");
  37                         return NULL;
  38                         /* LCOV_EXCL_STOP */
  39         }
  40
  41         g_variant_get(va, "a{sv}", &iter);
  42         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  43                 if (g_strcmp0(key, "DeviceID") == 0)
  44                         device_id = (char *)g_variant_get_string(key_value, NULL);
  45                 else if (g_strcmp0(key, "HostAddr") == 0)
  46                         host_addr = (char *)g_variant_get_string(key_value, NULL);
  47                 else if (g_strcmp0(key, "GroupName") == 0)
  48                         group_name = (char *)g_variant_get_string(key_value, NULL);
  49                 else if (g_strcmp0(key, "Type") == 0)
  50                         type = g_variant_get_int32(key_value);
  51         }
  52
  53         group->device_id = g_strdup(device_id);
  54         group->host_addr = g_strdup(host_addr);
  55         group->group_name = g_strdup(group_name);
  56         group->type = type;
  57
  58         g_variant_iter_free(iter);
  59
  60         return group;
  61 }
  62
  63 mdg_device_s *mdg_get_device_from_variant(GVariant *va)
  64 {
  65         char *device_id = NULL;
  66         char *addr = NULL;
  67         int port;
  68         int secure_port;
  69         int conn_type;
  70         char *model_name = NULL;
  71         char *device_name = NULL;
  72         char *platform_ver = NULL;
  73         char *vendor_id = NULL;
  74         char *profile = NULL;
  75         bool is_invited;
  76         int type = MDG_DEVICE_TYPE_LOCAL;
  77         GVariantIter *iter = NULL;
  78         const gchar *key;
  79         GVariant *key_value = NULL;
  80
  81         mdg_device_s *device = calloc(1, sizeof(mdg_device_s));
  82         if (NULL == device) {
  83                         /* LCOV_EXCL_START */
  84                         _ERR("Memory allocation failed");
  85                         return NULL;
  86                         /* LCOV_EXCL_STOP */
  87         }
  88
  89         g_variant_get(va, "a{sv}", &iter);
  90         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
  91                 if (g_strcmp0(key, "DeviceID") == 0)
  92                         device_id = (char *)g_variant_get_string(key_value, NULL);
  93                 else if (g_strcmp0(key, "Addr") == 0)
  94                         addr = (char *)g_variant_get_string(key_value, NULL);
  95                 else if (g_strcmp0(key, "Port") == 0)
  96                         port = g_variant_get_int32(key_value);
  97                 else if (g_strcmp0(key, "SecurePort") == 0)
  98                         secure_port = g_variant_get_int32(key_value);
  99                 else if (g_strcmp0(key, "ConnType") == 0)
 100                         conn_type = g_variant_get_int32(key_value);
 101                 else if (g_strcmp0(key, "ModelName") == 0)
 102                         model_name = (char *)g_variant_get_string(key_value, NULL);
 103                 else if (g_strcmp0(key, "DeviceName") == 0)
 104                         device_name = (char *)g_variant_get_string(key_value, NULL);
 105                 else if (g_strcmp0(key, "PlatformVer") == 0)
 106                         platform_ver = (char *)g_variant_get_string(key_value, NULL);
 107                 else if (g_strcmp0(key, "VendorID") == 0)
 108                         vendor_id = (char *)g_variant_get_string(key_value, NULL);
 109                 else if (g_strcmp0(key, "Profile") == 0)
 110                         profile = (char *)g_variant_get_string(key_value, NULL);
 111                 else if (g_strcmp0(key, "IsInvited") == 0)
 112                         is_invited = g_variant_get_int32(key_value);
 113                 else if (g_strcmp0(key, "Type") == 0)
 114                         type = g_variant_get_int32(key_value);
 115         }
 116
 117         device->device_id = g_strdup(device_id);
 118         device->addr = g_strdup(addr);
 119         device->port = port;
 120         device->secure_port = secure_port;
 121         device->conn_type = conn_type;
 122         device->model_name = g_strdup(model_name);
 123         device->device_name = g_strdup(device_name);
 124         device->platform_ver = g_strdup(platform_ver);
 125         device->vendor_id = g_strdup(vendor_id);
 126         device->profile = g_strdup(profile);
 127         device->is_invited = is_invited;
 128         device->type = type;
 129
 130         g_variant_iter_free(iter);
 131
 132         return device;
 133 }
 134
 135 void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id)
 136 {
 137         GVariantIter *iter = NULL;
 138         const gchar *key;
 139         GVariant *key_value = NULL;
 140
 141         g_variant_get(va, "a{sv}", &iter);
 142         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 143                 if (g_strcmp0(key, "DeviceID") == 0)
 144                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 145                 else if (g_strcmp0(key, "ChannelID") == 0)
 146                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 147         }
 148
 149         g_variant_iter_free(iter);
 150 }
 151
 152 void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id,
 153         unsigned char **data, int *data_len)
 154 {
 155         GVariantIter *iter = NULL;
 156         const gchar *key;
 157         GVariant *key_value = NULL;
 158         GVariant *data_va;
 159         GVariantIter *data_iter = NULL;
 160         unsigned char byte_data;
 161
 162         g_variant_get(va, "a{sv}", &iter);
 163         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 164                 if (g_strcmp0(key, "DeviceID") == 0)
 165                         *device_id = (char *)g_variant_get_string(key_value, NULL);
 166                 else if (g_strcmp0(key, "ChannelID") == 0)
 167                         *channel_id = (char *)g_variant_get_string(key_value, NULL);
 168                 else if (g_strcmp0(key, "Data") == 0)
 169                         data_va = g_variant_get_variant(key_value);
 170                 else if (g_strcmp0(key, "DataLength") == 0)
 171                         *data_len = g_variant_get_int32(key_value);
 172         }
 173
 174         int i = 0;
 175         *data = (unsigned char *)g_try_malloc0(*data_len + 1);
 176
 177         g_variant_get(data_va, "a(y)", &data_iter);
 178         while (g_variant_iter_loop(data_iter, "(y)", &byte_data))
 179                 (*data)[i++] = byte_data;
 180
 181         g_variant_iter_free(iter);
 182 }
 183
 184 void mdg_get_progress_from_variant(GVariant *va, char **file_path,
 185         long *send_size, long *total_size, int *percent)
 186 {
 187         GVariantIter *iter = NULL;
 188         const gchar *key;
 189         GVariant *key_value = NULL;
 190
 191         g_variant_get(va, "a{sv}", &iter);
 192         while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
 193                 if (g_strcmp0(key, "FilePath") == 0)
 194                         *file_path = (char *)g_variant_get_string(key_value, NULL);
 195                 if (g_strcmp0(key, "SendSize") == 0)
 196                         *send_size = g_variant_get_int64(key_value);
 197                 if (g_strcmp0(key, "TotalSize") == 0)
 198                         *total_size = g_variant_get_int64(key_value);
 199                 if (g_strcmp0(key, "Percent") == 0)
 200                         *percent = g_variant_get_int32(key_value);
 201         }
 202
 203         g_variant_iter_free(iter);
 204 }
 205
 206 GVariant *mdg_create_variant_device(mdg_device_s *device)
 207 {
 208         GVariant *va;
 209
 210         GVariantBuilder *builder;
 211
 212         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 213
 214         g_variant_builder_add(builder, "{sv}", "DeviceID",
 215                                                   g_variant_new_string(device->device_id));
 216         g_variant_builder_add(builder, "{sv}", "Port",
 217                                                   g_variant_new_int32(device->port));
 218         g_variant_builder_add(builder, "{sv}", "Addr",
 219                                                   g_variant_new_string(device->addr));
 220         g_variant_builder_add(builder, "{sv}", "ConnType",
 221                                                   g_variant_new_int32(device->conn_type));
 222         g_variant_builder_add(builder, "{sv}", "SecurePort",
 223                                                   g_variant_new_int32(device->secure_port));
 224         g_variant_builder_add(builder, "{sv}", "ModelName",
 225                                                   g_variant_new_string(device->model_name));
 226         g_variant_builder_add(builder, "{sv}", "DeviceName",
 227                                                   g_variant_new_string(device->device_name));
 228         g_variant_builder_add(builder, "{sv}", "PlatformVer",
 229                                                   g_variant_new_string(device->platform_ver));
 230         g_variant_builder_add(builder, "{sv}", "VendorID",
 231                                                   g_variant_new_string(device->vendor_id));
 232         g_variant_builder_add(builder, "{sv}", "Profile",
 233                                                   g_variant_new_string(device->profile));
 234         g_variant_builder_add(builder, "{sv}", "IsInvited",
 235                                                   g_variant_new_int32(device->is_invited));
 236         g_variant_builder_add(builder, "{sv}", "Type",
 237                                                   g_variant_new_int32(device->type));
 238
 239         va = g_variant_builder_end(builder);
 240
 241         g_variant_builder_unref(builder);
 242
 243         return va;
 244 }
 245