分享
 
 
 

http1.1---6

王朝other·作者佚名  2006-01-08
窄屏简体版  字體: |||超大  

Fielding, et. al. Standards Track [Page 71]

RFC 2068 HTTP/1.1 January 1997

Therefore, the HTTP/1.1 protocol provides these important elements:

1. Protocol features that provide full semantic transparency when this

is required by all parties.

2. Protocol features that allow an origin server or user agent to

explicitly request and control non-transparent operation.

3. Protocol features that allow a cache to attach warnings to

responses that do not preserve the requested approximation of

semantic transparency.

A basic principle is that it must be possible for the clients to

detect any potential relaxation of semantic transparency.

Note: The server, cache, or client implementer may be faced with

design decisions not explicitly discussed in this specification. If

a decision may affect semantic transparency, the implementer ought

to err on the side of maintaining transparency unless a careful and

complete analysis shows significant benefits in breaking

transparency.

13.1.1 Cache Correctness

A correct cache MUST respond to a request with the most up-to-date

response held by the cache that is appropriate to the request (see

sections 13.2.5, 13.2.6, and 13.12) which meets one of the following

conditions:

1. It has been checked for equivalence with what the origin server

would have returned by revalidating the response with the origin

server (section 13.3);

2. It is "fresh enough" (see section 13.2). In the default case, this

means it meets the least restrictive freshness requirement of the

client, server, and cache (see section 14.9); if the origin server

so specifies, it is the freshness requirement of the origin server

alone.

3. It includes a warning if the freshness demand of the client or the

origin server is violated (see section 13.1.5 and 14.45).

4. It is an appropriate 304 (Not Modified), 305 (Proxy Redirect), or

error (4xx or 5xx) response message.

If the cache can not communicate with the origin server, then a

correct cache SHOULD respond as above if the response can be

correctly served from the cache; if not it MUST return an error or

Fielding, et. al. Standards Track [Page 72]

RFC 2068 HTTP/1.1 January 1997

warning indicating that there was a communication failure.

If a cache receives a response (either an entire response, or a 304

(Not Modified) response) that it would normally forward to the

requesting client, and the received response is no longer fresh, the

cache SHOULD forward it to the requesting client without adding a new

Warning (but without removing any existing Warning headers). A cache

SHOULD NOT attempt to revalidate a response simply because that

response became stale in transit; this might lead to an infinite

loop. An user agent that receives a stale response without a Warning

MAY display a warning indication to the user.

13.1.2 Warnings

Whenever a cache returns a response that is neither first-hand nor

"fresh enough" (in the sense of condition 2 in section 13.1.1), it

must attach a warning to that effect, using a Warning response-

header. This warning allows clients to take appropriate action.

Warnings may be used for other purposes, both cache-related and

otherwise. The use of a warning, rather than an error status code,

distinguish these responses from true failures.

Warnings are always cachable, because they never weaken the

transparency of a response. This means that warnings can be passed to

HTTP/1.0 caches without danger; such caches will simply pass the

warning along as an entity-header in the response.

Warnings are assigned numbers between 0 and 99. This specification

defines the code numbers and meanings of each currently assigned

warnings, allowing a client or cache to take automated action in some

(but not all) cases.

Warnings also carry a warning text. The text may be in any

appropriate natural language (perhaps based on the client's Accept

headers), and include an optional indication of what character set is

used.

Multiple warnings may be attached to a response (either by the origin

server or by a cache), including multiple warnings with the same code

number. For example, a server may provide the same warning with texts

in both English and Basque.

When multiple warnings are attached to a response, it may not be

practical or reasonable to display all of them to the user. This

version of HTTP does not specify strict priority rules for deciding

which warnings to display and in what order, but does suggest some

heuristics.

Fielding, et. al. Standards Track [Page 73]

RFC 2068 HTTP/1.1 January 1997

The Warning header and the currently defined warnings are described

in section 14.45.

13.1.3 Cache-control Mechanisms

The basic cache mechanisms in HTTP/1.1 (server-specified expiration

times and validators) are implicit directives to caches. In some

cases, a server or client may need to provide explicit directives to

the HTTP caches. We use the Cache-Control header for this purpose.

The Cache-Control header allows a client or server to transmit a

variety of directives in either requests or responses. These

directives typically override the default caching algorithms. As a

general rule, if there is any apparent conflict between header

values, the most restrictive interpretation should be applied (that

is, the one that is most likely to preserve semantic transparency).

However, in some cases, Cache-Control directives are explicitly

specified as weakening the approximation of semantic transparency

(for example, "max-stale" or "public").

The Cache-Control directives are described in detail in section 14.9.

13.1.4 Explicit User Agent Warnings

Many user agents make it possible for users to override the basic

caching mechanisms. For example, the user agent may allow the user to

specify that cached entities (even explicitly stale ones) are never

validated. Or the user agent might habitually add "Cache-Control:

max-stale=3600" to every request. The user should have to explicitly

request either non-transparent behavior, or behavior that results in

abnormally ineffective caching.

If the user has overridden the basic caching mechanisms, the user

agent should explicitly indicate to the user whenever this results in

the display of information that might not meet the server's

transparency requirements (in particular, if the displayed entity is

known to be stale). Since the protocol normally allows the user agent

to determine if responses are stale or not, this indication need only

be displayed when this actually happens. The indication need not be a

dialog box; it could be an icon (for example, a picture of a rotting

fish) or some other visual indicator.

If the user has overridden the caching mechanisms in a way that would

abnormally reduce the effectiveness of caches, the user agent should

continually display an indication (for example, a picture of currency

in flames) so that the user does not inadvertently consume excess

resources or suffer from excessive latency.

Fielding, et. al. Standards Track [Page 74]

RFC 2068 HTTP/1.1 January 1997

13.1.5 Exceptions to the Rules and Warnings

In some cases, the operator of a cache may choose to configure it to

return stale responses even when not requested by clients. This

decision should not be made lightly, but may be necessary for reasons

of availability or performance, especially when the cache is poorly

connected to the origin server. Whenever a cache returns a stale

response, it MUST mark it as such (using a Warning header). This

allows the client software to alert the user that there may be a

potential problem.

It also allows the user agent to take steps to obtain a first-hand or

fresh response. For this reason, a cache SHOULD NOT return a stale

response if the client explicitly requests a first-hand or fresh one,

unless it is impossible to comply for technical or policy reasons.

13.1.6 Client-controlled Behavior

While the origin server (and to a lesser extent, intermediate caches,

by their contribution to the age of a response) are the primary

source of expiration information, in some cases the client may need

to control a cache's decision about whether to return a cached

response without validating it. Clients do this using several

directives of the Cache-Control header.

A client's request may specify the maximum age it is willing to

accept of an unvalidated response; specifying a value of zero forces

the cache(s) to revalidate all responses. A client may also specify

the minimum time remaining before a response expires. Both of these

options increase constraints on the behavior of caches, and so cannot

further relax the cache's approximation of semantic transparency.

A client may also specify that it will accept stale responses, up to

some maximum amount of staleness. This loosens the constraints on the

caches, and so may violate the origin server's specified constraints

on semantic transparency, but may be necessary to support

disconnected operation, or high availability in the face of poor

connectivity.

13.2 Expiration Model

13.2.1 Server-Specified Expiration

HTTP caching works best when caches can entirely avoid making

requests to the origin server. The primary mechanism for avoiding

requests is for an origin server to provide an explicit expiration

time in the future, indicating that a response may be used to satisfy

subsequent requests. In other words, a cache can return a fresh

Fielding, et. al. Standards Track [Page 75]

RFC 2068 HTTP/1.1 January 1997

response without first contacting the server.

Our expectation is that servers will assign future explicit

expiration times to responses in the belief that the entity is not

likely to change, in a semantically significant way, before the

expiration time is reached. This normally preserves semantic

transparency, as long as the server's expiration times are carefully

chosen.

The expiration mechanism applies only to responses taken from a cache

and not to first-hand responses forwarded immediately to the

requesting client.

If an origin server wishes to force a semantically transparent cache

to validate every request, it may assign an explicit expiration time

in the past. This means that the response is always stale, and so the

cache SHOULD validate it before using it for subsequent requests. See

section 14.9.4 for a more restrictive way to force revalidation.

If an origin server wishes to force any HTTP/1.1 cache, no matter how

it is configured, to validate every request, it should use the

"must-revalidate" Cache-Control directive (see section 14.9).

Servers specify explicit expiration times using either the Expires

header, or the max-age directive of the Cache-Control header.

An expiration time cannot be used to force a user agent to refresh

its display or reload a resource; its semantics apply only to caching

mechanisms, and such mechanisms need only check a resource's

expiration status when a new request for that resource is initiated.

See section 13.13 for explanation of the difference between caches

and history mechanisms.

13.2.2 Heuristic Expiration

Since origin servers do not always provide explicit expiration times,

HTTP caches typically assign heuristic expiration times, employing

algorithms that use other header values (such as the Last-Modified

time) to estimate a plausible expiration time. The HTTP/1.1

specification does not provide specific algorithms, but does impose

worst-case constraints on their results. Since heuristic expiration

times may compromise semantic transparency, they should be used

cautiously, and we encourage origin servers to provide explicit

expiration times as much as possible.

Fielding, et. al. Standards Track [Page 76]

RFC 2068 HTTP/1.1 January 1997

13.2.3 Age Calculations

In order to know if a cached entry is fresh, a cache needs to know if

its age exceeds its freshness lifetime. We discuss how to calculate

the latter in section 13.2.4; this section describes how to calculate

the age of a response or cache entry.

In this discussion, we use the term "now" to mean "the current value

of the clock at the host performing the calculation." Hosts that use

HTTP, but especially hosts running origin servers and caches, should

use NTP [28] or some similar protocol to synchronize their clocks to

a globally accurate time standard.

Also note that HTTP/1.1 requires origin servers to send a Date header

with every response, giving the time at which the response was

generated. We use the term "date_value" to denote the value of the

Date header, in a form appropriate for arithmetic operations.

HTTP/1.1 uses the Age response-header to help convey age information

between caches. The Age header value is the sender's estimate of the

amount of time since the response was generated at the origin server.

In the case of a cached response that has been revalidated with the

origin server, the Age value is based on the time of revalidation,

not of the original response.

In essence, the Age value is the sum of the time that the response

has been resident in each of the caches along the path from the

origin server, plus the amount of time it has been in transit along

network paths.

We use the term "age_value" to denote the value of the Age header, in

a form appropriate for arithmetic operations.

A response's age can be calculated in two entirely independent ways:

1. now minus date_value, if the local clock is reasonably well

synchronized to the origin server's clock. If the result is

negative, the result is replaced by zero.

2. age_value, if all of the caches along the response path

implement HTTP/1.1.

Given that we have two independent ways to compute the age of a

response when it is received, we can combine these as

corrected_received_age = max(now - date_value, age_value)

and as long as we have either nearly synchronized clocks or all-

Fielding, et. al. Standards Track [Page 77]

RFC 2068 HTTP/1.1 January 1997

HTTP/1.1 paths, one gets a reliable (conservative) result.

Note that this correction is applied at each HTTP/1.1 cache along the

path, so that if there is an HTTP/1.0 cache in the path, the correct

received age is computed as long as the receiving cache's clock is

nearly in sync. We don't need end-to-end clock synchronization

(although it is good to have), and there is no explicit clock

synchronization step.

Because of network-imposed delays, some significant interval may pass

from the time that a server generates a response and the time it is

received at the next outbound cache or client. If uncorrected, this

delay could result in improperly low ages.

Because the request that resulted in the returned Age value must have

been initiated prior to that Age value's generation, we can correct

for delays imposed by the network by recording the time at which the

request was initiated. Then, when an Age value is received, it MUST

be interpreted relative to the time the request was initiated, not

the time that the response was received. This algorithm results in

conservative behavior no matter how much delay is experienced. So, we

compute:

corrected_initial_age = corrected_received_age

+ (now - request_time)

where "request_time" is the time (according to the local clock) when

the request that elicited this response was sent.

Summary of age calculation algorithm, when a cache receives a

response:

/*

* age_value

* is the value of Age: header received by the cache with

* this response.

* date_value

* is the value of the origin server's Date: header

* request_time

* is the (local) time when the cache made the request

* that resulted in this cached response

* response_time

* is the (local) time when the cache received the

* response

* now

* is the current (local) time

*/

apparent_age = max(0, response_time - date_value);

Fielding, et. al. Standards Track [Page 78]

RFC 2068 HTTP/1.1 January 1997

corrected_received_age = max(apparent_age, age_value);

response_delay = response_time - request_time;

corrected_initial_age = corrected_received_age + response_delay;

resident_time = now - response_time;

current_age = corrected_initial_age + resident_time;

When a cache sends a response, it must add to the

corrected_initial_age the amount of time that the response was

resident locally. It must then transmit this total age, using the Age

header, to the next recipient cache.

Note that a client cannot reliably tell that a response is first-

hand, but the presence of an Age header indicates that a response

is definitely not first-hand. Also, if the Date in a response is

earlier than the client's local request time, the response is

probably not first-hand (in the absence of serious clock skew).

13.2.4 Expiration Calculations

In order to decide whether a response is fresh or stale, we need to

compare its freshness lifetime to its age. The age is calculated as

described in section 13.2.3; this section describes how to calculate

the freshness lifetime, and to determine if a response has expired.

In the discussion below, the values can be represented in any form

appropriate for arithmetic operations.

We use the term "expires_value" to denote the value of the Expires

header. We use the term "max_age_value" to denote an appropriate

value of the number of seconds carried by the max-age directive of

the Cache-Control header in a response (see section 14.10.

The max-age directive takes priority over Expires, so if max-age is

present in a response, the calculation is simply:

freshness_lifetime = max_age_value

Otherwise, if Expires is present in the response, the calculation is:

freshness_lifetime = expires_value - date_value

Note that neither of these calculations is vulnerable to clock skew,

since all of the information comes from the origin server.

If neither Expires nor Cache-Control: max-age appears in the

response, and the response does not include other restrictions on

caching, the cache MAY compute a freshness lifetime using a

heuristic. If the value is greater than 24 hours, the cache must

attach Warning 13 to any response whose age is more than 24 hours if

Fielding, et. al. Standards Track [Page 79]

RFC 2068 HTTP/1.1 January 1997

such warning has not already been added.

Also, if the response does have a Last-Modified time, the heuristic

expiration value SHOULD be no more than some fraction of the interval

since that time. A typical setting of this fraction might be 10%.

The calculation to determine if a response has expired is quite

simple:

response_is_fresh = (freshness_lifetime > current_age)

13.2.5 Disambiguating Expiration Values

Because expiration values are assigned optimistically, it is possible

for two caches to contain fresh values for the same resource that are

different.

If a client performing a retrieval receives a non-first-hand response

for a request that was already fresh in its own cache, and the Date

header in its existing cache entry is newer than the Date on the new

response, then the client MAY ignore the response. If so, it MAY

retry the request with a "Cache-Control: max-age=0" directive (see

section 14.9), to force a check with the origin server.

If a cache has two fresh responses for the same representation with

different validators, it MUST use the one with the more recent Date

header. This situation may arise because the cache is pooling

responses from other caches, or because a client has asked for a

reload or a revalidation of an apparently fresh cache entry.

13.2.6 Disambiguating Multiple Responses

Because a client may be receiving responses via multiple paths, so

that some responses flow through one set of caches and other

responses flow through a different set of caches, a client may

receive responses in an order different from that in which the origin

server sent them. We would like the client to use the most recently

generated response, even if older responses are still apparently

fresh.

Neither the entity tag nor the expiration value can impose an

ordering on responses, since it is possible that a later response

intentionally carries an earlier expiration time. However, the

HTTP/1.1 specification requires the transmission of Date headers on

every response, and the Date values are ordered to a granularity of

one second.

Fielding, et. al. Standards Track [Page 80]

RFC 2068 HTTP/1.1 January 1997

When a client tries to revalidate a cache entry, and the response it

receives contains a Date header that appears to be older than the one

for the existing entry, then the client SHOULD repeat the request

unconditionally, and include

Cache-Control: max-age=0

to force any intermediate caches to validate their copies directly

with the origin server, or

Cache-Control: no-cache

to force any intermediate caches to obtain a new copy from the origin

server.

If the Date values are equal, then the client may use either response

(or may, if it is being extremely prudent, request a new response).

Servers MUST NOT depend on clients being able to choose

deterministically between responses generated during the same second,

if their expiration times overlap.

13.3 Validation Model

When a cache has a stale entry that it would like to use as a

response to a client's request, it first has to check with the origin

server (or possibly an intermediate cache with a fresh response) to

see if its cached entry is still usable. We call this "validating"

the cache entry. Since we do not want to have to pay the overhead of

retransmitting the full response if the cached entry is good, and we

do not want to pay the overhead of an extra round trip if the cached

entry is invalid, the HTTP/1.1 protocol supports the use of

conditional methods.

The key protocol features for supporting conditional methods are

those concerned with "cache validators." When an origin server

generates a full response, it attaches some sort of validator to it,

which is kept with the cache entry. When a client (user agent or

proxy cache) makes a conditional request for a resource for which it

has a cache entry, it includes the associated validator in the

request.

The server then checks that validator against the current validator

for the entity, and, if they match, it responds with a special status

code (usually, 304 (Not Modified)) and no entity-body. Otherwise, it

returns a full response (including entity-body). Thus, we avoid

transmitting the full response if the validator matches, and we avoid

an extra round trip if it does not match.

Fielding, et. al. Standards Track [Page 81]

RFC 2068 HTTP/1.1 January 1997

Note: the comparison functions used to decide if validators match

are defined in section 13.3.3.

In HTTP/1.1, a conditional request looks exactly the same as a normal

request for the same resource, except that it carries a special

header (which includes the validator) that implicitly turns the

method (usually, GET) into a conditional.

The protocol includes both positive and negative senses of cache-

validating conditions. That is, it is possible to request either that

a method be performed if and only if a validator matches or if and

only if no validators match.

Note: a response that lacks a validator may still be cached, and

served from cache until it expires, unless this is explicitly

prohibited by a Cache-Control directive. However, a cache cannot do

a conditional retrieval if it does not have a validator for the

entity, which means it will not be refreshable after it expires.

13.3.1 Last-modified Dates

The Last-Modified entity-header field value is often used as a cache

validator. In simple terms, a cache entry is considered to be valid

if the entity has not been modified since the Last-Modified value.

13.3.2 Entity Tag Cache Validators

The ETag entity-header field value, an entity tag, provides for an

"opaque" cache validator. This may allow more reliable validation in

situations where it is inconvenient to store modification dates,

where the one-second resolution of HTTP date values is not

sufficient, or where the origin server wishes to avoid certain

paradoxes that may arise from the use of modification dates.

Entity Tags are described in section 3.11. The headers used with

entity tags are described in sections 14.20, 14.25, 14.26 and 14.43.

13.3.3 Weak and Strong Validators

Since both origin servers and caches will compare two validators to

decide if they represent the same or different entities, one normally

would expect that if the entity (the entity-body or any entity-

headers) changes in any way, then the associated validator would

change as well. If this is true, then we call this validator a

"strong validator."

However, there may be cases when a server prefers to change the

validator only on semantically significant changes, and not when

Fielding, et. al. Standards Track [Page 82]

RFC 2068 HTTP/1.1 January 1997

insignificant aspects of the entity change. A validator that does not

always change when the resource changes is a "weak validator."

Entity tags are normally "strong validators," but the protocol

provides a mechanism to tag an entity tag as "weak." One can think of

a strong validator as one that changes whenever the bits of an entity

changes, while a weak value changes whenever the meaning of an entity

changes. Alternatively, one can think of a strong validator as part

of an identifier for a specific entity, while a weak validator is

part of an identifier for a set of semantically equivalent entities.

Note: One example of a strong validator is an integer that is

incremented in stable storage every time an entity is changed.

An entity's modification time, if represented with one-second

resolution, could be a weak validator, since it is possible that

the resource may be modified twice during a single second.

Support for weak validators is optional; however, weak validators

allow for more efficient caching of equivalent objects; for

example, a hit counter on a site is probably good enough if it is

updated every few days or weeks, and any value during that period

is likely "good enough" to be equivalent.

A "use" of a validator is either when a client generates a request

and includes the validator in a validating header field, or when a

server compares two validators.

Strong validators are usable in any context. Weak validators are only

usable in contexts that do not depend on exact equality of an entity.

For example, either kind is usable for a conditional GET of a full

entity. However, only a strong validator is usable for a sub-range

retrieval, since otherwise the client may end up with an internally

inconsistent entity.

The only function that the HTTP/1.1 protocol defines on validators is

comparison. There are two validator comparison functions, depending

on whether the comparison context allows the use of weak validators

or not:

o The strong comparison function: in order to be considered equal,

both validators must be identical in every way, and neither may be

weak.

o The weak comparison function: in order to be considered equal, both

validators must be identical in every way, but either or both of

them may be tagged as "weak" without affecting the result.

The weak comparison function MAY be used for simple (non-subrange)

Fielding, et. al. Standards Track [Page 83]

RFC 2068 HTTP/1.1 January 1997

GET requests. The strong comparison function MUST be used in all

other cases.

An entity tag is strong unless it is explicitly tagged as weak.

Section 3.11 gives the syntax for entity tags.

A Last-Modified time, when used as a validator in a request, is

implicitly weak unless it is possible to deduce that it is strong,

using the following rules:

o The validator is being compared by an origin server to the actual

current validator for the entity and,

o That origin server reliably knows that the associated entity did

not change twice during the second covered by the presented

validator.

or

o The validator is about to be used by a client in an If-Modified-

Since or If-Unmodified-Since header, because the client has a cache

entry for the associated entity, and

o That cache entry includes a Date value, which gives the time when

the origin server sent the original response, and

o The presented Last-Modified time is at least 60 seconds before the

Date value.

or

o The validator is being compared by an intermediate cache to the

validator stored in its cache entry for the entity, and

o That cache entry includes a Date value, which gives the time when

the origin server sent the original response, and

o The presented Last-Modified time is at least 60 seconds before the

Date value.

This method relies on the fact that if two different responses were

sent by the origin server during the same second, but both had the

same Last-Modified time, then at least one of those responses would

have a Date value equal to its Last-Modified time. The arbitrary 60-

second limit guards against the possibility that the Date and Last-

Modified values are generated from different clocks, or at somewhat

different times during the preparation of the response. An

implementation may use a value larger than 60 seconds, if it is

believed that 60 seconds is too short.

If a client wishes to perform a sub-range retrieval on a value for

which it has only a Last-Modified time and no opaque validator, it

may do this only if the Last-Modified time is strong in the sense

described here.

Fielding, et. al. Standards Track [Page 84]

RFC 2068 HTTP/1.1 January 1997

A cache or origin server receiving a cache-conditional request, other

than a full-body GET request, MUST use the strong comparison function

to evaluate the condition.

These rules allow HTTP/1.1 caches and clients to safely perform sub-

range retrievals on values that have been obtained from HTTP/1.0

servers.

13.3.4 Rules for When to Use Entity Tags and Last-modified Dates

We adopt a set of rules and recommendations for origin servers,

clients, and caches regarding when various validator types should be

used, and for what purposes.

HTTP/1.1 origin servers:

o SHOULD send an entity tag validator unless it is not feasible to

generate one.

o MAY send a weak entity tag instead of a strong entity tag, if

performance considerations support the use of weak entity tags, or

if it is unfeasible to send a strong entity tag.

o SHOULD send a Last-Modified value if it is feasible to send one,

unless the risk of a breakdown in semantic transparency that could

result from using this date in an If-Modified-Since header would

lead to serious problems.

In other words, the preferred behavior for an HTTP/1.1 origin server

is to send both a strong entity tag and a Last-Modified value.

In order to be legal, a strong entity tag MUST change whenever the

associated entity value changes in any way. A weak entity tag SHOULD

change whenever the associated entity changes in a semantically

significant way.

Note: in order to provide semantically transparent caching, an

origin server must avoid reusing a specific strong entity tag value

for two different entities, or reusing a specific weak entity tag

value for two semantically different entities. Cache entries may

persist for arbitrarily long periods, regardless of expiration

times, so it may be inappropriate to expect that a cache will never

again attempt to validate an entry using a validator that it

obtained at some point in the past.

HTTP/1.1 clients:

o If an entity tag has been provided by the origin server, MUST

use that entity tag in any cache-conditional request (using

If-Match or If-None-Match).

谁翻译了别忘了给我发一份 xzjxu@126.com

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
2023年上半年GDP全球前十五强
 百态   2023-10-24
美众议院议长启动对拜登的弹劾调查
 百态   2023-09-13
上海、济南、武汉等多地出现不明坠落物
 探索   2023-09-06
印度或要将国名改为“巴拉特”
 百态   2023-09-06
男子为女友送行,买票不登机被捕
 百态   2023-08-20
手机地震预警功能怎么开?
 干货   2023-08-06
女子4年卖2套房花700多万做美容:不但没变美脸,面部还出现变形
 百态   2023-08-04
住户一楼被水淹 还冲来8头猪
 百态   2023-07-31
女子体内爬出大量瓜子状活虫
 百态   2023-07-25
地球连续35年收到神秘规律性信号,网友:不要回答!
 探索   2023-07-21
全球镓价格本周大涨27%
 探索   2023-07-09
钱都流向了那些不缺钱的人,苦都留给了能吃苦的人
 探索   2023-07-02
倩女手游刀客魅者强控制(强混乱强眩晕强睡眠)和对应控制抗性的关系
 百态   2020-08-20
美国5月9日最新疫情:美国确诊人数突破131万
 百态   2020-05-09
荷兰政府宣布将集体辞职
 干货   2020-04-30
倩女幽魂手游师徒任务情义春秋猜成语答案逍遥观:鹏程万里
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案神机营:射石饮羽
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案昆仑山:拔刀相助
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案天工阁:鬼斧神工
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案丝路古道:单枪匹马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:与虎谋皮
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:李代桃僵
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案镇郊荒野:指鹿为马
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:小鸟依人
 干货   2019-11-12
倩女幽魂手游师徒任务情义春秋猜成语答案金陵:千金买邻
 干货   2019-11-12
 
推荐阅读
 
 
 
>>返回首頁<<
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有