> nginx-c-modules
nginx C module development guidelines based on the official nginx development guide. This skill should be used when writing, reviewing, or refactoring nginx C modules to ensure correct memory management, request lifecycle handling, and event-driven patterns. Triggers on tasks involving nginx module development, ngx_http_module_t, handler/filter/upstream implementation, pool allocation, or nginx configuration directives.
curl "https://skillshub.wtf/pproenca/dot-skills/nginx-c-modules?format=md"nginx.org C Module Development Best Practices
Comprehensive development guide for nginx C modules, derived from the official nginx development documentation and community expertise. Contains 49 rules across 8 categories, prioritized by impact to guide correct module implementation and prevent common crashes, memory leaks, and undefined behavior.
When to Apply
Reference these guidelines when:
- Writing new nginx C modules (handlers, filters, upstream, load-balancers)
- Implementing configuration directives and merge logic
- Managing memory with nginx pools and shared memory zones
- Handling the HTTP request lifecycle (body reading, subrequests, finalization)
- Working with nginx's event loop, timers, and thread pools
Rule Categories by Priority
| Priority | Category | Impact | Prefix |
|---|---|---|---|
| 1 | Memory Management | CRITICAL | mem- |
| 2 | Request Lifecycle | CRITICAL | req- |
| 3 | Configuration System | HIGH | conf- |
| 4 | Handler Development | HIGH | handler- |
| 5 | Filter Chain | MEDIUM-HIGH | filter- |
| 6 | Upstream & Proxy | MEDIUM | upstream- |
| 7 | Event Loop & Concurrency | MEDIUM | event- |
| 8 | Data Structures & Strings | LOW-MEDIUM | ds- |
Quick Reference
1. Memory Management (CRITICAL)
mem-pool-allocation- Use Pool Allocation Instead of Heap mallocmem-check-allocation- Check Every Allocation Return for NULLmem-pcalloc-structs- Use ngx_pcalloc for Struct Initializationmem-cleanup-handlers- Register Pool Cleanup Handlers for External Resourcesmem-pnalloc-strings- Use ngx_pnalloc for String Data Allocationmem-pfree-limitations- Avoid Relying on ngx_pfree for Pool Allocationsmem-shared-slab- Use Slab Allocator for Shared Memory Zones
2. Request Lifecycle (CRITICAL)
req-finalize-once- Finalize Requests Exactly Oncereq-no-access-after-finalize- Never Access Request After Finalizationreq-body-async- Handle Request Body Reading Asynchronouslyreq-discard-body- Discard Request Body When Not Reading Itreq-subrequest-completion- Use Post-Subrequest Handlers for Completionreq-count-reference- Increment Request Count Before Async Operationsreq-internal-redirect- Return After Internal Redirect
3. Configuration System (HIGH)
conf-unset-init- Initialize Config Fields with UNSET Constantsconf-merge-all-fields- Merge All Config Fields in merge_loc_confconf-context-flags- Use Correct Context Flags for Directivesconf-null-command- Terminate Commands Array with ngx_null_commandconf-custom-handler- Use Custom Handlers for Complex Directive Parsingconf-module-ctx-null- Set Unused Module Context Callbacks to NULLconf-build-config- Write Correct config Build Script for Module Compilation
4. Handler Development (HIGH)
handler-send-header-first- Send Header Before Body Outputhandler-last-buf- Set last_buf Flag on Final Bufferhandler-phase-registration- Register Phase Handlers in postconfigurationhandler-content-handler- Use content_handler for Location-Specific Response Generationhandler-error-page- Return HTTP Status Codes for Error Responseshandler-empty-response- Use header_only for Empty Body Responseshandler-module-ctx- Use Module Context for Per-Request Statehandler-add-variable- Register Custom Variables in preconfiguration
5. Filter Chain (MEDIUM-HIGH)
filter-registration-order- Save and Replace Top Filter in postconfigurationfilter-call-next- Always Call Next Filter in the Chainfilter-check-subrequest- Distinguish Main Request from Subrequest in Filtersfilter-buffer-chain-iteration- Iterate Buffer Chains Using cl->next Patternfilter-buffering-flag- Set Buffering Flag When Accumulating Response Data
6. Upstream & Proxy (MEDIUM)
upstream-create-request- Build Complete Request Buffer in create_requestupstream-process-header- Parse Upstream Response Incrementally in process_headerupstream-peer-free- Track Failures in Peer free Callbackupstream-finalize- Clean Up Resources in finalize_request Callbackupstream-connection-reuse- Enable Keepalive for Upstream Connections
7. Event Loop & Concurrency (MEDIUM)
event-no-blocking- Never Use Blocking Calls in Event Handlersevent-timer-management- Delete Timers Before Freeing Associated Dataevent-handle-read-write- Call ngx_handle_read/write_event After I/O Operationsevent-thread-pool- Offload Blocking Operations to Thread Poolevent-posted-events- Use Posted Events for Deferred Processing
8. Data Structures & Strings (LOW-MEDIUM)
ds-ngx-str-not-null-terminated- Never Assume ngx_str_t Is Null-Terminatedds-ngx-str-set-literals- Use ngx_string Macro Only with String Literalsds-cpymem-pattern- Use ngx_cpymem for Sequential Buffer Writesds-list-iteration- Iterate ngx_list_t Using Part-Based Patternds-hash-readonly- Build Hash Tables During Configuration Only
How to Use
Read individual reference files for detailed explanations and code examples:
- Section definitions - Category structure and impact levels
- Rule template - Template for adding new rules
Reference Files
| File | Description |
|---|---|
| references/_sections.md | Category definitions and ordering |
| assets/templates/_template.md | Template for new rules |
| metadata.json | Version and reference information |
> related_skills --same-repo
> rust-write-tests
Skill for writing expert-level Rust tests. Teaches the "What Could Break?" framework, five transformations from superficial to expert tests, flake hunting protocol, intent-based assertions, naming conventions, and a mandatory self-review checklist. Triggers on writing Rust tests, designing test cases, improving test quality, or reviewing test coverage.
> rust-implement
Write production-grade Rust code using a multi-pass approach. Design types first, then implement, then simplify, then verify with automated lint. Use this skill whenever writing new Rust functions, structs, modules, or features. Triggers on Rust implementation, new Rust code, Rust functions, Rust modules, error handling in Rust, async Rust, or type design in Rust.
> valid-skill
A valid test skill with proper formatting. This skill should pass all validations and serves as a reference for the expected format.
> too-long-skill
This skill has more than 500 lines which should fail validation.