PolytreeDE
/
picom
mirror of https://github.com/yshui/picom.git
1
0
Fork 0
Code Releases Activity
picom/src/c2.c

2122 lines
58 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: MIT
/*
* Compton - a compositor for X11
*
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
*
* Copyright (c) 2011-2013, Christopher Jeffrey
* See LICENSE-mit for more information.
*
*/
#include <assert.h>
#include <ctype.h>
#include <fnmatch.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <uthash.h>
// libpcre
#ifdef CONFIG_REGEX_PCRE
#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
#endif
#include <X11/Xlib.h>
#include <xcb/xcb.h>
#include "atom.h"
#include "common.h"
#include "compiler.h"
#include "config.h"
#include "log.h"
#include "string_utils.h"
#include "test.h"
#include "utils.h"
#include "win.h"
#include "x.h"
#include "c2.h"
#pragma GCC diagnostic error "-Wunused-parameter"
#define C2_MAX_LEVELS 10
typedef struct _c2_b c2_b_t;
typedef struct _c2_l c2_l_t;
/// Pointer to a condition tree.
typedef struct {
bool isbranch : 1;
union {
c2_b_t *b;
c2_l_t *l;
};
} c2_ptr_t;
struct c2_tracked_property_key {
xcb_atom_t property;
bool is_on_client;
char padding[3];
};
static_assert(sizeof(struct c2_tracked_property_key) == 8, "Padding bytes in "
"c2_tracked_property_key");
struct c2_tracked_property {
UT_hash_handle hh;
struct c2_tracked_property_key key;
unsigned int id;
/// Highest indices of this property that
/// are tracked. -1 mean all indices are tracked.
int max_indices;
};
struct c2_state {
struct c2_tracked_property *tracked_properties;
struct atom *atoms;
xcb_get_property_cookie_t *cookies;
uint32_t *propert_lengths;
};
// TODO(yshui) this has some overlap with winprop_t, consider merging them.
struct c2_property_value {
union {
struct {
char *string;
};
struct {
int64_t numbers[4];
};
struct {
int64_t *array;
unsigned int capacity;
};
};
/// Number of items if the property is a number type,
/// or number of bytes in the string if the property is a string type.
uint32_t length;
enum {
C2_PROPERTY_TYPE_STRING,
C2_PROPERTY_TYPE_NUMBER,
C2_PROPERTY_TYPE_ATOM,
} type;
bool valid;
bool needs_update;
};
/// Initializer for c2_ptr_t.
#define C2_PTR_INIT \
{ .isbranch = false, .l = NULL, }
static const c2_ptr_t C2_PTR_NULL = C2_PTR_INIT;
/// Operator of a branch element.
typedef enum {
C2_B_OUNDEFINED,
C2_B_OAND,
C2_B_OOR,
C2_B_OXOR,
} c2_b_op_t;
/// Structure for branch element in a window condition
struct _c2_b {
bool neg : 1;
c2_b_op_t op;
c2_ptr_t opr1;
c2_ptr_t opr2;
};
/// Initializer for c2_b_t.
#define C2_B_INIT \
{ .neg = false, .op = C2_B_OUNDEFINED, .opr1 = C2_PTR_INIT, .opr2 = C2_PTR_INIT, }
/// Structure for leaf element in a window condition
struct _c2_l {
bool neg : 1;
enum {
C2_L_OEXISTS = 0,
C2_L_OEQ,
C2_L_OGT,
C2_L_OGTEQ,
C2_L_OLT,
C2_L_OLTEQ,
} op : 3;
enum {
C2_L_MEXACT,
C2_L_MSTART,
C2_L_MCONTAINS,
C2_L_MWILDCARD,
C2_L_MPCRE,
} match : 3;
bool match_ignorecase : 1;
char *tgt;
unsigned int target_id;
xcb_atom_t tgtatom;
bool target_on_client;
int index;
// TODO(yshui) translate some of the pre-defined targets to
// generic window properties. e.g. `name = "xterm"`
// should be translated to:
// "WM_NAME = 'xterm' || _NET_WM_NAME = 'xterm'"
enum {
C2_L_PUNDEFINED = -1,
C2_L_PID = 0,
C2_L_PX,
C2_L_PY,
C2_L_PX2,
C2_L_PY2,
C2_L_PWIDTH,
C2_L_PHEIGHT,
C2_L_PWIDTHB,
C2_L_PHEIGHTB,
C2_L_PBDW,
C2_L_PFULLSCREEN,
C2_L_POVREDIR,
C2_L_PARGB,
C2_L_PFOCUSED,
C2_L_PWMWIN,
C2_L_PBSHAPED,
C2_L_PROUNDED,
C2_L_PCLIENT,
C2_L_PWINDOWTYPE,
C2_L_PLEADER,
C2_L_PNAME,
C2_L_PCLASSG,
C2_L_PCLASSI,
C2_L_PROLE,
} predef;
enum {
C2_L_PTUNDEFINED,
C2_L_PTSTRING,
C2_L_PTINT,
} ptntype;
char *ptnstr;
long ptnint;
#ifdef CONFIG_REGEX_PCRE
pcre2_code *regex_pcre;
pcre2_match_data *regex_pcre_match;
#endif
};
/// Initializer for c2_l_t.
#define C2_L_INIT \
{ \
.neg = false, .op = C2_L_OEXISTS, .match = C2_L_MEXACT, \
.match_ignorecase = false, .tgt = NULL, .tgtatom = 0, \
.target_on_client = false, .predef = C2_L_PUNDEFINED, .index = 0, \
.ptntype = C2_L_PTUNDEFINED, .ptnstr = NULL, .ptnint = 0, \
}
static const c2_l_t leaf_def = C2_L_INIT;
/// Linked list type of conditions.
struct _c2_lptr {
c2_ptr_t ptr;
void *data;
struct _c2_lptr *next;
};
/// Initializer for c2_lptr_t.
#define C2_LPTR_INIT \
{ .ptr = C2_PTR_INIT, .data = NULL, .next = NULL, }
/// Structure representing a predefined target.
typedef struct {
const char *name;
} c2_predef_t;
// clang-format off
// Predefined targets.
static struct {
const char *name;
bool is_string;
} C2_PREDEFS[] = {
[C2_L_PID] = { "id", false, },
[C2_L_PX] = { "x", false, },
[C2_L_PY] = { "y", false, },
[C2_L_PX2] = { "x2", false, },
[C2_L_PY2] = { "y2", false, },
[C2_L_PWIDTH] = { "width", false, },
[C2_L_PHEIGHT] = { "height", false, },
[C2_L_PWIDTHB] = { "widthb", false, },
[C2_L_PHEIGHTB] = { "heightb", false, },
[C2_L_PBDW] = { "border_width", false, },
[C2_L_PFULLSCREEN] = { "fullscreen", false, },
[C2_L_POVREDIR] = { "override_redirect", false, },
[C2_L_PARGB] = { "argb", false, },
[C2_L_PFOCUSED] = { "focused", false, },
[C2_L_PWMWIN] = { "wmwin", false, },
[C2_L_PBSHAPED] = { "bounding_shaped", false, },
[C2_L_PROUNDED] = { "rounded_corners", false, },
[C2_L_PCLIENT] = { "client", false, },
[C2_L_PWINDOWTYPE] = { "window_type", true, },
[C2_L_PLEADER] = { "leader", false, },
[C2_L_PNAME] = { "name", true, },
[C2_L_PCLASSG] = { "class_g", true, },
[C2_L_PCLASSI] = { "class_i", true, },
[C2_L_PROLE] = { "role", true, },
};
// clang-format on
static const char *const c2_pattern_type_names[] = {
[C2_L_PTUNDEFINED] = "undefined",
[C2_L_PTSTRING] = "string",
[C2_L_PTINT] = "number",
};
/**
* Compare next word in a string with another string.
*/
static inline int strcmp_wd(const char *needle, const char *src) {
int ret = mstrncmp(needle, src);
if (ret) {
return ret;
}
char c = src[strlen(needle)];
if (isalnum((unsigned char)c) || '_' == c) {
return 1;
}
return 0;
}
/**
* Return whether a c2_ptr_t is empty.
*/
static inline attr_unused bool c2_ptr_isempty(const c2_ptr_t p) {
return !(p.isbranch ? (bool)p.b : (bool)p.l);
}
/**
* Reset a c2_ptr_t.
*/
static inline void c2_ptr_reset(c2_ptr_t *pp) {
if (pp) {
memcpy(pp, &C2_PTR_NULL, sizeof(c2_ptr_t));
}
}
/**
* Combine two condition trees.
*/
static inline c2_ptr_t c2h_comb_tree(c2_b_op_t op, c2_ptr_t p1, c2_ptr_t p2) {
c2_ptr_t p = {.isbranch = true, .b = NULL};
p.b = cmalloc(c2_b_t);
p.b->neg = false;
p.b->op = op;
p.b->opr1 = p1;
p.b->opr2 = p2;
return p;
}
/**
* Get the precedence value of a condition branch operator.
*/
static inline int c2h_b_opp(c2_b_op_t op) {
switch (op) {
case C2_B_OAND: return 2;
case C2_B_OOR: return 1;
case C2_B_OXOR: return 1;
default: break;
}
assert(0);
return 0;
}
/**
* Compare precedence of two condition branch operators.
*
* Associativity is left-to-right, forever.
*
* @return positive number if op1 > op2, 0 if op1 == op2 in precedence,
* negative number otherwise
*/
static inline int c2h_b_opcmp(c2_b_op_t op1, c2_b_op_t op2) {
return c2h_b_opp(op1) - c2h_b_opp(op2);
}
static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int level);
static int c2_parse_target(const char *pattern, int offset, c2_ptr_t *presult);
static int c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult);
static int c2_parse_pattern(const char *pattern, int offset, c2_ptr_t *presult);
static int c2_parse_legacy(const char *pattern, int offset, c2_ptr_t *presult);
static void c2_free(c2_ptr_t p);
static size_t c2_condition_to_str(c2_ptr_t p, char *output, size_t len);
static const char *c2_condition_to_str2(c2_ptr_t ptr);
/**
* Wrapper of c2_free().
*/
static inline void c2_freep(c2_ptr_t *pp) {
if (pp) {
c2_free(*pp);
c2_ptr_reset(pp);
}
}
static const char *c2h_dump_str_tgt(const c2_l_t *pleaf);
/**
* Parse a condition string.
*/
c2_lptr_t *c2_parse(c2_lptr_t **pcondlst, const char *pattern, void *data) {
if (!pattern) {
return NULL;
}
// Parse the pattern
c2_ptr_t result = C2_PTR_INIT;
int offset = -1;
if (strlen(pattern) >= 2 && ':' == pattern[1]) {
offset = c2_parse_legacy(pattern, 0, &result);
} else {
offset = c2_parse_grp(pattern, 0, &result, 0);
}
if (offset < 0) {
c2_freep(&result);
return NULL;
}
// Insert to pcondlst
{
static const c2_lptr_t lptr_def = C2_LPTR_INIT;
auto plptr = cmalloc(c2_lptr_t);
memcpy(plptr, &lptr_def, sizeof(c2_lptr_t));
plptr->ptr = result;
plptr->data = data;
if (pcondlst) {
plptr->next = *pcondlst;
*pcondlst = plptr;
}
#ifdef DEBUG_C2
log_trace("(\"%s\"): ", pattern);
c2_dump(plptr->ptr);
putchar('\n');
#endif
return plptr;
}
}
TEST_CASE(c2_parse) {
log_init_tls();
// log_add_target_tls(stderr_logger_new());
char str[1024];
c2_lptr_t *cond = c2_parse(NULL, "name = \"xterm\"", NULL);
struct atom *atoms = init_mock_atoms();
struct c2_state *state = c2_state_new(atoms);
TEST_NOTEQUAL(cond, NULL);
TEST_TRUE(!cond->ptr.isbranch);
TEST_NOTEQUAL(cond->ptr.l, NULL);
TEST_EQUAL(cond->ptr.l->op, C2_L_OEQ);
TEST_EQUAL(cond->ptr.l->ptntype, C2_L_PTSTRING);
TEST_STREQUAL(cond->ptr.l->ptnstr, "xterm");
size_t len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "name = \"xterm\"", len);
struct managed_win test_win = {
.name = "xterm",
};
TEST_TRUE(c2_match(state, &test_win, cond, NULL));
c2_list_postprocess(state, NULL, cond);
TEST_EQUAL(HASH_COUNT(state->tracked_properties), 0);
c2_state_free(state);
destroy_atoms(atoms);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "argb", NULL);
TEST_NOTEQUAL(cond, NULL);
TEST_TRUE(!cond->ptr.isbranch);
TEST_EQUAL(cond->ptr.l->ptntype, C2_L_PTINT);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "argb = 'b'", NULL);
TEST_EQUAL(cond, NULL);
cond = c2_parse(NULL, "_GTK_FRAME_EXTENTS@:c", NULL);
TEST_NOTEQUAL(cond, NULL);
TEST_TRUE(!cond->ptr.isbranch);
TEST_NOTEQUAL(cond->ptr.l, NULL);
TEST_EQUAL(cond->ptr.l->op, C2_L_OEXISTS);
TEST_EQUAL(cond->ptr.l->match, C2_L_MEXACT);
TEST_EQUAL(cond->ptr.l->predef, C2_L_PUNDEFINED);
TEST_TRUE(cond->ptr.l->target_on_client);
TEST_NOTEQUAL(cond->ptr.l->tgt, NULL);
TEST_STREQUAL(cond->ptr.l->tgt, "_GTK_FRAME_EXTENTS");
atoms = init_mock_atoms();
state = c2_state_new(atoms);
c2_list_postprocess(state, NULL, cond);
TEST_EQUAL(HASH_COUNT(state->tracked_properties), 1);
HASH_ITER2(state->tracked_properties, prop) {
TEST_EQUAL(prop->key.property,
get_atom_with_nul(state->atoms, "_GTK_FRAME_EXTENTS", NULL));
TEST_EQUAL(prop->max_indices, 0);
}
c2_state_free(state);
destroy_atoms(atoms);
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "_GTK_FRAME_EXTENTS@[0]", len);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "name = \"xterm\" && class_g *= \"XTerm\"", NULL);
TEST_NOTEQUAL(cond, NULL);
TEST_TRUE(cond->ptr.isbranch);
TEST_NOTEQUAL(cond->ptr.b, NULL);
TEST_EQUAL(cond->ptr.b->op, C2_B_OAND);
TEST_NOTEQUAL(cond->ptr.b->opr1.l, NULL);
TEST_NOTEQUAL(cond->ptr.b->opr2.l, NULL);
TEST_EQUAL(cond->ptr.b->opr1.l->op, C2_L_OEQ);
TEST_EQUAL(cond->ptr.b->opr1.l->match, C2_L_MEXACT);
TEST_EQUAL(cond->ptr.b->opr1.l->ptntype, C2_L_PTSTRING);
TEST_EQUAL(cond->ptr.b->opr2.l->op, C2_L_OEQ);
TEST_EQUAL(cond->ptr.b->opr2.l->match, C2_L_MCONTAINS);
TEST_EQUAL(cond->ptr.b->opr2.l->ptntype, C2_L_PTSTRING);
TEST_STREQUAL(cond->ptr.b->opr1.l->tgt, "name");
TEST_EQUAL(cond->ptr.b->opr1.l->predef, C2_L_PNAME);
TEST_STREQUAL(cond->ptr.b->opr2.l->tgt, "class_g");
TEST_EQUAL(cond->ptr.b->opr2.l->predef, C2_L_PCLASSG);
atoms = init_mock_atoms();
state = c2_state_new(atoms);
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "(name = \"xterm\" && class_g *= \"XTerm\")", len);
test_win.class_general = "XTerm";
TEST_TRUE(c2_match(state, &test_win, cond, NULL));
test_win.class_general = "asdf";
TEST_TRUE(!c2_match(state, &test_win, cond, NULL));
c2_list_free(&cond, NULL);
c2_state_free(state);
destroy_atoms(atoms);
cond = c2_parse(NULL, "_NET_WM_STATE[1]:32a *='_NET_WM_STATE_HIDDEN'", NULL);
TEST_EQUAL(cond->ptr.l->index, 1);
TEST_STREQUAL(cond->ptr.l->tgt, "_NET_WM_STATE");
TEST_STREQUAL(cond->ptr.l->ptnstr, "_NET_WM_STATE_HIDDEN");
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "_NET_WM_STATE[1] *= \"_NET_WM_STATE_HIDDEN\"", len);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "_NET_WM_STATE[*]:32a*='_NET_WM_STATE_HIDDEN'", NULL);
TEST_EQUAL(cond->ptr.l->index, -1);
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "_NET_WM_STATE[*] *= \"_NET_WM_STATE_HIDDEN\"", len);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "!class_i:0s", NULL);
TEST_NOTEQUAL(cond, NULL);
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, "!class_i", len);
c2_list_free(&cond, NULL);
cond = c2_parse(NULL, "_NET_WM_STATE = '_NET_WM_STATE_HIDDEN'", NULL);
TEST_NOTEQUAL(cond, NULL);
cond = c2_parse(NULL, "1A:\n1111111111111ar1", NULL);
TEST_EQUAL(cond, NULL);
cond = c2_parse(NULL, "N [4444444444444: \n", NULL);
TEST_EQUAL(cond, NULL);
cond = c2_parse(NULL, " x:a=\"b\377\\xCCCCC", NULL);
TEST_EQUAL(cond, NULL);
cond = c2_parse(NULL, "!!!!!!!((((((!(((((,", NULL);
TEST_EQUAL(cond, NULL);
const char *rule = "(((role = \"\\\\tg^\\n\\n[\\t\" && role ~?= \"\") && "
"role ~?= \"\\n\\n\\n\\b\\n^\\n*0bon\") && role ~?= "
"\"\\n\\n\\x8a\\b\\n^\\n*0\\n[\\n[\\n\\n\\b\\n\")";
cond = c2_parse(NULL, rule, NULL);
TEST_NOTEQUAL(cond, NULL);
len = c2_condition_to_str(cond->ptr, str, sizeof(str));
TEST_STREQUAL3(str, rule, len);
c2_list_free(&cond, NULL);
}
#define c2_error(format, ...) \
do { \
log_error("Pattern \"%s\" pos %d: " format, pattern, offset, ##__VA_ARGS__); \
goto fail; \
} while (0)
// TODO(yshui) Not a very good macro, should probably be a function
#define C2H_SKIP_SPACES() \
{ \
while (isspace((unsigned char)pattern[offset])) \
++offset; \
}
/**
* Parse a group in condition string.
*
* @return offset of next character in string
*/
static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int level) {
if (!pattern) {
return -1;
}
// Expected end character
const char endchar = (offset ? ')' : '\0');
// We use a system that a maximum of 2 elements are kept. When we find
// the third element, we combine the elements according to operator
// precedence. This design limits operators to have at most two-levels
// of precedence and fixed left-to-right associativity.
// For storing branch operators. ops[0] is actually unused
c2_b_op_t ops[3] = {};
// For storing elements
c2_ptr_t eles[2] = {C2_PTR_INIT, C2_PTR_INIT};
// Index of next free element slot in eles
int elei = 0;
// Pointer to the position of next element
c2_ptr_t *pele = eles;
// Negation flag of next operator
bool neg = false;
// Whether we are expecting an element immediately, is true at first, or
// after encountering a logical operator
bool next_expected = true;
// Check for recursion levels
if (level > C2_MAX_LEVELS) {
c2_error("Exceeded maximum recursion levels.");
}
// Parse the pattern character-by-character
for (; pattern[offset]; ++offset) {
assert(elei <= 2);
// Jump over spaces
if (isspace((unsigned char)pattern[offset])) {
continue;
}
// Handle end of group
if (')' == pattern[offset]) {
break;
}
// Handle "!"
if ('!' == pattern[offset]) {
if (!next_expected) {
c2_error("Unexpected \"!\".");
}
neg = !neg;
continue;
}
// Handle AND and OR
if ('&' == pattern[offset] || '|' == pattern[offset]) {
if (next_expected) {
c2_error("Unexpected logical operator.");
}
next_expected = true;
if (!mstrncmp("&&", pattern + offset)) {
ops[elei] = C2_B_OAND;
++offset;
} else if (!mstrncmp("||", pattern + offset)) {
ops[elei] = C2_B_OOR;
++offset;
} else {
c2_error("Illegal logical operator.");
}
continue;
}
// Parsing an element
if (!next_expected) {
c2_error("Unexpected expression.");
}
assert(!elei || ops[elei]);
// If we are out of space
if (2 == elei) {
--elei;
// If the first operator has higher or equal precedence, combine
// the first two elements
if (c2h_b_opcmp(ops[1], ops[2]) >= 0) {
eles[0] = c2h_comb_tree(ops[1], eles[0], eles[1]);
c2_ptr_reset(&eles[1]);
pele = &eles[elei];
ops[1] = ops[2];
}
// Otherwise, combine the second and the incoming one
else {
eles[1] = c2h_comb_tree(ops[2], eles[1], C2_PTR_NULL);
assert(eles[1].isbranch);
pele = &eles[1].b->opr2;
}
// The last operator always needs to be reset
ops[2] = C2_B_OUNDEFINED;
}
// It's a subgroup if it starts with '('
if ('(' == pattern[offset]) {
if ((offset = c2_parse_grp(pattern, offset + 1, pele, level + 1)) < 0) {
goto fail;
}
}
// Otherwise it's a leaf
else {
if ((offset = c2_parse_target(pattern, offset, pele)) < 0) {
goto fail;
}
assert(!pele->isbranch && !c2_ptr_isempty(*pele));
if ((offset = c2_parse_op(pattern, offset, pele)) < 0) {
goto fail;
}
if ((offset = c2_parse_pattern(pattern, offset, pele)) < 0) {
goto fail;
}
if (pele->l->predef != C2_L_PUNDEFINED) {
typeof(pele->l->ptntype) predef_type =
C2_PREDEFS[pele->l->predef].is_string ? C2_L_PTSTRING
: C2_L_PTINT;
if (pele->l->op == C2_L_OEXISTS) {
pele->l->ptntype = predef_type;
} else if (pele->l->ptntype != predef_type) {
c2_error("Predefined target %s is a %s, but you "
"are comparing it with a %s",
C2_PREDEFS[pele->l->predef].name,
c2_pattern_type_names[predef_type],
c2_pattern_type_names[pele->l->ptntype]);
}
}
}
// Decrement offset -- we will increment it in loop update
--offset;
// Apply negation
if (neg) {
neg = false;
if (pele->isbranch) {
pele->b->neg = !pele->b->neg;
} else {
pele->l->neg = !pele->l->neg;
}
}
next_expected = false;
++elei;
pele = &eles[elei];
}
// Wrong end character?
if (pattern[offset] && !endchar) {
c2_error("Expected end of string but found '%c'.", pattern[offset]);
}
if (!pattern[offset] && endchar) {
c2_error("Expected '%c' but found end of string.", endchar);
}
// Handle end of group
if (!elei) {
c2_error("Empty group.");
} else if (next_expected) {
c2_error("Missing rule before end of group.");
} else if (elei > 1) {
assert(2 == elei);
assert(ops[1]);
eles[0] = c2h_comb_tree(ops[1], eles[0], eles[1]);
c2_ptr_reset(&eles[1]);
}
*presult = eles[0];
if (')' == pattern[offset]) {
++offset;
}
return offset;
fail:
c2_freep(&eles[0]);
c2_freep(&eles[1]);
return -1;
}
/**
* Parse the target part of a rule.
*/
static int c2_parse_target(const char *pattern, int offset, c2_ptr_t *presult) {
// Initialize leaf
presult->isbranch = false;
presult->l = cmalloc(c2_l_t);
c2_l_t *const pleaf = presult->l;
memcpy(pleaf, &leaf_def, sizeof(c2_l_t));
// Parse negation marks
while ('!' == pattern[offset]) {
pleaf->neg = !pleaf->neg;
++offset;
C2H_SKIP_SPACES();
}
// Copy target name out
int tgtlen = 0;
for (; pattern[offset] && (isalnum((unsigned char)pattern[offset]) ||
'_' == pattern[offset] || '.' == pattern[offset]);
++offset) {
++tgtlen;
}
if (!tgtlen) {
c2_error("Empty target.");
}
pleaf->tgt = strndup(&pattern[offset - tgtlen], (size_t)tgtlen);
// Check for predefined targets
static const int npredefs = (int)(sizeof(C2_PREDEFS) / sizeof(C2_PREDEFS[0]));
for (int i = 0; i < npredefs; ++i) {
if (!strcmp(C2_PREDEFS[i].name, pleaf->tgt)) {
pleaf->predef = i;
break;
}
}
C2H_SKIP_SPACES();
// Parse target-on-client flag
if ('@' == pattern[offset]) {
pleaf->target_on_client = true;
++offset;
C2H_SKIP_SPACES();
}
// Parse index
if ('[' == pattern[offset]) {
if (pleaf->predef != C2_L_PUNDEFINED) {
c2_error("Predefined targets can't have index.");
}
offset++;
C2H_SKIP_SPACES();
long index = -1;
const char *endptr = NULL;
if ('*' == pattern[offset]) {
index = -1;
endptr = pattern + offset + 1;
} else {
index = strtol(pattern + offset, (char **)&endptr, 0);
if (index < 0) {
c2_error("Index number invalid.");
}
}
if (!endptr || pattern + offset == endptr) {
c2_error("No index number found after bracket.");
}
if (index > INT_MAX) {
c2_error("Index %ld too large.", index);
}
pleaf->index = (int)index;
offset = to_int_checked(endptr - pattern);
C2H_SKIP_SPACES();
if (pattern[offset] != ']') {
c2_error("Index end marker not found.");
}
++offset;
C2H_SKIP_SPACES();
}
// Parse target type and format
if (':' == pattern[offset]) {
++offset;
C2H_SKIP_SPACES();
// Look for format
bool hasformat = false;
long format = 0;
char *endptr = NULL;
format = strtol(pattern + offset, &endptr, 0);
assert(endptr);
hasformat = endptr && endptr != pattern + offset;
if (hasformat) {
offset = to_int_checked(endptr - pattern);
}
C2H_SKIP_SPACES();
// Look for type
switch (pattern[offset]) {
case 'w':
case 'd':
case 'c':
case 's':
case 'a': break;
default: c2_error("Invalid type character.");
}
log_warn("Type specifier is deprecated. Type \"%c\" specified on target "
"\"%s\" will be ignored, you can remove it.",
pattern[offset], pleaf->tgt);
offset++;
C2H_SKIP_SPACES();
// Write format
if (hasformat) {
log_warn("Format specifier is deprecated. Format \"%ld\" "
"specified on target \"%s\" will be ignored, you can "
"remove it.",
format, pleaf->tgt);
if (format && format != 8 && format != 16 && format != 32) {
c2_error("Invalid format %ld.", format);
}
}
}
return offset;
fail:
return -1;
}
/**
* Parse the operator part of a leaf.
*/
static int c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult) {
c2_l_t *const pleaf = presult->l;
// Parse negation marks
C2H_SKIP_SPACES();
while ('!' == pattern[offset]) {
pleaf->neg = !pleaf->neg;
++offset;
C2H_SKIP_SPACES();
}
// Parse qualifiers
if ('*' == pattern[offset] || '^' == pattern[offset] || '%' == pattern[offset] ||
'~' == pattern[offset]) {
switch (pattern[offset]) {
case '*': pleaf->match = C2_L_MCONTAINS; break;
case '^': pleaf->match = C2_L_MSTART; break;
case '%': pleaf->match = C2_L_MWILDCARD; break;
case '~': pleaf->match = C2_L_MPCRE; break;
default: assert(0);
}
++offset;
C2H_SKIP_SPACES();
}
// Parse flags
while ('?' == pattern[offset]) {
pleaf->match_ignorecase = true;
++offset;
C2H_SKIP_SPACES();
}
// Parse operator
while ('=' == pattern[offset] || '>' == pattern[offset] || '<' == pattern[offset]) {
if ('=' == pattern[offset] && C2_L_OGT == pleaf->op) {
pleaf->op = C2_L_OGTEQ;
} else if ('=' == pattern[offset] && C2_L_OLT == pleaf->op) {
pleaf->op = C2_L_OLTEQ;
} else if (pleaf->op) {
c2_error("Duplicate operator.");
} else {
switch (pattern[offset]) {
case '=': pleaf->op = C2_L_OEQ; break;
case '>': pleaf->op = C2_L_OGT; break;
case '<': pleaf->op = C2_L_OLT; break;
default: assert(0);
}
}
++offset;
C2H_SKIP_SPACES();
}
// Check for problems
if (C2_L_OEQ != pleaf->op && (pleaf->match || pleaf->match_ignorecase)) {
c2_error("Exists/greater-than/less-than operators cannot have a "
"qualifier.");
}
return offset;
fail:
return -1;
}
/**
* Parse the pattern part of a leaf.
*/
static int c2_parse_pattern(const char *pattern, int offset, c2_ptr_t *presult) {
c2_l_t *const pleaf = presult->l;
// Exists operator cannot have pattern
if (!pleaf->op) {
return offset;
}
C2H_SKIP_SPACES();
char *endptr = NULL;
if (!strcmp_wd("true", &pattern[offset])) {
pleaf->ptntype = C2_L_PTINT;
pleaf->ptnint = true;
offset += 4; // length of "true";
} else if (!strcmp_wd("false", &pattern[offset])) {
pleaf->ptntype = C2_L_PTINT;
pleaf->ptnint = false;
offset += 5; // length of "false";
} else if (pleaf->ptnint = strtol(pattern + offset, &endptr, 0),
pattern + offset != endptr) {
pleaf->ptntype = C2_L_PTINT;
offset = to_int_checked(endptr - pattern);
// Make sure we are stopping at the end of a word
if (isalnum((unsigned char)pattern[offset])) {
c2_error("Trailing characters after a numeric pattern.");
}
} else {
// Parse string patterns
bool raw = false;
char delim = '\0';
// String flags
if (tolower((unsigned char)pattern[offset]) == 'r') {
raw = true;
++offset;
C2H_SKIP_SPACES();
}
if (raw == true) {
log_warn("Raw string patterns has been deprecated. pos %d", offset);
}
// Check for delimiters
if (pattern[offset] == '\"' || pattern[offset] == '\'') {
pleaf->ptntype = C2_L_PTSTRING;
delim = pattern[offset];
++offset;
}
if (pleaf->ptntype != C2_L_PTSTRING) {
c2_error("Invalid pattern type.");
}
// Parse the string now
// We can't determine the length of the pattern, so we use the length
// to the end of the pattern string -- currently escape sequences
// cannot be converted to a string longer than itself.
auto tptnstr = ccalloc((strlen(pattern + offset) + 1), char);
char *ptptnstr = tptnstr;
pleaf->ptnstr = tptnstr;
for (; pattern[offset] && delim != pattern[offset]; ++offset) {
// Handle escape sequences if it's not a raw string
if ('\\' == pattern[offset] && !raw) {
switch (pattern[++offset]) {
case '\\': *(ptptnstr++) = '\\'; break;
case '\'': *(ptptnstr++) = '\''; break;
case '\"': *(ptptnstr++) = '\"'; break;
case 'a': *(ptptnstr++) = '\a'; break;
case 'b': *(ptptnstr++) = '\b'; break;
case 'f': *(ptptnstr++) = '\f'; break;
case 'n': *(ptptnstr++) = '\n'; break;
case 'r': *(ptptnstr++) = '\r'; break;
case 't': *(ptptnstr++) = '\t'; break;
case 'v': *(ptptnstr++) = '\v'; break;
case 'o':
case 'x': {
scoped_charp tstr = strndup(pattern + offset + 1, 2);
char *pstr = NULL;
long val = strtol(
tstr, &pstr, ('o' == pattern[offset] ? 8 : 16));
if (pstr != &tstr[2] || val <= 0) {
c2_error("Invalid octal/hex escape "
"sequence.");
}
if (val > 255) {
c2_error("Octal/hex escape sequence out "
"of ASCII range.");
}
if (val > 127) {
// Manual sign extension
val -= 256;
}
*(ptptnstr++) = (char)val;
offset += 2;
break;
}
default: c2_error("Invalid escape sequence.");
}
} else {
*(ptptnstr++) = pattern[offset];
}
}
if (!pattern[offset]) {
c2_error("Premature end of pattern string.");
}
++offset;
*ptptnstr = '\0';
pleaf->ptnstr = strdup(tptnstr);
free(tptnstr);
}
C2H_SKIP_SPACES();
if (!pleaf->ptntype) {
c2_error("Invalid pattern type.");
}
if (pleaf->ptntype == C2_L_PTINT) {
if (pleaf->match) {
c2_error("Integer/boolean pattern cannot have operator "
"qualifiers.");
}
if (pleaf->match_ignorecase) {
c2_error("Integer/boolean pattern cannot have flags.");
}
}
if (C2_L_PTSTRING == pleaf->ptntype &&
(C2_L_OGT == pleaf->op || C2_L_OGTEQ == pleaf->op || C2_L_OLT == pleaf->op ||
C2_L_OLTEQ == pleaf->op)) {
c2_error("String pattern cannot have an arithmetic operator.");
}
return offset;
fail:
return -1;
}
/**
* Parse a condition with legacy syntax.
*/
static int c2_parse_legacy(const char *pattern, int offset, c2_ptr_t *presult) {
if (strlen(pattern + offset) < 4 || pattern[offset + 1] != ':' ||
!strchr(pattern + offset + 2, ':')) {
c2_error("Legacy parser: Invalid format.");
}
// Allocate memory for new leaf
auto pleaf = cmalloc(c2_l_t);
presult->isbranch = false;
presult->l = pleaf;
memcpy(pleaf, &leaf_def, sizeof(c2_l_t));
pleaf->op = C2_L_OEQ;
pleaf->ptntype = C2_L_PTSTRING;
// Determine the pattern target
switch (pattern[offset]) {
case 'n': pleaf->predef = C2_L_PNAME; break;
case 'i': pleaf->predef = C2_L_PCLASSI; break;
case 'g': pleaf->predef = C2_L_PCLASSG; break;
case 'r': pleaf->predef = C2_L_PROLE; break;
default: c2_error("Target \"%c\" invalid.\n", pattern[offset]);
}
offset += 2;
// Determine the match type
switch (pattern[offset]) {
case 'e': pleaf->match = C2_L_MEXACT; break;
case 'a': pleaf->match = C2_L_MCONTAINS; break;
case 's': pleaf->match = C2_L_MSTART; break;
case 'w': pleaf->match = C2_L_MWILDCARD; break;
case 'p': pleaf->match = C2_L_MPCRE; break;
default: c2_error("Type \"%c\" invalid.\n", pattern[offset]);
}
++offset;
// Determine the pattern flags
while (':' != pattern[offset]) {
switch (pattern[offset]) {
case 'i': pleaf->match_ignorecase = true; break;
default: c2_error("Flag \"%c\" invalid.", pattern[offset]);
}
++offset;
}
++offset;
// Copy the pattern
pleaf->ptnstr = strdup(pattern + offset);
return offset;
fail:
return -1;
}
#undef c2_error
/**
* Do postprocessing on a condition leaf.
*/
static bool c2_l_postprocess(struct c2_state *state, xcb_connection_t *c, c2_l_t *pleaf) {
// Get target atom if it's not a predefined one
if (pleaf->predef == C2_L_PUNDEFINED) {
pleaf->tgtatom = get_atom_with_nul(state->atoms, pleaf->tgt, c);
if (!pleaf->tgtatom) {
log_error("Failed to get atom for target \"%s\".", pleaf->tgt);
return false;
}
}
// Insert target atom into tracked property name list
if (pleaf->tgtatom) {
struct c2_tracked_property *property;
struct c2_tracked_property_key key = {
.property = pleaf->tgtatom,
.is_on_client = pleaf->target_on_client,
};
HASH_FIND(hh, state->tracked_properties, &key, sizeof(key), property);
if (property == NULL) {
property = cmalloc(struct c2_tracked_property);
property->key = key;
property->id = HASH_COUNT(state->tracked_properties);
HASH_ADD_KEYPTR(hh, state->tracked_properties, &property->key,
sizeof(property->key), property);
property->max_indices = pleaf->index;
} else if (pleaf->index == -1) {
property->max_indices = -1;
} else if (property->max_indices >= 0 && pleaf->index > property->max_indices) {
property->max_indices = pleaf->index;
}
pleaf->target_id = property->id;
}
// Warn about lower case characters in target name
if (pleaf->predef == C2_L_PUNDEFINED) {
for (const char *pc = pleaf->tgt; *pc; ++pc) {
if (islower((unsigned char)*pc)) {
log_warn("Lowercase character in target name \"%s\".",
pleaf->tgt);
break;
}
}
}
// PCRE patterns
if (C2_L_PTSTRING == pleaf->ptntype && C2_L_MPCRE == pleaf->match) {
#ifdef CONFIG_REGEX_PCRE
int errorcode = 0;
PCRE2_SIZE erroffset = 0;
unsigned int options = 0;
// Ignore case flag
if (pleaf->match_ignorecase) {
options |= PCRE2_CASELESS;
}
// Compile PCRE expression
pleaf->regex_pcre =
pcre2_compile((PCRE2_SPTR)pleaf->ptnstr, PCRE2_ZERO_TERMINATED,
options, &errorcode, &erroffset, NULL);
if (pleaf->regex_pcre == NULL) {
PCRE2_UCHAR buffer[256];
pcre2_get_error_message(errorcode, buffer, sizeof(buffer));
log_error("Pattern \"%s\": PCRE regular expression "
"parsing failed on offset %zu: %s",
pleaf->ptnstr, erroffset, buffer);
return false;
}
pleaf->regex_pcre_match =
pcre2_match_data_create_from_pattern(pleaf->regex_pcre, NULL);
#else
log_error("PCRE regular expression support not compiled in.");
return false;
#endif
}
return true;
}
static bool c2_tree_postprocess(struct c2_state *state, xcb_connection_t *c, c2_ptr_t node) {
if (!node.isbranch) {
return c2_l_postprocess(state, c, node.l);
}
return c2_tree_postprocess(state, c, node.b->opr1) &&
c2_tree_postprocess(state, c, node.b->opr2);
}
bool c2_list_postprocess(struct c2_state *state, xcb_connection_t *c, c2_lptr_t *list) {
c2_lptr_t *head = list;
while (head) {
if (!c2_tree_postprocess(state, c, head->ptr)) {
return false;
}
head = head->next;
}
return true;
}
/**
* Free a condition tree.
*/
static void c2_free(c2_ptr_t p) {
// For a branch element
if (p.isbranch) {
c2_b_t *const pbranch = p.b;
if (!pbranch) {
return;
}
c2_free(pbranch->opr1);
c2_free(pbranch->opr2);
free(pbranch);
}
// For a leaf element
else {
c2_l_t *const pleaf = p.l;
if (!pleaf) {
return;
}
free(pleaf->tgt);
free(pleaf->ptnstr);
#ifdef CONFIG_REGEX_PCRE
pcre2_code_free(pleaf->regex_pcre);
pcre2_match_data_free(pleaf->regex_pcre_match);
#endif
free(pleaf);
}
}
/**
* Free a condition tree in c2_lptr_t.
*/
c2_lptr_t *c2_free_lptr(c2_lptr_t *lp, c2_userdata_free f) {
if (!lp) {
return NULL;
}
c2_lptr_t *pnext = lp->next;
if (f) {
f(lp->data);
}
lp->data = NULL;
c2_free(lp->ptr);
free(lp);
return pnext;
}
/**
* Get a string representation of a rule target.
*/
static const char *c2h_dump_str_tgt(const c2_l_t *pleaf) {
if (pleaf->predef != C2_L_PUNDEFINED) {
return C2_PREDEFS[pleaf->predef].name;
}
return pleaf->tgt;
}
/**
* Dump a condition tree to string. Return the number of characters that
* would have been written if the buffer had been large enough, excluding
* the null terminator.
* null terminator will not be written to the output.
*/
static size_t c2_condition_to_str(const c2_ptr_t p, char *output, size_t len) {
#define push_char(c) \
if (offset < len) \
output[offset] = (c); \
offset++
#define push_str(str) \
do { \
if (offset < len) { \
size_t slen = strlen(str); \
if (offset + slen > len) \
slen = len - offset; \
memcpy(output + offset, str, slen); \
} \
offset += strlen(str); \
} while (false)
size_t offset = 0;
if (p.isbranch) {
// Branch, i.e. logical operators &&, ||, XOR
const c2_b_t *const pbranch = p.b;
if (!pbranch) {
return 0;
}
if (pbranch->neg) {
push_char('!');
}
push_char('(');
if (len > offset) {
offset += c2_condition_to_str(pbranch->opr1, output + offset,
len - offset);
} else {
offset += c2_condition_to_str(pbranch->opr1, NULL, 0);
}
switch (pbranch->op) {
case C2_B_OAND: push_str(" && "); break;
case C2_B_OOR: push_str(" || "); break;
case C2_B_OXOR: push_str(" XOR "); break;
default: assert(0); break;
}
if (len > offset) {
offset += c2_condition_to_str(pbranch->opr2, output + offset,
len - offset);
} else {
offset += c2_condition_to_str(pbranch->opr2, NULL, 0);
}
push_str(")");
} else {
// Leaf node
const c2_l_t *const pleaf = p.l;
char number[128];
if (!pleaf) {
return 0;
}
if (C2_L_OEXISTS == pleaf->op && pleaf->neg) {
push_char('!');
}
// Print target name, type, and format
const char *target_str = c2h_dump_str_tgt(pleaf);
push_str(target_str);
if (pleaf->target_on_client) {
push_char('@');
}
if (pleaf->predef == C2_L_PUNDEFINED) {
if (pleaf->index < 0) {
push_str("[*]");
} else {
sprintf(number, "[%d]", pleaf->index);
push_str(number);
}
}
if (C2_L_OEXISTS == pleaf->op) {
return offset;
}
// Print operator
push_char(' ');
if (C2_L_OEXISTS != pleaf->op && pleaf->neg) {
push_char('!');
}
switch (pleaf->match) {
case C2_L_MEXACT: break;
case C2_L_MCONTAINS: push_char('*'); break;
case C2_L_MSTART: push_char('^'); break;
case C2_L_MPCRE: push_char('~'); break;
case C2_L_MWILDCARD: push_char('%'); break;
}
if (pleaf->match_ignorecase) {
push_char('?');
}
switch (pleaf->op) {
case C2_L_OEXISTS: break;
case C2_L_OEQ: push_str("="); break;
case C2_L_OGT: push_str(">"); break;
case C2_L_OGTEQ: push_str(">="); break;
case C2_L_OLT: push_str("<"); break;
case C2_L_OLTEQ: push_str("<="); break;
}
// Print pattern
push_char(' ');
switch (pleaf->ptntype) {
case C2_L_PTINT:
sprintf(number, "%ld", pleaf->ptnint);
push_str(number);
break;
case C2_L_PTSTRING:
// TODO(yshui) Escape string before printing out?
push_char('"');
for (int i = 0; pleaf->ptnstr[i]; i++) {
switch (pleaf->ptnstr[i]) {
case '\\': push_str("\\\\"); break;
case '"': push_str("\\\""); break;
case '\a': push_str("\\a"); break;
case '\b': push_str("\\b"); break;
case '\f': push_str("\\f"); break;
case '\r': push_str("\\r"); break;
case '\v': push_str("\\v"); break;
case '\t': push_str("\\t"); break;
case '\n': push_str("\\n"); break;
default:
if (isprint(pleaf->ptnstr[i])) {
push_char(pleaf->ptnstr[i]);
} else {
sprintf(number, "\\x%02x",
(unsigned char)pleaf->ptnstr[i]);
push_str(number);
}
break;
}
}
push_char('"');
break;
default: assert(0); break;
}
}
#undef push_char
#undef push_str
return offset;
}
/// Wrapper of c2_condition_to_str which uses an internal static buffer, and
/// returns a nul terminated string. The returned string is only valid until the
/// next call to this function, and should not be freed.
static const char *c2_condition_to_str2(c2_ptr_t ptr) {
static thread_local char buf[4096];
auto len = c2_condition_to_str(ptr, buf, sizeof(buf));
if (len >= sizeof(buf)) {
// Resulting string is too long, clobber the last character with a nul.
buf[sizeof(buf) - 1] = '\0';
} else {
buf[len] = '\0';
}
return buf;
}
const char *c2_lptr_to_str(const c2_lptr_t *ptr) {
return c2_condition_to_str2(ptr->ptr);
}
/// Get the list of target number values from a struct c2_property_value
static inline const int64_t *
c2_values_get_number_targets(const struct c2_property_value *values, int index, size_t *n) {
auto storage = values->numbers;
if (values->length > ARR_SIZE(values->numbers)) {
storage = values->array;
}
if (index < 0) {
*n = values->length;
return storage;
}
if ((size_t)index < values->length) {
*n = 1;
return &storage[index];
}
*n = 0;
return NULL;
}
static inline bool c2_int_op(const c2_l_t *leaf, int64_t target) {
switch (leaf->op) {
case C2_L_OEXISTS: return leaf->predef != C2_L_PUNDEFINED ? target : true;
case C2_L_OEQ: return target == leaf->ptnint;
case C2_L_OGT: return target > leaf->ptnint;
case C2_L_OGTEQ: return target >= leaf->ptnint;
case C2_L_OLT: return target < leaf->ptnint;
case C2_L_OLTEQ: return target <= leaf->ptnint;
}
unreachable();
}
static bool c2_match_once_leaf_int(const struct managed_win *w, const c2_l_t *leaf) {
const xcb_window_t wid = (leaf->target_on_client ? w->client_win : w->base.id);
// Get the value
if (leaf->predef != C2_L_PUNDEFINED) {
// A predefined target
int64_t predef_target = 0;
switch (leaf->predef) {
case C2_L_PID: predef_target = wid; break;
case C2_L_PX: predef_target = w->g.x; break;
case C2_L_PY: predef_target = w->g.y; break;
case C2_L_PX2: predef_target = w->g.x + w->widthb; break;
case C2_L_PY2: predef_target = w->g.y + w->heightb; break;
case C2_L_PWIDTH: predef_target = w->g.width; break;
case C2_L_PHEIGHT: predef_target = w->g.height; break;
case C2_L_PWIDTHB: predef_target = w->widthb; break;
case C2_L_PHEIGHTB: predef_target = w->heightb; break;
case C2_L_PBDW: predef_target = w->g.border_width; break;
case C2_L_PFULLSCREEN: predef_target = w->is_fullscreen; break;
case C2_L_POVREDIR: predef_target = w->a.override_redirect; break;
case C2_L_PARGB: predef_target = win_has_alpha(w); break;
case C2_L_PFOCUSED: predef_target = win_is_focused_raw(w); break;
case C2_L_PWMWIN: predef_target = win_is_wmwin(w); break;
case C2_L_PBSHAPED: predef_target = w->bounding_shaped; break;
case C2_L_PROUNDED: predef_target = w->rounded_corners; break;
case C2_L_PCLIENT: predef_target = w->client_win; break;
case C2_L_PLEADER: predef_target = w->leader; break;
default: unreachable();
}
return c2_int_op(leaf, predef_target);
}
// A raw window property
auto values = &w->c2_state.values[leaf->target_id];
assert(!values->needs_update);
if (!values->valid) {
log_verbose("Property %s not found on window %#010x (%s)", leaf->tgt,
w->client_win, w->name);
return false;
}
if (values->type == C2_PROPERTY_TYPE_STRING) {
log_error("Property %s is not an integer", leaf->tgt);
return false;
}
size_t ntargets = 0;
auto targets = c2_values_get_number_targets(values, leaf->index, &ntargets);
for (size_t i = 0; i < ntargets; i++) {
if (c2_int_op(leaf, targets[i])) {
return true;
}
}
return false;
}
static bool c2_string_op(const c2_l_t *leaf, const char *target) {
if (leaf->op == C2_L_OEXISTS) {
return true;
}
if (leaf->op != C2_L_OEQ) {
log_error("Unsupported operator %d for string comparison.", leaf->op);
assert(leaf->op == C2_L_OEQ);
return false;
}
if (leaf->match == C2_L_MPCRE) {
#ifdef CONFIG_REGEX_PCRE
assert(strlen(target) <= INT_MAX);
assert(leaf->regex_pcre);
return (pcre2_match(leaf->regex_pcre, (PCRE2_SPTR)target, strlen(target),
0, 0, leaf->regex_pcre_match, NULL) > 0);
#else
log_error("PCRE regular expression support not compiled in.");
assert(leaf->match != C2_L_MPCRE);
return false;
#endif
}
if (leaf->match_ignorecase) {
switch (leaf->match) {
case C2_L_MEXACT: return !strcasecmp(target, leaf->ptnstr);
case C2_L_MCONTAINS: return strcasestr(target, leaf->ptnstr);
case C2_L_MSTART:
return !strncasecmp(target, leaf->ptnstr, strlen(leaf->ptnstr));
case C2_L_MWILDCARD: return !fnmatch(leaf->ptnstr, target, FNM_CASEFOLD);
default: unreachable();
}
} else {
switch (leaf->match) {
case C2_L_MEXACT: return !strcmp(target, leaf->ptnstr);
case C2_L_MCONTAINS: return strstr(target, leaf->ptnstr);
case C2_L_MSTART:
return !strncmp(target, leaf->ptnstr, strlen(leaf->ptnstr));
case C2_L_MWILDCARD: return !fnmatch(leaf->ptnstr, target, 0);
default: unreachable();
}
}
unreachable();
}
static bool c2_match_once_leaf_string(struct atom *atoms, const struct managed_win *w,
const c2_l_t *leaf) {
// A predefined target
const char *predef_target = NULL;
if (leaf->predef != C2_L_PUNDEFINED) {
switch (leaf->predef) {
case C2_L_PWINDOWTYPE:
predef_target = WINTYPES[w->window_type].name;
break;
case C2_L_PNAME: predef_target = w->name; break;
case C2_L_PCLASSG: predef_target = w->class_general; break;
case C2_L_PCLASSI: predef_target = w->class_instance; break;
case C2_L_PROLE: predef_target = w->role; break;
default: unreachable();
}
if (!predef_target) {
return false;
}
log_verbose("Matching against predefined target %s", predef_target);
return c2_string_op(leaf, predef_target);
}
auto values = &w->c2_state.values[leaf->target_id];
assert(!values->needs_update);
if (!values->valid) {
log_verbose("Property %s not found on window %#010x (%s)", leaf->tgt,
w->client_win, w->name);
return false;
}
if (values->type == C2_PROPERTY_TYPE_ATOM) {
size_t ntargets = 0;
auto targets = c2_values_get_number_targets(values, leaf->index, &ntargets);
for (size_t i = 0; i < ntargets; ++i) {
auto atom = (xcb_atom_t)targets[i];
const char *atom_name = get_atom_name_cached(atoms, atom);
log_verbose("(%zu/%zu) Atom %u is %s", i, ntargets, atom, atom_name);
assert(atom_name != NULL);
if (atom_name && c2_string_op(leaf, atom_name)) {
return true;
}
}
return false;
}
if (values->type != C2_PROPERTY_TYPE_STRING) {
log_verbose("Property %s is not a string", leaf->tgt);
return false;
}
// Not an atom type, value is a list of nul separated strings
if (leaf->index < 0) {
size_t offset = 0;
while (offset < values->length) {
if (c2_string_op(leaf, values->string + offset)) {
return true;
}
offset += strlen(values->string + offset) + 1;
}
return false;
}
size_t offset = 0;
int index = leaf->index;
while (offset < values->length && index != 0) {
offset += strlen(values->string + offset) + 1;
index -= 1;
}
if (index != 0 || values->length == 0) {
// index is out of bounds
return false;
}
return c2_string_op(leaf, values->string + offset);
}
/**
* Match a window against a single leaf window condition.
*
* For internal use.
*/
static inline bool
c2_match_once_leaf(struct c2_state *state, const struct managed_win *w, const c2_l_t *leaf) {
assert(leaf);
const xcb_window_t wid = (leaf->target_on_client ? w->client_win : w->base.id);
// Return if wid is missing
if (leaf->predef == C2_L_PUNDEFINED && !wid) {
log_debug("Window ID missing.");
return false;
}
log_verbose("Matching window %#010x (%s) against condition %s", wid, w->name,
c2_condition_to_str2((c2_ptr_t){.l = (c2_l_t *)leaf, .isbranch = false}));
unsigned int pattern_type = leaf->ptntype;
if (pattern_type == C2_L_PTUNDEFINED) {
auto values = &w->c2_state.values[leaf->target_id];
if (values->type == C2_PROPERTY_TYPE_STRING) {
pattern_type = C2_L_PTSTRING;
} else {
pattern_type = C2_L_PTINT;
}
}
switch (pattern_type) {
// Deal with integer patterns
case C2_L_PTINT: return c2_match_once_leaf_int(w, leaf);
// String patterns
case C2_L_PTSTRING: return c2_match_once_leaf_string(state->atoms, w, leaf);
default: unreachable();
}
}
/**
* Match a window against a single window condition.
*
* @return true if matched, false otherwise.
*/
static bool
c2_match_once(struct c2_state *state, const struct managed_win *w, const c2_ptr_t cond) {
bool result = false;
if (cond.isbranch) {
// Handle a branch (and/or/xor operation)
const c2_b_t *pb = cond.b;
if (!pb) {
return false;
}
log_verbose("Matching window %#010x (%s) against condition %s",
w->base.id, w->name, c2_condition_to_str2(cond));
switch (pb->op) {
case C2_B_OAND:
result = (c2_match_once(state, w, pb->opr1) &&
c2_match_once(state, w, pb->opr2));
break;
case C2_B_OOR:
result = (c2_match_once(state, w, pb->opr1) ||
c2_match_once(state, w, pb->opr2));
break;
case C2_B_OXOR:
result = (c2_match_once(state, w, pb->opr1) !=
c2_match_once(state, w, pb->opr2));
break;
default: unreachable();
}
log_debug("(%#010x): branch: result = %d, pattern = %s", w->base.id,
result, c2_condition_to_str2(cond));
} else {
// A leaf
const c2_l_t *pleaf = cond.l;
if (!pleaf) {
return false;
}
result = c2_match_once_leaf(state, w, pleaf);
log_debug("(%#010x): leaf: result = %d, client = %#010x, "
"pattern = %s",
w->base.id, result, w->client_win, c2_condition_to_str2(cond));
}
// Postprocess the result
if (cond.isbranch ? cond.b->neg : cond.l->neg) {
result = !result;
}
return result;
}
/**
* Match a window against a condition linked list.
*
* @param cache a place to cache the last matched condition
* @param pdata a place to return the data
* @return true if matched, false otherwise.
*/
bool c2_match(struct c2_state *state, const struct managed_win *w,
const c2_lptr_t *condlst, void **pdata) {
// Then go through the whole linked list
for (; condlst; condlst = condlst->next) {
if (c2_match_once(state, w, condlst->ptr)) {
if (pdata) {
*pdata = condlst->data;
}
return true;
}
}
return false;
}
/// Iterate over all conditions in a condition linked list. Call the callback for
/// each of the conditions. If the callback returns true, the iteration stops
/// early.
///
/// Returns whether the iteration was stopped early.
bool c2_list_foreach(const c2_lptr_t *condlist, c2_list_foreach_cb_t cb, void *data) {
for (auto i = condlist; i; i = i->next) {
if (cb(i, data)) {
return true;
}
}
return false;
}
/// Return user data stored in a condition.
void *c2_list_get_data(const c2_lptr_t *condlist) {
return condlist->data;
}
struct c2_state *c2_state_new(struct atom *atoms) {
auto ret = ccalloc(1, struct c2_state);
ret->atoms = atoms;
return ret;
}
void c2_state_free(struct c2_state *state) {
struct c2_tracked_property *property, *tmp;
HASH_ITER(hh, state->tracked_properties, property, tmp) {
HASH_DEL(state->tracked_properties, property);
free(property);
}
free(state->propert_lengths);
free(state->cookies);
free(state);
}
void c2_window_state_init(const struct c2_state *state, struct c2_window_state *window_state) {
auto property_count = HASH_COUNT(state->tracked_properties);
window_state->values = ccalloc(property_count, struct c2_property_value);
for (size_t i = 0; i < property_count; i++) {
window_state->values[i].needs_update = true;
window_state->values[i].valid = false;
}
}
void c2_window_state_destroy(const struct c2_state *state,
struct c2_window_state *window_state) {
size_t property_count = HASH_COUNT(state->tracked_properties);
for (size_t i = 0; i < property_count; i++) {
auto values = &window_state->values[i];
if (values->type == C2_PROPERTY_TYPE_STRING) {
free(window_state->values[i].string);
} else if (values->length > ARR_SIZE(values->numbers)) {
free(window_state->values[i].array);
}
}
free(window_state->values);
}
void c2_window_state_mark_dirty(const struct c2_state *state,
struct c2_window_state *window_state, xcb_atom_t property,
bool is_on_client) {
struct c2_tracked_property *p;
struct c2_tracked_property_key key = {
.property = property,
.is_on_client = is_on_client,
};
HASH_FIND(hh, state->tracked_properties, &key, sizeof(key), p);
if (p) {
window_state->values[p->id].needs_update = true;
}
}
static void
c2_window_state_update_one_from_reply(struct c2_state *state,
struct c2_property_value *value, xcb_atom_t property,
xcb_get_property_reply_t *reply, xcb_connection_t *c) {
auto len = to_u32_checked(xcb_get_property_value_length(reply));
void *data = xcb_get_property_value(reply);
bool property_is_string = x_is_type_string(state->atoms, reply->type);
value->needs_update = false;
value->valid = false;
if (reply->type == XCB_ATOM_NONE) {
// Property doesn't exist on this window
log_verbose("Property %s doesn't exist on this window",
get_atom_name_cached(state->atoms, property));
return;
}
if ((property_is_string && reply->format != 8) ||
(reply->format != 8 && reply->format != 16 && reply->format != 32)) {
log_error("Invalid property type and format combination: property %s, "
"type: %s, format: %d.",
get_atom_name_cached(state->atoms, property),
get_atom_name_cached(state->atoms, reply->type), reply->format);
return;
}
log_verbose("Updating property %s, length = %u, format = %d",
get_atom_name_cached(state->atoms, property), len, reply->format);
value->valid = true;
if (len == 0) {
value->length = 0;
return;
}
if (property_is_string) {
bool nul_terminated = ((char *)data)[len - 1] == '\0';
value->length = len;
value->type = C2_PROPERTY_TYPE_STRING;
if (!nul_terminated) {
value->length += 1;
}
value->string = crealloc(value->string, value->length);
memcpy(value->string, data, len);
if (!nul_terminated) {
value->string[len] = '\0';
}
} else {
size_t step = reply->format / 8;
bool is_signed = reply->type == XCB_ATOM_INTEGER;
value->length = len * 8 / reply->format;
if (reply->type == XCB_ATOM_ATOM) {
value->type = C2_PROPERTY_TYPE_ATOM;
} else {
value->type = C2_PROPERTY_TYPE_NUMBER;
}
int64_t *storage = value->numbers;
if (value->length > ARR_SIZE(value->numbers)) {
if (value->capacity < value->length) {
value->array = crealloc(value->array, value->length);
value->capacity = value->length;
}
storage = value->array;
}
for (uint32_t i = 0; i < value->length; i++) {
auto item = (char *)data + i * step;
if (is_signed) {
switch (reply->format) {
case 8: storage[i] = *(int8_t *)item; break;
case 16: storage[i] = *(int16_t *)item; break;
case 32: storage[i] = *(int32_t *)item; break;
default: unreachable();
}
} else {
switch (reply->format) {
case 8: storage[i] = *(uint8_t *)item; break;
case 16: storage[i] = *(uint16_t *)item; break;
case 32: storage[i] = *(uint32_t *)item; break;
default: unreachable();
}
}
log_verbose("Property %s[%d] = %" PRId64,
get_atom_name_cached(state->atoms, property), i,
storage[i]);
if (reply->type == XCB_ATOM_ATOM) {
// Prefetch the atom name so it will be available
// during `c2_match`. We don't need the return value here.
get_atom_name(state->atoms, (xcb_atom_t)storage[i], c);
}
}
}
}
static void c2_window_state_update_from_replies(struct c2_state *state,
struct c2_window_state *window_state,
xcb_connection_t *c, xcb_window_t client_win,
xcb_window_t frame_win, bool refetch) {
HASH_ITER2(state->tracked_properties, p) {
if (!window_state->values[p->id].needs_update) {
continue;
}
xcb_window_t window = p->key.is_on_client ? client_win : frame_win;
xcb_get_property_reply_t *reply =
xcb_get_property_reply(c, state->cookies[p->id], NULL);
if (!reply) {
log_warn("Failed to get property %d for window %#010x, some "
"window rules might not work.",
p->id, window);
window_state->values[p->id].valid = false;
window_state->values[p->id].needs_update = false;
continue;
}
bool property_is_string = x_is_type_string(state->atoms, reply->type);
if (reply->bytes_after > 0 && (property_is_string || p->max_indices < 0)) {
if (!refetch) {
log_warn("Did property %d for window %#010x change while "
"we were fetching it? some window rules might "
"not work.",
p->id, window);
window_state->values[p->id].valid = false;
window_state->values[p->id].needs_update = false;
} else {
state->propert_lengths[p->id] += reply->bytes_after;
state->cookies[p->id] = xcb_get_property(
c, 0, window, p->key.property, XCB_GET_PROPERTY_TYPE_ANY,
0, (state->propert_lengths[p->id] + 3) / 4);
}
} else {
c2_window_state_update_one_from_reply(
state, &window_state->values[p->id], p->key.property, reply, c);
}
free(reply);
}
}
void c2_window_state_update(struct c2_state *state, struct c2_window_state *window_state,
xcb_connection_t *c, xcb_window_t client_win,
xcb_window_t frame_win) {
size_t property_count = HASH_COUNT(state->tracked_properties);
if (!state->cookies) {
state->cookies = ccalloc(property_count, xcb_get_property_cookie_t);
}
if (!state->propert_lengths) {
state->propert_lengths = ccalloc(property_count, uint32_t);
}
memset(state->cookies, 0, property_count * sizeof(xcb_get_property_cookie_t));
log_verbose("Updating c2 window state for window %#010x (frame %#010x)",
client_win, frame_win);
// Because we don't know the length of all properties (i.e. if they are string
// properties, or for properties matched with `[*]`). We do this in 3 steps:
// 1. Send requests to all properties we need. Use `max_indices` to determine
// the length, or use 0 if it's unknown.
// 2. From the replies to (1), for properties we know the length of, we update
// the values. For those we don't, use the length information from the
// replies to send a new request with the correct length.
// 3. Update the rest of the properties.
// Step 1
HASH_ITER2(state->tracked_properties, p) {
if (!window_state->values[p->id].needs_update) {
continue;
}
uint32_t length = 0;
if (p->max_indices >= 0) {
// length is in 4 bytes units
length = (uint32_t)p->max_indices + 1;
}
xcb_window_t window = p->key.is_on_client ? client_win : frame_win;
// xcb_get_property long_length is in units of 4-byte,
// so use `ceil(length / 4)`. same below.
state->cookies[p->id] = xcb_get_property(
c, 0, window, p->key.property, XCB_GET_PROPERTY_TYPE_ANY, 0, length);
state->propert_lengths[p->id] = length * 4;
}
// Step 2
c2_window_state_update_from_replies(state, window_state, c, client_win, frame_win, true);
// Step 3
c2_window_state_update_from_replies(state, window_state, c, client_win, frame_win,
false);
}
bool c2_state_is_property_tracked(struct c2_state *state, xcb_atom_t property) {
struct c2_tracked_property *p;
struct c2_tracked_property_key key = {
.property = property,
.is_on_client = true,
};
HASH_FIND(hh, state->tracked_properties, &key, sizeof(key), p);
if (p != NULL) {
return true;
}
key.is_on_client = false;
HASH_FIND(hh, state->tracked_properties, &key, sizeof(key), p);
return p != NULL;
}
View Git Blame Copy Permalink