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 static int _get_default_path_in_conf(char *buf, int size)
 179 {
 180         FILE *in = NULL;
 181         size_t nread = 0;
 182
 183         in = fopen(CONF_FILE, "r");
 184         retv_if(!in, -1);
 185
 186         nread = fread(buf, 1, size, in);
 187         if (nread <= 0) {
 188                 _I("No contents in the conf.");
 189                 return -1;
 190         }
 191
 192         if (buf[nread - 1] == '\n')
 193                 buf[nread - 1] = '\0';
 194
 195         fclose(in);
 196
 197         return 0;
 198 }
 199
 200 int web_util_json_add_sensor_data(const char* sensorpi_id, web_util_sensor_data_s *sensor_data)
 201 {
 202         const char n_id[] = "SensorPiID";
 203         const char n_motion[] = "Motion";
 204         const char n_flame[] = "Flame";
 205         const char n_hum[] = "Humidity";
 206         const char n_temp[] = "Temperature";
 207         const char n_vib[] = "Vibration";
 208         const char n_co2[] = "CO2";
 209         const char n_sound[] = "SoundLevel";
 210         const char n_tilt[] = "Tilt";
 211         const char n_light[] = "Light";
 212         const char n_collision[] = "Collision";
 213         const char n_obstacle[] = "Obstacle";
 214         const char n_distance[] = "Distance";
 215         const char n_rain[] = "Rain";
 216         const char n_touch[] = "Touch";
 217         const char n_gas[] = "Gas";
 218         const char n_e_sensor[] = "SensorEnabled";
 219         const char n_hash[] = "Hash";
 220         const char *path = NULL;
 221         char default_path[URI_PATH_LEN] = { 0, };
 222         int ret = -1;
 223
 224         retv_if(Json_h.builder == NULL, -1);
 225         retv_if(Json_h.is_begin == false, -1);
 226         retv_if(Json_h.is_end == true, -1);
 227         retv_if(sensor_data == NULL, -1);
 228
 229         /* JSON structure :
 230         {
 231                 SensorPiID: string,
 232                 Motion: boolean,
 233                 Flame: boolean,
 234                 Humidity: double,
 235                 Temperature: double,
 236                 Vibration: boolean,
 237                 CO2: double,
 238                 SoundLevel: int,
 239                 Tilt: int,
 240                 Light: int,
 241                 Collision: int,
 242                 Obstacle: int,
 243                 Distance: double,
 244                 Rain: int,
 245                 Touch: int,
 246                 Gas: int,
 247                 SensorEnabled: [Motion, ],
 248                 Hash: string,
 249         }
 250         */
 251
 252         if (sensorpi_id) {
 253                 path = sensorpi_id;
 254         } else {
 255                 ret = _get_default_path_in_conf(default_path, URI_PATH_LEN);
 256                 retv_if(ret < 0, -1);
 257                 path = default_path;
 258         }
 259         retv_if(!path, -1);
 260         retv_if(0 == strlen(path), -1);
 261
 262         json_builder_begin_object(Json_h.builder);
 263
 264         json_builder_set_member_name(Json_h.builder, n_id);
 265         json_builder_add_string_value(Json_h.builder, path);
 266
 267         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_MOTION) {
 268                 json_builder_set_member_name(Json_h.builder, n_motion);
 269                 json_builder_add_int_value(Json_h.builder, sensor_data->motion);
 270         }
 271
 272         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_FLAME) {
 273                 json_builder_set_member_name(Json_h.builder, n_flame);
 274                 json_builder_add_int_value(Json_h.builder, sensor_data->flame);
 275         }
 276
 277         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_HUMIDITY) {
 278                 json_builder_set_member_name(Json_h.builder, n_hum);
 279                 json_builder_add_double_value(Json_h.builder, sensor_data->humidity);
 280         }
 281
 282         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TEMPERATURE) {
 283                 json_builder_set_member_name(Json_h.builder, n_temp);
 284                 json_builder_add_double_value(Json_h.builder, sensor_data->temperature);
 285         }
 286
 287         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_VIB) {
 288                 json_builder_set_member_name(Json_h.builder, n_vib);
 289                 json_builder_add_int_value(Json_h.builder, sensor_data->virbration);
 290         }
 291
 292         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_CO2) {
 293                 json_builder_set_member_name(Json_h.builder, n_co2);
 294                 json_builder_add_double_value(Json_h.builder, sensor_data->co2);
 295         }
 296
 297         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_SOUND) {
 298                 json_builder_set_member_name(Json_h.builder, n_sound);
 299                 json_builder_add_int_value(Json_h.builder, sensor_data->soundlevel);
 300         }
 301
 302         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TILT) {
 303                 json_builder_set_member_name(Json_h.builder, n_tilt);
 304                 json_builder_add_int_value(Json_h.builder, sensor_data->tilt);
 305         }
 306
 307         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_LIGHT) {
 308                 json_builder_set_member_name(Json_h.builder, n_light);
 309                 json_builder_add_int_value(Json_h.builder, sensor_data->light);
 310         }
 311
 312         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_COLLISION) {
 313                 json_builder_set_member_name(Json_h.builder, n_collision);
 314                 json_builder_add_int_value(Json_h.builder, sensor_data->collision);
 315         }
 316
 317         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_OBSTACLE) {
 318                 json_builder_set_member_name(Json_h.builder, n_obstacle);
 319                 json_builder_add_int_value(Json_h.builder, sensor_data->obstacle);
 320         }
 321
 322         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_ULTRASONIC_DISTANCE) {
 323                 json_builder_set_member_name(Json_h.builder, n_distance);
 324                 json_builder_add_double_value(Json_h.builder, sensor_data->distance);
 325         }
 326
 327         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_RAIN) {
 328                 json_builder_set_member_name(Json_h.builder, n_rain);
 329                 json_builder_add_int_value(Json_h.builder, sensor_data->rain);
 330         }
 331
 332         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TOUCH) {
 333                 json_builder_set_member_name(Json_h.builder, n_touch);
 334                 json_builder_add_int_value(Json_h.builder, sensor_data->touch);
 335         }
 336
 337         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_GAS) {
 338                 json_builder_set_member_name(Json_h.builder, n_gas);
 339                 json_builder_add_int_value(Json_h.builder, sensor_data->gas);
 340         }
 341
 342         json_builder_set_member_name(Json_h.builder, n_e_sensor);
 343         json_builder_begin_array(Json_h.builder);
 344
 345         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_MOTION)
 346                 json_builder_add_string_value(Json_h.builder, n_motion);
 347
 348         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_FLAME)
 349                 json_builder_add_string_value(Json_h.builder, n_flame);
 350
 351         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_HUMIDITY)
 352                 json_builder_add_string_value(Json_h.builder, n_hum);
 353
 354         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TEMPERATURE)
 355                 json_builder_add_string_value(Json_h.builder, n_temp);
 356
 357         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_VIB)
 358                 json_builder_add_string_value(Json_h.builder, n_vib);
 359
 360         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_CO2)
 361                 json_builder_add_string_value(Json_h.builder, n_co2);
 362
 363         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_SOUND)
 364                 json_builder_add_string_value(Json_h.builder, n_sound);
 365
 366         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TILT)
 367                 json_builder_add_string_value(Json_h.builder, n_tilt);
 368
 369         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_LIGHT)
 370                 json_builder_add_string_value(Json_h.builder, n_light);
 371
 372         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_COLLISION)
 373                 json_builder_add_string_value(Json_h.builder, n_collision);
 374
 375         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_OBSTACLE)
 376                 json_builder_add_string_value(Json_h.builder, n_obstacle);
 377
 378         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_ULTRASONIC_DISTANCE)
 379                 json_builder_add_string_value(Json_h.builder, n_distance);
 380
 381         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_RAIN)
 382                 json_builder_add_string_value(Json_h.builder, n_rain);
 383
 384         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_TOUCH)
 385                 json_builder_add_string_value(Json_h.builder, n_touch);
 386
 387         if (sensor_data->enabled_sensor & WEB_UTIL_SENSOR_GAS)
 388                 json_builder_add_string_value(Json_h.builder, n_gas);
 389
 390         json_builder_end_array(Json_h.builder);
 391
 392         if (sensor_data->hash) {
 393                 json_builder_set_member_name(Json_h.builder, n_hash);
 394                 json_builder_add_string_value(Json_h.builder, sensor_data->hash);
 395         }
 396
 397         json_builder_end_object(Json_h.builder);
 398
 399         return 0;
 400 }
 401
 402 char *web_util_get_json_string(void)
 403 {
 404         JsonGenerator *gen = NULL;
 405         JsonNode *root = NULL;
 406         char *str = NULL;
 407
 408         retv_if(Json_h.builder == NULL, NULL);
 409         retv_if(Json_h.is_begin == false, NULL);
 410         retv_if(Json_h.is_end == false, NULL);
 411
 412         root = json_builder_get_root(Json_h.builder);
 413         retv_if(root == NULL, NULL);
 414
 415         gen = json_generator_new();
 416         goto_if(gen == NULL, error_release_all);
 417         json_generator_set_root(gen, root);
 418
 419         str = json_generator_to_data(gen, NULL);
 420
 421         return str;
 422
 423 error_release_all:
 424         if (root)
 425                 json_node_free(root);
 426
 427         if (gen)
 428                 g_object_unref(gen);
 429
 430         return NULL;
 431 }
 432