1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 * Common GNU extensions to be aware of.
 * 
 * These work on Linux but may not be available on BSD or macOS.
 */
 
/* GNU-specific functions */
#define _GNU_SOURCE
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
 
/* strdup/strndup - now in POSIX.1-2008, but were GNU extensions */
char *copy = strdup("hello");
 
/* asprintf - formatted allocation (not in POSIX) */
char *message;
asprintf(&message, "Value: %d", 42);  /* Non-portable */
 
/* POSIX portable alternative: */
int len = snprintf(NULL, 0, "Value: %d", 42);
message = malloc(len + 1);
snprintf(message, len + 1, "Value: %d", 42);
 
/* memmem - find substring in memory (not in POSIX) */
void *result = memmem(haystack, hlen, needle, nlen);  /* Non-portable */
 
/* getline - read line of arbitrary length (now in POSIX.1-2008) */
char *line = NULL;
size_t len = 0;
ssize_t nread = getline(&line, &len, stdin);
 
/* epoll - Linux-specific event notification */
/* Not in POSIX; use select/poll for portability, or abstraction layer */
 
/* GNU getopt extensions: optional arguments, long options */
/* POSIX getopt() is more limited */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * BSD extensions commonly encountered.
 */
 
/* kqueue - BSD event notification (macOS, FreeBSD, etc.) */
/* Not in POSIX; Linux equivalent is epoll */
#include <sys/event.h>
int kq = kqueue();  /* Non-portable to Linux */
 
/* strlcpy/strlcat - safe string functions */
/* NOT in POSIX or glibc by default */
#include <string.h>
strlcpy(dst, src, sizeof(dst));  /* Non-portable to Linux */
 
/* Linux alternative: use strncpy carefully or snprintf */
snprintf(dst, sizeof(dst), "%s", src);
 
/* setproctitle - change process title */
/* Available on BSD; Linux requires workarounds */
setproctitle("my-daemon: processing");  /* Non-portable */
 
/* arc4random - random number generation */
/* Now in many systems but not POSIX */
uint32_t random_val = arc4random();  /* Varies by platform */
 
/* pledge/unveil - OpenBSD security features */
/* Unique to OpenBSD */
pledge("stdio rpath", NULL);  /* OpenBSD only */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <unistd.h>
#include <limits.h>
 
/**
 * Query system POSIX capabilities.
 */
void query_posix_version(void) {
    /* Standard version supported */
    long posix_version = sysconf(_SC_VERSION);
    printf("POSIX version: ");
    
    switch (posix_version) {
        case 200809L:
            printf("POSIX.1-2008 (IEEE Std 1003.1-2008)
");
            break;
        case 200112L:
            printf("POSIX.1-2001 (IEEE Std 1003.1-2001)
");
            break;
        case 199506L:
            printf("POSIX.1-1996 (with threads)
");
            break;
        case 199009L:
            printf("POSIX.1-1990
");
            break;
        default:
            printf("%ld (interpret per standard)
", posix_version);
    }
    
    /* X/Open version */
    #ifdef _XOPEN_VERSION
    printf("X/Open version: %d
", _XOPEN_VERSION);
    #endif
    
    /* Check specific options */
    printf("
Option support:
");
    
    #if _POSIX_THREADS > 0
        printf("  Threads: compile-time supported
");
    #elif _POSIX_THREADS == 0
        long threads = sysconf(_SC_THREADS);
        printf("  Threads: %s
", threads > 0 ? "runtime supported" : "not supported");
    #else
        printf("  Threads: not supported
");
    #endif
    
    #if _POSIX_REALTIME_SIGNALS > 0
        printf("  Realtime signals: supported
");
    #else
        printf("  Realtime signals: not supported
");
    #endif
    
    #if _POSIX_ASYNCHRONOUS_IO > 0
        printf("  Async I/O: supported
");
    #else
        printf("  Async I/O: not supported
");
    #endif
}
 
void query_limits(void) {
    printf("
System limits:
");
    
    long arg_max = sysconf(_SC_ARG_MAX);
    printf("  ARG_MAX: %ld
", arg_max);
    
    long open_max = sysconf(_SC_OPEN_MAX);
    printf("  OPEN_MAX: %ld
", open_max);
    
    long pagesize = sysconf(_SC_PAGESIZE);
    printf("  PAGE_SIZE: %ld
", pagesize);
    
    long nprocs = sysconf(_SC_NPROCESSORS_ONLN);
    printf("  Processors online: %ld
", nprocs);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Check POSIX version via getconf
getconf POSIX_VERSION
# Output: 200809 (for POSIX.1-2008)
 
# Check various limits
getconf ARG_MAX      # Maximum command line length
getconf OPEN_MAX     # Maximum open files
getconf PATH_MAX /   # Maximum path length for root
 
# List all configuration variables
getconf -a
 
# Check shell POSIX mode
bash --posix -c 'echo POSIX mode active'
 
# Verify utilities conform to POSIX
# Use -p to get POSIX-conformant version from PATH
command -p ls -la    # Uses POSIX PATH, not aliases
 
# Check if specific command is POSIX
type command         # command is a shell builtin
man posix 2>/dev/null && echo "POSIX man pages installed"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Compile with strict POSIX mode
gcc -std=c11 -D_POSIX_C_SOURCE=200809L \
    -Wall -Wextra -pedantic \
    -Werror \
    -o myprogram myprogram.c
 
# The -pedantic flag warns about non-standard code
# -Werror makes warnings into errors
 
# If this compiles, your code uses only standard C and POSIX
 
# For shell scripts, check with shellcheck
shellcheck --shell=sh myscript.sh
 
# Run POSIX test suites if available
# (The Open Group's official suite requires membership)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

/**
 * Guidelines for writing strictly POSIX-compliant code.
 */
 
/* 1. Define only POSIX feature test macro, BEFORE any includes */
#define _POSIX_C_SOURCE 200809L
/* Do NOT define _GNU_SOURCE, _BSD_SOURCE, _DEFAULT_SOURCE, etc. */
 
/* 2. Include only POSIX headers */
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
/* 3. Use only POSIX functions */
 
/* WRONG: GNU extension */
// char *result = get_current_dir_name();
 
/* RIGHT: POSIX function */
char *get_cwd_portable(void) {
    char *buf = malloc(PATH_MAX);
    if (buf && getcwd(buf, PATH_MAX) == NULL) {
        free(buf);
        return NULL;
    }
    return buf;
}
 
/* WRONG: Linux-specific */
// int fd = epoll_create(1);
 
/* RIGHT: Use POSIX select() or poll() */
#include <poll.h>
int wait_for_input(int fd, int timeout_ms) {
    struct pollfd pfd = { .fd = fd, .events = POLLIN };
    return poll(&pfd, 1, timeout_ms);
}
 
/* 4. Avoid implementation-defined behavior when possible */
 
/* WRONG: Behavior varies by platform */
// int result = system("clear");
 
/* RIGHT: Use documented POSIX escape sequences */
void clear_screen(void) {
    /* ANSI escape sequence - widely supported */
    write(STDOUT_FILENO, "\033[2J\033[H", 10);
}
 
/* 5. Handle all error conditions POSIX specifies */
int safe_write(int fd, const void *buf, size_t count) {
    ssize_t written = write(fd, buf, count);
    if (written == -1) {
        switch (errno) {
            case EINTR:  /* Signal interrupted - POSIX defined */
                /* Retry the write */
                return safe_write(fd, buf, count);
            case EAGAIN: /* Would block - POSIX defined */
                /* Handle non-blocking case */
                return 0;
            case ENOSPC: /* No space - POSIX defined */
            case EIO:    /* I/O error - POSIX defined */
            default:
                return -1;
        }
    }
    return written;
}