sbin/newfs_msdos: Bring in FreeBSD/Git 902f77041b477be4d9d99608b463be01ac7611ea
[dragonfly.git] / contrib / openresolv / resolvconf.in
1 #!/bin/sh
2 # Copyright (c) 2007-2016 Roy Marples
3 # All rights reserved
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 #     * Redistributions of source code must retain the above copyright
9 #       notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 #       copyright notice, this list of conditions and the following
12 #       disclaimer in the documentation and/or other materials provided
13 #       with the distribution.
14 #
15 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27 RESOLVCONF="$0"
28 OPENRESOLV_VERSION="3.9.0"
29 SYSCONFDIR=@SYSCONFDIR@
30 LIBEXECDIR=@LIBEXECDIR@
31 VARDIR=@VARDIR@
32 RCDIR=@RCDIR@
33 RESTARTCMD=@RESTARTCMD@
34
35 if [ "$1" = "--version" ]; then
36         echo "openresolv $OPENRESOLV_VERSION"
37         echo "Copyright (c) 2007-2016 Roy Marples"
38         exit 0
39 fi
40
41 # Disregard dhcpcd setting
42 unset interface_order state_dir
43
44 # If you change this, change the test in VFLAG and libc.in as well
45 local_nameservers="127.* 0.0.0.0 255.255.255.255 ::1"
46
47 dynamic_order="tap[0-9]* tun[0-9]* vpn vpn[0-9]* ppp[0-9]* ippp[0-9]*"
48 interface_order="lo lo[0-9]*"
49 name_server_blacklist="0.0.0.0"
50
51 # Support original resolvconf configuration layout
52 # as well as the openresolv config file
53 if [ -f "$SYSCONFDIR"/resolvconf.conf ]; then
54         . "$SYSCONFDIR"/resolvconf.conf
55         [ -n "$state_dir" ] && VARDIR="$state_dir"
56 elif [ -d "$SYSCONFDIR/resolvconf" ]; then
57         SYSCONFDIR="$SYSCONFDIR/resolvconf"
58         if [ -f "$SYSCONFDIR"/interface-order ]; then
59                 interface_order="$(cat "$SYSCONFDIR"/interface-order)"
60         fi
61 fi
62 IFACEDIR="$VARDIR/interfaces"
63 METRICDIR="$VARDIR/metrics"
64 PRIVATEDIR="$VARDIR/private"
65 EXCLUSIVEDIR="$VARDIR/exclusive"
66 LOCKDIR="$VARDIR/lock"
67 _PWD="$PWD"
68
69 warn()
70 {
71         echo "$*" >&2
72 }
73
74 error_exit()
75 {
76         echo "$*" >&2
77         exit 1
78 }
79
80 usage()
81 {
82         cat <<-EOF
83         Usage: ${RESOLVCONF##*/} [options] command [argument]
84
85         Inform the system about any DNS updates.
86
87         Commands:
88           -a \$INTERFACE    Add DNS information to the specified interface
89                            (DNS supplied via stdin in resolv.conf format)
90           -d \$INTERFACE    Delete DNS information from the specified interface
91           -h               Show this help cruft
92           -i [\$PATTERN]    Show interfaces that have supplied DNS information
93                    optionally from interfaces that match the specified
94                    pattern
95           -l [\$PATTERN]    Show DNS information, optionally from interfaces
96                            that match the specified pattern
97
98           -u               Run updates from our current DNS information
99           --version        Echo the ${RESOLVCONF##*/} version
100
101         Options:
102           -f               Ignore non existent interfaces
103           -m metric        Give the added DNS information a metric
104           -p               Mark the interface as private
105           -x               Mark the interface as exclusive
106
107         Subscriber and System Init Commands:
108           -I               Init the state dir
109           -r \$SERVICE      Restart the system service
110                            (restarting a non-existent or non-running service
111                             should have no output and return 0)
112           -R               Show the system service restart command
113           -v [\$PATTERN]    echo NEWDOMAIN, NEWSEARCH and NEWNS variables to
114                            the console
115           -V [\$PATTERN]    Same as -v, but only uses configuration in
116                            $SYSCONFDIR/resolvconf.conf
117         EOF
118         [ -z "$1" ] && exit 0
119         echo
120         error_exit "$*"
121 }
122
123 # Strip any trailing dot from each name as a FQDN does not belong
124 # in resolv.conf(5)
125 # If you think otherwise, capture a DNS trace and you'll see libc
126 # will strip it regardless.
127 # This also solves setting up duplicate zones in our subscribers.
128 strip_trailing_dots()
129 {
130         local n= d=
131
132         for n; do
133                 printf "$d%s" "${n%.}"
134                 d=" "
135         done
136         printf "\n"
137 }
138
139 private_iface()
140 {
141         local p
142
143         # Allow expansion
144         cd "$IFACEDIR"
145
146         # Public interfaces override private ones.
147         for p in $public_interfaces; do
148                 case "$iface" in
149                 "$p"|"$p":*) return 1;;
150                 esac
151         done
152
153         if [ -e "$PRIVATEDIR/$iface" ]; then
154                 return 0
155         fi
156         
157         for p in $private_interfaces; do
158                 case "$iface" in
159                 "$p"|"$p":*) return 0;;
160                 esac
161         done
162
163         # Not a private interface
164         return 1
165 }
166
167 # Parse resolv.conf's and make variables
168 # for domain name servers, search name servers and global nameservers
169 parse_resolv()
170 {
171         local line= ns= ds= search= d= n= newns=
172         local new=true iface= private=false p= domain= l= islocal=
173
174         newns=
175
176         while read -r line; do
177                 case "$line" in
178                 "# resolv.conf from "*)
179                         if ${new}; then
180                                 iface="${line#\# resolv.conf from *}"
181                                 new=false
182                                 if private_iface "$iface"; then
183                                         private=true
184                                 else
185                                         private=false
186                                 fi
187                         fi
188                         ;;
189                 "nameserver "*)
190                         islocal=false
191                         for l in $local_nameservers; do
192                                 case "${line#* }" in
193                                 $l)
194                                         islocal=true
195                                         echo "LOCALNAMESERVERS=\"\$LOCALNAMESERVERS ${line#* }\""
196                                         break
197                                         ;;
198                                 esac
199                         done
200                         $islocal || ns="$ns${line#* } "
201                         ;;
202                 "domain "*)
203                         search="$(strip_trailing_dots ${line#* })"
204                         if [ -z "$domain" ]; then
205                                 domain="$search"
206                                 echo "DOMAIN=\"$domain\""
207                         fi
208                         ;;
209                 "search "*)
210                         search="$(strip_trailing_dots ${line#* })"
211                         ;;
212                 *)
213                         [ -n "$line" ] && continue
214                         if [ -n "$ns" -a -n "$search" ]; then
215                                 newns=
216                                 for n in $ns; do
217                                         newns="$newns${newns:+,}$n"
218                                 done
219                                 ds=
220                                 for d in $search; do
221                                         ds="$ds${ds:+ }$d:$newns"
222                                 done
223                                 echo "DOMAINS=\"\$DOMAINS $ds\""
224                         fi
225                         echo "SEARCH=\"\$SEARCH $search\""
226                         if ! $private; then
227                                 echo "NAMESERVERS=\"\$NAMESERVERS $ns\""
228                         fi
229                         ns=
230                         search=
231                         new=true
232                         ;;
233                 esac
234         done
235 }
236
237 uniqify()
238 {
239         local result=
240         while [ -n "$1" ]; do
241                 case " $result " in
242                 *" $1 "*);;
243                 *) result="$result $1";;
244                 esac
245                 shift
246         done
247         echo "${result# *}"
248 }
249
250 dirname()
251 {
252         local dir= OIFS="$IFS"
253         local IFS=/
254         set -- $@
255         IFS="$OIFS"
256         if [ -n "$1" ]; then
257                 printf %s .
258         else
259                 shift
260         fi
261         while [ -n "$2" ]; do
262                 printf "/%s" "$1"
263                 shift
264         done
265         printf "\n"
266 }
267
268 config_mkdirs()
269 {
270         local e=0 f d
271         for f; do
272                 [ -n "$f" ] || continue
273                 d="$(dirname "$f")"
274                 if [ ! -d "$d" ]; then
275                         if type install >/dev/null 2>&1; then
276                                 install -d "$d" || e=$?
277                         else
278                                 mkdir "$d" || e=$?
279                         fi
280                 fi
281         done
282         return $e
283 }
284
285 # With the advent of alternative init systems, it's possible to have
286 # more than one installed. So we need to try and guess what one we're
287 # using unless overriden by configure.
288 # Note that restarting a service is a last resort - the subscribers
289 # should make a reasonable attempt to reconfigre the service via some
290 # method, normally SIGHUP.
291 detect_init()
292 {
293         [ -n "$RESTARTCMD" ] && return 0
294
295         # Detect the running init system.
296         # As systemd and OpenRC can be installed on top of legacy init
297         # systems we try to detect them first.
298         local status="@STATUSARG@"
299         : ${status:=status}
300         if [ -x /bin/systemctl -a -S /run/systemd/private ]; then
301                 RESTARTCMD="if /bin/systemctl --quiet is-active \$1.service; then
302         /bin/systemctl restart \$1.service;
303 fi"
304         elif [ -x /usr/bin/systemctl -a -S /run/systemd/private ]; then
305                 RESTARTCMD="if /usr/bin/systemctl --quiet is-active \$1.service; then
306         /usr/bin/systemctl restart \$1.service;
307 fi"
308         elif [ -x /sbin/rc-service -a \
309             -s /libexec/rc/init.d/softlevel -o -s /run/openrc/softlevel ]
310         then
311                 RESTARTCMD="/sbin/rc-service -i \$1 -- -Ds restart"
312         elif [ -x /usr/sbin/invoke-rc.d ]; then
313                 RCDIR=/etc/init.d
314                 RESTARTCMD="if /usr/sbin/invoke-rc.d --quiet \$1 status 1>/dev/null 2>&1; then
315         /usr/sbin/invoke-rc.d \$1 restart;
316 fi"
317         elif [ -x /sbin/service ]; then
318                 # Old RedHat
319                 RCDIR=/etc/init.d
320                 RESTARTCMD="if /sbin/service \$1; then
321         /sbin/service \$1 restart;
322 fi"
323         elif [ -x /usr/sbin/service ]; then
324                 # Could be FreeBSD
325                 RESTARTCMD="if /usr/sbin/service \$1 $status 1>/dev/null 2>&1; then
326         /usr/sbin/service \$1 restart;
327 fi"
328         elif [ -x /bin/sv ]; then
329                 RESTARTCMD="/bin/sv status \$1 >/dev/null 2>&1 && /bin/sv try-restart \$1"
330         elif [ -x /usr/bin/sv ]; then
331                 RESTARTCMD="/usr/bin/sv status \$1 >/dev/null 2>&1 && /usr/bin/sv try-restart \$1"
332         elif [ -e /etc/arch-release -a -d /etc/rc.d ]; then
333                 RCDIR=/etc/rc.d
334                 RESTARTCMD="if [ -e /var/run/daemons/\$1 ]; then
335         /etc/rc.d/\$1 restart;
336 fi"
337         elif [ -e /etc/slackware-version -a -d /etc/rc.d ]; then
338                 RESTARTCMD="if /etc/rc.d/rc.\$1 status 1>/dev/null 2>&1; then
339         /etc/rc.d/rc.\$1 restart;
340 fi"
341         elif [ -e /etc/rc.d/rc.subr -a -d /etc/rc.d ]; then
342                 # OpenBSD
343                 RESTARTCMD="if /etc/rc.d/\$1 check 1>/dev/null 2>&1; then
344         /etc/rc.d/\$1 restart;
345 fi"
346         else
347                 for x in /etc/init.d/rc.d /etc/rc.d /etc/init.d; do
348                         [ -d $x ] || continue
349                         RESTARTCMD="if $x/\$1 $status 1>/dev/null 2>&1; then
350         $x/\$1 restart;
351 fi"
352                         break
353                 done
354         fi
355
356         if [ -z "$RESTARTCMD" ]; then
357                 if [ "$NOINIT_WARNED" != true ]; then
358                         warn "could not detect a useable init system"
359                         _NOINIT_WARNED=true
360                 fi
361                 return 1
362         fi
363         _NOINIT_WARNED=
364         return 0
365 }
366
367 echo_resolv()
368 {
369         local line= OIFS="$IFS"
370
371         [ -n "$1" -a -f "$IFACEDIR/$1" ] || return 1
372         echo "# resolv.conf from $1"
373         # Our variable maker works of the fact each resolv.conf per interface
374         # is separated by blank lines.
375         # So we remove them when echoing them.
376         while read -r line; do
377                 IFS="$OIFS"
378                 if [ -n "$line" ]; then
379                         # We need to set IFS here to preserve any whitespace
380                         IFS=''
381                         printf "%s\n" "$line"
382                 fi
383         done < "$IFACEDIR/$1"
384         IFS="$OIFS"
385 }
386
387 list_resolv()
388 {
389         [ -d "$IFACEDIR" ] || return 0
390
391         local report=false list= retval=0 cmd="$1" excl=
392         shift
393
394         case "$IF_EXCLUSIVE" in
395         [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
396                 if [ -d "$EXCLUSIVEDIR" ]; then
397                         cd "$EXCLUSIVEDIR"
398                         for i in *; do
399                                 if [ -f "$i" ]; then
400                                         list="${i#* }"
401                                         break
402                                 fi
403                         done
404                 fi
405                 excl=true
406                 cd "$IFACEDIR"
407                 for i in $inclusive_interfaces; do
408                         if [ -f "$i" -a "$list" = "$i" ]; then
409                                 list=
410                                 excl=false
411                                 break
412                         fi
413                 done
414                 ;;
415         *)
416                 excl=false
417                 ;;
418         esac
419
420         # If we have an interface ordering list, then use that.
421         # It works by just using pathname expansion in the interface directory.
422         if [ -n "$1" ]; then
423                 list="$*"
424                 $force || report=true
425         elif ! $excl; then
426                 cd "$IFACEDIR"
427                 for i in $interface_order; do
428                         [ -f "$i" ] && list="$list $i"
429                         for ii in "$i":* "$i".*; do
430                                 [ -f "$ii" ] && list="$list $ii"
431                         done
432                 done
433                 for i in $dynamic_order; do
434                         if [ -e "$i" -a ! -e "$METRICDIR/"*" $i" ]; then
435                                 list="$list $i"
436                         fi
437                         for ii in "$i":* "$i".*; do
438                                 if [ -f "$ii" -a ! -e "$METRICDIR/"*" $ii" ]; then
439                                         list="$list $ii"
440                                 fi
441                         done
442                 done
443                 if [ -d "$METRICDIR" ]; then
444                         cd "$METRICDIR"
445                         for i in *; do
446                                 [ -f "$i" ] && list="$list ${i#* }"
447                         done
448                 fi
449                 list="$list *"
450         fi
451
452         cd "$IFACEDIR"
453         retval=1
454         for i in $(uniqify $list); do
455                 # Only list interfaces which we really have
456                 if ! [ -f "$i" ]; then
457                         if $report; then
458                                 echo "No resolv.conf for interface $i" >&2
459                                 retval=2
460                         fi
461                         continue
462                 fi
463                 
464                 if [ "$cmd" = i -o "$cmd" = "-i" ]; then
465                         printf %s "$i "
466                 else
467                         echo_resolv "$i" && echo
468                 fi
469                 [ $? = 0 -a "$retval" = 1 ] && retval=0
470         done
471         [ "$cmd" = i -o "$cmd" = "-i" ] && echo
472         return $retval
473 }
474
475 list_remove() {
476         local list= e= l= result= found= retval=0
477
478         [ -z "$2" ] && return 0
479         eval list=\"\$$1\"
480         shift
481
482         set -f
483         for e; do
484                 found=false
485                 for l in $list; do
486                         case "$e" in
487                         $l) found=true;;
488                         esac
489                         $found && break
490                 done
491                 if $found; then
492                         retval=$(($retval + 1))
493                 else
494                         result="$result $e"
495                 fi
496         done
497         set +f
498         echo "${result# *}"
499         return $retval
500 }
501
502 echo_prepend()
503 {
504         echo "# Generated by resolvconf"
505         if [ -n "$search_domains" ]; then
506                 echo "search $search_domains"
507         fi
508         for n in $name_servers; do
509                 echo "nameserver $n"
510         done
511         echo
512 }
513
514 echo_append()
515 {
516         echo "# Generated by resolvconf"
517         if [ -n "$search_domains_append" ]; then
518                 echo "search $search_domains_append"
519         fi
520         for n in $name_servers_append; do
521                 echo "nameserver $n"
522         done
523         echo
524 }
525
526 replace()
527 {
528         local r= k= f= v= val= sub=
529
530         while read -r keyword value; do
531                 for r in $replace; do
532                         k="${r%%/*}"
533                         r="${r#*/}"
534                         f="${r%%/*}"
535                         r="${r#*/}"
536                         v="${r%%/*}"
537                         case "$keyword" in
538                         $k)
539                                 case "$value" in
540                                 $f) value="$v";;
541                                 esac
542                                 ;;
543                         esac
544                 done
545                 val=
546                 for sub in $value; do
547                         for r in $replace_sub; do
548                                 k="${r%%/*}"
549                                 r="${r#*/}"
550                                 f="${r%%/*}"
551                                 r="${r#*/}"
552                                 v="${r%%/*}"
553                                 case "$keyword" in
554                                 $k)
555                                         case "$sub" in
556                                         $f) sub="$v";;
557                                         esac
558                                         ;;
559                                 esac
560                         done
561                         val="$val${val:+ }$sub"
562                 done
563                 printf "%s %s\n" "$keyword" "$val"
564         done
565 }
566
567 make_vars()
568 {
569         local newdomains= d= dn= newns= ns=
570
571         # Clear variables
572         DOMAIN=
573         DOMAINS=
574         SEARCH=
575         NAMESERVERS=
576         LOCALNAMESERVERS=
577         
578         if [ -n "$name_servers" -o -n "$search_domains" ]; then
579                 eval "$(echo_prepend | parse_resolv)"
580         fi
581         if [ -z "$VFLAG" ]; then
582                 IF_EXCLUSIVE=1
583                 list_resolv -i "$@" >/dev/null || IF_EXCLUSIVE=0
584                 eval "$(list_resolv -l "$@" | replace | parse_resolv)"
585         fi
586         if [ -n "$name_servers_append" -o -n "$search_domains_append" ]; then
587                 eval "$(echo_append | parse_resolv)"
588         fi
589
590         # Ensure that we only list each domain once
591         for d in $DOMAINS; do
592                 dn="${d%%:*}"
593                 list_remove domain_blacklist "$dn" >/dev/null || continue
594                 case " $newdomains" in
595                 *" ${dn}:"*) continue;;
596                 esac
597                 newns=
598                 for nd in $DOMAINS; do
599                         if [ "$dn" = "${nd%%:*}" ]; then
600                                 ns="${nd#*:}"
601                                 while [ -n "$ns" ]; do
602                                         case ",$newns," in
603                                         *,${ns%%,*},*) ;;
604                                         *) list_remove name_server_blacklist \
605                                                 "${ns%%,*}" >/dev/null \
606                                         && newns="$newns${newns:+,}${ns%%,*}";;
607                                         esac
608                                         [ "$ns" = "${ns#*,}" ] && break
609                                         ns="${ns#*,}"
610                                 done
611                         fi
612                 done
613                 if [ -n "$newns" ]; then
614                         newdomains="$newdomains${newdomains:+ }$dn:$newns"
615                 fi
616         done
617         DOMAIN="$(list_remove domain_blacklist $DOMAIN)"
618         SEARCH="$(uniqify $SEARCH)"
619         SEARCH="$(list_remove domain_blacklist $SEARCH)"
620         NAMESERVERS="$(uniqify $NAMESERVERS)"
621         NAMESERVERS="$(list_remove name_server_blacklist $NAMESERVERS)"
622         LOCALNAMESERVERS="$(uniqify $LOCALNAMESERVERS)"
623         LOCALNAMESERVERS="$(list_remove name_server_blacklist $LOCALNAMESERVERS)"
624         echo "DOMAIN='$DOMAIN'"
625         echo "SEARCH='$SEARCH'"
626         echo "NAMESERVERS='$NAMESERVERS'"
627         echo "LOCALNAMESERVERS='$LOCALNAMESERVERS'"
628         echo "DOMAINS='$newdomains'"
629 }
630
631 force=false
632 VFLAG=
633 while getopts a:Dd:fhIilm:pRruvVx OPT; do
634         case "$OPT" in
635         f) force=true;;
636         h) usage;;
637         m) IF_METRIC="$OPTARG";;
638         p) IF_PRIVATE=1;;
639         V)
640                 VFLAG=1
641                 if [ "$local_nameservers" = \
642                     "127.* 0.0.0.0 255.255.255.255 ::1" ]
643                 then
644                         local_nameservers=
645                 fi
646                 ;;
647         x) IF_EXCLUSIVE=1;;
648         '?') ;;
649         *) cmd="$OPT"; iface="$OPTARG";;
650         esac
651 done
652 shift $(($OPTIND - 1))
653 args="$iface${iface:+ }$*"
654
655 # -I inits the state dir
656 if [ "$cmd" = I ]; then
657         if [ -d "$VARDIR" ]; then
658                 rm -rf "$VARDIR"/*
659         fi
660         exit $?
661 fi
662
663 # -D ensures that the listed config file base dirs exist
664 if [ "$cmd" = D ]; then
665         config_mkdirs "$@"
666         exit $?
667 fi
668
669 # -l lists our resolv files, optionally for a specific interface
670 if [ "$cmd" = l -o "$cmd" = i ]; then
671         list_resolv "$cmd" "$args"
672         exit $?
673 fi
674
675 # Restart a service or echo the command to restart a service
676 if [ "$cmd" = r -o "$cmd" = R ]; then
677         detect_init || exit 1
678         if [ "$cmd" = r ]; then
679                 set -- $args
680                 eval $RESTARTCMD
681         else
682                 echo "$RESTARTCMD"
683         fi
684         exit $?
685 fi
686
687 # Not normally needed, but subscribers should be able to run independently
688 if [ "$cmd" = v -o -n "$VFLAG" ]; then
689         make_vars "$iface"
690         exit $?
691 fi
692
693 # Test that we have valid options
694 if [ "$cmd" = a -o "$cmd" = d ]; then
695         if [ -z "$iface" ]; then
696                 usage "Interface not specified"
697         fi
698 elif [ "$cmd" != u ]; then
699         [ -n "$cmd" -a "$cmd" != h ] && usage "Unknown option $cmd"
700         usage
701 fi
702
703 if [ "$cmd" = a ]; then
704         for x in '/' \\ ' ' '*'; do
705                 case "$iface" in
706                 *[$x]*) error_exit "$x not allowed in interface name";;
707                 esac
708         done
709         for x in '.' '-' '~'; do
710                 case "$iface" in
711                 [$x]*) error_exit \
712                         "$x not allowed at start of interface name";;
713                 esac
714         done
715         [ "$cmd" = a -a -t 0 ] && error_exit "No file given via stdin"
716 fi
717
718 if [ ! -d "$VARDIR" ]; then
719         if [ -L "$VARDIR" ]; then
720                 dir="$(readlink "$VARDIR")"
721                 # link maybe relative
722                 cd "${VARDIR%/*}"
723                 if ! mkdir -m 0755 -p "$dir"; then
724                         error_exit "Failed to create needed" \
725                                 "directory $dir"
726                 fi
727         else
728                 if ! mkdir -m 0755 -p "$VARDIR"; then
729                         error_exit "Failed to create needed" \
730                                 "directory $VARDIR"
731                 fi
732         fi
733 fi
734
735 if [ ! -d "$IFACEDIR" ]; then
736         mkdir -m 0755 -p "$IFACEDIR" || \
737                 error_exit "Failed to create needed directory $IFACEDIR"
738         if [ "$cmd" = d ]; then
739                 # Provide the same error messages as below
740                 if ! ${force}; then
741                         cd "$IFACEDIR"
742                         for i in $args; do
743                                 warn "No resolv.conf for interface $i"
744                         done
745                 fi
746                 ${force}
747                 exit $?
748         fi
749 fi
750
751 # An interface was added, changed, deleted or a general update was called.
752 # Due to exclusivity we need to ensure that this is an atomic operation.
753 # Our subscribers *may* need this as well if the init system is sub par.
754 # As such we spinlock at this point as best we can.
755 # We don't use flock(1) because it's not widely available and normally resides
756 # in /usr which we do our very best to operate without.
757 [ -w "$VARDIR" ] || error_exit "Cannot write to $LOCKDIR"
758 : ${lock_timeout:=10}
759 while true; do
760         if mkdir "$LOCKDIR" 2>/dev/null; then
761                 trap 'rm -rf "$LOCKDIR";' EXIT
762                 trap 'rm -rf "$LOCKDIR"; exit 1' INT QUIT ABRT SEGV ALRM TERM
763                 echo $$ >"$LOCKDIR/pid"
764                 break
765         fi
766         pid=$(cat "$LOCKDIR/pid")
767         if ! kill -0 "$pid"; then
768                 warn "clearing stale lock pid $pid"
769                 rm -rf "$LOCKDIR"
770                 continue
771         fi
772         lock_timeout=$(($lock_timeout - 1))
773         if [ "$lock_timeout" -le 0 ]; then
774                 error_exit "timed out waiting for lock from pid $pid"
775         fi
776         sleep 1
777 done
778
779 case "$cmd" in
780 a)
781         # Read resolv.conf from stdin
782         resolv="$(cat)"
783         changed=false
784         changedfile=false
785         # If what we are given matches what we have, then do nothing
786         if [ -e "$IFACEDIR/$iface" ]; then
787                 if [ "$(echo "$resolv")" != \
788                         "$(cat "$IFACEDIR/$iface")" ]
789                 then
790                         changed=true
791                         changedfile=true
792                 fi
793         else
794                 changed=true
795                 changedfile=true
796         fi
797
798         # Set metric and private before creating the interface resolv.conf file
799         # to ensure that it will have the correct flags
800         [ ! -d "$METRICDIR" ] && mkdir "$METRICDIR"
801         oldmetric="$METRICDIR/"*" $iface"
802         newmetric=
803         if [ -n "$IF_METRIC" ]; then
804                 # Pad metric to 6 characters, so 5 is less than 10
805                 while [ ${#IF_METRIC} -le 6 ]; do
806                         IF_METRIC="0$IF_METRIC"
807                 done
808                 newmetric="$METRICDIR/$IF_METRIC $iface"
809         fi
810         rm -f "$METRICDIR/"*" $iface"
811         [ "$oldmetric" != "$newmetric" -a \
812             "$oldmetric" != "$METRICDIR/* $iface" ] &&
813                 changed=true
814         [ -n "$newmetric" ] && echo " " >"$newmetric"
815
816         case "$IF_PRIVATE" in
817         [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
818                 if [ ! -d "$PRIVATEDIR" ]; then
819                         [ -e "$PRIVATEDIR" ] && rm "$PRIVATEDIR"
820                         mkdir "$PRIVATEDIR"
821                 fi
822                 [ -e "$PRIVATEDIR/$iface" ] || changed=true
823                 [ -d "$PRIVATEDIR" ] && echo " " >"$PRIVATEDIR/$iface"
824                 ;;
825         *)
826                 if [ -e "$PRIVATEDIR/$iface" ]; then
827                         rm -f "$PRIVATEDIR/$iface"
828                         changed=true
829                 fi
830                 ;;
831         esac
832
833         oldexcl=
834         for x in "$EXCLUSIVEDIR/"*" $iface"; do
835                 if [ -f "$x" ]; then
836                         oldexcl="$x"
837                         break
838                 fi
839         done
840         case "$IF_EXCLUSIVE" in
841         [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
842                 if [ ! -d "$EXCLUSIVEDIR" ]; then
843                         [ -e "$EXCLUSIVEDIR" ] && rm "$EXCLUSIVEDIR"
844                         mkdir "$EXCLUSIVEDIR"
845                 fi
846                 cd "$EXCLUSIVEDIR"
847                 for x in *; do
848                         [ -f "$x" ] && break
849                 done
850                 if [ "${x#* }" != "$iface" ]; then
851                         if [ "$x" = "${x% *}" ]; then
852                                 x=10000000
853                         else
854                                 x="${x% *}"
855                         fi
856                         if [ "$x" = "0000000" ]; then
857                                 warn "exclusive underflow"
858                         else
859                                 x=$(($x - 1))
860                         fi
861                         if [ -d "$EXCLUSIVEDIR" ]; then
862                                 echo " " >"$EXCLUSIVEDIR/$x $iface"
863                         fi
864                         changed=true
865                 fi
866                 ;;
867         *)
868                 if [ -f "$oldexcl" ]; then
869                         rm -f "$oldexcl"
870                         changed=true
871                 fi
872                 ;;
873         esac
874
875         if $changedfile; then
876                 printf "%s\n" "$resolv" >"$IFACEDIR/$iface" || exit $?
877         elif ! $changed; then
878                 exit 0
879         fi
880         unset changed changedfile oldmetric newmetric x oldexcl
881         ;;
882
883 d)
884         # Delete any existing information about the interface
885         cd "$IFACEDIR"
886         changed=false
887         for i in $args; do
888                 if [ -e "$i" ]; then
889                         changed=true
890                 elif ! ${force}; then
891                         warn "No resolv.conf for interface $i"
892                 fi
893                 rm -f "$i" "$METRICDIR/"*" $i" \
894                         "$PRIVATEDIR/$i" \
895                         "$EXCLUSIVEDIR/"*" $i" || exit $?
896         done
897         if ! ${changed}; then
898                 # Set the return code based on the forced flag
899                 ${force}
900                 exit $?
901         fi
902         unset changed i
903         ;;
904 esac
905
906 case "${resolvconf:-YES}" in
907 [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1) ;;
908 *) exit 0;;
909 esac
910
911 # Try and detect a suitable init system for our scripts
912 detect_init
913 export RESTARTCMD RCDIR _NOINIT_WARNED
914
915 eval "$(make_vars)"
916 export RESOLVCONF DOMAINS SEARCH NAMESERVERS LOCALNAMESERVERS
917 : ${list_resolv:=list_resolv -l}
918 retval=0
919
920 # Run scripts in the same directory resolvconf is run from
921 # in case any scripts accidentally dump files in the wrong place.
922 cd "$_PWD"
923 for script in "$LIBEXECDIR"/*; do
924         if [ -f "$script" ]; then
925                 eval script_enabled="\$${script##*/}"
926                 case "${script_enabled:-YES}" in
927                 [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1) ;;
928                 *) continue;;
929                 esac
930                 if [ -x "$script" ]; then
931                         "$script" "$cmd" "$iface"
932                 else
933                         (set -- "$cmd" "$iface"; . "$script")
934                 fi
935                 retval=$(($retval + $?))
936         fi
937 done
938 exit $retval