pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-06-25 12:26:40 +02:00
Code Activity
Files
e050eebb2e935e69226863a2a6877fa0e63f6cfa
weechat/src/plugins/relay/api/relay-api-protocol.c
T

1211 lines
38 KiB
C
Raw Blame History

/*
* relay-api-protocol.c - API protocol for relay to client
*
* Copyright (C) 2023-2024 Sébastien Helleu <flashcode@flashtux.org>
*
* This file is part of WeeChat, the extensible chat client.
*
* WeeChat is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* WeeChat is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WeeChat. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <cjson/cJSON.h>
#include "../../weechat-plugin.h"
#include "../relay.h"
#include "../relay-auth.h"
#include "../relay-buffer.h"
#include "../relay-client.h"
#include "../relay-config.h"
#include "../relay-http.h"
#include "../relay-websocket.h"
#include "relay-api.h"
#include "relay-api-msg.h"
#include "relay-api-protocol.h"
int relay_api_protocol_command_delay = 1; /* delay to execute command */
/*
* Searches buffer by id or full name.
*/
struct t_gui_buffer *
relay_api_protocol_search_buffer_id_name (const char *string)
{
struct t_gui_buffer *ptr_buffer;
ptr_buffer = weechat_buffer_search ("==id", string);
if (ptr_buffer)
return ptr_buffer;
return weechat_buffer_search ("==", string);
}
/*
* Callback for signals "buffer_*".
*/
int
relay_api_protocol_signal_buffer_cb (const void *pointer, void *data,
const char *signal,
const char *type_data,
void *signal_data)
{
struct t_relay_client *ptr_client;
struct t_gui_buffer *ptr_buffer;
struct t_gui_line *ptr_line;
struct t_gui_line_data *ptr_line_data;
cJSON *json;
long lines, lines_free;
long long buffer_id;
int nicks;
const char *ptr_id;
char *error;
/* make C compiler happy */
(void) data;
(void) type_data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
if ((strcmp (signal, "buffer_opened") == 0)
|| (strcmp (signal, "buffer_type_changed") == 0)
|| (strcmp (signal, "buffer_moved") == 0)
|| (strcmp (signal, "buffer_merged") == 0)
|| (strcmp (signal, "buffer_unmerged") == 0)
|| (strcmp (signal, "buffer_hidden") == 0)
|| (strcmp (signal, "buffer_unhidden") == 0)
|| (strcmp (signal, "buffer_renamed") == 0)
|| (strcmp (signal, "buffer_title_changed") == 0)
|| (strcmp (signal, "buffer_modes_changed") == 0)
|| (strcmp (signal, "buffer_time_for_each_line_changed") == 0)
|| (strncmp (signal, "buffer_localvar_", 16) == 0)
|| (strcmp (signal, "buffer_cleared") == 0)
|| (strcmp (signal, "buffer_closing") == 0)
|| (strcmp (signal, "buffer_closed") == 0))
{
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer || relay_buffer_is_relay (ptr_buffer))
return WEECHAT_RC_OK;
if (strcmp (signal, "buffer_closed") == 0)
{
/*
* when a buffer is closed, we send the buffer id
* with body type "buffer" and empty body
*/
buffer_id = -1;
ptr_id = weechat_hashtable_get (
RELAY_API_DATA(ptr_client, buffers_closing),
ptr_buffer);
if (ptr_id)
{
error = NULL;
buffer_id = strtoll (ptr_id, &error, 10);
if (!error || error[0])
buffer_id = -1;
weechat_hashtable_remove (
RELAY_API_DATA(ptr_client, buffers_closing),
ptr_buffer);
}
relay_api_msg_send_event (ptr_client, signal, buffer_id, NULL, NULL);
return WEECHAT_RC_OK;
}
if (strcmp (signal, "buffer_closing") == 0)
{
/*
* when a buffer is closing, we save its id in the hashtable
* "buffers_closing", it will be used when sending the event
* "buffer_closed"
*/
weechat_hashtable_set (RELAY_API_DATA(ptr_client, buffers_closing),
ptr_buffer,
weechat_buffer_get_string (ptr_buffer, "id"));
}
/* we get all lines and nicks when a buffer is opened, otherwise none */
if (strcmp (signal, "buffer_opened") == 0)
{
lines = LONG_MAX;
lines_free = LONG_MAX;
nicks = 1;
}
else
{
lines = 0;
lines_free = 0;
nicks = 0;
}
/* build body with buffer info */
json = relay_api_msg_buffer_to_json (
ptr_buffer, lines, lines_free, nicks,
RELAY_API_DATA(ptr_client, sync_colors));
/* send to client */
if (json)
{
buffer_id = relay_api_get_buffer_id (ptr_buffer);
relay_api_msg_send_event (ptr_client, signal, buffer_id, "buffer", json);
cJSON_Delete (json);
}
}
else if (strcmp (signal, "buffer_line_added") == 0)
{
ptr_line = (struct t_gui_line *)signal_data;
if (!ptr_line)
return WEECHAT_RC_OK;
ptr_line_data = weechat_hdata_pointer (relay_hdata_line,
ptr_line, "data");
if (!ptr_line_data)
return WEECHAT_RC_OK;
ptr_buffer = weechat_hdata_pointer (relay_hdata_line_data,
ptr_line_data, "buffer");
if (!ptr_buffer || relay_buffer_is_relay (ptr_buffer))
return WEECHAT_RC_OK;
json = relay_api_msg_line_data_to_json (
ptr_line_data, RELAY_API_DATA(ptr_client, sync_colors));
if (json)
{
buffer_id = relay_api_get_buffer_id (ptr_buffer);
relay_api_msg_send_event (ptr_client, signal, buffer_id,
"line", json);
cJSON_Delete (json);
}
}
else if (strcmp (signal, "buffer_line_data_changed") == 0)
{
ptr_line_data = (struct t_gui_line_data *)signal_data;
if (!ptr_line_data)
return WEECHAT_RC_OK;
ptr_buffer = weechat_hdata_pointer (relay_hdata_line_data,
ptr_line_data, "buffer");
if (!ptr_buffer || relay_buffer_is_relay (ptr_buffer))
return WEECHAT_RC_OK;
json = relay_api_msg_line_data_to_json (
ptr_line_data, RELAY_API_DATA(ptr_client, sync_colors));
if (json)
{
buffer_id = relay_api_get_buffer_id (ptr_buffer);
relay_api_msg_send_event (ptr_client, signal, buffer_id,
"line", json);
cJSON_Delete (json);
}
}
return WEECHAT_RC_OK;
}
/*
* Callback for hsignals "nicklist_*".
*/
int
relay_api_protocol_hsignal_nicklist_cb (const void *pointer, void *data,
const char *signal,
struct t_hashtable *hashtable)
{
struct t_relay_client *ptr_client;
struct t_gui_buffer *ptr_buffer;
struct t_gui_nick_group *ptr_parent_group, *ptr_group;
struct t_gui_nick *ptr_nick;
cJSON *json;
long long buffer_id;
/* make C compiler happy */
(void) data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
ptr_buffer = weechat_hashtable_get (hashtable, "buffer");
ptr_parent_group = weechat_hashtable_get (hashtable, "parent_group");
ptr_group = weechat_hashtable_get (hashtable, "group");
ptr_nick = weechat_hashtable_get (hashtable, "nick");
/* if there is no parent group (for example "root" group), ignore the signal */
if (!ptr_parent_group)
return WEECHAT_RC_OK;
if (!ptr_buffer || relay_buffer_is_relay (ptr_buffer))
return WEECHAT_RC_OK;
buffer_id = relay_api_get_buffer_id (ptr_buffer);
if ((strcmp (signal, "nicklist_group_added") == 0)
|| (strcmp (signal, "nicklist_group_changed") == 0)
|| (strcmp (signal, "nicklist_group_removing") == 0))
{
json = relay_api_msg_nick_group_to_json (
ptr_group,
RELAY_API_DATA(ptr_client, sync_colors));
if (json)
{
relay_api_msg_send_event (ptr_client, signal, buffer_id,
"nick_group", json);
cJSON_Delete (json);
}
}
else if ((strcmp (signal, "nicklist_nick_added") == 0)
|| (strcmp (signal, "nicklist_nick_changed") == 0)
|| (strcmp (signal, "nicklist_nick_removing") == 0))
{
json = relay_api_msg_nick_to_json (
ptr_nick,
RELAY_API_DATA(ptr_client, sync_colors));
if (json)
{
relay_api_msg_send_event (ptr_client, signal, buffer_id,
"nick", json);
cJSON_Delete (json);
}
}
return WEECHAT_RC_OK;
}
/*
* Callback for signal "input_text_changed".
*/
int
relay_api_protocol_signal_input_cb (const void *pointer, void *data,
const char *signal,
const char *type_data,
void *signal_data)
{
struct t_relay_client *ptr_client;
struct t_gui_buffer *ptr_buffer;
cJSON *json;
long long buffer_id;
/* make C compiler happy */
(void) data;
(void) type_data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
ptr_buffer = (struct t_gui_buffer *)signal_data;
if (!ptr_buffer || relay_buffer_is_relay (ptr_buffer))
return WEECHAT_RC_OK;
json = relay_api_msg_buffer_to_json (
ptr_buffer, 0, 0, 0,
RELAY_API_DATA(ptr_client, sync_colors));
if (json)
{
buffer_id = relay_api_get_buffer_id (ptr_buffer);
relay_api_msg_send_event (ptr_client, signal, buffer_id, "buffer", json);
cJSON_Delete (json);
}
return WEECHAT_RC_OK;
}
/*
* Callback for signals "upgrade*".
*/
int
relay_api_protocol_signal_upgrade_cb (const void *pointer, void *data,
const char *signal,
const char *type_data,
void *signal_data)
{
struct t_relay_client *ptr_client;
/* make C compiler happy */
(void) data;
(void) type_data;
(void) signal_data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
if ((strcmp (signal, "upgrade") == 0)
|| (strcmp (signal, "upgrade_ended") == 0)
|| (strcmp (signal, "quit") == 0))
{
relay_api_msg_send_event (ptr_client, signal, -1, NULL, NULL);
}
return WEECHAT_RC_OK;
}
/*
* Callback for the OPTIONS preflight request.
*
* Routes:
* OPTIONS /api/xxx
*/
RELAY_API_PROTOCOL_CALLBACK(options)
{
relay_api_msg_send_json (
client,
RELAY_HTTP_204_NO_CONTENT,
"Access-Control-Allow-Methods: GET, POST, PUT, DELETE\r\n"
"Access-Control-Allow-Headers: origin, content-type, accept, authorization",
NULL, /* body_type */
NULL); /* json_body */
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "handshake".
*
* Routes:
* POST /api/handshake
*/
RELAY_API_PROTOCOL_CALLBACK(handshake)
{
cJSON *json_body, *json_algos, *json_algo, *json;
const char *ptr_algo;
char *totp_secret;
int hash_algo_found, index_hash_algo;
hash_algo_found = -1;
json_body = cJSON_Parse (client->http_req->body);
if (json_body)
{
json_algos = cJSON_GetObjectItem (json_body, "password_hash_algo");
if (json_algos)
{
cJSON_ArrayForEach (json_algo, json_algos)
{
ptr_algo = (cJSON_IsString (json_algo)) ?
cJSON_GetStringValue (json_algo) : NULL;
if (ptr_algo)
{
index_hash_algo = relay_auth_password_hash_algo_search (ptr_algo);
if ((index_hash_algo >= 0) && (index_hash_algo > hash_algo_found))
{
if (weechat_string_match_list (
relay_auth_password_hash_algo_name[index_hash_algo],
(const char **)relay_config_network_password_hash_algo_list,
1))
{
hash_algo_found = index_hash_algo;
}
}
}
}
}
}
json = cJSON_CreateObject ();
if (!json)
{
if (json_body)
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_MEMORY;
}
totp_secret = weechat_string_eval_expression (
weechat_config_string (relay_config_network_totp_secret),
NULL, NULL, NULL);
cJSON_AddItemToObject (
json,
"password_hash_algo",
(hash_algo_found >= 0) ?
cJSON_CreateString (relay_auth_password_hash_algo_name[hash_algo_found]) :
cJSON_CreateNull ());
cJSON_AddItemToObject (
json,
"password_hash_iterations",
cJSON_CreateNumber (
weechat_config_integer (relay_config_network_password_hash_iterations)));
cJSON_AddItemToObject (json, "totp",
cJSON_CreateBool ((totp_secret && totp_secret[0]) ? 1 : 0));
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL, "handshake", json);
free (totp_secret);
cJSON_Delete (json);
if (json_body)
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "version".
*
* Routes:
* GET /api/version
*/
RELAY_API_PROTOCOL_CALLBACK(version)
{
cJSON *json;
char *version, *error;
long number;
json = cJSON_CreateObject ();
if (!json)
return RELAY_API_PROTOCOL_RC_MEMORY;
version = weechat_info_get ("version", NULL);
cJSON_AddItemToObject (json,
"weechat_version", cJSON_CreateString (version));
free (version);
version = weechat_info_get ("version_git", NULL);
cJSON_AddItemToObject (json,
"weechat_version_git", cJSON_CreateString (version));
free (version);
version = weechat_info_get ("version_number", NULL);
error = NULL;
number = strtol (version, &error, 10);
if (error && !error[0])
{
cJSON_AddItemToObject (json,
"weechat_version_number",
cJSON_CreateNumber (number));
}
free (version);
cJSON_AddItemToObject (json, "relay_api_version",
cJSON_CreateString (RELAY_API_VERSION_STR));
cJSON_AddItemToObject (json,
"relay_api_version_number",
cJSON_CreateNumber (RELAY_API_VERSION_NUMBER));
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL, "version", json);
cJSON_Delete (json);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "buffers".
*
* Routes:
* GET /api/buffers
* GET /api/buffers/{buffer_id}
* GET /api/buffers/{buffer_id}/lines
* GET /api/buffers/{buffer_id}/lines/{line_id}
* GET /api/buffers/{buffer_id}/nicks
* GET /api/buffers/{buffer_name}
* GET /api/buffers/{buffer_name}/lines
* GET /api/buffers/{buffer_name}/lines/{line_id}
* GET /api/buffers/{buffer_name}/nicks
*/
RELAY_API_PROTOCOL_CALLBACK(buffers)
{
cJSON *json;
struct t_gui_buffer *ptr_buffer;
struct t_gui_line *ptr_line;
struct t_gui_line_data *ptr_line_data;
long lines, lines_free, line_id;
int nicks;
char *error;
enum t_relay_api_colors colors;
json = NULL;
ptr_buffer = NULL;
if (client->http_req->num_path_items > 2)
{
ptr_buffer = relay_api_protocol_search_buffer_id_name (
client->http_req->path_items[2]);
if (!ptr_buffer)
{
relay_api_msg_send_error_json (client, RELAY_HTTP_404_NOT_FOUND, NULL,
"Buffer \"%s\" not found",
client->http_req->path_items[2]);
return RELAY_API_PROTOCOL_RC_OK;
}
}
nicks = relay_http_get_param_boolean (client->http_req, "nicks", 0);
colors = relay_api_search_colors (
weechat_hashtable_get (client->http_req->params, "colors"));
if (client->http_req->num_path_items > 3)
{
/* sub-resource of buffers */
if (strcmp (client->http_req->path_items[3], "lines") == 0)
{
if (client->http_req->num_path_items > 4)
{
line_id = strtol (client->http_req->path_items[4], &error, 10);
ptr_line = (error && !error[0]) ?
weechat_line_search_by_id (ptr_buffer, line_id) : NULL;
ptr_line_data = (ptr_line) ?
weechat_hdata_pointer (relay_hdata_line, ptr_line, "data") : NULL;
if (!ptr_line_data)
{
relay_api_msg_send_error_json (client, RELAY_HTTP_404_NOT_FOUND, NULL,
"Line \"%s\" not found in buffer \"%s\"",
client->http_req->path_items[4],
client->http_req->path_items[2]);
return RELAY_API_PROTOCOL_RC_OK;
}
json = relay_api_msg_line_data_to_json (ptr_line_data, colors);
if (json)
{
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL,
"line", json);
}
}
else
{
lines = relay_http_get_param_long (client->http_req, "lines", LONG_MAX);
json = relay_api_msg_lines_to_json (ptr_buffer, lines, colors);
if (json)
{
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL,
"lines", json);
}
}
}
else if (strcmp (client->http_req->path_items[3], "nicks") == 0)
{
json = relay_api_msg_nick_group_to_json (
weechat_hdata_pointer (relay_hdata_buffer,
ptr_buffer, "nicklist_root"),
colors);
if (json)
{
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL,
"nick_group", json);
}
}
else
{
relay_api_msg_send_error_json (
client, RELAY_HTTP_404_NOT_FOUND, NULL,
"Sub-resource of buffers not found: \"%s\"",
client->http_req->path_items[3]);
return RELAY_API_PROTOCOL_RC_OK;
}
}
else
{
lines = relay_http_get_param_long (client->http_req, "lines", 0L);
lines_free = relay_http_get_param_long (client->http_req,
"lines_free",
(lines == 0) ? 0 : LONG_MAX);
if (ptr_buffer)
{
json = relay_api_msg_buffer_to_json (ptr_buffer, lines, lines_free,
nicks, colors);
if (json)
{
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL,
"buffer", json);
}
}
else
{
json = cJSON_CreateArray ();
if (!json)
return RELAY_API_PROTOCOL_RC_MEMORY;
ptr_buffer = weechat_hdata_get_list (relay_hdata_buffer,
"gui_buffers");
while (ptr_buffer)
{
cJSON_AddItemToArray (
json,
relay_api_msg_buffer_to_json (ptr_buffer, lines, lines_free,
nicks, colors));
ptr_buffer = weechat_hdata_move (relay_hdata_buffer, ptr_buffer, 1);
}
if (json)
{
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL,
"buffers", json);
}
}
}
if (!json)
return RELAY_API_PROTOCOL_RC_MEMORY;
cJSON_Delete (json);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "hotlist".
*
* Routes:
* GET /api/hotlist
*/
RELAY_API_PROTOCOL_CALLBACK(hotlist)
{
cJSON *json;
struct t_gui_hotlist *ptr_hotlist;
json = cJSON_CreateArray ();
if (!json)
return RELAY_API_PROTOCOL_RC_MEMORY;
ptr_hotlist = weechat_hdata_get_list (relay_hdata_hotlist, "gui_hotlist");
while (ptr_hotlist)
{
cJSON_AddItemToArray (
json,
relay_api_msg_hotlist_to_json (ptr_hotlist));
ptr_hotlist = weechat_hdata_move (relay_hdata_hotlist, ptr_hotlist, 1);
}
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL, "hotlist", json);
cJSON_Delete (json);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "input".
*
* Routes:
* POST /api/input
*/
RELAY_API_PROTOCOL_CALLBACK(input)
{
cJSON *json_body, *json_buffer_id, *json_buffer_name, *json_command;
const char *ptr_buffer_name, *ptr_command, *ptr_commands;
char str_id[64];
struct t_gui_buffer *ptr_buffer;
struct t_hashtable *options;
char str_delay[32];
json_body = cJSON_Parse (client->http_req->body);
if (!json_body)
return RELAY_API_PROTOCOL_RC_BAD_REQUEST;
ptr_buffer = NULL;
json_buffer_id = cJSON_GetObjectItem (json_body, "buffer_id");
if (json_buffer_id)
{
if (cJSON_IsNumber (json_buffer_id))
{
snprintf (str_id, sizeof (str_id),
"%lld", (long long)cJSON_GetNumberValue (json_buffer_id));
ptr_buffer = weechat_buffer_search ("==id", str_id);
if (!ptr_buffer)
{
relay_api_msg_send_error_json (
client,
RELAY_HTTP_404_NOT_FOUND, NULL,
"Buffer \"%lld\" not found",
(long long)cJSON_GetNumberValue (json_buffer_id));
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_OK;
}
}
}
else
{
json_buffer_name = cJSON_GetObjectItem (json_body, "buffer_name");
if (json_buffer_name)
{
if (cJSON_IsString (json_buffer_name))
{
ptr_buffer_name = cJSON_GetStringValue (json_buffer_name);
ptr_buffer = weechat_buffer_search ("==", ptr_buffer_name);
if (!ptr_buffer)
{
relay_api_msg_send_error_json (
client,
RELAY_HTTP_404_NOT_FOUND, NULL,
"Buffer \"%s\" not found",
ptr_buffer_name);
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_OK;
}
}
}
else
{
ptr_buffer = weechat_buffer_search_main ();
}
}
if (!ptr_buffer)
{
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_BAD_REQUEST;
}
json_command = cJSON_GetObjectItem (json_body, "command");
if (!json_command || !cJSON_IsString (json_command))
{
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_BAD_REQUEST;
}
ptr_command = cJSON_GetStringValue (json_command);
if (!ptr_command)
{
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_BAD_REQUEST;
}
options = weechat_hashtable_new (8,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING,
NULL, NULL);
if (!options)
{
relay_api_msg_send_error_json (client,
RELAY_HTTP_503_SERVICE_UNAVAILABLE,
NULL,
RELAY_HTTP_ERROR_OUT_OF_MEMORY);
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_OK;
}
ptr_commands = weechat_config_string (relay_config_network_commands);
if (ptr_commands && ptr_commands[0])
weechat_hashtable_set (options, "commands", ptr_commands);
/*
* delay the execution of command after we go back in the WeeChat
* main loop (some commands like /upgrade executed now can cause
* a crash)
*/
snprintf (str_delay, sizeof (str_delay),
"%d", relay_api_protocol_command_delay);
weechat_hashtable_set (options, "delay", str_delay);
/* execute the command, with the delay */
weechat_command_options (ptr_buffer, ptr_command, options);
weechat_hashtable_free (options);
cJSON_Delete (json_body);
relay_api_msg_send_json (client, RELAY_HTTP_204_NO_CONTENT, NULL, NULL, NULL);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "ping".
*
* Routes:
* POST /api/ping
*/
RELAY_API_PROTOCOL_CALLBACK(ping)
{
cJSON *json, *json_body, *json_data;
const char *ptr_data;
ptr_data = NULL;
json_body = cJSON_Parse (client->http_req->body);
if (json_body)
{
json_data = cJSON_GetObjectItem (json_body, "data");
if (json_data && cJSON_IsString (json_data))
ptr_data = cJSON_GetStringValue (json_data);
}
if (ptr_data)
{
json = cJSON_CreateObject ();
if (!json)
{
cJSON_Delete (json_body);
return RELAY_API_PROTOCOL_RC_MEMORY;
}
cJSON_AddItemToObject (json, "data",
cJSON_CreateString ((ptr_data) ? ptr_data : ""));
relay_api_msg_send_json (client, RELAY_HTTP_200_OK, NULL, "ping", json);
cJSON_Delete (json);
cJSON_Delete (json_body);
}
else
{
relay_api_msg_send_json (client, RELAY_HTTP_204_NO_CONTENT, NULL, NULL, NULL);
}
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Callback for resource "sync".
*
* Routes:
* POST /api/sync
*/
RELAY_API_PROTOCOL_CALLBACK(sync)
{
cJSON *json_body, *json_sync, *json_nicks, *json_input, *json_colors;
if (client->websocket != RELAY_CLIENT_WEBSOCKET_READY)
{
relay_api_msg_send_error_json (
client,
RELAY_HTTP_403_FORBIDDEN,
NULL,
"Sync resource is available only with a websocket connection");
return RELAY_API_PROTOCOL_RC_OK;
}
RELAY_API_DATA(client, sync_enabled) = 1;
RELAY_API_DATA(client, sync_nicks) = 1;
RELAY_API_DATA(client, sync_input) = 1;
RELAY_API_DATA(client, sync_colors) = RELAY_API_COLORS_ANSI;
json_body = cJSON_Parse (client->http_req->body);
if (json_body)
{
json_sync = cJSON_GetObjectItem (json_body, "sync");
if (json_sync && cJSON_IsBool (json_sync))
RELAY_API_DATA(client, sync_enabled) = (cJSON_IsTrue (json_sync)) ? 1 : 0;
json_nicks = cJSON_GetObjectItem (json_body, "nicks");
if (json_nicks && cJSON_IsBool (json_nicks))
RELAY_API_DATA(client, sync_nicks) = (cJSON_IsTrue (json_nicks)) ? 1 : 0;
json_input = cJSON_GetObjectItem (json_body, "input");
if (json_input && cJSON_IsBool (json_input))
RELAY_API_DATA(client, sync_input) = (cJSON_IsTrue (json_input)) ? 1 : 0;
json_colors = cJSON_GetObjectItem (json_body, "colors");
if (json_colors && cJSON_IsString (json_colors))
RELAY_API_DATA(client, sync_colors) = relay_api_search_colors (
cJSON_GetStringValue (json_colors));
}
if (RELAY_API_DATA(client, sync_enabled))
relay_api_hook_signals (client);
else
relay_api_unhook_signals (client);
relay_api_msg_send_json (client, RELAY_HTTP_204_NO_CONTENT, NULL, NULL, NULL);
return RELAY_API_PROTOCOL_RC_OK;
}
/*
* Reads one request from client.
*/
void
relay_api_protocol_recv_json_request (struct t_relay_client *client,
cJSON *json)
{
cJSON *json_request, *json_request_id, *json_body;
const char *ptr_request_id;
char *string_body;
int length;
relay_http_request_reinit (client->http_req);
json_request_id = cJSON_GetObjectItem (json, "request_id");
if (json_request_id
&& !cJSON_IsString (json_request_id)
&& !cJSON_IsNull (json_request_id))
{
goto error;
}
ptr_request_id = (json_request_id) ?
cJSON_GetStringValue (json_request_id) : NULL;
free (client->http_req->id);
client->http_req->id = NULL;
client->http_req->id = (ptr_request_id) ? strdup (ptr_request_id) : NULL;
json_request = cJSON_GetObjectItem (json, "request");
if (!json_request || !cJSON_IsString (json_request))
goto error;
if (!relay_http_parse_method_path (client->http_req,
cJSON_GetStringValue (json_request)))
{
goto error;
}
json_body = cJSON_GetObjectItem (json, "body");
if (json_body)
{
if (!cJSON_IsObject (json_body))
goto error;
string_body = cJSON_PrintUnformatted (json_body);
if (string_body)
{
length = strlen (string_body);
client->http_req->body = malloc (length + 1);
if (client->http_req->body)
{
memcpy (client->http_req->body, string_body, length + 1);
client->http_req->content_length = length;
client->http_req->body_size = length;
}
free (string_body);
}
}
relay_api_protocol_recv_http (client);
return;
error:
relay_api_msg_send_json (client, RELAY_HTTP_400_BAD_REQUEST,
NULL, NULL, NULL);
}
/*
* Reads JSON string from a client: when connected via websocket (persistent
* connection), the client is sending JSON data as a request, which is
* converted to HTTP request by this function, before calling the function
* relay_api_protocol_recv_http.
*
* Example of JSON received:
*
* {
* "request": "POST /api/input",
* "body": {
* "buffer_name": "irc.libera.#weechat",
* "command": "hello!"
* }
* }
*
* It is converted to an HTTP request which could have been:
*
* POST /api/input HTTP/1.1
* Content-Length: 58
* Content-Type: application/json
*
* {"buffer_name": "irc.libera.#weechat","command": "hello!"}
*
* The JSON can also be an array of requests, for example to fetch all buffers
* data and synchronize at same time:
*
* [
* {
* "request": "GET /api/buffers?lines=-1000&nicks=true&colors=weechat",
* "request_id": "initial_sync"
* },
* {
* "request": "POST /api/sync",
* "body": {
* "colors":"weechat"
* }
* }
* ]
*/
void
relay_api_protocol_recv_json (struct t_relay_client *client, const char *json)
{
cJSON *json_obj, *json_request;
json_obj = cJSON_Parse (json);
if (!json_obj)
{
relay_api_msg_send_json (client, RELAY_HTTP_400_BAD_REQUEST,
NULL, NULL, NULL);
return;
}
if (cJSON_IsArray (json_obj))
{
cJSON_ArrayForEach (json_request, json_obj)
{
relay_api_protocol_recv_json_request (client, json_request);
}
}
else
{
relay_api_protocol_recv_json_request (client, json_obj);
}
cJSON_Delete (json_obj);
}
/*
* Reads a HTTP request from a client.
*/
void
relay_api_protocol_recv_http (struct t_relay_client *client)
{
int i, num_args;
enum t_relay_api_protocol_rc return_code;
struct t_relay_api_protocol_cb protocol_cb[] = {
/* method, resource, auth, min args, max args, callback */
{ "OPTIONS", "*", 0, 0, -1, &relay_api_protocol_cb_options },
{ "POST", "handshake", 0, 0, 0, &relay_api_protocol_cb_handshake },
{ "GET", "version", 1, 0, 0, &relay_api_protocol_cb_version },
{ "GET", "buffers", 1, 0, 3, &relay_api_protocol_cb_buffers },
{ "GET", "hotlist", 1, 0, 3, &relay_api_protocol_cb_hotlist },
{ "POST", "input", 1, 0, 0, &relay_api_protocol_cb_input },
{ "POST", "ping", 1, 0, 0, &relay_api_protocol_cb_ping },
{ "POST", "sync", 1, 0, 0, &relay_api_protocol_cb_sync },
{ NULL, NULL, 0, 0, 0, NULL },
};
if (!client->http_req || RELAY_STATUS_HAS_ENDED(client->status))
return;
/* display debug message */
if (weechat_relay_plugin->debug >= 2)
{
weechat_printf (NULL,
"%s: recv from client %s%s%s: \"%s %s\", body: \"%s\"",
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT,
client->http_req->method,
client->http_req->path,
client->http_req->body);
}
if ((client->http_req->num_path_items < 2) || !client->http_req->path_items
|| !client->http_req->path_items[0] || !client->http_req->path_items[1])
{
goto error_not_found;
}
if (strcmp (client->http_req->path_items[0], "api") != 0)
goto error_not_found;
num_args = client->http_req->num_path_items - 2;
for (i = 0; protocol_cb[i].resource; i++)
{
if (strcmp (protocol_cb[i].method, client->http_req->method) != 0)
continue;
if ((strcmp (protocol_cb[i].resource, "*") != 0)
&& (strcmp (protocol_cb[i].resource, client->http_req->path_items[1]) != 0))
continue;
if (protocol_cb[i].auth_required
&& (client->status != RELAY_STATUS_CONNECTED)
&& !relay_http_check_auth (client))
{
relay_client_set_status (client, RELAY_STATUS_AUTH_FAILED);
return;
}
if (num_args < protocol_cb[i].min_args)
{
if (weechat_relay_plugin->debug >= 1)
{
weechat_printf (
NULL,
_("%s%s: too few arguments received from client "
"%s%s%s for resource \"%s\" "
"(received: %d arguments, expected: at least %d)"),
weechat_prefix ("error"),
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT,
client->http_req->path_items[1],
num_args,
protocol_cb[i].min_args);
}
goto error_not_found;
}
if ((protocol_cb[i].max_args >= 0)
&& (num_args > protocol_cb[i].max_args))
{
if (weechat_relay_plugin->debug >= 1)
{
weechat_printf (
NULL,
_("%s%s: too many arguments received from client "
"%s%s%s for resource \"%s\" "
"(received: %d arguments, expected: at most %d)"),
weechat_prefix ("error"),
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT,
client->http_req->path_items[1],
num_args,
protocol_cb[i].max_args);
}
goto error_not_found;
}
return_code = (protocol_cb[i].cmd_function) (client);
switch (return_code)
{
case RELAY_API_PROTOCOL_RC_OK:
return;
case RELAY_API_PROTOCOL_RC_BAD_REQUEST:
goto error_bad_request;
break;
case RELAY_API_PROTOCOL_RC_MEMORY:
goto error_memory;
break;
case RELAY_NUM_API_PROTOCOL_RC:
break;
}
}
goto error_not_found;
error_bad_request:
relay_api_msg_send_json (client, RELAY_HTTP_400_BAD_REQUEST, NULL, NULL, NULL);
goto error;
error_not_found:
relay_api_msg_send_json (client, RELAY_HTTP_404_NOT_FOUND, NULL, NULL, NULL);
goto error;
error_memory:
relay_api_msg_send_error_json (client, RELAY_HTTP_503_SERVICE_UNAVAILABLE,
NULL, RELAY_HTTP_ERROR_OUT_OF_MEMORY);
goto error;
error:
if (weechat_relay_plugin->debug >= 1)
{
weechat_printf (NULL,
_("%s%s: failed to execute route \"%s %s\" "
"for client %s%s%s"),
weechat_prefix ("error"),
RELAY_PLUGIN_NAME,
client->http_req->method,
client->http_req->path,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT);
}
}
View Git Blame Copy Permalink