• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/netifd/interface-event.c

  1 /*
  2  * netifd - network interface daemon
  3  * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
  4  *
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU General Public License version 2
  7  * as published by the Free Software Foundation
  8  *
  9  * This program is distributed in the hope that it will be useful,
 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  * GNU General Public License for more details.
 13  */
 14 #include <stdio.h>
 15 #include <stdlib.h>
 16 #include <string.h>
 17 
 18 #include <libubox/uloop.h>
 19 
 20 #include "netifd.h"
 21 #include "interface.h"
 22 #include "ubus.h"
 23 
 24 char *hotplug_cmd_path = DEFAULT_HOTPLUG_PATH;
 25 static struct interface *current;
 26 static enum interface_event current_ev;
 27 static struct list_head pending = LIST_HEAD_INIT(pending);
 28 
 29 static void task_complete(struct uloop_process *proc, int ret);
 30 static struct uloop_process task = {
 31         .cb = task_complete,
 32 };
 33 static const char * const eventnames[] = {
 34         [IFEV_DOWN] = "ifdown",
 35         [IFEV_UP] = "ifup",
 36         [IFEV_UP_FAILED] = "ifup-failed",
 37         [IFEV_UPDATE] = "ifupdate",
 38         [IFEV_FREE] = "free",
 39         [IFEV_RELOAD] = "reload",
 40         [IFEV_LINK_UP] = "iflink",
 41         [IFEV_CREATE] = "create",
 42 };
 43 
 44 static void
 45 run_cmd(const char *ifname, const char *device, enum interface_event event,
 46                 enum interface_update_flags updated)
 47 {
 48         char *argv[3];
 49         int pid;
 50 
 51         pid = fork();
 52         if (pid < 0)
 53                 return task_complete(NULL, -1);
 54 
 55         if (pid > 0) {
 56                 task.pid = pid;
 57                 uloop_process_add(&task);
 58                 return;
 59         }
 60 
 61         setenv("ACTION", eventnames[event], 1);
 62         setenv("INTERFACE", ifname, 1);
 63         if (device)
 64                 setenv("DEVICE", device, 1);
 65 
 66         if (event == IFEV_UPDATE) {
 67                 if (updated & IUF_ADDRESS)
 68                         setenv("IFUPDATE_ADDRESSES", "1", 1);
 69                 if (updated & IUF_ROUTE)
 70                         setenv("IFUPDATE_ROUTES", "1", 1);
 71                 if (updated & IUF_PREFIX)
 72                         setenv("IFUPDATE_PREFIXES", "1", 1);
 73                 if (updated & IUF_DATA)
 74                         setenv("IFUPDATE_DATA", "1", 1);
 75         }
 76 
 77         argv[0] = hotplug_cmd_path;
 78         argv[1] = "iface";
 79         argv[2] = NULL;
 80         execvp(argv[0], argv);
 81         exit(127);
 82 }
 83 
 84 static void
 85 call_hotplug(void)
 86 {
 87         const char *device = NULL;
 88         if (list_empty(&pending))
 89                 return;
 90 
 91         current = list_first_entry(&pending, struct interface, hotplug_list);
 92         current_ev = current->hotplug_ev;
 93         list_del_init(&current->hotplug_list);
 94 
 95         if ((current_ev == IFEV_UP || current_ev == IFEV_UPDATE) && current->l3_dev.dev)
 96                 device = current->l3_dev.dev->ifname;
 97 
 98         D(SYSTEM, "Call hotplug handler for interface '%s', event '%s' (%s)\n",
 99         current->name, eventnames[current_ev], device ? device : "none");
100         run_cmd(current->name, device, current_ev, current->updated);
101 }
102 
103 static void
104 task_complete(struct uloop_process *proc, int ret)
105 {
106         if (current)
107                 D(SYSTEM, "Complete hotplug handler for interface '%s'\n", current->name);
108         current = NULL;
109         call_hotplug();
110 }
111 
112 /*
113  * Queue an interface for an up/down event.
114  * An interface can only have one event in the queue and one
115  * event waiting for completion.
116  * When queueing an event that is the same as the one waiting for
117  * completion, remove the interface from the queue
118  */
119 static void
120 interface_queue_event(struct interface *iface, enum interface_event ev)
121 {
122         D(SYSTEM, "Queue hotplug handler for interface '%s', event '%s'\n",
123                         iface->name, eventnames[ev]);
124         if (ev == IFEV_UP || ev == IFEV_DOWN)
125                 netifd_ubus_interface_event(iface, ev == IFEV_UP);
126 
127         netifd_ubus_interface_notify(iface, ev != IFEV_DOWN);
128 
129         /* no hotplug.d calls for link up */
130         if (ev == IFEV_LINK_UP)
131                 return;
132 
133         if (current == iface) {
134                 /* an event for iface is being processed */
135                 if (!list_empty(&iface->hotplug_list)) {
136                         /* an additional event for iface is pending   */
137                         /* overwrite pending event if it differs from */
138                         /* an update                                  */
139                         if (ev != IFEV_UPDATE)
140                                 iface->hotplug_ev = ev;
141                 }
142                 else {
143                         /* no additional event for iface is pending */
144                         if (ev != current_ev || ev == IFEV_UPDATE) {
145                                 /* only add the interface to the pending list if
146                                  * the event is different from the one being
147                                  * handled or if it is an update */
148                                 iface->hotplug_ev = ev;
149                                 /* Handle hotplug calls FIFO */
150                                 list_add_tail(&iface->hotplug_list, &pending);
151                         }
152                 }
153         }
154         else {
155                 /* currently not handling an event or handling an event
156                  * for another interface */
157                 if (!list_empty(&iface->hotplug_list)) {
158                         /* an event for iface is pending */
159                         if (!(iface->hotplug_ev == IFEV_UP &&
160                                 ev == IFEV_UPDATE)) {
161                                 /* overwrite pending event, unless the incoming
162                                  * event is an ifupdate while the pending one
163                                  * is an ifup */
164                                 iface->hotplug_ev = ev;
165                         }
166                 }
167                 else {
168                         /* an event for the interface is not yet pending,
169                          * queue it */
170                         iface->hotplug_ev = ev;
171                         /* Handle hotplug calls FIFO */
172                         list_add_tail(&iface->hotplug_list, &pending);
173                 }
174         }
175 
176         if (!task.pending && !current)
177                 call_hotplug();
178 }
179 
180 static void
181 interface_dequeue_event(struct interface *iface)
182 {
183         if (iface == current)
184                 current = NULL;
185 
186         if (!list_empty(&iface->hotplug_list))
187                 list_del_init(&iface->hotplug_list);
188 }
189 
190 static void interface_event_cb(struct interface_user *dep, struct interface *iface,
191                                enum interface_event ev)
192 {
193         switch (ev) {
194                 case IFEV_LINK_UP:
195                 case IFEV_UP:
196                 case IFEV_UP_FAILED:
197                 case IFEV_UPDATE:
198                 case IFEV_DOWN:
199                         interface_queue_event(iface, ev);
200                         break;
201                 case IFEV_FREE:
202                         interface_dequeue_event(iface);
203                         break;
204                 default:
205                         break;
206         }
207 }
208 
209 static struct interface_user event_user = {
210         .cb = interface_event_cb
211 };
212 
213 static void __init interface_event_init(void)
214 {
215         interface_add_user(&event_user, NULL);
216 }
217 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt