Encoding, crypto & compression

import stdlib::base64::*;
import stdlib::hex::*;
import stdlib::bytes::*;
import stdlib::crypto::*;
import stdlib::compress::*;
import stdlib::tar::*;

import stdlib::base64::*;

fn main() -> i32 {
    let enc: string = b64_encode("Hello");   // "SGVsbG8="
    println!(enc);
    println!(b64_encode("foobar"));          // "Zm9vYmFy"
    println!(b64_encode(""));                // "" (empty in, empty out)

    let r: !string = b64_decode(enc);
    if r.ok {
        println!(r.val);                     // "Hello"
    }

    // Errors: one per failure mode.
    let e1: !string = b64_decode("***");     // out-of-alphabet byte
    if !e1.ok { println!(e1.err); }          // "invalid base64 character"

    let e2: !string = b64_decode("AB=C");    // data after a pad byte
    if !e2.ok { println!(e2.err); }          // "invalid base64 padding"

    let e3: !string = b64_decode("A");       // length % 4 == 1
    if !e3.ok { println!(e3.err); }          // "invalid base64 length"

    // Default-on-error with `??`.
    let dec: string = b64_decode("not!valid") ?? "fallback";
    println!(dec);                           // "fallback"

    return 0;
}

import stdlib::hex::*;

fn main() -> !i32 {
    let enc: string = hex_encode("ABC");     // "414243"
    println!(enc);
    println!(hex_encode(""));                // "" (empty)

    let dec: string = hex_decode(enc)?;      // propagate on error
    println!(dec);                           // "ABC"

    // Case-insensitive decode.
    let up: string = hex_decode("414243")?;
    let lo: string = hex_decode("414243".to_lower())?;
    if up.eq(lo) { println!("case-insensitive ok"); }

    let e1: !string = hex_decode("abc");     // odd number of digits
    if !e1.ok { println!(e1.err); }          // "odd length"

    let e2: !string = hex_decode("xy");      // not hex digits
    if !e2.ok { println!(e2.err); }          // "non-hex char"

    return ok(0);
}

pub struct ByteBuffer {
    pub data: *u8,   // raw byte storage (hand to C-side write syscalls)
    pub len: i32,    // number of valid bytes; always <= cap
    pub cap: i32,    // allocated capacity; always >= len
}

import stdlib::bytes::*;

fn main() -> i32 {
    let b: *ByteBuffer = ByteBuffer::new();
    defer b.free();

    println!(b.cap());            // 16 (initial capacity)

    b.push_str("hello, ");
    b.push_str("world");
    b.push(33 as u8);             // '!'

    println!(b.len());            // 13

    let first: u8 = b.at(0);
    println!(first as i32);       // 104 = 'h'

    println!(b.as_string());      // "hello, world!"

    // Push past the initial capacity to force a reallocation.
    let mut i: i32 = 0;
    while i < 50 { b.push(65 as u8); i = i + 1; }
    println!(b.len());            // 63
    println!(b.cap() >= b.len()); // true

    b.clear();
    println!(b.len());            // 0 (capacity is preserved)

    return 0;
}

import stdlib::bytes::*;

fn main() -> i32 {
    let req: *ByteBuffer = ByteBuffer::new();
    defer req.free();

    req.push_str("GET / HTTP/1.1\r\n");
    req.push_str("Host: example.com\r\n");
    req.push_str("\r\n");

    let p: *u8 = req.data;        // hand `p` + `req.len` to a write()
    let n: i32 = req.len;
    println!(n);

    return 0;
}

import stdlib::crypto::*;
import stdlib::hex::*;

fn main() -> i32 {
    // SHA-256
    println!(sha256_hex(""));
    // e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
    println!(sha256_hex("abc"));
    // ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

    // Raw digest -> hex equals the _hex variant.
    let raw: string = sha256("hello");
    println!(hex_encode(raw));
    // 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

    // SHA-1
    println!(sha1_hex(""));      // da39a3ee5e6b4b0d3255bfef95601890afd80709
    println!(sha1_hex("abc"));   // a9993e364706816aba3e25717850c26c9cd0d89d
    println!(hex_encode(sha1("abc")));

    // HMAC-SHA-256
    let mac: string = hmac_sha256_hex(
        "key", "The quick brown fox jumps over the lazy dog");
    println!(mac);
    // f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

    let macraw: string = hmac_sha256("secret", "payload");
    println!(hex_encode(macraw));
    // b82fcb791acec57859b989b430a826488ce2e479fdf92326bd0a2e8375a42ba4

    return 0;
}

import stdlib::crypto::*;
import stdlib::base64::*;

const WS_GUID: string = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

fn ws_accept(client_key: string) -> string {
    let combined: string = client_key.concat(WS_GUID);
    let digest: string = sha1(combined);     // 20 raw bytes
    return b64_encode(digest);
}

fn main() -> i32 {
    // RFC 6455 example vector.
    println!(ws_accept("dGhlIHNhbXBsZSBub25jZQ=="));
    // s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
    return 0;
}

import stdlib::compress::*;
import stdlib::fs::*;

extern fn __glide_string_from_buf(buf: *void, n: i32) -> string;

fn main() -> i32 {
    let mut raw_len: i32 = 0;
    let payload: string = fs_read_bytes("archive.gz", &raw_len);
    if raw_len <= 0 { return 1; }

    let mut out_len: i32 = 0;
    let buf: *void = gzip_decode(payload, raw_len, &out_len);
    if buf == null { return 1; }             // null on any decode error

    let decoded: string = __glide_string_from_buf(buf, out_len);
    free(buf);
    println!(out_len);

    return 0;
}

import stdlib::compress::*;
import stdlib::tar::*;
import stdlib::fs::*;

extern fn __glide_string_from_buf(buf: *void, n: i32) -> string;

fn main() -> i32 {
    let mut raw_len: i32 = 0;
    let payload: string = fs_read_bytes("repo.tar.gz", &raw_len);
    if raw_len <= 0 { return 1; }

    // Inflate the gzip wrapper.
    let mut out_len: i32 = 0;
    let buf: *void = gzip_decode(payload, raw_len, &out_len);
    if buf == null { return 1; }
    let decoded: string = __glide_string_from_buf(buf, out_len);
    free(buf);

    // Extract, stripping the leading <repo>-<sha>/ directory.
    let n: i32 = tar_extract(decoded, out_len, "/tmp/extract", 1);
    if n < 0 { return 1; }                   // -1 = a file write failed
    println!(n);                             // regular files written

    // Or keep full paths with strip_components = 0.
    let m: i32 = tar_extract(decoded, out_len, "/tmp/full", 0);
    println!(m);

    return 0;
}