GError *
peer_restore(const gchar *target, struct sqlx_name_s *name,
GByteArray *dump)
{
GError *err = NULL;
if (!target) {
g_byte_array_unref(dump);
return NULL;
}
GByteArray *encoded = _pack_RESTORE(name, dump);
struct gridd_client_s *client = gridd_client_create(target, encoded, NULL, NULL);
g_byte_array_unref(encoded);
if (!client)
return NEWERROR(CODE_INTERNAL_ERROR, "Failed to create client to [%s], bad address?", target);
gridd_client_set_timeout(client, SQLX_RESYNC_TIMEOUT);
gridd_client_start(client);
if (!(err = gridd_client_loop(client)))
err = gridd_client_error(client);
gridd_client_free(client);
return err;
}
GError *
gridd_client_exec_and_concat (const gchar *to, gdouble seconds, GByteArray *req,
GByteArray **out)
{
if (!to) {
g_byte_array_unref (req);
return NEWERROR(CODE_INTERNAL_ERROR, "No target");
}
GByteArray *tmp = NULL;
if (out)
tmp = g_byte_array_new();
struct gridd_client_s *client = gridd_client_create(to, req,
out ? tmp : NULL, out ? (client_on_reply)_cb_exec_and_concat : NULL);
g_byte_array_unref (req);
if (!client) {
if (tmp) g_byte_array_free (tmp, TRUE);
return NEWERROR(CODE_INTERNAL_ERROR, "client creation");
}
if (seconds > 0.0)
gridd_client_set_timeout (client, seconds);
GError *err = gridd_client_run (client);
gridd_client_free (client);
if (!err && out) {
*out = tmp;
tmp = NULL;
}
if (tmp)
metautils_gba_unref (tmp);
return err;
}
void
peers_restore(gchar **targets, struct sqlx_name_s *name,
GByteArray *dump)
{
GError *err = NULL;
if (!targets || !targets[0]) {
g_byte_array_unref(dump);
return ;
}
GByteArray *encoded = _pack_RESTORE(name, dump);
struct gridd_client_s **clients = gridd_client_create_many(targets, encoded, NULL, NULL);
g_byte_array_unref(encoded);
gridd_clients_set_timeout(clients, SQLX_RESYNC_TIMEOUT);
gridd_clients_start(clients);
if (!(err = gridd_clients_loop(clients)))
err = gridd_clients_error(clients);
gridd_clients_free(clients);
if (err) {
GRID_WARN("RESTORE failed [%s][%s] : (%d) %s", name->base, name->type,
err->code, err->message);
g_clear_error(&err);
}
}
static void finalize(GObject *obj)
{
RobotObjFile *self = ROBOT_OBJ_FILE(obj);
g_byte_array_unref(self->data);
g_byte_array_unref(self->text);
g_array_unref(self->sym);
g_array_unref(self->relocation);
g_array_unref(self->depends);
self->data = NULL;
self->text = NULL;
self->sym = NULL;
self->relocation = NULL;
self->depends = NULL;
}
static GByteArray*
m2v2_remote_pack_RAW_SUBST(struct oio_url_s *url,
GSList *new_chunks, GSList *old_chunks)
{
GByteArray *new_chunks_gba = bean_sequence_marshall(new_chunks);
GByteArray *old_chunks_gba = bean_sequence_marshall(old_chunks);
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_RAW_SUBST, url, NULL);
metautils_message_add_fields_gba(msg,
NAME_MSGKEY_NEW, new_chunks_gba,
NAME_MSGKEY_OLD, old_chunks_gba,
NULL);
g_byte_array_unref (new_chunks_gba);
g_byte_array_unref (old_chunks_gba);
return message_marshall_gba_and_clean(msg);
}
static void instr_clear(void *p)
{
struct instruction *s = p;
if (s->data)
g_byte_array_unref(s->data);
s->data = NULL;
}
gint
reply_context_reply (struct reply_context_s *ctx, GError **err)
{
EXTRA_ASSERT (ctx != NULL);
register gchar *ptr_msg = ctx->header.msg ? ctx->header.msg : "NOMSG";
MESSAGE answer = metaXServer_reply_simple (ctx->req_ctx->request, ctx->header.code, ptr_msg);
if (ctx->extra_headers)
g_hash_table_foreach(ctx->extra_headers, reply_ctx_header_adder, answer);
if (ctx->body.buffer && (ctx->body.size > 0))
metautils_message_set_BODY(answer, ctx->body.buffer, ctx->body.size);
GByteArray *encoded = message_marshall_gba_and_clean(answer);
answer = NULL;
if (encoded) {
gint _to = MAX(MS_REPLY_TIMEOUT, MIN(60000, default_to_operation));
gint sent = sock_to_write(ctx->req_ctx->fd, _to, encoded->data, encoded->len, err);
gboolean done = (sent > 0) && (encoded->len == (guint)sent);
g_byte_array_unref (encoded);
if (!done) {
g_prefix_error(err, "Failed to reply: ");
return 0;
}
}
return 1;
}
static guint
dmapd_dmap_db_ghashtable_add (DMAPDb *db, DMAPRecord *record)
{
gchar *db_dir = NULL;
GByteArray *blob = NULL;
gchar *location = NULL;;
g_object_ref (record);
g_object_get (record, "location", &location, NULL);
g_object_get (db, "db-dir", &db_dir, NULL);
if (db_dir != NULL) {
blob = dmap_record_to_blob (record);
cache_store (db_dir, location, blob);
}
_done:
if (NULL != location) {
g_free (location);
}
if (NULL != db_dir) {
g_free (db_dir);
}
if (NULL != blob) {
g_byte_array_unref (blob);
}
return dmapd_dmap_db_ghashtable_add_with_id (db, record, nextid--);
}
static void
serial_command_ready (MMPortSerial *port,
GAsyncResult *res,
GSimpleAsyncResult *simple)
{
GByteArray *response_buffer;
GError *error = NULL;
GString *response;
response_buffer = mm_port_serial_command_finish (port, res, &error);
if (!response_buffer) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
/* Build a GString just with the response we need, and clear the
* processed range from the response buffer */
response = g_string_new_len ((const gchar *)response_buffer->data, response_buffer->len);
if (response_buffer->len > 0)
g_byte_array_remove_range (response_buffer, 0, response_buffer->len);
g_byte_array_unref (response_buffer);
g_simple_async_result_set_op_res_gpointer (simple,
response,
(GDestroyNotify)string_free);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
GError*
sqlx_remote_execute_ADMGET(const gchar *target, GByteArray *sid,
struct sqlx_name_s *name, const gchar *k, gchar **v)
{
(void) sid;
GError *err = NULL;
GByteArray *encoded = sqlx_pack_ADMGET(name, k);
GByteArray *gba_buf = g_byte_array_new();
struct client_s *client = gridd_client_create(target, encoded,
gba_buf, on_reply_gba);
g_byte_array_unref(encoded);
gridd_client_start(client);
if (!(err = gridd_client_loop(client))) {
if (!(err = gridd_client_error(client))) {
gchar *buf = g_malloc0(gba_buf->len + 1);
metautils_gba_data_to_string(gba_buf, buf, gba_buf->len + 1);
*v = buf;
}
}
gridd_client_free(client);
metautils_gba_unref(gba_buf);
return err;
}
static void
reg_eri_6500_cb (MMPortSerialQcdm *port,
GAsyncResult *res,
DetailedRegistrationStateContext *ctx)
{
GError *error = NULL;
GByteArray *response;
response = mm_port_serial_qcdm_command_finish (port, res, &error);
if (error) {
/* Just ignore the error and complete with the input info */
mm_dbg ("Couldn't run QCDM MSM6500 ERI: '%s'", error->message);
g_error_free (error);
} else {
QcdmResult *result;
result = qcdm_cmd_nw_subsys_eri_result ((const gchar *) response->data, response->len, NULL);
g_byte_array_unref (response);
if (result) {
parse_modem_eri (ctx, result);
qcdm_result_unref (result);
}
}
/* NOTE: always complete NOT in idle here */
g_simple_async_result_set_op_res_gpointer (ctx->result, &ctx->state, NULL);
detailed_registration_state_context_complete_and_free (ctx);
}
static void
nw_snapshot_old_cb (MMPortSerialQcdm *port,
GAsyncResult *res,
SnapshotContext *ctx)
{
QcdmResult *result;
guint8 hdr_revision = QCDM_HDR_REV_UNKNOWN;
GError *error = NULL;
GByteArray *response;
response = mm_port_serial_qcdm_command_finish (port, res, &error);
if (error) {
/* Just ignore the error and complete with the input info */
mm_dbg ("Couldn't run QCDM Novatel Modem MSM6500 snapshot: '%s'", error->message);
g_error_free (error);
snapshot_context_complete_and_free (ctx, QCDM_HDR_REV_UNKNOWN);
return;
}
/* Parse the response */
result = qcdm_cmd_nw_subsys_modem_snapshot_cdma_result ((const gchar *) response->data, response->len, NULL);
g_byte_array_unref (response);
if (result) {
qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, &hdr_revision);
qcdm_result_unref (result);
} else
mm_dbg ("Failed to get QCDM Novatel Modem MSM6500 snapshot.");
snapshot_context_complete_and_free (ctx, hdr_revision);
}
static GkmTrustLevel
gkm_xdg_trust_get_level (GkmTrust *base, const gchar *purpose)
{
GkmXdgTrust *self = GKM_XDG_TRUST (base);
GkmAssertion *assertion;
GByteArray *key;
gulong type;
key = create_assertion_key (purpose, NULL);
assertion = g_hash_table_lookup (self->pv->assertions, key);
g_byte_array_unref (key);
if (!assertion)
return GKM_TRUST_UNKNOWN;
type = gkm_assertion_get_trust_type (assertion);
if (type == CKT_X_ANCHORED_CERTIFICATE)
return GKM_TRUST_ANCHOR;
else if (type == CKT_X_PINNED_CERTIFICATE)
return GKM_TRUST_TRUSTED;
else if (type == CKT_X_DISTRUSTED_CERTIFICATE)
return GKM_TRUST_DISTRUSTED;
else
g_return_val_if_reached (GKM_TRUST_UNKNOWN);
}
static void
modem_cdma_get_detailed_registration_state (MMIfaceModemCdma *self,
MMModemCdmaRegistrationState cdma1x_state,
MMModemCdmaRegistrationState evdo_state,
GAsyncReadyCallback callback,
gpointer user_data)
{
DetailedRegistrationStateContext *ctx;
GByteArray *nweri;
MMPortSerialQcdm *port;
/* Setup context */
ctx = g_new0 (DetailedRegistrationStateContext, 1);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
modem_cdma_get_detailed_registration_state);
ctx->state.detailed_cdma1x_state = cdma1x_state;
ctx->state.detailed_evdo_state = evdo_state;
port = mm_base_modem_peek_port_qcdm (MM_BASE_MODEM (self));
/* Try MSM6800 first since newer cards use that */
nweri = g_byte_array_sized_new (25);
nweri->len = qcdm_cmd_nw_subsys_eri_new ((char *) nweri->data, 25, QCDM_NW_CHIPSET_6800);
g_assert (nweri->len);
mm_port_serial_qcdm_command (port,
nweri,
3,
NULL,
(GAsyncReadyCallback)reg_eri_6800_cb,
ctx);
g_byte_array_unref (nweri);
}
static gboolean
get_nw_modem_snapshot (MMBaseModem *self,
GSimpleAsyncResult *simple,
MMModemAccessTechnology generic_act,
guint mask)
{
SnapshotContext *ctx;
GByteArray *nwsnap;
MMPortSerialQcdm *port;
port = mm_base_modem_peek_port_qcdm (self);
if (!port)
return FALSE;
/* Setup context */
ctx = g_new0 (SnapshotContext, 1);
ctx->self = g_object_ref (self);
ctx->port = g_object_ref (port);
ctx->simple = simple;
ctx->generic_act = generic_act;
ctx->mask = mask;
/* Try MSM6800 first since newer cards use that */
nwsnap = g_byte_array_sized_new (25);
nwsnap->len = qcdm_cmd_nw_subsys_modem_snapshot_cdma_new ((char *) nwsnap->data, 25, QCDM_NW_CHIPSET_6800);
g_assert (nwsnap->len);
mm_port_serial_qcdm_command (port,
nwsnap,
3,
NULL,
(GAsyncReadyCallback)nw_snapshot_new_cb,
ctx);
g_byte_array_unref (nwsnap);
return TRUE;
}
static GByteArray*
_pack_RESTORE(struct sqlx_name_s *name, GByteArray *dump)
{
GByteArray *encoded = sqlx_pack_RESTORE(name, dump->data, dump->len);
g_byte_array_unref(dump);
return encoded;
}
Util::Buffer::~Buffer()
{
if ( bytes )
{
g_byte_array_unref( bytes );
}
}
static GByteArray* load_file(const char *filename, GError **error)
{
GByteArray* res = g_byte_array_new();
int c;
unsigned char b;
FILE *f;
f = fopen(filename, "rb");
if (!f) {
g_set_error(error, ROBOT_ERROR, ROBOT_ERROR_IO, strerror(errno));
g_byte_array_unref(res);
return NULL;
}
while ((c = getc(f)) != EOF) {
b = c;
g_byte_array_append(res, &b, 1);
}
b = 0;
g_byte_array_append(res, &b, 1);
fclose(f);
return res;
}
void
metautils_message_add_body_unref (MESSAGE m, GByteArray *body)
{
if (!body)
return;
if (body->len && body->data)
metautils_message_set_BODY (m, body->data, body->len);
g_byte_array_unref (body);
}
static void
reg_eri_6800_cb (MMPortSerialQcdm *port,
GAsyncResult *res,
DetailedRegistrationStateContext *ctx)
{
GError *error = NULL;
GByteArray *response;
response = mm_port_serial_qcdm_command_finish (port, res, &error);
if (error) {
/* Just ignore the error and complete with the input info */
mm_dbg ("Couldn't run QCDM MSM6800 ERI: '%s'", error->message);
g_error_free (error);
} else {
QcdmResult *result;
/* Parse the response */
result = qcdm_cmd_nw_subsys_eri_result ((const gchar *) response->data, response->len, NULL);
g_byte_array_unref (response);
if (result) {
parse_modem_eri (ctx, result);
qcdm_result_unref (result);
} else {
GByteArray *nweri;
/* Try for MSM6500 */
nweri = g_byte_array_sized_new (25);
nweri->len = qcdm_cmd_nw_subsys_eri_new ((char *) nweri->data, 25, QCDM_NW_CHIPSET_6500);
g_assert (nweri->len);
mm_port_serial_qcdm_command (port,
nweri,
3,
NULL,
(GAsyncReadyCallback)reg_eri_6500_cb,
ctx);
g_byte_array_unref (nweri);
return;
}
}
/* NOTE: always complete NOT in idle here */
g_simple_async_result_set_op_res_gpointer (ctx->result, &ctx->state, NULL);
detailed_registration_state_context_complete_and_free (ctx);
}
static NMDevice *
find_vlan_parent (GSList *connections, NMApplet *applet)
{
const GPtrArray *devices;
NMDevice *parent_device;
GSList *iter;
devices = nm_client_get_devices (applet->nm_client);
if (!devices)
return NULL;
for (iter = connections; iter; iter = iter->next) {
NMConnection *connection = iter->data;
NMSettingVlan *s_vlan;
const char *parent;
s_vlan = nm_connection_get_setting_vlan (connection);
g_return_val_if_fail (s_vlan != NULL, NULL);
parent = nm_setting_vlan_get_parent (s_vlan);
if (parent && nm_utils_iface_valid_name (parent)) {
parent_device = find_device_by_iface (parent, devices);
} else {
NMSettingConnection *s_con;
NMSetting *s_hw;
const char *type;
GByteArray *mac;
s_con = nm_connection_get_setting_connection (connection);
type = nm_setting_connection_get_connection_type (s_con);
s_hw = nm_connection_get_setting_by_name (connection, type);
if (!s_hw) {
g_warn_if_reached ();
continue;
}
if (!g_object_class_find_property (G_OBJECT_GET_CLASS (s_hw),
"mac-address"))
continue;
g_object_get (G_OBJECT (s_hw),
"mac-address", &mac,
NULL);
if (mac) {
parent_device = find_device_by_mac (mac, devices);
g_byte_array_unref (mac);
} else
parent_device = NULL;
}
if (parent_device)
return parent_device;
}
return NULL;
}
static void
cockpit_auth_finalize (GObject *object)
{
CockpitAuth *self = COCKPIT_AUTH (object);
g_byte_array_unref (self->key);
g_hash_table_destroy (self->authenticated);
G_OBJECT_CLASS (cockpit_auth_parent_class)->finalize (object);
}
static void
nw_snapshot_new_cb (MMPortSerialQcdm *port,
GAsyncResult *res,
SnapshotContext *ctx)
{
QcdmResult *result;
GByteArray *nwsnap;
guint8 hdr_revision = QCDM_HDR_REV_UNKNOWN;
GError *error = NULL;
GByteArray *response;
response = mm_port_serial_qcdm_command_finish (port, res, &error);
if (error) {
mm_dbg ("Couldn't run QCDM Novatel Modem MSM6800 snapshot: '%s'", error->message);
g_error_free (error);
snapshot_context_complete_and_free (ctx, QCDM_HDR_REV_UNKNOWN);
return;
}
/* Parse the response */
result = qcdm_cmd_nw_subsys_modem_snapshot_cdma_result ((const gchar *) response->data, response->len, NULL);
g_byte_array_unref (response);
if (result) {
qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, &hdr_revision);
qcdm_result_unref (result);
snapshot_context_complete_and_free (ctx, hdr_revision);
return;
}
mm_dbg ("Failed to get QCDM Novatel Modem MSM6800 snapshot.");
/* Try for MSM6500 */
nwsnap = g_byte_array_sized_new (25);
nwsnap->len = qcdm_cmd_nw_subsys_modem_snapshot_cdma_new ((char *) nwsnap->data, 25, QCDM_NW_CHIPSET_6500);
g_assert (nwsnap->len);
mm_port_serial_qcdm_command (port,
nwsnap,
3,
NULL,
(GAsyncReadyCallback)nw_snapshot_old_cb,
ctx);
g_byte_array_unref (nwsnap);
}
static void
_client_reset_request(struct gridd_client_s *client)
{
if (client->request)
g_byte_array_unref(client->request);
client->request = NULL;
client->ctx = NULL;
client->on_reply = NULL;
client->sent_bytes = 0;
client->nb_redirects = 0;
}
/* destructor */
static void
thrift_memory_buffer_finalize (GObject *object)
{
ThriftMemoryBuffer *t = THRIFT_MEMORY_BUFFER (object);
if (t->owner && t->buf != NULL)
{
g_byte_array_unref (t->buf);
}
t->buf = NULL;
}
static void
gcab_cabinet_finalize (GObject *object)
{
GCabCabinet *self = GCAB_CABINET (object);
g_ptr_array_unref (self->folders);
if (self->reserved)
g_byte_array_unref (self->reserved);
G_OBJECT_CLASS (gcab_cabinet_parent_class)->finalize (object);
}
static void ovirt_proxy_set_mock_ca(OvirtProxy *proxy)
{
gchar *data;
gsize size;
GByteArray *cacert;
g_file_get_contents(abs_srcdir "/https-cert/ca-cert.pem", &data, &size, NULL);
cacert = g_byte_array_new_take((guint8 *)data, size);
g_object_set(proxy, "ca-cert", cacert, NULL);
g_byte_array_unref(cacert);
}
static void
grl_dpap_record_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GrlDPAPRecord *record = SIMPLE_DPAP_RECORD (object);
switch (prop_id) {
case PROP_LOCATION:
g_free (record->priv->location);
record->priv->location = g_value_dup_string (value);
break;
case PROP_LARGE_FILESIZE:
record->priv->largefilesize = g_value_get_int (value);
break;
case PROP_CREATION_DATE:
record->priv->creationdate = g_value_get_int (value);
break;
case PROP_RATING:
record->priv->rating = g_value_get_int (value);
break;
case PROP_FILENAME:
g_free (record->priv->filename);
record->priv->filename = g_value_dup_string (value);
break;
case PROP_ASPECT_RATIO:
g_free (record->priv->aspectratio);
record->priv->aspectratio = g_value_dup_string (value);
break;
case PROP_PIXEL_HEIGHT:
record->priv->height = g_value_get_int (value);
break;
case PROP_PIXEL_WIDTH:
record->priv->width = g_value_get_int (value);
break;
case PROP_FORMAT:
g_free (record->priv->format);
record->priv->format = g_value_dup_string (value);
break;
case PROP_COMMENTS:
g_free (record->priv->comments);
record->priv->comments = g_value_dup_string (value);
break;
case PROP_THUMBNAIL:
if (record->priv->thumbnail)
g_byte_array_unref (record->priv->thumbnail);
record->priv->thumbnail = g_byte_array_ref (g_value_get_pointer (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
load_assertions (GkmXdgTrust *self, GNode *asn)
{
gconstpointer element;
GHashTable *assertions;
GkmAssertion *assertion;
gsize n_element;
GByteArray *key;
GNode *node;
guint count, i;
g_assert (self);
g_assert (asn);
assertions = self->pv->assertions;
self->pv->assertions = create_assertions ();
count = egg_asn1x_count (egg_asn1x_node (asn, "assertions", NULL));
for (i = 0; i < count; ++i) {
node = egg_asn1x_node (asn, "assertions", i + 1, NULL);
g_return_val_if_fail (node, FALSE);
/* We use the raw DER encoding as an assertion */
element = egg_asn1x_get_raw_element (node, &n_element);
g_return_val_if_fail (node, FALSE);
/* Double check that this is valid, because it's how we hash */
key = g_byte_array_new ();
g_byte_array_append (key, element, n_element);
/* Already have this assertion? */
assertion = g_hash_table_lookup (assertions, key);
if (assertion) {
if (!g_hash_table_steal (assertions, key))
g_assert_not_reached ();
/* Create a new assertion */
} else {
assertion = create_assertion (self, node);
}
add_assertion_to_trust (self, assertion, NULL);
g_byte_array_unref (key);
g_object_unref (assertion);
}
/* Override the stored assertions and netscape trust */
g_hash_table_remove_all (assertions);
g_hash_table_unref (assertions);
return TRUE;
}
GByteArray*
m2v2_remote_pack_SUBST_CHUNKS(GByteArray *sid, struct hc_url_s *url,
GSList *new_chunks, GSList *old_chunks, gboolean restrict_to_alias)
{
struct message_s *msg;
GByteArray *new_chunks_gba = bean_sequence_marshall(new_chunks);
GByteArray *old_chunks_gba = bean_sequence_marshall(old_chunks);
msg = _m2v2_build_request("M2V2_SUBST_CHUNKS", sid, url, NULL);
if (restrict_to_alias) {
(void) message_add_field(msg,
M2_KEY_RESTRICT_TO_ALIAS, sizeof(M2_KEY_RESTRICT_TO_ALIAS)-1,
"TRUE", 5, NULL);
}
message_add_fields_gba(msg,
M2_KEY_NEW_CHUNKS, new_chunks_gba,
M2_KEY_OLD_CHUNKS, old_chunks_gba,
NULL);
g_byte_array_unref(new_chunks_gba);
g_byte_array_unref(old_chunks_gba);
return message_marshall_gba_and_clean(msg);
}
