//
// returns true if the name is an internal and/or generated name;
// returns false otherwise.
//
static Int32 isDelimitedIdentifierReservedForInternalUse
( const char *delimitedIdentWithoutTheLeadingQuote,
size_t identLen )
// delimitedIdentWithoutTheLeadingQuote may or may not be '\0' terminated.
// Rely on indentLen to get the length of delimitedIdentWithoutTheLeadingQuote
// Do not rely on the strlen(delimitedIdentWithoutTheLeadingQuote) call.
// The logic in this routine also handles internal-format name correctly.
{
// Prefixes of names reserved for internal use
//
// Names with @ funny prefix are not included in the
// array to save space and to improve efficiency.
//
// "@BR_...",
// "@CURRENT_EPOCH"
// "@EPOCH",
// "@EXECID", // used to be "EXECID@"
// "@F", // used to be "F@"
// "@GOP", // used to be "GOP@"
// "@ISLAST", // used to be "ISLAST@"
// "@LNN_@BR_...",
// "@MAINTAIN_CONTROL_INFO@",
// "@MAINTAIN_SCHEMA@",
// "@NEW",
// "@OLD",
// "@OP", // used to be "OP@"
// "@ROW_COUNT", // used to be "ROW_COUNT@"
// "@ROW_TYPE", // used to be "ROW_TYPE@"
// "@SORT_KEY_...", // where ... is the orginal column name
// "@SYSKEY",
// "@..."
//
// Note that the SQL/MX Engine scanner, parser, binder, etc.
// also support regular identifiers with pattern @{A|B}[0-9]+
// for internal use.
//
// Using the following ordered list to search for reserved
// prefixes may be inefficient when the list becomes
// long. We also need to remember to update the list
// whenever we introduce a new prefix.
//
// Starting from 4/7/2007, please use @ prefix for any new
// internal and/or generated names to improve efficiency.
//
const char * reservedNamePrefixes[] =
{
"DELTA@",
"INDIRECT@",
"KEYTAG@",
"NEW@",
"OLD@",
"PACKED__@",
"PACKED__IDU__@",
""
};
if (identLen == 0)
return false;
char firstChar = delimitedIdentWithoutTheLeadingQuote[0];
if (firstChar == '@')
return true;
const char * *p = &reservedNamePrefixes[0];
size_t len = 0;
char prefix1stChar;
for ( ; (prefix1stChar = **p) <= firstChar && prefix1stChar != '\0'; p++ )
{
if ( prefix1stChar == firstChar )
{
len = strlen(*p);
if ( identLen >= len &&
strncmp(delimitedIdentWithoutTheLeadingQuote, *p, len) == 0 )
return true;
}
} // for
return false;
} // isDelimitedIdentifierReservedForInternalUse()
static void
extract_ps_from_filestream (FILE *f,
TrackerSparqlBuilder *preupdate,
TrackerSparqlBuilder *metadata)
{
gchar *line;
gsize length;
gssize read_char;
gsize accum;
gsize max_bytes;
line = NULL;
length = 0;
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument");
/* 20 MiB should be enough! (original safe limit) */
accum = 0;
max_bytes = 20u << 20;
/* Reuse the same buffer for all lines. Must be dynamically allocated with
* malloc family methods as getline() may re-size it with realloc() */
length = 1024;
line = g_malloc (length);
/* Halt the whole when one of these conditions is met:
* a) Reached max bytes to read
* b) No more lines to read
*/
while ((accum < max_bytes) &&
(read_char = tracker_getline (&line, &length, f)) != -1) {
gboolean pageno_atend = FALSE;
gboolean header_finished = FALSE;
/* Update accumulated bytes read */
accum += read_char;
line[read_char - 1] = '\0'; /* overwrite '\n' char */
if (!header_finished && strncmp (line, "%%Copyright:", 12) == 0) {
tracker_sparql_builder_predicate (metadata, "nie:copyright");
tracker_sparql_builder_object_unvalidated (metadata, line + 13);
} else if (!header_finished && strncmp (line, "%%Title:", 8) == 0) {
tracker_sparql_builder_predicate (metadata, "nie:title");
tracker_sparql_builder_object_unvalidated (metadata, line + 9);
} else if (!header_finished && strncmp (line, "%%Creator:", 10) == 0) {
tracker_sparql_builder_predicate (metadata, "nco:creator");
tracker_sparql_builder_object_blank_open (metadata);
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nco:Contact");
tracker_sparql_builder_predicate (metadata, "nco:fullname");
tracker_sparql_builder_object_unvalidated (metadata, line + 11);
tracker_sparql_builder_object_blank_close (metadata);
} else if (!header_finished && strncmp (line, "%%CreationDate:", 15) == 0) {
gchar *date;
date = date_to_iso8601 (line + 16);
if (date) {
tracker_sparql_builder_predicate (metadata, "nie:contentCreated");
tracker_sparql_builder_object_unvalidated (metadata, date);
g_free (date);
}
} else if (strncmp (line, "%%Pages:", 8) == 0) {
if (strcmp (line + 9, "(atend)") == 0) {
pageno_atend = TRUE;
} else {
gint64 page_count;
page_count = g_ascii_strtoll (line + 9, NULL, 10);
tracker_sparql_builder_predicate (metadata, "nfo:pageCount");
tracker_sparql_builder_object_int64 (metadata, page_count);
}
} else if (strncmp (line, "%%EndComments", 14) == 0) {
header_finished = TRUE;
if (!pageno_atend) {
break;
}
}
}
/* Deallocate the buffer */
if (line) {
g_free (line);
}
}
static void serioHandler(int fd, int revents, int userValue)
{
static Bool firstTime = TRUE;
String line;
char newStatBits[21];
static char oldStatBits[21];
/* Do non-blocking line read */
if(serio_nb_line_readcr(serioStuff)){
/* Got a line or EOF */
if(serio_ateof(serioStuff)){
debug(DEBUG_EXPECTED, "EOF detected on serial port, closing port");
if(!xPL_removeIODevice(serio_fd(serioStuff))) /* Unregister ourself */
debug(DEBUG_UNEXPECTED,"Could not unregister from poll list");
serio_close(serioStuff); /* Close serial port */
serioStuff = NULL;
serialRetryTimer = SERIAL_RETRY_TIME;
return; /* Bail */
}
lineReceived = TRUE;
line = serio_line(serioStuff);
if(line[0] == '['){ /* Parse the status bits */
confreadStringCopy(newStatBits, line + 1, 21);
if(firstTime){ /* Set new and old the same on first time */
firstTime = FALSE;
confreadStringCopy(oldStatBits, newStatBits, 21);
}
if(strcmp(newStatBits, oldStatBits)){
confreadStringCopy(oldStatBits, newStatBits, 21);
debug(DEBUG_EXPECTED,"New Status bits: %s", newStatBits);
}
/* If ready */
if(newStatBits[0] == '1')
stateBits.ready = 1;
else
stateBits.ready = 0;
/* If anything is armed */
if((newStatBits[1] == '1') || (newStatBits[2] == '1') ||
(newStatBits[12] == '1') || (newStatBits[15] == '1'))
stateBits.armed = 1;
else
stateBits.armed = 0;
/* If any alarm including one sent from LRR */
if((newStatBits[10] == '1') || (newStatBits[13] == '1') || alarmLRR)
stateBits.alarm = 1;
else
stateBits.alarm = 0;
/* If AC fail */
if(newStatBits[7] == '0')
stateBits.acfail = 1;
else
stateBits.acfail = 0;
/* If low battery */
if(newStatBits[11] == '1')
stateBits.lowbatt = 1;
else
stateBits.lowbatt = 0;
}
else if(line[0] == '!'){ /* Other events */
String p = line + 5;
if(!strncmp(line + 1, "EXP", 3)){ /* Expander event ? */
debug(DEBUG_EXPECTED,"Expander event: %s", p);
doEXPTrigger(p);
}
if(!strncmp(line + 1, "LRR", 3)){ /* Long Range radio event ? */
debug(DEBUG_EXPECTED,"Long Range Radio event: %s", p);
doLRRTrigger(p);
}
}
} /* End serio_nb_line_read */
}
bool MMG_AccountProtocol::HandleMessage(SvClient *aClient, MN_ReadMessage *aMessage, MMG_ProtocolDelimiters::Delimiter aDelimiter)
{
Query myQuery;
if (!myQuery.FromStream(aDelimiter, aMessage))
return false;
// Copy over the data to the main client manager class
aClient->m_CipherIdentifier = myQuery.m_CipherIdentifier;
aClient->m_EncryptionKeySequenceNumber = myQuery.m_EncryptionKeySequenceNumber;
memcpy(aClient->m_CipherKeys, myQuery.m_CipherKeys, sizeof(myQuery.m_CipherKeys));
MN_WriteMessage cryptMessage(1024);
MMG_ProtocolDelimiters::Delimiter responseDelimiter;
// Write the base identifier (random number, only a marker)
cryptMessage.WriteUInt(myQuery.m_RandomKey);
if (myQuery.m_StatusCode == IncorrectProtocolVersion || !myQuery.VerifyProductId())
{
// Invalid game version
// This takes priority over maintenance due to potential protocol differences
DebugLog(L_INFO, "ACCOUNT_PATCH_INFORMATION: Client has an old version [%d vs %d]", myQuery.m_Protocol, MassgateProtocolVersion);
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_PATCH_INFORMATION;
this->WritePatchInformation(&cryptMessage, &myQuery);
}
else if (this->m_MaintenanceMode)
{
// Massgate/Server maintenance notice
DebugLog(L_INFO, "ACCOUNT_NOT_CONNECTED: Sending Maintenance Notice");
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_NOT_CONNECTED;
this->WriteMaintenanceInformation(&cryptMessage);
}
else
{
switch(myQuery.m_Delimiter)
{
// Account authorization: Login
case MMG_ProtocolDelimiters::ACCOUNT_AUTH_ACCOUNT_REQ:
{
#ifndef USING_MYSQL_DATABASE
// Query the database and determine if credentials were valid
uint accProfileId = 0;//Database::AuthUserAccount(myQuery.m_Authenticate.m_Email, myQuery.m_Authenticate.m_Password);
DebugLog(L_INFO, "ACCOUNT_AUTH_ACCOUNT_RSP: Sending login response (id %i)", accProfileId);
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_AUTH_ACCOUNT_RSP;
if (accProfileId == WIC_INVALID_ACCOUNT)
{
cryptMessage.WriteUChar(AuthFailed_BadCredentials);
cryptMessage.WriteUChar(0); // auth.mySuccessFlag
cryptMessage.WriteUShort(0);// auth.myLatestVersion
}
else
{
// Update the maximum client timeout
aClient->SetLoginStatus(true);
aClient->SetIsPlayer(true);
aClient->SetTimeout(WIC_LOGGEDIN_NET_TIMEOUT);
cryptMessage.WriteUChar(AuthSuccess);
cryptMessage.WriteUChar(1); // auth.mySuccessFlag
cryptMessage.WriteUShort(0);// auth.myLatestVersion
// Query profile
//if (!Database::QueryUserProfile(accProfileId, aClient->GetProfile()))
// DebugLog(L_ERROR, "Failed to retrieve profile for valid account ");
wcscpy_s(aClient->GetProfile()->m_Name, L"Nukem");
aClient->GetProfile()->m_OnlineStatus = 1;
aClient->GetProfile()->m_Rank = 18;
aClient->GetProfile()->m_ProfileId = 1234;
//aClient->GetProfile()->m_ClanId = 4321;
//aClient->GetProfile()->m_RankInClan = 1;
// Write the profile info stream
aClient->GetProfile()->ToStream(&cryptMessage);
MMG_AuthToken *myAuthToken = aClient->GetToken();
//sync client->authtoken.profileid to client->profile.profileid
myAuthToken->m_ProfileId = 1234; //myAuthToken->m_ProfileId = aClient->GetProfile()->m_ProfileId;
myAuthToken->m_AccountId = 69;
// TigerMD5 of ...? (possibly crypt keys)
/*myAuthToken->m_Hash.m_Hash[0] = 0x558C0A1C;
myAuthToken->m_Hash.m_Hash[1] = 0xA59C9FCA;
myAuthToken->m_Hash.m_Hash[2] = 0x6566857D;
myAuthToken->m_Hash.m_Hash[3] = 0x8A3FF551;
myAuthToken->m_Hash.m_Hash[4] = 0xB69D17E5;
myAuthToken->m_Hash.m_Hash[5] = 0xD7BBF74D;*/
memset(&myAuthToken->m_Hash.m_Hash, 0, 6 * sizeof(ulong));
myAuthToken->m_Hash.m_HashLength = 6 * sizeof(ulong);
myAuthToken->m_Hash.m_GeneratedFromHashAlgorithm = HASH_ALGORITHM_TIGER;
myAuthToken->ToStream(&cryptMessage);// Write the authorization token info stream
cryptMessage.WriteUInt(WIC_CREDAUTH_RESEND_S); // periodicityOfCredentialsRequests (How long until the first is sent)
cryptMessage.WriteUInt(0); // myLeaseTimeLeft (Limited access key)
cryptMessage.WriteUInt(45523626); // myAntiSpoofToken (Random number)
}
#else
//DebugLog(L_INFO, "ACCOUNT_AUTH_ACCOUNT_RSP: Sending login response (id %i)", AccountId);
DebugLog(L_INFO, "ACCOUNT_AUTH_ACCOUNT_RSP:");
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_AUTH_ACCOUNT_RSP;
MMG_AuthToken *myAuthToken = aClient->GetToken();
MMG_Profile *myProfile = aClient->GetProfile();
//password check should be done by massgate server, not by database
PasswordHash hasher(8, false);
char myPasswordHash[WIC_PASSWORDHASH_MAX_LENGTH];
memset(myPasswordHash, 0, sizeof(myPasswordHash));
char myPasswordMD5[64];
memset(myPasswordMD5, 0, sizeof(myPasswordMD5));
MC_Misc::MD5String(myQuery.m_Authenticate.m_Password, myPasswordMD5);
uchar isBanned = 0;
uint myStatusCode = 0;
uint mySuccessFlag = 0;
// Query the database
bool AuthQueryOK = MySQLDatabase::ourInstance->AuthUserAccount(myQuery.m_Authenticate.m_Email, myPasswordHash, &isBanned, myAuthToken);
// TODO: generate a better authtoken
myAuthToken->m_TokenId = MC_MTwister().Random();
//determine if credentials were valid
if(myAuthToken->m_AccountId == 0 && AuthQueryOK) //account doesnt exist
{
myStatusCode = AuthFailed_NoSuchAccount;
mySuccessFlag = 0;
}
else if(!hasher.CheckPassword(myPasswordMD5, myPasswordHash) && AuthQueryOK) //wrong password
{
myStatusCode = AuthFailed_BadCredentials;
mySuccessFlag = 0;
}
else if(isBanned && AuthQueryOK) //account has been banned
{
myStatusCode = AuthFailed_AccountBanned;
mySuccessFlag = 0;
}
else if(myAuthToken->m_ProfileId == 0 && AuthQueryOK) //no profiles exist. bring up add profile box
{
myStatusCode = AuthFailed_RequestedProfileNotFound;
mySuccessFlag = 0;
}
else if(SvClientManager::ourInstance->AccountInUse(myAuthToken->m_AccountId))
{
myStatusCode = AuthFailed_AccountInUse;
mySuccessFlag = 0;
}
else if(!AuthQueryOK) // something went wrong executing the query
{
myStatusCode = AuthFailed_General; //ServerError
mySuccessFlag = 0;
}
else //should be ok to retrieve a profile
{
// TODO insert missing data
if (myAuthToken->m_AccountId > 0)
{
// update geoip info
MySQLDatabase::ourInstance->UpdateRealCountry(myAuthToken->m_AccountId, aClient->GetIPAddress());
// update missing sequence number & cipherkeys for handmade accounts
MySQLDatabase::ourInstance->UpdateCDKeyInfo(myAuthToken->m_AccountId, myQuery.m_EncryptionKeySequenceNumber, myQuery.m_CipherKeys);
// if current password hash is md5 based, update to blowfish
if (!strncmp(myPasswordHash, "$H$", 3))
{
memset(myPasswordHash, 0, sizeof(myPasswordHash));
hasher.HashPassword(myPasswordHash, myPasswordMD5);
MySQLDatabase::ourInstance->UpdatePassword(myAuthToken->m_AccountId, myPasswordHash);
}
}
bool ProfileQueryOK;
//AuthFailed_AccountInUse, AuthFailed_ProfileInUse, AuthFailed_CdKeyInUse, AuthFailed_IllegalCDKey(not using)
//profile selection box was used
if(myQuery.m_Authenticate.m_UseProfile)
{
ProfileQueryOK = MySQLDatabase::ourInstance->QueryUserProfile(myAuthToken->m_AccountId, myQuery.m_Authenticate.m_UseProfile, myProfile);
//if(myQuery.m_Authenticate.m_UseProfile > 0 && ProfileQueryOK)
if(ProfileQueryOK) //ok to login, set active profile
{
myAuthToken->m_ProfileId = myProfile->m_ProfileId;
myStatusCode = AuthSuccess;
mySuccessFlag = 1;
}
else //!ProfileQueryOK // something went wrong executing the query
{
myStatusCode = AuthFailed_General; //ServerError
mySuccessFlag = 0;
}
}
//login button was used
else
{
//if(myQuery.m_Authenticate.m_HasOldCredentials)
//myQuery.m_Authenticate.m_Credentials, myQuery.m_Authenticate.m_Profile, myQuery.m_Authenticate.m_UseProfile
//myAuthToken, myProfile
ProfileQueryOK = MySQLDatabase::ourInstance->QueryUserProfile(myAuthToken->m_AccountId, myAuthToken->m_ProfileId, myProfile);
if(myAuthToken->m_ProfileId > 0 && ProfileQueryOK) // ok to login, set active profile
{
myAuthToken->m_ProfileId = myProfile->m_ProfileId;
myStatusCode = AuthSuccess;
mySuccessFlag = 1;
}
else //!ProfileQueryOK // something went wrong executing the query
{
myStatusCode = AuthFailed_General; //ServerError
mySuccessFlag = 0;
}
}
//TODO: use SetLoginStatus() + SetTimeout(), we need
//a way to determine if a profile or account is currently in use
//auth.myLatestVersion??
// Update the maximum client timeout
aClient->SetLoginStatus(true);
aClient->SetIsPlayer(true);
aClient->SetTimeout(WIC_LOGGEDIN_NET_TIMEOUT);
}
//write response message to the stream;
cryptMessage.WriteUChar(myStatusCode);
cryptMessage.WriteUChar(mySuccessFlag); // auth.mySuccessFlag
cryptMessage.WriteUShort(0); // auth.myLatestVersion
// Write the profile info stream
myProfile->ToStream(&cryptMessage);
// TigerMD5 of ...? (possibly crypt keys)
/*myAuthToken->m_Hash.m_Hash[0] = 0x558C0A1C;
myAuthToken->m_Hash.m_Hash[1] = 0xA59C9FCA;
myAuthToken->m_Hash.m_Hash[2] = 0x6566857D;
myAuthToken->m_Hash.m_Hash[3] = 0x8A3FF551;
myAuthToken->m_Hash.m_Hash[4] = 0xB69D17E5;
myAuthToken->m_Hash.m_Hash[5] = 0xD7BBF74D;
memset(&myAuthToken->m_Hash.m_Hash, 0, 6 * sizeof(ulong));*/
myAuthToken->m_Hash.m_HashLength = 6 * sizeof(ulong);
myAuthToken->m_Hash.m_GeneratedFromHashAlgorithm = HASH_ALGORITHM_TIGER;
// Write the authorization token info stream
myAuthToken->ToStream(&cryptMessage);
cryptMessage.WriteUInt(WIC_CREDAUTH_RESEND_S); // periodicityOfCredentialsRequests (How long until the first is sent)
cryptMessage.WriteUInt(0); // myLeaseTimeLeft (Limited access key)
//cryptMessage.WriteUInt(45523626); // myAntiSpoofToken (Random number)
cryptMessage.WriteUInt(myAuthToken->m_TokenId); // TODO
#endif
}
break;
// Client request to create a new account
case MMG_ProtocolDelimiters::ACCOUNT_CREATE_ACCOUNT_REQ:
{
DebugLog(L_INFO, "ACCOUNT_CREATE_ACCOUNT_RSP:");
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_CREATE_ACCOUNT_RSP;
#ifdef USING_MYSQL_DATABASE
bool isPrivateKeyUser = false;
uint myAccountId = 0;
uint myCdkeyId = 0;
uint myStatusCode = 0;
uint mySuccessFlag = 0;
bool CheckEmailQueryOK = MySQLDatabase::ourInstance->CheckIfEmailExists(myQuery.m_Create.m_Email, &myAccountId);
bool CheckCDKeyQueryOK = MySQLDatabase::ourInstance->CheckIfCDKeyExists(myQuery.m_EncryptionKeySequenceNumber, &myCdkeyId);
if (myAccountId > 0 && CheckEmailQueryOK)
{
myStatusCode = CreateFailed_EmailExists;
mySuccessFlag = 0;
}
else if (myCdkeyId > 0 && CheckCDKeyQueryOK)
{
myStatusCode = CreateFailed_CdKeyExhausted;
mySuccessFlag = 0;
}
else if (!CheckEmailQueryOK || !CheckCDKeyQueryOK)
{
myStatusCode = CreateFailed_General; //ServerError
mySuccessFlag = 0;
}
else
{
uint checkId = 0;
uchar checkValidated = 0;
char checkEmail[WIC_EMAIL_MAX_LENGTH];
memset(checkEmail, 0, sizeof(checkEmail));
bool CheckPrivateCDKeyQueryOk = MySQLDatabase::ourInstance->CheckIfPrivateCDKeyUser(myQuery.m_EncryptionKeySequenceNumber, &checkId, checkEmail, &checkValidated);
if (checkId > 0 && CheckPrivateCDKeyQueryOk)
{
// private
isPrivateKeyUser = true;
uint myPrivateCDKeyId = 0;
uint checkAccountId = 0;
// todo: extra checks, ip address, cipherkeys? etc
bool AuthPrivateCDKeyQueryOk = MySQLDatabase::ourInstance->AuthPrivateCDKey(myQuery.m_EncryptionKeySequenceNumber, myQuery.m_Create.m_Email, &myPrivateCDKeyId, &checkAccountId);
if (myPrivateCDKeyId == 0 && AuthPrivateCDKeyQueryOk)
{
myStatusCode = CreateFailed_General;
mySuccessFlag = 0;
}
else if (checkAccountId > 0 && AuthPrivateCDKeyQueryOk)
{
myStatusCode = CreateFailed_CdKeyExhausted;
mySuccessFlag = 0;
}
else if (!AuthPrivateCDKeyQueryOk)
{
myStatusCode = CreateFailed_General;
mySuccessFlag = 0;
}
else
{
myStatusCode = ActionStatusCodes::Creating;
mySuccessFlag = 1;
}
}
else
{
// purchased key from before the shutdown
myStatusCode = ActionStatusCodes::Creating;
mySuccessFlag = 1;
}
if (myStatusCode == ActionStatusCodes::Creating && mySuccessFlag == 1)
{
char realcountry[WIC_COUNTRY_MAX_LENGTH];
memset(realcountry, 0, sizeof(realcountry));
strcpy_s(realcountry, GeoIP::ClientLocateIP(aClient->GetIPAddress()));
PasswordHash hasher(8, false);
char myPasswordHash[WIC_PASSWORDHASH_MAX_LENGTH];
memset(myPasswordHash, 0, sizeof(myPasswordHash));
char myPasswordMD5[64];
memset(myPasswordMD5, 0, sizeof(myPasswordMD5));
MC_Misc::MD5String(myQuery.m_Create.m_Password, myPasswordMD5);
hasher.HashPassword(myPasswordHash, myPasswordMD5);
bool CreateQueryOK = MySQLDatabase::ourInstance->CreateUserAccount(isPrivateKeyUser, myQuery.m_Create.m_Email, myPasswordHash, myQuery.m_Create.m_Country, realcountry, &myQuery.m_Create.m_EmailMeGameRelated, &myQuery.m_Create.m_AcceptsEmail, myQuery.m_EncryptionKeySequenceNumber, myQuery.m_CipherKeys);
if (CreateQueryOK)
{
myStatusCode = CreateSuccess;
mySuccessFlag = 1;
}
else
{
myStatusCode = CreateFailed_General; //ServerError
mySuccessFlag = 0;
}
}
}
cryptMessage.WriteUChar(myStatusCode);
cryptMessage.WriteUChar(mySuccessFlag);
#endif
}
break;
// Prepare (sent before ACCOUNT_CREATE_ACCOUNT_REQ) authorization for cd-key
case MMG_ProtocolDelimiters::ACCOUNT_PREPARE_CREATE_ACCOUNT_REQ:
{
DebugLog(L_INFO, "ACCOUNT_PREPARE_CREATE_ACCOUNT_RSP:");
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_PREPARE_CREATE_ACCOUNT_RSP;
char country[WIC_COUNTRY_MAX_LENGTH]; // Guessed by IPv4 geolocation information
#ifndef USING_MYSQL_DATABASE
strcpy_s(country, "US");
#else
char* countrycode = GeoIP::ClientLocateIP(aClient->GetIPAddress());
strcpy_s(country, countrycode);
#endif
cryptMessage.WriteUChar(AuthSuccess); // Otherwise AuthFailed_CdKeyExpired
cryptMessage.WriteUChar(1); // mySuccessFlag
cryptMessage.WriteString(country); // yourCountry
}
break;
// Client requests a session update to prevent dropping
case MMG_ProtocolDelimiters::ACCOUNT_NEW_CREDENTIALS_REQ:
{
DebugLog(L_INFO, "ACCOUNT_NEW_CREDENTIALS_RSP:");
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_NEW_CREDENTIALS_RSP;
// Default to success until it's actually implemented (if ever)
cryptMessage.WriteUChar(AuthSuccess);
// Write the authorization token info stream
aClient->GetToken()->ToStream(&cryptMessage);
// doCredentialsRequestAgain (in seconds)
cryptMessage.WriteUInt(WIC_CREDAUTH_RESEND_S);
}
break;
// Retrieve account profiles list (maximum 5)
case MMG_ProtocolDelimiters::ACCOUNT_RETRIEVE_PROFILES_REQ:
{
DebugLog(L_INFO, "ACCOUNT_RETRIEVE_PROFILES_RSP: getting profiles for %s", myQuery.m_RetrieveProfiles.m_Email);
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_RETRIEVE_PROFILES_RSP;
#ifndef USING_MYSQL_DATABASE
cryptMessage.WriteUChar(AuthSuccess);
cryptMessage.WriteUChar(1); // mySuccessFlag
cryptMessage.WriteUInt(1); // numUserProfiles
cryptMessage.WriteUInt(1234); // lastUsedProfileId
MMG_Profile *myProfile = aClient->GetProfile();
wcscpy_s(myProfile->m_Name, L"Nukem");
myProfile->m_ProfileId = 1234;
//myProfile->m_ClanId = 4321;
myProfile->m_OnlineStatus = 0;
myProfile->m_Rank = 18;
//myProfile->m_RankInClan = 1;
// Write the profile info stream
myProfile->ToStream(&cryptMessage);
#else
MMG_AuthToken *myAuthToken = aClient->GetToken();
MMG_Profile myProfiles[5];
PasswordHash hasher(8, false);
char myPasswordHash[WIC_PASSWORDHASH_MAX_LENGTH];
memset(myPasswordHash, 0, sizeof(myPasswordHash));
char myPasswordMD5[64];
memset(myPasswordMD5, 0, sizeof(myPasswordMD5));
MC_Misc::MD5String(myQuery.m_RetrieveProfiles.m_Password, myPasswordMD5);
uchar isBanned = 0;
ulong myProfileCount = 0;
uint lastUsedId = 0;
uint myStatusCode = 0;
uint mySuccessFlag = 0;
bool AuthQueryOK = MySQLDatabase::ourInstance->AuthUserAccount(myQuery.m_RetrieveProfiles.m_Email, myPasswordHash, &isBanned, myAuthToken);
//determine if credentials were valid
if(myAuthToken->m_AccountId == 0 && AuthQueryOK) //account doesnt exist
{
myStatusCode = AuthFailed_BadCredentials; //AuthFailed_NoSuchAccount
mySuccessFlag = 0;
}
else if(!hasher.CheckPassword(myPasswordMD5, myPasswordHash) && AuthQueryOK) //wrong password
{
myStatusCode = AuthFailed_BadCredentials;
mySuccessFlag = 0;
}
else if(isBanned && AuthQueryOK) //account has been banned
{
myStatusCode = AuthFailed_AccountBanned;
mySuccessFlag = 0;
}
else if(SvClientManager::ourInstance->AccountInUse(myAuthToken->m_AccountId))
{
myStatusCode = AuthFailed_AccountInUse;
mySuccessFlag = 0;
}
else if(!AuthQueryOK) // something went wrong executing the query
{
myStatusCode = AuthFailed_General; //ServerError
mySuccessFlag = 0;
}
else //should be ok to retrieve profile list
{
// TODO insert missing data
if (myAuthToken->m_AccountId > 0)
{
// update geoip info
MySQLDatabase::ourInstance->UpdateRealCountry(myAuthToken->m_AccountId, aClient->GetIPAddress());
// update missing sequence number & cipherkeys for handmade accounts
MySQLDatabase::ourInstance->UpdateCDKeyInfo(myAuthToken->m_AccountId, myQuery.m_EncryptionKeySequenceNumber, myQuery.m_CipherKeys);
// if current password hash is md5 based, update to blowfish
if (!strncmp(myPasswordHash, "$H$", 3))
{
memset(myPasswordHash, 0, sizeof(myPasswordHash));
hasher.HashPassword(myPasswordHash, myPasswordMD5);
MySQLDatabase::ourInstance->UpdatePassword(myAuthToken->m_AccountId, myPasswordHash);
}
}
bool RetrieveProfilesQueryOK = MySQLDatabase::ourInstance->RetrieveUserProfiles(myAuthToken->m_AccountId, &myProfileCount, myProfiles);
if(RetrieveProfilesQueryOK)
{
myStatusCode = AuthSuccess;
mySuccessFlag = 1;
lastUsedId = myProfiles[0].m_ProfileId; //myAuthToken->m_ProfileId
}
else
{
myStatusCode = AuthFailed_General; //ServerError
mySuccessFlag = 0;
myProfileCount = 0;
lastUsedId = 0;
}
}
cryptMessage.WriteUChar(myStatusCode);
cryptMessage.WriteUChar(mySuccessFlag); // mySuccessFlag
cryptMessage.WriteUInt(myProfileCount); // numUserProfiles
cryptMessage.WriteUInt(lastUsedId); // lastUsedProfileId
//write profile/s to stream
for(uint i=0; i < myProfileCount; i++)
myProfiles[i].ToStream(&cryptMessage);
#endif
}
break;
case MMG_ProtocolDelimiters::ACCOUNT_MODIFY_PROFILE_REQ:
{
#ifdef USING_MYSQL_DATABASE
//DebugLog(L_INFO, "ACCOUNT_MODIFY_PROFILE_RSP: modify profiles");
//responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_MODIFY_PROFILE_RSP;
responseDelimiter = MMG_ProtocolDelimiters::ACCOUNT_RETRIEVE_PROFILES_RSP;
MMG_AuthToken *myAuthToken = aClient->GetToken();
MMG_Profile myProfiles[5];
uchar isBanned = 0;
ulong myProfileCount = 0;
uint lastUsedId = 0;
uint myProfileId = 0;
uint myStatusCode = 0;
uint mySuccessFlag = 0;
if (myQuery.m_ModifyProfile.m_Operation == 'add')
{
DebugLog(L_INFO, "ACCOUNT_MODIFY_PROFILE_RSP: add new profile for %s", myQuery.m_ModifyProfile.m_Email);
bool CheckProfileQueryOK = MySQLDatabase::ourInstance->CheckIfProfileExists(myQuery.m_ModifyProfile.m_Name, &myProfileId);
if (myProfileId > 0 && CheckProfileQueryOK) //profile exists with that name
{
myStatusCode = ModifyFailed_ProfileNameTaken;
mySuccessFlag = 1;
}
else if (!CheckProfileQueryOK)
{
myStatusCode = ModifyFailed_General; //server / database error
mySuccessFlag = 1;
}
else //should be ok to create profile
{
bool CreateProfileQueryOK = MySQLDatabase::ourInstance->CreateUserProfile(myAuthToken->m_AccountId, myQuery.m_ModifyProfile.m_Name, myQuery.m_ModifyProfile.m_Email);
if(CreateProfileQueryOK) //create profile success
{
myStatusCode = ModifySuccess;
mySuccessFlag = 1;
}
else //!CreateProfileQueryOK // something went wrong executing the query
{
myStatusCode = ModifyFailed_General; //ServerError
mySuccessFlag = 1;
}
}
}
else if (myQuery.m_ModifyProfile.m_Operation == 'del')
{
DebugLog(L_INFO, "ACCOUNT_MODIFY_PROFILE_RSP: delete profile %d for %s", myQuery.m_ModifyProfile.m_ProfileId, myQuery.m_ModifyProfile.m_Email);
MMG_Profile myProfile;
bool ProfileQueryOK = MySQLDatabase::ourInstance->QueryProfileName(myQuery.m_ModifyProfile.m_ProfileId, &myProfile);
if (!ProfileQueryOK)
{
myStatusCode = ModifyFailed_General;
mySuccessFlag = 0;
}
else if (ProfileQueryOK && myProfile.m_ClanId > 0)
{
myStatusCode = DeleteProfile_Failed_Clan;
mySuccessFlag = 1;
}
else
{
bool DeleteProfileQueryOK = MySQLDatabase::ourInstance->DeleteUserProfile(myAuthToken->m_AccountId, myQuery.m_ModifyProfile.m_ProfileId, myQuery.m_ModifyProfile.m_Email);
if(DeleteProfileQueryOK) //delete profile success
{
myStatusCode = ModifySuccess;
mySuccessFlag = 1;
}
else //!DeleteProfileQueryOK // something went wrong executing the query
{
myStatusCode = ModifyFailed_General; //ServerError
mySuccessFlag = 1;
}
}
}
else
{
DebugLog(L_INFO, "ACCOUNT_MODIFY_PROFILE_RSP: unknown operation");
}
// retrieve and send profile list
bool RetrieveProfilesQueryOK = MySQLDatabase::ourInstance->RetrieveUserProfiles(myAuthToken->m_AccountId, &myProfileCount, myProfiles);
if (RetrieveProfilesQueryOK && mySuccessFlag)
{
lastUsedId = myProfiles[0].m_ProfileId; //myAuthToken->m_ProfileId
}
else
{
myStatusCode = ModifyFailed_General; //ServerError
mySuccessFlag = 0;
myProfileCount = 0;
lastUsedId = 0;
}
cryptMessage.WriteUChar(myStatusCode);
cryptMessage.WriteUChar(mySuccessFlag); // mySuccessFlag
cryptMessage.WriteUInt(myProfileCount); // numUserProfiles
cryptMessage.WriteUInt(lastUsedId); // lastUsedProfileId
//write profile/s to stream
for(uint i=0; i < myProfileCount; i++)
myProfiles[i].ToStream(&cryptMessage);
#endif
}
break;
default:
DebugLog(L_WARN, "Unknown delimiter %i", aDelimiter);
return false;
}
}
// Write the main message header
MN_WriteMessage responseMsg(1024);
responseMsg.WriteDelimiter(responseDelimiter);
responseMsg.WriteUShort(MassgateProtocolVersion);
responseMsg.WriteUChar(aClient->m_CipherIdentifier);
responseMsg.WriteUInt(aClient->m_EncryptionKeySequenceNumber);
// Encrypt and write the data to the main (outgoing) packet
// Packet buffer can be modified because it is no longer used
sizeptr_t dataLength = cryptMessage.GetDataLength();
voidptr_t dataStream = cryptMessage.GetDataStream();
if (!MMG_ICipher::EncryptWith(aClient->m_CipherIdentifier, aClient->m_CipherKeys, (uint *)dataStream, dataLength))
return false;
responseMsg.WriteUShort(dataLength);
responseMsg.WriteRawData(dataStream, dataLength);
// Finally send the message
if (!aClient->SendData(&responseMsg))
return false;
return true;
}
/* SEARCH_HISTORY -- Search for the occurrence of the given string in the
* history buffer, leaving the corresponding command in the output buffer
* if it matches the pattern. Return the number of directive characters used.
* The "repeat last command" directive "^" is a special case: the null string
* matches anything.
*/
int
search_history (char *directive, char *new_command_block)
{
register char *ip, *op, *p;
char pattern[SZ_FNAME];
int match_only_at_bol=1, record, patlen;
ip = directive + 1; /* skip the '^' */
if (*ip == '\\' && *(ip+1) == MATCH_ANYWHERE)
ip++;
else if (*ip == MATCH_ANYWHERE) {
ip++;
match_only_at_bol = 0;
}
/* Extract pattern, delimited by whitespace, EOS, ?, or ":p",
* depending on whether we have ?? delimiters.
*/
patlen = strlen (NO_EXECUTE);
for (op=pattern; (*op = *ip) != EOS; op++, ip++)
if (match_only_at_bol) {
if (isspace (*ip))
break;
else if (strncmp (ip, NO_EXECUTE, patlen) == 0)
break;
} else if (*ip == '\\' && *(ip+1) == MATCH_ANYWHERE) {
*op = *++ip;
} else if (*ip == MATCH_ANYWHERE) {
ip++;
break;
}
*op++ = EOS;
/* Search backwards in history buffer until command is found
* which matches the pattern. The null pattern matches anything.
*/
patlen = strlen (pattern);
record = 1;
while (get_history (record++, new_command_block, SZ_CMDBLK) != ERR) {
if (patlen == 0) {
break;
} else if (match_only_at_bol) {
if (strncmp (new_command_block, pattern, patlen) == 0)
break;
} else {
for (p=new_command_block; *p != EOS; p++) {
if (*p == *pattern && strncmp(p,pattern,patlen) == 0)
break;
}
if (*p != EOS)
break;
}
}
if (strlen (new_command_block) == 0)
cl_error (E_UERR, "Event not found");
return (ip - directive);
}
library_all_infos_struct* ReadSharedCacheMap(const char *path) {
uint64_t b_address, e_address;
char frameworkName[256];
char *tokens[64];
char buf[1024];
char *fnp;
FILE *fd;
int ntokens;
int type;
int linkedit_found = 0;
char *substring, *ptr;
int numFrameworks = 0;
bzero(buf, sizeof(buf));
bzero(tokens, sizeof(tokens));
if ((fd = fopen(path, "r")) == 0)
{
return 0;
}
while (fgets(buf, 1023, fd)) {
if (strncmp(buf, "mapping", 7))
break;
}
buf[strlen(buf)-1] = 0;
frameworkName[0] = 0;
int start;
library_all_infos_struct* lib_all_infos =safe_malloc(sizeof(library_all_infos_struct));
lib_all_infos->count = 0;
for (;;) {
//Extract lib name from path name
ptr = buf;
substring = ptr;
start = 0;
while (*ptr) {
if (*ptr == '/' && start == 0) {
substring = ptr;
start = 1;
}
ptr++;
}
strncpy(frameworkName, substring, 256);
frameworkName[255] = 0;
fnp = (char *)malloc(strlen(frameworkName) + 1);
strcpy(fnp, frameworkName);
while (fgets(buf, 1023, fd) && numFrameworks < (MAXINDEX - 2)) {
/*
* Get rid of EOL
*/
buf[strlen(buf)-1] = 0;
ntokens = scanline(buf, tokens, 64);
if (ntokens < 4)
continue;
if (strncmp(tokens[0], "__TEXT", 6) == 0)
type = TEXT_R;
else if (strncmp(tokens[0], "__DATA", 6) == 0)
type = DATA_R;
else if (strncmp(tokens[0], "__OBJC", 6) == 0)
type = OBJC_R;
else if (strncmp(tokens[0], "__IMPORT", 8) == 0)
type = IMPORT_R;
else if (strncmp(tokens[0], "__UNICODE", 9) == 0)
type = UNICODE_R;
else if (strncmp(tokens[0], "__IMAGE", 7) == 0)
type = IMAGE_R;
else if (strncmp(tokens[0], "__LINKEDIT", 10) == 0)
type = LINKEDIT_R;
else
type = -1;
if (type == LINKEDIT_R && linkedit_found)
break;
if (type != -1) {
b_address = strtoull(tokens[1], 0, 16);
e_address = strtoull(tokens[3], 0, 16);
library_info_struct* new_lib_info = safe_malloc(sizeof(library_info_struct));
new_lib_info->b_address = b_address;
new_lib_info->e_address = e_address;
new_lib_info->r_type = type;
new_lib_info->name = fnp;
lib_all_infos->lib_info[lib_all_infos->count++] = new_lib_info;
if (type == LINKEDIT_R) {
linkedit_found = 1;
}
// #if DEBUG
// printf("%s(%d): %qx-%qx\n", frameworkInfo[numFrameworks].name, type, b_address, e_address);
// #endif
numFrameworks++;
}
if (type == LINKEDIT_R)
break;
}
if (fgets(buf, 1023, fd) == 0)
break;
buf[strlen(buf)-1] = 0;
}
fclose(fd);
// #if DEBUG
// for(int i=0;i<lib_all_infos->count;i++)
// {
// library_info_struct* dyldinfo = lib_all_infos->lib_info[i];
// printf("%p %p %d %s \n", dyldinfo->b_address, dyldinfo->e_address, dyldinfo->r_type, dyldinfo->name);
// }
// #endif
return lib_all_infos;
}
ENTRYPOINT void
init_unicrud (ModeInfo *mi)
{
unicrud_configuration *bp;
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_unicrud (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
{
double spin_speed = 0.05;
double wander_speed = 0.01;
double spin_accel = 1.0;
bp->rot = make_rotator (do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
spin_accel,
do_wander ? wander_speed : 0,
False);
bp->trackball = gltrackball_init (True);
}
bp->title_font = load_texture_font (mi->dpy, "titleFont");
bp->char_font = load_texture_font (mi->dpy, "font");
bp->state = IN;
bp->ratio = 0;
bp->spin_direction = (random() & 1) ? 1 : -1;
if (matches ("all", do_block))
do_block = strdup("");
{
char *s;
for (s = do_block; *s; s++)
if (*s == '_') *s = ' ';
}
if (matches ("help", do_block))
{
int i;
fprintf (stderr,
"%s: --blocks must contain one or more of these,"
" separated by commas:\n\n", progname);
for (i = 0; i < countof(unicode_block_names); i++)
{
const char *n = unicode_block_names[i].name;
if (*n == '*')
continue;
if (!strncmp (n, "Unassigned", 10) ||
!strncmp (n, "Combining", 9))
continue;
fprintf (stderr, "\t%s\n", n);
}
fprintf (stderr, "\n");
exit (1);
}
/* Make sure all elements in --block are valid.
*/
if (*do_block)
{
char *token = strdup (do_block ? do_block : "");
char *otoken = token;
char *name;
while ((name = strtok (token, ","))) {
token = 0;
name = strip (name);
if (*name)
{
Bool match = False;
int i;
for (i = 0; i < countof(unicode_block_names); i++)
{
const char *n = unicode_block_names[i].name;
if (*n == '*')
continue;
if (!strncmp (n, "Unassigned", 10) ||
!strncmp (n, "Combining", 9))
continue;
if (!strcasecmp (name, n))
{
match = True;
break;
}
}
if (! match)
{
fprintf (stderr, "%s: unknown block name: \"%s\"\n",
progname, name);
fprintf (stderr, "%s: use '--block help' for a list\n",
progname);
exit (1);
}
}
}
free (otoken);
}
pick_unichar (mi);
}
static inline int oma_match_identity_condition(xmlNodePtr condition, subs_t *subs, str *w_uri)
{
int r = 0, many_match = 0;
char *domain = NULL;
str uri;
str *normalized_uri;
xmlNodePtr node = NULL, except_node = NULL;
for(node = condition->children; node; node = node->next)
{
if(xmlStrcasecmp(node->name, (unsigned char*)"one") == 0)
{
uri.s = xmlNodeGetAttrContentByName(node, "id");
if(uri.s == NULL)
{
LM_ERR("when extracting entry attribute\n");
continue;
}
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
r = 1;
break;
}
}
else if(xmlStrcasecmp(node->name, (unsigned char*)"many") == 0)
{
domain = xmlNodeGetAttrContentByName(node, "domain");
if(domain == NULL)
{
LM_DBG("No domain attribute in identity many\n");
}
else
{
LM_DBG("<many domain= %s>\n", domain);
if(!(strlen(domain) == subs->from_domain.len &&
strncmp(domain, subs->from_domain.s, subs->from_domain.len) == 0))
{
xmlFree(domain);
continue;
}
xmlFree(domain);
}
many_match = 1;
for(except_node = node->children; except_node; except_node= except_node->next)
{
if(xmlStrcasecmp(except_node->name, (unsigned char*)"except"))
continue;
uri.s = xmlNodeGetAttrContentByName(except_node, "id");
if(uri.s != NULL)
{
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
many_match = 0;
break;
}
}
else
{
domain = NULL;
domain = xmlNodeGetAttrContentByName(except_node, "domain");
if(domain != NULL)
{
LM_DBG("Found except domain= %s\n- strlen(domain)= %d\n", domain, (int)strlen(domain));
if(strlen(domain)==subs->from_domain.len &&
(strncmp(domain,subs->from_domain.s , subs->from_domain.len)==0))
{
LM_DBG("except domain match\n");
xmlFree(domain);
many_match = 0;
break;
}
xmlFree(domain);
}
}
}
if(many_match)
{
r = 1;
break;
}
}
}
return r;
}
static void ietf_get_rules(subs_t* subs, xmlDocPtr xcap_tree, xcap_rule_t **rules)
{
str w_uri= {0, 0};
char* id = NULL, *domain = NULL, *time_cont= NULL;
int apply_rule = -1;
xmlNodePtr ruleset_node = NULL, node1= NULL, node2= NULL;
xmlNodePtr cond_node = NULL, except_node = NULL;
xmlNodePtr identity_node = NULL, sphere_node = NULL;
xmlNodePtr iden_child;
xmlNodePtr validity_node, time_node;
time_t t_init, t_fin, t;
int valid= 0;
xcap_rule_t *rule = NULL;
*rules = NULL;
uandd_to_uri(subs->from_user, subs->from_domain, &w_uri);
if(w_uri.s == NULL)
{
LM_ERR("while creating uri\n");
return;
}
ruleset_node = xmlDocGetNodeByName(xcap_tree, "ruleset", NULL);
if(ruleset_node == NULL)
{
LM_DBG("ruleset_node NULL\n");
goto error;
}
for(node1 = ruleset_node->children ; node1; node1 = node1->next)
{
if(xmlStrcasecmp(node1->name, (unsigned char*)"text")==0 )
continue;
/* process conditions */
LM_DBG("node1->name= %s\n", node1->name);
cond_node = xmlNodeGetChildByName(node1, "conditions");
if(cond_node == NULL)
{
LM_DBG("cond node NULL\n");
goto error;
}
LM_DBG("cond_node->name= %s\n", cond_node->name);
validity_node = xmlNodeGetChildByName(cond_node, "validity");
if(validity_node !=NULL)
{
LM_DBG("found validity tag\n");
t= time(NULL);
/* search all from-until pair */
for(time_node= validity_node->children; time_node;
time_node= time_node->next)
{
if(xmlStrcasecmp(time_node->name, (unsigned char*)"from")!= 0)
{
continue;
}
time_cont= (char*)xmlNodeGetContent(time_node);
t_init= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if(t_init< 0)
{
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if(t< t_init)
{
LM_DBG("the lower time limit is not respected\n");
continue;
}
time_node= time_node->next;
while(1)
{
if(time_node== NULL)
{
LM_ERR("bad formatted xml doc:until child not found in"
" validity pair\n");
goto error;
}
if( xmlStrcasecmp(time_node->name,
(unsigned char*)"until")== 0)
break;
time_node= time_node->next;
}
time_cont= (char*)xmlNodeGetContent(time_node);
t_fin= xml_parse_dateTime(time_cont);
xmlFree(time_cont);
if(t_fin< 0)
{
LM_ERR("failed to parse xml dateTime\n");
goto error;
}
if(t <= t_fin)
{
LM_DBG("the rule is active at this time\n");
valid= 1;
}
}
if(!valid)
{
LM_DBG("the rule is not active at this time\n");
continue;
}
}
sphere_node = xmlNodeGetChildByName(cond_node, "sphere");
if(sphere_node!= NULL)
{
/* check to see if matches presentity current sphere */
/* ask presence for sphere information */
char* sphere= pres_get_sphere(&subs->pres_uri);
if(sphere)
{
char* attr= (char*)xmlNodeGetContent(sphere_node);
if(xmlStrcasecmp((unsigned char*)attr, (unsigned char*)sphere)!= 0)
{
LM_DBG("sphere condition not respected\n");
pkg_free(sphere);
xmlFree(attr);
continue;
}
pkg_free(sphere);
xmlFree(attr);
}
else
{
LM_DBG("Noo sphere definition found\n");
continue;
}
/* if the user has not define a sphere
* consider the condition false*/
}
identity_node = xmlNodeGetChildByName(cond_node, "identity");
if(identity_node == NULL)
{
LM_ERR("didn't find identity tag\n");
goto error;
}
iden_child= xmlNodeGetChildByName(identity_node, "one");
if(iden_child)
{
for(node2 = identity_node->children; node2; node2 = node2->next)
{
if(xmlStrcasecmp(node2->name, (unsigned char*)"one")!= 0)
continue;
id = xmlNodeGetAttrContentByName(node2, "id");
if(id== NULL)
{
LM_ERR("while extracting attribute\n");
goto error;
}
if((strlen(id)== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0)))
{
apply_rule = 1;
xmlFree(id);
break;
}
xmlFree(id);
}
}
/* search for many node*/
iden_child= xmlNodeGetChildByName(identity_node, "many");
if(iden_child)
{
domain = NULL;
for(node2 = identity_node->children; node2; node2 = node2->next)
{
if(xmlStrcasecmp(node2->name, (unsigned char*)"many")!= 0)
continue;
domain = xmlNodeGetAttrContentByName(node2, "domain");
if(domain == NULL)
{
LM_DBG("No domain attribute to many\n");
}
else
{
LM_DBG("<many domain= %s>\n", domain);
if((strlen(domain)!= subs->from_domain.len &&
strncmp(domain, subs->from_domain.s,
subs->from_domain.len) ))
{
xmlFree(domain);
continue;
}
}
xmlFree(domain);
apply_rule = 1;
if(node2->children == NULL) /* there is no exception */
break;
for(except_node = node2->children; except_node;
except_node= except_node->next)
{
if(xmlStrcasecmp(except_node->name, (unsigned char*)"except"))
continue;
id = xmlNodeGetAttrContentByName(except_node, "id");
if(id!=NULL)
{
if((strlen(id)- 1== w_uri.len &&
(strncmp(id, w_uri.s, w_uri.len)==0)))
{
xmlFree(id);
apply_rule = 0;
break;
}
xmlFree(id);
}
else
{
domain = NULL;
domain = xmlNodeGetAttrContentByName(except_node, "domain");
if(domain!=NULL)
{
LM_DBG("Found except domain= %s\n- strlen(domain)= %d\n",
domain, (int)strlen(domain));
if(strlen(domain)==subs->from_domain.len &&
(strncmp(domain,subs->from_domain.s , subs->from_domain.len)==0))
{
LM_DBG("except domain match\n");
xmlFree(domain);
apply_rule = 0;
break;
}
xmlFree(domain);
}
}
}
if(apply_rule== 1) /* if a match was found no need to keep searching*/
break;
}
}
if(apply_rule ==1)
break;
}
LM_DBG("apply_rule= %d\n", apply_rule);
if(w_uri.s!=NULL)
pkg_free(w_uri.s);
if( !apply_rule || !node1)
return;
rule = (xcap_rule_t *)pkg_malloc(sizeof(*rule));
if (rule == NULL)
{
LM_ERR("cannot allocate pkg_mem\n");
return;
}
/* TODO: in IETF mode only the first matching rule is returned */
rule->node = node1;
rule->next = NULL;
*rules = rule;
return;
error:
if(w_uri.s)
pkg_free(w_uri.s);
}
#include "test.h"
MAIN("hello\nworld",
char* data;
bint_t data_len;
buffer_get(buf, &data, &data_len);
ASSERT("len", 11, data_len);
ASSERT("get", 0, strncmp(data, "hello\nworld", data_len));
)
static int cluster_format(int argc, char **argv)
{
int fd, ret;
struct sd_so_req hdr;
struct sd_so_rsp *rsp = (struct sd_so_rsp *)&hdr;
struct timeval tv;
char store_name[STORE_LEN];
DECLARE_BITMAP(vdi_inuse, SD_NR_VDIS);
unsigned long nr;
fd = connect_to(sdhost, sdport);
if (fd < 0)
return EXIT_SYSFAIL;
sd_init_req((struct sd_req *)&hdr, SD_OP_READ_VDIS);
hdr.data_length = sizeof(vdi_inuse);
ret = exec_req(fd, (struct sd_req *)&hdr, &vdi_inuse);
if (ret < 0) {
fprintf(stderr, "Failed to read VDIs from %s:%d\n",
sdhost, sdport);
close(fd);
return EXIT_SYSFAIL;
}
for (nr = 0; nr < SD_NR_VDIS; nr++)
if (test_bit(nr, vdi_inuse))
break;
if (nr != SD_NR_VDIS) {
int i, l;
char str[123] = {'\0'};
printf(FORMAT_PRINT);
ret = scanf("%s", str);
if (ret < 0)
return EXIT_SYSFAIL;
l = strlen(str);
for (i = 0; i < l; i++)
str[i] = tolower(str[i]);
if (strncmp(str, "yes", 3) != 0)
return EXIT_SUCCESS;
}
gettimeofday(&tv, NULL);
sd_init_req((struct sd_req *)&hdr, SD_OP_MAKE_FS);
hdr.copies = cluster_cmd_data.copies;
if (cluster_cmd_data.nohalt)
hdr.flags |= SD_FLAG_NOHALT;
if (cluster_cmd_data.quorum)
hdr.flags |= SD_FLAG_QUORUM;
hdr.ctime = (uint64_t) tv.tv_sec << 32 | tv.tv_usec * 1000;
if (strlen(cluster_cmd_data.name))
pstrcpy(store_name, STORE_LEN, cluster_cmd_data.name);
else
pstrcpy(store_name, STORE_LEN, DEFAULT_STORE);
hdr.data_length = strlen(store_name) + 1;
hdr.flags |= SD_FLAG_CMD_WRITE;
printf("using backend %s store\n", store_name);
ret = exec_req(fd, (struct sd_req *)&hdr, store_name);
close(fd);
if (ret) {
fprintf(stderr, "Failed to connect\n");
return EXIT_SYSFAIL;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Format failed: %s\n",
sd_strerror(rsp->result));
if (rsp->result == SD_RES_NO_STORE)
return list_store();
else
return EXIT_SYSFAIL;
}
return EXIT_SUCCESS;
}
static BOOLEAN
SetActiveDeviceInstance(
IN PTCHAR DeviceInstance
)
{
PTCHAR DeviceName;
BOOLEAN Success;
HKEY ParametersKey;
HRESULT Error;
Log("%s", DeviceInstance);
DeviceName = strchr(DeviceInstance, '\\');
assert(DeviceName != NULL);
DeviceName++;
// Check whether we are binding to the XenServer vendor device
if (strncmp(DeviceName,
XENSERVER_VENDOR_DEVICE_NAME,
strlen(XENSERVER_VENDOR_DEVICE_NAME)) != 0) {
PTCHAR DeviceKeyName;
// We are binding to a legacy platform device so only make it
// active if there is no XenServer vendor device
Success = GetDeviceKeyName(XENSERVER_VENDOR_DEVICE_NAME,
&DeviceKeyName);
if (!Success)
goto fail1;
if (DeviceKeyName != NULL) {
Log("ignoring");
free(DeviceKeyName);
goto done;
}
}
Error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
PARAMETERS_KEY("XEN"),
0,
KEY_ALL_ACCESS,
&ParametersKey);
if (Error != ERROR_SUCCESS) {
SetLastError(Error);
goto fail2;
}
Error = RegSetValueEx(ParametersKey,
"ActiveDeviceInstance",
0,
REG_SZ,
(LPBYTE)DeviceInstance,
(DWORD)(strlen(DeviceInstance) + sizeof (TCHAR)));
if (Error != ERROR_SUCCESS) {
SetLastError(Error);
goto fail3;
}
RegCloseKey(ParametersKey);
done:
return TRUE;
fail3:
Log("fail3");
RegCloseKey(ParametersKey);
fail2:
Log("fail2");
fail1:
Error = GetLastError();
{
PTCHAR Message;
Message = GetErrorMessage(Error);
Log("fail1 (%s)", Message);
LocalFree(Message);
}
return FALSE;
}
static DECLSPEC_NOINLINE BOOLEAN
GetDeviceKeyName(
IN PTCHAR Prefix,
OUT PTCHAR *Name
)
{
BOOLEAN Success;
HKEY PciKey;
HRESULT Error;
DWORD SubKeys;
DWORD MaxSubKeyLength;
DWORD SubKeyLength;
PTCHAR SubKeyName;
DWORD Index;
Success = OpenPciKey(&PciKey);
if (!Success)
goto fail1;
Error = RegQueryInfoKey(PciKey,
NULL,
NULL,
NULL,
&SubKeys,
&MaxSubKeyLength,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
if (Error != ERROR_SUCCESS) {
SetLastError(Error);
goto fail2;
}
SubKeyLength = MaxSubKeyLength + sizeof (TCHAR);
SubKeyName = malloc(SubKeyLength);
if (SubKeyName == NULL)
goto fail3;
for (Index = 0; Index < SubKeys; Index++) {
SubKeyLength = MaxSubKeyLength + sizeof (TCHAR);
memset(SubKeyName, 0, SubKeyLength);
Error = RegEnumKeyEx(PciKey,
Index,
(LPTSTR)SubKeyName,
&SubKeyLength,
NULL,
NULL,
NULL,
NULL);
if (Error != ERROR_SUCCESS) {
SetLastError(Error);
goto fail4;
}
if (strncmp(SubKeyName, Prefix, strlen(Prefix)) == 0)
goto found;
}
free(SubKeyName);
SubKeyName = NULL;
found:
RegCloseKey(PciKey);
Log("%s", (SubKeyName != NULL) ? SubKeyName : "none found");
*Name = SubKeyName;
return TRUE;
fail4:
Log("fail4");
free(SubKeyName);
fail3:
Log("fail3");
fail2:
Log("fail2");
RegCloseKey(PciKey);
fail1:
Error = GetLastError();
{
PTCHAR Message;
Message = GetErrorMessage(Error);
Log("fail1 (%s)", Message);
LocalFree(Message);
}
return FALSE;
}
SHPTreeHandle msSHPDiskTreeOpen(struct zzip_dir *zdir, const char * pszTree,
int debug)
{
char *pszFullname, *pszBasename;
SHPTreeHandle psTree;
char pabyBuf[16];
int i;
#ifdef SHAPELIB_DISABLED
char bBigEndian;
/* -------------------------------------------------------------------- */
/* Establish the byte order on this machine. */
/* -------------------------------------------------------------------- */
i = 1;
if( *((uchar *) &i) == 1 )
bBigEndian = MS_FALSE;
else
bBigEndian = MS_TRUE;
#endif /* SHAPELIB_DISABLED */
/* -------------------------------------------------------------------- */
/* Initialize the info structure. */
/* -------------------------------------------------------------------- */
psTree = (SHPTreeHandle) msSmallMalloc(sizeof(SHPTreeInfo));
/* -------------------------------------------------------------------- */
/* Compute the base (layer) name. If there is any extension */
/* on the passed in filename we will strip it off. */
/* -------------------------------------------------------------------- */
pszBasename = (char *) msSmallMalloc(strlen(pszTree)+5);
strcpy( pszBasename, pszTree );
for( i = strlen(pszBasename)-1;
i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
&& pszBasename[i] != '\\';
i-- ) {}
if( pszBasename[i] == '.' )
pszBasename[i] = '\0';
/* -------------------------------------------------------------------- */
/* Open the .shp and .shx files. Note that files pulled from */
/* a PC to Unix with upper case filenames won't work! */
/* -------------------------------------------------------------------- */
pszFullname = (char *) msSmallMalloc(strlen(pszBasename) + 5);
sprintf( pszFullname, "%s%s", pszBasename, MS_INDEX_EXTENSION);
psTree->fp = zzip_open_rb(zdir, pszFullname);
if( psTree->fp == NULL ) {
sprintf( pszFullname, "%s.QIX", pszBasename);
psTree->fp = zzip_open_rb(zdir, pszFullname);
}
msFree(pszBasename); /* don't need these any more */
msFree(pszFullname);
if( psTree->fp == NULL ) {
msFree(psTree);
return( NULL );
}
zzip_fread( pabyBuf, 8, 1, psTree->fp );
memcpy( &psTree->signature, pabyBuf, 3 );
if( strncmp(psTree->signature,"SQT",3) ) {
/* ---------------------------------------------------------------------- */
/* must check if the 2 first bytes equal 0 of max depth that cannot */
/* be more than 65535. If yes, we must swap all value. The problem */
/* here is if there's no Depth (bytea 5,6,7,8 in the file) all bytes */
/* will be set to 0. So,we will test with the number of shapes (bytes */
/* 1,2,3,4) that cannot be more than 65535 too. */
/* ---------------------------------------------------------------------- */
if (debug) {
msDebug("WARNING in msSHPDiskTreeOpen(): %s is in old index format "
"which has been deprecated. It is strongly recommended to "
"regenerate it in new format.\n", pszTree);
}
if((pabyBuf[4] == 0 && pabyBuf[5] == 0 &&
pabyBuf[6] == 0 && pabyBuf[7] == 0)) {
psTree->LSB_order = !(pabyBuf[0] == 0 && pabyBuf[1] == 0);
} else {
psTree->LSB_order = !(pabyBuf[4] == 0 && pabyBuf[5] == 0);
}
psTree->needswap = ((psTree->LSB_order) != (!bBigEndian));
/* ---------------------------------------------------------------------- */
/* poor hack to see if this quadtree was created by a computer with a */
/* different Endian */
/* ---------------------------------------------------------------------- */
psTree->version = 0;
} else {
psTree->needswap = (( pabyBuf[3] == MS_NEW_MSB_ORDER ) ^ ( bBigEndian ));
psTree->LSB_order = ( pabyBuf[3] == MS_NEW_LSB_ORDER );
memcpy( &psTree->version, pabyBuf+4, 1 );
memcpy( &psTree->flags, pabyBuf+5, 3 );
zzip_fread( pabyBuf, 8, 1, psTree->fp );
}
if( psTree->needswap ) SwapWord( 4, pabyBuf );
memcpy( &psTree->nShapes, pabyBuf, 4 );
if( psTree->needswap ) SwapWord( 4, pabyBuf+4 );
memcpy( &psTree->nDepth, pabyBuf+4, 4 );
return( psTree );
}
/**
* \brief Fetch a document from an url and return in a string.
*
* @param pszURL valid URL recognized by underlying download library (libcurl)
* @param papszOptions option list as a NULL-terminated array of strings. May be NULL.
* The following options are handled :
* <ul>
* <li>TIMEOUT=val, where val is in seconds. This is the maximum delay for the whole
* request to complete before being aborted.</li>
* <li>LOW_SPEED_TIME=val, where val is in seconds. This is the maximum time where the
* transfer speed should be below the LOW_SPEED_LIMIT (if not specified 1b/s),
* before the transfer to be considered too slow and aborted. (GDAL >= 2.1)</li>
* <li>LOW_SPEED_LIMIT=val, where val is in bytes/second. See LOW_SPEED_TIME. Has only
* effect if LOW_SPEED_TIME is specified too. (GDAL >= 2.1)</li>
* <li>HEADERS=val, where val is an extra header to use when getting a web page.
* For example "Accept: application/x-ogcwkt"
* <li>HTTPAUTH=[BASIC/NTLM/GSSNEGOTIATE/ANY] to specify an authentication scheme to use.
* <li>USERPWD=userid:password to specify a user and password for authentication
* <li>POSTFIELDS=val, where val is a nul-terminated string to be passed to the server
* with a POST request.
* <li>PROXY=val, to make requests go through a proxy server, where val is of the
* form proxy.server.com:port_number
* <li>PROXYUSERPWD=val, where val is of the form username:password
* <li>PROXYAUTH=[BASIC/NTLM/DIGEST/ANY] to specify an proxy authentication scheme to use.
* <li>NETRC=[YES/NO] to enable or disable use of $HOME/.netrc, default YES.
* <li>CUSTOMREQUEST=val, where val is GET, PUT, POST, DELETE, etc.. (GDAL >= 1.9.0)
* <li>COOKIE=val, where val is formatted as COOKIE1=VALUE1; COOKIE2=VALUE2; ...
* <li>MAX_RETRY=val, where val is the maximum number of retry attempts if a 503 or
* 504 HTTP error occurs. Default is 0. (GDAL >= 2.0)
* <li>RETRY_DELAY=val, where val is the number of seconds between retry attempts.
* Default is 30. (GDAL >= 2.0)
* </ul>
*
* Alternatively, if not defined in the papszOptions arguments, the TIMEOUT,
* LOW_SPEED_TIME, LOW_SPEED_LIMIT, PROXY, PROXYUSERPWD, PROXYAUTH, NETRC,
* MAX_RETRY and RETRY_DELAY values are searched in the configuration
* options named GDAL_HTTP_TIMEOUT, GDAL_HTTP_LOW_SPEED_TIME, GDAL_HTTP_LOW_SPEED_LIMIT,
* GDAL_HTTP_PROXY, GDAL_HTTP_PROXYUSERPWD, GDAL_PROXY_AUTH,
* GDAL_HTTP_NETRC, GDAL_HTTP_MAX_RETRY and GDAL_HTTP_RETRY_DELAY.
*
* @return a CPLHTTPResult* structure that must be freed by
* CPLHTTPDestroyResult(), or NULL if libcurl support is disabled
*/
CPLHTTPResult *CPLHTTPFetch( const char *pszURL, char **papszOptions )
{
if( strncmp(pszURL, "/vsimem/", strlen("/vsimem/")) == 0 &&
/* Disabled by default for potential security issues */
CSLTestBoolean(CPLGetConfigOption("CPL_CURL_ENABLE_VSIMEM", "FALSE")) )
{
CPLString osURL(pszURL);
const char* pszCustomRequest = CSLFetchNameValue( papszOptions, "CUSTOMREQUEST" );
if( pszCustomRequest != NULL )
{
osURL += "&CUSTOMREQUEST=";
osURL += pszCustomRequest;
}
const char* pszPost = CSLFetchNameValue( papszOptions, "POSTFIELDS" );
if( pszPost != NULL ) /* Hack: we append post content to filename */
{
osURL += "&POSTFIELDS=";
osURL += pszPost;
}
vsi_l_offset nLength = 0;
CPLHTTPResult* psResult = (CPLHTTPResult* )CPLCalloc(1, sizeof(CPLHTTPResult));
GByte* pabyData = VSIGetMemFileBuffer( osURL, &nLength, FALSE );
if( pabyData == NULL )
{
CPLDebug("HTTP", "Cannot find %s", osURL.c_str());
psResult->nStatus = 1;
psResult->pszErrBuf = CPLStrdup(CPLSPrintf("HTTP error code : %d", 404));
CPLError( CE_Failure, CPLE_AppDefined, "%s", psResult->pszErrBuf );
}
else if( nLength != 0 )
{
psResult->nDataLen = (size_t)nLength;
psResult->pabyData = (GByte*) CPLMalloc((size_t)nLength + 1);
memcpy(psResult->pabyData, pabyData, (size_t)nLength);
psResult->pabyData[(size_t)nLength] = 0;
}
if( psResult->pabyData != NULL &&
strncmp((const char*)psResult->pabyData, "Content-Type: ",
strlen("Content-Type: ")) == 0 )
{
const char* pszContentType = (const char*)psResult->pabyData + strlen("Content-type: ");
const char* pszEOL = strchr(pszContentType, '\r');
if( pszEOL )
pszEOL = strchr(pszContentType, '\n');
if( pszEOL )
{
int nLength = pszEOL - pszContentType;
psResult->pszContentType = (char*)CPLMalloc(nLength + 1);
memcpy(psResult->pszContentType, pszContentType, nLength);
psResult->pszContentType[nLength] = 0;
}
}
return psResult;
}
#ifndef HAVE_CURL
(void) papszOptions;
(void) pszURL;
CPLError( CE_Failure, CPLE_NotSupported,
"GDAL/OGR not compiled with libcurl support, remote requests not supported." );
return NULL;
#else
/* -------------------------------------------------------------------- */
/* Are we using a persistent named session? If so, search for */
/* or create it. */
/* */
/* Currently this code does not attempt to protect against */
/* multiple threads asking for the same named session. If that */
/* occurs it will be in use in multiple threads at once which */
/* might have bad consequences depending on what guarantees */
/* libcurl gives - which I have not investigated. */
/* -------------------------------------------------------------------- */
CURL *http_handle = NULL;
const char *pszPersistent = CSLFetchNameValue( papszOptions, "PERSISTENT" );
const char *pszClosePersistent = CSLFetchNameValue( papszOptions, "CLOSE_PERSISTENT" );
if (pszPersistent)
{
CPLString osSessionName = pszPersistent;
CPLMutexHolder oHolder( &hSessionMapMutex );
if( poSessionMap == NULL )
poSessionMap = new std::map<CPLString,CURL*>;
if( poSessionMap->count( osSessionName ) == 0 )
{
(*poSessionMap)[osSessionName] = curl_easy_init();
CPLDebug( "HTTP", "Establish persistent session named '%s'.",
osSessionName.c_str() );
}
http_handle = (*poSessionMap)[osSessionName];
}
/* -------------------------------------------------------------------- */
/* Are we requested to close a persistent named session? */
/* -------------------------------------------------------------------- */
else if (pszClosePersistent)
{
CPLString osSessionName = pszClosePersistent;
CPLMutexHolder oHolder( &hSessionMapMutex );
if( poSessionMap )
{
std::map<CPLString,CURL*>::iterator oIter = poSessionMap->find( osSessionName );
if( oIter != poSessionMap->end() )
{
curl_easy_cleanup(oIter->second);
poSessionMap->erase(oIter);
if( poSessionMap->size() == 0 )
{
delete poSessionMap;
poSessionMap = NULL;
}
CPLDebug( "HTTP", "Ended persistent session named '%s'.",
osSessionName.c_str() );
}
else
{
CPLDebug( "HTTP", "Could not find persistent session named '%s'.",
osSessionName.c_str() );
}
}
return NULL;
}
else
http_handle = curl_easy_init();
/* -------------------------------------------------------------------- */
/* Setup the request. */
/* -------------------------------------------------------------------- */
char szCurlErrBuf[CURL_ERROR_SIZE+1];
CPLHTTPResult *psResult;
struct curl_slist *headers=NULL;
const char* pszArobase = strchr(pszURL, '@');
const char* pszSlash = strchr(pszURL, '/');
const char* pszColon = (pszSlash) ? strchr(pszSlash, ':') : NULL;
if (pszArobase != NULL && pszColon != NULL && pszArobase - pszColon > 0)
{
/* http://user:[email protected] */
char* pszSanitizedURL = CPLStrdup(pszURL);
pszSanitizedURL[pszColon-pszURL] = 0;
CPLDebug( "HTTP", "Fetch(%s:#password#%s)", pszSanitizedURL, pszArobase );
CPLFree(pszSanitizedURL);
}
else
{
CPLDebug( "HTTP", "Fetch(%s)", pszURL );
}
psResult = (CPLHTTPResult *) CPLCalloc(1,sizeof(CPLHTTPResult));
curl_easy_setopt(http_handle, CURLOPT_URL, pszURL );
CPLHTTPSetOptions(http_handle, papszOptions);
// turn off SSL verification, accept all servers with ssl
curl_easy_setopt(http_handle, CURLOPT_SSL_VERIFYPEER, FALSE);
/* Set Headers.*/
const char *pszHeaders = CSLFetchNameValue( papszOptions, "HEADERS" );
if( pszHeaders != NULL ) {
CPLDebug ("HTTP", "These HTTP headers were set: %s", pszHeaders);
headers = curl_slist_append(headers, pszHeaders);
curl_easy_setopt(http_handle, CURLOPT_HTTPHEADER, headers);
}
// are we making a head request
const char* pszNoBody = NULL;
if ((pszNoBody = CSLFetchNameValue( papszOptions, "NO_BODY" )) != NULL)
{
if (CSLTestBoolean(pszNoBody))
{
CPLDebug ("HTTP", "HEAD Request: %s", pszURL);
curl_easy_setopt(http_handle, CURLOPT_NOBODY, 1L);
}
}
// capture response headers
curl_easy_setopt(http_handle, CURLOPT_HEADERDATA, psResult);
curl_easy_setopt(http_handle, CURLOPT_HEADERFUNCTION, CPLHdrWriteFct);
curl_easy_setopt(http_handle, CURLOPT_WRITEDATA, psResult );
curl_easy_setopt(http_handle, CURLOPT_WRITEFUNCTION, CPLWriteFct );
szCurlErrBuf[0] = '\0';
curl_easy_setopt(http_handle, CURLOPT_ERRORBUFFER, szCurlErrBuf );
static bool bHasCheckVersion = false;
static bool bSupportGZip = false;
if (!bHasCheckVersion)
{
bSupportGZip = strstr(curl_version(), "zlib/") != NULL;
bHasCheckVersion = true;
}
int bGZipRequested = false;
if (bSupportGZip && CSLTestBoolean(CPLGetConfigOption("CPL_CURL_GZIP", "YES")))
{
bGZipRequested = true;
curl_easy_setopt(http_handle, CURLOPT_ENCODING, "gzip");
}
/* -------------------------------------------------------------------- */
/* If 502, 503 or 504 status code retry this HTTP call until max */
/* retry has been rearched */
/* -------------------------------------------------------------------- */
const char *pszRetryDelay = CSLFetchNameValue( papszOptions, "RETRY_DELAY" );
if( pszRetryDelay == NULL )
pszRetryDelay = CPLGetConfigOption( "GDAL_HTTP_RETRY_DELAY", "30" );
const char *pszMaxRetries = CSLFetchNameValue( papszOptions, "MAX_RETRY" );
if( pszMaxRetries == NULL )
pszMaxRetries = CPLGetConfigOption( "GDAL_HTTP_MAX_RETRY", "0" );
int nRetryDelaySecs = atoi(pszRetryDelay);
int nMaxRetries = atoi(pszMaxRetries);
int nRetryCount = 0;
bool bRequestRetry;
do
{
bRequestRetry = false;
/* -------------------------------------------------------------------- */
/* Execute the request, waiting for results. */
/* -------------------------------------------------------------------- */
psResult->nStatus = (int) curl_easy_perform( http_handle );
/* -------------------------------------------------------------------- */
/* Fetch content-type if possible. */
/* -------------------------------------------------------------------- */
psResult->pszContentType = NULL;
curl_easy_getinfo( http_handle, CURLINFO_CONTENT_TYPE,
&(psResult->pszContentType) );
if( psResult->pszContentType != NULL )
psResult->pszContentType = CPLStrdup(psResult->pszContentType);
/* -------------------------------------------------------------------- */
/* Have we encountered some sort of error? */
/* -------------------------------------------------------------------- */
if( strlen(szCurlErrBuf) > 0 )
{
bool bSkipError = false;
/* Some servers such as http://115.113.193.14/cgi-bin/world/qgis_mapserv.fcgi?VERSION=1.1.1&SERVICE=WMS&REQUEST=GetCapabilities */
/* invalidly return Content-Length as the uncompressed size, with makes curl to wait for more data */
/* and time-out finally. If we got the expected data size, then we don't emit an error */
/* but turn off GZip requests */
if (bGZipRequested &&
strstr(szCurlErrBuf, "transfer closed with") &&
strstr(szCurlErrBuf, "bytes remaining to read"))
{
const char* pszContentLength =
CSLFetchNameValue(psResult->papszHeaders, "Content-Length");
if (pszContentLength && psResult->nDataLen != 0 &&
atoi(pszContentLength) == psResult->nDataLen)
{
const char* pszCurlGZIPOption = CPLGetConfigOption("CPL_CURL_GZIP", NULL);
if (pszCurlGZIPOption == NULL)
{
CPLSetConfigOption("CPL_CURL_GZIP", "NO");
CPLDebug("HTTP", "Disabling CPL_CURL_GZIP, because %s doesn't support it properly",
pszURL);
}
psResult->nStatus = 0;
bSkipError = true;
}
}
if (!bSkipError)
{
psResult->pszErrBuf = CPLStrdup(szCurlErrBuf);
CPLError( CE_Failure, CPLE_AppDefined,
"%s", szCurlErrBuf );
}
}
else
{
/* HTTP errors do not trigger curl errors. But we need to */
/* propagate them to the caller though */
long response_code = 0;
curl_easy_getinfo(http_handle, CURLINFO_RESPONSE_CODE, &response_code);
if (response_code >= 400 && response_code < 600)
{
/* If HTTP 502, 503 or 504 gateway timeout error retry after a pause */
if ((response_code >= 502 && response_code <= 504) && nRetryCount < nMaxRetries)
{
CPLError(CE_Warning, CPLE_AppDefined,
"HTTP error code: %d - %s. Retrying again in %d secs",
(int)response_code, pszURL, nRetryDelaySecs);
CPLSleep(nRetryDelaySecs);
nRetryCount++;
CPLFree(psResult->pszContentType);
psResult->pszContentType = NULL;
CSLDestroy(psResult->papszHeaders);
psResult->papszHeaders = NULL;
CPLFree(psResult->pabyData);
psResult->pabyData = NULL;
psResult->nDataLen = 0;
psResult->nDataAlloc = 0;
bRequestRetry = true;
}
else
{
psResult->pszErrBuf = CPLStrdup(CPLSPrintf("HTTP error code : %d", (int)response_code));
CPLError( CE_Failure, CPLE_AppDefined, "%s", psResult->pszErrBuf );
}
}
}
}
while (bRequestRetry);
if (!pszPersistent)
curl_easy_cleanup( http_handle );
curl_slist_free_all(headers);
return psResult;
#endif /* def HAVE_CURL */
}
static inline int oma_match_external_list_condition(xmlNodePtr condition, subs_t *subs, str *w_uri)
{
int found = 0;
str anchor, uri;
str *normalized_uri;
struct sip_uri sip_uri;
xcap_uri_t anchor_uri;
xmlNodePtr entry_node = NULL;
xmlNodePtr rl_node = NULL, rl_entry = NULL;
xmlDocPtr rl_doc = NULL;
if(!integrated_xcap_server)
{
LM_ERR("<external-list> is not supported in non integrated mode\n");
return 0;
}
if(parse_uri(subs->pres_uri.s, subs->pres_uri.len, &sip_uri) < 0)
{
LM_ERR("failed to parse uri\n");
return 0;
}
for(entry_node = condition->children; entry_node; entry_node = entry_node->next)
{
if(xmlStrcasecmp(entry_node->name, (unsigned char*)"entry") != 0)
continue;
rl_node = NULL;
rl_doc = NULL;
anchor.s = NULL;
uri.s = NULL;
anchor.s = xmlNodeGetAttrContentByName(entry_node, "anc");
if(anchor.s == NULL)
{
LM_ERR("cannot get external-list entry anchor\n");
continue;
}
anchor.len = strlen(anchor.s);
if(xcapParseUri(&anchor, &anchor_uri) != 0)
{
LM_ERR("unable to parse URI for external-list entry anchor\n");
xmlFree(anchor.s);
continue;
}
xmlFree(anchor.s);
/* TODO: validate XUI? */
if(get_resource_list(&sip_uri.user, &sip_uri.host, &anchor_uri.filename, &anchor_uri.selector, &rl_node, &rl_doc) < 0)
{
LM_ERR("error getting resource-list list pointed by external list anchor\n");
continue;
}
for(rl_entry = rl_node->children; rl_entry; rl_entry = rl_entry->next)
{
if(xmlStrcasecmp(rl_entry->name, (unsigned char*)"entry") != 0)
continue;
uri.s = xmlNodeGetAttrContentByName(rl_entry, "uri");
if(uri.s == NULL)
{
LM_ERR("when extracting entry uri attribute\n");
continue;
}
uri.len = strlen(uri.s);
normalized_uri = normalizeSipUri(&uri);
if (normalized_uri->s == NULL || normalized_uri->len == 0)
{
LM_ERR("normalizing URI\n");
xmlFree(uri.s);
continue;
}
xmlFree(uri.s);
if (normalized_uri->len == w_uri->len && strncmp(normalized_uri->s, w_uri->s, w_uri->len) == 0)
{
found = 1;
break;
}
}
xmlFreeDoc(rl_doc);
if (found)
break;
}
return found;
}
/**
* Parse the zoneinfo file structure (see tzfile.h) into a ZoneInfo
*/
static ZoneInfo*
zone_info_parser(unsigned char **input, gboolean is64bitData, gint *version)
{
gint32 i = 0;
unsigned char *buf = NULL;
ZoneInfo *info = NULL;
gint64 *transition_times = NULL;
guint8 *transition_types = NULL;
gint32 *gmt_offsets = NULL;
gint64 isgmtcnt, isdstcnt, leapcnt, timecnt, typecnt, charcnt;
gboolean insertInitial = FALSE;
buf = *input;
*input += 4;
if (strncmp((gchar*)buf, TZ_MAGIC, 4) != 0)
{
msg_error("Error while processing the time zone file",
evt_tag_str("message", TZ_MAGIC" signature is missing"),
NULL);
goto error;
}
/* read the version byte */
buf = *input;
*input += 1;
/*
* if '\0', we have just one copy of data,
* if '2', there is additional 64 bit version at the end.
*/
if (buf[0] != 0 && buf[0] != '2' && buf[0] != '3')
{
msg_error("Error in the time zone file",
evt_tag_str("message", "Bad Olson version info"),
NULL);
goto error;
}
else
{
if (buf[0] != 0)
*version = buf[0] - '0';
else
*version = 0;
}
/* Read reserved bytes */
*input += 15;
/* Read array sizes */
isgmtcnt = readcoded32(input, 0, G_MAXINT64);
isdstcnt = readcoded32(input, 0, G_MAXINT64);
leapcnt = readcoded32(input, 0, G_MAXINT64);
timecnt = readcoded32(input, 0, G_MAXINT64);
typecnt = readcoded32(input, 0, G_MAXINT64);
charcnt = readcoded32(input, 0, G_MAXINT64);
/*
* Confirm sizes that we assume to be equal. These assumptions
* are drawn from a reading of the zic source (2003a), so they
* should hold unless the zic source changes.
*/
if (isgmtcnt != typecnt ||
isdstcnt != typecnt)
{
msg_warning("Error in the time zone file",
evt_tag_str("message", "Count mismatch between tzh_ttisgmtcnt, tzh_ttisdstcnt, tth_typecnt"),
NULL);
}
/*
* Used temporarily to store transition times and types. We need
* to do this because the times and types are stored in two
* separate arrays.
*/
transition_times = g_new0(gint64, timecnt);
transition_types = g_new0(guint8, timecnt);
gmt_offsets = g_new0(gint32, typecnt);
/* Read transition times */
for (i = 0; i < timecnt; ++i)
{
if (is64bitData)
{
transition_times[i] = readcoded64(input, G_MININT64, G_MAXINT64);
}
else
{
transition_times[i] = readcoded32(input, G_MININT64, G_MAXINT64);
}
}
/* Read transition types */
for (i = 0; i < timecnt; ++i)
{
guint8 t = (guint8)readchar(input);
if (t >= typecnt)
{
msg_warning("Error in the time zone file",
evt_tag_str("message", "Illegal type number"),
evt_tag_printf("val", "%ld", (long) t),
evt_tag_printf("expected", "[0, %" G_GINT64_FORMAT "]", typecnt-1),
NULL);
goto error;
}
transition_types[i] = t;
}
/* Read types (except for the isstd and isgmt flags, which come later (why??)) */
for (i = 0; i<typecnt; ++i)
{
gint offs = 24;
if (*version == 3)
offs = 167;
gmt_offsets[i] = readcoded32(input, G_MININT64, G_MAXINT64);
if (gmt_offsets[i] > offs * 60 * 60 || gmt_offsets[i] < -1 * offs * 60 * 60)
{
msg_warning("Error in the time zone file",
evt_tag_str("message", "Illegal gmtoffset number"),
evt_tag_int("val", gmt_offsets[i]),
evt_tag_printf("expected", "[%d, %d]", -1 * offs * 60 * 60, offs * 60 * 60),
NULL);
goto error;
}
/* ignore isdst flag */
readbool(input);
/* ignore abbr index */
readchar(input);
}
/* allocate a new ZoneInfo structure */
if (typecnt > 0 && timecnt == 0)
{
/* only one type info is in the time zone file so add it with 1901 */
info = zone_info_new(1);
info->transitions[0].time = LOWEST_TIME32;
info->transitions[0].gmtoffset = gmt_offsets[0];
}
else
{
info = zone_info_new(timecnt);
}
/* Build transitions vector out of corresponding times and types. */
insertInitial = FALSE;
if (is64bitData)
{
if (timecnt > 0)
{
gint32 minidx = -1;
gint32 last_transition_index = 0;
for (i = 0; i < timecnt; ++i)
{
if (transition_times[i] < LOWEST_TIME32)
{
if (minidx == -1 || transition_times[i] > transition_times[minidx])
{
/* Preserve the latest transition before the 32bit minimum time */
minidx = i;
}
}
else
{
info->transitions[last_transition_index].time = transition_times[i];
info->transitions[last_transition_index].gmtoffset = gmt_offsets[transition_types[i]];
last_transition_index++;
}
}
if (minidx != -1)
{
/*
* If there are any transitions before the 32bit minimum time,
* put the type information with the 32bit minimum time
*/
memmove(&info->transitions[1], &info->transitions[0], sizeof(Transition) * (timecnt-1));
info->transitions[0].time = LOWEST_TIME32;
info->transitions[0].gmtoffset = gmt_offsets[transition_types[minidx]];
info->timecnt -= minidx;
}
else
{
/* Otherwise, we need insert the initial type later */
insertInitial = TRUE;
}
}
}
else
{
for (i = 0; i < timecnt; ++i)
{
info->transitions[i].time = transition_times[i];
info->transitions[i].gmtoffset = gmt_offsets[transition_types[i]];
}
}
if (insertInitial)
{
g_assert(timecnt > 0);
g_assert(typecnt > 0);
/* reallocate the transitions vector to be able to store a new entry */
info->timecnt ++;
timecnt ++;
info->transitions = g_renew(Transition, info->transitions, timecnt);
/* Add the initial type associated with the lowest int32 time */
memmove(&info->transitions[1], &info->transitions[0], sizeof(Transition) * (timecnt-1));
info->transitions[0].time = LOWEST_TIME32;
info->transitions[0].gmtoffset = gmt_offsets[0];
}
/* ignore the abbreviation string */
if (charcnt)
*input += charcnt;
/* ignore leap second info, if any */
for (i=0; i<leapcnt; ++i)
{
if(is64bitData)
readcoded64(input, G_MININT64, G_MAXINT64);/* leap second transition time */
else
readcoded32(input, G_MININT64, G_MAXINT64);/* leap second transition time */
readcoded32(input, G_MININT64, G_MAXINT64);/* total correction after above */
}
/* http://osdir.com/ml/time.tz/2006-02/msg00041.html */
/* We dont nead this flags to compute the wall time of the timezone*/
/* Ignore isstd flags */
for (i=0;i<typecnt;i++)
readbool(input);
/* Ignore isgmt flags */
for (i=0;i<typecnt;i++)
readbool(input);
error:
g_free(transition_times);
g_free(transition_types);
g_free(gmt_offsets);
*version = 0;
return info;
}
static int strrcmp_i(char *s,char *cmp){
return(strncmp(s+strlen(s)-strlen(cmp),cmp,strlen(cmp)));
}
static void
pick_unichar (ModeInfo *mi)
{
unicrud_configuration *bp = &bps[MI_SCREEN(mi)];
int i;
unsigned long min = 0;
unsigned long max = 0x2F800;
unsigned long last = 0;
int retries = 0;
AGAIN:
bp->unichar = min + (random() % (max - min));
if (++retries > 0xF0000 / 2)
{
fprintf (stderr, "%s: internal error: too many retries\n", progname);
exit (1);
}
/* bp->unichar = 0x1F4A9; */
last = 0;
bp->charplane = "Unassigned";
bp->charblock = "Unassigned";
for (i = 0; i < countof(unicode_block_names); i++)
{
if (unicode_block_names[i].start < last)
{
fprintf (stderr, "%s: progname: internal error: misordered: 0x%lX\n",
progname, unicode_block_names[i].start);
exit (1);
}
last = unicode_block_names[i].start;
if (bp->unichar >= unicode_block_names[i].start)
{
if (unicode_block_names[i].name[0] == '*')
{
bp->charplane = unicode_block_names[i].name + 1;
bp->charblock = "Unassigned";
}
else
bp->charblock = unicode_block_names[i].name;
}
else
break;
}
if (!strncmp (bp->charblock, "Unassigned", 10) ||
!strncmp (bp->charblock, "Combining", 9))
goto AGAIN;
if (*do_block && !matches (do_block, bp->charblock))
goto AGAIN;
/* Skip blank characters */
{
XCharStruct e;
char text[10];
i = utf8_encode (bp->unichar, text, sizeof(text) - 1);
text[i] = 0;
texture_string_metrics (bp->char_font, text, &e, 0, 0);
if (e.width < 2 || e.ascent + e.descent < 2)
goto AGAIN;
}
# ifdef HAVE_JWXYZ
bp->charname = texfont_unicode_character_name (bp->char_font, bp->unichar);
# endif
bp->color[0] = 0.5 + frand(0.5);
bp->color[1] = 0.5 + frand(0.5);
bp->color[2] = 0.5 + frand(0.5);
bp->color[3] = 1;
}
int main(int argc, char *argv[])
{
srand(time(NULL));
bool giveme = false;
long zero = 0;
char buf[100];
bool gotflag = false;
puts("Welcome to hell, we have real strong JumpFu here");
start:
DBUG("start")
puts("Where to?");
fflush(0);
zero = 0;
fgets(buf, 117, stdin);
buf[99] = 0;
if (strncmp(buf+10, "WHO GOES THERE", strlen("WHO GOES THERE")) == 10)
goto six;
else
goto two;
one:
DBUG("one")
puts("WELCOME BACK");
goto start;
two:
DBUG("two")
puts("Who are you? Where are you even going?");
fflush(0);
if (buf[69]=='8')
goto eleven;
if (buf[69]=='9')
goto five;
goto one;
three:
DBUG("three")
puts("Here we go again...");
fflush(0);
goto eight;
four:
DBUG("four")
if (!zero)
goto nine;
five:
DBUG("five")
giveme = true;
if (!zero)
goto eight;
six:
DBUG("six")
giveme = false;
seven: //lucky number seven
DBUG("seven")
if (giveme){
gotflag = true;
print_flag();
goto end;
}else{
puts("NO!!! GO AWAY");
fflush(0);
}
eight:
DBUG("eight")
puts("Goodnight! See you later!");
fflush(0);
sleep(1);
if (rand() % 2)
goto one;
else
goto twelve;
nine:
DBUG("nine")
goto two;
ten:
DBUG("ten")
if (!zero)
goto end;
goto one;
eleven:
DBUG("eleven")
if (strncmp(&zero, "risky!", strlen("risky")))
goto eight;
goto six;
twelve:
DBUG("twelve")
if (zero)
goto seven;
else
goto ten;
end:
DBUG("end")
if (!gotflag)
puts("Looks like you are leavin here empty handed.");
else
puts("Nice work. You won.");
fflush(0);
return 0;
}
int main(int argc, char** argv) {
int c, i;
char *inject_cmd = NULL;
char *domain = NULL;
char *rekall_profile = NULL;
char *dump_folder = NULL;
vmi_pid_t injection_pid = -1;
struct sigaction act;
int timeout = 0;
GThread *timeout_thread = NULL;
output_format_t output = OUTPUT_DEFAULT;
fprintf(stderr, "%s v%s\n", PACKAGE_NAME, PACKAGE_VERSION);
if ( __DRAKVUF_PLUGIN_LIST_MAX == 0 ) {
fprintf(stderr, "No plugins have been enabled, nothing to do!\n");
return 1;
}
if (argc < 4) {
fprintf(stderr, "Required input:\n"
"\t -r <rekall profile> The Rekall profile of the Windows kernel\n"
"\t -d <domain ID or name> The domain's ID or name\n"
"Optional inputs:\n"
"\t -i <injection pid> The PID of the process to hijack for injection\n"
"\t -e <inject_exe> The executable to start with injection\n"
"\t -t <timeout> Timeout (in seconds)\n"
"\t -D <file dump folder> Folder where extracted files should be stored at\n"
"\t -o <format> Output format (default or csv)\n"
"\t -v Turn on verbose (debug) output\n"
);
return 1;
}
while ((c = getopt (argc, argv, "r:d:i:e:t:D:o:v")) != -1)
switch (c)
{
case 'r':
rekall_profile = optarg;
break;
case 'd':
domain = optarg;
break;
case 'i':
injection_pid = atoi(optarg);
break;
case 'e':
inject_cmd = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'D':
dump_folder = optarg;
break;
case 'o':
if(!strncmp(optarg,"csv",3))
output = OUTPUT_CSV;
break;
case 'v':
// verbose = 1;
break;
default:
fprintf(stderr, "Unrecognized option: %c\n", c);
return 1;
}
interrupted = 0;
if (!drakvuf_init(&drakvuf, domain, rekall_profile))
return 1;
if(output != OUTPUT_DEFAULT)
drakvuf_set_output_format(drakvuf, output);
if(timeout > 0) {
timeout_thread = g_thread_new(NULL, timer, &timeout);
}
drakvuf_pause(drakvuf);
if (injection_pid > 0 && inject_cmd) {
int rc = drakvuf_inject_cmd(drakvuf, injection_pid, inject_cmd);
if (!rc) {
fprintf(stderr, "Process startup failed\n");
goto exit;
}
}
/*
* Pass the configuration input to the plugins.
* Default config is only the rekall profile but plugins
* can define additional options which need to be passed
* through their own config structure.
*/
for(i=0;i<__DRAKVUF_PLUGIN_LIST_MAX;i++) {
switch (i) {
case PLUGIN_FILEDELETE:
{
struct filedelete_config c = {
.rekall_profile = rekall_profile,
.dump_folder = dump_folder
};
if ( !drakvuf_plugin_init(drakvuf, i, &c) )
goto exit;
break;
}
default:
if ( !drakvuf_plugin_init(drakvuf, i, rekall_profile) )
goto exit;
break;
};
}
/* for a clean exit */
act.sa_handler = close_handler;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGHUP, &act, NULL);
sigaction(SIGTERM, &act, NULL);
sigaction(SIGINT, &act, NULL);
sigaction(SIGALRM, &act, NULL);
if ( drakvuf_plugins_start(drakvuf) )
drakvuf_loop(drakvuf);
exit:
drakvuf_pause(drakvuf);
drakvuf_plugins_close(drakvuf);
drakvuf_close(drakvuf);
if(timeout_thread)
g_thread_join(timeout_thread);
return 0;
}
KS_RESULT LoadDupl(KscServerBase* Server, PltString &ImpString)
/*****************************************************************************/
{
/*
* Variablen
*/
int exit_status;
size_t i,j; // Laufvariablen
char path[32]; // Hilfsstring
InstanceItems* pinst;
LinksItems* pLinks;
PltString VerbName; // Name der Verbindung
PltString NewName; // Neuen Name der Verbindung
PltString Assoc; // Assoziations-Identifier
yydebug = 0;
current_line = 0;
size_t Count; // Merker : Anzahl der Verbindungen
KS_RESULT err; // Ergebnis des Dienstes
struct yy_buffer_state* buf;
/*
* check option settings
*/
if(!Server)
return KS_ERR_SERVERUNKNOWN;
if(!ImpString.len() ) {
return KS_ERR_OK;
}
ppar = (Dienst_param*)malloc(sizeof(Dienst_param));
if(!ppar) {
return OV_ERR_HEAPOUTOFMEMORY;
}
ppar->Instance = 0;
ppar->Set_Inst_Var = 0;
ppar->DelInst = 0;
ppar->OldLibs = 0;
ppar->NewLibs = 0;
ppar->Links = 0;
ppar->UnLinks = 0;
/*
* Eingabe parsen
*/
buf = yy_scan_string( (char*)(const char*)ImpString );
exit_status = yyparse();
yy_delete_buffer( buf );
/* String geparst ? */
if(exit_status != EXIT_SUCCESS) {
memfre(ppar);
free(ppar);
fb_parser_freestrings();
return KS_ERR_BADPARAM;
}
///////////////////////////////////////////////////////////////////////////////
// Es muessen Namen der Verbindungen geaendert werden //
///////////////////////////////////////////////////////////////////////////////
sprintf(path, "/%s/",FB_CONN_CONTAINER);
/* Anzahl der Verbindungen ermitteln */
pinst = ppar->Instance;
Count = 0;
while(pinst) {
if( !strncmp(pinst->Inst_name, path, 4) ) {
// Verbindung gefunden
Count++;
}
pinst = pinst->next;
}
PltArray<char*> Verbindung(Count);
if(Verbindung.size() != Count) {
// Out of memory ?
err = OV_ERR_HEAPOUTOFMEMORY;
goto EXIT_FNC;
}
// Array initialisieren
for(j = 0; j < Count; j++) {
Verbindung[j] = 0;
}
// Gibt es Verbindungen ?
if(Count) {
// Dann erzeugen wir neuen Name fuer Verbindungs-Objekt.
GenerateComConName(Assoc); // Neuen Name der Verbindung erzeugen
NewName = path;
NewName += Assoc;
/* Verbindung-Namen aendern */
pinst = ppar->Instance;
j = 0;
while(pinst) {
char* ph;
if( !strncmp(pinst->Inst_name, path, 4) ) {
// Verbindung gefunden
VerbName = pinst->Inst_name; // Name der Verbindung merken
ph = (char*)malloc(NewName.len() + 33);
if(!ph) {
// Out of memory
for(i = 0; i < j; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
err = OV_ERR_HEAPOUTOFMEMORY;
goto EXIT_FNC;
}
// Neuen Name kopieren
sprintf(ph, "%s%d", (const char*)NewName, j);
pinst->Inst_name = ph;
// String merken
Verbindung[j] = ph;
j++;
for(i = 0; i < 2; i++) {
switch(i) {
case 0:
// Link "outputcon" suchen
Assoc = "outputcon";
break;
default:
// Link "inputcon" suchen
Assoc = "inputcon";
break;
}
pLinks = ppar->Links;
while( (pLinks) ) {
if( (VerbName == pLinks->children->child_path) &&
(Assoc == pLinks->child_role) ) {
break;
}
pLinks = pLinks->next;
}
if(!pLinks) {
// Link nicht gefunden
for(i = 0; i < j; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
err = KS_ERR_BADPARAM;
goto EXIT_FNC;
}
// Neuen Name in Link-String merken
pLinks->children->child_path = ph;
} // Links suchen
} // if Verb. gefunden
pinst = pinst->next; // Naechste Instance
} // while Instanzen
} // if Verbindungen vorhanden
// Alle Verbindungen und Links umbennant.
// Instanzen anlegen :
VerbName = "";
err = import_eval(Server, ppar, VerbName);
// Neue erzeugte Strings freigeben
for(i = 0; i < Count; i++) {
if(Verbindung[i]) free(Verbindung[i]);
}
EXIT_FNC:
memfre(ppar);
free(ppar);
fb_parser_freestrings();
return err;
}
/* PROCESS_HISTORY_DIRECTIVE -- Transform a history directive into an
* executable command or command block. There are two classes of
* directives: (1) string substitution editing of the last command block,
* and (2) search for an earlier command by some means and return that.
* If ":p" follows a directive, we generate the command and return false
* (no execute) as the function value. Any text which follows the directive
* is appended to the new command block.
*/
int
process_history_directive (char *directive, char *new_command_block)
{
register char *ip, *op, *p;
char last_command_block[SZ_CMDBLK+1];
int execute=1, edit=0;
int record;
char *rindex();
ip = directive + 1; /* skip the '^' */
op = new_command_block;
/* Chop the newline. */
if ((p = rindex (ip, '\n')) != NULL)
*p = EOS;
/* Scan the directive string to determine whether or not we have
* an edit directive. We have an edit directive if there is a second
* (unescaped) history metacharacter in the directive.
*/
for (p=ip, edit=0; *p != EOS; p++)
if (*p == '\\' && *(p+1) != EOS)
p++;
else if (*p == HISTCHAR) {
edit = 1;
break;
}
/* Directives "^^", "^str1^str2^", and "^str1^str2^g". */
if (edit) {
/* Get last command and edit it */
if (get_history (1, last_command_block, SZ_CMDBLK) == ERR)
cl_error (E_UERR, "Nothing in history buffer to edit");
ip = directive +
stredit (directive, last_command_block, new_command_block);
/* Directives "^absnum" and "-relnum". */
} else if ((*ip == '-' && isdigit (*(ip+1))) || isdigit (*ip)) {
if (*ip == '-')
record = -atoi(ip++);
else
record = histnum - atoi(ip) + 1;
if (get_history (record, new_command_block, SZ_CMDBLK) == ERR)
cl_error (E_UERR, "History record not found");
while (isdigit (*ip))
ip++;
/* Directives "^", "^str", and "^?str". */
} else
ip = directive + search_history (directive, new_command_block);
/* Check for the ":p" no execute suffix */
execute = (strncmp (ip, NO_EXECUTE, strlen(NO_EXECUTE)) != 0);
if (!execute)
ip += strlen (NO_EXECUTE);
/* Append any text remaining in the history directive to the new
* command block, BEFORE the final newline.
*/
op += strlen (new_command_block);
while (isspace (*(op-1)))
--op;
expand_history_macros (ip, op);
/* Make sure the new command line ends with a newline. */
while (*op != EOS)
op++;
while (isspace (*(op-1)))
--op;
*op++ = '\n';
*op = EOS;
return (execute);
}
/*
* Read a topography file and initialize Topo and TopoData.
* Input: filename - name of topo file.
* Return: 0 if error, otherwise non-zero for success.
*/
int read_topo( struct Topo *topo, char *filename )
{
int f;
int n;
char id[40];
f = open( filename, O_RDONLY );
if (f<0) {
printf("Topo file %s not found\n", filename );
return 0;
}
/* Read topo file header */
read_bytes( f, id, 40 );
read_float4( f, &(topo->Topo_westlon) );
read_float4( f, &(topo->Topo_eastlon) );
read_float4( f, &(topo->Topo_northlat) );
read_float4( f, &(topo->Topo_southlat) );
read_int4( f, &(topo->Topo_rows) );
read_int4( f, &(topo->Topo_cols) );
if (strncmp(id,"TOPO2",5)==0) {
/* OK */
}
else if (strncmp(id,"TOPO",4)==0) {
/* OLD STYLE: bounds given as ints, convert to floats */
int *p;
p = (int *) &(topo->Topo_westlon); topo->Topo_westlon = (float) *p / 100.0;
p = (int *) &(topo->Topo_eastlon); topo->Topo_eastlon = (float) *p / 100.0;
p = (int *) &(topo->Topo_northlat); topo->Topo_northlat = (float) *p / 100.0;
p = (int *) &(topo->Topo_southlat); topo->Topo_southlat = (float) *p / 100.0;
}
else {
printf("%s is not a TOPO file >%s<\n", filename,id);
close(f);
return 0;
}
if(topo->TopoData)
free(topo->TopoData);
topo->TopoData = (short *) malloc(topo->Topo_rows * topo->Topo_cols * sizeof(short));
/* dtx->TopoData = (short *) allocate( dtx, dtx->Topo_rows * dtx->Topo_cols
* sizeof(short) ); */
if (!topo->TopoData) {
printf("ERROR: Failed to allocate space for topo data\n");
close(f);
return 0;
}
n = topo->Topo_rows * topo->Topo_cols;
if (read_int2_array( f, topo->TopoData, n) < n) {
printf("ERROR: could not read data file or premature end of file\n");
free( topo->TopoData);
topo->TopoData = NULL;
close(f);
return 0;
}
close(f);
return 1;
}
/* STREDIT -- Edit string "in_text" according to the editing directive
* string given as the first argument, placing the edited string in the
* buffer "out_text". Return the number of characters used in the
* edit directive string.
* This is actually a general purpose string editor. For the history code,
* the edit directives are "^^", "^str", and "^?str". The directive "^^"
* is actually an edit directive wherein the match and substitute strings
* are both null, causing the last command to be repeated without change.
* The first character in the edit directive is taken to be the edit
* metacharacter (i.e., "^", "/", etc.).
*/
int
stredit (
char *edit_directive, /* e.g., "^str1^str2^" */
char *in_text, /* text to be edited */
char *out_text /* buffer for output text */
)
{
register char *ip, *op, *pp;
char metacharacter;
char pattern[SZ_LINE+1], text[SZ_LINE+1];
int replace_all_occurrences=0;
int patlen, len_directive, nmatches;
/* Extract pattern and substitution strings. The history metacharacter
* may be included in a string if escaped. Otherwise, we leave
* escape sequences completely alone.
*/
ip = edit_directive;
metacharacter = *ip++;
for (op=pattern; (*op = *ip) != EOS; ip++, op++)
if (*ip == '\\' && *(ip+1) == metacharacter)
*op = *++ip;
else if (*ip == metacharacter) {
ip++;
break;
}
*op = EOS;
patlen = strlen (pattern);
/* If the directive is "^^", we do not permit a substitution string
* so that the directive may be used to append text to the previous
* command. We interpret the sequences "^\n" and "^\t" as newline
* and tab, respectively.
*/
if (patlen > 0) {
for (op=text; (*op = *ip) != EOS; ip++, op++)
if ((*ip == metacharacter && *(ip+1) == '\\') &&
(*(ip+2) == 'n' || *(ip+2) == 't')) {
ip += 2;
*op = (*ip == 'n') ? '\n' : '\t';
} else if (*ip == '\\' && *(ip+1) == metacharacter) {
*op = *++ip;
} else if (*op == '\n' || *op == metacharacter) {
ip++;
break;
}
*op = EOS;
if (*ip == MATCH_ALL) {
replace_all_occurrences = 1;
ip++;
}
} else
*text = EOS;
/* All done processing edit directive; get nchars processed. */
len_directive = ip - edit_directive;
/* Edit the command, unless directive is "^^" (null pattern). */
nmatches = 0;
for (ip=in_text, op=out_text; *ip != EOS; ) {
/* Advance to next match */
for (pp=pattern; (*op = *ip) != EOS; op++, ip++)
if (*ip == *pp && strncmp (ip, pattern, patlen) == 0) {
nmatches++;
break;
}
if (patlen == 0)
break;
else if (nmatches == 0)
cl_error (E_UERR, "No match");
/* Copy replacement string, advance input pointer past the
* matched string, if we have a match.
*/
if (*ip == *pp) {
for (pp=text; (*op = *pp++) != EOS; op++)
;
ip += patlen;
}
if (!replace_all_occurrences) {
while ((*op = *ip++) != EOS)
op++;
break;
}
}
*op = EOS;
return (len_directive);
}
int
if_send_spoof_request(char *dev,
unsigned int new_ip, unsigned int r_ip,
unsigned char *remote_mac,
int count,int icmp) {
int i,ic;
struct ifreq ifr;
struct ether_header *eth;
struct arphdr *arp;
struct interface ifs[1024];
unsigned char *cp, *dest_mac;
static unsigned char buffer[60];
static unsigned char my_mac[ETH_ALEN];
static unsigned char bc_mac[ETH_ALEN] =
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
memset(&ifr, sizeof(struct ifreq), 0);
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
if (ioctl(_if_bpf, BIOCSETIF, (caddr_t)&ifr) < 0) {
perror("ioctl (BIOCSETIF)");
exit (EXIT_FAILURE);
}
ic = if_list_ips(ifs, 1024);
for(i=0; i<ic; i++) {
if(!strncmp(ifs[i].ifname, ifr.ifr_name, strlen(ifr.ifr_name)) &&
(ifs[i].mac[0] || ifs[i].mac[1] || ifs[i].mac[2] ||
ifs[i].mac[3] || ifs[i].mac[4] || ifs[i].mac[5]) ) {
memcpy(my_mac, ifs[i].mac, ETH_ALEN);
break;
}
}
memset(buffer, 0, 60);
eth = (struct ether_header *)buffer;
memcpy(eth->ether_shost, my_mac, ETH_ALEN);
memcpy(eth->ether_dhost, bc_mac, ETH_ALEN);
eth->ether_type = htons(ETH_P_ARP);
arp = (struct arphdr *)(eth+1);
arp->ar_hrd = htons(ARPHRD_ETHER);
arp->ar_pro = htons(ETH_P_IP);
arp->ar_hln = ETH_ALEN;
arp->ar_pln = 4;
arp->ar_op = htons(ARPOP_REPLY);
cp = (unsigned char *)(arp+1);
memcpy(cp, my_mac, ETH_ALEN); cp+=ETH_ALEN;
memcpy(cp, &new_ip, 4); cp+=4;
dest_mac = cp;
memcpy(cp, bc_mac, ETH_ALEN); cp+=ETH_ALEN;
memcpy(cp, &r_ip, 4); cp+=4;
for(i=0;i<count;i++)
write(_if_bpf, buffer, 60);
if(remote_mac) {
memcpy(dest_mac, remote_mac, ETH_ALEN);
memcpy(eth->ether_dhost, remote_mac, ETH_ALEN);
for(i=0;i<count;i++)
write(_if_bpf, buffer, 60);
if(icmp) {
compose_ping(buffer, my_mac, remote_mac, new_ip, r_ip);
write(_if_bpf, buffer, 42);
}
}
return i;
}
struct mi_root* pdt_mi_list(struct mi_root* cmd_tree, void* param)
{
str sd, sp, sdomain;
pdt_tree_t *pt;
struct mi_node* node = NULL;
unsigned int i= 0;
struct mi_root* rpl_tree = NULL;
struct mi_node* rpl = NULL;
static char code_buf[PDT_MAX_DEPTH+1];
int len;
str *cl;
pdt_tree_t **ptree;
ptree = pdt_get_ptree();
if(ptree==NULL)
{
LM_ERR("empty domain list\n");
return init_mi_tree( 500, MI_INTERNAL_ERR_S, MI_INTERNAL_ERR_LEN);
}
cl = pdt_get_char_list();
/* read sdomain */
sdomain.s = 0;
sdomain.len = 0;
sp.s = 0;
sp.len = 0;
sd.s = 0;
sd.len = 0;
node = cmd_tree->node.kids;
if(node != NULL)
{
sdomain = node->value;
if(sdomain.s == NULL || sdomain.len== 0)
return init_mi_tree( 404, "domain not found", 16);
if(*sdomain.s=='.')
sdomain.s = 0;
/* read prefix */
node = node->next;
if(node != NULL)
{
sp= node->value;
if(sp.s== NULL || sp.len==0 || *sp.s=='.')
sp.s = NULL;
else {
while(sp.s!=NULL && i!=sp.len)
{
if(strpos(cl->s, sp.s[i]) < 0)
{
LM_ERR("bad prefix [%.*s]\n", sp.len, sp.s);
return init_mi_tree( 400, "bad prefix", 10);
}
i++;
}
}
/* read domain */
node= node->next;
if(node != NULL)
{
sd= node->value;
if(sd.s== NULL || sd.len==0 || *sd.s=='.')
sd.s = NULL;
}
}
}
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if(rpl_tree == NULL)
return 0;
rpl = &rpl_tree->node;
if(*ptree==0)
return rpl_tree;
pt = *ptree;
while(pt!=NULL)
{
if(sdomain.s==NULL ||
(sdomain.s!=NULL && pt->sdomain.len>=sdomain.len &&
strncmp(pt->sdomain.s, sdomain.s, sdomain.len)==0))
{
len = 0;
if(pdt_print_mi_node(pt->head, rpl, code_buf, len, &pt->sdomain,
&sd, &sp)<0)
goto error;
}
pt = pt->next;
}
return rpl_tree;
error:
free_mi_tree(rpl_tree);
return 0;
}
static int __devinit dwc3_probe(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
struct resource *res;
struct dwc3 *dwc;
struct device *dev = &pdev->dev;
int ret = -ENOMEM;
void __iomem *regs;
void *mem;
u8 mode;
bool host_only_mode;
mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
if (!mem) {
dev_err(dev, "not enough memory\n");
return -ENOMEM;
}
dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
dwc->mem = mem;
if (!dev->dma_mask)
dev->dma_mask = &dwc3_dma_mask;
if (!dev->coherent_dma_mask)
dev->coherent_dma_mask = DMA_BIT_MASK(64);
dwc->notify_event = notify_event;
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(dev, "missing IRQ\n");
return -ENODEV;
}
dwc->xhci_resources[1].start = res->start;
dwc->xhci_resources[1].end = res->end;
dwc->xhci_resources[1].flags = res->flags;
dwc->xhci_resources[1].name = res->name;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(dev, "missing memory resource\n");
return -ENODEV;
}
dwc->xhci_resources[0].start = res->start;
dwc->xhci_resources[0].end = dwc->xhci_resources[0].start +
DWC3_XHCI_REGS_END;
dwc->xhci_resources[0].flags = res->flags;
dwc->xhci_resources[0].name = res->name;
/*
* Request memory region but exclude xHCI regs,
* since it will be requested by the xhci-plat driver.
*/
res = devm_request_mem_region(dev, res->start + DWC3_GLOBALS_REGS_START,
resource_size(res) - DWC3_GLOBALS_REGS_START,
dev_name(dev));
if (!res) {
dev_err(dev, "can't request mem region\n");
return -ENOMEM;
}
regs = devm_ioremap_nocache(dev, res->start, resource_size(res));
if (!regs) {
dev_err(dev, "ioremap failed\n");
return -ENOMEM;
}
spin_lock_init(&dwc->lock);
platform_set_drvdata(pdev, dwc);
dwc->regs = regs;
dwc->regs_size = resource_size(res);
dwc->dev = dev;
if (!strncmp("super", maximum_speed, 5))
dwc->maximum_speed = DWC3_DCFG_SUPERSPEED;
else if (!strncmp("high", maximum_speed, 4))
dwc->maximum_speed = DWC3_DCFG_HIGHSPEED;
else if (!strncmp("full", maximum_speed, 4))
dwc->maximum_speed = DWC3_DCFG_FULLSPEED1;
else if (!strncmp("low", maximum_speed, 3))
dwc->maximum_speed = DWC3_DCFG_LOWSPEED;
else
dwc->maximum_speed = DWC3_DCFG_SUPERSPEED;
#ifdef CONFIG_SEC_H_PROJECT
dwc->speed_limit = dwc->maximum_speed;
dwc->ss_host_avail = -1;
#endif
dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize");
host_only_mode = of_property_read_bool(node, "host-only-mode");
pm_runtime_no_callbacks(dev);
pm_runtime_set_active(dev);
pm_runtime_enable(dev);
ret = dwc3_core_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize core\n");
return ret;
}
mode = DWC3_MODE(dwc->hwparams.hwparams0);
/* Override mode if user selects host-only config with DRD core */
if (host_only_mode && (mode == DWC3_MODE_DRD)) {
dev_dbg(dev, "host only mode selected\n");
mode = DWC3_MODE_HOST;
}
switch (mode) {
case DWC3_MODE_DEVICE:
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
ret = dwc3_gadget_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize gadget\n");
goto err1;
}
break;
case DWC3_MODE_HOST:
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
ret = dwc3_host_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize host\n");
goto err1;
}
break;
case DWC3_MODE_DRD:
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
ret = dwc3_otg_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize otg\n");
goto err1;
}
ret = dwc3_host_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize host\n");
dwc3_otg_exit(dwc);
goto err1;
}
ret = dwc3_gadget_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize gadget\n");
dwc3_host_exit(dwc);
dwc3_otg_exit(dwc);
goto err1;
}
break;
default:
dev_err(dev, "Unsupported mode of operation %d\n", mode);
goto err1;
}
dwc->mode = mode;
ret = dwc3_debugfs_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize debugfs\n");
goto err2;
}
#ifdef CONFIG_SEC_H_PROJECT
WORK_INIT(dwc);
#endif
return 0;
err2:
switch (mode) {
case DWC3_MODE_DEVICE:
dwc3_gadget_exit(dwc);
break;
case DWC3_MODE_HOST:
dwc3_host_exit(dwc);
break;
case DWC3_MODE_DRD:
dwc3_gadget_exit(dwc);
dwc3_host_exit(dwc);
dwc3_otg_exit(dwc);
break;
default:
/* do nothing */
break;
}
err1:
dwc3_core_exit(dwc);
return ret;
}
int main(int argc, char **argv)
{
u_char *json_output;
dbrelay_request_t *request;
dbrelay_connection_t *connections;
pid_t pid;
char *s, *s2, *m2;
char *cmd = NULL;
int line = 0;
char prompt[20];
char *mybuf;
int bufsz = 4096;
size_t buflen = 0;
char *param0;
istty = isatty(0);
request = dbrelay_alloc_request();
strcpy(request->sql_port, "1433");
request->log_level = 0;
if (!populate_request(argc, argv, request)) {
printf("Usage: %s -u <user> -h <host> [-c <connection name>] [-d <database>] [-f <input file>] [-l <log level>] [-p <port>] [-t <tag>] [-v] [-w <password>]\n", argv[0]);
exit(1);
}
if ((connections=dbrelay_get_shmem())==NULL) {
dbrelay_create_shmem();
} else {
dbrelay_release_shmem(connections);
}
/* give the buffer an initial size */
bufsz = 4096;
mybuf = (char *) malloc(bufsz);
mybuf[0] = '\0';
buflen = 0;
if (input_file) {
slurp_input_file(input_file, &mybuf, &bufsz, &buflen, &line);
request->sql = mybuf;
json_output = (u_char *) dbrelay_db_run_query(request);
printf("%s\n", json_output);
} else
for (s=NULL, s2=NULL; ; free(s), free(s2), s2=NULL) {
sprintf(prompt, "%d> ", ++line);
s = dbrelay_readline(QUIET ? NULL : prompt);
if (s == NULL) break;
s2 = strdup(s);
if ((cmd = strtok(s2, " \t")) == NULL) cmd = "";
if (!strcasecmp(cmd, "exit") ||
!strcasecmp(cmd, "quit") ||
!strcasecmp(cmd, "bye")) {
break;
} else if (!strcasecmp(cmd, "go")) {
printf("mybuf %s\n", mybuf);
if (strlen(mybuf)>=6 && !strncmp(mybuf, "status", 6)) {
json_output = (u_char *) dbrelay_db_status(request);
} else if (strlen(mybuf)>=4 && !strncmp(mybuf, "kill", 4)) {
m2 = strdup(mybuf);
strtok(m2, " \t");
param0 = strtok(NULL, " \t\n\r");
fprintf(stderr, "killing %s\n", param0);
strcpy(request->cmd,"kill");
request->params[0] = param0;
json_output = dbrelay_db_cmd(request);
free(m2);
} else if (strlen(mybuf)>=11 && !strncmp(mybuf, "list tables", 11)) {
strcpy(request->cmd,"tables");
json_output = (u_char *) dbrelay_db_cmd(request);
} else if (strlen(mybuf)>=12 && !strncmp(mybuf, "list columns", 12)) {
m2 = strdup(mybuf);
strtok(m2, " \t");
strtok(NULL, " \t\n\r");
param0 = strtok(NULL, " \t\n\r");
strcpy(request->cmd,"columns");
request->params[0] = param0;
json_output = dbrelay_db_cmd(request);
free(m2);
} else if (strlen(mybuf)>=9 && !strncmp(mybuf, "list keys", 9)) {
m2 = strdup(mybuf);
strtok(m2, " \t");
strtok(NULL, " \t\n\r");
param0 = strtok(NULL, " \t\n\r");
strcpy(request->cmd,"pkey");
request->params[0] = param0;
json_output = dbrelay_db_cmd(request);
free(m2);
} else {
request->sql = mybuf;
json_output = (u_char *) dbrelay_db_run_query(request);
}
printf("%s\n", json_output);
line = 0;
mybuf[0] = '\0';
buflen = 0;
} else if (!strcasecmp(cmd, "reset")) {
line = 0;
mybuf[0] = '\0';
buflen = 0;
} else if (!strcasecmp(cmd, "load")) {
param0 = strtok(NULL, " \t");
fprintf(stderr, "reading %s\n", param0);
slurp_input_file(param0, &mybuf, &bufsz, &buflen, &line);
} else {
while (buflen + strlen(s) + 2 > bufsz) {
char *newbuf;
bufsz *= 2;
if ((newbuf = realloc(mybuf, bufsz)) == NULL) {
perror("dbrelay: ");
exit(1);
}
mybuf = newbuf;
}
dbrelay_add_history(s);
strcpy(mybuf + buflen, s);
/* preserve line numbering for the parser */
strcat(mybuf + buflen, "\n");
buflen += strlen(mybuf + buflen);
}
}
request->sql = NULL;
free(mybuf);
dbrelay_free_request(request);
}
/********************
** readProcCpuInfo **
*********************
** Reads and parses /proc/cpuinfo on a Linux system
** The pointers must point to pre-allocated arrays of at least BUF_SIZ
*/
static void readProcCpuInfo (char *model, char *cache) {
FILE * info;
char * cp;
int cpus = 0;
char * buffer_end;
char buffer[BUF_SIZ];
char vendor_id[BUF_SIZ];
char model_name[BUF_SIZ];
char cpu_MHz[BUF_SIZ];
int i;
float f;
vendor_id[0] = model_name[0] = cpu_MHz[0] = model[0] = cache[0] = '\0';
info = fopen("/proc/cpuinfo", "r");
if(info != NULL) {
/* command did not fail */
while(NULL != fgets(buffer, BUF_SIZ, info)){
buffer_end = buffer + strlen(buffer);
cp = buffer;
if(! strncmp(buffer, "processor", 9)) {
cpus++;
} else if(! strncmp(buffer, "vendor_id", 9)) {
cp+=strlen("vendor_id");
while(cp < buffer_end && ( *cp == ' ' || *cp == ':'|| *cp == '\t'))
cp++;
if(cp<buffer_end) {
strcpy(vendor_id, cp);
}
removeNewLine(vendor_id);
} else if(! strncmp(buffer, "model name", 10)) {
cp+=strlen("model name");
while(cp < buffer_end && ( *cp == ' ' || *cp == ':'|| *cp == '\t'))
cp++;
if(cp<buffer_end) {
strcpy(model_name, cp);
}
removeNewLine(model_name);
} else if(! strncmp(buffer, "cpu MHz", 7)) {
cp+=strlen("cpu MHz");
while(cp < buffer_end && ( *cp == ' ' || *cp == ':'|| *cp == '\t'))
cp++;
if(cp<buffer_end) {
strcpy(cpu_MHz, cp);
}
removeNewLine(cpu_MHz);
} else if(! strncmp(buffer, "cache size", 10)) {
cp+=strlen("cache size");
while(cp < buffer_end && ( *cp == ' ' || *cp == ':'|| *cp == '\t'))
cp++;
if(cp<buffer_end) {
strcpy(cache, cp);
}
removeNewLine(cache);
}
}
if(cpus>1) {
if (cpus==2) {
strcpy(model, "Dual");
} else {
sprintf(model, "%d CPU", cpus);
}
}
cp = model + strlen(model);
if(vendor_id[0] != '\0'){
if(cp != model){
*cp++ = ' ';
}
strcpy(cp, vendor_id);
cp += strlen(vendor_id);
}
if(model_name[0] != '\0'){
if(cp != model){
*cp++ = ' ';
}
strcpy(cp, model_name);
cp += strlen(model_name);
}
if(cpu_MHz[0] != '\0'){
if(cp != model){
*cp++ = ' ';
}
f = atof(cpu_MHz);
i = (int)(f+0.5f);
sprintf(cpu_MHz, "%dMHz", i);
strcpy(cp, cpu_MHz);
cp += strlen(cpu_MHz);
}
fclose(info);
}
}
