static int
openTransport(const char *address, SharedMemoryTransport **transportPtr)
{
jint error;
SharedMemoryTransport *transport;
transport = allocTransport();
if (transport == NULL) {
return SYS_NOMEM;
}
memset(transport, 0, sizeof(*transport));
if (strlen(address) >= MAX_IPC_PREFIX) {
char buf[128];
sprintf(buf, "Error: address strings longer than %d characters are invalid\n", MAX_IPC_PREFIX);
setLastErrorMsg(buf);
closeTransport(transport);
return SYS_ERR;
}
error = sysSharedMemOpen(address, &transport->sharedMemory, &transport->shared);
if (error != SYS_OK) {
setLastError(error);
closeTransport(transport);
return error;
}
strcpy(transport->name, address);
error = sysIPMutexOpen(transport->shared->mutexName, &transport->mutex);
if (error != SYS_OK) {
setLastError(error);
closeTransport(transport);
return error;
}
error = sysEventOpen(transport->shared->acceptEventName,
&transport->acceptEvent);
if (error != SYS_OK) {
setLastError(error);
closeTransport(transport);
return error;
}
error = sysEventOpen(transport->shared->attachEventName,
&transport->attachEvent);
if (error != SYS_OK) {
setLastError(error);
closeTransport(transport);
return error;
}
*transportPtr = transport;
return SYS_OK;
}
bool
GContactClient::uninit()
{
FUNCTION_CALL_TRACE;
closeTransport();
return true;
}
jint
shmemBase_attach(const char *addressString, long timeout, SharedMemoryConnection **connectionPtr)
{
int error;
SharedMemoryTransport *transport;
jlong acceptingPID;
clearLastError();
error = openTransport(addressString, &transport);
if (error != SYS_OK) {
return error;
}
/* lock transport - no additional event to wait on as no connection yet */
error = sysIPMutexEnter(transport->mutex, NULL);
if (error != SYS_OK) {
setLastError(error);
closeTransport(transport);
return error;
}
if (transport->shared->isListening) {
error = doAttach(transport, timeout);
if (error == SYS_OK) {
acceptingPID = transport->shared->acceptingPID;
}
} else {
/* Not listening: error */
error = SYS_ERR;
}
sysIPMutexExit(transport->mutex);
if (error != SYS_OK) {
closeTransport(transport);
return error;
}
error = openConnection(transport, acceptingPID, connectionPtr);
closeTransport(transport);
return error;
}
LircCommander::LircCommander(LircClient *lirc, RosegardenMainWindow *rgGUIApp)
: QObject()
{
m_lirc = lirc;
m_rgGUIApp = rgGUIApp;
connect(m_lirc, SIGNAL(buttonPressed(const char *)),
this, SLOT(slotExecute(const char *)) );
connect(this, SIGNAL(play()),
m_rgGUIApp, SLOT(slotPlay()) );
connect(this, SIGNAL(stop()),
m_rgGUIApp, SLOT(slotStop()) );
connect(this, SIGNAL(record()),
m_rgGUIApp, SLOT(slotRecord()) );
connect(this, SIGNAL(rewind()),
m_rgGUIApp, SLOT(slotRewind()) );
connect(this, SIGNAL(rewindToBeginning()),
m_rgGUIApp, SLOT(slotRewindToBeginning()) );
connect(this, SIGNAL(fastForward()),
m_rgGUIApp, SLOT(slotFastforward()) );
connect(this, SIGNAL(fastForwardToEnd()),
m_rgGUIApp, SLOT(slotFastForwardToEnd()) );
connect(this, SIGNAL(toggleRecord()),
m_rgGUIApp, SLOT(slotToggleRecord()) );
connect(this, SIGNAL(trackDown()),
m_rgGUIApp, SLOT(slotTrackDown()) );
connect(this, SIGNAL(trackUp()),
m_rgGUIApp, SLOT(slotTrackUp()) );
connect(this, SIGNAL(trackMute()),
m_rgGUIApp, SLOT(slotToggleMute()) );
connect(this, SIGNAL(trackRecord()),
m_rgGUIApp, SLOT(slotToggleRecordCurrentTrack()) );
connect(this, SIGNAL(undo()),
CommandHistory::getInstance(), SLOT(undo()) );
connect(this, SIGNAL(redo()),
CommandHistory::getInstance(), SLOT(redo()) );
connect(this, SIGNAL(aboutrg()),
m_rgGUIApp, SLOT(slotHelpAbout()) );
connect(this, SIGNAL(editInMatrix()),
m_rgGUIApp, SLOT(slotEditInMatrix()) );
connect(this, SIGNAL(editInPercussionMatrix()),
m_rgGUIApp, SLOT(slotEditInPercussionMatrix()) );
connect(this, SIGNAL(editInEventList()),
m_rgGUIApp, SLOT(slotEditInEventList()) );
connect(this, SIGNAL(editAsNotation()),
m_rgGUIApp, SLOT(slotEditAsNotation()) );
connect(this, SIGNAL(quit()),
m_rgGUIApp, SLOT(slotQuit()) );
connect(this, SIGNAL(closeTransport()),
m_rgGUIApp, SLOT(slotCloseTransport()) );
connect(this, SIGNAL(toggleTransportVisibility()),
m_rgGUIApp, SLOT(slotToggleTransportVisibility()) );
}
~zmqTransport() { closeTransport(); }
void
shmemBase_closeTransport(SharedMemoryTransport *transport)
{
closeTransport(transport);
}
static jint
createTransport(const char *address, SharedMemoryTransport **transportPtr)
{
SharedMemoryTransport *transport;
jint error;
char prefix[MAX_IPC_PREFIX];
transport = allocTransport();
if (transport == NULL) {
return SYS_NOMEM;
}
memset(transport, 0, sizeof(*transport));
if ((address == NULL) || (address[0] == '\0')) {
SharedMemoryArg arg;
arg.size = sizeof(SharedListener);
error = createWithGeneratedName("javadebug", transport->name,
createSharedMem, &arg);
transport->shared = arg.start;
transport->sharedMemory = arg.memory;
} else {
if (strlen(address) >= MAX_IPC_PREFIX) {
fprintf(stderr,"Error: address strings longer than %d characters are invalid\n", MAX_IPC_PREFIX);
closeTransport(transport);
return SYS_ERR;
}
strcpy(transport->name, address);
error = sysSharedMemCreate(address, sizeof(SharedListener),
&transport->sharedMemory, &transport->shared);
}
if (error != SYS_OK) {
fprintf(stderr,"Error creating shared memory, rc = %d\n", error);
closeTransport(transport);
return error;
}
memset(transport->shared, 0, sizeof(SharedListener));
transport->shared->acceptingPID = sysProcessGetID();
sprintf(prefix, "%s.mutex", transport->name);
error = createWithGeneratedName(prefix, transport->shared->mutexName,
createMutex, &transport->mutex);
if (error != SYS_OK) {
fprintf(stderr,"Error creating mutex, rc = %d\n", error);
closeTransport(transport);
return error;
}
sprintf(prefix, "%s.accept", transport->name);
error = createWithGeneratedName(prefix, transport->shared->acceptEventName,
createEvent, &transport->acceptEvent);
if (error != SYS_OK) {
fprintf(stderr,"Error creating event, rc = %d\n", error);
closeTransport(transport);
return error;
}
sprintf(prefix, "%s.attach", transport->name);
error = createWithGeneratedName(prefix, transport->shared->attachEventName,
createEvent, &transport->attachEvent);
if (error != SYS_OK) {
fprintf(stderr,"Error creating event, rc = %d\n", error);
closeTransport(transport);
return error;
}
*transportPtr = transport;
return SYS_OK;
}
void LircCommander::slotExecute(const char *command)
{
struct command tmp, *res;
RG_DEBUG << "LircCommander::slotExecute: invoking command: " << command;
// find the function for the name
tmp.name = command;
res = (struct command *)bsearch(&tmp, commands,
sizeof(commands) / sizeof(struct command),
sizeof(struct command),
compareCommandName);
if (res != NULL)
{
switch (res->code)
{
case cmd_play:
emit play();
break;
case cmd_stop:
emit stop();
break;
case cmd_record:
emit record();
break;
case cmd_rewind:
emit rewind();
break;
case cmd_rewindToBeginning:
emit rewindToBeginning();
break;
case cmd_fastForward:
emit fastForward();
break;
case cmd_fastForwardToEnd:
emit fastForwardToEnd();
break;
case cmd_toggleRecord:
emit toggleRecord();
break;
case cmd_trackDown:
emit trackDown();
break;
case cmd_trackUp:
emit trackUp();
break;
case cmd_trackMute:
emit trackMute();
break;
case cmd_trackRecord:
emit trackRecord();
break;
case cmd_undo:
emit undo();
break;
case cmd_redo:
emit redo();
break;
case cmd_aboutrg:
emit aboutrg();
break;
case cmd_editInEventList:
emit editInEventList();
break;
case cmd_editInMatrix:
emit editInMatrix();
break;
case cmd_editInPercussionMatrix:
emit editInPercussionMatrix();
break;
case cmd_editAsNotation:
emit editAsNotation();
break;
case cmd_quit:
emit quit();
break;
case cmd_closeTransport:
emit closeTransport();
break;
case cmd_toggleTransportVisibility:
emit toggleTransportVisibility();
break;
default:
RG_DEBUG << "LircCommander::slotExecute: unhandled command " << command;
return;
}
RG_DEBUG << "LircCommander::slotExecute: handled command: " << command;
}
else
{
RG_DEBUG << "LircCommander::slotExecute: invoking command: " << command
<< " failed (command not defined in LircCommander::commands[])" << endl;
};
}
void
shmemBase_closeTransport(SharedMemoryTransport *transport)
{
clearLastError();
closeTransport(transport);
}
void Subscription::pendingConnectionDone(const PendingConnectionPtr& conn, XmlRpcValue& result)
{
boost::mutex::scoped_lock lock(shutdown_mutex_);
if (shutting_down_ || dropped_)
{
return;
}
{
boost::mutex::scoped_lock pending_connections_lock(pending_connections_mutex_);
pending_connections_.erase(conn);
}
ros::TransportUDPPtr udp_transport;
std::string peer_host = conn->getClient()->getHost();
uint32_t peer_port = conn->getClient()->getPort();
std::stringstream ss;
ss << "http://" << peer_host << ":" << peer_port << "/";
std::string xmlrpc_uri = ss.str();
udp_transport = conn->getUDPTransport();
XmlRpc::XmlRpcValue proto;
if(!XMLRPCManager::instance()->validateXmlrpcResponse("requestTopic", result, proto))
{
ROSCPP_LOG_DEBUG("Failed to contact publisher [%s:%d] for topic [%s]",
peer_host.c_str(), peer_port, name_.c_str());
closeTransport(udp_transport);
return;
}
if (proto.size() == 0)
{
ROSCPP_LOG_DEBUG("Couldn't agree on any common protocols with [%s] for topic [%s]", xmlrpc_uri.c_str(), name_.c_str());
closeTransport(udp_transport);
return;
}
if (proto.getType() != XmlRpcValue::TypeArray)
{
ROSCPP_LOG_DEBUG("Available protocol info returned from %s is not a list.", xmlrpc_uri.c_str());
closeTransport(udp_transport);
return;
}
if (proto[0].getType() != XmlRpcValue::TypeString)
{
ROSCPP_LOG_DEBUG("Available protocol info list doesn't have a string as its first element.");
closeTransport(udp_transport);
return;
}
std::string proto_name = proto[0];
if (proto_name == "TCPROS")
{
if (proto.size() != 3 ||
proto[1].getType() != XmlRpcValue::TypeString ||
proto[2].getType() != XmlRpcValue::TypeInt)
{
ROSCPP_LOG_DEBUG("publisher implements TCPROS, but the " \
"parameters aren't string,int");
return;
}
std::string pub_host = proto[1];
int pub_port = proto[2];
ROSCPP_LOG_DEBUG("Connecting via tcpros to topic [%s] at host [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
//ROS_INFO("here in subscription");
//ros::TransportTCPPtr transport(new ros::TransportTCP(&ros::PollManager::instance()->getPollSet()));
ros::TransportTCPPtr transport(new ros::TransportTCP(&poll_manager_->getPollSet()));
if (transport->connect(pub_host, pub_port))
{
ros::ConnectionPtr connection(new ros::Connection());
TransportPublisherLinkPtr pub_link(new TransportPublisherLink(shared_from_this(), xmlrpc_uri, transport_hints_));
connection->initialize(transport, false, ros::HeaderReceivedFunc());
pub_link->initialize(connection);
ConnectionManager::instance()->addConnection(connection);
boost::mutex::scoped_lock lock(publisher_links_mutex_);
addPublisherLink(pub_link);
ROSCPP_LOG_DEBUG("Connected to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
}
else
{
ROSCPP_LOG_DEBUG("Failed to connect to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
}
}
else if (proto_name == "UDPROS")
{
if (proto.size() != 6 ||
proto[1].getType() != XmlRpcValue::TypeString ||
proto[2].getType() != XmlRpcValue::TypeInt ||
proto[3].getType() != XmlRpcValue::TypeInt ||
proto[4].getType() != XmlRpcValue::TypeInt ||
proto[5].getType() != XmlRpcValue::TypeBase64)
{
ROSCPP_LOG_DEBUG("publisher implements UDPROS, but the " \
"parameters aren't string,int,int,int,base64");
closeTransport(udp_transport);
return;
}
std::string pub_host = proto[1];
int pub_port = proto[2];
int conn_id = proto[3];
int max_datagram_size = proto[4];
std::vector<char> header_bytes = proto[5];
boost::shared_array<uint8_t> buffer = boost::shared_array<uint8_t>(new uint8_t[header_bytes.size()]);
memcpy(buffer.get(), &header_bytes[0], header_bytes.size());
ros::Header h;
std::string err;
if (!h.parse(buffer, header_bytes.size(), err))
{
ROSCPP_LOG_DEBUG("Unable to parse UDPROS connection header: %s", err.c_str());
closeTransport(udp_transport);
return;
}
ROSCPP_LOG_DEBUG("Connecting via udpros to topic [%s] at host [%s:%d] connection id [%08x] max_datagram_size [%d]", name_.c_str(), pub_host.c_str(), pub_port, conn_id, max_datagram_size);
std::string error_msg;
if (h.getValue("error", error_msg))
{
ROSCPP_LOG_DEBUG("Received error message in header for connection to [%s]: [%s]", xmlrpc_uri.c_str(), error_msg.c_str());
closeTransport(udp_transport);
return;
}
TransportPublisherLinkPtr pub_link(new TransportPublisherLink(shared_from_this(), xmlrpc_uri, transport_hints_));
if (pub_link->setHeader(h))
{
ros::ConnectionPtr connection(new ros::Connection());
connection->initialize(udp_transport, false, NULL);
connection->setHeader(h);
pub_link->initialize(connection);
ConnectionManager::instance()->addConnection(connection);
boost::mutex::scoped_lock lock(publisher_links_mutex_);
addPublisherLink(pub_link);
ROSCPP_LOG_DEBUG("Connected to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
}
else
{
ROSCPP_LOG_DEBUG("Failed to connect to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
closeTransport(udp_transport);
return;
}
}
else
{
ROSCPP_LOG_DEBUG("Publisher offered unsupported transport [%s]", proto_name.c_str());
}
}
