source: protocols/rpc/rpc.c @ 9076a1c

Last change on this file since 9076a1c was 9076a1c, checked in by Wilmer van der Gaast <wilmer@…>, at 2015-07-27T23:48:04Z

Fix cleanup of (RPC) groupchats, fixes some crashes at logout time.

  • Property mode set to 100644
File size: 32.5 KB
Line 
1#include <sys/socket.h>
2#include <sys/un.h>
3#include <sys/types.h>
4#include <dirent.h>
5
6#include "bitlbee.h"
7#include "bee.h"
8#include "nogaim.h"
9#include "parson.h"
10
11#define JSON_O_FOREACH(o, k, v) \
12    const char *k; const JSON_Value *v; int __i; \
13    for (__i = 0; json_object_get_tuple(o, __i, &k, &v); __i++)
14
15static int next_rpc_id = 1;
16
17struct rpc_plugin {
18        /* Socket address of the RPC server. */
19        struct sockaddr *addr;
20        socklen_t addrlen;
21        /* Full copy of the "settings" section of the init message. This info
22         * can only be applied later on, when an account is created (but well
23         * before logging in). */
24        JSON_Value *settings;
25        /* Supported away states returned by the away_states() function. Since
26         * RPC servers can't do return values, just get this info at init time.
27         * This means the list of possible away states is static from init time
28         * which hopefully won't be a problem. If NULL, the away_states function
29         * will not be set on this protocol. */
30        GList *away_states;
31        /* Account flags. See account.h. Plugin lib should provide constants. */
32        int account_flags;
33};
34
35struct rpc_connection {
36        int fd;
37        char *buf;
38        int buflen;
39        GHashTable *groupchats;
40};
41
42struct rpc_groupchat {
43        int id;
44        struct groupchat *gc;
45};
46
47static JSON_Value *jsonrpc_error(int code, const char *msg) {
48        JSON_Value *ret = json_value_init_object();
49        json_object_set_null(json_object(ret), "result");
50        if (TRUE) {
51                /* Format from http://jsonrpc.org/historical/json-rpc-1-1-alt.html.
52                 * Not sure whether to use it. */
53                JSON_Value *error = json_value_init_object();
54                json_object_set_integer(json_object(error), "code", code);
55                json_object_set_string(json_object(error), "message", msg);
56                json_object_set_value(json_object(ret), "error", error);
57        } else {
58                json_object_set_string(json_object(ret), "error", msg);
59        }
60       
61        return ret;
62}
63
64// Might have liked to have this one in the library for optional values/etc.
65static void json_array_append_string_or_null(JSON_Array *array, const char *string) {
66        if (string)
67                json_array_append_string(array, string);
68        else
69                json_array_append_null(array);
70}
71
72static void json_object_set_string_or_null(JSON_Object *object, const char *key, const char *string) {
73        if (string)
74                json_object_set_string(object, key, string);
75        else
76                json_object_set_null(object, key);
77}
78
79static JSON_Value *rpc_out_new(const char *method, JSON_Array **params_) {
80        JSON_Value *rpc = json_value_init_object();
81        json_object_set_string(json_object(rpc), "method", method);
82        json_object_set_integer(json_object(rpc), "id", next_rpc_id++);
83
84        JSON_Value *params = json_value_init_array();
85        json_object_set_value(json_object(rpc), "params", params);
86
87        if (params_)
88                *params_ = json_array(params);
89
90        return rpc;
91}
92
93#define RPC_OUT_INIT(method) \
94        JSON_Array *params; \
95        JSON_Value *rpc = rpc_out_new(method, &params);
96
97/** Sends an RPC object. Takes ownership (i.e. frees it when done). */
98static gboolean rpc_send(struct im_connection *ic, JSON_Value *rpc) {
99        struct rpc_connection *rd = ic->proto_data;
100        char *buf = json_serialize_to_string(rpc);
101        int len = strlen(buf);
102        int st;
103
104        buf = g_realloc(buf, len + 3);
105        strcpy(buf + len, "\r\n");
106        len += 2;
107
108        st = write(rd->fd, buf, len);
109        g_free(buf);
110        json_value_free(rpc);
111
112        if (st != len) {
113                if (!(ic->flags & OPT_LOGGING_OUT))
114                        imcb_log(ic, "Write error");
115                imc_logout(ic, TRUE);
116                return FALSE;
117        }
118
119        return TRUE;
120}
121
122static JSON_Value *rpc_ser_settings(set_t **set);
123
124static JSON_Value *rpc_ser_account(account_t *acc) {
125        JSON_Value *v = json_value_init_object();
126        JSON_Object *o = json_object(v);
127        json_object_set_string(o, "user", acc->user);
128        json_object_set_string(o, "pass", acc->pass);
129        if (acc->server)
130                json_object_set_string(o, "server", acc->server);
131        json_object_set_value(o, "settings", rpc_ser_settings(&acc->set));
132        return v;
133}
134
135static JSON_Value *rpc_ser_bee_user(bee_user_t *bu) {
136        JSON_Value *v = json_value_init_object();
137        JSON_Object *o = json_object(v);
138        json_object_set_string_or_null(o, "handle", bu->handle);
139        json_object_set_string_or_null(o, "fullname", bu->fullname);
140        json_object_set_string_or_null(o, "nick", bu->nick);
141        json_object_set_string_or_null(o, "group", bu->group ? bu->group->name : NULL);
142        json_object_set_integer(o, "flags", bu->flags);
143        json_object_set_string_or_null(o, "status", bu->status);
144        json_object_set_string_or_null(o, "status_msg", bu->status_msg);
145        json_object_set_integer(o, "login_time", bu->login_time);
146        json_object_set_integer(o, "idle_time", bu->idle_time);
147        return v;
148}
149
150static char *rpc_set_evaluator(set_t *set, char *value);
151
152static void rpc_init(account_t *acc) {
153        struct rpc_plugin *pd = acc->prpl->data;
154
155        JSON_O_FOREACH(json_object(pd->settings), name, value) {
156                JSON_Object *o = json_object(value);
157                char *defs = NULL;
158                JSON_Value *defv = json_object_get_value(o, "default");
159                if (json_type(defv) == JSONString)
160                        defs = g_strdup(json_string(defv));
161                else if(json_type(defv) == JSONInteger)
162                        defs = g_strdup_printf("%lld", (long long) json_integer(defv));
163                else if(json_type(defv) == JSONBoolean)
164                        defs = g_strdup(json_boolean(defv) ? "true" : "false");
165                set_t *set = set_add(&acc->set, name, defs, NULL, acc);
166                g_free(defs);
167                set->flags |= json_object_get_integer(o, "flags");
168                set->eval = rpc_set_evaluator;
169                set->eval_data = o;
170                /* eval_list turns out to be a memory leak so don't implement it
171                 * for now.
172                 * Allowing a plugin to define its own evaluator is not really
173                 * possible without having BitlBee block on it responding which
174                 * I don't want to do.
175                 * Should a module want to override a user's setting, it can
176                 * use set_setstr(). */
177        }
178
179        acc->flags |= pd->account_flags;
180}
181
182set_eval rpc_type_set_eval(const set_t *set) {
183        JSON_Object *o = set->eval_data;
184        const char *type = json_object_get_string(o, "type");
185
186        set_eval type_eval = NULL;
187        if (type == NULL) {
188                /* Try to do something sane for settings that aren't ours. */
189                if (set->eval == set_eval_int || set->eval == set_eval_bool) {
190                        type_eval = set->eval;
191                }
192        } else if (g_str_has_prefix(type, "int")) {
193                type_eval = set_eval_int;
194        } else if (g_str_has_prefix(type, "bool")) {
195                type_eval = set_eval_bool;
196        }
197
198        return type_eval;
199}
200
201static JSON_Value *set_make_json_value(set_eval type, const char *value) {
202        JSON_Value *ret;
203
204        if (value == NULL) {
205                ret = json_value_init_null();
206        } else if (type == set_eval_int) {
207                long long num = 0;
208                /* Evaluator already did validation so ignore retval. */
209                sscanf(value, "%lld", &num);
210                ret = json_value_init_integer(num);
211        } else if (type == set_eval_bool) {
212                ret = json_value_init_boolean(bool2int(value));
213        } else {
214                ret = json_value_init_string(value);
215        }
216        return ret;
217}
218
219static char *rpc_set_evaluator(set_t *set, char *value) {
220        set_eval type_eval = rpc_type_set_eval(set);
221        if (type_eval) {
222                char *new = type_eval(set, value);
223                if (new == SET_INVALID) {
224                        return SET_INVALID;
225                }
226        }
227
228        account_t *acc = set->data;
229        if (acc->ic) {
230                /* But do send RPCs to the plugin for each changed setting so
231                 * it always has up-to-date values. */
232                RPC_OUT_INIT("set_set");
233                json_array_append_string(params, set->key);
234                json_array_append_value(params, set_make_json_value(rpc_type_set_eval(set), value));
235                rpc_send(acc->ic, rpc);
236        }
237
238        return value;
239}
240
241static JSON_Value *rpc_ser_settings(set_t **set) {
242        const set_t *s;
243        JSON_Value *ret = json_value_init_object();
244       
245        for (s = *set; s; s = s->next) {
246                JSON_Value *v = set_make_json_value(rpc_type_set_eval(s), set_value(s));
247                json_object_set_value(json_object(ret), s->key, v);
248        }
249
250        return ret;
251}
252
253static gboolean rpc_login_cb(gpointer data, gint fd, b_input_condition cond);
254static gboolean rpc_in_event(gpointer data, gint fd, b_input_condition cond);
255static JSON_Value *rpc_init_isup();
256
257static void rpc_login(account_t *acc) {
258        struct im_connection *ic = imcb_new(acc);
259        struct rpc_connection *rd = ic->proto_data = g_new0(struct rpc_connection, 1);
260        struct rpc_plugin *pd = acc->prpl->data;
261        imcb_log(ic, "Logging in via RPC server");
262        rd->fd = socket(pd->addr->sa_family, SOCK_STREAM, 0);
263        sock_make_nonblocking(rd->fd);
264        if (connect(rd->fd, pd->addr, pd->addrlen) == -1) {
265                closesocket(rd->fd);
266                imcb_error(ic, "RPC server unreachable");
267                imc_logout(ic, TRUE);
268                return;
269        }
270        ic->inpa = b_input_add(rd->fd, B_EV_IO_WRITE, rpc_login_cb, ic);
271        rd->groupchats = g_hash_table_new(g_int_hash, g_int_equal);
272}
273
274static gboolean rpc_login_cb(gpointer data, gint fd, b_input_condition cond) {
275        struct im_connection *ic = data;
276        struct rpc_connection *rd = ic->proto_data;
277
278        /* Need to repeat this since each IM connection means an actual new
279         * RPC session. */
280        JSON_Value *init = rpc_init_isup();
281        if (!rpc_send(ic, init))
282                return FALSE;
283
284        RPC_OUT_INIT("login");
285        json_array_append_value(params, rpc_ser_account(ic->acc));
286        if (!rpc_send(ic, rpc))
287                return FALSE;
288
289        ic->inpa = b_input_add(rd->fd, B_EV_IO_READ, rpc_in_event, ic);
290
291        return FALSE;
292}
293
294static void rpc_keepalive(struct im_connection *ic) {
295        RPC_OUT_INIT("keepalive");
296        rpc_send(ic, rpc);
297}
298
299static void rpc_groupchat_free(struct groupchat *gc);
300
301static void rpc_logout(struct im_connection *ic) {
302        RPC_OUT_INIT("logout");
303        if (!rpc_send(ic, rpc))
304                return;
305
306        struct rpc_connection *rd = ic->proto_data;
307
308        GHashTableIter iter;
309        struct rpc_groupchat *rc;
310        g_hash_table_iter_init(&iter, rd->groupchats);
311        while (g_hash_table_iter_next(&iter, NULL, (gpointer*)&rc)) {
312                rpc_groupchat_free(rc->gc);
313        }
314
315        b_event_remove(ic->inpa);
316        closesocket(rd->fd);
317        g_free(rd->buf);
318        g_hash_table_destroy(rd->groupchats);
319        g_free(rd);
320}
321
322static int rpc_buddy_msg(struct im_connection *ic, char *to, char *message, int flags) {
323        RPC_OUT_INIT("buddy_msg");
324        json_array_append_string(params, to);
325        json_array_append_string(params, message);
326        json_array_append_integer(params, flags);
327        return rpc_send(ic, rpc);
328}
329
330static void rpc_set_away(struct im_connection *ic, char *state, char *message) {
331        RPC_OUT_INIT("set_away");
332        json_array_append_string_or_null(params, state);
333        json_array_append_string_or_null(params, message);
334        rpc_send(ic, rpc);
335}
336
337static int rpc_send_typing(struct im_connection *ic, char *who, int flags) {
338        RPC_OUT_INIT("send_typing");
339        json_array_append_string(params, who);
340        json_array_append_integer(params, flags);
341        return rpc_send(ic, rpc);
342}
343
344static void rpc_add_buddy(struct im_connection *ic, char *name, char *group) {
345        RPC_OUT_INIT("add_buddy");
346        json_array_append_string(params, name);
347        json_array_append_string_or_null(params, group);
348        rpc_send(ic, rpc);
349}
350
351static void rpc_remove_buddy(struct im_connection *ic, char *name, char *group) {
352        RPC_OUT_INIT("remove_buddy");
353        json_array_append_string(params, name);
354        json_array_append_string_or_null(params, group);
355        rpc_send(ic, rpc);
356}
357
358static void rpc_add_permit(struct im_connection *ic, char *who) {
359        RPC_OUT_INIT("add_permit");
360        json_array_append_string(params, who);
361        rpc_send(ic, rpc);
362}
363
364static void rpc_add_deny(struct im_connection *ic, char *who) {
365        RPC_OUT_INIT("add_deny");
366        json_array_append_string(params, who);
367        rpc_send(ic, rpc);
368}
369
370static void rpc_rem_permit(struct im_connection *ic, char *who) {
371        RPC_OUT_INIT("rem_permit");
372        json_array_append_string(params, who);
373        rpc_send(ic, rpc);
374}
375
376static void rpc_rem_deny(struct im_connection *ic, char *who) {
377        RPC_OUT_INIT("rem_deny");
378        json_array_append_string(params, who);
379        rpc_send(ic, rpc);
380}
381
382static void rpc_get_info(struct im_connection *ic, char *who) {
383        RPC_OUT_INIT("get_info");
384        json_array_append_string(params, who);
385        rpc_send(ic, rpc);
386}
387
388static void rpc_chat_invite(struct groupchat *gc, char *who, char *message) {
389        RPC_OUT_INIT("chat_invite");
390        struct rpc_groupchat *rc = gc->data;
391        json_array_append_integer(params, rc->id);
392        json_array_append_string(params, who);
393        json_array_append_string_or_null(params, message);
394        rpc_send(gc->ic, rpc);
395}
396
397static void rpc_chat_kick(struct groupchat *gc, char *who, const char *message) {
398        RPC_OUT_INIT("chat_kick");
399        struct rpc_groupchat *rc = gc->data;
400        json_array_append_integer(params, rc->id);
401        json_array_append_string(params, who);
402        json_array_append_string_or_null(params, message);
403        rpc_send(gc->ic, rpc);
404}
405
406static void rpc_chat_leave(struct groupchat *gc) {
407        RPC_OUT_INIT("chat_leave");
408        struct rpc_groupchat *rc = gc->data;
409        json_array_append_integer(params, rc->id);
410        rpc_send(gc->ic, rpc);
411
412        struct rpc_connection *rd = gc->ic->proto_data;
413        g_hash_table_remove(rd->groupchats, &rc->id);
414        rpc_groupchat_free(gc);
415}
416
417static void rpc_chat_msg(struct groupchat *gc, char *msg, int flags) {
418        RPC_OUT_INIT("chat_msg");       
419        struct rpc_groupchat *rc = gc->data;
420        json_array_append_integer(params, rc->id);
421        json_array_append_string(params, msg);
422        json_array_append_integer(params, flags);
423        rpc_send(gc->ic, rpc);
424}
425
426static struct rpc_groupchat *rpc_groupchat_new(struct im_connection *ic, const char *handle) {
427        struct rpc_connection *rd = ic->proto_data;
428        struct groupchat *gc = imcb_chat_new(ic, handle);
429        struct rpc_groupchat *rc = gc->data = g_new0(struct rpc_groupchat, 1);
430        rc->id = next_rpc_id++;
431        rc->gc = gc;
432        g_hash_table_insert(rd->groupchats, &rc->id, rc);
433        return rc;  // TODO: RETVAL HERE AND BELOW
434}
435
436static struct rpc_groupchat *rpc_groupchat_by_id(struct im_connection *ic, int id) {
437        struct rpc_connection *rd = ic->proto_data;
438        struct rpc_groupchat *rc = g_hash_table_lookup(rd->groupchats, &id);
439
440        return rc;
441}
442
443/* When calling this, also make sure the element gets removes from
444   rpc_connection->groupchat. This function doesn't do that because it gets
445   called from within an iterator. */
446static void rpc_groupchat_free(struct groupchat *gc) {
447        g_free(gc->data);
448        imcb_chat_free(gc);
449}
450
451/* Boilerplate for all incoming RPCs (where groupchat is identified using
452 * numeric ID). */
453#define SET_GROUPCHAT(rc) \
454        do { \
455                rc = rpc_groupchat_by_id(ic, json_array_get_integer(params, 0)); \
456                if (rc == NULL) \
457                        return jsonrpc_error(ENOENT, "No groupchat with that id."); \
458        } while (0)
459
460static struct groupchat *rpc_chat_with(struct im_connection *ic, char *who) {
461        RPC_OUT_INIT("chat_with");
462        struct rpc_groupchat *rc = rpc_groupchat_new(ic, who);
463        json_array_append_integer(params, rc->id);
464        json_array_append_string(params, who);
465        rpc_send(ic, rpc);
466
467        return rc->gc; 
468}
469
470static struct groupchat *rpc_chat_join(struct im_connection *ic, const char *room, const char *nick,
471                                       const char *password, set_t **sets) {
472        RPC_OUT_INIT("chat_join");
473        struct rpc_groupchat *rc = rpc_groupchat_new(ic, room);
474        json_array_append_integer(params, rc->id);
475        json_array_append_string(params, room);
476        json_array_append_string_or_null(params, nick);
477        json_array_append_string_or_null(params, password);
478        json_array_append_value(params, rpc_ser_settings(sets));
479        rpc_send(ic, rpc);
480
481        return rc->gc;
482}
483
484static void rpc_chat_topic(struct groupchat *gc, char *topic) {
485        RPC_OUT_INIT("chat_topic");
486        struct rpc_groupchat *rc = gc->data;
487        json_array_append_integer(params, rc->id);
488        json_array_append_string(params, topic);
489        rpc_send(gc->ic, rpc);
490}
491
492static GList *rpc_away_states(struct im_connection *ic) {
493        struct rpc_plugin *pd = ic->acc->prpl->data;
494        return pd->away_states;
495}
496
497static JSON_Value *rpc_cmd_in(struct im_connection *ic, const char *cmd, JSON_Array *params);
498
499static gboolean rpc_in(struct im_connection *ic, JSON_Object *rpc) {
500        const char *cmd = json_object_get_string(rpc, "method");
501        JSON_Value *id = json_object_get_value(rpc, "id");
502        JSON_Value *error = json_object_get_value(rpc, "error");
503        JSON_Array *params = json_object_get_array(rpc, "params");
504
505        /* Removed checks for result/error/etc. as it's all too free-form and
506         * at least for now this code is not going to care about retvals as
507         * they come in late anyway. */
508        if (!id) {
509                imcb_log(ic, "Received invalid JSON-RPC object.");
510                imc_logout(ic, TRUE);
511                return FALSE;
512        }
513
514        if (cmd) {
515                JSON_Value *resp = rpc_cmd_in(ic, cmd, params);
516                if (!resp) {
517                        resp = json_value_init_object();
518                        json_object_set_boolean(json_object(resp), "result", TRUE);
519                }
520                json_object_set_value(json_object(resp), "id", json_value_deep_copy(id));
521                return rpc_send(ic, resp);
522        } else if (error && json_type(error) != JSONNull) {
523                char *error_str = json_serialize_to_string(error);
524                /* Maybe sanitise/truncate? Though really that should be done at
525                 * a different layer. */
526                imcb_error(ic, "RPC Error: %s", error_str);
527                g_free(error_str);
528        }
529
530        return TRUE;
531}
532
533static gboolean rpc_in_event(gpointer data, gint fd, b_input_condition cond) {
534        struct im_connection *ic = data;
535        struct rpc_connection *rd = ic->proto_data;
536        char buf[2048];
537        int st;
538
539        while ((st = read(rd->fd, buf, sizeof(buf))) > 0) {
540                rd->buf = g_realloc(rd->buf, rd->buflen + st + 1);
541                memcpy(rd->buf + rd->buflen, buf, st);
542                rd->buflen += st;
543        }
544
545        if (st == 0 || (st == -1 && !(sockerr_again() || errno == EAGAIN))) {
546                imcb_log(ic, "Lost RPC connection");
547                imc_logout(ic, TRUE);
548                return FALSE;
549        }
550        rd->buf[rd->buflen] = '\0';
551
552        JSON_Value *parsed;
553        const char *end;
554        while ((parsed = json_parse_first(rd->buf, &end))) {
555                st = rpc_in(ic, json_object(parsed));
556                json_value_free(parsed);
557
558                if (!st)
559                        return FALSE;
560
561                if (end == rd->buf + rd->buflen) {
562                        g_free(rd->buf);
563                        rd->buf = NULL;
564                } else {
565                        int newlen = rd->buf + rd->buflen - end;
566                        char new[newlen];
567                        memcpy(new, end, newlen);
568                        rd->buf = g_realloc(rd->buf, newlen + 1);
569                        memcpy(rd->buf, new, newlen);
570                        rd->buflen = newlen;
571                        rd->buf[rd->buflen] = '\0';
572                }
573        }
574
575        return TRUE;
576}
577
578static JSON_Value *rpc_imcb_log(struct im_connection *ic, void *func_, JSON_Array *params) {
579        void (*func)(struct im_connection*, const char*, ...) = func_;
580        func(ic, "%s", json_array_get_string(params, 0));
581        return NULL;
582}
583
584static JSON_Value *rpc_imcb_connected(struct im_connection *ic, void *func_, JSON_Array *params) {
585        void (*func)(struct im_connection*) = func_;
586        func(ic);
587        return NULL;
588}
589
590static JSON_Value *rpc_imc_logout(struct im_connection *ic, void *func_, JSON_Array *params) {
591        void (*func)(struct im_connection*, gboolean) = func_;
592        func(ic, json_array_get_boolean(params, 0));
593        return NULL;
594}
595
596static JSON_Value *rpc_imcb_add_buddy(struct im_connection *ic, void *func_, JSON_Array *params) {
597        void (*func)(struct im_connection*, const char*, const char*) = func_;
598        func(ic, json_array_get_string(params, 0), json_array_get_string(params, 1));
599        return NULL;
600}
601
602static JSON_Value *rpc_imcb_buddy_status(struct im_connection *ic, void *func_, JSON_Array *params) {
603        void (*func)(struct im_connection*, const char*, int, const char*, const char*) = func_;
604        func(ic, json_array_get_string(params, 0), json_array_get_integer(params, 1),
605                 json_array_get_string(params, 2), json_array_get_string(params, 3));
606        return NULL;
607}
608
609static JSON_Value *rpc_imcb_buddy_times(struct im_connection *ic, void *func_, JSON_Array *params) {
610        void (*func)(struct im_connection*, const char*, int, int) = func_;
611        func(ic, json_array_get_string(params, 0), json_array_get_integer(params, 1),
612                 json_array_get_integer(params, 2));
613        return NULL;
614}
615
616static JSON_Value *rpc_imcb_buddy_msg(struct im_connection *ic, void *func_, JSON_Array *params) {
617        void (*func)(struct im_connection*, const char*, const char*, int, int) = func_;
618        func(ic, json_array_get_string(params, 0), json_array_get_string(params, 1),
619                 json_array_get_integer(params, 2), json_array_get_integer(params, 3));
620        return NULL;
621}
622
623static JSON_Value *rpc_imcb_buddy_typing(struct im_connection *ic, void *func_, JSON_Array *params) {
624        void (*func)(struct im_connection*, const char*, int) = func_;
625        func(ic, (char*) json_array_get_string(params, 0), json_array_get_integer(params, 1));
626        return NULL;
627}
628
629static JSON_Value *rpc_imcb_get_local_contacts(struct im_connection *ic, void *func_, JSON_Array *params) {
630        JSON_Value *resp = json_value_init_object();
631        JSON_Value *arr = json_value_init_array();
632        GSList *contacts = imcb_get_local_contacts(ic);
633        GSList *c;
634        for (c = contacts; c; c = c->next) {
635                json_array_append_string(json_array(arr), (const char*) c->data);
636        }
637        g_slist_free(contacts);
638        json_object_set_value(json_object(resp), "result", arr);
639        return resp;
640}
641
642static JSON_Value *rpc_imcb_chat_new(struct im_connection *ic, void *func_, JSON_Array *params) {
643        struct rpc_groupchat *rc = rpc_groupchat_new(ic, json_array_get_string(params, 0));
644        JSON_Value *resp = json_value_init_object();
645        json_object_set_integer(json_object(resp), "result", rc->id);
646        return resp;
647}
648
649static JSON_Value *rpc_imcb_chat_name_hint(struct im_connection *ic, void *func_, JSON_Array *params) {
650        void (*func)(struct groupchat*, const char*) = func_;
651        struct rpc_groupchat *rc;
652        SET_GROUPCHAT(rc);
653        func(rc->gc, json_array_get_string(params, 1));
654        return NULL;
655}
656
657static JSON_Value *rpc_imcb_chat_msg(struct im_connection *ic, void *func_, JSON_Array *params) {
658        void (*func)(struct groupchat*, const char*, const char*, guint32, time_t) = func_;
659        struct rpc_groupchat *rc;
660        SET_GROUPCHAT(rc);
661        func(rc->gc, json_array_get_string(params, 1), json_array_get_string(params, 2),
662             json_array_get_integer(params, 3), json_array_get_integer(params, 4));
663        return NULL;
664}
665
666static JSON_Value *rpc_imcb_chat_log(struct im_connection *ic, void *func_, JSON_Array *params) {
667        void (*func)(struct groupchat*, const char*, ...) = func_;
668        struct rpc_groupchat *rc;
669        SET_GROUPCHAT(rc);
670        func(rc->gc, "%s", json_array_get_string(params, 1));
671        return NULL;
672}
673
674static JSON_Value *rpc_imcb_chat_topic(struct im_connection *ic, void *func_, JSON_Array *params) {
675        void (*func)(struct groupchat*, const char*, const char*, time_t) = func_;
676        struct rpc_groupchat *rc;
677        SET_GROUPCHAT(rc);
678        func(rc->gc, json_array_get_string(params, 1), json_array_get_string(params, 2),
679             json_array_get_integer(params, 3));
680        return NULL;
681}
682
683static JSON_Value *rpc_imcb_chat_remove_buddy(struct im_connection *ic, void *func_, JSON_Array *params) {
684        void (*func)(struct groupchat*, const char*, const char*) = func_;
685        struct rpc_groupchat *rc;
686        SET_GROUPCHAT(rc);
687        func(rc->gc, json_array_get_string(params, 1), json_array_get_string(params, 2));
688        return NULL;
689}
690
691static JSON_Value *rpc_imcb_chat_invite(struct im_connection *ic, void *func_, JSON_Array *params) {
692        void (*func)(struct groupchat*, const char*, const char*, const char*) = func_;
693        struct rpc_groupchat *rc;
694        SET_GROUPCHAT(rc);
695        func(rc->gc, json_array_get_string(params, 1), json_array_get_string(params, 2),
696             json_array_get_string(params, 3));
697        return NULL;
698}
699
700static JSON_Value *rpc_set_getstr(struct im_connection *ic, void *func_, JSON_Array *params) {
701        char *rets = set_getstr(&ic->acc->set, json_array_get_string(params, 0));
702        JSON_Value *ret = json_value_init_object();
703        if (rets)
704                json_object_set_string(json_object(ret), "result", rets);
705        else
706                json_object_set_null(json_object(ret), "result");
707        return ret;
708}
709
710static JSON_Value *rpc_set_setstr(struct im_connection *ic, void *func_, JSON_Array *params) {
711        /* Sadly use of const is very poor in BitlBee. :-( */
712        char *newval = g_strdup(json_array_get_string(params, 1));
713        set_setstr(&ic->acc->set, json_array_get_string(params, 0), newval);
714        g_free(newval);
715        return rpc_set_getstr(ic, func_, params);
716}
717
718static JSON_Value *rpc_set_reset(struct im_connection *ic, void *func_, JSON_Array *params) {
719        set_reset(&ic->acc->set, json_array_get_string(params, 0));
720        return rpc_set_getstr(ic, func_, params);
721}
722
723static JSON_Value *rpc_bee_user_by_handle(struct im_connection *ic, void *func_, JSON_Array *params) {
724        bee_user_t *bu = bee_user_by_handle(ic->bee, ic, json_array_get_string(params, 0));
725        JSON_Value *ret = json_value_init_object();
726        if (bu)
727                json_object_set_value(json_object(ret), "result", rpc_ser_bee_user(bu));
728        else
729                json_object_set_value(json_object(ret), "error", jsonrpc_error(ENOENT, "Contact not found"));
730        return ret;
731}
732
733struct rpc_in_method {
734        char *name;
735        void *func;
736        JSON_Value* (* wfunc) (struct im_connection *ic, void *cmd, JSON_Array *params);
737        char args[8];
738};
739
740static const struct rpc_in_method methods[] = {
741        /* All these RPCs are equivalent of BitlBee C functions but with the
742         * struct im_connection* removed as this is in the object context. */
743        { "imcb_log", imcb_log, rpc_imcb_log, "s" },
744        { "imcb_error", imcb_error, rpc_imcb_log, "s" },
745        { "imcb_connected", imcb_connected, rpc_imcb_connected, "" },
746        { "imc_logout", imc_logout, rpc_imc_logout, "b" },
747        { "imcb_add_buddy", imcb_add_buddy, rpc_imcb_add_buddy, "ss" },
748        { "imcb_remove_buddy", imcb_remove_buddy, rpc_imcb_add_buddy, "ss" },
749        { "imcb_rename_buddy", imcb_rename_buddy, rpc_imcb_add_buddy, "ss" },
750        { "imcb_buddy_nick_hint", imcb_buddy_nick_hint, rpc_imcb_add_buddy, "ss" },
751        { "imcb_buddy_status", imcb_buddy_status, rpc_imcb_buddy_status, "siss" },
752        { "imcb_buddy_status_msg", imcb_buddy_status_msg, rpc_imcb_add_buddy, "ss" },
753        { "imcb_buddy_times", imcb_buddy_times, rpc_imcb_buddy_times, "sii" },
754        { "imcb_buddy_msg", imcb_buddy_msg, rpc_imcb_buddy_msg, "ssii" },
755        { "imcb_buddy_typing", imcb_buddy_typing, rpc_imcb_buddy_typing, "si" },
756        { "imcb_get_local_contacts", NULL, rpc_imcb_get_local_contacts, "" },
757        { "imcb_chat_new", NULL, rpc_imcb_chat_new, "s" },
758       
759        /* RPCs below are equivalent, but with the struct groupchat* replaced
760         * with the numeric id of the chat. */
761        { "imcb_chat_name_hint", imcb_chat_name_hint, rpc_imcb_chat_name_hint, "is" },
762        { "imcb_chat_msg", imcb_chat_msg, rpc_imcb_chat_msg, "issii" },
763        { "imcb_chat_log", imcb_chat_log, rpc_imcb_chat_log, "is" },
764        { "imcb_chat_topic", imcb_chat_topic, rpc_imcb_chat_topic, "issi" },
765        { "imcb_chat_add_buddy", imcb_chat_add_buddy, rpc_imcb_chat_name_hint, "is" },
766        { "imcb_chat_remove_buddy", imcb_chat_remove_buddy, rpc_imcb_chat_remove_buddy, "iss" },
767        { "imcb_chat_invite", imcb_chat_invite, rpc_imcb_chat_invite, "isss" },
768
769        /* These are not imcb* functions but should still be exported. */
770        /* Setting functions. Starting with just providing access to account
771         * settings. See later whether access to chat/chan settings is necessary.
772         * All of these will return the (new) value of given setting. */
773        { "set_getstr", NULL, rpc_set_getstr, "s" },
774        { "set_setstr", NULL, rpc_set_setstr, "ss" },
775        { "set_reset", NULL, rpc_set_reset, "s" },
776       
777        { "bee_user_by_handle", NULL, rpc_bee_user_by_handle, "s" },
778
779        { NULL },
780};
781
782static JSON_Value *rpc_cmd_in(struct im_connection *ic, const char *cmd, JSON_Array *params) {
783        int i;
784
785        for (i = 0; methods[i].name; i++) {
786                if (strcmp(cmd, methods[i].name) == 0) {
787                        if (json_array_get_count(params) != strlen(methods[i].args)) {
788                                imcb_error(ic, "Invalid argument count to method %s: %d, wanted %zd", cmd, (int) json_array_get_count(params), strlen(methods[i].args));
789                                return jsonrpc_error(E2BIG, "Invalid integer of arguments");
790                        }
791                        int j;
792                        for (j = 0; methods[i].args[j]; j++) {
793                                JSON_Value_Type type = json_value_get_type(json_array_get_value(params, j));
794                                gboolean ok = FALSE;
795                                switch (methods[i].args[j]) {
796                                case 's':
797                                        ok = type == JSONString || type == JSONNull;
798                                        break;
799                                case 'i':
800                                        ok = type == JSONInteger;
801                                        break;
802                                case 'o':
803                                        ok = type == JSONObject;
804                                        break;
805                                case 'a':
806                                        ok = type == JSONArray;
807                                        break;
808                                case 'b':
809                                        ok = type == JSONBoolean;
810                                        break;
811                                }
812                                if (!ok) {
813                                        // This error sucks, but just get your types right!
814                                        imcb_error(ic, "Invalid argument type, %s parameter %d: %d not %c", cmd, j, type, methods[i].args[j]);
815                                        return jsonrpc_error(EINVAL, "Invalid argument type");
816                                }
817                        }
818                        return methods[i].wfunc(ic, methods[i].func, params);
819                }
820        }
821        return jsonrpc_error(ENOSYS, "Function not implemented");
822}
823
824#define RPC_ADD_FUNC(func) \
825        ret->func = rpc_ ## func
826#define RPC_ADD_OPT_FUNC(func) \
827        if (g_hash_table_lookup(methods, #func)) \
828                RPC_ADD_FUNC(func)
829
830static JSON_Value *rpc_init_isup() {
831        int i;
832
833        RPC_OUT_INIT("init");
834        JSON_Value *d = json_value_init_object();
835        json_object_set_string(json_object(d), "version_str", BITLBEE_VERSION);
836        json_object_set_integer(json_object(d), "version", BITLBEE_VERSION_CODE);
837       
838        JSON_Value *ml = json_value_init_array();
839        for (i = 0; methods[i].name; i++) {
840                json_array_append_string(json_array(ml), methods[i].name);
841        }
842        json_object_set_value(json_object(d), "method_list", ml);
843        json_array_append_value(params, d);
844
845        return rpc;
846}
847
848gboolean rpc_initmodule_sock(struct sockaddr *address, socklen_t addrlen) {
849        int st, fd, i;
850
851        fd = socket(address->sa_family, SOCK_STREAM, 0);
852        if (fd == -1 || connect(fd, address, addrlen) == -1) {
853                log_message(LOGLVL_WARNING, "Failed to connect to RPC server: %s", strerror(errno));
854                if (fd != -1)
855                        closesocket(fd);
856                return FALSE;
857        }
858
859        JSON_Value *rpc = rpc_init_isup();
860        char *s = json_serialize_to_string(rpc);
861        json_value_free(rpc);
862
863        int len = strlen(s);
864        s = g_realloc(s, len + 3);
865        strcpy(s + len, "\r\n");
866        len += 2;
867
868        if ((st = write(fd, s, len)) != len) {
869                log_message(LOGLVL_WARNING, "Error while writing to RPC server: %s", strerror(errno));
870                return FALSE;
871        }
872        g_free(s);
873
874        char *resp = NULL;
875        int buflen = 4096, resplen = 0;
876        JSON_Value *parsed;
877        do {
878                fd_set rfds;
879                struct timeval to;
880
881                FD_ZERO(&rfds);
882                FD_SET(fd, &rfds);
883                to.tv_sec = 1;
884                to.tv_usec = 0;
885                st = select(fd + 1, &rfds, NULL, NULL, &to);
886
887                if (st == 0) {
888                        log_message(LOGLVL_WARNING, "Error while reading from RPC server: %s", strerror(errno));
889                        closesocket(fd);
890                        return FALSE;
891                }
892               
893                if (resplen >= buflen)
894                        buflen *= 2;
895                resp = g_realloc(resp, buflen + 1);
896                st = read(fd, resp + resplen, buflen - resplen);
897                if (st == -1) {
898                        if (sockerr_again())
899                                continue;
900                        log_message(LOGLVL_WARNING, "Error while reading from RPC server: %s", strerror(errno));
901                        closesocket(fd);
902                        return FALSE;
903                }
904                resplen += st;
905                resp[resplen] = '\0';
906        }
907        while (!(parsed = json_parse_string(resp)));
908        closesocket(fd);
909
910        JSON_Object *isup = json_object_get_object(json_object(parsed), "result");
911        if (isup == NULL) {
912                log_message(LOGLVL_WARNING, "Error while parsing RPC server response");
913                return FALSE;
914        }
915
916        struct prpl *ret = g_new0(struct prpl, 1);
917        struct rpc_plugin *proto_data = g_new0(struct rpc_plugin, 1);
918        proto_data->addr = g_memdup(address, addrlen);
919        proto_data->addrlen = addrlen;
920        ret->name = g_strdup(json_object_get_string(isup, "name"));
921        ret->data = proto_data;
922
923        proto_data->account_flags = json_object_get_integer(isup, "account_flags");
924
925        /* Keep a full copy of the settings list, we can only use it when we
926         * have an account to work on. */
927        JSON_Value *settings = json_object_get_value(isup, "settings");
928        if (json_type(settings) == JSONObject)
929                proto_data->settings = json_value_deep_copy(settings);
930
931        JSON_Array *aways_a = json_object_get_array(isup, "away_state_list");
932        for (i = 0; i < json_array_get_count(aways_a); ++i) {
933                JSON_Value *state = json_array_get_value(aways_a, i);
934                if (json_type(state) == JSONString)
935                        proto_data->away_states =
936                                g_list_append(proto_data->away_states,
937                                              g_strdup(json_string(state)));
938        }
939
940        JSON_Array *methods_a = json_object_get_array(isup, "method_list");
941        GHashTable *methods = g_hash_table_new(g_str_hash, g_str_equal);
942        for (i = 0; i < json_array_get_count(methods_a); i++) {
943                gpointer func = (void*) json_array_get_string(methods_a, i);
944                g_hash_table_replace(methods, func, func);
945        }
946
947        ret->init = rpc_init;
948        RPC_ADD_FUNC(login);
949        RPC_ADD_OPT_FUNC(keepalive);
950        RPC_ADD_FUNC(logout);
951        RPC_ADD_FUNC(buddy_msg);
952        RPC_ADD_OPT_FUNC(set_away);
953        RPC_ADD_OPT_FUNC(send_typing);
954        RPC_ADD_OPT_FUNC(add_buddy);
955        RPC_ADD_OPT_FUNC(remove_buddy);
956        RPC_ADD_OPT_FUNC(add_permit);
957        RPC_ADD_OPT_FUNC(add_deny);
958        RPC_ADD_OPT_FUNC(rem_permit);
959        RPC_ADD_OPT_FUNC(rem_deny);
960        RPC_ADD_OPT_FUNC(get_info);
961        RPC_ADD_OPT_FUNC(chat_invite);
962        RPC_ADD_OPT_FUNC(chat_kick);
963        RPC_ADD_OPT_FUNC(chat_leave);
964        RPC_ADD_OPT_FUNC(chat_msg);
965        RPC_ADD_OPT_FUNC(chat_with);
966        RPC_ADD_OPT_FUNC(chat_join);
967        RPC_ADD_OPT_FUNC(chat_topic);
968        if (proto_data->away_states)
969                ret->away_states = rpc_away_states;
970       
971        g_hash_table_destroy(methods);
972
973        // TODO: Property for a few standard nickcmp implementations.
974        ret->handle_cmp = g_ascii_strcasecmp;
975       
976        register_protocol(ret);
977
978        return TRUE;
979}
980
981#define PDIR "/tmp/rpcplugins"
982
983/* YA RLY :-/ */
984#ifndef UNIX_PATH_MAX
985struct sockaddr_un sizecheck;
986#define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
987#endif
988
989void rpc_initmodule() {
990        DIR *pdir = opendir(PDIR);
991        struct dirent *de;
992
993        if (!pdir)
994                return;
995
996        while ((de = readdir(pdir))) {
997                if (de->d_type != DT_SOCK && de->d_type != DT_UNKNOWN)
998                        continue;
999
1000                char *fn = g_build_filename(PDIR, de->d_name, NULL);
1001                struct sockaddr_un su;
1002
1003                strncpy(su.sun_path, fn, UNIX_PATH_MAX);
1004
1005#if 0
1006                struct stat fdata;
1007                if (stat(fn, &fdata) == -1) {
1008                        log_message(LOGLVL_WARNING, "Could not stat %s: %s", fn, strerror(errno));
1009                        g_free(fn);
1010                        continue;
1011                }
1012                /* For now just skip anything that is not a Unix domain socket. */
1013                if (!S_ISSOCK(fdata.st_mode))
1014                        continue;
1015#endif
1016
1017                su.sun_path[UNIX_PATH_MAX-1] = '\0';
1018                su.sun_family = AF_UNIX;
1019                gboolean st = rpc_initmodule_sock((struct sockaddr*) &su, sizeof(su));
1020                g_free(fn);
1021                if (!st)
1022                        log_message(LOGLVL_WARNING, "Failed to register protocol %s", fn);
1023                /* Idea: Also support textfiles containing a host:port tuple to
1024                 * connect to. Not that remote RPC'ing would be a great idea,
1025                 * but maybe some jsonrpc libs don't support Unix domain sockets. */
1026        }
1027        closedir(pdir);
1028}
1029
Note: See TracBrowser for help on using the repository browser.