GByteArray* g_byte_array_prepend (GByteArray *array,
const guint8 *data,
guint len)
{
g_array_prepend_vals ((GArray*) array, (guint8*)data, len);
return array;
}
/* pack data with DefBuffer encoding */
static void build_buffer(GArray *array, uint8_t op)
{
GArray *data = build_alloc_array();
build_append_int(data, array->len);
g_array_prepend_vals(array, data->data, data->len);
build_free_array(data);
build_package(array, op);
}
void
gdk_wayland_selection_store (GdkWindow *window,
GdkAtom type,
GdkPropMode mode,
const guchar *data,
gint len)
{
GdkDisplay *display = gdk_window_get_display (window);
GdkWaylandSelection *selection = gdk_wayland_display_get_selection (display);
GArray *array;
if (type == gdk_atom_intern_static_string ("NULL"))
return;
array = g_array_new (TRUE, FALSE, sizeof (guchar));
g_array_append_vals (array, data, len);
if (selection->stored_selection.data)
{
if (mode != GDK_PROP_MODE_REPLACE &&
type != selection->stored_selection.type)
{
gchar *type_str, *stored_str;
type_str = gdk_atom_name (type);
stored_str = gdk_atom_name (selection->stored_selection.type);
g_warning (G_STRLOC ": Attempted to append/prepend selection data with "
"type %s into the current selection with type %s",
type_str, stored_str);
g_free (type_str);
g_free (stored_str);
return;
}
/* In these cases we also replace the stored data, so we
* apply the inverse operation into the just given data.
*/
if (mode == GDK_PROP_MODE_APPEND)
g_array_prepend_vals (array, selection->stored_selection.data,
selection->stored_selection.data_len - 1);
else if (mode == GDK_PROP_MODE_PREPEND)
g_array_append_vals (array, selection->stored_selection.data,
selection->stored_selection.data_len - 1);
g_free (selection->stored_selection.data);
}
selection->stored_selection.source = window;
selection->stored_selection.data_len = array->len;
selection->stored_selection.data = (guchar *) g_array_free (array, FALSE);
selection->stored_selection.type = type;
gdk_wayland_selection_check_write (selection);
}
int main(void) {
GArray *a = g_array_new(FALSE, FALSE, sizeof(int));
printf("Array is empty\n");
int x[2] = { 4, 5 };
g_array_append_vals(a, &x, 2);
print_array(a);
printf("Prepending values\n");
int y[2] = { 2, 3 };
g_array_prepend_vals(a, &y, 2);
print_array(a);
printf("Some more prepending\n");
int z = 1;
g_array_prepend_val(a, z);
print_array(a);
g_array_free(a, FALSE);
}
int main(int argc, char** argv) {
GArray* a = g_array_new(FALSE, FALSE, sizeof(int));
printf("Array is empty, so appending some values\n");
int x[2] = {4,5};
g_array_append_vals(a, &x, 2);
prt(a);
printf("Now to prepend some values\n");
int y[2] = {2,3};
g_array_prepend_vals(a, &y, 2);
prt(a);
printf("And one more prepend\n");
int z = 1;
g_array_prepend_val(a, z);
prt(a);
g_array_free(a, FALSE);
return 0;
}
void bios_linker_loader_alloc(GArray *linker,
const char *file,
uint32_t alloc_align,
bool alloc_fseg)
{
BiosLinkerLoaderEntry entry;
memset(&entry, 0, sizeof entry);
strncpy(entry.alloc.file, file, sizeof entry.alloc.file - 1);
entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE);
entry.alloc.align = cpu_to_le32(alloc_align);
entry.alloc.zone = cpu_to_le32(alloc_fseg ?
BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG :
BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH);
/* Alloc entries must come first, so prepend them */
g_array_prepend_vals(linker, &entry, sizeof entry);
}
/*
* bios_linker_loader_alloc: ask guest to load file into guest memory.
*
* @linker: linker object instance
* @file_name: name of the file blob to be loaded
* @file_blob: pointer to blob corresponding to @file_name
* @alloc_align: required minimal alignment in bytes. Must be a power of 2.
* @alloc_fseg: request allocation in FSEG zone (useful for the RSDP ACPI table)
*
* Note: this command must precede any other linker command using this file.
*/
void bios_linker_loader_alloc(BIOSLinker *linker,
const char *file_name,
GArray *file_blob,
uint32_t alloc_align,
bool alloc_fseg)
{
BiosLinkerLoaderEntry entry;
BiosLinkerFileEntry file = { g_strdup(file_name), file_blob};
assert(!(alloc_align & (alloc_align - 1)));
assert(!bios_linker_find_file(linker, file_name));
g_array_append_val(linker->file_list, file);
memset(&entry, 0, sizeof entry);
strncpy(entry.alloc.file, file_name, sizeof entry.alloc.file - 1);
entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE);
entry.alloc.align = cpu_to_le32(alloc_align);
entry.alloc.zone = alloc_fseg ? BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG :
BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH;
/* Alloc entries must come first, so prepend them */
g_array_prepend_vals(linker->cmd_blob, &entry, sizeof entry);
}
static gboolean
process_nduseropt_dnssl (NMIP6Device *device, struct nd_opt_hdr *opt)
{
size_t opt_len;
struct nd_opt_dnssl *dnssl_opt;
unsigned char *opt_ptr;
time_t now = time (NULL);
GArray *new_domains;
NMIP6DNSSL domain, *cur_domain;
gboolean changed;
guint i;
opt_len = opt->nd_opt_len;
if (opt_len < 2)
return FALSE;
dnssl_opt = (struct nd_opt_dnssl *) opt;
opt_ptr = (unsigned char *)(dnssl_opt + 1);
opt_len = (opt_len - 1) * 8; /* prefer bytes for later handling */
new_domains = g_array_new (FALSE, FALSE, sizeof (NMIP6DNSSL));
changed = FALSE;
/* Pad the DNS server expiry somewhat to give a bit of slack in cases
* where one RA gets lost or something (which can happen on unreliable
* links like wifi where certain types of frames are not retransmitted).
* Note that 0 has special meaning and is therefore not adjusted.
*/
domain.expires = ntohl (dnssl_opt->nd_opt_dnssl_lifetime);
if (domain.expires > 0)
domain.expires += now + 10;
while (opt_len) {
const char *domain_str;
domain_str = parse_dnssl_domain (opt_ptr, opt_len);
if (domain_str == NULL) {
nm_log_dbg (LOGD_IP6, "(%s): invalid DNSSL option, parsing aborted",
device->iface);
break;
}
/* The DNSSL encoding of domains happen to occupy the same size
* as the length of the resulting string, including terminating
* null. */
opt_ptr += strlen (domain_str) + 1;
opt_len -= strlen (domain_str) + 1;
/* Ignore empty domains. They're probably just padding... */
if (domain_str[0] == '\0')
continue;
/* Update cached domain information if we've seen this domain before */
for (i = 0; i < device->dnssl_domains->len; i++) {
cur_domain = &(g_array_index (device->dnssl_domains, NMIP6DNSSL, i));
if (strcmp (domain_str, cur_domain->domain) != 0)
continue;
cur_domain->expires = domain.expires;
if (domain.expires > 0) {
nm_log_dbg (LOGD_IP6, "(%s): refreshing RA-provided domain %s (expires in %ld seconds)",
device->iface, domain_str,
domain.expires - now);
break;
}
nm_log_dbg (LOGD_IP6, "(%s): removing RA-provided domain %s on router request",
device->iface, domain_str);
g_array_remove_index (device->dnssl_domains, i);
changed = TRUE;
break;
}
if (domain.expires == 0)
continue;
if (i < device->dnssl_domains->len)
continue;
nm_log_dbg (LOGD_IP6, "(%s): found RA-provided domain %s (expires in %ld seconds)",
device->iface, domain_str, domain.expires - now);
g_assert (strlen (domain_str) < sizeof (domain.domain));
strcpy (domain.domain, domain_str);
g_array_append_val (new_domains, domain);
}
/* New domains must be added in the order they are listed in the
* RA option and before any existing domains.
*
* Note: This is the place to remove domains if we want to cap the
* number of domains. The RFC states that the one to expire
* first of the existing domains should be removed.
*/
if (new_domains->len) {
g_array_prepend_vals (device->dnssl_domains,
new_domains->data, new_domains->len);
changed = TRUE;
}
g_array_free (new_domains, TRUE);
/* Timeouts may have changed even if domains didn't */
set_dnssl_timeout (device);
return changed;
}
static gboolean
process_nduseropt_rdnss (NMIP6Device *device, struct nd_opt_hdr *opt)
{
size_t opt_len;
struct nd_opt_rdnss *rdnss_opt;
time_t now = time (NULL);
struct in6_addr *addr;
GArray *new_servers;
NMIP6RDNSS server, *cur_server;
gboolean changed = FALSE;
guint i;
opt_len = opt->nd_opt_len;
if (opt_len < 3 || (opt_len & 1) == 0)
return FALSE;
rdnss_opt = (struct nd_opt_rdnss *) opt;
new_servers = g_array_new (FALSE, FALSE, sizeof (NMIP6RDNSS));
/* Pad the DNS server expiry somewhat to give a bit of slack in cases
* where one RA gets lost or something (which can happen on unreliable
* links like WiFi where certain types of frames are not retransmitted).
* Note that 0 has special meaning and is therefore not adjusted.
*/
server.expires = ntohl (rdnss_opt->nd_opt_rdnss_lifetime);
if (server.expires > 0)
server.expires += now + 10;
for (addr = (struct in6_addr *) (rdnss_opt + 1); opt_len >= 2; addr++, opt_len -= 2) {
char buf[INET6_ADDRSTRLEN + 1];
if (!inet_ntop (AF_INET6, addr, buf, sizeof (buf))) {
nm_log_warn (LOGD_IP6, "(%s): received invalid RA-provided nameserver", device->iface);
continue;
}
/* Update the cached timeout if we already saw this server */
for (i = 0; i < device->rdnss_servers->len; i++) {
cur_server = &(g_array_index (device->rdnss_servers, NMIP6RDNSS, i));
if (!IN6_ARE_ADDR_EQUAL (addr, &cur_server->addr))
continue;
cur_server->expires = server.expires;
if (server.expires > 0) {
nm_log_dbg (LOGD_IP6, "(%s): refreshing RA-provided nameserver %s (expires in %ld seconds)",
device->iface, buf,
server.expires - now);
break;
}
nm_log_dbg (LOGD_IP6, "(%s): removing RA-provided nameserver %s on router request",
device->iface, buf);
g_array_remove_index (device->rdnss_servers, i);
changed = TRUE;
break;
}
if (server.expires == 0)
continue;
if (i < device->rdnss_servers->len)
continue;
nm_log_dbg (LOGD_IP6, "(%s): found RA-provided nameserver %s (expires in %ld seconds)",
device->iface, buf, server.expires - now);
server.addr = *addr;
g_array_append_val (new_servers, server);
}
/* New servers must be added in the order they are listed in the
* RA option and before any existing servers.
*
* Note: This is the place to remove servers if we want to cap the
* number of resolvers. The RFC states that the one to expire
* first of the existing servers should be removed.
*/
if (new_servers->len) {
g_array_prepend_vals (device->rdnss_servers,
new_servers->data, new_servers->len);
changed = TRUE;
}
g_array_free (new_servers, TRUE);
/* Timeouts may have changed even if IPs didn't */
set_rdnss_timeout (device);
return changed;
}
static gboolean
panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
int *monitors_ret,
GdkRectangle **geometries_ret)
{
#ifdef HAVE_RANDR
Display *xdisplay;
Window xroot;
XRRScreenResources *resources;
RROutput primary;
GArray *geometries;
int i;
gboolean driver_is_pre_randr_1_2;
if (!have_randr)
return FALSE;
/* GTK+ 2.14.x uses the Xinerama API, instead of RANDR, to get the
* monitor geometries. It does this to avoid calling
* XRRGetScreenResources(), which is slow as it re-detects all the
* monitors --- note that XRRGetScreenResourcesCurrent() had not been
* introduced yet. Using Xinerama in GTK+ has the bad side effect that
* gdk_screen_get_monitor_plug_name() will return NULL, as Xinerama
* does not provide that information, unlike RANDR.
*
* Here we need to identify the output names, so that we can put the
* built-in LCD in a laptop *before* all other outputs. This is so
* that mate-panel will normally prefer to appear on the "native"
* display rather than on an external monitor.
*
* To get the output names and geometries, we will not use
* gdk_screen_get_n_monitors() and friends, but rather we will call
* XRR*() directly.
*
* See https://bugzilla.novell.com/show_bug.cgi?id=479684 for this
* particular bug, and and
* http://bugzilla.gnome.org/show_bug.cgi?id=562944 for a more
* long-term solution.
*/
xdisplay = GDK_SCREEN_XDISPLAY (screen);
#if GTK_CHECK_VERSION (3, 0, 0)
xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
#else
xroot = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
#endif
#if (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
if (have_randr_1_3) {
resources = XRRGetScreenResourcesCurrent (xdisplay, xroot);
if (resources->noutput == 0) {
/* This might happen if nothing tried to get randr
* resources from the server before, so we need an
* active probe. See comment #27 in
* https://bugzilla.gnome.org/show_bug.cgi?id=597101 */
XRRFreeScreenResources (resources);
resources = XRRGetScreenResources (xdisplay, xroot);
}
} else
resources = XRRGetScreenResources (xdisplay, xroot);
#else
resources = XRRGetScreenResources (xdisplay, xroot);
#endif
if (!resources)
return FALSE;
primary = None;
#if (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
if (have_randr_1_3)
primary = XRRGetOutputPrimary (xdisplay, xroot);
#endif
geometries = g_array_sized_new (FALSE, FALSE,
sizeof (GdkRectangle),
resources->noutput);
driver_is_pre_randr_1_2 = FALSE;
for (i = 0; i < resources->noutput; i++) {
XRROutputInfo *output;
output = XRRGetOutputInfo (xdisplay, resources,
resources->outputs[i]);
/* Drivers before RANDR 1.2 return "default" for the output
* name */
if (g_strcmp0 (output->name, "default") == 0)
driver_is_pre_randr_1_2 = TRUE;
if (output->connection != RR_Disconnected &&
output->crtc != 0) {
XRRCrtcInfo *crtc;
GdkRectangle rect;
crtc = XRRGetCrtcInfo (xdisplay, resources,
output->crtc);
rect.x = crtc->x;
rect.y = crtc->y;
rect.width = crtc->width;
rect.height = crtc->height;
XRRFreeCrtcInfo (crtc);
if (_panel_multiscreen_output_should_be_first (xdisplay,
resources->outputs[i],
output, primary))
g_array_prepend_vals (geometries, &rect, 1);
else
g_array_append_vals (geometries, &rect, 1);
}
XRRFreeOutputInfo (output);
}
XRRFreeScreenResources (resources);
if (driver_is_pre_randr_1_2) {
/* Drivers before RANDR 1.2 don't provide useful info about
* outputs */
g_array_free (geometries, TRUE);
return FALSE;
}
if (geometries->len == 0) {
/* This can happen in at least one case:
* https://bugzilla.novell.com/show_bug.cgi?id=543876 where all
* monitors appear disconnected (possibly because the screen
* is behing a KVM switch) -- see comment #8.
* There might be other cases too, so we stay on the safe side.
*/
g_array_free (geometries, TRUE);
return FALSE;
}
*monitors_ret = geometries->len;
*geometries_ret = (GdkRectangle *) g_array_free (geometries, FALSE);
return TRUE;
#else
return FALSE;
#endif
}
