I took a break from programming today to take a look at ordinary differential equations. Below are my summary and notes for the first chapter.

Introduction

A differential equation is an equation involving an unknown function and its derivatives. For example:

Notation

Often we use a short hand notation. To represent the derivates of a function y with with respect to the independent variable under consideration, we can use:

The parentheses are used to distinguish the derivative from exponentiation. If the function is with respect to time, raised dots, instead of ticks, are often used instead.

Solutions

A solution of a differential equation in the unknown function y and the independent variable x on the interval I is a function y(x) that satisfies the differential equation identically for all x in I. For example, the function:

is a general solution of

Initial-Value and Boundary-Value Problems

We close this chapter with a brief discussion on initial-value and boundary-value problems. A differential equation with subsidiary conditions on the unknown functions and its derivatives, all given the same value of the independent variable, constitutes an initial-value problem. If the subsidiary conditions are given at more than one value of the independent variable, it becomes a boundary-value problem. Clearly, a solution to an initial-value or boundary-value problem is a function y(x) that solves the differential equation and satisfies all given subsidiary conditions.

Next time, I’ll take a look at classications of first-order differential equations, including linear equations, Bernoulli equations, and separable equations.

I conclude my discussion of Advanced Linux Programming by summarizing Chapter 10 of ALP. In this chapter, we take an introductory look at Linux security through the use of its users and and groups mechanism. This article is intentionally brief, primarily because Linux, more or less, is POSIX compliant and behaves similarly to other POSIX-like systems.

Users and Groups

Each Linux user is assigned a unique number, called a user ID or UID. When you login using a username, the system converts the username internally to a user ID. As a result, it’s entirely possible to have more than one username that refers to the same user. To share resources among multiple users, Linux provides the concept of groups. Like a UID, a group is also a unique number, called a group ID, or GID. Every group can contain multiple user IDs, and a single user can be a member of multiple groups. Groups cannot have subgroups. You can use the id command to view information the user and groups that you belong to.

The Superuser

The superuser has a user ID of 0, and is usually named root. This account can basically do anything, and should be well guarded. In particular, programs running as root must be written very carefully.

Process User IDs and Process Group IDs

Users and groups also reveal themselves when working with processes. Every process has an associated user ID and a group ID. Thus, when we say that a user performs an operation, we are really saying that a process with a corresponding user ID performs that operation.

If a program needs to modify user and group permissions, then it should use the uit_t and gid_t types. Even though user and group IDs are essentially integers, treat these fields as opaque handles for user and group identity.

File System Permissions

Each file has exactly one owning user and exactly one owning group. In general, when you create a file, the file is owned by the user and group of the creating process. The basic things that you can do with files are read, write, and execute. There are some nuances involving directories and their behavior, but it’s not worth discussing them here.

Sticky Bits

In addition to read, write, and execute permissions, there is a magic bit called the sticky bit. It applies only to directories. A directory that has the sticky bit set allows you to delete a file only if you are the owner of that file. A few directories, such as /tmp, have the stick bit set.

Real and Effective IDs

Processes aren’t really as simple as I made them out to be earlier. Every process actually hast wo user IDs. An effective user ID and a real user ID. Most of the time, the kernel only checks the effective ID. This is done using the geteuid and getegid functions. A user without root priveleges can only perform the operations with effective and real IDs:

• set its effective user ID to be the same as its real user ID
• set its real user ID to be the same as its effective user ID
• swap the two user IDs

Programs like login use real and effective IDs to transfer control from one username to another.

Setuid Programs

There exists a special class of setuid programs. When a setuid program is run, the effective user ID of the process will that of the file’s owner rather than the effective user ID of the process that performed the exec call. To use setuid, use chmod +s on the command line, or the S_ISUID flag if calling chmod programmatically.

Authenticating Users

If you writing a program that requires authentication, it’s typically best to allow the system administrator to decide what kind of authentication mechanism he or she will use. Consequently, Linux uses the pluggable authentication module, or PAM to authenticate their users as a system administrator sees fit. Thus, always use PAM if developing an application that requires authentication.

An upgrade to the latest Alchemy 6rc1 firmware had the net effect of turning our beautiful Linksys WRT54G router into nothing more than a brick. I guess I should have done a bit more research before trying to hack the device, but luckily, I’ve finally gotten everything sorted out again. The details of what actually happened are fairly uninteresting and tedious to explain, so I’ll get to the point and tell you what to do when you completely bork your router. Hopefully it will allow you to avoid some of the tough love and hard lessons that I faced today in the realm of embedded systems.

Preventative Measures

First, let’s talk about what to do if your device is already working. These are some preventative measures that will really help out if you do eventually end up turning your router into a brick. If you’re already using a third-party firmware, for example, you should go ahead and set the boot_wait parameter to on in your nvram:

nvram set boot_wait=on
nvram commit

There should be no need to ever unset boot_wait. The variable allows you a three to five second window to tftp over new firmware at bootup and avoid otherwise catastrophic failure. The OpenWRT users guide has more details. Next, go ahead and download all the firmware and software that you’ll need to bring your router back to life. After all, Internet access can be quite problematic to obtain when your primary router is dead. So save yourself the headache and download the firmware upgrade files and the Auto Upgrade Utility.

Also, remember to disable the password when upgrading your firmware. Linksys firmware updates use the trivial FTP (tftp) protocol, but it’s a non-standard modification that supports authentication. By disabling the password, you’ll still be able to use standard tftp utilities to update the firmware. Note, however, that boot_wait will never request a password, since it essentially bypasses the standard loading mechanism. In my opinion, your best bet is to simply boot up Windows and use the official Linksys utility.

Corrupt Firmware

If you’ve forgotten to set boot_wait, but your firmware is corrupt, don’t despair. On many systems, a corrupt firmware can mean the end of a device. But the Linksys engineers did a fantastic job on this hardware and were smart enough to provide users with a way out. A corrupt firmwire can be identified by the constantly flashing red diagnostic light. When this occurs, your router has most likely gone into PROM mode, a minimalistic, base environment that has just enough functionality to upload a new, working firmware. Linksys provides instructions on how to fix a red blinking diagnostic light. Remember to set your ethernet card to 10Mb, half duplex.

Linksys Brick

The worst of all cases is when you’ve uploaded a non-corrupt firmware, but the firmware itself doesn’t actually work because of bugs. Most users don’t run into this case, but for those of us who like to hack our own firmware, this is a common dilemma. If you set the boot_wait parameter, then this is trivial to fix. If not, you’re in for a world of hurt, but revival is not insurmountable. You will, however, void your warranty. It’s time to open up your device and hack the WRT554G.

Congratulations, your Linksys router is now immortal.