static void
try_qcdm_probe (MMPluginBaseSupportsTask *task)
{
MMPluginBaseSupportsTaskPrivate *priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
const char *name;
GError *error = NULL;
GByteArray *verinfo = NULL, *verinfo2;
gint len;
/* Close the AT port */
if (priv->probe_port) {
mm_serial_port_close (MM_SERIAL_PORT (priv->probe_port));
g_object_unref (priv->probe_port);
priv->probe_port = NULL;
}
/* Open the QCDM port */
name = g_udev_device_get_name (priv->port);
g_assert (name);
priv->qcdm_port = mm_qcdm_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
if (priv->qcdm_port == NULL) {
g_warning ("(%s) failed to create new QCDM serial port.", name);
probe_complete (task);
return;
}
if (!mm_serial_port_open (MM_SERIAL_PORT (priv->qcdm_port), &error)) {
g_warning ("(%s) failed to open new QCDM serial port: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
/* Build up the probe command */
verinfo = g_byte_array_sized_new (50);
len = qcdm_cmd_version_info_new ((char *) verinfo->data, 50, &error);
if (len <= 0) {
g_byte_array_free (verinfo, TRUE);
g_warning ("(%s) failed to create QCDM version info command: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
verinfo->len = len;
/* Queuing the command takes ownership over it; copy it for the second try */
verinfo2 = g_byte_array_sized_new (verinfo->len);
g_byte_array_append (verinfo2, verinfo->data, verinfo->len);
/* Send the command twice; the ports often need to be woken up */
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo, 3, qcdm_verinfo_cb, NULL);
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo2, 3, qcdm_verinfo_cb, task);
}
static void
mac_address_parser (NMSetting *setting, const char *key, GKeyFile *keyfile)
{
const char *setting_name = nm_setting_get_name (setting);
struct ether_addr *eth;
char *tmp_string = NULL, *p;
gint *tmp_list;
GByteArray *array = NULL;
gsize length;
int i;
p = tmp_string = g_key_file_get_string (keyfile, setting_name, key, NULL);
if (tmp_string) {
/* Look for enough ':' characters to signify a MAC address */
i = 0;
while (*p) {
if (*p == ':')
i++;
p++;
}
if (i == 5) {
/* parse as a MAC address */
eth = ether_aton (tmp_string);
if (eth) {
g_free (tmp_string);
array = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (array, eth->ether_addr_octet, ETH_ALEN);
goto done;
}
}
}
g_free (tmp_string);
/* Old format; list of ints */
tmp_list = g_key_file_get_integer_list (keyfile, setting_name, key, &length, NULL);
array = g_byte_array_sized_new (length);
for (i = 0; i < length; i++) {
int val = tmp_list[i];
unsigned char v = (unsigned char) (val & 0xFF);
if (val < 0 || val > 255) {
g_warning ("%s: %s / %s ignoring invalid byte element '%d' (not "
" between 0 and 255 inclusive)", __func__, setting_name,
key, val);
} else
g_byte_array_append (array, (const unsigned char *) &v, sizeof (v));
}
g_free (tmp_list);
done:
if (array->len == ETH_ALEN) {
g_object_set (setting, key, array, NULL);
} else {
g_warning ("%s: ignoring invalid MAC address for %s / %s",
__func__, setting_name, key);
}
g_byte_array_free (array, TRUE);
}
static GByteArray *mod_loadfile(struct decoder *decoder, struct input_stream *is)
{
unsigned char *data;
GByteArray *bdatas;
size_t ret;
if (is->size == 0) {
g_warning("file is empty");
return NULL;
}
if (is->size > MODPLUG_FILE_LIMIT) {
g_warning("file too large");
return NULL;
}
//known/unknown size, preallocate array, lets read in chunks
if (is->size > 0) {
bdatas = g_byte_array_sized_new(is->size);
} else {
bdatas = g_byte_array_sized_new(MODPLUG_PREALLOC_BLOCK);
}
data = g_malloc(MODPLUG_READ_BLOCK);
while (true) {
ret = decoder_read(decoder, is, data, MODPLUG_READ_BLOCK);
if (ret == 0) {
if (input_stream_lock_eof(is))
/* end of file */
break;
/* I/O error - skip this song */
g_free(data);
g_byte_array_free(bdatas, true);
return NULL;
}
if (bdatas->len + ret > MODPLUG_FILE_LIMIT) {
g_warning("stream too large\n");
g_free(data);
g_byte_array_free(bdatas, TRUE);
return NULL;
}
g_byte_array_append(bdatas, data, ret);
}
g_free(data);
return bdatas;
}
GByteArray *
namespace_info_marshall(namespace_info_t * namespace_info, const char *version, GError ** err)
{
asn_enc_rval_t encRet;
GByteArray *result = NULL;
NamespaceInfo_t asn1_namespace_info;
/*sanity checks */
if (!namespace_info) {
GSETERROR(err, "Invalid parameter");
goto error_params;
}
memset(&asn1_namespace_info, 0x00, sizeof(NamespaceInfo_t));
/* convert version to an int to easy compare */
// FIXME ugly piece of code!
gint64 versint64 = 0;
if(NULL != version) {
char *r = strchr(version,'.');
if(r) {
char tmp[256];
memset(tmp, '\0', 256);
g_snprintf(tmp, 256, "%.*s%s", (int)(r - version), version, r + 1);
versint64 = g_ascii_strtoll(tmp, NULL, 10);
TRACE("marshalling int64 : %"G_GINT64_FORMAT, versint64);
}
}
/*fills an ASN.1 structure */
if (!namespace_info_API2ASN(namespace_info, versint64, &asn1_namespace_info)) {
GSETERROR(err, "API to ASN.1 mapping error");
goto error_mapping;
}
/*serialize the ASN.1 structure */
if (!(result = g_byte_array_sized_new(4096))) {
GSETERROR(err, "memory allocation failure");
goto error_alloc_gba;
}
encRet = der_encode(&asn_DEF_NamespaceInfo, &asn1_namespace_info, write_in_gba, result);
if (encRet.encoded == -1) {
GSETERROR(err, "ASN.1 encoding error");
goto error_encode;
}
/*free the ASN.1 structure */
namespace_info_cleanASN(&asn1_namespace_info, TRUE);
return result;
error_encode:
g_byte_array_free(result, TRUE);
error_alloc_gba:
error_mapping:
namespace_info_cleanASN(&asn1_namespace_info, TRUE);
error_params:
return NULL;
}
static void
state_read_buffer (GcrImporter *self, gboolean async)
{
GError *error = NULL;
gssize count;
gsize at;
g_assert (GCR_IS_IMPORTER (self));
g_assert (G_IS_INPUT_STREAM (self->pv->input));
if (!self->pv->buffer)
self->pv->buffer = g_byte_array_sized_new (BLOCK);
at = self->pv->buffer->len;
g_byte_array_set_size (self->pv->buffer, at + BLOCK);
if (async) {
g_input_stream_read_async (self->pv->input, self->pv->buffer->data + at,
BLOCK, G_PRIORITY_DEFAULT, self->pv->cancel,
on_read_buffer, self);
} else {
count = g_input_stream_read (self->pv->input, self->pv->buffer->data + at,
BLOCK, self->pv->cancel, &error);
complete_read_buffer (self, count, error);
}
}
/**
* mongo_bson_new_from_data:
* @buffer: (in): The buffer to create a #MongoBson.
* @length: (in): The length of @buffer.
*
* Creates a new #MongoBson instance using the buffer and the length.
*
* Returns: A new #MongoBson that should be freed with mongo_bson_unref().
*/
MongoBson *
mongo_bson_new_from_data (const guint8 *buffer,
gsize length)
{
MongoBson *bson;
guint32 bson_len;
g_return_val_if_fail(buffer != NULL, NULL);
/*
* The first 4 bytes of a BSON are the length, including the 4 bytes
* containing said length.
*/
memcpy(&bson_len, buffer, sizeof bson_len);
bson_len = GUINT32_FROM_LE(bson_len);
if (bson_len != length) {
return NULL;
}
bson = g_slice_new0(MongoBson);
bson->ref_count = 1;
bson->buf = g_byte_array_sized_new(length);
g_byte_array_append(bson->buf, buffer, length);
return bson;
}
static void
test_content_dedup(gconstpointer test_data)
{
guint num_duplicates = *(guint*)test_data;
void change_chunk_hash(GSList *beans, guint start) {
guint8 counter = start;
for (GSList *cursor = beans;
cursor;
cursor = cursor->next) {
if (DESCR(cursor->data) == &descr_struct_CHUNKS) {
GByteArray *hash = CHUNKS_get_hash(cursor->data);
hash->data[0] = counter;
CHUNKS_set_hash(cursor->data, hash); // no-op because same pointer
counter++;
} else if (DESCR(cursor->data) == &descr_struct_CONTENTS_HEADERS) {
GByteArray *hash = g_byte_array_sized_new(16);
GRID_INFO("---- forging content hash ----");
for (guint8 i = 0; i < 16; i++) {
hash->data[i] = i + 1;
}
CONTENTS_HEADERS_set_hash(cursor->data, hash);
}
}
}
static GByteArray *
get_duid (NMDHCPClient *self)
{
static GByteArray *duid = NULL;
GByteArray *copy = NULL;
char *escaped;
if (G_UNLIKELY (duid == NULL)) {
duid = generate_duid_from_machine_id ();
g_assert (duid);
if (nm_logging_level_enabled (LOGL_DEBUG)) {
escaped = escape_duid (duid);
nm_log_dbg (LOGD_DHCP6, "Generated DUID %s", escaped);
g_free (escaped);
}
}
if (G_LIKELY (duid)) {
copy = g_byte_array_sized_new (duid->len);
g_byte_array_append (copy, duid->data, duid->len);
}
return copy;
}
static void
g_unix_socket_address_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GUnixSocketAddress *address = G_UNIX_SOCKET_ADDRESS (object);
GByteArray *array;
switch (prop_id)
{
case PROP_PATH:
g_value_set_string (value, address->priv->path);
break;
case PROP_PATH_AS_ARRAY:
array = g_byte_array_sized_new (address->priv->path_len);
g_byte_array_append (array, (guint8 *)address->priv->path, address->priv->path_len);
g_value_take_boxed (value, array);
break;
case PROP_ABSTRACT:
g_value_set_boolean (value, address->priv->abstract);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
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;
}
bool Coder<WebCore::CertificateInfo>::decode(Decoder& decoder, WebCore::CertificateInfo& certificateInfo)
{
bool hasCertificate;
if (!decoder.decode(hasCertificate))
return false;
if (!hasCertificate)
return true;
uint64_t size = 0;
if (!decoder.decode(size))
return false;
Vector<uint8_t> vector(size);
if (!decoder.decodeFixedLengthData(vector.data(), vector.size()))
return false;
GByteArray* certificateData = g_byte_array_sized_new(vector.size());
certificateData = g_byte_array_append(certificateData, vector.data(), vector.size());
GRefPtr<GByteArray> certificateBytes = adoptGRef(certificateData);
GTlsBackend* backend = g_tls_backend_get_default();
GRefPtr<GTlsCertificate> certificate = adoptGRef(G_TLS_CERTIFICATE(g_initable_new(
g_tls_backend_get_certificate_type(backend), 0, 0, "certificate", certificateBytes.get(), nullptr)));
certificateInfo.setCertificate(certificate.get());
uint32_t tlsErrors;
if (!decoder.decode(tlsErrors))
return false;
certificateInfo.setTLSErrors(static_cast<GTlsCertificateFlags>(tlsErrors));
return true;
}
static void interleaved_read_tcp_cb( struct ev_loop *loop, ev_io *w,
int revents)
{
GByteArray *pkt;
uint16_t ne_n;
char buffer[RTSP_BUFFERSIZE + 1];
RTSP_interleaved_channel *intlvd = w->data;
RTSP_Client *rtsp = intlvd->local->data;
int n;
if ((n = Sock_read(intlvd->local, buffer,
RTSP_BUFFERSIZE, NULL, MSG_DONTWAIT)) < 0) {
fnc_log(FNC_LOG_WARN, "Error reading from local socket\n");
return;
}
ne_n = htons((uint16_t)n);
pkt = g_byte_array_sized_new(n+4);
g_byte_array_set_size(pkt, n+4);
pkt->data[0] = '$';
pkt->data[1] = (uint8_t)intlvd->channel;
memcpy(&pkt->data[2], &ne_n, sizeof(ne_n));
memcpy(&pkt->data[4], buffer, n);
g_queue_push_head(rtsp->out_queue, pkt);
ev_io_start(rtsp->srv->loop, &rtsp->ev_io_write);
}
static void
reg_nwsnap_6800_cb (MMQcdmSerialPort *port,
GByteArray *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = user_data;
QcdmResult *result;
GByteArray *nwsnap;
if (error)
goto done;
/* Parse the response */
result = qcdm_cmd_nw_subsys_modem_snapshot_cdma_result ((const char *) response->data, response->len, NULL);
if (!result) {
/* 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_qcdm_serial_port_queue_command (port, nwsnap, 3, reg_nwsnap_6500_cb, info);
return;
}
parse_modem_snapshot (info, result);
qcdm_result_unref (result);
done:
mm_callback_info_schedule (info);
}
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);
}
bool ArgumentCoder<CertificateInfo>::decode(ArgumentDecoder& decoder, CertificateInfo& certificateInfo)
{
bool hasCertificate;
if (!decoder.decode(hasCertificate))
return false;
if (!hasCertificate)
return true;
IPC::DataReference certificateDataReference;
if (!decoder.decodeVariableLengthByteArray(certificateDataReference))
return false;
GByteArray* certificateData = g_byte_array_sized_new(certificateDataReference.size());
certificateData = g_byte_array_append(certificateData, certificateDataReference.data(), certificateDataReference.size());
GRefPtr<GByteArray> certificateBytes = adoptGRef(certificateData);
GTlsBackend* backend = g_tls_backend_get_default();
GRefPtr<GTlsCertificate> certificate = adoptGRef(G_TLS_CERTIFICATE(g_initable_new(
g_tls_backend_get_certificate_type(backend), 0, 0, "certificate", certificateBytes.get(), nullptr)));
certificateInfo.setCertificate(certificate.get());
uint32_t tlsErrors;
if (!decoder.decode(tlsErrors))
return false;
certificateInfo.setTLSErrors(static_cast<GTlsCertificateFlags>(tlsErrors));
return true;
}
static void
get_hash_cb (gpointer key, gpointer value, gpointer user_data)
{
ConfigOption *opt = (ConfigOption *) value;
GValue *variant;
GByteArray *array;
variant = g_slice_new0 (GValue);
switch (opt->type) {
case TYPE_INT:
g_value_init (variant, G_TYPE_INT);
g_value_set_int (variant, atoi (opt->value));
break;
case TYPE_BYTES:
case TYPE_UTF8:
array = g_byte_array_sized_new (opt->len);
g_byte_array_append (array, (const guint8 *) opt->value, opt->len);
g_value_init (variant, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_set_boxed (variant, array);
g_byte_array_free (array, TRUE);
break;
case TYPE_KEYWORD:
case TYPE_STRING:
g_value_init (variant, G_TYPE_STRING);
g_value_set_string (variant, opt->value);
break;
default:
g_slice_free (GValue, variant);
return;
}
g_hash_table_insert ((GHashTable *) user_data, g_strdup (key), variant);
}
static GByteArray *
wifi_wext_get_ssid (WifiData *data)
{
WifiDataWext *wext = (WifiDataWext *) data;
struct iwreq wrq;
char ssid[IW_ESSID_MAX_SIZE + 2];
guint32 len;
GByteArray *array = NULL;
memset (ssid, 0, sizeof (ssid));
wrq.u.essid.pointer = (caddr_t) &ssid;
wrq.u.essid.length = sizeof (ssid);
wrq.u.essid.flags = 0;
strncpy (wrq.ifr_name, wext->parent.iface, IFNAMSIZ);
if (ioctl (wext->fd, SIOCGIWESSID, &wrq) < 0) {
nm_log_err (LOGD_HW | LOGD_WIFI, "(%s): couldn't get SSID: %d",
wext->parent.iface, errno);
return NULL;
}
len = wrq.u.essid.length;
if (nm_utils_is_empty_ssid ((guint8 *) ssid, len) == FALSE) {
array = g_byte_array_sized_new (len);
g_byte_array_append (array, (const guint8 *) ssid, len);
}
return array;
}
//Copy from ui/gtk/follow_udp.c
static gboolean
udp_queue_packet_data(void *tapdata, packet_info *pinfo,
epan_dissect_t *, const void *data)
{
follow_record_t *follow_record;
follow_info_t *follow_info = (follow_info_t *)tapdata;
tvbuff_t *next_tvb = (tvbuff_t *)data;
follow_record = g_new(follow_record_t,1);
follow_record->data = g_byte_array_sized_new(tvb_captured_length(next_tvb));
follow_record->data = g_byte_array_append(follow_record->data,
tvb_get_ptr(next_tvb, 0, -1),
tvb_captured_length(next_tvb));
follow_record->packet_num = pinfo->fd->num;
if (follow_info->client_port == 0) {
follow_info->client_port = pinfo->srcport;
copy_address(&follow_info->client_ip, &pinfo->src);
}
if (addresses_equal(&follow_info->client_ip, &pinfo->src) && follow_info->client_port == pinfo->srcport)
follow_record->is_server = FALSE;
else
follow_record->is_server = TRUE;
/* update stream counter */
follow_info->bytes_written[follow_record->is_server] += follow_record->data->len;
follow_info->payload = g_list_append(follow_info->payload, follow_record);
return FALSE;
}
static GByteArray *
at_command_to_byte_array (const char *command, gboolean is_raw, gboolean send_lf)
{
GByteArray *buf;
int cmdlen;
g_return_val_if_fail (command != NULL, NULL);
cmdlen = strlen (command);
buf = g_byte_array_sized_new (cmdlen + 4);
if (!is_raw) {
/* Make sure there's an AT in the front */
if (!g_str_has_prefix (command, "AT"))
g_byte_array_append (buf, (const guint8 *) "AT", 2);
}
g_byte_array_append (buf, (const guint8 *) command, cmdlen);
if (!is_raw) {
/* Make sure there's a trailing carriage return */
if ((cmdlen == 0) ||
(command[cmdlen - 1] != '\r' && (cmdlen == 1 || command[cmdlen - 2] != '\r')))
g_byte_array_append (buf, (const guint8 *) "\r", 1);
if (send_lf) {
/* Make sure there's a trailing line-feed */
if ((cmdlen == 0) ||
(command[cmdlen - 1] != '\n' && (cmdlen == 1 || command[cmdlen - 2] != '\n')))
g_byte_array_append (buf, (const guint8 *) "\n", 1);
}
}
return buf;
}
static void
query_registration_state (MMGenericCdma *cdma,
MMModemCdmaRegistrationState cur_cdma_state,
MMModemCdmaRegistrationState cur_evdo_state,
MMModemCdmaRegistrationStateFn callback,
gpointer user_data)
{
MMCallbackInfo *info;
MMQcdmSerialPort *port;
GByteArray *nwsnap;
info = mm_generic_cdma_query_reg_state_callback_info_new (cdma, cur_cdma_state, cur_evdo_state, callback, user_data);
port = mm_generic_cdma_get_best_qcdm_port (cdma, &info->error);
if (!port) {
mm_callback_info_schedule (info);
return;
}
/* 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_qcdm_serial_port_queue_command (port, nwsnap, 3, reg_nwsnap_6800_cb, info);
}
void
nm_ap_set_ssid (NMAccessPoint *ap, const GByteArray * ssid)
{
NMAccessPointPrivate *priv;
g_return_if_fail (NM_IS_AP (ap));
priv = NM_AP_GET_PRIVATE (ap);
if ((ssid == priv->ssid) && ssid == NULL)
return;
/* same SSID */
if ((ssid && priv->ssid) && (ssid->len == priv->ssid->len)) {
if (!memcmp (ssid->data, priv->ssid->data, ssid->len))
return;
}
if (priv->ssid) {
g_byte_array_free (priv->ssid, TRUE);
priv->ssid = NULL;
}
if (ssid) {
priv->ssid = g_byte_array_sized_new (ssid->len);
priv->ssid->len = ssid->len;
memcpy (priv->ssid->data, ssid->data, ssid->len);
}
g_object_notify (G_OBJECT (ap), NM_AP_SSID);
}
static void
mac_address_parser (NMSetting *setting, const char *key, GKeyFile *keyfile, const char *keyfile_path)
{
const char *setting_name = nm_setting_get_name (setting);
char *tmp_string = NULL, *p;
gint *tmp_list;
GByteArray *array = NULL;
gsize length;
int i, type;
p = tmp_string = g_key_file_get_string (keyfile, setting_name, key, NULL);
if (tmp_string) {
/* Look for enough ':' characters to signify a MAC address */
i = 0;
while (*p) {
if (*p == ':')
i++;
p++;
}
/* If we found enough it's probably a string-format MAC address */
type = nm_utils_hwaddr_type (i + 1);
if (type > 0)
array = nm_utils_hwaddr_atoba (tmp_string, type);
}
g_free (tmp_string);
if (array == NULL) {
/* Old format; list of ints */
tmp_list = g_key_file_get_integer_list (keyfile, setting_name, key, &length, NULL);
type = nm_utils_hwaddr_type (length);
if (type < 0) {
array = g_byte_array_sized_new (length);
for (i = 0; i < length; i++) {
int val = tmp_list[i];
const guint8 v = (guint8) (val & 0xFF);
if (val < 0 || val > 255) {
g_warning ("%s: %s / %s ignoring invalid byte element '%d' (not "
" between 0 and 255 inclusive)", __func__, setting_name,
key, val);
g_byte_array_free (array, TRUE);
array = NULL;
break;
}
g_byte_array_append (array, &v, 1);
}
}
g_free (tmp_list);
}
if (array) {
g_object_set (setting, key, array, NULL);
g_byte_array_free (array, TRUE);
} else {
g_warning ("%s: ignoring invalid MAC address for %s / %s",
__func__, setting_name, key);
}
}
static GByteArray *
generate_duid_from_machine_id (void)
{
GByteArray *duid;
char *contents = NULL;
GChecksum *sum;
guint8 buffer[32]; /* SHA256 digest size */
gsize sumlen = sizeof (buffer);
const guint16 duid_type = g_htons (4);
uuid_t uuid;
GRand *generator;
guint i;
gboolean success = FALSE;
/* Get the machine ID from /etc/machine-id; it's always in /etc no matter
* where our configured SYSCONFDIR is. Alternatively, it might be in
* LOCALSTATEDIR /lib/dbus/machine-id.
*/
if ( g_file_get_contents ("/etc/machine-id", &contents, NULL, NULL)
|| g_file_get_contents (LOCALSTATEDIR "/lib/dbus/machine-id", &contents, NULL, NULL)) {
contents = g_strstrip (contents);
success = machine_id_parse (contents, uuid);
if (success) {
/* Hash the machine ID so it's not leaked to the network */
sum = g_checksum_new (G_CHECKSUM_SHA256);
g_checksum_update (sum, (const guchar *) &uuid, sizeof (uuid));
g_checksum_get_digest (sum, buffer, &sumlen);
g_checksum_free (sum);
}
g_free (contents);
}
if (!success) {
nm_log_warn (LOGD_DHCP6, "Failed to read " SYSCONFDIR "/machine-id "
"or " LOCALSTATEDIR "/lib/dbus/machine-id to generate "
"DHCPv6 DUID; creating non-persistent random DUID.");
generator = g_rand_new ();
for (i = 0; i < sizeof (buffer) / sizeof (guint32); i++)
((guint32 *) buffer)[i] = g_rand_int (generator);
g_rand_free (generator);
}
/* Generate a DHCP Unique Identifier for DHCPv6 using the
* DUID-UUID method (see RFC 6355 section 4). Format is:
*
* u16: type (DUID-UUID = 4)
* u8[16]: UUID bytes
*/
duid = g_byte_array_sized_new (18);
g_byte_array_append (duid, (guint8 *) &duid_type, sizeof (duid_type));
/* Since SHA256 is 256 bits, but UUID is 128 bits, we just take the first
* 128 bits of the SHA256 as the DUID-UUID.
*/
g_byte_array_append (duid, buffer, 16);
return duid;
}
static GByteArray *
parse_pkcs8_key_file (const GByteArray *contents,
gboolean *out_encrypted,
GError **error)
{
GByteArray *key = NULL;
gsize start = 0, end = 0;
unsigned char *der = NULL;
guint8 save_end;
gsize length = 0;
const char *start_tag = NULL, *end_tag = NULL;
gboolean encrypted = FALSE;
/* Try encrypted first, decrypted next */
if (find_tag (PEM_PKCS8_ENC_KEY_BEGIN, contents, 0, &start)) {
start_tag = PEM_PKCS8_ENC_KEY_BEGIN;
end_tag = PEM_PKCS8_ENC_KEY_END;
encrypted = TRUE;
} else if (find_tag (PEM_PKCS8_DEC_KEY_BEGIN, contents, 0, &start)) {
start_tag = PEM_PKCS8_DEC_KEY_BEGIN;
end_tag = PEM_PKCS8_DEC_KEY_END;
encrypted = FALSE;
} else {
g_set_error_literal (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Failed to find expected PKCS#8 start tag."));
return NULL;
}
start += strlen (start_tag);
if (!find_tag (end_tag, contents, start, &end)) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Failed to find expected PKCS#8 end tag '%s'."),
end_tag);
return NULL;
}
/* g_base64_decode() wants a NULL-terminated string */
save_end = contents->data[end];
contents->data[end] = '\0';
der = g_base64_decode ((const char *) (contents->data + start), &length);
contents->data[end] = save_end;
if (der && length) {
key = g_byte_array_sized_new (length);
g_byte_array_append (key, der, length);
g_assert (key->len == length);
*out_encrypted = encrypted;
} else {
g_set_error_literal (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_DECODE_FAILED,
_("Failed to decode PKCS#8 private key."));
}
g_free (der);
return key;
}
static gpointer
_nm_ssid_copy (GByteArray *src)
{
GByteArray *dest;
dest = g_byte_array_sized_new (src->len);
g_byte_array_append (dest, src->data, src->len);
return dest;
}
bson *
bson_new_sized (gint32 size)
{
bson *b = g_new0 (bson, 1);
b->data = g_byte_array_sized_new (size + sizeof (gint32) + sizeof (guint8));
_bson_append_int32 (b, 0);
return b;
}
static gboolean
real_complete_connection (NMDevice *device,
NMConnection *connection,
const char *specific_object,
const GSList *existing_connections,
GError **error)
{
NMSettingOlpcMesh *s_mesh;
GByteArray *tmp;
s_mesh = (NMSettingOlpcMesh *) nm_connection_get_setting (connection, NM_TYPE_SETTING_OLPC_MESH);
if (!s_mesh) {
s_mesh = (NMSettingOlpcMesh *) nm_setting_olpc_mesh_new ();
nm_connection_add_setting (connection, NM_SETTING (s_mesh));
}
if (!nm_setting_olpc_mesh_get_ssid (s_mesh)) {
tmp = g_byte_array_sized_new (strlen (DEFAULT_SSID));
g_byte_array_append (tmp, (const guint8 *) DEFAULT_SSID, strlen (DEFAULT_SSID));
g_object_set (G_OBJECT (s_mesh), NM_SETTING_OLPC_MESH_SSID, tmp, NULL);
g_byte_array_free (tmp, TRUE);
}
if (!nm_setting_olpc_mesh_get_dhcp_anycast_address (s_mesh)) {
const guint8 anycast[ETH_ALEN] = { 0xC0, 0x27, 0xC0, 0x27, 0xC0, 0x27 };
tmp = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (tmp, anycast, sizeof (anycast));
g_object_set (G_OBJECT (s_mesh), NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, tmp, NULL);
g_byte_array_free (tmp, TRUE);
}
nm_utils_complete_generic (connection,
NM_SETTING_OLPC_MESH_SETTING_NAME,
existing_connections,
_("Mesh %d"),
NULL,
FALSE); /* No IPv6 by default */
return TRUE;
}
static void fastcgi_send_begin(fastcgi_connection *fcon) {
GByteArray *buf = g_byte_array_sized_new(16);
guint16 w;
stream_build_fcgi_record(buf, FCGI_BEGIN_REQUEST, fcon->requestid, 8);
w = htons(FCGI_RESPONDER);
g_byte_array_append(buf, (const guint8*) &w, sizeof(w));
l_byte_array_append_c(buf, 0); /* TODO: FCGI_KEEP_CONN */
append_padding(buf, 5);
li_chunkqueue_append_bytearr(fcon->fcgi_out, buf);
}
static gboolean
nm_supplicant_config_add_blob (NMSupplicantConfig *self,
const char *key,
GBytes *value,
const char *blobid,
GError **error)
{
NMSupplicantConfigPrivate *priv;
ConfigOption *old_opt;
ConfigOption *opt;
OptType type;
GByteArray *blob;
const guint8 *data;
gsize data_len;
g_return_val_if_fail (NM_IS_SUPPLICANT_CONFIG (self), FALSE);
g_return_val_if_fail (key != NULL, FALSE);
g_return_val_if_fail (value != NULL, FALSE);
g_return_val_if_fail (blobid != NULL, FALSE);
data = g_bytes_get_data (value, &data_len);
g_return_val_if_fail (data_len > 0, FALSE);
priv = NM_SUPPLICANT_CONFIG_GET_PRIVATE (self);
type = nm_supplicant_settings_verify_setting (key, (const char *) data, data_len);
if (type == TYPE_INVALID) {
g_set_error (error, NM_SUPPLICANT_ERROR, NM_SUPPLICANT_ERROR_CONFIG,
"key '%s' and/or its contained value is invalid", key);
return FALSE;
}
old_opt = (ConfigOption *) g_hash_table_lookup (priv->config, key);
if (old_opt) {
g_set_error (error, NM_SUPPLICANT_ERROR, NM_SUPPLICANT_ERROR_CONFIG,
"key '%s' already configured", key);
return FALSE;
}
blob = g_byte_array_sized_new (data_len);
g_byte_array_append (blob, data, data_len);
opt = g_slice_new0 (ConfigOption);
opt->value = g_strdup_printf ("blob://%s", blobid);
opt->len = strlen (opt->value);
opt->type = type;
nm_log_info (LOGD_SUPPLICANT, "Config: added '%s' value '%s'", key, opt->value);
g_hash_table_insert (priv->config, g_strdup (key), opt);
g_hash_table_insert (priv->blobs, g_strdup (blobid), blob);
return TRUE;
}
NmaBtDevice *
nma_bt_device_new (const char *bdaddr,
const char *alias,
const char *object_path,
gboolean has_pan,
gboolean has_dun)
{
NmaBtDevice *self;
GError *error = NULL;
g_return_val_if_fail (bdaddr != NULL, NULL);
g_return_val_if_fail (object_path != NULL, NULL);
self = (NmaBtDevice *) g_object_new (NMA_TYPE_BT_DEVICE,
NMA_BT_DEVICE_BDADDR, bdaddr,
NMA_BT_DEVICE_ALIAS, alias,
NMA_BT_DEVICE_OBJECT_PATH, object_path,
NMA_BT_DEVICE_HAS_PAN, has_pan,
NMA_BT_DEVICE_HAS_DUN, has_dun,
NULL);
if (self) {
NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
struct ether_addr *addr;
g_assert (priv->bdaddr);
g_assert (priv->object_path);
addr = ether_aton (priv->bdaddr);
if (!addr) {
g_warning ("%s: invalid Bluetooth address '%s'", __func__, priv->bdaddr);
g_object_unref (self);
return NULL;
}
priv->bdaddr_array = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (priv->bdaddr_array, (const guint8 *) addr->ether_addr_octet, ETH_ALEN);
priv->bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (error) {
g_warning ("%s: failed to connect to D-Bus: %s", __func__, error->message);
g_object_unref (self);
self = NULL;
}
priv->window_group = gtk_window_group_new ();
priv->settings = nm_remote_settings_new (priv->bus);
g_signal_connect (priv->settings,
NM_REMOTE_SETTINGS_CONNECTIONS_READ,
G_CALLBACK (connections_read),
self);
}
return self;
}
