static void GetKSDATARANGE(IXMLDOMElement* e,KSDATARANGE& v)
{
HRESULT hr;
_variant_t var;
hr = e->getAttribute(_bstr_t(L"FormatSize"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.FormatSize = (unsigned long)var;
var.Clear();
hr = e->getAttribute(_bstr_t(L"Flags"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.Flags = (unsigned long)var;
var.Clear();
hr = e->getAttribute(_bstr_t(L"SampleSize"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.SampleSize = (unsigned long)var;
var.Clear();
hr = e->getAttribute(_bstr_t(L"Reserved"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.Reserved = (unsigned long)var;
var.Clear();
hr = e->getAttribute(_bstr_t(L"MajorFormat"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&v.MajorFormat);
var.Clear();
hr = e->getAttribute(_bstr_t(L"SubFormat"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&v.SubFormat);
var.Clear();
hr = e->getAttribute(_bstr_t(L"Specifier"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&v.Specifier);
var.Clear();
}
static void
col_ref_cb (QofInstance* ref_ent, gpointer user_data)
{
QofInstanceReference *ref;
QofInstanceCopyData *qecd;
QofInstance *ent;
const GncGUID *cm_guid;
char cm_sa[GUID_ENCODING_LENGTH + 1];
gchar *cm_string;
g_return_if_fail(user_data);
qecd = (QofInstanceCopyData*)user_data;
ent = qecd->from;
g_return_if_fail(ent);
ref = g_new0(QofInstanceReference, 1);
ref->type = ent->e_type;
ref->ref_guid = g_new(GncGUID, 1);
ref->ent_guid = qof_instance_get_guid(ent);
ref->param = qof_class_get_parameter(ent->e_type,
qecd->param->param_name);
cm_guid = qof_entity_get_guid(ref_ent);
guid_to_string_buff(cm_guid, cm_sa);
cm_string = g_strdup(cm_sa);
if (TRUE == string_to_guid(cm_string, ref->ref_guid))
{
g_free(cm_string);
qof_session_update_reference_list(qecd->new_session, ref);
}
}
static void GetGUIDs(IXMLDOMElement* e, std::vector<GUID>& v)
{
HRESULT hr;
IXMLDOMNodeListPtr children;
long listlength;
hr = e->get_childNodes(&children);
if(hr!=S_OK) throw _com_error(hr);
hr = children->get_length(&listlength);
if(hr!=S_OK) throw _com_error(hr);
for(size_t n=0;n<listlength;n++)
{
IXMLDOMElementPtr item;
IXMLDOMNodePtr itemnode;
_variant_t var;
GUID guid;
hr = children->get_item(n,&itemnode);
if(hr!=S_OK) throw _com_error(hr);
item = itemnode;
hr = item->getAttribute(_bstr_t(L"name"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&guid);
v.push_back(guid);
}
}
bool
generic_guid_end_handler(gpointer data_for_children,
GSList *data_from_children, GSList *sibling_data,
gpointer parent_data, gpointer global_data,
gpointer *result, const gchar *tag)
{
gchar *txt = NULL;
GncGUID *gid;
bool ok;
txt = concatenate_child_result_chars(data_from_children);
g_return_val_if_fail(txt, FALSE);
gid = g_new(GncGUID, 1);
if (!gid)
{
g_free(txt);
return(FALSE);
}
ok = string_to_guid(txt, gid);
g_free(txt);
if (!ok)
{
PERR ("couldn't parse GncGUID");
g_free(gid);
return(FALSE);
}
*result = gid;
return(TRUE);
}
/********************************************************************
* update_report_list
*
* this procedure does the real work of displaying a sorted list of
* available custom reports
********************************************************************/
static void
update_report_list(GtkListStore *store, CustomReportDialog *crd)
{
SCM get_rpt_guids = scm_c_eval_string("gnc:custom-report-template-guids");
SCM template_menu_name = scm_c_eval_string("gnc:report-template-menu-name/report-guid");
SCM rpt_guids;
int i;
GtkTreeIter iter;
GtkTreeModel *model = GTK_TREE_MODEL (store);
gboolean valid_iter;
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_NAME, GTK_SORT_ASCENDING);
crd->reportlist = scm_call_0(get_rpt_guids);
rpt_guids = crd->reportlist;
/* Empty current liststore */
valid_iter = gtk_tree_model_get_iter_first (model, &iter);
while (valid_iter)
{
GValue value = { 0, };
GncGUID *row_guid;
g_value_init ( &value, G_TYPE_POINTER);
gtk_tree_model_get_value (model, &iter, COL_NUM, &value);
row_guid = (GncGUID *) g_value_get_pointer (&value);
guid_free (row_guid);
g_value_unset (&value);
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
gtk_list_store_clear(store);
if (scm_is_list(rpt_guids))
{
/* for all the report guids in the list, store them, with a reference,
in the gtkliststore */
for (i = 0; !scm_is_null(rpt_guids); i++)
{
GncGUID *guid = guid_malloc ();
gchar *guid_str = scm_to_utf8_string (SCM_CAR(rpt_guids));
gchar *name = gnc_scm_to_utf8_string (scm_call_2(template_menu_name, SCM_CAR(rpt_guids), SCM_BOOL_F));
if (string_to_guid (guid_str, guid))
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
COL_NAME, name,
COL_NUM, guid,
-1);
}
g_free (name);
g_free (guid_str);
rpt_guids = SCM_CDR(rpt_guids);
}
}
}
/***********************************************************
* gnc_ui_custom_report_edit_name
*
* open the custom report dialog and highlight the given
* report's name for editing.
***********************************************************/
void
gnc_ui_custom_report_edit_name (GncMainWindow * window, SCM scm_guid)
{
SCM is_custom_report;
CustomReportDialog *crd = gnc_ui_custom_report_internal (window);
GtkTreeModel *model;
GtkTreeIter iter;
GncGUID *guid;
gchar *guid_str;
gboolean valid_iter;
is_custom_report = scm_c_eval_string ("gnc:report-template-is-custom/template-guid?");
if (scm_is_false (scm_call_1 (is_custom_report, scm_guid)))
return;
guid = guid_malloc ();
guid_str = scm_to_utf8_string (scm_guid);
if (!string_to_guid (guid_str, guid))
goto cleanup;
/* Look up the row for the requested guid */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (crd->reportview));
valid_iter = gtk_tree_model_get_iter_first (model, &iter);
while (valid_iter)
{
GValue value = { 0, };
GncGUID *row_guid;
gtk_tree_model_get_value (model, &iter, COL_NUM, &value);
row_guid = (GncGUID *) g_value_get_pointer (&value);
if (guid_equal (guid, row_guid))
{
/* We found the row for the requested guid
* Now let's set the report's name cell in edit mode
* so the user can edit the name.
*/
GtkTreePath *path;
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (crd->reportview));
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
g_object_set(G_OBJECT(crd->namerenderer), "editable", TRUE, NULL);
gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (crd->reportview),
path, crd->namecol,
crd->namerenderer, TRUE);
break;
}
g_value_unset (&value);
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
cleanup:
guid_free (guid);
}
/* ----------------------------------------------------------------- */
static void
load_tx_guid( const GncSqlBackend* be, GncSqlRow* row,
/*@ null @*/ QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
Transaction* tx;
const gchar* guid_str;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
val = gnc_sql_row_get_value_at_col_name( row, table_row->col_name );
g_assert( val != NULL );
guid_str = g_value_get_string(val);
if ( guid_str != NULL )
{
(void)string_to_guid( guid_str, &guid );
tx = xaccTransLookup( &guid, be->book );
// If the transaction is not found, try loading it
if ( tx == NULL )
{
gchar* buf;
GncSqlStatement* stmt;
buf = g_strdup_printf( "SELECT * FROM %s WHERE guid='%s'",
TRANSACTION_TABLE, guid_str );
stmt = gnc_sql_create_statement_from_sql( (GncSqlBackend*)be, buf );
g_free( buf );
query_transactions( (GncSqlBackend*)be, stmt );
tx = xaccTransLookup( &guid, be->book );
}
if ( tx != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
qof_instance_increase_editlevel (pObject);
g_object_set( pObject, table_row->gobj_param_name, tx, NULL );
qof_instance_decrease_editlevel (pObject);
}
else
{
g_return_if_fail( setter != NULL );
(*setter)( pObject, (const gpointer)tx );
}
}
}
}
gboolean
gnc_sql_slots_delete( GncSqlBackend* be, const GncGUID* guid )
{
gchar* buf;
GncSqlResult* result;
gchar guid_buf[GUID_ENCODING_LENGTH + 1];
GncSqlStatement* stmt;
slot_info_t slot_info = { NULL, NULL, TRUE, NULL, 0, NULL, FRAME, NULL, g_string_new('\0') };
g_return_val_if_fail( be != NULL, FALSE );
g_return_val_if_fail( guid != NULL, FALSE );
(void)guid_to_string_buff( guid, guid_buf );
buf = g_strdup_printf( "SELECT * FROM %s WHERE obj_guid='%s' and slot_type in ('%d', '%d') and not guid_val is null",
TABLE_NAME, guid_buf, KVP_TYPE_FRAME, KVP_TYPE_GLIST );
stmt = gnc_sql_create_statement_from_sql( be, buf );
g_free( buf );
if ( stmt != NULL )
{
result = gnc_sql_execute_select_statement( be, stmt );
gnc_sql_statement_dispose( stmt );
if ( result != NULL )
{
GncSqlRow* row = gnc_sql_result_get_first_row( result );
while ( row != NULL )
{
GncSqlColumnTableEntry table_row = col_table[guid_val_col];
GncGUID child_guid;
const GValue* val =
gnc_sql_row_get_value_at_col_name( row, table_row.col_name);
if ( val == NULL )
continue;
(void)string_to_guid( g_value_get_string( val ), &child_guid );
gnc_sql_slots_delete( be, &child_guid );
row = gnc_sql_result_get_next_row( result );
}
gnc_sql_result_dispose( result );
}
}
slot_info.be = be;
slot_info.guid = guid;
slot_info.is_ok = TRUE;
slot_info.is_ok = gnc_sql_do_db_operation( be, OP_DB_DELETE, TABLE_NAME,
TABLE_NAME, &slot_info, obj_guid_col_table );
return slot_info.is_ok;
}
/** Select the row in the tree that was selected when the user last
* quit gnucash. Its job is to map from owner name to tree row and
* select the row.
*
* @param tree A pointer to the GncTreeViewOwner embedded.
*
* @param owner_name A pointer to the full owner name. */
static void
tree_restore_selected_row (GncTreeViewOwner *view,
GncOwnerType owner_type,
const gchar *owner_guid_str)
{
GncOwner *owner = gncOwnerNew();
QofBook *book;
GncGUID owner_guid;
book = qof_session_get_book (gnc_get_current_session());
if (string_to_guid (owner_guid_str, &owner_guid))
if (gncOwnerGetOwnerFromTypeGuid (book, owner, gncOwnerTypeToQofIdType(owner_type), &owner_guid))
gnc_tree_view_owner_set_selected_owner(view, owner);
}
static void GetBDANodeDescriptors(IXMLDOMElement* e,std::vector<BDANODE_DESCRIPTOR>& v)
{
HRESULT hr;
IXMLDOMNodeListPtr children;
long listlength;
hr = e->get_childNodes(&children);
if(hr!=S_OK) throw _com_error(hr);
hr = children->get_length(&listlength);
if(hr!=S_OK) throw _com_error(hr);
for(size_t n=0;n<listlength;n++)
{
IXMLDOMElementPtr item;
IXMLDOMNodePtr itemnode;
_variant_t var;
BDANODE_DESCRIPTOR con;
hr = children->get_item(n,&itemnode);
if(hr!=S_OK) throw _com_error(hr);
item = itemnode;
hr = item->getAttribute(_bstr_t(L"ulBdaNodeType"),&var);
if(hr!=S_OK) throw _com_error(hr);
con.ulBdaNodeType = (unsigned long)var;
var.Clear();
hr = item->getAttribute(_bstr_t(L"guidFunction"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&con.guidFunction);
var.Clear();
hr = item->getAttribute(_bstr_t(L"guidName"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&con.guidName);
var.Clear();
}
}
gboolean
gnc_sql_slots_delete (GncSqlBackend* sql_be, const GncGUID* guid)
{
gchar* buf;
gchar guid_buf[GUID_ENCODING_LENGTH + 1];
slot_info_t slot_info = { NULL, NULL, TRUE, NULL, KvpValue::Type::INVALID,
NULL, FRAME, NULL, "" };
g_return_val_if_fail (sql_be != NULL, FALSE);
g_return_val_if_fail (guid != NULL, FALSE);
(void)guid_to_string_buff (guid, guid_buf);
buf = g_strdup_printf ("SELECT * FROM %s WHERE obj_guid='%s' and slot_type in ('%d', '%d') and not guid_val is null",
TABLE_NAME, guid_buf, KvpValue::Type::FRAME, KvpValue::Type::GLIST);
auto stmt = sql_be->create_statement_from_sql(buf);
g_free (buf);
if (stmt != nullptr)
{
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
{
try
{
const GncSqlColumnTableEntryPtr table_row =
col_table[guid_val_col];
GncGUID child_guid;
auto val = row.get_string_at_col (table_row->name());
(void)string_to_guid (val.c_str(), &child_guid);
gnc_sql_slots_delete (sql_be, &child_guid);
}
catch (std::invalid_argument)
{
continue;
}
}
}
slot_info.be = sql_be;
slot_info.guid = guid;
slot_info.is_ok = TRUE;
slot_info.is_ok = sql_be->do_db_operation(OP_DB_DELETE, TABLE_NAME,
TABLE_NAME, &slot_info,
obj_guid_col_table);
return slot_info.is_ok;
}
static gboolean
have_session (const char *session_auth_string)
{
GncGUID guid;
GList *next = logged_in_users;
string_to_guid (session_auth_string, &guid);
while (next)
{
if (guid_equal (&guid, next->data)) return TRUE;
next = next->next;
}
/* guid was not found */
return FALSE;
}
static void
gnc_string_to_guid (const GValue *src, GValue *dest)
{
/* FIXME: add more checks*/
GncGUID *guid;
const gchar *as_string;
g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
GNC_VALUE_HOLDS_GUID (dest));
as_string = g_value_get_string (src);
guid = g_new0 (GncGUID, 1);
string_to_guid(as_string, guid);
g_value_take_boxed (dest, guid);
}
static void GetKSIDENTIFIER(IXMLDOMElement* e,KSIDENTIFIER& v)
{
HRESULT hr;
_variant_t var;
hr = e->getAttribute(_bstr_t(L"Set"),&var);
if(hr!=S_OK) throw _com_error(hr);
string_to_guid((LPCWSTR)(_bstr_t)var,&v.Set);
var.Clear();
hr = e->getAttribute(_bstr_t(L"Id"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.Id = (unsigned long)var;
var.Clear();
hr = e->getAttribute(_bstr_t(L"Flags"),&var);
if(hr!=S_OK) throw _com_error(hr);
v.Flags = (unsigned long)var;
var.Clear();
}
/* ================================================================= */
static void
load_account_guid (const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row)
{
const GValue* val;
GncGUID guid;
Account* account = NULL;
g_return_if_fail (be != NULL);
g_return_if_fail (row != NULL);
g_return_if_fail (pObject != NULL);
g_return_if_fail (table_row != NULL);
val = gnc_sql_row_get_value_at_col_name (row, table_row->col_name);
if (val != NULL && G_VALUE_HOLDS_STRING (val) &&
g_value_get_string (val) != NULL)
{
(void)string_to_guid (g_value_get_string (val), &guid);
account = xaccAccountLookup (&guid, be->book);
if (account != NULL)
{
if (table_row->gobj_param_name != NULL)
{
qof_instance_increase_editlevel (pObject);
g_object_set (pObject, table_row->gobj_param_name, account, NULL);
qof_instance_decrease_editlevel (pObject);
}
else
{
g_return_if_fail (setter != NULL);
(*setter) (pObject, (const gpointer)account);
}
}
else
{
PWARN ("Account ref '%s' not found", g_value_get_string (val));
}
}
}
FirewireChannel::FirewireChannel(TVRec *parent, const QString &_videodevice,
const FireWireDBOptions &firewire_opts) :
DTVChannel(parent),
videodevice(_videodevice),
fw_opts(firewire_opts),
device(NULL),
current_channel(0),
isopen(false)
{
uint64_t guid = string_to_guid(videodevice);
uint subunitid = 0; // we only support first tuner on STB...
#ifdef USING_LINUX_FIREWIRE
device = new LinuxFirewireDevice(
guid, subunitid, fw_opts.speed,
LinuxFirewireDevice::kConnectionP2P == (uint) fw_opts.connection);
#endif // USING_LINUX_FIREWIRE
#ifdef USING_OSX_FIREWIRE
device = new DarwinFirewireDevice(guid, subunitid, fw_opts.speed);
#endif // USING_OSX_FIREWIRE
}
/* ================================================================= */
static void
load_billterm_guid (const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row)
{
const GValue* val;
GncGUID guid;
GncBillTerm* term = NULL;
g_return_if_fail (be != NULL);
g_return_if_fail (row != NULL);
g_return_if_fail (pObject != NULL);
g_return_if_fail (table_row != NULL);
val = gnc_sql_row_get_value_at_col_name (row, table_row->col_name);
if (val != NULL && G_VALUE_HOLDS_STRING (val) &&
g_value_get_string (val) != NULL)
{
string_to_guid (g_value_get_string (val), &guid);
term = gncBillTermLookup (be->book, &guid);
if (term != NULL)
{
if (table_row->gobj_param_name != NULL)
{
qof_instance_increase_editlevel (pObject);
g_object_set (pObject, table_row->gobj_param_name, term, NULL);
qof_instance_decrease_editlevel (pObject);
}
else
{
(*setter) (pObject, (const gpointer)term);
}
}
else
{
PWARN ("Billterm ref '%s' not found", g_value_get_string (val));
}
}
}
static void
load_commodity_guid( const GncSqlBackend* be, GncSqlRow* row,
/*@ null @*/ QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
gnc_commodity* commodity = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
val = gnc_sql_row_get_value_at_col_name( row, table_row->col_name );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
(void)string_to_guid( g_value_get_string( val ), &guid );
commodity = gnc_commodity_find_commodity_by_guid( &guid, be->book );
if ( commodity != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
qof_instance_increase_editlevel (pObject);
g_object_set( pObject, table_row->gobj_param_name, commodity, NULL );
qof_instance_decrease_editlevel (pObject);
}
else if ( setter != NULL )
{
(*setter)( pObject, (const gpointer)commodity );
}
}
else
{
PWARN( "Commodity ref '%s' not found", g_value_get_string( val ) );
}
}
}
static gboolean
validate_type(const char *url_type, const char *location,
const char *entity_type, GNCURLResult *result,
GncGUID *guid, QofInstance **entity)
{
QofCollection *col;
QofBook * book = gnc_get_current_book();
if (!string_to_guid (location + strlen(url_type), guid))
{
result->error_message = g_strdup_printf (_("Bad URL: %s"), location);
return FALSE;
}
col = qof_book_get_collection (book, entity_type);
*entity = qof_collection_lookup_entity (col, guid);
if (NULL == *entity)
{
result->error_message = g_strdup_printf (_("Entity Not Found: %s"),
location);
return FALSE;
}
return TRUE;
}
/* ================================================================= */
static void
load_lot_guid( const GncSqlBackend* be, GncSqlRow* row,
/*@ null @*/ QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
GNCLot* lot;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
val = gnc_sql_row_get_value_at_col_name( row, table_row->col_name );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
(void)string_to_guid( g_value_get_string( val ), &guid );
lot = gnc_lot_lookup( &guid, be->book );
if ( lot != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, lot, NULL );
}
else
{
g_return_if_fail( setter != NULL );
(*setter)( pObject, (const gpointer)lot );
}
}
else
{
PWARN( "Lot ref '%s' not found", g_value_get_string( val ) );
}
}
}
/* ================================================================= */
static void
load_taxtable_guid( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
GncTaxTable* taxtable = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
val = gnc_sql_row_get_value_at_col_name( row, table_row->col_name );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
string_to_guid( g_value_get_string( val ), &guid );
taxtable = gncTaxTableLookup( be->primary_book, &guid );
if ( taxtable != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, taxtable, NULL );
}
else
{
(*setter)( pObject, (const gpointer)taxtable );
}
}
else
{
PWARN( "Taxtable ref '%s' not found", g_value_get_string( val ) );
}
}
}
static void GetPininfos(IXMLDOMElement* e,std::vector<PININFO>& v)
{
HRESULT hr;
IXMLDOMNodeListPtr children;
long listlength;
hr = e->get_childNodes(&children);
if(hr!=S_OK) throw _com_error(hr);
hr = children->get_length(&listlength);
if(hr!=S_OK) throw _com_error(hr);
for(size_t n=0;n<listlength;n++)
{
IXMLDOMElementPtr item, item2;
IXMLDOMNodePtr itemnode, itemnode2;
_variant_t var;
PININFO pininfo;
hr = children->get_item(n,&itemnode);
if(hr!=S_OK) throw _com_error(hr);
item = itemnode;
hr = item->getAttribute(_bstr_t(L"ksproperty_pin_category"),&var);
if(hr==S_OK)
{
string_to_guid((LPCWSTR)(_bstr_t)var,&pininfo.category);
pininfo.category_valid = true;
var.Clear();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_cinstances"),&itemnode2);
if(hr==S_OK)
{
item2 = itemnode2;
hr = item2->getAttribute(_bstr_t(L"PossibleCount"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.cinstances.PossibleCount = (unsigned long)var;
var.Clear();
hr = item2->getAttribute(_bstr_t(L"CurrentCount"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.cinstances.CurrentCount = (unsigned long)var;
var.Clear();
pininfo.cinstances_valid = true;
itemnode2.Release();
item2.Release();
}
hr = item->getAttribute(_bstr_t(L"ksproperty_pin_communication"),&var);
if(hr==S_OK)
{
pininfo.communication = (KSPIN_COMMUNICATION)(unsigned long)var;
pininfo.communication_valid = true;
var.Clear();
}
hr = item->getAttribute(_bstr_t(L"ksproperty_pin_dataflow"),&var);
if(hr==S_OK)
{
pininfo.dataflow = (KSPIN_DATAFLOW)(unsigned long)var;
pininfo.dataflow_valid = true;
var.Clear();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_dataintersection"),&itemnode2);
if(hr == S_OK)
{
item2 = itemnode2;
GetKSDATARANGE(item2,pininfo.dataintersection);
pininfo.dataintersection_valid = true;
itemnode2.Release();
item2.Release();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_dataranges"),&itemnode2);
if(hr==S_OK)
{
IXMLDOMNodeListPtr children2;
long listlength2;
item2 = itemnode2;
hr = item2->get_childNodes(&children2);
if(hr!=S_OK) throw _com_error(hr);
hr = children2->get_length(&listlength2);
if(hr!=S_OK) throw _com_error(hr);
for(size_t m=0;m<listlength2;m++)
{
IXMLDOMElementPtr item3;
IXMLDOMNodePtr itemnode3;
KSDATARANGE ksdatarange;
hr = children2->get_item(m, &itemnode3);
if(hr!=S_OK) throw _com_error(hr);
item3 = itemnode3;
GetKSDATARANGE(item3,ksdatarange);
pininfo.dataranges.push_back(ksdatarange);
}
item2.Release();
itemnode2.Release();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_globalcinstances"),&itemnode2);
if(hr==S_OK)
{
item2 = itemnode2;
hr = item2->getAttribute(_bstr_t(L"PossibleCount"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.globalcinstances.PossibleCount = (unsigned long)var;
var.Clear();
hr = item2->getAttribute(_bstr_t(L"CurrentCount"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.globalcinstances.CurrentCount = (unsigned long)var;
var.Clear();
pininfo.globalcinstances_valid = true;
itemnode2.Release();
item2.Release();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_interfaces"),&itemnode2);
if(hr==S_OK)
{
IXMLDOMNodeListPtr children2;
long listlength2;
item2 = itemnode2;
hr = item2->get_childNodes(&children2);
if(hr!=S_OK) throw _com_error(hr);
hr = children2->get_length(&listlength2);
if(hr!=S_OK) throw _com_error(hr);
for(size_t m=0;m<listlength2;m++)
{
IXMLDOMElementPtr item3;
IXMLDOMNodePtr itemnode3;
KSIDENTIFIER ksidentifier;
hr = children2->get_item(m, &itemnode3);
if(hr!=S_OK) throw _com_error(hr);
item3 = itemnode3;
GetKSIDENTIFIER(item3,ksidentifier);
pininfo.interfaces.push_back(ksidentifier);
}
itemnode2.Release();
item2.Release();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_mediums"),&itemnode2);
if(hr==S_OK)
{
IXMLDOMNodeListPtr children2;
long listlength2;
item2 = itemnode2;
hr = item2->get_childNodes(&children2);
if(hr!=S_OK) throw _com_error(hr);
hr = children2->get_length(&listlength2);
if(hr!=S_OK) throw _com_error(hr);
for(size_t m=0;m<listlength2;m++)
{
IXMLDOMElementPtr item3;
IXMLDOMNodePtr itemnode3;
KSIDENTIFIER ksidentifier;
hr = children2->get_item(m, &itemnode3);
if(hr!=S_OK) throw _com_error(hr);
item3 = itemnode3;
GetKSIDENTIFIER(item3,ksidentifier);
pininfo.mediums.push_back(ksidentifier);
}
itemnode2.Release();
item2.Release();
}
hr = item->getAttribute(_bstr_t(L"ksproperty_pin_name"),&var);
if(hr==S_OK)
{
pininfo.name = (LPCWSTR)(_bstr_t)var;
var.Clear();
}
hr = item->getAttribute(_bstr_t(L"ksproperty_pin_necessaryinstances"),&var);
if(hr==S_OK)
{
pininfo.necessaryinstances = (unsigned long)var;
pininfo.necessaryinstances_valid = true;
var.Clear();
}
hr = item->selectSingleNode(_bstr_t(L"ksproperty_pin_physicalconnection"),&itemnode2);
if(hr==S_OK)
{
item2 = itemnode2;
hr = item2->getAttribute(_bstr_t(L"Size"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.physicalconnection.Size = (unsigned long)var;
var.Clear();
hr = item2->getAttribute(_bstr_t(L"Pin"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.physicalconnection.Pin = (unsigned long)var;
var.Clear();
hr = item2->getAttribute(_bstr_t(L"SymbolicLinkName"),&var);
if(hr!=S_OK) throw _com_error(hr);
pininfo.symboliclinkname = (LPCWSTR)(_bstr_t)var;
var.Clear();
pininfo.physicalconnection_valid = true;
itemnode2.Release();
item2.Release();
}
v.push_back(pininfo);
}
}
HRESULT WINAPI PSPropertyKeyFromString(LPCWSTR pszString, PROPERTYKEY *pkey)
{
int has_minus = 0, has_comma = 0;
TRACE("(%s, %p)\n", debugstr_w(pszString), pkey);
if (!pszString || !pkey)
return E_POINTER;
memset(pkey, 0, sizeof(PROPERTYKEY));
if (!string_to_guid(pszString, &pkey->fmtid))
return E_INVALIDARG;
pszString += GUIDSTRING_MAX - 1;
if (!*pszString)
return E_INVALIDARG;
/* Only the space seems to be recognized as whitespace. The comma is only
* recognized once and processing terminates if another comma is found. */
while (*pszString == ' ' || *pszString == ',')
{
if (*pszString == ',')
{
if (has_comma)
return S_OK;
else
has_comma = 1;
}
pszString++;
}
if (!*pszString)
return E_INVALIDARG;
/* Only two minus signs are recognized if no comma is detected. The first
* sign is ignored, and the second is interpreted. If a comma is detected
* before the minus sign, then only one minus sign counts, and property ID
* interpretation begins with the next character. */
if (has_comma)
{
if (*pszString == '-')
{
has_minus = 1;
pszString++;
}
}
else
{
if (*pszString == '-')
pszString++;
/* Skip any intermediate spaces after the first minus sign. */
while (*pszString == ' ')
pszString++;
if (*pszString == '-')
{
has_minus = 1;
pszString++;
}
/* Skip any remaining spaces after minus sign. */
while (*pszString == ' ')
pszString++;
}
/* Overflow is not checked. */
while (isdigitW(*pszString))
{
pkey->pid *= 10;
pkey->pid += (*pszString - '0');
pszString++;
}
if (has_minus)
pkey->pid = ~pkey->pid + 1;
return S_OK;
}
static int ipa_cldap_encode_netlogon(char *hostname, char *domain,
char *guid, char *sid, char *name,
uint32_t ntver, struct berval *reply)
{
struct NETLOGON_SAM_LOGON_RESPONSE_EX *nlr;
enum ndr_err_code ndr_err;
DATA_BLOB blob;
char *pdc_name;
char *p;
int ret;
nlr = talloc_zero(NULL, struct NETLOGON_SAM_LOGON_RESPONSE_EX);
if (!nlr) {
return ENOMEM;
}
if (!(ntver & NETLOGON_NT_VERSION_5EX)) {
ret = EINVAL;
goto done;
}
nlr->command = LOGON_SAM_LOGON_RESPONSE_EX;
/* nlr->sbz */
nlr->server_type = DS_SERVER_PDC |
DS_SERVER_GC |
DS_SERVER_LDAP |
DS_SERVER_DS |
DS_SERVER_KDC |
DS_SERVER_TIMESERV |
DS_SERVER_CLOSEST |
DS_SERVER_WRITABLE |
DS_SERVER_GOOD_TIMESERV;
string_to_guid(guid, &nlr->domain_uuid);
nlr->forest = domain;
nlr->dns_domain = domain;
nlr->pdc_dns_name = talloc_asprintf(nlr, "%s.%s", hostname, domain);
if (!nlr->pdc_dns_name) {
ret = ENOMEM;
goto done;
}
nlr->domain_name = name;
pdc_name = talloc_asprintf(nlr, "\\\\%s", hostname);
for (p = pdc_name; *p; p++) {
*p = toupper(*p);
}
nlr->pdc_name = pdc_name;
nlr->user_name = "";
nlr->server_site = "Default-First-Site-Name";
nlr->client_site = "Default-First-Site-Name";
/* nlr->sockaddr_size (filled in by ndr_push) */
nlr->sockaddr.sockaddr_family = 2;
nlr->sockaddr.pdc_ip = "127.0.0.1";
nlr->sockaddr.remaining.length = 8;
nlr->sockaddr.remaining.data = talloc_zero_size(nlr, 8);
/* nlr->next_closest_site */
nlr->nt_version = NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1;
nlr->lmnt_token = 0xFFFF;
nlr->lm20_token = 0xFFFF;
ndr_err = ndr_push_struct_blob(&blob, nlr, nlr,
NETLOGON_SAM_LOGON_RESPONSE_EX_pusher);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ret = EFAULT;
goto done;
}
reply->bv_val = malloc(blob.length);
if (!reply->bv_val) {
ret = ENOMEM;
goto done;
}
memcpy(reply->bv_val, blob.data, blob.length);
reply->bv_len = blob.length;
ret = 0;
done:
talloc_free(nlr);
return ret;
}
static split_record interpret_split_record( char *record_line)
{
char * tok_ptr;
split_record record;
memset(&record, 0, sizeof(record));
DEBUG("interpret_split_record(): Start...");
if (strlen(tok_ptr = my_strtok(record_line, "\t")) != 0)
{
switch (tok_ptr[0])
{
case 'B':
record.log_action = split_record::LOG_BEGIN_EDIT;
break;
case 'D':
record.log_action = split_record::LOG_DELETE;
break;
case 'C':
record.log_action = split_record::LOG_COMMIT;
break;
case 'R':
record.log_action = split_record::LOG_ROLLBACK;
break;
}
record.log_action_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
string_to_guid(tok_ptr, &(record.trans_guid));
record.trans_guid_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
string_to_guid(tok_ptr, &(record.split_guid));
record.split_guid_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
record.log_date = gnc_iso8601_to_timespec_gmt(tok_ptr);
record.log_date_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
record.date_entered = gnc_iso8601_to_timespec_gmt(tok_ptr);
record.date_entered_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
record.date_posted = gnc_iso8601_to_timespec_gmt(tok_ptr);
record.date_posted_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
string_to_guid(tok_ptr, &(record.acc_guid));
record.acc_guid_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.acc_name, tok_ptr, STRING_FIELD_SIZE - 1);
record.acc_name_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.trans_num, tok_ptr, STRING_FIELD_SIZE - 1);
record.trans_num_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.trans_descr, tok_ptr, STRING_FIELD_SIZE - 1);
record.trans_descr_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.trans_notes, tok_ptr, STRING_FIELD_SIZE - 1);
record.trans_notes_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.split_memo, tok_ptr, STRING_FIELD_SIZE - 1);
record.split_memo_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
strncpy(record.split_action, tok_ptr, STRING_FIELD_SIZE - 1);
record.split_action_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
record.split_reconcile = tok_ptr[0];
record.split_reconcile_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
string_to_gnc_numeric(tok_ptr, &(record.amount));
record.amount_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
string_to_gnc_numeric(tok_ptr, &(record.value));
record.value_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
record.date_reconciled = gnc_iso8601_to_timespec_gmt(tok_ptr);
record.date_reconciled_present = TRUE;
}
if (strlen(tok_ptr = my_strtok(NULL, "\t")) != 0)
{
PERR("interpret_split_record(): Expected number of fields exceeded!");
}
DEBUG("interpret_split_record(): End");
return record;
}
static void
load_owner( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
gchar* buf;
GncOwnerType type;
GncGUID guid;
QofBook* book;
GncOwner owner;
GncGUID* pGuid = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
book = be->primary_book;
buf = g_strdup_printf( "%s_type", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
type = (GncOwnerType)gnc_sql_get_integer_value( val );
g_free( buf );
buf = g_strdup_printf( "%s_guid", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
g_free( buf );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
string_to_guid( g_value_get_string( val ), &guid );
pGuid = &guid;
}
switch ( type )
{
case GNC_OWNER_CUSTOMER:
{
GncCustomer *cust = NULL;
if ( pGuid != NULL )
{
cust = gncCustomerLookup( book, pGuid );
if ( cust == NULL )
{
cust = gncCustomerCreate( book );
gncCustomerSetGUID( cust, &guid );
}
}
gncOwnerInitCustomer( &owner, cust );
break;
}
case GNC_OWNER_JOB:
{
GncJob *job = NULL;
if ( pGuid != NULL )
{
job = gncJobLookup( book, pGuid );
if ( job == NULL )
{
job = gncJobCreate( book );
gncJobSetGUID( job, &guid );
}
}
gncOwnerInitJob( &owner, job );
break;
}
case GNC_OWNER_VENDOR:
{
GncVendor *vendor = NULL;
if ( pGuid != NULL )
{
vendor = gncVendorLookup( book, pGuid );
if ( vendor == NULL )
{
vendor = gncVendorCreate( book );
gncVendorSetGUID( vendor, &guid );
}
}
gncOwnerInitVendor( &owner, vendor );
break;
}
case GNC_OWNER_EMPLOYEE:
{
GncEmployee *employee = NULL;
if ( pGuid != NULL )
{
employee = gncEmployeeLookup( book, pGuid );
if ( employee == NULL )
{
employee = gncEmployeeCreate( book );
gncEmployeeSetGUID( employee, &guid );
}
}
gncOwnerInitEmployee( &owner, employee );
break;
}
default:
PWARN("Invalid owner type: %d\n", type );
}
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, &owner, NULL );
}
else
{
(*setter)( pObject, &owner );
}
}
static gboolean
gst_directsound_src_open (GstAudioSrc * asrc)
{
GstDirectSoundSrc *dsoundsrc;
HRESULT hRes; /* Result for windows functions */
GST_DEBUG_OBJECT (asrc, "opening directsoundsrc");
dsoundsrc = GST_DIRECTSOUND_SRC (asrc);
/* Open dsound.dll */
dsoundsrc->DSoundDLL = LoadLibrary ("dsound.dll");
if (!dsoundsrc->DSoundDLL) {
goto dsound_open;
}
/* Building the DLL Calls */
pDSoundCaptureCreate =
(void *) GetProcAddress (dsoundsrc->DSoundDLL,
TEXT ("DirectSoundCaptureCreate"));
/* If everything is not ok */
if (!pDSoundCaptureCreate) {
goto capture_function;
}
if (dsoundsrc->device_id) {
GST_DEBUG_OBJECT (asrc, "device id set to: %s ", dsoundsrc->device_id);
dsoundsrc->device_guid = string_to_guid (dsoundsrc->device_id);
if (dsoundsrc->device_guid == NULL) {
GST_ELEMENT_ERROR (dsoundsrc, RESOURCE, OPEN_READ,
("gst_directsound_src_open: device set, but guid not found: %s",
dsoundsrc->device_id), (NULL));
g_free (dsoundsrc->device_guid);
return FALSE;
}
} else {
hRes = DirectSoundCaptureEnumerate ((LPDSENUMCALLBACK)
gst_directsound_enum_callback, (VOID *) dsoundsrc);
if (FAILED (hRes)) {
goto capture_enumerate;
}
}
/* Create capture object */
hRes = pDSoundCaptureCreate (dsoundsrc->device_guid, &dsoundsrc->pDSC, NULL);
if (FAILED (hRes)) {
goto capture_object;
}
// mixer is only supported when device-id is not set
if (!dsoundsrc->device_id) {
gst_directsound_src_mixer_init (dsoundsrc);
}
return TRUE;
capture_function:
{
FreeLibrary (dsoundsrc->DSoundDLL);
GST_ELEMENT_ERROR (dsoundsrc, RESOURCE, OPEN_READ,
("Unable to get capturecreate function"), (NULL));
return FALSE;
}
capture_enumerate:
{
FreeLibrary (dsoundsrc->DSoundDLL);
GST_ELEMENT_ERROR (dsoundsrc, RESOURCE, OPEN_READ,
("Unable to enumerate audio capture devices"), (NULL));
return FALSE;
}
capture_object:
{
FreeLibrary (dsoundsrc->DSoundDLL);
GST_ELEMENT_ERROR (dsoundsrc, RESOURCE, OPEN_READ,
("Unable to create capture object"), (NULL));
return FALSE;
}
dsound_open:
{
DWORD err = GetLastError ();
GST_ELEMENT_ERROR (dsoundsrc, RESOURCE, OPEN_READ,
("Unable to open dsound.dll"), (NULL));
g_print ("0x%lx\n", HRESULT_FROM_WIN32 (err));
return FALSE;
}
}
