| RNodeList (* Returns hive_node_h* or NULL. *)
| RValue (* Returns hive_value_h or 0. *)
| RValueList (* Returns hive_value_h* or NULL. *)
+ | RLenValue (* Returns offset and length of value. *)
| RString (* Returns char* or NULL. *)
| RStringList (* Returns char** or NULL. *)
| RLenType (* See hivex_value_type. *)
"node_struct_length", (RSize, [AHive; ANode "node"]),
"return the length of a node",
"\
-Return the length of the node data structure. Returns 0
-and sets errno on error.";
+Return the length of the node data structure.";
"value_struct_length", (RSize, [AHive; AValue "val"]),
"return the length of a value data structure",
"\
-Return the length of the value data structure. Returns 0
-and sets errno on error.";
+Return the length of the value data structure.";
+
+ "value_data_cell_offset", (RLenValue, [AHive; AValue "val"]),
+ "return the offset and length of a value data cell",
+ "\
+Return the offset and length of the value's data cell.
+
+The data cell is a registry structure that contains the length
+(a 4 byte, little endian integer) followed by the data.
+
+If the length of the value is less than or equal to 4 bytes
+then the offset and length returned by this function is zero
+as the data is inlined in the value.
+
+Returns 0 and sets errno on error.";
"value_value", (RLenTypeVal, [AHive; AValue "val"]),
"return data length, data type and data of a value",
| RValueList -> pr "hive_value_h *"
| RString -> pr "char *"
| RStringList -> pr "char **"
+ | RLenValue -> pr "hive_value_h "
| RLenType -> pr "int "
| RLenTypeVal -> pr "char *"
| RInt32 -> pr "int32_t "
) (snd style);
(match fst style with
| RLenType | RLenTypeVal -> pr ", hive_type *t, size_t *len"
+ | RLenValue -> pr ", size_t *len"
| _ -> ()
);
pr ");\n"
pr "\
Returns 0 on success.
On error this returns -1 and sets errno.\n\n"
+ | RLenValue ->
+ pr "\
+Returns a value handle.
+On error this returns 0 and sets errno.\n\n"
| RLenTypeVal ->
pr "\
The value is returned as an array of bytes (of length C<len>).
| RString -> pr "string"
| RStringList -> pr "string array"
| RLenType -> pr "hive_type * int"
+ | RLenValue -> pr "int * value"
| RLenTypeVal -> pr "hive_type * string"
| RInt32 -> pr "int32"
| RInt64 -> pr "int64"
static value Val_hive_type (hive_type);
static value copy_int_array (size_t *);
static value copy_type_len (size_t, hive_type);
+static value copy_len_value (size_t, hive_value_h);
static value copy_type_value (const char *, size_t, hive_type);
static void raise_error (const char *) Noreturn;
static void raise_closed (const char *) Noreturn;
let c_params =
match fst style with
| RLenType | RLenTypeVal -> c_params @ [["&t"; "&len"]]
+ | RLenValue -> c_params @ [["&len"]]
| _ -> c_params in
let c_params = List.concat c_params in
pr " size_t len;\n";
pr " hive_type t;\n";
"-1"
+ | RLenValue ->
+ pr " errno = 0;";
+ pr " hive_value_h r;\n";
+ pr " size_t len;\n";
+ "0 && errno != 0"
| RLenTypeVal ->
pr " char *r;\n";
pr " size_t len;\n";
pr " for (int i = 0; r[i] != NULL; ++i) free (r[i]);\n";
pr " free (r);\n"
| RLenType -> pr " rv = copy_type_len (len, t);\n"
+ | RLenValue -> pr " rv = copy_len_value (len, r);\n"
| RLenTypeVal ->
pr " rv = copy_type_value (r, len, t);\n";
pr " free (r);\n"
}
static value
+copy_len_value (size_t len, hive_value_h r)
+{
+ CAMLparam0 ();
+ CAMLlocal2 (v, rv);
+
+ rv = caml_alloc (2, 0);
+ v = Val_int (len);
+ Store_field (rv, 0, v);
+ v = Val_int (r);
+ Store_field (rv, 1, v);
+ CAMLreturn (rv);
+}
+
+static value
copy_type_value (const char *r, size_t len, hive_type t)
{
CAMLparam0 ();
| RString
| RStringList
| RLenType
+ | RLenValue
| RLenTypeVal
| RInt32
| RInt64 -> ()
| RString -> pr "$string = "
| RStringList -> pr "@strings = "
| RLenType -> pr "($type, $len) = "
+ | RLenValue -> pr "($len, $value) = "
| RLenTypeVal -> pr "($type, $data) = "
| RInt32 -> pr "$int32 = "
| RInt64 -> pr "$int64 = "
| RValueList
| RStringList
| RLenType
+ | RLenValue
| RLenTypeVal -> pr "void\n"
| RInt32 -> pr "SV *\n"
| RInt64 -> pr "SV *\n"
pr " PUSHs (sv_2mortal (newSViv (type)));\n";
pr " PUSHs (sv_2mortal (newSViv (len)));\n";
+ | RLenValue ->
+ pr "PREINIT:\n";
+ pr " hive_value_h r;\n";
+ pr " size_t len;\n";
+ pr " PPCODE:\n";
+ pr " errno = 0;\n";
+ pr " r = hivex_%s (%s, &len);\n"
+ name (String.concat ", " c_params);
+ free_args ();
+ pr " if (r == 0 && errno)\n";
+ pr " croak (\"%%s: \", \"%s\", strerror (errno));\n"
+ name;
+ pr " EXTEND (SP, 2);\n";
+ pr " PUSHs (sv_2mortal (newSViv (len)));\n";
+ pr " PUSHs (sv_2mortal (newSViv (r)));\n";
+
| RLenTypeVal ->
pr "PREINIT:\n";
pr " char *r;\n";
generate_header CStyle LGPLv2plus;
pr "\
+#include <config.h>
+
#define PY_SSIZE_T_CLEAN 1
#include <Python.h>
get_value (PyObject *v, hive_set_value *ret)
{
PyObject *obj;
+#ifndef HAVE_PYSTRING_ASSTRING
+ PyObject *bytes;
+#endif
obj = PyDict_GetItemString (v, \"key\");
if (!obj) {
PyErr_SetString (PyExc_RuntimeError, \"no 'key' element in dictionary\");
return -1;
}
- if (!PyString_Check (obj)) {
- PyErr_SetString (PyExc_RuntimeError, \"'key' element is not a string\");
- return -1;
- }
+#ifdef HAVE_PYSTRING_ASSTRING
ret->key = PyString_AsString (obj);
+#else
+ bytes = PyUnicode_AsUTF8String (obj);
+ ret->key = PyBytes_AS_STRING (bytes);
+#endif
obj = PyDict_GetItemString (v, \"t\");
if (!obj) {
PyErr_SetString (PyExc_RuntimeError, \"no 't' element in dictionary\");
return -1;
}
- if (!PyInt_Check (obj)) {
- PyErr_SetString (PyExc_RuntimeError, \"'t' element is not an integer\");
- return -1;
- }
- ret->t = PyInt_AsLong (obj);
+ ret->t = PyLong_AsLong (obj);
obj = PyDict_GetItemString (v, \"value\");
if (!obj) {
PyErr_SetString (PyExc_RuntimeError, \"no 'value' element in dictionary\");
return -1;
}
- if (!PyString_Check (obj)) {
- PyErr_SetString (PyExc_RuntimeError, \"'value' element is not a string\");
- return -1;
- }
+#ifdef HAVE_PYSTRING_ASSTRING
ret->value = PyString_AsString (obj);
ret->len = PyString_Size (obj);
+#else
+ bytes = PyUnicode_AsUTF8String (obj);
+ ret->value = PyBytes_AS_STRING (bytes);
+ ret->len = PyBytes_GET_SIZE (bytes);
+#endif
return 0;
}
;
list = PyList_New (argc);
- for (i = 0; i < argc; ++i)
+ for (i = 0; i < argc; ++i) {
+#ifdef HAVE_PYSTRING_ASSTRING
PyList_SetItem (list, i, PyString_FromString (argv[i]));
+#else
+ PyList_SetItem (list, i, PyUnicode_FromString (argv[i]));
+#endif
+ }
return list;
}
put_len_type (size_t len, hive_type t)
{
PyObject *r = PyTuple_New (2);
- PyTuple_SetItem (r, 0, PyInt_FromLong ((long) t));
+ PyTuple_SetItem (r, 0, PyLong_FromLong ((long) t));
PyTuple_SetItem (r, 1, PyLong_FromLongLong ((long) len));
return r;
}
static PyObject *
+put_len_val (size_t len, hive_value_h value)
+{
+ PyObject *r = PyTuple_New (2);
+ PyTuple_SetItem (r, 0, PyLong_FromLongLong ((long) len));
+ PyTuple_SetItem (r, 1, PyLong_FromLongLong ((long) value));
+ return r;
+}
+
+static PyObject *
put_val_type (char *val, size_t len, hive_type t)
{
PyObject *r = PyTuple_New (2);
- PyTuple_SetItem (r, 0, PyInt_FromLong ((long) t));
+ PyTuple_SetItem (r, 0, PyLong_FromLong ((long) t));
+#ifdef HAVE_PYSTRING_ASSTRING
PyTuple_SetItem (r, 1, PyString_FromStringAndSize (val, len));
+#else
+ PyTuple_SetItem (r, 1, PyBytes_FromStringAndSize (val, len));
+#endif
return r;
}
pr " size_t len;\n";
pr " hive_type t;\n";
"-1"
+ | RLenValue ->
+ pr " errno = 0;\n";
+ pr " int r;\n";
+ pr " size_t len;\n";
+ "0 && errno != 0"
| RLenTypeVal ->
pr " char *r;\n";
pr " size_t len;\n";
let c_params =
match fst style with
| RLenType | RLenTypeVal -> c_params @ ["&t"; "&len"]
+ | RLenValue -> c_params @ ["&len"]
| _ -> c_params in
List.iter (
| RValue ->
pr " py_r = PyLong_FromLongLong (r);\n"
| RString ->
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " py_r = PyString_FromString (r);\n";
+ pr "#else\n";
+ pr " py_r = PyUnicode_FromString (r);\n";
+ pr "#endif\n";
pr " free (r);"
| RStringList ->
pr " py_r = put_string_list (r);\n";
pr " free_strings (r);\n"
| RLenType ->
pr " py_r = put_len_type (len, t);\n"
+ | RLenValue ->
+ pr " py_r = put_len_val (len, r);\n"
| RLenTypeVal ->
pr " py_r = put_val_type (r, len, t);\n";
pr " free (r);\n"
| RInt32 ->
- pr " py_r = PyInt_FromLong ((long) r);\n"
+ pr " py_r = PyLong_FromLong ((long) r);\n"
| RInt64 ->
pr " py_r = PyLong_FromLongLong (r);\n"
);
(* Init function. *)
pr "\
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef moduledef = {
+ PyModuleDef_HEAD_INIT,
+ \"libhivexmod\", /* m_name */
+ \"hivex module\", /* m_doc */
+ -1, /* m_size */
+ methods, /* m_methods */
+ NULL, /* m_reload */
+ NULL, /* m_traverse */
+ NULL, /* m_clear */
+ NULL, /* m_free */
+};
+#endif
+
+static PyObject *
+moduleinit (void)
+{
+ PyObject *m;
+
+#if PY_MAJOR_VERSION >= 3
+ m = PyModule_Create (&moduledef);
+#else
+ m = Py_InitModule ((char *) \"libhivexmod\", methods);
+#endif
+
+ return m; /* m might be NULL if module init failed */
+}
+
+#if PY_MAJOR_VERSION >= 3
+PyMODINIT_FUNC
+PyInit_libhivexmod (void)
+{
+ return moduleinit ();
+}
+#else
void
initlibhivexmod (void)
{
- static int initialized = 0;
-
- if (initialized) return;
- Py_InitModule ((char *) \"libhivexmod\", methods);
- initialized = 1;
+ (void) moduleinit ();
}
+#endif
"
and generate_python_py () =
generate_header HashStyle LGPLv2plus;
pr "\
-u\"\"\"Python bindings for hivex
+\"\"\"Python bindings for hivex
import hivex
h = hivex.Hivex (filename)
pr " def %s (self" name;
List.iter (fun arg -> pr ", %s" (name_of_argt arg)) args;
pr "):\n";
- pr " u\"\"\"%s\"\"\"\n" shortdesc;
+ pr " \"\"\"%s\"\"\"\n" shortdesc;
pr " return libhivexmod.%s (self._o" name;
List.iter (
fun arg ->
#define RARRAY_LEN(r) (RARRAY((r))->len)
#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(r) (RSTRING((r))->len)
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(r) (RSTRING((r))->ptr)
+#endif
+
static VALUE m_hivex; /* hivex module */
static VALUE c_hivex; /* hive_h handle */
static VALUE e_Error; /* used for all errors */
val->key = StringValueCStr (key);
val->t = NUM2ULL (type);
- val->len = RSTRING (value)->len;
- val->value = RSTRING (value)->ptr;
+ val->len = RSTRING_LEN (value);
+ val->value = RSTRING_PTR (value);
}
static hive_set_value *
| RString -> "string"
| RStringList -> "list"
| RLenType -> "hash"
+ | RLenValue -> "integer"
| RLenTypeVal -> "hash"
| RInt32 -> "integer"
| RInt64 -> "integer" in
pr " size_t len;\n";
pr " hive_type t;\n";
"-1"
+ | RLenValue ->
+ pr " errno = 0;\n";
+ pr " hive_value_h r;\n";
+ pr " size_t len;\n";
+ "0 && errno != 0"
| RLenTypeVal ->
pr " char *r;\n";
pr " size_t len;\n";
let c_params =
match ret with
| RLenType | RLenTypeVal -> c_params @ [["&t"; "&len"]]
+ | RLenValue -> c_params @ [["&len"]]
| _ -> c_params in
let c_params = List.concat c_params in
pr " rb_hash_aset (rv, ID2SYM (rb_intern (\"len\")), INT2NUM (len));\n";
pr " rb_hash_aset (rv, ID2SYM (rb_intern (\"type\")), INT2NUM (t));\n";
pr " return rv;\n"
+ | RLenValue ->
+ pr " VALUE rv = rb_hash_new ();\n";
+ pr " rb_hash_aset (rv, ID2SYM (rb_intern (\"len\")), INT2NUM (len));\n";
+ pr " rb_hash_aset (rv, ID2SYM (rb_intern (\"off\")), ULL2NUM (r));\n";
+ pr " return rv;\n"
| RLenTypeVal ->
pr " VALUE rv = rb_hash_new ();\n";
pr " rb_hash_aset (rv, ID2SYM (rb_intern (\"len\")), INT2NUM (len));\n";
git.annexia.org / hivex.git / blobdiff