• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2008, The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <unistd.h>
20 #include <string.h>
21 #include <errno.h>
22 
23 #include <sys/socket.h>
24 #include <sys/select.h>
25 #include <sys/types.h>
26 #include <netinet/in.h>
27 #include <arpa/inet.h>
28 #include <net/if.h>
29 #include <netdb.h>
30 
31 #include <linux/if.h>
32 #include <linux/if_ether.h>
33 #include <linux/if_arp.h>
34 #include <linux/netlink.h>
35 #include <linux/route.h>
36 #include <linux/ipv6_route.h>
37 #include <linux/rtnetlink.h>
38 #include <linux/sockios.h>
39 
40 #include "netutils/ifc.h"
41 
42 #ifdef ANDROID
43 #define LOG_TAG "NetUtils"
44 #include <cutils/log.h>
45 #include <cutils/properties.h>
46 #else
47 #include <stdio.h>
48 #include <string.h>
49 #define ALOGD printf
50 #define ALOGW printf
51 #endif
52 
53 #ifdef HAVE_ANDROID_OS
54 /* SIOCKILLADDR is an Android extension. */
55 #define SIOCKILLADDR 0x8939
56 #endif
57 
58 static int ifc_ctl_sock = -1;
59 static int ifc_ctl_sock6 = -1;
60 void printerr(char *fmt, ...);
61 
62 #define DBG 0
63 #define INET_ADDRLEN 4
64 #define INET6_ADDRLEN 16
65 
prefixLengthToIpv4Netmask(int prefix_length)66 in_addr_t prefixLengthToIpv4Netmask(int prefix_length)
67 {
68     in_addr_t mask = 0;
69 
70     // C99 (6.5.7): shifts of 32 bits have undefined results
71     if (prefix_length <= 0 || prefix_length > 32) {
72         return 0;
73     }
74 
75     mask = ~mask << (32 - prefix_length);
76     mask = htonl(mask);
77 
78     return mask;
79 }
80 
ipv4NetmaskToPrefixLength(in_addr_t mask)81 int ipv4NetmaskToPrefixLength(in_addr_t mask)
82 {
83     int prefixLength = 0;
84     uint32_t m = (uint32_t)ntohl(mask);
85     while (m & 0x80000000) {
86         prefixLength++;
87         m = m << 1;
88     }
89     return prefixLength;
90 }
91 
ipaddr_to_string(in_addr_t addr)92 static const char *ipaddr_to_string(in_addr_t addr)
93 {
94     struct in_addr in_addr;
95 
96     in_addr.s_addr = addr;
97     return inet_ntoa(in_addr);
98 }
99 
string_to_ip(const char * string,struct sockaddr_storage * ss)100 int string_to_ip(const char *string, struct sockaddr_storage *ss) {
101     struct addrinfo hints, *ai;
102     int ret;
103 
104     if (ss == NULL) {
105         return -EFAULT;
106     }
107 
108     memset(&hints, 0, sizeof(hints));
109     hints.ai_family = AF_UNSPEC;
110     hints.ai_flags = AI_NUMERICHOST;
111     hints.ai_socktype = SOCK_DGRAM;
112 
113     ret = getaddrinfo(string, NULL, &hints, &ai);
114     if (ret == 0) {
115         memcpy(ss, ai->ai_addr, ai->ai_addrlen);
116         freeaddrinfo(ai);
117     }
118 
119     return ret;
120 }
121 
ifc_init(void)122 int ifc_init(void)
123 {
124     int ret;
125     if (ifc_ctl_sock == -1) {
126         ifc_ctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
127         if (ifc_ctl_sock < 0) {
128             printerr("socket() failed: %s\n", strerror(errno));
129         }
130     }
131 
132     ret = ifc_ctl_sock < 0 ? -1 : 0;
133     if (DBG) printerr("ifc_init_returning %d", ret);
134     return ret;
135 }
136 
ifc_init6(void)137 int ifc_init6(void)
138 {
139     if (ifc_ctl_sock6 == -1) {
140         ifc_ctl_sock6 = socket(AF_INET6, SOCK_DGRAM, 0);
141         if (ifc_ctl_sock6 < 0) {
142             printerr("socket() failed: %s\n", strerror(errno));
143         }
144     }
145     return ifc_ctl_sock6 < 0 ? -1 : 0;
146 }
147 
ifc_close(void)148 void ifc_close(void)
149 {
150     if (DBG) printerr("ifc_close");
151     if (ifc_ctl_sock != -1) {
152         (void)close(ifc_ctl_sock);
153         ifc_ctl_sock = -1;
154     }
155 }
156 
ifc_close6(void)157 void ifc_close6(void)
158 {
159     if (ifc_ctl_sock6 != -1) {
160         (void)close(ifc_ctl_sock6);
161         ifc_ctl_sock6 = -1;
162     }
163 }
164 
ifc_init_ifr(const char * name,struct ifreq * ifr)165 static void ifc_init_ifr(const char *name, struct ifreq *ifr)
166 {
167     memset(ifr, 0, sizeof(struct ifreq));
168     strncpy(ifr->ifr_name, name, IFNAMSIZ);
169     ifr->ifr_name[IFNAMSIZ - 1] = 0;
170 }
171 
ifc_get_hwaddr(const char * name,void * ptr)172 int ifc_get_hwaddr(const char *name, void *ptr)
173 {
174     int r;
175     struct ifreq ifr;
176     ifc_init_ifr(name, &ifr);
177 
178     r = ioctl(ifc_ctl_sock, SIOCGIFHWADDR, &ifr);
179     if(r < 0) return -1;
180 
181     memcpy(ptr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
182     return 0;
183 }
184 
ifc_get_ifindex(const char * name,int * if_indexp)185 int ifc_get_ifindex(const char *name, int *if_indexp)
186 {
187     int r;
188     struct ifreq ifr;
189     ifc_init_ifr(name, &ifr);
190 
191     r = ioctl(ifc_ctl_sock, SIOCGIFINDEX, &ifr);
192     if(r < 0) return -1;
193 
194     *if_indexp = ifr.ifr_ifindex;
195     return 0;
196 }
197 
ifc_set_flags(const char * name,unsigned set,unsigned clr)198 static int ifc_set_flags(const char *name, unsigned set, unsigned clr)
199 {
200     struct ifreq ifr;
201     ifc_init_ifr(name, &ifr);
202 
203     if(ioctl(ifc_ctl_sock, SIOCGIFFLAGS, &ifr) < 0) return -1;
204     ifr.ifr_flags = (ifr.ifr_flags & (~clr)) | set;
205     return ioctl(ifc_ctl_sock, SIOCSIFFLAGS, &ifr);
206 }
207 
ifc_up(const char * name)208 int ifc_up(const char *name)
209 {
210     int ret = ifc_set_flags(name, IFF_UP, 0);
211     if (DBG) printerr("ifc_up(%s) = %d", name, ret);
212     return ret;
213 }
214 
ifc_down(const char * name)215 int ifc_down(const char *name)
216 {
217     int ret = ifc_set_flags(name, 0, IFF_UP);
218     if (DBG) printerr("ifc_down(%s) = %d", name, ret);
219     return ret;
220 }
221 
init_sockaddr_in(struct sockaddr * sa,in_addr_t addr)222 static void init_sockaddr_in(struct sockaddr *sa, in_addr_t addr)
223 {
224     struct sockaddr_in *sin = (struct sockaddr_in *) sa;
225     sin->sin_family = AF_INET;
226     sin->sin_port = 0;
227     sin->sin_addr.s_addr = addr;
228 }
229 
ifc_set_addr(const char * name,in_addr_t addr)230 int ifc_set_addr(const char *name, in_addr_t addr)
231 {
232     struct ifreq ifr;
233     int ret;
234 
235     ifc_init_ifr(name, &ifr);
236     init_sockaddr_in(&ifr.ifr_addr, addr);
237 
238     ret = ioctl(ifc_ctl_sock, SIOCSIFADDR, &ifr);
239     if (DBG) printerr("ifc_set_addr(%s, xx) = %d", name, ret);
240     return ret;
241 }
242 
243 /*
244  * Adds or deletes an IP address on an interface.
245  *
246  * Action is one of:
247  * - RTM_NEWADDR (to add a new address)
248  * - RTM_DELADDR (to delete an existing address)
249  *
250  * Returns zero on success and negative errno on failure.
251  */
ifc_act_on_address(int action,const char * name,const char * address,int prefixlen)252 int ifc_act_on_address(int action, const char *name, const char *address,
253                        int prefixlen) {
254     int ifindex, s, len, ret;
255     struct sockaddr_storage ss;
256     void *addr;
257     size_t addrlen;
258     struct {
259         struct nlmsghdr n;
260         struct ifaddrmsg r;
261         // Allow for IPv6 address, headers, and padding.
262         char attrbuf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
263                      NLMSG_ALIGN(sizeof(struct rtattr)) +
264                      NLMSG_ALIGN(INET6_ADDRLEN)];
265     } req;
266     struct rtattr *rta;
267     struct nlmsghdr *nh;
268     struct nlmsgerr *err;
269     char buf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
270              NLMSG_ALIGN(sizeof(struct nlmsgerr)) +
271              NLMSG_ALIGN(sizeof(struct nlmsghdr))];
272 
273     // Get interface ID.
274     ifindex = if_nametoindex(name);
275     if (ifindex == 0) {
276         return -errno;
277     }
278 
279     // Convert string representation to sockaddr_storage.
280     ret = string_to_ip(address, &ss);
281     if (ret) {
282         return ret;
283     }
284 
285     // Determine address type and length.
286     if (ss.ss_family == AF_INET) {
287         struct sockaddr_in *sin = (struct sockaddr_in *) &ss;
288         addr = &sin->sin_addr;
289         addrlen = INET_ADDRLEN;
290     } else if (ss.ss_family == AF_INET6) {
291         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
292         addr = &sin6->sin6_addr;
293         addrlen = INET6_ADDRLEN;
294     } else {
295         return -EAFNOSUPPORT;
296     }
297 
298     // Fill in netlink structures.
299     memset(&req, 0, sizeof(req));
300 
301     // Netlink message header.
302     req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.r));
303     req.n.nlmsg_type = action;
304     req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
305     req.n.nlmsg_pid = getpid();
306 
307     // Interface address message header.
308     req.r.ifa_family = ss.ss_family;
309     req.r.ifa_prefixlen = prefixlen;
310     req.r.ifa_index = ifindex;
311 
312     // Routing attribute. Contains the actual IP address.
313     rta = (struct rtattr *) (((char *) &req) + NLMSG_ALIGN(req.n.nlmsg_len));
314     rta->rta_type = IFA_LOCAL;
315     rta->rta_len = RTA_LENGTH(addrlen);
316     req.n.nlmsg_len = NLMSG_ALIGN(req.n.nlmsg_len) + RTA_LENGTH(addrlen);
317     memcpy(RTA_DATA(rta), addr, addrlen);
318 
319     s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
320     if (send(s, &req, req.n.nlmsg_len, 0) < 0) {
321         close(s);
322         return -errno;
323     }
324 
325     len = recv(s, buf, sizeof(buf), 0);
326     close(s);
327     if (len < 0) {
328         return -errno;
329     }
330 
331     // Parse the acknowledgement to find the return code.
332     nh = (struct nlmsghdr *) buf;
333     if (!NLMSG_OK(nh, (unsigned) len) || nh->nlmsg_type != NLMSG_ERROR) {
334         return -EINVAL;
335     }
336     err = NLMSG_DATA(nh);
337 
338     // Return code is negative errno.
339     return err->error;
340 }
341 
ifc_add_address(const char * name,const char * address,int prefixlen)342 int ifc_add_address(const char *name, const char *address, int prefixlen) {
343     return ifc_act_on_address(RTM_NEWADDR, name, address, prefixlen);
344 }
345 
ifc_del_address(const char * name,const char * address,int prefixlen)346 int ifc_del_address(const char *name, const char * address, int prefixlen) {
347     return ifc_act_on_address(RTM_DELADDR, name, address, prefixlen);
348 }
349 
350 /*
351  * Clears IPv6 addresses on the specified interface.
352  */
ifc_clear_ipv6_addresses(const char * name)353 int ifc_clear_ipv6_addresses(const char *name) {
354     char rawaddrstr[INET6_ADDRSTRLEN], addrstr[INET6_ADDRSTRLEN];
355     unsigned int prefixlen;
356     int lasterror = 0, i, j, ret;
357     char ifname[64];  // Currently, IFNAMSIZ = 16.
358     FILE *f = fopen("/proc/net/if_inet6", "r");
359     if (!f) {
360         return -errno;
361     }
362 
363     // Format:
364     // 20010db8000a0001fc446aa4b5b347ed 03 40 00 01    wlan0
365     while (fscanf(f, "%32s %*02x %02x %*02x %*02x %63s\n",
366                   rawaddrstr, &prefixlen, ifname) == 3) {
367         // Is this the interface we're looking for?
368         if (strcmp(name, ifname)) {
369             continue;
370         }
371 
372         // Put the colons back into the address.
373         for (i = 0, j = 0; i < 32; i++, j++) {
374             addrstr[j] = rawaddrstr[i];
375             if (i % 4 == 3) {
376                 addrstr[++j] = ':';
377             }
378         }
379         addrstr[j - 1] = '\0';
380 
381         // Don't delete the link-local address as well, or it will disable IPv6
382         // on the interface.
383         if (strncmp(addrstr, "fe80:", 5) == 0) {
384             continue;
385         }
386 
387         ret = ifc_del_address(ifname, addrstr, prefixlen);
388         if (ret) {
389             ALOGE("Deleting address %s/%d on %s: %s", addrstr, prefixlen, ifname,
390                  strerror(-ret));
391             lasterror = ret;
392         }
393     }
394 
395     fclose(f);
396     return lasterror;
397 }
398 
399 /*
400  * Clears IPv4 addresses on the specified interface.
401  */
ifc_clear_ipv4_addresses(const char * name)402 void ifc_clear_ipv4_addresses(const char *name) {
403     unsigned count, addr;
404     ifc_init();
405     for (count=0, addr=1;((addr != 0) && (count < 255)); count++) {
406         if (ifc_get_addr(name, &addr) < 0)
407             break;
408         if (addr)
409             ifc_set_addr(name, 0);
410     }
411     ifc_close();
412 }
413 
414 /*
415  * Clears all IP addresses on the specified interface.
416  */
ifc_clear_addresses(const char * name)417 int ifc_clear_addresses(const char *name) {
418     ifc_clear_ipv4_addresses(name);
419     return ifc_clear_ipv6_addresses(name);
420 }
421 
ifc_set_hwaddr(const char * name,const void * ptr)422 int ifc_set_hwaddr(const char *name, const void *ptr)
423 {
424     int r;
425     struct ifreq ifr;
426     ifc_init_ifr(name, &ifr);
427 
428     ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
429     memcpy(&ifr.ifr_hwaddr.sa_data, ptr, ETH_ALEN);
430     return ioctl(ifc_ctl_sock, SIOCSIFHWADDR, &ifr);
431 }
432 
ifc_set_mask(const char * name,in_addr_t mask)433 int ifc_set_mask(const char *name, in_addr_t mask)
434 {
435     struct ifreq ifr;
436     int ret;
437 
438     ifc_init_ifr(name, &ifr);
439     init_sockaddr_in(&ifr.ifr_addr, mask);
440 
441     ret = ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
442     if (DBG) printerr("ifc_set_mask(%s, xx) = %d", name, ret);
443     return ret;
444 }
445 
ifc_set_prefixLength(const char * name,int prefixLength)446 int ifc_set_prefixLength(const char *name, int prefixLength)
447 {
448     struct ifreq ifr;
449     // TODO - support ipv6
450     if (prefixLength > 32 || prefixLength < 0) return -1;
451 
452     in_addr_t mask = prefixLengthToIpv4Netmask(prefixLength);
453     ifc_init_ifr(name, &ifr);
454     init_sockaddr_in(&ifr.ifr_addr, mask);
455 
456     return ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
457 }
458 
ifc_get_addr(const char * name,in_addr_t * addr)459 int ifc_get_addr(const char *name, in_addr_t *addr)
460 {
461     struct ifreq ifr;
462     int ret = 0;
463 
464     ifc_init_ifr(name, &ifr);
465     if (addr != NULL) {
466         ret = ioctl(ifc_ctl_sock, SIOCGIFADDR, &ifr);
467         if (ret < 0) {
468             *addr = 0;
469         } else {
470             *addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr;
471         }
472     }
473     return ret;
474 }
475 
ifc_get_info(const char * name,in_addr_t * addr,int * prefixLength,unsigned * flags)476 int ifc_get_info(const char *name, in_addr_t *addr, int *prefixLength, unsigned *flags)
477 {
478     struct ifreq ifr;
479     ifc_init_ifr(name, &ifr);
480 
481     if (addr != NULL) {
482         if(ioctl(ifc_ctl_sock, SIOCGIFADDR, &ifr) < 0) {
483             *addr = 0;
484         } else {
485             *addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr;
486         }
487     }
488 
489     if (prefixLength != NULL) {
490         if(ioctl(ifc_ctl_sock, SIOCGIFNETMASK, &ifr) < 0) {
491             *prefixLength = 0;
492         } else {
493             *prefixLength = ipv4NetmaskToPrefixLength(
494                     ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr);
495         }
496     }
497 
498     if (flags != NULL) {
499         if(ioctl(ifc_ctl_sock, SIOCGIFFLAGS, &ifr) < 0) {
500             *flags = 0;
501         } else {
502             *flags = ifr.ifr_flags;
503         }
504     }
505 
506     return 0;
507 }
508 
ifc_act_on_ipv4_route(int action,const char * ifname,struct in_addr dst,int prefix_length,struct in_addr gw)509 int ifc_act_on_ipv4_route(int action, const char *ifname, struct in_addr dst, int prefix_length,
510       struct in_addr gw)
511 {
512     struct rtentry rt;
513     int result;
514     in_addr_t netmask;
515 
516     memset(&rt, 0, sizeof(rt));
517 
518     rt.rt_dst.sa_family = AF_INET;
519     rt.rt_dev = (void*) ifname;
520 
521     netmask = prefixLengthToIpv4Netmask(prefix_length);
522     init_sockaddr_in(&rt.rt_genmask, netmask);
523     init_sockaddr_in(&rt.rt_dst, dst.s_addr);
524     rt.rt_flags = RTF_UP;
525 
526     if (prefix_length == 32) {
527         rt.rt_flags |= RTF_HOST;
528     }
529 
530     if (gw.s_addr != 0) {
531         rt.rt_flags |= RTF_GATEWAY;
532         init_sockaddr_in(&rt.rt_gateway, gw.s_addr);
533     }
534 
535     ifc_init();
536 
537     if (ifc_ctl_sock < 0) {
538         return -errno;
539     }
540 
541     result = ioctl(ifc_ctl_sock, action, &rt);
542     if (result < 0) {
543         if (errno == EEXIST) {
544             result = 0;
545         } else {
546             result = -errno;
547         }
548     }
549     ifc_close();
550     return result;
551 }
552 
553 /* deprecated - v4 only */
ifc_create_default_route(const char * name,in_addr_t gw)554 int ifc_create_default_route(const char *name, in_addr_t gw)
555 {
556     struct in_addr in_dst, in_gw;
557 
558     in_dst.s_addr = 0;
559     in_gw.s_addr = gw;
560 
561     int ret = ifc_act_on_ipv4_route(SIOCADDRT, name, in_dst, 0, in_gw);
562     if (DBG) printerr("ifc_create_default_route(%s, %d) = %d", name, gw, ret);
563     return ret;
564 }
565 
566 // Needed by code in hidden partner repositories / branches, so don't delete.
ifc_enable(const char * ifname)567 int ifc_enable(const char *ifname)
568 {
569     int result;
570 
571     ifc_init();
572     result = ifc_up(ifname);
573     ifc_close();
574     return result;
575 }
576 
577 // Needed by code in hidden partner repositories / branches, so don't delete.
ifc_disable(const char * ifname)578 int ifc_disable(const char *ifname)
579 {
580     unsigned addr, count;
581     int result;
582 
583     ifc_init();
584     result = ifc_down(ifname);
585 
586     ifc_set_addr(ifname, 0);
587     for (count=0, addr=1;((addr != 0) && (count < 255)); count++) {
588        if (ifc_get_addr(ifname, &addr) < 0)
589             break;
590        if (addr)
591           ifc_set_addr(ifname, 0);
592     }
593 
594     ifc_close();
595     return result;
596 }
597 
ifc_reset_connections(const char * ifname,const int reset_mask)598 int ifc_reset_connections(const char *ifname, const int reset_mask)
599 {
600 #ifdef HAVE_ANDROID_OS
601     int result, success;
602     in_addr_t myaddr = 0;
603     struct ifreq ifr;
604     struct in6_ifreq ifr6;
605 
606     if (reset_mask & RESET_IPV4_ADDRESSES) {
607         /* IPv4. Clear connections on the IP address. */
608         ifc_init();
609         if (!(reset_mask & RESET_IGNORE_INTERFACE_ADDRESS)) {
610             ifc_get_info(ifname, &myaddr, NULL, NULL);
611         }
612         ifc_init_ifr(ifname, &ifr);
613         init_sockaddr_in(&ifr.ifr_addr, myaddr);
614         result = ioctl(ifc_ctl_sock, SIOCKILLADDR,  &ifr);
615         ifc_close();
616     } else {
617         result = 0;
618     }
619 
620     if (reset_mask & RESET_IPV6_ADDRESSES) {
621         /*
622          * IPv6. On Linux, when an interface goes down it loses all its IPv6
623          * addresses, so we don't know which connections belonged to that interface
624          * So we clear all unused IPv6 connections on the device by specifying an
625          * empty IPv6 address.
626          */
627         ifc_init6();
628         // This implicitly specifies an address of ::, i.e., kill all IPv6 sockets.
629         memset(&ifr6, 0, sizeof(ifr6));
630         success = ioctl(ifc_ctl_sock6, SIOCKILLADDR,  &ifr6);
631         if (result == 0) {
632             result = success;
633         }
634         ifc_close6();
635     }
636 
637     return result;
638 #else
639     return 0;
640 #endif
641 }
642 
643 /*
644  * Removes the default route for the named interface.
645  */
ifc_remove_default_route(const char * ifname)646 int ifc_remove_default_route(const char *ifname)
647 {
648     struct rtentry rt;
649     int result;
650 
651     ifc_init();
652     memset(&rt, 0, sizeof(rt));
653     rt.rt_dev = (void *)ifname;
654     rt.rt_flags = RTF_UP|RTF_GATEWAY;
655     init_sockaddr_in(&rt.rt_dst, 0);
656     if ((result = ioctl(ifc_ctl_sock, SIOCDELRT, &rt)) < 0) {
657         ALOGD("failed to remove default route for %s: %s", ifname, strerror(errno));
658     }
659     ifc_close();
660     return result;
661 }
662 
663 int
ifc_configure(const char * ifname,in_addr_t address,uint32_t prefixLength,in_addr_t gateway,in_addr_t dns1,in_addr_t dns2)664 ifc_configure(const char *ifname,
665         in_addr_t address,
666         uint32_t prefixLength,
667         in_addr_t gateway,
668         in_addr_t dns1,
669         in_addr_t dns2) {
670 
671     char dns_prop_name[PROPERTY_KEY_MAX];
672 
673     ifc_init();
674 
675     if (ifc_up(ifname)) {
676         printerr("failed to turn on interface %s: %s\n", ifname, strerror(errno));
677         ifc_close();
678         return -1;
679     }
680     if (ifc_set_addr(ifname, address)) {
681         printerr("failed to set ipaddr %s: %s\n", ipaddr_to_string(address), strerror(errno));
682         ifc_close();
683         return -1;
684     }
685     if (ifc_set_prefixLength(ifname, prefixLength)) {
686         printerr("failed to set prefixLength %d: %s\n", prefixLength, strerror(errno));
687         ifc_close();
688         return -1;
689     }
690     if (ifc_create_default_route(ifname, gateway)) {
691         printerr("failed to set default route %s: %s\n", ipaddr_to_string(gateway), strerror(errno));
692         ifc_close();
693         return -1;
694     }
695 
696     ifc_close();
697 
698     snprintf(dns_prop_name, sizeof(dns_prop_name), "net.%s.dns1", ifname);
699     property_set(dns_prop_name, dns1 ? ipaddr_to_string(dns1) : "");
700     snprintf(dns_prop_name, sizeof(dns_prop_name), "net.%s.dns2", ifname);
701     property_set(dns_prop_name, dns2 ? ipaddr_to_string(dns2) : "");
702 
703     return 0;
704 }
705