void QParseSite::finishedSlot(QNetworkReply* reply)
{
// Reathising attributes of the reply
// e.g. the HTTP status cothise
QVariant statusCodV =
reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
// Or the target URL if it was a rethisirect:
QVariant redirectionTargetUrl =
reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
// see CS001432 on how to hanthisle this
// no error receivethis?
if (reply->error() == QNetworkReply::NoError)
{
QByteArray bytes = reply->readAll(); // bytes
QString string(bytes); // string
parse_page(string);
}
// Some http error receivethis
else
{
emit page_parsed(links,media,"",QDateTime::currentDateTime ().toString()+" "+reply->errorString());
// hanthisle errors here
}
// We receive ownership of the reply object
// anthis therefore neethis to hanthisle thiseletion.
/// thiselete reply;
}
static GList * lyrics_lyricstime_parse(cb_object * capo)
{
GList * rList = NULL;
char * start = capo->cache->data;
if(start != NULL)
{
gchar * div_end = strstr(start,SEARCH_ENDIN);
gchar * node = capo->cache->data;
gchar * backpointer = node;
gsize nlen = (sizeof NODE_BEGIN) - 1;
while(continue_search(g_list_length(rList),capo->s) && (node = strstr(node+nlen,NODE_BEGIN)) != NULL)
{
if(div_end >= node)
break;
if(validate_artist(capo,backpointer) == TRUE)
{
gchar * end_of_url = strstr(node+nlen,NODE_ENDIN);
if(end_of_url != NULL)
{
gchar * url = copy_value(node+nlen,end_of_url);
if(url != NULL)
{
gchar * full_url = g_strdup_printf("http://www.lyricstime.com%s",url);
GlyrMemCache * dl_cache = download_single(full_url,capo->s,NULL);
if(dl_cache)
{
GlyrMemCache * parsed_cache = parse_page(dl_cache,capo);
if(parsed_cache != NULL)
{
rList = g_list_prepend(rList,parsed_cache);
}
DL_free(dl_cache);
g_free(full_url);
}
g_free(url);
}
}
}
backpointer = node;
}
}
return rList;
}
struct page *
page_slurp(char *file_path)
{
struct page *p = NULL;
FILE *f = fopen(file_path, "r");
if (NULL == f) {
fatal("Unable to open: %s\n", file_path);
}
p = parse_page(f, file_path);
p->next = NULL;
p->prev = NULL;
if (0 != fclose(f)) {
fatal("Unabled to close: %s\n", file_path);
}
return p;
}
/*
* Backup data file in the from_root directory to the to_root directory with
* same relative path.
* If lsn is not NULL, pages only which are modified after the lsn will be
* copied.
*/
bool
backup_data_file(const char *from_root, const char *to_root,
pgFile *file, const XLogRecPtr *lsn)
{
char to_path[MAXPGPATH];
FILE *in;
FILE *out;
BackupPageHeader header;
DataPage page; /* used as read buffer */
BlockNumber blknum = 0;
size_t read_len = 0;
pg_crc32 crc;
off_t offset;
INIT_CRC32C(crc);
/* reset size summary */
file->read_size = 0;
file->write_size = 0;
/* open backup mode file for read */
in = fopen(file->path, "r");
if (in == NULL)
{
FIN_CRC32C(crc);
file->crc = crc;
/* maybe vanished, it's not error */
if (errno == ENOENT)
return false;
elog(ERROR, "cannot open backup mode file \"%s\": %s",
file->path, strerror(errno));
}
/* open backup file for write */
if (check)
snprintf(to_path, lengthof(to_path), "%s/tmp", backup_path);
else
join_path_components(to_path, to_root, file->path + strlen(from_root) + 1);
out = fopen(to_path, "w");
if (out == NULL)
{
int errno_tmp = errno;
fclose(in);
elog(ERROR, "cannot open backup file \"%s\": %s",
to_path, strerror(errno_tmp));
}
/* confirm server version */
check_server_version();
/*
* Read each page and write the page excluding hole. If it has been
* determined that the page can be copied safely, but no page map
* has been built, it means that we are in presence of a relation
* file that needs to be completely scanned. If a page map is present
* only scan the blocks needed. In each case, pages are copied without
* their hole to ensure some basic level of compression.
*/
if (file->pagemap.bitmapsize == 0)
{
for (blknum = 0;
(read_len = fread(&page, 1, sizeof(page), in)) == sizeof(page);
++blknum)
{
XLogRecPtr page_lsn;
int upper_offset;
int upper_length;
header.block = blknum;
/*
* If an invalid data page was found, fallback to simple copy to ensure
* all pages in the file don't have BackupPageHeader.
*/
if (!parse_page(&page, &page_lsn,
&header.hole_offset, &header.hole_length))
{
elog(LOG, "%s fall back to simple copy", file->path);
fclose(in);
fclose(out);
file->is_datafile = false;
return copy_file(from_root, to_root, file);
}
file->read_size += read_len;
/* if the page has not been modified since last backup, skip it */
if (lsn && !XLogRecPtrIsInvalid(page_lsn) && page_lsn < *lsn)
continue;
upper_offset = header.hole_offset + header.hole_length;
upper_length = BLCKSZ - upper_offset;
/* write data page excluding hole */
if (fwrite(&header, 1, sizeof(header), out) != sizeof(header) ||
fwrite(page.data, 1, header.hole_offset, out) != header.hole_offset ||
fwrite(page.data + upper_offset, 1, upper_length, out) != upper_length)
{
int errno_tmp = errno;
/* oops */
fclose(in);
fclose(out);
elog(ERROR, "cannot write at block %u of \"%s\": %s",
blknum, to_path, strerror(errno_tmp));
}
/* update CRC */
COMP_CRC32C(crc, &header, sizeof(header));
COMP_CRC32C(crc, page.data, header.hole_offset);
COMP_CRC32C(crc, page.data + upper_offset, upper_length);
file->write_size += sizeof(header) + read_len - header.hole_length;
}
}
else
{
datapagemap_iterator_t *iter;
iter = datapagemap_iterate(&file->pagemap);
while (datapagemap_next(iter, &blknum))
{
XLogRecPtr page_lsn;
int upper_offset;
int upper_length;
int ret;
offset = blknum * BLCKSZ;
if (offset > 0)
{
ret = fseek(in, offset, SEEK_SET);
if (ret != 0)
elog(ERROR,
"Can't seek in file offset: %llu ret:%i\n",
(long long unsigned int) offset, ret);
}
read_len = fread(&page, 1, sizeof(page), in);
header.block = blknum;
/*
* If an invalid data page was found, fallback to simple copy to ensure
* all pages in the file don't have BackupPageHeader.
*/
if (!parse_page(&page, &page_lsn,
&header.hole_offset, &header.hole_length))
{
elog(LOG, "%s fall back to simple copy", file->path);
fclose(in);
fclose(out);
file->is_datafile = false;
return copy_file(from_root, to_root, file);
}
file->read_size += read_len;
/* if the page has not been modified since last backup, skip it */
if (lsn && !XLogRecPtrIsInvalid(page_lsn) && page_lsn < *lsn)
continue;
upper_offset = header.hole_offset + header.hole_length;
upper_length = BLCKSZ - upper_offset;
/* write data page excluding hole */
if (fwrite(&header, 1, sizeof(header), out) != sizeof(header) ||
fwrite(page.data, 1, header.hole_offset, out) != header.hole_offset ||
fwrite(page.data + upper_offset, 1, upper_length, out) != upper_length)
{
int errno_tmp = errno;
/* oops */
fclose(in);
fclose(out);
elog(ERROR, "cannot write at block %u of \"%s\": %s",
blknum, to_path, strerror(errno_tmp));
}
/* update CRC */
COMP_CRC32C(crc, &header, sizeof(header));
COMP_CRC32C(crc, page.data, header.hole_offset);
COMP_CRC32C(crc, page.data + upper_offset, upper_length);
file->write_size += sizeof(header) + read_len - header.hole_length;
}
pg_free(iter);
}
/*
* update file permission
* FIXME: Should set permission on open?
*/
if (!check && chmod(to_path, FILE_PERMISSION) == -1)
{
int errno_tmp = errno;
fclose(in);
fclose(out);
elog(ERROR, "cannot change mode of \"%s\": %s", file->path,
strerror(errno_tmp));
}
fclose(in);
fclose(out);
/* finish CRC calculation and store into pgFile */
FIN_CRC32C(crc);
file->crc = crc;
/* Treat empty file as not-datafile */
if (file->read_size == 0)
file->is_datafile = false;
/* We do not backup if all pages skipped. */
if (file->write_size == 0 && file->read_size > 0)
{
if (remove(to_path) == -1)
elog(ERROR, "cannot remove file \"%s\": %s", to_path,
strerror(errno));
return false;
}
/* remove $BACKUP_PATH/tmp created during check */
if (check)
remove(to_path);
return true;
}
static void client_handler(void *opaque)
{
QemuHttpConnection *conn = (QemuHttpConnection *)opaque;
if (conn->state == NEW_REQUEST) {
conn->pos = 0;
}
if (conn->pos == HEADER_SIZE) {
conn->pos = 0;
}
int read_bytes
= read(conn->fd, conn->in_buffer + conn->pos, HEADER_SIZE - conn->pos);
/* connection is closed or invalid */
if (read_bytes == 0
|| (read_bytes == -1 && (errno != EINTR && errno != EAGAIN)))
{
goto end_connection;
}
if (conn->state == NEW_REQUEST) {
conn->state = IN_HEADERS;
}
int b = conn->pos;
int e = conn->pos + read_bytes;
while (b < e) {
/* we are at beginning ? */
if (!conn->page_complete) {
while (b < e) {
if (conn->page_pos >= 0 && conn->page[conn->page_pos] == '\r'
&& conn->in_buffer[b] == '\n')
{
conn->page[++conn->page_pos] = conn->in_buffer[b++];
conn->page_complete = 1;
break;
} else {
conn->page[++conn->page_pos] = conn->in_buffer[b++];
}
}
} else {
if (b >= 3) {
if (conn->in_buffer[b-3] == '\r' && conn->in_buffer[b-2] == '\n'
&& conn->in_buffer[b-1] == '\r' && conn->in_buffer[b] == '\n')
{
conn->state = NEW_REQUEST;
goto process_request;
}
}
b++;
}
}
conn->pos = e;
if (conn->state == IN_HEADERS) {
return;
}
process_request:
if (parse_page(conn) || process_request(conn)) {
goto end_connection;
}
end_connection:
close(conn->fd);
conn->open = 0;
conn->state = NEW_REQUEST;
ghttp_state->connections--;
qemu_set_fd_handler(conn->fd, NULL, NULL, NULL);
}
