void LZ::writeTokens()
{
deque<triple> temp = tokens;
cout << N << "," << L << "," << S << endl;
vector<bool>Nb = get_bits(N,8);
vector<bool>Lb = get_bits(L,8);
vector<bool>Sb = get_bits(S,8);
//ouput NLS as bytes
vector<bool>output;
output.reserve(24);
output.insert(output.end(), Nb.begin(), Nb.end());
output.insert(output.end(), Lb.begin(), Lb.end());
output.insert(output.end(), Sb.begin(), Sb.end());
std::ostream_iterator<bool>out_it(std::cerr);
copy(output.begin(), output.end(), out_it);
while (temp.size() > 0)
{
writeToken(temp.front());
temp.pop_front();
}
triple endToken;
endToken.length = 0;
endToken.offset = 0;
endToken.s = "";
writeToken(endToken);
}
void
KeychainAuthLogger::writeCommon()
{
writeSubject();
writeToken(au_to_text(sysKCAuthStr), sysKCAuthStr);
writeToken(au_to_text(mDatabase.c_str()), "keychain");
writeToken(au_to_text(mItem.c_str()), "keychain item");
}
void
AuthMechLogger::writeCommon()
{
writeSubject();
writeToken(au_to_text(mRight.c_str()), "right");
if (true == mEvaluatingMechanism)
{
string tmpStr = mechStr; // mechStr includes a trailing space
tmpStr += mCurrentMechanism;
writeToken(au_to_text(tmpStr.c_str()), "mechanism");
}
}
void
RightAuthenticationLogger::logFailure(uid_t authenticator, const char *targetName)
{
if (false == open())
return;
writeCommon();
writeToken(au_to_arg32(1, authenticatorStr, authenticator), "authenticator");
if (NULL == targetName)
writeToken(au_to_text(unknownUserStr), "target username");
else
writeToken(au_to_text(targetName), "target username");
// @@@ EAUTH more appropriate, but !defined for _POSIX_C_SOURCE
writeReturn(EPERM, errAuthorizationDenied);
close();
}
void set( const std::string& dictLib,
const std::string& className,
const std::string& containerName,
int pkcolumnValue=0) {
ora::SharedLibraryName libName;
edmplugin::SharedLibrary shared( libName(dictLib) );
m_token = writeToken(containerName, 0, pkcolumnValue, className);
}
void
RightAuthenticationLogger::logSuccess(uid_t authenticator, uid_t target, const char *targetName)
{
if (false == open())
return;
writeCommon();
// au_to_arg32() is really meant for auditing syscall arguments;
// we're slightly abusing it to get descriptive strings for free.
writeToken(au_to_arg32(1, authenticatorStr, authenticator), "authenticator");
string tmpStr(authenticatedAsStr);
// targetName shouldn't be NULL on a successful authentication, but allow
// for programmer screwups
tmpStr += targetName ? targetName : unknownUserStr;
writeToken(au_to_arg32(2, tmpStr.c_str(), target), "target");
writeReturn(0, 0);
close();
}
void
RightAuthenticationLogger::logAuthorizationResult(const char *client, const char *authCreator, int errcode)
{
if (false == open())
return;
writeCommon();
string tmpStr(clientStr);
tmpStr += client ? client : unknownClientStr;
writeToken(au_to_text(tmpStr.c_str()), "Authorization client");
tmpStr.clear();
tmpStr = authCreatorStr;
tmpStr += authCreator ? authCreator : unknownAuthCreatorStr;
writeToken(au_to_text(tmpStr.c_str()), "Authorization creator");
if (errAuthorizationSuccess == errcode)
writeReturn(0, 0);
else
writeReturn(EPERM, errcode);
close();
}
void
RightAuthenticationLogger::logLeastPrivilege(uid_t userId, bool isAuthorizingUser)
{
if (false == open())
return;
writeCommon();
writeToken(au_to_text(leastPrivStr), leastPrivStr);
writeReturn(0, 0);
close();
}
void
AuthMechLogger::logInterrupt(const char *msg)
{
if (false == open())
return;
writeCommon();
if (msg)
writeToken(au_to_text(msg), "interrupt");
writeReturn(0, 0);
close();
}
void
AuditLogger::logFailure(const char *errMsg, int errcode)
{
if (false == open())
return;
writeCommon();
if (errMsg)
writeToken(au_to_text(errMsg), "evaluation error");
writeReturn(EPERM, errcode);
close();
}
void CssPrettyWriter::writeDeclaration(const Token &property,
const TokenList &value) {
indent();
if (sourcemap != NULL)
sourcemap->writeMapping(column, property);
writeToken(property);
writeStr(": ", 2);
writeValue(value);
}
void
AuditLogger::writeSubject()
{
assert(mClientInfoSet);
token_t *token;
// @@@ terminal ID is not carried in the audit trailer nowadays, but
// this code should be harmless: it replicates the current logic in
// audit_submit()
if (AU_IPv4 == mTerminalId.at_type)
token = au_to_subject32(mAuditId, mEuid, mEgid, mRuid, mRgid, mPid, mAuditSessionId, &mOldTerminalId);
else
token = au_to_subject_ex(mAuditId, mEuid, mEgid, mRuid, mRgid, mPid, mAuditSessionId, &mTerminalId);
writeToken(token, "subject");
}
void CssPrettyWriter::writeSelector(const TokenList &selector) {
TokenList::const_iterator it;
if (sourcemap != NULL)
sourcemap->writeMapping(column, selector.front());
for (it = selector.begin(); it != selector.end(); it++) {
writeToken(*it);
if ((*it) == ",") {
if (sourcemap != NULL)
sourcemap->writeMapping(column, selector.front());
newline();
indent();
}
}
}
void
RightAuthenticationLogger::writeCommon()
{
writeSubject();
writeToken(au_to_text(mRight.c_str()), "right");
}
int TokensJob::execute()
{
std::shared_ptr<Project> proj = project();
if (!proj)
return 1;
auto map = proj->openTokens(mFileId);
if (!map)
return 2;
const uint32_t count = map->count();
uint32_t i = 0;
if (mFrom != 0) {
i = map->lowerBound(mFrom);
if (i > 0 && i < count) {
const Token val = map->valueAt(i - 1);
if (val.offset + val.length >= mFrom)
--i;
}
}
std::function<bool(const Token &)> writeToken;
if (queryFlags() & QueryMessage::Elisp) {
const char *elispFormat = "(cons %d (list (cons 'length %d) (cons 'kind \"%s\") (cons 'spelling \"%s\")))";
write("(list");
if (queryFlags() & QueryMessage::TokensIncludeSymbols) {
writeToken = [this, &proj, elispFormat](const Token &token) {
String out = String::format<1024>(elispFormat,
token.offset, token.length, RTags::tokenKindSpelling(token.kind),
RTags::elispEscape(token.spelling).constData());
const Symbol sym = proj->findSymbol(token.location);
if (!sym.isNull()) {
out.chop(2);
out << " (cons 'symbol ";
}
if (!write(out))
return false;
if (!sym.isNull())
return write(sym) && write(")))");
return true;
};
} else {
writeToken = [this, elispFormat](const Token &token) {
return write<1024>(elispFormat,
token.offset, token.length, RTags::tokenKindSpelling(token.kind),
RTags::elispEscape(token.spelling).constData());
};
}
} else {
writeToken = [this](const Token &token) {
return write(token.toString());
};
}
while (i < count) {
const Token token = map->valueAt(i++);
if (token.offset > mTo)
break;
if (!writeToken(token))
return 4;
}
if (queryFlags() & QueryMessage::Elisp) {
write(")");
}
return 0;
}
void CssPrettyWriter::writeComment(const Token &comment) {
writeToken(comment);
newline();
}
void DocSets::addIndexItem(Definition *context,MemberDef *md,
const char *,const char *)
{
if (md==0 && context==0) return;
FileDef *fd = 0;
ClassDef *cd = 0;
NamespaceDef *nd = 0;
if (md)
{
fd = md->getFileDef();
cd = md->getClassDef();
nd = md->getNamespaceDef();
if (!md->isLinkable()) return; // internal symbol
}
QCString scope;
QCString type;
QCString decl;
// determine language
QCString lang;
SrcLangExt langExt = SrcLangExt_Cpp;
if (md)
{
langExt = md->getLanguage();
}
else if (context)
{
langExt = context->getLanguage();
}
switch (langExt)
{
case SrcLangExt_Cpp:
case SrcLangExt_ObjC:
{
if (md && (md->isObjCMethod() || md->isObjCProperty()))
lang="occ"; // Objective C/C++
else if (fd && fd->name().right(2).lower()==".c")
lang="c"; // Plain C
else if (cd==0 && nd==0)
lang="c"; // Plain C symbol outside any class or namespace
else
lang="cpp"; // C++
}
break;
case SrcLangExt_IDL: lang="idl"; break; // IDL
case SrcLangExt_CSharp: lang="csharp"; break; // C#
case SrcLangExt_PHP: lang="php"; break; // PHP4/5
case SrcLangExt_D: lang="d"; break; // D
case SrcLangExt_Java: lang="java"; break; // Java
case SrcLangExt_JS: lang="javascript"; break; // Javascript
case SrcLangExt_Python: lang="python"; break; // Python
case SrcLangExt_Fortran: lang="fortran"; break; // Fortran
case SrcLangExt_VHDL: lang="vhdl"; break; // VHDL
case SrcLangExt_XML: lang="xml"; break; // DBUS XML
case SrcLangExt_Tcl: lang="tcl"; break; // Tcl
case SrcLangExt_Markdown:lang="markdown"; break; // Markdown
case SrcLangExt_Unknown: lang="unknown"; break; // should not happen!
}
if (md)
{
if (context==0)
{
if (md->getGroupDef())
context = md->getGroupDef();
else if (md->getFileDef())
context = md->getFileDef();
}
if (context==0) return; // should not happen
switch (md->memberType())
{
case MemberType_Define:
type="macro"; break;
case MemberType_Function:
if (cd && (cd->compoundType()==ClassDef::Interface ||
cd->compoundType()==ClassDef::Class))
{
if (md->isStatic())
type="clm"; // class member
else
type="instm"; // instance member
}
else if (cd && cd->compoundType()==ClassDef::Protocol)
{
if (md->isStatic())
type="intfcm"; // interface class member
else
type="intfm"; // interface member
}
else
type="func";
break;
case MemberType_Variable:
type="data"; break;
case MemberType_Typedef:
type="tdef"; break;
case MemberType_Enumeration:
type="enum"; break;
case MemberType_EnumValue:
type="econst"; break;
//case MemberDef::Prototype:
// type="prototype"; break;
case MemberType_Signal:
type="signal"; break;
case MemberType_Slot:
type="slot"; break;
case MemberType_Friend:
type="ffunc"; break;
case MemberType_DCOP:
type="dcop"; break;
case MemberType_Property:
if (cd && cd->compoundType()==ClassDef::Protocol)
type="intfp"; // interface property
else
type="instp"; // instance property
break;
case MemberType_Event:
type="event"; break;
case MemberType_Interface:
type="ifc"; break;
case MemberType_Service:
type="svc"; break;
}
cd = md->getClassDef();
nd = md->getNamespaceDef();
if (cd)
{
scope = cd->qualifiedName();
}
else if (nd)
{
scope = nd->name();
}
MemberDef *declMd = md->memberDeclaration();
if (declMd==0) declMd = md;
{
fd = md->getFileDef();
if (fd)
{
decl = fd->name();
}
}
writeToken(m_tts,md,type,lang,scope,md->anchor(),decl);
}
else if (context && context->isLinkable())
{
if (fd==0 && context->definitionType()==Definition::TypeFile)
{
fd = (FileDef*)context;
}
if (cd==0 && context->definitionType()==Definition::TypeClass)
{
cd = (ClassDef*)context;
}
if (nd==0 && context->definitionType()==Definition::TypeNamespace)
{
nd = (NamespaceDef*)context;
}
if (fd)
{
type="file";
}
else if (cd)
{
scope = cd->qualifiedName();
if (cd->isTemplate())
{
type="tmplt";
}
else if (cd->compoundType()==ClassDef::Protocol)
{
type="intf";
if (scope.right(2)=="-p") scope=scope.left(scope.length()-2);
}
else if (cd->compoundType()==ClassDef::Interface)
{
type="cl";
}
else if (cd->compoundType()==ClassDef::Category)
{
type="cat";
}
else
{
type = "cl";
}
IncludeInfo *ii = cd->includeInfo();
if (ii)
{
decl=ii->includeName;
}
}
else if (nd)
{
scope = nd->name();
type = "ns";
}
if (m_scopes.find(context->getOutputFileBase())==0)
{
writeToken(m_tts,context,type,lang,scope,0,decl);
m_scopes.append(context->getOutputFileBase(),(void*)0x8);
}
}
}
void
AuditLogger::writeReturn(char status, int reterr)
{
writeToken(au_to_return32(status, reterr), "return");
}
void DocSets::addIndexItem(const char *, const char *,
const char *, const char *,
const char *,const MemberDef *md)
{
if (!md->isLinkable()) return; // internal symbol
ClassDef *cd = md->getClassDef();
NamespaceDef *nd = md->getNamespaceDef();
FileDef *fd = md->getFileDef();
// determine language
QCString lang;
SrcLangExt langExt = SrcLangExt_Cpp;
if (fd) langExt = getLanguageFromFileName(fd->name());
switch (langExt)
{
case SrcLangExt_Cpp:
{
if (md->isObjCMethod())
lang="occ"; // Objective C/C++
else if (fd && fd->name().right(2).lower()==".c")
lang="c"; // Plain C
else
lang="cpp"; // C++
}
break;
case SrcLangExt_ObjC: lang="occ"; break; // Objective C++
case SrcLangExt_IDL: lang="idl"; break; // IDL
case SrcLangExt_CSharp: lang="csharp"; break; // C#
case SrcLangExt_PHP: lang="php"; break; // PHP4/5
case SrcLangExt_D: lang="d"; break; // D
case SrcLangExt_Java: lang="java"; break; // Java
case SrcLangExt_JS: lang="javascript"; break; // Javascript
case SrcLangExt_Python: lang="python"; break; // Python
case SrcLangExt_F90: lang="fortran"; break; // Fortran
case SrcLangExt_VHDL: lang="vhdl"; break; // VHDL
}
// determine scope
QCString scope;
QCString type;
QCString decl;
Definition *d = 0;
if (fd && fd->isLinkable() && m_scopes.find(fd->getOutputFileBase())==0)
{
writeToken(m_tts,fd,"file",lang,0,0,0);
m_scopes.append(fd->getOutputFileBase(),(void*)0x8);
}
if (cd)
{
scope = cd->qualifiedName();
if (cd->isTemplate())
type="tmplt";
else if (cd->compoundType()==ClassDef::Protocol)
type="intf";
else if (cd->compoundType()==ClassDef::Interface)
type="cl";
else if (cd->compoundType()==ClassDef::Category)
type="cat";
else
type = "cl";
d = cd;
IncludeInfo *ii = cd->includeInfo();
if (ii)
{
decl=ii->includeName;
if (decl.isEmpty())
{
decl=ii->local;
}
}
}
else if (nd)
{
scope = nd->name();
type = "ns";
d = cd;
}
if (d && d->isLinkable() && m_scopes.find(d->getOutputFileBase())==0)
{
writeToken(m_tts,d,type,lang,0,0,decl);
m_scopes.append(d->getOutputFileBase(),(void*)0x8);
}
switch (md->memberType())
{
case MemberDef::Define:
type="macro"; break;
case MemberDef::Function:
if (cd && cd->compoundType()==ClassDef::Interface)
type="intfm";
else if (cd && cd->compoundType()==ClassDef::Class)
type="clm";
else
type="func";
break;
case MemberDef::Variable:
type="data"; break;
case MemberDef::Typedef:
type="tdef"; break;
case MemberDef::Enumeration:
type="enum"; break;
case MemberDef::EnumValue:
type="econst"; break;
//case MemberDef::Prototype:
// type="prototype"; break;
case MemberDef::Signal:
type="signal"; break;
case MemberDef::Slot:
type="slot"; break;
case MemberDef::Friend:
type="ffunc"; break;
case MemberDef::DCOP:
type="dcop"; break;
case MemberDef::Property:
type="property"; break;
case MemberDef::Event:
type="event"; break;
}
writeToken(m_tts,md,type,lang,scope,md->anchor());
}
