synta 0.1.8

# Quick Start


This page shows the minimal code to decode and encode ASN.1 data using the
Synta C API, plus how to compile and run the examples.

## Decode an INTEGER

```c
#include <synta.h>
#include <stdio.h>

int main(void) {
    const uint8_t data[] = {0x02, 0x01, 0x2A}; /* INTEGER 42 */
    SyntaDecoder *dec = synta_decoder_new(data, sizeof(data), SyntaEncoding_Der);
    if (!dec) {
        fprintf(stderr, "Error: %s\n", synta_get_last_error_message());
        return 1;
    }

    SyntaInteger *integer = NULL;
    if (synta_decode_integer(dec, &integer) == SyntaErrorCode_Success) {
        int64_t value;
        synta_integer_to_i64(integer, &value);
        printf("Value: %lld\n", (long long)value);
        synta_integer_free(integer);
    } else {
        fprintf(stderr, "Error: %s\n", synta_get_last_error_message());
    }

    synta_decoder_free(dec);
    return 0;
}
```

## Encode a SEQUENCE

```c
#include <synta.h>

int main(void) {
    SyntaEncoder *enc = synta_encoder_new(SyntaEncoding_Der);

    SyntaEncoder *seq = NULL;
    synta_encoder_start_sequence(enc, &seq);
    synta_encode_integer_i64(seq, 42);
    synta_encode_boolean(seq, true);
    synta_encoder_end_constructed(seq);

    SyntaByteArray output = {0};
    synta_encoder_finish(enc, &output);
    /* enc is consumed by synta_encoder_finish; do not free enc */

    /* use output.data[0..output.len-1] */

    synta_byte_array_free(&output);
    return 0;
}
```

## Parse an X.509 Certificate

```c
#include <synta.h>
#include <stdio.h>

void print_cert_info(const uint8_t *der, uintptr_t der_len) {
    SyntaCertificate *cert = synta_certificate_parse_der(der, der_len);
    if (!cert) {
        fprintf(stderr, "Parse failed: %s\n", synta_get_last_error_message());
        return;
    }

    /* Subject DN: zero-copy borrowed slice into the original DER buffer */
    SyntaByteArray subject = {0};
    synta_certificate_get_subject_der(cert, &subject);
    /* subject.owned == 0: bytes are borrowed from cert; do not free */
    printf("Subject DER: %u bytes\n", subject.len);

    /* Signature algorithm OID as a dotted-decimal string (size-query pattern) */
    uintptr_t needed = synta_certificate_get_signature_algorithm(cert, NULL, 0);
    char sig_alg[64];
    if (needed <= sizeof(sig_alg)) {
        synta_certificate_get_signature_algorithm(cert, sig_alg, sizeof(sig_alg));
        printf("Sig alg: %s\n", sig_alg);
    }

    synta_certificate_free(cert);
}
```

## Compile and Run

### With pkg-config

```bash
gcc example.c $(pkg-config --cflags --libs csynta) -o example
./example
```

### Without pkg-config

```bash
gcc example.c -I/path/to/synta/include \
              -L/path/to/synta/lib -lcsynta -lpthread -ldl -lm \
              -o example
./example
```

The generated code requires a C99-capable compiler (`-std=c99` or later).

## Configure DoS Protection

By default, `synta_decoder_new` uses built-in limits.  To set custom limits:

```c
#include <synta.h>

SyntaDecoder *make_decoder(const uint8_t *data, uintptr_t len) {
    SyntaDecoderConfig cfg = {
        .max_depth             = 32,
        .max_sequence_elements = 10000,
        .max_length            = 16 * 1024 * 1024,  /* 16 MB */
    };
    return synta_decoder_new_with_config(data, len, SyntaEncoding_Der, &cfg);
}
```

## Next Steps

- [Installation and Linking](installation.md) — build options, pkg-config, CMake
- [API Reference: Decoder](../api/decoder.md) — all decode functions
- [API Reference: Encoder](../api/encoder.md) — all encode functions
- [Memory Management](../memory.md) — ownership rules and common pitfalls
- [Code Generation](../codegen/overview.md) — generate C structs from ASN.1 schemas