cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

test-io-channel-file.c (4082B)

      1/*
      2 * QEMU I/O channel file test
      3 *
      4 * Copyright (c) 2015 Red Hat, Inc.
      5 *
      6 * This library is free software; you can redistribute it and/or
      7 * modify it under the terms of the GNU Lesser General Public
      8 * License as published by the Free Software Foundation; either
      9 * version 2.1 of the License, or (at your option) any later version.
     10 *
     11 * This library is distributed in the hope that it will be useful,
     12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14 * Lesser General Public License for more details.
     15 *
     16 * You should have received a copy of the GNU Lesser General Public
     17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
     18 *
     19 */
     20
     21#include "qemu/osdep.h"
     22#include "io/channel-file.h"
     23#include "io/channel-util.h"
     24#include "io-channel-helpers.h"
     25#include "qapi/error.h"
     26#include "qemu/module.h"
     27
     28#define TEST_FILE "tests/test-io-channel-file.txt"
     29#define TEST_MASK 0600
     30
     31/*
     32 * On Windows the stat() function in the C library checks only
     33 * the FAT-style READONLY attribute and does not look at the ACL at all.
     34 */
     35#ifdef _WIN32
     36#define TEST_MASK_EXPECT 0700
     37#else
     38#define TEST_MASK_EXPECT 0777
     39#endif
     40
     41static void test_io_channel_file_helper(int flags)
     42{
     43    QIOChannel *src, *dst;
     44    QIOChannelTest *test;
     45    struct stat st;
     46    mode_t mask;
     47    int ret;
     48
     49    unlink(TEST_FILE);
     50    src = QIO_CHANNEL(qio_channel_file_new_path(
     51                          TEST_FILE,
     52                          flags, TEST_MASK,
     53                          &error_abort));
     54    dst = QIO_CHANNEL(qio_channel_file_new_path(
     55                          TEST_FILE,
     56                          O_RDONLY | O_BINARY, 0,
     57                          &error_abort));
     58
     59    test = qio_channel_test_new();
     60    qio_channel_test_run_writer(test, src);
     61    qio_channel_test_run_reader(test, dst);
     62    qio_channel_test_validate(test);
     63
     64    /* Check that the requested mode took effect. */
     65    mask = umask(0);
     66    umask(mask);
     67    ret = stat(TEST_FILE, &st);
     68    g_assert_cmpint(ret, >, -1);
     69    g_assert_cmpuint(TEST_MASK & ~mask, ==, st.st_mode & TEST_MASK_EXPECT);
     70
     71    unlink(TEST_FILE);
     72    object_unref(OBJECT(src));
     73    object_unref(OBJECT(dst));
     74}
     75
     76static void test_io_channel_file(void)
     77{
     78    test_io_channel_file_helper(O_WRONLY | O_CREAT | O_TRUNC | O_BINARY);
     79}
     80
     81static void test_io_channel_file_rdwr(void)
     82{
     83    test_io_channel_file_helper(O_RDWR | O_CREAT | O_TRUNC | O_BINARY);
     84}
     85
     86static void test_io_channel_fd(void)
     87{
     88    QIOChannel *ioc;
     89    int fd = -1;
     90
     91    fd = open(TEST_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0600);
     92    g_assert_cmpint(fd, >, -1);
     93
     94    ioc = qio_channel_new_fd(fd, &error_abort);
     95
     96    g_assert_cmpstr(object_get_typename(OBJECT(ioc)),
     97                    ==,
     98                    TYPE_QIO_CHANNEL_FILE);
     99
    100    unlink(TEST_FILE);
    101    object_unref(OBJECT(ioc));
    102}
    103
    104
    105#ifndef _WIN32
    106static void test_io_channel_pipe(bool async)
    107{
    108    QIOChannel *src, *dst;
    109    QIOChannelTest *test;
    110    int fd[2];
    111
    112    if (pipe(fd) < 0) {
    113        perror("pipe");
    114        abort();
    115    }
    116
    117    src = QIO_CHANNEL(qio_channel_file_new_fd(fd[1]));
    118    dst = QIO_CHANNEL(qio_channel_file_new_fd(fd[0]));
    119
    120    test = qio_channel_test_new();
    121    qio_channel_test_run_threads(test, async, src, dst);
    122    qio_channel_test_validate(test);
    123
    124    object_unref(OBJECT(src));
    125    object_unref(OBJECT(dst));
    126}
    127
    128
    129static void test_io_channel_pipe_async(void)
    130{
    131    test_io_channel_pipe(true);
    132}
    133
    134static void test_io_channel_pipe_sync(void)
    135{
    136    test_io_channel_pipe(false);
    137}
    138#endif /* ! _WIN32 */
    139
    140
    141int main(int argc, char **argv)
    142{
    143    module_call_init(MODULE_INIT_QOM);
    144
    145    g_test_init(&argc, &argv, NULL);
    146
    147    g_test_add_func("/io/channel/file", test_io_channel_file);
    148    g_test_add_func("/io/channel/file/rdwr", test_io_channel_file_rdwr);
    149    g_test_add_func("/io/channel/file/fd", test_io_channel_fd);
    150#ifndef _WIN32
    151    g_test_add_func("/io/channel/pipe/sync", test_io_channel_pipe_sync);
    152    g_test_add_func("/io/channel/pipe/async", test_io_channel_pipe_async);
    153#endif
    154    return g_test_run();
    155}