src/ttrss_ws.c

   1 /*
   2  * Copyright (C) 2010-2013 jeanfi@gmail.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301 USA
  18  */
  19
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23
  24 #include <json/json.h>
  25
  26 #include "http.h"
  27 #include "log.h"
  28 #include "ttrss_ws.h"
  29 #include "url.h"
  30
  31 static char *session_id;
  32 static char *session_url;
  33 static char *session_user;
  34 static char *session_pwd;
  35
  36 void ws_request_add_att_str(json_object *rq, const char *k, const char *str)
  37 {
  38         json_object_object_add(rq, k, json_object_new_string(str));
  39 }
  40
  41 void ws_request_add_att_int(json_object *rq, const char *k, int v)
  42 {
  43         json_object_object_add(rq, k, json_object_new_int(v));
  44 }
  45
  46 struct json_object *ws_request_new(const char *op)
  47 {
  48         struct json_object *rq;
  49
  50         rq = json_object_new_object();
  51
  52         ws_request_add_att_str(rq, "op", op);
  53
  54         if (session_id)
  55                 ws_request_add_att_str(rq, "sid", session_id);
  56
  57         return rq;
  58 }
  59
  60 void ws_init(const char *url, const char *user, const char *pwd)
  61 {
  62         char *tmp;
  63
  64         if (session_url && !strcmp(session_url, url)
  65             && session_user && !strcmp(session_user, user)
  66             && session_pwd && !strcmp(session_pwd, pwd))
  67                 return ;
  68
  69         free(session_id);
  70         session_id = NULL;
  71
  72         free(session_user);
  73         session_user = strdup(user);
  74
  75         free(session_pwd);
  76         session_pwd = strdup(pwd);
  77
  78         tmp = url_normalize(url);
  79         free(session_url);
  80         session_url = malloc(strlen(tmp) + strlen("/api/") + 1);
  81         strcpy(session_url, tmp);
  82         strcat(session_url, "/api/");
  83         free(tmp);
  84 }
  85
  86 struct json_object *ws_reply_get_content(struct json_object *rp)
  87 {
  88         return json_object_object_get(rp, "content");
  89 }
  90
  91 static struct json_object *execute(struct json_object *rq, char **err)
  92 {
  93         struct json_object *rp, *content, *jerror;
  94         const char *str;
  95
  96         rp = http_json_get(session_url, rq);
  97
  98         content = NULL;
  99
 100         if (rp) {
 101                 content = ws_reply_get_content(rp);
 102
 103                 if (content) {
 104                         jerror = json_object_object_get(content, "error");
 105                         if (jerror) {
 106                                 if (err) {
 107                                         str = json_object_get_string(jerror);
 108                                         *err = strdup(str);
 109                                 }
 110                                 content = NULL;
 111                         } else {
 112                                 json_object_get(content);
 113                         }
 114                 }
 115
 116                 json_object_put(rp);
 117         }
 118
 119         return content;
 120 }
 121
 122 struct json_object *ws_execute(struct json_object *rq)
 123 {
 124         char *err;
 125         struct json_object *result;
 126
 127         log_debug("ws_execute()");
 128
 129         err = NULL;
 130         result = execute(rq, &err);
 131
 132         if (err) {
 133                 log_debug("ws_execute(): error=%s\n", err);
 134
 135                 if (!strcmp(err, "NOT_LOGGED_IN")) {
 136                         ws_open_session();
 137                         result = execute(rq, NULL);
 138                 }
 139
 140                 free(err);
 141         }
 142
 143         return result;
 144 }
 145
 146 int ws_get_api_version()
 147 {
 148         struct json_object *rp, *rq;
 149         int v;
 150
 151         rq = ws_request_new("getApiLevel");
 152
 153         rp = ws_execute(rq);
 154
 155         json_object_put(rq);
 156
 157         if (rp) {
 158                 v = json_object_get_int(json_object_object_get(rp, "level"));
 159
 160                 json_object_put(rp);
 161         } else {
 162                 v = 0;
 163         }
 164
 165         return v;
 166 }
 167
 168 char *ws_login()
 169 {
 170         struct json_object *rq, *rp, *j;
 171         char *str;
 172
 173         rq = ws_request_new("login");
 174         ws_request_add_att_str(rq, "user", session_user);
 175         ws_request_add_att_str(rq, "password", session_pwd);
 176
 177         rp = ws_execute(rq);
 178         json_object_put(rq);
 179
 180         str = NULL;
 181         if (rp) {
 182                 j = json_object_object_get(rp, "session_id");
 183
 184                 if (j)
 185                         str = strdup(json_object_get_string(j));
 186
 187                 json_object_put(rp);
 188         }
 189
 190         return str;
 191 }
 192
 193 int ws_open_session()
 194 {
 195         int version, result;
 196
 197         log_debug("ws_open_session()");
 198
 199         if (session_id)
 200                 free(session_id);
 201
 202         session_id = ws_login();
 203
 204         if (session_id) {
 205                 version = ws_get_api_version();
 206                 log_debug("API version= %d", version);
 207
 208                 if (version > 0) {
 209                         result = 1;
 210                 } else {
 211                         free(session_id);
 212                         session_id = NULL;
 213                         result = 0;
 214                 }
 215         } else {
 216                 result =  0;
 217         }
 218
 219         return result;
 220 }
 221
 222 char *ws_get_article_content(int id)
 223 {
 224         struct json_object *rp, *rq, *content, *item;
 225         char *str;
 226
 227         rq = ws_request_new("getArticle");
 228         ws_request_add_att_int(rq, "article_id", id);
 229
 230         rp = ws_execute(rq);
 231
 232         json_object_put(rq);
 233
 234         str = NULL;
 235
 236         if (rp) {
 237                 item = json_object_array_get_idx(rp, 0);
 238
 239                 if (item) {
 240                         content = json_object_object_get(item, "content");
 241                         str = strdup(json_object_get_string(content));
 242                 }
 243
 244                 json_object_put(rp);
 245         }
 246
 247         return str;
 248 }
 249
 250 int ws_update_headlines(struct feed *feed)
 251 {
 252         struct json_object *rp, *rq, *jheadline, *j;
 253         int i, n, hid;
 254         struct headline *h, **tmp;
 255         const char *title, *url;
 256
 257         rq = ws_request_new("getHeadlines");
 258         ws_request_add_att_int(rq, "feed_id", feed->id);
 259
 260         rp = ws_execute(rq);
 261
 262         json_object_put(rq);
 263
 264         if (rp) {
 265                 n = json_object_array_length(rp);
 266                 for (i = 0; i < n; i++) {
 267                         jheadline = json_object_array_get_idx(rp, i);
 268
 269                         j = json_object_object_get(jheadline, "id");
 270                         hid = json_object_get_int(j);
 271                         h = feed_get_headline(feed, hid);
 272
 273                         if (!h) {
 274                                 j = json_object_object_get(jheadline, "title");
 275                                 title = json_object_get_string(j);
 276
 277                                 j = json_object_object_get(jheadline, "link");
 278                                 url = json_object_get_string(j);
 279
 280                                 h = headline_new(hid, url, title);
 281
 282                                 tmp = headlines_add(feed->headlines, h);
 283                                 if (feed->headlines)
 284                                         free(feed->headlines);
 285                                 feed->headlines = tmp;
 286                         }
 287
 288                         j = json_object_object_get(jheadline, "unread");
 289                         h->unread = json_object_get_boolean(j);
 290                 }
 291                 json_object_put(rp);
 292                 return 1;
 293         } else {
 294                 return 0;
 295         }
 296 }
 297
 298 struct feed **ws_update_feeds(struct feed **feeds)
 299 {
 300         struct json_object *rp, *rq, *jfeed, *j;
 301         int i, n, id;
 302         struct feed *feed, **tmp;
 303         const char *title, *url;
 304
 305         log_debug("ws_update_feeds()");
 306
 307         rq = ws_request_new("getFeeds");
 308
 309         rp = ws_execute(rq);
 310         json_object_put(rq);
 311
 312         if (rp) {
 313                 n = json_object_array_length(rp);
 314
 315                 for (i = 0; i < n; i++) {
 316                         jfeed = json_object_array_get_idx(rp, i);
 317
 318                         j = json_object_object_get(jfeed, "id");
 319                         id = json_object_get_int(j);
 320
 321                         feed = feeds_get_feed(feeds, id);
 322
 323                         if (!feed) {
 324                                 j = json_object_object_get(jfeed, "title");
 325                                 title = json_object_get_string(j);
 326
 327                                 j = json_object_object_get(jfeed, "feed_url");
 328                                 url = json_object_get_string(j);
 329
 330                                 feed = feed_new(id, url, title);
 331
 332                                 tmp = feeds_add(feeds, feed);
 333                                 free(feeds);
 334                                 feeds = tmp;
 335                         }
 336
 337                         j = json_object_object_get(jfeed, "unread");
 338                         feed->unread = json_object_get_int(j);
 339                 }
 340                 json_object_put(rp);
 341         } else {
 342                 feeds_free(feeds);
 343                 feeds = NULL;
 344         }
 345
 346         log_debug("ws_update_feeds() done");
 347
 348         return feeds;
 349 }
 350
 351 void ws_set_article_unread(int id, int unread)
 352 {
 353         struct json_object *rp, *rq;
 354
 355
 356         log_debug("ws_set_article_unread(%d,%d)", id, unread);
 357
 358         rq = ws_request_new("updateArticle");
 359         json_object_object_add(rq, "article_ids", json_object_new_int(id));
 360         json_object_object_add(rq, "field", json_object_new_int(2));
 361         json_object_object_add(rq, "mode", json_object_new_int(unread));
 362
 363         rp = ws_execute(rq);
 364
 365         json_object_put(rq);
 366
 367         if (rp)
 368                 json_object_put(rp);
 369
 370         log_debug("ws_set_article_unread(%d,%d) done", id, unread);
 371 }