Bilingual

6 years and 360 patches to clean all instances of strnpy out of the Linux kernel
25 days ago
- The C string library, while fast, can cause buffer overrun errors if used incorrectly, posing security risks.
- strcpy() is problematic when source strings are larger than the destination buffer or not NULL-terminated, potentially allowing hackers to overwrite memory.
- strncpy() was introduced to limit copying but often leaves strings non-NULL terminated, leading to errors and unnecessary padding.
- Linux spent six years and over 360 patches to remove strncpy, replacing it with functions like strscpy() that guarantee NULL termination and clearer semantics.
- New functions such as strscpy_pad() and strtomem_pad() separate string copying from padding, improving security and efficiency.
- Despite its flaws, the C string library has been widely used since 1972, and these updates aim to fix shortcomings while maintaining efficiency.
C Strings: A 50-Year Mistake – By Trần Thành Long
6 days ago
- Null-terminated strings in C are outdated and prone to errors; length-based strings are superior.
- Length-based strings store both pointer and size, enabling efficient operations like substrings without extra allocations.
- C strings' ambiguity in length definitions (e.g., snprintf) leads to bugs and confusion in handling null terminators.
- Length-based strings support arbitrary binary data, including null bytes, unlike C strings which rely on sentinels.
- C strings force unnecessary allocations for common operations, while length-based strings allow efficient slicing and referencing.
- Modern hardware and compilers reduce performance benefits of sentinel-based strings; length-based designs are more robust and clear.
A bunch of stuff I used to not know about K&R C
5 days ago
- C's grammar is context-sensitive due to single-pass compiler design and lack of function prototype scope in K&R C.
- The 'void' keyword and type qualifiers like 'const' were ANSI inventions; pre-ANSI C used 'int' for returns and had mutable string literals.
- Pre-ANSI C lacked 'signed' specifier, limited type combinations (e.g., no 'unsigned char'), and used 'long float' as synonym for 'double'.
- Integer promotion rules diverged: 'unsigned preserving' vs. 'value preserving' (standardized), with no 'U' suffix and unsigned constants having 'int' type if fitting.
- Octal constants allowed digits 8 and 9; missing escape sequences like '\a', and '\"' was effectively valid via backslash dropping.
- Preprocessor lacked '##', '#', '#elif', 'defined' operator, and predefined macros; line continuations restricted to certain contexts.
- Function declarators lacked typed parameter lists, preventing variadic function declarations; parameters with function types disallowed.
- Structs/unions were limited: no assignments, function parameters/returns, or compound initializers for 'auto' structs/unions.
- Compound assignment operators lexed as two tokens (e.g., '+ ='); original '=+' was single token but obsolete.
- Control reaching 'main' end was implied successful pre-standard, made UB in C89, and special-cased in C99 with implicit return 0.
C Craft
2 days ago
- Size 0 arrays in GNU C serve as flexible arrays, with C99 supporting similar but disallowing explicit zero size declarations.
- Size 1 arrays can mimic flexible arrays where size 0 is disallowed or enable uniform stack/heap interface with pointer-like syntax.
- Using 'do...while(0)' in macros ensures safe inclusion in conditionals; GNU C's expression statements offer alternatives.
- C's boolean logic, returning 0 or 1, enables Iverson brackets for concise conditions, contrasting with C99's boolean type.
- Tagged pointers leverage alignment bits for metadata storage, requiring masking during dereferencing but can be over-optimized.
- GNU C's nested functions provide closures, simplifying APIs like factorization callbacks, though trampolining may be restricted.
- Goto statements are useful in specific cases like implementing efficient virtual machines (computed goto), inner loops, and coroutines.
- Information hiding via file scope (opaque structs) separates interface from implementation; exposing structs can optimize performance.
- Memory-mapped files allow direct file access via arrays, leveraging kernel paging for efficiency, with 'die' functions for error handling.
- Little languages (e.g., expression interpreters) and metaprogramming (code generators) extend C's capabilities for domain-specific problems.

Hasty Briefsbeta

#c programming

6 years and 360 patches to clean all instances of strnpy out of the Linux kernel

C Strings: A 50-Year Mistake – By Trần Thành Long

A bunch of stuff I used to not know about K&R C

C Craft