diff options
| -rw-r--r-- | packet-x11-keysymdef.h | 2168 | ||||
| -rw-r--r-- | packet-x11.c | 2280 | ||||
| -rw-r--r-- | x11-fields | 56 |
3 files changed, 3947 insertions, 557 deletions
diff --git a/packet-x11-keysymdef.h b/packet-x11-keysymdef.h new file mode 100644 index 0000000000..4e390d4d53 --- /dev/null +++ b/packet-x11-keysymdef.h @@ -0,0 +1,2168 @@ +/* packet-x11-keysymdef.h + * Key symbol definitions for X11 (XFree86 distribution: keysymdef.h) + * Copyright holders: Digital, The Open Group + * (see below for their copyright statement) + * + * $Id: packet-x11-keysymdef.h,v 1.1 2004/01/02 12:52:45 obiot Exp $ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program 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 2 + * of the License, or (at your option) any later version. + * + * This program 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* $TOG: keysymdef.h /main/28 1998/05/22 16:18:01 kaleb $ */ + +/*********************************************************** +Copyright 1987, 1994, 1998 The Open Group + +All Rights Reserved. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ +/* $XFree86: xc/include/keysymdef.h,v 1.10 2000/10/27 18:30:46 dawes Exp $ */ + +#define XK_VoidSymbol 0xFFFFFF /* void symbol */ + +#define XK_MISCELLANY +#ifdef XK_MISCELLANY +/* + * TTY Functions, cleverly chosen to map to ascii, for convenience of + * programming, but could have been arbitrary (at the cost of lookup + * tables in client code. + */ + +#define XK_BackSpace 0xFF08 /* back space, back char */ +#define XK_Tab 0xFF09 +#define XK_Linefeed 0xFF0A /* Linefeed, LF */ +#define XK_Clear 0xFF0B +#define XK_Return 0xFF0D /* Return, enter */ +#define XK_Pause 0xFF13 /* Pause, hold */ +#define XK_Scroll_Lock 0xFF14 +#define XK_Sys_Req 0xFF15 +#define XK_Escape 0xFF1B +#define XK_Delete 0xFFFF /* Delete, rubout */ + + + +/* International & multi-key character composition */ + +#define XK_Multi_key 0xFF20 /* Multi-key character compose */ +#define XK_Codeinput 0xFF37 +#define XK_SingleCandidate 0xFF3C +#define XK_MultipleCandidate 0xFF3D +#define XK_PreviousCandidate 0xFF3E + +/* Japanese keyboard support */ + +#define XK_Kanji 0xFF21 /* Kanji, Kanji convert */ +#define XK_Muhenkan 0xFF22 /* Cancel Conversion */ +#define XK_Henkan_Mode 0xFF23 /* Start/Stop Conversion */ +#define XK_Henkan 0xFF23 /* Alias for Henkan_Mode */ +#define XK_Romaji 0xFF24 /* to Romaji */ +#define XK_Hiragana 0xFF25 /* to Hiragana */ +#define XK_Katakana 0xFF26 /* to Katakana */ +#define XK_Hiragana_Katakana 0xFF27 /* Hiragana/Katakana toggle */ +#define XK_Zenkaku 0xFF28 /* to Zenkaku */ +#define XK_Hankaku 0xFF29 /* to Hankaku */ +#define XK_Zenkaku_Hankaku 0xFF2A /* Zenkaku/Hankaku toggle */ +#define XK_Touroku 0xFF2B /* Add to Dictionary */ +#define XK_Massyo 0xFF2C /* Delete from Dictionary */ +#define XK_Kana_Lock 0xFF2D /* Kana Lock */ +#define XK_Kana_Shift 0xFF2E /* Kana Shift */ +#define XK_Eisu_Shift 0xFF2F /* Alphanumeric Shift */ +#define XK_Eisu_toggle 0xFF30 /* Alphanumeric toggle */ +#define XK_Kanji_Bangou 0xFF37 /* Codeinput */ +#define XK_Zen_Koho 0xFF3D /* Multiple/All Candidate(s) */ +#define XK_Mae_Koho 0xFF3E /* Previous Candidate */ + +/* 0xFF31 thru 0xFF3F are under XK_KOREAN */ + +/* Cursor control & motion */ + +#define XK_Home 0xFF50 +#define XK_Left 0xFF51 /* Move left, left arrow */ +#define XK_Up 0xFF52 /* Move up, up arrow */ +#define XK_Right 0xFF53 /* Move right, right arrow */ +#define XK_Down 0xFF54 /* Move down, down arrow */ +#define XK_Prior 0xFF55 /* Prior, previous */ +#define XK_Page_Up 0xFF55 +#define XK_Next 0xFF56 /* Next */ +#define XK_Page_Down 0xFF56 +#define XK_End 0xFF57 /* EOL */ +#define XK_Begin 0xFF58 /* BOL */ + + +/* Misc Functions */ + +#define XK_Select 0xFF60 /* Select, mark */ +#define XK_Print 0xFF61 +#define XK_Execute 0xFF62 /* Execute, run, do */ +#define XK_Insert 0xFF63 /* Insert, insert here */ +#define XK_Undo 0xFF65 /* Undo, oops */ +#define XK_Redo 0xFF66 /* redo, again */ +#define XK_Menu 0xFF67 +#define XK_Find 0xFF68 /* Find, search */ +#define XK_Cancel 0xFF69 /* Cancel, stop, abort, exit */ +#define XK_Help 0xFF6A /* Help */ +#define XK_Break 0xFF6B +#define XK_Mode_switch 0xFF7E /* Character set switch */ +#define XK_script_switch 0xFF7E /* Alias for mode_switch */ +#define XK_Num_Lock 0xFF7F + +/* Keypad Functions, keypad numbers cleverly chosen to map to ascii */ + +#define XK_KP_Space 0xFF80 /* space */ +#define XK_KP_Tab 0xFF89 +#define XK_KP_Enter 0xFF8D /* enter */ +#define XK_KP_F1 0xFF91 /* PF1, KP_A, ... */ +#define XK_KP_F2 0xFF92 +#define XK_KP_F3 0xFF93 +#define XK_KP_F4 0xFF94 +#define XK_KP_Home 0xFF95 +#define XK_KP_Left 0xFF96 +#define XK_KP_Up 0xFF97 +#define XK_KP_Right 0xFF98 +#define XK_KP_Down 0xFF99 +#define XK_KP_Prior 0xFF9A +#define XK_KP_Page_Up 0xFF9A +#define XK_KP_Next 0xFF9B +#define XK_KP_Page_Down 0xFF9B +#define XK_KP_End 0xFF9C +#define XK_KP_Begin 0xFF9D +#define XK_KP_Insert 0xFF9E +#define XK_KP_Delete 0xFF9F +#define XK_KP_Equal 0xFFBD /* equals */ +#define XK_KP_Multiply 0xFFAA +#define XK_KP_Add 0xFFAB +#define XK_KP_Separator 0xFFAC /* separator, often comma */ +#define XK_KP_Subtract 0xFFAD +#define XK_KP_Decimal 0xFFAE +#define XK_KP_Divide 0xFFAF + +#define XK_KP_0 0xFFB0 +#define XK_KP_1 0xFFB1 +#define XK_KP_2 0xFFB2 +#define XK_KP_3 0xFFB3 +#define XK_KP_4 0xFFB4 +#define XK_KP_5 0xFFB5 +#define XK_KP_6 0xFFB6 +#define XK_KP_7 0xFFB7 +#define XK_KP_8 0xFFB8 +#define XK_KP_9 0xFFB9 + + + +/* + * Auxilliary Functions; note the duplicate definitions for left and right + * function keys; Sun keyboards and a few other manufactures have such + * function key groups on the left and/or right sides of the keyboard. + * We've not found a keyboard with more than 35 function keys total. + */ + +#define XK_F1 0xFFBE +#define XK_F2 0xFFBF +#define XK_F3 0xFFC0 +#define XK_F4 0xFFC1 +#define XK_F5 0xFFC2 +#define XK_F6 0xFFC3 +#define XK_F7 0xFFC4 +#define XK_F8 0xFFC5 +#define XK_F9 0xFFC6 +#define XK_F10 0xFFC7 +#define XK_F11 0xFFC8 +#define XK_L1 0xFFC8 +#define XK_F12 0xFFC9 +#define XK_L2 0xFFC9 +#define XK_F13 0xFFCA +#define XK_L3 0xFFCA +#define XK_F14 0xFFCB +#define XK_L4 0xFFCB +#define XK_F15 0xFFCC +#define XK_L5 0xFFCC +#define XK_F16 0xFFCD +#define XK_L6 0xFFCD +#define XK_F17 0xFFCE +#define XK_L7 0xFFCE +#define XK_F18 0xFFCF +#define XK_L8 0xFFCF +#define XK_F19 0xFFD0 +#define XK_L9 0xFFD0 +#define XK_F20 0xFFD1 +#define XK_L10 0xFFD1 +#define XK_F21 0xFFD2 +#define XK_R1 0xFFD2 +#define XK_F22 0xFFD3 +#define XK_R2 0xFFD3 +#define XK_F23 0xFFD4 +#define XK_R3 0xFFD4 +#define XK_F24 0xFFD5 +#define XK_R4 0xFFD5 +#define XK_F25 0xFFD6 +#define XK_R5 0xFFD6 +#define XK_F26 0xFFD7 +#define XK_R6 0xFFD7 +#define XK_F27 0xFFD8 +#define XK_R7 0xFFD8 +#define XK_F28 0xFFD9 +#define XK_R8 0xFFD9 +#define XK_F29 0xFFDA +#define XK_R9 0xFFDA +#define XK_F30 0xFFDB +#define XK_R10 0xFFDB +#define XK_F31 0xFFDC +#define XK_R11 0xFFDC +#define XK_F32 0xFFDD +#define XK_R12 0xFFDD +#define XK_F33 0xFFDE +#define XK_R13 0xFFDE +#define XK_F34 0xFFDF +#define XK_R14 0xFFDF +#define XK_F35 0xFFE0 +#define XK_R15 0xFFE0 + +/* Modifiers */ + +#define XK_Shift_L 0xFFE1 /* Left shift */ +#define XK_Shift_R 0xFFE2 /* Right shift */ +#define XK_Control_L 0xFFE3 /* Left control */ +#define XK_Control_R 0xFFE4 /* Right control */ +#define XK_Caps_Lock 0xFFE5 /* Caps lock */ +#define XK_Shift_Lock 0xFFE6 /* Shift lock */ + +#define XK_Meta_L 0xFFE7 /* Left meta */ +#define XK_Meta_R 0xFFE8 /* Right meta */ +#define XK_Alt_L 0xFFE9 /* Left alt */ +#define XK_Alt_R 0xFFEA /* Right alt */ +#define XK_Super_L 0xFFEB /* Left super */ +#define XK_Super_R 0xFFEC /* Right super */ +#define XK_Hyper_L 0xFFED /* Left hyper */ +#define XK_Hyper_R 0xFFEE /* Right hyper */ +#endif /* XK_MISCELLANY */ + +/* + * ISO 9995 Function and Modifier Keys + * Byte 3 = 0xFE + */ + +#define XK_XKB_KEYS +#ifdef XK_XKB_KEYS +#define XK_ISO_Lock 0xFE01 +#define XK_ISO_Level2_Latch 0xFE02 +#define XK_ISO_Level3_Shift 0xFE03 +#define XK_ISO_Level3_Latch 0xFE04 +#define XK_ISO_Level3_Lock 0xFE05 +#define XK_ISO_Group_Shift 0xFF7E /* Alias for mode_switch */ +#define XK_ISO_Group_Latch 0xFE06 +#define XK_ISO_Group_Lock 0xFE07 +#define XK_ISO_Next_Group 0xFE08 +#define XK_ISO_Next_Group_Lock 0xFE09 +#define XK_ISO_Prev_Group 0xFE0A +#define XK_ISO_Prev_Group_Lock 0xFE0B +#define XK_ISO_First_Group 0xFE0C +#define XK_ISO_First_Group_Lock 0xFE0D +#define XK_ISO_Last_Group 0xFE0E +#define XK_ISO_Last_Group_Lock 0xFE0F + +#define XK_ISO_Left_Tab 0xFE20 +#define XK_ISO_Move_Line_Up 0xFE21 +#define XK_ISO_Move_Line_Down 0xFE22 +#define XK_ISO_Partial_Line_Up 0xFE23 +#define XK_ISO_Partial_Line_Down 0xFE24 +#define XK_ISO_Partial_Space_Left 0xFE25 +#define XK_ISO_Partial_Space_Right 0xFE26 +#define XK_ISO_Set_Margin_Left 0xFE27 +#define XK_ISO_Set_Margin_Right 0xFE28 +#define XK_ISO_Release_Margin_Left 0xFE29 +#define XK_ISO_Release_Margin_Right 0xFE2A +#define XK_ISO_Release_Both_Margins 0xFE2B +#define XK_ISO_Fast_Cursor_Left 0xFE2C +#define XK_ISO_Fast_Cursor_Right 0xFE2D +#define XK_ISO_Fast_Cursor_Up 0xFE2E +#define XK_ISO_Fast_Cursor_Down 0xFE2F +#define XK_ISO_Continuous_Underline 0xFE30 +#define XK_ISO_Discontinuous_Underline 0xFE31 +#define XK_ISO_Emphasize 0xFE32 +#define XK_ISO_Center_Object 0xFE33 +#define XK_ISO_Enter 0xFE34 + +#define XK_dead_grave 0xFE50 +#define XK_dead_acute 0xFE51 +#define XK_dead_circumflex 0xFE52 +#define XK_dead_tilde 0xFE53 +#define XK_dead_macron 0xFE54 +#define XK_dead_breve 0xFE55 +#define XK_dead_abovedot 0xFE56 +#define XK_dead_diaeresis 0xFE57 +#define XK_dead_abovering 0xFE58 +#define XK_dead_doubleacute 0xFE59 +#define XK_dead_caron 0xFE5A +#define XK_dead_cedilla 0xFE5B +#define XK_dead_ogonek 0xFE5C +#define XK_dead_iota 0xFE5D +#define XK_dead_voiced_sound 0xFE5E +#define XK_dead_semivoiced_sound 0xFE5F +#define XK_dead_belowdot 0xFE60 +#define XK_dead_hook 0xFE61 +#define XK_dead_horn 0xFE62 + +#define XK_First_Virtual_Screen 0xFED0 +#define XK_Prev_Virtual_Screen 0xFED1 +#define XK_Next_Virtual_Screen 0xFED2 +#define XK_Last_Virtual_Screen 0xFED4 +#define XK_Terminate_Server 0xFED5 + +#define XK_AccessX_Enable 0xFE70 +#define XK_AccessX_Feedback_Enable 0xFE71 +#define XK_RepeatKeys_Enable 0xFE72 +#define XK_SlowKeys_Enable 0xFE73 +#define XK_BounceKeys_Enable 0xFE74 +#define XK_StickyKeys_Enable 0xFE75 +#define XK_MouseKeys_Enable 0xFE76 +#define XK_MouseKeys_Accel_Enable 0xFE77 +#define XK_Overlay1_Enable 0xFE78 +#define XK_Overlay2_Enable 0xFE79 +#define XK_AudibleBell_Enable 0xFE7A + +#define XK_Pointer_Left 0xFEE0 +#define XK_Pointer_Right 0xFEE1 +#define XK_Pointer_Up 0xFEE2 +#define XK_Pointer_Down 0xFEE3 +#define XK_Pointer_UpLeft 0xFEE4 +#define XK_Pointer_UpRight 0xFEE5 +#define XK_Pointer_DownLeft 0xFEE6 +#define XK_Pointer_DownRight 0xFEE7 +#define XK_Pointer_Button_Dflt 0xFEE8 +#define XK_Pointer_Button1 0xFEE9 +#define XK_Pointer_Button2 0xFEEA +#define XK_Pointer_Button3 0xFEEB +#define XK_Pointer_Button4 0xFEEC +#define XK_Pointer_Button5 0xFEED +#define XK_Pointer_DblClick_Dflt 0xFEEE +#define XK_Pointer_DblClick1 0xFEEF +#define XK_Pointer_DblClick2 0xFEF0 +#define XK_Pointer_DblClick3 0xFEF1 +#define XK_Pointer_DblClick4 0xFEF2 +#define XK_Pointer_DblClick5 0xFEF3 +#define XK_Pointer_Drag_Dflt 0xFEF4 +#define XK_Pointer_Drag1 0xFEF5 +#define XK_Pointer_Drag2 0xFEF6 +#define XK_Pointer_Drag3 0xFEF7 +#define XK_Pointer_Drag4 0xFEF8 +#define XK_Pointer_Drag5 0xFEFD + +#define XK_Pointer_EnableKeys 0xFEF9 +#define XK_Pointer_Accelerate 0xFEFA +#define XK_Pointer_DfltBtnNext 0xFEFB +#define XK_Pointer_DfltBtnPrev 0xFEFC + +#endif + +/* + * 3270 Terminal Keys + * Byte 3 = 0xFD + */ + +#define XK_3270 +#ifdef XK_3270 +#define XK_3270_Duplicate 0xFD01 +#define XK_3270_FieldMark 0xFD02 +#define XK_3270_Right2 0xFD03 +#define XK_3270_Left2 0xFD04 +#define XK_3270_BackTab 0xFD05 +#define XK_3270_EraseEOF 0xFD06 +#define XK_3270_EraseInput 0xFD07 +#define XK_3270_Reset 0xFD08 +#define XK_3270_Quit 0xFD09 +#define XK_3270_PA1 0xFD0A +#define XK_3270_PA2 0xFD0B +#define XK_3270_PA3 0xFD0C +#define XK_3270_Test 0xFD0D +#define XK_3270_Attn 0xFD0E +#define XK_3270_CursorBlink 0xFD0F +#define XK_3270_AltCursor 0xFD10 +#define XK_3270_KeyClick 0xFD11 +#define XK_3270_Jump 0xFD12 +#define XK_3270_Ident 0xFD13 +#define XK_3270_Rule 0xFD14 +#define XK_3270_Copy 0xFD15 +#define XK_3270_Play 0xFD16 +#define XK_3270_Setup 0xFD17 +#define XK_3270_Record 0xFD18 +#define XK_3270_ChangeScreen 0xFD19 +#define XK_3270_DeleteWord 0xFD1A +#define XK_3270_ExSelect 0xFD1B +#define XK_3270_CursorSelect 0xFD1C +#define XK_3270_PrintScreen 0xFD1D +#define XK_3270_Enter 0xFD1E +#endif + +/* + * Latin 1 + * Byte 3 = 0 + */ +#define XK_LATIN1 +#ifdef XK_LATIN1 +#define XK_space 0x020 +#define XK_exclam 0x021 +#define XK_quotedbl 0x022 +#define XK_numbersign 0x023 +#define XK_dollar 0x024 +#define XK_percent 0x025 +#define XK_ampersand 0x026 +#define XK_apostrophe 0x027 +#define XK_quoteright 0x027 /* deprecated */ +#define XK_parenleft 0x028 +#define XK_parenright 0x029 +#define XK_asterisk 0x02a +#define XK_plus 0x02b +#define XK_comma 0x02c +#define XK_minus 0x02d +#define XK_period 0x02e +#define XK_slash 0x02f +#define XK_0 0x030 +#define XK_1 0x031 +#define XK_2 0x032 +#define XK_3 0x033 +#define XK_4 0x034 +#define XK_5 0x035 +#define XK_6 0x036 +#define XK_7 0x037 +#define XK_8 0x038 +#define XK_9 0x039 +#define XK_colon 0x03a +#define XK_semicolon 0x03b +#define XK_less 0x03c +#define XK_equal 0x03d +#define XK_greater 0x03e +#define XK_question 0x03f +#define XK_at 0x040 +#define XK_A 0x041 +#define XK_B 0x042 +#define XK_C 0x043 +#define XK_D 0x044 +#define XK_E 0x045 +#define XK_F 0x046 +#define XK_G 0x047 +#define XK_H 0x048 +#define XK_I 0x049 +#define XK_J 0x04a +#define XK_K 0x04b +#define XK_L 0x04c +#define XK_M 0x04d +#define XK_N 0x04e +#define XK_O 0x04f +#define XK_P 0x050 +#define XK_Q 0x051 +#define XK_R 0x052 +#define XK_S 0x053 +#define XK_T 0x054 +#define XK_U 0x055 +#define XK_V 0x056 +#define XK_W 0x057 +#define XK_X 0x058 +#define XK_Y 0x059 +#define XK_Z 0x05a +#define XK_bracketleft 0x05b +#define XK_backslash 0x05c +#define XK_bracketright 0x05d +#define XK_asciicircum 0x05e +#define XK_underscore 0x05f +#define XK_grave 0x060 +#define XK_quoteleft 0x060 /* deprecated */ +#define XK_a 0x061 +#define XK_b 0x062 +#define XK_c 0x063 +#define XK_d 0x064 +#define XK_e 0x065 +#define XK_f 0x066 +#define XK_g 0x067 +#define XK_h 0x068 +#define XK_i 0x069 +#define XK_j 0x06a +#define XK_k 0x06b +#define XK_l 0x06c +#define XK_m 0x06d +#define XK_n 0x06e +#define XK_o 0x06f +#define XK_p 0x070 +#define XK_q 0x071 +#define XK_r 0x072 +#define XK_s 0x073 +#define XK_t 0x074 +#define XK_u 0x075 +#define XK_v 0x076 +#define XK_w 0x077 +#define XK_x 0x078 +#define XK_y 0x079 +#define XK_z 0x07a +#define XK_braceleft 0x07b +#define XK_bar 0x07c +#define XK_braceright 0x07d +#define XK_asciitilde 0x07e + +#define XK_nobreakspace 0x0a0 +#define XK_exclamdown 0x0a1 +#define XK_cent 0x0a2 +#define XK_sterling 0x0a3 +#define XK_currency 0x0a4 +#define XK_yen 0x0a5 +#define XK_brokenbar 0x0a6 +#define XK_section 0x0a7 +#define XK_diaeresis 0x0a8 +#define XK_copyright 0x0a9 +#define XK_ordfeminine 0x0aa +#define XK_guillemotleft 0x0ab /* left angle quotation mark */ +#define XK_notsign 0x0ac +#define XK_hyphen 0x0ad +#define XK_registered 0x0ae +#define XK_macron 0x0af +#define XK_degree 0x0b0 +#define XK_plusminus 0x0b1 +#define XK_twosuperior 0x0b2 +#define XK_threesuperior 0x0b3 +#define XK_acute 0x0b4 +#define XK_mu 0x0b5 +#define XK_paragraph 0x0b6 +#define XK_periodcentered 0x0b7 +#define XK_cedilla 0x0b8 +#define XK_onesuperior 0x0b9 +#define XK_masculine 0x0ba +#define XK_guillemotright 0x0bb /* right angle quotation mark */ +#define XK_onequarter 0x0bc +#define XK_onehalf 0x0bd +#define XK_threequarters 0x0be +#define XK_questiondown 0x0bf +#define XK_Agrave 0x0c0 +#define XK_Aacute 0x0c1 +#define XK_Acircumflex 0x0c2 +#define XK_Atilde 0x0c3 +#define XK_Adiaeresis 0x0c4 +#define XK_Aring 0x0c5 +#define XK_AE 0x0c6 +#define XK_Ccedilla 0x0c7 +#define XK_Egrave 0x0c8 +#define XK_Eacute 0x0c9 +#define XK_Ecircumflex 0x0ca +#define XK_Ediaeresis 0x0cb +#define XK_Igrave 0x0cc +#define XK_Iacute 0x0cd +#define XK_Icircumflex 0x0ce +#define XK_Idiaeresis 0x0cf +#define XK_ETH 0x0d0 +#define XK_Eth 0x0d0 /* deprecated */ +#define XK_Ntilde 0x0d1 +#define XK_Ograve 0x0d2 +#define XK_Oacute 0x0d3 +#define XK_Ocircumflex 0x0d4 +#define XK_Otilde 0x0d5 +#define XK_Odiaeresis 0x0d6 +#define XK_multiply 0x0d7 +#define XK_Ooblique 0x0d8 +#define XK_Oslash XK_Ooblique +#define XK_Ugrave 0x0d9 +#define XK_Uacute 0x0da +#define XK_Ucircumflex 0x0db +#define XK_Udiaeresis 0x0dc +#define XK_Yacute 0x0dd +#define XK_THORN 0x0de +#define XK_Thorn 0x0de /* deprecated */ +#define XK_ssharp 0x0df +#define XK_agrave 0x0e0 +#define XK_aacute 0x0e1 +#define XK_acircumflex 0x0e2 +#define XK_atilde 0x0e3 +#define XK_adiaeresis 0x0e4 +#define XK_aring 0x0e5 +#define XK_ae 0x0e6 +#define XK_ccedilla 0x0e7 +#define XK_egrave 0x0e8 +#define XK_eacute 0x0e9 +#define XK_ecircumflex 0x0ea +#define XK_ediaeresis 0x0eb +#define XK_igrave 0x0ec +#define XK_iacute 0x0ed +#define XK_icircumflex 0x0ee +#define XK_idiaeresis 0x0ef +#define XK_eth 0x0f0 +#define XK_ntilde 0x0f1 +#define XK_ograve 0x0f2 +#define XK_oacute 0x0f3 +#define XK_ocircumflex 0x0f4 +#define XK_otilde 0x0f5 +#define XK_odiaeresis 0x0f6 +#define XK_division 0x0f7 +#define XK_oslash 0x0f8 +#define XK_ooblique XK_oslash +#define XK_ugrave 0x0f9 +#define XK_uacute 0x0fa +#define XK_ucircumflex 0x0fb +#define XK_udiaeresis 0x0fc +#define XK_yacute 0x0fd +#define XK_thorn 0x0fe +#define XK_ydiaeresis 0x0ff +#endif /* XK_LATIN1 */ + +/* + * Latin 2 + * Byte 3 = 1 + */ + +#define XK_LATIN2 +#ifdef XK_LATIN2 +#define XK_Aogonek 0x1a1 +#define XK_breve 0x1a2 +#define XK_Lstroke 0x1a3 +#define XK_Lcaron 0x1a5 +#define XK_Sacute 0x1a6 +#define XK_Scaron 0x1a9 +#define XK_Scedilla 0x1aa +#define XK_Tcaron 0x1ab +#define XK_Zacute 0x1ac +#define XK_Zcaron 0x1ae +#define XK_Zabovedot 0x1af +#define XK_aogonek 0x1b1 +#define XK_ogonek 0x1b2 +#define XK_lstroke 0x1b3 +#define XK_lcaron 0x1b5 +#define XK_sacute 0x1b6 +#define XK_caron 0x1b7 +#define XK_scaron 0x1b9 +#define XK_scedilla 0x1ba +#define XK_tcaron 0x1bb +#define XK_zacute 0x1bc +#define XK_doubleacute 0x1bd +#define XK_zcaron 0x1be +#define XK_zabovedot 0x1bf +#define XK_Racute 0x1c0 +#define XK_Abreve 0x1c3 +#define XK_Lacute 0x1c5 +#define XK_Cacute 0x1c6 +#define XK_Ccaron 0x1c8 +#define XK_Eogonek 0x1ca +#define XK_Ecaron 0x1cc +#define XK_Dcaron 0x1cf +#define XK_Dstroke 0x1d0 +#define XK_Nacute 0x1d1 +#define XK_Ncaron 0x1d2 +#define XK_Odoubleacute 0x1d5 +#define XK_Rcaron 0x1d8 +#define XK_Uring 0x1d9 +#define XK_Udoubleacute 0x1db +#define XK_Tcedilla 0x1de +#define XK_racute 0x1e0 +#define XK_abreve 0x1e3 +#define XK_lacute 0x1e5 +#define XK_cacute 0x1e6 +#define XK_ccaron 0x1e8 +#define XK_eogonek 0x1ea +#define XK_ecaron 0x1ec +#define XK_dcaron 0x1ef +#define XK_dstroke 0x1f0 +#define XK_nacute 0x1f1 +#define XK_ncaron 0x1f2 +#define XK_odoubleacute 0x1f5 +#define XK_udoubleacute 0x1fb +#define XK_rcaron 0x1f8 +#define XK_uring 0x1f9 +#define XK_tcedilla 0x1fe +#define XK_abovedot 0x1ff +#endif /* XK_LATIN2 */ + +/* + * Latin 3 + * Byte 3 = 2 + */ + +#define XK_LATIN3 +#ifdef XK_LATIN3 +#define XK_Hstroke 0x2a1 +#define XK_Hcircumflex 0x2a6 +#define XK_Iabovedot 0x2a9 +#define XK_Gbreve 0x2ab +#define XK_Jcircumflex 0x2ac +#define XK_hstroke 0x2b1 +#define XK_hcircumflex 0x2b6 +#define XK_idotless 0x2b9 +#define XK_gbreve 0x2bb +#define XK_jcircumflex 0x2bc +#define XK_Cabovedot 0x2c5 +#define XK_Ccircumflex 0x2c6 +#define XK_Gabovedot 0x2d5 +#define XK_Gcircumflex 0x2d8 +#define XK_Ubreve 0x2dd +#define XK_Scircumflex 0x2de +#define XK_cabovedot 0x2e5 +#define XK_ccircumflex 0x2e6 +#define XK_gabovedot 0x2f5 +#define XK_gcircumflex 0x2f8 +#define XK_ubreve 0x2fd +#define XK_scircumflex 0x2fe +#endif /* XK_LATIN3 */ + + +/* + * Latin 4 + * Byte 3 = 3 + */ + +#define XK_LATIN4 +#ifdef XK_LATIN4 +#define XK_kra 0x3a2 +#define XK_kappa 0x3a2 /* deprecated */ +#define XK_Rcedilla 0x3a3 +#define XK_Itilde 0x3a5 +#define XK_Lcedilla 0x3a6 +#define XK_Emacron 0x3aa +#define XK_Gcedilla 0x3ab +#define XK_Tslash 0x3ac +#define XK_rcedilla 0x3b3 +#define XK_itilde 0x3b5 +#define XK_lcedilla 0x3b6 +#define XK_emacron 0x3ba +#define XK_gcedilla 0x3bb +#define XK_tslash 0x3bc +#define XK_ENG 0x3bd +#define XK_eng 0x3bf +#define XK_Amacron 0x3c0 +#define XK_Iogonek 0x3c7 +#define XK_Eabovedot 0x3cc +#define XK_Imacron 0x3cf +#define XK_Ncedilla 0x3d1 +#define XK_Omacron 0x3d2 +#define XK_Kcedilla 0x3d3 +#define XK_Uogonek 0x3d9 +#define XK_Utilde 0x3dd +#define XK_Umacron 0x3de +#define XK_amacron 0x3e0 +#define XK_iogonek 0x3e7 +#define XK_eabovedot 0x3ec +#define XK_imacron 0x3ef +#define XK_ncedilla 0x3f1 +#define XK_omacron 0x3f2 +#define XK_kcedilla 0x3f3 +#define XK_uogonek 0x3f9 +#define XK_utilde 0x3fd +#define XK_umacron 0x3fe +#endif /* XK_LATIN4 */ + +/* + * Latin-8 + * Byte 3 = 18 + */ +#define XK_LATIN8 +#ifdef XK_LATIN8 +#define XK_Babovedot 0x12a1 +#define XK_babovedot 0x12a2 +#define XK_Dabovedot 0x12a6 +#define XK_Wgrave 0x12a8 +#define XK_Wacute 0x12aa +#define XK_dabovedot 0x12ab +#define XK_Ygrave 0x12ac +#define XK_Fabovedot 0x12b0 +#define XK_fabovedot 0x12b1 +#define XK_Mabovedot 0x12b4 +#define XK_mabovedot 0x12b5 +#define XK_Pabovedot 0x12b7 +#define XK_wgrave 0x12b8 +#define XK_pabovedot 0x12b9 +#define XK_wacute 0x12ba +#define XK_Sabovedot 0x12bb +#define XK_ygrave 0x12bc +#define XK_Wdiaeresis 0x12bd +#define XK_wdiaeresis 0x12be +#define XK_sabovedot 0x12bf +#define XK_Wcircumflex 0x12d0 +#define XK_Tabovedot 0x12d7 +#define XK_Ycircumflex 0x12de +#define XK_wcircumflex 0x12f0 +#define XK_tabovedot 0x12f7 +#define XK_ycircumflex 0x12fe +#endif /* XK_LATIN8 */ + +/* + * Latin-9 (a.k.a. Latin-0) + * Byte 3 = 19 + */ + +#define XK_LATIN9 +#ifdef XK_LATIN9 +#define XK_OE 0x13bc +#define XK_oe 0x13bd +#define XK_Ydiaeresis 0x13be +#endif /* XK_LATIN9 */ + +/* + * Katakana + * Byte 3 = 4 + */ + +#define XK_KATAKANA +#ifdef XK_KATAKANA +#define XK_overline 0x47e +#define XK_kana_fullstop 0x4a1 +#define XK_kana_openingbracket 0x4a2 +#define XK_kana_closingbracket 0x4a3 +#define XK_kana_comma 0x4a4 +#define XK_kana_conjunctive 0x4a5 +#define XK_kana_middledot 0x4a5 /* deprecated */ +#define XK_kana_WO 0x4a6 +#define XK_kana_a 0x4a7 +#define XK_kana_i 0x4a8 +#define XK_kana_u 0x4a9 +#define XK_kana_e 0x4aa +#define XK_kana_o 0x4ab +#define XK_kana_ya 0x4ac +#define XK_kana_yu 0x4ad +#define XK_kana_yo 0x4ae +#define XK_kana_tsu 0x4af +#define XK_kana_tu 0x4af /* deprecated */ +#define XK_prolongedsound 0x4b0 +#define XK_kana_A 0x4b1 +#define XK_kana_I 0x4b2 +#define XK_kana_U 0x4b3 +#define XK_kana_E 0x4b4 +#define XK_kana_O 0x4b5 +#define XK_kana_KA 0x4b6 +#define XK_kana_KI 0x4b7 +#define XK_kana_KU 0x4b8 +#define XK_kana_KE 0x4b9 +#define XK_kana_KO 0x4ba +#define XK_kana_SA 0x4bb +#define XK_kana_SHI 0x4bc +#define XK_kana_SU 0x4bd +#define XK_kana_SE 0x4be +#define XK_kana_SO 0x4bf +#define XK_kana_TA 0x4c0 +#define XK_kana_CHI 0x4c1 +#define XK_kana_TI 0x4c1 /* deprecated */ +#define XK_kana_TSU 0x4c2 +#define XK_kana_TU 0x4c2 /* deprecated */ +#define XK_kana_TE 0x4c3 +#define XK_kana_TO 0x4c4 +#define XK_kana_NA 0x4c5 +#define XK_kana_NI 0x4c6 +#define XK_kana_NU 0x4c7 +#define XK_kana_NE 0x4c8 +#define XK_kana_NO 0x4c9 +#define XK_kana_HA 0x4ca +#define XK_kana_HI 0x4cb +#define XK_kana_FU 0x4cc +#define XK_kana_HU 0x4cc /* deprecated */ +#define XK_kana_HE 0x4cd +#define XK_kana_HO 0x4ce +#define XK_kana_MA 0x4cf +#define XK_kana_MI 0x4d0 +#define XK_kana_MU 0x4d1 +#define XK_kana_ME 0x4d2 +#define XK_kana_MO 0x4d3 +#define XK_kana_YA 0x4d4 +#define XK_kana_YU 0x4d5 +#define XK_kana_YO 0x4d6 +#define XK_kana_RA 0x4d7 +#define XK_kana_RI 0x4d8 +#define XK_kana_RU 0x4d9 +#define XK_kana_RE 0x4da +#define XK_kana_RO 0x4db +#define XK_kana_WA 0x4dc +#define XK_kana_N 0x4dd +#define XK_voicedsound 0x4de +#define XK_semivoicedsound 0x4df +#define XK_kana_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_KATAKANA */ + +/* + * Arabic + * Byte 3 = 5 + */ + +#define XK_ARABIC +#ifdef XK_ARABIC +#define XK_Farsi_0 0x590 +#define XK_Farsi_1 0x591 +#define XK_Farsi_2 0x592 +#define XK_Farsi_3 0x593 +#define XK_Farsi_4 0x594 +#define XK_Farsi_5 0x595 +#define XK_Farsi_6 0x596 +#define XK_Farsi_7 0x597 +#define XK_Farsi_8 0x598 +#define XK_Farsi_9 0x599 +#define XK_Arabic_percent 0x5a5 +#define XK_Arabic_superscript_alef 0x5a6 +#define XK_Arabic_tteh 0x5a7 +#define XK_Arabic_peh 0x5a8 +#define XK_Arabic_tcheh 0x5a9 +#define XK_Arabic_ddal 0x5aa +#define XK_Arabic_rreh 0x5ab +#define XK_Arabic_comma 0x5ac +#define XK_Arabic_fullstop 0x5ae +#define XK_Arabic_0 0x5b0 +#define XK_Arabic_1 0x5b1 +#define XK_Arabic_2 0x5b2 +#define XK_Arabic_3 0x5b3 +#define XK_Arabic_4 0x5b4 +#define XK_Arabic_5 0x5b5 +#define XK_Arabic_6 0x5b6 +#define XK_Arabic_7 0x5b7 +#define XK_Arabic_8 0x5b8 +#define XK_Arabic_9 0x5b9 +#define XK_Arabic_semicolon 0x5bb +#define XK_Arabic_question_mark 0x5bf +#define XK_Arabic_hamza 0x5c1 +#define XK_Arabic_maddaonalef 0x5c2 +#define XK_Arabic_hamzaonalef 0x5c3 +#define XK_Arabic_hamzaonwaw 0x5c4 +#define XK_Arabic_hamzaunderalef 0x5c5 +#define XK_Arabic_hamzaonyeh 0x5c6 +#define XK_Arabic_alef 0x5c7 +#define XK_Arabic_beh 0x5c8 +#define XK_Arabic_tehmarbuta 0x5c9 +#define XK_Arabic_teh 0x5ca +#define XK_Arabic_theh 0x5cb +#define XK_Arabic_jeem 0x5cc +#define XK_Arabic_hah 0x5cd +#define XK_Arabic_khah 0x5ce +#define XK_Arabic_dal 0x5cf +#define XK_Arabic_thal 0x5d0 +#define XK_Arabic_ra 0x5d1 +#define XK_Arabic_zain 0x5d2 +#define XK_Arabic_seen 0x5d3 +#define XK_Arabic_sheen 0x5d4 +#define XK_Arabic_sad 0x5d5 +#define XK_Arabic_dad 0x5d6 +#define XK_Arabic_tah 0x5d7 +#define XK_Arabic_zah 0x5d8 +#define XK_Arabic_ain 0x5d9 +#define XK_Arabic_ghain 0x5da +#define XK_Arabic_tatweel 0x5e0 +#define XK_Arabic_feh 0x5e1 +#define XK_Arabic_qaf 0x5e2 +#define XK_Arabic_kaf 0x5e3 +#define XK_Arabic_lam 0x5e4 +#define XK_Arabic_meem 0x5e5 +#define XK_Arabic_noon 0x5e6 +#define XK_Arabic_ha 0x5e7 +#define XK_Arabic_heh 0x5e7 /* deprecated */ +#define XK_Arabic_waw 0x5e8 +#define XK_Arabic_alefmaksura 0x5e9 +#define XK_Arabic_yeh 0x5ea +#define XK_Arabic_fathatan 0x5eb +#define XK_Arabic_dammatan 0x5ec +#define XK_Arabic_kasratan 0x5ed +#define XK_Arabic_fatha 0x5ee +#define XK_Arabic_damma 0x5ef +#define XK_Arabic_kasra 0x5f0 +#define XK_Arabic_shadda 0x5f1 +#define XK_Arabic_sukun 0x5f2 +#define XK_Arabic_madda_above 0x5f3 +#define XK_Arabic_hamza_above 0x5f4 +#define XK_Arabic_hamza_below 0x5f5 +#define XK_Arabic_jeh 0x5f6 +#define XK_Arabic_veh 0x5f7 +#define XK_Arabic_keheh 0x5f8 +#define XK_Arabic_gaf 0x5f9 +#define XK_Arabic_noon_ghunna 0x5fa +#define XK_Arabic_heh_doachashmee 0x5fb +#define XK_Farsi_yeh 0x5fc +#define XK_Arabic_farsi_yeh XK_Farsi_yeh +#define XK_Arabic_yeh_baree 0x5fd +#define XK_Arabic_heh_goal 0x5fe +#define XK_Arabic_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_ARABIC */ + +/* + * Cyrillic + * Byte 3 = 6 + */ +#define XK_CYRILLIC +#ifdef XK_CYRILLIC +#define XK_Cyrillic_GHE_bar 0x680 +#define XK_Cyrillic_ghe_bar 0x690 +#define XK_Cyrillic_ZHE_descender 0x681 +#define XK_Cyrillic_zhe_descender 0x691 +#define XK_Cyrillic_KA_descender 0x682 +#define XK_Cyrillic_ka_descender 0x692 +#define XK_Cyrillic_KA_vertstroke 0x683 +#define XK_Cyrillic_ka_vertstroke 0x693 +#define XK_Cyrillic_EN_descender 0x684 +#define XK_Cyrillic_en_descender 0x694 +#define XK_Cyrillic_U_straight 0x685 +#define XK_Cyrillic_u_straight 0x695 +#define XK_Cyrillic_U_straight_bar 0x686 +#define XK_Cyrillic_u_straight_bar 0x696 +#define XK_Cyrillic_HA_descender 0x687 +#define XK_Cyrillic_ha_descender 0x697 +#define XK_Cyrillic_CHE_descender 0x688 +#define XK_Cyrillic_che_descender 0x698 +#define XK_Cyrillic_CHE_vertstroke 0x689 +#define XK_Cyrillic_che_vertstroke 0x699 +#define XK_Cyrillic_SHHA 0x68a +#define XK_Cyrillic_shha 0x69a + +#define XK_Cyrillic_SCHWA 0x68c +#define XK_Cyrillic_schwa 0x69c +#define XK_Cyrillic_I_macron 0x68d +#define XK_Cyrillic_i_macron 0x69d +#define XK_Cyrillic_O_bar 0x68e +#define XK_Cyrillic_o_bar 0x69e +#define XK_Cyrillic_U_macron 0x68f +#define XK_Cyrillic_u_macron 0x69f + +#define XK_Serbian_dje 0x6a1 +#define XK_Macedonia_gje 0x6a2 +#define XK_Cyrillic_io 0x6a3 +#define XK_Ukrainian_ie 0x6a4 +#define XK_Ukranian_je 0x6a4 /* deprecated */ +#define XK_Macedonia_dse 0x6a5 +#define XK_Ukrainian_i 0x6a6 +#define XK_Ukranian_i 0x6a6 /* deprecated */ +#define XK_Ukrainian_yi 0x6a7 +#define XK_Ukranian_yi 0x6a7 /* deprecated */ +#define XK_Cyrillic_je 0x6a8 +#define XK_Serbian_je 0x6a8 /* deprecated */ +#define XK_Cyrillic_lje 0x6a9 +#define XK_Serbian_lje 0x6a9 /* deprecated */ +#define XK_Cyrillic_nje 0x6aa +#define XK_Serbian_nje 0x6aa /* deprecated */ +#define XK_Serbian_tshe 0x6ab +#define XK_Macedonia_kje 0x6ac +#define XK_Ukrainian_ghe_with_upturn 0x6ad +#define XK_Byelorussian_shortu 0x6ae +#define XK_Cyrillic_dzhe 0x6af +#define XK_Serbian_dze 0x6af /* deprecated */ +#define XK_numerosign 0x6b0 +#define XK_Serbian_DJE 0x6b1 +#define XK_Macedonia_GJE 0x6b2 +#define XK_Cyrillic_IO 0x6b3 +#define XK_Ukrainian_IE 0x6b4 +#define XK_Ukranian_JE 0x6b4 /* deprecated */ +#define XK_Macedonia_DSE 0x6b5 +#define XK_Ukrainian_I 0x6b6 +#define XK_Ukranian_I 0x6b6 /* deprecated */ +#define XK_Ukrainian_YI 0x6b7 +#define XK_Ukranian_YI 0x6b7 /* deprecated */ +#define XK_Cyrillic_JE 0x6b8 +#define XK_Serbian_JE 0x6b8 /* deprecated */ +#define XK_Cyrillic_LJE 0x6b9 +#define XK_Serbian_LJE 0x6b9 /* deprecated */ +#define XK_Cyrillic_NJE 0x6ba +#define XK_Serbian_NJE 0x6ba /* deprecated */ +#define XK_Serbian_TSHE 0x6bb +#define XK_Macedonia_KJE 0x6bc +#define XK_Ukrainian_GHE_WITH_UPTURN 0x6bd +#define XK_Byelorussian_SHORTU 0x6be +#define XK_Cyrillic_DZHE 0x6bf +#define XK_Serbian_DZE 0x6bf /* deprecated */ +#define XK_Cyrillic_yu 0x6c0 +#define XK_Cyrillic_a 0x6c1 +#define XK_Cyrillic_be 0x6c2 +#define XK_Cyrillic_tse 0x6c3 +#define XK_Cyrillic_de 0x6c4 +#define XK_Cyrillic_ie 0x6c5 +#define XK_Cyrillic_ef 0x6c6 +#define XK_Cyrillic_ghe 0x6c7 +#define XK_Cyrillic_ha 0x6c8 +#define XK_Cyrillic_i 0x6c9 +#define XK_Cyrillic_shorti 0x6ca +#define XK_Cyrillic_ka 0x6cb +#define XK_Cyrillic_el 0x6cc +#define XK_Cyrillic_em 0x6cd +#define XK_Cyrillic_en 0x6ce +#define XK_Cyrillic_o 0x6cf +#define XK_Cyrillic_pe 0x6d0 +#define XK_Cyrillic_ya 0x6d1 +#define XK_Cyrillic_er 0x6d2 +#define XK_Cyrillic_es 0x6d3 +#define XK_Cyrillic_te 0x6d4 +#define XK_Cyrillic_u 0x6d5 +#define XK_Cyrillic_zhe 0x6d6 +#define XK_Cyrillic_ve 0x6d7 +#define XK_Cyrillic_softsign 0x6d8 +#define XK_Cyrillic_yeru 0x6d9 +#define XK_Cyrillic_ze 0x6da +#define XK_Cyrillic_sha 0x6db +#define XK_Cyrillic_e 0x6dc +#define XK_Cyrillic_shcha 0x6dd +#define XK_Cyrillic_che 0x6de +#define XK_Cyrillic_hardsign 0x6df +#define XK_Cyrillic_YU 0x6e0 +#define XK_Cyrillic_A 0x6e1 +#define XK_Cyrillic_BE 0x6e2 +#define XK_Cyrillic_TSE 0x6e3 +#define XK_Cyrillic_DE 0x6e4 +#define XK_Cyrillic_IE 0x6e5 +#define XK_Cyrillic_EF 0x6e6 +#define XK_Cyrillic_GHE 0x6e7 +#define XK_Cyrillic_HA 0x6e8 +#define XK_Cyrillic_I 0x6e9 +#define XK_Cyrillic_SHORTI 0x6ea +#define XK_Cyrillic_KA 0x6eb +#define XK_Cyrillic_EL 0x6ec +#define XK_Cyrillic_EM 0x6ed +#define XK_Cyrillic_EN 0x6ee +#define XK_Cyrillic_O 0x6ef +#define XK_Cyrillic_PE 0x6f0 +#define XK_Cyrillic_YA 0x6f1 +#define XK_Cyrillic_ER 0x6f2 +#define XK_Cyrillic_ES 0x6f3 +#define XK_Cyrillic_TE 0x6f4 +#define XK_Cyrillic_U 0x6f5 +#define XK_Cyrillic_ZHE 0x6f6 +#define XK_Cyrillic_VE 0x6f7 +#define XK_Cyrillic_SOFTSIGN 0x6f8 +#define XK_Cyrillic_YERU 0x6f9 +#define XK_Cyrillic_ZE 0x6fa +#define XK_Cyrillic_SHA 0x6fb +#define XK_Cyrillic_E 0x6fc +#define XK_Cyrillic_SHCHA 0x6fd +#define XK_Cyrillic_CHE 0x6fe +#define XK_Cyrillic_HARDSIGN 0x6ff +#endif /* XK_CYRILLIC */ + +/* + * Greek + * Byte 3 = 7 + */ + +#define XK_GREEK +#ifdef XK_GREEK +#define XK_Greek_ALPHAaccent 0x7a1 +#define XK_Greek_EPSILONaccent 0x7a2 +#define XK_Greek_ETAaccent 0x7a3 +#define XK_Greek_IOTAaccent 0x7a4 +#define XK_Greek_IOTAdieresis 0x7a5 +#define XK_Greek_IOTAdiaeresis XK_Greek_IOTAdieresis /* old typo */ +#define XK_Greek_OMICRONaccent 0x7a7 +#define XK_Greek_UPSILONaccent 0x7a8 +#define XK_Greek_UPSILONdieresis 0x7a9 +#define XK_Greek_OMEGAaccent 0x7ab +#define XK_Greek_accentdieresis 0x7ae +#define XK_Greek_horizbar 0x7af +#define XK_Greek_alphaaccent 0x7b1 +#define XK_Greek_epsilonaccent 0x7b2 +#define XK_Greek_etaaccent 0x7b3 +#define XK_Greek_iotaaccent 0x7b4 +#define XK_Greek_iotadieresis 0x7b5 +#define XK_Greek_iotaaccentdieresis 0x7b6 +#define XK_Greek_omicronaccent 0x7b7 +#define XK_Greek_upsilonaccent 0x7b8 +#define XK_Greek_upsilondieresis 0x7b9 +#define XK_Greek_upsilonaccentdieresis 0x7ba +#define XK_Greek_omegaaccent 0x7bb +#define XK_Greek_ALPHA 0x7c1 +#define XK_Greek_BETA 0x7c2 +#define XK_Greek_GAMMA 0x7c3 +#define XK_Greek_DELTA 0x7c4 +#define XK_Greek_EPSILON 0x7c5 +#define XK_Greek_ZETA 0x7c6 +#define XK_Greek_ETA 0x7c7 +#define XK_Greek_THETA 0x7c8 +#define XK_Greek_IOTA 0x7c9 +#define XK_Greek_KAPPA 0x7ca +#define XK_Greek_LAMDA 0x7cb +#define XK_Greek_LAMBDA 0x7cb +#define XK_Greek_MU 0x7cc +#define XK_Greek_NU 0x7cd +#define XK_Greek_XI 0x7ce +#define XK_Greek_OMICRON 0x7cf +#define XK_Greek_PI 0x7d0 +#define XK_Greek_RHO 0x7d1 +#define XK_Greek_SIGMA 0x7d2 +#define XK_Greek_TAU 0x7d4 +#define XK_Greek_UPSILON 0x7d5 +#define XK_Greek_PHI 0x7d6 +#define XK_Greek_CHI 0x7d7 +#define XK_Greek_PSI 0x7d8 +#define XK_Greek_OMEGA 0x7d9 +#define XK_Greek_alpha 0x7e1 +#define XK_Greek_beta 0x7e2 +#define XK_Greek_gamma 0x7e3 +#define XK_Greek_delta 0x7e4 +#define XK_Greek_epsilon 0x7e5 +#define XK_Greek_zeta 0x7e6 +#define XK_Greek_eta 0x7e7 +#define XK_Greek_theta 0x7e8 +#define XK_Greek_iota 0x7e9 +#define XK_Greek_kappa 0x7ea +#define XK_Greek_lamda 0x7eb +#define XK_Greek_lambda 0x7eb +#define XK_Greek_mu 0x7ec +#define XK_Greek_nu 0x7ed +#define XK_Greek_xi 0x7ee +#define XK_Greek_omicron 0x7ef +#define XK_Greek_pi 0x7f0 +#define XK_Greek_rho 0x7f1 +#define XK_Greek_sigma 0x7f2 +#define XK_Greek_finalsmallsigma 0x7f3 +#define XK_Greek_tau 0x7f4 +#define XK_Greek_upsilon 0x7f5 +#define XK_Greek_phi 0x7f6 +#define XK_Greek_chi 0x7f7 +#define XK_Greek_psi 0x7f8 +#define XK_Greek_omega 0x7f9 +#define XK_Greek_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_GREEK */ + +/* + * Technical + * Byte 3 = 8 + */ + +#define XK_TECHNICAL +#ifdef XK_TECHNICAL +#define XK_leftradical 0x8a1 +#define XK_topleftradical 0x8a2 +#define XK_horizconnector 0x8a3 +#define XK_topintegral 0x8a4 +#define XK_botintegral 0x8a5 +#define XK_vertconnector 0x8a6 +#define XK_topleftsqbracket 0x8a7 +#define XK_botleftsqbracket 0x8a8 +#define XK_toprightsqbracket 0x8a9 +#define XK_botrightsqbracket 0x8aa +#define XK_topleftparens 0x8ab +#define XK_botleftparens 0x8ac +#define XK_toprightparens 0x8ad +#define XK_botrightparens 0x8ae +#define XK_leftmiddlecurlybrace 0x8af +#define XK_rightmiddlecurlybrace 0x8b0 +#define XK_topleftsummation 0x8b1 +#define XK_botleftsummation 0x8b2 +#define XK_topvertsummationconnector 0x8b3 +#define XK_botvertsummationconnector 0x8b4 +#define XK_toprightsummation 0x8b5 +#define XK_botrightsummation 0x8b6 +#define XK_rightmiddlesummation 0x8b7 +#define XK_lessthanequal 0x8bc +#define XK_notequal 0x8bd +#define XK_greaterthanequal 0x8be +#define XK_integral 0x8bf +#define XK_therefore 0x8c0 +#define XK_variation 0x8c1 +#define XK_infinity 0x8c2 +#define XK_nabla 0x8c5 +#define XK_approximate 0x8c8 +#define XK_similarequal 0x8c9 +#define XK_ifonlyif 0x8cd +#define XK_implies 0x8ce +#define XK_identical 0x8cf +#define XK_radical 0x8d6 +#define XK_includedin 0x8da +#define XK_includes 0x8db +#define XK_intersection 0x8dc +#define XK_union 0x8dd +#define XK_logicaland 0x8de +#define XK_logicalor 0x8df +#define XK_partialderivative 0x8ef +#define XK_function 0x8f6 +#define XK_leftarrow 0x8fb +#define XK_uparrow 0x8fc +#define XK_rightarrow 0x8fd +#define XK_downarrow 0x8fe +#endif /* XK_TECHNICAL */ + +/* + * Special + * Byte 3 = 9 + */ + +#define XK_SPECIAL +#ifdef XK_SPECIAL +#define XK_blank 0x9df +#define XK_soliddiamond 0x9e0 +#define XK_checkerboard 0x9e1 +#define XK_ht 0x9e2 +#define XK_ff 0x9e3 +#define XK_cr 0x9e4 +#define XK_lf 0x9e5 +#define XK_nl 0x9e8 +#define XK_vt 0x9e9 +#define XK_lowrightcorner 0x9ea +#define XK_uprightcorner 0x9eb +#define XK_upleftcorner 0x9ec +#define XK_lowleftcorner 0x9ed +#define XK_crossinglines 0x9ee +#define XK_horizlinescan1 0x9ef +#define XK_horizlinescan3 0x9f0 +#define XK_horizlinescan5 0x9f1 +#define XK_horizlinescan7 0x9f2 +#define XK_horizlinescan9 0x9f3 +#define XK_leftt 0x9f4 +#define XK_rightt 0x9f5 +#define XK_bott 0x9f6 +#define XK_topt 0x9f7 +#define XK_vertbar 0x9f8 +#endif /* XK_SPECIAL */ + +/* + * Publishing + * Byte 3 = a + */ + +#define XK_PUBLISHING +#ifdef XK_PUBLISHING +#define XK_emspace 0xaa1 +#define XK_enspace 0xaa2 +#define XK_em3space 0xaa3 +#define XK_em4space 0xaa4 +#define XK_digitspace 0xaa5 +#define XK_punctspace 0xaa6 +#define XK_thinspace 0xaa7 +#define XK_hairspace 0xaa8 +#define XK_emdash 0xaa9 +#define XK_endash 0xaaa +#define XK_signifblank 0xaac +#define XK_ellipsis 0xaae +#define XK_doubbaselinedot 0xaaf +#define XK_onethird 0xab0 +#define XK_twothirds 0xab1 +#define XK_onefifth 0xab2 +#define XK_twofifths 0xab3 +#define XK_threefifths 0xab4 +#define XK_fourfifths 0xab5 +#define XK_onesixth 0xab6 +#define XK_fivesixths 0xab7 +#define XK_careof 0xab8 +#define XK_figdash 0xabb +#define XK_leftanglebracket 0xabc +#define XK_decimalpoint 0xabd +#define XK_rightanglebracket 0xabe +#define XK_marker 0xabf +#define XK_oneeighth 0xac3 +#define XK_threeeighths 0xac4 +#define XK_fiveeighths 0xac5 +#define XK_seveneighths 0xac6 +#define XK_trademark 0xac9 +#define XK_signaturemark 0xaca +#define XK_trademarkincircle 0xacb +#define XK_leftopentriangle 0xacc +#define XK_rightopentriangle 0xacd +#define XK_emopencircle 0xace +#define XK_emopenrectangle 0xacf +#define XK_leftsinglequotemark 0xad0 +#define XK_rightsinglequotemark 0xad1 +#define XK_leftdoublequotemark 0xad2 +#define XK_rightdoublequotemark 0xad3 +#define XK_prescription 0xad4 +#define XK_minutes 0xad6 +#define XK_seconds 0xad7 +#define XK_latincross 0xad9 +#define XK_hexagram 0xada +#define XK_filledrectbullet 0xadb +#define XK_filledlefttribullet 0xadc +#define XK_filledrighttribullet 0xadd +#define XK_emfilledcircle 0xade +#define XK_emfilledrect 0xadf +#define XK_enopencircbullet 0xae0 +#define XK_enopensquarebullet 0xae1 +#define XK_openrectbullet 0xae2 +#define XK_opentribulletup 0xae3 +#define XK_opentribulletdown 0xae4 +#define XK_openstar 0xae5 +#define XK_enfilledcircbullet 0xae6 +#define XK_enfilledsqbullet 0xae7 +#define XK_filledtribulletup 0xae8 +#define XK_filledtribulletdown 0xae9 +#define XK_leftpointer 0xaea +#define XK_rightpointer 0xaeb +#define XK_club 0xaec +#define XK_diamond 0xaed +#define XK_heart 0xaee +#define XK_maltesecross 0xaf0 +#define XK_dagger 0xaf1 +#define XK_doubledagger 0xaf2 +#define XK_checkmark 0xaf3 +#define XK_ballotcross 0xaf4 +#define XK_musicalsharp 0xaf5 +#define XK_musicalflat 0xaf6 +#define XK_malesymbol 0xaf7 +#define XK_femalesymbol 0xaf8 +#define XK_telephone 0xaf9 +#define XK_telephonerecorder 0xafa +#define XK_phonographcopyright 0xafb +#define XK_caret 0xafc +#define XK_singlelowquotemark 0xafd +#define XK_doublelowquotemark 0xafe +#define XK_cursor 0xaff +#endif /* XK_PUBLISHING */ + +/* + * APL + * Byte 3 = b + */ + +#define XK_APL +#ifdef XK_APL +#define XK_leftcaret 0xba3 +#define XK_rightcaret 0xba6 +#define XK_downcaret 0xba8 +#define XK_upcaret 0xba9 +#define XK_overbar 0xbc0 +#define XK_downtack 0xbc2 +#define XK_upshoe 0xbc3 +#define XK_downstile 0xbc4 +#define XK_underbar 0xbc6 +#define XK_jot 0xbca +#define XK_quad 0xbcc +#define XK_uptack 0xbce +#define XK_circle 0xbcf +#define XK_upstile 0xbd3 +#define XK_downshoe 0xbd6 +#define XK_rightshoe 0xbd8 +#define XK_leftshoe 0xbda +#define XK_lefttack 0xbdc +#define XK_righttack 0xbfc +#endif /* XK_APL */ + +/* + * Hebrew + * Byte 3 = c + */ + +#define XK_HEBREW +#ifdef XK_HEBREW +#define XK_hebrew_doublelowline 0xcdf +#define XK_hebrew_aleph 0xce0 +#define XK_hebrew_bet 0xce1 +#define XK_hebrew_beth 0xce1 /* deprecated */ +#define XK_hebrew_gimel 0xce2 +#define XK_hebrew_gimmel 0xce2 /* deprecated */ +#define XK_hebrew_dalet 0xce3 +#define XK_hebrew_daleth 0xce3 /* deprecated */ +#define XK_hebrew_he 0xce4 +#define XK_hebrew_waw 0xce5 +#define XK_hebrew_zain 0xce6 +#define XK_hebrew_zayin 0xce6 /* deprecated */ +#define XK_hebrew_chet 0xce7 +#define XK_hebrew_het 0xce7 /* deprecated */ +#define XK_hebrew_tet 0xce8 +#define XK_hebrew_teth 0xce8 /* deprecated */ +#define XK_hebrew_yod 0xce9 +#define XK_hebrew_finalkaph 0xcea +#define XK_hebrew_kaph 0xceb +#define XK_hebrew_lamed 0xcec +#define XK_hebrew_finalmem 0xced +#define XK_hebrew_mem 0xcee +#define XK_hebrew_finalnun 0xcef +#define XK_hebrew_nun 0xcf0 +#define XK_hebrew_samech 0xcf1 +#define XK_hebrew_samekh 0xcf1 /* deprecated */ +#define XK_hebrew_ayin 0xcf2 +#define XK_hebrew_finalpe 0xcf3 +#define XK_hebrew_pe 0xcf4 +#define XK_hebrew_finalzade 0xcf5 +#define XK_hebrew_finalzadi 0xcf5 /* deprecated */ +#define XK_hebrew_zade 0xcf6 +#define XK_hebrew_zadi 0xcf6 /* deprecated */ +#define XK_hebrew_qoph 0xcf7 +#define XK_hebrew_kuf 0xcf7 /* deprecated */ +#define XK_hebrew_resh 0xcf8 +#define XK_hebrew_shin 0xcf9 +#define XK_hebrew_taw 0xcfa +#define XK_hebrew_taf 0xcfa /* deprecated */ +#define XK_Hebrew_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_HEBREW */ + +/* + * Thai + * Byte 3 = d + */ + +#define XK_THAI +#ifdef XK_THAI +#define XK_Thai_kokai 0xda1 +#define XK_Thai_khokhai 0xda2 +#define XK_Thai_khokhuat 0xda3 +#define XK_Thai_khokhwai 0xda4 +#define XK_Thai_khokhon 0xda5 +#define XK_Thai_khorakhang 0xda6 +#define XK_Thai_ngongu 0xda7 +#define XK_Thai_chochan 0xda8 +#define XK_Thai_choching 0xda9 +#define XK_Thai_chochang 0xdaa +#define XK_Thai_soso 0xdab +#define XK_Thai_chochoe 0xdac +#define XK_Thai_yoying 0xdad +#define XK_Thai_dochada 0xdae +#define XK_Thai_topatak 0xdaf +#define XK_Thai_thothan 0xdb0 +#define XK_Thai_thonangmontho 0xdb1 +#define XK_Thai_thophuthao 0xdb2 +#define XK_Thai_nonen 0xdb3 +#define XK_Thai_dodek 0xdb4 +#define XK_Thai_totao 0xdb5 +#define XK_Thai_thothung 0xdb6 +#define XK_Thai_thothahan 0xdb7 +#define XK_Thai_thothong 0xdb8 +#define XK_Thai_nonu 0xdb9 +#define XK_Thai_bobaimai 0xdba +#define XK_Thai_popla 0xdbb +#define XK_Thai_phophung 0xdbc +#define XK_Thai_fofa 0xdbd +#define XK_Thai_phophan 0xdbe +#define XK_Thai_fofan 0xdbf +#define XK_Thai_phosamphao 0xdc0 +#define XK_Thai_moma 0xdc1 +#define XK_Thai_yoyak 0xdc2 +#define XK_Thai_rorua 0xdc3 +#define XK_Thai_ru 0xdc4 +#define XK_Thai_loling 0xdc5 +#define XK_Thai_lu 0xdc6 +#define XK_Thai_wowaen 0xdc7 +#define XK_Thai_sosala 0xdc8 +#define XK_Thai_sorusi 0xdc9 +#define XK_Thai_sosua 0xdca +#define XK_Thai_hohip 0xdcb +#define XK_Thai_lochula 0xdcc +#define XK_Thai_oang 0xdcd +#define XK_Thai_honokhuk 0xdce +#define XK_Thai_paiyannoi 0xdcf +#define XK_Thai_saraa 0xdd0 +#define XK_Thai_maihanakat 0xdd1 +#define XK_Thai_saraaa 0xdd2 +#define XK_Thai_saraam 0xdd3 +#define XK_Thai_sarai 0xdd4 +#define XK_Thai_saraii 0xdd5 +#define XK_Thai_saraue 0xdd6 +#define XK_Thai_sarauee 0xdd7 +#define XK_Thai_sarau 0xdd8 +#define XK_Thai_sarauu 0xdd9 +#define XK_Thai_phinthu 0xdda +#define XK_Thai_maihanakat_maitho 0xdde +#define XK_Thai_baht 0xddf +#define XK_Thai_sarae 0xde0 +#define XK_Thai_saraae 0xde1 +#define XK_Thai_sarao 0xde2 +#define XK_Thai_saraaimaimuan 0xde3 +#define XK_Thai_saraaimaimalai 0xde4 +#define XK_Thai_lakkhangyao 0xde5 +#define XK_Thai_maiyamok 0xde6 +#define XK_Thai_maitaikhu 0xde7 +#define XK_Thai_maiek 0xde8 +#define XK_Thai_maitho 0xde9 +#define XK_Thai_maitri 0xdea +#define XK_Thai_maichattawa 0xdeb +#define XK_Thai_thanthakhat 0xdec +#define XK_Thai_nikhahit 0xded +#define XK_Thai_leksun 0xdf0 +#define XK_Thai_leknung 0xdf1 +#define XK_Thai_leksong 0xdf2 +#define XK_Thai_leksam 0xdf3 +#define XK_Thai_leksi 0xdf4 +#define XK_Thai_lekha 0xdf5 +#define XK_Thai_lekhok 0xdf6 +#define XK_Thai_lekchet 0xdf7 +#define XK_Thai_lekpaet 0xdf8 +#define XK_Thai_lekkao 0xdf9 +#endif /* XK_THAI */ + +/* + * Korean + * Byte 3 = e + */ + +#define XK_KOREAN +#ifdef XK_KOREAN + +#define XK_Hangul 0xff31 /* Hangul start/stop(toggle) */ +#define XK_Hangul_Start 0xff32 /* Hangul start */ +#define XK_Hangul_End 0xff33 /* Hangul end, English start */ +#define XK_Hangul_Hanja 0xff34 /* Start Hangul->Hanja Conversion */ +#define XK_Hangul_Jamo 0xff35 /* Hangul Jamo mode */ +#define XK_Hangul_Romaja 0xff36 /* Hangul Romaja mode */ +#define XK_Hangul_Codeinput 0xff37 /* Hangul code input mode */ +#define XK_Hangul_Jeonja 0xff38 /* Jeonja mode */ +#define XK_Hangul_Banja 0xff39 /* Banja mode */ +#define XK_Hangul_PreHanja 0xff3a /* Pre Hanja conversion */ +#define XK_Hangul_PostHanja 0xff3b /* Post Hanja conversion */ +#define XK_Hangul_SingleCandidate 0xff3c /* Single candidate */ +#define XK_Hangul_MultipleCandidate 0xff3d /* Multiple candidate */ +#define XK_Hangul_PreviousCandidate 0xff3e /* Previous candidate */ +#define XK_Hangul_Special 0xff3f /* Special symbols */ +#define XK_Hangul_switch 0xFF7E /* Alias for mode_switch */ + +/* Hangul Consonant Characters */ +#define XK_Hangul_Kiyeog 0xea1 +#define XK_Hangul_SsangKiyeog 0xea2 +#define XK_Hangul_KiyeogSios 0xea3 +#define XK_Hangul_Nieun 0xea4 +#define XK_Hangul_NieunJieuj 0xea5 +#define XK_Hangul_NieunHieuh 0xea6 +#define XK_Hangul_Dikeud 0xea7 +#define XK_Hangul_SsangDikeud 0xea8 +#define XK_Hangul_Rieul 0xea9 +#define XK_Hangul_RieulKiyeog 0xeaa +#define XK_Hangul_RieulMieum 0xeab +#define XK_Hangul_RieulPieub 0xeac +#define XK_Hangul_RieulSios 0xead +#define XK_Hangul_RieulTieut 0xeae +#define XK_Hangul_RieulPhieuf 0xeaf +#define XK_Hangul_RieulHieuh 0xeb0 +#define XK_Hangul_Mieum 0xeb1 +#define XK_Hangul_Pieub 0xeb2 +#define XK_Hangul_SsangPieub 0xeb3 +#define XK_Hangul_PieubSios 0xeb4 +#define XK_Hangul_Sios 0xeb5 +#define XK_Hangul_SsangSios 0xeb6 +#define XK_Hangul_Ieung 0xeb7 +#define XK_Hangul_Jieuj 0xeb8 +#define XK_Hangul_SsangJieuj 0xeb9 +#define XK_Hangul_Cieuc 0xeba +#define XK_Hangul_Khieuq 0xebb +#define XK_Hangul_Tieut 0xebc +#define XK_Hangul_Phieuf 0xebd +#define XK_Hangul_Hieuh 0xebe + +/* Hangul Vowel Characters */ +#define XK_Hangul_A 0xebf +#define XK_Hangul_AE 0xec0 +#define XK_Hangul_YA 0xec1 +#define XK_Hangul_YAE 0xec2 +#define XK_Hangul_EO 0xec3 +#define XK_Hangul_E 0xec4 +#define XK_Hangul_YEO 0xec5 +#define XK_Hangul_YE 0xec6 +#define XK_Hangul_O 0xec7 +#define XK_Hangul_WA 0xec8 +#define XK_Hangul_WAE 0xec9 +#define XK_Hangul_OE 0xeca +#define XK_Hangul_YO 0xecb +#define XK_Hangul_U 0xecc +#define XK_Hangul_WEO 0xecd +#define XK_Hangul_WE 0xece +#define XK_Hangul_WI 0xecf +#define XK_Hangul_YU 0xed0 +#define XK_Hangul_EU 0xed1 +#define XK_Hangul_YI 0xed2 +#define XK_Hangul_I 0xed3 + +/* Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_Kiyeog 0xed4 +#define XK_Hangul_J_SsangKiyeog 0xed5 +#define XK_Hangul_J_KiyeogSios 0xed6 +#define XK_Hangul_J_Nieun 0xed7 +#define XK_Hangul_J_NieunJieuj 0xed8 +#define XK_Hangul_J_NieunHieuh 0xed9 +#define XK_Hangul_J_Dikeud 0xeda +#define XK_Hangul_J_Rieul 0xedb +#define XK_Hangul_J_RieulKiyeog 0xedc +#define XK_Hangul_J_RieulMieum 0xedd +#define XK_Hangul_J_RieulPieub 0xede +#define XK_Hangul_J_RieulSios 0xedf +#define XK_Hangul_J_RieulTieut 0xee0 +#define XK_Hangul_J_RieulPhieuf 0xee1 +#define XK_Hangul_J_RieulHieuh 0xee2 +#define XK_Hangul_J_Mieum 0xee3 +#define XK_Hangul_J_Pieub 0xee4 +#define XK_Hangul_J_PieubSios 0xee5 +#define XK_Hangul_J_Sios 0xee6 +#define XK_Hangul_J_SsangSios 0xee7 +#define XK_Hangul_J_Ieung 0xee8 +#define XK_Hangul_J_Jieuj 0xee9 +#define XK_Hangul_J_Cieuc 0xeea +#define XK_Hangul_J_Khieuq 0xeeb +#define XK_Hangul_J_Tieut 0xeec +#define XK_Hangul_J_Phieuf 0xeed +#define XK_Hangul_J_Hieuh 0xeee + +/* Ancient Hangul Consonant Characters */ +#define XK_Hangul_RieulYeorinHieuh 0xeef +#define XK_Hangul_SunkyeongeumMieum 0xef0 +#define XK_Hangul_SunkyeongeumPieub 0xef1 +#define XK_Hangul_PanSios 0xef2 +#define XK_Hangul_KkogjiDalrinIeung 0xef3 +#define XK_Hangul_SunkyeongeumPhieuf 0xef4 +#define XK_Hangul_YeorinHieuh 0xef5 + +/* Ancient Hangul Vowel Characters */ +#define XK_Hangul_AraeA 0xef6 +#define XK_Hangul_AraeAE 0xef7 + +/* Ancient Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_PanSios 0xef8 +#define XK_Hangul_J_KkogjiDalrinIeung 0xef9 +#define XK_Hangul_J_YeorinHieuh 0xefa + +/* Korean currency symbol */ +#define XK_Korean_Won 0xeff + +#endif /* XK_KOREAN */ + +/* + * Armenian + * Byte 3 = 0x14 + */ + +#define XK_ARMENIAN +#ifdef XK_ARMENIAN +#define XK_Armenian_eternity 0x14a1 +#define XK_Armenian_ligature_ew 0x14a2 +#define XK_Armenian_full_stop 0x14a3 +#define XK_Armenian_verjaket 0x14a3 +#define XK_Armenian_parenright 0x14a4 +#define XK_Armenian_parenleft 0x14a5 +#define XK_Armenian_guillemotright 0x14a6 +#define XK_Armenian_guillemotleft 0x14a7 +#define XK_Armenian_em_dash 0x14a8 +#define XK_Armenian_dot 0x14a9 +#define XK_Armenian_mijaket 0x14a9 +#define XK_Armenian_separation_mark 0x14aa +#define XK_Armenian_but 0x14aa +#define XK_Armenian_comma 0x14ab +#define XK_Armenian_en_dash 0x14ac +#define XK_Armenian_hyphen 0x14ad +#define XK_Armenian_yentamna 0x14ad +#define XK_Armenian_ellipsis 0x14ae +#define XK_Armenian_exclam 0x14af +#define XK_Armenian_amanak 0x14af +#define XK_Armenian_accent 0x14b0 +#define XK_Armenian_shesht 0x14b0 +#define XK_Armenian_question 0x14b1 +#define XK_Armenian_paruyk 0x14b1 +#define XK_Armenian_AYB 0x14b2 +#define XK_Armenian_ayb 0x14b3 +#define XK_Armenian_BEN 0x14b4 +#define XK_Armenian_ben 0x14b5 +#define XK_Armenian_GIM 0x14b6 +#define XK_Armenian_gim 0x14b7 +#define XK_Armenian_DA 0x14b8 +#define XK_Armenian_da 0x14b9 +#define XK_Armenian_YECH 0x14ba +#define XK_Armenian_yech 0x14bb +#define XK_Armenian_ZA 0x14bc +#define XK_Armenian_za 0x14bd +#define XK_Armenian_E 0x14be +#define XK_Armenian_e 0x14bf +#define XK_Armenian_AT 0x14c0 +#define XK_Armenian_at 0x14c1 +#define XK_Armenian_TO 0x14c2 +#define XK_Armenian_to 0x14c3 +#define XK_Armenian_ZHE 0x14c4 +#define XK_Armenian_zhe 0x14c5 +#define XK_Armenian_INI 0x14c6 +#define XK_Armenian_ini 0x14c7 +#define XK_Armenian_LYUN 0x14c8 +#define XK_Armenian_lyun 0x14c9 +#define XK_Armenian_KHE 0x14ca +#define XK_Armenian_khe 0x14cb +#define XK_Armenian_TSA 0x14cc +#define XK_Armenian_tsa 0x14cd +#define XK_Armenian_KEN 0x14ce +#define XK_Armenian_ken 0x14cf +#define XK_Armenian_HO 0x14d0 +#define XK_Armenian_ho 0x14d1 +#define XK_Armenian_DZA 0x14d2 +#define XK_Armenian_dza 0x14d3 +#define XK_Armenian_GHAT 0x14d4 +#define XK_Armenian_ghat 0x14d5 +#define XK_Armenian_TCHE 0x14d6 +#define XK_Armenian_tche 0x14d7 +#define XK_Armenian_MEN 0x14d8 +#define XK_Armenian_men 0x14d9 +#define XK_Armenian_HI 0x14da +#define XK_Armenian_hi 0x14db +#define XK_Armenian_NU 0x14dc +#define XK_Armenian_nu 0x14dd +#define XK_Armenian_SHA 0x14de +#define XK_Armenian_sha 0x14df +#define XK_Armenian_VO 0x14e0 +#define XK_Armenian_vo 0x14e1 +#define XK_Armenian_CHA 0x14e2 +#define XK_Armenian_cha 0x14e3 +#define XK_Armenian_PE 0x14e4 +#define XK_Armenian_pe 0x14e5 +#define XK_Armenian_JE 0x14e6 +#define XK_Armenian_je 0x14e7 +#define XK_Armenian_RA 0x14e8 +#define XK_Armenian_ra 0x14e9 +#define XK_Armenian_SE 0x14ea +#define XK_Armenian_se 0x14eb +#define XK_Armenian_VEV 0x14ec +#define XK_Armenian_vev 0x14ed +#define XK_Armenian_TYUN 0x14ee +#define XK_Armenian_tyun 0x14ef +#define XK_Armenian_RE 0x14f0 +#define XK_Armenian_re 0x14f1 +#define XK_Armenian_TSO 0x14f2 +#define XK_Armenian_tso 0x14f3 +#define XK_Armenian_VYUN 0x14f4 +#define XK_Armenian_vyun 0x14f5 +#define XK_Armenian_PYUR 0x14f6 +#define XK_Armenian_pyur 0x14f7 +#define XK_Armenian_KE 0x14f8 +#define XK_Armenian_ke 0x14f9 +#define XK_Armenian_O 0x14fa +#define XK_Armenian_o 0x14fb +#define XK_Armenian_FE 0x14fc +#define XK_Armenian_fe 0x14fd +#define XK_Armenian_apostrophe 0x14fe +#define XK_Armenian_section_sign 0x14ff +#endif /* XK_ARMENIAN */ + +/* + * Georgian + * Byte 3 = 0x15 + */ + +#define XK_GEORGIAN +#ifdef XK_GEORGIAN +#define XK_Georgian_an 0x15d0 +#define XK_Georgian_ban 0x15d1 +#define XK_Georgian_gan 0x15d2 +#define XK_Georgian_don 0x15d3 +#define XK_Georgian_en 0x15d4 +#define XK_Georgian_vin 0x15d5 +#define XK_Georgian_zen 0x15d6 +#define XK_Georgian_tan 0x15d7 +#define XK_Georgian_in 0x15d8 +#define XK_Georgian_kan 0x15d9 +#define XK_Georgian_las 0x15da +#define XK_Georgian_man 0x15db +#define XK_Georgian_nar 0x15dc +#define XK_Georgian_on 0x15dd +#define XK_Georgian_par 0x15de +#define XK_Georgian_zhar 0x15df +#define XK_Georgian_rae 0x15e0 +#define XK_Georgian_san 0x15e1 +#define XK_Georgian_tar 0x15e2 +#define XK_Georgian_un 0x15e3 +#define XK_Georgian_phar 0x15e4 +#define XK_Georgian_khar 0x15e5 +#define XK_Georgian_ghan 0x15e6 +#define XK_Georgian_qar 0x15e7 +#define XK_Georgian_shin 0x15e8 +#define XK_Georgian_chin 0x15e9 +#define XK_Georgian_can 0x15ea +#define XK_Georgian_jil 0x15eb +#define XK_Georgian_cil 0x15ec +#define XK_Georgian_char 0x15ed +#define XK_Georgian_xan 0x15ee +#define XK_Georgian_jhan 0x15ef +#define XK_Georgian_hae 0x15f0 +#define XK_Georgian_he 0x15f1 +#define XK_Georgian_hie 0x15f2 +#define XK_Georgian_we 0x15f3 +#define XK_Georgian_har 0x15f4 +#define XK_Georgian_hoe 0x15f5 +#define XK_Georgian_fi 0x15f6 +#endif /* XK_GEORGIAN */ + +/* + * Azeri (and other Turkic or Caucasian languages of ex-USSR) + * Byte 3 = 0x16 + */ + +#define XK_CAUCASUS +#ifdef XK_CAUCASUS +/* latin */ +#define XK_Ccedillaabovedot 0x16a2 +#define XK_Xabovedot 0x16a3 +#define XK_Qabovedot 0x16a5 +#define XK_Ibreve 0x16a6 +#define XK_IE 0x16a7 +#define XK_UO 0x16a8 +#define XK_Zstroke 0x16a9 +#define XK_Gcaron 0x16aa +#define XK_Obarred 0x16af +#define XK_ccedillaabovedot 0x16b2 +#define XK_xabovedot 0x16b3 +#define XK_Ocaron 0x16b4 +#define XK_qabovedot 0x16b5 +#define XK_ibreve 0x16b6 +#define XK_ie 0x16b7 +#define XK_uo 0x16b8 +#define XK_zstroke 0x16b9 +#define XK_gcaron 0x16ba +#define XK_ocaron 0x16bd +#define XK_obarred 0x16bf +#define XK_SCHWA 0x16c6 +#define XK_schwa 0x16f6 +/* those are not really Caucasus, but I put them here for now */ +/* For Inupiak */ +#define XK_Lbelowdot 0x16d1 +#define XK_Lstrokebelowdot 0x16d2 +#define XK_lbelowdot 0x16e1 +#define XK_lstrokebelowdot 0x16e2 +/* For Guarani */ +#define XK_Gtilde 0x16d3 +#define XK_gtilde 0x16e3 +#endif /* XK_CAUCASUS */ + +/* + * Vietnamese + * Byte 3 = 0x1e + */ + +#define XK_VIETNAMESE +#ifdef XK_VIETNAMESE +#define XK_Abelowdot 0x1ea0 +#define XK_abelowdot 0x1ea1 +#define XK_Ahook 0x1ea2 +#define XK_ahook 0x1ea3 +#define XK_Acircumflexacute 0x1ea4 +#define XK_acircumflexacute 0x1ea5 +#define XK_Acircumflexgrave 0x1ea6 +#define XK_acircumflexgrave 0x1ea7 +#define XK_Acircumflexhook 0x1ea8 +#define XK_acircumflexhook 0x1ea9 +#define XK_Acircumflextilde 0x1eaa +#define XK_acircumflextilde 0x1eab +#define XK_Acircumflexbelowdot 0x1eac +#define XK_acircumflexbelowdot 0x1ead +#define XK_Abreveacute 0x1eae +#define XK_abreveacute 0x1eaf +#define XK_Abrevegrave 0x1eb0 +#define XK_abrevegrave 0x1eb1 +#define XK_Abrevehook 0x1eb2 +#define XK_abrevehook 0x1eb3 +#define XK_Abrevetilde 0x1eb4 +#define XK_abrevetilde 0x1eb5 +#define XK_Abrevebelowdot 0x1eb6 +#define XK_abrevebelowdot 0x1eb7 +#define XK_Ebelowdot 0x1eb8 +#define XK_ebelowdot 0x1eb9 +#define XK_Ehook 0x1eba +#define XK_ehook 0x1ebb +#define XK_Etilde 0x1ebc +#define XK_etilde 0x1ebd +#define XK_Ecircumflexacute 0x1ebe +#define XK_ecircumflexacute 0x1ebf +#define XK_Ecircumflexgrave 0x1ec0 +#define XK_ecircumflexgrave 0x1ec1 +#define XK_Ecircumflexhook 0x1ec2 +#define XK_ecircumflexhook 0x1ec3 +#define XK_Ecircumflextilde 0x1ec4 +#define XK_ecircumflextilde 0x1ec5 +#define XK_Ecircumflexbelowdot 0x1ec6 +#define XK_ecircumflexbelowdot 0x1ec7 +#define XK_Ihook 0x1ec8 +#define XK_ihook 0x1ec9 +#define XK_Ibelowdot 0x1eca +#define XK_ibelowdot 0x1ecb +#define XK_Obelowdot 0x1ecc +#define XK_obelowdot 0x1ecd +#define XK_Ohook 0x1ece +#define XK_ohook 0x1ecf +#define XK_Ocircumflexacute 0x1ed0 +#define XK_ocircumflexacute 0x1ed1 +#define XK_Ocircumflexgrave 0x1ed2 +#define XK_ocircumflexgrave 0x1ed3 +#define XK_Ocircumflexhook 0x1ed4 +#define XK_ocircumflexhook 0x1ed5 +#define XK_Ocircumflextilde 0x1ed6 +#define XK_ocircumflextilde 0x1ed7 +#define XK_Ocircumflexbelowdot 0x1ed8 +#define XK_ocircumflexbelowdot 0x1ed9 +#define XK_Ohornacute 0x1eda +#define XK_ohornacute 0x1edb +#define XK_Ohorngrave 0x1edc +#define XK_ohorngrave 0x1edd +#define XK_Ohornhook 0x1ede +#define XK_ohornhook 0x1edf +#define XK_Ohorntilde 0x1ee0 +#define XK_ohorntilde 0x1ee1 +#define XK_Ohornbelowdot 0x1ee2 +#define XK_ohornbelowdot 0x1ee3 +#define XK_Ubelowdot 0x1ee4 +#define XK_ubelowdot 0x1ee5 +#define XK_Uhook 0x1ee6 +#define XK_uhook 0x1ee7 +#define XK_Uhornacute 0x1ee8 +#define XK_uhornacute 0x1ee9 +#define XK_Uhorngrave 0x1eea +#define XK_uhorngrave 0x1eeb +#define XK_Uhornhook 0x1eec +#define XK_uhornhook 0x1eed +#define XK_Uhorntilde 0x1eee +#define XK_uhorntilde 0x1eef +#define XK_Uhornbelowdot 0x1ef0 +#define XK_uhornbelowdot 0x1ef1 +#define XK_Ybelowdot 0x1ef4 +#define XK_ybelowdot 0x1ef5 +#define XK_Yhook 0x1ef6 +#define XK_yhook 0x1ef7 +#define XK_Ytilde 0x1ef8 +#define XK_ytilde 0x1ef9 +#define XK_Ohorn 0x1efa /* U+01a0 */ +#define XK_ohorn 0x1efb /* U+01a1 */ +#define XK_Uhorn 0x1efc /* U+01af */ +#define XK_uhorn 0x1efd /* U+01b0 */ + +#define XK_combining_tilde 0x1e9f /* U+0303 */ +#define XK_combining_grave 0x1ef2 /* U+0300 */ +#define XK_combining_acute 0x1ef3 /* U+0301 */ +#define XK_combining_hook 0x1efe /* U+0309 */ +#define XK_combining_belowdot 0x1eff /* U+0323 */ +#endif /* XK_VIETNAMESE */ + +#define XK_CURRENCY +#ifdef XK_CURRENCY +#define XK_EcuSign 0x20a0 +#define XK_ColonSign 0x20a1 +#define XK_CruzeiroSign 0x20a2 +#define XK_FFrancSign 0x20a3 +#define XK_LiraSign 0x20a4 +#define XK_MillSign 0x20a5 +#define XK_NairaSign 0x20a6 +#define XK_PesetaSign 0x20a7 +#define XK_RupeeSign 0x20a8 +#define XK_WonSign 0x20a9 +#define XK_NewSheqelSign 0x20aa +#define XK_DongSign 0x20ab +#define XK_EuroSign 0x20ac +#endif + +void +XConvertCase(sym, lower, upper) + register int sym; + int *lower; + int *upper; +{ + *lower = sym; + *upper = sym; + switch(sym >> 8) { + case 0: /* Latin 1 */ + if ((sym >= XK_A) && (sym <= XK_Z)) + *lower += (XK_a - XK_A); + else if ((sym >= XK_a) && (sym <= XK_z)) + *upper -= (XK_a - XK_A); + else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) + *lower += (XK_agrave - XK_Agrave); + else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) + *upper -= (XK_agrave - XK_Agrave); + else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) + *lower += (XK_oslash - XK_Ooblique); + else if ((sym >= XK_oslash) && (sym <= XK_thorn)) + *upper -= (XK_oslash - XK_Ooblique); + break; + case 1: /* Latin 2 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym == XK_Aogonek) + *lower = XK_aogonek; + else if (sym >= XK_Lstroke && sym <= XK_Sacute) + *lower += (XK_lstroke - XK_Lstroke); + else if (sym >= XK_Scaron && sym <= XK_Zacute) + *lower += (XK_scaron - XK_Scaron); + else if (sym >= XK_Zcaron && sym <= XK_Zabovedot) + *lower += (XK_zcaron - XK_Zcaron); + else if (sym == XK_aogonek) + *upper = XK_Aogonek; + else if (sym >= XK_lstroke && sym <= XK_sacute) + *upper -= (XK_lstroke - XK_Lstroke); + else if (sym >= XK_scaron && sym <= XK_zacute) + *upper -= (XK_scaron - XK_Scaron); + else if (sym >= XK_zcaron && sym <= XK_zabovedot) + *upper -= (XK_zcaron - XK_Zcaron); + else if (sym >= XK_Racute && sym <= XK_Tcedilla) + *lower += (XK_racute - XK_Racute); + else if (sym >= XK_racute && sym <= XK_tcedilla) + *upper -= (XK_racute - XK_Racute); + break; + case 2: /* Latin 3 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Hstroke && sym <= XK_Hcircumflex) + *lower += (XK_hstroke - XK_Hstroke); + else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex) + *lower += (XK_gbreve - XK_Gbreve); + else if (sym >= XK_hstroke && sym <= XK_hcircumflex) + *upper -= (XK_hstroke - XK_Hstroke); + else if (sym >= XK_gbreve && sym <= XK_jcircumflex) + *upper -= (XK_gbreve - XK_Gbreve); + else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex) + *lower += (XK_cabovedot - XK_Cabovedot); + else if (sym >= XK_cabovedot && sym <= XK_scircumflex) + *upper -= (XK_cabovedot - XK_Cabovedot); + break; + case 3: /* Latin 4 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Rcedilla && sym <= XK_Tslash) + *lower += (XK_rcedilla - XK_Rcedilla); + else if (sym >= XK_rcedilla && sym <= XK_tslash) + *upper -= (XK_rcedilla - XK_Rcedilla); + else if (sym == XK_ENG) + *lower = XK_eng; + else if (sym == XK_eng) + *upper = XK_ENG; + else if (sym >= XK_Amacron && sym <= XK_Umacron) + *lower += (XK_amacron - XK_Amacron); + else if (sym >= XK_amacron && sym <= XK_umacron) + *upper -= (XK_amacron - XK_Amacron); + break; + case 6: /* Cyrillic */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE) + *lower -= (XK_Serbian_DJE - XK_Serbian_dje); + else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze) + *upper += (XK_Serbian_DJE - XK_Serbian_dje); + else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN) + *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu); + else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign) + *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu); + break; + case 7: /* Greek */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent) + *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent); + else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent && + sym != XK_Greek_iotaaccentdieresis && + sym != XK_Greek_upsilonaccentdieresis) + *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent); + else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA) + *lower += (XK_Greek_alpha - XK_Greek_ALPHA); + else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega && + sym != XK_Greek_finalsmallsigma) + *upper -= (XK_Greek_alpha - XK_Greek_ALPHA); + break; + } +} + diff --git a/packet-x11.c b/packet-x11.c index 7ae20795c0..5ca7139bd6 100644 --- a/packet-x11.c +++ b/packet-x11.c @@ -1,8 +1,9 @@ /* packet-x11.c * Routines for X11 dissection * Copyright 2000, Christophe Tronche <ch.tronche@computer.org> + * Copyright 2003, Michael Shuldman * - * $Id: packet-x11.c,v 1.47 2003/09/21 20:06:01 gerald Exp $ + * $Id: packet-x11.c,v 1.48 2004/01/02 12:52:45 obiot Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -65,9 +66,81 @@ #include "prefs.h" #include "packet-frame.h" +#include "packet-x11-keysymdef.h" #define cVALS(x) (const value_string*)(x) +/* + * Data structure associated with a conversation; keeps track of the + * request for which we're expecting a reply, the frame number of + * the initial connection request, and the byte order of the connection. + * + * An opcode of -3 means we haven't yet seen any requests yet. + * An opcode of -2 means we're not expecting a reply. + * An opcode of -1 means means we're waiting for a reply to the initial + * connection request. + * Other values are the opcode of the request for which we're expecting + * a reply. + * + */ +#define NOTHING_SEEN -3 +#define NOTHING_EXPECTED -2 +#define INITIAL_CONN -1 + +#define BYTE_ORDER_BE 0 +#define BYTE_ORDER_LE 1 +#define BYTE_ORDER_UNKNOWN -1 + +static const char *modifiers[] = { + "Shift", + "Lock", + "Control", + "Mod1", + "Mod2", + "Mod3", + "Mod4", + "Mod5" +}; + +/* Keymasks. From <X11/X.h>. */ +#define ShiftMask (1<<0) +#define LockMask (1<<1) +#define ControlMask (1<<2) +#define Mod1Mask (1<<3) +#define Mod2Mask (1<<4) +#define Mod3Mask (1<<5) +#define Mod4Mask (1<<6) +#define Mod5Mask (1<<7) + +static const int modifiermask[] = { ShiftMask, LockMask, ControlMask, +Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask }; + +/* from <X11/X.h> */ +#define NoSymbol 0L /* special KeySym */ + +typedef struct { + GHashTable *seqtable; /* hashtable of sequncenumber <-> opcode. */ + int sequencenumber; /* sequencenumber of current packet. */ + guint32 iconn_frame; /* frame # of initial connection request */ + guint32 iconn_reply; /* frame # of initial connection reply */ + int byte_order; /* byte order of connection */ + + int *keycodemap[256]; /* keycode to keysymvalue map. */ + int keysyms_per_keycode; + int first_keycode; + int *modifiermap[array_length(modifiers)];/* modifier to keycode. */ + int keycodes_per_modifier; + + union { + struct { + int first_keycode; + } GetKeyboardMapping; + } request; +} x11_conv_data_t; + +static GMemChunk *x11_state_chunk = NULL; + + /* Initialize the protocol and registered fields */ static int proto_x11 = -1; @@ -129,6 +202,12 @@ static const value_string byte_order_vals[] = { { 0, NULL } }; +static const value_string image_byte_order_vals[] = { + { 0, "LSBFirst" }, + { 1, "MSBFirst" }, + { 0, NULL } +}; + static const value_string access_mode_vals[] = { { 0, "Disable" }, { 1, "Enable" }, @@ -412,128 +491,378 @@ static const value_string on_off_vals[] = { { 0, NULL } }; +/* Requestcodes. From <X11/Xproto.h>. */ +#define X_CreateWindow 1 +#define X_ChangeWindowAttributes 2 +#define X_GetWindowAttributes 3 +#define X_DestroyWindow 4 +#define X_DestroySubwindows 5 +#define X_ChangeSaveSet 6 +#define X_ReparentWindow 7 +#define X_MapWindow 8 +#define X_MapSubwindows 9 +#define X_UnmapWindow 10 +#define X_UnmapSubwindows 11 +#define X_ConfigureWindow 12 +#define X_CirculateWindow 13 +#define X_GetGeometry 14 +#define X_QueryTree 15 +#define X_InternAtom 16 +#define X_GetAtomName 17 +#define X_ChangeProperty 18 +#define X_DeleteProperty 19 +#define X_GetProperty 20 +#define X_ListProperties 21 +#define X_SetSelectionOwner 22 +#define X_GetSelectionOwner 23 +#define X_ConvertSelection 24 +#define X_SendEvent 25 +#define X_GrabPointer 26 +#define X_UngrabPointer 27 +#define X_GrabButton 28 +#define X_UngrabButton 29 +#define X_ChangeActivePointerGrab 30 +#define X_GrabKeyboard 31 +#define X_UngrabKeyboard 32 +#define X_GrabKey 33 +#define X_UngrabKey 34 +#define X_AllowEvents 35 +#define X_GrabServer 36 +#define X_UngrabServer 37 +#define X_QueryPointer 38 +#define X_GetMotionEvents 39 +#define X_TranslateCoords 40 +#define X_WarpPointer 41 +#define X_SetInputFocus 42 +#define X_GetInputFocus 43 +#define X_QueryKeymap 44 +#define X_OpenFont 45 +#define X_CloseFont 46 +#define X_QueryFont 47 +#define X_QueryTextExtents 48 +#define X_ListFonts 49 +#define X_ListFontsWithInfo 50 +#define X_SetFontPath 51 +#define X_GetFontPath 52 +#define X_CreatePixmap 53 +#define X_FreePixmap 54 +#define X_CreateGC 55 +#define X_ChangeGC 56 +#define X_CopyGC 57 +#define X_SetDashes 58 +#define X_SetClipRectangles 59 +#define X_FreeGC 60 +#define X_ClearArea 61 +#define X_CopyArea 62 +#define X_CopyPlane 63 +#define X_PolyPoint 64 +#define X_PolyLine 65 +#define X_PolySegment 66 +#define X_PolyRectangle 67 +#define X_PolyArc 68 +#define X_FillPoly 69 +#define X_PolyFillRectangle 70 +#define X_PolyFillArc 71 +#define X_PutImage 72 +#define X_GetImage 73 +#define X_PolyText8 74 +#define X_PolyText16 75 +#define X_ImageText8 76 +#define X_ImageText16 77 +#define X_CreateColormap 78 +#define X_FreeColormap 79 +#define X_CopyColormapAndFree 80 +#define X_InstallColormap 81 +#define X_UninstallColormap 82 +#define X_ListInstalledColormaps 83 +#define X_AllocColor 84 +#define X_AllocNamedColor 85 +#define X_AllocColorCells 86 +#define X_AllocColorPlanes 87 +#define X_FreeColors 88 +#define X_StoreColors 89 +#define X_StoreNamedColor 90 +#define X_QueryColors 91 +#define X_LookupColor 92 +#define X_CreateCursor 93 +#define X_CreateGlyphCursor 94 +#define X_FreeCursor 95 +#define X_RecolorCursor 96 +#define X_QueryBestSize 97 +#define X_QueryExtension 98 +#define X_ListExtensions 99 +#define X_ChangeKeyboardMapping 100 +#define X_GetKeyboardMapping 101 +#define X_ChangeKeyboardControl 102 +#define X_GetKeyboardControl 103 +#define X_Bell 104 +#define X_ChangePointerControl 105 +#define X_GetPointerControl 106 +#define X_SetScreenSaver 107 +#define X_GetScreenSaver 108 +#define X_ChangeHosts 109 +#define X_ListHosts 110 +#define X_SetAccessControl 111 +#define X_SetCloseDownMode 112 +#define X_KillClient 113 +#define X_RotateProperties 114 +#define X_ForceScreenSaver 115 +#define X_SetPointerMapping 116 +#define X_GetPointerMapping 117 +#define X_SetModifierMapping 118 +#define X_GetModifierMapping 119 +#define X_NoOperation 127 + static const value_string opcode_vals[] = { - { 1, "CreateWindow" }, - { 2, "ChangeWindowAttributes" }, - { 3, "GetWindowAttributes" }, - { 4, "DestroyWindow" }, - { 5, "DestroySubwindows" }, - { 6, "ChangeSaveSet" }, - { 7, "ReparentWindow" }, - { 8, "MapWindow" }, - { 9, "MapSubwindows" }, - { 10, "UnmapWindow" }, - { 11, "UnmapSubwindows" }, - { 12, "ConfigureWindow" }, - { 13, "CirculateWindow" }, - { 14, "GetGeometry" }, - { 15, "QueryTree" }, - { 16, "InternAtom" }, - { 17, "GetAtomName" }, - { 18, "ChangeProperty" }, - { 19, "DeleteProperty" }, - { 20, "GetProperty" }, - { 21, "ListProperties" }, - { 22, "SetSelectionOwner" }, - { 23, "GetSelectionOwner" }, - { 24, "ConvertSelection" }, - - { 26, "GrabPointer" }, - { 27, "UngrabPointer" }, - { 28, "GrabButton" }, - { 29, "UngrabButton" }, - { 30, "ChangeActivePointerGrab" }, - { 31, "GrabKeyboard" }, - { 32, "UngrabKeyboard" }, - { 33, "GrabKey" }, - { 34, "UngrabKey" }, - { 35, "AllowEvents" }, - { 36, "GrabServer" }, - { 37, "UngrabServer" }, - { 38, "QueryPointer" }, - { 39, "GetMotionEvents" }, - { 40, "TranslateCoordinates" }, - { 41, "WarpPointer" }, - { 42, "SetInputFocus" }, - { 43, "GetInputFocus" }, - { 44, "QueryKeymap" }, - { 45, "OpenFont" }, - { 46, "CloseFont" }, - { 47, "QueryFont" }, - { 48, "QueryTextExtents" }, - { 49, "ListFonts" }, - { 50, "ListFontsWithInfo" }, - { 51, "SetFontPath" }, - { 52, "GetFontPath" }, - { 53, "CreatePixmap" }, - { 54, "FreePixmap" }, - { 55, "CreateGC" }, - { 56, "ChangeGC" }, - { 57, "CopyGC" }, - { 58, "SetDashes" }, - { 59, "SetClipRectangles" }, - { 60, "FreeGC" }, - { 61, "ClearArea" }, - { 62, "CopyArea" }, - { 63, "CopyPlane" }, - { 64, "PolyPoint" }, - { 65, "PolyLine" }, - { 66, "PolySegment" }, - { 67, "PolyRectangle" }, - { 68, "PolyArc" }, - { 69, "FillPoly" }, - { 70, "PolyFillRectangle" }, - { 71, "PolyFillArc" }, - { 72, "PutImage" }, - { 73, "GetImage" }, - { 74, "PolyText8" }, - { 75, "PolyText16" }, - { 76, "ImageText8" }, - { 77, "ImageText16" }, - { 78, "CreateColormap" }, - { 79, "FreeColormap" }, - { 80, "CopyColormapAndFree" }, - { 81, "InstallColormap" }, - { 82, "UninstallColormap" }, - { 83, "ListInstalledColormaps" }, - { 84, "AllocColor" }, - { 85, "AllocNamedColor" }, - { 86, "AllocColorCells" }, - { 87, "AllocColorPlanes" }, - { 88, "FreeColors" }, - { 89, "StoreColors" }, - { 90, "StoreNamedColor" }, - { 91, "QueryColors" }, - { 92, "LookupColor" }, - { 93, "CreateCursor" }, - { 94, "CreateGlyphCursor" }, - { 95, "FreeCursor" }, - { 96, "RecolorCursor" }, - { 97, "QueryBestSize" }, - { 98, "QueryExtension" }, - { 99, "ListExtensions" }, - { 100, "ChangeKeyboardMapping" }, - { 101, "GetKeyboardMapping" }, - { 102, "ChangeKeyboardControl" }, - { 103, "GetKeyboardControl" }, - { 104, "Bell" }, - { 105, "ChangePointerControl" }, - { 106, "GetPointerControl" }, - { 107, "SetScreenSaver" }, - { 108, "GetScreenSaver" }, - { 109, "ChangeHosts" }, - { 110, "ListHosts" }, - { 111, "SetAccessControl" }, - { 112, "SetCloseDownMode" }, - { 113, "KillClient" }, - { 114, "RotateProperties" }, - { 115, "ForceScreenSaver" }, - { 116, "SetPointerMapping" }, - { 117, "GetPointerMapping" }, - { 118, "SetModifierMapping" }, - { 119, "GetModifierMapping" }, - { 127, "NoOperation" }, - { 0, NULL } + { INITIAL_CONN, "Initial connection request" }, + { X_CreateWindow, "CreateWindow" }, + { X_ChangeWindowAttributes, "ChangeWindowAttributes" }, + { X_GetWindowAttributes, "GetWindowAttributes" }, + { X_DestroyWindow, "DestroyWindow" }, + { X_DestroySubwindows, "DestroySubwindows" }, + { X_ChangeSaveSet, "ChangeSaveSet" }, + { X_ReparentWindow, "ReparentWindow" }, + { X_MapWindow, "MapWindow" }, + { X_MapSubwindows, "MapSubwindows" }, + { X_UnmapWindow, "UnmapWindow" }, + { X_UnmapSubwindows, "UnmapSubwindows" }, + { X_ConfigureWindow, "ConfigureWindow" }, + { X_CirculateWindow, "CirculateWindow" }, + { X_GetGeometry, "GetGeometry" }, + { X_QueryTree, "QueryTree" }, + { X_InternAtom, "InternAtom" }, + { X_GetAtomName, "GetAtomName" }, + { X_ChangeProperty, "ChangeProperty" }, + { X_DeleteProperty, "DeleteProperty" }, + { X_GetProperty, "GetProperty" }, + { X_ListProperties, "ListProperties" }, + { X_SetSelectionOwner, "SetSelectionOwner" }, + { X_GetSelectionOwner, "GetSelectionOwner" }, + { X_ConvertSelection, "ConvertSelection" }, + /* { X_SendEvent, "SendEvent" }, */ + { X_GrabPointer, "GrabPointer" }, + { X_UngrabPointer, "UngrabPointer" }, + { X_GrabButton, "GrabButton" }, + { X_UngrabButton, "UngrabButton" }, + { X_ChangeActivePointerGrab, "ChangeActivePointerGrab" }, + { X_GrabKeyboard, "GrabKeyboard" }, + { X_UngrabKeyboard, "UngrabKeyboard" }, + { X_GrabKey, "GrabKey" }, + { X_UngrabKey, "UngrabKey" }, + { X_AllowEvents, "AllowEvents" }, + { X_GrabServer, "GrabServer" }, + { X_UngrabServer, "UngrabServer" }, + { X_QueryPointer, "QueryPointer" }, + { X_GetMotionEvents, "GetMotionEvents" }, + { X_TranslateCoords, "TranslateCoordinates" }, + { X_WarpPointer, "WarpPointer" }, + { X_SetInputFocus, "SetInputFocus" }, + { X_GetInputFocus, "GetInputFocus" }, + { X_QueryKeymap, "QueryKeymap" }, + { X_OpenFont, "OpenFont" }, + { X_CloseFont, "CloseFont" }, + { X_QueryFont, "QueryFont" }, + { X_QueryTextExtents, "QueryTextExtents" }, + { X_ListFonts, "ListFonts" }, + { X_ListFontsWithInfo, "ListFontsWithInfo" }, + { X_SetFontPath, "SetFontPath" }, + { X_GetFontPath, "GetFontPath" }, + { X_CreatePixmap, "CreatePixmap" }, + { X_FreePixmap, "FreePixmap" }, + { X_CreateGC, "CreateGC" }, + { X_ChangeGC, "ChangeGC" }, + { X_CopyGC, "CopyGC" }, + { X_SetDashes, "SetDashes" }, + { X_SetClipRectangles, "SetClipRectangles" }, + { X_FreeGC, "FreeGC" }, + { X_ClearArea, "ClearArea" }, + { X_CopyArea, "CopyArea" }, + { X_CopyPlane, "CopyPlane" }, + { X_PolyPoint, "PolyPoint" }, + { X_PolyLine, "PolyLine" }, + { X_PolySegment, "PolySegment" }, + { X_PolyRectangle, "PolyRectangle" }, + { X_PolyArc, "PolyArc" }, + { X_FillPoly, "FillPoly" }, + { X_PolyFillRectangle, "PolyFillRectangle" }, + { X_PolyFillArc, "PolyFillArc" }, + { X_PutImage, "PutImage" }, + { X_GetImage, "GetImage" }, + { X_PolyText8, "PolyText8" }, + { X_PolyText16, "PolyText16" }, + { X_ImageText8, "ImageText8" }, + { X_ImageText16, "ImageText16" }, + { X_CreateColormap, "CreateColormap" }, + { X_FreeColormap, "FreeColormap" }, + { X_CopyColormapAndFree, "CopyColormapAndFree" }, + { X_InstallColormap, "InstallColormap" }, + { X_UninstallColormap, "UninstallColormap" }, + { X_ListInstalledColormaps, "ListInstalledColormaps" }, + { X_AllocColor, "AllocColor" }, + { X_AllocNamedColor, "AllocNamedColor" }, + { X_AllocColorCells, "AllocColorCells" }, + { X_AllocColorPlanes, "AllocColorPlanes" }, + { X_FreeColors, "FreeColors" }, + { X_StoreColors, "StoreColors" }, + { X_StoreNamedColor, "StoreNamedColor" }, + { X_QueryColors, "QueryColors" }, + { X_LookupColor, "LookupColor" }, + { X_CreateCursor, "CreateCursor" }, + { X_CreateGlyphCursor, "CreateGlyphCursor" }, + { X_FreeCursor, "FreeCursor" }, + { X_RecolorCursor, "RecolorCursor" }, + { X_QueryBestSize, "QueryBestSize" }, + { X_QueryExtension, "QueryExtension" }, + { X_ListExtensions, "ListExtensions" }, + { X_ChangeKeyboardMapping, "ChangeKeyboardMapping" }, + { X_GetKeyboardMapping, "GetKeyboardMapping" }, + { X_ChangeKeyboardControl, "ChangeKeyboardControl" }, + { X_GetKeyboardControl, "GetKeyboardControl" }, + { X_Bell, "Bell" }, + { X_ChangePointerControl, "ChangePointerControl" }, + { X_GetPointerControl, "GetPointerControl" }, + { X_SetScreenSaver, "SetScreenSaver" }, + { X_GetScreenSaver, "GetScreenSaver" }, + { X_ChangeHosts, "ChangeHosts" }, + { X_ListHosts, "ListHosts" }, + { X_SetAccessControl, "SetAccessControl" }, + { X_SetCloseDownMode, "SetCloseDownMode" }, + { X_KillClient, "KillClient" }, + { X_RotateProperties, "RotateProperties" }, + { X_ForceScreenSaver, "ForceScreenSaver" }, + { X_SetPointerMapping, "SetPointerMapping" }, + { X_GetPointerMapping, "GetPointerMapping" }, + { X_SetModifierMapping, "SetModifierMapping" }, + { X_GetModifierMapping, "GetModifierMapping" }, + { X_NoOperation, "NoOperation" }, + { 0, NULL } +}; + +/* Eventscodes. From <X11/X.h>. */ +#define KeyPress 2 +#define KeyRelease 3 +#define ButtonPress 4 +#define ButtonRelease 5 +#define MotionNotify 6 +#define EnterNotify 7 +#define LeaveNotify 8 +#define FocusIn 9 +#define FocusOut 10 +#define KeymapNotify 11 +#define Expose 12 +#define GraphicsExpose 13 +#define NoExpose 14 +#define VisibilityNotify 15 +#define CreateNotify 16 +#define DestroyNotify 17 +#define UnmapNotify 18 +#define MapNotify 19 +#define MapRequest 20 +#define ReparentNotify 21 +#define ConfigureNotify 22 +#define ConfigureRequest 23 +#define GravityNotify 24 +#define ResizeRequest 25 +#define CirculateNotify 26 +#define CirculateRequest 27 +#define PropertyNotify 28 +#define SelectionClear 29 +#define SelectionRequest 30 +#define SelectionNotify 31 +#define ColormapNotify 32 +#define ClientMessage 33 +#define MappingNotify 34 + +static const value_string eventcode_vals[] = { + { KeyPress, "KeyPress" }, + { KeyRelease, "KeyRelease" }, + { ButtonPress, "ButtonPress" }, + { ButtonRelease, "ButtonRelease" }, + { MotionNotify, "MotionNotify" }, + { EnterNotify, "EnterNotify" }, + { LeaveNotify, "LeaveNotify" }, + { FocusIn, "FocusIn" }, + { FocusOut, "FocusOut" }, + { KeymapNotify, "KeymapNotify" }, + { Expose, "Expose" }, + { GraphicsExpose, "GraphicsExpose" }, + { NoExpose, "NoExpose" }, + { VisibilityNotify, "VisibilityNotify" }, + { CreateNotify, "CreateNotify" }, + { DestroyNotify, "DestroyNotify" }, + { UnmapNotify, "UnmapNotify" }, + { MapNotify, "MapNotify" }, + { MapRequest, "MapRequest" }, + { ReparentNotify, "ReparentNotify" }, + { ConfigureNotify, "ConfigureNotify" }, + { ConfigureRequest, "ConfigureRequest" }, + { GravityNotify, "GravityNotify" }, + { ResizeRequest, "ResizeRequest" }, + { CirculateNotify, "CirculateNotify" }, + { CirculateRequest, "CirculateRequest" }, + { PropertyNotify, "PropertyNotify" }, + { SelectionClear, "SelectionClear" }, + { SelectionRequest, "SelectionRequest" }, + { SelectionNotify, "SelectionNotify" }, + { ColormapNotify, "ColormapNotify" }, + { ClientMessage, "ClientMessage" }, + { MappingNotify, "MappingNotify" }, + { 0, NULL } +}; + +/* Errorcodes. From <X11/X.h> */ +#define Success 0 /* everything's okay */ +#define BadRequest 1 /* bad request code */ +#define BadValue 2 /* int parameter out of range */ +#define BadWindow 3 /* parameter not a Window */ +#define BadPixmap 4 /* parameter not a Pixmap */ +#define BadAtom 5 /* parameter not an Atom */ +#define BadCursor 6 /* parameter not a Cursor */ +#define BadFont 7 /* parameter not a Font */ +#define BadMatch 8 /* parameter mismatch */ +#define BadDrawable 9 /* parameter not a Pixmap or Window */ +#define BadAccess 10 /* depending on context: + - key/button already grabbed + - attempt to free an illegal + cmap entry + - attempt to store into a read-only + color map entry. + - attempt to modify the access control + list from other than the local host. + */ +#define BadAlloc 11 /* insufficient resources */ +#define BadColor 12 /* no such colormap */ +#define BadGC 13 /* parameter not a GC */ +#define BadIDChoice 14 /* choice not in range or already used */ +#define BadName 15 /* font or color name doesn't exist */ +#define BadLength 16 /* Request length incorrect */ +#define BadImplementation 17 /* server is defective */ + +#define FirstExtensionError 128 +#define LastExtensionError 255 + +static const value_string errorcode_vals[] = { + { Success, "Success" }, + { BadRequest, "BadRequest" }, + { BadValue, "BadValue" }, + { BadWindow, "BadWindow" }, + { BadPixmap, "BadPixmap" }, + { BadAtom, "BadAtom" }, + { BadCursor, "BadCursor" }, + { BadFont, "BadFont" }, + { BadMatch, "BadMatch" }, + { BadDrawable, "BadDrawable" }, + { BadAccess, "BadAccess" }, + { BadAlloc, "BadAlloc" }, + { BadColor, "BadColor" }, + { BadGC, "BadGC" }, + { BadIDChoice, "BadIDChoice" }, + { BadName, "BadName" }, + { BadLength, "BadLength" }, + { BadImplementation, "BadImplementation" }, + { FirstExtensionError, "FirstExtensionError" }, + { LastExtensionError, "LastExtensionError" }, + { 0, NULL } }; static const value_string ordering_vals[] = { @@ -620,6 +949,10 @@ static const value_string zero_is_none_vals[] = { { 0, NULL } }; +/* we have not seen packet before. */ +#define PACKET_IS_NEW(pinfo) \ + (!((pinfo)->fd->flags.visited)) + /************************************************************************ *** *** *** F I E L D D E C O D I N G M A C R O S *** @@ -651,9 +984,9 @@ static const value_string zero_is_none_vals[] = { #define FLAG(position, name) {\ proto_tree_add_boolean(bitmask_tree, hf_x11_##position##_mask##_##name, tvb, bitmask_offset, bitmask_size, bitmask_value); } -#define FLAG_IF_NONZERO(position, name) {\ +#define FLAG_IF_NONZERO(position, name) do {\ if (bitmask_value & proto_registrar_get_nth(hf_x11_##position##_mask##_##name) -> bitmask)\ - proto_tree_add_boolean(bitmask_tree, hf_x11_##position##_mask##_##name, tvb, bitmask_offset, bitmask_size, bitmask_value); } + proto_tree_add_boolean(bitmask_tree, hf_x11_##position##_mask##_##name, tvb, bitmask_offset, bitmask_size, bitmask_value); } while (0) #define ATOM(name) { atom(tvb, offsetp, t, hf_x11_##name, little_endian); } #define BITGRAVITY(name) { gravity(tvb, offsetp, t, hf_x11_##name, "Forget"); } @@ -676,31 +1009,43 @@ static const value_string zero_is_none_vals[] = { #define BITMASK16(name) BITMASK(name, 2); #define BITMASK32(name) BITMASK(name, 4); #define BOOL(name) (add_boolean(tvb, offsetp, t, hf_x11_##name)) -#define BUTTON(name) { FIELD8(name); } -#define CARD8(name) { FIELD8(name); } +#define BUTTON(name) FIELD8(name) +#define CARD8(name) FIELD8(name) #define CARD16(name) (FIELD16(name)) #define CARD32(name) (FIELD32(name)) -#define COLOR_FLAGS(name) { colorFlags(tvb, offsetp, t); } -#define COLORMAP(name) { FIELD32(name); } -#define CURSOR(name) { FIELD32(name); } -#define DRAWABLE(name) { FIELD32(name); } +#define COLOR_FLAGS(name) colorFlags(tvb, offsetp, t) +#define COLORMAP(name) FIELD32(name) +#define CURSOR(name) FIELD32(name) +#define DRAWABLE(name) FIELD32(name) #define ENUM8(name) (FIELD8(name)) -#define ENUM16(name) { FIELD16(name); } -#define FONT(name) { FIELD32(name); } -#define FONTABLE(name) { FIELD32(name); } -#define GCONTEXT(name) { FIELD32(name); } -#define INT8(name) { FIELD8(name); } -#define INT16(name) { FIELD16(name); } -#define KEYCODE(name) { FIELD8(name); } +#define ENUM16(name) FIELD16(name) +#define FONT(name) FIELD32(name) +#define FONTABLE(name) FIELD32(name) +#define GCONTEXT(name) FIELD32(name) +#define INT8(name) FIELD8(name) +#define INT16(name) FIELD16(name) +#define INT32(name) FIELD32(name) +#define KEYCODE(name) FIELD8(name) +#define KEYCODE_DECODED(name, keycode, mask) do { \ + proto_tree_add_uint_format(t, hf_x11_##name, tvb, offset, 1, \ + keycode, "keycode: %d (%s)", \ + keycode, keycode2keysymString(state->keycodemap, \ + state->first_keycode, state->keysyms_per_keycode, \ + state->modifiermap, state->keycodes_per_modifier, \ + keycode, mask)); \ + ++offset; \ +} while (0) + #define LISTofARC(name) { listOfArc(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 12, little_endian); } #define LISTofATOM(name, length) { listOfAtom(tvb, offsetp, t, hf_x11_##name, (length) / 4, little_endian); } #define LISTofBYTE(name, length) { listOfByte(tvb, offsetp, t, hf_x11_##name, (length), little_endian); } #define LISTofCARD8(name, length) { listOfByte(tvb, offsetp, t, hf_x11_##name, (length), little_endian); } #define LISTofCARD32(name, length) { listOfCard32(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_item, (length) / 4, little_endian); } #define LISTofCOLORITEM(name, length) { listOfColorItem(tvb, offsetp, t, hf_x11_##name, (length) / 12, little_endian); } -#define LISTofKEYCODE(name, length) { listOfKeycode(tvb, offsetp, t, hf_x11_##name, (length), little_endian); } -#define LISTofKEYSYM(name, keycode_count, keysyms_per_keycode) { \ - listOfKeysyms(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_item, (keycode_count), (keysyms_per_keycode), little_endian); } +#define LISTofKEYCODE(map, name, length) { listOfKeycode(tvb, offsetp, t, hf_x11_##name, map, (length), little_endian); } +#define LISTofKEYSYM(name, map, keycode_first, keycode_count, \ +keysyms_per_keycode) {\ + listOfKeysyms(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_item, map, (keycode_first), (keycode_count), (keysyms_per_keycode), little_endian); } #define LISTofPOINT(name, length) { listOfPoint(tvb, offsetp, t, hf_x11_##name, (length) / 4, little_endian); } #define LISTofRECTANGLE(name) { listOfRectangle(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 8, little_endian); } #define LISTofSEGMENT(name) { listOfSegment(tvb, offsetp, t, hf_x11_##name, (next_offset - *offsetp) / 8, little_endian); } @@ -712,7 +1057,7 @@ static const value_string zero_is_none_vals[] = { #define REQUEST_LENGTH() (requestLength(tvb, offsetp, t, little_endian)) #define SETofEVENT(name) { setOfEvent(tvb, offsetp, t, little_endian); } #define SETofDEVICEEVENT(name) { setOfDeviceEvent(tvb, offsetp, t, little_endian);} -#define SETofKEYMASK(name) { setOfKeyMask(tvb, offsetp, t, little_endian); } +#define SETofKEYMASK(name) { setOfKeyButMask(tvb, offsetp, t, little_endian, 0); } #define SETofPOINTEREVENT(name) { setOfPointerEvent(tvb, offsetp, t, little_endian); } #define STRING8(name, length) { string8(tvb, offsetp, t, hf_x11_##name, length); } #define STRING16(name, length) { string16(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_bytes, length, little_endian); } @@ -726,6 +1071,107 @@ static const value_string zero_is_none_vals[] = { #define VISUALID(name) { gint32 v = VALUE32(tvb, *offsetp); \ proto_tree_add_uint_format(t, hf_x11_##name, tvb, *offsetp, 4, v, "Visualid: 0x%08x%s", v, \ v ? "" : " (CopyFromParent)"); *offsetp += 4; } +#define REPLY(name) FIELD8(name); +#define REPLYLENGTH(name) FIELD32(name); + +#define EVENTCONTENTS_COMMON() do { \ + TIMESTAMP(time); \ + WINDOW(rootwindow); \ + WINDOW(eventwindow); \ + WINDOW(childwindow); \ + INT16(root_x); \ + INT16(root_y); \ + INT16(event_x); \ + INT16(event_y); \ + setOfKeyButMask(tvb, offsetp, t, little_endian, 1); \ +} while (0) + +#define SEQUENCENUMBER_REPLY(name) do { \ + guint16 seqno; \ + \ + seqno = VALUE16(tvb, *offsetp); \ + proto_tree_add_uint_format(t, hf_x11_reply_##name, tvb, \ + *offsetp, sizeof(seqno), seqno, \ + "sequencenumber: %d (%s)", \ + (int)seqno, \ + val_to_str(opcode, opcode_vals, "<Unknown opcode %d>")); \ + *offsetp += sizeof(seqno); \ +} while (0) + +#define REPLYCONTENTS_COMMON() do { \ + REPLY(reply); \ + proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, \ + 1, little_endian); \ + ++offset; \ + SEQUENCENUMBER_REPLY(sequencenumber); \ + REPLYLENGTH(replylength); \ + proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, \ + tvb_reported_length_remaining(tvb, offset), little_endian); \ + offset += tvb_reported_length_remaining(tvb, offset); \ +} while (0) + + +#define HANDLE_REPLY(plen, length_remaining, str, func) do { \ + if (length_remaining < plen) { \ + if (x11_desegment && pinfo->can_desegment) { \ + pinfo->desegment_offset = offset; \ + pinfo->desegment_len = plen - length_remaining;\ + return; \ + } else { \ + ; /* XXX yes, what then? Need to skip/join. */ \ + } \ + } \ + if (length_remaining > plen) \ + length_remaining = plen; \ + next_tvb = tvb_new_subset(tvb, offset, length_remaining, plen); \ + \ + if (sep == NULL) { \ + if (check_col(pinfo->cinfo, COL_INFO)) \ + col_add_str(pinfo->cinfo, COL_INFO, str); \ + sep = ":"; \ + } \ + \ + TRY { \ + func(next_tvb, pinfo, tree, sep, state, little_endian); \ + } \ + \ + CATCH(BoundsError) { \ + RETHROW; \ + } \ + CATCH(ReportedBoundsError) { \ + show_reported_bounds_error(next_tvb, pinfo, tree); \ + } \ + ENDTRY; \ + \ + sep = ","; \ +} while (0) + +static void +dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *sep, x11_conv_data_t *volatile state, gboolean + little_endian); + +static void +dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *sep, x11_conv_data_t *volatile state, gboolean + little_endian); + +static void +dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *sep, x11_conv_data_t *volatile state, + gboolean little_endian); + +static void +dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *sep, x11_conv_data_t *volatile state, + gboolean little_endian); + +static void +x11_stateinit(x11_conv_data_t **state, conversation_t *conversation); + +static const char * +keysymString(guint32 v); + /************************************************************************ *** *** @@ -946,6 +1392,186 @@ static gint compareGuint32(gconstpointer a, gconstpointer b) return GPOINTER_TO_INT(b) - GPOINTER_TO_INT(a); } +static const char * +keycode2keysymString(int *keycodemap[256], int first_keycode, + int keysyms_per_keycode, + int *modifiermap[array_length(modifiers)], + int keycodes_per_modifier, + guint32 keycode, guint32 bitmask) +{ + static char buf[32]; + int *syms; + int groupmodkc, numlockkc, numlockmod, groupmod; + int lockmod_is_capslock = 0, lockmod_is_shiftlock = 0; + int lockmod_is_nosymbol = 1; + int modifier, kc, keysym; + + if ((syms = keycodemap[keycode]) == NULL) + return "<Unknown>"; + + for (kc = first_keycode, groupmodkc = numlockkc = -1; kc < 256; ++kc) + for (keysym = 0; keysym < keysyms_per_keycode; ++keysym) + switch (keycodemap[kc][keysym]) { + case 0xff7e: + groupmodkc = kc; + break; + + case 0xff7f: + numlockkc = kc; + break; + + case 0xffe5: + lockmod_is_capslock = kc; + break; + + case 0xffe6: + lockmod_is_shiftlock = kc; + break; + } + + + /* + * If we have not seen the modifiermap we don't know what the + * keycode translates to, but we do know it's one of the keys + * in syms (give or take a case-conversion), so we could in + * theory list them all. + */ + if (modifiermap[array_length(modifiers) - 1] == NULL) /* all or none */ + return "<Unknown>"; + + /* find out what the numlockmodifer and groupmodifier is. */ + for (modifier = 0, numlockmod = groupmod = -1; + modifier < (int)array_length(modifiers) && numlockmod == -1; + ++modifier) + for (kc = 0; kc < keycodes_per_modifier; ++kc) + if (modifiermap[modifier][kc] == numlockkc) + numlockmod = modifier; + else if (modifiermap[modifier][kc] == groupmodkc) + groupmod = modifier; + + /* + * ... and what the lockmodifier is interpreted as. + * (X11v4r6 ref, keyboard and pointers section.) + */ + for (kc = 0; kc < keycodes_per_modifier; ++kc) + if (modifiermap[1][kc] == lockmod_is_capslock) { + lockmod_is_shiftlock = lockmod_is_nosymbol = 0; + break; + } + else if (modifiermap[0][kc] == lockmod_is_shiftlock) { + lockmod_is_capslock = lockmod_is_nosymbol = 0; + break; + } + +#if 0 + /* + * This is (how I understand) the X11v4R6 protocol description given + * in A. Nye's book. It is quite different from the + * code in _XTranslateKey() in the file + * "$XConsortium: KeyBind.c /main/55 1996/02/02 14:08:55 kaleb $" + * as shipped with XFree, and doesn't work correctly, nor do I see + * how it could (e.g. the case of lower/uppercase-letters). + * -- Michael Shuldman + */ + + if (numlockmod >= 0 && (bitmask & modifiermask[numlockmod]) + && ((keycodemap[keycode][1] >= 0xff80 + && keycodemap[keycode][1] <= 0xffbd) + || (keycodemap[keycode][1] >= 0x11000000 + && keycodemap[keycode][1] <= 0x1100ffff))) { + if ((bitmask & ShiftMask) || lockmod_is_shiftlock) + return keysymString(keycodemap[keycode][groupmod + 0]); + else + if (keycodemap[keycode][groupmod + 1] == NoSymbol) + return keysymString(keycodemap[keycode] + [groupmod + 0]); + else + return keysymString(keycodemap[keycode] + [groupmod + 1]); + } + else if (!(bitmask & ShiftMask) && !(bitmask & LockMask)) + return keysymString(keycodemap[keycode][groupmod + 0]); + else if (!(bitmask & ShiftMask) + && ((bitmask & LockMask) && lockmod_is_capslock)) + if (islower(keycodemap[keycode][groupmod + 0])) +/* return toupper(keysymString(keycodemap[keycode][groupmod + 0])); */ + return "Uppercase"; /* XXX */ + else + return keysymString(keycodemap[keycode][groupmod + 0]); + + else if ((bitmask & ShiftMask) + && ((bitmask & LockMask) && lockmod_is_capslock)) + if (islower(keycodemap[keycode][groupmod + 1])) +/* return toupper(keysymString(keycodemap[keycode][groupmod + 1])); */ + return "Uppercase"; /* XXX */ + else + return keysymString(keycodemap[keycode][groupmod + 1]); + + else if ((bitmask & ShiftMask) + || ((bitmask & LockMask) && lockmod_is_shiftlock)) + return keysymString(keycodemap[keycode][groupmod + 1]); +#else /* _XTranslateKey() based code. */ + + while (keysyms_per_keycode > 2 + && keycodemap[keysyms_per_keycode - 1] == NoSymbol) + --keysyms_per_keycode; + if (keysyms_per_keycode > 2 + && (groupmod >= 0 && (modifiermask[groupmod] & bitmask))) { + syms += 2; + keysyms_per_keycode -= 2; + } + + if (numlockmod >= 0 && (bitmask & modifiermask[numlockmod]) + && keysyms_per_keycode > 1 && ((syms[1] >= 0xff80 && syms[1] <= 0xffbd) + || (syms[1] >= 0x11000000 && syms[1] <= 0x1100ffff))) { + if ((bitmask & ShiftMask) + || (bitmask & LockMask && lockmod_is_shiftlock)) + keysym = syms[0]; + else + keysym = syms[1]; + } + else if (!(bitmask & ShiftMask) + && (!(bitmask & LockMask) || lockmod_is_nosymbol)) { + if (keysyms_per_keycode == 1 + || (keysyms_per_keycode > 1 && syms[1] == NoSymbol)) { + int usym; + + XConvertCase(syms[0], &keysym, &usym); + } + else + keysym = syms[0]; + } + else if (!(bitmask & LockMask) || !lockmod_is_capslock) { + int lsym, usym; + + if (keysyms_per_keycode == 1 + || (keysyms_per_keycode > 1 && (usym = syms[1]) == NoSymbol)) + XConvertCase(syms[0], &lsym, &usym); + keysym = usym; + } + else { + int lsym, usym; + + if (keysyms_per_keycode == 1 + || (keysyms_per_keycode > 1 && syms[1] == NoSymbol)) + keysym = syms[0]; + + XConvertCase(keysym, &lsym, &usym); + + if (!(bitmask & ShiftMask) && keysym != syms[0] + && ((keysym != usym) || (lsym == usym))) + XConvertCase(syms[0], &lsym, &usym); + keysym = usym; + } + + if (keysym == XK_VoidSymbol) + keysym = NoSymbol; + + sprintf(buf, "%d, \"%s\"", keysym, keysymString(keysym)); + return buf; +#endif +} + static const char *keysymString(guint32 v) { gpointer res; @@ -959,55 +1585,110 @@ static const char *keysymString(guint32 v) g_tree_insert(keysymTable, GINT_TO_POINTER(p -> value), p -> strptr); } res = g_tree_lookup(keysymTable, GINT_TO_POINTER(v)); - return res ? res : "Unknown"; + return res ? res : "<Unknown>"; } -static const char *modifiers[] = { "Shift", "Lock", "Control", "Mod1", "Mod2", "Mod3", "Mod4", "Mod5" }; - static void listOfKeycode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, - int length, gboolean little_endian) + int *modifiermap[], int keycodes_per_modifier, + gboolean little_endian) { char buffer[1024]; - proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, little_endian); + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, + array_length(modifiers) * keycodes_per_modifier, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_keycode); + size_t m; - while(length--) { + for (m = 0; m < array_length(modifiers); + ++m, *offsetp += keycodes_per_modifier) { char *bp = buffer; - const char **m; int i; - for(i = 8, m = modifiers; i; i--, m++) { - guchar c = tvb_get_guint8(tvb, *offsetp); - *offsetp += 1; + modifiermap[m] = g_malloc(keycodes_per_modifier); + + for(i = 0; i < keycodes_per_modifier; ++i) { + guchar c = tvb_get_guint8(tvb, *offsetp + i); + if (c) - bp += sprintf(bp, " %s=%d", *m, c); + bp += sprintf(bp, " %s=%d", modifiers[m], c); + + modifiermap[m][i] = c; } - proto_tree_add_bytes_format(tt, hf_x11_keycodes_item, tvb, *offsetp - 8, 8, tvb_get_ptr(tvb, *offsetp - 8, 8), "item: %s", buffer); + proto_tree_add_bytes_format(tt, hf_x11_keycodes_item, tvb, + *offsetp, keycodes_per_modifier, + tvb_get_ptr(tvb, *offsetp, keycodes_per_modifier), + "item: %s", buffer); } } static void listOfKeysyms(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, - int hf_item, int keycode_count, + int hf_item, int *keycodemap[256], + int keycode_first, int keycode_count, int keysyms_per_keycode, gboolean little_endian) { proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, keycode_count * keysyms_per_keycode * 4, little_endian); proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_keysyms); proto_item *tti; proto_tree *ttt; - int i; + int i, keycode; + + g_assert(keycode_first >= 0); + g_assert(keycode_count >= 0); + g_assert((size_t)(keycode_first + keycode_count) <= 256); + + + for (keycode = keycode_first; keycode_count > 0; + ++keycode, --keycode_count) { + tti = proto_tree_add_none_format(tt, hf_item, tvb, *offsetp, + keysyms_per_keycode * 4, "keysyms (keycode %d):", keycode); - while(keycode_count--) { - tti = proto_tree_add_none_format(tt, hf_item, tvb, *offsetp, keysyms_per_keycode * 4, - "keysyms:"); ttt = proto_item_add_subtree(tti, ett_x11_keysym); - for(i = keysyms_per_keycode; i; i--) { + + keycodemap[keycode] + = g_malloc(sizeof(*keycodemap[keycode]) * keysyms_per_keycode); + + for(i = 0; i < keysyms_per_keycode; ++i) { + /* keysymvalue = byte3 * 256 + byte4. */ guint32 v = VALUE32(tvb, *offsetp); + proto_item_append_text(tti, " %s", keysymString(v)); - proto_tree_add_uint_format(ttt, hf_x11_keysyms_item_keysym, tvb, *offsetp, 4, v, - "keysym: 0x%08x (%s)", v, keysymString(v)); + proto_tree_add_uint_format(ttt, hf_x11_keysyms_item_keysym, + tvb, *offsetp, 4, v, + "keysym (keycode %d): 0x%08x (%s)", + keycode, v, keysymString(v)); + + keycodemap[keycode][i] = v; *offsetp += 4; } + + for (i = 1; i < keysyms_per_keycode; ++i) + if (keycodemap[keycode][i] != NoSymbol) + break; + + if (i == keysyms_per_keycode) { + /* all but (possibly) first were NoSymbol. */ + if (keysyms_per_keycode == 4) { + keycodemap[keycode][1] = NoSymbol; + keycodemap[keycode][2] = keycodemap[keycode][0]; + keycodemap[keycode][3] = NoSymbol; + } + + continue; + } + + for (i = 2; i < keysyms_per_keycode; ++i) + if (keycodemap[keycode][i] != NoSymbol) + break; + if (i == keysyms_per_keycode) { + /* all but (possibly) first two were NoSymbol. */ + if (keysyms_per_keycode == 4) { + keycodemap[keycode][2] = keycodemap[keycode][0]; + keycodemap[keycode][3] = keycodemap[keycode][1]; + } + + continue; + } } } @@ -1294,8 +1975,8 @@ static guint32 field8(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, enumValue = match_strval(v, cVALS(hfi -> strings)); if (enumValue) proto_tree_add_uint_format(t, hf, tvb, *offsetp, 1, v, - hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%02x (%s)", - hfi -> name, v, enumValue); + hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%02x (%s)", + hfi -> name, v, enumValue); else proto_tree_add_item(t, hf, tvb, *offsetp, 1, little_endian); *offsetp += 1; @@ -1306,7 +1987,17 @@ static guint32 field16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, gboolean little_endian) { guint32 v = VALUE16(tvb, *offsetp); - proto_tree_add_item(t, hf, tvb, *offsetp, 2, little_endian); + header_field_info *hfi = proto_registrar_get_nth(hf); + gchar *enumValue = NULL; + + if (hfi -> strings) + enumValue = match_strval(v, cVALS(hfi -> strings)); + if (enumValue) + proto_tree_add_uint_format(t, hf, tvb, *offsetp, 2, v, + hfi -> display == BASE_DEC ? "%s: %u (%s)" : "%s: 0x%02x (%s)", + hfi -> name, v, enumValue); + else + proto_tree_add_item(t, hf, tvb, *offsetp, 2, little_endian); *offsetp += 2; return v; } @@ -1396,10 +2087,10 @@ static void gcMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, static guint32 requestLength(tvbuff_t *tvb, int *offsetp, proto_tree *t, gboolean little_endian) { - guint32 res = VALUE16(tvb, *offsetp) * 4; + guint32 res = VALUE16(tvb, *offsetp); proto_tree_add_uint(t, hf_x11_request_length, tvb, *offsetp, 2, res); *offsetp += 2; - return res; + return res * 4; } static void setOfEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t, @@ -1454,8 +2145,9 @@ static void setOfDeviceEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t, ENDBITMASK; } -static void setOfKeyMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, - gboolean little_endian) + +static void setOfKeyButMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, + gboolean little_endian, gboolean butmask) { proto_item *ti; guint32 bitmask_value; @@ -1466,7 +2158,8 @@ static void setOfKeyMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, bitmask_value = VALUE16(tvb, *offsetp); bitmask_offset = *offsetp; bitmask_size = 2; - if (bitmask_value == 0x8000) + + if (!butmask && bitmask_value == 0x8000) proto_tree_add_uint_format(t, hf_x11_modifiers_mask_AnyModifier, tvb, *offsetp, 2, 0x8000, "modifiers-masks: 0x8000 (AnyModifier)"); else { @@ -1481,11 +2174,24 @@ static void setOfKeyMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, FLAG(modifiers, Mod3); FLAG(modifiers, Mod4); FLAG(modifiers, Mod5); - FLAG_IF_NONZERO(modifiers, erroneous_bits); + + if (butmask) { + FLAG(modifiers, Button1); + FLAG(modifiers, Button2); + FLAG(modifiers, Button3); + FLAG(modifiers, Button4); + FLAG(modifiers, Button5); + } + + if (butmask) + FLAG_IF_NONZERO(keybut, erroneous_bits); + else + FLAG_IF_NONZERO(modifiers, erroneous_bits); } *offsetp += 2; } + static void setOfPointerEvent(tvbuff_t *tvb, int *offsetp, proto_tree *t, gboolean little_endian) { @@ -1590,37 +2296,6 @@ static void windowAttributes(tvbuff_t *tvb, int *offsetp, proto_tree *t, ENDBITMASK; } -/* - * Data structure associated with a conversation; keeps track of the - * request for which we're expecting a reply, the frame number of - * the initial connection request, and the byte order of the connection. - * - * An opcode of -3 means we haven't yet seen any requests yet. - * An opcode of -2 means we're not expecting a reply. - * An opcode of -1 means means we're waiting for a reply to the initial - * connection request. - * Other values are the opcode of the request for which we're expecting - * a reply. - * - * XXX - assumes only one outstanding request is awaiting a reply, - * which should always be the case. - */ -#define NOTHING_SEEN -3 -#define NOTHING_EXPECTED -2 -#define INITIAL_CONN -1 - -#define BYTE_ORDER_BE 0 -#define BYTE_ORDER_LE 1 -#define BYTE_ORDER_UNKNOWN -1 - -typedef struct { - int opcode; /* opcode for which we're awaiting a reply */ - guint32 iconn_frame; /* frame # of initial connection request */ - int byte_order; /* byte order of connection */ -} x11_conv_data_t; - -static GMemChunk *x11_state_chunk = NULL; - static void x11_init_protocol(void) { if (x11_state_chunk != NULL) @@ -1690,67 +2365,67 @@ static int rounded4(int n) static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, guint16 (*v16)(tvbuff_t *, gint)) { switch(tvb_get_guint8(tvb, offset)) { - case 1: /* CreateWindow */ + case X_CreateWindow: return !tvb_bytes_exist(tvb, offset, 32) || length == 8 + numberOfBitSet(tvb, offset + 7 * 4, 4); - case 2: /* ChangeWindowAttributes */ - case 56: /* ChangeGC */ + case X_ChangeWindowAttributes: + case X_ChangeGC: return !tvb_bytes_exist(tvb, offset, 12) || length == 3 + numberOfBitSet(tvb, offset + 8, 4); - case 3: /* GetWindowAttributes */ - case 4: /* DestroyWindow */ - case 5: /* DestroySubwindows */ - case 6: /* ChangeSaveSet */ - case 8: /* MapWindow */ - case 9: /* MapSubWindow */ - case 10: /* UnmapWindow */ - case 11: /* UnmapSubwindows */ - case 13: /* CirculateWindow */ - case 14: /* GetGeometry */ - case 15: /* QueryTree */ - case 17: /* GetAtomName */ - case 21: /* ListProperties */ - case 23: /* GetSelectionOwner */ - case 27: /* UngrabPointer */ - case 32: /* UngrabKeyboard */ - case 35: /* AllowEvents */ - case 38: /* QueryPointer */ - case 46: /* CloseFont */ - case 47: /* QueryFont */ - case 54: /* FreePixmap */ - case 60: /* FreeGC */ - case 79: /* FreeColormap */ - case 81: /* InstallColormap */ - case 82: /* UninstallColormap */ - case 83: /* ListInstalledColormaps */ - case 95: /* FreeCursor */ - case 101: /* GetKeyboardMapping */ - case 113: /* KillClient */ + case X_GetWindowAttributes: + case X_DestroyWindow: + case X_DestroySubwindows: + case X_ChangeSaveSet: + case X_MapWindow: + case X_MapSubwindows: + case X_UnmapWindow: + case X_UnmapSubwindows: + case X_CirculateWindow: + case X_GetGeometry: + case X_QueryTree: + case X_GetAtomName: + case X_ListProperties: + case X_GetSelectionOwner: + case X_UngrabPointer: + case X_UngrabKeyboard: + case X_AllowEvents: + case X_QueryPointer: + case X_CloseFont: + case X_QueryFont: + case X_FreePixmap: + case X_FreeGC: + case X_FreeColormap: + case X_InstallColormap: + case X_UninstallColormap: + case X_ListInstalledColormaps: + case X_FreeCursor: + case X_GetKeyboardMapping: + case X_KillClient: return length == 2; - case 7: /* ReparentWindow */ - case 22: /* SetSelectionOwner */ - case 30: /* ChangeActivePointerGrab */ - case 31: /* GrabKeyboard */ - case 33: /* GrabKey */ - case 39: /* GetMotionEvents */ - case 40: /* TranslateCoordinates */ - case 53: /* CreatePixmap */ - case 57: /* CopyGC */ - case 61: /* ClearArea */ - case 78: /* CreateColormap */ - case 84: /* AllocColor */ - case 87: /* AllocColorPlanes */ + case X_ReparentWindow: + case X_SetSelectionOwner: + case X_ChangeActivePointerGrab: + case X_GrabKeyboard: + case X_GrabKey: + case X_GetMotionEvents: + case X_TranslateCoords: + case X_CreatePixmap: + case X_CopyGC: + case X_ClearArea: + case X_CreateColormap: + case X_AllocColor: + case X_AllocColorPlanes: return length == 4; - case 12: /* ConfigureWindow */ + case X_ConfigureWindow: return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + numberOfBitSet(tvb, offset + 8, 2); - case 16: /* InternAtom */ - case 98: /* QueryExtension */ + case X_InternAtom: + case X_QueryExtension: return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + rounded4(v16(tvb, offset + 4)); - case 18: /* ChangeProperty */ + case X_ChangeProperty: { int multiplier, type; if (!tvb_bytes_exist(tvb, offset, 17)) return TRUE; @@ -1761,139 +2436,139 @@ static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, guint return length == 6 + rounded4((v16 == tvb_get_letohs ? tvb_get_letohl : tvb_get_ntohl)(tvb, offset + 20) * multiplier); } - case 19: /* DeleteProperty */ - case 29: /* UngrabButton */ - case 34: /* UngrabKey */ - case 42: /* SetInputFocus */ - case 80: /* CopyColormapAndFree */ - case 86: /* AllocColorCells */ - case 97: /* QueryBestSize */ - case 105: /* ChangePointerControl */ - case 107: /* SetScreenSaver */ + case X_DeleteProperty: + case X_UngrabButton: + case X_UngrabKey: + case X_SetInputFocus: + case X_CopyColormapAndFree: + case X_AllocColorCells: + case X_QueryBestSize: + case X_ChangePointerControl: + case X_SetScreenSaver: return length == 3; - case 20: /* GetProperty */ - case 24: /* ConvertSelection */ - case 26: /* GrabPointer */ - case 28: /* GrabButton */ - case 41: /* WarpPointer */ + case X_GetProperty: + case X_ConvertSelection: + case X_GrabPointer: + case X_GrabButton: + case X_WarpPointer: return length == 6; - case 25: /* SendEvent */ + case X_SendEvent: return length == 11; - case 36: /* GrabServer */ - case 37: /* UngrabServer */ - case 43: /* GetInputFocus */ - case 44: /* QueryKeymap */ - case 52: /* GetFontPath */ - case 99: /* ListExtensions */ - case 103: /* GetKeyboardControl */ - case 104: /* Bell */ - case 106: /* GetPointerControl */ - case 108: /* GetScreenSaver */ - case 110: /* ListHosts */ - case 111: /* SetAccessControl */ - case 112: /* SetCloseDownMode */ - case 115: /* ForceScreenSaver */ - case 117: /* GetPointerMapping */ - case 119: /* GetModifierMapping */ + case X_GrabServer: + case X_UngrabServer: + case X_GetInputFocus: + case X_QueryKeymap: + case X_GetFontPath: + case X_ListExtensions: + case X_GetKeyboardControl: + case X_Bell: + case X_GetPointerControl: + case X_GetScreenSaver: + case X_ListHosts: + case X_SetAccessControl: + case X_SetCloseDownMode: + case X_ForceScreenSaver: + case X_GetPointerMapping: + case X_GetModifierMapping: return length == 1; - case 45: /* OpenFont */ - case 85: /* AllocNamedColor */ - case 92: /* LookupColor */ + case X_OpenFont: + case X_AllocNamedColor: + case X_LookupColor: return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + rounded4(v16(tvb, offset + 8)); - case 48: /* QueryTextExtents */ + case X_QueryTextExtents: return length >= 2; - case 49: /* ListFonts */ - case 50: /* ListFontsWithInfo */ - case 109: /* ChangeHosts */ + case X_ListFonts: + case X_ListFontsWithInfo: + case X_ChangeHosts: return !tvb_bytes_exist(tvb, offset, 8) || length == 2 + rounded4(v16(tvb, offset + 6)); - case 51: /* SetFontPath */ + case X_SetFontPath: if (length < 2) return FALSE; if (!tvb_bytes_exist(tvb, offset, 8)) return TRUE; return listOfStringLengthConsistent(tvb, offset + 8, (length - 2) * 4, v16(tvb, offset + 4)); - case 55: /* CreateGC */ + case X_CreateGC: return !tvb_bytes_exist(tvb, offset, 16) || length == 4 + numberOfBitSet(tvb, offset + 12, 4); - case 58: /* SetDashes */ + case X_SetDashes: return !tvb_bytes_exist(tvb, offset, 12) || length == 3 + rounded4(v16(tvb, offset + 10)); - case 59: /* SetClipRectangles */ - case 66: /* PolySegment */ - case 67: /* PolyRectangle */ - case 70: /* PolyFillRectangle */ + case X_SetClipRectangles: + case X_PolySegment: + case X_PolyRectangle: + case X_PolyFillRectangle: return length >= 3 && (length - 3) % 2 == 0; - case 62: /* CopyArea */ + case X_CopyArea: return length == 7; - case 63: /* CopyPlane */ - case 93: /* CreateCursor */ - case 94: /* CreateGlyphCursor */ + case X_CopyPlane: + case X_CreateCursor: + case X_CreateGlyphCursor: return length == 8; - case 64: /* PolyPoint */ - case 65: /* PolyLine */ - case 88: /* FreeColors */ + case X_PolyPoint: + case X_PolyLine: + case X_FreeColors: return length >= 3; - case 68: /* PolyArc */ - case 71: /* PolyFillArc */ + case X_PolyArc: + case X_PolyFillArc: return length >= 3 && (length - 3) % 3 == 0; - case 69: /* FillPoly */ - case 76: /* ImageText8 */ + case X_FillPoly: + case X_ImageText8: return length >= 4; - case 72: /* PutImage */ + case X_PutImage: return length >= 6; - case 73: /* GetImage */ - case 96: /* RecolorCursor */ + case X_GetImage: + case X_RecolorCursor: return length == 5; - case 74: /* PolyText8 */ + case X_PolyText8: if (length < 4) return FALSE; return TRUE; /* We don't perform many controls on this one */ - case 75: /* PolyText16 */ + case X_PolyText16: if (length < 4) return FALSE; return TRUE; /* We don't perform many controls on this one */ - case 77: /* ImageText16 */ + case X_ImageText16: return length >= 4; - case 89: /* StoreColors */ + case X_StoreColors: return length > 2 && (length - 2) % 3 == 0; - case 90: /* StoreNamedColor */ + case X_StoreNamedColor: return !tvb_bytes_exist(tvb, offset, 14) || length == 4 + rounded4(v16(tvb, offset + 12)); - case 91: /* QueryColors */ + case X_QueryColors: return length >= 2; - case 100: /* ChangeKeyboardMapping */ + case X_ChangeKeyboardMapping: return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + tvb_get_guint8(tvb, 1) * tvb_get_guint8(tvb, 5); - case 102: /* ChangeKeyboardControl */ + case X_ChangeKeyboardControl: return !tvb_bytes_exist(tvb, offset, 6) || length == 2 + numberOfBitSet(tvb, offset + 4, 2); - case 114: /* RotateProperties */ + case X_RotateProperties: return !tvb_bytes_exist(tvb, offset, 10) || length == 3 + v16(tvb, offset + 8); - case 116: /* SetPointerMapping */ + case X_SetPointerMapping: return length == 1 + rounded4(tvb_get_guint8(tvb, 1)); - case 118: /* SetModifierMapping */ + case X_SetModifierMapping: return length == 1 + tvb_get_guint8(tvb, 1) * 2; - case 127: /* NoOperation */ + case X_NoOperation: return length >= 1; default: @@ -1921,16 +2596,16 @@ static int x_endian_match(tvbuff_t *tvb, guint16 (*v16)(tvbuff_t *, gint)) static gboolean guess_byte_ordering(tvbuff_t *tvb, packet_info *pinfo, - x11_conv_data_t *state_info) + x11_conv_data_t *state) { /* With X the client gives the byte ordering for the protocol, and the port on the server tells us we're speaking X. */ int le, be, decision, decisionToCache; - if (state_info->byte_order == BYTE_ORDER_BE) + if (state->byte_order == BYTE_ORDER_BE) return FALSE; /* known to be big-endian */ - else if (state_info->byte_order == BYTE_ORDER_LE) + else if (state->byte_order == BYTE_ORDER_LE) return TRUE; /* known to be little-endian */ if (pinfo->srcport == pinfo->match_port) { @@ -1967,7 +2642,7 @@ guess_byte_ordering(tvbuff_t *tvb, packet_info *pinfo, /* * Remember the decision. */ - state_info->byte_order = decision ? BYTE_ORDER_LE : BYTE_ORDER_BE; + state->byte_order = decision ? BYTE_ORDER_LE : BYTE_ORDER_BE; } /* @@ -1987,7 +2662,7 @@ guess_byte_ordering(tvbuff_t *tvb, packet_info *pinfo, * Decode an initial connection request. */ static void dissect_x11_initial_conn(tvbuff_t *tvb, packet_info *pinfo, - proto_tree *tree, x11_conv_data_t *state_info, gboolean little_endian) + proto_tree *tree, x11_conv_data_t *state, gboolean little_endian) { int offset = 0; int *offsetp = &offset; @@ -1997,6 +2672,7 @@ static void dissect_x11_initial_conn(tvbuff_t *tvb, packet_info *pinfo, gint left; ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); + proto_item_append_text(ti, ", Request, Initial connection request"); t = proto_item_add_subtree(ti, ett_x11); CARD8(byte_order); @@ -2006,31 +2682,84 @@ static void dissect_x11_initial_conn(tvbuff_t *tvb, packet_info *pinfo, auth_proto_name_length = CARD16(authorization_protocol_name_length); auth_proto_data_length = CARD16(authorization_protocol_data_length); UNUSED(2); + if (auth_proto_name_length != 0) { STRING8(authorization_protocol_name, auth_proto_name_length); offset = ROUND_LENGTH(offset); } + if (auth_proto_data_length != 0) { STRING8(authorization_protocol_data, auth_proto_data_length); offset = ROUND_LENGTH(offset); } - left = tvb_length_remaining(tvb, offset); - if (left) - proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, left, little_endian); + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, left, + little_endian); /* * This is the initial connection request... */ - state_info->iconn_frame = pinfo->fd->num; + state->iconn_frame = pinfo->fd->num; /* * ...and we're expecting a reply to it. */ - state_info->opcode = INITIAL_CONN; + state->sequencenumber = 0; + g_hash_table_insert(state->seqtable, (int *)state->sequencenumber, + (int *)INITIAL_CONN); +} + +static void dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, const char _U_ *sep, x11_conv_data_t *state, + gboolean little_endian) +{ + int offset = 0, *offsetp = &offset, left; + unsigned char success; + int length_of_vendor; + proto_item *ti; + proto_tree *t; + + ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); + proto_item_append_text(ti, ", Reply, Initial connection reply"); + t = proto_item_add_subtree(ti, ett_x11); + + state->iconn_reply = pinfo->fd->num; + success = INT8(success); + if (success == 0) { + UNDECODED(1); + } + else { + UNUSED(1); + } + + INT16(protocol_major_version); + INT16(protocol_minor_version); + INT16(replylength); + INT32(release_number); + INT32(resource_id_base); + INT32(resource_id_mask); + INT32(motion_buffer_size); + length_of_vendor = INT16(length_of_vendor); + INT16(maximum_request_length); + INT8(number_of_screens_in_roots); + INT8(number_of_formats_in_pixmap_formats); + INT8(image_byte_order); + INT8(bitmap_format_bit_order); + INT8(bitmap_format_scanline_unit); + INT8(bitmap_format_scanline_pad); + INT8(min_keycode); + INT8(max_keycode); + UNUSED(4); + STRING8(vendor, length_of_vendor); + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + UNDECODED(left); + } static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, - proto_tree *tree, const char *sep, x11_conv_data_t *state_info, + proto_tree *tree, const char *sep, x11_conv_data_t *state, gboolean little_endian) { int offset = 0; @@ -2039,10 +2768,11 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, proto_item *ti; proto_tree *t; int length, opcode; - guint8 v8, v8_2; + guint8 v8, v8_2, v8_3; guint16 v16; guint32 v32; gint left; + char *str; length = VALUE16(tvb, 2) * 4; @@ -2056,70 +2786,88 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); t = proto_item_add_subtree(ti, ett_x11); + if (PACKET_IS_NEW(pinfo)) + ++state->sequencenumber; + OPCODE(); if (check_col(pinfo->cinfo, COL_INFO)) col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", sep, - val_to_str(opcode, opcode_vals, "Unknown (%u)")); + val_to_str(opcode, opcode_vals, "<Unknown opcode %d>")); + + str = g_strdup_printf(", Request, opcode: %d (%s)", + opcode, val_to_str(opcode, opcode_vals, + "<Unknown opcode %d>")); + + proto_item_append_text(ti, str); + g_free(str); /* * Does this request expect a reply? */ switch(opcode) { - - case 3: /* GetWindowAttributes */ - case 14: /* GetGeometry */ - case 15: /* QueryTree */ - case 16: /* InternAtom */ - case 17: /* GetAtomName */ - case 20: /* GetProperty */ - case 21: /* ListProperties */ - case 23: /* GetSelectionOwner */ - case 26: /* GrabPointer */ - case 31: /* GrabKeyboard */ - case 38: /* QueryPointer */ - case 39: /* GetMotionEvents */ - case 40: /* TranslateCoordinates */ - case 44: /* QueryKeymap */ - case 47: /* QueryFont */ - case 48: /* QueryTextExtents */ - case 49: /* ListFonts */ - case 73: /* GetImage */ - case 83: /* ListInstalledColormaps */ - case 84: /* AllocColor */ - case 91: /* QueryColors */ - case 92: /* LookupColor */ - case 97: /* QueryBestSize */ - case 98: /* QueryExtension */ - case 99: /* ListExtensions */ - case 101: /* GetKeyboardMapping */ - case 103: /* GetKeyboardControl */ - case 106: /* GetPointerControl */ - case 108: /* GetScreenSaver */ - case 110: /* ListHosts */ - case 116: /* SetPointerMapping */ - case 117: /* GetPointerMapping */ - case 118: /* SetModifierMapping */ - case 119: /* GetModifierMapping */ - /* - * Those requests expect a reply. - */ - state_info->opcode = opcode; - break; + case X_AllocColor: + case X_AllocColorCells: + case X_AllocColorPlanes: + case X_AllocNamedColor: + case X_GetAtomName: + case X_GetFontPath: + case X_GetGeometry: + case X_GetImage: + case X_GetInputFocus: + case X_GetKeyboardControl: + case X_GetKeyboardMapping: + case X_GetModifierMapping: + case X_GetMotionEvents: + case X_GetPointerControl: + case X_GetPointerMapping: + case X_GetProperty: + case X_GetScreenSaver: + case X_GetSelectionOwner: + case X_GetWindowAttributes: + case X_GrabKeyboard: + case X_GrabPointer: + case X_InternAtom: + case X_ListExtensions: + case X_ListFonts: + case X_ListFontsWithInfo: + case X_ListHosts: + case X_ListInstalledColormaps: + case X_ListProperties: + case X_LookupColor: + case X_QueryBestSize: + case X_QueryColors: + case X_QueryExtension: + case X_QueryFont: + case X_QueryKeymap: + case X_QueryPointer: + case X_QueryTextExtents: + case X_QueryTree: + case X_SetModifierMapping: + case X_SetPointerMapping: + case X_TranslateCoords: + /* + * Those requests expect a reply. + */ + + g_hash_table_insert(state->seqtable, + (int *)state->sequencenumber, (int *)opcode); + + break; default: - /* - * No reply is expected from any other request. - */ - state_info->opcode = NOTHING_EXPECTED; - break; + /* + * No reply is expected from any other request. + */ + break; } - if (!tree) return; + if (tree == NULL) + return; switch(opcode) { - case 1: /* CreateWindow */ + case X_CreateWindow: CARD8(depth); REQUEST_LENGTH(); WINDOW(wid); @@ -2134,28 +2882,28 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, windowAttributes(tvb, offsetp, t, little_endian); break; - case 2: /* ChangeWindowAttributes */ + case X_ChangeWindowAttributes: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); windowAttributes(tvb, offsetp, t, little_endian); break; - case 3: /* GetWindowAttributes */ - case 4: /* DestroyWindow */ - case 5: /* DestroySubwindows */ + case X_GetWindowAttributes: + case X_DestroyWindow: + case X_DestroySubwindows: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); break; - case 6: /* ChangeSaveSet */ + case X_ChangeSaveSet: ENUM8(save_set_mode); REQUEST_LENGTH(); WINDOW(window); break; - case 7: /* ReparentWindow */ + case X_ReparentWindow: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); @@ -2164,16 +2912,16 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, INT16(y); break; - case 8: /* MapWindow */ - case 9: /* MapSubWindow */ - case 10: /* UnmapWindow */ - case 11: /* UnmapSubwindows */ + case X_MapWindow: + case X_MapSubwindows: + case X_UnmapWindow: + case X_UnmapSubwindows: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); break; - case 12: /* ConfigureWindow */ + case X_ConfigureWindow: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); @@ -2190,20 +2938,20 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 13: /* CirculateWindow */ + case X_CirculateWindow: ENUM8(direction); REQUEST_LENGTH(); WINDOW(window); break; - case 14: /* GetGeometry */ - case 15: /* QueryTree */ + case X_GetGeometry: + case X_QueryTree: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); break; - case 16: /* InternAtom */ + case X_InternAtom: BOOL(only_if_exists); REQUEST_LENGTH(); v16 = FIELD16(name_length); @@ -2212,13 +2960,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 17: /* GetAtomName */ + case X_GetAtomName: UNUSED(1); REQUEST_LENGTH(); ATOM(atom); break; - case 18: /* ChangeProperty */ + case X_ChangeProperty: ENUM8(mode); REQUEST_LENGTH(); WINDOW(window); @@ -2231,14 +2979,14 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 19: /* DeleteProperty */ + case X_DeleteProperty: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); ATOM(property); break; - case 20: /* GetProperty */ + case X_GetProperty: BOOL(delete); REQUEST_LENGTH(); WINDOW(window); @@ -2248,13 +2996,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD32(long_length); break; - case 21: /* ListProperties */ + case X_ListProperties: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); break; - case 22: /* SetSelectionOwner */ + case X_SetSelectionOwner: UNUSED(1); REQUEST_LENGTH(); WINDOW(owner); @@ -2262,13 +3010,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, TIMESTAMP(time); break; - case 23: /* GetSelectionOwner */ + case X_GetSelectionOwner: UNUSED(1); REQUEST_LENGTH(); ATOM(selection); break; - case 24: /* ConvertSelection */ + case X_ConvertSelection: UNUSED(1); REQUEST_LENGTH(); WINDOW(requestor); @@ -2278,7 +3026,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, TIMESTAMP(time); break; - case 26: /* GrabPointer */ + case X_GrabPointer: BOOL(owner_events); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2290,13 +3038,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, TIMESTAMP(time); break; - case 27: /* UngrabPointer */ + case X_UngrabPointer: UNUSED(1); REQUEST_LENGTH(); TIMESTAMP(time); break; - case 28: /* GrabButton */ + case X_GrabButton: BOOL(owner_events); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2310,7 +3058,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, SETofKEYMASK(modifiers); break; - case 29: /* UngrabButton */ + case X_UngrabButton: BUTTON(button); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2318,7 +3066,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 30: /* ChangeActivePointerGrab */ + case X_ChangeActivePointerGrab: UNUSED(1); REQUEST_LENGTH(); CURSOR(cursor); @@ -2327,7 +3075,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 31: /* GrabKeyboard */ + case X_GrabKeyboard: BOOL(owner_events); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2337,13 +3085,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 32: /* UngrabKeyboard */ + case X_UngrabKeyboard: UNUSED(1); REQUEST_LENGTH(); TIMESTAMP(time); break; - case 33: /* GrabKey */ + case X_GrabKey: BOOL(owner_events); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2354,7 +3102,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(3); break; - case 34: /* UngrabKey */ + case X_UngrabKey: KEYCODE(key); REQUEST_LENGTH(); WINDOW(grab_window); @@ -2362,29 +3110,29 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 35: /* AllowEvents */ + case X_AllowEvents: ENUM8(allow_events_mode); REQUEST_LENGTH(); TIMESTAMP(time); break; - case 36: /* GrabServer */ + case X_GrabServer: UNUSED(1); REQUEST_LENGTH(); break; - case 37: /* UngrabServer */ + case X_UngrabServer: UNUSED(1); REQUEST_LENGTH(); break; - case 38: /* QueryPointer */ + case X_QueryPointer: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); break; - case 39: /* GetMotionEvents */ + case X_GetMotionEvents: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); @@ -2392,7 +3140,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, TIMESTAMP(stop); break; - case 40: /* TranslateCoordinates */ + case X_TranslateCoords: UNUSED(1); REQUEST_LENGTH(); WINDOW(src_window); @@ -2401,7 +3149,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, INT16(src_y); break; - case 41: /* WarpPointer */ + case X_WarpPointer: UNUSED(1); REQUEST_LENGTH(); WINDOW(warp_pointer_src_window); @@ -2414,24 +3162,24 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, INT16(dst_y); break; - case 42: /* SetInputFocus */ + case X_SetInputFocus: ENUM8(revert_to); REQUEST_LENGTH(); WINDOW(focus); TIMESTAMP(time); break; - case 43: /* GetInputFocus */ + case X_GetInputFocus: UNUSED(1); REQUEST_LENGTH(); break; - case 44: /* QueryKeymap */ + case X_QueryKeymap: UNUSED(1); REQUEST_LENGTH(); break; - case 45: /* OpenFont */ + case X_OpenFont: UNUSED(1); REQUEST_LENGTH(); FONT(fid); @@ -2441,19 +3189,19 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 46: /* CloseFont */ + case X_CloseFont: UNUSED(1); REQUEST_LENGTH(); FONT(font); break; - case 47: /* QueryFont */ + case X_QueryFont: UNUSED(1); REQUEST_LENGTH(); FONTABLE(font); break; - case 48: /* QueryTextExtents */ + case X_QueryTextExtents: v8 = BOOL(odd_length); REQUEST_LENGTH(); FONTABLE(font); @@ -2461,7 +3209,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 49: /* ListFonts */ + case X_ListFonts: UNUSED(1); REQUEST_LENGTH(); CARD16(max_names); @@ -2470,7 +3218,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 50: /* ListFontsWithInfo */ + case X_ListFontsWithInfo: UNUSED(1); REQUEST_LENGTH(); CARD16(max_names); @@ -2479,7 +3227,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 51: /* SetFontPath */ + case X_SetFontPath: UNUSED(1); REQUEST_LENGTH(); v16 = CARD16(str_number_in_path); @@ -2488,12 +3236,12 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 52: /* GetFontPath */ + case X_GetFontPath: UNUSED(1); REQUEST_LENGTH(); break; - case 53: /* CreatePixmap */ + case X_CreatePixmap: CARD8(depth); REQUEST_LENGTH(); PIXMAP(pid); @@ -2502,13 +3250,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(height); break; - case 54: /* FreePixmap */ + case X_FreePixmap: UNUSED(1); REQUEST_LENGTH(); PIXMAP(pixmap); break; - case 55: /* CreateGC */ + case X_CreateGC: UNUSED(1); REQUEST_LENGTH(); GCONTEXT(cid); @@ -2516,14 +3264,14 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, gcAttributes(tvb, offsetp, t, little_endian); break; - case 56: /* ChangeGC */ + case X_ChangeGC: UNUSED(1); REQUEST_LENGTH(); GCONTEXT(gc); gcAttributes(tvb, offsetp, t, little_endian); break; - case 57: /* CopyGC */ + case X_CopyGC: UNUSED(1); REQUEST_LENGTH(); GCONTEXT(src_gc); @@ -2531,7 +3279,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, gcMask(tvb, offsetp, t, little_endian); break; - case 58: /* SetDashes */ + case X_SetDashes: UNUSED(1); REQUEST_LENGTH(); GCONTEXT(gc); @@ -2541,7 +3289,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 59: /* SetClipRectangles */ + case X_SetClipRectangles: ENUM8(ordering); REQUEST_LENGTH(); GCONTEXT(gc); @@ -2550,13 +3298,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofRECTANGLE(rectangles); break; - case 60: /* FreeGC */ + case X_FreeGC: UNUSED(1); REQUEST_LENGTH(); GCONTEXT(gc); break; - case 61: /* ClearArea */ + case X_ClearArea: BOOL(exposures); REQUEST_LENGTH(); WINDOW(window); @@ -2566,7 +3314,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(height); break; - case 62: /* CopyArea */ + case X_CopyArea: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(src_drawable); @@ -2580,7 +3328,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(height); break; - case 63: /* CopyPlane */ + case X_CopyPlane: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(src_drawable); @@ -2595,7 +3343,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD32(bit_plane); break; - case 64: /* PolyPoint */ + case X_PolyPoint: ENUM8(coordinate_mode); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2603,7 +3351,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofPOINT(points, v16 - 12); break; - case 65: /* PolyLine */ + case X_PolyLine: ENUM8(coordinate_mode); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2611,7 +3359,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofPOINT(points, v16 - 12); break; - case 66: /* PolySegment */ + case X_PolySegment: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2619,7 +3367,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofSEGMENT(segments); break; - case 67: /* PolyRectangle */ + case X_PolyRectangle: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2627,7 +3375,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofRECTANGLE(rectangles); break; - case 68: /* PolyArc */ + case X_PolyArc: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2635,7 +3383,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofARC(arcs); break; - case 69: /* FillPoly */ + case X_FillPoly: UNUSED(1); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2646,7 +3394,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofPOINT(points, v16 - 16); break; - case 70: /* PolyFillRectangle */ + case X_PolyFillRectangle: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2654,7 +3402,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofRECTANGLE(rectangles); break; - case 71: /* PolyFillArc */ + case X_PolyFillArc: UNUSED(1); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2662,7 +3410,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofARC(arcs); break; - case 72: /* PutImage */ + case X_PutImage: ENUM8(image_format); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2678,7 +3426,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 73: /* GetImage */ + case X_GetImage: ENUM8(image_pixmap_format); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2689,7 +3437,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD32(plane_mask); break; - case 74: /* PolyText8 */ + case X_PolyText8: UNUSED(1); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2700,7 +3448,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 75: /* PolyText16 */ + case X_PolyText16: UNUSED(1); v16 = REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2711,7 +3459,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 76: /* ImageText8 */ + case X_ImageText8: v8 = FIELD8(string_length); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2722,7 +3470,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 77: /* ImageText16 */ + case X_ImageText16: v8 = FIELD8(string_length); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2733,7 +3481,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 78: /* CreateColormap */ + case X_CreateColormap: ENUM8(alloc); REQUEST_LENGTH(); COLORMAP(mid); @@ -2741,38 +3489,38 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, VISUALID(visual); break; - case 79: /* FreeColormap */ + case X_FreeColormap: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); break; - case 80: /* CopyColormapAndFree */ + case X_CopyColormapAndFree: UNUSED(1); REQUEST_LENGTH(); COLORMAP(mid); COLORMAP(src_cmap); break; - case 81: /* InstallColormap */ + case X_InstallColormap: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); break; - case 82: /* UninstallColormap */ + case X_UninstallColormap: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); break; - case 83: /* ListInstalledColormaps */ + case X_ListInstalledColormaps: UNUSED(1); REQUEST_LENGTH(); WINDOW(window); break; - case 84: /* AllocColor */ + case X_AllocColor: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2782,7 +3530,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 85: /* AllocNamedColor */ + case X_AllocNamedColor: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2792,7 +3540,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 86: /* AllocColorCells */ + case X_AllocColorCells: BOOL(contiguous); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2800,7 +3548,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(planes); break; - case 87: /* AllocColorPlanes */ + case X_AllocColorPlanes: BOOL(contiguous); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2810,7 +3558,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(blues); break; - case 88: /* FreeColors */ + case X_FreeColors: UNUSED(1); v16 = REQUEST_LENGTH(); COLORMAP(cmap); @@ -2818,14 +3566,14 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofCARD32(pixels, v16 - 12); break; - case 89: /* StoreColors */ + case X_StoreColors: UNUSED(1); v16 = REQUEST_LENGTH(); COLORMAP(cmap); LISTofCOLORITEM(color_items, v16 - 8); break; - case 90: /* StoreNamedColor */ + case X_StoreNamedColor: COLOR_FLAGS(color); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2836,14 +3584,14 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 91: /* QueryColors */ + case X_QueryColors: UNUSED(1); v16 = REQUEST_LENGTH(); COLORMAP(cmap); LISTofCARD32(pixels, v16 - 8); break; - case 92: /* LookupColor */ + case X_LookupColor: UNUSED(1); REQUEST_LENGTH(); COLORMAP(cmap); @@ -2853,7 +3601,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 93: /* CreateCursor */ + case X_CreateCursor: UNUSED(1); REQUEST_LENGTH(); CURSOR(cid); @@ -2869,7 +3617,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(y); break; - case 94: /* CreateGlyphCursor */ + case X_CreateGlyphCursor: UNUSED(1); REQUEST_LENGTH(); CURSOR(cid); @@ -2885,13 +3633,13 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(back_blue); break; - case 95: /* FreeCursor */ + case X_FreeCursor: UNUSED(1); REQUEST_LENGTH(); CURSOR(cursor); break; - case 96: /* RecolorCursor */ + case X_RecolorCursor: UNUSED(1); REQUEST_LENGTH(); CURSOR(cursor); @@ -2903,7 +3651,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(back_blue); break; - case 97: /* QueryBestSize */ + case X_QueryBestSize: ENUM8(class); REQUEST_LENGTH(); DRAWABLE(drawable); @@ -2911,7 +3659,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, CARD16(height); break; - case 98: /* QueryExtension */ + case X_QueryExtension: UNUSED(1); REQUEST_LENGTH(); v16 = FIELD16(name_length); @@ -2920,29 +3668,30 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, PAD(); break; - case 99: /* ListExtensions */ + case X_ListExtensions: UNUSED(1); REQUEST_LENGTH(); break; - case 100: /* ChangeKeyboardMapping */ + case X_ChangeKeyboardMapping: v8 = FIELD8(keycode_count); REQUEST_LENGTH(); - KEYCODE(first_keycode); - v8_2 = FIELD8(keysyms_per_keycode); + v8_2 = KEYCODE(first_keycode); + v8_3 = FIELD8(keysyms_per_keycode); UNUSED(2); - LISTofKEYSYM(keysyms, v8, v8_2); + LISTofKEYSYM(keysyms, state->keycodemap, v8_2, v8, v8_3); break; - case 101: /* GetKeyboardMapping */ + case X_GetKeyboardMapping: UNUSED(1); REQUEST_LENGTH(); - KEYCODE(first_keycode); + state->request.GetKeyboardMapping.first_keycode + = KEYCODE(first_keycode); FIELD8(count); UNUSED(2); break; - case 102: /* ChangeKeyboardControl */ + case X_ChangeKeyboardControl: UNUSED(1); REQUEST_LENGTH(); BITMASK32(keyboard_value); @@ -2957,17 +3706,17 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, ENDBITMASK; break; - case 103: /* GetKeyboardControl */ + case X_GetKeyboardControl: UNUSED(1); REQUEST_LENGTH(); break; - case 104: /* Bell */ + case X_Bell: INT8(percent); REQUEST_LENGTH(); break; - case 105: /* ChangePointerControl */ + case X_ChangePointerControl: UNUSED(1); REQUEST_LENGTH(); INT16(acceleration_numerator); @@ -2977,12 +3726,12 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, BOOL(do_threshold); break; - case 106: /* GetPointerControl */ + case X_GetPointerControl: UNUSED(1); REQUEST_LENGTH(); break; - case 107: /* SetScreenSaver */ + case X_SetScreenSaver: UNUSED(1); REQUEST_LENGTH(); INT16(timeout); @@ -2992,12 +3741,12 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(2); break; - case 108: /* GetScreenSaver */ + case X_GetScreenSaver: UNUSED(1); REQUEST_LENGTH(); break; - case 109: /* ChangeHosts */ + case X_ChangeHosts: ENUM8(change_host_mode); REQUEST_LENGTH(); v8 = ENUM8(family); @@ -3014,28 +3763,28 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofCARD8(address, v16); break; - case 110: /* ListHosts */ + case X_ListHosts: UNUSED(1); REQUEST_LENGTH(); break; - case 111: /* SetAccessControl */ + case X_SetAccessControl: ENUM8(access_mode); REQUEST_LENGTH(); break; - case 112: /* SetCloseDownMode */ + case X_SetCloseDownMode: ENUM8(close_down_mode); REQUEST_LENGTH(); break; - case 113: /* KillClient */ + case X_KillClient: UNUSED(1); REQUEST_LENGTH(); CARD32(resource); break; - case 114: /* RotateProperties */ + case X_RotateProperties: UNUSED(1); v16 = REQUEST_LENGTH(); WINDOW(window); @@ -3044,42 +3793,42 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, LISTofATOM(properties, (v16 - 12)); break; - case 115: /* ForceScreenSaver */ + case X_ForceScreenSaver: ENUM8(screen_saver_mode); REQUEST_LENGTH(); break; - case 116: /* SetPointerMapping */ + case X_SetPointerMapping: v8 = FIELD8(map_length); REQUEST_LENGTH(); LISTofCARD8(map, v8); PAD(); break; - case 117: /* GetPointerMapping */ + case X_GetPointerMapping: UNUSED(1); REQUEST_LENGTH(); break; - case 118: /* SetModifierMapping */ + case X_SetModifierMapping: v8 = FIELD8(keycodes_per_modifier); REQUEST_LENGTH(); - LISTofKEYCODE(keycodes, v8); + LISTofKEYCODE(state->modifiermap, keycodes, v8); break; - case 119: /* GetModifierMapping */ + case X_GetModifierMapping: UNUSED(1); REQUEST_LENGTH(); break; - case 127: /* NoOperation */ + case X_NoOperation: UNUSED(1); REQUEST_LENGTH(); break; } - left = tvb_length_remaining(tvb, offset); - if (left) - proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, left, little_endian); + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + UNDECODED(left); } static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, @@ -3096,13 +3845,12 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, guint16 auth_proto_len, auth_data_len; const char *volatile sep = NULL; conversation_t *conversation; - x11_conv_data_t *volatile state_info; + x11_conv_data_t *state; int length; tvbuff_t *next_tvb; - while (tvb_reported_length_remaining(tvb, offset) != 0) { - length_remaining = tvb_length_remaining(tvb, offset); - + while ((length_remaining = tvb_reported_length_remaining(tvb, offset)) + > 0) { /* * Can we do reassembly? */ @@ -3142,23 +3890,14 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, /* * Is there state attached to this conversation? */ - state_info = conversation_get_proto_data(conversation, proto_x11); - if (state_info == NULL) { - /* - * No - create a state structure and attach it. - */ - state_info = g_mem_chunk_alloc(x11_state_chunk); - state_info->opcode = NOTHING_SEEN; /* nothing seen yet */ - state_info->iconn_frame = 0; /* don't know it yet */ - state_info->byte_order = BYTE_ORDER_UNKNOWN; /* don't know it yet */ - conversation_add_proto_data(conversation, proto_x11, - state_info); - } + if ((state = conversation_get_proto_data(conversation, proto_x11)) + == NULL) + x11_stateinit(&state, conversation); /* * Guess the byte order if we don't already know it. */ - little_endian = guess_byte_ordering(tvb, pinfo, state_info); + little_endian = guess_byte_ordering(tvb, pinfo, state); /* * Get the opcode and length of the putative X11 request. @@ -3173,14 +3912,17 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, * helped. * Give up. */ - ti = proto_tree_add_item(tree, proto_x11, tvb, offset, -1, FALSE); + ti = proto_tree_add_item(tree, proto_x11, tvb, offset, -1, + FALSE); t = proto_item_add_subtree(ti, ett_x11); - proto_tree_add_text(t, tvb, offset, -1, "Bogus request length (0)"); + proto_tree_add_text(t, tvb, offset, -1, + "Bogus request length (0)"); return; } - if (state_info->iconn_frame == pinfo->fd->num || - (state_info->opcode == NOTHING_SEEN && + if (state->iconn_frame == pinfo->fd->num || + (g_hash_table_lookup(state->seqtable, + (int *)state->sequencenumber) == (int *)NOTHING_SEEN && (opcode == 'B' || opcode == 'l') && (plen == 11 || plen == 2816))) { /* @@ -3213,18 +3955,18 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, /* * We now know the byte order. Override the guess. */ - if (state_info->byte_order == BYTE_ORDER_UNKNOWN) { + if (state->byte_order == BYTE_ORDER_UNKNOWN) { if (opcode == 'B') { /* * Big-endian. */ - state_info->byte_order = BYTE_ORDER_BE; + state->byte_order = BYTE_ORDER_BE; little_endian = FALSE; } else { /* * Little-endian. */ - state_info->byte_order = BYTE_ORDER_LE; + state->byte_order = BYTE_ORDER_LE; little_endian = TRUE; } } @@ -3316,7 +4058,8 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, */ if (is_initial_creq) { if (check_col(pinfo->cinfo, COL_INFO)) - col_set_str(pinfo->cinfo, COL_INFO, "Initial connection request"); + col_set_str(pinfo->cinfo, COL_INFO, + "Initial connection request"); } else { if (sep == NULL) { /* @@ -3347,10 +4090,10 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, TRY { if (is_initial_creq) { dissect_x11_initial_conn(next_tvb, pinfo, tree, - state_info, little_endian); + state, little_endian); } else { dissect_x11_request(next_tvb, pinfo, tree, sep, - state_info, little_endian); + state, little_endian); } } CATCH(BoundsError) { @@ -3371,30 +4114,454 @@ static void dissect_x11_requests(tvbuff_t *tvb, packet_info *pinfo, } static void +x11_stateinit(x11_conv_data_t **state, conversation_t *conversation) +{ + + /* + * No - create a state structure and attach it. + */ + static x11_conv_data_t stateinit; + + *state = g_mem_chunk_alloc(x11_state_chunk); + **state = stateinit; + + (*state)->seqtable = g_hash_table_new(g_direct_hash, g_direct_equal); + g_hash_table_insert((*state)->seqtable, (int *)0, (int *)NOTHING_SEEN); + (*state)->byte_order = BYTE_ORDER_UNKNOWN; /* don't know yet*/ + conversation_add_proto_data(conversation, proto_x11, *state); +} + + +static void dissect_x11_replies(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { /* Set up structures we will need to add the protocol subtree and manage it */ - proto_item *ti; - proto_tree *x11_tree; + volatile int offset, plen; + tvbuff_t * volatile next_tvb; + conversation_t *conversation; + x11_conv_data_t *state; + gboolean little_endian; + int length_remaining; + const char *volatile sep = NULL; + + + /* + * Get the state for this conversation; create the conversation + * if we don't have one, and create the state if we don't have + * any. + */ + conversation = find_conversation(&pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, pinfo->destport, 0); + if (conversation == NULL) { + /* + * No - create one. + */ + conversation = conversation_new(&pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, pinfo->destport, 0); + } + + /* + * Is there state attached to this conversation? + */ + if ((state = conversation_get_proto_data(conversation, proto_x11)) + == NULL) + x11_stateinit(&state, conversation); + + /* + * Guess the byte order if we don't already know it. + */ + little_endian = guess_byte_ordering(tvb, pinfo, state); + + offset = 0; + while ((length_remaining = tvb_reported_length_remaining(tvb, offset)) + > 0) { + /* + * Can we do reassembly? + */ + if (x11_desegment && pinfo->can_desegment) { + /* + * Yes - is the X11 reply header split across + * segment boundaries? + */ + if (length_remaining < 8) { + /* + * Yes. Tell the TCP dissector where the data + * for this message starts in the data it handed + * us, and how many more bytes we need, and + * return. + */ + pinfo->desegment_offset = offset; + pinfo->desegment_len = 4 - length_remaining; + return; + } + } + + /* + * Find out what kind of a reply it is. + * There are three possible: + * - errorreply (a request generated an error) + * - requestreply (reply to a request) + * - eventreply (some event occured) + */ + + switch (tvb_get_guint8(tvb, offset)) { + case 0: + plen = 32; + HANDLE_REPLY(plen, length_remaining, + "Error", dissect_x11_error); + break; + + case 1: + /* replylength is in units of four. */ + if (g_hash_table_lookup(state->seqtable, + (int *)state->sequencenumber) + == (int *)INITIAL_CONN + || (state->iconn_reply == pinfo->fd->num)) { + /* + * ref. by A. Nye. says all + * replies are 32 + "additional bytes". + * Initial serverreply seems to be + * the exception, it's 8 + "additional + * bytes". + */ + plen = 8 + VALUE16(tvb, offset + 6) * 4; + + HANDLE_REPLY(plen, length_remaining, + "Initial connection reply", + dissect_x11_initial_reply); + } + else { + plen + = 32 + VALUE32(tvb, offset + 4) * 4; + + HANDLE_REPLY(plen, length_remaining, + "Reply", dissect_x11_reply); + } + break; + + default: + plen = 32; + HANDLE_REPLY(plen, length_remaining, + "Event", dissect_x11_event); + break; + } + + offset += plen; + } + + return; +} -/* This field shows up as the "Info" column in the display; you should make - it, if possible, summarize what's in the packet, so that a user looking - at the list of packets can tell what type of packet it is. */ - if (check_col(pinfo->cinfo, COL_INFO)) - col_set_str(pinfo->cinfo, COL_INFO, "Replies/events"); +static void +dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *volatile sep, x11_conv_data_t *volatile state, + gboolean little_endian) +{ + int offset = 0, *offsetp = &offset, length, left, opcode; + proto_item *ti; + proto_tree *t; + char *str; + + ti = proto_tree_add_item(tree, proto_x11, tvb, 0, + tvb_reported_length_remaining(tvb, offset), + FALSE); + t = proto_item_add_subtree(ti, ett_x11); + + + opcode = (int)g_hash_table_lookup(state->seqtable, + (int *)VALUE16(tvb, offset + 2)); + + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", + sep, + /* + * don't print opcode value since if it's + * unknown, we didn't know to save the + * request opcode. + */ + val_to_str(opcode, opcode_vals, "<Unknown opcode %d>")); + + str = g_strdup_printf(", Reply, opcode: %d (%s)", + opcode, val_to_str(opcode, opcode_vals, + "<Unknown opcode %d>")); + + proto_item_append_text(ti, str); + g_free(str); + + if (tree == NULL) + return; + + switch (opcode) { + /* + * Requests that expect a reply. + */ + + case X_GetWindowAttributes: + case X_GetGeometry: + case X_QueryTree: + case X_InternAtom: + case X_GetAtomName: + REPLYCONTENTS_COMMON(); + break; + + case X_GetProperty: + REPLY(reply); + CARD8(format); + SEQUENCENUMBER_REPLY(sequencenumber); + length = REPLYLENGTH(replylength); + ATOM(get_property_type); + CARD32(bytes_after); + CARD32(valuelength); + UNUSED(12); + break; + + case X_ListProperties: + case X_GetSelectionOwner: + case X_GrabPointer: + case X_GrabKeyboard: + case X_QueryPointer: + case X_GetMotionEvents: + case X_TranslateCoords: + REPLYCONTENTS_COMMON(); + break; + + case X_QueryKeymap: + case X_QueryFont: + case X_QueryTextExtents: + case X_ListFonts: + case X_GetImage: + case X_ListInstalledColormaps: + case X_AllocColor: + case X_QueryColors: + case X_LookupColor: + case X_QueryBestSize: + case X_QueryExtension: + case X_ListExtensions: + REPLYCONTENTS_COMMON(); + break; + + case X_GetKeyboardMapping: + state->first_keycode + = state->request.GetKeyboardMapping.first_keycode, + REPLY(reply); + state->keysyms_per_keycode + = FIELD8(keysyms_per_keycode); + SEQUENCENUMBER_REPLY(sequencenumber); + length = REPLYLENGTH(replylength); + UNUSED(24); + LISTofKEYSYM(keysyms, state->keycodemap, + state->request.GetKeyboardMapping.first_keycode, + length / state->keysyms_per_keycode, + state->keysyms_per_keycode); + break; + + case X_GetKeyboardControl: + case X_GetPointerControl: + case X_GetScreenSaver: + case X_ListHosts: + case X_SetPointerMapping: + case X_GetPointerMapping: + case X_SetModifierMapping: + REPLYCONTENTS_COMMON(); + break; + + case X_GetModifierMapping: + REPLY(reply); + state->keycodes_per_modifier + = FIELD8(keycodes_per_modifier); + SEQUENCENUMBER_REPLY(sequencenumber); + REPLYLENGTH(replylength); + UNUSED(24); + LISTofKEYCODE(state->modifiermap, keycodes, + state->keycodes_per_modifier); + break; + + default: + REPLYCONTENTS_COMMON(); + } + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + UNDECODED(left); +} -/* In the interest of speed, if "tree" is NULL, don't do any work not - necessary to generate protocol tree items. */ - if (!tree) return; - ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); - x11_tree = proto_item_add_subtree(ti, ett_x11); +static void +dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *volatile sep, x11_conv_data_t *volatile state, + gboolean little_endian) +{ + int offset = 0, *offsetp = &offset, left; + unsigned char eventcode; + char *str; + proto_item *ti; + proto_tree *t; + + ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); + t = proto_item_add_subtree(ti, ett_x11); + + eventcode = tvb_get_guint8(tvb, offset); + + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", + sep, val_to_str(eventcode, eventcode_vals, + "<Unknown eventcode %u>")); + + proto_tree_add_uint_format(t, hf_x11_eventcode, tvb, offset, 1, + eventcode, + "eventcode: %d (%s)", + eventcode, + val_to_str(eventcode, eventcode_vals, + "<Unknown eventcode %u>")); + ++offset; + + str = g_strdup_printf(", Event, eventcode: %d (%s)", + eventcode, val_to_str(eventcode, eventcode_vals, + "<Unknown eventcode %u>")); + + proto_item_append_text(ti, str); + g_free(str); + + if (tree == NULL) + return; + + switch (eventcode) { + case KeyPress: + case KeyRelease: { + int code, mask; + + /* need to do some prefetching here ... */ + code = VALUE8(tvb, offset); + mask = VALUE16(tvb, 28); + + KEYCODE_DECODED(keycode, code, mask); + CARD16(event_sequencenumber); + EVENTCONTENTS_COMMON(); + BOOL(same_screen); + UNUSED(1); + break; + } + + case ButtonPress: + case ButtonRelease: + BUTTON(eventbutton); + CARD16(event_sequencenumber); + EVENTCONTENTS_COMMON(); + BOOL(same_screen); + UNUSED(1); + break; + + case MotionNotify: + CARD8(detail); + CARD16(event_sequencenumber); + EVENTCONTENTS_COMMON(); + BOOL(same_screen); + UNUSED(1); + break; + + case EnterNotify: + case LeaveNotify: + CARD8(detail); + CARD16(event_sequencenumber); + EVENTCONTENTS_COMMON(); + CARD8(same_screen); + break; + + case FocusIn: + case FocusOut: + case KeymapNotify: + case Expose: + case GraphicsExpose: + case NoExpose: + case VisibilityNotify: + case CreateNotify: + case DestroyNotify: + case UnmapNotify: + case MapNotify: + case MapRequest: + case ReparentNotify: + case ConfigureNotify: + case ConfigureRequest: + case GravityNotify: + case ResizeRequest: + case CirculateNotify: + case CirculateRequest: + case PropertyNotify: + case SelectionClear: + case SelectionRequest: + case SelectionNotify: + case ColormapNotify: + case ClientMessage: + case MappingNotify: + default: + break; + } + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + UNDECODED(left); + + return; +} - /* - * XXX - dissect these in a loop, like the requests. - */ - call_dissector(data_handle,tvb, pinfo, x11_tree); +static void +dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + const char *volatile sep, _U_ x11_conv_data_t *volatile state, + gboolean little_endian) +{ + int offset = 0, *offsetp = &offset, left; + unsigned char errorcode, error; + proto_item *ti; + proto_tree *t; + char *str; + + + ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE); + t = proto_item_add_subtree(ti, ett_x11); + + error = tvb_get_guint8(tvb, offset); + CARD8(error); + + errorcode = tvb_get_guint8(tvb, offset); + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", + sep, val_to_str(errorcode, errorcode_vals, "<Unknown errorcode %u>")); + + proto_tree_add_uint_format(t, hf_x11_errorcode, tvb, offset, 1, + errorcode, + "errorcode: %d (%s)", + errorcode, + val_to_str(errorcode, errorcode_vals, + "<Unknown errocode %u>")); + ++offset; + + str = g_strdup_printf(", Error, errorcode: %d (%s)", + errorcode, val_to_str(errorcode, errorcode_vals, + "<Unknown errorcode %u>")); + + proto_item_append_text(ti, str); + g_free(str); + + if (tree == NULL) + return; + + CARD16(error_sequencenumber); + + switch (errorcode) { + case BadValue: + CARD32(error_badvalue); + break; + + default: + UNDECODED(4); + } + + CARD16(minor_opcode); + CARD8(major_opcode); + + if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) + UNDECODED(left); } + + /************************************************************************ *** *** *** I N I T I A L I Z A T I O N A N D M A I N *** @@ -3404,13 +4571,13 @@ dissect_x11_replies(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) static void dissect_x11(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { - if (check_col(pinfo->cinfo, COL_PROTOCOL)) - col_set_str(pinfo->cinfo, COL_PROTOCOL, "X11"); + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + col_set_str(pinfo->cinfo, COL_PROTOCOL, "X11"); - if (pinfo->match_port == pinfo->destport) - dissect_x11_requests(tvb, pinfo, tree); - else - dissect_x11_replies(tvb, pinfo, tree); + if (pinfo->match_port == pinfo->srcport) + dissect_x11_replies(tvb, pinfo, tree); + else + dissect_x11_requests(tvb, pinfo, tree); } /* Register the protocol with Ethereal */ @@ -3489,3 +4656,4 @@ proto_reg_handoff_x11(void) dissector_add("tcp.port", TCP_PORT_X11_3, x11_handle); data_handle = find_dissector("data"); } + diff --git a/x11-fields b/x11-fields index 8c5a639ee5..11f41f903b 100644 --- a/x11-fields +++ b/x11-fields @@ -3,7 +3,7 @@ # # Copyright 2000, Christophe Tronche <ch.tronche@computer.org> # -# $Id: x11-fields,v 1.9 2003/07/09 05:23:50 guy Exp $ +# $Id: x11-fields,v 1.10 2004/01/02 12:52:45 obiot Exp $ # # Ethereal - Network traffic analyzer # By Gerald Combs <gerald@ethereal.com> @@ -50,6 +50,11 @@ authorization-protocol-name STRING HEX authorization-protocol-data-length UINT16 DEC authorization-protocol-data STRING HEX auto-repeat-mode UINT8 DEC VALS + +bitmap-format-bit-order UINT8 HEX VALS(image_byte_order) +bitmap-format-scanline-pad UINT8 DEC bitmap format scanline-pad +bitmap-format-scanline-unit UINT8 DEC bitmap format scanline unit +bytes-after UINT32 DEC bytes after back-blue UINT16 DEC Background blue value for a cursor back-green UINT16 DEC Background green value for a cursor back-red UINT16 DEC Background red value for a cursor @@ -71,6 +76,8 @@ border-pixmap UINT32 HEX VALS border-width UINT16 DEC button UINT8 DEC VALS byte-order UINT8 HEX VALS + +childwindow UINT32 DEC childwindow cap-style UINT8 DEC VALS change-host-mode UINT8 DEC VALS(insert_delete) cid UINT32 HEX @@ -118,6 +125,7 @@ dashes-length UINT16 DEC do-acceleration BOOLEAN NONE do-threshold BOOLEAN NONE +detail UINT8 DEC detail do-not-propagate-mask UINT32 HEX KeyPress BOOLEAN 32 0x00000001 KeyRelease BOOLEAN 32 0x00000002 @@ -132,6 +140,17 @@ do-not-propagate-mask UINT32 HEX ButtonMotion BOOLEAN 32 0x00002000 erroneous-bits BOOLEAN 32 0xffffc0b0 +event-sequencenumber UINT16 DEC event sequencenumber +error UINT8 DEC error +error-badvalue UINT32 DEC error badvalue +error_sequencenumber UINT16 DEC error sequencenumber +errorcode UINT8 DEC VALS errrorcode +event-x UINT16 DEC event x +event-y UINT16 DEC event y +eventbutton UINT8 DEC eventbutton +eventcode UINT8 DEC VALS eventcode +eventwindow UINT32 DEC eventwindow + gc-dashes UINT8 DEC gc-value-mask UINT32 HEX @@ -221,6 +240,8 @@ get-property-type UINT32 HEX VALS(zero_is_any_property_type) grab_window UINT32 HEX graphics-exposures BOOLEAN NONE height UINT16 DEC +image-byte-order UINT8 HEX VALS +initial-connection NONE NONE undecoded image-format UINT8 DEC VALS image-pixmap-format UINT8 DEC VALS interval INT16 DEC @@ -230,6 +251,8 @@ key UINT8 DEC VALS key-click-percent INT8 DEC keyboard-key UINT8 DEC keyboard-mode UINT8 DEC VALS(pointer_keyboard_mode) +keybut-mask-erroneous-bits BOOLEAN 16 0xe000 keybut mask erroneous bits +keycode UINT8 HEX keycode keyboard-value-mask UINT32 HEX key-click-percent BOOLEAN 32 0x0001 @@ -253,6 +276,7 @@ keysyms NONE NONE keysym UINT32 HEX keysyms-per-keycode UINT8 DEC +length-of-vendor UINT16 DEC length of vendor led UINT8 DEC led-mode UINT8 DEC VALS(on_off) left-pad UINT8 DEC @@ -268,8 +292,18 @@ mask-font UINT32 HEX VALS(zero_is_none) max-names UINT16 DEC mid UINT32 HEX mode UINT8 DEC VALS +major-opcode UINT16 DEC major opcode +max-keycode UINT8 DEC max keycode +maximum-request-length UINT16 DEC maximum request length +min-keycode UINT8 DEC min keycode +minor-opcode UINT16 DEC minor opcode modifiers-mask UINT16 HEX + Button1 BOOLEAN 16 0x0100 + Button2 BOOLEAN 16 0x0200 + Button3 BOOLEAN 16 0x0300 + Button4 BOOLEAN 16 0x0400 + Button5 BOOLEAN 16 0x0500 Shift BOOLEAN 16 0x0001 Lock BOOLEAN 16 0x0002 Control BOOLEAN 16 0x0004 @@ -281,6 +315,11 @@ modifiers-mask UINT16 HEX AnyModifier UINT16 HEX 0x8000 erroneous-bits BOOLEAN 16 0xff00 +motion-buffer-size UINT16 DEC motion buffer size + +number-of-formats-in-pixmap-formats UINT8 DEC number of formats in pixmap formats +number-of-screens-in-roots UINT8 DEC number of screens in roots + name STRING HEX name-length UINT16 DEC odd-length BOOLEAN NONE @@ -349,6 +388,19 @@ requestor UINT32 HEX request-length UINT16 DEC Request length resource UINT32 HEX VALS(all_temporary) revert-to UINT8 DEC VALS +release-number UINT32 DEC release number +reply UINT8 DEC reply +reply-sequencenumber UINT16 DEC VALS(opcode) +replylength UINT32 DEC replylength +replyopcode UINT8 DEC VALS(opcode) +resource-id-base UINT32 HEX resource id base +resource-id-mask UINT32 HEX resource id mask +root-x UINT16 DEC root x +root-y UINT16 DEC root y +rootwindow UINT32 DEC rootwindow + +same-screen BOOLEAN NONE same screen +success UINT8 DEC success save-set-mode UINT8 DEC VALS(insert_delete) save-under BOOLEAN NONE screen-saver-mode UINT8 DEC VALS @@ -403,6 +455,8 @@ timeout INT16 DEC type UINT32 HEX undecoded NONE NONE Yet undecoded by dissector unused NONE NONE +valuelength UINT32 DEC valuelength +vendor STRING HEX vendor visual UINT32 HEX visualid UINT32 HEX warp-pointer-dst-window UINT32 HEX VALS(zero_is_none) |