(/home/sate/Testcases/c/cve/wireshark-1.2.0/epan/dissectors/packet-x11.c) |
| |
| 1616 | | | static const char * |
| 1617 | | | keycode2keysymString(int *keycodemap[256], int first_keycode, |
| 1618 | | | int keysyms_per_keycode, |
| 1619 | | | int *modifiermap[array_length(modifiers)], |
| 1620 | | | int keycodes_per_modifier, |
| 1621 | | | guint32 keycode, guint32 bitmask) |
| 1622 | | | { |
| 1623 | | | static char *buf; |
| 1624 | | | int *syms; |
| 1625 | | | int groupmodkc, numlockkc, numlockmod, groupmod; |
| 1626 | | | int lockmod_is_capslock = 0, lockmod_is_shiftlock = 0; |
| 1627 | | | int lockmod_is_nosymbol = 1; |
| 1628 | | | int modifier, kc, keysym; |
| 1629 | | | |
| 1630 | | | if ((syms = keycodemap[keycode]) == NULL) |
Event 1:
Skipping " if". (syms = keycodemap[keycode]) == (void *)0 evaluates to false.
hide
|
|
| 1631 | | | return "<Unknown>"; |
| 1632 | | | |
| 1633 | | | for (kc = first_keycode, groupmodkc = numlockkc = -1; kc < 256; ++kc) |
Event 2:
Leaving loop. kc < 256 evaluates to false.
hide
|
|
| 1634 | | | for (keysym = 0; keysym < keysyms_per_keycode; ++keysym) { |
| 1635 | | | if (keycodemap[kc] == NULL) |
| 1636 | | | return "<Unknown>"; |
| 1637 | | | switch (keycodemap[kc][keysym]) { |
| 1638 | | | case 0xff7e: |
| 1639 | | | groupmodkc = kc; |
| 1640 | | | break; |
| 1641 | | | |
| 1642 | | | case 0xff7f: |
| 1643 | | | numlockkc = kc; |
| 1644 | | | break; |
| 1645 | | | |
| 1646 | | | case 0xffe5: |
| 1647 | | | lockmod_is_capslock = kc; |
| 1648 | | | break; |
| 1649 | | | |
| 1650 | | | case 0xffe6: |
| 1651 | | | lockmod_is_shiftlock = kc; |
| 1652 | | | break; |
| 1653 | | | } |
| 1654 | | | } |
| 1655 | | | |
| 1656 | | | |
| 1657 | | | |
| 1658 | | | |
| 1659 | | | |
| 1660 | | | |
| 1661 | | | |
| 1662 | | | |
| 1663 | | | if (modifiermap[array_length(modifiers) - 1] == NULL) |
Event 3:
Skipping " if". modifiermap[sizeof( modifiers ) / sizeof( modifiers[0] ) - 1] == (void *)0 evaluates to false.
hide
|
|
| 1664 | | | return "<Unknown>"; |
| 1665 | | | |
| 1666 | | | |
| 1667 | | | for (modifier = 0, numlockmod = groupmod = -1; |
| 1668 | | | modifier < (int)array_length(modifiers) && numlockmod == -1; |
| 1669 | | | ++modifier) |
| 1670 | | | for (kc = 0; kc < keycodes_per_modifier; ++kc) |
| 1671 | | | if (modifiermap[modifier][kc] == numlockkc) |
| 1672 | | | numlockmod = modifier; |
| 1673 | | | else if (modifiermap[modifier][kc] == groupmodkc) |
| 1674 | | | groupmod = modifier; |
| 1675 | | | |
| 1676 | | | |
| 1677 | | | |
| 1678 | | | |
| 1679 | | | |
| 1680 | | | for (kc = 0; kc < keycodes_per_modifier; ++kc) |
Event 5:
Entering loop body. kc < keycodes_per_modifier evaluates to true.
hide
|
|
| 1681 | | | if (modifiermap[1][kc] == lockmod_is_capslock) { |
Event 6:
Taking true branch. modifiermap[1][kc] == lockmod_is_capslock evaluates to true.
hide
|
|
| 1682 | | | lockmod_is_shiftlock = lockmod_is_nosymbol = 0; |
| 1683 | | | break; |
| 1684 | | | } |
| 1685 | | | else if (modifiermap[0][kc] == lockmod_is_shiftlock) { |
| 1686 | | | lockmod_is_capslock = lockmod_is_nosymbol = 0; |
| 1687 | | | break; |
| 1688 | | | } |
| 1689 | | | |
| 1690 | | | #if 0 |
| 1691 | | | |
| 1692 | | | |
| 1693 | | | |
| 1694 1726 |  | | [ Lines 1694 to 1726 omitted. ] |
| 1727 | | | |
| 1728 | | | return "Uppercase"; |
| 1729 | | | else |
| 1730 | | | return keysymString(syms[groupmod + 1]); |
| 1731 | | | |
| 1732 | | | else if ((bitmask & ShiftMask) |
| 1733 | | | || ((bitmask & LockMask) && lockmod_is_shiftlock)) |
| 1734 | | | return keysymString(syms[groupmod + 1]); |
| 1735 | | | #else |
| 1736 | | | |
| 1737 | | | while (keysyms_per_keycode > 2 |
Event 7:
Leaving loop. keysyms_per_keycode > 2 evaluates to false.
hide
|
|
| 1738 | | | && keycodemap[keysyms_per_keycode - 1] == NoSymbol) |
| 1739 | | | --keysyms_per_keycode; |
| 1740 | | | if (keysyms_per_keycode > 2 |
Event 8:
Skipping " if". keysyms_per_keycode > 2 evaluates to false.
hide
|
|
| 1741 | | | && (groupmod >= 0 && (modifiermask[groupmod] & bitmask))) { |
| 1742 | | | syms += 2; |
| 1743 | | | keysyms_per_keycode -= 2; |
| 1744 | | | } |
| 1745 | | | |
| 1746 | | | if (numlockmod >= 0 && (bitmask & modifiermask[numlockmod]) |
Event 9:
Taking false branch. numlockmod >= 0 evaluates to false.
hide
|
|
| 1747 | | | && keysyms_per_keycode > 1 |
| 1748 | | | && ((syms[1] >= 0xff80 && syms[1] <= 0xffbd) |
| 1749 | | | || (syms[1] >= 0x11000000 && syms[1] <= 0x1100ffff))) { |
| 1750 | | | if ((bitmask & ShiftMask) |
| 1751 | | | || (bitmask & LockMask && lockmod_is_shiftlock)) |
| 1752 | | | keysym = syms[0]; |
| 1753 | | | else |
| 1754 | | | keysym = syms[1]; |
| 1755 | | | } |
| 1756 | | | else if (!(bitmask & ShiftMask) |
Event 10:
Taking false branch. bitmask & 1 << 0 evaluates to true.
hide
|
|
| 1757 | | | && (!(bitmask & LockMask) || lockmod_is_nosymbol)) { |
| 1758 | | | if (keysyms_per_keycode == 1 |
| 1759 | | | || (keysyms_per_keycode > 1 && syms[1] == NoSymbol)) { |
| 1760 | | | int usym; |
| 1761 | | | |
| 1762 | | | XConvertCase(syms[0], &keysym, &usym); |
| 1763 | | | } |
| 1764 | | | else |
| 1765 | | | keysym = syms[0]; |
| 1766 | | | } |
| 1767 | | | else if (!(bitmask & LockMask) || !lockmod_is_capslock) { |
Event 11:
Taking true branch. bitmask & 1 << 1 evaluates to false.
hide
|
|
| 1768 | | | int lsym, usym; |
| 1769 | | | |
| 1770 | | | if (keysyms_per_keycode == 1 |
Event 12:
Skipping " if". - keysyms_per_keycode == 1 evaluates to false.
- keysyms_per_keycode > 1 evaluates to false.
hide
|
|
| 1771 | | | || (keysyms_per_keycode > 1 && (usym = syms[1]) == NoSymbol)) |
| 1772 | | | XConvertCase(syms[0], &lsym, &usym); |
| 1773 | | | keysym = usym; |
| |