protocols/ipv6/ipv6.cpp

69 	uint16 GetHeaderOffset(net_buffer* buffer, uint32 headerCode = ~0u) const;
93 									net_buffer* buffer, bool lastFragment);
234 IPv6Header::GetHeaderOffset(net_buffer* buffer, uint32 headerCode) const
248 		status_t status = gBufferModule->read(buffer, offset,
268 	buffer->protocol = next;
299 	net_buffer* buffer;
300 	while ((buffer = fFragments.RemoveHead()) != NULL) {
301 		gBufferModule->free(buffer);
307 FragmentPacket::AddFragment(uint16 start, uint16 end, net_buffer* buffer,
337 		gBufferModule->free(buffer);
341 	fIndex = buffer->index;
342 		// adopt the buffer's device index
350 		gBufferModule->remove_header(buffer, previous->fragment.end - start);
355 		gBufferModule->remove_trailer(buffer, end - next->fragment.start);
361 	// We will always keep the last buffer received, so that we can still
367 		buffer->fragment.start = previous->fragment.start;
368 		buffer->fragment.end = end;
370 		status_t status = gBufferModule->merge(buffer, previous, false);
377 		fFragments.InsertBefore(next, buffer);
394 		buffer->fragment.start = start;
395 		buffer->fragment.end = next->fragment.end;
397 		status_t status = gBufferModule->merge(buffer, next, true);
405 		fFragments.InsertBefore(afterNext, buffer);
422 	TRACE("    new fragment: %p, bytes %d-%d", buffer, start, end);
424 	buffer->fragment.start = start;
425 	buffer->fragment.end = end;
426 	fFragments.InsertBefore(next, buffer);
442 /*!	Reassembles the fragments to the specified buffer \a to.
443 	This buffer must have been added via AddFragment() before.
451 	net_buffer* buffer = NULL;
455 		if (buffer != NULL) {
458 				status = gBufferModule->merge(fragment, buffer, false);
459 				buffer = fragment;
461 				status = gBufferModule->merge(buffer, fragment, true);
465 			buffer = fragment;
468 	if (buffer != to)
472 		// reset the buffer's device index
534 		\a _buffer will point to its buffer, otherwise, it will be \c NULL.
541 	net_buffer* buffer = *_buffer;
545 	status = gBufferModule->read(buffer, offset, &fragmentHeader,
584 		gBufferModule->remove_header(buffer, offset);
586 	status = packet->AddFragment(start, end, buffer, lastFragment);
595 		status = packet->Reassemble(buffer);
608 /*!	Fragments the incoming buffer and send all fragments via the specified
613 	net_buffer* buffer, uint32 mtu)
616 		buffer->size, mtu);
618 	NetBufferHeaderReader<IPv6Header> originalHeader(buffer);
624 	uint16 headersLength = originalHeader->GetHeaderOffset(buffer);
627 	uint32 bytesLeft = buffer->size - headersLength;
632 	net_buffer* headerBuffer = gBufferModule->clone(buffer, false);
643 	status = gBufferModule->read(buffer, headersLength, data, bytesLeft);
683 			fragmentBuffer = buffer;
707 			// we don't own the last buffer, so we don't have to free it
725 deliver_multicast(net_protocol_module_info* module, net_buffer* buffer,
728 	sockaddr_in6* multicastAddr = (sockaddr_in6*)buffer->destination;
740 		if (state->FilterAccepts(buffer)) {
742 			module->deliver_data(ipproto, buffer);
751 deliver_multicast(net_protocol_module_info* module, net_buffer* buffer,
760 	if (buffer->interface_address != NULL) {
761 		status = deliver_multicast(module, buffer, deliverToRaw,
762 			buffer->interface_address->interface);
775 			status = deliver_multicast(module, buffer, deliverToRaw, interface);
786 raw_receive_data(net_buffer* buffer)
793 	TRACE("RawReceiveData(%i)", buffer->protocol);
795 	if ((buffer->flags & MSG_MCAST) != 0) {
796 		deliver_multicast(&gIPv6Module, buffer, true);
803 			if (raw->Socket()->protocol == buffer->protocol)
804 				raw->EnqueueClone(buffer);
1246 ip6_select_hoplimit(net_protocol* _protocol, net_buffer* buffer)
1255 	const bool isMulticast = buffer->flags & MSG_MCAST;
1267 	net_buffer* buffer)
1278 		protocolNumber = buffer->protocol;
1281 		buffer, buffer->size);
1283 	sockaddr_in6& source = *(sockaddr_in6*)buffer->source;
1284 	sockaddr_in6& destination = *(sockaddr_in6*)buffer->destination;
1286 	buffer->flags &= ~(MSG_BCAST | MSG_MCAST);
1292 		buffer->flags |= MSG_MCAST;
1294 	uint16 dataLength = buffer->size;
1298 	NetBufferPrepend<ip6_hdr> header(buffer);
1302 	if (buffer->size > 0xffff)
1317 	header->ip6_hlim = ip6_select_hoplimit(protocol, buffer);
1328 			icmpChecksum(buffer);
1333 		uint16 checksum = gBufferModule->checksum(buffer, sizeof(ip6_hdr),
1334 			buffer->size - sizeof(ip6_hdr), false);
1346 	if (buffer->size > mtu) {
1348 		return send_fragments(protocol, route, buffer, mtu);
1351 	return sDatalinkModule->send_routed_data(route, buffer);
1356 ipv6_send_data(net_protocol* _protocol, net_buffer* buffer)
1360 	TRACE_SK(protocol, "SendData(%p [%" B_PRIu32 " bytes])", buffer,
1361 		buffer->size);
1363 	sockaddr_in6* destination = (sockaddr_in6*)buffer->destination;
1375 		sDatalinkModule->put_interface_address(buffer->interface_address);
1376 		buffer->interface_address = address;
1377 			// the buffer takes over ownership of the address
1383 		return sDatalinkModule->send_routed_data(route, buffer);
1386 	return sDatalinkModule->send_data(protocol, sDomain, buffer);
1453 ipv6_receive_data(net_buffer* buffer)
1455 	TRACE("ReceiveData(%p [%" B_PRIu32 " bytes])", buffer, buffer->size);
1457 	NetBufferHeaderReader<IPv6Header> bufferHeader(buffer);
1468 	if (packetLength > buffer->size)
1472 	buffer->flags &= ~(MSG_BCAST | MSG_MCAST);
1478 		buffer->flags |= MSG_MCAST;
1484 				&buffer->interface_address, &matchedAddressType)
1486 				buffer->destination, &buffer->interface_address)) {
1500 		buffer->flags |= matchedAddressType;
1504 	fill_sockaddr_in6((struct sockaddr_in6*)buffer->source, header.Src());
1505 	memcpy(buffer->destination, &destination, sizeof(sockaddr_in6));
1508 	uint16 transportHeaderOffset = header.GetHeaderOffset(buffer);
1509 	uint8 protocol = buffer->protocol;
1512 	status_t status = gBufferModule->trim(buffer, packetLength);
1518 		= header.GetHeaderOffset(buffer, IPPROTO_FRAGMENT);
1523 		status = reassemble_fragments(header, &buffer, fragmentHeaderOffset);
1528 		if (buffer == NULL) {
1529 			// buffer was put into fragment packet
1535 	// tell the buffer to preserve removed ipv6 header - may need it later
1536 	gBufferModule->store_header(buffer);
1539 	gBufferModule->remove_header(buffer, transportHeaderOffset);
1542 	raw_receive_data(buffer);
1550 	if ((buffer->flags & MSG_MCAST) != 0) {
1555 		return deliver_multicast(module, buffer, false);
1558 	return module->receive_data(buffer);
1563 ipv6_deliver_data(net_protocol* _protocol, net_buffer* buffer)
1570 	return protocol->raw->EnqueueClone(buffer);
1591 	net_buffer* buffer, void* msgControl, size_t msgControlLen)
1605 		if (gBufferModule->stored_header_length(buffer)
1608 			if (gBufferModule->restore_header(buffer, 0,
1640 			&((struct sockaddr_in6*)buffer->destination)->sin6_addr,
1642 		if (buffer->interface_address != NULL
1643 			&& buffer->interface_address->interface != NULL)
1644 			pi.ipi6_ifindex = buffer->interface_address->interface->index;