template <typename T> void TypeSequence<T>::call_concat_inplace::call() { TypeSequence &type = dynamic_cast<TypeSequence &>(TypeBase<T>::m_get()); if (self) { try { T &obj = reinterpret_cast<typename TypeBase<T>::T_struct *>(self)->endosome; PYHROL_TRACE(tpMediator, type.address(obj), signature) type.concat(Ptr<T>(&obj, self), args); Py_IncRef(self); } catch(...) { self = NULL; throw; } } else { type.concat(Ptr<T>(), args); } }
static int TargetCall(WsXmlDocH doc, PyObject* instance, const char* opname, int nargs, ...) { va_list vargs; PyObject *pyargs = NULL; PyObject *pyfunc = NULL; PyObject *result = NULL; WsmanStatus status; wsman_status_init(&status); pyargs = PyTuple_New(nargs); pyfunc = PyObject_GetAttrString(instance, opname); if (pyfunc == NULL) { PyErr_Print(); PyErr_Clear(); char* str = fmtstr("Python module does not contain \"%s\"", opname); debug("%s", str); status.fault_code = WSA_ENDPOINT_UNAVAILABLE; status.fault_detail_code = 0; free(str); goto cleanup; } if (! PyCallable_Check(pyfunc)) { char* str = fmtstr("Python module attribute \"%s\" is not callable", opname); debug("%s", str); status.fault_code = WSA_ENDPOINT_UNAVAILABLE; status.fault_detail_code = 0; free(str); goto cleanup; } va_start(vargs, nargs); int i; for (i = 0; i < nargs; ++i) { PyObject* arg = va_arg(vargs, PyObject*); if (arg == NULL) { arg = Py_None; Py_IncRef(arg); } PyTuple_SET_ITEM(pyargs, i, arg); } va_end(vargs); result = PyObject_CallObject(pyfunc, pyargs); if (PyErr_Occurred()) { status.fault_code = WSMAN_INTERNAL_ERROR; status.fault_detail_code = 0; PyErr_Clear(); goto cleanup; } if (! PyTuple_Check(result) || (PyTuple_Size(result) != 2 && PyTuple_Size(result) != 1)) { TARGET_THREAD_BEGIN_ALLOW; status.fault_msg = fmtstr("Python function \"%s\" didn't return a two-tuple", opname); status.fault_code = WSMAN_INTERNAL_ERROR; status.fault_detail_code = 0; TARGET_THREAD_END_ALLOW; goto cleanup; } PyObject* code = PyTuple_GetItem(result, 0); PyObject* detail = Py_None; if (PyTuple_Size(result) == 2) { detail = PyTuple_GetItem(result, 1); } if (! PyInt_Check(code) || (! PyInt_Check(detail) && detail != Py_None)) { TARGET_THREAD_BEGIN_ALLOW; status.fault_msg = fmtstr("Python function \"%s\" didn't return a {<int>, <int>) two-tuple", opname); status.fault_code = WSMAN_INTERNAL_ERROR; status.fault_detail_code = 0; TARGET_THREAD_END_ALLOW; goto cleanup; } status.fault_code = PyInt_AsLong(code); if (detail == Py_None) { status.fault_code = WSMAN_INTERNAL_ERROR; status.fault_detail_code = 0; } else { status.fault_detail_code = PyInt_AsLong(detail); } cleanup: if (status.fault_code != WSMAN_RC_OK) wsman_generate_fault( doc, status.fault_code, status.fault_detail_code, status.fault_msg ); Py_DecRef(pyargs); Py_DecRef(pyfunc); Py_DecRef(result); return status.fault_code != WSMAN_RC_OK; }
/* Creates a file object IO handle * Make sure the value file_object_io_handle is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int pymsiecf_file_object_io_handle_initialize( pymsiecf_file_object_io_handle_t **file_object_io_handle, PyObject *file_object, libcerror_error_t **error ) { static char *function = "pymsiecf_file_object_io_handle_initialize"; if( file_object_io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file object IO handle.", function ); return( -1 ); } if( *file_object_io_handle != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file object IO handle value already set.", function ); return( -1 ); } if( file_object == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file object.", function ); return( -1 ); } *file_object_io_handle = (pymsiecf_file_object_io_handle_t *) PyMem_Malloc( sizeof( pymsiecf_file_object_io_handle_t ) ); if( *file_object_io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create file object IO handle.", function ); goto on_error; } if( memory_set( *file_object_io_handle, 0, sizeof( pymsiecf_file_object_io_handle_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear file object IO handle.", function ); goto on_error; } ( *file_object_io_handle )->file_object = file_object; Py_IncRef( ( *file_object_io_handle )->file_object ); return( 1 ); on_error: if( *file_object_io_handle != NULL ) { PyMem_Free( *file_object_io_handle ); *file_object_io_handle = NULL; } return( -1 ); }
/* Creates a new items object * Returns a Python object if successful or NULL on error */ PyObject *pyfwsi_items_new( pyfwsi_item_list_t *item_list_object, PyObject* (*get_item_by_index)( pyfwsi_item_list_t *item_list_object, int item_index ), int number_of_items ) { pyfwsi_items_t *pyfwsi_items = NULL; static char *function = "pyfwsi_items_new"; if( item_list_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid item list object.", function ); return( NULL ); } if( get_item_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get item by index function.", function ); return( NULL ); } /* Make sure the items values are initialized */ pyfwsi_items = PyObject_New( struct pyfwsi_items, &pyfwsi_items_type_object ); if( pyfwsi_items == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize items.", function ); goto on_error; } if( pyfwsi_items_init( pyfwsi_items ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize items.", function ); goto on_error; } pyfwsi_items->item_list_object = item_list_object; pyfwsi_items->get_item_by_index = get_item_by_index; pyfwsi_items->number_of_items = number_of_items; Py_IncRef( (PyObject *) pyfwsi_items->item_list_object ); return( (PyObject *) pyfwsi_items ); on_error: if( pyfwsi_items != NULL ) { Py_DecRef( (PyObject *) pyfwsi_items ); } return( NULL ); }
void PyIOCPBuffer_AddObject( PyObject* m ) { Py_IncRef((PyObject*)&iocp_buffer_type); PyModule_AddObject( m, "buffer", (PyObject *)&iocp_buffer_type ) ; }
/* Creates a new items object * Returns a Python object if successful or NULL on error */ PyObject *pymsiecf_items_new( PyObject *parent_object, PyObject* (*get_item_by_index)( PyObject *parent_object, int index ), int number_of_items ) { pymsiecf_items_t *items_object = NULL; static char *function = "pymsiecf_items_new"; if( parent_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid parent object.", function ); return( NULL ); } if( get_item_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get item by index function.", function ); return( NULL ); } /* Make sure the items values are initialized */ items_object = PyObject_New( struct pymsiecf_items, &pymsiecf_items_type_object ); if( items_object == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to create items object.", function ); goto on_error; } if( pymsiecf_items_init( items_object ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize items object.", function ); goto on_error; } items_object->parent_object = parent_object; items_object->get_item_by_index = get_item_by_index; items_object->number_of_items = number_of_items; Py_IncRef( (PyObject *) items_object->parent_object ); return( (PyObject *) items_object ); on_error: if( items_object != NULL ) { Py_DecRef( (PyObject *) items_object ); } return( NULL ); }
PyObject *TuplesDefaultImpl::ubiquitous_caller ( exceptionHandler &h , PyObject *args , PyObject *kwds , const bool is_probe , const callerTypes ct ) { const callVariants cv = m_data.cv; const modes mode = is_probe ? (_G_signature_hack_enabled ? modeInitHack : modeInit) : modeRun; TuplesData2DefaultImpl &data = dynamic_cast<TuplesData2DefaultImpl &>(m_data); if (mode == modeRun && !m_data.m_valid) { PyErr_Format(PyExc_AttributeError, "Tuple invalid due to one or more previous errors. Call impossible in any way (%s)", Container::container().context_by_address(data.m_address).c_str()); return NULL; } if (ct == ctGetter) { TupleState::set_mode_getter(); } else if (ct == ctSetter) { TupleState::set_mode_setter(); } if (mode == modeRun) { m_exec = true; m_tuple = args; m_kw = kwds; m_retval = NULL; } if (mode == modeRun || mode == modeInitHack) { m_clear_before_execute(); bool just_filled = false , exception_thrown ; try { exception_thrown = !exceptionHandler::call(h, data.m_address); just_filled = !exception_thrown; } catch (const ParseException &ex) { //Неверные аргументы Python; только в режиме исполнения PyErr_Format(PyExc_TypeError, "%s (%s)", ex.what(), Container::container().context_by_address(data.m_address).c_str()); exception_thrown = true; just_filled = true; } /* NOTE Despite of exception thrown user call can leave return value inited Non null return value in case of not filled tuple is unbelievable internal error */ if (m_retval && (exception_thrown || !TupleState::is_filled())) { Py_DecRef(m_retval); m_retval = NULL; } if (mode == modeInitHack && PyErr_Occurred()) { PyErr_PrintEx(0); PyErr_Clear(); } if (!TupleState::is_filled()) { /* NOTE Tuple must be filled during first call in any way. Any exceptions or invalid actions inside (TuplesData::*call_t) whereby tuple not filled during first call causes inevitable invalidation. Any subsequent calls waved aside This in the same way as for v_getsetter calls: even if getter filled successfully, error in setter invalidates tuple at all and virce versa */ m_data.m_valid = false; just_filled = false; if (!exception_thrown) { PyErr_Format(PyExc_AttributeError, "Tuple invalid due to unknown reason. Any further calls impossible in any way (%s)", Container::container().context_by_address(data.m_address).c_str()); } } else if (just_filled) { //Here: user call executed successfully or caused parse error just_filled = false; try { just_filled = TupleState::just_filled(); } catch (const CheckCalls::ForbiddenCall &ex) { PyErr_Format(PyExc_AttributeError, "%s (%s)", ex.what(), Container::container().context_by_address(data.m_address).c_str()); } } if (just_filled || m_data.m_valid && (mode == modeInit || mode == modeInitHack)) { m_generate_description(); } } if (cv == v_getsetter && TupleState::mode() == TupleFillState::modSetter || cv == v_setter || cv == v_protof || cv == v_ctor) { return NULL; } if (!PyErr_Occurred() && !m_retval && mode == modeRun) { Py_IncRef(Py_None); m_retval = Py_None; } return m_retval; }
/* Creates a new blocks sequence and iterator object * Returns a Python object if successful or NULL on error */ PyObject *pyvshadow_blocks_new( PyObject *parent_object, PyObject* (*get_item_by_index)( PyObject *parent_object, int index ), int number_of_items ) { pyvshadow_blocks_t *sequence_object = NULL; static char *function = "pyvshadow_blocks_new"; if( parent_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid parent object.", function ); return( NULL ); } if( get_item_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get item by index function.", function ); return( NULL ); } /* Make sure the blocks values are initialized */ sequence_object = PyObject_New( struct pyvshadow_blocks, &pyvshadow_blocks_type_object ); if( sequence_object == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to create sequence object.", function ); goto on_error; } sequence_object->parent_object = parent_object; sequence_object->get_item_by_index = get_item_by_index; sequence_object->current_index = 0; sequence_object->number_of_items = number_of_items; Py_IncRef( (PyObject *) sequence_object->parent_object ); return( (PyObject *) sequence_object ); on_error: if( sequence_object != NULL ) { Py_DecRef( (PyObject *) sequence_object ); } return( NULL ); }
/* Creates a new physical volumes object * Returns a Python object if successful or NULL on error */ PyObject *pyvslvm_physical_volumes_new( pyvslvm_volume_group_t *volume_group_object, PyObject* (*get_physical_volume_by_index)( pyvslvm_volume_group_t *volume_group_object, int physical_volume_index ), int number_of_physical_volumes ) { pyvslvm_physical_volumes_t *pyvslvm_physical_volumes = NULL; static char *function = "pyvslvm_physical_volumes_new"; if( volume_group_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid volume group object.", function ); return( NULL ); } if( get_physical_volume_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get physical volume by index function.", function ); return( NULL ); } /* Make sure the physical volumes values are initialized */ pyvslvm_physical_volumes = PyObject_New( struct pyvslvm_physical_volumes, &pyvslvm_physical_volumes_type_object ); if( pyvslvm_physical_volumes == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize physical volumes.", function ); goto on_error; } if( pyvslvm_physical_volumes_init( pyvslvm_physical_volumes ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize physical volumes.", function ); goto on_error; } pyvslvm_physical_volumes->volume_group_object = volume_group_object; pyvslvm_physical_volumes->get_physical_volume_by_index = get_physical_volume_by_index; pyvslvm_physical_volumes->number_of_physical_volumes = number_of_physical_volumes; Py_IncRef( (PyObject *) pyvslvm_physical_volumes->volume_group_object ); return( (PyObject *) pyvslvm_physical_volumes ); on_error: if( pyvslvm_physical_volumes != NULL ) { Py_DecRef( (PyObject *) pyvslvm_physical_volumes ); } return( NULL ); }
static foreign_t python_apply(term_t tin, term_t targs, term_t keywds, term_t tf) { PyObject *pF; PyObject *pArgs, *pKeywords; PyObject *pValue; int i, arity; atom_t aname; foreign_t out; term_t targ = PL_new_term_ref(); pF = term_to_python(tin, true); PyErr_Clear(); if (pF == NULL) { { return false; } } if (PL_is_atom(targs)) { pArgs = NULL; } else { if (!PL_get_name_arity(targs, &aname, &arity)) { { return false; } } if (arity == 1 && PL_get_arg(1, targs, targ) && PL_is_variable(targ)) { /* ignore (_) */ pArgs = NULL; } else { pArgs = PyTuple_New(arity); if (!pArgs) { return false; } for (i = 0; i < arity; i++) { PyObject *pArg; if (!PL_get_arg(i + 1, targs, targ)) { return false; } pArg = term_to_python(targ, true); if (pArg == NULL) { return false; } /* pArg reference stolen here: */ PyTuple_SetItem(pArgs, i, pArg); } } } if (PL_is_atom(keywds)) { pKeywords = NULL; } else { pKeywords = term_to_python(keywds, true); } if (PyCallable_Check(pF)) { pValue = PyEval_CallObjectWithKeywords(pF, pArgs, pKeywords); // PyObject_Print(pF,stderr,0);fprintf(stderr, "\n"); // PyObject_Print(pArgs,stderr,0);fprintf(stderr, " "); // PyObject_Print(pKeywords,stderr,0);fprintf(stderr, "\n"); if (!pValue) PyErr_Print(); else Py_IncRef(pValue); } else if (pArgs == NULL) { pValue = pF; if (pF) { Py_IncRef(pValue); } } else { PyErr_Print(); { return false; } } if (pArgs) Py_DECREF(pArgs); Py_DECREF(pF); if (pValue == NULL) { return false; } out = python_to_ptr(pValue, tf); return out; }
/* Creates a new columns object * Returns a Python object if successful or NULL on error */ PyObject *pyesedb_columns_new( pyesedb_table_t *table_object, PyObject* (*get_column_by_index)( pyesedb_table_t *table_object, int column_entry ), int number_of_columns ) { pyesedb_columns_t *pyesedb_columns = NULL; static char *function = "pyesedb_columns_new"; if( table_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid table object.", function ); return( NULL ); } if( get_column_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get column by index function.", function ); return( NULL ); } /* Make sure the columns values are initialized */ pyesedb_columns = PyObject_New( struct pyesedb_columns, &pyesedb_columns_type_object ); if( pyesedb_columns == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize columns.", function ); goto on_error; } if( pyesedb_columns_init( pyesedb_columns ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize columns.", function ); goto on_error; } pyesedb_columns->table_object = table_object; pyesedb_columns->get_column_by_index = get_column_by_index; pyesedb_columns->number_of_columns = number_of_columns; Py_IncRef( (PyObject *) pyesedb_columns->table_object ); return( (PyObject *) pyesedb_columns ); on_error: if( pyesedb_columns != NULL ) { Py_DecRef( (PyObject *) pyesedb_columns ); } return( NULL ); }
/* Seeks a certain offset in the file entry data * Returns a Python object holding the offset if successful or NULL on error */ PyObject *pyewf_file_entry_seek_offset( pyewf_file_entry_t *pyewf_file_entry, PyObject *arguments, PyObject *keywords ) { libcerror_error_t *error = NULL; static char *function = "pyewf_file_entry_seek_offset"; static char *keyword_list[] = { "offset", "whence", NULL }; off64_t offset = 0; int whence = 0; if( pyewf_file_entry == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf file_entry.", function ); return( NULL ); } if( pyewf_file_entry->file_entry == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf file_entry - missing libewf file_entry.", function ); return( NULL ); } if( PyArg_ParseTupleAndKeywords( arguments, keywords, "L|i", keyword_list, &offset, &whence ) == 0 ) { return( NULL ); } Py_BEGIN_ALLOW_THREADS offset = libewf_file_entry_seek_offset( pyewf_file_entry->file_entry, offset, whence, &error ); Py_END_ALLOW_THREADS if( offset == -1 ) { pyewf_error_raise( error, PyExc_IOError, "%s: unable to seek offset.", function ); libcerror_error_free( &error ); return( NULL ); } Py_IncRef( Py_None ); return( Py_None ); }
/** * Replace the current condition list with the new one. * * @param self TODO. Must not be NULL. * @param args TODO. Must not be NULL. * * @retval SRD_OK The new condition list was set successfully. * @retval SRD_ERR There was an error setting the new condition list. * The contents of di->condition_list are undefined. * @retval 9999 TODO. */ static int set_new_condition_list(PyObject *self, PyObject *args) { struct srd_decoder_inst *di; GSList *term_list; PyObject *py_conditionlist, *py_conds, *py_dict; int i, num_conditions, ret; if (!self || !args) return SRD_ERR_ARG; /* Get the decoder instance. */ if (!(di = srd_inst_find_by_obj(NULL, self))) { PyErr_SetString(PyExc_Exception, "decoder instance not found"); return SRD_ERR; } /* * Return an error condition from .wait() when termination is * requested, such that decode() will terminate. */ if (di->want_wait_terminate) { srd_dbg("%s: %s: Skip (want_term).", di->inst_id, __func__); return SRD_ERR; } /* Parse the argument of self.wait() into 'py_conds'. */ if (!PyArg_ParseTuple(args, "O", &py_conds)) { /* Let Python raise this exception. */ return SRD_ERR; } /* Check whether 'py_conds' is a dict or a list. */ if (PyList_Check(py_conds)) { /* 'py_conds' is a list. */ py_conditionlist = py_conds; num_conditions = PyList_Size(py_conditionlist); if (num_conditions == 0) return 9999; /* The PD invoked self.wait([]). */ Py_IncRef(py_conditionlist); } else if (PyDict_Check(py_conds)) { /* 'py_conds' is a dict. */ if (PyDict_Size(py_conds) == 0) return 9999; /* The PD invoked self.wait({}). */ /* Make a list and put the dict in there for convenience. */ py_conditionlist = PyList_New(1); Py_IncRef(py_conds); PyList_SetItem(py_conditionlist, 0, py_conds); num_conditions = 1; } else { srd_err("Condition list is neither a list nor a dict."); return SRD_ERR; } /* Free the old condition list. */ condition_list_free(di); ret = SRD_OK; /* Iterate over the conditions, set di->condition_list accordingly. */ for (i = 0; i < num_conditions; i++) { /* Get a condition (dict) from the condition list. */ py_dict = PyList_GetItem(py_conditionlist, i); if (!PyDict_Check(py_dict)) { srd_err("Condition is not a dict."); ret = SRD_ERR; break; } /* Create the list of terms in this condition. */ if ((ret = create_term_list(py_dict, &term_list)) < 0) break; /* Add the new condition to the PD instance's condition list. */ di->condition_list = g_slist_append(di->condition_list, term_list); } Py_DecRef(py_conditionlist); return ret; }
/* Creates a new segments object * Returns a Python object if successful or NULL on error */ PyObject *pyvslvm_segments_new( pyvslvm_logical_volume_t *logical_volume_object, PyObject* (*get_segment_by_index)( pyvslvm_logical_volume_t *logical_volume_object, int segment_index ), int number_of_segments ) { pyvslvm_segments_t *pyvslvm_segments = NULL; static char *function = "pyvslvm_segments_new"; if( logical_volume_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid logical volume object.", function ); return( NULL ); } if( get_segment_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get segment by index function.", function ); return( NULL ); } /* Make sure the segments values are initialized */ pyvslvm_segments = PyObject_New( struct pyvslvm_segments, &pyvslvm_segments_type_object ); if( pyvslvm_segments == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize segments.", function ); goto on_error; } if( pyvslvm_segments_init( pyvslvm_segments ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize segments.", function ); goto on_error; } pyvslvm_segments->logical_volume_object = logical_volume_object; pyvslvm_segments->get_segment_by_index = get_segment_by_index; pyvslvm_segments->number_of_segments = number_of_segments; Py_IncRef( (PyObject *) pyvslvm_segments->logical_volume_object ); return( (PyObject *) pyvslvm_segments ); on_error: if( pyvslvm_segments != NULL ) { Py_DecRef( (PyObject *) pyvslvm_segments ); } return( NULL ); }
/* Creates a new cache directories object * Returns a Python object if successful or NULL on error */ PyObject *pymsiecf_cache_directories_new( PyObject *parent_object, PyObject* (*get_cache_directory_by_index)( PyObject *parent_object, int cache_directory_index ), int number_of_cache_directories ) { pymsiecf_cache_directories_t *pymsiecf_cache_directories = NULL; static char *function = "pymsiecf_cache_directories_new"; if( parent_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid parent object.", function ); return( NULL ); } if( get_cache_directory_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get cache directory by index function.", function ); return( NULL ); } /* Make sure the cache directories values are initialized */ pymsiecf_cache_directories = PyObject_New( struct pymsiecf_cache_directories, &pymsiecf_cache_directories_type_object ); if( pymsiecf_cache_directories == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize cache directories.", function ); goto on_error; } if( pymsiecf_cache_directories_init( pymsiecf_cache_directories ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize cache directories.", function ); goto on_error; } pymsiecf_cache_directories->parent_object = parent_object; pymsiecf_cache_directories->get_cache_directory_by_index = get_cache_directory_by_index; pymsiecf_cache_directories->number_of_cache_directories = number_of_cache_directories; Py_IncRef( (PyObject *) pymsiecf_cache_directories->parent_object ); return( (PyObject *) pymsiecf_cache_directories ); on_error: if( pymsiecf_cache_directories != NULL ) { Py_DecRef( (PyObject *) pymsiecf_cache_directories ); } return( NULL ); }
/* Open EWF file(s) * Returns a Python object if successful or NULL on error */ PyObject *pyewf_handle_open( pyewf_handle_t *pyewf_handle, PyObject *arguments, PyObject *keywords ) { char error_string[ PYEWF_ERROR_STRING_SIZE ]; libcerror_error_t *error = NULL; char **filenames = NULL; char *mode = NULL; static char *keyword_list[] = { "filenames", "mode", NULL }; PyObject *sequence_object = NULL; PyObject *string_object = NULL; static char *function = "pyewf_handle_open"; size_t filename_length = 0; int access_flags = 0; int filename_index = 0; int number_of_filenames = 0; int result = 0; if( pyewf_handle == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf handle.", function ); return( NULL ); } if( PyArg_ParseTupleAndKeywords( arguments, keywords, "O|s", keyword_list, &sequence_object, &mode ) == 0 ) { return( NULL ); } if( PySequence_Check( sequence_object ) == 0 ) { PyErr_Format( PyExc_TypeError, "%s: argument: files must be a sequence object.", function ); return( NULL ); } if( mode == NULL ) { access_flags = LIBEWF_OPEN_READ; } else if( mode[ 0 ] == 'r' ) { if( mode[ 1 ] == '+' ) { if( ( mode[ 2 ] == 0 ) || ( ( mode[ 2 ] == 'b' ) && ( mode[ 3 ] == 0 ) ) ) { access_flags = LIBEWF_OPEN_READ_WRITE; } } else if( ( mode[ 1 ] == 0 ) || ( ( mode[ 1 ] == 'b' ) && ( mode[ 2 ] == 0 ) ) ) { access_flags = LIBEWF_OPEN_READ; } } else if( mode[ 0 ] == 'w' ) { if( ( mode[ 1 ] == 0 ) || ( ( mode[ 1 ] == 'b' ) && ( mode[ 2 ] == 0 ) ) ) { access_flags = LIBEWF_OPEN_WRITE; } } else if( mode[ 0 ] == 'a' ) { if( ( mode[ 1 ] == 0 ) || ( ( mode[ 1 ] == 'b' ) && ( mode[ 2 ] == 0 ) ) ) { access_flags = LIBEWF_OPEN_WRITE_RESUME; } } if( access_flags == 0 ) { PyErr_Format( PyExc_ValueError, "%s: unsupported mode: %s.", function, mode ); return( NULL ); } number_of_filenames = PySequence_Size( sequence_object ); if( ( number_of_filenames <= 0 ) || ( number_of_filenames > (int) UINT16_MAX ) ) { PyErr_Format( PyExc_ValueError, "%s: invalid number of files.", function ); goto on_error; } filenames = (char **) PyMem_Malloc( sizeof( char * ) * number_of_filenames ); if( filenames == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to create filenames.", function ); goto on_error; } if( memory_set( filenames, 0, sizeof( char * ) * number_of_filenames ) == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to clear filenames.", function ); PyMem_Free( filenames ); return( NULL ); } for( filename_index = 0; filename_index < number_of_filenames; filename_index++ ) { string_object = PySequence_GetItem( sequence_object, filename_index ); filename_length = PyString_Size( string_object ); filenames[ filename_index ] = (char *) PyMem_Malloc( sizeof( char ) * ( filename_length + 1 ) ); if( filenames[ filename_index ] == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to create filename: %d.", function, filename_index ); goto on_error; } if( libcstring_narrow_string_copy( filenames[ filename_index ], PyString_AsString( string_object ), filename_length ) == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to set filename: %d.", function, filename_index ); goto on_error; } ( filenames[ filename_index ] )[ filename_length ] = 0; Py_DecRef( string_object ); } Py_BEGIN_ALLOW_THREADS result = libewf_handle_open( pyewf_handle->handle, filenames, number_of_filenames, access_flags, &error ); Py_END_ALLOW_THREADS if( result != 1 ) { if( libcerror_error_backtrace_sprint( error, error_string, PYEWF_ERROR_STRING_SIZE ) == -1 ) { PyErr_Format( PyExc_IOError, "%s: unable to open handle.", function ); } else { PyErr_Format( PyExc_IOError, "%s: unable to open handle.\n%s", function, error_string ); } libcerror_error_free( &error ); goto on_error; } for( filename_index = 0; filename_index < number_of_filenames; filename_index++ ) { PyMem_Free( filenames[ filename_index ] ); } PyMem_Free( filenames ); Py_IncRef( Py_None ); return( Py_None ); on_error: if( filenames != NULL ) { for( ; filename_index > 0; filename_index-- ) { PyMem_Free( filenames[ filename_index - 1 ] ); } PyMem_Free( filenames ); } return( NULL ); }
// -------------------------------------------------- // static PyObject *addData(PyObject *self, PyObject *args) { float f; long l; int sz; PyObj *p = (PyObj *)self; sz = (int)PyTuple_Size(args); bk3dlib::DataType dtype = p->p->GetDataType(); switch(dtype) { case bk3dlib::FLOAT32: case bk3dlib::FLOAT16: case bk3dlib::UNKNOWN: default: for(int i=0; i<sz; i++) { PyObject *po = PyTuple_GetItem(args, i); if(!po) { PyErr_SetString(PyExc_AttributeError, "Bad item"); return NULL; } // case of a Blender vector // We don't know the implementation so let's use attributes with names if(PyObject_HasAttrString(po, "x")) { PyObject *oComp = PyObject_GetAttrString(po, "x"); float fVal = (float)PyFloat_AsDouble(oComp); p->p->AddData(&fVal, 1); Py_DecRef(oComp); if(PyObject_HasAttrString(po, "y")) { oComp = PyObject_GetAttrString(po, "y"); fVal = (float)PyFloat_AsDouble(oComp); p->p->AddData(&fVal, 1); Py_DecRef(oComp); } if(PyObject_HasAttrString(po, "z")) { oComp = PyObject_GetAttrString(po, "z"); fVal = (float)PyFloat_AsDouble(oComp); p->p->AddData(&fVal, 1); Py_DecRef(oComp); } if(PyObject_HasAttrString(po, "w")) { oComp = PyObject_GetAttrString(po, "w"); fVal = (float)PyFloat_AsDouble(oComp); p->p->AddData(&fVal, 1); Py_DecRef(oComp); } } // case of a sub-list else if(PyList_Check(po)) { int lsz = (int)PyList_Size(po); for(int j=0; j<lsz; j++) { PyObject *plo = PyList_GetItem(po, j); // case of a sub-list if(PyList_Check(plo)) { int lsz2 = (int)PyList_Size(plo); for(int j=0; j<lsz2; j++) { PyObject *plo2 = PyList_GetItem(plo, j); int n = PyArg_Parse(plo2, "f", &f); if(n>0) p->p->AddData(&f, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } else { int n = PyArg_Parse(plo, "f", &f); if(n>0) p->p->AddData(&f, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } } else { int n = PyArg_Parse(po, "f", &f); if(n>0) p->p->AddData(&f, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } break; case bk3dlib::UINT32: case bk3dlib::UINT16: case bk3dlib::UINT8: for(int i=0; i<sz; i++) { PyObject *po = PyTuple_GetItem(args, i); if(!po) { PyErr_SetString(PyExc_AttributeError, "Problem with Item argument"); return NULL; } assert(po); // case of a sub-list if(PyList_Check(po)) { int lsz = (int)PyList_Size(po); for(int j=0; j<lsz; j++) { PyObject *plo = PyList_GetItem(po, j); // case of a sub-list if(PyList_Check(plo)) { int lsz2 = (int)PyList_Size(plo); for(int j=0; j<lsz2; j++) { PyObject *plo2 = PyList_GetItem(plo, j); int n = PyArg_Parse(plo2, "l", &l); if(n>0) p->p->AddData(&l, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } else { int n = PyArg_Parse(plo, "l", &l); if(n>0) p->p->AddData(&l, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } } else { int n = PyArg_Parse(po, "l", &l); if(n>0) p->p->AddData(&l, 1); else { PyErr_SetString(PyExc_AttributeError, "Couldn't add arg to buffer"); return NULL; } } } break; } Py_IncRef(Py_None); return Py_None; }
/** * Decode a chunk of samples. * * The calls to this function must provide the samples that shall be * used by the protocol decoder * - in the correct order ([...]5, 6, 4, 7, 8[...] is a bug), * - starting from sample zero (2, 3, 4, 5, 6[...] is a bug), * - consecutively, with no gaps (0, 1, 2, 4, 5[...] is a bug). * * The start- and end-sample numbers are absolute sample numbers (relative * to the start of the whole capture/file/stream), i.e. they are not relative * sample numbers within the chunk specified by 'inbuf' and 'inbuflen'. * * Correct example (4096 samples total, 4 chunks @ 1024 samples each): * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * srd_inst_decode(di, 1024, 2047, inbuf, 1024, 1); * srd_inst_decode(di, 2048, 3071, inbuf, 1024, 1); * srd_inst_decode(di, 3072, 4095, inbuf, 1024, 1); * * The chunk size ('inbuflen') can be arbitrary and can differ between calls. * * Correct example (4096 samples total, 7 chunks @ various samples each): * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * srd_inst_decode(di, 1024, 1123, inbuf, 100, 1); * srd_inst_decode(di, 1124, 1423, inbuf, 300, 1); * srd_inst_decode(di, 1424, 1642, inbuf, 219, 1); * srd_inst_decode(di, 1643, 2047, inbuf, 405, 1); * srd_inst_decode(di, 2048, 3071, inbuf, 1024, 1); * srd_inst_decode(di, 3072, 4095, inbuf, 1024, 1); * * INCORRECT example (4096 samples total, 4 chunks @ 1024 samples each, but * the start- and end-samplenumbers are not absolute): * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * srd_inst_decode(di, 0, 1023, inbuf, 1024, 1); * * @param di The decoder instance to call. Must not be NULL. * @param abs_start_samplenum The absolute starting sample number for the * buffer's sample set, relative to the start of capture. * @param abs_end_samplenum The absolute ending sample number for the * buffer's sample set, relative to the start of capture. * @param inbuf The buffer to decode. Must not be NULL. * @param inbuflen Length of the buffer. Must be > 0. * @param unitsize The number of bytes per sample. Must be > 0. * * @return SRD_OK upon success, a (negative) error code otherwise. * * @private */ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di, uint64_t abs_start_samplenum, uint64_t abs_end_samplenum, const uint8_t *inbuf, uint64_t inbuflen, uint64_t unitsize) { PyObject *py_res; srd_logic *logic; long apiver; /* Return an error upon unusable input. */ if (!di) { srd_dbg("empty decoder instance"); return SRD_ERR_ARG; } if (!inbuf) { srd_dbg("NULL buffer pointer"); return SRD_ERR_ARG; } if (inbuflen == 0) { srd_dbg("empty buffer"); return SRD_ERR_ARG; } if (unitsize == 0) { srd_dbg("unitsize 0"); return SRD_ERR_ARG; } di->data_unitsize = unitsize; srd_dbg("Decoding: abs start sample %" PRIu64 ", abs end sample %" PRIu64 " (%" PRIu64 " samples, %" PRIu64 " bytes, unitsize = " "%d), instance %s.", abs_start_samplenum, abs_end_samplenum, abs_end_samplenum - abs_start_samplenum, inbuflen, di->data_unitsize, di->inst_id); apiver = srd_decoder_apiver(di->decoder); if (apiver == 2) { /* * Create new srd_logic object. Each iteration around the PD's * loop will fill one sample into this object. */ logic = PyObject_New(srd_logic, (PyTypeObject *)srd_logic_type); Py_INCREF(logic); logic->di = (struct srd_decoder_inst *)di; logic->abs_start_samplenum = abs_start_samplenum; logic->itercnt = 0; logic->inbuf = (uint8_t *)inbuf; logic->inbuflen = inbuflen; logic->sample = PyList_New(2); Py_INCREF(logic->sample); Py_IncRef(di->py_inst); if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", "KKO", abs_start_samplenum, abs_end_samplenum, logic))) { srd_exception_catch("Protocol decoder instance %s", di->inst_id); return SRD_ERR_PYTHON; } Py_DecRef(py_res); } else { /* If this is the first call, start the worker thread. */ if (!di->thread_handle) di->thread_handle = g_thread_new("di_thread", di_thread, di); /* Push the new sample chunk to the worker thread. */ g_mutex_lock(&di->data_mutex); di->abs_start_samplenum = abs_start_samplenum; di->abs_end_samplenum = abs_end_samplenum; di->inbuf = inbuf; di->inbuflen = inbuflen; di->got_new_samples = TRUE; di->handled_all_samples = FALSE; /* Signal the thread that we have new data. */ g_cond_signal(&di->got_new_samples_cond); g_mutex_unlock(&di->data_mutex); /* When all samples in this chunk were handled, return. */ g_mutex_lock(&di->data_mutex); while (!di->handled_all_samples) g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex); g_mutex_unlock(&di->data_mutex); } return SRD_OK; }
/* Creates a new records object * Returns a Python object if successful or NULL on error */ PyObject *pyevtx_records_new( pyevtx_file_t *file_object, PyObject* (*get_record_by_index)( pyevtx_file_t *file_object, int record_index ), int number_of_records ) { pyevtx_records_t *pyevtx_records = NULL; static char *function = "pyevtx_records_new"; if( file_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid file object.", function ); return( NULL ); } if( get_record_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get record by index function.", function ); return( NULL ); } /* Make sure the records values are initialized */ pyevtx_records = PyObject_New( struct pyevtx_records, &pyevtx_records_type_object ); if( pyevtx_records == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize records.", function ); goto on_error; } if( pyevtx_records_init( pyevtx_records ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize records.", function ); goto on_error; } pyevtx_records->file_object = file_object; pyevtx_records->get_record_by_index = get_record_by_index; pyevtx_records->number_of_records = number_of_records; Py_IncRef( (PyObject *) pyevtx_records->file_object ); return( (PyObject *) pyevtx_records ); on_error: if( pyevtx_records != NULL ) { Py_DecRef( (PyObject *) pyevtx_records ); } return( NULL ); }
/* Initializes the pyewf module */ PyMODINIT_FUNC initpyewf( void ) { PyObject *module = NULL; PyTypeObject *file_entries_type_object = NULL; PyTypeObject *file_entry_type_object = NULL; PyTypeObject *handle_type_object = NULL; PyGILState_STATE gil_state = 0; /* Create the module * This function must be called before grabbing the GIL * otherwise the module will segfault on a version mismatch */ module = Py_InitModule3( "pyewf", pyewf_module_methods, "Python libewf module (pyewf)." ); PyEval_InitThreads(); gil_state = PyGILState_Ensure(); /* Setup the handle type object */ pyewf_handle_type_object.tp_new = PyType_GenericNew; if( PyType_Ready( &pyewf_handle_type_object ) < 0 ) { goto on_error; } Py_IncRef( (PyObject * ) &pyewf_handle_type_object ); handle_type_object = &pyewf_handle_type_object; PyModule_AddObject( module, "handle", (PyObject *) handle_type_object ); /* Setup the file entry type object */ pyewf_file_entry_type_object.tp_new = PyType_GenericNew; if( PyType_Ready( &pyewf_file_entry_type_object ) < 0 ) { goto on_error; } Py_IncRef( (PyObject *) &pyewf_file_entry_type_object ); file_entry_type_object = &pyewf_file_entry_type_object; PyModule_AddObject( module, "file_entry", (PyObject *) file_entry_type_object ); /* Setup the file entries type object */ pyewf_file_entries_type_object.tp_new = PyType_GenericNew; if( PyType_Ready( &pyewf_file_entries_type_object ) < 0 ) { goto on_error; } Py_IncRef( (PyObject *) &pyewf_file_entries_type_object ); file_entries_type_object = &pyewf_file_entries_type_object; PyModule_AddObject( module, "_file_entries", (PyObject *) file_entries_type_object ); on_error: PyGILState_Release( gil_state ); }
/** Convert a TValue from the Delphi RTTI system to a PyObject*. * \param V: The value to convert. * \return New reference to a converted object. * \throw EPyVclError if the conversion fails. */ PyObject* ToPyObject(const Rtti::TValue &V) { Rtti::TValue &Value = const_cast<Rtti::TValue&>(V); if(Value.IsEmpty) Py_RETURN_NONE; switch(Value.Kind) { case tkInteger: return ToPyObject(Value.AsInteger()); case tkUString: case tkString: case tkLString: case tkWString: return ToPyObject(Value.AsString()); case tkEnumeration: { if(AnsiString(Value.TypeInfo->Name) == "Boolean") return ToPyObject(static_cast<bool>(Value.AsOrdinal())); TRttiEnumerationType *Type = static_cast<TRttiEnumerationType*>(Context.GetType(Value.TypeInfo)); int Ordinal = Value.AsOrdinal(); if(Ordinal >= Type->MinValue && Ordinal <= Type->MaxValue) //GetEnumName() lacks range check return ToPyObject(GetEnumName(Value.TypeInfo, Ordinal)); return ToPyObject("0x" + IntToHex(Ordinal, 2)); } case tkClass: return VclObject_Create(Value.AsObject(), false); case tkSet: return ToPyObject(SetToString(Value.TypeInfo, *static_cast<int*>(Value.GetReferenceToRawData()), false)); case tkChar: return ToPyObject(Value.AsType<char>()); case tkWChar: return ToPyObject(Value.AsType<wchar_t>()); case tkFloat: return ToPyObject(Value.AsExtended()); case tkRecord: { void *Data = Value.GetReferenceToRawData(); TRttiType *Type = Context.GetType(Value.TypeInfo); DynamicArray<TRttiField*> Fields = Type->GetFields(); PyObject *Tuple = PyTuple_New(Fields.Length); for(int I = 0; I < Fields.Length; I++) PyTuple_SET_ITEM(Tuple, I, ToPyObject(Fields[I]->GetValue(Data))); return Tuple; } case tkMethod: //Event { TMethod Method; Value.ExtractRawDataNoCopy(&Method); if(Method.Code == NULL) Py_RETURN_NONE; TObject *Object = static_cast<TObject*>(Method.Data); if(TMethodImplementation *Impl = dynamic_cast<TMethodImplementation*>(Object)) { PyObject *Result = static_cast<PyObject*>(Impl->FUserData); Py_IncRef(Result); return Result; } String Name = Object->MethodName(Method.Code); TRttiType *Type = Context.GetType(Object->ClassType()); return VclMethod_Create(NULL, Object, Type->GetMethods(Name)); } case tkInt64: return PyLong_FromLongLong(Value.AsInt64()); case tkVariant: case tkArray: case tkInterface: case tkDynArray: case tkClassRef: case tkPointer: case tkProcedure: case tkUnknown: default: throw EPyVclError("Unable to convert type '" + AnsiString(Value.TypeInfo->Name) + "'"); } }
/* Sets the keys * Returns a Python object if successful or NULL on error */ PyObject *pycaes_tweaked_context_set_keys( pycaes_tweaked_context_t *pycaes_context, PyObject *arguments, PyObject *keywords ) { libcerror_error_t *error = NULL; PyObject *key_string_object = NULL; PyObject *tweak_key_string_object = NULL; static char *function = "pycaes_tweaked_context_set_key"; static char *keyword_list[] = { "mode", "key", "tweak_key", NULL }; char *key_data = NULL; char *tweak_key_data = NULL; Py_ssize_t key_data_size = 0; Py_ssize_t tweak_key_data_size = 0; int mode = 0; int result = 0; if( PyArg_ParseTupleAndKeywords( arguments, keywords, "iOO", keyword_list, &mode, &key_string_object, &tweak_key_string_object ) == 0 ) { return( NULL ); } #if PY_MAJOR_VERSION >= 3 key_data = PyBytes_AsString( key_string_object ); key_data_size = PyBytes_Size( key_string_object ); #else key_data = PyString_AsString( key_string_object ); key_data_size = PyString_Size( key_string_object ); #endif if( ( key_data_size < 0 ) || ( key_data_size > (Py_ssize_t) ( SSIZE_MAX / 8 ) ) ) { PyErr_Format( PyExc_ValueError, "%s: invalid argument key data size value out of bounds.", function ); return( NULL ); } #if PY_MAJOR_VERSION >= 3 tweak_key_data = PyBytes_AsString( tweak_key_string_object ); tweak_key_data_size = PyBytes_Size( tweak_key_string_object ); #else tweak_key_data = PyString_AsString( tweak_key_string_object ); tweak_key_data_size = PyString_Size( tweak_key_string_object ); #endif if( ( tweak_key_data_size < 0 ) || ( tweak_key_data_size > (Py_ssize_t) ( SSIZE_MAX / 8 ) ) ) { PyErr_Format( PyExc_ValueError, "%s: invalid argument tweak key data size value out of bounds.", function ); return( NULL ); } Py_BEGIN_ALLOW_THREADS result = libcaes_tweaked_context_set_keys( pycaes_context->context, mode, (uint8_t *) key_data, (size_t) ( key_data_size * 8 ), (uint8_t *) tweak_key_data, (size_t) ( tweak_key_data_size * 8 ), &error ); Py_END_ALLOW_THREADS if( result != 1 ) { pycaes_error_raise( error, PyExc_IOError, "%s: unable to set keys.", function ); libcerror_error_free( &error ); return( NULL ); } Py_IncRef( Py_None ); return( Py_None ); }
/** * Decode a chunk of samples. * * @param di The decoder instance to call. Must not be NULL. * @param start_samplenum The starting sample number for the buffer's sample * set, relative to the start of capture. * @param end_samplenum The ending sample number for the buffer's sample * set, relative to the start of capture. * @param inbuf The buffer to decode. Must not be NULL. * @param inbuflen Length of the buffer. Must be > 0. * @param unitsize The number of bytes per sample. Must be > 0. * * @return SRD_OK upon success, a (negative) error code otherwise. * * @private */ SRD_PRIV int srd_inst_decode(const struct srd_decoder_inst *di, uint64_t start_samplenum, uint64_t end_samplenum, const uint8_t *inbuf, uint64_t inbuflen, uint64_t unitsize) { PyObject *py_res; srd_logic *logic; long apiver; /* Return an error upon unusable input. */ if (!di) { srd_dbg("empty decoder instance"); return SRD_ERR_ARG; } if (!inbuf) { srd_dbg("NULL buffer pointer"); return SRD_ERR_ARG; } if (inbuflen == 0) { srd_dbg("empty buffer"); return SRD_ERR_ARG; } if (unitsize == 0) { srd_dbg("unitsize 0"); return SRD_ERR_ARG; } ((struct srd_decoder_inst *)di)->data_unitsize = unitsize; srd_dbg("Decoding: start sample %" PRIu64 ", end sample %" PRIu64 " (%" PRIu64 " samples, %" PRIu64 " bytes, unitsize = " "%d), instance %s.", start_samplenum, end_samplenum, end_samplenum - start_samplenum, inbuflen, di->data_unitsize, di->inst_id); apiver = srd_decoder_apiver(di->decoder); if (apiver == 2) { /* * Create new srd_logic object. Each iteration around the PD's * loop will fill one sample into this object. */ logic = PyObject_New(srd_logic, (PyTypeObject *)srd_logic_type); Py_INCREF(logic); logic->di = (struct srd_decoder_inst *)di; logic->start_samplenum = start_samplenum; logic->itercnt = 0; logic->inbuf = (uint8_t *)inbuf; logic->inbuflen = inbuflen; logic->sample = PyList_New(2); Py_INCREF(logic->sample); Py_IncRef(di->py_inst); if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", "KKO", start_samplenum, end_samplenum, logic))) { srd_exception_catch("Protocol decoder instance %s", di->inst_id); return SRD_ERR_PYTHON; } Py_DecRef(py_res); } return SRD_OK; }
PyObject* DetailView::loadDetail(PyObject *dict) { static QString nameFmt = "<span style=\" font-size:16pt; font-weight:600;\">%1</span> (rating: %2)"; if (!PyDict_Check(dict)) { PyErr_SetString(PyExc_TypeError, "The argument is not a dict."); return NULL; } PyObject *item; QString name; //name if (NULL != (item = PyDict_GetItemString(dict, "name"))) { name = PyString_AsQString(item); setWindowTitle(name + tr(" - Detail page")); } //rating if (NULL != (item = PyDict_GetItemString(dict, "rating"))) ui->nameLabel->setText(nameFmt.arg(name, QString::number(PyFloat_AsDouble(item)))); else ui->nameLabel->setText(nameFmt.arg(name, tr("Unknown"))); //length if (NULL != (item = PyDict_GetItemString(dict, "length"))) ui->lengthLabel->setText(PyString_AsQString(item)); else ui->lengthLabel->setText(tr("Unknown")); //summary if (NULL != (item = PyDict_GetItemString(dict, "summary"))) ui->summaryLabel->setText(PyString_AsQString(item)); else ui->summaryLabel->setText(tr("Unknown")); //others struct Item {const char *item_name; QLabel *label;}; struct Item items[] = { {"directors", ui->directorLabel}, {"script_writers", ui->scriptwriterLabel}, {"players", ui->playerLabel}, {"types", ui->typeLabel}, {"nations", ui->nationLabel}, {"languages", ui->langLabel}, {"dates", ui->dateLabel}, {"alt_names", ui->alternameLabel}, {NULL, NULL} }; for (struct Item *i = items; i->item_name; i++) { item = PyDict_GetItemString(dict, i->item_name); if (item) { QStringList list = PyList_AsQStringList(item); i->label->setText(list.join(" / ").simplified()); } else i->label->setText(tr("Unknown")); } // Source ui->sourceListWidget->clear(); urls.clear(); item = PyDict_GetItemString(dict, "source"); if (item) { int n = PyList_Size(item); for (int i = 0; i < n; i += 2) { QString name = PyString_AsQString(PyList_GetItem(item, i)); const char *url = PyString_AsString(PyList_GetItem(item, i+1)); ui->sourceListWidget->addItem(name); urls.append(url); } } // Image item = PyDict_GetItemString(dict, "image"); if (item) { QNetworkRequest request(QUrl(PyString_AsQString(item))); request.setRawHeader("User-Agent", "moonplayer"); reply = access_manager->get(request); connect(reply, SIGNAL(finished()), this, SLOT(onImageLoaded())); } Py_IncRef(Py_None); return Py_None; }
int API_resultRowValue(void *result, int column, UMTypeInfo *ti, char *value, size_t cbValue) { PyObject *valobj = NULL; PRINTMARK(); //fprintf (stderr, "%s: Got %p (%08x) %08x\n", __FUNCTION__, value, ti->type, cbValue); if (value == NULL) { valobj = Py_None; Py_IncRef(valobj); } else { switch (ti->type) { //PyNone: case MFTYPE_NULL: valobj = Py_None; Py_IncRef(valobj); break; // Use PyLong for "INT UNSIGNED". case MFTYPE_LONG: if(isUnsigned(ti->flags)){ // XXX: No overflow detected. valobj = PyLong_FromLongLong(parseINT64 (value, ((char *) value) + cbValue)); break; } // "INT" only, let it fall through to PyInt. //PyInt case MFTYPE_TINY: case MFTYPE_SHORT: case MFTYPE_INT24: { valobj = PyInt_FromLong(parseINT32 (value, ((char *) value) + cbValue)); break; } //PyLong case MFTYPE_LONGLONG: { if(isUnsigned(ti->flags)){ valobj = PyLong_FromUnsignedLongLong(parseUINT64 (value, ((char *) value) + cbValue)); }else{ valobj = PyLong_FromLongLong(parseINT64 (value, ((char *) value) + cbValue)); } break; } //PyFloat case MFTYPE_FLOAT: case MFTYPE_DOUBLE: { //FIXME: Too f*****g slow PyObject *sobj = PyString_FromStringAndSize((char *) value, cbValue); valobj = PyFloat_FromString (sobj, NULL); Py_DECREF(sobj); break; } case MFTYPE_DATE: { int year; int month; int day; year = parseINT32 (value, value + 4); if (year < 1) { valobj = Py_None; Py_IncRef(valobj); break; } value += 5; month = parseINT32 (value, value + 2); value += 3; day = parseINT32 (value, value + 2); value += 3; valobj = PyDate_FromDate (year, month, day); break; } case MFTYPE_TIMESTAMP: case MFTYPE_DATETIME: { int year; int month; int day; int hour; int minute; int second; //9999-12-31 23:59:59 char temp[20]; memcpy (temp, value, cbValue); temp[cbValue] = '\0'; year = parseINT32 (value, value + 4); value += 5; month = parseINT32 (value, value + 2); value += 3; day = parseINT32 (value, value + 2); value += 3; hour = parseINT32 (value, value + 2); value += 3; minute = parseINT32 (value, value + 2); value += 3; second = parseINT32 (value, value + 2); value += 3; if (year < 1) { valobj = Py_None; Py_IncRef(valobj); break; } valobj = PyDateTime_FromDateAndTime (year, month, day, hour, minute, second, 0); break; } // We ignore these case MFTYPE_TIME: case MFTYPE_YEAR: case MFTYPE_NEWDATE: // Fall through for string encoding //Blob goes as String case MFTYPE_TINY_BLOB: case MFTYPE_MEDIUM_BLOB: case MFTYPE_LONG_BLOB: case MFTYPE_BLOB: if (ti->flags & MFFLAG_BINARY_FLAG) { valobj = PyString_FromStringAndSize( (const char *) value, cbValue); } else { valobj = DecodeString (ti, value, cbValue); } break; //PyString family case MFTYPE_VAR_STRING: case MFTYPE_VARCHAR: case MFTYPE_STRING: valobj = DecodeString (ti, value, cbValue); break; case MFTYPE_ENUM: case MFTYPE_GEOMETRY: case MFTYPE_BIT: case MFTYPE_NEWDECIMAL: case MFTYPE_SET: case MFTYPE_DECIMAL: // Fall through for string encoding valobj = PyString_FromStringAndSize( (const char *) value, cbValue); break; } } if (valobj == NULL) { if (PyErr_Occurred()) { return FALSE; } PyErr_Format (umysql_Error, "Unable to convert field of type %d", ti->type); return FALSE; } PyTuple_SET_ITEM(((ResultSet *)result)->currRow, column, valobj); PRINTMARK(); return TRUE; }
/* Creates a new strings object * Returns a Python object if successful or NULL on error */ PyObject *pyevtx_strings_new( pyevtx_record_t *record_object, PyObject* (*get_string_by_index)( pyevtx_record_t *record_object, int string_index ), int number_of_strings ) { pyevtx_strings_t *pyevtx_strings = NULL; static char *function = "pyevtx_strings_new"; if( record_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid record object.", function ); return( NULL ); } if( get_string_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get string by index function.", function ); return( NULL ); } /* Make sure the strings values are initialized */ pyevtx_strings = PyObject_New( struct pyevtx_strings, &pyevtx_strings_type_object ); if( pyevtx_strings == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize strings.", function ); goto on_error; } if( pyevtx_strings_init( pyevtx_strings ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize strings.", function ); goto on_error; } pyevtx_strings->record_object = record_object; pyevtx_strings->get_string_by_index = get_string_by_index; pyevtx_strings->number_of_strings = number_of_strings; Py_IncRef( (PyObject *) pyevtx_strings->record_object ); return( (PyObject *) pyevtx_strings ); on_error: if( pyevtx_strings != NULL ) { Py_DecRef( (PyObject *) pyevtx_strings ); } return( NULL ); }
/* Creates a new blocks object * Returns a Python object if successful or NULL on error */ PyObject *pyvshadow_blocks_new( pyvshadow_store_t *store_object, PyObject* (*get_block_by_index)( pyvshadow_store_t *store_object, int block_index ), int number_of_blocks ) { pyvshadow_blocks_t *pyvshadow_blocks = NULL; static char *function = "pyvshadow_blocks_new"; if( store_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid store object.", function ); return( NULL ); } if( get_block_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get block by index function.", function ); return( NULL ); } /* Make sure the blocks values are initialized */ pyvshadow_blocks = PyObject_New( struct pyvshadow_blocks, &pyvshadow_blocks_type_object ); if( pyvshadow_blocks == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize blocks.", function ); goto on_error; } if( pyvshadow_blocks_init( pyvshadow_blocks ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize blocks.", function ); goto on_error; } pyvshadow_blocks->store_object = store_object; pyvshadow_blocks->get_block_by_index = get_block_by_index; pyvshadow_blocks->number_of_blocks = number_of_blocks; Py_IncRef( (PyObject *) pyvshadow_blocks->store_object ); return( (PyObject *) pyvshadow_blocks ); on_error: if( pyvshadow_blocks != NULL ) { Py_DecRef( (PyObject *) pyvshadow_blocks ); } return( NULL ); }
/* Seeks a certain offset in the media data * Returns a Python object holding the offset if successful or NULL on error */ PyObject *pyewf_handle_seek_offset( pyewf_handle_t *pyewf_handle, PyObject *arguments, PyObject *keywords ) { char error_string[ PYEWF_ERROR_STRING_SIZE ]; libcerror_error_t *error = NULL; static char *function = "pyewf_handle_seek_offset"; static char *keyword_list[] = { "offset", "whence", NULL }; off64_t offset = 0; int whence = 0; if( pyewf_handle == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf handle.", function ); return( NULL ); } if( PyArg_ParseTupleAndKeywords( arguments, keywords, "L|i", keyword_list, &offset, &whence ) == 0 ) { return( NULL ); } Py_BEGIN_ALLOW_THREADS offset = libewf_handle_seek_offset( pyewf_handle->handle, offset, whence, &error ); Py_END_ALLOW_THREADS if( offset == -1 ) { if( libcerror_error_backtrace_sprint( error, error_string, PYEWF_ERROR_STRING_SIZE ) == -1 ) { PyErr_Format( PyExc_IOError, "%s: unable to seek offset.", function ); } else { PyErr_Format( PyExc_IOError, "%s: unable to seek offset.\n%s", function, error_string ); } libcerror_error_free( &error ); return( NULL ); } Py_IncRef( Py_None ); return( Py_None ); }
/* Creates a new file entries object * Returns a Python object if successful or NULL on error */ PyObject *pyewf_file_entries_new( pyewf_file_entry_t *file_entry_object, PyObject* (*get_sub_file_entry_by_index)( pyewf_file_entry_t *file_entry_object, int sub_file_entry_index ), int number_of_sub_file_entries ) { pyewf_file_entries_t *pyewf_file_entries = NULL; static char *function = "pyewf_file_entries_new"; if( file_entry_object == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid file enry object.", function ); return( NULL ); } if( get_sub_file_entry_by_index == NULL ) { PyErr_Format( PyExc_ValueError, "%s: invalid get sub file entry by index function.", function ); return( NULL ); } /* Make sure the file entries values are initialized */ pyewf_file_entries = PyObject_New( struct pyewf_file_entries, &pyewf_file_entries_type_object ); if( pyewf_file_entries == NULL ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize file entries.", function ); goto on_error; } if( pyewf_file_entries_init( pyewf_file_entries ) != 0 ) { PyErr_Format( PyExc_MemoryError, "%s: unable to initialize file entries.", function ); goto on_error; } pyewf_file_entries->file_entry_object = file_entry_object; pyewf_file_entries->get_sub_file_entry_by_index = get_sub_file_entry_by_index; pyewf_file_entries->number_of_sub_file_entries = number_of_sub_file_entries; Py_IncRef( (PyObject *) pyewf_file_entries->file_entry_object ); return( (PyObject *) pyewf_file_entries ); on_error: if( pyewf_file_entries != NULL ) { Py_DecRef( (PyObject *) pyewf_file_entries ); } return( NULL ); }
/* Retrieves the name * Returns a Python object if successful or NULL on error */ PyObject *pyewf_file_entry_get_name( pyewf_file_entry_t *pyewf_file_entry ) { char error_string[ PYEWF_ERROR_STRING_SIZE ]; libcerror_error_t *error = NULL; PyObject *string_object = NULL; const char *errors = NULL; uint8_t *name = NULL; static char *function = "pyewf_file_entry_get_name"; size_t name_size = 0; int result = 0; if( pyewf_file_entry == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid file entry.", function ); return( NULL ); } Py_BEGIN_ALLOW_THREADS result = libewf_file_entry_get_utf8_name_size( pyewf_file_entry->file_entry, &name_size, &error ); Py_END_ALLOW_THREADS if( result == -1 ) { if( libcerror_error_backtrace_sprint( error, error_string, PYEWF_ERROR_STRING_SIZE ) == -1 ) { PyErr_Format( PyExc_IOError, "%s: unable to retrieve name size.", function ); } else { PyErr_Format( PyExc_IOError, "%s: unable to retrieve name size.\n%s", function, error_string ); } libcerror_error_free( &error ); goto on_error; } else if( ( result == 0 ) || ( name_size == 0 ) ) { Py_IncRef( Py_None ); return( Py_None ); } name = (uint8_t *) PyMem_Malloc( sizeof( uint8_t ) * name_size ); if( name == NULL ) { PyErr_Format( PyExc_IOError, "%s: unable to create name.", function ); goto on_error; } Py_BEGIN_ALLOW_THREADS result = libewf_file_entry_get_utf8_name( pyewf_file_entry->file_entry, name, name_size, &error ); Py_END_ALLOW_THREADS if( result != 1 ) { if( libcerror_error_backtrace_sprint( error, error_string, PYEWF_ERROR_STRING_SIZE ) == -1 ) { PyErr_Format( PyExc_IOError, "%s: unable to retrieve name.", function ); } else { PyErr_Format( PyExc_IOError, "%s: unable to retrieve name.\n%s", function, error_string ); } libcerror_error_free( &error ); goto on_error; } /* Pass the string length to PyUnicode_DecodeUTF8 * otherwise it makes the end of string character is part * of the string */ string_object = PyUnicode_DecodeUTF8( (char *) name, (Py_ssize_t) name_size - 1, errors ); PyMem_Free( name ); return( string_object ); on_error: if( name != NULL ) { PyMem_Free( name ); } return( NULL ); }