NAME 
src/io/name.c - Win32 IO layer
DESCRIPTION
This is the Parrot OS-specific IO layer for Win32 platforms.
References
Win32 System Programming, 2nd Edition.
Functions
*/
#ifdef WIN32 # include <windows.h> #endif
#include "parrot/parrot.h" #include "io_private.h"
#ifdef PIO_OS_WIN32
/* HEADERIZER HFILE: none */ /* HEADERIZER BEGIN: static */
static INTVAL flags_to_win32( INTVAL flags, NOTNULL(DWORD * fdwAccess), NOTNULL(DWORD * fdwShareMode), NOTNULL(DWORD * fdwCreate) ) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4);
PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_accept( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io) ) __attribute__nonnull__(1) __attribute__nonnull__(3);
static INTVAL PIO_win32_bind( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NULLOK(STRING *l) ) __attribute__nonnull__(1) __attribute__nonnull__(3);
static INTVAL PIO_win32_close( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io) ) __attribute__nonnull__(3);
static INTVAL PIO_win32_connect( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *r) ) __attribute__nonnull__(1) __attribute__nonnull__(3) __attribute__nonnull__(4);
PARROT_WARN_UNUSED_RESULT PARROT_CANNOT_RETURN_NULL static ParrotIO * PIO_win32_fdopen( PARROT_INTERP, SHIM(ParrotIOLayer *layer), PIOHANDLE fd, INTVAL flags ) __attribute__nonnull__(1);
static INTVAL PIO_win32_flush( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io) ) __attribute__nonnull__(3);
static INTVAL PIO_win32_init( PARROT_INTERP, NOTNULL(ParrotIOLayer *layer) ) __attribute__nonnull__(1) __attribute__nonnull__(2);
PARROT_WARN_UNUSED_RESULT static INTVAL PIO_win32_isatty( PIOHANDLE fd );
static INTVAL PIO_win32_listen( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), INTVAL backlog ) __attribute__nonnull__(3);
PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_open( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(const char *spath), INTVAL flags ) __attribute__nonnull__(1) __attribute__nonnull__(3);
static size_t PIO_win32_read( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING **buf) ) __attribute__nonnull__(1) __attribute__nonnull__(3) __attribute__nonnull__(4);
static INTVAL PIO_win32_recv( PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING **s) ) __attribute__nonnull__(1) __attribute__nonnull__(3) __attribute__nonnull__(4);
static PIOOFF_T PIO_win32_seek( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), PIOOFF_T off, INTVAL whence ) __attribute__nonnull__(3);
static INTVAL PIO_win32_send( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *s) ) __attribute__nonnull__(3) __attribute__nonnull__(4);
PARROT_WARN_UNUSED_RESULT PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_socket( PARROT_INTERP, SHIM(ParrotIOLayer *layer), int fam, int type, int proto ) __attribute__nonnull__(1);
static PIOOFF_T PIO_win32_tell( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io) ) __attribute__nonnull__(3);
static size_t PIO_win32_write( SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *s) ) __attribute__nonnull__(3) __attribute__nonnull__(4);
/* HEADERIZER END: static */
# include <tchar.h>
/* Defined at bottom */ extern const ParrotIOLayerAPI pio_win32_layer_api;
ParrotIOLayer pio_win32_layer = { NULL, "win32", PIO_L_TERMINAL, &pio_win32_layer_api, 0, 0 };
/*
FUNCDOC: flags_to_win32
Convert to platform-specific bit open flags.
*/
static INTVAL flags_to_win32(INTVAL flags, NOTNULL(DWORD * fdwAccess), NOTNULL(DWORD * fdwShareMode), NOTNULL(DWORD * fdwCreate)) { static DWORD dwDefaultShareMode; if (!dwDefaultShareMode) { OSVERSIONINFO osvi; osvi.dwOSVersionInfoSize = sizeof (osvi); GetVersionEx(&osvi); if (osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) { dwDefaultShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; } else { dwDefaultShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE; } }
if ((flags & (PIO_F_WRITE | PIO_F_READ)) == (PIO_F_WRITE | PIO_F_READ)) {
*fdwAccess = GENERIC_WRITE | GENERIC_READ;
if (flags & PIO_F_TRUNC)
*fdwCreate = CREATE_ALWAYS;
else
*fdwCreate = OPEN_ALWAYS;
}
else if (flags & PIO_F_WRITE) {
*fdwAccess = GENERIC_WRITE;
if (flags & PIO_F_TRUNC)
*fdwCreate = CREATE_ALWAYS;
else
*fdwCreate = OPEN_ALWAYS;
}
else if (flags & PIO_F_READ) {
*fdwAccess = GENERIC_READ;
*fdwCreate = OPEN_EXISTING;
}
*fdwShareMode = dwDefaultShareMode;
if (flags & PIO_F_APPEND) {
/* dealt with specially in _write and _puts */
}
return 1;
}
/*
FUNCDOC: PIO_win32_init
Sets up the standard std* IO handles.
*/
static INTVAL PIO_win32_init(PARROT_INTERP, NOTNULL(ParrotIOLayer *layer)) { HANDLE h; # if PARROT_NET_DEVEL struct WSAData sockinfo; int ret; # endif
if ((h = GetStdHandle(STD_INPUT_HANDLE)) != INVALID_HANDLE_VALUE) {
_PIO_STDIN(interp) = new_io_pmc(interp,
PIO_win32_fdopen(interp, layer, h, PIO_F_READ));
}
else {
return -1;
}
if ((h = GetStdHandle(STD_OUTPUT_HANDLE)) != INVALID_HANDLE_VALUE) {
_PIO_STDOUT(interp) = new_io_pmc(interp,
PIO_win32_fdopen(interp, layer, h, PIO_F_WRITE));
}
else {
return -2;
}
if ((h = GetStdHandle(STD_ERROR_HANDLE)) != INVALID_HANDLE_VALUE) {
_PIO_STDERR(interp) = new_io_pmc(interp,
PIO_win32_fdopen(interp, layer, h, PIO_F_WRITE));
}
else {
return -3;
}
# if PARROT_NET_DEVEL
/* Start Winsock
* no idea where or whether destroy it
*/
ret = WSAStartup(2, &sockinfo);
if (ret != 0) {
fprintf(stderr, "WSAStartup failed!!\n ErrorCode=%i\n\n",
WSAGetLastError());
return -4;
}
# endif
return 0;
}
/*
FUNCDOC: PIO_win32_getblksize
Returns PIO_BLKSIZE.
*/
INTVAL PIO_win32_getblksize(SHIM(PIOHANDLE fd)) { /* Hard coded for now */ return PIO_BLKSIZE; }
/*
FUNCDOC: PIO_win32_open
Calls CreateFile() to open *spath with the Win32 translation of flags.
*/
PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_open(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(const char *spath), INTVAL flags) { ParrotIO *io; DWORD fAcc, fShare, fCreat; PIOHANDLE fd;
const int type = PIO_TYPE_FILE;
# if 0
if ((Interp_flags_TEST(interp, PARROT_DEBUG_FLAG)) != 0) {
fprintf(stderr, "PIO_win32_open: %s\n", spath);
}
# endif
if ((flags & (PIO_F_WRITE | PIO_F_READ)) == 0)
return NULL;
/* Set open flags - <, >, >>, +<, +> */
/* add ? and ! for block/non-block */
if (flags_to_win32(flags, &fAcc, &fShare, &fCreat) < 0)
return NULL;
/* Only files for now */
flags |= PIO_F_FILE;
fd = CreateFile(spath, fAcc, fShare, NULL, fCreat,
FILE_ATTRIBUTE_NORMAL, NULL);
if (fd != INVALID_HANDLE_VALUE) {
io = PIO_new(interp, type, flags, 0);
io->fd = fd;
return io;
}
else {
int err = GetLastError();
if (err) {
errno = err;
}
}
return NULL;
}
/*
FUNCDOC: PIO_win32_fdopen
Returns a new ParrotIO with fd as its file descriptor.
*/
PARROT_WARN_UNUSED_RESULT PARROT_CANNOT_RETURN_NULL static ParrotIO * PIO_win32_fdopen(PARROT_INTERP, SHIM(ParrotIOLayer *layer), PIOHANDLE fd, INTVAL flags) { ParrotIO *io; INTVAL mode; mode = 0;
if (PIO_win32_isatty(fd))
flags |= PIO_F_CONSOLE;
/* fdopened files are always shared */
flags |= PIO_F_SHARED;
io = PIO_new(interp, PIO_F_FILE, flags, mode);
io->fd = fd;
return io;
}
/*
FUNCDOC: PIO_win32_close
Calls CloseHandle() to close *io's file descriptor.
*/
static INTVAL PIO_win32_close(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io)) { if (io && io->fd != INVALID_HANDLE_VALUE) { CloseHandle(io->fd); io->fd = INVALID_HANDLE_VALUE; } return 0; }
/*
FUNCDOC: PIO_win32_isatty
Returns whether fd is a console/tty.
*/
PARROT_WARN_UNUSED_RESULT static INTVAL PIO_win32_isatty(PIOHANDLE fd) { const DWORD ftype = GetFileType(fd); return (ftype == FILE_TYPE_CHAR); }
/*
FUNCDOC: PIO_win32_flush
Calls FlushFileBuffers() to flush *io's file descriptor.
*/
static INTVAL PIO_win32_flush(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io)) { /* * FlushFileBuffers won't work for console handles. From the MS help file: * * Windows NT: The function fails if hFile is a handle to console * output. That is because console output is not buffered. The * function returns FALSE, and GetLastError returns * ERROR_INVALID_HANDLE. * * Windows 9x: The function does nothing if hFile is a handle to * console output. That is because console output is not buffered. * The function returns TRUE, but it does nothing. */ return FlushFileBuffers(io->fd); }
/*
FUNCDOC: PIO_win32_read
Calls ReadFile() to read up to len bytes from *io's file descriptor to the memory starting at buffer.
*/
static size_t PIO_win32_read(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING **buf)) { DWORD countread; void *buffer; size_t len; STRING *s;
s = PIO_make_io_string(interp, buf, 2048);
len = s->bufused;
buffer = s->strstart;
if (ReadFile(io->fd, (LPVOID) buffer, (DWORD) len, &countread, NULL)) {
if (countread > 0) {
s->bufused = s->strlen = countread;
return (size_t)countread;
}
else if (len > 0)
/* EOF if read 0 and bytes were requested */
io->flags |= PIO_F_EOF;
}
else {
/* FIXME : An error occured */
}
s->bufused = s->strlen = 0;
return 0;
}
/*
FUNCDOC: PIO_win32_write
Calls WriteFile() to write len bytes from the memory starting at buffer to *io's file descriptor.
*/
static size_t PIO_win32_write(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *s)) { DWORD countwrote = 0; void * const buffer = s->strstart; size_t len = s->bufused;
/* do it by hand, Win32 hasn't any specific flag */
if (io->flags & PIO_F_APPEND) {
LARGE_INTEGER p;
p.LowPart = 0;
p.HighPart = 0;
p.LowPart = SetFilePointer(io->fd, p.LowPart,
&p.HighPart, FILE_END);
if (p.LowPart == 0xFFFFFFFF && (GetLastError() != NO_ERROR)) {
/* Error - exception */
return -1;
}
}
if (io
&& WriteFile(io->fd, (LPCSTR) buffer, (DWORD) len, &countwrote, NULL))
return countwrote;
/* FIXME: Set error flag */
return (size_t)-1;
}
/*
FUNCDOC: PIO_win32_seek
Hard seek.
Calls SetFilePointer() to move the read/write position of *io's file descriptor to off bytes relative to the location specified by whence.
*/
static PIOOFF_T PIO_win32_seek(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), PIOOFF_T off, INTVAL whence) { LARGE_INTEGER offset;
offset.QuadPart = off;
/* offset.HighPart gets overwritten */
offset.LowPart = SetFilePointer(io->fd, offset.LowPart,
&offset.HighPart, whence);
if (offset.LowPart == 0xFFFFFFFF && (GetLastError() != NO_ERROR)) {
/* Error - exception */
return -1;
}
io->fpos = offset.QuadPart;
return io->fpos;
}
/*
FUNCDOC: PIO_win32_tell
Returns the current read/write position of *io's file descriptor.
*/
static PIOOFF_T PIO_win32_tell(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io)) { LARGE_INTEGER p;
p.QuadPart = piooffsetzero;
p.LowPart = SetFilePointer(io->fd, 0, &p.HighPart, FILE_CURRENT);
if (p.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR) {
/* FIXME: Error - exception */
}
return p.QuadPart;
}
/*
FUNCDOC: PIO_sockaddr_in
PIO_sockaddr_in() is not part of the layer and so must be extern.
XXX: We can probably just write our own routines (htons(), inet_aton(), etc.) and take this out of platform specific compilation
*/
PARROT_WARN_UNUSED_RESULT PARROT_CAN_RETURN_NULL STRING * PIO_sockaddr_in(PARROT_INTERP, unsigned short port, NOTNULL(STRING *addr)) { struct sockaddr_in sa; struct hostent *he; char * const s = string_to_cstring(interp, addr); /* Hard coded to IPv4 for now */
sa.sin_addr.s_addr = inet_addr(s);
/* Maybe it is a hostname, try to lookup */
/* XXX Check PIO option before doing a name lookup,
* it may have been toggled off.
*/
he = gethostbyname(s);
/* XXX FIXME - Handle error condition better */
if (!he) {
string_cstring_free(s);
fprintf(stderr, "gethostbyname failure [%s]\n", s);
return NULL;
}
memcpy((char*)&sa.sin_addr, he->h_addr, sizeof (sa.sin_addr));
string_cstring_free(s);
sa.sin_port = htons(port);
return string_make(interp, (char *)&sa, sizeof (struct sockaddr), "binary", 0);
}
/****************************************************************************/
# if PARROT_NET_DEVEL
/*
FUNCDOC: PIO_win32_socket
Uses socket() to create a socket with the specified address family, socket type and protocol number.
*/
PARROT_WARN_UNUSED_RESULT PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_socket(PARROT_INTERP, SHIM(ParrotIOLayer *layer), int fam, int type, int proto) { const int sock = socket(fam, type, proto);
if (sock >= 0) {
ParrotIO * const io = PIO_new(interp, PIO_F_SOCKET, 0, PIO_F_READ|PIO_F_WRITE);
io->fd = (PIOHANDLE) sock;
io->remote.sin_family = fam;
return io;
}
perror("socket:");
return NULL;
}
/*
FUNCDOC: PIO_win32_connect
Connects *io's socket to address *r.
*/
static INTVAL PIO_win32_connect(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *r)) { if (r) { struct sockaddr_in sa; memcpy(&sa, PObj_bufstart(r), sizeof (struct sockaddr)); io->remote.sin_addr.s_addr = sa.sin_addr.s_addr; io->remote.sin_port = sa.sin_port; }
/* PIO_eprintf(interp, "connect: fd = %d port = %d\n",
* io->fd, ntohs(io->remote.sin_port));*/
if ((connect((SOCKET)io->fd, (struct sockaddr*)&io->remote,
sizeof (struct sockaddr))) != 0) {
PIO_eprintf(interp, "PIO_win32_connect: errno = %d\n",
WSAGetLastError());
return -1;
}
return 0;
}
/*
FUNCDOC: PIO_win32_send
Send the message *s to *io's connected socket.
*/
static INTVAL PIO_win32_send(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING *s)) { int error, bytes, byteswrote, maxwrite;
bytes = sizeof(s); /* XXX This can't be correct, to send the size of a pointer */
byteswrote = 0;
maxwrite = 2048;
AGAIN:
/*
* Ignore encoding issues for now.
*/
if ((error = send((SOCKET)io->fd, (char *)PObj_bufstart(s) + byteswrote,
PObj_buflen(s), 0)) >= 0) {
byteswrote += error;
if (byteswrote >= bytes) {
return byteswrote;
}
else if (bytes - byteswrote < maxwrite) {
maxwrite = bytes - byteswrote;
}
goto AGAIN;
}
else {
switch (errno) {
case EINTR:
goto AGAIN;
# ifdef EWOULDBLOCK
case EWOULDBLOCK:
goto AGAIN;
# else
case EAGAIN:
goto AGAIN;
# endif
case EPIPE:
_close((SOCKET)io->fd);
return -1;
default:
return -1;
}
}
}
/*
FUNCDOC: PIO_win32_recv
Receives a message in **s from *io's connected socket.
*/
static INTVAL PIO_win32_recv(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NOTNULL(STRING **s)) { int error; int err; unsigned int bytesread = 0; char buf[2048+1];
AGAIN: error = recv((SOCKET)io->fd, buf, 2048, 0); err = WSAGetLastError(); if (error > 0) { if (error > 0) bytesread += error; else { _close((SOCKET)io->fd); } /* The charset should probably be 'binary', but right now httpd.imc * only works with 'ascii' */ *s = string_make(interp, buf, bytesread, "ascii", 0); if (!*s) { PANIC(interp, "PIO_recv: Failed to allocate string"); } # if PIO_TRACE PIO_eprintf(interp, "PIO_win32_recv: %d bytes\n", bytesread); # endif return bytesread; } else { switch (err) { case WSAEINTR: goto AGAIN; case WSAEWOULDBLOCK: goto AGAIN; case WSAECONNRESET: _close((SOCKET)io->fd); # if PIO_TRACE PIO_eprintf(interp, "recv: Connection reset by peer\n"); # endif return -1; default: _close((SOCKET)io->fd); # if PIO_TRACE PIO_eprintf(interp, "recv: errno = %d\n", err); # endif return -1; } } }
/*
FUNCDOC: PIO_win32_bind
Binds *io's socket to the local address and port specified by *l.
*/
static INTVAL PIO_win32_bind(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), NULLOK(STRING *l)) { struct sockaddr_in sa;
if (!l)
return -1;
memcpy(&sa, PObj_bufstart(l), sizeof (struct sockaddr));
io->local.sin_addr.s_addr = sa.sin_addr.s_addr;
io->local.sin_port = sa.sin_port;
io->local.sin_family = AF_INET;
if ((bind((SOCKET)io->fd, (struct sockaddr *)&io->local,
sizeof (struct sockaddr))) == -1) {
PIO_eprintf(interp, "PIO_win32_bind: errno = %d\n",
WSAGetLastError());
return -1;
}
return 0;
}
/*
FUNCDOC: PIO_win32_listen
Listen for new connections. This is only applicable to STREAM or SEQ sockets.
*/
static INTVAL PIO_win32_listen(SHIM_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io), INTVAL backlog) { if ((listen((SOCKET)io->fd, backlog)) == -1) { fprintf(stderr, "listen: errno= ret=%d fd = %d port = %d\n", errno, (int)io->fd, ntohs(io->local.sin_port)); return -1; } return 0; }
/*
FUNCDOC: PIO_win32_accept
Accept a new connection and return a newly created ParrotIO socket.
*/
PARROT_CAN_RETURN_NULL static ParrotIO * PIO_win32_accept(PARROT_INTERP, SHIM(ParrotIOLayer *layer), NOTNULL(ParrotIO *io)) { int newsock; int err_code;
ParrotIO * const newio = PIO_new(interp, PIO_F_SOCKET, 0, PIO_F_READ|PIO_F_WRITE);
Parrot_Socklen_t newsize = sizeof (struct sockaddr);
newsock = accept((SOCKET)io->fd, (struct sockaddr *)&(newio->remote),
&newsize);
err_code = WSAGetLastError();
if (err_code != 0) {
fprintf(stderr, "accept: errno=%d", err_code);
/* Didn't get far enough, free the io */
mem_sys_free(newio);
return NULL;
}
newio->fd = (PIOHANDLE) newsock;
/* XXX FIXME: Need to do a getsockname and getpeername here to
* fill in the sockaddr_in structs for local and peer
*/
/* Optionally do a gethostyaddr() to resolve remote IP address.
* This should be based on an option set in the master socket
*/
return newio;
}
# endif
/******************************************************************************/
const ParrotIOLayerAPI pio_win32_layer_api = { PIO_win32_init, PIO_base_new_layer, PIO_base_delete_layer, PIO_null_push_layer, PIO_null_pop_layer, PIO_win32_open, PIO_null_open2, PIO_null_open3, PIO_null_open_async, PIO_win32_fdopen, PIO_win32_close, PIO_win32_write, PIO_null_write_async, PIO_win32_read, PIO_null_read_async, PIO_win32_flush, NULL, /* no peek */ PIO_win32_seek, PIO_win32_tell, PIO_null_setbuf, PIO_null_setlinebuf, PIO_null_getcount, PIO_null_fill, PIO_null_eof, # if PARROT_NET_DEVEL NULL, PIO_win32_socket, PIO_win32_connect, PIO_win32_send, PIO_win32_recv, PIO_win32_bind, PIO_win32_listen, PIO_win32_accept # else NULL, /* no poll */ NULL, /* no socket */ NULL, /* no connect */ NULL, /* no send */ NULL, /* no recv */ NULL, /* no bind */ NULL, /* no listen */ NULL, /* no accept */ # endif };
#endif /* PIO_OS_WIN32 */
/*
SEE ALSO
src/io/io_buf.c, src/io/io_passdown.c, src/io/io_stdio.c, src/io/io_unix.c, src/io/io.c, src/io/io_private.h.
HISTORY
Initially written by Melvin Smith.
*/
/* * Local variables: * c-file-style: "parrot" * End: * vim: expandtab shiftwidth=4: */
