rc.ddclient script for dyndns.org

shilo · 07-16-2004, 12:13 AM

I recently had some trouble with the dyndns.org updater included with my router. Since I was having trouble with that, I decided to download the ddclient package ( http://s90389134.onlinehome.us/ddclient/ddclient.tar.gz ) to update my IP address. It has a lot of cool features. It can update Custom DNS accounts, as well as handle multiple dyndns.org accounts. It wasn't perfect, though. It looks like it was tailored for SystemV type init scripts, specifically Redhat. I needed to make something that worked for Slackware, so this is what I came up with.

I'm not very good at bash scripting, but I believe that I was able to write a script to use for ddclient. I just wrote the following file, saved it as /etc/rc.d/rc.ddclient , made it executable, and ran it. Here's a copy:

Code:

#!/bin/sh
#
# /etc/rc.d/rc.ddclient
#
# Start/stop/restart/staus the ddclient Dynamic DNS IP address updater
#
# To make ddclient start automatically at boot, make this
# file executable:  chmod 755 /etc/rc.d/rc.ddclient
#

progname=ddclient
program="`which $progname` -daemon 300"
pidfile="/var/run/ddclient.pid"
pids=`cat $pidfile 2> /dev/null`

ddclient_start() {
        if [ -r /etc/ddclient.conf ]; then
                echo "Starting $progname:  $program"
               $program
        fi
}

ddclient_stop() {
        echo "Shutting down $progname: "
        kill $pids
        sleep 1
        [ -f $pidfile ] && rm $pidfile
}

ddclient_restart() {
        ddclient_stop
        sleep 2
        ddclient_start
}

ddclient_status() {
        if test -f "$pidfile" 
        then
        echo "$progname (pid $pids) is running"
        else
        echo "$progname is stopped"
        fi
}

case "$1" in
	'start')
		ddclient_start   
		;;
	'stop')
		ddclient_stop
		;;
	'restart')
		ddclient_restart
		;;
	'status')
		ddclient_status
		;;
	*)
		echo "usage $0 start|stop|restart|status"
		;;
esac

Feel free to use this if you find it useful. Also, if anyone who actually knows anythimg about bash scripting would care to comment on it or fix it (if it doesn't work) I would appreciate it.

Good luck,

thegeekster · 07-16-2004, 02:04 PM

Looks like a good start................Although I have some questions about the status function (ddclient_status)..........You have $pids defined, but where are the other two variables defined, $program and $p)

Just from the way it looks, $program would be the ddclient script itself, and $p is actually $pids......so the "then" line in the ddclient_status function should actually be: echo "ddclient (pid $pids) is running"

And a tip about defining the $pids variable.............You also use the same command substitution for the kill command that you define the $pids variable with......So why not define the $pids variable at the start of the script and use 'kill $pids' for the ddclient_stop function?

So the proposed changes (in bold type) would be:

Code:

# To make ddclient start automatically at boot, make this
# file executable:  chmod 755 /etc/rc.d/rc.ddclient
#

pids=`ps -aef | awk '/[ \/]*ddclient/ { print $2}'`

ddclient_start() {

Code:

ddclient_stop() {
        echo "Shutting down ddclient: "
        kill $pids
}

Code:

ddclient_status() {
        if test "$pids" 
        then
        echo "ddclient (pid $pids) is running"
        else
        echo "ddclient is stopped"
        fi
}

NOTE: If you put the ddclient script in the recommended directory (/usr/sbin), you can also define the $program variable as:

Code:

program=`which ddclient`

and if you want to exclude the path in the variable:

Code:

program=`basename \`which ddclient\``

HTH

BTW: I'm usng the java program JDDUpdater...............

thegeekster · 07-16-2004, 02:24 PM

About that $program variable...........You can also define it at the start of the script, along with the $pids variable using program=`which ddclient`:

Code:

# To make ddclient start automatically at boot, make this
# file executable:  chmod 755 /etc/rc.d/rc.ddclient
#

program=`which ddclient`
pids=`ps -aef | awk '/[ \/]*ddclient/ { print $2}'`

ddclient_start() {

then in the start function (ddclient_start) you can use the $program variable to call the ddclient script:

Code:

ddclient_start() {
        if [ -r /etc/ddclient.conf ]; then
                echo "Starting ddclient:  $program -daemon 300"
                $program -daemon 300;
        fi
}

Then you can keep the $program variable in the status function but use the command substitution with basename:

Code:

ddclient_status() {
        if test "$pids" 
        then
        echo "`basename $program` (pid $pids) is running"
        else
        echo "`basename $program` is stopped"
        fi
}

keefaz · 07-16-2004, 02:33 PM

Why not trace pids with the help of a file like :

Code:

ddclient_start() {
        if [ -r /etc/ddclient.conf ]; then
                echo "Starting ddclient:  $program -daemon 300"
                $program -daemon 300;
                echo $! > /var/run/ddclient.pid
        fi
}

So you have a way to know the pid of ddclient without ps by cat /var/run/ddclient.pid

shilo · 07-16-2004, 03:03 PM

Thanks for the tips, guys. I feel a little bit dumb, though. I posted this script and I left out half of the changes that I made. Mostly stupid stuff that you noted, geekster, like the extra variables and such. I'll edit the original.

I hope you don't mind, but I'm gonna put your recommendations in the script, geekster.

keefaz- ddclient already makes a file /var/run/ddclient.pid , I was just trying to keep the original script they included somewhat intact. Probably simpler to use the pid like you suggest.

thegeekster · 07-16-2004, 03:18 PM

Quote:

Originally posted by keefaz
Why not trace pids with the help of a file like :

Code:

ddclient_start() { if [ -r /etc/ddclient.conf ]; then echo "Starting ddclient: $program -daemon 300" $program -daemon 300; echo $! > /var/run/ddclient.pid fi }

So you have a way to know the pid of ddclient without ps by cat /var/run/ddclient.pid

Good one, keefaz..........but it's not necessary to do that...........I _just_ downloaded and looked in the sample config file that ships with ddclient, and it already creates that file.................but whether it removes that file when shut down, i don't know...........

Anyway, shilo, you can add these variables at the top of your startup script:

Code:

# To make ddclient start automatically at boot, make this
# file executable:  chmod 755 /etc/rc.d/rc.ddclient
#

program=`which ddclient`
pidfile="/var/run/ddclient.pid"
pids=`cat $pidfile`

ddclient_start() {

and then make these changes:

Code:

ddclient_stop() {
        echo "Shutting down ddclient: "
        kill $pids
        # In case the PID file is not removed when ddclient is shutdown:
        sleep 1
        [ -f $pidfile ] && rm $pidfile
}

Code:

ddclient_status() {
        if test -f "$pidfile" 
        then
        echo "`basename $program` (pid $pids) is running"
        else
        echo "`basename $program` is stopped"
        fi
}

-- OR --

ddclient_status() {
        { [ -f $pidfile ] && echo "`basename $program` (pid $pids) is running" ; } \
            || echo "`basename $program` is stopped"
}

keefaz · 07-16-2004, 03:21 PM

ready for a package now

thegeekster · 07-16-2004, 03:26 PM

Quote:

Originally posted by shilo
........I feel a little bit dumb, though. I posted this script and I left out half of the changes that I made. Mostly stupid stuff that you noted, geekster, like the extra variables and such. I'll edit the original....

LOL..........Don't feel bad..............there's a lot of little details I overlook when making scripts, and because of that I've learned to troubleshoot scripts quite easily from lots of experience.......

And I don't mind at all about you uisng what I've showed you here.............If I did mind, I wouldn't post it at all.............

shilo · 07-16-2004, 03:55 PM

Sweet. I made the changes suggested.. All except the $program variable. Seemed kinda silly to type "$program" insted of "ddclient".

thegeekster · 07-16-2004, 04:33 PM

Quote:

Originally posted by shilo
...Seemed kinda silly to type "$program" insted of "ddclient".

It may seem a bit silly at first, but it is a good habit to get into in case you want to update some changes, like the name of the script................by using variabes throughout the script like that, you only need to make one change, the value in the variable, and it will be reflected throughout the script with less chance of overlooking anything (especially in big scripts).............This principle applies to any type of programming - to make the maintaining of the source much easier and faster.............

thegeekster · 07-16-2004, 05:05 PM

To illustrate what I'm talking about above, the changes in your updated script could look like this:

Code:

# To make ddclient start automatically at boot, make this
# file executable:  chmod 755 /etc/rc.d/rc.ddclient
#

progname=ddclient
program="`which $progname` -daemon 300"
pidfile="/var/run/ddclient.pid"
pids=`cat $pidfile`

ddclient_start() {
        if [ -r /etc/ddclient.conf ]; then
                echo "Starting $progname:  $program"
               $program
        fi
}

ddclient_stop() {
        echo "Shutting down $progname: "
        kill $pids
        sleep 1
        [ -f $pidfile ] && rm $pidfile
}

ddclient_restart() {
        ddclient_stop
        sleep 2
        ddclient_start
}

ddclient_status() {
        if test -f "$pidfile" 
        then
        echo "$progname (pid $pids) is running"
        else
        echo "$progname is stopped"
        fi
}

Now, if you want to change how ddclient is started, or decide to change the name, then all you need to do is change the value of the $progname or $program variable and that change will automatically be reflected throughout the script., without having to hunt through the entire script.........You merely go to the start of the script, where the variables are defined, and make the change there.............

thegeekster · 07-16-2004, 11:39 PM

shilo

Ooops........You will need to change that $pids variable............this is because if 'cat' cannot find the $PIDFILE (like when the ddclient is not running), it will output an error message to the screen........

So to avoid this, the error message should be redirected to the bit bucket (/dev/null). like so:

Code:

pids=`cat $pidfile 2> /dev/null`

The combination of '2>' is way to redirect 'stderr' (that is, any error messages) to wherever you want it to go besides the screen........You could even redirect it to a log file, like the Apache server does.........

shilo · 07-17-2004, 05:55 PM

Thanks Geekster,

Man, you are good at this. I gotta keep practicing my scripting skills.

I'm posting the changes to the main post.

Earth · 07-17-2004, 07:32 PM

here is my homebrewed java dyndns update client. it gets your WAN ip from the web so it doesn't matter what router you have. at the moment it only updates one domain at a time, but you can cron job it a couple times to do multiple domains.

Code:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class jdyn {
	
	private static URLConnection connection;
	
	public static void main(String[] args) {
		String proxyUrl = new String();
		int proxyPort = -1;
		if (args.length < 3) System.out.println("Please supply the necessary arguments. \n Example usage:\n" +
		" $java jdyn username password mydomain.dyndns.org");
		else {
			
			// extract proxy information from arguments and adjust the args 
			// as if it weren't there (wouldn't that be nice if proxies weren't a factor?
			if (args[0].equals("-p")) {
				String[] argsNew = new String[args.length - 3];
				proxyUrl = args[1];
				proxyPort = Integer.parseInt(args[2]);
				System.setProperty("http.proxyHost",proxyUrl);
				System.setProperty("http.proxyPort",String.valueOf(proxyPort));
				System.getProperties().put( "proxySet", "true" );
				System.getProperties().put( "proxyHost", proxyUrl );
				System.getProperties().put( "proxyPort", String.valueOf(proxyPort));
				for (int i=5; i<=args.length -1; i++)		{
					String myURL = new String("http://checkip.dyndns.org");
					String ipUpdate = new String();
					String output = new String();
					int startIP, endIP;
					connect(myURL, args, proxyUrl, proxyPort);
					output=readContents(args);
					endIP = output.indexOf("body", 70) -2;
					startIP = output.indexOf(":") + 2;
					try{
						ipUpdate = output.substring(startIP, endIP);
					}
					catch(StringIndexOutOfBoundsException e){
						System.out.println("hehe oops.");
					}
					myURL = "http://members.dyndns.org/nic/update?system=dyndns&hostname=" + args[i] + "&myip=" + ipUpdate + "&wildcard=OFF&backmx=NO&offline=NO%22";
					connect(myURL, args, proxyUrl, proxyPort);
					readContents(args);
				}
				
			}
			else {
				for (int i=2; i<=args.length -1; i++)		{
					String myURL = new String("http://checkip.dyndns.org");
					String ipUpdate = new String();
					String output = new String();
					int startIP, endIP;
					connect(myURL, args, proxyUrl, proxyPort);
					output=readContents(args);
					endIP = output.indexOf("body", 70) -2;
					startIP = output.indexOf(":") + 2;
					ipUpdate = output.substring(startIP, endIP);
					myURL = "http://members.dyndns.org/nic/update?system=dyndns&hostname=" + args[i] + "&myip=" + ipUpdate + "&wildcard=OFF&backmx=NO&offline=NO%22";
					connect(myURL, args, proxyUrl, proxyPort);
					readContents(args);
				}
			}
		}
	}
	
	private static void connect( String urlString, String[] args, String proxyUrl, int proxyPort) {
		try {
			String userPassword = new String();
			URL url = new URL(urlString);
			if (args[0].equals("-p")) {
				 userPassword = args[3] + ":" + args[4]; 
			}
			else {
				 userPassword = args[0] + ":" + args[1]; 	
			}
			String encoding = new sun.misc.BASE64Encoder().encode (userPassword.getBytes());
			connection = url.openConnection();
			connection.setRequestProperty ("Authorization", "Basic " + encoding);
		} catch (MalformedURLException e){
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	private static String readContents(String[] args) {
		BufferedReader in = null;
		String inputLine;
		
		try {
			in = new BufferedReader(
					new InputStreamReader(
							connection.getInputStream()));
			
			
			while (
					((inputLine = in.readLine()) != null)) {
				int g=2;
				if (!(inputLine.startsWith("<html>")))
					System.out.println(args[g]+ "\n ip update result: "+ inputLine);
				g++;
				
				return inputLine;
			}
		} catch (IOException e) {
			e.printStackTrace();
			return " ";
		}
		
		return inputLine;
		
	}
}

Edit: Hey, I could write that after freshman intro courses in college, it's not that bad, right? And that JDDClient has nothing over my code.

Actually, I wrote this in order to refresh my java lessons from last spring that I forgot completely when I became obsessed with Wolf: ET and was playing for 5+ hours a day. Writing jdyn was a little ambitious leap back into the real world ;D

thegeekster · 07-17-2004, 10:52 PM

Quote:

Originally posted by shilo
Thanks Geekster,

Man, you are good at this. I gotta keep practicing my scripting skills.

I'm posting the changes to the main post.

LOL........Like I said, I've had LOTS of practice on the little details I might overlook................

MORE ON ERROR CHECKING
There is something else which can be done to help with another error that may be encountered is with the $program variable.............You can take a couple of different approaches with this......

One is using the command substitution with the `which` command to locate the full path to the program, This is fine as long as ddclient is located somewhere in the $PATH................But what if it isn't...............what if it can't be found OR, if found, it isn't executable............then the script will continue on, but is pretty much useless......

So we need to check to make sure it is found, or tell us as much and exit right then and there..........Most people would opt for the usual "if test; then command; fi" routine, but there is a much simpler way of doing that...................Instead, you can use "command1 || command2" construction, which is a more compact way of saying the same thing.........That double pipe is a logical OR operator, which means that only one of the commands needs to be true.........Therefore, If the first command is true (returns an exit code of zero), then the second command is ignored. If the first command is false (returns a "non-zero" exit code), then the second command is executed......

Now to apply this to the script.............You can expand the line where you defined the $program variable to include error checking, like so:

Code:

program="`which $progname 2> /dev/null` -daemon 300" || { echo "  Sorry, but $progname cannot be found." && exit ; }

-- OR --

program="`which $progname 2> /dev/null` -daemon 300" \
  || { echo "  Sorry, but $progname cannot be found." && exit ; }

Of the two above, they are identical, but I prefer the second one because it's easier to read...........The backslash in the second one is used as a line continuation character in bash, BUT ONLY IF IT IS THE VERY LAST CHARACTER ON THE LINE.........In other words, there cannot be any blanks or tabs after the backslash when used as a line continuation character..........What it really does is to "escape" the invisible (or non-printable) newline character present at the end of each line. telling bash to ignore that newline character as if it didn't exist..........This way you can break up very long lines into shorter chunks for easier reading...............

Also, notice how i grouped the next commands after the || operator together using the curly braces, { }.....................In bash, the curly braces are actually considered words, and as such must be separated by white space (blank spaces, tabs, or newlines)............This is what bash functions use to group their commands, and is used in exactly the same manner.........One important fact to remember is you must use a semicolon after the last command before placing the closing curly brace ( } ), or put the closing brace on the next line like is commonly done for bash functions............I could've used the parentheses metacharacters to group the commands, but what that ends up doing is spawning another "child" process, or subprocess, just to execute those commands, which is not really necessary.............

Another thing to note is how I redirected the error message in this case by placing it inside the command substitution with the 'which' command................It needed to go there rather than putting just it before the OR operator ( || ), otherwise the error from the 'which' command would still show up on the screen........

Anyway, I needed to group the next two command together ('echo' and 'exit') to avoid running the 'exit' command even if the first command which defined the variable is true. Otherwise it would end up being "command1 || command2 && command3"..........The && operator is a logical AND operator, which means the first command must be true before the next one is executed..........In this case, what would've happened is the variable is successfully defined (true) so the 'echo' command will be ignored, but the 'exit' command will be executed instead of the 'echo' command...............When I grouped the 'echo' and 'exit' commands, it turns the line back into "command1 || command2"......................Still with me so far?

........

What if something happened and the program is no longer executable?..............Now we need to check for that, which is really very simple, and is the method used by the Slack startup scripts.........In it's simplest form it looks like this:

Code:

if [ -x /path/to/program ] ; then
  command
fi

-- OR --

if [ -x /path/to/program ] ; then command ; fi

However, we want to see if it's NOT executable and exit, if need be..................So we will use the NOT operator ( ! ) in front of the test expression, like so:

Code:

if [ ! -x /path/to/program ] ; then echo "Sorry, but program is not executable." && exit ; fi

Looking good so far................but since I'm a rather lazy typist (

), I like to make it even more compact than that already compact one-liner, which is:

Code:

[ ! -x `which $progname` ] && { echo "Sorry, but $progname is not executable." && exit ; }

-- OR --

[ ! -x `which $progname` ] \
  && { echo "Sorry, but $progname is not executable." & exit ; }

The NOT operator reverses the outcome of a test expression, making a normally true statement False and a normally false statement True.............And remember, when using AND, the first statement must be true before the second statement will be considered, So in this case if ddclient is executable (false statement), the rest of the commands on that line will be ignored.......and if ddclient is NOT executable (true statement) then the commands that follow on the same line will be executed.............A good place for this is right after you define the variables and before the functions.......

Okay, I said a couple of different approaches, right? That was one, here's another................When defining the $program variable, simply insert the full path instead of using 'which ddclient', so now it looks like:

program=/usr/sbin/ddclient

But we're still faced with the two possibilities of it being missing or not execuable. Instead, we can do this:

Code:

program="/usr/sbin/$progname -daemon 300"

followed by:

Code:

[ ! -x /usr/sbin/$progname ] \
  && { echo "Sorry, but $progname is either missing or not executable." && exit ; }

When testing with '-x', it also implies whether it exists, too, as well as whether it is executable..............Short and sweet.................For a simple startup script, this is probably the route I would eventually end up with, hard-coding the path when defining the variable and doing a simple error check routine...........

There are times when it would be better to use 'which' and other times it would be better to hard-code the path when defining variables, and sometimes just a matter of preference of who is doing the coding.........But now, at least, you should have a few more tools handy to work with and some concepts to think about.................Bottom line is the KISS principle (Keep It Simple Silly)..............You don't need to be very inventive with a simple startup script, but it's nice to have a few concepts and tools under your belt for when the occasion calls for it......(It's not unusual for me to get carried away, so I have to occasionally stop what I'm working on, and come back to it later and prune it down to get rid of the unecessary bloat of my 'inventiveness"...

)

Sorry to be so long-winded, but you sounded interested in scripting and I'm just trying to help you out a little without trying to be offensive (or too boring for that matter).........

---thegeekster

Edit: Correcting typos as I find them......