Revision 087f4ae0 vl.c
| b/vl.c | ||
|---|---|---|
| 1874 | 1874 |
|
| 1875 | 1875 |
#ifdef _WIN32 |
| 1876 | 1876 |
typedef struct {
|
| 1877 |
CharDriverState *chr; |
|
| 1878 | 1877 |
int max_size; |
| 1879 | 1878 |
HANDLE hcom, hrecv, hsend; |
| 1880 | 1879 |
OVERLAPPED orecv, osend; |
| ... | ... | |
| 1890 | 1889 |
static int win_chr_poll(void *opaque); |
| 1891 | 1890 |
static int win_chr_pipe_poll(void *opaque); |
| 1892 | 1891 |
|
| 1893 |
static void win_chr_close2(WinCharState *s)
|
|
| 1892 |
static void win_chr_close(CharDriverState *chr)
|
|
| 1894 | 1893 |
{
|
| 1894 |
WinCharState *s = chr->opaque; |
|
| 1895 |
|
|
| 1895 | 1896 |
if (s->hsend) {
|
| 1896 | 1897 |
CloseHandle(s->hsend); |
| 1897 | 1898 |
s->hsend = NULL; |
| ... | ... | |
| 1905 | 1906 |
s->hcom = NULL; |
| 1906 | 1907 |
} |
| 1907 | 1908 |
if (s->fpipe) |
| 1908 |
qemu_del_polling_cb(win_chr_pipe_poll, s);
|
|
| 1909 |
qemu_del_polling_cb(win_chr_pipe_poll, chr);
|
|
| 1909 | 1910 |
else |
| 1910 |
qemu_del_polling_cb(win_chr_poll, s);
|
|
| 1911 |
qemu_del_polling_cb(win_chr_poll, chr);
|
|
| 1911 | 1912 |
} |
| 1912 | 1913 |
|
| 1913 |
static void win_chr_close(CharDriverState *chr)
|
|
| 1914 |
static int win_chr_init(CharDriverState *chr, const char *filename)
|
|
| 1914 | 1915 |
{
|
| 1915 | 1916 |
WinCharState *s = chr->opaque; |
| 1916 |
win_chr_close2(s); |
|
| 1917 |
} |
|
| 1918 |
|
|
| 1919 |
static int win_chr_init(WinCharState *s, CharDriverState *chr, const char *filename) |
|
| 1920 |
{
|
|
| 1921 | 1917 |
COMMCONFIG comcfg; |
| 1922 | 1918 |
COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
|
| 1923 | 1919 |
COMSTAT comstat; |
| ... | ... | |
| 1974 | 1970 |
fprintf(stderr, "Failed ClearCommError\n"); |
| 1975 | 1971 |
goto fail; |
| 1976 | 1972 |
} |
| 1977 |
s->chr = chr; |
|
| 1978 |
qemu_add_polling_cb(win_chr_poll, s); |
|
| 1973 |
qemu_add_polling_cb(win_chr_poll, chr); |
|
| 1979 | 1974 |
return 0; |
| 1980 | 1975 |
|
| 1981 | 1976 |
fail: |
| 1982 |
win_chr_close2(s);
|
|
| 1977 |
win_chr_close(chr);
|
|
| 1983 | 1978 |
return -1; |
| 1984 | 1979 |
} |
| 1985 | 1980 |
|
| ... | ... | |
| 2017 | 2012 |
return len1 - len; |
| 2018 | 2013 |
} |
| 2019 | 2014 |
|
| 2020 |
static int win_chr_read_poll(WinCharState *s)
|
|
| 2015 |
static int win_chr_read_poll(CharDriverState *chr)
|
|
| 2021 | 2016 |
{
|
| 2022 |
s->max_size = qemu_chr_can_read(s->chr); |
|
| 2017 |
WinCharState *s = chr->opaque; |
|
| 2018 |
|
|
| 2019 |
s->max_size = qemu_chr_can_read(chr); |
|
| 2023 | 2020 |
return s->max_size; |
| 2024 | 2021 |
} |
| 2025 | 2022 |
|
| 2026 |
static void win_chr_readfile(WinCharState *s)
|
|
| 2023 |
static void win_chr_readfile(CharDriverState *chr)
|
|
| 2027 | 2024 |
{
|
| 2025 |
WinCharState *s = chr->opaque; |
|
| 2028 | 2026 |
int ret, err; |
| 2029 | 2027 |
uint8_t buf[1024]; |
| 2030 | 2028 |
DWORD size; |
| ... | ... | |
| 2040 | 2038 |
} |
| 2041 | 2039 |
|
| 2042 | 2040 |
if (size > 0) {
|
| 2043 |
qemu_chr_read(s->chr, buf, size);
|
|
| 2041 |
qemu_chr_read(chr, buf, size); |
|
| 2044 | 2042 |
} |
| 2045 | 2043 |
} |
| 2046 | 2044 |
|
| 2047 |
static void win_chr_read(WinCharState *s)
|
|
| 2045 |
static void win_chr_read(CharDriverState *chr)
|
|
| 2048 | 2046 |
{
|
| 2047 |
WinCharState *s = chr->opaque; |
|
| 2048 |
|
|
| 2049 | 2049 |
if (s->len > s->max_size) |
| 2050 | 2050 |
s->len = s->max_size; |
| 2051 | 2051 |
if (s->len == 0) |
| 2052 | 2052 |
return; |
| 2053 | 2053 |
|
| 2054 |
win_chr_readfile(s);
|
|
| 2054 |
win_chr_readfile(chr);
|
|
| 2055 | 2055 |
} |
| 2056 | 2056 |
|
| 2057 | 2057 |
static int win_chr_poll(void *opaque) |
| 2058 | 2058 |
{
|
| 2059 |
WinCharState *s = opaque; |
|
| 2059 |
CharDriverState *chr = opaque; |
|
| 2060 |
WinCharState *s = chr->opaque; |
|
| 2060 | 2061 |
COMSTAT status; |
| 2061 | 2062 |
DWORD comerr; |
| 2062 | 2063 |
|
| 2063 | 2064 |
ClearCommError(s->hcom, &comerr, &status); |
| 2064 | 2065 |
if (status.cbInQue > 0) {
|
| 2065 | 2066 |
s->len = status.cbInQue; |
| 2066 |
win_chr_read_poll(s);
|
|
| 2067 |
win_chr_read(s);
|
|
| 2067 |
win_chr_read_poll(chr);
|
|
| 2068 |
win_chr_read(chr);
|
|
| 2068 | 2069 |
return 1; |
| 2069 | 2070 |
} |
| 2070 | 2071 |
return 0; |
| ... | ... | |
| 2087 | 2088 |
chr->chr_write = win_chr_write; |
| 2088 | 2089 |
chr->chr_close = win_chr_close; |
| 2089 | 2090 |
|
| 2090 |
if (win_chr_init(s, chr, filename) < 0) {
|
|
| 2091 |
if (win_chr_init(chr, filename) < 0) {
|
|
| 2091 | 2092 |
free(s); |
| 2092 | 2093 |
free(chr); |
| 2093 | 2094 |
return NULL; |
| ... | ... | |
| 2098 | 2099 |
|
| 2099 | 2100 |
static int win_chr_pipe_poll(void *opaque) |
| 2100 | 2101 |
{
|
| 2101 |
WinCharState *s = opaque; |
|
| 2102 |
CharDriverState *chr = opaque; |
|
| 2103 |
WinCharState *s = chr->opaque; |
|
| 2102 | 2104 |
DWORD size; |
| 2103 | 2105 |
|
| 2104 | 2106 |
PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL); |
| 2105 | 2107 |
if (size > 0) {
|
| 2106 | 2108 |
s->len = size; |
| 2107 |
win_chr_read_poll(s);
|
|
| 2108 |
win_chr_read(s);
|
|
| 2109 |
win_chr_read_poll(chr);
|
|
| 2110 |
win_chr_read(chr);
|
|
| 2109 | 2111 |
return 1; |
| 2110 | 2112 |
} |
| 2111 | 2113 |
return 0; |
| 2112 | 2114 |
} |
| 2113 | 2115 |
|
| 2114 |
static int win_chr_pipe_init(WinCharState *s, const char *filename)
|
|
| 2116 |
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
|
|
| 2115 | 2117 |
{
|
| 2118 |
WinCharState *s = chr->opaque; |
|
| 2116 | 2119 |
OVERLAPPED ov; |
| 2117 | 2120 |
int ret; |
| 2118 | 2121 |
DWORD size; |
| ... | ... | |
| 2164 | 2167 |
CloseHandle(ov.hEvent); |
| 2165 | 2168 |
ov.hEvent = NULL; |
| 2166 | 2169 |
} |
| 2167 |
qemu_add_polling_cb(win_chr_pipe_poll, s);
|
|
| 2170 |
qemu_add_polling_cb(win_chr_pipe_poll, chr);
|
|
| 2168 | 2171 |
return 0; |
| 2169 | 2172 |
|
| 2170 | 2173 |
fail: |
| 2171 |
win_chr_close2(s);
|
|
| 2174 |
win_chr_close(chr);
|
|
| 2172 | 2175 |
return -1; |
| 2173 | 2176 |
} |
| 2174 | 2177 |
|
| ... | ... | |
| 2190 | 2193 |
chr->chr_write = win_chr_write; |
| 2191 | 2194 |
chr->chr_close = win_chr_close; |
| 2192 | 2195 |
|
| 2193 |
if (win_chr_pipe_init(s, filename) < 0) {
|
|
| 2196 |
if (win_chr_pipe_init(chr, filename) < 0) {
|
|
| 2194 | 2197 |
free(s); |
| 2195 | 2198 |
free(chr); |
| 2196 | 2199 |
return NULL; |
Also available in: Unified diff