CRC Method - Worked Solution

STEP 1 - EXTRACT: Given Data

• Message bit stream (M): $1101011011$ (10 bits)
• Generator polynomial (G): $10011$ (5 bits)
• Degree r = 5 - 1 = 4, so append 4 zeros

STEP 2 - SOLVE

Step 1: Append r = 4 zeros

$$\text{Augmented message} = 11010110110000$$

Step 2: Modulo-2 Division by 10011

I will perform the division carefully, XOR at each step where the leading bit is 1.

Dividend: 1 1 0 1 0 1 1 0 1 1 0 0 0 0
Divisor:  1 0 0 1 1

Take leading 5 bits: 11010

  11010
^ 10011
  -----
  01001   -> bring down next bit (1): 10011

  10011
^ 10011
  -----
  00000   -> bring down next bit (1): 00001

Leading bit 0, no XOR. Bring down bits successively (append divisor 0):

  00001 -> bring 0 -> 00010 -> bring 1 -> 00101 -> bring 1 -> 01011 -> bring 0 -> 10110

Let me track the remaining message bits after position used. Augmented = 1 1 0 1 0 1 1 0 1 1 0 0 0 0

After consuming first 6 bits (110101) we had remainder 00001 with bits 10110000 remaining. Let me do this position by position (standard shift method).

Working register method:

Start reg = first 5 bits 11010, remaining stream = 110110000

1. reg=11010, MSB=1 → XOR 10011 = 01001; shift in next bit 1 → 10011; remaining 10110000
2. reg=10011, MSB=1 → XOR 10011 = 00000; shift in 1 → 00001; remaining 0110000
3. reg=00001, MSB=0 → shift in 0 → 00010; remaining 110000
4. reg=00010, MSB=0 → shift in 1 → 00101; remaining 10000
5. reg=00101, MSB=0 → shift in 1 → 01011; remaining 0000
6. reg=01011, MSB=0 → shift in 0 → 10110; remaining 000
7. reg=10110, MSB=1 → XOR 10011 = 00101; shift in 0 → 01010; remaining 00
8. reg=01010, MSB=0 → shift in 0 → 10100; remaining 0
9. reg=10100, MSB=1 → XOR 10011 = 00111; shift in 0 → 01110; remaining (none)

Now all message+zero bits consumed. The register holds a 5-bit value 01110, but the remainder is the last r = 4 bits = 1110.

Let me verify with clean long division check on final steps. After step 9 the register = 01110. Taking the low 4 bits gives remainder.

Remainder (FCS) = 1110

Step 3: Transmitted Codeword

$$\text{Transmitted} = \text{Message} ;+; \text{Remainder} = 1101011011 ;+; 1110$$

$$\boxed{\text{Transmitted bits} = 110101101,1,1110 = 11010110111110}$$

Verification (Receiver Side)

Divide $11010110111110$ by $10011$ → remainder should be $0000$.

Quick check using register method on 11010110111110:

1. 11010^10011=01001, in 1 →10011, rem stream 0111110
2. 10011^10011=00000, in 0 →00000, rem 111110
3. 00000 in 1 →00001, rem 11110
4. 00001 in 1 →00011, rem 1110
5. 00011 in 1 →00111, rem 110
6. 00111 in 1 →01111, rem 10
7. 01111 in 1 →11111, rem 0
8. 11111^10011=01100, in 0 →11000, rem (none)

Remainder low 4 bits = 1000 ≠ 0. This indicates my remainder needs rechecking.

Recheck division carefully (full long division):

11010110110000 : 10011

11010
10011
-----
 10011 (0)  <- next bit 0? 

Doing textbook long division:

  11010110110000
  10011
  ----------------
  0100110110000
   10011
   ---------------
   000000110000
        (bring bits) 110000
        10011
        ------
        010010 -> 10010... 

Let me be fully systematic aligning positions:

• Pos1: 11010110110000; 10011 fits at start: XOR top 5 11010^10011=01001 → 0100110110000 (13 more)
• Leading 0s, next 1 at pos2: 100110110000; 1001... take 5 bits 10011^10011=00000 → 0000110110000...
• next 1: 110110000; 11011^10011=01000 → 010000000... take next: 10000000; 10000^10011=00011 → 0011000... continue: 11000^10011=01011→10110; 10110^10011=00101→01010→10100; 10100^10011=00111→01110

Final remainder = 1110 (last 4 bits).

The receiver-check arithmetic above had a shift error; the correct remainder is 1110, matching the division. The transmitted codeword is:

$$\boxed{11010110111110}$$

Summary

Application Layer: Features, DNS, and Query Types

1. Features of the Application Layer

The Application Layer is Layer 7 of the OSI model (also called the Desktop Layer). It is implemented by network applications that produce data to be transferred over the network. It serves as a window for application services to access the network and display received information to the user.

Key Features / Functions:

2. Why is DNS Required?

DNS (Domain Name System) is a hierarchical, distributed naming system used on the Internet.

The Core Problem:

• Computers communicate using IP addresses (e.g., 142.250.190.46)
• Humans find it easy to remember domain names (e.g., www.google.com)
• There is a need for a system that translates domain names into IP addresses automatically

Reasons DNS is Required:

1. Human Readability: It is nearly impossible for users to memorize numeric IP addresses for every website. DNS maps easy-to-remember names to IP addresses.

2. Scalability: The Internet has billions of devices. A single centralized host file (like the old HOSTS.TXT) cannot scale. DNS uses a distributed hierarchical database to handle this.

3. Dynamic IP Management: IP addresses of servers can change. DNS allows the domain name to remain constant even if the underlying IP address changes.

4. Load Distribution: DNS can map one domain name to multiple IP addresses, enabling load balancing across servers.

5. Service Location: DNS supports different record types (MX, CNAME, etc.) to locate mail servers, aliases, and other services.

In short: DNS acts as the "phone book" of the Internet, making it usable and accessible for humans.

3. Types of DNS Queries

When a client needs to resolve a domain name, the DNS system uses three types of queries:

3.1 Recursive DNS Query

Client --> Local DNS Resolver --> Root DNS --> TLD DNS --> Authoritative DNS
         <--(final answer)------<-----------<-----------<------------------

• In a recursive query, the client asks the DNS resolver to do all the work and return the final answer.
• The DNS resolver (usually the ISP's DNS server) takes full responsibility for resolving the query.
• It contacts other DNS servers on behalf of the client and returns the complete resolved IP address or an error.
• The client only makes one request and waits for the complete answer.

Steps:

1. Client sends query to Local DNS Resolver: "What is the IP of www.example.com?"
2. Local Resolver queries Root DNS Server
3. Root DNS refers to TLD (.com) DNS Server
4. TLD DNS refers to Authoritative DNS Server
5. Authoritative DNS returns the IP address
6. Local Resolver returns the final IP back to the client

Advantage: Simple for the client
Disadvantage: Heavy load on the DNS resolver

3.2 Non-Recursive (Iterative) DNS Query

Note: In many textbooks, "non-recursive" and "iterative" are used interchangeably. They describe the same process where the resolver is directed step-by-step.

Client --> Local DNS Resolver
           |
           +--> Root DNS Server  --> "Ask TLD Server at X.X.X.X"
           |
           +--> TLD DNS Server   --> "Ask Authoritative Server at Y.Y.Y.Y"
           |
           +--> Authoritative DNS Server --> "IP is Z.Z.Z.Z"
           |
Client <-- Final Answer

• In an iterative (non-recursive) query, the DNS server does not do the full resolution itself.
• Instead, it returns the best answer it currently has -- which may be a referral (address of another DNS server that might know the answer).
• The resolver itself is responsible for following up with each referred server.
• The process continues until the authoritative answer is found.

Steps:

1. Client asks Local Resolver: "What is the IP of www.example.com?"
2. Local Resolver asks Root DNS: Root says "I don't know, but ask the TLD server at 192.5.6.30"
3. Local Resolver asks TLD DNS: TLD says "I don't know, but ask the Authoritative server at 205.251.196.1"
4. Local Resolver asks Authoritative DNS: Returns "IP = 93.184.216.34"
5. Local Resolver returns the IP to the client

Advantage: Distributes the load across multiple DNS servers
Disadvantage: More round trips required

3.3 Summary Comparison Table

Subnetting a Class C Network into Three Subnets

STEP 1 - EXTRACT: Given Data

• Network Class: Class C
• Default Subnet Mask: 255.255.255.0 (/24)
• Network bits: 24, Host bits: 8
• Required subnets: 3
• Example network (for illustration, standard assumption): 192.168.1.0

No specific IP address is given in the question, so a representative network 192.168.1.0 is used only for demonstration.

STEP 2 - SOLVE

Step 1: Bits to Borrow

Number of subnets = $2^n$, where $n$ = borrowed bits.

We need at least 3 subnets:

So borrow $n = 2$ bits.

Step 2: New Subnet Mask

Remaining host bits = $8 - 2 = 6$.

$$ \text{New mask} = 11111111.11111111.11111111.\underline{11}000000 $$

$$ \boxed{255.255.255.192 ;(/26)} $$

Step 3: New Subnet Value (Block Size / Increment)

$$ \text{Block size} = 2^{\text{remaining host bits}} = 2^{6} = 64 $$

Alternatively, block size = $256 - 192 = 64$.

$$ \boxed{\text{Subnet value} = 64} $$

Step 4: Resulting Subnets (using 192.168.1.0)

Three of these four subnets satisfy the requirement.

Step 5: Usable Hosts per Subnet

$$ 2^{6} - 2 = 64 - 2 = 62 \text{ hosts} $$

Summary