picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Systemd/src/libsystemd-network/sd-pppoe.c

802 lines
22 KiB
C
Raw Blame History

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright (C) 2014 Tom Gundersen
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
/* See RFC 2516 */
#include <sys/ioctl.h>
#include <linux/ppp_defs.h>
#include <linux/ppp-ioctl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_pppox.h>
#include "sd-pppoe.h"
#include "event-util.h"
#include "util.h"
#include "socket-util.h"
#include "async.h"
#include "refcnt.h"
#include "utf8.h"
#define PPPOE_MAX_PACKET_SIZE 1484
#define PPPOE_MAX_PADR_RESEND 16
/* TODO: move this to socket-util.h without getting into
* a mess with the includes */
union sockaddr_union_pppox {
struct sockaddr sa;
struct sockaddr_pppox pppox;
};
typedef enum PPPoEState {
PPPOE_STATE_INITIALIZING,
PPPOE_STATE_REQUESTING,
PPPOE_STATE_RUNNING,
PPPOE_STATE_STOPPED,
_PPPOE_STATE_MAX,
_PPPOE_STATE_INVALID = -1,
} PPPoEState;
typedef struct PPPoETags {
char *service_name;
char *ac_name;
uint8_t *host_uniq;
size_t host_uniq_len;
uint8_t *cookie;
size_t cookie_len;
} PPPoETags;
struct sd_pppoe {
RefCount n_ref;
PPPoEState state;
uint64_t host_uniq;
int ifindex;
char *ifname;
sd_event *event;
int event_priority;
int fd;
sd_event_source *io;
sd_event_source *timeout;
int padr_resend_count;
char *service_name;
struct ether_addr peer_mac;
be16_t session_id;
int pppoe_fd;
int channel;
sd_pppoe_cb_t cb;
void *userdata;
PPPoETags tags;
};
#define PPPOE_PACKET_LENGTH(header) \
be16toh((header)->length)
#define PPPOE_PACKET_TAIL(packet) \
(struct pppoe_tag*)((uint8_t*)(packet) + sizeof(struct pppoe_hdr) + PPPOE_PACKET_LENGTH(packet))
#define PPPOE_TAG_LENGTH(tag) \
be16toh((tag)->tag_len)
#define PPPOE_TAG_TYPE(tag) \
(tag)->tag_type
#define PPPOE_TAG_NEXT(tag) \
(struct pppoe_tag *)((uint8_t *)(tag) + sizeof(struct pppoe_tag) + PPPOE_TAG_LENGTH(tag))
#define PPPOE_TAGS_FOREACH(tag, header) \
for (tag = (header)->tag; \
((uint8_t *)(tag) + sizeof(struct pppoe_tag) < (uint8_t*)PPPOE_PACKET_TAIL(header)) && \
(PPPOE_TAG_NEXT(tag) <= PPPOE_PACKET_TAIL(header)) && \
(tag >= (header)->tag) && \
(PPPOE_TAG_TYPE(tag) != PTT_EOL); \
tag = PPPOE_TAG_NEXT(tag))
static void pppoe_tags_clear(PPPoETags *tags) {
free(tags->service_name);
free(tags->ac_name);
free(tags->host_uniq);
free(tags->cookie);
zero(*tags);
}
int sd_pppoe_set_ifindex(sd_pppoe *ppp, int ifindex) {
assert_return(ppp, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
ppp->ifindex = ifindex;
return 0;
}
int sd_pppoe_set_ifname(sd_pppoe *ppp, const char *ifname) {
char *name;
assert_return(ppp, -EINVAL);
assert_return(ifname, -EINVAL);
if (strlen(ifname) > IFNAMSIZ)
return -EINVAL;
name = strdup(ifname);
if (!name)
return -ENOMEM;
free(ppp->ifname);
ppp->ifname = name;
return 0;
}
int sd_pppoe_set_service_name(sd_pppoe *ppp, const char *service_name) {
_cleanup_free_ char *name = NULL;
assert_return(ppp, -EINVAL);
if (service_name) {
name = strdup(service_name);
if (!name)
return -ENOMEM;
}
free(ppp->service_name);
ppp->service_name = name;
name = NULL;
return 0;
}
int sd_pppoe_attach_event(sd_pppoe *ppp, sd_event *event, int priority) {
int r;
assert_return(ppp, -EINVAL);
assert_return(!ppp->event, -EBUSY);
if (event)
ppp->event = sd_event_ref(event);
else {
r = sd_event_default(&ppp->event);
if (r < 0)
return r;
}
ppp->event_priority = priority;
return 0;
}
int sd_pppoe_detach_event(sd_pppoe *ppp) {
assert_return(ppp, -EINVAL);
ppp->event = sd_event_unref(ppp->event);
return 0;
}
sd_pppoe *sd_pppoe_ref(sd_pppoe *ppp) {
if (ppp)
assert_se(REFCNT_INC(ppp->n_ref) >= 2);
return ppp;
}
sd_pppoe *sd_pppoe_unref(sd_pppoe *ppp) {
if (ppp && REFCNT_DEC(ppp->n_ref) <= 0) {
pppoe_tags_clear(&ppp->tags);
free(ppp->ifname);
free(ppp->service_name);
sd_pppoe_stop(ppp);
sd_pppoe_detach_event(ppp);
free(ppp);
}
return NULL;
}
int sd_pppoe_new (sd_pppoe **ret) {
sd_pppoe *ppp;
assert_return(ret, -EINVAL);
ppp = new0(sd_pppoe, 1);
if (!ppp)
return -ENOMEM;
ppp->n_ref = REFCNT_INIT;
ppp->state = _PPPOE_STATE_INVALID;
ppp->ifindex = -1;
ppp->fd = -1;
ppp->pppoe_fd = -1;
ppp->padr_resend_count = PPPOE_MAX_PADR_RESEND;
*ret = ppp;
return 0;
}
int sd_pppoe_get_channel(sd_pppoe *ppp, int *channel) {
assert_return(ppp, -EINVAL);
assert_return(channel, -EINVAL);
assert_return(ppp->pppoe_fd != -1, -EUNATCH);
assert_return(ppp->state == PPPOE_STATE_RUNNING, -EUNATCH);
*channel = ppp->channel;
return 0;
}
int sd_pppoe_set_callback(sd_pppoe *ppp, sd_pppoe_cb_t cb, void *userdata) {
assert_return(ppp, -EINVAL);
ppp->cb = cb;
ppp->userdata = userdata;
return 0;
}
static void pppoe_tag_append(struct pppoe_hdr *packet, size_t packet_size, be16_t tag_type, const void *tag_data, uint16_t tag_len) {
struct pppoe_tag *tag;
assert(packet);
assert(sizeof(struct pppoe_hdr) + PPPOE_PACKET_LENGTH(packet) + sizeof(struct pppoe_tag) + tag_len <= packet_size);
assert(!(!tag_data ^ !tag_len));
tag = PPPOE_PACKET_TAIL(packet);
tag->tag_len = htobe16(tag_len);
tag->tag_type = tag_type;
if (tag_data)
memcpy(tag->tag_data, tag_data, tag_len);
packet->length = htobe16(PPPOE_PACKET_LENGTH(packet) + sizeof(struct pppoe_tag) + tag_len);
}
static int pppoe_send(sd_pppoe *ppp, uint8_t code) {
union sockaddr_union link = {
.ll = {
.sll_family = AF_PACKET,
.sll_protocol = htons(ETH_P_PPP_DISC),
.sll_halen = ETH_ALEN,
},
};
_cleanup_free_ struct pppoe_hdr *packet = NULL;
int r;
assert(ppp);
assert(ppp->fd != -1);
assert(IN_SET(code, PADI_CODE, PADR_CODE, PADT_CODE));
link.ll.sll_ifindex = ppp->ifindex;
if (code == PADI_CODE)
memset(&link.ll.sll_addr, 0xff, ETH_ALEN);
else
memcpy(&link.ll.sll_addr, &ppp->peer_mac, ETH_ALEN);
packet = malloc0(PPPOE_MAX_PACKET_SIZE);
if (!packet)
return -ENOMEM;
packet->ver = 0x1;
packet->type = 0x1;
packet->code = code;
if (code == PADT_CODE)
packet->sid = ppp->session_id;
/* Service-Name */
pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_SRV_NAME,
ppp->service_name, ppp->service_name ? strlen(ppp->service_name) : 0);
/* AC-Cookie */
if (code == PADR_CODE && ppp->tags.cookie)
pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_AC_COOKIE,
ppp->tags.cookie, ppp->tags.cookie_len);
/* Host-Uniq */
if (code != PADT_CODE) {
ppp->host_uniq = random_u64();
pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_HOST_UNIQ,
&ppp->host_uniq, sizeof(ppp->host_uniq));
}
r = sendto(ppp->fd, packet, sizeof(struct pppoe_hdr) + PPPOE_PACKET_LENGTH(packet),
0, &link.sa, sizeof(link.ll));
if (r < 0)
return -errno;
return 0;
}
static int pppoe_timeout(sd_event_source *s, uint64_t usec, void *userdata);
static int pppoe_arm_timeout(sd_pppoe *ppp) {
_cleanup_event_source_unref_ sd_event_source *timeout = NULL;
usec_t next_timeout = 0;
int r;
assert(ppp);
r = sd_event_now(ppp->event, clock_boottime_or_monotonic(), &next_timeout);
if (r == -ENODATA)
next_timeout = now(clock_boottime_or_monotonic());
else if (r < 0)
return r;
next_timeout += 500 * USEC_PER_MSEC;
r = sd_event_add_time(ppp->event, &timeout, clock_boottime_or_monotonic(), next_timeout,
10 * USEC_PER_MSEC, pppoe_timeout, ppp);
if (r < 0)
return r;
r = sd_event_source_set_priority(timeout, ppp->event_priority);
if (r < 0)
return r;
sd_event_source_unref(ppp->timeout);
ppp->timeout = timeout;
timeout = NULL;
return 0;
}
static int pppoe_send_initiation(sd_pppoe *ppp) {
int r;
r = pppoe_send(ppp, PADI_CODE);
if (r < 0)
return r;
log_debug("PPPoE: sent DISCOVER (Service-Name: %s)",
ppp->service_name ? : "");
pppoe_arm_timeout(ppp);
return r;
}
static int pppoe_send_request(sd_pppoe *ppp) {
int r;
r = pppoe_send(ppp, PADR_CODE);
if (r < 0)
return r;
log_debug("PPPoE: sent REQUEST");
ppp->padr_resend_count --;
pppoe_arm_timeout(ppp);
return 0;
}
static int pppoe_send_terminate(sd_pppoe *ppp) {
int r;
r = pppoe_send(ppp, PADT_CODE);
if (r < 0)
return r;
log_debug("PPPoE: sent TERMINATE");
return 0;
}
static int pppoe_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
sd_pppoe *ppp = userdata;
int r;
assert(ppp);
switch (ppp->state) {
case PPPOE_STATE_INITIALIZING:
r = pppoe_send_initiation(ppp);
if (r < 0)
log_warning_errno(r, "PPPoE: sending PADI failed: %m");
break;
case PPPOE_STATE_REQUESTING:
if (ppp->padr_resend_count <= 0) {
log_debug("PPPoE: PADR timed out, restarting PADI");
r = pppoe_send_initiation(ppp);
if (r < 0)
log_warning_errno(r, "PPPoE: sending PADI failed: %m");
ppp->padr_resend_count = PPPOE_MAX_PADR_RESEND;
ppp->state = PPPOE_STATE_INITIALIZING;
} else {
r = pppoe_send_request(ppp);
if (r < 0)
log_warning_errno(r, "PPPoE: sending PADR failed: %m");
}
break;
default:
assert_not_reached("timeout in invalid state");
}
return 0;
}
static int pppoe_tag_parse_binary(struct pppoe_tag *tag, uint8_t **ret, size_t *length) {
uint8_t *data;
assert(ret);
assert(length);
data = memdup(tag->tag_data, PPPOE_TAG_LENGTH(tag));
if (!data)
return -ENOMEM;
free(*ret);
*ret = data;
*length = PPPOE_TAG_LENGTH(tag);
return 0;
}
static int pppoe_tag_parse_string(struct pppoe_tag *tag, char **ret) {
char *string;
assert(ret);
string = strndup(tag->tag_data, PPPOE_TAG_LENGTH(tag));
if (!string)
return -ENOMEM;
free(*ret);
*ret = string;
return 0;
}
static int pppoe_payload_parse(PPPoETags *tags, struct pppoe_hdr *header) {
struct pppoe_tag *tag;
int r;
assert(tags);
pppoe_tags_clear(tags);
PPPOE_TAGS_FOREACH(tag, header) {
switch (PPPOE_TAG_TYPE(tag)) {
case PTT_SRV_NAME:
r = pppoe_tag_parse_string(tag, &tags->service_name);
if (r < 0)
return r;
break;
case PTT_AC_NAME:
r = pppoe_tag_parse_string(tag, &tags->ac_name);
if (r < 0)
return r;
break;
case PTT_HOST_UNIQ:
r = pppoe_tag_parse_binary(tag, &tags->host_uniq, &tags->host_uniq_len);
if (r < 0)
return r;
break;
case PTT_AC_COOKIE:
r = pppoe_tag_parse_binary(tag, &tags->cookie, &tags->cookie_len);
if (r < 0)
return r;
break;
case PTT_SRV_ERR:
case PTT_SYS_ERR:
case PTT_GEN_ERR:
{
_cleanup_free_ char *error = NULL;
/* TODO: do something more sensible with the error messages */
r = pppoe_tag_parse_string(tag, &error);
if (r < 0)
return r;
if (strlen(error) > 0 && utf8_is_valid(error))
log_debug("PPPoE: error - '%s'", error);
else
log_debug("PPPoE: error");
break;
}
default:
log_debug("PPPoE: ignoring unknown PPPoE tag type: 0x%.2x", PPPOE_TAG_TYPE(tag));
}
}
return 0;
}
static int pppoe_open_pppoe_socket(sd_pppoe *ppp) {
int s;
assert(ppp);
assert(ppp->pppoe_fd == -1);
s = socket(AF_PPPOX, SOCK_STREAM, 0);
if (s < 0)
return -errno;
ppp->pppoe_fd = s;
return 0;
}
static int pppoe_connect_pppoe_socket(sd_pppoe *ppp) {
union sockaddr_union_pppox link = {
.pppox = {
.sa_family = AF_PPPOX,
.sa_protocol = PX_PROTO_OE,
},
};
int r, channel;
assert(ppp);
assert(ppp->pppoe_fd != -1);
assert(ppp->session_id);
assert(ppp->ifname);
link.pppox.sa_addr.pppoe.sid = ppp->session_id;
memcpy(link.pppox.sa_addr.pppoe.dev, ppp->ifname, strlen(ppp->ifname));
memcpy(link.pppox.sa_addr.pppoe.remote, &ppp->peer_mac, ETH_ALEN);
r = connect(ppp->pppoe_fd, &link.sa, sizeof(link.pppox));
if (r < 0)
return r;
r = ioctl(ppp->pppoe_fd, PPPIOCGCHAN, &channel);
if (r < 0)
return -errno;
ppp->channel = channel;
return 0;
}
static int pppoe_handle_message(sd_pppoe *ppp, struct pppoe_hdr *packet, struct ether_addr *mac) {
int r;
assert(packet);
if (packet->ver != 0x1 || packet->type != 0x1)
return 0;
r = pppoe_payload_parse(&ppp->tags, packet);
if (r < 0)
return 0;
switch (ppp->state) {
case PPPOE_STATE_INITIALIZING:
if (packet->code != PADO_CODE)
return 0;
if (ppp->tags.host_uniq_len != sizeof(ppp->host_uniq) ||
memcmp(ppp->tags.host_uniq, &ppp->host_uniq, sizeof(ppp->host_uniq)) != 0)
return 0;
log_debug("PPPoE: got OFFER (Peer: "
"%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx; "
"Service-Name: '%s'; AC-Name: '%s')",
mac->ether_addr_octet[0],
mac->ether_addr_octet[1],
mac->ether_addr_octet[2],
mac->ether_addr_octet[3],
mac->ether_addr_octet[4],
mac->ether_addr_octet[5],
ppp->tags.service_name ? : "",
ppp->tags.ac_name ? : "");
memcpy(&ppp->peer_mac, mac, ETH_ALEN);
r = pppoe_open_pppoe_socket(ppp);
if (r < 0) {
log_warning("PPPoE: could not open socket");
return r;
}
r = pppoe_send_request(ppp);
if (r < 0)
return 0;
ppp->state = PPPOE_STATE_REQUESTING;
break;
case PPPOE_STATE_REQUESTING:
if (packet->code != PADS_CODE)
return 0;
if (ppp->tags.host_uniq_len != sizeof(ppp->host_uniq) ||
memcmp(ppp->tags.host_uniq, &ppp->host_uniq,
sizeof(ppp->host_uniq)) != 0)
return 0;
if (memcmp(&ppp->peer_mac, mac, ETH_ALEN) != 0)
return 0;
ppp->session_id = packet->sid;
log_debug("PPPoE: got CONFIRMATION (Session ID: %"PRIu16")",
be16toh(ppp->session_id));
r = pppoe_connect_pppoe_socket(ppp);
if (r < 0) {
log_warning("PPPoE: could not connect socket");
return r;
}
ppp->state = PPPOE_STATE_RUNNING;
ppp->timeout = sd_event_source_unref(ppp->timeout);
assert(ppp->cb);
ppp->cb(ppp, PPPOE_EVENT_RUNNING, ppp->userdata);
break;
case PPPOE_STATE_RUNNING:
if (packet->code != PADT_CODE)
return 0;
if (memcmp(&ppp->peer_mac, mac, ETH_ALEN) != 0)
return 0;
if (ppp->session_id != packet->sid)
return 0;
log_debug("PPPoE: got TERMINATE");
ppp->state = PPPOE_STATE_STOPPED;
assert(ppp->cb);
ppp->cb(ppp, PPPOE_EVENT_STOPPED, ppp->userdata);
break;
case PPPOE_STATE_STOPPED:
break;
default:
assert_not_reached("PPPoE: invalid state when receiving message");
}
return 0;
}
static int pppoe_receive_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
sd_pppoe *ppp = userdata;
_cleanup_free_ struct pppoe_hdr *packet = NULL;
union sockaddr_union link = {};
socklen_t addrlen = sizeof(link);
int buflen = 0, len, r;
assert(ppp);
assert(fd != -1);
r = ioctl(fd, FIONREAD, &buflen);
if (r < 0)
return r;
if (buflen < 0)
/* this can't be right */
return -EIO;
packet = malloc0(buflen);
if (!packet)
return -ENOMEM;
len = recvfrom(fd, packet, buflen, 0, &link.sa, &addrlen);
if (len < 0) {
log_warning_errno(r, "PPPoE: could not receive message from raw socket: %m");
return 0;
} else if ((size_t)len < sizeof(struct pppoe_hdr))
return 0;
else if ((size_t)len != sizeof(struct pppoe_hdr) + PPPOE_PACKET_LENGTH(packet))
return 0;
if (link.ll.sll_halen != ETH_ALEN)
/* not ethernet? */
return 0;
r = pppoe_handle_message(ppp, packet, (struct ether_addr*)&link.ll.sll_addr);
if (r < 0)
return r;
return 1;
}
int sd_pppoe_start(sd_pppoe *ppp) {
union sockaddr_union link = {
.ll = {
.sll_family = AF_PACKET,
.sll_protocol = htons(ETH_P_PPP_DISC),
},
};
_cleanup_close_ int s = -1;
_cleanup_event_source_unref_ sd_event_source *io = NULL;
int r;
assert_return(ppp, -EINVAL);
assert_return(ppp->fd == -1, -EBUSY);
assert_return(!ppp->io, -EBUSY);
assert_return(ppp->ifindex > 0, -EUNATCH);
assert_return(ppp->ifname, -EUNATCH);
assert_return(ppp->event, -EUNATCH);
assert_return(ppp->cb, -EUNATCH);
s = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
if (s < 0)
return -errno;
link.ll.sll_ifindex = ppp->ifindex;
r = bind(s, &link.sa, sizeof(link.ll));
if (r < 0)
return r;
r = sd_event_add_io(ppp->event, &io,
s, EPOLLIN, pppoe_receive_message,
ppp);
if (r < 0)
return r;
r = sd_event_source_set_priority(io, ppp->event_priority);
if (r < 0)
return r;
ppp->fd = s;
s = -1;
ppp->io = io;
io = NULL;
r = pppoe_send_initiation(ppp);
if (r < 0)
return r;
ppp->state = PPPOE_STATE_INITIALIZING;
return 0;
}
int sd_pppoe_stop(sd_pppoe *ppp) {
assert_return(ppp, -EINVAL);
if (ppp->state == PPPOE_STATE_RUNNING)
pppoe_send_terminate(ppp);
ppp->io = sd_event_source_unref(ppp->io);
ppp->timeout = sd_event_source_unref(ppp->timeout);
ppp->fd = asynchronous_close(ppp->fd);
ppp->pppoe_fd = asynchronous_close(ppp->pppoe_fd);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink