mirrors
/
sway
mirror of https://github.com/swaywm/sway.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rework get_clipboard implementation

This commit is contained in:
nyorain 2017-07-07 21:51:34 +02:00
parent 42547cafb6
commit c0f2acce4e
8 changed files with 455 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
completions/zsh/_swaymsg
View File

@ -21,6 +21,7 @@ types=(
'get_marks'
'get_bar_config'
'get_version'
'get_clipboard'
)
_arguments -s \

2
include/sway/config.h
View File

@ -235,7 +235,7 @@ enum ipc_feature {
IPC_FEATURE_EVENT_WINDOW = 2048,
IPC_FEATURE_EVENT_BINDING = 4096,
IPC_FEATURE_EVENT_INPUT = 8192,
IPC_FEATURE_GET_CLIPBOARD = 16384,
IPC_FEATURE_GET_CLIPBOARD = 16384,
IPC_FEATURE_ALL_COMMANDS = 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 16384,
IPC_FEATURE_ALL_EVENTS = 256 | 512 | 1024 | 2048 | 4096 | 8192,

5
include/util.h
View File

@ -3,6 +3,7 @@
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <xkbcommon/xkbcommon.h>
/**
@ -57,4 +58,8 @@ uint32_t parse_color(const char *color);
* to a dangling symlink, NULL is returned.
*/
char* resolve_path(const char* path);
char *b64_encode(const char* binaryData, size_t len, size_t *flen);
unsigned char *b64_decode(const char *ascii, size_t len, size_t *flen);
#endif

3
sway/CMakeLists.txt
View File

@ -19,6 +19,7 @@ file(GLOB cmds
add_executable(sway
commands.c
${cmds}
base64.c
config.c
container.c
criteria.c
@ -35,7 +36,7 @@ add_executable(sway
output.c
workspace.c
border.c
security.c
security.c
)
add_definitions(

221
sway/base64.c Normal file
View File

@ -0,0 +1,221 @@
/*
* Adapted from https://github.com/littlstar/b64.c
* License under the MIT License:
* Copyright (c) 2014 Little Star Media, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <ctype.h>
#include <stdlib.h>
#include "util.h"
static const char b64_table[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
char *b64_encode(const char *src, size_t len, size_t *flen) {
int i = 0;
int j = 0;
char *enc = NULL;
size_t size = len * 4 / 3;
size_t idx = 0;
unsigned char buf[4];
char tmp[3];
// alloc
enc = (char *) malloc(size + 1);
if (NULL == enc) { return NULL; }
// parse until end of source
while (len--) {
// read up to 3 bytes at a time into `tmp'
tmp[i++] = *(src++);
// if 3 bytes read then encode into `buf'
if (3 == i) {
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
// shouldn't really happen
if (idx + 4 > size) {
size += 16;
enc = (char *) realloc(enc, size + 1);
}
for (i = 0; i < 4; ++i) {
enc[idx++] = b64_table[buf[i]];
}
// reset index
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 3 times
for (j = i; j < 3; ++j) {
tmp[j] = '\0';
}
// perform same codec as above
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
// perform same write to `enc` with new allocation
size_t delta = (i > 3 ? 0 : 3 - i) + (j > i + 1 ? 0 : i + 1 - j);
if (idx + delta > size) {
size += delta;
enc = (char *) realloc(enc, size + 1);
}
for (j = 0; (j < i + 1); ++j) {
enc[idx++] = b64_table[buf[j]];
}
// while there is still a remainder
// append `=' to `enc'
while ((i++ < 3)) {
enc[idx++] = '=';
}
}
enc[idx] = '\0';
if (flen)
*flen = size;
return enc;
}
unsigned char *b64_decode(const char *src, size_t len, size_t *decsize) {
int i = 0;
int j = 0;
int l = 0;
// max size estimate
size_t size = len * 3 / 4;
size_t idx = 0;
unsigned char *dec = NULL;
unsigned char buf[3];
unsigned char tmp[4];
// alloc
dec = (unsigned char *) malloc(size + 1);
if (NULL == dec) { return NULL; }
// parse until end of source
while (len--) {
if (isspace(src[j])) { j++; continue; }
// break if char is `=' or not base64 char
if ('=' == src[j]) { break; }
if (!(isalnum(src[j]) || '+' == src[j] || '/' == src[j])) { break; }
// read up to 4 bytes at a time into `tmp'
tmp[i++] = src[j++];
// if 4 bytes read then decode into `buf'
if (4 == i) {
// translate values in `tmp' from table
for (i = 0; i < 4; ++i) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[i] == b64_table[l]) {
tmp[i] = l;
break;
}
}
}
// decode
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// unlikely
if (idx + 3 > size) {
size += 16;
dec = (unsigned char *) realloc(dec, size + 1);
}
if (dec != NULL){
for (i = 0; i < 3; ++i) {
dec[idx++] = buf[i];
}
} else {
return NULL;
}
// reset
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 4 times
for (j = i; j < 4; ++j) {
tmp[j] = '\0';
}
// translate remainder
for (j = 0; j < 4; ++j) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[j] == b64_table[l]) {
tmp[j] = l;
break;
}
}
}
// decode remainder
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// write remainer decoded buffer to `dec'
if (idx + (i - 1) > size) {
size += 16;
dec = (unsigned char *) realloc(dec, size + 1);
}
if (dec != NULL){
for (j = 0; (j < i - 1); ++j) {
dec[idx++] = buf[j];
}
} else {
return NULL;
}
}
dec[idx] = '\0';
// Return back the size of decoded string if demanded.
if (decsize != NULL) {
*decsize = size;
}
return dec;
}

279
sway/ipc-server.c
View File

@ -1,5 +1,6 @@
// See https://i3wm.org/docs/ipc.html for protocol information
#define _XOPEN_SOURCE 700
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
@ -56,8 +57,11 @@ struct get_pixels_request {
};
struct get_clipboard_request {
struct ipc_client *client;
struct wlc_event_source *event_source;
struct ipc_client *client;
json_object *json;
struct wlc_event_source *event_source;
char *type;
unsigned int *pending;
};
struct sockaddr_un *ipc_user_sockaddr(void);
@ -327,44 +331,201 @@ void ipc_get_pixels(wlc_handle output) {
ipc_get_pixel_requests = unhandled;
}
static int ipc_selection_data_cb(int fd, uint32_t mask, void *data)
{
static int ipc_selection_data_cb(int fd, uint32_t mask, void *data) {
assert(data);
struct get_clipboard_request *req = (struct get_clipboard_request*) data;
struct get_clipboard_request *req = (struct get_clipboard_request *)data;
if (mask & WLC_EVENT_ERROR) {
sway_log(L_ERROR, "Selection data fd error");
const char *error = "{ \"success\": false, \"error\": "
"\"Could not receive text data from clipboard\" }";
ipc_send_reply(req->client, error, (uint32_t)strlen(error));
goto cleanup;
}
if (mask & WLC_EVENT_READABLE) {
char buf[512];
int ret = read(fd, buf, 511);
if (ret < 0) {
sway_log_errno(L_ERROR, "Reading from selection data fd failed");
const char *error = "{ \"success\": false, \"error\": "
"\"Could not receive text data from clipboard\" }";
ipc_send_reply(req->client, error, (uint32_t)strlen(error));
goto cleanup;
if (mask & WLC_EVENT_READABLE || true) {
static const int step_size = 512;
char *data = NULL;
int ret = 0;
int current = 0;
// read data as long as there is data avilable
// grow the buffer step_size in every iteration
do {
if (data == NULL) {
data = malloc(step_size);
} else {
data = realloc(data, current + step_size);
}
ret = read(fd, data + current, step_size - 1);
if (ret < 0) {
sway_log_errno(L_ERROR, "Reading from selection data fd failed");
goto cleanup;
}
current += ret;
} while (ret == step_size - 1);
data[current] = '\0';
if (strncmp(req->type, "text/", 5) == 0) {
json_object_object_add(req->json, req->type,
json_object_new_string(data));
} else {
size_t outlen;
char *b64 = b64_encode(data, current, &outlen);
json_object_object_add(req->json, req->type,
json_object_new_string(b64));
free(b64);
}
buf[ret] = '\0';
json_object *obj = json_object_new_object();
json_object_object_add(obj, "success", json_object_new_boolean(true));
json_object_object_add(obj, "content", json_object_new_string(buf));
const char *str = json_object_to_json_string(obj);
ipc_send_reply(req->client, str, (uint32_t)strlen(str));
json_object_put(obj);
free(data);
} else {
return 0; // TODO
}
cleanup:
wlc_event_source_remove(req->event_source);
close(fd);
free(req);
return 0;
close(fd);
if (--(*req->pending) == 0) {
const char *str = json_object_to_json_string(req->json);
ipc_send_reply(req->client, str, (uint32_t)strlen(str));
json_object_put(req->json);
}
free(req->type);
wlc_event_source_remove(req->event_source);
free(req);
return 0;
}
// greedy wildcard (only "*") matching
bool mime_type_matches(const char *mime_type, const char *pattern) {
const char* wildcard = NULL;
while (*mime_type && *pattern) {
if (*pattern == '*' && !wildcard) {
wildcard = pattern;
++pattern;
}
if (*mime_type != *pattern) {
if (!wildcard)
return false;
pattern = wildcard;
++mime_type;
continue;
}
++mime_type;
++pattern;
}
while (*pattern == '*') {
++pattern;
}
return (*mime_type == *pattern);
}
void ipc_get_clipboard(struct ipc_client *client, char *buf) {
static const char *error_json = "{ \"success\": false, \"error\": "
"\"Failed to retrieve clipboard data\" }";
size_t size;
const char **types = wlc_get_selection_types(&size);
if (client->payload_length == 0) {
json_object *obj = json_object_new_array();
for (size_t i = 0; i < size; ++i) {
json_object_array_add(obj, json_object_new_string(types[i]));
}
const char *str = json_object_to_json_string(obj);
ipc_send_reply(client, str, strlen(str));
json_object_put(obj);
return;
}
unescape_string(buf);
strip_quotes(buf);
list_t *requested = split_string(buf, " ");
json_object *json = json_object_new_object();
unsigned int *pending = malloc(sizeof(unsigned int));
*pending = 0;
for (size_t l = 0; l < (size_t) requested->length; ++l) {
const char *pattern = requested->items[l];
bool found = false;
for (size_t i = 0; i < size; ++i) {
if (mime_type_matches(types[i], pattern)) {
found = true;
struct get_clipboard_request *req = malloc(sizeof(*req));
if (!req) {
sway_log(L_ERROR, "Cannot allocate get_clipboard_request");
goto data_error;
}
int pipes[2];
if (pipe(pipes) == -1) {
sway_log_errno(L_ERROR, "pipe call failed");
free(req);
goto data_error;
}
fcntl(pipes[0], F_SETFD, FD_CLOEXEC | O_NONBLOCK);
fcntl(pipes[1], F_SETFD, FD_CLOEXEC | O_NONBLOCK);
if (!wlc_get_selection_data(types[i], pipes[1])) {
close(pipes[0]);
close(pipes[1]);
free(req);
sway_log(L_ERROR, "wlc_get_selection_data failed");
goto data_error;
}
(*pending)++;
req->client = client;
req->type = strdup(types[i]);
req->json = json;
req->pending = pending;
req->event_source = wlc_event_loop_add_fd(pipes[0],
WLC_EVENT_READABLE | WLC_EVENT_ERROR | WLC_EVENT_HANGUP,
&ipc_selection_data_cb, req);
// NOTE: remove this goto to enable retrieving multiple
// targets at once. The whole implementation is already
// made for it. The only reason it was disabled
// at the time of writing is that neither wlc's xselection
// implementation nor (apparently) gtk on wayland supports
// multiple send requests at the same time which makes
// every request except the last one fail (and therefore
// return empty data)
goto cleanup;
}
}
if (!found) {
sway_log(L_INFO, "Invalid clipboard type %s requested", pattern);
}
}
if (*pending == 0) {
static const char *empty = "[]";
ipc_send_reply(client, empty, (uint32_t)strlen(empty));
free(json);
free(pending);
}
goto cleanup;
data_error:
ipc_send_reply(client, error_json, (uint32_t)strlen(error_json));
free(json);
free(pending);
cleanup:
list_free(requested);
free(types);
}
void ipc_client_handle_command(struct ipc_client *client) {
@ -610,69 +771,13 @@ void ipc_client_handle_command(struct ipc_client *client) {
goto exit_cleanup;
}
case IPC_GET_CLIPBOARD:
{
case IPC_GET_CLIPBOARD:
{
if (!(client->security_policy & IPC_FEATURE_GET_CLIPBOARD)) {
goto exit_denied;
}
size_t size;
const char **types = wlc_get_selection_types(&size);
const char *type = NULL;
if (types == NULL || size == 0) {
const char *error = "{ \"success\": false, \"error\": "
"\"Empty clipboard\" }";
ipc_send_reply(client, error, (uint32_t)strlen(error));
goto exit_cleanup;
}
for (size_t i = 0; i < size; ++i) {
if (strcmp(types[i], "text/plain;charset=utf-8") == 0
|| strcmp(types[i], "text/plain") == 0) {
type = types[i];
break;
}
}
if (type) {
struct get_clipboard_request *req = malloc(sizeof(*req));
if (!req) {
sway_log(L_ERROR, "Unable to allocate get_clipboard_request");
goto clipboard_error;
}
int pipes[2];
if (pipe(pipes) == -1) {
sway_log_errno(L_ERROR, "pipe call failed");
free(req);
goto clipboard_error;
}
fcntl(pipes[0], F_SETFD, FD_CLOEXEC | O_NONBLOCK);
fcntl(pipes[1], F_SETFD, FD_CLOEXEC | O_NONBLOCK);
if (!wlc_get_selection_data(type, pipes[1])) {
close(pipes[0]);
close(pipes[1]);
free(req);
sway_log(L_ERROR, "wlc_get_selection_data failed");
goto clipboard_error;
}
req->client = client;
req->event_source = wlc_event_loop_add_fd(pipes[0],
WLC_EVENT_READABLE | WLC_EVENT_ERROR | WLC_EVENT_HANGUP,
&ipc_selection_data_cb, req);
free(types);
goto exit_cleanup;
}
clipboard_error:
sway_log(L_INFO, "Clipboard has to text data");
const char *error = "{ \"success\": false, \"error\": "
"\"Could not receive text data from clipboard\" }";
ipc_send_reply(client, error, (uint32_t)strlen(error));
free(types);
ipc_get_clipboard(client, buf);
goto exit_cleanup;
}

41
swaymsg/main.c
View File

@ -19,15 +19,17 @@ void sway_terminate(int exit_code) {
exit(exit_code);
}
static void pretty_print_cmd(json_object *r) {
bool _success;
static bool success(json_object *r, bool fallback) {
json_object *success;
if (!json_object_object_get_ex(r, "success", &success)) {
_success = true;
return fallback;
} else {
_success = json_object_get_boolean(success);
return json_object_get_boolean(success);
}
if (!_success) {
}
static void pretty_print_cmd(json_object *r) {
if (!success(r, true)) {
json_object *error;
if (!json_object_object_get_ex(r, "error", &error)) {
printf("An unknkown error occured");
@ -145,15 +147,23 @@ static void pretty_print_version(json_object *v) {
}
static void pretty_print_clipboard(json_object *v) {
bool _success;
json_object *success;
json_object_object_get_ex(v, "success", &success);
_success = json_object_get_boolean(success);
if (_success) {
json_object *ver;
json_object_object_get_ex(v, "content", &ver);
printf("%s\n", json_object_get_string(ver));
if (success(v, true)) {
if (json_object_is_type(v, json_type_array)) {
for (int i = 0; i < json_object_array_length(v); ++i) {
json_object *o = json_object_array_get_idx(v, i);
printf("%s\n", json_object_get_string(o));
}
} else {
// NOTE: could be extended to print all received types
// instead just the first one when sways ipc server
// supports it
struct json_object_iterator iter = json_object_iter_begin(v);
struct json_object_iterator end = json_object_iter_end(v);
if (!json_object_iter_equal(&iter, &end)) {
printf("%s\n", json_object_get_string(
json_object_iter_peek_value(&iter)));
}
}
}
}
@ -310,6 +320,9 @@ int main(int argc, char **argv) {
printf("%s\n", resp);
ret = 1;
} else {
if (!success(obj, true)) {
ret = 1;
}
if (raw) {
printf("%s\n", json_object_to_json_string_ext(obj,
JSON_C_TO_STRING_PRETTY | JSON_C_TO_STRING_SPACED));

6
swaymsg/swaymsg.1.txt
View File

@ -65,6 +65,12 @@ IPC Message Types
*get_version*::
Get JSON-encoded version information for the running instance of sway.
*get_clipboard*::
Get JSON-encoded information about the clipboard.
Returns the current clipboard mime-types if called without
arguments, otherwise returns the clipboard data in the requested
formats. Encodes the data using base64 for non-text mime types.
Authors
-------