Add missing file
[dhcpcd-ui] / src / libdhcpcd / dhcpcd.c
1 /*
2  * libdhcpcd
3  * Copyright 2009-2014 Roy Marples <roy@marples.name>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26
27 // For strverscmp(3)
28 #define _GNU_SOURCE
29
30 #include <sys/socket.h>
31 #include <sys/stat.h>
32 #include <sys/un.h>
33
34 #include <arpa/inet.h>
35
36 #include <assert.h>
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <libintl.h>
40 #include <limits.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45
46 #define IN_LIBDHCPCD
47
48 #include "config.h"
49 #include "dhcpcd.h"
50
51 #ifdef HAS_GETTEXT
52 #include <libintl.h>
53 #define _ gettext
54 #else
55 #define _(a) (a)
56 #endif
57
58 #ifndef SUN_LEN
59 #define SUN_LEN(su) \
60         (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
61 #endif
62
63 static const char * const dhcpcd_types[] =
64     { "link", "ipv4", "ra", "dhcp6", NULL };
65
66 static ssize_t
67 dhcpcd_command_fd(DHCPCD_CONNECTION *con,
68     int fd, bool progname, const char *cmd, char **buffer)
69 {
70         size_t pl, cl, len;
71         ssize_t bytes;
72         char buf[1024], *p;
73         char *nbuf;
74
75         /* Each command is \n terminated.
76          * Each argument is NULL seperated.
77          * We may need to send a space one day, so the API
78          * in this function may need to be improved */
79         cl = strlen(cmd);
80         if (progname) {
81                 pl = strlen(con->progname);
82                 len = pl + 1 + cl + 1;
83         } else {
84                 pl = 0;
85                 len = cl + 1;
86         }
87         if (con->terminate_commands)
88                 len++;
89         if (len > sizeof(buf)) {
90                 errno = ENOBUFS;
91                 return -1;
92         }
93         p = buf;
94         if (progname) {
95                 memcpy(buf, con->progname, pl);
96                 buf[pl] = '\0';
97                 p = buf + pl + 1;
98         }
99         memcpy(p, cmd, cl);
100         p[cl] = '\0';
101         while ((p = strchr(p, ' ')) != NULL)
102                 *p++ = '\0';
103         if (con->terminate_commands) {
104                 buf[len - 2] = '\n';
105                 buf[len - 1] = '\0';
106         } else
107                 buf[len - 1] = '\0';
108         if (write(fd, buf, len) == -1)
109                 return -1;
110         if (buffer == NULL)
111                 return 0;
112
113         bytes = read(fd, buf, sizeof(size_t));
114         if (bytes == 0 || bytes == -1)
115                 return bytes;
116         memcpy(&len, buf, sizeof(size_t));
117         nbuf = realloc(*buffer, len + 1);
118         if (nbuf == NULL)
119                 return -1;
120         *buffer = nbuf;
121         bytes = read(fd, *buffer, len);
122         if (bytes != -1 && (size_t)bytes < len)
123                 *buffer[bytes] = '\0';
124         return bytes;
125 }
126
127 ssize_t
128 dhcpcd_command(DHCPCD_CONNECTION *con, const char *cmd, char **buffer)
129 {
130
131         return dhcpcd_command_fd(con, con->command_fd, true, cmd, buffer);
132 }
133
134 static ssize_t
135 dhcpcd_ctrl_command(DHCPCD_CONNECTION *con, const char *cmd, char **buffer)
136 {
137
138         return dhcpcd_command_fd(con, con->command_fd, false, cmd, buffer);
139 }
140
141 bool
142 dhcpcd_realloc(DHCPCD_CONNECTION *con, size_t len)
143 {
144
145         if (con->buflen < len) {
146                 char *nbuf;
147
148                 nbuf = realloc(con->buf, len);
149                 if (nbuf == NULL)
150                         return false;
151                 con->buf = nbuf;
152                 con->buflen = len;
153         }
154         return true;
155 }
156
157 ssize_t
158 dhcpcd_command_arg(DHCPCD_CONNECTION *con, const char *cmd, const char *arg,
159     char **buffer)
160 {
161         size_t cmdlen, len;
162
163         cmdlen = strlen(cmd);
164         if (arg)
165                 len = cmdlen + strlen(arg) + 2;
166         else
167                 len = cmdlen + 1;
168         if (!dhcpcd_realloc(con, len))
169                 return -1;
170         strlcpy(con->buf, cmd, con->buflen);
171         if (arg) {
172                 con->buf[cmdlen] = ' ';
173                 strlcpy(con->buf + cmdlen + 1, arg, con->buflen - 1 - cmdlen);
174         }
175
176         return dhcpcd_command_fd(con, con->command_fd, true, con->buf, buffer);
177 }
178
179
180 static int
181 dhcpcd_connect(const char *path, int opts)
182 {
183         int fd;
184         socklen_t len;
185         struct sockaddr_un sun;
186
187         fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | opts, 0);
188         if (fd == -1)
189                 return -1;
190
191         memset(&sun, 0, sizeof(sun));
192         sun.sun_family = AF_UNIX;
193         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
194         len = (socklen_t)SUN_LEN(&sun);
195         if (connect(fd, (struct sockaddr *)&sun, len) == 0)
196                 return fd;
197         close(fd);
198         return -1;
199 }
200
201 static const char *
202 get_value(const char *data, size_t len, const char *var)
203 {
204         const char *end, *p;
205         size_t vlen;
206
207         assert(var);
208         end = data + len;
209         vlen = strlen(var);
210         p = NULL;
211         while (data + vlen + 1 < end) {
212                 if (strncmp(data, var, vlen) == 0) {
213                         p = data + vlen;
214                         break;
215                 }
216                 data += strlen(data) + 1;
217         }
218         if (p != NULL && *p != '\0')
219                 return p;
220         return NULL;
221 }
222
223 const char *
224 dhcpcd_get_value(const DHCPCD_IF *i, const char *var)
225 {
226
227         assert(i);
228         return get_value(i->data, i->data_len, var);
229 }
230
231 const char *
232 dhcpcd_get_prefix_value(const DHCPCD_IF *i, const char *prefix, const char *var)
233 {
234         char pvar[128], *p;
235         size_t plen, l;
236
237         p = pvar;
238         plen = sizeof(pvar);
239         l = strlcpy(p, prefix, plen);
240         if (l >= sizeof(pvar)) {
241                 errno = ENOBUFS;
242                 return NULL;
243         }
244         p += l;
245         plen -= l;
246         if (strlcpy(p, var, plen) >= plen) {
247                 errno = ENOBUFS;
248                 return NULL;
249         }
250         return dhcpcd_get_value(i, pvar);
251 }
252
253 static bool
254 strtobool(const char *var)
255 {
256
257         if (var == NULL)
258                 return false;
259
260          return (*var == '0' || *var == '\0' ||
261             strcmp(var, "false") == 0 ||
262             strcmp(var, "no") == 0) ? false : true;
263 }
264
265 static const char *
266 get_status(DHCPCD_CONNECTION *con)
267 {
268         DHCPCD_IF *i;
269         const char *status;
270
271         assert(con);
272         if (con->command_fd == -1)
273                 return "down";
274
275         if (con->listen_fd == -1)
276                 return "opened";
277
278         if (con->interfaces == NULL)
279                 return "initialised";
280
281         status = "disconnected";
282         for (i = con->interfaces; i; i = i->next) {
283                 if (i->up) {
284                         if (strcmp(i->type, "link")) {
285                                 status = "connected";
286                                 break;
287                         } else
288                                 status = "connecting";
289                 }
290         }
291         return status;
292 }
293
294 static void
295 update_status(DHCPCD_CONNECTION *con, const char *nstatus)
296 {
297
298         assert(con);
299         if (nstatus == NULL)
300                 nstatus = get_status(con);
301         if (con->status == NULL || strcmp(nstatus, con->status)) {
302                 con->status = nstatus;
303                 if (con->status_cb)
304                         con->status_cb(con, con->status, con->status_context);
305         }
306 }
307
308 DHCPCD_IF *
309 dhcpcd_interfaces(DHCPCD_CONNECTION *con)
310 {
311
312         assert(con);
313         return con->interfaces;
314 }
315
316 DHCPCD_IF *
317 dhcpcd_get_if(DHCPCD_CONNECTION *con, const char *ifname, const char *type)
318 {
319         DHCPCD_IF *i;
320
321         assert(con);
322         for (i = con->interfaces; i; i = i->next)
323                 if (strcmp(i->ifname, ifname) == 0 &&
324                     strcmp(i->type, type) == 0)
325                         return i;
326         return NULL;
327 }
328
329 static DHCPCD_IF *
330 dhcpcd_new_if(DHCPCD_CONNECTION *con, char *data, size_t len)
331 {
332         const char *ifname, *ifclass, *reason, *type, *order, *flags;
333         char *orderdup, *o, *p;
334         DHCPCD_IF *e, *i, *l, *n, *nl;
335         int ti;
336         bool addedi;
337
338         ifname = get_value(data, len, "interface=");
339         if (ifname == NULL || *ifname == '\0') {
340                 errno = ESRCH;
341                 return NULL;
342         }
343         reason = get_value(data, len, "reason=");
344         if (reason == NULL || *reason == '\0') {
345                 errno = ESRCH;
346                 return NULL;
347         }
348         ifclass = get_value(data, len, "ifclass=");
349         /* Skip pseudo interfaces */
350         if (ifclass && *ifclass != '\0') {
351                 errno = ENOTSUP;
352                 return NULL;
353         }
354         if (strcmp(reason, "RECONFIGURE") == 0) {
355                 errno = ENOTSUP;
356                 return NULL;
357         }
358         order = get_value(data, len, "interface_order=");
359         if (order == NULL || *order == '\0') {
360                 errno = ESRCH;
361                 return NULL;
362         }
363
364         if (strcmp(reason, "PREINIT") == 0 ||
365             strcmp(reason, "UNKNOWN") == 0 ||
366             strcmp(reason, "CARRIER") == 0 ||
367             strcmp(reason, "NOCARRIER") == 0 ||
368             strcmp(reason, "DEPARTED") == 0 ||
369             strcmp(reason, "STOPPED") == 0)
370                 type = "link";
371         else if (strcmp(reason, "ROUTERADVERT") == 0)
372                 type = "ra";
373         else if (reason[strlen(reason) - 1] == '6')
374                 type = "dhcp6";
375         else
376                 type = "ipv4";
377
378         i = NULL;
379        /* Remove all instances on carrier drop */
380         if (strcmp(reason, "NOCARRIER") == 0 ||
381             strcmp(reason, "DEPARTED") == 0 ||
382             strcmp(reason, "STOPPED") == 0)
383         {
384                 l = NULL;
385                 for (e = con->interfaces; e; e = n) {
386                         n = e->next;
387                         if (strcmp(e->ifname, ifname) == 0) {
388                                 if (strcmp(e->type, type) == 0)
389                                         l = i = e;
390                                 else {
391                                         if (l)
392                                                 l->next = e->next;
393                                         else
394                                                 con->interfaces = e->next;
395                                         free(e);
396                                 }
397                         } else
398                                 l = e;
399                 }
400         } else if (strcmp(type, "link")) {
401                 /* If link is down, ignore it */
402                 e = dhcpcd_get_if(con, ifname, "link");
403                 if (e && !e->up)
404                         return NULL;
405         }
406
407         orderdup = strdup(order);
408         if (orderdup == NULL)
409                 return NULL;
410
411         /* Find our pointer */
412         if (i == NULL) {
413                 l = NULL;
414                 for (e = con->interfaces; e; e = e->next) {
415                         if (strcmp(e->ifname, ifname) == 0 &&
416                             strcmp(e->type, type) == 0)
417                         {
418                                 i = e;
419                                 break;
420                         }
421                         l = e;
422                 }
423         }
424         if (i == NULL) {
425                 i = malloc(sizeof(*i));
426                 if (i == NULL) {
427                         free(orderdup);
428                         return NULL;
429                 }
430                 if (l)
431                         l->next = i;
432                 else
433                         con->interfaces = i;
434                 i->next = NULL;
435                 i->last_message = NULL;
436         } else
437                 free(i->data);
438
439         /* Now fill out our interface structure */
440         i->con = con;
441         i->data = data;
442         i->data_len = len;
443         i->ifname = ifname;
444         i->type = type;
445         i->reason = reason;
446         flags = dhcpcd_get_value(i, "ifflags=");
447         if (flags)
448                 i->flags = (unsigned int)strtoul(flags, NULL, 0);
449         else
450                 i->flags = 0;
451         if (strcmp(reason, "CARRIER") == 0)
452                 i->up = true;
453         else
454                 i->up = strtobool(dhcpcd_get_value(i, "if_up="));
455         i->wireless = strtobool(dhcpcd_get_value(i, "ifwireless="));
456         i->ssid = dhcpcd_get_value(i, i->up ? "new_ssid=" : "old_ssid=");
457
458        /* Sort! */
459         n = nl = NULL;
460         p = orderdup;
461         addedi = false;
462         while ((o = strsep(&p, " ")) != NULL) {
463                 for (ti = 0; dhcpcd_types[ti]; ti++) {
464                         l = NULL;
465                         for (e = con->interfaces; e; e = e->next) {
466                                 if (strcmp(e->ifname, o) == 0 &&
467                                     strcmp(e->type, dhcpcd_types[ti]) == 0)
468                                         break;
469                                 l = e;
470                         }
471                         if (e == NULL)
472                                 continue;
473                         if (i == e)
474                                 addedi = true;
475                         if (l)
476                                 l->next = e->next;
477                         else
478                                 con->interfaces = e->next;
479                         e->next = NULL;
480                         if (nl == NULL)
481                                 n = nl = e;
482                         else {
483                                 nl->next = e;
484                                 nl = e;
485                         }
486                 }
487         }
488         free(orderdup);
489         /* Free any stragglers */
490         while (con->interfaces) {
491                 e = con->interfaces->next;
492                 free(con->interfaces->data);
493                 free(con->interfaces->last_message);
494                 free(con->interfaces);
495                 con->interfaces = e;
496         }
497         con->interfaces = n;
498
499         return addedi ? i : NULL;
500 }
501
502 static DHCPCD_IF *
503 dhcpcd_read_if(DHCPCD_CONNECTION *con, int fd)
504 {
505         char sbuf[sizeof(size_t)], *rbuf;
506         size_t len;
507         ssize_t bytes;
508         DHCPCD_IF *i;
509
510         bytes = read(fd, sbuf, sizeof(sbuf));
511         if (bytes == 0 || bytes == -1) {
512                 dhcpcd_close(con);
513                 return NULL;
514         }
515         memcpy(&len, sbuf, sizeof(len));
516         rbuf = malloc(len + 1);
517         if (rbuf == NULL)
518                 return NULL;
519         bytes = read(fd, rbuf, len);
520         if (bytes == 0 || bytes == -1) {
521                 free(rbuf);
522                 dhcpcd_close(con);
523                 return NULL;
524         }
525         if ((size_t)bytes != len) {
526                 free(rbuf);
527                 errno = EINVAL;
528                 return NULL;
529         }
530         rbuf[bytes] = '\0';
531
532         i = dhcpcd_new_if(con, rbuf, len);
533         if (i == NULL)
534                 free(rbuf);
535         return i;
536 }
537
538 static void
539 dhcpcd_dispatchif(DHCPCD_IF *i)
540 {
541
542         assert(i);
543         if (i->con->if_cb)
544                 i->con->if_cb(i, i->con->if_context);
545         dhcpcd_wpa_if_event(i);
546 }
547
548 void
549 dhcpcd_dispatch(DHCPCD_CONNECTION *con)
550 {
551         DHCPCD_IF *i;
552
553         assert(con);
554         i = dhcpcd_read_if(con, con->listen_fd);
555         if (i)
556                 dhcpcd_dispatchif(i);
557
558         /* Have to call update_status last as it could
559          * cause the interface to be destroyed. */
560         update_status(con, NULL);
561 }
562
563 DHCPCD_CONNECTION *
564 dhcpcd_new(void)
565 {
566         DHCPCD_CONNECTION *con;
567
568         con = calloc(1, sizeof(*con));
569         con->command_fd = con->listen_fd = -1;
570         con->open = false;
571         con->progname = "libdhcpcd";
572         return con;
573 }
574
575 void
576 dhcpcd_set_progname(DHCPCD_CONNECTION *con, const char *progname)
577 {
578
579         assert(con);
580         con->progname = progname;
581 }
582
583 const char *
584 dhcpcd_get_progname(const DHCPCD_CONNECTION *con)
585 {
586
587         assert(con);
588         return con->progname;
589 }
590
591 #ifndef __GLIBC__
592 /* Good enough for our needs */
593 static int
594 strverscmp(const char *s1, const char *s2)
595 {
596         int s1maj, s1min, s1part;
597         int s2maj, s2min, s2part;
598         int r;
599
600         s1min = s1part = 0;
601         if (sscanf(s1, "%d.%d.%d", &s1maj, &s1min, &s1part) < 1)
602                 return -1;
603         s2min = s2part = 0;
604         if (sscanf(s2, "%d.%d.%d", &s2maj, &s2min, &s2part) < 1)
605                 return -1;
606         r = s1maj - s2maj;
607         if (r != 0)
608                 return r;
609         r = s1min - s2min;
610         if (r != 0)
611                 return r;
612         return s1part - s2part;
613 }
614 #endif
615
616 int
617 dhcpcd_open(DHCPCD_CONNECTION *con, bool privileged)
618 {
619         const char *path = privileged ? DHCPCD_SOCKET : DHCPCD_UNPRIV_SOCKET;
620         char cmd[128];
621         ssize_t bytes;
622         size_t nifs, n;
623
624         assert(con);
625         if (con->open) {
626                 if (con->listen_fd != -1)
627                         return con->listen_fd;
628                 errno = EISCONN;
629                 return -1;
630         }
631         /* We need to block the command fd */
632         con->command_fd = dhcpcd_connect(path, 0);
633         if (con->command_fd == -1)
634                 goto err_exit;
635
636         con->terminate_commands = false;
637         if (dhcpcd_ctrl_command(con, "--version", &con->version) <= 0)
638                 goto err_exit;
639         con->terminate_commands =
640             strverscmp(con->version, "6.4.1") >= 0 ? true : false;
641
642         if (dhcpcd_ctrl_command(con, "--getconfigfile", &con->cffile) <= 0)
643                 goto err_exit;
644
645         con->open = true;
646         con->privileged = privileged;
647         update_status(con, NULL);
648
649         con->listen_fd = dhcpcd_connect(path, SOCK_NONBLOCK);
650         if (con->listen_fd == -1)
651                 goto err_exit;
652
653         dhcpcd_command_fd(con, con->listen_fd, false, "--listen", NULL);
654         dhcpcd_command_fd(con, con->command_fd, false, "--getinterfaces", NULL);
655         bytes = read(con->command_fd, cmd, sizeof(nifs));
656         if (bytes != sizeof(nifs))
657                 goto err_exit;
658         memcpy(&nifs, cmd, sizeof(nifs));
659         /* We don't dispatch each interface here as that
660          * causes too much notification spam when the GUI starts */
661         for (n = 0; n < nifs; n++)
662                 dhcpcd_read_if(con, con->command_fd);
663
664         update_status(con, NULL);
665
666         return con->listen_fd;
667
668 err_exit:
669         dhcpcd_close(con);
670         return -1;
671 }
672
673 int
674 dhcpcd_get_fd(DHCPCD_CONNECTION *con)
675 {
676
677         assert(con);
678         return con->listen_fd;
679 }
680
681 bool
682 dhcpcd_privileged(DHCPCD_CONNECTION *con)
683 {
684
685         assert(con);
686         return con->privileged;
687 }
688
689 const char *
690 dhcpcd_status(DHCPCD_CONNECTION *con)
691 {
692
693         assert(con);
694         return con->status;
695 }
696
697 const char *
698 dhcpcd_version(DHCPCD_CONNECTION *con)
699 {
700
701         assert(con);
702         return con->version;
703 }
704
705 const char *
706 dhcpcd_cffile(DHCPCD_CONNECTION *con)
707 {
708
709         assert(con);
710         return con->cffile;
711 }
712
713 void
714 dhcpcd_set_if_callback(DHCPCD_CONNECTION *con,
715     void (*cb)(DHCPCD_IF *, void *), void *ctx)
716 {
717
718         assert(con);
719         con->if_cb = cb;
720         con->if_context = ctx;
721 }
722
723 void
724 dhcpcd_set_status_callback(DHCPCD_CONNECTION *con,
725     void (*cb)(DHCPCD_CONNECTION *, const char *, void *), void *ctx)
726 {
727
728         assert(con);
729         con->status_cb = cb;
730         con->status_context = ctx;
731 }
732
733 void
734 dhcpcd_close(DHCPCD_CONNECTION *con)
735 {
736         DHCPCD_IF *nif;
737         DHCPCD_WPA *nwpa;
738         DHCPCD_WI_HIST *nh;
739
740         assert(con);
741
742         con->open = false;
743
744         /* Shut down WPA listeners as they aren't much good without dhcpcd.
745          * They'll be restarted anyway when dhcpcd comes back up. */
746         while (con->wpa) {
747                 nwpa = con->wpa->next;
748                 dhcpcd_wpa_close(con->wpa);
749                 free(con->wpa);
750                 con->wpa = nwpa;
751         }
752         while (con->wi_history) {
753                 nh = con->wi_history->next;
754                 free(con->wi_history);
755                 con->wi_history = nh;
756         }
757         while (con->interfaces) {
758                 nif = con->interfaces->next;
759                 free(con->interfaces->data);
760                 free(con->interfaces->last_message);
761                 free(con->interfaces);
762                 con->interfaces = nif;
763         }
764
765         if (con->command_fd != -1)
766                 shutdown(con->command_fd, SHUT_RDWR);
767         if (con->listen_fd != -1)
768                 shutdown(con->listen_fd, SHUT_RDWR);
769
770         update_status(con, "down");
771
772         if (con->command_fd != -1) {
773                 close(con->command_fd);
774                 con->command_fd = -1;
775         }
776         if (con->listen_fd != -1) {
777                 close(con->listen_fd);
778                 con->listen_fd = -1;
779         }
780
781         if (con->cffile) {
782                 free(con->cffile);
783                 con->cffile = NULL;
784         }
785         if (con->version) {
786                 free(con->version);
787                 con->version = NULL;
788         }
789         if (con->buf) {
790                 free(con->buf);
791                 con->buf = NULL;
792                 con->buflen = 0;
793         }
794 }
795
796 void
797 dhcpcd_free(DHCPCD_CONNECTION *con)
798 {
799
800         assert(con);
801         free(con);
802 }
803
804 DHCPCD_CONNECTION *
805 dhcpcd_if_connection(DHCPCD_IF *i)
806 {
807
808         assert(i);
809         return i->con;
810 }
811
812 char *
813 dhcpcd_if_message(DHCPCD_IF *i, bool *new_msg)
814 {
815         const char *ip, *iplen, *pfx;
816         char *msg, *p;
817         const char *reason = NULL;
818         size_t len;
819         bool showssid;
820
821         assert(i);
822         /* Don't report non SLAAC configurations */
823         if (strcmp(i->type, "ra") == 0 && i->up &&
824             dhcpcd_get_value(i, "ra1_prefix=") == NULL)
825                 return NULL;
826
827         showssid = false;
828         if (strcmp(i->reason, "EXPIRE") == 0)
829                 reason = _("Expired");
830         else if (strcmp(i->reason, "CARRIER") == 0) {
831                 if (i->wireless) {
832                         showssid = true;
833                         reason = _("Associated with");
834                 } else
835                         reason = _("Cable plugged in");
836         } else if (strcmp(i->reason, "NOCARRIER") == 0) {
837                 if (i->wireless) {
838                         if (i->ssid) {
839                                 reason = _("Disassociated from");
840                                 showssid = true;
841                         } else
842                                 reason = _("Not associated");
843                 } else
844                         reason = _("Cable unplugged");
845         } else if (strcmp(i->reason, "DEPARTED") == 0)
846                 reason = _("Departed");
847         else if (strcmp(i->reason, "UNKNOWN") == 0)
848                 reason = _("Unknown link state");
849         else if (strcmp(i->reason, "FAIL") == 0)
850                 reason = _("Automatic configuration not possible");
851         else if (strcmp(i->reason, "3RDPARTY") == 0)
852                 reason = _("Waiting for 3rd Party configuration");
853
854         if (reason == NULL) {
855                 if (i->up)
856                         reason = _("Configured");
857                 else if (strcmp(i->type, "ra") == 0)
858                         reason = "Expired RA";
859                 else
860                         reason = i->reason;
861         }
862
863         pfx = i->up ? "new_" : "old_";
864         if ((ip = dhcpcd_get_prefix_value(i, pfx, "ip_address=")))
865                 iplen = dhcpcd_get_prefix_value(i, pfx, "subnet_cidr=");
866         else if ((ip = dhcpcd_get_value(i, "ra1_prefix=")))
867                 iplen = NULL;
868         else if ((ip = dhcpcd_get_prefix_value(i, pfx,
869             "dhcp6_ia_na1_ia_addr1=")))
870                 iplen = "128";
871         else {
872                 ip = NULL;
873                 iplen = NULL;
874         }
875
876         len = strlen(i->ifname) + strlen(reason) + 3;
877         if (showssid && i->ssid)
878                 len += strlen(i->ssid) + 1;
879         if (ip)
880                 len += strlen(ip) + 1;
881         if (iplen)
882                 len += strlen(iplen) + 1;
883         msg = p = malloc(len);
884         if (msg == NULL)
885                 return NULL;
886         p += snprintf(msg, len, "%s: %s", i->ifname, reason);
887         if (showssid)
888                 p += snprintf(p, len - (size_t)(p - msg), " %s", i->ssid);
889         if (iplen)
890                 snprintf(p, len - (size_t)(p - msg), " %s/%s", ip, iplen);
891         else if (ip)
892                 snprintf(p, len - (size_t)(p - msg), " %s", ip);
893
894         if (new_msg) {
895                 if (i->last_message == NULL || strcmp(i->last_message, msg))
896                         *new_msg = true;
897                 else
898                         *new_msg = false;
899         }
900         free(i->last_message);
901         i->last_message = strdup(msg);
902
903         return msg;
904 }