quad-image 0.1.0

An image host
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

use base64;
use failure::Error;
use hmac;
use rusqlite;
use rusqlite::Connection;
use sha2;

fn gallery_db() -> Result<Connection, Error> {
    Ok(Connection::open("gallery.db")?)
}

pub fn migrate_gallery() -> Result<(), Error> {
    let conn = gallery_db()?;
    conn.execute(
        "create table if not exists gallery_images (
gallery char(10) not null,
image char(15) not null,
added datetime not null
)",
        rusqlite::NO_PARAMS,
    )?;
    conn.execute(
        "create unique index if not exists gal_img
on gallery_images (gallery, image)",
        rusqlite::NO_PARAMS,
    )?;
    Ok(())
}

pub fn gallery_list_all(public: &str) -> Result<Vec<String>, Error> {
    let conn = gallery_db()?;

    let mut stat = conn.prepare(
        "select image from gallery_images
where gallery=? order by added desc",
    )?;

    let mut resp = Vec::new();

    for image in stat.query_map(&[&public], |row| row.get::<usize, String>(0))? {
        resp.push(image?);
    }

    Ok(resp)
}

pub enum StoreResult {
    Ok(String),
    Duplicate,
}

pub fn gallery_store(
    secret: &[u8],
    token: &str,
    private: &str,
    image: &str,
) -> Result<StoreResult, Error> {
    let user_details = mac(token.as_bytes(), private.as_bytes());
    let trigger = mac(secret, &user_details);
    let public = format!(
        "{}:{}",
        token,
        base64::encode_config(&trigger[..7], base64::URL_SAFE_NO_PAD)
    );

    Ok(match gallery_db()?.execute(
        "insert into gallery_images (gallery, image, added) values (?, ?, current_timestamp)",
        &[&public.as_ref(), &image],
    ) {
        Ok(_) => StoreResult::Ok(public),
        Err(rusqlite::Error::SqliteFailure(ffi, _))
            if rusqlite::ErrorCode::ConstraintViolation == ffi.code =>
        {
            StoreResult::Duplicate
        }
        Err(e) => bail!(e),
    })
}

fn mac(key: &[u8], val: &[u8]) -> Vec<u8> {
    use hmac::Mac;
    let mut mac = hmac::Hmac::<sha2::Sha512Trunc256>::new_varkey(key).expect("varkey");
    mac.input(val);
    mac.result().code().to_vec()
}