1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * http_vhost.c: functions pertaining to virtual host addresses
19 * (configuration and run-time)
23 #include "apr_strings.h"
26 #define APR_WANT_STRFUNC
30 #include "ap_config.h"
32 #include "http_config.h"
34 #include "http_vhost.h"
35 #include "http_protocol.h"
36 #include "http_core.h"
38 #if APR_HAVE_ARPA_INET_H
39 #include <arpa/inet.h>
43 * After all the definitions there's an explanation of how it's all put
47 /* meta-list of name-vhosts. Each server_rec can be in possibly multiple
48 * lists of name-vhosts.
50 typedef struct name_chain name_chain;
53 server_addr_rec *sar; /* the record causing it to be in
54 * this chain (needed for port comparisons) */
55 server_rec *server; /* the server to use on a match */
58 /* meta-list of ip addresses. Each server_rec can be in possibly multiple
59 * hash chains since it can have multiple ips.
61 typedef struct ipaddr_chain ipaddr_chain;
64 server_addr_rec *sar; /* the record causing it to be in
65 * this chain (need for both ip addr and port
67 server_rec *server; /* the server to use if this matches */
68 name_chain *names; /* if non-NULL then a list of name-vhosts
69 * sharing this address */
72 /* This defines the size of the hash apr_table_t used for hashing ip addresses
73 * of virtual hosts. It must be a power of two.
75 #ifndef IPHASH_TABLE_SIZE
76 #define IPHASH_TABLE_SIZE 256
79 /* A (n) bucket hash table, each entry has a pointer to a server rec and
80 * a pointer to the other entries in that bucket. Each individual address,
81 * even for virtualhosts with multiple addresses, has an entry in this hash
82 * table. There are extra buckets for _default_, and name-vhost entries.
84 * Note that after config time this is constant, so it is thread-safe.
86 static ipaddr_chain *iphash_table[IPHASH_TABLE_SIZE];
88 /* dump out statistics about the hash function */
89 /* #define IPHASH_STATISTICS */
91 /* list of the _default_ servers */
92 static ipaddr_chain *default_list;
94 /* list of the NameVirtualHost addresses */
95 static server_addr_rec *name_vhost_list;
96 static server_addr_rec **name_vhost_list_tail;
101 * The ip address determines which chain in iphash_table is interesting, then
102 * a comparison is done down that chain to find the first ipaddr_chain whose
103 * sar matches the address:port pair.
105 * If that ipaddr_chain has names == NULL then you're done, it's an ip-vhost.
107 * Otherwise it's a name-vhost list, and the default is the server in the
108 * ipaddr_chain record. We tuck away the ipaddr_chain record in the
109 * conn_rec field vhost_lookup_data. Later on after the headers we get a
110 * second chance, and we use the name_chain to figure out what name-vhost
111 * matches the headers.
113 * If there was no ip address match in the iphash_table then do a lookup
114 * in the default_list.
116 * How it's put together ... well you should be able to figure that out
117 * from how it's used. Or something like that.
121 /* called at the beginning of the config */
122 AP_DECLARE(void) ap_init_vhost_config(apr_pool_t *p)
124 memset(iphash_table, 0, sizeof(iphash_table));
126 name_vhost_list = NULL;
127 name_vhost_list_tail = &name_vhost_list;
132 * Parses a host of the form <address>[:port]
133 * paddr is used to create a list in the order of input
134 * **paddr is the ->next pointer of the last entry (or s->addrs)
135 * *paddr is the variable used to keep track of **paddr between calls
136 * port is the default port to assume
138 static const char *get_addresses(apr_pool_t *p, const char *w_,
139 server_addr_rec ***paddr,
140 apr_port_t default_port)
142 apr_sockaddr_t *my_addr;
143 server_addr_rec *sar;
144 char *w, *host, *scope_id;
153 w = apr_pstrdup(p, w_);
154 /* apr_parse_addr_port() doesn't understand ":*" so handle that first. */
155 wlen = strlen(w); /* wlen must be > 0 at this point */
157 if (w[wlen - 1] == '*') {
161 else if (w[wlen - 2] == ':') {
166 rv = apr_parse_addr_port(&host, &scope_id, &port, w, p);
167 /* If the string is "80", apr_parse_addr_port() will be happy and set
168 * host to NULL and port to 80, so watch out for that.
170 if (rv != APR_SUCCESS) {
171 return "The address or port is invalid";
174 return "Missing address for VirtualHost";
177 return "Scope ids are not supported";
179 if (!port && !wild_port) {
183 if (strcmp(host, "*") == 0) {
184 rv = apr_sockaddr_info_get(&my_addr, "0.0.0.0", APR_INET, port, 0, p);
185 ap_assert(rv == APR_SUCCESS); /* must be bug or out of storage */
187 else if (strcasecmp(host, "_default_") == 0
188 || strcmp(host, "255.255.255.255") == 0) {
189 rv = apr_sockaddr_info_get(&my_addr, "255.255.255.255", APR_INET, port, 0, p);
190 ap_assert(rv == APR_SUCCESS); /* must be bug or out of storage */
193 rv = apr_sockaddr_info_get(&my_addr, host, APR_UNSPEC, port, 0, p);
194 if (rv != APR_SUCCESS) {
195 ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
196 "Cannot resolve host name %s --- ignoring!", host);
201 /* Remember all addresses for the host */
204 sar = apr_pcalloc(p, sizeof(server_addr_rec));
207 sar->host_addr = my_addr;
208 sar->host_port = port;
209 sar->virthost = host;
210 my_addr = my_addr->next;
217 /* parse the <VirtualHost> addresses */
218 const char *ap_parse_vhost_addrs(apr_pool_t *p,
219 const char *hostname,
222 server_addr_rec **addrs;
225 /* start the list of addreses */
227 while (hostname[0]) {
228 err = get_addresses(p, ap_getword_conf(p, &hostname), &addrs, s->port);
234 /* terminate the list */
237 if (s->addrs->host_port) {
238 /* override the default port which is inherited from main_server */
239 s->port = s->addrs->host_port;
246 const char *ap_set_name_virtual_host(cmd_parms *cmd, void *dummy,
249 /* use whatever port the main server has at this point */
250 return get_addresses(cmd->pool, arg, &name_vhost_list_tail,
255 /* hash apr_table_t statistics, keep this in here for the beta period so
256 * we can find out if the hash function is ok
258 #ifdef IPHASH_STATISTICS
259 static int iphash_compare(const void *a, const void *b)
261 return (*(const int *) b - *(const int *) a);
265 static void dump_iphash_statistics(server_rec *main_s)
267 unsigned count[IPHASH_TABLE_SIZE];
271 char buf[HUGE_STRING_LEN];
275 for (i = 0; i < IPHASH_TABLE_SIZE; ++i) {
277 for (src = iphash_table[i]; src; src = src->next) {
279 if (i < IPHASH_TABLE_SIZE) {
280 /* don't count the slop buckets in the total */
285 qsort(count, IPHASH_TABLE_SIZE, sizeof(count[0]), iphash_compare);
286 p = buf + apr_snprintf(buf, sizeof(buf),
287 "iphash: total hashed = %u, avg chain = %u, "
288 "chain lengths (count x len):",
289 total, total / IPHASH_TABLE_SIZE);
291 for (i = 1; i < IPHASH_TABLE_SIZE; ++i) {
292 if (count[i - 1] != count[i]) {
293 p += apr_snprintf(p, sizeof(buf) - (p - buf), " %ux%u",
294 total, count[i - 1]);
301 p += apr_snprintf(p, sizeof(buf) - (p - buf), " %ux%u",
302 total, count[IPHASH_TABLE_SIZE - 1]);
303 ap_log_error(APLOG_MARK, APLOG_DEBUG, main_s, buf);
308 /* This hashing function is designed to get good distribution in the cases
309 * where the server is handling entire "networks" of servers. i.e. a
310 * whack of /24s. This is probably the most common configuration for
311 * ISPs with large virtual servers.
313 * NOTE: This function is symmetric (i.e. collapses all 4 octets
314 * into one), so machine byte order (big/little endianness) does not matter.
316 * Hash function provided by David Hankins.
318 static APR_INLINE unsigned hash_inaddr(unsigned key)
321 return ((key >> 8) ^ key) % IPHASH_TABLE_SIZE;
324 static APR_INLINE unsigned hash_addr(struct apr_sockaddr_t *sa)
328 /* The key is the last four bytes of the IP address.
329 * For IPv4, this is the entire address, as always.
330 * For IPv6, this is usually part of the MAC address.
332 key = *(unsigned *)((char *)sa->ipaddr_ptr + sa->ipaddr_len - 4);
333 return hash_inaddr(key);
336 static ipaddr_chain *new_ipaddr_chain(apr_pool_t *p,
337 server_rec *s, server_addr_rec *sar)
341 new = apr_palloc(p, sizeof(*new));
350 static name_chain *new_name_chain(apr_pool_t *p,
351 server_rec *s, server_addr_rec *sar)
355 new = apr_palloc(p, sizeof(*new));
363 static APR_INLINE ipaddr_chain *find_ipaddr(apr_sockaddr_t *sa)
368 /* scan the hash apr_table_t for an exact match first */
369 bucket = hash_addr(sa);
370 for (trav = iphash_table[bucket]; trav; trav = trav->next) {
371 server_addr_rec *sar = trav->sar;
372 apr_sockaddr_t *cur = sar->host_addr;
374 if (cur->port == 0 || sa->port == 0 || cur->port == sa->port) {
375 if (apr_sockaddr_equal(cur, sa)) {
383 static ipaddr_chain *find_default_server(apr_port_t port)
385 server_addr_rec *sar;
388 for (trav = default_list; trav; trav = trav->next) {
390 if (sar->host_port == 0 || sar->host_port == port) {
398 static void dump_a_vhost(apr_file_t *f, ipaddr_chain *ic)
402 char buf[MAX_STRING_LEN];
403 apr_sockaddr_t *ha = ic->sar->host_addr;
405 if (ha->family == APR_INET &&
406 ha->sa.sin.sin_addr.s_addr == DEFAULT_VHOST_ADDR) {
407 len = apr_snprintf(buf, sizeof(buf), "_default_:%u",
410 else if (ha->family == APR_INET &&
411 ha->sa.sin.sin_addr.s_addr == INADDR_ANY) {
412 len = apr_snprintf(buf, sizeof(buf), "*:%u",
416 len = apr_snprintf(buf, sizeof(buf), "%pI", ha);
418 if (ic->sar->host_port == 0) {
421 if (ic->names == NULL) {
422 apr_file_printf(f, "%-22s %s (%s:%u)\n", buf,
423 ic->server->server_hostname,
424 ic->server->defn_name, ic->server->defn_line_number);
427 apr_file_printf(f, "%-22s is a NameVirtualHost\n"
428 "%8s default server %s (%s:%u)\n",
429 buf, "", ic->server->server_hostname,
430 ic->server->defn_name, ic->server->defn_line_number);
431 for (nc = ic->names; nc; nc = nc->next) {
432 if (nc->sar->host_port) {
433 apr_file_printf(f, "%8s port %u ", "", nc->sar->host_port);
436 apr_file_printf(f, "%8s port * ", "");
438 apr_file_printf(f, "namevhost %s (%s:%u)\n",
439 nc->server->server_hostname,
440 nc->server->defn_name, nc->server->defn_line_number);
444 static void dump_vhost_config(apr_file_t *f)
449 apr_file_printf(f, "VirtualHost configuration:\n");
450 for (i = 0; i < IPHASH_TABLE_SIZE; ++i) {
451 for (ic = iphash_table[i]; ic; ic = ic->next) {
456 apr_file_printf(f, "wildcard NameVirtualHosts and _default_ servers:\n");
457 for (ic = default_list; ic; ic = ic->next) {
464 * Two helper functions for ap_fini_vhost_config()
466 static int add_name_vhost_config(apr_pool_t *p, server_rec *main_s,
467 server_rec *s, server_addr_rec *sar,
470 /* the first time we encounter a NameVirtualHost address
471 * ic->server will be NULL, on subsequent encounters
472 * ic->names will be non-NULL.
474 if (ic->names || ic->server == NULL) {
475 name_chain *nc = new_name_chain(p, s, sar);
476 nc->next = ic->names;
479 if (sar->host_port != ic->sar->host_port) {
480 /* one of the two is a * port, the other isn't */
481 ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_s,
482 "VirtualHost %s:%u -- mixing * "
483 "ports and non-* ports with "
484 "a NameVirtualHost address is not supported,"
485 " proceeding with undefined results",
486 sar->virthost, sar->host_port);
491 /* IP-based vhosts are handled by the caller */
496 static void remove_unused_name_vhosts(server_rec *main_s, ipaddr_chain **pic)
499 ipaddr_chain *ic = *pic;
501 if (ic->server == NULL) {
502 ap_log_error(APLOG_MARK, APLOG_WARNING, 0, main_s,
503 "NameVirtualHost %s:%u has no VirtualHosts",
504 ic->sar->virthost, ic->sar->host_port);
507 else if (ic->names == NULL) {
508 /* if server != NULL and names == NULL then we're done
509 * looking at NameVirtualHosts
519 /* compile the tables and such we need to do the run-time vhost lookups */
520 AP_DECLARE(void) ap_fini_vhost_config(apr_pool_t *p, server_rec *main_s)
522 server_addr_rec *sar;
523 int has_default_vhost_addr;
526 ipaddr_chain **iphash_table_tail[IPHASH_TABLE_SIZE];
528 /* terminate the name_vhost list */
529 *name_vhost_list_tail = NULL;
531 /* Main host first */
534 if (!s->server_hostname) {
535 s->server_hostname = ap_get_local_host(p);
538 /* initialize the tails */
539 for (i = 0; i < IPHASH_TABLE_SIZE; ++i) {
540 iphash_table_tail[i] = &iphash_table[i];
543 /* The first things to go into the hash apr_table_t are the NameVirtualHosts
544 * Since name_vhost_list is in the same order that the directives
545 * occured in the config file, we'll copy it in that order.
547 for (sar = name_vhost_list; sar; sar = sar->next) {
548 char inaddr_any[16] = {0}; /* big enough to handle IPv4 or IPv6 */
549 unsigned bucket = hash_addr(sar->host_addr);
550 ipaddr_chain *ic = new_ipaddr_chain(p, NULL, sar);
552 if (memcmp(sar->host_addr->ipaddr_ptr, inaddr_any,
553 sar->host_addr->ipaddr_len)) { /* not IN[6]ADDR_ANY */
554 *iphash_table_tail[bucket] = ic;
555 iphash_table_tail[bucket] = &ic->next;
558 /* A wildcard NameVirtualHost goes on the default_list so
559 * that it can catch incoming requests on any address.
561 ic->next = default_list;
564 /* Notice that what we've done is insert an ipaddr_chain with
565 * both server and names NULL. This fact is used to spot name-
566 * based vhosts in add_name_vhost_config().
570 /* The next things to go into the hash apr_table_t are the virtual hosts
571 * themselves. They're listed off of main_s->next in the reverse
572 * order they occured in the config file, so we insert them at
573 * the iphash_table_tail but don't advance the tail.
576 for (s = main_s->next; s; s = s->next) {
577 has_default_vhost_addr = 0;
578 for (sar = s->addrs; sar; sar = sar->next) {
580 char inaddr_any[16] = {0}; /* big enough to handle IPv4 or IPv6 */
582 if ((sar->host_addr->family == AF_INET &&
583 sar->host_addr->sa.sin.sin_addr.s_addr == DEFAULT_VHOST_ADDR)
584 || !memcmp(sar->host_addr->ipaddr_ptr, inaddr_any, sar->host_addr->ipaddr_len)) {
585 ic = find_default_server(sar->host_port);
586 if (!ic || !add_name_vhost_config(p, main_s, s, sar, ic)) {
587 if (ic && ic->sar->host_port != 0) {
588 ap_log_error(APLOG_MARK, APLOG_WARNING,
589 0, main_s, "_default_ VirtualHost "
590 "overlap on port %u, the first has "
591 "precedence", sar->host_port);
593 ic = new_ipaddr_chain(p, s, sar);
594 ic->next = default_list;
597 has_default_vhost_addr = 1;
600 /* see if it matches something we've already got */
601 ic = find_ipaddr(sar->host_addr);
604 unsigned bucket = hash_addr(sar->host_addr);
606 ic = new_ipaddr_chain(p, s, sar);
607 ic->next = *iphash_table_tail[bucket];
608 *iphash_table_tail[bucket] = ic;
610 else if (!add_name_vhost_config(p, main_s, s, sar, ic)) {
611 ap_log_error(APLOG_MARK, APLOG_WARNING,
612 0, main_s, "VirtualHost %s:%u overlaps "
613 "with VirtualHost %s:%u, the first has "
614 "precedence, perhaps you need a "
615 "NameVirtualHost directive",
616 sar->virthost, sar->host_port,
617 ic->sar->virthost, ic->sar->host_port);
624 /* Ok now we want to set up a server_hostname if the user was
625 * silly enough to forget one.
626 * XXX: This is silly we should just crash and burn.
628 if (!s->server_hostname) {
629 if (has_default_vhost_addr) {
630 s->server_hostname = main_s->server_hostname;
632 else if (!s->addrs) {
633 /* what else can we do? at this point this vhost has
634 no configured name, probably because they used
635 DNS in the VirtualHost statement. It's disabled
636 anyhow by the host matching code. -djg */
638 apr_pstrdup(p, "bogus_host_without_forward_dns");
644 rv = apr_getnameinfo(&hostname, s->addrs->host_addr, 0);
645 if (rv == APR_SUCCESS) {
646 s->server_hostname = apr_pstrdup(p, hostname);
649 /* again, what can we do? They didn't specify a
650 ServerName, and their DNS isn't working. -djg */
653 apr_sockaddr_ip_get(&ipaddr_str, s->addrs->host_addr);
654 ap_log_error(APLOG_MARK, APLOG_ERR, rv, main_s,
655 "Failed to resolve server name "
656 "for %s (check DNS) -- or specify an explicit "
660 apr_pstrdup(p, "bogus_host_without_reverse_dns");
666 /* now go through and delete any NameVirtualHosts that didn't have any
667 * hosts associated with them. Lamers.
669 for (i = 0; i < IPHASH_TABLE_SIZE; ++i) {
670 remove_unused_name_vhosts(main_s, &iphash_table[i]);
672 remove_unused_name_vhosts(main_s, &default_list);
674 #ifdef IPHASH_STATISTICS
675 dump_iphash_statistics(main_s);
677 if (ap_exists_config_define("DUMP_VHOSTS")) {
678 apr_file_t *thefile = NULL;
679 apr_file_open_stderr(&thefile, p);
680 dump_vhost_config(thefile);
685 /*****************************************************************************
686 * run-time vhost matching functions
689 /* Lowercase and remove any trailing dot and/or :port from the hostname,
690 * and check that it is sane.
692 * In most configurations the exact syntax of the hostname isn't
693 * important so strict sanity checking isn't necessary. However, in
694 * mass hosting setups (using mod_vhost_alias or mod_rewrite) where
695 * the hostname is interpolated into the filename, we need to be sure
696 * that the interpolation doesn't expose parts of the filesystem.
697 * We don't do strict RFC 952 / RFC 1123 syntax checking in order
698 * to support iDNS and people who erroneously use underscores.
699 * Instead we just check for filesystem metacharacters: directory
700 * separators / and \ and sequences of more than one dot.
702 static void fix_hostname(request_rec *r)
704 char *host, *scope_id;
709 /* According to RFC 2616, Host header field CAN be blank. */
714 rv = apr_parse_addr_port(&host, &scope_id, &port, r->hostname, r->pool);
715 if (rv != APR_SUCCESS || scope_id) {
720 /* silly looking host ("Host: 123") but that isn't our job
721 * here to judge; apr_parse_addr_port() would think we had a port
724 host = apr_itoa(r->pool, (int)port);
727 /* Don't throw the Host: header's port number away:
728 save it in parsed_uri -- ap_get_server_port() needs it! */
729 /* @@@ XXX there should be a better way to pass the port.
730 * Like r->hostname, there should be a r->portno
732 r->parsed_uri.port = port;
733 r->parsed_uri.port_str = apr_itoa(r->pool, (int)port);
736 /* if the hostname is an IPv6 numeric address string, it was validated
737 * already; otherwise, further validation is needed
739 if (r->hostname[0] != '[') {
740 for (dst = host; *dst; dst++) {
741 if (apr_islower(*dst)) {
742 /* leave char unchanged */
744 else if (*dst == '.') {
745 if (*(dst + 1) == '.') {
749 else if (apr_isupper(*dst)) {
750 *dst = apr_tolower(*dst);
752 else if (*dst == '/' || *dst == '\\') {
756 /* strip trailing gubbins */
757 if (dst > host && dst[-1] == '.') {
765 r->status = HTTP_BAD_REQUEST;
766 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
767 "Client sent malformed Host header");
772 /* return 1 if host matches ServerName or ServerAliases */
773 static int matches_aliases(server_rec *s, const char *host)
776 apr_array_header_t *names;
778 /* match ServerName */
779 if (!strcasecmp(host, s->server_hostname)) {
783 /* search all the aliases from ServerAlias directive */
786 char **name = (char **) names->elts;
787 for (i = 0; i < names->nelts; ++i) {
788 if(!name[i]) continue;
789 if (!strcasecmp(host, name[i]))
793 names = s->wild_names;
795 char **name = (char **) names->elts;
796 for (i = 0; i < names->nelts; ++i) {
797 if(!name[i]) continue;
798 if (!ap_strcasecmp_match(host, name[i]))
806 /* Suppose a request came in on the same socket as this r, and included
807 * a header "Host: host:port", would it map to r->server? It's more
808 * than just that though. When we do the normal matches for each request
809 * we don't even bother considering Host: etc on non-namevirtualhosts,
810 * we just call it a match. But here we require the host:port to match
811 * the ServerName and/or ServerAliases.
813 AP_DECLARE(int) ap_matches_request_vhost(request_rec *r, const char *host,
817 server_addr_rec *sar;
821 /* search all the <VirtualHost> values */
822 /* XXX: If this is a NameVirtualHost then we may not be doing the Right Thing
825 * NameVirtualHost 10.1.1.1
826 * <VirtualHost 10.1.1.1>
829 * <VirtualHost 10.1.1.1>
833 * Suppose r->server is v2, and we're asked to match "10.1.1.1". We'll say
834 * "yup it's v2", when really it isn't... if a request came in for 10.1.1.1
835 * it would really go to v1.
837 for (sar = s->addrs; sar; sar = sar->next) {
838 if ((sar->host_port == 0 || port == sar->host_port)
839 && !strcasecmp(host, sar->virthost)) {
844 /* the Port has to match now, because the rest don't have ports associated
846 if (port != s->port) {
850 return matches_aliases(s, host);
854 static void check_hostalias(request_rec *r)
857 * Even if the request has a Host: header containing a port we ignore
858 * that port. We always use the physical port of the socket. There
859 * are a few reasons for this:
861 * - the default of 80 or 443 for SSL is easier to handle this way
862 * - there is less of a possibility of a security problem
863 * - it simplifies the data structure
864 * - the client may have no idea that a proxy somewhere along the way
865 * translated the request to another ip:port
866 * - except for the addresses from the VirtualHost line, none of the other
867 * names we'll match have ports associated with them
869 const char *host = r->hostname;
877 apr_sockaddr_port_get(&port, r->connection->local_addr);
879 /* Recall that the name_chain is a list of server_addr_recs, some of
880 * whose ports may not match. Also each server may appear more than
881 * once in the chain -- specifically, it will appear once for each
882 * address from its VirtualHost line which matched. We only want to
883 * do the full ServerName/ServerAlias comparisons once for each
884 * server, fortunately we know that all the VirtualHost addresses for
885 * a single server are adjacent to each other.
888 for (src = r->connection->vhost_lookup_data; src; src = src->next) {
889 server_addr_rec *sar;
891 /* We only consider addresses on the name_chain which have a matching
895 if (sar->host_port != 0 && port != sar->host_port) {
901 /* does it match the virthost from the sar? */
902 if (!strcasecmp(host, sar->virthost)) {
907 /* we've already done ServerName and ServerAlias checks for this
914 if (matches_aliases(s, host)) {
921 /* s is the first matching server, we're done */
926 static void check_serverpath(request_rec *r)
933 apr_sockaddr_port_get(&port, r->connection->local_addr);
936 * This is in conjunction with the ServerPath code in http_core, so we
937 * get the right host attached to a non- Host-sending request.
939 * See the comment in check_hostalias about how each vhost can be
940 * listed multiple times.
944 for (src = r->connection->vhost_lookup_data; src; src = src->next) {
945 /* We only consider addresses on the name_chain which have a matching
948 if (src->sar->host_port != 0 && port != src->sar->host_port) {
958 if (s->path && !strncmp(r->uri, s->path, s->pathlen) &&
959 (s->path[s->pathlen - 1] == '/' ||
960 r->uri[s->pathlen] == '/' ||
961 r->uri[s->pathlen] == '\0')) {
969 AP_DECLARE(void) ap_update_vhost_from_headers(request_rec *r)
971 /* must set this for HTTP/1.1 support */
972 if (r->hostname || (r->hostname = apr_table_get(r->headers_in, "Host"))) {
974 if (r->status != HTTP_OK)
977 /* check if we tucked away a name_chain */
978 if (r->connection->vhost_lookup_data) {
988 * For every virtual host on this connection, call func_cb.
990 AP_DECLARE(int) ap_vhost_iterate_given_conn(conn_rec *conn,
991 ap_vhost_iterate_conn_cb func_cb,
1000 if (conn->vhost_lookup_data) {
1002 port = conn->local_addr->port;
1004 for (src = conn->vhost_lookup_data; src; src = src->next) {
1005 server_addr_rec *sar;
1007 /* We only consider addresses on the name_chain which have a
1011 if (sar->host_port != 0 && port != sar->host_port) {
1018 /* we've already done a callback for this vhost. */
1024 rv = func_cb(baton, conn, s);
1032 rv = func_cb(baton, conn, conn->base_server);
1038 /* Called for a new connection which has a known local_addr. Note that the
1039 * new connection is assumed to have conn->server == main server.
1041 AP_DECLARE(void) ap_update_vhost_given_ip(conn_rec *conn)
1046 /* scan the hash apr_table_t for an exact match first */
1047 trav = find_ipaddr(conn->local_addr);
1050 /* save the name_chain for later in case this is a name-vhost */
1051 conn->vhost_lookup_data = trav->names;
1052 conn->base_server = trav->server;
1056 /* maybe there's a default server or wildcard name-based vhost
1057 * matching this port
1059 apr_sockaddr_port_get(&port, conn->local_addr);
1061 trav = find_default_server(port);
1063 conn->vhost_lookup_data = trav->names;
1064 conn->base_server = trav->server;
1068 /* otherwise we're stuck with just the main server
1069 * and no name-based vhosts
1071 conn->vhost_lookup_data = NULL;