[PATCH 2/6] Generic PPP control protocol support
Kristen Carlson Accardi
kristen at linux.intel.com
Mon Mar 22 17:05:57 PDT 2010
Implement a generic protocol that can be shared by both the LCP and the
NCP implementation.
---
Makefile.am | 3 +-
gatchat/ppp.h | 2 +
gatchat/ppp_cp.c | 1503 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
gatchat/ppp_cp.h | 139 +++++
4 files changed, 1646 insertions(+), 1 deletions(-)
create mode 100644 gatchat/ppp_cp.c
create mode 100644 gatchat/ppp_cp.h
diff --git a/Makefile.am b/Makefile.am
index 6891d16..a58f10e 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -57,7 +57,8 @@ gatchat_sources = gatchat/gatchat.h gatchat/gatchat.c \
gatchat/gat.h \
gatchat/gatserver.h gatchat/gatserver.c \
gatchat/gatppp.c gatchat/gatppp.h \
- gatchat/ppp.c gatchat/ppp.h
+ gatchat/ppp.c gatchat/ppp.h gatchat/ppp_cp.h \
+ gatchat/ppp_cp.c
udev_files = plugins/ofono.rules
diff --git a/gatchat/ppp.h b/gatchat/ppp.h
index 573c967..0f39440 100644
--- a/gatchat/ppp.h
+++ b/gatchat/ppp.h
@@ -18,6 +18,8 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
+#include "ppp_cp.h"
+
#define DEFAULT_MRU 1500
#define BUFFERSZ DEFAULT_MRU*2
#define DEFAULT_ACCM 0x00000000
diff --git a/gatchat/ppp_cp.c b/gatchat/ppp_cp.c
new file mode 100644
index 0000000..6967f9d
--- /dev/null
+++ b/gatchat/ppp_cp.c
@@ -0,0 +1,1503 @@
+/*
+ *
+ * PPP library with GLib integration
+ *
+ * Copyright (C) 2009-2010 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <termios.h>
+#include <glib.h>
+#include <arpa/inet.h>
+#include "gatppp.h"
+#include "ppp.h"
+
+#ifdef DEBUG
+const char *pppcp_state_strings[] =
+ {"INITIAL", "STARTING", "CLOSED", "STOPPED", "CLOSING", "STOPPING",
+ "REQSENT", "ACKRCVD", "ACKSENT", "OPENED" };
+
+#define pppcp_trace(p) \
+ (g_print("%s: current state %d:%s\n", __FUNCTION__, \
+ p->state, pppcp_state_strings[p->state]))
+#else
+#define pppcp_trace(p)
+#endif
+
+#define pppcp_to_ppp_packet(p) \
+ (p-PPP_HEADROOM)
+
+struct pppcp_event {
+ enum pppcp_event_type type;
+ gint len;
+ guint8 data[0];
+};
+
+#define INITIAL_RESTART_TIMEOUT 3000
+#define MAX_TERMINATE 2
+#define MAX_CONFIGURE 10
+#define MAX_FAILURE 5
+#define CP_HEADER_SZ 4
+
+static struct pppcp_packet *pppcp_packet_new(struct pppcp_data *data,
+ guint type, guint bufferlen)
+{
+ struct pppcp_packet *packet;
+ struct ppp_header *ppp_packet;
+ guint16 packet_length = bufferlen + sizeof(*packet);
+
+ ppp_packet = g_try_malloc0(packet_length + 2);
+ if (!ppp_packet)
+ return NULL;
+
+ /* add our protocol information */
+ ppp_packet->proto = htons(data->proto);
+
+ /* advance past protocol to add CP header information */
+ packet = (struct pppcp_packet *) (ppp_packet->info);
+
+ packet->length = htons(packet_length);
+ packet->code = type;
+ return packet;
+}
+
+static gboolean pppcp_timeout(gpointer user_data)
+{
+ struct pppcp_data *data = user_data;
+
+ pppcp_trace(data);
+
+ data->restart_timer = 0;
+
+ if (data->restart_counter)
+ pppcp_generate_event(data, TO_PLUS, NULL, 0);
+ else
+ pppcp_generate_event(data, TO_MINUS, NULL, 0);
+ return FALSE;
+}
+
+static void pppcp_start_timer(struct pppcp_data *data)
+{
+ data->restart_timer = g_timeout_add(data->restart_interval,
+ pppcp_timeout, data);
+}
+
+static void pppcp_stop_timer(struct pppcp_data *data)
+{
+ if (data->restart_timer) {
+ g_source_remove(data->restart_timer);
+ data->restart_timer = 0;
+ }
+}
+
+static gboolean pppcp_timer_is_running(struct pppcp_data *data)
+{
+ /* determine if the restart timer is running */
+ if (data->restart_timer)
+ return TRUE;
+ return FALSE;
+}
+
+static struct pppcp_event *pppcp_event_new(enum pppcp_event_type type,
+ gpointer event_data, guint len)
+{
+ struct pppcp_event *event;
+ guint8 *data = event_data;
+
+ event = g_try_malloc0(sizeof(struct pppcp_event) + len);
+ if (!event)
+ return NULL;
+
+ event->type = type;
+ memcpy(event->data, data, len);
+ event->len = len;
+ return event;
+}
+
+static struct pppcp_event *pppcp_get_event(struct pppcp_data *data)
+{
+ return g_queue_pop_head(data->event_queue);
+}
+
+/* actions */
+/* log an illegal event, but otherwise do nothing */
+static void pppcp_illegal_event(guint8 state, guint8 type)
+{
+ g_printerr("Illegal event %d while in state %d\n", type, state);
+}
+
+static void pppcp_this_layer_up(struct pppcp_data *data)
+{
+ struct pppcp_action *action = data->action;
+
+ if (action->this_layer_up)
+ action->this_layer_up(data);
+}
+
+static void pppcp_this_layer_down(struct pppcp_data *data)
+{
+ struct pppcp_action *action = data->action;
+
+ if (action->this_layer_up)
+ action->this_layer_down(data);
+}
+
+static void pppcp_this_layer_started(struct pppcp_data *data)
+{
+ struct pppcp_action *action = data->action;
+
+ if (action->this_layer_up)
+ action->this_layer_started(data);
+}
+
+static void pppcp_this_layer_finished(struct pppcp_data *data)
+{
+ struct pppcp_action *action = data->action;
+
+ if (action->this_layer_up)
+ action->this_layer_finished(data);
+}
+
+static void pppcp_free_option(gpointer data, gpointer user_data)
+{
+ struct ppp_option *option = data;
+ g_free(option);
+}
+
+static void pppcp_clear_options(struct pppcp_data *data)
+{
+ g_list_foreach(data->acceptable_options, pppcp_free_option, NULL);
+ g_list_foreach(data->unacceptable_options, pppcp_free_option, NULL);
+ g_list_foreach(data->rejected_options, pppcp_free_option, NULL);
+ g_list_free(data->acceptable_options);
+ g_list_free(data->unacceptable_options);
+ g_list_free(data->rejected_options);
+ data->acceptable_options = NULL;
+ data->unacceptable_options = NULL;
+ data->rejected_options = NULL;
+}
+
+/*
+ * set the restart counter to either max-terminate
+ * or max-configure. The counter is decremented for
+ * each transmission, including the first.
+ */
+static void pppcp_initialize_restart_count(struct pppcp_data *data, guint value)
+{
+ pppcp_trace(data);
+ pppcp_clear_options(data);
+ data->restart_counter = value;
+}
+
+/*
+ * set restart counter to zero
+ */
+static void pppcp_zero_restart_count(struct pppcp_data *data)
+{
+ data->restart_counter = 0;
+}
+
+/*
+ * TBD - generate new identifier for packet
+ */
+static guint8 new_identity(struct pppcp_data *data, guint prev_identifier)
+{
+ return prev_identifier+1;
+}
+
+static void get_option_length(gpointer data, gpointer user_data)
+{
+ struct ppp_option *option = data;
+ guint8 *length = user_data;
+
+ *length += option->length;
+}
+
+static void copy_option(gpointer data, gpointer user_data)
+{
+ struct ppp_option *option = data;
+ guint8 **location = user_data;
+ memcpy(*location, (guint8 *) option, option->length);
+ *location += option->length;
+}
+
+void pppcp_add_config_option(struct pppcp_data *data, struct ppp_option *option)
+{
+ data->config_options = g_list_append(data->config_options, option);
+}
+
+/*
+ * transmit a Configure-Request packet
+ * start the restart timer
+ * decrement the restart counter
+ */
+static void pppcp_send_configure_request(struct pppcp_data *data)
+{
+ struct pppcp_packet *packet;
+ guint8 olength = 0;
+ guint8 *odata;
+
+ pppcp_trace(data);
+
+ /* figure out how much space to allocate for options */
+ g_list_foreach(data->config_options, get_option_length, &olength);
+
+ packet = pppcp_packet_new(data, CONFIGURE_REQUEST, olength);
+
+ /* copy config options into packet data */
+ odata = packet->data;
+ g_list_foreach(data->config_options, copy_option, &odata);
+
+ /*
+ * if this is the first request, we need a new identifier.
+ * if this is a retransmission, leave the identifier alone.
+ */
+ if (data->restart_counter == data->max_configure)
+ data->config_identifier =
+ new_identity(data, data->config_identifier);
+ packet->identifier = data->config_identifier;
+
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+
+ /* XXX don't retransmit right now */
+#if 0
+ data->restart_counter--;
+ pppcp_start_timer(data);
+#endif
+}
+
+/*
+ * transmit a Configure-Ack packet
+ */
+static void pppcp_send_configure_ack(struct pppcp_data *data,
+ guint8 *request)
+{
+ struct pppcp_packet *packet;
+ struct pppcp_packet *pppcp_header = (struct pppcp_packet *) request;
+ guint len;
+ guint8 *odata;
+
+ pppcp_trace(data);
+
+ /* subtract for header. */
+ len = ntohs(pppcp_header->length) - sizeof(*packet);
+
+ packet = pppcp_packet_new(data, CONFIGURE_ACK, len);
+
+ /* copy the applied options in. */
+ odata = packet->data;
+
+ if (g_list_length(data->acceptable_options))
+ g_list_foreach(data->acceptable_options, copy_option, &odata);
+
+ /* match identifier of the request */
+ packet->identifier = pppcp_header->identifier;
+
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+}
+
+/*
+ * transmit a Configure-Nak or Configure-Reject packet
+ */
+static void pppcp_send_configure_nak(struct pppcp_data *data,
+ guint8 *configure_packet)
+{
+ struct pppcp_packet *packet;
+ struct pppcp_packet *pppcp_header =
+ (struct pppcp_packet *) configure_packet;
+ guint8 olength = 0;
+ guint8 *odata;
+
+ /* if we have any rejected options, send a config-reject */
+ if (g_list_length(data->rejected_options)) {
+ /* figure out how much space to allocate for options */
+ g_list_foreach(data->rejected_options, get_option_length,
+ &olength);
+
+ packet = pppcp_packet_new(data, CONFIGURE_REJECT, olength);
+
+ /* copy the rejected options in. */
+ odata = packet->data;
+ g_list_foreach(data->rejected_options, copy_option,
+ &odata);
+
+ packet->identifier = pppcp_header->identifier;
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+
+ }
+ /* if we have any unacceptable options, send a config-nak */
+ if (g_list_length(data->unacceptable_options)) {
+ olength = 0;
+
+ /* figure out how much space to allocate for options */
+ g_list_foreach(data->unacceptable_options, get_option_length,
+ &olength);
+
+ packet = pppcp_packet_new(data, CONFIGURE_NAK, olength);
+
+ /* copy the unacceptable options in. */
+ odata = packet->data;
+ g_list_foreach(data->unacceptable_options, copy_option,
+ &odata);
+
+ packet->identifier = pppcp_header->identifier;
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+ }
+}
+
+/*
+ * transmit a Terminate-Request packet.
+ * start the restart timer.
+ * decrement the restart counter
+ */
+static void pppcp_send_terminate_request(struct pppcp_data *data)
+{
+ struct pppcp_packet *packet;
+
+ /*
+ * the data field can be used by the sender (us).
+ * leave this empty for now.
+ */
+ packet = pppcp_packet_new(data, TERMINATE_REQUEST, 0);
+
+ /*
+ * Is this a retransmission? If so, do not change
+ * the identifier. If not, we need a fresh identity.
+ */
+ if (data->restart_counter == data->max_terminate)
+ data->terminate_identifier =
+ new_identity(data, data->terminate_identifier);
+ packet->identifier = data->terminate_identifier;
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+ data->restart_counter--;
+ pppcp_start_timer(data);
+}
+
+/*
+ * transmit a Terminate-Ack packet
+ */
+static void pppcp_send_terminate_ack(struct pppcp_data *data,
+ guint8 *request)
+{
+ struct pppcp_packet *packet;
+ struct pppcp_packet *pppcp_header = (struct pppcp_packet *) request;
+
+ packet = pppcp_packet_new(data, TERMINATE_ACK, 0);
+
+ /* match identifier of the request */
+ packet->identifier = pppcp_header->identifier;
+
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(pppcp_header->length));
+}
+
+/*
+ * transmit a Code-Reject packet
+ *
+ * XXX this seg faults.
+ */
+static void pppcp_send_code_reject(struct pppcp_data *data,
+ guint8 *rejected_packet)
+{
+ struct pppcp_packet *packet;
+
+ packet = pppcp_packet_new(data, CODE_REJECT,
+ ntohs(((struct pppcp_packet *) rejected_packet)->length));
+
+ /*
+ * Identifier must be changed for each Code-Reject sent
+ */
+ packet->identifier = new_identity(data, data->reject_identifier);
+
+ /*
+ * rejected packet should be copied in, but it should be
+ * truncated if it needs to be to comply with mtu requirement
+ */
+ memcpy(packet->data, rejected_packet,
+ ntohs(packet->length - CP_HEADER_SZ));
+
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+}
+
+/*
+ * transmit an Echo-Reply packet
+ */
+static void pppcp_send_echo_reply(struct pppcp_data *data,
+ guint8 *request)
+{
+ struct pppcp_packet *packet;
+ struct pppcp_packet *header = (struct pppcp_packet *) request;
+
+ /*
+ * 0 bytes for data, 4 bytes for magic number
+ */
+ packet = pppcp_packet_new(data, ECHO_REPLY, 4);
+
+ /*
+ * match identifier of request
+ */
+ packet->identifier = header->identifier;
+
+ /* magic number? */
+ ppp_transmit(data->ppp, pppcp_to_ppp_packet((guint8 *) packet),
+ ntohs(packet->length));
+
+}
+
+static void pppcp_transition_state(enum pppcp_state new_state,
+ struct pppcp_data *data)
+{
+ /*
+ * if switching from a state where
+ * TO events occur, to one where they
+ * may not, shut off the timer
+ */
+ switch (new_state) {
+ case INITIAL:
+ case STARTING:
+ case CLOSED:
+ case STOPPED:
+ case OPENED:
+ /* if timer is running, stop it */
+ if (pppcp_timer_is_running(data))
+ pppcp_stop_timer(data);
+ break;
+ case CLOSING:
+ case STOPPING:
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ break;
+ }
+ data->state = new_state;
+}
+
+static void pppcp_up_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+ switch (data->state) {
+ case INITIAL:
+ /* switch state to CLOSED */
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case STARTING:
+ /* irc, scr/6 */
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case CLOSED:
+ case STOPPED:
+ case OPENED:
+ case CLOSING:
+ case STOPPING:
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_illegal_event(data->state, UP);
+ }
+}
+
+static void pppcp_down_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ switch (data->state) {
+ case CLOSED:
+ pppcp_transition_state(INITIAL, data);
+ break;
+ case STOPPED:
+ /* tls/1 */
+ pppcp_transition_state(STARTING, data);
+ pppcp_this_layer_started(data);
+ break;
+ case CLOSING:
+ pppcp_transition_state(INITIAL, data);
+ break;
+ case STOPPING:
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_transition_state(STARTING, data);
+ break;
+ case OPENED:
+ pppcp_transition_state(STARTING, data);
+ pppcp_this_layer_down(data);
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, DOWN);
+ /* illegal */
+ }
+}
+
+static void pppcp_open_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+ switch (data->state) {
+ case INITIAL:
+ /* tls/1 */
+ pppcp_transition_state(STARTING, data);
+ pppcp_this_layer_started(data);
+ break;
+ case STARTING:
+ pppcp_transition_state(STARTING, data);
+ break;
+ case CLOSED:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case STOPPED:
+ /* 3r */
+ pppcp_transition_state(STOPPED, data);
+ break;
+ case CLOSING:
+ case STOPPING:
+ /* 5r */
+ pppcp_transition_state(STOPPING, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_transition_state(data->state, data);
+ break;
+ case OPENED:
+ /* 9r */
+ pppcp_transition_state(data->state, data);
+ break;
+ }
+}
+
+static void pppcp_close_event(struct pppcp_data *data, guint8* packet, guint len)
+{
+ switch (data->state) {
+ case INITIAL:
+ pppcp_transition_state(INITIAL, data);
+ break;
+ case STARTING:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(INITIAL, data);
+ break;
+ case CLOSED:
+ case STOPPED:
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(CLOSING, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_initialize_restart_count(data, data->max_terminate);
+ pppcp_send_terminate_request(data);
+ pppcp_transition_state(CLOSING, data);
+ break;
+ }
+}
+
+static void pppcp_to_plus_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSING:
+ pppcp_send_terminate_request(data);
+ pppcp_transition_state(CLOSING, data);
+ break;
+ case STOPPING:
+ pppcp_send_terminate_request(data);
+ pppcp_transition_state(STOPPING, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case ACKSENT:
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ case CLOSED:
+ case STOPPED:
+ case OPENED:
+ pppcp_illegal_event(data->state, TO_PLUS);
+ }
+}
+
+static void pppcp_to_minus_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+ switch (data->state) {
+ case CLOSING:
+ pppcp_transition_state(CLOSED, data);
+ pppcp_this_layer_finished(data);
+ break;
+ case STOPPING:
+ pppcp_transition_state(STOPPED, data);
+ pppcp_this_layer_finished(data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ /* tlf/3p */
+ pppcp_transition_state(STOPPED, data);
+ pppcp_this_layer_finished(data);
+ break;
+ case INITIAL:
+ case STARTING:
+ case CLOSED:
+ case STOPPED:
+ case OPENED:
+ pppcp_illegal_event(data->state, TO_MINUS);
+ }
+}
+
+static void pppcp_rcr_plus_event(struct pppcp_data *data,
+ guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+ switch (data->state) {
+ case CLOSED:
+ pppcp_send_terminate_ack(data, packet);
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case STOPPED:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_send_configure_ack(data, packet);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(data->state, data);
+ break;
+ case REQSENT:
+ pppcp_send_configure_ack(data, packet);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case ACKRCVD:
+ pppcp_send_configure_ack(data, packet);
+ pppcp_this_layer_up(data);
+ pppcp_transition_state(OPENED, data);
+ break;
+ case ACKSENT:
+ pppcp_send_configure_ack(data, packet);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_send_configure_request(data);
+ pppcp_send_configure_ack(data, packet);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RCR_PLUS);
+ }
+}
+
+static void pppcp_rcr_minus_event(struct pppcp_data *data,
+ guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ pppcp_send_terminate_ack(data, packet);
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case STOPPED:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_send_configure_nak(data, packet);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(data->state, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ pppcp_send_configure_nak(data, packet);
+ pppcp_transition_state(data->state, data);
+ break;
+ case ACKSENT:
+ pppcp_send_configure_nak(data, packet);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_send_configure_request(data);
+ pppcp_send_configure_nak(data, packet);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RCR_MINUS);
+ }
+}
+
+static void pppcp_rca_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ pppcp_send_terminate_ack(data, packet);
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(data->state, data);
+ break;
+ case REQSENT:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_transition_state(ACKRCVD, data);
+ break;
+ case ACKRCVD:
+ /* scr/6x */
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ case ACKSENT:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_this_layer_up(data);
+ pppcp_transition_state(OPENED, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RCA);
+ }
+}
+
+static void pppcp_rcn_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ pppcp_send_terminate_ack(data, packet);
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(data->state, data);
+ case REQSENT:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case ACKRCVD:
+ /* scr/6x */
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case ACKSENT:
+ pppcp_initialize_restart_count(data, data->max_configure);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RCN);
+ }
+}
+
+static void pppcp_rtr_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ pppcp_send_terminate_ack(data, packet);
+ case CLOSING:
+ case STOPPING:
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_send_terminate_ack(data, packet);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_zero_restart_count(data);
+ pppcp_send_terminate_ack(data, packet);
+ pppcp_transition_state(STOPPING, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RTR);
+ }
+}
+
+static void pppcp_rta_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ pppcp_transition_state(data->state, data);
+ break;
+ case CLOSING:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case STOPPING:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(STOPPED, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case ACKSENT:
+ pppcp_transition_state(ACKSENT, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_send_configure_request(data);
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RTA);
+ }
+}
+
+static void pppcp_ruc_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ case CLOSING:
+ case STOPPING:
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ case OPENED:
+ pppcp_send_code_reject(data, packet);
+ pppcp_transition_state(data->state, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RUC);
+ }
+}
+
+static void pppcp_rxj_plus_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ case CLOSING:
+ case STOPPING:
+ pppcp_transition_state(data->state, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ pppcp_transition_state(REQSENT, data);
+ break;
+ case ACKSENT:
+ case OPENED:
+ pppcp_transition_state(data->state, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RXJ_PLUS);
+ }
+}
+
+static void pppcp_rxj_minus_event(struct pppcp_data *data,
+ guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(data->state, data);
+ break;
+ case CLOSING:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(CLOSED, data);
+ break;
+ case STOPPING:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(STOPPED, data);
+ break;
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_this_layer_finished(data);
+ pppcp_transition_state(STOPPED, data);
+ break;
+ case OPENED:
+ pppcp_this_layer_down(data);
+ pppcp_initialize_restart_count(data, data->max_terminate);
+ pppcp_send_terminate_request(data);
+ pppcp_transition_state(STOPPING, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RXJ_MINUS);
+ }
+}
+
+static void pppcp_rxr_event(struct pppcp_data *data, guint8 *packet, guint len)
+{
+ pppcp_trace(data);
+
+ switch (data->state) {
+ case CLOSED:
+ case STOPPED:
+ case CLOSING:
+ case STOPPING:
+ case REQSENT:
+ case ACKRCVD:
+ case ACKSENT:
+ pppcp_transition_state(data->state, data);
+ break;
+ case OPENED:
+ pppcp_send_echo_reply(data, packet);
+ pppcp_transition_state(OPENED, data);
+ break;
+ case INITIAL:
+ case STARTING:
+ pppcp_illegal_event(data->state, RXR);
+ }
+}
+
+static void pppcp_handle_event(gpointer user_data)
+{
+ struct pppcp_event *event;
+ struct pppcp_data *data = user_data;
+
+ while ((event = pppcp_get_event(data))) {
+ if (event->type > RXR)
+ pppcp_illegal_event(data->state, event->type);
+ else
+ data->event_ops[event->type](data, event->data,
+ event->len);
+ g_free(event);
+ }
+}
+
+/*
+ * send the event handler a new event to process
+ */
+void pppcp_generate_event(struct pppcp_data *data,
+ enum pppcp_event_type event_type,
+ gpointer event_data, guint data_len)
+{
+ struct pppcp_event *event;
+
+ event = pppcp_event_new(event_type, event_data, data_len);
+ if (event)
+ g_queue_push_tail(data->event_queue, event);
+ pppcp_handle_event(data);
+}
+
+static gint is_option(gconstpointer a, gconstpointer b)
+{
+ const struct ppp_option *o = a;
+ guint8 otype = (guint8) GPOINTER_TO_UINT(b);
+
+ if (o->type == otype)
+ return 0;
+ else
+ return -1;
+}
+
+static void verify_config_option(gpointer elem, gpointer user_data)
+{
+ struct ppp_option *config = elem;
+ struct pppcp_data *data = user_data;
+ GList *list = NULL;
+ struct ppp_option *option;
+
+ /*
+ * determine whether this config option is in the
+ * acceptable options list
+ */
+ if (g_list_length(data->acceptable_options))
+ list = g_list_find_custom(data->acceptable_options,
+ GUINT_TO_POINTER(config->type),
+ is_option);
+ if (!list) {
+ /*
+ * if the option did not exist, we need to store a copy
+ * of the option in the unacceptable_options list so it
+ * can be nak'ed.
+ */
+ option = g_try_malloc0(config->length);
+ if (option == NULL)
+ return;
+ option->type = config->type;
+ option->length = config->length;
+ data->unacceptable_options =
+ g_list_append(data->unacceptable_options, option);
+ }
+
+}
+
+static void remove_config_option(gpointer elem, gpointer user_data)
+{
+ struct ppp_option *config = elem;
+ struct pppcp_data *data = user_data;
+ GList *list;
+
+ /*
+ * determine whether this config option is in the
+ * applied options list
+ */
+ if (g_list_length(data->config_options)) {
+ list = g_list_find_custom(data->config_options,
+ GUINT_TO_POINTER(config->type),
+ is_option);
+ if (list)
+ data->config_options =
+ g_list_delete_link(data->config_options, list);
+ }
+}
+
+static guint8 pppcp_process_configure_request(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ gint len;
+ int i = 0;
+ struct ppp_option *option;
+ enum option_rval rval = OPTION_ERR;
+ struct pppcp_action *action = data->action;
+
+ pppcp_trace(data);
+
+ len = ntohs(packet->length) - CP_HEADER_SZ;
+
+ /*
+ * check the options.
+ */
+ while (i < len) {
+ guint8 otype = packet->data[i];
+ guint8 olen = packet->data[i+1];
+ option = g_try_malloc0(olen);
+ if (option == NULL)
+ break;
+ option->type = otype;
+ option->length = olen;
+ memcpy(option->data, &packet->data[i+2], olen-2);
+ if (action->option_scan)
+ rval = action->option_scan(option, data);
+ switch (rval) {
+ case OPTION_ACCEPT:
+ data->acceptable_options =
+ g_list_append(data->acceptable_options, option);
+ break;
+ case OPTION_REJECT:
+ data->rejected_options =
+ g_list_append(data->rejected_options, option);
+ break;
+ case OPTION_NAK:
+ data->unacceptable_options =
+ g_list_append(data->unacceptable_options,
+ option);
+ break;
+ case OPTION_ERR:
+ g_printerr("unhandled option type %d\n", otype);
+ }
+ /* skip ahead to the next option */
+ i += olen;
+ }
+
+ /* make sure all required config options were included */
+ g_list_foreach(data->config_options, verify_config_option, data);
+
+ if (g_list_length(data->unacceptable_options) ||
+ g_list_length(data->rejected_options))
+ return RCR_MINUS;
+
+ /*
+ * all options were acceptable, so we should apply them before
+ * sending a configure-ack
+ *
+ * Remove all applied options from the config_option list. The
+ * protocol will have to re-add them if they want them renegotiated
+ * when the ppp goes down.
+ */
+ if (action->option_process) {
+ g_list_foreach(data->acceptable_options,
+ action->option_process, data->priv);
+ g_list_foreach(data->acceptable_options, remove_config_option,
+ data);
+ }
+
+ return RCR_PLUS;
+}
+
+static guint8 pppcp_process_configure_ack(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ guint len;
+ GList *list;
+ struct ppp_option *acked_option;
+ guint i = 0;
+ struct pppcp_action *action = data->action;
+
+ pppcp_trace(data);
+
+ len = ntohs(packet->length) - CP_HEADER_SZ;
+
+ /* if identifiers don't match, we should silently discard */
+ if (packet->identifier != data->config_identifier) {
+ g_printerr("received an ack id %d, but config id is %d\n",
+ packet->identifier, data->config_identifier);
+ return 0;
+ }
+
+ /*
+ * check each acked option. If it is what we requested,
+ * then we can apply these option values.
+ *
+ * XXX what if it isn't? Do this correctly -- for now
+ * we are just going to assume that all options matched
+ * and apply them.
+ */
+ while (i < len) {
+ guint8 otype = packet->data[i];
+ guint8 olen = packet->data[i + 1];
+ acked_option = g_try_malloc0(olen);
+ if (acked_option == NULL)
+ break;
+ acked_option->type = otype;
+ acked_option->length = olen;
+ memcpy(acked_option->data, &packet->data[i + 2], olen - 2);
+ list = g_list_find_custom(data->config_options,
+ GUINT_TO_POINTER(acked_option->type),
+ is_option);
+ if (list) {
+ /*
+ * once we've applied the option, delete it from
+ * the config_options list.
+ */
+ if (action->option_process)
+ action->option_process(acked_option,
+ data->priv);
+ data->config_options =
+ g_list_delete_link(data->config_options, list);
+ } else
+ g_printerr("oops -- found acked option %d we didn't request\n", acked_option->type);
+ g_free(acked_option);
+
+ /* skip ahead to the next option */
+ i += olen;
+ }
+ return RCA;
+}
+
+static guint8 pppcp_process_configure_nak(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ guint len;
+ GList *list;
+ struct ppp_option *naked_option;
+ struct ppp_option *config_option;
+ guint i = 0;
+ enum option_rval rval = OPTION_ERR;
+ struct pppcp_action *action = data->action;
+
+ pppcp_trace(data);
+
+ len = ntohs(packet->length) - CP_HEADER_SZ;
+
+ /* if identifiers don't match, we should silently discard */
+ if (packet->identifier != data->config_identifier)
+ return 0;
+
+ /*
+ * check each unacceptable option. If it is acceptable, then
+ * we can resend the configure request with this value. we need
+ * to check the current config options to see if we need to
+ * modify a value there, or add a new option.
+ */
+ while (i < len) {
+ guint8 otype = packet->data[i];
+ guint8 olen = packet->data[i+1];
+ naked_option = g_try_malloc0(olen);
+ if (naked_option == NULL)
+ break;
+ naked_option->type = otype;
+ naked_option->length = olen;
+ memcpy(naked_option->data, &packet->data[i + 2], olen - 2);
+ if (action->option_scan)
+ rval = action->option_scan(naked_option, data);
+ if (rval == OPTION_ACCEPT) {
+ /*
+ * check the current config options to see if they
+ * match.
+ */
+ list = g_list_find_custom(data->config_options,
+ GUINT_TO_POINTER(otype),
+ is_option);
+ if (list) {
+ /* modify current option value to match */
+ config_option = list->data;
+
+ /*
+ * option values should match, otherwise
+ * we need to reallocate
+ */
+ if ((config_option->length ==
+ naked_option->length) && (olen - 2)) {
+ memcpy(config_option->data,
+ naked_option->data,
+ olen - 2);
+ } else {
+ /* XXX implement this */
+ g_printerr("uh oh, option value doesn't match\n");
+ }
+ g_free(naked_option);
+ } else {
+ /* add to list of config options */
+ pppcp_add_config_option(data, naked_option);
+ }
+ } else {
+ /* XXX handle this correctly */
+ g_printerr("oops, option wasn't acceptable\n");
+ g_free(naked_option);
+ }
+
+ /* skip ahead to the next option */
+ i += olen;
+ }
+ return RCN;
+}
+
+static guint8 pppcp_process_configure_reject(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ /*
+ * make sure identifier matches that of last sent configure
+ * request
+ */
+ if (packet->identifier == data->config_identifier) {
+ /*
+ * check to see which options were rejected
+ * Rejected options must be a subset of requested
+ * options.
+ *
+ * when a new configure-request is sent, we may
+ * not request any of these options be negotiated
+ */
+ return RCN;
+ }
+ return 0;
+}
+
+static guint8 pppcp_process_terminate_request(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ return RTR;
+}
+
+static guint8 pppcp_process_terminate_ack(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ /*
+ * if we wind up using the data field for anything, then
+ * we'd want to check the identifier.
+ * even if the identifiers don't match, we still handle
+ * a terminate ack, as it is allowed to be unelicited
+ */
+ return RTA;
+}
+
+static guint8 pppcp_process_code_reject(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ /*
+ * determine if the code reject is catastrophic or not.
+ * return RXJ_PLUS if this reject is acceptable, RXJ_MINUS if
+ * it is catastrophic.
+ */
+ return RXJ_MINUS;
+}
+
+static guint8 pppcp_process_protocol_reject(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ /*
+ * determine if the protocol reject is catastrophic or not.
+ * return RXJ_PLUS if this reject is acceptable, RXJ_MINUS if
+ * it is catastrophic.
+ */
+ return RXJ_MINUS;
+}
+
+static guint8 pppcp_process_echo_request(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ return RXR;
+}
+
+static guint8 pppcp_process_echo_reply(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ return 0;
+}
+
+static guint8 pppcp_process_discard_request(struct pppcp_data *data,
+ struct pppcp_packet *packet)
+{
+ return 0;
+}
+
+/*
+ * parse the packet and determine which event this packet caused
+ */
+void pppcp_process_packet(gpointer priv, guint8 *new_packet)
+{
+ struct pppcp_data *data = priv;
+ struct pppcp_packet *packet = (struct pppcp_packet *) new_packet;
+ guint8 event_type;
+ gpointer event_data = NULL;
+ guint data_len = 0;
+
+ if (data == NULL)
+ return;
+
+ /* check flags to see if we support this code */
+ if (!(data->valid_codes & (1 << packet->code))) {
+ event_type = RUC;
+ } else
+ event_type = data->packet_ops[packet->code-1](data, packet);
+ if (event_type) {
+ data_len = ntohs(packet->length);
+ event_data = packet;
+ pppcp_generate_event(data, event_type, event_data, data_len);
+ }
+}
+
+void pppcp_set_valid_codes(struct pppcp_data *data, guint16 codes)
+{
+ if (data == NULL)
+ return;
+
+ data->valid_codes = codes;
+}
+
+void pppcp_free(struct pppcp_data *data)
+{
+ if (data == NULL)
+ return;
+
+ /* free event queue */
+ if (!g_queue_is_empty(data->event_queue))
+ g_queue_foreach(data->event_queue, (GFunc) g_free, NULL);
+ g_queue_free(data->event_queue);
+
+ /* remove all config options */
+ pppcp_clear_options(data);
+
+ /* free self */
+ g_free(data);
+}
+
+struct pppcp_data *pppcp_new(GAtPPP *ppp, guint16 proto,
+ gpointer priv)
+{
+ struct pppcp_data *data;
+
+ data = g_try_malloc0(sizeof(struct pppcp_data));
+ if (!data)
+ return NULL;
+
+ data->state = INITIAL;
+ data->restart_interval = INITIAL_RESTART_TIMEOUT;
+ data->max_terminate = MAX_TERMINATE;
+ data->max_configure = MAX_CONFIGURE;
+ data->max_failure = MAX_FAILURE;
+ data->event_queue = g_queue_new();
+ data->identifier = 0;
+ data->ppp = ppp;
+ data->proto = proto;
+ data->priv = priv;
+
+ /* setup func ptrs for processing packet by pppcp code */
+ data->packet_ops[CONFIGURE_REQUEST - 1] =
+ pppcp_process_configure_request;
+ data->packet_ops[CONFIGURE_ACK - 1] = pppcp_process_configure_ack;
+ data->packet_ops[CONFIGURE_NAK - 1] = pppcp_process_configure_nak;
+ data->packet_ops[CONFIGURE_REJECT - 1] = pppcp_process_configure_reject;
+ data->packet_ops[TERMINATE_REQUEST - 1] =
+ pppcp_process_terminate_request;
+ data->packet_ops[TERMINATE_ACK - 1] = pppcp_process_terminate_ack;
+ data->packet_ops[CODE_REJECT - 1] = pppcp_process_code_reject;
+ data->packet_ops[PROTOCOL_REJECT - 1] = pppcp_process_protocol_reject;
+ data->packet_ops[ECHO_REQUEST - 1] = pppcp_process_echo_request;
+ data->packet_ops[ECHO_REPLY - 1] = pppcp_process_echo_reply;
+ data->packet_ops[DISCARD_REQUEST - 1] = pppcp_process_discard_request;
+
+ /* setup func ptrs for handling events by event type */
+ data->event_ops[UP] = pppcp_up_event;
+ data->event_ops[DOWN] = pppcp_down_event;
+ data->event_ops[OPEN] = pppcp_open_event;
+ data->event_ops[CLOSE] = pppcp_close_event;
+ data->event_ops[TO_PLUS] = pppcp_to_plus_event;
+ data->event_ops[TO_MINUS] = pppcp_to_minus_event;
+ data->event_ops[RCR_PLUS] = pppcp_rcr_plus_event;
+ data->event_ops[RCR_MINUS] = pppcp_rcr_minus_event;
+ data->event_ops[RCA] = pppcp_rca_event;
+ data->event_ops[RCN] = pppcp_rcn_event;
+ data->event_ops[RTR] = pppcp_rtr_event;
+ data->event_ops[RTA] = pppcp_rta_event;
+ data->event_ops[RUC] = pppcp_ruc_event;
+ data->event_ops[RXJ_PLUS] = pppcp_rxj_plus_event;
+ data->event_ops[RXJ_MINUS] = pppcp_rxj_minus_event;
+ data->event_ops[RXR] = pppcp_rxr_event;
+
+ return data;
+}
diff --git a/gatchat/ppp_cp.h b/gatchat/ppp_cp.h
new file mode 100644
index 0000000..875d02f
--- /dev/null
+++ b/gatchat/ppp_cp.h
@@ -0,0 +1,139 @@
+/*
+ *
+ * PPP library with GLib integration
+ *
+ * Copyright (C) 2009-2010 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+struct pppcp_data;
+
+enum pppcp_code {
+ CONFIGURE_REQUEST = 1,
+ CONFIGURE_ACK,
+ CONFIGURE_NAK,
+ CONFIGURE_REJECT,
+ TERMINATE_REQUEST,
+ TERMINATE_ACK,
+ CODE_REJECT,
+ PROTOCOL_REJECT,
+ ECHO_REQUEST,
+ ECHO_REPLY,
+ DISCARD_REQUEST
+};
+
+enum pppcp_event_type {
+ UP,
+ DOWN,
+ OPEN,
+ CLOSE,
+ TO_PLUS,
+ TO_MINUS,
+ RCR_PLUS,
+ RCR_MINUS,
+ RCA,
+ RCN,
+ RTR,
+ RTA,
+ RUC,
+ RXJ_PLUS,
+ RXJ_MINUS,
+ RXR,
+};
+
+enum pppcp_state {
+ INITIAL,
+ STARTING,
+ CLOSED,
+ STOPPED,
+ CLOSING,
+ STOPPING,
+ REQSENT,
+ ACKRCVD,
+ ACKSENT,
+ OPENED,
+};
+
+/* option format */
+struct ppp_option {
+ guint8 type;
+ guint8 length;
+ guint8 data[0];
+};
+
+enum option_rval {
+ OPTION_ACCEPT,
+ OPTION_REJECT,
+ OPTION_NAK,
+ OPTION_ERR,
+};
+
+struct pppcp_action {
+ void (*this_layer_up)(struct pppcp_data *data);
+ void (*this_layer_down)(struct pppcp_data *data);
+ void (*this_layer_started)(struct pppcp_data *data);
+ void (*this_layer_finished)(struct pppcp_data *data);
+ enum option_rval (*option_scan)(struct ppp_option *option,
+ gpointer user_data);
+ void (*option_process)(gpointer option, gpointer user_data);
+};
+
+struct pppcp_packet {
+ guint8 code;
+ guint8 identifier;
+ guint16 length;
+ guint8 data[0];
+} __attribute__((packed));
+
+struct pppcp_data {
+ enum pppcp_state state;
+ guint restart_timer;
+ guint restart_counter;
+ guint restart_interval;
+ guint max_terminate;
+ guint max_configure;
+ guint max_failure;
+ guint32 magic_number;
+ GQueue *event_queue;
+ GList *config_options;
+ GList *acceptable_options;
+ GList *unacceptable_options;
+ GList *rejected_options;
+ GList *applied_options;
+ GAtPPP *ppp;
+ guint8 identifier; /* don't think I need this now */
+ guint8 config_identifier;
+ guint8 terminate_identifier;
+ guint8 reject_identifier;
+ struct pppcp_action *action;
+ guint16 valid_codes;
+ guint8 (*packet_ops[11])(struct pppcp_data *data,
+ struct pppcp_packet *packet);
+ void (*event_ops[16])(struct pppcp_data *data, guint8 *packet,
+ guint length);
+ gpointer priv;
+ guint16 proto;
+};
+
+struct pppcp_data *pppcp_new(GAtPPP *ppp, guint16 proto, gpointer priv);
+void pppcp_free(struct pppcp_data *data);
+void pppcp_add_config_option(struct pppcp_data *data,
+ struct ppp_option *option);
+void pppcp_set_valid_codes(struct pppcp_data *data, guint16 codes);
+void pppcp_generate_event(struct pppcp_data *data,
+ enum pppcp_event_type event_type,
+ gpointer event_data, guint data_len);
+void pppcp_process_packet(gpointer priv, guint8 *new_packet);
--
1.6.6.1
More information about the ofono
mailing list