See: https://github.com/VirusTotal/yara/issues/990

Closes issue #79.

If Yara return error for `rules.match(data='string')` the Python wrapper
module crashes process with a segmentation fault.
Handle properly errors from 'data' and from 'pid'.

This Python function takes two optional kwargs: stack_size,
max_strings_per_rule. These each are unsigned int types and will be used
to update the YR_CONFIG_STACK_SIZE and YR_CONFIG_MAX_STRINGS_PER_RULE
configuration options in the matching engine, respectively. We found a
case preventing moving from cmdline yara to python-yara due to the lack
of control over these options in the Python module. This fixes that. I
suppose, at some point, it might be worthwhile to also implement a
get_config entrypoint as well.

Fix regression in "includes" argument in yara.compile. With includes=True includes were being disabled instead of enabled.

Closes #78.

* Fix regression in which_callbacks.

* Add test to detect regression fixed in 367290a586ef7b7f83e5db265bfe39b57847473e.

* Fix typo in previous commit.

* Remove redundant conditional.

* stable on python 2

* Stable on python 2 and 3 (fixed utf-8 and ascii encoding issues)
 * Still needs compatible yara submodule update once pull request accepted

* * Fixed all encoding issues

* Proper error handling

* Updating yara submodule to reference yara patched with include callback support

* Updating submodule's branch

* Updating yara submodule

* Updating yara submodule

* Updating yara submodule

* Updating yara submodule

* Submodule update

* * Fixing memory leaks
* Fixing errors handling

* making error messages order consistent between include_callback and default yara behaviour

* Removing exception printing when callback fails

* Minor re-styling.

* Destroy compiler if PyCallable_Check(include_callback) fails.

* References to Py_None should be increased.

* Use Py_DECREF instead of Py_XDECREF for references that can't be NULL.

* Minor re-styling.

* Fix reference leak.

After calling Py_INCREF(include_callback) some code paths were leading to a return without calling Py_DECREF. Calling Py_INCREF before yr_compiler_set_include_callback is not necessary, as this function doesn't yield control to Python, but it should be called before yr_compiler_add_XX.

* Remove unnecessary calls to Py_INCREF/Py_DECREF.

The references were already incremented in yara_compile.

* Implement test case for include callbacks

* Point yara submodule to official repository.

Add a 'which_callbacks' keyword to match(), which limits when the Python callback will be called.

Revert "Add a 'which_callback' keyword to match(), which limits when the python callback will be called."

This reverts commit e2cb4e39.

When iterating over a Rules object, the iteration would work for a
single pass before throwing a StopIteration exception. This slightly
changes the iteration logic to reset to the iteration list head after
a full iteration has been completed.

When rules are passed as strings, the line number would not be shown
when input as a string. The information is available however.

If it is not a file like object, the function would return -1. This
would eventually lead to a segmention fault later on.

The "scan" method was returning a error when the "externals" dictionary has keys that weren't previously passed to "compile". Ignore those extra keys to avoid regression errors.

Show appropriate error message when an external variable is redefined with a different type. See issue #12.

Implement a callback to handle module data. It will be given a dictionary
which contains all the information stored in the module that is fit for
consumption. Things like functions are left out.

You can now do things like this:

```
import yara
import json
from pprint import pprint

def modules_callback(d):
    try:
        pprint(d)
        # This will not work if you have non-ASCII in your strings.
        #print json.dumps(d, indent=4)
    except Exception as e:
        print "Exception: %s" % e
    return yara.CALLBACK_CONTINUE

rules = yara.compile(source='import "pe" rule always_false { condition: false }')
with open('foo.exe') as f:
    rules.match(data=f.read(), modules_callback=modules_callback)
```

yara_callback was invoking Python's code without acquiring the global interpreter lock.

Starting with Python 3.2 hash functions should return Py_hash_t instead of long.