bool ArtistInfo::parse(std::string &data)
{
size_t a, b;
bool parse_failed = false;
if ((a = data.find("<content>")) != std::string::npos)
{
a += static_strlen("<content>");
if ((b = data.find("</content>")) == std::string::npos)
parse_failed = true;
}
else
parse_failed = true;
if (parse_failed)
{
data = msgParseFailed;
return false;
}
if (a == b)
{
data = "No description available for this artist.";
return false;
}
std::vector< std::pair<std::string, std::string> > similars;
for (size_t i = data.find("<name>"), j, k = data.find("<url>"), l;
i != std::string::npos; i = data.find("<name>", i), k = data.find("<url>", k))
{
j = data.find("</name>", i);
i += static_strlen("<name>");
l = data.find("</url>", k);
k += static_strlen("<url>");
similars.push_back(std::make_pair(data.substr(i, j-i), data.substr(k, l-k)));
StripHtmlTags(similars.back().first);
}
a += static_strlen("<![CDATA[");
b -= static_strlen("]]>");
data = data.substr(a, b-a);
postProcess(data);
data += "\n\nSimilar artists:\n";
for (size_t i = 1; i < similars.size(); ++i)
{
data += "\n * ";
data += similars[i].first;
data += " (";
data += similars[i].second;
data += ")";
}
data += "\n\n";
data += similars.front().second;
return true;
}
static int parse_thread_name (const char * name,
const char ** next, int * next_len,
const char ** nextnext)
{
const char * p = name;
int pid = 0;
if (*p == '/')
p++;
if (strpartcmp_static(p, "self")) {
p += static_strlen("self");
if (*p && *p != '/')
return -ENOENT;
pid = get_cur_tid();
} else {
for ( ; *p && *p != '/' ; p++) {
if (*p < '0' || *p > '9')
return -ENOENT;
pid = pid * 10 + *p - '0';
}
}
if (next) {
if (*(p++) == '/' && *p) {
*next = p;
if (next_len || nextnext)
for ( ; *p && *p != '/' ; p++);
if (next_len)
*next_len = p - *next;
if (nextnext)
*nextnext = (*(p++) == '/' && *p) ? p : NULL;
} else {
*next = NULL;
}
}
return pid;
}
static int find_thread_link (const char * name, struct shim_qstr * link,
struct shim_dentry ** dentptr,
struct shim_thread ** threadptr)
{
const char * next, * nextnext;
int next_len;
int pid = parse_thread_name(name, &next, &next_len, &nextnext);
if (pid < 0)
return pid;
struct shim_thread * thread = lookup_thread(pid);
struct shim_dentry * dent = NULL;
int ret = 0;
if (!thread)
return -ENOENT;
if (!thread->in_vm) {
ret = -ENOENT;
goto out;
}
lock(&thread->lock);
if (next_len == static_strlen("root") && !memcmp(next, "root", next_len)) {
dent = thread->root;
get_dentry(dent);
}
if (next_len == static_strlen("cwd") && !memcmp(next, "cwd", next_len)) {
dent = thread->cwd;
get_dentry(dent);
}
if (next_len == static_strlen("exe") && !memcmp(next, "exe", next_len)) {
struct shim_handle * exec = thread->exec;
if (!exec->dentry) {
unlock(&thread->lock);
ret = -EINVAL;
goto out;
}
dent = exec->dentry;
get_dentry(dent);
}
unlock(&thread->lock);
if (nextnext) {
struct shim_dentry * next_dent = NULL;
ret = path_lookupat(dent, nextnext, 0, &next_dent, dent->fs);
if (ret < 0)
goto out;
put_dentry(dent);
dent = next_dent;
}
if (link) {
int size;
char * path = dentry_get_path(dent, true, &size);
qstrsetstr(link, path, size);
}
if (dentptr) {
get_dentry(dent);
*dentptr = dent;
}
if (threadptr) {
get_thread(thread);
*threadptr = thread;
}
ret = 0;
out:
if (dent)
put_dentry(dent);
if (thread)
put_thread(thread);
return ret;
}
constexpr std::size_t static_strlen(const char* str) {
return (str == nullptr || *str == 0) ? 0 : 1 + static_strlen(++str);
}
