http_server.ion

// HTTP server on port 8080. FFI sockets, spawn per client, stdin quit shuts down listen socket.
//
// recv and send are Ion keywords; FFI uses recv_sys and send_sys (see ion.toml cflags).

import "stdlib/fmt.ion" as fmt;
import "stdlib/io.ion" as io;

enum Option<T> {
    Some(T);
    None;
}

enum SendResult<T> {
    Sent;
    Closed(T);
}

extern "C" {
    fn ion_net_init();
    fn read(fd: int, buf: *u8, count: int) -> int;
    fn socket(domain: int, sock_type: int, proto: int) -> int;
    fn bind(sockfd: &int, addr: &SockAddrIn, addrlen: int) -> int;
    fn listen(sockfd: &int, backlog: int) -> int;
    fn accept(sockfd: &int, addr: &mut u8, addrlen: &mut int) -> int;
    fn recv_sys(sockfd: &int, buf: &mut u8, len: int, flags: int) -> int;
    fn send_sys(sockfd: &int, buf: *u8, len: int, flags: int) -> int;
    fn close(fd: &int) -> int;
    fn htons(hostshort: u16) -> u16;
}

struct SockAddrIn {
    sin_family: u16;
    sin_port: u16;
    sin_addr: u32;
    sin_zero: [u8; 8];
}

fn read_line() -> String {
    let mut bytes: Vec<u8> = Vec::new();
    let mut byte_buf: [u8; 1] = [0; 1];

    loop {
        unsafe {
            let n: int = read(0, &byte_buf[0], 1);
            if n <= 0 {
                match String::from_utf8(bytes) {
                    Option::Some(text) => {
                        return text;
                    }
                    Option::None => {
                        return String::new();
                    }
                }
            }
        }
        let ch: u8 = byte_buf[0];
        if ch == 10 as u8 {
            match String::from_utf8(bytes) {
                Option::Some(text) => {
                    return text;
                }
                Option::None => {
                    return String::new();
                }
            }
        }
        if ch != 13 as u8 {
            Vec::push(&mut bytes, ch);
        }
    }

    return String::new();
}

fn trim_line(s: String) -> String {
    let mut bytes: Vec<u8> = Vec::new();
    let mut skipping: bool = true;
    for ch in s {
        if skipping && (ch == 32 || ch == 9) {
            continue;
        }
        skipping = false;
        Vec::push(&mut bytes, ch);
    }
    match String::from_utf8(bytes) {
        Option::Some(out) => {
            return out;
        }
        Option::None => {
            return String::new();
        }
    }
}

fn create_sockaddr_in(port: u16) -> SockAddrIn {
    unsafe {
        return SockAddrIn {
            sin_family: 2,
            sin_port: htons(port),
            sin_addr: 0,
            sin_zero: [0; 8],
        };
    }
}

fn http_body() -> String {
    return "<html><head><title>Ion HTTP Server</title></head><body><h1>Hello from Ion!</h1><p>This is a simple HTTP server written in Ion.</p></body></html>";
}

fn dispatch_peer(peer_fd: int) {
    if peer_fd < 0 {
        return;
    }
    spawn {
        let _result: int = handle_client(peer_fd);
    };
}

fn send_string_bytes(fd: int, text: String) {
    let nbytes: int = text.len();
    unsafe {
        let _sent: int = send_sys(&fd, text.data, nbytes, 0);
    }
}

fn handle_client(client_fd: int) -> int {
    let mut buffer: [u8; 128] = [0; 128];
    let buf_len: int = buffer.len();

    unsafe {
        let received: int = recv_sys(&client_fd, &mut buffer[0], buf_len, 0);
        if received < 1 {
            close(&client_fd);
            return 0;
        }

        let body: String = http_body();
        let body_len: int = body.len();
        let digits: String = fmt::int_to_string(body_len);

        let _sent1: int = send_sys(&client_fd, "HTTP/1.1 200 OK\r\n", 17, 0);
        let _sent2: int = send_sys(&client_fd, "Content-Type: text/html\r\n", 25, 0);
        let _sent3: int = send_sys(&client_fd, "Content-Length: ", 16, 0);
        send_string_bytes(client_fd, digits);
        let _sent5: int = send_sys(&client_fd, "\r\n", 2, 0);
        let _sent6: int = send_sys(&client_fd, "Connection: close\r\n", 19, 0);
        let _sent7: int = send_sys(&client_fd, "\r\n", 2, 0);
        send_string_bytes(client_fd, body);

        close(&client_fd);
    }

    return 0;
}

fn listen_and_serve(fd_tx: Sender<int>, stopped_tx: Sender<int>) {
    unsafe {
        ion_net_init();

        let af_inet: int = 2;
        let sock_stream: int = 1;
        let ipproto_tcp: int = 6;

        let server_fd: int = socket(af_inet, sock_stream, ipproto_tcp);
        if server_fd < 0 {
            send(&stopped_tx, 1);
            return;
        }

        let sockaddr: SockAddrIn = create_sockaddr_in(8080);

        let bind_result: int = bind(&server_fd, &sockaddr, 16);
        if bind_result < 0 {
            close(&server_fd);
            send(&stopped_tx, 2);
            return;
        }

        let listen_result: int = listen(&server_fd, 10);
        if listen_result < 0 {
            close(&server_fd);
            send(&stopped_tx, 3);
            return;
        }

        send(&fd_tx, server_fd);

        loop {
            let mut client_addr: [u8; 16] = [0; 16];
            let mut addrlen: int = 16;
            let peer_fd: int = accept(&server_fd, &mut client_addr[0], &mut addrlen);
            if peer_fd < 0 {
                break;
            }
            dispatch_peer(peer_fd);
        }

        close(&server_fd);
        send(&stopped_tx, 0);
    }
}

fn wait_for_quit() {
    loop {
        let trimmed: String = trim_line(read_line());
        if trimmed == String::from("quit") {
            break;
        }
    }
}

fn main() -> int {
    let (fd_tx, fd_rx): (Sender<int>, Receiver<int>) = channel<int>();
    let (stopped_tx, stopped_rx): (Sender<int>, Receiver<int>) = channel<int>();

    spawn {
        listen_and_serve(fd_tx, stopped_tx);
    };

    let mut fd_rx_mut: Receiver<int> = fd_rx;
    let mut server_fd: int = -1;
    match recv(&mut fd_rx_mut) {
        Option::Some(fd) => {
            server_fd = fd;
        }
        Option::None => {
            return 1;
        }
    }

    io::println("listening on http://127.0.0.1:8080 (type quit)");

    wait_for_quit();

    unsafe {
        close(&server_fd);
    }

    let mut stopped_rx_mut: Receiver<int> = stopped_rx;
    match recv(&mut stopped_rx_mut) {
        Option::Some(status) => {
            return status;
        }
        Option::None => {
            return 1;
        }
    }
}