// L2TPNS: icmp
-char const *cvs_id_icmp = "$Id: icmp.c,v 1.9 2005-07-31 10:04:10 bodea Exp $";
+char const *cvs_id_icmp = "$Id: icmp.c,v 1.10 2005-08-10 11:25:56 bodea Exp $";
#include <arpa/inet.h>
#include <netdb.h>
return htons((uint16_t) sum);
}
-void send_ipv6_ra(tunnelidt t, sessionidt s, struct in6_addr *ip)
+void send_ipv6_ra(sessionidt s, tunnelidt t, struct in6_addr *ip)
{
struct nd_opt_prefix_info *pinfo;
struct ipv6_pseudo_hdr *phdr;
LOG(3, s, t, "Sending IPv6 RA\n");
memset(b, 0, sizeof(b));
- o = makeppp(b, sizeof(b), 0, 0, t, s, PPPIPV6);
+ o = makeppp(b, sizeof(b), 0, 0, s, t, PPPIPV6);
if (!o)
{
// Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced
// vim: sw=8 ts=8
-char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.118 2005-08-10 08:36:48 bodea Exp $";
+char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.119 2005-08-10 11:25:56 bodea Exp $";
#include <arpa/inet.h>
#include <assert.h>
// Add on L2TP header
{
- uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP);
+ uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIP);
if (!p) return;
tunnelsend(b, len + (p-b), t); // send it...
}
// Add on L2TP header
{
- uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIPV6);
+ uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIPV6);
if (!p) return;
tunnelsend(b, len + (p-b), t); // send it...
}
// Add on L2TP header
{
- uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP);
+ uint8_t *p = makeppp(b, sizeof(b), buf, len, s, t, PPPIP);
if (!p) return;
tunnelsend(b, len + (p-b), t); // send it...
}
}
// add a control message to a tunnel, and send if within window
-static void controladd(controlt * c, tunnelidt t, sessionidt far)
+static void controladd(controlt *c, sessionidt far, tunnelidt t)
{
*(uint16_t *) (c->buf + 2) = htons(c->length); // length
*(uint16_t *) (c->buf + 4) = htons(tunnel[t].far); // tunnel
control16(c, 1, result, 1);
control16(c, 14, s, 1); // assigned session (our end)
- controladd(c, session[s].tunnel, session[s].far); // send the message
+ controladd(c, session[s].far, session[s].tunnel); // send the message
}
if (!session[s].die)
cluster_send_session(s);
}
-void sendipcp(tunnelidt t, sessionidt s)
+void sendipcp(sessionidt s, tunnelidt t)
{
uint8_t buf[MAXCONTROL];
uint8_t *q;
session[s].unique_id = last_id;
}
- q = makeppp(buf,sizeof(buf), 0, 0, t, s, PPPIPCP);
+ q = makeppp(buf,sizeof(buf), 0, 0, s, t, PPPIPCP);
if (!q) return;
*q = ConfigReq;
tunnelsend(buf, 10 + (q - buf), t); // send it
}
-void sendipv6cp(tunnelidt t, sessionidt s)
+void sendipv6cp(sessionidt s, tunnelidt t)
{
uint8_t buf[MAXCONTROL];
uint8_t *q;
CSTAT(sendipv6cp);
- q = makeppp(buf,sizeof(buf), 0, 0, t, s, PPPIPV6CP);
+ q = makeppp(buf,sizeof(buf), 0, 0, s, t, PPPIPV6CP);
if (!q) return;
*q = ConfigReq;
control16(c, 1, result, 1);
control16(c, 9, t, 1); // assigned tunnel (our end)
- controladd(c, t, 0); // send the message
+ controladd(c, 0, t); // send the message
}
}
controls(c, 7, tunnel[t].hostname, 1); // host name (TBA)
if (chapresponse) controlb(c, 13, chapresponse, 16, 1); // Challenge response
control16(c, 9, t, 1); // assigned tunnel
- controladd(c, t, 0); // send the resply
+ controladd(c, 0, t); // send the resply
}
else
{
session[s].last_packet = time_now;
LOG(3, s, t, "New session (%d/%d)\n", tunnel[t].far, session[s].far);
control16(c, 14, s, 1); // assigned session
- controladd(c, t, asession); // send the reply
+ controladd(c, asession, t); // send the reply
strncpy(session[s].called, called, sizeof(session[s].called) - 1);
strncpy(session[s].calling, calling, sizeof(session[s].calling) - 1);
else
control16(c, 1, 2, 7); // shutting down, try another
- controladd(c, t, asession); // send the message
+ controladd(c, asession, t); // send the message
}
return;
case 11: // ICRP
authtype = config->radius_authprefer;
// start LCP
- sendlcp(t, s, authtype);
+ sendlcp(s, t, authtype);
sess_local[s].lcp.restart = time_now + config->ppp_restart_time;
sess_local[s].lcp.conf_sent = 1;
sess_local[s].lcp.nak_sent = 0;
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processpap(t, s, p, l);
+ processpap(s, t, p, l);
}
else if (prot == PPPCHAP)
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processchap(t, s, p, l);
+ processchap(s, t, p, l);
}
else if (prot == PPPLCP)
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processlcp(t, s, p, l);
+ processlcp(s, t, p, l);
}
else if (prot == PPPIPCP)
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processipcp(t, s, p, l);
+ processipcp(s, t, p, l);
}
else if (prot == PPPIPV6CP)
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processipv6cp(t, s, p, l);
+ processipv6cp(s, t, p, l);
}
else if (prot == PPPCCP)
{
session[s].last_packet = time_now;
if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
- processccp(t, s, p, l);
+ processccp(s, t, p, l);
}
else if (prot == PPPIP)
{
return;
}
- processipin(t, s, p, l);
+ processipin(s, t, p, l);
}
else if (prot == PPPIPV6)
{
return;
}
- processipv6in(t, s, p, l);
+ processipv6in(s, t, p, l);
}
else
{
if (tunnel[t].state == TUNNELOPEN && tunnel[t].lastrec < TIME + 600)
{
controlt *c = controlnew(6); // sending HELLO
- controladd(c, t, 0); // send the message
+ controladd(c, 0, t); // send the message
LOG(3, 0, t, "Sending HELLO message\n");
t_actions++;
}
LOG(3, s, session[s].tunnel, "No ACK for LCP ConfigReq... resending\n");
sess_local[s].lcp.restart = time_now + config->ppp_restart_time;
sess_local[s].lcp.conf_sent++;
- sendlcp(t, s, sess_local[s].lcp_authtype);
+ sendlcp(s, t, sess_local[s].lcp_authtype);
change_state(s, lcp, next_state);
}
else
LOG(3, s, session[s].tunnel, "No ACK for IPCP ConfigReq... resending\n");
sess_local[s].ipcp.restart = time_now + config->ppp_restart_time;
sess_local[s].ipcp.conf_sent++;
- sendipcp(t, s);
+ sendipcp(s, t);
change_state(s, ipcp, next_state);
}
else
LOG(3, s, session[s].tunnel, "No ACK for IPV6CP ConfigReq... resending\n");
sess_local[s].ipv6cp.restart = time_now + config->ppp_restart_time;
sess_local[s].ipv6cp.conf_sent++;
- sendipv6cp(t, s);
+ sendipv6cp(s, t);
change_state(s, ipv6cp, next_state);
}
else
LOG(3, s, session[s].tunnel, "No ACK for CCP ConfigReq... resending\n");
sess_local[s].ccp.restart = time_now + config->ppp_restart_time;
sess_local[s].ccp.conf_sent++;
- sendccp(t, s);
+ sendccp(s, t);
change_state(s, ccp, next_state);
}
else
{
uint8_t b[MAXCONTROL] = {0};
- uint8_t *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, PPPLCP);
+ uint8_t *q = makeppp(b, sizeof(b), 0, 0, s, session[s].tunnel, PPPLCP);
if (!q) continue;
*q = EchoReq;
update_config();
}
-int sessionsetup(tunnelidt t, sessionidt s)
+int sessionsetup(sessionidt s, tunnelidt t)
{
// A session now exists, set it up
in_addr_t ip;
}
sess_local[s].lcp_authtype = 0; // RADIUS authentication complete
- lcp_open(t, s); // transition to Network phase and send initial IPCP
+ lcp_open(s, t); // transition to Network phase and send initial IPCP
// Run the plugin's against this new session.
{
// L2TPNS Global Stuff
-// $Id: l2tpns.h,v 1.81 2005-07-31 10:04:10 bodea Exp $
+// $Id: l2tpns.h,v 1.82 2005-08-10 11:25:56 bodea Exp $
#ifndef __L2TPNS_H__
#define __L2TPNS_H__
// ppp.c
-void processpap(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processchap(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void lcp_open(tunnelidt t, sessionidt s);
-void processlcp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processipcp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processipv6cp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processipin(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processipv6in(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void processccp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l);
-void sendchap(tunnelidt t, sessionidt s);
-uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, tunnelidt t, sessionidt s, uint16_t mtype);
-void sendlcp(tunnelidt t, sessionidt s, int authtype);
+void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void lcp_open(sessionidt s, tunnelidt t);
+void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processipv6in(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void processccp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l);
+void sendchap(sessionidt s, tunnelidt t);
+uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, sessionidt s, tunnelidt t, uint16_t mtype);
+void sendlcp(sessionidt s, tunnelidt t, int authtype);
void send_ipin(sessionidt s, uint8_t *buf, int len);
-void sendccp(tunnelidt t, sessionidt s);
+void sendccp(sessionidt s, tunnelidt t);
// radius.c
// l2tpns.c
clockt backoff(uint8_t try);
-void send_ipv6_ra(tunnelidt t, sessionidt s, struct in6_addr *ip);
+void send_ipv6_ra(sessionidt s, tunnelidt t, struct in6_addr *ip);
void route6set(sessionidt s, struct in6_addr ip, int prefixlen, int add);
sessionidt sessionbyip(in_addr_t ip);
sessionidt sessionbyipv6(struct in6_addr ip);
void filter_session(sessionidt s, int filter_in, int filter_out);
void send_garp(in_addr_t ip);
void tunnelsend(uint8_t *buf, uint16_t l, tunnelidt t);
-void sendipcp(tunnelidt t, sessionidt s);
-void sendipv6cp(tunnelidt t, sessionidt s);
+void sendipcp(sessionidt s, tunnelidt t);
+void sendipv6cp(sessionidt s, tunnelidt t);
void processudp(uint8_t *buf, int len, struct sockaddr_in *addr);
void snoop_send_packet(uint8_t *packet, uint16_t size, in_addr_t destination, uint16_t port);
int find_filter(char const *name, size_t len);
void _log(int level, sessionidt s, tunnelidt t, const char *format, ...) __attribute__((format (printf, 4, 5)));
void _log_hex(int level, const char *title, const uint8_t *data, int maxsize);
-int sessionsetup(tunnelidt t, sessionidt s);
+int sessionsetup(sessionidt s, tunnelidt t);
int run_plugins(int plugin_type, void *data);
void rebuild_address_pool(void);
void throttle_session(sessionidt s, int rate_in, int rate_out);
// L2TPNS PPP Stuff
-char const *cvs_id_ppp = "$Id: ppp.c,v 1.67 2005-08-10 08:59:23 bodea Exp $";
+char const *cvs_id_ppp = "$Id: ppp.c,v 1.68 2005-08-10 11:25:56 bodea Exp $";
#include <stdio.h>
#include <string.h>
static int add_lcp_auth(uint8_t *b, int size, int authtype);
// Process PAP messages
-void processpap(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processpap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
char user[MAXUSER];
char pass[MAXPASS];
// respond now, either no RADIUS available or already authenticated
uint8_t b[MAXCONTROL];
uint8_t id = p[1];
- uint8_t *p = makeppp(b, sizeof(b), 0, 0, t, s, PPPPAP);
+ uint8_t *p = makeppp(b, sizeof(b), 0, 0, s, t, PPPPAP);
if (!p) return;
if (session[s].ip)
}
// Process CHAP messages
-void processchap(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processchap(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
uint16_t r;
uint16_t hl;
}
}
-void lcp_open(tunnelidt t, sessionidt s)
+void lcp_open(sessionidt s, tunnelidt t)
{
// transition to Authentication or Network phase:
session[s].ppp.phase = sess_local[s].lcp_authtype ? Authenticate : Network;
if (session[s].ppp.phase == Authenticate)
{
if (sess_local[s].lcp_authtype == AUTHCHAP)
- sendchap(t, s);
+ sendchap(s, t);
}
else
{
// This-Layer-Up
- sendipcp(t, s);
+ sendipcp(s, t);
change_state(s, ipcp, RequestSent);
// move to passive state for IPv6 (if configured), CCP
if (config->ipv6_prefix.s6_addr[0])
{
if (!*response || **response != ConfigRej)
{
- queued = *response = makeppp(buf, blen, packet, 2, session[s].tunnel, s, mtype);
+ queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype);
if (!queued)
return 0;
if (*nak_sent >= config->ppp_max_failure)
return ppp_rej(s, buf, blen, mtype, response, 0, packet, option);
- queued = *response = makeppp(buf, blen, packet, 2, session[s].tunnel, s, mtype);
+ queued = *response = makeppp(buf, blen, packet, 2, s, session[s].tunnel, mtype);
if (!queued)
return 0;
}
// Process LCP messages
-void processlcp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processlcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
uint8_t b[MAXCONTROL];
uint8_t *q = NULL;
break;
case AckSent:
- lcp_open(t, s);
+ lcp_open(s, t);
break;
default:
else
{
// Send packet back as ConfigAck
- response = makeppp(b, sizeof(b), p, l, t, s, PPPLCP);
+ response = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
if (!response) return;
*response = ConfigAck;
}
switch (session[s].ppp.lcp)
{
case Closed:
- response = makeppp(b, sizeof(b), p, 2, t, s, PPPLCP);
+ response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP);
if (!response) return;
*response = TerminateAck;
*((uint16_t *) (response + 2)) = htons(l = 4);
case AckReceived:
if (*response == ConfigAck)
- lcp_open(t, s);
+ lcp_open(s, t);
break;
case Closed:
case Stopped:
{
- uint8_t *response = makeppp(b, sizeof(b), p, 2, t, s, PPPLCP);
+ uint8_t *response = makeppp(b, sizeof(b), p, 2, s, t, PPPLCP);
if (!response) return;
*response = TerminateAck;
*((uint16_t *) (response + 2)) = htons(l = 4);
{
LOG(3, s, t, "LCP: Received TerminateReq. Sending TerminateAck\n");
*p = TerminateAck; // close
- q = makeppp(b, sizeof(b), p, l, t, s, PPPLCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
if (!q) return;
tunnelsend(b, l + (q - b), t); // send it
sessionshutdown(s, "Remote end closed connection.", 3, 0);
LOG(5, s, t, "LCP: Received EchoReq. Sending EchoReply\n");
*p = EchoReply; // reply
*(uint32_t *) (p + 4) = htonl(session[s].magic); // our magic number
- q = makeppp(b, sizeof(b), p, l, t, s, PPPLCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
if (!q) return;
tunnelsend(b, l + (q - b), t); // send it
}
if (l > mru) l = mru;
*p = CodeRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPLCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPLCP);
if (!q) return;
LOG(3, s, t, "Unexpected LCP code %s\n", ppp_code(code));
}
}
-static void ipcp_open(tunnelidt t, sessionidt s)
+static void ipcp_open(sessionidt s, tunnelidt t)
{
LOG(3, s, t, "IPCP: Opened, session is now active\n");
// start IPv6 if configured and still in passive state
if (session[s].ppp.ipv6cp == Stopped)
{
- sendipv6cp(t, s);
+ sendipv6cp(s, t);
change_state(s, ipv6cp, RequestSent);
}
}
// Process IPCP messages
-void processipcp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processipcp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
uint8_t b[MAXCONTROL];
uint8_t *q = 0;
break;
case AckSent:
- ipcp_open(t, s);
+ ipcp_open(s, t);
break;
default:
else if (gotip)
{
// Send packet back as ConfigAck
- response = makeppp(b, sizeof(b), p, l, t, s, PPPIPCP);
+ response = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP);
if (!response) return;
*response = ConfigAck;
}
switch (session[s].ppp.ipcp)
{
case Closed:
- response = makeppp(b, sizeof(b), p, 2, t, s, PPPIPCP);
+ response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPCP);
if (!response) return;
*response = TerminateAck;
*((uint16_t *) (response + 2)) = htons(l = 4);
case AckReceived:
if (*response == ConfigAck)
- ipcp_open(t, s);
+ ipcp_open(s, t);
break;
{
LOG(3, s, t, "IPCP: Received TerminateReq. Sending TerminateAck\n");
*p = TerminateAck;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPIPCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP);
if (!q) return;
tunnelsend(b, l + (q - b), t);
change_state(s, ipcp, Stopped);
if (l > mru) l = mru;
*p = CodeRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPIPCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPIPCP);
if (!q) return;
LOG(3, s, t, "Unexpected IPCP code %s\n", ppp_code(code));
}
}
-static void ipv6cp_open(tunnelidt t, sessionidt s)
+static void ipv6cp_open(sessionidt s, tunnelidt t)
{
LOG(3, s, t, "IPV6CP: Opened\n");
route6set(s, session[s].ipv6route, session[s].ipv6prefixlen, 1);
// Send an initial RA (TODO: Should we send these regularly?)
- send_ipv6_ra(t, s, NULL);
+ send_ipv6_ra(s, t, NULL);
}
// Process IPV6CP messages
-void processipv6cp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processipv6cp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
uint8_t b[MAXCONTROL];
uint8_t *q = 0;
{
LOG(2, s, t, "IPV6CP: %s rejected (not configured)\n", ppp_code(*p));
*p = ProtocolRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPIPV6CP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP);
if (!q) return;
tunnelsend(b, l + (q - b), t);
return;
break;
case AckSent:
- ipv6cp_open(t, s);
+ ipv6cp_open(s, t);
break;
default:
else if (gotip)
{
// Send packet back as ConfigAck
- response = makeppp(b, sizeof(b), p, l, t, s, PPPIPV6CP);
+ response = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP);
if (!response) return;
*response = ConfigAck;
}
switch (session[s].ppp.ipv6cp)
{
case Closed:
- response = makeppp(b, sizeof(b), p, 2, t, s, PPPIPV6CP);
+ response = makeppp(b, sizeof(b), p, 2, s, t, PPPIPV6CP);
if (!response) return;
*response = TerminateAck;
*((uint16_t *) (response + 2)) = htons(l = 4);
case AckReceived:
if (*response == ConfigAck)
- ipv6cp_open(t, s);
+ ipv6cp_open(s, t);
break;
{
LOG(3, s, t, "IPV6CP: Received TerminateReq. Sending TerminateAck\n");
*p = TerminateAck;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPIPV6CP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP);
if (!q) return;
tunnelsend(b, l + (q - b), t);
change_state(s, ipv6cp, Stopped);
if (l > mru) l = mru;
*p = CodeRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPIPV6CP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPIPV6CP);
if (!q) return;
LOG(3, s, t, "Unexpected IPV6CP code %s\n", ppp_code(code));
//
// This MUST be called with at least 4 byte behind 'p'.
// (i.e. this routine writes to p[-4]).
-void processipin(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processipin(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
in_addr_t ip;
//
// This MUST be called with at least 4 byte behind 'p'.
// (i.e. this routine writes to p[-4]).
-void processipv6in(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processipv6in(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
struct in6_addr ip;
in_addr_t ipv4;
*(uint32_t *)(p + 34) == 0 &&
*(p + 38) == 0 && *(p + 39) == 2 && *(p + 40) == 133) {
LOG(3, s, t, "Got IPv6 RS\n");
- send_ipv6_ra(t, s, &ip);
+ send_ipv6_ra(s, t, &ip);
return;
}
// Process CCP messages
-void processccp(tunnelidt t, sessionidt s, uint8_t *p, uint16_t l)
+void processccp(sessionidt s, tunnelidt t, uint8_t *p, uint16_t l)
{
uint8_t b[MAXCONTROL];
uint8_t *q;
else // compression requested--reject
*p = ConfigRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPCCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPCCP);
if (!q) return;
switch (session[s].ppp.ccp)
{
case Closed:
- q = makeppp(b, sizeof(b), p, 2, t, s, PPPCCP);
+ q = makeppp(b, sizeof(b), p, 2, s, t, PPPCCP);
if (!q) return;
*q = TerminateAck;
*((uint16_t *) (q + 2)) = htons(l = 4);
{
LOG(3, s, t, "CCP: Received TerminateReq. Sending TerminateAck\n");
*p = TerminateAck;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPCCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPCCP);
if (!q) return;
tunnelsend(b, l + (q - b), t);
change_state(s, ccp, Stopped);
if (l > mru) l = mru;
*p = CodeRej;
- q = makeppp(b, sizeof(b), p, l, t, s, PPPCCP);
+ q = makeppp(b, sizeof(b), p, l, s, t, PPPCCP);
if (!q) return;
LOG(3, s, t, "Unexpected CCP code %s\n", ppp_code(code));
}
// send a CHAP challenge
-void sendchap(tunnelidt t, sessionidt s)
+void sendchap(sessionidt s, tunnelidt t)
{
uint8_t b[MAXCONTROL];
uint16_t r;
STAT(tunnel_tx_errors);
return ;
}
- q = makeppp(b, sizeof(b), 0, 0, t, s, PPPCHAP);
+ q = makeppp(b, sizeof(b), 0, 0, s, t, PPPCHAP);
if (!q) return;
*q = 1; // challenge
// fill in a L2TP message with a PPP frame,
// copies existing PPP message and changes magic number if seen
// returns start of PPP frame
-uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, tunnelidt t, sessionidt s, uint16_t mtype)
+uint8_t *makeppp(uint8_t *b, int size, uint8_t *p, int l, sessionidt s, tunnelidt t, uint16_t mtype)
{
if (size < 12) // Need more space than this!!
{
}
// Send initial LCP ConfigReq for MRU, authentication type and magic no
-void sendlcp(tunnelidt t, sessionidt s, int authtype)
+void sendlcp(sessionidt s, tunnelidt t, int authtype)
{
uint8_t b[500], *q, *l;
- if (!(q = makeppp(b, sizeof(b), NULL, 0, t, s, PPPLCP)))
+ if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPLCP)))
return;
LOG(4, s, t, "Sending LCP ConfigReq%s%s\n",
}
// Send CCP request for no compression
-void sendccp(tunnelidt t, sessionidt s)
+void sendccp(sessionidt s, tunnelidt t)
{
uint8_t b[500], *q;
- if (!(q = makeppp(b, sizeof(b), NULL, 0, t, s, PPPCCP)))
+ if (!(q = makeppp(b, sizeof(b), NULL, 0, s, t, PPPCCP)))
return;
LOG(4, s, t, "Sending CCP ConfigReq for no compression\n");
// L2TPNS Radius Stuff
-char const *cvs_id_radius = "$Id: radius.c,v 1.38 2005-07-31 10:35:39 bodea Exp $";
+char const *cvs_id_radius = "$Id: radius.c,v 1.39 2005-08-10 11:25:56 bodea Exp $";
#include <time.h>
#include <stdio.h>
if (radius[r].chap)
{
// CHAP
- uint8_t *p = makeppp(b, sizeof(b), 0, 0, t, s, PPPCHAP);
+ uint8_t *p = makeppp(b, sizeof(b), 0, 0, s, t, PPPCHAP);
if (!p) return; // Abort!
*p = (r_code == AccessAccept) ? 3 : 4; // ack/nak
else
{
// PAP
- uint8_t *p = makeppp(b, sizeof(b), 0, 0, t, s, PPPPAP);
+ uint8_t *p = makeppp(b, sizeof(b), 0, 0, s, t, PPPPAP);
if (!p) return; // Abort!
// ack/nak
// Valid Session, set it up
session[s].unique_id = 0;
- sessionsetup(t, s);
+ sessionsetup(s, t);
}
else
{
switch (radius[r].state)
{
case RADIUSCHAP: // sending CHAP down PPP
- sendchap(t, s);
+ sendchap(s, t);
break;
case RADIUSAUTH: // sending auth to RADIUS server
case RADIUSSTART: // sending start accounting to RADIUS server