Changeset 869

Timestamp:

07/31/07 10:52:00 (1 year ago)

Author:

adefacc

Message:

handler_*.c, space / code style cleanups

Files:

cherokee/trunk/ChangeLog (modified) (1 diff)
cherokee/trunk/cherokee/handler_cgi.c (modified) (4 diffs)
cherokee/trunk/cherokee/handler_cgi_base.c (modified) (10 diffs)
cherokee/trunk/cherokee/handler_common.c (modified) (1 diff)
cherokee/trunk/cherokee/handler_dirlist.c (modified) (6 diffs)
cherokee/trunk/cherokee/handler_error.c (modified) (1 diff)
cherokee/trunk/cherokee/handler_error_redir.c (modified) (3 diffs)
cherokee/trunk/cherokee/handler_fastcgi.c (modified) (25 diffs)
cherokee/trunk/cherokee/handler_fcgi.c (modified) (13 diffs)
cherokee/trunk/cherokee/handler_file.c (modified) (4 diffs)
cherokee/trunk/cherokee/handler_mirror.c (modified) (2 diffs)
cherokee/trunk/cherokee/handler_nn.c (modified) (3 diffs)
cherokee/trunk/cherokee/handler_phpcgi.c (modified) (2 diffs)
cherokee/trunk/cherokee/handler_proxy.c (modified) (9 diffs)
cherokee/trunk/cherokee/handler_redir.c (modified) (2 diffs)
cherokee/trunk/cherokee/handler_scgi.c (modified) (2 diffs)
cherokee/trunk/cherokee/handler_webcam.c (modified) (6 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

cherokee/trunk/ChangeLog

r868	r869
	1	2007-07-31 A.D.F <adefacc@tin.it>
	2
	3	* cherokee/handler_*.c
	4	- space / indentation / code style cleanups.
	5
1	6	2007-07-30 A.D.F <adefacc@tin.it>
2	7

cherokee/trunk/cherokee/handler_cgi.c

r784	r869
171	171	/* Reap defunct children until there aren't any more.
172	172	*/
173		for (child_count = 0; ; ++child_count)
174		{
	173	for (child_count = 0; ; ++child_count) {
	174
175	175	pid = waitpid (-1, &status, WNOHANG);
176	176
177		/* none left */
178		if (pid == 0) break;
179
180		else if (pid < 0) {
	177	/* none left */
	178	if (pid == 0)
	179	break;
	180	else
	181	if (pid < 0) {
181	182	/* because of ptrace */
182		if (errno == EINTR) continue;
	183	if (errno == EINTR)
	184	continue;
183	185	break;
184	186	}
185		}
	187	}
186	188	#endif
187	189
…	…
276	278
277	279	cherokee_handler_cgi_base_props_init_base (PROP_CGI_BASE(n),
278		MODULE_PROPS_FREE(cherokee_handler_cgi_props_free));
	280	MODULE_PROPS_FREE(cherokee_handler_cgi_props_free));
279	281	*_props = MODULE_PROPS(n);
280	282	}
…	…
304	306	*/
305	307	entry = (char *) malloc (name_len + content_len + 2);
306		if (entry == NULL) return;
	308	if (entry == NULL)
	309	return;
307	310
308	311	memcpy (entry, name, name_len);
…	…
334	337
335	338	ret = cherokee_handler_cgi_base_build_envp (HDL_CGI_BASE(cgi), conn);
336		if (unlikely (ret != ret_ok)) return ret;
	339	if (unlikely (ret != ret_ok))
	340	return ret;
337	341
338	342	/* CONTENT_LENGTH

cherokee/trunk/cherokee/handler_cgi_base.c

r799	r869
62	62	*/
63	63	ret = cherokee_connection_parse_args (conn);
64		if (unlikely(ret < ret_ok)) return ret;
	64	if (unlikely(ret < ret_ok))
	65	return ret;
65	66
66	67	/* Init to default values
…	…
151	152	cherokee_handler_cgi_base_props_t *props;
152	153
153		/* Sanity check: This class is pure virtual, it shouldn't allocate memory here.
154		* Check that the object space has been already instanced by it father.
	154	/* Sanity check: This class is pure virtual,
	155	* it shouldn't allocate memory here.
	156	* Check that the object space has been already instanced by its father.
155	157	*/
156	158	if (*_props == NULL) {
…	…
178	180	if (equal_buf_str (&subconf->key, "script_alias")) {
179	181	ret = cherokee_buffer_add_buffer (&props->script_alias, &subconf->val);
180		if (ret != ret_ok) return ret;
	182	if (ret != ret_ok)
	183	return ret;
181	184
182	185	} else if (equal_buf_str (&subconf->key, "env")) {
…	…
186	189
187	190	env = env_item_new (&subconf2->key, &subconf2->val);
188		if (env == NULL) return ret_error;
	191	if (env == NULL)
	192	return ret_error;
189	193
190	194	cherokee_list_add_tail (LIST(env), &props->system_env);
…	…
237	241
238	242	root = getenv("SYSTEMROOT");
239		if (!root) return;
	243	if (!root)
	244	return;
240	245
241	246	set_env (cgi, "SYSTEMROOT", root, strlen(root));
…	…
245	250
246	251	ret_t
247		cherokee_handler_cgi_base_build_basic_env (cherokee_handler_cgi_base_t *cgi,
248		cherokee_handler_cgi_base_add_env_pair_t set_env_pair,
249		cherokee_connection_t *conn,
250		cherokee_buffer_t *tmp)
	252	cherokee_handler_cgi_base_build_basic_env (
	253	cherokee_handler_cgi_base_t *cgi,
	254	cherokee_handler_cgi_base_add_env_pair_t set_env_pair,
	255	cherokee_connection_t *conn,
	256	cherokee_buffer_t *tmp)
251	257	{
252	258	int re;
…	…
528	534	cherokee_buffer_clean (&tmp);
529	535
530		if (cgi_props->check_file &&
531		(conn->web_directory.len > 1))
532		{
	536	if (cgi_props->check_file && (conn->web_directory.len > 1)) {
533	537	cherokee_buffer_add_buffer (&tmp, &conn->web_directory);
534	538	}
…	…
689	693	*/
690	694	if ((buffer->len > 4) &&
691		(strncmp (CRLF_CRLF, buffer->buf + buffer->len - 4, 4) == 0))
692		{
	695	(strncmp (CRLF_CRLF, buffer->buf + buffer->len - 4, 4) == 0)) {
693	696	cherokee_buffer_drop_endding (buffer, 2);
694	697	}
…	…
705	708
706	709	end2 = end;
707		while (((end2 == CHR_CR) \|\| (end2 == CHR_LF)) && (*end2 != '\0')) end2++;
	710	while (((end2 == CHR_CR) \|\| (end2 == CHR_LF)) && (*end2 != '\0'))
	711	end2++;
708	712
709	713	if (strncasecmp ("Status: ", begin, 8) == 0) {
…	…
854	858	*/
855	859	ret = cherokee_split_pathinfo (buf, init_pos, allow_dirs, &pathinfo, &pathinfo_len);
856		if (ret == ret_not_found) return ret;
	860	if (ret == ret_not_found)
	861	return ret;
857	862
858	863	/* Split the string

cherokee/trunk/cherokee/handler_common.c

r857	r869
76	76
77	77	cherokee_handler_props_init_base (HANDLER_PROPS(n),
78		MODULE_PROPS_FREE(cherokee_handler_common_props_free));
	78	MODULE_PROPS_FREE(cherokee_handler_common_props_free));
79	79
80	80	n->props_file = NULL;

cherokee/trunk/cherokee/handler_dirlist.c

r857	r869
95	95
96	96	begin = strstr (buf->buf, token.buf);
97		if (begin == NULL) goto error;
	97	if (begin == NULL)
	98	goto error;
98	99
99	100	end = strstr (begin, "%fi%");
100		if (end == NULL) goto error;
	101	if (end == NULL)
	102	goto error;
101	103
102	104	if (show) {
…	…
179	181
180	182	cherokee_handler_props_init_base (HANDLER_PROPS(n),
181		MODULE_PROPS_FREE(cherokee_handler_dirlist_props_free));
	183	MODULE_PROPS_FREE(cherokee_handler_dirlist_props_free));
182	184
183	185	n->show_size = true;
…	…
245	247	cherokee_list_t *i;
246	248
247		list_for_each (i, &HDL_DIRLIST_PROP(dhdl)->notice_files)
248		{
	249	list_for_each (i, &HDL_DIRLIST_PROP(dhdl)->notice_files) {
249	250	if (strcmp (filename, LIST_ITEM_INFO(i)) == 0)
250	251	return true;
…	…
294	295	(name[0] == '#') \|\|
295	296	(name[n->name_len-1] == '~') \|\|
296		is_header_file (dhdl, name))
297		{
	297	is_header_file (dhdl, name)) {
298	298	continue;
299	299	}
…	…
428	428
429	429	if ((cherokee_buffer_is_empty (&conn->request)) \|\|
430		(!cherokee_buffer_is_endding (&conn->request, '/')))
431		{
	430	(!cherokee_buffer_is_endding (&conn->request, '/'))) {
	431
432	432	cherokee_buffer_clean (&conn->redirect);
433	433	cherokee_buffer_ensure_size (&conn->redirect, conn->request.len + conn->userdir.len + 4);
…	…
479	479
480	480	diff = f1->stat.st_mtime - f2->stat.st_mtime;
481		if (diff == 0) cmp_name_down (a,b);
	481	if (diff == 0)
	482	cmp_name_down (a,b);
482	483
483	484	return diff;

cherokee/trunk/cherokee/handler_error.c

r855 r869

286 286 }
287 287
288

cherokee/trunk/cherokee/handler_error_redir.c

r597	r869
80	80	if (!http_type_300 (error) &&
81	81	!http_type_400 (error) &&
82		!http_type_500 (error))
83		{
	82	!http_type_500 (error)) {
84	83	PRINT_ERROR ("ERROR: error_redir: Wrong error code: '%s'\n", subconf->key.buf);
85	84	continue;
…	…
87	86
88	87	entry = (error_entry_t *) malloc (sizeof(error_entry_t));
89		if (entry == NULL) return ret_nomem;
	88	if (entry == NULL)
	89	return ret_nomem;
90	90
91	91	INIT_LIST_HEAD (&entry->entry);
…	…
141	141
142	142	PLUGIN_INFO_HANDLER_EASY_INIT (error_redir, http_all_methods);
	143

cherokee/trunk/cherokee/handler_fastcgi.c

r864	r869
92	92	if (equal_buf_str (&subconf->key, "balancer")) {
93	93	ret = cherokee_balancer_instance (&subconf->val, subconf, srv, &props->balancer);
94		if (ret != ret_ok) return ret;
	94	if (ret != ret_ok)
	95	return ret;
95	96
96	97	} else if (equal_buf_str (&subconf->key, "fcgi_env")) {
…	…
98	99	cherokee_config_node_t *subconf2 = CONFIG_NODE(j);
99	100
100		// TODO : implemet this
	101	// TODO : implement this
101	102	subconf2 = subconf2;
102	103	}
…	…
119	120	fcgi_build_header (FCGI_Header *hdr, cuchar_t type, cushort_t request_id, cuint_t content_length, cuchar_t padding)
120	121	{
121		hdr->version = FCGI_VERSION_1;
122		hdr->type = type;
123		hdr->requestIdB0 = (cuchar_t) request_id;
124		hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
125		hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
126		hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
127		hdr->paddingLength = padding;
128		hdr->reserved = 0;
	122	hdr->version = FCGI_VERSION_1;
	123	hdr->type = type;
	124	hdr->requestIdB0 = (cuchar_t) request_id;
	125	hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
	126	hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
	127	hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
	128	hdr->paddingLength = padding;
	129	hdr->reserved = 0;
129	130	}
130	131
…	…
132	133	fcgi_build_request_body (FCGI_BeginRequestRecord *request)
133	134	{
134		request->body.roleB0 = FCGI_RESPONDER;
135		request->body.roleB1 = 0;
136		request->body.flags = FCGI_KEEP_CONN;
137		request->body.reserved[0] = 0;
138		request->body.reserved[1] = 0;
139		request->body.reserved[2] = 0;
140		request->body.reserved[3] = 0;
141		request->body.reserved[4] = 0;
	135	request->body.roleB0 = FCGI_RESPONDER;
	136	request->body.roleB1 = 0;
	137	request->body.flags = FCGI_KEEP_CONN;
	138	request->body.reserved[0] = 0;
	139	request->body.reserved[1] = 0;
	140	request->body.reserved[2] = 0;
	141	request->body.reserved[3] = 0;
	142	request->body.reserved[4] = 0;
142	143	}
143	144
…	…
147	148	char *val, int val_len)
148	149	{
149		int len;
150		FCGI_BeginRequestRecord request;
	150	int len;
	151	FCGI_BeginRequestRecord request;
151	152	cherokee_handler_fastcgi_t *hdl = HDL_FASTCGI(cgi_base);
152	153	cherokee_buffer_t *buf = &hdl->write_buffer;
153	154
154		len = key_len + val_len;
155		len += key_len > 127 ? 4 : 1;
156		len += val_len > 127 ? 4 : 1;
157
158		fcgi_build_header (&request.header, FCGI_PARAMS, hdl->id, len, 0);
159
160		cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len);
161		cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header));
162
163		if (key_len <= 127) {
164		buf->buf[buf->len++] = key_len;
165		} else {
166		buf->buf[buf->len++] = ((key_len >> 24) & 0xff) \| 0x80;
167		buf->buf[buf->len++] = (key_len >> 16) & 0xff;
168		buf->buf[buf->len++] = (key_len >> 8) & 0xff;
169		buf->buf[buf->len++] = (key_len >> 0) & 0xff;
170		}
171
172		if (val_len <= 127) {
173		buf->buf[buf->len++] = val_len;
174		} else {
175		buf->buf[buf->len++] = ((val_len >> 24) & 0xff) \| 0x80;
176		buf->buf[buf->len++] = (val_len >> 16) & 0xff;
177		buf->buf[buf->len++] = (val_len >> 8) & 0xff;
178		buf->buf[buf->len++] = (val_len >> 0) & 0xff;
179		}
180
181		cherokee_buffer_add (buf, key, key_len);
182		cherokee_buffer_add (buf, val, val_len);
	155	len = key_len + val_len;
	156	len += key_len > 127 ? 4 : 1;
	157	len += val_len > 127 ? 4 : 1;
	158
	159	fcgi_build_header (&request.header, FCGI_PARAMS, hdl->id, len, 0);
	160
	161	cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len);
	162	cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header));
	163
	164	if (key_len <= 127) {
	165	buf->buf[buf->len++] = key_len;
	166	} else {
	167	buf->buf[buf->len++] = ((key_len >> 24) & 0xff) \| 0x80;
	168	buf->buf[buf->len++] = (key_len >> 16) & 0xff;
	169	buf->buf[buf->len++] = (key_len >> 8) & 0xff;
	170	buf->buf[buf->len++] = (key_len >> 0) & 0xff;
	171	}
	172
	173	if (val_len <= 127) {
	174	buf->buf[buf->len++] = val_len;
	175	} else {
	176	buf->buf[buf->len++] = ((val_len >> 24) & 0xff) \| 0x80;
	177	buf->buf[buf->len++] = (val_len >> 16) & 0xff;
	178	buf->buf[buf->len++] = (val_len >> 8) & 0xff;
	179	buf->buf[buf->len++] = (val_len >> 0) & 0xff;
	180	}
	181
	182	cherokee_buffer_add (buf, key, key_len);
	183	cherokee_buffer_add (buf, val, val_len);
183	184	}
184	185
…	…
273	274	cherokee_buffer_init (&n->write_buffer);
274	275
275		/* The first FastCGI handler of each thread must create the
276		* FastCGI manager container table, and set the freeing func.
277		*/
278		if (CONN_THREAD(cnt)->fastcgi_servers == NULL) {
279		CONN_THREAD(cnt)->fastcgi_free_func = (cherokee_func_free_t) cherokee_fcgi_dispatcher_free;
280		cherokee_avl_new (&CONN_THREAD(cnt)->fastcgi_servers);
281		}
	276	/* The first FastCGI handler of each thread must create the
	277	* FastCGI manager container table, and set the freeing func.
	278	*/
	279	if (CONN_THREAD(cnt)->fastcgi_servers == NULL) {
	280	CONN_THREAD(cnt)->fastcgi_free_func = (cherokee_func_free_t) cherokee_fcgi_dispatcher_free;
	281	cherokee_avl_new (&CONN_THREAD(cnt)->fastcgi_servers);
	282	}
282	283
283	284	/* Return the object
…	…
308	309	cherokee_source_t *src = NULL;
309	310	cherokee_thread_t *thread = HANDLER_THREAD(hdl);
310		cherokee_avl_t *dispatchers = thread->fastcgi_servers;
	311	cherokee_avl_t *dispatchers = thread->fastcgi_servers;
311	312	cherokee_handler_fastcgi_props_t *props = HANDLER_FASTCGI_PROPS(hdl);
312	313
…	…
314	315	*/
315	316	ret = cherokee_balancer_dispatch (props->balancer, HANDLER_CONN(hdl), &src);
316		if (ret != ret_ok) return ret;
	317	if (ret != ret_ok)
	318	return ret;
317	319
318	320	/* Get the manager
…	…
321	323	if (ret == ret_not_found) {
322	324	ret = cherokee_fcgi_dispatcher_new (dispatcher, thread, src, props->nsockets, props->nkeepalive, props->npipeline);
323		if (unlikely (ret != ret_ok)) return ret;
	325	if (unlikely (ret != ret_ok))
	326	return ret;
324	327
325	328	ret = cherokee_avl_add (dispatchers, &src->original, *dispatcher);
326		if (unlikely (ret != ret_ok)) return ret;
	329	if (unlikely (ret != ret_ok))
	330	return ret;
327	331	}
328	332
…	…
348	352	case ret_not_found:
349	353	ret = cherokee_thread_retire_active_connection (thd, conn);
350		if (unlikely (ret != ret_ok)) return ret;
	354	if (unlikely (ret != ret_ok))
	355	return ret;
351	356
352	357	ret = cherokee_fcgi_dispatcher_queue_conn (hdl->dispatcher, conn);
353		if (unlikely (ret != ret_ok)) return ret;
	358	if (unlikely (ret != ret_ok))
	359	return ret;
354	360
355	361	return ret_eagain;
…	…
359	365
360	366	ret = cherokee_fcgi_manager_ensure_is_connected (hdl->manager, thd);
361		if (unlikely (ret != ret_ok)) return ret;
	367	if (unlikely (ret != ret_ok))
	368	return ret;
362	369
363	370	ret = cherokee_fcgi_manager_register (hdl->manager, conn, &hdl->id, &hdl->generation);
364		if (unlikely (ret != ret_ok)) return ret;
	371	if (unlikely (ret != ret_ok))
	372	return ret;
365	373
366	374	TRACE (ENTRIES, "disp=%p mgr=%p, ok\n", hdl->dispatcher, hdl->manager);
…	…
375	383	ret_t ret;
376	384	cherokee_handler_cgi_base_t *cgi_base = HDL_CGI_BASE(hdl);
377		cherokee_buffer_t buffer = CHEROKEE_BUF_INIT;
	385	cherokee_buffer_t buffer = CHEROKEE_BUF_INIT;
378	386	cherokee_connection_t *conn = HANDLER_CONN(hdl);
379	387
…	…
390	398	if (conn->request.len > 0) {
391	399	cherokee_buffer_add (&buffer, conn->request.buf + 1, conn->request.len - 1);
392		}
393
394		/* if (! cherokee_buffer_is_empty (&conn->pathinfo)) { */
395		/* set_env (cgi_base, "PATH_INFO", conn->pathinfo.buf, conn->pathinfo.len); */
396		/* } */
397
	400	}
	401
	402	/* if (! cherokee_buffer_is_empty (&conn->pathinfo)) {
	403	* set_env (cgi_base, "PATH_INFO", conn->pathinfo.buf, conn->pathinfo.len);
	404	* }
	405	*/
398	406	/* A few more..
399	407	*/
…	…
413	421	fixup_padding (cherokee_buffer_t *buf, cuint_t id, cuint_t last_header_offset)
414	422	{
415		cuint_t rest;
416		cuint_t pad;
417		static char padding[8] = {0, 0, 0, 0, 0, 0, 0, 0};
418		FCGI_Header *last_header;
419
420		if (buf->len <= 0)
421		return;
422		last_header = (FCGI_Header *) (buf->buf + last_header_offset);
423		rest = buf->len % 8;
424		pad = 8 - rest;
425
426		if (rest == 0)
427		return;
428
429		last_header->paddingLength = pad;
430
431		cherokee_buffer_ensure_size (buf, buf->len + pad);
432		cherokee_buffer_add (buf, padding, pad);
	423	cuint_t rest;
	424	cuint_t pad;
	425	static char padding[8] = {0, 0, 0, 0, 0, 0, 0, 0};
	426	FCGI_Header *last_header;
	427
	428	if (buf->len <= 0)
	429	return;
	430	last_header = (FCGI_Header *) (buf->buf + last_header_offset);
	431	rest = buf->len % 8;
	432	pad = 8 - rest;
	433
	434	if (rest == 0)
	435	return;
	436
	437	last_header->paddingLength = pad;
	438
	439	cherokee_buffer_ensure_size (buf, buf->len + pad);
	440	cherokee_buffer_add (buf, padding, pad);
433	441	}
434	442
…	…
437	445	add_empty_packet (cherokee_handler_fastcgi_t *hdl, cuint_t type)
438	446	{
439		FCGI_BeginRequestRecord request;
	447	FCGI_BeginRequestRecord request;
440	448
441		fcgi_build_header (&request.header, type, hdl->id, 0, 0);
442		cherokee_buffer_add (&hdl->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
443
444		TRACE (ENTRIES, "id=%d gen=%d, empty packet type=%d, len=%d\n", hdl->id, hdl->generation, type, hdl->write_buffer.len);
	449	fcgi_build_header (&request.header, type, hdl->id, 0, 0);
	450	cherokee_buffer_add (&hdl->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
	451
	452	TRACE (ENTRIES, "id=%d gen=%d, empty packet type=%d, len=%d\n", hdl->id, hdl->generation, type, hdl->write_buffer.len);
445	453	}
446	454
…	…
451	459	FCGI_BeginRequestRecord request;
452	460	cherokee_connection_t *conn = HANDLER_CONN(hdl);
453		cuint_t last_header_offset;
454
455		/* Take care here, if the connection is reinjected, it
	461	cuint_t last_header_offset;
	462
	463	/* Take care here, if the connection is reinjected, it
456	464	* shouldn't parse the arguments again.
457		*/
458		if (conn->arguments == NULL)
459		cherokee_connection_parse_args (conn);
	465	*/
	466	if (conn->arguments == NULL)
	467	cherokee_connection_parse_args (conn);
460	468
461	469	cherokee_buffer_clean (&hdl->write_buffer);
…	…
464	472	/* FCGI_BEGIN_REQUEST
465	473	*/
466		fcgi_build_header (&request.header, FCGI_BEGIN_REQUEST, hdl->id, sizeof(request.body), 0);
467		fcgi_build_request_body (&request);
468
	474	fcgi_build_header (&request.header, FCGI_BEGIN_REQUEST, hdl->id, sizeof(request.body), 0);
	475	fcgi_build_request_body (&request);
	476
469	477	cherokee_buffer_add (&hdl->write_buffer, (void *)&request, sizeof(FCGI_BeginRequestRecord));
470		TRACE (ENTRIES, "id=%d gen=%d, Added FCGI_BEGIN_REQUEST, len=%d\n", hdl->id, hdl->generation, hdl->write_buffer.len);
	478	TRACE (ENTRIES, "id=%d gen=%d, Added FCGI_BEGIN_REQUEST, len=%d\n", hdl->id, hdl->generation, hdl->write_buffer.len);
471	479
472	480	/* Add enviroment variables
…	…
475	483
476	484	add_extra_fastcgi_env (hdl, &last_header_offset);
477		fixup_padding (&hdl->write_buffer, hdl->id, last_header_offset);
478
479		/* There are not more parameters
480		*/
	485	fixup_padding (&hdl->write_buffer, hdl->id, last_header_offset);
	486
	487	/* There are no more parameters
	488	*/
481	489	add_empty_packet (hdl, FCGI_PARAMS);
482	490
483		TRACE (ENTRIES, "id=%d gen=%d, Added FCGI_PARAMS, len=%d\n", hdl->id, hdl->generation, hdl->write_buffer.len);
	491	TRACE (ENTRIES, "id=%d gen=%d, Added FCGI_PARAMS, len=%d\n", hdl->id, hdl->generation, hdl->write_buffer.len);
484	492	return ret_ok;
485	493	}
…	…
492	500	cherokee_connection_t *conn = HANDLER_CONN(hdl);
493	501	static FCGI_Header empty_header = {0,0,0,0,0,0,0,0};
494
	502
495	503	switch (hdl->post_phase) {
496	504	case fcgi_post_init:
…	…
517	525	switch (ret) {
518	526	case ret_ok:
519		case ret_eagain:
520		break;
	527	case ret_eagain:
	528	break;
521	529	case ret_error:
522		return ret;
	530	return ret;
523	531	default:
524		RET_UNKNOWN(ret);
525		return ret_error;
	532	RET_UNKNOWN(ret);
	533	return ret_error;
526	534	}
527	535
528	536	if (buf->len > sizeof(FCGI_Header)) {
529	537	fcgi_build_header ((FCGI_Header *)buf->buf, FCGI_STDIN,
530		hdl->id, buf->len - sizeof(FCGI_Header), 0);
	538	hdl->id, buf->len - sizeof(FCGI_Header), 0);
531	539	}
532	540
…	…
544	552	ret = cherokee_fcgi_manager_send_remove (hdl->manager, buf);
545	553	switch (ret) {
546		case ret_ok:
547		break;
548		case ret_eagain:
549		return ret_eagain;
550		case ret_eof:
551		case ret_error:
552		conn->error_code = http_bad_gateway;
553		return ret_error;
554		default:
555		RET_UNKNOWN(ret);
556		return ret_error;
557		}
	554	case ret_ok:
	555	break;
	556	case ret_eagain:
	557	return ret_eagain;
	558	case ret_eof:
	559	case ret_error:
	560	conn->error_code = http_bad_gateway;
	561	return ret_error;
	562	default:
	563	RET_UNKNOWN(ret);
	564	return ret_error;
	565	}
558	566	}
559	567
…	…
592	600
593	601	ret = cherokee_fcgi_manager_ensure_is_connected (hdl->manager, HANDLER_THREAD(hdl));
594		if (unlikely (ret != ret_ok)) return ret;
	602	if (unlikely (ret != ret_ok))
	603	return ret;
595	604
596	605	ret = register_connection (hdl);
597		if (unlikely (ret != ret_ok)) return ret;
	606	if (unlikely (ret != ret_ok))
	607	return ret;
598	608
599	609	HDL_CGI_BASE(hdl)->got_eof = false;
…	…
637	647	*/
638	648	ret = cherokee_handler_cgi_base_extract_path (HDL_CGI_BASE(cgi), true);
639		if (unlikely (ret < ret_ok)) return ret;
	649	if (unlikely (ret < ret_ok))
	650	return ret;
640	651
641	652	hdl->init_phase = fcgi_init_build_header;
…	…
647	658	*/
648	659	ret = build_header (hdl);
649		if (unlikely (ret != ret_ok)) return ret;
	660	if (unlikely (ret != ret_ok))
	661	return ret;
650	662
651	663	hdl->init_phase = fcgi_init_send_header;
…	…
673	685
674	686	ret = send_post (hdl, &hdl->write_buffer);
675		if (ret != ret_ok) return ret;
	687	if (ret != ret_ok)
	688	return ret;
676	689
677	690	hdl->init_phase = fcgi_init_read;

cherokee/trunk/cherokee/handler_fcgi.c

r686	r869
83	83	if (header->type != FCGI_STDERR &&
84	84	header->type != FCGI_STDOUT &&
85		header->type != FCGI_END_REQUEST)
86		{
	85	header->type != FCGI_END_REQUEST) {
87	86	cherokee_buffer_print_debug (inbuf, -1);
88	87	PRINT_ERROR_S ("Parsing error: unknown type\n");
…	…
318	317	fcgi_build_header (FCGI_Header *hdr, cuchar_t type, cushort_t request_id, cuint_t content_length, cuchar_t padding)
319	318	{
320		hdr->version = FCGI_VERSION_1;
321		hdr->type = type;
322		hdr->requestIdB0 = (cuchar_t) request_id;
323		hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
324		hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
325		hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
326		hdr->paddingLength = padding;
327		hdr->reserved = 0;
	319	hdr->version = FCGI_VERSION_1;
	320	hdr->type = type;
	321	hdr->requestIdB0 = (cuchar_t) request_id;
	322	hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
	323	hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
	324	hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
	325	hdr->paddingLength = padding;
	326	hdr->reserved = 0;
328	327	}
329	328
…	…
331	330	fcgi_build_request_body (FCGI_BeginRequestRecord *request)
332	331	{
333		request->body.roleB0 = FCGI_RESPONDER;
334		request->body.roleB1 = 0;
335		request->body.flags = 0;
336		request->body.reserved[0] = 0;
337		request->body.reserved[1] = 0;
338		request->body.reserved[2] = 0;
339		request->body.reserved[3] = 0;
340		request->body.reserved[4] = 0;
	332	request->body.roleB0 = FCGI_RESPONDER;
	333	request->body.roleB1 = 0;
	334	request->body.flags = 0;
	335	request->body.reserved[0] = 0;
	336	request->body.reserved[1] = 0;
	337	request->body.reserved[2] = 0;
	338	request->body.reserved[3] = 0;
	339	request->body.reserved[4] = 0;
341	340	}
342	341
…	…
346	345	char *val, int val_len)
347	346	{
348		int len;
349		FCGI_BeginRequestRecord request;
	347	int len;
	348	FCGI_BeginRequestRecord request;
350	349	cherokee_handler_fcgi_t *hdl = HDL_FCGI(cgi_base);
351	350	cherokee_buffer_t *buf = &hdl->write_buffer;
352	351
353		len = key_len + val_len;
354		len += key_len > 127 ? 4 : 1;
355		len += val_len > 127 ? 4 : 1;
356
357		fcgi_build_header (&request.header, FCGI_PARAMS, 1, len, 0);
358
359		cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len);
360		cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header));
361
362		if (key_len <= 127) {
363		buf->buf[buf->len++] = key_len;
364		} else {
365		buf->buf[buf->len++] = ((key_len >> 24) & 0xff) \| 0x80;
366		buf->buf[buf->len++] = (key_len >> 16) & 0xff;
367		buf->buf[buf->len++] = (key_len >> 8) & 0xff;
368		buf->buf[buf->len++] = (key_len >> 0) & 0xff;
369		}
370
371		if (val_len <= 127) {
372		buf->buf[buf->len++] = val_len;
373		} else {
374		buf->buf[buf->len++] = ((val_len >> 24) & 0xff) \| 0x80;
375		buf->buf[buf->len++] = (val_len >> 16) & 0xff;
376		buf->buf[buf->len++] = (val_len >> 8) & 0xff;
377		buf->buf[buf->len++] = (val_len >> 0) & 0xff;
378		}
379
380		cherokee_buffer_add (buf, key, key_len);
381		cherokee_buffer_add (buf, val, val_len);
	352	len = key_len + val_len;
	353	len += key_len > 127 ? 4 : 1;
	354	len += val_len > 127 ? 4 : 1;
	355
	356	fcgi_build_header (&request.header, FCGI_PARAMS, 1, len, 0);
	357
	358	cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len);
	359	cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header));
	360
	361	if (key_len <= 127) {
	362	buf->buf[buf->len++] = key_len;
	363	} else {
	364	buf->buf[buf->len++] = ((key_len >> 24) & 0xff) \| 0x80;
	365	buf->buf[buf->len++] = (key_len >> 16) & 0xff;
	366	buf->buf[buf->len++] = (key_len >> 8) & 0xff;
	367	buf->buf[buf->len++] = (key_len >> 0) & 0xff;
	368	}
	369
	370	if (val_len <= 127) {
	371	buf->buf[buf->len++] = val_len;
	372	} else {
	373	buf->buf[buf->len++] = ((val_len >> 24) & 0xff) \| 0x80;
	374	buf->buf[buf->len++] = (val_len >> 16) & 0xff;
	375	buf->buf[buf->len++] = (val_len >> 8) & 0xff;
	376	buf->buf[buf->len++] = (val_len >> 0) & 0xff;
	377	}
	378
	379	cherokee_buffer_add (buf, key, key_len);
	380	cherokee_buffer_add (buf, val, val_len);
382	381	}
383	382
…	…

r855	r869
286	286	}
287	287
288

Navigation

Changeset 869

Legend: