8579 lines of KNF, ANSO and zap-junk diff without the resulting binary

changing by a single byte.
partly from theo

1 files changed, 169 insertions, 179 deletions

diff --git a/sbin/dhclient/dispatch.c b/sbin/dhclient/dispatch.c
index c92f1591c44..54ef5aba9e6 100644
--- a/sbin/dhclient/dispatch.c
+++ b/sbin/dhclient/dispatch.c
@@ -46,7 +46,6 @@
 #include <poll.h>
 #include <net/if_media.h>
 
-
 /* Most boxes has less than 16 interfaces, so this might be a good guess.  */
 #define INITIAL_IFREQ_COUNT 16
 
@@ -55,9 +54,9 @@ struct protocol *protocols;
 struct timeout *timeouts;
 static struct timeout *free_timeouts;
 static int interfaces_invalidated;
-void (*bootp_packet_handler) PROTO ((struct interface_info *,
-				     struct dhcp_packet *, int, unsigned int,
-				     struct iaddr, struct hardware *));
+void (*bootp_packet_handler)(struct interface_info *,
+     struct dhcp_packet *, int, unsigned int,
+     struct iaddr, struct hardware *);
 
 static int interface_status(struct interface_info *ifinfo);
 
@@ -68,8 +67,8 @@ int quiet_interface_discovery;
    register that interface with the network I/O software, figure out what
    subnet it's on, and add it to the list of interfaces. */
 
-void discover_interfaces (state)
-	int state;
+void
+discover_interfaces(int state)
 {
 	struct interface_info *tmp;
 	struct interface_info *last, *next;
@@ -89,8 +88,7 @@ void discover_interfaces (state)
 	/* If we already have a list of interfaces, and we're running as
 	   a DHCP server, the interfaces were requested. */
 	if (interfaces && (state == DISCOVER_SERVER ||
-			   state == DISCOVER_RELAY ||
-			   state == DISCOVER_REQUESTED))
+	    state == DISCOVER_RELAY || state == DISCOVER_REQUESTED))
 		ir = 0;
 	else if (state == DISCOVER_UNCONFIGURED)
 		ir = INTERFACE_REQUESTED | INTERFACE_AUTOMATIC;
@@ -106,12 +104,12 @@ void discover_interfaces (state)
 		if ((ifa->ifa_flags & IFF_LOOPBACK) ||
 		    (ifa->ifa_flags & IFF_POINTOPOINT) ||
 		    (!(ifa->ifa_flags & IFF_UP) &&
-		     state != DISCOVER_UNCONFIGURED))
+		    state != DISCOVER_UNCONFIGURED))
 			continue;
 		
 		/* See if we've seen an interface that matches this one. */
-		for (tmp = interfaces; tmp; tmp = tmp -> next)
-			if (!strcmp (tmp -> name, ifa -> ifa_name))
+		for (tmp = interfaces; tmp; tmp = tmp->next)
+			if (!strcmp (tmp->name, ifa->ifa_name))
 				break;
 
 		/* If there isn't already an interface by this name,
@@ -121,25 +119,25 @@ void discover_interfaces (state)
 			       dmalloc (sizeof *tmp, "discover_interfaces"));
 			if (!tmp)
 				error ("Insufficient memory to %s %s",
-				       "record interface", ifa -> ifa_name);
-			strlcpy (tmp -> name, ifa -> ifa_name, sizeof(tmp->name));
-			tmp -> next = interfaces;
-			tmp -> flags = ir;
-			tmp -> noifmedia = tmp -> dead = tmp->errors = 0;
+				       "record interface", ifa->ifa_name);
+			strlcpy (tmp->name, ifa->ifa_name, sizeof(tmp->name));
+			tmp->next = interfaces;
+			tmp->flags = ir;
+			tmp->noifmedia = tmp->dead = tmp->errors = 0;
 			interfaces = tmp;
 		}
 
 		/* If we have the capability, extract link information
 		   and record it in a linked list. */
-		if (ifa -> ifa_addr->sa_family == AF_LINK) {
+		if (ifa->ifa_addr->sa_family == AF_LINK) {
 			struct sockaddr_dl *foo = ((struct sockaddr_dl *)
-						   (ifa -> ifa_addr));
-			tmp -> index = foo->sdl_index;
-			tmp -> hw_address.hlen = foo -> sdl_alen;
-			tmp -> hw_address.htype = HTYPE_ETHER; /* XXX */
-			memcpy (tmp -> hw_address.haddr,
-				LLADDR (foo), foo -> sdl_alen);
-		} else if (ifa -> ifa_addr->sa_family == AF_INET) {
+						   (ifa->ifa_addr));
+			tmp->index = foo->sdl_index;
+			tmp->hw_address.hlen = foo->sdl_alen;
+			tmp->hw_address.htype = HTYPE_ETHER; /* XXX */
+			memcpy(tmp->hw_address.haddr,
+			    LLADDR (foo), foo->sdl_alen);
+		} else if (ifa->ifa_addr->sa_family == AF_INET) {
 			struct iaddr addr;
 
 			/* Get a pointer to the address... */
@@ -152,58 +150,56 @@ void discover_interfaces (state)
 			/* If this is the first real IP address we've
 			   found, keep a pointer to ifreq structure in
 			   which we found it. */
-			if (!tmp -> ifp) {
-				int len = (IFNAMSIZ +
-					   ifa -> ifa_addr->sa_len);
+			if (!tmp->ifp) {
+				int len = (IFNAMSIZ + ifa->ifa_addr->sa_len);
 				tif = (struct ifreq *)malloc (len);
 				if (!tif)
-					error ("no space to remember ifp.");
+					error("no space to remember ifp.");
 				strlcpy(tif->ifr_name, ifa->ifa_name, IFNAMSIZ);
 				memcpy(&tif->ifr_addr, ifa->ifa_addr,
 				    ifa->ifa_addr->sa_len);
-				tmp -> ifp = tif;
-				tmp -> primary_address = foo.sin_addr;
+				tmp->ifp = tif;
+				tmp->primary_address = foo.sin_addr;
 			}
 
 			/* Grab the address... */
 			addr.len = 4;
-			memcpy (addr.iabuf, &foo.sin_addr.s_addr,
-				addr.len);
+			memcpy(addr.iabuf, &foo.sin_addr.s_addr, addr.len);
 
 			/* If there's a registered subnet for this address,
 			   connect it together... */
-			if ((subnet = find_subnet (addr))) {
+			if ((subnet = find_subnet(addr))) {
 				/* If this interface has multiple aliases
 				   on the same subnet, ignore all but the
 				   first we encounter. */
-				if (!subnet -> interface) {
-					subnet -> interface = tmp;
-					subnet -> interface_address = addr;
-				} else if (subnet -> interface != tmp) {
+				if (!subnet->interface) {
+					subnet->interface = tmp;
+					subnet->interface_address = addr;
+				} else if (subnet->interface != tmp) {
 					warn ("Multiple %s %s: %s %s", 
 					      "interfaces match the",
 					      "same subnet",
-					      subnet -> interface -> name,
-					      tmp -> name);
+					      subnet->interface->name,
+					      tmp->name);
 				}
-				share = subnet -> shared_network;
-				if (tmp -> shared_network &&
-				    tmp -> shared_network != share) {
+				share = subnet->shared_network;
+				if (tmp->shared_network &&
+				    tmp->shared_network != share) {
 					warn ("Interface %s matches %s",
-					      tmp -> name,
+					      tmp->name,
 					      "multiple shared networks");
 				} else {
-					tmp -> shared_network = share;
+					tmp->shared_network = share;
 				}
 
-				if (!share -> interface) {
-					share -> interface = tmp;
-				} else if (share -> interface != tmp) {
+				if (!share->interface) {
+					share->interface = tmp;
+				} else if (share->interface != tmp) {
 					warn ("Multiple %s %s: %s %s", 
 					      "interfaces match the",
 					      "same shared network",
-					      share -> interface -> name,
-					      tmp -> name);
+					      share->interface->name,
+					      tmp->name);
 				}
 			}
 		}
@@ -220,94 +216,92 @@ void discover_interfaces (state)
 	/* Weed out the interfaces that did not have IP addresses. */
 	last = (struct interface_info *)0;
 	for (tmp = interfaces; tmp; tmp = next) {
-		next = tmp -> next;
-		if ((tmp -> flags & INTERFACE_AUTOMATIC) &&
+		next = tmp->next;
+		if ((tmp->flags & INTERFACE_AUTOMATIC) &&
 		    state == DISCOVER_REQUESTED)
-			tmp -> flags &= ~(INTERFACE_AUTOMATIC |
+			tmp->flags &= ~(INTERFACE_AUTOMATIC |
 					  INTERFACE_REQUESTED);
-		if (!tmp -> ifp || !(tmp -> flags & INTERFACE_REQUESTED)) {
-			if ((tmp -> flags & INTERFACE_REQUESTED) != ir)
-				error ("%s: not found", tmp -> name);
+		if (!tmp->ifp || !(tmp->flags & INTERFACE_REQUESTED)) {
+			if ((tmp->flags & INTERFACE_REQUESTED) != ir)
+				error ("%s: not found", tmp->name);
 			if (!last)
-				interfaces = interfaces -> next;
+				interfaces = interfaces->next;
 			else
-				last -> next = tmp -> next;
+				last->next = tmp->next;
 
 			/* Remember the interface in case we need to know
 			   about it later. */
-			tmp -> next = dummy_interfaces;
+			tmp->next = dummy_interfaces;
 			dummy_interfaces = tmp;
 			continue;
 		}
 		last = tmp;
 
-		memcpy (&foo, &tmp -> ifp -> ifr_addr,
-			sizeof tmp -> ifp -> ifr_addr);
+		memcpy (&foo, &tmp->ifp->ifr_addr, sizeof tmp->ifp->ifr_addr);
 
 		/* We must have a subnet declaration for each interface. */
-		if (!tmp -> shared_network && (state == DISCOVER_SERVER)) {
-			warn ("No subnet declaration for %s (%s).",
-			      tmp -> name, inet_ntoa (foo.sin_addr));
-			warn ("Please write a subnet declaration in your %s",
-			      "dhcpd.conf file for the");
-			error ("network segment to which interface %s %s",
-			       tmp -> name, "is attached.");
+		if (!tmp->shared_network && (state == DISCOVER_SERVER)) {
+			warn("No subnet declaration for %s (%s).",
+			    tmp->name, inet_ntoa (foo.sin_addr));
+			warn("Please write a subnet declaration in your %s",
+			    "dhcpd.conf file for the");
+			error("network segment to which interface %s %s",
+			    tmp->name, "is attached.");
 		}
 
 		/* Find subnets that don't have valid interface
 		   addresses... */
-		for (subnet = (tmp -> shared_network
-			       ? tmp -> shared_network -> subnets
-			       : (struct subnet *)0);
-		     subnet; subnet = subnet -> next_sibling) {
-			if (!subnet -> interface_address.len) {
+		for (subnet = (tmp->shared_network ?
+		    tmp->shared_network->subnets : NULL);
+		     subnet; subnet = subnet->next_sibling) {
+			if (!subnet->interface_address.len) {
 				/* Set the interface address for this subnet
 				   to the first address we found. */
-				subnet -> interface_address.len = 4;
-				memcpy (subnet -> interface_address.iabuf,
+				subnet->interface_address.len = 4;
+				memcpy(subnet->interface_address.iabuf,
 					&foo.sin_addr.s_addr, 4);
 			}
 		}
 
 		/* Register the interface... */
-		if_register_receive (tmp);
-		if_register_send (tmp);
+		if_register_receive(tmp);
+		if_register_send(tmp);
 	}
 
 	/* Now register all the remaining interfaces as protocols. */
-	for (tmp = interfaces; tmp; tmp = tmp -> next) {
-		add_protocol (tmp -> name, tmp -> rfdesc, got_one, tmp);
-	}
+	for (tmp = interfaces; tmp; tmp = tmp->next)
+		add_protocol (tmp->name, tmp->rfdesc, got_one, tmp);
 
 	freeifaddrs(ifap);
 
-	maybe_setup_fallback ();
+	maybe_setup_fallback();
 }
 
-struct interface_info *setup_fallback ()
+struct interface_info *
+setup_fallback(void)
 {
 	fallback_interface =
-		((struct interface_info *)
-		 dmalloc (sizeof *fallback_interface, "discover_interfaces"));
+		 dmalloc(sizeof *fallback_interface, "discover_interfaces");
 	if (!fallback_interface)
-		error ("Insufficient memory to record fallback interface.");
-	memset (fallback_interface, 0, sizeof *fallback_interface);
-	strlcpy (fallback_interface -> name, "fallback", IFNAMSIZ);
-	fallback_interface -> shared_network =
-		new_shared_network ("parse_statement");
-	if (!fallback_interface -> shared_network)
-		error ("No memory for shared subnet");
-	memset (fallback_interface -> shared_network, 0,
-		sizeof (struct shared_network));
-	fallback_interface -> shared_network -> name = "fallback-net";
+		error("Insufficient memory to record fallback interface.");
+	memset(fallback_interface, 0, sizeof *fallback_interface);
+	strlcpy(fallback_interface->name, "fallback", IFNAMSIZ);
+	fallback_interface->shared_network =
+	    new_shared_network("parse_statement");
+	if (!fallback_interface->shared_network)
+		error("No memory for shared subnet");
+	memset(fallback_interface->shared_network, 0,
+	    sizeof(struct shared_network));
+	fallback_interface->shared_network->name = "fallback-net";
 	return fallback_interface;
 }
 
-void reinitialize_interfaces ()
+void
+reinitialize_interfaces(void)
 {
 	struct interface_info *ip;
 
-	for (ip = interfaces; ip; ip = ip -> next) {
+	for (ip = interfaces; ip; ip = ip->next) {
 		if_reinitialize_receive (ip);
 		if_reinitialize_send (ip);
 	}
@@ -323,7 +317,8 @@ void reinitialize_interfaces ()
    addressing information from it, and then call through the
    bootp_packet_handler hook to try to do something with it. */
 
-void dispatch ()
+void
+dispatch(void)
 {
 	struct protocol *l;
 	int nfds = 0;
@@ -334,10 +329,10 @@ void dispatch ()
 	int to_msec;
 
 	nfds = 0;
-	for (l = protocols; l; l = l -> next) {
+	for (l = protocols; l; l = l->next)
 		++nfds;
-	}
-	fds = (struct pollfd *)malloc ((nfds) * sizeof (struct pollfd));
+
+	fds = malloc((nfds) * sizeof (struct pollfd));
 	if (fds == NULL)
 		error ("Can't allocate poll structures.");
 
@@ -345,14 +340,14 @@ void dispatch ()
 		/* Call any expired timeouts, and then if there's
 		   still a timeout registered, time out the select
 		   call then. */
-	      another:
+another:
 		if (timeouts) {
 			struct timeout *t;
-			if (timeouts -> when <= cur_time) {
+			if (timeouts->when <= cur_time) {
 				t = timeouts;
-				timeouts = timeouts -> next;
-				(*(t -> func)) (t -> what);
-				t -> next = free_timeouts;
+				timeouts = timeouts->next;
+				(*(t->func)) (t->what);
+				t->next = free_timeouts;
 				free_timeouts = t;
 				goto another;
 			}
@@ -363,7 +358,7 @@ void dispatch ()
 			 * timeout and blocking indefinetely.
 			 */
 
-			howlong = timeouts -> when - cur_time;
+			howlong = timeouts->when - cur_time;
 			if (howlong > INT_MAX / 1000)
 				howlong = INT_MAX / 1000;
 			to_msec = howlong * 1000;
@@ -373,10 +368,10 @@ void dispatch ()
 		/* Set up the descriptors to be polled. */
 		i = 0;
 		
-		for (l = protocols; l; l = l -> next) {
-			struct interface_info *ip = l -> local;
+		for (l = protocols; l; l = l->next) {
+			struct interface_info *ip = l->local;
 			if (ip && (l->handler != got_one || !ip->dead)) {
-				fds [i].fd = l -> fd;
+				fds [i].fd = l->fd;
 				fds [i].events = POLLIN;
 				fds [i].revents = 0;
 				++i;
@@ -403,14 +398,14 @@ void dispatch ()
 		GET_TIME (&cur_time);
 
 		i = 0;
-		for (l = protocols; l; l = l -> next) {
+		for (l = protocols; l; l = l->next) {
 		        struct interface_info *ip;
 			ip = l->local;
 			if ((fds [i].revents & POLLIN)) {
 				fds [i].revents = 0;
 				if (ip && (l->handler != got_one ||
 				     !ip->dead))
-					(*(l -> handler)) (l);
+					(*(l->handler)) (l);
 				if (interfaces_invalidated)
 					break;
 			}
@@ -421,28 +416,28 @@ void dispatch ()
 }
 
 
-void got_one (l)
-	struct protocol *l;
+void
+got_one(struct protocol *l)
 {
 	struct sockaddr_in from;
 	struct hardware hfrom;
 	struct iaddr ifrom;
 	size_t result;
 	union {
-		unsigned char packbuf [4095]; /* Packet input buffer.
+		unsigned char packbuf[4095]; /* Packet input buffer.
 					 	 Must be as large as largest
 						 possible MTU. */
 		struct dhcp_packet packet;
 	} u;
-	struct interface_info *ip = l -> local;
+	struct interface_info *ip = l->local;
 
 	if ((result =
-	     receive_packet (ip, u.packbuf, sizeof u, &from, &hfrom)) == -1) {
-		warn ("receive_packet failed on %s: %s", ip -> name, 
-		      strerror(errno));
+	    receive_packet(ip, u.packbuf, sizeof u, &from, &hfrom)) == -1) {
+		warn("receive_packet failed on %s: %s", ip->name, 
+		    strerror(errno));
 		ip->errors++;
-		if ((! interface_status(ip)) 
-		    || (ip->noifmedia && ip->errors > 20)) {
+		if ((! interface_status(ip)) ||
+		    (ip->noifmedia && ip->errors > 20)) {
 			/* our interface has gone away. */
 			warn("Interface %s no longer appears valid.",
 			     ip->name); 
@@ -459,10 +454,10 @@ void got_one (l)
 
 	if (bootp_packet_handler) {
 		ifrom.len = 4;
-		memcpy (ifrom.iabuf, &from.sin_addr, ifrom.len);
+		memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
 
-		(*bootp_packet_handler) (ip, &u.packet, result,
-					 from.sin_port, ifrom, &hfrom);
+		(*bootp_packet_handler)(ip, &u.packet, result,
+		    from.sin_port, ifrom, &hfrom);
 	}
 }
 
@@ -520,51 +515,49 @@ interface_status(struct interface_info *ifinfo)
 			goto inactive;
 		}
 	}
- inactive:
+inactive:
 	return(0);
- active:
+active:
 	return(1);
 }
 
-int locate_network (packet)
-	struct packet *packet;
+int
+locate_network(struct packet *packet)
 {
 	struct iaddr ia;
 
 	/* If this came through a gateway, find the corresponding subnet... */
-	if (packet -> raw -> giaddr.s_addr) {
+	if (packet->raw->giaddr.s_addr) {
 		struct subnet *subnet;
 		ia.len = 4;
-		memcpy (ia.iabuf, &packet -> raw -> giaddr, 4);
+		memcpy (ia.iabuf, &packet->raw->giaddr, 4);
 		subnet = find_subnet (ia);
 		if (subnet)
-			packet -> shared_network = subnet -> shared_network;
+			packet->shared_network = subnet->shared_network;
 		else
-			packet -> shared_network = (struct shared_network *)0;
-	} else {
-		packet -> shared_network =
-			packet -> interface -> shared_network;
-	}
-	if (packet -> shared_network)
+			packet->shared_network = (struct shared_network *)0;
+	} else
+		packet->shared_network =
+			packet->interface->shared_network;
+
+	if (packet->shared_network)
 		return 1;
 	return 0;
 }
 
-void add_timeout (when, where, what)
-	TIME when;
-	void (*where) PROTO ((void *));
-	void *what;
+void
+add_timeout(TIME when, void (*where)(void *), void *what)
 {
 	struct timeout *t, *q;
 
 	/* See if this timeout supersedes an existing timeout. */
 	t = (struct timeout *)0;
-	for (q = timeouts; q; q = q -> next) {
-		if (q -> func == where && q -> what == what) {
+	for (q = timeouts; q; q = q->next) {
+		if (q->func == where && q->what == what) {
 			if (t)
-				t -> next = q -> next;
+				t->next = q->next;
 			else
-				timeouts = q -> next;
+				timeouts = q->next;
 			break;
 		}
 		t = q;
@@ -575,57 +568,56 @@ void add_timeout (when, where, what)
 	if (!q) {
 		if (free_timeouts) {
 			q = free_timeouts;
-			free_timeouts = q -> next;
-			q -> func = where;
-			q -> what = what;
+			free_timeouts = q->next;
+			q->func = where;
+			q->what = what;
 		} else {
 			q = (struct timeout *)malloc (sizeof (struct timeout));
 			if (!q)
 				error ("Can't allocate timeout structure!");
-			q -> func = where;
-			q -> what = what;
+			q->func = where;
+			q->what = what;
 		}
 	}
 
-	q -> when = when;
+	q->when = when;
 
 	/* Now sort this timeout into the timeout list. */
 
 	/* Beginning of list? */
-	if (!timeouts || timeouts -> when > q -> when) {
-		q -> next = timeouts;
+	if (!timeouts || timeouts->when > q->when) {
+		q->next = timeouts;
 		timeouts = q;
 		return;
 	}
 
 	/* Middle of list? */
-	for (t = timeouts; t -> next; t = t -> next) {
-		if (t -> next -> when > q -> when) {
-			q -> next = t -> next;
-			t -> next = q;
+	for (t = timeouts; t->next; t = t->next) {
+		if (t->next->when > q->when) {
+			q->next = t->next;
+			t->next = q;
 			return;
 		}
 	}
 
 	/* End of list. */
-	t -> next = q;
-	q -> next = (struct timeout *)0;
+	t->next = q;
+	q->next = (struct timeout *)0;
 }
 
-void cancel_timeout (where, what)
-	void (*where) PROTO ((void *));
-	void *what;
+void
+cancel_timeout(void (*where)(void *), void *what)
 {
 	struct timeout *t, *q;
 
 	/* Look for this timeout on the list, and unlink it if we find it. */
 	t = (struct timeout *)0;
-	for (q = timeouts; q; q = q -> next) {
-		if (q -> func == where && q -> what == what) {
+	for (q = timeouts; q; q = q->next) {
+		if (q->func == where && q->what == what) {
 			if (t)
-				t -> next = q -> next;
+				t->next = q->next;
 			else
-				timeouts = q -> next;
+				timeouts = q->next;
 			break;
 		}
 		t = q;
@@ -633,17 +625,15 @@ void cancel_timeout (where, what)
 
 	/* If we found the timeout, put it on the free list. */
 	if (q) {
-		q -> next = free_timeouts;
+		q->next = free_timeouts;
 		free_timeouts = q;
 	}
 }
 
 /* Add a protocol to the list of protocols... */
-void add_protocol (name, fd, handler, local)
-	char *name;
-	int fd;
-	void (*handler) PROTO ((struct protocol *));
-	void *local;
+void
+add_protocol(char *name, int fd, void (*handler)(struct protocol *),
+    void *local)
 {
 	struct protocol *p;
 
@@ -651,27 +641,27 @@ void add_protocol (name, fd, handler, local)
 	if (!p)
 		error ("can't allocate protocol struct for %s", name);
 
-	p -> fd = fd;
-	p -> handler = handler;
-	p -> local = local;
+	p->fd = fd;
+	p->handler = handler;
+	p->local = local;
 
-	p -> next = protocols;
+	p->next = protocols;
 	protocols = p;
 }
 
-void remove_protocol (proto)
-	struct protocol *proto;
+void
+remove_protocol(struct protocol *proto)
 {
 	struct protocol *p, *next, *prev;
 
 	prev = (struct protocol *)0;
 	for (p = protocols; p; p = next) {
-		next = p -> next;
+		next = p->next;
 		if (p == proto) {
 			if (prev)
-				prev -> next = p -> next;
+				prev->next = p->next;
 			else
-				protocols = p -> next;
+				protocols = p->next;
 			free (p);
 		}
 	}