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

/*
 * Copyright (C) 1996-2020 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;

    case Http::scEarlyHints: // 103
        return "Early Hints";
        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::scMisdirectedRequest:
        return "Misdirected Request";
        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;

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