Add IPv6 support

.gitignore

@@ -0,0 +1,4 @@
+*.o
+_hgversion
+mdns-repeater
+mdns-repeater-*.zip

Makefile

@@ -24,7 +24,7 @@ CFLAGS+= -DHGVERSION="\"${HGVERSION}\""
 
 all: mdns-repeater
 
-mdns-repeater.o: _hgversion
+mdns-repeater.o: _hgversion list.h
 
 mdns-repeater: mdns-repeater.o
 

README.txt

@@ -1,18 +1,22 @@
 mdns-repeater
 ==============
 mdns-repeater is a Multicast DNS repeater for Linux. Multicast DNS uses the 
-224.0.0.251 address, which is "administratively scoped" and does not 
-leave the subnet.
+224.0.0.251 (IPv4) and ff02::fb (IPv6) addresses, which are "administratively
+scoped" and do not leave the subnet.
 
 This program re-broadcast mDNS packets from one interface to other interfaces.
 It was written primarily to be run on my Linksys WRT54G which runs dd-wrt,
 since my wireless network is on a different subnet from my wired network and 
 I would like my zeroconf devices to work properly across the two subnets.
 
-Since the mDNS protocol sends the AA records in the packet itself, the 
+Since the mDNS protocol sends the A records in the packet itself, the
 repeater does not need to forge the source address. Instead, the source 
 address is of the interface that repeats the packet.
 
+For IPv6, some devices send AAAA records containing a link-local address.
+The repeater does currently not change such records, meaning that hosts
+might be advertised with unreachable addresses.
+
 
 USAGE
 -----
@@ -32,6 +36,7 @@ long as you abide by the software license.
 LICENSE
 --------
 Copyright (C) 2011 Darell Tan
+Copyright (C) 2024 David Härdeman <david@hardeman.nu>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License

list.h

@@ -0,0 +1,155 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * This is the doubly linked list implementation taken from the Linux
+ * kernel (26 June 2020).
+ *
+ * The only modifications are the ones necessary to make it compile
+ * outside the kernel tree, and to remove some functions which are not
+ * necessary (like hlist*).
+ */
+
+#ifndef _LINUX_LIST_H
+#define _LINUX_LIST_H
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)
+
+#define container_of(ptr, type, member)                                        \
+	__extension__({                                                        \
+		const typeof(((type *)0)->member) *__mptr = (ptr);             \
+		(type *)((char *)__mptr - offsetof(type, member));             \
+	})
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+#define LIST_HEAD_INIT(name)                                                   \
+	{                                                                      \
+		&(name), &(name)                                               \
+	}
+
+#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)
+
+/**
+ * INIT_LIST_HEAD - Initialize a list_head structure
+ * @list: list_head structure to be initialized.
+ *
+ * Initializes the list_head to point to itself.  If it is a list header,
+ * the result is an empty list.
+ */
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+	list->next = list;
+	list->prev = list;
+}
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new, struct list_head *prev,
+			      struct list_head *next)
+{
+	next->prev = new;
+	new->next = next;
+	new->prev = prev;
+	prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head, head->next);
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty() on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+	entry->next->prev = entry->prev;
+	entry->prev->next = entry->next;
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(const struct list_head *head)
+{
+	return head->next == head;
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:	the &struct list_head pointer.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_head within the struct.
+ */
+#define list_entry(ptr, type, member) container_of(ptr, type, member)
+
+/**
+ * list_first_entry - get the first element from a list
+ * @ptr:	the list head to take the element from.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_head within the struct.
+ *
+ * Note, that list is expected to be not empty.
+ */
+#define list_first_entry(ptr, type, member)                                    \
+	list_entry((ptr)->next, type, member)
+
+/**
+ * list_next_entry - get the next element in list
+ * @pos:	the type * to cursor
+ * @member:	the name of the list_head within the struct.
+ */
+#define list_next_entry(pos, member)                                           \
+	list_entry((pos)->member.next, typeof(*(pos)), member)
+
+/**
+ * list_for_each_entry	-	iterate over list of given type
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_head within the struct.
+ */
+#define list_for_each_entry(pos, head, member)                                 \
+	for (pos = list_first_entry(head, typeof(*pos), member);               \
+	     &pos->member != (head); pos = list_next_entry(pos, member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against
+ * removal of list entry
+ * @pos:	the type * to use as a loop cursor.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_head within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member)                         \
+	for (pos = list_first_entry(head, typeof(*pos), member),               \
+	    n = list_next_entry(pos, member);                                  \
+	     &pos->member != (head); pos = n, n = list_next_entry(n, member))
+
+#endif