DWORD WINAPI ProcWaitSignal( LPVOID lpParam){
while(1){
printf("checking queue\n");
Sleep(1000);
if (NbElmt != 0){
if ((!IsUpper(buf)) && (!IsLower(buf))) {
printf("Mengonsumsi ke - %d : %c\n", ind, buf.TI[ind]);
ind++;
NbElmt--; // konsumsi buffer
} else if (IsUpper(buf)) {
SendXOFF();
printf("Masuk Upper limit\n");
printf("Mengonsumsi ke - %d : %c\n", ind, buf.TI[ind]);
ind++;
NbElmt--; // konsumsi buffer
} else if (IsLower(buf)) {
SendXON();
printf("Masuk Lower limit\n");
// no consume0
}
}
}
return 0;
};
void WordToken::SetCapped(const char *s) {
if (IsUpper(*s))
firstCapped = 1;
for(; *s; s++)
if (!IsUpper(*s))
return;
allCapped = 1;
}
static WString sSwapCase(const WString& s)
{
WStringBuffer r;
r.SetCount(s.GetCount());
for(int i = 0; i < s.GetCount(); i++)
r[i] = IsUpper(s[i]) ? ToLower(s[i]) : ToUpper(s[i]);
return r;
}
static const std::vector<wchar_t> create_alt_sort_table()
{
std::vector<wchar_t> alt_sort_table(WCHAR_MAX + 1);
std::vector<wchar_t> chars(WCHAR_MAX + 1);
std::iota(ALL_RANGE(chars), 0);
std::sort(chars.begin() + 1, chars.end(), [](wchar_t a, wchar_t b) { return StrCmpNN(&a, 1, &b, 1) < 0; });
int u_beg = 0, u_end = 0xffff;
for (int ic=0; ic < 0x10000; ++ic)
{
if (chars[ic] == L'a')
{
u_beg = ic;
break;
}
alt_sort_table[chars[ic]] = static_cast<wchar_t>(ic);
}
for (int ic=0xffff; ic > u_beg; --ic)
{
if (IsUpper(chars[ic]))
{
u_end = ic;
break;
}
alt_sort_table[chars[ic]] = static_cast<wchar_t>(ic);
}
assert(u_beg > 0 && u_beg < u_end && u_end < 0xffff);
int cc = u_beg;
for (int ic=u_beg; ic <= u_end; ++ic) // uppercase first
{
if (IsUpper(chars[ic]))
alt_sort_table[chars[ic]] = static_cast<wchar_t>(cc++);
}
for (int ic=u_beg; ic <= u_end; ++ic) // than not uppercase
{
if (!IsUpper(chars[ic]))
alt_sort_table[chars[ic]] = static_cast<wchar_t>(cc++);
}
assert(cc == u_end+1);
return alt_sort_table;
}
void CzString::ToLower()
{
char* pData = Data;
for (int t = 0; t < Length; t++)
{
char c = *pData;
if (IsUpper(c))
{
c += 'a' - 'A';
*pData++ = c;
}
else
pData++;
}
}
void WordToken::SetFirstInSentence(bool b) {
// std::cout << "sf " << string << std::endl;
char st[MAX_WORD_LENGTH];
firstInSentence = b;
if (b) {
if (IsUpper(*string))
return;
*st = Upper(*string);
} else {
if (IsLower(*string))
return;
*st = Lower(*string);
}
strcpy(st+1, string+1);
SetWord(word, st, token);
}
String ToUpper_Caps(const String& name)
{
String output("");
int str_len = name.GetLength();
for (int i = 0; i < str_len; ++i)
{
int ch = name[i];
if (IsAlNum(ch))
{
output += ToUpper(ch);
if (i < str_len - 1)
if (IsLower(ch) && IsUpper(name[i + 1]))
output += '_';
}
else
output += '_';
}
return output;
}
static int GetPeserveCaseStyleMask(const string& strStr)
{
int Result = 15;
for (size_t I = 0; I < strStr.size(); I++)
{
int Upper = IsUpper(strStr[I]);
int Lower = IsLower(strStr[I]);
if (!Upper)
Result &= ~(1 << UPPERCASE_ALL);
if (!Lower)
Result &= ~(1 << LOWERCASE_ALL);
if ((!Upper || !IsAlpha(strStr[I])) && I == 0)
Result &= ~(1 << UPPERCASE_FIRST);
if (!Lower && I > 0)
Result &= ~(1 << UPPERCASE_FIRST);
}
return Result;
}
static void
h_can_send(void *vdata)
{
char *text;
size_t contor;
int caps = 0;
int len = 0;
hook_data_channel_approval *data = (hook_data_channel_approval *) vdata;
if ((data->chptr->mode.mode & mymode) &&
((strchr(ConfigChannel.exemptchanops, 'G') == NULL) ||
!is_any_op(data->msptr)))
{
/* 2 == unprintable */
text = ((char **)data->data)[2];
if(strlen(text) < 10)
return;
for(contor = 0; contor < strlen(text); contor++)
{
if(IsUpper(text[contor]) && !isdigit(text[contor]))
caps++;
len++;
}
/* Added divide by 0 check --alxbl */
if(len > 0 && ((caps * 100) / len) >= conf_threshold)
{
if(data->cmd == COMMAND_PRIVMSG)
sendto_one_numeric(data->client, 404,
"%s :Cannot send to channel - Your message contains more than %d%% capital letters (+G set)",
data->chptr->chname, conf_threshold);
data->approved = CAN_SEND_NO_NONOTIFY;
return;
}
}
return;
}
static int exec(FILE* fp, ENC_INFO* einfo)
{
#define NCOL 8
int c, val, enc;
enc = einfo->num;
fprintf(fp, "static const unsigned short Enc%s_CtypeTable[256] = {\n",
einfo->name);
for (c = 0; c < 256; c++) {
val = 0;
if (IsNewline(enc, c)) val |= BIT_CTYPE_NEWLINE;
if (IsAlpha (enc, c)) val |= (BIT_CTYPE_ALPHA | BIT_CTYPE_ALNUM);
if (IsBlank (enc, c)) val |= BIT_CTYPE_BLANK;
if (IsCntrl (enc, c)) val |= BIT_CTYPE_CNTRL;
if (IsDigit (enc, c)) val |= (BIT_CTYPE_DIGIT | BIT_CTYPE_ALNUM);
if (IsGraph (enc, c)) val |= BIT_CTYPE_GRAPH;
if (IsLower (enc, c)) val |= BIT_CTYPE_LOWER;
if (IsPrint (enc, c)) val |= BIT_CTYPE_PRINT;
if (IsPunct (enc, c)) val |= BIT_CTYPE_PUNCT;
if (IsSpace (enc, c)) val |= BIT_CTYPE_SPACE;
if (IsUpper (enc, c)) val |= BIT_CTYPE_UPPER;
if (IsXDigit(enc, c)) val |= BIT_CTYPE_XDIGIT;
if (IsWord (enc, c)) val |= BIT_CTYPE_WORD;
if (IsAscii (enc, c)) val |= BIT_CTYPE_ASCII;
if (c % NCOL == 0) fputs(" ", fp);
fprintf(fp, "0x%04x", val);
if (c != 255) fputs(",", fp);
if (c != 0 && c % NCOL == (NCOL-1))
fputs("\n", fp);
else
fputs(" ", fp);
}
fprintf(fp, "};\n");
return 0;
}
bool IsLetter (Char c)
{
return IsLower(c) || IsUpper(c);
}
static inline bool IsAlpha(char c) { return IsLower(c) || IsUpper(c); }
void ExhTestCPEngine::ExhTestProperties()
{
HRESULT hr;
// REVIEW LarsH: how do we pass in the location of the UnicodeData.txt file as
// a parameter? Env var?
StrAnsi staDataFile = L"d:\\lars\\Unicode\\UnicodeData.txt";
FILE *pFileIn = fopen(staDataFile, "r");
if (!pFileIn)
FailureFormat("Unable to open Unicode data file %s", staDataFile);
CodePtData cpdCurrent, cpdNext;
cpdNext.chCodeValue = -1; // uninitialized
// TODO LarsH: We should test through 0x10FFFF, but currently there are
// some problems with higher characters which have been postponed,
// so in order to avoid a humungous error log we'll stick with the first page for now.
// Raid #31
#define JUST_FIRST_PAGE
#ifdef JUST_FIRST_PAGE
for (int ch = 0; ch <= 0xFFFF; ch++)
#else
for (int ch = 0; ch <= 0x10FFFF; ch++)
#endif
{
if (! (ch % 0x1000))
LogFormat("%x:\n", ch);
// Read in the next record unless we've already got this data
if (cpdNext.chCodeValue < ch)
ParseRecord(pFileIn, &cpdNext);
// This is NOT an "else"; it may happen in addition to the above.
if (cpdNext.chCodeValue == ch)
{
// got the right record; copy it over
cpdCurrent.chCodeValue = ch;
strcpy(cpdCurrent.szCategory, cpdNext.szCategory);
wcscpy(cpdCurrent.szwName, cpdNext.szwName);
cpdCurrent.nNumericValue = cpdNext.nNumericValue;
cpdCurrent.nCombiningClass = cpdNext.nCombiningClass;
wcscpy(cpdCurrent.szwDecomposition, cpdNext.szwDecomposition);
cpdCurrent.chUpper = cpdNext.chUpper;
cpdCurrent.chLower = cpdNext.chLower;
cpdCurrent.chTitle = cpdNext.chTitle;
}
// Treat special ranges specially:
if (ch >= 0x3400 && ch <= 0x4db5 || ch >= 0x4e00 && ch <= 0x9fa5)
{
// CJK Ideographs (Extension A and other)
// Most data is same as previous, so don't need to load;
// but must set names algorithmically.
swprintf(cpdCurrent.szwName, L"CJK UNIFIED IDEOGRAPH-%X", ch);
}
else if (ch >= 0xac00 && ch <= 0xd7a3)
{
// Hangul Syllables
// Data for 0xAC00 is loaded, and applies to all others, except
// name and decomp.
HangulDecomposition(ch, cpdCurrent.szwDecomposition);
HangulName(cpdCurrent.szwDecomposition, cpdCurrent.szwName);
}
else if (ch >= 0xd800 &&
// ch <= 0xdb7f || ch >= 0xdb80 && ch <= 0xdbff ||
// ch >= 0xdc00 && ch <= 0xdfff || ch >= 0xe000
ch <= 0xf8ff)
{
// Consecutive ranges: Non-Private Use High Surrogates,
// Private Use High Surrogates, Low Surrogates, Private Use Area.
// All of these are nameless (UnicodeData File Format v3.0.0)
// TODO LarsH: change all this before closing Raid #24.
cpdCurrent.szwName[0] = '\0';
}
else if (ch == 0xfffe || ch == 0xffff || // explicitly "not Unicode chars"
cpdNext.chCodeValue > ch || (cpdNext.chCodeValue < ch && feof(pFileIn)))
{
// Not assigned in the data file.
cpdCurrent.chCodeValue = ch;
cpdCurrent.szwName[0] = '\0';
strcpy(cpdCurrent.szCategory, "Cn");
cpdCurrent.nCombiningClass = 0;
// Must distinguish between lack of a NumericValue and a zero NumericValue.
cpdCurrent.nNumericValue = -1;
cpdCurrent.szwDecomposition[0] = '\0';
// Zero is not an anycase equivalent of any character.
cpdCurrent.chLower = cpdCurrent.chUpper = cpdCurrent.chTitle = ch;
}
// ** If looking for a character with a specific combination of properties,
// ** you can test it here. This would be better done in SQL.
// if (cpdCurrent.szCategory[0] != 'L' && cpdCurrent.chUpper > 0)
// LogFormat("*** U+%x fulfills conditions\n");
// continue; // skip all the usual tests if desired
// Make sure the property interface methods get the same data.
LgGeneralCharCategory cc = ParseCC(cpdCurrent.szCategory);
CheckCat(ch, cc);
ComBool fLet, fPun, fNum, fSep, fSym, fMar, fOth, fAll;
#define CheckBoolProp(prop, var, index, letter) \
{ \
hr = m_qpropeng->get_##prop(ch, &var); \
WarnHr(hr); \
if (var != (cpdCurrent.szCategory[index] == letter)) \
FailureFormat("get_" #prop "(U+%x) gave wrong answer", ch); \
}
CheckBoolProp(IsLetter, fLet, 0, 'L');
CheckBoolProp(IsPunctuation, fPun, 0, 'P');
CheckBoolProp(IsNumber, fNum, 0, 'N');
CheckBoolProp(IsSeparator, fSep, 0, 'Z');
CheckBoolProp(IsSymbol, fSym, 0, 'S');
CheckBoolProp(IsMark, fMar, 0, 'M');
CheckBoolProp(IsOther, fOth, 0, 'C');
// REVIEW LarsH: is int(ComBool) guaranteed to be 1 if true? I think so.
int nCat;
if ((nCat = fLet + fPun + fNum + fSep + fSym + fMar + fOth) != 1)
FailureFormat("Codepoint U+%x is in %d categories instead of one.",
ch, nCat);
if (fLet)
{
ComBool fUpp, fLow, fTit, fMod, fOth;
CheckBoolProp(IsUpper, fUpp, 1, 'u');
CheckBoolProp(IsLower, fLow, 1, 'l');
CheckBoolProp(IsTitle, fTit, 1, 't');
CheckBoolProp(IsModifier, fMod, 1, 'm');
CheckBoolProp(IsOtherLetter, fOth, 1, 'o');
if ((nCat = fUpp + fLow + fTit + fMod + fOth) != 1)
FailureFormat("Letter U+%x is in %d subcategories instead of one.",
ch, nCat);
}
else
{
// All should be false.
CheckBoolProp(IsUpper, fAll, 0, 'L');
CheckBoolProp(IsLower, fAll, 0, 'L');
CheckBoolProp(IsTitle, fAll, 0, 'L');
CheckBoolProp(IsModifier, fAll, 0, 'L');
CheckBoolProp(IsOtherLetter, fAll, 0, 'L');
}
if (fPun)
{
ComBool fOpe, fClo, fMed;
CheckBoolProp(IsOpen, fOpe, 1, 's');
CheckBoolProp(IsClose, fOpe, 1, 'e');
CheckBoolProp(IsWordMedial, fOpe, 1, 'c');
// TODO LarsH: update this if definition in Language.idh changes, e.g.
// if the above methods come to be true for Pd, Pi, Pf
}
else
{
CheckBoolProp(IsOpen, fAll, 0, 'P');
CheckBoolProp(IsClose, fAll, 0, 'P');
CheckBoolProp(IsWordMedial, fAll, 0, 'P');
}
// IsControl should return true if category is Cc, false otherwise:
CheckBoolProp(IsControl, fAll, 1, (cpdCurrent.szCategory[0] == 'C' ? 'c' : 0));
#undef CheckBoolProp
#define IsLetter() (cpdCurrent.szCategory[0] == 'L')
#define IsUpper() (cpdCurrent.szCategory[1] == 'u')
#define IsLower() (cpdCurrent.szCategory[1] == 'l')
#define IsTitle() (cpdCurrent.szCategory[1] == 't')
// We must check IsLetter() etc. because the docs say, if it's not Lu/Ll/Tt, ToUpper() etc.
// don't do case conversion, even if the Unicode database gives a conversion.
int chUpper = -1, chLower = -1, chTitle = -1;
// TODO LarsH: some of these should check different locales
// if such data exists in SpecialCasing.txt
hr = m_qpropeng->get_ToUpperCh(ch, &chUpper);
if (FAILED(hr))
FailureFormat("get_ToUpperCh(0x%x) gave result %s", ch, AsciiHresult(hr));
int chUExp = (IsLetter() && (IsLower() || IsTitle()) && cpdCurrent.chUpper) ?
cpdCurrent.chUpper : ch;
if (chUpper != chUExp)
{
FailureFormat("get_ToUpperCh(0x%x {%s}) returned 0x%x instead of 0x%x",
ch, cpdCurrent.szCategory, chUpper, chUExp);
}
hr = m_qpropeng->get_ToLowerCh(ch, &chLower);
if (FAILED(hr))
FailureFormat("get_ToLowerCh(0x%x) gave result %s", ch, AsciiHresult(hr));
int chLExp = (IsLetter() && (IsUpper() || IsTitle()) && cpdCurrent.chLower) ?
cpdCurrent.chLower : ch;
if (chLower != chLExp)
{
FailureFormat("get_ToLowerCh(0x%x {%s}) returned 0x%x instead of 0x%x",
ch, cpdCurrent.szCategory, chLower, chLExp);
}
hr = m_qpropeng->get_ToTitleCh(ch, &chTitle);
if (FAILED(hr))
FailureFormat("get_ToTitleCh(0x%x) gave result %s", ch, AsciiHresult(hr));
#define FIXED_BUG_198 // just for now
#ifdef FIXED_BUG_198
int chTExp = (IsLetter() && (IsUpper() || IsLower())) ?
(cpdCurrent.chTitle ? cpdCurrent.chTitle : cpdCurrent.chUpper ? cpdCurrent.chUpper : ch) :
ch;
// ToTitleCh() returns the uppercase if there is no titlecase value defined
if (chTitle != chTExp)
{
FailureFormat("get_ToTitleCh(0x%x {%s}) returned 0x%x instead of 0x%x",
ch, cpdCurrent.szCategory, chTitle, chTExp);
}
#endif // FIXED_BUG_198
// TODO LarsH: test get_ToLower, etc. (BSTR functions)
// These should take into account any special casing (SpecialCasing.txt), by testing
// different locales (esp. Turkish) and contexts (FINAL/NON_FINAL, MODERN/NON_MODERN).
wchar pwz[2];
pwz[0] = (wchar)ch;
pwz[1] = '\0';
SmartBstr sbstrFrom(pwz), sbstrTo = L"fish";
// This one properly gives a warning if ch is half of a surrogate pair.
if (ch >= 0xd800 && ch <= 0xdfff) // half a surrogate pair
{
IgnoreWarnings iw;
hr = m_qpropeng->ToLower(sbstrFrom, &sbstrTo);
TestFailZero(sbstrTo, "ToLower");
if (SUCCEEDED(hr))
FailureFormat("ToLower with 0x%x (half a surrogate pair) should have failed", ch);
}
else
{
hr = m_qpropeng->ToLower(sbstrFrom, &sbstrTo);
TestFailZero(sbstrTo, "ToLower");
WarnHr(hr);
// TODO LarsH: check that the return value from get_ToLower is correct
// TODO LarsH: use smart bstrs where possible
}
// TODO LarsH: test get_ToLowerRgch, etc. (Rgch functions)
// TODO LarsH: test IsUserDefinedClass(). Right now there is no way to define
// classes, so this will always return false.
ComBool fRet;
hr = m_qpropeng->get_IsUserDefinedClass(ch, 'A', &fRet);
WarnHr(hr);
if (fRet)
FailureFormat("Character U+%x is a member of class 'A'??", ch);
// TODO LarsH: test SoundAlikeKey
// REVIEW LarsH: is this bstr causing a memory leak on every iteration of ch?
SmartBstr sbstr = L"foo";
// TODO LarsH: Remove this kludge once get_CharacterName(Hangul) is working.
if (ch >= 0xac00 && ch <= 0xd7a3)
goto skipHangul;
hr = m_qpropeng->get_CharacterName(ch, &sbstr);
TestFailZero(sbstr, "get_CharacterName");
if (FAILED(hr))
FailureFormat("get_CharacterName(U+%x) failed", ch);
else if (
#ifndef FIXED_BUG_24
!(ch >= 0xd800 && ch <= 0xf8ff) &&
#endif
wcscmp(cpdCurrent.szwName, sbstr))
{
FailureFormat(L"get_CharacterName(U+%x) returned \"%s\" instead of \"%s\".",
ch, sbstr, cpdCurrent.szwName);
}
// if (sbstr)
// SysFreeString(sbstr);
#ifdef FIXED_BUG_125
sbstr = L"foo";
hr = m_qpropeng->get_Decomposition(ch, &sbstr);
TestFailZero(sbstr, "get_Decomposition");
if (FAILED(hr))
FailureFormat("get_Decomposition(U+%x) failed", ch);
// REVIEW LarsH: Does wcscmp understand NULL sbstrs? Apparently...
else if (sbstr ? wcscmp(cpdCurrent.szwDecomposition, sbstr) :
cpdCurrent.szwDecomposition[0])
{
FailureFormat("Got wrong decomposition for U+%x", ch);
}
// if (sbstr)
// SysFreeString(bstr);
#endif // FIXED_BUG_125
sbstr = NULL;
// TODO LarsH: test DecompositionRgch
// That will probably require a separate pass through the whole UnicodeData
// file to build up a hash table or sthg...
skipHangul:
int nNumericValue;
{
IgnoreWarnings iw;
hr = m_qpropeng->get_NumericValue(ch, &nNumericValue);
}
if (fNum && (cc == kccNd || cc == kccNl || cc == kccNo) && cpdCurrent.nNumericValue > -1)
{
if (FAILED(hr))
FailureFormat("get_NumericValue(U+%x) failed with hr=%s", ch, AsciiHresult(hr));
else if (nNumericValue != cpdCurrent.nNumericValue)
{
FailureFormat("get_NumericValue(U+%x) returned %d instead of %d",
ch, nNumericValue, cpdCurrent.nNumericValue);
}
}
else if (hr != E_UNEXPECTED)
{
FailureFormat("get_NumericValue(U+%x {%s}) gave result %s instead of E_UNEXPECTED",
ch, cpdCurrent.szCategory, AsciiHresult(hr));
}
#define FIXED_BUG_18 1 // Seems to be fixed now.
#ifdef FIXED_BUG_18
int nCombClass;
hr = m_qpropeng->get_CombiningClass(ch, &nCombClass);
WarnHr(hr);
if (nCombClass != cpdCurrent.nCombiningClass)
{
FailureFormat("get_CombiningClass(U+%x) gave %d instead of %d",
ch, nCombClass, cpdCurrent.nCombiningClass);
}
#endif
// TODO LarsH: test everything else
// TODO LarsH: test get_Comment
// TODO LarsH: test GetLineBreakProps if not obsolete
// TODO LarsH: test GetLineBreakStatus if not obsolete
}
}
int CharFilterAlphaToUpper(int c)
{
return IsAlpha(c) ? IsUpper(c) ? c : ToUpper(c) : 0;
}
int m_stats(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Message* mptr;
struct Client* acptr;
char l_stat = parc > 1 ? parv[1][0] : '\0';
int i;
int doall = 0;
int wilds = 0;
int ignore_request = 0;
int valid_stats = 0;
char* name;
char *mename = me.name;
if(sptr->user && sptr->user->vlink)
mename = sptr->user->vlink->name;
if(!IsClient(sptr))
{
return 0;
}
if(!IsAnOper(sptr))
{
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), mename, parv[0]);
return -1;
}
if (hunt_server(cptr,sptr,":%s STATS %s :%s",2,parc,parv)!=HUNTED_ISME)
return 0;
if (parc > 2)
{
name = parv[2];
if (!irccmp(name, mename))
doall = 2;
else if (match(name, mename))
doall = 1;
if (strchr(name, '*') || strchr(name, '?'))
wilds = 1;
}
else
name = mename;
switch (l_stat)
{
case 'L' : case 'l' :
/*
* send info about connections which match, or all if the
* mask matches mename. Only restrictions are on those who
* are invisible not being visible to 'foreigners' who use
* a wild card based search to list it.
*/
for (i = 0; i <= highest_fd; i++)
{
if (!(acptr = local[i]))
continue;
if (!doall && wilds && !match(name, acptr->name))
continue;
if (!(doall || wilds) && irccmp(name, acptr->name))
continue;
/* I've added a sanity test to the "CurrentTime - acptr->since"
* occasionally, acptr->since is larger than CurrentTime.
* The code in parse.c "randomly" increases the "since",
* which means acptr->since is larger then CurrentTime at times,
* this gives us very high odd number..
* So, I am going to return 0 for ->since if this happens.
* - Dianora
*/
/* trust opers not on this server */
/* if(IsAnOper(sptr)) */
/* Don't trust opers not on this server */
#ifdef HIDE_SERVERS_IPS
if(MyClient(sptr) && IsAnOper(sptr) && !IsServer(acptr) &&
!IsConnecting(acptr) && !IsHandshake(acptr))
#else
if(MyClient(sptr) && IsAnOper(sptr))
#endif
{
sendto_one(sptr, Lformat, mename,
RPL_STATSLINKINFO, parv[0],
get_client_name(acptr, TRUE),
(int)DBufLength(&acptr->sendQ),
(int)acptr->sendM, (int)acptr->sendK,
(int)acptr->receiveM, (int)acptr->receiveK,
CurrentTime - acptr->firsttime,
(CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0,
IsServer(acptr) ? show_capabilities(acptr) : "-");
}
else
{
if(IsServer(acptr))
sendto_one(sptr, Lformat, mename,
RPL_STATSLINKINFO, parv[0],
get_client_name(acptr, HIDEME),
(int)DBufLength(&acptr->sendQ),
(int)acptr->sendM, (int)acptr->sendK,
(int)acptr->receiveM, (int)acptr->receiveK,
CurrentTime - acptr->firsttime,
(CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0,
IsServer(acptr) ? show_capabilities(acptr) : "-");
else
sendto_one(sptr, Lformat, mename,
RPL_STATSLINKINFO, parv[0],
(IsUpper(lstat)) ?
get_client_name(acptr, TRUE) :
get_client_name(acptr, FALSE),
(int)DBufLength(&acptr->sendQ),
(int)acptr->sendM, (int)acptr->sendK,
(int)acptr->receiveM, (int)acptr->receiveK,
CurrentTime - acptr->firsttime,
(CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0,
IsServer(acptr) ? show_capabilities(acptr) : "-");
}
}
valid_stats++;
break;
case 'C' : case 'c' :
report_configured_links(sptr, CONF_CONNECT_SERVER|CONF_NOCONNECT_SERVER);
valid_stats++;
break;
case 'B' : case 'b' :
sendto_one(sptr,":%s NOTICE %s :Use stats I instead", mename, parv[0]);
break;
case 'D':
report_dlines(sptr);
valid_stats++;
break;
case 'd':
report_domain_stats(sptr);
valid_stats++;
break;
case 'E' : case 'e' :
sendto_one(sptr,":%s NOTICE %s :Use stats I instead", mename, parv[0]);
break;
case 'F' : case 'f' :
report_channel_stats(sptr);
break;
case 'g' :
report_sxlines(sptr);
valid_stats++;
break;
case 'G' :
report_glines(sptr, NULL);
valid_stats++;
break;
case 'H' : case 'h' :
report_configured_links(sptr, CONF_HUB|CONF_LEAF);
valid_stats++;
break;
case 'i' :
report_vlinks(sptr);
valid_stats++;
break;
case 'I' :
report_mtrie_conf_links(sptr, CONF_CLIENT);
valid_stats++;
break;
case 'k' :
report_temp_klines(sptr);
valid_stats++;
break;
case 'K' :
if(parc > 3)
report_matching_host_klines(sptr,parv[3]);
else
report_mtrie_conf_links(sptr, CONF_KILL);
valid_stats++;
break;
case 'M' : case 'm' :
for (mptr = msgtab; mptr->cmd; mptr++)
sendto_one(sptr, form_str(RPL_STATSCOMMANDS),
mename, parv[0], mptr->cmd,
mptr->count, mptr->bytes);
valid_stats++;
break;
case 'o' : case 'O' :
report_configured_links(sptr, CONF_OPS);
valid_stats++;
break;
case 'P' :
show_ports(sptr);
valid_stats++;
break;
case 'p' :
show_opers(sptr);
valid_stats++;
break;
case 'Q' :
report_qlines(sptr);
valid_stats++;
break;
case 'q' :
report_sqlines(sptr);
valid_stats++;
break;
case 'R' : case 'r' :
send_usage(sptr,parv[0]);
valid_stats++;
break;
case 'S' :
list_scache(cptr,sptr,parc,parv);
valid_stats++;
break;
case 'T' : case 't' :
tstats(sptr, parv[0]);
valid_stats++;
break;
case 'U' :
report_specials(sptr,CONF_ULINE,RPL_STATSULINE);
valid_stats++;
break;
case 'u' :
{
time_t now;
now = CurrentTime - me.since;
sendto_one(sptr, form_str(RPL_STATSUPTIME), mename, parv[0],
now/86400, (now/3600)%24, (now/60)%60, now%60);
sendto_one(sptr, form_str(RPL_STATSCONN), mename, parv[0],
MaxConnectionCount, MaxClientCount,
Count.totalrestartcount);
valid_stats++;
break;
}
case 'V' :
show_servers(sptr);
valid_stats++;
break;
case 'v' :
report_svlines(sptr);
valid_stats++;
break;
case 'x' :
report_specials(sptr,CONF_XLINE,RPL_STATSXLINE);
valid_stats++;
break;
case 'X' :
report_configured_links(sptr, CONF_MISSING);
valid_stats++;
break;;
case 'Y' : case 'y' :
report_classes(sptr);
valid_stats++;
break;
case 'Z' :
report_zlines(sptr);
valid_stats++;
break;
case 'z' :
count_memory(sptr, parv[0]);
valid_stats++;
break;
case '?':
serv_info(sptr, parv[0]);
valid_stats++;
break;
default :
l_stat = '*';
break;
}
sendto_one(sptr, form_str(RPL_ENDOFSTATS), mename, parv[0], l_stat);
/* personally, I don't see why opers need to see stats requests
* at all. They are just "noise" to an oper, and users can't do
* any damage with stats requests now anyway. So, why show them?
* -Dianora
*/
if (valid_stats)
{
if ( (l_stat == 'L') || (l_stat == 'l') )
{
sendto_ops_imodes(IMODE_SPY,
"STATS %c requested by %s (%s@%s) [%s] on %s%s",
l_stat,
sptr->name,
sptr->username,
sptr->host,
sptr->user->server,
parc > 2 ? parv[2] : "<no recipient>",
ignore_request > 0 ? " [request ignored]" : "\0"
);
}
else
{
sendto_ops_imodes(IMODE_SPY,
"STATS %c requested by %s (%s@%s) [%s]%s",
l_stat,
sptr->name,
sptr->username,
sptr->host,
sptr->user->server,
ignore_request > 0 ? " [request ignored]" : "\0"
);
}
}
return 0;
}
int compare(struct sorted_data * sd1,
struct sorted_data * sd2,
ULONG col,
BOOL case_on)
{
ULONG len = MIN(sd1->len, sd2->len);
#warning It seems like StrnCmp of locale does not work.
#if 1
LONG retval = 0;
if (TRUE == case_on)
{
int i = col;
while (i < len)
{
BOOL a,b;
a = IsUpper(locale,(ULONG)*(sd1->data+col+i));
b = IsUpper(locale,(ULONG)*(sd2->data+col+i));
if (a == b)
{
if (0 != (retval = StrnCmp(locale,
sd1->data+col,
sd2->data+col,
1,
SC_COLLATE2)));
break;
}
else
{
retval = b - a;
break;
}
i++;
}
}
else
{
retval=StrnCmp(locale,
sd1->data+col,
sd2->data+col,
len,
SC_COLLATE2);
if (0 == retval)
{
if (sd1->len < sd2->len)
retval = -100;
else
retval = +100;
}
}
return retval;
#else
int i = col;
char * str1 = sd1->data;
char * str2 = sd2->data;
while (i < len)
{
if (str1[i] != str2[i])
return (int)(str1[i] - str2[i]);
i++;
}
return (int)sd1->len - (int)sd2->len;
#endif
}
static std::list<PreserveStyleToken> InternalPreserveStyleTokenize(const string& strStr, size_t From, size_t Length)
{
FN_RETURN_TYPE(InternalPreserveStyleTokenize) Result;
std::vector<bool> Seps(Length, false);
for (size_t I = From+1; I+1 < From+Length; I++)
{
if (IsPreserveStyleTokenSeparator(strStr[I])
&& !IsPreserveStyleTokenSeparator(strStr[I-1])
&& !IsPreserveStyleTokenSeparator(strStr[I+1]))
{
Seps[I-From] = true;
}
}
size_t L = From;
for (size_t I = From+1; I < From+Length; I++)
{
if (Seps[I-From])
{
PreserveStyleToken T;
T.Token = strStr.substr(L, I-L);
T.PrependChar = 0;
if (L >= From + 1 && Seps[L-1-From])
T.PrependChar = strStr[L-1];
Result.emplace_back(T);
L = I+1;
I++;
continue;
}
if (!Seps[I-From-1] && IsLower(strStr[I-1]) && IsUpper(strStr[I]))
{
PreserveStyleToken T;
T.Token = strStr.substr(L, I-L);
T.PrependChar = 0;
if (L >= From + 1 && Seps[L-1-From])
T.PrependChar = strStr[L-1];
Result.emplace_back(T);
L = I;
}
}
if (L < From+Length)
{
PreserveStyleToken T;
T.Token = strStr.substr(L, From+Length-L);
T.PrependChar = 0;
if (L >= From + 1 && Seps[L-1-From])
T.PrependChar = strStr[L-1];
Result.emplace_back(T);
}
if (Result.size() > 1)
{
wchar_t PrependChar = std::next(Result.cbegin())->PrependChar;
FOR (const auto& i, make_range(std::next(Result.cbegin(), 2), Result.cend()))
{
if (PrependChar != i.PrependChar)
{
Result.clear();
PreserveStyleToken T;
T.Token = strStr.substr(From, Length);
T.PrependChar = 0;
T.TypeMask = 1 << UNKNOWN;
Result.emplace_back(T);
return Result;
}
}
}
int eval_upper(char c)
{
return (0 != IsUpper(c));
}
