int main (void)
{
linkedList* memoryMap = new linkedList(); // instantiate linkedList
memoryMap->create(); // create memory map (add Node)
displayMenu(); // print menu to screen
do {
input = parseUser(); // make sure user is inputting number
switch (input) {
case 1:
addProgram(memoryMap); // add program in MM
break;
case 2:
killProgram(memoryMap); // kill progam in MM
break;
case 3:
getFragments(memoryMap); // get fragements in MM
break;
case 4:
memoryMap -> display(); // display MM
break;
}
while (input != 1 && input != 2 && input != 3 && input != 4 && input != 5) {
input = parseUser(); // make sure user is inputting numbers
}
} while (input == 1 || input == 2 || input == 3 || input == 4); // if input = 5 -> exit Program
}
string TgTypeParser::parseMessage(const Message::Ptr& object) const {
if (!object) {
return "";
}
string result;
result += '{';
appendToJson(result, "message_id", object->messageId);
appendToJson(result, "from", parseUser(object->from));
appendToJson(result, "date", object->date);
appendToJson(result, "chat", parseChat(object->chat));
appendToJson(result, "forward_from", parseUser(object->forwardFrom));
appendToJson(result, "forward_date", object->forwardDate);
appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
appendToJson(result, "text", object->text);
appendToJson(result, "audio", parseAudio(object->audio));
appendToJson(result, "document", parseDocument(object->document));
appendToJson(result, "photo", parseArray(&TgTypeParser::parsePhotoSize, object->photo));
appendToJson(result, "sticker", parseSticker(object->sticker));
appendToJson(result, "video", parseVideo(object->video));
appendToJson(result, "contact", parseContact(object->contact));
appendToJson(result, "location", parseLocation(object->location));
appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
appendToJson(result, "new_chat_title", object->newChatTitle);
appendToJson(result, "new_chat_photo", parseArray(&TgTypeParser::parsePhotoSize, object->newChatPhoto));
appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
appendToJson(result, "group_chat_created", object->groupChatCreated);
appendToJson(result, "caption", object->caption);
result.erase(result.length() - 1);
result += '}';
return result;
}
void UserLoader::handleResponse(QString t_uuid, QNetworkReply *t_reply) {
auto api = API::sharedAPI()->sharedAniListAPI();
auto url = t_reply->request().url();
auto api_part = QUrl(url.toDisplayString().split("?").first());
auto display_name = User::sharedUser()->displayName();
auto string_part = api_part.toDisplayString();
if (api_part == api->API_USER) {
auto result = QJsonDocument::fromJson(t_reply->readAll()).object();
parseUser(result);
} else if (api_part == api->API_USER_LIST(display_name)) {
auto result = QJsonDocument::fromJson(t_reply->readAll()).object();
parseUserList(result);
} else if (string_part.startsWith(api->API_ANIME("").toDisplayString()) &&
!string_part.startsWith(
api->API_ANIME_SEARCH("").toDisplayString())) {
auto result = QJsonDocument::fromJson(t_reply->readAll()).object();
parseAnime(result);
} else {
if (m_callbacks.contains(t_uuid)) {
auto result = QJsonDocument::fromJson(t_reply->readAll()).object();
m_callbacks.value(t_uuid)(result);
m_callbacks.remove(t_uuid);
}
}
}
int parseUsers(std::string &xmlstr, struct t_user ** dest){
mxml_node_t *xml;
mxml_node_t *unit;
struct t_user * users = (struct t_user *)mem2_calloc(MAXUNITS, sizeof(struct t_user), MEM2_OTHER);
if(!users){
return 0;
}
size_t pos = 0;
while(1){
pos = xmlstr.find("&", pos);
if(pos == std::string::npos) break;
xmlstr.replace(pos, 9, "&");
}
xml = mxmlLoadString(NULL, xmlstr.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
mem2_free(users, MEM2_OTHER);
return 0;
}
int t=0;
for(unit = mxmlFindElement(xml, xml, "user", NULL, NULL, MXML_DESCEND); unit; unit = mxmlFindElement(unit, xml, "user", NULL, NULL, MXML_DESCEND)){
parseUser(unit, &users[t++]);
}
mxmlDelete(xml);
if(t < MAXUNITS){ //Free unused memory
users = (struct t_user *)mem2_realloc(users, t*sizeof(struct t_user), MEM2_OTHER);
}
*dest = users;
return t;
}
int facebook_json_parser::parse_user_info(std::string *data, facebook_user* fbu)
{
std::string jsonData = data->substr(9);
JSONNode root = JSONNode::parse(jsonData.c_str());
if (!root)
return EXIT_FAILURE;
const JSONNode &profiles = root["payload"].at("profiles");
if (!profiles)
return EXIT_FAILURE;
//std::map<std::string, std::string> user_ids;
for (auto it = profiles.begin(); it != profiles.end(); ++it) {
// TODO: allow more users to parse at once
std::string id = (*it).name();
if (fbu->user_id == id) {
parseUser(*it, fbu);
break;
}
}
return EXIT_SUCCESS;
}
void parseTweet(mxml_node_t *tweet, struct t_tweet *dest, int parseuser){
mxml_node_t *value = NULL;
if(parseuser){
value = mxmlFindElement(tweet, tweet, "name", NULL, NULL, MXML_DESCEND);
snprintf(dest->retweetby, 96, "Retweeted by %s", value->child->value.opaque);
}
value = mxmlFindElement(tweet, tweet, "current_user_retweet", NULL, NULL, MXML_DESCEND);
if(value && value->child){
value = mxmlFindElement(value, tweet, "id", NULL, NULL, MXML_DESCEND);
sscanf(value->child->value.opaque, "%llu", &(dest->retweet_id));
dest->flags |= RETWEETED;
}
value = mxmlFindElement(tweet, tweet, "retweeted_status", NULL, NULL, MXML_DESCEND);
if(value && value->child){ //The retweeted status becomes the target unit
tweet = value;
}else{
dest->retweetby[0] = 0;
}
value = mxmlFindElement(tweet, tweet, "created_at", NULL, NULL, MXML_DESCEND);
{
struct tm tm;
strptime(value->child->value.opaque, tweet_format, &tm);
tm.tm_isdst = -1;
dest->created = mktime(&tm) - timeoffset;
}
value = mxmlFindElement(value, tweet, "id", NULL, NULL, MXML_DESCEND);
sscanf(value->child->value.opaque, "%llu", &(dest->id));
value = mxmlFindElement(value, tweet, "text", NULL, NULL, MXML_DESCEND);
wt_strncpy(dest->text, value->child->value.opaque, 765);
if(parseuser){
value = mxmlFindElement(tweet, tweet, "user", NULL, NULL, MXML_DESCEND);
if(value && value->child) parseUser(value, &(dest->user));
}
value = mxmlFindElement(tweet, tweet, "favorited", NULL, NULL, MXML_DESCEND);
if(value && value->child && value->child->value.opaque[0] == 't') dest->flags |= FAVORITED;
value = mxmlFindElement(tweet, tweet, "retweeted", NULL, NULL, MXML_DESCEND);
if(value && value->child && value->child->value.opaque[0] == 't') dest->flags |= RETWEETED;
value = mxmlFindElement(tweet, tweet, "entities", NULL, NULL, MXML_DESCEND);
if(value && value->child) parseEntities(value, dest);
mxmlDelete(value);
}
static ParseResult<Authority> parseAuthority(char const* str) {
ParseResult<Authority> result{};
if (str[0] == '\0' || str[0] != '/' || str[1] != '/') {
result.ch = str;
return result;
}
auto user = parseUser(str+2); // For "//"
auto host = parseHost(user.ch);
auto port = parsePort(host.ch);
result.value.userIs(user.value);
result.value.hostIs(host.value);
result.value.portIs(port.value);
result.ch = port.ch;
return result;
}
static struct passwd *
getpw(const char *nam, uid_t uid, int which)
{
char *line;
struct passwd *pw;
if (which != 0)
{
if (setpwent() == 0) return NULL;
}
forever
{
line = getLine(_pfp);
if (line == NULL) break;
if (line[0] == '#')
{
free(line);
line = NULL;
continue;
}
pw = parseUser(line);
free(line);
line = NULL;
if ((pw == NULL) || (which == _PWENT_))
{
if (_pwStayOpen == 0) endpwent();
return pw;
}
if (((which == _PWNAM_) && (!strcmp(nam, pw->pw_name))) ||
((which == _PWUID_) && (uid == pw->pw_uid)))
{
if (_pwStayOpen == 0) endpwent();
return pw;
}
}
if (_pwStayOpen == 0) endpwent();
return NULL;
}
int parseTweets(std::string &xmlstr, struct t_tweet ** dest, int usertop)
{
mxml_node_t *xml;
mxml_node_t *unit;
struct t_tweet * tweets = (struct t_tweet *)mem2_calloc(MAXUNITS, sizeof(struct t_tweet), MEM2_OTHER);
if(!tweets){
return 0;
}
size_t pos = 0;
while(1){
pos = xmlstr.find("&amp;", pos);
if(pos == std::string::npos) break;
xmlstr.replace(pos, 9, "&");
}
xml = mxmlLoadString(NULL, xmlstr.c_str(), MXML_OPAQUE_CALLBACK);
if(!xml){
mem2_free(tweets, MEM2_OTHER);
return 0;
}
int t=0;
if(usertop){
for(unit = mxmlFindElement(xml, xml, "user", NULL, NULL, MXML_DESCEND); unit && t < MAXUNITS; unit = mxmlFindElement(unit, xml, "user", NULL, NULL, MXML_DESCEND)){
parseUser(unit, &(tweets[t].user), &(tweets[t]));
t++;
}
}else{
for(unit = mxmlFindElement(xml, xml, "status", NULL, NULL, MXML_DESCEND); unit && t < MAXUNITS; unit = mxmlFindElement(unit, xml, "status", NULL, NULL, MXML_DESCEND)){
parseTweet(unit, &tweets[t++]);
}
}
mxmlDelete(xml);
if(t < MAXUNITS){ //Free unused memory
tweets = (struct t_tweet *)mem2_realloc(tweets, t*sizeof(struct t_tweet), MEM2_OTHER);
}
*dest = tweets;
return t;
}
int facebook_json_parser::parse_friends(std::string *data, std::map< std::string, facebook_user* >* friends)
{
std::string jsonData = data->substr(9);
JSONNode root = JSONNode::parse(jsonData.c_str());
if (!root)
return EXIT_FAILURE;
const JSONNode &payload = root["payload"];
if (!payload)
return EXIT_FAILURE;
for (auto it = payload.begin(); it != payload.end(); ++it) {
facebook_user *fbu = new facebook_user();
parseUser(*it, fbu);
friends->insert(std::make_pair(fbu->user_id, fbu));
}
return EXIT_SUCCESS;
}
// METODO Database::loadUserList
void Database::loadUsersList() {
QString path( "users.xml" );
QFile file( path );
if( !file.open( QIODevice::ReadWrite | QIODevice::Text ) ) {
qDebug() << "Cannot read file: " << file.errorString();
return;
}
QXmlStreamReader xmlReader( &file );
while( !xmlReader.atEnd() && !xmlReader.hasError() ) {
QXmlStreamReader::TokenType token = xmlReader.readNext();
if( token == QXmlStreamReader::StartDocument )
continue;
if( token == QXmlStreamReader::StartElement ) {
if( xmlReader.name() == "user" )
parseUser( xmlReader );
}
}
file.close();
if( !file.open( QIODevice::ReadWrite | QIODevice::Text ) ) {
qDebug() << "Cannot read file: " << file.errorString();
return;
}
xmlReader.setDevice( &file );
while( !xmlReader.atEnd() && !xmlReader.hasError() ) {
QXmlStreamReader::TokenType token = xmlReader.readNext();
if( token == QXmlStreamReader::StartDocument )
continue;
if( token == QXmlStreamReader::StartElement) {
if( xmlReader.name() == "user" )
loadUsersNet( xmlReader );
}
}
}
void addProgram(linkedList* memoryMap)
{
string nameOfProgram; // intialize variables
int sizeOfProgram;
char whatFit;
cout << "Program name?" << endl;
cin >> nameOfProgram; // enter string name of program
string upperNameOfProgram = nameOfProgram; // change everything to upper case
transform(upperNameOfProgram.begin(), upperNameOfProgram.end(),
upperNameOfProgram.begin(), ::toupper);
cout << "Size of Program (KB):" << endl; //
sizeOfProgram = parseUser(); // parse users input
cout << "Enter 1 for Best fit or 0 Worst fit:" << endl;
cin >> whatFit;
while (whatFit != '1' && whatFit != '0') {
cin >> whatFit;
}
int decision = atoi(&whatFit); // change to integer
if(decision == 1)
{
memoryMap -> bestFitAddProgram(sizeOfProgram,upperNameOfProgram); // use bestFit Algorithm
}
else
{
memoryMap -> worstFitAddProgram(sizeOfProgram,upperNameOfProgram); // use worstFit Alogorithm
}
}
HintedUser Deserializer::deserializeHintedUser(const json& aJson, bool aAllowMe, const string& aFieldName) {
auto userJson = JsonUtil::getRawValue(aFieldName, aJson);
auto user = parseUser(userJson, aAllowMe);
return HintedUser(user, JsonUtil::getField<string>("hub_url", userJson, aAllowMe && user == ClientManager::getInstance()->getMe()));
}
UserPtr Deserializer::deserializeUser(const json& aJson, bool aAllowMe, const string& aFieldName) {
auto userJson = JsonUtil::getRawValue(aFieldName, aJson);
return parseUser(userJson);
}
abyss_bool
ConfReadServerFile(const char * const filename,
TServer * const serverP) {
struct _TServer * const srvP = serverP->srvP;
BIHandler * const handlerP = srvP->builtinHandlerP;
TFile * fileP;
char z[512];
char * p;
unsigned int lineNum;
TFileStat fs;
if (!FileOpen(&fileP, filename, O_RDONLY))
return FALSE;
lineNum = 0;
while (ConfReadLine(fileP, z, 512)) {
++lineNum;
p = z;
if (ConfNextToken(&p)) {
const char * const option = ConfGetToken(&p);
if (option) {
ConfNextToken(&p);
if (xmlrpc_strcaseeq(option, "port")) {
int32_t n;
if (ConfReadInt(p, &n, 1, 65535))
srvP->port = n;
else
TraceExit("Invalid port '%s'", p);
} else if (xmlrpc_strcaseeq(option, "serverroot")) {
bool success;
chdirx(p, &success);
if (!success)
TraceExit("Invalid server root '%s'",p);
} else if (xmlrpc_strcaseeq(option, "path")) {
if (FileStat(p, &fs))
if (fs.st_mode & S_IFDIR) {
HandlerSetFilesPath(handlerP, p);
continue;
}
TraceExit("Invalid path '%s'", p);
} else if (xmlrpc_strcaseeq(option, "default")) {
const char * filename;
while ((filename = ConfGetToken(&p))) {
HandlerAddDefaultFN(handlerP, filename);
if (!ConfNextToken(&p))
break;
}
} else if (xmlrpc_strcaseeq(option, "keepalive")) {
int32_t n;
if (ConfReadInt(p, &n, 1, 65535))
srvP->keepalivemaxconn = n;
else
TraceExit("Invalid KeepAlive value '%s'", p);
} else if (xmlrpc_strcaseeq(option, "timeout")) {
int32_t n;
if (ConfReadInt(p, &n, 1, 3600)) {
srvP->keepalivetimeout = n;
/* Must see what to do with that */
srvP->timeout = n;
} else
TraceExit("Invalid TimeOut value '%s'", p);
} else if (xmlrpc_strcaseeq(option, "mimetypes")) {
MIMEType * mimeTypeP;
readMIMETypesFile(p, &mimeTypeP);
if (!mimeTypeP)
TraceExit("Can't read MIME Types file '%s'", p);
else
HandlerSetMimeType(handlerP, mimeTypeP);
} else if (xmlrpc_strcaseeq(option,"logfile")) {
srvP->logfilename = strdup(p);
} else if (xmlrpc_strcaseeq(option,"user")) {
parseUser(p, srvP);
} else if (xmlrpc_strcaseeq(option, "pidfile")) {
parsePidfile(p, srvP);
} else if (xmlrpc_strcaseeq(option, "advertiseserver")) {
if (!ConfReadBool(p, &srvP->advertise))
TraceExit("Invalid boolean value "
"for AdvertiseServer option");
} else
TraceExit("Invalid option '%s' at line %u",
option, lineNum);
}
}
}
FileClose(fileP);
return TRUE;
}
static policyPtr parsePermission(xmlNode *node, int allow) {
xmlNode *cur_node = node;
int accessParsed = 0;
ulong noOfGroups = 0;
ulong noOfUsers = 0;
int fileParsed = 0;
ulong userIndex = 0;
ulong groupIndex = 0;
long tempaccessMode = 0;
policyPtr newAccessNode = null;
char *temp = null;
if (cur_node && cur_node->type == XML_ELEMENT_NODE && (!strcmp(cur_node->name, allowTagName) || !strcmp(cur_node->name, denyTagName))) {
fileParsed = 0;
accessParsed = 0;
noOfGroups = getNoOfGroups(cur_node);
noOfUsers = getNoOfUsers(cur_node);
newAccessNode = getNewPolicyElement();
if (noOfGroups) {
newAccessNode->groups = (char**) malloc(sizeof (char*) * noOfGroups);
}
if (noOfUsers) {
newAccessNode->users = (char**) malloc(sizeof (char*) * noOfUsers);
}
newAccessNode->allow = allow;
userIndex = 0;
groupIndex = 0;
tempaccessMode = -1;
for (cur_node = node->children; cur_node; cur_node = cur_node->next) {
if (cur_node->type == XML_ELEMENT_NODE) {
if (!strcmp(cur_node->name, fileTagName) && !(fileParsed)) {
temp = parseFile(cur_node);
fileParsed = 1;
if (temp) {
newAccessNode->fileName = temp;
} else {
goto cleanup;
}
} else if (!strcmp(cur_node->name, userTagName)) {
temp = parseUser(cur_node);
if (temp) {
newAccessNode->users[userIndex++] = temp;
newAccessNode->noOfUsers++;
} else {
goto cleanup;
}
} else if (!strcmp(cur_node->name, groupTagName)) {
temp = parseGroup(cur_node);
if (temp) {
newAccessNode->groups[groupIndex++] = temp;
newAccessNode->noOfGroups++;
} else {
goto cleanup;
}
} else if (!strcmp(cur_node->name, accessTagName) && !(accessParsed)) {
tempaccessMode = parseAccess(cur_node);
accessParsed = 1;
if (tempaccessMode < 0) {
goto cleanup;
} else {
newAccessNode->mode = (ulong) tempaccessMode;
}
} else {
fprintf(stderr, "\nInvalid Element:%s\n", cur_node->name);
goto cleanup;
}
}
}
} else {
fprintf(stderr, "Expected element : %s, as root node but found:%s", allowTagName, cur_node->name);
}
ret:
return newAccessNode;
cleanup:
freePolicyElement(newAccessNode);
newAccessNode = null;
goto ret;
}
