/*
* seg6.c "ip sr/seg6"
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation;
*
* Author: David Lebrun <david.lebrun@uclouvain.be>
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <linux/if.h>
#include <linux/genetlink.h>
#include <linux/seg6_genl.h>
#include <linux/seg6_hmac.h>
#include "utils.h"
#include "ip_common.h"
#include "libgenl.h"
#include "json_print.h"
#define HMAC_KEY_PROMPT "Enter secret for HMAC key ID (blank to delete): "
static void usage(void)
{
fprintf(stderr,
"Usage: ip sr { COMMAND | help }\n"
" ip sr hmac show\n"
" ip sr hmac set KEYID ALGO\n"
" ip sr tunsrc show\n"
" ip sr tunsrc set ADDRESS\n"
"where ALGO := { sha1 | sha256 }\n");
exit(-1);
}
static struct rtnl_handle grth = { .fd = -1 };
static int genl_family = -1;
#define SEG6_REQUEST(_req, _bufsiz, _cmd, _flags) \
GENL_REQUEST(_req, _bufsiz, genl_family, 0, \
SEG6_GENL_VERSION, _cmd, _flags)
static struct {
unsigned int cmd;
inet_prefix addr;
__u32 keyid;
const char *pass;
__u8 alg_id;
} opts;
static void print_dumphmac(struct rtattr *attrs[])
{
char secret[64];
char *algstr;
__u8 slen = rta_getattr_u8(attrs[SEG6_ATTR_SECRETLEN]);
__u8 alg_id = rta_getattr_u8(attrs[SEG6_ATTR_ALGID]);
memset(secret, 0, 64);
if (slen > 63) {
fprintf(stderr, "HMAC secret length %d > 63, truncated\n", slen);
slen = 63;
}
memcpy(secret, RTA_DATA(attrs[SEG6_ATTR_SECRET]), slen);
switch (alg_id) {
case SEG6_HMAC_ALGO_SHA1:
algstr = "sha1";
break;
case SEG6_HMAC_ALGO_SHA256:
algstr = "sha256";
break;
default:
algstr = "<unknown>";
}
print_uint(PRINT_ANY, "hmac", "hmac %u ",
rta_getattr_u32(attrs[SEG6_ATTR_HMACKEYID]));
print_string(PRINT_ANY, "algo", "algo %s ", algstr);
print_string(PRINT_ANY, "secret", "secret \"%s\"\n", secret);
}
static void print_tunsrc(struct rtattr *attrs[])
{
const char *dst
= rt_addr_n2a(AF_INET6, 16,
RTA_DATA(attrs[SEG6_ATTR_DST]));
print_string(PRINT_ANY, "tunsrc",
"tunsrc addr %s\n", dst);
}
static int process_msg(struct nlmsghdr *n, void *arg)
{
struct rtattr *attrs[SEG6_ATTR_MAX + 1];
struct genlmsghdr *ghdr;
int len = n->nlmsg_len;
if (n->nlmsg_type != genl_family)
return -1;
len -= NLMSG_LENGTH(GENL_HDRLEN);
if (len < 0)
return -1;
ghdr = NLMSG_DATA(n);
parse_rtattr(attrs, SEG6_ATTR_MAX, (void *)ghdr + GENL_HDRLEN, len);
open_json_object(NULL);
switch (ghdr->cmd) {
case SEG6_CMD_DUMPHMAC:
print_dumphmac(attrs);
break;
case SEG6_CMD_GET_TUNSRC:
print_tunsrc(attrs);
break;
}
close_json_object();
return 0;
}
static int seg6_do_cmd(void)
{
SEG6_REQUEST(req, 1024, opts.cmd, NLM_F_REQUEST);
struct nlmsghdr *answer;
int repl = 0, dump = 0;
if (genl_family < 0) {
if (rtnl_open_byproto(&grth, 0, NETLINK_GENERIC) < 0) {
fprintf(stderr, "Cannot open generic netlink socket\n");
exit(1);
}
genl_family = genl_resolve_family(&grth, SEG6_GENL_NAME);
if (genl_family < 0)
exit(1);
req.n.nlmsg_type = genl_family;
}
switch (opts.cmd) {
case SEG6_CMD_SETHMAC:
{
addattr32(&req.n, sizeof(req), SEG6_ATTR_HMACKEYID, opts.keyid);
addattr8(&req.n, sizeof(req), SEG6_ATTR_SECRETLEN,
strlen(opts.pass));
addattr8(&req.n, sizeof(req), SEG6_ATTR_ALGID, opts.alg_id);
if (strlen(opts.pass))
addattr_l(&req.n, sizeof(req), SEG6_ATTR_SECRET,
opts.pass, strlen(opts.pass));
break;
}
case SEG6_CMD_SET_TUNSRC:
addattr_l(&req.n, sizeof(req), SEG6_ATTR_DST, opts.addr.data,
sizeof(struct in6_addr));
break;
case SEG6_CMD_DUMPHMAC:
dump = 1;
break;
case SEG6_CMD_GET_TUNSRC:
repl = 1;
break;
}
if (!repl && !dump) {
if (rtnl_talk(&grth, &req.n, NULL) < 0)
return -1;
} else if (repl) {
if (rtnl_talk(&grth, &req.n, &answer) < 0)
return -2;
new_json_obj(json);
if (process_msg(answer, stdout) < 0) {
fprintf(stderr, "Error parsing reply\n");
exit(1);
}
delete_json_obj();
free(answer);
} else {
req.n.nlmsg_flags |= NLM_F_DUMP;
req.n.nlmsg_seq = grth.dump = ++grth.seq;
if (rtnl_send(&grth, &req, req.n.nlmsg_len) < 0) {
perror("Failed to send dump request");
exit(1);
}
new_json_obj(json);
if (rtnl_dump_filter(&grth, process_msg, stdout) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
delete_json_obj();
fflush(stdout);
}
return 0;
}
int do_seg6(int argc, char **argv)
{
if (argc < 1 || matches(*argv, "help") == 0)
usage();
memset(&opts, 0, sizeof(opts));
if (matches(*argv, "hmac") == 0) {
NEXT_ARG();
if (matches(*argv, "show") == 0) {
opts.cmd = SEG6_CMD_DUMPHMAC;
} else if (matches(*argv, "set") == 0) {
NEXT_ARG();
if (get_u32(&opts.keyid, *argv, 0) || opts.keyid == 0)
invarg("hmac KEYID value is invalid", *argv);
NEXT_ARG();
if (strcmp(*argv, "sha1") == 0) {
opts.alg_id = SEG6_HMAC_ALGO_SHA1;
} else if (strcmp(*argv, "sha256") == 0) {
opts.alg_id = SEG6_HMAC_ALGO_SHA256;
} else {
invarg("hmac ALGO value is invalid", *argv);
}
opts.cmd = SEG6_CMD_SETHMAC;
opts.pass = getpass(HMAC_KEY_PROMPT);
} else {
invarg("unknown", *argv);
}
} else if (matches(*argv, "tunsrc") == 0) {
NEXT_ARG();
if (matches(*argv, "show") == 0) {
opts.cmd = SEG6_CMD_GET_TUNSRC;
} else if (matches(*argv, "set") == 0) {
NEXT_ARG();
opts.cmd = SEG6_CMD_SET_TUNSRC;
get_addr(&opts.addr, *argv, AF_INET6);
} else {
invarg("unknown", *argv);
}
} else {
invarg("unknown", *argv);
}
return seg6_do_cmd();
}