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)); }