Giving Some STATIC (Routes, that Is!)

The Original Static Route!

Last time we talked about the IPv4 routing table and how the information populates it in the first place, starting with directly connected routes.  The fact that interfaces with these routes have to be up and functioning to be in the table at all makes them inherently “believable” (the term used to describe routes).  Routes in the IPv4 routing table from this source are marked with a C (connected) and easily recognizable.

That brings us to the topic of static routes, which may evoke images of lightning (see above), or walking across a carpeted room and sending a shock to someone just for fun.  Certainly the word static is used in those contexts, but in this case it simply means fixed or stationary, and refers to the fact that these routes stay permanently in the routing table.  You might think that this sounds like a description of connected routes too, but in reality it means that the routes are manually configured by a network administrator.

You can think of static routes in terms of the large concrete barricades that separate the sides of traffic on the highway.  First, they stay in one place, they do not move, even when an object may strike them with some degree of force.  Static routes remain in the table once configured and do not simply vanish when things are taking place from a routing perspective.  Second, these barriers unforgivingly separate traffic, just as static routes continually direct traffic to their intended destination.  Finally, these concrete dividers are actually put there by highway workers, they do not simply magically appear, just as static routes have to be placed manually in the router’s configuration.

The configuration of a static is remarkably straightforward and uncomplicated, using the following syntax:

ip route <destination-prefix> <subnet-mask> <next-hop-address | exit-interface> [<distance>]

The destination prefix is a subnet and/or network using standard decimal notation (e.g., 192.168.2.0), followed by a subnet mask, just as you probably have seen and used numerous times in your networking job and/or studies.  The next part is critical to understand, as you have options you need to consider.  You can choose simply to specify the outgoing interface, or you can specify the IPv4 address of the device you want to send the traffic to (typically directly connected).  In either case, if the interface is down and/or the next hop is unreachable, the route will not appear in the table.  The optional distance command allows you to specify the administrative distance, which we will cover next time!

– Joe

Road Trip, the Sequel! (aka, Introduction to IP Routing II)

Road Trip! (aka, Introduction to IP Routing I)

As you may recall from the very first entries on this blog, networking is all about communication—getting information from one location to another.  IPV4 packets carry that data from a source address to a destination address and all, but how does the process know how to get there in the first place?  The simple version of the answer is just IP routing!  Routing is the process of figuring out the best path to travel between any two given points in the journey.

To explain this a little bit, let me describe how I remember family vacations when I was a kid.  My Dad would load up the station wagon (yes, the nerdiest possible vehicle in history, I know), load us all inside, and then head out on the road.  My father was not the typical “Red Foreman” dad (in case you don’t remember, he was the colorful character from That 70’s Show).  My Dad is an engineer, and approaches everything with a carefully calculated plan by which to succeed, without much tolerance for variance.  Out would come the map, and he would move through and figure out the safest, most efficient path of travel, all before we ever actually got out on the road.

In a nutshell, that’s almost the same exact process that network devices (routers) use to figure out how to send data from the source to the destination.  When there are multiple possible ways to get there, a process is used to determine the most efficient manner to get from end to end.  Each part of the journey involves various networks, addresses, interfaces and media, not unlike the various highways and access roads used on a long-distance road trip.  And no, none of the small packets in the back seat keep asking “Are we there yet” over and over!

Each segment of the “trip” of an IP packet is managed by a Layer 3 routing device, typically a router or Layer 3 switch.  These devices maintain a list of networks it can reach, and by which exit point from the device (interface) it uses to reach those.  Once the packet leaves that device, it becomes the responsibility of the next one in the chain, which uses a similar process (route lookup) to send traffic on to the next part of the journey.  Once it reaches the destination, the process is repeated for return traffic, just as a road trip usually involves heading back to the point of origin.

Next time, we will take a look at the various methods used for specifically accomplishing the forwarding process.

–          Joe

Service, Service Please! Part II

TCP and UDP Comparison

TCP (Tansmission Control Protocol) and UDP (Use Datagram Protocol) are a lot like siblings in a family; you can see the resemblance and can tell they are related, but there are striking differences that set them apart.  For example, both use port numbers for accessing applications/services and both operate at Layer 4, but the similarities end there.

Ever met a control freak?  If so, then you have a pretty good idea of how TCP operates, in that it exerts significant control over how traffic is sent and received.  To begin with, TCP won’t send any data without sending up a virtual end-to-end connection between hosts, and it does so with a three-step process to establish that connection, as follows:

1. TCP SYN (synchronization)

2. SYN ACK (SYN acknowledgement)

3. ACK (acknowledgement).

After the connection establishment phase, a TCP connected hosts are free to send data, but does so in a very paranoid and calculated manner.  First, sequence numbers are assigned to the data, in order to reassemble everything in correct order.  Once the data is numbered and sent, the receiving station sends an acknowledgement, and if that acknowledgement is not received, the data is assumed lost and retransmitted.  Since that process can slow data transfer rates, TCP supports a concept called windowing, in which several segments of data can be sent before acknowledgements are required.  Sounds great, right?  Lots of mechanisms for connection-oriented, reliable delivery (which are terms often used to describe TCP).  The problem is, however, that if all of that extensive control is applied to every single piece of data, then everything is likely to take a lot longer to process.

If you are anything like me, you probably don’t follow a 57-point checklist before getting in the car and driving off when you go to work in the morning.  Welcome to the world of UDP, which contains no acknowledgements, no sequencing, no virtual connections, and incredibly low protocol overhead.  UDP is faster than TCP and well-suited to latency-senstitive traffic such as voice (although VoIP requires use of the Real-Time Transport Protocol in order to function).  The terms used for UDP and connectionless and unreliable, due to how it transmits traffic, and it is used often for network transmission.  When you look at both formats side by side (see above), it’s clear how vastly different UDP is from TCP.  The lack of reliability of UDP may seem somewhat random, but when you consider the fact that many applications handle retransmission and data delivery, then the thought of having other protocols do that may seem unnecessary.

Next time, we will dive into the world of IP routing…

– Joe

Service, Service Please! Part I

What a Network Dog Says!

Aside from the general principles of IP addressing and subnetting, any CCNA candidate and/or student needs to know about IP Services.  In the design of the Internet Protocol (IPV4 in particular), there are several functions that other parts of the TCP/IP Suite provide to network users, broadly termed services.  The first part of this set of protocols involves Layer 4 of the OSI Model, namely the Transport Layer, with the Transmission Control Protocol (TCP) and the User Datagram Protocol (UDP).

The first aspect of TCP and UDP regarding services are pretty much identical between the two, so let’s consider that first.  Probably the simplest way to think about this is to consider how the television in your home operates; you don’t have to know all of the electronic details to use it, but knowing the concepts is helpful to making full use of the technology.  Using cable TV as an example, a great of content is available, but it would be impractical (not to mention scary) to have all of that sent to your television at once.  Instead, each content provider is assigned a channel, over which they transmit/broadcast programming to subscribers, who tune in on that channel when they want that particular content.  For example, customers wanting sports programming will tune into ESPN (for example purposes, let’s say that’s channel 88), those wanting news might go to CNN (example channel 47), while still others might just want popular movies (example channel 76).  Each subscriber on the cable network would be connecting on a different channel at any one time to get the viewing experience that they wanted.  Sounds simple enough, right?

Now let’s jump from the example to the details of TCP and UDP operation on networks.  Different machines (end users, for example), may want to access different types of information on a server/computer on the network, similar to the content on cable TV networks.  These hosts or workstations “tune in” (connect) to a specific port (similar idea to a channel on a TV network) to access a specific type of information/content on that destination server.  Each type of service uses a different port to access that service, most of which are set by standards groups (e.g., the Internet Assigned Numbers Authority or IANA at www.iana.org).  Common port numbers, for example, are TCP port 80 for http or web access, TCP/UDP port 53 for DNS, and TCP port 23 for telnet.  Any computer wanting to access that type of service requests a connection on that port on the destination device.  Each service coexists on a separate port.

Next time, we will distinguish between TCP and UDP protocols.

– Joe

Sub(net) Operations! (Part II)

Subnetting Worksheet

I sincerely hope that the above graphic is readable as I created it myself to assist with subnetting tasks.  There are several ways to perform subnetting tasks, one of which involves rote memorization of tables for each addressing class, and the other involves mathematical calculations.  In my own certification studies I chose the memorization route because the math part scared me to death, although I did the tables the most difficult way imaginable!

The first step to keep in mind is what I mentioned in my first blog, namely that binary is the keys to the kingdom when it comes to networking know-how.  Just for review, remember that the 32-bit (4 octet) address is broken out into eight bits per section, and each bit is part of the powers of two, namely 1, 2, 4, 8, 16, 32, 64, 128 (see the image above).  The first logical step is to break each part of the address back into its binary representation.  For example, 192 is the combination of 128 and 64 (first two bits) which is binary 11000000.  One of the ways to get the most familiar with this process is simply to practice it over and over, you can find an address on a network and break it out or simply make up numbers and do the same thing.  To verify your work you can create a decimal-to-binary converter in Excel, either column by column or using the built-in functions.

One of the typical questions that seemingly appear on all practice exams is the request to find the subnet number, broadcast addresses and range of valid host addresses for a given address and subnet mask.  This is another thing to practice over and over since on the actual exam, time is a very precious resource and not to be wasted.  Here is a breakdown of how to accomplish this task:

1.  Write out the address in the question out in binary (see above for some guidelines).

2. Directly underneath, do a binary conversion of the subnet mask.  Most likely there will be strings of 1’s in the first octets.

3. Perform a Boolean AND Process (not an alien race, but a math operation).  In simple terms, it means to compare the column with the IP address with the column of the subnet mask.  Two 1’s means to write a 1 in the third row, and anything else is a 0.

4. Convert the new row back into decimal.  That is the subnet address.

5. Referring to the row you just converted back, there will be a string of 0’s at the end of that address.  Recopy the 0’s with 1’s and convert it back as well.  This will be the broadcast address.  To get the range of hosts, add 1 to the subnet address and subtract 1 from the broadcast.

More to come…

– Joe

Sub(net) Operations! (Part I)

Sub(marine) Net(ting)

I have always had a fascination about submarines.  I read about them in school, created many crude designs for personally sized ones, and dreamed about actually building one.  Fortunately, I lacked the tools and resources to do that, which is one of many reasons I am still alive to write this right now.  I also watched an inordinately large number of movies on the subject, one of which was Down Periscope starring Kesley Grammer, who took on nuclear subs in an antiquated diesel one and actually won.

One reason for the military’s use of submarines is their ability to evade a certain amount of detection, which was capitalized in the movie The Hunt for Red October, which the U.S. Navy had a hard time tracking.  The typical defense of surface ships against these vessels were depth charges (explosive barrels dumped in or around the subs to sink them) as well as anti-submarine nets (pictured in the photo above).  This brings us to another CCNA level topics, namely, submarine netting, or rather, subnetting.  Corny? Yes, but I suspect now that you are unlikely to ever forget it.

Subnetting is the process of taking an address space and carving it up into smaller parts, a lot like what happens when you take a cake or pie and split it into smaller servings.  Here is the rationale:  inefficient usage of IP addresses wastes both space and addresses. Going back to the pie analogy, there are very few people who will simply sit down and consume the entire dessert in one sitting, partly for health reasons and partly to lengthen the ability to enjoy it.  Subnetting works the same way, in which you divide up an address space (Class A, B or C) into smaller parts for better use.  Here is one example, using Class C addresses in the range of 192.168.0.0/16:

Without Subnetting:

1.  Management VLAN: 192.168.1.0/24.  Only 4 addresses needed, wasting 250 (.0 not usable/255 is broadcast)

2. Production VLAN: 192.168.11.0/24. Only 14 address addresses needed, wasting 240  (.0 not usable/255 is broadcast)

3. WAN Link: 192.168.111.0/24.  Only 2 address addresses needed, wasting 252  (.0 not usable/255 is broadcast)

Total Addresses Used:  20    Total Addresses Wasted: 742

Using Subnetting:

1.  Management VLAN: 192.168.1.0/28. 14 usable addresses consumed (.1 – .6, .0 is subnet, .15 is broadcast)

2. Production VLAN: 192.168.1.16/29. Only 6 address addresses consumed (.16 not usable, .23 is broadcast)

3. WAN Link: 192.168.1.24/30.  Only 2 address addresses consumed (.24 not usable, .27 is broadcast)

Total Addresses Used:  20    Total Addresses Spared: 742 (234 for remainder of 192.168.1.0, 255 for 192.168.11.0, 255 for 192.168.111.0)

The example used here went from three Class C networks with wasted addresses, to the fractional use of one network with more efficient use of address space.  This gives you an idea of how beneficial subnetting is.  Next time we will dig into how it works.

– Joe

Addressing a Secret Agent! (no, not really)

Agent 004 1/2

For me, there will always be only ONE James Bond, namely Sean Connery.  While that certainly dates me a little bit (I am in my 40’s, you can stop laughing now), I just never cared for the subsequent incarnations of the role by the later actors, and I certain envy Connery’s continued appeal and longevity.  In any case, James Bond represents the consummate “black ops” agent, although the older term most of us grew up with was spy or secret agent.

That thought makes a great entry point into a particularly helpful area of network knowledge, namely, private addressing.  As we discussed earlier, IP addressing assumes the ability to globally route packets based on the source and destination addresses contained in the IPV4 header.  As with many human inventions, however, there were unexpected flaws in the Internet, and it became the victim of its own success.  Because of the vast popularity of the commercial Internet, IP address space was rapidly getting utilized, creating a threat called address exhaustion (think of it as a widespread shortage).  One of the mechanisms created to address this problem was the creation of private addressing, defined in RFC
1918 and 4193.  Private addressing operates under the legitimate assumption that every device does not need or require a globally routable address and even encouraged the use of groups of addresses that are not allowed on the Internet (we will discuss Network Address Translation in the next article).  Three ranges, each in a separate address class, were designated for private addressing, as follows:

Class	Networks		Range	# of Addresses
	CIDR Notation	Network/Mask Notation
A	10.0.0.0/8	10.0.0.0  255.0.0.0	10.0.0.0 – 10.255.255.255	16,777,216
B	172.16.0.0/12	172.16.0.0  255.240.0.0	172.16.0.0 – 172.31.255.255	1,048,576
C	192.68.0.0/16	192.168.0.0 255.255.0.0	192.168.0.0 – 192.168.255.255	65,536

In my personal experiences as a network professional, I can tell you that the range I have seen on most enterprise networks is from the 10.0.0.0/8 range.  That makes sense, because the address space is incredibly vast and unlikely to be exhausted in just about any environment!  I have also
seen some usage in the 192.168.0.0/16 range, particularly in consumer devices.  Cisco/Linksys devices use this range by default, and even some of the business-grade units, such as the ASA 5505, utilize this set of addresses.  The advantages are that they are well-suited for smaller environments and fairly straightforward overall.  The 172.16.0.0/12 range is one that I have seen on a few, very limited and rare
occasions.  Honestly, I am curious about the reasons for this.

In our next discussion, we will consider the fraternal twin of private addressing, namely, Network Address Translation.

–  Joe

 

Going Back to Class

When the Internet Protocol was first introduced, the designers had no idea just how widely it would become adopted.  At the time, it competed head to end with Novell’s IPX protocol, along with Appletalk and a number of others, before IP finally achieved dominance.  In the beginning uses, groups of addresses were placed in classes which represented the way the addresses treated parts of the address, namely network and node (or host).  I love Wendell Odom’s explanation of these concepts, which he uses in his CCNA ICND1 Official Exam Certification Guide by Cisco Press (his website can be found at:http://www.certskills.com/) .  The network portion of the address is similar to a postal zip code, a broader representation of locations in a geographical area, after which street addresses and cities narrow down to a specific location.  A letter carrier on his/her route doesn’t care about zip codes several states away (in this analogy, addresses in other networks), but only the ones local to them.  With this in mind, let’s look at how address classes break out in terms of network length and node length.

Class A addresses have a network length of 8 bits, which is the first byte/octet of that address space.  Let’s use the example of 4.233.10.40, which would use 4 as the network portion and 233.10.40 as the node portion.  The natural or default mask is 255.0.0.0, or /8 using the examples described in the last blog.  Look at the representation of the possible ranges of Class A addresses in binary: 00000000 – 01111111. Two things should jump out at you, first, that only the leading digit (0) is consistent, which should always clue you in that a leading zero represents a Class A address.  Second, if you do the conversion from binary back to decimal, you will find the range to be 0 through 127 in the first octet.  Strictly speaking, the 127.0.0.0  range is reserved for internal loopback usage and zero ist permitted, so the actual usable range is 1.0.0.0 – 126.255.255.255.

To save space and brain cells, I will just summarize the Class B and C address characteristics, but keep in mind that the binary math works similarly to what is discussed above:

Address Class                        Leading Bit(s)                       Valid Network Numbers                       Network Bits                       Host Bits

A                                               0                                              1.0.0.0 to 126.0.0.0                                8                                             24

B                                               10                                            128.0.0.0 to 191.0.0.0                            16                                           16

C                                               11                                             192.0.0.0 to 223.0.0.0                           24                                           8

Notice that if you add the host bits and network bits you end up with 32 bits (4 bytes), which is the total address space in an IP Address.  Being able to recognize the Class of address in both binary and decimal will be very helpful not only on the exam, but later on when we discuss subnetting.

More to come…

– Joe

An Address By Any Other Name…

Source and Destination Addresses

When I first got into networking, I found the whole idea of IP addressing to be arcane and mysterious. Keep in mind that during most of my
elementary and middle school years, I was told that math was certainly NOT my thing (the string of C’s seemed to support that). That made me very skittish to even try to grasp things in the numerical arena, and it cast a blanket of fog over the dotted decimal addresses (e.g., 192.168.1.1, 10.2.1.5, etc.)

To be totally truthful, as a visual learner I read and memorized first and had my “aha” moment much later. Granted, there are a
boatload of principles, facts, and figures that just have to be firmly fixed in the brain first, but typically understanding happens at various points along the way. I hope that sharing my own experiences of learning will enable some of you to grasp the concepts more readily than I first did.

First things first, binary is king, as I mentioned much earlier in this blog. All of the seemingly strange things make perfect sense when you
leave behind our familiar decimal/base 10 thinking and get “tw0-dimensional.” At various points I will try to explain the quite-literal “bits and bytes” when it will further clarify some of the networking magic.

There are two ways to typically refer to an Internet Protocol (IP or IPV4) address, either of which you may encounter in various articles, books,
and other technical literature. The first is the use of the address and then the mask/subnet mask, while the second is the network or subnet, with the number of bits used, as follows:

192.168.1.2                 255.255.255.0

192.168.1.2/24

While they look very different, they mean exactly the same thing.  In decimal, each group of numbers between the dots is between 1-255 and is
referred to as an octet because you use 8 binary characters (bits) to create the same number in base-2. We’ll look into the bits involved a little
bit later, but that gives you a beginning point.

IP addresses are grouped into categories referred to as address classes, referred to as A, B, C, D and E. Class D addresses (223.0.0.0 to
239.255.255.255) refer to multicast addresses which are beyond the scope of the CCENT/CCNA but a fascinating topic nonetheless (if interested, read some more on your own). Class E (240.0.0.0 – 255.255.255.255) addresses were experimental and never used in any production setting, and mostly just idle geek-party chatter (just kidding).

Next time we will delve into the A, B and C address classes in more detail

– Joe