xref: /haiku/src/system/kernel/messaging/KMessage.cpp (revision 220d04022750f40f8bac8f01fa551211e28d04f2) 
1 /*
2  * Copyright 2005-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
3  * Distributed under the terms of the MIT License.
4  */
5 
6 
7 #include <util/KMessage.h>
8 
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #include <ByteOrder.h>
13 #include <Debug.h>
14 #include <KernelExport.h>
15 #include <TypeConstants.h>
16 
17 
18 #if defined(_BOOT_MODE) || defined(_LOADER_MODE)
19 #	include <util/kernel_cpp.h>
20 #else
21 #	include <new>
22 #endif
23 
24 
25 // TODO: Add a field index using a hash map, so that lookup improves to O(1)
26 // (is now O(n)).
27 
28 
29 // define the PANIC macro
30 #ifndef PANIC
31 #	ifdef _KERNEL_MODE
32 #		define PANIC(str)	panic(str)
33 #	else
34 #		define PANIC(str)	debugger(str)
35 #	endif
36 #endif
37 
38 
39 #if !defined(HAIKU_TARGET_PLATFORM_HAIKU) || defined(_BOOT_MODE) \
40 	|| defined(_LOADER_MODE)
41 #	define MEMALIGN(alignment, size)	malloc(size)
42 	// Built as part of a build tool or the boot or runtime loader.
43 #else
44 #	include <malloc.h>
45 #	define MEMALIGN(alignment, size)	memalign(alignment, size)
46 	// Built as part of the kernel or userland. Using memalign allows use of
47 	// special heap implementations that might otherwise return unaligned
48 	// buffers for debugging purposes.
49 #endif
50 
51 
52 static const int32 kMessageReallocChunkSize = 64;
53 static const size_t kMessageBufferAlignment = 4;
54 
55 const uint32 KMessage::kMessageHeaderMagic = 'kMsG';
56 
57 
58 // #pragma mark - Helper Functions
59 
60 static inline int32
61 _Align(int32 offset)
62 {
63 	return (offset + kMessageBufferAlignment - 1)
64 		& ~(kMessageBufferAlignment - 1);
65 }
66 
67 
68 static inline void*
69 _Align(void* address, int32 offset = 0)
70 {
71 	return (void*)(((addr_t)address + offset + kMessageBufferAlignment - 1)
72 		& ~(kMessageBufferAlignment - 1));
73 }
74 
75 
76 // #pragma mark - FieldValueHeader
77 
78 
79 struct KMessage::FieldValueHeader {
80 	int32		size;
81 
82 	void* Data()
83 	{
84 		return _Align(this, sizeof(FieldValueHeader));
85 	}
86 
87 	FieldValueHeader* NextFieldValueHeader()
88 	{
89 		return (FieldValueHeader*)_Align(Data(), size);
90 	}
91 };
92 
93 
94 // #pragma mark - FieldHeader
95 
96 
97 struct KMessage::FieldHeader {
98 	type_code	type;
99 	int32		elementSize;	// if < 0: non-fixed size
100 	int32		elementCount;
101 	int32		fieldSize;
102 	int16		headerSize;
103 	char		name[1];
104 
105 	void* Data()
106 	{
107 		return (uint8*)this + headerSize;
108 	}
109 
110 	bool HasFixedElementSize()
111 	{
112 		return elementSize >= 0;
113 	}
114 
115 	void* ElementAt(int32 index, int32* size)
116 	{
117 		if (index < 0 || index >= elementCount)
118 			return NULL;
119 		uint8* data = (uint8*)this + headerSize;
120 		if (HasFixedElementSize()) {
121 			*size = elementSize;
122 			return data + elementSize * index;
123 		}
124 		// non-fixed element size: we need to iterate
125 		FieldValueHeader* valueHeader = (FieldValueHeader*)data;
126 		for (int i = 0; i < index; i++)
127 			valueHeader = valueHeader->NextFieldValueHeader();
128 		*size = valueHeader->size;
129 		return valueHeader->Data();
130 	}
131 
132 	FieldHeader* NextFieldHeader()
133 	{
134 		return (FieldHeader*)_Align(this, fieldSize);
135 	}
136 };
137 
138 
139 // #pragma mark - KMessage
140 
141 
142 KMessage::KMessage()
143 	:
144 	fBuffer(NULL),
145 	fBufferCapacity(0),
146 	fFlags(0),
147 	fLastFieldOffset(0)
148 {
149 	Unset();
150 }
151 
152 
153 KMessage::KMessage(uint32 what)
154 	:
155 	fBuffer(NULL),
156 	fBufferCapacity(0),
157 	fFlags(0),
158 	fLastFieldOffset(0)
159 {
160 	Unset();
161 	SetWhat(what);
162 }
163 
164 
165 KMessage::~KMessage()
166 {
167 	Unset();
168 }
169 
170 
171 status_t
172 KMessage::SetTo(uint32 what, uint32 flags)
173 {
174 	// There are no flags interesting in this case at the moment.
175 	Unset();
176 	SetWhat(what);
177 	return B_OK;
178 }
179 
180 
181 status_t
182 KMessage::SetTo(void* buffer, int32 bufferSize, uint32 what, uint32 flags)
183 {
184 	Unset();
185 
186 	if (!buffer)
187 		return B_BAD_VALUE;
188 
189 	if (bufferSize < 0) {
190 		if (!(flags & KMESSAGE_INIT_FROM_BUFFER))
191 			return B_BAD_VALUE;
192 	} else if (bufferSize < (int)sizeof(Header))
193 		return B_BAD_VALUE;
194 
195 	// if read-only, we need to init from the buffer, too
196 	if ((flags & KMESSAGE_READ_ONLY) != 0
197 		&& (flags & KMESSAGE_INIT_FROM_BUFFER) == 0) {
198 		return B_BAD_VALUE;
199 	}
200 
201 	// if not initializing from the given buffer, cloning it doesn't make sense
202 	if ((flags & KMESSAGE_INIT_FROM_BUFFER) == 0
203 		&& (flags & KMESSAGE_CLONE_BUFFER) != 0) {
204 		return B_BAD_VALUE;
205 	}
206 
207 	fBuffer = buffer;
208 	fBufferCapacity = bufferSize;
209 	fFlags = flags;
210 
211 	status_t error = B_OK;
212 	if (flags & KMESSAGE_INIT_FROM_BUFFER)
213 		error = _InitFromBuffer(bufferSize < 0);
214 	else
215 		_InitBuffer(what);
216 
217 	if (error != B_OK)
218 		Unset();
219 
220 	return error;
221 }
222 
223 
224 status_t
225 KMessage::SetTo(const void* buffer, int32 bufferSize, uint32 flags)
226 {
227 	return SetTo(const_cast<void*>(buffer), bufferSize, 0,
228 		KMESSAGE_INIT_FROM_BUFFER | KMESSAGE_READ_ONLY | flags);
229 }
230 
231 
232 void
233 KMessage::Unset()
234 {
235 	// free buffer
236 	if (fBuffer && fBuffer != &fHeader && (fFlags & KMESSAGE_OWNS_BUFFER))
237 		free(fBuffer);
238 	fBuffer = &fHeader;
239 	fBufferCapacity = sizeof(Header);
240 	_InitBuffer(0);
241 }
242 
243 
244 void
245 KMessage::SetWhat(uint32 what)
246 {
247 	_Header()->what = what;
248 }
249 
250 
251 uint32
252 KMessage::What() const
253 {
254 	return _Header()->what;
255 }
256 
257 
258 const void*
259 KMessage::Buffer() const
260 {
261 	return fBuffer;
262 }
263 
264 
265 int32
266 KMessage::BufferCapacity() const
267 {
268 	return fBufferCapacity;
269 }
270 
271 
272 int32
273 KMessage::ContentSize() const
274 {
275 	return _Header()->size;
276 }
277 
278 
279 status_t
280 KMessage::AddField(const char* name, type_code type, int32 elementSize,
281 	KMessageField* field)
282 {
283 	if (!name || type == B_ANY_TYPE)
284 		return B_BAD_VALUE;
285 	KMessageField existingField;
286 	if (FindField(name, &existingField) == B_OK)
287 		return B_NAME_IN_USE;
288 	return _AddField(name, type, elementSize, field);
289 }
290 
291 
292 status_t
293 KMessage::FindField(const char* name, KMessageField* field) const
294 {
295 	return FindField(name, B_ANY_TYPE, field);
296 }
297 
298 
299 status_t
300 KMessage::FindField(const char* name, type_code type,
301 	KMessageField* field) const
302 {
303 	if (!name)
304 		return B_BAD_VALUE;
305 	KMessageField stackField;
306 	if (field)
307 		field->Unset();
308 	else
309 		field = &stackField;
310 	while (GetNextField(field) == B_OK) {
311 		if ((type == B_ANY_TYPE || field->TypeCode() == type)
312 			&& strcmp(name, field->Name()) == 0) {
313 			return B_OK;
314 		}
315 	}
316 	return B_NAME_NOT_FOUND;
317 }
318 
319 
320 status_t
321 KMessage::GetNextField(KMessageField* field) const
322 {
323 	if (!field || (field->Message() != NULL && field->Message() != this))
324 		return B_BAD_VALUE;
325 	FieldHeader* fieldHeader = field->_Header();
326 	FieldHeader* lastField = _LastFieldHeader();
327 	if (!lastField)
328 		return B_NAME_NOT_FOUND;
329 	if (fieldHeader == NULL) {
330 		fieldHeader = _FirstFieldHeader();
331 	} else {
332 		if ((uint8*)fieldHeader < (uint8*)_FirstFieldHeader()
333 			|| (uint8*)fieldHeader > (uint8*)lastField) {
334 			return B_BAD_VALUE;
335 		}
336 		if (fieldHeader == lastField)
337 			return B_NAME_NOT_FOUND;
338 		fieldHeader = fieldHeader->NextFieldHeader();
339 	}
340 	field->SetTo(const_cast<KMessage*>(this), _BufferOffsetFor(fieldHeader));
341 	return B_OK;
342 }
343 
344 
345 bool
346 KMessage::IsEmpty() const
347 {
348 	return _LastFieldHeader() == NULL;
349 }
350 
351 
352 status_t
353 KMessage::AddData(const char* name, type_code type, const void* data,
354 	int32 numBytes, bool isFixedSize)
355 {
356 	if (!name || type == B_ANY_TYPE || !data || numBytes < 0)
357 		return B_BAD_VALUE;
358 	KMessageField field;
359 	if (FindField(name, &field) == B_OK) {
360 		// field with that name already exists: check its type
361 		if (field.TypeCode() != type)
362 			return B_BAD_TYPE;
363 	} else {
364 		// no such field yet: add it
365 		status_t error = _AddField(name, type, (isFixedSize ? numBytes : -1),
366 			&field);
367 		if (error != B_OK)
368 			return error;
369 	}
370 	return _AddFieldData(&field, data, numBytes, 1);
371 }
372 
373 
374 status_t
375 KMessage::AddArray(const char* name, type_code type, const void* data,
376 	int32 elementSize, int32 elementCount)
377 {
378 	if (!name || type == B_ANY_TYPE || !data || elementSize < 0
379 		|| elementCount < 0) {
380 		return B_BAD_VALUE;
381 	}
382 	KMessageField field;
383 	if (FindField(name, &field) == B_OK) {
384 		// field with that name already exists: check its type
385 		if (field.TypeCode() != type)
386 			return B_BAD_TYPE;
387 	} else {
388 		// no such field yet: add it
389 		status_t error = _AddField(name, type, elementSize, &field);
390 		if (error != B_OK)
391 			return error;
392 	}
393 	return _AddFieldData(&field, data, elementSize, elementCount);
394 }
395 
396 
397 status_t
398 KMessage::SetData(const char* name, type_code type, const void* data,
399 	int32 numBytes)
400 {
401 	if (fBuffer != &fHeader && (fFlags & KMESSAGE_READ_ONLY))
402 		return B_NOT_ALLOWED;
403 
404 	KMessageField field;
405 
406 	if (FindField(name, &field) == B_OK) {
407 		// field already known
408 		if (field.TypeCode() != type || !field.HasFixedElementSize()
409 			|| field.ElementSize() != numBytes) {
410 			return B_BAD_VALUE;
411 		}
412 
413 		// if it has an element, just replace its value
414 		if (field.CountElements() > 0) {
415 			const void* element = field.ElementAt(0);
416 			memcpy(const_cast<void*>(element), data, numBytes);
417 			return B_OK;
418 		}
419 	} else {
420 		// no such field yet -- add it
421 		status_t error = _AddField(name, type, numBytes, &field);
422 		if (error != B_OK)
423 			return error;
424 	}
425 
426 	// we've got an empty field -- add the element
427 	return _AddFieldData(&field, data, numBytes, 1);
428 }
429 
430 
431 status_t
432 KMessage::FindData(const char* name, type_code type, const void** data,
433 	int32* numBytes) const
434 {
435 	return FindData(name, type, 0, data, numBytes);
436 }
437 
438 
439 status_t
440 KMessage::FindData(const char* name, type_code type, int32 index,
441 	const void** data, int32* numBytes) const
442 {
443 	if (!name || !data || !numBytes)
444 		return B_BAD_VALUE;
445 	KMessageField field;
446 	status_t error = FindField(name, type, &field);
447 	if (error != B_OK)
448 		return error;
449 	const void* foundData = field.ElementAt(index, numBytes);
450 	if (!foundData)
451 		return B_BAD_INDEX;
452 	if (data)
453 		*data = foundData;
454 	return B_OK;
455 }
456 
457 
458 team_id
459 KMessage::Sender() const
460 {
461 	return _Header()->sender;
462 }
463 
464 
465 int32
466 KMessage::TargetToken() const
467 {
468 	return _Header()->targetToken;
469 }
470 
471 
472 port_id
473 KMessage::ReplyPort() const
474 {
475 	return _Header()->replyPort;
476 }
477 
478 
479 int32
480 KMessage::ReplyToken() const
481 {
482 	return _Header()->replyToken;
483 }
484 
485 
486 void
487 KMessage::SetDeliveryInfo(int32 targetToken, port_id replyPort,
488 	int32 replyToken, team_id senderTeam)
489 {
490 	Header* header = _Header();
491 	header->sender = senderTeam;
492 	header->targetToken = targetToken;
493 	header->replyPort = replyPort;
494 	header->replyToken = replyToken;
495 	header->sender = senderTeam;
496 }
497 
498 
499 #ifndef KMESSAGE_CONTAINER_ONLY
500 
501 
502 status_t
503 KMessage::SendTo(port_id targetPort, int32 targetToken, port_id replyPort,
504 	int32 replyToken, bigtime_t timeout, team_id senderTeam)
505 {
506 	// get the sender team
507 	if (senderTeam < 0) {
508 		thread_info info;
509 		status_t error = get_thread_info(find_thread(NULL), &info);
510 		if (error != B_OK)
511 			return error;
512 
513 		senderTeam = info.team;
514 	}
515 
516 	SetDeliveryInfo(targetToken, replyPort, replyToken, senderTeam);
517 
518 	// send the message
519 	if (timeout < 0)
520 		return write_port(targetPort, 'KMSG', fBuffer, ContentSize());
521 
522 	return write_port_etc(targetPort, 'KMSG', fBuffer, ContentSize(),
523 		B_RELATIVE_TIMEOUT, timeout);
524 }
525 
526 
527 status_t
528 KMessage::SendTo(port_id targetPort, int32 targetToken, KMessage* reply,
529 	bigtime_t deliveryTimeout, bigtime_t replyTimeout, team_id senderTeam)
530 {
531 	// get the team the target port belongs to
532 	port_info portInfo;
533 	status_t error = get_port_info(targetPort, &portInfo);
534 	if (error != B_OK)
535 		return error;
536 	team_id targetTeam = portInfo.team;
537 	// allocate a reply port, if a reply is desired
538 	port_id replyPort = -1;
539 	if (reply) {
540 		// get our team
541 		team_id ourTeam = B_SYSTEM_TEAM;
542 		#ifndef _KERNEL_MODE
543 			if (targetTeam != B_SYSTEM_TEAM) {
544 				thread_info threadInfo;
545 				error = get_thread_info(find_thread(NULL), &threadInfo);
546 				if (error != B_OK)
547 					return error;
548 				ourTeam = threadInfo.team;
549 			}
550 		#endif
551 		// create the port
552 		replyPort = create_port(1, "KMessage reply port");
553 		if (replyPort < 0)
554 			return replyPort;
555 		// If the target team is not our team and not the kernel team either,
556 		// we transfer the ownership of the port to it, so we will not block
557 		if (targetTeam != ourTeam && targetTeam != B_SYSTEM_TEAM)
558 			set_port_owner(replyPort, targetTeam);
559 	}
560 	struct PortDeleter {
561 		PortDeleter(port_id port) : port(port) {}
562 		~PortDeleter()
563 		{
564 			if (port >= 0)
565 				delete_port(port);
566 		}
567 
568 		port_id	port;
569 	} replyPortDeleter(replyPort);
570 	// send the message
571 	error = SendTo(targetPort, targetToken, replyPort, 0,
572 		deliveryTimeout, senderTeam);
573 	if (error != B_OK)
574 		return error;
575 	// get the reply
576 	if (reply)
577 		return reply->ReceiveFrom(replyPort, replyTimeout);
578 	return B_OK;
579 }
580 
581 
582 status_t
583 KMessage::SendReply(KMessage* message, port_id replyPort, int32 replyToken,
584 	bigtime_t timeout, team_id senderTeam)
585 {
586 	if (!message)
587 		return B_BAD_VALUE;
588 	return message->SendTo(ReplyPort(), ReplyToken(), replyPort, replyToken,
589 		timeout, senderTeam);
590 }
591 
592 
593 status_t
594 KMessage::SendReply(KMessage* message, KMessage* reply,
595 	bigtime_t deliveryTimeout, bigtime_t replyTimeout, team_id senderTeam)
596 {
597 	if (!message)
598 		return B_BAD_VALUE;
599 	return message->SendTo(ReplyPort(), ReplyToken(), reply, deliveryTimeout,
600 		replyTimeout, senderTeam);
601 }
602 
603 
604 status_t
605 KMessage::ReceiveFrom(port_id fromPort, bigtime_t timeout,
606 	port_message_info* messageInfo)
607 {
608 	port_message_info _messageInfo;
609 	if (messageInfo == NULL)
610 		messageInfo = &_messageInfo;
611 
612 	// get the port buffer size
613 	status_t error;
614 	if (timeout < 0) {
615 		error = get_port_message_info_etc(fromPort, messageInfo, 0, 0);
616 	} else {
617 		error = get_port_message_info_etc(fromPort, messageInfo,
618 			B_RELATIVE_TIMEOUT, timeout);
619 	}
620 	if (error != B_OK)
621 		return error;
622 
623 	// allocate a buffer
624 	uint8* buffer = (uint8*)MEMALIGN(kMessageBufferAlignment,
625 		messageInfo->size);
626 	if (!buffer)
627 		return B_NO_MEMORY;
628 
629 	// read the message
630 	int32 what;
631 	ssize_t realSize = read_port_etc(fromPort, &what, buffer, messageInfo->size,
632 		B_RELATIVE_TIMEOUT, 0);
633 	if (realSize < 0) {
634 		free(buffer);
635 		return realSize;
636 	}
637 	if (messageInfo->size != (size_t)realSize) {
638 		free(buffer);
639 		return B_ERROR;
640 	}
641 
642 	// init the message
643 	return SetTo(buffer, messageInfo->size, 0,
644 		KMESSAGE_OWNS_BUFFER | KMESSAGE_INIT_FROM_BUFFER);
645 }
646 
647 
648 #endif	// !KMESSAGE_CONTAINER_ONLY
649 
650 
651 void
652 KMessage::Dump(void (*printFunc)(const char*, ...)) const
653 {
654 	Header* header = _Header();
655 	printFunc("KMessage: buffer: %p (size/capacity: %ld/%ld), flags: %#"
656 		B_PRIx32 "\n", fBuffer, header->size, fBufferCapacity, fFlags);
657 
658 	KMessageField field;
659 	while (GetNextField(&field) == B_OK) {
660 		type_code type = field.TypeCode();
661 		uint32 bigEndianType = B_HOST_TO_BENDIAN_INT32(type);
662 		int nameSpacing = 17 - strlen(field.Name());
663 		if (nameSpacing < 0)
664 			nameSpacing = 0;
665 
666 		printFunc("  field: \"%s\"%*s (%.4s): ", field.Name(), nameSpacing, "",
667 			(char*)&bigEndianType);
668 
669 		if (field.CountElements() != 1)
670 			printFunc("\n");
671 
672 		int32 size;
673 		for (int i = 0; const void* data = field.ElementAt(i, &size); i++) {
674 			if (field.CountElements() != 1)
675 				printFunc("    [%2d] ", i);
676 
677 			bool isIntType = false;
678 			int64 intData = 0;
679 			switch (type) {
680 				case B_BOOL_TYPE:
681 					printFunc("%s\n", (*(bool*)data ? "true" : "false"));
682 					break;
683 				case B_INT8_TYPE:
684 					isIntType = true;
685 					intData = *(int8*)data;
686 					break;
687 				case B_INT16_TYPE:
688 					isIntType = true;
689 					intData = *(int16*)data;
690 					break;
691 				case B_INT32_TYPE:
692 					isIntType = true;
693 					intData = *(int32*)data;
694 					break;
695 				case B_INT64_TYPE:
696 					isIntType = true;
697 					intData = *(int64*)data;
698 					break;
699 				case B_STRING_TYPE:
700 					printFunc("\"%s\"\n", (char*)data);
701 					break;
702 				default:
703 					printFunc("data at %p, %ld bytes\n", (char*)data, size);
704 					break;
705 			}
706 			if (isIntType)
707 				printFunc("%lld (0x%llx)\n", intData, intData);
708 		}
709 	}
710 }
711 
712 
713 KMessage::Header*
714 KMessage::_Header() const
715 {
716 	return (Header*)fBuffer;
717 }
718 
719 
720 int32
721 KMessage::_BufferOffsetFor(const void* data) const
722 {
723 	if (!data)
724 		return -1;
725 	return (uint8*)data - (uint8*)fBuffer;
726 }
727 
728 
729 KMessage::FieldHeader*
730 KMessage::_FirstFieldHeader() const
731 {
732 	return (FieldHeader*)_Align(fBuffer, sizeof(Header));
733 }
734 
735 
736 KMessage::FieldHeader*
737 KMessage::_LastFieldHeader() const
738 {
739 	return _FieldHeaderForOffset(fLastFieldOffset);
740 }
741 
742 
743 KMessage::FieldHeader*
744 KMessage::_FieldHeaderForOffset(int32 offset) const
745 {
746 	if (offset <= 0 || offset >= _Header()->size)
747 		return NULL;
748 	return (FieldHeader*)((uint8*)fBuffer + offset);
749 }
750 
751 
752 status_t
753 KMessage::_AddField(const char* name, type_code type, int32 elementSize,
754 	KMessageField* field)
755 {
756 	FieldHeader* fieldHeader;
757 	int32 alignedSize;
758 	status_t error = _AllocateSpace(sizeof(FieldHeader) + strlen(name), true,
759 		true, (void**)&fieldHeader, &alignedSize);
760 	if (error != B_OK)
761 		return error;
762 	fieldHeader->type = type;
763 	fieldHeader->elementSize = elementSize;
764 	fieldHeader->elementCount = 0;
765 	fieldHeader->fieldSize = alignedSize;
766 	fieldHeader->headerSize = alignedSize;
767 	strcpy(fieldHeader->name, name);
768 	fLastFieldOffset = _BufferOffsetFor(fieldHeader);
769 	if (field)
770 		field->SetTo(this, _BufferOffsetFor(fieldHeader));
771 	return B_OK;
772 }
773 
774 
775 status_t
776 KMessage::_AddFieldData(KMessageField* field, const void* data,
777 	int32 elementSize, int32 elementCount)
778 {
779 	if (!field)
780 		return B_BAD_VALUE;
781 	FieldHeader* fieldHeader = field->_Header();
782 	FieldHeader* lastField = _LastFieldHeader();
783 	if (!fieldHeader || fieldHeader != lastField || !data
784 		|| elementSize < 0 || elementCount < 0) {
785 		return B_BAD_VALUE;
786 	}
787 	if (elementCount == 0)
788 		return B_OK;
789 	// fixed size values
790 	if (fieldHeader->HasFixedElementSize()) {
791 		if (elementSize != fieldHeader->elementSize)
792 			return B_BAD_VALUE;
793 		void* address;
794 		int32 alignedSize;
795 		status_t error = _AllocateSpace(elementSize * elementCount,
796 			(fieldHeader->elementCount == 0), false, &address, &alignedSize);
797 		if (error != B_OK)
798 			return error;
799 		fieldHeader = field->_Header();	// might have been relocated
800 		memcpy(address, data, elementSize * elementCount);
801 		fieldHeader->elementCount += elementCount;
802 		fieldHeader->fieldSize = (uint8*)address + alignedSize
803 			- (uint8*)fieldHeader;
804 		return B_OK;
805 	}
806 	// non-fixed size values
807 	// add the elements individually (TODO: Optimize!)
808 	int32 valueHeaderSize = _Align(sizeof(FieldValueHeader));
809 	int32 entrySize = valueHeaderSize + elementSize;
810 	for (int32 i = 0; i < elementCount; i++) {
811 		void* address;
812 		int32 alignedSize;
813 		status_t error = _AllocateSpace(entrySize, true, false, &address,
814 			&alignedSize);
815 		if (error != B_OK)
816 			return error;
817 		fieldHeader = field->_Header();	// might have been relocated
818 		FieldValueHeader* valueHeader = (FieldValueHeader*)address;
819 		valueHeader->size = elementSize;
820 		memcpy(valueHeader->Data(), (const uint8*)data + i * elementSize,
821 			elementSize);
822 		fieldHeader->elementCount++;
823 		fieldHeader->fieldSize = (uint8*)address + alignedSize
824 			- (uint8*)fieldHeader;
825 	}
826 	return B_OK;
827 }
828 
829 
830 status_t
831 KMessage::_InitFromBuffer(bool sizeFromBuffer)
832 {
833 	if (fBuffer == NULL)
834 		return B_BAD_DATA;
835 
836 	// clone the buffer, if requested
837 	if ((fFlags & KMESSAGE_CLONE_BUFFER) != 0 || _Align(fBuffer) != fBuffer) {
838 		if (sizeFromBuffer) {
839 			int32 size = fBufferCapacity;
840 			memcpy(&size, &_Header()->size, 4);
841 			fBufferCapacity = size;
842 		}
843 
844 		void* buffer = MEMALIGN(kMessageBufferAlignment, fBufferCapacity);
845 		if (buffer == NULL)
846 			return B_NO_MEMORY;
847 
848 		memcpy(buffer, fBuffer, fBufferCapacity);
849 
850 		if ((fFlags & KMESSAGE_OWNS_BUFFER) != 0)
851 			free(fBuffer);
852 
853 		fBuffer = buffer;
854 		fFlags &= ~(uint32)(KMESSAGE_READ_ONLY | KMESSAGE_CLONE_BUFFER);
855 		fFlags |= KMESSAGE_OWNS_BUFFER;
856 	}
857 
858 	if (_Align(fBuffer) != fBuffer)
859 		return B_BAD_DATA;
860 
861 	Header* header = _Header();
862 
863 	if (sizeFromBuffer)
864 		fBufferCapacity = header->size;
865 
866 	if (fBufferCapacity < (int)sizeof(Header))
867 		return B_BAD_DATA;
868 
869 	// check header
870 	if (header->magic != kMessageHeaderMagic)
871 		return B_BAD_DATA;
872 	if (header->size < (int)sizeof(Header) || header->size > fBufferCapacity)
873 		return B_BAD_DATA;
874 
875 	// check the fields
876 	FieldHeader* fieldHeader = NULL;
877 	uint8* data = (uint8*)_FirstFieldHeader();
878 	int32 remainingBytes = (uint8*)fBuffer + header->size - data;
879 	while (remainingBytes > 0) {
880 		if (remainingBytes < (int)sizeof(FieldHeader))
881 			return B_BAD_DATA;
882 		fieldHeader = (FieldHeader*)data;
883 		// check field header
884 		if (fieldHeader->type == B_ANY_TYPE)
885 			return B_BAD_DATA;
886 		if (fieldHeader->elementCount < 0)
887 			return B_BAD_DATA;
888 		if (fieldHeader->fieldSize < (int)sizeof(FieldHeader)
889 			|| fieldHeader->fieldSize > remainingBytes) {
890 			return B_BAD_DATA;
891 		}
892 		if (fieldHeader->headerSize < (int)sizeof(FieldHeader)
893 			|| fieldHeader->headerSize > fieldHeader->fieldSize) {
894 			return B_BAD_DATA;
895 		}
896 		int32 maxNameLen = data + fieldHeader->headerSize
897 			- (uint8*)fieldHeader->name;
898 		int32 nameLen = strnlen(fieldHeader->name, maxNameLen);
899 		if (nameLen == maxNameLen || nameLen == 0)
900 			return B_BAD_DATA;
901 		int32 fieldSize =  fieldHeader->headerSize;
902 		if (fieldHeader->HasFixedElementSize()) {
903 			// fixed element size
904 			int32 dataSize = fieldHeader->elementSize
905 				* fieldHeader->elementCount;
906 			fieldSize = (uint8*)fieldHeader->Data() + dataSize - data;
907 		} else {
908 			// non-fixed element size
909 			FieldValueHeader* valueHeader
910 				= (FieldValueHeader*)fieldHeader->Data();
911 			for (int32 i = 0; i < fieldHeader->elementCount; i++) {
912 				remainingBytes = (uint8*)fBuffer + header->size
913 					- (uint8*)valueHeader;
914 				if (remainingBytes < (int)sizeof(FieldValueHeader))
915 					return B_BAD_DATA;
916 				uint8* value = (uint8*)valueHeader->Data();
917 				remainingBytes = (uint8*)fBuffer + header->size - (uint8*)value;
918 				if (remainingBytes < valueHeader->size)
919 					return B_BAD_DATA;
920 				fieldSize = value + valueHeader->size - data;
921 				valueHeader = valueHeader->NextFieldValueHeader();
922 			}
923 			if (fieldSize > fieldHeader->fieldSize)
924 				return B_BAD_DATA;
925 		}
926 		data = (uint8*)fieldHeader->NextFieldHeader();
927 		remainingBytes = (uint8*)fBuffer + header->size - data;
928 	}
929 	fLastFieldOffset = _BufferOffsetFor(fieldHeader);
930 	return B_OK;
931 }
932 
933 
934 void
935 KMessage::_InitBuffer(uint32 what)
936 {
937 	Header* header = _Header();
938 	header->magic = kMessageHeaderMagic;
939 	header->size = sizeof(Header);
940 	header->what = what;
941 	header->sender = -1;
942 	header->targetToken = -1;
943 	header->replyPort = -1;
944 	header->replyToken = -1;
945 	fLastFieldOffset = 0;
946 }
947 
948 
949 void
950 KMessage::_CheckBuffer()
951 {
952 	int32 lastFieldOffset = fLastFieldOffset;
953 	if (_InitFromBuffer(false) != B_OK) {
954 		PANIC("internal data mangled");
955 	}
956 	if (fLastFieldOffset != lastFieldOffset) {
957 		PANIC("fLastFieldOffset changed during KMessage::_CheckBuffer()");
958 	}
959 }
960 
961 
962 status_t
963 KMessage::_AllocateSpace(int32 size, bool alignAddress, bool alignSize,
964 	void** address, int32* alignedSize)
965 {
966 	if (fBuffer != &fHeader && (fFlags & KMESSAGE_READ_ONLY))
967 		return B_NOT_ALLOWED;
968 
969 	int32 offset = ContentSize();
970 	if (alignAddress)
971 		offset = _Align(offset);
972 	int32 newSize = offset + size;
973 	if (alignSize)
974 		newSize = _Align(newSize);
975 	// reallocate if necessary
976 	if (fBuffer == &fHeader) {
977 		int32 newCapacity = _CapacityFor(newSize);
978 		void* newBuffer = MEMALIGN(kMessageBufferAlignment, newCapacity);
979 		if (!newBuffer)
980 			return B_NO_MEMORY;
981 		fBuffer = newBuffer;
982 		fBufferCapacity = newCapacity;
983 		fFlags |= KMESSAGE_OWNS_BUFFER;
984 		memcpy(fBuffer, &fHeader, sizeof(fHeader));
985 	} else {
986 		if (newSize > fBufferCapacity) {
987 			// if we don't own the buffer, we can't resize it
988 			if (!(fFlags & KMESSAGE_OWNS_BUFFER)) {
989 #if defined(_KERNEL_MODE) && 0
990 				// optional debugging to find insufficiently sized KMessage
991 				// buffers (e.g. for in-kernel notifications)
992 				panic("KMessage: out of space: available: %" B_PRId32
993 					", needed: %" B_PRId32 "\n", fBufferCapacity, newSize);
994 #endif
995 				return B_BUFFER_OVERFLOW;
996 			}
997 
998 			int32 newCapacity = _CapacityFor(newSize);
999 			void* newBuffer = realloc(fBuffer, newCapacity);
1000 			if (!newBuffer)
1001 				return B_NO_MEMORY;
1002 			fBuffer = newBuffer;
1003 			fBufferCapacity = newCapacity;
1004 		}
1005 	}
1006 	_Header()->size = newSize;
1007 	*address = (char*)fBuffer + offset;
1008 	*alignedSize = newSize - offset;
1009 	return B_OK;
1010 }
1011 
1012 
1013 int32
1014 KMessage::_CapacityFor(int32 size)
1015 {
1016 	return (size + kMessageReallocChunkSize - 1) / kMessageReallocChunkSize
1017 		* kMessageReallocChunkSize;
1018 }
1019 
1020 
1021 // #pragma mark - KMessageField
1022 
1023 
1024 KMessageField::KMessageField()
1025 	:
1026 	fMessage(NULL),
1027 	fHeaderOffset(0)
1028 {
1029 }
1030 
1031 
1032 void
1033 KMessageField::Unset()
1034 {
1035 	fMessage = NULL;
1036 	fHeaderOffset = 0;
1037 }
1038 
1039 
1040 KMessage*
1041 KMessageField::Message() const
1042 {
1043 	return fMessage;
1044 }
1045 
1046 
1047 const char*
1048 KMessageField::Name() const
1049 {
1050 	KMessage::FieldHeader* header = _Header();
1051 	return header ? header->name : NULL;
1052 }
1053 
1054 
1055 type_code
1056 KMessageField::TypeCode() const
1057 {
1058 	KMessage::FieldHeader* header = _Header();
1059 	return header ? header->type : 0;
1060 }
1061 
1062 
1063 bool
1064 KMessageField::HasFixedElementSize() const
1065 {
1066 	KMessage::FieldHeader* header = _Header();
1067 	return header ? header->HasFixedElementSize() : false;
1068 }
1069 
1070 
1071 int32
1072 KMessageField::ElementSize() const
1073 {
1074 	KMessage::FieldHeader* header = _Header();
1075 	return header ? header->elementSize : -1;
1076 }
1077 
1078 
1079 status_t
1080 KMessageField::AddElement(const void* data, int32 size)
1081 {
1082 	KMessage::FieldHeader* header = _Header();
1083 	if (!header || !data)
1084 		return B_BAD_VALUE;
1085 	if (size < 0) {
1086 		size = ElementSize();
1087 		if (size < 0)
1088 			return B_BAD_VALUE;
1089 	}
1090 	return fMessage->_AddFieldData(this, data, size, 1);
1091 }
1092 
1093 
1094 status_t
1095 KMessageField::AddElements(const void* data, int32 count, int32 elementSize)
1096 {
1097 	KMessage::FieldHeader* header = _Header();
1098 	if (!header || !data || count < 0)
1099 		return B_BAD_VALUE;
1100 	if (elementSize < 0) {
1101 		elementSize = ElementSize();
1102 		if (elementSize < 0)
1103 			return B_BAD_VALUE;
1104 	}
1105 	return fMessage->_AddFieldData(this, data, elementSize, count);
1106 }
1107 
1108 
1109 const void*
1110 KMessageField::ElementAt(int32 index, int32* size) const
1111 {
1112 	KMessage::FieldHeader* header = _Header();
1113 	return header ? header->ElementAt(index, size) : NULL;
1114 }
1115 
1116 
1117 int32
1118 KMessageField::CountElements() const
1119 {
1120 	KMessage::FieldHeader* header = _Header();
1121 	return header ? header->elementCount : 0;
1122 }
1123 
1124 
1125 void
1126 KMessageField::SetTo(KMessage* message, int32 headerOffset)
1127 {
1128 	fMessage = message;
1129 	fHeaderOffset = headerOffset;
1130 }
1131 
1132 
1133 KMessage::FieldHeader*
1134 KMessageField::_Header() const
1135 {
1136 	return fMessage ? fMessage->_FieldHeaderForOffset(fHeaderOffset) : NULL;
1137 }
1138