jeka/utun2
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
982e5a06ab6b1a7e39d2c97fabb561ed213185b6
utun2/src/chat/invite_build.c
T

503 lines
22 KiB
C
Raw Blame History

/*
* invite_build.c — сборка invite-ссылок utun:// (выбор узла + адреса)
*
* Общий модуль для всех GUI (desktop chatgui, Android, headless CLI).
* Логика выбора «лучшего узла» перенесена из tools/chatgui-android/jni_bridge.
* Работает в uasync-потоке, использует per-instance контекст.
*/
#include "invite_build.h"
#include "invite_link.h"
#include "chat_core_priv.h"
#include "chat_event.h"
#include "chat_join.h"
#include "../routing_layer/topo_group.h"
#include "../routing_layer/topo_node.h"
#include "../utun_instance.h"
#include "../transport_layer/etcp_connections.h"
#include "../../lib/mem.h"
#include "../../lib/platform_compat.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/rand.h>
/* ── живость узла в канале (BGP/прямое/через посредника) ── */
static struct TOPO_GROUP* resolve_chat_group(struct UTUN_INSTANCE* inst, uint64_t channel_id) {
if (!inst || !inst->topo_groups) return NULL;
struct TOPO_GROUP* grp = topo_groups_find(inst->topo_groups, channel_id);
if (!grp || grp->group_type != TOPO_GROUP_TYPE_CHAT) return NULL;
return grp;
}
static int node_is_alive(struct UTUN_INSTANCE* inst, struct TOPO_GROUP* grp, uint64_t node_id) {
struct chat_core_ctx* cc = CC(inst);
if (cc && node_id == cc->my_node_id) return 1; /* self всегда доступен */
if (!grp) return 0;
struct TOPO_GROUP_NODE* nq = topo_node_find_by_id(grp, node_id);
if (!nq) return 0;
return (nq->conn_presence & (NCONN_DIRECT | NCONN_INDIRECT | NCONN_BGP)) != 0;
}
/* есть ли у узла публичные адреса v4 и v6 (addr_type=DIRECT) */
static int node_has_both_public(struct UTUN_INSTANCE* inst, uint64_t node_id) {
struct chat_core_ctx* cc = CC(inst);
int has_v4 = 0, has_v6 = 0;
sqlite3_stmt* st = NULL;
char sql[256];
snprintf(sql, sizeof(sql),
"SELECT family FROM node_addresses WHERE node_id=? AND addr_type=%d", ADDR_TYPE_DIRECT);
if (sqlite3_prepare_v2(cc->db, sql, -1, &st, NULL) != SQLITE_OK) return 0;
sqlite3_bind_int64(st, 1, (sqlite3_int64)node_id);
while (sqlite3_step(st) == SQLITE_ROW) {
int fam = sqlite3_column_int(st, 0);
if (fam == 4) has_v4 = 1;
else if (fam == 6) has_v6 = 1;
}
sqlite3_finalize(st);
return (has_v4 && has_v6) ? 1 : 0;
}
/* ── Фаза 1-2: лучший достижимый узел в канале ── */
static uint64_t pick_best_node(struct UTUN_INSTANCE* inst, uint64_t channel_id, int* out_has_both_public, int* out_priority) {
struct chat_core_ctx* cc = CC(inst);
uint64_t best_nid = 0;
int best_priority = 4; /* 1=super, 2=regular, 3=self, 4=invalid */
int best_has_both = 0;
struct TOPO_GROUP* grp = resolve_chat_group(inst, channel_id);
if (!grp) {
*out_has_both_public = 0;
*out_priority = best_priority;
return 0;
}
char ch_str[32];
snprintf(ch_str, sizeof(ch_str), "%llu", (unsigned long long)channel_id);
char peers_tbl[80];
peers_table_name(ch_str, peers_tbl, sizeof(peers_tbl));
char sql[512];
snprintf(sql, sizeof(sql), "SELECT node_id, node_type FROM \"%s\" ORDER BY node_id", peers_tbl);
sqlite3_stmt* pst = NULL;
if (sqlite3_prepare_v2(cc->db, sql, -1, &pst, NULL) != SQLITE_OK) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: pick_best — query failed ch=%llu err=%s",
(unsigned long long)channel_id, sqlite3_errmsg(cc->db));
*out_has_both_public = 0;
*out_priority = best_priority;
return 0;
}
while (sqlite3_step(pst) == SQLITE_ROW) {
uint64_t nid = (uint64_t)sqlite3_column_int64(pst, 0);
int ntype = sqlite3_column_int(pst, 1);
if (!node_is_alive(inst, grp, nid)) continue;
int has_both = node_has_both_public(inst, nid);
int priority;
if (ntype == 4) priority = 1; /* supernode, включая self */
else if (nid == cc->my_node_id) priority = 3;
else priority = 2;
if (priority <= best_priority) {
best_nid = nid;
best_priority = priority;
best_has_both = has_both;
}
}
sqlite3_finalize(pst);
*out_has_both_public = best_has_both;
*out_priority = best_priority;
return best_nid;
}
/* авто-узел: pick_best_node + фолбэк на self */
static uint64_t resolve_auto_node(struct UTUN_INSTANCE* inst, uint64_t channel_id, int* out_has_both, int* out_priority) {
struct chat_core_ctx* cc = CC(inst);
int has_both = 0, prio = 4;
uint64_t best = pick_best_node(inst, channel_id, &has_both, &prio);
if (best == 0) best = cc->my_node_id;
DEBUG_INFO(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: auto selection ch=%llu node=0x%016llx role=%s self=%d",
(unsigned long long)channel_id, (unsigned long long)best,
prio == 1 ? "supernode" : prio == 2 ? "regular" : "self", best == cc->my_node_id);
if (out_has_both) *out_has_both = has_both;
if (out_priority) *out_priority = prio;
return best;
}
/* ── Фаза 3: pubkey узла ── */
static int get_node_pubkey(struct UTUN_INSTANCE* inst, uint64_t node_id, int is_self, uint8_t pubkey_out[INVITE_PUBKEY_SIZE]) {
struct chat_core_ctx* cc = CC(inst);
if (is_self) {
if (!inst) return -1;
memcpy(pubkey_out, inst->my_keys.public_key, INVITE_PUBKEY_SIZE);
return 0;
}
sqlite3_stmt* st = NULL;
if (sqlite3_prepare_v2(cc->db, "SELECT x25519_pubkey FROM nodes WHERE node_id=?",
-1, &st, NULL) != SQLITE_OK) return -1;
sqlite3_bind_int64(st, 1, (sqlite3_int64)node_id);
int ok = 0;
if (sqlite3_step(st) == SQLITE_ROW) {
const void* pk = sqlite3_column_blob(st, 0);
int pklen = sqlite3_column_bytes(st, 0);
if (pk && pklen >= INVITE_PUBKEY_SIZE) { memcpy(pubkey_out, pk, INVITE_PUBKEY_SIZE); ok = 1; }
}
sqlite3_finalize(st);
return ok ? 0 : -1;
}
/* ── Фаза 4a: свои адреса из сокетов ── */
static int collect_self_addrs(struct UTUN_INSTANCE* inst, struct InviteAddr* out, int max_cnt) {
int cnt = 0;
if (!inst) return 0;
struct ETCP_SOCKET* s;
/* UDP */
for (s = inst->etcp_sockets; s && cnt < max_cnt; s = s->next) {
if (s->is_tcp) continue;
struct sockaddr_storage* sa = s->interface_addr.ss_family ? &s->interface_addr : &s->local_addr;
if (sa->ss_family == AF_INET) {
struct sockaddr_in* sin = (struct sockaddr_in*)sa;
out[cnt].family = 4; out[cnt].socketId = s->sock_id; out[cnt].proto = INVITE_PROTO_UDP;
memcpy(out[cnt].address, &sin->sin_addr, 4);
out[cnt].port = ntohs(sin->sin_port); cnt++;
} else if (sa->ss_family == AF_INET6) {
struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
out[cnt].family = 6; out[cnt].socketId = s->sock_id; out[cnt].proto = INVITE_PROTO_UDP;
memcpy(out[cnt].address, &sin6->sin6_addr, 16);
out[cnt].port = ntohs(sin6->sin6_port); cnt++;
}
}
/* TCP */
for (s = inst->etcp_sockets; s && cnt < max_cnt; s = s->next) {
if (!s->is_tcp) continue;
struct sockaddr_storage* sa = s->interface_addr.ss_family ? &s->interface_addr : &s->local_addr;
uint8_t proto = INVITE_PROTO_TCP | (s->reality_enabled ? INVITE_PROTO_REALITY : 0);
if (sa->ss_family == AF_INET) {
struct sockaddr_in* sin = (struct sockaddr_in*)sa;
out[cnt].family = 4; out[cnt].socketId = s->sock_id; out[cnt].proto = proto;
memcpy(out[cnt].address, &sin->sin_addr, 4);
out[cnt].port = ntohs(sin->sin_port); cnt++;
} else if (sa->ss_family == AF_INET6) {
struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
out[cnt].family = 6; out[cnt].socketId = s->sock_id; out[cnt].proto = proto;
memcpy(out[cnt].address, &sin6->sin6_addr, 16);
out[cnt].port = ntohs(sin6->sin6_port); cnt++;
}
}
return cnt;
}
/* reality-параметры self-узла из конфига (node-global, как в topo_node_update_my_addresses). */
static void collect_self_reality(struct UTUN_INSTANCE* inst, struct InviteReality* out) {
memset(out, 0, sizeof(*out));
if (!inst || !inst->config) return;
const struct reality_config* rc = &inst->config->global.reality;
if (!rc->enabled || !rc->has_private_key) return;
int any = 0;
for (struct ETCP_SOCKET* s = inst->etcp_sockets; s; s = s->next)
if (s->is_tcp && s->reality_enabled) { any = 1; break; }
if (!any) return;
uint8_t pub[32];
if (reality_pubkey_from_priv(rc->private_key, pub) != REALITY_OK) return;
out->has = 1;
if (rc->short_id_count > 0) memcpy(out->short_id, rc->short_ids[0], 8);
else memcpy(out->short_id, rc->short_id, 8);
memcpy(out->server_pubkey, pub, 32);
memcpy(out->version, rc->version, 3);
strncpy(out->server_name, rc->server_name, INVITE_SNAME_MAX - 1);
out->server_name[INVITE_SNAME_MAX - 1] = '\0';
}
/* ── Фаза 4b: адреса узла из БД ── */
static int collect_node_addrs_from_db(struct UTUN_INSTANCE* inst, uint64_t node_id, struct InviteAddr* out, int max_cnt, int dir_only,
struct InviteReality* reality) {
struct chat_core_ctx* cc = CC(inst);
char sql[256];
if (dir_only)
snprintf(sql, sizeof(sql),
"SELECT family,socket_id,protocol,address,port,options FROM node_addresses"
" WHERE node_id=? AND addr_type=%d", ADDR_TYPE_DIRECT);
else
snprintf(sql, sizeof(sql),
"SELECT family,socket_id,protocol,address,port,options FROM node_addresses WHERE node_id=?");
sqlite3_stmt* st = NULL;
if (sqlite3_prepare_v2(cc->db, sql, -1, &st, NULL) != SQLITE_OK) return 0;
sqlite3_bind_int64(st, 1, (sqlite3_int64)node_id);
int cnt = 0;
while (sqlite3_step(st) == SQLITE_ROW && cnt < max_cnt) {
int family = sqlite3_column_int(st, 0);
out[cnt].family = family;
out[cnt].socketId = (uint8_t)sqlite3_column_int(st, 1);
out[cnt].proto = (uint8_t)sqlite3_column_int(st, 2);
const uint8_t* addr = sqlite3_column_blob(st, 3);
int addr_len = sqlite3_column_bytes(st, 3);
int ip_len = (family == 6) ? 16 : 4;
memset(out[cnt].address, 0, sizeof(out[cnt].address));
if (addr && addr_len >= ip_len) memcpy(out[cnt].address, addr, (size_t)ip_len);
out[cnt].port = (uint16_t)sqlite3_column_int(st, 4);
if (reality && !reality->has && (out[cnt].proto & INVITE_PROTO_REALITY)
&& sqlite3_column_type(st, 5) == SQLITE_BLOB
&& sqlite3_column_bytes(st, 5) == TOPO_ADDR_REALITY_OPTS_SIZE) {
const struct TOPO_ADDR_REALITY_OPTS* o = (const struct TOPO_ADDR_REALITY_OPTS*)sqlite3_column_blob(st, 5);
reality->has = 1;
memcpy(reality->short_id, o->short_id, 8);
memcpy(reality->server_pubkey, o->server_pubkey, 32);
memcpy(reality->version, o->version, 3);
memcpy(reality->server_name, o->server_name, INVITE_SNAME_MAX);
reality->server_name[INVITE_SNAME_MAX - 1] = '\0';
}
cnt++;
}
sqlite3_finalize(st);
return cnt;
}
/* ── публичный API ── */
static int prepare_link(struct UTUN_INSTANCE* inst, uint64_t channel_id, uint64_t target_node_id,
const char* password, char* out, size_t out_size, uint64_t* target, uint64_t* key) {
struct chat_core_ctx* cc = CC(inst);
if (!out || out_size == 0) return -1;
out[0] = '\0';
if (!cc || !cc->initialized || !inst || !cc->db) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: not initialized (inst=%p db=%p)",
(void*)inst, (void*)(cc ? cc->db : NULL));
return -1;
}
if (channel_id == 0) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: invalid channel_id");
return -1;
}
/* ── выбор узла ── */
uint64_t target_nid = target_node_id;
int use_self = 0, has_both_public = 0;
if (target_nid == 0) {
int prio = 4;
target_nid = resolve_auto_node(inst, channel_id, &has_both_public, &prio);
use_self = (target_nid == cc->my_node_id) ? 1 : 0;
DEBUG_INFO(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: auto ch=%llu best=0x%016llx prio=%d self=%d both=%d",
(unsigned long long)channel_id, (unsigned long long)target_nid,
prio, use_self, has_both_public);
} else {
if (target_nid == cc->my_node_id) {
use_self = 1;
} else {
struct TOPO_GROUP* grp = resolve_chat_group(inst, channel_id);
if (!node_is_alive(inst, grp, target_nid)) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC,
"invite_build: node 0x%016llx not reachable in ch=%llu",
(unsigned long long)target_nid, (unsigned long long)channel_id);
return -1;
}
has_both_public = node_has_both_public(inst, target_nid);
}
DEBUG_INFO(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: manual ch=%llu target=0x%016llx self=%d both=%d",
(unsigned long long)channel_id, (unsigned long long)target_nid, use_self, has_both_public);
}
/* ── pubkey ── */
struct InviteData data;
memset(&data, 0, sizeof(data));
data.channelId = channel_id;
data.nodeId = target_nid;
/* join-ключ: генерируется инвайтером, кладётся в ссылку и регистрируется на connection-узле */
if (RAND_bytes((uint8_t*)&data.join_key, sizeof(data.join_key)) != 1 || data.join_key == 0) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: join_key generation failed");
return -1;
}
if (get_node_pubkey(inst, target_nid, use_self, data.pubkey) != 0) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: no pubkey for node=0x%016llx",
(unsigned long long)target_nid);
return -1;
}
/* ── адреса ── */
if (use_self) {
data.addrCount = (uint8_t)collect_self_addrs(inst, data.addrs, INVITE_ADDR_MAX);
collect_self_reality(inst, &data.reality);
} else {
int dir_only = has_both_public ? 1 : 0;
data.addrCount = (uint8_t)collect_node_addrs_from_db(inst, target_nid, data.addrs, INVITE_ADDR_MAX, dir_only, &data.reality);
}
if (data.addrCount == 0) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: no addrs for node=0x%016llx",
(unsigned long long)target_nid);
return -1;
}
DEBUG_INFO(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: node=0x%016llx addrs=%d dir_only=%d",
(unsigned long long)target_nid, data.addrCount, (!use_self && has_both_public) ? 1 : 0);
/* ── encode ── */
if (invite_link_encode(&data, password, out, out_size) < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: encode failed ch=%llu",
(unsigned long long)channel_id);
return -1;
}
/* ── регистрация join-ключа на connection-узле (или локально, если target==self) ── */
*target = target_nid;
*key = data.join_key;
return 0;
}
int chat_invite_best_node(struct UTUN_INSTANCE* inst, uint64_t channel_id, uint64_t* out_node_id) {
struct chat_core_ctx* cc = CC(inst);
if (!out_node_id) return -1;
if (!cc || !cc->initialized || !inst || !cc->db) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: best_node — not initialized");
return -1;
}
*out_node_id = resolve_auto_node(inst, channel_id, NULL, NULL);
return 0;
}
struct chat_invite_build {
struct chat_join_registration* registration;
chat_invite_ready_fn callback;
void* arg;
char link[1024];
};
static void invite_registered(void* arg, int result) {
struct chat_invite_build* req = arg;
req->registration = NULL;
req->callback(req->arg, result, result == CHAT_JOIN_OK ? req->link : NULL);
u_free(req);
}
struct chat_invite_build* chat_invite_build_link(struct UTUN_INSTANCE* inst, uint64_t channel_id, uint64_t target_node_id,
const char* password, chat_invite_ready_fn callback, void* arg) {
if (!callback) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: missing callback"); return NULL; }
struct chat_invite_build* req = u_calloc(1, sizeof(*req));
if (!req) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: allocation failed"); return NULL; }
uint64_t target, key;
if (prepare_link(inst, channel_id, target_node_id, password, req->link, sizeof(req->link), &target, &key) != 0) {
u_free(req); return NULL;
}
req->callback = callback; req->arg = arg;
req->registration = chat_join_register_key(inst, channel_id, target, key, invite_registered, req);
if (!req->registration) { u_free(req); return NULL; }
return req;
}
void chat_invite_build_cancel(struct chat_invite_build* req) {
if (req && req->registration) chat_join_cancel_registration(req->registration);
}
int chat_invite_candidate_nodes(struct UTUN_INSTANCE* inst, uint64_t channel_id, uint64_t* out_ids, int max_ids) {
struct chat_core_ctx* cc = CC(inst);
if (!out_ids || max_ids <= 0) return -1;
if (!cc || !cc->initialized || !inst || !cc->db) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: candidates — not initialized");
return -1;
}
struct TOPO_GROUP* grp = resolve_chat_group(inst, channel_id);
if (!grp) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: candidates — group not found ch=%llu",
(unsigned long long)channel_id);
return -1;
}
char ch_str[32];
snprintf(ch_str, sizeof(ch_str), "%llu", (unsigned long long)channel_id);
char peers_tbl[80];
peers_table_name(ch_str, peers_tbl, sizeof(peers_tbl));
char sql[512];
snprintf(sql, sizeof(sql), "SELECT node_id FROM \"%s\" ORDER BY node_id", peers_tbl);
sqlite3_stmt* st = NULL;
if (sqlite3_prepare_v2(cc->db, sql, -1, &st, NULL) != SQLITE_OK) {
DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: candidates — query failed ch=%llu err=%s",
(unsigned long long)channel_id, sqlite3_errmsg(cc->db));
return -1;
}
int cnt = 0;
while (sqlite3_step(st) == SQLITE_ROW && cnt < max_ids) {
uint64_t nid = (uint64_t)sqlite3_column_int64(st, 0);
if (node_is_alive(inst, grp, nid)) out_ids[cnt++] = nid;
}
sqlite3_finalize(st);
return cnt;
}
/* ── трамплины для gui_bridge ── */
void chat_invite_candidates_trampoline(void* arg) {
struct chat_invite_cand_req* req = (struct chat_invite_cand_req*)arg;
if (!req) return;
struct UTUN_INSTANCE* inst = req->inst;
char ch_id[64];
strncpy(ch_id, req->ch_id, sizeof(ch_id) - 1);
ch_id[sizeof(ch_id) - 1] = '\0';
u_free(arg);
if (!CC(inst) || !CC(inst)->initialized) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: candidates — not initialized"); return; }
uint64_t channel_id = strtoull(ch_id, NULL, 10);
uint64_t auto_id = 0;
chat_invite_best_node(inst, channel_id, &auto_id);
uint64_t ids[INVITE_ADDR_MAX];
int cnt = chat_invite_candidate_nodes(inst, channel_id, ids, INVITE_ADDR_MAX);
if (cnt < 0) cnt = 0;
size_t ch_len = strlen(ch_id);
size_t evt_sz = 1 + ch_len + 8 + 2 + (size_t)cnt * 8;
uint8_t* evt = u_malloc(evt_sz);
if (!evt) return;
evt[0] = (uint8_t)ch_len;
memcpy(evt + 1, ch_id, ch_len);
memcpy(evt + 1 + ch_len, &auto_id, 8);
uint16_t u16 = (uint16_t)cnt;
memcpy(evt + 1 + ch_len + 8, &u16, 2);
for (int i = 0; i < cnt; i++) memcpy(evt + 1 + ch_len + 8 + 2 + i * 8, &ids[i], 8);
chat_event_post(inst, CHAT_EVT_INVITE_CANDIDATES, evt, (int)evt_sz);
u_free(evt);
}
static void gui_invite_ready(void* arg, int result, const char* link) {
struct chat_invite_build_req* req = arg;
req->inst->invite_gui_request = NULL;
if (result == CHAT_JOIN_CANCELLED) { u_free(req); return; }
size_t ch_len = strlen(req->ch_id);
size_t link_len = link ? strlen(link) : 0;
size_t evt_sz = 1 + ch_len + 8 + 2 + link_len;
uint8_t* evt = u_malloc(evt_sz);
if (!evt) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: event allocation failed"); u_free(req); return; }
evt[0] = (uint8_t)ch_len;
memcpy(evt + 1, req->ch_id, ch_len);
uint16_t u16 = (uint16_t)link_len;
memcpy(evt + 1 + ch_len, &req->request_id, 8);
memcpy(evt + 1 + ch_len + 8, &u16, 2);
if (link_len) memcpy(evt + 1 + ch_len + 10, link, link_len);
chat_event_post(req->inst, CHAT_EVT_INVITE_LINK_READY, evt, (int)evt_sz);
u_free(evt);
u_free(req);
}
void chat_invite_build_link_trampoline(void* arg) {
struct chat_invite_build_req* req = arg;
if (!req) return;
if (!req->inst) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT_SYNC, "invite_build: GUI request without instance"); u_free(req); return; }
if (req->inst->invite_gui_request) chat_invite_build_cancel(req->inst->invite_gui_request->pending);
req->inst->invite_gui_request = req;
req->pending = chat_invite_build_link(req->inst, strtoull(req->ch_id, NULL, 10), req->target_node_id,
req->password[0] ? req->password : NULL, gui_invite_ready, req);
if (!req->pending) gui_invite_ready(req, CHAT_JOIN_ERROR, NULL);
}
Reference in new issue View Git Blame Copy Permalink