RegPacket::RegPacket(MSNClient *client, unsigned id, const char *name)
: MSNPacket(client, "REG")
{
addArg(number(id).c_str());
addArg(name);
addArg("0");
}
AdgPacket::AdgPacket(MSNClient *client, unsigned grp_id, const char *name)
: MSNPacket(client, "ADG")
{
m_id = grp_id;
addArg(name);
addArg("0");
}
CvrPacket::CvrPacket(MSNClient *client)
: MSNPacket(client, "CVR")
{
addArg("0x0409 winnt 5.1 i386 MSNMSGR");
addArg(client->getVersion());
addArg("MSMSGS");
addArg(m_client->getLogin());
}
RemPacket::RemPacket(MSNClient *client, const char *listType, const char *mail, unsigned grp)
: MSNPacket(client, "REM")
{
addArg(listType);
addArg(mail);
if (!strcmp(listType, "FL"))
addArg(number(grp).c_str());
}
AddPacket::AddPacket(MSNClient *client, const char *listType, const char *mail, const char *name, unsigned grp)
: MSNPacket(client, "ADD")
{
m_mail = mail;
addArg(listType);
addArg(mail);
addArg(name);
if (!strcmp(listType, "FL"))
addArg(number(grp).c_str());
}
UsrPacket::UsrPacket(MSNClient *client, const char *digest)
: MSNPacket(client, "USR")
{
addArg("MD5");
if (digest){
addArg("S");
addArg(digest);
}else{
addArg("I");
addArg(m_client->getLogin());
}
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE ArgList::expandArgs(
char ** ppszArgs,
FLMUINT uiNumArgs)
{
RCODE rc = FERR_OK;
FLMUINT uiLoop;
for( uiLoop = 0; uiLoop < uiNumArgs; uiLoop++)
{
if( ppszArgs[uiLoop][0] == '@')
{
if( RC_BAD( rc = expandFileArgs( &ppszArgs[uiLoop][ 1])))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = addArg( ppszArgs[ uiLoop])))
{
goto Exit;
}
}
}
Exit:
return( rc);
}
/* SCallTip::loadArgSet
* Opens and displays the arg set [set] from the current function
*******************************************************************/
void SCallTip::loadArgSet(int set)
{
args.clear();
if (!function->getArgSet(set).empty())
{
Tokenizer tz;
tz.setSpecialCharacters("[],");
tz.openString(function->getArgSet(set));
string token = tz.getToken();
vector<string> tokens;
while (true)
{
tokens.push_back(token);
string next = tz.peekToken();
if (next == "," || next == "")
{
addArg(tokens);
tokens.clear();
tz.getToken();
}
if (next == "")
break;
token = tz.getToken();
}
}
updateSize();
Update();
Refresh();
}
QryPacket::QryPacket(MSNClient *client, const char *qry)
: MSNPacket(client, "QRY")
{
addArg("PROD0038W!61ZTF9");
addArg("32");
m_line += "\r\n";
char qry_add[] = "VT6PX?UQTM4WM%YR";
string md = qry;
md += qry_add;
md = md5(md.c_str());
for (unsigned i = 0; i < md.length(); i++){
char b[3];
sprintf(b, "%02x",md[i]);
m_line += b;
}
}
SynPacket::SynPacket(MSNClient *client)
: MSNPacket(client, "SYN")
{
bDone = false;
client->data.ListVer = 0;
addArg(number(client->data.ListVer).c_str());
}
std::shared_ptr<ir::Expr> MathFuncDecl::getNew(
std::vector<std::shared_ptr<ir::Expr>>& args,
fabrica::TypeFactory* fact) const {
// Type Checking
if (args.size() != 1 || args[0] == nullptr)
return nullptr;
auto int_ty = fact->getTy(ir::IRConstString::INT);
auto real_ty = fact->getTy(ir::IRConstString::DOUBLE);
auto mat_ty = fact->getTy(ir::IRConstString::MATRIX);
// Note: We accept Int/Real/Matrix
if (args[0]->getTyp() != int_ty
&& args[0]->getTyp() != real_ty
&& args[0]->getTyp() != mat_ty)
return nullptr;
auto ret_ty = (args[0]->getTyp() == mat_ty ? mat_ty : real_ty);
auto func = std::make_shared<ir::FunctionCall>(this);
func->addArg(args[0]);
// check randomness
func->setRandom(func->get(0)->isRandom());
func->setTyp(ret_ty);
return func;
}
ChgPacket::ChgPacket(MSNClient *client)
: MSNPacket(client, "CHG")
{
const char *status = "NLN";
switch (m_client->getStatus()){
case STATUS_NA:
status = "IDL";
break;
case STATUS_AWAY:
status = "AWY";
break;
case STATUS_DND:
status = "BSY";
break;
case STATUS_BRB:
status = "BRB";
break;
case STATUS_PHONE:
status = "PHN";
break;
case STATUS_LUNCH:
status = "LUN";
break;
}
addArg(status);
}
SynPacket::SynPacket(MSNClient *client)
: MSNPacket(client, "SYN")
{
bDone = false;
m_data = NULL;
client->data.ListVer.value = 0;
addArg(number(client->data.ListVer.value).c_str());
}
QryPacket::QryPacket(MSNClient *client, const char *qry)
: MSNPacket(client, "QRY")
{
addArg("*****@*****.**");
addArg("32");
m_line += "\r\n";
char qry_add[] = "Q1P7W2E4J9R8U3S5";
MD5_CTX c;
unsigned char md[MD5_DIGEST_LENGTH];
MD5_Init(&c);
MD5_Update(&c, qry, (unsigned long)strlen(qry));
MD5_Update(&c, qry_add, (unsigned long)strlen(qry_add));
MD5_Final(md, &c);
for (unsigned i = 0; i < MD5_DIGEST_LENGTH; i++){
char b[3];
sprintf(b, "%02x",md[i]);
m_line += b;
}
}
QryPacket::QryPacket(MSNClient *client, const char *qry)
: MSNPacket(client, "QRY")
{
addArg("PROD0038W!61ZTF9");
addArg("32");
m_line += "\r\n";
char qry_add[] = "VT6PX?UQTM4WM%YR";
MD5_CTX c;
unsigned char md[MD5_DIGEST_LENGTH];
MD5_Init(&c);
MD5_Update(&c, qry, (unsigned long)strlen(qry));
MD5_Update(&c, qry_add, (unsigned long)strlen(qry_add));
MD5_Final(md, &c);
for (unsigned i = 0; i < MD5_DIGEST_LENGTH; i++){
char b[3];
sprintf(b, "%02x",md[i]);
m_line += b;
}
}
void Commande::setError(const string err, const char errNum, const string nameClt)
{
this->errNum = errNum;
if (err == "")
this->err = errors[errNum];
else
this->err = err;
cde = 129;
setDest(nameClt);
addArg("Server");
}
/* a tester */
int main(int argc, char **argv) {
int n=0;
char infile[9]="infile value";
char outfile[256]="outfile value";
float fl=-1.0;
double dbl = -1.0;
int flag = 0;
//Add arguments
addArg("infile", 'i', 1, 's', infile, sizeof(infile), "input file name");
addArg("outfile", 'o', 1, 's', outfile, sizeof(infile), "output file name");
addArg("nSPUs", 'n', 1, 'i', &n, 0, "number of SPUs");
addArg("floater", 0, 1, 'f', &fl, 0, "floating number");
addArg("doubler", 'k', 1, 'd', &dbl, 0, "double number");
addArg("justFlag",'F', 0, 0, &flag, 0, "just a flag");
// print the argument help
printArgs();
// process (and free) arguments
processArgs(argc,argv);
// print the variables in the code
printf("Got n = %d\n",n);
printf("Got fl = %f\n",fl);
printf("Got dbl = %lf\n",dbl);
printf("Got flag = %d\n",flag);
printf("Got infile = %s\n",infile);
printf("Got outfile = %s\n",outfile);
printf("\n\n");
return 0;
}
/**
* @brief Builds the arguments of the script call.
*
* @return true: OK<br>
* false: error occurred
*/
bool Converter::buildArgs()
{
bool rc = true;
m_args.clear();
m_args << "-v";
if (m_landscapeHeight > 0)
addArg(m_args, "-lw", m_landscapeHeight);
else if (m_landscapeWidth > 0)
addArg(m_args, "-lh", m_landscapeWidth);
else
rc = error("keine/falsche Maximalangabe beim Breitformat");
if (m_portraitWidth > 0)
addArg(m_args, "-pw", m_portraitWidth);
else if (m_portraitHeight > 0)
addArg(m_args, "-ph", m_portraitHeight);
else
rc = error("keine/falsche Maximalangabe beim Hochformat");
if (m_squareWidth > 0)
addArg(m_args, "-sw", m_squareWidth);
else
rc = error("keine/falsche Maximalangabe beim Hochformat");
if (m_quality < 10 || m_quality > 100)
rc = error("keine/falsche Qualität");
else
addArg(m_args, "-q", m_quality);
return rc;
}
Message& Message::setArg(size_t i, string s)
{
if(i == args.size())
return addArg(s);
assert(i < args.size());
if((i+1) < args.size() && args.back().find(' ') != string::npos)
throw MalformedMessage();
args[i] = s;
return *this;
}
// o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o
void
FunctionType::addArgs(Decl *args)
{
Decl *arg = args;
while (args != NULL)
{
args = args->next;
arg->next = NULL;
addArg(arg);
arg = args;
}
}
void SetValueForArg(char prop[], char arg[], int value, HashTable **hash, int m, int n)
{ /* This function actually sets the value returned when you
* pass argument arg to propositional function pointed to
* by hash -> node_ptr -> name
*/
ArgNode *arg_ptr;
//setPointerToArg(arg, hash, m, n);
addArg(prop, arg, hash, m, n);
arg_ptr = (*hash) -> node_ptr -> arg_ptr;
if (arg_ptr -> arg == NULL)
InconsistencyErr("void setValueForArg(char arg, HashTable *hash, int m, int n, int value) 1 ");
*((*hash) -> node_ptr -> arg_ptr -> result) = value;
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE ArgList::expandFileArgs(
const char * pszFilename)
{
RCODE rc = FERR_OK;
char token[64];
IF_FileHdl * pFileHdl = NULL;
if( RC_BAD( rc = gv_FlmSysData.pFileSystem->openFile(
pszFilename, FLM_IO_RDWR, &pFileHdl)))
{
goto Exit;
}
while( RC_OK( rc = getTokenFromFile(token, pFileHdl)))
{
if( token[0] == '@')
{
if( RC_BAD( rc = expandFileArgs( &token[1])))
{
goto Exit;
}
}
else
{
flmAssert(*token);
if( RC_BAD( rc = addArg( token)))
{
goto Exit;
}
}
}
if( rc == FERR_IO_END_OF_FILE)
{
rc = FERR_OK;
}
Exit:
if( pFileHdl)
{
pFileHdl->Release();
}
return( rc);
}
/*!
Sends the request. If the request is synchronous, then client is blocked
until service provider completes the request or request fails for some reason.
If the request is asynchronous, then client won't be blocked.
\param retData Defines refence to a value service provider will return after service.
\return False if there was no application that could service the request, otherwise true.
*/
bool XQServiceRequest::send(QVariant& retData)
{
XQSERVICE_DEBUG_PRINT("XQServiceRequest::send(2)");
if (isNull())
{
XQSERVICE_DEBUG_PRINT("XQServiceRequest::send error: null request");
XQService::serviceThreadData()->setLatestError(XQService::EArgumentError);
return false;
}
// Handle sharable file argument(s), if any
if (!handleSharableFileArgs())
{
XQSERVICE_DEBUG_PRINT("XQServiceRequest::send error:invalid sharable file");
XQService::serviceThreadData()->setLatestError(XQService::EArgumentError);
return false;
}
mData->mRequestUtil.setSynchronous(mData->mSynchronous); // Ensure option is set !
mData->mRequestUtil.mOperation = mData->mMessage; // Save the operation name for startup
// !!!
// Add the info as extra argument to the request
// This shall be removed by the server
// !!!
addArg(qVariantFromValue(mData->mRequestUtil.mInfo));
// Pass always the util instance onwards as user data.
// It can be utilized by the XQServiceManager::startServer
// e.g. to optimize startup of a service server
// Create unique channel name to separate multiple client requests to same channel name.
quint32 handle = (unsigned int)mData;
mData->mUniqueChannelName = QString("%1:").arg(handle) + mData->mService;
XQSERVICE_DEBUG_PRINT("XQServiceRequest::send(2):uniqueChannel=%s", qPrintable(mData->mUniqueChannelName));
return XQServiceAdaptor::send(mData->mUniqueChannelName, message(), mData->mArguments, retData, mData->mSynchronous,mData,
(const void *)&mData->mRequestUtil);
}
int char_buffer::do_html(int argc, char *argv[])
{
string s;
alterDeviceTo(argc, argv, 0);
argv += troff_arg; // skip all arguments up to groff
argc -= troff_arg;
argv = addArg(argc, argv, (char *)"-Z");
argc++;
s = (char *)"-dwww-image-template=";
s += macroset_template; // do not combine these statements,
// otherwise they will not work
s += '\0'; // the trailing `\0' is ignored
argv = addRegDef(argc, argv, s.contents());
argc++;
if (dialect == xhtml) {
argv = addRegDef(argc, argv, "-rxhtml=1");
argc++;
if (eqn_flag) {
argv = addRegDef(argc, argv, "-e");
argc++;
}
}
#if defined(DEBUGGING)
# define HTML_DEBUG_STREAM OUTPUT_STREAM(htmlFileName)
// slight security risk so only enabled if compiled with defined(DEBUGGING)
if (debug) {
int saved_stdout = save_and_redirect(STDOUT_FILENO, HTML_DEBUG_STREAM);
emit_troff_output(DEVICE_FORMAT(HTML_OUTPUT_FILTER));
set_redirection(STDOUT_FILENO, saved_stdout);
}
#endif
return run_output_filter(HTML_OUTPUT_FILTER, argc, argv);
}
int EdifyFunc::replaceOffendings(std::list<EdifyElement*> **parentList, std::list<EdifyElement*>::iterator& lastNewlineRef)
{
int res = 0;
if(m_name == "mount" || m_name == "unmount" || m_name == "format")
{
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyValue(
std::string("# MultiROM removed function ") + m_name +
"(" + getArgsStr() +
std::string(") from following line.")));
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyNewline());
if(m_name == "format")
{
for(std::list<EdifyElement*>::iterator itr = m_args.begin(); itr != m_args.end(); ++itr)
{
if((*itr)->getType() != EDF_VALUE)
continue;
if(((EdifyValue*)(*itr))->getText().find("/system") != std::string::npos)
{
res |= OFF_FORMAT_SYSTEM;
break;
}
}
}
res |= OFF_CHANGED;
m_name = "ui_print";
clearArgs();
addArg(new EdifyValue("\"\""));
return res;
}
else if(m_name == "block_image_update")
{
res |= OFF_BLOCK_UPDATES;
}
else if(m_name == "run_program")
{
bool rem = false;
for(std::list<EdifyElement*>::iterator itr = m_args.begin(); itr != m_args.end(); ++itr)
{
if((*itr)->getType() != EDF_VALUE)
continue;
const std::string& t = ((EdifyValue*)(*itr))->getText();
if(t.find("mount") != std::string::npos)
{
rem = true;
break;
}
else if(t.find("boot.img") != NPOS || t.find(MultiROM::getBootDev()) != NPOS ||
t.find("zImage") != NPOS || t.find("bootimg") != NPOS)
{
rem = false;
break;
}
else if(t.find("/dev/block") != NPOS)
rem = true;
}
if(rem)
{
std::string info = "# MultiROM replaced run_program(";
info += getArgsStr();
info += ") with \"/sbin/true\"";
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyValue(info));
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyNewline());
res |= OFF_CHANGED;
clearArgs();
addArg(new EdifyValue("\"/sbin/true\""));
}
}
else if(m_name == "package_extract_file" && m_args.size() >= 2)
{
int st = 0;
static const char * const forbidden_images[] = {
"radio", "bootloader", "NON-HLOS.bin", "emmc_appsboot.mbn",
"rpm.mbn", "logo.bin", "sdi.mbn", "tz.mbn", "sbl1.mbn",
NULL
};
for(std::list<EdifyElement*>::iterator itr = m_args.begin(); itr != m_args.end(); ++itr)
{
if((*itr)->getType() != EDF_VALUE)
continue;
if(st == 0)
{
for(int i = 0; forbidden_images[i]; ++i)
{
if(((EdifyValue*)(*itr))->getText().find(forbidden_images[i]) != NPOS)
{
st = 1;
break;
}
}
}
else if(st == 1 && (((EdifyValue*)(*itr))->getText().find("/dev/block/") <= 1))
{
st = 2;
break;
}
}
if(st == 2)
{
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyValue(
std::string("# MultiROM removed function ") + m_name +
"(" + getArgsStr() +
std::string(") from following line.")));
lastNewlineRef = (*parentList)->insert(++lastNewlineRef, new EdifyNewline());
res |= OFF_CHANGED;
m_name = "ui_print";
clearArgs();
addArg(new EdifyValue("\"\""));
}
}
for(std::list<EdifyElement*>::iterator itr = m_args.begin(); itr != m_args.end(); ++itr)
{
if((*itr)->getType() == EDF_FUNC)
res |= ((EdifyFunc*)(*itr))->replaceOffendings(parentList, lastNewlineRef);
else if((*itr)->getType() == EDF_NEWLINE)
{
*parentList = &m_args;
lastNewlineRef = itr;
}
}
return res;
}
SynPacket::SynPacket(MSNClient *client)
: MSNPacket(client, "SYN")
{
addArg(number(client->data.ListVer).c_str());
}
RmgPacket::RmgPacket(MSNClient *client, unsigned id)
: MSNPacket(client, "RMG")
{
addArg(number(id).c_str());
}
VerPacket::VerPacket(MSNClient *client)
: MSNPacket(client, "VER")
{
addArg("MSNP7 MSNP6 MSNP5 MSNP4 CVR0");
}
XfrPacket::XfrPacket(MSNClient *client, SBSocket *socket)
: MSNPacket(client, "XFR")
{
m_socket = socket;
addArg("SB");
}
BlpPacket::BlpPacket(MSNClient *client, bool bInvisible)
: MSNPacket(client, "BLP")
{
addArg(bInvisible ? "BL" : "AL");
}
