diff --git a/apps/routing/common/pom.xml b/apps/routing/common/pom.xml
index 5b14fcd..4199c52 100644
--- a/apps/routing/common/pom.xml
+++ b/apps/routing/common/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpConstants.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpConstants.java
index 0344b54..e7863b8 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpConstants.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpConstants.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpFrameDecoder.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpFrameDecoder.java
index d6c9d30..b14302e 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpFrameDecoder.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpFrameDecoder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpInfoService.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpInfoService.java
index 1fa303e..8fd0ee9 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpInfoService.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpInfoService.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpKeepalive.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpKeepalive.java
index 050a30f..ae19753 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpKeepalive.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpKeepalive.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpMessage.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpMessage.java
index cafbeb1..fb54e8b 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpMessage.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpMessage.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpNotification.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpNotification.java
index 0cf03a5..2891130 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpNotification.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpNotification.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpOpen.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpOpen.java
index e5d4821..195f970 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpOpen.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpOpen.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteEntry.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteEntry.java
index 15ac60c..87ef98d 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteEntry.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteEntry.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteSelector.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteSelector.java
index 96f3a92..1432360 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteSelector.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpRouteSelector.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSession.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSession.java
index 25623ac..b0b9900 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSession.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSession.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionInfo.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionInfo.java
index af3a41f..f7bb526 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionInfo.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionManager.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionManager.java
index a8cf5d8..a84830f 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionManager.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpSessionManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpUpdate.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpUpdate.java
index afde4d8..f3f3d89 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpUpdate.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/BgpUpdate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteEntry.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteEntry.java
index 20d1298..c7dd76b 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteEntry.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteEntry.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteUpdate.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteUpdate.java
index 07cb589..3b1fa7b 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteUpdate.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/RouteUpdate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/package-info.java b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/package-info.java
index d4b18ae..6d412ba 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/bgp/package-info.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/bgp/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddPeerCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddPeerCommand.java
index 8d89c45..a5e3600 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddPeerCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddPeerCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddSpeakerCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddSpeakerCommand.java
index 49fb4f4..ff5ef94 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddSpeakerCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/AddSpeakerCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpNeighborsListCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpNeighborsListCommand.java
index c7d6e1b..9a39cbf 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpNeighborsListCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpNeighborsListCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpRoutesListCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpRoutesListCommand.java
index e140c9b..7b61f7c 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpRoutesListCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpRoutesListCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpSpeakersListCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpSpeakersListCommand.java
index 2e4de6f..6f85c5e 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpSpeakersListCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/BgpSpeakersListCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemovePeerCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemovePeerCommand.java
index 204dfb7..7ce2456 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemovePeerCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemovePeerCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemoveSpeakerCommand.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemoveSpeakerCommand.java
index cba02b6..5594e17 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemoveSpeakerCommand.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/RemoveSpeakerCommand.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/cli/package-info.java b/apps/routing/common/src/main/java/org/onosproject/routing/cli/package-info.java
index fc50db3..b2cea0a 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/cli/package-info.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/cli/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/RoutingConfigurationImpl.java b/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/RoutingConfigurationImpl.java
index c41724f..b725192 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/RoutingConfigurationImpl.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/RoutingConfigurationImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/package-info.java b/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/package-info.java
index b7a9594..a1492d9 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/package-info.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/config/impl/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/impl/BgpSpeakerNeighbourHandler.java b/apps/routing/common/src/main/java/org/onosproject/routing/impl/BgpSpeakerNeighbourHandler.java
index b98b69a..7cd23bb 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/impl/BgpSpeakerNeighbourHandler.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/impl/BgpSpeakerNeighbourHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/impl/DirectHostManager.java b/apps/routing/common/src/main/java/org/onosproject/routing/impl/DirectHostManager.java
index 7356d95..46b3162 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/impl/DirectHostManager.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/impl/DirectHostManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/java/org/onosproject/routing/impl/package-info.java b/apps/routing/common/src/main/java/org/onosproject/routing/impl/package-info.java
index c1ecfc2..72561f7 100644
--- a/apps/routing/common/src/main/java/org/onosproject/routing/impl/package-info.java
+++ b/apps/routing/common/src/main/java/org/onosproject/routing/impl/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml
index 58e82f6..1692a1d 100644
--- a/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ b/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/AsPathTest.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/AsPathTest.java
index 8c567e0..570e6d6 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/AsPathTest.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/AsPathTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpRouteEntryTest.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpRouteEntryTest.java
index 5a05792..6e2f5ca 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpRouteEntryTest.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpRouteEntryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpSessionManagerTest.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpSessionManagerTest.java
index 9f9ad3c..2319d5e 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpSessionManagerTest.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/BgpSessionManagerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/PathSegmentTest.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/PathSegmentTest.java
index 8605161..ca2ff16 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/PathSegmentTest.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/PathSegmentTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/RouteEntryTest.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/RouteEntryTest.java
index 901d608..2873e6f 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/RouteEntryTest.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/RouteEntryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerChannelHandler.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerChannelHandler.java
index 5ce6462..affbcde 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerChannelHandler.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerChannelHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerFrameDecoder.java b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerFrameDecoder.java
index ef9f1d3..d208077 100644
--- a/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerFrameDecoder.java
+++ b/apps/routing/common/src/test/java/org/onosproject/routing/bgp/TestBgpPeerFrameDecoder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/cpr/pom.xml b/apps/routing/cpr/pom.xml
index fba17e5..645c39f 100644
--- a/apps/routing/cpr/pom.xml
+++ b/apps/routing/cpr/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/ControlPlaneRedirectManager.java b/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/ControlPlaneRedirectManager.java
index 17de391..d5392cb 100644
--- a/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/ControlPlaneRedirectManager.java
+++ b/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/ControlPlaneRedirectManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/package-info.java b/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/package-info.java
index b098961..48cf1e0 100644
--- a/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/package-info.java
+++ b/apps/routing/cpr/src/main/java/org/onosproject/routing/cpr/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/cpr/src/test/java/org/onosproject/routing/cpr/ControlPlaneRedirectManagerTest.java b/apps/routing/cpr/src/test/java/org/onosproject/routing/cpr/ControlPlaneRedirectManagerTest.java
index ffcce3b..6a6a3a8 100644
--- a/apps/routing/cpr/src/test/java/org/onosproject/routing/cpr/ControlPlaneRedirectManagerTest.java
+++ b/apps/routing/cpr/src/test/java/org/onosproject/routing/cpr/ControlPlaneRedirectManagerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fibinstaller/pom.xml b/apps/routing/fibinstaller/pom.xml
index 5a3cefb..f1d5dcc 100644
--- a/apps/routing/fibinstaller/pom.xml
+++ b/apps/routing/fibinstaller/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/FibInstaller.java b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/FibInstaller.java
index bbf2c36..df729f7 100644
--- a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/FibInstaller.java
+++ b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/FibInstaller.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java
index 669754d..479e6c7 100644
--- a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java
+++ b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/FibInstallerTest.java b/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/FibInstallerTest.java
index e00a029..365ee51 100644
--- a/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/FibInstallerTest.java
+++ b/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/FibInstallerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/pom.xml b/apps/routing/fpm/pom.xml
index 6561d90..b216228 100644
--- a/apps/routing/fpm/pom.xml
+++ b/apps/routing/fpm/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmFrameDecoder.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmFrameDecoder.java
index 479b4da..5c8f29b 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmFrameDecoder.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmFrameDecoder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmInfoService.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmInfoService.java
index cd24cc6..124a1e9 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmInfoService.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmInfoService.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmListener.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmListener.java
index 3092ae0..07efa1d 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmListener.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmManager.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmManager.java
index 9019960..79b4ea3 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmManager.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmPeer.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmPeer.java
index d9a11fc..e0f98bf 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmPeer.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmPeer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmSessionHandler.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmSessionHandler.java
index f6e982f..7a88fd1 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmSessionHandler.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/FpmSessionHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/FpmConnectionsList.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/FpmConnectionsList.java
index 5a398b8..c6805a2 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/FpmConnectionsList.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/FpmConnectionsList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/package-info.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/package-info.java
index 8c4812d..ee64e04 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/package-info.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/cli/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/package-info.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/package-info.java
index 1f4f1de..c879073 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/package-info.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/FpmHeader.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/FpmHeader.java
index 5bba9fb..8dbd35f 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/FpmHeader.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/FpmHeader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/Netlink.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/Netlink.java
index 79c23ab..6c3f578 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/Netlink.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/Netlink.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/NetlinkMessageType.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/NetlinkMessageType.java
index 0abb0bd..22e1fbf 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/NetlinkMessageType.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/NetlinkMessageType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttribute.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttribute.java
index cffb422..095e516 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttribute.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttribute.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDecoder.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDecoder.java
index f702c40..961c9a6 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDecoder.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDecoder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDst.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDst.java
index d12f14c..1590e90 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDst.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeDst.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeGateway.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeGateway.java
index 0f5d158..c22d556 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeGateway.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeGateway.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeOif.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeOif.java
index 28c4b32..f6a84d8 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeOif.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributeOif.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributePriority.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributePriority.java
index 8f324f9..a1abe97 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributePriority.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RouteAttributePriority.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtNetlink.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtNetlink.java
index f914f0c..71d9572 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtNetlink.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtNetlink.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtProtocol.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtProtocol.java
index de86394..4314c14 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtProtocol.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/RtProtocol.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/package-info.java b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/package-info.java
index fed7b1e..251e193 100644
--- a/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/package-info.java
+++ b/apps/routing/fpm/src/main/java/org/onosproject/routing/fpm/protocol/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-present Open Networking Laboratory
+ * Copyright 2017-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/apps/routing/fpm/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/routing/fpm/src/main/resources/OSGI-INF/blueprint/shell-config.xml
index fe6f8f5..3af7033 100644
--- a/apps/routing/fpm/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ b/apps/routing/fpm/src/main/resources/OSGI-INF/blueprint/shell-config.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/apps/routing/pom.xml b/apps/routing/pom.xml
index 55d7bc5..85aa197 100644
--- a/apps/routing/pom.xml
+++ b/apps/routing/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
