bsd/netkey/key.c

1016 			struct mbuf *m, *result;
1024 			result = m;
1033 			m_cat(result, m);
1042 			m_cat(result, m);
1048 			m_cat(result, m);
1050 			if (result->m_len < sizeof(struct sadb_msg)) {
1051 				result = m_pullup(result,
1053 				if (result == NULL)
1057 			result->m_pkthdr.len = 0;
1058 			for (m = result; m; m = m->m_next)
1059 				result->m_pkthdr.len += m->m_len;
1060 			mtod(result, struct sadb_msg *)->sadb_msg_len =
1061 				PFKEY_UNIT64(result->m_pkthdr.len);
1063 			if (key_sendup_mbuf(NULL, result,
2002 	struct mbuf *result = NULL, *n;
2049 		if (result)
2050 			m_cat(result, n);
2052 			result = n;
2055 	if ((result->m_flags & M_PKTHDR) != 0) {
2056 		result->m_pkthdr.len = 0;
2057 		for (n = result; n; n = n->m_next)
2058 			result->m_pkthdr.len += n->m_len;
2061 	return result;
2064 	m_freem(result);
2647 	struct mbuf *result = NULL, *m;
2689 	result = m;
2691 	result->m_pkthdr.len = 0;
2692 	for (m = result; m; m = m->m_next)
2693 		result->m_pkthdr.len += m->m_len;
2695 	mtod(result, struct sadb_msg *)->sadb_msg_len =
2696 	    PFKEY_UNIT64(result->m_pkthdr.len);
2701 	if (result)
2702 		m_freem(result);
2850 	struct mbuf *result = NULL, *m;
2855 	result = m;
2862 	m_cat(result, m);
2869 	m_cat(result, m);
2874 	m_cat(result, m);
2876 	if ((result->m_flags & M_PKTHDR) == 0)
2879 	if (result->m_len < sizeof(struct sadb_msg)) {
2880 		result = m_pullup(result, sizeof(struct sadb_msg));
2881 		if (result == NULL)
2885 	result->m_pkthdr.len = 0;
2886 	for (m = result; m; m = m->m_next)
2887 		result->m_pkthdr.len += m->m_len;
2889 	mtod(result, struct sadb_msg *)->sadb_msg_len =
2890 	    PFKEY_UNIT64(result->m_pkthdr.len);
2892 	return result;
2895 	m_freem(result);
2944 	struct mbuf *result = NULL, *m;
2961 	result = m;
2987 	m_cat(result, m);
2997 	m_cat(result, m);
3007 	m_cat(result, m);
3015 	m_cat(result, m);
3017 	if ((result->m_flags & M_PKTHDR) == 0) {
3022 	if (result->m_len < sizeof(struct sadb_msg)) {
3023 		result = m_pullup(result, sizeof(struct sadb_msg));
3024 		if (result == NULL) {
3030 	result->m_pkthdr.len = 0;
3031 	for (m = result; m; m = m->m_next)
3032 		result->m_pkthdr.len += m->m_len;
3034 	mtod(result, struct sadb_msg *)->sadb_msg_len =
3035 	    PFKEY_UNIT64(result->m_pkthdr.len);
3037 	return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
3040 	if (result)
3041 		m_freem(result);
4297 	struct mbuf *result = NULL, *tres = NULL, *m;
4313 	result = m;
4414 	m_cat(result, tres);
4416 	if (result->m_len < sizeof(struct sadb_msg)) {
4417 		result = m_pullup(result, sizeof(struct sadb_msg));
4418 		if (result == NULL)
4422 	result->m_pkthdr.len = 0;
4423 	for (m = result; m; m = m->m_next)
4424 		result->m_pkthdr.len += m->m_len;
4426 	mtod(result, struct sadb_msg *)->sadb_msg_len =
4427 	    PFKEY_UNIT64(result->m_pkthdr.len);
4429 	return result;
4432 	m_freem(result);
4917 			 * The result must be of same reqid in this case.
6509  * it is caller's responsibility to free the result.
6954 	struct mbuf *result = NULL, *m, *n;
7014 		if (!result)
7015 			result = m;
7017 			m_cat(result, m);
7020 	return result;
7023 	if (result)
7024 		m_freem(result);
7206 	struct mbuf *result = NULL, *m;
7262 	result = m;
7271 	m_cat(result, m);
7279 	m_cat(result, m);
7290 		m_cat(result, m);
7348 	m_cat(result, m);
7354 		m_cat(result, m);
7357 	if ((result->m_flags & M_PKTHDR) == 0) {
7362 	if (result->m_len < sizeof(struct sadb_msg)) {
7363 		result = m_pullup(result, sizeof(struct sadb_msg));
7364 		if (result == NULL) {
7370 	result->m_pkthdr.len = 0;
7371 	for (m = result; m; m = m->m_next)
7372 		result->m_pkthdr.len += m->m_len;
7374 	mtod(result, struct sadb_msg *)->sadb_msg_len =
7375 	    PFKEY_UNIT64(result->m_pkthdr.len);
7377 	return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
7380 	if (result)
7381 		m_freem(result);
7854 	struct mbuf *result = NULL, *m;
7875 	result = m;
7883 	m_cat(result, m);
7893 	m_cat(result, m);
7914 	m_cat(result, m);
7924 	m_cat(result, m);
7934 	m_cat(result, m);
7936 	if ((result->m_flags & M_PKTHDR) == 0) {
7941 	if (result->m_len < sizeof(struct sadb_msg)) {
7942 		result = m_pullup(result, sizeof(struct sadb_msg));
7943 		if (result == NULL) {
7949 	result->m_pkthdr.len = 0;
7950 	for (m = result; m; m = m->m_next)
7951 		result->m_pkthdr.len += m->m_len;
7953 	mtod(result, struct sadb_msg *)->sadb_msg_len =
7954 	    PFKEY_UNIT64(result->m_pkthdr.len);
7956 	return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
7959 	if (result)
7960 		m_freem(result);
8907         struct mbuf *result = NULL, *m = NULL;
8913         result = m;
8919         m_cat(result, m);
8927         m_cat(result, m);
8929         if ((result->m_flags & M_PKTHDR) == 0) {
8933         if (result->m_len < sizeof(struct sadb_msg)) {
8934 	        result = m_pullup(result, sizeof(struct sadb_msg));
8935 		if (result == NULL) {
8940         result->m_pkthdr.len = 0;
8941         for (m = result; m; m = m->m_next) {
8942 	        result->m_pkthdr.len += m->m_len;
8945         mtod(result, struct sadb_msg *)->sadb_msg_len =
8946 	  PFKEY_UNIT64(result->m_pkthdr.len);
8948         return result;
8951 	if (result) {
8952 	        m_freem(result);