2005-04-02 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripng_interface.c: (ripng_interface_delete) After deleting, set
	  ifp->ifindex to IFINDEX_INTERNAL.

2005-01-30 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripng_interface.c: (ripng_multicast_join) Save errno before calling
	  ripngd_privs.change.

2005-01-04 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripngd.c: (ripng_recv_packet) Use ZCMSG_FIRSTHDR instead of
	  CMSG_FIRSTHDR.

2004-12-16 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripng_nexthop.c: Replace NEXTHOP_OUT macro with NEXTHOP_OUT_PTR,
	  since it's not really OK to take the address of a ternary expression.
	  (_ripng_rte_cmp,ripng_rte_send) Use new NEXTHOP_OUT_PTR macro
	  instead of NEXTHOP_OUT.

2004-12-08 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* *.c: Change level of debug messages to LOG_DEBUG.

2004-12-07 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripng_main.c: (main) The 2nd argument to openzlog has been removed.

2004-12-03 Andrew J. Schorr <ajschorr@alumni.princeton.edu>

	* ripng_main.c: (sighup) Remove spurious terminating message.
	  (sigint) Use zlog_notice for termination message.
	  (main) Issue a startup announcement using zlog_notice.

2004-11-25 Hasso Tepper <hasso at quagga.net>

	* ripng_main.c: Make group to run as configurable.

2004-10-26 Hasso Tepper <hasso at quagga.net>

	* ripng_debug.c: Fix help of "show debugging ripng" command.

2004-10-11 Hasso Tepper <hasso at quagga.net>

	* *.c: Make more strings const.

2004-10-08 Hasso Tepper <hasso at quagga.net>

	* *.[c|h]: Fix compiler warnings: make strings const, signed ->
	  unsigned etc.

2004-09-26 Hasso Tepper <hasso at quagga.net>

	* ripingd.c: Access list hook argument function must have struct
	  access_list * argument. Solution taken from ripd.
	* ripngd.c, ripnf_nexthop.c: Fix compiler warnings.

2004-09-23 Hasso Tepper <hasso at quagga.net>

	* *.[c|h]: list -> struct list *, listnode -> struct listnode *.

2004-09-17 Paul Jakma <paul@dishone.st>

	* ripngd.c: move setsockopt_so_recvbuf to lib.

2004-07-23  Hasso Tepper  <hasso@estpak.ee>

	* ripng_interface.c, ripng_nexthop.c: use ifp->mtu6 instead of
	  ifp->mtu.

2004-07-01  Greg Troxel  <gdt@fnord.ir.bbn.com>

	* ripng_interface.c (ripng_multicast_join): Use privs to do join,
	to work around bug on gif(4) on NetBSD 1.6.2.

2004-05-11 Paul Jakma <paul@dishone.st>

	* ripng_nexthop.h: SUNOS_5 does not define s6_addr32
	  catch ifndef(s6_addr32) && defined(SUNOS_5) and define
	  it ourselves based on the S10 _KERNEL guarded define.
	  
2004-05-08 Paul Jakma <paul@dishone.st>

	* ripng_{interface,zebra}.c: sync with zclient changes

2004-01-03  Greg Troxel  <gdt@ahi.ir.bbn.com>

	* ripng_interface.c (ripng_multicast_join): If IPV6_JOIN_GROUP
	returns EADDRINUSE, consider the join successful.  This happens
	when an interface goes down and comes back because
	ripng_multicast_leave does not invoke the LEAVE_GROUP operation if
	the interface is down.  Solves problem of ripng stopping working
	on an interface which goes down and then comes back up (on NetBSD).

2003-05-25 Hasso Tepper <hasso@estpak.ee>
  
  * Revert ripng_ifrmap stuff because ripd uses it now as well.
  * Merge ripngd part of 6Wind patch from Vincent Jardin 
    <vjardin@wanadoo.fr>.

2003-04-23 Hasso Tepper <hasso@estpak.ee>

	* {ripng_ifrmap,ripngd}.c: fix "router xxx" node commands in vtysh

2003-04-19 Hasso Tepper <hasso@estpak.ee>

	* rip_routemap.c: sync daemon's route-map commands to have same
	syntax

2002-07-07  Kunihiro Ishiguro  <kunihiro@ipinfusion.com>

	* zebra-0.93 released.

2001-08-28  NOGUCHI Kay <kay@v6.access.co.jp>

	* ripngd.c (no_ripng_route): route_unlock_node () is not needed.

2001-08-26  NOGUCHI Kay <kay@v6.access.co.jp>

	* ripngd.h (struct ripng_interface): Add passive interface option.

2001-08-19  Kunihiro Ishiguro  <kunihiro@ipinfusion.com>

	* zebra-0.92a released.

2001-08-15  Kunihiro Ishiguro  <kunihiro@ipinfusion.com>

	* zebra-0.92 released.

2001-08-07  Akira Kato <kato@wide.ad.jp>

	* ripngd.c (ripng_timers): "timers basic" argument is fixed.

2001-02-01  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* zebra-0.91 is released.

2001-01-09  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* zebra-0.90 is released.

2001-01-01  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.h (RIPNG_VTYSH_PATH): Change "/tmp/ripngd" to
	"/tmp/.ripngd".

2000-10-02  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* zebra-0.89 is released.

2000-09-20  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_send_packet): Use CMSG_SPACE instead of sizeof
	hack.  Revert privious alignment patch.

2000-09-20  URA Hiroshi <ura@hiru.aoba.yokohama.jp>

	* ripngd.c (ripng_send_packet): Fix an alignment bug. Thus ripngd
	can't send packets.

2000-09-10  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_interface.c (ripng_interface_address_delete): Connected
	address delete treatment added.

2000-08-22  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_routemap.c (route_set_metric_compile): When checking '-'
	character, argv[1] should be argv[0].  Reported by SHIRASAKI
	Yasuhiro <yasuhiro@ocn.v6.ntt.net>.

2000-08-17  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* zebra-0.88 is released.

2000-06-06  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_route_process): Clear prefix_ipv6 before using
	it.
	(ripng_redistribute_delete): Fix bug of missing
	route_unlock_node() when redistribute route is not found.
	(ripng_redistribute_delete): Make it sure that timers are off.
	(ripng_redistribute_delete): Likewise.

2000-01-19  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_route_process): Fix bug of mis-checking of same
	route.
	(show_ipv6_ripng): Include ifindex to "show ipv6 ripng" output.

1999-11-12  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_output_process): Use MINMTU when mtu value is
	not available.

1999-11-05  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_output_process): Calculate max RTE count from
	interface MTU value.

1999-09-29  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_distribute_update): Fix bug of updating
	access-list and prefix-list.

1999-09-07  URA Hiroshi <ura@hiru.aoba.yokohama.jp>

	* ripngd.c (ripng_recv_packet): Change CMSG_DATA cast from (u_char
	*) to (int *).  (u_char *) does not work for NetBSD-currnet on
	SparcStation 10.

1999-08-15  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_request_process): When request packet comes,
	check RIPng process is enabled on the interface.
	(ripng_redistribute_withdraw): Delete routes when `no
	redistribute' is executed.

1999-08-13  Yasuhiro Ohara  <yasu@sfc.wide.ad.jp>

	* ripng_zebra.c (ripng_redistribute_ospf6_cmd): Add OSPF6
	redistribute command.

1999-07-21  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (default_information_originate): Add
	default-information command.

1999-07-19  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_route_process): rip_add_route() and
	rip_delete_route() are deleted.  Both functions are integrated
	into ripng_route_process().
	(ripng_request_process): Proper reply for request message.

	* ripng_routemap.c: New file added.

1999-07-18  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_nexthop_rte): RIPng next hop routine is
	rewritten.
	(show_ipv6_ripng): Change `show ip ripng' to `show ipv6 ripng'.
	(ripng_response_process): RIPng incoming packet's hop count check
	added.
	(ripng_response_process): Add strict RTE checking.

1999-07-03  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_add_route): Fix metric compare bug.

1999-06-25  itojun@iijlab.net

	* ripngd.c (ripng_distribute_in): "distribute in" filter in ripngd
	actually work.

1999-05-25  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_zebra): Send each ripng information by separate
	zebra packet.

1999-05-15  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_interface.c (if_add_multicast): Change log to zlog.

1999-05-10  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_interface.c (ripng_zebra_get_interface): Add function.

	* ripng_zebra.c (redistribute_ripng): Delete function because
	redistirbute the routes to the zebra daemon is now default
	behavior.

1999-05-09  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.conf.sample: Change network to route statement.

1999-03-25  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c: Old non Advanced API version ripng_send_packet and
	ripng_recv_packet is removed.
	* ripng_radix.c: File removed.

1998-12-15  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* Now I assume KAME support Advanced API and use sendmsg/recvmsg.

1998-12-13  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_interface.c: Delete old ifa (interface address) related
	functions.

1998-12-10  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_debug.[ch]: New file.

	* ripngd.c (ripng_supply): Do not send header only RIPng packet.
	Change `network' statement to `route' statement.
	(ripng_request_process): Reply to RIPng REQUEST packet.

1998-12-09  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripngd.c (ripng_config_write): Delete vector v argument.
	* ripng_zebra.c (zebra_config_write): Likewise.
	* ripng_interface.c (interface_config_write): Likewise.

1998-12-07  Kunihiro Ishiguro  <kunihiro@zebra.org>

	* ripng_route.h: New file.

	* ripng_interface.c:  Delete #include <linux/in6.h>.
	ripng_main.c: likewise.
	ripng_radix.c: likewise.
	ripng_route.c: likewise.
	ripng_zebra.c: likewise.
	ripngd.c: likewise.

1998-12-06  Yasuhiro Ohara <yasu@sfc.wide.ad.jp>

	* ripngd.h (IPV6_ADD_MEMBERSHIP): If IPV6_ADD_MEMBERSHIP is not
	defined. Define IPV6_ADD_MEMBERSHIP as IPV6_JOIN_GROUP.

1998-09-15  HEO SeonMeyong  <seirios@matrix.iri.co.jp>

	* all Hydrangea define is changed to KAME.

