| /* |
| * |
| * PPP library with GLib integration |
| * |
| * Copyright (C) 2009-2011 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_MTU 1500 |
| |
| #define PPP_ADDR_FIELD 0xff |
| #define PPP_CTRL 0x03 |
| |
| #define GUARD_TIMEOUTS 1500 |
| |
| 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 ok, 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; |
| struct ppp_pap *pap; |
| GAtHDLC *hdlc; |
| gint mtu; |
| char username[256]; |
| char password[256]; |
| GAtPPPAuthMethod auth_method; |
| GAtPPPConnectFunc connect_cb; |
| gpointer connect_data; |
| GAtPPPDisconnectFunc disconnect_cb; |
| gpointer disconnect_data; |
| GAtPPPDisconnectReason disconnect_reason; |
| GAtDebugFunc debugf; |
| gpointer debug_data; |
| gboolean sta_pending; |
| guint ppp_dead_source; |
| GAtSuspendFunc suspend_func; |
| gpointer suspend_data; |
| int fd; |
| guint guard_timeout_source; |
| gboolean suspended; |
| gboolean xmit_acfc; |
| gboolean xmit_pfc; |
| }; |
| |
| void ppp_debug(GAtPPP *ppp, const char *str) |
| { |
| if (ppp == NULL || ppp->debugf == NULL) |
| return; |
| |
| ppp->debugf(str, ppp->debug_data); |
| } |
| |
| static gboolean ppp_dead(gpointer userdata) |
| { |
| GAtPPP *ppp = userdata; |
| |
| DBG(ppp, ""); |
| |
| ppp->ppp_dead_source = 0; |
| |
| /* notify interested parties */ |
| if (ppp->disconnect_cb) |
| ppp->disconnect_cb(ppp->disconnect_reason, |
| ppp->disconnect_data); |
| |
| return FALSE; |
| } |
| |
| static void sta_sent(gpointer userdata) |
| { |
| GAtPPP *ppp = userdata; |
| |
| DBG(ppp, ""); |
| |
| ppp->sta_pending = FALSE; |
| |
| if (ppp->phase == PPP_PHASE_DEAD) |
| ppp_dead(ppp); |
| } |
| |
| 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 && |
| protocol != PAP_PROTOCOL) |
| return TRUE; |
| break; |
| case PPP_PHASE_DEAD: |
| return TRUE; |
| case PPP_PHASE_NETWORK: |
| if (protocol != LCP_PROTOCOL && protocol != CHAP_PROTOCOL && |
| protocol != PAP_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; |
| unsigned int offset = 0; |
| guint16 protocol; |
| const guint8 *packet; |
| |
| if (len == 0) |
| return; |
| |
| if (buf[0] == PPP_ADDR_FIELD && len >= 2 && buf[1] == PPP_CTRL) |
| offset = 2; |
| |
| if (len < offset + 1) |
| return; |
| |
| /* From RFC 1661: |
| * the Protocol field uses an extension mechanism consistent with the |
| * ISO 3309 extension mechanism for the Address field; the Least |
| * Significant Bit (LSB) of each octet is used to indicate extension |
| * of the Protocol field. A binary "0" as the LSB indicates that the |
| * Protocol field continues with the following octet. The presence |
| * of a binary "1" as the LSB marks the last octet of the Protocol |
| * field. |
| * |
| * To check for compression we simply check the LSB of the first |
| * protocol byte. |
| */ |
| |
| if (buf[offset] & 0x1) { |
| protocol = buf[offset]; |
| offset += 1; |
| } else { |
| if (len < offset + 2) |
| return; |
| |
| protocol = get_host_short(buf + offset); |
| offset += 2; |
| } |
| |
| if (ppp_drop_packet(ppp, protocol)) |
| return; |
| |
| packet = buf + offset; |
| |
| switch (protocol) { |
| case PPP_IP_PROTO: |
| ppp_net_process_packet(ppp->net, packet, len - offset); |
| break; |
| case LCP_PROTOCOL: |
| pppcp_process_packet(ppp->lcp, packet, len - offset); |
| break; |
| case IPCP_PROTO: |
| pppcp_process_packet(ppp->ipcp, packet, len - offset); |
| break; |
| case PAP_PROTOCOL: |
| if (ppp->pap) |
| ppp_pap_process_packet(ppp->pap, packet, len - offset); |
| else |
| pppcp_send_protocol_reject(ppp->lcp, buf, len); |
| |
| break; |
| case CHAP_PROTOCOL: |
| if (ppp->chap) { |
| ppp_chap_process_packet(ppp->chap, packet, |
| len - offset); |
| break; |
| } |
| /* fall through */ |
| default: |
| pppcp_send_protocol_reject(ppp->lcp, buf, len); |
| break; |
| }; |
| } |
| |
| static void ppp_send_lcp_frame(GAtPPP *ppp, guint8 *packet, guint infolen) |
| { |
| struct ppp_header *header = (struct ppp_header *) packet; |
| guint8 code; |
| guint32 xmit_accm = 0; |
| gboolean sta = FALSE; |
| gboolean lcp; |
| |
| /* |
| * all LCP Link Configuration, Link Termination, and Code-Reject |
| * packets must be sent with the default sending ACCM |
| */ |
| code = pppcp_get_code(packet); |
| lcp = code > 0 && code < 8; |
| |
| /* |
| * If we're going down, we try to make sure to send the final |
| * ack before informing the upper layers via the ppp_disconnect |
| * function. Once we enter PPP_DEAD phase, no further packets |
| * will be sent |
| */ |
| if (code == PPPCP_CODE_TYPE_TERMINATE_ACK) |
| sta = TRUE; |
| |
| 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)) == TRUE) { |
| if (sta) { |
| GAtIO *io = g_at_hdlc_get_io(ppp->hdlc); |
| |
| ppp->sta_pending = TRUE; |
| g_at_io_set_write_done(io, sta_sent, ppp); |
| } |
| } else |
| DBG(ppp, "Failed to send a frame\n"); |
| |
| if (lcp) |
| g_at_hdlc_set_xmit_accm(ppp->hdlc, xmit_accm); |
| } |
| |
| static void ppp_send_acfc_frame(GAtPPP *ppp, guint8 *packet, |
| guint infolen) |
| { |
| struct ppp_header *header = (struct ppp_header *) packet; |
| guint offset = 0; |
| |
| if (ppp->xmit_acfc) |
| offset = 2; |
| |
| /* We remove the only address and control field */ |
| if (g_at_hdlc_send(ppp->hdlc, packet + offset, |
| infolen + sizeof(*header) - offset) |
| == FALSE) |
| DBG(ppp, "Failed to send a frame\n"); |
| } |
| |
| static void ppp_send_acfc_pfc_frame(GAtPPP *ppp, guint8 *packet, |
| guint infolen) |
| { |
| struct ppp_header *header = (struct ppp_header *) packet; |
| guint offset = 0; |
| |
| if (ppp->xmit_acfc && ppp->xmit_pfc) |
| offset = 3; |
| else if (ppp->xmit_acfc) |
| offset = 2; |
| else if (ppp->xmit_pfc) { |
| /* Shuffle AC bytes in place of the first protocol byte */ |
| packet[2] = packet[1]; |
| packet[1] = packet[0]; |
| offset = 1; |
| } |
| |
| if (g_at_hdlc_send(ppp->hdlc, packet + offset, |
| infolen + sizeof(*header) - offset) |
| == FALSE) |
| DBG(ppp, "Failed to send a frame\n"); |
| } |
| |
| /* |
| * 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) |
| { |
| guint16 proto = ppp_proto(packet); |
| |
| if (proto == LCP_PROTOCOL) { |
| ppp_send_lcp_frame(ppp, packet, infolen); |
| return; |
| } |
| |
| /* |
| * If the upper 8 bits of the protocol are 0, then send |
| * with PFC if enabled |
| */ |
| if ((proto & 0xff00) == 0) |
| ppp_send_acfc_pfc_frame(ppp, packet, infolen); |
| else |
| ppp_send_acfc_frame(ppp, packet, infolen); |
| } |
| |
| static inline void ppp_enter_phase(GAtPPP *ppp, enum ppp_phase phase) |
| { |
| DBG(ppp, "%d", phase); |
| ppp->phase = phase; |
| |
| if (phase == PPP_PHASE_DEAD && ppp->sta_pending == FALSE) |
| ppp->ppp_dead_source = g_idle_add(ppp_dead, ppp); |
| } |
| |
| void ppp_set_auth(GAtPPP *ppp, const guint8* auth_data) |
| { |
| guint16 proto = get_host_short(auth_data); |
| |
| switch (proto) { |
| case PAP_PROTOCOL: |
| if (ppp->pap) |
| ppp_pap_free(ppp->pap); |
| |
| ppp->pap = ppp_pap_new(ppp); |
| break; |
| case CHAP_PROTOCOL: |
| if (ppp->chap) |
| ppp_chap_free(ppp->chap); |
| |
| ppp->chap = ppp_chap_new(ppp, auth_data[2]); |
| break; |
| default: |
| DBG(ppp, "unknown authentication proto"); |
| 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, ppp->fd); |
| |
| /* |
| * ppp_net_new took control over the fd, whatever happens is out of |
| * our hands now |
| */ |
| ppp->fd = -1; |
| |
| 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) |
| DBG(ppp, "Unable to set MTU"); |
| |
| 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) |
| { |
| if (ppp->chap != NULL) { |
| /* Wait for the peer to send us a challenge. */ |
| ppp_enter_phase(ppp, PPP_PHASE_AUTHENTICATION); |
| return; |
| } else if (ppp->pap != NULL) { |
| /* Try to send an Authenticate-Request and wait for reply. */ |
| if (ppp_pap_start(ppp->pap) == TRUE) |
| ppp_enter_phase(ppp, PPP_PHASE_AUTHENTICATION); |
| else |
| /* It'll never work out. */ |
| ppp_auth_notify(ppp, FALSE); |
| |
| 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; |
| } |
| |
| void ppp_set_xmit_acfc(GAtPPP *ppp, gboolean acfc) |
| { |
| ppp->xmit_acfc = acfc; |
| } |
| |
| void ppp_set_xmit_pfc(GAtPPP *ppp, gboolean pfc) |
| { |
| ppp->xmit_pfc = pfc; |
| } |
| |
| 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); |
| } |
| |
| static void ppp_proxy_suspend_net_interface(gpointer user_data) |
| { |
| GAtPPP *ppp = user_data; |
| |
| ppp->suspended = TRUE; |
| ppp_net_suspend_interface(ppp->net); |
| |
| if (ppp->suspend_func) |
| ppp->suspend_func(ppp->suspend_data); |
| } |
| |
| gboolean g_at_ppp_listen(GAtPPP *ppp, GAtIO *io) |
| { |
| ppp->hdlc = g_at_hdlc_new_from_io(io); |
| if (ppp->hdlc == NULL) |
| return FALSE; |
| |
| ppp->suspended = FALSE; |
| g_at_hdlc_set_receive(ppp->hdlc, ppp_receive, ppp); |
| g_at_hdlc_set_suspend_function(ppp->hdlc, |
| ppp_proxy_suspend_net_interface, ppp); |
| g_at_io_set_disconnect_function(io, io_disconnect, ppp); |
| |
| ppp_enter_phase(ppp, PPP_PHASE_ESTABLISHMENT); |
| |
| return TRUE; |
| } |
| |
| /* Administrative Open */ |
| gboolean g_at_ppp_open(GAtPPP *ppp, GAtIO *io) |
| { |
| ppp->hdlc = g_at_hdlc_new_from_io(io); |
| if (ppp->hdlc == NULL) |
| return FALSE; |
| |
| ppp->suspended = FALSE; |
| g_at_hdlc_set_receive(ppp->hdlc, ppp_receive, ppp); |
| g_at_hdlc_set_suspend_function(ppp->hdlc, |
| ppp_proxy_suspend_net_interface, ppp); |
| g_at_hdlc_set_no_carrier_detect(ppp->hdlc, TRUE); |
| g_at_io_set_disconnect_function(io, io_disconnect, ppp); |
| |
| /* send an UP & OPEN events to the lcp layer */ |
| pppcp_signal_up(ppp->lcp); |
| pppcp_signal_open(ppp->lcp); |
| |
| ppp_enter_phase(ppp, PPP_PHASE_ESTABLISHMENT); |
| |
| return TRUE; |
| } |
| |
| 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; |
| } |
| |
| gboolean g_at_ppp_set_auth_method(GAtPPP *ppp, GAtPPPAuthMethod method) |
| { |
| if (method != G_AT_PPP_AUTH_METHOD_CHAP && |
| method != G_AT_PPP_AUTH_METHOD_PAP && |
| method != G_AT_PPP_AUTH_METHOD_NONE) |
| return FALSE; |
| |
| ppp->auth_method = method; |
| |
| return TRUE; |
| } |
| |
| GAtPPPAuthMethod g_at_ppp_get_auth_method(GAtPPP *ppp) |
| { |
| return ppp->auth_method; |
| } |
| |
| 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_set_suspend_function(GAtPPP *ppp, GAtSuspendFunc func, |
| gpointer user_data) |
| { |
| if (ppp == NULL) |
| return; |
| |
| ppp->suspend_func = func; |
| ppp->suspend_data = user_data; |
| |
| if (ppp->hdlc != NULL) |
| g_at_hdlc_set_suspend_function(ppp->hdlc, |
| ppp_proxy_suspend_net_interface, ppp); |
| } |
| |
| 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); |
| } |
| |
| static gboolean call_suspend_cb(gpointer user_data) |
| { |
| GAtPPP *ppp = user_data; |
| |
| ppp->guard_timeout_source = 0; |
| |
| if (ppp->suspend_func) |
| ppp->suspend_func(ppp->suspend_data); |
| |
| return FALSE; |
| } |
| |
| static gboolean send_escape_sequence(gpointer user_data) |
| { |
| GAtPPP *ppp = user_data; |
| GAtIO *io = g_at_hdlc_get_io(ppp->hdlc); |
| |
| g_at_io_write(io, "+++", 3); |
| ppp->guard_timeout_source = g_timeout_add(GUARD_TIMEOUTS, |
| call_suspend_cb, ppp); |
| |
| return FALSE; |
| } |
| |
| void g_at_ppp_suspend(GAtPPP *ppp) |
| { |
| if (ppp == NULL) |
| return; |
| |
| ppp->suspended = TRUE; |
| ppp_net_suspend_interface(ppp->net); |
| g_at_hdlc_suspend(ppp->hdlc); |
| ppp->guard_timeout_source = g_timeout_add(GUARD_TIMEOUTS, |
| send_escape_sequence, ppp); |
| } |
| |
| void g_at_ppp_resume(GAtPPP *ppp) |
| { |
| if (ppp == NULL) |
| return; |
| |
| if (g_at_hdlc_get_io(ppp->hdlc) == NULL) { |
| io_disconnect(ppp); |
| return; |
| } |
| |
| ppp->suspended = FALSE; |
| g_at_io_set_disconnect_function(g_at_hdlc_get_io(ppp->hdlc), |
| io_disconnect, ppp); |
| ppp_net_resume_interface(ppp->net); |
| g_at_hdlc_resume(ppp->hdlc); |
| } |
| |
| 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; |
| |
| if (ppp->suspended == FALSE) |
| g_at_io_set_disconnect_function(g_at_hdlc_get_io(ppp->hdlc), |
| NULL, NULL); |
| |
| if (ppp->net) |
| ppp_net_free(ppp->net); |
| else if (ppp->fd >= 0) |
| close(ppp->fd); |
| |
| if (ppp->pap) |
| ppp_pap_free(ppp->pap); |
| |
| if (ppp->chap) |
| ppp_chap_free(ppp->chap); |
| |
| lcp_free(ppp->lcp); |
| ipcp_free(ppp->ipcp); |
| |
| if (ppp->ppp_dead_source) { |
| g_source_remove(ppp->ppp_dead_source); |
| ppp->ppp_dead_source = 0; |
| } |
| |
| if (ppp->guard_timeout_source) { |
| g_source_remove(ppp->guard_timeout_source); |
| ppp->guard_timeout_source = 0; |
| } |
| |
| 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); |
| } |
| |
| void g_at_ppp_set_acfc_enabled(GAtPPP *ppp, gboolean enabled) |
| { |
| lcp_set_acfc_enabled(ppp->lcp, enabled); |
| } |
| |
| void g_at_ppp_set_pfc_enabled(GAtPPP *ppp, gboolean enabled) |
| { |
| lcp_set_pfc_enabled(ppp->lcp, enabled); |
| } |
| |
| static GAtPPP *ppp_init_common(gboolean is_server, guint32 ip) |
| { |
| GAtPPP *ppp; |
| |
| ppp = g_try_malloc0(sizeof(GAtPPP)); |
| if (ppp == NULL) |
| return NULL; |
| |
| ppp->ref_count = 1; |
| ppp->suspended = TRUE; |
| ppp->fd = -1; |
| |
| /* set options to defaults */ |
| 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); |
| |
| /* chap authentication by default */ |
| ppp->auth_method = G_AT_PPP_AUTH_METHOD_CHAP; |
| |
| return ppp; |
| } |
| |
| GAtPPP *g_at_ppp_new(void) |
| { |
| return ppp_init_common(FALSE, 0); |
| } |
| |
| GAtPPP *g_at_ppp_server_new_full(const char *local, int fd) |
| { |
| GAtPPP *ppp; |
| guint32 ip; |
| |
| if (local == NULL) |
| ip = 0; |
| else if (inet_pton(AF_INET, local, &ip) != 1) |
| return NULL; |
| |
| ppp = ppp_init_common(TRUE, ip); |
| |
| if (ppp != NULL) |
| ppp->fd = fd; |
| |
| return ppp; |
| } |
| |
| GAtPPP *g_at_ppp_server_new(const char *local) |
| { |
| return g_at_ppp_server_new_full(local, -1); |
| } |