mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
455 lines
16 KiB
JavaScript
455 lines
16 KiB
JavaScript
/* Copyright 2012 Mozilla Foundation and Mozilla contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
if (!this.ctypes) {
|
|
// We're likely being loaded as a JSM.
|
|
this.EXPORTED_SYMBOLS = [ "libcutils", "libnetutils", "netHelpers" ];
|
|
Components.utils.import("resource://gre/modules/ctypes.jsm");
|
|
}
|
|
|
|
const SYSTEM_PROPERTY_KEY_MAX = 32;
|
|
const SYSTEM_PROPERTY_VALUE_MAX = 92;
|
|
|
|
// We leave this as 'undefined' instead of setting it to 'false'. That
|
|
// way a file that includes us can have it defined already without us
|
|
// overriding the value here.
|
|
let DEBUG;
|
|
|
|
/**
|
|
* Expose some system-level functions.
|
|
*/
|
|
this.libcutils = (function() {
|
|
let lib;
|
|
try {
|
|
lib = ctypes.open("libcutils.so");
|
|
} catch(ex) {
|
|
// Return a fallback option in case libcutils.so isn't present (e.g.
|
|
// when building Firefox with MOZ_B2G_RIL.
|
|
if (DEBUG) {
|
|
dump("Could not load libcutils.so. Using fake propdb.\n");
|
|
}
|
|
let fake_propdb = Object.create(null);
|
|
return {
|
|
property_get: function fake_property_get(key, defaultValue) {
|
|
if (key in fake_propdb) {
|
|
return fake_propdb[key];
|
|
}
|
|
return defaultValue === undefined ? null : defaultValue;
|
|
},
|
|
property_set: function fake_property_set(key, value) {
|
|
fake_propdb[key] = value;
|
|
}
|
|
};
|
|
}
|
|
|
|
let c_property_get = lib.declare("property_get", ctypes.default_abi,
|
|
ctypes.int, // return value: length
|
|
ctypes.char.ptr, // key
|
|
ctypes.char.ptr, // value
|
|
ctypes.char.ptr); // default
|
|
let c_property_set = lib.declare("property_set", ctypes.default_abi,
|
|
ctypes.int, // return value: success
|
|
ctypes.char.ptr, // key
|
|
ctypes.char.ptr); // value
|
|
let c_value_buf = ctypes.char.array(SYSTEM_PROPERTY_VALUE_MAX)();
|
|
|
|
return {
|
|
|
|
/**
|
|
* Get a system property.
|
|
*
|
|
* @param key
|
|
* Name of the property
|
|
* @param defaultValue [optional]
|
|
* Default value to return if the property isn't set (default: null)
|
|
*/
|
|
property_get: function property_get(key, defaultValue) {
|
|
if (defaultValue === undefined) {
|
|
defaultValue = null;
|
|
}
|
|
c_property_get(key, c_value_buf, defaultValue);
|
|
return c_value_buf.readString();
|
|
},
|
|
|
|
/**
|
|
* Set a system property
|
|
*
|
|
* @param key
|
|
* Name of the property
|
|
* @param value
|
|
* Value to set the property to.
|
|
*/
|
|
property_set: function property_set(key, value) {
|
|
let rv = c_property_set(key, value);
|
|
if (rv) {
|
|
throw Error('libcutils.property_set("' + key + '", "' + value +
|
|
'") failed with error ' + rv);
|
|
}
|
|
}
|
|
|
|
};
|
|
})();
|
|
|
|
/**
|
|
* Network-related functions from libnetutils.
|
|
*/
|
|
this.libnetutils = (function () {
|
|
let library;
|
|
try {
|
|
library = ctypes.open("libnetutils.so");
|
|
} catch(ex) {
|
|
if (DEBUG) {
|
|
dump("Could not load libnetutils.so!\n");
|
|
}
|
|
// For now we just fake the ctypes library interfacer to return
|
|
// no-op functions when library.declare() is called.
|
|
library = {
|
|
declare: function fake_declare() {
|
|
return function fake_libnetutils_function() {};
|
|
}
|
|
};
|
|
}
|
|
|
|
let iface = {
|
|
ifc_enable: library.declare("ifc_enable", ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
ifc_disable: library.declare("ifc_disable", ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
ifc_add_host_route: library.declare("ifc_add_host_route",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr,
|
|
ctypes.int),
|
|
ifc_remove_host_routes: library.declare("ifc_remove_host_routes",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
ifc_set_default_route: library.declare("ifc_set_default_route",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr,
|
|
ctypes.int),
|
|
ifc_get_default_route: library.declare("ifc_get_default_route",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
ifc_remove_default_route: library.declare("ifc_remove_default_route",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
ifc_configure: library.declare("ifc_configure", ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr,
|
|
ctypes.int,
|
|
ctypes.int,
|
|
ctypes.int,
|
|
ctypes.int,
|
|
ctypes.int),
|
|
ifc_add_route: library.declare("ifc_add_route", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.char.ptr, // dst
|
|
ctypes.int, // prefix_length
|
|
ctypes.char.ptr), // gw
|
|
ifc_remove_route: library.declare("ifc_remove_route", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.char.ptr, // dst
|
|
ctypes.int, // prefix_length
|
|
ctypes.char.ptr), // gw
|
|
dhcp_stop: library.declare("dhcp_stop", ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
dhcp_release_lease: library.declare("dhcp_release_lease", ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr),
|
|
dhcp_get_errmsg: library.declare("dhcp_get_errmsg", ctypes.default_abi,
|
|
ctypes.char.ptr),
|
|
|
|
// Constants for ifc_reset_connections.
|
|
// NOTE: Ignored in versions before ICS.
|
|
RESET_IPV4_ADDRESSES: 0x01,
|
|
RESET_IPV6_ADDRESSES: 0x02,
|
|
};
|
|
|
|
iface.RESET_ALL_ADDRESSES = iface.RESET_IPV4_ADDRESSES |
|
|
iface.RESET_IPV6_ADDRESSES
|
|
|
|
// dhcp_do_request's interface changed in SDK version 15. We try to hide
|
|
// this here by implementing the same JS API for both versions.
|
|
|
|
let sdkVersion = libcutils.property_get("ro.build.version.sdk") || "0";
|
|
sdkVersion = parseInt(sdkVersion, 10);
|
|
if (sdkVersion >= 15) {
|
|
let ipaddrbuf = ctypes.char.array(4096)();
|
|
let gatewaybuf = ctypes.char.array(4096)();
|
|
let prefixLen = ctypes.int();
|
|
let dns1buf = ctypes.char.array(4096)();
|
|
let dns2buf = ctypes.char.array(4096)();
|
|
let serverbuf = ctypes.char.array(4096)();
|
|
let lease = ctypes.int();
|
|
let vendorbuf = ctypes.char.array(4096)();
|
|
let c_dhcp_do_request;
|
|
|
|
// also changed for 16
|
|
if (sdkVersion >= 16) {
|
|
c_dhcp_do_request =
|
|
library.declare("dhcp_do_request", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.char.ptr, // ipaddr
|
|
ctypes.char.ptr, // gateway
|
|
ctypes.int.ptr, // prefixlen
|
|
ctypes.char.ptr, // dns1
|
|
ctypes.char.ptr, // dns2
|
|
ctypes.char.ptr, // server
|
|
ctypes.int.ptr, // lease
|
|
ctypes.char.ptr); // vendorinfo
|
|
} else {
|
|
c_dhcp_do_request =
|
|
library.declare("dhcp_do_request", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.char.ptr, // ipaddr
|
|
ctypes.char.ptr, // gateway
|
|
ctypes.int.ptr, // prefixlen
|
|
ctypes.char.ptr, // dns1
|
|
ctypes.char.ptr, // dns2
|
|
ctypes.char.ptr, // server
|
|
ctypes.int.ptr); // lease
|
|
}
|
|
|
|
|
|
iface.dhcp_do_request = function dhcp_do_request(ifname) {
|
|
let ret;
|
|
if (sdkVersion >= 16) {
|
|
ret = c_dhcp_do_request(ifname,
|
|
ipaddrbuf,
|
|
gatewaybuf,
|
|
prefixLen.address(),
|
|
dns1buf,
|
|
dns2buf,
|
|
serverbuf,
|
|
lease.address(),
|
|
vendorbuf);
|
|
} else {
|
|
ret = c_dhcp_do_request(ifname,
|
|
ipaddrbuf,
|
|
gatewaybuf,
|
|
prefixLen.address(),
|
|
dns1buf,
|
|
dns2buf,
|
|
serverbuf,
|
|
lease.address());
|
|
}
|
|
|
|
if (ret && DEBUG) {
|
|
let error = iface.dhcp_get_errmsg();
|
|
dump("dhcp_do_request failed - " + error.readString());
|
|
}
|
|
let obj = {
|
|
ret: ret | 0,
|
|
ipaddr_str: ipaddrbuf.readString(),
|
|
mask: netHelpers.makeMask(prefixLen.value),
|
|
gateway_str: gatewaybuf.readString(),
|
|
dns1_str: dns1buf.readString(),
|
|
dns2_str: dns2buf.readString(),
|
|
server_str: serverbuf.readString(),
|
|
lease: lease.value | 0,
|
|
vendor_str: vendorbuf.readString()
|
|
};
|
|
obj.ipaddr = netHelpers.stringToIP(obj.ipaddr_str);
|
|
obj.mask_str = netHelpers.ipToString(obj.mask);
|
|
obj.broadcast_str = netHelpers.ipToString((obj.ipaddr & obj.mask) + ~obj.mask);
|
|
obj.gateway = netHelpers.stringToIP(obj.gateway_str);
|
|
obj.dns1 = netHelpers.stringToIP(obj.dns1_str);
|
|
obj.dns2 = netHelpers.stringToIP(obj.dns2_str);
|
|
obj.server = netHelpers.stringToIP(obj.server_str);
|
|
return obj;
|
|
};
|
|
// dhcp_do_request_renew() went away in newer libnetutils.
|
|
iface.dhcp_do_request_renew = iface.dhcp_do_request;
|
|
|
|
// Same deal with ifc_reset_connections.
|
|
let c_ifc_reset_connections =
|
|
library.declare("ifc_reset_connections",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr,
|
|
ctypes.int);
|
|
iface.ifc_reset_connections = function(ifname, reset_mask) {
|
|
return c_ifc_reset_connections(ifname, reset_mask) | 0;
|
|
}
|
|
} else {
|
|
let ints = ctypes.int.array(8)();
|
|
let c_dhcp_do_request =
|
|
library.declare("dhcp_do_request", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.int.ptr, // ipaddr
|
|
ctypes.int.ptr, // gateway
|
|
ctypes.int.ptr, // mask
|
|
ctypes.int.ptr, // dns1
|
|
ctypes.int.ptr, // dns2
|
|
ctypes.int.ptr, // server
|
|
ctypes.int.ptr); // lease
|
|
let c_dhcp_do_request_renew =
|
|
library.declare("dhcp_do_request_renew", ctypes.default_abi,
|
|
ctypes.int, // return value
|
|
ctypes.char.ptr, // ifname
|
|
ctypes.int.ptr, // ipaddr
|
|
ctypes.int.ptr, // gateway
|
|
ctypes.int.ptr, // mask
|
|
ctypes.int.ptr, // dns1
|
|
ctypes.int.ptr, // dns2
|
|
ctypes.int.ptr, // server
|
|
ctypes.int.ptr); // lease
|
|
|
|
let wrapCFunc = function wrapCFunc(c_fn) {
|
|
return function (ifname) {
|
|
let ret = c_fn(ifname,
|
|
ints.addressOfElement(0),
|
|
ints.addressOfElement(1),
|
|
ints.addressOfElement(2),
|
|
ints.addressOfElement(3),
|
|
ints.addressOfElement(4),
|
|
ints.addressOfElement(5),
|
|
ints.addressOfElement(6));
|
|
if (ret && DEBUG) {
|
|
let error = iface.dhcp_get_errmsg();
|
|
dump("dhcp_do_request_* failed - " + error.readString());
|
|
}
|
|
return {ret: ret | 0,
|
|
ipaddr: ints[0] | 0,
|
|
gateway: ints[1] | 0,
|
|
mask: ints[2] | 0,
|
|
dns1: ints[3] | 0,
|
|
dns2: ints[4] | 0,
|
|
server: ints[5] | 0,
|
|
lease: ints[6] | 0};
|
|
};
|
|
};
|
|
iface.dhcp_do_request = wrapCFunc(c_dhcp_do_request);
|
|
iface.dhcp_do_request_renew = wrapCFunc(c_dhcp_do_request_renew);
|
|
let c_ifc_reset_connections =
|
|
library.declare("ifc_reset_connections",
|
|
ctypes.default_abi,
|
|
ctypes.int,
|
|
ctypes.char.ptr);
|
|
iface.ifc_reset_connections = function(ifname, reset_mask) {
|
|
return c_ifc_reset_connections(ifname) | 0;
|
|
}
|
|
}
|
|
|
|
return iface;
|
|
})();
|
|
|
|
/**
|
|
* Helpers for conversions.
|
|
*/
|
|
this.netHelpers = {
|
|
|
|
/**
|
|
* Swap byte orders for 32-bit value
|
|
*/
|
|
swap32: function swap32(n) {
|
|
return (((n >> 24) & 0xFF) << 0) |
|
|
(((n >> 16) & 0xFF) << 8) |
|
|
(((n >> 8) & 0xFF) << 16) |
|
|
(((n >> 0) & 0xFF) << 24);
|
|
},
|
|
|
|
/**
|
|
* Convert network byte order to host byte order
|
|
* Note: Assume that the system is little endian
|
|
*/
|
|
ntohl: function ntohl(n) {
|
|
return this.swap32(n);
|
|
},
|
|
|
|
/**
|
|
* Convert host byte order to network byte order
|
|
* Note: Assume that the system is little endian
|
|
*/
|
|
htonl: function htonl(n) {
|
|
return this.swap32(n);
|
|
},
|
|
|
|
/**
|
|
* Convert integer representation of an IP address to the string
|
|
* representation.
|
|
*
|
|
* @param ip
|
|
* IP address in number format.
|
|
*/
|
|
ipToString: function ipToString(ip) {
|
|
return ((ip >> 0) & 0xFF) + "." +
|
|
((ip >> 8) & 0xFF) + "." +
|
|
((ip >> 16) & 0xFF) + "." +
|
|
((ip >> 24) & 0xFF);
|
|
},
|
|
|
|
/**
|
|
* Convert string representation of an IP address to the integer
|
|
* representation.
|
|
*
|
|
* @param string
|
|
* String containing the IP address.
|
|
*/
|
|
stringToIP: function stringToIP(string) {
|
|
let ip = 0;
|
|
let start, end = -1;
|
|
for (let i = 0; i < 4; i++) {
|
|
start = end + 1;
|
|
end = string.indexOf(".", start);
|
|
if (end == -1) {
|
|
end = string.length;
|
|
}
|
|
let num = parseInt(string.slice(start, end), 10);
|
|
if (isNaN(num)) {
|
|
return null;
|
|
}
|
|
ip |= num << (i * 8);
|
|
}
|
|
return ip;
|
|
},
|
|
|
|
/**
|
|
* Make a subnet mask.
|
|
*/
|
|
makeMask: function makeMask(len) {
|
|
let mask = 0;
|
|
for (let i = 0; i < len; ++i) {
|
|
mask |= (0x80000000 >> i);
|
|
}
|
|
return this.ntohl(mask);
|
|
},
|
|
|
|
/**
|
|
* Get Mask length from given mask address
|
|
*/
|
|
getMaskLength: function getMaskLength(mask) {
|
|
let len = 0;
|
|
let netmask = this.ntohl(mask);
|
|
while (netmask & 0x80000000) {
|
|
len++;
|
|
netmask = netmask << 1;
|
|
}
|
|
return len;
|
|
}
|
|
};
|