[thirdparty/squid.git] / src / http / StatusCode.cc

/*
 * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */

#include "squid.h"
#include "Debug.h"
#include "http/StatusCode.h"

const char *
Http::StatusCodeString(const Http::StatusCode status)
{
    switch (status) {

        // 000
    case Http::scNone:
        return "Init";		/* we init .status with code 0 */
        break;

        // 100-199
    case Http::scContinue:
        return "Continue";
        break;

    case Http::scSwitchingProtocols:
        return "Switching Protocols";
        break;

    case Http::scProcessing:
        return "Processing";
        break;

        // 200-299
    case Http::scOkay:
        return "OK";
        break;

    case Http::scCreated:
        return "Created";
        break;

    case Http::scAccepted:
        return "Accepted";
        break;

    case Http::scNonAuthoritativeInformation:
        return "Non-Authoritative Information";
        break;

    case Http::scNoContent:
        return "No Content";
        break;

    case Http::scResetContent:
        return "Reset Content";
        break;

    case Http::scPartialContent:
        return "Partial Content";
        break;

    case Http::scMultiStatus:
        return "Multi-Status";
        break;

    case Http::scAlreadyReported:
        return "Already Reported";
        break;

    case Http::scImUsed:
        return "IM Used";
        break;

        // 300-399
    case Http::scMultipleChoices:
        return "Multiple Choices";
        break;

    case Http::scMovedPermanently:
        return "Moved Permanently";
        break;

    case Http::scFound:
        return "Found";
        break;

    case Http::scSeeOther:
        return "See Other";
        break;

    case Http::scNotModified:
        return "Not Modified";
        break;

    case Http::scUseProxy:
        return "Use Proxy";
        break;

    case Http::scTemporaryRedirect:
        return "Temporary Redirect";
        break;

    case Http::scPermanentRedirect:
        return "Permanent Redirect";
        break;

        // 400-499
    case Http::scBadRequest:
        return "Bad Request";
        break;

    case Http::scUnauthorized:
        return "Unauthorized";
        break;

    case Http::scPaymentRequired:
        return "Payment Required";
        break;

    case Http::scForbidden:
        return "Forbidden";
        break;

    case Http::scNotFound:
        return "Not Found";
        break;

    case Http::scMethodNotAllowed:
        return "Method Not Allowed";
        break;

    case Http::scNotAcceptable:
        return "Not Acceptable";
        break;

    case Http::scProxyAuthenticationRequired:
        return "Proxy Authentication Required";
        break;

    case Http::scRequestTimeout:
        return "Request Timeout";
        break;

    case Http::scConflict:
        return "Conflict";
        break;

    case Http::scGone:
        return "Gone";
        break;

    case Http::scLengthRequired:
        return "Length Required";
        break;

    case Http::scPreconditionFailed:
        return "Precondition Failed";
        break;

    case Http::scPayloadTooLarge:
        return "Payload Too Large";
        break;

    case Http::scUriTooLong:
        return "URI Too Long";
        break;

    case Http::scUnsupportedMediaType:
        return "Unsupported Media Type";
        break;

    case Http::scRequestedRangeNotSatisfied:
        return "Requested Range Not Satisfiable";
        break;

    case Http::scExpectationFailed:
        return "Expectation Failed";
        break;

    case Http::scUnprocessableEntity:
        return "Unprocessable Entity";
        break;

    case Http::scLocked:
        return "Locked";
        break;

    case Http::scFailedDependency:
        return "Failed Dependency";
        break;

    case Http::scUpgradeRequired:
        return "Upgrade Required";
        break;

    case Http::scPreconditionRequired:
        return "Precondition Required";
        break;

    case Http::scTooManyRequests:
        return "Too Many Requests";
        break;

    case Http::scRequestHeaderFieldsTooLarge:
        return "Request Header Fields Too Large";
        break;

        // 500-599
    case Http::scInternalServerError:
        return "Internal Server Error";
        break;

    case Http::scNotImplemented:
        return "Not Implemented";
        break;

    case Http::scBadGateway:
        return "Bad Gateway";
        break;

    case Http::scServiceUnavailable:
        return "Service Unavailable";
        break;

    case Http::scGatewayTimeout:
        return "Gateway Timeout";
        break;

    case Http::scHttpVersionNotSupported:
        return "HTTP Version not supported";
        break;

    case Http::scVariantAlsoNegotiates:
        return "Variant Also Negotiates";
        break;

    case Http::scInsufficientStorage:
        return "Insufficient Storage";
        break;

    case Http::scLoopDetected:
        return "Loop Detected";
        break;

    case Http::scNotExtended:
        return "Not Extended";
        break;

    case Http::scNetworkAuthenticationRequired:
        return "Network Authentication Required";
        break;

        // 600+
    case Http::scInvalidHeader:
    case Http::scHeaderTooLarge:
        // fall through to default.

    default:
        debugs(57, 3, "Unassigned HTTP status code: " << status);
    }
    return "Unassigned";
}
Commit	Line	Data
bbc27441 AJ	1	/*
	2	* Copyright (C) 1996-2014 The Squid Software Foundation and contributors
	3	*
	4	* Squid software is distributed under GPLv2+ license and includes
	5	* contributions from numerous individuals and organizations.
	6	* Please see the COPYING and CONTRIBUTORS files for details.
	7	*/
	8
9b769c67 AJ	9	#include "squid.h"
	10	#include "Debug.h"
	11	#include "http/StatusCode.h"
	12
	13	const char *
	14	Http::StatusCodeString(const Http::StatusCode status)
	15	{
	16	switch (status) {
	17
e2849af8	18	// 000
9b769c67 AJ	19	case Http::scNone:
	20	return "Init"; /* we init .status with code 0 */
	21	break;
	22
e2849af8	23	// 100-199
9b769c67 AJ	24	case Http::scContinue:
	25	return "Continue";
	26	break;
	27
	28	case Http::scSwitchingProtocols:
	29	return "Switching Protocols";
	30	break;
	31
f11c8e2f AJ	32	case Http::scProcessing:
	33	return "Processing";
	34	break;
	35
e2849af8	36	// 200-299
9b769c67 AJ	37	case Http::scOkay:
	38	return "OK";
	39	break;
	40
	41	case Http::scCreated:
	42	return "Created";
	43	break;
	44
	45	case Http::scAccepted:
	46	return "Accepted";
	47	break;
	48
	49	case Http::scNonAuthoritativeInformation:
	50	return "Non-Authoritative Information";
	51	break;
	52
	53	case Http::scNoContent:
	54	return "No Content";
	55	break;
	56
	57	case Http::scResetContent:
	58	return "Reset Content";
	59	break;
	60
	61	case Http::scPartialContent:
	62	return "Partial Content";
	63	break;
	64
	65	case Http::scMultiStatus:
	66	return "Multi-Status";
	67	break;
	68
f11c8e2f AJ	69	case Http::scAlreadyReported:
	70	return "Already Reported";
	71	break;
	72
	73	case Http::scImUsed:
	74	return "IM Used";
	75	break;
	76
e2849af8	77	// 300-399
9b769c67 AJ	78	case Http::scMultipleChoices:
	79	return "Multiple Choices";
	80	break;
	81
	82	case Http::scMovedPermanently:
	83	return "Moved Permanently";
	84	break;
	85
f11c8e2f AJ	86	case Http::scFound:
f11c8e2f AJ	87	return "Found";
9b769c67 AJ	88	break;
	89
	90	case Http::scSeeOther:
	91	return "See Other";
	92	break;
	93
	94	case Http::scNotModified:
	95	return "Not Modified";
	96	break;
	97
	98	case Http::scUseProxy:
	99	return "Use Proxy";
	100	break;
	101
	102	case Http::scTemporaryRedirect:
	103	return "Temporary Redirect";
	104	break;
	105
	106	case Http::scPermanentRedirect:
	107	return "Permanent Redirect";
	108	break;
	109
e2849af8	110	// 400-499
9b769c67 AJ	111	case Http::scBadRequest:
	112	return "Bad Request";
	113	break;
	114
	115	case Http::scUnauthorized:
	116	return "Unauthorized";
	117	break;
	118
	119	case Http::scPaymentRequired:
	120	return "Payment Required";
	121	break;
	122
	123	case Http::scForbidden:
	124	return "Forbidden";
	125	break;
	126
	127	case Http::scNotFound:
	128	return "Not Found";
	129	break;
	130
	131	case Http::scMethodNotAllowed:
	132	return "Method Not Allowed";
	133	break;
	134
	135	case Http::scNotAcceptable:
	136	return "Not Acceptable";
	137	break;
	138
	139	case Http::scProxyAuthenticationRequired:
	140	return "Proxy Authentication Required";
	141	break;
	142
	143	case Http::scRequestTimeout:
f11c8e2f	144	return "Request Timeout";
9b769c67 AJ	145	break;
	146
	147	case Http::scConflict:
	148	return "Conflict";
	149	break;
	150
	151	case Http::scGone:
	152	return "Gone";
	153	break;
	154
	155	case Http::scLengthRequired:
	156	return "Length Required";
	157	break;
	158
	159	case Http::scPreconditionFailed:
	160	return "Precondition Failed";
	161	break;
	162
f11c8e2f AJ	163	case Http::scPayloadTooLarge:
f11c8e2f AJ	164	return "Payload Too Large";
9b769c67 AJ	165	break;
9b769c67 AJ	166
f11c8e2f AJ	167	case Http::scUriTooLong:
f11c8e2f AJ	168	return "URI Too Long";
9b769c67 AJ	169	break;
	170
	171	case Http::scUnsupportedMediaType:
	172	return "Unsupported Media Type";
	173	break;
	174
	175	case Http::scRequestedRangeNotSatisfied:
	176	return "Requested Range Not Satisfiable";
	177	break;
	178
	179	case Http::scExpectationFailed:
	180	return "Expectation Failed";
	181	break;
	182
f11c8e2f AJ	183	case Http::scUnprocessableEntity:
	184	return "Unprocessable Entity";
	185	break;
	186
	187	case Http::scLocked:
	188	return "Locked";
	189	break;
	190
	191	case Http::scFailedDependency:
	192	return "Failed Dependency";
	193	break;
	194
	195	case Http::scUpgradeRequired:
	196	return "Upgrade Required";
	197	break;
	198
	199	case Http::scPreconditionRequired:
	200	return "Precondition Required";
	201	break;
	202
	203	case Http::scTooManyRequests:
	204	return "Too Many Requests";
	205	break;
	206
	207	case Http::scRequestHeaderFieldsTooLarge:
	208	return "Request Header Fields Too Large";
	209	break;
	210
e2849af8	211	// 500-599
9b769c67 AJ	212	case Http::scInternalServerError:
	213	return "Internal Server Error";
	214	break;
	215
	216	case Http::scNotImplemented:
	217	return "Not Implemented";
	218	break;
	219
	220	case Http::scBadGateway:
	221	return "Bad Gateway";
	222	break;
	223
	224	case Http::scServiceUnavailable:
	225	return "Service Unavailable";
	226	break;
	227
f11c8e2f AJ	228	case Http::scGatewayTimeout:
f11c8e2f AJ	229	return "Gateway Timeout";
9b769c67 AJ	230	break;
	231
	232	case Http::scHttpVersionNotSupported:
	233	return "HTTP Version not supported";
	234	break;
	235
f11c8e2f AJ	236	case Http::scVariantAlsoNegotiates:
f11c8e2f AJ	237	return "Variant Also Negotiates";
9b769c67 AJ	238	break;
9b769c67 AJ	239
f11c8e2f AJ	240	case Http::scInsufficientStorage:
f11c8e2f AJ	241	return "Insufficient Storage";
9b769c67 AJ	242	break;
9b769c67 AJ	243
f11c8e2f AJ	244	case Http::scLoopDetected:
f11c8e2f AJ	245	return "Loop Detected";
9b769c67 AJ	246	break;
9b769c67 AJ	247
f11c8e2f AJ	248	case Http::scNotExtended:
	249	return "Not Extended";
	250	break;
	251
	252	case Http::scNetworkAuthenticationRequired:
9b769c67 AJ	253	return "Network Authentication Required";
	254	break;
	255
e2849af8	256	// 600+
f11c8e2f AJ	257	case Http::scInvalidHeader:
	258	case Http::scHeaderTooLarge:
	259	// fall through to default.
	260
9b769c67	261	default:
f11c8e2f	262	debugs(57, 3, "Unassigned HTTP status code: " << status);
9b769c67	263	}
f11c8e2f	264	return "Unassigned";
9b769c67	265	}