void SchemaStatisticImpl::encode(Buffer& buffer) const
{
FieldTable map;
map.setString("name", name);
map.setInt("type", (int) typecode);
if (!unit.empty())
map.setString("unit", unit);
if (!description.empty())
map.setString("desc", description);
map.encode(buffer);
}
void SchemaMethodImpl::encode(Buffer& buffer) const
{
FieldTable map;
map.setString("name", name);
map.setInt("argCount", arguments.size());
if (!description.empty())
map.setString("desc", description);
map.encode(buffer);
for (vector<const SchemaArgument*>::const_iterator iter = arguments.begin();
iter != arguments.end(); iter++)
(*iter)->impl->encode(buffer);
}
void SchemaPropertyImpl::encode(Buffer& buffer) const
{
FieldTable map;
map.setString("name", name);
map.setInt("type", (int) typecode);
map.setInt("access", (int) access);
map.setInt("index", index ? 1 : 0);
map.setInt("optional", optional ? 1 : 0);
if (!unit.empty())
map.setString("unit", unit);
if (!description.empty())
map.setString("desc", description);
map.encode(buffer);
}
ConnectionHandler::Handler::Handler(Connection& c, bool isClient) :
proxy(c.getOutput()),
connection(c), serverMode(!isClient), secured(0),
isOpen(false)
{
if (serverMode) {
FieldTable properties;
Array mechanisms(0x95);
properties.setString(QPID_FED_TAG, connection.getBroker().getFederationTag());
authenticator = SaslAuthenticator::createAuthenticator(c);
authenticator->getMechanisms(mechanisms);
Array locales(0x95);
boost::shared_ptr<FieldValue> l(new Str16Value(en_US));
locales.add(l);
proxy.start(properties, mechanisms, locales);
}
maxFrameSize = (64 * 1024) - 1;
}
void SchemaArgumentImpl::encode(Buffer& buffer) const
{
FieldTable map;
map.setString("name", name);
map.setInt("type", (int) typecode);
if (dir == DIR_IN)
map.setString("dir", "I");
else if (dir == DIR_OUT)
map.setString("dir", "O");
else
map.setString("dir", "IO");
if (!unit.empty())
map.setString("unit", unit);
if (!description.empty())
map.setString("desc", description);
map.encode(buffer);
}
void ValueImpl::mapToFieldTable(FieldTable& ft) const
{
FieldTable subFt;
for (map<string, Value>::const_iterator iter = mapVal.begin();
iter != mapVal.end(); iter++) {
const string& name(iter->first);
const Value& subval(iter->second);
switch (subval.getType()) {
case TYPE_UINT8:
case TYPE_UINT16:
case TYPE_UINT32:
ft.setUInt64(name, (uint64_t) subval.asUint());
break;
case TYPE_UINT64:
case TYPE_DELTATIME:
ft.setUInt64(name, subval.asUint64());
break;
case TYPE_SSTR:
case TYPE_LSTR:
ft.setString(name, subval.asString());
break;
case TYPE_INT64:
case TYPE_ABSTIME:
ft.setInt64(name, subval.asInt64());
break;
case TYPE_BOOL:
ft.set(name, FieldTable::ValuePtr(new BoolValue(subval.asBool())));
break;
case TYPE_FLOAT:
ft.setFloat(name, subval.asFloat());
break;
case TYPE_DOUBLE:
ft.setDouble(name, subval.asDouble());
break;
case TYPE_INT8:
case TYPE_INT16:
case TYPE_INT32:
ft.setInt(name, subval.asInt());
break;
case TYPE_MAP:
subFt.clear();
subval.impl->mapToFieldTable(subFt);
ft.setTable(name, subFt);
break;
case TYPE_LIST:
{
List subList;
subval.impl->listToFramingList(subList);
ft.set(name,
::qpid::framing::FieldTable::ValuePtr(
new ListValue(
subList)));
} break;
case TYPE_ARRAY:
case TYPE_OBJECT:
case TYPE_UUID:
case TYPE_REF:
default:
break;
}
}
}
void ConnectionHandler::Handler::start(const FieldTable& serverProperties,
const framing::Array& supportedMechanisms,
const framing::Array& /*locales*/)
{
string requestedMechanism = connection.getAuthMechanism();
std::string username = connection.getUsername();
std::string password = connection.getPassword();
std::string host = connection.getHost();
std::string service("qpidd");
if ( connection.getBroker().isAuthenticating() ) {
sasl = SaslFactory::getInstance().create( username,
password,
service,
host,
0, // TODO -- mgoulish Fri Sep 24 2010
256,
false ); // disallow interaction
}
std::string supportedMechanismsList;
Array::const_iterator i;
/*
If no specific mechanism has been requested, just make
a list of all of them, and assert that the one the caller
requested is there. ( If *any* are supported! )
*/
if ( requestedMechanism.empty() ) {
for ( i = supportedMechanisms.begin(); i != supportedMechanisms.end(); ++i) {
if (i != supportedMechanisms.begin())
supportedMechanismsList += SPACE;
supportedMechanismsList += (*i)->get<std::string>();
}
}
else {
/*
The caller has requested a mechanism. If it's available,
make sure it ends up at the head of the list.
*/
for ( i = supportedMechanisms.begin(); i != supportedMechanisms.end(); ++i) {
string currentMechanism = (*i)->get<std::string>();
if ( requestedMechanism == currentMechanism ) {
supportedMechanismsList = currentMechanism + SPACE + supportedMechanismsList;
} else {
if (i != supportedMechanisms.begin())
supportedMechanismsList += SPACE;
supportedMechanismsList += currentMechanism;
}
}
}
if (serverProperties.isSet(QPID_FED_TAG)) {
connection.setFederationPeerTag(serverProperties.getAsString(QPID_FED_TAG));
}
FieldTable ft = connection.getBroker().getLinkClientProperties();
ft.setInt(QPID_FED_LINK,1);
ft.setString(QPID_FED_TAG, connection.getBroker().getFederationTag());
string response;
if (sasl.get()) {
const qpid::sys::SecuritySettings& ss = connection.getExternalSecuritySettings();
if (sasl->start ( requestedMechanism.empty()
? supportedMechanismsList
: requestedMechanism,
response,
& ss )) {
proxy.startOk ( ft, sasl->getMechanism(), response, en_US );
} else {
//response was null
ConnectionStartOkBody body;
body.setClientProperties(ft);
body.setMechanism(sasl->getMechanism());
//Don't set response, as none was given
body.setLocale(en_US);
proxy.send(body);
}
}
else {
response = ((char)0) + username + ((char)0) + password;
proxy.startOk ( ft, requestedMechanism, response, en_US );
}
}