1/* //device/java/android/android/os/INetworkManagementService.aidl
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18package android.os;
19
20import android.net.InterfaceConfiguration;
21import android.net.INetworkManagementEventObserver;
22import android.net.Network;
23import android.net.NetworkStats;
24import android.net.RouteInfo;
25import android.net.UidRange;
26import android.net.wifi.WifiConfiguration;
27import android.os.INetworkActivityListener;
28
29/**
30 * @hide
31 */
32interface INetworkManagementService
33{
34    /**
35     ** GENERAL
36     **/
37
38    /**
39     * Register an observer to receive events
40     */
41    void registerObserver(INetworkManagementEventObserver obs);
42
43    /**
44     * Unregister an observer from receiving events.
45     */
46    void unregisterObserver(INetworkManagementEventObserver obs);
47
48    /**
49     * Returns a list of currently known network interfaces
50     */
51    String[] listInterfaces();
52
53    /**
54     * Retrieves the specified interface config
55     *
56     */
57    InterfaceConfiguration getInterfaceConfig(String iface);
58
59    /**
60     * Sets the configuration of the specified interface
61     */
62    void setInterfaceConfig(String iface, in InterfaceConfiguration cfg);
63
64    /**
65     * Clear all IP addresses on the specified interface
66     */
67    void clearInterfaceAddresses(String iface);
68
69    /**
70     * Set interface down
71     */
72    void setInterfaceDown(String iface);
73
74    /**
75     * Set interface up
76     */
77    void setInterfaceUp(String iface);
78
79    /**
80     * Set interface IPv6 privacy extensions
81     */
82    void setInterfaceIpv6PrivacyExtensions(String iface, boolean enable);
83
84    /**
85     * Disable IPv6 on an interface
86     */
87    void disableIpv6(String iface);
88
89    /**
90     * Enable IPv6 on an interface
91     */
92    void enableIpv6(String iface);
93
94    /**
95     * Enables or enables IPv6 ND offload.
96     */
97    void setInterfaceIpv6NdOffload(String iface, boolean enable);
98
99    /**
100     * Retrieves the network routes currently configured on the specified
101     * interface
102     */
103    RouteInfo[] getRoutes(String iface);
104
105    /**
106     * Add the specified route to the interface.
107     */
108    void addRoute(int netId, in RouteInfo route);
109
110    /**
111     * Remove the specified route from the interface.
112     */
113    void removeRoute(int netId, in RouteInfo route);
114
115    /**
116     * Set the specified MTU size
117     */
118    void setMtu(String iface, int mtu);
119
120    /**
121     * Shuts down the service
122     */
123    void shutdown();
124
125    /**
126     ** TETHERING RELATED
127     **/
128
129    /**
130     * Returns true if IP forwarding is enabled
131     */
132    boolean getIpForwardingEnabled();
133
134    /**
135     * Enables/Disables IP Forwarding
136     */
137    void setIpForwardingEnabled(boolean enabled);
138
139    /**
140     * Start tethering services with the specified dhcp server range
141     * arg is a set of start end pairs defining the ranges.
142     */
143    void startTethering(in String[] dhcpRanges);
144
145    /**
146     * Stop currently running tethering services
147     */
148    void stopTethering();
149
150    /**
151     * Returns true if tethering services are started
152     */
153    boolean isTetheringStarted();
154
155    /**
156     * Tethers the specified interface
157     */
158    void tetherInterface(String iface);
159
160    /**
161     * Untethers the specified interface
162     */
163    void untetherInterface(String iface);
164
165    /**
166     * Returns a list of currently tethered interfaces
167     */
168    String[] listTetheredInterfaces();
169
170    /**
171     * Sets the list of DNS forwarders (in order of priority)
172     */
173    void setDnsForwarders(in Network network, in String[] dns);
174
175    /**
176     * Returns the list of DNS forwarders (in order of priority)
177     */
178    String[] getDnsForwarders();
179
180    /**
181     * Enables unidirectional packet forwarding from {@code fromIface} to
182     * {@code toIface}.
183     */
184    void startInterfaceForwarding(String fromIface, String toIface);
185
186    /**
187     * Disables unidirectional packet forwarding from {@code fromIface} to
188     * {@code toIface}.
189     */
190    void stopInterfaceForwarding(String fromIface, String toIface);
191
192    /**
193     *  Enables Network Address Translation between two interfaces.
194     *  The address and netmask of the external interface is used for
195     *  the NAT'ed network.
196     */
197    void enableNat(String internalInterface, String externalInterface);
198
199    /**
200     *  Disables Network Address Translation between two interfaces.
201     */
202    void disableNat(String internalInterface, String externalInterface);
203
204    /**
205     ** PPPD
206     **/
207
208    /**
209     * Returns the list of currently known TTY devices on the system
210     */
211    String[] listTtys();
212
213    /**
214     * Attaches a PPP server daemon to the specified TTY with the specified
215     * local/remote addresses.
216     */
217    void attachPppd(String tty, String localAddr, String remoteAddr, String dns1Addr,
218            String dns2Addr);
219
220    /**
221     * Detaches a PPP server daemon from the specified TTY.
222     */
223    void detachPppd(String tty);
224
225    /**
226     * Load firmware for operation in the given mode. Currently the three
227     * modes supported are "AP", "STA" and "P2P".
228     */
229    void wifiFirmwareReload(String wlanIface, String mode);
230
231    /**
232     * Start Wifi Access Point
233     */
234    void startAccessPoint(in WifiConfiguration wifiConfig, String iface);
235
236    /**
237     * Stop Wifi Access Point
238     */
239    void stopAccessPoint(String iface);
240
241    /**
242     * Set Access Point config
243     */
244    void setAccessPoint(in WifiConfiguration wifiConfig, String iface);
245
246    /**
247     ** DATA USAGE RELATED
248     **/
249
250    /**
251     * Return global network statistics summarized at an interface level,
252     * without any UID-level granularity.
253     */
254    NetworkStats getNetworkStatsSummaryDev();
255    NetworkStats getNetworkStatsSummaryXt();
256
257    /**
258     * Return detailed network statistics with UID-level granularity,
259     * including interface and tag details.
260     */
261    NetworkStats getNetworkStatsDetail();
262
263    /**
264     * Return detailed network statistics for the requested UID,
265     * including interface and tag details.
266     */
267    NetworkStats getNetworkStatsUidDetail(int uid);
268
269    /**
270     * Return summary of network statistics all tethering interfaces.
271     */
272    NetworkStats getNetworkStatsTethering();
273
274    /**
275     * Set quota for an interface.
276     */
277    void setInterfaceQuota(String iface, long quotaBytes);
278
279    /**
280     * Remove quota for an interface.
281     */
282    void removeInterfaceQuota(String iface);
283
284    /**
285     * Set alert for an interface; requires that iface already has quota.
286     */
287    void setInterfaceAlert(String iface, long alertBytes);
288
289    /**
290     * Remove alert for an interface.
291     */
292    void removeInterfaceAlert(String iface);
293
294    /**
295     * Set alert across all interfaces.
296     */
297    void setGlobalAlert(long alertBytes);
298
299    /**
300     * Control network activity of a UID over interfaces with a quota limit.
301     */
302    void setUidNetworkRules(int uid, boolean rejectOnQuotaInterfaces);
303
304    void setUidCleartextNetworkPolicy(int uid, int policy);
305
306    /**
307     * Return status of bandwidth control module.
308     */
309    boolean isBandwidthControlEnabled();
310
311    /**
312     * Sets idletimer for an interface.
313     *
314     * This either initializes a new idletimer or increases its
315     * reference-counting if an idletimer already exists for given
316     * {@code iface}.
317     *
318     * {@code type} is the type of the interface, such as TYPE_MOBILE.
319     *
320     * Every {@code addIdleTimer} should be paired with a
321     * {@link removeIdleTimer} to cleanup when the network disconnects.
322     */
323    void addIdleTimer(String iface, int timeout, int type);
324
325    /**
326     * Removes idletimer for an interface.
327     */
328    void removeIdleTimer(String iface);
329
330    /**
331     * Bind name servers to a network in the DNS resolver.
332     */
333    void setDnsServersForNetwork(int netId, in String[] servers, String domains);
334
335    /**
336     * Flush the DNS cache associated with the specified network.
337     */
338    void flushNetworkDnsCache(int netId);
339
340    void setFirewallEnabled(boolean enabled);
341    boolean isFirewallEnabled();
342    void setFirewallInterfaceRule(String iface, boolean allow);
343    void setFirewallEgressSourceRule(String addr, boolean allow);
344    void setFirewallEgressDestRule(String addr, int port, boolean allow);
345    void setFirewallUidRule(int chain, int uid, int rule);
346    void setFirewallUidRules(int chain, in int[] uids, in int[] rules);
347    void setFirewallChainEnabled(int chain, boolean enable);
348
349    /**
350     * Set all packets from users in ranges to go through VPN specified by netId.
351     */
352    void addVpnUidRanges(int netId, in UidRange[] ranges);
353
354    /**
355     * Clears the special VPN rules for users in ranges and VPN specified by netId.
356     */
357    void removeVpnUidRanges(int netId, in UidRange[] ranges);
358
359    /**
360     * Start the clatd (464xlat) service on the given interface.
361     */
362    void startClatd(String interfaceName);
363
364    /**
365     * Stop the clatd (464xlat) service on the given interface.
366     */
367    void stopClatd(String interfaceName);
368
369    /**
370     * Determine whether the clatd (464xlat) service has been started on the given interface.
371     */
372    boolean isClatdStarted(String interfaceName);
373
374    /**
375     * Start listening for mobile activity state changes.
376     */
377    void registerNetworkActivityListener(INetworkActivityListener listener);
378
379    /**
380     * Stop listening for mobile activity state changes.
381     */
382    void unregisterNetworkActivityListener(INetworkActivityListener listener);
383
384    /**
385     * Check whether the mobile radio is currently active.
386     */
387    boolean isNetworkActive();
388
389    /**
390     * Setup a new physical network.
391     * @param permission null if no permissions required to access this network.  PERMISSION_NETWORK
392     *                   or PERMISSION_SYSTEM to set respective permission.
393     */
394    void createPhysicalNetwork(int netId, String permission);
395
396    /**
397     * Setup a new VPN.
398     */
399    void createVirtualNetwork(int netId, boolean hasDNS, boolean secure);
400
401    /**
402     * Remove a network.
403     */
404    void removeNetwork(int netId);
405
406    /**
407     * Add an interface to a network.
408     */
409    void addInterfaceToNetwork(String iface, int netId);
410
411    /**
412     * Remove an Interface from a network.
413     */
414    void removeInterfaceFromNetwork(String iface, int netId);
415
416    void addLegacyRouteForNetId(int netId, in RouteInfo routeInfo, int uid);
417
418    void setDefaultNetId(int netId);
419    void clearDefaultNetId();
420
421    /**
422     * Set permission for a network.
423     * @param permission null to clear permissions. PERMISSION_NETWORK or PERMISSION_SYSTEM to set
424     *                   permission.
425     */
426    void setNetworkPermission(int netId, String permission);
427
428    void setPermission(String permission, in int[] uids);
429    void clearPermission(in int[] uids);
430
431    /**
432     * Allow UID to call protect().
433     */
434    void allowProtect(int uid);
435
436    /**
437     * Deny UID from calling protect().
438     */
439    void denyProtect(int uid);
440
441    void addInterfaceToLocalNetwork(String iface, in List<RouteInfo> routes);
442    void removeInterfaceFromLocalNetwork(String iface);
443}
444