git.gag.com Git - fw/stlink/blob - mingw/mingw.c

   1 #ifdef __MINGW32__
   2
   3 #include "mingw.h"
   4
   5 #undef socket
   6 #undef connect
   7 #undef accept
   8 #undef shutdown
   9
  10 #include <string.h>
  11 #include <errno.h>
  12 #include <assert.h>
  13
  14 int win32_poll(struct pollfd *fds, unsigned int nfds, int timo)
  15 {
  16     struct timeval timeout, *toptr;
  17     fd_set ifds, ofds, efds, *ip, *op;
  18     unsigned int i, rc;
  19
  20     /* Set up the file-descriptor sets in ifds, ofds and efds. */
  21     FD_ZERO(&ifds);
  22     FD_ZERO(&ofds);
  23     FD_ZERO(&efds);
  24     for (i = 0, op = ip = 0; i < nfds; ++i) {
  25         fds[i].revents = 0;
  26         if(fds[i].events & (POLLIN|POLLPRI)) {
  27             ip = &ifds;
  28             FD_SET(fds[i].fd, ip);
  29         }
  30         if(fds[i].events & POLLOUT) {
  31             op = &ofds;
  32             FD_SET(fds[i].fd, op);
  33         }
  34         FD_SET(fds[i].fd, &efds);
  35     }
  36
  37     /* Set up the timeval structure for the timeout parameter */
  38     if(timo < 0) {
  39         toptr = 0;
  40     } else {
  41         toptr = &timeout;
  42         timeout.tv_sec = timo / 1000;
  43         timeout.tv_usec = (timo - timeout.tv_sec * 1000) * 1000;
  44     }
  45
  46 #ifdef DEBUG_POLL
  47     printf("Entering select() sec=%ld usec=%ld ip=%lx op=%lx\n",
  48             (long)timeout.tv_sec, (long)timeout.tv_usec, (long)ip, (long)op);
  49 #endif
  50     rc = select(0, ip, op, &efds, toptr);
  51 #ifdef DEBUG_POLL
  52     printf("Exiting select rc=%d\n", rc);
  53 #endif
  54
  55     if(rc <= 0)
  56         return rc;
  57
  58     if(rc > 0) {
  59         for ( i = 0; i < nfds; ++i) {
  60             int fd = fds[i].fd;
  61             if(fds[i].events & (POLLIN|POLLPRI) && FD_ISSET(fd, &ifds))
  62                 fds[i].revents |= POLLIN;
  63             if(fds[i].events & POLLOUT && FD_ISSET(fd, &ofds))
  64                 fds[i].revents |= POLLOUT;
  65             if(FD_ISSET(fd, &efds))
  66                 /* Some error was detected ... should be some way to know. */
  67                 fds[i].revents |= POLLHUP;
  68 #ifdef DEBUG_POLL
  69             printf("%d %d %d revent = %x\n",
  70                     FD_ISSET(fd, &ifds), FD_ISSET(fd, &ofds), FD_ISSET(fd, &efds),
  71                     fds[i].revents
  72                   );
  73 #endif
  74         }
  75     }
  76     return rc;
  77 }
  78 static void
  79 set_connect_errno(int winsock_err)
  80 {
  81     switch(winsock_err) {
  82     case WSAEINVAL:
  83     case WSAEALREADY:
  84     case WSAEWOULDBLOCK:
  85         errno = EINPROGRESS;
  86         break;
  87     default:
  88         errno = winsock_err;
  89         break;
  90     }
  91 }
  92
  93 static void
  94 set_socket_errno(int winsock_err)
  95 {
  96     switch(winsock_err) {
  97     case WSAEWOULDBLOCK:
  98         errno = EAGAIN;
  99         break;
 100     default:
 101         errno = winsock_err;
 102         break;
 103     }
 104 }
 105 /*
 106  * A wrapper around the socket() function. The purpose of this wrapper
 107  * is to ensure that the global errno symbol is set if an error occurs,
 108  * even if we are using winsock.
 109  */
 110 SOCKET
 111 win32_socket(int domain, int type, int protocol)
 112 {
 113     SOCKET fd = socket(domain, type, protocol);
 114     if(fd == INVALID_SOCKET) {
 115         set_socket_errno(WSAGetLastError());
 116     }
 117     return fd;
 118 }
 119 /*
 120  * A wrapper around the connect() function. The purpose of this wrapper
 121  * is to ensure that the global errno symbol is set if an error occurs,
 122  * even if we are using winsock.
 123  */
 124 int
 125 win32_connect(SOCKET fd, struct sockaddr *addr, socklen_t addr_len)
 126 {
 127     int rc = connect(fd, addr, addr_len);
 128     assert(rc == 0 || rc == SOCKET_ERROR);
 129     if(rc == SOCKET_ERROR) {
 130         set_connect_errno(WSAGetLastError());
 131     }
 132     return rc;
 133 }
 134
 135 /*
 136  * A wrapper around the accept() function. The purpose of this wrapper
 137  * is to ensure that the global errno symbol is set if an error occurs,
 138  * even if we are using winsock.
 139  */
 140 SOCKET
 141 win32_accept(SOCKET fd, struct sockaddr *addr, socklen_t *addr_len)
 142 {
 143     SOCKET newfd = accept(fd, addr, addr_len);
 144     if(newfd == INVALID_SOCKET) {
 145         set_socket_errno(WSAGetLastError());
 146         newfd = -1;
 147     }
 148     return newfd;
 149 }
 150
 151 /*
 152  * A wrapper around the shutdown() function. The purpose of this wrapper
 153  * is to ensure that the global errno symbol is set if an error occurs,
 154  * even if we are using winsock.
 155  */
 156 int
 157 win32_shutdown(SOCKET fd, int mode)
 158 {
 159     int rc = shutdown(fd, mode);
 160     assert(rc == 0 || rc == SOCKET_ERROR);
 161     if(rc == SOCKET_ERROR) {
 162         set_socket_errno(WSAGetLastError());
 163     }
 164     return rc;
 165 }
 166
 167 int win32_close_socket(SOCKET fd)
 168 {
 169     int rc = closesocket(fd);
 170     if(rc == SOCKET_ERROR) {
 171         set_socket_errno(WSAGetLastError());
 172     }
 173     return rc;
 174 }
 175
 176 ssize_t win32_write_socket(SOCKET fd, void *buf, int n)
 177 {
 178     int rc = send(fd, buf, n, 0);
 179     if(rc == SOCKET_ERROR) {
 180         set_socket_errno(WSAGetLastError());
 181     }
 182     return rc;
 183 }
 184
 185 ssize_t win32_read_socket(SOCKET fd, void *buf, int n)
 186 {
 187     int rc = recv(fd, buf, n, 0);
 188     if(rc == SOCKET_ERROR) {
 189         set_socket_errno(WSAGetLastError());
 190     }
 191     return rc;
 192 }
 193
 194
 195 char * win32_strtok_r(char *s, const char *delim, char **lasts)
 196 {
 197     register char *spanp;
 198     register int c, sc;
 199     char *tok;
 200
 201
 202     if (s == NULL && (s = *lasts) == NULL)
 203         return (NULL);
 204
 205     /*
 206      * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
 207      */
 208 cont:
 209     c = *s++;
 210     for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
 211         if (c == sc)
 212             goto cont;
 213     }
 214
 215     if (c == 0) {               /* no non-delimiter characters */
 216         *lasts = NULL;
 217         return (NULL);
 218     }
 219     tok = s - 1;
 220
 221     /*
 222      * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
 223      * Note that delim must have one NUL; we stop if we see that, too.
 224      */
 225     for (;;) {
 226         c = *s++;
 227         spanp = (char *)delim;
 228         do {
 229             if ((sc = *spanp++) == c) {
 230                 if (c == 0)
 231                     s = NULL;
 232                 else
 233                     s[-1] = 0;
 234                 *lasts = s;
 235                 return (tok);
 236             }
 237         } while (sc != 0);
 238     }
 239     /* NOTREACHED */
 240 }
 241
 242 char *win32_strsep (char **stringp, const char *delim)
 243 {
 244     register char *s;
 245     register const char *spanp;
 246     register int c, sc;
 247     char *tok;
 248
 249     if ((s = *stringp) == NULL)
 250         return (NULL);
 251     for (tok = s;;) {
 252         c = *s++;
 253         spanp = delim;
 254         do {
 255             if ((sc = *spanp++) == c) {
 256                 if (c == 0)
 257                     s = NULL;
 258                 else
 259                     s[-1] = 0;
 260                 *stringp = s;
 261                 return (tok);
 262             }
 263         } while (sc != 0);
 264     }
 265     /* NOTREACHED */
 266 }
 267
 268 #endif
 269
 270