/* check permissions and setup the upload transfer */
void upload_start(const char *nick, const char *hostname, const char *hostmask,
const char *filename, const char *remoteip, const char *remoteport, const char *bytes, char *token)
{
upload *ul;
char *uploaddir;
char *tempstr;
off_t len;
updatecontext();
len = atoull(bytes);
if (invalid_upload(nick, hostmask, len))
return;
uploaddir = get_uploaddir(hostmask);
if (uploaddir == NULL) {
error_upload_start(nick, hostmask, "no uploaddir", "No uploaddir defined.");
return;
}
if (disk_full(uploaddir) != 0) {
error_upload_start(nick, hostmask, "disk full", "not enough free space on disk");
return;
}
if (file_uploading(filename) != 0) {
error_upload_start(nick, hostmask, "upload running", "I'm already getting this file");
return;
}
if (max_uploads_reached() != 0) {
error_upload_start(nick, hostmask, "too many uploads", "I'm already getting too many files");
return;
}
ul = irlist_add(&gdata.uploads, sizeof(upload));
l_initvalues(ul);
ul->file = mystrdup(getfilename(filename));
ul->con.family = (strchr(remoteip, ':')) ? AF_INET6 : AF_INET;
ul->con.remoteaddr = mystrdup(remoteip);
ul->con.remoteport = atoi(remoteport);
ul->totalsize = len;
ul->nick = mystrdup(nick);
ul->hostname = mystrdup(hostname);
ul->uploaddir = mystrdup(uploaddir);
ul->net = gnetwork->net;
qupload_started(gnetwork->net, nick);
tempstr = getsendname(ul->file);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"DCC Send Accepted from %s on %s: %s (%" LLPRINTFMT "dkB)",
nick, gnetwork->name, tempstr,
(ul->totalsize / 1024));
mydelete(tempstr);
if (gdata.mirc_dcc64)
if (ul->totalsize > 0xFFFFFFFFL)
ul->mirc_dcc64 = 1;
if (ul->con.remoteport > 0U) {
l_establishcon(ul);
} else {
/* Passive DCC */
l_setup_passive(ul, token);
}
}
/* search the DDC transfer a user wants to resume */
unsigned int t_find_resume(const char *nick, const char *filename, const char *localport, const char *bytes, char *token)
{
char *sendnamestr;
transfer *guess;
transfer *tr;
off_t len;
guess = NULL;
for (tr = irlist_get_head(&gdata.trans);
tr;
tr = irlist_get_next(tr)) {
if ((tr->tr_status != TRANSFER_STATUS_LISTENING) && (tr->tr_status != TRANSFER_STATUS_RESUME))
continue;
if (strcasecmp(tr->caps_nick, nick))
continue;
/* the filename can be converted */
if (guess == NULL)
guess = tr;
if (strcasestr(tr->xpack->file, filename))
break;
if (tr->con.localport == (unsigned)atoi(localport))
break;
}
if (tr == NULL) {
if (guess != NULL) {
outerror(OUTERROR_TYPE_WARN,
"Guessed transfer that %s on %s tried to resume!",
nick, gnetwork->name);
outerror(OUTERROR_TYPE_WARN,
"resume trying %s, %s, %d",
nick, filename, atoi(localport));
tr = guess;
} else {
t_find_debug(nick, filename, localport);
return 1;
}
}
len = atoull(bytes);
if (len >= tr->xpack->st_size) {
notice(nick, "You can't resume the transfer at a point greater than the size of the file");
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"XDCC [%02i:%s on %s]: Resume attempted beyond end of file ( %" LLPRINTFMT "d >= %" LLPRINTFMT "d )",
tr->id, tr->nick, gnetwork->name, len,
tr->xpack->st_size);
return 1;
}
t_setresume(tr, bytes);
sendnamestr = getsendname(filename);
if ((tr->tr_status == TRANSFER_STATUS_RESUME) && (token != NULL)) {
privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s %s" IRC_CTCP, sendnamestr, localport, bytes, token); /* NOTRANSLATE */
} else {
privmsg_fast(nick, IRC_CTCP "DCC ACCEPT %s %s %s" IRC_CTCP, sendnamestr, localport, bytes); /* NOTRANSLATE */
}
mydelete(sendnamestr);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_YELLOW,
"XDCC [%02i:%s on %s]: Resumed at %" LLPRINTFMT "dK", tr->id,
tr->nick, gnetwork->name, tr->startresume/1024);
return 0;
}
int64 MoneyStringToMoney(const std::string& moneyString)
{
int64 money = 0;
if (!(std::count(moneyString.begin(), moneyString.end(), 'g') == 1 ||
std::count(moneyString.begin(), moneyString.end(), 's') == 1 ||
std::count(moneyString.begin(), moneyString.end(), 'c') == 1))
return 0; // Bad format
Tokenizer tokens(moneyString, ' ');
for (Tokenizer::const_iterator itr = tokens.begin(); itr != tokens.end(); ++itr)
{
std::string tokenString(*itr);
size_t gCount = std::count(tokenString.begin(), tokenString.end(), 'g');
size_t sCount = std::count(tokenString.begin(), tokenString.end(), 's');
size_t cCount = std::count(tokenString.begin(), tokenString.end(), 'c');
if (gCount + sCount + cCount != 1)
return 0;
uint64 amount = atoull(*itr);
if (gCount == 1)
money += amount * 100 * 100;
else if (sCount == 1)
money += amount * 100;
else if (cCount == 1)
money += amount;
}
return money;
}
ObjectGuid::LowType ChatHandler::extractLowGuidFromLink(char* text, HighGuid& guidHigh)
{
int type = 0;
// |color|Hcreature:creature_guid|h[name]|h|r
// |color|Hgameobject:go_guid|h[name]|h|r
// |color|Hplayer:name|h[name]|h|r
char* idS = extractKeyFromLink(text, guidKeys, &type);
if (!idS)
return 0;
switch (type)
{
case GUID_LINK_PLAYER:
{
guidHigh = HighGuid::Player;
std::string name = idS;
if (!normalizePlayerName(name))
return 0;
if (Player* player = ObjectAccessor::FindPlayerByName(name))
return player->GetGUID().GetCounter();
ObjectGuid guid = ObjectMgr::GetPlayerGUIDByName(name);
if (guid.IsEmpty())
return 0;
return guid.GetCounter();
}
case GUID_LINK_CREATURE:
{
guidHigh = HighGuid::Creature;
ObjectGuid::LowType lowguid = atoull(idS);
return lowguid;
}
case GUID_LINK_GAMEOBJECT:
{
guidHigh = HighGuid::GameObject;
ObjectGuid::LowType lowguid = atoull(idS);
return lowguid;
}
}
// unknown type?
return 0;
}
static bool HandleLfgGroupInfoCommand(ChatHandler* handler, char const* args)
{
Player* playerTarget;
ObjectGuid guidTarget;
std::string nameTarget;
ObjectGuid parseGUID = ObjectGuid::Create<HighGuid::Player>(uint64(atoull(args)));
if (sObjectMgr->GetPlayerNameByGUID(parseGUID, nameTarget))
{
playerTarget = ObjectAccessor::FindPlayer(parseGUID);
guidTarget = parseGUID;
}
else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
return false;
Group* groupTarget = NULL;
if (playerTarget)
groupTarget = playerTarget->GetGroup();
else
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
stmt->setUInt32(0, guidTarget.GetCounter());
PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
if (resultGroup)
groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
}
if (!groupTarget)
{
handler->PSendSysMessage(LANG_LFG_NOT_IN_GROUP, nameTarget.c_str());
handler->SetSentErrorMessage(true);
return false;
}
ObjectGuid guid = groupTarget->GetGUID();
std::string const& state = lfg::GetStateString(sLFGMgr->GetState(guid));
handler->PSendSysMessage(LANG_LFG_GROUP_INFO, groupTarget->isLFGGroup(),
state.c_str(), sLFGMgr->GetDungeon(guid));
Group::MemberSlotList const& members = groupTarget->GetMemberSlots();
for (Group::MemberSlotList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
{
Group::MemberSlot const& slot = *itr;
Player* p = ObjectAccessor::FindPlayer((*itr).guid);
if (p)
GetPlayerInfo(handler, p);
else
handler->PSendSysMessage("%s is offline.", slot.name.c_str());
}
return true;
}
void sBook::ParseBookEntry(char * ptr, int line_no)
{
char token[256];
int token_no = 1;
for (;;) {
ptr = Parser.ParseToken(ptr, token);
if (token_no == 1) myBook[line_no].hash = atoull(token);
if (token_no == 2) myBook[line_no].move = atoi(token);
if (token_no == 3) myBook[line_no].freq = atoi(token);
token_no++;
if (*token == '\0') break;
}
}
void sLearner::ParseLearnEntry(char * ptr, int line_no)
{
char token[256];
int token_no = 1;
for (;;) {
ptr = Parser.ParseToken(ptr, token);
if (token_no == 1) learnData[line_no].hash = atoull(token);
if (token_no == 2) learnData[line_no].depth = atoi(token);
if (token_no == 3) learnData[line_no].val = atoi(token);
token_no++;
if (*token == '\0') break;
}
}
std::shared_ptr<Chip> AxessTMC13ReaderUnit::getChipInAir()
{
std::shared_ptr<Chip> chip;
std::vector<unsigned char> cmd;
cmd.push_back(static_cast<unsigned char>('s'));
std::vector<unsigned char> tmpASCIIId = getDefaultAxessTMC13ReaderCardAdapter()->sendCommand(cmd);
if (tmpASCIIId.size() > 0 && tmpASCIIId[0] != 'N')
{
unsigned long long l = atoull(BufferHelper::getStdString(tmpASCIIId));
char bufTmpId[64];
sprintf(bufTmpId, "%llx", l);
chip = ReaderUnit::createChip(
(d_card_type == CHIP_UNKNOWN ? CHIP_GENERICTAG : d_card_type),
formatHexString(std::string(bufTmpId))
);
}
return chip;
}
void t_setresume(transfer * const t, const char *amt) {
updatecontext();
t->startresume = (off_t)atoull(amt);
t->lastack = t->startresume;
}
