id: pb5n9i86hu3d2yf7th643z6nyfzhx5rvulfc5zyy9ojwx2us
name: b2dlkeygen
license: MIT
description: Program for acquiring fresh download keys for use by proxying servers.
root_dependencies:
  - src: git https://github.com/Hejsil/zig-clap branch-master
  - src: git https://github.com/nektro/zig-json
  - src: git https://github.com/MasterQ32/zig-uri/

2
git https://github.com/Hejsil/zig-clap commit-996821a3e1f186c9e5cdfd971d742c9815ea590e
git https://github.com/nektro/zig-json commit-a091eaa9f9ae91c3875630ba1983b33ea04971a3
git https://github.com/nektro/zig-extras commit-596432af98c7cfd04047b9c885871e0237d34bed
git https://github.com/nektro/zig-range commit-4b2f12808aa09be4b27a163efc424dd4e0415992
git https://github.com/MasterQ32/zig-uri/ commit-e879df3a236869f92298fbe2db3c25e6e84cfd4c

const std = @import("std");
const clap = @import("clap");
const curl = @cImport({
    @cInclude("curl/curl.h");
});
const uri = @import("uri");
const json = @import("json");
const log = std.log.scoped(.b2dlkeygen);
const params = clap.parseParamsComptime(
    \\-h, --help                   Display this help and exit.
    \\-c, --config <FILE>          Read application config from FILE.
);
fn printFullUsage(w: anytype) !void {
    _ = try w.print("{s} ", .{std.os.argv[0]});
    try clap.usage(w, clap.Help, &params);
    _ = try w.writeByte('\n');
    try clap.help(w, clap.Help, &params, .{});
    return;
}
var curlerr = [_:0]u8{0} ** (curl.CURL_ERROR_SIZE);
fn curlErrorReport(str: []const u8, code: curl.CURLcode) void {
    log.err("{s}: {s} {s}", .{ str, curl.curl_easy_strerror(code), curlerr[0.. :0] });
}
const strList = std.ArrayList([]const u8);
const str0List = std.ArrayList([:0]const u8);
fn Deoptional(comptime t: type) type {
    const ti = @typeInfo(t);
    return switch (ti) {
        .Optional => |o| o.child,
        else => t,
    };
}
pub fn unwrap(
    un: anytype,
    comptime tag: std.meta.Tag(Deoptional(@TypeOf(un))),
) ?std.meta.TagPayload(Deoptional(@TypeOf(un)), tag) {
    if (@typeInfo(@TypeOf(un)) == .Optional) {
        if (un == null) return null;
        if (un.? != tag) return null;
        return @field(un.?, @tagName(tag));
    } else {
        if (un != tag) return null;
        return @field(un, @tagName(tag));
    }
}
const Config = struct {
    key: [*:0]const u8,
    pre: []const u8,
    post: []const u8,
    output: []const u8,
    pub fn newFromFile(path: []const u8, alloc: std.mem.Allocator) !Config {
        const file = std.fs.cwd().openFile(path, .{ .mode = .read_only }) catch |e| {
            log.err("Error opening file: {s}\n", .{e});
            std.os.exit(2);
        };
        const buf = try file.readToEndAlloc(alloc, 100000);
        defer alloc.free(buf);
        var config: Config = undefined;
        var obj = try json.parse(alloc, buf);
        defer {
            if (unwrap(obj, .Object)) |o| alloc.free(o);
        }
        if (unwrap(obj.get(.{"key"}), .String)) |key| {
            config.key = try alloc.dupeZ(u8, key);
        } else {
            log.err("No key in config, or not a string.", .{});
            return error.ConfigError;
        }
        if (unwrap(obj.get(.{"pre"}), .String)) |pre| {
            config.pre = try alloc.dupe(u8, pre);
        } else {
            log.err("No pre in config, or not a string.", .{});
            return error.ConfigError;
        }
        if (unwrap(obj.get(.{"post"}), .String)) |post| {
            config.post = try alloc.dupe(u8, post);
        } else {
            log.err("No post in config, or not a string.", .{});
            return error.ConfigError;
        }
        if (unwrap(obj.get(.{"output"}), .String)) |output| {
            config.output = try alloc.dupe(u8, output);
        } else {
            log.err("No output in config, or not a string.", .{});
            return error.ConfigError;
        }
        return config;
    }
};
pub fn main() anyerror!void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const alloc = gpa.allocator();
    std.log.info("All your codebase are belong to us.", .{});
    const parsers = comptime .{
        .PATH = clap.parsers.string,
        .FILE = clap.parsers.string,
        .NAME = clap.parsers.string,
        .REGEX = clap.parsers.string,
        .ID = clap.parsers.int(i64, 10),
    };
    var diag = clap.Diagnostic{};
    var clap_res = clap.parse(clap.Help, &params, parsers, .{
        .diagnostic = &diag,
        .allocator = alloc,
    }) catch |err| {
        diag.report(std.io.getStdErr().writer(), err) catch {};
        return err;
    };
    defer clap_res.deinit();
    var args = clap_res.args;
    if (args.help) {
        var w = std.io.getStdOut().writer();
        try printFullUsage(w);
        return;
    }
    if (args.config == null) {
        log.err("Please specify a config file with --config.", .{});
        std.os.exit(3);
    }
    const cfile = args.config.?;
    var ret = curl.curl_global_init(curl.CURL_GLOBAL_ALL);
    if (ret != curl.CURLE_OK) {
        log.err("cURL global init failure: {s}", .{curl.curl_easy_strerror(ret)});
        return;
    }
    defer curl.curl_global_cleanup();
    const handle = curl.curl_easy_init() orelse return error.CURLHandleInitFailed;
    defer curl.curl_easy_cleanup(handle);
    var response_buffer = std.ArrayList(u8).init(alloc);
    defer response_buffer.deinit();
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_ERRORBUFFER, &curlerr);
    //    try easyFetch(handle, "http://cloud/foo.jpeg", &response_buffer);
    //    var dir = try std.fs.cwd().makeOpenPath(".", .{
    //        .access_sub_paths = true,
    //    });
    //    var file = try dir.createFile(
    //        "test.foo",
    //        .{
    //            .read = false,
    //            .truncate = true,
    //        },
    //    );
    //    defer file.close();
    //    try file.writeAll(response_buffer.items);
    const conf = try Config.newFromFile(cfile, alloc);
    var api = try getAuthToken(handle, conf.key, alloc);
    try getDlToken(handle, &api, alloc);
    var file: std.fs.File = try std.fs.cwd().createFile(conf.output, .{ .read = false, .truncate = true });
    defer file.close();
    var w = file.writer();
    try w.print("{s}{s}{s}\n", .{ conf.pre, api.dl_auth.?, conf.post });
}
const B2API = struct {
    auth: [*:0]const u8,
    url: [*:0]const u8,
    dl_url: [*:0]const u8,
    dl_auth: ?[]const u8,
};
fn getAuthToken(handle: *curl.CURL, key: [*:0]const u8, alloc: std.mem.Allocator) !B2API {
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_URL, "https://api.backblazeb2.com/b2api/v2/b2_authorize_account");
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_USERPWD, key);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEFUNCTION, writeToArrayListCallback);
    var resp = std.ArrayList(u8).init(alloc);
    defer resp.deinit();
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEDATA, resp);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_USERAGENT, "b2keygen 0.1 (linux)");
    _ = curl.curl_easy_perform(handle);
    var val = try json.parse(alloc, resp.items);
    var autho = val.get(.{"authorizationToken"});
    var urlo = val.get(.{"apiUrl"});
    var urlo2 = val.get(.{"downloadUrl"});
    if (autho == null or urlo == null or urlo2 == null) {
        return error.ShitsFucked;
    }
    var foo: B2API = undefined;
    foo.auth = try std.fmt.allocPrintZ(alloc, "Authorization: {s}", .{autho.?.String});
    foo.url = try alloc.dupeZ(u8, urlo.?.String);
    foo.dl_url = try alloc.dupeZ(u8, urlo2.?.String);
    foo.dl_auth = null;
    return foo;
}
fn getDlToken(handle: *curl.CURL, api: *B2API, alloc: std.mem.Allocator) !void {
    const url = try std.fmt.allocPrintZ(alloc, "{s}/b2api/v2/b2_get_download_authorization", .{api.url});
    //const url: [:0]const u8 = "http://localhost:6666";
    defer alloc.free(url);
    var resp = std.ArrayList(u8).init(alloc);
    defer resp.deinit();
    var bar = curl.curl_slist_append(null, api.auth);
    bar = curl.curl_slist_append(bar, "Content-Type: application/json");
    defer curl.curl_slist_free_all(bar);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_URL, url.ptr);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEFUNCTION, writeToArrayListCallback);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEDATA, resp);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_HTTPHEADER, bar);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_USERAGENT, "b2keygen 0.1 (linux)");
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_POST, @as(u32, 1));
    var buffer: [1024]u8 = undefined;
    var aaa = std.io.fixedBufferStream(buffer[0..]).writer();
    var asd = [_]json.Member{
        .{ .key = "bucketId", .value = json.Value{ .String = "1b191ebe58f4fa1876bc031d" } },
        .{ .key = "fileNamePrefix", .value = json.Value{ .String = "" } },
        .{ .key = "validDurationInSeconds", .value = json.Value{ .Int = 259200 } },
    };
    const data = json.Value{
        .Object = asd[0..],
    };
    try data.format("", .{}, aaa);
    buffer[aaa.context.pos] = 0;
    const jason = @ptrCast([*:0]const u8, buffer[0..aaa.context.pos].ptr);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_POSTFIELDS, jason);
    _ = curl.curl_easy_setopt(handle, curl.CURLOPT_POSTFIELDSIZE, aaa.context.pos);
    _ = curl.curl_easy_perform(handle);
    var val = try json.parse(alloc, resp.items);
    var autho = val.get(.{"authorizationToken"});
    if (autho == null) {
        return error.ShitsFucked2;
    }
    api.dl_auth = try alloc.dupe(u8, autho.?.String);
}
fn easyFetch(handle: *curl.CURL, url: [*:0]const u8, resp: *std.ArrayList(u8)) !void {
    //    if (fetch_wait > 0) {
    //        if (fetch_timer) |*timer| {
    //            const cur = timer.read() / (1000 * 1000);
    //            if (cur < fetch_wait) {
    //                std.time.sleep((fetch_wait - cur) * 1000 * 1000);
    //            }
    //            timer.reset();
    //        } else {
    //            fetch_timer = try std.time.Timer.start();
    //        }
    //    }
    var ret = curl.curl_easy_setopt(handle, curl.CURLOPT_URL, url);
    if (ret != curl.CURLE_OK) {
        curlErrorReport("cURL set url:", ret);
        return error.CurlError;
    }
    ret = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEFUNCTION, writeToArrayListCallback);
    if (ret != curl.CURLE_OK) {
        curlErrorReport("cURL set writefunction:", ret);
        return error.CurlError;
    }
    ret = curl.curl_easy_setopt(handle, curl.CURLOPT_WRITEDATA, resp);
    if (ret != curl.CURLE_OK) {
        curlErrorReport("cURL set writedata:", ret);
        return error.CurlError;
    }
    ret = curl.curl_easy_setopt(handle, curl.CURLOPT_USERAGENT, "b2backup 0.1 (linux)");
    if (ret != curl.CURLE_OK) {
        curlErrorReport("cURL set user agent:", ret);
        return error.CurlError;
    }
    ret = curl.curl_easy_perform(handle);
    if (ret != curl.CURLE_OK) {
        curlErrorReport("cURL perform:", ret);
        return error.CurlError;
    }
    log.info("Got {d} bytes", .{resp.items.len});
}
fn writeToArrayListCallback(
    data: *anyopaque,
    size: c_uint,
    nmemb: c_uint,
    user_data: *anyopaque,
) callconv(.C) c_uint {
    var buffer = @intToPtr(*std.ArrayList(u8), @ptrToInt(user_data));
    var typed_data = @ptrCast([*]u8, data);
    buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
    return nmemb * size;
}

const std = @import("std");
const deps = @import("./deps.zig");
pub fn build(b: *std.build.Builder) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    var target = b.standardTargetOptions(
        .{
            .default_target = .{
                .abi = .musl,
            },
        },
    );
    // Standard release options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
    const mode = b.standardReleaseOptions();
    const exe = b.addExecutable("b2dlkeygen", "src/main.zig");
    exe.linkage = .static;
    exe.setTarget(target);
    exe.setBuildMode(mode);
    exe.install();
    //    exe.linkage = .static;
    deps.addAllTo(exe);
    exe.linkLibC();
    exe.addObjectFile("/usr/lib/libcurl.a");
    exe.addIncludeDir("/usr/include");
    exe.addObjectFile("/usr/lib/libssl.a");
    exe.addObjectFile("/usr/lib/libcrypto.a");
    exe.addObjectFile("/usr/lib/libnghttp2.a");
    exe.addObjectFile("/usr/lib/libbrotlicommon.a");
    exe.addObjectFile("/usr/lib/libbrotlidec.a");
    exe.addObjectFile("/usr/lib/libbrotlienc.a");
    exe.addObjectFile("/lib/libz.a");
    const run_cmd = exe.run();
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);
    const exe_tests = b.addTest("src/main.zig");
    exe_tests.setTarget(target);
    exe_tests.setBuildMode(mode);
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&exe_tests.step);
}

MIT License
Copyright (c) 2022 lonjil
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Session.vim
deps.zig
zig-cache/
zig-out/
.zigmod/
.DS_Store
.git