network/stack/net_buffer.cpp

79 	size_t			offset;		// the net_buffer-wide offset of this node
163 					uint32 offset, size_t bytes);
164 static status_t read_data(net_buffer* _buffer, size_t offset, void* data,
293 	Split(net_buffer* buffer, uint32 offset, net_buffer* newBuffer)
297 		fOffset(offset)
304 		out.Print("net buffer split: buffer: %p, offset: %lu "
340 	AppendCloned(net_buffer* buffer, net_buffer* source, uint32 offset,
345 		fOffset(offset),
354 			"offset: %lu, size: %lu", fBuffer, fSource, fOffset, fSize);
450 	Read(net_buffer* buffer, uint32 offset, void* data, size_t size)
454 		fOffset(offset),
462 		out.Print("net buffer read: buffer: %p, offset: %lu, size: %lu, "
475 	Write(net_buffer* buffer, uint32 offset, const void* data, size_t size)
479 		fOffset(offset),
487 		out.Print("net buffer write: buffer: %p, offset: %lu, size: %lu, "
622 		dprintf("  node %p, offset %lu, used %u, header %u, tail %u, "
623 			"header %p\n", node, node->offset, node->used, node->HeaderSpace(),
678 		if (node->offset != size) {
679 			panic("net_buffer %p: bad node %p offset (%lu vs. %lu)",
680 				buffer, node, node->offset, size);
697 check_buffer_contents(net_buffer* buffer, size_t offset, const void* data,
704 	if (read_data(buffer, offset, bufferData, size) == B_OK) {
710 				"%ld, buffer: %p, offset: %lu, size: %lu", index, buffer,
711 				offset, size);
714 		panic("failed to read from buffer %p, offset: %lu, size: %lu",
715 			buffer, offset, size);
723 check_buffer_contents(net_buffer* buffer, size_t offset, net_buffer* source,
731 		check_buffer_contents(buffer, offset, bufferData, size);
733 		panic("failed to read from source buffer %p, offset: %lu, size: %lu",
954 	node->offset = 0;
1013 get_node_at_offset(net_buffer_private* buffer, size_t offset)
1016 	while (node != NULL && node->offset + node->used <= offset)
1056 	int32 diff = node->offset + node->used - size;
1081 	destination->offset = source->offset;
1128 	buffer->offset = 0;
1282 		node->offset = sourceNode->offset;
1330 /*!	Split the buffer at offset, the header data
1334 split_buffer(net_buffer* from, uint32 offset)
1345 	TRACE(("%d: split_buffer(buffer %p -> %p, offset %" B_PRIu32 ")\n",
1346 		find_thread(NULL), from, buffer, offset));
1348 	if (append_data_from_buffer(buffer, from, offset) == B_OK) {
1349 		if (remove_header(from, offset) == B_OK) {
1352 			T(Split(from, offset, buffer));
1396 		// change offset of all nodes already in the buffer
1403 			node->offset += with->size;
1438 			node->offset = buffer->size;
1464 write_data(net_buffer* _buffer, size_t offset, const void* data, size_t size)
1468 	T(Write(buffer, offset, data, size));
1472 	if (offset + size > buffer->size)
1478 	data_node* node = get_node_at_offset(buffer, offset);
1482 	offset -= node->offset;
1485 		size_t written = min_c(size, node->used - offset);
1487 			if (user_memcpy(node->start + offset, data, written) != B_OK)
1490 			memcpy(node->start + offset, data, written);
1496 		offset = 0;
1511 read_data(net_buffer* _buffer, size_t offset, void* data, size_t size)
1515 	T(Read(buffer, offset, data, size));
1519 	if (offset + size > buffer->size)
1525 	data_node* node = get_node_at_offset(buffer, offset);
1529 	offset -= node->offset;
1532 		size_t bytesRead = min_c(size, node->used - offset);
1534 			if (user_memcpy(data, node->start + offset, bytesRead) != B_OK)
1537 			memcpy(data, node->start + offset, bytesRead);
1543 		offset = 0;
1617 		// correct data offset in all nodes
1619 		size_t offset = 0;
1623 			node->offset = offset;
1624 			offset += node->used;
1638 		// adjust offset of following nodes
1641 			node->offset += size;
1736 			node->offset = buffer->size;
1847 		node->offset = 0;
1858 	// adjust offset of following nodes
1860 		node->offset -= bytes;
1910 	int32 diff = node->used + node->offset - newSize;
1941 append_cloned_data(net_buffer* _buffer, net_buffer* _source, uint32 offset,
1949 	TRACE(("%d: append_cloned_data(buffer %p, source %p, offset = %" B_PRIu32 ", "
1950 		"bytes = %ld)\n", find_thread(NULL), buffer, source, offset, bytes));
1951 	T(AppendCloned(buffer, source, offset, bytes));
1956 	if (source->size < offset + bytes || source->size < offset)
1960 	data_node* node = get_node_at_offset(source, offset);
1975 		if (offset)
1976 			offset -= node->offset;
1978 		clone->offset = buffer->size;
1979 		clone->start = node->start + offset;
1980 		clone->used = min_c(bytes, node->used - offset);
1982 			// take over stored offset
1990 		offset = 0;
2109 restore_header(net_buffer* _buffer, uint32 offset, void* data, size_t bytes)
2113 	if (offset < buffer->stored_header_length) {
2116 			|| offset + bytes > buffer->stored_header_length + buffer->size)
2121 		size_t copied = std::min(bytes, buffer->stored_header_length - offset);
2122 		memcpy(data, node->start + offset - buffer->stored_header_length,
2130 		offset = 0;
2132 		offset -= buffer->stored_header_length;
2134 	return read_data(_buffer, offset, data, bytes);
2144 append_restored_header(net_buffer* buffer, net_buffer* _source, uint32 offset,
2149 	if (offset < source->stored_header_length) {
2152 			|| offset + bytes > source->stored_header_length + source->size)
2157 		size_t appended = std::min(bytes, source->stored_header_length - offset);
2159 			node->start + offset - source->stored_header_length, appended);
2167 		offset = 0;
2169 		offset -= source->stored_header_length;
2171 	return append_cloned_data(buffer, source, offset, bytes);
2179 	\return B_BAD_VALUE if the offset is outside of the buffer's bounds.
2183 direct_access(net_buffer* _buffer, uint32 offset, size_t size,
2190 	//TRACE(("direct_access(buffer %p, offset %ld, size %ld)\n", buffer, offset,
2193 	if (offset + size > buffer->size)
2197 	data_node* node = get_node_at_offset(buffer, offset);
2201 	offset -= node->offset;
2203 	if (size > node->used - offset)
2206 	*_contiguousBuffer = node->start + offset;
2212 checksum_data(net_buffer* _buffer, uint32 offset, size_t size, bool finalize)
2216 	if (offset + size > buffer->size || size == 0)
2220 	data_node* node = get_node_at_offset(buffer, offset);
2224 	offset -= node->offset;
2232 		size_t bytes = min_c(size, node->used - offset);
2233 		if ((offset + node->offset) & 1) {
2234 			// if we're at an uneven offset, we have to swap the checksum
2235 			sum += __swap_int16(compute_checksum(node->start + offset, bytes));
2237 			sum += compute_checksum(node->start + offset, bytes);
2243 		offset = 0;