summaryrefslogtreecommitdiff
path: root/src/register.c
blob: 4885ec539a706626c3d8899fd7fb9d26d1056026 (plain)
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#define _POSIX_C_SOURCE 200809L
#include <err.h>
#include <string.h>
#include <stdbool.h>
#include <jansson.h>
#include "http.h"
#include "config.h"
#include "log.h"

#define CLIENT_NAME "ap_client"
#define REGISTER_URL "https://%s/api/v1/apps"

struct register_response {
    char *client_id;
    char *client_secret;
};

static char *get_register_url(const char *domain)
{
    char *url;
    size_t size;

    size = strlen(REGISTER_URL) + strlen(domain) - 1;
    url = malloc(size);
    if (!url) {
        err(1, NULL);
        return NULL;
    }

    sprintf(url, REGISTER_URL, domain);
    return url;
}

static char *get_register_req()
{
    char *req;
    json_t *json_root;

    json_root = json_pack_ex(NULL, 1, "{s:s, s:s, s:s}", "client_name",
            CLIENT_NAME, "redirect_uris", "urn:ietf:wg:oauth:2.0:oob", "scopes",
            "read write push");
    if (!json_root) {
        return NULL;
    }

    req = json_dumps(json_root, 0);
    json_decref(json_root);

    return req;
}

static struct register_response *get_register_resp(const char *data)
{
    struct register_response *resp;
    json_t *json_root;
    json_t *cid, *csec;

    json_root = json_loads(data, 0, NULL);
    if (!json_root) {
        return NULL;
    }

    if (!json_is_object(json_root)) {
        json_decref(json_root);
        return NULL;
    }

    cid = json_object_get(json_root, "client_id");
    csec = json_object_get(json_root, "client_secret");
    if (!json_is_string(cid) || !json_is_string(csec)) {
        json_decref(json_root);
        return NULL;
    }

    resp = calloc(1, sizeof(struct register_response));
    resp->client_id = strdup(json_string_value(cid));
    resp->client_secret = strdup(json_string_value(csec));

    json_decref(json_root);
    return resp;
}

int register_app(const char *domain)
{
    char *url, *req_data, *resp_data;
    struct register_response *resp;

    if (!domain || !*domain) {
        log_msg(LOG_WARNING, "register_app", "invalid argument");
        return -1;
    }

    url = get_register_url(domain);
    if (!url) {
        return -1;
    }

    req_data = get_register_req();
    if (!req_data) {
        free(url);
        return -1;
    }

    resp_data = post_request(url, req_data);
    free(url);
    free(req_data);
    if (!resp_data) {
        log_msg(LOG_WARNING, "register_app", "register request failed");
        return -1;
    }

    resp = get_register_resp(resp_data);
    free(resp_data);
    if (!resp) {
        log_msg(LOG_WARNING, "register_app", "invalid response");
        return -1;
    }

    config_set_client_id(resp->client_id);
    config_set_client_secret(resp->client_secret);
    config_set_instance_url(domain);

    free(resp->client_id);
    free(resp->client_secret);
    free(resp);

    return 0;
}