diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | Makefile.am | 13 | ||||
| -rw-r--r-- | src/libsystemd-network/sd-pppoe.c | 808 | ||||
| -rw-r--r-- | src/libsystemd-network/test-pppoe.c | 181 | ||||
| -rw-r--r-- | src/systemd/sd-pppoe.h | 53 |
5 files changed, 1056 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore index 2e2c64e28a..6649d19fc7 100644 --- a/.gitignore +++ b/.gitignore @@ -168,6 +168,7 @@ /test-dhcp-option /test-dhcp-server /test-dhcp6-client +/test-pppoe /test-dns-domain /test-icmp6-rs /test-ellipsize diff --git a/Makefile.am b/Makefile.am index ea4da0b3d1..3800a22353 100644 --- a/Makefile.am +++ b/Makefile.am @@ -2958,6 +2958,7 @@ libsystemd_network_la_SOURCES = \ src/systemd/sd-icmp6-nd.h \ src/systemd/sd-dhcp6-client.h \ src/systemd/sd-dhcp6-lease.h \ + src/systemd/sd-pppoe.h \ src/libsystemd-network/sd-dhcp-client.c \ src/libsystemd-network/sd-dhcp-server.c \ src/libsystemd-network/dhcp-network.c \ @@ -2972,6 +2973,7 @@ libsystemd_network_la_SOURCES = \ src/libsystemd-network/ipv4ll-network.c \ src/libsystemd-network/ipv4ll-packet.c \ src/libsystemd-network/ipv4ll-internal.h \ + src/libsystemd-network/sd-pppoe.c \ src/libsystemd-network/network-internal.c \ src/libsystemd-network/network-internal.h \ src/libsystemd-network/sd-icmp6-nd.c \ @@ -3031,6 +3033,14 @@ test_ipv4ll_LDADD = \ libsystemd-internal.la \ libsystemd-shared.la +test_pppoe_SOURCES = \ + src/systemd/sd-pppoe.h \ + src/libsystemd-network/test-pppoe.c + +test_pppoe_LDADD = \ + libsystemd-network.la \ + libsystemd-shared.la + test_icmp6_rs_SOURCES = \ src/systemd/sd-dhcp6-client.h \ src/systemd/sd-icmp6-nd.h \ @@ -3060,6 +3070,9 @@ tests += \ test-icmp6-rs \ test-dhcp6-client +manual_tests += \ + test-pppoe + # ------------------------------------------------------------------------------ if ENABLE_TERMINAL noinst_LTLIBRARIES += \ diff --git a/src/libsystemd-network/sd-pppoe.c b/src/libsystemd-network/sd-pppoe.c new file mode 100644 index 0000000000..17b2d6dab6 --- /dev/null +++ b/src/libsystemd-network/sd-pppoe.c @@ -0,0 +1,808 @@ +/*-*- 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-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 "unaligned.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) \ + unaligned_read_be16(&(tag)->tag_len) + +#define PPPOE_TAG_TYPE(tag) \ + htobe16(unaligned_read_be16(&(tag)->tag_type)) + +#define PPPOE_TAG_SET_LENGTH(tag, len) \ + unaligned_write_be16(&(tag)->tag_len, len) + +#define PPPOE_TAG_SET_TYPE(tag, len) \ + unaligned_write_be16(&(tag)->tag_type, be16toh(len)) + +#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); + 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); + + PPPOE_TAG_SET_LENGTH(tag, tag_len); + PPPOE_TAG_SET_TYPE(tag, 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; + 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("PPPoE: sending PADI failed: %s", strerror(-r)); + + 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("PPPoE: sending PADI failed: %s", strerror(-r)); + + ppp->padr_resend_count = PPPOE_MAX_PADR_RESEND; + ppp->state = PPPOE_STATE_INITIALIZING; + } else { + r = pppoe_send_request(ppp); + if (r < 0) + log_warning("PPPoE: sending PADR failed: %s", strerror(-r)); + } + + 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("PPPoE: colud not receive message from raw socket: %s", + strerror(-r)); + 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; +} diff --git a/src/libsystemd-network/test-pppoe.c b/src/libsystemd-network/test-pppoe.c new file mode 100644 index 0000000000..0d419aa172 --- /dev/null +++ b/src/libsystemd-network/test-pppoe.c @@ -0,0 +1,181 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright (C) 2014 Tom Gundersen <teg@jklm.no> + + 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/>. +***/ + +#include <stdlib.h> +#include <assert.h> +#include <errno.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <unistd.h> + +#include <linux/veth.h> +#include <net/if.h> + +#include "util.h" +#include "socket-util.h" +#include "sd-event.h" +#include "event-util.h" +#include "sd-rtnl.h" +#include "rtnl-util.h" +#include "sd-pppoe.h" + +static void pppoe_handler(sd_pppoe *ppp, int event, void *userdata) { + static int pppoe_state = -1; + sd_event *e = userdata; + + assert_se(ppp); + assert_se(e); + + switch (event) { + case PPPOE_EVENT_RUNNING: + assert_se(pppoe_state == -1); + log_info("running"); + break; + case PPPOE_EVENT_STOPPED: + assert_se(pppoe_state == PPPOE_EVENT_RUNNING); + log_info("stopped"); + assert_se(sd_event_exit(e, 0) >= 0); + break; + default: + assert_not_reached("invalid pppoe event"); + } + + pppoe_state = event; +} + +static int client_run(const char *client_name, sd_event *e) { + sd_pppoe *pppoe; + int client_ifindex; + + client_ifindex = (int) if_nametoindex(client_name); + assert_se(client_ifindex > 0); + + assert_se(sd_pppoe_new(&pppoe) >= 0); + assert_se(sd_pppoe_attach_event(pppoe, e, 0) >= 0); + + assert_se(sd_pppoe_set_ifname(pppoe, "pppoe-client") >= 0); + assert_se(sd_pppoe_set_ifindex(pppoe, client_ifindex) >= 0); + assert_se(sd_pppoe_set_callback(pppoe, pppoe_handler, e) >= 0); + + log_info("starting PPPoE client, it will exit when the server times out and sends PADT"); + + assert_se(sd_pppoe_start(pppoe) >= 0); + + assert_se(sd_event_loop(e) >= 0); + + assert_se(!sd_pppoe_unref(pppoe)); + + return EXIT_SUCCESS; +} + +static int test_pppoe_server(sd_event *e) { + sd_rtnl *rtnl; + sd_rtnl_message *m; + pid_t pid; + int r, client_ifindex, server_ifindex; + + r = unshare(CLONE_NEWNET); + if (r < 0 && errno == EPERM) + return EXIT_TEST_SKIP; + + assert_se(r >= 0); + + assert_se(sd_rtnl_open(&rtnl, 0) >= 0); + assert_se(sd_rtnl_attach_event(rtnl, e, 0) >= 0); + + assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0) >= 0); + assert_se(sd_rtnl_message_append_string(m, IFLA_IFNAME, "pppoe-server") >= 0); + assert_se(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0); + assert_se(sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "veth") >= 0); + assert_se(sd_rtnl_message_open_container(m, VETH_INFO_PEER) >= 0); + assert_se(sd_rtnl_message_append_string(m, IFLA_IFNAME, "pppoe-client") >= 0); + assert_se(sd_rtnl_message_close_container(m) >= 0); + assert_se(sd_rtnl_message_close_container(m) >= 0); + assert_se(sd_rtnl_message_close_container(m) >= 0); + assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0); + + client_ifindex = (int) if_nametoindex("pppoe-client"); + assert_se(client_ifindex > 0); + server_ifindex = (int) if_nametoindex("pppoe-server"); + assert_se(server_ifindex > 0); + + m = sd_rtnl_message_unref(m); + assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, client_ifindex) >= 0); + assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0); + assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0); + + m = sd_rtnl_message_unref(m); + assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, server_ifindex) >= 0); + assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0); + assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0); + + pid = fork(); + assert_se(pid >= 0); + if (pid == 0) { + /* let the client send some discover messages before the server is started */ + sleep(2); + + /* TODO: manage pppoe-server-options */ + execlp("pppoe-server", "pppoe-server", "-F", + "-I", "pppoe-server", + "-C", "Test-AC", + "-S", "Service-Default", + "-S", "Service-First-Auxillary", + "-S", "Service-Second-Auxillary", + NULL); + assert_not_reached("failed to execute pppoe-server. not installed?"); + } + + client_run("pppoe-client", e); + + assert_se(kill(pid, SIGTERM) >= 0); + assert_se(wait_for_terminate(pid, NULL) >= 0); + + assert_se(!sd_rtnl_message_unref(m)); + assert_se(!sd_rtnl_unref(rtnl)); + + return EXIT_SUCCESS; +} + +int main(int argc, char *argv[]) { + _cleanup_event_unref_ sd_event *e = NULL; + + log_set_max_level(LOG_DEBUG); + log_parse_environment(); + log_open(); + + assert_se(sd_event_new(&e) >= 0); + + if (argc == 1) { + log_info("running PPPoE client against local server"); + + return test_pppoe_server(e); + } else if (argc == 2) { + log_info("running PPPoE client over '%s'", argv[1]); + + return client_run(argv[1], e); + } else { + log_error("This program takes one or no arguments.\n" + "\t %s [<ifname>]", program_invocation_short_name); + return EXIT_FAILURE; + } +} diff --git a/src/systemd/sd-pppoe.h b/src/systemd/sd-pppoe.h new file mode 100644 index 0000000000..318d2f033b --- /dev/null +++ b/src/systemd/sd-pppoe.h @@ -0,0 +1,53 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#ifndef foosdpppoefoo +#define foosdpppoefoo + +/*** + 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/>. +***/ + +#include <stdbool.h> +#include <net/ethernet.h> + +#include "sd-event.h" + +#include "sparse-endian.h" + +enum { + PPPOE_EVENT_RUNNING = 0, + PPPOE_EVENT_STOPPED = 1, +}; + +typedef struct sd_pppoe sd_pppoe; +typedef void (*sd_pppoe_cb_t)(sd_pppoe *ppp, int event, void *userdata); + +int sd_pppoe_detach_event(sd_pppoe *ppp); +int sd_pppoe_attach_event(sd_pppoe *ppp, sd_event *event, int priority); +int sd_pppoe_get_channel(sd_pppoe *ppp, int *channel); +int sd_pppoe_set_callback(sd_pppoe *ppp, sd_pppoe_cb_t cb, void *userdata); +int sd_pppoe_set_ifindex(sd_pppoe *ppp, int ifindex); +int sd_pppoe_set_ifname(sd_pppoe *ppp, const char *ifname); +int sd_pppoe_set_service_name(sd_pppoe *ppp, const char *service_name); +int sd_pppoe_start(sd_pppoe *ppp); +int sd_pppoe_stop(sd_pppoe *ppp); +sd_pppoe *sd_pppoe_ref(sd_pppoe *ppp); +sd_pppoe *sd_pppoe_unref(sd_pppoe *ppp); +int sd_pppoe_new (sd_pppoe **ret); + +#endif |