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 int win32_close_socket(SOCKET fd) {
 167     int rc;
 168
 169     rc = closesocket(fd);
 170     return rc;
 171 }
 172
 173
 174 ssize_t win32_write_socket(SOCKET fd, void *buf, int n)
 175 {
 176     int rc = send(fd, buf, n, 0);
 177     if(rc == SOCKET_ERROR) {
 178         set_socket_errno(WSAGetLastError());
 179     }
 180     return rc;
 181 }
 182
 183 ssize_t win32_read_socket(SOCKET fd, void *buf, int n)
 184 {
 185     int rc = recv(fd, buf, n, 0);
 186     if(rc == SOCKET_ERROR) {
 187         set_socket_errno(WSAGetLastError());
 188     }
 189     return rc;
 190 }
 191
 192
 193 char * win32_strtok_r(char *s, const char *delim, char **lasts)
 194 {
 195         register char *spanp;
 196         register int c, sc;
 197         char *tok;
 198
 199
 200         if (s == NULL && (s = *lasts) == NULL)
 201                 return (NULL);
 202
 203         /*
 204          * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
 205          */
 206 cont:
 207         c = *s++;
 208         for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
 209                 if (c == sc)
 210                         goto cont;
 211         }
 212
 213         if (c == 0) {           /* no non-delimiter characters */
 214                 *lasts = NULL;
 215                 return (NULL);
 216         }
 217         tok = s - 1;
 218
 219         /*
 220          * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
 221          * Note that delim must have one NUL; we stop if we see that, too.
 222          */
 223         for (;;) {
 224                 c = *s++;
 225                 spanp = (char *)delim;
 226                 do {
 227                         if ((sc = *spanp++) == c) {
 228                                 if (c == 0)
 229                                         s = NULL;
 230                                 else
 231                                         s[-1] = 0;
 232                                 *lasts = s;
 233                                 return (tok);
 234                         }
 235                 } while (sc != 0);
 236         }
 237         /* NOTREACHED */
 238 }
 239
 240 char *win32_strsep (char **stringp, const char *delim)
 241 {
 242         register char *s;
 243         register const char *spanp;
 244         register int c, sc;
 245         char *tok;
 246
 247         if ((s = *stringp) == NULL)
 248                 return (NULL);
 249         for (tok = s;;) {
 250                 c = *s++;
 251                 spanp = delim;
 252                 do {
 253                         if ((sc = *spanp++) == c) {
 254                                 if (c == 0)
 255                                         s = NULL;
 256                                 else
 257                                         s[-1] = 0;
 258                                 *stringp = s;
 259                                 return (tok);
 260                         }
 261                 } while (sc != 0);
 262         }
 263         /* NOTREACHED */
 264 }
 265
 266 #endif
 267
 268