Merge "Uniform rethrowing of NDC exceptions."

jsharkey · Android (Google) Code Review · commit 7a1c428ed3de · 2011-12-01T13:27:38.000-08:00
diff --git a/services/java/com/android/server/NetworkManagementService.java b/services/java/com/android/server/NetworkManagementService.java
@@ -360,8 +360,7 @@ public String[] listInterfaces() {
         try {
             return mConnector.doListCommand("interface list", NetdResponseCode.InterfaceListResult);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Cannot communicate with native daemon to list interfaces");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -372,8 +371,7 @@ public InterfaceConfiguration getInterfaceConfig(String iface) {
         try {
             rsp = mConnector.doCommand("interface getcfg " + iface).get(0);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Cannot communicate with native daemon to get interface config");
+            throw e.rethrowAsParcelableException();
         }
         Slog.d(TAG, String.format("rsp <%s>", rsp));
 
@@ -436,8 +434,7 @@ public void setInterfaceConfig(String iface, InterfaceConfiguration cfg) {
         try {
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate with native daemon to interface setcfg - " + e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -465,8 +462,7 @@ public void setInterfaceIpv6PrivacyExtensions(String iface, boolean enable) {
         try {
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate with native daemon to set ipv6privacyextensions - " + e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -479,8 +475,7 @@ public void clearInterfaceAddresses(String iface) {
         try {
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate with native daemon to interface clearallips - " + e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -490,8 +485,7 @@ public void enableIpv6(String iface) {
         try {
             mConnector.doCommand(String.format("interface ipv6 %s enable", iface));
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for enabling ipv6");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -501,8 +495,7 @@ public void disableIpv6(String iface) {
         try {
             mConnector.doCommand(String.format("interface ipv6 %s disable", iface));
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for disabling ipv6");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -569,9 +562,7 @@ private void modifyRoute(String interfaceName, int action, RouteInfo route, Stri
         try {
             rsp = mConnector.doCommand(cmd.toString());
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate with native dameon to add routes - "
-                    + e);
+            throw e.rethrowAsParcelableException();
         }
 
         if (DBG) {
@@ -700,8 +691,7 @@ public boolean getIpForwardingEnabled() throws IllegalStateException{
         try {
             rsp = mConnector.doCommand("ipfwd status");
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate with native daemon to ipfwd status");
+            throw e.rethrowAsParcelableException();
         }
 
         for (String line : rsp) {
@@ -728,7 +718,7 @@ public void setIpForwardingEnabled(boolean enable) {
         try {
             mConnector.doCommand(String.format("ipfwd %sable", (enable ? "en" : "dis")));
         } catch (NativeDaemonConnectorException e) {
-            e.rethrowAsParcelableException();
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -745,7 +735,7 @@ public void startTethering(String[] dhcpRange) {
         try {
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Unable to communicate to native daemon");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -755,7 +745,7 @@ public void stopTethering() {
         try {
             mConnector.doCommand("tether stop");
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Unable to communicate to native daemon to stop tether");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -767,8 +757,7 @@ public boolean isTetheringStarted() {
         try {
             rsp = mConnector.doCommand("tether status");
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon to get tether status");
+            throw e.rethrowAsParcelableException();
         }
 
         for (String line : rsp) {
@@ -793,8 +782,7 @@ public void tetherInterface(String iface) {
         try {
             mConnector.doCommand("tether interface add " + iface);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for adding tether interface");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -804,8 +792,7 @@ public void untetherInterface(String iface) {
         try {
             mConnector.doCommand("tether interface remove " + iface);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for removing tether interface");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -816,8 +803,7 @@ public String[] listTetheredInterfaces() {
             return mConnector.doListCommand(
                     "tether interface list", NetdResponseCode.TetherInterfaceListResult);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for listing tether interfaces");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -832,8 +818,7 @@ public void setDnsForwarders(String[] dns) {
             try {
                 mConnector.doCommand(cmd);
             } catch (NativeDaemonConnectorException e) {
-                throw new IllegalStateException(
-                        "Unable to communicate to native daemon for setting tether dns");
+                throw e.rethrowAsParcelableException();
             }
         } catch (IllegalArgumentException e) {
             throw new IllegalStateException("Error resolving dns name", e);
@@ -847,8 +832,7 @@ public String[] getDnsForwarders() {
             return mConnector.doListCommand(
                     "tether dns list", NetdResponseCode.TetherDnsFwdTgtListResult);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for listing tether dns");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -874,7 +858,7 @@ private void modifyNat(String cmd, String internalInterface, String externalInte
         try {
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            e.rethrowAsParcelableException();
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -910,8 +894,7 @@ public String[] listTtys() {
         try {
             return mConnector.doListCommand("list_ttys", NetdResponseCode.TtyListResult);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Unable to communicate to native daemon for listing TTYs");
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -928,7 +911,7 @@ public void attachPppd(
         } catch (IllegalArgumentException e) {
             throw new IllegalStateException("Error resolving addr", e);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon to attach pppd", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -938,7 +921,7 @@ public void detachPppd(String tty) {
         try {
             mConnector.doCommand(String.format("pppd detach %s", tty));
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon to detach pppd", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -972,7 +955,7 @@ public void startAccessPoint(
             }
             mConnector.doCommand(String.format("softap startap"));
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon to start softap", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1003,7 +986,7 @@ public void wifiFirmwareReload(String wlanIface, String mode) {
         try {
             mConnector.doCommand(String.format("softap fwreload " + wlanIface + " " + mode));
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon ", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1016,8 +999,7 @@ public void stopAccessPoint(String wlanIface) {
             mConnector.doCommand("softap stop " + wlanIface);
             wifiFirmwareReload(wlanIface, "STA");
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon to stop soft AP",
-                    e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1036,8 +1018,7 @@ public void setAccessPoint(WifiConfiguration wifiConfig, String wlanIface, Strin
                 mConnector.doCommand(str);
             }
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon to set soft AP",
-                    e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1113,7 +1094,7 @@ public void setInterfaceQuota(String iface, long quotaBytes) {
                 mConnector.doCommand(command.toString());
                 mActiveQuotaIfaces.add(iface);
             } catch (NativeDaemonConnectorException e) {
-                throw new IllegalStateException("Error communicating to native daemon", e);
+                throw e.rethrowAsParcelableException();
             }
         }
     }
@@ -1142,8 +1123,7 @@ public void removeInterfaceQuota(String iface) {
                 // TODO: support quota shared across interfaces
                 mConnector.doCommand(command.toString());
             } catch (NativeDaemonConnectorException e) {
-                // TODO: include current iptables state
-                throw new IllegalStateException("Error communicating to native daemon", e);
+                throw e.rethrowAsParcelableException();
             }
         }
     }
@@ -1175,7 +1155,7 @@ public void setInterfaceAlert(String iface, long alertBytes) {
                 mConnector.doCommand(command.toString());
                 mActiveAlertIfaces.add(iface);
             } catch (NativeDaemonConnectorException e) {
-                throw new IllegalStateException("Error communicating to native daemon", e);
+                throw e.rethrowAsParcelableException();
             }
         }
     }
@@ -1202,7 +1182,7 @@ public void removeInterfaceAlert(String iface) {
                 mConnector.doCommand(command.toString());
                 mActiveAlertIfaces.remove(iface);
             } catch (NativeDaemonConnectorException e) {
-                throw new IllegalStateException("Error communicating to native daemon", e);
+                throw e.rethrowAsParcelableException();
             }
         }
     }
@@ -1221,7 +1201,7 @@ public void setGlobalAlert(long alertBytes) {
         try {
             mConnector.doCommand(command.toString());
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1257,7 +1237,7 @@ public void setUidNetworkRules(int uid, boolean rejectOnQuotaInterfaces) {
                     mUidRejectOnQuota.delete(uid);
                 }
             } catch (NativeDaemonConnectorException e) {
-                throw new IllegalStateException("Error communicating to native daemon", e);
+                throw e.rethrowAsParcelableException();
             }
         }
     }
@@ -1304,7 +1284,7 @@ private NetworkStats.Entry getNetworkStatsTethering(String ifaceIn, String iface
         try {
             rsp = mConnector.doCommand(command.toString()).get(0);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException("Error communicating to native daemon", e);
+            throw e.rethrowAsParcelableException();
         }
 
         final String[] tok = rsp.split(" ");
@@ -1349,7 +1329,7 @@ public void setInterfaceThrottle(String iface, int rxKbps, int txKbps) {
             mConnector.doCommand(String.format(
                     "interface setthrottle %s %d %d", iface, rxKbps, txKbps));
         } catch (NativeDaemonConnectorException e) {
-            Slog.e(TAG, "Error communicating with native daemon to set throttle", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1362,8 +1342,7 @@ private int getInterfaceThrottle(String iface, boolean rx) {
                         String.format("interface getthrottle %s %s", iface,
                                 (rx ? "rx" : "tx"))).get(0);
             } catch (NativeDaemonConnectorException e) {
-                Slog.e(TAG, "Error communicating with native daemon to getthrottle", e);
-                return -1;
+                throw e.rethrowAsParcelableException();
             }
 
             String[] tok = rsp.split(" ");
@@ -1410,8 +1389,7 @@ public void setDefaultInterfaceForDns(String iface) {
 
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Error communicating with native daemon to set default interface", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1430,8 +1408,7 @@ public void setDnsServersForInterface(String iface, String[] servers) {
         } catch (IllegalArgumentException e) {
             throw new IllegalStateException("Error setting dnsn for interface", e);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Error communicating with native daemon to set dns for interface", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1443,8 +1420,7 @@ public void flushDefaultDnsCache() {
 
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Error communicating with native deamon to flush default interface", e);
+            throw e.rethrowAsParcelableException();
         }
     }
 
@@ -1456,8 +1432,7 @@ public void flushInterfaceDnsCache(String iface) {
 
             mConnector.doCommand(cmd);
         } catch (NativeDaemonConnectorException e) {
-            throw new IllegalStateException(
-                    "Error communicating with native daemon to flush interface " + iface, e);
+            throw e.rethrowAsParcelableException();
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -360,8 +360,7 @@ public String[] listInterfaces() {`
`360`	`360`	`try {`
`361`	`361`	`return mConnector.doListCommand("interface list", NetdResponseCode.InterfaceListResult);`
`362`	`362`	`} catch (NativeDaemonConnectorException e) {`
`363`		`- throw new IllegalStateException(`
`364`		`- "Cannot communicate with native daemon to list interfaces");`
	`363`	`+ throw e.rethrowAsParcelableException();`
`365`	`364`	`}`
`366`	`365`	`}`
`367`	`366`
`@@ -372,8 +371,7 @@ public InterfaceConfiguration getInterfaceConfig(String iface) {`
`372`	`371`	`try {`
`373`	`372`	`rsp = mConnector.doCommand("interface getcfg " + iface).get(0);`
`374`	`373`	`} catch (NativeDaemonConnectorException e) {`
`375`		`- throw new IllegalStateException(`
`376`		`- "Cannot communicate with native daemon to get interface config");`
	`374`	`+ throw e.rethrowAsParcelableException();`
`377`	`375`	`}`
`378`	`376`	`Slog.d(TAG, String.format("rsp <%s>", rsp));`
`379`	`377`
`@@ -436,8 +434,7 @@ public void setInterfaceConfig(String iface, InterfaceConfiguration cfg) {`
`436`	`434`	`try {`
`437`	`435`	`mConnector.doCommand(cmd);`
`438`	`436`	`} catch (NativeDaemonConnectorException e) {`
`439`		`- throw new IllegalStateException(`
`440`		`- "Unable to communicate with native daemon to interface setcfg - " + e);`
	`437`	`+ throw e.rethrowAsParcelableException();`
`441`	`438`	`}`
`442`	`439`	`}`
`443`	`440`
`@@ -465,8 +462,7 @@ public void setInterfaceIpv6PrivacyExtensions(String iface, boolean enable) {`
`465`	`462`	`try {`
`466`	`463`	`mConnector.doCommand(cmd);`
`467`	`464`	`} catch (NativeDaemonConnectorException e) {`
`468`		`- throw new IllegalStateException(`
`469`		`- "Unable to communicate with native daemon to set ipv6privacyextensions - " + e);`
	`465`	`+ throw e.rethrowAsParcelableException();`
`470`	`466`	`}`
`471`	`467`	`}`
`472`	`468`
`@@ -479,8 +475,7 @@ public void clearInterfaceAddresses(String iface) {`
`479`	`475`	`try {`
`480`	`476`	`mConnector.doCommand(cmd);`
`481`	`477`	`} catch (NativeDaemonConnectorException e) {`
`482`		`- throw new IllegalStateException(`
`483`		`- "Unable to communicate with native daemon to interface clearallips - " + e);`
	`478`	`+ throw e.rethrowAsParcelableException();`
`484`	`479`	`}`
`485`	`480`	`}`
`486`	`481`
`@@ -490,8 +485,7 @@ public void enableIpv6(String iface) {`
`490`	`485`	`try {`
`491`	`486`	`mConnector.doCommand(String.format("interface ipv6 %s enable", iface));`
`492`	`487`	`} catch (NativeDaemonConnectorException e) {`
`493`		`- throw new IllegalStateException(`
`494`		`- "Unable to communicate to native daemon for enabling ipv6");`
	`488`	`+ throw e.rethrowAsParcelableException();`
`495`	`489`	`}`
`496`	`490`	`}`
`497`	`491`
`@@ -501,8 +495,7 @@ public void disableIpv6(String iface) {`
`501`	`495`	`try {`
`502`	`496`	`mConnector.doCommand(String.format("interface ipv6 %s disable", iface));`
`503`	`497`	`} catch (NativeDaemonConnectorException e) {`
`504`		`- throw new IllegalStateException(`
`505`		`- "Unable to communicate to native daemon for disabling ipv6");`
	`498`	`+ throw e.rethrowAsParcelableException();`
`506`	`499`	`}`
`507`	`500`	`}`
`508`	`501`
`@@ -569,9 +562,7 @@ private void modifyRoute(String interfaceName, int action, RouteInfo route, Stri`
`569`	`562`	`try {`
`570`	`563`	`rsp = mConnector.doCommand(cmd.toString());`
`571`	`564`	`} catch (NativeDaemonConnectorException e) {`
`572`		`- throw new IllegalStateException(`
`573`		`- "Unable to communicate with native dameon to add routes - "`
`574`		`- + e);`
	`565`	`+ throw e.rethrowAsParcelableException();`
`575`	`566`	`}`
`576`	`567`
`577`	`568`	`if (DBG) {`
`@@ -700,8 +691,7 @@ public boolean getIpForwardingEnabled() throws IllegalStateException{`
`700`	`691`	`try {`
`701`	`692`	`rsp = mConnector.doCommand("ipfwd status");`
`702`	`693`	`} catch (NativeDaemonConnectorException e) {`
`703`		`- throw new IllegalStateException(`
`704`		`- "Unable to communicate with native daemon to ipfwd status");`
	`694`	`+ throw e.rethrowAsParcelableException();`
`705`	`695`	`}`
`706`	`696`
`707`	`697`	`for (String line : rsp) {`
`@@ -728,7 +718,7 @@ public void setIpForwardingEnabled(boolean enable) {`
`728`	`718`	`try {`
`729`	`719`	`mConnector.doCommand(String.format("ipfwd %sable", (enable ? "en" : "dis")));`
`730`	`720`	`} catch (NativeDaemonConnectorException e) {`
`731`		`- e.rethrowAsParcelableException();`
	`721`	`+ throw e.rethrowAsParcelableException();`
`732`	`722`	`}`
`733`	`723`	`}`
`734`	`724`
`@@ -745,7 +735,7 @@ public void startTethering(String[] dhcpRange) {`
`745`	`735`	`try {`
`746`	`736`	`mConnector.doCommand(cmd);`
`747`	`737`	`} catch (NativeDaemonConnectorException e) {`
`748`		`- throw new IllegalStateException("Unable to communicate to native daemon");`
	`738`	`+ throw e.rethrowAsParcelableException();`
`749`	`739`	`}`
`750`	`740`	`}`
`751`	`741`
`@@ -755,7 +745,7 @@ public void stopTethering() {`
`755`	`745`	`try {`
`756`	`746`	`mConnector.doCommand("tether stop");`
`757`	`747`	`} catch (NativeDaemonConnectorException e) {`
`758`		`- throw new IllegalStateException("Unable to communicate to native daemon to stop tether");`
	`748`	`+ throw e.rethrowAsParcelableException();`
`759`	`749`	`}`
`760`	`750`	`}`
`761`	`751`
`@@ -767,8 +757,7 @@ public boolean isTetheringStarted() {`
`767`	`757`	`try {`
`768`	`758`	`rsp = mConnector.doCommand("tether status");`
`769`	`759`	`} catch (NativeDaemonConnectorException e) {`
`770`		`- throw new IllegalStateException(`
`771`		`- "Unable to communicate to native daemon to get tether status");`
	`760`	`+ throw e.rethrowAsParcelableException();`
`772`	`761`	`}`
`773`	`762`
`774`	`763`	`for (String line : rsp) {`
`@@ -793,8 +782,7 @@ public void tetherInterface(String iface) {`
`793`	`782`	`try {`
`794`	`783`	`mConnector.doCommand("tether interface add " + iface);`
`795`	`784`	`} catch (NativeDaemonConnectorException e) {`
`796`		`- throw new IllegalStateException(`
`797`		`- "Unable to communicate to native daemon for adding tether interface");`
	`785`	`+ throw e.rethrowAsParcelableException();`
`798`	`786`	`}`
`799`	`787`	`}`
`800`	`788`
`@@ -804,8 +792,7 @@ public void untetherInterface(String iface) {`
`804`	`792`	`try {`
`805`	`793`	`mConnector.doCommand("tether interface remove " + iface);`
`806`	`794`	`} catch (NativeDaemonConnectorException e) {`
`807`		`- throw new IllegalStateException(`
`808`		`- "Unable to communicate to native daemon for removing tether interface");`
	`795`	`+ throw e.rethrowAsParcelableException();`
`809`	`796`	`}`
`810`	`797`	`}`
`811`	`798`
`@@ -816,8 +803,7 @@ public String[] listTetheredInterfaces() {`
`816`	`803`	`return mConnector.doListCommand(`
`817`	`804`	`"tether interface list", NetdResponseCode.TetherInterfaceListResult);`
`818`	`805`	`} catch (NativeDaemonConnectorException e) {`
`819`		`- throw new IllegalStateException(`
`820`		`- "Unable to communicate to native daemon for listing tether interfaces");`
	`806`	`+ throw e.rethrowAsParcelableException();`
`821`	`807`	`}`
`822`	`808`	`}`
`823`	`809`
`@@ -832,8 +818,7 @@ public void setDnsForwarders(String[] dns) {`
`832`	`818`	`try {`
`833`	`819`	`mConnector.doCommand(cmd);`
`834`	`820`	`} catch (NativeDaemonConnectorException e) {`
`835`		`- throw new IllegalStateException(`
`836`		`- "Unable to communicate to native daemon for setting tether dns");`
	`821`	`+ throw e.rethrowAsParcelableException();`
`837`	`822`	`}`
`838`	`823`	`} catch (IllegalArgumentException e) {`
`839`	`824`	`throw new IllegalStateException("Error resolving dns name", e);`
`@@ -847,8 +832,7 @@ public String[] getDnsForwarders() {`
`847`	`832`	`return mConnector.doListCommand(`
`848`	`833`	`"tether dns list", NetdResponseCode.TetherDnsFwdTgtListResult);`
`849`	`834`	`} catch (NativeDaemonConnectorException e) {`
`850`		`- throw new IllegalStateException(`
`851`		`- "Unable to communicate to native daemon for listing tether dns");`
	`835`	`+ throw e.rethrowAsParcelableException();`
`852`	`836`	`}`
`853`	`837`	`}`
`854`	`838`
`@@ -874,7 +858,7 @@ private void modifyNat(String cmd, String internalInterface, String externalInte`
`874`	`858`	`try {`
`875`	`859`	`mConnector.doCommand(cmd);`
`876`	`860`	`} catch (NativeDaemonConnectorException e) {`
`877`		`- e.rethrowAsParcelableException();`
	`861`	`+ throw e.rethrowAsParcelableException();`
`878`	`862`	`}`
`879`	`863`	`}`
`880`	`864`
`@@ -910,8 +894,7 @@ public String[] listTtys() {`
`910`	`894`	`try {`
`911`	`895`	`return mConnector.doListCommand("list_ttys", NetdResponseCode.TtyListResult);`
`912`	`896`	`} catch (NativeDaemonConnectorException e) {`
`913`		`- throw new IllegalStateException(`
`914`		`- "Unable to communicate to native daemon for listing TTYs");`
	`897`	`+ throw e.rethrowAsParcelableException();`
`915`	`898`	`}`
`916`	`899`	`}`
`917`	`900`
`@@ -928,7 +911,7 @@ public void attachPppd(`
`928`	`911`	`} catch (IllegalArgumentException e) {`
`929`	`912`	`throw new IllegalStateException("Error resolving addr", e);`
`930`	`913`	`} catch (NativeDaemonConnectorException e) {`
`931`		`- throw new IllegalStateException("Error communicating to native daemon to attach pppd", e);`
	`914`	`+ throw e.rethrowAsParcelableException();`
`932`	`915`	`}`
`933`	`916`	`}`
`934`	`917`
`@@ -938,7 +921,7 @@ public void detachPppd(String tty) {`
`938`	`921`	`try {`
`939`	`922`	`mConnector.doCommand(String.format("pppd detach %s", tty));`
`940`	`923`	`} catch (NativeDaemonConnectorException e) {`
`941`		`- throw new IllegalStateException("Error communicating to native daemon to detach pppd", e);`
	`924`	`+ throw e.rethrowAsParcelableException();`
`942`	`925`	`}`
`943`	`926`	`}`
`944`	`927`
`@@ -972,7 +955,7 @@ public void startAccessPoint(`
`972`	`955`	`}`
`973`	`956`	`mConnector.doCommand(String.format("softap startap"));`
`974`	`957`	`} catch (NativeDaemonConnectorException e) {`
`975`		`- throw new IllegalStateException("Error communicating to native daemon to start softap", e);`
	`958`	`+ throw e.rethrowAsParcelableException();`
`976`	`959`	`}`
`977`	`960`	`}`
`978`	`961`
`@@ -1003,7 +986,7 @@ public void wifiFirmwareReload(String wlanIface, String mode) {`
`1003`	`986`	`try {`
`1004`	`987`	`mConnector.doCommand(String.format("softap fwreload " + wlanIface + " " + mode));`
`1005`	`988`	`} catch (NativeDaemonConnectorException e) {`
`1006`		`- throw new IllegalStateException("Error communicating to native daemon ", e);`
	`989`	`+ throw e.rethrowAsParcelableException();`
`1007`	`990`	`}`
`1008`	`991`	`}`
`1009`	`992`
`@@ -1016,8 +999,7 @@ public void stopAccessPoint(String wlanIface) {`
`1016`	`999`	`mConnector.doCommand("softap stop " + wlanIface);`
`1017`	`1000`	`wifiFirmwareReload(wlanIface, "STA");`
`1018`	`1001`	`} catch (NativeDaemonConnectorException e) {`
`1019`		`- throw new IllegalStateException("Error communicating to native daemon to stop soft AP",`
`1020`		`- e);`
	`1002`	`+ throw e.rethrowAsParcelableException();`
`1021`	`1003`	`}`
`1022`	`1004`	`}`
`1023`	`1005`
`@@ -1036,8 +1018,7 @@ public void setAccessPoint(WifiConfiguration wifiConfig, String wlanIface, Strin`
`1036`	`1018`	`mConnector.doCommand(str);`
`1037`	`1019`	`}`
`1038`	`1020`	`} catch (NativeDaemonConnectorException e) {`
`1039`		`- throw new IllegalStateException("Error communicating to native daemon to set soft AP",`
`1040`		`- e);`
	`1021`	`+ throw e.rethrowAsParcelableException();`
`1041`	`1022`	`}`
`1042`	`1023`	`}`
`1043`	`1024`
`@@ -1113,7 +1094,7 @@ public void setInterfaceQuota(String iface, long quotaBytes) {`
`1113`	`1094`	`mConnector.doCommand(command.toString());`
`1114`	`1095`	`mActiveQuotaIfaces.add(iface);`
`1115`	`1096`	`} catch (NativeDaemonConnectorException e) {`
`1116`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1097`	`+ throw e.rethrowAsParcelableException();`
`1117`	`1098`	`}`
`1118`	`1099`	`}`
`1119`	`1100`	`}`
`@@ -1142,8 +1123,7 @@ public void removeInterfaceQuota(String iface) {`
`1142`	`1123`	`// TODO: support quota shared across interfaces`
`1143`	`1124`	`mConnector.doCommand(command.toString());`
`1144`	`1125`	`} catch (NativeDaemonConnectorException e) {`
`1145`		`- // TODO: include current iptables state`
`1146`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1126`	`+ throw e.rethrowAsParcelableException();`
`1147`	`1127`	`}`
`1148`	`1128`	`}`
`1149`	`1129`	`}`
`@@ -1175,7 +1155,7 @@ public void setInterfaceAlert(String iface, long alertBytes) {`
`1175`	`1155`	`mConnector.doCommand(command.toString());`
`1176`	`1156`	`mActiveAlertIfaces.add(iface);`
`1177`	`1157`	`} catch (NativeDaemonConnectorException e) {`
`1178`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1158`	`+ throw e.rethrowAsParcelableException();`
`1179`	`1159`	`}`
`1180`	`1160`	`}`
`1181`	`1161`	`}`
`@@ -1202,7 +1182,7 @@ public void removeInterfaceAlert(String iface) {`
`1202`	`1182`	`mConnector.doCommand(command.toString());`
`1203`	`1183`	`mActiveAlertIfaces.remove(iface);`
`1204`	`1184`	`} catch (NativeDaemonConnectorException e) {`
`1205`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1185`	`+ throw e.rethrowAsParcelableException();`
`1206`	`1186`	`}`
`1207`	`1187`	`}`
`1208`	`1188`	`}`
`@@ -1221,7 +1201,7 @@ public void setGlobalAlert(long alertBytes) {`
`1221`	`1201`	`try {`
`1222`	`1202`	`mConnector.doCommand(command.toString());`
`1223`	`1203`	`} catch (NativeDaemonConnectorException e) {`
`1224`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1204`	`+ throw e.rethrowAsParcelableException();`
`1225`	`1205`	`}`
`1226`	`1206`	`}`
`1227`	`1207`
`@@ -1257,7 +1237,7 @@ public void setUidNetworkRules(int uid, boolean rejectOnQuotaInterfaces) {`
`1257`	`1237`	`mUidRejectOnQuota.delete(uid);`
`1258`	`1238`	`}`
`1259`	`1239`	`} catch (NativeDaemonConnectorException e) {`
`1260`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1240`	`+ throw e.rethrowAsParcelableException();`
`1261`	`1241`	`}`
`1262`	`1242`	`}`
`1263`	`1243`	`}`
`@@ -1304,7 +1284,7 @@ private NetworkStats.Entry getNetworkStatsTethering(String ifaceIn, String iface`
`1304`	`1284`	`try {`
`1305`	`1285`	`rsp = mConnector.doCommand(command.toString()).get(0);`
`1306`	`1286`	`} catch (NativeDaemonConnectorException e) {`
`1307`		`- throw new IllegalStateException("Error communicating to native daemon", e);`
	`1287`	`+ throw e.rethrowAsParcelableException();`
`1308`	`1288`	`}`
`1309`	`1289`
`1310`	`1290`	`final String[] tok = rsp.split(" ");`
`@@ -1349,7 +1329,7 @@ public void setInterfaceThrottle(String iface, int rxKbps, int txKbps) {`
`1349`	`1329`	`mConnector.doCommand(String.format(`
`1350`	`1330`	`"interface setthrottle %s %d %d", iface, rxKbps, txKbps));`
`1351`	`1331`	`} catch (NativeDaemonConnectorException e) {`
`1352`		`- Slog.e(TAG, "Error communicating with native daemon to set throttle", e);`
	`1332`	`+ throw e.rethrowAsParcelableException();`
`1353`	`1333`	`}`
`1354`	`1334`	`}`
`1355`	`1335`
`@@ -1362,8 +1342,7 @@ private int getInterfaceThrottle(String iface, boolean rx) {`
`1362`	`1342`	`String.format("interface getthrottle %s %s", iface,`
`1363`	`1343`	`(rx ? "rx" : "tx"))).get(0);`
`1364`	`1344`	`} catch (NativeDaemonConnectorException e) {`
`1365`		`- Slog.e(TAG, "Error communicating with native daemon to getthrottle", e);`
`1366`		`- return -1;`
	`1345`	`+ throw e.rethrowAsParcelableException();`
`1367`	`1346`	`}`
`1368`	`1347`
`1369`	`1348`	`String[] tok = rsp.split(" ");`
`@@ -1410,8 +1389,7 @@ public void setDefaultInterfaceForDns(String iface) {`
`1410`	`1389`
`1411`	`1390`	`mConnector.doCommand(cmd);`
`1412`	`1391`	`} catch (NativeDaemonConnectorException e) {`
`1413`		`- throw new IllegalStateException(`
`1414`		`- "Error communicating with native daemon to set default interface", e);`
	`1392`	`+ throw e.rethrowAsParcelableException();`
`1415`	`1393`	`}`
`1416`	`1394`	`}`
`1417`	`1395`
`@@ -1430,8 +1408,7 @@ public void setDnsServersForInterface(String iface, String[] servers) {`
`1430`	`1408`	`} catch (IllegalArgumentException e) {`
`1431`	`1409`	`throw new IllegalStateException("Error setting dnsn for interface", e);`
`1432`	`1410`	`} catch (NativeDaemonConnectorException e) {`
`1433`		`- throw new IllegalStateException(`
`1434`		`- "Error communicating with native daemon to set dns for interface", e);`
	`1411`	`+ throw e.rethrowAsParcelableException();`
`1435`	`1412`	`}`
`1436`	`1413`	`}`
`1437`	`1414`
`@@ -1443,8 +1420,7 @@ public void flushDefaultDnsCache() {`
`1443`	`1420`
`1444`	`1421`	`mConnector.doCommand(cmd);`
`1445`	`1422`	`} catch (NativeDaemonConnectorException e) {`
`1446`		`- throw new IllegalStateException(`
`1447`		`- "Error communicating with native deamon to flush default interface", e);`
	`1423`	`+ throw e.rethrowAsParcelableException();`
`1448`	`1424`	`}`
`1449`	`1425`	`}`
`1450`	`1426`
`@@ -1456,8 +1432,7 @@ public void flushInterfaceDnsCache(String iface) {`
`1456`	`1432`
`1457`	`1433`	`mConnector.doCommand(cmd);`
`1458`	`1434`	`} catch (NativeDaemonConnectorException e) {`
`1459`		`- throw new IllegalStateException(`
`1460`		`- "Error communicating with native daemon to flush interface " + iface, e);`
	`1435`	`+ throw e.rethrowAsParcelableException();`
`1461`	`1436`	`}`
`1462`	`1437`	`}`
`1463`	`1438`