Below is the file 'src/wccp2.c' from this revision. You can also download the file.
/* * $Id$ * * DEBUG: section 80 WCCP Support * AUTHOR: Steven WIlton * * SQUID Web Proxy Cache http://www.squid-cache.org/ * ---------------------------------------------------------- * * Squid is the result of efforts by numerous individuals from * the Internet community; see the CONTRIBUTORS file for full * details. Many organizations have provided support for Squid's * development; see the SPONSORS file for full details. Squid is * Copyrighted (C) 2001 by the Regents of the University of * California; see the COPYRIGHT file for full details. Squid * incorporates software developed and/or copyrighted by other * sources; see the CREDITS file for full details. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ #include "squid.h" #if USE_WCCPv2 #include <netdb.h> #define WCCP_PORT 2048 #define WCCP_VERSION 4 #define WCCP_REVISION 0 #define WCCP_RESPONSE_SIZE 12448 #define WCCP_ACTIVE_CACHES 32 #define WCCP_HASH_SIZE 32 #define WCCP_BUCKETS 256 #define WCCP_HERE_I_AM 7 #define WCCP_I_SEE_YOU 8 #define WCCP_ASSIGN_BUCKET 9 static int theInWccp2Connection = -1; static int theOutWccp2Connection = -1; static int wccp2_connected = 0; static PF wccp2HandleUdp; static EVH wccp2HereIam; static EVH wccp2AssignBuckets; /* KDW WCCP V2 */ #define WCCP2_HERE_I_AM 10 #define WCCP2_I_SEE_YOU 11 #define WCCP2_REDIRECT_ASSIGN 12 #define WCCP2_REMOVAL_QUERY 13 #define WCCP2_VERSION 0x200 #define WCCP2_SECURITY_INFO 0 #define WCCP2_NO_SECURITY 0 #define WCCP2_MD5_SECURITY 1 #define WCCP2_SERVICE_INFO 1 #define WCCP2_SERVICE_STANDARD 0 #define WCCP2_SERVICE_DYNAMIC 1 #define WCCP2_SERVICE_ID_HTTP 0x00 #define WCCP2_SERVICE_SRC_IP_HASH 0x1 #define WCCP2_SERVICE_DST_IP_HASH 0x2 #define WCCP2_SERVICE_SOURCE_PORT_HASH 0x4 #define WCCP2_SERVICE_DST_PORT_HASH 0x8 #define WCCP2_SERVICE_PORTS_DEFINED 0x10 #define WCCP2_SERVICE_PORTS_SOURCE 0x20 #define WCCP2_SERVICE_SRC_IP_ALT_HASH 0x100 #define WCCP2_SERVICE_DST_IP_ALT_HASH 0x200 #define WCCP2_SERVICE_SRC_PORT_ALT_HASH 0x400 #define WCCP2_SERVICE_DST_PORT_ALT_HASH 0x800 #define WCCP2_ROUTER_ID_INFO 2 #define WCCP2_WC_ID_INFO 3 #define WCCP2_RTR_VIEW_INFO 4 #define WCCP2_WC_VIEW_INFO 5 #define WCCP2_REDIRECT_ASSIGNMENT 6 #define WCCP2_QUERY_INFO 7 #define WCCP2_CAPABILITY_INFO 8 #define WCCP2_CAPABILITY_FORWARDING_METHOD 0x01 #define WCCP2_CAPABILITY_ASSIGNMENT_METHOD 0x02 #define WCCP2_CAPABILITY_RETURN_METHOD 0x03 #define WCCP2_CAPABILITY_GRE 0x00000001 #define WCCP2_CAPABILITY_L2 0x00000002 #define WCCP2_NONE_SECURITY_LEN 0 #define WCCP2_MD5_SECURITY_LEN 16 /* Useful defines */ #define WCCP2_NUMPORTS 8 #define WCCP2_PASSWORD_LEN 8 /* WCCP v2 packet header */ struct wccp2_here_i_am_header_t { uint32_t type; uint16_t version; uint16_t length; }; static struct wccp2_here_i_am_header_t wccp2_here_i_am_header; /* Security struct for the "no security" option */ struct wccp2_security_none_t { uint16_t security_type; uint16_t security_length; uint32_t security_option; }; struct wccp2_security_md5_t { uint16_t security_type; uint16_t security_length; uint32_t security_option; uint8_t security_implementation[WCCP2_MD5_SECURITY_LEN]; }; /* Service info struct */ struct wccp2_service_info_t { uint16_t service_type; uint16_t service_length; uint8_t service; uint8_t service_id; uint8_t service_priority; uint8_t service_protocol; uint32_t service_flags; uint16_t port0; uint16_t port1; uint16_t port2; uint16_t port3; uint16_t port4; uint16_t port5; uint16_t port6; uint16_t port7; }; struct wccp2_cache_identity_info_t { struct in_addr addr; uint16_t hash_revision; char bits[2]; char buckets[32]; uint16_t weight; uint16_t status; }; /* Web Cache identity info */ struct wccp2_identity_info_t { uint16_t cache_identity_type; uint16_t cache_identity_length; struct wccp2_cache_identity_info_t cache_identity; }; static struct wccp2_identity_info_t wccp2_identity_info; /* View header */ struct wccp2_cache_view_header_t { uint16_t cache_view_type; uint16_t cache_view_length; uint32_t cache_view_version; }; static struct wccp2_cache_view_header_t wccp2_cache_view_header; /* View info */ struct wccp2_cache_view_info_t { uint32_t num_routers; uint32_t num_caches; }; static struct wccp2_cache_view_info_t wccp2_cache_view_info; /* Router ID element */ struct wccp2_router_id_element_t { struct in_addr router_address; uint32_t received_id; }; static struct wccp2_router_id_element_t wccp2_router_id_element; /* Capability info header */ struct wccp2_capability_info_header_t { uint16_t capability_info_type; uint16_t capability_info_length; }; static struct wccp2_capability_info_header_t wccp2_capability_info_header; /* Capability element */ struct wccp2_capability_element_t { uint16_t capability_type; uint16_t capability_length; uint32_t capability_value; }; static struct wccp2_capability_element_t wccp2_capability_element; /* RECEIVED PACKET STRUCTURE */ struct wccp2_i_see_you_t { uint32_t type; uint16_t version; uint16_t length; char data[WCCP_RESPONSE_SIZE]; }; static struct wccp2_i_see_you_t wccp2_i_see_you; /* Router ID element */ struct wccp2_router_assign_element_t { struct in_addr router_address; uint32_t received_id; uint32_t change_number; }; /* Generic header struct */ struct wccp2_item_header_t { uint16_t type; uint16_t length; }; /* Router identity struct */ struct router_identity_info_t { struct wccp2_item_header_t header; struct wccp2_router_id_element_t router_id_element; struct in_addr router_address; uint32_t number_caches; }; /* assigment key */ struct assignment_key_t { struct in_addr master_ip; uint32_t master_number; }; /* Router view of WCCP */ struct router_view_t { struct wccp2_item_header_t header; uint32_t change_number; struct assignment_key_t assignment_key; }; /* Lists used to keep track of caches, routers and services */ struct wccp2_cache_list_t { struct in_addr cache_ip; struct wccp2_cache_list_t *next; }; struct wccp2_router_list_t { struct wccp2_router_id_element_t *info; struct in_addr local_ip; struct in_addr router_sendto_address; uint32_t member_change; uint32_t num_caches; struct wccp2_cache_list_t cache_list_head; struct wccp2_router_list_t *next; }; static int wccp2_numrouters; struct wccp2_service_list_t { struct wccp2_service_info_t info; uint32_t num_routers; struct wccp2_router_list_t router_list_head; int lowest_ip; uint32_t change_num; struct wccp2_identity_info_t *wccp2_identity_info_ptr; struct wccp2_security_md5_t *security_info; struct wccp2_service_info_t *service_info; char wccp_packet[WCCP_RESPONSE_SIZE]; size_t wccp_packet_size; struct wccp2_service_list_t *next; char wccp_password[WCCP2_PASSWORD_LEN+1]; /* hold the trailing C-string NUL */ uint32_t wccp2_security_type; }; static struct wccp2_service_list_t *wccp2_service_list_head = NULL; int empty_portlist[WCCP2_NUMPORTS] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* END WCCP V2 */ void wccp2_add_service_list(int service, int service_id, int service_priority, int service_proto, int service_flags, int ports[], int security_type, char *password); /* * The functions used during startup: * wccp2Init * wccp2ConnectionOpen * wccp2ConnectionShutdown * wccp2ConnectionClose */ static void wccp2InitServices(void) { debug(80, 5) ("wccp2InitServices: called\n"); } void wccp2_update_service(struct wccp2_service_list_t *srv, int service, int service_id, int service_priority, int service_proto, int service_flags, int ports[]) { /* XXX check what needs to be wrapped in htons()! */ srv->info.service = service; srv->info.service_id = service_id; srv->info.service_priority = service_priority; srv->info.service_protocol = service_proto; srv->info.service_flags = htonl(service_flags); srv->info.port0 = htons(ports[0]); srv->info.port1 = htons(ports[1]); srv->info.port2 = htons(ports[2]); srv->info.port3 = htons(ports[3]); srv->info.port4 = htons(ports[4]); srv->info.port5 = htons(ports[5]); srv->info.port6 = htons(ports[6]); srv->info.port7 = htons(ports[7]); } void wccp2_add_service_list(int service, int service_id, int service_priority, int service_proto, int service_flags, int ports[], int security_type, char *password) { struct wccp2_service_list_t *wccp2_service_list_ptr; wccp2_service_list_ptr = xcalloc(1,sizeof(struct wccp2_service_list_t)); debug(80, 5) ("wccp2_add_service_list: added service id %d\n", service_id); /* XXX check what needs to be wrapped in htons()! */ wccp2_service_list_ptr->info.service_type = htons(WCCP2_SERVICE_INFO); wccp2_service_list_ptr->info.service_length = htons(sizeof(struct wccp2_service_info_t)-4); wccp2_service_list_ptr->change_num=0; wccp2_update_service(wccp2_service_list_ptr, service, service_id, service_priority, service_proto, service_flags, ports); wccp2_service_list_ptr->wccp2_security_type = security_type; bzero(wccp2_service_list_ptr->wccp_password, WCCP2_PASSWORD_LEN + 1); strncpy(wccp2_service_list_ptr->wccp_password, password, WCCP2_PASSWORD_LEN); /* add to linked list - XXX this should use the Squid dlink* routines! */ wccp2_service_list_ptr->next = wccp2_service_list_head; wccp2_service_list_head = wccp2_service_list_ptr; } struct wccp2_service_list_t * wccp2_get_service_by_id(int service, int service_id) { struct wccp2_service_list_t *p; p = wccp2_service_list_head; while (p != NULL) { if (p->info.service == service && p->info.service_id == service_id) { return p; } p = p->next; } return NULL; } /* * Update the md5 security header, if possible * * Returns: 1 if we set it, 0 if not (eg, no security section, or non-md5) */ char wccp2_update_md5_security(char *password, char *ptr, char *packet, int len) { u_int8_t md5_digest[16]; char pwd[WCCP2_PASSWORD_LEN]; MD5_CTX M; struct wccp2_security_md5_t *ws; debug(80, 5) ("wccp2_update_md5_security: called\n"); /* The password field, for the MD5 hash, needs to be 8 bytes and NUL padded. */ bzero(pwd, sizeof(pwd)); strncpy(pwd, password, sizeof(pwd)); ws = (struct wccp2_security_md5_t *) ptr; assert(ntohs(ws->security_type) == WCCP2_SECURITY_INFO); /* Its the security part */ if (ntohl(ws->security_option) != WCCP2_MD5_SECURITY) { debug(80, 5) ("wccp2_update_md5_security: this service ain't md5'ing, abort\n"); return 0; } /* And now its the MD5 section! */ /* According to the draft, the MD5 security hash is the combination of * the 8-octet password (padded w/ NUL bytes) and the entire WCCP packet, * including the WCCP message header. The WCCP security implementation * area should be zero'ed before calculating the MD5 hash. */ /* XXX eventually we should be able to kill md5_digest and blit it directly in */ bzero(ws->security_implementation, sizeof(ws->security_implementation)); MD5Init(&M); MD5Update(&M, pwd, 8); MD5Update(&M, packet, len); MD5Final(md5_digest, &M); memcpy(ws->security_implementation, md5_digest, sizeof(md5_digest)); /* Finished! */ return 1; } /* * Check the given WCCP2 packet against the given password. */ char wccp2_check_security(struct wccp2_service_list_t *srv, char *security, char *packet, int len) { struct wccp2_security_md5_t *ws = (struct wccp2_security_md5_t *) security; u_int8_t md5_digest[16], md5_challenge[16]; char pwd[WCCP2_PASSWORD_LEN]; MD5_CTX M; /* Make sure the security type matches what we expect */ if (ntohl(ws->security_option) != srv->wccp2_security_type) { debug(80, 1) ("wccp2_check_security: received packet has the wrong security option\n"); return 0; } if (srv->wccp2_security_type == WCCP2_NO_SECURITY) { return 1; } if (srv->wccp2_security_type != WCCP2_MD5_SECURITY) { debug(80, 1) ("wccp2_check_security: invalid security option\n"); return 1; } /* If execution makes it here then we have an MD5 security */ /* The password field, for the MD5 hash, needs to be 8 bytes and NUL padded. */ bzero(pwd, sizeof(pwd)); strncpy(pwd, srv->wccp_password, sizeof(pwd)); /* Take a copy of the challenge: we need to NUL it before comparing */ memcpy(md5_challenge, ws->security_implementation, 16); bzero(ws->security_implementation, sizeof(ws->security_implementation)); MD5Init(&M); MD5Update(&M, pwd, 8); MD5Update(&M, packet, len); MD5Final(md5_digest, &M); return (memcmp(md5_digest, md5_challenge, 16) == 0); } void wccp2Init(void) { sockaddr_in_list *s; char *ptr; struct wccp2_service_list_t *service_list_ptr; struct wccp2_router_list_t *router_list_ptr; struct wccp2_security_md5_t wccp2_security_md5; debug(80, 5) ("wccp2Init: Called\n"); if (wccp2_connected == 1) return; wccp2_numrouters=0; /* Calculate the number of routers configured in the config file */ for (s = Config.Wccp2.router; s; s = s->next) { if(s->s.sin_addr.s_addr != any_addr.s_addr) { /* Increment the counter */ wccp2_numrouters++; } } if(wccp2_numrouters == 0) { return; } /* Initialise the list of services */ wccp2InitServices(); service_list_ptr = wccp2_service_list_head; while (service_list_ptr != NULL) { /* Set up our list pointers */ router_list_ptr=&service_list_ptr->router_list_head; /* start the wccp header */ wccp2_here_i_am_header.type = htonl(WCCP2_HERE_I_AM); wccp2_here_i_am_header.version = htons(WCCP2_VERSION); wccp2_here_i_am_header.length = 0; ptr = service_list_ptr->wccp_packet + sizeof(wccp2_here_i_am_header); /* add the security section */ /* XXX this is ugly */ if (service_list_ptr->wccp2_security_type == WCCP2_MD5_SECURITY) { wccp2_security_md5.security_option = htonl(WCCP2_MD5_SECURITY); wccp2_security_md5.security_length = htons(sizeof(struct wccp2_security_md5_t)-4); } else if (service_list_ptr->wccp2_security_type == WCCP2_NO_SECURITY) { wccp2_security_md5.security_option = htonl(WCCP2_NO_SECURITY); /* XXX I hate magic length numbers! */ wccp2_security_md5.security_length = htons(4); } else { fatalf("Bad WCCP2 security type\n"); } wccp2_here_i_am_header.length += sizeof(struct wccp2_security_md5_t); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_security_md5.security_type = htons(WCCP2_SECURITY_INFO); service_list_ptr->security_info =(struct wccp2_security_md5_t *)ptr; if (service_list_ptr->wccp2_security_type == WCCP2_MD5_SECURITY) { xmemcpy(ptr,&wccp2_security_md5,sizeof(struct wccp2_security_md5_t)); ptr += sizeof(struct wccp2_security_md5_t); } else { /* assume NONE, and XXX I hate magic length numbers */ xmemcpy(ptr,&wccp2_security_md5, 8); ptr += 8; } /* Add the service info section */ wccp2_here_i_am_header.length += sizeof(struct wccp2_service_info_t); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); xmemcpy(ptr,&service_list_ptr->info,sizeof(struct wccp2_service_info_t)); service_list_ptr->service_info = (struct wccp2_service_info_t *)ptr; ptr += sizeof(struct wccp2_service_info_t); /* Add the cache identity section */ wccp2_here_i_am_header.length += sizeof(struct wccp2_identity_info_t); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_identity_info.cache_identity_type = htons(WCCP2_WC_ID_INFO); wccp2_identity_info.cache_identity_length = htons(sizeof(wccp2_identity_info.cache_identity)); memset(&wccp2_identity_info.cache_identity.addr,'\0',sizeof(wccp2_identity_info.cache_identity.addr)); memset(&wccp2_identity_info.cache_identity.hash_revision,'\0',sizeof(wccp2_identity_info.cache_identity.hash_revision)); memset(&wccp2_identity_info.cache_identity.bits,'\0',sizeof(wccp2_identity_info.cache_identity.bits)); memset(&wccp2_identity_info.cache_identity.buckets,'\0',sizeof(wccp2_identity_info.cache_identity.buckets)); wccp2_identity_info.cache_identity.weight = htons(10000); memset(&wccp2_identity_info.cache_identity.status,'\0',sizeof(wccp2_identity_info.cache_identity.status)); xmemcpy(ptr,&wccp2_identity_info,sizeof(struct wccp2_identity_info_t)); service_list_ptr->wccp2_identity_info_ptr = (struct wccp2_identity_info_t *)ptr; ptr += sizeof(struct wccp2_identity_info_t); /* Add the cache view section */ wccp2_here_i_am_header.length += sizeof(wccp2_cache_view_header); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_cache_view_header.cache_view_type = htons(WCCP2_WC_VIEW_INFO); wccp2_cache_view_header.cache_view_length = htons(sizeof(wccp2_cache_view_header) - 4 + sizeof(wccp2_cache_view_info) + (wccp2_numrouters * sizeof(wccp2_router_id_element)) ); wccp2_cache_view_header.cache_view_version = htonl(1); xmemcpy(ptr,&wccp2_cache_view_header,sizeof(wccp2_cache_view_header)); ptr += sizeof(wccp2_cache_view_header); /* Add the number of routers to the packet */ wccp2_here_i_am_header.length += sizeof(service_list_ptr->num_routers); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); service_list_ptr->num_routers = htonl(wccp2_numrouters); xmemcpy(ptr,&service_list_ptr->num_routers,sizeof(service_list_ptr->num_routers)); ptr += sizeof(service_list_ptr->num_routers); /* Add each router. Keep this functionality here to make sure the received_id can be updated in the packet */ for (s = Config.Wccp2.router; s; s = s->next) { if(s->s.sin_addr.s_addr != any_addr.s_addr) { wccp2_here_i_am_header.length += sizeof(struct wccp2_router_id_element_t); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); /* Add a pointer to the router list for this router */ router_list_ptr->info=(struct wccp2_router_id_element_t *)ptr; router_list_ptr->info->router_address=s->s.sin_addr; router_list_ptr->info->received_id = htonl(0); router_list_ptr->router_sendto_address=s->s.sin_addr; router_list_ptr->member_change = htonl(0); /* Build the next struct */ router_list_ptr->next=xcalloc(1,sizeof(struct wccp2_router_list_t)); /* update the pointer */ router_list_ptr=router_list_ptr->next; router_list_ptr->next=NULL; /* no need to copy memory - we've just set the values directly in the packet above */ ptr+=sizeof(struct wccp2_router_id_element_t); } } /* Add the number of caches (0) */ wccp2_here_i_am_header.length += sizeof(wccp2_cache_view_info.num_caches); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_cache_view_info.num_caches = htonl(0); xmemcpy(ptr,&wccp2_cache_view_info.num_caches,sizeof(wccp2_cache_view_info.num_caches)); ptr += sizeof(wccp2_cache_view_info.num_caches); /* Add the extra capability header */ wccp2_here_i_am_header.length += sizeof(wccp2_capability_info_header); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_capability_info_header.capability_info_type = htons(WCCP2_CAPABILITY_INFO); wccp2_capability_info_header.capability_info_length = htons(2 * sizeof(wccp2_capability_element)); xmemcpy(ptr,&wccp2_capability_info_header,sizeof(wccp2_capability_info_header)); ptr += sizeof(wccp2_capability_info_header); /* Add the forwarding method */ wccp2_here_i_am_header.length += sizeof(wccp2_capability_element); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_capability_element.capability_type = htons(WCCP2_CAPABILITY_FORWARDING_METHOD); wccp2_capability_element.capability_length = htons(sizeof(wccp2_capability_element.capability_value)); wccp2_capability_element.capability_value = htonl(Config.Wccp2.forwarding_method); xmemcpy(ptr,&wccp2_capability_element,sizeof(wccp2_capability_element)); ptr += sizeof(wccp2_capability_element); /* Add the return method */ wccp2_here_i_am_header.length += sizeof(wccp2_capability_element); assert(wccp2_here_i_am_header.length <= WCCP_RESPONSE_SIZE); wccp2_capability_element.capability_type = htons(WCCP2_CAPABILITY_RETURN_METHOD); wccp2_capability_element.capability_length = htons(sizeof(wccp2_capability_element.capability_value)); wccp2_capability_element.capability_value = htonl(Config.Wccp2.return_method); xmemcpy(ptr,&wccp2_capability_element,sizeof(wccp2_capability_element)); ptr += sizeof(wccp2_capability_element); /* Finally, fix the total length to network order, and copy to the appropriate memory blob */ wccp2_here_i_am_header.length = htons(wccp2_here_i_am_header.length); memcpy(&service_list_ptr->wccp_packet,&wccp2_here_i_am_header,sizeof(wccp2_here_i_am_header)); service_list_ptr->wccp_packet_size=ntohs(wccp2_here_i_am_header.length) + sizeof(wccp2_here_i_am_header); /* Add the event if everything initialised correctly */ if(wccp2_numrouters) { if (!eventFind(wccp2HereIam, NULL)) { eventAdd("wccp2HereIam", wccp2HereIam, NULL, 10.0, 1); } } service_list_ptr = service_list_ptr->next; } } void wccp2ConnectionOpen(void) { u_short port = WCCP_PORT; struct sockaddr_in router, local; socklen_t local_len, router_len; struct wccp2_service_list_t *service_list_ptr; struct wccp2_router_list_t *router_list_ptr; debug(80, 5) ("wccp2ConnectionOpen: Called\n"); if(wccp2_numrouters == 0) { debug(80, 1) ("WCCPv2 Disabled.\n"); } theInWccp2Connection = comm_open(SOCK_DGRAM, 0, Config.Wccp2.incoming, port, COMM_NONBLOCKING, "WCCP2 Socket"); if (theInWccp2Connection < 0) fatal("Cannot open WCCP Port"); commSetSelect(theInWccp2Connection, COMM_SELECT_READ, wccp2HandleUdp, NULL, 0); debug(80, 1) ("Accepting WCCP v2 messages on port %d, FD %d.\n", (int) port, theInWccp2Connection); if (Config.Wccp2.outgoing.s_addr != no_addr.s_addr) { theOutWccp2Connection = comm_open(SOCK_DGRAM, 0, Config.Wccp2.outgoing, port, COMM_NONBLOCKING, "WCCP2 Socket (outgoing)"); if (theOutWccp2Connection < 0) fatal("Cannot open Outgoing WCCP Port"); commSetSelect(theOutWccp2Connection, COMM_SELECT_READ, wccp2HandleUdp, NULL, 0); debug(80, 1) ("Outgoing WCCPv2 messages on port %d, FD %d.\n", (int) port, theOutWccp2Connection); } else { theOutWccp2Connection = theInWccp2Connection; } debug(80, 1) ("Initialising all WCCPv2 lists\n"); /* Initialise all routers on all services */ service_list_ptr = wccp2_service_list_head; while (service_list_ptr != NULL) { for (router_list_ptr=&service_list_ptr->router_list_head;router_list_ptr->next != NULL;router_list_ptr=router_list_ptr->next) { router_len = sizeof(router); memset(&router, '\0', router_len); router.sin_family = AF_INET; router.sin_port = htons(port); router.sin_addr = router_list_ptr->router_sendto_address; if (connect(theOutWccp2Connection, (struct sockaddr *) &router, router_len)) fatal("Unable to connect WCCP out socket"); local_len = sizeof(local); memset(&local, '\0', local_len); if (getsockname(theOutWccp2Connection, (struct sockaddr *) &local, &local_len)) fatal("Unable to getsockname on WCCP out socket"); router_list_ptr->local_ip=local.sin_addr; /* Disconnect the sending socket */ router.sin_family = AF_UNSPEC; if (connect(theOutWccp2Connection, (struct sockaddr *) &router, router_len)) fatal("Unable to disconnect WCCP out socket"); } service_list_ptr = service_list_ptr->next; } wccp2_connected=1; } void wccp2ConnectionShutdown(void) { if (theInWccp2Connection < 0) return; if(wccp2_connected == 0) return; if (theInWccp2Connection != theOutWccp2Connection) { debug(80, 1) ("FD %d Closing WCCP socket\n", theInWccp2Connection); comm_close(theInWccp2Connection); } assert(theOutWccp2Connection > -1); commSetSelect(theOutWccp2Connection, COMM_SELECT_READ, NULL, NULL, 0); } void wccp2ConnectionClose(void) { struct wccp2_service_list_t *service_list_ptr; struct wccp2_service_list_t *service_list_ptr_next; struct wccp2_router_list_t *router_list_ptr; struct wccp2_router_list_t *router_list_next; struct wccp2_cache_list_t *cache_list_ptr; struct wccp2_cache_list_t *cache_list_ptr_next; if(wccp2_connected == 0) { return; } wccp2ConnectionShutdown(); if (theOutWccp2Connection > -1) { debug(80, 1) ("FD %d Closing WCCP socket\n", theOutWccp2Connection); comm_close(theOutWccp2Connection); } /* for each router on each service send a packet */ service_list_ptr = wccp2_service_list_head; while (service_list_ptr != NULL) { for (router_list_ptr=&service_list_ptr->router_list_head;router_list_ptr != NULL;router_list_ptr=router_list_next) { for(cache_list_ptr=&router_list_ptr->cache_list_head;cache_list_ptr;cache_list_ptr=cache_list_ptr_next) { cache_list_ptr_next=cache_list_ptr->next; if(cache_list_ptr != &router_list_ptr->cache_list_head) { xfree(cache_list_ptr); } else { memset(cache_list_ptr,'\0',sizeof(struct wccp2_cache_list_t)); } } router_list_next=router_list_ptr->next; if(router_list_ptr != &service_list_ptr->router_list_head) { xfree(router_list_ptr); } else { memset(router_list_ptr,'\0',sizeof(struct wccp2_router_list_t)); } } service_list_ptr_next=service_list_ptr->next; xfree(service_list_ptr); service_list_ptr = service_list_ptr_next; } wccp2_service_list_head = NULL; wccp2_connected=0; } /* * Functions for handling the requests. */ /* * Accept the UDP packet */ static void wccp2HandleUdp(int sock, void *not_used) { struct wccp2_service_list_t *service_list_ptr; struct wccp2_router_list_t *router_list_ptr; struct wccp2_cache_list_t *cache_list_ptr; struct wccp2_cache_list_t *cache_list_ptr_next; /* These structs form the parts of the packet */ struct wccp2_item_header_t *header=NULL; struct wccp2_security_none_t *security_info=NULL; struct wccp2_service_info_t *service_info=NULL; struct router_identity_info_t *router_identity_info=NULL; struct router_view_t *router_view_header=NULL; struct wccp2_cache_identity_info_t *cache_identity=NULL; struct wccp2_capability_info_header_t *router_capability_header=NULL; struct wccp2_capability_element_t *router_capability_element; struct sockaddr_in from; struct in_addr cache_address; socklen_t from_len; int len,found; short int data_length, offset; uint32_t tmp; char *ptr; int num_caches; uint16_t num_capabilities; debug(80, 6) ("wccp2HandleUdp: Called.\n"); commSetSelect(sock, COMM_SELECT_READ, wccp2HandleUdp, NULL, 0); from_len = sizeof(struct sockaddr_in); memset(&from, '\0', from_len); statCounter.syscalls.sock.recvfroms++; len = recvfrom(sock, &wccp2_i_see_you, WCCP_RESPONSE_SIZE, 0, (struct sockaddr *) &from, &from_len); if (len < 0) return; if (ntohs(wccp2_i_see_you.version) != WCCP2_VERSION) return; if (ntohl(wccp2_i_see_you.type) != WCCP2_I_SEE_YOU) return; debug(80, 3) ("Incoming WCCP v2 I_SEE_YOU length %d.\n", ntohs(wccp2_i_see_you.length)); /* Record the total data length */ data_length=ntohs(wccp2_i_see_you.length); offset=0; if(data_length > len) { debug(80, 1) ("ERROR: Malformed WCCPv2 packet claiming it's bigger than received data\n"); return; } /* Go through the data structure */ while(data_length > offset) { header=(struct wccp2_item_header_t *)&wccp2_i_see_you.data[offset]; switch(ntohs(header->type)) { case WCCP2_SECURITY_INFO: if(security_info != NULL ) { debug(80, 1) ("Duplicate security definition\n"); return; } security_info=(struct wccp2_security_none_t *)&wccp2_i_see_you.data[offset]; break; case WCCP2_SERVICE_INFO: if(service_info != NULL ) { debug(80, 1) ("Duplicate service_info definition\n"); return; } service_info=(struct wccp2_service_info_t *)&wccp2_i_see_you.data[offset]; break; case WCCP2_ROUTER_ID_INFO: if(router_identity_info != NULL ) { debug(80, 1) ("Duplicate router_identity_info definition\n"); return; } router_identity_info=(struct router_identity_info_t *)&wccp2_i_see_you.data[offset]; break; case WCCP2_RTR_VIEW_INFO: if(router_view_header != NULL ) { debug(80, 1) ("Duplicate router_view definition\n"); return; } router_view_header=(struct router_view_t *)&wccp2_i_see_you.data[offset]; break; case WCCP2_CAPABILITY_INFO: if(router_capability_header != NULL ) { debug(80, 1) ("Duplicate router_capability definition\n"); return; } router_capability_header=(struct wccp2_capability_info_header_t *)&wccp2_i_see_you.data[offset]; return; default: debug(80, 1) ("Unknown record type in WCCPv2 Packet (%d).\n", ntohs(header->type)); } offset+=sizeof(struct wccp2_item_header_t); offset+=ntohs(header->length); if(offset > data_length) { debug(80,1) ("Error: WCCPv2 packet tried to tell us there is data beyond the end of the packet\n"); return; } } if((security_info == NULL) || (service_info == NULL) || (router_identity_info == NULL) || (router_view_header == NULL)) { debug(80, 1) ("Incomplete WCCPv2 Packet\n"); return; } debug (80,5) ("Complete packet received\n"); /* Check that the service in the packet is configured on this router */ service_list_ptr = wccp2_service_list_head; while (service_list_ptr != NULL) { //debug(80, 5) ("wccpv2: checking %d against %d\n", service_info->service_id, service_list_ptr->service_info->service_id); if(service_info->service_id == service_list_ptr->service_info->service_id) { break; } service_list_ptr = service_list_ptr->next; } if(service_list_ptr == NULL) { debug(80, 1) ("WCCPv2 Unknown service received from router (%d)\n", service_info->service_id); return; } if(ntohl(security_info->security_option) != ntohl(service_list_ptr->security_info->security_option)) { debug(80, 1) ("Invalid security option in WCCPv2 Packet (%d vs %d).\n", ntohl(security_info->security_option), ntohl(service_list_ptr->security_info->security_option)); return; } if (! wccp2_check_security(service_list_ptr, (char *)security_info, (char *)&wccp2_i_see_you, len)) { debug(80, 1) ("Received WCCPv2 Packet failed authentication\n"); return; } /* Check that the router address is configured on this router */ for (router_list_ptr=&service_list_ptr->router_list_head;router_list_ptr->next != NULL;router_list_ptr=router_list_ptr->next) { if(router_list_ptr->router_sendto_address.s_addr == from.sin_addr.s_addr) break; } if(router_list_ptr->next == NULL) { debug(80, 1) ("WCCPv2 Packet received from unknown router\n"); return; } /* Set the router id */ router_list_ptr->info->router_address=router_identity_info->router_id_element.router_address; /* Increment the received id in the packet */ if ( ntohl(router_list_ptr->info->received_id) != ntohl(router_identity_info->router_id_element.received_id) ) { debug(80, 3) ("Incoming WCCP2_I_SEE_YOU member change = %d tmp=%d.\n", ntohl(router_list_ptr->info->received_id), ntohl(router_identity_info->router_id_element.received_id)); router_list_ptr->info->received_id = router_identity_info->router_id_element.received_id; } /* TODO: check return/forwarding methods */ if(router_capability_header == NULL) { if((Config.Wccp2.return_method != WCCP2_CAPABILITY_GRE) || (Config.Wccp2.forwarding_method != WCCP2_CAPABILITY_GRE)) { debug (80,1) ("wccp2HandleUdp: fatal error - A WCCP router does not support the forwarding method specified\n"); wccp2ConnectionClose(); return; } } else { num_capabilities=ntohs(router_capability_header->capability_info_length); /* run through each capability element from last to first */ if(num_capabilities > 0) { num_capabilities--; router_capability_element=(struct wccp2_capability_element_t *)(router_capability_header) + sizeof(struct wccp2_capability_info_header_t) + (num_capabilities * sizeof(struct wccp2_capability_element_t)); switch(ntohs(router_capability_element->capability_type)) { case WCCP2_CAPABILITY_FORWARDING_METHOD: if(ntohl(router_capability_element->capability_value) != Config.Wccp2.forwarding_method) { debug (80,1) ("wccp2HandleUdp: fatal error - A WCCP router has specified a different forwarding method\n"); wccp2ConnectionClose(); return; } break; case WCCP2_CAPABILITY_ASSIGNMENT_METHOD: /* we don't current care */ break; case WCCP2_CAPABILITY_RETURN_METHOD: if(ntohl(router_capability_element->capability_value) != Config.Wccp2.return_method) { debug (80,1) ("wccp2HandleUdp: fatal error - A WCCP router has specified a different return method\n"); wccp2ConnectionClose(); return; } break; default: debug(80, 1) ("Unknown capability type in WCCPv2 Packet (%d).\n", ntohs(router_capability_element->capability_type)); } } } debug(80, 5) ("Cleaning out cache list\n"); /* clean out the old cache list */ for(cache_list_ptr=&router_list_ptr->cache_list_head;cache_list_ptr;cache_list_ptr=cache_list_ptr_next) { cache_list_ptr_next=cache_list_ptr->next; if(cache_list_ptr != &router_list_ptr->cache_list_head) { xfree(cache_list_ptr); } } router_list_ptr->num_caches=htonl(0); num_caches=0; /* Check to see if we're the master cache and update the cache list */ found=0; service_list_ptr->lowest_ip=1; cache_list_ptr=&router_list_ptr->cache_list_head; /* to find the list of caches, we start at the end of the router view header */ ptr=(char *)(router_view_header) + sizeof(struct router_view_t); /* Then we read the number of routers */ memcpy(&tmp,ptr,sizeof(tmp)); /* skip the number plus all the ip's */ ptr+=sizeof(tmp) + (ntohl(tmp) * sizeof(struct in_addr)); /* Then read the number of caches */ memcpy(&tmp,ptr,sizeof(tmp)); ptr+=sizeof(tmp); if(ntohl(tmp) != 0) { /* search through the list of received-from ip addresses */ for(num_caches=0;num_caches< ntohl(tmp);num_caches++) { /* Get a copy of the ip */ cache_identity=(struct wccp2_cache_identity_info_t *)ptr; ptr+=sizeof(struct wccp2_cache_identity_info_t); memcpy(&cache_address,&cache_identity->addr,sizeof(struct in_addr)); /* Update the cache list */ cache_list_ptr->cache_ip=cache_address; cache_list_ptr->next=xcalloc(1,sizeof(struct wccp2_cache_list_t)); cache_list_ptr=cache_list_ptr->next; cache_list_ptr->next=NULL; debug(80,5) ("checking cache list: (%x:%x)\n",cache_address.s_addr,router_list_ptr->local_ip.s_addr); /* Check to see if it's the master, or us */ if(cache_address.s_addr == router_list_ptr->local_ip.s_addr) { found=1; } if(cache_address.s_addr < router_list_ptr->local_ip.s_addr) { service_list_ptr->lowest_ip=0; } } } else { /* Update the cache list */ cache_list_ptr->cache_ip=router_list_ptr->local_ip; cache_list_ptr->next=xcalloc(1,sizeof(struct wccp2_cache_list_t)); cache_list_ptr=cache_list_ptr->next; cache_list_ptr->next=NULL; service_list_ptr->lowest_ip=0; found=1; num_caches=1; } router_list_ptr->num_caches=htonl(num_caches); if ((found == 1) && (service_list_ptr->lowest_ip == 1)) { if( ntohl(router_view_header->change_number) != router_list_ptr->member_change ) { debug (80,4) ("Change detected - queueing up new assignment\n"); router_list_ptr->member_change = ntohl(router_view_header->change_number); if (!eventFind(wccp2AssignBuckets, NULL)) { eventAdd("wccp2AssignBuckets", wccp2AssignBuckets, NULL, 15.0, 1); } } } else { debug (80,5) ("I am not the lowest ip cache - not assigning buckets\n"); } } static void wccp2HereIam(void *voidnotused) { struct wccp2_service_list_t *service_list_ptr; struct wccp2_router_list_t *router_list_ptr; struct sockaddr_in router; int router_len; u_short port = WCCP_PORT; debug(80, 6) ("wccp2HereIam: Called\n"); if(wccp2_connected == 0) { debug (80,1) ("wccp2HereIam: wccp2 socket closed. Shutting down WCCP2\n"); return; } router_len = sizeof(router); memset(&router, '\0', router_len); router.sin_family = AF_INET; router.sin_port = htons(port); /* for each router on each service send a packet */ service_list_ptr = wccp2_service_list_head; while (service_list_ptr != NULL) { debug(80, 5) ("wccp2HereIam: sending to service id %d\n", service_list_ptr->info.service_id); for (router_list_ptr=&service_list_ptr->router_list_head;router_list_ptr->next != NULL;router_list_ptr=router_list_ptr->next) { router.sin_addr = router_list_ptr->router_sendto_address; /* Set the cache id (ip) */ service_list_ptr->wccp2_identity_info_ptr->cache_identity.addr=router_list_ptr->local_ip; /* Security update, if needed */ if (service_list_ptr->wccp2_security_type == WCCP2_MD5_SECURITY) { wccp2_update_md5_security(service_list_ptr->wccp_password, (char *)service_list_ptr->security_info, service_list_ptr->wccp_packet, service_list_ptr->wccp_packet_size); } debug(80,3) ("Sending HereIam packet size %d\n", (int)service_list_ptr->wccp_packet_size); /* Send the packet */ sendto(theOutWccp2Connection, &service_list_ptr->wccp_packet, service_list_ptr->wccp_packet_size, 0, (struct sockaddr *)&router, router_len); } service_list_ptr = service_list_ptr->next; } if (!eventFind(wccp2HereIam, NULL)) eventAdd("wccp2HereIam", wccp2HereIam, NULL, 10.0, 1); } static void wccp2AssignBuckets(void *voidnotused) { struct wccp2_service_list_t *service_list_ptr; struct wccp2_router_list_t *router_list_ptr; struct wccp2_cache_list_t *cache_list_ptr; char wccp_packet[WCCP_RESPONSE_SIZE]; short int offset,saved_offset; struct sockaddr_in router; int router_len; int bucket_counter; u_short port = WCCP_PORT; /* Packet segments */ struct wccp2_here_i_am_header_t *main_header; struct wccp2_security_md5_t *security = NULL; /* service from service struct */ struct wccp2_item_header_t *assignment_header; struct assignment_key_t *assignment_key; /* number of routers */ struct wccp2_router_assign_element_t *router_assign; /* number of caches */ struct in_addr *cache_address; char *buckets; router_len = sizeof(router); memset(&router, '\0', router_len); router.sin_family = AF_INET; router.sin_port = htons(port); /* Start main header - fill in length later */ offset=0; main_header=(struct wccp2_here_i_am_header_t *)&wccp_packet[offset]; main_header->type=htonl(WCCP2_REDIRECT_ASSIGN); main_header->version=htons(WCCP2_VERSION); debug(80,2)