mirror of git://git.sysmocom.de/ofono
591 lines
12 KiB
C
591 lines
12 KiB
C
/*
|
|
*
|
|
* 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 <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include <glib.h>
|
|
|
|
#include "gatutil.h"
|
|
#include "gathdlc.h"
|
|
#include "gatppp.h"
|
|
#include "crc-ccitt.h"
|
|
#include "ppp.h"
|
|
|
|
#define DEFAULT_MRU 1500
|
|
#define DEFAULT_MTU 1500
|
|
|
|
#define PPP_ADDR_FIELD 0xff
|
|
#define PPP_CTRL 0x03
|
|
|
|
enum ppp_phase {
|
|
PPP_PHASE_DEAD = 0, /* Link dead */
|
|
PPP_PHASE_ESTABLISHMENT, /* LCP started */
|
|
PPP_PHASE_AUTHENTICATION, /* Auth started */
|
|
PPP_PHASE_NETWORK, /* IPCP started */
|
|
PPP_PHASE_LINK_UP, /* IPCP negotiation succeeded, link up */
|
|
PPP_PHASE_TERMINATION, /* LCP Terminate phase */
|
|
};
|
|
|
|
struct _GAtPPP {
|
|
gint ref_count;
|
|
enum ppp_phase phase;
|
|
struct pppcp_data *lcp;
|
|
struct pppcp_data *ipcp;
|
|
struct ppp_net *net;
|
|
struct ppp_chap *chap;
|
|
GAtHDLC *hdlc;
|
|
gint mru;
|
|
gint mtu;
|
|
char username[256];
|
|
char password[256];
|
|
GAtPPPConnectFunc connect_cb;
|
|
gpointer connect_data;
|
|
GAtPPPDisconnectFunc disconnect_cb;
|
|
gpointer disconnect_data;
|
|
GAtPPPDisconnectReason disconnect_reason;
|
|
GAtDebugFunc debugf;
|
|
gpointer debug_data;
|
|
};
|
|
|
|
void ppp_debug(GAtPPP *ppp, const char *str)
|
|
{
|
|
if (ppp == NULL || ppp->debugf == NULL)
|
|
return;
|
|
|
|
ppp->debugf(str, ppp->debug_data);
|
|
}
|
|
|
|
struct ppp_header *ppp_packet_new(gsize infolen, guint16 protocol)
|
|
{
|
|
struct ppp_header *ppp_packet;
|
|
|
|
ppp_packet = g_try_malloc0(infolen + sizeof(*ppp_packet));
|
|
if (ppp_packet == NULL)
|
|
return NULL;
|
|
|
|
ppp_packet->proto = htons(protocol);
|
|
ppp_packet->address = PPP_ADDR_FIELD;
|
|
ppp_packet->control = PPP_CTRL;
|
|
|
|
return ppp_packet;
|
|
}
|
|
|
|
/*
|
|
* Silently discard packets which are received when they shouldn't be
|
|
*/
|
|
static inline gboolean ppp_drop_packet(GAtPPP *ppp, guint16 protocol)
|
|
{
|
|
switch (ppp->phase) {
|
|
case PPP_PHASE_ESTABLISHMENT:
|
|
case PPP_PHASE_TERMINATION:
|
|
if (protocol != LCP_PROTOCOL)
|
|
return TRUE;
|
|
break;
|
|
case PPP_PHASE_AUTHENTICATION:
|
|
if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL)
|
|
return TRUE;
|
|
break;
|
|
case PPP_PHASE_DEAD:
|
|
return TRUE;
|
|
case PPP_PHASE_NETWORK:
|
|
if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL &&
|
|
protocol != IPCP_PROTO)
|
|
return TRUE;
|
|
break;
|
|
case PPP_PHASE_LINK_UP:
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void ppp_receive(const unsigned char *buf, gsize len, void *data)
|
|
{
|
|
GAtPPP *ppp = data;
|
|
guint16 protocol = ppp_proto(buf);
|
|
const guint8 *packet = ppp_info(buf);
|
|
|
|
if (ppp_drop_packet(ppp, protocol))
|
|
return;
|
|
|
|
switch (protocol) {
|
|
case PPP_IP_PROTO:
|
|
ppp_net_process_packet(ppp->net, packet);
|
|
break;
|
|
case LCP_PROTOCOL:
|
|
pppcp_process_packet(ppp->lcp, packet);
|
|
break;
|
|
case IPCP_PROTO:
|
|
pppcp_process_packet(ppp->ipcp, packet);
|
|
break;
|
|
case CHAP_PROTOCOL:
|
|
if (ppp->chap) {
|
|
ppp_chap_process_packet(ppp->chap, packet);
|
|
break;
|
|
}
|
|
/* fall through */
|
|
default:
|
|
pppcp_send_protocol_reject(ppp->lcp, buf, len);
|
|
break;
|
|
};
|
|
}
|
|
|
|
/*
|
|
* transmit out through the lower layer interface
|
|
*
|
|
* infolen - length of the information part of the packet
|
|
*/
|
|
void ppp_transmit(GAtPPP *ppp, guint8 *packet, guint infolen)
|
|
{
|
|
struct ppp_header *header = (struct ppp_header *) packet;
|
|
guint16 proto = ppp_proto(packet);
|
|
guint8 code;
|
|
gboolean lcp = (proto == LCP_PROTOCOL);
|
|
guint32 xmit_accm = 0;
|
|
|
|
/*
|
|
* all LCP Link Configuration, Link Termination, and Code-Reject
|
|
* packets must be sent with the default sending ACCM
|
|
*/
|
|
if (lcp) {
|
|
code = pppcp_get_code(packet);
|
|
lcp = code > 0 && code < 8;
|
|
}
|
|
|
|
if (lcp) {
|
|
xmit_accm = g_at_hdlc_get_xmit_accm(ppp->hdlc);
|
|
g_at_hdlc_set_xmit_accm(ppp->hdlc, ~0U);
|
|
}
|
|
|
|
header->address = PPP_ADDR_FIELD;
|
|
header->control = PPP_CTRL;
|
|
|
|
if (g_at_hdlc_send(ppp->hdlc, packet,
|
|
infolen + sizeof(*header)) == FALSE)
|
|
g_print("Failed to send a frame\n");
|
|
|
|
if (lcp)
|
|
g_at_hdlc_set_xmit_accm(ppp->hdlc, xmit_accm);
|
|
}
|
|
|
|
static void ppp_dead(GAtPPP *ppp)
|
|
{
|
|
/* notify interested parties */
|
|
if (ppp->disconnect_cb)
|
|
ppp->disconnect_cb(ppp->disconnect_reason,
|
|
ppp->disconnect_data);
|
|
}
|
|
|
|
static inline void ppp_enter_phase(GAtPPP *ppp, enum ppp_phase phase)
|
|
{
|
|
g_print("Entering new phase: %d\n", phase);
|
|
ppp->phase = phase;
|
|
|
|
if (phase == PPP_PHASE_DEAD)
|
|
ppp_dead(ppp);
|
|
}
|
|
|
|
void ppp_set_auth(GAtPPP *ppp, const guint8* auth_data)
|
|
{
|
|
guint16 proto = get_host_short(auth_data);
|
|
|
|
switch (proto) {
|
|
case CHAP_PROTOCOL:
|
|
if (ppp->chap)
|
|
ppp_chap_free(ppp->chap);
|
|
|
|
ppp->chap = ppp_chap_new(ppp, auth_data[2]);
|
|
break;
|
|
default:
|
|
g_printerr("unknown authentication proto\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ppp_auth_notify(GAtPPP *ppp, gboolean success)
|
|
{
|
|
if (success == FALSE) {
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_AUTH_FAIL;
|
|
pppcp_signal_close(ppp->lcp);
|
|
return;
|
|
}
|
|
|
|
ppp_enter_phase(ppp, PPP_PHASE_NETWORK);
|
|
|
|
/* Send UP & OPEN events to the IPCP layer */
|
|
pppcp_signal_open(ppp->ipcp);
|
|
pppcp_signal_up(ppp->ipcp);
|
|
}
|
|
|
|
void ppp_ipcp_up_notify(GAtPPP *ppp, const char *local, const char *peer,
|
|
const char *dns1, const char *dns2)
|
|
{
|
|
ppp->net = ppp_net_new(ppp);
|
|
|
|
if (ppp->net == NULL) {
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_NET_FAIL;
|
|
pppcp_signal_close(ppp->lcp);
|
|
return;
|
|
}
|
|
|
|
if (ppp_net_set_mtu(ppp->net, ppp->mtu) == FALSE)
|
|
g_printerr("Unable to set MTU\n");
|
|
|
|
ppp_enter_phase(ppp, PPP_PHASE_LINK_UP);
|
|
|
|
if (ppp->connect_cb)
|
|
ppp->connect_cb(ppp_net_get_interface(ppp->net),
|
|
local, peer, dns1, dns2,
|
|
ppp->connect_data);
|
|
}
|
|
|
|
void ppp_ipcp_down_notify(GAtPPP *ppp)
|
|
{
|
|
/* Most likely we failed to create the interface */
|
|
if (ppp->net == NULL)
|
|
return;
|
|
|
|
ppp_net_free(ppp->net);
|
|
ppp->net = NULL;
|
|
}
|
|
|
|
void ppp_ipcp_finished_notify(GAtPPP *ppp)
|
|
{
|
|
if (ppp->phase != PPP_PHASE_NETWORK)
|
|
return;
|
|
|
|
/* Our IPCP parameter negotiation failed */
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_IPCP_FAIL;
|
|
pppcp_signal_close(ppp->ipcp);
|
|
pppcp_signal_close(ppp->lcp);
|
|
}
|
|
|
|
void ppp_lcp_up_notify(GAtPPP *ppp)
|
|
{
|
|
/* Wait for the peer to send us a challenge if we expect auth */
|
|
if (ppp->chap != NULL) {
|
|
ppp_enter_phase(ppp, PPP_PHASE_AUTHENTICATION);
|
|
return;
|
|
}
|
|
|
|
/* Otherwise proceed as if auth succeeded */
|
|
ppp_auth_notify(ppp, TRUE);
|
|
}
|
|
|
|
void ppp_lcp_down_notify(GAtPPP *ppp)
|
|
{
|
|
if (ppp->phase == PPP_PHASE_NETWORK || ppp->phase == PPP_PHASE_LINK_UP)
|
|
pppcp_signal_down(ppp->ipcp);
|
|
|
|
if (ppp->disconnect_reason == G_AT_PPP_REASON_UNKNOWN)
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_PEER_CLOSED;
|
|
|
|
ppp_enter_phase(ppp, PPP_PHASE_TERMINATION);
|
|
}
|
|
|
|
void ppp_lcp_finished_notify(GAtPPP *ppp)
|
|
{
|
|
ppp_enter_phase(ppp, PPP_PHASE_DEAD);
|
|
}
|
|
|
|
void ppp_set_recv_accm(GAtPPP *ppp, guint32 accm)
|
|
{
|
|
g_at_hdlc_set_recv_accm(ppp->hdlc, accm);
|
|
}
|
|
|
|
void ppp_set_xmit_accm(GAtPPP *ppp, guint32 accm)
|
|
{
|
|
g_at_hdlc_set_xmit_accm(ppp->hdlc, accm);
|
|
}
|
|
|
|
/*
|
|
* The only time we use other than default MTU is when we are in
|
|
* the network phase.
|
|
*/
|
|
void ppp_set_mtu(GAtPPP *ppp, const guint8 *data)
|
|
{
|
|
guint16 mtu = get_host_short(data);
|
|
|
|
ppp->mtu = mtu;
|
|
}
|
|
|
|
static void io_disconnect(gpointer user_data)
|
|
{
|
|
GAtPPP *ppp = user_data;
|
|
|
|
if (ppp->phase == PPP_PHASE_DEAD)
|
|
return;
|
|
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_LINK_DEAD;
|
|
pppcp_signal_down(ppp->lcp);
|
|
pppcp_signal_close(ppp->lcp);
|
|
}
|
|
|
|
/* Administrative Open */
|
|
void g_at_ppp_open(GAtPPP *ppp)
|
|
{
|
|
ppp_enter_phase(ppp, PPP_PHASE_ESTABLISHMENT);
|
|
|
|
/* send an UP & OPEN events to the lcp layer */
|
|
pppcp_signal_up(ppp->lcp);
|
|
pppcp_signal_open(ppp->lcp);
|
|
}
|
|
|
|
gboolean g_at_ppp_set_credentials(GAtPPP *ppp, const char *username,
|
|
const char *password)
|
|
{
|
|
if (username && strlen(username) > 255)
|
|
return FALSE;
|
|
|
|
if (password && strlen(password) > 255)
|
|
return FALSE;
|
|
|
|
memset(ppp->username, 0, sizeof(ppp->username));
|
|
memset(ppp->password, 0, sizeof(ppp->password));
|
|
|
|
if (username)
|
|
strcpy(ppp->username, username);
|
|
|
|
if (password)
|
|
strcpy(ppp->password, password);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
const char *g_at_ppp_get_username(GAtPPP *ppp)
|
|
{
|
|
return ppp->username;
|
|
}
|
|
|
|
const char *g_at_ppp_get_password(GAtPPP *ppp)
|
|
{
|
|
return ppp->password;
|
|
}
|
|
|
|
void g_at_ppp_set_recording(GAtPPP *ppp, const char *filename)
|
|
{
|
|
if (ppp == NULL)
|
|
return;
|
|
|
|
g_at_hdlc_set_recording(ppp->hdlc, filename);
|
|
}
|
|
|
|
void g_at_ppp_set_connect_function(GAtPPP *ppp, GAtPPPConnectFunc func,
|
|
gpointer user_data)
|
|
{
|
|
if (func == NULL)
|
|
return;
|
|
|
|
ppp->connect_cb = func;
|
|
ppp->connect_data = user_data;
|
|
}
|
|
|
|
void g_at_ppp_set_disconnect_function(GAtPPP *ppp, GAtPPPDisconnectFunc func,
|
|
gpointer user_data)
|
|
{
|
|
if (func == NULL)
|
|
return;
|
|
|
|
ppp->disconnect_cb = func;
|
|
ppp->disconnect_data = user_data;
|
|
}
|
|
|
|
void g_at_ppp_set_debug(GAtPPP *ppp, GAtDebugFunc func, gpointer user_data)
|
|
{
|
|
if (ppp == NULL)
|
|
return;
|
|
|
|
ppp->debugf = func;
|
|
ppp->debug_data = user_data;
|
|
}
|
|
|
|
void g_at_ppp_shutdown(GAtPPP *ppp)
|
|
{
|
|
if (ppp->phase == PPP_PHASE_DEAD || ppp->phase == PPP_PHASE_TERMINATION)
|
|
return;
|
|
|
|
ppp->disconnect_reason = G_AT_PPP_REASON_LOCAL_CLOSE;
|
|
pppcp_signal_close(ppp->lcp);
|
|
}
|
|
|
|
void g_at_ppp_ref(GAtPPP *ppp)
|
|
{
|
|
g_atomic_int_inc(&ppp->ref_count);
|
|
}
|
|
|
|
void g_at_ppp_unref(GAtPPP *ppp)
|
|
{
|
|
gboolean is_zero;
|
|
|
|
if (ppp == NULL)
|
|
return;
|
|
|
|
is_zero = g_atomic_int_dec_and_test(&ppp->ref_count);
|
|
|
|
if (is_zero == FALSE)
|
|
return;
|
|
|
|
g_at_io_set_disconnect_function(g_at_hdlc_get_io(ppp->hdlc),
|
|
NULL, NULL);
|
|
|
|
if (ppp->net)
|
|
ppp_net_free(ppp->net);
|
|
|
|
if (ppp->chap)
|
|
ppp_chap_free(ppp->chap);
|
|
|
|
lcp_free(ppp->lcp);
|
|
ipcp_free(ppp->ipcp);
|
|
|
|
g_at_hdlc_unref(ppp->hdlc);
|
|
|
|
g_free(ppp);
|
|
}
|
|
|
|
void g_at_ppp_set_server_info(GAtPPP *ppp, const char *remote,
|
|
const char *dns1, const char *dns2)
|
|
{
|
|
guint32 r = 0;
|
|
guint32 d1 = 0;
|
|
guint32 d2 = 0;
|
|
|
|
inet_pton(AF_INET, remote, &r);
|
|
inet_pton(AF_INET, dns1, &d1);
|
|
inet_pton(AF_INET, dns2, &d2);
|
|
|
|
ipcp_set_server_info(ppp->ipcp, r, d1, d2);
|
|
}
|
|
|
|
static GAtPPP *ppp_init_common(GAtHDLC *hdlc, gboolean is_server, guint32 ip)
|
|
{
|
|
GAtPPP *ppp;
|
|
|
|
ppp = g_try_malloc0(sizeof(GAtPPP));
|
|
if (ppp == NULL)
|
|
return NULL;
|
|
|
|
ppp->hdlc = g_at_hdlc_ref(hdlc);
|
|
|
|
ppp->ref_count = 1;
|
|
|
|
/* set options to defaults */
|
|
ppp->mru = DEFAULT_MRU;
|
|
ppp->mtu = DEFAULT_MTU;
|
|
|
|
/* initialize the lcp state */
|
|
ppp->lcp = lcp_new(ppp, is_server);
|
|
|
|
/* initialize IPCP state */
|
|
ppp->ipcp = ipcp_new(ppp, is_server, ip);
|
|
|
|
g_at_hdlc_set_receive(ppp->hdlc, ppp_receive, ppp);
|
|
g_at_io_set_disconnect_function(g_at_hdlc_get_io(ppp->hdlc),
|
|
io_disconnect, ppp);
|
|
|
|
if (is_server)
|
|
ppp_enter_phase(ppp, PPP_PHASE_ESTABLISHMENT);
|
|
|
|
return ppp;
|
|
}
|
|
|
|
GAtPPP *g_at_ppp_new(GIOChannel *modem)
|
|
{
|
|
GAtHDLC *hdlc;
|
|
GAtPPP *ppp;
|
|
|
|
hdlc = g_at_hdlc_new(modem);
|
|
if (hdlc == NULL)
|
|
return NULL;
|
|
|
|
ppp = ppp_init_common(hdlc, FALSE, 0);
|
|
g_at_hdlc_unref(hdlc);
|
|
|
|
return ppp;
|
|
}
|
|
|
|
GAtPPP *g_at_ppp_new_from_io(GAtIO *io)
|
|
{
|
|
GAtHDLC *hdlc;
|
|
GAtPPP *ppp;
|
|
|
|
hdlc = g_at_hdlc_new_from_io(io);
|
|
if (hdlc == NULL)
|
|
return NULL;
|
|
|
|
ppp = ppp_init_common(hdlc, FALSE, 0);
|
|
g_at_hdlc_unref(hdlc);
|
|
|
|
return ppp;
|
|
}
|
|
|
|
GAtPPP *g_at_ppp_server_new(GIOChannel *modem, const char *local)
|
|
{
|
|
GAtHDLC *hdlc;
|
|
GAtPPP *ppp;
|
|
guint32 ip;
|
|
|
|
if (local == NULL)
|
|
ip = 0;
|
|
else if (inet_pton(AF_INET, local, &ip) != 1)
|
|
return NULL;
|
|
|
|
hdlc = g_at_hdlc_new(modem);
|
|
if (hdlc == NULL)
|
|
return NULL;
|
|
|
|
ppp = ppp_init_common(hdlc, TRUE, ip);
|
|
g_at_hdlc_unref(hdlc);
|
|
|
|
return ppp;
|
|
}
|
|
|
|
GAtPPP *g_at_ppp_server_new_from_io(GAtIO *io, const char *local)
|
|
{
|
|
GAtHDLC *hdlc;
|
|
GAtPPP *ppp;
|
|
guint32 ip;
|
|
|
|
if (local == NULL)
|
|
ip = 0;
|
|
else if (inet_pton(AF_INET, local, &ip) != 1)
|
|
return NULL;
|
|
|
|
hdlc = g_at_hdlc_new_from_io(io);
|
|
if (hdlc == NULL)
|
|
return NULL;
|
|
|
|
ppp = ppp_init_common(hdlc, TRUE, ip);
|
|
g_at_hdlc_unref(hdlc);
|
|
|
|
return ppp;
|
|
}
|