int main()
{
check_xml("<node attr='value'><child>text</child></node>");
check_xml("<node attr='value'><child>text</chil></node>");
check_xml("<node attr='value'><child>text</child>");
check_xml("<node attr='value\"><child>text</child></node>");
check_xml("<node attr='value'><#tag /></node>");
}
static void test_domain_device_network(void)
{
GVirConfigDomain *domain;
GVirConfigDomainInterface *interface;
domain = gvir_config_domain_new();
interface = GVIR_CONFIG_DOMAIN_INTERFACE(gvir_config_domain_interface_network_new());
gvir_config_domain_interface_network_set_source(GVIR_CONFIG_DOMAIN_INTERFACE_NETWORK(interface),
"default");
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(interface));
g_object_unref(G_OBJECT(interface));
interface = GVIR_CONFIG_DOMAIN_INTERFACE(gvir_config_domain_interface_user_new());
gvir_config_domain_interface_set_ifname(interface, "eth0");
gvir_config_domain_interface_set_link_state(interface,
GVIR_CONFIG_DOMAIN_INTERFACE_LINK_STATE_UP);
gvir_config_domain_interface_set_mac(interface, "00:11:22:33:44:55");
gvir_config_domain_interface_set_model(interface, "foo");
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(interface));
g_object_unref(G_OBJECT(interface));
check_xml(domain, "gconfig-domain-device-network.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_filesystem(void)
{
GVirConfigDomain *domain;
GVirConfigDomainFilesys *fs;
domain = gvir_config_domain_new();
fs = gvir_config_domain_filesys_new();
gvir_config_domain_filesys_set_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_FILE);
gvir_config_domain_filesys_set_access_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_MAPPED);
gvir_config_domain_filesys_set_driver_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_NBD);
gvir_config_domain_filesys_set_driver_format(fs, GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW2);
gvir_config_domain_filesys_set_source(fs, "/path/to/source");
gvir_config_domain_filesys_set_target(fs, "/path/to/target1");
gvir_config_domain_filesys_set_readonly(fs, TRUE);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(fs));
g_object_unref(fs);
/* Add a RAM fs */
fs = gvir_config_domain_filesys_new();
gvir_config_domain_filesys_set_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_RAM);
gvir_config_domain_filesys_set_access_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_ACCESS_PASSTHROUGH);
gvir_config_domain_filesys_set_driver_type(fs, GVIR_CONFIG_DOMAIN_FILESYS_DRIVER_PATH);
gvir_config_domain_filesys_set_ram_usage(fs, 1234);
gvir_config_domain_filesys_set_target(fs, "/path/to/target2");
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(fs));
g_object_unref(fs);
check_xml(domain, "gconfig-domain-device-filesys.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_input(void)
{
GVirConfigDomain *domain;
GVirConfigDomainInput *input;
GList *inputs;
domain = gvir_config_domain_new();
input = gvir_config_domain_input_new();
gvir_config_domain_input_set_device_type(input,
GVIR_CONFIG_DOMAIN_INPUT_DEVICE_TABLET);
gvir_config_domain_input_set_bus(input, GVIR_CONFIG_DOMAIN_INPUT_BUS_USB);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(input));
g_object_unref(G_OBJECT(input));
check_xml(domain, "gconfig-domain-device-input.xml");
inputs = get_devices_by_type(domain, GVIR_CONFIG_TYPE_DOMAIN_INPUT);
g_assert_cmpint(g_list_length(inputs), ==, 1);
g_assert(GVIR_CONFIG_IS_DOMAIN_INPUT(inputs->data));
input = GVIR_CONFIG_DOMAIN_INPUT(inputs->data);
g_assert_cmpint(gvir_config_domain_input_get_device_type(input), ==, GVIR_CONFIG_DOMAIN_INPUT_DEVICE_TABLET);
g_assert_cmpint(gvir_config_domain_input_get_bus(input), ==, GVIR_CONFIG_DOMAIN_INPUT_BUS_USB);
g_list_free_full(inputs, g_object_unref);
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_disk(void)
{
GVirConfigDomain *domain;
GVirConfigDomainDisk *disk;
GVirConfigDomainDiskDriver *driver;
GList *disks;
domain = gvir_config_domain_new();
driver = gvir_config_domain_disk_driver_new();
gvir_config_domain_disk_driver_set_name(driver, "foo");
gvir_config_domain_disk_driver_set_format(driver, GVIR_CONFIG_DOMAIN_DISK_FORMAT_BOCHS);
gvir_config_domain_disk_driver_set_name(driver, "qemu");
gvir_config_domain_disk_driver_set_cache(driver, GVIR_CONFIG_DOMAIN_DISK_CACHE_NONE);
gvir_config_domain_disk_driver_set_format(driver, GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW2);
gvir_config_domain_disk_driver_set_copy_on_read(driver, TRUE);
disk = gvir_config_domain_disk_new();
gvir_config_domain_disk_set_type(disk, GVIR_CONFIG_DOMAIN_DISK_FILE);
gvir_config_domain_disk_set_guest_device_type(disk, GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_DISK);
gvir_config_domain_disk_set_source(disk, "/tmp/foo/bar");
gvir_config_domain_disk_set_startup_policy (disk, GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_REQUISITE);
gvir_config_domain_disk_set_target_bus(disk, GVIR_CONFIG_DOMAIN_DISK_BUS_IDE);
gvir_config_domain_disk_set_target_dev(disk, "hda");
gvir_config_domain_disk_set_driver(disk, driver);
g_object_unref(G_OBJECT(driver));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(disk));
g_object_unref(disk);
check_xml(domain, "gconfig-domain-device-disk.xml");
disks = get_devices_by_type(domain, GVIR_CONFIG_TYPE_DOMAIN_DISK);
g_assert_cmpint(g_list_length(disks), ==, 1);
g_assert(GVIR_CONFIG_IS_DOMAIN_DISK(disks->data));
disk = GVIR_CONFIG_DOMAIN_DISK(disks->data);
g_assert_cmpint(gvir_config_domain_disk_get_disk_type(disk), ==, GVIR_CONFIG_DOMAIN_DISK_FILE);
g_assert_cmpint(gvir_config_domain_disk_get_guest_device_type(disk), ==, GVIR_CONFIG_DOMAIN_DISK_GUEST_DEVICE_DISK);
g_assert_cmpint(gvir_config_domain_disk_get_startup_policy (disk), ==, GVIR_CONFIG_DOMAIN_DISK_STARTUP_POLICY_REQUISITE);
g_assert_cmpstr(gvir_config_domain_disk_get_source(disk), ==, "/tmp/foo/bar");
driver = gvir_config_domain_disk_get_driver(disk);
g_assert(driver != NULL);
g_assert_cmpint(gvir_config_domain_disk_driver_get_cache(driver), ==, GVIR_CONFIG_DOMAIN_DISK_CACHE_NONE);
g_assert_cmpstr(gvir_config_domain_disk_driver_get_name(driver), ==, "qemu");
g_assert_cmpint(gvir_config_domain_disk_driver_get_format(driver), ==, GVIR_CONFIG_DOMAIN_DISK_FORMAT_QCOW2);
g_assert(gvir_config_domain_disk_driver_get_copy_on_read(driver));
g_assert_cmpint(gvir_config_domain_disk_get_target_bus(disk), ==, GVIR_CONFIG_DOMAIN_DISK_BUS_IDE);
g_assert_cmpstr(gvir_config_domain_disk_get_target_dev(disk), ==, "hda");
g_object_unref(G_OBJECT(driver));
gvir_config_domain_disk_set_driver(disk, NULL);
driver = gvir_config_domain_disk_get_driver(disk);
g_assert(driver == NULL);
g_list_free_full(disks, g_object_unref);
g_object_unref(G_OBJECT(domain));
}
static void test_domain_clock(void)
{
GVirConfigDomain *domain;
GVirConfigDomainClock *klock;
GVirConfigDomainTimerPit *pit;
GVirConfigDomainTimerRtc *rtc;
GVirConfigDomainTimerHpet *hpet;
domain = gvir_config_domain_new();
klock = gvir_config_domain_clock_new();
gvir_config_domain_clock_set_offset(klock, GVIR_CONFIG_DOMAIN_CLOCK_TIMEZONE);
gvir_config_domain_clock_set_timezone(klock, "CEST");
g_assert_cmpint(gvir_config_domain_clock_get_offset(klock), ==, GVIR_CONFIG_DOMAIN_CLOCK_TIMEZONE);
g_assert_cmpstr(gvir_config_domain_clock_get_timezone(klock), ==, "CEST");
pit = gvir_config_domain_timer_pit_new();
gvir_config_domain_timer_set_tick_policy(GVIR_CONFIG_DOMAIN_TIMER(pit),
GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DELAY);
gvir_config_domain_clock_add_timer(klock, GVIR_CONFIG_DOMAIN_TIMER(pit));
g_assert_cmpint(gvir_config_domain_timer_get_tick_policy(GVIR_CONFIG_DOMAIN_TIMER(pit)), ==, GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_DELAY);
g_assert(gvir_config_domain_timer_get_present(GVIR_CONFIG_DOMAIN_TIMER(pit)) != FALSE);
g_object_unref(G_OBJECT(pit));
rtc = gvir_config_domain_timer_rtc_new();
gvir_config_domain_timer_set_tick_policy(GVIR_CONFIG_DOMAIN_TIMER(rtc),
GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_CATCHUP);
gvir_config_domain_clock_add_timer(klock, GVIR_CONFIG_DOMAIN_TIMER(rtc));
g_assert_cmpint(gvir_config_domain_timer_get_tick_policy(GVIR_CONFIG_DOMAIN_TIMER(rtc)), ==, GVIR_CONFIG_DOMAIN_TIMER_TICK_POLICY_CATCHUP);
g_assert(gvir_config_domain_timer_get_present(GVIR_CONFIG_DOMAIN_TIMER(rtc)) != FALSE);
g_object_unref(G_OBJECT(rtc));
hpet = gvir_config_domain_timer_hpet_new();
gvir_config_domain_timer_set_present(GVIR_CONFIG_DOMAIN_TIMER(hpet), FALSE);
gvir_config_domain_clock_add_timer(klock, GVIR_CONFIG_DOMAIN_TIMER(hpet));
g_assert(gvir_config_domain_timer_get_present(GVIR_CONFIG_DOMAIN_TIMER(hpet)) == FALSE);
g_object_unref(G_OBJECT(hpet));
gvir_config_domain_set_clock(domain, klock);
g_object_unref(G_OBJECT(klock));
klock = gvir_config_domain_get_clock(domain);
g_assert(klock != NULL);
g_assert_cmpint(gvir_config_domain_clock_get_offset(klock), ==, GVIR_CONFIG_DOMAIN_CLOCK_TIMEZONE);
g_assert_cmpstr(gvir_config_domain_clock_get_timezone(klock), ==, "CEST");
g_object_unref(G_OBJECT(klock));
/* FIXME: gvir_config_domain_clock_get_timers() */
check_xml(domain, "gconfig-domain-clock.xml");
gvir_config_domain_set_clock(domain, NULL);
klock = gvir_config_domain_get_clock(domain);
g_assert(klock == NULL);
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_usb_redir(void)
{
GVirConfigDomain *domain;
domain = gvir_config_domain_new();
/* spice usb redirection */
GVirConfigDomainControllerUsb *ehci;
GVirConfigDomainControllerUsb *uhci1;
GVirConfigDomainControllerUsb *uhci2;
GVirConfigDomainControllerUsb *uhci3;
GVirConfigDomainRedirdev *redirdev;
ehci = domain_device_usb_redir_create_usb_controller(GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_EHCI1,
1, NULL, 0, 0, 0, 8, 7, FALSE);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(ehci));
uhci1 = domain_device_usb_redir_create_usb_controller(GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI1,
7, ehci, 0, 0, 0, 8, 0, TRUE);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(uhci1));
uhci2 = domain_device_usb_redir_create_usb_controller(GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI2,
7, ehci, 2, 0, 0, 8, 1, FALSE);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(uhci2));
uhci3 = domain_device_usb_redir_create_usb_controller(GVIR_CONFIG_DOMAIN_CONTROLLER_USB_MODEL_ICH9_UHCI3,
7, ehci, 4, 0, 0, 8, 2, FALSE);
g_assert_cmpint(gvir_config_domain_controller_get_index(GVIR_CONFIG_DOMAIN_CONTROLLER(uhci1)), ==, 1);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(uhci3));
g_object_unref(G_OBJECT(uhci1));
g_object_unref(G_OBJECT(uhci2));
g_object_unref(G_OBJECT(uhci3));
g_object_unref(G_OBJECT(ehci));
/* three redirdev channels allows to redirect a maximum of 3 USB
* devices at a time. The address which create_redirdev assigns to the
* redirdev object is optional
*/
redirdev = domain_device_usb_redir_create_redirdev(0, 3);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(redirdev));
g_object_unref(G_OBJECT(redirdev));
redirdev = domain_device_usb_redir_create_redirdev(0, 4);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(redirdev));
g_object_unref(G_OBJECT(redirdev));
redirdev = domain_device_usb_redir_create_redirdev(0, 5);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(redirdev));
g_object_unref(G_OBJECT(redirdev));
check_xml(domain, "gconfig-domain-device-usbredir.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_channel(void)
{
GVirConfigDomain *domain;
domain = gvir_config_domain_new();
/* spice agent channel */
GVirConfigDomainChannel *channel;
GVirConfigDomainChardevSourceSpiceVmc *spicevmc;
GVirConfigDomainChardevSourceSpicePort *spiceport;
GVirConfigDomainChardevSourceUnix *unix_source;
channel = gvir_config_domain_channel_new();
gvir_config_domain_channel_set_target_type(channel,
GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_VIRTIO);
spicevmc = gvir_config_domain_chardev_source_spicevmc_new();
gvir_config_domain_chardev_set_source(GVIR_CONFIG_DOMAIN_CHARDEV(channel),
GVIR_CONFIG_DOMAIN_CHARDEV_SOURCE(spicevmc));
g_object_unref(G_OBJECT(spicevmc));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(channel));
g_object_unref(G_OBJECT(channel));
channel = gvir_config_domain_channel_new();
gvir_config_domain_channel_set_target_type(channel,
GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_VIRTIO);
gvir_config_domain_channel_set_target_name(channel,
"org.spice-space.webdav.0");
spiceport = gvir_config_domain_chardev_source_spiceport_new();
gvir_config_domain_chardev_source_spiceport_set_channel(spiceport, "org.spice-space.webdav.0");
gvir_config_domain_chardev_set_source(GVIR_CONFIG_DOMAIN_CHARDEV(channel),
GVIR_CONFIG_DOMAIN_CHARDEV_SOURCE(spiceport));
g_object_unref(G_OBJECT(spiceport));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(channel));
g_object_unref(G_OBJECT(channel));
channel = gvir_config_domain_channel_new();
gvir_config_domain_channel_set_target_type(channel,
GVIR_CONFIG_DOMAIN_CHANNEL_TARGET_VIRTIO);
gvir_config_domain_channel_set_target_name(channel, "org.qemu.guest_agent.0");
unix_source = gvir_config_domain_chardev_source_unix_new();
gvir_config_domain_chardev_set_source(GVIR_CONFIG_DOMAIN_CHARDEV(channel),
GVIR_CONFIG_DOMAIN_CHARDEV_SOURCE(unix_source));
g_object_unref(G_OBJECT(unix_source));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(channel));
g_object_unref(G_OBJECT(channel));
check_xml(domain, "gconfig-domain-device-channel.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain(void)
{
GVirConfigDomain *domain;
const char *features[] = { "foo", "bar", "baz", NULL };
GStrv feat;
unsigned int i;
domain = gvir_config_domain_new();
g_assert(domain != NULL);
gvir_config_domain_set_virt_type(domain, GVIR_CONFIG_DOMAIN_VIRT_KVM);
g_assert_cmpint(gvir_config_domain_get_virt_type(domain), ==, GVIR_CONFIG_DOMAIN_VIRT_KVM);
gvir_config_domain_set_name(domain, "foo");
g_assert_cmpstr(gvir_config_domain_get_name(domain), ==, "foo");
gvir_config_domain_set_memory(domain, 1234);
g_assert_cmpint(gvir_config_domain_get_memory(domain), ==, 1234);
gvir_config_domain_set_vcpus(domain, 3);
g_assert_cmpint(gvir_config_domain_get_vcpus(domain), ==, 3);
gvir_config_domain_set_features(domain, (const GStrv)features);
feat = gvir_config_domain_get_features(domain);
for (i = 0; features[i] != NULL; i++) {
g_assert(feat[i] != NULL);
g_assert_cmpstr(feat[i], ==, features[i]);
}
g_strfreev(feat);
gvir_config_domain_set_lifecycle(domain,
GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_POWEROFF,
GVIR_CONFIG_DOMAIN_LIFECYCLE_RESTART);
gvir_config_domain_set_custom_xml(domain, "<foo/>", "ns", "http://foo", NULL);
gvir_config_domain_set_custom_xml(domain, "<foo/>", "nsbar", "http://bar", NULL);
gvir_config_domain_set_custom_xml(domain, "<foo/>", "ns", "http://bar", NULL);
gvir_config_domain_set_custom_xml(domain, "<bar/>", "ns", "http://foo", NULL);
g_assert_cmpstr_free1(gvir_config_domain_get_custom_xml(domain, "http://foo"), ==, "<ns:bar xmlns:ns=\"http://foo\"/>");
g_assert_cmpstr_free1(gvir_config_domain_get_custom_xml(domain, "http://bar"), ==, "<ns:foo xmlns:ns=\"http://bar\"/>");
check_xml(domain, "gconfig-domain.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_sound(void)
{
GVirConfigDomain *domain;
domain = gvir_config_domain_new();
/* sound node */
GVirConfigDomainSound *sound;
sound = gvir_config_domain_sound_new();
gvir_config_domain_sound_set_model(sound,
GVIR_CONFIG_DOMAIN_SOUND_MODEL_ES1370);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(sound));
g_object_unref(G_OBJECT(sound));
check_xml(domain, "gconfig-domain-device-sound.xml");
g_object_unref(G_OBJECT(domain));
}
void file_history(char *player1, char *player2, char *winner, int hits, int rounds,enum gameType gametype) {
/* gametype enum from billmove.h GAME_8BALL, GAME_9BALL, GAME_CARAMBOL, GAME_SNOOKER
localeText[432] etc.*/
//fprintf(stderr,"Start: %s, %s, %s, %i, %i, %i\n",player1,player2,winner,hits,rounds,gametype);
FILE *fp, *wfp;
char historyfile[1024]; // no file with directory should be longer
char newfile[1024]; // no file with directory should be longer
char checkstring[2048]; // no entry inside the history-file should be longer
char datestring[25];
time_t rawtime;
struct tm * timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
snprintf(datestring,sizeof(datestring),"%02d.%02d.%04d %02d:%02d:%02d",timeinfo->tm_mday,timeinfo->tm_mon+1,timeinfo->tm_year+1900,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);
//fprintf(stderr,"%s\n",datestring);
if(check_xml("history.xml")) {
// write new history to the file
snprintf(historyfile,sizeof(historyfile),"%s/html/%s",file_name,"history.xml");
snprintf(newfile,sizeof(newfile),"%s/html/%s",file_name,"history.tmp");
if((fp=fopen(historyfile,"r"))) {
if((wfp=fopen(newfile,"w+"))) {
while(fgets(checkstring, sizeof(checkstring), fp) != NULL) {
if(strstr(checkstring,"</start>")) {
break;
} else {
fprintf(wfp,"%s",checkstring);
}
}
fprintf(wfp,"<%s>\n<date>%s</date>\n<player1>%s</player1>\n<player2>%s</player2>\n<winner>%s</winner>\n<hits>%i</hits>\n<rounds>%i</rounds>\n</%s>\n</start>\n",
localeText[432+gametype],datestring,player1,player2,winner,hits,rounds,localeText[432+gametype]);
fclose(fp);
fclose(wfp);
remove(historyfile);
rename(newfile,historyfile);
} else {
fclose(fp);
}
}
}
}
static void test_domain_device_pci_hostdev(void)
{
GVirConfigDomain *domain;
GVirConfigDomainAddressPci *address;
GVirConfigDomainHostdevPci *hostdev;
domain = gvir_config_domain_new();
hostdev = gvir_config_domain_hostdev_pci_new();
gvir_config_domain_hostdev_set_boot_order(GVIR_CONFIG_DOMAIN_HOSTDEV(hostdev), 1);
g_assert_cmpint(gvir_config_domain_hostdev_get_boot_order(GVIR_CONFIG_DOMAIN_HOSTDEV(hostdev)), ==, 1);
gvir_config_domain_hostdev_pci_set_managed(hostdev, TRUE);
g_assert(gvir_config_domain_hostdev_pci_get_managed(hostdev) == TRUE);
gvir_config_domain_hostdev_pci_set_rom_bar(hostdev, TRUE);
gvir_config_domain_hostdev_pci_set_rom_file(hostdev, "/etc/fake/boot.bin");
g_assert_cmpstr(gvir_config_domain_hostdev_pci_get_rom_file(hostdev), ==, "/etc/fake/boot.bin");
g_assert(gvir_config_domain_hostdev_pci_get_rom_bar(hostdev));
address = gvir_config_domain_address_pci_new();
gvir_config_domain_address_pci_set_domain(address, 1);
gvir_config_domain_address_pci_set_bus(address, 2);
gvir_config_domain_address_pci_set_slot(address, 3);
gvir_config_domain_address_pci_set_function(address, 4);
gvir_config_domain_hostdev_pci_set_address(hostdev, address);
g_object_unref(G_OBJECT(address));
address = gvir_config_domain_hostdev_pci_get_address(hostdev);
g_assert(address != NULL);
g_assert_cmpint(gvir_config_domain_address_pci_get_domain(address), ==, 1);
g_assert_cmpint(gvir_config_domain_address_pci_get_bus(address), ==, 2);
g_assert_cmpint(gvir_config_domain_address_pci_get_slot(address), ==, 3);
g_assert_cmpint(gvir_config_domain_address_pci_get_function(address), ==, 4);
g_object_unref(G_OBJECT(address));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE (hostdev));
g_object_unref(G_OBJECT(hostdev));
check_xml(domain, "gconfig-domain-device-pci-hostdev.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_console(void)
{
GVirConfigDomain *domain;
domain = gvir_config_domain_new();
/* console node */
GVirConfigDomainConsole *console;
GVirConfigDomainChardevSourcePty *pty;
console = gvir_config_domain_console_new();
pty = gvir_config_domain_chardev_source_pty_new();
gvir_config_domain_chardev_set_source(GVIR_CONFIG_DOMAIN_CHARDEV(console),
GVIR_CONFIG_DOMAIN_CHARDEV_SOURCE(pty));
g_object_unref(G_OBJECT(pty));
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(console));
g_object_unref(G_OBJECT(console));
check_xml(domain, "gconfig-domain-device-console.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_video(void)
{
GVirConfigDomain *domain;
domain = gvir_config_domain_new();
/* video node */
GVirConfigDomainVideo *video;
video = gvir_config_domain_video_new();
gvir_config_domain_video_set_model(video,
GVIR_CONFIG_DOMAIN_VIDEO_MODEL_QXL);
gvir_config_domain_video_set_heads(video, 4);
gvir_config_domain_video_set_vram(video, 256*1024);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(video));
g_object_unref(G_OBJECT(video));
check_xml(domain, "gconfig-domain-device-video.xml");
g_object_unref(G_OBJECT(domain));
}
static void test_domain_os(void)
{
GVirConfigDomain *domain;
GVirConfigDomainOs *os;
GList *devices = NULL;
domain = gvir_config_domain_new();
os = gvir_config_domain_os_new();
gvir_config_domain_os_set_os_type(os, GVIR_CONFIG_DOMAIN_OS_TYPE_HVM);
gvir_config_domain_os_set_arch(os, "x86_64");
g_assert_cmpint(gvir_config_domain_os_get_os_type(os), ==, GVIR_CONFIG_DOMAIN_OS_TYPE_HVM);
g_assert_cmpstr(gvir_config_domain_os_get_arch(os), ==, "x86_64");
devices = g_list_append(devices,
GINT_TO_POINTER(GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_CDROM));
devices = g_list_append(devices,
GINT_TO_POINTER(GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_NETWORK));
gvir_config_domain_os_set_boot_devices(os, devices);
g_list_free(devices);
devices = NULL;
domain_os_check_boot_devices(os);
gvir_config_domain_set_os(domain, os);
g_object_unref(G_OBJECT(os));
os = gvir_config_domain_get_os(domain);
g_assert(os != NULL);
g_assert_cmpstr(gvir_config_domain_os_get_arch(os), ==, "x86_64");
g_assert_cmpint(gvir_config_domain_os_get_os_type(os), ==, GVIR_CONFIG_DOMAIN_OS_TYPE_HVM);
domain_os_check_boot_devices(os);
g_object_unref(G_OBJECT(os));
check_xml(domain, "gconfig-domain-os.xml");
gvir_config_domain_set_os(domain, NULL);
os = gvir_config_domain_get_os(domain);
g_assert(os == NULL);
g_object_unref(G_OBJECT(domain));
}
static void test_domain_device_graphics(void)
{
GVirConfigDomain *domain;
GVirConfigDomainGraphicsSpice *graphics;
domain = gvir_config_domain_new();
graphics = gvir_config_domain_graphics_spice_new();
gvir_config_domain_graphics_spice_set_port(graphics, 1234);
g_assert_cmpint(gvir_config_domain_graphics_spice_get_port(graphics), ==, 1234);
/* SPICE image compression configuration */
gvir_config_domain_graphics_spice_set_image_compression
(graphics, GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_LZ);
g_assert_cmpint(gvir_config_domain_graphics_spice_get_image_compression(graphics), ==,
GVIR_CONFIG_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_LZ);
gvir_config_domain_add_device(domain, GVIR_CONFIG_DOMAIN_DEVICE(graphics));
g_object_unref(G_OBJECT(graphics));
check_xml(domain, "gconfig-domain-device-graphics.xml");
g_object_unref(G_OBJECT(domain));
}
/*------------------------------------------------------------------------*/
int do_upload(char **uuids, int num_uuids, char *device, char *optarg)
{
int n;
int ret=0;
if (check_xml(optarg)) {
fprintf(stderr,"Configuration file <%s> not valid XML\n",optarg);
return -2;
}
for(n=0;n<num_uuids;n++) {
if (!uuids[n])
continue;
printf("UUID %s: Uploading %s ... ",uuids[n], optarg);
fflush(stdout);
ret=do_single_upload(uuids[n], device, "/mmc/etc/", optarg, NC_CONFFILE);
if (!ret)
printf("Upload done\n");
else {
printf("Upload failed (ret=%i)\n",ret);
uuids[n]=NULL;
}
}
return ret;
}
void init_history(void) {
char *filenames[] = {"body-bg.png","content-bg.png","feature.jpg","footer-bg.png","gradient-shadow.png","header-bg.jpg","logo.jpg","sidebar-h3-bg.jpg"};
#define ARRAYLEN 8
char directorycheck[1024];
char directorycheck1[1024];
char copy_file[1024];
int i, checktournament, checkhistory;
#ifdef USE_WIN
strcpy(file_name,getenv("USERPROFILE"));
strcat(file_name,"/Desktop/foobillardplus-data");
mkdir(file_name); //build directory every time is not a problem
#elif defined(__APPLE__)
strcpy(file_name,getenv("HOME"));
strcat(file_name,"/Library/Application Support/Foobillard++");
mkdir(file_name,0777); //build directory every time is not a problem
#else
strcpy(file_name,getenv("HOME"));
strcat(file_name,"/foobillardplus-data");
mkdir(file_name,0777); //build directory every time is not a problem
#endif
checktournament = check_xml("tournament.xml");
checkhistory = check_xml("history.xml");
if(!checkhistory || !checktournament) {
//only build, if no xml-file is there
//fprintf(stderr,"Call only one time\n");
#ifdef USE_WIN
sprintf(directorycheck,"%s/html",file_name);
mkdir(directorycheck);
sprintf(directorycheck1,"%s/html/images",file_name);
mkdir(directorycheck1);
#else
sprintf(directorycheck,"%s/html",file_name);
mkdir(directorycheck,0777);
sprintf(directorycheck1,"%s/html/images",file_name);
mkdir(directorycheck1,0777);
#endif
if(!chdir("html") ) {
if(!checkhistory) {
sprintf(copy_file,"%s/%s",directorycheck,"history.xsl");
filecopy("history.xsl",copy_file);
sprintf(copy_file,"%s/%s",directorycheck,"history.xml");
parse_history("history.xml",copy_file);
}
if(!checktournament) {
sprintf(copy_file,"%s/%s",directorycheck,"tournament.xsl");
filecopy("tournament.xsl",copy_file);
sprintf(copy_file,"%s/%s",directorycheck,"tournament.xml");
parse_history("tournament.xml",copy_file);
}
sprintf(copy_file,"%s/%s",directorycheck,"styles.css");
filecopy("styles.css",copy_file);
if(!chdir("images")) {
for(i=0;i< ARRAYLEN ;i++) {
sprintf(copy_file,"%s/%s",directorycheck1,filenames[i]);
filecopy(filenames[i],copy_file);
}
chdir("../..");
} else {
chdir("..");
}
}
}
#undef ARRAYLEN
}
void file_tournament_history( struct TournamentState_ * ts, char *winner, enum gameType gametype ) {
/* gametype enum from billmove.h GAME_8BALL, GAME_9BALL, GAME_CARAMBOL, GAME_SNOOKER
localeText[432] etc.*/
//fprintf(stderr,"Start: %s, %s, %s, %i, %i, %i\n",player1,player2,winner,hits,rounds,gametype);
FILE *fp, *wfp;
char historyfile[1024]; // no file with directory should be longer
char newfile[1024]; // no file with directory should be longer
char checkstring[2048]; // no entry inside the history-file should be longer
char datestring[25];
char gameid[200];
time_t rawtime;
struct tm * timeinfo;
int i,j;
if(!ts->tournament_over) {
fprintf(stderr,"Something is wrong with tournament write to history\n");
return; // nothing to do
}
time(&rawtime);
timeinfo = localtime(&rawtime);
snprintf(gameid,sizeof(gameid),"%02d%02d%04d%02d%02d%02d-%i",timeinfo->tm_mday,timeinfo->tm_mon+1,timeinfo->tm_year+1900,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec,rand());
snprintf(datestring,sizeof(datestring),"%02d.%02d.%04d %02d:%02d:%02d",timeinfo->tm_mday,timeinfo->tm_mon+1,timeinfo->tm_year+1900,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);
//fprintf(stderr,"%s\n",datestring);
if(check_xml("tournament.xml")) {
// write new history to the file
sprintf(historyfile,"%s/html/%s",file_name,"tournament.xml");
sprintf(newfile,"%s/html/%s",file_name,"tournament.tmp");
if((fp=fopen(historyfile,"r"))) {
if((wfp=fopen(newfile,"w+"))) {
while(fgets(checkstring, sizeof(checkstring), fp) != NULL) {
if(strstr(checkstring,"</start>")) {
break;
} else {
fprintf(wfp,"%s",checkstring);
}
}
// write tournament to file
fprintf(wfp,"<%s>\n<gameid>%s</gameid>\n<date>%s</date>\n<allwin>%s</allwin>\n\n",
localeText[432+gametype],gameid,datestring,winner);
for(i=0;i<=ts->round_ind;i++) {
for(j=0;j<(1<<(ts->round_num-i-1));j++){
fprintf(wfp,"<g%i>\n<go>%i</go>\n<p1>%s</p1>\n<p2>%s</p2>\n",
i+1,j+1,ts->roster.player[ts->game[i][j].roster_player1].name,ts->roster.player[ts->game[i][j].roster_player2].name);
if(ts->game[i][j].winner == 0) {
fprintf(wfp,"<w>%s</w>\n",ts->roster.player[ts->game[i][j].roster_player1].name);
} else {
fprintf(wfp,"<w>%s</w>\n",ts->roster.player[ts->game[i][j].roster_player2].name);
}
fprintf(wfp,"<h>%i</h>\n<r>%i</r>\n</g%i>\n",ts->game[i][j].hits,ts->game[i][j].rounds,i+1);
}
}
fprintf(wfp,"</%s>\n</start>\n",localeText[432+gametype]);
fclose(fp);
fclose(wfp);
remove(historyfile);
rename(newfile,historyfile);
} else {
fclose(fp);
}
}
}
}
static void test_domain_cpu(void)
{
GVirConfigDomain *domain;
/* cpu node */
GVirConfigDomainCpu *cpu;
domain = gvir_config_domain_new();
cpu = gvir_config_domain_cpu_new();
gvir_config_domain_set_vcpus(domain, 3);
/* cpu/feature nodes */
GVirConfigDomainCpuFeature *feature;
GList *cpu_features = NULL;
gvir_config_domain_cpu_set_match_policy(cpu, GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT);
gvir_config_domain_cpu_set_mode(cpu, GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH);
feature = gvir_config_domain_cpu_feature_new();
gvir_config_capabilities_cpu_feature_set_name(GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature),
"foo");
gvir_config_domain_cpu_feature_set_policy(feature, GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE);
gvir_config_capabilities_cpu_add_feature(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature));
g_object_unref(feature);
/* cpu/topology nodes */
GVirConfigCapabilitiesCpuTopology *topology;
topology = gvir_config_capabilities_cpu_topology_new();
gvir_config_capabilities_cpu_topology_set_cores(topology, 1);
gvir_config_capabilities_cpu_topology_set_sockets(topology, 2);
gvir_config_capabilities_cpu_topology_set_threads(topology, 3);
gvir_config_capabilities_cpu_set_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
topology);
g_object_unref(topology);
gvir_config_domain_set_cpu(domain, cpu);
g_object_unref(cpu);
cpu = gvir_config_domain_get_cpu(domain);
g_assert(cpu != NULL);
g_assert(GVIR_CONFIG_IS_CAPABILITIES_CPU(cpu));
g_assert_cmpint(gvir_config_domain_cpu_get_match_policy(cpu), ==, GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT);
g_assert_cmpint(gvir_config_domain_cpu_get_mode(cpu), ==, GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH);
cpu_features = gvir_config_capabilities_cpu_get_features(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
g_assert_cmpint(g_list_length(cpu_features), ==, 1);
g_assert(GVIR_CONFIG_IS_DOMAIN_CPU_FEATURE(cpu_features->data));
feature = GVIR_CONFIG_DOMAIN_CPU_FEATURE(cpu_features->data);
g_assert_cmpstr(gvir_config_capabilities_cpu_feature_get_name(GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature)), ==, "foo");
g_assert_cmpint(gvir_config_domain_cpu_feature_get_policy(feature), ==, GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE);
g_list_free_full(cpu_features, g_object_unref);
topology = gvir_config_capabilities_cpu_get_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
g_assert(topology != NULL);
g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_cores(topology), ==, 1);
g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_sockets(topology), ==, 2);
g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_threads(topology), ==, 3);
g_object_unref(topology);
g_object_unref(cpu);
check_xml(domain, "gconfig-domain-cpu.xml");
cpu = gvir_config_domain_get_cpu(domain);
gvir_config_capabilities_cpu_set_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
NULL);
topology = gvir_config_capabilities_cpu_get_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
g_assert(topology == NULL);
g_object_unref(G_OBJECT(cpu));
gvir_config_domain_set_cpu(domain, NULL);
cpu = gvir_config_domain_get_cpu(domain);
g_assert(cpu == NULL);
g_object_unref(G_OBJECT(domain));
}
