Parameter::Parameter(Node *node, const ParameterName& name, const ParameterType& type, Channel channels, ParameterDirection direction) : m_node(node), m_name(name), m_verboseName(""), m_type(type), m_direction(direction), m_connection(0), m_channelCount(channels), m_channels(new Value[channels]) { if (validName(name)) { m_name = name; } else { throw InvalidName(); } if (channels <= 0) { throw InvalidName(); } for (Channel i=0; i<m_channelCount;++i) { if (m_type == kInt) { m_channels[i].i = 0; } else if (m_type == kFloat) { m_channels[i].f = 0; } else if (m_type == kString) { m_channels[i].s = new std::string; } else { m_channels[i].d = 0; } } }
void connect_bang(t_connect *x) { int i, j; x->f_inc = 0; if (x->f_nbSelected > 0) { for (i = 0; i < x->f_nbSelected; i++) { if(validName(x->f_object[i])) { x->f_object[x->f_inc++] = x->f_object[i]; } } for(i = 1; i < x->f_inc; i++) { if (object_classname(jbox_get_object(x->f_object[i -1])) == gensym("hoa.decoder~") || object_classname(jbox_get_object(x->f_object[i -1])) == gensym("hoa.projector~")) { for(j = 0; j < x->f_output; j++) { connect_connect(x->f_patcher, x->f_object[i -1], j, x->f_object[i], j); } } else if (object_classname(jbox_get_object(x->f_object[i -1])) == gensym("jpatcher")) { for(j = 0; j < x->f_harmonics; j++) { connect_connect(x->f_patcher, x->f_object[i -1], j, x->f_object[i], j); } } else { for(j = 0; j < x->f_harmonics; j++) { connect_connect(x->f_patcher, x->f_object[i -1], j, x->f_object[i], j); } } } for(i = 0; i < CONNECT_MAX_TAB; i++) x->f_object[i] = NULL; jpatcher_set_dirty(x->f_patcherview, true); } x->f_nbSelected = 0; color_patchline(x); }
MObject HesperisTransformCreator::create(BaseTransform * data, MObject & parentObj, const std::string & nodeName) { MObject otm = MObject::kNullObj; if(!HesperisIO::FindNamedChild(otm, nodeName, parentObj)) { MFnTransform ftransform; otm = ftransform.create(parentObj); std::string validName(nodeName); SHelper::noColon(validName); ftransform.setName(validName.c_str()); } // MGlobal::displayInfo(MString("todo transform in ")+nodeName.c_str()); return otm; }
int du_file(const char * pathname) { struct stat st; struct dirent* stdir; char current [PATH_MAX+1]; int size;/*count dir size*/ DIR * dir; /*Check if the st is init*/ assert(lstat(pathname, &st) == 0); /*if it is a regular file, return the size (using the opt)*/ if(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode) ){ return opt_apparent_size ? st.st_size : st.st_blocks; } /*If is a directory*/ if(S_ISDIR(st.st_mode)){ /*Open directory*/ dir = opendir(pathname); /*add the directory size (unsing the opt)*/ size = opt_apparent_size ? st.st_size : st.st_blocks ; while( (stdir = readdir(dir)) != NULL ){ /*if the directory is the same or the parent ignore*/ if(!validName(stdir->d_name)){ continue; } /*add the path of the current dir to the given path*/ snprintf(current,PATH_MAX,"%s/%s",pathname, stdir->d_name); size+= du_file(current); } closedir(dir); return size; } /*4 autres type possibles*/ printf("Warning the pathname were ignored because the type of file is not treated"); return 0; }
int insertName(int line, int row, char *name, int menu) { int valid; char temp[1000]; gotoxy(line, row); gets(temp); valid = validName(temp, 2); if (valid != -1){ valid = inputInfoYesOrNo(menu); if (valid == 0){ strcpy(name, temp); return 0; } else if (valid == -1) return -2; gotoxy(0, 16); lineClear(); gotoxy(0, 17); lineClear(); gotoxy(0, 18); lineClear(); gotoxy(0, 26); lineClear(); gotoxy(0, 28); lineClear(); } return valid; }
inline bool validName(const std::string& name) { return validName(name.c_str(), name.size()); }
//------------------------------------------------------------------------------------- bool Loginapp::_createAccount(Network::Channel* pChannel, std::string& accountName, std::string& password, std::string& datas, ACCOUNT_TYPE type) { AUTO_SCOPED_PROFILE("createAccount"); ACCOUNT_TYPE oldType = type; if(!g_kbeSrvConfig.getDBMgr().account_registration_enable) { WARNING_MSG(fmt::format("Loginapp::_createAccount({}): not available!\n", accountName)); std::string retdatas = ""; Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_REGISTER_NOT_AVAILABLE; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } accountName = KBEngine::strutil::kbe_trim(accountName); password = KBEngine::strutil::kbe_trim(password); if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName too big, size={}, limit={}.\n", accountName.size(), ACCOUNT_NAME_MAX_LENGTH)); return false; } if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: password too big, size={}, limit={}.\n", password.size(), ACCOUNT_PASSWD_MAX_LENGTH)); return false; } if(datas.size() > ACCOUNT_DATA_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: bindatas too big, size={}, limit={}.\n", datas.size(), ACCOUNT_DATA_MAX_LENGTH)); return false; } std::string retdatas = ""; if(shuttingdown_ != SHUTDOWN_STATE_STOP) { WARNING_MSG(fmt::format("Loginapp::_createAccount: shutting down, create {} failed!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_IN_SHUTTINGDOWN; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName)); if(ptinfos != NULL) { WARNING_MSG(fmt::format("Loginapp::_createAccount: pendingCreateMgr has {}, request create failed!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } { // 把请求交由脚本处理 SERVER_ERROR_CODE retcode = SERVER_SUCCESS; SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onRequestCreateAccount"), const_cast<char*>("ssy#"), accountName.c_str(), password.c_str(), datas.c_str(), datas.length()); if(pyResult != NULL) { if(PySequence_Check(pyResult) && PySequence_Size(pyResult) == 4) { char* sname; char* spassword; char *extraDatas; Py_ssize_t extraDatas_size = 0; if(PyArg_ParseTuple(pyResult, "H|s|s|y#", &retcode, &sname, &spassword, &extraDatas, &extraDatas_size) == -1) { ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error! accountName={}\n", g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName)); retcode = SERVER_ERR_OP_FAILED; } else { accountName = sname; password = spassword; if (extraDatas && extraDatas_size > 0) datas.assign(extraDatas, extraDatas_size); else SCRIPT_ERROR_CHECK(); } } else { ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error, must be errorcode or tuple! accountName={}\n", g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName)); retcode = SERVER_ERR_OP_FAILED; } Py_DECREF(pyResult); } else { SCRIPT_ERROR_CHECK(); retcode = SERVER_ERR_OP_FAILED; } if(retcode != SERVER_SUCCESS) { Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } else { if(accountName.size() == 0) { ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName is empty!\n")); retcode = SERVER_ERR_NAME; Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } } } if(type == ACCOUNT_TYPE_SMART) { if (email_isvalid(accountName.c_str())) { type = ACCOUNT_TYPE_MAIL; } else { if(!validName(accountName)) { ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } type = ACCOUNT_TYPE_NORMAL; } } else if(type == ACCOUNT_TYPE_NORMAL) { if(!validName(accountName)) { ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } } else if (!email_isvalid(accountName.c_str())) { /* std::string user_name, domain_name; user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") ); domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") ); */ WARNING_MSG(fmt::format("Loginapp::_createAccount: invalid mail={}\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } DEBUG_MSG(fmt::format("Loginapp::_createAccount: accountName={}, passwordsize={}, type={}, oldType={}.\n", accountName.c_str(), password.size(), type, oldType)); ptinfos = new PendingLoginMgr::PLInfos; ptinfos->accountName = accountName; ptinfos->password = password; ptinfos->datas = datas; ptinfos->addr = pChannel->addr(); pendingCreateMgr_.add(ptinfos); Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE); Components::ComponentInfos* dbmgrinfos = NULL; if(cts.size() > 0) dbmgrinfos = &(*cts.begin()); if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0) { ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } pChannel->extra(accountName); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(DbmgrInterface::reqCreateAccount); uint8 uatype = uint8(type); (*pBundle) << accountName << password << uatype; (*pBundle).appendBlob(datas); dbmgrinfos->pChannel->send(pBundle); return true; }
void WorkerThread::runUnzip() { emit(beginRunUnzip()); emit(stageEvent("Extracting and merging game data")); emit(infoEvent("Unzipping original game files")); CZipArchive zip; try { zip.Open(m_gameFileName.toStdString().c_str(), CZipArchive::zipOpenReadOnly); ZIP_SIZE_TYPE totalSize = 0; for(ZIP_INDEX_TYPE i = 0; i < zip.GetCount(); i++) { totalSize += zip.GetFileInfo(i)->m_uUncomprSize; // uncompressed size QString name = QString::fromUtf8(zip.GetFileInfo(i)->GetFileName()); if(!validName(name)) { emit(errorEvent("Game pack contains illegal file names (e.g. " + name + ")")); emit(infoEvent("A near future release of WHDRun will fix this problem, sorry for the inconvenience")); m_die = true; return; } } emit(unzipTotalSize(totalSize)); ZIP_SIZE_TYPE progress = 0; for(ZIP_INDEX_TYPE i = 0; i < zip.GetCount(); i++) { progress += zip.GetFileInfo(i)->m_uUncomprSize; zip.ExtractFile(i, m_tempPath.toUtf8()); emit(unzipProgress(progress)); } zip.Close(); } catch(CZipException ex) { zip.Close(CZipArchive::afAfterException); emit(errorEvent(QString("Error while unzipping: %1").arg((LPCTSTR)ex.GetErrorDescription()))); m_die = true; // no need to rezip return; } emit(infoEvent("Collecting checksums of unmodified files")); emit(beginCollect()); m_checksums.clear(); collectFiles(m_tempPath, &m_checksums); // TODO: progress for this? (should always be quick) QString gameFileBase = QFileInfo(m_gameFileName).baseName(); QString diffFileName = m_dataPath + "/" + gameFileBase + __WHDRun__DiffSuffix; if(QFileInfo(diffFileName).exists()) { emit(infoEvent("Merging original game files with previously modified files")); CZipArchive zip; try { zip.Open(diffFileName.toUtf8(), CZipArchive::zipOpenReadOnly); //TODO: progress infoEvent for this? (should always be quick) for (ZIP_INDEX_TYPE i = 0; i < zip.GetCount(); i++) { zip.ExtractFile(i, m_tempPath.toUtf8()); } zip.Close(); } catch(CZipException ex) { zip.Close(CZipArchive::afAfterException); emit(errorEvent(QString("Error while unzipping changes: %1").arg((LPCTSTR)ex.GetErrorDescription()))); m_die = true; // no need to rezip return; } } emit(endRunUnzip()); }
//------------------------------------------------------------------------------------- bool Loginapp::_createAccount(Network::Channel* pChannel, std::string& accountName, std::string& password, std::string& datas, ACCOUNT_TYPE type) { AUTO_SCOPED_PROFILE("createAccount"); ACCOUNT_TYPE oldType = type; if(!g_kbeSrvConfig.getDBMgr().account_registration_enable) { WARNING_MSG(fmt::format("Loginapp::_createAccount({}): not available!\n", accountName)); std::string retdatas = ""; Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_REGISTER_NOT_AVAILABLE; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } accountName = KBEngine::strutil::kbe_trim(accountName); password = KBEngine::strutil::kbe_trim(password); if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName too big, size={}, limit={}.\n", accountName.size(), ACCOUNT_NAME_MAX_LENGTH)); return false; } if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: password too big, size={}, limit={}.\n", password.size(), ACCOUNT_PASSWD_MAX_LENGTH)); return false; } if(datas.size() > ACCOUNT_DATA_MAX_LENGTH) { ERROR_MSG(fmt::format("Loginapp::_createAccount: bindatas too big, size={}, limit={}.\n", datas.size(), ACCOUNT_DATA_MAX_LENGTH)); return false; } std::string retdatas = ""; if(shuttingdown_ != SHUTDOWN_STATE_STOP) { WARNING_MSG(fmt::format("Loginapp::_createAccount: shutting down, create {} failed!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_IN_SHUTTINGDOWN; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName)); if(ptinfos != NULL) { WARNING_MSG(fmt::format("Loginapp::_createAccount: pendingCreateMgr has {}, request create failed!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } if(type == ACCOUNT_TYPE_SMART) { if (email_isvalid(accountName.c_str())) { type = ACCOUNT_TYPE_MAIL; } else { if(!validName(accountName)) { ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } type = ACCOUNT_TYPE_NORMAL; } } else if(type == ACCOUNT_TYPE_NORMAL) { if(!validName(accountName)) { ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } } else if (!email_isvalid(accountName.c_str())) { /* std::string user_name, domain_name; user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") ); domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") ); */ WARNING_MSG(fmt::format("Loginapp::_createAccount: invalid mail={}\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } DEBUG_MSG(fmt::format("Loginapp::_createAccount: accountName={}, passwordsize={}, type={}, oldType={}.\n", accountName.c_str(), password.size(), type, oldType)); ptinfos = new PendingLoginMgr::PLInfos; ptinfos->accountName = accountName; ptinfos->password = password; ptinfos->datas = datas; ptinfos->addr = pChannel->addr(); pendingCreateMgr_.add(ptinfos); Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE); Components::ComponentInfos* dbmgrinfos = NULL; if(cts.size() > 0) dbmgrinfos = &(*cts.begin()); if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0) { ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n", accountName)); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY; (*pBundle) << retcode; (*pBundle).appendBlob(retdatas); pChannel->send(pBundle); return false; } pChannel->extra(accountName); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(DbmgrInterface::reqCreateAccount); uint8 uatype = uint8(type); (*pBundle) << accountName << password << uatype; (*pBundle).appendBlob(datas); dbmgrinfos->pChannel->send(pBundle); return true; }
//------------------------------------------------------------------------------------- bool Loginapp::_createAccount(Mercury::Channel* pChannel, std::string& accountName, std::string& password, std::string& datas, ACCOUNT_TYPE type) { accountName = KBEngine::strutil::kbe_trim(accountName); password = KBEngine::strutil::kbe_trim(password); if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH) { ERROR_MSG(boost::format("Loginapp::_createAccount: accountName too big, size=%1%, limit=%2%.\n") % accountName.size() % ACCOUNT_NAME_MAX_LENGTH); return false; } if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH) { ERROR_MSG(boost::format("Loginapp::_createAccount: password too big, size=%1%, limit=%2%.\n") % password.size() % ACCOUNT_PASSWD_MAX_LENGTH); return false; } if(datas.size() > ACCOUNT_DATA_MAX_LENGTH) { ERROR_MSG(boost::format("Loginapp::_createAccount: bindatas too big, size=%1%, limit=%2%.\n") % datas.size() % ACCOUNT_DATA_MAX_LENGTH); return false; } std::string retdatas = ""; if(shuttingdown_) { WARNING_MSG(boost::format("Loginapp::_createAccount: shutting down, create %1% failed!\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_SHUTTINGDOWN; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName)); if(ptinfos != NULL) { WARNING_MSG(boost::format("Loginapp::_createAccount: pendingCreateMgr has %1%, request create failed!\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } if(type == ACCOUNT_TYPE_SMART) { if (email_isvalid(accountName.c_str())) { type = ACCOUNT_TYPE_MAIL; } else { if(!validName(accountName)) { ERROR_MSG(boost::format("Loginapp::_createAccount: invalid accountName(%1%)\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } type = ACCOUNT_TYPE_NORMAL; } } else if(type == ACCOUNT_TYPE_NORMAL) { if(!validName(accountName)) { ERROR_MSG(boost::format("Loginapp::_createAccount: invalid accountName(%1%)\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } } else if (!email_isvalid(accountName.c_str())) { /* std::string user_name, domain_name; user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") ); domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") ); */ WARNING_MSG(boost::format("Loginapp::_createAccount: invalid mail=%1%\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } DEBUG_MSG(boost::format("Loginapp::_createAccount: accountName=%1%, passwordsize=%2%, type=%3%.\n") % accountName.c_str() % password.size() % type); ptinfos = new PendingLoginMgr::PLInfos; ptinfos->accountName = accountName; ptinfos->password = password; ptinfos->datas = datas; ptinfos->addr = pChannel->addr(); pendingCreateMgr_.add(ptinfos); Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE); Components::ComponentInfos* dbmgrinfos = NULL; if(cts.size() > 0) dbmgrinfos = &(*cts.begin()); if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0) { ERROR_MSG(boost::format("Loginapp::_createAccount: create(%1%), not found dbmgr!\n") % accountName); Mercury::Bundle bundle; bundle.newMessage(ClientInterface::onCreateAccountResult); SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY; bundle << retcode; bundle.appendBlob(retdatas); bundle.send(this->getNetworkInterface(), pChannel); return false; } pChannel->extra(accountName); Mercury::Bundle bundle; bundle.newMessage(DbmgrInterface::reqCreateAccount); uint8 uatype = uint8(type); bundle << accountName << password << uatype; bundle.appendBlob(datas); bundle.send(this->getNetworkInterface(), dbmgrinfos->pChannel); return true; }