| [52] | 1 | package de.ugoe.cs.eventbench.windows;
|
|---|
| [1] | 2 |
|
|---|
| 3 | import java.io.IOException;
|
|---|
| 4 | import java.security.InvalidParameterException;
|
|---|
| 5 | import java.util.HashMap;
|
|---|
| 6 | import java.util.Iterator;
|
|---|
| 7 | import java.util.LinkedList;
|
|---|
| 8 | import java.util.List;
|
|---|
| 9 | import java.util.ListIterator;
|
|---|
| 10 | import java.util.Map;
|
|---|
| 11 | import java.util.NoSuchElementException;
|
|---|
| 12 |
|
|---|
| 13 | import org.jdom.Document;
|
|---|
| 14 | import org.jdom.Element;
|
|---|
| 15 | import org.jdom.JDOMException;
|
|---|
| 16 | import org.jdom.Namespace;
|
|---|
| 17 | import org.jdom.input.SAXBuilder;
|
|---|
| 18 |
|
|---|
| [171] | 19 | import de.ugoe.cs.eventbench.data.Event;
|
|---|
| [52] | 20 | import de.ugoe.cs.eventbench.windows.data.WindowTree;
|
|---|
| 21 | import de.ugoe.cs.eventbench.windows.data.WindowTreeNode;
|
|---|
| [198] | 22 | import de.ugoe.cs.eventbench.windows.data.WindowsEvent;
|
|---|
| [52] | 23 | import de.ugoe.cs.eventbench.windows.data.WindowsMessage;
|
|---|
| [1] | 24 | import de.ugoe.cs.util.console.Console;
|
|---|
| 25 |
|
|---|
| 26 | /**
|
|---|
| 27 | * <p>
|
|---|
| [171] | 28 | * Translates sequences of windows messages into {@link WindowsEvent}s that can
|
|---|
| 29 | * be used by the EventBench core libraries.
|
|---|
| [1] | 30 | * </p>
|
|---|
| 31 | *
|
|---|
| 32 | * @author Steffen Herbold
|
|---|
| [171] | 33 | * @version 1.0
|
|---|
| [1] | 34 | */
|
|---|
| 35 | public class EventGenerator {
|
|---|
| 36 |
|
|---|
| 37 | /**
|
|---|
| 38 | * <p>
|
|---|
| 39 | * Helper method that fetches the document node of an XML file.
|
|---|
| 40 | * </p>
|
|---|
| 41 | *
|
|---|
| 42 | * @param filename
|
|---|
| 43 | * name of the XML file
|
|---|
| 44 | * @return the document node
|
|---|
| 45 | */
|
|---|
| 46 | private static Document getDocument(String filename) {
|
|---|
| 47 | SAXBuilder builder = new SAXBuilder();
|
|---|
| 48 | Document doc = null;
|
|---|
| 49 |
|
|---|
| 50 | try {
|
|---|
| 51 | doc = builder.build(filename);
|
|---|
| 52 | rulesNamespace = Namespace.getNamespace("ul:rules");
|
|---|
| 53 | } catch (JDOMException e) {
|
|---|
| [226] | 54 | Console.printerrln("Invalid rules file.");
|
|---|
| [1] | 55 | e.printStackTrace();
|
|---|
| 56 | } catch (IOException e) {
|
|---|
| [226] | 57 | Console.printerrln("Invalid rules file.");
|
|---|
| [1] | 58 | e.printStackTrace();
|
|---|
| 59 | }
|
|---|
| 60 |
|
|---|
| 61 | return doc;
|
|---|
| 62 | }
|
|---|
| 63 |
|
|---|
| 64 | /**
|
|---|
| 65 | * <p>
|
|---|
| 66 | * Name and path of the XML files containing the rules.
|
|---|
| 67 | * </p>
|
|---|
| 68 | */
|
|---|
| 69 | private String rulesFile;
|
|---|
| 70 |
|
|---|
| 71 | /**
|
|---|
| 72 | * <p>
|
|---|
| 73 | * Iterator used for the current sequence.
|
|---|
| 74 | * </p>
|
|---|
| 75 | */
|
|---|
| 76 | private ListIterator<WindowsMessage> sequenceIterator;
|
|---|
| 77 |
|
|---|
| 78 | /**
|
|---|
| 79 | * <p>
|
|---|
| 80 | * Token that is currently being generated.
|
|---|
| 81 | * </p>
|
|---|
| 82 | */
|
|---|
| [77] | 83 | private WindowsEvent currentToken;
|
|---|
| [1] | 84 |
|
|---|
| 85 | /**
|
|---|
| 86 | * <p>
|
|---|
| 87 | * Reference to the ul:rules namespace.
|
|---|
| 88 | * </p>
|
|---|
| 89 | */
|
|---|
| 90 | private static Namespace rulesNamespace;
|
|---|
| 91 |
|
|---|
| 92 | /**
|
|---|
| 93 | * <p>
|
|---|
| 94 | * The name of the rule that is currently being evaluated.
|
|---|
| 95 | * </p>
|
|---|
| 96 | */
|
|---|
| 97 | private String currentRuleName;
|
|---|
| 98 |
|
|---|
| 99 | /**
|
|---|
| 100 | * <p>
|
|---|
| 101 | * Internal message storage. Used to implement the
|
|---|
| 102 | * <code>{@literal <store>}</code> and <code>{@literal <storeSeq>}</code>
|
|---|
| 103 | * tags.
|
|---|
| 104 | * </p>
|
|---|
| 105 | */
|
|---|
| 106 | private Map<String, Object> messageStorage;
|
|---|
| 107 |
|
|---|
| 108 | /**
|
|---|
| 109 | * <p>
|
|---|
| 110 | * Creates a new EventGenerator. Sets "rules/rules.xml" as default file for
|
|---|
| 111 | * the rules.
|
|---|
| 112 | * </p>
|
|---|
| 113 | */
|
|---|
| 114 | public EventGenerator() {
|
|---|
| 115 | rulesFile = "rules/rules.xml";
|
|---|
| 116 | }
|
|---|
| 117 |
|
|---|
| 118 | /**
|
|---|
| 119 | * <p>
|
|---|
| 120 | * Tries to match the rules to the given sequence to generate an
|
|---|
| [77] | 121 | * {@link WindowsEvent}.
|
|---|
| [1] | 122 | * </p>
|
|---|
| 123 | * <p>
|
|---|
| 124 | * The rules are matched the order, in which they are defined in the XML
|
|---|
| 125 | * file. Therefore, the order of the rules in the file defines priorities,
|
|---|
| 126 | * when multiple rules could be matched to the same sequence.
|
|---|
| 127 | * </p>
|
|---|
| 128 | *
|
|---|
| 129 | * @param sequence
|
|---|
| 130 | * sequence of message for which an event will be generated
|
|---|
| 131 | * @return event that matches the messages; null, if no rule can be matched
|
|---|
| 132 | */
|
|---|
| 133 | @SuppressWarnings("unchecked")
|
|---|
| [77] | 134 | public WindowsEvent generateEvent(List<WindowsMessage> sequence) {
|
|---|
| [1] | 135 | Document rulesDoc = getDocument(rulesFile);
|
|---|
| 136 | Element rulesRoot = rulesDoc.getRootElement();
|
|---|
| 137 |
|
|---|
| 138 | List<Element> ruleElements = rulesRoot.getChildren("rule",
|
|---|
| 139 | rulesNamespace);
|
|---|
| 140 |
|
|---|
| 141 | boolean isMatch = false;
|
|---|
| 142 |
|
|---|
| 143 | for (int ruleIndex = 0; ruleIndex < ruleElements.size() && !isMatch; ruleIndex++) {
|
|---|
| 144 | Element currentRule = ruleElements.get(ruleIndex);
|
|---|
| [18] | 145 | currentRuleName = currentRule.getAttributeValue("name");
|
|---|
| [77] | 146 | currentToken = new WindowsEvent(currentRuleName);
|
|---|
| [58] | 147 | currentToken.setDecorator(MFCReplayDecorator.getInstance());
|
|---|
| [1] | 148 | isMatch = true;
|
|---|
| 149 | messageStorage = new HashMap<String, Object>();
|
|---|
| 150 | sequenceIterator = sequence.listIterator();
|
|---|
| 151 | List<Element> ruleChildrenMsg = currentRule.getChildren("msg",
|
|---|
| 152 | rulesNamespace);
|
|---|
| 153 |
|
|---|
| 154 | int i = 0;
|
|---|
| 155 | while (isMatch && i < ruleChildrenMsg.size()) {
|
|---|
| 156 | Element messageElement = ruleChildrenMsg.get(i);
|
|---|
| 157 | if ("true".equals(messageElement.getAttributeValue("multiple"))) {
|
|---|
| 158 | Element nextMessageElement = null;
|
|---|
| 159 | if (i + 1 < ruleChildrenMsg.size()) {
|
|---|
| 160 | nextMessageElement = ruleChildrenMsg.get(i + 1);
|
|---|
| 161 | }
|
|---|
| 162 | try {
|
|---|
| 163 | isMatch = matchMultipleMessages(messageElement,
|
|---|
| 164 | nextMessageElement);
|
|---|
| 165 | } catch (InvalidParameterException e) {
|
|---|
| 166 | Console.printerrln(e.getMessage());
|
|---|
| 167 | }
|
|---|
| 168 | } else {
|
|---|
| 169 | try {
|
|---|
| 170 | isMatch = matchSingleMessage(messageElement);
|
|---|
| 171 | } catch (InvalidParameterException e) {
|
|---|
| 172 | Console.printerrln(e.getMessage());
|
|---|
| 173 | }
|
|---|
| 174 | }
|
|---|
| 175 | i++;
|
|---|
| 176 | }
|
|---|
| 177 | if (isMatch) {
|
|---|
| 178 | List<Element> ruleChildren = currentRule.getChildren();
|
|---|
| 179 | for (Element genMsgElement : ruleChildren) {
|
|---|
| 180 | if (genMsgElement.getName().equals("genMsg")) {
|
|---|
| 181 | try {
|
|---|
| 182 | generateReplayMessage(genMsgElement);
|
|---|
| 183 | } catch (InvalidParameterException e) {
|
|---|
| 184 | Console.printerrln(e.getMessage());
|
|---|
| 185 | currentToken.invalidateReplay();
|
|---|
| 186 | }
|
|---|
| 187 | } else if (genMsgElement.getName().equals("genMsgSeq")) {
|
|---|
| 188 | try {
|
|---|
| 189 | generateReplaySequence(genMsgElement);
|
|---|
| 190 | currentToken.invalidateReplay();
|
|---|
| 191 | } catch (InvalidParameterException e) {
|
|---|
| 192 | Console.printerrln(e.getMessage());
|
|---|
| 193 | currentToken.invalidateReplay();
|
|---|
| 194 | }
|
|---|
| 195 | }
|
|---|
| 196 | }
|
|---|
| 197 | Element idinfoElement = currentRule.getChild("idinfo",
|
|---|
| 198 | rulesNamespace);
|
|---|
| 199 | if (idinfoElement != null) {
|
|---|
| 200 | // cannot be empty if document is valid
|
|---|
| 201 | List<Element> valueElements = idinfoElement.getChildren();
|
|---|
| 202 | currentToken.setIdInfo(getTermValue(null,
|
|---|
| 203 | valueElements.get(0)));
|
|---|
| 204 | }
|
|---|
| 205 | Console.traceln(currentRule.getAttributeValue("name")
|
|---|
| 206 | + currentToken.getIdInfo() + " matched");
|
|---|
| 207 | } else {
|
|---|
| 208 | currentToken = null;
|
|---|
| 209 | }
|
|---|
| 210 | }
|
|---|
| 211 | if (!isMatch) {
|
|---|
| 212 | Console.traceln("no match found for sequence: "
|
|---|
| 213 | + sequence.toString());
|
|---|
| 214 | }
|
|---|
| 215 | return currentToken;
|
|---|
| 216 | }
|
|---|
| 217 |
|
|---|
| [171] | 218 | // ////////////////////////////////////////////////////////////
|
|---|
| 219 | // Helper functions for matching of events, i.e., msg-nodes //
|
|---|
| 220 | // ////////////////////////////////////////////////////////////
|
|---|
| 221 |
|
|---|
| 222 | /**
|
|---|
| 223 | * <p>
|
|---|
| 224 | * Handles msg-nodes where multiple is not true, i.e., not a sequences.
|
|---|
| 225 | * </p>
|
|---|
| 226 | *
|
|---|
| 227 | * @param messageElement
|
|---|
| 228 | * {@link Element} representing the msg-node
|
|---|
| 229 | * @return true, if a match is found; false otherwise
|
|---|
| 230 | */
|
|---|
| 231 | private boolean matchSingleMessage(Element messageElement) {
|
|---|
| 232 | boolean isMatch = false;
|
|---|
| 233 | WindowsMessage currentMessage = null;
|
|---|
| 234 |
|
|---|
| 235 | int type = Integer.parseInt(messageElement.getAttributeValue("type"));
|
|---|
| 236 |
|
|---|
| 237 | while (!isMatch && sequenceIterator.hasNext()) {
|
|---|
| 238 | /*
|
|---|
| 239 | * traverses the messages from the current position forward till a
|
|---|
| 240 | * message with the correct type is found
|
|---|
| 241 | */
|
|---|
| 242 | currentMessage = sequenceIterator.next();
|
|---|
| 243 | if (type == currentMessage.getType()) {
|
|---|
| 244 | // message with the correct type found
|
|---|
| 245 | // eval child nodes for further matching/storing
|
|---|
| 246 | isMatch = evalEqualRestrictions(currentMessage, messageElement);
|
|---|
| 247 |
|
|---|
| 248 | // in case the message is a match, eval storage children
|
|---|
| 249 | if (isMatch) {
|
|---|
| 250 | handleStorage(messageElement, currentMessage);
|
|---|
| 251 | currentToken.setTarget(currentMessage
|
|---|
| 252 | .getXmlWindowDescription());
|
|---|
| 253 | currentToken
|
|---|
| 254 | .setTargetShort(currentMessage.getParentNames());
|
|---|
| [1] | 255 | }
|
|---|
| 256 | }
|
|---|
| 257 | }
|
|---|
| [171] | 258 |
|
|---|
| 259 | return isMatch;
|
|---|
| [1] | 260 | }
|
|---|
| 261 |
|
|---|
| [171] | 262 | /**
|
|---|
| 263 | * <p>
|
|---|
| 264 | * Handles msg-nodes where multiple is true, i.e., sequences. Requires
|
|---|
| 265 | * knowledge about the next msg-node to determine the end of the sequence.
|
|---|
| 266 | * </p>
|
|---|
| 267 | *
|
|---|
| 268 | * @param messageElement
|
|---|
| 269 | * {@link Element} representing the msg-node
|
|---|
| 270 | * @param nextMessageElement
|
|---|
| 271 | * {@link Element} representing the next msg-node; {@code null}
|
|---|
| 272 | * if the current node is the last one
|
|---|
| 273 | * @return true, if a sequence is matched; false otherwise
|
|---|
| 274 | */
|
|---|
| 275 | private boolean matchMultipleMessages(Element messageElement,
|
|---|
| 276 | Element nextMessageElement) {
|
|---|
| 277 | boolean isMatch = false;
|
|---|
| 278 | boolean isCurrentMatch = false;
|
|---|
| 279 | boolean nextMatchFound = false;
|
|---|
| 280 | WindowsMessage currentMessage = null;
|
|---|
| 281 | WindowsMessage nextMessage = null;
|
|---|
| 282 |
|
|---|
| 283 | int type = Integer.parseInt(messageElement.getAttributeValue("type"));
|
|---|
| 284 |
|
|---|
| 285 | int nextType = -1;
|
|---|
| 286 | if (nextMessageElement != null) {
|
|---|
| 287 | nextType = Integer.parseInt(nextMessageElement
|
|---|
| 288 | .getAttributeValue("type"));
|
|---|
| [1] | 289 | }
|
|---|
| 290 |
|
|---|
| [171] | 291 | while (!nextMatchFound && sequenceIterator.hasNext()) {
|
|---|
| 292 | currentMessage = sequenceIterator.next();
|
|---|
| 293 | if (type == currentMessage.getType()) {
|
|---|
| 294 | isCurrentMatch = evalEqualRestrictions(currentMessage,
|
|---|
| 295 | messageElement);
|
|---|
| 296 | isMatch = isMatch || isCurrentMatch;
|
|---|
| 297 |
|
|---|
| 298 | if (isCurrentMatch) {
|
|---|
| 299 | handleStorage(messageElement, currentMessage);
|
|---|
| 300 | currentToken.setTarget(currentMessage
|
|---|
| 301 | .getXmlWindowDescription());
|
|---|
| 302 | currentToken
|
|---|
| 303 | .setTargetShort(currentMessage.getParentNames());
|
|---|
| 304 | }
|
|---|
| [1] | 305 | }
|
|---|
| [171] | 306 | if (nextMessageElement != null && isMatch) {
|
|---|
| 307 | // peek next message to check if the sequence ends and the next
|
|---|
| 308 | // match is found
|
|---|
| 309 | if (!sequenceIterator.hasNext()) {
|
|---|
| 310 | return false; // sequence is over, but not all messages are
|
|---|
| 311 | // found
|
|---|
| [1] | 312 | }
|
|---|
| [171] | 313 | nextMessage = sequenceIterator.next();
|
|---|
| 314 | sequenceIterator.previous();
|
|---|
| 315 |
|
|---|
| 316 | if (nextType == nextMessage.getType()) {
|
|---|
| 317 | nextMatchFound = evalEqualRestrictions(nextMessage,
|
|---|
| 318 | nextMessageElement);
|
|---|
| 319 | }
|
|---|
| 320 |
|
|---|
| [1] | 321 | }
|
|---|
| 322 | }
|
|---|
| [171] | 323 |
|
|---|
| 324 | return isMatch;
|
|---|
| [1] | 325 | }
|
|---|
| 326 |
|
|---|
| [171] | 327 | /**
|
|---|
| 328 | * <p>
|
|---|
| 329 | * Handles equals-nodes.
|
|---|
| 330 | * </p>
|
|---|
| 331 | *
|
|---|
| 332 | * @param currentMessage
|
|---|
| 333 | * {@link Element} representing the msg-node the equals-node
|
|---|
| 334 | * belongs to
|
|---|
| 335 | * @param messageElement
|
|---|
| 336 | * {@link Element} representing the equals-node to be evaluated
|
|---|
| 337 | * @return true, if constraint is fulfilled; false otherwise
|
|---|
| 338 | */
|
|---|
| [1] | 339 | @SuppressWarnings("unchecked")
|
|---|
| 340 | private boolean evalEqualRestrictions(WindowsMessage currentMessage,
|
|---|
| 341 | Element messageElement) {
|
|---|
| 342 | boolean isMatch = true;
|
|---|
| 343 | for (Element childElement : (List<Element>) messageElement.getChildren(
|
|---|
| 344 | "equals", rulesNamespace)) {
|
|---|
| 345 | List<Element> termElements = childElement.getChildren();
|
|---|
| 346 | // the size 2 of termElements is guaranteed by the XML schema
|
|---|
| 347 | String value1 = getTermValue(currentMessage, termElements.get(0));
|
|---|
| 348 | String value2 = getTermValue(currentMessage, termElements.get(1));
|
|---|
| 349 | if (value1 == null || value2 == null) {
|
|---|
| 350 | isMatch = false;
|
|---|
| 351 | } else {
|
|---|
| 352 | isMatch = isMatch && value1.equals(value2);
|
|---|
| 353 | }
|
|---|
| 354 | }
|
|---|
| 355 | for (Element childElement : (List<Element>) messageElement.getChildren(
|
|---|
| 356 | "equalsSeq", rulesNamespace)) {
|
|---|
| 357 | List<Element> termElements = childElement.getChildren();
|
|---|
| [171] | 358 | List<String> values1 = getTermValueSeq(termElements.get(0));
|
|---|
| 359 | List<String> values2 = getTermValueSeq(termElements.get(0));
|
|---|
| [1] | 360 | if (values1 == null || values2 == null) {
|
|---|
| 361 | isMatch = false;
|
|---|
| 362 | } else {
|
|---|
| 363 | isMatch = isMatch && values1.equals(values2);
|
|---|
| 364 | }
|
|---|
| 365 | }
|
|---|
| 366 | return isMatch;
|
|---|
| 367 | }
|
|---|
| 368 |
|
|---|
| [171] | 369 | /**
|
|---|
| 370 | * <p>
|
|---|
| 371 | * Handles store-nodes and storeSeq-nodes.
|
|---|
| 372 | * </p>
|
|---|
| 373 | *
|
|---|
| 374 | * @param messageElement
|
|---|
| 375 | * {@link Element} representing the msg-node that is currently
|
|---|
| 376 | * being evaluated
|
|---|
| 377 | * @param currentMessage
|
|---|
| 378 | * current message in the message sequence that is matched; this
|
|---|
| 379 | * is the message that is stored
|
|---|
| 380 | */
|
|---|
| [1] | 381 | @SuppressWarnings("unchecked")
|
|---|
| [171] | 382 | private void handleStorage(Element messageElement,
|
|---|
| 383 | WindowsMessage currentMessage) {
|
|---|
| 384 | for (Element childElement : (List<Element>) messageElement.getChildren(
|
|---|
| 385 | "store", rulesNamespace)) {
|
|---|
| 386 | String identifier = childElement.getAttributeValue("var");
|
|---|
| 387 | messageStorage.put(identifier, currentMessage);
|
|---|
| 388 | resolveHwnd(currentMessage, childElement);
|
|---|
| 389 | }
|
|---|
| 390 | for (Element childElement : (List<Element>) messageElement.getChildren(
|
|---|
| 391 | "storeSeq", rulesNamespace)) {
|
|---|
| 392 | String identifier = childElement.getAttributeValue("varSeq");
|
|---|
| 393 | Object tmp = messageStorage.get(identifier);
|
|---|
| 394 | List<WindowsMessage> storedSequence;
|
|---|
| 395 | if (tmp == null || tmp instanceof WindowsMessage) {
|
|---|
| 396 | storedSequence = new LinkedList<WindowsMessage>();
|
|---|
| 397 | storedSequence.add(currentMessage);
|
|---|
| 398 | messageStorage.put(identifier, storedSequence);
|
|---|
| 399 | } else if (tmp instanceof List<?>) {
|
|---|
| 400 | storedSequence = (List<WindowsMessage>) tmp;
|
|---|
| 401 | storedSequence.add(currentMessage);
|
|---|
| 402 | messageStorage.put(identifier, storedSequence);
|
|---|
| 403 | }
|
|---|
| 404 | resolveHwnd(currentMessage, childElement);
|
|---|
| 405 | }
|
|---|
| 406 | }
|
|---|
| 407 |
|
|---|
| 408 | /**
|
|---|
| 409 | * <p>
|
|---|
| 410 | * Resolves a parameter that contains a HWND of a message to the target
|
|---|
| 411 | * string of the HWND and stores it.
|
|---|
| 412 | * </p>
|
|---|
| 413 | *
|
|---|
| 414 | * @param currentMessage
|
|---|
| 415 | * message whose HWND is resolved
|
|---|
| 416 | * @param childElement
|
|---|
| 417 | * child element of the store node that represents the resolve
|
|---|
| 418 | */
|
|---|
| 419 | @SuppressWarnings("unchecked")
|
|---|
| 420 | private void resolveHwnd(WindowsMessage currentMessage, Element childElement) {
|
|---|
| 421 | List<Element> resolveElements = childElement.getChildren("resolveHwnd",
|
|---|
| 422 | rulesNamespace);
|
|---|
| 423 | for (Element resolveElement : resolveElements) {
|
|---|
| 424 | String param = resolveElement.getAttributeValue("param");
|
|---|
| 425 | String storeParam = resolveElement.getAttributeValue("storeParam");
|
|---|
| 426 | int paramHwnd = Integer
|
|---|
| 427 | .parseInt(currentMessage.getParameter(param));
|
|---|
| 428 | WindowTreeNode node = WindowTree.getInstance().find(paramHwnd);
|
|---|
| 429 | if (node != null) {
|
|---|
| 430 | currentMessage.addParameter(storeParam,
|
|---|
| 431 | node.xmlRepresentation());
|
|---|
| 432 | }
|
|---|
| 433 | }
|
|---|
| 434 | }
|
|---|
| 435 |
|
|---|
| 436 | // /////////////////////////////////////////////////////
|
|---|
| 437 | // Helper functions for generating the replay, i.e.,
|
|---|
| 438 | // parsing of genMsg und genMsgSeq-nodes
|
|---|
| 439 | // /////////////////////////////////////////////////////
|
|---|
| 440 |
|
|---|
| 441 | /**
|
|---|
| 442 | * <p>
|
|---|
| 443 | * Handles genMsg-nodes and adds the replay to the {@link Event} that is
|
|---|
| 444 | * generated.
|
|---|
| 445 | * </p>
|
|---|
| 446 | *
|
|---|
| 447 | * @param genMsgElement
|
|---|
| 448 | * {@link Element} representing the genMsg-node
|
|---|
| 449 | */
|
|---|
| 450 | @SuppressWarnings("unchecked")
|
|---|
| [1] | 451 | private void generateReplayMessage(Element genMsgElement) {
|
|---|
| 452 | List<Element> genMsgChildren = genMsgElement.getChildren();
|
|---|
| 453 | WindowsMessage generatedMessage = null;
|
|---|
| 454 | if (genMsgChildren.size() == 1) { // replay stored message without
|
|---|
| 455 | // change
|
|---|
| 456 | String obj = genMsgChildren.get(0).getAttributeValue("obj");
|
|---|
| 457 | generatedMessage = getStoredMessageVariable(null, obj);
|
|---|
| 458 | } else { // generate message according to the rule
|
|---|
| 459 | for (Element genMsgChild : genMsgChildren) {
|
|---|
| 460 | Element termElement = (Element) genMsgChild.getChildren()
|
|---|
| 461 | .get(0);
|
|---|
| 462 | if (genMsgChild.getName().equals("type")) {
|
|---|
| 463 | try {
|
|---|
| 464 | int msgType = Integer.parseInt(getTermValue(null,
|
|---|
| 465 | termElement));
|
|---|
| 466 | generatedMessage = new WindowsMessage(msgType);
|
|---|
| 467 | } catch (NumberFormatException e) {
|
|---|
| 468 | throw new InvalidParameterException(
|
|---|
| 469 | "Failure generating replay sequence for rule "
|
|---|
| 470 | + currentRuleName
|
|---|
| 471 | + ": Defined type is not an integer.");
|
|---|
| 472 | }
|
|---|
| 473 | } else if (genMsgChild.getName().equals("target")) {
|
|---|
| 474 | String targetString = getTermValue(null, termElement);
|
|---|
| 475 | generatedMessage.setXmlWindowDescription(targetString);
|
|---|
| 476 | } else if (genMsgChild.getName().equals("LPARAM")) {
|
|---|
| 477 | String paramValueStr = getTermValue(null, termElement);
|
|---|
| [41] | 478 | long paramValue = 0;
|
|---|
| [171] | 479 | Element loword = genMsgChild.getChild("LOWORD",
|
|---|
| 480 | rulesNamespace);
|
|---|
| 481 | if (loword != null) {
|
|---|
| [41] | 482 | paramValue = loHiWord(genMsgChild);
|
|---|
| [42] | 483 | generatedMessage.setLPARAM(paramValue);
|
|---|
| [41] | 484 | } else {
|
|---|
| 485 | try {
|
|---|
| 486 | paramValue = Integer.parseInt(paramValueStr);
|
|---|
| 487 | generatedMessage.setLPARAM(paramValue);
|
|---|
| 488 | } catch (NumberFormatException e) {
|
|---|
| [171] | 489 | generatedMessage
|
|---|
| 490 | .setLPARAMasWindowDesc(paramValueStr);
|
|---|
| [41] | 491 | }
|
|---|
| [1] | 492 | }
|
|---|
| 493 | } else if (genMsgChild.getName().equals("WPARAM")) {
|
|---|
| 494 | String paramValueStr = getTermValue(null, termElement);
|
|---|
| [41] | 495 | long paramValue = 0;
|
|---|
| [171] | 496 | Element loword = genMsgChild.getChild("LOWORD",
|
|---|
| 497 | rulesNamespace);
|
|---|
| 498 | if (loword != null) {
|
|---|
| [41] | 499 | paramValue = loHiWord(genMsgChild);
|
|---|
| [42] | 500 | generatedMessage.setWPARAM(paramValue);
|
|---|
| [41] | 501 | } else {
|
|---|
| 502 | try {
|
|---|
| 503 | paramValue = Integer.parseInt(paramValueStr);
|
|---|
| 504 | generatedMessage.setWPARAM(paramValue);
|
|---|
| 505 | } catch (NumberFormatException e) {
|
|---|
| [171] | 506 | generatedMessage
|
|---|
| 507 | .setWPARAMasWindowDesc(paramValueStr);
|
|---|
| [41] | 508 | }
|
|---|
| [1] | 509 | }
|
|---|
| 510 | }
|
|---|
| 511 | }
|
|---|
| 512 | }
|
|---|
| 513 | if (generatedMessage != null) {
|
|---|
| 514 | int delay = Integer.parseInt(genMsgElement
|
|---|
| 515 | .getAttributeValue("delay"));
|
|---|
| 516 | generatedMessage.setDelay(delay);
|
|---|
| 517 | } else {
|
|---|
| 518 | currentToken.invalidateReplay();
|
|---|
| 519 | }
|
|---|
| 520 | currentToken.addReplayEvent(generatedMessage);
|
|---|
| 521 | }
|
|---|
| 522 |
|
|---|
| [171] | 523 | /**
|
|---|
| 524 | * Handles genMsgSeq-nodes and adds the replay to the {@link Event} that is
|
|---|
| 525 | * generated.</p>
|
|---|
| 526 | *
|
|---|
| 527 | * @param genMsgElement
|
|---|
| 528 | * {@link Element} representing the genMsgSeq-node.
|
|---|
| 529 | */
|
|---|
| [1] | 530 | @SuppressWarnings("unchecked")
|
|---|
| 531 | private void generateReplaySequence(Element genMsgElement) {
|
|---|
| 532 | List<Element> genMsgSeqChildren = genMsgElement.getChildren();
|
|---|
| 533 | List<WindowsMessage> generatedMessageSeq = new LinkedList<WindowsMessage>();
|
|---|
| 534 | if (genMsgSeqChildren.size() == 1) {
|
|---|
| 535 | String obj = genMsgSeqChildren.get(0).getAttributeValue("seqObj");
|
|---|
| 536 | generatedMessageSeq = getStoredSeqVariable(obj);
|
|---|
| 537 | } else {
|
|---|
| 538 | boolean msgsGenerated = false;
|
|---|
| 539 | int constMsgType = 0;
|
|---|
| 540 | for (Element genMsgSeqChild : genMsgSeqChildren) {
|
|---|
| 541 | Element termElement = (Element) genMsgSeqChild.getChildren()
|
|---|
| 542 | .get(0);
|
|---|
| 543 | if (genMsgSeqChild.getName().equals("type")) {
|
|---|
| 544 | // note: cannot easily be extracted because of mulitple
|
|---|
| 545 | // return values
|
|---|
| 546 | if (termElement.getName().equals("seqValue")) {
|
|---|
| 547 | String obj = termElement.getAttributeValue("seqObj");
|
|---|
| 548 | List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
|
|---|
| 549 | for (WindowsMessage msg : seqVar) {
|
|---|
| 550 | generatedMessageSeq.add(new WindowsMessage(msg
|
|---|
| 551 | .getType()));
|
|---|
| 552 | }
|
|---|
| 553 | msgsGenerated = true;
|
|---|
| 554 | } else { // constValue type
|
|---|
| 555 | constMsgType = Integer.parseInt(getTermValue(null,
|
|---|
| 556 | termElement));
|
|---|
| 557 | }
|
|---|
| 558 | } else if (genMsgSeqChild.getName().equals("target")) {
|
|---|
| 559 | msgsGenerated = createSequenceTarget(generatedMessageSeq,
|
|---|
| 560 | msgsGenerated, constMsgType, termElement);
|
|---|
| 561 | } else if (genMsgSeqChild.getName().equals("LPARAM")) {
|
|---|
| 562 | msgsGenerated = createSequenceLParam(generatedMessageSeq,
|
|---|
| 563 | msgsGenerated, constMsgType, termElement);
|
|---|
| 564 | } else if (genMsgSeqChild.getName().equals("WPARAM")) {
|
|---|
| 565 | msgsGenerated = createSequenceWParam(generatedMessageSeq,
|
|---|
| 566 | msgsGenerated, constMsgType, termElement);
|
|---|
| 567 | }
|
|---|
| 568 | }
|
|---|
| 569 | }
|
|---|
| 570 | currentToken.addReplaySequence(generatedMessageSeq);
|
|---|
| 571 | }
|
|---|
| 572 |
|
|---|
| [171] | 573 | /**
|
|---|
| 574 | * <p>
|
|---|
| 575 | * Creates the targets for replay sequences generated with genMsgSeq-nodes.
|
|---|
| 576 | * </p>
|
|---|
| 577 | *
|
|---|
| 578 | * @param generatedMessageSeq
|
|---|
| 579 | * list of the messages that is being generated
|
|---|
| 580 | * @param msgsGenerated
|
|---|
| 581 | * boolean stating if the list of messages is already generated
|
|---|
| 582 | * or if the generation has to be handles by this method
|
|---|
| 583 | * @param constMsgType
|
|---|
| 584 | * a constant message type that is used for message generation,
|
|---|
| 585 | * in case the list of message is generated by this method
|
|---|
| 586 | * @param termElement
|
|---|
| 587 | * {@link Element} representing the term-node describing the
|
|---|
| 588 | * target
|
|---|
| 589 | * @return true, if the list of message is generated after calling this
|
|---|
| 590 | * method; false otherwise
|
|---|
| 591 | * @throws NoSuchElementException
|
|---|
| 592 | * thrown if the seqVar referred to in the termElement contains
|
|---|
| 593 | * a different number of messages than is contained in
|
|---|
| 594 | * messageSeq
|
|---|
| 595 | */
|
|---|
| 596 | private boolean createSequenceTarget(
|
|---|
| 597 | List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
|
|---|
| 598 | int constMsgType, Element termElement)
|
|---|
| 599 | throws NoSuchElementException {
|
|---|
| 600 | Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
|
|---|
| 601 | if (termElement.getName().equals("seqValue")) {
|
|---|
| 602 | String obj = termElement.getAttributeValue("seqObj");
|
|---|
| 603 | List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
|
|---|
| 604 | if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
|
|---|
| 605 | throw new InvalidParameterException(
|
|---|
| 606 | "Failure generating replay sequence for rule "
|
|---|
| 607 | + currentRuleName
|
|---|
| 608 | + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
|
|---|
| 609 | }
|
|---|
| 610 | for (WindowsMessage msg : seqVar) {
|
|---|
| 611 | WindowsMessage currentSeqMsg = getCurrentSeqMsg(
|
|---|
| 612 | generatedMessageSeq, msgsGenerated, constMsgType,
|
|---|
| 613 | seqIterator);
|
|---|
| 614 | String targetString = msg.getParameter(termElement
|
|---|
| 615 | .getAttributeValue("param"));
|
|---|
| 616 | currentSeqMsg.setXmlWindowDescription(targetString);
|
|---|
| 617 | }
|
|---|
| 618 | msgsGenerated = true;
|
|---|
| 619 | } else { // const value
|
|---|
| 620 | throw new AssertionError("target must be a sequence variable!");
|
|---|
| 621 | /*
|
|---|
| 622 | * If target would not be a variable, the message-elements could not
|
|---|
| 623 | * yet be created and the whole sequence might be broken. If this is
|
|---|
| 624 | * to be changed, createSequenceLParam and createSequenceWParam need
|
|---|
| 625 | * to be addepted, too.
|
|---|
| 626 | */
|
|---|
| 627 | }
|
|---|
| 628 | return msgsGenerated;
|
|---|
| 629 | }
|
|---|
| 630 |
|
|---|
| 631 | /**
|
|---|
| 632 | * <p>
|
|---|
| 633 | * Creates the LPARAMs for replay sequences generated with genMsgSeq-nodes.
|
|---|
| 634 | * </p>
|
|---|
| 635 | *
|
|---|
| 636 | * @param generatedMessageSeq
|
|---|
| 637 | * list of the messages that is being generated
|
|---|
| 638 | * @param msgsGenerated
|
|---|
| 639 | * boolean stating if the list of messages is already generated
|
|---|
| 640 | * or if the generation has to be handles by this method
|
|---|
| 641 | * @param constMsgType
|
|---|
| 642 | * a constant message type that is used for message generation,
|
|---|
| 643 | * in case the list of message is generated by this method
|
|---|
| 644 | * @param termElement
|
|---|
| 645 | * {@link Element} representing the term-node describing the
|
|---|
| 646 | * LPARAM
|
|---|
| 647 | * @return true, if the list of message is generated after calling this
|
|---|
| 648 | * method; false otherwise
|
|---|
| 649 | * @throws NoSuchElementException
|
|---|
| 650 | * thrown if the seqVar referred to in the termElement contains
|
|---|
| 651 | * a different number of messages than is contained in
|
|---|
| 652 | * messageSeq
|
|---|
| 653 | */
|
|---|
| 654 | private boolean createSequenceLParam(
|
|---|
| 655 | List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
|
|---|
| 656 | int constMsgType, Element termElement)
|
|---|
| 657 | throws NoSuchElementException {
|
|---|
| 658 | Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
|
|---|
| 659 | if (termElement.getName().equals("seqValue")) {
|
|---|
| 660 | String obj = termElement.getAttributeValue("seqObj");
|
|---|
| 661 | List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
|
|---|
| 662 | if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
|
|---|
| 663 | throw new InvalidParameterException(
|
|---|
| 664 | "Failure generating replay sequence for rule "
|
|---|
| 665 | + currentRuleName
|
|---|
| 666 | + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
|
|---|
| 667 | }
|
|---|
| 668 | for (WindowsMessage msg : seqVar) {
|
|---|
| 669 | WindowsMessage currentSeqMsg = getCurrentSeqMsg(
|
|---|
| 670 | generatedMessageSeq, msgsGenerated, constMsgType,
|
|---|
| 671 | seqIterator);
|
|---|
| 672 | String paramValueStr = msg.getParameter(termElement
|
|---|
| 673 | .getAttributeValue("param"));
|
|---|
| 674 | int paramValue = 0;
|
|---|
| 675 | try {
|
|---|
| 676 | paramValue = Integer.parseInt(paramValueStr);
|
|---|
| 677 | currentSeqMsg.setLPARAM(paramValue);
|
|---|
| 678 | } catch (NumberFormatException e) {
|
|---|
| 679 | currentSeqMsg.setLPARAMasWindowDesc(paramValueStr);
|
|---|
| 680 | }
|
|---|
| 681 | }
|
|---|
| 682 | if (seqIterator.hasNext()) {
|
|---|
| 683 | // the first seq-var has a different number of elements than the
|
|---|
| 684 | // current one
|
|---|
| 685 | throw new NoSuchElementException();
|
|---|
| 686 | }
|
|---|
| 687 | msgsGenerated = true;
|
|---|
| 688 | } else { // const value
|
|---|
| 689 | int paramValue = Integer.parseInt(getTermValue(null, termElement));
|
|---|
| 690 | while (seqIterator.hasNext()) {
|
|---|
| 691 | seqIterator.next().setLPARAM(paramValue);
|
|---|
| 692 | }
|
|---|
| 693 | }
|
|---|
| 694 | return msgsGenerated;
|
|---|
| 695 | }
|
|---|
| 696 |
|
|---|
| 697 | /**
|
|---|
| 698 | * <p>
|
|---|
| 699 | * Creates the WPARAMs for replay sequences generated with genMsgSeq-nodes.
|
|---|
| 700 | * </p>
|
|---|
| 701 | *
|
|---|
| 702 | * @param generatedMessageSeq
|
|---|
| 703 | * list of the messages that is being generated
|
|---|
| 704 | * @param msgsGenerated
|
|---|
| 705 | * boolean stating if the list of messages is already generated
|
|---|
| 706 | * or if the generation has to be handles by this method
|
|---|
| 707 | * @param constMsgType
|
|---|
| 708 | * a constant message type that is used for message generation,
|
|---|
| 709 | * in case the list of message is generated by this method
|
|---|
| 710 | * @param termElement
|
|---|
| 711 | * {@link Element} representing the term-node describing the
|
|---|
| 712 | * WPARAM
|
|---|
| 713 | * @return true, if the list of message is generated after calling this
|
|---|
| 714 | * method; false otherwise
|
|---|
| 715 | * @throws NoSuchElementException
|
|---|
| 716 | * thrown if the seqVar referred to in the termElement contains
|
|---|
| 717 | * a different number of messages than is contained in
|
|---|
| 718 | * messageSeq
|
|---|
| 719 | */
|
|---|
| 720 | private boolean createSequenceWParam(
|
|---|
| 721 | List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
|
|---|
| 722 | int constMsgType, Element termElement)
|
|---|
| 723 | throws NoSuchElementException {
|
|---|
| 724 | Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
|
|---|
| 725 | if (termElement.getName().equals("seqValue")) {
|
|---|
| 726 | String obj = termElement.getAttributeValue("seqObj");
|
|---|
| 727 | List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
|
|---|
| 728 | if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
|
|---|
| 729 | throw new InvalidParameterException(
|
|---|
| 730 | "Failure generating replay sequence for rule "
|
|---|
| 731 | + currentRuleName
|
|---|
| 732 | + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
|
|---|
| 733 | }
|
|---|
| 734 | for (WindowsMessage msg : seqVar) {
|
|---|
| 735 | WindowsMessage currentSeqMsg = getCurrentSeqMsg(
|
|---|
| 736 | generatedMessageSeq, msgsGenerated, constMsgType,
|
|---|
| 737 | seqIterator);
|
|---|
| 738 | String paramValueStr = msg.getParameter(termElement
|
|---|
| 739 | .getAttributeValue("param"));
|
|---|
| 740 | int paramValue = 0;
|
|---|
| 741 | try {
|
|---|
| 742 | paramValue = Integer.parseInt(paramValueStr);
|
|---|
| 743 | currentSeqMsg.setWPARAM(paramValue);
|
|---|
| 744 | } catch (NumberFormatException e) {
|
|---|
| 745 | currentSeqMsg.setWPARAMasWindowDesc(paramValueStr);
|
|---|
| 746 | }
|
|---|
| 747 | }
|
|---|
| 748 | if (seqIterator.hasNext()) {
|
|---|
| 749 | // the first seq-var has a different number of elements than the
|
|---|
| 750 | // current one
|
|---|
| 751 | throw new NoSuchElementException();
|
|---|
| 752 | }
|
|---|
| 753 | msgsGenerated = true;
|
|---|
| 754 | } else { // const value
|
|---|
| 755 | int paramValue = Integer.parseInt(getTermValue(null, termElement));
|
|---|
| 756 | while (seqIterator.hasNext()) {
|
|---|
| 757 | seqIterator.next().setWPARAM(paramValue);
|
|---|
| 758 | }
|
|---|
| 759 | }
|
|---|
| 760 | return msgsGenerated;
|
|---|
| 761 | }
|
|---|
| 762 |
|
|---|
| 763 | /**
|
|---|
| 764 | * <p>
|
|---|
| 765 | * If a message sequence is already generated, i.e., msgsGenerated is true,
|
|---|
| 766 | * the seqIterator is used to iterate through these messages and return the
|
|---|
| 767 | * current one. If the message sequence is not yet generated, i.e.,
|
|---|
| 768 | * msgsGenerated is false, the message sequence is generated on the fly
|
|---|
| 769 | * during each call of this message and the newly generated messages are
|
|---|
| 770 | * returned.
|
|---|
| 771 | * </p>
|
|---|
| 772 | *
|
|---|
| 773 | * @param generatedMessageSeq
|
|---|
| 774 | * message sequence
|
|---|
| 775 | * @param msgsGenerated
|
|---|
| 776 | * indicates if generatedMessageSeq is already generated or has
|
|---|
| 777 | * to be generated on the fly by this method
|
|---|
| 778 | * @param constMsgType
|
|---|
| 779 | * type of the message to be used for message generation
|
|---|
| 780 | * @param seqIterator
|
|---|
| 781 | * iterates through an already generated message sequence; must
|
|---|
| 782 | * not be {@code null}, if msgsGenerated is true
|
|---|
| 783 | * @return current message
|
|---|
| 784 | */
|
|---|
| [1] | 785 | private WindowsMessage getCurrentSeqMsg(
|
|---|
| 786 | List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
|
|---|
| 787 | int constMsgType, Iterator<WindowsMessage> seqIterator) {
|
|---|
| 788 | WindowsMessage currentSeqMsg = null;
|
|---|
| 789 | if (msgsGenerated) {
|
|---|
| 790 | currentSeqMsg = seqIterator.next();
|
|---|
| 791 | } else {
|
|---|
| 792 | currentSeqMsg = new WindowsMessage(constMsgType);
|
|---|
| 793 | generatedMessageSeq.add(currentSeqMsg);
|
|---|
| 794 | }
|
|---|
| 795 | return currentSeqMsg;
|
|---|
| 796 | }
|
|---|
| 797 |
|
|---|
| [171] | 798 | // ////////////////////////////
|
|---|
| 799 | // General helper functions //
|
|---|
| 800 | // ////////////////////////////
|
|---|
| 801 |
|
|---|
| 802 | /**
|
|---|
| 803 | * <p>
|
|---|
| 804 | * Retrieves a message from the storage for, e.g., comparison or replay.
|
|---|
| 805 | * "this" is used to refer to the current message.
|
|---|
| 806 | * </p>
|
|---|
| 807 | *
|
|---|
| 808 | * @param currentMessage
|
|---|
| 809 | * current message during the parsing; passed to handle "this"
|
|---|
| 810 | * @param obj
|
|---|
| 811 | * object identifier in the storage
|
|---|
| 812 | * @return message retrieved from the storage
|
|---|
| 813 | * @throws InvalidParameterException
|
|---|
| 814 | * thrown in case of invalid uses of "this" or if no message
|
|---|
| 815 | * with the identifier obj is found in the storage
|
|---|
| 816 | */
|
|---|
| [1] | 817 | private WindowsMessage getStoredMessageVariable(
|
|---|
| 818 | WindowsMessage currentMessage, String obj)
|
|---|
| 819 | throws InvalidParameterException {
|
|---|
| 820 | WindowsMessage varMessage = null;
|
|---|
| 821 | if (obj.equals("this")) {
|
|---|
| 822 | if (currentMessage == null) {
|
|---|
| 823 | throw new InvalidParameterException(
|
|---|
| 824 | "Failure obtaining term value for rule "
|
|---|
| 825 | + currentRuleName
|
|---|
| 826 | + ": \"this\" is not a valid name for generating runtime messages.");
|
|---|
| 827 | }
|
|---|
| 828 | varMessage = currentMessage;
|
|---|
| 829 | } else {
|
|---|
| 830 | Object tmp = messageStorage.get(obj);
|
|---|
| 831 | if (tmp instanceof WindowsMessage) {
|
|---|
| 832 | varMessage = (WindowsMessage) tmp;
|
|---|
| 833 | } else {
|
|---|
| 834 | throw new InvalidParameterException(
|
|---|
| 835 | "Failure obtaining term value for rule "
|
|---|
| 836 | + currentRuleName + ": No message \"" + obj
|
|---|
| 837 | + "\" stored.");
|
|---|
| 838 | }
|
|---|
| 839 | }
|
|---|
| 840 | return varMessage;
|
|---|
| 841 | }
|
|---|
| 842 |
|
|---|
| [171] | 843 | /**
|
|---|
| 844 | * <p>
|
|---|
| 845 | * Retrieves a stored message sequence from the storage.
|
|---|
| 846 | * </p>
|
|---|
| 847 | *
|
|---|
| 848 | * @param obj
|
|---|
| 849 | * object identifier in the storage
|
|---|
| 850 | * @return message sequence retrieved from the storage
|
|---|
| 851 | * @throws InvalidParameterException
|
|---|
| 852 | * thrown if no message sequences with the identifier obj is
|
|---|
| 853 | * found in the storage
|
|---|
| 854 | */
|
|---|
| [1] | 855 | @SuppressWarnings("unchecked")
|
|---|
| 856 | private List<WindowsMessage> getStoredSeqVariable(String obj)
|
|---|
| 857 | throws InvalidParameterException {
|
|---|
| 858 | List<WindowsMessage> varMsgSeq = null;
|
|---|
| 859 | Object tmp = messageStorage.get(obj);
|
|---|
| 860 | if (tmp instanceof List<?>) {
|
|---|
| 861 | varMsgSeq = (List<WindowsMessage>) tmp;
|
|---|
| 862 | } else {
|
|---|
| 863 | throw new InvalidParameterException(
|
|---|
| 864 | "Failure obtaining term value for rule " + currentRuleName
|
|---|
| 865 | + ": No sequence \"" + obj + "\" store.");
|
|---|
| 866 | }
|
|---|
| 867 | return varMsgSeq;
|
|---|
| 868 | }
|
|---|
| 869 |
|
|---|
| [171] | 870 | /**
|
|---|
| 871 | * <p>
|
|---|
| 872 | * Handles term-nodes and returns the value of the described term.
|
|---|
| 873 | * </p>
|
|---|
| 874 | *
|
|---|
| 875 | * @param currentMessage
|
|---|
| 876 | * current message during the parsing; required to resolve
|
|---|
| 877 | * references to "this" in a term
|
|---|
| 878 | * @param termElement
|
|---|
| 879 | * {@link Element} representing the term node
|
|---|
| 880 | * @return value of the term or {@code null} of the term node could not be
|
|---|
| 881 | * evaluated
|
|---|
| 882 | */
|
|---|
| [1] | 883 | private String getTermValue(WindowsMessage currentMessage,
|
|---|
| 884 | Element termElement) {
|
|---|
| 885 | String value = null;
|
|---|
| 886 | WindowsMessage varMessage = null;
|
|---|
| 887 | if (termElement.getName().equals("constValue")) {
|
|---|
| 888 | value = termElement.getAttributeValue("value");
|
|---|
| 889 | } else if (termElement.getName().equals("paramValue")) {
|
|---|
| 890 | String objectName = termElement.getAttributeValue("obj");
|
|---|
| 891 | varMessage = getStoredMessageVariable(currentMessage, objectName);
|
|---|
| 892 | if (varMessage != null) {
|
|---|
| 893 | String param = termElement.getAttributeValue("param");
|
|---|
| 894 | value = varMessage.getParameter(param);
|
|---|
| 895 | }
|
|---|
| 896 | } else if (termElement.getName().equals("winInfoValue")) {
|
|---|
| 897 | String objectName = termElement.getAttributeValue("obj");
|
|---|
| 898 | varMessage = getStoredMessageVariable(currentMessage, objectName);
|
|---|
| 899 | if (varMessage != null) {
|
|---|
| 900 | String paramString = termElement.getAttributeValue("winParam");
|
|---|
| 901 | if (paramString.equals("class")) {
|
|---|
| 902 | value = varMessage.getWindowClass();
|
|---|
| 903 | } else if (paramString.equals("resourceId")) {
|
|---|
| 904 | value = "" + varMessage.getWindowResourceId();
|
|---|
| 905 | } else if (paramString.equals("hwnd")) {
|
|---|
| 906 | value = "" + varMessage.getHwnd();
|
|---|
| [27] | 907 | } else if (paramString.equals("parentTarget")) {
|
|---|
| 908 | String target = varMessage.getXmlWindowDescription();
|
|---|
| 909 | int index = target.lastIndexOf("<");
|
|---|
| [171] | 910 | if (index == 0) {
|
|---|
| [244] | 911 | Console.traceln("Trying to adress parent of top-level window! Replay probably invalid!");
|
|---|
| [28] | 912 | }
|
|---|
| [27] | 913 | value = target.substring(0, index);
|
|---|
| [141] | 914 | } else if (paramString.equals("parentClass")) {
|
|---|
| 915 | value = varMessage.getParentClass();
|
|---|
| [1] | 916 | }
|
|---|
| 917 | }
|
|---|
| 918 | } else if (termElement.getName().equals("msgInfoValue")) {
|
|---|
| 919 | String objectName = termElement.getAttributeValue("obj");
|
|---|
| 920 | varMessage = getStoredMessageVariable(currentMessage, objectName);
|
|---|
| 921 | if (varMessage != null) {
|
|---|
| 922 | String paramString = termElement.getAttributeValue("msgParam");
|
|---|
| 923 | if (paramString.equals("type")) {
|
|---|
| 924 | value = "" + varMessage.getType();
|
|---|
| 925 | } else if (paramString.equals("target")) {
|
|---|
| 926 | value = varMessage.getXmlWindowDescription();
|
|---|
| 927 | }
|
|---|
| 928 | }
|
|---|
| 929 | }
|
|---|
| 930 | return value;
|
|---|
| 931 | }
|
|---|
| 932 |
|
|---|
| [171] | 933 | /**
|
|---|
| 934 | * <p>
|
|---|
| 935 | * Handles term-nodes contained by equalSeq nodes.
|
|---|
| 936 | * </p>
|
|---|
| 937 | *
|
|---|
| 938 | * @param termElement
|
|---|
| 939 | * {@link Element} representing the term-node
|
|---|
| 940 | * @return list of values of the term
|
|---|
| 941 | */
|
|---|
| 942 | private List<String> getTermValueSeq(Element termElement) {
|
|---|
| [1] | 943 | List<String> values = new LinkedList<String>();
|
|---|
| 944 | if (termElement.getName().equals("seqValue")) {
|
|---|
| 945 | String obj = termElement.getAttributeValue("seqObj");
|
|---|
| 946 | String param = termElement.getAttributeValue("param");
|
|---|
| 947 | List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
|
|---|
| 948 |
|
|---|
| 949 | for (WindowsMessage msg : seqVar) {
|
|---|
| 950 | // msg.getParameter returns null, if parameter is not found,
|
|---|
| 951 | // therefore the List can contain null-values
|
|---|
| 952 | values.add(msg.getParameter(param));
|
|---|
| 953 | }
|
|---|
| 954 | }
|
|---|
| 955 | return values;
|
|---|
| 956 | }
|
|---|
| 957 |
|
|---|
| [171] | 958 | /**
|
|---|
| 959 | * <p>
|
|---|
| 960 | * Handles LOWORD and HIWORD child nodes of LPARAM and WPARAM nodes. The
|
|---|
| 961 | * returned value is the LPARAM/WPARAM value based on the LOWORD and HIWORD.
|
|---|
| 962 | * </p>
|
|---|
| 963 | *
|
|---|
| 964 | * @param param
|
|---|
| 965 | * {@link Element} representing the LPARAM/WPARAM node
|
|---|
| 966 | * @return value of the LPARAM/WPARAM
|
|---|
| 967 | */
|
|---|
| [41] | 968 | private long loHiWord(Element param) {
|
|---|
| 969 | Element loword = param.getChild("LOWORD", rulesNamespace);
|
|---|
| 970 | Element hiword = param.getChild("HIWORD", rulesNamespace);
|
|---|
| [171] | 971 | String lowordStr = getTermValue(null, (Element) loword.getChildren()
|
|---|
| 972 | .get(0));
|
|---|
| 973 | String hiwordStr = getTermValue(null, (Element) hiword.getChildren()
|
|---|
| 974 | .get(0));
|
|---|
| 975 | return MAKEPARAM(Short.parseShort(lowordStr),
|
|---|
| 976 | Short.parseShort(hiwordStr));
|
|---|
| [41] | 977 | }
|
|---|
| [171] | 978 |
|
|---|
| 979 | /**
|
|---|
| 980 | * <p>
|
|---|
| 981 | * Takes to short integers and combines them into the high and low order
|
|---|
| 982 | * bits of an integer.
|
|---|
| 983 | * </p>
|
|---|
| 984 | *
|
|---|
| 985 | * @param loword
|
|---|
| 986 | * low word
|
|---|
| 987 | * @param hiword
|
|---|
| 988 | * high word
|
|---|
| 989 | * @return combined integer
|
|---|
| 990 | */
|
|---|
| [43] | 991 | private static int MAKEPARAM(short loword, short hiword) {
|
|---|
| [171] | 992 | return loword | ((int) hiword) << Short.SIZE;
|
|---|
| [41] | 993 | }
|
|---|
| [1] | 994 |
|
|---|
| 995 | }
|
|---|
