msg_parser.c

Bug Summary

File:	libs/sofia-sip/libsofia-sip-ua/msg/msg_parser.c
Location:	line 1387, column 5
Description:	Value stored to 'rest' is never read

Annotated Source Code

1	/*
2	* This file is part of the Sofia-SIP package
3	*
4	* Copyright (C) 2005 Nokia Corporation.
5	*
6	* Contact: Pekka Pessi <pekka.pessi@nokia.com>
7	*
8	* This library is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU Lesser General Public License
10	* as published by the Free Software Foundation; either version 2.1 of
11	* the License, or (at your option) any later version.
12	*
13	* This library is distributed in the hope that it will be useful, but
14	* WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* Lesser General Public License for more details.
17	*
18	* You should have received a copy of the GNU Lesser General Public
19	* License along with this library; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21	* 02110-1301 USA
22	*
23	*/
24
25	/**@ingroup msg_parser
26	* @CFILE msg_parser.c
27	*
28	* HTTP-like message parser engine.
29	*
30	* @author Pekka Pessi <Pekka.Pessi@nokia.com>
31	*
32	* @date Created: Thu Oct 5 14:01:24 2000 ppessi
33	*
34	*/
35
36	/#define NDEBUG/
37
38	#include "config.h"
39
40	#include <stddef.h>
41	#include <stdlib.h>
42	#include <string.h>
43	#include <stdio.h>
44	#include <assert.h>
45	#include <limits.h>
46	#include <errno(*__errno_location ()).h>
47
48	#include <stdarg.h>
49	#include <sofia-sip/su_tagarg.h>
50
51	#include <sofia-sip/su.h>
52	#include <sofia-sip/su_alloc.h>
53
54	#include "msg_internal.h"
55	#include "sofia-sip/msg_header.h"
56	#include "sofia-sip/bnf.h"
57	#include "sofia-sip/msg_parser.h"
58	#include "sofia-sip/msg_mclass.h"
59	#include "sofia-sip/msg_mclass_hash.h"
60	#include "sofia-sip/msg_mime.h"
61
62	#if HAVE_FUNC1
63	#elif HAVE_FUNCTION1
64	#define __func__ __FUNCTION__
65	#else
66	static char const __func__[] = "msg_parser";
67	#endif
68
69	static int _msg_header_add_dup_as(msg_t *msg,
70	msg_pub_t *pub,
71	msg_hclass_t *hc,
72	msg_header_t const *src);
73
74	static void msg_insert_chain(msg_t msg, msg_pub_t pub, int prepend,
75	msg_header_t *head, msg_header_t h);
76	static void msg_insert_here_in_chain(msg_t *msg,
77	msg_header_t **prev,
78	msg_header_t *h);
79	su_inlinestatic inline msg_header_t msg_chain_remove(msg_t msg, msg_header_t *h);
80
81	#ifndef NDEBUG
82	static int msg_chain_loop(msg_header_t const *h);
83	static int msg_chain_errors(msg_header_t const *h);
84	#endif
85
86	/* ====================================================================== */
87	/* Message properties */
88
89	/** Get message flags. */
90	unsigned msg_get_flags(msg_t const *msg, unsigned mask)
91	{
92	return msg ? msg->m_object->msg_flags & mask : 0;
93	}
94
95	/** Set message flags. */
96	unsigned msg_set_flags(msg_t *msg, unsigned mask)
97	{
98	return msg ? msg->m_object->msg_flags \|= mask : 0;
99	}
100
101	/** Clear message flags. */
102	unsigned msg_zap_flags(msg_t *msg, unsigned mask)
103	{
104	return msg ? msg->m_object->msg_flags &= ~mask : 0;
105	}
106
107	/** Test if streaming is in progress. */
108	int msg_is_streaming(msg_t const *msg)
109	{
110	return msg && msg->m_streaming != 0;
111	}
112
113	/** Enable/disable streaming */
114	void msg_set_streaming(msg_t *msg, enum msg_streaming_status what)
115	{
116	if (msg)
117	msg->m_streaming = what != 0;
118	}
119
120	/* ---------------------------------------------------------------------- */
121
122	/** Test if header is not in the chain */
123	#define msg_header_is_removed(h)((h)->sh_common->h_prev == ((void)0)) ((h)->sh_prevsh_common->h_prev == NULL((void)0))
124
125	su_inlinestatic inline int msg_is_request(msg_header_t const *h)
126	{
127	return h->sh_classsh_common->h_class->hc_hash == msg_request_hash;
128	}
129
130	su_inlinestatic inline int msg_is_status(msg_header_t const *h)
131	{
132	return h->sh_classsh_common->h_class->hc_hash == msg_status_hash;
133	}
134
135	/* ====================================================================== */
136	/* Message buffer management */
137
138	/** Allocate a buffer of @a size octets, with slack of #msg_min_size. */
139	void msg_buf_alloc(msg_t msg, usize_t size)
140	{
141	struct msg_mbuffer_s *mb = msg->m_buffer;
142	size_t room = mb->mb_size - mb->mb_commit - mb->mb_used;
143	size_t target_size;
144
145	if (mb->mb_data && room >= (unsigned)size)
146	return mb->mb_data + mb->mb_used + mb->mb_commit;
147
148	target_size =
149	msg_min_size * ((size + mb->mb_commit) / msg_min_size + 1) - mb->mb_commit;
150
151	return msg_buf_exact(msg, target_size);
152	}
153
154	/** Allocate a buffer exactly of @a size octets, without any slack. */
155	void msg_buf_exact(msg_t msg, usize_t size)
156	{
157	struct msg_mbuffer_s *mb = msg->m_buffer;
158	size_t room = mb->mb_size - mb->mb_commit - mb->mb_used;
159	char *buffer;
160	int realloc;
161
162	if (mb->mb_data && room >= (unsigned)size)
163	return mb->mb_data + mb->mb_used + mb->mb_commit;
164
165	size += mb->mb_commit;
166
167	if (msg->m_maxsize && msg->m_size + size > msg->m_maxsize + 1) {
168	msg->m_object->msg_flags \|= MSG_FLG_TOOLARGE;
169	errno(*__errno_location ()) = msg->m_errno = ENOBUFS105;
170	return NULL((void*)0);
171	}
172
173	realloc = !mb->mb_used && !msg->m_set_buffer;
174
175	if (realloc)
176	buffer = su_realloc(msg->m_home, mb->mb_data, size);
177	else
178	buffer = su_alloc(msg->m_home, size);
179
180	if (!buffer)
181	return NULL((void*)0);
182
183	if (!realloc && mb->mb_commit && mb->mb_data)
184	memcpy(buffer, mb->mb_data + mb->mb_used, mb->mb_commit);
185
186	msg->m_set_buffer = 0;
187
188	mb->mb_data = buffer;
189	mb->mb_size = size;
190	mb->mb_used = 0;
191
192	return buffer + mb->mb_commit;
193	}
194
195	/** Commit data into buffer. */
196	usize_t msg_buf_commit(msg_t *msg, usize_t size, int eos)
197	{
198	if (msg) {
199	struct msg_mbuffer_s *mb = msg->m_buffer;
200	assert(mb->mb_used + mb->mb_commit + size <= mb->mb_size)((mb->mb_used + mb->mb_commit + size <= mb->mb_size ) ? (void) (0) : __assert_fail ("mb->mb_used + mb->mb_commit + size <= mb->mb_size" , "msg_parser.c", 200, __PRETTY_FUNCTION__));
201
202	mb->mb_commit += size;
203	mb->mb_eos = eos;
204
205	if (mb->mb_used == 0 && !msg->m_chunk && !msg->m_set_buffer) {
206	size_t slack = mb->mb_size - mb->mb_commit;
207
208	if (eos \|\| slack >= msg_min_size) {
209	/* realloc and cut down buffer */
210	size_t new_size;
211	void *new_data;
212
213	if (eos)
214	new_size = mb->mb_commit + 1;
215	else
216	new_size = mb->mb_commit + msg_min_size;
217
218	new_data = su_realloc(msg->m_home, mb->mb_data, new_size);
219	if (new_data) {
220	mb->mb_data = new_data, mb->mb_size = new_size;
221	}
222	}
223	}
224	}
225	return 0;
226	}
227
228	/** Get length of committed data */
229	usize_t msg_buf_committed(msg_t const *msg)
230	{
231	if (msg)
232	return msg->m_buffer->mb_commit;
233	else
234	return 0;
235	}
236
237	/** Get committed data */
238	void msg_buf_committed_data(msg_t const msg)
239	{
240	return msg && msg->m_buffer->mb_data ?
241	msg->m_buffer->mb_data + msg->m_buffer->mb_used
242	: NULL((void*)0);
243	}
244
245	usize_t msg_buf_size(msg_t const *msg)
246	{
247	assert(msg)((msg) ? (void) (0) : __assert_fail ("msg", "msg_parser.c", 247 , __PRETTY_FUNCTION__));
248	if (msg) {
249	struct msg_mbuffer_s const *mb = msg->m_buffer;
250	return mb->mb_size - mb->mb_commit - mb->mb_used;
251	}
252	else
253	return 0;
254	}
255
256	su_inlinestatic inline
257	void msg_buf_used(msg_t *msg, usize_t used)
258	{
259	msg->m_size += used;
260	msg->m_buffer->mb_used += used;
261	if (msg->m_buffer->mb_commit > used)
262	msg->m_buffer->mb_commit -= used;
263	else
264	msg->m_buffer->mb_commit = 0;
265	}
266
267	/** Set buffer. */
268	void msg_buf_set(msg_t msg, void b, usize_t size)
269	{
270	if (msg) {
271	struct msg_mbuffer_s *mb = msg->m_buffer;
272
273	assert(!msg->m_set_buffer)((!msg->m_set_buffer) ? (void) (0) : __assert_fail ("!msg->m_set_buffer" , "msg_parser.c", 273, __PRETTY_FUNCTION__)); /* This can be set only once */
274
275	mb->mb_data = b;
276	mb->mb_size = size;
277	mb->mb_used = 0;
278	mb->mb_commit = 0;
279	mb->mb_eos = 0;
280
281	msg->m_set_buffer = 1;
282	}
283	}
284
285	/** Move unparsed data from src to dst */
286	void msg_buf_move(msg_t dst, msg_t const *src)
287	{
288	void *retval;
289	struct msg_mbuffer_s *db = dst->m_buffer;
290	struct msg_mbuffer_s const *sb = src->m_buffer;
291
292	if (!dst \|\| !src)
293	return NULL((void*)0);
294
295	if (sb->mb_eos)
296	retval = msg_buf_exact(dst, sb->mb_commit + 1);
297	else
298	retval = msg_buf_alloc(dst, sb->mb_commit + 1);
299
300	if (retval == NULL((void*)0))
301	return NULL((void*)0);
302
303	memcpy(retval, sb->mb_data + sb->mb_used, sb->mb_commit);
304
305	db->mb_commit += sb->mb_commit;
306	db->mb_eos = sb->mb_eos;
307
308	return retval;
309	}
310
311	/**Obtain I/O vector for receiving the data.
312	*
313	* @relatesalso msg_s
314	*
315	* Allocate buffers for receiving @a n bytes
316	* of data available from network. Function returns the buffers in the I/O vector
317	* @a vec. The @a vec is allocated by the caller, the available length is
318	* given as @a veclen. If the protocol is message-oriented like UDP or SCTP
319	* and the available data ends at message boundary, the caller should set
320	* the @a exact as 1. Otherwise some extra buffer (known as @em slack) is
321	* allocated).
322	*
323	* Currently, the msg_recv_iovec() allocates receive buffers in at most two
324	* blocks, so the caller should allocate at least two elements for the I/O
325	* vector @a vec.
326	*
327	* @param[in] msg message object
328	* @param[out] vec I/O vector
329	* @param[in] veclen available length of @a vec
330	* @param[in] n number of possibly available bytes
331	* @param[in] exact true if data ends at message boundary
332	*
333	* @return
334	* The length of I/O vector to
335	* receive data, 0 if there are not enough buffers, or -1 upon an error.
336	*
337	* @sa msg_iovec(), su_vrecv()
338	*/
339	issize_t msg_recv_iovec(msg_t *msg, msg_iovec_t vec[], isize_t veclen,
340	usize_t n, int exact)
341	{
342	size_t i = 0;
343	size_t len = 0;
344	msg_payload_t *chunk;
345	char *buf;
346
347	if (n == 0)
348	return 0;
349
350	if (veclen == 0)
351	vec = NULL((void*)0);
352
353	for (chunk = msg->m_chunk; chunk; chunk = MSG_CHUNK_NEXT(chunk)((chunk)->pl_next)) {
354	buf = MSG_CHUNK_BUFFER(chunk)((char *)chunk->pl_common->h_data + (chunk)->pl_common ->h_len);
355	len = MSG_CHUNK_AVAIL(chunk)((chunk)->pl_len + ((chunk)->pl_data - (char *)chunk-> pl_common->h_data) - (chunk)->pl_common->h_len);
356
357	if (len == 0)
358	continue;
359	if (!buf)
360	break;
361
362	#if SU_HAVE_WINSOCK
363	/* WSABUF has u_long */
364	if (len > SU_IOVECLEN_MAX(18446744073709551615UL))
365	len = SU_IOVECLEN_MAX(18446744073709551615UL);
366	#endif
367	if (len > n)
368	len = n;
369	if (vec)
370	vec[i].mv_basesiv_base = buf, vec[i].mv_lensiv_len = (su_ioveclen_t)len;
371	i++;
372	if (len == n)
373	return i;
374	if (i == veclen)
375	vec = NULL((void*)0);
376	n -= len;
377	}
378
379	if (!chunk && msg->m_chunk && msg_get_flags(msg, MSG_FLG_FRAGS)) {
380	/*
381	* If the m_chunk is the last fragment for this message,
382	* receive rest of the data to the next message
383	*/
384	if (msg->m_next == NULL((void*)0))
385	msg->m_next = msg_create(msg->m_class, msg->m_oflags);
386	if (msg->m_next) {
387	msg->m_next->m_maxsize = msg->m_maxsize;
388	msg_addr_copy(msg->m_next, msg);
389	}
390	msg = msg->m_next;
391	if (msg == NULL((void*)0))
392	return 0;
393	}
394
395	if (exact)
396	buf = msg_buf_exact(msg, n + 1), len = n;
397	else if (chunk && len > n && !msg_get_flags(msg, MSG_FLG_CHUNKING))
398	buf = msg_buf_exact(msg, len + 1);
399	else
400	buf = msg_buf_alloc(msg, n + 1), len = msg_buf_size(msg);
401
402	if (buf == NULL((void*)0))
403	return -1;
404
405	if (vec)
406	vec[i].mv_basesiv_base = buf, vec[i].mv_lensiv_len = (su_ioveclen_t)n;
407
408	if (chunk) {
409	assert(chunk->pl_data == NULL)((chunk->pl_data == ((void)0)) ? (void) (0) : __assert_fail ("chunk->pl_data == ((void)0)", "msg_parser.c", 409, __PRETTY_FUNCTION__ )); assert(chunk->pl_common->h_len == 0)((chunk->pl_common->h_len == 0) ? (void) (0) : __assert_fail ("chunk->pl_common->h_len == 0", "msg_parser.c", 409, __PRETTY_FUNCTION__ ));
410
411	chunk->pl_common->h_data = chunk->pl_data = buf;
412
413	if (len < MSG_CHUNK_AVAIL(chunk)((chunk)->pl_len + ((chunk)->pl_data - (char *)chunk-> pl_common->h_data) - (chunk)->pl_common->h_len)) {
414	msg_header_t h = (void)chunk;
415	h->sh_succsh_common->h_succ = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), h->sh_classsh_common->h_class, 0);
416	if (!h->sh_succsh_common->h_succ)
417	return -1;
418	h->sh_succsh_common->h_succ->sh_prevsh_common->h_prev = &h->sh_succsh_common->h_succ;
419	chunk->pl_next = (msg_payload_t *)h->sh_succsh_common->h_succ;
420	chunk->pl_next->pl_len = chunk->pl_len - len;
421	chunk->pl_len = len;
422	}
423	else if (len > MSG_CHUNK_AVAIL(chunk)((chunk)->pl_len + ((chunk)->pl_data - (char *)chunk-> pl_common->h_data) - (chunk)->pl_common->h_len)) {
424	len = MSG_CHUNK_AVAIL(chunk)((chunk)->pl_len + ((chunk)->pl_data - (char *)chunk-> pl_common->h_data) - (chunk)->pl_common->h_len);
425	}
426
427	msg_buf_used(msg, len);
428	}
429
430	return i + 1;
431
432	#if 0
433	if ((msg->m_ssize \|\| msg->m_stream)
434	/* && msg_get_flags(msg, MSG_FLG_BODY) */) {
435	/* Streaming */
436	msg_buffer_t b, b0;
437
438	/* Calculate available size of current buffers */
439	for (b = msg->m_stream, len = 0; b && n > len; b = b->b_next)
440	len += b->b_avail - b->b_size;
441
442	/* Allocate new buffers */
443	if (n > len && msg_buf_external(msg, n, 0) < 0)
444	return -1;
445
446	for (b0 = msg->m_stream; b0; b0 = b0->b_next)
447	if (b0->b_avail != b0->b_size)
448	break;
449
450	for (b = b0; b && n > 0; i++, b = b->b_next) {
451	len = b->b_size - b->b_avail;
452	len = n < len ? n : len;
453	if (vec && i < veclen)
454	vec[i].mv_basesiv_base = b->b_data + b->b_avail, vec[i].mv_lensiv_len = len;
455	else
456	vec = NULL((void*)0);
457	n -= len;
458	}
459
460	return i + 1;
461	}
462	#endif
463	}
464
465
466	/** Obtain a buffer for receiving data.
467	*
468	* @relatesalso msg_s
469	*/
470	issize_t msg_recv_buffer(msg_t msg, void *return_buffer)
471	{
472	void *buffer;
473
474	if (!msg)
475	return -1;
476
477	if (return_buffer == NULL((void*)0))
478	return_buffer = &buffer;
479
480	if (msg->m_chunk) {
481	msg_payload_t *pl;
482
483	for (pl = msg->m_chunk; pl; pl = pl->pl_next) {
484	size_t n = MSG_CHUNK_AVAIL(pl)((pl)->pl_len + ((pl)->pl_data - (char *)pl->pl_common ->h_data) - (pl)->pl_common->h_len);
485	if (n) {
486	return_buffer = MSG_CHUNK_BUFFER(pl)((char )pl->pl_common->h_data + (pl)->pl_common-> h_len);
487	return n;
488	}
489	}
490
491	return 0;
492	}
493
494	if (msg_get_flags(msg, MSG_FLG_FRAGS)) {
495	/* Message is complete */
496	return 0;
497	}
498	else if ((*return_buffer = msg_buf_alloc(msg, 2))) {
499	return msg_buf_size(msg) - 1;
500	}
501	else {
502	return -1;
503	}
504	}
505
506
507
508	/**Commit @a n bytes of buffers.
509	*
510	* @relatesalso msg_s
511	*
512	* The function msg_recv_commit() is called after @a n bytes of data has
513	* been received to the message buffers and the parser can extract the
514	* received data.
515	*
516	* @param msg pointer to message object
517	* @param n number of bytes received
518	* @param eos true if stream is complete
519	*
520	* @note The @a eos should be always true for message-based transports. It
521	* should also be true when a stram oin stream-based transport ends, for
522	* instance, when TCP FIN is received.
523	*
524	* @retval 0 when successful
525	* @retval -1 upon an error.
526	*/
527	isize_t msg_recv_commit(msg_t *msg, usize_t n, int eos)
528	{
529	msg_payload_t *pl;
530
531	if (eos)
532	msg->m_buffer->mb_eos = 1;
533
534	for (pl = msg->m_chunk; pl; pl = pl->pl_next) {
535	size_t len = MSG_CHUNK_AVAIL(pl)((pl)->pl_len + ((pl)->pl_data - (char *)pl->pl_common ->h_data) - (pl)->pl_common->h_len);
536
537	if (n <= len)
538	len = n;
539
540	pl->pl_common->h_len += len;
541
542	n -= len;
543
544	if (n == 0)
545	return 0;
546	}
547
548	if (msg->m_chunk && msg->m_next)
549	msg = msg->m_next;
550
551	return msg_buf_commit(msg, n, eos);
552	}
553
554	/**Get a next message of the stream.
555	*
556	* @relatesalso msg_s
557	*
558	* When parsing a transport stream, only the first message in the stream is
559	* created with msg_create(). The rest of the messages should be created
560	* with msg_next() after previous message has been completely received and
561	* parsed.
562	*
563	*/
564	msg_t msg_next(msg_t msg)
565	{
566	msg_t *next;
567	usize_t n;
568
569	if (msg && msg->m_next) {
570	next = msg->m_next;
571	msg->m_next = NULL((void*)0);
572	return next;
573	}
574
575	if ((n = msg_buf_committed(msg))) {
576	if (msg_buf_move(next = msg_create(msg->m_class, msg->m_oflags), msg)) {
577	msg_addr_copy(next, msg);
578	return next;
579	}
580	/* How to indicate error? */
581	msg_destroy(next);
582	}
583
584	return NULL((void*)0);
585	}
586
587	/** Set next message of the stream.
588	*
589	* @relatesalso msg_s
590	*/
591	int msg_set_next(msg_t msg, msg_t next)
592	{
593	if (!msg \|\| (next && next->m_next))
594	return -1;
595
596	if (msg->m_next && next)
597	next->m_next = msg->m_next;
598
599	msg->m_next = next;
600
601	return 0;
602	}
603
604	/** Clear committed data.
605	*
606	* @relatesalso msg_s
607	*/
608	void msg_clear_committed(msg_t *msg)
609	{
610	if (msg) {
611	usize_t n = msg_buf_committed(msg);
612
613	if (n)
614	msg_buf_used(msg, n);
615	}
616	}
617
618	#if 0
619	struct sigcomp_udvm;
620
621	struct sigcomp_udvm msg_get_udvm(msg_t msg);
622	struct sigcomp_udvm msg_set_udvm(msg_t msg, struct sigcomp_udvm *);
623
624	/** Save UDVM. */
625	struct sigcomp_udvm msg_set_udvm(msg_t msg, struct sigcomp_udvm *udvm)
626	{
627	struct sigcomp_udvm prev = NULL((void)0);
628
629	if (msg) {
630	prev = msg->m_udvm;
631	msg->m_udvm = udvm;
632	}
633
634	return prev;
635	}
636
637	/** Get saved UDVM */
638	struct sigcomp_udvm msg_get_udvm(msg_t msg)
639	{
640	return msg ? msg->m_udvm : NULL((void*)0);
641	}
642
643	#endif
644
645	/** Mark message as complete.
646	*
647	* @relatesalso msg_s
648	*/
649	unsigned msg_mark_as_complete(msg_t *msg, unsigned mask)
650	{
651	if (msg) {
652	msg->m_streaming = 0;
653	return msg->m_object->msg_flags \|= mask \| MSG_FLG_COMPLETE;
654	}
655	else {
656	return 0;
657	}
658	}
659
660	/** Return true if message is complete.
661	*
662	* @relatesalso msg_s
663	*/
664	int msg_is_complete(msg_t const *msg)
665	{
666	return msg && MSG_IS_COMPLETE(msg->m_object)(((msg->m_object)->msg_flags & MSG_FLG_COMPLETE) != 0);
667	}
668
669	/** Return true if message has parsing errors.
670	*
671	* @relatesalso msg_s
672	*/
673	int msg_has_error(msg_t const *msg)
674	{
675	return msg->m_object->msg_flags & MSG_FLG_ERROR;
676	}
677
678	/**Total size of message.
679	*
680	* @relatesalso msg_s
681	*/
682	usize_t msg_size(msg_t const *msg)
683	{
684	return msg ? msg->m_size : 0;
685	}
686
687	/** Set the maximum size of a message.
688	*
689	* @relatesalso msg_s
690	*
691	* The function msg_maxsize() sets the maximum buffer size of a message. It
692	* returns the previous maximum size. If the @a maxsize is 0, maximum size
693	* is not set, but the current maximum size is returned.
694	*
695	* If the message size exceeds maxsize, msg_errno() returns ENOBUFS,
696	* MSG_FLG_TOOLARGE and MSG_FLG_ERROR flags are set.
697	*/
698	usize_t msg_maxsize(msg_t *msg, usize_t maxsize)
699	{
700	usize_t retval = 0;
701
702	if (msg) {
703	retval = msg->m_maxsize;
704	if (maxsize)
705	msg->m_maxsize = maxsize;
706	}
707
708	return retval;
709	}
710
711	/**Set the size of next fragment.
712	*
713	* @relatesalso msg_s
714	*
715	* The function msg_streaming_size() sets the size of the message body for
716	* streaming.
717	*/
718	int msg_streaming_size(msg_t *msg, usize_t ssize)
719	{
720	if (!msg)
721	return -1;
722
723	msg->m_ssize = ssize;
724
725	return 0;
726	}
727
728	/**Allocate a list of external buffers.
729	*
730	* @relatesalso msg_s
731	*
732	* The function msg_buf_external() allocates at most msg_n_fragments
733	* external buffers for the message body.
734	*
735	* @return The function msg_buf_external() returns number of allocated
736	* buffers, or -1 upon an error.
737	*/
738	issize_t msg_buf_external(msg_t *msg,
739	usize_t N,
740	usize_t blocksize)
741	{
742	msg_buffer_t ext = NULL((void)0), b, *bb;
743	size_t i, I;
744
745	assert(N <= 128 * 1024)((N <= 128 * 1024) ? (void) (0) : __assert_fail ("N <= 128 * 1024" , "msg_parser.c", 745, __PRETTY_FUNCTION__));
746
747	if (msg == NULL((void*)0))
748	return -1;
749	if (blocksize == 0)
750	blocksize = msg_min_block;
751	if (N == 0)
752	N = blocksize;
753	if (N > blocksize * msg_n_fragments)
754	N = blocksize * msg_n_fragments;
755	if (N > msg->m_ssize)
756	N = msg->m_ssize;
757
758	I = (N + blocksize - 1) / blocksize; assert(I <= msg_n_fragments)((I <= msg_n_fragments) ? (void) (0) : __assert_fail ("I <= msg_n_fragments" , "msg_parser.c", 758, __PRETTY_FUNCTION__));
759
760	for (i = 0, bb = &ext; i < I; i++) {
761	bb = su_zalloc(msg_home(msg)((su_home_t)(msg)), sizeof **bb);
762	if (!*bb)
763	break;
764	bb = &(*bb)->b_next;
765	}
766
767	if (i == I)
768	for (b = ext, i = 0; b; b = b->b_next, i++) {
769	b->b_data = su_alloc(msg_home(msg)((su_home_t*)(msg)), b->b_size = blocksize);
770	if (!b->b_data)
771	break;
772	}
773
774	if (i == I) {
775	/* Successful return */
776	for (bb = &msg->m_stream; bb; bb = &(bb)->b_next)
777	;
778
779	*bb = ext;
780
781	if (msg->m_ssize != MSG_SSIZE_MAX((2147483647 *2U +1U)))
782	for (b = ext; b; b = b->b_next) {
783	if (msg->m_ssize < b->b_size) {
784	b->b_size = msg->m_ssize;
785	}
786	msg->m_ssize -= b->b_size;
787	}
788
789	return i;
790	}
791
792	for (b = ext; b; b = ext) {
793	ext = b->b_next;
794	su_free(msg_home(msg)((su_home_t*)(msg)), b->b_data);
795	su_free(msg_home(msg)((su_home_t*)(msg)), b);
796	}
797
798	return -1;
799	}
800
801	int msg_unref_external(msg_t msg, msg_buffer_t b)
802	{
803	if (msg && b) {
804	su_free(msg_home(msg)((su_home_t*)(msg)), b->b_data);
805	su_free(msg_home(msg)((su_home_t*)(msg)), b);
806	return 0;
807	}
808	errno(*__errno_location ()) = EINVAL22;
809	return -1;
810	}
811
812	/* ====================================================================== */
813	/* Parsing messages */
814
815	su_inlinestatic inline int extract_incomplete_chunks(msg_t *, int eos);
816	static issize_t extract_first(msg_t , msg_pub_t ,
817	char b[], isize_t bsiz, int eos);
818	su_inlinestatic inline issize_t extract_next(msg_t , msg_pub_t , char *, isize_t bsiz,
819	int eos, int copy);
820	static issize_t extract_header(msg_t , msg_pub_t,
821	char b[], isize_t bsiz, int eos, int copy);
822	static msg_header_t header_parse(msg_t , msg_pub_t , msg_href_t const ,
823	char s[], isize_t slen, int copy_buffer);
824	static msg_header_t error_header_parse(msg_t msg, msg_pub_t *mo,
825	msg_href_t const *hr);
826	su_inlinestatic inline issize_t
827	extract_trailers(msg_t msg, msg_pub_t mo,
828	char *b, isize_t bsiz, int eos, int copy);
829
830	/** Calculate length of line ending (0, 1 or 2). @internal */
831	#define CRLF_TEST(b)((b)[0] == '\r' ? ((b)[1] == '\n') + 1 : (b)[0] =='\n') ((b)[0] == '\r' ? ((b)[1] == '\n') + 1 : (b)[0] =='\n')
832
833	su_inlinestatic inline void
834	append_parsed(msg_t msg, msg_pub_t mo, msg_href_t const hr, msg_header_t h,
835	int always_into_chain);
836
837	/**Extract and parse a message from internal buffer.
838	*
839	* @relatesalso msg_s
840	*
841	* This function parses the internal buffer and adds the parsed fragments to
842	* the message object. It marks the successfully parsed data as extracted.
843	*
844	* @param msg message to be parsed
845	*
846	* @retval positive if a complete message was parsed
847	* @retval 0 if message was incomplete
848	* @retval negative if an error occurred
849	*/
850	int msg_extract(msg_t *msg)
851	{
852	msg_pub_t *mo = msg_object(msg);
853	msg_mclass_t const *mc;
854	char *b;
855	ssize_t m;
856	size_t bsiz;
857	int eos;
858
859	if (!msg \|\| !msg->m_buffer->mb_data)
860	return -1;
861
862	assert(mo)((mo) ? (void) (0) : __assert_fail ("mo", "msg_parser.c", 862 , __PRETTY_FUNCTION__));
863
864	mc = msg->m_class;
865	mo = msg->m_object;
866	eos = msg->m_buffer->mb_eos;
867
868	if (msg->m_chunk) {
869	int incomplete = extract_incomplete_chunks(msg, eos);
870	if (incomplete < 1 \|\| MSG_IS_COMPLETE(mo)(((mo)->msg_flags & MSG_FLG_COMPLETE) != 0))
871	return incomplete;
872	}
873
874	if (mo->msg_flags & MSG_FLG_TRAILERS)
875	msg_set_streaming(msg, (enum msg_streaming_status)0);
876
877	if (msg->m_buffer->mb_used + msg->m_buffer->mb_commit ==
878	msg->m_buffer->mb_size)
879	/* Why? When? */
880	return 0;
881
882	assert(msg->m_buffer->mb_used + msg->m_buffer->mb_commit <((msg->m_buffer->mb_used + msg->m_buffer->mb_commit < msg->m_buffer->mb_size) ? (void) (0) : __assert_fail ("msg->m_buffer->mb_used + msg->m_buffer->mb_commit < msg->m_buffer->mb_size" , "msg_parser.c", 883, __PRETTY_FUNCTION__))
883	msg->m_buffer->mb_size)((msg->m_buffer->mb_used + msg->m_buffer->mb_commit < msg->m_buffer->mb_size) ? (void) (0) : __assert_fail ("msg->m_buffer->mb_used + msg->m_buffer->mb_commit < msg->m_buffer->mb_size" , "msg_parser.c", 883, __PRETTY_FUNCTION__));
884
885	m = 0;
886
887	b = msg->m_buffer->mb_data + msg->m_buffer->mb_used;
888	bsiz = msg->m_buffer->mb_commit;
889	b[bsiz] = '\0';
890
891	while (msg->m_buffer->mb_commit > 0) {
892	int flags = mo->msg_flags;
893	int copy = MSG_IS_EXTRACT_COPY(flags)((((flags)) & (MSG_FLG_EXTRACT_COPY)) == MSG_FLG_EXTRACT_COPY );
894
895	if (flags & MSG_FLG_COMPLETE)
896	break;
897
898	if (flags & MSG_FLG_TRAILERS)
899	m = extract_trailers(msg, mo, b, bsiz, eos, copy);
900	else if (flags & MSG_FLG_BODY)
901	m = mc->mc_extract_body(msg, mo, b, bsiz, eos);
902	else if (flags & MSG_FLG_HEADERS)
903	m = extract_next(msg, mo, b, bsiz, eos, copy);
904	else
905	m = extract_first(msg, mo, b, bsiz, eos);
906
907	if (m <= 0 \|\| msg->m_chunk)
908	break;
909
910	b += m;
911	bsiz -= m;
912
913	msg_buf_used(msg, (size_t)m);
914	}
915
916	if (eos && bsiz == 0)
917	msg_mark_as_complete(msg, 0);
918
919	if (m < 0 \|\| (mo->msg_flags & MSG_FLG_ERROR)) {
920	msg_mark_as_complete(msg, MSG_FLG_ERROR);
921	return -1;
922	}
923	else if (!MSG_IS_COMPLETE(mo)(((mo)->msg_flags & MSG_FLG_COMPLETE) != 0))
924	return 0;
925	else if (!(mo->msg_flags & MSG_FLG_HEADERS)) {
926	msg_mark_as_complete(msg, MSG_FLG_ERROR);
927	return -1;
928	}
929	else
930	return 1;
931	}
932
933	static
934	issize_t extract_first(msg_t msg, msg_pub_t mo, char b[], isize_t bsiz, int eos)
935	{
936	/* First line */
937	size_t k, l, m, n, xtra;
938	int crlf;
939	msg_header_t *h;
940	msg_href_t const *hr;
941	msg_mclass_t const *mc = msg->m_class;
942
943	for (k = 0; IS_LWS(b[k])((b[k]) == ' ' \|\| (b[k]) == '\t' \|\| (b[k]) == '\r' \|\| (b[k]) == '\n'); k++) /* Skip whitespace */
944	;
945	if (!b[k]) return k;
946
947	/* If first token contains no /, this is request, otherwise status line */
948	l = span_token(b + k) + k;
949	if (b[l] != '/')
950	hr = mc->mc_request;
951	else
952	hr = mc->mc_status;
953
954	n = span_non_crlf(b + l)__extension__ ({ char __r0, __r1, __r2; (__builtin_constant_p ("\r" "\n") && ((size_t)(const void )(("\r" "\n") + 1) - (size_t)(const void )("\r" "\n") == 1) ? ((__builtin_constant_p (b + l) && ((size_t)(const void )((b + l) + 1) - (size_t )(const void )(b + l) == 1)) ? __builtin_strcspn (b + l, "\r" "\n") : ((__r0 = ((const char ) ("\r" "\n"))[0], __r0 == '\0' ) ? strlen (b + l) : ((__r1 = ((const char ) ("\r" "\n"))[1] , __r1 == '\0') ? __strcspn_c1 (b + l, __r0) : ((__r2 = ((const char ) ("\r" "\n"))[2], __r2 == '\0') ? __strcspn_c2 (b + l , __r0, __r1) : (((const char ) ("\r" "\n"))[3] == '\0' ? __strcspn_c3 (b + l, __r0, __r1, __r2) : __builtin_strcspn (b + l, "\r" "\n" )))))) : __builtin_strcspn (b + l, "\r" "\n")); }) + l;
955	if (!b[n])
956	return eos ? -1 : 0;
957	crlf = CRLF_TEST(b + n)((b + n)[0] == '\r' ? ((b + n)[1] == '\n') + 1 : (b + n)[0] == '\n');
958
959	for (m = n + crlf; IS_WS(b[m])((b[m]) == ' ' \|\| (b[m]) == '\t'); m++)
960	;
961	/* In order to skip possible whitespace after first line, we don't parse
962	first line until first non-ws char from next one has been received */
963	if (!b[m] && !eos)
964	return 0;
965
966	xtra = MSG_IS_EXTRACT_COPY(mo->msg_flags)((((mo->msg_flags)) & (MSG_FLG_EXTRACT_COPY)) == MSG_FLG_EXTRACT_COPY ) ? n + 1 - k : 0;
967	if (!(h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hr->hr_class, xtra)))
968	return -1;
969
970	if (xtra) {
971	char bb = memcpy(MSG_HEADER_DATA(h)((char )(h) + (h)->sh_common->h_class->hc_size), b, xtra - 1);
972	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = n + crlf;
973	b = bb; n = xtra - 1;
974	}
975	else {
976	b = b + k; n = n - k;
977	}
978
979	b[n] = 0;
980
981	if (hr->hr_class->hc_parse(msg_home(msg)((su_home_t*)(msg)), h, b, n) < 0)
982	return -1;
983
984	assert(hr->hr_offset)((hr->hr_offset) ? (void) (0) : __assert_fail ("hr->hr_offset" , "msg_parser.c", 984, __PRETTY_FUNCTION__));
985
986	append_parsed(msg, mo, hr, h, 1);
987
988	mo->msg_flags \|= MSG_FLG_HEADERS;
989
990	return m;
991	}
992
993	/* Extract header or message body */
994	su_inlinestatic inline issize_t
995	extract_next(msg_t msg, msg_pub_t mo, char *b, isize_t bsiz,
996	int eos, int copy)
997	{
998	if (IS_CRLF(b[0])((b[0]) == '\r' \|\| (b[0]) == '\n'))
999	return msg->m_class->mc_extract_body(msg, mo, b, bsiz, eos);
1000	else
1001	return extract_header(msg, mo, b, bsiz, eos, copy);
1002	}
1003
1004	/** Extract a header. */
1005	issize_t msg_extract_header(msg_t msg, msg_pub_t mo,
1006	char b[], isize_t bsiz, int eos)
1007	{
1008	return extract_header(msg, mo, b, bsiz, eos, 0);
1009	}
1010
1011	/** Extract a header from buffer @a b.
1012	*/
1013	static
1014	issize_t
1015	extract_header(msg_t msg, msg_pub_t mo, char *b, isize_t bsiz, int eos,
1016	int copy_buffer)
1017	{
1018	size_t len, m;
1019	size_t name_len = 0, xtra;
1020	isize_t n = 0;
1021	int crlf = 0, name_len_set = 0;
1022	int error = 0;
1023	msg_header_t *h;
1024	msg_href_t const *hr;
1025	msg_mclass_t const *mc = msg->m_class;
1026
1027	hr = msg_find_hclass(mc, b, &n); /* Get header name */
1028	error = n == 0;
1029	if (hr == NULL((void)0)) / Panic */
1030	return -1;
1031
1032	xtra = span_ws(b + n)__extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (" " "\t") && ((size_t)(const void )((" " "\t") + 1 ) - (size_t)(const void )(" " "\t") == 1) ? ((__builtin_constant_p (b + n) && ((size_t)(const void )((b + n) + 1) - (size_t )(const void )(b + n) == 1)) ? __builtin_strspn (b + n, " " "\t" ) : ((__a0 = ((const char ) (" " "\t"))[0], __a0 == '\0') ? ( (void) (b + n), (size_t) 0) : ((__a1 = ((const char ) (" " "\t" ))[1], __a1 == '\0') ? __strspn_c1 (b + n, __a0) : ((__a2 = ( (const char ) (" " "\t"))[2], __a2 == '\0') ? __strspn_c2 (b + n, __a0, __a1) : (((const char ) (" " "\t"))[3] == '\0' ? __strspn_c3 (b + n, __a0, __a1, __a2) : __builtin_strspn (b + n, " " "\t")))))) : __builtin_strspn (b + n, " " "\t")); });
1033
1034	/* Find next crlf which is not followed by whitespace */
1035	do {
1036	n += xtra + crlf;
1037	if (!eos && bsiz == n)
1038	return 0;
1039	m = span_non_crlf(b + n)__extension__ ({ char __r0, __r1, __r2; (__builtin_constant_p ("\r" "\n") && ((size_t)(const void )(("\r" "\n") + 1) - (size_t)(const void )("\r" "\n") == 1) ? ((__builtin_constant_p (b + n) && ((size_t)(const void )((b + n) + 1) - (size_t )(const void )(b + n) == 1)) ? __builtin_strcspn (b + n, "\r" "\n") : ((__r0 = ((const char ) ("\r" "\n"))[0], __r0 == '\0' ) ? strlen (b + n) : ((__r1 = ((const char ) ("\r" "\n"))[1] , __r1 == '\0') ? __strcspn_c1 (b + n, __r0) : ((__r2 = ((const char ) ("\r" "\n"))[2], __r2 == '\0') ? __strcspn_c2 (b + n , __r0, __r1) : (((const char ) ("\r" "\n"))[3] == '\0' ? __strcspn_c3 (b + n, __r0, __r1, __r2) : __builtin_strcspn (b + n, "\r" "\n" )))))) : __builtin_strcspn (b + n, "\r" "\n")); });
1040	if (!name_len_set && m)
1041	name_len = n, name_len_set = 1; /* First non-ws after COLON */
1042	n += m;
1043	crlf = CRLF_TEST(b + n)((b + n)[0] == '\r' ? ((b + n)[1] == '\n') + 1 : (b + n)[0] == '\n');
1044	xtra = span_ws(b + n + crlf)__extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (" " "\t") && ((size_t)(const void )((" " "\t") + 1 ) - (size_t)(const void )(" " "\t") == 1) ? ((__builtin_constant_p (b + n + crlf) && ((size_t)(const void )((b + n + crlf ) + 1) - (size_t)(const void )(b + n + crlf) == 1)) ? __builtin_strspn (b + n + crlf, " " "\t") : ((__a0 = ((const char ) (" " "\t" ))[0], __a0 == '\0') ? ((void) (b + n + crlf), (size_t) 0) : ( (__a1 = ((const char ) (" " "\t"))[1], __a1 == '\0') ? __strspn_c1 (b + n + crlf, __a0) : ((__a2 = ((const char ) (" " "\t"))[ 2], __a2 == '\0') ? __strspn_c2 (b + n + crlf, __a0, __a1) : ( ((const char ) (" " "\t"))[3] == '\0' ? __strspn_c3 (b + n + crlf, __a0, __a1, __a2) : __builtin_strspn (b + n + crlf, " " "\t")))))) : __builtin_strspn (b + n + crlf, " " "\t")); });
1045	}
1046	while (xtra);
1047
1048	if (!eos && bsiz == n + crlf)
1049	return 0;
1050
1051	if (hr->hr_class->hc_hash == msg_unknown_hash)
1052	name_len = 0, name_len_set = 1;
1053
1054	if (error) {
1055	msg->m_extract_err \|= hr->hr_flags;
1056	if (hr->hr_class->hc_critical)
1057	mo->msg_flags \|= MSG_FLG_ERROR;
1058	hr = mc->mc_error;
1059	copy_buffer = 1;
1060	h = error_header_parse(msg, mo, hr);
1061	}
1062	else {
1063	if (!name_len_set)
1064	/* Empty header - nothing but name, COLON and LWS */
1065	name_len = n;
1066	else
1067	/* Strip extra whitespace at the end of header */
1068	while (n > name_len && IS_LWS(b[n - 1])((b[n - 1]) == ' ' \|\| (b[n - 1]) == '\t' \|\| (b[n - 1]) == '\r' \|\| (b[n - 1]) == '\n'))
1069	n--, crlf++;
1070
1071	h = header_parse(msg, mo, hr, b + name_len, n - name_len, copy_buffer);
1072	}
1073
1074	if (h == NULL((void*)0))
1075	return -1;
1076
1077	len = n + crlf;
1078
1079	/*
1080	* If the header contains multiple header fields, set the pointer to the
1081	* encodeded data correctly
1082	*/
1083	while (h) {
1084	if (copy_buffer)
1085	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = len;
1086	b += len, len = 0;
1087	if (h->sh_succsh_common->h_succ)
1088	assert(&h->sh_succ == h->sh_succ->sh_prev)((&h->sh_common->h_succ == h->sh_common->h_succ ->sh_common->h_prev) ? (void) (0) : __assert_fail ("&h->sh_common->h_succ == h->sh_common->h_succ->sh_common->h_prev" , "msg_parser.c", 1088, __PRETTY_FUNCTION__));
1089	h = h->sh_nextsh_header_next->shn_next;
1090	}
1091
1092	return n + crlf;
1093	}
1094
1095	static
1096	msg_header_t header_parse(msg_t msg, msg_pub_t *mo,
1097	msg_href_t const *hr,
1098	char s[], isize_t slen,
1099	int copy_buffer)
1100	{
1101	su_home_t home = msg_home(msg)((su_home_t)(msg));
1102	msg_header_t h, *hh;
1103	msg_hclass_t *hc = hr->hr_class;
1104	int n;
1105	int add_to_list, clear = 0;
1106
1107	hh = (msg_header_t *)((char )mo + hr->hr_offset);
1108
1109	add_to_list = (hc->hc_kind == msg_kind_list && !copy_buffer && *hh);
1110
1111	if (add_to_list)
1112	h = *hh;
1113	else
1114	h = msg_header_alloc(home, hc, copy_buffer ? slen + 1 : 0);
1115
1116	if (!h)
1117	return NULL((void*)0);
1118
1119	if (copy_buffer)
1120	s = memcpy(MSG_HEADER_DATA(h)((char *)(h) + (h)->sh_common->h_class->hc_size), s, slen);
1121
1122	s[slen] = '\0';
1123
1124	if (hc->hc_kind == msg_kind_list && *hh) {
1125	n = hc->hc_parse(home, *hh, s, slen);
1126	/* Clear if adding new header disturbs existing headers */
1127	clear = *hh != h && !copy_buffer;
1128	if (clear)
1129	msg_fragment_clear((*hh)->sh_common);
1130	}
1131	else
1132	n = hc->hc_parse(home, h, s, slen);
1133
1134	if (n < 0) {
1135	msg->m_extract_err \|= hr->hr_flags;
1136
1137	if (hc->hc_critical)
1138	mo->msg_flags \|= MSG_FLG_ERROR;
1139
1140	clear = 0;
1141
1142	if (!add_to_list) {
1143	/* XXX - This should be done by msg_header_free_all() */
1144	msg_header_t *h_next;
1145	msg_param_t *h_params;
1146	msg_error_t *er;
1147
1148	while (h) {
1149	h_next = h->sh_nextsh_header_next->shn_next;
1150	if (hc->hc_params) {
1151	h_params = (msg_param_t )((char )h + hc->hc_params);
1152	if (h_params)
1153	su_free(home, h_params);
1154	}
1155	su_free(home, h);
1156	h = h_next;
1157	}
1158	/* XXX - This should be done by msg_header_free_all() */
1159	hr = msg->m_class->mc_error;
1160	h = msg_header_alloc(home, hr->hr_class, 0);
1161	er = (msg_error_t *)h;
1162
1163	if (!er)
1164	return NULL((void*)0);
1165
1166	er->er_name = hc->hc_name;
1167	hh = (msg_header_t *)((char )mo + hr->hr_offset);
1168	}
1169	}
1170
1171	if (clear)
1172	for (hh = &(hh)->sh_nextsh_header_next->shn_next; hh; hh = (hh)->sh_nextsh_header_next->shn_next)
1173	msg_chain_remove(msg, *hh);
1174	else if (h != *hh)
1175	append_parsed(msg, mo, hr, h, 0);
1176
1177	return h;
1178	}
1179
1180	static
1181	msg_header_t error_header_parse(msg_t msg, msg_pub_t *mo,
1182	msg_href_t const *hr)
1183	{
1184	msg_header_t *h;
1185
1186	h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hr->hr_class, 0);
1187	if (h)
1188	append_parsed(msg, mo, hr, h, 0);
1189
1190	return h;
1191	}
1192
1193
1194	/** Complete this header field and parse next header field.
1195	*
1196	* This function completes parsing a multi-field header like @Accept,
1197	* @Contact, @Via or @Warning. It scans for the next header field and
1198	* if one is found, it calls the parsing function recursively.
1199	*
1200	* @param home memory home used ot allocate
1201	* new header structures and parameter lists
1202	* @param prev pointer to header structure already parsed
1203	* @param s header content to parse; should point to the area after
1204	* current header field (either end of line or to a comma
1205	* separating header fields)
1206	* @param slen ignored
1207	*
1208	* @since New in @VERSION_1_12_4.
1209	*
1210	* @retval >= 0 when successful
1211	* @retval -1 upon an error
1212	*/
1213	issize_t msg_parse_next_field(su_home_t home, msg_header_t prev,
1214	char *s, isize_t slen)
1215	{
1216	msg_hclass_t *hc = prev->sh_classsh_common->h_class;
1217	msg_header_t *h;
1218	char *end = s + slen;
1219
1220	if (s && s != ',')
1221	return -1;
1222
1223	if (msg_header_update_params(prev->sh_common, 0) < 0)
1224	return -1;
1225
1226	while (s == ',') / Skip comma and following whitespace */
1227	*s = '\0', s += span_lws(s + 1) + 1;
1228
1229	if (*s == 0)
1230	return 0;
1231
1232	h = msg_header_alloc(home, hc, 0);
1233	if (!h)
1234	return -1;
1235
1236	prev->sh_succsh_common->h_succ = h, h->sh_prevsh_common->h_prev = &prev->sh_succsh_common->h_succ;
1237	prev->sh_nextsh_header_next->shn_next = h;
1238
1239	return hc->hc_parse(home, h, s, end - s);
1240	}
1241
1242
1243	/** Decode a message header. */
1244	msg_header_t msg_header_d(su_home_t home, msg_t const msg, char const b)
1245	{
1246	msg_mclass_t const *mc = msg->m_class;
1247	msg_href_t const *hr = mc->mc_unknown;
1248	isize_t n; /* Length of header contents */
1249	isize_t name_len, xtra;
1250	msg_header_t *h;
1251	char *bb;
1252
1253	n = strlen(b);
1254	hr = msg_find_hclass(mc, b, &name_len);
1255	if (hr == NULL((void*)0))
1256	return NULL((void*)0);
1257
1258	/* Strip extra whitespace at the end and begin of header */
1259	while (n > name_len && IS_LWS(b[n - 1])((b[n - 1]) == ' ' \|\| (b[n - 1]) == '\t' \|\| (b[n - 1]) == '\r' \|\| (b[n - 1]) == '\n'))
1260	n--;
1261	if (name_len < n && IS_LWS(b[name_len])((b[name_len]) == ' ' \|\| (b[name_len]) == '\t' \|\| (b[name_len ]) == '\r' \|\| (b[name_len]) == '\n'))
1262	name_len++;
1263
1264	xtra = (n - name_len);
1265	if (!(h = msg_header_alloc(home, hr->hr_class, xtra + 1)))
1266	return NULL((void*)0);
1267
1268	bb = memcpy(MSG_HEADER_DATA(h)((char *)(h) + (h)->sh_common->h_class->hc_size), b + name_len, xtra), bb[xtra] = 0;
1269
1270	if (hr->hr_class->hc_parse(home, h, bb, xtra) >= 0)
1271	return h;
1272
1273	hr = mc->mc_unknown;
1274	su_free(home, h);
1275	if (!(h = msg_header_alloc(home, hr->hr_class, n + 1)))
1276	return NULL((void*)0);
1277	bb = memcpy(MSG_HEADER_DATA(h)((char *)(h) + (h)->sh_common->h_class->hc_size), b, n), bb[n] = 0;
1278	if (hr->hr_class->hc_parse(home, h, bb, n) < 0)
1279	su_free(home, h), h = NULL((void*)0);
1280
1281	return h;
1282	}
1283
1284	/** Extract a separator line */
1285	issize_t msg_extract_separator(msg_t msg, msg_pub_t mo,
1286	char b[], isize_t bsiz, int eos)
1287	{
1288	msg_mclass_t const *mc = msg->m_class;
1289	msg_href_t const *hr = mc->mc_separator;
1290	int l = CRLF_TEST(b)((b)[0] == '\r' ? ((b)[1] == '\n') + 1 : (b)[0] =='\n'); /* Separator length */
1291	msg_header_t *h;
1292
1293	/* Even if a single CR may be a payload separator we cannot be sure */
1294	if (l == 0 \|\| (!eos && bsiz == 1 && b[0] == '\r'))
1295	return 0;
1296
1297	/* Separator */
1298	if (!(h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hr->hr_class, 0)))
1299	return -1;
1300	if (hr->hr_class->hc_parse(msg_home(msg)((su_home_t*)(msg)), h, b, l) < 0)
1301	return -1;
1302
1303	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = l;
1304
1305	append_parsed(msg, mo, hr, h, 0);
1306
1307	return l;
1308	}
1309
1310	su_inlinestatic inline msg_header_t *msg_chain_tail(msg_t const msg);
1311
1312	/** Extract a message body of @a body_len bytes.
1313	*/
1314	issize_t msg_extract_payload(msg_t msg, msg_pub_t mo,
1315	msg_header_t **return_payload,
1316	usize_t body_len,
1317	char b[], isize_t bsiz,
1318	int eos)
1319	{
1320	msg_mclass_t const *mc;
1321	msg_href_t const *hr;
1322	msg_header_t h, h0;
1323	msg_payload_t *pl;
1324	char *x;
1325
1326	if (msg == NULL((void)0) \|\| mo == NULL((void)0))
1327	return -1;
1328
1329	assert(!msg->m_chunk)((!msg->m_chunk) ? (void) (0) : __assert_fail ("!msg->m_chunk" , "msg_parser.c", 1329, __PRETTY_FUNCTION__));
1330	mc = msg->m_class;
1331	hr = mc->mc_payload;
1332
1333	if (return_payload == NULL((void*)0))
1334	return_payload = &h0;
1335	return_payload = NULL((void)0);
1336
1337	assert(body_len > 0)((body_len > 0) ? (void) (0) : __assert_fail ("body_len > 0" , "msg_parser.c", 1337, __PRETTY_FUNCTION__));
1338
1339	/* Allocate header structure for payload */
1340	if (!(h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hr->hr_class, 0)))
1341	return -1;
1342
1343	append_parsed(msg, mo, hr, h, 0);
1344	pl = (msg_payload_t*)h;
1345	*return_payload = h;
1346
1347	if (bsiz >= body_len) {
1348	/* We have a complete body. */
1349	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = body_len;
1350	pl->pl_data = b, pl->pl_len = body_len;
1351	return body_len;
1352	}
1353
1354	if (msg->m_maxsize != 0 && body_len > msg->m_maxsize) {
1355	mo->msg_flags \|= MSG_FLG_TOOLARGE;
1356	return -1;
1357	}
1358
1359	assert(msg->m_buffer->mb_commit == bsiz)((msg->m_buffer->mb_commit == bsiz) ? (void) (0) : __assert_fail ("msg->m_buffer->mb_commit == bsiz", "msg_parser.c", 1359 , __PRETTY_FUNCTION__));
1360	assert(b == msg->m_buffer->mb_data + msg->m_buffer->mb_used)((b == msg->m_buffer->mb_data + msg->m_buffer->mb_used ) ? (void) (0) : __assert_fail ("b == msg->m_buffer->mb_data + msg->m_buffer->mb_used" , "msg_parser.c", 1360, __PRETTY_FUNCTION__));
1361
1362	if (msg->m_buffer->mb_used + body_len <= msg->m_buffer->mb_size) {
1363	/* We don't have a complete body, but we have big enough buffer for it. */
1364	msg->m_chunk = pl;
1365
1366	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = bsiz;
1367	pl->pl_data = b, pl->pl_len = body_len;
1368
1369	if (msg->m_buffer->mb_used + body_len < msg->m_buffer->mb_size)
1370	/* NUL-terminate payload */
1371	b[body_len++] = '\0';
1372
1373	/* Mark the rest of the body as used in the buffer */
1374	/* msg_buf_commit(msg, body_len - bsiz, eos); */
1375	msg_buf_used(msg, body_len);
1376
1377	return bsiz;
1378	}
1379
1380	/* We don't have big enough buffer for body. */
1381
1382	if (msg_get_flags(msg, MSG_FLG_CHUNKING)) {
1383	/* Application supports chunking, use multiple chunks for payload */
1384	usize_t current, rest;
1385
1386	current = msg->m_buffer->mb_size - msg->m_buffer->mb_used;
1387	rest = body_len - current;
	Value stored to 'rest' is never read
1388
1389	/* Use all the data from our current buffer */
1390	msg_buf_used(msg, current);
1391
1392	msg->m_chunk = pl;
1393
1394	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = bsiz;
1395	pl->pl_data = b, pl->pl_len = current;
1396
1397	for (;current < body_len; current += rest) {
1398	msg_header_t *h0 = h;
1399
1400	/* Allocate header structure for next payload chunk */
1401	if (!(h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hr->hr_class, 0)))
1402	return -1;
1403	if (msg->m_chain)
1404	msg_insert_here_in_chain(msg, msg_chain_tail(msg), h);
1405	h0->sh_nextsh_header_next->shn_next = h;
1406
1407	rest = body_len - current;
1408
1409	if (!msg->m_streaming) {
1410	x = msg_buf_exact(msg, rest);
1411	if (x == NULL((void*)0)) {
1412	mo->msg_flags \|= MSG_FLG_TOOLARGE;
1413	return -1;
1414	}
1415	}
1416	else {
1417	x = NULL((void*)0);
1418	}
1419
1420	if (x) {
1421	/* Mark the just-allocated buffer as used */
1422	rest = msg->m_buffer->mb_size - msg->m_buffer->mb_used;
1423	msg_buf_used(msg, rest);
1424	}
1425
1426	pl = h->sh_payload;
1427
1428	h->sh_lensh_common->h_len = 0, pl->pl_len = rest;
1429	h->sh_datash_common->h_data = x, pl->pl_data = x;
1430	}
1431	}
1432	else {
1433	/* No chunking.
1434	*
1435	* Allocate a single buffer that contains enough free space for body.
1436	*
1437	* msg_buf_exact() also copies committed but un-used data
1438	* from the old buffer (b[0] .. b[bsiz])
1439	* to the new buffer (x[-bsiz-1]..b[-1])
1440	*/
1441	if (!(x = msg_buf_exact(msg, body_len - bsiz + 1))) {
1442	if (mo->msg_flags & MSG_FLG_TOOLARGE) {
1443	msg_mark_as_complete(msg, MSG_FLG_TRUNC);
1444	return bsiz;
1445	}
1446	return -1;
1447	}
1448
1449	/* Fake un-received data as already received and then use it */
1450	/* msg_buf_commit(msg, body_len - bsiz + 1, eos); */
1451	msg_buf_used(msg, body_len + 1);
1452
1453	msg->m_chunk = h->sh_payload;
1454
1455	x -= bsiz; /* Start of un-used data */
1456	x[body_len] = '\0';
1457
1458	h->sh_datash_common->h_data = x, h->sh_lensh_common->h_len = bsiz;
1459	pl->pl_data = x, pl->pl_len = body_len;
1460
1461	assert(MSG_CHUNK_AVAIL(pl) == body_len - bsiz)((((pl)->pl_len + ((pl)->pl_data - (char )pl->pl_common ->h_data) - (pl)->pl_common->h_len) == body_len - bsiz ) ? (void) (0) : __assert_fail ("((pl)->pl_len + ((pl)->pl_data - (char )pl->pl_common->h_data) - (pl)->pl_common->h_len) == body_len - bsiz" , "msg_parser.c", 1461, __PRETTY_FUNCTION__));
1462	}
1463
1464	return bsiz;
1465	}
1466
1467	/** Extract incomplete chunks.
1468	*/
1469	su_inlinestatic inline
1470	int extract_incomplete_chunks(msg_t *msg, int eos)
1471	{
1472	msg_payload_t *chunk;
1473
1474	for (chunk = msg->m_chunk; chunk; chunk = MSG_CHUNK_NEXT(chunk)((chunk)->pl_next)) {
1475	if (MSG_CHUNK_AVAIL(chunk)((chunk)->pl_len + ((chunk)->pl_data - (char *)chunk-> pl_common->h_data) - (chunk)->pl_common->h_len) != 0)
1476	break;
1477
1478	/* The incomplete payload fragment is now complete */
1479	assert(MSG_CHUNK_BUFFER(chunk) == chunk->pl_data + chunk->pl_len)((((char )chunk->pl_common->h_data + (chunk)->pl_common ->h_len) == chunk->pl_data + chunk->pl_len) ? (void) (0) : __assert_fail ("((char )chunk->pl_common->h_data + (chunk)->pl_common->h_len) == chunk->pl_data + chunk->pl_len" , "msg_parser.c", 1479, __PRETTY_FUNCTION__));
1480
1481	msg->m_size += chunk->pl_common->h_len;
1482	}
1483
1484	msg->m_chunk = chunk;
1485
1486	if (chunk) {
1487	if (eos) {
1488	msg_mark_as_complete(msg, MSG_FLG_TRUNC);
1489	return 1;
1490	}
1491	}
1492	else {
1493	if (msg_get_flags(msg, MSG_FLG_FRAGS))
1494	msg_mark_as_complete(msg, 0);
1495	}
1496
1497	/**@retval 1 when message is complete
1498	* @retval 0 when message is incomplete
1499	* @retval -1 upon an error
1500	*/
1501	return chunk == NULL((void*)0);
1502	}
1503
1504	/* Extract trailers */
1505	su_inlinestatic inline issize_t
1506	extract_trailers(msg_t msg, msg_pub_t mo,
1507	char *b, isize_t bsiz, int eos, int copy)
1508	{
1509	if (IS_CRLF(b[0])((b[0]) == '\r' \|\| (b[0]) == '\n')) {
1510	msg_mark_as_complete(msg, MSG_FLG_COMPLETE);
1511	return CRLF_TEST(b)((b)[0] == '\r' ? ((b)[1] == '\n') + 1 : (b)[0] =='\n');
1512	}
1513	else
1514	return extract_header(msg, mo, b, bsiz, eos, copy);
1515	}
1516
1517	/* ====================================================================== */
1518	/* Preparing (printing/encoding) a message structure for sending */
1519
1520	/* Internal prototypes */
1521	su_inlinestatic inline size_t
1522	msg_header_name_e(char b[], size_t bsiz, msg_header_t const *h, int flags);
1523	static size_t msg_header_prepare(msg_mclass_t const *, int flags,
1524	msg_header_t h, msg_header_t *return_next,
1525	char *b, size_t bsiz);
1526
1527	/**Encode all message fragments.
1528	*
1529	* @relatesalso msg_s
1530	*
1531	* The function msg_prepare() prepares a message for sending. It encodes all
1532	* serialized fragments in the message. You have to call msg_serialize()
1533	* before calling msg_headers_prepare() in order to make sure that all the
1534	* heades and other message fragments are included in the chain.
1535	*
1536	* After encoding, the msg_common_s::h_data field will point to the encoding
1537	* result of size msg_common_s::h_len bytes in in each fragment.
1538	*
1539	* When multiple header fields are represented as a comma-separated list
1540	* within a single header line, the first fragment in the header will
1541	* contain all the text belonging to the header. The rest of the header
1542	* fields will have zero-length encoding with msg_common_s::h_data that
1543	* points to the end of the line.
1544	*
1545	* @return Total size of the encoded message in bytes, or -1 upon an error.
1546	*
1547	* @sa msg_extract(), msg_serialize()
1548	*/
1549	int msg_prepare(msg_t *msg)
1550	{
1551	int total;
1552
1553	assert(msg->m_chain)((msg->m_chain) ? (void) (0) : __assert_fail ("msg->m_chain" , "msg_parser.c", 1553, __PRETTY_FUNCTION__));
1554	assert(msg_chain_errors(msg->m_chain) == 0)((msg_chain_errors(msg->m_chain) == 0) ? (void) (0) : __assert_fail ("msg_chain_errors(msg->m_chain) == 0", "msg_parser.c", 1554 , __PRETTY_FUNCTION__));
1555
1556	/* Get rid of data that was received but not yet used (parsed) */
1557	msg_clear_committed(msg);
1558
1559	total = msg_headers_prepare(msg, msg->m_chain, msg_object(msg)->msg_flags);
1560
1561	if (total != -1) {
1562	msg->m_size = total;
1563	msg->m_prepared = 1;
1564	}
1565
1566	return total;
1567	}
1568
1569	/** Clear 'prepared' flag. */
1570	void msg_unprepare(msg_t *msg)
1571	{
1572	if (msg) msg->m_prepared = 0;
1573	}
1574
1575	/** Return true if message is prepared. */
1576	int msg_is_prepared(msg_t const *msg)
1577	{
1578	return msg && msg->m_prepared;
1579	}
1580
1581	/**Encode headers in chain.
1582	*
1583	* The function msg_headers_prepare() encodes all the headers in the header
1584	* chain. You have to call msg_serialize() before calling
1585	* msg_headers_prepare() in order to make sure that all the heades and other
1586	* message fragments are included in the chain.
1587	*
1588	* @return
1589	* The size of all the headers in chain, or -1 upon an error.
1590	*/
1591	issize_t msg_headers_prepare(msg_t msg, msg_header_t headers, int flags)
1592	{
1593	msg_mclass_t const *mc = msg->m_class;
1594	msg_header_t h, next;
1595	ssize_t n = 0;
1596	size_t bsiz = 0, used = 0;
1597	char *b;
1598	size_t total = 0;
1599
1600	b = msg_buf_alloc(msg, msg_min_size);
1601	bsiz = msg_buf_size(msg);
1602
1603	if (!b)
1604	return -1;
1605
1606	for (h = headers; h;) {
1607
1608	if (h->sh_datash_common->h_data) {
1609	total += h->sh_lensh_common->h_len;
1610	h = h->sh_succsh_common->h_succ;
1611	continue;
1612	}
1613
1614	for (next = h->sh_succsh_common->h_succ; next; next = next->sh_succsh_common->h_succ)
1615	if (next->sh_classsh_common->h_class != h->sh_classsh_common->h_class \|\| next->sh_datash_common->h_data)
1616	break;
1617
1618	n = msg_header_prepare(mc, flags, h, &next, b, bsiz - used);
1619
1620	if (n == (ssize_t)-1) {
1621	errno(*__errno_location ()) = EINVAL22;
1622	return -1;
1623	}
1624
1625	if (used + n >= bsiz) {
1626	/* Allocate next buffer */
1627	if ((b = msg_buf_alloc(msg, n + 1)) == NULL((void*)0))
1628	return -1;
1629	bsiz = msg_buf_size(msg); used = 0;
1630	continue;
1631	}
1632
1633	h->sh_datash_common->h_data = b, h->sh_lensh_common->h_len = n;
1634
1635	for (h = h->sh_succsh_common->h_succ; h != next; h = h->sh_succsh_common->h_succ)
1636	h->sh_datash_common->h_data = b + n, h->sh_lensh_common->h_len = 0;
1637
1638	msg_buf_used(msg, n);
1639
1640	total += n;
1641	used += n;
1642	b += n;
1643	}
1644
1645	return total;
1646	}
1647
1648	/** Encode a header or a list of headers */
1649	static
1650	size_t msg_header_prepare(msg_mclass_t const *mc, int flags,
1651	msg_header_t h, msg_header_t *return_next,
1652	char *b, size_t bsiz)
1653	{
1654	msg_header_t h0, next;
1655	msg_hclass_t *hc;
1656	char const *s;
1657	size_t n; ssize_t m;
1658	int compact, one_line_list, comma_list;
1659
1660	assert(h)((h) ? (void) (0) : __assert_fail ("h", "msg_parser.c", 1660, __PRETTY_FUNCTION__)); assert(h->sh_class)((h->sh_common->h_class) ? (void) (0) : __assert_fail ( "h->sh_common->h_class", "msg_parser.c", 1660, __PRETTY_FUNCTION__ ));
1661
1662	hc = h->sh_classsh_common->h_class;
1663	compact = MSG_IS_COMPACT(flags)((((flags)) & (MSG_FLG_COMPACT)) == MSG_FLG_COMPACT);
1664	one_line_list = hc->hc_kind == msg_kind_apndlist;
1665	comma_list = compact \|\| one_line_list \|\| MSG_IS_COMMA_LISTS(flags)((((flags)) & (MSG_FLG_COMMA_LISTS)) == MSG_FLG_COMMA_LISTS );
1666
1667	for (h0 = h, n = 0; ; h = next) {
1668	next = h->sh_succsh_common->h_succ;
1669
1670	if (h == h0 && hc->hc_name && hc->hc_name[0])
1671	n += msg_header_name_e(b + n, bsiz >= n ? bsiz - n : 0, h, flags);
1672
1673	if ((m = hc->hc_print(b + n, bsiz >= n ? bsiz - n : 0, h, flags)) == -1) {
1674	if (bsiz >= n + 64)
1675	m = 2 * (bsiz - n);
1676	else
1677	m = 128;
1678	}
1679
1680	n += m;
1681
1682	if (hc->hc_name) {
1683	if (!hc->hc_name[0] \|\| !comma_list \|\| !next \|\| next == *return_next)
1684	s = CRLF"\r" "\n", m = 2;
1685	/* Else encode continuation */
1686	else if (compact)
1687	s = ",", m = 1;
1688	else if (one_line_list)
1689	s = ", ", m = 2;
1690	else
1691	s = "," CRLF"\r" "\n" "\t", m = 4;
1692
1693	if (bsiz > n + m)
1694	memcpy(b + n, s, m);
1695	n += m;
1696	}
1697
1698	if (!comma_list \|\| !next \|\| next == *return_next)
1699	break;
1700	}
1701
1702	*return_next = next;
1703
1704	return n;
1705	}
1706
1707	/** Encode a header.
1708	*
1709	* The function msg_header_e() encodes a header field in the buffer @a
1710	* b[]. The encoding includes its name and trailing CRLF. The function
1711	* returns the length of the encoding in bytes, excluding the final @c NUL.
1712	* The buffer @a b must be large enough for whole encoding, including the
1713	* final @c NUL.
1714	*
1715	* The @a flags parameter define how the encoding is done. If the flags
1716	* specify @c MSG_DO_COMPACT, the encoding is compact (short form with
1717	* minimal whitespace).
1718	*/
1719	issize_t msg_header_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
1720	{
1721	size_t n, m;
1722
1723	assert(h)((h) ? (void) (0) : __assert_fail ("h", "msg_parser.c", 1723, __PRETTY_FUNCTION__)); assert(h->sh_class)((h->sh_common->h_class) ? (void) (0) : __assert_fail ( "h->sh_common->h_class", "msg_parser.c", 1723, __PRETTY_FUNCTION__ ));
1724
1725	if (h == NULL((void)0) \|\| h->sh_classsh_common->h_class == NULL((void)0))
1726	return -1;
1727
1728	n = msg_header_name_e(b, bsiz, h, flags);
1729	m = h->sh_classsh_common->h_class->hc_print(b + n, bsiz > n ? bsiz - n : 0, h, flags);
1730	if (h->sh_classsh_common->h_class->hc_name) {
1731	/* Ordinary header */
1732	if (bsiz > n + m + strlen(CRLF"\r" "\n"))
1733	strcpy(b + n + m, CRLF"\r" "\n");
1734	return n + m + strlen(CRLF"\r" "\n");
1735	}
1736	else
1737	return m;
1738	}
1739
1740	/** Encode header name */
1741	su_inlinestatic inline
1742	size_t
1743	msg_header_name_e(char b[], size_t bsiz, msg_header_t const *h, int flags)
1744	{
1745	int compact = MSG_IS_COMPACT(flags)((((flags)) & (MSG_FLG_COMPACT)) == MSG_FLG_COMPACT);
1746	char const *name;
1747	size_t n, n2;
1748
1749	if (compact && h->sh_classsh_common->h_class->hc_short[0])
1750	name = h->sh_classsh_common->h_class->hc_short, n = 1;
1751	else
1752	name = h->sh_classsh_common->h_class->hc_name, n = h->sh_classsh_common->h_class->hc_len;
1753
1754	if (!name \|\| !name[0])
1755	return 0;
1756
1757	n2 = compact ? n + 1 : n + 2;
1758
1759	if (n2 < bsiz) {
1760	memcpy(b, name, n);
1761	b[n++] = ':';
1762	if (!compact)
1763	b[n++] = ' ';
1764	b[n++] = '\0';
1765	}
1766
1767	return n2;
1768	}
1769
1770	/** Convert a message to a string.
1771	*
1772	* A message is encoded and the encoding result is returned as a string.
1773	* Because the message may contain binary payload (or NUL in headers), the
1774	* message length is returned separately in @a *return_len, too.
1775	*
1776	* Note that the message is serialized as a side effect.
1777	*
1778	* @param home memory home used to allocate the string
1779	* @param msg message to encode
1780	* @param pub message object to encode (may be NULL)
1781	* @param flags flags used when encoding
1782	* @param return_len return-value parameter for encoded message length
1783	*
1784	* @return Encoding result as a C string.
1785	*
1786	* @since New in @VERSION_1_12_4
1787	*
1788	* @sa msg_make(), msg_prepare(), msg_serialize().
1789	*/
1790	char msg_as_string(su_home_t home, msg_t msg, msg_pub_t pub, int flags,
1791	size_t *return_len)
1792	{
1793	msg_mclass_t const *mc = msg->m_class;
1794	msg_header_t h, next;
1795	ssize_t n = 0;
1796	size_t bsiz = 0, used = 0;
1797	char b, b2;
1798
1799	if (pub == NULL((void*)0))
1800	pub = msg->m_object;
1801
1802	if (msg_serialize(msg, pub) < 0)
1803	return NULL((void*)0);
1804
1805	if (return_len == NULL((void*)0))
1806	return_len = &used;
1807
1808	b = su_alloc(home, bsiz = msg_min_size);
1809
1810	if (!b)
1811	return NULL((void*)0);
1812
1813	if (pub == msg->m_object)
1814	h = msg->m_chain;
1815	else
1816	h = pub->msg_common->h_succ;
1817
1818	while (h) {
1819	for (next = h->sh_succsh_common->h_succ; next; next = next->sh_succsh_common->h_succ)
1820	if (next->sh_classsh_common->h_class != h->sh_classsh_common->h_class)
1821	break;
1822
1823	n = msg_header_prepare(mc, flags, h, &next, b + used, bsiz - used);
1824
1825	if (n == -1) {
1826	errno(*__errno_location ()) = EINVAL22;
1827	su_free(home, b);
1828	return NULL((void*)0);
1829	}
1830
1831	if (bsiz > used + n) {
1832	used += n;
1833	h = next;
1834	}
1835	else {
1836	/* Realloc */
1837	if (h->sh_succsh_common->h_succ)
1838	bsiz = (used + n + msg_min_size) / msg_min_size * msg_min_size;
1839	else
1840	bsiz = used + n + 1;
1841
1842	if (bsiz < msg_min_size) {
1843	errno(*__errno_location ()) = ENOMEM12;
1844	su_free(home, b);
1845	return NULL((void*)0);
1846	}
1847
1848	b2 = su_realloc(home, b, bsiz);
1849
1850	if (b2 == NULL((void*)0)) {
1851	errno(*__errno_location ()) = ENOMEM12;
1852	su_free(home, b);
1853	return NULL((void*)0);
1854	}
1855
1856	b = b2;
1857
1858	continue;
1859	}
1860	}
1861
1862	*return_len = used;
1863
1864	b[used] = '\0'; /* NUL terminate */
1865
1866	return su_realloc(home, b, used + 1);
1867	}
1868
1869	/* ====================================================================== */
1870	/* Handling header chain */
1871
1872	su_inlinestatic inline void serialize_first(msg_t msg, msg_header_t h);
1873	static msg_header_t *serialize_one(msg_t msg, msg_header_t *h,
1874	msg_header_t **prev);
1875
1876	/** Return head of the fragment chain */
1877	msg_header_t *msg_chain_head(msg_t const msg)
1878	{
1879	return msg ? (msg_header_t *)&msg->m_chain : NULL((void)0);
1880	}
1881
1882	su_inlinestatic inline msg_header_t *_msg_chain_head(msg_t const msg)
1883	{
1884	return msg ? (msg_header_t *)&msg->m_chain : NULL((void)0);
1885	}
1886
1887	/** Return tail of the fragment chain */
1888	su_inlinestatic inline msg_header_t *msg_chain_tail(msg_t const msg)
1889	{
1890	return msg ? msg->m_tail : NULL((void*)0);
1891	}
1892
1893	/** Serialize headers into the fragment chain.
1894	*
1895	* The msg_serialize() collects the headers and other message components in
1896	* the fragment chain. It should be called before msg_prepare().
1897	*
1898	* @relatesalso msg_s
1899	*
1900	* @param msg pointer to message object
1901	* @param pub public message structure
1902	*
1903	* @retval 0 when successful
1904	* @retval -1 upon an error
1905	*/
1906	int msg_serialize(msg_t msg, msg_pub_t pub)
1907	{
1908	msg_header_t h, hh, *end;
1909	msg_header_t **separator;
1910	msg_header_t **payload;
1911	msg_header_t **multipart;
1912	msg_mclass_t const *mc;
1913	msg_header_t tail, *ptail;
1914
1915	if (!msg)
1916	return errno(*__errno_location ()) = EINVAL22, -1;
1917	if (pub == NULL((void*)0))
1918	pub = msg->m_object;
1919
1920	/* There must be a first line */
1921	if (pub->msg_request)
1922	h = pub->msg_request;
1923	else if (pub->msg_status)
1924	h = pub->msg_status;
1925	else
1926	return errno(*__errno_location ()) = EINVAL22, -1;
1927
1928	serialize_first(msg, h);
1929
1930	mc = msg->m_class;
1931	separator = (msg_header_t *)((char )pub + mc->mc_separator->hr_offset);
1932	payload = (msg_header_t *)((char )pub + mc->mc_payload->hr_offset);
1933	if (mc->mc_multipart->hr_class)
1934	multipart = (msg_header_t *)((char )pub + mc->mc_multipart->hr_offset);
1935	else
1936	multipart = NULL((void*)0);
1937
1938	/* Find place to insert headers: before separator, payload and multipart */
1939	if (separator && !msg_header_is_removed(separator)((separator)->sh_common->h_prev == ((void)0)))
1940	ptail = &(*separator)->sh_prevsh_common->h_prev;
1941	else if (payload && !msg_header_is_removed(payload)((payload)->sh_common->h_prev == ((void)0)))
1942	ptail = &(*payload)->sh_prevsh_common->h_prev;
1943	else if (multipart && multipart && !msg_header_is_removed(multipart)((multipart)->sh_common->h_prev == ((void)0)))
1944	ptail = &(*multipart)->sh_prevsh_common->h_prev;
1945	else
1946	ptail = &msg->m_tail;
1947
1948	tail = *ptail;
1949
1950	end = (msg_header_t *)((char )pub + pub->msg_size);
1951
1952	for (hh = pub->msg_headers; hh < end; hh++) {
1953	if (!*hh)
1954	continue;
1955	if (hh == separator \|\| hh == payload \|\| hh == multipart)
1956	continue;
1957	tail = serialize_one(msg, *hh, tail);
1958	}
1959
1960	/* Serialize separator, payload and multipart last */
1961	if (*separator)
1962	tail = serialize_one(msg, *separator, tail);
1963
1964	*ptail = tail;
1965
1966	/* Payload comes after separator but before multipart */
1967	if (ptail != &(*separator)->sh_prevsh_common->h_prev)
1968	;
1969	else if (payload && !msg_header_is_removed(payload)((payload)->sh_common->h_prev == ((void)0)))
1970	ptail = &(*payload)->sh_prevsh_common->h_prev;
1971	else if (multipart && multipart && !msg_header_is_removed(multipart)((multipart)->sh_common->h_prev == ((void)0)))
1972	ptail = &(*multipart)->sh_prevsh_common->h_prev;
1973	else
1974	ptail = &msg->m_tail;
1975
1976	tail = *ptail;
1977
1978	if (*payload) {
1979	tail = serialize_one(msg, *payload, tail);
1980	*ptail = tail;
1981	}
1982
1983	if (multipart && *multipart) {
1984	msg_header_t *last;
1985
1986	last = msg_multipart_serialize(tail, (msg_multipart_t )multipart);
1987
1988	msg->m_tail = &last->sh_succsh_common->h_succ;
1989	}
1990
1991	assert(msg->m_chain && msg_chain_errors(msg->m_chain) == 0)((msg->m_chain && msg_chain_errors(msg->m_chain ) == 0) ? (void) (0) : __assert_fail ("msg->m_chain && msg_chain_errors(msg->m_chain) == 0" , "msg_parser.c", 1991, __PRETTY_FUNCTION__));
1992
1993	return 0;
1994	}
1995
1996	su_inlinestatic inline
1997	void serialize_first(msg_t msg, msg_header_t h)
1998	{
1999	if (msg_header_is_removed(h)((h)->sh_common->h_prev == ((void*)0))) {
2000	if ((h->sh_succsh_common->h_succ = msg->m_chain))
2001	h->sh_succsh_common->h_succ->sh_prevsh_common->h_prev = &h->sh_succsh_common->h_succ;
2002	else
2003	msg->m_tail = &h->sh_succsh_common->h_succ;
2004	*(h->sh_prevsh_common->h_prev = &msg->m_chain) = h;
2005	}
2006	}
2007
2008	static
2009	msg_header_t *serialize_one(msg_t msg, msg_header_t h, msg_header_t *prev)
2010	{
2011	msg_header_t *last;
2012	msg_header_t succ = prev;
2013
2014	if (msg_header_is_removed(h)((h)->sh_common->h_prev == ((void*)0))) {
2015	/* Add the first header in the list to the chain */
2016	*prev = h; h->sh_prevsh_common->h_prev = prev;
2017	for (last = h; last->sh_succsh_common->h_succ; last = last->sh_succsh_common->h_succ) {
2018	/* Ensure that chain is connected */
2019	assert(last->sh_next == last->sh_succ)((last->sh_header_next->shn_next == last->sh_common-> h_succ) ? (void) (0) : __assert_fail ("last->sh_header_next->shn_next == last->sh_common->h_succ" , "msg_parser.c", 2019, __PRETTY_FUNCTION__));
2020	assert(last->sh_succ->sh_prev = &last->sh_succ)((last->sh_common->h_succ->sh_common->h_prev = & last->sh_common->h_succ) ? (void) (0) : __assert_fail ( "last->sh_common->h_succ->sh_common->h_prev = &last->sh_common->h_succ" , "msg_parser.c", 2020, __PRETTY_FUNCTION__));
2021	}
2022	prev = &last->sh_succsh_common->h_succ;
2023	}
2024
2025	if ((h = h->sh_nextsh_header_next->shn_next)) {
2026	assert(!msg_is_single(h))((!msg_is_single(h)) ? (void) (0) : __assert_fail ("!msg_is_single(h)" , "msg_parser.c", 2026, __PRETTY_FUNCTION__));
2027
2028	if (msg_is_single(h)) {
2029	for (; h; h = h->sh_nextsh_header_next->shn_next)
2030	if (!msg_header_is_removed(h)((h)->sh_common->h_prev == ((void*)0)))
2031	msg_chain_remove(msg, h);
2032	}
2033	/* Add the rest of the headers in the list to the chain */
2034	else for (; h; h = h->sh_nextsh_header_next->shn_next) {
2035	if (msg_header_is_removed(h)((h)->sh_common->h_prev == ((void*)0))) {
2036	*prev = h; h->sh_prevsh_common->h_prev = prev;
2037	for (;h->sh_succsh_common->h_succ; h = h->sh_succsh_common->h_succ)
2038	assert(h->sh_succ == h->sh_next)((h->sh_common->h_succ == h->sh_header_next->shn_next ) ? (void) (0) : __assert_fail ("h->sh_common->h_succ == h->sh_header_next->shn_next" , "msg_parser.c", 2038, __PRETTY_FUNCTION__));
2039	prev = &h->sh_succsh_common->h_succ;
2040	}
2041	}
2042	}
2043
2044	*prev = succ;
2045
2046	return prev;
2047	}
2048
2049	/**Fill an I/O vector with message contents.
2050	*
2051	* @relatesalso msg_s
2052	*
2053	* Calculate number of entries in the I/O vector
2054	* required to send a message @a msg. It also fills in the I/O vector array,
2055	* if it is provided by the caller and it is large enough.
2056	*
2057	* @param msg pointer to message object
2058	* @param vec I/O vector (may be NULL)
2059	* @param veclen length of I/O vector in @a vec
2060	*
2061	* @return
2062	* Number of entries of I/O
2063	* vector required by @a msg, or 0 upon an error.
2064	*
2065	* @note The caller should check that the I/O vector @a vec has enough
2066	* entries. If the @a vec is too short, it should allocate big enough
2067	* vector and re-invoke msg_iovec().
2068	*
2069	* @sa msg_recv_iovec(), su_vsend()
2070	*/
2071	isize_t msg_iovec(msg_t *msg, msg_iovec_t vec[], isize_t veclen)
2072	{
2073	size_t len = 0, n = 0;
2074	char const p = NULL((void)0);
2075	msg_header_t *h;
2076
2077	size_t total = 0;
2078
2079	if (veclen <= 0)
2080	veclen = 0;
2081
2082	for (h = msg->m_chain; h; h = h->sh_succsh_common->h_succ) {
2083	if (h->sh_datash_common->h_data != p) {
2084	p = h->sh_datash_common->h_data; len = h->sh_lensh_common->h_len;
2085
2086	if (p == NULL((void*)0))
2087	return 0;
2088
2089	if (vec && n != veclen)
2090	/* new iovec entry */
2091	vec[n].mv_basesiv_base = (void *)p, vec[n].mv_lensiv_len = (su_ioveclen_t)len;
2092	else
2093	vec = NULL((void*)0);
2094
2095	p += len; n++;
2096	}
2097	else {
2098	/* extend old entry */
2099	len = h->sh_lensh_common->h_len;
2100	if (vec)
2101	vec[n-1].mv_lensiv_len += (su_ioveclen_t)len;
2102	p += len;
2103	}
2104
2105	total += len;
2106	}
2107
2108	msg->m_size = total;
2109
2110	return n;
2111	}
2112
2113	/** Insert a header to existing header chain.
2114	*
2115	* Headers are either inserted just before the payload, or after the first
2116	* line, depending on their type.
2117	*
2118	* @param[in] msg message object
2119	* @param[in,out] pub public message structure
2120	* @param prepend if true, add before same type of headers (instead after them)
2121	* @param head head of chain
2122	* @param h header to insert
2123	*
2124	*/
2125	static
2126	void msg_insert_chain(msg_t *msg,
2127	msg_pub_t *pub,
2128	int prepend,
2129	msg_header_t **head,
2130	msg_header_t *h)
2131	{
2132	msg_mclass_t const *mc;
2133	msg_header_t **hh;
2134	msg_header_t **separator;
2135	msg_header_t **payload;
2136
2137	assert(msg && pub && head && h)((msg && pub && head && h) ? (void) ( 0) : __assert_fail ("msg && pub && head && h" , "msg_parser.c", 2137, __PRETTY_FUNCTION__));
2138
2139	mc = msg->m_class;
2140	separator = (msg_header_t *)((char )pub + mc->mc_separator->hr_offset);
2141	payload = (msg_header_t *)((char )pub + mc->mc_payload->hr_offset);
2142
2143	if (msg_is_request(h)) {
2144	if (pub->msg_status)
2145	pub->msg_status = NULL((void*)0);
2146	hh = head;
2147	}
2148	else if (msg_is_status(h)) {
2149	if (pub->msg_request)
2150	pub->msg_request = NULL((void*)0);
2151	hh = head;
2152	}
2153	else if (msg_is_payload(h)) {
2154	/* Append */
2155	hh = msg_chain_tail(msg);
2156	}
2157	else if (prepend) {
2158	if (!msg_is_request(head) && !msg_is_status(head))
2159	hh = head;
2160	else
2161	hh = &((*head)->sh_succsh_common->h_succ);
2162	}
2163	/* Append headers before separator or payload */
2164	else if (separator && (separator)->sh_prevsh_common->h_prev)
2165	hh = (*separator)->sh_prevsh_common->h_prev;
2166	else if (payload && (payload)->sh_prevsh_common->h_prev)
2167	hh = (*payload)->sh_prevsh_common->h_prev;
2168	else
2169	hh = msg_chain_tail(msg);
2170
2171	msg_insert_here_in_chain(msg, hh, h);
2172	}
2173
2174	/** Insert one or more message header to the chain.
2175	*
2176	* The function msg_insert_here_in_chain() appends message header to the
2177	* chain of headers after the given header.
2178	*
2179	* @param msg message
2180	* @param prev pointer to h_succ of previous fragment in the list
2181	* @param h header to be inserted.
2182	*
2183	* @return The pointer to the last header inserted.
2184	*/
2185	static
2186	void msg_insert_here_in_chain(msg_t *msg,
2187	msg_header_t **prev,
2188	msg_header_t *h)
2189	{
2190	if (h) {
2191	msg_header_t last, next;
2192	assert(h->sh_prev == NULL)((h->sh_common->h_prev == ((void)0)) ? (void) (0) : __assert_fail ("h->sh_common->h_prev == ((void)0)", "msg_parser.c", 2192, __PRETTY_FUNCTION__));
2193	assert(prev)((prev) ? (void) (0) : __assert_fail ("prev", "msg_parser.c", 2193, __PRETTY_FUNCTION__));
2194	assert(!msg_chain_errors(h))((!msg_chain_errors(h)) ? (void) (0) : __assert_fail ("!msg_chain_errors(h)" , "msg_parser.c", 2194, __PRETTY_FUNCTION__));
2195
2196	for (last = h; last->sh_succsh_common->h_succ; last = last->sh_succsh_common->h_succ)
2197	;
2198
2199	last->sh_succsh_common->h_succ = next = *prev;
2200	*prev = h;
2201	h->sh_prevsh_common->h_prev = prev;
2202	if (next)
2203	next->sh_prevsh_common->h_prev = &last->sh_succsh_common->h_succ;
2204	else
2205	msg->m_tail = &last->sh_succsh_common->h_succ;
2206
2207	assert(msg->m_chain && msg_chain_errors(msg->m_chain) == 0)((msg->m_chain && msg_chain_errors(msg->m_chain ) == 0) ? (void) (0) : __assert_fail ("msg->m_chain && msg_chain_errors(msg->m_chain) == 0" , "msg_parser.c", 2207, __PRETTY_FUNCTION__));
2208	}
2209	}
2210
2211	/**
2212	* Remove a message from header chain.
2213	*
2214	* The function @c msg_chain_remove() removes a message header from the header
2215	* chain.
2216	*
2217	* @param msg pointer to the message
2218	* @param h pointer to the header in the list to be removed
2219	*
2220	* @return The pointer to the header just removed.
2221	*/
2222	su_inlinestatic inline
2223	msg_header_t msg_chain_remove(msg_t msg, msg_header_t *h)
2224	{
2225	if (h) {
2226	if (h->sh_prevsh_common->h_prev) {
2227	assert(h->sh_prev == h)((h->sh_common->h_prev == h) ? (void) (0) : __assert_fail ("*h->sh_common->h_prev == h", "msg_parser.c", 2227, __PRETTY_FUNCTION__ ));
2228	assert(h->sh_succ == NULL \|\| h->sh_succ->sh_prev == &h->sh_succ)((h->sh_common->h_succ == ((void)0) \|\| h->sh_common ->h_succ->sh_common->h_prev == &h->sh_common-> h_succ) ? (void) (0) : __assert_fail ("h->sh_common->h_succ == ((void)0) \|\| h->sh_common->h_succ->sh_common->h_prev == &h->sh_common->h_succ" , "msg_parser.c", 2228, __PRETTY_FUNCTION__));
2229
2230	*h->sh_prevsh_common->h_prev = h->sh_succsh_common->h_succ;
2231	}
2232
2233	if (h->sh_succsh_common->h_succ)
2234	h->sh_succsh_common->h_succ->sh_prevsh_common->h_prev = h->sh_prevsh_common->h_prev;
2235	else if (msg && h->sh_prevsh_common->h_prev)
2236	msg->m_tail = h->sh_prevsh_common->h_prev;
2237
2238	h->sh_succsh_common->h_succ = NULL((void)0); h->sh_prevsh_common->h_prev = NULL((void)0);
2239
2240	if (msg)
2241	assert(msg_chain_errors(msg->m_chain) == 0)((msg_chain_errors(msg->m_chain) == 0) ? (void) (0) : __assert_fail ("msg_chain_errors(msg->m_chain) == 0", "msg_parser.c", 2241 , __PRETTY_FUNCTION__));
2242	}
2243	return h;
2244	}
2245
2246	#ifndef NDEBUG
2247	/**Check if header chain contains any loops.
2248	*
2249	* @return
2250	* Return 0 if no loop, -1 otherwise.
2251	*/
2252	static
2253	int msg_chain_loop(msg_header_t const *h)
2254	{
2255	msg_header_t const *h2;
2256
2257	if (!h) return 0;
2258
2259	for (h2 = h->sh_succsh_common->h_succ; h && h2 && h2->sh_succsh_common->h_succ; h = h->sh_succsh_common->h_succ) {
2260	if (h == h2 \|\| h == h2->sh_succsh_common->h_succ)
2261	return 1;
2262
2263	h2 = h2->sh_succsh_common->h_succ->sh_succsh_common->h_succ;
2264
2265	if (h == h2)
2266	return 1;
2267	}
2268
2269	return 0;
2270	}
2271
2272	/** Check header chain consistency.
2273	*
2274	* @return
2275	* Return 0 if consistent, number of errors otherwise.
2276	*/
2277	static
2278	int msg_chain_errors(msg_header_t const *h)
2279	{
2280	if (msg_chain_loop(h))
2281	return -1;
2282
2283	for (; h; h = h->sh_succsh_common->h_succ) {
2284	if (h->sh_succsh_common->h_succ && h->sh_succsh_common->h_succ->sh_prevsh_common->h_prev != &h->sh_succsh_common->h_succ)
2285	return -1;
2286	if (h->sh_prevsh_common->h_prev && h != (*h->sh_prevsh_common->h_prev))
2287	return -1;
2288	}
2289
2290	return 0;
2291	}
2292	#endif
2293
2294	/* ====================================================================== */
2295	/* Handling message structure - allocating, adding and removing headers */
2296
2297	/** Allocate a header structure
2298	*
2299	* The msg_header_alloc() function allocates a generic MO header structure
2300	* and returns a pointer to it.
2301	*
2302	* @param home memory home
2303	* @param hc header class
2304	* @param extra amount of extra memory to be allocated after header structure
2305	*
2306	* @return
2307	* A pointer to the newly created header object, or @c NULL upon an error.
2308	*/
2309	msg_header_t msg_header_alloc(su_home_t home,
2310	msg_hclass_t *hc,
2311	isize_t extra)
2312	{
2313	isize_t size = hc->hc_size;
2314	msg_header_t *h = su_alloc(home, size + extra);
2315
2316	if (h) {
2317	memset(h, 0, size);
2318	h->sh_classsh_common->h_class = hc;
2319	}
2320
2321	return h;
2322	}
2323
2324	/**Add a (list of) header(s) to the header structure and fragment chain.
2325	*
2326	* The function @c msg_header_add() adds a header or list of headers into
2327	* the given place within the message structure. It also inserts the headers
2328	* into the the message fragment chain, if it exists.
2329	*
2330	* If the header is a prepend header, the new header is inserted before
2331	* existing headers of the same class. If the header is an append header,
2332	* the new header is inserted after existing headers of the same class. If
2333	* the header is a singleton, existing headers of the same class are
2334	* removed. If the header is a list header, the values in the new header are
2335	* added to the existing list.
2336	*
2337	* @param msg message owning the fragment chain
2338	* @param pub public message structure
2339	* @param hh place in message structure to which header is added
2340	* @param h list of header(s) to be added
2341	*/
2342	int msg_header_add(msg_t *msg,
2343	msg_pub_t *pub,
2344	msg_header_t **hh,
2345	msg_header_t *h)
2346	{
2347	msg_header_t *head, old = NULL((void)0), end;
2348
2349	if (msg == NULL((void)0) \|\| h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t )-1) \|\| hh == NULL((void)0))
2350	return -1;
2351	if (pub == NULL((void*)0))
2352	pub = msg->m_object;
2353
2354	head = _msg_chain_head(msg);
2355
2356	if (*head) {
2357	msg_header_t sh, *prev;
2358
2359	for (sh = h, prev = NULL((void*)0); sh; sh = sh->sh_nextsh_header_next->shn_next) {
2360	sh->sh_succsh_common->h_succ = sh->sh_nextsh_header_next->shn_next;
2361	sh->sh_prevsh_common->h_prev = prev;
2362	prev = &sh->sh_succsh_common->h_succ;
2363	}
2364	}
2365
2366	switch (h->sh_classsh_common->h_class->hc_kind) {
2367	case msg_kind_single:
2368	case msg_kind_list:
2369	old = (*hh);
2370	break;
2371	case msg_kind_append:
2372	case msg_kind_apndlist:
2373	while (*hh)
2374	hh = &(*hh)->sh_nextsh_header_next->shn_next;
2375	break;
2376	case msg_kind_prepend:
2377	for (end = h; end->sh_nextsh_header_next->shn_next; end = end->sh_nextsh_header_next->shn_next)
2378	;
2379	end->sh_nextsh_header_next->shn_next = *hh;
2380	}
2381
2382	if (*head) {
2383	/* Insert into existing fragment chain */
2384	msg_insert_chain(msg, pub, msg_is_prepend(h), head, h);
2385
2386	/* Remove replaced fragment */
2387	if (old)
2388	msg_chain_remove(msg, old);
2389	}
2390
2391	/* Insert into header list */
2392	*hh = h;
2393
2394	return 0;
2395	}
2396
2397	/**Prepend a (list of) header(s) to the header structure and fragment chain.
2398	*
2399	* The function @c msg_header_prepend() adds a header or list of headers into
2400	* the given place within the message structure. It also inserts the headers
2401	* into the the message fragment chain, if it exists.
2402	*
2403	* Unlike msg_header_add(), msg_header_prepend() always inserts header @a h
2404	* before other headers of the same class. If the header is a singleton,
2405	* existing headers of the same class are removed. If the header is a list
2406	* header, the values in the new header are prepended to the existing list.
2407	*
2408	* @param msg message owning the fragment chain
2409	* @param pub public message structure
2410	* @param hh place in message structure to which header is added
2411	* @param h list of header(s) to be added
2412	*/
2413	int msg_header_prepend(msg_t *msg,
2414	msg_pub_t *pub,
2415	msg_header_t **hh,
2416	msg_header_t *h)
2417	{
2418	msg_header_t *head, old = NULL((void)0), end;
2419
2420	assert(msg && pub)((msg && pub) ? (void) (0) : __assert_fail ("msg && pub" , "msg_parser.c", 2420, __PRETTY_FUNCTION__));
2421
2422	if (msg == NULL((void)0) \|\| h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t )-1) \|\| hh == NULL((void)0))
2423	return -1;
2424	if (pub == NULL((void*)0))
2425	pub = msg->m_object;
2426
2427	head = _msg_chain_head(msg);
2428
2429	if (*head) {
2430	msg_header_t sh, *prev;
2431
2432	for (sh = h, prev = NULL((void*)0); sh; sh = sh->sh_nextsh_header_next->shn_next) {
2433	sh->sh_succsh_common->h_succ = sh->sh_nextsh_header_next->shn_next;
2434	sh->sh_prevsh_common->h_prev = prev;
2435	prev = &sh->sh_succsh_common->h_succ;
2436	}
2437	}
2438
2439	switch (h->sh_classsh_common->h_class->hc_kind) {
2440	case msg_kind_single:
2441	case msg_kind_list:
2442	old = (*hh);
2443	break;
2444	case msg_kind_append:
2445	case msg_kind_apndlist:
2446	case msg_kind_prepend:
2447	for (end = h; end->sh_nextsh_header_next->shn_next; end = end->sh_nextsh_header_next->shn_next)
2448	;
2449	end->sh_nextsh_header_next->shn_next = *hh;
2450	break;
2451	}
2452
2453	if (*head) {
2454	/* Insert into existing fragment chain */
2455	msg_insert_chain(msg, pub, 1, head, h);
2456
2457	/* Remove replaced fragment */
2458	if (old)
2459	msg_chain_remove(msg, old);
2460	}
2461
2462	/* Insert into header list */
2463	*hh = h;
2464
2465	return 0;
2466	}
2467
2468
2469	/** Find place to insert header of the class @a hc. */
2470	msg_header_t **
2471	msg_hclass_offset(msg_mclass_t const mc, msg_pub_t const mo, msg_hclass_t *hc)
2472	{
2473	assert(mc && hc)((mc && hc) ? (void) (0) : __assert_fail ("mc && hc" , "msg_parser.c", 2473, __PRETTY_FUNCTION__));
2474
2475	if (mc == NULL((void)0) \|\| hc == NULL((void)0))
2476	return NULL((void*)0);
2477
2478	if (hc->hc_hash > 0) {
2479	unsigned j, N = mc->mc_hash_size;
2480	for (j = hc->hc_hash % N; mc->mc_hash[j].hr_class; j = (j + 1) % N)
2481	if (mc->mc_hash[j].hr_class == hc) {
2482	return (msg_header_t *)((char )mo + mc->mc_hash[j].hr_offset);
2483	}
2484	} else {
2485	/* Header has no name. */
2486	if (hc->hc_hash == mc->mc_request[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_request[0].hr_offset);
2487	if (hc->hc_hash == mc->mc_status[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_status[0].hr_offset);
2488	if (hc->hc_hash == mc->mc_separator[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_separator[0].hr_offset);
2489	if (hc->hc_hash == mc->mc_payload[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_payload[0].hr_offset);
2490	if (hc->hc_hash == mc->mc_unknown[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_unknown[0].hr_offset);
2491	if (hc->hc_hash == mc->mc_error[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_error[0].hr_offset);
2492	if (hc->hc_hash == mc->mc_multipart[0].hr_class->hc_hash) return (msg_header_t *)((char )mo + mc->mc_multipart[0].hr_offset);
2493	}
2494
2495	return NULL((void*)0);
2496	}
2497
2498	/** Append a parsed header object into the message structure */
2499	su_inlinestatic inline void
2500	append_parsed(msg_t msg, msg_pub_t mo, msg_href_t const hr, msg_header_t h,
2501	int always_into_chain)
2502	{
2503	msg_header_t **hh;
2504
2505	assert(msg)((msg) ? (void) (0) : __assert_fail ("msg", "msg_parser.c", 2505 , __PRETTY_FUNCTION__)); assert(hr->hr_offset)((hr->hr_offset) ? (void) (0) : __assert_fail ("hr->hr_offset" , "msg_parser.c", 2505, __PRETTY_FUNCTION__));
2506
2507	hh = (msg_header_t *)((char )mo + hr->hr_offset);
2508
2509	if (msg->m_chain \|\| always_into_chain)
2510	msg_insert_here_in_chain(msg, msg_chain_tail(msg), h);
2511
2512	if (*hh && msg_is_single(h)) {
2513	/* If there is multiple instances of single headers,
2514	put the extra headers into the list of erroneous headers */
2515	msg_error_t **e;
2516
2517	for (e = &mo->msg_error; e; e = &(e)->er_next)
2518	;
2519	e = (msg_error_t )h;
2520
2521	msg->m_extract_err \|= hr->hr_flags;
2522	if (hr->hr_class->hc_critical)
2523	mo->msg_flags \|= MSG_FLG_ERROR;
2524
2525	return;
2526	}
2527
2528	while (*hh)
2529	hh = &(*hh)->sh_nextsh_header_next->shn_next;
2530	*hh = h;
2531	}
2532
2533	static int _msg_header_add_list_items(msg_t *msg,
2534	msg_header_t **hh,
2535	msg_header_t const *src);
2536
2537	/**Duplicate and add a (list of) header(s) to the message.
2538	*
2539	* The function @c msg_header_add_dup() duplicates and adds a (list of)
2540	* header(s) into a message structure.
2541	*
2542	* When inserting headers into the fragment chain, a request (or status) is
2543	* inserted first and replaces the existing request (or status). Other
2544	* headers are inserted after the request or status.
2545	*
2546	* If the header is a singleton, existing headers with the same class are
2547	* removed.
2548	*
2549	* @param msg message owning the fragment chain
2550	* @param pub public message structure to which header is added
2551	* @param src list of header(s) to be added
2552	*/
2553	int msg_header_add_dup(msg_t *msg,
2554	msg_pub_t *pub,
2555	msg_header_t const *src)
2556	{
2557	msg_header_t h, hh = NULL((void)0);
2558	msg_hclass_t hc = NULL((void)0);
2559
2560	if (msg == NULL((void*)0))
2561	return -1;
2562	if (src == NULL((void)0) \|\| src == MSG_HEADER_NONE((msg_header_t )-1))
2563	return 0;
2564	if (pub == NULL((void*)0))
2565	pub = msg->m_object;
2566
2567	for ( ;src; src = src->sh_nextsh_header_next->shn_next) {
2568	assert(src->sh_class)((src->sh_common->h_class) ? (void) (0) : __assert_fail ("src->sh_common->h_class", "msg_parser.c", 2568, __PRETTY_FUNCTION__ ));
2569
2570	if (!src->sh_classsh_common->h_class)
2571	return -1;
2572
2573	if (hc != src->sh_classsh_common->h_class)
2574	hh = msg_hclass_offset(msg->m_class, pub, hc = src->sh_classsh_common->h_class);
2575
2576	if (hh == NULL((void*)0))
2577	return -1;
2578
2579	if (!*hh \|\| hc->hc_kind != msg_kind_list) {
2580	int size = hc->hc_size;
2581	isize_t xtra = hc->hc_dxtra(src, size) - size;
2582	char *end;
2583
2584	if (!(h = msg_header_alloc(msg_home(msg)((su_home_t*)(msg)), hc, xtra)))
2585	return -1; /* error */
2586
2587	if (!(end = hc->hc_dup_one(h, src, (char *)h + size, xtra)))
2588	return -1; /* error */
2589
2590	if (hc->hc_update)
2591	msg_header_update_params(h->sh_common, 0);
2592
2593	assert(end == (char )h + size + xtra)((end == (char )h + size + xtra) ? (void) (0) : __assert_fail ("end == (char *)h + size + xtra", "msg_parser.c", 2593, __PRETTY_FUNCTION__ ));
2594
2595	if (msg_header_add(msg, pub, hh, h) < 0)
2596	return -1;
2597
2598	hh = &h->sh_nextsh_header_next->shn_next;
2599	}
2600	else {
2601	if (_msg_header_add_list_items(msg, hh, src) < 0)
2602	break;
2603	}
2604	}
2605
2606	if (src)
2607	return -1;
2608
2609	return 0;
2610	}
2611
2612	/**Duplicate a header as a given type and add the duplicate into message.
2613	*
2614	* The function @c msg_header_add_dup_as() duplicates a header as a instance
2615	* of the given header class. It adds the new copy into the message.
2616	*
2617	* When inserting headers into the fragment chain, a request (or status) is
2618	* inserted first and replaces the existing request (or status). Other
2619	* headers are inserted after the request or status.
2620	*
2621	* If the header is a singleton, existing headers with the same class are
2622	* removed.
2623	*
2624	* @param msg message owning the fragment chain
2625	* @param pub public message structure to which header is added
2626	* @param hc header class for header target type
2627	* @param src list of header(s) to be duplicated and added
2628	*/
2629	int msg_header_add_dup_as(msg_t *msg,
2630	msg_pub_t *pub,
2631	msg_hclass_t *hc,
2632	msg_header_t const *src)
2633	{
2634	if (msg == NULL((void)0) \|\| hc == NULL((void)0))
2635	return -1;
2636	if (src == NULL((void)0) \|\| src == MSG_HEADER_NONE((msg_header_t )-1))
2637	return 0;
2638	if (pub == NULL((void*)0))
2639	pub = msg->m_object;
2640
2641	return _msg_header_add_dup_as(msg, pub, hc, src);
2642	}
2643
2644	/** Duplicate and add a (list of) header to a message */
2645	static
2646	int _msg_header_add_dup_as(msg_t *msg,
2647	msg_pub_t *pub,
2648	msg_hclass_t *hc,
2649	msg_header_t const *src)
2650	{
2651	msg_header_t h, *hh;
2652
2653	hh = msg_hclass_offset(msg->m_class, pub, hc);
2654
2655	if (hh == NULL((void*)0))
2656	return -1;
2657
2658	if (*hh && hc->hc_kind == msg_kind_list)
2659	return _msg_header_add_list_items(msg, hh, src);
2660
2661	if (!(h = msg_header_dup_as(msg_home(msg)((su_home_t*)(msg)), hc, src)))
2662	return -1;
2663
2664	return msg_header_add(msg, pub, hh, h);
2665	}
2666
2667	/* Add list items */
2668	static int _msg_header_add_list_items(msg_t *msg,
2669	msg_header_t **hh,
2670	msg_header_t const *src)
2671	{
2672	msg_header_t h = hh;
2673	msg_param_t **s = msg_header_params(src->sh_common);
2674
2675	if (!s \|\| !*s)
2676	return 0;
2677
2678	msg_fragment_clear(h->sh_common);
2679
2680	/* Remove empty headers */
2681	for (hh = &h->sh_nextsh_header_next->shn_next; hh; hh = (*hh)->sh_nextsh_header_next->shn_next)
2682	msg_chain_remove(msg, *hh);
2683
2684	if (msg_header_join_items(msg_home(msg)((su_home_t*)(msg)), h->sh_common, src->sh_common, 1)
2685	< 0)
2686	return -1;
2687
2688	return 0;
2689	}
2690
2691	/** Parse a string as a given header field and add result to the message. */
2692	int msg_header_add_make(msg_t *msg,
2693	msg_pub_t *pub,
2694	msg_hclass_t *hc,
2695	char const *s)
2696	{
2697	msg_header_t h, *hh;
2698
2699	if (msg == NULL((void*)0))
2700	return -1;
2701	if (pub == NULL((void*)0))
2702	pub = msg->m_object;
2703
2704	hh = msg_hclass_offset(msg->m_class, pub, hc);
2705
2706	if (hh == NULL((void*)0))
2707	return -1;
2708
2709	if (!s)
2710	return 0;
2711
2712	if (*hh && hc->hc_kind == msg_kind_list) {
2713	/* Add list items */
2714	msg_header_t h = hh;
2715	msg_param_t **d;
2716	char *s0;
2717
2718	skip_lws(&s)((&s) += span_lws((&s)));
2719
2720	d = msg_header_params(h->sh_common); assert(d)((d) ? (void) (0) : __assert_fail ("d", "msg_parser.c", 2720, __PRETTY_FUNCTION__));
2721
2722	msg_fragment_clear(h->sh_common);
2723
2724	/* Remove empty headers */
2725	for (hh = &h->sh_nextsh_header_next->shn_next; hh; hh = (*hh)->sh_nextsh_header_next->shn_next)
2726	msg_chain_remove(msg, *hh);
2727
2728	s0 = su_strdup(msg_home(msg)((su_home_t*)(msg)), s);
2729
2730	if (!s0 \|\| msg_commalist_d(msg_home(msg)((su_home_t*)(msg)), &s0, d, msg_token_scan) < 0)
2731	return -1;
2732
2733	return 0;
2734	}
2735
2736	if (!(h = msg_header_make(msg_home(msg)((su_home_t*)(msg)), hc, s)))
2737	return -1;
2738
2739	return msg_header_add(msg, pub, hh, h);
2740	}
2741
2742	/** Add formatting result to message.
2743	*
2744	* Parse result from printf-formatted params as a given header field and add
2745	* result to the message.
2746	*
2747	* @NEW_1_12_10
2748	*/
2749	int msg_header_add_format(msg_t *msg,
2750	msg_pub_t *pub,
2751	msg_hclass_t *hc,
2752	char const *fmt,
2753	...)
2754	{
2755	msg_header_t h, *hh;
2756	va_list va;
2757
2758	if (msg == NULL((void*)0))
2759	return -1;
2760	if (pub == NULL((void*)0))
2761	pub = msg->m_object;
2762
2763	hh = msg_hclass_offset(msg->m_class, pub, hc);
2764
2765	if (hh == NULL((void*)0))
2766	return -1;
2767
2768	if (!fmt)
2769	return 0;
2770
2771	va_start(va, fmt)__builtin_va_start(va, fmt);
2772	h = msg_header_vformat(msg_home(msg)((su_home_t*)(msg)), hc, fmt, va);
2773	va_end(va)__builtin_va_end(va);
2774
2775	if (!h)
2776	return -1;
2777
2778	return msg_header_add(msg, pub, hh, h);
2779	}
2780
2781
2782	/**Add string contents to message.
2783	*
2784	* Duplicate a string containing headers (or a message body, if the string
2785	* starts with linefeed), parse it and add resulting header objects to the
2786	* message object.
2787	*
2788	* @param msg message object
2789	* @param pub message header structure where heades are added (may be NULL)
2790	* @param str string to be copied and parsed (not modified, may be NULL)
2791	*
2792	* @retval 0 when succesful
2793	* @retval -1 upon an error
2794	*/
2795	int msg_header_add_str(msg_t *msg,
2796	msg_pub_t *pub,
2797	char const *str)
2798	{
2799	char *s;
2800
2801	if (!msg)
2802	return -1;
2803	if (!str)
2804	return 0;
2805
2806	s = su_strdup(msg_home(msg)((su_home_t*)(msg)), str);
2807
2808	if (s == NULL((void*)0))
2809	return -1;
2810
2811	return msg_header_parse_str(msg, pub, s);
2812	}
2813
2814	/**Add string to message.
2815	*
2816	* Parse a string containing headers (or a message body, if the string
2817	* starts with linefeed) and add resulting header objects to the message
2818	* object.
2819	*
2820	* @param msg message object
2821	* @param pub message header structure where heades are added (may be NULL)
2822	* @param s string to be parsed (and modified)
2823	*
2824	* @retval 0 when succesful
2825	* @retval -1 upon an error
2826	*
2827	* @sa msg_header_add_str(), url_headers_as_string()
2828	*
2829	* @since New in @VERSION_1_12_4.
2830	*/
2831	int msg_header_parse_str(msg_t *msg,
2832	msg_pub_t *pub,
2833	char *s)
2834	{
2835	if (!msg)
2836	return -1;
2837
2838	if (pub == NULL((void*)0))
2839	pub = msg->m_object;
2840
2841	if (s) {
2842	size_t ssiz = strlen(s), used = 0;
2843	ssize_t n = 1;
2844
2845	while (ssiz > used) {
2846	if (IS_CRLF(s[used])((s[used]) == '\r' \|\| (s[used]) == '\n'))
2847	break;
2848	n = msg_extract_header(msg, pub, s + used, ssiz - used, 1);
2849	if (n <= 0)
2850	break;
2851	used += n;
2852	}
2853
2854	if (n > 0 && ssiz > used) {
2855	used += CRLF_TEST(s + used)((s + used)[0] == '\r' ? ((s + used)[1] == '\n') + 1 : (s + used )[0] =='\n');
2856	if (ssiz > used)
2857	msg_extract_payload(msg, pub, NULL((void*)0), ssiz - used,
2858	s + used, ssiz - used, 1);
2859	}
2860
2861	if (n <= 0)
2862	return -1;
2863	}
2864
2865	return 0;
2866	}
2867
2868	/** Insert a (list of) header(s) to the fragment chain.
2869	*
2870	* The function @c msg_header_insert() inserts header or list of headers
2871	* into a message structure. It also inserts them into the the message
2872	* fragment chain, if it exists.
2873	*
2874	* When inserting headers into the fragment chain, a request (or status) is
2875	* inserted first and replaces the existing request (or status). Other
2876	* headers are inserted after the request or status.
2877	*
2878	* If there can be only one header field of this type (hc_kind is
2879	* msg_kind_single), existing header objects with the same class are
2880	* removed.
2881	*
2882	* @param msg message object owning the fragment chain
2883	* @param pub public message structure to which header is added
2884	* @param h list of header(s) to be added
2885	*/
2886	int msg_header_insert(msg_t msg, msg_pub_t pub, msg_header_t *h)
2887	{
2888	msg_header_t **hh;
2889
2890	assert(msg)((msg) ? (void) (0) : __assert_fail ("msg", "msg_parser.c", 2890 , __PRETTY_FUNCTION__));
2891
2892	if (msg == NULL((void)0) \|\| h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t *)-1) \|\|
2893	h->sh_classsh_common->h_class == NULL((void*)0))
2894	return -1;
2895	if (pub == NULL((void*)0))
2896	pub = msg->m_object;
2897
2898	hh = msg_hclass_offset(msg->m_class, pub, h->sh_classsh_common->h_class);
2899
2900	return msg_header_add(msg, pub, hh, h);
2901	}
2902
2903	/**Remove a header from the header structure and fragment chain.
2904	*
2905	* The function @c msg_header_remove() removes a header from a message
2906	* structure. It also removes the message from the message fragment chain
2907	* and clears the encoding of other headers objects that share same
2908	* encoding.
2909	*
2910	* @param msg message owning the fragment chain
2911	* @param pub public message structure to which header is added
2912	* @param h header to be removed
2913	*/
2914	int msg_header_remove(msg_t msg, msg_pub_t pub, msg_header_t *h)
2915	{
2916	msg_header_t hh, hh0;
2917
2918	if (msg == NULL((void)0) \|\| h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t *)-1) \|\|
2919	h->sh_classsh_common->h_class == NULL((void*)0))
2920	return -1;
2921	if (pub == NULL((void*)0))
2922	pub = msg->m_object;
2923
2924	/* First, remove from public structure (msg_pub_t) */
2925	hh0 = msg_hclass_offset(msg->m_class, pub, h->sh_classsh_common->h_class);
2926	if (!hh0)
2927	return -1;
2928
2929	for (hh = hh0; hh; hh = &(hh)->sh_nextsh_header_next->shn_next) {
2930	if (*hh == h) {
2931	*hh = h->sh_nextsh_header_next->shn_next;
2932	break;
2933	}
2934	}
2935
2936	if (h->sh_datash_common->h_data) {
2937	void const data = (char )h->sh_datash_common->h_data + h->sh_lensh_common->h_len;
2938	for (hh = hh0; hh; hh = &(hh)->sh_nextsh_header_next->shn_next) {
2939	if (data == (char )(hh)->sh_datash_common->h_data + (*hh)->sh_lensh_common->h_len) {
2940	(hh)->sh_datash_common->h_data = NULL((void)0), (*hh)->sh_lensh_common->h_len = 0;
2941	}
2942	}
2943	}
2944
2945	msg_chain_remove(msg, h);
2946
2947	return 0;
2948	}
2949
2950
2951	/**Remove a header list from the header structure and fragment chain.
2952	*
2953	* The function @c msg_header_remove_all() removes a list of headers from a
2954	* message structure. It also removes the message from the message fragment
2955	* chain and clears the encoding of other headers objects that share same
2956	* encoding.
2957	*
2958	* @param msg message owning the fragment chain
2959	* @param pub public message structure to which header is added
2960	* @param h header list to be removed
2961	*/
2962	int msg_header_remove_all(msg_t msg, msg_pub_t pub, msg_header_t *h)
2963	{
2964	msg_header_t hh, hh0;
2965	void const *data;
2966
2967	if (msg == NULL((void)0) \|\| h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t *)-1) \|\|
2968	h->sh_classsh_common->h_class == NULL((void*)0))
2969	return -1;
2970	if (pub == NULL((void*)0))
2971	pub = msg->m_object;
2972
2973	hh0 = msg_hclass_offset(msg->m_class, pub, h->sh_classsh_common->h_class);
2974	if (!hh0)
2975	return -1;
2976
2977	data = (char *)h->sh_datash_common->h_data + h->sh_lensh_common->h_len;
2978
2979	/* First, remove from public structure (msg_pub_t) */
2980	for (hh = hh0; hh; hh = &(hh)->sh_nextsh_header_next->shn_next) {
2981	if (*hh == h) {
2982	break;
2983	}
2984	if (data && data == (char )(hh)->sh_datash_common->h_data + (*hh)->sh_lensh_common->h_len) {
2985	h->sh_datash_common->h_data = NULL((void*)0), h->sh_lensh_common->h_len = 0;
2986	(hh)->sh_datash_common->h_data = NULL((void)0), (*hh)->sh_lensh_common->h_len = 0;
2987	}
2988	}
2989
2990	/* Remove from header chain */
2991	while (h) {
2992	h->sh_datash_common->h_data = NULL((void*)0), h->sh_lensh_common->h_len = 0;
2993	msg_chain_remove(msg, h);
2994	h = h->sh_nextsh_header_next->shn_next;
2995	}
2996
2997	hh = NULL((void)0);
2998
2999	return 0;
3000	}
3001
3002
3003	/** Replace a header item with a (list of) header(s).
3004	*
3005	* The function @c msg_header_replace() removes a header structure from
3006	* message and replaces it with a new one or a list of headers. It inserts
3007	* the new headers into the the message fragment chain, if it exists.
3008	*
3009	* @param msg message object owning the fragment chain
3010	* @param pub public message structure to which header is added
3011	* @param replaced old header to be removed
3012	* @param h list of header(s) to be added
3013	*/
3014	int msg_header_replace(msg_t *msg,
3015	msg_pub_t *pub,
3016	msg_header_t *replaced,
3017	msg_header_t *h)
3018	{
3019	msg_header_t h0, last, hh, hh0;
3020
3021	if (msg == NULL((void)0) \|\| replaced == NULL((void)0))
3022	return -1;
3023	if (h == NULL((void)0) \|\| h == MSG_HEADER_NONE((msg_header_t )-1) \|\| h->sh_classsh_common->h_class == NULL((void*)0))
3024	return msg_header_remove(msg, pub, replaced);
3025	if (pub == NULL((void*)0))
3026	pub = msg->m_object;
3027
3028	hh = hh0 = msg_hclass_offset(msg->m_class, pub, h->sh_classsh_common->h_class);
3029	if (hh == NULL((void*)0))
3030	return -1;
3031	if (replaced == NULL((void*)0))
3032	return msg_header_add(msg, pub, hh, h);
3033
3034	assert(h->sh_prev == NULL)((h->sh_common->h_prev == ((void)0)) ? (void) (0) : __assert_fail ("h->sh_common->h_prev == ((void)0)", "msg_parser.c", 3034, __PRETTY_FUNCTION__)); /* Must not be in existing chain! */
3035
3036	for (last = h; last->sh_nextsh_header_next->shn_next; last = last->sh_nextsh_header_next->shn_next) {
3037	if ((last->sh_succsh_common->h_succ = last->sh_nextsh_header_next->shn_next))
3038	last->sh_nextsh_header_next->shn_next->sh_prevsh_common->h_prev = &last->sh_succsh_common->h_succ;
3039	}
3040
3041	for (h0 = hh; h0; hh = &h0->sh_nextsh_header_next->shn_next, h0 = hh) {
3042	if (replaced == h0)
3043	break;
3044	}
3045
3046	if (h0 == NULL((void*)0))
3047	return -1;
3048
3049	hh = h; / Replace in list */
3050	last->sh_nextsh_header_next->shn_next = replaced->sh_nextsh_header_next->shn_next;
3051
3052	if (replaced->sh_prevsh_common->h_prev) {
3053	*replaced->sh_prevsh_common->h_prev = h;
3054	h->sh_prevsh_common->h_prev = replaced->sh_prevsh_common->h_prev;
3055	if ((last->sh_succsh_common->h_succ = replaced->sh_succsh_common->h_succ))
3056	last->sh_succsh_common->h_succ->sh_prevsh_common->h_prev = &last->sh_succsh_common->h_succ;
3057	if (msg->m_tail == &replaced->sh_succsh_common->h_succ)
3058	msg->m_tail = &last->sh_succsh_common->h_succ;
3059	}
3060
3061	assert(msg->m_tail != &replaced->sh_succ)((msg->m_tail != &replaced->sh_common->h_succ) ? (void) (0) : __assert_fail ("msg->m_tail != &replaced->sh_common->h_succ" , "msg_parser.c", 3061, __PRETTY_FUNCTION__));
3062
3063	replaced->sh_nextsh_header_next->shn_next = NULL((void*)0);
3064	replaced->sh_prevsh_common->h_prev = NULL((void*)0);
3065	replaced->sh_succsh_common->h_succ = NULL((void*)0);
3066
3067	if (replaced->sh_datash_common->h_data) {
3068	/* Remove cached encoding if it is shared with more than one header fragments */
3069	int cleared = 0;
3070	void const data = (char )replaced->sh_datash_common->h_data + replaced->sh_lensh_common->h_len;
3071
3072	for (hh = hh0; hh; hh = &(hh)->sh_nextsh_header_next->shn_next) {
3073	if (data == (char )(hh)->sh_datash_common->h_data + (*hh)->sh_lensh_common->h_len) {
3074	(hh)->sh_datash_common->h_data = NULL((void)0), (*hh)->sh_lensh_common->h_len = 0, cleared = 1;
3075	}
3076	}
3077
3078	if (cleared)
3079	replaced->sh_datash_common->h_data = NULL((void*)0), replaced->sh_lensh_common->h_len = 0;
3080	}
3081
3082	return 0;
3083	}
3084
3085	/** Free a header structure */
3086	void msg_header_free(su_home_t home, msg_header_t h)
3087	{
3088	su_free(home, h);
3089	}
3090
3091	/** Free a (list of) header structures */
3092	void msg_header_free_all(su_home_t home, msg_header_t h)
3093	{
3094	msg_header_t *h_next;
3095
3096	while (h) {
3097	h_next = h->sh_nextsh_header_next->shn_next;
3098	su_free(home, h);
3099	h = h_next;
3100	}
3101	}