The problem:
For anyone looking at this problem, here’s something that you should know about this problem. Although it’s not explicitly stated that I saw, the sample data implies that if an employee is in the office hometown, that person does not need to commute via a vehicle and can be excluded.

Other than that, it’s relatively simple. Create a list of employees with their hometown and commuter capacity, then just iterate through that list (sorted by commuter capacity) for each hometown. You should be able to either determine that minimum number of cars needed or that it’s impossible relatively quickly.

Here’s the C# code that I used to solve the problem.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
 
namespace get_to_work
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = args[0];
 
	    StreamReader reader = new StreamReader(path);
	    StreamWriter writer = new StreamWriter(path + ".out", true);
 
            int numTestCases = int.Parse(reader.ReadLine());
            int currNum = 0;
            int numTowns = 0;
            int officeTown = 0;
            int numEmployees = 0;
            string commute = null;
            string[] officeInfo = null;
            bool impossible = false;
            List<Employee> employees = null;
 
            while (!reader.EndOfStream)
            {
                officeInfo = reader.ReadLine().Split(new char[] { ' ' });
                impossible = false;
                currNum++;
                writer.Write("Case #" + currNum + ": ");
                officeTown = Int32.Parse(officeInfo[1]);
                numTowns = Int32.Parse(officeInfo[0]);
                numEmployees = Int32.Parse(reader.ReadLine());
                employees = new List<Employee>();
                commute = "";
 
                for (int i = 0; i < numEmployees; i++)
                {
                    string[] employee = reader.ReadLine().Split(new char[] { ' ' });
                    int town = Int32.Parse(employee[0]);
                    int capacity = Int32.Parse(employee[1]);
                    employees.Add(new Employee(town, capacity));
                }
 
                var towns = employees.Select(r => r.hometown).Distinct();
                for (int i = 1; i <= numTowns; i++)
                {
                    var employees_in_town = employees.Where(e => e.hometown == i);
 
                    if (employees_in_town.Count() == 0 || i == officeTown)
                        commute = commute + "0 ";
                    else if (employees_in_town.Sum(e => e.passengers) < employees_in_town.Count())
                    {
                        impossible = true;
                        break;
                    }
                    else
                    {
                        commute = commute + computeVehicles(employees_in_town) + " ";
                    }
                }
                if (commute.EndsWith(" "))
                {
                    commute = commute.Substring(0, commute.Length - 1);
                }
 
                if (impossible)
                {
                    writer.WriteLine("IMPOSSIBLE");
                }
                else
                {
                    writer.WriteLine(commute);
                }
 
                writer.Flush();
            }
        }
 
        static int computeVehicles(IEnumerable<Employee> employees)
        {
            int totalVehicles = 0;
            int totalCommuters = employees.Count();
 
            foreach (Employee employee in employees.OrderByDescending(e => e.passengers))
            {
                totalCommuters = totalCommuters - employee.passengers;
                totalVehicles++;
                if (totalCommuters <= 0)
                {
                    break;
                }
            }
 
            return totalVehicles;
        }
    }
 
    public struct Employee
    {
        public int hometown;
        public int passengers;
 
        public Employee(int h, int p)
        {
            hometown = h;
            passengers = p;
        }
    }
}

The problem:
This problem is pretty easy. Basically, we have N number of integers with one of them being unique. It’s easy enough to simply search through a list of the provided integers until you run across one that has only 1 match in the list – that’s your answer.

And yes, I know I can break the loop after I’ve found the lone integer – since this is so quick running and it’s nothing important, I didn’t bother going back to fix that.

Here’s the C# code that I used to solve the problem.

using System;
using System.IO;
using System.Collections.Generic;
 
namespace odd_man_out
{
	class Program
	{
		public static void Main(string[] args)
		{
			string path = args[0];
 
			StreamReader reader = new StreamReader(path);
			StreamWriter writer = new StreamWriter(path + ".out", true);
 
			int numTestCases = int.Parse(reader.ReadLine());
			int currNum = 0;
 
			List<string> guests = null;
			int numGuests = 0;
 
			while (!reader.EndOfStream)
			{
				currNum++;
				guests = new List<string>();
				numGuests = Int32.Parse(reader.ReadLine());
				string input = reader.ReadLine();
 
				guests.AddRange(input.Split(new char[] { ' ' }));
 
				writer.Write("Case #" + currNum + ": ");
				foreach (string guest in guests)
				{
					if (guests.FindAll(
						delegate(string s)
						{
							return s == guest;
						}).Count == 1)
					{
					writer.WriteLine(guest);
					writer.Flush();
					}
				}
			}
		}
	}
}

Overview:

Coke and Pepsi are finally merging after so many decades once people realized that the separation in drinks was stupid, they taste exactly the same. Anyway, Coke utilizes an EIGRP based IPv6 network while Pepsi chose to go with IPv6 and OSPF because well, the coin landed on tails. You have been tasked with establishing connectivity between these two corporations. Luckily, we found a router in a janitor’s closet that randomly happened to be connecting the two companies, so that made it easy.

Technologies:

EIGRPv6:

EIGRPv6 is the IPv6 flavor of EIGRP that Cisco has developed. It is remarkably similar to EIGRP for IPv4, the only difference is in how it is enabled on a per interface basis. Be sure to remember that you do need to specify a seed metric when redistributing. You must define a value for the five metrics that EIGRP uses which are bandwidth, delay, reliability, load, and MTU. Also, there is no more “network” command. Instead, you would type “ipv6 eigrp 1” in the interface configuration mode in order to enable EIGRP in AS 1. The other important thing to note is that there is a shutdown command in the router configuration mode for EIGRP in this version, so be sure to do a no shutdown to enable the routing protocol.

OSPFv3:

OSPFv3 is the open standard IPv6 version of OSPF. Like EIGRP, it is quite similar to the prior version of OSPF. It still utilizes the same metric, which is “cost”. The command to enable OSPF on a per interface basis is “ipv6 ospf 1 area 0” in the interface configuration mode in order to enable OSPF process number 1 in area 0 for example. You will also have to manually define the router-id since it still uses the old IPv4 format rather than the new IPv6 address format. If you turn on debugging for R1, you will see it receiving the type 5 LSAs which is the external LSA type.

Redistribution:

Redistribution is also very similar to IPv4, however there is one very important and notable difference. The implicit connected interfaces in each routing protocol are no longer redistributed; that means that the interfaces and networks that you physically have configured for routing on the router will not be redistributed by default anymore. In order to accomplish this you have to use “redistribute connected”, possibly with a route-map if you don’t want all of the connected interfaces to be redistributed.

Tasks:

**You may need to create two VLANs and some trunks depending on how you have your environment physically cabled**

R1:

• Enable IPv6 unicast routing
• Configure OSPFv3 process 1 with a router-id of 1.1.1.1
• Configure both FastEthernet0/0 and Loopback0 and enable OSPF on them for area 0

R2

• Enable IPv6 unicast routing
• Configure OSPFv3 with a router-id of 2.2.2.2
• Configure EIGRP with a router-id of 2.2.2.2
• Configure FastEthernet0/0 and enable OSPFv3 on it in area 0
• Configure FastEthernet0/1 and enable EIGRPv6 on it in AS 1
• In OSPFv3 process 1 configuration mode enable redistribution for EIGRP AS 1 and enable redistribution for connected interfaces.
• In EIGRPv6 configuration mode enable redistribution for OSPF process 1 and connected routes. Be sure to define the metric property for each of them otherwise they will not be entered into the IPv6 routing tables. Issue a “no shutdown” command to enable the protocol.

R3

• Enable IPv6 unicast routing
• Configure EIGRPv6 AS 1 with a router-id of 3.3.3.3 and issue a “no shutdown” command
• Configure both FastEthernet0/1 and Loopback0, then enable EIGRP on each of them in AS 1.

Logical Topology

Walkthrough

R1

Before we can do anything, we need to enable IPv6 routing on the router. By default, IPv6 routing is disabled. This command will enable unicast routing for IPv6. You should note that there is an entirely different command for routing multicast packets, which is “ipv6 multicast-routing”.

R1(config)#ipv6 unicast-routing

Next, we will set the router id that OSPF will use on this router. It must be manually set because it still uses a 32bit notation, so it will not automatically take one of the set IPv6 addresses. If you have an IPv4 interface configured, it will still pull that address and use it as its router id.

R1(config)#ipv6 router ospf 1
R1(config-router)#router-id 1.1.1.1

Now let’s start configuring the interfaces. We’ll begin with FastEthernet0/0 which will be in OSPF Area 0. Then, we will also put Loopback0 into Area 0.

R1(config)#interface FastEthernet0/0
R1(config-if)#ipv6 router ospf 1
R1(config)#interface Loopback0
R1(config-if)#ipv6 router ospf 1

That’s all we need on R1.

R2

Again, we first need to enable IPv6 routing on the router

R2(config)#ipv6 unicast-routing

Next, let’s configure the two FastEthernet interfaces. We’ll start with FastEthernet0/0 which is in OSPF Area 0.

R2(config)#interface FastEthernet0/0
R2(config-if)#ipv6 ospf 1 area 0

Next, FastEthernet0/1 which is in EIGRP AS 1

R2(config)#interface FastEthernet0/1
R2(config-if)ipv6 eigrp 1

Now let’s configure the router id of OSPF and redistribute EIGRP and connected routes. In IPv6, there is no implicit redistribution of connected routes in a different protocol unlike in IPv4.

R2(config)#ipv6 router ospf 1
R2(config-router)#router-id 2.2.2.2
R2(config-router)#redistributed eigrp 1
R2(config-router)#redistribute connected

Now we will do the same for EIGRP AS 1. Remember that a seed metric must be defined for redistributed routes, otherwise they will not be put in as active EIGRP routes.

R2(config)#ipv6 eigrp 1
R2(config-router)router-id 2.2.2.2
R2(config-router)redistribute ospf 1 metric 100 10 100 1 1500
R2(config-router)redistribute connected metric 100 10 100 1 1500

This next step is new to IPv6 routing protocols. There is now a shutdown command, just like in interface configuration mode. OSPF defaults to being “no shutdown” but the same doesn’t hold true for EIGRP, so we must enable it.

R2(config-router)#no shutdown

Now we’re done with R2.

R3

Again, we must first enable IPv6 routing.

R3(config)#ipv6 unicast-routing

Now let’s set up the EIGRP router id and enable the protocol.

R3(config)#ipv6 router eigrp 1
R3(config-router)#router-id 3.3.3.3
R3(config-router)#no shutdown

Finally, let’s put FastEthernet0/1 and Loopback0 into EIGRP AS 1

R3(config)#interface FastEthernet0/1
R3(config-router)#ipv6 eigrp 1
R3(config)#interface Loopback0
R3(config-router)#ipv6 eigrp 1

And we’re done!

Testing and Debugging

show ipv6 route

Show the IPv6 routing table

Example:

R1#show ipv6 route
 
IPv6 Routing Table - 6 entries
 
Codes: C - Connected, L - Local, S - Static, R - RIP, B - BGP
 
       U - Per-user Static route, M - MIPv6
 
       I1 - ISIS L1, I2 - ISIS L2, IA - ISIS interarea, IS - ISIS summary
 
       O - OSPF intra, OI - OSPF inter, OE1 - OSPF ext 1, OE2 - OSPF ext 2
 
       ON1 - OSPF NSSA ext 1, ON2 - OSPF NSSA ext 2
 
       D - EIGRP, EX - EIGRP external
 
OE2  E567::1/128 [110/20]
 
     via FE80::207:EFF:FE1F:6FA8, FastEthernet0/0
 
(Here’s an example of an External Type 2 OSPF route.  That means that it is a redistributed route.  Type 2 routes generally only reflect the cost from THIS router to the destination whereas Type 1 routes would reflect the cost of the full path.)
 
LC  F564::1/128 [0/0]
 
     via ::, Loopback0
 
C   FEC0::/126 [0/0]
 
     via ::, FastEthernet0/0
 
L   FEC0::1/128 [0/0]
 
     via ::, FastEthernet0/0
 
OE2  FEC0::4/126 [110/20]
 
     via FE80::207:EFF:FE1F:6FA8, FastEthernet0/0
 
L   FF00::/8 [0/0]
 
     via ::, Null0

show ipv6 interface brief

Show information whenever an IPv6 packet is sent or received

Example:

R1#show ipv6 interface brief
 
FastEthernet0/0            [up/up]
 
    FE80::214:F2FF:FE01:6438
 
    FEC0::1
 
FastEthernet0/1            [administratively down/down]
 
Serial0/0/0                [administratively down/down]
 
Serial0/0/1                [administratively down/down]
 
Loopback0                  [up/up]
 
    FE80::214:F2FF:FE01:6438
 
    F564::1

show ipv6 ospf

Show information for the defined OSPF process

Example:

R1#show ipv6 ospf 1
 
 Routing Process "ospfv3 1" with ID 1.1.1.1
 
 SPF schedule delay 5 secs, Hold time between two SPFs 10 secs
 
 Minimum LSA interval 5 secs. Minimum LSA arrival 1 secs
 
 LSA group pacing timer 240 secs
 
 Interface flood pacing timer 33 msecs
 
 Retransmission pacing timer 66 msecs
 
 Number of external LSA 2. Checksum Sum 0x01497B
 
 Number of areas in this router is 1. 1 normal 0 stub 0 nssa
 
 Reference bandwidth unit is 100 mbps
 
    Area BACKBONE(0)
 
        Number of interfaces in this area is 2
 
        SPF algorithm executed 4 times
 
        Number of LSA 7. Checksum Sum 0x02B045
 
        Number of DCbitless LSA 0
 
        Number of indication LSA 0
 
        Number of DoNotAge LSA 0
 
        Flood list length 0

show ipv6 eigrp topology

Show the IPv6 EIGRP topology table

Example:

R3#show ipv6 eigrp topology
 
IPv6-EIGRP Topology Table for AS(1)/ID(3.3.3.3)
 
 
 
Codes: P - Passive, A - Active, U - Update, Q - Query, R - Reply,
 
       r - reply Status, s - sia Status
 
 
 
P F564::1/128, 1 successors, FD is 25605120
 
        via FE80::207:EFF:FE1F:6FA9 (25605120/25602560), FastEthernet0/1
 
(Here is the route to the Loopback interface on R1.  The advertised distance will change with the metrics that we specified in the redistribution.)
 
P E567::1/128, 1 successors, FD is 128256
 
        via Connected, Loopback0
 
P FEC0::/126, 1 successors, FD is 25605120
 
        via FE80::207:EFF:FE1F:6FA9 (25605120/25602560), FastEthernet0/1
 
P FEC0::4/126, 1 successors, FD is 28160
 
        via Connected, FastEthernet0/1

ping ipv6

Ping the defined IPv6 address

Example:

R1#ping ipv6 E567::1
 
 
 
Type escape sequence to abort.
 
Sending 5, 100-byte ICMP Echos to E567::1, timeout is 2 seconds:
 
!!!!!
 
Success rate is 100 percent (5/5), round-trip min/avg/max = 0/0/4 ms

Basically you can take almost any debug or show command from IPv4, change “ip” to “ipv6” and it will show you the IPv6 related information.

Solutions

R1

hostname R1
!
ipv6 unicast-routing
!
interface Loopback0
 no ip address
 ipv6 address F564::1/128
 ipv6 ospf 1 area 0
!
interface FastEthernet0/0
 no ip address
 duplex auto
 speed auto
 ipv6 address FEC0::1/126
 ipv6 ospf 1 area 0
!
ipv6 router ospf 1
 router-id 1.1.1.1
 log-adjacency-changes
!
end

R2

hostname R2
!
ipv6 unicast-routing
!
interface FastEthernet0/0
 no ip address
 duplex auto
 speed auto
 ipv6 address FEC0::2/126
 ipv6 ospf 1 area 
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 ipv6 address FEC0::5/126
 ipv6 eigrp 1
!
ipv6 router eigrp 1
 router-id 2.2.2.2
 no shutdown
 redistribute connected metric 100 10 100 1 1500
 redistribute ospf 1 metric 100 10 100 1 1500
!
ipv6 router ospf 1
 router-id 2.2.2.2
 log-adjacency-changes
 redistribute connected
 redistribute eigrp 1
!
end

R3

hostname R3
!
ipv6 unicast-routing
!
interface Loopback0
 no ip address
 ipv6 address E567::1/128
 ipv6 eigrp 1
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 ipv6 address FEC0::6/126
 ipv6 eigrp 1
!
ipv6 router eigrp 1
 router-id 3.3.3.3
 no shutdown
!
end

The problem:
This problem is basically asking us to do conversions from base-X to base-Y. To do that, we’re going to do 2 conversions: one from base-X to base-10, then one from base-10 to base Y.

The conversion for base-10 is pretty simple. If we have a number in base-3 such as 201, then that can be represented in base-10 by the following: (2 * 3^2) + (0 * 3^1) + (1 * 3^0) = 19.

To convert to base-Y, we’re going to use the following method (using base-5 for our conversion and 19 (base-10) as our example).
19 / 5 = 3 R 4
3 / 5 = 0 R 3

We then take those remainders and write them down in reverse, so 19 (base-10) = 34 (base 5). Converting the numbers to the “Alien” numbers is a simple process of matching up the digits with their corresponding index in the given alien numbers.

Here’s the C# code that I used to solve the problem.

using System.Collections;
using System.IO;
using System;
 
namespace Alien_Numbers
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = args[0];
            int numTestCases = 0;
            ArrayList input = new ArrayList();
            StreamReader reader = new StreamReader(path);
            StreamWriter writer = new StreamWriter(path + ".out", true);
 
            numTestCases = Int32.Parse(reader.ReadLine());
 
            while (!reader.EndOfStream)
                input.Add(reader.ReadLine());
 
            string alien_number = null;
            string source_language = null;
            string target_language = null;
 
            string[] line;
 
            foreach (string s in input)
            {
                line = s.Split(new char[] {' '});
 
                alien_number = line[0];
                source_language = line[1];
                target_language = line[2];
 
                writer.WriteLine("Case #" + (input.IndexOf(s) + 1) + ": " + ConvertToAlienLanguage(source_language, alien_number, target_language));
                writer.Flush();
            }   
        }
 
        static string ConvertToAlienLanguage(string source_language, string source_number, string target_language)
        {
            long srcbase = source_language.Length;
            long trgbase = target_language.Length;
 
            long srcnum_base10 = 0;
            string strConvertedNum = "";
 
            // --------- Convert the source number to base 10 ------------
 
            for (int i = 0; i < source_number.Length; i++)
                srcnum_base10 += source_language.IndexOf(source_number[i]) * (long)(Math.Pow(srcbase, (source_number.Length - 1) - i)); 
 
            // --------- Convert our Base 10 number into the target base and "Alien" numbers
 
            while (true)
            {
                strConvertedNum = strConvertedNum.Insert(0, (target_language[(int)(srcnum_base10 % trgbase)]).ToString());
 
                if (srcnum_base10 / trgbase == 0)
                    break;
 
                srcnum_base10 = srcnum_base10 / trgbase;
            }
 
            return strConvertedNum;       
        }
    }
}

(Note: Please complete Challenge Lab #2 – EIGRPv6 / OSPFv3 Redistribution prior to this if you are not already familiar with IPv6 terms and concepts.)

Overview:

A small business owner in your local town has contacted your consulting company request someone to change them to an entirely IPv6 network. Although you know that it is kind of pointless for a small shop to be spending money on the transition at this time, you are more than willing to let them write you as many checks as they want. One of the issues you will be facing is how to maintain connectivity between their two locations when you only have access to the IPv4 internet.

Technologies:

GRE:

GRE, or Generic Routing Encapsulation, is a technology developed by Cisco that creates a logical point-to-point link over already accessible networks. This technology is useful in order to run different kind of protocol stacks. For example, you can run IPSec/GRE tunnel between two sites in order to provide security. Another example which we will be utilizing here is the ability to connect two sites via IPv4 but pass IPv6 information through it.

IPv6 to IPv6 Tunnel Methods:

There are five different methods of tunneling IPv6 through an IPv4 backbone, and they are divided into two majors groups which are automatic and manual. The automatic tunnels still need IPv4 information, however it is generally pulled from another already configured address such as a BGP peer. ISPs may also run an overlay service that allows customers to connect and configure themselves which may provide ease of management in larger deployments. For this example, we will be using a manually configured IPv6 tunnel since this is for a small business and there will be very minimal management required.

Tasks:

**You may need to create two VLANs and some trunks depending on how you have your environment physically cabled**

R1:

• Enable IPv6 unicast routing
• Configure a default IPv4 static route via R2
• Configure Tun0 with a mode of ipv6ip, a source of F0/0, and the destination address of the Tun0 on R3
• Configure IPv6 OSPF Area 0 on Lo0 and Tun0

R2

• Configure the two interfaces with basic IP addressing

R3

• Enable IPv6 unicast routing
• Configure a default IPv4 static route via R2
• Configure Tun0 with a mode of ipv6ip, a source of F0/1, and the destination address of the Tun0 on R1
• Configure IPv6 OSPF Area 0 on Lo0 and Tun0

Logical Topology

Walkthrough Below!

Walkthrough

R1

Since we will be running an IPv6 routing protocol, we need to enable IPv6 unicast routing.

R1(config)#ipv6 unicast-routing

Let’s configure a default static route via R2 so that we will have full IPv4 connectivity. You can run a routing protocol instead if you wish.

R1(config)#ip route 0.0.0.0 0.0.0.0 201.2.3.2

Let’s create Interface Tunnel0 that we will use to tunnel IPv6 over the IPv4 backbone and set the IPv6 address. A tunnel interface is a logical interface that communicates with another tunnel interface via connected physical interfaces.

R1(config)#interface Tunnel0
R1(config-if)#ipv6 address FED0::1/126

Now let’s change the tunnel mode to IPv6 using IPv4 encapsulation. What this command is doing is basically stating that the inner packet contains IPv6 data, and that inner packet is encapsulated within a packet utilizing IPv4 data.

R1(config-if)#tunnel mode ipv6ip

We are going to be using the source address from F0/0 since that is our connection to the internet, then we will use the public address of R3 as the tunnel destination.

R1(config-if)#tunnel source FastEthernet 0/0
R1(config-if)#tunnel destination 202.3.2.1

Now let’s just run IPv6 OSPF on our two IPv6 interfaces to showcase running a routing protocol over our new tunnel.

R1(config)#int Tunnel0
R1(config-if)#ipv6 ospf 1 area 0
R1(config)#int Lo0
R1(config-if)#ipv6 ospf 1 area 0

That’s all we need on R1.

R2

All we need to do on R2 is configure the two FastEthernet interfaces with IPv4 addresses to get basic connectivity, we don’t need to do anything else.

R2(config)#interface FastEthernet0/0
R2(config-if)#ip address 201.2.3.2 255.255.255.252
R2(config)#interface FastEthernet0/1
R2(config)#ip address 202.3.4.2 255.255.255.252

Now we’re done with R2.

R3

Since we will be running an IPv6 routing protocol, we need to enable IPv6 unicast routing.

R3(config)#ipv6 unicast-routing

Let’s configure a default static route via R2 so that we will have full IPv4 connectivity. You can run a routing protocol instead of you wish.

R3(config)#ip route 0.0.0.0 0.0.0.0 202.3.2.1

Let’s create Interface Tunnel0 that we will use to tunnel IPv6 over the IPv4 backbone and set the IPv6 address.

R3(config)#interface Tunnel0
R3(config-if)#ipv6 address FED0::2/126

Now let’s change the tunnel mode to IPv6 using IPv4 encapsulation

R3(config-if)#tunnel mode ipv6ip

We are going to be using the source address from F0/1 since that is our connection to the internet, then we will use the public address of R1 as the tunnel destination.

R3(config-if)#tunnel source FastEthernet 0/1
R3(config-if)#tunnel destination 201.2.3.1

Now let’s just run IPv6 OSPF on our two IPv6 interfaces to showcase running a routing protocol over our new tunnel.

R3(config)#int Tunnel0
R3(config-if)#ipv6 ospf 1 area 0
R3(config)#int Lo0
R3(config-if)#ipv6 ospf 1 area 0

That’s all we need on R3.

Testing and Debugging

show ipv6 route

Show the IPv6 routing table

Example:

R1#show ipv6 route
 
IPv6 Routing Table - 6 entries
 
Codes: C - Connected, L - Local, S - Static, R - RIP, B - BGP
       U - Per-user Static route, M - MIPv6
       I1 - ISIS L1, I2 - ISIS L2, IA - ISIS interarea, IS - ISIS summary
       O - OSPF intra, OI - OSPF inter, OE1 - OSPF ext 1, OE2 - OSPF ext 2
       ON1 - OSPF NSSA ext 1, ON2 - OSPF NSSA ext 2
       D - EIGRP, EX - EIGRP external
C   FEC0::/65 [0/0]
     via ::, Loopback0
L   FEC0::1/128 [0/0]
 
     via ::, Loopback0
O   FEC0:F000::1/128 [110/11111]
     via FE80::CA03:402, Tunnel0
 
(Notice how this OSPF route is received via Tunnel0.  Success!)
 
C   FED0::/126 [0/0
     via ::, Tunnel0
L   FED0::1/128 [0/0]
     via ::, Tunnel0
L   FF00::/8 [0/0]
     via ::, Null0

show ipv6 interface brief

Show information whenever an IPv6 packet is sent or received

Example:

R1#show ipv6 interface brief
 
FastEthernet0/0            [up/up]
    FE80::214:F2FF:FE01:6438
    FEC0::1
FastEthernet0/1            [administratively down/down]
Serial0/0/0                [administratively down/down]
Serial0/0/1                [administratively down/down]
Loopback0                  [up/up]
    FE80::214:F2FF:FE01:6438
    F564::1

show ipv6 tunnel

Show tunnels that are configured for IPv6

Example:

R1#show ipv6 tunnel
 
Tun Route  LastInp              Packets Description
  0   -   00:00:01                  212
 
(You can see the number of the tunnel of the interface here, how many packets it has sent, and the last time it was used!)

ping ipv6

Send an ICMP request to the specified address

Example:

R1#ping FEC0:F000::1
 
Type escape sequence to abort.
 
Sending 5, 100-byte ICMP Echos to FEC0:F000::1, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 0/1/4 ms

show interface tunnel

Show information relating to the specified tunnel

Example:

R1#show interface tunnel 0
 
Tunnel0 is up, line protocol is up
  Hardware is Tunnel
  MTU 1514 bytes, BW 9 Kbit, DLY 500000 usec,
     reliability 255/255, txload 1/255, rxload 1/255
  Encapsulation TUNNEL, loopback not set
  Keepalive not set
  Tunnel source 201.2.3.1 (FastEthernet0/0), destination 202.3.4.2
 
(You can see our source and destinations are completely IPv4 based here)
 
  Tunnel protocol/transport IPv6/IP
 
(You can see that we specified that we will be encapsulating our IPv6 packets within IPv4 Packets here!)
 
  Tunnel TTL 255
  Fast tunneling enabled
  Tunnel transmit bandwidth 8000 (kbps)
  Tunnel receive bandwidth 8000 (kbps)
  Last input 00:00:05, output 00:00:09, output hang never
  Last clearing of "show interface" counters never
  Input queue: 0/75/0/0 (size/max/drops/flushes); Total output drops: 20
  Queueing strategy: fifo
  Output queue: 0/0 (size/max)
  5 minute input rate 0 bits/sec, 0 packets/sec
  5 minute output rate 0 bits/sec, 0 packets/sec
     203 packets input, 24672 bytes, 0 no buffer
     Received 0 broadcasts, 0 runts, 0 giants, 0 throttles
     0 input errors, 0 CRC, 0 frame, 0 overrun, 0 ignored, 0 abort
     210 packets output, 21388 bytes, 0 underruns
     0 output errors, 0 collisions, 0 interface resets
     0 output buffer failures, 0 output buffers swapped out

Solutions

R1

hostname R1
!
ipv6 unicast-routing
!
interface Loopback0
 no ip address
 ipv6 address FEC0::1/65
 ipv6 ospf 1 area 0
!
interface Tunnel0
 no ip address
 ipv6 address FED0::1/126
 ipv6 ospf 1 area 0
 tunnel source FastEthernet0/0
 tunnel destination 202.3.4.2
 tunnel mode ipv6ip
!
interface FastEthernet0/0
 ip address 201.2.3.1 255.255.255.252
 duplex auto
 speed auto
!
ip route 0.0.0.0 0.0.0.0 201.2.3.2
!
ipv6 router ospf 1
 router-id 1.1.1.1
 log-adjacency-changes
!
end

hostname R2
!
interface FastEthernet0/0
 ip address 201.2.3.2 255.255.255.252
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 202.3.4.1 255.255.255.252
 duplex auto
 speed auto
!
end

R3

hostname R3
!
ipv6 unicast-routing
!
interface Loopback0
 no ip address
 ipv6 address FEC0:F000::1/65
 ipv6 ospf 1 area 0
!
interface Tunnel0
 no ip address
 ipv6 address FED0::2/126
 ipv6 ospf 1 area 0
 tunnel source FastEthernet0/1
 tunnel destination 201.2.3.1
 tunnel mode ipv6ip
!
interface FastEthernet0/1
 ip address 202.3.4.2 255.255.255.252
 duplex auto
 speed auto
!
ip route 0.0.0.0 0.0.0.0 202.3.4.1
!
ipv6 router ospf 1
 router-id 3.3.3.3
 log-adjacency-changes
!
end

Copyright © 2008 dch-it.com. All Rights Reserved.

The problem with that is these hashes are NOT unique. There are “collisions” that can occur; two completely different files or strings or in this case certificates can have identical hashes. Through some massive computing power, researchers were able to create certificates that mimic the valid hash of certain websites which to say the least is dangerous for anyone visiting a compromised website. You could be redirected to a phishing website for your local bank and it would still look completely legitimate, SSL certificate and all.

People, this is why we have advancements in security. MD5 is a very old technology, and though still a good technology, it has been replaced by newer and better hash functions such as SHA-1 and SHA-2 to name a couple. Using MD5 to me is like saying that DES-56 encryption is good enough when you have AES-256 available to you. It is insanity for the websites that are dealing with the very security of our personal and financial information to not be using the latest and greatest technology.

To check out the presentation given at this conference, go here.

Apparently, Microsoft deems it dangerous to be able to create dynamic disks and/or RAID arrays on laptops due to the “removable” nature of the media. In all fairness, I don’t really blame them – who in their right mind would set up a RAID array using a removable drive on a laptop? Well, that’s exactly what we needed to do. Here’s how we did it:

If you search Microsoft’s website for a few minutes (hint: laptop dynamic disk) you will get a bunch of results, none exactly telling you what you need. If you look a bit closer, you’ll notice this article entitled “Laptop May Incorrectly have Option to Upgrade Basic Disks to Dynamic”. Whoa, wait a second here. The wheels turned in my head for about 5 seconds and then I thought to myself “why not just do the opposite of what this kbase says and purposely break my laptop to get what I want?”. Sure enough the clouds parted and I was able to have my mobile RAID array. It is fully functional and completely reliable – I tested every possible variation of purposefully corrupting data or accidentally ripping out the drive, but the worst that happened was needing to rebuild the array from the surviving disk as intended.

Here’s the resolution text from Microsoft’s website to save you a few seconds. Just do the opposite of what it says to do.

WARNING: If you use Registry Editor incorrectly, you may cause serious problems that may require you to reinstall your operating system. Microsoft cannot guarantee that you can solve problems that result from using Registry Editor incorrectly. Use Registry Editor at your own risk.

To disable the “Upgrade to Dynamic Disk” command, use the following steps.

NOTE: If you have already created any Dynamic disks, delete any volumes on the Dynamic disks and revert them to Basic disks before continuing.

1. Start Registry Editor (Regedt32.exe).
2. Locate the Start value under the following key:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\dmload
3. On the Edit menu, click Modify.
4. Change the data value from 0×0 (boot) to 0×4 (disabled), and then click OK.
5. Quit Registry Editor, and then restart the computer.

Overview:

A customer at XYZ corporation has just asked you, an engineer at HyperGlobalMegaCorp Regional ISP, to set him up a tunneled VPN connection between two of their sites. The problem is that somehow both XYZ and ABC corporations use the same exact IP addressing scheme, so they need to somehow accommodate that. You’ve been tasked with researching and implementing MPLS VPNs and VRF in order to accommodate both their security and IP addressing needs.

Technologies:

VRF:

Virtual Routing and Forwarding is a virtualization technology that is used to segment one physical router into two or more logical routers. This is very similar to running software such as VMWare or Microsoft Virtual PC, but on a router. The routing and IP tables contained in each of these logical routers do not communicate with other logical routers. This means that a router can route the same IP address space in completely different ways; this is useful with RFC1918 for example. In order to accomplish this, VRF uses a Route Distinguisher that is configured by the administrator. This will allow for similar routes to become unique. This will become clearer as you progress through the lab. You may also set route-target exports/imports which will send or receive information with the specified BGP extended community. This will come into play when we set up BGP for communication. You may have multiple import and export rules.

MPLS:

MPLS, or Multi Protocol Label Switching, is a recent type of transport technology that is eventually intended to replace both ATM and Frame Relay due to it’s enhanced capabilities for simplicity, efficiency, and to still be able to handle the Quality of Service (QoS) need of companies in order to keep time and bandwidth sensitive applications running properly. By applying a label to each route and pre-generating where each label is sent to, speed and efficiency is greatly increased. These labels can either be statically defined or dynamically generated.

Tasks:

Feel free to skip around. It may be logically easier for you to configure BGP after everything else is set up for example.

**You may need to create VLANs or trunks depending on your physical connections in order to create this logical topology.**

R1

• Enable Cisco Express Forwarding. This is required for MPLS to function because the MPLS tags are actually based on the information in the CEF FIB Table, not the routing table itself.
• Configure VRF ABC. Utilize a route distinguisher of 100:1. Configure a route target import of 100:1, and a route target export of 100:4. These values are arbitrary, but it makes sense to give them a context. Company 100, router 4 for example.
• Configure VRF XYZ. Utilize a route distinguisher of 200:1. Configure a route target import of 200:1, and a route target export of 200:4.
• Configure all of the interfaces. Be sure to enable MPLS on F0/0, and put Lo0 and Lo1 in their corresponding VRFs.
• Enable OSPF Area 0 on Lo2 and F0/0. These two interfaces are part of the Provider network, so we need to run an IGP to have internal connectivity.
• Configure BGP AS 1. Disable normal BGP IPv4 unicast connectivity. Create a neighbor relationship with R4 utilizing the 4.4.4.4 address, and be sure to source the updates from Lo2. Enter the configuration mode for the VPNv4 address family. Activate the 4.4.4.4 neighbor, and also send the extended community information to it. Enter the configuration mode for the IPv4 VRF XYZ. Disable synchronization, and redistribute the connected interfaces. This will only enter Lo0 into BGP since it is the only interface configured for VRF XYZ. Repeat these steps for VRF ABC.

R2/R3

• Enable Cisco Express Forwarding. This is required for MPLS to function.
• Configure the two FastEthernet Interfaces, and enable MPLS on them.
• Enable OSPF Area 0 on both interfaces.

R4

• Enable Cisco Express Forwarding. This is required for MPLS to function.
• Configure VRF ABC. Utilize a route distinguisher of 100:1. Configure a route target import of 100:4, and a route target export of 100:1.
• Configure VRF XYZ. Utilize a route distinguisher of 200:1. Configure a route target import of 200:4, and a route target export of 200:1.
• Configure all of the interfaces. Be sure to enable MPLS on F0/0, and put Lo0 and Lo1 in their corresponding VRFs.
• Enable OSPF Area 0 on Lo2 and F0/0. These two interfaces are part of the Provider network, so we need to run an IGP to have internal connectivity.
• Configure BGP AS 1. Disable normal BGP IPv4 unicast connectivity. Create a neighbor relationship with R1 utilizing the 1.1.1.1 address, and be sure to source the updates from Lo2. Enter the configuration mode for the VPNv4 address family. Activate the 1.1.1.1 neighbor, and also send the extended community information to it. Enter the configuration mode for the IPv4 VRF XYZ. Disable synchronization, and redistribute the connected interfaces. This will only enter Lo0 into BGP since it is the only interface configured for VRF XYZ. Repeat these steps for VRF ABC.10

Logical Topology

Walkthrough

R1

One of the prerequisites for MPLS to be able to function is to have CEF (Cisco Express Forwarding) enabled on the router, so we will do this before taking any further steps. This is because CEF provides the fast performance of fast switching caches and yet provides resilience because it relies on information pulled directly from the IP Routing tables via the CEF FIB, rather than cached information.

R1(config)#ip cef

Now, let’s create a new VRF for one of our companies, ABC. We’ll call the VRF “ABC” to keep it simple.

R1(config)#ip vrf ABC

Now we’ll define the route distinguisher which is what is prepended to the 32bit IPv4 addresses of the VRF to create truly unique addresses, even when the same RFC1918 addresses are in use on other VRFs.

R1(config-vrf)# rd 100:1

Let’s define the extended import and export communities that we will be using with BGP. Although not shown in this example, this would be used if we wanted to attach other information to the traffic such as QoS or different local preferences. Again we are defining this for ABC which we assigned as company 200, and we are defining that we want to import the community designated for R1, and export the community designated for R4.

R1(config-vrf)#route-target import 100:1
R1(config-vrf)#route-target export 100:4

Now let’s repeat these steps again to create the VRF for company XYZ

R1(config)#ip vrf XYZ
R1(config-vrf)#rd 200:1
R1(config-vrf)#route-target import 200:1
R1(config-vrf)#route-target export 200:4

Let’s configure the interfaces that are part of the provider network now. Both Loopback2 and FastEthernet0/0 are a part of this, so each will be added to OSPF Area 0. We will also define the router-id for R1 as 1.1.1.1.

R1(config)#interface Loopback2
R1(config-if)#ip ospf 1 area 0
R1(config)#interface FastEthernet0/0
R1(config-if)#ip ospf 1 area 0
R1(config)#router ospf 1
R1(config-router)#router-id 1.1.1.1

Now we will enable MPLS connectivity on FastEthernet0/0 which is where we want the MPLS connectivity to begin.

R1(config)#interface FastEthernet0/0
R1(config-if)#mpls ip

Now that we have the provider interfaces configured, we need to set up the two Loopback interfaces that will represent our customers. Lets start with customer ABC which will utilize Loopback0.

R1(config)#interface Loopback0

Notice that we have to define the VRF before applying an IP address. If we define an IP address before the VRF, then it will be deleted when the VRF is applied.

R1(config-if)#ip vrf forwarding ABC
R1(config-if)#ip address 192.168.10.1 255.255.255.0

Now we will repeat these steps for company XYZ. We are allowed to have duplicate IP addresses because the two “companies” utilize different VRFs.

R1(config)#interface Loopback1
R1(config-if)#ip vrf forwarding XYZ
R1(config-if)#ip address 192.168.10.1 255.255.255.0

Our VRFs are all completely set up now. Let’s configure our BGP instance so that we will be able to pass routing information between the edge routers for our customers. We will utilize BGP AS 1.

R1(config)#router bgp 1

The first thing we will do is disable normal BGP IPv4 unicast connectivity. We aren’t going to configure it for normal connectivity, and we don’t even want this type of traffic to flow between the routers, so it is best to explicitly disable it.

R1(config-router)#no bgp default ipv4-unicast

We are going to be peering with R4 using it’s Loopback2 address of 4.4.4.4 in AS 1

R1(config-router)#neighbor 4.4.4.4 remote-as 1

We are also going to define that our updates will be sourced from our own Loopback2. This will make it so that the next hop is defined as our Loopback2, rather than the physical interface that the packet is actually sent out.

R1(config-router)#neighbor 4.4.4.4 update-source Loopback2

Now, we are going to define the VPNv4 family, which is what will facilitate communication internally in our MPLS VPNs.

R1(config-router)#address-family vpnv4

Let’s enable the exchange of information for the neighbor adjacency for this address-family and send our configured communities to them.

R1(config-router-af)#neighbor 4.4.4.4 activate
R1(config-router-af)#neighbor 4.4.4.4 send-community both

Finally, let’s configure what we want to send to our neighbor routers in each VRF. Let’s start with VRF ABC.

R1(config-router)#address-family ipv4 vrf ABC

We will disable synchronization so that the routes we are advertising in our iBGP setup don’t need to be in an IGP routing table to be exchanged

R1(config-router-af)#no synchronization

Now we will redistribute our connected interfaces. We can either do this or define a network statement, either will have the same effect in this example. When we redistribute connected interfaces, it will only affect Lo0 since it is the only interface in VRF ABC.

R1(config-router-af)#redistributed connected

Now let’s repeat these steps for VRF XYZ.

R1(config-router)#address-family ipv4 vrf XYZ
R1(config-router-af)#no synchronization
R1(config-router-af)#redistribute connected

And we’re done on R1!

R2

R2 is simply an internal router of the ISP, so it does not need to have any knowledge of the customer’s networks or BGP. All it needs to do is help provide end to end IP and MPLS connectivity.

As before, we need to first enable CEF as a prerequisite to running MPLS.

R2(config)#ip cef

Let’s put both FastEthernet interfaces into OSPF Area 0 and enable MPLS on both interfaces

R2(config)#interface FastEthernet0/0
R2(config-if)#ip ospf 1 area 0
R2(config-if)#mpls ip
R2(config)#interface FastEthernet0/1
R2(config-if)#ip ospf 1 area 0
R2(config-if)#mpls ip

Finally, let’s define the router id for R2 as 2.2.2.2

R2(config)#router ospf 1
R2(config-router)#router-id 2.2.2.2

That’s it for R2!

R3

R3 is simply an internal router of the ISP, so it does not need to have any knowledge of the customer’s networks or BGP. All it needs to do is help provide end to end IP and MPLS connectivity.

As before, we need to first enable CEF as a prerequisite to running MPLS.

R3(config)#ip cef

Let’s put both FastEthernet interfaces into OSPF Area 0 and enable MPLS on both interfaces

R3(config)#interface FastEthernet0/0
R3(config-if)#ip ospf 1 area 0
R3(config-if)#mpls ip
R3(config)#interface FastEthernet0/1
R3(config-if)#ip ospf 1 area 0
R3(config-if)#mpls ip

Finally, let’s define the router id for R3 as 3.3.3.3

R3(config)#router ospf 1
R3(config-router)#router-id 3.3.3.3

That’s it for R3!

R4

First, we have to again enable CEF on the router before enabling MPLS.

R4(config)#ip cef

Now, let’s create a new VRF for company ABC.

R4(config)#ip vrf ABC

Now we’ll define the route distinguisher used for ABC, just as we did on R1.

R4(config-vrf)# rd 200:1

Let’s define the extended import and export communities that we will be using with BGP. Notice that this time we are reversing what we are importing and exporting. This is so that we import the information targeted for R4, and export information for R1.

R4(config-vrf)#route-target import 100:4
R4(config-vrf)#route-target export 100:1

Now let’s repeat these steps again to create the VRF for company XYZ

R4(config)#ip vrf XYZ
R4(config-vrf)#rd 200:1
R4(config-vrf)#route-target import 200:4
R4(config-vrf)#route-target export 200:1

Let’s configure the interfaces that are part of the provider network now. Both Loopback2 and FastEthernet0/0 are a part of this, so each will be added to OSPF Area 0. We will also define the router-id for R4 as 4.4.4.4

R4(config)#interface Loopback2
R4(config-if)#ip ospf 1 area 0
R4(config)#interface FastEthernet0/0
R4(config-if)#ip ospf 1 area 0
R4(config)#router ospf 1
R4(config-router)#router-id 4.4.4.4

Now we will enable MPLS connectivity on FastEthernet0/0 which is where we want the MPLS connectivity to begin.

R4(config)#interface FastEthernet0/0
R4(config-if)#mpls ip

Now that we have the provider interfaces configured, we need to set up the two Loopback interfaces that will represent our customers. Lets start with customer ABC which will utilize Loopback0.

R4(config)#interface Loopback0

Notice that we have to define the VRF before applying an IP address. If we define an IP address before the VRF, then it will be deleted when the VRF is applied.

R4(config-if)#ip vrf forwarding ABC
R4(config-if)#ip address 192.168.10.1 255.255.255.0

Now we will repeat these steps for company XYZ. We are allowed to have duplicate IP addresses because the two “companies” utilize different VRFs.

R4(config)#interface Loopback1
R4(config-if)#ip vrf forwarding XYZ
R4(config-if)#ip address 192.168.10.1 255.255.255.0

Our VRFs are all completely set up now. Let’s configure our BGP instance so that we will be able to pass routing information between the edge routers for our customers. We will utilize BGP AS 1.

R4(config)#router bgp 1

The first thing we will do is disable normal BGP IPv4 unicast connectivity. We aren’t going to configure it for normal connectivity, and we don’t even want this type of traffic to flow between the routers, so it is best to explicitly disable it.

R4(config-router)#no bgp default ipv4-unicast

We are going to be peering with R1 using it’s Loopback2 address of 1.1.1.1 in AS 1

R4(config-router)#neighbor 1.1.1.1 remote-as 1

We are also going to define that our updates will be sourced from our own Loopback2. This will make it so that the next hop is defined as our Loopback2, rather than the physical interface that the packet is actually sent out.

R4(config-router)#neighbor 1.1.1.1 update-source Loopback2

Now, we are going to define the VPNv4 family, which is what will facilitate communication internally in our MPLS VPNs.

R4(config-router)#address-family vpnv4

Let’s enable the exchange of information for the neighbor adjacency for this address-family and send our configured communities to them.

R4(config-router-af)#neighbor 1.1.1.1 activate
R4(config-router-af)#neighbor 1.1.1.1 send-community both

Finally, let’s configure what we want to send to our neighbor routers in each VRF. Let’s star with VRF ABC.

R4(config-router)#address-family ipv4 vrf ABC

We will disable synchronization so that the routes we are advertising in our iBGP setup don’t need to be in an IGP routing table to be exchanged

R4(config-router-af)#no synchronization

Now we will redistribute our connected interfaces. We can either do this or define a network statement, either will have the same effect in this example. When we redistribute connected interfaces, it will only affect Lo0 since it is the only interface in VRF ABC.

R4(config-router-af)#redistributed connected

Now let’s repeat these steps for VRF XYZ.

R4(config-router)#address-family ipv4 vrf XYZ
R4(config-router-af)#no synchronization
R4(config-router-af)#redistribute connected

And that’s it!

Testing and Debug Commands

show ip route vrf

Show the routing table for a specific VRF

Example:

R4#show ip route vrf XYZ
Routing Table: XYZ
(Notice how it is displaying only the routing table for VRF XYZ)
Codes: C - connected, S - static, R - RIP, M - mobile, B - BGP
D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area
N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2
E1 - OSPF external type 1, E2 - OSPF external type 2
i - IS-IS, su - IS-IS summary, L1 - IS-IS level-1, L2 - IS-IS level-2
ia - IS-IS inter area, * - candidate default, U - per-user static route
o - ODR, P - periodic downloaded static route
 
Gateway of last resort is not set
 
B 192.168.10.0/24 [200/0] via 1.1.1.1, 00:00:23
C 192.168.1.0/24 is directly connected, Loopback1

ping vrf

Ping an IP address in a specific VRF

Example:

R4#ping vrf ABC 192.168.10.1
 
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.10.1, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 4/4/4 ms

show mpls forwarding-table

Show the MPLS forwarding table. See the different types of tags and the labels. Be sure to note how when the packet reaches the directly connected interface, the final label is popped off.

Example:

R4#show mpls forwarding-table
Local Outgoing Prefix Bytes tag Outgoing Next Hop
tag tag or VC or Tunnel Id switched interface
16 Aggregate 192.168.1.0/24[V] 1560
17 Aggregate 192.168.1.0/24[V] 1248
(Even though the two VRF networks are the “same”, they are assigned different tags!)
18 Pop tag 10.0.0.4/30 0 Fa0/0 10.0.0.9
19 17 1.1.1.1/32 0 Fa0/0 10.0.0.9
20 18 10.0.0.0/30 0 Fa0/0 10.0.0.9

show mpls ldp bindings

Show the LDP bindings for each of the known addresses

Example:

R4#show mpls ldp bindings
tib entry: 1.1.1.1/32, rev 8
local binding: tag: 19
remote binding: tsr: 10.0.0.2:0, tag: 16
remote binding: tsr: 10.0.0.9:0, tag: 17
remote binding: tsr: 1.1.1.1:0, tag: imp-null
tib entry: 4.4.4.4/32, rev 2
local binding: tag: imp-null
remote binding: tsr: 10.0.0.9:0, tag: 16
remote binding: tsr: 10.0.0.2:0, tag: 17
remote binding: tsr: 1.1.1.1:0, tag: 20
tib entry: 10.0.0.0/30, rev 10
local binding: tag: 20
remote binding: tsr: 10.0.0.2:0, tag: imp-null
remote binding: tsr: 10.0.0.9:0, tag: 18
remote binding: tsr: 1.1.1.1:0, tag: imp-null
tib entry: 10.0.0.4/30, rev 6
local binding: tag: 18
remote binding: tsr: 10.0.0.9:0, tag: imp-null
remote binding: tsr: 10.0.0.2:0, tag: imp-null
remote binding: tsr: 1.1.1.1:0, tag: 16
tib entry: 10.0.0.8/30, rev 4
local binding: tag: imp-null
remote binding: tsr: 10.0.0.9:0, tag: imp-null
remote binding: tsr: 10.0.0.2:0, tag: 18
remote binding: tsr: 1.1.1.1:0, tag: 21

show mpls ldp neighbor

Show the LDP neighbors

Example:

R4#show mpls ldp neighbor
Peer LDP Ident: 10.0.0.9:0; Local LDP Ident 4.4.4.4:0
TCP connection: 10.0.0.9.14725 - 4.4.4.4.646
State: Oper; Msgs sent/rcvd: 36/37; Downstream
Up time: 00:25:14
LDP discovery sources:
FastEthernet0/0, Src IP addr: 10.0.0.9
FastEthernet0/0, Src IP addr: 10.0.0.6
Addresses bound to peer LDP Ident:
10.0.0.9 10.0.0.6
Peer LDP Ident: 10.0.0.2:0; Local LDP Ident 4.4.4.4:0
TCP connection: 10.0.0.2.38070 - 4.4.4.4.646
State: Oper; Msgs sent/rcvd: 32/31; Downstream
Up time: 00:20:32
LDP discovery sources:
FastEthernet0/0, Src IP addr: 10.0.0.5
FastEthernet0/0, Src IP addr: 10.0.0.2
Addresses bound to peer LDP Ident:
10.0.0.2 10.0.0.5
Peer LDP Ident: 1.1.1.1:0; Local LDP Ident 4.4.4.4:0
TCP connection: 1.1.1.1.646 - 4.4.4.4.59004
State: Oper; Msgs sent/rcvd: 30/31; Downstream
Up time: 00:20:28
LDP discovery sources:
FastEthernet0/0, Src IP addr: 10.0.0.1
Addresses bound to peer LDP Ident:
10.0.0.1 1.1.1.1

debug mpls packets

Enable debugging of MPLS packets. Enable this on either R2 or R3, then ping from one end of a company to the other. See how it recognizes the labels are received and how it resends it back out. If it is destined for a directly connected interface, the last label is popped off and you will see an xmit: (no label)

Example:

R4#debug mpls packets
*Apr 17 19:54:43.643: MPLS: Fa0/0: recvd: CoS=6, TTL=255, Label(s)=18
*Apr 17 19:54:43.643: MPLS: Fa0/1: xmit: (no label)
 
(This was generated by an ICMP echo from R1. Notice how the incoming Label is 18 
which we know is the “pop” label. It is then sent out the other interface with no label 
at all to its final destination!)
 
*Apr 17 19:54:43.843: MPLS: Fa0/1: recvd: CoS=6, TTL=255, Label(s)=16
*Apr 17 19:54:43.843: MPLS: Fa0/0: xmit: (no label)
*Apr 17 19:54:44.999: MPLS: Fa0/1: recvd: CoS=6, TTL=255, Label(s)=16
*Apr 17 19:54:44.999: MPLS: Fa0/0: xmit: (no label)
*Apr 17 19:54:44.999: MPLS: Fa0/0: recvd: CoS=6, TTL=255, Label(s)=18
*Apr 17 19:54:44.999: MPLS: Fa0/1: xmit: (no label)/0: xmit: CoS=0, TTL=253, Label(s)=18
*Apr 17 20:04:06.223: MPLS: Fa0/0: recvd: CoS=0, TTL=255, Label(s)=17/16
*Apr 17 20:04:06.223: MPLS: Fa0/1: xmit: CoS=0, TTL=254, Label(s)=16/16

Solutions

R1

hostname R1
!
ip cef
!
ip vrf ABC
rd 100:1
route-target export 100:4
route-target import 100:1
!
ip vrf XYZ
rd 200:1
route-target export 200:4
route-target import 200:1
!
interface Loopback0
ip vrf forwarding ABC
ip address 192.168.10.1 255.255.255.0
!
interface Loopback1
ip vrf forwarding XYZ
ip address 192.168.10.1 255.255.255.0
!
interface Loopback2
ip address 1.1.1.1 255.255.255.255
ip ospf 1 area 0
!
interface FastEthernet0/0
ip address 10.0.0.1 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
router ospf 1
router-id 1.1.1.1
log-adjacency-changes
!
router bgp 1
no bgp default ipv4-unicast
bgp log-neighbor-changes
neighbor 4.4.4.4 remote-as 1
neighbor 4.4.4.4 update-source Loopback2
!
address-family vpnv4
neighbor 4.4.4.4 activate
neighbor 4.4.4.4 send-community both
exit-address-family
!
address-family ipv4 vrf XYZ
redistribute connected
no synchronization
exit-address-family
!
address-family ipv4 vrf ABC
redistribute connected
no synchronization
exit-address-family
!
end

R2

hostname R2
!
ip cef
!
interface FastEthernet0/0
ip address 10.0.0.2 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
interface FastEthernet0/1
ip address 10.0.0.5 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
router ospf 1
router-id 2.2.2.2
log-adjacency-changes
!
end

R3

hostname R3
!
ip cef
!
interface FastEthernet0/0
ip address 10.0.0.9 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
interface FastEthernet0/1
ip address 10.0.0.6 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
router ospf 1
router-id 3.3.3.3
log-adjacency-changes
!
end

R4

hostname R4
!
ip cef
!
ip vrf ABC
rd 100:1
route-target export 100:1
route-target import 100:4
!
ip vrf XYZ
rd 200:1
route-target export 200:1
route-target import 200:4
!
interface Loopback0
ip vrf forwarding ABC
ip address 192.168.1.1 255.255.255.0
!
interface Loopback1
ip vrf forwarding XYZ
ip address 192.168.1.1 255.255.255.0
!
interface Loopback2
ip address 4.4.4.4 255.255.255.255
ip ospf 1 area 0
!
interface FastEthernet0/0
ip address 10.0.0.10 255.255.255.252
ip ospf 1 area 0
duplex auto
speed auto
mpls ip
!
router ospf 1
router-id 4.4.4.4
log-adjacency-changes
!
router bgp 1
no bgp default ipv4-unicast
bgp log-neighbor-changes
neighbor 1.1.1.1 remote-as 1
neighbor 1.1.1.1 update-source Loopback2
!
address-family vpnv4
neighbor 1.1.1.1 activate
neighbor 1.1.1.1 send-community extended
exit-address-family
!
address-family ipv4 vrf XYZ
redistribute connected
no synchronization
exit-address-family
!
address-family ipv4 vrf ABC
redistribute connected
no synchronization
exit-address-family
!
end

An absolutely perfect solution to this dilemma would have been DNS SRV entries. Or they would have been if any browser in existence supported them. I can’t really fathom why they aren’t supported either.

DNS SRV entries are basically entries that map a service to a destination host and port, which is an elegant solution to a problem presented by an outdated paradigm. Our old method of connectivity revolves around sockets which are a combination of an IP Address and a port. In this day, who really cares what port a service like HTTP is running on? If we can recognize that they’re looking for HTTP, then we can simply do a DNS SRV lookup to find that for the domain dch-it.com, an HTTP server exists over at randomdns.com at port 87 or whatever I had set it up as. The user will never know that though, all he/she will see is http://dch-it.com as it should be.

It’s also a very cost efficient (read: FREE) way of load balancing servers. You can set a priority and weight for each individual SRV entry. Let’s ignore priority for the moment since I’m sure you can figure what that does (if you can’t, please reference dictionary.com). Let’s say we have two HTTP SRV entries with equal priority, and we set one of their weights to be 70 and the other 30. That means that 70% of DNS queries will be directed to server A, and 30% to server B. Now isn’t that much easier than setting up any kind of funky Load Balancing Hardware or a software based solution? The only downside is that it doesn’t take the current load of the server into consideration, however most small companies really don’t have to worry about things like that unless they are heavy into the web business.

So how about it Microsoft or Mozilla? Who’s going to be the big man and step up first?