/*
* The call that gets the paging ball rolling...
*/
void page_string(Descriptor *d, char *str, int keep_internal)
{
if (!d)
return;
if (!str || !*str)
{
d->send("");
return;
}
d->showstr_count = count_pages(str);
CREATE(d->showstr_vector, char *, d->showstr_count);
if (keep_internal)
{
d->showstr_head = str_dup(str);
paginate_string(d->showstr_head, d);
}
else
paginate_string(str, d);
char sEmpty[8];
*sEmpty = '\0';
show_string(d, sEmpty);
}
int pmdisk_suspend(void)
{
int error = 0;
if ((error = read_swapfiles()))
return error;
drain_local_pages();
pm_pagedir_nosave = NULL;
pr_debug("pmdisk: Counting pages to copy.\n" );
count_pages();
pr_debug("pmdisk: (pages needed: %d + %d free: %d)\n",
pmdisk_pages,PAGES_FOR_IO,nr_free_pages());
if (!enough_free_mem())
return -ENOMEM;
if (!enough_swap())
return -ENOSPC;
if ((error = alloc_pagedir())) {
pr_debug("pmdisk: Allocating pagedir failed.\n");
return error;
}
if ((error = alloc_image_pages())) {
pr_debug("pmdisk: Allocating image pages failed.\n");
free_pagedir();
return error;
}
nr_copy_pages_check = pmdisk_pages;
pagedir_order_check = pagedir_order;
/* During allocating of suspend pagedir, new cold pages may appear.
* Kill them
*/
drain_local_pages();
/* copy */
copy_pages();
/*
* End of critical section. From now on, we can write to memory,
* but we should not touch disk. This specially means we must _not_
* touch swap space! Except we must write out our image of course.
*/
pr_debug("pmdisk: %d pages copied\n", pmdisk_pages );
return 0;
}
void page_string(SOCKET_DATA *dsock, const char *string) {
if(dsock->page_string)
free(dsock->page_string);
dsock->page_string = strdup(string);
dsock->tot_pages = count_pages(string);
if(dsock->tot_pages == 1) {
text_to_buffer(dsock, dsock->page_string);
delete_page(dsock);
}
else {
dsock->curr_page = 1;
show_page(dsock, 1);
}
}
int main(int argc, char *argv[])
{
FILE *f;
int pages = 0, rows, i;
char line[MAXLINE];
int count_pages(FILE *f);
if (argc == 1)
{
printf("Not enough arguments!\n");
return 0;
}
else
while (--argc > 0)
if ((f = fopen(*++argv, "r")) != NULL)
{
pages = count_pages(f);
printf("File: %s, %d pages\n", *argv, pages);
rows = 0;
if ((fgets(line, MAXLINE, f)) == NULL)
printf("NULL");
while ((fgets(line, MAXLINE, f)) != NULL)
{
rows++;
printf("%s", line);
}
for (i = rows % PAGEROWS; i <= PAGEROWS; i++ )
printf("\n");
fclose(f);
}
else
{
fprintf(stderr, "can't opne %s", *argv);
exit(1);
}
return 0;
}
static int init_pdb7_root_stream(R_PDB *pdb, int *root_page_list, int pages_amount,
EStream indx, int root_size, int page_size) {
R_PDB_STREAM *pdb_stream = 0;
int tmp_data_max_size = 0;
char *tmp_data = NULL, *data_end;
int stream_size = 0;
int num_streams = 0;
int *sizes = NULL;
int num_pages = 0;
int data_size = 0;
char *data = NULL;
int i = 0;
int pos = 0;
char *tmp;
R_PDB7_ROOT_STREAM *root_stream7;
pdb->root_stream = R_NEW0 (R_PDB7_ROOT_STREAM);
init_r_pdb_stream(&pdb->root_stream->pdb_stream, pdb->buf, root_page_list, pages_amount,
indx, root_size, page_size);
root_stream7 = pdb->root_stream;
pdb_stream = &(root_stream7->pdb_stream);
stream_file_get_size (&pdb_stream->stream_file, &data_size);
data = (char *) calloc (1, data_size);
if (!data) return 0;
stream_file_get_data(&pdb_stream->stream_file, data);
num_streams = *(int *)data;
tmp_data = data;
tmp_data += 4;
root_stream7->num_streams = num_streams;
tmp_data_max_size = (data_size - (num_streams * 4 - 4));
data_end = data + tmp_data_max_size;
if (tmp_data_max_size> data_size) {
R_FREE(data);
eprintf ("invalid max tmp data size\n");
return 0;
}
if (num_streams<0 || tmp_data_max_size <= 0) {
R_FREE(data);
eprintf ("too much amount of streams\n"
"curremt pdb file is not correct\n");
return 0;
}
sizes = (int *) calloc (num_streams, 4);
if (!sizes) {
R_FREE (data);
eprintf ("too much amount of streams\n"
"current pdb file is not correct\n");
return 0;
}
for (i = 0; i < num_streams && (tmp_data+4 < data_end); i++) {
stream_size = *(int *)(tmp_data);
tmp_data += 4;
if (stream_size == UT32_MAX) {
stream_size = 0;
}
memcpy (sizes + i, &stream_size, 4);
}
// char *tmp_file_name = (char *) malloc(strlen("/root/test.pdb.000") + 1);
// short ii;
// FILE *tmp_file;
tmp_data = ((char *)data + num_streams * 4 + 4);
root_stream7->streams_list = r_list_new();
RList *pList = root_stream7->streams_list;
SPage *page = 0;
for (i = 0; i < num_streams; i++) {
num_pages = count_pages (sizes[i], page_size);
if ((pos + num_pages) > tmp_data_max_size) {
R_FREE(data);
R_FREE(sizes);
eprintf("warning: looks like there is not correct values "
"of stream size in pdb file\n");
return 0;
}
// TODO: cache that num_pages * 4, its used 4 times
tmp = (char *) calloc (num_pages, 4);
memset(tmp, 0, num_pages * 4);
page = R_NEW0 (SPage);
if (num_pages != 0) {
if ((pos+(num_pages*4)) > tmp_data_max_size) {
eprintf ("data overrun by num_pages\n");
R_FREE (data);
R_FREE (sizes);
R_FREE (tmp);
R_FREE (page);
return 0;
}
memcpy (tmp, tmp_data + pos, num_pages * 4);
pos += num_pages * 4;
// sprintf(tmp_file_name, "%s%d", "/root/test.pdb", i);
// tmp_file = fopen(tmp_file_name, "wb");
// fwrite(tmp, num_pages * 4, 1, tmp_file);
// fclose(tmp_file);
page->stream_size = sizes[i];
page->stream_pages = tmp;
page->num_pages = num_pages;
} else {
page->stream_size = 0;
page->stream_pages = 0;
page->num_pages = 0;
free(tmp);
}
r_list_append (pList, page);
}
free (sizes);
free (data);
// printf("init_pdb7_root_stream()\n");
return 1;
}
static bool pdb7_parse(R_PDB *pdb) {
char signature[PDB7_SIGNATURE_LEN + 1];
int num_root_index_pages = 0;
int *root_index_pages = 0;
void *root_page_data = 0;
int *root_page_list = 0;
int num_root_pages = 0;
int num_file_pages = 0;
int alloc_tbl_ptr = 0;
int bytes_read = 0;
int page_size = 0;
int root_size = 0;
int reserved = 0;
void *p_tmp;
int i = 0;
bytes_read = r_buf_read(pdb->buf, (unsigned char *)signature, PDB7_SIGNATURE_LEN);
if (bytes_read != PDB7_SIGNATURE_LEN) {
eprintf ("error while reading PDB7_SIGNATURE\n");
goto error;
}
if (!read_int_var ("page_size", &page_size, pdb)) {
goto error;
}
if (!read_int_var ("alloc_tbl_ptr", &alloc_tbl_ptr, pdb)) {
goto error;
}
if (!read_int_var ("num_file_pages", &num_file_pages, pdb)) {
goto error;
}
if (!read_int_var ("root_size", &root_size, pdb)) {
goto error;
}
if (!read_int_var("reserved", &reserved, pdb)) {
goto error;
}
// FIXME: why they is not equal ????
// if (memcmp(signature, PDB7_SIGNATURE, PDB7_SIGNATURE_LEN) != 0) {
// printf("Invalid signature for PDB7 format\n");
// //goto error;
// }
num_root_pages = count_pages (root_size, page_size);
num_root_index_pages = count_pages ((num_root_pages * 4), page_size);
root_index_pages = (int *)calloc (sizeof (int), R_MAX (num_root_index_pages, 1));
if (!root_index_pages) {
eprintf("error memory allocation\n");
goto error;
}
// bytes_read = fread(root_index_pages, 4, num_root_index_pages, pdb->fp);
bytes_read = r_buf_read(pdb->buf, (unsigned char *)root_index_pages, 4 * num_root_index_pages);
//fread(root_index_pages, 4, num_root_index_pages, pdb->fp);
if (bytes_read != 4 * num_root_index_pages) {
eprintf ("error while reading root_index_pages\n");
goto error;
}
root_page_data = (int *)calloc (page_size, num_root_index_pages);
if (!root_page_data) {
eprintf ("error memory allocation of root_page_data\n");
goto error;
}
p_tmp = root_page_data;
for (i = 0; i < num_root_index_pages; i++) {
r_buf_seek(pdb->buf, root_index_pages[i] * page_size, 0);
r_buf_read(pdb->buf, p_tmp, page_size);
p_tmp = (char *)p_tmp + page_size;
}
root_page_list = (int *)calloc (sizeof(int), num_root_pages);
if (!root_page_list) {
eprintf ("error: memory allocation of root page\n");
goto error;
}
p_tmp = root_page_data;
for (i = 0; i < num_root_pages; i++) {
root_page_list[i] = *((int *)p_tmp);
p_tmp = (int *)p_tmp + 1;
}
pdb->pdb_streams2 = 0;
if (!init_pdb7_root_stream (pdb, root_page_list, num_root_pages,
ePDB_STREAM_ROOT, root_size, page_size)) {
eprintf ("root stream has not initialized\n");
goto error;
}
if (!pdb_read_root (pdb)) {
eprintf ("pdb root has not initialized\n");
goto error;
}
R_FREE (root_page_list);
R_FREE (root_page_data);
R_FREE (root_index_pages);
return true;
error:
R_FREE (root_page_list);
R_FREE (root_page_data);
R_FREE (root_index_pages);
return false;
}
static GObject*
close_confirmation_dialog_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
CloseConfirmationDialog *dialog;
GtkWidget *hbox, *image, *vbox, *label;
GtkTreeIter iter;
gboolean ret, single_page;
gchar *tmp, *str;
const gchar *cstr;
/* chain up to constructor of parent class */
object =
G_OBJECT_CLASS (close_confirmation_dialog_parent_class)->constructor (
type,
n_construct_properties,
construct_params);
dialog = CLOSE_CONFIRMATION_DIALOG (object);
g_object_set (dialog,
/* GtkDialog */
"has-separator", FALSE,
/* GtkWindow */
"resizable", FALSE,
"skip-taskbar-hint", TRUE,
/* GtkContainer */
"border-width", 5,
NULL);
g_object_set (GTK_DIALOG (dialog)->vbox,
/* GtkBox */
"spacing", 14,
NULL);
g_object_set (GTK_DIALOG (dialog)->action_area,
/* GtkBox */
"spacing", 6,
/* GtkContainer */
"border-width", 5,
NULL);
/* check if there is one or more than one page with changes */
ret = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
dialog->store_unsaved_pages),
&iter);
g_assert (ret);
single_page = !gtk_tree_model_iter_next (GTK_TREE_MODEL (
dialog->store_unsaved_pages),
&iter);
/* here starts the layout of the dialog */
hbox = GTK_WIDGET (g_object_new (GTK_TYPE_HBOX,
/* GtkContainer */
"border-width", 5,
/* GtkBox */
"homogeneous", FALSE,
"spacing", 12,
NULL));
/* warning image */
image = GTK_WIDGET (g_object_new (GTK_TYPE_IMAGE,
/* GtkMisc */
"xalign", 0.5,
"yalign", 0.0,
/* GtkImage */
"stock", GTK_STOCK_DIALOG_WARNING,
"icon-size", GTK_ICON_SIZE_DIALOG,
NULL));
gtk_box_pack_start (GTK_BOX (hbox), image,
FALSE, FALSE, 0);
/* vertical box on the right hand side of the dialog */
vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
/* GtkBox */
"homogeneous", FALSE,
"spacing", 12,
NULL));
/* primary label */
if (single_page) {
/* single page */
gchar *page_name;
page_name = get_page_name (GTK_TREE_MODEL (dialog->store_unsaved_pages),
NULL);
tmp = g_strdup_printf (
_("Save the changes to schematic \"%1$s\" before closing?"),
page_name);
g_free (page_name);
} else {
/* multi page */
tmp = g_strdup_printf (
_("There are %1$d schematics with unsaved changes. "
"Save changes before closing?"),
count_pages (GTK_TREE_MODEL (dialog->store_unsaved_pages)));
}
str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL);
g_free (tmp);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
/* GtkMisc */
"xalign", 0.0,
"yalign", 0.0,
"selectable", TRUE,
/* GtkLabel */
"wrap", TRUE,
"use-markup", TRUE,
"label", str,
NULL));
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), label,
FALSE, FALSE, 0);
if (!single_page) {
/* more than one page with changes, display each page and offer */
/* the opportunity to save them before exiting */
gtk_box_pack_start (GTK_BOX (vbox),
close_confirmation_dialog_build_page_list (dialog),
FALSE, FALSE, 0);
}
/* secondary label */
cstr = _("If you don't save, all your changes will be permanently lost.");
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
/* GtkMisc */
"xalign", 0.0,
"yalign", 0.0,
"selectable", TRUE,
/* GtkLabel */
"wrap", TRUE,
"label", cstr,
NULL));
gtk_box_pack_start (GTK_BOX (vbox), label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox,
FALSE, FALSE, 0);
/* add buttons to dialog action area */
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Close _without saving"), GTK_RESPONSE_NO,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_YES,
NULL);
/* Set the alternative button order (ok, cancel, help) for other systems */
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_YES,
GTK_RESPONSE_NO,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
/* all done, let's show the contents of the dialog */
gtk_widget_show_all (hbox);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
FALSE, FALSE, 0);
return object;
}
