]> git.pld-linux.org Git - packages/squid.git/blame - squid-2.5.STABLE2-reply_body_max_size.patch
projects / packages / squid.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- fix for small memory leak in squid, more info on
[packages/squid.git] / squid-2.5.STABLE2-reply_body_max_size.patch
CommitLineData
992dce4c
MW		 1Index: squid/src/HttpReply.c
2diff -c squid/src/HttpReply.c:1.49 squid/src/HttpReply.c:1.49.2.1
3*** squid/src/HttpReply.c:1.49 Wed Oct 24 02:19:08 2001
4--- squid/src/HttpReply.c Tue May 6 14:13:02 2003
5***************
6*** 82,88 ****
7 {
8 assert(rep);
9 rep->hdr_sz = 0;
10- rep->maxBodySize = 0;
11 rep->pstate = psReadyToParseStartLine;
12 httpBodyInit(&rep->body);
13 httpHeaderInit(&rep->header, hoReply);
14--- 82,87 ----
15***************
16*** 463,491 ****
17 else if (reply->sline.status < HTTP_OK)
18 return 0;
19 return reply->content_length;
20- }
21-
22- /*
23- * Calculates the maximum size allowed for an HTTP response
24- */
25- void
26- httpReplyBodyBuildSize(request_t * request, HttpReply * reply, dlink_list * bodylist)
27- {
28- body_size *bs;
29- aclCheck_t *checklist;
30- bs = (body_size *) bodylist->head;
31- while (bs) {
32- checklist = aclChecklistCreate(bs->access_list, request, NULL);
33- checklist->reply = reply;
34- if (1 != aclCheckFast(bs->access_list, checklist)) {
35- /* deny - skip this entry */
36- bs = (body_size *) bs->node.next;
37- } else {
38- /* Allow - use this entry */
39- reply->maxBodySize = bs->maxsize;
40- bs = NULL;
41- debug(58, 3) ("httpReplyBodyBuildSize: Setting maxBodySize to %ld\n", (long int) reply->maxBodySize);
42- }
43- aclChecklistFree(checklist);
44- }
45 }
46--- 462,465 ----
47Index: squid/src/client_side.c
48diff -c squid/src/client_side.c:1.561.2.33 squid/src/client_side.c:1.561.2.34
49*** squid/src/client_side.c:1.561.2.33 Wed Feb 19 16:39:12 2003
50--- squid/src/client_side.c Tue May 6 14:13:02 2003
51***************
52*** 124,130 ****
53 static int clientCheckContentLength(request_t * r);
54 static DEFER httpAcceptDefer;
55 static log_type clientProcessRequest2(clientHttpRequest * http);
56! static int clientReplyBodyTooLarge(HttpReply *, ssize_t clen);
57 static int clientRequestBodyTooLarge(int clen);
58 static void clientProcessBody(ConnStateData * conn);
59
60--- 124,130 ----
61 static int clientCheckContentLength(request_t * r);
62 static DEFER httpAcceptDefer;
63 static log_type clientProcessRequest2(clientHttpRequest * http);
64! static int clientReplyBodyTooLarge(clientHttpRequest *, ssize_t clen);
65 static int clientRequestBodyTooLarge(int clen);
66 static void clientProcessBody(ConnStateData * conn);
67
68***************
69*** 1806,1819 ****
70 return i->debt_size > 0;
71 }
72
73 static int
74! clientReplyBodyTooLarge(HttpReply * rep, ssize_t clen)
75 {
76! if (0 == rep->maxBodySize)
77 return 0; /* disabled */
78 if (clen < 0)
79 return 0; /* unknown */
80! if (clen > rep->maxBodySize)
81 return 1; /* too large */
82 return 0;
83 }
84--- 1806,1844 ----
85 return i->debt_size > 0;
86 }
87
88+ /*
89+ * Calculates the maximum size allowed for an HTTP response
90+ */
91+ static void
92+ clientMaxBodySize(request_t * request, clientHttpRequest * http, HttpReply * reply)
93+ {
94+ body_size *bs;
95+ aclCheck_t *checklist;
96+ bs = (body_size *) Config.ReplyBodySize.head;
97+ while (bs) {
98+ checklist = clientAclChecklistCreate(bs->access_list, http);
99+ checklist->reply = reply;
100+ if (1 != aclCheckFast(bs->access_list, checklist)) {
101+ /* deny - skip this entry */
102+ bs = (body_size *) bs->node.next;
103+ } else {
104+ /* Allow - use this entry */
105+ http->maxBodySize = bs->maxsize;
106+ bs = NULL;
107+ debug(58, 3) ("httpReplyBodyBuildSize: Setting maxBodySize to %ld\n", (long int) http->maxBodySize);
108+ }
109+ aclChecklistFree(checklist);
110+ }
111+ }
112+
113 static int
114! clientReplyBodyTooLarge(clientHttpRequest * http, ssize_t clen)
115 {
116! if (0 == http->maxBodySize)
117 return 0; /* disabled */
118 if (clen < 0)
119 return 0; /* unknown */
120! if (clen > http->maxBodySize)
121 return 1; /* too large */
122 return 0;
123 }
124***************
125*** 1857,1863 ****
126 }
127 }
128
129-
130 /*
131 * accepts chunk of a http message in buf, parses prefix, filters headers and
132 * such, writes processed message to the client's socket
133--- 1882,1887 ----
134***************
135*** 1918,1925 ****
136 if (rep) {
137 aclCheck_t *ch;
138 int rv;
139! httpReplyBodyBuildSize(http->request, rep, &Config.ReplyBodySize);
140! if (clientReplyBodyTooLarge(rep, rep->content_length)) {
141 ErrorState *err = errorCon(ERR_TOO_BIG, HTTP_FORBIDDEN);
142 err->request = requestLink(http->request);
143 storeUnregister(http->sc, http->entry, http);
144--- 1942,1949 ----
145 if (rep) {
146 aclCheck_t *ch;
147 int rv;
148! clientMaxBodySize(http->request, http, rep);
149! if (clientReplyBodyTooLarge(http, rep->content_length)) {
150 ErrorState *err = errorCon(ERR_TOO_BIG, HTTP_FORBIDDEN);
151 err->request = requestLink(http->request);
152 storeUnregister(http->sc, http->entry, http);
153***************
154*** 2172,2178 ****
155 } else {
156 comm_close(fd);
157 }
158! } else if (clientReplyBodyTooLarge(entry->mem_obj->reply, http->out.offset)) {
159 comm_close(fd);
160 } else {
161 /* More data will be coming from primary server; register with
162--- 2196,2203 ----
163 } else {
164 comm_close(fd);
165 }
166! } else if (clientReplyBodyTooLarge(http, http->out.offset - 4096)) {
167! /* 4096 is a margin for the HTTP headers included in out.offset */
168 comm_close(fd);
169 } else {
170 /* More data will be coming from primary server; register with
171Index: squid/src/protos.h
172diff -c squid/src/protos.h:1.420.2.17 squid/src/protos.h:1.420.2.18
173*** squid/src/protos.h:1.420.2.17 Thu Jan 2 16:10:46 2003
174--- squid/src/protos.h Tue May 6 14:13:02 2003
175***************
176*** 509,515 ****
177 extern int httpReplyHasCc(const HttpReply * rep, http_hdr_cc_type type);
178 extern void httpRedirectReply(HttpReply *, http_status, const char *);
179 extern int httpReplyBodySize(method_t, HttpReply *);
180- extern void httpReplyBodyBuildSize(request_t *, HttpReply *, dlink_list *);
181
182 /* Http Request */
183 extern request_t *requestCreate(method_t, protocol_t, const char *urlpath);
184--- 509,514 ----
185Index: squid/src/structs.h
186diff -c squid/src/structs.h:1.408.2.9 squid/src/structs.h:1.408.2.10
187*** squid/src/structs.h:1.408.2.9 Mon Jan 20 17:06:39 2003
188--- squid/src/structs.h Tue May 6 14:13:03 2003
189***************
190*** 959,965 ****
191 HttpStatusLine sline;
192 HttpHeader header;
193 HttpBody body; /* for small constant memory-resident text bodies only */
194- size_t maxBodySize;
195 };
196
197 struct _http_state_flags {
198--- 959,964 ----
199***************
200*** 1083,1088 ****
201--- 1082,1088 ----
202 char *location;
203 } redirect;
204 dlink_node active;
205+ size_t maxBodySize;
206 };
207
208 struct _ConnStateData {
SQUID Internet Object Cache
This page took 0.112729 seconds and 4 git commands to generate.