protocols/ipv4/ipv4.cpp

78 									net_buffer* buffer, bool lastFragment);
260 	net_buffer* buffer;
261 	while ((buffer = fFragments.RemoveHead()) != NULL) {
262 		gBufferModule->free(buffer);
268 FragmentPacket::AddFragment(uint16 start, uint16 end, net_buffer* buffer,
298 		gBufferModule->free(buffer);
302 	fIndex = buffer->index;
303 		// adopt the buffer's device index
311 		gBufferModule->remove_header(buffer, previous->fragment.end - start);
316 		gBufferModule->remove_trailer(buffer, end - next->fragment.start);
322 	// We will always keep the last buffer received, so that we can still
328 		buffer->fragment.start = previous->fragment.start;
329 		buffer->fragment.end = end;
331 		status_t status = gBufferModule->merge(buffer, previous, false);
338 		fFragments.InsertBefore(next, buffer);
355 		buffer->fragment.start = start;
356 		buffer->fragment.end = next->fragment.end;
358 		status_t status = gBufferModule->merge(buffer, next, true);
366 		fFragments.InsertBefore(afterNext, buffer);
383 	TRACE("    new fragment: %p, bytes %d-%d", buffer, start, end);
385 	buffer->fragment.start = start;
386 	buffer->fragment.end = end;
387 	fFragments.InsertBefore(next, buffer);
403 /*!	Reassembles the fragments to the specified buffer \a to.
404 	This buffer must have been added via AddFragment() before.
412 	net_buffer* buffer = NULL;
416 		if (buffer != NULL) {
419 				status = gBufferModule->merge(fragment, buffer, false);
420 				buffer = fragment;
422 				status = gBufferModule->merge(buffer, fragment, true);
426 			buffer = fragment;
429 	if (buffer != to)
433 		// reset the buffer's device index
535 		will point to its buffer, otherwise, it will be \c NULL.
541 	net_buffer* buffer = *_buffer;
578 		gBufferModule->remove_header(buffer, header.HeaderLength());
580 	status = packet->AddFragment(start, end, buffer, lastFragment);
589 		status = packet->Reassemble(buffer);
602 /*!	Fragments the incoming buffer and send all fragments via the specified
607 	net_buffer* buffer, uint32 mtu)
610 		buffer->size, mtu);
612 	NetBufferHeaderReader<ipv4_header> originalHeader(buffer);
617 	uint32 bytesLeft = buffer->size - headerLength;
621 	net_buffer* headerBuffer = gBufferModule->split(buffer, headerLength);
655 			fragmentBuffer = gBufferModule->split(buffer, fragmentLength);
658 			fragmentBuffer = buffer;
673 			// we don't own the last buffer, so we don't have to free it
688 status_t ipv4_receive_data(net_buffer* buffer);
691 /*!	Delivers the provided \a buffer to all listeners of this multicast group.
692 	Does not take over ownership of the buffer.
695 deliver_multicast(net_protocol_module_info* module, net_buffer* buffer,
698 	TRACE("deliver_multicast(%p [%" B_PRIu32 " bytes])", buffer, buffer->size);
704 	sockaddr_in* multicastAddr = (sockaddr_in*)buffer->destination;
706 	uint32 index = buffer->index;
707 	if (buffer->interface_address != NULL)
708 		index = buffer->interface_address->interface->index;
720 				|| ipProtocol->socket->protocol != buffer->protocol))
723 		if (state->FilterAccepts(buffer)) {
736 				module->deliver_data(protocol, buffer);
746 /*!	Delivers the buffer to all listening raw sockets without taking ownership of
747 	the provided \a buffer.
751 raw_receive_data(net_buffer* buffer)
758 	TRACE("RawReceiveData(%i)", buffer->protocol);
760 	if ((buffer->flags & MSG_MCAST) != 0) {
762 		// buffer still has the IP header, and it won't in the
766 		return deliver_multicast(&gIPv4Module, buffer, true);
775 		if (raw->Socket()->protocol == buffer->protocol) {
776 			raw->EnqueueClone(buffer);
1475 	net_buffer* buffer)
1485 		buffer, buffer->size);
1487 	sockaddr_in& source = *(sockaddr_in*)buffer->source;
1488 	sockaddr_in& destination = *(sockaddr_in*)buffer->destination;
1496 	buffer->flags &= ~(MSG_BCAST | MSG_MCAST);
1507 		buffer->flags |= MSG_BCAST;
1509 		buffer->flags |= MSG_MCAST;
1514 		NetBufferPrepend<ipv4_header> header(buffer);
1521 		header->total_length = htons(buffer->size);
1525 			header->time_to_live = (buffer->flags & MSG_MCAST) != 0
1528 			header->time_to_live = (buffer->flags & MSG_MCAST) != 0
1532 			? protocol->socket->protocol : buffer->protocol;
1541 		NetBufferHeaderReader<ipv4_header> header(buffer);
1556 	if (buffer->size > 0xffff)
1560 		*IPChecksumField(buffer) = gBufferModule->checksum(buffer, 0,
1564 	if ((buffer->flags & MSG_MCAST) != 0
1568 		net_buffer *loopbackBuffer = gBufferModule->duplicate(buffer);
1594 		", buffer checksum: %" B_PRIu32,
1595 		gBufferModule->checksum(buffer, 0, sizeof(ipv4_header), true),
1596 		gBufferModule->checksum(buffer, 0, buffer->size, true));
1602 	if (buffer->size > mtu) {
1604 		return send_fragments(protocol, route, buffer, mtu);
1607 	return sDatalinkModule->send_routed_data(route, buffer);
1612 ipv4_send_data(net_protocol* _protocol, net_buffer* buffer)
1616 	TRACE_SK(protocol, "SendData(%p [%" B_PRIu32 " bytes])", buffer,
1617 		buffer->size);
1620 		if (buffer->size < sizeof(ipv4_header))
1623 		sockaddr_in* source = (sockaddr_in*)buffer->source;
1624 		sockaddr_in* destination = (sockaddr_in*)buffer->destination;
1627 			offsetof(ipv4_header, source)>(buffer));
1629 			offsetof(ipv4_header, destination)>(buffer));
1634 			((sockaddr_in*)buffer->destination)->sin_addr.s_addr))
1643 		sDatalinkModule->put_interface_address(buffer->interface_address);
1644 		buffer->interface_address = address;
1645 			// the buffer takes over ownership of the address
1651 		return sDatalinkModule->send_routed_data(route, buffer);
1654 	return sDatalinkModule->send_data(protocol, sDomain, buffer);
1722 ipv4_receive_data(net_buffer* buffer)
1724 	TRACE("ipv4_receive_data(%p [%" B_PRIu32 " bytes])", buffer, buffer->size);
1728 	NetBufferHeaderReader<ipv4_header> bufferHeader(buffer);
1740 	if (packetLength > buffer->size
1745 	if (gBufferModule->checksum(buffer, 0, headerLength, true) != 0)
1750 	bool wasMulticast = (buffer->flags & (MSG_BCAST | MSG_MCAST)) != 0;
1752 	buffer->flags &= ~(MSG_BCAST | MSG_MCAST);
1758 		buffer->flags |= MSG_BCAST;
1762 				buffer->destination, &buffer->interface_address))
1765 		buffer->flags |= MSG_MCAST;
1771 				&buffer->interface_address, &matchedAddressType)
1773 				buffer->destination, &buffer->interface_address)) {
1774 			// if the buffer was a link layer multicast, regard it as a
1777 				buffer->flags |= MSG_BCAST;
1782 			buffer->flags |= matchedAddressType;
1787 	fill_sockaddr_in((struct sockaddr_in*)buffer->source, header.source);
1788 	memcpy(buffer->destination, &destination, sizeof(sockaddr_in));
1790 	buffer->protocol = header.protocol;
1798 			sDomain->module->error_reply(NULL, buffer, B_NET_ERROR_UNREACH_HOST,
1806 	status_t status = gBufferModule->trim(buffer, packetLength);
1816 		status = reassemble_fragments(header, &buffer);
1821 		if (buffer == NULL) {
1822 			// buffer was put into fragment packet
1828 	// Since the buffer might have been changed (reassembled fragment)
1833 	bool rawDelivered = raw_receive_data(buffer);
1836 	gBufferModule->store_header(buffer);
1837 	gBufferModule->remove_header(buffer, headerLength);
1841 	net_protocol_module_info* module = receiving_protocol(buffer->protocol);
1845 			sDomain->module->error_reply(NULL, buffer,
1851 	if ((buffer->flags & MSG_MCAST) != 0) {
1856 		deliver_multicast(module, buffer, false);
1857 		gBufferModule->free(buffer);
1861 	return module->receive_data(buffer);
1866 ipv4_deliver_data(net_protocol* _protocol, net_buffer* buffer)
1873 	return protocol->raw->EnqueueClone(buffer);
1878 ipv4_error_received(net_error error, net_buffer* buffer)
1880 	TRACE("  ipv4_error_received(error %d, buffer %p [%" B_PRIu32 " bytes])",
1881 		(int)error, buffer, buffer->size);
1883 	NetBufferHeaderReader<ipv4_header> bufferHeader(buffer);
1894 		|| gBufferModule->checksum(buffer, 0, headerLength, true) != 0)
1897 	// Restore addresses of the original buffer
1901 	buffer->flags &= ~(MSG_BCAST | MSG_MCAST);
1903 	fill_sockaddr_in((struct sockaddr_in*)buffer->source, header.source);
1904 	fill_sockaddr_in((struct sockaddr_in*)buffer->destination,
1908 		buffer->flags |= MSG_BCAST;
1910 		buffer->flags |= MSG_MCAST;
1913 	if (!sDatalinkModule->is_local_address(sDomain, buffer->source, NULL,
1920 	buffer->protocol = header.protocol;
1924 	net_protocol_module_info* protocol = receiving_protocol(buffer->protocol);
1929 	return protocol->error_received(error, buffer);
1948 	net_buffer* buffer, void* msgControl, size_t msgControlLen)
1962 		 	&((struct sockaddr_in*)buffer->destination)->sin_addr,