C Language

Why C still matters

C is the language you use when the next layer down is hardware or an ABI that must stay stable for decades. The Linux kernel, bootloaders, libc (glibc on GNU/Linux, bionic on Android), vendor HALs, radio firmware, and most NDK libraries are C or a thin C-callable shell around C++. Interviews for platform, BSP, modem and native Android roles treat C as assumed fluency, not as a "nice to have".

App (Java / Kotlin)          see java.html
        | Binder / JNI
Framework + native daemons   see android-frameworks.html, binder-aidl.html
        | C ABI / HIDL / AIDL / ioctl
Vendor HAL (often C or C++)
        | syscall / ioctl
Linux kernel (C)             see linux-kernel-bsp.html
        | MMIO / IRQ / DMA
Firmware, bootloader, libc   C, sometimes assembly

What an interviewer is really testing

They are not testing whether you remember the exact wording of the standard. They are testing whether you can ship a HAL or a native daemon without leaking, racing, overflowing, or invoking UB that only appears at -O2 on the device. C++ adds RAII and the STL (see C++); algorithms and Big-O live on the DSA page. Here the subject is the C abstract machine and how it maps onto Linux and Android.

Compilation model

A C program is not "the source files". It is one or more translation units that the compiler turns into object files, which the linker combines with libraries into an executable or a shared object. Interviews fail people who treat #include as "copy the implementation" or who cannot explain why a function in a header became a multiple-definition error.

The four stages

1. Preprocess cpp / clang -E expands #include, #define, #ifdef. The output is still C text, one translation unit. Line markers remember the original file for diagnostics.
2. Compile The compiler front end parses that text, type-checks it, and the back end emits assembly for the target (aarch64, x86_64, …).
3. Assemble as turns assembly into an object file: machine code, a symbol table, and relocation records. Nothing has been "wired up" to other files yet.
4. Link The linker assigns final addresses, patches relocations, pulls in .a members or records DT_NEEDED for .so files, and writes the ELF (or PE) image.

# See each stage (names vary; the idea does not)
clang -E  foo.c -o foo.i          # preprocessed C
clang -S  foo.c -o foo.s          # assembly
clang -c  foo.c -o foo.o          # object file
clang     foo.o bar.o -o prog     # link
clang -shared -fPIC foo.o -o libfoo.so

Headers vs sources

A header is included textually. Anything with external linkage that you define in a header (a non-inline function body, a non-const object) is copied into every unit that includes it, and the linker then sees many definitions. Put declarations in headers and definitions in exactly one .c, unless you use static (internal linkage) or C99 inline with a single external definition.

Types, promotions and conversions

C's integer rules are older than most of the codebases you will work in, and they still surprise people. Almost every "why did this comparison go wrong?" or "why is this shift UB?" question bottoms out in integer promotions, usual arithmetic conversions, signedness, and whether overflow is defined.

Integer promotions

In most expression contexts, types narrower than int (char, signed char, unsigned char, short, bit-fields, enums of small range) are promoted: if int can represent every value of the original type, the result is int; otherwise unsigned int. This happens to operands of arithmetic, to function arguments without a prototype (old style), and to the integer operand of some operators. It does not happen when you store into an object — assignment converts to the target type.

unsigned char a = 1, b = 2;
int s = a - b;          /* promotions to int: result is -1, not 255 */
unsigned char u = a - b; /* then convert: implementation-defined / wrap to 255 */

if (a - b > 0) { }      /* -1 > 0 is false — a common loop/unsigned-char bug */

Usual arithmetic conversions

For a binary operator, after promotions, C picks a common real type. Roughly: if either side is floating, both become that floating type; else both become the type with the higher conversion rank; if ranks are equal but signedness differs, a signed type converts to the unsigned type of the same rank. That last rule is why if (len < 0) is nonsense when len is size_t, and why -1 < (size_t)1 is false: -1 becomes a huge unsigned value.

Signed overflow vs unsigned wrap

Unsigned integers wrap modulo 2ⁿ. That is defined. Signed overflow (and signed division overflow, and shifting into or past the sign bit in ways the standard forbids) is undefined behaviour. Compilers exploit "signed overflow never happens" to delete bounds checks and to rewrite loops. -fwrapv makes signed overflow wrap, but that is a dialect, not portable C, and kernel/Android code should not depend on it unless the build actually passes the flag.

int n = INT_MAX;
n = n + 1;              /* UB. Do not "know" it becomes INT_MIN. */

unsigned u = UINT_MAX;
u = u + 1u;             /* defined: 0 */

size_t bytes = (size_t)count * elem;  /* may wrap; then malloc(bytes) is too small */

char signedness

Plain char is either signed or unsigned; the implementation chooses. On many ARM Android ABIs it is unsigned; on x86 it is often signed. If you write char c = getbyte(); if (c == 0xFF) you may be comparing -1 to 255. For bytes, use unsigned char or uint8_t. For text, be explicit. This is a favourite "works on my laptop, fails on the phone" question.

Memory: stack, heap, data, bss, text

A running C program (userspace) has a virtual address space the OS backs with pages. Interviewers want the segments you reason about, not a full MMU lecture (that is on Linux kernel & BSP).

high addresses
  argv / env
  stack (grows down)     locals, return addresses, spilled args
  ...
  mmap / shared libs
  heap  (grows up)       malloc / new
  bss                    uninitialised / zero globals
  data                   initialised globals
  rodata                 string literals, const
  text                   machine code
low addresses

malloc, calloc, realloc, free

• malloc(n) — n bytes, alignment suitable for any standard type (at least max_align_t). Contents indeterminate. malloc(0) is implementation-defined (NULL or a unique pointer you must still free).
• calloc(nmemb, size) — zeroed; watch overflow in nmemb * size.
• realloc(p, n) — may extend in place or move. On failure, p is still valid; the classic leak is p = realloc(p, n) when the result is NULL. realloc(NULL, n) is malloc(n). realloc(p, 0) is a mess across C versions and libraries — avoid it.
• free(p) — free(NULL) is a no-op. Anything else twice, or a pointer not from this allocator, is UB.

void *p = malloc(n);
if (!p) return -ENOMEM;
void *q = realloc(p, n2);
if (!q) { free(p); return -ENOMEM; }  /* p still valid on failure */
p = q;

Alignment, padding, endian

The CPU and the ABI require that a type sit at an address divisible by its alignment (often its size). The compiler inserts padding inside structs so every member is aligned, and often trailing padding so an array of the struct stays aligned. offsetof and sizeof tell the truth; guessing does not.

Endianness is the byte order of a multi-byte integer in memory. Little-endian (ARM Android, x86) stores the least significant byte at the lowest address. Big-endian is the opposite. The host endian is not the wire endian. Protocols and filesystems specify one; you convert with explicit shifts or htole32-style helpers, not by taking the address of an int.

Pointer vs array

An array is a sequence of objects. In most expressions, an array decays to a pointer to its first element. Exceptions: sizeof, _Alignof (C11), address-of &arr (type is pointer-to-array), and string-literal initialisation of an array. A function parameter void f(int a[10]) is a lie: it is int *a. sizeof a inside f is the size of a pointer.

int a[3] = {1, 2, 3};
int *p = a;           /* decay */
size_t n = sizeof a;  /* 3 * sizeof(int) */
size_t m = sizeof p;  /* sizeof(int *) */

void f(int b[3]) {
    /* sizeof b == sizeof(int *), always */
}

Pointers in depth

A pointer value is an address plus a type that says how to load, store and step. Almost all hard C bugs are pointer bugs: wrong type, wrong lifetime, wrong provenance, or arithmetic that walks off the object.

Pointer arithmetic

If p points to an element of an array (or one-past-the-last), p + k moves by k * sizeof(*p) bytes. Arithmetic on pointers that do not belong to the same array object is UB. One-past-the-end is a valid pointer value but must not be dereferenced. NULL arithmetic is UB. Subtracting two pointers yields ptrdiff_t and is only defined within the same array.

Because a[i] is defined as *((a) + (i)), i[a] is the same expression. That is a trivia question; the useful point is that the array and the index are symmetric in the abstract machine.

void*

void * is the generic data pointer. You may convert to and from any object pointer without a cast in C (C++ requires a cast; see C++). You may not dereference it or do pointer arithmetic on it (GCC has a byte-sized void * extension; do not use it in interview-portable code). Function pointers are not safely portable through void * in standard C, though POSIX and Android practice often do it; the honest answer is "object pointers yes, function pointers only with a platform ABI".

Function pointers

The type includes the return type and parameter types. Use a typedef so callbacks stay readable. HALs, qsort, pthread start routines and JNI native method tables are function-pointer tables.

typedef int (*cmp_fn)(const void *a, const void *b);
void qsort(void *base, size_t n, size_t size, cmp_fn cmp);

int start(void *ctx);
pthread_t t;
pthread_create(&t, NULL, start, ctx);  /* start must match the ABI */

const correctness

Casting away const and then writing is UB if the object was defined const (string literals, const globals). It is a safety hole even when the language does not catch it. APIs that only read should take const T * so callers can pass const data and so the compiler can help.

restrict

C99 restrict on a pointer means: for the lifetime of that pointer, every access to the object it points to will go through a pointer based on it (or through a pointer to a const-qualified-compatible type in some cases — the standard wording is fussy). memcpy is restrict; memmove is not. If you pass overlapping buffers to a restrict function, that is UB and the vectoriser may produce a wrong result. Interview translation: "I promise these buffers do not alias."

Pointer to pointer

You need T ** when a function must change the caller's pointer (allocate and hand back, or walk a list by rewriting head), or when you have an array of pointers (argv, JNI jobjectArray internals, a table of strings). void ** is not a generic "pointer to any pointer" in a type-safe way; it is a pointer to void *.

int alloc_buf(uint8_t **out, size_t n)
{
    uint8_t *p = malloc(n);
    if (!p) return -1;
    *out = p;             /* rewrite caller's pointer */
    return 0;
}

Strings and buffers

A C string is a contiguous sequence of char ending in a '\0'. There is no stored length. A buffer is storage that may or may not contain a string. Interviews hammer the gap between length (how many payload bytes you mean), capacity (how many bytes the allocation can hold, including the NUL if it is a string), and size of the pointer (useless).

snprintf is the default formatting tool

char buf[32];
int n = snprintf(buf, sizeof buf, "%s:%d", name, port);
if (n < 0) { /* encoding / output error */ }
if ((size_t)n >= sizeof buf) { /* truncated; buf still terminated */ }

The return value is the number of characters that would have been written, excluding the NUL — or a negative error. That is how you detect truncation and how you size a second buffer. sprintf has no bound. strncpy is not "safe strcpy".

Common bugs

• Forgetting the NUL when you build a string with memcpy.
• Using sizeof(ptr) as a buffer size.
• Off-by-one: looping i <= n on a buffer of n bytes.
• Assuming char is unsigned when scanning bytes.
• Modifying a string literal (char *s = "hi"; s[0] = 'H';) — UB; use char s[] = "hi";.
• gets — removed; if you see it, reject the code.

Structs, unions, bitfields, flexible arrays, packed layouts

These types are how C describes memory that more than one field shares or occupies. HAL ioctls, Binder parcels (at a lower level), file headers and register maps are all "a struct plus rules about padding".

Structs and padding

Members are laid out in order. The compiler may add padding between members and at the end. Reordering members can shrink the struct. There is no portable "insert a field in the middle and keep the old ABI" without a versioning plan. Do not memcmp two structs for equality if they have padding — padding bytes can be garbage.

struct item {
    uint8_t  id;      /* offset 0 */
    /* 3 bytes padding on a 4-byte-align ABI */
    uint32_t flags;   /* offset 4 */
    uint16_t len;     /* offset 8 */
    /* 2 bytes tail padding so sizeof is 12 */
};

Unions

Size is the size of the largest member, plus any trailing padding the ABI wants. Reading a member other than the one last written is implementation-defined in C (type punning via union is a common dialect and is what GCC/Clang document); the strictly portable pun is memcpy into an object of the other type. Do not use unions to "extend lifetime" of pointers.

Bitfields

Syntax: unsigned flags : 3;. Allocation unit, order within the unit, and whether they can straddle storage units are implementation-defined. They are fine for in-memory flags on one compiler/ABI. They are a bad choice for a wire format or a shared-memory protocol unless both sides were built with the same toolchain and you have tests. Atomic bitfields are not a thing you should invent; use atomic_uint and masks.

Flexible array members (C99)

The last member may be T data[]; — not a pointer, not a fixed array. sizeof(struct) does not include the flexible part. You allocate offsetof(struct s, data) + n * sizeof(T) (or equivalent). Access s->data[i] for i < n. The old data[1] and GNU data[0] hacks exist in kernels; say so, then prefer FAM in new userspace C.

struct pkt {
    uint32_t len;
    uint8_t  data[];
};

struct pkt *p = malloc(offsetof(struct pkt, data) + n);
if (!p) return NULL;
p->len = (uint32_t)n;

Packed structs

__attribute__((packed)) (or a pragma) removes padding. On ARM, an unaligned uint32_t load can be slow or, on some older/strict configs, fault. The compiler will emit bytewise accesses if it knows the pointer is unaligned, but a cast of a packed member's address to uint32_t * can re-introduce a badly aligned load. Prefer explicit serialisation: read bytes, shift, or memcpy into an aligned local.

Preprocessor

The preprocessor is a token-based text engine that runs before the compiler proper. It is not scoped, not typed, and not debuggable in the way functions are. Use it for include guards, feature tests and a few typed wrappers; do not build a second language out of macros.

Include guards

#ifndef FOO_H
#define FOO_H
/* declarations */
#endif

The name must be unique. #pragma once is widely supported and fine in practice; in an interview, still know guards, because they are standard and they are what you will see in kernel and AOSP headers. Guards are per translation unit, not per process.

Macros vs inline

#define MAX(a, b) ((a) > (b) ? (a) : (b))   /* double-evaluates */
#define STR(x) #x
#define JOIN(a, b) a##b
int JOIN(foo, Bar) = 1;     /* fooBar */
const char *s = STR(fooBar); /* "fooBar" */

Include paths and quotes

#include "foo.h" searches the including file's directory first, then the include path. #include <foo.h> searches the system / -I path. Order of -I flags matters: the first hit wins. A wrong order is how you compile against a stale generated AIDL header or the wrong bionic header.

Conditional compilation

#if, #ifdef, #ifndef, #elif, #else, #endif. Use #if defined(FOO) && FOO when the value matters. Nested #ifdef forests are how Android HALs grow untestable variants. Prefer putting differences behind small functions and a single config header. Never close a brace in only one arm of an #ifdef — the translation unit becomes different C.

Linkage: static, extern, tentative definitions, inline

Linkage answers "when I write the name foo in two places, is it the same object or function?". Storage duration answers "how long does it live?". They are different axes. Interviews mix them on purpose.

Tentative definitions

At file scope, int g; without extern and without an initialiser is a tentative definition. If the translation unit never sees a real definition, the compiler emits a zeroed g. Historically many units could each have int g; and the linker merged them as "common" symbols. Modern toolchains default to -fno-common: two tentative definitions in two units are a multiple-definition error. Write extern in headers and one definition in one .c.

C99 inline

This is not C++ inline. In C99:

• An inline definition in a header may be used for inlining.
• If the function is also used as an out-of-line function (its address is taken, or the compiler chooses not to inline), there must be exactly one external definition.
• The usual pattern: inline int foo(int x) { … } in the header, and extern inline int foo(int x); or a copy in exactly one .c (toolchain-specific preferred form; GCC's extern inline history is messy). Many codebases just use static inline in headers and accept a copy per unit if the compiler does not inline.

C++ inline (see C++) is a different ODR rule. Do not mix the stories.

One-definition issues

C does not use the C++ term ODR, but the linker still wants one definition for each external symbol (plus weak / common exceptions). Two non-static functions with the same name in two .c files fail at link. Two static functions with the same name are fine: they are different functions. A non-inline function defined in a header is the usual way to get the first failure.

Undefined, unspecified and implementation-defined behaviour

This is the section that separates people who have been burned from people who have only read a blog. The compiler is a theorem prover that assumes your program is free of undefined behaviour. If you lie, it may delete your if, reorder stores, or format your disk — more realistically: miscompile a bounds check that only fails on the device at -O2.

Sequence points (older teaching) vs sequenced-before (C11/C17)

C17 describes an expression as a partial order: A is sequenced before B, or they are unsequenced, or they are indeterminately sequenced. A sequence point (the C89/C99 classroom word) is a place where all prior side effects are complete and no subsequent ones have started — the semicolon, the comma operator, && / || / ?:, function call (after arguments, before the body), and a few others.

If a scalar object is modified twice, or modified and read for a different reason, with those accesses unsequenced relative to each other, the behaviour is undefined. That is why i = i++, a[i] = i++, and printf("%d %d", i++, i++) are rejected in interviews. C17 did not make them defined; it just changed the vocabulary.

i = i++;            /* UB */
a[i++] = i;         /* UB */
i = i + 1;          /* fine */
i += 1;             /* fine */
j = i++;            /* fine: one modify, the extra read is the value computation of i++ */

volatile — what it is and is not

volatile tells the compiler: every read or write in the abstract machine must appear as a real access to that lvalue, and volatile accesses are not reordered with each other. Use it for memory-mapped registers, for sig_atomic_t flags set by a signal handler, and for values a debugger might poke.

It is not atomicity (a 64-bit store may tear). It is not a compiler barrier for surrounding non-volatile accesses in the way people hope. It is not a CPU memory barrier. It does not make a data race defined. For threads, use C11 atomics or a mutex. For device registers in a driver, the kernel uses readl/writel and READ_ONCE/WRITE_ONCE — see kernel & BSP.

restrict and data races

restrict is a promise about aliasing in a single thread of execution of that function. A data race is two threads accessing the same memory, at least one a write, without synchronisation. C11 says a data race is undefined behaviour — even a "plain byte store that looks atomic on this CPU". "I only write a flag" is not a defence unless that flag is atomic or protected by a happens-before edge (unlock/lock, release/acquire, etc.).

I/O, FILE*, file descriptors and errno

Userspace C has two I/O layers that interviews expect you to keep straight. The kernel's objects are file descriptors (small integers in the process fd table). The C library's portable API is FILE* streams that buffer on top of an fd. Android adds fdsan and a slightly different buffering story in bionic.

errno

On failure, many POSIX functions return -1 (or NULL) and set errno to a positive E* constant. Success does not set errno to 0. You must look at errno only when the function said it failed, unless the man page says otherwise. errno is thread-local in modern libc (a macro that expands to a function). strerror is not reliably thread-safe; prefer strerror_r where it exists. Some functions return the error code directly (pthread, many C11/C23 APIs) and leave errno alone.

int fd = open(path, O_RDONLY);
if (fd < 0) {
    /* errno is valid here */
    return -errno;
}
FILE *fp = fdopen(fd, "r");
if (!fp) { close(fd); return -errno; }
/* fclose will close fd; do not close it again */

Make, gdb, sanitizers and valgrind

Platform interviews expect you to build and debug C without an IDE doing it for you. You do not need to be a Make guru; you need the mental model and the sanitizer names.

Make at interview level

CC ?= clang
CFLAGS ?= -Wall -Wextra -O2
objs := main.o util.o

prog: $(objs)
	$(CC) $(CFLAGS) -o $@ $(objs)

%.o: %.c util.h
	$(CC) $(CFLAGS) -c -o $@ $<

.PHONY: clean
clean:
	rm -f $(objs) prog

A rule is target: dependencies plus a recipe. Make compares timestamps. .PHONY means "this name is not a file". Variables: $@ target, $< first prerequisite, $^ all prerequisites. Android.bp / Soong is what AOSP actually uses; saying "Make is the model, Soong is the Android generator" is enough. Do not claim you ship product with a 20-line Makefile unless you do.

gdb (and lldb)

• break foo, break file.c:42, run, continue, next, step, finish.
• bt / backtrace — the first thing after a crash.
• print expr, x/16xb ptr (examine bytes), info locals, info registers.
• watch *ptr — stop when that location changes (hardware watchpoint if available).
• Need -g (and preferably not a fully stripped binary). Optimised code will not match source line-for-line; that is expected.

Android: lldb from the NDK, or gdbserver / lldb-server on device. Tombstones already have a backtrace; use that before attaching.

Sanitizers vs Valgrind

Concurrency in C: atomics and pthreads

C did not have a thread memory model until C11. Before that, pthreads was a library contract on top of a language that pretended threads did not exist. You should still treat any unsynchronised shared write as UB. This section is the practical subset; it is not a full memory-model course.

pthreads (POSIX, including Android)

• pthread_create / pthread_join / pthread_detach.
• pthread_mutex_t — default is normal mutex; recursive is opt-in. Do not unlock from another thread.
• pthread_cond_t — always wait in a loop on the predicate; the mutex must be held. Spurious wakeups happen.
• pthread_rwlock_t, pthread_once, thread-specific data / TLS (_Thread_local in C11).
• Mutex unlock synchronises-with the next lock of the same mutex: a full happens-before for data you touched while holding it.

C11 atomics at a practical level

#include <stdatomic.h>

atomic_int ready = 0;
atomic_store_explicit(&ready, 1, memory_order_release);
int r = atomic_load_explicit(&ready, memory_order_acquire);

volatile is not on this table. A mutex is still the default for anything with more than one word of invariant. Atomics shine for flags, reference counts and simple queues you can actually prove.

C on Android: NDK, JNI, bionic, HALs

Android native code is still C's world: the NDK toolchain, bionic, JNI bridges, and HAL processes. The Java object model, GC and JNI from Java belong on the Java page. Kernel-side C belongs on Linux kernel & BSP. Framework services that call into native are on Android frameworks. This section is the C side of those boundaries.

NDK

The NDK is Clang, a sysroot of bionic headers and libs, and build files (Android.mk legacy, CMake, or Soong cc_library). You produce .so files loaded by System.loadLibrary or packaged in the vendor / system image. ABI: arm64-v8a is the default interview answer for phones; 32-bit is dying. Compile with -fPIC, hidden visibility by default in modern NDK, and do not ship debug symbols in the unsigned path without a plan.

JNI from the C side

Every JNI call goes through a JNIEnv * (a table of function pointers). It is per-thread. A native thread must AttachCurrentThread before using JNI and DetachCurrentThread before exit. Caching JNIEnv in a global is a bug.

• FindClass from a native thread uses the system class loader, not the app loader. You will not find app classes unless you cached a jclass (global ref) from a method that ran with the right loader, or you use a cached ClassLoader object.
• Local refs are freed when the native method returns, or when you DeleteLocalRef / PopLocalFrame. Tight loops that NewObject without deleting will overflow the local ref table (default a few hundred).
• Global refs (NewGlobalRef) survive; you must DeleteGlobalRef. Weak global refs do not keep the object alive.
• Strings: Java is UTF-16. GetStringUTFChars gives modified UTF-8, not always standard UTF-8 (surrogates / U+0000). For binary data use jbyteArray, not strings. ReleaseStringUTFChars must be paired. Check for NULL: the VM may throw OutOfMemoryError.
• After any JNI call that can throw, check ExceptionCheck before continuing; otherwise the next JNI call is undefined from the VM's point of view.

Java-side native methods, RegisterNatives from Java, and GC interaction are covered on Java.

bionic vs glibc

fdsan (file descriptor sanitizer) is always-on in modern Android. Closing an fd that libc thinks another owner still holds aborts. The fix is ownership: do not close an fd you passed to fdopen without knowing who closes it; do not close fds the framework still owns.

HAL C APIs

Legacy HALs export HAL_MODULE_INFO_SYM, a hw_module_t with open() that returns an hw_device_t whose first fields are a vtable. Calls look like device->ops->foo(device, …). Newer HALs are AIDL interfaces in a vendor process; the C/C++ NDK stubs still feel like "struct of function pointers" plus Binder. Do not invent a new ioctl ABI if AIDL exists. See Binder & AIDL and frameworks.

Interview coding patterns in C

This is not the DSA page. They will not ask you to invent Dijkstra in C. They will ask you to write the functions that make Dijkstra possible without invoking UB: strings, bytes, bits, ownership, and small structs. Write boring, correct C. Comment who owns each pointer.

What they actually ask

• Implement strlen, strcpy, strcmp, memcpy, memset, memmove.
• Reverse a string in place; reverse words; is-palindrome on bytes.
• Bit tricks: count bits, isolate lowest set bit (x & -x), swap without a temp (they still ask; mention XOR and also "just use a temp"), endian swap, test power-of-two (x && !(x & (x-1))).
• Manual atoi with overflow detection using unsigned or wider types.
• In-place remove of a character; compress runs; circular buffer of bytes.
• Intrusive linked list (the kernel style: next/prev in the struct) — language, not graph theory.

Ownership comments

/* out: malloc'd, caller frees. Returns 0 or -errno. */
int read_all(int fd, uint8_t **out, size_t *len);

/* borrows name; does not free it. Copies into an internal table. */
int registry_add(const char *name);

/* takes ownership of buf; will free() it. buf may be NULL. */
void packet_set_payload(struct packet *p, uint8_t *buf, size_t n);

C has no unique_ptr. The comment is the type system. Interviewers read the comment before they read the loop. If you allocate twice and only free once on the error path, say the cleanup label out loud (goto cleanup is idiomatic C, not a sin).

A correct-enough memcpy

void *my_memcpy(void *restrict dst, const void *restrict src, size_t n)
{
    unsigned char *d = dst;
    const unsigned char *s = src;
    while (n--)
        *d++ = *s++;
    return dst;
}

Say: bytewise is correct; real libc aligns and copies words; overlap is UB because of restrict — use memmove (copy backwards if d is after s inside the same object). For strlen, walk until '\0', return the count, and mention you must not read past a missing terminator if the buffer length is known — then you wanted memchr.

Quick revision

• C remains the language of kernels, bootloaders, libc/bionic, HALs and firmware because the ABI is stable and nothing is implicit.
• Preprocess → compile → assemble → link; the compiler sees one translation unit at a time.
• Headers declare; exactly one .c defines each external object or function (unless static or a careful inline).
• Static .a copies used object files into the image; shared .so is loaded at runtime and needs PIC.
• Integer promotions lift narrow types to int (or unsigned int) before most arithmetic.
• Usual arithmetic conversions pick a common type; signed vs unsigned of the same rank becomes unsigned.
• Signed overflow is UB; unsigned wrap is defined modulo 2ⁿ.
• size_t is unsigned; never write if (len < 0) on a size_t.
• intptr_t / uintptr_t hold a pointer as an integer; they are not a free pass for provenance games.
• Plain char signedness is implementation-defined; use unsigned char for bytes.
• Text = code; rodata = literals; data = initialised globals; bss = zero globals; stack = frames; heap = malloc.
• realloc failure leaves the old pointer valid; do not overwrite it with NULL.
• Alignment drives struct padding; sizeof includes tail padding.
• Endian is a property of how integers are stored; the wire format is not automatically the host format.
• Arrays decay to pointers except for sizeof, &arr and a few other cases; function parameters are already pointers.
• Pointer arithmetic is in elements, only within the same array (or one-past-end, not dereferenced).
• void * is a generic object pointer; do not dereference it; function pointers are a separate story.
• const T * vs T * const: pointee vs pointer.
• restrict means "these buffers do not alias"; overlapping memcpy is UB.
• A C string is bytes plus a NUL; capacity must include that NUL if you store a string.
• snprintf bounds the write, NUL-terminates if size > 0, and returns the untruncated length.
• strncpy is not safe strcpy: it may omit the NUL and it zero-pads.
• memcpy is restrict and forbids overlap; memmove allows overlap.
• Do not memcmp structs for equality when they contain padding.
• Union type punning is a documented compiler dialect; portable punning is memcpy.
• Bitfield allocation order and straddling are implementation-defined; do not use them as a wire format.
• A flexible array member is T data[] at the end; sizeof excludes it; allocate offsetof + n * sizeof(T).
• Packed structs drop padding and can cause unaligned accesses on ARM; serialise with bytes or memcpy.
• Include guards (or #pragma once) are per translation unit; they do not give you one definition across the program.
• Prefer static inline over function-like macros: types, single evaluation, debuggable.
• # stringizes, ## pastes tokens; both happen in the preprocessor, not the type system.
• #include "…" searches the includer's directory first; <…> uses the include path; first -I hit wins.
• static at file scope = internal linkage; on a local = static duration; the word is not one concept.
• Tentative definition: file-scope int g; with no initialiser. Modern -fno-common forbids one per unit.
• C99 inline is not C++ inline; you still need one external definition if the function is used out of line.
• Undefined = no requirements; unspecified = one of several; implementation-defined = documented choice.
• Unsequenced modify + modify (or modify + extra read) of the same scalar is UB: i = i++.
• volatile forces accesses to that lvalue; it is not atomic, not a mutex, not a CPU barrier.
• A data race is UB in C11 even if the store "looks atomic" on the CPU.
• File descriptors are kernel ints; FILE* is a buffered libc stream; fileno / fdopen bridge them.
• Read errno only after a documented failure; it is thread-local; save it before you log.
• Make rebuilds a target when a dependency is newer; .PHONY is a name that is not a file.
• After a crash: backtrace first. gdb/lldb need -g; optimised code will not match source perfectly.
• ASan = spatial/temporal memory; UBSan = language UB; LSan = leaks; TSan = races; Valgrind = interpreter, slow, host-friendly.
• Mutex unlock happens-before the next lock; condvar waits must loop on the predicate.
• Publish with payload stores then a release store; consume with an acquire load then payload loads.
• memory_order_relaxed is for independent counters, not for publishing a pointer to new data.
• Android native = NDK/Clang + bionic, not glibc. Kernel C is a different world (no libc).
• JNIEnv is per-thread; attach native threads; never cache another thread's env.
• FindClass on a native thread uses the system class loader — cache jclass from the right context.
• Local JNI refs die when the native method returns; delete in tight loops; global refs must be deleted.
• JNI "UTF" is modified UTF-8; Java strings are UTF-16; binary data belongs in byte arrays.
• fdsan aborts on close of an fd the runtime thinks someone else owns.
• HALs are C vtables historically and AIDL/Binder now; do not invent a new ioctl protocol if AIDL exists.
• C has no unique_ptr: ownership is a comment plus one free on every path, often via goto cleanup.
• Whiteboard C is strlen/memcpy/bits/buffers, not graph algorithms (those live on the DSA page).
• Check overflow before malloc(count * size); a wrapped size is a security bug.
• Writing a string literal is UB; use an array if you need to mutate.
• One-past-the-end pointers may be computed, not dereferenced.
• LTO and -O2 make latent UB visible; "it works in debug" is not a proof of definedness.

Glossary

ABI

Application Binary Interface: sizes, alignments, calling convention and symbol names that compiled objects must agree on.

Alignment

Requirement that an object's address is a multiple of N (often the type's size). Misalignment can be slow or fault.

ASan

AddressSanitizer: compiler instrumentation plus shadow memory that catches out-of-bounds and use-after-free.

bionic

Android's C library and dynamic linker, smaller than glibc and with extras such as fdsan.

Bitfield

A struct member occupying a specified number of bits; layout is implementation-defined.

BSS

Segment for zero-initialised (or uninitialised) static-duration objects; the file stores a size, not the zeros.

calloc

Heap allocation that zeros memory; the element-count times size product can overflow.

const

Type qualifier meaning the object will not be modified through this lvalue. Casting it away and writing can be UB.

Data race

Two threads touch the same memory, at least one writes, with no happens-before. UB in C11.

Declaration

Introduces a name and type without necessarily reserving storage or providing a body.

Definition

The unique place that reserves storage or provides a function body (plus C's tentative-definition rules).

Effective type

The type C uses for aliasing rules: how an object may be read. Strict aliasing is the informal name.

Endianness

Byte order of a multi-byte integer in memory or on the wire. Host and protocol may differ.

errno

Thread-local error code set by many failing libc/POSIX calls. Inspect it only after a documented failure.

extern

Specifies external linkage, or (with an initialiser) a definition. In headers, usually a declaration only.

FAM

Flexible array member: last struct member T data[], sized by the allocation, not by sizeof.

fdsan

Android file-descriptor sanitizer: tags fds and aborts on use-after-close or mismatched owner.

FILE

Opaque libc stream with buffering, sitting on top of a file descriptor.

Function pointer

Pointer to a function; type includes return and parameter types. Not an object pointer.

GOT / PLT

Global Offset Table and Procedure Linkage Table: indirection used by position-independent code to reach data and functions.

HAL

Hardware Abstraction Layer: vendor code behind a stable interface (legacy C vtable or AIDL).

Implementation-defined

The implementation must choose and document a behaviour (for example plain char signedness).

Include guard

#ifndef / #define / #endif wrapper so a header's body is pasted at most once per translation unit.

Integer promotion

Conversion of narrow integer types to int or unsigned int before most arithmetic.

intptr_t

Signed integer type guaranteed to hold a pointer. Pair is uintptr_t.

JNI

Java Native Interface: the C API that talks to the VM. Java-side details belong on the Java page.

JNIEnv

Per-thread table of JNI function pointers. Must not be shared across threads.

Linkage

Whether two declarations of the same name denote the same object or function (external, internal, or none).

LSan

LeakSanitizer: reports heap that is not freed at process exit (often bundled with ASan).

lvalue

An expression that designates an object (something that can appear on the left of assignment, roughly).

malloc

Uninitialised heap allocation aligned for any standard type. Pair with free.

memcpy

Copy n bytes between non-overlapping (restrict) buffers. Overlap is UB.

memmove

Copy n bytes; overlap is allowed.

memory_order

C11 atomic constraint: relaxed, acquire, release, acq_rel, seq_cst — how much reordering is forbidden.

NDK

Native Development Kit: Clang, bionic sysroot and build support for Android native code.

Object file

Compiler output (.o) containing machine code, data and relocation records, not yet linked.

Padding

Unused bytes inserted so members and the whole struct meet alignment. Contents are not meaningful.

PIC / PIE

Position-independent code / executable: can run at any load address, used for shared libraries and hardened binaries.

Pointer provenance

The idea that a pointer is not only an address: it is tied to the object it was derived from. Casting through integers can lose that.

pthread

POSIX threads API: create, join, mutex, condvar. The everyday threading API on Android userspace.

realloc

Resize a heap block; may move it. On failure the original pointer remains valid.

Relocation

A linker (or loader) patch that fills in an address that was unknown at compile time.

restrict

Promise that a pointer is the only way the function will access that object, enabling non-aliasing optimisations.

Sequence point

Older term for a place where previous side effects are complete. C11+ uses sequenced-before.

Sequenced-before

C11/C17 partial order on evaluations. Unsequenced conflicting accesses to a scalar are UB.

Shared library

Dynamically loaded image (.so) with its own text/data, resolved by the dynamic linker.

size_t

Unsigned type of object sizes; result of sizeof and the usual malloc/strlen type.

snprintf

Bounded formatted write that NUL-terminates when the size is not zero; return is the untruncated length.

static

Keyword meaning internal linkage (file scope) or static storage duration (block scope), depending on where it appears.

Static library

Archive (.a) of object files. The linker copies only the members it needs.

Storage duration

How long an object lives: automatic (stack), static (process), or allocated (heap until free).

Strict aliasing

Informal name for effective-type rules: accessing an object as the wrong type is UB (with exceptions such as char *).

Tentative definition

File-scope declaration that may become a zeroed definition if no real definition appears in the unit.

Text segment

The executable code portion of the image, usually mapped read-only and shareable.

Translation unit

A source file after preprocessing: what the compiler actually compiles.

Trap representation

A bit pattern that is not a valid value of the type. Reading it can be UB (more relevant historically for some integers).

TSan

ThreadSanitizer: detects data races in instrumented builds.

UBSan

UndefinedBehaviorSanitizer: runtime checks for many kinds of language UB.

Undefined behaviour

The standard imposes no requirements. Compilers may assume it never happens and optimise accordingly.

Unspecified behaviour

The standard gives a set of allowed outcomes and does not require the choice to be documented.

Usual arithmetic conversions

Rules that convert both operands of a binary operator to a common type after promotions.

Valgrind

Dynamic analysis suite; memcheck interprets the binary and finds many memory errors without a special compile.

void*

Generic object pointer. Convertible to other object pointers in C; not dereferenceable; not a portable function-pointer box.

volatile

Qualifier requiring that accesses to that lvalue are not elided. Not a concurrency tool.

Weak symbol

A symbol the linker may override with a strong definition, used for interposable defaults.

Interview questions

size_t my_strlen(const char *s)
{
    const char *p = s;
    while (*p) p++;
    return (size_t)(p - s);
}

void *my_memcpy(void *restrict d, const void *restrict s, size_t n)
{
    unsigned char *cd = d;
    const unsigned char *cs = s;
    while (n--) *cd++ = *cs++;
    return d;
}