static void error_service(VSTREAM *client_stream, char *service, char **argv)
{
DELIVER_REQUEST *request;
int status;
/*
* Sanity check. This service takes no command-line arguments.
*/
if (argv[0])
msg_fatal("unexpected command-line argument: %s", argv[0]);
/*
* This routine runs whenever a client connects to the UNIX-domain socket
* dedicated to the error mailer. What we see below is a little protocol
* to (1) tell the queue manager that we are ready, (2) read a request
* from the queue manager, and (3) report the completion status of that
* request. All connection-management stuff is handled by the common code
* in single_server.c.
*/
if ((request = deliver_request_read(client_stream)) != 0) {
if (strcmp(service, MAIL_SERVICE_ERROR) == 0)
status = deliver_message(request, "5.0.0", bounce_append);
else if (strcmp(service, MAIL_SERVICE_RETRY) == 0)
status = deliver_message(request, "4.0.0", defer_append);
else
msg_fatal("bad error service name: %s", service);
deliver_request_done(client_stream, request, status);
}
}
void send_msg(void* sock, int parts, int size){
for(int i=0; i < (parts-1); i++){
deliver_message(sock,size,ZMQ_SNDMORE);
sleep(operation.interval);
}
deliver_message(sock,size,0);
puts(" done!");
}
void LLFloaterIMPanel::sessionInitReplyReceived(const LLUUID& session_id)
{
mSessionUUID = session_id;
mVoiceChannel->updateSessionID(session_id);
mSessionInitialized = true;
//we assume the history editor hasn't moved at all since
//we added the starting session message
//so, we count how many characters to remove
S32 chars_to_remove = mHistoryEditor->getWText().length() - mSessionStartMsgPos;
mHistoryEditor->removeTextFromEnd(chars_to_remove);
//and now, send the queued msg
for (LLSD::array_iterator iter = mQueuedMsgsForInit.beginArray();
iter != mQueuedMsgsForInit.endArray();
++iter)
{
deliver_message(
iter->asString(),
mSessionUUID,
mOtherParticipantUUID,
mDialog);
}
// auto-start the call on session initialization?
if (mStartCallOnInitialize)
{
gIMMgr->startCall(mSessionUUID);
}
}
static void pipe_service(VSTREAM *client_stream, char *service, char **argv)
{
DELIVER_REQUEST *request;
int status;
/*
* This routine runs whenever a client connects to the UNIX-domain socket
* dedicated to delivery via external command. What we see below is a
* little protocol to (1) tell the queue manager that we are ready, (2)
* read a request from the queue manager, and (3) report the completion
* status of that request. All connection-management stuff is handled by
* the common code in single_server.c.
*/
if ((request = deliver_request_read(client_stream)) != 0) {
status = deliver_message(request, service, argv);
deliver_request_done(client_stream, request, status);
}
}
static void discard_service(VSTREAM *client_stream, char *unused_service, char **argv)
{
DELIVER_REQUEST *request;
int status;
/*
* Sanity check. This service takes no command-line arguments.
*/
if (argv[0])
msg_fatal("unexpected command-line argument: %s", argv[0]);
/*
* This routine runs whenever a client connects to the UNIX-domain socket
* dedicated to the discard mailer. What we see below is a little
* protocol to (1) tell the queue manager that we are ready, (2) read a
* request from the queue manager, and (3) report the completion status
* of that request. All connection-management stuff is handled by the
* common code in single_server.c.
*/
if ((request = deliver_request_read(client_stream)) != 0) {
status = deliver_message(request);
deliver_request_done(client_stream, request, status);
}
}
static int cycle(mqtt_client_t* c, mqtt_timer_t* timer)
{
// read the socket, see what work is due
int packet_type = read_packet(c, timer);
int len = 0,
rc = MQTT_SUCCESS;
switch (packet_type)
{
case MQTTPACKET_CONNACK:
case MQTTPACKET_PUBACK:
case MQTTPACKET_SUBACK:
break;
case MQTTPACKET_PUBLISH:
{
mqtt_string_t topicName;
mqtt_message_t msg;
if (mqtt_deserialize_publish((unsigned char*)&msg.dup, (int*)&msg.qos, (unsigned char*)&msg.retained, (unsigned short*)&msg.id, &topicName,
(unsigned char**)&msg.payload, (int*)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
goto exit;
deliver_message(c, &topicName, &msg);
if (msg.qos != MQTT_QOS0)
{
if (msg.qos == MQTT_QOS1)
len = mqtt_serialize_ack(c->buf, c->buf_size, MQTTPACKET_PUBACK, 0, msg.id);
else if (msg.qos == MQTT_QOS2)
len = mqtt_serialize_ack(c->buf, c->buf_size, MQTTPACKET_PUBREC, 0, msg.id);
if (len <= 0)
rc = MQTT_FAILURE;
else
rc = send_packet(c, len, timer);
if (rc == MQTT_FAILURE)
goto exit; // there was a problem
}
break;
}
case MQTTPACKET_PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
if (mqtt_deserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = MQTT_FAILURE;
else if ((len = mqtt_serialize_ack(c->buf, c->buf_size, MQTTPACKET_PUBREL, 0, mypacketid)) <= 0)
rc = MQTT_FAILURE;
else if ((rc = send_packet(c, len, timer)) != MQTT_SUCCESS) // send the PUBREL packet
rc = MQTT_FAILURE; // there was a problem
if (rc == MQTT_FAILURE)
goto exit; // there was a problem
break;
}
case MQTTPACKET_PUBCOMP:
break;
case MQTTPACKET_PINGRESP:
{
c->ping_outstanding = 0;
c->fail_count = 0;
break;
}
case MQTT_READ_ERROR:
{
c->isconnected = 0; // we simulate a disconnect if reading error
rc = MQTT_DISCONNECTED; // so that the outer layer will reconnect and recover
break;
}
}
if (c->isconnected)
rc = keepalive(c);
exit:
if (rc == MQTT_SUCCESS)
rc = packet_type;
return rc;
}
// Singu Note: LLFloaterIMSession::sendMsg
void LLFloaterIMPanel::onSendMsg()
{
if (!gAgent.isGodlike()
&& (mSessionType == P2P_SESSION)
&& mOtherParticipantUUID.isNull())
{
llinfos << "Cannot send IM to everyone unless you're a god." << llendl;
return;
}
if (mInputEditor)
{
LLWString text = mInputEditor->getConvertedText();
if(!text.empty())
{
// store sent line in history, duplicates will get filtered
if (mInputEditor) mInputEditor->updateHistory();
// Truncate and convert to UTF8 for transport
std::string utf8_text = wstring_to_utf8str(text);
bool action = convert_roleplay_text(utf8_text);
if (!action && mRPMode)
utf8_text = "((" + utf8_text + "))";
// [RLVa:KB] - Checked: 2010-11-30 (RLVa-1.3.0)
if ( (RlvActions::hasBehaviour(RLV_BHVR_SENDIM)) || (RlvActions::hasBehaviour(RLV_BHVR_SENDIMTO)) )
{
bool fRlvFilter = false;
switch (mSessionType)
{
case P2P_SESSION: // One-on-one IM
fRlvFilter = !RlvActions::canSendIM(mOtherParticipantUUID);
break;
case GROUP_SESSION: // Group chat
fRlvFilter = !RlvActions::canSendIM(mSessionUUID);
break;
case ADHOC_SESSION: // Conference chat: allow if all participants can be sent an IM
{
if (!mSpeakers)
{
fRlvFilter = true;
break;
}
LLSpeakerMgr::speaker_list_t speakers;
mSpeakers->getSpeakerList(&speakers, TRUE);
for (LLSpeakerMgr::speaker_list_t::const_iterator itSpeaker = speakers.begin();
itSpeaker != speakers.end(); ++itSpeaker)
{
const LLSpeaker* pSpeaker = *itSpeaker;
if ( (gAgentID != pSpeaker->mID) && (!RlvActions::canSendIM(pSpeaker->mID)) )
{
fRlvFilter = true;
break;
}
}
}
break;
default:
fRlvFilter = true;
break;
}
if (fRlvFilter)
{
utf8_text = RlvStrings::getString(RLV_STRING_BLOCKED_SENDIM);
}
}
// [/RLVa:KB]
if ( mSessionInitialized )
{
// Split messages that are too long, same code like in llimpanel.cpp
U32 split = MAX_MSG_BUF_SIZE - 1;
U32 pos = 0;
U32 total = utf8_text.length();
while (pos < total)
{
U32 next_split = split;
if (pos + next_split > total)
{
next_split = total - pos;
}
else
{
// don't split utf-8 bytes
while (U8(utf8_text[pos + next_split]) != 0x20 // space
&& U8(utf8_text[pos + next_split]) != 0x21 // !
&& U8(utf8_text[pos + next_split]) != 0x2C // ,
&& U8(utf8_text[pos + next_split]) != 0x2E // .
&& U8(utf8_text[pos + next_split]) != 0x3F // ?
&& next_split > 0)
{
--next_split;
}
if (next_split == 0)
{
next_split = split;
LL_WARNS("Splitting") << "utf-8 couldn't be split correctly" << LL_ENDL;
}
else
{
++next_split;
}
}
std::string send = utf8_text.substr(pos, next_split);
pos += next_split;
LL_DEBUGS("Splitting") << "Pos: " << pos << " next_split: " << next_split << LL_ENDL;
deliver_message(send,
mSessionUUID,
mOtherParticipantUUID,
mDialog);
}
// local echo
if((mSessionType == P2P_SESSION) &&
(mOtherParticipantUUID.notNull()))
{
std::string name;
gAgent.buildFullname(name);
// Look for actions here.
if (action)
{
utf8_text.replace(0,3,"");
}
else
{
utf8_text.insert(0, ": ");
}
bool other_was_typing = mOtherTyping;
addHistoryLine(utf8_text, gSavedSettings.getColor("UserChatColor"), true, gAgentID, name);
if (other_was_typing) addTypingIndicator(mOtherTypingName);
}
}
else
{
//queue up the message to send once the session is
//initialized
mQueuedMsgsForInit.append(utf8_text);
}
}
LLViewerStats::getInstance()->incStat(LLViewerStats::ST_IM_COUNT);
mInputEditor->setText(LLStringUtil::null);
}
// Don't need to actually send the typing stop message, the other
// client will infer it from receiving the message.
mTyping = false;
mSentTypingState = true;
}
int deliver_messages(struct list *messages) {
int nmsgs = 0; // number of delivered messages
int ret;
// acquire read lock for list of messages
ret = pthread_rwlock_rdlock(messages->listrwlock);
assert(ret == 0);
struct node *curMsg = messages->root;
while (curMsg != NULL) {
struct message *msg = curMsg->entry;
// acquire lock for message stat list
ret = pthread_rwlock_rdlock(msg->stats->listrwlock);
assert(ret == 0);
// walk through statistics of a message and check
// with read lock whether it is eligible. If yes,
// check again with write lock and deliver.
struct node *curStat = msg->stats->root;
while (curStat != NULL) {
struct msg_statistics *stat = curStat->entry;
// acquire read lock for statistic
ret = pthread_rwlock_rdlock(stat->statrwlock);
assert(ret == 0);
int eligible = is_eligible(stat);
// release read lock for statistic
ret = pthread_rwlock_unlock(stat->statrwlock);
assert(ret == 0);
if (eligible) {
// acquire write lock for statistic
ret = pthread_rwlock_wrlock(stat->statrwlock);
assert(ret == 0);
// check again to make sure
if (is_eligible(stat)) {
deliver_message(msg, stat); // requires write lock
nmsgs++;
}
// release read lock for statistic
ret = pthread_rwlock_unlock(stat->statrwlock);
assert(ret == 0);
}
curStat = curStat->next;
}
// release lock for message stat list
ret = pthread_rwlock_unlock(msg->stats->listrwlock);
assert(ret == 0);
curMsg = curMsg->next;
}
// release read lock for list of messages
ret = pthread_rwlock_unlock(messages->listrwlock);
assert(ret == 0);
return nmsgs;
}
void recv_msg(void* sock){
int retval = 0;
zmq_msg_t msg;
// Wow, fun bug. You have to set the identity before bind. No changing identity at runtime?
#define IDENTITY "blaster.c"
zmq_setsockopt(sock,ZMQ_IDENTITY,IDENTITY,strlen(IDENTITY));
retval = zmq_bind(sock,operation.destination);
if(retval != 0){
switch(errno){
case EINVAL:
puts("zmq_bind EINVAL");
break;
case EPROTONOSUPPORT:
puts("zmq_bind EPROTONOSUPPORT");
break;
case ENOCOMPATPROTO:
puts("zmq_bind ENOCOMPATPROTO");
break;
case EADDRINUSE:
puts("zmq_bind EADDRINUSE");
break;
case EADDRNOTAVAIL:
puts("zmq_bind EADDRNOTAVAIL");
break;
case ENODEV:
puts("zmq_bind ENODEV");
break;
case ETERM:
puts("zmq_bind ETERM");
break;
case ENOTSOCK:
puts("zmq_bind ENOTSOCK");
break;
case EMTHREAD:
puts("zmq_bind EMTHREAD");
break;
default:
puts("zmq_bind errno default");
}
}
char identity[256];
size_t identity_size;
zmq_getsockopt(sock,ZMQ_IDENTITY,identity,&identity_size);
printf("Server up (identity %.*s). Waiting for message.\n",(int)identity_size,identity);
while(1){
zmq_msg_init(&msg);
retval = zmq_recv(sock,&msg,0);
if(retval != 0){
switch(errno){
case EAGAIN:
puts("zmq_connect EAGAIN");
break;
case ENOTSUP:
puts("zmq_connect ENOTSUP");
break;
case EFSM:
puts("zmq_connect EFSM");
break;
case ETERM:
puts("zmq_connect ETERM");
break;
case ENOTSOCK:
puts("zmq_connect ENOTSOCK");
break;
case EINTR:
puts("zmq_connect EINTR");
break;
case EFAULT:
default:
puts("zmq_recv errno default");
}
}
#ifdef LOGGING
printf("Message %d '%.*s' (%d bytes)\n",message_count,(int)zmq_msg_size(&msg),zmq_msg_data(&msg),(int)zmq_msg_size(&msg));
message_count=message_count+1;
#endif
deliver_message(sock,10,0);
zmq_msg_close(&msg);
}
}
