📝 ASN.1 data types explained (23 MCQs)

📖 Explanation: Using a floating‑point type for a descriptor causes the large integer returned by `socket()` to be converted to a floating‑point representation, losing precision and potentially yielding a negative or non‑integer value. Subsequent system calls expect a valid integer descriptor, so the program will likely fail to communicate or produce errors.

📖 Explanation: The command‑line argument is already stored in memory by the runtime; assigning a `char *` simply points to that existing string. Using a fixed‑size array would require copying the data, which is unnecessary and could waste stack space if the name is short. Hence the pointer is the most efficient choice.

📖 Explanation: `recv()` returns a negative value on error. Storing that in a signed `int` and then testing `n > MAX` would treat an error as a valid byte count, potentially causing the program to process invalid data. Proper error checking should test for `n < 0` before any size comparison.

📖 Explanation: The buffer is intended for raw data transfer, not null‑terminated strings, so the extra byte is not for a terminator. However, many protocols prepend a length byte or need a sentinel value; allocating one more byte anticipates such a requirement, ensuring the buffer can hold the maximum payload plus the additional control byte.

📖 Explanation: `struct sockaddr_in` is the standard structure for IPv4 socket addresses, applicable to both stream (TCP) and datagram (UDP) sockets. Its presence indicates the program will operate over IPv4, but does not restrict the transport protocol; the later `listen` or `connect` calls determine TCP versus UDP.

📖 Explanation: Assigning `AF_INET6` to a field designed for IPv4 does not automatically adjust the structure layout. The `bind` system call will interpret the mismatched family as an error, typically returning `EINVAL`. The program will not start listening, highlighting the importance of matching address families with their corresponding structures.

📖 Explanation: `ptr` is initialized to the start of `buffer` and then incremented as bytes are received. This technique lets the program write incoming data to successive locations while preserving the original buffer address for later processing or printing. Advancing `ptr` does not modify `buffer` itself; it merely changes where the next write occurs.

📖 Explanation: Socket descriptors are defined by the POSIX API as integer values. Using `int` aligns with the standard, ensuring portability across platforms. A `void *` would require casting and could obscure the nature of the descriptor, potentially leading to misuse or compilation warnings. Therefore, `int` remains the preferred choice.

📖 Explanation: `argv[3]` is provided by the runtime and points to a null‑terminated string from the command line. Assigning its address to `string` does not copy the data but merely references it. As long as the program does not modify the string or exceed its length, this usage is safe and common in C programs.

📖 Explanation: Zero‑initializing ensures that all fields not explicitly set (such as padding bytes) contain known values, preventing accidental leakage of garbage data into system calls like `bind`. This practice avoids undefined behavior that could arise from uninitialized fields, especially on architectures where padding may be transmitted.

📖 Explanation: Increasing the buffer size without adjusting the logic that tracks the number of valid bytes can lead to processing of uninitialized memory. If the program assumes the buffer contains only the received payload, residual data from previous operations may be mistakenly transmitted or printed, causing incorrect output.

📖 Explanation: `atoi` returns 0 when conversion fails, which is a valid (though usually undesired) port number. Not checking the result can cause the client to attempt a connection on an unintended port, leading to connection failures or unintended behavior. Proper error handling should verify that the conversion succeeded and the result lies within the valid port range.

📖 Explanation: Placing the address structure globally makes it accessible to any function, which could unintentionally modify its fields, especially in multi‑threaded contexts. Declaring it locally confines its lifetime to `main`, reducing side effects and improving encapsulation. However, both scopes can be zeroed explicitly, so the primary concerns are encapsulation and thread safety.

📖 Explanation: The POSIX `recv` function returns a signed size type (`ssize_t`) that can represent both the number of bytes read and negative error codes. Using `ssize_t` ensures the variable can hold the full range of possible return values without truncation, improving correctness and portability.

📖 Explanation: Writing a null terminator at `buffer[length]` when the buffer size equals the maximum payload (256) writes to index 256, which is outside the allocated array (indices 0‑255). This out‑of‑bounds write can corrupt adjacent memory, leading to crashes or security vulnerabilities.

📖 Explanation: POSIX defines socket descriptors as non‑negative integers, but functions like `socket()` return `-1` on error. Using a signed `int` allows the program to detect this error condition directly. An unsigned type would wrap `-1` to a large positive value, obscuring the failure. Hence, signed `int` aligns with the API contract.

📖 Explanation: Using a pointer that is incremented after each `recv` call eliminates the need for an explicit index variable, making the loop body shorter and clearer. The pointer always points to the next free position in the buffer, and the code can directly pass `ptr` to subsequent functions without calculating offsets.

📖 Explanation: `struct sockaddr_in` is the IPv4 socket address structure. `sin_family` must be set to `AF_INET` to indicate IPv4. `sin_port` stores the port number in network byte order, typically set using `htons`. `sin_addr` holds the IPv4 address, often set via `inet_pton` or `INADDR_ANY`. These fields together define where the socket will bind or connect.

📖 Explanation: While most POSIX implementations keep socket descriptors as 32‑bit integers even on 64‑bit platforms, some systems may define them as larger types. Using a plain `int` could truncate a 64‑bit descriptor, leading to invalid handles and runtime errors. Portable code should use the `socket_t` or `int` as defined by the API, but awareness of potential size differences is essential.

📖 Explanation: POSIX system calls, including `recv()`, return `-1` to indicate an error, setting `errno` to describe the failure. Checking for `n == -1` follows this convention, allowing the program to handle errors appropriately. This pattern is fundamental to robust network programming.

📖 Explanation: `size_t` is the unsigned type returned by `strlen` and other size‑related functions, guaranteeing a non‑negative value and accommodating the full range of possible string lengths on the target platform. Using `int` could truncate large lengths or permit negative values, which are semantically incorrect for a size.

📖 Explanation: Without copying the provided hostname into `servName`, the array remains filled with zeros (or indeterminate data), leading to an empty or invalid hostname string. The subsequent `connect` call will fail to resolve the address, typically resulting in a DNS error and termination of the client.

📖 Explanation: `AF_INET` is a constant defined in the sockets API that designates the IPv4 address family. It tells the system that the socket will use IPv4 addresses, influencing how address structures are interpreted and how routing is performed. It is distinct from `AF_INET6`, which is used for IPv6.