diff --git a/ospfd/ChangeLog b/ospfd/ChangeLog
index 0a2b999..c80f3b6 100644
--- a/ospfd/ChangeLog
+++ b/ospfd/ChangeLog
@@ -1,3 +1,22 @@
+2006-12-12 Andrew J. Schorr <ajschorr@alumni.princeton.edu>
+
+	* ospf_interface.c: (ospf_if_is_configured, ospf_if_lookup_by_prefix,
+	  ospf_if_lookup_recv_if) Simplify logic using new CONNECTED_PREFIX
+	  macro.
+	* ospf_lsa.c: (lsa_link_ptop_set) Using the new CONNECTED_PREFIX
+	  macro, both options collapse into the same code.
+	* ospf_snmp.c: (ospf_snmp_if_update) Simplify logic using new
+	  CONNECTED_ID macro.
+	  (ospf_snmp_is_if_have_addr) Simplify logic using new CONNECTED_PREFIX
+	  macro.
+	* ospf_vty.c: (show_ip_ospf_interface_sub) Use new CONNECTED_PEER macro
+	  instead of testing the IFF_POINTOPOINT flag.
+	* ospfd.c: (ospf_network_match_iface) Use new CONNECTED_PEER macro
+	  instead of testing with if_is_pointopoint.  And add commented-out
+	  code to implement alternative (in my opinion) more elegant behavior
+	  that has no special-case treatment for PtP addresses.
+	  (ospf_network_run) Use new CONNECTED_ID macro to simplify logic.
+
 2006-12-04 Andrew J. Schorr <ajschorr@alumni.princeton.edu>
 
 	* ospfd.c: (ospf_network_run) Remove an offending 'break' statement.
