suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rktio: more repairs exposed by warnings

Browse Source
This commit is contained in:
Matthew Flatt 2017-06-13 08:04:19 -06:00
parent 2f5797f1d5
commit 03c3655b1f
14 changed files with 215 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
racket/src/rktio/demo.c
View File

@ -169,7 +169,7 @@ static void check_hello_content(rktio_t *rktio, char *fn)
{
rktio_fd_t *fd;
intptr_t amt;
char buffer[256], *s;
char buffer[256];
fd = rktio_open(rktio, fn, RKTIO_OPEN_READ);
check_valid(fd);
@ -196,7 +196,7 @@ static void check_read_write_pair(rktio_t *rktio, rktio_fd_t *fd, rktio_fd_t *fd
{
rktio_ltps_t *lt;
rktio_ltps_handle_t *h1, *h2;
intptr_t amt, i;
intptr_t amt;
char buffer[256];
lt = try_check_ltps(rktio, fd, fd2, &h1, &h2);
@ -446,8 +446,6 @@ int main(int argc, char **argv)
rktio_directory_list_t *ls;
rktio_file_copy_t *cp;
rktio_timestamp_t *ts1, *ts1a;
rktio_ltps_t *lt;
rktio_ltps_handle_t *h1, *h2;
int verbose = 0, dont_rely_on_sigchild = 0;
for (i = 1; i < argc; i++) {
@ -588,16 +586,21 @@ int main(int argc, char **argv)
/* We expect `lt` to work on regular files except on Windows and epoll: */
#if !defined(RKTIO_SYSTEM_WINDOWS) && !defined(HAVE_EPOLL_SYSCALL)
fd = rktio_open(rktio, "test1", RKTIO_OPEN_READ);
check_valid(fd);
fd2 = rktio_open(rktio, "test1", RKTIO_OPEN_WRITE | RKTIO_OPEN_CAN_EXIST);
check_valid(fd2);
lt = try_check_ltps(rktio, fd, fd2, &h1, &h2);
check_valid(lt);
check_ltps_read_and_write_ready(rktio, lt, h1, h2);
check_valid(rktio_ltps_close(rktio, lt));
check_valid(rktio_close(rktio, fd));
check_valid(rktio_close(rktio, fd2));
{
rktio_ltps_handle_t *h1, *h2;
rktio_ltps_t *lt;
fd = rktio_open(rktio, "test1", RKTIO_OPEN_READ);
check_valid(fd);
fd2 = rktio_open(rktio, "test1", RKTIO_OPEN_WRITE | RKTIO_OPEN_CAN_EXIST);
check_valid(fd2);
lt = try_check_ltps(rktio, fd, fd2, &h1, &h2);
check_valid(lt);
check_ltps_read_and_write_ready(rktio, lt, h1, h2);
check_valid(rktio_ltps_close(rktio, lt));
check_valid(rktio_close(rktio, fd));
check_valid(rktio_close(rktio, fd2));
}
#endif
/* Pipes, non-blocking operations, and more long-term poll sets */

1
racket/src/rktio/rktio.h
View File

@ -42,6 +42,7 @@ intptr_t rktio_fd_system_fd(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_fd_is_regular_file(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_fd_is_socket(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_fd_is_udp(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_fd_is_terminal(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_fd_modes(rktio_t *rktio, rktio_fd_t *rfd);

10
racket/src/rktio/rktio_envvars.c
View File

@ -95,7 +95,7 @@ int rktio_setenv(rktio_t *rktio, const char *name, const char *val)
if (rc)
return 1;
set_windows_error();
get_windows_error();
return 0;
#endif
}
@ -341,8 +341,8 @@ void *rktio_envvars_to_block(rktio_t *rktio, rktio_envvars_t *envvars)
wchar_t *r, *s;
for (i = 0; i < envvars->count; i++) {
len += wc_strlen(WIDE_PATH_temp(envvars->names[i]));
len += wc_strlen(WIDE_PATH_temp(envvars->vals[i]));
len += wcslen(WIDE_PATH_temp(envvars->names[i]));
len += wcslen(WIDE_PATH_temp(envvars->vals[i]));
len += 2;
}
@ -352,12 +352,12 @@ for (i = 0; i < envvars->count; i++) {
for (i = 0; i < envvars->count; i++) {
s = WIDE_PATH_temp(envvars->names[i]);
slen = wc_strlen(s);
slen = wcslen(s);
memcpy(r + len, s, slen * sizeof(wchar_t));
len += slen;
r[len++] = '=';
s = WIDE_PATH_temp(envvars->vals[i]);
slen = wc_strlen(s);
slen = wcslen(s);
memcpy(r + len, s, slen * sizeof(wchar_t));
len += slen;
r[len++] = 0;

6
racket/src/rktio/rktio_error.c
View File

@ -24,6 +24,12 @@ void rktio_get_windows_error(rktio_t *rktio)
rktio->errid = GetLastError();
rktio->errkind = RKTIO_ERROR_KIND_WINDOWS;
}
void rktio_set_windows_error(rktio_t *rktio, int errid)
{
rktio->errid = errid;
rktio->errkind = RKTIO_ERROR_KIND_WINDOWS;
}
#endif
int rktio_get_last_error(rktio_t *rktio)

55
racket/src/rktio/rktio_fd.c
View File

@ -234,6 +234,28 @@ int rktio_fd_is_udp(rktio_t *rktio, rktio_fd_t *rfd)
return ((rfd->modes & RKTIO_OPEN_UDP) ? 1 : 0);
}
int rktio_system_fd_is_terminal(rktio_t *rktio, intptr_t fd)
{
#ifdef RKTIO_SYSTEM_UNIX
return isatty(fd);
#endif
#ifdef RKTIO_SYSTEM_WINDOWS
if (GetFileType((HANDLE)fd) == FILE_TYPE_CHAR) {
DWORD mode;
if (GetConsoleMode((HANDLE)fd, &mode))
return 1;
else
return 0;
} else
return 0;
#endif
}
int rktio_fd_is_terminal(rktio_t *rktio, rktio_fd_t *rfd)
{
return rktio_system_fd_is_terminal(rktio, (intptr_t)rfd->fd);
}
rktio_fd_t *rktio_dup(rktio_t *rktio, rktio_fd_t *rfd)
{
#ifdef RKTIO_SYSTEM_UNIX
@ -249,9 +271,9 @@ rktio_fd_t *rktio_dup(rktio_t *rktio, rktio_fd_t *rfd)
} else
return rktio_system_fd(rktio, nfd, rfd->modes);
#endif
#ifdef WINDOWS_FILE_HANDLES
#ifdef RKTIO_SYSTEM_WINDOWS
if (rfd->modes & RKTIO_OPEN_SOCKET) {
return rktio_socket_dup(rktio_t *rktio, rktio_fd_t *rfd)
return rktio_socket_dup(rktio, rfd);
} else {
HANDLE newhandle;
BOOL rc;
@ -632,7 +654,7 @@ void rktio_poll_add(rktio_t *rktio, rktio_fd_t *rfd, rktio_poll_set_t *fds, int
if (rfd->oth && !rktio_poll_write_ready(rktio, rfd))
rktio_poll_set_add_handle(rktio, (intptr_t)rfd->oth->ready_sema, fds, 1);
else
rktio_poll_set_nosleep(rktio, fds);
rktio_poll_set_add_nosleep(rktio, fds);
}
}
#endif
@ -701,7 +723,7 @@ intptr_t rktio_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
if (!rfd->th) {
/* We can read directly. This must be a regular file, where
reading never blocks. */
DWORD rgot, delta;
DWORD rgot;
if (!ReadFile((HANDLE)rfd->fd, buffer, len, &rgot, NULL)) {
get_windows_error();
@ -713,7 +735,7 @@ intptr_t rktio_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
else
return rgot;
} else {
if (!rktio_poll_read(rfd))
if (!rktio_poll_read_ready(rktio, rfd))
return 0;
/* If we get this far, there's definitely data available.
@ -796,13 +818,11 @@ static long WINAPI WindowsFDReader(Win_FD_Input_Thread *th)
static void WindowsFDICleanup(Win_FD_Input_Thread *th)
{
int rc;
CloseHandle(th->checking_sema);
CloseHandle(th->ready_sema);
CloseHandle(th->you_clean_up_sema);
if (!rc) CloseHandle(th->fd);
CloseHandle(th->fd);
free(th->buffer);
free(th);
@ -908,7 +928,7 @@ intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len
if (!rfd->oth) {
/* The FILE_TYPE_PIPE test is currently redundant, I think,
but better safe than sorry. */
nonblocking = (rktio_windows_nt_or_later()
nonblocking = (rktio->windows_nt_or_later
&& (GetFileType((HANDLE)rfd->fd) == FILE_TYPE_PIPE));
} else
nonblocking = 1; /* must be, or we would not have gotten here */
@ -965,7 +985,7 @@ intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len
|| (!ok && (errsaved == ERROR_NOT_ENOUGH_MEMORY))) {
towrite = towrite >> 1;
if (!towrite) {
set_windows_error();
get_windows_error();
return RKTIO_WRITE_ERROR;
}
} else
@ -1107,10 +1127,13 @@ intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len
ok = 1;
}
ReleaseSemaphore(oth->lock_sema, 1, NULL);
} else if (out_len > 0) {
/* We've already written, which implies that no flush is
in progress. We'll need a flush check in the future. */
rfd->oth->needflush = 1;
} else {
if (out_len > 0) {
/* We've already written, which implies that no flush is
in progress. We'll need a flush check in the future. */
rfd->oth->needflush = 1;
}
ok = 1;
}
if (ok)
@ -1189,13 +1212,11 @@ static long WINAPI WindowsFDWriter(Win_FD_Output_Thread *oth)
static void WindowsFDOCleanup(Win_FD_Output_Thread *oth)
{
int rc;
CloseHandle(oth->lock_sema);
CloseHandle(oth->work_sema);
CloseHandle(oth->you_clean_up_sema);
if (!rc) CloseHandle(oth->fd);
CloseHandle(oth->fd);
if (oth->buffer)
free(oth->buffer);

2
racket/src/rktio/rktio_file.c
View File

@ -158,7 +158,7 @@ static rktio_fd_t *open_write(rktio_t *rktio, char *filename, int modes)
#endif
#ifdef RKTIO_SYSTEM_WINDOWS
HANDLE fd;
int hmode, regfile;
int hmode;
BY_HANDLE_FILE_INFORMATION info;
rktio_fd_t *rfd;

2
racket/src/rktio/rktio_fs_change.c
View File

@ -127,7 +127,7 @@ rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path)
| FILE_NOTIFY_CHANGE_LAST_WRITE
| FILE_NOTIFY_CHANGE_ATTRIBUTES));
if (h == INVALID_HANDLE_VALUE)
set_windows_error();
get_windows_error();
else {
fd = (intptr_t)h;
ok = 1;

13
racket/src/rktio/rktio_ltps.c
View File

@ -44,15 +44,16 @@ typedef struct rktio_ltps_handle_pair_t {
rktio_ltps_handle_t *write_handle;
} rktio_ltps_handle_pair_t;
#ifdef RKTIO_SYSTEM_UNIX
static rktio_ltps_handle_pair_t *ltps_hash_get(rktio_ltps_t *lt, intptr_t fd);
static void ltps_hash_set(rktio_ltps_t *lt, intptr_t fd, rktio_ltps_handle_pair_t *v);
static void ltps_hash_remove(rktio_ltps_t *lt, intptr_t fd);
static void ltps_hash_init(rktio_ltps_t *lt);
static void ltps_hash_free(rktio_ltps_t *lt);
#if !defined(HAVE_KQUEUE_SYSCALL) && !defined(HAVE_EPOLL_SYSCALL)
static int ltps_is_hash_empty(rktio_ltps_t *lt);
#endif
#endif
/*========================================================================*/
@ -104,8 +105,10 @@ rktio_ltps_t *rktio_open_ltps(rktio_t *rktio)
lt->signaled = NULL;
#ifdef RKTIO_SYSTEM_UNIX
ltps_hash_init(lt);
#endif
return lt;
}
@ -129,7 +132,9 @@ int rktio_ltps_close(rktio_t *rktio, rktio_ltps_t *lt)
while ((s = rktio_ltps_get_signaled_handle(rktio, lt)))
free(s);
#ifdef RKTIO_SYSTEM_UNIX
ltps_hash_free(lt);
#endif
#if defined(HAVE_KQUEUE_SYSCALL) || defined(HAVE_EPOLL_SYSCALL)
if (lt->fd >= 0) {
@ -609,6 +614,8 @@ int rktio_ltps_poll(rktio_t *rktio, rktio_ltps_t *lt)
/*========================================================================*/
#ifdef RKTIO_SYSTEM_UNIX
typedef struct ltps_bucket_t {
/* v is non-NULL => bucket is filled */
/* v is NULL and fd is -1 => was removed */
@ -741,3 +748,5 @@ static int ltps_is_hash_empty(rktio_ltps_t *lt)
return (lt->count == 0);
}
#endif
#endif

13
racket/src/rktio/rktio_main.c
View File

@ -21,7 +21,14 @@ rktio_t *rktio_init(void)
return NULL;
}
rktio_useless_wide();
#ifdef RKTIO_SYSTEM_WINDOWS
if (!rktio_winsock_init(rktio)) {
rktio_destroy(rktio);
return NULL;
}
#endif
rktio_init_wide(rktio);
return rktio;
}
@ -32,6 +39,9 @@ void rktio_destroy(rktio_t *rktio)
rktio_free_ghbn(rktio);
rktio_free_global_poll_set(rktio);
rktio_stop_fs_change(rktio);
#ifdef RKTIO_SYSTEM_WINDOWS
rktio_winsock_done(rktio);
#endif
free(rktio);
}
@ -41,4 +51,3 @@ void rktio_free(void *p)
{
free(p);
}

115
racket/src/rktio/rktio_network.c
View File

@ -24,6 +24,8 @@
# define RKTIO_AFNOSUPPORT EAFNOSUPPORT
typedef intptr_t rktio_socket_t;
typedef unsigned int rktio_sockopt_len_t;
# define INVALID_SOCKET (-1)
static void closesocket(rktio_socket_t s) {
@ -92,6 +94,7 @@ struct SOCKADDR_IN {
# define RKTIO_AFNOSUPPORT WSAEAFNOSUPPORT
typedef SOCKET rktio_socket_t;
typedef int rktio_sockopt_len_t;
typedef struct SOCKADDR_IN rktio_unspec_address;
# define REGISTER_SOCKET(s) winsock_remember(s)
@ -521,10 +524,6 @@ static rktio_addrinfo_lookup_t *start_lookup(rktio_t *rktio, rktio_addrinfo_look
# ifdef RKTIO_SYSTEM_WINDOWS
{
HANDLE ready_sema;
unsigned int id;
intptr_t th;
lookup->done_sema = CreateSemaphore(NULL, 0, 1, NULL);
if (!lookup->done_sema) {
get_windows_error();
@ -761,16 +760,10 @@ const char *rktio_gai_strerror(int errnum)
#ifdef RKTIO_SYSTEM_WINDOWS
static HANDLE winsock_sema;
static int winsock_started = 0;
static int wsr_size = 0;
static rktio_socket_t *wsr_array;
void rktio_winsock_init()
{
if (!winsock_sema) {
winsock_sema = CreateSemaphore(NULL, 1, 1, NULL);
}
}
static void winsock_remember(rktio_socket_t s)
{
int i, new_size;
@ -804,18 +797,14 @@ static void winsock_remember(rktio_socket_t s)
wsr_size = new_size;
}
# ifdef RKTIO_USE_PLACES
ReleaseSemaphore(winsock_sema, 1, NULL);
# endif
}
static void winsock_forget(rktio_socket_t s)
{
int i;
# ifdef RKTIO_USE_PLACES
WaitForSingleObject(winsock_sema, INFINITE);
# endif
for (i = 0; i < wsr_size; i++) {
if (wsr_array[i] == s) {
@ -824,50 +813,56 @@ static void winsock_forget(rktio_socket_t s)
}
}
# ifdef RKTIO_USE_PLACES
ReleaseSemaphore(winsock_sema, 1, NULL);
# endif
}
static int winsock_done(void)
int rktio_winsock_init(rktio_t *rktio)
{
if (!winsock_sema) {
winsock_sema = CreateSemaphore(NULL, 1, 1, NULL);
}
WaitForSingleObject(winsock_sema, INFINITE);
if (!winsock_started) {
WSADATA data;
if (!WSAStartup(MAKEWORD(1, 1), &data)) {
winsock_started = 1;
} else {
get_windows_error();
ReleaseSemaphore(winsock_sema, 1, NULL);
return 0;
}
} else
winsock_started++;
ReleaseSemaphore(winsock_sema, 1, NULL);
return 1;
}
void rktio_winsock_done(rktio_t *rktio)
{
int i;
/* only called in the original place */
for (i = 0; i < wsr_size; i++) {
if (wsr_array[i]) {
closesocket(wsr_array[i]);
wsr_array[i] = (rktio_socket_t)NULL;
}
}
return WSACleanup();
}
static void TCP_INIT(char *name)
{
static int started = 0;
WaitForSingleObject(winsock_sema, INFINITE);
if (!started) {
WSADATA data;
if (!WSAStartup(MAKEWORD(1, 1), &data)) {
started = 1;
#ifdef __BORLANDC__
atexit((void(*)())winsock_done);
#else
_onexit(winsock_done);
#endif
if (!--winsock_started) {
for (i = 0; i < wsr_size; i++) {
if (wsr_array[i]) {
closesocket(wsr_array[i]);
wsr_array[i] = (rktio_socket_t)NULL;
}
}
wsr_size = 0;
wsr_array = NULL;
WSACleanup();
}
ReleaseSemaphore(winsock_sema, 1, NULL);
}
#else
/* Not Windows */
# define TCP_INIT(x) /* nothing */
#endif
/*========================================================================*/
@ -1197,7 +1192,7 @@ rktio_fd_t *rktio_connect_finish(rktio_t *rktio, rktio_connect_t *conn)
if (conn->inprogress) {
/* Check whether connect succeeded, or get error: */
int errid;
unsigned int so_len = sizeof(errid);
rktio_sockopt_len_t so_len = sizeof(errid);
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
if (getsockopt(s, SOL_SOCKET, SO_ERROR, (void *)&errid, &so_len) != 0) {
errid = SOCK_ERRNO();
@ -1435,7 +1430,7 @@ static int get_no_portno(rktio_t *rktio, rktio_socket_t socket)
{
char here[RKTIO_SOCK_NAME_MAX_LEN];
struct sockaddr_in *addr_in;
unsigned int l = sizeof(here);
rktio_sockopt_len_t l = sizeof(here);
unsigned short no_port;
if (getsockname(socket, (struct sockaddr *)here, &l)) {
@ -1561,7 +1556,7 @@ rktio_fd_t *rktio_accept(rktio_t *rktio, rktio_listener_t *listener)
int
ready_pos;
rktio_socket_t s, ls;
unsigned int l;
rktio_sockopt_len_t l;
char tcp_accept_addr[RKTIO_SOCK_NAME_MAX_LEN];
ready_pos = do_poll_accept_ready(rktio, listener, 1);
@ -1632,7 +1627,7 @@ static char **get_numeric_strings(rktio_t *rktio, void *sa, unsigned int salen)
char **rktio_socket_address(rktio_t *rktio, rktio_fd_t *rfd)
{
char name[RKTIO_SOCK_NAME_MAX_LEN];
unsigned int name_len;
rktio_sockopt_len_t name_len;
name_len = sizeof(name);
if (getsockname(rktio_fd_system_fd(rktio, rfd), (struct sockaddr *)name, &name_len)) {
@ -1646,7 +1641,7 @@ char **rktio_socket_address(rktio_t *rktio, rktio_fd_t *rfd)
char **rktio_socket_peer_address(rktio_t *rktio, rktio_fd_t *rfd)
{
char name[RKTIO_SOCK_NAME_MAX_LEN];
unsigned int name_len;
rktio_sockopt_len_t name_len;
name_len = sizeof(name);
if (getpeername(rktio_fd_system_fd(rktio, rfd), (struct sockaddr *)name, &name_len)) {
@ -1779,7 +1774,7 @@ rktio_length_and_addrinfo_t *rktio_udp_recvfrom(rktio_t *rktio, rktio_fd_t *rfd,
rktio_length_and_addrinfo_t *r;
int rn, errid;
char src_addr[RKTIO_SOCK_NAME_MAX_LEN];
unsigned int asize = sizeof(src_addr);
rktio_sockopt_len_t asize = sizeof(src_addr);
while (1) {
if (!len) {
@ -1830,7 +1825,7 @@ int rktio_udp_get_multicast_loopback(rktio_t *rktio, rktio_fd_t *rfd)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
u_char loop;
unsigned int loop_len = sizeof(loop);
rktio_sockopt_len_t loop_len = sizeof(loop);
int status;
status = getsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, (void *)&loop, &loop_len);
@ -1846,7 +1841,7 @@ int rktio_udp_set_multicast_loopback(rktio_t *rktio, rktio_fd_t *rfd, int on)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
u_char loop = (on ? 1 : 0);
unsigned int loop_len = sizeof(loop);
rktio_sockopt_len_t loop_len = sizeof(loop);
int status;
status = setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, (void *)&loop, loop_len);
@ -1862,7 +1857,7 @@ int rktio_udp_get_multicast_ttl(rktio_t *rktio, rktio_fd_t *rfd)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
u_char ttl;
unsigned int ttl_len = sizeof(ttl);
rktio_sockopt_len_t ttl_len = sizeof(ttl);
int status;
status = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&ttl, &ttl_len);
@ -1878,7 +1873,7 @@ int rktio_udp_set_multicast_ttl(rktio_t *rktio, rktio_fd_t *rfd, int ttl_val)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
u_char ttl = ttl_val;
unsigned int ttl_len = sizeof(ttl);
rktio_sockopt_len_t ttl_len = sizeof(ttl);
int status;
status = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&ttl, ttl_len);
@ -1894,7 +1889,7 @@ char *rktio_udp_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
struct in_addr intf;
unsigned int intf_len = sizeof(intf);
rktio_sockopt_len_t intf_len = sizeof(intf);
int status;
status = getsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, (void *)&intf, &intf_len);
@ -1913,7 +1908,7 @@ int rktio_udp_set_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd, rktio_add
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
struct in_addr intf;
unsigned int intf_len = sizeof(intf);
rktio_sockopt_len_t intf_len = sizeof(intf);
int status;
if (!intf_addr) {
@ -1937,7 +1932,7 @@ int rktio_udp_change_multicast_group(rktio_t *rktio, rktio_fd_t *rfd,
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
struct ip_mreq mreq;
unsigned int mreq_len = sizeof(mreq);
rktio_sockopt_len_t mreq_len = sizeof(mreq);
int status;
int optname;

35
racket/src/rktio/rktio_poll_set.c
View File

@ -393,7 +393,7 @@ static void init_fdset_array(rktio_poll_set_t *fdarray, int count)
int reset = 0;
fd = rktio_get_fdset(fdarray, i);
fd->added = 0;
if (RKTIO_INT_VAL(fd->alloc) > (2 * RKTIO_INT_VAL(fd->last_alloc))) {
if (fd->alloc > (2 * fd->last_alloc)) {
fd->alloc = 0;
if (fd->sockets) free(fd->sockets);
fd->sockets = NULL;
@ -401,7 +401,7 @@ static void init_fdset_array(rktio_poll_set_t *fdarray, int count)
}
fd->last_alloc = 0;
fd->num_handles = 0;
if (RKTIO_INT_VAL(fd->alloc_handles) > (2 * RKTIO_INT_VAL(fd->last_alloc_handles))) {
if (fd->alloc_handles > (2 * fd->last_alloc_handles)) {
fd->alloc_handles = 0;
if (fd->handles) free(fd->handles);
if (fd->repost_sema) free(fd->repost_sema);
@ -488,7 +488,7 @@ void rktio_fdset(rktio_poll_set_t *fd, int n)
int na;
na = next_size(fd->alloc);
naya = malloc(na * sizeof(SOCKET));
memcpy(naya, fd->sockets, RKTIO_INT_VAL(fd->alloc) * sizeof(SOCKET));
memcpy(naya, fd->sockets, fd->alloc * sizeof(SOCKET));
if (fd->sockets) free(fd->sockets);
fd->sockets = naya;
fd->alloc = na;
@ -630,7 +630,7 @@ void rktio_collapse_win_fd(rktio_poll_set_t *fds)
rfd->combined_wait_array = NULL;
} else {
/* merge */
if (rfd->alloc < RKTIO_INT_VAL(wfd->alloc)) {
if (rfd->alloc < wfd->alloc) {
if (wfd->alloc < efd->alloc)
wa = efd->wait_array;
else
@ -924,8 +924,13 @@ int rktio_initialize_signal(rktio_t *rktio)
}
#endif
#ifdef WIN32_FD_HANDLES
break_semaphore = (void*)CreateSemaphore(NULL, 0, 1, NULL);
#ifdef RKTIO_SYSTEM_WINDOWS
rktio->break_semaphore = (void*)CreateSemaphore(NULL, 0, 1, NULL);
if (rktio->break_semaphore == INVALID_HANDLE_VALUE) {
get_windows_error();
return 0;
} else
return 1;
#endif
}
@ -1111,11 +1116,15 @@ void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds, rktio_ltps_
}
# endif
#else
# ifndef NO_SLEEP
# ifndef NO_USLEEP
usleep((unsigned)(nsecs * 1000));
# else
sleep(nsecs);
# ifdef RKTIO_SYSTEM_WINDOWS
Sleep((DWORD)(nsecs * 1000));
# else
# ifndef NO_SLEEP
# ifndef NO_USLEEP
usleep((unsigned)(nsecs * 1000));
# else
sleep(nsecs);
# endif
# endif
# endif
#endif
@ -1195,7 +1204,7 @@ void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds, rktio_ltps_
HANDLE *array, just_two_array[2];
int count, rcount, *rps;
scheme_collapse_win_fd(fds); /* merges */
rktio_collapse_win_fd(fds); /* merges */
rcount = fds->num_handles;
count = fds->combined_len;
@ -1260,7 +1269,7 @@ void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds, rktio_ltps_
result = MsgWaitForMultipleObjects(count, array, FALSE, msec, fds->wait_event_mask);
}
clean_up_wait(rktio, result, array, rps, rcount);
scheme_collapse_win_fd(fds); /* cleans up */
rktio_collapse_win_fd(fds); /* cleans up */
return;
}

10
racket/src/rktio/rktio_private.h
View File

@ -227,6 +227,8 @@ void rktio_set_racket_error(rktio_t *rktio, int errid);
#ifdef RKTIO_SYSTEM_WINDOWS
void rktio_get_windows_error(rktio_t *rktio);
# define get_windows_error() rktio_get_windows_error(rktio)
void rktio_set_windows_error(rktio_t *rktio, int errid);
# define set_windows_error(errid) rktio_set_windows_error(rktio, errid)
#endif
#if defined(USE_FCNTL_O_NONBLOCK)
@ -243,10 +245,14 @@ void rktio_get_windows_error(rktio_t *rktio);
void rktio_reliably_close(intptr_t s);
#endif
int rktio_system_fd_is_terminal(rktio_t *rktio, intptr_t fd);
void *rktio_envvars_to_block(rktio_t *rktio, rktio_envvars_t *envvars);
void rktio_stop_fs_change(rktio_t *rktio);
#ifdef RKTIO_SYSTEM_UNIX
void rktio_useless_wide();
#ifdef RKTIO_SYSTEM_WINDOWS
int rktio_winsock_init(rktio_t *rktio);
void rktio_winsock_done(rktio_t *rktio);
#endif
void rktio_init_wide(rktio_t *rktio);

40
racket/src/rktio/rktio_process.c
View File

@ -948,7 +948,6 @@ static int do_subprocess_kill(rktio_t *rktio, rktio_process_t *sp, int as_kill)
#if defined(RKTIO_SYSTEM_WINDOWS)
if (as_kill || sp->is_group) {
DWORD w;
int errid;
if (!sp->handle)
return 1;
@ -1137,9 +1136,9 @@ static intptr_t do_spawnv(rktio_t *rktio,
/* If none of the stdio handles are consoles, specifically
create the subprocess without a console: */
if (!is_fd_terminal((intptr_t)startup.hStdInput)
&& !is_fd_terminal((intptr_t)startup.hStdOutput)
&& !is_fd_terminal((intptr_t)startup.hStdError))
if (!rktio_system_fd_is_terminal(rktio, (intptr_t)startup.hStdInput)
&& !rktio_system_fd_is_terminal(rktio, (intptr_t)startup.hStdOutput)
&& !rktio_system_fd_is_terminal(rktio, (intptr_t)startup.hStdError))
cr_flag = CREATE_NO_WINDOW;
else
cr_flag = 0;
@ -1218,12 +1217,16 @@ static void CloseFileHandleForSubprocess(intptr_t *hs, int pos)
#define RKTIO_COPY_FOR_SUBPROCESS(array, pos) CopyFileHandleForSubprocess(array, pos)
#define RKTIO_CLOSE_SUBPROCESS_COPY(array, pos) CloseFileHandleForSubprocess(array, pos)
#define RKTIO_CLOSE(fd) CloseHandle((HANDLE)fd)
#endif /* RKTIO_SYSTEM_WINDOWS */
#ifdef RKTIO_SYSTEM_UNIX
# define RKTIO_COPY_FOR_SUBPROCESS(array, pos) /* empty */
# define RKTIO_CLOSE_SUBPROCESS_COPY(array, pos) /* empty */
# define RKTIO_CLOSE(fd) rktio_reliably_close(fd)
#endif
/*========================================================================*/
@ -1239,7 +1242,7 @@ rktio_process_result_t *rktio_process(rktio_t *rktio,
{
rktio_process_result_t *result;
intptr_t to_subprocess[2], from_subprocess[2], err_subprocess[2];
int pid, errid;
int pid;
#if defined(RKTIO_SYSTEM_UNIX)
# if !defined(CENTRALIZED_SIGCHILD)
System_Child *sc;
@ -1324,8 +1327,10 @@ rktio_process_result_t *rktio_process(rktio_t *rktio,
argv = new_argv;
}
pid = 0;
spawn_status = do_spawnv(rktio,
command, (const char * const *)new_argv,
command, (const char * const *)argv,
windows_exact_cmdline,
to_subprocess[0],
from_subprocess[1],
@ -1452,6 +1457,8 @@ rktio_process_result_t *rktio_process(rktio_t *rktio,
case 0: /* child */
{
int errid;
/* Copy pipe descriptors to stdin and stdout */
do {
errid = MSC_IZE(dup2)(to_subprocess[0], 0);
@ -1528,22 +1535,21 @@ rktio_process_result_t *rktio_process(rktio_t *rktio,
free(env);
if (!stdin_fd) {
rktio_reliably_close(to_subprocess[0]);
} else {
if (!stdin_fd)
RKTIO_CLOSE(to_subprocess[0]);
else
RKTIO_CLOSE_SUBPROCESS_COPY(to_subprocess, 0);
}
if (!stdout_fd) {
rktio_reliably_close(from_subprocess[1]);
} else {
if (!stdout_fd)
RKTIO_CLOSE(from_subprocess[1]);
else
RKTIO_CLOSE_SUBPROCESS_COPY(from_subprocess, 1);
}
if (!stderr_fd) {
if (!stderr_is_stdout)
rktio_reliably_close(err_subprocess[1]);
} else {
RKTIO_CLOSE(err_subprocess[1]);
} else
RKTIO_CLOSE_SUBPROCESS_COPY(err_subprocess, 1);
}
/*--------------------------------------*/
/* Create new file-descriptor objects */

21
racket/src/rktio/rktio_wide.c
View File

@ -4,8 +4,7 @@
/* For converting byte strings to and from "wide" strings on Windows. */
#ifdef RKTIO_SYSTEM_UNIX
/* To avoid complaints about an empty object file */
void rktio_useless_wide() { }
void rktio_init_wide(rktio_t *rktio) { }
#endif
#ifdef RKTIO_SYSTEM_WINDOWS
@ -14,6 +13,17 @@ void rktio_useless_wide() { }
#include <string.h>
#include <stdlib.h>
void rktio_init_wide(rktio_t *rktio)
{
OSVERSIONINFO info;
info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&info);
if (info.dwPlatformId == VER_PLATFORM_WIN32_NT)
rktio->windows_nt_or_later = 1;
else
rktio->windows_nt_or_later = 0;
}
/* A UTF-8 to UTF-16 conversion, but accepts an extended variant of
UTF-16 that accommodates unpaired surrogates, so that all 16-byte
sequences are accessible. */
@ -300,7 +310,8 @@ wchar_t *rktio_convert_to_wchar(rktio_t *rktio, const char *s, int do_copy)
rktio->wide_buffer_size = RKTIO_MAX_IDEAL_BUFFER_SIZE;
ws = malloc(sizeof(wchar_t) * RKTIO_MAX_IDEAL_BUFFER_SIZE);
rktio->wide_buffer = ws;
}
} else
ws = rktio->wide_buffer;
(void)utf8ish_to_utf16ish((unsigned char *)s, l, (unsigned short*)ws, '\t');
@ -316,9 +327,9 @@ char *rktio_convert_from_wchar(const wchar_t *ws, int free_given)
len = utf16ish_to_utf8ish((unsigned short *)ws, l, NULL);
s = (char *)scheme_malloc_atomic(len);
s = malloc(len);
len = utf16ish_to_utf8ish((unsigned short *)ws, l, s);
len = utf16ish_to_utf8ish((unsigned short *)ws, l, (unsigned char *)s);
if (free_given)
free((void *)ws);