3-3 c2

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/defs.h

@@ -1,3 +1,8 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* Redefined and missing POSIX macros
+*/
 #pragma once
 
 #include <memory.h>

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/fcntl.h

@@ -1,3 +1,8 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* POSIX header and needed function definitions
+*/
 #include "w32posix.h"
 
 #define fcntl w32_fcntl

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/sys/select.h

@@ -1,3 +1,8 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* POSIX header and needed function definitions 
+*/
 #include "..\w32posix.h"
 
 #define select w32_select

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/sys/socket.h

@@ -1,3 +1,9 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* POSIX header and needed function definitions
+*/
+
 #include "..\w32posix.h"
 
 #define socket w32_socket

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/sys/stat.h

@@ -1,3 +1,9 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* POSIX header and needed function definitions
+*/
+
 #include "..\w32posix.h"
 
 #define fstat w32_fstat

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/unistd.h

@@ -1,3 +1,9 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* POSIX header and needed function definitions
+*/
+
 #include "w32posix.h"
 
 #define pipe w32_pipe

contrib/win32/w32-posix-prototype/win32posix/win32posix/inc/w32posix.h

@@ -1,3 +1,8 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* Win32 renamed POSIX APIs
+*/
 #pragma once
 
 #include <WinSock2.h>

contrib/win32/w32-posix-prototype/win32posix/win32posix/w32fd.c

@@ -1,3 +1,8 @@
+/*
+* Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+*
+* Implementation of POSIX APIs
+*/
 #include "inc\w32posix.h"
 #include "w32fd.h"
 #include <stdarg.h>
@@ -5,17 +10,25 @@
 #include <time.h>
 #include <assert.h>
 
+/* internal table that stores the fd to w32_io mapping*/
 struct w32fd_table {
-    w32_fd_set occupied;
+	w32_fd_set occupied;		/*bit map for tracking occipied table entries*/
-    struct w32_io* w32_ios[MAX_FDS];
+	struct w32_io* w32_ios[MAX_FDS];/*array of references to mapped w32_io objects*/
 };
 
-struct w32fd_table fd_table;
+/* mapping table*/
-struct w32_io w32_io_stdin, w32_io_stdout, w32_io_stderr;
+static struct w32fd_table fd_table;
+
+/* static table entries representing std in, out and error*/
+static struct w32_io w32_io_stdin, w32_io_stdout, w32_io_stderr;
+
+/* maps pio to fd (specified by index)*/
 void fd_table_set(struct w32_io* pio, int index);
 
 #pragma warning(disable:4312)
-int fd_table_initialize() {
+/* initializes mapping table*/
+static int 
+fd_table_initialize() {
 	memset(&fd_table, 0, sizeof(fd_table));
 	memset(&w32_io_stdin, 0, sizeof(w32_io_stdin));
 	w32_io_stdin.handle = (HANDLE)STD_INPUT_HANDLE;
@@ -32,13 +45,14 @@ int fd_table_initialize() {
 	return 0;
 }
 
-static int fd_table_get_min_index() {
+/* get a free slot in mapping table with least index*/
+static int 
+fd_table_get_min_index() {
 	int min_index = 0;
 	unsigned char* bitmap = fd_table.occupied.bitmap;
 	unsigned char tmp;
 
-    while (*bitmap == 0xff)
+	while (*bitmap == 0xff)  {
-    {
 		bitmap++;
 		min_index += 8;
 		if (min_index >= MAX_FDS) {
@@ -59,56 +73,57 @@ static int fd_table_get_min_index() {
 	return min_index;
 }
 
-static void fd_table_set(struct w32_io* pio, int index) {
+static void 
+fd_table_set(struct w32_io* pio, int index) {
 	fd_table.w32_ios[index] = pio;
 	pio->table_index = index;
 	assert(pio->type != UNKNOWN_FD);
 	FD_SET(index, &(fd_table.occupied));
 }
 
-static void fd_table_clear(int index)
+static void 
+fd_table_clear(int index)
 {
 	fd_table.w32_ios[index]->table_index = -1;
 	fd_table.w32_ios[index] = NULL;
 	FD_CLR(index, &(fd_table.occupied));
 }
 
-void w32posix_initialize() {
+void 
+w32posix_initialize() {
 	if ((debug_initialize() != 0)
 	    || (fd_table_initialize() != 0)
 	    || (socketio_initialize() != 0))
 		abort();
 }
 
-void w32posix_done() {
+void 
+w32posix_done() {
 	debug_done();
 	socketio_done();
 }
 
-BOOL w32_io_is_blocking(struct w32_io* pio)
+BOOL 
+w32_io_is_blocking(struct w32_io* pio)
 {
 	return (pio->fd_status_flags & O_NONBLOCK) ? FALSE : TRUE;
 }
 
-BOOL w32_io_is_io_available(struct w32_io* pio, BOOL rd) {
+BOOL 
-    if (pio->type == SOCK_FD) {
+w32_io_is_io_available(struct w32_io* pio, BOOL rd) {
+	if (pio->type == SOCK_FD) 
 		return socketio_is_io_available(pio, rd);
-    }
+	else 
-    else {
 		return fileio_is_io_available(pio, rd);
-    }
-
 }
 
-int w32_io_on_select(struct w32_io* pio, BOOL rd)
+int 
+w32_io_on_select(struct w32_io* pio, BOOL rd)
 {
-    if ((pio->type == SOCK_FD)) {
+	if ((pio->type == SOCK_FD))
 		return socketio_on_select(pio, rd);
-    }
+	else 
-    else {
 		return fileio_on_select(pio, rd);
-    }
-
 }
 
 #define CHECK_FD(fd) do {							\
@@ -129,7 +144,8 @@ int w32_io_on_select(struct w32_io* pio, BOOL rd)
 	}                                                                   \
 } while (0)
 
-int w32_socket(int domain, int type, int protocol) {
+int 
+w32_socket(int domain, int type, int protocol) {
 	int min_index = fd_table_get_min_index();
 	struct w32_io* pio = NULL;
 
@@ -138,9 +154,8 @@ int w32_socket(int domain, int type, int protocol) {
 		return -1;
 
 	pio = socketio_socket(domain, type, protocol);
-    if (!pio) {
+	if (pio == NULL) 
 		return -1;
-    }
 
 	pio->type = SOCK_FD;
 	fd_table_set(pio, min_index);
@@ -148,7 +163,8 @@ int w32_socket(int domain, int type, int protocol) {
 	return min_index;
 }
 
-int w32_accept(int fd, struct sockaddr* addr, int* addrlen)
+int 
+w32_accept(int fd, struct sockaddr* addr, int* addrlen)
 {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
@@ -160,9 +176,8 @@ int w32_accept(int fd, struct sockaddr* addr, int* addrlen)
 		return -1;
 
 	pio = socketio_accept(fd_table.w32_ios[fd], addr, addrlen);
-    if (!pio) {
+	if (!pio) 
 		return -1;
-    }
 
 	pio->type = SOCK_FD;
 	fd_table_set(pio, min_index);
@@ -170,70 +185,80 @@ int w32_accept(int fd, struct sockaddr* addr, int* addrlen)
 	return min_index;
 }
 
-int w32_setsockopt(int fd, int level, int optname, const char* optval, int optlen) {
+int 
+w32_setsockopt(int fd, int level, int optname, const char* optval, int optlen) {
 	debug3("fd:%d", fd); 
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_setsockopt(fd_table.w32_ios[fd], level, optname, optval, optlen);
 }
 
-int w32_getsockopt(int fd, int level, int optname, char* optval, int* optlen) {
+int 
+w32_getsockopt(int fd, int level, int optname, char* optval, int* optlen) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_getsockopt(fd_table.w32_ios[fd], level, optname, optval, optlen);
 }
 
-int w32_getsockname(int fd, struct sockaddr* name, int* namelen) {
+int 
+w32_getsockname(int fd, struct sockaddr* name, int* namelen) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_getsockname(fd_table.w32_ios[fd], name, namelen);
 }
 
-int w32_getpeername(int fd, struct sockaddr* name, int* namelen) {
+int 
+w32_getpeername(int fd, struct sockaddr* name, int* namelen) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_getpeername(fd_table.w32_ios[fd], name, namelen);
 }
 
-int w32_listen(int fd, int backlog) {
+int 
+w32_listen(int fd, int backlog) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_listen(fd_table.w32_ios[fd], backlog);
 }
 
-int w32_bind(int fd, const struct sockaddr *name, int namelen) {
+int 
+w32_bind(int fd, const struct sockaddr *name, int namelen) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_bind(fd_table.w32_ios[fd], name, namelen);
 }
 
-int w32_connect(int fd, const struct sockaddr* name, int namelen) {
+int 
+w32_connect(int fd, const struct sockaddr* name, int namelen) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_connect(fd_table.w32_ios[fd], name, namelen);
 }
 
-int w32_recv(int fd, void *buf, size_t len, int flags) {
+int 
+w32_recv(int fd, void *buf, size_t len, int flags) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
 	return socketio_recv(fd_table.w32_ios[fd], buf, len, flags);
 }
 
-int w32_send(int fd, const void *buf, size_t len, int flags) {
+int 
+w32_send(int fd, const void *buf, size_t len, int flags) {
 	debug3("fd:%d", fd);
 	CHECK_FD(fd);
 	return socketio_send(fd_table.w32_ios[fd], buf, len, flags);
 }
 
 
-int w32_shutdown(int fd, int how) {
+int 
+w32_shutdown(int fd, int how) {
 	debug3("fd:%d how:%d", fd, how);
 	CHECK_FD(fd);
 	CHECK_SOCK_IO(fd_table.w32_ios[fd]);
@@ -241,8 +266,8 @@ int w32_shutdown(int fd, int how) {
 }
 
 
-//file io
+int 
-int w32_pipe(int *pfds){
+w32_pipe(int *pfds){
 	int read_index, write_index;
 	struct w32_io* pio[2];
 
@@ -251,7 +276,7 @@ int w32_pipe(int *pfds){
 	if (read_index == -1)
 		return -1;
 
-    //temporarily set occupied bit
+	/*temporarily set occupied bit*/
 	FD_SET(read_index, &fd_table.occupied);
 	write_index = fd_table_get_min_index();
 	FD_CLR(read_index, &fd_table.occupied);
@@ -272,7 +297,8 @@ int w32_pipe(int *pfds){
 	return 0;
 }
 
-int w32_open(const char *pathname, int flags, ...) {
+int 
+w32_open(const char *pathname, int flags, ...) {
 	int min_index = fd_table_get_min_index();
 	struct w32_io* pio;
     
@@ -290,31 +316,36 @@ int w32_open(const char *pathname, int flags, ...) {
 	return min_index;
 }
 
-int w32_read(int fd, void *dst, unsigned int max) {
+int 
+w32_read(int fd, void *dst, unsigned int max) {
 	CHECK_FD(fd);
 	if (fd_table.w32_ios[fd]->type == SOCK_FD)
 		return socketio_recv(fd_table.w32_ios[fd], dst, max, 0);
 	return fileio_read(fd_table.w32_ios[fd], dst, max);
 }
 
-int w32_write(int fd, const void *buf, unsigned int max) {
+int 
+w32_write(int fd, const void *buf, unsigned int max) {
 	CHECK_FD(fd);
 	if (fd_table.w32_ios[fd]->type == SOCK_FD)
 		return socketio_send(fd_table.w32_ios[fd], buf, max, 0);
 	return fileio_write(fd_table.w32_ios[fd], buf, max);
 }
 
-int w32_fstat(int fd, struct stat *buf) {
+int 
+w32_fstat(int fd, struct stat *buf) {
 	CHECK_FD(fd);
 	return fileio_fstat(fd_table.w32_ios[fd], buf);
 }
 
-int w32_isatty(int fd) {
+int 
+w32_isatty(int fd) {
 	CHECK_FD(fd);
 	return fileio_isatty(fd_table.w32_ios[fd]);
 }
 
-FILE* w32_fdopen(int fd, const char *mode) {
+FILE* 
+w32_fdopen(int fd, const char *mode) {
 	errno = 0;                                                              
 	if ((fd < 0) || (fd > MAX_FDS - 1) || fd_table.w32_ios[fd] == NULL) {
 		errno = EBADF;                                                     
@@ -324,9 +355,8 @@ FILE* w32_fdopen(int fd, const char *mode) {
 	return fileio_fdopen(fd_table.w32_ios[fd], mode);
 }
 
-//Common IO
+int 
-int w32_close(int fd) {
+w32_close(int fd) {
-
 	struct w32_io* pio;
 
 	CHECK_FD(fd);
@@ -334,14 +364,14 @@ int w32_close(int fd) {
     
 	debug("io:%p, type:%d, fd:%d, table_index:%d", pio, pio->type, fd, pio->table_index);
 	fd_table_clear(pio->table_index);
-    if ((pio->type == SOCK_FD)) {
+	if ((pio->type == SOCK_FD)) 
 		return socketio_close(pio);
-    }
 	else
 		return fileio_close(pio);
 }
 
-int w32_fcntl(int fd, int cmd, ... /* arg */) {
+int 
+w32_fcntl(int fd, int cmd, ... /* arg */) {
 	va_list valist;
 	va_start(valist, cmd);
 
@@ -366,13 +396,14 @@ int w32_fcntl(int fd, int cmd, ... /* arg */) {
     }
 }
 
-int w32_select(int fds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, const struct timeval *timeout) {
+int 
-    int in_set_fds = 0, out_ready_fds = 0, i;
+w32_select(int fds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, const struct timeval *timeout) {
+	ULONGLONG ticks_start = GetTickCount64(), ticks_now;
 	fd_set read_ready_fds, write_ready_fds;
 	HANDLE events[32];
 	int num_events = 0;
+	int in_set_fds = 0, out_ready_fds = 0, i;
 	unsigned int time_milliseconds = timeout->tv_sec * 100 + timeout->tv_usec / 1000;
-    ULONGLONG ticks_start = GetTickCount64(), ticks_now;
 
 	errno = 0;
 	memset(&read_ready_fds, 0, sizeof(fd_set));

contrib/win32/w32-posix-prototype/win32posix/win32posix/w32fd.h

@@ -1,3 +1,9 @@
+/*
+ * Author: Manoj Ampalam <manoj.ampalam@microsoft.com>
+ *
+ * Definitions for Win32 wrapper functions with POSIX like signatures
+*/
+
 #pragma once
 
 #include <Windows.h>
@@ -6,79 +12,81 @@
 
 enum w32_io_type {
 	UNKNOWN_FD = 0,
-    SOCK_FD = 1,
+	SOCK_FD = 1,	/*maps a socket fd*/
-    FILE_FD = 2,
+	FILE_FD = 2,	/*maps a file fd*/
-    PIPE_FD = 3,
+	PIPE_FD = 3,	/*maps a pipe fd*/
-    CONSOLE_FD = 4,
+	STD_IO_FD = 5	/*maps a std fd*/
-    STD_IO_FD = 5
 };
 
 enum w32_io_sock_state {
 	SOCK_INITIALIZED = 0,		
-    SOCK_LISTENING = 1,
+	SOCK_LISTENING = 1,	/*listen called on socket*/
-    SOCK_ACCEPTED = 2,
+	SOCK_ACCEPTED = 2,	/*socket retruned from accept()*/
-    SOCK_CONNECTING = 3,
+	SOCK_CONNECTING = 3,	/*connect called on socket, connect is in progress*/
-    SOCK_CONNECTED = 4
+	SOCK_CONNECTED = 4	/*connect completed on socket*/
 };
 
 enum w32_io_pipe_state {
-    PIPE_READ_END = 1,
+	PIPE_READ_END = 1,	/*read end of a pipe()*/
-    PIPE_WRITE_END = 2
+	PIPE_WRITE_END = 2	/*write end of a pipe()*/
 };
 
+/*
+* This sturcture encapsulates the state info needed to map a File Descriptor to Win32 Handle
+*/
 struct w32_io {
 	OVERLAPPED read_overlapped;
 	OVERLAPPED write_overlapped;
 	struct {
-        //internal buffer details
+		/*internal read buffer*/
 		char *buf;
 		DWORD buf_size;
-
+		DWORD remaining;	/*bytes in internal buffer remaining to be read by application*/
-        //async io details
+		DWORD completed;	/*bytes in internal buffer already read by application*/
-        DWORD error;  //error reported on async read completion
+		BOOL pending;		/*waiting on a read operation to complete*/
-        DWORD remaining; //bytes in internal buffer remaining to be read by application
+		DWORD error;		/*error reported on async read or accept completion*/
-        DWORD completed; //bytes in internal buffer already read by application
-        BOOL pending; //waiting on async io to complete 
 	}read_details;
 	struct {
-        //internal buffer details
+		/*internal write buffer*/
-        char* buf;
+		char *buf;
 		DWORD buf_size;
-
+		DWORD remaining;	/*bytes in internal buffer remaining to be written to network*/
-        //async io details 
+		DWORD completed;	/*bytes in internal buffer already written to network*/
-        DWORD error;   //error reported on async write completion
+		BOOL pending;		/*waiting on a write operation to complete*/
-        DWORD remaining; //bytes in internal buffer that are not yet successfully written on i/o 
+		DWORD error;		/*error reported on async write or connect completion*/
-        DWORD completed; //bytes in internal buffer that have been successfully written on i/o 
-        BOOL pending; //waiting on async io to complete 
 	}write_details;
 
-    //-1 if not indexed
+	int table_index;		/*index at which this object is stored in fd_table*/
-    int table_index;
+	enum w32_io_type type;		/*hanldle type*/
-	//handle type
+	DWORD fd_flags;			/*fd flags from POSIX*/
-	enum w32_io_type type;
+	DWORD fd_status_flags;		/*fd status flags from POSIX*/
-	DWORD fd_flags;
-    DWORD fd_status_flags;
 	
-	//underlying w32 handle
+	/*underlying w32 handle*/
 	union {
 		SOCKET sock;
 		HANDLE handle;
 	};
 
-	//handle specific internal state context, currently used by sockets
+	/*handle specific internal state context, used by sockets and pipes*/
 	struct {
 		enum w32_io_sock_state state;
 		void* context;
 	}internal;
 };
 
+/* Check if the corresponding fd is set blocking */
 BOOL w32_io_is_blocking(struct w32_io*);
+/* 
+ * Check if io is ready/available. This function is primarily used by select() as it decides on what fds can be set.
+ */
 BOOL w32_io_is_io_available(struct w32_io* pio, BOOL rd);
 
-//signal
+/*
+ * Main wait routine used by all blocking calls. It wakes up on IO completions, timers, timeouts and signals.
+ */
 int wait_for_any_event(HANDLE* events, int num_events, DWORD milli_seconds);
 
-//socket io
+/*POSIX mimic'ing socket API*/
 int socketio_initialize();
 int socketio_done();
 BOOL socketio_is_io_available(struct w32_io* pio, BOOL rd);
@@ -98,7 +106,7 @@ int socketio_shutdown(struct w32_io* pio, int how);
 int socketio_close(struct w32_io* pio);
 
 
-//fileio
+/*POSIX mimic'ing file API*/
 BOOL fileio_is_io_available(struct w32_io* pio, BOOL rd);
 int fileio_on_select(struct w32_io* pio, BOOL rd);
 int fileio_close(struct w32_io* pio);