X-Git-Url: http://git.sameswireless.fr/l2tpns.git/blobdiff_plain/4d4030929ee9bea1908e895f9e8d07a8c343b581..a350423d38f12d40b50a2d253ef2516d4409c2bc:/l2tpns.c?ds=sidebyside diff --git a/l2tpns.c b/l2tpns.c index cf66730..eb95d57 100644 --- a/l2tpns.c +++ b/l2tpns.c @@ -1,10 +1,10 @@ // L2TP Network Server // Adrian Kennard 2002 -// Copyright (c) 2003, 2004 Optus Internet Engineering +// Copyright (c) 2003, 2004, 2005 Optus Internet Engineering // 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.65 2004/12/13 02:27:31 bodea Exp $"; +char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.73.2.12 2005/05/30 06:35:19 bodea Exp $"; #include #include @@ -64,11 +64,11 @@ int *radfds = NULL; // RADIUS requests file handles int ifrfd = -1; // File descriptor for routing, etc time_t basetime = 0; // base clock char hostname[1000] = ""; // us. -static u32 sessionid = 0; // session id for radius accounting +static uint32_t sessionid = 0; // session id for radius accounting static int syslog_log = 0; // are we logging to syslog static FILE *log_stream = NULL; // file handle for direct logging (i.e. direct into file, not via syslog). extern int cluster_sockfd; // Intra-cluster communications socket. -u32 last_id = 0; // Last used PPP SID. Can I kill this?? -- mo +uint32_t last_id = 0; // Last used PPP SID. Can I kill this?? -- mo struct cli_session_actions *cli_session_actions = NULL; // Pending session changes requested by CLI struct cli_tunnel_actions *cli_tunnel_actions = NULL; // Pending tunnel changes required by CLI @@ -76,14 +76,14 @@ struct cli_tunnel_actions *cli_tunnel_actions = NULL; // Pending tunnel changes static void *ip_hash[256]; // Mapping from IP address to session structures. // Traffic counters. -static u32 udp_rx = 0, udp_rx_pkt = 0, udp_tx = 0; -static u32 eth_rx = 0, eth_rx_pkt = 0; -u32 eth_tx = 0; +static uint32_t udp_rx = 0, udp_rx_pkt = 0, udp_tx = 0; +static uint32_t eth_rx = 0, eth_rx_pkt = 0; +uint32_t eth_tx = 0; -static u32 ip_pool_size = 1; // Size of the pool of addresses used for dynamic address allocation. +static uint32_t ip_pool_size = 1; // Size of the pool of addresses used for dynamic address allocation. time_t time_now = 0; // Current time in seconds since epoch. static char time_now_string[64] = {0}; // Current time as a string. -static char main_quit = 0; // True if we're in the process of exiting. +char main_quit = 0; // True if we're in the process of exiting. linked_list *loaded_plugins; linked_list *plugins[MAX_PLUGIN_TYPES]; @@ -112,15 +112,16 @@ config_descriptt config_values[] = { CONFIG("accounting_dir", accounting_dir, STRING), CONFIG("setuid", target_uid, INT), CONFIG("dump_speed", dump_speed, BOOL), - CONFIG("cleanup_interval", cleanup_interval, INT), CONFIG("multi_read_count", multi_read_count, INT), CONFIG("scheduler_fifo", scheduler_fifo, BOOL), CONFIG("lock_pages", lock_pages, BOOL), CONFIG("icmp_rate", icmp_rate, INT), + CONFIG("packet_limit", max_packets, INT), CONFIG("cluster_address", cluster_address, IP), CONFIG("cluster_interface", cluster_interface, STRING), CONFIG("cluster_hb_interval", cluster_hb_interval, INT), CONFIG("cluster_hb_timeout", cluster_hb_timeout, INT), + CONFIG("cluster_master_min_adv", cluster_master_min_adv, INT), { NULL, 0, 0, 0 }, }; @@ -147,7 +148,7 @@ static sessionidt shut_acct_n = 0; tunnelt *tunnel = NULL; // Array of tunnel structures. sessiont *session = NULL; // Array of session structures. -sessioncountt *sess_count = NULL; // Array of partial per-session traffic counters. +sessionlocalt *sess_local = NULL; // Array of local per-session counters. radiust *radius = NULL; // Array of radius structures. ippoolt *ip_address_pool = NULL; // Array of dynamic IP addresses. ip_filtert *ip_filters = NULL; // Array of named filters. @@ -157,8 +158,8 @@ struct Tstats *_statistics = NULL; struct Tringbuffer *ringbuffer = NULL; #endif -static void cache_ipmap(ipt ip, int s); -static void uncache_ipmap(ipt ip); +static void cache_ipmap(in_addr_t ip, int s); +static void uncache_ipmap(in_addr_t ip); static void free_ip_address(sessionidt s); static void dump_acct_info(int all); static void sighup_handler(int sig); @@ -168,16 +169,19 @@ static void sigquit_handler(int sig); static void sigchild_handler(int sig); static void read_state(void); static void dump_state(void); -static void build_chap_response(char *challenge, u8 id, u16 challenge_length, char **challenge_response); +static void build_chap_response(char *challenge, uint8_t id, uint16_t challenge_length, char **challenge_response); static void update_config(void); static void read_config_file(void); static void initplugins(void); static int add_plugin(char *plugin_name); static int remove_plugin(char *plugin_name); static void plugins_done(void); -static void processcontrol(u8 * buf, int len, struct sockaddr_in *addr, int alen); +static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen); static tunnelidt new_tunnel(void); -static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length); +static int unhide_avp(uint8_t *avp, tunnelidt t, sessionidt s, uint16_t length); + +// on slaves, alow BGP to withdraw cleanly before exiting +#define QUIT_DELAY 5 // return internal time (10ths since process startup) static clockt now(void) @@ -190,7 +194,7 @@ static clockt now(void) // work out a retry time based on try number // This is a straight bounded exponential backoff. // Maximum re-try time is 32 seconds. (2^5). -clockt backoff(u8 try) +clockt backoff(uint8_t try) { if (try > 5) try = 5; // max backoff return now() + 10 * (1 << try); @@ -245,7 +249,7 @@ void _log(int level, sessionidt s, tunnelidt t, const char *format, ...) void _log_hex(int level, const char *title, const char *data, int maxsize) { int i, j; - const u8 *d = (const u8 *)data; + const uint8_t *d = (const uint8_t *) data; if (config->debug < level) return; @@ -302,7 +306,7 @@ void _log_hex(int level, const char *title, const char *data, int maxsize) // // 'ip' and 'mask' must be in _host_ order. // -static void routeset(sessionidt s, ipt ip, ipt mask, ipt gw, u8 add) +static void routeset(sessionidt s, in_addr_t ip, in_addr_t mask, in_addr_t gw, int add) { struct rtentry r; int i; @@ -314,11 +318,11 @@ static void routeset(sessionidt s, ipt ip, ipt mask, ipt gw, u8 add) memset(&r, 0, sizeof(r)); r.rt_dev = config->tundevice; r.rt_dst.sa_family = AF_INET; - *(u32 *) & (((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr) = htonl(ip); + *(uint32_t *) & (((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr) = htonl(ip); r.rt_gateway.sa_family = AF_INET; - *(u32 *) & (((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr) = htonl(gw); + *(uint32_t *) & (((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr) = htonl(gw); r.rt_genmask.sa_family = AF_INET; - *(u32 *) & (((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr) = htonl(mask); + *(uint32_t *) & (((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr) = htonl(mask); r.rt_flags = (RTF_UP | RTF_STATIC); if (gw) r.rt_flags |= RTF_GATEWAY; @@ -461,27 +465,26 @@ static void initudp(void) // IP address. // -static int lookup_ipmap(ipt ip) +static int lookup_ipmap(in_addr_t ip) { - u8 *a = (u8 *)&ip; - char **d = (char **) ip_hash; - int s; + uint8_t *a = (uint8_t *) &ip; + uint8_t **d = (uint8_t **) ip_hash; - if (!(d = (char **) d[(size_t) *a++])) return 0; - if (!(d = (char **) d[(size_t) *a++])) return 0; - if (!(d = (char **) d[(size_t) *a++])) return 0; + if (!(d = (uint8_t **) d[(size_t) *a++])) return 0; + if (!(d = (uint8_t **) d[(size_t) *a++])) return 0; + if (!(d = (uint8_t **) d[(size_t) *a++])) return 0; - s = (ipt) d[(size_t) *a]; - return s; + return (int) (intptr_t) d[(size_t) *a]; } -sessionidt sessionbyip(ipt ip) +sessionidt sessionbyip(in_addr_t ip) { int s = lookup_ipmap(ip); CSTAT(call_sessionbyip); - if (s > 0 && s < MAXSESSION && session[s].tunnel) - return s; + if (s > 0 && s < MAXSESSION && session[s].opened) + return (sessionidt) s; + return 0; } @@ -491,25 +494,25 @@ sessionidt sessionbyip(ipt ip) // // (It's actually cached in network order) // -static void cache_ipmap(ipt ip, int s) +static void cache_ipmap(in_addr_t ip, int s) { - ipt nip = htonl(ip); // MUST be in network order. I.e. MSB must in be ((char*)(&ip))[0] - u8 *a = (u8 *) &nip; - char **d = (char **) ip_hash; + in_addr_t nip = htonl(ip); // MUST be in network order. I.e. MSB must in be ((char *) (&ip))[0] + uint8_t *a = (uint8_t *) &nip; + uint8_t **d = (uint8_t **) ip_hash; int i; for (i = 0; i < 3; i++) { if (!d[(size_t) a[i]]) { - if (!(d[(size_t) a[i]] = calloc(256, sizeof (void *)))) + if (!(d[(size_t) a[i]] = calloc(256, sizeof(void *)))) return; } - d = (char **) d[(size_t) a[i]]; + d = (uint8_t **) d[(size_t) a[i]]; } - d[(size_t) a[3]] = (char *)((int)s); + d[(size_t) a[3]] = (uint8_t *) (intptr_t) s; if (s > 0) LOG(4, s, session[s].tunnel, "Caching ip address %s\n", fmtaddr(nip, 0)); @@ -519,7 +522,7 @@ static void cache_ipmap(ipt ip, int s) // else a map to an ip pool index. } -static void uncache_ipmap(ipt ip) +static void uncache_ipmap(in_addr_t ip) { cache_ipmap(ip, 0); // Assign it to the NULL session. } @@ -542,22 +545,22 @@ int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc) { if (!d[i]) continue; - e = (char**) d[i]; + e = (char **) d[i]; for (j = 0; j < 256; ++j) { if (!e[j]) continue; - f = (char**) e[j]; + f = (char **) e[j]; for (k = 0; k < 256; ++k) { if (!f[k]) continue; - g = (char**)f[k]; + g = (char **)f[k]; for (l = 0; l < 256; ++l) { if (!g[l]) continue; - cli_print(cli, "%7d %d.%d.%d.%d", (int) g[l], i, j, k, l); + cli_print(cli, "%7d %d.%d.%d.%d", (int) (intptr_t) g[l], i, j, k, l); ++count; } } @@ -579,8 +582,11 @@ sessionidt sessionbyuser(char *username) int s; CSTAT(call_sessionbyuser); - for (s = 1; s < MAXSESSION ; ++s) + for (s = 1; s <= config->cluster_highest_sessionid ; ++s) { + if (!session[s].opened) + continue; + if (session[s].walled_garden) continue; // Skip walled garden users. @@ -591,11 +597,11 @@ sessionidt sessionbyuser(char *username) return 0; // Not found. } -void send_garp(ipt ip) +void send_garp(in_addr_t ip) { int s; struct ifreq ifr; - u8 mac[6]; + uint8_t mac[6]; s = socket(PF_INET, SOCK_DGRAM, 0); if (s < 0) @@ -622,22 +628,21 @@ void send_garp(ipt ip) sendarp(ifr.ifr_ifindex, mac, ip); } -// Find session by username, 0 for not found static sessiont *sessiontbysessionidt(sessionidt s) { - if (!s || s > MAXSESSION) return NULL; + if (!s || s >= MAXSESSION) return NULL; return &session[s]; } static sessionidt sessionidtbysessiont(sessiont *s) { sessionidt val = s-session; - if (s < session || val > MAXSESSION) return 0; + if (s < session || val >= MAXSESSION) return 0; return val; } // actually send a control message for a specific tunnel -void tunnelsend(u8 * buf, u16 l, tunnelidt t) +void tunnelsend(uint8_t * buf, uint16_t l, tunnelidt t) { struct sockaddr_in addr; @@ -663,11 +668,11 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t) memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; - *(u32 *) & addr.sin_addr = htonl(tunnel[t].ip); + *(uint32_t *) & addr.sin_addr = htonl(tunnel[t].ip); addr.sin_port = htons(tunnel[t].port); // sequence expected, if sequence in message - if (*buf & 0x08) *(u16 *) (buf + ((*buf & 0x40) ? 10 : 8)) = htons(tunnel[t].nr); + if (*buf & 0x08) *(uint16_t *) (buf + ((*buf & 0x40) ? 10 : 8)) = htons(tunnel[t].nr); // If this is a control message, deal with retries if (*buf & 0x80) @@ -683,7 +688,7 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t) if (sendto(udpfd, buf, l, 0, (void *) &addr, sizeof(addr)) < 0) { - LOG(0, ntohs((*(u16 *) (buf + 6))), t, "Error sending data out tunnel: %s (udpfd=%d, buf=%p, len=%d, dest=%s)\n", + LOG(0, ntohs((*(uint16_t *) (buf + 6))), t, "Error sending data out tunnel: %s (udpfd=%d, buf=%p, len=%d, dest=%s)\n", strerror(errno), udpfd, buf, l, inet_ntoa(addr.sin_addr)); STAT(tunnel_tx_errors); return; @@ -698,37 +703,37 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t) // Tiny helper function to write data to // the 'tun' device. // -int tun_write(u8 * data, int size) +int tun_write(uint8_t * data, int size) { return write(tunfd, data, size); } // process outgoing (to tunnel) IP // -static void processipout(u8 * buf, int len) +static void processipout(uint8_t * buf, int len) { sessionidt s; sessiont *sp; tunnelidt t; - ipt ip; + in_addr_t ip; - char * data = buf; // Keep a copy of the originals. + char *data = buf; // Keep a copy of the originals. int size = len; - u8 b[MAXETHER + 20]; + uint8_t b[MAXETHER + 20]; CSTAT(call_processipout); if (len < MIN_IP_SIZE) { LOG(1, 0, 0, "Short IP, %d bytes\n", len); - STAT(tunnel_tx_errors); + STAT(tun_rx_errors); return; } if (len >= MAXETHER) { LOG(1, 0, 0, "Oversize IP packet %d bytes\n", len); - STAT(tunnel_tx_errors); + STAT(tun_rx_errors); return; } @@ -737,13 +742,13 @@ static void processipout(u8 * buf, int len) len -= 4; // Got an IP header now - if (*(u8 *)(buf) >> 4 != 4) + if (*(uint8_t *)(buf) >> 4 != 4) { LOG(1, 0, 0, "IP: Don't understand anything except IPv4\n"); return; } - ip = *(u32 *)(buf + 16); + ip = *(uint32_t *)(buf + 16); if (!(s = sessionbyip(ip))) { // Is this a packet for a session that doesn't exist? @@ -758,14 +763,53 @@ static void processipout(u8 * buf, int len) if (rate++ < config->icmp_rate) // Only send a max of icmp_rate per second. { - LOG(4, 0, 0, "IP: Sending ICMP host unreachable to %s\n", fmtaddr(*(u32 *)(buf + 12), 0)); - host_unreachable(*(u32 *)(buf + 12), *(u16 *)(buf + 4), ip, buf, (len < 64) ? 64 : len); + LOG(4, 0, 0, "IP: Sending ICMP host unreachable to %s\n", fmtaddr(*(in_addr_t *)(buf + 12), 0)); + host_unreachable(*(in_addr_t *)(buf + 12), *(uint16_t *)(buf + 4), ip, buf, (len < 64) ? 64 : len); } return; } t = session[s].tunnel; sp = &session[s]; + // DoS prevention: enforce a maximum number of packets per 0.1s for a session + if (config->max_packets > 0) + { + if (sess_local[s].last_packet_out == TIME) + { + int max = config->max_packets; + + // All packets for throttled sessions are handled by the + // master, so further limit by using the throttle rate. + // A bit of a kludge, since throttle rate is in kbps, + // but should still be generous given our average DSL + // packet size is 200 bytes: a limit of 28kbps equates + // to around 180 packets per second. + if (!config->cluster_iam_master && sp->throttle_out && sp->throttle_out < max) + max = sp->throttle_out; + + if (++sess_local[s].packets_out > max) + { + sess_local[s].packets_dropped++; + return; + } + } + else + { + if (sess_local[s].packets_dropped) + { + INC_STAT(tun_rx_dropped, sess_local[s].packets_dropped); + LOG(3, s, t, "Dropped %u/%u packets to %s for %suser %s\n", + sess_local[s].packets_dropped, sess_local[s].packets_out, + fmtaddr(ip, 0), sp->throttle_out ? "throttled " : "", + sp->user); + } + + sess_local[s].last_packet_out = TIME; + sess_local[s].packets_out = 1; + sess_local[s].packets_dropped = 0; + } + } + // run access-list if any if (session[s].filter_out && !ip_filter(buf, len, session[s].filter_out - 1)) return; @@ -790,7 +834,7 @@ static void processipout(u8 * buf, int len) // Add on L2TP header { - u8 *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP); + uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP); if (!p) return; tunnelsend(b, len + (p-b), t); // send it... } @@ -803,20 +847,20 @@ static void processipout(u8 * buf, int len) sp->total_cout += len; // byte count sp->pout++; udp_tx += len; - sess_count[s].cout += len; // To send to master.. + sess_local[s].cout += len; // To send to master.. } // // Helper routine for the TBF filters. // Used to send queued data in to the user! // -static void send_ipout(sessionidt s, u8 *buf, int len) +static void send_ipout(sessionidt s, uint8_t *buf, int len) { sessiont *sp; tunnelidt t; - ipt ip; + in_addr_t ip; - u8 b[MAXETHER + 20]; + uint8_t b[MAXETHER + 20]; if (len < 0 || len > MAXETHER) { @@ -828,7 +872,7 @@ static void send_ipout(sessionidt s, u8 *buf, int len) buf += 4; len -= 4; - ip = *(u32 *)(buf + 16); + ip = *(in_addr_t *)(buf + 16); if (!session[s].ip) return; @@ -840,7 +884,7 @@ static void send_ipout(sessionidt s, u8 *buf, int len) // Add on L2TP header { - u8 *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP); + uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP); if (!p) return; tunnelsend(b, len + (p-b), t); // send it... } @@ -853,55 +897,55 @@ static void send_ipout(sessionidt s, u8 *buf, int len) sp->total_cout += len; // byte count sp->pout++; udp_tx += len; - sess_count[s].cout += len; // To send to master.. + sess_local[s].cout += len; // To send to master.. } // add an AVP (16 bit) -static void control16(controlt * c, u16 avp, u16 val, u8 m) +static void control16(controlt * c, uint16_t avp, uint16_t val, uint8_t m) { - u16 l = (m ? 0x8008 : 0x0008); - *(u16 *) (c->buf + c->length + 0) = htons(l); - *(u16 *) (c->buf + c->length + 2) = htons(0); - *(u16 *) (c->buf + c->length + 4) = htons(avp); - *(u16 *) (c->buf + c->length + 6) = htons(val); + uint16_t l = (m ? 0x8008 : 0x0008); + *(uint16_t *) (c->buf + c->length + 0) = htons(l); + *(uint16_t *) (c->buf + c->length + 2) = htons(0); + *(uint16_t *) (c->buf + c->length + 4) = htons(avp); + *(uint16_t *) (c->buf + c->length + 6) = htons(val); c->length += 8; } // add an AVP (32 bit) -static void control32(controlt * c, u16 avp, u32 val, u8 m) +static void control32(controlt * c, uint16_t avp, uint32_t val, uint8_t m) { - u16 l = (m ? 0x800A : 0x000A); - *(u16 *) (c->buf + c->length + 0) = htons(l); - *(u16 *) (c->buf + c->length + 2) = htons(0); - *(u16 *) (c->buf + c->length + 4) = htons(avp); - *(u32 *) (c->buf + c->length + 6) = htonl(val); + uint16_t l = (m ? 0x800A : 0x000A); + *(uint16_t *) (c->buf + c->length + 0) = htons(l); + *(uint16_t *) (c->buf + c->length + 2) = htons(0); + *(uint16_t *) (c->buf + c->length + 4) = htons(avp); + *(uint32_t *) (c->buf + c->length + 6) = htonl(val); c->length += 10; } // add an AVP (32 bit) -static void controls(controlt * c, u16 avp, char *val, u8 m) +static void controls(controlt * c, uint16_t avp, char *val, uint8_t m) { - u16 l = ((m ? 0x8000 : 0) + strlen(val) + 6); - *(u16 *) (c->buf + c->length + 0) = htons(l); - *(u16 *) (c->buf + c->length + 2) = htons(0); - *(u16 *) (c->buf + c->length + 4) = htons(avp); + uint16_t l = ((m ? 0x8000 : 0) + strlen(val) + 6); + *(uint16_t *) (c->buf + c->length + 0) = htons(l); + *(uint16_t *) (c->buf + c->length + 2) = htons(0); + *(uint16_t *) (c->buf + c->length + 4) = htons(avp); memcpy(c->buf + c->length + 6, val, strlen(val)); c->length += 6 + strlen(val); } // add a binary AVP -static void controlb(controlt * c, u16 avp, char *val, unsigned int len, u8 m) +static void controlb(controlt * c, uint16_t avp, char *val, unsigned int len, uint8_t m) { - u16 l = ((m ? 0x8000 : 0) + len + 6); - *(u16 *) (c->buf + c->length + 0) = htons(l); - *(u16 *) (c->buf + c->length + 2) = htons(0); - *(u16 *) (c->buf + c->length + 4) = htons(avp); + uint16_t l = ((m ? 0x8000 : 0) + len + 6); + *(uint16_t *) (c->buf + c->length + 0) = htons(l); + *(uint16_t *) (c->buf + c->length + 2) = htons(0); + *(uint16_t *) (c->buf + c->length + 4) = htons(avp); memcpy(c->buf + c->length + 6, val, len); c->length += 6 + len; } // new control connection -static controlt *controlnew(u16 mtype) +static controlt *controlnew(uint16_t mtype) { controlt *c; if (!controlfree) @@ -913,7 +957,7 @@ static controlt *controlnew(u16 mtype) } assert(c); c->next = 0; - *(u16 *) (c->buf + 0) = htons(0xC802); // flags/ver + *(uint16_t *) (c->buf + 0) = htons(0xC802); // flags/ver c->length = 12; control16(c, 0, mtype, 1); return c; @@ -923,26 +967,26 @@ static controlt *controlnew(u16 mtype) // (ZLB send). static void controlnull(tunnelidt t) { - u8 buf[12]; + uint8_t buf[12]; if (tunnel[t].controlc) // Messages queued; They will carry the ack. return; - *(u16 *) (buf + 0) = htons(0xC802); // flags/ver - *(u16 *) (buf + 2) = htons(12); // length - *(u16 *) (buf + 4) = htons(tunnel[t].far); // tunnel - *(u16 *) (buf + 6) = htons(0); // session - *(u16 *) (buf + 8) = htons(tunnel[t].ns); // sequence - *(u16 *) (buf + 10) = htons(tunnel[t].nr); // sequence + *(uint16_t *) (buf + 0) = htons(0xC802); // flags/ver + *(uint16_t *) (buf + 2) = htons(12); // length + *(uint16_t *) (buf + 4) = htons(tunnel[t].far); // tunnel + *(uint16_t *) (buf + 6) = htons(0); // session + *(uint16_t *) (buf + 8) = htons(tunnel[t].ns); // sequence + *(uint16_t *) (buf + 10) = htons(tunnel[t].nr); // sequence tunnelsend(buf, 12, t); } // add a control message to a tunnel, and send if within window static void controladd(controlt * c, tunnelidt t, sessionidt s) { - *(u16 *) (c->buf + 2) = htons(c->length); // length - *(u16 *) (c->buf + 4) = htons(tunnel[t].far); // tunnel - *(u16 *) (c->buf + 6) = htons(s ? session[s].far : 0); // session - *(u16 *) (c->buf + 8) = htons(tunnel[t].ns); // sequence + *(uint16_t *) (c->buf + 2) = htons(c->length); // length + *(uint16_t *) (c->buf + 4) = htons(tunnel[t].far); // tunnel + *(uint16_t *) (c->buf + 6) = htons(s ? session[s].far : 0); // session + *(uint16_t *) (c->buf + 8) = htons(tunnel[t].ns); // sequence tunnel[t].ns++; // advance sequence // link in message in to queue if (tunnel[t].controlc) @@ -973,7 +1017,7 @@ static void controladd(controlt * c, tunnelidt t, sessionidt s) // void throttle_session(sessionidt s, int rate_in, int rate_out) { - if (!session[s].tunnel) + if (!session[s].opened) return; // No-one home. if (!*session[s].user) @@ -1011,7 +1055,7 @@ void throttle_session(sessionidt s, int rate_in, int rate_out) // add/remove filters from session (-1 = no change) void filter_session(sessionidt s, int filter_in, int filter_out) { - if (!session[s].tunnel) + if (!session[s].opened) return; // No-one home. if (!*session[s].user) @@ -1054,9 +1098,9 @@ void sessionshutdown(sessionidt s, char *reason) CSTAT(call_sessionshutdown); - if (!session[s].tunnel) + if (!session[s].opened) { - LOG(3, s, session[s].tunnel, "Called sessionshutdown on a session with no tunnel.\n"); + LOG(3, s, session[s].tunnel, "Called sessionshutdown on an unopened session.\n"); return; // not a live session } @@ -1067,16 +1111,15 @@ void sessionshutdown(sessionidt s, char *reason) run_plugins(PLUGIN_KILL_SESSION, &data); } - if (session[s].opened && !walled_garden && !session[s].die) + if (session[s].ip && !walled_garden && !session[s].die) { // RADIUS Stop message - u16 r = session[s].radius; + uint16_t r = session[s].radius; if (!r) { if (!(r = radiusnew(s))) { LOG(1, s, session[s].tunnel, "No free RADIUS sessions for Stop message\n"); - STAT(radius_overflow); } else { @@ -1128,7 +1171,7 @@ void sessionshutdown(sessionidt s, char *reason) } if (!session[s].die) - session[s].die = now() + 150; // Clean up in 15 seconds + session[s].die = TIME + 150; // Clean up in 15 seconds // update filter refcounts if (session[s].filter_in) ip_filters[session[s].filter_in - 1].used--; @@ -1139,15 +1182,21 @@ void sessionshutdown(sessionidt s, char *reason) void sendipcp(tunnelidt t, sessionidt s) { - u8 buf[MAXCONTROL]; - u16 r = session[s].radius; - u8 *q; + uint8_t buf[MAXCONTROL]; + uint16_t r = session[s].radius; + uint8_t *q; CSTAT(call_sendipcp); if (!r) r = radiusnew(s); + if (!r) + { + sessionshutdown(s, "No free RADIUS sessions for IPCP"); + return; + } + if (radius[r].state != RADIUSIPCP) { radius[r].state = RADIUSIPCP; @@ -1166,36 +1215,51 @@ void sendipcp(tunnelidt t, sessionidt s) if (!q) return; *q = ConfigReq; - q[1] = r << RADIUS_SHIFT; // ID, dont care, we only send one type of request - *(u16 *) (q + 2) = htons(10); + q[1] = r >> RADIUS_SHIFT; // ID, dont care, we only send one type of request + *(uint16_t *) (q + 2) = htons(10); q[4] = 3; q[5] = 6; - *(u32 *) (q + 6) = config->peer_address ? config->peer_address : - config->bind_address ? config->bind_address : - my_address; // send my IP + *(in_addr_t *) (q + 6) = config->peer_address ? config->peer_address : + config->bind_address ? config->bind_address : + my_address; // send my IP tunnelsend(buf, 10 + (q - buf), t); // send it session[s].flags &= ~SF_IPCP_ACKED; // Clear flag. } +static void sessionclear(sessionidt s) +{ + memset(&session[s], 0, sizeof(session[s])); + memset(&sess_local[s], 0, sizeof(sess_local[s])); + memset(&cli_session_actions[s], 0, sizeof(cli_session_actions[s])); + + session[s].tunnel = T_FREE; // Mark it as free. + session[s].next = sessionfree; + sessionfree = s; +} + // kill a session now -static void sessionkill(sessionidt s, char *reason) +void sessionkill(sessionidt s, char *reason) { CSTAT(call_sessionkill); - session[s].die = now(); + if (!session[s].opened) // not alive + return; + + if (session[s].next) + { + LOG(0, s, session[s].tunnel, "Tried to kill a session with next pointer set (%d)\n", session[s].next); + return; + } + + session[s].die = TIME; sessionshutdown(s, reason); // close radius/routes, etc. if (session[s].radius) radiusclear(session[s].radius, s); // cant send clean accounting data, session is killed LOG(2, s, session[s].tunnel, "Kill session %d (%s): %s\n", s, session[s].user, reason); - - memset(&session[s], 0, sizeof(session[s])); - session[s].tunnel = T_FREE; // Mark it as free. - session[s].next = sessionfree; - sessionfree = s; - cli_session_actions[s].action = 0; + sessionclear(s); cluster_send_session(s); } @@ -1226,7 +1290,7 @@ static void tunnelkill(tunnelidt t, char *reason) controlfree = c; } // kill sessions - for (s = 1; s < MAXSESSION; s++) + for (s = 1; s <= config->cluster_highest_sessionid ; ++s) if (session[s].tunnel == t) sessionkill(s, reason); @@ -1253,12 +1317,12 @@ static void tunnelshutdown(tunnelidt t, char *reason) LOG(1, 0, t, "Shutting down tunnel %d (%s)\n", t, reason); // close session - for (s = 1; s < MAXSESSION; s++) + for (s = 1; s <= config->cluster_highest_sessionid ; ++s) if (session[s].tunnel == t) sessionshutdown(s, reason); tunnel[t].state = TUNNELDIE; - tunnel[t].die = now() + 700; // Clean up in 70 seconds + tunnel[t].die = TIME + 700; // Clean up in 70 seconds cluster_send_tunnel(t); // TBA - should we wait for sessions to stop? { // Send StopCCN @@ -1270,11 +1334,11 @@ static void tunnelshutdown(tunnelidt t, char *reason) } // read and process packet on tunnel (UDP) -void processudp(u8 * buf, int len, struct sockaddr_in *addr) +void processudp(uint8_t * buf, int len, struct sockaddr_in *addr) { char *chapresponse = NULL; - u16 l = len, t = 0, s = 0, ns = 0, nr = 0; - u8 *p = buf + 2; + uint16_t l = len, t = 0, s = 0, ns = 0, nr = 0; + uint8_t *p = buf + 2; CSTAT(call_processudp); @@ -1298,12 +1362,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } if (*buf & 0x40) { // length - l = ntohs(*(u16 *) p); + l = ntohs(*(uint16_t *) p); p += 2; } - t = ntohs(*(u16 *) p); + t = ntohs(*(uint16_t *) p); p += 2; - s = ntohs(*(u16 *) p); + s = ntohs(*(uint16_t *) p); p += 2; if (s >= MAXSESSION) { @@ -1319,36 +1383,36 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } if (*buf & 0x08) { // ns/nr - ns = ntohs(*(u16 *) p); + ns = ntohs(*(uint16_t *) p); p += 2; - nr = ntohs(*(u16 *) p); + nr = ntohs(*(uint16_t *) p); p += 2; } if (*buf & 0x02) { // offset - u16 o = ntohs(*(u16 *) p); + uint16_t o = ntohs(*(uint16_t *) p); p += o + 2; } if ((p - buf) > l) { - LOG(1, s, t, "Bad length %d>%d\n", (p - buf), l); + LOG(1, s, t, "Bad length %d>%d\n", (int) (p - buf), l); STAT(tunnel_rx_errors); return; } l -= (p - buf); if (*buf & 0x80) { // control - u16 message = 0xFFFF; // message type - u8 fatal = 0; - u8 mandatorymessage = 0; - u8 chap = 0; // if CHAP being used - u16 asession = 0; // assigned session - u32 amagic = 0; // magic number - u8 aflags = 0; // flags from last LCF - u16 version = 0x0100; // protocol version (we handle 0.0 as well and send that back just in case) - int requestchap = 0; // do we request PAP instead of original CHAP request? - char called[MAXTEL] = ""; // called number - char calling[MAXTEL] = ""; // calling number + uint16_t message = 0xFFFF; // message type + uint8_t fatal = 0; + uint8_t mandatorymessage = 0; + uint8_t chap = 0; // if CHAP being used + uint16_t asession = 0; // assigned session + uint32_t amagic = 0; // magic number + uint8_t aflags = 0; // flags from last LCF + uint16_t version = 0x0100; // protocol version (we handle 0.0 as well and send that back just in case) + int requestchap = 0; // do we request PAP instead of original CHAP request? + char called[MAXTEL] = ""; // called number + char calling[MAXTEL] = ""; // calling number if (!config->cluster_iam_master) { @@ -1374,7 +1438,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) for (i = 1; i <= config->cluster_highest_tunnelid ; ++i) { if (tunnel[i].state != TUNNELOPENING || - tunnel[i].ip != ntohl(*(ipt *) & addr->sin_addr) || + tunnel[i].ip != ntohl(*(in_addr_t *) & addr->sin_addr) || tunnel[i].port != ntohs(addr->sin_port) ) continue; t = i; @@ -1396,7 +1460,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) return; } tunnelclear(t); - tunnel[t].ip = ntohl(*(ipt *) & addr->sin_addr); + tunnel[t].ip = ntohl(*(in_addr_t *) & addr->sin_addr); tunnel[t].port = ntohs(addr->sin_port); tunnel[t].window = 4; // default window STAT(tunnel_created); @@ -1469,10 +1533,10 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) // process AVPs while (l && !(fatal & 0x80)) { - u16 n = (ntohs(*(u16 *) p) & 0x3FF); - u8 *b = p; - u8 flags = *p; - u16 mtype; + uint16_t n = (ntohs(*(uint16_t *) p) & 0x3FF); + uint8_t *b = p; + uint8_t flags = *p; + uint16_t mtype; p += n; // next if (l < n) { @@ -1513,14 +1577,14 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) continue; // next } b += 2; - if (*(u16 *) (b)) + if (*(uint16_t *) (b)) { - LOG(2, s, t, "Unknown AVP vendor %d\n", ntohs(*(u16 *) (b))); + LOG(2, s, t, "Unknown AVP vendor %d\n", ntohs(*(uint16_t *) (b))); fatal = flags; continue; // next } b += 2; - mtype = ntohs(*(u16 *) (b)); + mtype = ntohs(*(uint16_t *) (b)); b += 2; n -= 6; @@ -1528,13 +1592,13 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) switch (mtype) { case 0: // message type - message = ntohs(*(u16 *) b); + message = ntohs(*(uint16_t *) b); LOG(4, s, t, " Message type = %d (%s)\n", *b, l2tp_message_types[message]); mandatorymessage = flags; break; case 1: // result code { - u16 rescode = ntohs(*(u16 *)(b)); + uint16_t rescode = ntohs(*(uint16_t *) b); const char* resdesc = "(unknown)"; if (message == 4) { /* StopCCN */ @@ -1550,7 +1614,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) LOG(4, s, t, " Result Code %d: %s\n", rescode, resdesc); if (n >= 4) { - u16 errcode = ntohs(*(u16 *)(b + 2)); + uint16_t errcode = ntohs(*(uint16_t *)(b + 2)); const char* errdesc = "(unknown)"; if (errcode <= MAX_ERROR_CODE) errdesc = error_codes[errcode]; @@ -1564,7 +1628,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) break; case 2: // protocol version { - version = ntohs(*(u16 *) (b)); + version = ntohs(*(uint16_t *) (b)); LOG(4, s, t, " Protocol version = %d\n", version); if (version && version != 0x0100) { // allow 0.0 and 1.0 @@ -1599,11 +1663,11 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) LOG(4, s, t, " Vendor name = \"%s\"\n", tunnel[t].vendor); break; case 9: // assigned tunnel - tunnel[t].far = ntohs(*(u16 *) (b)); + tunnel[t].far = ntohs(*(uint16_t *) (b)); LOG(4, s, t, " Remote tunnel id = %d\n", tunnel[t].far); break; case 10: // rx window - tunnel[t].window = ntohs(*(u16 *) (b)); + tunnel[t].window = ntohs(*(uint16_t *) (b)); if (!tunnel[t].window) tunnel[t].window = 1; // window of 0 is silly LOG(4, s, t, " rx window = %d\n", tunnel[t].window); @@ -1620,18 +1684,18 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) break; case 14: // assigned session - asession = session[s].far = ntohs(*(u16 *) (b)); + asession = session[s].far = ntohs(*(uint16_t *) (b)); LOG(4, s, t, " assigned session = %d\n", asession); break; case 15: // call serial number - LOG(4, s, t, " call serial number = %d\n", ntohl(*(u32 *)b)); + LOG(4, s, t, " call serial number = %d\n", ntohl(*(uint32_t *)b)); break; case 18: // bearer type - LOG(4, s, t, " bearer type = %d\n", ntohl(*(u32 *)b)); + LOG(4, s, t, " bearer type = %d\n", ntohl(*(uint32_t *)b)); // TBA - for RADIUS break; case 19: // framing type - LOG(4, s, t, " framing type = %d\n", ntohl(*(u32 *)b)); + LOG(4, s, t, " framing type = %d\n", ntohl(*(uint32_t *)b)); // TBA break; case 21: // called number @@ -1649,7 +1713,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) case 24: // tx connect speed if (n == 4) { - session[s].tx_connect_speed = ntohl(*(u32 *)b); + session[s].tx_connect_speed = ntohl(*(uint32_t *)b); } else { @@ -1663,7 +1727,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) case 38: // rx connect speed if (n == 4) { - session[s].rx_connect_speed = ntohl(*(u32 *)b); + session[s].rx_connect_speed = ntohl(*(uint32_t *)b); } else { @@ -1676,13 +1740,13 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) break; case 25: // Physical Channel ID { - u32 tmp = ntohl(*(u32 *)b); + uint32_t tmp = ntohl(*(uint32_t *) b); LOG(4, s, t, " Physical Channel ID <%X>\n", tmp); break; } case 29: // Proxy Authentication Type { - u16 authtype = ntohs(*(u16 *)b); + uint16_t authtype = ntohs(*(uint16_t *)b); LOG(4, s, t, " Proxy Auth Type %d (%s)\n", authtype, authtypes[authtype]); requestchap = (authtype == 2); break; @@ -1703,7 +1767,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } case 32: // Proxy Authentication ID { - u16 authid = ntohs(*(u16 *)(b)); + uint16_t authid = ntohs(*(uint16_t *)(b)); LOG(4, s, t, " Proxy Auth ID (%d)\n", authid); if (session[s].radius) radius[session[s].radius].id = authid; @@ -1718,12 +1782,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } case 27: // last send lcp { // find magic number - u8 *p = b, *e = p + n; + uint8_t *p = b, *e = p + n; while (p + 1 < e && p[1] && p + p[1] <= e) { if (*p == 5 && p[1] == 6) // Magic-Number - amagic = ntohl(*(u32 *) (p + 2)); - else if (*p == 3 && p[1] == 5 && *(u16 *) (p + 2) == htons(PPPCHAP) && p[4] == 5) // Authentication-Protocol + amagic = ntohl(*(uint32_t *) (p + 2)); + else if (*p == 3 && p[1] == 5 && *(uint16_t *) (p + 2) == htons(PPPCHAP) && p[4] == 5) // Authentication-Protocol chap = 1; else if (*p == 7) // Protocol-Field-Compression aflags |= SESSIONPFC; @@ -1797,11 +1861,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) if (!sessionfree) { STAT(session_overflow); - tunnelshutdown(t, "No free sessions"); + LOG(1, 0, t, "No free sessions\n"); + return; } else { - u16 r; + uint16_t r; controlt *c; s = sessionfree; @@ -1815,13 +1880,13 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) if (!(r = radiusnew(s))) { LOG(1, s, t, "No free RADIUS sessions for ICRQ\n"); - sessionkill(s, "no free RADIUS sesions"); + sessionclear(s); return; } c = controlnew(11); // sending ICRP session[s].id = sessionid++; - session[s].opened = time(NULL); + session[s].opened = time_now; session[s].tunnel = t; session[s].far = asession; session[s].last_packet = time_now; @@ -1878,7 +1943,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } else { // data - u16 prot; + uint16_t prot; LOG_HEX(5, "Receive Tunnel Data", p, l); if (l > 2 && p[0] == 0xFF && p[1] == 0x03) @@ -1899,12 +1964,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } else { - prot = ntohs(*(u16 *) p); + prot = ntohs(*(uint16_t *) p); p += 2; l -= 2; } - if (s && !session[s].tunnel) // Is something wrong?? + if (s && !session[s].opened) // Is something wrong?? { if (!config->cluster_iam_master) { @@ -1913,10 +1978,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) return; } - - LOG(1, s, t, "UDP packet contains session %d but no session[%d].tunnel " - "exists (LAC said tunnel = %d). Dropping packet.\n", s, s, t); - + LOG(1, s, t, "UDP packet contains session which is not opened. Dropping packet.\n"); STAT(tunnel_rx_errors); return; } @@ -1977,7 +2039,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr) } // read and process packet on tun -static void processtun(u8 * buf, int len) +static void processtun(uint8_t * buf, int len) { LOG_HEX(5, "Receive TUN Data", buf, len); STAT(tun_rx_packets); @@ -1994,47 +2056,69 @@ static void processtun(u8 * buf, int len) return; } - if (*(u16 *) (buf + 2) == htons(PKTIP)) // IP + if (*(uint16_t *) (buf + 2) == htons(PKTIP)) // IP processipout(buf, len); // Else discard. } -// -// Maximum number of actions to complete. -// This is to avoid sending out too many packets -// at once. -#define MAX_ACTIONS 500 - -static int regular_cleanups(void) +// Handle retries, timeouts. Runs every 1/10th sec, want to ensure +// that we look at the whole of the tunnel, radius and session tables +// every second +static void regular_cleanups(int period) { - static sessionidt s = 0; // Next session to check for actions on. - tunnelidt t; - int count=0,i; - u16 r; - static clockt next_acct = 0; - static clockt next_shut_acct = 0; + // Next tunnel, radius and session to check for actions on. + static tunnelidt t = 0; + static int r = 0; + static sessionidt s = 0; + + int t_actions = 0; + int r_actions = 0; + int s_actions = 0; + + int t_slice; + int r_slice; + int s_slice; + + int i; int a; - LOG(3, 0, 0, "Begin regular cleanup\n"); + // paranoia + if (period < 1) period = 1; - for (r = 1; r < MAXRADIUS; r++) - { - if (!radius[r].state) - continue; - if (radius[r].retry) - { - if (radius[r].retry <= TIME) - radiusretry(r); - } else - radius[r].retry = backoff(radius[r].try+1); // Is this really needed? --mo - } - for (t = 1; t <= config->cluster_highest_tunnelid; t++) + // divide up tables into period * 1/10th sec slices + t_slice = config->cluster_highest_tunnelid / 10.0 * period + 0.5; + r_slice = (MAXRADIUS - 1) / 10.0 * period + 0.5; + s_slice = config->cluster_highest_sessionid / 10.0 * period + 0.5; + + if (t_slice < 1) + t_slice = 1; + else if (t_slice > config->cluster_highest_tunnelid) + t_slice = config->cluster_highest_tunnelid; + + if (r_slice < 1) + r_slice = 1; + else if (r_slice > (MAXRADIUS - 1)) + r_slice = MAXRADIUS - 1; + + if (s_slice < 1) + s_slice = 1; + else if (s_slice > config->cluster_highest_sessionid) + s_slice = config->cluster_highest_sessionid; + + LOG(4, 0, 0, "Begin regular cleanup (last %d/10s ago)\n", period); + + for (i = 0; i < t_slice; i++) { + t++; + if (t > config->cluster_highest_tunnelid) + t = 1; + // check for expired tunnels if (tunnel[t].die && tunnel[t].die <= TIME) { STAT(tunnel_timeout); tunnelkill(t, "Expired"); + t_actions++; continue; } // check for message resend @@ -2044,7 +2128,7 @@ static int regular_cleanups(void) if (tunnel[t].retry <= TIME) { controlt *c = tunnel[t].controls; - u8 w = tunnel[t].window; + uint8_t w = tunnel[t].window; tunnel[t].try++; // another try if (tunnel[t].try > 5) tunnelkill(t, "Timeout on control message"); // game over @@ -2054,6 +2138,8 @@ static int regular_cleanups(void) tunnelsend(c->buf, c->length, t); c = c->next; } + + t_actions++; } } // Send hello @@ -2062,6 +2148,7 @@ static int regular_cleanups(void) controlt *c = controlnew(6); // sending HELLO controladd(c, t, 0); // send the message LOG(3, 0, t, "Sending HELLO message\n"); + t_actions++; } // Check for tunnel changes requested from the CLI @@ -2072,19 +2159,34 @@ static int regular_cleanups(void) { LOG(2, 0, t, "Dropping tunnel by CLI\n"); tunnelshutdown(t, "Requested by administrator"); + t_actions++; } } + } + + for (i = 0; i < r_slice; i++) + { + r++; + if (r >= MAXRADIUS) + r = 1; + if (!radius[r].state) + continue; + + if (radius[r].retry <= TIME) + { + radiusretry(r); + r_actions++; + } } - count = 0; - for (i = 1; i <= config->cluster_highest_sessionid; i++) + for (i = 0; i < s_slice; i++) { s++; if (s > config->cluster_highest_sessionid) s = 1; - if (!session[s].tunnel) // Session isn't in use + if (!session[s].opened) // Session isn't in use continue; if (!session[s].die && session[s].ip && !(session[s].flags & SF_IPCP_ACKED)) @@ -2092,13 +2194,14 @@ static int regular_cleanups(void) // IPCP has not completed yet. Resend LOG(3, s, session[s].tunnel, "No ACK for initial IPCP ConfigReq... resending\n"); sendipcp(session[s].tunnel, s); + s_actions++; } // check for expired sessions if (session[s].die && session[s].die <= TIME) { sessionkill(s, "Expired"); - if (++count >= MAX_ACTIONS) break; + s_actions++; continue; } @@ -2107,27 +2210,27 @@ static int regular_cleanups(void) { sessionshutdown(s, "No response to LCP ECHO requests"); STAT(session_timeout); - if (++count >= MAX_ACTIONS) break; + s_actions++; continue; } // No data in IDLE_TIMEOUT seconds, send LCP ECHO if (session[s].user[0] && (time_now - session[s].last_packet >= ECHO_TIMEOUT)) { - u8 b[MAXCONTROL] = {0}; + uint8_t b[MAXCONTROL] = {0}; - u8 *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, PPPLCP); + uint8_t *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, PPPLCP); if (!q) continue; *q = EchoReq; - *(u8 *)(q + 1) = (time_now % 255); // ID - *(u16 *)(q + 2) = htons(8); // Length - *(u32 *)(q + 4) = 0; // Magic Number (not supported) + *(uint8_t *)(q + 1) = (time_now % 255); // ID + *(uint16_t *)(q + 2) = htons(8); // Length + *(uint32_t *)(q + 4) = 0; // Magic Number (not supported) LOG(4, s, session[s].tunnel, "No data in %d seconds, sending LCP ECHO\n", (int)(time_now - session[s].last_packet)); tunnelsend(b, 24, session[s].tunnel); // send it - if (++count >= MAX_ACTIONS) break; + s_actions++; } // Check for actions requested from the CLI @@ -2141,6 +2244,7 @@ static int regular_cleanups(void) LOG(2, s, session[s].tunnel, "Dropping session by CLI\n"); sessionshutdown(s, "Requested by administrator"); a = 0; // dead, no need to check for other actions + s_actions++; } if (a & CLI_SESS_NOSNOOP) @@ -2148,6 +2252,7 @@ static int regular_cleanups(void) LOG(2, s, session[s].tunnel, "Unsnooping session by CLI\n"); session[s].snoop_ip = 0; session[s].snoop_port = 0; + s_actions++; send++; } else if (a & CLI_SESS_SNOOP) @@ -2158,6 +2263,7 @@ static int regular_cleanups(void) session[s].snoop_ip = cli_session_actions[s].snoop_ip; session[s].snoop_port = cli_session_actions[s].snoop_port; + s_actions++; send++; } @@ -2165,6 +2271,7 @@ static int regular_cleanups(void) { LOG(2, s, session[s].tunnel, "Un-throttling session by CLI\n"); throttle_session(s, 0, 0); + s_actions++; send++; } else if (a & CLI_SESS_THROTTLE) @@ -2174,6 +2281,7 @@ static int regular_cleanups(void) cli_session_actions[s].throttle_out); throttle_session(s, cli_session_actions[s].throttle_in, cli_session_actions[s].throttle_out); + s_actions++; send++; } @@ -2181,6 +2289,7 @@ static int regular_cleanups(void) { LOG(2, s, session[s].tunnel, "Un-filtering session by CLI\n"); filter_session(s, 0, 0); + s_actions++; send++; } else if (a & CLI_SESS_FILTER) @@ -2190,38 +2299,17 @@ static int regular_cleanups(void) cli_session_actions[s].filter_out); filter_session(s, cli_session_actions[s].filter_in, cli_session_actions[s].filter_out); + s_actions++; send++; } if (send) cluster_send_session(s); - - if (++count >= MAX_ACTIONS) break; - } - } - - if (*config->accounting_dir) - { - if (next_acct <= TIME) - { - // Dump accounting data - next_acct = TIME + ACCT_TIME; - dump_acct_info(1); - } - else if (next_shut_acct <= TIME) - { - // Dump accounting data for shutdown sessions - next_acct = TIME + ACCT_SHUT_TIME; - if (shut_acct_n) - dump_acct_info(0); } } - if (count >= MAX_ACTIONS) - return 1; // Didn't finish! - - LOG(3, 0, 0, "End regular cleanup (%d actions), next in %d seconds\n", count, config->cleanup_interval); - return 0; + LOG(3, 0, 0, "End regular cleanup: scanned %d/%d/%d tunnels/radius/sessions, %d/%d/%d actions\n", + t_slice, r_slice, s_slice, t_actions, r_actions, s_actions); } @@ -2232,8 +2320,39 @@ static int regular_cleanups(void) static int still_busy(void) { int i; + static time_t stopped_bgp = 0; static clockt last_talked = 0; static clockt start_busy_wait = 0; + + if (!config->cluster_iam_master) + { +#ifdef BGP + if (bgp_configured) + { + if (!stopped_bgp) + { + LOG(1, 0, 0, "Shutting down in %d seconds, stopping BGP...\n", QUIT_DELAY); + + for (i = 0; i < BGP_NUM_PEERS; i++) + if (bgp_peers[i].state == Established) + bgp_stop(&bgp_peers[i]); + + stopped_bgp = time_now; + + // we don't want to become master + cluster_send_ping(0); + + return 1; + } + + if (time_now < (stopped_bgp + QUIT_DELAY)) + return 1; + } +#endif /* BGP */ + + return 0; + } + if (start_busy_wait == 0) start_busy_wait = TIME; @@ -2282,10 +2401,9 @@ static int readset_n = 0; static void mainloop(void) { int i; - u8 buf[65536]; + uint8_t buf[65536]; struct timeval to; clockt next_cluster_ping = 0; // send initial ping immediately - time_t next_clean = time_now + config->cleanup_interval; LOG(4, 0, 0, "Beginning of main loop. udpfd=%d, tunfd=%d, cluster_sockfd=%d, controlfd=%d\n", udpfd, tunfd, cluster_sockfd, controlfd); @@ -2346,6 +2464,8 @@ static void mainloop(void) n = select(n + 1, &r, 0, 0, &to); #endif /* BGP */ + STAT(select_called); + TIME = now(); if (n < 0) { @@ -2361,6 +2481,9 @@ static void mainloop(void) { struct sockaddr_in addr; int alen, c, s; + int udp_pkts = 0; + int tun_pkts = 0; + int cluster_pkts = 0; // nsctl commands if (FD_ISSET(controlfd, &r)) @@ -2420,6 +2543,7 @@ static void mainloop(void) if ((s = recvfrom(udpfd, buf, sizeof(buf), 0, (void *) &addr, &alen)) > 0) { processudp(buf, s, &addr); + udp_pkts++; } else { @@ -2431,9 +2555,10 @@ static void mainloop(void) // incoming IP if (FD_ISSET(tunfd, &r)) { - if ((n = read(tunfd, buf, sizeof(buf))) > 0) + if ((s = read(tunfd, buf, sizeof(buf))) > 0) { - processtun(buf, n); + processtun(buf, s); + tun_pkts++; } else { @@ -2449,6 +2574,7 @@ static void mainloop(void) if ((s = recvfrom(cluster_sockfd, buf, sizeof(buf), MSG_WAITALL, (void *) &addr, &alen)) > 0) { processcluster(buf, s, addr.sin_addr.s_addr); + cluster_pkts++; } else { @@ -2457,6 +2583,19 @@ static void mainloop(void) } } } + + if (udp_pkts > 1 || tun_pkts > 1 || cluster_pkts > 1) + STAT(multi_read_used); + + if (c >= config->multi_read_count) + { + LOG(3, 0, 0, "Reached multi_read_count (%d); processed %d udp, %d tun and %d cluster packets\n", + config->multi_read_count, udp_pkts, tun_pkts, cluster_pkts); + + STAT(multi_read_exceeded); + } + + TIME = now(); } // Runs on every machine (master and slaves). @@ -2472,38 +2611,60 @@ static void mainloop(void) master_update_counts(); // If we're a slave, send our byte counters to our master. + TIME = now(); if (config->cluster_iam_master && !config->cluster_iam_uptodate) next_cluster_ping = TIME + 1; // out-of-date slaves, do fast updates else next_cluster_ping = TIME + config->cluster_hb_interval; } + if (!config->cluster_iam_master) + continue; + // Run token bucket filtering queue.. // Only run it every 1/10th of a second. - // Runs on all machines both master and slave. { static clockt last_run = 0; if (last_run != TIME) { - last_run = TIME; tbf_run_timer(); + last_run = TIME; + TIME = now(); } } - /* Handle timeouts. Make sure that this gets run anyway, even if there was - * something to read, else under load this will never actually run.... - * - */ - if (config->cluster_iam_master && next_clean <= time_now) + // Handle timeouts, retries etc. { - if (regular_cleanups()) + clockt last_clean = 0; + if (last_clean != TIME) { - // Did it finish? - next_clean = time_now + 1 ; // Didn't finish. Check quickly. + if (!last_clean) + last_clean = TIME - 10; + + regular_cleanups(TIME - last_clean); + last_clean = TIME; + TIME = now(); } - else + } + + if (*config->accounting_dir) + { + static clockt next_acct = 0; + static clockt next_shut_acct = 0; + + if (next_acct <= TIME) { - next_clean = time_now + config->cleanup_interval; // Did. Move to next interval. + // Dump accounting data + next_acct = TIME + ACCT_TIME; + next_shut_acct = TIME + ACCT_SHUT_TIME; + dump_acct_info(1); + } + else if (next_shut_acct <= TIME) + { + // Dump accounting data for shutdown sessions + next_shut_acct = TIME + ACCT_SHUT_TIME; + if (shut_acct_n) + dump_acct_info(0); } } } @@ -2518,6 +2679,7 @@ static void mainloop(void) // // Important!!! We MUST not process any packets past this point! + LOG(1, 0, 0, "Clean shutdown complete\n"); } static void stripdomain(char *host) @@ -2606,6 +2768,7 @@ static void initdata(int optdebug, char *optconfig) config->debug = optdebug; config->num_tbfs = MAXTBFS; config->rl_rate = 28; // 28kbps + config->cluster_master_min_adv = 1; if (!(tunnel = shared_malloc(sizeof(tunnelt) * MAXTUNNEL))) { @@ -2618,9 +2781,9 @@ static void initdata(int optdebug, char *optconfig) exit(1); } - if (!(sess_count = shared_malloc(sizeof(sessioncountt) * MAXSESSION))) + if (!(sess_local = shared_malloc(sizeof(sessionlocalt) * MAXSESSION))) { - LOG(0, 0, 0, "Error doing malloc for sessions_count: %s\n", strerror(errno)); + LOG(0, 0, 0, "Error doing malloc for sess_local: %s\n", strerror(errno)); exit(1); } @@ -2672,7 +2835,7 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER); memset(ip_address_pool, 0, sizeof(ippoolt) * MAXIPPOOL); // Put all the sessions on the free list marked as undefined. - for (i = 1; i < MAXSESSION - 1; i++) + for (i = 1; i < MAXSESSION; i++) { session[i].next = i + 1; session[i].tunnel = T_UNDEF; // mark it as not filled in. @@ -2681,7 +2844,7 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER); sessionfree = 1; // Mark all the tunnels as undefined (waiting to be filled in by a download). - for (i = 1; i < MAXTUNNEL- 1; i++) + for (i = 1; i < MAXTUNNEL; i++) tunnel[i].state = TUNNELUNDEF; // mark it as not filled in. if (!*hostname) @@ -2704,7 +2867,7 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER); static int assign_ip_address(sessionidt s) { - u32 i; + uint32_t i; int best = -1; time_t best_time = time_now; char *u = session[s].user; @@ -2807,7 +2970,7 @@ void rebuild_address_pool(void) for (i = 0; i < MAXSESSION; ++i) { int ipid; - if (!session[i].ip || !session[i].tunnel) + if (!(session[i].opened && session[i].ip)) continue; ipid = - lookup_ipmap(htonl(session[i].ip)); @@ -2865,7 +3028,7 @@ static void fix_address_pool(int sid) // // Add a block of addresses to the IP pool to hand out. // -static void add_to_ip_pool(u32 addr, u32 mask) +static void add_to_ip_pool(in_addr_t addr, in_addr_t mask) { int i; if (mask == 0) @@ -2916,7 +3079,7 @@ static void initippool() if ((p = (char *)strrchr(buf, '\n'))) *p = 0; if ((p = (char *)strchr(buf, ':'))) { - ipt src; + in_addr_t src; *p = '\0'; src = inet_addr(buf); if (src == INADDR_NONE) @@ -2934,7 +3097,7 @@ static void initippool() { // It's a range int numbits = 0; - u32 start = 0, mask = 0; + in_addr_t start = 0, mask = 0; LOG(2, 0, 0, "Adding IP address range %s\n", buf); *p++ = 0; @@ -2944,7 +3107,7 @@ static void initippool() continue; } start = ntohl(inet_addr(pool)); - mask = (u32)(pow(2, numbits) - 1) << (32 - numbits); + mask = (in_addr_t) (pow(2, numbits) - 1) << (32 - numbits); // Add a static route for this pool LOG(5, 0, 0, "Adding route for address pool %s/%u\n", @@ -2964,7 +3127,7 @@ static void initippool() LOG(1, 0, 0, "IP address pool is %d addresses\n", ip_pool_size - 1); } -void snoop_send_packet(char *packet, u16 size, ipt destination, u16 port) +void snoop_send_packet(char *packet, uint16_t size, in_addr_t destination, uint16_t port) { struct sockaddr_in snoop_addr = {0}; if (!destination || !port || snoopfd <= 0 || size <= 0 || !packet) @@ -2974,8 +3137,8 @@ void snoop_send_packet(char *packet, u16 size, ipt destination, u16 port) snoop_addr.sin_addr.s_addr = destination; snoop_addr.sin_port = ntohs(port); - LOG(5, 0, 0, "Snooping packet at %p (%d bytes) to %s:%d\n", - packet, size, fmtaddr(snoop_addr.sin_addr.s_addr, 0), + LOG(5, 0, 0, "Snooping %d byte packet to %s:%d\n", size, + fmtaddr(snoop_addr.sin_addr.s_addr, 0), htons(snoop_addr.sin_port)); if (sendto(snoopfd, packet, size, MSG_DONTWAIT | MSG_NOSIGNAL, (void *) &snoop_addr, sizeof(snoop_addr)) < 0) @@ -3020,8 +3183,8 @@ static int dump_session(FILE **f, sessiont *s) s->user, // username fmtaddr(htonl(s->ip), 0), // ip (s->throttle_in || s->throttle_out) ? 2 : 1, // qos - (u32) s->cin, // uptxoctets - (u32) s->cout); // downrxoctets + (uint32_t) s->cin, // uptxoctets + (uint32_t) s->cout); // downrxoctets s->pin = s->cin = 0; s->pout = s->cout = 0; @@ -3109,7 +3272,7 @@ int main(int argc, char *argv[]) init_tbf(config->num_tbfs); LOG(0, 0, 0, "L2TPNS version " VERSION "\n"); - LOG(0, 0, 0, "Copyright (c) 2003, 2004 Optus Internet Engineering\n"); + LOG(0, 0, 0, "Copyright (c) 2003, 2004, 2005 Optus Internet Engineering\n"); LOG(0, 0, 0, "Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced\n"); { struct rlimit rlim; @@ -3197,14 +3360,6 @@ int main(int argc, char *argv[]) mainloop(); -#ifdef BGP - /* try to shut BGP down cleanly; with luck the sockets will be - writable since we're out of the select */ - for (i = 0; i < BGP_NUM_PEERS; i++) - if (bgp_peers[i].state == Established) - bgp_stop(&bgp_peers[i]); -#endif /* BGP */ - /* remove plugins (so cleanup code gets run) */ plugins_done(); @@ -3307,7 +3462,7 @@ static void read_state() ippoolt itmp; FILE *f; char magic[sizeof(DUMP_MAGIC) - 1]; - u32 buf[2]; + uint32_t buf[2]; if (!config->save_state) { @@ -3428,7 +3583,7 @@ static void read_state() static void dump_state() { FILE *f; - u32 buf[2]; + uint32_t buf[2]; if (!config->save_state) return; @@ -3476,7 +3631,7 @@ static void dump_state() unlink(STATEFILE); } -static void build_chap_response(char *challenge, u8 id, u16 challenge_length, char **challenge_response) +static void build_chap_response(char *challenge, uint8_t id, uint16_t challenge_length, char **challenge_response) { MD5_CTX ctx; *challenge_response = NULL; @@ -3579,7 +3734,7 @@ static void update_config() if (!config->numradiusservers) LOG(0, 0, 0, "No RADIUS servers defined!\n"); - config->num_radfds = 2 << RADIUS_SHIFT; + config->num_radfds = 1 << RADIUS_SHIFT; // Update plugins for (i = 0; i < MAXPLUGINS; i++) @@ -3599,7 +3754,6 @@ static void update_config() } } memcpy(config->old_plugins, config->plugins, sizeof(config->plugins)); - if (!config->cleanup_interval) config->cleanup_interval = 10; if (!config->multi_read_count) config->multi_read_count = 10; if (!config->cluster_address) config->cluster_address = inet_addr(DEFAULT_MCAST_ADDR); if (!*config->cluster_interface) @@ -3671,7 +3825,7 @@ static void read_config_file() int sessionsetup(tunnelidt t, sessionidt s) { // A session now exists, set it up - ipt ip; + in_addr_t ip; char *user; sessionidt i; int r; @@ -3680,7 +3834,7 @@ int sessionsetup(tunnelidt t, sessionidt s) LOG(3, s, t, "Doing session setup for session\n"); - if (!session[s].ip || session[s].ip == 0xFFFFFFFE) + if (!session[s].ip) { assign_ip_address(s); if (!session[s].ip) @@ -3880,8 +4034,8 @@ int load_session(sessionidt s, sessiont *new) // for walking the sessions to forward byte counts to the master. config->cluster_highest_sessionid = s; - // TEMP: old session struct used a u32 to define the throttle - // speed for both up/down, new uses a u16 for each. Deal with + // TEMP: old session struct used a uint32_t to define the throttle + // speed for both up/down, new uses a uint16_t for each. Deal with // sessions from an old master for migration. if (new->throttle_out == 0 && new->tbf_out) new->throttle_out = new->throttle_in; @@ -4070,7 +4224,7 @@ static void plugins_done() run_plugin_done(p); } -static void processcontrol(u8 * buf, int len, struct sockaddr_in *addr, int alen) +static void processcontrol(uint8_t * buf, int len, struct sockaddr_in *addr, int alen) { struct nsctl request; struct nsctl response; @@ -4278,7 +4432,7 @@ void become_master(void) { for (s = 1; s <= config->cluster_highest_sessionid ; ++s) { - if (!session[s].tunnel) // Not an in-use session. + if (!session[s].opened) // Not an in-use session. continue; run_plugins(PLUGIN_NEW_SESSION_MASTER, &session[s]); @@ -4310,7 +4464,7 @@ int cmd_show_hist_idle(struct cli_def *cli, char *command, char **argv, int argc for (s = 1; s <= config->cluster_highest_sessionid ; ++s) { int idle; - if (!session[s].tunnel) + if (!session[s].opened) continue; idle = time_now - session[s].last_packet; @@ -4348,7 +4502,7 @@ int cmd_show_hist_open(struct cli_def *cli, char *command, char **argv, int argc for (s = 1; s <= config->cluster_highest_sessionid ; ++s) { int open = 0, d; - if (!session[s].tunnel) + if (!session[s].opened) continue; d = time_now - session[s].opened; @@ -4382,16 +4536,16 @@ int cmd_show_hist_open(struct cli_def *cli, char *command, char **argv, int argc * * Based on code from rp-l2tpd by Roaring Penguin Software Inc. */ -static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length) +static int unhide_avp(uint8_t *avp, tunnelidt t, sessionidt s, uint16_t length) { MD5_CTX ctx; - u8 *cursor; - u8 digest[16]; - u8 working_vector[16]; + uint8_t *cursor; + uint8_t digest[16]; + uint8_t working_vector[16]; uint16_t hidden_length; - u8 type[2]; + uint8_t type[2]; size_t done, todo; - u8 *output; + uint8_t *output; // Find the AVP type. type[0] = *(avp + 4); @@ -4446,7 +4600,7 @@ static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length) return hidden_length + 6; } -static int ip_filter_port(ip_filter_portt *p, portt port) +static int ip_filter_port(ip_filter_portt *p, uint16_t port) { switch (p->op) { @@ -4460,7 +4614,7 @@ static int ip_filter_port(ip_filter_portt *p, portt port) return 0; } -static int ip_filter_flag(u8 op, u8 sflags, u8 cflags, u8 flags) +static int ip_filter_flag(uint8_t op, uint8_t sflags, uint8_t cflags, uint8_t flags) { switch (op) { @@ -4477,15 +4631,15 @@ static int ip_filter_flag(u8 op, u8 sflags, u8 cflags, u8 flags) return 0; } -int ip_filter(u8 *buf, int len, u8 filter) +int ip_filter(uint8_t *buf, int len, uint8_t filter) { - u16 frag_offset; - u8 proto; - ipt src_ip; - ipt dst_ip; - portt src_port = 0; - portt dst_port = 0; - u8 flags = 0; + uint16_t frag_offset; + uint8_t proto; + in_addr_t src_ip; + in_addr_t dst_ip; + uint16_t src_port = 0; + uint16_t dst_port = 0; + uint8_t flags = 0; ip_filter_rulet *rule; if (len < 20) // up to end of destination address @@ -4494,10 +4648,10 @@ int ip_filter(u8 *buf, int len, u8 filter) if ((*buf >> 4) != 4) // IPv4 return 0; - frag_offset = ntohs(*(u16 *) (buf + 6)) & 0x1fff; + frag_offset = ntohs(*(uint16_t *) (buf + 6)) & 0x1fff; proto = buf[9]; - src_ip = *(u32 *) (buf + 12); - dst_ip = *(u32 *) (buf + 16); + src_ip = *(in_addr_t *) (buf + 12); + dst_ip = *(in_addr_t *) (buf + 16); if (frag_offset == 0 && (proto == IPPROTO_TCP || proto == IPPROTO_UDP)) { @@ -4505,8 +4659,8 @@ int ip_filter(u8 *buf, int len, u8 filter) if (len < l + 4) // ports return 0; - src_port = ntohs(*(u16 *) (buf + l)); - dst_port = ntohs(*(u16 *) (buf + l + 2)); + src_port = ntohs(*(uint16_t *) (buf + l)); + dst_port = ntohs(*(uint16_t *) (buf + l + 2)); if (proto == IPPROTO_TCP) { if (len < l + 14) // flags