/* Perform conversion using the kernel method. */
void
kernel_conversion (struct config *config, char **cmdline, int cmdline_source)
{
const char *p;
/* Pre-conversion command. */
p = get_cmdline_key (cmdline, "p2v.pre");
if (p)
run_command ("p2v.pre", p);
/* Connect to and interrogate virt-v2v on the conversion server. */
p = get_cmdline_key (cmdline, "p2v.skip_test_connection");
if (!p) {
wait_network_online (config);
if (test_connection (config) == -1) {
const char *err = get_ssh_error ();
error (EXIT_FAILURE, 0,
"error opening control connection to %s:%d: %s",
config->remote.server, config->remote.port, err);
}
}
/* Some disks must have been specified for conversion. */
if (config->disks == NULL || guestfs_int_count_strings (config->disks) == 0)
error (EXIT_FAILURE, 0,
"no non-removable disks were discovered on this machine.\n"
"virt-p2v looked in /sys/block and in p2v.disks on the kernel command line.\n"
"This is a fatal error and virt-p2v cannot continue.");
/* Perform the conversion in text mode. */
if (start_conversion (config, notify_ui_callback) == -1) {
const char *err = get_conversion_error ();
fprintf (stderr, "%s: error during conversion: %s\n",
getprogname (), err);
p = get_cmdline_key (cmdline, "p2v.fail");
if (p)
run_command ("p2v.fail", p);
exit (EXIT_FAILURE);
}
ansi_green (stdout);
printf ("Conversion finished successfully.");
ansi_restore (stdout);
putchar ('\n');
p = get_cmdline_key (cmdline, "p2v.post");
if (!p) {
if (geteuid () == 0 && cmdline_source == CMDLINE_SOURCE_PROC_CMDLINE)
p = "poweroff";
}
if (p)
run_command ("p2v.post", p);
}
static void ipobble_DrawScene()
{
char s[24];
draw_podzilla(podzilla_bmp_var);
me_draw(current_angle);
draw_ball(new_ball_x, new_ball_y, new_ball_type, new_ball_type);
draw_ball(current_ball_x, current_ball_y, current_ball_type,
current_ball_type);
if(ball_firing){
/* first 'white' the ball */
GrSetGCForeground(ipobble_gc, WHITE);
draw_ball(ball_x,ball_y,ball_type, -1);
/* now test if bumping */
if((ball_x + (float)BALL_WIDTH) >= (float)BRD_MAXX ||
(ball_x - 2) <= (float)BRD_MINX)
ball_vx=-ball_vx;
ball_x+=ball_vx;
ball_y+=ball_vy;
/* now test if attaching */
/* if yes set flag to test new 4s... */
GrSetGCForeground(ipobble_gc, BLACK);
draw_ball(ball_x,ball_y,ball_type, ball_type);
if(test_collision()==1){
boards_ball_draw(0);
test_connection(level_connection);
}
} else {
fire_counter--;
if(fire_counter * DELTA_TIME % 100 == 0) {
sprintf(s, "time: %.3d", fire_counter *
DELTA_TIME / 100);
GrText(ipobble_wid,ipobble_gc,
screen_info.cols - 50, screen_info.rows -
HEADER_TOPLINE - 15, s, -1, GR_TFASCII);
}
if(fire_counter <= 0)
do_fire();
}
}
/*-------
* ConfigDlgProc
* Description: Manage add data source name dialog
* Input : hdlg --- Dialog window handle
* wMsg --- Message
* wParam - Message parameter
* lParam - Message parameter
* Output : TRUE if message processed, FALSE otherwise
*-------
*/
LRESULT CALLBACK
ConfigDlgProc(HWND hdlg,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
LPSETUPDLG lpsetupdlg;
ConnInfo *ci;
DWORD cmd;
char strbuf[64];
switch (wMsg)
{
/* Initialize the dialog */
case WM_INITDIALOG:
lpsetupdlg = (LPSETUPDLG) lParam;
ci = &lpsetupdlg->ci;
/* Hide the driver connect message */
ShowWindow(GetDlgItem(hdlg, DRV_MSG_LABEL), SW_HIDE);
LoadString(s_hModule, IDS_ADVANCE_SAVE, strbuf, sizeof(strbuf));
SetWindowText(GetDlgItem(hdlg, IDOK), strbuf);
SetWindowLongPtr(hdlg, DWLP_USER, lParam);
CenterDialog(hdlg); /* Center dialog */
/*
* NOTE: Values supplied in the attribute string will always
*/
/* override settings in ODBC.INI */
copy_globals(&ci->drivers, &globals);
/* Get the rest of the common attributes */
getDSNinfo(ci, CONN_DONT_OVERWRITE);
/* Fill in any defaults */
getDSNdefaults(ci);
/* Initialize dialog fields */
SetDlgStuff(hdlg, ci);
/* Save drivername */
if (!(lpsetupdlg->ci.drivername[0]))
lstrcpy(lpsetupdlg->ci.drivername, lpsetupdlg->lpszDrvr);
if (lpsetupdlg->fNewDSN || !ci->dsn[0])
ShowWindow(GetDlgItem(hdlg, IDC_MANAGEDSN), SW_HIDE);
if (lpsetupdlg->fDefault)
{
EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
}
else
SendDlgItemMessage(hdlg, IDC_DSNAME,
EM_LIMITTEXT, (WPARAM) (MAXDSNAME - 1), 0L);
SendDlgItemMessage(hdlg, IDC_DESC,
EM_LIMITTEXT, (WPARAM) (MAXDESC - 1), 0L);
return TRUE; /* Focus was not set */
/* Process buttons */
case WM_COMMAND:
switch (cmd = GET_WM_COMMAND_ID(wParam, lParam))
{
/*
* Ensure the OK button is enabled only when a data
* source name
*/
/* is entered */
case IDC_DSNAME:
if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE)
{
char szItem[MAXDSNAME]; /* Edit control text */
/* Enable/disable the OK button */
EnableWindow(GetDlgItem(hdlg, IDOK),
GetDlgItemText(hdlg, IDC_DSNAME,
szItem, sizeof(szItem)));
return TRUE;
}
break;
/* Accept results */
case IDOK:
case IDAPPLY:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
/* Retrieve dialog values */
if (!lpsetupdlg->fDefault)
GetDlgItemText(hdlg, IDC_DSNAME,
lpsetupdlg->ci.dsn,
sizeof(lpsetupdlg->ci.dsn));
/* Get Dialog Values */
GetDlgStuff(hdlg, &lpsetupdlg->ci);
/* Update ODBC.INI */
SetDSNAttributes(hdlg, lpsetupdlg, NULL);
if (IDAPPLY == cmd)
break;
/* Return to caller */
case IDCANCEL:
EndDialog(hdlg, wParam);
return TRUE;
case IDC_TEST:
{
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
if (NULL != lpsetupdlg)
{
/* Get Dialog Values */
GetDlgStuff(hdlg, &lpsetupdlg->ci);
test_connection(lpsetupdlg->hwndParent, &lpsetupdlg->ci, FALSE);
return TRUE;
}
break;
}
case IDC_DATASOURCE:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_DRV),
hdlg, ds_options1Proc, (LPARAM) &lpsetupdlg->ci);
return TRUE;
case IDC_DRIVER:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_GLOBAL),
hdlg, global_optionsProc, (LPARAM) &lpsetupdlg->ci);
return TRUE;
case IDC_MANAGEDSN:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
if (DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_DRIVER_CHANGE),
hdlg, manage_dsnProc,
(LPARAM) lpsetupdlg) > 0)
EndDialog(hdlg, 0);
return TRUE;
}
break;
case WM_CTLCOLORSTATIC:
if (lParam == (LPARAM)GetDlgItem(hdlg, IDC_NOTICE_USER))
{
HBRUSH hBrush = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
SetTextColor((HDC)wParam, RGB(255, 0, 0));
return (LRESULT)hBrush;
}
break;
}
/* Message not processed */
return FALSE;
}
void
kernel_configuration (struct config *config, char **cmdline, int cmdline_source)
{
const char *p;
p = get_cmdline_key (cmdline, "p2v.pre");
if (p)
run_command (config->verbose, "p2v.pre", p);
p = get_cmdline_key (cmdline, "p2v.server");
assert (p); /* checked by caller */
free (config->server);
config->server = strdup (p);
p = get_cmdline_key (cmdline, "p2v.port");
if (p) {
if (sscanf (p, "%d", &config->port) != 1) {
fprintf (stderr, "%s: cannot parse p2v.port from kernel command line",
guestfs_int_program_name);
exit (EXIT_FAILURE);
}
}
p = get_cmdline_key (cmdline, "p2v.username");
if (p) {
free (config->username);
config->username = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.password");
if (p) {
free (config->password);
config->password = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.identity");
if (p) {
free (config->identity_url);
config->identity_url = strdup (p);
config->identity_file_needs_update = 1;
}
p = get_cmdline_key (cmdline, "p2v.sudo");
if (p)
config->sudo = 1;
/* We should now be able to connect and interrogate virt-v2v
* on the conversion server.
*/
p = get_cmdline_key (cmdline, "p2v.skip_test_connection");
if (!p) {
wait_network_online (config);
if (test_connection (config) == -1) {
const char *err = get_ssh_error ();
fprintf (stderr, "%s: error opening control connection to %s:%d: %s\n",
guestfs_int_program_name, config->server, config->port, err);
exit (EXIT_FAILURE);
}
}
p = get_cmdline_key (cmdline, "p2v.name");
if (p) {
free (config->guestname);
config->guestname = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.vcpus");
if (p) {
if (sscanf (p, "%d", &config->vcpus) != 1) {
fprintf (stderr, "%s: cannot parse p2v.vcpus from kernel command line\n",
guestfs_int_program_name);
exit (EXIT_FAILURE);
}
}
p = get_cmdline_key (cmdline, "p2v.memory");
if (p) {
char mem_code;
if (sscanf (p, "%" SCNu64 "%c", &config->memory, &mem_code) != 2) {
fprintf (stderr, "%s: cannot parse p2v.memory from kernel command line\n",
guestfs_int_program_name);
exit (EXIT_FAILURE);
}
config->memory *= 1024;
if (mem_code == 'M' || mem_code == 'm'
|| mem_code == 'G' || mem_code == 'g')
config->memory *= 1024;
if (mem_code == 'G' || mem_code == 'g')
config->memory *= 1024;
if (mem_code != 'M' && mem_code != 'm'
&& mem_code != 'G' && mem_code != 'g') {
fprintf (stderr, "%s: p2v.memory on kernel command line must be followed by 'G' or 'M'\n",
guestfs_int_program_name);
exit (EXIT_FAILURE);
}
}
p = get_cmdline_key (cmdline, "p2v.disks");
if (p) {
CLEANUP_FREE char *t;
t = strdup (p);
guestfs_int_free_string_list (config->disks);
config->disks = guestfs_int_split_string (',', t);
}
p = get_cmdline_key (cmdline, "p2v.removable");
if (p) {
CLEANUP_FREE char *t;
t = strdup (p);
guestfs_int_free_string_list (config->removable);
config->removable = guestfs_int_split_string (',', t);
}
p = get_cmdline_key (cmdline, "p2v.interfaces");
if (p) {
CLEANUP_FREE char *t;
t = strdup (p);
guestfs_int_free_string_list (config->interfaces);
config->interfaces = guestfs_int_split_string (',', t);
}
p = get_cmdline_key (cmdline, "p2v.network");
if (p) {
CLEANUP_FREE char *t;
t = strdup (p);
guestfs_int_free_string_list (config->network_map);
config->network_map = guestfs_int_split_string (',', t);
}
p = get_cmdline_key (cmdline, "p2v.o");
if (p) {
free (config->output);
config->output = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.oa");
if (p) {
if (STREQ (p, "sparse"))
config->output_allocation = OUTPUT_ALLOCATION_SPARSE;
else if (STREQ (p, "preallocated"))
config->output_allocation = OUTPUT_ALLOCATION_PREALLOCATED;
else
fprintf (stderr, "%s: warning: don't know what p2v.oa=%s means\n",
guestfs_int_program_name, p);
}
p = get_cmdline_key (cmdline, "p2v.oc");
if (p) {
free (config->output_connection);
config->output_connection = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.of");
if (p) {
free (config->output_format);
config->output_format = strdup (p);
}
p = get_cmdline_key (cmdline, "p2v.os");
if (p) {
free (config->output_storage);
config->output_storage = strdup (p);
}
/* Undocumented command line tool used for testing command line parsing. */
p = get_cmdline_key (cmdline, "p2v.dump_config_and_exit");
if (p) {
print_config (config, stdout);
exit (EXIT_SUCCESS);
}
/* Some disks must have been specified for conversion. */
if (config->disks == NULL || guestfs_int_count_strings (config->disks) == 0) {
fprintf (stderr, "%s: error: no non-removable disks were discovered on this machine.\n",
guestfs_int_program_name);
fprintf (stderr, "virt-p2v looked in /sys/block and in p2v.disks on the kernel command line.\n");
fprintf (stderr, "This is a fatal error and virt-p2v cannot continue.\n");
exit (EXIT_FAILURE);
}
/* Perform the conversion in text mode. */
if (start_conversion (config, notify_ui_callback) == -1) {
const char *err = get_conversion_error ();
fprintf (stderr, "%s: error during conversion: %s\n",
guestfs_int_program_name, err);
p = get_cmdline_key (cmdline, "p2v.fail");
if (p)
run_command (config->verbose, "p2v.fail", p);
exit (EXIT_FAILURE);
}
p = get_cmdline_key (cmdline, "p2v.post");
if (!p) {
if (geteuid () == 0 && cmdline_source == CMDLINE_SOURCE_PROC_CMDLINE)
p = "poweroff";
}
if (p)
run_command (config->verbose, "p2v.post", p);
}
