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

Authentication support with CHAP and MD5 --- Makefile.am | 3 +- gatchat/gatppp.c | 11 +++- gatchat/gatppp.h | 2 + gatchat/ppp.c | 1 + gatchat/ppp.h | 15 ++++ gatchat/ppp_auth.c | 229 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 259 insertions(+), 2 deletions(-) create mode 100644 gatchat/ppp_auth.c diff --git a/Makefile.am b/Makefile.am index 1a444ca..df89ef5 100644 --- a/Makefile.am +++ b/Makefile.am @@ -58,7 +58,8 @@ gatchat_sources = gatchat/gatchat.h gatchat/gatchat.c \ gatchat/gatserver.h gatchat/gatserver.c \ gatchat/gatppp.c gatchat/gatppp.h \ gatchat/ppp.c gatchat/ppp.h gatchat/ppp_cp.h \ - gatchat/ppp_cp.c gatchat/ppp_lcp.c + gatchat/ppp_cp.c gatchat/ppp_lcp.c \ + gatchat/ppp_auth.c udev_files = plugins/ofono.rules diff --git a/gatchat/gatppp.c b/gatchat/gatppp.c index f083842..2b682f8 100644 --- a/gatchat/gatppp.c +++ b/gatchat/gatppp.c @@ -43,6 +43,12 @@ void g_at_ppp_open(GAtPPP *ppp) lcp_open(ppp->lcp); } +void g_at_ppp_set_credentials(GAtPPP *ppp, const char *username, + const char *passwd) +{ + auth_set_credentials(ppp->auth, username, passwd); +} + void g_at_ppp_set_connect_function(GAtPPP *ppp, GAtPPPConnectFunc callback, gpointer user_data) { @@ -73,6 +79,9 @@ void g_at_ppp_shutdown(GAtPPP *ppp) /* remove lcp */ lcp_free(ppp->lcp); + + /* remove auth */ + auth_free(ppp->auth); } void g_at_ppp_ref(GAtPPP *ppp) @@ -124,7 +133,7 @@ GAtPPP *g_at_ppp_new(GIOChannel *modem) ppp->lcp = lcp_new(ppp); /* initialize the autentication state */ - + ppp->auth = auth_new(ppp); /* intialize the network state */ diff --git a/gatchat/gatppp.h b/gatchat/gatppp.h index 0d5d5cc..8db26c9 100644 --- a/gatchat/gatppp.h +++ b/gatchat/gatppp.h @@ -51,6 +51,8 @@ void g_at_ppp_set_disconnect_function(GAtPPP *ppp, void g_at_ppp_shutdown(GAtPPP *ppp); void g_at_ppp_ref(GAtPPP *ppp); void g_at_ppp_unref(GAtPPP *ppp); +void g_at_ppp_set_credentials(GAtPPP *ppp, const char *username, + const char *passwd); #ifdef __cplusplus } #endif diff --git a/gatchat/ppp.c b/gatchat/ppp.c index 2399ed4..0b3221b 100644 --- a/gatchat/ppp.c +++ b/gatchat/ppp.c @@ -463,6 +463,7 @@ void ppp_set_auth(GAtPPP *ppp, guint8* auth_data) switch (proto) { case CHAP_PROTOCOL: /* get the algorithm */ + auth_set_proto(ppp->auth, proto, auth_data[2]); break; default: g_printerr("unknown authentication proto\n"); diff --git a/gatchat/ppp.h b/gatchat/ppp.h index 7753a39..53d5274 100644 --- a/gatchat/ppp.h +++ b/gatchat/ppp.h @@ -95,10 +95,20 @@ static inline guint16 __get_unaligned_short(const gpointer p) #define ppp_proto(packet) \ (get_host_short(packet + 2)) +struct auth_data { + guint16 proto; + gpointer proto_data; + void (*process_packet)(struct auth_data *data, guint8 *packet); + char *username; + char *passwd; + GAtPPP *ppp; +}; + struct _GAtPPP { gint ref_count; enum ppp_phase phase; struct pppcp_data *lcp; + struct auth_data *auth; guint8 buffer[BUFFERSZ]; int index; gint mru; @@ -137,3 +147,8 @@ void lcp_open(struct pppcp_data *data); void lcp_close(struct pppcp_data *data); void lcp_establish(struct pppcp_data *data); void lcp_terminate(struct pppcp_data *data); +void auth_set_credentials(struct auth_data *data, const char *username, + const char *passwd); +void auth_set_proto(struct auth_data *data, guint16 proto, guint8 method); +struct auth_data *auth_new(GAtPPP *ppp); +void auth_free(struct auth_data *auth); diff --git a/gatchat/ppp_auth.c b/gatchat/ppp_auth.c new file mode 100644 index 0000000..c23d9ad --- /dev/null +++ b/gatchat/ppp_auth.c @@ -0,0 +1,229 @@ +/* + * + * 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 <arpa/inet.h> + +#include <glib.h> + +#include "gatppp.h" +#include "ppp.h" + +struct chap_header { + guint8 code; + guint8 identifier; + guint16 length; + guint8 data[0]; +} __attribute__((packed)); + +struct chap_data { + guint8 method; + struct auth_data *auth; +}; + +enum chap_code { + CHALLENGE=1, + RESPONSE, + SUCCESS, + FAILURE +}; + +void auth_set_credentials(struct auth_data *data, const char *username, + const char *passwd) +{ + if (data == NULL) + return; + + if (data->username) + g_free(data->username); + if (data->passwd) + g_free(data->passwd); + + data->username = g_strdup(username); + data->passwd = g_strdup(passwd); +} + +static void chap_process_challenge(struct auth_data *auth, guint8 *packet) +{ + struct chap_header *header = (struct chap_header *) packet; + struct chap_header *response; + struct chap_data *data = auth->proto_data; + GChecksum *checksum; + gchar *secret = data->auth->passwd; + guint16 response_length; + struct ppp_header *ppp_packet; + gsize digest_len; + + /* create a checksum over id, secret, and challenge */ + checksum = g_checksum_new(data->method); + if (!checksum) + return; + g_checksum_update(checksum, &header->identifier, 1); + g_checksum_update(checksum, (guchar *) secret, strlen(secret)); + g_checksum_update(checksum, &header->data[1], header->data[0]); + + /* transmit a response packet */ + /* + * allocate space for the header, the checksum, and the ppp header, + * and the value size byte + */ + digest_len = g_checksum_type_get_length(data->method); + response_length = digest_len + sizeof(*header) + 1; + ppp_packet = g_try_malloc0(response_length + 2); + if (!ppp_packet) + goto challenge_out; + + /* add our protocol information */ + ppp_packet->proto = htons(CHAP_PROTOCOL); + response = (struct chap_header *) &ppp_packet->info; + if (response) { + response->code = RESPONSE; + response->identifier = header->identifier; + response->length = htons(response_length); + response->data[0] = digest_len; + g_checksum_get_digest(checksum, &response->data[1], + (gsize *) &response->data[0]); + /* leave the name empty? */ + } + + /* transmit the packet */ + ppp_transmit(auth->ppp, (guint8 *) ppp_packet, response_length); + +challenge_out: + g_checksum_free(checksum); +} + +static void chap_process_success(struct auth_data *data, guint8 *packet) +{ + ppp_generate_event(data->ppp, PPP_SUCCESS); +} + +static void chap_process_failure(struct auth_data *data, guint8 *packet) +{ + struct chap_header *header = (struct chap_header *) packet; + + g_print("Failed to authenticate, message %s\n", header->data); +} + +/* + * parse the packet + */ +static void chap_process_packet(gpointer priv, guint8 *new_packet) +{ + struct auth_data *data = priv; + guint8 code = new_packet[0]; + + switch (code) { + case CHALLENGE: + chap_process_challenge(data, new_packet); + break; + case RESPONSE: + g_print("Oops, received RESPONSE, but I've not implemented\n"); + break; + case SUCCESS: + chap_process_success(data, new_packet); + break; + case FAILURE: + chap_process_failure(data, new_packet); + break; + default: + g_print("unknown auth code\n"); + break; + } +} + +struct ppp_packet_handler chap_packet_handler = { + .proto = CHAP_PROTOCOL, + .handler = chap_process_packet, +}; + +static void chap_free(struct auth_data *auth) +{ + /* TBD unregister protocol handler */ + + g_free(auth->proto_data); +} + +static struct chap_data *chap_new(struct auth_data *auth, guint8 method) +{ + struct chap_data *data; + + data = g_try_malloc0(sizeof(*data)); + if (!data) + return NULL; + + data->auth = auth; + switch (method) { + case MD5: + data->method = G_CHECKSUM_MD5; + break; + default: + g_print("Unknown method\n"); + } + + /* register packet handler for CHAP protocol */ + chap_packet_handler.priv = auth; + ppp_register_packet_handler(&chap_packet_handler); + return data; +} + +void auth_set_proto(struct auth_data *data, guint16 proto, guint8 method) +{ + if (data == NULL) + return; + + switch (proto) { + case CHAP_PROTOCOL: + data->proto_data = (gpointer) chap_new(data, method); + break; + default: + g_print("Unknown auth protocol 0x%x\n", proto); + } +} + +void auth_free(struct auth_data *data) +{ + if (data == NULL) + return; + + chap_free(data); + g_free(data); +} + +struct auth_data *auth_new(GAtPPP *ppp) +{ + struct auth_data *data; + + data = g_try_malloc0(sizeof(*data)); + if (!data) + return NULL; + + data->ppp = ppp; + return data; +} -- 1.6.6.1

Implement new options for gsmdial to use PPP and set the user name and password for authentication if needed. --- gatchat/gsmdial.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 84 insertions(+), 3 deletions(-) diff --git a/gatchat/gsmdial.c b/gatchat/gsmdial.c index 2087e70..aee9eea 100644 --- a/gatchat/gsmdial.c +++ b/gatchat/gsmdial.c @@ -36,6 +36,7 @@ #include <glib.h> #include <gatchat.h> #include <gattty.h> +#include <gatppp.h> static const char *none_prefix[] = { NULL }; static const char *cgreg_prefix[] = { "+CGREG:", NULL }; @@ -48,7 +49,11 @@ static gint option_cid = 0; static gchar *option_apn = NULL; static gint option_offmode = 0; static gboolean option_legacy = FALSE; +static gboolean option_ppp = FALSE; +static gchar *option_username = NULL; +static gchar *option_password = NULL; +static GAtPPP *ppp; static GAtChat *control; static GAtChat *modem; static GMainLoop *event_loop; @@ -223,6 +228,76 @@ static void at_cgact_up_cb(gboolean ok, GAtResult *result, gpointer user_data) g_at_chat_send(modem, buf, none_prefix, NULL, NULL, NULL); } +static void print_ip_address(const char *label, guint32 ip_addr) +{ + struct in_addr addr; + char buf[INET_ADDRSTRLEN]; + + addr.s_addr = ip_addr; + + if (inet_ntop(AF_INET, &addr, buf, INET_ADDRSTRLEN)) + g_print("%s: %s\n", label, buf); +} + +static void ppp_connect(GAtPPP *ppp, GAtPPPConnectStatus success, + guint32 ip_addr, guint32 dns1, guint32 dns2, + gpointer user_data) +{ + if (success != G_AT_PPP_CONNECT_SUCCESS) { + g_print("Failed to create PPP interface!\n"); + return; + } + + /* print out the negotiated address and dns server */ + print_ip_address("IP Address", ip_addr); + print_ip_address("Primary DNS Server", dns1); + print_ip_address("Secondary DNS Server", dns2); +} + +static void ppp_disconnect(GAtPPP *ppp, gpointer user_data) +{ + g_print("PPP Link down\n"); +} + +static void connect_cb(gboolean ok, GAtResult *result, gpointer user_data) +{ + GIOChannel *channel; + + if (!ok) { + g_print("Unable to define context\n"); + exit(1); + } + + if (option_ppp == FALSE) + return; + + /* get the data IO channel */ + channel = g_at_chat_get_channel(modem); + + /* + * shutdown gatchat or else it tries to take all the input + * from the modem and does not let PPP get it. + */ + g_at_chat_shutdown(control); + g_at_chat_shutdown(modem); + + /* open ppp */ + ppp = g_at_ppp_new(channel); + if (!ppp) { + g_print("Unable to create PPP object\n"); + return; + } + g_at_ppp_set_credentials(ppp, option_username, + option_password); + + /* set connect and disconnect callbacks */ + g_at_ppp_set_connect_function(ppp, ppp_connect, NULL); + g_at_ppp_set_disconnect_function(ppp, ppp_disconnect, NULL); + + /* open the ppp connection */ + g_at_ppp_open(ppp); +} + static void at_cgdcont_cb(gboolean ok, GAtResult *result, gpointer user_data) { char buf[64]; @@ -233,9 +308,9 @@ static void at_cgdcont_cb(gboolean ok, GAtResult *result, gpointer user_data) } if (option_legacy == TRUE) { - sprintf(buf, "ATD*99***%u#", option_cid); - g_at_chat_send(modem, buf, none_prefix, - NULL, NULL, NULL); + sprintf(buf, "ATD*99***%u#", option_cid); + g_at_chat_send(modem, buf, none_prefix, + connect_cb, NULL, NULL); } else { sprintf(buf, "AT+CGACT=1,%u", option_cid); g_at_chat_send(control, buf, none_prefix, @@ -452,6 +527,12 @@ static GOptionEntry options[] = { "Specify CFUN offmode" }, { "legacy", 'l', 0, G_OPTION_ARG_NONE, &option_legacy, "Use ATD*99***<cid>#" }, + { "ppp", 'P', 0, G_OPTION_ARG_NONE, &option_ppp, + "Connect using PPP" }, + { "username", 'u', 0, G_OPTION_ARG_STRING, &option_username, + "Specify PPP username" }, + { "password", 'w', 0, G_OPTION_ARG_STRING, &option_password, + "Specifiy PPP password" }, { NULL }, }; -- 1.6.6.1

* Kristen Carlson Accardi <kristen(a)linux.intel.com&gt; [2010-03-22 17:06:01 -0700]: I guess we should not call exit here. Just return. -- Gustavo F. Padovan ProFUSION embedded systems - http://profusion.mobi