1*10ee6647Sroy /* $NetBSD: arp.c,v 1.68 2020/09/15 11:14:16 roy Exp $ */
27f624aaaSchopps
361f28255Scgd /*
417c454feSmycroft * Copyright (c) 1984, 1993
517c454feSmycroft * The Regents of the University of California. All rights reserved.
661f28255Scgd *
761f28255Scgd * This code is derived from software contributed to Berkeley by
861f28255Scgd * Sun Microsystems, Inc.
961f28255Scgd *
1061f28255Scgd * Redistribution and use in source and binary forms, with or without
1161f28255Scgd * modification, are permitted provided that the following conditions
1261f28255Scgd * are met:
1361f28255Scgd * 1. Redistributions of source code must retain the above copyright
1461f28255Scgd * notice, this list of conditions and the following disclaimer.
1561f28255Scgd * 2. Redistributions in binary form must reproduce the above copyright
1661f28255Scgd * notice, this list of conditions and the following disclaimer in the
1761f28255Scgd * documentation and/or other materials provided with the distribution.
18326b2259Sagc * 3. Neither the name of the University nor the names of its contributors
1961f28255Scgd * may be used to endorse or promote products derived from this software
2061f28255Scgd * without specific prior written permission.
2161f28255Scgd *
2261f28255Scgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
2361f28255Scgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2461f28255Scgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2561f28255Scgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
2661f28255Scgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2761f28255Scgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2861f28255Scgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2961f28255Scgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
3061f28255Scgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
3161f28255Scgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3261f28255Scgd * SUCH DAMAGE.
3361f28255Scgd */
3461f28255Scgd
3540980191Slukem #include <sys/cdefs.h>
3661f28255Scgd #ifndef lint
379c194566Slukem __COPYRIGHT("@(#) Copyright (c) 1984, 1993\
389c194566Slukem The Regents of the University of California. All rights reserved.");
3961f28255Scgd #endif /* not lint */
4061f28255Scgd
4161f28255Scgd #ifndef lint
4240980191Slukem #if 0
4340980191Slukem static char sccsid[] = "@(#)arp.c 8.3 (Berkeley) 4/28/95";
4440980191Slukem #else
45*10ee6647Sroy __RCSID("$NetBSD: arp.c,v 1.68 2020/09/15 11:14:16 roy Exp $");
4640980191Slukem #endif
4761f28255Scgd #endif /* not lint */
4861f28255Scgd
4961f28255Scgd /*
5061f28255Scgd * arp - display, set, and delete arp table entries
5161f28255Scgd */
5261f28255Scgd
5361f28255Scgd #include <sys/param.h>
5461f28255Scgd #include <sys/file.h>
5561f28255Scgd #include <sys/socket.h>
5617c454feSmycroft #include <sys/sysctl.h>
570ea0f71aSfair #include <sys/ioctl.h>
5861f28255Scgd
5961f28255Scgd #include <net/if.h>
6017c454feSmycroft #include <net/if_dl.h>
6100cef679Sis #include <net/if_ether.h>
6217c454feSmycroft #include <net/if_types.h>
63bf1e4582Sroy #include <net/nd.h>
6417c454feSmycroft #include <net/route.h>
6517c454feSmycroft #include <netinet/in.h>
66bf1e4582Sroy #include <netinet/in_var.h>
6700cef679Sis #include <netinet/if_inarp.h>
68804c4234Smycroft #include <arpa/inet.h>
6961f28255Scgd
70c4516a41Schopps #include <err.h>
71f3b151f5Smikel #include <errno.h>
72f3b151f5Smikel #include <netdb.h>
7361f28255Scgd #include <nlist.h>
74f3b151f5Smikel #include <paths.h>
7561f28255Scgd #include <stdio.h>
76c4516a41Schopps #include <stdlib.h>
77867b4b0fScgd #include <string.h>
78f3b151f5Smikel #include <unistd.h>
79ecf05965Srafal #include <ifaddrs.h>
8061f28255Scgd
81018518e2Sozaki-r #include "prog_ops.h"
82018518e2Sozaki-r
838adc537dSdyoung static int is_llinfo(const struct sockaddr_dl *, int);
84efddc5fcSozaki-r static int delete_one(struct rt_msghdr *);
856fef5d35Schristos static void dump(uint32_t);
86efddc5fcSozaki-r static void delete(const char *, const char *);
876fef5d35Schristos static void sdl_print(const struct sockaddr_dl *);
886fef5d35Schristos static int getifname(u_int16_t, char *, size_t);
8927bb1e23Schristos static int atosdl(const char *, struct sockaddr_dl *);
906fef5d35Schristos static int file(const char *);
916fef5d35Schristos static void get(const char *);
926fef5d35Schristos static int getinetaddr(const char *, struct in_addr *);
9395cda991Sozaki-r static int getsocket(void);
9427bb1e23Schristos static int getetheraddr(struct in_addr, struct sockaddr_dl *);
9527bb1e23Schristos static struct rt_msghdr * rtmsg(const int, const int, struct rt_msghdr *,
96efddc5fcSozaki-r const struct sockaddr_inarp *, const struct sockaddr_dl *);
97bf1e4582Sroy static struct in_nbrinfo * getnbrinfo(const char *, struct in_addr *);
98bf1e4582Sroy static const char * sec2str(time_t);
996fef5d35Schristos static int set(int, char **);
1008b0f9554Sperry static void usage(void) __dead;
10100cef679Sis
102c0da9e56Satatat static int aflag, nflag, vflag;
1036fef5d35Schristos static struct sockaddr_in so_mask = {
1046fef5d35Schristos .sin_len = 8,
1056fef5d35Schristos .sin_addr = {
1066fef5d35Schristos .s_addr = 0xffffffff
1076fef5d35Schristos }
1086fef5d35Schristos };
1096fef5d35Schristos static struct sockaddr_inarp blank_sin = {
1106fef5d35Schristos .sin_len = sizeof(blank_sin),
1116fef5d35Schristos .sin_family = AF_INET
1126fef5d35Schristos };
1136fef5d35Schristos static struct sockaddr_dl blank_sdl = {
1146fef5d35Schristos .sdl_len = sizeof(blank_sdl),
1156fef5d35Schristos .sdl_family = AF_LINK
1166fef5d35Schristos };
1176fef5d35Schristos
1186fef5d35Schristos static int expire_time, flags, export_only, doing_proxy, found_entry;
11938e37321Smikel
120c4516a41Schopps int
main(int argc,char ** argv)1214d3d9104Sxtraeme main(int argc, char **argv)
12261f28255Scgd {
12361f28255Scgd int ch;
124f3b151f5Smikel int op = 0;
12561f28255Scgd
126eda273b9Stv setprogname(argv[0]);
127eda273b9Stv
12892e05e0eSmrg while ((ch = getopt(argc, argv, "andsfv")) != -1)
12961f28255Scgd switch((char)ch) {
13017c454feSmycroft case 'a':
131c0da9e56Satatat aflag = 1;
132c0da9e56Satatat break;
13361f28255Scgd case 'd':
134f3b151f5Smikel case 's':
135f3b151f5Smikel case 'f':
136f3b151f5Smikel if (op)
13761f28255Scgd usage();
138f3b151f5Smikel op = ch;
139f3b151f5Smikel break;
14017c454feSmycroft case 'n':
14117c454feSmycroft nflag = 1;
142c4516a41Schopps break;
14392e05e0eSmrg case 'v':
14492e05e0eSmrg vflag = 1;
14592e05e0eSmrg break;
14661f28255Scgd default:
14761f28255Scgd usage();
14861f28255Scgd }
149f3b151f5Smikel argc -= optind;
150f3b151f5Smikel argv += optind;
151f3b151f5Smikel
152c0da9e56Satatat if (!op && aflag)
153c0da9e56Satatat op = 'a';
154c0da9e56Satatat
155018518e2Sozaki-r if (prog_init && prog_init() == -1)
156018518e2Sozaki-r err(1, "init failed");
157018518e2Sozaki-r
158f3b151f5Smikel switch((char)op) {
159f3b151f5Smikel case 'a':
160f3b151f5Smikel dump(0);
161f3b151f5Smikel break;
162f3b151f5Smikel case 'd':
163c0da9e56Satatat if (aflag && argc == 0)
164efddc5fcSozaki-r delete(NULL, NULL);
165c0da9e56Satatat else {
166c0da9e56Satatat if (aflag || argc < 1 || argc > 2)
16761f28255Scgd usage();
168efddc5fcSozaki-r delete(argv[0], argv[1]);
169c0da9e56Satatat }
170f3b151f5Smikel break;
171f3b151f5Smikel case 's':
1728f2efeecSchristos if (argc < 2 || argc > 7)
173f3b151f5Smikel usage();
174f3b151f5Smikel return (set(argc, argv) ? 1 : 0);
175f3b151f5Smikel case 'f':
176f3b151f5Smikel if (argc != 1)
177f3b151f5Smikel usage();
178f3b151f5Smikel return (file(argv[0]));
179f3b151f5Smikel default:
180f3b151f5Smikel if (argc != 1)
181f3b151f5Smikel usage();
182f3b151f5Smikel get(argv[0]);
183f3b151f5Smikel break;
184f3b151f5Smikel }
185c4516a41Schopps return (0);
18661f28255Scgd }
18761f28255Scgd
18861f28255Scgd /*
18961f28255Scgd * Process a file to set standard arp entries
19061f28255Scgd */
1916fef5d35Schristos static int
file(const char * name)1926fef5d35Schristos file(const char *name)
19361f28255Scgd {
1946fef5d35Schristos char *line, *argv[5];
195c4516a41Schopps int i, retval;
196c4516a41Schopps FILE *fp;
19761f28255Scgd
1986ea002c7Sdholland if (!strcmp(name, "-")) {
1996ea002c7Sdholland fp = stdin;
2006ea002c7Sdholland } else {
2016ea002c7Sdholland fp = fopen(name, "r");
2026ea002c7Sdholland if (fp == NULL) {
2036ea002c7Sdholland err(1, "Cannot open %s", name);
2046ea002c7Sdholland }
2056ea002c7Sdholland }
20661f28255Scgd retval = 0;
2076fef5d35Schristos for (; (line = fparseln(fp, NULL, NULL, NULL, 0)) != NULL; free(line)) {
2086fef5d35Schristos char **ap, *inputstring;
2096fef5d35Schristos
2106fef5d35Schristos inputstring = line;
2116fef5d35Schristos for (ap = argv; ap < &argv[sizeof(argv) / sizeof(argv[0])] &&
2126fef5d35Schristos (*ap = stresep(&inputstring, " \t", '\\')) != NULL;) {
2136fef5d35Schristos if (**ap != '\0')
2146fef5d35Schristos ap++;
2156fef5d35Schristos }
2166fef5d35Schristos i = ap - argv;
21761f28255Scgd if (i < 2) {
218c4516a41Schopps warnx("bad line: %s", line);
21961f28255Scgd retval = 1;
22061f28255Scgd continue;
22161f28255Scgd }
2226fef5d35Schristos if (set(i, argv))
22361f28255Scgd retval = 1;
22461f28255Scgd }
2256ea002c7Sdholland if (fp != stdin)
2266fef5d35Schristos (void)fclose(fp);
2276fef5d35Schristos return retval;
22861f28255Scgd }
22961f28255Scgd
23095cda991Sozaki-r static int
getsocket(void)2314d3d9104Sxtraeme getsocket(void)
232c4516a41Schopps {
23395cda991Sozaki-r int s;
234018518e2Sozaki-r s = prog_socket(PF_ROUTE, SOCK_RAW, 0);
235c4516a41Schopps if (s < 0)
236c4516a41Schopps err(1, "socket");
23795cda991Sozaki-r return s;
23817c454feSmycroft }
23917c454feSmycroft
240e17012b1Schristos static int
getlink(const char * name,struct sockaddr_dl * sdl)241e17012b1Schristos getlink(const char *name, struct sockaddr_dl *sdl)
242e17012b1Schristos {
243e17012b1Schristos struct ifaddrs *ifap, *ifa;
244e17012b1Schristos
245e17012b1Schristos if (getifaddrs(&ifap) != 0) {
246e17012b1Schristos warn("getifaddrs");
247e17012b1Schristos return 0;
248e17012b1Schristos }
249e17012b1Schristos
250e17012b1Schristos for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
251e17012b1Schristos if (ifa->ifa_addr->sa_family != AF_LINK)
252e17012b1Schristos continue;
253e17012b1Schristos if (strcmp(ifa->ifa_name, name) != 0)
254e17012b1Schristos continue;
255e17012b1Schristos memcpy(sdl, ifa->ifa_addr, sizeof(*sdl));
256e17012b1Schristos freeifaddrs(ifap);
257e17012b1Schristos return 1;
258e17012b1Schristos }
259e17012b1Schristos freeifaddrs(ifap);
260e17012b1Schristos return 0;
261e17012b1Schristos }
262e17012b1Schristos
26361f28255Scgd /*
26461f28255Scgd * Set an individual arp entry
26561f28255Scgd */
2666fef5d35Schristos static int
set(int argc,char ** argv)2674d3d9104Sxtraeme set(int argc, char **argv)
26861f28255Scgd {
2694d3d9104Sxtraeme struct sockaddr_inarp *sina;
2702c3eb313Sozaki-r struct sockaddr_dl *sdl = NULL;
27140980191Slukem struct rt_msghdr *rtm;
272c4516a41Schopps char *host = argv[0], *eaddr;
27395cda991Sozaki-r struct sockaddr_inarp sin_m = blank_sin; /* struct copy */
27495cda991Sozaki-r struct sockaddr_dl sdl_m = blank_sdl; /* struct copy */
27595cda991Sozaki-r int s;
276c4516a41Schopps
277c4516a41Schopps eaddr = argv[1];
27861f28255Scgd
27995cda991Sozaki-r s = getsocket();
28061f28255Scgd argc -= 2;
28161f28255Scgd argv += 2;
28295cda991Sozaki-r
2837d1cb5f3Sdholland if (getinetaddr(host, &sin_m.sin_addr) == -1) {
2847d1cb5f3Sdholland prog_close(s);
28561f28255Scgd return (1);
2867d1cb5f3Sdholland }
2879ff41a62Schristos if (strcmp(eaddr, "auto") != 0 && atosdl(eaddr, &sdl_m))
28800cef679Sis warnx("invalid link-level address '%s'", eaddr);
28917c454feSmycroft doing_proxy = flags = export_only = expire_time = 0;
290e17012b1Schristos for (; argc-- > 0; argv++) {
29117c454feSmycroft if (strncmp(argv[0], "temp", 4) == 0) {
2924d3d9104Sxtraeme struct timeval timev;
2934d3d9104Sxtraeme (void)gettimeofday(&timev, 0);
2944d3d9104Sxtraeme expire_time = timev.tv_sec + 20 * 60;
29517c454feSmycroft }
29617c454feSmycroft else if (strncmp(argv[0], "pub", 3) == 0) {
29717c454feSmycroft flags |= RTF_ANNOUNCE;
298806be1d8Sozaki-r doing_proxy = 1;
29940918b5aSseanb if (argc && strncmp(argv[1], "pro", 3) == 0) {
30040918b5aSseanb export_only = 1;
30140918b5aSseanb argc--; argv++;
30240918b5aSseanb }
30317c454feSmycroft } else if (strncmp(argv[0], "trail", 5) == 0) {
3046fef5d35Schristos warnx("%s: Sending trailers is no longer supported",
30517c454feSmycroft host);
306e17012b1Schristos } else if (strcmp(argv[0], "ifscope") == 0) {
307e17012b1Schristos if (argc == 0) {
308e17012b1Schristos warnx("missing interface for ifscope");
309e17012b1Schristos continue;
31017c454feSmycroft }
311e17012b1Schristos argc--;
31261f28255Scgd argv++;
313e17012b1Schristos if (!getlink(argv[0], &sdl_m))
314e17012b1Schristos warnx("cannot get link address for %s", argv[0]);
31561f28255Scgd }
316e17012b1Schristos
317e17012b1Schristos }
3189ff41a62Schristos if (doing_proxy && strcmp(eaddr, "auto") == 0) {
3197d1cb5f3Sdholland if (getetheraddr(sin_m.sin_addr, &sdl_m) == -1) {
3207d1cb5f3Sdholland prog_close(s);
32127bb1e23Schristos return 1;
32227bb1e23Schristos }
3237d1cb5f3Sdholland }
32417c454feSmycroft tryagain:
325efddc5fcSozaki-r rtm = rtmsg(s, RTM_GET, NULL, &sin_m, &sdl_m);
32695cda991Sozaki-r if (rtm == NULL) {
327c4516a41Schopps warn("%s", host);
3287d1cb5f3Sdholland prog_close(s);
32917c454feSmycroft return (1);
33061f28255Scgd }
3316fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1);
332af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) +
3336fef5d35Schristos (char *)(void *)sina);
3344d3d9104Sxtraeme if (sina->sin_addr.s_addr == sin_m.sin_addr.s_addr) {
3358adc537dSdyoung if (is_llinfo(sdl, rtm->rtm_flags))
33617c454feSmycroft goto overwrite;
33717c454feSmycroft if (doing_proxy == 0) {
3386fef5d35Schristos warnx("set: can only proxy for %s", host);
3397d1cb5f3Sdholland prog_close(s);
34017c454feSmycroft return (1);
34117c454feSmycroft }
34217c454feSmycroft if (sin_m.sin_other & SIN_PROXY) {
3436fef5d35Schristos warnx("set: proxy entry exists for non 802 device");
3447d1cb5f3Sdholland prog_close(s);
34517c454feSmycroft return (1);
34617c454feSmycroft }
34717c454feSmycroft sin_m.sin_other = SIN_PROXY;
34817c454feSmycroft export_only = 1;
34917c454feSmycroft goto tryagain;
35017c454feSmycroft }
35117c454feSmycroft overwrite:
35217c454feSmycroft if (sdl->sdl_family != AF_LINK) {
3536fef5d35Schristos warnx("cannot intuit interface index and type for %s",
354c4516a41Schopps host);
3557d1cb5f3Sdholland prog_close(s);
35617c454feSmycroft return (1);
35717c454feSmycroft }
35817c454feSmycroft sdl_m.sdl_type = sdl->sdl_type;
35917c454feSmycroft sdl_m.sdl_index = sdl->sdl_index;
36095cda991Sozaki-r sin_m.sin_other = 0;
36195cda991Sozaki-r if (doing_proxy && export_only)
36295cda991Sozaki-r sin_m.sin_other = SIN_PROXY;
363efddc5fcSozaki-r rtm = rtmsg(s, RTM_ADD, NULL, &sin_m, &sdl_m);
36492e05e0eSmrg if (vflag)
36592e05e0eSmrg (void)printf("%s (%s) added\n", host, eaddr);
3667d1cb5f3Sdholland prog_close(s);
36795cda991Sozaki-r return (rtm == NULL) ? 1 : 0;
36861f28255Scgd }
36961f28255Scgd
37061f28255Scgd /*
37161f28255Scgd * Display an individual arp entry
37261f28255Scgd */
3736fef5d35Schristos static void
get(const char * host)3744d3d9104Sxtraeme get(const char *host)
37561f28255Scgd {
37695cda991Sozaki-r struct sockaddr_inarp sin = blank_sin; /* struct copy */
37761f28255Scgd
37895cda991Sozaki-r if (getinetaddr(host, &sin.sin_addr) == -1)
37961f28255Scgd exit(1);
38095cda991Sozaki-r dump(sin.sin_addr.s_addr);
3816fef5d35Schristos if (found_entry == 0)
38295cda991Sozaki-r errx(1, "%s (%s) -- no entry", host, inet_ntoa(sin.sin_addr));
38361f28255Scgd }
38461f28255Scgd
3858adc537dSdyoung
3868adc537dSdyoung static int
is_llinfo(const struct sockaddr_dl * sdl,int rtflags)3878adc537dSdyoung is_llinfo(const struct sockaddr_dl *sdl, int rtflags)
3888adc537dSdyoung {
3898adc537dSdyoung if (sdl->sdl_family != AF_LINK ||
3902c3eb313Sozaki-r (rtflags & (RTF_LLDATA|RTF_GATEWAY)) != RTF_LLDATA)
3918adc537dSdyoung return 0;
3928adc537dSdyoung
3938adc537dSdyoung switch (sdl->sdl_type) {
3948adc537dSdyoung case IFT_ETHER:
3958adc537dSdyoung case IFT_FDDI:
3968adc537dSdyoung case IFT_ISO88023:
3978adc537dSdyoung case IFT_ISO88024:
3988adc537dSdyoung case IFT_ISO88025:
3998adc537dSdyoung case IFT_ARCNET:
4008adc537dSdyoung return 1;
4018adc537dSdyoung default:
4028adc537dSdyoung return 0;
4038adc537dSdyoung }
4048adc537dSdyoung }
4058adc537dSdyoung
40661f28255Scgd /*
40761f28255Scgd * Delete an arp entry
40861f28255Scgd */
409c4516a41Schopps int
delete_one(struct rt_msghdr * rtm)410efddc5fcSozaki-r delete_one(struct rt_msghdr *rtm)
41161f28255Scgd {
4124d3d9104Sxtraeme struct sockaddr_inarp *sina;
41317c454feSmycroft struct sockaddr_dl *sdl;
41495cda991Sozaki-r int s;
41561f28255Scgd
41695cda991Sozaki-r s = getsocket();
4176fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1);
418af069eb3Schristos sdl = (struct sockaddr_dl *)(void *)(RT_ROUNDUP(sina->sin_len) +
4196fef5d35Schristos (char *)(void *)sina);
4209b776eb9Snonaka if (sdl->sdl_family != AF_LINK) {
4219b776eb9Snonaka prog_close(s);
42217c454feSmycroft return (1);
4239b776eb9Snonaka }
424efddc5fcSozaki-r rtm = rtmsg(s, RTM_DELETE, rtm, sina, sdl);
4257d1cb5f3Sdholland prog_close(s);
42695cda991Sozaki-r if (rtm == NULL)
427c4516a41Schopps return (1);
428c4516a41Schopps return (0);
42961f28255Scgd }
43061f28255Scgd
43161f28255Scgd /*
43261f28255Scgd * Dump the entire arp table
43361f28255Scgd */
434c4516a41Schopps void
dump(uint32_t addr)4356fef5d35Schristos dump(uint32_t addr)
43661f28255Scgd {
43717c454feSmycroft int mib[6];
43817c454feSmycroft size_t needed;
4390ea0f71aSfair char ifname[IFNAMSIZ];
4404d3d9104Sxtraeme char *lim, *buf, *next;
4414d3d9104Sxtraeme const char *host;
44217c454feSmycroft struct rt_msghdr *rtm;
4434d3d9104Sxtraeme struct sockaddr_inarp *sina;
44417c454feSmycroft struct sockaddr_dl *sdl;
44561f28255Scgd struct hostent *hp;
446bf1e4582Sroy struct timeval tim;
447bf1e4582Sroy struct in_nbrinfo *nbi;
44861f28255Scgd
44917c454feSmycroft mib[0] = CTL_NET;
45017c454feSmycroft mib[1] = PF_ROUTE;
45117c454feSmycroft mib[2] = 0;
45217c454feSmycroft mib[3] = AF_INET;
45317c454feSmycroft mib[4] = NET_RT_FLAGS;
4542c3eb313Sozaki-r mib[5] = 0;
455018518e2Sozaki-r if (prog_sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
456c4516a41Schopps err(1, "route-sysctl-estimate");
4579bef2d1dSfvdl if (needed == 0)
4589bef2d1dSfvdl return;
45917c454feSmycroft if ((buf = malloc(needed)) == NULL)
460c4516a41Schopps err(1, "malloc");
461018518e2Sozaki-r if (prog_sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
462c4516a41Schopps err(1, "actual retrieval of routing table");
46317c454feSmycroft lim = buf + needed;
46417c454feSmycroft for (next = buf; next < lim; next += rtm->rtm_msglen) {
4656fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next;
4666fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1);
4676fef5d35Schristos sdl = (struct sockaddr_dl *)(void *)
468af069eb3Schristos (RT_ROUNDUP(sina->sin_len) + (char *)(void *)sina);
46917c454feSmycroft if (addr) {
4704d3d9104Sxtraeme if (addr != sina->sin_addr.s_addr)
47161f28255Scgd continue;
47217c454feSmycroft found_entry = 1;
47317c454feSmycroft }
47417c454feSmycroft if (nflag == 0)
4756fef5d35Schristos hp = gethostbyaddr((const char *)(void *)
4766fef5d35Schristos &(sina->sin_addr),
4774d3d9104Sxtraeme sizeof sina->sin_addr, AF_INET);
47861f28255Scgd else
479f5e60284Schristos hp = NULL;
480f5e60284Schristos
481f5e60284Schristos host = hp ? hp->h_name : "?";
482f5e60284Schristos
4834d3d9104Sxtraeme (void)printf("%s (%s) at ", host, inet_ntoa(sina->sin_addr));
48417c454feSmycroft if (sdl->sdl_alen)
48500cef679Sis sdl_print(sdl);
48661f28255Scgd else
487c4516a41Schopps (void)printf("(incomplete)");
4880ea0f71aSfair
4890ea0f71aSfair if (sdl->sdl_index) {
4904a1c105cSitojun if (getifname(sdl->sdl_index, ifname, sizeof(ifname)) == 0)
4916fef5d35Schristos (void)printf(" on %s", ifname);
4920ea0f71aSfair }
4930ea0f71aSfair
4944d3d9104Sxtraeme if (sina->sin_other & SIN_PROXY)
495c4516a41Schopps (void)printf(" published (proxy only)");
49617c454feSmycroft if (rtm->rtm_addrs & RTA_NETMASK) {
4976fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)
498af069eb3Schristos (RT_ROUNDUP(sdl->sdl_len) + (char *)(void *)sdl);
4994d3d9104Sxtraeme if (sina->sin_addr.s_addr == 0xffffffff)
500c4516a41Schopps (void)printf(" published");
5014d3d9104Sxtraeme if (sina->sin_len != 8)
5029a18c8bbSerh (void)printf("(weird)");
50317c454feSmycroft }
504bf1e4582Sroy
505bf1e4582Sroy if (sdl->sdl_index == 0)
506bf1e4582Sroy goto done;
507bf1e4582Sroy (void)gettimeofday(&tim, 0);
508bf1e4582Sroy nbi = getnbrinfo(ifname, &sina->sin_addr);
509bf1e4582Sroy if (nbi != NULL) {
510bf1e4582Sroy if (nbi->expire > tim.tv_sec) {
511bf1e4582Sroy (void)printf(" %s",
512bf1e4582Sroy sec2str(nbi->expire - tim.tv_sec));
513bf1e4582Sroy } else if (nbi->expire == 0)
514bf1e4582Sroy (void)printf(" %s", "permanent");
515bf1e4582Sroy else
516bf1e4582Sroy (void)printf(" %s", "expired");
517bf1e4582Sroy
518bf1e4582Sroy switch (nbi->state) {
519bf1e4582Sroy case ND_LLINFO_NOSTATE:
520bf1e4582Sroy (void)printf(" N");
521bf1e4582Sroy break;
522bf1e4582Sroy case ND_LLINFO_WAITDELETE:
523bf1e4582Sroy (void)printf(" W");
524bf1e4582Sroy break;
525bf1e4582Sroy case ND_LLINFO_INCOMPLETE:
526bf1e4582Sroy (void)printf(" I");
527bf1e4582Sroy break;
528bf1e4582Sroy case ND_LLINFO_REACHABLE:
529bf1e4582Sroy (void)printf(" R");
530bf1e4582Sroy break;
531bf1e4582Sroy case ND_LLINFO_STALE:
532bf1e4582Sroy (void)printf(" S");
533bf1e4582Sroy break;
534bf1e4582Sroy case ND_LLINFO_DELAY:
535bf1e4582Sroy (void)printf(" D");
536bf1e4582Sroy break;
537bf1e4582Sroy case ND_LLINFO_PROBE:
538bf1e4582Sroy (void)printf(" P");
539bf1e4582Sroy break;
5404843b656Sroy case ND_LLINFO_UNREACHABLE:
5414843b656Sroy (void)printf(" U");
5424843b656Sroy break;
543bf1e4582Sroy default:
544bf1e4582Sroy (void)printf(" ?");
545bf1e4582Sroy break;
546bf1e4582Sroy }
547bf1e4582Sroy }
548bf1e4582Sroy
549bf1e4582Sroy done:
550c4516a41Schopps (void)printf("\n");
55161f28255Scgd }
552c4191f38Sitojun free(buf);
55361f28255Scgd }
55461f28255Scgd
555c0da9e56Satatat /*
556c0da9e56Satatat * Delete the entire arp table
557c0da9e56Satatat */
558c0da9e56Satatat void
delete(const char * host,const char * info)559efddc5fcSozaki-r delete(const char *host, const char *info)
560c0da9e56Satatat {
561c0da9e56Satatat int mib[6];
562b69c4cc5Snonaka char addr[sizeof("000.000.000.000\0")];
563c0da9e56Satatat size_t needed;
564c0da9e56Satatat char *lim, *buf, *next;
565c0da9e56Satatat struct rt_msghdr *rtm;
5664d3d9104Sxtraeme struct sockaddr_inarp *sina;
567efddc5fcSozaki-r struct sockaddr_inarp sin_m = blank_sin; /* struct copy */
5689316f32fSozaki-r bool found = false;
569c0da9e56Satatat
570efddc5fcSozaki-r if (host != NULL) {
571efddc5fcSozaki-r int ret = getinetaddr(host, &sin_m.sin_addr);
572efddc5fcSozaki-r if (ret == -1)
573efddc5fcSozaki-r return;
574efddc5fcSozaki-r }
575efddc5fcSozaki-r if (info && strncmp(info, "pro", 3) == 0)
576efddc5fcSozaki-r sin_m.sin_other = SIN_PROXY;
577efddc5fcSozaki-r
578efddc5fcSozaki-r retry:
579c0da9e56Satatat mib[0] = CTL_NET;
580c0da9e56Satatat mib[1] = PF_ROUTE;
581c0da9e56Satatat mib[2] = 0;
582c0da9e56Satatat mib[3] = AF_INET;
583c0da9e56Satatat mib[4] = NET_RT_FLAGS;
584efddc5fcSozaki-r mib[5] = RTF_LLDATA;
585018518e2Sozaki-r if (prog_sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
586c0da9e56Satatat err(1, "route-sysctl-estimate");
587c0da9e56Satatat if (needed == 0)
588c0da9e56Satatat return;
589c0da9e56Satatat if ((buf = malloc(needed)) == NULL)
590c0da9e56Satatat err(1, "malloc");
591efddc5fcSozaki-r if (prog_sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
592efddc5fcSozaki-r free(buf);
593efddc5fcSozaki-r if (errno == ENOBUFS)
594efddc5fcSozaki-r goto retry;
595c0da9e56Satatat err(1, "actual retrieval of routing table");
596efddc5fcSozaki-r }
597c0da9e56Satatat lim = buf + needed;
598efddc5fcSozaki-r
599c0da9e56Satatat for (next = buf; next < lim; next += rtm->rtm_msglen) {
600efddc5fcSozaki-r int ret;
6016fef5d35Schristos rtm = (struct rt_msghdr *)(void *)next;
6026fef5d35Schristos sina = (struct sockaddr_inarp *)(void *)(rtm + 1);
603efddc5fcSozaki-r if (host != NULL &&
604efddc5fcSozaki-r sina->sin_addr.s_addr != sin_m.sin_addr.s_addr)
605efddc5fcSozaki-r continue;
6069316f32fSozaki-r found = true;
607efddc5fcSozaki-r ret = delete_one(rtm);
608efddc5fcSozaki-r if (vflag && ret == 0) {
609b69c4cc5Snonaka snprintf(addr, sizeof(addr), "%s",
6106fef5d35Schristos inet_ntoa(sina->sin_addr));
611b69c4cc5Snonaka (void)printf("%s (%s) deleted\n",
612b69c4cc5Snonaka host != NULL ? host : addr, addr);
613efddc5fcSozaki-r }
614c0da9e56Satatat }
6159316f32fSozaki-r if (host != NULL && !found)
6169316f32fSozaki-r warnx("delete: can't locate %s", host);
617c4191f38Sitojun free(buf);
618c0da9e56Satatat }
619c0da9e56Satatat
620c4516a41Schopps void
sdl_print(const struct sockaddr_dl * sdl)6214d3d9104Sxtraeme sdl_print(const struct sockaddr_dl *sdl)
62261f28255Scgd {
62358777943Sbjh21 char hbuf[NI_MAXHOST];
62400cef679Sis
6256fef5d35Schristos if (getnameinfo((const struct sockaddr *)(const void *)sdl,
6266fef5d35Schristos (socklen_t)sdl->sdl_len,
62758777943Sbjh21 hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0)
6286fef5d35Schristos (void)printf("<invalid>");
62958777943Sbjh21 else
6306fef5d35Schristos (void)printf("%s", hbuf);
63100cef679Sis }
63200cef679Sis
6336fef5d35Schristos static int
atosdl(const char * ss,struct sockaddr_dl * sdl)6344d3d9104Sxtraeme atosdl(const char *ss, struct sockaddr_dl *sdl)
63500cef679Sis {
63600cef679Sis int i;
6376fef5d35Schristos unsigned long b;
6386fef5d35Schristos char *endp;
6396fef5d35Schristos char *p;
64000cef679Sis char *t, *r;
64100cef679Sis
64200cef679Sis p = LLADDR(sdl);
6436fef5d35Schristos endp = ((char *)(void *)sdl) + sdl->sdl_len;
64400cef679Sis i = 0;
64500cef679Sis
6466fef5d35Schristos b = strtoul(ss, &t, 16);
6476fef5d35Schristos if (b > 255 || t == ss)
64800cef679Sis return 1;
64900cef679Sis
6506fef5d35Schristos *p++ = (char)b;
65100cef679Sis ++i;
65200cef679Sis while ((p < endp) && (*t++ == ':')) {
6536fef5d35Schristos b = strtoul(t, &r, 16);
6546fef5d35Schristos if (b > 255 || r == t)
65500cef679Sis break;
6566fef5d35Schristos *p++ = (char)b;
65700cef679Sis ++i;
65800cef679Sis t = r;
65900cef679Sis }
66000cef679Sis sdl->sdl_alen = i;
66100cef679Sis
66200cef679Sis return 0;
66361f28255Scgd }
66461f28255Scgd
6656fef5d35Schristos static void
usage(void)6664d3d9104Sxtraeme usage(void)
66761f28255Scgd {
6689da6188fSpooka const char *progname;
6697cbe3d2cSlukem
6709da6188fSpooka progname = getprogname();
6716fef5d35Schristos (void)fprintf(stderr, "Usage: %s [-n] hostname\n", progname);
6726fef5d35Schristos (void)fprintf(stderr, " %s [-nv] -a\n", progname);
673a23efb78Snonaka (void)fprintf(stderr, " %s [-v] -d [-a|hostname [proxy]]\n",
6746fef5d35Schristos progname);
67540918b5aSseanb (void)fprintf(stderr, " %s -s hostname ether_addr [temp] [pub [proxy]]\n",
6766fef5d35Schristos progname);
6776fef5d35Schristos (void)fprintf(stderr, " %s -f filename\n", progname);
67861f28255Scgd exit(1);
67961f28255Scgd }
68017c454feSmycroft
68195cda991Sozaki-r static struct rt_msghdr *
rtmsg(const int s,const int cmd,struct rt_msghdr * _rtm,const struct sockaddr_inarp * sin,const struct sockaddr_dl * sdl)682efddc5fcSozaki-r rtmsg(const int s, const int cmd, struct rt_msghdr *_rtm,
683efddc5fcSozaki-r const struct sockaddr_inarp *sin, const struct sockaddr_dl *sdl)
68417c454feSmycroft {
68517c454feSmycroft static int seq;
686efddc5fcSozaki-r struct rt_msghdr *rtm = _rtm;
68740980191Slukem char *cp;
68840980191Slukem int l;
68995cda991Sozaki-r static struct {
69095cda991Sozaki-r struct rt_msghdr m_rtm;
69195cda991Sozaki-r char m_space[512];
69295cda991Sozaki-r } m_rtmsg;
69395cda991Sozaki-r pid_t pid;
69417c454feSmycroft
69517c454feSmycroft errno = 0;
696efddc5fcSozaki-r if (rtm != NULL) {
697efddc5fcSozaki-r memcpy(&m_rtmsg, rtm, rtm->rtm_msglen);
698efddc5fcSozaki-r rtm = &m_rtmsg.m_rtm;
69917c454feSmycroft goto doit;
7002c3eb313Sozaki-r }
701c4516a41Schopps (void)memset(&m_rtmsg, 0, sizeof(m_rtmsg));
702efddc5fcSozaki-r rtm = &m_rtmsg.m_rtm;
703efddc5fcSozaki-r cp = m_rtmsg.m_space;
704efddc5fcSozaki-r
70517c454feSmycroft rtm->rtm_flags = flags;
70617c454feSmycroft rtm->rtm_version = RTM_VERSION;
70717c454feSmycroft
70817c454feSmycroft switch (cmd) {
70917c454feSmycroft default:
710c4516a41Schopps errx(1, "internal wrong cmd");
711c4516a41Schopps /*NOTREACHED*/
71217c454feSmycroft case RTM_ADD:
71317c454feSmycroft rtm->rtm_addrs |= RTA_GATEWAY;
71417c454feSmycroft rtm->rtm_rmx.rmx_expire = expire_time;
71517c454feSmycroft rtm->rtm_inits = RTV_EXPIRE;
7162c3eb313Sozaki-r rtm->rtm_flags |= (RTF_HOST | RTF_STATIC | RTF_LLDATA);
71717c454feSmycroft if (doing_proxy) {
71895cda991Sozaki-r if (!export_only) {
71917c454feSmycroft rtm->rtm_addrs |= RTA_NETMASK;
72017c454feSmycroft rtm->rtm_flags &= ~RTF_HOST;
72117c454feSmycroft }
72217c454feSmycroft }
72317c454feSmycroft rtm->rtm_addrs |= RTA_DST;
7242c3eb313Sozaki-r break;
7252c3eb313Sozaki-r case RTM_GET:
7262c3eb313Sozaki-r rtm->rtm_flags |= RTF_LLDATA;
72733ead633Sozaki-r rtm->rtm_addrs |= RTA_DST | RTA_GATEWAY;
72817c454feSmycroft }
7299a18c8bbSerh
73017c454feSmycroft #define NEXTADDR(w, s) \
73117c454feSmycroft if (rtm->rtm_addrs & (w)) { \
7326fef5d35Schristos (void)memcpy(cp, &s, \
73395cda991Sozaki-r (size_t)((const struct sockaddr *)&s)->sa_len); \
73495cda991Sozaki-r RT_ADVANCE(cp, ((const struct sockaddr *)&s)); \
7359a18c8bbSerh }
73617c454feSmycroft
73795cda991Sozaki-r NEXTADDR(RTA_DST, *sin);
73895cda991Sozaki-r NEXTADDR(RTA_GATEWAY, *sdl);
73917c454feSmycroft NEXTADDR(RTA_NETMASK, so_mask);
74017c454feSmycroft
7416fef5d35Schristos rtm->rtm_msglen = cp - (char *)(void *)&m_rtmsg;
74217c454feSmycroft doit:
74317c454feSmycroft l = rtm->rtm_msglen;
74417c454feSmycroft rtm->rtm_seq = ++seq;
74517c454feSmycroft rtm->rtm_type = cmd;
746018518e2Sozaki-r if (prog_write(s, &m_rtmsg, (size_t)l) < 0) {
74717c454feSmycroft if (errno != ESRCH || cmd != RTM_DELETE) {
748c4516a41Schopps warn("writing to routing socket");
74995cda991Sozaki-r return NULL;
75017c454feSmycroft }
75117c454feSmycroft }
75295cda991Sozaki-r
75395cda991Sozaki-r pid = prog_getpid();
75417c454feSmycroft do {
755018518e2Sozaki-r l = prog_read(s, &m_rtmsg, sizeof(m_rtmsg));
75617c454feSmycroft } while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
75717c454feSmycroft if (l < 0)
758c4516a41Schopps warn("read from routing socket");
75995cda991Sozaki-r return rtm;
76017c454feSmycroft }
76117c454feSmycroft
7626fef5d35Schristos static int
getinetaddr(const char * host,struct in_addr * inap)7634d3d9104Sxtraeme getinetaddr(const char *host, struct in_addr *inap)
76417c454feSmycroft {
765c4516a41Schopps struct hostent *hp;
766c4516a41Schopps
7679a1b7b98Schopps if (inet_aton(host, inap) == 1)
768c4516a41Schopps return (0);
769c4516a41Schopps if ((hp = gethostbyname(host)) == NULL) {
7702df1fdaaSchs warnx("%s: %s", host, hstrerror(h_errno));
771c4516a41Schopps return (-1);
772c4516a41Schopps }
773c4516a41Schopps (void)memcpy(inap, hp->h_addr, sizeof(*inap));
774c4516a41Schopps return (0);
77517c454feSmycroft }
7760ea0f71aSfair
7776fef5d35Schristos static int
getifname(u_int16_t ifindex,char * ifname,size_t l)7784d3d9104Sxtraeme getifname(u_int16_t ifindex, char *ifname, size_t l)
7790ea0f71aSfair {
780ecf05965Srafal int i;
781ecf05965Srafal struct ifaddrs *addr;
78227bb1e23Schristos const struct sockaddr_dl *sdl;
78395cda991Sozaki-r static struct ifaddrs* ifaddrs = NULL;
7840ea0f71aSfair
785ecf05965Srafal if (ifaddrs == NULL) {
786ecf05965Srafal i = getifaddrs(&ifaddrs);
787ecf05965Srafal if (i != 0)
788ecf05965Srafal err(1, "getifaddrs");
7890ea0f71aSfair }
7900ea0f71aSfair
791ecf05965Srafal for (addr = ifaddrs; addr; addr = addr->ifa_next) {
792ecf05965Srafal if (addr->ifa_addr == NULL ||
793ecf05965Srafal addr->ifa_addr->sa_family != AF_LINK)
7940ea0f71aSfair continue;
7950ea0f71aSfair
7966fef5d35Schristos sdl = (const struct sockaddr_dl *)(void *)addr->ifa_addr;
7970ea0f71aSfair if (sdl && sdl->sdl_index == ifindex) {
7984a1c105cSitojun (void) strlcpy(ifname, addr->ifa_name, l);
7990ea0f71aSfair return 0;
8000ea0f71aSfair }
8010ea0f71aSfair }
8020ea0f71aSfair
8030ea0f71aSfair return -1;
8040ea0f71aSfair }
80527bb1e23Schristos
80627bb1e23Schristos static int
getetheraddr(struct in_addr ipaddr,struct sockaddr_dl * sdl)80727bb1e23Schristos getetheraddr(struct in_addr ipaddr, struct sockaddr_dl *sdl)
80827bb1e23Schristos {
80927bb1e23Schristos struct ifaddrs *ifaddrs, *addr;
81027bb1e23Schristos in_addr_t ina, mask;
81127bb1e23Schristos char ifname[IFNAMSIZ];
81227bb1e23Schristos
81327bb1e23Schristos if (getifaddrs(&ifaddrs) != 0) {
81427bb1e23Schristos warn("getifaddrs");
81527bb1e23Schristos return -1;
81627bb1e23Schristos }
81727bb1e23Schristos
81827bb1e23Schristos for (addr = ifaddrs; addr; addr = addr->ifa_next) {
81927bb1e23Schristos if (addr->ifa_addr == NULL ||
82027bb1e23Schristos addr->ifa_addr->sa_family != AF_INET)
82127bb1e23Schristos continue;
82227bb1e23Schristos if ((addr->ifa_flags & (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|
82327bb1e23Schristos IFF_LOOPBACK|IFF_NOARP)) != (IFF_UP|IFF_BROADCAST))
82427bb1e23Schristos continue;
82527bb1e23Schristos
82627bb1e23Schristos mask = ((struct sockaddr_in *)(void *)addr->ifa_netmask)->sin_addr.s_addr;
82727bb1e23Schristos ina = ((struct sockaddr_in *)(void *)addr->ifa_addr)->sin_addr.s_addr;
82827bb1e23Schristos if ((ipaddr.s_addr & mask) != (ina & mask))
82927bb1e23Schristos continue;
83027bb1e23Schristos strlcpy(ifname, addr->ifa_name, sizeof(ifname));
83127bb1e23Schristos break;
83227bb1e23Schristos }
83327bb1e23Schristos if (addr == NULL) {
83427bb1e23Schristos warnx("No interface matched %s", inet_ntoa(ipaddr));
83527bb1e23Schristos freeifaddrs(ifaddrs);
83627bb1e23Schristos return -1;
83727bb1e23Schristos }
83827bb1e23Schristos
83927bb1e23Schristos for (addr = ifaddrs; addr; addr = addr->ifa_next) {
84027bb1e23Schristos if (addr->ifa_addr == NULL ||
84127bb1e23Schristos addr->ifa_addr->sa_family != AF_LINK)
84227bb1e23Schristos continue;
84327bb1e23Schristos if (strcmp(ifname, addr->ifa_name) != 0)
84427bb1e23Schristos continue;
84527bb1e23Schristos memcpy(sdl, addr->ifa_addr, sizeof(*sdl));
84627bb1e23Schristos freeifaddrs(ifaddrs);
84727bb1e23Schristos return 0;
84827bb1e23Schristos }
84927bb1e23Schristos warnx("No link address for interface %s", ifname);
85027bb1e23Schristos freeifaddrs(ifaddrs);
85127bb1e23Schristos return -1;
85227bb1e23Schristos }
853bf1e4582Sroy
854bf1e4582Sroy static struct in_nbrinfo *
getnbrinfo(const char * ifname,struct in_addr * addr)855bf1e4582Sroy getnbrinfo(const char *ifname, struct in_addr *addr)
856bf1e4582Sroy {
857bf1e4582Sroy static struct in_nbrinfo nbi, *nbip;
858bf1e4582Sroy int s;
859bf1e4582Sroy
860bf1e4582Sroy if ((s = prog_socket(AF_INET, SOCK_DGRAM, 0)) == -1)
861bf1e4582Sroy err(1, "socket");
862bf1e4582Sroy
863bf1e4582Sroy (void)memset(&nbi, 0, sizeof(nbi));
864bf1e4582Sroy (void)strlcpy(nbi.ifname, ifname, sizeof(nbi.ifname));
865bf1e4582Sroy nbi.addr = *addr;
866bf1e4582Sroy if (prog_ioctl(s, SIOCGNBRINFO, &nbi) == -1) {
867bf1e4582Sroy warn("ioctl(SIOCGNBRINFO)");
868bf1e4582Sroy nbip = NULL;
869bf1e4582Sroy } else
870bf1e4582Sroy nbip = &nbi;
871bf1e4582Sroy (void)prog_close(s);
872bf1e4582Sroy
873bf1e4582Sroy return nbip;
874bf1e4582Sroy }
875bf1e4582Sroy
876bf1e4582Sroy static const char *
sec2str(time_t total)877bf1e4582Sroy sec2str(time_t total)
878bf1e4582Sroy {
879bf1e4582Sroy static char result[256];
880bf1e4582Sroy int days, hours, mins, secs;
881bf1e4582Sroy int first = 1;
882bf1e4582Sroy char *p = result;
883bf1e4582Sroy char *ep = &result[sizeof(result)];
884bf1e4582Sroy int n;
885bf1e4582Sroy
886bf1e4582Sroy days = total / 3600 / 24;
887bf1e4582Sroy hours = (total / 3600) % 24;
888bf1e4582Sroy mins = (total / 60) % 60;
889bf1e4582Sroy secs = total % 60;
890bf1e4582Sroy
891bf1e4582Sroy if (days) {
892bf1e4582Sroy first = 0;
893bf1e4582Sroy n = snprintf(p, (size_t)(ep - p), "%dd", days);
894bf1e4582Sroy if (n < 0 || n >= ep - p)
895bf1e4582Sroy return "?";
896bf1e4582Sroy p += n;
897bf1e4582Sroy }
898bf1e4582Sroy if (!first || hours) {
899bf1e4582Sroy first = 0;
900bf1e4582Sroy n = snprintf(p, (size_t)(ep - p), "%dh", hours);
901bf1e4582Sroy if (n < 0 || n >= ep - p)
902bf1e4582Sroy return "?";
903bf1e4582Sroy p += n;
904bf1e4582Sroy }
905bf1e4582Sroy if (!first || mins) {
906bf1e4582Sroy first = 0;
907bf1e4582Sroy n = snprintf(p, (size_t)(ep - p), "%dm", mins);
908bf1e4582Sroy if (n < 0 || n >= ep - p)
909bf1e4582Sroy return "?";
910bf1e4582Sroy p += n;
911bf1e4582Sroy }
912bf1e4582Sroy (void)snprintf(p, (size_t)(ep - p), "%ds", secs);
913bf1e4582Sroy
914bf1e4582Sroy return(result);
915bf1e4582Sroy }
916