When diving into network programming, understanding fundamental concepts is crucial. Let's break down your questions systematically with practical implementations.

The address 192.168.1.105 represents a private IPv4 address in the 192.168.0.0/16 range, commonly used in home networks. The 127.0.0.1 is the loopback address that points to your local machine. These concepts form the basis of network communication.

# Python example checking localhost
import socket

def check_localhost():
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind(('127.0.0.1', 8000))
        print("Localhost is available")
    except socket.error as e:
        print(f"Error: {e}")
    finally:
        sock.close()

A subnet mask determines which portion of an IP address represents the network and which represents the host. For example, with 192.168.1.105/24, the first 24 bits are the network portion.

# Calculating network address from IP and subnet mask
def calculate_network(ip, mask):
    ip_octets = list(map(int, ip.split('.')))
    mask_octets = list(map(int, mask.split('.')))
    network = [str(ip_octets[i] & mask_octets[i]) for i in range(4)]
    return '.'.join(network)

print(calculate_network('192.168.1.105', '255.255.255.0'))  # Output: 192.168.1.0

Traceroute works by sending packets with increasing TTL values. Here's a simplified Python implementation using ICMP:

import os
import socket
import struct
import select

def traceroute(dest, max_hops=30, timeout=2):
    port = 33434
    icmp = socket.getprotobyname('icmp')
    udp = socket.getprotobobyname('udp')
    
    for ttl in range(1, max_hops+1):
        rx_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
        rx_socket.bind(('', port))
        
        tx_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp)
        tx_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl)
        tx_socket.sendto(b'', (dest, port))
        
        ready = select.select([rx_socket], [], [], timeout)
        if ready[0]:
            data, addr = rx_socket.recvfrom(512)
            print(f"{ttl}\t{addr[0]}")
            if addr[0] == dest:
                break
        else:
            print(f"{ttl}\t*")
            
        rx_socket.close()
        tx_socket.close()

localhost and machine names like room3pc work through hostname resolution:

1. localhost is hardcoded in the hosts file to resolve to 127.0.0.1
2. room3pc uses either DNS or local network name resolution (NetBIOS, mDNS)

# Python hostname resolution
import socket

print(socket.gethostbyname('localhost'))  # 127.0.0.1
print(socket.gethostbyname_ex('room3pc'))  # Returns all name info

The smb://room3pc format is a UNC path for Server Message Block protocol, commonly used in Windows networks for file sharing. On macOS/Linux, you can use smbclient or mount via:

mount_smbfs //username@room3pc/sharename /mnt/point

In a DHCP-enabled LAN:

1. Client broadcasts DHCP Discover
2. Server responds with Offer
3. Client requests an IP (Request)
4. Server acknowledges (ACK)

Without DHCP, you need static IP configuration:

# Linux static IP configuration example
ifconfig eth0 192.168.1.100 netmask 255.255.255.0 up
route add default gw 192.168.1.1

Modern macOS systems support several URL schemes:

1. VNC: vnc://mac-hostname.local
2. SSH: ssh://user@mac-hostname.local
3. AFP (Apple Filing Protocol): afp://mac-hostname.local

---

Before diving into implementation, let's clarify some fundamental concepts you mentioned:

• Private IP addresses (192.168.x.x): These are non-routable addresses used within local networks
• Localhost (127.0.0.1): A loopback address pointing to your own machine
• Hostnames (room3pc): Local network name resolution typically handled by DNS or NetBIOS

Here's a Python implementation using raw sockets to demonstrate how traceroute works:

import socket
import struct
import time

def traceroute(dest, max_hops=30, timeout=2):
    port = 33434
    ttl = 1
    while True:
        recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
        send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
        send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl)
        recv_socket.settimeout(timeout)
        
        recv_socket.bind(("", port))
        send_socket.sendto(b"", (dest, port))
        
        try:
            _, curr_addr = recv_socket.recvfrom(512)
            curr_addr = curr_addr[0]
            print(f"{ttl}\t{curr_addr}")
            if curr_addr == dest:
                break
        except socket.error:
            print(f"{ttl}\t*")
        
        send_socket.close()
        recv_socket.close()
        ttl += 1
        if ttl > max_hops:
            break

traceroute("google.com")

A subnet mask determines which portion of an IP address is the network portion and which is the host portion. For example:

• IP: 192.168.1.105
• Subnet mask: 255.255.255.0
• Network ID: 192.168.1.0
• Host ID: 105

Here's how to calculate network boundaries in Python:

import ipaddress

net = ipaddress.IPv4Network("192.168.1.105/24", strict=False)
print(f"Network address: {net.network_address}")
print(f"Broadcast address: {net.broadcast_address}")
print(f"Usable host range: {list(net.hosts())[0]} - {list(net.hosts())[-1]}")

In a LAN without DHCP, you need to manually configure:

# Linux static IP configuration example
$ sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
$ sudo route add default gw 192.168.1.1
$ echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

With DHCP, this is handled automatically when you connect to the network.

The different URL formats you mentioned work because of various protocols:

• http://room3pc: Uses HTTP protocol and relies on local name resolution
• smb://room3pc: Uses SMB protocol for Windows file sharing

For macOS connectivity, you can use:

# Connect via SSH
$ ssh username@mac-hostname.local

# Mount AFP share
$ mount_afp afp://username:password@mac-hostname.local/ShareName /mnt/macshare

For deeper understanding, consider these books:

• "Computer Networking: A Top-Down Approach" by Kurose and Ross
• "TCP/IP Illustrated, Volume 1" by W. Richard Stevens
• "Network Programming with Go" by Adam Woodbeck

Online resources:

• Cloudflare Learning Center (https://www.cloudflare.com/learning/)
• PacketLife.net's cheat sheets
• Wireshark documentation for packet analysis