1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/**
* @file lldispatcher.cpp
* @brief Implementation of the dispatcher object.
*
* Copyright (c) 2004-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#include "linden_common.h"
#include "lldispatcher.h"
#include <algorithm>
#include "llstl.h"
#include "message.h"
///----------------------------------------------------------------------------
/// Class lldispatcher
///----------------------------------------------------------------------------
LLDispatcher::LLDispatcher()
{
}
LLDispatcher::~LLDispatcher()
{
}
bool LLDispatcher::isHandlerPresent(const key_t& name) const
{
if(mHandlers.find(name) != mHandlers.end())
{
return true;
}
return false;
}
void LLDispatcher::copyAllHandlerNames(keys_t& names) const
{
// copy the names onto the vector we are given
std::transform(
mHandlers.begin(),
mHandlers.end(),
std::back_insert_iterator<keys_t>(names),
llselect1st<dispatch_map_t::value_type>());
}
bool LLDispatcher::dispatch(
const key_t& name,
const LLUUID& invoice,
const sparam_t& strings) const
{
dispatch_map_t::const_iterator it = mHandlers.find(name);
if(it != mHandlers.end())
{
LLDispatchHandler* func = (*it).second;
return (*func)(this, name, invoice, strings);
}
return false;
}
LLDispatchHandler* LLDispatcher::addHandler(
const key_t& name, LLDispatchHandler* func)
{
dispatch_map_t::iterator it = mHandlers.find(name);
LLDispatchHandler* old_handler = NULL;
if(it != mHandlers.end())
{
old_handler = (*it).second;
mHandlers.erase(it);
}
if(func)
{
// only non-null handlers so that we don't have to worry about
// it later.
mHandlers.insert(dispatch_map_t::value_type(name, func));
}
return old_handler;
}
// static
bool LLDispatcher::unpackMessage(
LLMessageSystem* msg,
LLDispatcher::key_t& method,
LLUUID& invoice,
LLDispatcher::sparam_t& parameters)
{
char buf[MAX_STRING]; /*Flawfinder: ignore*/
msg->getStringFast(_PREHASH_MethodData, _PREHASH_Method, MAX_STRING, buf);
method.assign(buf);
msg->getUUIDFast(_PREHASH_MethodData, _PREHASH_Invoice, invoice);
S32 size;
S32 count = msg->getNumberOfBlocksFast(_PREHASH_ParamList);
for (S32 i = 0; i < count; ++i)
{
// we treat the SParam as binary data (since it might be an
// LLUUID in compressed form which may have embedded \0's,)
size = msg->getSizeFast(_PREHASH_ParamList, i, _PREHASH_Parameter);
msg->getBinaryDataFast(
_PREHASH_ParamList, _PREHASH_Parameter,
buf, size, i, MAX_STRING-1);
// If the last byte of the data is 0x0, this is either a normally
// packed string, or a binary packed UUID (which for these messages
// are packed with a 17th byte 0x0). Unpack into a std::string
// without the trailing \0, so "abc\0" becomes std::string("abc", 3)
// which matches const char* "abc".
if (size > 0
&& buf[size-1] == 0x0)
{
// special char*/size constructor because UUIDs may have embedded
// 0x0 bytes.
std::string binary_data(buf, size-1);
parameters.push_back(binary_data);
}
else
{
// This is either a NULL string, or a string that was packed
// incorrectly as binary data, without the usual trailing '\0'.
std::string string_data(buf, size);
parameters.push_back(string_data);
}
}
return true;
}
|
