diff --git a/modules/rampart-samples/policy/build.xml b/modules/rampart-samples/policy/build.xml
index ced89e2..e9f6dea 100644
--- a/modules/rampart-samples/policy/build.xml
+++ b/modules/rampart-samples/policy/build.xml
@@ -144,6 +144,7 @@
              dest="${endorsed.dir}/xercesImpl-2.9.1.jar" verbose="true"/>
     </target>
 
+
 	<target name="clean">
 		<delete dir="${build.dir}" />
 	</target>
diff --git a/modules/rampart-samples/policy/sample09/services.xml b/modules/rampart-samples/policy/sample09/services.xml
index b3de463..f3cf087 100644
--- a/modules/rampart-samples/policy/sample09/services.xml
+++ b/modules/rampart-samples/policy/sample09/services.xml
@@ -1,20 +1,22 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
- !
- ! Copyright 2006 The Apache Software Foundation.
- !
- ! Licensed under the Apache License, Version 2.0 (the "License");
- ! you may not use this file except in compliance with the License.
- ! You may obtain a copy of the License at
- !
- !      http://www.apache.org/licenses/LICENSE-2.0
- !
- ! Unless required by applicable law or agreed to in writing, software
- ! distributed under the License is distributed on an "AS IS" BASIS,
- ! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ! See the License for the specific language governing permissions and
- ! limitations under the License.
- !-->
+  ~ Licensed to the Apache Software Foundation (ASF) under one
+  ~ or more contributor license agreements. See the NOTICE file
+  ~ distributed with this work for additional information
+  ~ regarding copyright ownership. The ASF licenses this file
+  ~ to you under the Apache License, Version 2.0 (the
+  ~ "License"); you may not use this file except in compliance
+  ~ with the License. You may obtain a copy of the License at
+  ~
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied. See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
 <!-- services.xml for sample09 with different in,out policies -->
 <service>
     <operation name="echo">
diff --git a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/Client.java b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/Client.java
index a4d5666..62f3dcd 100644
--- a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/Client.java
+++ b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/Client.java
@@ -1,19 +1,21 @@
 /*
- * Copyright 2004,2005 The Apache Software Foundation.
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
-
 package org.apache.rampart.samples.policy.sample09;
 
 import org.apache.axiom.om.OMAbstractFactory;
diff --git a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/PWCBHandler.java b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/PWCBHandler.java
index dad5beb..2d62ae1 100644
--- a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/PWCBHandler.java
+++ b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/PWCBHandler.java
@@ -1,19 +1,21 @@
 /*
- * Copyright 2004,2005 The Apache Software Foundation.
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
-
 package org.apache.rampart.samples.policy.sample09;
 
 import org.apache.ws.security.WSPasswordCallback;
diff --git a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/SimpleService.java b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/SimpleService.java
index eb0747a..e1a56c4 100644
--- a/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/SimpleService.java
+++ b/modules/rampart-samples/policy/sample09/src/org/apache/rampart/samples/policy/sample09/SimpleService.java
@@ -1,22 +1,24 @@
 /*
- * Copyright  2003-2005 The Apache Software Foundation.
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
  *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 package org.apache.rampart.samples.policy.sample09;
+
 public class SimpleService {
-    
     public String echo(String arg) {
         return arg;
     }
