OpenSolaris_b135/cmd/parted/ui.c
/*
parted - a frontend to libparted
Copyright (C) 1999, 2000, 2001, 2002, 2006, 2007
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <parted/parted.h>
#include <parted/debug.h>
#include <ctype.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <setjmp.h>
#include <config.h>
#include "command.h"
#include "strlist.h"
#include "ui.h"
#include "error.h"
#define N_(String) String
#if ENABLE_NLS
# include <libintl.h>
# include <locale.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
#endif /* ENABLE_NLS */
#ifdef HAVE_LIBREADLINE
#ifdef HAVE_TERMCAP_H
#include <termcap.h>
#else
extern int tgetnum (char* key);
#endif
#include <readline/readline.h>
#include <readline/history.h>
#ifndef HAVE_RL_COMPLETION_MATCHES
#define rl_completion_matches completion_matches
#endif
#ifndef rl_compentry_func_t
#define rl_compentry_func_t void
#endif
#endif /* HAVE_LIBREADLINE */
#ifndef SA_SIGINFO
# ifndef HAVE_SIGACTION
struct sigaction {
};
static inline int
sigaction (int signum, const struct* sigaction, struct* sigaction)
{
}
# endif /* HAVE_SIGACTON */
struct siginfo_t {
int si_code;
};
#endif /* SA_SIGINFO */
#ifndef SEGV_MAPERR
# define SEGV_MAPERR (INTMAX - 1)
#endif
#ifndef SEGV_ACCERR
# define SEGV_ACCERR (INTMAX - 2)
#endif
#ifndef FPE_INTDIV
# define FPE_INTDIV (INTMAX - 1)
#endif
#ifndef FPE_INTOVF
# define FPE_INTOVF (INTMAX - 2)
#endif
#ifndef FPE_FLTDIV
# define FPE_FLTDIV (INTMAX - 3)
#endif
#ifndef FPE_FLTOVF
# define FPE_FLTOVF (INTMAX - 4)
#endif
#ifndef FPE_FLTUND
# define FPE_FLTUND (INTMAX - 5)
#endif
#ifndef FPE_FLTRES
# define FPE_FLTRES (INTMAX - 6)
#endif
#ifndef FPE_FLTINV
# define FPE_FLTINV (INTMAX - 7)
#endif
#ifndef FPE_FLTSUB
# define FPE_FLTSUB (INTMAX - 8)
#endif
#ifndef ILL_ILLOPC
# define ILL_ILLOPC (INTMAX - 1)
#endif
#ifndef ILL_ILLOPN
# define ILL_ILLOPN (INTMAX - 2)
#endif
#ifndef ILL_ILLADR
# define ILL_ILLADR (INTMAX - 3)
#endif
#ifndef ILL_ILLTRP
# define ILL_ILLTRP (INTMAX - 4)
#endif
#ifndef ILL_PRVOPC
# define ILL_PRVOPC (INTMAX - 5)
#endif
#ifndef ILL_PRVREG
# define ILL_PRVREG (INTMAX - 6)
#endif
#ifndef ILL_COPROC
# define ILL_COPROC (INTMAX - 7)
#endif
#ifndef ILL_BADSTK
# define ILL_BADSTK (INTMAX - 8)
#endif
char* prog_name = "GNU Parted " VERSION "\n";
static char* banner_msg = N_(
"Welcome to GNU Parted! Type 'help' to view a list of commands.\n");
static char* usage_msg = N_(
"Usage: parted [OPTION]... [DEVICE [COMMAND [PARAMETERS]...]...]\n"
"Apply COMMANDs with PARAMETERS to DEVICE. If no COMMAND(s) are given, "
"run in\ninteractive mode.\n");
static char* bug_msg = N_(
"\n\nYou found a bug in GNU Parted! Here's what you have to do:\n\n"
"Don't panic! The bug has most likely not affected any of your data.\n"
"Help us to fix this bug by doing the following:\n\n"
"Check whether the bug has already been fixed by checking\n"
"the last version of GNU Parted that you can find at:\n\n"
"\thttp://ftp.gnu.org/gnu/parted/\n\n"
"Please check this version prior to bug reporting.\n\n"
"If this has not been fixed yet or if you don't know how to check,\n"
"please visit the GNU Parted website:\n\n"
"\thttp://www.gnu.org/software/parted\n\n"
"for further information.\n\n"
"Your report should contain the version of this release (%s)\n"
"along with the error message below, the output of\n\n"
"\tparted DEVICE unit co print unit s print\n\n"
"and the following history of commands you entered.\n"
"Also include any additional information about your setup you\n"
"consider important.\n");
#define MAX_WORDS 1024
static StrList* command_line;
static Command** commands;
static StrList* ex_opt_str [64];
static StrList* on_list;
static StrList* off_list;
static StrList* on_off_list;
static StrList* fs_type_list;
static StrList* disk_type_list;
static struct {
const StrList* possibilities;
const StrList* cur_pos;
int in_readline;
sigjmp_buf jmp_state;
} readline_state;
static struct sigaction sig_segv;
static struct sigaction sig_int;
static struct sigaction sig_fpe;
static struct sigaction sig_ill;
volatile int got_ctrl_c = 0; /* used in exception_handler */
int
screen_width ()
{
int width = 0;
if (opt_script_mode || pretend_input_tty)
return 32768; /* no wrapping ;) */
/* HACK: don't specify termcap separately - it'll annoy the users. */
#ifdef HAVE_LIBREADLINE
width = tgetnum ("co");
#endif
if (width <= 0)
width = 80;
return width;
}
void
wipe_line ()
{
if (opt_script_mode)
return;
/* yuck */
fputs ("\r "
" \r", stdout);
}
#ifdef HAVE_LIBREADLINE
/* returns matching commands for text */
static char*
command_generator (char* text, int state)
{
if (!state)
readline_state.cur_pos = readline_state.possibilities;
while (readline_state.cur_pos) {
const StrList* cur = readline_state.cur_pos;
readline_state.cur_pos = cur->next;
if (str_list_match_node (cur, text))
return str_list_convert_node (cur);
}
return NULL;
}
/* completion function for readline() */
char**
complete_function (char* text, int start, int end)
{
return rl_completion_matches (text,
(rl_compentry_func_t*) command_generator);
}
static void
_add_history_unique (const char* line)
{
HIST_ENTRY* last_entry = current_history ();
if (!strlen (line))
return;
if (!last_entry || strcmp (last_entry->line, line))
add_history ((char*) line);
}
/* Prints command history, to be used before aborting */
static void
_dump_history ()
{
int i = 0;
HIST_ENTRY** all_entries = history_list ();
fputs (_("\nCommand History:\n"), stdout);
while (all_entries[i]) {
puts(all_entries[i++]->line);
}
}
#else
/* Print nothing because Readline is absent. */
static inline void
_dump_history (void)
{
}
#endif /* HAVE_LIBREADLINE */
static void
mask_signal()
{
sigset_t curr;
sigset_t prev;
sigfillset(&curr);
sigprocmask(SIG_SETMASK, &curr, &prev);
}
/* Resets the environment by jumping to the initial state
* saved during ui intitialisation.
* Pass 1 as the parameter if you want to quit parted,
* 0 if you just want to reset to the command prompt.
*/
static void
reset_env (int quit)
{
int in_readline = readline_state.in_readline;
readline_state.in_readline = 0;
if (in_readline) {
putchar ('\n');
if (quit)
exit (0);
siglongjmp (readline_state.jmp_state, 1);
}
}
/* Signal handler for SIGINT using 'sigaction'. */
static void
sa_sigint_handler (int signum, siginfo_t* info, void *ucontext)
{
if (info)
sigaction (SIGINT, &sig_int, NULL);
got_ctrl_c = 1;
reset_env (0);
}
/* Signal handler for SIGINT using 'signal'. */
static void
s_sigint_handler (int signum)
{
signal (SIGINT, &s_sigint_handler);
mask_signal ();
sa_sigint_handler (signum, NULL, NULL);
}
/* Signal handler for SIGSEGV using 'sigaction'. */
static void
sa_sigsegv_handler (int signum, siginfo_t* info, void* ucontext)
{
printf (bug_msg, VERSION);
_dump_history ();
if (!info)
abort ();
sigaction (SIGSEGV, &sig_segv, NULL);
switch (info->si_code) {
case SEGV_MAPERR:
fputs(_("\nError: SEGV_MAPERR (Address not mapped "
"to object)\n"), stdout);
PED_ASSERT(0, break); /* Force a backtrace */
break;
case SEGV_ACCERR:
fputs(_("\nError: SEGV_ACCERR (Invalid permissions "
"for mapped object)\n"), stdout);
break;
default:
fputs(_("\nError: A general SIGSEGV signal was "
"encountered.\n"), stdout);
PED_ASSERT(0, break); /* Force a backtrace */
break;
}
abort ();
}
/* Signal handler for SIGSEGV using 'signal'. */
static void
s_sigsegv_handler (int signum)
{
signal (SIGSEGV, &s_sigsegv_handler);
mask_signal ();
sa_sigsegv_handler (signum, NULL, NULL);
}
/* Signal handler for SIGFPE using 'sigaction'. */
static void
sa_sigfpe_handler (int signum, siginfo_t* info, void* ucontext)
{
printf (bug_msg, VERSION);
_dump_history ();
if (!info)
abort ();
sigaction (SIGFPE, &sig_fpe, NULL);
switch (info->si_code) {
case FPE_INTDIV:
fputs(_("\nError: FPE_INTDIV (Integer: "
"divide by zero)"), stdout);
break;
case FPE_INTOVF:
fputs(_("\nError: FPE_INTOVF (Integer: "
"overflow)"), stdout);
break;
case FPE_FLTDIV:
fputs(_("\nError: FPE_FLTDIV (Float: "
"divide by zero)"), stdout);
break;
case FPE_FLTOVF:
fputs(_("\nError: FPE_FLTOVF (Float: "
"overflow)"), stdout);
break;
case FPE_FLTUND:
fputs(_("\nError: FPE_FLTUND (Float: "
"underflow)"), stdout);
break;
case FPE_FLTRES:
fputs(_("\nError: FPE_FLTRES (Float: "
"inexact result)"), stdout);
break;
case FPE_FLTINV:
fputs(_("\nError: FPE_FLTINV (Float: "
"invalid operation)"), stdout);
break;
case FPE_FLTSUB:
fputs(_("\nError: FPE_FLTSUB (Float: "
"subscript out of range)"), stdout);
break;
default:
fputs(_("\nError: A general SIGFPE signal "
"was encountered."), stdout);
break;
}
abort ();
}
/* Signal handler for SIGFPE using 'signal'. */
static void
s_sigfpe_handler (int signum)
{
signal (SIGFPE, &s_sigfpe_handler);
mask_signal ();
sa_sigfpe_handler (signum, NULL, NULL);
}
/* Signal handler for SIGILL using 'sigaction'. */
static void
sa_sigill_handler (int signum, siginfo_t* info, void* ucontext)
{
printf (bug_msg, VERSION);
_dump_history ();
if (!info)
abort();
sigaction (SIGILL, &sig_ill, NULL);
switch (info->si_code) {
case ILL_ILLOPC:
fputs(_("\nError: ILL_ILLOPC "
"(Illegal Opcode)"), stdout);
break;
case ILL_ILLOPN:
fputs(_("\nError: ILL_ILLOPN "
"(Illegal Operand)"), stdout);
break;
case ILL_ILLADR:
fputs(_("\nError: ILL_ILLADR "
"(Illegal addressing mode)"), stdout);
break;
case ILL_ILLTRP:
fputs(_("\nError: ILL_ILLTRP "
"(Illegal Trap)"), stdout);
break;
case ILL_PRVOPC:
fputs(_("\nError: ILL_PRVOPC "
"(Privileged Opcode)"), stdout);
break;
case ILL_PRVREG:
fputs(_("\nError: ILL_PRVREG "
"(Privileged Register)"), stdout);
break;
case ILL_COPROC:
fputs(_("\nError: ILL_COPROC "
"(Coprocessor Error)"), stdout);
break;
case ILL_BADSTK:
fputs(_("\nError: ILL_BADSTK "
"(Internal Stack Error)"), stdout);
break;
default:
fputs(_("\nError: A general SIGILL "
"signal was encountered."), stdout);
break;
}
abort ();
}
/* Signal handler for SIGILL using 'signal'. */
static void
s_sigill_handler (int signum)
{
signal (SIGILL, &s_sigill_handler);
mask_signal ();
sa_sigill_handler (signum, NULL, NULL);
}
static char*
_readline (const char* prompt, const StrList* possibilities)
{
char* line;
readline_state.possibilities = possibilities;
readline_state.cur_pos = NULL;
readline_state.in_readline = 1;
if (sigsetjmp (readline_state.jmp_state,1))
return NULL;
wipe_line ();
#ifdef HAVE_LIBREADLINE
if (!opt_script_mode) {
/* XXX: why isn't prompt const? */
line = readline ((char*) prompt);
if (line)
_add_history_unique (line);
} else
#endif
{
fputs (prompt, stdout);
fflush (stdout);
line = (char*) malloc (256);
if (fgets (line, 256, stdin) && strcmp (line, "") != 0) {
#ifndef HAVE_LIBREADLINE
/* Echo the input line, to be consistent with
how readline-5.2 works. */
fputs (line, stdout);
fflush (stdout);
#endif
line [strlen (line) - 1] = 0; /* kill trailing CR */
} else {
free (line);
line = NULL;
}
}
readline_state.in_readline = 0;
return line;
}
static PedExceptionOption
option_get_next (PedExceptionOption options, PedExceptionOption current)
{
PedExceptionOption i;
if (current == 0)
i = PED_EXCEPTION_OPTION_FIRST;
else
i = current * 2;
for (; i <= options; i *= 2) {
if (options & i)
return i;
}
return 0;
}
static void
_print_exception_text (PedException* ex)
{
StrList* text;
wipe_line ();
if (ex->type == PED_EXCEPTION_BUG) {
printf (bug_msg, VERSION);
text = str_list_create ("\n", ex->message, "\n\n", NULL);
} else {
text = str_list_create (
_(ped_exception_get_type_string (ex->type)),
": ", ex->message, "\n", NULL);
}
str_list_print_wrap (text, screen_width (), 0, 0);
str_list_destroy (text);
}
static PedExceptionOption
exception_handler (PedException* ex)
{
PedExceptionOption opt;
_print_exception_text (ex);
/* only one choice? Take it ;-) */
opt = option_get_next (ex->options, 0);
if (!option_get_next (ex->options, opt))
return opt;
/* script-mode: don't handle the exception */
if (opt_script_mode || (!isatty (0) && !pretend_input_tty))
return PED_EXCEPTION_UNHANDLED;
got_ctrl_c = 0;
do {
opt = command_line_get_ex_opt ("", ex->options);
} while (opt == PED_EXCEPTION_UNHANDLED
&& (isatty (0) || pretend_input_tty) && !got_ctrl_c);
if (got_ctrl_c) {
got_ctrl_c = 0;
opt = PED_EXCEPTION_UNHANDLED;
}
return opt;
}
void
command_line_push_word (const char* word)
{
command_line = str_list_append (command_line, word);
}
char*
command_line_pop_word ()
{
char* result;
StrList* next;
PED_ASSERT (command_line != NULL, return NULL);
result = str_list_convert_node (command_line);
next = command_line->next;
str_list_destroy_node (command_line);
command_line = next;
return result;
}
void
command_line_flush ()
{
str_list_destroy (command_line);
command_line = NULL;
}
char*
command_line_peek_word ()
{
if (command_line)
return str_list_convert_node (command_line);
else
return NULL;
}
int
command_line_get_word_count ()
{
return str_list_length (command_line);
}
static int
_str_is_spaces (const char* str)
{
while (isspace (*str))
str++;
return *str == 0;
}
/* "multi_word mode" is the "normal" mode... many words can be typed,
* delimited by spaces, etc.
* In single-word mode, only one word is parsed per line.
* Leading and trailing spaces are removed. For example: " a b c "
* is a single word "a b c". The motivation for this mode is partition
* names, etc. In single-word mode, the empty string is a word.
* (but not in multi-word mode).
*/
void
command_line_push_line (const char* line, int multi_word)
{
int quoted = 0;
char quote_char = 0;
char this_word [256];
int i;
do {
while (*line == ' ')
line++;
i = 0;
for (; *line; line++) {
if (*line == ' ' && !quoted) {
if (multi_word)
break;
/* single word: check for trailing spaces + eol */
if (_str_is_spaces (line))
break;
}
if (!quoted && strchr ("'\"", *line)) {
quoted = 1;
quote_char = *line;
continue;
}
if (quoted && *line == quote_char) {
quoted = 0;
continue;
}
/* hack: escape characters */
if (quoted && line[0] == '\\' && line[1])
line++;
this_word [i++] = *line;
}
if (i || !multi_word) {
this_word [i] = 0;
command_line_push_word (this_word);
}
} while (*line && multi_word);
}
static char*
realloc_and_cat (char* str, const char* append)
{
int length = strlen (str) + strlen (append) + 1;
char* new_str = realloc (str, length);
strcat (new_str, append);
return new_str;
}
static char*
_construct_prompt (const char* head, const char* def,
const StrList* possibilities)
{
char* prompt = strdup (head);
if (def && possibilities)
PED_ASSERT (str_list_match_any (possibilities, def),
return NULL);
if (possibilities && str_list_length (possibilities) < 8) {
const StrList* walk;
if (strlen (prompt))
prompt = realloc_and_cat (prompt, " ");
for (walk = possibilities; walk; walk = walk->next) {
if (walk != possibilities)
prompt = realloc_and_cat (prompt, "/");
if (def && str_list_match_node (walk, def) == 2) {
prompt = realloc_and_cat (prompt, "[");
prompt = realloc_and_cat (prompt, def);
prompt = realloc_and_cat (prompt, "]");
} else {
char* text = str_list_convert_node (walk);
prompt = realloc_and_cat (prompt, text);
free (text);
}
}
prompt = realloc_and_cat (prompt, "? ");
} else if (def) {
if (strlen (prompt))
prompt = realloc_and_cat (prompt, " ");
prompt = realloc_and_cat (prompt, "[");
prompt = realloc_and_cat (prompt, def);
prompt = realloc_and_cat (prompt, "]? ");
} else {
if (strlen (prompt))
prompt = realloc_and_cat (prompt, " ");
}
return prompt;
}
void
command_line_prompt_words (const char* prompt, const char* def,
const StrList* possibilities, int multi_word)
{
char* line;
char* real_prompt;
char* _def = (char*) def;
int _def_needs_free = 0;
if (!def && str_list_length (possibilities) == 1) {
_def = str_list_convert_node (possibilities);
_def_needs_free = 1;
}
if (opt_script_mode) {
if (_def)
command_line_push_line (_def, 0);
return;
}
do {
real_prompt = _construct_prompt (prompt, _def, possibilities);
line = _readline (real_prompt, possibilities);
free (real_prompt);
if (!line)
break;
if (!strlen (line)) {
if (_def)
command_line_push_line (_def, 0);
} else {
command_line_push_line (line, multi_word);
}
free (line);
} while (!command_line_get_word_count () && !_def);
if (_def_needs_free)
free (_def);
}
/**
* Get a word from command line.
*
* \param possibilities a StrList of valid strings, NULL if all are valid.
* \param multi_word whether multiple words are allowed.
*
* \return The word(s), or NULL if empty.
*/
char*
command_line_get_word (const char* prompt, const char* def,
const StrList* possibilities, int multi_word)
{
do {
if (command_line_get_word_count ()) {
char* result = command_line_pop_word ();
StrList* result_node;
if (!possibilities)
return result;
result_node = str_list_match (possibilities, result);
if (result_node == NULL)
error (0, 0, _("invalid token: %s"), result);
free (result);
if (result_node)
return str_list_convert_node (result_node);
command_line_flush ();
if (opt_script_mode)
return NULL;
}
command_line_prompt_words (prompt, def, possibilities,
multi_word);
} while (command_line_get_word_count ());
return NULL;
}
int
command_line_get_integer (const char* prompt, int* value)
{
char def_str [10];
char* input;
int valid;
snprintf (def_str, 10, "%d", *value);
input = command_line_get_word (prompt, *value ? def_str : NULL,
NULL, 1);
if (!input)
return 0;
valid = sscanf (input, "%d", value);
free (input);
return valid;
}
int
command_line_get_sector (const char* prompt, PedDevice* dev, PedSector* value,
PedGeometry** range)
{
char* def_str;
char* input;
int valid;
def_str = ped_unit_format (dev, *value);
input = command_line_get_word (prompt, *value ? def_str : NULL,
NULL, 1);
/* def_str might have rounded *value a little bit. If the user picked
* the default, make sure the selected sector is identical to the
* default.
*/
if (input && *value && !strcmp (input, def_str)) {
if (range) {
*range = ped_geometry_new (dev, *value, 1);
ped_free (def_str);
return *range != NULL;
}
ped_free (def_str);
return 1;
}
ped_free (def_str);
if (!input) {
*value = 0;
if (range)
*range = NULL;
return 0;
}
valid = ped_unit_parse (input, dev, value, range);
free (input);
return valid;
}
int
command_line_get_state (const char* prompt, int* value)
{
char* def_word;
char* input;
if (*value)
def_word = str_list_convert_node (on_list);
else
def_word = str_list_convert_node (off_list);
input = command_line_get_word (prompt, def_word, on_off_list, 1);
free (def_word);
if (!input)
return 0;
if (str_list_match_any (on_list, input))
*value = 1;
else
*value = 0;
free (input);
return 1;
}
int
command_line_get_device (const char* prompt, PedDevice** value)
{
char* def_dev_name = *value ? (*value)->path : NULL;
char* dev_name;
PedDevice* dev;
dev_name = command_line_get_word (prompt, def_dev_name, NULL, 1);
if (!dev_name)
return 0;
dev = ped_device_get (dev_name);
free (dev_name);
if (!dev)
return 0;
*value = dev;
return 1;
}
int
command_line_get_disk (const char* prompt, PedDisk** value)
{
PedDevice* dev = *value ? (*value)->dev : NULL;
if (!command_line_get_device (prompt, &dev))
return 0;
if (dev != (*value)->dev) {
PedDisk* new_disk = ped_disk_new (dev);
if (!new_disk)
return 0;
*value = new_disk;
}
return 1;
}
int
command_line_get_partition (const char* prompt, PedDisk* disk,
PedPartition** value)
{
PedPartition* part;
/* Flawed logic, doesn't seem to work?!
check = ped_disk_next_partition (disk, part);
part = ped_disk_next_partition (disk, check);
if (part == NULL) {
*value = check;
printf (_("The (only) primary partition has "
"been automatically selected\n"));
return 1;
} else {
*/
int num = (*value) ? (*value)->num : 0;
if (!command_line_get_integer (prompt, &num)) {
ped_exception_throw (PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("Expecting a partition number."));
return 0;
}
part = ped_disk_get_partition (disk, num);
if (!part) {
ped_exception_throw (PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("Partition doesn't exist."));
return 0;
}
*value = part;
return 1;
//}
}
int
command_line_get_fs_type (const char* prompt, const PedFileSystemType*(* value))
{
char* fs_type_name;
PedFileSystemType* fs_type;
fs_type_name = command_line_get_word (prompt,
*value ? (*value)->name : NULL,
fs_type_list, 1);
if (!fs_type_name) {
ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Expecting a file system type."));
return 0;
}
fs_type = ped_file_system_type_get (fs_type_name);
if (!fs_type) {
ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Unknown file system type \"%s\"."),
fs_type_name);
return 0;
}
free (fs_type_name);
*value = fs_type;
return 1;
}
int
command_line_get_disk_type (const char* prompt, const PedDiskType*(* value))
{
char* disk_type_name;
disk_type_name = command_line_get_word (prompt,
*value ? (*value)->name : NULL,
disk_type_list, 1);
if (!disk_type_name) {
ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Expecting a disk label type."));
return 0;
}
*value = ped_disk_type_get (disk_type_name);
free (disk_type_name);
PED_ASSERT (*value != NULL, return 0);
return 1;
}
int
command_line_get_part_flag (const char* prompt, const PedPartition* part,
PedPartitionFlag* flag)
{
StrList* opts = NULL;
PedPartitionFlag walk = 0;
char* flag_name;
while ( (walk = ped_partition_flag_next (walk)) ) {
if (ped_partition_is_flag_available (part, walk)) {
const char* walk_name;
walk_name = ped_partition_flag_get_name (walk);
opts = str_list_append (opts, walk_name);
opts = str_list_append_unique (opts, _(walk_name));
}
}
flag_name = command_line_get_word (prompt, NULL, opts, 1);
str_list_destroy (opts);
if (flag_name) {
*flag = ped_partition_flag_get_by_name (flag_name);
ped_free (flag_name);
return 1;
} else
return 0;
}
static int
_can_create_primary (const PedDisk* disk)
{
int i;
for (i = 1; i <= ped_disk_get_max_primary_partition_count (disk); i++) {
if (!ped_disk_get_partition (disk, i))
return 1;
}
return 0;
}
static int
_can_create_extended (const PedDisk* disk)
{
if (!_can_create_primary (disk))
return 0;
if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED))
return 0;
if (ped_disk_extended_partition (disk))
return 0;
return 1;
}
static int
_can_create_logical (const PedDisk* disk)
{
if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED))
return 0;
return ped_disk_extended_partition (disk) != 0;
}
int
command_line_get_part_type (const char* prompt, const PedDisk* disk,
PedPartitionType* type)
{
StrList* opts = NULL;
char* type_name;
if (_can_create_primary (disk)) {
opts = str_list_append_unique (opts, "primary");
opts = str_list_append_unique (opts, _("primary"));
}
if (_can_create_extended (disk)) {
opts = str_list_append_unique (opts, "extended");
opts = str_list_append_unique (opts, _("extended"));
}
if (_can_create_logical (disk)) {
opts = str_list_append_unique (opts, "logical");
opts = str_list_append_unique (opts, _("logical"));
}
if (!opts) {
ped_exception_throw (
PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Can't create any more partitions."));
return 0;
}
type_name = command_line_get_word (prompt, NULL, opts, 1);
str_list_destroy (opts);
if (!type_name) {
ped_exception_throw (
PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Expecting a partition type."));
return 0;
}
if (!strcmp (type_name, "primary")
|| !strcmp (type_name, _("primary"))) {
*type = 0;
}
if (!strcmp (type_name, "extended")
|| !strcmp (type_name, _("extended"))) {
*type = PED_PARTITION_EXTENDED;
}
if (!strcmp (type_name, "logical")
|| !strcmp (type_name, _("logical"))) {
*type = PED_PARTITION_LOGICAL;
}
free (type_name);
return 1;
}
PedExceptionOption
command_line_get_ex_opt (const char* prompt, PedExceptionOption options)
{
StrList* options_strlist = NULL;
PedExceptionOption opt;
char* opt_name;
for (opt = option_get_next (options, 0); opt;
opt = option_get_next (options, opt)) {
options_strlist = str_list_append_unique (options_strlist,
_(ped_exception_get_option_string (opt)));
options_strlist = str_list_append_unique (options_strlist,
ped_exception_get_option_string (opt));
}
opt_name = command_line_get_word (prompt, NULL, options_strlist, 1);
if (!opt_name)
return PED_EXCEPTION_UNHANDLED;
str_list_destroy (options_strlist);
opt = PED_EXCEPTION_OPTION_FIRST;
while (1) {
if (strcmp (opt_name,
ped_exception_get_option_string (opt)) == 0)
break;
if (strcmp (opt_name,
_(ped_exception_get_option_string (opt))) == 0)
break;
opt = option_get_next (options, opt);
}
free (opt_name);
return opt;
}
int
command_line_get_unit (const char* prompt, PedUnit* unit)
{
StrList* opts = NULL;
PedUnit walk;
char* unit_name;
const char* default_unit_name;
for (walk = PED_UNIT_FIRST; walk <= PED_UNIT_LAST; walk++)
opts = str_list_append (opts, ped_unit_get_name (walk));
default_unit_name = ped_unit_get_name (ped_unit_get_default ());
unit_name = command_line_get_word (prompt, default_unit_name, opts, 1);
str_list_destroy (opts);
if (unit_name) {
*unit = ped_unit_get_by_name (unit_name);
free (unit_name);
return 1;
} else
return 0;
}
int
command_line_is_integer ()
{
char* word;
int is_integer;
int scratch;
word = command_line_peek_word ();
if (!word)
return 0;
is_integer = sscanf (word, "%d", &scratch);
free (word);
return is_integer;
}
static int
init_ex_opt_str ()
{
int i;
PedExceptionOption opt;
for (i = 0; (1 << i) <= PED_EXCEPTION_OPTION_LAST; i++) {
opt = (1 << i);
ex_opt_str [i]
= str_list_create (
ped_exception_get_option_string (opt),
_(ped_exception_get_option_string (opt)),
NULL);
if (!ex_opt_str [i])
return 0;
}
ex_opt_str [i] = NULL;
return 1;
}
static void
done_ex_opt_str ()
{
int i;
for (i=0; ex_opt_str [i]; i++)
str_list_destroy (ex_opt_str [i]);
}
static int
init_state_str ()
{
on_list = str_list_create_unique (_("on"), "on", NULL);
off_list = str_list_create_unique (_("off"), "off", NULL);
on_off_list = str_list_join (str_list_duplicate (on_list),
str_list_duplicate (off_list));
return 1;
}
static void
done_state_str ()
{
str_list_destroy (on_list);
str_list_destroy (off_list);
str_list_destroy (on_off_list);
}
static int
init_fs_type_str ()
{
PedFileSystemType* walk;
fs_type_list = NULL;
for (walk = ped_file_system_type_get_next (NULL); walk;
walk = ped_file_system_type_get_next (walk))
{
fs_type_list = str_list_insert (fs_type_list, walk->name);
if (!fs_type_list)
return 0;
}
return 1;
}
static int
init_disk_type_str ()
{
PedDiskType* walk;
disk_type_list = NULL;
for (walk = ped_disk_type_get_next (NULL); walk;
walk = ped_disk_type_get_next (walk))
{
disk_type_list = str_list_insert (disk_type_list, walk->name);
if (!disk_type_list)
return 0;
}
return 1;
}
int
init_ui ()
{
if (!init_ex_opt_str ()
|| !init_state_str ()
|| !init_fs_type_str ()
|| !init_disk_type_str ())
return 0;
ped_exception_set_handler (exception_handler);
#ifdef HAVE_LIBREADLINE
rl_initialize ();
rl_attempted_completion_function = (CPPFunction*) complete_function;
readline_state.in_readline = 0;
#endif
#ifdef SA_SIGINFO
sigset_t curr;
sigfillset (&curr);
sig_segv.sa_sigaction = &sa_sigsegv_handler;
sig_int.sa_sigaction = &sa_sigint_handler;
sig_fpe.sa_sigaction = &sa_sigfpe_handler;
sig_ill.sa_sigaction = &sa_sigill_handler;
sig_segv.sa_mask =
sig_int.sa_mask =
sig_fpe.sa_mask =
sig_ill.sa_mask = curr;
sig_segv.sa_flags =
sig_int.sa_flags =
sig_fpe.sa_flags =
sig_ill.sa_flags = SA_SIGINFO;
sigaction (SIGSEGV, &sig_segv, NULL);
sigaction (SIGINT, &sig_int, NULL);
sigaction (SIGFPE, &sig_fpe, NULL);
sigaction (SIGILL, &sig_ill, NULL);
#else
signal (SIGSEGV, s_sigsegv_handler);
signal (SIGINT, s_sigint_handler);
signal (SIGFPE, s_sigfpe_handler);
signal (SIGILL, s_sigill_handler);
#endif /* SA_SIGINFO */
return 1;
}
void
done_ui ()
{
ped_exception_set_handler (NULL);
done_ex_opt_str ();
done_state_str ();
str_list_destroy (fs_type_list);
str_list_destroy (disk_type_list);
}
void
help_msg ()
{
fputs (_(usage_msg), stdout);
putchar ('\n');
fputs (_("OPTIONs:"), stdout);
putchar ('\n');
print_options_help ();
putchar ('\n');
fputs (_("COMMANDs:"), stdout);
putchar ('\n');
print_commands_help ();
exit (0);
}
void
print_using_dev (PedDevice* dev)
{
printf (_("Using %s\n"), dev->path);
}
int
interactive_mode (PedDevice** dev, Command* cmd_list[])
{
StrList* list;
StrList* command_names = command_get_names (cmd_list);
commands = cmd_list; /* FIXME yucky, nasty, evil hack */
fputs (prog_name, stdout);
print_using_dev (*dev);
list = str_list_create (_(banner_msg), NULL);
str_list_print_wrap (list, screen_width (), 0, 0);
str_list_destroy (list);
while (1) {
char* word;
Command* cmd;
while (!command_line_get_word_count ()) {
if (feof (stdin)) {
putchar ('\n');
return 1;
}
command_line_prompt_words ("(parted)", NULL,
command_names, 1);
}
word = command_line_pop_word ();
if (word) {
cmd = command_get (commands, word);
free (word);
if (cmd) {
if (!command_run (cmd, dev))
command_line_flush ();
} else
print_commands_help ();
}
}
return 1;
}
int
non_interactive_mode (PedDevice** dev, Command* cmd_list[],
int argc, char* argv[])
{
int i;
Command* cmd;
commands = cmd_list; /* FIXME yucky, nasty, evil hack */
for (i = 0; i < argc; i++)
command_line_push_line (argv [i], 1);
while (command_line_get_word_count ()) {
char* word;
word = command_line_pop_word ();
if (!word)
break;
cmd = command_get (commands, word);
free (word);
if (!cmd) {
help_msg ();
goto error;
}
if (!(cmd->non_interactive)) {
fputs(_("This command does not make sense in "
"non-interactive mode.\n"), stdout);
exit(1);
goto error;
}
if (!command_run (cmd, dev))
goto error;
}
return 1;
error:
return 0;
}