void CDBThread::delImsiMsisdnByMsisdn(stMSISDN* pMsisdn) { stImsiMsisdn numdata; memset(&numdata, 0, sizeof(stImsiMsisdn)); //delete the old one from db by MSISDN numdata.MsisdnLen = pMsisdn->ucLen; memcpy(numdata.strMsisdn, pMsisdn->ucMSISDN, pMsisdn->ucLen); #ifdef __SYB_ESQL__ int ret = ::delMsisdnImsiByMsisdn(&numdata, 0); if(ret < 0) { char buf[512] = {0}; if(ERROR_WRITE(-ret)) { LOG4CXX_WARN(dbLogger, "The DB connection has broken, reconnect ..."); connect2db(); } else { LOG4CXX_WARN(dbLogger, "DELETE MSISDN["<<pMsisdn->ucMSISDN<<"]<=>IMSI by MSISDN from DB failed: ", ::getLastError()); } } #endif #ifdef __SYB_CTLIB__ if(m_pSybClient->delMsisdnImsiByMsisdn(m_iDbConnId, "SapDB.dbo.TBL_ImsiMsisdn", &numdata) < 0) { char buf[512] = {0}; snprintf(buf, sizeof(buf) - 1, "DELETE MSISDN[%s]<=>IMSI by MSISDN from DB failed: ", pMsisdn->ucMSISDN); if(checkSybCtlibError(buf) < 0) { _connect2db(); } } #endif }
void CDBThread::insertImsiMsisdn(stImsiMsisdn* pNum) { #ifdef __SYB_ESQL__ int ret = ::writeMsisdnImsi(pNum, 0); if(ret < 0) { if(ERROR_WRITE(-ret)) { LOG4CXX_WARN(dbLogger, "The DB connection has broken, reconnect ..."); connect2db(); } else { LOG4CXX_WARN(dbLogger, "INSERT MSISDN["<<pNum->strMsisdn<<"]<=>IMSI["<<pNum->strImsi<<"] to DB failed: "<<::getLastError()); } } #endif #ifdef __SYB_CTLIB__ if(m_pSybClient->write_ImsiMsisdn(m_iDbConnId, "SapDB.dbo.TBL_ImsiMsisdn", pNum) < 0) { char buf[512] = {0}; snprintf(buf, sizeof(buf) - 1, "INSERT MSISDN[%s]<=>IMSI[%s] to DB failed: ", pNum->strMsisdn, pNum->strImsi); if(checkSybCtlibError(buf) < 0) { _connect2db(); } } #endif }
void CDBThread::delImsiMsisdnByImsi(stIMSI* pImsi) { stImsiMsisdn numdata; memset(&numdata, 0, sizeof(stImsiMsisdn)); numdata.ImsiLen = pImsi->m_ucIMSILen; memcpy(numdata.strImsi, pImsi->m_szIMSI, numdata.ImsiLen); #ifdef __SYB_ESQL__ int ret = ::delMsisdnImsiByImsi(&numdata, 0); if(ret < 0) { if(ERROR_WRITE(-ret)) { LOG4CXX_WARN(dbLogger, "The DB connection has broken, reconnect ..."); connect2db(); } else { LOG4CXX_WARN(dbLogger, "DELETE MSISDN<=>IMSI["<<pImsi->m_szIMSI<<"] by IMSI from DB failed: "<< ::getLastError()); } } #endif #ifdef __SYB_CTLIB__ if(m_pSybClient->delMsisdnImsiByImsi(m_iDbConnId, "SapDB.dbo.TBL_ImsiMsisdn", &numdata) < 0) { char buf[512] = {0}; snprintf(buf, sizeof(buf) - 1, "DELETE MSISDN<=>IMSI[%s] by IMSI from DB failed: ", pImsi->m_szIMSI); if(checkSybCtlibError(buf) < 0) { _connect2db(); } } #endif }
void QueryService::AddService() { std::list<std::string>::iterator iter = file_list_.begin(); void* handler; QueryInfo* query; QueryObj result; for(;iter!=file_list_.end();++iter) { std::string temp_path = *iter; LOG4CXX_INFO(log_,temp_path); handler = dlopen(temp_path.c_str(),RTLD_LAZY); if(!handler) { //load failed LOG4CXX_WARN(log_,"Can not load so: "+*iter); continue; } dlerror(); query = (QueryInfo *)dlsym(handler,g_query_name.c_str()); const char* dlsym_error = dlerror(); if(dlsym_error) { dlclose(handler); LOG4CXX_WARN(log_,"Can not find QueryInfo in "+*iter); continue; } result = query->handler(); node_.service()->addService(result.name,result.object,false); LOG4CXX_INFO(log_,"add service "+result.name); } }
void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) { std::string session = getSessionName(user, room); std::string target = getTargetName(room); LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Joining room " << target); if (m_sessions[session] == NULL) { if (m_servers.empty()) { // in gateway mode we want to login this user to network according to legacyName if (room.find("@") != std::string::npos) { // suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net m_sessions[session] = createSession(user, room.substr(room.find("@") + 1), nickname, "", room.substr(room.find("@"))); } else { LOG4CXX_WARN(logger, user << ": There's no proper server defined in room to which this user wants to join: " << room); return; } } else { LOG4CXX_WARN(logger, user << ": Join room requested for unconnected user"); return; } } m_sessions[session]->addAutoJoinChannel(target, password); m_sessions[session]->sendCommand(IrcCommand::createJoin(FROM_UTF8(target), FROM_UTF8(password))); m_sessions[session]->rooms += 1; // update nickname, because we have nickname per session, no nickname per room. handleRoomNicknameChanged(user, target, TO_UTF8(m_sessions[session]->nickName())); }
void QueryService::GetFile() { if(!boost::filesystem::exists(path_)) { std::ostringstream oss; oss << "path do not exists!!"; LOG4CXX_WARN(log_,oss.str()); } else if(path_.empty()) { std::ostringstream oss; oss << "path is empty!"; LOG4CXX_WARN(log_,oss.str()); } else { boost::filesystem::directory_iterator end_it; for(boost::filesystem::directory_iterator it(path_); it!=end_it;++it) { boost::filesystem::path temp(*it); //only load so file if(temp.extension() == ".so") { file_list_.push_back(temp.string()); std::ostringstream oss; oss << "find " << temp.filename(); LOG4CXX_DEBUG(log_,oss.str()); } } } }
bool Collector::TryToConnect(ACE_SOCK_Connector& con,ACE_SOCK_Stream& peer) { if(data_source_.node_list.size() == 0) { std::ostringstream oss; oss << data_source_.name << " have no legal IP"; LOG4CXX_WARN(log_,oss.str()); return false; } for(int i=0;i<data_source_.node_list.size();i++) { std::string ip_temp = data_source_.node_list[i].ip; unsigned int port = data_source_.node_list[i].port; ACE_INET_Addr addr(port,ip_temp.c_str()); if(con.connect(peer,addr)==0) { return true; } } std::ostringstream oss; oss << "can not connect every host in cluster:" << data_source_.name; LOG4CXX_WARN(log_,oss.str()); return false; }
void MpiLauncher::handleKillTimeout(boost::shared_ptr<boost::asio::deadline_timer>& killTimer, const boost::system::error_code& error) { ScopedMutexLock lock(_mutex); if (error == boost::asio::error::operation_aborted) { assert(_pid < 0); LOG4CXX_TRACE(logger, " MPI launcher kill timer cancelled"); return; } if (error) { assert(false); LOG4CXX_WARN(logger, "MPI launcher kill timer encountered error"<<error); } if (_pid <= 0) { LOG4CXX_WARN(logger, "MPI launcher kill timer cannot kill pid="<<_pid); return; } if (!_waiting) { assert(false); LOG4CXX_ERROR(logger, "MPI launcher kill timer cannot kill pid="<<_pid); throw InvalidStateException(REL_FILE, __FUNCTION__, __LINE__) << " MPI launcher process cannot be killed"; } LOG4CXX_WARN(logger, "MPI launcher is about to kill group pid="<<_pid); // kill launcher's proc group MpiErrorHandler::killProc(_installPath, -_pid); }
void CDBThread::connect2db() { #ifdef __SYB_ESQL__ int ret = -1; while((ret = ::connectDb(sysPtr->getSysCfg().szDbUser, sysPtr->getSysCfg().szDbPassword, sysPtr->getSysCfg().szDbName)) < 0 && !EXIT()) { LOG4CXX_WARN(dbLogger, "Connect to DB failed: "<<::getLastError()<<", retry after 3s ..."); ::disconnectDb(0); Delay2(3, 0); } if(ret >= 0) LOG4CXX_DEBUG(dbLogger, "Connect to db OK"); #endif #ifdef __SYB_CTLIB__ while(m_pSybClient->open() < 0 && !EXIT()) { LOG4CXX_WARN(dbLogger, "SYBASE CTLIB initialize failed, retry after 3s ..."); Delay2(3, 0); } while((m_iDbConnId = m_pSybClient->connect(sysPtr->getSysCfg().szDbName, sysPtr->getSysCfg().szDbUser, sysPtr->getSysCfg().szDbPassword)) < 0 && !EXIT()) { LOG4CXX_WARN(dbLogger, "Connect to db failed, retry after 3s ..."); Delay2(3, 0); } if(m_iDbConnId >= 0) LOG4CXX_DEBUG(dbLogger, "Connect to db OK"); #endif }
stDataUpdateTime *CDBThread::CheckDataUpdateFlag(unsigned char index) { static stDataUpdateTime upd; memset(&upd, 0, sizeof(stDataUpdateTime)); #ifdef __SYB_ESQL__ int retcode = readDataUpdateFlag(&upd, index); if (retcode < 0) { memset(&upd, 0, sizeof(stDataUpdateTime)); // if(ERROR_READ(-retcode)) { LOG4CXX_WARN(dbLogger, "The DB connection has broken, reconnect ..."); connect2db(); } else { LOG4CXX_WARN(dbLogger, "Read TBL_DateUpdateFlag failed: "<<::getLastError()); } } #endif #ifdef __SYB_CTLIB__ if(m_pSybClient->read_DataUpdateFlag(m_iDbConnId, "SapDB.dbo.TBL_DataUpdateFlag", index, &upd) < 0) { if(checkSybCtlibError("Read TBL_DateUpdateFlag failed:") < 0) { _connect2db(); } } #endif return &upd; }
bool doMsg(std::string& reply, const std::string& msg) { Cmd::Set setmsg; if (setmsg.ParseFromString(msg)) { const std::string& key = setmsg.key(); const std::string& value = setmsg.value(); LOG4CXX_INFO(logger, "<" << pthread_self() << "> set : " << setmsg.key() << ", " << setmsg.value().size()); RedisConnectionByKey redis(key, worker->cachePool()); if (redis) { redis->hmset("%s value %b flag %u touchtime %u", key.c_str(), value.data(), value.size(), 0, (unsigned int)time(0)); } else { LOG4CXX_WARN(logger, "set " << key << " .. redis is not ready"); } if (0 == s_cacheonly) { MySqlConnectionByKey mysql(key, worker->dbPool()); if (mysql) { try { mysqlpp::Query query = mysql->query(); query.reset(); query << "replace into " << getKVSTableName(key) << "(`key`, value, flag, touchtime) values(" << mysqlpp::quote << key << "," << mysqlpp::quote << value << "," << 0 << "," << time(0) << ")"; query.execute(); LOG4CXX_INFO(logger, "mysql " << key << "," << mysql->shard() << "," << getKVSTableName(key)); } catch (std::exception& err) { LOG4CXX_WARN(logger, "set " << key << " .. mysql error:" << err.what()); return false; } } else { LOG4CXX_WARN(logger, "set " << key << " .. mysql is not ready"); } } } reply = "OK"; return true; }
bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) { sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload())); User *user = m_userManager->getUser(from.toBare().toString()); if (!user) { LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in"); return true; } if (payload->getItems().size() == 0) { LOG4CXX_WARN(logger, from.toBare().toString() << ": Roster push with no item"); return true; } Swift::RosterItemPayload item = payload->getItems()[0]; if (item.getJID().getNode().empty()) { return true; } Buddy *buddy = user->getRosterManager()->getBuddy(Buddy::JIDToLegacyName(item.getJID())); if (buddy) { if (item.getSubscription() == Swift::RosterItemPayload::Remove) { LOG4CXX_INFO(logger, from.toBare().toString() << ": Removing buddy " << buddy->getName()); onBuddyRemoved(buddy); // send roster push here Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, user->getJID().toBare(), user->getComponent()->getIQRouter()); request->send(); } else { LOG4CXX_INFO(logger, from.toBare().toString() << ": Updating buddy " << buddy->getName()); onBuddyUpdated(buddy, item); } } else if (item.getSubscription() != Swift::RosterItemPayload::Remove) { // Roster push for this new buddy is sent by RosterManager BuddyInfo buddyInfo; buddyInfo.id = -1; buddyInfo.alias = item.getName(); buddyInfo.legacyName = Buddy::JIDToLegacyName(item.getJID()); buddyInfo.subscription = "both"; buddyInfo.flags = Buddy::buddyFlagsFromJID(item.getJID()); LOG4CXX_INFO(logger, from.toBare().toString() << ": Adding buddy " << buddyInfo.legacyName); buddy = user->getComponent()->getFactory()->createBuddy(user->getRosterManager(), buddyInfo); user->getRosterManager()->setBuddy(buddy); onBuddyAdded(buddy, item); } return true; }
void LoggerUtil::warning(HLoggerPtr logger, const char* msg){ #ifdef HAVE_LOG4CXX LOG4CXX_WARN(static_cast<Logger*>(logger), msg); #else stdLogOut(logger, msg); #endif }
void ConversationManager::handleMessageReceived(Swift::Message::ref message) { // std::string name = message->getTo().getUnescapedNode(); // if (name.find_last_of("%") != std::string::npos) { // OK when commented // name.replace(name.find_last_of("%"), 1, "@"); // OK when commented // } std::string name = Buddy::JIDToLegacyName(message->getTo()); if (name.empty()) { LOG4CXX_WARN(logger, m_user->getJID().toString() << ": Tried to create empty conversation"); return; } // create conversation if it does not exist. if (!m_convs[name]) { Conversation *conv = m_component->getFactory()->createConversation(this, name); addConversation(conv); } // if it exists and it's MUC, but this message is PM, get PM conversation or create new one. else if (m_convs[name]->isMUC() && message->getType() != Swift::Message::Groupchat) { std::string room_name = name; name = room_name + "/" + message->getTo().getResource(); if (m_convs.find(name) == m_convs.end()) { Conversation *conv = m_component->getFactory()->createConversation(this, message->getTo().getResource()); conv->setRoom(room_name); conv->setNickname(name); addConversation(conv); } } // update resource and send the message m_convs[name]->setJID(message->getFrom()); m_convs[name]->sendMessage(message); }
static bool SetVorbisCommentDouble(FLAC__StreamMetadata *block, const char *key, CFNumberRef value, CFStringRef format = NULL) { assert(NULL != block); assert(NULL != key); CFStringRef numberString = NULL; if(NULL != value) { double f; if(!CFNumberGetValue(value, kCFNumberDoubleType, &f)) { log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.FLAC"); LOG4CXX_WARN(logger, "CFNumberGetValue() failed"); return false; } numberString = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, NULL == format ? CFSTR("%f") : format, f); } bool result = SetVorbisComment(block, key, numberString); if(numberString) CFRelease(numberString), numberString = NULL; return result; }
void ThriftAsyncClientPool::DiscoverServicesDelegate::process(CallbackResponse response, const ::std::vector< ::std::string>& services) { if ((response != ServiceDiscoveryCallback::OK) || (services.empty())) { LOG4CXX_WARN(_poolRef.LOG, "Failed to get application services." " This might be okay if no application services have been registered"); } else if (services.empty()) { //done discovering all services for this iteration. Invoke next callback _nextCb->operator()(); return; } ::boost::optional< ::std::string> appName_opt; if ((_nextCb != _ownerDispatch) && (_poolRef._applicationName.find_first_not_of(' ') != ::std::string::npos)) { //not looking for common serivces. If application name has been set, //set the optional agrument for the endpoint discovery delegate appName_opt = _poolRef._applicationName; } ::boost::shared_ptr<DiscoverEndpointsDelegate> delegate = ::boost::make_shared<DiscoverEndpointsDelegate>(_poolRef, ::boost::bind(*_nextCb), appName_opt, services); //save a boost shared ptr to this instance inorder not to prematurely //destory the instance before the endpoint delegate completes delegate->_servicesDelegate = shared_from_this(); //use a shared_ptr to invoke the discoverEndpoint method as the discoverEndpoint method uses the //shared_ptr to hold a reference to the delegate object event after this current function //exits. delegate->discoverEndpoints(); }
rgb_classification_dataset::rgb_classification_dataset(const std::string& filename, int pattern_size, int n_crops) :m_n_crops(n_crops) ,m_pattern_size(pattern_size) ,m_filename(filename){ std::ifstream ifs(filename.c_str()); unsigned int n_cls; ifs >> n_cls; ifs.get(); // consume '\n' for(unsigned int klass = 0; klass < n_cls; klass++){ std::string line; std::getline(ifs, line); if(ifs) m_class_names.push_back(line); } cuvAssert(m_class_names.size() == n_cls); while(ifs){ meta_t m; ifs >> m.rgb_filename; //ifs >> m.klass; // dummy value for historical reasons ifs >> m.klass; if(ifs) m_meta.push_back(m); } cuvAssert(m_meta.size() > 0); LOG4CXX_WARN(g_log, "read `"<< filename<<"', n_classes: "<<n_cls<<", size: "<<m_meta.size()); m_predictions.resize(this->size()); shuffle(false); }
void Collector::PollData() { ACE_SOCK_Stream peer; ACE_SOCK_Connector connector; try { if(TryToConnect(connector,peer)) { std::ostringstream oss; oss << "poll data form cluster: " << data_source_.name; LOG4CXX_INFO(log_,oss.str()); char buf[T_SIZE] = "request"; if((peer.send(buf,sizeof(buf)))<=0) throw "KSN POLLER COLLECTOR SEND REQUEST ERROR!!"; char* ch = new char[T_SIZE](); if((peer.recv(ch,T_SIZE)<=0)) throw "KSN POLLER COLLECTOR RECV ERROR!!"; msg_ = new ACE_Message_Block(ch,sizeof(*ch)); sender_->putq(msg_); } else { std::ostringstream oss; oss << "Can not poll data form " + data_source_.name; LOG4CXX_WARN(log_,oss.str()); } } catch(const char* ch) { LOG4CXX_ERROR(log_,ch); } }
bool TapeMsg::IsValid() { if(m_recId.length() == 0) { LOG4CXX_WARN(LOG.messaging,"Ignoring tape message with empty recId"); return false; } return true; }
int CGsmASythesize::sendPowerOff(SPowerOff& data) { //@zh 判断是否是本地号码,否则不发送 //stNumPrefix* prefix = findNumPrefix((unsigned char*)(&data.msisdn[0])); stNumPrefix* prefix = sysPtr->findNumPrefix((unsigned char*)(&data.msisdn[0])); if(!prefix) return 0; // WEvent evt; evt.PtlId = PTL_SAP; evt.PtlVer = 0; // 不填亦可,程序不做判断。 evt.dmid = LMI_SCP << 4; evt.what = evControl; evt.evCode = SYT_SCP_MOFF; evt.msgLen = sizeof(SPowerOff); evt.msgPtr = NULL; evt.PktLength = sizeof(WEvent) + evt.msgLen; // evt.msgPtr = (char*)&data; int ret = ipcPtr->SendMsg(evt); if(ret < 0) { LOG4CXX_WARN(rootlog, "Send POWER ON message to SCP failed!"); } #ifdef SYTHESIZE_DEBUG else { printf("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n" "Send power off to scp:\nMSISDN: %s\n" "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", data.msisdn); } #endif return ret; }
void CoreBoundQueuesScheduler::pushToQueue(std::shared_ptr<Task> task) { // check if task should be scheduled on specific core int core = task->getPreferredCore(); if (core >= 0 && core < static_cast<int>(this->_queues)) { //potentially assigns task to a queue blocked by long running task this->_taskQueues[core]->push(task); LOG4CXX_DEBUG(this->_logger, "Task " << std::hex << (void *)task.get() << std::dec << " pushed to queue " << core); } else if (core == Task::NO_PREFERRED_CORE || core >= static_cast<int>(this->_queues)) { if (core < Task::NO_PREFERRED_CORE || core >= static_cast<int>(this->_queues)) // Tried to assign task to core which is not assigned to scheduler; assigned to other core, log warning LOG4CXX_WARN(this->_logger, "Tried to assign task " << std::hex << (void *)task.get() << std::dec << " to core " << std::to_string(core) << " which is not assigned to scheduler; assigned it to next available core"); // lock queuesMutex to sync pushing to queue and incrementing next queue { std::lock_guard<lock_t> lk2(this->_queuesMutex); // simple strategy to avoid blocking of queues; check if queue is blocked - try a couple of times, otherwise schedule on next queue size_t retries = 0; while (static_cast<CoreBoundQueue *>(this->_taskQueues[this->_nextQueue])->blocked() && retries < 100) { this->_nextQueue = (this->_nextQueue + 1) % this->_queues; ++retries; } this->_taskQueues[this->_nextQueue]->push(task); //std::cout << "Task " << task->vname() << "; hex " << std::hex << &task << std::dec << " pushed to queue " << this->_nextQueue << std::endl; //round robin on cores this->_nextQueue = (this->_nextQueue + 1) % this->_queues; } } }
int SYSTEM::sendCDR (SCallDetailRecord& data) { WEvent evt; evt.PtlId = PTL_SAP; evt.PtlVer = 0; // 不填亦可,程序不做判断。 evt.dmid = LMI_SCP << 4; evt.what = evControl; evt.evCode = SYT_SCP_CDR; evt.msgLen = sizeof(SCallDetailRecord); evt.msgPtr = NULL; evt.PktLength = sizeof(WEvent) + evt.msgLen; // evt.msgPtr = (char*)&data; int ret = ipcPtr->SendMsg(evt); if(ret < 0) { LOG4CXX_WARN(rootlog, "Send CDR message to SCP failed!"); } #ifdef SYTHESIZE_DEBUG else { printf("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n" "Send cdr to scp:\ncaller MSISDN: %s\ncallee MSISDN: %s\n" "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", data.caller, data.called); } #endif return ret; }
bool retreiver::queuewait(int count) { int total = 1; int queue_len = length(); bool ret = false; while(queue_len > m_goodlevel) { m_overloaded++; LOG4CXX_WARN("[" << total << "] mqueue overloaded: qlength = " << queue_len << " count = " << count << " wait = " << m_nsleeper << "s" << " lost = " << (m_nsleeper*total) << "s" << " over = " << m_overloaded); sleep(m_nsleeper); queue_len = length(); total++; ret = true; m_overavg = (m_overloaded*1.0)/(m_batch*1.0); // if we are still overloaded after x retries then we need to // quit and start over if(m_overloadexit > 0) { if(total > m_overloadexit) exit(1); } } return ret; }
/** * @brief check the error when something wrong happened * @return -1 if should reconnect to db , or return 0 */ int CDBThread::checkSybCtlibError(char* logheader) { char buf[512] = {0}; CS_CLIENTMSG clt; CS_SERVERMSG srv; m_pSybClient->GetLastError(clt, srv); //if(clt.msgnumber > 0 || clt.msgstring[0] != '\0') //{ // snprintf(buf, 511, "%s%s", logheader, clt.msgstring); //} //else //{ // snprintf(buf, 511, "%s%s", logheader, srv.text); //} LOG4CXX_WARN(dbLogger, logheader<<"["<<clt.msgstring<<"]["<<srv.text<<"]"); if(clt.severity == CS_SV_RESOURCE_FAIL || clt.severity == CS_SV_COMM_FAIL || clt.severity == CS_SV_INTERNAL_FAIL || clt.severity == CS_SV_FATAL) { return -1; } return 0; }
int SYSTEM::sendLocUpdt (SLocationUpdate& data) { //@zh 判断是否是本地号码,否则不发送 //stNumPrefix* prefix = findNumPrefix((unsigned char*)(&data.msisdn[0])); stNumPrefix* prefix = sysPtr->findNumPrefix((unsigned char*)(&data.msisdn[0])); if(!prefix) return 0; // WEvent evt; evt.PtlId = PTL_SAP; evt.PtlVer = 0; // 不填亦可,程序不做判断。 evt.dmid = LMI_SCP << 4; evt.what = evControl; evt.evCode = SYT_SCP_UPD; evt.msgLen = sizeof(SLocationUpdate); evt.msgPtr = NULL; evt.PktLength = sizeof(WEvent) + evt.msgLen; // evt.msgPtr = (char*)&data; int ret = ipcPtr->SendMsg(evt); if(ret < 0) { LOG4CXX_WARN(rootlog, "Send LOCATION UPDTATE message to SCP failed!"); } #ifdef SYTHESIZE_DEBUG else { printf("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n" "Send location update to scp:\nMSISDN: %s\n" "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", data.msisdn); } #endif return ret; }
bool ComponentReader::read(Component& component) { enum { eStart, eId, eGap, }; static boost::regex reg(">component[ \t]+(\\d+)"); if (_stream) { component.contigs.clear(); component.gaps.clear(); int state = eStart; std::string buf; boost::char_separator< char > sep(" ,\t"); while (std::getline(_stream, buf)) { if (state == eStart) { boost::smatch what; if (boost::regex_match(buf, what, reg)) { state = eId; component.id = boost::lexical_cast< size_t >(what[1]); } else { LOG4CXX_WARN(logger, boost::format("fa=>invalid line for not start with >: %s") % buf); return false; } } else if (state == eId) { boost::tokenizer< boost::char_separator< char > > toker(buf, sep); BOOST_FOREACH(const std::string& id, toker) { component.contigs.push_back( boost::lexical_cast< size_t > (id)); } state = eGap; } else if (state == eGap) {
bool MemoryMappedFileInputSource::Close(CFErrorRef *error) { if(!IsOpen()) { log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.InputSource.MemoryMappedFile"); LOG4CXX_WARN(logger, "Close() called on an InputSource that hasn't been opened"); return true; } memset(&mFilestats, 0, sizeof(mFilestats)); if(NULL != mMemory) { int result = munmap(mMemory, mFilestats.st_size); mMemory = NULL; mCurrentPosition = NULL; if(-1 == result) { if(error) *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, errno, NULL); return false; } } mIsOpen = false; return true; }
void SingleIRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) { // legacy name is users nickname if (m_sessions[user] != NULL) { LOG4CXX_WARN(logger, user << ": Already logged in."); return; } LOG4CXX_INFO(logger, user << ": Connecting " << m_server << " as " << legacyName); MyIrcSession *session = new MyIrcSession(user, this); session->setUserName(FROM_UTF8(legacyName)); session->setNickName(FROM_UTF8(legacyName)); session->setRealName(FROM_UTF8(legacyName)); session->setHost(FROM_UTF8(m_server)); session->setPort(6667); session->setEncoding( "utf-8" ); if (!password.empty()) { std::string identify = m_identify; boost::replace_all(identify, "$password", password); boost::replace_all(identify, "$name", legacyName); session->setIdentify(identify); } session->open(); m_sessions[user] = session; }
void EventHandler::processRegister(EventCmd &e,vector<string> &check_cmd) { if(check_cmd.size()!=4) return; //1.eqid 2.name 3.passwd if(check_cmd[1].size() == 0 || check_cmd[2].size() == 0 || check_cmd[3].size() == 0) return; if(check_cmd[1].size()>32 || check_cmd[2].size()>32 || check_cmd[3].size()>32) return; if(checkString(check_cmd[1])==false || checkString(check_cmd[2])==false || checkString(check_cmd[3]) == false){ LOG4CXX_WARN(logger_, "check string false:"<<check_cmd[1]<<";"<<check_cmd[2]<<";"<<check_cmd[3]); } bool check = false; check = dh_->usernameHasBeenUsed(check_cmd[2]); if(check == true){ sendErrorResponse(e.fd_, CMD_REGISTER,ERROR_USERNAME_HAS_BEEN_USED); return; }else{ if(dh_->db_error_ != 0){ sendErrorResponse(e.fd_, CMD_REGISTER, ERROR_SYSTEM_CRITICAL_ERROR); return; } long long user_id; check = dh_->registerNewUser(check_cmd[2],check_cmd[3],check_cmd[1],user_id); if(check == true){ LOG4CXX_INFO(logger_, "register;"<<user_id); string res = buildRegisterResponse(); nh_->sendString(e.fd_, res); return; }else{ sendErrorResponse(e.fd_, CMD_REGISTER,ERROR_SYSTEM_CRITICAL_ERROR); return; } } //string res = buildRegisterResponse(); //nh_->sendString(e.fd_, res); return; }
void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/, const std::string &/*id*/) { std::string session = getSessionName(user, legacyName); if (m_sessions[session] == NULL) { LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user"); return; } std::string target = getTargetName(legacyName); // We are sending PM message. On XMPP side, user is sending PM using the particular channel, // for example #[email protected]/hanzz. On IRC side, we are forwarding this message // just to "hanzz". Therefore we have to somewhere store, that message from "hanzz" should // be mapped to #[email protected]/hanzz. if (legacyName.find("/") != std::string::npos) { m_sessions[session]->addPM(target, legacyName.substr(0, legacyName.find("@"))); } LOG4CXX_INFO(logger, user << ": Session name: " << session << ", message to " << target); if (message.find("/me") == 0) { m_sessions[session]->sendCommand(IrcCommand::createCtcpAction(FROM_UTF8(target), FROM_UTF8(message.substr(4)))); } else if (message.find("/whois") == 0 || message.find(".whois") == 0) { m_sessions[session]->sendWhoisCommand(target, message.substr(7)); return; } else { m_sessions[session]->sendCommand(IrcCommand::createMessage(FROM_UTF8(target), FROM_UTF8(message))); } if (target.find("#") == 0) { handleMessage(user, legacyName, message, TO_UTF8(m_sessions[session]->nickName())); } }