src/webutil.c

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Contact: Jin Yoon <jinny.yoon@samsung.com>
   5  *          Geunsun Lee <gs86.lee@samsung.com>
   6  *          Eunyoung Lee <ey928.lee@samsung.com>
   7  *          Junkyu Han <junkyu.han@samsung.com>
   8  *          Jeonghoon Park <jh1979.park@samsung.com>
   9  *
  10  * Licensed under the Flora License, Version 1.1 (the License);
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://floralicense.org/license/
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an AS IS BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  */
  22
  23 #include <stdbool.h>
  24 #include <curl/curl.h>
  25 #include <glib-object.h>
  26 #include <json-glib/json-glib.h>
  27 #include "log.h"
  28 #include "webutil.h"
  29
  30 #define URI_PATH_LEN 64
  31
  32 typedef struct _wu_json_handle {
  33         JsonBuilder *builder;
  34         bool is_begin;
  35         bool is_end;
  36 } wu_json_handle;
  37
  38 static wu_json_handle Json_h = {NULL, false, false};
  39
  40 static size_t _response_write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
  41 {
  42         size_t res_size = 0;
  43
  44         res_size = size*nmemb;
  45
  46         if (res_size > 0)
  47                 _I("POST response : %s", ptr);
  48         /* What should we do here, if response body has negative message? */
  49
  50         return res_size;
  51 }
  52
  53 int web_util_noti_init(void)
  54 {
  55         int ret = 0;
  56         CURLcode result;
  57         result = curl_global_init(CURL_GLOBAL_DEFAULT);
  58         if (result != CURLE_OK) {
  59                 _E("curl_global_init() failed: %s",
  60                         curl_easy_strerror(result));
  61                 ret = -1;
  62         }
  63         return ret;
  64 }
  65
  66 void web_util_noti_fini(void)
  67 {
  68         curl_global_cleanup();
  69         return;
  70 }
  71
  72 int web_util_noti_post(const char *resource, const char *json_data)
  73 {
  74         int ret = 0;
  75         CURL *curl = NULL;
  76         CURLcode response = CURLE_OK;
  77         struct curl_slist *headers = NULL;
  78
  79         retv_if(resource == NULL, -1);
  80         retv_if(json_data == NULL, -1);
  81
  82         _I("server : %s", resource);
  83         _I("json_data : %s", json_data);
  84
  85         curl = curl_easy_init();
  86
  87         if (!curl) {
  88                 _E("fail to init curl");
  89                 return -1;
  90         }
  91
  92         headers = curl_slist_append(headers, "Accept: application/json");
  93         headers = curl_slist_append(headers, "Content-Type: application/json");
  94
  95         curl_easy_setopt(curl, CURLOPT_URL, resource);
  96         curl_easy_setopt(curl, CURLOPT_POST, 1L);
  97         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  98         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data);
  99         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _response_write_callback);
 100
 101         response = curl_easy_perform(curl);
 102
 103         if (response != CURLE_OK) {
 104                 _E("curl_easy_perform() failed: %s",
 105                         curl_easy_strerror(response));
 106                 /* What should we do here, if response is kind of errors? */
 107                 ret = -1;
 108         }
 109
 110         curl_slist_free_all(headers);
 111         curl_easy_cleanup(curl);
 112
 113         return ret;
 114 }
 115
 116
 117 int web_util_json_init(void)
 118 {
 119         if (Json_h.builder)
 120                 g_object_unref(Json_h.builder);
 121
 122         Json_h.is_begin = false;
 123         Json_h.is_end = false;
 124         Json_h.builder = json_builder_new();
 125         retv_if(Json_h.builder == NULL, -1);
 126
 127         return 0;
 128 }
 129
 130 int web_util_json_fini(void)
 131 {
 132
 133         if (Json_h.builder) {
 134                 g_object_unref(Json_h.builder);
 135                 Json_h.builder = NULL;
 136         }
 137
 138         Json_h.is_begin = false;
 139         Json_h.is_end = false;
 140
 141         return 0;
 142 }
 143
 144 int web_util_json_data_array_begin(void)
 145 {
 146         retv_if(Json_h.builder == NULL, -1);
 147         retv_if(Json_h.is_begin == true, -1);
 148         retv_if(Json_h.is_end == true, -1);
 149
 150         Json_h.is_begin = true;
 151
 152         /*
 153         {
 154                 SensorsDataList : [ SensorData ]
 155         }
 156         */
 157
 158         json_builder_begin_object(Json_h.builder);
 159         json_builder_set_member_name(Json_h.builder, "SensorDataList");
 160         json_builder_begin_array(Json_h.builder);
 161
 162         return 0;
 163 }
 164
 165 int web_util_json_data_array_end(void)
 166 {
 167         retv_if(Json_h.builder == NULL, -1);
 168         retv_if(Json_h.is_begin == false, -1);
 169         retv_if(Json_h.is_end == true, -1);
 170
 171         json_builder_end_array(Json_h.builder);
 172         json_builder_end_object(Json_h.builder);
 173         Json_h.is_end = true;
 174
 175         return 0;
 176 }
 177
 178 int web_util_json_add_sensor_data(const char* sensorpi_id, web_util_sensor_data_s *sensor_data)
 179 {
 180         const char n_id[] = "SensorPiID";
 181         const char n_motion[] = "Motion";
 182         const char n_flame[] = "Flame";
 183         const char n_hum[] = "Humidity";
 184         const char n_temp[] = "Temperature";
 185         const char n_vib[] = "Vibration";
 186         const char n_co2[] = "CO2";
 187         const char n_sound[] = "SoundLevel";
 188         const char n_tilt[] = "Tilt";
 189         const char n_light[] = "Light";
 190         const char n_collision[] = "Collision";
 191         const char n_obstacle[] = "Obstacle";
 192         const char n_distance[] = "Distance";
 193         const char n_rain[] = "Rain";
 194         const char n_touch[] = "Touch";
 195         const char n_gas[] = "Gas";
 196         const char n_e_sensor[] = "SensorEnabled";
 197         const char n_hash[] = "Hash";
 198
 199         retv_if(!sensorpi_id, -1);
 200         retv_if(Json_h.builder == NULL, -1);
 201         retv_if(Json_h.is_begin == false, -1);
 202         retv_if(Json_h.is_end == true, -1);
 203         retv_if(sensor_data == NULL, -1);
 204
 205         /* JSON structure :
 206         {
 207                 SensorPiID: string,
 208                 Motion: boolean,
 209                 Flame: boolean,
 210                 Humidity: double,
 211                 Temperature: double,
 212                 Vibration: boolean,
 213                 CO2: double,
 214                 SoundLevel: int,
 215                 Tilt: int,
 216                 Light: int,
 217                 Collision: int,
 218                 Obstacle: int,
 219                 Distance: double,
 220                 Rain: int,
 221                 Touch: int,
 222                 Gas: int,
 223                 SensorEnabled: [Motion, ],
 224                 Hash: string,
 225         }
 226         */
 227
 228
 229         json_builder_begin_object(Json_h.builder);
 230
 231         json_builder_set_member_name(Json_h.builder, n_id);
 232         json_builder_add_string_value(Json_h.builder, sensorpi_id);
 233
 234         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_MOTION) {
 235                 json_builder_set_member_name(Json_h.builder, n_motion);
 236                 json_builder_add_int_value(Json_h.builder, sensor_data->motion);
 237         }
 238
 239         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_FLAME) {
 240                 json_builder_set_member_name(Json_h.builder, n_flame);
 241                 json_builder_add_int_value(Json_h.builder, sensor_data->flame);
 242         }
 243
 244         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_HUMIDITY) {
 245                 json_builder_set_member_name(Json_h.builder, n_hum);
 246                 json_builder_add_double_value(Json_h.builder, sensor_data->humidity);
 247         }
 248
 249         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TEMPERATURE) {
 250                 json_builder_set_member_name(Json_h.builder, n_temp);
 251                 json_builder_add_double_value(Json_h.builder, sensor_data->temperature);
 252         }
 253
 254         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_VIB) {
 255                 json_builder_set_member_name(Json_h.builder, n_vib);
 256                 json_builder_add_int_value(Json_h.builder, sensor_data->virbration);
 257         }
 258
 259         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_CO2) {
 260                 json_builder_set_member_name(Json_h.builder, n_co2);
 261                 json_builder_add_double_value(Json_h.builder, sensor_data->co2);
 262         }
 263
 264         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_SOUND) {
 265                 json_builder_set_member_name(Json_h.builder, n_sound);
 266                 json_builder_add_int_value(Json_h.builder, sensor_data->soundlevel);
 267         }
 268
 269         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TILT) {
 270                 json_builder_set_member_name(Json_h.builder, n_tilt);
 271                 json_builder_add_int_value(Json_h.builder, sensor_data->tilt);
 272         }
 273
 274         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_LIGHT) {
 275                 json_builder_set_member_name(Json_h.builder, n_light);
 276                 json_builder_add_int_value(Json_h.builder, sensor_data->light);
 277         }
 278
 279         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_COLLISION) {
 280                 json_builder_set_member_name(Json_h.builder, n_collision);
 281                 json_builder_add_int_value(Json_h.builder, sensor_data->collision);
 282         }
 283
 284         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_OBSTACLE) {
 285                 json_builder_set_member_name(Json_h.builder, n_obstacle);
 286                 json_builder_add_int_value(Json_h.builder, sensor_data->obstacle);
 287         }
 288
 289         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_ULTRASONIC_DISTANCE) {
 290                 json_builder_set_member_name(Json_h.builder, n_distance);
 291                 json_builder_add_double_value(Json_h.builder, sensor_data->distance);
 292         }
 293
 294         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_RAIN) {
 295                 json_builder_set_member_name(Json_h.builder, n_rain);
 296                 json_builder_add_int_value(Json_h.builder, sensor_data->rain);
 297         }
 298
 299         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TOUCH) {
 300                 json_builder_set_member_name(Json_h.builder, n_touch);
 301                 json_builder_add_int_value(Json_h.builder, sensor_data->touch);
 302         }
 303
 304         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_GAS) {
 305                 json_builder_set_member_name(Json_h.builder, n_gas);
 306                 json_builder_add_int_value(Json_h.builder, sensor_data->gas);
 307         }
 308
 309         json_builder_set_member_name(Json_h.builder, n_e_sensor);
 310         json_builder_begin_array(Json_h.builder);
 311
 312         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_MOTION)
 313                 json_builder_add_string_value(Json_h.builder, n_motion);
 314
 315         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_FLAME)
 316                 json_builder_add_string_value(Json_h.builder, n_flame);
 317
 318         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_HUMIDITY)
 319                 json_builder_add_string_value(Json_h.builder, n_hum);
 320
 321         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TEMPERATURE)
 322                 json_builder_add_string_value(Json_h.builder, n_temp);
 323
 324         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_VIB)
 325                 json_builder_add_string_value(Json_h.builder, n_vib);
 326
 327         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_CO2)
 328                 json_builder_add_string_value(Json_h.builder, n_co2);
 329
 330         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_SOUND)
 331                 json_builder_add_string_value(Json_h.builder, n_sound);
 332
 333         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TILT)
 334                 json_builder_add_string_value(Json_h.builder, n_tilt);
 335
 336         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_LIGHT)
 337                 json_builder_add_string_value(Json_h.builder, n_light);
 338
 339         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_COLLISION)
 340                 json_builder_add_string_value(Json_h.builder, n_collision);
 341
 342         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_OBSTACLE)
 343                 json_builder_add_string_value(Json_h.builder, n_obstacle);
 344
 345         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_ULTRASONIC_DISTANCE)
 346                 json_builder_add_string_value(Json_h.builder, n_distance);
 347
 348         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_RAIN)
 349                 json_builder_add_string_value(Json_h.builder, n_rain);
 350
 351         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TOUCH)
 352                 json_builder_add_string_value(Json_h.builder, n_touch);
 353
 354         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_GAS)
 355                 json_builder_add_string_value(Json_h.builder, n_gas);
 356
 357         json_builder_end_array(Json_h.builder);
 358
 359         if (sensor_data->hash) {
 360                 json_builder_set_member_name(Json_h.builder, n_hash);
 361                 json_builder_add_string_value(Json_h.builder, sensor_data->hash);
 362         }
 363
 364         json_builder_end_object(Json_h.builder);
 365
 366         return 0;
 367 }
 368
 369 char *web_util_get_json_string(void)
 370 {
 371         JsonGenerator *gen = NULL;
 372         JsonNode *root = NULL;
 373         char *str = NULL;
 374
 375         retv_if(Json_h.builder == NULL, NULL);
 376         retv_if(Json_h.is_begin == false, NULL);
 377         retv_if(Json_h.is_end == false, NULL);
 378
 379         root = json_builder_get_root(Json_h.builder);
 380         retv_if(root == NULL, NULL);
 381
 382         gen = json_generator_new();
 383         goto_if(gen == NULL, error_release_all);
 384         json_generator_set_root(gen, root);
 385
 386         str = json_generator_to_data(gen, NULL);
 387
 388         return str;
 389
 390 error_release_all:
 391         if (root)
 392                 json_node_free(root);
 393
 394         if (gen)
 395                 g_object_unref(gen);
 396
 397         return NULL;
 398 }
 399