test/at_spi2_tool.c

   1 #include "atspi/atspi.h"
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <getopt.h>
   6 #include <stdbool.h>
   7
   8 #define ERROR_STATE -1
   9 #define SAFE_BUFFER_SIZE 255
  10 #define CHECK_OUTPUT_WIDTH 42
  11 #define MINIMAL_MODULE_WIDTH 3
  12 #define ATTR_WIDTH 50
  13 #define NUMBER_WIDTH 6
  14 #define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
  15 #define COLUMN_NO 3
  16 #define FLAG_NO 3
  17 #define DUMP 0
  18 #define CHECK 1
  19 #define FIRST_MATCH 2
  20 #define VERSION "1.1"
  21
  22 static unsigned indent_width = 2;
  23 static int module_name_limit = -1;
  24
  25 static const char* atspi_state_names[] = {
  26         [ATSPI_STATE_INVALID] = "INVALID",
  27         [ATSPI_STATE_ACTIVE] = "ACTIVE",
  28         [ATSPI_STATE_ARMED] = "ARMED",
  29         [ATSPI_STATE_BUSY] =  "BUSY",
  30         [ATSPI_STATE_CHECKED] = "CHECKED",
  31         [ATSPI_STATE_COLLAPSED] = "COLLAPSED",
  32         [ATSPI_STATE_DEFUNCT] = "DEFUNCT",
  33         [ATSPI_STATE_EDITABLE] = "EDITABLE",
  34         [ATSPI_STATE_ENABLED] = "ENABLED",
  35         [ATSPI_STATE_EXPANDABLE] = "EXPANDABLE",
  36         [ATSPI_STATE_EXPANDED] = "EXPANDED",
  37         [ATSPI_STATE_FOCUSABLE] = "FOCUSABLE",
  38         [ATSPI_STATE_FOCUSED] = "FOCUSED",
  39         [ATSPI_STATE_HAS_TOOLTIP] = "HAS_TOOLTIP",
  40         [ATSPI_STATE_HORIZONTAL] = "HORIZONTAL",
  41         [ATSPI_STATE_ICONIFIED] = "ICONIFIED",
  42         [ATSPI_STATE_MULTI_LINE] = "MULTI_LINE",
  43         [ATSPI_STATE_MULTISELECTABLE] = "MULTISELECTABLE",
  44         [ATSPI_STATE_OPAQUE] = "OPAQUE",
  45         [ATSPI_STATE_PRESSED] = "PRESSED",
  46         [ATSPI_STATE_RESIZABLE] = "RESIZABLE",
  47         [ATSPI_STATE_SELECTABLE] = "SELECTABLE",
  48         [ATSPI_STATE_SELECTED] = "SELECTED",
  49         [ATSPI_STATE_SENSITIVE] = "SENSITIVE",
  50         [ATSPI_STATE_SHOWING] = "SHOWING",
  51         [ATSPI_STATE_SINGLE_LINE] = "SINGLE_LINE",
  52         [ATSPI_STATE_STALE] = "STALE",
  53         [ATSPI_STATE_TRANSIENT] = "TRANSIENT",
  54         [ATSPI_STATE_VERTICAL] = "VERTICAL",
  55         [ATSPI_STATE_VISIBLE] = "VISIBLE",
  56         [ATSPI_STATE_MANAGES_DESCENDANTS] = "MANAGES_DESCENDANTS",
  57         [ATSPI_STATE_INDETERMINATE] = "INDETERMINATE",
  58         [ATSPI_STATE_REQUIRED] = "REQUIRED",
  59         [ATSPI_STATE_TRUNCATED] = "TRUNCATED",
  60         [ATSPI_STATE_ANIMATED] = "ANIMATED",
  61         [ATSPI_STATE_INVALID_ENTRY] = "INVALID_ENTRY",
  62         [ATSPI_STATE_SUPPORTS_AUTOCOMPLETION] = "SUPPORTS_AUTOCOMPLETION",
  63         [ATSPI_STATE_SELECTABLE_TEXT] = "SELECTABLE_TEXT",
  64         [ATSPI_STATE_IS_DEFAULT] = "IS_DEFAULT",
  65         [ATSPI_STATE_VISITED] = "VISITED",
  66         [ATSPI_STATE_CHECKABLE] = "CHECKABLE",
  67         [ATSPI_STATE_MODAL] = "MODAL",
  68         [ATSPI_STATE_HIGHLIGHTED] = "HIGHLIGHTED",
  69         [ATSPI_STATE_HIGHLIGHTABLE] = "HIGHLIGHTABLE",
  70         [ATSPI_STATE_HAS_POPUP] = "HAS_POPUP",
  71         [ATSPI_STATE_READ_ONLY] = "READ_ONLY",
  72         [ATSPI_STATE_LAST_DEFINED] = "LAST_DEFINED"
  73 };
  74
  75 typedef struct _Box_Size {
  76         char *x;
  77         char *y;
  78         char *height;
  79         char *width;
  80 } Box_Size;
  81
  82 char *_strdup(const char *c)
  83 {
  84         char *result = (char *)calloc(1, strlen(c) + 1);
  85         return result ? strcpy(result, c) : result;
  86 }
  87
  88 static char *_multiply_string(char c, unsigned number)
  89 {
  90         char *result = (char *)calloc(1, number + 1);
  91
  92         if (result == NULL)
  93                 return result;
  94
  95         memset(result, c, number);
  96
  97         return result;
  98 }
  99
 100 static void _print_module_legend()
 101 {
 102         printf("\n[[node role name],[attributes list],[x,y,width,height],[node name],[states list]]\n\n");
 103 }
 104
 105 static void _print_atspi_states_legend()
 106 {
 107         _print_module_legend();
 108
 109         int array_len = ARRAY_SIZE(atspi_state_names);
 110         int line_count = (array_len + COLUMN_NO - 1)/COLUMN_NO;
 111         for (int line_idx = 0; line_idx < line_count; line_idx++) {
 112                 if ((line_idx < line_count - 1) || (array_len % COLUMN_NO == 0)) {
 113                         printf("[%d]\t%-24s[%d]\t%-24s[%d]\t%s\n",
 114                                         line_idx * COLUMN_NO,
 115                                         atspi_state_names[line_idx * COLUMN_NO],
 116                                         (line_idx * COLUMN_NO) + 1,
 117                                         atspi_state_names[(line_idx * COLUMN_NO) + 1],
 118                                         (line_idx * COLUMN_NO) + 2,
 119                                         atspi_state_names[(line_idx * COLUMN_NO) + 2]);
 120                 } else if (array_len % COLUMN_NO == 2) {
 121                         printf("[%d]\t%-24s[%d]\t%s\n",
 122                                         line_idx * COLUMN_NO,
 123                                         atspi_state_names[line_idx * COLUMN_NO],
 124                                         (line_idx * COLUMN_NO) + 1,
 125                                         atspi_state_names[(line_idx * COLUMN_NO) + 1]);
 126                 } else {
 127                         printf("[%d]\t%s\n", line_idx * COLUMN_NO, atspi_state_names[line_idx * COLUMN_NO]);
 128                 }
 129         }
 130 }
 131
 132 static void _set_indent(int indent_size)
 133 {
 134         if (indent_size < 0) {
 135                 fprintf(stderr, "WARNING: Invalid indent size. Default value retained.\n");
 136                 return;
 137         }
 138
 139         indent_width = indent_size;
 140 }
 141
 142 static void _set_module_length_limit(int limit)
 143 {
 144         if (limit < MINIMAL_MODULE_WIDTH) {
 145                 fprintf(stderr, "WARNING: Invalid maximum field size. Default value retained.\n");
 146                 return;
 147         }
 148
 149         module_name_limit = limit;
 150 }
 151
 152 static int _int_sort_function(gconstpointer a, gconstpointer b)
 153 {
 154         int int_a = GPOINTER_TO_INT (a);
 155         int int_b = GPOINTER_TO_INT (b);
 156
 157         return int_a - int_b;
 158 }
 159
 160 static void _truncate_string(char *string, int length_limit)
 161 {
 162         if (length_limit < MINIMAL_MODULE_WIDTH || !string)
 163                 return;
 164
 165         int len = strlen(string);
 166
 167         if (len > length_limit)
 168                 memcpy(string + length_limit - 3, "...", 4);
 169 }
 170
 171 static size_t _combine_strings(char **destination, const char *source)
 172 {
 173         if (!source || !*source || !destination)
 174                 return 0;
 175
 176         size_t old_len = *destination ? strlen(*destination) : 0;
 177         size_t source_len = strlen(source);
 178         size_t len = old_len + source_len;
 179         char *buf = realloc(*destination, (len + 1) * sizeof(char));
 180
 181         if (!buf) {
 182                 fprintf(stderr, "_combine_strings: allocation failed");
 183                 return old_len;
 184         }
 185
 186         memcpy(buf + old_len, source, source_len + 1);
 187
 188         *destination = buf;
 189
 190         return len;
 191 }
 192
 193 static Box_Size *_get_box_size(AtspiAccessible *node)
 194 {
 195         Box_Size *box_size = (Box_Size *)malloc(sizeof(Box_Size));
 196         if (box_size == NULL)
 197                 return NULL;
 198
 199         char *x = NULL;
 200         char *y = NULL;
 201         char *width = NULL;
 202         char *height = NULL;
 203
 204         AtspiComponent *component = atspi_accessible_get_component_iface(node);
 205         AtspiRect *extent = component ? atspi_component_get_extents(component, ATSPI_COORD_TYPE_SCREEN, NULL) : NULL;
 206
 207         if (extent == NULL) {
 208                 _combine_strings(&x, "_");
 209                 _combine_strings(&y, "_");
 210                 _combine_strings(&width, "_");
 211                 _combine_strings(&height, "_");
 212         } else {
 213                 char temp_buff[NUMBER_WIDTH];
 214
 215                 snprintf(temp_buff, NUMBER_WIDTH, "%d", extent->x);
 216                 _combine_strings(&x, temp_buff);
 217
 218                 snprintf(temp_buff, NUMBER_WIDTH, "%d", extent->y);
 219                 _combine_strings(&y, temp_buff);
 220
 221                 snprintf(temp_buff, NUMBER_WIDTH, "%d", extent->width);
 222                 _combine_strings(&width, temp_buff);
 223
 224                 snprintf(temp_buff, NUMBER_WIDTH, "%d", extent->height);
 225                 _combine_strings(&height, temp_buff);
 226
 227                 g_object_unref(component);
 228                 g_free(extent);
 229         }
 230
 231         box_size->x = x;
 232         box_size->y = y;
 233         box_size->width = width;
 234         box_size->height = height;
 235
 236         return box_size;
 237 }
 238
 239 static char *_get_states(AtspiAccessible *node)
 240 {
 241         AtspiStateSet *node_state_set = atspi_accessible_get_state_set(node);
 242         GArray *states = atspi_state_set_get_states(node_state_set);
 243         g_array_sort(states, _int_sort_function);
 244
 245         AtspiStateType state_type;
 246         char *state_string = NULL;
 247
 248         for (int i = 0; states && (i < states->len); i++) {
 249                 state_type = g_array_index(states, AtspiStateType, i);
 250
 251                 char node_state_str[8];
 252                 sprintf(node_state_str, "(%d)", state_type);
 253                 _combine_strings(&state_string, node_state_str);
 254         }
 255
 256         g_array_free(states, 0);
 257         g_object_unref(node_state_set);
 258
 259         return state_string;
 260 }
 261
 262 static char *_get_attributes(AtspiAccessible *node)
 263 {
 264         GHashTable *attributes = NULL;
 265         attributes = atspi_accessible_get_attributes(node, NULL);
 266
 267         if (!attributes)
 268                 return NULL;
 269
 270         GHashTableIter attributes_iter;
 271         gpointer attr_key;
 272         gpointer attr_value;
 273         g_hash_table_iter_init (&attributes_iter, attributes);
 274         char *result = NULL;
 275         while (g_hash_table_iter_next (&attributes_iter, &attr_key, &attr_value)) {
 276                 char attributes_string[ATTR_WIDTH];
 277                 int ret = snprintf(attributes_string, ATTR_WIDTH, "(%s=%s)", (char*)attr_key, (char*)attr_value);
 278                 if (ret >= ATTR_WIDTH) {
 279                         fprintf(stderr, "_get_attributes: generated string is too long. Buffer overflow");
 280                         abort();
 281                 }
 282                 _combine_strings(&result, attributes_string);
 283         }
 284         g_hash_table_unref(attributes);
 285
 286         return result;
 287 }
 288
 289 static char *_get_info(AtspiAccessible *node, int length_limit)
 290 {
 291         if (!node)
 292                 return NULL;
 293
 294         char *node_name = atspi_accessible_get_name(node, NULL);
 295         char *node_role_name = atspi_accessible_get_role_name(node, NULL);
 296
 297         char *attributes = _get_attributes(node);
 298         _truncate_string(attributes, length_limit);
 299         Box_Size *box_size = _get_box_size(node);
 300         char *states = _get_states(node);
 301         _truncate_string(states, length_limit);
 302
 303         char result[SAFE_BUFFER_SIZE];
 304         int ret = snprintf(result, SAFE_BUFFER_SIZE, "[[%s],[%s],[%s,%s,%s,%s],[%s],[%s]]",
 305                                                                                 node_role_name,
 306                                                                                 attributes,
 307                                                                                 box_size->x,
 308                                                                                 box_size->y,
 309                                                                                 box_size->width,
 310                                                                                 box_size->height,
 311                                                                                 node_name,
 312                                                                                 states);
 313
 314         if (ret >= SAFE_BUFFER_SIZE) {
 315                 fprintf(stderr, "_get_info: generated string is too long. Buffer overflow");
 316                 abort();
 317         }
 318
 319         free(node_name);
 320         free(node_role_name);
 321         free(attributes);
 322         if (box_size) {
 323                 free(box_size->width);
 324                 free(box_size->height);
 325                 free(box_size);
 326         }
 327         free(states);
 328
 329         return _strdup(result);
 330 }
 331
 332 static void _test_atspi_parent_child_relation(AtspiAccessible *obj, AtspiAccessible *parent_candidate, int parent_candidate_index)
 333 {
 334         int parent_index = atspi_accessible_get_index_in_parent(obj, NULL);
 335         AtspiAccessible *parent = atspi_accessible_get_parent(obj, NULL);
 336
 337         char output[CHECK_OUTPUT_WIDTH];
 338         if (parent_index != parent_candidate_index || parent_candidate != parent) {
 339                 char parent_status[NUMBER_WIDTH];
 340
 341                 if (parent == NULL)
 342                         strcpy(parent_status, "_");
 343                 else
 344                         snprintf(parent_status, NUMBER_WIDTH, "%d", parent_index);
 345
 346                 snprintf(output, CHECK_OUTPUT_WIDTH, "[FAIL<%d,%s><%p,%p>]", parent_candidate_index, parent_status, parent_candidate, parent);
 347
 348         } else {
 349                 snprintf(output, CHECK_OUTPUT_WIDTH, "[OK]");
 350         }
 351
 352         printf("%-*s\t", CHECK_OUTPUT_WIDTH, output);
 353 }
 354
 355 static int _print_atspi_tree_verify_maybe_r(int indent_number, AtspiAccessible *object, bool check_integrity, int length_limit)
 356 {
 357         char *indent = _multiply_string(' ', indent_number*indent_width);
 358         if (indent != NULL) {
 359                 printf("%s", indent);
 360                 free(indent);
 361         }
 362
 363         char *node_info = _get_info(object, length_limit);
 364         if (node_info != NULL) {
 365                 printf("%s\n", node_info);
 366                 free(node_info);
 367         }
 368
 369         int count = atspi_accessible_get_child_count(object, NULL);
 370         for (int i = 0; i < count; i++) {
 371                 AtspiAccessible *child = atspi_accessible_get_child_at_index(object, i, NULL);
 372                 if (child) {
 373                         if (check_integrity)
 374                                 _test_atspi_parent_child_relation(child, object, i);
 375
 376                         _print_atspi_tree_verify_maybe_r(indent_number + 1, child, check_integrity, length_limit);
 377                 }
 378         }
 379         return 0;
 380 }
 381
 382 void _print_help()
 383 {
 384         printf("AT-SPI2-CORE-UTIL\n\n");
 385         printf("USAGE: at_spi2_tool [OPTION] [PARAMETER] ...\n\n");
 386         printf("OPTION LIST:\n");
 387         printf("-h, --help\t\tshow this message\n");
 388         printf("-v, --version\t\tshow actual version of tool\n");
 389         printf("-g, --show-legend\tprint AT-SPI state legend\n");
 390         printf("-l, --list-apps\t\tlist all applications of desktop\n");
 391         printf("-d, --tree-dump\t\tdump tree for selected application\n");
 392         printf("-c, --tree-check\tcheck tree for selected application\n");
 393         printf("-f, --first-match\tperform dump or check only for first matching application\n");
 394         printf("-i, --indent\t\tset indentation size, default value stands at 2\n");
 395         printf("-t, --truncate\t\tset maximum single field size, default value stands at 30\n");
 396         printf("\nEXAMPLE:\n");
 397         printf("\tat_spi2_tool -i3 -d quickpanel\n");
 398         printf("\t  show AT-SPI tree for node \"quickpanel\" using three-space indentation\n");
 399         printf("\tat_spi2_tool -i1 -c starter\n");
 400         printf("\t  show AT-SPI tree with integrity test for node \"starter\" using one-space indentation\n");
 401 }
 402 void _print_version()
 403 {
 404         printf("AT-SPI2-CORE-UTIL v%s\n", VERSION);
 405 }
 406
 407 static void _atspi_tree_traverse(AtspiAccessible *desktop, const char *app_name, bool dump, bool check, bool first_match, int length_limit)
 408 {
 409         int count = atspi_accessible_get_child_count(desktop, NULL);
 410         bool app_name_matched = false;
 411         for (int i = 0; i < count; i++) {
 412                 AtspiAccessible *child = atspi_accessible_get_child_at_index(desktop, i, NULL);
 413                 if (child) {
 414                         char *name = atspi_accessible_get_name(child, NULL);
 415
 416                         if (!dump && !check) {
 417                                 printf("%s\n", name);
 418                         }
 419
 420                         if ((check || dump) && name && !strcmp(name, app_name)) {
 421                                 app_name_matched = true;
 422
 423                                 _print_module_legend();
 424
 425                                 if (check)
 426                                         _test_atspi_parent_child_relation(child, desktop, i);
 427
 428                                 _print_atspi_tree_verify_maybe_r(0, child, check, length_limit);
 429
 430                                 if (first_match) {
 431                                         free(name);
 432                                         break;
 433                                 } else
 434                                         printf("\n");
 435                         }
 436                         free(name);
 437                 }
 438         }
 439
 440         if (!app_name_matched && (dump || check))
 441                 fprintf(stderr, "There is no application with name: %s. Try again.\n", app_name);
 442 }
 443
 444 static void _run_command(int argc, char *argv[], AtspiAccessible *desktop)
 445 {
 446         struct option long_options[] = {
 447                 {"help", no_argument, 0, 'h'},
 448                 {"version", no_argument, 0, 'v'},
 449                 {"show-legend", no_argument, 0, 'g'},
 450                 {"list-apps", no_argument, 0, 'l'},
 451                 {"tree-dump", required_argument, 0, 'd'},
 452                 {"tree-check", required_argument, 0, 'c'},
 453                 {"first-match", no_argument, 0, 'f'},
 454                 {"indent", required_argument, 0, 'i'},
 455                 {"truncate", required_argument, 0, 't'},
 456         };
 457
 458         int command = 0;
 459         int option_index = 0;
 460         bool traverse_flags[FLAG_NO] = {false};
 461         char *app_name = NULL;
 462
 463         while (TRUE) {
 464                 command = getopt_long(argc, argv, "hvgld:c:ft:i:", long_options, &option_index);
 465
 466                 if (command == ERROR_STATE)
 467                         break;
 468
 469                 switch (command) {
 470                 case 'h':
 471                         _print_help();
 472                         break;
 473
 474                 case 'v':
 475                         _print_version();
 476                         break;
 477
 478                 case 'g':
 479                         _print_atspi_states_legend();
 480                         break;
 481
 482                 case 'l':
 483                         _atspi_tree_traverse(desktop, NULL, false, false, false, module_name_limit);
 484                         break;
 485
 486                 case 'd':
 487                         traverse_flags[DUMP] = true;
 488                         app_name = optarg;
 489                         break;
 490
 491                 case 'c':
 492                         traverse_flags[CHECK] = true;
 493                         app_name = optarg;
 494                         break;
 495
 496                 case 'f':
 497                         traverse_flags[FIRST_MATCH] = true;
 498                         break;
 499
 500                 case 'i':
 501                         _set_indent(atoi(optarg));
 502                         break;
 503
 504                 case 't':
 505                         _set_module_length_limit(atoi(optarg));
 506                         break;
 507
 508                 case '?':
 509                         fprintf(stderr, "Invalid parameter. Use: \"--help\"\n");
 510                         break;
 511
 512                 default:
 513                         abort();
 514                 }
 515         }
 516
 517         if (traverse_flags[DUMP] || traverse_flags[CHECK])
 518                 _atspi_tree_traverse(desktop, app_name, traverse_flags[DUMP], traverse_flags[CHECK], traverse_flags[FIRST_MATCH], module_name_limit);
 519 }
 520
 521 int main(int argc, char *argv[])
 522 {
 523         if (argc < 2) {
 524                 printf("Arguments required. Type %s --help.\n", argv[0]);
 525                 return -1;
 526         }
 527
 528         int result = atspi_init();
 529         if (result != 0)
 530         {
 531                 fprintf(stderr, "Unable to initilize AT-SPI infrastructure, atspi_init failed\n");
 532                 return -1;
 533         }
 534
 535         AtspiAccessible *desktop = atspi_get_desktop(0);
 536         if (!desktop) {
 537                 fprintf(stderr, "atspi_get_desktop failed\n");
 538                 return -1;
 539         }
 540
 541         _run_command(argc, argv, desktop);
 542
 543         return 0;
 544 }